python内置函数 S

python内置函数 S

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

S

名称	描述
set	创建一个集合。
setattr	设置对象的属性值。
slice	创建切片对象。
sorted	对可迭代对象（如列表、元组等）进行排序，并返回一个新的已排序列表。
staticmethod	装饰一个方法是静态方法。
str	将其他数据类型转换为字符串（string）类型。
sum	计算可迭代对象（如列表、元组、字符串等）中所有元素的和。
super	super()函数用于调用父类（或超类）的一个方法。

set()

set() 是 Python 中的一个内置数据类型，用于存储无序且不重复的元素集合。集合是一种可变的数据类型，它支持集合运算，如并集、交集、差集等。

class set

class set(iterable)

返回一个新的 set 对象，可以选择带有从 iterable 获取的元素。 set 是一个内置类型。 请查看 set 和 集合类型 — set, frozenset 获取关于这个类的文档。

有关其他容器请参看内置的 frozenset, list, tuple 和 dict 类，以及 collections 模块。

# 使用 set() 函数
s1 = set([1, 2, 3, 2])
print(s1)  # 输出: {1, 2, 3}

# 使用字面量语法
s2 = {1, 2, 3}
print(s2)  # 输出: {1, 2, 3}

# 使用字面量语法创建只有一个元素的集合
s3 = {4, }  # 注意这里的逗号
print(s3)  # 输出: {4}

# 并集
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s_union = s1 | s2  # 使用 | 运算符
print(s_union)  # 输出: {1, 2, 3, 4}

# 交集
s_intersection = s1 & s2  # 使用 & 运算符
print(s_intersection)  # 输出: {2, 3}

# 差集
s_difference = s1 - s2  # 使用 - 运算符
print(s_difference)  # 输出: {1}

# 对称差集
s_symmetric_difference = s1 ^ s2  # 使用 ^ 运算符
print(s_symmetric_difference)  # 输出: {1, 4}

s = {1, 2, 3}
s.add(4)  # 添加元素 4  
print(s)  # 输出: {1, 2, 3, 4}

s.remove(3)  # 移除元素 3
print(s)  # 输出: {1, 2, 4}

s.discard(5)  # 尝试移除元素 5，但元素不存在，所以不会有任何影响
print(s)  # 输出: {1, 2, 4}

当使用 {} 时，如果里面只有一个元素，你需要加上逗号来区分它和空字典 {}。

集合的其他操作：

• add(element)：向集合中添加一个元素。
• remove(element)：从集合中移除一个元素。如果元素不存在，会抛出 KeyError。
• discard(element)：从集合中移除一个元素。如果元素不存在，不会抛出任何异常。
• clear()：清空集合。
• isdisjoint(other)：如果两个集合没有交集，返回 True。
• issubset(other) 或 <=：判断集合是否是另一个集合的子集。
• issuperset(other) 或 >=：判断集合是否是另一个集合的超集。

集合在数据去重、集合运算等方面非常有用，是 Python 中一个重要的数据类型。

setattr(object, name, value)

setattr() 是 Python 中的一个内置函数，用于设置对象的属性值。

• object：要设置属性的对象。
• name：要设置的属性名，以字符串形式提供。
• value：要设置的属性值。

setattr() 函数会尝试将对象的指定属性设置为给定值。如果该属性不存在，它会被创建。如果属性已存在，它的值将被更新。

本函数与 getattr() 相对应。其参数为一个对象、一个字符串和一个任意值。字符串可以为某现有属性的名称，或为新属性。只要对象允许，函数会将值赋给属性。如 setattr(x, 'foobar', 123) 等价于 x.foobar = 123。

name 无需为在 标识符和关键字 中定义的 Python 标识符除非对象选择强制这样做，例如在一个自定义的 __getattribute__() 中或是通过 __slots__。 一个名称不为标识符的属性将不可使用点号标记来访问，但是可以通过 getattr() 等来访问。

备注：由于 私有名称混合 发生在编译时，因此必须手动混合私有属性（以两个下划线打头的属性）名称以便使用 setattr() 来设置它。

