Python入门Day5

函数

函数的规则

在Python中，函数的参数是函数与外部沟通的桥梁，它可以接受外部传递来的值。

参数的传递规则如下：

--参数的传递是通过把对象赋值给局部的名字。

赋值在Python中就意味着引用，函数中的参数与调用者共同引用同一个对象。

--==在函数内部给参数赋值不会影响调用者。==这是因为在大多数编程语言中，函数参数传递采用的是值传递（pass by value）机制。当调用函数时，实参的值会被复制一份传递给形参，形参和实参实际上是两个独立的变量。

例如，在Python中：

def modify_param(x):
    x = 2  # 只在函数内部修改
    print("函数内x的值:", x)

num = 1
modify_param(num)
print("函数外num的值:", num)

输出结果会是：

函数内x的值: 2
函数外num的值: 1

在Python中，函数不仅仅是代码的封装单元，它们实际上是第一类对象(first-class objects)。这意味着函数可以像其他对象一样被赋值给变量、存储在数据结构中、作为参数传递给其他函数，甚至作为其他函数的返回值。

以下是函数作为对象的具体表现：

1. 赋值给变量
   我们可以直接将函数赋值给变量，然后通过变量名调用：

def greet(name):
    return f"Hello, {name}!"

say_hello = greet  # 将函数对象赋值给变量
print(say_hello("Alice"))  # 输出: Hello, Alice!

2. 存储在数据结构中
   函数可以像其他对象一样存储在列表、字典等数据结构中：

def add(a, b): return a + b
def subtract(a, b): return a - b

operations = [add, subtract]
print(operations[0](5, 3))  # 输出: 8

3. 作为参数传递
   函数可以作为参数传递给其他函数，这是高阶函数的基础：

def apply(func, x, y):
    return func(x, y)

print(apply(add, 10, 5))  # 输出: 15

4. 作为返回值
   函数可以返回其他函数，实现函数工厂模式：

def make_power(n):
    def power(x):
        return x ** n
    return power

square = make_power(2)
print(square(5))  # 输出: 25

5. 拥有属性和方法
   函数对象可以拥有自己的属性：

def func():
    pass

func.description = "This is a function"
print(func.description)  # 输出: This is a function

6. 可以被检查
   可以使用dir()函数查看函数的所有属性和方法：

print(dir(greet))  # 输出函数的所有属性和方法

这种设计使得Python支持函数式编程范式，实现了装饰器、回调函数等高级特性。函数作为对象的特性是Python灵活性和强大表现力的重要基础。

函数参数匹配的模式

函数参数匹配是编程中一个重要的概念，它决定了函数如何接收和处理传入的参数。以下是几种常见的参数匹配模式：

1. 位置参数 (Positional Arguments)

这是最基本的参数传递方式，参数按照函数定义时的顺序依次匹配。

示例：

def greet(name, greeting):
    print(f"{greeting}, {name}!")

greet("Alice", "Hello")  # 输出: Hello, Alice!

特点：

• 参数必须按照定义的顺序传递
• 参数数量必须与定义一致
• 简单直观，适用于参数较少的情况

2. 关键字参数 (Keyword Arguments)

通过参数名指定值，可以不按顺序传递参数。

示例：

def greet(name, greeting):
    print(f"{greeting}, {name}!")

greet(greeting="Hi", name="Bob")  # 输出: Hi, Bob!

特点：

• 提高了代码的可读性
• 允许跳过某些参数（如果有默认值）
• 特别适用于参数较多的情况

3. 默认参数 (Default Arguments)

为参数指定默认值，调用时可不传递这些参数。

示例：

def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")

greet("Charlie")  # 输出: Hello, Charlie!
greet("David", "Good morning")  # 输出: Good morning, David!

特点：

• 使函数调用更加灵活
• 默认参数必须定义在非默认参数之后
• 可以避免重复传递相同的参数值

4. 可变位置参数 (*args)

接收任意数量的位置参数，打包为元组。

示例：

def sum_numbers(*numbers):
    return sum(numbers)

print(sum_numbers(1, 2, 3))  # 输出: 6
print(sum_numbers(1, 2, 3, 4, 5))  # 输出: 15

特点：

• 参数名前加星号(*)
  -可以接收0到多个参数
