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
"""
Math库
math：python提供的内置数学类函数库，包含了很多数学公式
数字常数
| 常数 | 数学表示 | 描述 |
|---|---|---|
| math.pi | π | 圆周率，值为3.14159… |
| math.e | e | 自然对数，值为2.7182818… |
| math.inf | ∞ | 正无穷大，负无穷是-math.inf |
| math.nan | NAN | 非数字，Not a Number |
>>> import math
>>> math.pi
3.141592653589793
>>> math.e
2.718281828459045
>>> math.inf
inf
>>> -math.inf
-inf
>>> math.nan
nan
数论与表示函数
| 函数 | 描述与 |
|---|---|
| ceil(x) | 向上取整 |
| floor(x) | 向下取整 |
| factorial(x) | 阶乘 |
| gcd(a, b) | 最大公约数 |
| fab(x) | 绝对值 |
>>> 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
幂对数函数
| 函数 | 描述与 |
|---|---|
| pow(x, y) | 返回x的y次幂 |
| exp(x) | e(自然对数)的x次幂 |
| sqrt(x) | x的平方根 |
| log(x, base=math.e) | 返回x的对数值 |
>>> 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
进制转换
| 方法 | 描述 |
|---|---|
| bin(num) | 将十进制数值num转成二进制(num必须是int类型） |
| oct(num) | 将十进制数值num转成八进制(num必须是int类型） |
| int(num, base=10) | 根据指定进制base转换成十进制（注意，如果传了参数base，则num必须是字符串形式 |
| hex(num) | 将十进制数值num转成十六进制(num必须是int类型） |
>>> 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
>>>
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)
[]
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])))
执行结果如下：
map()返回的值是：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"})
执行结果为：
eval(s)传入的第一个参数，其值为1+2*3，类型为，返回结果是7，结果的数据类型是
eval的表达式中包含变量：10
eval的表达式中包含本地函数：23
无globals参数无locals参数：hello
有globals参数无locals参数：wenxiaoba
无globals参数有locals参数：wenxiaoba_local
以下代码执行会报错，因为有globals参数，所以第一个参数中的函数和变量都不会在本地模块中查找，但globals没有定义add()方法（虽然本地定义了add()），所以会报错
def add(x, y):
return x+y
print(f'eval的表达式中包含本地函数和globals变量，：{eval("add(x, 2)", {"x": 23})}')
报错信息为：
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
类属性相关函数
| 方法 | 说明 |
|---|---|
| hasattr(object, name) | 判断对象object是否包含指定的属性（属性名为name） |
| getattr(object, name[, default]) | 返回对象object的属性名为name的值 |
| setattr(object, name, value) | 给对象object设置属性（名为name、值为value） |
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())
执行结果为：
True
True
-----------------------
False
False
True
True
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}")
执行结果为：
年龄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'
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}")
执行结果为：
使用了对象的set_name()修改名称为：harry
使用了setattr()添加了gender属性：gender=男
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))
执行结果为：
[(0, 'red'), (1, 'blue'), (2, 'yellow'), (3, 'black')]
[(2, 'red'), (3, 'blue'), (4, 'yellow'), (5, 'black')]
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))))
执行结果为：
filter()返回的数据类型为：
filter(is_even, data)的遍历结果为： [2, 4, 6, -4]
filter()中使用lambda： [2, 4, 6, -4]
filter()中传入迭代器： [0, 2, 4, 6, 8]