python常用的内置函数

  熟悉和掌握python的内置函数，可以在写算法的时候简化代码。

关键字

lambda表达式 :不定义函数名，使用一次的函数

>>> a = [(1, 2), (4, 1), (9, 10), (13, -3)]#type :list
	a.sort(key=lambda x: x[1])#key的用法很高端，规则排序
	print(a)
>>> [(13, -3), (4, 1), (1, 2), (9, 10)]

yield函数:可构建生成器，对可迭代对象进行逐次返回，节约计算资源，如keras的 imagegenerator

1. 可迭代对象`iterable`是实现了`__iter__()`方法的对象，`iter()`方法返回`iterator`对象，通过`next`显示的获取元素,用完一个删一个，当迭代器为空时会抛出异常（StopIteration）（和c++迭代器 （`pop_front`+`iterator++`）理解类似），调用迭代器`for item in iterator:`。

#如list是一个可迭代对象包含__iter__()方法，使用iter(list)变成迭代器iterator
>>>dir(list)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
>>> a = [1,2,3,4,5]
>>> type(a)
list
>>> type(iter(a))
list_iterator
>>> b = iter(a)
>>> next(b)
1
>>> len(b)
4
#调用迭代器for item in iterator:...
>>> for item in b:
    	print (item)
2
3
4
5

2. 生成器generator就是带yield的函数，generator就是一种迭代器。yield相当于在迭代器迭代的时候加了个断点返回元素不终止执行，遇到下一个next()触发一次执行。

3. 总结：

   

   生成器迭代器关系图

   • 可迭代对象(Iterable)是实现了__iter__()方法的对象,通过调用iter()方法可以获得一个迭代器(Iterator)
   • 迭代器(Iterator)是实现了__iter__()和__next__()的对象
   • for ... in ...的迭代,实际是将可迭代对象转换成迭代器,再重复调用next()方法实现的
   • 生成器(generator)是一个特殊的迭代器,它的实现更简单优雅.
   • yield是生成器实现__next__()方法的关键.它作为生成器执行的暂停恢复点,可以对yield表达式进行赋值,也可以将yield表达式的值返回.

类型转换

tuple：根据传入的参数创建一个新的元组

>>> tuple() #不传入参数，创建空元组
()
>>> tuple('121') #传入可迭代对象。使用其元素创建新的元组
('1', '2', '1')

list：根据传入的参数创建一个新的列表

>>>list() # 不传入参数，创建空列表
[] 
>>> list('abcd') # 传入可迭代对象，使用其元素创建新的列表
['a', 'b', 'c', 'd']

dict：根据传入的参数创建一个新的字典

>>> dict() # 不传入任何参数时，返回空字典。
{}
>>> dict(a = 1,b = 2) #  可以传入键值对创建字典。
{'b': 2, 'a': 1}
>>> dict(zip(['a','b'],[1,2])) # 可以传入映射函数创建字典。
{'b': 2, 'a': 1}
>>> dict((('a',1),('b',2))) # 可以传入可迭代对象创建字典。
{'b': 2, 'a': 1}

enumerate：根据可迭代对象创建枚举对象

>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1)) #指定起始值
(range(0, 10), range(1, 10), range(1, 10, 3))
(range(0, 10), range(1, 10), range(1, 10, 3))
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

range：根据传入的参数创建一个新的range对象

>>> a = range(10)
>>> b = range(1,10)
>>> c = range(1,10,3)
>>> a,b,c # 分别输出a,b,c
(range(0, 10), range(1, 10), range(1, 10, 3))
>>> list(a),list(b),list(c) # 分别输出a,b,c的元素
([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 4, 7])

iter：根据传入的参数创建一个新的可迭代对象

>>> a = iter('abcd') #字符串序列
>>> a
<str_iterator object at 0x03FB4FB0>
>>> next(a)
'a'
>>> next(a)
'b'
>>> next(a)
'c'
>>> next(a)
'd'
>>> next(a)
Traceback (most recent call last):
  File "<pyshell#29>", line 1, in <module>
    next(a)
StopIteration

序列操作

all：判断可迭代对象的每个元素是否都为True值

>>> all([1,2]) #列表中每个元素逻辑值均为True，返回True
True
>>> all([0,1,2]) #列表中0的逻辑值为False，返回False
False
>>> all(()) #空元组
True
>>> all({}) #空字典
True

any：判断可迭代对象的元素是否有为True值的元素

>>> any([0,1,2]) #列表元素有一个为True，则返回True
True
>>> any([0,0]) #列表元素全部为False，则返回False
False
>>> any([]) #空列表
False
>>> any({}) #空字典
False

filter：使用指定方法过滤可迭代对象的元素

>>> a = list(range(1,10)) #定义序列
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> def if_odd(x): #定义奇数判断函数
    return x%2==1
>>> list(filter(if_odd,a)) #筛选序列中的奇数
[1, 3, 5, 7, 9]

map：使用指定方法去作用传入的每个可迭代对象的元素，生成新的可迭代对象

