1.随机抽样只需一个函数，列表排序可以自定规则

for循环语句只能读取元素，而不适用于修改被循环的对象里的内容

比如一下例子中，列表元素保持不变

price=[100,200,300]
for i in price:
    i=i*7
print(price)	#依然是[100,200,300]

可以通过while循环来修改列表中的元素

price=[100,200,300]
i=0
while i<len(price):
    price[i]=price[i]*7
    i+=1
print(price)    #[700, 1400, 2100]

使用for语句来实现修改列表元素的方法如下，使用该方法不是直接修改i，而是修改列表中第i个元素

price=[100,200,300]
i=0
for i in range(len(price)):
    price[i]='*'
print(price)

python中，可以通过sort方法对一个列表中的元素进行排序，sort方法的key参数，可以指定一个函数名（包括自己创建的函数），作为排序的规则，key参数可以接受任何一个能够返回可用于排序的键的函数或表达式，除了函数外，还接受lambda、属性访问、操作符函数、多个键，如果想反向排列，再加一个参数【reverse=True】

#python中，可以通过sort方法对一个列表中的元素进行排序，sort方法的key参数，可以指定一个函数名，作为排序的规则
fruits=['cherry','apple','banana',]
fruits.sort(key=len)    #根据列表中每个元素的长度，从小到大排序
print(fruits)   #['apple', 'cherry', 'banana']

#lambda示例，使字符串列表中的元素按字母顺序排序
fruits = ["apple", "banana", "cherry", "date", "elderberry"]
fruits.sort(key=lambda x: x.lower())
print(fruits)
# 输出：['apple', 'banana', 'cherry', 'date', 'elderberry']


#属性访问
'''
在这个例子中，我们定义了一个 Person 类，具有 name 和 age 属性。我们创建了一个 people 列表，其中包含了几个 Person 对象。我们使用 lambda 表达式来指定排序的键为 name 属性，导致对象列表按照姓名的字母顺序进行排序。
'''
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

people = [
    Person("Alice", 25),
    Person("Bob", 30),
    Person("Charlie", 20)
]

people.sort(key=lambda x: x.name)
for person in people:
    print(person.name, person.age)
# 输出：
# Alice 25
# Bob 30
# Charlie 20


#操作符函数
#使用了 operator.itemgetter 函数来指定排序的键为每个元素的索引为 1 的值。这将导致列表按照第二个元素的值进行排序。
import operator

numbers = [4, 2, 8, 6, 5]
numbers.sort(key=operator.itemgetter(1))
print(numbers)
# 输出：[2, 4, 5, 6, 8]


#多个键
#使用 lambda 表达式来指定排序的键为元组 (x.age, x.name)。这将导致对象列表首先按照年龄进行升序排序，如果年龄相同，则按照姓名的字母顺序进行排序。
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

people = [
    Person("Alice", 25),
    Person("Bob", 30),
    Person("Charlie", 20)
]

people.sort(key=lambda x: (x.age, x.name))
for person in people:
    print(person.name, person.age)
# 输出：
# Charlie 20
# Alice 25
# Bob 30

读取Excel表格，按表格的第二列的内容进行排序，表格内容如下：

import xlwings as xw
#使用xlwings将Excel文件中的名单读入到列表name中
app=xw.App()
wb=app.books.open('D:\\Python\\学习\\test.xlsx')  #读取的文件，好像必须要完整的路径？
names=wb.sheets['Sheet1'].range('a1:b3').value  #设置读取的范围，并返回给名为names的变量
wb.close()
app.quit()

print(names)
print('----------------')

#循环打印names中的每一个元素，每个占一行
for n in names:
    print(n)
print('----------------')
def order(s):
    #由于传进来的每一个元素都是一个列表，排序时取列表中的第1个元素进行计算
    if s[1]=='硕士':
        return 1
    if s[1]=='博士':
        return 2
    else:
        return -1
names.sort(key=order,reverse=True)
for n in names:
    print(n)

以上程序最终的输出结果为：

[‘l’, ‘博士’]

[‘c’, ‘硕士’]

[‘h’, ‘硕士’]

更为简化的写法是，创建一个字典，字典内放置文本以及对应的值，然后通过函数检查字典内对应的值

import xlwings as xw
#使用xlwings将Excel文件中的名单读入到列表name中
app=xw.App()
wb=app.books.open('D:\\Python\\学习\\test.xlsx')  #读取的文件，好像必须要完整的路径？
names=wb.sheets['Sheet1'].range('a1:b3').value  #设置读取的范围，并返回给名为names的变量
wb.close()
app.quit()

d={'硕士':1,'博士':2}

def order(s):
    t=s[1]
    return d[t]

names.sort(key=order,reverse=True)
for n in names:
    print(n)

除了sort()，sorted()方法也可以对列表进行排序，用法是【sorted(列表名,key,reverse)】,它可以将指定的列表复制后，对复制的新列表进行排序，不修改原列表

