python学习——python的内建函数总结

标识 id

• 返回对象的唯一标识，CPython中返回内存地址

哈希 hash()

• 返回一个对象的哈希值、散列值

类型type()

• 返回对象的类型

类型转换

• float():强制转换浮点数，常用与数字
• int():强制转换整数，常用语数字
• bin():强制转换成二进制
• hex():强制转换成16进制
• oct():强制转换成8进制
• bool():强制转换成布尔类型，True或者False
• list():强制转换成列表
• tuple():强元组换成远足
• dict():强制转换成字典
• set():强制转换成set
• complex():强制转换成复数
• bytes():强制转换成bytes
• bytearray():强制转换成bytearray

输入 input([prompt])

• 接受用户输入，返回一个字符串

打印 print

• 语法：print(*args, sep=’ ‘, end=’\n’, file=None)
• 打印输出，默认使用空格分割，换行结尾，输出到控制台
• 代码示例：

a = "dfjhdjh"
b = ["dfsj","hfjs"]
c = 123.56
d = 123
print(id(a),id(b),id(c))
print(type(a),type(b),type(c))
print(hash(a),hash(c),hash(d))
print(float(d),int(c),set(b),list(a),tuple(b),bool(d))
print(bin(d),hex(d))
m = input()
print(m,hash(m))
========run_result==========
4312597680 4313075456 4312356080
<class 'str'> <class 'list'> <class 'float'>
-6399621406674454723 1291272085159673979 123
123.0 123 {'dfsj', 'hfjs'} ['d', 'f', 'j', 'h', 'd', 'j', 'h'] ('dfsj', 'hfjs') True
0b1111011 0x7b
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

获取长度 len

• 返回一个集合类型的元素的个数

判断对象类型isinstance

• 判断对象obj是属于某种类型或者元组中列出的某个类型
• 语法：isinstance(x, A_tuple)，x指的是被判断的元素，A_tuple是被判断的类型，可以单输入某种类型，也可以是多种类型的集合
• 返回值：True或者int

判断类的子类issubclass

• 判断类型cls是否是某种类型的子类或者元组中列出的某个类型的子类
• 语法:issubclass(x, A_tuple)x指的是被判断的元素，A_tuple是被判断的类，可以单输入某种类的名称，也可以是多个类集合
• 返回值：True或者int

数值处理

• abs(x),x为数值，求某个数的绝对值
• max(x),min(x)，返回可迭代对象/多个参数中的最大值或者最小值
• round(x) :四舍六入五取偶(五取偶的意思是：第一个小数是5时，个位数是偶数，直接舍弃，个位是奇数，个位数+1)
• pow(x):x的y次幂
• range(stop)返回从0开始到stop-1的可迭代对象；range(start,stop,[,step])返回从start开始，到stop-1结束，步长为step的可迭代对象;range不是迭代器，不能使用next函数
• 列表切片取值时浅copy，取值嵌套列表时id一致
• sum(iterable),对可迭代对象的所有数值求和
• divmod(x,y):返回x//y(整除)和x%y(取余)的元组

b = ["dfsj","hfjs"]
c = 123.56
d = [101,999,4,-12,1.5]
n = isinstance(b,(list,dict))
print(n)
print(max(d),min(d),round(c),round(d[4]),pow(d[0],d[2]),abs(d[3]))
print(divmod(d[0],d[2]))
#bool是int的子类
x = issubclass(bool,int)
print(x)
a = sum(range(1,101,2))
print(a)
k = [0,[1,5,6],2]
z = k[1:2]
print("切片取值，浅copy，嵌套列表的id一致：",id(k[1][0]),id(z[0][0]))
===========run_result========
True
999 -12 124 2 104060401 12
(25, 1)
True
2500
切片取值，浅copy，嵌套列表的id一致： 4313022704 4313022704
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

数字和字母转换,ASCII码表

• chr(i)给一个一定范围内的证书返回对应的字符
• ord(str)，返回字符对应的整除
• 代码示例：

print(chr(97),chr(20013))
print(ord("a"),ord("A"),ord("国"))
=========run_result======
a 中
97 65 22269
1
2
3
4
5

排序、翻转、枚举、封装和获取迭代器元素

• sorted
  1.sorted(iterable,reverse=True),iterable为可迭代的参数，
  2.返回一个新的列表，当reverse参数位True时，倒序排列，为False时，正序排列；
  3.如果可迭代对象是字典，排序的是字典的key，返回的仍然是列表
