一文搞定Python内建类型

魔术师JeffreyChu

于 2024-06-21 07:16:30 发布

阅读量614

点赞数 22

分类专栏： python 文章标签： python 开发语言

本文链接：https://blog.csdn.net/u010098702/article/details/139846682

版权

python 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

Python 内建函数（类型）是语言核心功能的一部分，提供了高效的数据处理和简化编程的工具集。它们涵盖了数据类型转换、集合操作、迭代器、函数式编程支持，以及面向对象编程辅助。

本篇主要是介绍内建函数中的内建类型。

内建类型概念

Python 内建函数中的内建类型（built-in types）是指 Python 语言中原生支持的数据类型，像int、list、str这种内建函数实际上都是类class，不同于普通内建函数abs、input。但由于用法比较像函数所以也被称为内建函数，其实称为内建类型更为确切些。

可以通过IDE(如VScode、PyCharm等)跳到builtins.py文件中int定义的地方看到是一种类(类型)
内建函数int
或者通过type函数的结果发现int是一种类。如果是一个函数，那么type(int)返回的应该是function。

int的本质

这些类型涵盖了常见的数据表示方法，包括数值、序列、集合、映射、文本等。每种内建类型都具有特定的行为、属性和方法，使得数据操作变得简单和直观。

常见用法

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 函数用于将一个值转换为布尔值，其继承了int。除了 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')