一、列表的相关操作 1. 列表的相关运算：+，* 1）列表1 + 列表2 将两个列表中的元素合并产生一个新的列表（不会修改原列表）
print([1, 2, 3] + [10, 20, 30])# [1, 2, 3, 10, 20, 30]
list1 = [11, 22, 33]
print(list1 + [100, 200])# [11, 22, 33, 100, 200]
2）列表 * N、N * 列表 （N是正整数） 列表中的元素重复N次产生一个新的列表（不会修改原列表）
list1 = [11, 22, 33]
print(list1 * 3)# [11, 22, 33, 11, 22, 33, 11, 22, 33] [11, 22, 33]
2. 列表的比较运算：==, !=, >=, <= 两个列表比较大小不是比较列表的长度，而是比较元素的大小 1）列表1 == 列表2，列表1 != 列表2
list2 = [1, 2, 3]
list3 = [1, 2, 3]
print(list2 == list3)# Truelist3 = [1, 3, 2]
print(list2 == list3)# False
2）补充：is的用法 【2019-07-29_Note_Day6】
==：判断两个数据的值是否相等is：判断两个数据在内存中的地址是否相同list2 = [1, 2, 3]
list3 = [1, 2, 3]
print(list2 == list3)# True
# is相当于：id(list2) == id(list3)
print(list2 is list3)# False
3）列表1 >= 列表2，列表1 <= 列表2
print([1, 2, 3, 4, 5] > [2, 3])# False
print([10, 2, 3, 4, 5] > [2, 3])# True
print([1, 2, 3, 4, 5] > [1, 2])# True
3. in和not in 元素
in 列表：判断列表中是否存在指定的元素
元素 not in 列表：判断列表中是否不存在指定的元素
print(60 in [23, 45, 12, 70])# False
print(12 in [23, 45, 12, 70])# True
4. 内置函数： max(序列)，min(序列)，sum(序列)，len(序列)，list(序列) 1）max()和min() 要求序列中的元素类型必须一致，并且元素支持比较运算符
print(max([23, 45, 78, 90, 32, 45]))# 90
print(min([23, 45, 78, 90, 32, 45]))# 23# TypeError: '>' not supported between instances of 'str' and 'int'
print(max([23, 45, 78, 90, 'abc', 45]))
2）sum() 要求序列中的元素必须是数字
print(sum([23, 45, 78, 90, 32, 45]))# 313
print(sum(range(1, 101)))# 5050
3）list() list(序列)：只有容器型数据类型才能转换成列表 功能：将序列中的元素作为列表中的元素产生一个新列表
# print(list(100))# TypeError: 'int' object is not iterable
print(list('abc'))# ['a', 'b', 'c']
print(list(range(5)))# [0, 1, 2, 3, 4]
二、列表方法 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(序列) 将序列中元素添加到列表的最后
num = [1, 2, 3]
num.extend([10, 20])
print(num)# [1, 2, 3, 10, 20]num = [1, 2, 3]
num.extend('hello')# [1, 2, 3, 'h', 'e', 'l', 'l', 'o']
print(num)num = [1, 2, 3]
num.extend(range(100, 106))# [1, 2, 3, 100, 101, 102, 103, 104, 105]
print(num)
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)# [1, 23, 60, 1, 60, 89, 60, 89, 23]
5. 列表.sort() 1）sort() 列表.sort()：将列表按升序排列 列表.sort(reverse=True)：将列表按降序排列
注意：列表中的元素类型必须一样，并且元素支持比较运算符（不会产生新列表）
nums = [23, 89, 60, 89, 60, 1, 60, 23, 1]
nums.sort()
print(nums)# [1, 1, 23, 23, 60, 60, 60, 89, 89]nums.sort(reverse=True)
print(nums)# [89, 89, 60, 60, 60, 23, 23, 1, 1]
2）内置函数：sorted() sorted(序列)：将列表按升序排列，产生一个新的序列 sorted(序列, reverse=True)：将列表按降序排列，产生一个新的序列
nums = [23, 89, 60, 89, 60, 1, 60, 23, 1]
new_nums = sorted(nums)
print(new_nums)# [1, 1, 23, 23, 60, 60, 60, 89, 89]
6. 清空列表
nums = [23, 89, 60, 89, 60, 1, 60, 23, 1]
print(id(nums))# 4532454024
nums.clear()
print(nums)# []
print(id(nums))# 4532454024
7. 列表.copy() 和列表[:]的效果相同，拷贝列表中的元素，产生一个新的列表（浅拷贝）
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[:]
print(new_nums2)# [1, 2, 3]
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）元组中的元素：和列表要求相同 2.元组的表示
1）单个元素的元组：(元素,)
tuple1 = ()
print(tuple1, type(tuple1))# () tuple2 = (10)
print(tuple2, type(tuple2))# 10 tuple3 = ('abc',)
print(tuple3, type(tuple3))# ('abc',)
2）单独表示一个元组值时，小括号可以省略
tuple4 = 1, 2, 3, 4
print(tuple4, type(tuple4))# (1, 2, 3, 4)
3. 获取元组中的元素 列表中获取元素的方式元组都支持 1）获取单个元素
weeks = '周一', '周二', '周三', '周四', '周五', '周六', '周日'
print(weeks[1], weeks[-1])# 周二 周日
2）切片
注意：切片的结果是元组
print(weeks[1:4])# ('周二', '周三', '周四')
3）遍历
for week in weeks:
print(week, end=" ")# 周一 周二 周三 周四 周五 周六 周日print('\n')for index in range(len(weeks)):
print(index, weeks[index], end=" ")
# 0 周一 1 周二 2 周三 3 周四 4 周五 5 周六 6 周日
4）获取部分元素：变量1, 变量2, 变量3, ... = 元组 用变量获取元组中元素的值（要求前面变量的个数和元组中元素的个数一致）
tuple4 = 10, 20
x, y = tuple4
print(x, y)# 10 20
5）
*语法：多个变量，某一个变量前带* = 元组
让不带*的变量去元组中获取元素，剩下的全部给带*的变量（带*的变量为列表类型）
student = '小明', 18, 'stu001', 23, 89, 90, 89
name, age, study_id, *scores = student# 小明 18 stu001 [23, 89, 90, 89]
print(name, age, study_id, scores)*x, y, z = student
# ['小明', 18, 'stu001', 23, 89] 90 89
print(x, y, z)
4.元组相关操作：与列表相同
t1 = 10, 20
t2 = 30, 40
print(t1 + t2)# (10, 20, 30, 40)
print(t1 * 3)# (10, 20, 10, 20, 10, 20)t3 = 10, 20
print(t3 is t1, t3 == t1)# False Trueprint(10 in t1, 50 not in t1)# True Trueprint(max(t1), min(t2))# 20 30
print(sum(t1))# 30t3 = 1, 2, 3, 1, 1, 2, 4, 3
new_t3 = sorted(t3)
print(new_t3)# [1, 1, 1, 2, 2, 3, 3, 4]print(t3.count(1), t3.count(3))# 3 2
四、数字 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'))# 45 100 -123
print(int())# 0
print(list(), tuple())# [] ()
2. 浮点型 所有的小数对应的类型就是浮点型，浮点型对应的数据类型只有float 支持科学计数法：3e4, 1.25e2, 2e-3 float(数据)：整型、布尔和部分字符串可以转换成浮点型
注意：字符串中只有去掉引号后本身就是一个数字的字符串才能转换成浮点型
print(3e4, 1.25e2, 2e-3)# 30000.0 125.0 0.002print(9.9 / 3)# 3.3000000000000003(计算机存储浮点数问题)
print(float(100))# 100.0
print(float(True), float(False))# 1.0 0.0print(float('23'), float('23.89'))# 23.0 23.89
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 + 0)# 0# False False False False False False False
print(bool(0), bool(0.0), bool(''), bool([]), bool(()), bool({}), bool(None))
4. 复数 由实部和虚部组成的数字叫复数 a+bj（a是实部，b是虚部，j是虚部单位 j * j == -1），对应的类型是complex python直接支持复数的运算
a = 10 + 20j
print(a, type(a))# (10+20j)
b = 10 + 1j# 虚部即使为1也不能省略
c = 10j
print(b, c)# (10+1j) 10jnum1 = 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是标准库（python内置的模块），提供和数学运算相关的方法 需导入import math math.方法名 6. 随机模块random python内置了一个模块叫random，提供了随机操作相关的方法 1）random.randint(M, N) 产生一个区间在[M~N]的随机整数
print(random.randint(0, 10))
2）random.random() 产生一个区间在[0~1)的随机小数
print(random.random())
3）random.randrange(M, N, step) 产生序列range(M, N, step)中的任意一个整数
print(random.randrange(0, 4, 2))
4）random.choices(序列, k=N) 在序列中随机获取N个元素,以列表的形式返回，N默认为1
names = ['小明', '张三', '李四', '小花', 'Tom']
print(random.choices(names, k=2))
5）random.shuffle(列表) 随机打乱列表元素的位置
names = ['小明', '张三', '李四', '小花', 'Tom']
random.shuffle(names)
print(names)# ['李四', '小花', 'Tom', '张三', '小明']
