python/匿名函数和内置函数

1 匿名函数

　　匿名函数是lambda定义的没有名字的具有一些小功能的函数

　　具体形式是

　　

lambda 参数列表:返回值表达式

lambda x: X**2
# 求平方操作
lambda x: x>100
# 判断参数是否大于100

2 内置函数

1) int(), float(), bool(), str(), list(), set(), tuple() 和 dict()

　　这些都是和类型相关的函数

　　这些叫做 工厂函数

2) map(), reduce() 和 filter()

　　map()函数有两个参数, 一个是处理函数, 另一个是可迭代对象, map取出可迭代对象的元素, 进行前面的函数操作, 形成新的迭代器的元素, 最终返回该迭代器

　　

>>> l = [1,2,3,4,5]
>>> m = map( lambda x:x*x, l)
>>> m
<map object="" at="" 0x0000000003200240="">
>>> list(m)
[1, 4, 9, 16, 25]
</map>

reduce()函数性质同map()函数, 只是传入的函数需要设置两个参数, 具体功能是每次取迭代器中的两个元素,放入函数操作, 下次取出一个值和上一次运行的结果继续在函数中运行, 最后得到一个值并且返回

　　

>>> from functools import reduce
>>> l = range(100)
>>> sumValue = reduce(lambda x,y:x+y, l)
>>> sumValue
4950

fileter()函数用于过滤, 和map()类似取一个元素放入函数中运行, 如果运行结果为True则放入生成器中, 否则不放入, 最后返回这个生成器

　　

nameDict = [
    {'name':'egon','age':18},
    {'name':'dfire','age':1000},
    {'name':'gaoluchuan','age':9000},
    {'name':'fsw','age':10000},
]
filter(lambda x:x['age']>100,nameDict)

3) zip()

　　拉链函数, 用于将参数中的可迭代对象的元素组个弄出来匹配成一个一个的元组

　　

d={"a":1203,"b":4568,"c":1425}
for i in zip(d.keys(), d.values()):
    print(i)

4) abs()

　　abs是求绝对值的

　　

>>> abs(-1)
1
>>> abs(1)
1
>>> abs(0)
0

5) all() 和 any()

　　all函数传入一个可迭代对象, 分别遍历其中的元素, 并且进行bool值判断, 如果有一个值为False就返回False, 只有全部为True才返回True

　　当all的参数是空的可迭代对象的时候返回True

　　any()函数情况与all()相反, any()中传入空的可迭代对象值为False, 一个值为True就是True, 全部为False才为False

　　

>>> all([])
True
>>> all([1,2,3])
True
>>> all([1,2,3,None])
False

6) bin(), oct(), hex()

　　返回二进制, 八进制, 十六进制

　　

>>> bin(10)
'0b1010'

7) callable()

　　判断该对象是否可以被调用

　　

>>> def hello():
    print("hello")

>>> callable(hello)
True

8) chr()

　　将字符编码(数字)转化为字符

　　

>>> chr(67)
'C'

9) ord()

　　与chr()对应, 将字符转化为编码

　　

>>> ord('a')
97

10) complex()

　　生成复数的函数

　　

>>> i = complex(2-4j)
>>> i.real
2.0
>>> i.imag
-4.0

11) dir()

　　查看该对象中的成员内容

12) divmod()

　　传入两个参数, 返回一个元组, 该元组有两个值, 一个是商, 一个是余数

　　

>>> divmod(10,3)
(3, 1)
>>> divmod(15,5)
(3, 0)

13) enumerate()

　　传入一个可迭代对象, 返回索引和元素组成的元组

　　

>>> for i in enumerate([4,6,7,8,12]):
    print(i)

(0, 4)
(1, 6)
(2, 7)
(3, 8)
(4, 12)
>>> for i in enumerate([4,6,7,8,12],10):
    print(i)

(10, 4)
(11, 6)
(12, 7)
(13, 8)
(14, 12)

14) eval()

　　获取传入的字符串, 把他当成命令执行

　　

>>> l = eval("[1,2,3,4]")
>>> l
[1, 2, 3, 4]

15) hansh()

　　根据传入的值生成哈希值

　　

>>> hash(1234344)
1234344
>>> hash("shdaiohdsh")
64688500983994519

16) id()

　　获得对象的身份(一般说是内存地址)

　　

>>> a = 100
>>> id(a)
502009392
>>> b = 100
>>> id(b)
502009392

17) isinstance()

　　判断对象是不是某种类型的

　　

>>> a = 100
>>> isinstance(a,int)
True
>>> isinstance(a,(int,float))
True

18) iter() 和 next()

　　iter获取可迭代对象的迭代器

　　

>>> l = [1,2,3,4]
>>> iter(l)
<list_iterator object="" at="" 0x0000000003265828="">
</list_iterator>

next是根据迭代器生成一个值

　　

>>> l = [1,2,3,4]
>>> iter(l)
<list_iterator object="" at="" 0x00000000030eab70="">
>>> ll = iter(l)
>>> next(ll)
1
>>> next(ll)
2</list_iterator 

 19) len()

　　获得对象的长度

　　

>>> len("hello")
5
>>> len([1,2,3])
3

20) locals() 和 globals()

　　这是获取局部变量和全局变量的函数

　　

>>> def f():
    j = 2
    print(locals())

>>> f()
{'j': 2}
>>> globals()
{'f': <function f="" at="" 0x0000000000d40378="">, '__builtins__': <module 'builtins'="" (built-in)="">, '__package__': None, '__doc__': None, 'x': 1, 'y': 'xx', '__name__': '__main__', '__spec__': None, '__loader__': <class '_frozen_importlib.builtinimporter'="">}
</class></module></function>

21) max() 和 min()

　　求最大值和最小值

　　

d={"a":1203,"b":4568,"c":1425}
def get_value(k):
    return d[k]

print( max(d, key=get_value ) )
print( min(d, key= lambda k:d[k] ) )

22) open()

　　打开文件

23) pow()

　　求次方, 第一个参数是底数,第二个是指数, 加入第三个参数就是对其结果求余

　　

>>> pow(2,3)
8
>>> pow(2,3,3)
2

24) reversed()

　　颠倒序列

>>> l = [2,8,5,6,9]
>>> reversed(l)
<list_reverseiterator object="" at="" 0x00000000030eab00="">
>>> list(reversed(l))
[9, 6, 5, 8, 2]
</list_reverseiterator>

25) slice()

　　切片函数

26) sorted()

　　排序序列

　　

>>> sorted(l)
[2, 5, 6, 8, 9]
>>> sorted(l,reverse=True)
[9, 8, 6, 5, 2]

27) type()

　　求类型

28) vars()

　　没有参数的时候就是locals()