内置函数
1、内置函数（工厂函数）
内置函数id()可以返回一个对象的身份，返回值为整数。这个整数通常对应与该对象在内存中的位置，但这与python的具体实现有关，不应该作为对身份的定义，即不够精准，最精准的还是以内存地址为准。
is运算符用于比较两个对象的身份
等号比较两个对象的值
内置函数type()则返回一个对象的类型
常用内置函数：
abs() 取绝对值
|
1
2
3
4
|
print
(
abs
(
-
1
))
输出：
1
|
all() 传入一个可迭代对象，如果对象中的值都能取出返回True，否则返回False
|
1
2
3
4
5
|
print
(
all
([
1
,
2
,
'a'
,
None
]))
print
(
all
([]))
输出：
False
True
|
any() 传入一个可迭代对象，如果对象中有至少一个值能取出来，返回True，否则返回False，bool值为假的情况：None，空，0，Flase
|
1
2
3
|
print
(
any
([
' '
,
None
,
False
]))
#True
print
(
any
(['',
None
,
False
]))
#False
print
(
any
(['',
None
,
False
,
1
]))
#True
|
bin() 二进制
oct() 八进制
hex() 十六进制
|
1
2
3
4
5
6
7
|
print
(
bin
(
10
))
print
(
oct
(
10
))
print
(
hex
(
10
))
输出：
0b1010
0o12
0xa
|
bytes() 把传入对象转为bytes类型
unicode -----> encode -----> bytes
|
1
2
3
4
|
print
(bytes(
'hello'
,encoding
=
'utf-8'
))
输出：
b
'hello'
|
callable() 检测传入对象能否被执行（加括号执行），结果返回布尔值
|
1
2
3
4
5
|
print
(
callable
(bytes))
print
(
callable
(
abs
))
输出：
True
True
|
chr() 对应ASCII编码，根据十进制数字取出对应的字符
ord() 对应ASCII编码，根据字符取出对应的十进制数字
|
1
2
3
4
5
6
7
8
|
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() 查看模块下能够调取的属性方法
|
1
2
3
4
5
6
|
import
sys
# sys.path #sys模块下的属性方法
# sys.argv
print
(
dir
(sys))
输出：
[
'__displayhook__'
,
'__doc__'
,
'__excepthook__'
......]
#sys模块下方法
|
divmod() 传入两个参数，两数相除，返回商和余数（适用于计算分页数量）
|
1
2
3
4
5
|
print
(
divmod
(
10
,
3
))
print
(
divmod
(
102
,
20
))
输出：
(
3
,
1
)
(
5
,
2
)
|
enumerate() 取出传入的列表中的元素和索引
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
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()
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
|
#字符串可以提供的参数 '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() 返回传入对象的校验值
|
1
2
3
4
5
|
print
(
hash
(
'abcdefg123'
))
print
(
hash
(
'abcdefg123'
))
输出：
6531764118696325436
6531764118696325436
|
help() 查看注释信息
给函数加文档解释，用到单引号，双引号，三引号，使用#做注释不会打印
id() 返回传入对象的内存地址（id只是python解释器实现的功能，只是反映了对象在内存的地址，但并不是真实的内存地址）
|
1
2
3
4
5
6
|
def
func():
pass
print
(
id
(func))
print
(func)
输出：
30424600
<function func at
0x0000000001D03E18
>
|
isinstance() 判断一个变量的类型（面向对象中会详解）
|
1
2
3
4
5
6
|
x
=
1
print
(
type
(x)
is
int
)
print
(
isinstance
(x,
int
))
#x=int(1)
输出：
True
True
|
max() 取最大值
min() 取最小值
只能同数据类型之间比较
pow() 做幂和取模运算（可以传两个或者三个参数）
|
1
2
3
4
|
print
(
pow
(
3
,
2
,
2
))
#3**2%2
输出：
1
|
repr() 把一个对象转换成字符串类型
==str()
区别：前者是给python解释器用的，后者是给用户用的
reversed() 反转传入对象
|
1
2
3
4
5
6
|
l
=
[
1
,
'a'
,
2
,
'c'
]
print
(
list
(
reversed
(l)))
print
(l)
输出：
[
'c'
,
2
,
'a'
,
1
]
[
1
,
'a'
,
2
,
'c'
]
|
round() 传入两个参数，保留小数位数
|
1
2
3
4
|
print
(
round
(
3.456
,
2
))
输出：
3.46
|
slice() 切片（传入三个参数，前两个切片范围，最后一个为步长）
sorted() 排序（把传入对象从小到大进行排序，只能同数据类型）
|
1
2
3
4
5
6
|
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() 求和
|
1
2
3
4
5
6
|
print
(
sum
([
1
,
2
,
3
]))
print
(
sum
(i
for
i
in
range
(
10
)))
输出：
6
45
|
zip() 拉链，两个对象的值一一对应
|
1
2
3
4
5
6
|
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
练习：
取出薪资最高的人名：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
# 方法一：使用内置函数
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
|
薪资从低到高排序：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
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() 映射
|
1
2
3
4
5
6
7
8
|
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的值）
|
1
2
3
4
|
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模块
|
1
2
3
4
5
6
7
8
|
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
|
