python基础---内置函数

xsmscb

　　
　　内置函数
　　1、内置函数（工厂函数）
　　内置函数id()可以返回一个对象的身份，返回值为整数。这个整数通常对应与该对象在内存中的位置，但这与python的具体实现有关，不应该作为对身份的定义，即不够精准，最精准的还是以内存地址为准。
　　is运算符用于比较两个对象的身份
　　等号比较两个对象的值
　　内置函数type()则返回一个对象的类型
　　常用内置函数：
　　abs()          取绝对值
print(abs(-1))　　

　　
输出：
　　
1
　　all()      传入一个可迭代对象，如果对象中的值都能取出返回True，否则返回False
print(all([1,2,'a',None]))　　
print(all([]))
　　
输出：
　　
False
　　
True
　　any()         传入一个可迭代对象，如果对象中有至少一个值能取出来，返回True，否则返回False，bool值为假的情况：None，空，0，Flase
print(any([' ',None,False])) #True　　
print(any(['',None,False])) #False
　　
print(any(['',None,False,1])) #True
　　bin()          二进制
　　oct()          八进制
　　hex()          十六进制
print(bin(10))　　
print(oct(10))
　　
print(hex(10))
　　
输出：
　　
0b1010
　　
0o12
　　
0xa
　　bytes()       把传入对象转为bytes类型
　　unicode -----> encode -----> bytes
print(bytes('hello',encoding='utf-8'))　　

　　
输出：
　　
b'hello'
　　callable()     检测传入对象能否被执行（加括号执行），结果返回布尔值
print(callable(bytes))　　
print(callable(abs))
　　
输出：
　　
True
　　
True
　　chr()     对应ASCII编码，根据十进制数字取出对应的字符
　　ord()    对应ASCII编码，根据字符取出对应的十进制数字
print(chr(65)) #在ascii编码中，65-90对应字母A-Z　　
print(chr(90))
　　

　　
print(ord('#'))
　　
输出：
　　
A
　　
Z
　　
35
　　面向对象中的重点内置函数
　　classmethod()
　　staticmethod()
　　property()
　　delattr()
　　hasattr()
　　setattr()
　　getattr()
　　数据类型都是内置函数
　　int()           整型数字
　　complex()       复数
　　float()        浮点数
　　str()           字符串
　　dict()        字典
　　list()        列表
　　tuple()        元组
　　set()           可变集合
　　forzenset()       不可变集合（集合里的值固定不变）
　　dir()           查看模块下能够调取的属性方法
import sys　　
# sys.path     #sys模块下的属性方法
　　
# sys.argv
　　
print(dir(sys))
　　
输出：
　　
['__displayhook__', '__doc__', '__excepthook__' ......]  #sys模块下方法
　　divmod()     传入两个参数，两数相除，返回商和余数（适用于计算分页数量）
print(divmod(10,3))　　
print(divmod(102,20))
　　
输出：
　　
(3, 1)
　　
(5, 2)
　　enumerate()           取出传入的列表中的元素和索引
l=['a','b','c']　　
res=enumerate(l)
　　
for i in res:
　　
    print(i)
　　
for index,item in enumerate(l):
　　
    print(index,item)
　　
