完整版)python常用函数

完整版)python常用函数

Practical Standard Document

() n

The map() n is a built-in higher-order n in Python。It takes a

n f and a list。and applies the n f to each element of the list in turn

to obtain a new list and return it.

For example。if we want to square each element of the list

[1.2.3.4.5.6.7.8.9]。we can use the map() n。Therefore。we only

need to pass in the n f(x)=x*x XXX using the map() n:

def f(x):

return x*x

print(map(f。[1.2.3.4.5.6.7.8.9]))

Output:

1.4.9.16.25.36.49.64.81]

XXX in a list can be of any type。map() can handle lists that

contain any type of data。as long as the passed-in n f can handle

this data type.

Suppose that the English names entered by users are not

standardized and do not follow the rule of capitalizing the XXX。We can use the map() n to convert a list (containing several non-standard English names) into a list of standardized English names:

Input: ['adam'。'LISA'。'barT']

Output: ['Adam'。'XXX'。'Bart']

() n

The ce() n is also a built-in higher-order n in Python。The

parameters received by ce() are similar to those of map()。a n f

and a list。but the r is different from that of map()。The n f

passed to ce() must accept two parameters。The ce() n repeatedly

calls the n f for each element in the list and returns the final result

value.

For example。we can write an f n that accepts x and y and

returns the sum of x and y:

def f(x。y):

return x + y

ce函数时，会对list中的元素进行逐个计算，每次计算都会把前面计算得到的结果和当前元素一起传入函数中进行计算。例如，ce(f。[1.3.5.7.9])会先计算f(1.3)，结果为4，然后再计算f(4.5)，结果为9，以此类推，直到计算结束。最终的结果就是所有元素的计算结果。ce函数来实现求和等操作。

除了默认的计算方式外，ce函数还可以接收第三个参数，作为计算的初始值。如果设置了初始值，那么第一次计算时会使用初始值和第一个元素进行计算。例如，ce(f。[1.3.5.7.9]。100)会先计算f(100.1)，结果为101，然后再计算f(101.3)，以此类推，直到计算结束。最终的结果就是所有元素的计算结果加上初始值。

如果需要求一个list中所有元素的积，ce函数和一个自定义的函数来实现。例如，给定一个list [2.4.5.7.12]，ce函数和一个名为prod的函数来求积。prod函数接收两个参数，返回它们的乘积。最终的结果就是所有元素的乘积。

ce函数外，Python还提供了另一个有用的高阶函数filter。filter函数接收一个函数f和一个list，函数f的作用是对每个元素进行判断，返回True或False。filter函数会根据判断结果自动过滤掉不符合条件的元素，最终返回符合条件的元素组成的新list。

例如，给定一个list [1.4.6.7.9.12.17]，需要删除其中的偶数并保留奇数。可以先编写一个判断奇数的函数is_odd，然后利用filter函数过滤掉偶数。同样地，利用filter函数还可以实现删除None或空字符串等功能。

文案大全

实用标准文档

请利用filter()过滤出1~100中平方根是整数的数，即结果应该是：[1.4.9.16.25.36.49.64.81.100]

参考代码：

import math

def is_sqr(x):

r = int((x))

return r*r==x

print filter(is_sqr。range(1.101))

实用标准文档提供了一个使用filter()函数的例子，用于过滤出1~100中平方根是整数的数。需要注意的是，该函数需要判断一个数的平方根是否是整数，而()返回的是浮点数，因此需要进行转换。

自定义排序函数sorted()

Python内置的sorted()函数可对list进行排序：

sorted([36.5.12.9.21])

5.9.12.21.36]

但sorted()也是一个高阶函数，它可以接收一个比较函数来实现自定义排序。比较函数的定义是，传入两个待比较的元素x和y，如果x应该排在y的前面，返回-1，如果x应该排在y的后面，返回1.如果x和y相等，返回0.

因此，如果我们要实现倒序排序，只需要编写一个reversed_cmp函数：

def reversed_cmp(x。y):

if x。y:

return -1

if x < y:

return 1

return 0

这样，调用sorted()并传入reversed_cmp就可以实现倒序排序：

sorted([36.5.12.9.21]。reversed_cmp)

36.21.12.9.5]

sorted()也可以对字符串进行排序，字符串默认按照ASCII大小来比较：

sorted(['bob'。'about'。'Zoo'。'Credit'])

Zoo'排在'about'之前是因为'Z'的ASCII码比'a'小。为了实现忽略大小写比较，我们可以先把两个字符串都转换成大写或小写，然后再进行比较。下面是一个忽略大小写比较的函数cmp_ignore_case(s1.s2)：

