python的内置函数

MESSIR22

已于 2024-09-16 14:12:17 修改

阅读量1.8k

点赞数 15

文章标签： python 开发语言

于 2024-08-31 15:58:31 首次发布

本文链接：https://blog.csdn.net/2301_79783285/article/details/141753643

版权

前言：主要介绍几个遇到的,以后遇到别的再补充。

一、builtin

__builtin__ 模块是 Python 2 中的一个内置模块，它包含了 Python 解释器中所有内置函数和异常类型的定义。在 Python 3 中，这个模块已经被重命名为 builtins。

特点

内置模块：__builtin__（Python 2）或 builtins（Python 3）是 Python 解释器自带的模块之一。
内置函数和异常：该模块提供了许多常用的内置函数和异常类型，如 len(), int(), str(), Exception, TypeError 等。

常见函数和功能

以下是 __builtin__ 或 builtins 模块中的一些常见函数和功能：

内置函数：
abs(): 计算绝对值。
all(): 检查可迭代对象的所有元素是否为真。
any(): 检查可迭代对象的任何元素是否为真。
ascii(): 返回对象的 ASCII 表示。
bin(): 将整数转换为二进制字符串。
bool(): 将值转换为布尔值。
bytearray(): 创建一个新的字节数组。
callable(): 检查对象是否可调用。
chr(): 返回指定 Unicode 码位的字符。
compile(): 编译源代码为代码或 AST 对象。
delattr(): 删除对象的属性。
dir(): 返回对象的有效属性列表。
divmod(): 返回除法和取模的结果。
enumerate(): 返回枚举对象。
eval(): 评估一个字符串表达式。
exec(): 动态执行 Python 代码。
filter(): 构造一个迭代器，从可迭代对象中过滤元素。
float(): 将值转换为浮点数。
format(): 格式化字符串。
frozenset(): 创建一个不可变集合。
getattr(): 获取对象的属性。
globals(): 返回当前全局命名空间的字典。
hasattr(): 检查对象是否有指定的属性。
hash(): 返回对象的哈希值。
hex(): 将整数转换为十六进制字符串。
id(): 返回对象的标识。
input(): 读取用户输入。
int(): 将值转换为整数。
isinstance(): 检查对象是否是某个类的实例。
issubclass(): 检查一个类是否是另一个类的子类。
iter(): 返回一个迭代器对象。
len(): 返回对象的长度。
list(): 创建一个列表。
locals(): 返回当前局部命名空间的字典。
map(): 应用函数到可迭代对象的每个元素。
max(): 返回最大值。
memoryview(): 返回一个内存视图对象。
min(): 返回最小值。
next(): 获取迭代器的下一个项目。
oct(): 将整数转换为八进制字符串。
open(): 打开一个文件。
ord(): 返回字符的 Unicode 码位。
pow(): 计算幂。
print(): 打印对象。
property(): 创建一个属性对象。
range(): 创建一个范围对象。
repr(): 返回对象的字符串表示。
reversed(): 返回一个反转的迭代器。
round(): 四舍五入一个数字。
setattr(): 设置对象的属性。
slice(): 创建一个切片对象。
sorted(): 返回排序后的列表。
staticmethod(): 创建一个静态方法。
str(): 将值转换为字符串。
sum(): 计算可迭代对象中元素的总和。
super(): 返回一个代理对象，用来调用父类的方法。
tuple(): 创建一个元组。
type(): 返回对象的类型。
vars(): 返回对象的 __dict__ 属性。
zip(): 返回一个迭代器，聚合多个可迭代对象。

二、os

Python 的 os 模块提供了与操作系统交互的一系列功能。这个模块让你可以直接从 Python 脚本中调用操作系统级别的功能，如文件和目录的操作、环境变量的管理、进程控制等。

1. 文件和目录操作

os.mkdir(path, mode=0o777)

功能：创建一个目录。
参数：
path：新目录的路径。
mode：新目录的权限模式，默认为 0o777。

os.makedirs(name, mode=0o777, exist_ok=False)

功能：递归创建目录。
参数：
name：新目录的路径。
mode：新目录的权限模式，默认为 0o777。
exist_ok：如果设置为 True，则如果目录已经存在，则不会抛出异常。

os.rmdir(path)

功能：删除一个空目录。
参数：
path：要删除的目录的路径。

os.removedirs(path)

功能：递归地删除目录。
参数：
path：要删除的目录的路径。

os.rename(src, dst)

功能：重命名文件或目录。
参数：
src：源文件或目录的路径。
dst：目标文件或目录的新路径。