>>>  a = str(map(list,['a','b','b','fd']))#每一个可迭代对象进行操作
	 b = list(['a','b','b','fd'])#对每个元素进行操作
>>> a,b
[['a'], ['b'], ['b'], ['f', 'd']]
['a', 'b', 'b', 'fd']

next：返回可迭代对象中的下一个元素值

>>> a = iter('abcd')
>>> next(a)
'a'
>>> next(a)
'b'
>>> next(a)
'c'
>>> next(a)
'd'
>>> next(a)
Traceback (most recent call last):
  File "<pyshell#18>", line 1, in <module>
    next(a)
StopIteration

#传入default参数后，如果可迭代对象还有元素没有返回，则依次返回其元素值，如果所有元素已经返回，则返回default指定的默认值而不抛出StopIteration 异常
>>> next(a,'e')
'e'
>>> next(a,'e')
'e'

reversed：反转序列生成新的可迭代对象

>>> a = reversed(range(10)) # 传入range对象
>>> a # 类型变成迭代器
<range_iterator object at 0x035634E8>
>>> list(a)
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

sorted：对可迭代对象进行排序，返回一个新的列表

>>> a = ['a','b','d','c','B','A']
>>> a
['a', 'b', 'd', 'c', 'B', 'A']

>>> sorted(a) # 默认按字符ascii码排序
['A', 'B', 'a', 'b', 'c', 'd']

>>> sorted(a,key = str.lower) # 转换成小写后再排序，'a'和'A'值一样，'b'和'B'值一样
['a', 'A', 'b', 'B', 'c', 'd']

zip：聚合传入的每个迭代器中相同位置的元素，返回一个新的元组类型迭代器

>>> x = [1,2,3] #长度3
>>> y = [4,5,6,7,8] #长度5
>>> list(zip(x,y)) # 取最小长度3
[(1, 4), (2, 5), (3, 6)]

对象操作

dir：返回对象或者当前作用域内的属性列表

>>> dir(list)#非常重要的list属性，leetcode写代码可以直接用！
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

type：返回对象的类型，或者根据传入的参数创建一个新的类型

>>> type(1) # 返回对象的类型
<class 'int'>

#使用type函数创建类型D，含有属性InfoD
>>> D = type('D',(A,B),dict(InfoD='some thing defined in D'))
>>> d = D()
>>> d.InfoD
 'some thing defined in D'

len：返回对象的长度

>>> len('abcd') # 字符串
>>> len(bytes('abcd','utf-8')) # 字节数组
>>> len((1,2,3,4)) # 元组
>>> len([1,2,3,4]) # 列表
>>> len(range(1,5)) # range对象
>>> len({'a':1,'b':2,'c':3,'d':4}) # 字典
>>> len({'a','b','c','d'}) # 集合
>>> len(frozenset('abcd')) #不可变集合

变量操作

globals：返回当前作用域内的全局变量和其值组成的字典

>>> globals()
{'__spec__': None, '__package__': None, '__builtins__': <module 'builtins' (built-in)>, '__name__': '__main__', '__doc__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>}
>>> a = 1
>>> globals() #多了一个a
{'__spec__': None, '__package__': None, '__builtins__': <module 'builtins' (built-in)>, 'a': 1, '__name__': '__main__', '__doc__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>}

global：定义全局变量

>>> def fg():
    global a
    a=1
>>> fg()
>>> a
>>> 1
>>>def f():
    a=1
>>> f()
>>> a
>>> Traceback (most recent call last):
 	File "<ipython-input-8-60b725f10c9c>", line 1, in <module>
		a
	NameError: name 'a' is not defined

locals：返回当前作用域内的局部变量和其值组成的字典(在调试函数的时候可以返回local)

>>> def f():
        print('before define a ')
        print(locals()) #作用域内无变量
        a = 1
        print('after define a')
        print(locals()) #作用域内有一个a变量，值为1
        b=a**2
        return locals()
>>> f
<function f at 0x03D40588>
>>> f()
before define a 
{} 
after define a
{'a': 1, 'b': 1}

交互操作

print：向标准输出对象打印输出

>>> print(1,2,3)
1 2 3
>>> a = ['a', 'b', 'v', 'f', 's', 'a']
	print(a,sep = '+')
['a', 'b', 'v', 'f', 's', 'a']
>>> print(a,a,sep = '+',end = '=!')
['a', 'b', 'v', 'f', 's', 'a']+['a', 'b', 'v', 'f', 's', 'a']=！

input：读取用户输入值

>>> file = input('please enter your filename:')
please input your name:cat.png
>>> file
'cat.png'

文件操作

open：使用指定的模式和编码打开文件，返回文件读写对象

# rb为二进制读,wb为二进制写操作
>>> f = open('test.txt','rt')
>>> f.read()
'read test'
>>> f.close()
#读操作:
    #read()将文本文件所有行读到一个字符串中。 
    #readline()是一行一行的读
    #readlines()是将文本文件中所有行读到一个list中，文本文件每一行是list的一个元素。

参考：

1. Python内置函数详解——总结篇
2. Python之生成器详解