输出：
　　
(0, 'a')
　　
(1, 'b')
　　
(2, 'c')
　　
0 a
　　
1 b
　　
2 c
　　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'
　　globals()     查看全局作用域（内置、全局命名空间）
　　locals()     查看局部作用域
　　hash()        返回传入对象的校验值
print(hash('abcdefg123'))　　
print(hash('abcdefg123'))
　　
输出：
　　
6531764118696325436
　　
6531764118696325436
　　help()         查看注释信息
　　给函数加文档解释，用到单引号，双引号，三引号，使用#做注释不会打印
　　id()       返回传入对象的内存地址（id只是python解释器实现的功能，只是反映了对象在内存的地址，但并不是真实的内存地址）
def func():pass　　
print(id(func))
　　
print(func)
　　
输出：
　　
30424600
　　
<function func at 0x0000000001D03E18>
　　isinstance()       判断一个变量的类型（面向对象中会详解）
x=1　　
print(type(x) is int)
　　
print(isinstance(x,int)) #x=int(1)
　　
输出：
　　
True
　　
True
　　max()         取最大值
　　min()          取最小值
　　只能同数据类型之间比较
　　pow()         做幂和取模运算（可以传两个或者三个参数）
print(pow(3,2,2)) #3**2%2　　

　　
输出：
　　
1
　　repr()         把一个对象转换成字符串类型
　　==str()
　　区别：前者是给python解释器用的，后者是给用户用的
　　reversed()   反转传入对象
l=[1,'a',2,'c']　　
print(list(reversed(l)))
　　
print(l)
　　
输出：
　　
['c', 2, 'a', 1]
　　
[1, 'a', 2, 'c']
　　round() 传入两个参数，保留小数位数
print(round(3.456,2))　　

　　
输出：
　　
3.46
　　slice()         切片（传入三个参数，前两个切片范围，最后一个为步长）
　　sorted() 排序（把传入对象从小到大进行排序，只能同数据类型）
l=[1,10,4,3,-1]　　
print(sorted(l))
　　
print(sorted(l,reverse=True)) #使用reverse内置函数实现从大到小排序
　　
输出：
　　
[-1, 1, 3, 4, 10]
　　
[10, 4, 3, 1, -1]
　　sum()         求和
print(sum([1, 2,3]))　　

　　
print(sum(i for i in range(10)))
　　
输出：
　　
6
　　
45
　　zip()     拉链，两个对象的值一一对应
s='hellosssssssssssssssss'　　
l=[1,2,3,4,5]
　　

　　
print(list(zip(s,l)))
　　
输出：
　　
[('h', 1), ('e', 2), ('l', 3), ('l', 4), ('o', 5)] #多出的不显示
　　内置函数与匿名函数的结合：
　　匿名函数
　　应用于一次性的场景，临时使用
　　a.没有名字
　　b.函数体自带return
　　练习：
　　取出薪资最高的人名：
# 方法一：使用内置函数　　
salaries={
　　
'egon':3000,
　　
'alex':100000000,
　　
'wupeiqi':10000,
　　
'yuanhao':2000
　　
}
　　
print(max(zip(salaries.values(),salaries.keys()))[1])
　　

　　
输出：
　　
alex
　　

　　
# 方法二：内置函数与匿名函数结合
　　
salaries={
　　
'egon':3000,
　　
'alex':100000000,
　　
'wupeiqi':10000,
　　
'yuanhao':2000
　　
}
　　

　　
# lambda name:salaries[name]   #匿名函数
　　

　　
print(max(salaries,key=lambda name:salaries[name]))
　　
print(min(salaries,key=lambda name:salaries[name]))
　　
输出：
　　
alex
　　
yuanhao
　　薪资从低到高排序：
salaries={　　
'egon':3000,
　　
'alex':100000000,
　　
'wupeiqi':10000,
　　
'yuanhao':2000
　　
}
　　
def get_value(name):
　　
    return salaries[name]
　　

　　
print(sorted(salaries,key=get_value))
　　
print(sorted(salaries,key=get_value,reverse=True))
　　
输出：
　　
['yuanhao', 'egon', 'wupeiqi', 'alex']
　　
['alex', 'wupeiqi', 'egon', 'yuanhao']
　　map()        映射
names=['alex','wupeiqi','yuanhao','yanglei','egon']　　

　　
res=map(lambda x:x if x == 'egon' else x+'SB',names)
　　
print(res)
　　
print(list(res))
　　
输出：
　　
<map object at 0x00000000021DCDD8>
　　
['alexSB', 'wupeiqiSB', 'yuanhaoSB', 'yangleiSB', 'egon']
　　filter()         过滤（根据返回的布尔值，只留下返回True的值）
names=['alex_SB','wupeiqi_SB','yuanhao_SB','yanglei_SB','egon']　　
print(list(filter(lambda name:name.endswith('SB'),names)))
　　
输出：
　　
['alex_SB', 'wupeiqi_SB', 'yuanhao_SB', 'yanglei_SB']
　　reduce()      传入两个对象，把后一个对象当做初始值，使用for循环的方式操作两个对象
　　需要先导入functools模块
from functools import reduce　　

　　
# 100以内的数字相加
　　
print(reduce(lambda x,y:x+y,range(101),100))
　　
print(reduce(lambda x,y:x+y,range(101)))
　　
输出：
　　
5150
　　
5050