Python内置函数

abs()　获取绝对值

>>> abs(-10)
10

all()   参数为可迭代对象.如果迭代对象的所有元素都为真，那么返回True，否则返回False.注意，迭代对象为空时，返回True

all(['python',123])
--->True
 
all([])
--->True
 
all([0])
--->False
 
all(" ")
--->True
 
all(1,' ',2,None)
--->False

any()  参数为可迭代对象，只要任一元素为真，则返回真。参数为空时返回True

print(any([None,0,' ',{},1]))
--->True
 
print(any(' '))
--->True

sum()  求和

>>> res = sum(i for i in range(5))
>>> print(res)
10

bin()  将参数转化为二进制

>>> bin(3)
'0b11'
>>> bin(10)
'0b1010'

bool()   布尔函数，返回bool值，False或True

>>> bool(3)
True
>>> bool(0)
False
>>> bool(None)
False

ascii()　　调用对象的__repr__()方法，获得该方法的返回值

bytes()  将一个字符串转化为字节类型

>>> print(bytes('hello',encoding='utf-8'))
b'hello

str()将字符类型/数值类型等转换为字符串类型

>> str(1)
'1

chr()   查看十进制数对应的ASCII字符

>>> chr(65)
'A'
>>> chr(90)
'Z'
>>> chr(97)
'a'
>>> chr(122)
'z'

ord()   查看某个ASCII对应的十进制数

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

callabe()   判断对象是否可以被调用，能被调用的对象就是一个callables对象，比如函数和带有__call__()的实例

classmethod()　用来指定一个方法为类的方法，由类直接调用执行，只有一个cls参数,执行类的方法时，自动将调用该方法的类赋值给cls.没有此参数指定的类的方法为实例方法

class Province:
    country = "中国"
       
    def __init__(self, name):
        self.name = name
       
    @classmethod
    def show(cls):  # 类方法，由类调用，最少要有一个参数cls，调用的时候这个参数不用传值，自动将类名赋值给cls
        print(cls)
       
# 调用方法
Province.show()

float()　将一个字符串或整数转换为浮点数

>>> print(float(1))
1.0

frozenset()   不可变集合

dir()　不带参数时返回当前范围内的变量，方法和定义的类型列表，带参数时返回参数的属性，方法列表

>>> dir()
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__']
>>> dir(sum)#输出sum下有哪些可被sum调用的方法。（对象.方法），sum.方法

divmod()　　分别取商和余数.二个参数x和y，输出元组（x//y,x%y）

print(divmod(100,33))
--->(3,1)

enumerate()　　返回一个可以枚举的对象，该对象的next()方法将返回一个元组

for i in enumerate(['a','b','c','d']):
    print(i)

结果：
(0, 'a')
(1, 'b')
(2, 'c')
(3, 'd')

eval()　将字符串str中的表达式提取出来并运行

s= "1 + 2 * 3"
print(type(s))
print(eval(s))

结果：
<class 'str'>
7

exec()　执行字符串或complie方法编译过的字符串，没有返回值

exec函数和eval函数类似，也是执行动态语句，只不过eval函数只用于执行表达式求值，而exec函数主要用于执行语句块。

>>> eval('a=1+2') #执行语句报错
Traceback (most recent call last):
  File "<pyshell#0>", line 1, in <module>
    eval('a=1+2')
  File "<string>", line 1
    a=1+2
     ^
SyntaxError: invalid syntax

>>> exec('a=1+2') #执行语句
>>> a

#1、语法
# eval(str,[,globasl[,locals]])
# exec(str,[,globasl[,locals]])

#2、区别
#示例一：
s='1+2+3'
print(eval(s)) #eval用来执行表达式，并返回表达式执行的结果
print(exec(s)) #exec用来执行语句，不会返回任何值
'''
None
'''

#示例二：
print(eval('1+2+x',{'x':3},{'x':30})) #返回33
print(exec('1+2+x',{'x':3},{'x':30})) #返回None

# print(eval('for i in range(10):print(i)')) #语法错误，eval不能执行表达式
print(exec('for i in range(10):print(i)'))

