python----常用函数

常用函数

zip(*iters)

在 Python 3 中，为了节省空间，zip()返回的是一个tuple的迭代器，这也是我们为什么要调用list()将它强制转换成list的原因

>>>a=[1,2,3]
>>>b=['a','b','c']
>>>zip(a,b)
<zip object at 0x000001C1E3F52980>
>>>tuple(zip(a,b))
((1, 'a'), (2, 'b'), (3, 'c'))
>>>list(zip(a,b))
[(1, 'a'), (2, 'b'), (3, 'c')]
>>>c=[4,5,6]
>>>list(zip(a,b,c))
[(1, 'a', 4), (2, 'b', 5), (3, 'c', 6)]

如果我们传入zip()中的几个参数不等长，会有什么结果呢？zip()很灵活,如果几个参数不等长，那么它会取最短的那个参数的长度，然后再进行处理。至于那些超出最短长度的成员，就只好被舍弃掉了。

>>>a=[1,2,3]
>>>b=[1,2]
>>>list(zip(a,b))
[(1, 1), (2, 2)]
>>>a=[1,2,3]
>>>b=(1,2)
>>>tuple(zip(a,b))
((1, 1), (2, 2))

**enumerate(*iters)**

枚举可迭代对象元素，返回枚举对象，其中每个元素为包含下标和值的元组。

>>>list(enumerate('abcdef'))
[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd'), (4, 'e'), (5, 'f')]

range()

函数表达式的一般形式

range(start, stop[, step])

参数说明：

start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;

stop: 计数到 stop 结束，但不包括 stop。

例如：range（0， 5） 是[0, 1, 2, 3, 4]，没有5

step：步长，默认为1。

举例1：

>>>range(10)        # 从 0 开始到 10
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1, 11)     # 从 1 开始到 11
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> range(0, 30, 5)  # 步长为 5
[0, 5, 10, 15, 20, 25]
>>> range(0, 10, 3)  # 步长为 3
[0, 3, 6, 9]
>>> range(0, -10, -1) # 负数
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> range(0)
[]
>>> range(1,-10)
[]

举例2：

>>>a=range(0,10)
>>>10 in a
False

map()

描述：
map() 会根据提供的函数对指定序列做映射。
第一个参数接受一个函数名，后面的参数接受一个或多个可迭代的序列，把函数依次作用在list中的每一个元素上，得到一个新的list并返回。注意，map不改变原list，而是返回一个新list。
语法：
map(function, iterable, ...)
参数：
function ----> 函数
iterable ----> 一个或多个序列

举例：

1.当不传入function时，map()就等同于zip()，将多个列表相同位置的元素归并到一个元组：

map(None,[2,4,6],[3,2,1])
 
# 结果如下
[(2,3),(4,2),(6,1)]

def square(x):
    return x ** 2
 
map(square,[1,2,3,4,5])
 
# 结果如下:
[1,4,9,16,25]

3.通过map还可以实现类型转换,将元组转换为list,将字符转化为整数：

>>>list(map(int, ('1', '2', '3')))
[1, 2, 3]

>>>map(int,'1234')
[1,2,3,4]

4.提取字典中的key，并将结果放在一个list中

map(int,{1:2,2:3,3:4})
# 结果如下
[1,2,3]

lambda()

在Python中有两种函数，一种是def定义的函数，另一种是lambda函数，也就是大家常说的匿名函数。

lambda表达式的基本语法：

lamda arg1,arg2,arg3... : <表达式>

arg1 arg2 arg3为函数的参数。<表达式>相当于函数体。运算结果是：表达式的运算结果。

a = lambda x,y,z:x*y*z
print(a(1,2,3))  #6

同类型比较def函数

def a(x,y,z):
    result = x*y*z
    return result
print(a(1,2,3))

例子：

lambda x, y: x*y            # 函数输入是x和y，输出是它们的积x*y
lambda:None                    # 函数没有输入参数，输出是None
lambda *args: sum(args)        # 输入是任意个数参数，输出是它们的和(隐性要求输入参数必须能进行算术运算)
lambda **kwargs: 1            # 输入是任意键值对参数，输出是1

常见用法

1.将lambda函数赋值给一个变量，通过这个变量间接调用该lambda函数。如上面所示。

2.将lambda函数赋值给其他函数，从而将其他函数用该lambda函数替换。

# 为了把标准库time中的函数sleep的功能屏蔽(Mock)，我们可以在程序初始化时调用：
time.sleep=lambda x: None
# 这样，在后续代码中调用time库的sleep函数将不会执行原有的功能。
# 例如：
time.sleep(3)    # 程序不会休眠 3 秒钟，而是因为lambda输出为None，所以这里结果是什么都不做

3.将lambda函数作为参数传递给其他函数，也是一种高级的用法

lambda和map相结合

# 1、计算平方数，lambda 写法
map(lambda x: x ** 2, [1, 2, 3, 4, 5])
# 结果：
[1, 4, 9, 16, 25]	 

# 2、提供两个列表，将其相同索引位置的列表元素进行相加
map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
# 结果：
[3, 7, 11, 15, 19]

sorted（）

