python内置函数

发表于 更新于
Python内置的函数及其用法。

Python内置的函数及其用法。

一、数学运算操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 对浮点数进行四舍五入求值
print(round(4.6))
print(round(1.1314926, 5))
# 求数值的绝对值
print(abs(-5)) 
# 返回两个数值的商和余数
print(divmod(10, 3))  
# 返回两个数值的幂运算值或其与指定整数的模值
print(pow(2, 3))
print(pow(2, 3, 5))
print(pow(2, 3)%5)
# 返回可迭代对象中的元素中的最大值或者所有参数的最大值
print(max([1, 2, 3, 4]))
# 返回可迭代对象中的元素中的最小值或者所有参数的最小值
print(min([1, 2, 3, 4]))
# 对元素类型是数值的可迭代对象中的每个元素求和
print(sum([1, 2, 3, 4]))
print(sum((1, 2, 3, 4)))
print(sum((1, 2, 3, 4), -10))

二、类型转换操作

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
# 根据传入的参数的逻辑值创建一个新的布尔值
print(bool()) 
print(bool(1)) 
print(bool(19))
# 根据传入的参数创建一个新的整数
print(int(10.5))
# 根据传入的参数创建一个新的浮点数
print(float(3))
print(float('10.5'))
# 根据传入参数创建一个新的复数
print(complex(1, 5))
print(complex('1+5j'))
# 返回一个对象的字符串表现形式
print(str('abc'))
print(str(123))
# 根据传入的参数创建一个新的字节数组
print(bytearray('中文','utf-8'))
# 根据传入的参数创建一个新的不可变字节数组
print(bytes('中文','utf-8'))
# 根据传入的参数创建一个新的内存查看对象
v = memoryview(b'abcefg')
print(v[0])
print(v[1])
print(v[-1])
# 返回Unicode字符对应的整数
print(ord('a'))
# 返回整数所对应的Unicode字符
print(chr(97))
# 将整数转换成2进制字符串, b后面是转化结果
print(bin(19))
# 将整数转化成8进制数字符串, o后面是转化结果
print(oct(19))
# 将整数转换成16进制字符串, x后面是转化结果
print(hex(19))

三、集合操作

有序集合、无序集合，及它们的遍历方法

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
# 根据传入的参数创建一个新的元组
print(tuple('121'))
# 根据传入的参数创建一个新的列表
print(list('abc'))
# 根据传入的参数创建一个新的字典
print(dict(a = 1,b = 2))  # 可以传入键值对创建字典
print(dict(zip(['a','b'],[1,2])))   # 可以传入映射函数创建字典
print(dict((('a',1),('b',2))))  # 可以传入可迭代对象创建字典
# 根据传入的参数创建一个新的无序不重复集合
print(set([10,2,3,4,10]))
print(set(range(10)))
# 根据传入的参数创建一个新的无序不重复的不可变集合
print(frozenset([10,2,3,4,10]))
print(frozenset(range(10)))

#########################################################

# 根据传入的参数创建一个新的range对象
print(range(10))
print(range(1, 10))
print(range(1, 10, 1))
print(list(range(1, 10, 1)))  # 输出其中元素
for i in range(10):
    print(i)
# 根据可迭代对象创建枚举对象
seasons = ['Spring', 'Summer', 'Fall', 'Winter']
print(list(enumerate(seasons)))
print(list(enumerate(seasons, start=1))) # 指定起始值
for index, i in enumerate(seasons):
    print(index, i)
# 根据传入的参数创建一个新的可迭代对象
seasons = ['Spring', 'Summer', 'Fall', 'Winter']
print(list(iter(seasons)))
for i in iter(seasons):
    print(i)

四、序列操作

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
# 判断可迭代对象的每个元素是否都为True值
print(all([0, 1, 2]))
# 判断可迭代对象的元素是否有为True值的元素
print(any([0, 1, 2]))
# 使用指定方法过滤可迭代对象的元素
a = list(range(1,10))  # 定义序列
def if_odd(x):   # 定义奇数判断函数
    return x%2==1
print(list(filter(if_odd, a)))
# 使用指定方法去作用传入的每个可迭代对象的元素，生成新的可迭代对象
b = map(ord, 'abcd')
print(list(b))
# 返回可迭代对象中的下一个元素值
c = iter('abcd')
print(next(c))
# 反转序列生成新的可迭代对象
d = reversed(range(10))
print(list(d))
# 对可迭代对象进行排序，返回一个新的列表
e =  ['a','b','d','c','B','A']
print(sorted(e))
print(sorted(e, key = str.lower))  # 转换成小写后再排序
# 聚合传入的每个迭代器中相同位置的元素，返回一个新的元组类型迭代器
x = [1, 2, 3] # 长度3
y = [4, 5, 6, 7, 8] # 长度5
print(list(zip(x, y))) # 长度取最小的那个长度

五、对象操作

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
# 返回对象的帮助信息
print(help(int))
# 返回对象或者当前作用域内的属性列表
import math
print(dir(math.cos))
# 返回对象的唯一标识符
s = 'abc'
print(id(s))
# 获取对象的哈希值
print(hash('hello world'))
# 返回对象的类型
print(type('aabbcc'))
# 返回对象的长度
print(len('aabbcc'))
# 返回对象的可打印表字符串表现方式
print(ascii('a'))
print(ascii(16))
print(ascii('中文'))
# 格式化显示值
#### 字符串格式化输出
print("{0},{1}".format(100,120))
#### 整形数值可以提供的参数有 'b' 'c' 'd' 'o' 'x' 'X'
print(format(3,'b'))   # 转换成二进制
print(format(97,'c'))  # 转换unicode成字符
print(format(11,'d'))  # 转换成10进制
print(format(11,'o'))  # 转换成8进制
print(format(11,'x'))  # 转换成16进制 小写字母表示
print(format(11,'X'))  # 转换成16进制 大写字母表示
#### 浮点数可以提供的参数有 'e' 'E' 'f' 'F'
print(format(314159267,'e'))   # 科学计数法，默认保留6位小数
print(format(314159267,'0.2e'))  # 科学计数法，指定保留2位小数
print(format(314159267,'0.2E'))  # 科学计数法，指定保留2位小数，采用大写E表示
print(format(3.14159267000,'f'))  # 小数点计数法，默认保留6位小数
print(format(3.14159267000,'0.8f')) # 小数点计数法，指定保留8位小数
print(format(3.14e+1000000,'F'))  # 小数点计数法，无穷大转换成大小字母
# vars()：返回当前作用域内的局部变量和其值组成的字典，或者返回对象的属性列表
#### 定义类A
class A(object):
    pass
a = A()
print(vars(a))
a.name = 'Kim'
print(vars(a))
# super()：根据传入的参数创建一个新的子类和父类关系的代理对象
#### 定义父类B
class B(object):
    def __init__(self):
        print('B.__init__')
#### 定义子类C，继承B
class C(A):
    def __init__(self):
        print('C.__init__')
        super().__init__()
c = C()

六、 变量操作

1
2
3
4
5
6
7
8
# 返回当前作用域内的全局变量和其值组成的字典
print(globals())
# 返回当前作用域内的局部变量和其值组成的字典
def f():
    print(locals()) # 作用域内无变量
    a = 1
    print(locals()) # 作用域内有一个a变量，值为1
f()

七、交互操作

1
2
3
4
5
# 向标准输出对象打印输出
print(1,2,3)
# 读取用户输入值
s = input('please input your name:')
print(s)

八、编译执行

1
2
3
4
5
# 执行动态表达式求值
print(eval('1+2+3+4'))
# 执行动态语句块
exec('a=1+2')
print(a)