• 常用于需要处理不确定数量参数的函数

5. 可变关键字参数 (**kwargs)

接收任意数量的关键字参数，打包为字典。这里并不是传入的参数为字典，而是通过xxx="yyy"的形式传入参数，然后会被打包成字典。

示例：

def print_info(**info):
    for key, value in info.items():
        print(f"{key}: {value}")

print_info(name="Eve", age=25, city="New York")
# 输出:
# name: Eve
# age: 25
# city: New York

特点：

• 参数名前加双星号(**)
• 可以接收0到多个关键字参数
• 常用于配置选项或需要灵活扩展参数的情况

6. 参数解包

将序列或字典解包后作为参数传递。

示例：

def greet(name, greeting):
    print(f"{greeting}, {name}!")

params = ["Frank", "Good evening"]
greet(*params)  # 输出: Good evening, Frank!

kwargs = {"name": "Grace", "greeting": "Hi"}
greet(**kwargs)  # 输出: Hi, Grace!

特点：

• 使用星号(*)解包序列为位置参数
• 使用双星号(**)解包字典为关键字参数
• 方便将已有数据结构直接作为参数传递

7. 组合使用模式

这些参数模式可以组合使用，但必须遵循一定的顺序规则：

Python中的参数顺序规则：

1. 位置参数
2. 关键字参数
3. *args
4. 仅限关键字参数
5. **kwargs

示例：

def complex_function(a, b=2, *args, c=3, **kwargs):
    print(f"a: {a}, b: {b}, args: {args}, c: {c}, kwargs: {kwargs}")

complex_function(1, 4, 5, 6, c=7, d=8, e=9)
# 输出: a: 1, b: 4, args: (5, 6), c: 7, kwargs: {'d': 8, 'e': 9}

正确理解和使用这些参数匹配模式，可以使函数设计更加灵活和强大，同时提高代码的可读性和可维护性。

模块

定义

Python的模块提供了一种逻辑的方式来组织我们的代码，模块的物理形式就是文件。一个文件对应一个模块，反之亦然。

模块化编程是Python的重要特性之一，它允许我们==将相关的代码组织在一起，形成一个独立的单元。==每个模块都是一个独立的命名空间，可以包含变量、函数、类等Python对象。通过将代码分割到不同的模块中，我们可以实现：

1. 代码复用：常用的功能可以封装在模块中，在多个项目中重复使用
2. 命名空间管理：避免命名冲突，保持代码整洁
3. 可维护性：将大型项目分解为更小的、可管理的部分
4. 安全性：通过限制导入内容来控制访问权限

==模块的物理实现方式就是.py文件。==例如：

• math.py 是Python标准库中的数学模块
• random.py 是随机数相关功能的模块
• os.py 提供操作系统接口

创建模块的基本步骤：

1. 创建一个.py文件
2. 在文件中编写Python代码（函数、类、变量等）
3. 保存文件时确保文件名符合Python命名规范（只包含字母、数字和下划线，且不以数字开头）

假设我们创建一个名为calculator.py的模块：

# calculator.py
def add(x, y):
    return x + y

def subtract(x, y):
    return x - y

在其他Python文件中，可以通过import语句使用这个模块：

import calculator
result = calculator.add(5, 3)

Python还支持从模块中导入特定功能：

from calculator import add
result = add(5, 3)

模块搜索路径：

当导入模块时，Python会在以下位置查找：

1. 当前目录
2. PYTHONPATH环境变量指定的目录
3. Python安装目录的标准库路径
4. 任何.pth文件指定的路径

通过合理使用模块，我们可以构建出结构清晰、易于维护的大型Python项目。

导入顺序

导入模块顺序的理解

在Python中，按照特定顺序组织import语句有助于提高代码的可读性和可维护性。推荐顺序为：Python标准库 → 第三方库 → 应用程序自定义库。

---

Python标准库优先

Python标准库是Python内置的模块（如os、sys、datetime）。这些模块经过严格测试且与Python版本绑定，优先导入可避免因后续导入的第三方库或自定义库中可能存在的同名模块冲突。

import os
import sys
from datetime import datetime

---

第三方库次之

第三方库是通过pip等工具安装的外部依赖（如numpy、requests）。它们通常依赖于标准库，放在标准库之后导入逻辑更清晰。

