python常用函数或库

range()

range(start, stop[, step])
描述：返回开始数值start，结束数值为stop，数值间隔为step的迭代器（非列表，是迭代器）

参数说明：
start: 计数从 start 开始。start参数可以不传，默认是从 0 开始
stop: 计数到 stop 结束，但不包括 stop。
step：步长，默认为1。

data = range(3, 15, 2)
for i in data:
    print(i, end='\t')

"""
运行结果：
3	5	7	9	11	13	
"""
1
2
3
4
5
6
7
8

Math库

math：python提供的内置数学类函数库，包含了很多数学公式

数字常数

>>> import math
>>> math.pi
3.141592653589793
>>> math.e
2.718281828459045
>>> math.inf
inf
>>> -math.inf
-inf
>>> math.nan
nan
1
2
3
4
5
6
7
8
9
10
11

数论与表示函数

>>> import math
>>> math.ceil(3.14)
4
>>> math.ceil(-3.14)
-3
>>> math.ceil(3)
3
>>> math.floor(3.14)
3
>>> math.floor(-3.14)
-4
>>> math.floor(3)
3
>>> math.factorial(3)
6
>>> math.factorial(4)
24
>>> math.gcd(64, 96)
32
>>> math.fabs(-4.67)
4.67
>>> math.fabs(4.68)
4.68
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

幂对数函数

>>> import math
>>> math.pow(2, 4)
16.0
>>> math.pow(4, 0.5)
2.0
>>> math.exp(5)
148.4131591025766
>>> math.exp(2)
7.38905609893065
>>> math.sqrt(4)
2.0
>>> math.sqrt(25)
5.0
>>> math.log(7.38905609893065)
2.0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

进制转换

>>> bin(4)
'0b100'
>>> type(bin(4))
<class 'str'>
>>> bin("5")
Traceback (most recent call last):
  File "", line 1, in <module>
TypeError: 'str' object cannot be interpreted as an integer

>>> oct(12)
'0o14'
>>> type(oct(12))
<class 'str'>
>>> oct("12")
Traceback (most recent call last):
  File "", line 1, in <module>
TypeError: 'str' object cannot be interpreted as an integer

>>> int(34.6)
34
>>> int("101", 2)
5
>>> int("0o12", 8)
10
>>> int("34.2", 10)
Traceback (most recent call last):
  File "", line 1, in <module>
ValueError: invalid literal for int() with base 10: '34.2'
>>> int("34", 10)
34
>>> int("1b", 16)
27
>>> int(101, 2)
Traceback (most recent call last):
  File "", line 1, in <module>
TypeError: int() can't convert non-string with explicit base
>>> type(int("101", 2))
int'>

>>> hex(20)
'0x14'
>>> type(hex(20))
str'>
>>> hex("20")
Traceback (most recent call last):
  File "", line 1, in 
TypeError: 'str' object cannot be interpreted as an integer
>>>

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

zip()

zip是python的一个内建函数，将可迭代对象中的元素打包成一个个元组，元组组成列表返回

方法：zip([iterable, …])
[iterable, …]为迭代器组成的列表，iterable表示迭代器
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
解压缩：zip(*zip对象)

>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> c = [4, 5, 6, 7, 8]

# zip()函数将多个迭代器从同一个位置的元素组成元组，返回zip对象
>>> d1 = zip(a, b)
>>> print(d1)
<zip object at 0x000002228D8ECBC0>
>>> type(d1)
<class 'zip'>
# zip对象可以通过list()转成列表对象
>>> data1 = list(d1)
>>> data1
[(1, 4), (2, 5), (3, 6)]

# 迭代器的元素个数不一致时，则打包到元素个数最少的那一个
>>> list(zip(a, b, c))
[(1, 4, 4), (2, 5, 5), (3, 6, 6)]

# zip(*zip对象)，如果zip对象未被解包过，则可以通过该格式进行解包，如果已经解包过，则返回空列表
>>> d2 = zip(a, b)
>>> d3 = zip(*d2)
>>> d3
<zip object at 0x000002228D8ECDC0>
>>> list(d3)
[(1, 2, 3), (4, 5, 6)]
>>> list(d3)
[]
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

map()

