下面这部分内容计划应该是第三周讲的，但是应该是当时来不及，第四周上来的内容又比较重要，就放到了第四周讲完后才讲了。
匿名函数
如果函数值使用一次，并且结构结单（需要一行表达式），就可以使用匿名函数。匿名函数的好处：
-
程序一次行使用，所以不需要定义函数名，节省内存中变量定义空间
-
让程序更加简洁
普通函数：
|
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，如需转载请自行联系原作者
