关键词搜索

源码搜索 ×
×

Python基础教程：7个经典基础案例

发布2021-08-31浏览1101次

详情内容

1.列表排序

  1. def que6():
  2.     # 6.输入三个整数x, y, z，形成一个列表，请把这n个数由小到大输出。
  3.     # 程序分析：列表有sort方法，所以把他们组成列表即可。
  4.     li = np.random.randint(-100, 100, size=10)
  5.     # 就地转化
  6.     li = li.tolist()
  7.     # 用sort()结果
  8.     li_sort = sorted(li, reverse = False)
  9.     print('用sort方法，重新排列结果：{}'.format(li_sort))
  10.  
  11.     # 不用sort方法，自己写排序方法做，
  12.  
  13.     # 冒泡排序
  14.     def bubbleSort(m):
  15.         m = m.copy()
  16.         for time in range(1, len(m)):
  17.             for index in range(len(m) - time):
  18.                 if m[index] > m[index+1]:
  19.                     m[index], m[index+1] = m[index+1] , m[index]
  20.         return  m
  21.  
  22.     # 选择排序
  23.     def selectSort(m):
  24.         m = m.copy()
  25.         for seat_L in range(len(m)-1):
  26.             for seat_R in range(seat_L+1, len(m)):
  27.                 if m[seat_L] > m[seat_R]:
  28.                     m[seat_L], m[seat_R] = m[seat_R], m[seat_L]
  29.         return m
  30.  
  31.     # 插入排序1（内部写成函数）：
  32.     def insertSort_1(m):
  33.         result = []
  34.  
  35.         # 单个元素k插入列表li
  36.         def to_insert(li, k):
  37.             # 标识符
  38.             tab = False
  39.  
  40.             # 寻找插入位置
  41.             # 循环次数应该至少大于列表长度+1，None也占一位（空列表），即认为扑克牌最末尾还有一张‘空牌’
  42.             for i in range(len(li) + 1):
  43.                 # 修改标识符，标志‘遍历完后的下一个循环’，即在和‘空牌’比较
  44.                 if i == (len(li)):
  45.                     tab = True
  46.  
  47.                 # 如果在对li[-1]比较完成（包含）之前，且寻找到位置，即把扑克从左往右比较一遍
  48.                 if not tab and k < li[i]:
  49.                     li.insert(i, k)
  50.                     break
  51.             # 如果遍历完成，多循环一次，即和‘空牌’不需要比较，直接把牌替换掉‘空牌’
  52.             if tab:
  53.                 li.append(k)
  54.             return li
  55.         # 遍历列表
  56.         # result = result[:1]
  57.         for length in range(len(m)):
  58.             result = to_insert(result, m[length])
  59.  
  60.             # print(result,m[length])
  61.         return result
  62.  
  63.     # 插入排序2(直接嵌套循环)：
  64.     def insertSort2(m):
  65.         m = m.copy()
  66.         result = m[:1]
  67.         for index_choose in range(1, len(m)):
  68.             # 手上已经有index_choose张牌，比较第index_choose+1张牌则append
  69.             # 逐个比对手上的牌，如果都对比了一遍，则加到最后
  70.             for index_insert in range(len(result) + 1):
  71.                 print(result, index_insert,'\n',m, index_choose,'\n\n')
  72.                 if index_insert != index_choose and m[index_choose] < result[index_insert] :
  73.                     result.insert(index_insert, m[index_choose])
  74.                     break
  75.                 if index_insert == index_choose:
  76.                     result.append(m[index_choose])
  77.             # print(result, m[index_choose])
  78.         return result
  79.  
  80.  
  81.  
  82.     # print(li)
  83.     print('插入排序：',insertSort3(li))
  84.     print('选择排序：',selectSort(li))
  85.     print('冒泡排序：',bubbleSort(li))
  86. que6()