import numpy as np
import requests
from flask import Flask

---

应用程序自定义库最后

自定义库是项目内部的模块（如utils.py、config.py）。放在最后可以明确区分外部依赖和内部实现，便于调试时定位问题。

from .utils import helper_function
from config import API_KEY

---

其他注意事项

• 分组与空行：不同组别的导入之间用空行分隔，进一步提升可读性。
• 绝对导入优先 ：尽量使用绝对路径（如from package import module），避免相对路径（如from ..module import function）。
• 避免通配符导入 ：不建议使用from module import *，可能引发命名冲突。

这种分层导入方式不仅符合PEP 8规范，还能帮助开发者快速理解代码的依赖结构。

包的层次结构

Python包的层次结构

Python包是一种组织模块的方式，通过目录和__init__.py文件实现层次化结构。典型的包结构如下：

my_package/
    __init__.py
    module1.py
    subpackage/
        __init__.py
        module2.py

• __init__.py：标识目录为Python包（可以是空文件，或包含初始化代码）。
• 模块 ：.py文件，包含函数、类等代码。
• 子包 ：包内嵌套的包，同样需包含__init__.py。

导入方式

直接导入模块

import my_package.module1
my_package.module1.some_function()

从模块导入具体内容

from my_package.module1 import some_function
some_function()

导入子包模块

from my_package.subpackage import module2
module2.another_function()

使用别名简化

import my_package.subpackage.module2 as m2
m2.another_function()

相对导入（在包内部使用）

在module1.py中导入同级的module2：

from .subpackage import module2

动态导入

通过importlib动态加载模块：

import importlib
module = importlib.import_module("my_package.module1")
module.some_function()

__all__控制导入范围

在__init__.py中定义__all__，限制from package import *时导入的模块：

__all__ = ["module1", "subpackage"]

注意事项

• 避免循环导入。
• 使用绝对导入（推荐）或相对导入（仅限包内部）。
• Python 3.3+允许无__init__.py的命名空间包，但显式定义更清晰。

init.py 文件

init.py 文件的作用

__init__.py 文件==是 Python 包结构的核心文件，用来标识一个目录为 Python 包。==它可以为空，也可以包含初始化代码或定义包的公共接口。

空文件示例

最简单的 __init__.py 文件可以是一个空文件，仅用于标记目录为 Python 包：

# 空文件，仅用于标记目录为包

初始化代码示例

可以在 __init__.py 文件中执行包的初始化操作，例如导入必要的模块或设置包级变量：

# 包级变量
PACKAGE_NAME = "my_package"

# 导入包内的模块
from . import module1
from . import module2

定义包公共接口

通过 __init__.py 文件可以定义包的公共接口，方便用户直接使用包的功能：

# 从模块中导入特定函数或类
from .module1 import function1
from .module2 import Class2

# 定义包的 __all__ 变量，控制 from package import * 的行为
__all__ = ['function1', 'Class2']

复杂初始化示例

对于更复杂的包，可以在 __init__.py 中执行配置加载、子包导入等操作：

import os
import sys

# 添加包路径到系统路径
sys.path.append(os.path.dirname(__file__))

# 动态导入子包
from .subpackage1 import *
from .subpackage2 import *

# 配置加载
def load_config():
    pass

load_config()

注意事项

• 在 Python 3.3 及以上版本中，__init__.py 文件不再是必需的（称为"命名空间包"），但为了兼容性和明确性，建议保留。
• 避免在 __init__.py 中执行耗时操作，因为这会增加包的导入时间。
• 合理使用 __all__ 可以控制包的公开接口。

作用域

Python使用名称空间的概念存储对象，这个名称空间就是对象作用域，不同对象存在于不同的作用域。Python的名称空间本质上是一个字典结构，用于保存变量名与对象之间的映射关系。下面是不同对象的作用域规则：

1. 内置作用域(Built-in)

   • 包含Python内置的函数和异常名称
   • 如print()、len()等内置函数
   • 在整个Python解释器运行期间都有效
   • 是最高层级的作用域

2. 全局作用域(Global)

   • 在模块级别定义的变量

   • 如模块中的函数定义、类定义和直接赋值的变量

   • 可通过globals()函数查看

   • 示例：

     global_var = "module level"
     
     def func():
         print(global_var)  # 可以访问

