map() 函数
map(fun,iter)函数主要用于让一个可迭代对象进行对应的函数运算,第一个参数是函数对象,负责运算可迭代对象的每个参数,第二个参数是可迭代对象,给函数对香港提供需要的参数和变量;以通过map对象求列表各个值得平方数与立方数为例:
def square(lst):
return map(lambda x:x**2,lst)
print(list(square([2,5,6])))
# 定义一个函数,接收外部传过来的一个列表参数,然后对列表的每个参数进行平方运算
print(list(map(lambda x:x**3,[9,8,7])))
# map() 函数会返回一个map对象这个对象可以被转换为list对象
通过map()函数实现两个列表之间的向量运算
def mul_lists(lst1, lst2):
return map(lambda x, y: x * y, lst1, lst2)
print(mul_lists([1,2,3],[4,5,6]))
print(list(mul_lists([1,2,3],[4,5,6])))
# 接收两个列表参数,并将两个列表参数都作为可迭代对象直接传入map函数中(两个参数之间用逗号“,”隔开)
案例:选出字典中最大的元素
需求是在一组字典中,选出值最大的键值对;首先我们可以通过 map() 函数以匿名函数的方式进行比较(挑选出值比较大的键值对)然后将键值对以列表形式返回即可
# 测试用例:可以通过map函数用返回键值对的形式返回我们需要比较的参数(也就是值)
e = {'a':8,'b':6,'c':23}
print(map(lambda v:v[1],e.items())) # 输出 <map object at 0x0324A970> 返回的是一个map对象
# 需要注意的是在 dict 对象作为一个可迭代对象的时候,遍历的是dict.items()是其元素,而不是字典对象本身
print(list(map(lambda v:v[1],e.items())))
# 代码:选出字典中最大的元素并作为列表返回
def max_pairs(dict):
if len(dict) == 0:
return dict
max_val = max(map(lambda v:v[1],dict.items()))
return [item for item in dict.items() if item[1] == max_val]
r = max_pairs({'a': -10, 'b': 5, 'c': 3, 'd': 5})
print(r)
# 代码运行结果: [('b', 5), ('d', 5)]
一行代码将两个字典合并为一个字典
在python3.5之后可以通过下面这种方式将两个字典合并为一个字典
def merge_dict(dict1,dict2):
return {**dict1,**dict2}
print(merge_dict({'a':1,'b':5,'c':8},{'d':8,'e':6}))
# 如果两个字典里有键相同的元素,那么后一个字典里元素的值会替代前一个字典里元素中的值
print(merge_dict({'a':1,'b':5,'c':8},{'a':5,'b':23,'f':10}))
# 也可以直接打印合并(不通过函数):这一条比较废话
dict1 = {'a':55,'b':44,'c':203}
dict2 = {'e':88,'f':66}
print({**dict1,**dict2})
查找字典中第n个大(小)的元素
使用的函数是 nlargest 和 nsmallest 他们的第一个参数都是查找的数量(查找到第几个大,或者小的数目)第二个参数是可迭代对象;如果可迭代对象是字典,可以通过第三个参数:key = lambda 的方式遍历字典对象
from heapq import nsmallest,nlargest
def topn_dict(d,n):
return nlargest(n,d,key=lambda k:d[k])#通过匿名函数,把比较的标准定为字典里的键值对(遍历字典)
print(topn_dict({'a': 10, 'b': 8, 'c': 9, 'd': 10}, 2)) # 输出结果:['a', 'd']
nlargest() 与 nsmallest()
heapq模块中的两个函数
nlargest:找到集合(可迭代对象)中的最大的n个值;
nsmallest:找到可迭代对象中的最小的n个值;这两个函数的第一个参数是取到第几个(最大的值或者最小的值),第二个参数是可迭代对象(需要取值的集合),如果可迭代对象是字典,则会使用第三个参数,也就是key = lambda k:dict[k] 的形式遍历这个字典(取得键值对对象)
lst = [2,4,6,8,10,12]
print(nlargest(3,lst)) # [2,4,6]
print(nsmallest(3,lst)) # [12,10,8]
判断字符串是否是异位词
异位词:指的是相同字母的异序排列;简称:互为变位词
counter 函数可以统计字符串或者集合中每个字符出现的次数,函数中定义了,如果两个字符串的每个字符出现的次数相等,返回true;如果两个字符串中字符出现的频率不相等,返回false
from collections import Counter
def anagram(str1,str2):
# 如果两个词是异位词 返回 true 如果两个词语不是异位词,则返回false
return Counter(str1) == Counter(str2)
print(anagram('eleven+two', 'twelve+one'))
print(anagram('eleven', 'twelve'))
同样counter函数也可以用于进行统计
统计在一个多元素的可迭代对象或一个字符串中,对应数字或者字符出现的次数 并返回一个Counter对象
from collections import Counter
a = [1,2,3,4,5,6,7]
print(Counter(a)) # Counter({1: 1, 2: 1, 3: 1, 4: 1, 5: 1, 6: 1, 7: 1})
print(type(Counter(a)))
str = 'I LOVE AMERICA'
# Counter({'I': 2, ' ': 2, 'E': 2, 'A': 2, 'L': 1, 'O': 1, 'V': 1, 'M': 1, 'R': 1, 'C': 1})
print(Counter(str))
逻辑合并两个字典
通过collection包中的函数 ChainMap 实现逻辑合并两个字典并返回一个 ChainMap 对象 ;函数的两个参数分别表示两个需要合并成一个对象的字典
from collections import ChainMap
dic1 = {'a':1,'b':10}
dic2 = {'b':3,'d':15}
merged = ChainMap(dic1,dic2)
print(merged)
print(type(merged)) # <class 'collections.ChainMap'>
merged['b'] = 100
merged['d'] = 100
print(merged) # ChainMap({'a': 1, 'b': 100, 'd': 100}, {'b': 3, 'd': 15})
# 如果修改的值的哥字典中,有对应的键,那么修改第一个字典中对应的值;大怒如果第一个字典中没有对应的键,那么在第一个字典中添加对应的键值对(第二个字典始终不做变动)
列表切片
从随机生成的范围为:0--50的100个数字的序列中抽取前5个数存放在一个新的列表中
from random import randint
lst = [randint(0,50) for _ in range(0,100)]
print(lst[:5]) # [5, 10, 4, 4, 11]
# _ 作为 for 循环的变量;一般使用的前提是这个参数不会被调用(仅用作控制循环次数)
常用的列表切片方法:
a = [1,2,3,4,5,6,7,8,9,10]
# 一般是通过下标取数值
a[0:1] = [1]
a[0:2] = [1,2]
# 包含开头,不包含结尾。
a [:-1] # 从头一直到最后一个元素a[-1],但不包含最后一个元素。
word = 'I-love-China'
word[:2] # 取前两个
word[2:] # 除了前两个,其他全部选取
sample() 函数
sample()函数是random包中的函数;一般用于随机获取列表中的元素,有两个参数;第一个参数是可迭代对象(可以是列表,数组等数据集合)第二个参数是随机抽取的个数
from random import randint,sample
lst = [randint(0,50) for _ in range(0,100)]
lst_sample = sample(lst,10)
print(lst_sample) # [33, 6, 4, 0, 28, 39, 33, 13, 28, 16]
sample()函数也可以用来处理字符串,此时第一个参数是字符串对象,第二个参数是需要随机抽取的字符的个数,最后会返回一个列表对象作为结果
str = 'aaaannnhhhsuuiocnaibcubvaocns'
str_sample = sample(str,12)
print(str_sample) # ['a', 'a', 'a', 'v', 'n', 'b', 'a', 'c', 'n', 'o', 's', 'n']
print(type(str_sample)) # <class 'list'>
重洗数据集
使用的是random包中的shuffle函数这个函数的返回值是None,但是可以起到对数据集合重新排序的作用使用shuffle用来重洗数据集,值得注意shuffle
是对lst就地(in place)洗牌,节省存储空间
from random import shuffle,randint
lst = [randint(0,50) for _ in range(100)]
print(lst)
shuffle(lst)
print(lst)
print(shuffle(lst)) # 直接打印这个函数的返回值:None
生成坐标点
生成十个随机分布的坐标点:这个案例使用到的函数是random包中的uniform()函数;uniform() 方法将随机生成下一个实数,它在 [x, y] 范围内。其中x是随机数的最小值,生成的数据中可以包含这个值,y是随机数范围的最大值,生成的数据不包括这个值
from random import uniform
lst = [(uniform(1,10),uniform(1,10)) for _ in range(10)]
print(lst)
生成十个高斯分布的坐标点,使用gauss()函数,gauss(u,sigma)有两个参数:生成均值为u, 标准差为sigma;的满足高斯分布的值;但是gauss()函数只能生成对应的分布数字,需要生成坐标点列表的话要与zip函数连用
from random import gauss
x = range(10)
y = [2*xi*gauss(0,1) for xi in x]
points = list(zip(x,y)) # 通过 zip() 函数,将之前生成的range序列与在对应循环中生成的高斯分布的数字连接在一起,形成坐标点,因为zip返回的是zip对象,将其转换为列表之后可以看见高斯坐标点列表
print(points)
chain()函数
chain 函数可以用来串联多个容器(相同或者不同的数据集合)中的对象并返回一个chain对象;返回的对象是一个可迭代对象,这个对象可以被转换为列表,也可以被转换为其他数据集合
from itertools import chain
a = [1,2,3,4,5,6,7]
b = (8,9,5,6,3,4,2)
print(chain(a,b)) # <class 'itertools.chain'> 返回的是一个可迭代的对象
print(list(chain(a,b)))
生成逆序序列
可以使用range()函数生成一个逆序序列,这会用到range函数的第三个参数(也就是步长)当第三个参数为负值的时候,意味着是从后向前生成一个序列,这个数值的绝对绝对值意味着两个数值之间的间隔
x = range(10,-1,-1)
print(list(x))
y = range(20,-1,-2)
print(list(y)) # 同样 range 函数返回的是一个 range对象,这个对象可以被转换成列表
python 函数的五类参数
函数的五类参数分别为:位置参数、默认参数、可变位置参数、可变关键字参数、命名关键字参数
def fun(a,*b,c=10,**d):
print(f'a:{a},b:{b},c:{c},d:{d}')
fun(1,2,5,width=10,height=20) #输出:a:1,b:(2, 5),c:10,d:{'width': 10, 'height': 20}
fun(10,20,c=30) # a:10,b:(20,),c:30,d:{}
位置参数在调用的时候一定要有参数;关键字参数会把对应位置的参数解析成一个可遍历的元组对象;如果默认参数被赋值,那么调用默认参数的时候就采用赋值的数值,如果默认参数没有被赋值,调用的时候就采用函数自带的默认参数值;可变位置参数会把对应位置的参数解析为字典
函数的默认参数案例
def add_END(L=[]):
L.append('END')
return L
print(add_END([1,2,3,8,5,6]))
print(add_END([7,5,64,2,11,223]))
如果每次运行只调用一次这个函数,的确没什么问题,但是如果运行多次会导致关键词‘END’重复的额情况发生
def add_END(L = []):
L.append('END')
return L
print(add_END())
print(add_END()) # 输出:['END', 'END']
因为每次调用这个函数的时候,都执行了一次添加 ’END‘关键字;Python函数在定义的时候,默认参数L的值就被计算出来了,即[],因为默认参数L也是一个变量,它指向对象[],每次调用该函数,如果改变了L的内容,则下次调用时,默认参数的内容就变了,不再是函数定义时的[]了。(第二次调用的时候,函数的参数变成了[’END‘])
def add_END(L=None):
if L is None:
L = []
else:
L.append('END')
return L
print(add_END())
print(add_END([1,2,4,5,6])) # None || [1, 2, 4, 5, 6, 'END']
可变位置参数:可变参数意味着;传入的参数是可变的,可以是1个、2个到任意个,还可以是0个;被传入的参数都会被解析为一个成一个可以遍历的元组对象
python可变位置参数案例:计算1,2,3,4,5,6的平方和
def calc(*nums):
sum = 0
for n in nums: # 在调用这个参数的时候,可以不用加 *
sum += n * n
return sum
print(calc(1,2,3,4,5,6)) # 91;嗯,我就随便找几个数那么一算
如果是求列表中的各个元素的平方和(或者列表中的各个元素是函数的参数),可以采用列表名称[下标]的方式调用,或者直接在调用的时候输入:函数名(*列表名);以刚刚求平方和的函数为例
# 如果已经有一个list或者tuple,要调用一个可变参数
lst = [7,8,9,10,11]
# 可以使用列表(或者其他数据集合)下标的方法来表示,也可以直接将列表名变成一个可变参数
print(calc(lst[0],lst[1],lst[2],lst[3],lst[4]))
print(calc(*lst))
可变关键字参数:参数允许你传入0个或任意个含参数名的参数,这些关键字参数在函数内部自动组装为一个dict
def person(name,age,**kw):
print('name:', name, 'age:', age, 'others:', kw)
person('Tom',21,job='engineer',address='Hongkong')
在调用带有可变关键字的参数的时候,注意一定要以键值对的形式进行调用;在函数内部使用这个参数,不需要加上**
在使用 *kw 参数的时候,调用函数注意点
1、关键字参数会把对应位置的参数解析为字典;所以写的时候要做道键值一一对应
2、在调用的时候(程序中)使用kw不需要再加
3、可以向关键字参数的位置传入若干字数的关键字参数
和可变位置参数一样,当调用的参数是对应的字典中的键值对时可以通过引用字典名[键名]的方式给对应的参数赋值;也可以通过**字典名的方式调用整个字典中的键值对:以上述函数为例:
extra = {'gender':'female','job':'engineer','address':'Shanghai'}
person('katheine',22,gender=extra['gender'],address=extra['address'])
person('linda',23,**extra)
# 输出的结果为:
# name: katheine age: 22 others: {'gender': 'female', 'address': 'Shanghai'}
# name: linda age: 23 others: {'gender': 'female', 'job': 'engineer', 'address': 'Shanghai'}
命名关键字参数:命名关键字参数可以用来限制可变关键字参数的键值,如果要限制可变关键字参数的键(接受特定键名)可以使用命名关键字参数;命名关键字也可以有缺省值(类似于默认参数)从而简化调用
def person(name, age, *, city, job):
print('name:', name, 'age:', age, 'city:', city, 'job:', job)
person('TOM',21,city='Beijing') # 会因为缺少对应的键值 job 而报错,
person('TOM',21,city='Beijing',job='engineer')
一旦使用了命名关键字参数,调用函数时每个命名关键字的参数值都要给出,否则会报缺少参数的错误;也可以用一种缺省关键字的做法(类似于默认参数)用来避免多次录入同样的参数
def person(name, age, *, city, job='fireman'): # 在这里如果我们加上了 = ’fireman‘ 这个参数,没有赋值的键就会自动使用这个默认参数
print('name:', name, 'age:', age, 'city:', city, 'job:', job)
person('TOM',21,city='Beijing')
person('TOM',21,city='Beijing',job='engineer')
# name: TOM age: 21 city: Beijing job: fireman
# name: TOM age: 21 city: Beijing job: engineer