Python学习笔记（十）推导式与公共操作

一、公共操作

1.运算符

运算符	描述	支持的容器类型
+	合并	字符串，列表，元组
*	复制	字符串，列表，元组
in	是否存在	字符串，列表，元组，字典，集合
not in	是否不存在	字符串，列表，元组，字典，集合

1）合并

# 字符串
a = 'I'
b = 'love'
c = 'You'
print(a + " " + b + " " + c)

# 列表
li = [1, 2, 3, 4, 5]
li2 = [6, 7, 8, 9, 10]
print(li + li2)  # 并不会改变元素中的值

# 元组
tup = (1, 2, 3, 4, 5)
tup2 = (6, 7, 8, 9, 10)
print(tup + tup2)

2）复制

# 字符串
print('放假了' * 10)

# 列表
li3 = [1, 2, 3]
print(li3 * 3)  # 并不会改变元素中的值

# 元组
tup3 = (1, 2, 3)
print(tup3 * 3)

3）是否存在

li3 = [1, 2, 3]
if 1 in li3:
    print('在的')
else:
    print('不在')

2.公共方法

函数	描述
len()	计算容器中元素个数
del	删除
max()	返回容器中元素最大值
min()	返回容器中元素最小值
range(start,end,step)	生成从start到end的数字，步长为step，供for循环使用
enumerate()	函数用于将一个可遍历的数据对象（如列表、元组或字符串）组合为一个索引序列，同时列出数据和数据下标，一般用在for循环中
sum()	序列求和
zip()	合并序列

1）max()

# 字符串
str1 = 'abcdefg'
print(max(str1))  # 比较的是ASCII码值
# 列表
list1 = [10, 20, 30, 40]
print(max(list1))

2）enumerate()

# enumerate(可遍历对象,start=0)
list1 = ['a', 'b', 'c', 'd', 'e']
# 通过循环 得到每一个值的下标
# for循环
count = 0
for i in list1:
    # print(i, count)
    print(i, list1.index(i))
    count += 1
# while循环
# len() while 自增1 长度5 下标0~4
count = 0
while count < len(list1):
    print(list1[count], count)
    count += 1
# 使用enumerate
for index, value in enumerate(list1):
    print(index, value)  # 直接返回的是元组

3）zip()

• zip()函数用于将可迭代对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表
• 如果各个迭代器的元素个数不一致，则返回列表长度与最短对象相同
• 利用*号操作符，可以将元组解压为列表

a = [1, 2, 3]
b = [4, 5, 6]
c = [4, 5, 6, 7, 8]
d = {'name': 'yue', 'age': 18, 'gender': 1}

# 迭代器元素个数一致
zipped = zip(a, b)
print(zipped)
print(list(zipped))

a = [1, 2, 3]
b = [4, 5, 6]
c = [4, 5, 6, 7, 8]
d = {'name': 'yue', 'age': 18, 'gender': 1}

# 迭代器元素个数不一致
zipped = zip(a, c)
print(zipped)
print(list(zipped))

a = [1, 2, 3]
b = [4, 5, 6]
c = [4, 5, 6, 7, 8]
d = {'name': 'yue', 'age': 18, 'gender': 1}
zipped = zip(a, b)

# 解包
x1, x2 = list(zip(*zipped))
print(x1, x2)

 

二、容器类型转换

1.转字符串

a = 1
print(str(a), type(str(a)))

2.转数值

a = '1'
print(int(a), type(int(a)))

a = 'asd'
print(int(a), type(int(a))) # ValueError: invalid literal for int() with base 10: '20:49:23'

a = '20:49:23'
print(int(a), type(int(a))) # ValueError: invalid literal for int() with base 10: '20:49:23'
print(float(a), type(float(a)))  # ValueError: invalid literal for int() with base 10: '20:49:23'

3.转元组

list1 = [10, 20, 30, 40, 50, 20]
set1 = {100, 200, 300, 400, 500}
print(tuple(list1))
print(tuple(set1))

4.转列表

tuple1 = ('a', 'b', 'c', 'd', 'e')
set1 = {100, 200, 300, 400, 500}
print(list(tuple1))
print(list(set1))

5.转集合

list1 = [10, 20, 30, 40, 50]
tuple1 = ('a', 'b', 'c', 'd', 'e')
print(set(list1))
print(set(tuple1))

6.总结

• 列表 元组 集合 三者之间可以相互转换
• int可以转字符串
• 字符串不可以直接转int 除了0123456789

7.扩展

pop()

set1 = {1, 2, 3, 4, 5, 6}
set2 = {'blue', 'red', 'green'}
print(set1.pop())  # 随机删除 如果是数值类型，会删除最小的那个
print(set2.pop())  # 如果是字符串类型的会随机删除
print(set1)

三、推导式

1.列表推导式

li = []
for i in range(1, 11):  # 拿到偶数 2 4 6 8 10
    print(i)
    if i % 2 == 0:
        li.append(i)
print(li)

# 列表推导式 [表达式 for 变量 in 列表 if 条件]
new_li = [i for i in range(1, 11) if i % 2 == 0]  # 对于简单我们可以使用列表推导式
# 对于复杂的 在读代码时并不能直接明白代码的意思
print(new_li)

2.字典推导式

1）字典创建：字典key是1-5数字，value是这个数字的2次方

# 字典推导式 {键：值 for 变量 in 字典.items() if 条件}
dict1 = {i: i ** 2 for i in range(1, 6)}
print(dict1)

2）两个列表变成一个字典

list1 = ['name', 'age', 'sex']
list2 = ['Tom', 20, '男']
dict1 = {list1[i]: list2[i] for i in range(len(list1))}  # i对应值为0 1 2 作为下标去取值

# 另一种方式：通过循环 list1中的每一个值作为键 list2的每一个值作为值 前提是要有一个空字典
dict1 = {}
for i in range(len(list1)):
    dict1[list1[i]] = list2[i]
print(dict1)

3）提取字典中的目标数据

computs = {'AUC': 268, 'HP': 125, 'DELL': 201, 'lenovo': 199, 'acer': 99}
count1 = {key: value for key, value in computs.items() if value >= 200}
print(count1)

注：先写for循环，再写for前表达式，代码是有逻辑性的，不是从头写到尾

3.集合推导式

# 集合推导式 {表达式 for 变量 in 列表 if 条件}
# 计算数字1,2,3的平方数
se = {i ** 2 for i in range(1, 4)}
print(se)

set1 = {x for x in 'abcdefg' if x not in 'abc'}
print(set1)

4.元组推导式

# 元组推导式 （表达式 for 变量 in 列表 if 条件）
a = (i for i in range(1, 10))
print(tuple(a))
print(list(a))