python基础---内置函数

内置函数

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