python闭集函数 函数闭包 python

python 8个常用内置函数解说

8个超好用内置函数set（），eval（），sorted（），reversed（），map（），reduce（），filter（），enumerate（）

创新互联建站是专业的江宁网站建设公司，江宁接单;提供网站设计、成都网站设计,网页设计,网站设计,建网站,PHP网站建设等专业做网站服务;采用PHP框架,可快速的进行江宁网站开发网页制作和功能扩展;专业做搜索引擎喜爱的网站,专业的做网站团队,希望更多企业前来合作!

python中有许多内置函数，不像print那么广为人知，但它们却异常的强大，用好了可以大大提高代码效率。

这次来梳理下8个好用的python内置函数

1、set()

当需要对一个列表进行去重操作的时候，set()函数就派上用场了。

用于创建一个集合，集合里的元素是无序且不重复的。集合对象创建后，还能使用并集、交集、差集功能。

2、eval()之前有人问如何用python写一个四则运算器，输入字符串公式，直接产生结果。用eval()来做就很简单：eval(str_expression)作用是将字符串转换成表达式，并且执行。

3、sorted()在处理数据过程中，我们经常会用到排序操作，比如将列表、字典、元组里面的元素正/倒排序。这时候就需要用到sorted() ，它可以对任何可迭代对象进行排序，并返回列表。对列表升序操作：

对元组倒序操作：

使用参数：key，根据自定义规则，按字符串长度来排序：

根据自定义规则，对元组构成的列表进行排序：

4、reversed()如果需要对序列的元素进行反转操作，reversed()函数能帮到你。reversed()接受一个序列，将序列里的元素反转，并最终返回迭代器。

5、map()做文本处理的时候，假如要对序列里的每个单词进行大写转化操作。这个时候就可以使用map()函数。

map()会根据提供的函数，对指定的序列做映射，最终返回迭代器。也就是说map()函数会把序列里的每一个元素用指定的方法加工一遍，最终返回给你加工好的序列。举个例子，对列表里的每个数字作平方处理：

6、reduce()前面说到对列表里的每个数字作平方处理，用map()函数。那我想将列表里的每个元素相乘，该怎么做呢？这时候用到reduce()函数。

reduce()会对参数序列中元素进行累积。第一、第二个元素先进行函数操作，生成的结果再和第三个元素进行函数操作，以此类推，最终生成所有元素累积运算的结果。再举个例子，将字母连接成字符串。

你可能已经注意到，reduce()函数在python3里已经不再是内置函数，而是迁移到了functools模块中。这里把reduce()函数拎出来讲，是因为它太重要了。

7、filter()一些数字组成的列表，要把其中偶数去掉，该怎么做呢？

filter()函数轻松完成了任务，它用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象。filter()函数和map()、reduce()函数类似，都是将序列里的每个元素映射到函数，最终返回结果。我们再试试，如何从许多单词里挑出包含字母w的单词。

8、enumerate()这样一个场景，同时打印出序列里每一个元素和它对应的顺序号，我们用enumerate()函数做做看。

enumerate翻译过来是枚举、列举的意思，所以说enumerate()函数用于对序列里的元素进行顺序标注，返回(元素、索引)组成的迭代器。再举个例子说明，对字符串进行标注，返回每个字母和其索引。

Python 之内置函数：filter、map、reduce、zip、enumerate

这几个函数在 Python 里面被称为高阶函数，本文主要学习它们的用法。

filter 函数原型如下：

第一个参数是判断函数（返回结果需要是 True 或者 False），第二个为序列，该函数将对 iterable 序列依次执行 function(item) 操作，返回结果是过滤之后结果组成的序列。

简单记忆：对序列中的元素进行筛选，获取符合条件的序列。

返回结果为： ，使用 list 函数可以输入序列内容。

map 函数原型如下：

该函数运行之后生成一个 list，第一个参数是函数、第二个参数是一个或多个序列；

下述代码是一个简单的测试案例：

上述代码运行完毕，得到的结果是： 。使用 print(list(my_new_list)) 可以得到结果。

map 函数的第一个参数，可以有多个参数，当这种情况出现后，后面的第二个参数需要是多个序列。

map 函数解决的问题：

reduce 函数原型如下：

第一个参数是函数，第二个参数是序列，返回计算结果之后的值。该函数价值在于滚动计算应用于列表中的连续值。

测试代码如下：

最终的结果是 6，如果设置第三个参数为 4，可以运行代码查看结果，最后得到的结论是，第三个参数表示初始值，即累加操作初始的数值。

简单记忆：对序列内所有元素进行累计操作。

zip 函数原型如下：

zip 函数将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