格式：map(function, iterable, …)
function参数传的是函数，iterable是序列对象
返回值：将序列对象中的元素按照function函数处理后，返回map对象（python3)
可以通过list()、tuple()等操作将map对象转成指定的数据类型
注意：function指向的函数有多少个必传参数，则iterable就必须有多少个

def square(x):
    return x ** 2

m = map(square, [1, 2, 3, 4, 5])
print(f"map()返回的值是：{m}，其类型是：{type(m)}")

print(f"map对象第一次被遍历：{list(m)}\n第2次从第1次结束位置开始遍历（所以为空）：{list(m)}")

print(f"元组：{tuple(map(square, [1, 2, 3, 4, 5]))}")
print(f"集合：{set(map(square, [1, 2, 3, 4, 5]))}")


def add(x, y):
    return x + y
print(f"函数有多个必传参数：{list(map(add, [1, 2, 3, 4, 5], [6, 7, 8, 9, 10]))}")

# 按照指定的进制转换为十进制数
print("使用python自带的函数", list(map(int, ["2", "21", "2a"], [10, 8, 16])))

print("使用了lambda关键字：", list(map(lambda x: 2*x, [3, 7, 1, 6])))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

执行结果如下：

map()返回的值是：
1
2
3
4
5
6
7
8

eval()

格式：eval(expression[, globals[, locals]])

• source：执行语句表达式（字符串形式），必传
• globals：可选参数，全局命名空间，字典形式传入
• locals：可选参数，局部命名空间，设置locals时，必须要有globals
  描述：将source转成可执行语句并执行。
  注意：source中涉及到变量和函数、方法部分，查找顺序为：locals --> globals，如果2者都没有传参，则直接从当前模块中查找（即如果globals或locals要么从传入参数中找，要么从当前模块中找，不能兼容）

s = "1+2*3"
result = eval(s)
print(f"eval(s)传入的第一个参数，其值为{s}，类型为{type(s)}，返回结果是{result}，结果的数据类型是{type(result)}")


x = 21
print(f"eval的表达式中包含变量：{eval('x - 11')}")

def add(x, y):
    return x+y
print(f'eval的表达式中包含本地函数：{eval("add(x, 2)")}')


name = "hello"
eval("print(f'无globals参数无locals参数：{name}')")
eval("print(f'有globals参数无locals参数：{name}')", {"name": "wenxiaoba"})
eval("print(f'无globals参数有locals参数：{name}')", {"name": "wenxiaoba_global"}, {"name": "wenxiaoba_local"})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

执行结果为：

eval(s)传入的第一个参数，其值为1+2*3，类型为，返回结果是7，结果的数据类型是
eval的表达式中包含变量：10
eval的表达式中包含本地函数：23
无globals参数无locals参数：hello
有globals参数无locals参数：wenxiaoba
无globals参数有locals参数：wenxiaoba_local
1
2
3
4
5
6

以下代码执行会报错，因为有globals参数，所以第一个参数中的函数和变量都不会在本地模块中查找，但globals没有定义add()方法（虽然本地定义了add()），所以会报错

def add(x, y):
    return x+y
print(f'eval的表达式中包含本地函数和globals变量，：{eval("add(x, 2)", {"x": 23})}')
1
2
3

报错信息为：

Traceback (most recent call last):
  File "D:\hogwart\demo.py", line 22, in 
    print(f'eval的表达式中包含本地函数和globals变量，：{eval("add(x, 2)", {"x": 23})}')
  File "", line 1, in 
NameError: name 'add' is not defined
1
2
3
4
5

类属性相关函数

hasattr()

格式：hasattr(object, name)

• object：根据类生成的对象，也叫实例
• name：属性名称（可理解为实例中某个变量名），字符串类型
  描述：判断对象中是否包含某个属性，若已有对应属性，则返回True，否则返回False

class Person:
    name = ""
    age = 0

    def is_gender_exit(self):
        # 判断对象中是否包含gender属性
        return hasattr(self, "gender")

p = Person()
print(hasattr(p, 'name'))
print(hasattr(p, 'age'))
print("-----------------------")
print(hasattr(p, 'gender'))
print(p.is_gender_exit())
p.gender = "女"
print(hasattr(p, 'gender'))
print(p.is_gender_exit())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