eval与exec

filter()　过滤器，构造一个序列，等价于[ item for item in iterables if function(item)]，在函数中设定过滤条件，逐一循环迭代器中的元素，将返回值为True时的元素留下，形成一个filter类型数据

format()　格式化输出字符串

#字符串可以提供的参数 's' None
>>> format('some string','s')
'some string'
>>> format('some string')
'some string'

#整形数值可以提供的参数有 'b' 'c' 'd' 'o' 'x' 'X' 'n' None
>>> format(3,'b') #转换成二进制
'11'
>>> format(97,'c') #转换unicode成字符
'a'
>>> format(11,'d') #转换成10进制
'11'
>>> format(11,'o') #转换成8进制
'13'
>>> format(11,'x') #转换成16进制 小写字母表示
'b'
>>> format(11,'X') #转换成16进制 大写字母表示
'B'
>>> format(11,'n') #和d一样
'11'
>>> format(11) #默认和d一样
'11'

#浮点数可以提供的参数有 'e' 'E' 'f' 'F' 'g' 'G' 'n' '%' None
>>> format(314159267,'e') #科学计数法，默认保留6位小数
'3.141593e+08'
>>> format(314159267,'0.2e') #科学计数法，指定保留2位小数
'3.14e+08'
>>> format(314159267,'0.2E') #科学计数法，指定保留2位小数，采用大写E表示
'3.14E+08'
>>> format(314159267,'f') #小数点计数法，默认保留6位小数
'314159267.000000'
>>> format(3.14159267000,'f') #小数点计数法，默认保留6位小数
'3.141593'
>>> format(3.14159267000,'0.8f') #小数点计数法，指定保留8位小数
'3.14159267'
>>> format(3.14159267000,'0.10f') #小数点计数法，指定保留10位小数
'3.1415926700'
>>> format(3.14e+1000000,'F')  #小数点计数法，无穷大转换成大小字母
'INF'

