2021-09-09--积少成多之python运算符列表推导式

每天一小节python知识

积少成多它不香吗？？？

第十四节

运算符和公共方法

运算符 ，支持容器类型

# 多个变量同赋值，一一对应，
str1, str2 = "abc", "def"  # 字符串
list1, list2 = [1, 2], [3, 4]  # 列表
t1, t2 = (11, 21), (31, 41)  # tuple元组
set1, set2 = {10, 11}, {20, 21}  # 集合
dict2 = {"name": "qao", "age": 99}  # 字典

a、+: 合并，支持字符串，列表，元组

print(str1 + str2)  # 结果：abcdef
print(t1 + t2)  # 结果：报错，集合和字典不支持合并

b、*: 复制，支持字符串，列表，元组

print(t1 * 3)  # 结果：(11, 21, 11, 21, 11, 21)
print(dict2 * 4)  # 报错：集合和字典不支持复制

c、in: 元素是否存在，支持字符串，列表，元组，字典，结果返回布尔型为True和False

print("a" in str1)  # 结果：True
print("qao" in dict2)  # 结果：False

d、not in: 元素是否不存在，支持字符串，列表，元组，字典，结果返回布尔型为True和False

print("a" not in str1)  # 结果：False
print("qao" not in dict2)  # 结果：True

字典的in和not in用法

print("age" in dict2)  # 结果：True
print(dict2["name"] in dict2.values())  # 结果：True

公共方法

str3 = "abcd"  # 字符串
list3 = [1, 2, 4, 6, 1]  # 列表
t3 = (12, 22, 32, 42)  # tuple元组
set3 = {500, 400, 300, 200, 100}  # 集合
dict3 = {"xm": "guy", "age": 60, "id": 123456}  # 字典

a、len():计算容器中元素个数

print(len(t3))
print(len(dict3))
# 结果：
4
3

b、del或del(): 删除，有根据下标删除，没有下标根据k删除

del set3  # 根据集合名称删除
print(set3)
# 结果：
列表不存在，会报错

del list3[2]  # 根据下标删除
print(list3)
# 结果：
[1, 2, 6, 1]
del(dict3["xm"])
print(dict3)
# 结果：
{'age': 60, 'id': 123456}

c、max(): 返回容器中元素最大值
d、min()：返回容器中元素最小值

print(max(str3))
print(min(str3))  # 英文大小的排序是按照字母的排序
# 结果：
d
a
print(max(set3))
print(min(set3))
# 结果：
500
100
print(max(dict3))
print(min(dict3))
# 结果：
id
age

e、range(start,end,step): 生成从start到end的数字，步长为step，供for循环使用

生成1到10中间的数字

for i in range(1, 11):  # 包前不包后，步长不写，默认为1
    print(i)
# 结果：
1
2
3
4
5
6
7
8
9
10

for i in range(1, 11, 2):  # 包前不包后，步长不写，默认为1,步长就是增量
    print(i)
# 结果：
1
3
5
7
9

for i in range(10):  # 代表开始不写，默认从零开始，步长为1
    print(i)
# 结果：
0
1
2
3
4
5
6
7
8
9

f、enumerate(可遍历对象): 函数用于将一个可遍历的数据对象(如列表、元组或字符串)结合为一个索引序列 ，同时列出数据和数据下标，一般用于for循环当中，用于改变序列中序列下标的起始值
for i in enumerate(list3):  # 返回的数据类型是元组，元组中第一个数字是序列中数字对应的下标，第二个数字是序列中的数字
     print(i)
# 结果：
(0, 1)
(1, 2)
(2, 6)
(3, 1)

for i in enumerate(list3, start=2):  # start设置下标的起始值
    print(i)
# 结果：
(2, 1)
(3, 2)
(4, 6)
(5, 1)

容器类型转换

list4 = [11, 22, 33, 44, 55]                     # list 列表
t4 = (10, 20, 30, 40, 50)                        # tuple 元组
s4 = {13, 23, 33, 43, 53}                        # set 集合
dict4 = {"name": "gao", "age": 34, "id": 65535}  # dict 字典

a、tuple()：将序列转换为元组

