python学习03

推导和lambda表达式

一.列表推导式

1.整除3的数字列表
numbers = []
for x in range(100):
    if x % 3 == 0:
   numbers.append(x)
# 使用推导实现

numbers = [x for x in range(100) if x % 3 == 0]

2.
def squared(x):
    return x*x
multiples = [squared(i) for i in range(30) if i % 3 is 0]

print(multiples)

Python 使用 def 开始函数定义，紧接着是函数名，括号内部为函数的参数，内部为函数的 具体功能实现代码，如果想要函数有返回值, 在 expressions 中的逻辑代码中用 return 返回。

3.

print(type(multiples))

type:一个参数返回对象类型, 三个参数，返回新的类型对象。

上述输出为<class 'list'>  类型为列表

二、字典推导式

字典推导和列表推导的使用方法是类似的，只不过中括号该改成大括号。

1.快速更换key和value
mcase = {'a': 10, 'b': 34}
mcase_frequency = {value: key for key, value in mcase.items()}

print(mcase_frequency)

字典(dictionary)是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下:

d = {key1 : value1, key2 : value2 }

键一般是唯一的,如果重复最后的一个键值对会替换前面的,值不需要唯一。值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组,不能为列表。

修改字典

a={'name':'Tim','age':'15'}

添加:a['class']='first'   #输出a为['name':'Tim','age':'15','class':''first]

修改:a['name']='Aim'  #输出a为:['name':'Aim','age':'15']

删除字典元素

del a['name'];  # 删除键是'name'的条目
a.clear();      # 清空词典所有条目

del a ;         # 删除词典 删除字典可能会报错,找不到该字典

三、集合推导式

#它们跟列表推导式也是类似的。 唯一的区别在于它使用大括号{}

1.squared={x**2 for x in [1,1,2]}

print(squared)  #输出为[1,4]

2.用集合推导字符串长度的集合

strings=['a','is','with','exception','b']

a={len(s) for s in strings} #输出a为[1,2,4,9] 注意有长度相同的只会保留一个

#小练习

1.   0到9的次方

squares=[x**2 for x in range(10)]

2.  将单词长度大于3的转化为大写输出

names = ['bob','tom','alice','jerry','wendy','smith']

print([name.upper() for name in names if len(name)>3])   #.upper() 函数为将小写字母转为大写

3.  求(x,y)其中x是0-5之间的偶数，y是0-5之间的奇数组成的元祖列表

[(x,y) for x in range(5) if x%2==0 for y in range(5) if y %2!=0]

4.  求m中3,6,9组成的列表
m = [[1,2,3],[4,5,6],[7,8,9]]

[row[2] for row in m]  或者  [m[row][2] for row in (0,1,2)]

5.  求m 中斜线1,5,9组成的列表
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
[m[i][i] for i in range(len(m))] 

6.  结合两个列表的元素，如果元素之间不相等的话

[(x,y) for x in [1,2,3] for y in [3,1,6] if x!=y]

7.  创建一个列表 形式为(number,square)

[(x,x**2) for x in range(number)]

lambda 表达式

python 使用 lambda 表达式来创建匿名函数
lambda只是一个表达式，函数体比def简单很多
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去
lambda函数拥有自己的名字空间，且不能访问自有参数列表之外或全局名字空间里的参数

虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率.

lambda函数的语法只包含一个语句： lambda [arg1 [,arg2,.....argn]]:expression 

使用如下：

1 square = lambda x : x**2
2 print(square(3)) # 9
3 sum = lambda x, y : x + y

4 print(sum(2, 3)) # 5

例:

1个参数  >  func1 = lambda x:x*2    print(func1(3))  输出为6

多个参数 >  func2 = lambda x,y,z=1:x+y+z print(func2(2))  输出4 ; print(func2(2,3))  输出6;  print(func(2,3,4))  输出9   

#可以初始化参数

func=lambda x:x+1  

等同于

def func(x):

    return(x+1)

python 闭包

python中的闭包从表现形式上定义（解释）为：如果在一个内部函数里，对在外部作用域（但不是在全局作用域）的变量进行引用，那么内部函数就被认为是闭包(closure).

def addx(x): 
 def adder(y): return x + y 
 return adder 
 c = addx(8) 
 type(c) 
<type 'function'> 
 c.__name__ 
'adder'
 c(10) 

18

结合这段简单的代码和定义来说明闭包：

如果在一个内部函数里：adder(y)就是这个内部函数，
对在外部作用域（但不是在全局作用域）的变量进行引用：x就是被引用的变量，x在外部作用域addx里面，但不在全局作用域里，
则这个内部函数adder就是一个闭包。

再稍微讲究一点的解释是，闭包=函数块+定义函数时的环境，adder就是函数块，x就是环境，当然这个环境可以有很多，不止一个简单的x。