random.shuffle(列表名)可以对列表内容进行随机排序，相当于“洗牌”，使用前需要import random

import xlwings as xw
import random

#使用xlwings将Excel文件中的名单读入到列表name中
app=xw.App()
wb=app.books.open('D:\\Python\\学习\\test.xlsx')  #读取的文件，好像必须要完整的路径？
names=wb.sheets['Sheet1'].range('a1:b3').value  #设置读取的范围，并返回给名为names的变量
wb.close()
app.quit()

random.shuffle(names)
for n in names:
    print(n)

random.sample(列表,数量)可以从指定列表中，随机抽取指定数量元素，并放在一个列表中返回，而且在返回的结果中，各个元素的顺序也是随机的，值得注意的是，即使抽取一个元素，random.sample()返回的也是一个列表（长度为1）

2.zip函数轻松合并列表，range对象竟然无视内存

以下程序可以实现，从给定的姓氏与名字列表中，随机生成姓名列表

from random import sample,randint
姓=['李','陈','黄','宋','瓦',]
名=['灵','悦','愉','茉','黛','清','风','知','礼']
#名=名*2   #如果名字中需要叠字，那么可以将列表中的每个字重复，然后让程序从有重复字的名字列表中抽取名字
名单=[]

'''
通过join()方法连接字符串，随机抽取一个姓，随机抽取1个或二个名'''

i=0
while i < 20:
    姓名=''.join(sample(姓,1)+sample(名,randint(1,2)))
    if 姓名 not in 名单:    #避免重复，只有在得到新的姓名组合时才添加进列表
        名单.append(姓名)
        i+=1    #只有在每次得到一个新的姓名组合后才+1
print(名单)
#['黄灵黛', '黄悦灵', '陈知', '瓦清悦', '李灵悦', '李悦', '李礼', '黄风悦', '瓦风悦', '陈茉', '宋黛', '宋风知', '黄风愉', '宋茉', '李灵', '陈悦知', '陈知黛', '瓦悦清', '瓦茉', '李知']

zip()方法可以将两个或多个列表，相同位置的元素拼合，得到一个新的列表，列表中的每个元素都是元组，元组中包含每个指定列表中对应位置的元素，新列表的长度取决于之前所有个列表中最短列表的长度

更准确的说法是，zip()返回的，是一个迭代器（iterator），“迭代”或者说“iterate”可以理解为“按某种顺序逐个访问”，比如用for循环遍历一个列表内的每个元素，那么这个for循环的过程就可以被称作迭代的过程，因为列表支持使用for循环对里面的元素进行逐个访问，因此也可以将列表看做可迭代对象，包括列表、字典‘字符串等容器都可以被“迭代”，因此Python中的所有容器都属于“可迭代对象”，可迭代对象不仅仅包括各种“容器”，好包括range、zip等其他各种类型

姓=['李','陈','黄','宋','瓦',]
名=['灵','悦','愉','茉','黛','清','风','知','礼']

#名=名*2   #如果名字中需要叠字，那么可以将列表中的每个字重复，然后让程序从有重复字的名字列表中抽取名字
名单=zip(姓,名)
for n in 名单:
    print(n)

#返回结果
'''
('李', '灵')
('陈', '悦')
('黄', '愉')
('宋', '茉')
('瓦', '黛')
'''


print('-----------------')
姓=['李','陈','黄','宋','瓦',]
名=['灵','悦','愉','茉','黛','清','风','知','礼']

#名=名*2   #如果名字中需要叠字，那么可以将列表中的每个字重复，然后让程序从有重复字的名字列表中抽取名字
名单=zip(姓,名)
for n in 名单:
    print(''.join(n))
'''
李灵
陈悦
黄愉
宋茉
瓦黛'''

range返回的并非“列表”而是一个“range”对象，直接print，只会显示起始值（从0开始）到结束值，比如range(10)返回的是range(0, 10)，可以使用for循环遍历range对象中的每个数值，也可以通过list()方法将range对象转换为列表。

值得注意的是，x=list(range(1000000000000))可能会挤满计算机的内存，但x=range(1000000000000)

却能正常运行，甚至提取其中任意一个元素，比如print(x[100])会返回100

3. 生成式长得帅跑得快，迭代器拿时间换空间

“列表生成式”是专门用来生成列表的表达式，它的运算速度比普通循环更快

在已有一个列表的情况下，想要得到基于第一个列表每个数值乘以10的第二个列表，也就是说第二个列表中每个元素是第一个列表中对应位置的元素的10倍，第一个方法是

l1=[100,200,300]
l2=[]
for i in l1:
    l2.append(i*10)
print(l2)

由于非常常用，Python为此提供了更精简的写法，先将要填入列表的内容填入方括号，然后将循环规则（不包含冒号）写入方括号，这样就得到了一个列表生成式

需要注意的是，最外面必须要是方括号，因为要生成的是一个列表，在方括号中，要先写循环结果，后写循环规则