如果各个迭代器的元素个数不一样，则返回列表长度与最短的对象相同，利用星号（ * ）操作符，可以将元组解压为列表。

测试代码如下：

展示如何利用 * 操作符：

输出结果如下：

简单记忆：zip 的功能是映射多个容器的相似索引，可以方便用于来构造字典。

enumerate 函数原型如下：

参数说明：

该函数用于将一个可遍历的数据对象组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

测试代码如下：

返回结果为： 。

本文涉及的函数可以与 lambda 表达式进行结合，能大幅度提高编码效率。最好的学习资料永远是官方手册

求帮助，Python闭包和返回函数问题

（1）unpack tuple和list, 可以让函数返回多个值

def count():

return (1, 2, 3) # 或者 return [1, 2, 3]

# 把列表解包，把1 2 3 分别赋值给 a b c

a, b, c = count()

print a, b, c

# 输出 1, 2, 3

（2）假设你知道Python的dict类型。Python中，在函数中定义一个变量的时候，会在一个隐藏的叫locals的dict里面插入key-value，其中key是变量名，value是变量值。而引用一个变量的时候，则首先会在这个叫locals的dict里面，根据变量名作为key，去查对应的值。

var = 1 # 你可以认为这里进行了 locals['var'] = 1 的操作

print var # 在对var变量进行求值的时候，就在locals['var']里面找var变量对应的值

（3）for循环中，每次循环只是给 `i` 重新绑定值

for i in (1, 2, 3):

print i

print i

# 一次输入 1 2 3 3

每次`for i in (1, 2, 3)`相当于在`print i`之前，进行了

`locals['i'] = 1`

`locals['i'] = 2`

`locals['i'] = 3`

的操作

所以最后的`print i`再去locals字典里面找`i`的时候，就变成 3 了。

（4）闭包是 一个函数加上这个函数引用的外部变量

var = 1

def f():

print var

# 这里的闭包是函数 f 和 f 引用的外部变量 var

def count():

var2 = 2

def f():

print var2

# 这里的闭包是函数 f 和 f 引用的外部变量 var2

return f

拿第一个函数 f 来说。在 f 运行的时候，解释器拿着'var'这个字符串去locals字典里面找，发现找不到，于是在closure字典里面找，最后closure字典里面找，你可以认为就是找closure['var']，然后发现找到对应的值。count里面的 f 函数同理。

（为了容易理解，我这里说谎了。实际上 f 压根没有closure，count里面的 f 才有。其实closure压根不是像locals那样的字典）

（5）函数定义时，函数只是记录变量的名字。

要区分什么是名字，什么是值。

`i = 1`这里 i 只是名字，只是一个字符串 'i' 。这句话运行完，locals['i'] = 1，就说 i 对应的值是1

def count():

fs = []

for i in range(1, 4):

# 定义一个函数，等价于运行了 locals['f'] = 真正生成的函数

# 每次循环，这里都会重新生成一个函数，然后把重新生成的函数赋值给 locals['f']

def f():

return i * i # 引用了'i'这个名字，但并不是引用了'i'对应的值

# 等价于 locals['fs'].append(locals['f'])

# f 不是函数，它只是一个名字'f'。f 引用的东西，也就是locals['f']才是真正的函数

fs.append(f)

# 于是这个for循环生成了三个函数，这三个函数是没有名字的，这个函数运行完后，它们跟'f'这个名字就毛关系都没有了(是的我说慌了，但可以先不管)

# 把整个列表返回，这个列表包含了三个函数

return fs

# count()返回三个函数的列表，unpack 列表的语法把列表中的三个函数抽出来，重新给他们命名为 f1, f2, f3

# 也就是说，

# locals['f1'] = 列表中的第1个函数

# locals['f2'] = 列表中的第2个函数

# locals['f3'] = 列表中的第3个函数

# 这三个函数跟'f'这个名字现在毛关系都没有。（其实是有的，但为了说明需要简化，现在你可以完全不管括号里面说的话）

f1, f2, f3 = count()

print f1(), f2(), f3()

# 好了我们运行它们，输入都是 9

# def f():

# return i * i

这是因为 f1 现在对应的函数，里面引用了 'i' 这个字符串，我们根据 'i '这个字符串去找它对应的值，先找到 f 当前的locals字典，发现没有，因为函数定义的时候没有定义 i 变量。然后再去closure['i']里面找，因为Python是通过closure字典实现闭包的（就当它是对的好不好），所以我们可以在closure['i']找到值，这个值就是我们上一次运行的时候count函数里面残留的locals['i']，而由于for循环三遍之后，locals['i'] == 3，所以找到 i 的值就是3。所以最后输出都是9

python中range()的用法是什么？

range()函数的用法如下：

（1）range(stop)

