python常用内置函数

常用内置函数

abs()

abs()是绝对值函数，返回数字的绝对值。

>>> abs(-5.9)
5.9
>>> abs(15)
15
>>> abs(-5)
5
>>> 

all()和any()

all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否不为 0、''、False 或者 iterable 为空，如果是返回 True，否则返回 False。简言之:所有为真才返回True

any() 函数用于判断给定的可迭代参数 iterable 是否全部为空对象，如果都为空、0、false，则返回 False，如果不都为空、0、false，则返回 True。简言之:有一个为真就是真True

>>> all([1,2,3,'',0])
False
TypeError: all() takes exactly one argument (3 given)
>>> all([1,2,3])
True
>>> all([])    #all参数里是个空列表时返回True
True
>>> 

>>> any([1,2,3,'',0])
True
>>> any(['',0,False])
False
>>> 
>>> any([])
False
>>> 

bool()

bool()函数用于将给定参数转换为布尔类型，没有参数则返回False。
只有空''、0、False布尔值为False

>>> bool(0)
False
>>> bool(1)
True
>>> bool('')
False
>>> bool(False)
False
>>> 

chr()和ord()

chr() 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符。

ord() 函数是 chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常。

>>> print (chr(65),chr(97))
A a
>>> 

>>> print (ord('A'),ord('a'))
65 97
>>> 

bytes()

>>> bytes('hello',encoding='utf-8')
b'hello'
>>> x = 'hello'
>>> x.encode('utf-7')
b'hello'
>>> x.encode('utf-8')
b'hello'
>>> 

dict()

dict()函数用于创建一个字典

>>> dict()     #空字典
{}
>>> dict(a='a',b='b',c='c')     #传入关键字
{'a': 'a', 'b': 'b', 'c': 'c'}
>>> dict(zip(['one', 'two', 'three'], [1, 2, 3]))   #zip()映射函数实现
{'one': 1, 'two': 2, 'three': 3}
>>> dict([('one', 1), ('two', 2), ('three', 3)]) #可迭代的键值对
{'one': 1, 'two': 2, 'three': 3}

divmod()

divmod(a,b)返回a除b的商和余数。

>>> divmod(5,2)
(2, 1)
>>> divmod(5.5,2)
(2.0, 1.5)
>>> divmod(5.5,2.5)
(2.0, 0.5)
>>> 

enumrate()

enumerate(iterable，start)
返回枚举对象。 iterable必须是序列，迭代器或支持迭代的其他对象。
iterable------一个序列，迭代器或者其他支持迭代对象。
start------下标起始位置，默认为从0开始。
示例：

>>> list2=['one','two','three']	
>>> for k,v in enumerate(list2,1):
		print(k,v)


1 one
2 two
3 three

>>> for k in enumerate(list2):
print (k)


(0, 'one')
(1, 'two')
(2, 'three')

>>> for k,v in enumerate(list2):
print (k,v)


0 one
1 two
2 three

eval()

eval() 函数用来执行一个字符串表达式，并返回表达式的值。

>>> eval("{'name':'tom','age':50}") #使用双引号或者三引号
{'name': 'tom', 'age': 50}
>>>
>>> x = 1
>>> eval('x+2')
3 

exec()

exec()用于执行字符串或者文件中的python语句。

>>> exec("print('Hello,World')")
Hello,World
>>> exec('''print('Hello,World')''')
Hello,World
>>> exec("if True: print(200)")
200
>>> 

def tt(name):
	print('hello %s' %name)

exec("tt('bob')")
#执行结果：
hello bob

format()

format()和%格式化功能一样，基本语法是通过 {} 和：来代替以前的%。format函数可以接受不限个参数，位置可以不按顺序。
示例：

>>> msg='Nname:{},age:{},sex:{}'
>>> print(msg.format('tom',18,'male'))
Nname:tom,age:18,sex:male

>>> print (msg.format(x='tom',y=18,z='male'))
Nname:tom,age:18,sex:male

>>> url='https://movie.douban.com/top250?start={page}&filter=&type='
>>> print(url.format(page=50))
https://movie.douban.com/top250?start=50&filter=&type=
>>> 

map()

map(function, iterable, ...)
返回一个迭代器对象，它将函数应用于可迭代的每个项目，从而产生结果。 如果传递额外的可迭代参数，函数必须使用许多参数，并且并行地应用于所有迭代的项目。

>>> res = map(lambda x:x**2,[1,2,3,4])
>>> list(res)
[1, 4, 9, 16]

>>> res = map(lambda x,y:x+y,[1,2,3,4],[5,6,7,8])
>>> list(res)
[6, 8, 10, 12]

>>> res = map(lambda x,y,z:x+y+z,[1,2,3,4],[5,6,7,8],[1,1,2,2])
>>> list(res)
[7, 9, 12, 14]

reduce()

