python内置函数 R

python内置函数 R

Python 解释器内置了很多函数和类型，任何时候都能使用。

R

range(stop)

class range(stop)

class range(start, stop, step=1)

虽然被称为函数，但 range 实际上是一个不可变的序列类型，参见在 range 对象 与 序列类型 — list, tuple, range 中的文档说明。

# 一个参数：表示从 0 开始，到这个参数（不包括这个参数）结束的整数序列。
nums = list(range(5))
nums[2] = 10
print(nums)
# 输出: [0, 1, 10, 3, 4]

# 两个参数：第一个参数表示开始的值，第二个参数表示结束的值（不包括）。
for i in range(1, 6):
    print(i)
# 输出:
# 1
# 2
# 3
# 4
# 5

# 三个参数：第一个参数表示开始的值，第二个参数表示结束的值（不包括），第三个参数表示步长。
for i in range(1, 10, 2):
    print(i)
# 输出:
# 1
# 3  
# 5
# 7
# 9
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

range() 返回的对象是一个迭代对象，这意味着它不会在内存中存储所有的值，而是每次迭代时生成下一个值。

range() 返回的整数序列是左闭右开的，即包括开始值，但不包括结束值。

repr(object)

返回包含一个对象的可打印表示形式的字符串。 对于许多类型而言，此函数会尝试返回一个具有与传给 eval() 时相同的值的字符串；在其他情况下，其表示形式将为一个包含对象类型名称和通常包括对象名称和地址的额外信息的用尖括号括起来的字符串。 一个类可以通过定义 __repr__() 方法来控制此函数为其实例所返回的内容。 如果 sys.displayhook() 不可访问，则此函数将会引发 RuntimeError。

该类具有自定义的表示形式，它可被求值为:

class Person:
   def __init__(self, name, age):
      self.name = name
      self.age = age

   def __repr__(self):
      return f"Person('{self.name}', {self.age})"
1
2
3
4
5
6
7

# 对于整数和浮点数，repr() 基本上返回其字面值
num = 42
print(repr(num))  # 输出: '42'

float_num = 3.14159
print(repr(float_num))  # 输出: '3.14159'

# 对于字符串，repr() 会添加引号，并转义特殊字符
s = 'Hello, world!'
print(repr(s))  # 输出: 'Hello, world!'

escaped_s = 'He said, "Hello, world!"'
print(repr(escaped_s))  # 输出: 'He said, "Hello, world!"'

# 对于列表和元组等复合类型，repr() 返回一个包含其元素的字符串表示形式
lst = [1, 2, 3]
print(repr(lst))  # 输出: '[1, 2, 3]'

tup = (1, 'a', 3.14)
print(repr(tup))  # 输出: '(1, 'a', 3.14)'


# 对于自定义对象，如果没有定义 __repr__() 方法，则会返回默认的表示形式
class MyClass:
    def __init__(self, value):
        self.value = value


obj = MyClass(42)
print(repr(obj))  # 输出: '<__main__.MyClass object at 0x7f...>'（这里的地址会变化）


# 自定义 __repr__() 方法以提供更有用的字符串表示形式
class MyClassWithRepr:
    def __init__(self, value):
        self.value = value

    def __repr__(self):
        return f'MyClassWithRepr({self.value})'


obj_with_repr = MyClassWithRepr(42)
print(repr(obj_with_repr))  # 输出: 'MyClassWithRepr(42)'
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

当你使用交互式 Python 解释器或在打印对象时（如果没有定义 __str__() 方法），Python 默认使用 repr() 函数来显示对象。

repr() 的主要目的是提供一个精确且无歧义的字符串表示形式，使得可以通过 eval() 重新创建对象（在大多数情况下）。而 str() 函数则更侧重于提供一个对用户友好的、可读的字符串表示形式。通常，在自定义类中，你会同时实现 __repr__() 和 __str__() 方法，以确保对象在调试时和向用户展示时都能提供适当的表示形式。

reversed(seq)

reversed() 是 Python 的一个内置函数，它返回一个反向迭代器，用于在遍历序列（如列表、元组或字符串）时以相反的顺序获取元素。

返回一个反向的 iterator。 seq 必须是一个具有 __reversed__() 方法或是支持序列协议（具有 __len__() 方法和从 0 开始的整数参数的 __getitem__() 方法）的对象。

# 元组
tup = ('a', 'b', 'c', 'd', 'e')
for char in reversed(tup):
    print(char)
# 输出:
# e
# d
# c
# b
# a

# 字符串
s = 'hello'
for letter in reversed(s):
    print(letter)
# 输出:
# o
# l
# l
# e
# h

lst = [1, 2, 3, 4, 5]
reversed_lst = list(reversed(lst))
print(reversed_lst)  # 输出: [5, 4, 3, 2, 1]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

reversed() 返回的是一个迭代器，而不是一个新的序列。这意味着它不会占用额外的内存来存储整个反向序列，而只是在迭代时逐个产生元素。

round(number, ndigits=None)

返回 number 舍入到小数点后 ndigits 位精度的值。 如果 ndigits 被省略或为 None，则返回最接近输入值的整数。

对于支持 round() 方法的内置类型，结果值会舍入至最接近的 10 的负 ndigits 次幂的倍数；如果与两个倍数同样接近，则选用偶数。因此，round(0.5) 和 round(-0.5) 均得出 0 而 round(1.5) 则为 2。ndigits 可为任意整数值（正数、零或负数）。如果省略了 ndigits 或为 None ，则返回值将为整数。否则返回值与 number 的类型相同。

对于一般的 Python 对象 number, round 将委托给 number.__round__。

备注：对浮点数执行 round() 的行为可能会令人惊讶：例如，round(2.675, 2) 将给出 2.67 而不是期望的 2.68。 这不算是程序错误：这一结果是由于大多数十进制小数实际上都不能以浮点数精确地表示。 请参阅 浮点算术：争议和限制 了解更多信息。

# 四舍五入到最接近的整数
num = 3.14159
rounded_num = round(num)
print(rounded_num)  # 输出: 3

# 四舍五入到指定的小数位数
num_with_decimal = 3.14159
rounded_to_2_decimal_places = round(num_with_decimal, 2)
print(rounded_to_2_decimal_places)  # 输出: 3.14

# 向上舍入的情况
num_up = 3.5
rounded_up = round(num_up)
print(rounded_up)  # 输出: 4

# 向下舍入的情况
num_down = 3.4
rounded_down = round(num_down)
print(rounded_down)  # 输出: 3

# 处理负数
negative_num = -3.5
rounded_negative = round(negative_num)
print(rounded_negative)  # 输出: -4

# 由于浮点数精度问题导致的非直观舍入
weird_float = 2.675
rounded_weird = round(weird_float, 2)
print(rounded_weird)  # 输出可能是 2.67 或 2.68，取决于具体的实现和浮点数精度
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

四舍五入并不总是按照直觉进行，特别是在处理浮点数的精度问题时。由于计算机内部表示浮点数的限制，有些浮点数并不能精确表示，这可能会导致一些意外的舍入结果。通常建议在进行财务计算或需要精确结果的场景中，使用整数或固定小数点数据类型，或者使用专门的数学库来处理浮点数。

参考：内置函数 — Python 3.12.2 文档