print(tuple(list4))
print(tuple(t4))
print(tuple(s4))
print(tuple(dict4))  # 将字典转换为其他序列类型时，会丢失val值
# 结果：
(11, 22, 33, 44, 55)
(10, 20, 30, 40, 50)
(33, 43, 13, 53, 23)
('name', 'age', 'id')

b、list():将序列转换成列表

print(list(list4))
print(list(t4))
print(list(s4))
print(list(dict3))  # age类型为整型，不再转换类型内，可以录入时候以字符串类型录入，然后再转化为整型
# 结果：
[11, 22, 33, 44, 55]
[10, 20, 30, 40, 50]
[33, 43, 13, 53, 23]
['age', 'id']

c、set():将序列转换为集合

注意
1、集合可以快速完成列表去重
2、集合不支持下标

print(set(list4))
print(set(t4))
print(set(s4))
print(set(dict4))
# 结果：
{33, 11, 44, 22, 55}
{40, 10, 50, 20, 30}
{33, 53, 23, 43, 13}
{'id', 'age', 'name'}

d、dict（）没有将其他类型转换为字典的函数，因为字典含有键值对，其他类型缺少键或值

print(dict(list4))
# 结果：
无法运行，退出代码为1

列表推导式

推导式作用：简化序列写法的写法
列表的推导式：用一个表达式创建一个有规律的列表或控制一个有规律列表，列表推导式又叫列表生成式

# 使用while，for，和列表推导式，创建一个1到10的列表
# while循环
i = 1
list5 = []  # 创建空列表
while i <= 10:  # 生成1到10之间的数字
    list5.append(i)  # 循环将i（生成的数值添加到空列表），append()添加函数
    i += 1
print(list5)
# 结果：
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# for循环
list6 = []  # 创建空列表
for j in range(1, 11, 1):  # range生成1到10这几个数，步长为1
    list6.append(j)
print(list6)
# 结果：
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 列表推导式，一般都是配合for循环使用
list7 = [d for d in range(1, 11)]
print(list7)
# 结果：
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

带if的列表推导式

创建一个有1~10范围的偶数数字的列表
1、使用range步长为2去控制
2、使用if语句去控制实现：for循环后面接if加条件

list8 = [a for a in range(1, 11) if a % 2 == 0]
print(list8)
# 结果：
[2, 4, 6, 8, 10]

多个for循环实现列表推导式
实现效果[(1, 0),(1, 1),(1, 2),(2, 0),(2, 1),(2, 2)]
for循环实现
元组的数据1：1 2->range(1, 3)元组的数据2、0 1 2->range(3)

list9 = []
for i1 in range(1, 3):
    for i2 in range(3):
        list9.append((i1, i2))  # 列表中添加元组
print(list9)
# 结果：
[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

多个for循环实现列表推导式，格式：for循环(外) for循环(内)

list10 = [(t, b)for t in range(1, 3) for b in range(3)]
print(list10)
# 结果：
[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

字典和集合推导式

字典推导式->作用：快速合并列表为字典或提取字典中目标数据。
创建一个字典，字典key是1-5数字，value是这个数字的2次方

dc1 = {i3: i3 ** 2 for i3 in range(1, 6)}
print(dc1)
# 结果;
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

拼接下方两个列表成为一个字典

ls1 = ["name", "age", "gender", "id"]  # 当需要合并的两个列表长度不同，拼接时尽量以列表长度短的为准
ls2 = ["jak", 20, "man", 95279527]
dc2 = {ls1[i4]: ls2[i4] for i4 in range(len(ls1))}  # len函数，计算列表长度，range内也可以直接填0， 4（包前不包后）
print(dc2)
# 结果：
{'name': 'jak', 'age': 20, 'gender': 'man', 'id': 95279527}

提取value大于等于2000

dc3 = {"hua": 3000, "viv": 1998, "opp": 2001, "mi": 2500}
# 字典推导式
dc4 = {key: value for key, value in dc3.items() if value >= 2000}
print(dc4)
# 结果：
{'hua': 3000, 'opp': 2001, 'mi': 2500}

集合推导式

创建集合，数据是下方列表数据的2次方

lt1 = {1, 2, 3, 4, 5, 6}
set1 = {i ** 2 for i in lt1}
print(set1)
# 结果：
{1, 4, 36, 9, 16, 25}

没有元组推导式