一、列表
1.列表的数学运算：+，*
加法运算
列表1 + 列表2 - 将两个列表中的元素合并产生一个新的列表；（不会修改原列表）
print([1, 2, 3] + [10, 20, 30])
list1 = [11, 22, 33]
print(list1 + [100, 200], list1) # 不会修改原列表
乘法运算
print(list1 * 3, list1) # 不会修改原列表， list1*3 == list1 + list1 + list1
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
# 比较大小
print([1, 2, 3, 4, 5] > [1, 3, 3]) # False
print([1, 2, 3, 4, 5] > [1, 2]) # True
# print([1, 2, 3, 4, 5] > ['az', 3])
# TypeError: '>' not supported between instances of 'int' and 'str'
补充
is的用法
== -> 判断两个数据的值是否相等
is -> 判断两个数据的地址是否一样
list1 = [1, 2, 3]
list2 = [1, 2, 3]
print(list1 == list2) # True
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
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(序列)
- max和min要求序列中的元素类型必须一致；并且元素支持比较运算符
- sum要求序列中的元素必须是数字
- list(序列) - 只有容器性数据类型才能转换成列表；将序列中的元素作为列表的元素产生一个新的列表
print(max([23, 45, 78, 90, 32, 45]))
# print(max([23, 45, 78, 90, 'abc', 45]))
# TypeError: '>' not supported between instances of 'str' and 'int'
print(min([23, 45, 78, 90, 32, 45]))
print(max('小明', 'abc', '小花')) # 字典不支持比较运算符
print(sum([23, 45, 78, 90, 32, 45]))
print(sum(range(1, 4)))
# print(list(100))
# TypeError: 'int' object is not iterable
print(list('abc'))
print(list(list(range(5))))
二、列表的方法
1.列表.count(元素) - 统计列表中指定元素的个数
nums = [23, 89, 60, 89, 60, 1, 60, 23, 1]
print(nums.count(60)) # 3
print(nums.count(1)) # 1
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(1, 4))
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.reverse()
print(nums)
5.列表.sort() - 将列表中的元素从小到大排序
列表.sort(reverse=True) - 将列表中的元素从大到小排序
注意：列表中的元素类型必须一样，并且元素支持比较运算符，不会产生新的列表
nums.sort()
# nums.sort(reverse=True)
print(nums)
nums = [23, 89, 60, 89, 60, 1, 60, 23, 1]
new_nums = sorted(nums)
print(new_nums)
# python内置函数：sorted(序列)
# sorted(序列) - 对序列中的元素从小到大排序，产生一个新的序列
# sorted(序列, reverse=True) - 对序列中的元素从大到小排序，产生一个新的序列
nums = [23, 89, 60, 89, 60, 1, 60, 23, 1]
new_nums = sorted(nums)
print(new_nums)
print(sorted('hello'))
6.清空列表(clear)
nums = [23, 89, 60, 89, 60, 1, 60, 23, 1]
nums.clear()
print(nums) # []
7.列表.copy()
- 和列表[:]的效果一样，赋值列表中的元素，产生一个新的列表
- 这儿的拷贝是浅拷贝
nums = [1, 2, 3]
new_nums = nums # 直接赋值，赋的是地址
nums.append(100)
print(new_nums)
nums = [1, 2, 3]
# new_nums2 = nums.copy() # 拷贝赋值，赋的是新的地址
new_nums2 = nums[:]
nums.append(100)
print(new_nums2) # [1, 2, 3]
三、元组
1.什么是元组(tuple)
元组就是不可变的列表
1）元组是容器型数据类型（序列），将小括号作为容器的标志，多个元素用逗号隔开：(元素1, 元素2, ...)
特点：不可变（不支持增删改），有序的（支持下标操作）
2）元组中的元素 - 和列表要求一样
2.元组的表示
1）单个元素的元组：(元素, )
tuple1 = ()
print(tuple1, type(tuple1))
tuple2 = ('abc', )
print(tuple2, type(tuple2))
2）单独表示一个元组的时候，小括号可以省略
# tuple3 = (1, 2, 3, 4)
# tuple = 1,
tuple3 = 1, 2, 3, 4
print(tuple3, type(tuple3))
3.相关操作
- 列表中获取元素的方式元组都支持
- 注意，切片的结果是元组
1)获取单个元素
weeks = '周一', '周二', '周三', '周四', '周五', '周六', '周日'
# 1)获取单个元素
print(weeks[1], weeks[-1])
# 2)切片
print(weeks[1: 4]) # 列表切片的结果是列表，元组切片的的结果是元组
# 3）遍历
for week in weeks:
print(week)
for index in range(len(weeks)):
print(index, weeks[index])
2）获取部分元素
变量1, 变量2, ... = 元组/列表
用变量去获取元组中元素的值（要求前面的变量的个数和元组中元素的个数一致）
tuple4 = (10, 20)
# tuple4 = (10, 20, 30) # ValueError: too many values to unpack (expected 2)
x, y = tuple4
print(x, y)
a, b, c = 1, 2, 3 # (a, b, c) = (1, 2, 3)
a1, a2 = [10, 20] # 列表也可以
print(a1, a2)
4.语法：多个变量某一个变量前带* = 元组
让不带*的变量去获取元素，剩下的全部给*的变量
带*的变量会变成列表
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) # ['小明', 18, 'stu001', 23, 89] 90 89
x, y, *z, m = student
print(z) # ['stu001', 23, 89, 90]
5.元组的相关操作：和列表一样
+, *, ==, !=, in、not in, max, min, sum, tuple, len, sorted
四、数字
import math
math是标准库(python内置模块)，提供和数学运算相关的方法
python中数字相关的类型有：int(整型)、float(浮点型)、bool(布尔)、complex(复数)
1.int
所有的整数对应的类型就是整型，python3.x中整型对应的数据类型只有int，ptyhon2.x中除了int还有long
int(数据)
- 将数据转换成整数。所有的小数、布尔值和部分字符串可以转换成整数
- 字符串中只有去掉引号后本身就是一个整数字符串才能转换成整型
print(int(3.14), int(3.99)) # 3 3
print(int(True), int(False)) # 1 0
# print(int('abc'))
# ValueError: invalid literal for int() with base 10: 'abc'
print(int('45'), int('+100'), int('-123'))
# print(int('12.5'))
# ValueError: invalid literal for int() with base 10: '12.5'
print(int()) # 0
# print(int(None))
# TypeError: int() argument must be a string, a bytes-like object or a number, not 'NoneType'
print(list(), tuple()) # 本身不是类型转换，而是创建对象
2.float
- 所有的小数对应的类型就是浮点型，浮点型对应的数据类型只有float
- 支持科学计数法3e4、1.25e2、2e-3
- float(数据) - 整型、布尔和部分字符串可以转换成浮点型
- 字符串中只有去掉引号本身就是一个数字的字符串才能转换成浮点型
print(3e4) # 30000.0
print(1.25e2) # 125.0
print(2e-3) # 0.002
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.89')) # 23.0 23.89
3.bool
布尔中True本质是整数1，False本质是整数0
bool(数据)
- 所有的数据都能转换成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 False
print(bool(' ')) # True
4.complex
由实部和虚部组成的数字叫复数：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模块
import math
print(math.pi)
print(math.e)
print(max(20, 5, 19, 22, 7))
五、随机模块
import random
python内置了一个模块交random模块，提供了和随机操作相关的方法
1.random.randint(M, N)
产生M~N的整数
print(random.randint(0, 10))
2.random.random()
产生0~1的随机数（小数，0可以取到，1取不到）
print(random.random())
3.random.randrange(M, N, step)
产生序列range(M, N, step)中的任意一个整数
print(random.randrange(0, 100, 2))
4.random.choices(列表, k=N)
在序列中随机获取N个元素，以列表的形式返回。N默认是1
print(random.choices(names, k=2))
5.random.shuffle(列表)
随机打乱列表元素 的位置
random.shuffle(names)
print(names)