2.调换字python教程典键值

  1. # 1. 调换元素.\
  2. def que1():
  3.     d={1:"one",2:"two"}
  4.  
  5.     # 方法1 --- 动态赋值
  6.     def method1(d):
  7.         d = d.copy()
  8.         result = {}
  9.         for k,v in d.items():
  10.             result[v] = k
  11.         return result
  12.  
  13.     # 方法2 --- 生成器
  14.     def method2(d):
  15.         d = d.copy()
  16.         result = {v:k for k,v in d.items()}
  17.         return result
  18.  
  19.     # 方法3 --- 由值寻找键
  20.     def method3(d):
  21.         d = d.copy()
  22.         # 由键寻找值
  23.         def match(dic, b):
  24.             return [k for k,v in dic.items() if v == b]
  25.         # 先生成key-None,再赋值
  26.         result = {}
  27.         result = result.fromkeys(d.values())
  28.         for k in result.keys():
  29.             result[k] = match(d, k)[0]
  30.         return result
  31.  
  32.     # 方法4 --- 列表转字典 < 直接转换/动态赋值 >
  33.     def method4(d):
  34.         d = d.copy()
  35.         key = d.keys()
  36.         val = d.values()
  37.         data = list(zip(key, val))
  38.  
  39.         # 方法4-1
  40.         result1 = {}
  41.         for i in range(len(data)):
  42.             result1[data[i][1]] = data[i][0]
  43.  
  44.         # 方法4-2
  45.         result2 = dict(zip(val, key))
  46.  
  47.         return result1, result2
  48.  
  49.     print('新列表动态赋值方法：{}'.format(method1(d)))
  50.     print('生成器方法：{}'.format(method2(d)))
  51.     print('由键寻值方法：{}'.format(method3(d)))
  52.     print('动态赋值列表转字典方法：{}'.format(method4(d)[0]))
  53.     print('直接列表转字典方法：{}'.format(method4(d)[1]))
  54. # que1()

3.删除列表中的重复元素

  1. #遇到问题没人解答？小编创建了一个Python学习交流群：531509025
  2. #寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
  3.  
  4. # 3. 删除重复元素list =[1,2,5,4,1,5,6,8,0,2,5]
  5. a = np.random.randint(-100, 100, size=10)
  6. a = a.tolist()
  7.  
  8. def method1(a):
  9.     a = a.copy()
  10.     a = set(a)
  11.     return a
  12. def method2(a):
  13.     b = a.copy()
  14.     c = 0
  15.     for i in range(len(a)-1):
  16.         if b[i+c] in b[:i+c]+b[i+c+1:]:
  17.             b.pop(i+c)
  18.             c -= 1
  19.     return b
  20. print('集合法：',method1(a))
  21. print('遍历法：',method2(a))

4.输出质数

  1. def prime(end):
  2.  
  3.     prime_list = []
  4.     if end <= 1:
  5.         print('必须大于1')
  6.     else:
  7.         # prime_list.append(2)
  8.         for i in range(2, end+1, 1):
  9.             count = 0
  10.             if i == 2:
  11.                 if i%2 != 0:
  12.                     prime_list.append(2)
  13.             else:
  14.                 for m in range(2, i):
  15.                     # 能够整除，则跳出循环
  16.                     if (i % m) == 0:
  17.                         # print(i, m)
  18.                         break
  19.                     # 否则计数+1
  20.                     else:
  21.                         count += 1
  22.                     # 判断是否整除完成(0/n)
  23.                     if count == i - 2:
  24.                         prime_list.append(i)
  25.  
  26.                     print(count, i, m)
  27.  
  28.     return (prime_list)
  29.  
  30. num = int(input('想输出2到多少？'))
  31. print(prime(num))

5.判断是一年中第几天

  1. def que3():
  2.     # 3.输入某年某月某日，判断这一天是这一年的第几天？：
  3.     # 闰年判断函数
  4.     def judge_leap(num):
  5.         date = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
  6.         # (四年一闰 and not百年) or 四百年闰
  7.         if (num % 4 == 0 and num % 100 != 0) or num % 400 ==0:
  8.             date[1] =29
  9.         return date
  10.  
  11.     # 格式转换
  12.     date = (input('请输入一个日期，格式如：“2018.02.12”：'))
  13.     date_list = (list(map(int, (date.split('.')))))
  14.     # 遍历计算天数
  15.     day = date_list[2]
  16.     for i in range(date_list[1]):
  17.         day += judge_leap(date_list[0])[i]
  18.     print('{}月{}日是{}年的第{}天\n'.format(date_list[1], date_list[2], date_list[0], day))
  19. # que3()