创建一个（0,stop)之间的整数序列，步长为1。

（2）range(start,stop)

创建一个（start,stop)之间的整数序列，步长为1。

（3）range(start,stop,step)

创建一个[start,stop)之间的整数序列，步长为step。

参数介绍：

start：表示从返回序列的起始编号，默认情况下从0开始。

stop：表示生成最多但不包括此数字的数字。

step：指的是序列中每个数字之间的差异，默认值为1。

range()是Python的内置函数，在用户需要执行特定次数的操作时使用它，表示循环的意思。内置函数range()可用于以列表的形式生成数字序列。在range()函数中最常见用法是使用for和while循环迭代序列类型（List，string等）。

简单的来说，range()函数允许用户在给定范围内生成一系列数字。根据用户传递给函数的参数数量，用户可以决定该系列数字的开始和结束位置以及一个数字与下一个数字之间的差异有多大。

python集合和函数

变量名={元素，元素，，，}

nums={11,24,45,96,28}

nums.add(42)

print(nums)

nums={11,24,45,96,28}

nums2=["anfly","tom"]

nums.update(nums2)

print(nums)

1）nums={11,24,45,96,28}  [没有该数字报错]

   nums.remove(24)

   print(nums)

2）nums={11,24,45,96,28}  [随机删]

 nums.pop()

 print(nums)

3）nums={11,24,45,96,28} [没有该数字不会报错]

 nums.discard(24)

 print(nums)

交集:(存在相同元素)

set1={"anfly","tom","haha"}

set2={"anfly","susala"}

set3=set1set2

print(set3)

并集:(得到全部集合中全部的元素)

set1={1,2,3,4}

set2={3,4,5,6}

new_set=set1|set2

print(new_set)

运算符 (+ * in)

内置函数 (len max min del)

列：set1 = {"1","2","3"}

    print(min(set1))

def函数名():

   执行语句

函数名()

列：

defhello():

print("hello word")

hello()

2.函数参数：

def  add2num():

a=11

b=22

c=a+b

print(c)

add2num()

3.位置参数:

def  fun(a,b):

 print("a:",a)

 print("b:",b)

fun(2,3)

4.关键字参数：

def  fun(a,b):

  print("a:",a)

 print("b:",b)

fun(a=2,b=3)   [第一个‘a’可以直接写数字，也可以展示；第二个以及之后‘b’不能直接写数字，要写‘b=3’这种格式]

5.缺省参数

def printinfo(name,age=20):

  print("name:",name)

  print("age:",age)

printinfo(name="anfly")  [展示都能展示出来]

6.不定长参数

1).*args[展示是元组]

defprintinfo(*args):

 print("args:",args)

printinfo(100,200,300,400)

2）**args[展示是k.v格式]

def printinfo(**kwargs):

 print("kwargs:",kwargs)

printinfo(a=100,b=200,c=300,d=400)

7.参数位置顺序

def sun(a,*args,b=22,**kwargs):

     print("a：",a)        ==10

     print("args：",args)    ==（200，300）

     print("b：",b)    ==2

     print("kwargs：",kwargs)  =={‘m’:3,'n':4}

sun(100,200,300,b=2,m=3,n=4)

8.函数返回值

def fan(a,b):

  return a+b

print(fan(1,2))  #3

9.匿名函数（lambda函数也叫匿名函数，即函数没有具体的名称）

案例一：

sum=lambda a,b:a+b

print(sum(1,2))  #3

案例二：

sum=lambda a,b:100

print(sum(1,2))  #100

1.局部变量

def jv():

   a=3 

   print(a)

def jv1():   

   a=99   

   print(a)

jv()       #3

jv1()    #99

2.全局变量

def jv():

   print(a) 

def jv1():   

    a=99   

    print(a)

jv()     #全局变量

jv1()    #99

3.局部变量升成全局变量

def jv():

    a=3 

    global b   

     b="我也是全局变量" 

      print(a)

def jv1():   

       a=99   

        print(a)   

         print(b)

jv()          #3

jv1()        #99 #“我也是全局变量”

Python中的常用内置函数有哪些呢？

abs() divmod() input() open() staticmethod()

all() enumerate() int() ord() str()

any() eval() isinstance() pow() sum()

basestring() execfile() issubclass() print() super()

bin() file() iter() property() tuple()

bool() filter() len() range() type()

bytearray() float() list() raw_input() unichr()

callable() format() locals() reduce() unicode()

chr() frozenset() long() reload() vars()

classmethod() getattr() map() repr() xrange()

cmp() globals() max() reverse() zip()

compile() hasattr() memoryview() round() __import__()

complex() hash() min() set()

delattr() help() next() setattr()

dict() hex() object() slice()

dir() id() oct() sorted()