python内置函数

abs()
返回数字的绝对值。
print(abs(-12)) #结果:12
print(abs(1.23))#结果:1.23

all()
参数为一个可迭代对象，如果可迭代对象的元素有一个为，0，''(为空)，all()返回false，否则为true
print(all([1,2,3])) #true
print(all([0,2,3])) #列表元素包含0,false
print(all(["",1]))    #列表元素包含""(空) false
print(all([])    #空列表true

any()
参数为一个可迭代对象，如果可迭代对象的元素不都为0，''(空)，返回true,空迭代对象返回false，其他都为true
print(any([1,2,3])) #true
print(any([0,2,3])) #true
print(any(["",1])) #true
print(any([]))    #false

ascii()
返回一个可打印的对象字符串方式表示，如果是非ascii字符就会输出\x，\u或\U等字符来表示。与python2版本里的repr()是等效的函数。
print(ascii(1))
print(ascii("hello world"))
print(ascii("你好，世界"))
a =ascii([1,"hello world","你好，世界"])
print([a])
运行结果:
1
'hello world'
'\u4f60\u597d\uff0c\u4e16\u754c'
["[1, 'hello world', '\\u4f60\\u597d\\uff0c\\u4e16\\u754c']"]

bin()
将一个整形数字转换成二进制字符串，若参数不是整数或者函数、对象返回的值不为整数，会报错。
print(bin(10)) #0b1010 

bool()
1. 返回值为True或者False的布尔值
2. 参数如果缺省，则返回False
3. 参数转换使用标准的逻辑测试表达式
3.1 传入布尔类型时，按原值返回
3.2 传入字符串时，空字符串返回False，否则返回True
3.3 传入数值时，0值返回False，否则返回True
示例代码：
>>> bool()
False
>>> bool(True)
True
>>> bool(False)
False
>>> bool('')
False
>>> bool('0')
True
>>> bool(0)
False
>>> bool(1)
True
>>> bool(-1.0)
True
>>> bool("hello world")
True
>>> bool(())
False
>>> bool((0,))
True
>>> bool([])
False
>>> bool([0])
True
>>> bool({})
False
>>> bool({'k':'v'})
True

bytes()    
1. 返回值为一个新的不可修改字节数组，每个数字元素都必须在0 - 255范围内，是bytearray函数的具有相同的行为，差别仅仅是返回的字节数组不可修改。
2. 当3个参数都不传的时候，返回长度为0的字节数组    
a = bytes("hello world",encoding="utf-8")
print(a[0])
104
a[0] = 97 #这里会报错，不支持修改，区别于bytearray()

bytearray()
1. 返回值为一个新的字节数组(参数的ASSCII位置)
2. 当3个参数都不传的时候，返回长度为0的字节数组
参数为整数时：
>>> bytearray(12)
bytearray(b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')    
参数为字符串，需要指定本身的编码
>>> bytearray("你好，世界",encoding='utf-8')
bytearray(b'\xe4\xbd\xa0\xe5\xa5\xbd\xef\xbc\x8c\xe4\xb8\x96\xe7\x95\x8c')
3.修改二进制字符串
>>> a = bytearray("abced",encoding="utf-8") #生成了一个列表
>>> print(a[0]) #打印字母a对应ascii编码的值
97
>>> a[0]=98 #将字母a改为b
>>> print(a)
bytearray(b'bbced')

callable()
1. 方法用来检测对象是否可被调用，可被调用指的是对象能否使用()括号的方法调用。
2. 可调用对象，在实际调用也可能调用失败；但是不可调用对象，调用肯定不成功。
3. 类对象都是可被调用对象，类的实例对象是否可调用对象，取决于类是否定义了__call__方法。
示例代码：
def say_hi():
pass
print(callable([1,2,3])) #false 列表不能调用
print(callable(say_hi))    #true 函数可以调用，返回true

chr()
参数i的有效范围为0到1，114，111（0x10FFFF），参数可以是10进制也可以是16进制的形式,对应unicode编码对应的值，其它范围的值会抛出异常ValueError。
>>> chr(97)
'a'
>>> chr(0x5a)
'Z'
ord()
参数是一个unicode字符，返回值是对应的十进制整数
>>> ord('a')
97
>>> ord('Z')
90

compile()    
compile(source, filename, mode[, flags[, dont_inherit]])
参数source：字符串或者AST（Abstract Syntax Trees）对象。
参数 filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
参数model：指定编译代码的种类。可以指定为 ‘exec’,’eval’,’single’。如果是exec类型，表示这是一个序列语句，可以进行运行；
如果是eval类型，表示这是一个单一的表达式语句，可以用来计算相应的值出来；如果是single类型，表示这是一个单一语句，采用交互模式执行，在这种情况下，如果是一个表达式，一般会输出结果，而不是打印为None输出。    
code = '''
for i in range(10):
print(i)
'''
obj_py = compile(code,'error.log','exec')
exec(obj_py)

dir()
dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。
>>> dict ={}
>>> dir(dict)
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']

divmod()
divmod(a,b)方法返回的是a//b（除法取整）以及a对b的余数，返回结果类型为tuple，参数：a,b可以为数字（包括复数）
>>> divmod(9,2)
(4, 1) #结果为等于4，余1

enumerate
对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值
示例代码：
list1 = ["这", "是", "一个", "测试"]
for index, item in enumerate(list1, 1): #1为指定开始数字位置
print index,item 

eval()
1.将字符串str当成有效的表达式来求值并返回计算结果。
2.可以把list,tuple,dict和string相互转化。
示例代码：
计算：
>>> x = 1
>>> eval('x+1')
2
字符串-列表转换
>>> a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]"
>>> print(type(a))
<class 'str'>
>>> b =eval(a)
>>> print(type(b))
<class 'list'>
>>> b
[[1, 2], [3, 4], [5, 6], [7, 8], [9, 0]]

exec()
exec()函数将字符串str当成有效的Python表达式来执行，不返回计算结果：
>>> exec("print('hello world')") #内外层双引号不能相同，否则会报错
hello world






5.匿名函数
f = lambda x:x*2 #没有函数名的函数(一般用来处理简单的计算,处理不了for循环等这样的复杂语句)
lambda:关键字
x:形参
x*2：函数体，相当于return x*2
f = lambda x:x*2
等价于
def calc(x):
return x*2

单独使用的场景不多，一般配合其他函数使用,如：filter(),map(),reduce()
filter():
1.filter()函数是 Python 内置的另一个有用的高阶函数，filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，
2.filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。
例子：求100以内能被3整除的数。
res = filter(lambda x:x%3==0, [i for i in range(100)]) #filter必须要传入一个能判断真假的函数，依次将列表中的元素传入比较，将布尔值为true的添加生成一个新的列表。
for i in res:
print(i)
map():
Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。
1.例子:求0-9的每个素的平方
res = map(lambda x:x*x, [i for i in range(10)])
for i in res:
print(i)
reduce()
Python 3里,reduce()函数已经被从全局名字空间里移除了,它现在被放置在fucntools模块
reduce函数，reduce函数会对参数序列中元素进行累积。
function参数是一个有两个参数的函数，reduce依次从sequence中取一个元素，和上一次调用function的结果做参数再次调用function。 第一次调用function时，如果提供initial参数，会以sequence中的第一个元素和initial作为参数调用function，否则会以序列sequence中的前两个元素做参数调用function。
例子：求1加到9
from functools import reduce
res = reduce(lambda x,y:x+y,range(10))
print(res

执行步骤：将x+y的和，当做x再传值
1.0+1
2.1+2 
3.3+3
...
format()
格式化字符串
name = 'alex'
print("my is {_name}".format(_name =name))


frozenset()
是冻结的集合，它是不可变的，存在哈希值，好处是它可以作为字典的key，也可以作为其它集合的元素。缺点是一旦创建便不能更改，没有add，remove方法。


global()
在当前作用域下,查看全局变量,以字典形式获取，key变量名，values为变量值。

hash()
本函数返回对象的哈希值。返回的哈希值是使用一个整数表示，通常使用在字典里，以便实现快速查询键值。参数object输入是数字类型时，是根据数值来计算的，比如1和1.0计算出来是一样的哈希值，因此说这个函数是不区分不同的数值类型。
>>> hash(123)
123
>>> hash("hello")
8097327901088283448
>>> hash("你好")
2766071058062769031
help()
查看函数或模块用途的详细说明
1.查看内置函数帮助
help('dir')
2.查看模块使用帮助
help('sys')
3.查看字符串使用帮助
help('hello')
4.查看数字的使用帮助
help(123)
5.查看都迭代对象使用帮助
list = [1,2,3,4,5]
help[list] #查看列表的使用帮助
help[list.append]#查看列表append方法的使用帮助
hex()
>>> hex(10)
'0xa'
>>> hex(15)
'0xf'
>>> hex(255)
'0xff'

id()
id方法的返回值就是对象的内存地址。
>>> id("hello")
52190936
>>> id("你好")
52333096

input()
默认接收到的是str类型，等待用户输入。    

int()
将一个数字或base类型的字符串转换成整数。

isinstance()
判断实例是否是这个类或者object是变量
from collections import Iterable
from collections import Iterator
isinstance([],Iterable) #判断是不是一个可迭代对象
isinstance([],Iterator)    #判断是不是一个迭代器

iter()
将列表、字典、元祖、集合、open("file","r")等可迭代对象转为迭代器
list = [1,2,3,4]
g = iter(list)

locals()
函数会以dict类型返回当前位置的全部局部变量。
def test():
local_var = 333
print(locals())
test()

max()
1. 函数功能为取传入的多个参数中的最大值，或者传入的可迭代对象元素中的最大值。默认数值型参数，取值大者；字符型参数，取字母表排序靠后者。还可以传入命名参数key，其为一个函数，用来指定取最大值的方法。default命名参数用来指定最大值不存在时返回的默认值。
　　    2. 函数至少传入两个参数，但是有只传入一个参数的例外，此时参数必须为可迭代对象，返回的是可迭代对象中的最大元素。
>>> max([1,2,3,4,5])
5

min()
1. 函数功能为取传入的多个参数中的最小值，或者传入的可迭代对象元素中的最小值。默认数值型参数，取值小者；字符型参数，取字母表排序靠前者。还可以传入命名参数key，其为一个函数，用来指定取最小值的方法。default命名参数用来指定最小值不存在时返回的默认值。功能与max函数相反。
2. 函数至少传入两个参数，但是有只传入一个参数的例外，此时参数必须为可迭代对象，返回的是可迭代对象中的最小元素。
>>> min([1,2,3,4,5])
1

next()
迭代器的next()，取下一个值

oct()
返回一个整数的八进制表示。
>>> oct(10)
'0o12'
>>> oct(12)
'0o14'    

open()
操作文件
f = open("file.txt","r",encoding='utf-8')
模式：r,w,a,r+,w+,a+,rb,wb,ab,rb+,wb+,ab+,rU,wU,aU,rU+,wU+,aU+

pow()
计算多少次幂
>>> pow(2,8)
256

print()
格式化打印输出

range()
创建一个整数列表，一般用在 for 循环中。

repr()
将任意值转为字符串,转化为供解释器读取的形式。函数str() 用于将值转化为适于人阅读的形式。

reversed()
返回序列seq的反向访问的迭代子。参数可以是列表，元组，字符串，不改变原对象。
list = [1,2,3,4,5,6]
list1 = reversed(list)
for i in list1:
print(i)
运行结果:
6
5
4
3
2
1

round()
返回浮点数x的四舍五入值。
>>> round(3.1423)
3
>>> round(3.53)
4
>>> round(3.1234,2)
3.12
>>> round(3.1274,2)
3.13

set()
创建一个集合
>>>set('boy')
set(['y', 'b', 'o'])

sorted()
对所有可迭代的对象进行排序操作。
intdic = {2:4,5:8,92:0,0:54,10:432}
print(sorted(intdic.items())) #按key值排序
print(sorted(intdic.items(),key=lambda x:x[1])) #按key值排序
运行结果：
[(0, 54), (2, 4), (5, 8), (10, 432), (92, 0)]
[(92, 0), (2, 4), (5, 8), (0, 54), (10, 432)]

str()
将对象转化为适于人阅读的形式。

sum()
对系列进行求和计算
>>>sum([0,1,2]) 
3 
>>> sum((2, 3, 4), 1) # 元组计算总和后再加 1
10
>>> sum([0,1,2,3,4], 2) # 列表计算总和后再加 2
12

tuple()
将列表、字典（key）转换为元组。
>>> tuple([1,2,3,4])
(1, 2, 3, 4)
>>> tuple((1,2,3,4))
(1, 2, 3, 4)
>>> tuple({1:2,3:4})
(1, 3)

type()
返回对象的类型


zip()
用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
a = ["a","b","c","d"] #当a,b元素个数不相等时，以a为准
b = [1,2,3,4,]
for i in zip(a,b):
print(i)
执行结果：
('a', 1)
('b', 2)
('c', 3)
('d', 4)

__import__()
同import语句同样的功能，但__import__是一个函数，并且只接收字符串作为参数
__import__('decorator') #当只知道模块名的字符串格式