【Python】公共操作、公共方法与推导式

这儿主要记录：根底内容的公共操作，

运算符：

兼并：

"""字符串"""
str1 = 'aa'
str2 = 'bb'
str3 = str1 + str2
print(str3)  # aabb
"""列表"""
l1 = [1, 3]
l2 = [10, 20]
l3 = l1 + l2
print(l3)  # [1, 3, 10, 20]
"""元组"""
t1 = (1, 3)
t2 = (10, 30)
t3 = t1 + t2
print(t3)  # (1, 3, 10, 30)

复制：

"""字符串"""
print('-' * 10)  # ----------
"""列表"""
l4 = ['hello']
print(l4 * 4)  # ['hello', 'hello', 'hello', 'hello']
"""元组"""
t4 = ('world',)
print(t4 * 4)  # ('world', 'world', 'world', 'world')

in 或 not in

"""字符串"""
print('a' in 'abcd')  # True
print('a' not in 'abcd')  # False
"""列表"""
l5 = ['a', 'b', 'c', 'd']
print('a' in 'abcd')  # True
print('a' not in 'abcd')  # False
"""元组"""
t5 = ('a', 'b', 'c', 'd')
print('aa' in t5)    # False
print('aa' not in t5)  # True

可变与不行变数据类型：

• 可变：列表、字典、调集 （内存地址前后不发生改变）

• 不行变：数值、字符串、元组 （内存地址前后发生改变）

公共方法：

max():

"""字符串之间的巨细比较：比较的是ascll码值"""
a = 'abcdefg'
b = 'bcdefg'
print(max(a))  # g
li = [1, 3, 5, 7]
print(max(li))  # 7
print(min(li))  # 1

min()：用法同上

enumerate() 枚举，可遍历方针

"""enumerate() 枚举，可遍历方针"""
li_2 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
for i, j in enumerate(li_2):
    print(i, j)
"""enumerate(可遍历方针，start = 0)"""
# (0, 'a')
# (1, 'b')
# (2, 'c')
# (3, 'd')
li_3 = ['a', 'b', 'c', 'd']
for i in enumerate(li_3):
    print(i)
for index, char in enumerate(li_3):
    print(f"下标是{index},对应的字符是{char}")

高阶函数：zip()

zip()函数，用于将可迭代的方针作为参数，将方针中对应的元素打包成一个个元组，然后回来由这些元组组成的列表。

假如各个迭代器的元素个数不一致，则回来列表长度与最短的方针相同，使用*号操作符，可以将元组解压为列表。

list_1 = [1, 2, 3]
list_2 = [4, 5, 6]
list_3 = [4, 5, 6, 7, 8]
zipped = zip(list_1, list_2)  # 压缩
print(zipped)                 # <zip object at 0x102fe4280>
print(list(zipped))           # 转为列表：[(1, 4), (2, 5), (3, 6)]
zipped_1 = zip(list_1, list_3)
print(zipped_1)               # <zip object at 0x1043c8380>
print(list(zipped_1))         # [(1, 4), (2, 5), (3, 6)]
"""一起遍历多个字典"""
dict_1 = {'name': 'maria', 'age': '30', 'gender': 'girl'}
dict_2 = {'name': 'manta', 'age': '18', 'gender': 'boy'}
for (k1, v1), (k2, v2) in zip(dict_1.items(), dict_2.items()):
    print(k1, '-->', v1)
    print(k2, '-->', v2)     

""" zip(*zipped)中的 *zipped参数，可以list数组，也可所以zip()函数回来的方针。"""
nums = [[1, 2, 3], [4, 5, 6]]
iters = zip(*nums)
print("type of iters is %s" % type(iters))  # type of iters is <class 'zip'>
print(iters)  # <zip object at 0x104f3cc40>
m = [1, 2, 3]
n = [4, 5, 6]
print("*zip(m,n)回来：", *zip(m, n))  # *zip(m,n)回来： (1, 4) (2, 5) (3, 6)
""" *zip()函数是zip()函数的逆进程，将zip方针变成原先组合前的数据 """
m2, n2 = zip(*zip(m, n))
print("m2 和 n2 的值分别是：", m2, n2)  # m2 和 n2 的值分别是： (1, 2, 3) (4, 5, 6)

对多个元素一起进行排序：

"""姓名与分数一一对应进行排序，又不损坏对应关系"""
names = ['Tom', 'Bob', 'Dave']
scores = [90, 80, 100]
data = list(zip(names, scores))
data.sort()  # 优先对姓名进行排序
print(data)  # [('Bob', 80), ('Dave', 100), ('Tom', 90)]

对数据进行计算：

