Python 内置函数 range、repr、reversed、round 是编程常用工具。range 生成不可变数字序列，支持步长和负数递减，常用于循环控制。repr 返回对象官方字符串表示，用于调试和序列化，区别于 str。reversed 创建反向迭代器，节省内存，适用于数据反转和回文检测。round 实现数值四舍五入，遵循银行家舍入规则，注意浮点数精度问题。掌握这些函数有助于编写高效健壮的 Python 代码，涵盖数据分析、财务计算等场景。
range() 函数用于生成不可变的数字序列，支持三种调用方式。
# 方式 1：只指定结束值（从 0 开始）
r1 = range(5)
print(f"range(5): {list(r1)}") # 输出：[0, 1, 2, 3, 4]
# 方式 2：指定开始和结束值
r2 = range(2, 8)
print(f"range(2, 8): {list(r2)}") # 输出：[2, 3, 4, 5, 6, 7]
# 方式 3：指定开始、结束和步长
r3 = range(1, 10, 2)
print(f"range(1, 10, 2): {list(r3)}") # 输出：[1, 3, 5, 7, 9]
# 负步长（递减）
r4 = range(10, 0, -2)
print(f"range(10, 0, -2): {list(r4)}") # 输出：[10, 8, 6, 4, 2]
# range 对象的基本操作
r = range(3)
print(f"长度：{len(r)}") # 输出：3
print(f"包含检查：{2 in r}") # 输出：True
print(f"索引访问：{r[1]}") # 输出：1
class RangeUtils:
@staticmethod
def generate_sequence(start, stop, step=1):
"""生成自定义序列"""
return list(range(start, stop, step))
@staticmethod
def create_index_pairs(length):
"""创建索引对"""
return [(i, length - i - 1) for i in range(length // 2)]
@staticmethod
def batch_process(data, batch_size):
"""批量处理数据"""
for i in range(0, len(data), batch_size):
batch = data[i:i + batch_size]
yield batch
# 使用示例
utils = RangeUtils()
# 生成序列
even_numbers = utils.generate_sequence(0, 10, 2)
print(f"偶数序列：{even_numbers}")
# 创建索引对
pairs = utils.create_index_pairs(6)
print(f"索引对：{pairs}")
# 批量处理
data = [1, 2, 3, 4, 5, , , ]
batches = (utils.batch_process(data, ))
()
()
i ():
()
countdown = ((, , -))
()
repr() 函数返回对象的官方字符串表示，通常可以用于重新创建该对象。
# 基本数据类型
print(f"字符串 repr: {repr('hello')}") # 输出：'hello'
print(f"整数 repr: {repr(42)}") # 输出：42
print(f"列表 repr: {repr([1, 2, 3])}") # 输出：[1, 2, 3]
# 特殊字符处理
text = "hello\nworld"
print(f"原始字符串：{text}")
print(f"repr 表示：{repr(text)}") # 输出：'hello\nworld'
# 与 str() 的区别
data = "hello"
print(f"str(): {str(data)}") # 输出：hello
print(f"repr(): {repr(data)}") # 输出：'hello'
# 自定义对象
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def __repr__(self):
return f"Person('', )"
p = Person(, )
()
class DebugHelper:
@staticmethod
def inspect_object(obj):
"""检查对象的详细信息"""
return {
'type': type(obj).__name__,
'repr': repr(obj),
'str': str(obj),
'id': id(obj)
}
@staticmethod
def safe_repr(obj, max_length=100):
"""安全的 repr 表示，限制长度"""
repr_str = repr(obj)
if len(repr_str) > max_length:
return repr_str[:max_length] + '...'
return repr_str
@staticmethod
def compare_representations(*objects):
"""比较多个对象的表示形式"""
comparisons = []
for obj in objects:
comparisons.append({
'object': obj,
'repr': repr(obj),
'str': str(obj)
})
return comparisons
# 使用示例
helper = DebugHelper()
# 对象检查
sample_data = [1, "hello", [1, 2, 3], {'key': }]
item sample_data:
info = helper.inspect_object(item)
()
long_text = *
short_repr = helper.safe_repr(long_text, )
()
:
():
.name = name
.price = price
.quantity = quantity
():
():
product = Product(, , )
()
()
reversed() 函数返回一个反向的迭代器，用于逆序访问序列元素。
# 列表反向
numbers = [1, 2, 3, 4, 5]
reversed_numbers = list(reversed(numbers))
print(f"原始列表：{numbers}")
print(f"反向列表：{reversed_numbers}")
# 字符串反向
text = "hello"
reversed_text = ''.join(reversed(text))
print(f"原始字符串：{text}")
print(f"反向字符串：{reversed_text}")
# 元组反向
tuple_data = (10, 20, 30)
reversed_tuple = tuple(reversed(tuple_data))
print(f"原始元组：{tuple_data}")
print(f"反向元组：{reversed_tuple}")
# 直接使用迭代器
for char in reversed("Python"):
print(char, end=" ") # 输出：n o h t y P
class ReversalUtils:
@staticmethod
def reverse_data_structure(data):
"""反转各种数据结构"""
if isinstance(data, (list, tuple, str)):
return type(data)(reversed(data))
else:
raise TypeError("不支持的数据类型")
@staticmethod
def is_palindrome(text):
"""检查是否为回文"""
cleaned = ''.join(c.lower() for c in text if c.isalnum())
return cleaned == ''.join(reversed(cleaned))
@staticmethod
def process_in_reverse(data, process_func):
"""反向处理数据"""
return [process_func(item) for item in reversed(data)]
@staticmethod
def get_last_n_items(data, n):
"""获取最后 n 个元素（使用反向）"""
return list(reversed(list(reversed(data))[:n]))
# 使用示例
utils = ReversalUtils()
# 数据结构反转
original_list = [, , , , ]
reversed_list = utils.reverse_data_structure(original_list)
()
test_texts = [, , ]
text test_texts:
result = utils.is_palindrome(text)
()
numbers = [, , , , ]
squared_reverse = utils.process_in_reverse(numbers, x: x ** )
()
data = [, , , , ]
last_three = utils.get_last_n_items(data, )
()
round() 函数用于对数值进行四舍五入，支持指定小数位数。
# 基本舍入
print(f"round(3.14159): {round(3.14159)}") # 输出：3
print(f"round(3.14159, 2): {round(3.14159, 2)}") # 输出：3.14
# 银行家舍入（向偶数舍入）
print(f"round(0.5): {round(0.5)}") # 输出：0
print(f"round(1.5): {round(1.5)}") # 输出：2
print(f"round(2.5): {round(2.5)}") # 输出：2
# 负小数位数
print(f"round(1234, -2): {round(1234, -2)}") # 输出：1200
print(f"round(5678, -3): {round(5678, -3)}") # 输出：6000
# 浮点数精度问题
print(f"round(2.675, 2): {round(2.675, 2)}") # 输出：2.67（不是 2.68）
# 整数舍入
print()
()
class RoundingUtils:
@staticmethod
def financial_round(value, decimals=2):
"""财务舍入（处理货币）"""
return round(value, decimals)
@staticmethod
def percentage_display(value, decimals=1):
"""百分比显示格式化"""
return f"{round(value * 100, decimals)}%"
@staticmethod
def significant_figures(number, figures=3):
"""有效数字舍入"""
if number == 0:
return 0
import math
magnitude = math.floor(math.log10(abs(number)))
return round(number, figures - magnitude - 1)
@staticmethod
def safe_round(value, decimals=None, default=0):
"""安全舍入（处理异常）"""
try:
if decimals is None:
return round(value)
else:
return (value, decimals)
(TypeError, ValueError):
default
utils = RoundingUtils()
prices = [, , ]
rounded_prices = [utils.financial_round(price) price prices]
()
ratios = [, , ]
percentages = [utils.percentage_display(ratio) ratio ratios]
()
scientific_numbers = [, , ]
sig_figs = [utils.significant_figures(num, ) num scientific_numbers]
()
test_values = [, , , ]
val test_values:
result = utils.safe_round(val, , )
()
class DataAnalyzer:
def __init__(self, data):
self.data = data
def summarize(self):
"""数据摘要统计"""
if not self.data:
return "无数据"
return {
'length': len(self.data),
'first': self.data[0] if self.data else None,
'last': self.data[-1] if self.data else None,
'reversed_sample': list(reversed(self.data))[:3],
'repr_sample': repr(self.data[:3]) + '...' if len(self.data) > 3 else repr(self.data)
}
def generate_report(self, decimal_places=2):
.data ((x, (, )) x .data):
numeric_data = [(x) x .data]
{
: (numeric_data),
: ((numeric_data), decimal_places),
: ((numeric_data) / (numeric_data), decimal_places),
: ((numeric_data), decimal_places),
: ((numeric_data), decimal_places),
: (((numeric_data))),
: [(x, decimal_places) x (numeric_data)]
}
analyzer = DataAnalyzer([, , , ])
summary = analyzer.summarize()
()
key, value summary.items():
()
report = analyzer.generate_report()
()
key, value report.items():
()
def create_number_sequence(start, end, step=1, precision=2):
"""创建精确的数字序列"""
return [round(x, precision) for x in range(start, end, step)]
def format_data_for_display(data, max_display=5):
"""格式化数据用于显示"""
if len(data) > max_display:
display_data = data[:max_display]
return f"{repr(display_data)}... 和 {len(data) - max_display} 更多项"
return repr(data)
def process_data_pipeline(data):
"""数据处理管道：反向→处理→舍入"""
# 反向处理
reversed_data = list(reversed(data))
# 数值处理（平方）
processed = [x ** 2 for x in reversed_data if isinstance(x, (int, float))]
# 舍入
rounded = [round(x, 2) for x in processed]
return {
'original': data,
'reversed': reversed_data,
'processed': processed,
'rounded': rounded
}
()
sequence = create_number_sequence(, , )
()
large_data = (())
display_str = format_data_for_display(large_data, )
()
test_data = [, , , ]
pipeline_result = process_data_pipeline(test_data)
()
stage, result pipeline_result.items():
()
通过本文的详细解析，我们深入了解了 Python 中四个重要的内置功能：
关键知识点总结：
range() 生成惰性序列，节省内存repr() 返回可 eval 的字符串表示，str() 返回用户友好表示reversed() 返回迭代器，支持各种序列类型round() 使用银行家舍入规则，注意浮点数精度问题实用场景推荐：
最佳实践建议：
range() 避免内存浪费repr()，显示用 str()reversed() 比切片 [::-1] 更节省内存注意事项：
range() 的参数必须是整数repr() 可能暴露敏感信息，生产环境慎用reversed() 不改变原序列，返回新迭代器round() 的浮点数精度问题需要特别注意进阶学习方向：
xrange()（Python 2）__repr__() 和 __str__() 的特殊方法这四个功能是 Python 编程的基础工具，从简单的循环控制到复杂的数据处理，它们为各种编程场景提供了强大的支持。掌握它们能够帮助你编写出更加高效、健壮的 Python 代码。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。 在线工具，加密/解密文本在线工具，online
解析常见 curl 参数并生成 fetch、axios、PHP curl 或 Python requests 示例代码。 在线工具，curl 转代码在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML转Markdown 互为补充。 在线工具，Markdown转HTML在线工具，online
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。 在线工具，HTML转Markdown在线工具，online