def cmp_ignore_case(s1.s2):

u1 = ()

u2 = ()

if u1 < u2:

return -1

if u1.u2:

return 1

return 0

print sorted(['bob'。'about'。'Zoo'。'Credit']。cmp_ignore_case)

Python的函数不仅可以返回int、str、list、dict等数据类型，还可以返回函数。例如，我们可以定义一个函数f()，让它返回一个函数g：

def f():

print('call f()。')

定义函数g:

def g():

print('call g()。')

返回函数g:

return g

在函数f内部，我们定义了一个函数g，并返回变量g，即函数g本身。调用函数f()，我们会得到f返回的一个函数：

x = f()#调用f()

call f()。

x#变量x是f()返回的函数：

n f。g at 0x7f2d0c7c0ae8>

x()# x指向函数，因此可以调用

call g()。

请注意区分返回函数和返回值。返回函数可以把一些计算延迟执行。例如，我们可以定义一个普通的求和函数：

def calc_sum(lst):

return sum(lst)

如果我们需要不断地进行求和，但每次传入的列表都不同，那么我们可以先返回一个求和函数，再根据不同的列表调用这个函数：

f = calc_sum

print(f([1.2.3]))#6

print(f([4.5.6]))#15

这样，我们就可以把计算延迟到调用函数的时候再执行，提高程序的灵活性和效率。

当我们调用calc_sum()函数时，会立即计算并返回结果。但如果我们返回一个函数，就可以实现“延迟计算”。具体来说，我们可以在calc_sum()函数内部再定义一个函数lazy_sum()，并将其作为返回值。这样，调用calc_sum()函数时，并不会立

即计算结果，而是返回一个函数。只有在调用返回的函数时，才会真正计算结果。

下面是一个例子，演示了如何使用闭包计算一个列表的乘积。我们定义一个calc_prod()函数，它接收一个列表作为参数，并返回一个函数。这个函数可以计算列表中所有元素的乘积。具体来说，我们在calc_prod()函数内部再定义一个函数lazy_prod()，并将其作为返回值。这样，调用calc_prod()函数时，并不会立即计算结果，而是返回一个函数。只有在调用返回的函数时，才会真正计算结果。

闭包是指内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况。闭包可以用来实现“延迟计算”的效果，也可以用来隐藏变量，防止被其他代码访问。注意，如果内层函数修改了外层函数的变量，这种修改会被保存下来，因为闭包会保留外层函数的状态。

闭包的特点是返回的函数引用了外层函数的局部变量。为了正确使用闭包，需要确保引用的局部变量在函数返回后不会发生变化。例如，希望一次返回3个函数，分别计算1x1、2x2、3x3，可以使用以下代码：

python

def count():

fs = []

for i in range(1.4):

def f():

return i*i

(f)

return fs

f1.f2.f3 = count()

然而，调用f1()、f2()和f3()的结果都是9，而不是1、4、9.原因是在count()函数返回3个函数时，这3个函数所引用的变量i的值已经变成了3.因此，返回函数不应引用任何循环变量或后续可能发生变化的变量。为了避免这个问题，可以改写count()函数，如下所示：

python

def count():

fs = []

for i in range(1.4):

def f(j):

def g():

return j*j

return g

r = f(i)

(r)

return fs

f1.f2.f3 = count()

print(f1()。f2()。f3())

这样，可以正确返回能计算1x1、2x2、3x3的函数。

另外，Python还支持匿名函数。在高阶函数中，有时候不需要显式地定义函数，直接传入匿名函数更方便。例如，可以使用lambda表达式计算f(x)=x，如下所示：

python

list(map(lambda x: x * x。[1.2.3.4.5.6.7.8.9]))

这将返回[1.4.9.16.25.36.49.64.81]。

通过对比可以看出，匿名函数lambda x: x * x实际上就是定义一个函数f(x)，并返回x的平方。关键字lambda表示匿名函数，冒号前面的x表示函数参数。匿名函数有个限制，就是只能有一个表达式，不写return，返回值就是该表达式的结果。使用匿名函数可以不必定义函数名，直接创建一个函数对象，很多时候可以简化代码。例如，可以使用lambda表达式作为sorted()函数的key参数来排序。例如：sorted([1.3.9.5.0]。lambda x,y: -cmp(x,y))，会返回一个降序排列的列表[9.5.3.1.0]。返回函数时，也可以使用匿名函数来简化代码。例如：myabs

= lambda x: -x if x。0.['test'。None。''。'str'。'。'。'END'])。在定义匿名函数时，没有return关键字，且表达式的值就是函数返回值。