下面这部分内容计划应该是第三周讲的,但是应该是当时来不及,第四周上来的内容又比较重要,就放到了第四周讲完后才讲了。
匿名函数
如果函数值使用一次,并且结构结单(需要一行表达式),就可以使用匿名函数。匿名函数的好处:
-
程序一次行使用,所以不需要定义函数名,节省内存中变量定义空间
-
让程序更加简洁
普通函数:
1
2
3
|
def test(x,y):
return x + y
print (test( 1 , 2 ))
|
匿名函数:
1
2
|
test = lambda x,y:x + y
print (test( 1 , 2 ))
|
lambda:定义一个匿名函数
冒号(:):分隔符
冒号之前的部分:函数的参数,可以无参数,但是冒号不能省
冒号之后的部分:函数的返回值。lambda没有return,后面的就是返回值
上面的列子我们还是定了一个变量名,因为方便后面给参数赋值,这样函数用完后并没有释放空间。把整个函数括起来,后面再写个括号写入参数。
1
|
print (( lambda x,y:x + y)( 1 , 2 ))
|
最终变成了一行,这就很像函数式编程了。
再举个求最大值的例子:
1
2
3
|
f = ( lambda x,y:x if x>y else y)
print (f( 2 , 3 ))
print (f( 6 , 4 ))
|
但是上面的例子平时根本不用这么写。平时不用这么用,因为一般匿名函数是配合别的函数一起使用的,如reduce、filter。
1
2
|
a = filter ( lambda x:x> 3 ,[ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ]) # 通过lambda函数来过滤列表中的元素
print ( list (a))
|
嵌套使用
匿名函数可以嵌套在普通函数中,匿名函数本身作为return的返回值。
1
2
3
4
|
def func(n):
return lambda x:n * * x
f = func( 3 )
print (f( 2 ),f( 3 ),f( 4 ))
|
内置函数
然后是把所有的内置函数都讲了一遍,也不是所有,很多关于对象的类的都先跳过了。
abs()取绝对值
1
|
print ( abs ( 3 ), abs ( 0 ), abs ( - 4 ))
|
all()一个可迭代对象如果所有的值都为True则返回True
1
2
|
print ( all ([ 0 , 1 , 2 , 3 , 4 , 5 ])) # False
print ( all ([ 1 , 2 , 3 , 4 , 5 ])) # True
|
any()一个可迭代对象只有其中有一个的值都为True就返回True
1
2
|
print ( any ([ 0 , 1 , 2 , 3 , 4 , 5 ])) # True
print ( any ([ 0 ,'', False , None ])) # False
|
ascii()把一个对象变成一个可打印的字符串的形式,没什么用。
1
2
|
print ( type ( 123 ), type (ascii( 123 )),ascii( 123 )) # int类型通过ascii()变成了str类型
print (ascii( "你好" )) # 中文字还会转码
|
bin()把一个整数转换成二进制
1
|
print ( bin ( 8 )) # 0b1000
|
bool()布尔,判断True还是False
1
2
3
4
5
|
print ( bool ( 1 ))
print ( bool ([]))
print ( bool ([ 1 , 2 , 3 ]))
print ( bool ( "你好" ))
print ( bool ( None ))
|
bytearray()变成一个bytearray格式
bytes()变成一个bytes格式
1
2
3
4
5
6
|
a = bytes( "abcde" ,encoding = "utf-8" )
b = bytearray( "abcde" ,encoding = "utf-8" )
print ( type (a), type (b))
#a[1] = 99 # bytes类型是不可以修改的,str类型也是 b[ 1 ] = 99 # 这个可以修改
print (a,b)
|
callable() 判断一个对象是否可以被调用。函数名后面可以加(),加了()就是调用。是否可以被调用,就是是否可以后面加()
1
2
3
4
5
6
7
|
a = []
print ( callable (a)) # Fales,列表不能被调用
def b():
pass
print ( callable (b)) # True,函数可以被调用
c = ( i for i in range ( 10 ) )
print ( callable (c.__next__)) # True,生成器c可以用next方法调用下一个元素
|
chr()返回这个整数对应的字符
ord()返回这个字符对应的字符的编码
1
2
3
4
|
print ( chr ( 100 ))
print ( ord ( "d" ))
print ( chr ( 8364 )) # 是这个符号
print ( chr ( 7 )) # 这个会发出“嘟”的一声
|
classmethod(function)类方法,以后会讲
compile()把代码进行编译,大概是这样。我们用不到,给个了可以执行的演示。
把字符串形式的代码编译执行。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
# 把你的代码转成字符串存在变量里 code = """
def fib(n): i,a,b = 0,0,1
while i < n:
#print(b)
yield b
a,b = b,a+b
i += 1
return "结束"
f = fib(10) while 1: try:
x = next(f) # x = f.__next__()
print(x)
except StopIteration as e:
print("返回值是:",e.value)
break
""" #exec(code) # 其实这里直接exec也是可以执行的 py_obj = compile (code," "," exec ") # 编译你的代码,第二个参数是文件名存放编译过程中出错的信息
exec (py_obj) # 上面是用exec编辑的,这里用exec执行
|
这个例子并不是很好,把上面的那句注释掉的语句直接执行也是可以的,不需要经过compile的编译。但是也没有别的例子了,总之就是用不到
这里为啥是exec,什么是exec,还能不能是别的,暂时不知道。
complex()生成复数
1
2
3
4
|
a = complex ( "1+2j" ) # 字符串转为复数
print ( type (a),a)
b = complex ( 1 , 2 ) # 两个参数都是数字,第一个为实部,第二个为虚部
print ( type (b),b)
|
delattr()被略过了,以后会讲
dict()创建字典,其实可以用来生成很复杂的字典,比如用列表来构造
1
2
|
a = dict () # 创建一个空字典
print ( type (a),a)
|
dir()查看对象有什么方法
1
2
3
4
5
6
|
a = {}
print ( dir (a))
b = "123"
print ( dir (b))
c = 123
print ( dir (c))
|
不同的数据类型,能使用的方法是不用的。两个__下划线的是内部方法,一般都不能用,也有能用的,比如迭代器的__next__。
divmod(a,b),a除以b,得到商和余数
1
2
|
print ( divmod ( 9 , 5 )) # (1,4)
print ( divmod ( 10 , 4 )) # (2,2)
|
enumerate()可以为元组或列表等生产索引序列
1
2
3
|
list1 = [ 'a' , 'b' , 'c' , 'd' , 'e' ]
for i,j in enumerate (list1):
print (i,j)
|
eval()把字符串形式的字典、列表等等,转换成对应的数据类型
1
2
3
4
|
a = "{'a':1,'b':2,'c':3}"
print ( type (a),a)
b = eval (a)
print ( type (b),b)
|
exec(),可以执行字符串形式的代码
1
2
3
4
5
6
|
comm = """
a = [1,2,3,4,5] for i in a: print(i)
""" exec (comm)
|
filter(),根据参数1的函数对参数2进行过滤
map(),根据参数1的函数对参数2进行处理
1
2
3
4
5
6
|
res1 = filter ( lambda n:n> 6 , range ( 10 ))
for i in res1:
print (i)
res2 = map ( lambda n:n * 2 , range ( 10 ))
for j in res2:
print (j)
|
frozenset(),创建一个不可变的集合
1
2
3
4
5
6
|
a = set ([ 1 , 2 , 3 , 4 , 5 ])
a.pop() # set可以从中增加或者删除元素
print ( type (a),a)
b = frozenset ([ 1 , 2 , 3 , 4 , 5 ])
#b.pop() # frozenset无法改变里面的元素 print ( type (b),b)
|
globals(),返回全局变量的变量名和值,字典的形式。局部变量可以用locals()
1
|
print ( globals ())
|
getattr(),返回对象属性值,关于对象还没讲到,以后会讲,应该是很重要的内容
hasattr(),判断对象是否包含这个属性
setattr(),设置对象属性值,和上面的getattr相对应。
hash(),获取一个字符串或数值的哈希值
1
2
3
4
|
print ( hash ( 123 ))
print ( hash ( '123' ))
print ( hash ( 'test' ))
print ( hash ( str ([ 1 , 2 , 3 ]))) # 列表不可以,需要转成字符串
|
help(),查看帮助
1
2
3
|
help ( 'hash' ) # 查看hash函数的帮助
a = [] # a现在是一个列表
help (a) # 查看列表的帮助
|
hex(),把数字转成16进制
1
2
3
|
print ( hex ( 15 ))
print ( hex ( 1023 ))
print ( hex ( - 256 ))
|
id(),返回内存地址
1
2
3
4
|
def a():
pass
print (a) # 这里直接打印函数的内存地址
print ( hex ( id (a))) # id默认是10进制,转成16进制和上面一样
|
input(),获取输入的字符串
1
2
|
a = input ( "输入任意字符串:" )
print (a)
|
int(),转成10进制,默认输入的数据是10进制,或者用第二个参数指定
1
2
3
4
5
6
7
|
print ( int ( '15' )) # 默认10进制
print ( int ( '10' , 16 )) # 16进制的10就是10进制的16
print ( int ( '0x10' , 16 )) # 即时字符串前有0x,后面的16进制也不能省略
print ( int ( 'ff' , 16 ))
print ( int ( '0b100' , 2 ))
print ( int ( '100' , 5 )) # 还可以有奇怪的进制,5进制
print ( int ( '1gg' , 17 )) # 17进制
|
isinstance(),判断参数1是否是参数2的类型
1
2
3
4
|
print ( isinstance ( 1 , str )) # False
print ( isinstance ( '1' , str )) # True
print ( isinstance ([],( set , dict ))) # False,是否是元祖中的其中一个类型
print ( isinstance ([],( list , dict ))) # True
|
issubclass(),是不是一个子类。啥是类,还没学
iter(),装换成迭代器
1
2
3
4
5
6
7
8
|
from collections import Iterator
a = [ 1 , 2 , 3 , 4 , 5 , 6 ] # a是列表
print ( isinstance (a,Iterator)) # Fales,现在a还不是一个迭代器
b = iter (a) # 把a变成成迭代器
print ( isinstance (b,Iterator)) # True,现在b是一个迭代器了
print (b.__next__()) # 可以用next
print (b.__next__())
print (b.__next__())
|
len(),返回长度
1
2
|
print ( len ( '123' ))
print ( len ([ 1 , 2 , 3 ]))
|
list(),可以将元祖转换成列表。只要是可迭代对象应该都可以
1
2
3
4
5
6
|
a = ( 1 , 2 , 3 )
b = list (a)
print ( type (a),a)
print ( type (b),b)
print ( range ( 10 ))
print ( list ( range ( 10 ))) # range()也可以转
|
locals(),打印当前位置的局部变量,字典的形式,变量名和值
1
2
3
4
5
6
7
|
def test():
local_var = 123
print ( locals ()) # 打印局部变量,只有一个local_var
print ( globals ()) # 打印的依然是全局变量,没有当前位置的局部变量
test() print ( locals ()) # 这个位置打印的就是全局变量
print ( globals ()) # 打印的还是全局变量
|
map(),根据提供的函数,对指定的对象做映射
1
2
|
a = map ( lambda x:x * * 2 ,[ 1 , 2 , 3 , 4 , 5 ]) # 列表中的每个元素都用lambda的方法计算一次
print ( list (a))
|
max()和min(),返回最大值和最小值
1
2
|
print ( max ( 1 , 2 , 3 )) # 可以是好几个变量
print ( min ([ 1 , 2 , 3 ])) # 也可以是一个列表
|
memoryview(),返回给定对象的内存查看对象(Momory view)。不懂,也用不到。
next(),通过__next__()调用迭代器的下一项
1
2
3
4
|
a = ( ( lambda x:x * * 2 )(i) for i in range ( 2 , 10 ) ) # 构造一个迭代器
print ( next (a)) # 打印出迭代器中的下一项
print ( next (a))
print ( next (a))
|
object,Python里,一切皆对象。至于这里有什么用,不知道
oct(),将整数转为8进制
1
2
3
4
|
print ( oct ( 1 ))
print ( oct ( 8 ))
print ( oct ( 9 ))
print ( oct ( 0xa )) # 这个是16进制的写法
|
open(),打开文件。之前用过很多了,略。
ord(),前面chr()一起讲了
pow(),求幂。其实可以有3个参数pow(x,y,z),就是计算(x**y)%z,有z的情况下求余数。
1
2
|
print ( pow ( 2 , 10 , 3 )) # 2**10除以3的余数
print ( pow ( 2 , 10 )) # 求2的10次幂
|
print(),略
property(),返回新式类属性,以后会讲。
range(),直接看例子
1
2
3
|
print ( list ( range ( 10 ))) # 1个参数,从0开始
print ( list ( range ( 2 , 10 ))) # 2个参数:指定开始和结束
print ( list ( range ( 2 , 10 , 2 ))) # 3个参数:再加上步长
|
repr(),把对象转为字符串
1
2
3
4
|
a = [ 1 , 2 , 3 , 4 , 5 ]
b = repr (a)
print ( type (a),a) # a是列表
print ( type (b),b) # b是字符串
|
reversed(),对对象进行反转,返回的是一个迭代器
1
2
3
4
5
6
7
8
|
a = ( 1 , 2 , 3 , 4 , 5 )
b = reversed (a)
print ( next (b))
print ( next (b))
print ( list (b))
c = [ 'a' , 'b' , 'c' , 'd' , 'e' ]
d = reversed (c)
print ( list (d))
|
round(),格式化浮点数。第一个参数是数值,第二个参数是小数位数。用字符串格式化的%f应该更方便,但是如果要用参数控制小数位数,应该只能靠round()
1
2
3
4
|
print ( round ( 0.1234 , 2 ))
num = 0.1234567
for i in range ( 3 , 7 ):
print ( round (num,i))
|
set(),创建集合
1
2
3
|
a = [ 1 , 2 , 3 , 4 , 5 , 2 , 3 ]
b = set (a)
print ( type (b),b)
|
setattr(),设置对象属性值,和上面的getattr相对应。这个非常重要,以后会讲
slice(),切片。一般用[x:y:z],所以没用
1
2
3
|
arr = range ( 10 )
print (arr[ slice ( 2 , 8 , 2 )])
print (arr[ 2 : 8 : 2 ]) # 和上面效果一样
|
sorted(),
1
2
3
4
5
6
|
a = { 'c' : 5 , 'z' : 2 , 'a' : 4 , 'o' : 9 , 'f' : 8 }
b = sorted (a.items()) # 按字典的key来排序
c = sorted (a.items(),key = lambda x:x[ 1 ]) # 按字典的value排序比较复杂
print (a) # 原来的字典
print (b) # 排序后,但是这里是列表了,因为字典是无序的
print (c) # 排序后,按照原来字典的value输出了
|
b=sorted(a.items(),key=lambda x:x[1])这句解释一下。sorted的第二个参数是指定排序的关键字。这里的key=是sorted函数的关键参数(不是字典的key),就是按lambda x:x[1]的值进行排序。这里已经把字典的每一个元素变成一个元组了,参考b的输出。这里的x[1]就是元组的第二个元素,也就是字典的value值。所以就是按字典的value来进行排序了。
staticmethod(),是一个方法,以后会讲。
str(),转换成字符串。
sum(),求和
super(),非常重要的面向对象里的继承的概念,也要以后讲了。
tuple(),生成一个元组
type(),查看数据类型
1
2
3
4
5
6
|
print ( type ( 1 ))
print ( type ( '1' ))
print ( type ( True ))
print ( type ({}))
print ( type ([]))
print ( type (()))
|
vars(),返回一个对象的所有的属性名和值,缺省参数就和locals()一样了。要加上对象才有别的效果。但是:1、对象还没学;2、还是用不到
1
2
3
4
5
6
7
8
9
10
11
12
13
|
class Runoob:
a = 1
def test():
a = 1
print ( vars ())
print ( locals ())
print ( "在函数内部,2个效果一样" )
test() print ( "作用于全局,2个效果还是一样" )
print ( vars ())
print ( locals ())
print ( "vars可以带参数,指定一个class,主要是这个作用" )
print ( vars (Runoob))
|
zip(),把几个可迭代对象组合起来
1
2
3
4
5
6
7
8
9
|
a = [ 1 , 2 , 3 , 4 ]
b = [ 'a' , 'b' , 'c' , 'd' ]
for i in zip (a,b): # 把两个可迭代对象组合起来
print (i)
c = [ 'A' , 'B' , 'C' , 'D' , 'E' ]
for i in zip (a,c): # 如果长度不一样,按短的来
print (i)
for i in zip (a,b,c): # 参数的数量不定
print (i)
|
__import__(),动态加载。一般用import加载模块就好了。如果一个模块经常变化就要使用 __import__() 来动态载入。以后可能会用到。暂时知道就行了。这个忘记它吧,这不出官方的推荐用法也没给出例子。
本文转自骑士救兵51CTO博客,原文链接:http://blog.51cto.com/steed/1980315,如需转载请自行联系原作者