class MyClass:
    def __init__(self):
        self.existing_attribute = "Hello"

# 创建一个 MyClass 的实例  
my_object = MyClass()

# 使用 setattr() 设置一个已存在的属性  
setattr(my_object, "existing_attribute", "World")
print(my_object.existing_attribute)  # 输出: World  

# 使用 setattr() 设置一个新属性  
setattr(my_object, "new_attribute", 42)
print(my_object.new_attribute)  # 输出: 42

setattr() 非常强大，因为它能够动态地修改对象的属性。然而，这也可能导致代码难以理解和维护，特别是当属性的设置和修改散布在代码的多个地方时。因此，在使用 setattr() 时应该谨慎，并确保它确实符合你的需求。在大多数情况下，直接访问和设置对象的属性（如 object.attribute = value）是更清晰和更直接的方式。

slice(stop)

class slice(stop)

class slice(start, stop, step=None)

slice() 函数返回一个切片对象，这个对象具有 start、stop 和 step 属性，并定义了相应的 __getitem__() 方法，以便它可以用于索引序列。

返回一个表示由 range(start, stop, step) 指定的索引集的 slice 对象。 start 和 step 参数默认为 None。

• 切片对象具有只读的数据属性 start, stop 和 step，它们将简单地返回相应的参数值（或其默认值）。 它们没有其他显式的功能；但是，它们会被 NumPy 和其他第三方包所使用。
• start：切片的起始索引（包含）。如果省略，则默认为 None，意味着从序列的开始位置开始。
• stop：切片的结束索引（不包含）。如果省略，则默认为 None，意味着到序列的结束位置结束。
• step：切片的步长。如果省略，则默认为 None，意味着取序列中所有的元素。

当使用扩展索引语法时也会生成切片对象。 例如: a[start:stop:step] 或 a[start:stop, i]。 请参阅 itertools.islice() 了解返回 iterator 的替代版本。

在 3.12 版本发生变更: Slice 对象现在将为 hashable (如果 start, stop 和 step 均为可哈希对象)。

s = "hello world"  
  
# 创建一个切片对象  
my_slice = slice(2, 7)  
  
# 使用切片对象对字符串进行切片  
print(s[my_slice])  # 输出: 'llo w'  
  
# 也可以查看切片对象的属性  
print(my_slice.start)  # 输出: 2  
print(my_slice.stop)  # 输出: 7  
print(my_slice.step)  # 输出: None，因为没有指定步长  
  
# 切片对象也可以带有步长  
my_slice_with_step = slice(0, None, 2)  
print(s[my_slice_with_step])  # 输出: 'hlowrd'，因为步长为2

sorted(iterable, /, *, key=None, reverse=False)

根据 iterable 中的项返回一个新的已排序列表。

• iterable：要进行排序的可迭代对象。
• key：一个函数，用于从每个元素中提取一个比较键。默认值为 None，意味着直接使用元素的值进行比较。
• reverse：一个布尔值，如果为 True 则降序排序，如果为 False 则升序排序。默认值为 False。

具有两个可选参数，它们都必须指定为关键字参数。

key 指定带有单个参数的函数，用于从 iterable 的每个元素中提取用于比较的键 (例如 key=str.lower)。 默认值为 None (直接比较元素)。

reverse 为一个布尔值。 如果设为 True，则每个列表元素将按反向顺序比较进行排序。

使用 functools.cmp_to_key() 可将老式的 cmp 函数转换为 key 函数。

内置的 sorted() 确保是稳定的。 如果一个排序确保不会改变比较结果相等的元素的相对顺序就称其为稳定的 — 这有利于进行多重排序（例如先按部门、再按薪级排序）。

排序算法只使用 < 在项目之间比较。 虽然定义一个 __lt__() 方法就足以进行排序，但 PEP 8 建议实现所有六个 富比较 。 这将有助于避免在与其他排序工具（如 max() ）使用相同的数据时出现错误，这些工具依赖于不同的底层方法。实现所有六个比较也有助于避免混合类型比较的混乱，因为混合类型比较可以调用反射到 __gt__() 的方法。