os.replace(src, dst)

功能：重命名文件或目录，并且如果目标文件已存在，则会覆盖目标文件。
参数：
src：源文件或目录的路径。
dst：目标文件或目录的新路径。

os.remove(path)

功能：删除文件。
参数：
path：要删除的文件的路径。

os.listdir(path='.')

功能：列出指定目录下的文件和目录。
参数：
path：要列出的目录的路径，默认为当前目录。

os.chdir(path)

功能：改变当前工作目录。
参数：
path：新的工作目录的路径。

os.getcwd()

功能：获取当前工作目录。

os.stat(path)

功能：获取文件或目录的状态信息。
参数：
path：要获取状态信息的文件或目录的路径。

2. 环境变量管理

os.environ

功能：访问环境变量的字典。

os.getenv(key, default=None)

功能：获取环境变量的值。
参数：
key：环境变量的名称。
default：如果环境变量不存在，则返回这个默认值。

os.putenv(key, value)

功能：设置环境变量的值。
参数：
key：环境变量的名称。
value：环境变量的值。

os.unsetenv(key)

功能：删除环境变量。
参数：
key：要删除的环境变量的名称。

3. 进程控制

os.execl(file, *args)

功能：替换当前进程的映像。
参数：
file：要执行的文件的路径。
*args：传递给新进程的参数。

os.execv(path, args)

功能：替换当前进程的映像。
参数：
path：要执行的文件的路径。
args：一个包含新进程参数的列表。

os.fork()

功能：创建一个新的进程。
返回值：
在父进程中返回子进程的 PID。
在子进程中返回 0。

os.waitpid(pid, options)

功能：等待子进程终止。
参数：
pid：要等待的子进程的 PID。
options：选项标志，如 os.WNOHANG 表示如果没有子进程退出则立即返回。

os.system(command)

功能：执行一个shell命令。
参数：
command：要执行的命令字符串。

4. 其他功能

os.path

功能：提供与文件系统路径相关的函数。
os.path.exists(path)：检查路径是否存在。
os.path.isfile(path)：检查路径是否指向一个文件。
os.path.isdir(path)：检查路径是否指向一个目录。
os.path.join(*paths)：将多个路径组件合并成一个路径。
os.path.split(path)：分割路径，返回路径名和文件名。
os.path.abspath(path)：返回绝对路径。
os.path.dirname(path)：返回路径中的目录部分。
os.path.basename(path)：返回路径中的文件名部分。
os.path.getsize(path)：返回文件大小。

os.urandom(n)

功能：生成 n 字节的随机数据。
参数：
n：要生成的随机数据的字节数。

os.pipe()

功能：创建一个管道。
返回值：
返回一个包含两个文件描述符的元组，第一个用于读取，第二个用于写入。

import os

# 创建目录
os.mkdir('new_dir')

# 列出当前目录下的文件和目录
print("Current directory contents:", os.listdir('.'))

# 改变当前工作目录
os.chdir('new_dir')

# 获取当前工作目录
print("Current working directory:", os.getcwd())

# 创建文件
with open('example.txt', 'w') as file:
    file.write('Hello, World!')

# 获取文件大小
print("File size:", os.path.getsize('example.txt'))

# 获取环境变量
print("HOME environment variable:", os.getenv('HOME'))

# 执行命令
os.system('ls -l')

# 删除文件
os.remove('example.txt')

# 删除目录
os.chdir('..')
os.rmdir('new_dir')

三、sys

Python 的 sys 模块提供了对解释器的一些变量和函数的访问，这些变量和函数与 Python 解释器的运行环境有关。sys 模块主要用于获取和设置与 Python 解释器有关的各种属性，包括命令行参数、标准输入/输出流、模块搜索路径等。

1. 命令行参数

sys.argv

功能：获取命令行参数列表。
说明：sys.argv 是一个列表，其中第一个元素 (sys.argv[0]) 是脚本的名称，其余元素是传入脚本的参数。

示例：

1import sys
2
3print("Script name:", sys.argv[0])
4print("Arguments:", sys.argv[1:])

2. 输入输出流

sys.stdin

功能：标准输入流。
说明：可以用来读取从命令行输入的数据。

示例：

1import sys
2
3for line in sys.stdin:
4    print(line.strip())

sys.stdout

功能：标准输出流。
说明：可以用来向命令行输出数据。

示例：

1import sys
2
3sys.stdout.write("Hello, World!\n")

sys.stderr

功能：标准错误流。
说明：通常用于输出错误信息。

示例：

