review
1.list
容器； 可变、有序
2.元素
[元素1, 元素2, 元素3]
3.增删改查
查 - 1）获取单个元素: 列表[下标]
2)切片: 列表[开始下标:结束下标:步长]
- 遍历
增 - 列表.append(元素), 列表.insert(下标, 元素)
删 - del 列表[下标]; 列表.remove(元素); 列表.pop()/列表.pop(下标)
改 - 列表[下标] = 新值
homework
1.已知一个数字列表，求列表中心元素。
nums = [1, 2, 67, 90, 87, 3] # 67, 90 (6, 2/3 -> 6//2-1,6//2)
nums = [1, 2, 67, 90, 87, 3, 100] # 90 (7, 3) -> 7//2
length = len(nums)
if length & 1 == 0:
print(nums[length//2-1], nums[length//2])
else:
print(nums[length//2])
2.已知一个数字列表，求所有元素和。
nums = [10, 30, 20, 10]
sum1 = 0
for num in nums:
sum1 += num
print(sum1)
3.已知一个数字列表，输出所有奇数下标元素。
print('方法二:')
nums = [10, 30, 20, 10]
for index in range(1, len(nums), 2):
print(nums[index])
# print(nums[1::2])
print('方法三:')
for num in nums[1::2]:
print(num)
5.已知一个数字列表，将所有元素乘二。
例如：nums = [1, 2, 3, 4] —> nums = [2, 4, 6, 8]
print('方法一:')
nums = [1, 2, 3, 4]
for index in range(len(nums)):
nums[index] *= 2 # nums[index] = nums[index]*2
print(nums)
print('方法二:')
nums = [1, 2, 3, 4]
new_nums = []
for num in nums:
new_nums.append(num*2)
nums = new_nums
print(nums)
print('============遍历删除练习=============')
练习: 删除分数列表scores中所有分数低于60分的成绩
坑一: 遍历删除的时候因为没有遍历完，导致一些数据没有参数判断
scores = [78, 56, 40, 66, 70, 12, 45, 59, 90] # [78, 66, 70, 90]
for score in scores:
print(score)
if score < 60:
scores.remove(score)
print(scores)
"""
scores = [78, 56, 40, 66, 70, 12, 45, 59, 90]
score = 78
score = 56; 56<60; scores = [78, 40, 66, 70, 12, 45, 59, 90]
score = 66;
score = 70
score = 12; 12<60; scores = [78, 40, 66, 70, 45, 59, 90]
score = 59; 59 < 60; scores = [78, 40, 66, 70, 45, 90]
结束
scores = [78, 40, 66, 70, 45, 90]
"""
解决方案一: 先用一个新的列表对原数据进行备份
scores = [78, 56, 40, 66, 70, 12, 45, 59, 90]
new_scores = scores[:]
# print(id(scores), id(new_scores))
for num in new_scores:
if num < 60:
scores.remove(num)
print(scores)
解决方案二: 下标范围从len-1到0，倒着取
scores = [78, 56, 40, 66, 70, 12, 45, 59, 90]
for index in range(len(scores)-1, -1, -1):
if scores[index] < 60:
del scores[index]
print(scores)
"""
range(8, -1, -1)
index = 8; 90 < 60
index = 7; 59 < 60; [78, 56, 40, 66, 70, 12, 45, 90]
index = 6; 45 < 60; [78, 56, 40, 66, 70, 12, 90]
index= 5; 12 < 60; [78, 56, 40, 66, 70, 90]
index= 4; 70 < 60
index=3; 66 < 60
index=2; 40<60; [78, 56, 66, 70, 90]
index=1; 56<60; [78,66, 70, 90]
index=0; 78
"""
解决方案3: 用空列表
scores = [78, 56, 40, 66, 70, 12, 45, 59, 90]
new_scores = []
for score in scores:
if score >= 60:
new_scores.append(score)
print(new_scores)
坑二
scores = [78, 56, 40, 66, 70, 12, 45, 59, 90]
for index in range(len(scores)):
if scores[index] < 60:
del scores[index]
print(scores)
"""
for index in range(0, 9)
index = 0; 78 < 60
index = 1; 56 < 60; scores = [78, 40, 66, 70, 12, 45, 59, 90]
index = 2; 66 < 60
index = 3; 70 < 60
index = 4; 12 < 60; scores = [78, 40, 66, 70, 45, 59, 90]
index = 5; 59 < 60; scores = [78, 40, 66, 70, 45, 90]
index = 6; 越界!!!
"""
scores = [78, 56, 40, 66, 70, 12, 45, 59, 90]
index = 0
while index < len(scores):
if scores[index] < 60:
del scores[index]
# index -= 1
continue
index += 1
print(scores)
6.有一个长度是10的列表，数组内有10个人名，要求去掉重复的
例如:names = ['张三', '李四', '大黄', '张三'] -> names = ['张三', '李四', '大黄']
names = ['张三', '李四', '大黄', '张三', '张三', '李四']
for index in range(len(names)-1, 0, -1):
name1 = names[index]
for name2 in names[index-1::-1]:
if name1 == name2:
del names[index]
break # 一次只能删一次
print(names)
10.有一个数字列表，获取这个列表中的最大值.(注意: 不能使用max函数)
例如: nums = [19, 89, 90, 600, 1] —> 600
nums = [19, 89, 90, 600, 1]
max1 = nums[0]
for num in nums[1:]:
if num > max1:
max1 = num
print(max1)
列表相关操作
1.列表的数学运算: +, *
列表1 + 列表2 - 将两个列表中的元素合并产生一个新的列表；（不会修改原列表）
列表 * N 、N * 列表 - N是正整数; 列表中的元素重复N次产生一个新的列表
加法运算
print([1, 2, 3] + [10, 20, 30])
list1 = [11, 22, 33]
print(list1 + [100, 200], list1)
乘法运算
print(list1 * 3, list1) # [11, 22, 33, 11, 22, 33, 11, 22, 33] [11, 22, 33]
2.列表的比较运算: ==, !=, >, <, >=, <=
列表1 == 列表2 、 列表1 != 列表2
两个列表比较大小，不是比较列表的长度，而是比较元素的大小
比较相等
list2 = [1, 2, 3]
list3 = [1, 2, 3]
print(list2 == list3) # True
list3 = [1, 3, 2]
print(list2 == list3) # False
补充：is的用法
== -> 判断两个数据的值是否相等
is -> 判断两个数据的地址是否一样
list1 = [1, 2, 3]
list2 = [1, 2, 3]
print(list1 == list2)
print(list1 is list2) # list1 is list2 相当于: id(list1) == id(list2)
a = 10
b = 10
print(id(a), id(b))
print(a == b, a is b) # True True
# 比较大小
print([1, 2, 3, 4, 5] > [2, 3]) # False
3. in和not in
元素 in 列表 - 判断列表中是否存在指定的元素
元素 not in 列表 - 判断列表中是否不存在指定的元素
print(60 in [23, 45, 12, 70]) # False
print(12 in [23, 45, 12, 70, 12]) # True
4. 内置函数: max(序列), min(序列), sum(序列), len(序列), list(序列)
max和min要求序列中的元素类型必须一致；并且元素支持比较运算符
sum要求序列中的元素必须是数字
list(序列) - 只有容器型数据类型才能转换成列表; 将序列中的元素作为列表的元素产生一个新列表
print(max([23, 45, 78, 90, 32, 45]))
print(min([23, 45, 78, 90, 32, 45]))
print(max(['小明', 'abc', '小花']))
print(sum([23, 45, 78, 90, 32, 45]))
print(sum(range(1, 101)))
# print(list(100)) # TypeError: 'int' object is not iterable
print(list('abc'))
print(list(range(5)))
列表方法
1. 列表.count(元素) - 统计列表中指定元素的个数, 返回一个数字
nums = [23, 89, 60, 89, 60, 1, 60, 23, 1]
print(nums.count(60)) # 3
print(nums.count(1)) # 2
print(nums.count(100)) # 0
2.列表.extend(序列) - 将序列中的元素添加到列表的最后，没有返回值
nums = [1, 2, 3]
nums.extend([10, 20])
print(nums)
nums.extend('hello')
print(nums)
nums.extend(range(100, 105))
print(nums)
3.列表.index(元素) - 获取元素在列表中的正下标(如果元素有多个只取第一个, 元素不存在会报错)
nums = [23, 89, 60, 89, 60, 1, 60, 23, 1]
print(nums.index(89)) # 1
print(nums.index(23)) # 0
# print(nums.index(100)) # ValueError: 100 is not in list
4. 列表.reverse() - 让列表倒序（不会产生新的列表）
nums = [23, 89, 60, 89, 60, 1, 60, 23, 1]
nums.reverse()
print(nums)
5.排序
列表.sort() - 将列表中的元素从小到大排序
列表.sort(reverse=True) - 将列表中的元素从大到小排序
注意: 列表中的元素类型必须一样，并且元素支持比较运算符; 不会产生新的列表
nums = [23, 89, 60, 89, 60, 1, 60, 23, 1]
# nums.sort()
nums.sort(reverse=True)
print(nums)
# nums = [23, 89, 60, 89, 60, 1, 60, 23, 1]
# nums.sort(key= lambda num: num % 10)
# print(nums)
内置函数: sorted
sorted(序列) - 对序列中的元素从小到大排序，产生一个新的列表
sorted(序列, reverse=True) - 对序列中的元素从大到小排序，产生一个新的列表
nums = [23, 89, 60, 89, 60, 1, 60, 23, 1]
new_nums = sorted(nums)
print(nums)
print(new_nums)
print(sorted('hello'))
6.清空列表
nums = [23, 89, 60, 89, 60, 1, 60, 23, 1]
nums.clear()
print(nums) # []
# nums = [23, 89, 60, 89, 60, 1, 60, 23, 1]
# print(id(nums))
# nums = []
# print(id(nums))
````
#### 7.列表.copy() - 和列表[:]的效果一样，拷贝列表中的元素产生一个新的列表。这儿的拷贝是浅拷贝
```python
nums = [1, 2, 3]
new_nums = nums # 直接赋值，赋的是地址
nums.append(100)
print(new_nums) # [1, 2, 3, 100]
nums = [1, 2, 3]
# new_nums2 = nums.copy() # 拷贝赋值，赋的是新的地址
new_nums2 = nums[:]
nums.append(100)
print(new_nums2) # [1, 2, 3]
nums = [1, 2, 3]
new_nums3 = nums*1
print(nums is new_nums3) # False
元祖
1.什么是元祖(tuple)
元祖就是不可变的列表
1)元祖是容器型数据类型(序列), 将()作为容器的标志，多个元素用逗号隔开: (元素1,元素2,元素3,...)
特点: 不可变(不支持增删改)，有序的(支持下标操作)
2)元祖中元素 - 和列表要求一样
1.元祖的表示
1)单个元素的元祖: (元素,)
tuple1 = ()
print(tuple1, type(tuple1))
tuple2 = ('abc',)
print(tuple2, type(tuple2))
2)单独表示一个元祖值的时候，小括号可以省略
tuple3 = 1, 2, 3, 4
print(tuple3, type(tuple3))
2. 获取元祖中的元素
列表中获取元素的方式元祖都支持; 注意，切片的结果是元祖
weeks = '周一', '周二', '周三', '周四', '周五', '周六', '周天'
# 1)获取单个元素
print(weeks[1], weeks[-1])
# 2)切片
print(weeks[1:4], weeks[1::2])
# 3)遍历
for week in weeks:
print(week)
for index in range(len(weeks)):
print(index, weeks[index])
# 4)获取部分元素: 变量1, 变量2, 变量3,... = 元祖
# 用变量去获取元祖中元素的值(要求前面变量的个数和元祖中元素的个数一致)
tuple4 = (10, 20, 30)
x, y, z = tuple4
print(x, y, z)
a, b, c = 1, 2, 3 # a, b, c = (1, 2, 3)
a1, a2 = [10, 20] # 列表也可以
print(a1, a2)
# 5)*语法: 多个变量某一个变量前带* = 元祖
# 让不带*的变量去元祖中获取元素，剩下的全部给带*的变量 (带*的变量会变成列表)
student = ('小明', 18, 'stu001', 23, 89, 90, 89)
name, age, study_id, *scores = student
print(name, age,study_id, scores) # 小明 18 stu001 [23, 89, 90, 89]
*x, y, z = student
print(x, y, z) # z=89, y=90, x=['小明', 18, 'stu001', 23, 89]
x, y, *z, m = student # z = ['stu001', 23, 89, 90]
print(z)
3.元祖相关操作：和列表一样
+， *， ==, !=, in、not in, max, min, sum, tuple, len, sorted
数字
math是标准库(python内置的模块),提供和数学运算相关的方法
import math
python中数字相关的类型有: int(整型), float(浮点型),bool(布尔), complex(复数)
1.整型
所有的整数对应的类型就是整型, python3.x中整型对应的数据类型只有int， python2.x除了int还有long
int(数据) ->
将数据转换成整数。所有的小数、布尔值和部分字符串可以转换成整数
字符串中只有去掉引号后本身就是一个整数的字符串才能转换成整型
print(int(3.14), int(3.99)) # 3 3
print(int(True), int(False)) # 1 0
print(int('45'), int('+100'), int('-123'), int('125')) # 45 100 -123
print(int()) # 0
print(list(), tuple()) # [] ()
2.浮点型
所有的小数对应的类型就是浮点型, 浮点型对应的数据类型只有float。支持科学计数法: 3e4, 1.25e2, 2e-3
float(数据) -
整型、布尔和部分字符串可以转换成浮点型
字符串中只有去掉引号后本身就是一个数子的字符串才能转换成浮点型
print(3e4) # 30000.0
print(1.25e2) # 125.0
print(9.9/3) # 3.3000000000000003(计算机存储浮点数的正常情况)
print(float(100)) # 100.0
print(float(True), float(False)) # 1.0 0.0
print(float('23'), float('23.8'))
3.布尔
布尔中True本质就是整数1，False本质是整数0
bool(数据) - 所有的数据都可以转换成布尔; 所有为0为空的值都会转换成False,其他都是True
print(1+1, True+1, True*10, True/10) # 2 2 10 0.1
print(False + 10) # 10
print(bool(0), bool(0.0), bool(''), bool([]), bool(()), bool({}), bool(None)) # False False False False False False False
# nums = []
# if nums == []:
# pass
#
# if len(nums) == 0:
# pass
#
# if not nums:
# pass
num = 10
if not num % 2:
print('偶数')
if num % 2:
print('奇数')
4.复数
由实部和虚部组成数字叫复数: a+bj(a是实部、b是虚部,j是虚数单位), 对应的类型是complex; python直接支持复数的运算
a = 10 + 20j
print(a, type(a))
b = 10 + 1j # 虚部是1不能省略
c = 10j
print(b, c)
num1 = 2 + 3j
num2 = 4 - 2j
print(num1+num2) # 6+1j
print(num1*num2) # (14+8j)
print(num1/num2) # (0.1+0.8j)
5.math模块
math.方法名
print(math.pi, math.e)
print(max([12, 34, 78]))
print(max(12, 90, 89))
随机模块
import random
python内置了一个模块叫random， 提供了和随机操作相关的方法
- random.randint(M,N) - 产生M~N的整数,可以取到N
print(random.randint(0, 10))
- random.random() - 产生 0 ~ 1的随机数(小数, 0可以取到，1取不到)
print(random.random())
- random.randrange(M, N, step) - 产生序列range(M,N,step)中的任意一个整数
print(random.randrange(0, 100, 2))
- random.choices(序列, k=N) - 在序列中随机获取N个元素，以列表的形式返回。N默认是1
names = ['小明', '张三', '李四', '小花', 'Tom']
print(random.choices(names, k=2))
- random.shuffle(列表) - 随机打乱列表元素的位置
names = ['小明', '张三', '李四', '小花', 'Tom']
random.shuffle(names)
print(names)