3. 局部作用域(Local)

   • 在函数或方法内部定义的变量

   • 只在函数执行期间存在

   • 可通过locals()函数查看

   • 示例：

     def func():
         local_var = "inside function"
         print(local_var)
     
     func()
     print(local_var)  # 会报错，无法访问

4. 嵌套作用域(Enclosing)

   • 存在于嵌套函数结构中

   • 内层函数可以访问外层函数的变量

   • 示例：

     def outer():
         outer_var = "outer"
         
         def inner():
             print(outer_var)  # 可以访问
         
         inner()

5. 类作用域(Class)

   • 类定义中定义的变量

   • 可通过类名或实例访问

   • 示例：

     class MyClass:
         class_var = "class level"
         
         def method(self):
             print(self.class_var)

LEGB规则

Python使用LEGB规则来查找变量：

1. 先在Local(局部)作用域查找
2. 然后在Enclosing(嵌套)作用域查找
3. 接着在Global(全局)作用域查找
4. 最后在Built-in(内置)作用域查找
   示例：

局部作用域（Local）

当变量在函数内部定义时，优先从当前函数局部作用域查找。例如：

def func():
    x = 10  # 局部变量
    print(x)  # 输出10
func()

嵌套作用域（Enclosing）

若局部作用域未找到变量，则向外层嵌套函数的作用域查找：

def outer():
    y = 20  # 嵌套作用域变量
    def inner():
        print(y)  # 输出20
    inner()
outer()

全局作用域（Global）

若前两层均未找到，则检查全局作用域：

z = 30  # 全局变量
def func():
    print(z)  # 输出30
func()

内置作用域（Built-in）

最后查找Python内置的变量或函数（如print、len等）：

def func():
    print(len([1, 2, 3]))  # 调用内置函数len
func()

冲突处理示例

若同名变量存在于不同作用域，遵循LEGB优先级：

x = 100  # 全局变量
def test():
    x = 200  # 局部变量
    print(x)  # 输出200（局部优先）
test()
print(x)  # 输出100（全局不变）

类与实例

类和实例的基本概念

在Python中，**类(Class)**是对象的蓝图或模板，它定义了一组属性和方法，用于创建具有相同结构和行为的对象。**实例(Instance)**则是根据类创建的具体对象。

# 定义一个简单的类
class Dog:
    # 类属性
    species = "Canis familiaris"

    # 初始化方法
    def __init__(self, name, age):
        # 实例属性
        self.name = name
        self.age = age

    # 实例方法
    def bark(self):
        print(f"{self.name} says: Woof!")

# 创建实例
my_dog = Dog("Buddy", 3)

类和实例的主要特性

1. 类属性：属于类本身的变量，所有实例共享

   • 如上述例子中的species属性
   • 可以通过类名或实例访问

2. 实例属性：每个实例特有的属性

   • 通常在__init__方法中初始化
   • 如name和age属性

3. 实例方法 ：定义在类中的函数，第一个参数通常是self

   • self代表当前实例
   • 如bark()方法

类的继承

Python支持继承，允许创建新的类继承现有类的属性和方法：

class GoldenRetriever(Dog):  # 继承Dog类
    def __init__(self, name, age, color="golden"):
        super().__init__(name, age)  # 调用父类初始化方法
        self.color = color

    # 方法重写
    def bark(self):
        print(f"{self.name} says: Woof woof! (I'm a Golden Retriever)")
      

对象的属性是可以动态增加的，如：

goldendog.attribution = "踢皮球"
print(goldendog.attribution)
#输出踢皮球

类的所有对象，都可以读取类属性'但是类属性不能通过对象修改，在修改时，Python会自动为对象创建画一个实例属性，并屏蔽掉类属性。

goldendog.species = "people"
print(goldendog.species)#输出people
print(my_dog.species)#输出animal

类方法和实例方法的区别

类方法是通过类名就可以直接调用的方法，函数的第一个参数为类本身。

实例方法是必须通过对象调用的方法，方法的第一个参数是对象本身。

类方法的定义与调用

类方法使用@classmethod装饰器定义，其第一个参数通常命名为cls，代表类本身。类方法可通过类名直接调用，无需创建实例。例如：