6.猜数字

  1. # 重新猜数字
  2. import random
  3.  
  4. def judge_num(num, num_random):
  5.     if num > num_random:
  6.         print('It\'s too big')
  7.         return 1
  8.     elif num < num_random:
  9.         print('It\'s too small')
  10.         return 1
  11.     else:
  12.         print("Congratulation!! That\' right!")
  13.         return 0
  14.  
  15. # 产生随机数
  16. num_start = int(input('Digital lower limit of guess number:\n'))
  17. num_end = int(input('Digital upper limit of guess number:\n'))
  18. num_random = random.randint(num_start, num_end)
  19.  
  20. # 参数初始化
  21. result = 1      # 判断结果
  22. i = 0           # 循环次数
  23. frequency = 3   # 循环限制次数
  24.  
  25. # 提示总猜测次数、剩余次数
  26. print('WARNING: You have【{}】 chances you guess '.format(frequency), end = '--&&>>--')
  27. print('【{}】 chances left now:\n'.format(frequency - i +1))
  28.  
  29. while result and i != frequency:
  30.     # 猜数字
  31.     num = int(input('Please guess a int_number:\n'))
  32.     result = judge_num(num, num_random)
  33.     i += 1

7.进制转换

  1. # 任意进制转十进制
  2. def other_to_decimal(hex, num):
  3.     # 整型转化为列表，
  4.     num_str = str(num)
  5.     # map（）将List对象中的元素（list类型）转化为集合（set）类型
  6.     num_list = list(map(int, num_str))
  7.     # 列表反序
  8.     num_list = num_list[::-1]
  9.     print(list(map(int, num_str)))
  10.  
  11.     # 获取数字位数
  12.     digit = len(num_list)
  13.     num_decimal = 0
  14.  
  15.     # 累加
  16.     for i in range(digit):
  17.         numi = num_list[i]
  18.         # print(numi, hex**i)
  19.         num_decimal += numi*(hex**i)   # 对每一位数的幂指数累加
  20.  
  21.     return num_decimal
  22.  
  23. # 十进制转任意进制
  24. def decimal_to_other(hex, num):
  25.     # 获取数字位数
  26.     digit = len(str(num))
  27.  
  28.     num_hex = []
  29.     quotient = 1
  30.  
  31.     # 相除，余数计入列表num_hex
  32.     while quotient:
  33.         # 取余和取商
  34.         quotient = num // hex
  35.         remainder = num % hex
  36.         # print(quotient, remainder)
  37.         # 余数计入列表
  38.         num_hex.append(remainder)
  39.         # 商做下一次循环
  40.         num = quotient
  41.  
  42.     # 列表反序,通过切片和sort()函数可以实现
  43.     num_hex = num_hex[::-1]
  44.     # num_hex.sort(reverse=True)
  45.  
  46.     # 如果超过十进制，用ASCII码转化为字母
  47.     for i in range(len(num_hex)):
  48.         if num_hex[i] > 9:
  49.             num_hex[i] = chr(int(num_hex[i])+87)
  50.     # print(num_hex)
  51.  
  52.     # 列表转化为字符串
  53.     result = (''.join('%s' %m for m in num_hex))
  54.     return result
  55.  
  56.  
  57. Type = bool(input("十进制转任意进制请输入1，任意进制转十进制请输入0\n"))
  58. if Type:
  59.     hex = int(input("需要把十进制转换为多少进制？请输入正整数\n"))
  60.     num = int(input("需要转换的数字是:"))
  61.     print("换算结果是：", decimal_to_other(hex, num))
  62. else:
  63.     hex = int(input("需要把多少进制转换为十进制？请输入正整数\n年"))
  64.     num = int(input("需要转换的数字是:"))
  65.     print("换算结果是：", other_to_decimal(hex, num))

相关技术文章

最新源码

下载排行榜
点击QQ咨询
开通会员
返回顶部
×
微信扫码支付 元
微信扫码支付
确定支付下载
请使用微信描二维码支付
×

提示信息

×

选择支付方式

  • 微信支付
  • 支付宝付款
确定支付下载