有关排序示例和简要排序教程，请参阅 排序的技巧 。

# 对列表进行升序排序  
numbers = [5, 1, 9, 3, 7]
sorted_numbers = sorted(numbers)
print(sorted_numbers)  # 输出: [1, 3, 5, 7, 9]  

# 对列表进行降序排序  
sorted_numbers_desc = sorted(numbers, reverse=True)
print(sorted_numbers_desc)  # 输出: [9, 7, 5, 3, 1]  

# 使用 key 函数对元组列表进行排序（按照元组的第二个元素排序）  
tuples = [(1, 3), (4, 1), (2, 2)]
sorted_tuples = sorted(tuples, key=lambda x: x[1])
print(sorted_tuples)  # 输出: [(4, 1), (2, 2), (1, 3)]  

# 对字符串列表按照字符串长度排序  
strings = ['apple', 'banana', 'cherry', 'date']
sorted_strings = sorted(strings, key=len)
print(sorted_strings)  # 输出: ['date', 'apple', 'cherry', 'banana']

sorted() 函数返回的是一个新的列表，而原始的可迭代对象不会被修改。如果你希望原地（即不创建新列表）对列表进行排序，可以使用列表的 sort() 方法。

@staticmethod

将方法转换为静态方法。

@staticmethod是一个装饰器，用于指示一个方法是静态方法。静态方法属于类，而不是类的实例。这意味着静态方法不接收特殊的第一个参数（如self或cls），它们就像普通的函数一样，只是被绑定到了类上。

静态方法不会接收隐式的第一个参数。要声明一个静态方法，请使用此语法

class C:
    @staticmethod
    def f(arg1, arg2, argN): ...

@staticmethod 这样的形式称为函数的 decorator – 详情参阅 函数定义。

静态方法既可以由类中调用（如 C.f()），也可以由实例中调用（如 C().f()）。此外，还可以作为普通的函数进行调用（如 f()）。

Python 的静态方法与 Java 或 C++ 类似。另请参阅 classmethod() ，可用于创建另一种类构造函数。

像所有装饰器一样，也可以像常规函数一样调用 staticmethod ，并对其结果执行某些操作。比如某些情况下需要从类主体引用函数并且您希望避免自动转换为实例方法。对于这些情况，请使用此语法:

def regular_function():
    ...

class C:
    method = staticmethod(regular_function)

想了解更多有关静态方法的信息，请参阅 标准类型层级结构 。

在 3.10 版本发生变更: 静态方法继承了方法的多个属性（ __module__、 __name__、 __qualname__、 __doc__ 和 __annotations__），还拥有一个新的 __wrapped__ 属性，并且现在还可以作为普通函数进行调用。

class MyClass:
    class_variable = 42

    @staticmethod
    def static_method():
        return "This is a static method."

    @classmethod
    def class_method(cls):
        return f"This is a class method. Class variable is {cls.class_variable}."

    def instance_method(self):
        return "This is an instance method."

# 使用静态方法
result_static = MyClass.static_method()
print(result_static)  # 输出: This is a static method.  

# 注意：静态方法不需要通过类实例来调用，但也可以通过实例调用  
instance = MyClass()
result_static_via_instance = instance.static_method()
print(result_static_via_instance)  # 输出: This is a static method.  

# 使用类方法  
result_class = MyClass.class_method()
print(result_class)  # 输出: This is a class method. Class variable is 42.  

# 使用实例方法  
result_instance = instance.instance_method()
print(result_instance)  # 输出: This is an instance method.

静态方法常用于那些逻辑上属于类，但不需要访问或修改类状态（即类的属性或方法）的方法。它们可以作为工具函数或用于执行与类相关的某些操作，但这些操作不需要类的实例状态。

尽管静态方法可以通过类的实例来调用，但这并不是推荐的做法，因为这可能会使代码阅读者感到困惑。通常，静态方法应该通过类名直接调用。