执行结果为：

True
True
-----------------------
False
False
True
True
1
2
3
4
5
6
7

getattr()

格式：getattr(object, name[, default])

• object：根据类生成的对象，也叫实例
• name：属性名称（可理解为实例中某个变量名），字符串类型
• default：默认返回值。如果对象中没有对应属性，则默认返回该参数值，如果该参数未设置且对象中没有对应属性时，触发AttributeError报错，
  描述：返回对象中对应属性的值，如果对象无指定属性：default有传时返回default值，default未传参时触发AttributeError

class Person:
    name = "wenxiaoba"
    age = 18

    def get_name(self):
        return getattr(self, "name")

p = Person()
age = getattr(p, "age", 12)
print(f"年龄age值为：{age}")
a2 = p.get_name()
print(f"姓名name值为：{a2}")

gender = getattr(p, "gender", "女")
print(f"性别gender为：{gender}")

# 对象没有对应的属性，getattr也没有设置default参数，所以会报错
gender = getattr(p, "gender")
print(f"性别gender为：{gender}")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

执行结果为：

年龄age值为：18
姓名name值为：wenxiaoba
性别gender为：女
Traceback (most recent call last):
  File "D:\hogwart\demo.py", line 18, in 
    gender = getattr(p, "gender")
AttributeError: 'Person' object has no attribute 'gender'
1
2
3
4
5
6
7

setattr()

格式：setattr(object, name, value)

• object：根据类生成的对象，也叫实例
• name：属性名称（可理解为实例中某个变量名），字符串类型
• value：属性值，即要给属性设置的值
  描述：给对象设置属性值

class Person:
    name = "wenxiaoba"
    age = 18

    def set_name(self):
        setattr(self, "name", "harry")

p = Person()
p.set_name()
print(f"使用了对象的set_name()修改名称为：{p.name}")

setattr(p, "gender", "男")
print(f"使用了setattr()添加了gender属性：gender={p.gender}")
1
2
3
4
5
6
7
8
9
10
11
12
13

执行结果为：

使用了对象的set_name()修改名称为：harry
使用了setattr()添加了gender属性：gender=男
1
2

enumerate()

enumerate(sequence, start=0)

• sequence：序列化对象，如List、Tuple等
  -start：下标起始位置的值，默认从0开始
  将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，即列出sequence中每个参数及其下标+start组成的元素

data = ["red", "blue", "yellow", "black"]
result = enumerate(data)
print(result)
print(type(result))
print(list(result))
r2 = enumerate(data, 2)
print(list(r2))
1
2
3
4
5
6
7

执行结果为：

[(0, 'red'), (1, 'blue'), (2, 'yellow'), (3, 'black')]
[(2, 'red'), (3, 'blue'), (4, 'yellow'), (5, 'black')]
1
2
3
4

random

random也是偶尔会用到的python自带的库，这个库有几个经常用到的方法，具体的在这篇博客：python常用库random

filter()

filter(function_or_None, iterable)：将序列iterable的元素进行function_or_None处理，如果返回的非假（假表示None、False、空列表等），则表示该元素是符合要求的，返回的是filter数据类型（迭代器），可遍历

• function_or_None：函数名称，传None时表示不对序列做过滤处理
• iterable：序列

def is_even(num):
    # 判断是否为偶数，为偶数时返回True
    if int(num)%2 == 0:
        return 2
    return False

data = [2, 3, 4, 5, 6, -4, -7]
r = filter(is_even, data)
print("filter()返回的数据类型为：", type(r))
print("filter(is_even, data)的遍历结果为：", list(r))

print("filter()中使用lambda：", list(filter(lambda x: not x%2, data)))

print("filter()中传入迭代器：", list(filter(lambda x: not x%2, range(10))))
1
2
3
4
5
6
7
8
9
10
11
12
13
14

执行结果为：

filter()返回的数据类型为： 
filter(is_even, data)的遍历结果为： [2, 4, 6, -4]
filter()中使用lambda： [2, 4, 6, -4]
filter()中传入迭代器： [0, 2, 4, 6, 8]
1
2
3
4