在Python 3里,reduce()函数已经被从全局名字空间里移除了,它现在被放置在fucntools模块里 用的话要 先引入：
from functools import reduce
reduce()函数语法形式：
reduce(function, sequence[, initial]) -> value
function参数是一个有两个参数的函数，reduce依次从sequence中取一个元素，和上一次调用function的结果作为参数再次调用function,第一次调用function时，如果提供initial(初始)参数，会以sequence中的第一个元素和initial作为参数调用function，否则会以序列sequence中的前两个元素做参数调用function。

简单的说就是：
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

示例：

>>> from functools import reduce
>>> reduce(lambda x,y:x+y,range(101))   # 相当于 ((1 + 2) + 3) + 4 + ... 100
5050
>>> reduce(lambda x,y:x+y,range(101),11)  # 相当于 ((11 + 1) + 2) + 3 + ... 100
5061
>>> 

>>> reduce(lambda x, y: x * y, [1, 2, 3, 4])  # 相当于 ((1 * 2) * 3) * 4
24
>>> reduce(lambda x, y: x * y, [1, 2, 3, 4], 5) # ((((5 * 1) * 2) * 3)) * 4
120
>>> reduce(lambda x, y: x / y, [2, 3, 4], 72)  #  (((72 / 2) / 3)) / 4
3
>>> reduce(lambda x, y: x + y, [1, 2, 3, 4], 5)  # ((((5 + 1) + 2) + 3)) + 4
15
>>> reduce(lambda x, y: x - y, [8, 5, 1], 20)  # ((20 - 8) - 5) - 1
6
>>> f = lambda a, b: a if (a > b) else b   # 两两比较，取最大值
>>> reduce(f, [5, 8, 1, 10])
10

filter()

filter()函数用于过滤列表中满足条件的元素输出到一个新列表,使用形式如下：

filter(function, sequnce)
解释：将 function 依次作用于 sequnce 的每个 item，即 function(item)，将返回值为 True 的 item 组成一个 List/String/Tuple (取决于 sequnce 的类型，python3 统一返回迭代器) 返回。

示例：

>>> print(list(filter(lambda x: x % 2 == 0, [1, 2, 3, 4, 5, 6])))

[2, 4, 6]
>>> print(list(filter(lambda x: x % 2, [1, 2, 3, 4, 5, 6])))
[1, 3, 5]

>>> z = [{'name': 'tom','age': 18}, {'name': 'bob','age': 38}, {'name': 'kom','age': 28}]
>>> print(list(filter(lambda x:x['name'].startswith('to'),z)))
[{'name': 'tom', 'age': 18}]
>>> 

max()

max(iterable, *[, key, default])
当key参数不为空时，就以key的函数对象为判断的标准。
指定key和不指定key区别，如下示例：

#不指定key
>>> max(1,8,3,5)
8
>>> max([1,5,9,2])
9
>>> 

#指定key的列表取最大值
>>> x = [-9, -8, 1, 3, -4, 6]
>>> max(x,key=lambda x:abs(x))
-9
>>> 

#指定key的字典找到value最大的key输出
>>> prices = {'A': 123, 'B': 450.1, 'C': 12, 'E': 444}
>>> list(zip(prices.values(),prices.keys()))
[(123, 'A'), (450.1, 'B'), (12, 'C'), (444, 'E')]
>>> m = list(zip(prices.values(),prices.keys()))
>>> max(m)   # 默认按照第第一个比较
(450.1, 'B')
>>> max(m,key=lambda x:x[0])  #指定x[0],这里就是价格
(450.1, 'B')
>>> n = list(zip(prices.keys(),prices.values()))
>>> max(n,key=lambda x:x[1])   #直接这样比较x[1]
('B', 450.1)
>>> 

min()

min(iterable, *[, key, default])
当key参数不为空时，就以key的函数对象为判断的标准。
指定key和不指定key区别，和max用法一致。如下示例：

>>> min(1,8,3,5)
1
>>> min([1,5,9,2])
1

#指定key的字典找到value最小的key输出（参考上面的max）
>>> prices = {'A': 123, 'B': 450.1, 'C': 12, 'E': 444}
>>> m = list(zip(prices.values(),prices.keys()))
>>> m
[(123, 'A'), (450.1, 'B'), (12, 'C'), (444, 'E')]
>>> min(m)
(12, 'C')
>>> min(m,key=lambda x:x[0])
(12, 'C')
>>> n = list(zip(prices.keys(),prices.values()))
>>> n
[('A', 123), ('B', 450.1), ('C', 12), ('E', 444)]
>>> min(n,key=lambda x:x[1])
('C', 12)
>>> 

sorted()

sorted(iterable[, key][, reverse])
排序函数，不改变原来的值。

>>> x = [5,7,9,-1,-8]
>>> sorted(x)     #正向排序
[-8, -1, 5, 7, 9]
>>> sorted(x,reverse=True)  #反向排序
[9, 7, 5, -1, -8] 
>>> 

#使用key
>>> students = [('john', 'A', 15), ('jane', 'B', 12), ('dave','B', 10)]
>>> sorted(students,key=lambda x:x[2])
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
>>> 