• 列表对象提供了sort()方法支持原地排序，而内置函数sorted()返回新列表，并不对原列表进行任何修改。
• sorted()方法可以对列表、元组、字典、range对象等进行排序。
• 列表的sort()方法和内置函数sorted()都支持key参数实现复杂排序要求。
• sorted() 函数对所有可迭代的对象进行排序操作

sort 与 sorted 区别：
1、sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
2、list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

sorted(iterable, cmp=None, key=None, reverse=False)

Sorted+lambda表达式组合

>>> persons = [{'name':'Dong', 'age':37}, 
{'name':'Zhang', 'age':40},
{'name':'Li', 'age':50},
{'name':'Dong', 'age':43}]
>>> print(persons)
[{'age': 37, 'name': 'Dong'}, {'age': 40, 'name': 'Zhang'}, {'age': 50, 'name': 
'Li'}, {'age': 43, 'name': 'Dong'}]
#使用key来指定排序依据，先按姓名升序排序，姓名相同的按年龄降序排序（使用两个参数的时候reserve参数失效，手动使用符号-进行调节）
>>> print(sorted(persons, key=lambda x:(x['name'], -x['age'])))
[{'age': 43, 'name': 'Dong'}, {'age': 37, 'name': 'Dong'}, {'age': 50, 'name': 
'Li'}, {'age': 40, 'name': 'Zhang'}]

sorted+itemgetter函数相结合

itemgetter函数用于获取对象的哪些维的数据，参数为序号。字典接受任何可哈希值（字典下标）。 列表，元组和字符串接受索引。

>>> phonebook = {'Linda':'7750', 'Bob':'9345', 'Carol':'5834'}
>>> from operator import itemgetter
>>> sorted(phonebook.items(), key=itemgetter(1))
#按字典中元素值进行排序
[('Carol', '5834'), ('Linda', '7750'), ('Bob', '9345')]
>>> sorted(phonebook.items(), key=itemgetter(0))
#按字典中元素的键进行排序
[('Bob', '9345'), ('Carol', '5834'), ('Linda', '7750')]

itemgetter函数用于获取对象的哪些维的数据，参数为序号。字典接受任何可哈希值（字典下标）。 列表，元组和字符串接受索引或切片。

>>> gameresult = [{'name':'Bob', 'wins':10, 'losses':3, 'rating':75.0},
{'name':'David', 'wins':3, 'losses':5, 'rating':57.0},
{'name':'Carol', 'wins':4, 'losses':5, 'rating':57.0},
{'name':'Patty', 'wins':9, 'losses':3, 'rating':72.8}]
>>> sorted(gameresult, key=itemgetter('wins', 'name')) 
#按'wins'升序，该值相同的按'name'升序排序
[{'wins': 3, 'rating': 57.0, 'name': 'David', 'losses': 5}, {'wins': 4, 'rating': 
57.0, 'name': 'Carol', 'losses': 5}, {'wins': 9, 'rating': 72.8, 'name': 'Patty', 'losses': 3}, {'wins': 10, 'rating': 75.0, 'name': 'Bob', 'losses': 3}]

itemgetter函数用于获取对象的哪些维的数据，参数为序号。字典接受任何可哈希值（字典下标）。 列表，元组和字符串接受索引或切片。

>>> gameresult = [['Bob', 95.0, 'A'], ['Alan', 86.0, 'C'], 
['Mandy', 83.5, 'A'], ['Rob', 89.3, 'E']]
>>> sorted(gameresult, key=itemgetter(0, 1))
#按姓名升序，姓名相同按分数升序排序
[['Alan', 86.0, 'C'], ['Bob', 95.0, 'A'], ['Mandy', 83.5, 'A'], ['Rob', 89.3, 'E']]
>>> sorted(gameresult, key=itemgetter(1, 0))
#按分数升序，分数相同的按姓名升序排序
[['Mandy', 83.5, 'A'], ['Alan', 86.0, 'C'], ['Rob', 89.3, 'E'], ['Bob', 95.0, 'A']]
>>> sorted(gameresult, key=itemgetter(2, 0))
#按等级升序，等级相同的按姓名升序排序
[['Bob', 95.0, 'A'], ['Mandy', 83.5, 'A'], ['Alan', 86.0, 'C'], ['Rob', 89.3, 'E']]

print()

输出函数：print()函数用于打印输出，格式为

print(objects, sep=' ', end='\n', file=sys.stdout, flush=False)

• objects – 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
• sep – 用来间隔多个对象，默认值是一个空格。

assert 表达式，[参数]

当表达式为真时，程序继续往下执行

当表达式为假时，抛出错误并且将参数输出

（可能看起来用处不太大）

reduce()

标准库functools中的reduce()函数可以将一个接受2个参数的函数以迭代的方式从左到右依次作用到一个序列或迭代器对象的所有元素上。

from functools import reduce
seq=[1,2,3,4,5,6,7,8]
print(reduce(lambda x,y:x+y,seq))
print(reduce(lambda x,y:x+y,range(9)))

内置函数eval()

把字符串转化为python表达式并求值

>>> eval("3+4")
7
>>> a = 3
>>> b = 5
>>> eval('a+b')
8
>>> import math
>>> eval('math.sqrt(3)')
1.7320508075688772