class MyClass:
    @classmethod
    def class_method(cls):
        print(f"Called from {cls.__name__}")

MyClass.class_method()  # 直接通过类名调用

类方法的典型应用包括工厂模式、替代构造函数或需要访问类级别属性的场景。

实例方法的定义与调用

实例方法的第一个参数通常命名为self，代表调用该方法的对象实例。必须通过实例化对象调用：

class MyClass:
    def instance_method(self):
        print(f"Called from instance of {self.__class__.__name__}")

obj = MyClass()
obj.instance_method()  # 必须通过实例调用

实例方法主要用于操作或访问实例的属性和状态。

__init__方法的作用和调用机制

__init__方法的基本概念

在Python中，__init__是一个特殊的类方法，被称为构造器或初始化方法。它在创建类的新实例时自动调用，主要用于初始化对象的属性或执行必要的设置操作。

__init__方法的核心功能

__init__方法的主要作用是初始化实例的属性和状态。当通过类创建新对象时，Python会自动调用该方法，传递任何提供的参数给__init__。

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

__init__方法的参数传递

__init__方法的第一个参数通常命名为self，代表类的实例。后续参数用于接收初始化时传入的值，这些值会被赋给实例的属性。

person = Person("Alice", 30)
print(person.name)  # 输出: Alice
print(person.age)   # 输出: 30

__init__方法的默认行为

如果类没有定义__init__方法，Python会使用默认的__init__方法，该方法不执行任何操作。这种情况下，实例创建时不会有任何属性初始化。

class EmptyClass:
    pass

obj = EmptyClass()  # 无__init__方法，不进行初始化

####__init__方法与其他特殊方法的区别

__init__方法与__new__方法不同。__new__负责创建实例，而__init__负责初始化实例。__init__在__new__返回实例后被调用。

class Example:
    def __new__(cls, *args, **kwargs):
        instance = super().__new__(cls)
        print("__new__ called")
        return instance

    def __init__(self, value):
        self.value = value
        print("__init__ called")

__init__方法的使用场景

__init__方法常用于设置实例的初始状态，例如数据库连接、文件句柄、默认配置等。它确保对象在创建后处于一致且可用的状态。

class DatabaseConnection:
    def __init__(self, host, port):
        self.host = host
        self.port = port
        self.connect()

    def connect(self):
        print(f"Connecting to {self.host}:{self.port}")

关键区别对比

调用方式差异

类方法：ClassName.method()

实例方法：instance.method()

参数含义

类方法接收类引用作为第一参数，实例方法接收对象实例作为第一参数。

使用场景

类方法处理类级别的逻辑，实例方法处理对象特定的数据和行为。

特殊方法

Python类可以使用特殊方法（双下划线方法）实现特定功能：

class Dog:
    # ...其他代码...
    
    def __str__(self):
        return f"{self.name} is {self.age} years old"
    
    def __len__(self):
        return self.age

Python面向对象编程的三大基本要素可通过以下代码示例详细解释：

封装

封装==将数据和操作数据的方法绑定在一起，隐藏内部实现细节，仅暴露必要接口。==私有属性可以通过在变量名称前面加"__"实现。以下示例展示如何通过私有属性和方法实现封装：

class BankAccount:
    def __init__(self, owner, balance):
        self.__owner = owner  # 私有属性
        self.__balance = balance
    
    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
            print(f"存款成功，当前余额: {self.__balance}")
    
    def get_balance(self):
        return self.__balance

account = BankAccount("Alice", 1000)
account.deposit(500)  # 输出: 存款成功，当前余额: 1500
print(account.get_balance())  # 输出: 1500
# print(account.__balance)  # 报错: AttributeError，因为是私有属性

当然也有私有方法，是指在 Python 的面向对象开发过程中，对象的某些方法或者称为函数只想在对象的内部被使用，但不想在外部被访问到这些方法或函数。

class Staff:
    def __init__(self, s_name, s_salary):
      self.s_name = s_name
      self.__salary = s_salary
      
    def __secret(self):
      print("%s 的工资是 %d" % (self.s_name, self.__salary))

继承

继承允许子类复用父类的属性和方法，同时可进行扩展或修改。示例展示单继承和方法重写：

class Animal:
    def __init__(self, name):
        self.name = name
    
    def speak(self):
        raise NotImplementedError("子类必须实现此方法")