profit = 0  # 赢利
sales = [52000, 51000, 49000]  # 销售额
cost = [46800, 45900, 43000]  # 成本
# 赢利：
for sales, cost in zip(sales, cost):
    profit = sales - cost
    print(profit)

构建字典：

"""将上面的成果兼并起来，得到一个字典："""
stu = dict(zip(names, scores))
print(stu)  # {'Tom': 90, 'Bob': 80, 'Dave': 100}

容器类型的互转：

list   列表
tuple  元组
set    调集

li = [1, 3, 5, 7]
tup = (1, 2, 34, 5, 7, 7, 7)
s1 = {1, 2, 34, 5, 6}
print(list(tup), type(list(tup)))  # 元组转列表  [1, 2, 34, 5, 7, 7, 7] <class 'list'>
print(set(tup), type(set(tup)))    # 元组转调集    {1, 2, 34, 5, 7} <class 'set'>
# print(tup(li), type(tup(li)))  # 列表转元组    # “元组”方针不行调用
print(set(li), type(set(li)))    # 列表转调集      {1, 3, 5, 7} <class 'set'>
print(list(s1), type(list(s1)))  # 调集转列表    [1, 2, 34, 5, 6] <class 'list'>
# print(tup(s1), type(tup(s1)))  # 调集转元组    # “元组”方针不行调用

推导式：

• 推导式：都是对可变数据类型来使用的

• 什么是遍历：从序列中一个一个取出元素的进程

• 什么是迭代：通常用于循环、递归，重复履行某个操作来逐步逼近方针的进程

• 列表推导式

  [表达式 for 变量 in 列表 if 条件]

• 字典推导式

  {键：值 for 变量 in 字典.items() if 条件}

• 调集推导式

  {表达式 for 变量 in 调集 if 条件}

• 元组推导式

  （表达式 for 变量 in 元组 if 条件）

列表推导式：

1、for循环：

# for循环完成进程：
li = []
for i in range(1, 11):
    li.append(i / 2)
print(li)  # [0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0]
# 列表推导式完成进程：
new_li_1 = [i / 2 for i in range(1, 11)]
print(new_li_1)  # [0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0]

2、带 if 的列表推导式：

# 使用步长完成：
li_2 = []
for i in range(0, 10, 2):
    print(i, end=" ")  # 0 2 4 6 8
    li_2.append(i)
print(li_2)  # [0, 2, 4, 6, 8]
new_li_2 = [i for i in range(0, 10, 2)]
print(new_li_2)  # [0, 2, 4, 6, 8]
# if 完成：
li_3 = []
for i in range(1, 11):
    if i % 2 == 0:
        print(i)
        li_3.append(i)
print(li_3)  # [2, 4, 6, 8, 10]
li_4 = [2, 4, 6, 8, 10]
print(li_4)
"""回来的值  循环表达式  条件判别"""
new_li_4 = [i for i in range(1, 11) if i % 2 == 0]
print(new_li_4)  # [2, 4, 6, 8, 10]

字典推导式：

1、创立一个字典：

dic1 = {i: i ** 2 for i in range(1, 6)}
print(dic1)  # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

2、将2个列表变为一个字典：

li_5 = ['name', 'age', 'sex']
print(len(li_5))  # 3
li_6 = ['Tom', '20', 'boy']
dic2 = {li_5[i]: li_6[i] for i in range(len(li_5))}
print(dic2)  # {'name': 'Tom', 'age': '20', 'sex': 'boy'}

3、提取字典中的方针数据：

"""需求：提取上述电脑数量大于等于200的字典数据"""
cumputer = {'AUC': 260, 'HP': 125, "DELL": 208, 'Lenovo': 180}
count = {k1: v1 for k1, v1 in cumputer.items() if v1 >= 200}
print(count)  # {'AUC': 260, 'DELL': 208}
"""等同于："""
for key, value in cumputer.items():
    if value >= 200:
        count[key] = value
print(count)  # {'AUC': 260, 'DELL': 208}

调集推导式：

1、计算平方：

new_set = {i ** 2 for i in (1, 3, 5)}
print(new_set)  # {1, 9, 25}

2、输出非abd的字母：

"""调集：无序、去重"""
a = {x for x in 'dfadfnamdjk' if x not in 'abd'}
print(a)         # 回来的是生成器方针
print(tuple(a))  # 直接将生成器方针转换为元组

元组推导式：

生成包括1-9数字的元组：

a = (j for j in range(1, 10))
print(a)  # 回来的是生成器方针   <generator object <genexpr> at 0x104ccc040>
print(tuple(j for j in range(1, 10)))  # (1, 2, 3, 4, 5, 6, 7, 8, 9)