list1=[7, -8, 5, 4, 0, -2, -5]
#要求1.正数在前负数在后 2.整数从小到大 3.负数从大到小
>>> sorted(list1,key=lambda x:(x<0,abs(x)))  #先利用x<0排负数大小（分出正负）,再利用abs(x)排大小
[0, 4, 5, 7, -2, -5, -8]
>>> 

zip()

zip函数接受任意多个（包括0个和1个）序列作为参数，返回一个tuple列表。俗称拉链函数

#相同长度序列zip	
>>> x = [1, 2, 3]
>>> y= [4, 5, 6]
>>> z= [7, 8, 9]
>>> xyz = zip(x,y,z)
>>> xyz
<zip object at 0x000001C51F305C08>
>>> list(xyz)
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
>>> 

#不同长度zip，取其最短
>>> x = [1,2,3]
>>> y = [4,5,6,7]
>>> xy = zip(x,y)
>>> list(xy)
[(1, 4), (2, 5), (3, 6)]
>>> 

#zip传入一个序列时
>>> x = [1,2,3]
>>> m = zip(x)
>>> list(m)
[(1,), (2,), (3,)]
>>>

frozenset()

frozenset([iterable]) 转化为不可变集合

globals()

globals() 可以通过字典方式查看全局变量

locals()

globals() 可以通过字典方式查看局部变量

hash()

有hash值的数据类型是不可变类型，无hash值的是可变类型

help()

help([object]) 在解释器交互界面，不传参数调用函数时，将激活内置的帮助系统，并进入帮助系统。在帮助系统内部输入模块、类、函数等名称时，将显示其使用说明，输入quit退出内置帮助系统，并返回交互界面；在解释器交互界面，传入参数调用函数时，将查找参数是否是模块名、类名、函数名，如果是将显示其使用说明。

id()

id(object) 返回对象的内存地址

input()

input([prompt]) 与用户交互，返回用户输入的值，类型为字符串

int()

int(x,base=10) 将对象转化为整数型

float()

float([x]) 转化为浮点型

str()

str(object=’’) 将对象转化为字符串形式

tuple()

tuple([iterable]) 将可迭代对象转化为元组

isinstance()

isinstance(object,classinfo) 判断object是不是classinfo类型的数据

iter()

iter(object[,sentinel]) 返回一个迭代器，如果不提供sentinel参数，则object必须为可迭代对象，当第二个参数sentinel提供时，第一个参数必须是一个可被调用对象。

len()

len(s) 返回一个对象的长度

list()

list([iterable]) 将可迭代对象转化为列表

next()

next(iterator[,default]) 函数必须接收一个迭代器参数，每次调用的时候，返回可迭代对象的下一个元素。如果所有元素均已经返回过，则抛出StopIteration 异常；函数可以接收一个可选的default参数，传入default参数后，如果可迭代对象还有元素没有返回，则依次返回其元素值，如果所有元素已经返回，则返回default指定的默认值而不抛出StopIteration 异常。

bin()

bin(x) 将十进制数转化为二进制数，以0b开头

oct()

oct(x) 将十进制数转化为八进制数，以0o开头

hex()

hex(x) 将十进制数转化为十六进制数，以0x开头

open()

open(file,mode=’r’,buffering=-1,encoding=None,errors=None,newline=None,closefd=True,opener=None)打开文件，默认为只读模式打开

pow()

pow(x,y[,z]) 函数有两个必需参数x,y和一个可选参数z，结果返回x的y次幂乘(相当于x**y)，如果可选参数z有传入值，则返回幂乘之后再对z取模

print()

print(*object,sep=’’,end=’\n’,file=sys.stdout,flush=False)打印

range()

range(start,stop[,step]) 一个范围start<<x<stop，默认步长为1.

repr()

repr(object) 返回对象的详细说明字符串

reversed()

reversed(seq) 返回序列seq的反转序列

round()

round(number[,ndigits]) round函数用于对浮点数进行四舍五入求值，具体保留几位小数，以传入的ndigits参数来控制。默认返回整数； ndigits参数传入0时，虽然与不传入ndigits参数一样保留0位小数进行四舍五入，但是返回的值是浮点型；ndigits参数小于0时，对整数部分进行四舍五入，ndigits参数控制了对浮点数的整数部分的后几位进行四舍五入，小数部分全部清0，返回类型是浮点数。如果传入的浮点数的整数部分位数小于ndigits参数绝对值，则返回0.0；round四舍五入时是遵循靠近0原则，所以-0.5和0.5进行0位四舍五入，返回的都是0.

set()

set([iterable]) 将可迭代对象转化为集合

slice()

class slice(stop)
class slice(start,stop[,step]) 实际上是一个切片类的构造函数，返回一个切片对象。切片对象主要用于对序列对象进行切片取对应元素。

sum()

sum(iterable[,start]) 对可迭代对象求和

type()

type(object) 返回对象的数据类型