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)) # True
int
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) # 26
bool
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])) # 非空列表为 True
bytes
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.9154759474226504
float
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')) # inf
str
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) # 20
classmethod
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) # 2
staticmethod
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)) # 7
super
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 B
slice
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 内建函数,提升编程效率