#g的格式化比较特殊，假设p为格式中指定的保留小数位数，先尝试采用科学计数法格式化，得到幂指数exp，如果-4<=exp<p，则采用小数计数法，并保留p-1-exp位小数，否则按小数计数法计数，并按p-1保留小数位数
>>> format(0.00003141566,'.1g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点
'3e-05'
>>> format(0.00003141566,'.2g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留1位小数点
'3.1e-05'
>>> format(0.00003141566,'.3g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留2位小数点
'3.14e-05'
>>> format(0.00003141566,'.3G') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点，E使用大写
'3.14E-05'
>>> format(3.1415926777,'.1g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留0位小数点
'3'
>>> format(3.1415926777,'.2g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留1位小数点
'3.1'
>>> format(3.1415926777,'.3g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留2位小数点
'3.14'
>>> format(0.00003141566,'.1n') #和g相同
'3e-05'
>>> format(0.00003141566,'.3n') #和g相同
'3.14e-05'
>>> format(0.00003141566) #和g相同
'3.141566e-05'

format(了解即可)

getattr()　获取对象的属性

getattr(object, name [, defalut])
获取对象object名为name的特性，如果object不包含名为name的特性，将会抛出AttributeError异常；如果不包含名为name的特性
且提供default参数，将返回default。
参数object：对象
参数name：对象的特性名
参数default：缺省返回值
 
print(getattr(list, 'append'))
---> <method 'append' of 'list' objects>
 
mylist = [3, 4, 5]
append(mylist, 6)
print(mylist)
--->[3, 4, 5, 6]
 
print(getattr(list, 'add'))
--->Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: type object 'list' has no attribute 'add'
 
print(getattr(list, 'add', 'NoMethod'))
---> 'NoMethod'

globals()　返回一个描述当前全局变量的字典

hasattr()

hasattr(object，name)
判断对象object是否包含名为name的特性（hasattr是通过调用getattr(object，name)）是否抛出异常来实现的。
参数object：对象
参数name：特性名称
 
print(hasattr(list, 'append'))
---> True
 
print(hasattr(list, 'add'))
---> False

hash()　哈希值

hash(object)
hash是一种算法，二个数值相等hash值是确定的唯一的，常用来校验数据。<br>hash值不能逆推。
如果对象object为哈希表类型，返回对象object的哈希值。哈希值为整数，在字典查找中，哈希值用于快递比价字典的键。
两个数值如果相等，则哈希值也相等。

hex()   十进制转化为十六进制

>>> print(hex(10))
0xa

id()  查看唯一标识的身份

help()　返回对象的帮助文档

input()　获取用户输入内容

isinstance()   检查对象是否是类的对象，返回True或False

issubclass()　检查一个类是否是另一个类的子类。返回True或False

issubclass(sub, super)
检查sub类是否是super类的派生类（子类）。返回True 或 False
  
class Foo(object):
    pass
    
class Bar(Foo):
    pass
    
issubclass(Bar, Foo)

zip()     ‘拉链’，一对一的

>>> print(list(zip(('a','n','c'),(1,2,3))))
[('a', 1), ('n', 2), ('c', 3)]
>>> print(list(zip(('a','n','c'),(1,2,3,4))))
[('a', 1), ('n', 2), ('c', 3)]
>>> print(list(zip(('a','n','c','d'),(1,2,3))))
[('a', 1), ('n', 2), ('c', 3)]
>>> print(list(zip(['a','b'],'12345')))
[('a', '1'), ('b', '2')]

max

# 得到年龄最大的那个
age_dic={'alex_age':18,'wupei_age':20,'zsc_age':100,'lhf_age':30}

>>> print('=======>',max(zip(age_dic.values(),age_dic.keys())))
=======> (100, 'zsc_age')

# 不同类型之间不能进行比较
# l=[
#     (5,'e'),
#     (1,'b'),
#     (3,'a'),
#     (4,'d'),
# ]
# # l1=['a10','b12','c10',100] #不同类型之间不能进行比较
# l1=['a10','a2','a10'] #不同类型之间不能进行比较
# print(list(max(l)))
# print('--->',list(max(l1)))

# 传函数
people=[
    {'name':'alex','age':1000},
    {'name':'wupei','age':10000},
    {'name':'yuanhao','age':9000},
    {'name':'linhaifeng','age':18},
]
max(people,key=lambda dic:dic['age'])
print(max(people,key=lambda dic:dic['age']))

sorted()

l=[3,2,1,5,7]
l1=[3,2,'a',1,5,7]
print(sorted(l))
print(sorted(l1)) #排序本质就是在比较大小，不同类型之间不可以比较大小

>>> people=[
...     {'name':'alex','age':1000},
...     {'name':'wupei','age':10000},
...     {'name':'yuanhao','age':9000},
...     {'name':'linhaifeng','age':18},
... ]
>>> print(sorted(people,key=lambda dic:dic['age']))
[{'name': 'linhaifeng', 'age': 18}, {'name': 'alex', 'age': 1000}, {'name': 'yuanhao', 'age': 9000}, {'name': 'wupei', 'age': 10000}]

name_dic={
    'abyuanhao': 11900,
    'alex':1200,
    'wupei':300,
}
print(sorted(name_dic))
print(sorted(name_dic,key=lambda key:name_dic[key]))  # 用key的前提是"name_dic"是可迭代的
print(sorted(zip(name_dic.values(),name_dic.keys())))

map()    映射，第一个参数为函数，第二个参数为可迭代对象

round()　四舍六入五留双，五留双留离整数最近的偶数

print(round(10.3))
----> 10
 
print(round(10.5))
----> 10
 
print(round(10.6))
----> 11
 
print(round(10.9))
----> 11
 
print(round(11.5))
----> 12

pow()　幂函数

>>> print(pow(3,3))
27
>>> print(pow(2,5))
32

reduce()   合并，第一个参数为函数，第二个参数为可迭代对象。第三个参数可有可无，默认初始值。

oct()   十进制转化为八进制

vars    没有参数时和locals()一样，有参数得到字典