Python常用内置函数
Python内置函数
python中提供了很多内置函数，只要下载了python，不需要导入任何模块就可以使用。
本文介绍在深度学习中经常使用到的内置函数以及python中常用的函数，每遇见一个就更新笔记。
一、输入输出
1、input()
input() 输入的内容被接收后都是str字符串类型。
x = input("请输入x的值：")
print(x, type(x))
# 输入：45->x
# 输出：45 <class 'str'>
2、print()
print()是输出函数，可以直接输出某个变量，可以输出一段文字与变量。这就不得不提到格式化输出。
格式化输出大致有两种，①%s格式化输出 ②format()
Ⅰ. %s格式化输出
一般会使用%s来进行格式化输出，因为使用%s会自动调用str()函数，可以接受任何类型，也可以使用%d、%f，像c语言一样，可以使用%.05d(右对齐、左补零)等格式进行格式化输出。
注意： 和c语言不同，这里想输出的字符串和嵌入的%s 与 后面的变量之间需要使用 %隔离开 ，c语言是用逗号 “,” 。
name = "Alice"
age = 25
# 单个变量
print("Name: %s" % name)
# 输出：Name: Alice
# 多个变量（需用元组）
print("Name: %s, Age: %.3d" % (name, age))
# 输出：Name: Alice, Age: 025
# 变量运算后输出，需要加括号
print("两个我一共%s岁" % (age * 2))
print("两个我一共%s岁" % age * 2) # 不加括号默认会认为print( ("两个我一共%s岁" % age) * 2)，也就是输出两次
# 输出：两个我一共50岁
# 两个我一共25岁两个我一共25岁
Ⅱ. format() 格式化输出
format()格式化输出有两种形式，一种我称为format格式化"字符串{}".format(变量)，另一种我称为f表达式f"字符串{变量}"。
<1> "字符串{:}".format(变量)的方法
{}是占位符，每一个{}会占一个位置，能在字符串中插入一个变量的值，如果还相对变量进行进一步的格式控制，如左/右对齐，宽度，小数位数等，需要在{}内加上冒号{:}，然后再写格式控制。
name = "Alice"
age = 25
height = 1.68
# 按顺序传参
print("姓名: {}, 年龄: {}, 身高: {}".format(name, age, height))
# 输出 ↓
姓名: Alice, 年龄: 25, 身高: 1.68
# 按索引值使用
print("姓名: {2}, 年龄: {1}, 身高: {0}".format(height, age, name))
# 输出 ↓
姓名: Alice, 年龄: 25, 身高: 1.68
# 关键字参数
print("姓名: {n}, 年龄: {a}".format(n=name, a=age))
# 输出 ↓
姓名：Alice，年龄：25
# 对齐和填充,使用冒号 “：”
print("{:<10}".format(name)) # 左对齐，宽度10
print("{:^10}".format(name)) # 居中对齐
print("{:>10}".format(name)) # 右对齐
print("{:>010}".format(name)) # 右对齐,左补零，另外两种在格式化宽度前加0也分别是在不足宽度的地方补零
print("{:.5f}".format(height)) # 小数部分保留五位
print("{:>010.5f}".format(height)) # 全部占10位，小数占五位(不含小数点)，右对齐左补零
# 输出 ↓
Alice
Alice
Alice
00000Alice
1.68000
0001.68000
<2> f"字符串{变量:}"的方法
相对于format格式化，f表达式的方法不需要再在字符串后面写一大坨东西，而是直接将变量写在
{}内：{name}，如果需要进一步格式化就在变量后加上冒号：{name:}，之后进一步进行格式控制。
name = "Alice"
age = 25
height = 1.68
# 直接引用变量
print(f"姓名: {name}, 年龄: {age}, 身高: {height:.2f}")
# 支持表达式
print(f"{name.upper()} is {age * 2} in dog years.")
# 对齐和格式控制
print(f"{name:<10}") # 左对齐
print(f"{height:^10.3f}") # 居中对齐，保留2位小数
# 输出 ↓
姓名: Alice, 年龄: 25, 身高: 1.68
ALICE is 50 in dog years.
Alice
1.680
二、数据类型转换
1、int(x,base=10)
x：要转换的值（数字或字符串）（必须传入）
base：进制基数（2~36），默认为10
# 基本转换
print(int(3.99)) # 3（截断小数）
print(int(-2.7)) # -2
print(int("100")) # 100
print(int(" -20 ")) # -20（自动去除空格）
# 进制转换
print(int("1010", 2)) # 10（二进制）
print(int("FF", 16)) # 255（十六进制）
print(int("755", 8)) # 493（八进制）
print(int("Z", 36)) # 35（最大36进制）
# 特殊案例
print(int(True)) # 1（布尔值转换）
print(int(False)) # 0
# 错误案例
try:
print(int("3.14")) # ValueError
print(int("abc")) # ValueError
print(int("100", 2)) # ValueError（二进制不能有2）
except ValueError as e:
print(f"转换错误：{e}")
2、float(x)
x：要转换的值（数字或字符串）（必须传入）
# 基本转换
print(float(42)) # 42.0
print(float("3.14")) # 3.14
print(float(" -2.5 ")) # -2.5
# 科学计数法
print(float("1e-3")) # 0.001
print(float("2.5E+2")) # 250.0
# 特殊值
print(float("inf")) # inf
print(float("-inf")) # -inf
print(float("nan")) # nan
print(float("NaN")) # nan
# 布尔值转换
print(float(True)) # 1.0
print(float(False)) # 0.0
# 错误案例
try:
print(float("3.14.15")) # ValueError
print(float("abc")) # ValueError
except ValueError as e:
print(f"转换错误：{e}")
3、str(object='', encoding='utf-8', errors='strict')
object：要转换的对象 （必须传入）
encoding：编码方式（字节串转字符串时使用）
errors：错误处理方式（'strict', 'ignore', 'replace'等）
# 基本类型转换
print(str(100)) # '100'
print(str(3.14)) # '3.14'
print(str(True)) # 'True'
print(str(None)) # 'None'
# 容器类型
print(str([1, 2, 3])) # '[1, 2, 3]'
print(str({'a': 1})) # "{'a': 1}"
# 字节串解码
b = b'\xe4\xbd\xa0\xe5\xa5\xbd'
print(str(b, encoding='utf-8')) # '你好'
print(str(b, encoding='gbk', errors='ignore')) # 忽略错误字符
# 自定义对象
class Person:
def __init__(self, name):
self.name = name
def __str__(self):
return f"Person: {self.name}"
print(str(Person("Alice"))) # 'Person: Alice'
# 错误案例
try:
print(str(b, encoding='ascii')) # UnicodeDecodeError
except UnicodeDecodeError as e:
print(f"解码错误：{e}")
4、list(iterable)
iterable：任何可迭代对象（如字符串、元组、集合、字典、range对象等）
返回值：一个新的列表对象
Ⅰ、创建空列表
list1 = list() # 输出: []
# 等价于
list1 = []
Ⅱ、从其他可迭代对象转换（字符串""，元组()，集合{},字典{}，range对象）
list2= list("hello") # ['h', 'e', 'l', 'l', 'o']
list3= list((1, 2, 3)) # [1, 2, 3]
list4 = list({1, 2, 3}) # 输出可能是: [1, 2, 3]（集合无序，顺序可能不同）
list5= list({'a': 1, 'b': 2}) # 默认获取键,输出: ['a', 'b']
list6= list({'a': 1, 'b': 2}.items()) # {}.items() 输出: [('a', 1), ('b', 2)]
list7= list(range(5)) # [0, 1, 2, 3, 4]
Ⅱ、从生成器或迭代器转换
# 生成器表达式
gen = (x**2 for x in range(5))
list8= list(gen) # [0, 1, 4, 9, 16]
补充： 推导式
推导式主要包含四种:
列表推导式 -- [x for x in iterable]
字典推导式 -- {key : value for k,v in iterable}
集合推导式 -- {x for x in iterable}
生成器表达式 -- (x for x in iterable) （不要认为这是元组推导式，python中没有元组推导式）# 列表推导式 - 立即执行，返回列表 list_comp = [x**2 for x in range(5)] # [0, 1, 4, 9, 16] # 生成器表达式 - 惰性执行，返回生成器 gen_exp = (x**2 for x in range(5)) # <generator object at...> # 字典推导式 - 立即执行，返回字典 dict_comp = {x: x**2 for x in range(5)} # {0:0, 1:1, 2:4, 3:9, 4:16} # 集合推导式 - 立即执行，返回集合 set_comp = {x**2 for x in range(5)} # {0, 1, 4, 9, 16}其中生成器表达式返回的是一个生成器对象<class ‘generator’>，它和range对象<class 'range'>很类似，都是惰性计算，不会立刻返回值，都是可迭代对象。但是range对象可以重复使用和随机存取
如:range(10)[6]，而生成器对象只能单次使用不支持随机访问
三、其他常用内置函数
1、len(object)
object：可以是序列（如字符串、列表、元组等）、集合（如集合、字典）或其他实现了__len__() 方法的对象
返回值：对象的长度（整数）
Ⅰ、常见用法
# 1.序列类型
len("Hello") # 5 (字符串)
len([1, 2, 3]) # 3 (列表)
len((1, 2, 3)) # 3 (元组)
# 2.集合类型
len({1, 2, 3}) # 3 (集合)
len({"a": 1, "b": 2}) # 2 (字典，计算键的数量)
# 3.其他可迭代对象
len(range(10)) # 10 (range对象)
Ⅱ、深度学习中用途
用途：获取数据集/批量大小、张量维度长度。
示例：
dataset = [1, 2, 3, 4, 5]
batch_size = 2
num_batches = len(dataset) / batch_size # 计算批量数量
# 创建一个4维张量 (batch_size=2, channels=3, height=4, width=4)
tensor = torch.randn(2, 3, 4, 4)
print(len(tensor)) # 输出: 2 (第0维的长度)
print(tensor.shape) # 输出: torch.Size([2, 3, 4, 4])
print(tensor.shape[0]) # 输出: 2 (第0维的长度)
2、range()
range() 是 Python 中用于生成不可变序列的内置函数，特别适合用于循环控制和序列生成。它是惰性计算，占用内存小。
range() 函数有三种调用方式：
range(stop) # 生成 0 到 stop-1 的整数序列
range(start, stop) # 生成 start 到 stop-1 的整数序列
range(start, stop, step) # 生成 start 到 stop-1，步长为 step 的序列
# 步长可为负数，但是始值要大于终值
常见用法
# 固定循环次数
for i in range(5):
print(i) # 0, 1, 2, 3, 4
# 生成数字列表
numbers = list(range(10)) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 训练10个epoch
for epoch in range(10):
train_model()
3、enumerate(iterable, start=0)
iterable: 任何可迭代对象（列表、元组、字符串等）
start: 索引的起始值（默认为0)。无论是几，都会遍历全部元素，只是规定首元素下标不同而已。
返回：一个枚举对象（可迭代，每次迭代返回 (index, value) 元组）
enumerate()用于在遍历可迭代对象（如列表、元组、字符串等）时同时获取索引和值。他本是也是惰性计算，不会事先计算出索引键值对
# 1.常见用法
fruits = ['apple', 'banana', 'cherry']
# 使用enumerate
for index, fruit in enumerate(fruits):
print(index, fruit) # 0 apple 1 banana 2 cherry
for index, fruit in enumerate(fruits, start=1):
print(index, fruit) # 1 apple 2 banana 3 cherry
# 2.深度学习中用法
## 获取loader中的x,y数据
batch_idx = 0
for x, y in test_loader:
# 处理代码...
batch_idx += 1
## 获取loader中的索引和x,y数据
for batch_idx, (x, y) in enumerate(test_loader):
# 处理代码...
4、zip(*iterables, strict=False)
zip()用于将多个可迭代对象中的元素配对打包。可以用于一次获取多个可迭代对象中某个相同索引的的值。
*iterables：一个或多个可迭代对象（如列表、元组、生成器等）
strict：是否要求所有可迭代对象长度一致（Python 3.10+新增)。不要求一致时，按最短的序列进行截断。
返回：一个 zip 对象（可迭代的元组序列）
names = ['Alice', 'Bob', 'Charlie']
scores = [85, 92, 78]
# 单个值接收，接收到的都是元组对象
for i in zip(names, scores):
print(i) # ('Alice', 85)
# ('Bob', 92)
# ('Charlie', 78)
# 因为返回的是元组，所以可以用两个变量接收
for name, score in zip(names, scores):
print(f"{name}: {score}") # Alice: 85
# Bob: 92
# Charlie: 78
5、isinstance(object, classinfo)
isinstance() 是 Python 内置的类型检查函数，用于判断一个对象是否属于指定的类型或类型元组。它与type()区别：type()仅支持精确类型查询，且更快。
object：要检查的对象
classinfo：类型（类）或类型元组
返回值：True 如果对象是 classinfo 的实例或其子类的实例，否则返回 False
# 1.基本类型检查
num = 42
print(isinstance(num, int)) # True
name = "Alice"
print(isinstance(name, str)) # True
# 2.检查多个类型
value = 3.14
print(isinstance(value, (int, float))) # True
# 3.继承关系检查
python
class Parent: pass
class Child(Parent): pass
obj = Child()
print(isinstance(obj, Parent)) # True
# 4.在深度学习中的典型应用
## 4.1 模型层类型检查
import torch.nn as nn
layer = nn.Linear(10, 5)
print(isinstance(layer, nn.Module)) # True
## 4.2 数据类型验证
tensor = torch.randn(3, 3)
print(isinstance(tensor, torch.Tensor)) # True
6、map(function, iterable, *iterables)
map() 是 Python 内置的高阶函数，用于将函数应用于可迭代对象的每个元素，并返回一个迭代器。
function：要应用的函数（可以是普通函数、lambda函数等）
iterable：一个或多个可迭代对象
返回值：一个 map 对象（迭代器）
# 1.基本映射操作
# 将列表中的每个元素平方
numbers = [1, 2, 3, 4]
squared = map(lambda x: x**2, numbers)
print(list(squared)) # [1, 4, 9, 16]
# 2.多参数映射
# 两个列表对应元素相加
a = [1, 2, 3]
b = [4, 5, 6]
result = map(lambda x, y: x + y, a, b)
print(list(result)) # [5, 7, 9]
# 3.内置函数应用
# 将字符串列表转为整数
str_nums = ["1", "2", "3"]
int_nums = map(int, str_nums)
print(list(int_nums)) # [1, 2, 3]
# 4.在深度学习中的典型应用
## 4.1 数据预处理
# 批量标准化图像数据
images = [...] # 原始图像列表,四维数据，第0维表示图像个数
normalized = map(lambda img: (img - img.mean()) / img.std(), images)
##4.2 批量转换数据类型
# 将张量列表移动到GPU
tensors = [tensor1, tensor2, tensor3]
gpu_tensors = map(lambda t: t.to("cuda"), tensors)
##4.3多模型输入处理
# 对多个输入应用相同的预处理
inputs = [input1, input2, input3]
processed = map(preprocess_function, inputs)
7、sorted(iterable, *, key=None, reverse=False)
sorted() 是 Python 内置的排序函数，用于对可迭代对象进行排序并返回新的列表。与列表的 list.sort() 方法不同，sorted() 可以处理任何可迭代对象且不改变原数据。
iterable：要排序的可迭代对象加粗样式（列表、元组、字符串、字典等）
key：排序依据的函数（可选）
reverse：是否降序排序（默认False升序）
返回：一个新的已排序列表
*：单独出现的 * 符号是一个特殊的语法，用于强制要求其后的参数必须使用关键字参数的形式传递。这个特性被称为仅限关键字参数。* 之前的参数可以按位置或关键字传递。* 之后的参数 必须按关键字传递（如 key=function1 和 reverse=False）
# 1.基本排序
numbers = [3, 1, 4, 1, 5, 9, 2]
sorted_nums = sorted(numbers)
print(sorted_nums) # [1, 1, 2, 3, 4, 5, 9]
# 2.降序排序
print(sorted(numbers, reverse=True)) # [9, 5, 4, 3, 2, 1, 1]
# 3.字符串排序
words = ["banana", "apple", "cherry"]
print(sorted(words)) # ['apple', 'banana', 'cherry'] (按字母顺序)
8、type(object)
type() 是 Python 内置的核心函数，主要用于获取对象的类型信息和动态创建类。
x = torch.randn(3,3)
print(type(x)) # <class 'torch.Tensor'>
y = [1, 2, 3]
print(type(y)) # <class 'list'>
9、dir([object])
dir()主要用于交互式探索对象的属性和方法。它返回一个对象的所有有效属性名称的列表。查看里面有什么。
object (可选)：要检查的对象。如果省略，返回当前局部作用域中的名称列表
返回：一个按字母顺序排列的字符串列表
[object]：方括号 [] 的作用---表示被包裹的参数是 可选的（optional），调用时可以省略。
object：代表可以传入任何 Python 对象（如变量、实例、类等）。
组合 [object]：表示该参数可以传一个对象，也可以不传。
# 1.探索对象成员
my_list = [1, 2, 3]
print(dir(my_list)) # 显示列表对象的所有方法和属性
['__add__', '__class__', '__contains__', ..., 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
# 2.检查模块内容
import math
print(dir(math)) # 显示math模块的所有函数和常量
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc']
# 3.查看当前作用域
python
x = 10
y = "hello"
print(dir()) # 显示当前作用域的所有变量名
['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'x', 'y']
# 4.在深度学习中的典型应用
## 4.1探索PyTorch/TensorFlow对象
import torch
tensor = torch.randn(3,3)
print(dir(tensor)) # 查看张量的所有可用方法
##4.2 检查模型结构
model = torch.nn.Linear(10, 5)
print(dir(model)) # 查看模型的所有属性和方法
## 4.3 动态发现数据集特性
from torchvision import datasets
mnist = datasets.MNIST(root='./data')
print(dir(mnist)) # 查看数据集对象的可用方法和属性
10、help([object])
help() 是 Python 内置的交互式帮助系统，能够提供对象、模块、函数或关键字的详细文档说明。使用dir()查看完一个工具中有什么了之后，使用help()查看某个具体工具的使用方法。
显示对象的完整文档（docstring）
如果没有参数，启动交互式帮助系统
返回：无返回值（直接打印帮助信息）
四、PyCharm
PyCharm中有一个Python Concle（控制台）和Terminal（终端）。
控制台类似jupyter notebook，给一块输入就有一个输出。在测试的时候常用。 PyCharm 的 Python 控制台会自动继承当前项目的解释器环境。
Terminal类似Windows中CMD控制台，直接与操作系统交互，不直接涉及python环境。也可以在终端中输入python命令使用python解释器。一般情况下，经常用于在项目中缺少某个包的时候，直接打开PyCharm中的Terminal，它会自动选择当前项目的环境，在这里直接pip或conda安装包就行。
浙公网安备 33010602011771号