• sort()`，对列表进行排序，不会有返回值
• reversed()，返回一个反转元素的迭代器
• reverse，配合列表使用，反转的是列表本身
• enumerate 枚举
  1.语法：enumerate(seq,start=0)
  2.含义：迭代一个序列，返回索引数字和元素构成的二元组;注意：二维元组可以用于解构，其类型也是迭代器，可使用next函数
  3.start代表第一个元素从几开始往后索引，即索引开始的数字，默认值为0
  4.seq值的是可迭代序列
• 迭代器的封装和获取函数是：iter和next
  1.iter将一个可迭代的对象封装成一个迭代器
  2.next对一个迭代器取下一个元素，如果全部的元素获取完了，再次next会抛出异常
• 代码示例：

d = [101,999,4,-12,1.5]
m = sorted(d)
n = sorted(d,reverse=True)
print(d,m,n)
k = reversed(d)
print(d,type(k))
print("next取值",next(k))
[print("迭代器",i) for i in k]
d.reverse()
print("反转：",d)
d.sort()
print("排序：",d)
z = enumerate(d,start=1)
print("next取值",next(z))
[print(k) for k in z ]
z = enumerate(d,start=0)
[print(k,v,sep="\t") for k,v in z ]
f = ["f","7",9,4,5]
it = iter(f)
print(type(it))
print(next(it))


===========run_result==========
[101, 999, 4, -12, 1.5] [-12, 1.5, 4, 101, 999] [999, 101, 4, 1.5, -12]
[101, 999, 4, -12, 1.5] <class 'list_reverseiterator'>
next取值 1.5
迭代器 -12
迭代器 4
迭代器 999
迭代器 101
反转： [1.5, -12, 4, 999, 101]
排序： [-12, 1.5, 4, 101, 999]
next取值 (1, -12)
(2, 1.5)
(3, 4)
(4, 101)
(5, 999)
0	-12
1	1.5
2	4
3	101
4	999
<class 'list_iterator'>
f
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

可迭代对象的定义

• 能通过一次迭代，一次次返回不同元素的对象，所谓相同不是指值相同，而是元素在内存中是否是同一个，即元素的id是否相同
• 可以迭代，但是未必有序（例如字典），未必可索引（例如set）
• 当前可迭代对象有：list，tuple，string，bytes，bytesarray，range，set，dict，生成器等
• 可使用的成员运算符有：in，not in；in本质上就是在遍历对象
• 代码示例：

a =3 in [x for x in range(10)]
print(a)
#3匹配的是key，而不是value
b = 3 in {x:y for x,y in zip(range(4),range(4,10))}
print(b)
1
2
3
4
5

迭代器

• Python中一个实现_iter_方法和_next_方法的类对象，就是迭代器。
• 通过iter方法把一个可迭代兑现封装成迭代器
• 通过next方法，迭代 迭代器的对象
• 即是一个能记住遍历位置的对象，遍历时只能往前，不能后退。迭代器常用方法有 iter() 和 next()
• 把一个类作为迭代器使用需要在类中实现两个函数：__iter__() 和 __next__().
• 生成器对象，就是迭代器对象
• python中的迭代器，生成器和可迭代对象都在collections中，导入代码如下：
• • from collections import Iterable,Iterator,Generator
• • Generator，生成器；Iterator，迭代器；Iterable，可迭代对象

生成器

• Python 中使用了 yield 的函数称为生成器，生成器函数返回一个迭代器
• 在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行
• 生成器函数自动实现了迭代器协议，能更方便地实现
• 生成器函数 和 生成器表达式都可以提供生成器，只需要简单地将列表推导的中括号替换成圆括号即可

二者区别

• 迭代器是访问容器的一种方式，也就是说容器已经出现
• • 我们是从已有元素拓印出一份副本，只为我们此次迭代使用
• • 而生成器则是自己生成元素的
• 在用法上生成器只需要简单函数写法，配合yield就能实现
• • 迭代器真正开发中很难使用到。我们可以把生成器看做一个迭代器
• • python给我们提供的特殊接口实现的迭代器
• 生成器是只能遍历一次的。

为什么使用生成器

• Python使用生成器对延迟操作提供了支持。在需要的时候才产生结果，而不是立即产生结果
• 节省资源消耗，和声明序列不同的是生成器在不使用的时候几乎不占内存，也没有声明计算过程
• 使用的时候，生成器是随用随生成，用完即刻释放，非常高效
• 可在单线程下实现并发运算处理效果。

zip函数——拉链函数

• 像拉链一样，把多个可迭代对象合并到一起，返回一个迭代器
• 将每次从不同对象中渠道的元素合并成一个元组
• 如果多个可迭代对象的长度不一致，按照最短长度的来组合，

print(list(zip(range(10),range(10,20),(1,2),{"name":"11","age":20})))

===========run_result=========
[(0, 10, 1, 'name'), (1, 11, 2, 'age')]
1
2
3
4

filter函数——过滤函数

• 接受两个参数，function_or_None和iterable
• • 其中function_or_None表示要执行的函数，可以传函数或者None：iterable表示可迭代对象
• 作用：将可迭代对象中的元素遍历之后，当做参数传入前面传入的函数中
• • 传入的函数中写过滤条件，如果retur True，那么传入的值就会写在filter返回的对象中，反之则不会写在对象中；返回的对象是一个可迭代对象，可遍历
• 如以下代码，找出列表中大于10的数值：

def filter_d(x):
    if x > 10:
        return False
    else:
        return True

list_l = [10,25,78,9,0]
res = filter(filter_d,list_l)
print("filter的返回值转换元组：",tuple(res))
*********************run_result***********************
filter的返回值转换元组： (25, 78)
1
2
3
4
5
6
7
8
9
10
11

map函数

接受两个参数，function_or_None和iterable

• • 其中function_or_None表示要执行的函数，可以传函数或者None：iterable表示可迭代对象
• 作用：将可迭代对象中的元素遍历之后，当做参数传入前面传入的函数中
• • 传入的函数中写判断条件，不论是否符合条件，都要将return的返回值添加进map的对象中

def filter_d(x):
    if x > 10:
        return "zq"
    else:
        return "error"

res_m = map(filter_d, list_l)
print("map的返回值转换元组：", tuple(res_m))
*********************run_result***********************
map的返回值转换元组： ('error', 'zq', 'zq', 'error', 'error')
1
2
3
4
5
6
7
8
9
10