本文主要是介绍python常用库函数，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
Python标准库
0内置函数模块
一部分常用的的内置函数。
| 函数 | 说明 |
|---|---|
abs | 返回一个数的绝对值，例如：abs(-1.3)会返回1.3。 |
bin | 把一个整数转换成以'0b'开头的二进制字符串，例如：bin(123)会返回'0b1111011'。 |
chr | 将Unicode编码转换成对应的字符，例如：chr(8364)会返回'€'。 |
hex | 将一个整数转换成以'0x'开头的十六进制字符串，例如：hex(123)会返回'0x7b'。 |
input | 从输入中读取一行，返回读到的字符串。 |
len | 获取字符串、列表等的长度。 |
max | 返回多个参数或一个可迭代对象中的最大值，例如：max(12, 95, 37)会返回95。 |
min | 返回多个参数或一个可迭代对象中的最小值，例如：min(12, 95, 37)会返回12。 |
oct | 把一个整数转换成以'0o'开头的八进制字符串，例如：oct(123)会返回'0o173'。 |
open | 打开一个文件并返回文件对象。 |
ord | 将字符转换成对应的Unicode编码，例如：ord('€')会返回8364。 |
pow | 求幂运算，例如：pow(2, 3)会返回8；pow(2, 0.5)会返回1.4142135623730951。 |
print | 打印输出。 |
range | 构造一个范围序列，例如：range(100)会产生0到99的整数序列。 |
round | 按照指定的精度对数值进行四舍五入，例如：round(1.23456, 4)会返回1.2346。 |
sum | 对一个序列中的项从左到右进行求和运算，例如：sum(range(1, 101))会返回5050。 |
type | 返回对象的类型，例如：type(10)会返回int；而 type('hello')会返回str。 |
map
在 Python 中，map() 函数是一个内置函数，用于将给定函数应用于可迭代对象（如列表、元组等）的每个元素，然后返回一个迭代器。map() 函数非常适合对数据进行转换和信息提取的任务，因为它可以批量处理数据集中的每个元素。
基本语法
map() 函数的基本语法是：
map(function, iterable, ...)
- function：这是一个函数，它接受的参数数量应该与传给
map()的可迭代对象的数量相对应。 - iterable：一个或多个可迭代对象。如果有多个可迭代对象，函数应该能够接受相应数量的参数，每个可迭代对象分别对应一个参数。
示例
下面是一些使用 map() 函数的示例，展示其用法和效果：
单个可迭代对象
将每个数字平方：
def square(x):return x ** 2numbers = [1, 2, 3, 4, 5]
squared = map(square, numbers)
print(list(squared)) # 输出: [1, 4, 9, 16, 25]
多个可迭代对象
将两个列表的对应元素相加：
def add(a, b):return a + bnums1 = [1, 2, 3]
nums2 = [4, 5, 6]
result = map(add, nums1, nums2)
print(list(result)) # 输出: [5, 7, 9]
使用 lambda 函数
map() 常与匿名函数（lambda 函数）结合使用，使代码更加简洁：
numbers = [1, 2, 3, 4, 5]
squared = map(lambda x: x ** 2, numbers)
print(list(squared)) # 输出: [1, 4, 9, 16, 25]
优势和场景
- 代码简洁：
map()可以使用一行代码完成对数据的批量处理。 - 性能：对于大数据集，
map()通常比等价的循环结构更加高效。 - 功能强大：可与任何函数一起使用，包括内置函数和自定义函数。
注意事项
map()返回的是一个迭代器，如果需要直接查看结果，通常需要将其转换为列表或元组。- 如果使用多个可迭代对象，它们的长度应该相同。如果长度不同，
map()将在最短的可迭代对象用完时停止。
map() 函数是 Python 中实现“函数式编程”风格的重要工具之一，适用于数据预处理、数据转换、以及任何需要对集合中所有元素应用同一操作的场景。
kwargs
在 Python 中，**kwargs 是一种用来接收任意数量的关键字参数的语法。它在定义函数时使用，允许你传递一个不固定数量的关键字参数给函数。这些关键字参数在函数内部被处理为一个字典。
基本用法
kwargs 是 “keyword arguments” 的缩写，经常以 **kwargs 的形式出现。这里的 ** 是一个特殊的操作符，用于收集额外的关键字参数。这些额外的参数被存储在一个字典中，字典的键是参数的名字，值是参数的值。
定义一个接受任意关键字参数的函数：
def my_function(**kwargs):for key, value in kwargs.items():print(f"The value of {key} is {value}")
调用函数并传递关键字参数：
my_function(first='Hello', second='World', third=123)
这将输出：
The value of first is Hello
The value of second is World
The value of third is 123
与 *args 和固定参数结合使用
**kwargs 可以与固定位置参数和 *args（用于收集任意数量的位置参数）结合使用。重要的是保持参数的正确顺序：先是固定参数，然后是 *args，最后是 **kwargs。
def another_function(arg1, arg2, *args, **kwargs):print(f"arg1: {arg1}")print(f"arg2: {arg2}")for arg in args:print(f"additional positional arg: {arg}")for key, value in kwargs.items():print(f"additional keyword arg {key}: {value}")# 调用函数
another_function(1, 2, 3, 4, 5, first='alpha', second='beta')
这将输出：
arg1: 1
arg2: 2
additional positional arg: 3
additional positional arg: 4
additional positional arg: 5
additional keyword arg first: alpha
additional keyword arg second: beta
使用场景
**kwargs 在需要灵活处理函数参数的场景非常有用，例如：
- 当你在编写函数库或框架时，允许用户提供配置选项。
- 在继承体系中覆盖方法时，允许通过关键字参数灵活传递数据。
- 在装饰器函数中，用于接收和传递任意数量的关键字参数。
通过使用 **kwargs，你的 Python 函数可以变得更加灵活和强大，能够处理各种不同的调用情形。
lambda
在 Python 中，lambda 函数是一种简短的函数定义方式，也称为匿名函数，因为它不需要使用标准的 def 关键字进行命名。lambda 函数可以接受任何数量的参数，但只能有一个表达式，其结果是该表达式的值。
基本语法
lambda 函数的基本语法如下：
lambda arguments: expression
这里 arguments 是函数的输入参数，可以是多个，用逗号分隔；expression 是一个表达式，其值将作为函数的返回值。
示例
下面是一些使用 lambda 函数的示例，展示其用法和实用性：
基础示例
将两个数相加的 lambda 函数：
add = lambda x, y: x + y
print(add(5, 3)) # 输出: 8
结合高阶函数使用
结合 map() 函数使用 lambda 来平方列表中的每个元素：
numbers = [1, 2, 3, 4]
squared = map(lambda x: x**2, numbers)
print(list(squared)) # 输出: [1, 4, 9, 16]
结合 sorted() 使用
使用 lambda 函数作为 sorted() 函数的 key 参数，对列表中的元组按第二个元素排序：
pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
pairs_sorted = sorted(pairs, key=lambda pair: pair[1])
print(pairs_sorted) # 输出: [(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]
优势和场景
- 简洁性：
lambda函数通常比普通函数更加简洁，尤其是在只需要一个表达式的情况下。 - 即用即弃：它们常用于不需要多次调用的简单函数的场合，如传递给高阶函数的小函数。
- 灵活性：非常适合用作临时或短生命周期的小函数，例如在 GUI 事件处理、小型回调函数等场景。
注意事项
lambda函数限制为单个表达式，这意味着不能写多行代码或包含复杂逻辑（如if语句的多个分支）。- 在可读性和复杂功能需求上，应优先选择常规的函数定义方式。
lambda 函数是 Python 中实现快速、简洁函数定义的有力工具，适合在需要简单函数的地方快速实现，而无需正式定义完整的函数。
sorted
在 Python 中，sorted() 函数是一个内置的函数，用于对各种可迭代的对象（如列表、元组、字典等）进行排序，并返回一个新的排好序的列表。这使得 sorted() 非常灵活和强大，因为它不仅能对简单的数字和字符串列表进行排序，还可以对复杂的数据结构按自定义的规则排序。
基本用法
sorted() 函数的基本语法如下：
sorted(iterable, key=None, reverse=False)
- iterable：这是要排序的可迭代对象。
- key：可选，一个只有一个参数的函数，用于为每个元素定义排序键（或排序的标准）。默认情况下，元素直接比较。
- reverse：可选，是一个布尔值。设置为
True时，列表以降序排序；默认情况下为False（升序）。
示例
基础排序
排序一个数字列表：
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
sorted_numbers = sorted(numbers)
print(sorted_numbers) # 输出: [1, 1, 2, 3, 4, 5, 6, 9]
使用 key 参数
对一个字符串列表按长度排序：
words = ["banana", "apple", "cherry", "date"]
sorted_words = sorted(words, key=len)
print(sorted_words) # 输出: ['date', 'apple', 'banana', 'cherry']
使用 reverse 参数
对数字进行降序排序：
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
sorted_numbers = sorted(numbers, reverse=True)
print(sorted_numbers) # 输出: [9, 6, 5, 4, 3, 2, 1, 1]
排序复杂结构
排序一个包含元组的列表，按元组中的第二个元素排序：
pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
sorted_pairs = sorted(pairs, key=lambda x: x[1])
print(sorted_pairs) # 输出: [(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]
使用场景
- 排序数据：
sorted()是数据处理中非常基础的一个工具，用于排序报表数据、用户输入数据等。 - 功能增强：通过
key参数，可以实现复杂的排序逻辑，如按对象属性、字典值等排序。 - 提升可读性：对输出进行排序，使得结果更加易于理解和检查。
sorted() 函数因其强大的功能和简单的使用方法，在数据处理和日常编程中广泛应用。
filter
在 Python 中，filter() 函数是一个内置的高阶函数，用于从一个可迭代对象中构造一个迭代器，该迭代器生成满足给定函数条件的所有元素。这使得 filter() 在数据处理中非常有用，尤其是当你需要从一组数据中筛选出符合特定条件的元素时。
基本用法
filter() 函数的基本语法如下：
filter(function, iterable)
- function: 一个函数，用于测试每个元素是否应该被包含在返回的迭代器中。如果
function返回True，则该元素将被包含。如果function是None，则会自动将元素的布尔值作为测试条件。 - iterable: 一个可迭代对象，其元素将被
function测试。
示例
基础使用
从列表中筛选出所有的偶数：
def is_even(num):return num % 2 == 0numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
filtered_numbers = filter(is_even, numbers)
print(list(filtered_numbers)) # 输出: [2, 4, 6, 8, 10]
使用 lambda 函数
同样的任务，使用 lambda 函数使代码更简洁：
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
filtered_numbers = filter(lambda x: x % 2 == 0, numbers)
print(list(filtered_numbers)) # 输出: [2, 4, 6, 8, 10]
过滤 None 值
移除列表中的所有 None 值：
data = [1, None, 'hello', None, 50, None]
filtered_data = filter(None, data)
print(list(filtered_data)) # 输出: [1, 'hello', 50]
在这个例子中，filter() 使用了默认行为，即直接使用每个元素的布尔值作为测试条件。因为 None 在布尔上下文中被视为 False，所以它被过滤掉了。
使用场景
- 数据清洗：从数据集中移除不符合条件的数据，如无效、错误或不完整的记录。
- 特征选择：在预处理数据时选择满足某些统计标准的数据子集。
- 条件筛选：在复杂数据结构中，如从对象列表中筛选出满足特定属性的对象。
filter() 函数是 Python 中实现“函数式编程”风格的重要工具之一，适用于任何需要条件筛选元素的场景。使用时需要注意，它返回的是一个迭代器，如果需要直接查看结果，通常需要将其转换为列表或其他数据结构。
zip
在Python中，zip() 函数是一个内置函数，用于将多个可迭代对象（如列表、元组、字典的键或值等）组合成一个迭代器。这个迭代器生成一系列元组，每个元组包含来自每个原可迭代对象的相应元素。
基本用法
函数的基本形式如下：
zip(*iterables)
*iterables: 一个或多个可迭代对象。可以是列表、元组、字典、集合等。
示例
-
将两个列表组合成一系列元组：
list1 = [1, 2, 3] list2 = ['a', 'b', 'c'] zipped = zip(list1, list2) print(list(zipped)) # 输出: [(1, 'a'), (2, 'b'), (3, 'c')] -
使用三个列表：
names = ['John', 'Doe', 'Jane'] ages = [25, 30, 35] genders = ['Male', 'Male', 'Female'] zipped = zip(names, ages, genders) print(list(zipped)) # 输出: [('John', 25, 'Male'), ('Doe', 30, 'Male'), ('Jane', 35, 'Female')] -
处理长度不一致的可迭代对象：
numbers = [1, 2, 3] letters = ['a', 'b'] zipped = zip(numbers, letters) print(list(zipped)) # 输出: [(1, 'a'), (2, 'b')]注意，
zip()函数生成的元组数量由最短的输入可迭代对象决定。在这个例子中，因为letters只有两个元素，所以结果中只有两个元组。
应用场景
- 并行迭代：当你需要同时迭代多个序列时，
zip()非常有用。你可以在一个循环中获取每个序列的对应元素。 - 数据转换：
zip()可以用来配对数据，常用于将数据转换成字典或其他数据结构。 - 复杂结构解构：在处理嵌套结构（如列表的列表或列表的元组等）时，可以使用
zip(*iterable)进行解构和重新组合。
注意事项
- 当使用
zip()时，如果不需要再次使用原始迭代器的数据，可以直接使用。但如果需要多次使用，应该将zip()的结果转换为列表或元组，以避免迭代器耗尽。 - 如果你想确保处理的是长度相同的迭代器，可能需要在使用
zip()前做一些长度检查或使用itertools.zip_longest()来处理长度不一致的情况。
zip() 是一个非常实用的函数，能够简化很多涉及到多序列处理的编程任务。
dict
在Python中，dict() 函数是用来创建字典的内置函数。字典是Python中一种非常重要的数据结构，用于存储键值对，其中每个键都是唯一的，并且每个键映射到一个值。dict() 函数可以通过多种方式来创建字典，使其既灵活又易于使用。
基本用法
函数的基本形式如下：
dict(**kwargs)
dict(mapping, **kwargs)
dict(iterable, **kwargs)
1. 使用关键字参数创建字典
可以直接使用关键字参数来创建字典，其中关键字作为字典的键，关键字的值作为字典的值：
d = dict(a=1, b=2, c=3)
print(d)
# 输出: {'a': 1, 'b': 2, 'c': 3}
2. 通过映射函数创建字典
如果你有一个已存在的映射类型（如另一个字典），你可以通过它来创建一个新的字典：
original = {'a': 1, 'b': 2}
new_dict = dict(original)
print(new_dict)
# 输出: {'a': 1, 'b': 2}
3. 通过可迭代对象创建字典
可以通过一个可迭代对象来创建字典，该可迭代对象应该产生一系列的键值对：
pairs = [('a', 1), ('b', 2), ('c', 3)]
d = dict(pairs)
print(d)
# 输出: {'a': 1, 'b': 2, 'c': 3}
示例
- 从键值对列表创建字典：
pairs = [('one', 1), ('two', 2), ('three', 3)]
d = dict(pairs)
print(d)
# 输出: {'one': 1, 'two': 2, 'three': 3}
- 使用关键字参数创建字典：
d = dict(apple=10, banana=20, cherry=30)
print(d)
# 输出: {'apple': 10, 'banana': 20, 'cherry': 30}
- 使用从两个列表组成的元组创建字典：
keys = ['a', 'b', 'c']
values = [1, 2, 3]
d = dict(zip(keys, values))
print(d)
# 输出: {'a': 1, 'b': 2, 'c': 3}
注意事项
- 字典中的键必须是不可变类型，比如数字、字符串或元组。
- 使用
dict()创建字典时，如果传递的键值对重复，则后面的值会覆盖前面的值。 dict()是创建字典的一种非常快捷和可读性强的方法。
使用 dict() 函数创建字典可以极大地提高代码的可读性和灵活性，特别是在处理复杂的数据结构或进行数据转换时。
1文本处理模块
string模块
import string
digits
当然，string.digits 在 Python 中是 string 模块预定义的字符串常量，包含了所有有效的十进制数字字符，从 ‘0’ 到 ‘9’。使用这个常量可以方便地引用所有的数字字符，无需手动键入它们。
使用方法
要使用 string.digits，你首先需要导入 string 模块。这里是如何操作的：
import stringprint(string.digits) # 输出: '0123456789'
示例用例
string.digits 可用于多种情况，例如：
- 验证输入：检查一个字符串是否只包含数字字符。
- 生成随机数字字符串：与
random模块结合生成指定长度的随机数字字符串。 - 数据清洗：在处理文本数据时，去除所有非数字字符。
这个常量的使用非常简单直接，可以在任何需要引用数字字符的场景中发挥作用。
ascii_letters
在 Python 中，string.ascii_letters 是 string 模块提供的另一个预定义字符串常量，它包含了所有的 ASCII 字母字符，即小写和大写字母（‘a’ 到 ‘z’ 和 ‘A’ 到 ‘Z’）。
使用方法
若要使用 string.ascii_letters，同样需要先导入 string 模块：
import stringprint(string.ascii_letters) # 输出: 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
示例用例
string.ascii_letters 可以用于许多需要引用字母字符的场景，例如：
- 生成随机字母字符串：与
random模块结合，可以生成随机的字母字符串，适用于创建密码、标识符等。 - 数据过滤和清洗：在文本处理中，你可以用它来过滤或清洗字符串，确保只包含字母。
- 字符分类：用于程序中的字符分类任务，如区分字母和非字母字符。
这个常量由于涵盖了所有基本的 ASCII 字母，因此非常适用于任何涉及到字母处理的场景。
strip
在Python中，strip() 函数是用于字符串处理的一种方法，它主要用于去除字符串开头和结尾的空白字符（如空格、换行符等）。此外，strip() 方法也可以用来移除字符串首尾的其他指定字符。
基本用法
函数的基本形式如下：
str.strip([chars])
- str: 这是要处理的字符串对象。
- chars: 可选参数，指定要从字符串首尾去除的字符集。如果未指定或为 None，则默认移除空白字符。
示例
-
去除字符串首尾的空白字符：
text = " Hello, World! " cleaned_text = text.strip() print(cleaned_text) # 输出 'Hello, World!' -
去除字符串首尾的指定字符：
url = "www.example.com/" cleaned_url = url.strip('/') print(cleaned_url) # 输出 'www.example.com'在这个例子中，
strip('/')去除了字符串两端的斜杠。 -
去除字符串首尾的多种字符：
text = "abcHello, World!cba" cleaned_text = text.strip('abc') print(cleaned_text) # 输出 'Hello, World!'这里使用
strip('abc')去除了字符串首尾的 ‘a’、‘b’ 和 ‘c’ 字符。
注意
strip()只能去除字符串首尾的字符，不能从字符串的中间部分去除字符。- 如果需要去除字符串中部的字符或者替换字符串中的某些字符，应考虑使用
replace()或正则表达式相关的方法。
strip() 是处理文本数据时非常常用的方法，特别是在数据清洗和预处理阶段，可以有效地去除不需要的空格或其他干扰字符。
split
在Python中，split() 函数是字符串对象的一种方法，用于将字符串按照指定的分隔符切割成多个子字符串，并返回这些子字符串组成的列表。如果不指定分隔符，split() 会默认按照任何空白字符（如空格、换行符 \n、制表符 \t 等）进行分割。
基本用法
函数的基本形式如下：
str.split(sep=None, maxsplit=-1)
- sep: 可选参数，指定用作分隔符的字符串。默认值为 None，这时将按照空白字符分割。
- maxsplit: 可选参数，指定最大分割次数。默认值为 -1，表示不限制分割次数。
示例
-
按空格分割字符串：
sentence = "Hello, World! Welcome to coding." words = sentence.split() print(words) # 输出 ['Hello,', 'World!', 'Welcome', 'to', 'coding.'] -
按指定字符分割字符串：
data = "apple,orange,banana,grape" fruits = data.split(',') print(fruits) # 输出 ['apple', 'orange', 'banana', 'grape'] -
限制分割次数：
info = "name:John Doe:age:30" parts = info.split(':', 1) print(parts) # 输出 ['name', 'John Doe:age:30']在这个例子中，
maxsplit设置为 1，所以split()只在第一个冒号处分割字符串。
注意
split()是处理和解析文本数据时非常有用的方法，尤其是当你需要从格式化的字符串（如 CSV 或日志文件）中提取数据时。- 如果分割符不存在于字符串中，
split()会返回包含原始字符串的单元素列表。 - 对于包含连续空格的字符串使用默认分割，会看到这些连续空格被视为一个分割符处理。
split() 方法因其简单和强大，广泛应用于字符串数据的预处理、数据分析和信息提取任务中。
2.数据类型模块
3.数字和数学模块
random模块
import random
randint
在 Python 中，randint 是 random 模块中的一个函数，用于生成一个指定范围内的随机整数。使用这个函数之前，你需要先导入 random 模块。下面是 randint 函数的基本用法：
基本用法
import random# 生成一个在[a, b]范围内的随机整数（包括两端点）
num = random.randint(a, b)
其中 a 和 b 是整数，且 a 应小于或等于 b。randint 会包括这两个边界值，即结果可能是 a 也可能是 b，或者是这两者之间的任何整数。
示例
如果你想生成一个从 1 到 10 的随机整数，可以这样写：
import randomnum = random.randint(1, 10)
print(num)
每次运行这段代码时，num 都会是 1 到 10 之间的一个随机整数，包括 1 和 10。
应用场景
randint 在许多场景下都非常有用，比如：
- 生成随机测试数据。
- 在游戏开发中随机选择一个选项。
- 在模拟实验中随机决定一个事件的结果。
这种生成随机数的方法非常直接和易用，适合需要快速获得随机结果的各种应用。
choice
在Python中，np.random.choice 函数是 NumPy 库提供的一个非常有用的工具，用于从给定的一维数组中随机抽取元素。你可以指定要抽取的样本数量，以及是否进行重复抽取（替换）。这个函数非常适用于概率模拟、随机抽样调查或在机器学习中划分数据集等场景。
基本用法
函数的基本形式如下：
numpy.random.choice(a, size=None, replace=True, p=None)
- a: 如果是一个整数，将从
np.arange(a)中随机抽取。如果是一个数组，将从该数组中抽取。 - size: 输出样本的数量。默认为 None，这意味着输出一个值。
- replace: 布尔值。表示是否允许抽取的元素可以重复。默认为 True，表示可以重复。
- p: 一个一维数组，指定
a中每个元素对应的抽取概率。如果不指定，每个元素被抽取的概率相等。
示例
-
从 0 到 9 中随机选择 5 个数字，允许重复：
import numpy as np samples = np.random.choice(10, size=5, replace=True) print(samples) -
从数组中随机选择 3 个元素，不允许重复：
arr = np.array([1, 2, 3, 4, 5]) samples = np.random.choice(arr, size=3, replace=False) print(samples) -
指定概率抽取：
arr = [10, 20, 30, 40, 50] probabilities = [0.1, 0.2, 0.4, 0.2, 0.1] sample = np.random.choice(arr, size=1, p=probabilities) print(sample)
这些示例涵盖了 np.random.choice 函数的基本用法，包括如何控制抽取是否重复以及如何通过指定概率来影响抽取结果。你可以根据需要调整参数来适应不同的使用场景。
choices
在 Python 中，random.choices() 函数是 random 模块的一部分，用于从给定的序列中返回一个或多个带权重的随机元素。这个函数在 Python 3.6 及以后的版本中可用，非常适合进行需要加权抽样的随机选择任务。
基本用法
函数签名为：
random.choices(population, weights=None, *, cum_weights=None, k=1)
- population：序列，表示可能的选择。
- weights：可选，一个数值列表，用于指定每个元素的选择权重。
- cum_weights：可选，一个数值列表，提供累积权重（如果提供了
cum_weights，则weights不应同时提供）。 - k：返回元素的数量，默认为 1。
示例
- 不带权重的选择
从列表中随机选择三个元素，每个元素被选择的概率相等。
import randomitems = ['apple', 'banana', 'cherry']
choices = random.choices(items, k=3)
print(choices)
- 带权重的选择
从列表中选择元素，每个元素的选择概率由权重决定。
import randomitems = ['apple', 'banana', 'cherry']
weights = [10, 1, 1] # 'apple' 的选择概率远大于其他两个
choices = random.choices(items, weights=weights, k=10)
print(choices)
在这个例子中，由于 ‘apple’ 的权重是 ‘banana’ 和 ‘cherry’ 的十倍，所以 ‘apple’ 被选中的频率也远高于其他两项。
使用场景
- 数据模拟：生成符合特定分布的测试数据。
- 负载均衡：根据服务器或资源的容量进行加权选择，以实现负载均衡。
- 随机抽奖：根据不同的中奖概率进行抽奖。
random.choices() 是一个非常灵活的工具，可以根据具体需求，通过调整权重来控制随机选择的结果。
shuffle
在Python中，random.shuffle 函数是用来随机打乱一个序列的原地顺序。这个函数定义在 random 模块中，所以使用前需要先导入 random 模块。
使用方法
random.shuffle(x[, random]) 接收以下参数：
- x: 要打乱的可变序列，如列表。注意，
x必须是一个可变类型，因为shuffle会直接修改序列。 - random (可选): 这是一个函数或实现了随机数生成器功能的对象的引用，用来作为底层的随机数生成器。
示例
下面是一个使用 random.shuffle 的示例，展示如何打乱一个列表：
import random# 创建一个列表
my_list = [1, 2, 3, 4, 5]
print("Original list:", my_list)# 打乱列表
random.shuffle(my_list)
print("Shuffled list:", my_list)
注意事项
- 因为
random.shuffle是原地操作，它不返回新的列表，而是直接修改传入的列表。 - 如果你需要保留原列表的顺序，可以先对列表进行复制，再对复制的列表使用
shuffle。
使用场景
random.shuffle 非常适用于需要随机化元素顺序的场景，如：
- 在机器学习中打乱数据顺序，以确保训练和测试集的随机性。
- 创建随机排列的测试或调查问卷。
- 开发游戏或模拟场景时随机设置初始条件。
这个函数通过提供一个简单而有效的方式来随机化序列元素，帮助开发者在多种应用中实现元素的随机排序。
operator模块
import operator
add
在 Python 中，operator.add 是 operator 模块提供的一个函数，用于执行两个参数的加法运算。这个函数实质上是对 Python 内置的 + 运算符的函数式封装。使用 operator.add 可以在需要将运算符作为函数传递的情况下，代替直接使用 + 运算符。
基本用法
要使用 operator.add，首先需要导入 operator 模块。然后可以使用 operator.add 来将两个对象相加。
示例代码：
import operator# 使用 operator.add 来添加两个数字
result = operator.add(10, 5)
print(result) # 输出: 15# 使用 operator.add 来连接两个字符串
text = operator.add("Hello, ", "World!")
print(text) # 输出: Hello, World!# 使用 operator.add 来合并两个列表
list_result = operator.add([1, 2, 3], [4, 5, 6])
print(list_result) # 输出: [1, 2, 3, 4, 5, 6]
使用场景
operator.add 特别有用在需要将加法操作作为一个函数传递的场景。例如，在函数式编程风格中，你可能需要将操作符作为参数传递给高阶函数，或者在需要将多个操作动态组合成复杂运算的场景中使用。
应用实例：使用 map 函数
假设你需要对两组数字进行成对加法，可以将 operator.add 与 map 函数结合使用：
import operatora = [1, 2, 3]
b = [4, 5, 6]
result = list(map(operator.add, a, b))
print(result) # 输出: [5, 7, 9]
这里，map 函数接受 operator.add 作为第一个参数（函数），a 和 b 作为后续的两个序列参数。map 将 a 和 b 的对应元素传递给 operator.add 函数，实现成对相加。
总结
使用 operator.add 可以提供一种函数式的方法来进行加法运算，这使得在需要将运算符作为函数传递或者处理的编程风格中非常方便和有效。这种方式简化了代码，特别是在涉及到高阶函数或复杂表达式的情况下。
4.文件和目录访问模块
os模块
walk
在Python中，os.walk 是一个非常有用的函数，它用于生成文件夹中的文件名，通过在目录树中游走，向使用者提供三个信息：当前文件夹名称，其子文件夹列表和其文件列表。这个功能对于需要递归访问文件系统和处理文件和目录的任务来说非常方便。
使用os.walk的基本格式如下：
import osfor dirpath, dirnames, filenames in os.walk(top, topdown=True, onerror=None, followlinks=False):# 处理逻辑
参数解释：
- top: 要遍历的顶级目录的路径。
- topdown (可选): 如果为
True（默认），则先遍历顶级目录，然后是子目录。如果为False，则先遍历所有子目录，再遍历顶级目录。 - onerror (可选): 是一个函数，它会在遇到错误时调用，错误对象会作为参数传递给该函数。
- followlinks (可选): 如果为
True，则会遍历目录下的符号链接指向的目录。
示例代码：
以下是一个使用os.walk遍历特定目录并打印每个目录中文件的示例：
import ospath = '/path/to/directory'for dirpath, dirnames, filenames in os.walk(path):print(f'Found directory: {dirpath}')for filename in filenames:print(f'\t{filename}')
这段代码将打印指定目录及其所有子目录中的所有文件和文件夹。
应用场景
os.walk特别适用于需要处理文件系统中大量文件的场景，例如：
- 搜索特定文件或文件类型。
- 重构目录结构。
- 自动化文件备份和同步。
- 大规模文件操作，比如批量重命名或修改。
由于os.walk自动处理目录树的深度遍历，因此它省去了手动编写递归遍历代码的麻烦，使得文件系统操作变得更加容易和直观。
listdir
在Python中，os.listdir() 函数是 os 模块提供的一个功能，用于列出指定目录下的所有文件和目录名。这个函数不会递归到子目录中，仅列出给定目录的直接子项。它返回一个列表，包含目录中的条目名称（文件、子目录等），不包括 '.'（当前目录）和 '..'（上级目录）。
基本用法
函数的基本形式如下：
import osos.listdir(path='.')
- path: 可选参数，指定要列出其条目的目录的路径。默认值是
'.'，代表当前工作目录。
示例
假设你有一个目录 /tmp/sample_dir，里面有几个文件和子目录，你可以使用 os.listdir() 来列出这些条目：
import os# 列出当前工作目录中的文件和目录
entries = os.listdir('.')
print(entries)# 指定目录
path = '/tmp/sample_dir'
entries = os.listdir(path)
print(entries)
应用场景
- 文件管理任务：
os.listdir()常用于文件管理和自动化脚本中，比如批量重命名文件、检查目录内容等。 - 数据预处理：在处理数据集时，经常需要列出数据目录中的文件，以进行进一步的数据加载和处理。
- 系统监控：用于监控特定目录下的变更，例如新文件的添加或文件的删除。
注意事项
- 权限问题：如果Python没有权限访问指定的目录，
os.listdir()会抛出一个PermissionError。 - 路径存在性：如果指定的路径不存在，会抛出一个
FileNotFoundError。
os.listdir() 是一个简单而强大的工具，适用于需要快速查看或处理目录内容的场景。在使用时，确保处理异常，如路径不存在或权限不足的问题。
os.path子模块
splittext
在 Python 中，splitext() 是 os.path 模块提供的一个函数，用于从一个路径中分离文件名和扩展名。这个函数非常实用，因为它能够正确处理不同操作系统中的文件路径，且能够正确识别文件扩展名的界限。
功能
splitext() 会返回一个元组，其中第一个元素是路径中的文件名（不包含扩展名），第二个元素是文件的扩展名（包含点 .）。如果路径中没有扩展名，扩展名部分将是一个空字符串。
基本用法
import ospath = 'example.txt'
filename, extension = os.path.splitext(path)
print("Filename:", filename)
print("Extension:", extension)
输出将会是：
Filename: example
Extension: .txt
示例
下面是一些使用 splitext() 的例子，演示其在处理不同类型文件路径时的表现：
import os# 示例 1: 普通文件名
print(os.path.splitext('example.txt')) # ('example', '.txt')# 示例 2: 包含路径的文件名
print(os.path.splitext('/path/to/example.txt')) # ('/path/to/example', '.txt')# 示例 3: 没有扩展名的文件
print(os.path.splitext('example')) # ('example', '')# 示例 4: 隐藏文件或点文件
print(os.path.splitext('.example')) # ('.example', '')# 示例 5: 复杂的文件名
print(os.path.splitext('archive.tar.gz')) # ('archive.tar', '.gz')
应用场景
os.path.splitext() 在很多场合都非常有用，尤其是在处理文件上传、文件处理和自动化脚本编写时，你需要根据文件类型做出不同的处理决策。这个函数帮助开发者轻松地获取文件扩展名，并据此进行逻辑操作。
注意，虽然这个函数对于大多数情况都工作良好，但在处理像 tar.gz 这样的双重扩展名时可能不会按预期返回全部的扩展名（如示例 5所示）。在这些情况下，可能需要额外的逻辑来正确处理复杂的文件扩展名。
join
在Python中，os.path.join函数是用来将多个路径组件合并成一个完整的路径字符串。这个函数会根据操作系统的路径分隔符来正确地构造路径。例如，在Windows系统中，路径分隔符是反斜杠\，而在Unix/Linux系统中，路径分隔符是正斜杠/。
这个函数可以接收多个字符串参数，将它们组合成一个路径。如果任何一个路径片段是一个绝对路径，那么之前的所有路径片段都会被忽略，组合将从绝对路径片段开始。
下面是一些使用os.path.join的例子：
import os# 在Unix/Linux系统上
path = os.path.join("/home", "user", "documents", "file.txt")
print(path) # 输出: /home/user/documents/file.txt# 在Windows系统上
path = os.path.join("C:\\", "Documents", "file.txt")
print(path) # 输出: C:\Documents\file.txt# 使用绝对路径片段
path = os.path.join("/home", "/user", "file.txt")
print(path) # 输出: /user/file.txt
这个函数是非常有用的，特别是在需要构建跨平台兼容的文件路径时。
basename
在Python中，os.path.basename() 函数是 os.path 模块的一部分，用于从一个完整的路径中提取文件名。这个函数非常有用，尤其是在处理文件路径和文件名时。
基本用法
函数的基本形式如下：
import os.pathfilename = os.path.basename(path)
- path: 字符串，表示文件或目录的完整路径。
示例
假设你有以下几个文件路径，你可以使用 os.path.basename() 来获取每个路径的基本文件名：
import os.pathpath1 = '/home/user/data.txt'
print(os.path.basename(path1)) # 输出: data.txtpath2 = '/home/user/documents/'
print(os.path.basename(path2)) # 输出: documentspath3 = 'filename.ext'
print(os.path.basename(path3)) # 输出: filename.ext
应用场景
- 文件处理：在读取、写入或操作文件时，经常需要从完整路径中提取文件名。
- 日志记录：在日志记录中记录正在处理的文件名时，
os.path.basename()提供了一种方便的方式来获取文件名。 - 用户界面显示：在开发涉及文件管理的应用程序时，显示当前操作的文件名而非完整路径可以提高用户体验。
注意事项
- 路径分隔符：
os.path.basename()会根据操作系统处理路径分隔符。在Windows上，它处理正斜杠（/）和反斜杠（\），而在Unix/Linux系统上，它只处理正斜杠。 - 空路径：如果传递给
os.path.basename()的路径为空，它返回空字符串。
os.path.basename() 是处理文件路径的基础工具之一，它简化了从完整路径中提取文件名的过程，非常适合在文件处理和数据管理任务中使用。
splittext
在Python中，os.path.splitext() 函数是 os.path 模块的一部分，用于分割文件名和扩展名。这个函数返回一个元组，其中第一个元素是路径中的文件名（不包括扩展名），第二个元素是文件的扩展名。
基本用法
函数的基本形式如下：
import os.pathroot, ext = os.path.splitext(path)
- path: 字符串，表示文件的完整路径或文件名。
示例
假设你有以下几个文件路径，你可以使用 os.path.splitext() 来获取每个路径的文件名和扩展名：
import os.pathpath1 = '/home/user/data.txt'
print(os.path.splitext(path1)) # 输出: ('/home/user/data', '.txt')path2 = 'archive.tar.gz'
print(os.path.splitext(path2)) # 输出: ('archive.tar', '.gz')path3 = 'filename'
print(os.path.splitext(path3)) # 输出: ('filename', '')path4 = 'anotherfile.'
print(os.path.splitext(path4)) # 输出: ('anotherfile', '.')
应用场景
- 文件处理：在读取、写入或操作特定类型的文件时，经常需要基于文件扩展名来决定如何处理文件。
- 数据导入/导出：在处理不同格式的数据文件（如 CSV、JSON、XML）时，可以使用
os.path.splitext()来动态确定文件格式。 - 文件上传：在web开发中处理文件上传时，可以用
os.path.splitext()来验证文件类型是否符合要求。
注意事项
- 处理多重扩展名：对于具有多重扩展名的文件（如
.tar.gz），os.path.splitext()只能正确分割出最后一个扩展名。如果需要处理复杂的文件名，可能需要更复杂的逻辑或多次调用此函数。 - 空扩展名：如果文件名没有扩展名，
os.path.splitext()返回的扩展名部分将是空字符串。
os.path.splitext() 是一个非常实用的函数，可以帮助开发者在处理文件和文件路径时更精确地操作文件名和扩展名，是文件处理和数据管理中不可或缺的工具。
json模块
dump
在Python中，json.dump 函数用于将Python对象编码成JSON格式的数据，并将其写入一个文件。这个函数属于 json 模块，因此在使用之前需要先导入这个模块。
函数签名
json.dump(obj, fp, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)
参数解释：
- obj: 要序列化的Python对象。
- fp: 一个
.write()支持的文件类对象。 - skipkeys: 如果
True，则字典中的keys不是基本数据类型（即非str、int、float或None）时将会被跳过，而不是引发TypeError异常。 - ensure_ascii: 如果为
True（默认），所有非ASCII字符都会被转义。如果为False，这些字符将会原样输出。 - check_circular: 如果
True（默认），则检查对象引用中的循环引用；这意味着引用相同的对象不会导致无限循环。 - allow_nan: 如果
True（默认），允许序列化NaN、Infinity和-Infinity作为它们对应的JSON表示形式；如果False，尝试这样做会引发ValueError。 - cls: 如果指定，它必须是一个继承自
json.JSONEncoder的自定义编码器类。 - indent: 指定缩进级别。使用非负整数将使每个级别缩进相应的空格数；如果指定为字符串，则使用字符串作为缩进；如果为
None（默认），则输出最紧凑的JSON表示。 - separators: 一个
(item_separator, key_separator)元组，用于指定列表和字典中的分隔符；默认为(', ', ': ')。 - default: 一个函数，它会被调用来处理无法被
json模块序列化的对象。 - sort_keys: 如果为
True，则字典的输出将按照键的字母顺序排序。
示例代码
下面是一个使用 json.dump 将Python字典写入文件的示例：
import jsondata = {"name": "John","age": 30,"city": "New York"
}# 写入到文件
with open('data.json', 'w') as f:json.dump(data, f, indent=4)
在这个例子中，data 字典被转换成了一个格式化的JSON文件，具有四个空格的缩进。
应用场景
json.dump 在处理数据持久化、数据交换等场景中非常有用，例如：
- 保存应用设置或状态。
- 创建或处理Web应用的配置文件。
- 在客户端与服务器之间发送和接收数据。
这个函数提供了一种标准化方式来处理JSON数据，使得数据在不同的系统和语言之间能够轻松交换。
load
在Python中，json.load() 函数是用来从一个文件句柄或者任何支持 .read() 方法的对象中解析JSON格式的数据，并将其转换为Python数据类型（如字典或列表）。这个函数是 json 模块的一部分，该模块提供了用于编码和解码JSON数据的方法。
基本用法
函数的基本形式如下：
import jsonjson.load(fp, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None)
- fp: 一个文件对象，必须支持
.read()方法。 - cls: 可选参数，为JSON解码器。默认情况下，使用
json.JSONDecoder。 - object_hook: 可选参数，如果指定，将使用此函数对解码出的字典进行后处理。
- parse_float: 可选参数，如果指定，将使用此函数对解码出的所有JSON浮点数进行后处理。
- parse_int: 可选参数，如果指定，将使用此函数对解码出的所有JSON整数进行后处理。
- parse_constant: 可选参数，如果指定，将使用此函数对解码过程中遇到的JSON常量（如
null,true,false）进行后处理。 - object_pairs_hook: 可选参数，如果指定，将使用此函数对解码出的字典进行后处理，此函数会覆盖
object_hook。
示例
读取JSON文件
假设你有一个名为 data.json 的文件，内容如下：
{"name": "John Doe","age": 30,"children": ["Jane Doe", "Doe Jr"],"married": true
}
要读取这个文件并将其内容转换为Python字典，你可以使用以下代码：
import json# 打开文件
with open('data.json', 'r') as file:data = json.load(file)# 输出数据
print(data)
# 输出: {'name': 'John Doe', 'age': 30, 'children': ['Jane Doe', 'Doe Jr'], 'married': True}
用途
json.load() 非常适合处理存储在文件中的JSON数据，常用于配置文件、数据交换等场景。由于JSON是一种轻量级的数据交换格式，这使得它在网络通信和多语言数据交换中非常流行。
注意事项
- 确保JSON文件格式正确，否则
json.load()可能会抛出json.JSONDecodeError。 - 使用
json.load()时，通常配合with语句来管理文件，这样可以自动处理文件的打开和关闭，避免文件泄露。
json.load() 是处理JSON数据的强大工具，它简化了从文件中读取结构化数据的过程，并能够轻松地将其转换为Python可操作的对象。
5.数据持久化模块
6.数据压缩和归档模块
7.并发执行模块
8.网络通信模块
9.运行交互模块
这篇关于python常用库函数的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
![[Python]锁](/front/images/it_default.gif)