l1=[100,200,300]
l2=[i*10 for i in l1]
print(l2)

#案例2
from math import sin
l1=[100,200,300]
l2=[sin(i) for i in l1]
print(l2)

for循环不仅仅能遍历列表，可以遍历任何可迭代对象，因此列表生成式也具有同样的功能

a=[i/10 for i in range(1,100)]
print(a)
#相当于以下for循环
for i in range(1,100):
    a.append(i/10)
#运行后得到的结果是[0.1,0.2......9.9]

for循环能用的语法，生成式里都可以使用

with open('1.txt','r') as f:
    原始文本列表=f.readlines()
整理后列表=[s.split(',') for s in 原始文本列表[1:]]    #从第二行开始读取，每行内容以逗号进行分割
关键信息=  [x[0],float(x[5]),int(x[6].strip() for x in 整理后列表]  #仅获取其中个别列的数据，并针对性的进行格式化
print(关键信息)

此处为语雀视频卡片，点击链接查看：[9.4]–第十四回 生成式长得帅跑得快，迭代器拿时间换空间.mp4

在 Python 中，next() 是一个内置函数，用于从迭代器中获取下一个元素。它允许您逐步访问迭代器中的元素，一次获取一个，允许使用next()逐个访问的统称为“迭代器”，但最好使用for循环访问迭代器，因为next不仅写法繁琐，而且最后一次访问时会有异常。

next()和for都只能向后逐个读取，不能回头读取前面的元素，所以迭代器中的元素一旦被读取过，就再无法重新读取。

有两种方式可以编写迭代器，第一种是定义一个类，然后使用next等等方法，，这种方法生成的迭代器就叫做“普通迭代器”iterator，例如zip对象，第二种方法是使用yieled关键字或圆括号生成式写出的代码，也叫做迭代器，但因为写法比较特殊，所以算作迭代器中的子类，叫做生成器（generator）,例如x for x in [1,2,3]

可迭代对象包括：常见容器（列表、字典、集合等）、range对象、迭代器（iterator）以及其他可迭代对象

迭代器（包含子类生成器）以及其他可迭代对象，一般不允许通过下标的方式直接引用指定位置的元素，而必须使用nexy()函数从第一个开始逐个找到后面的元素，而且与其他可迭代对象不一样的地方时，迭代器、生成器里面所有的元素都只能访问一次，一旦访问一次，就不能回头重新找到它，用完之后，必须重新定义一边，才能重新使用

4.字典也有生成式，却拿空间换时间

可以使用dict()方法将一个列表转换成字典，但是被转换的列表必须是每个元素都包含两个数据的列表，才可以直接构造字典对象，否则无法转换

a=[['a',100],['b',200],['c',300]]
d=dict(a)
print(d)

另一个将列表转换为字典的方法是，先用zip()方法合并两个列表每个位置对应的元素，虽然zip(）方法生成的对象不是列表，但依然可以被dict()所转换

zip()的功能是：将多个可迭代对象（包括列表、元组、字符串）内的对应位置的元素打包成一个个元组，并返回一个由这些元组所组成的迭代器

a=['a','b','c']
b=[1,2,3]
d=dict(zip(a,b))
print(d)    #{'a': 1, 'b': 2, 'c': 3}

.count()方法可以统计一个可迭代对象中，某个元素在里面出现了多少次，比如：

fruits = ('apple', 'banana', 'orange', 'apple', 'grape', 'apple')
count = fruits.count('apple')
print(count)  # 输出: 3

以下代码通过zip、count以及dict方法，实现对列表中每个元素出现次数的统计，并且将每个单独的元素与其出现的次数生成一个字典

i=['l','h','c','c']
b=[i.count(n) for n in i] #每次遍历列表中的元素，都返回该元素在列表中出现的次数，最后将每个元素出现的次数生成一个列表
print(b)    #[1, 1, 2, 2]

d=dict(zip(i,b))    #将两个列表进行zip，然后通过zip对象生成字典，字典会去除重复建，每个键只保留一个
print(d)    #{'l': 1, 'h': 1, 'c': 2}

.fromkeys()是字典类对象的方法，用于创建一个新的字典，给它一个列表作为参数，它会将列表中的每个元素，作为字典中的键放置在字典中，如果不设置默认值，那么在新生成的字典中，所有的键对应的值都是None，

需要注意的是，直接使用fromkeys()并不会对字典对象本身的内容进行改变，而是需要将其赋值给其他的对象，就算对一个已有内容的字典使用formkeys方法，返回的结果也不会包含该字典已有的内容，所以fromkeys方法一般都是针对空字典{}进行使用

fromkey方法无法将一个二维列表转换成字典，二维列表指的是，列表中的每个元素也都是列表，在fromkeys看来，所有的列表都是一维列表，如果在fromkeys的方法中填入二维列表作为参数，那么二维列表中的单个列表元素会作为字典的键，但Python中又规定只允许使用不可变对象作为字典的键，而列表属于可变对象，因此程序会报错

a=['a','b','c','d']
d={}
d=d.fromkeys(a)	#需要进行赋值，才能修改d的内容
print(d)	#{'a': None, 'b': None, 'c': None, 'd': None}

可以直接对一个空字典，也就是两个花括号，使用.fromkeys()方法

a=['a','b','c','d']
d={}.fromkeys(a)    #直接对一个空字典使用.fromkeys()方法
print(d)

可以给指定新字典的默认值，只需要给.fromkeys()方法加入第二个参数

a=[1,2]
b={}.fromkeys(a,'v')
print(b)    #{1: 'v', 2: 'v'}

fromkeys方法经常被用来创建一个初始字典，然后再使用循环等结构，修改每个键对应的值

需要注意的是，通过for循环来遍历字典中的内容，每次读取只会得到每一个键，并不会得到值，想要通过for循环得到每个键的值，可以使用以下代码：

d={"a":1,"b":2,"c":3}
for i in d:
    print(d[i])

另一个方法是，for i in 字典.values():

通过.fromkeys()方法得到列表中每个元素出现的次数，并创建一个子弹

a=[1,1,2,2,2,3,3,3]
d={}.fromkeys(a,0)#通过列表a创建字典，后者的每个元素所做字典的键，每个键的默认值为0
for k in d:
    d[k]=a.count(k) #字典中每个键的值 等于 列表中每个元素出现的次数
print(d)    #{1: 2, 2: 3, 3: 3}

如果formkeys的第二个参数是一个列表，也就是生成的新字典都以这个列表作为默认的值，根据前面所学的内容，这个作为默认参数的列表会得到一个内存地址，而新字典中每个键的默认值都指向同一个内存地址，如果修改列表，意味着该字典所有的键的值都会改变，因为它们都指向同一个内存地址，因此Python官方建议，不要使用可变对象比如列表作为默认值。

字典生成式

与列表生成式一样的原理

d={x:x*x for x in a}

传统写法：

stock_data = [
    ['AAPL', 135.52, 133.43, 134.16, 135.37, 1000000, '2023-05-19'],
    ['GOOGL', 2426.31, 2415.52, 2422.89, 2424.98, 750000, '2023-05-19'],
    ['AMZN', 3280.94, 3256.43, 3265.79, 3278.39, 500000, '2023-05-19'],
    ['MSFT', 248.15, 246.91, 247.52, 248.06, 900000, '2023-05-19'],
    ['TSLA', 605.12, 595.50, 600.00, 602.89, 600000, '2023-05-19']
]
d={}
for i in stock_data:    #遍历列表中每一个列表，i会是列表中的小列表
    d[i[0]]=i[6]    #左边，小列表中的第一个值作为字典的键，列表中第7个值作为值
print(d)    #{'AAPL': '2023-05-19', 'GOOGL': '2023-05-19', 'AMZN': '2023-05-19', 'MSFT': '2023-05-19', 'TSLA': '2023-05-19'}

字典生成式的写法：

stock_data = [
    ['AAPL', 135.52, 133.43, 134.16, 135.37, 1000000, '2023-05-19'],
    ['GOOGL', 2426.31, 2415.52, 2422.89, 2424.98, 750000, '2023-05-19'],
    ['AMZN', 3280.94, 3256.43, 3265.79, 3278.39, 500000, '2023-05-19'],
    ['MSFT', 248.15, 246.91, 247.52, 248.06, 900000, '2023-05-19'],
    ['TSLA', 605.12, 595.50, 600.00, 602.89, 600000, '2023-05-19']
]
#字典生成式
d={x[0]:x[5] for x in stock_data}	#for之前，左边是小列表的键与小列表的值的位置，右边是循环方法

print(d)    #{'AAPL': 1000000, 'GOOGL': 750000, 'AMZN': 500000, 'MSFT': 900000, 'TSLA': 600000}

通过字典生成式的方法，来统计列表中每个元素出现的次数，并生成字典

传统写法：

a=['a','b','c','d','e','e']
d={}
for i in a:
    d[i]=a.count(i)
print(d)

字典生成式的写法

a=['a','b','c','d','e','e']

d={i:a.count(i) for i in a} #遍历列表中每个元素，以每个元素作为键，加上冒号表示字典，冒号右边是次数统计，for 之后是循环规则
print(d)	#{'a': 1, 'b': 1, 'c': 1, 'd': 1, 'e': 2}

列表生成式允许if判断语句，字典生成式同样也支持，如果有if，需要放在for后面

只找出出现2次及以上的元素放入字典中

传统写法：

a=['a','b','c','d','e','e']
d={}
for  i in a:
    if a.count(i)>=2:
        d[i]=a.count(i)
print(d)    #{'e': 2}

字典生成式写法a:

a=['a','b','c','d','e','e']
d={i:a.count(i) for i in a if a.count(i)>=2}
print(d)    #{'e': 2}

字典生成式与列表生成式，与传统的for循环并不完全相等

5.字典元素任遍历，元组赋值巧解包

字典.values()可以得到包含该字典的所有值的一个可迭代对象，class ‘dict_values’，在早期Python版本中，它属于列表，但它不支持索引，因此现在已经不再是列表，也不支持使用next()函数，因此也不是迭代器，之所以它可以被看做是可迭代对象，因为支持使用for循环来遍历

字典.values()返回的对象属于dictview类型

统计一个列表中，出现X次数的元素有多少个，然后生成字典

#统计列表中，出现N个的分别有几个元素，将统计结果生成字典，键对应次数，值对应元素数量
a=['a','b','c','d','e','e'] #列表
d={i:a.count(i) for i in a} #生成一个字典，得到每个元素以及每个元素出现的次数
print(d)    #{'a': 1, 'b': 1, 'c': 1, 'd': 1, 'e': 2}

f=list(d.values())  #将上面字典的所有值转换成一个列表，也就是每个元素出现的次数
print(f)    #[1, 1, 1, 1, 2]
d2={k:f.count(k) for k in f}    #用字典生成式生成一个字典，左边是单个元素出现的次数，右边是出现这个次数的元素有多少个
print(d2)   #{1: 4, 2: 1}

统计一个列表中，出现次数最多的元素是哪些

#统计列表中，出现次数最多的元素出现了是哪些，并且出现了多少次，生成字典
a=['a','b','c','d','e','e','f','f'] #列表
d={i:a.count(i) for i in a} #先用字典生成式得到每个元素出现的次数
print(d)    #{'a': 1, 'b': 1, 'c': 1, 'd': 1, 'e': 2, 'f': 2}
m=max(d.values())   #获取字典中所有的值，通过max()得到最大的值是哪一个
d2={i:d[i] for i in d if d[i]==m}   #利用字典生成式，遍历字典中每个元素，如果值等于m，那就将这对键值放入新的字典
print(d2)   #{'e': 2, 'f': 2}

字典.values()可以返回字典中所有的值

字典.keys()可以返回字典中所有的键

字典.items()也可以返回一个dictview，其中每个元素都是一个元组，每个元组包含字典中的一个键和值，如果直接print，那么显示效果是【dict_items([(‘e’, 2), (‘f’, 2)])】，但可以通过for循环取出里面的元组【for i in d2.items():print(i)】，可以逐一得到每个元组（原字典的键与值）

通过字典的.items()得到该字典的所有键值：

p={"name":"lingjie","age":"25"}
for i in p.items():
    print(i[0],i[1])

更精简的写法：

p={"name":"lingjie","age":"25"}
for x,y in p.items():
    print(x,y)
'''
输出结果：
name lingjie
age 25
'''

反向字典，也就是键值互换

p={"name":"lingjie","age":"25"}
p2={y:x for x,y in p.items()}   #让xy等于字典的键值，然后让y等于键，x等于值
print(p2)   #{'lingjie': 'name', '25': 'age'}

解包

Python中的解包指的是，将可迭代对象（）元组、字典、列表、集合等），将里面的元素直接拿出来赋值给其他变量，比如上面的反向字典案例，让xy得到了字典中的元组的两个值

a,b=(1,2)

解包操作可以在for循环中使用，for a,b in 字典.items()相当于让a与b得到字典的键值

解包操作时，等号右边甚至可以不需要括号，实现一条语句将多个值赋给多个变量，这种操作也被称为“多元赋值语句”，但需要注意的是，等号左右两边的元素数量需要一致：

a,b=1,2

这种方法也可以交换两个变量之间的值：a,b=b,a

解包操作的右边也可以是一个字符串：a,b,c=’甲乙丙’

如果解包操作等号右边是字典，那么等号左边的变量将被赋值字典的键

一般来说，解包操作中等号左右两边的数量要保持一致，如果不一致，在python2中肯定会报错，但是Python3中，如果左边的变量数量少于右边的值的数量，可以为左边其中任意位置的一个变量前加上*号，

在其他的变量都被赋值完成之后，最后一个被加上*号变量将得到右边剩余所有的值（列表），即使剩余1个元素，也会被作为一个列表返回给加上*号的变量，

如果*号的变量位置在中间，那么左边第一个变量会被赋值左边第一个值，左边最后一个变量会被赋值右边最后一个值，右边中间剩余的变量会被赋值给左边加*号的变量yi

x,y,*z=100,200,233,666
print(x)    #100
print(y)    #200
print(z)    #[233, 666]

一组分数中，去掉一个最高分，去掉一个最低分，计算平均值：

a=66,233,3,4,5,6,7
最低分,*有效分,最高分=sorted(a)  #对a列表内的数值进行从小到大排序，然后解包，最低分与最高分得到列表开头与末尾的值，中间的有效分得到剩下所有的数值
print(最低分)
print(最高分)
print(有效分)
平均分=sum(有效分)/len(有效分)   #对列表进行求和，然后处于列表中的元素数量，得到列表的平均值
print(平均分)

6.集合运算统计名单变动，Counter与chain简化数

Python中集合的3个重要特性是：

不允许出现重复元素/元素排列无特定顺序/只能包含不可变类型的元素

只能包含不可变类型的元素意味着，集合的元素可以是字符串、数值、元组，但不能是列表或另外一个集合

可以通过set()方法将一个列表/元组/字典转换成集合，如果将字典转换成集合，那么集合中只会包含字典中所有的键，此外，zip、range等可迭代对象也能通过set()方法转换成集合

将一个列表转换成集合再转换回列表，可以去除原始列表中的重复值

a=['中国','美国','意大利']
b=['cn','usa','it']
c=zip(a,b)  #zip()的功能是将两个列表对应位置的元素打包成一个元组，所有的元组合并成一个zip可迭代对象
print(c)    #<zip object at 0x000001D4A69EF8C0>
s=set(c)
print(s)    #{('美国', 'usa'), ('意大利', 'it'), ('中国', 'cn')}

Python中的集合可以用来计算交集/差集/并集

交集：

a={1,2,3}
b={2,3,3}
c=a&b   # 【&】符号取交集，也就是两个集合中都有的元素
print(c)    #{2, 3}

如果两个集合之间没有相同的元素，那么取交集后会得到一个空集合，但是因为空花括号{}表示一个空字典，因此空集合会被set()来表示：

判断变量a是否属于空集合：

if a==set():

或者

if len(a)==0:

又或者直接写成 if a:

并集：

并集运算符【|】

a={1,2,3}
b={2,3,3}
c=a|b   # 【|】符号取并集，取得a与b中所有出现过的元素（会过滤掉重复的元素）
print(c)    #{2, 3}

差集：

差集运算符【-】

可以得到【-】号前面的变量有，而右边的变量没有的元素

a={1,2,3}
b={2,3,6}
c=a-b   # 【-】符号取差集，取得左边变量有，而右边变量没有的元素
print(c)    #{2, 3}

通过上月在职员工名单与本月在职名单的列表，得到离职员工与新员工的列表

import xlwings as xw
app=xw.App()    #创建一个Excel应用程序对象
wb=app.books.open('names.xlsx') #指定工作簿
ws=wb.sheets[0] #指定工作表

n1=ws.range('a2:a39').value #得到工作表中第一列数据
n2=ws.range('b2:b35').value

#获取离职员工列表
#取差集，也就是上月有但本月没有的员工
离职员工=set(n1)-set(n2)

#获取本月新员工列表
#取差集，本月有，但上月没有的员工
新员工=set(n2)-set(n1)

ws.range('c2').options(transpose=True).value=list(离职员工)#将集合转换成列表，然后设置transpose以一列的方式从指定的单元格位置开始写入
ws.range('d2').value=list(新员工)     #如果有名.options(transpose=True)，那么这个列表会以横排的方式从指定的单元格开始写入

wb.save('names.xlsx')
wb.close()
app.quit()

集合的其他方法与运算符

方法/运算符	作用	示例
add	向集合内添加元素	s.add(元素)
remove	从集合内删除指定数值的元素	s.remove(x)
pop	让集合删除并返回该元素（由Python决定删除哪个元素，不能由程序员空值）	x=s.pop()
clear	移除集合内所有元素	s.clear()
issubset	判断本集合是否是另一个集合的子集，也就是另一个集合是否包含本集合的所有元素，返回True或False	a.issubset(b)
<=	同issubset	a<=b
issuperset	判断本集合是否是另一个集合的父集，也就是本集合是否包含另一个集合的所有元素	a.issuperset(b)
>=	同issuperset	a>=b
union	返回本集合与其他集合的并集	a.union(b,c,d)
intersection	返回本集合与其他集合的交集	a.intersection(b,c)
difference	返回本集合与其他集合的差集	a.difference(b,c)
isdisjiont	判断本集合与其他集合的交集是否为空（即不 相交）	a.isjiont(b)

Python内置了collections库，其中的Counter是一个计数器，可以用它来得到一个可迭代对象中每个元素出现的次数，返回的是一个类似字典的Counter类型的对象，用法与字典完全相同

from collections import Counter

a=['apple','banana','apple']
b=Counter(a)
print(b)    #Counter({'apple': 2, 'banana': 1})

两个Counter对象之间可以直接相加，相同键的值会进行求和，其他键也会被放入相加的结果中

两个Counter对象之间也可以相减，但是如果其中一个元素相减后得到的值为负数，就不会出现在相减后的结果中，也就是说Counter减法中，只保留正数的结果，减数中出现了被减数中没有的元素，该元素也不会出现在结果中，因为0-任何正数都是负数

Counter对象也可以通过【&】与【|】符号做交集与并集运算

max()函数在处理二维列表时，并不会取出每一个单独的元素作比较，而是将二维列表中的每个小列表的第一个元素取出来作比较，返回第一项最大的子列表，如果第一项都相同，则顺次比较第二项，以此类推

a=[[1,5],[3,4],[2,1,3]]
print(max(a))   #[3, 4] 所有子列表中第一个二元素最大的是[3,4]

通过列表生成式，得到二维列表中数值最大的元素

a=[[1,5],[3,4],[2,1,3]]
b=[max(x) for x in a]   #得到每个子列表中的最大的值，返回一个新列表
print(b)    #[5, 4, 3]
c=max(b)
print(c)    #5  第二次比较

更精简的写法：

a=[[1,5],[3,4],[2,1,3]]
b=max([max(x) for x in a])
print(b)    #5

Python中有一个itertools模块，其中有一个函数是itertools.chain，可以将多个可迭代对象连接在一起，形成一个新的单一的迭代器，它按照它们在参数中出现的顺序依次返回元素

也就是说，itertools.chain可以将二维列表转换成一维列表

from itertools import chain

list1 = [1, 2, 3]
list2 = [4, 5, 6]
tuple1 = (7, 8, 9)

x=chain(list1,list2,tuple1)
print(x)    #<itertools.chain object at 0x00000122B4CCCFA0> 返回一个chain类型的可迭代对象
x=list(x)   #可以转换成列表
print(x)    #[1, 2, 3, 4, 5, 6, 7, 8, 9]

通过itertools模块中的chain来得到二维列表中数值最大元素的方法

from itertools import chain

list1 = [1, 2, 3]
list2 = [4, 5, 6]

li=[list1,list2]

x=list(chain(*li))   #解包写法，相当于chain(li[0],li[1])
print(x)    #[1, 2, 3, 4, 5, 6]
print(max(x))   #得到最大值6

当你调用chain(*li)时，*li使用了解包的写法，这里的*li是一个包含两个列表list1和list2的列表。

解包操作*li将li中的元素拆分开，相当于chain(list1,list2)，chain函数是Itertools模块中的一个函数，它的作用将多个可迭代对象连接在一起，返回一个迭代器，按照它们在参数中出现的顺序依次输出元素。

在上述例子中，chain(list1,list2)会将list1和list2连接在一起，产生一个包含list1和list2所有元素的迭代器，接着，通过list()函数继昂这个迭代器转换成列表，赋值给x

7.拷贝容器细分深与浅，可变对象难做默认值

如果函数的参数默认值是可变对象（列表、集合、字典等），该默认值在程序运行之初的“编译阶段”就已经被创建， 并一直保留在内存中

所以每次调用函数，修改的都是同一个默认值对象

最好的方法，就是不使用可变对象作为函数的默认值

def add_End(t=[]):  #创建一个函数，默认参数是一个空列表
    t.append('END') #为参数加上一个'END'元素
    return t

if __name__=="__main__":
    x=add_End()
    print(x)    #['END']

    y=add_End()
    print(y)    #['END', 'END'] #返回2个END

    z=add_End()
    print(z)    #['END', 'END', 'END']  #返回3个END
#每次调用函数，用的都是同一个内存拷贝，而不是创建一个空的list对象，所以调用了同样的函数，但返回的结果却不一致

新手常见的错误还有误将浅拷贝当做深拷贝

a=['a','b','c']
b=a #a与b指向同一个内存地址
a[1]=1  #修改a列表中的元素，因为指向同一个内存地址，因此b也发生了改变
print(b)    #['a', 1, 'c']

。copy()方法属于浅拷贝，浅拷贝可以解决上面的问题，但并不完全，如果a中的一个元素是列表，该类问题还是会出现

a=['a','b','c']
b=a.copy()  #复制a的内容到新的内存地址并链接到b
a[0]=1  #修改a后b不会发生变化
print(b)    #['a', 'b', 'c']

print('-----------------')
a=['a',['b','c'],'d']
b=a.copy()
a[1][0]='test'  #修改a列表里的小列表里的第一个元素，b也跟着发生变化，因为小列表指向的都是同一个内存地址
print(b)    #['a', ['test', 'c'], 'd']

Python自带的copy模块中有一个deepcopy，不仅能拷贝列表的第一层，还能拷贝列表的子列表甚至子列表的子列表

from copy import deepcopy

a=['a',['b','c'],'d']
b=deepcopy(a)
a[1][0]='test'  #修改a子列表中的第一个元素
print(a)    #['a', ['test', 'c'], 'd']  #a被改变
print(b)    #['a', ['b', 'c'], 'd'] #b保持不变

深拷贝不仅对列表有效，对所有嵌套的容器都能使用，包括字典等

a={"a":[1,2],"b":[10,11]}
b=a.copy()
b['b'][0]=6 #修改b字典中b键的值的第一个元素
print(a)    #{'a': [1, 2], 'b': [6, 11]}    #a跟着被改变
print(b)    #{'a': [1, 2], 'b': [6, 11]}

from copy import deepcopy
a={"a":[1,2],"b":[10,11]}
b=deepcopy(a)
b['b'][0]=6 #修改b字典中b键的值的第一个元素
print(a)    #{'a': [1, 2], 'b': [10, 11]}    #a没有跟着被改变
print(b)    #{'a': [1, 2], 'b': [6, 11]}

一些新手可能会通过乘法制作二维列表

对一维列表使用乘法，可以使里面的元素重复多少次

a=[1,2]
b=a*2
print(b)    #[1, 2, 1, 2]

对二维列表使用上述的乘法，看起来能起到同样的效果，但是，如果修改了二维列表中的第一个子列表，另一个被复制出来的子列表中的内容也会跟着改变，因为它们都被指向了同一个内存地址，因此这种用法是不规范的

a=[1,2]
b=a*2
print(b)    #[1, 2, 1, 2]

c=[b]*2
print(c)    #[[1, 2, 1, 2], [1, 2, 1, 2]]

c[0][0]=6
print(c)    #[[6, 2, 1, 2], [6, 2, 1, 2]]   #修改第一个子列表，第二个子列表也会跟着改变

通过id()可以查看列表或子列表的内存地址

通过列表生成式生成二维列表

b=[[0,0,0] for i in range(2)]
print(b)    #[[0, 0, 0], [0, 0, 0]] 通过列表生成式生成二维列表

#实现同样功能但更精简的代码
b=[[0]*3 for _ in range(2)] #写成_因为它没有任何意义只是用来控制循环次数
print(b)    #[[0, 0, 0], [0, 0, 0]]

8.Numpy玩转二维结构，Pandas搞定统计分析

Numpy之核心结构：ndarray

ndarray是N-dimensional array（N 维度 数组）的缩写

可以使用array()将列表等容器转换为ndarray类型的数组

import numpy as np
x=[1,2,3]
a=np.array(x)
print(a)    #[1 2 3]
print(type(a))  #<class 'numpy.ndarray'>

将ndarray数据看做矩阵，可以进行整体的数学运算

import numpy as np
x=[1,2,3]
a=np.array(x)
print(a)    #[1 2 3]
print(type(a))  #<class 'numpy.ndarray'>

b=a*3   #进行数学运算而不是复制3次列表
print(b)    #[3 6 9]

import numpy as np
x=[1,2,3]
a=np.array(x)
print(a)    #[1 2 3]
print(type(a))  #<class 'numpy.ndarray'>

b=a*3   #进行数学运算而不是复制3次列表
print(b)    #[3 6 9]

c=b*2-a     #两个array对象之间也可以进行数学运算
print(c)    #[ 5 10 15]

列表=array对象.tolist() 可以将一个array对象转换成Python中的普通列表

不仅仅是加减乘除，array对象还可以进行其他数学运算，比如求平方： array对象**2

import math模块后，不能调用math模块中的某些方法来进行更高级的运算，因为某些方法要求输入的参数是数字而不是其他对象

但是Numpy模块本身，就已经提供了许多函数对数组进行统计运算，比如np.log(ndarray对象)或者np.sin(ndarray对象)等，

除了各种数学计算还属外，Numpy还提供了各种统计函数

函数名	函数功能
sum	计算总和
mean	计算平均值
average	计算加权平均值
std	计算标准差
var	计算方差
min	取最小值
max	取最大值
argmin	返回最小值元素所在的下标位置
argmax	返回最大值元素所在的下标位置
ptp	计算极差（最大值与最小值之间的差）
median	计算中位数
corrcoef	计算相关系数
percentile	计算百分位数

import numpy as np
x=[10,100,60]
a=np.array(x)
print(np.max(a))    #100 得到最大值

ndarray对象可以通过reshape()方法从一维对象转换为二维对象，在转换时数字要匹配元素数量（比如20个元素的ndarray对象可以转换为2行10列，但不能转换成6行1列），否则会报错

二维对象还可以进行reshape成另一个二维对象

对二维对象使用统计方法，就像对一维对象使用统计方法一样

ndarray对象.T 可以进行行列转置，也就是行变成列，列变成行

import numpy as np
a=np.arange(20) #得到一个拥有20个数值元素的ndarray对象
print(a)    #[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]
b=a.reshape(2,10)   #转换成2行10列，或者说分成2组，每组10个对象
print(b)
'''
[[ 0  1  2  3  4  5  6  7  8  9]
 [10 11 12 13 14 15 16 17 18 19]]'''

c=b.reshape(1,20)   #二维数组还可以再重新reshape()
print(c)    #[[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]]

print(np.max(b))   #返回19 #二维数组使用统计方法，就像对一维数组使用统计方法一样

d=c.T   #转置，行变成列，列变成行
print(d)
'''
[[ 0]
 [ 1]
 [ 2]
 [ 3]
 [ 4]
 [ 5]
 [ 6]
 [ 7]
 [ 8]
 [ 9]
 [10]
 [11]
 [12]
 [13]
 [14]
 [15]
 [16]
 [17]
 [18]
 [19]]'''