str(object=‘’)

class str(object=‘’)

class str(object=b’', encoding=‘utf-8’, errors=‘strict’)

返回一个 str 版本的 object 。有关详细信息，请参阅 str() 。

bytes 类型用于表示字节序列，而 str 类型用于表示Unicode字符串。如果你有一个 bytes 对象，并且想要将它转换为一个字符串，你需要使用 bytes 对象的 decode() 方法，而不是 str() 函数。

• encoding 指定了字符编码，如 'utf-8'，'ascii' 等。
• errors 指定了当解码过程中遇到无法识别的字节时应该采取的策略，如 'strict'（遇到无法识别的字节时抛出异常），'ignore'（忽略无法识别的字节），'replace'（用问号 ? 替换无法识别的字节）等。

str 是内置字符串 class 。更多关于字符串的信息查看 文本序列类型 — str。

# 转换整数为字符串  
num = 123
str_num = str(num)
print(str_num)  # 输出: '123'  
print(type(str_num))  # 输出: <class 'str'>  

# 转换浮点数为字符串  
float_num = 3.14159
str_float_num = str(float_num)
print(str_float_num)  # 输出: '3.14159'  

# 转换列表为字符串（注意：这会输出列表的字符串表示，而不是列表元素的拼接）  
list_items = [1, 2, 3]
str_list = str(list_items)
print(str_list)  # 输出: '[1, 2, 3]'  

# 转换字典为字符串（同样，这会输出字典的字符串表示）  
dict_items = {'a': 1, 'b': 2}
str_dict = str(dict_items)
print(str_dict)  # 输出: "{'a': 1, 'b': 2}"  

# 转换布尔值为字符串  
bool_val = True
str_bool = str(bool_val)
print(str_bool)  # 输出: 'True'  

# 转换None为字符串  
none_val = None
str_none = str(none_val)
print(str_none)  # 输出: 'None'

# 字节型转换为字符串
b = b'3.14159'
str_bytes = str(b, encoding='utf-8', errors='strict')
print(str_bytes)  # 输出: '3.14159'

# 假设我们有一个bytes对象
bytes_obj = b'Hello, World!'
# 使用decode方法将其转换为字符串
str_obj = bytes_obj.decode('utf-8')
print(str_obj)  # 输出: Hello, World!
print(type(str_obj))  # 输出: <class 'str'>

对于列表和字典，str() 函数返回的是它们的字符串表示，而不是它们的元素连接成一个字符串。如果你想要将列表或字典的元素连接成一个字符串，你需要使用其他方法，比如列表推导式、join() 方法等。

str() 函数并不会改变原始变量的类型，而是返回一个新的字符串类型的对象。如果你想要改变原始变量的类型，你需要将str()函数的返回值赋给原始变量，或者赋给一个新的变量。

sum(iterable, /, start=0)

从 start 开始自左向右对 iterable 的项求和并返回总计值。 iterable 的项通常为数字，而 start 值则不允许为字符串。

对某些用例来说，存在 sum() 的更好替代。 拼接字符串序列的更好更快方式是调用 ''.join(sequence)。 要以扩展精度对浮点值求和，请参阅 math.fsum()。 要拼接一系列可迭代对象，请考虑使用 itertools.chain()。

在 3.8 版本发生变更: start 形参可用关键字参数形式来指定。

在 3.12 版本发生变更: 浮点数的加总已切换为一种可在大多数构建版本上给出更高精度的算法。

# 计算数字列表的总和
numbers = [1, 2, 3, 4, 5]
total = sum(numbers)
print(total)  # 输出: 15

# 计算元组中数字的总和
tuple_numbers = (6, 7, 8, 9, 10)
total_tuple = sum(tuple_numbers)
print(total_tuple)  # 输出: 40

# 计算字符串中字符的Unicode码点之和（通常不是很有用，但演示了sum()的通用性）
string_chars = 'hello'
char_sum = sum(ord(c) for c in string_chars)
print(char_sum)  # 输出: 532（每个字符的Unicode码点之和）

# 计算空列表的总和，结果为0
empty_list = []
empty_sum = sum(empty_list)
print(empty_sum)  # 输出: 0

# 计算一个列表中所有元素的平方和
numbers = [1, 2, 3, 4, 5]
squared_sum = sum(n**2 for n in numbers)
print(squared_sum)  # 输出: 55 (1^2 + 2^2 + 3^2 + 4^2 + 5^2)

# start初始值
print(sum([1,2,3], 1)) # 输出：7

如果可迭代对象为空（例如空列表或空元组），sum() 函数将返回0，因为没有任何数字可以相加。

super

class super

class super(type, object_or_type=None)

super()函数返回一个临时对象，该对象绑定到父类，并允许你调用父类的方法。

返回一个代理对象，它会将方法调用委托给 type 的父类或兄弟类。 这对于访问已在类中被重写的继承方法很有用。

object_or_type 确定要用于搜索的 method resolution order（方法解析顺序）。 搜索会从 type 之后的类开始。

举例来说，如果 object_or_type 的 __mro__ 为 D -> B -> C -> A -> object 并且 type 的值为 B，则 super() 将会搜索 C -> A -> object。

object_or_type 的 __mro__ 属性列出了 getattr() 和 super() 所共同使用的方法解析搜索顺序。 该属性是动态的并可在任何继承层级结构发生更新时被改变。

如果省略第二个参数，则返回的超类对象是未绑定的。 如果第二个参数为一个对象，则 isinstance(obj, type) 必须为真值。 如果第二个参数为一个类型，则 issubclass(type2, type) 必须为真值（这适用于类方法）。

super 有两个典型用例。 在具有单继承的类层级结构中，super 可用来引用父类而不必显式地指定它们的名称，从而令代码更易维护。 这种用法与其他编程语言中 super 的用法非常相似。

第二个用例是在动态执行环境中支持协作多重继承。 此用例为 Python 所独有而不存在于静态编码语言或仅支持单继承的语言当中。 这使用实现“菱形图”成为可能，即有多个基类实现相同的方法。 好的设计强制要求这样的方法在每个情况下都具有相同的调用签名（因为调用顺序是在运行时确定的，也因为这个顺序要适应类层级结构的更改，还因为这个顺序可能包括在运行时之前未知的兄弟类）。

对于以上两个用例，典型的超类调用看起来是这样的:

class C(B):
    def method(self, arg):
        super().method(arg)    # This does the same thing as:
                               # super(C, self).method(arg)

除了方法查找之外，super() 也可用于属性查找。 一个可能的应用场合是在上级或同级类中调用 描述器。

请注意 super() 被实现为为显式的带点号属性查找的绑定过程的组成部分，例如 super().__getitem__(name)。 它做到这一点是通过实现自己的 __getattribute__() 方法以便能够按支持协作多重继承的可预测的顺序来搜索类。 相应地，super() 在像 super()[name] 这样使用语句或运算符进行隐式查找时则是未定义的。

还要注意的是，除了零个参数的形式以外，super() 并不限于在方法内部使用。 两个参数的形式明确指定参数并进行相应的引用。 零个参数的形式仅适用于类定义内部，因为编译器需要填入必要的细节以正确地检索到被定义的类，还需要让普通方法访问当前实例。

对于有关如何使用 super() 来如何设计协作类的实用建议，请参阅 使用 super() 的指南。

class Parent:
    def __init__(self):
        print("Parent's constructor called")

    def my_method(self):
        print("Parent's method called")


class Child(Parent):
    def __init__(self):
        super().__init__()  # 调用父类的构造函数  
        print("Child's constructor called")

    def my_method(self):
        super().my_method()  # 调用父类的my_method方法  
        print("Child's method called")

# 创建Child类的实例并调用my_method方法
c = Child()
c.my_method()
'''输出：
Parent's constructor called  
Child's constructor called  
Parent's method called  
Child's method called'''

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