Python 内建函数是语言核心功能的一部分，提供了高效的数据处理和简化编程的工具集。它们涵盖了数据类型转换、集合操作、迭代器、函数式编程支持，以及面向对象编程辅助。
本篇主要是介绍内建函数中的内建类型。
内建类型概念
Python 内建函数中的内建类型（built-in types）是指 Python 语言中原生支持的数据类型，像int、list、str这种内建函数实际上都是类class，不同于普通内建函数abs、input。但由于用法比较像函数所以也被称为内建函数，所以称为内建类型更为确切些。
可以通过IDE(如VScode、PyCharm等)跳到int定义的地方看到，它确实是一种类(类型)
或者通过type函数的结果发现，int是一种类，如果是一个函数那么type(int)返回的应该是function。
这些类型涵盖了常见的数据表示方法，包括数值、序列、集合、映射、文本等。每种内建类型都具有特定的行为、属性和方法，使得数据操作变得简单和直观。
常见用法
object
object 函数返回一个新的空对象。它是所有新风格类的基类。
obj = object()
print(type(obj)) # <class 'object'>进阶使用：
class MyClass(object):
pass
instance = MyClass()
print(isinstance(instance, object)) # Trueint
int 函数用于将一个数或字符串转换为整数。它可以指定进制来进行转换。
number = int("42")
print(number) # 42
number = int(3.14)
print(number) # 3进阶使用：
binary_number = int("1010", 2) # 二进制转十进制
print(binary_number) # 10
hex_number = int("1A", 16) # 十六进制转十进制
print(hex_number) # 26bool
bool 函数用于将一个值转换为布尔值。除了 None、0、""、[]、()、{} 等被认为是 False 之外，其他所有值均为 True。
flag = bool(1)
print(flag) # True
flag = bool(0)
print(flag) # False进阶使用：
print(bool([])) # 空列表为 False
print(bool([1, 2, 3])) # 非空列表为 Truebytes
bytes 函数用于创建一个不可变的字节序列。可以从整数序列、字符串（需要指定编码）或缓冲区对象创建。
byte_data = bytes("hello", encoding='utf-8')
print(byte_data) # b'hello'
byte_data = bytes([104, 101, 108, 108, 111])
print(byte_data) # b'hello'进阶使用：
byte_data = bytes(5) # 长度为5的空字节序列
print(byte_data) # b'\x00\x00\x00\x00\x00'
byte_data = bytes(b'\x01\x02\x03')
print(list(byte_data)) # [1, 2, 3]bytearray
bytearray 函数用于创建一个可变的字节序列。与 bytes 类似，但它是可变的。
byte_array = bytearray("hello", encoding='utf-8')
print(byte_array) # bytearray(b'hello')
byte_array = bytearray([104, 101, 108, 108, 111])
print(byte_array) # bytearray(b'hello')进阶使用：
byte_array = bytearray(5) # 长度为5的空字节序列
byte_array[0] = 65
print(byte_array) # bytearray(b'A\x00\x00\x00\x00')
byte_array.extend(b' world')
print(byte_array) # bytearray(b'A\x00\x00\x00\x00 world')complex
complex 函数用于创建复数。可以从两个数字创建复数，或者从字符串表示形式创建复数。
complex_number = complex(1, 2)
print(complex_number) # (1+2j)
complex_number = complex("1+2j")
print(complex_number) # (1+2j)进阶使用：
real = 1.5
imaginary = 2.5
complex_number = complex(real, imaginary)
print(complex_number) # (1.5+2.5j)
magnitude = abs(complex_number)
print(magnitude) # 2.9154759474226504float
float 函数用于将一个数或字符串转换为浮点数。可以处理科学计数法。
floating_number = float("3.14")
print(floating_number) # 3.14
floating_number = float(42)
print(floating_number) # 42.0进阶使用：
scientific = float("1e-3")
print(scientific) # 0.001
not_a_number = float('nan')
print(not_a_number) # nan
print(float('inf')) # infstr
str 函数用于将对象转换为字符串。可以指定编码格式。
text = str(42)
print(text) # '42'
text = str(3.14)
print(text) # '3.14'进阶使用：
byte_data = b"hello"
text = str(byte_data, encoding='utf-8')
print(text) # 'hello'
number = 1234
formatted = str(number).zfill(6)
print(formatted) # '001234'list
list 函数用于创建列表，可以从可迭代对象创建。
numbers = list(range(5))
print(numbers) # [0, 1, 2, 3, 4]
characters = list("hello")
print(characters) # ['h', 'e', 'l', 'l', 'o']进阶使用：
tuple_data = (1, 2, 3)
list_from_tuple = list(tuple_data)
print(list_from_tuple) # [1, 2, 3]
filtered_numbers = list(filter(lambda x: x % 2 == 0, range(10)))
print(filtered_numbers) # [0, 2, 4, 6, 8]dict
dict 函数用于创建字典，可以从键值对序列或关键字参数创建。
student = dict(name="Alice", age=21)
print(student) # {'name': 'Alice', 'age': 21}
pairs = [('name', 'Bob'), ('age', 22)]
student = dict(pairs)
print(student) # {'name': 'Bob', 'age': 22}进阶使用：
keys = ["name", "age"]
values = ["Charlie", 23]
student = dict(zip(keys, values))
print(student) # {'name': 'Charlie', 'age': 23}
default_student = dict.fromkeys(['name', 'age'], 'Unknown')
print(default_student) # {'name': 'Unknown', 'age': 'Unknown'}set
set 函数用于创建集合，可以从可迭代对象创建。
unique_numbers = set([1, 2, 2, 3, 4])
print(unique_numbers) # {1, 2, 3, 4}
characters = set("hello")
print(characters) # {'h', 'e', 'l', 'o'}进阶使用：
set1 = set([1, 2, 3])
set2 = set([3, 4, 5])
union_set = set1 | set2
print(union_set) # {1, 2, 3, 4, 5}
intersection_set = set1 & set2
print(intersection_set) # {3}frozenset
frozenset 函数用于创建不可变集合，可以从可迭代对象创建。
frozen = frozenset([1, 2, 2, 3, 4])
print(frozen) # frozenset({1, 2, 3, 4})
characters = frozenset("hello")
print(characters) # frozenset({'h', 'e', 'l', 'o'})进阶使用：
set1 = frozenset([1, 2, 3])
set2 = frozenset([3, 4, 5])
union_frozen = set1 | set2
print(union_frozen) # frozenset({1, 2, 3, 4, 5})
intersection_frozen = set1 & set2
print(intersection_frozen) # frozenset({3})tuple
tuple 函数用于创建元组，可以从可迭代对象创建。
numbers = tuple([1, 2, 3])
print(numbers) # (1, 2, 3)
characters = tuple("hello")
print(characters) # ('h', 'e', 'l', 'l', 'o')进阶使用：
list_data = [1, 2, 3]
tuple_from_list = tuple(list_data)
print(tuple_from_list) # (1, 2, 3)
single_element = tuple([42])
print(single_element) # (42,)filter
filter 函数用于过滤序列，返回一个过滤后的迭代器。
numbers = [1, 2, 3, 4, 5, 6]
even_numbers = filter(lambda x: x % 2 == 0, numbers)
print(list(even_numbers)) # [2, 4, 6]进阶使用：
def is_positive(n):
return n > 0
positive_numbers = filter(is_positive, [-2, -1, 0, 1, 2])
print(list(positive_numbers)) # [1, 2]map
map 函数用于对序列中的每个元素应用指定的函数，返回一个迭代器。
numbers = [1, 2, 3, 4, 5]
squared_numbers = map(lambda x: x ** 2, numbers)
print(list(squared_numbers)) # [1, 4, 9, 16, 25]进阶使用：
def double(n):
return n * 2
doubled_numbers = map(double, [1, 2, 3, 4])
print(list(doubled_numbers)) # [2, 4, 6, 8]property
property 函数用于创建属性访问器，通常用于封装对象的私有属性。
class Person:
def __init__(self, name):
self._name = name
@property
def name(self):
return self._name
@name.setter
def name(self, value):
self._name = value
person = Person("Alice")
print(person.name) # Alice
person.name = "Bob"
print(person.name) # Bob进阶使用：
class Rectangle:
def __init__(self, width, height):
self._width = width
self._height = height
@property
def area(self):
return self._width * self._height
rect = Rectangle(4, 5)
print(rect.area) # 20classmethod
classmethod 函数用于将方法定义为类方法，可以访问类本身而不是实例。
class MyClass:
counter = 0
@classmethod
def increment_counter(cls):
cls.counter += 1
MyClass.increment_counter()
print(MyClass.counter) # 1进阶使用：
class Person:
population = 0
def __init__(self, name):
self.name = name
Person.increase_population()
@classmethod
def increase_population(cls):
cls.population += 1
print(Person.population) # 0
p1 = Person("Alice")
p2 = Person("Bob")
print(Person.population) # 2staticmethod
staticmethod 函数用于将方法定义为静态方法，无法访问类或实例。
class MyClass:
@staticmethod
def greet(name):
return f"Hello, {name}!"
print(MyClass.greet("Alice")) # Hello, Alice!进阶使用：
class Math:
@staticmethod
def add(a, b):
return a + b
print(Math.add(3, 4)) # 7super
super 函数用于调用父类的方法，可以支持多继承。
class Animal:
def sound(self):
return "Some sound"
class Dog(Animal):
def sound(self):
return super().sound() + " (Dog)"
dog = Dog()
print(dog.sound()) # Some sound (Dog)进阶使用：
class A:
def __init__(self):
print("A")
class B(A):
def __init__(self):
super().__init__()
print("B")
b = B() # A Bslice
slice 函数用于创建一个切片对象，可以用在序列的切片操作中。
s = "hello"
slice_obj = slice(1, 3)
print(s[slice_obj]) # 'el'进阶使用：
numbers = [0, 1, 2, 3, 4]
slice_obj = slice(1, 4, 2)
print(numbers[slice_obj]) # [1, 3]zip
zip 函数用于将多个可迭代对象打包成一个迭代器，按元素并行处理。
names = ["Alice", "Bob", "Charlie"]
ages = [24, 30, 22]
combined = zip(names, ages)
print(list(combined)) # [('Alice', 24), ('Bob', 30), ('Charlie', 22)]进阶使用：
keys = ["name", "age"]
values = ["Alice", 24]
combined = dict(zip(keys, values))
print(combined) # {'name': 'Alice', 'age': 24}reversed
reversed 函数用于返回序列的反向迭代器。
numbers = [1, 2, 3, 4, 5]
rev_numbers = reversed(numbers)
print(list(rev_numbers)) # [5, 4, 3, 2, 1]进阶使用：
text = "hello"
rev_text = reversed(text)
print(''.join(rev_text)) # 'olleh'range
range 函数用于生成数字序列，常用于循环中。
for i in range(5):
print(i) # 0 1 2 3 4进阶使用：
numbers = list(range(1, 10, 2))
print(numbers) # [1, 3, 5, 7, 9]
reverse_range = list(range(10, 0, -2))
print(reverse_range) # [10, 8, 6, 4, 2]memoryview
memoryview 函数用于创建一个视图对象，可以直接访问原始数据的内存。
byte_array = bytearray(b'hello')
view = memoryview(byte_array)
print(view[0]) # 104
view[0] = 72
print(byte_array) # bytearray(b'Hello')进阶使用：
buffer = memoryview(b'abcdefgh')
print(buffer[1:4].tobytes()) # b'bcd'
numbers = bytearray([1, 2, 3, 4, 5])
view = memoryview(numbers)
view[1:3] = b'\x00\x01'
print(numbers) # bytearray(b'\x01\x00\x01\x04\x05')总结
本文详细介绍了 Python 内建函数的多种用法及其实际代码示例。内建函数是 Python 强大的语言特性之一，它们不仅提供了基本的数据操作能力，还能简化日常编程任务，使代码更加简洁、高效。掌握这些函数的用法，能有效提升编程技巧和代码质量。
希望这些示例能帮助你更好地理解和使用 Python 内建函数，提升编程效率