class Dog(Animal):
    def speak(self):
        return f"{self.name}说: 汪汪!"

class Cat(Animal):
    def speak(self):
        return f"{self.name}说: 喵喵!"

dog = Dog("阿黄")
print(dog.speak())  # 输出: 阿黄说: 汪汪!
cat = Cat("小白")
print(cat.speak())  # 输出: 小白说: 喵喵!

多态

多态指相同接口在不同类中有不同实现方式，可通过继承或鸭子类型实现。以下示例展示两种实现方式：

# 基于继承的多态
class Bird:
    def fly(self):
        pass

class Eagle(Bird):
    def fly(self):
        print("鹰高空翱翔")

class Penguin(Bird):
    def fly(self):
        print("企鹅不会飞")

def animal_fly(bird):
    bird.fly()

eagle = Eagle()
penguin = Penguin()
animal_fly(eagle)    # 输出: 鹰高空翱翔
animal_fly(penguin)  # 输出: 企鹅不会飞

# 鸭子类型多态
class Airplane:
    def fly(self):
        print("飞机引擎驱动飞行")

airplane = Airplane()
animal_fly(airplane)  # 输出: 飞机引擎驱动飞行

三个特性常结合使用。以下综合示例展示更复杂的应用场景：

class Employee:
    def __init__(self, name, salary):
        self.__name = name
        self.__salary = salary
    
    def calculate_bonus(self):
        return self.__salary * 0.1
    
    def __str__(self):
        return f"员工: {self.__name}"

class Manager(Employee):
    def calculate_bonus(self):
        return super().calculate_bonus() + 5000
    
    def __str__(self):
        return f"经理: {self._Employee__name}"

def print_bonus(employee):
    print(f"{employee} 的年终奖: {employee.calculate_bonus()}")

emp = Employee("张三", 50000)
mgr = Manager("李四", 80000)
print_bonus(emp)  # 输出: 员工: 张三 的年终奖: 5000.0
print_bonus(mgr)  # 输出: 经理: 李四 的年终奖: 13000.0

面向对象中的常用方法

dir & dict

dir() 函数返回一个对象的所有属性和方法的列表，包括内置属性和方法。该函数无需参数时返回当前作用域的变量、方法和定义的类型列表。对于对象实例，dir() 返回实例属性、类属性以及继承的属性和方法。

dict 是对象的属性字典，仅包含实例的自定义属性（不包括类属性和内置属性）。它是一个字典结构，键为属性名，值为对应的属性值。类也有 dict 属性，但包含的是类级别的属性和方法。

class Example:
    class_attr = "class_value"
    def __init__(self):
        self.instance_attr = "instance_value"
obj = Example()
print(dir(obj))  # 输出所有属性和方法（包括继承的）
print(obj.__dict__)  # 输出 {'instance_attr': 'instance_value'}，因为只输出对象的属性

attr相关的方法

getattr

getattr(object, name[, default]) 用于动态获取对象的属性值。若属性不存在且未提供默认值，会引发 AttributeError；提供默认值时返回该值而非抛出异常。

value = getattr(obj, 'instance_attr', 'default')  # 返回 'instance_value'
missing = getattr(obj, 'non_existent', None)  # 返回 None

setattr

setattr(object, name, value) 动态设置对象的属性值。若属性不存在，会自动创建新属性。

setattr(obj, 'new_attr', 100)  # 等价于 obj.new_attr = 100
print(obj.__dict__)  # 输出 {'instance_attr': 'instance_value', 'new_attr': 100}

delattr

delattr(object, name) 删除对象的指定属性。属性不存在时引发 AttributeError。

delattr(obj, 'new_attr')  # 删除后 obj.__dict__ 恢复为 {'instance_attr': 'instance_value'}

hasattr

hasattr(object, name) 检查对象是否包含指定属性，返回布尔值。该方法通过尝试获取属性并捕获异常实现，性能略低于直接访问属性。

print(hasattr(obj, 'instance_attr'))  # 输出 True
print(hasattr(obj, 'non_existent'))  # 输出 False

isinatance & issubclass

isinstance 函数

isinstance(obj, classinfo) 用于检查对象 obj 是否为 classinfo 的实例或子类实例。返回 True 或 False。

