Python初级学习20230901
运算符--->优先级和结合性
左结合：从左往右进行计算（大部分运算符）
右结合：从右往左进行计算（赋值运算符，正负号，索引和切片）
assert断言语句
a = 1
assert a == 1 # 后面可以不加
assert a == 1, '这里写的是如果出错时的提示语句，AssertionError:内容'
容器型数据类型
容器型：用一个变量可以保存多个数据（命名的时候，推荐复数形式）
- 列表（list）
- 元组（tuple)
- 集合（set）
- 字典（dict）
列表list
len(list)求长度，和c#的list.lenth差不多，就是一个是函数形式，注意别混。
# 列表list,元组tuple,集合set,字典dict
# 创建列表的字面量语法
# python中的列表各种数据类型都可以放进去，但使用的时候最好同类型。
nums = [1, 2, 3, 4] # 命名的时候，推荐复数形式。可以折行
nums.insert(2, '插index2的位置') # 插入元素（在指定位置加入元素），序列从前往后以0开始。
print(nums)
assert nums == [1, 2, '插index2的位置', 3, 4], True # assert断言语句，直接在这里放结果显示
nums.pop(2) # 删除index2的元素
nums.pop() # 默认删除最后一个元素
assert nums == [1, 2, 3]
nums[2] = '最后' # 列表的下标（索引）
print(nums)
assert nums == [1, 2, '最后']
assert nums[-1] == '最后' # nums[-n]是从后往前，第一个是-1
# 对列表进行读写操作的for循环
for i in range(len(nums)): # 循环取值,len函数求列表个数
print(nums[i])
nums[i] = 100
print(nums)
assert nums == [100, 100, 100]
print('-' * 20) # 字符串的重复运算，不需要自己一直打
nums = [1, 2, '最后']
# 对列表只进行读操作的for循环
for num in nums: # 直接将i代言nums中的数据
print(num)
num = 100
print(nums)
assert nums == [1, 2, '最后']
# 先通过enumerate函数对列表进行预处理
# 循环便利的时候可以获取到索引和元素
for i, num in enumerate(nums):
print(i, num)
example：
# 1.将一个骰子掷60000次，统计每一面出现的次数
counts = [0, 0, 0, 0, 0, 0]
counts = [0] * 6 # 列表的重复运算
for _ in range(60000):
count = random.randrange(1, 7)
counts[count - 1] += 1
for i, count in enumerate(counts):
print(f'骰子点数{i+1}的次数为{count}')
# 2.输入10个整数，计算平均值，方差和标准差，找出最大值和最小值
nums = []
# for _ in range(10):
# nums.append(int(input('请输入数值：')))
nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] # 正常要输入，这里省事不输了
# 求和直接使用sum函数，最大最小值也有函数
average_value = sum(nums) / len(nums)
max_value = max(nums)
min_value = min(nums)
variance_value = 0 # 方差variance=>var
for num in nums:
variance_value += (num - average_value) ** 2
variance_value = variance_value / (len(nums) - 1)
standard_deviation_value = variance_value ** 0.5 # 平方差standard deviation=》std/stdev
print(f'最大值{max_value},最小值{min_value},平均数{average_value},'
f'标准差{standard_deviation_value:.2f},'
f'方差{variance_value:.2f},极差（全距）{max_value - min_value}')
# 列表中添加10个随机整数，找出第2大的元素
print('*' * 20, 'example2', '*' * 20)
nums = []
for _ in range(10):
nums.append(random.randrange(1,1000))
# 列表的生成式（推导式）
nums = [random.randrange(1,1000) for _ in range(10)]
nums_temp = nums[:] # nums_temp = nums的话，是将引用分享给了nums_temp，而[:]则是重新创建了一个新的元素和nums相同的列表
nums_temp.remove(max(nums_temp)) # 这种方式只是取巧，并不合适
print(nums)
print(nums_temp)
print(f'列表中第二大的值{max(nums_temp)}')
max_value = nums[0]
max2_value = nums[1]
if max_value < max2_value:
max_value, max2_value = max2_value, max_value
for i in range(2, len(nums)): # 最大值和第二大值可以一样
if max_value < nums[i]:
max_value, max2_value = nums[i], max_value
elif max2_value < nums[i]:
max2_value = nums[i]
print(f'列表中第二大的值{max2_value}')
列表的创建
方式一：字面量语法
list1 = ['apple', 'this', 'hello']
print(list1)
方式二：构造器语法
list2 = list(range(1, 10))
print(list2)
list3 = list(list1) # 构造了一个新的列表
print(list3)
list4 = list(value ** 2 for value in range(1, 10, 3))
print(list4)
list4 = list('abcd')
print(list4)
方式三：生成式（推导式）语法
list5 = [i * 5 for i in range(1, 10)]
print(list5)
list6 = [random.randrange(1,1000) for _ in range(10)]
print(list6)
列表的运算
list1 = [1, 2,3] * 5 # 重复运算
print(list1)
# 成员运算
print(2 in list1) # True
print(3 not in list1) # False
print('abc' in list1) # False
索引和切片
# 正向索引：0 - N-1 负向索引：-N - -1
print('*' * 20, '索引切片', '*' * 20)
list1 = ['happy', 'home', 'start', 'end']
# 切片会创造一个新的列表，如果想列表直接改变，那么list1 = list1[::-1]
print(list1[1:]) # 输出索引从1开始的所有数据['home', 'start', 'end']
print(list1[:-2]) # 输出索引0 - -2的所有数据，不包括索引-2（表示倒数第二个）['happy', 'home']
print(list1[1:3]) # 输出索引1-3的所有数据，不包括3['home', 'start']
print(list1[1::2]) # 从索引1开始，每隔一个数提取['home', 'end']
print(list1[::-1]) # 从末尾往前，负的，是从后往前切['end', 'start', 'home', 'happy']
print(list1[::-2]) # ['end', 'home']
反转和排序，sort(key=int)
# 反转和排序
print('*' * 20, '反转和排序', '*' * 20)
list1.reverse()
print(list1)
list1.sort(reverse=True) # 可以通过reverse参数控制升序或者降排序，True的话是从大到小，默认是从小到大
print(list1)
# sort函数有key的参数可以按照int整式方式排序
list1 = ['1', '4', '64', '34']
list1.sort(key=int)
print(list1)
合并
list1 = [1, 4, 6]
list2 = [7, 8, 9]
list3 = list1 + list2 # [1, 4, 6, 7, 8, 9]
print(list3)
list1 += list2
print(list1) # [1, 4, 6, 7, 8, 9]
list1.extend(list2)
比较
list1 = [1, 2, 3, 4]
list2 = [1, 2, 3, 4]
list3 = [2, 4, 3, 1]
print(list1 == list2) # True
print(list1 == list3) # False
print(list1 > list3) # False 从第一个开始比，第一个小就小
list4 = [0, 5, 6, 7]
print(list1 > list4) # True 从第一个开始比，第一个大就大
list5 = ['abc', 'hello', 'say']
# print(list4 > list5) # 会报错TypeError: '>' not supported between instances of 'int' and 'str'
list6 = ['ab', 1, 2, ]
print(list5 > list6) # True第一个字符串就已经判断了，所以即使后面是数字也不影响
查找、删除、清空内容
# 查找、删除、清空内容
list1 = ['one', 'two', 'three', 'four', 'one']
# print(list1.index('?')) # 找不到会报错ValueError: '?' is not in list
# 所以需要先判断是否在列表中
if '?' in list1:
print(list1.index('?'))
else:
print('不在列表中')
print(list1.index('one', 3)) # 从索引3开始找
print(list1.count('on')) # 计数，如果不存在，会输出0
temp = list1.pop() # 有返回值
del list1[0] # 删除引用，没有返回
print(list1)
while 'two' in list1:
list1.remove('two')
list1.clear()
ord()获取字符的编码
print(ord('b')) # 获取字符的编码为98
chr()根据字符的编码获取对应的值
for i in range(0x4e00, 0x9fa6): # 汉字的编码范围0x4e00 ~ 0x9fa6
print(chr(i), end='')
排序算法
对于算法也需要优化
list1 = [15, 58, 47, 85, 69, 44, 55, 63]
list2 = list1
list2.sort()
print(list2)
# 简单排序方法
for i in range(0, len(list1) - 1):
for j in range(i + 1, len(list1)):
if list1[i] > list1[j]:
list1[i], list1[j] = list1[j], list1[i]
print(list1)
# 冒泡排序：元素两两比较，如果前面的元素大于后面的元素，就交换两个元素的位置
# [15, 58, 47, 85, 69, 44, 55, 63]
# [15, 58, 47, 85, 69, 44, 55, 63] 两两比较15和58并不交换
# [15, 47, 58, 85, 69, 44, 55, 63]
# [15, 47, 58, 85, 69, 44, 55, 63]
# [15, 47, 58, 69, 85, 44, 55, 63]
# [15, 47, 58, 69, 44, 85, 55, 63]
# [15, 47, 58, 69, 44, 55, 85, 63]
# [15, 47, 58, 69, 44, 55, 63, 85]一轮最大的就会到最后
# 还有一种情况[2, 3, 4, 5, 6, 7, 8, 1]
# 搅拌排序（鸡尾酒排序）
list1 = [15, 58, 47, 85, 69, 44, 55, 63]
# list1 = [8, 1, 2, 3, 4, 5, 6, 7]
list1 = [2, 3, 4, 5, 6, 7, 8, 1]
for i in range(len(list1)-1):
# 但是冒泡法碰到[8, 1, 2, 3, 4, 5, 6, 7]，第一轮就已经排好序了，之后就不会再调序了
# 所以当排序没有发生交换的时候，表明就已经从小到大了，直接终止
is_swapped = False
for j in range(len(list1) - i - 1):
if list1[j] > list1[j+1]:
list1[j], list1[j + 1] = list1[j + 1], list1[j]
is_swapped = True
if not is_swapped:
break
# 还有一种情况[2, 3, 4, 5, 6, 7, 8, 1]
# 搅拌排序（鸡尾酒排序），倒着将小的数往前冒
for j in range(len(list1) - i - 1):
if list1[-1 - j] < list1[-2 - j]:
list1[-1 - j], list1[-2 - j] = list1[-2 - j], list1[-1 - j]
is_swapped = True
if not is_swapped:
break
print(list1)
抽样
print('*' * 20, '抽样', '*' * 20)
# *******抽样*******
# sample函数可以对列表元素进行无放回抽样
print(random.sample(list1, k=2)) # k=2表示取几个
# choices函数可以对列表元素进行有放回抽样（可以重复抽中）
print(random.choices(list1, k=5)) # k=5表示取几个
# choice函数可以从列表中随机选择一个元素
print(random.choice(list1))
# 会将列表打乱顺序
random.shuffle(list1)
example
幸运的女人（Josephu环）
print('*' * 20, 'example', '*' * 20)
"""
题目：幸运的女人（Josephu环）
有15个男人和15个女人坐船出海，船坏了，需要把其中15个人扔到海里，其他人才能活下来；
所有人围城一圈，由某个人从1开始一次报数，报到9的人被扔到海里，下一个人重新从1开始报数，
直到将15个人扔到海里。最后15个女人都幸存了下来，15个男人都被扔到了海里。
问原先哪些位置是男人，哪些位置是女人。
第一次编辑的时候，将列表中投海的数据删除，导致代码出现问题，在循环中，设置的参数如果动态的话，代码不是像想象中的运行
"""
list1 = [True] * 30
index, counter, number = 0, 0, 0
while counter < 15:
for i in range(0, len(list1)):
if list1[i]:
number += 1
if number == 9:
list1[i] = False
number = 0
counter += 1
for i in range(0, len(list1), 6):
print(list1[i: i + 6])
# print('女' if i in list1 else '男', end = '')
# 第二种做法：将第九位除去，从第十位作为开头继续数
list1 = [i for i in range(1, 31)]
for _ in range(15):
list1 = list1[9:] + list1[:8]
print(list1)
嵌套列表
-
列表的生成式（推导式）
-
""" 用一个列表保存54张扑克牌， 先洗牌，再按斗地主的发牌方式把牌发给三个玩家， 多的3张牌给第一个玩家（地主）， 最后把每个玩家手上的牌显示出来。 """ cards = [] # 卡片 suites = ['黑桃', '红心', '草花', '方块'] # 花色 points = ['A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K'] # 点数 cards = [f'{suite}{point}' for suite in suites for point in points] # cards += ['大王', '小王'] cards.append('大王') cards.append('小王') print(cards) random.shuffle(cards) # 洗牌 -
嵌套列表（列表中的元素又是列表）
-
# 嵌套列表 players = [[] for _ in range(3)] # [[] * 3]这个结果是[[]]所以对于列表重复运算是有问题的 print('输出players=', players) for _ in range(17): for player in players: player.append(cards.pop()) # pop会返回删除的值的。效率上讲，对最后一个数进行处理效率更高 players[0].extend(cards) for player in players: player.sort(key=lambda x: x[2:]) # 差不多意思就是先比前面的，再比索引2后面的？ print(player)
example
# 保存5个学生，3门课程的成绩
names = ['张三', '李四', '赵五', '孙六', '钱七']
courses = ['语文', '数学', '英语']
# scores = [
# [90, 56, 89],
# [20, 34, 54],
# [54, 43, 99],
# [78, 34, 84],
# [34, 59, 93]
# ]
scores = [[random.randrange(0, 100) for _ in range(3)] for _ in range(5)]
print(scores)
for i in range(len(names)):
for j, course in enumerate(courses):
print(f'{names[i]}的{course}成绩是{scores[i][j]}')
# 学生的平均成绩
print(f'{names[i]}的平均成绩为{sum(scores[i]) / len(scores[i]):.3f}')
# 求每门课的最高分和最低分
for i, course in enumerate(courses):
temp = [scores[j][i] for j in range(len(names))]
print(f'{course}最高分是{max(temp)}')
print(f'{course}最低分是{min(temp)}')