1import sys
2
3sys.stderr.write("An error occurred!\n")

3. 版本信息

sys.version

功能：获取 Python 解释器的版本信息。

示例：

1import sys
2
3print("Python version:", sys.version)

sys.version_info

功能：获取 Python 解释器的版本信息，返回一个元组。

示例：

1import sys
2
3print("Python major version:", sys.version_info.major)
4print("Python minor version:", sys.version_info.minor)
5print("Python micro version:", sys.version_info.micro)

4. 解释器配置

sys.platform

功能：获取当前平台的名称。

示例：

1import sys
2
3print("Platform:", sys.platform)

sys.prefix

功能：获取 Python 安装前缀。

示例：

1import sys
2
3print("Python prefix:", sys.prefix)

sys.path

功能：获取模块搜索路径列表。
说明：Python 解释器会在这些路径中查找模块。

示例：

1import sys
2
3print("Module search paths:", sys.path)

5. 解释器状态

sys.modules

功能：获取已导入的模块字典。

示例：

1import sys
2
3print("Imported modules:", list(sys.modules.keys()))

sys.builtin_module_names

功能：获取内置模块名称列表。

示例：

1import sys
2
3print("Built-in module names:", sys.builtin_module_names)

6. 异常处理

sys.exc_info()

功能：获取当前正在处理的异常信息。
返回值：一个三元组，包含异常类型、异常对象和追踪回溯对象。

示例：

1import sys
2
3try:
4    1 / 0
5except Exception as e:
6    exc_type, exc_value, exc_traceback = sys.exc_info()
7    print("Exception type:", exc_type)
8    print("Exception value:", exc_value)

7. 解释器退出

sys.exit(n=0)

功能：退出 Python 解释器。
参数：
- n：退出状态码，默认为 0。

示例：

1import sys
2
3if __name__ == "__main__":
4    if len(sys.argv) != 2:
5        sys.exit("Usage: script.py <argument>")

8. 其他常用函数

sys.setrecursionlimit(limit)

功能：设置递归限制。
参数：
- limit：递归的最大深度。

示例：

1import sys
2
3sys.setrecursionlimit(5000)

sys.maxsize

功能：获取系统支持的最大整数大小。

示例：

1import sys
2
3print("Max integer size:", sys.maxsize)

sys.getsizeof(obj)

功能：获取对象的大小（以字节为单位）。
参数：
- obj：要测量的对象。

示例：

1import sys
2
3x = [1, 2, 3]
4print("Size of x:", sys.getsizeof(x))

示例代码

下面是一个简单的示例，演示如何使用 sys 模块的一些功能：

1import sys
2
3# 获取命令行参数
4if len(sys.argv) > 1:
5    print("Arguments:", sys.argv[1:])
6else:
7    print("No arguments provided.")
8
9# 输出到标准输出
10sys.stdout.write("Hello, World!\n")
11
12# 输出到标准错误
13sys.stderr.write("An error occurred!\n")
14
15# 获取 Python 版本信息
16print("Python version:", sys.version)
17print("Python major version:", sys.version_info.major)
18
19# 获取平台信息
20print("Platform:", sys.platform)
21
22# 获取模块搜索路径
23print("Module search paths:", sys.path)
24
25# 获取已导入的模块
26print("Imported modules:", list(sys.modules.keys()))
27
28# 设置递归限制
29sys.setrecursionlimit(5000)
30
31# 获取对象大小
32x = [1, 2, 3]
33print("Size of x:", sys.getsizeof(x))
34
35# 退出程序
36sys.exit(0)

四、urllib

在 Python 中，import urllib 语句用于导入 urllib 模块，这是一个用于处理 URL 的标准库。urllib 模块提供了一系列工具和函数，使得你可以轻松地处理 HTTP 请求、解析 URL、打开网络资源等。

`urllib` 模块的结构

urllib 模块实际上是一个包，包含了多个子模块，每个子模块负责不同的功能。主要的子模块有：

urllib.request：用于发送网络请求和接收响应。
urllib.parse：用于解析和构造 URL。
urllib.error：定义了一些异常类，用于处理请求错误。
urllib.robotparser：用于解析 robots.txt 文件，确定爬虫的爬取规则。

`urllib.request` 模块

urllib.request 模块提供了用于发送 HTTP 请求的功能，包括打开网络资源、发送 POST 请求等。

常用函数

urlopen(url, data=None, timeout=<socket._GLOBAL_DEFAULT_TIMEOUT>)：
- 功能：打开一个 URL 并返回一个类似于文件的对象。
- 参数：
  - url：要打开的 URL。
  - data：可选参数，用于发送 POST 数据。
  - timeout：超时时间，默认为全局默认值。