参数说明

• obj: 待检测的对象。
• classinfo: 类、类型或由它们组成的元组（支持多类型检查）。

示例代码

class Animal: pass  
class Dog(Animal): pass  

dog = Dog()  
print(isinstance(dog, Dog))    # True  
print(isinstance(dog, Animal)) # True（子类实例）  
print(isinstance(dog, (str, int, Animal))) # True（元组匹配）  

关键特性

• 支持继承关系检查。
• 若 classinfo 为元组，任意类型匹配即返回 True。
• 常用于运行时类型验证或多态逻辑。

---

issubclass 函数

issubclass(cls, classinfo) 用于判断类 cls 是否为 classinfo 的子类（或自身）。返回 True 或 False。

参数说明

• cls: 待检测的类。
• classinfo: 类、类型或由它们组成的元组。

示例代码

class Animal: pass  
class Dog(Animal): pass  

print(issubclass(Dog, Animal))    # True  
print(issubclass(Dog, Dog))       # True（自身也算子类）  
print(issubclass(Dog, (str, Animal))) # True（元组匹配）  

关键特性

• 检查类之间的继承关系，而非实例。
• 若 cls 与 classinfo 相同，仍返回 True。
• 适用于框架设计或类结构验证。

---

区别与联系

• isinstance 针对对象与类的关系，issubclass 针对类与类的关系。
• 两者均支持元组参数和多类型匹配。
• 继承链中的任意层级均能被检测到。

综合示例

class A: pass  
class B(A): pass  
obj = B()  

print(isinstance(obj, A))      # True  
print(issubclass(B, A))        # True  
print(isinstance(obj, type(obj))) # True（obj.__class__ 为 B）  

Python中的type

type函数的基本用法

在Python中，type()函数用于获取对象的类型。直接调用type(object)会返回该对象所属的类。例如：

num = 42
print(type(num))  # 输出: <class 'int'>

text = "Hello"
print(type(text))  # 输出: <class 'str'>

检查变量类型

type()常用于动态类型检查，尤其是在需要验证输入数据类型时：

def calculate_square(value):
    if type(value) not in (int, float):
        raise TypeError("Input must be a number")
    return value ** 2

与isinstance的区别

type()直接返回对象的类型类，而isinstance()会考虑继承关系：

class Parent: pass
class Child(Parent): pass

obj = Child()
print(type(obj) is Child)  # True
print(type(obj) is Parent)  # False
print(isinstance(obj, Parent))  # True

元类编程中的应用

type()作为元类时，可以动态创建新类。三个参数分别是类名、基类元组和类属性字典：

MyClass = type('MyClass', (), {'x': 10})
instance = MyClass()
print(instance.x)  # 输出: 10

性能注意事项

在类型检查中，isinstance()通常比type()更灵活且性能相当。但在需要精确匹配类型时，type()更合适：

# 不推荐
if type(obj) == list:
    pass

# 推荐
if isinstance(obj, (list, tuple)):
    pass
```### type函数的基本用法
在Python中，`type()`函数用于获取对象的类型。直接调用`type(object)`会返回该对象所属的类。例如：
```python
num = 42
print(type(num))  # 输出: <class 'int'>

text = "Hello"
print(type(text))  # 输出: <class 'str'>

检查变量类型

type()常用于动态类型检查，尤其是在需要验证输入数据类型时：

def calculate_square(value):
    if type(value) not in (int, float):
        raise TypeError("Input must be a number")
    return value ** 2

与isinstance的区别

type()直接返回对象的类型类，而isinstance()会考虑继承关系：

class Parent: pass
class Child(Parent): pass

obj = Child()
print(type(obj) is Child)  # True
print(type(obj) is Parent)  # False
print(isinstance(obj, Parent))  # True

元类编程中的应用

type()作为元类时，可以动态创建新类。三个参数分别是类名、基类元组和类属性字典：

MyClass = type('MyClass', (), {'x': 10})
instance = MyClass()
print(instance.x)  # 输出: 10

性能注意事项

在类型检查中，isinstance()通常比type()更灵活且性能相当。但在需要精确匹配类型时，type()更合适：

# 不推荐
if type(obj) == list:
    pass

# 推荐
if isinstance(obj, (list, tuple)):
    pass