- 返回值：返回一个类似于文件的对象，可以从中读取数据。
Request(url, data=None, headers={}, origin_req_host=None, unverifiable=False, method=None)：
- 功能：创建一个 Request 对象，用于发送请求。
- 参数：
  - url：要请求的 URL。
  - data：可选参数，用于发送 POST 数据。
  - headers：请求头。
  - origin_req_host：请求的主机。
  - unverifiable：是否不可验证。
  - method：请求方法（GET, POST 等）。

示例代码

下面是一个简单的示例，演示如何使用 urllib.request 模块发送 GET 请求并读取响应：

1import urllib.request
2
3# 发送 GET 请求
4response = urllib.request.urlopen('http://www.example.com')
5
6# 读取响应内容
7html = response.read().decode('utf-8')
8
9# 打印响应内容
10print(html)

`urllib.parse` 模块

urllib.parse 模块提供了用于解析和构造 URL 的功能。

常用函数

urlencode(query, doseq=0)：
- 功能：将字典或序列转换为 URL 编码的查询字符串。
- 参数：
  - query：字典或序列。
  - doseq：如果为 True，则对多个相同的键进行编码。
- 示例：
```
1params = {'name': 'John Doe', 'age': 30}
2query_string = urllib.parse.urlencode(params)
3print(query_string)  # 输出: name=John+Doe&age=30
```

urlsplit(url)：

功能：将 URL 分解为五个部分：scheme, netloc, path, query, fragment。
参数：
- url：要分解的 URL。
返回值：一个元组，包含五个部分。

示例：

1result = urllib.parse.urlsplit('http://www.example.com/path?query=string#fragment')
2print(result)  # 输出: SplitResult(scheme='http', netloc='www.example.com', path='/path', query='query=string', fragment='fragment')

urlunsplit(parts)：

功能：将五个部分重新组合成一个完整的 URL。
参数：
- parts：一个包含五个部分的元组。

示例：

1parts = ('http', 'www.example.com', '/path', 'query=string', 'fragment')
2url = urllib.parse.urlunsplit(parts)
3print(url)  # 输出: http://www.example.com/path?query=string#fragment

示例代码

下面是一个简单的示例，演示如何使用 urllib.parse 模块解析和构造 URL：

1import urllib.parse
2
3# 解析 URL
4result = urllib.parse.urlsplit('http://www.example.com/path?query=string#fragment')
5print(result)
6
7# 构造 URL
8parts = ('http', 'www.example.com', '/path', 'query=string', 'fragment')
9url = urllib.parse.urlunsplit(parts)
10print(url)

`urllib.error` 模块

urllib.error 模块定义了一些异常类，用于处理请求错误。

常用异常

HTTPError：当 HTTP 请求失败时抛出。
URLError：当无法到达服务器时抛出。

示例代码

下面是一个简单的示例，演示如何处理请求错误：

1import urllib.request
2from urllib.error import HTTPError, URLError
3
4try:
5    response = urllib.request.urlopen('http://www.example.com/nonexistent')
6except HTTPError as e:
7    print(f"HTTP Error: {e.code} {e.reason}")
8except URLError as e:
9    print(f"URL Error: {e.reason}")
10else:
11    html = response.read().decode('utf-8')
12    print(html)

五、init

在 Python 中，__init__ 方法是一个特殊的方法，被称为初始化方法（或构造函数），用于初始化新创建的对象。当一个类的实例被创建时，__init__ 方法会被自动调用。

`init` 的基本用法

1. 方法签名

__init__ 方法的第一个参数通常是 self，它代表即将被初始化的对象的引用。除此之外，可以根据需要添加其他参数来传递给构造函数。

2. 示例

下面是一个简单的类定义，包含了一个 __init__ 方法：

1class Person:
2    def __init__(self, name, age):
3        self.name = name
4        self.age = age
5
6# 创建一个 Person 类的实例
7person = Person('Alice', 30)
8print(person.name)  # 输出: Alice
9print(person.age)   # 输出: 30

在这个例子中，Person 类有一个 __init__ 方法，接受两个参数 name 和 age。当创建 Person 类的新实例时，传入的参数将用于初始化对象的属性。

`init` 的其他用途

3. 默认参数

__init__ 方法可以接受默认参数值：

1class Person:
2    def __init__(self, name, age=30):
3        self.name = name
4        self.age = age
5
6# 创建一个 Person 类的实例，年龄默认为 30
7person = Person('Alice')
8print(person.name)  # 输出: Alice
9print(person.age)   # 输出: 30

4. 调用父类的 `init` 方法

如果一个类继承自另一个类，并且想要在子类中重写 __init__ 方法，通常需要显式调用父类的 __init__ 方法来确保父类的初始化逻辑也被执行：

1class Person:
2    def __init__(self, name, age):
3        self.name = name
4        self.age = age
5
6class Student(Person):
7    def __init__(self, name, age, grade):
8        super().__init__(name, age)  # 调用父类的 __init__ 方法
9        self.grade = grade
10
11# 创建一个 Student 类的实例
12student = Student('Bob', 20, 'Sophomore')
13print(student.name)  # 输出: Bob
14print(student.age)   # 输出: 20
15print(student.grade) # 输出: Sophomore

在这个例子中，Student 类继承自 Person 类，并且重写了 __init__ 方法。通过调用 super().__init__(name, age) 来确保父类的初始化逻辑被执行。

注意事项

5. 构造函数与 `init` 的区别

在 Python 中，__init__ 方法是一个初始化方法，而不是传统意义上的构造函数。Python 中的构造函数实际上是 __new__ 方法，它负责创建一个新的对象。__init__ 方法则负责初始化这个对象。

6. `init` 与 `new`

__new__ 是一个静态方法，用于创建对象并返回这个新的对象实例。
__init__ 是一个实例方法，用于初始化 __new__ 创建的对象。

通常情况下，我们只需要关注 __init__ 方法即可，除非需要定制对象的创建过程（例如，改变内存分配方式或实现定制的克隆机制）。

总结

__init__ 方法是 Python 类中的一个特殊方法，用于初始化类的实例。通过定义 __init__ 方法，可以在创建类的实例时设置对象的初始状态。在继承的情况下，通常需要显式调用父类的 __init__ 方法来确保父类的初始化逻辑得到执行。

六、`globals`

访问全局变量：可以使用 __globals__ 来访问当前模块中的全局变量。
执行动态代码：在执行动态生成的代码时，可以使用 __globals__ 来提供全局命名空间。
调试和元编程：在调试或进行元编程时，可以利用 __globals__ 获取当前模块的全局环境。

示例

1. 访问全局变量

1x = 10  # 全局变量
2
3def example_function():
4    print("__globals__:", __globals__)
5    print("Accessing global variable x:", __globals__['x'])
6
7example_function()

在这个例子中，example_function 中的 __globals__ 引用了全局命名空间，并且可以从中访问全局变量 x。

2. 执行动态代码

假设你需要在运行时动态生成一些代码，并且希望这些代码能够在当前模块的全局环境下执行：

1def dynamic_code():
2    code = """
3def my_function(a, b):
4    return a + b
5"""
6    exec(code, __globals__)
7
8dynamic_code()
9
10print("Calling the dynamically created function:", __globals__['my_function'](1, 2))

在这个例子中，exec 函数用于执行动态生成的代码，并且通过 __globals__ 提供了全局命名空间。这样，动态生成的函数 my_function 可以在全局环境中定义，并且可以在后续代码中调用。

3. 调试和元编程

在某些情况下，你可能需要知道当前模块的全局环境，例如在调试过程中或者在实现元编程工具时：

1import inspect
2
3def inspect_globals():
4    global_var = 42
5    print("Global variables:", __globals__.keys())
6    print("Current frame globals:", inspect.currentframe().f_globals.keys())
7
8inspect_globals()

在这个例子中，inspect_globals 函数展示了如何使用 __globals__ 来获取当前模块的全局变量，并且使用了 inspect 模块来进一步确认当前帧的全局环境。

注意事项

安全问题：使用 __globals__ 来执行动态生成的代码时，需要注意安全性。如果动态代码来自不可信的来源，可能会存在安全风险。
命名冲突：在使用 __globals__ 时，要小心避免命名冲突。例如，在 exec 或 eval 中使用全局变量时，确保变量名称在全局命名空间中唯一。

python的常用模块

os：提供与操作系统交互的功能，如文件和目录操作。
sys：提供与 Python 解释器交互的功能，如命令行参数、退出程序等。
math：提供数学相关的函数。
datetime：提供日期和时间相关的功能。
re：提供正则表达式匹配功能。
json：提供 JSON 编码和解码功能。
pickle：提供对象的序列化和反序列化功能。
random：提供随机数生成功能。
collections：提供容器数据类型的补充。
itertools：提供高效的循环迭代工具。