9.类的定义与使用

类的定义
构造函数(__init__)
实例变量
类变量
方法(实例方法)
类方法(@classmethod)
静态方法(@staticmethod)
属性装饰器(@property)
私有属性与方法
继承
多态
方法重写
super()函数
类的文档字符串
类的属性和方法访问控制

1.类的定义:

如int,list,tuple等等都是类,还可以通过class方法自己创建类,

定义:类是对象的蓝图,包括属性(数据)和方法(行为),在python中使用class关键字定义

用法:类可以用来创建对象(实例),每个对象都可以有自己的属性与方法

例如：游戏角色就是类

亚索就是对象

技能就是对象的方法，数值是对象的属性

2.属性:既他们共有的部分,如建立一个student类,那么他们的学号,年纪,课程,各科成绩都是属性

3.方法:既函数,如:计算他们的总成绩

如下可以创建一个空类

class MyClass:pass  # 空类

2.构造函数(init)

定义:构造函数是一个特殊的方法,用于初始化对象的属性,他在创建对象时自动调用.

用法:构造函数的名称是__init__,它接受参数并将这些参数赋值给实例变量.

class Person:def __init__(self, name, age):self.name = name  # 实例变量self.age = age    # 实例变量

说明:在这个例子中,Person类有一个构造函数,他接受name,age作为参数,并将他们赋值给实例变量self.name和self.age,每当创建一个Person对象时,都会调用这个构造函数.

3.实例变量

定义:实例变量是属于特定对象的变量,每个对象都有自己的副本,他们通常在构造函数中定义

用法:通过self关键字访问实例变量

class Dog:def __init__(self, name):self.name = name  # 实例变量dog1 = Dog("Buddy")
dog2 = Dog("Max")
print(dog1.name)  # 输出: Buddy
print(dog2.name)  # 输出: Max

说明:在这个例子中,Dog类的每个实例都有自己的name属性,dog1和dog2是两个不同的对象,他们的name属性是独立的.

4.类变量

定义:类变量是属于类的变量,所有实例共享同一个类变量,他们通常在类体中定义.

用法:可以通过类名或实例访问类变量.

class Dog:species = "Canis familiaris"  # 类变量def __init__(self, name):self.name = name  # 实例变量print(Dog.species,Dog.name)  # 输出: Canis familiaris
dog1 = Dog("Buddy")
print(dog1.species,dog1.name)  # 输出: Canis familiaris Buddy

说明:在这个例子中,species是一个类变量,所有Dog类的实例共享这个变量,无论是通过类名还是实例访问,结果都是相同的.

5.方法(实例方法)

定义:方法是定义在类中的函数,用于描述对象的行为,方法可以访问实例变量和类变量.

用法:通过实例调用方法.

class Dog:def __init__(self, name, age):self.name = name  # 实例变量self.age = age    # 实例变量def bark(self):  # 实例方法return f"{self.name} says Woof!"def get_age(self):  # 实例方法return self.age# 创建实例
dog1 = Dog("Buddy", 3)
dog2 = Dog("Max", 5)# 调用实例方法
print(dog1.bark())  # 输出: Buddy says Woof!
print(dog2.get_age())  # 输出: 5

说明:

在这个例子中，Dog类有两个实例变量name和age，它们在构造函数中初始化。

bark和get_age是实例方法，分别用于返回狗的叫声和年龄。

通过创建Dog类的实例dog1和dog2，可以调用这些实例方法。

6.类方法(@classmethod)

定义:类方法是绑定到类而不是实例的方法,可以访问类变量,他的第一个参数是类本身,通常被命名为cls.类方法不需要实例化对象就可以调用

用法:使用@classmethod装饰器

class Dog:species = "Canis familiaris"  # 类变量def __init__(self, name):self.name = name  # 实例变量@classmethoddef get_species(cls):return cls.species  # 访问类变量@classmethoddef create_dog(cls, name):return cls(name)  # 使用类方法创建实例# 调用类方法
print(Dog.get_species())  # 输出: Canis familiaris# 使用类方法创建实例
dog1 = Dog.create_dog("Buddy")
print(dog1.name)  # 输出: Buddy

说明:

在这个例子中，Dog类有一个类变量species，它表示狗的物种。

get_species是一个类方法，用于返回类变量species的值。

create_dog是另一个类方法，用于根据传入的名称创建Dog类的实例。它返回一个新的Dog对象。

6.1类方法的其他参数

class MyClass:class_variable = 0@classmethoddef increment(cls, amount):cls.class_variable += amount  # 增加类变量的值@classmethoddef get_class_variable(cls):return cls.class_variable# 使用类方法
MyClass.increment(5)
print(MyClass.get_class_variable())  # 输出: 5MyClass.increment(10)
print(MyClass.get_class_variable())  # 输出: 15

说明:

在这个例子中，increment方法接受一个参数amount，用于增加类变量class_variable的值。

注6.2:类方法与实例方法的比较

实例方法：实例方法的第一个参数是self，它指向实例本身，可以访问实例变量和类变量。

类方法：类方法的第一个参数是cls，它指向类本身，只能访问类变量。

class Example:class_variable = "I am a class variable"def __init__(self, instance_variable):self.instance_variable = instance_variable@classmethoddef class_method(cls):return cls.class_variable  # 访问类变量def instance_method(self):return self.instance_variable,self.class_variable  # 访问实例变量和类变量example = Example("I am an instance variable")
print(example.class_method())  # 输出: I am a class variable
print(example.instance_method())  # 输出: ('I am an instance variable', 'I am a class variable')

7.静态方法(@staticmethod)

定义:静态方法是定义在类中的方法，但它不依赖于类或实例的状态。静态方法不需要访问类变量或实例变量，因此它不需要self或cls作为参数。静态方法通常用于执行一些与类或实例无关的功能。

用法:使用@staticmethod装饰器

class Math:@staticmethoddef add(a, b):return a + b@staticmethoddef multiply(a, b):return a * b# 调用静态方法
result_add = Math.add(5, 3)  # 通过类名调用
result_multiply = Math.multiply(4, 2)  # 通过类名调用print(result_add)      # 输出: 8
print(result_multiply) # 输出: 8

说明:

在这个例子中，Math类定义了两个静态方法：add和multiply，分别用于执行加法和乘法运算。

这些方法不依赖于类的状态，因此可以直接通过类名调用。

注:7.1静态方法与实例方法,类方法的比较

实例方法：实例方法的第一个参数是self，它指向实例本身，可以访问实例变量和类变量。

类方法：类方法的第一个参数是cls，它指向类本身，可以访问类变量。

静态方法：静态方法不需要self或cls，它们不依赖于类或实例的状态。

class Example:class_variable = "I am a class variable"def __init__(self, instance_variable):self.instance_variable = instance_variable@classmethoddef class_method(cls):  #类方法return cls.class_variable  # 访问类变量def instance_method(self):    #实例方法return self.instance_variable  # 访问实例变量@staticmethoddef static_method():    #静态方法return "I am a static method"  # 不依赖于类或实例example = Example("I am an instance variable")
print(example.class_method())  # 输出: I am a class variable
print(example.instance_method())  # 输出: I am an instance variable
print(Example.static_method())  # 输出: I am a static method

8.属性装饰器(@property)

定义:属性装饰器用于将方法转换为属性,允许对属性的访问进行控制,她可以让你在访问属性时执行一些逻辑

用法:使用@property和@<property_name>.setter装饰器

class Circle:def __init__(self, radius):self._radius = radius  # 保护属性@propertydef radius(self):"""获取圆的半径"""return self._radius@radius.setterdef radius(self, value):"""设置圆的半径，确保半径为正数"""if value < 0:raise ValueError("Radius cannot be negative")self._radius = value@propertydef area(self):"""计算圆的面积"""return 3.14159 * (self._radius ** 2)# 创建实例
circle = Circle(5)# 访问属性
print(circle.radius)  # 输出: 5
print(circle.area)    # 输出: 78.53975# 修改属性
circle.radius = 10
print(circle.radius)  # 输出: 10
print(circle.area)    # 输出: 314.159# circle.radius = -5  # 会引发 ValueError

说明:

在这个例子中，Circle类有一个保护属性_radius，用于存储圆的半径。

radius方法被装饰为属性，允许通过circle.radius访问半径。

radius的设置器方法允许对半径进行赋值，并在赋值时进行验证，确保半径为正数。

area方法被装饰为只读属性，计算并返回圆的面积。

具体实例:

class Bank:#使用__加在需要隐藏的属性命名前# 即使是使用print(__money)也输出不了def __init__(self,ID,password,money):self.ID = IDself.__passsword = passwordself.__money = money@property   #python内置三大装饰器 描述符 将方法变为属性def money(self):return self.__money@money.setter  #存钱def money(self,value):self.__money = valueprint(f'尊敬的{self.ID}你好，您的余额还剩{self.__money}')@money.deleter  #删除def money(self):del self.__moneyprint('已删除')
b = Bank('小徐','123456',1000)
print(b.money)   #1000
b.money =2000    #尊敬的小徐你好，您的余额还剩2000
print(b.money)   #2000
#删除此数据
del b.money  #已删除

9.私有属性与方法

定义:在Python中，私有属性和方法是以双下划线（__）开头的属性和方法。它们的设计目的是为了限制对类内部状态的直接访问，从而实现数据封装和保护。

私有属性：以双下划线开头的实例变量，外部无法直接访问。

私有方法：以双下划线开头的方法，外部无法直接调用。

用法:通过公共方法访问私有属性

class BankAccount:def __init__(self, balance):self.__balance = balance  # 私有属性def deposit(self, amount):"""存款方法，增加余额"""if amount > 0:self.__balance += amountelse:print("Deposit amount must be positive")def withdraw(self, amount):"""取款方法，减少余额"""if 0 < amount <= self.__balance:self.__balance -= amountelse:print("Invalid withdrawal amount")def get_balance(self):"""获取当前余额"""return self.__balance  # 通过公共方法访问私有属性# 创建实例
account = BankAccount(1000)# 存款
account.deposit(500)
print(account.get_balance())  # 输出: 1500# 取款
account.withdraw(200)
print(account.get_balance())  # 输出: 1300# 直接访问私有属性会引发错误
# print(account.__balance)  # 会引发 AttributeError

说明:

在这个例子中，BankAccount类有一个私有属性__balance，用于存储账户余额。

deposit和withdraw方法用于增加和减少余额，确保对余额的操作是安全的。

get_balance方法是一个公共方法，用于获取当前余额，允许外部访问私有属性。

10.继承

定义:继承允许一个类(子类)继承另一个类(父类)的属性和方法,子类可以重用父类的代码,并可以添加或重写功能.

用法:通过在类定义中指定父类.

10.1单继承:

# 定义父类 Animal
class Animal:def __init__(self, name, age):self.name = name  # 实例变量self.age = age    # 实例变量def speak(self):return "Some sound"def info(self):return f"{self.name} is {self.age} years old."# 定义子类 Dog，继承自 Animal
class Dog(Animal):def speak(self):  # 重写父类的方法return "Woof!"# 定义子类 Cat，继承自 Animal
class Cat(Animal):def speak(self):  # 重写父类的方法return "Meow!"# 创建实例
dog = Dog("Buddy", 3)
cat = Cat("Whiskers", 5)# 访问父类的属性和方法
print(dog.name)  # 输出: Buddy
print(dog.age)   # 输出: 3
print(dog.info())  # 输出: Buddy is 3 years old.
print(dog.speak())  # 输出: Woof!print(cat.name)  # 输出: Whiskers
print(cat.age)   # 输出: 5
print(cat.info())  # 输出: Whiskers is 5 years old.
print(cat.speak())  # 输出: Meow!

说明:

在这个例子中，Animal是父类，包含两个实例变量name和age，以及两个方法speak和info。
Dog和Cat是子类，分别继承自Animal类，并重写了speak方法，以返回特定的声音。
通过创建Dog和Cat的实例，可以访问它们的属性和方法，展示了继承的效果。

10.2多继承:

class Flyer:def fly(self):return "Flying"class Swimmer:def swim(self):return "Swimming"class Duck(Flyer, Swimmer):  # 多重继承def quack(self):return "Quack!"# 创建实例
duck = Duck()
print(duck.fly())  # 输出: Flying
print(duck.swim())  # 输出: Swimming
print(duck.quack())  # 输出: Quack!

说明:

在这个例子中，Flyer和Swimmer是两个父类，Duck类同时继承了这两个父类。

Duck类可以访问Flyer和Swimmer类的方法，展示了多重继承的特性。

注:10.1方法解析顺序

在多重继承中，Python使用方法解析顺序（MRO）来确定方法的调用顺序。可以使用__mro__属性查看类的MRO。

print(Duck.__mro__)  # 输出: (<class '__main__.Duck'>, <class '__main__.Flyer'>, <class '__main__.Swimmer'>, <class 'object'>)

MRO的顺序是从子类到父类的顺序

11.多态

定义:多态允许不同类的对象以相同的方式调用相同的方法,它使代码更加灵活可拓展

用法:通过父类引用调用子类的方法

# 定义父类 Animal
class Animal:def speak(self):raise NotImplementedError("Subclasses must implement this method")# 定义子类 Dog，继承自 Animal
class Dog(Animal):def speak(self):  # 重写父类的方法return "Woof!"# 定义子类 Cat，继承自 Animal
class Cat(Animal):def speak(self):  # 重写父类的方法return "Meow!"# 定义子类 Bird，继承自 Animal
class Bird(Animal):def speak(self):  # 重写父类的方法return "Chirp!"# 创建一个函数，接受 Animal 类型的参数
def animal_sound(animal):print(animal.speak())# 创建实例
dog = Dog()
cat = Cat()
bird = Bird()# 调用函数，展示多态
animal_sound(dog)  # 输出: Woof!
animal_sound(cat)  # 输出: Meow!
animal_sound(bird)  # 输出: Chirp!

说明:

在这个例子中，Animal是一个父类，定义了一个speak方法，但没有实现具体的逻辑，而是抛出NotImplementedError，要求子类必须实现这个方法。

Dog、Cat和Bird是子类，它们分别重写了speak方法，返回各自特有的声音。

animal_sound函数接受一个Animal类型的参数，并调用其speak方法。无论传入的是Dog、Cat还是Bird对象，都会调用相应的speak方法，展示了多态的特性。

11.1多态与鸭子类型

Python是一种动态类型语言，支持鸭子类型（Duck Typing）。这意味着只要一个对象实现了所需的方法，就可以被视为该类型，而不需要显式声明类型。

class Duck:def quack(self):return "Quack!"class Person:def quack(self):return "I'm quacking like a duck!"# 定义一个函数，接受任何具有 quack 方法的对象
def make_it_quack(thing):print(thing.quack())# 创建实例
duck = Duck()
person = Person()# 调用函数，展示鸭子类型
make_it_quack(duck)    # 输出: Quack!
make_it_quack(person)  # 输出: I'm quacking like a duck!

在这个例子中，Duck和Person类都实现了quack方法。make_it_quack函数接受任何具有quack方法的对象，无论其类型如何。

这展示了鸭子类型的灵活性，允许不同类型的对象以相同的方式进行操作。

12.方法重写

定义:方法重写（Method Overriding）是指在子类中重新定义父类的方法，以提供特定的实现。通过方法重写，子类可以改变或扩展父类的行为。

用法:子类中定义与父类同名的方法

# 定义父类 Animal
class Animal:def speak(self):return "Some sound"# 定义子类 Dog，继承自 Animal
class Dog(Animal):def speak(self):  # 重写父类的方法return "Woof!"# 定义子类 Cat，继承自 Animal
class Cat(Animal):def speak(self):  # 重写父类的方法return "Meow!"# 创建实例
dog = Dog()
cat = Cat()# 调用方法
print(dog.speak())  # 输出: Woof!
print(cat.speak())  # 输出: Meow!

说明:

在这个例子中，Animal是父类，定义了一个speak方法，返回一个通用的声音。

Dog和Cat是子类，它们分别重写了speak方法，返回特定的声音。

当调用dog.speak()和cat.speak()时，执行的是子类中的实现，而不是父类中的实现。

13.super()函数

定义:super()是一个内置函数，用于返回当前类的父类（超类）对象。它主要用于调用父类的方法，特别是在子类重写父类方法时，可以通过super()来访问父类的实现。

用法:在子类中使用super()调用父类的构造函数或方法

class Animal:def __init__(self, name):self.name = namedef speak(self):return "Some sound"class Dog(Animal):def __init__(self, name, breed):super().__init__(name)  # 调用父类的构造函数self.breed = breeddef speak(self):  # 重写父类的方法parent_sound = super().speak()  # 调用父类的方法return f"{parent_sound} and Woof!"# 创建实例
dog = Dog("Buddy", "Golden Retriever")# 调用方法
print(dog.name)  # 输出: Buddy
print(dog.breed)  # 输出: Golden Retriever
print(dog.speak())  # 输出: Some sound and Woof!

说明:

在这个例子中，Animal类有一个构造函数和一个speak方法。

Dog类继承自Animal，在其构造函数中使用super().__init__(name)调用父类的构造函数，以初始化name属性。

Dog类重写了speak方法，并在其中使用super().speak()调用父类的speak方法，结合了父类和子类的行为。

13.1多继承中的super()

在多重继承中，super()能够按照方法解析顺序（MRO）正确地调用父类的方法。

class A:def greet(self):return "Hello from A"class B(A):def greet(self):return super().greet() + " and Hello from B"class C(A):def greet(self):return super().greet() + " and Hello from C"class D(B, C):  # D 继承自 B 和 Cdef greet(self):return super().greet() + " and Hello from D"# 创建实例
d = D()
print(d.greet())  # 输出: Hello from A and Hello from C and Hello from B and Hello from D

说明:

在这个例子中，D类继承自B和C，而B和C又都继承自A。

当调用d.greet()时，super()会按照MRO的顺序依次调用父类的方法，确保每个类的greet方法都被调用。

14.类的文档字符串

定义:文档字符串用于描述类或方法的功能,她们呢是类和方法的第一行字符串,通常用于提供帮助信息.

用法:在类或方法的第一行使用三重引号

class Dog:"""A class representing a dog."""def bark(self):"""Make the dog bark."""return "Woof!"

说明:在这个例子中,Dog类和bark方法都有文档字符串,可以使用help(Dog)或help(Dog.bark)查看这些文档字符串,帮助用户理解类和方法的功能.

15.类的属性和方法的访问控制

公有:可以在类外部访问,默认情况下,所有属性和方法都是公有的
保护:以单下划线开头,表示不建议在类的外部访问,通常用于内部使用
私有:以双下划线开头,外部无法直接访问,通常用于保护类的内部状态.

class Example:def __init__(self):self.public_var = "I am public"self._protected_var = "I am protected"self.__private_var = "I am private"example = Example()
print(example.public_var)  # 输出: I am public
print(example._protected_var)  # 输出: I am protected
# print(example.__private_var)  # 会引发 AttributeError

16.其他

'''
Python内置的类属性
1.dict 类的属性 返回字典
2.doc 类的文档  输出第一行内部注释 单' '或三 ''' ''' #不行
3.name 输出类的名字
4.bases 类的所有父类
'''
class a :'所有员工的基类'b = 0'13'print(a.__doc__)  #所有员工的基类
print(a.__name__)  #a
print(a.__dict__)  #{'__module__': '__main__', '__doc__': '所有员工的基类', 'b': 0, '__dict__': <attribute '__dict__' of 'a' objects>, '__weakref__': <attribute '__weakref__' of 'a' objects>}
print(a.__bases__)   #(<class 'object'>,)

'''
type :检测该数据是什么数据类型
isinstance(obj,int) :检测obj是不是int类型,检测一个类型是不是指定类型
issubclass(子类,父类):是否有继承关系
'''class A(object):pass
class B(A):pass
#检测B是不是A的子类
print(issubclass(B,A))  #True

16总结

class Animal:"""父类：动物"""def __init__(self, name, age):self.name = name  # 实例变量self.age = age    # 实例变量def speak(self):"""动物发声，子类需要重写此方法"""raise NotImplementedError("Subclasses must implement this method")def info(self):"""获取动物信息"""return f"{self.name} is {self.age} years old."class Dog(Animal):"""子类：狗"""def __init__(self, name, age, breed):super().__init__(name, age)  # 调用父类构造函数self.breed = breed  # 实例变量def speak(self):  # 重写父类的方法return "Woof!"@staticmethoddef species():"""静态方法：返回物种"""return "Canis familiaris"class Cat(Animal):"""子类：猫"""def speak(self):  # 重写父类的方法return "Meow!"class Bird(Animal):"""子类：鸟"""def speak(self):  # 重写父类的方法return "Chirp!"class AnimalShelter:"""动物收容所类"""def __init__(self):self.animals = []  # 存储动物的列表def add_animal(self, animal):"""添加动物到收容所"""self.animals.append(animal)def make_sounds(self):"""让所有动物发声"""for animal in self.animals:print(f"{animal.info()} says {animal.speak()}")# 创建动物实例
dog = Dog("Buddy", 3, "Golden Retriever")
cat = Cat("Whiskers", 2)
bird = Bird("Tweety", 1)# 创建动物收容所实例
shelter = AnimalShelter()# 添加动物到收容所
shelter.add_animal(dog)
shelter.add_animal(cat)
shelter.add_animal(bird)# 让所有动物发声
shelter.make_sounds()# 输出狗的物种
print(f"{dog.name} is a {Dog.species()}.")  # 输出: Buddy is a Canis familiaris.

说明:

1. 类定义：

Animal是父类，包含基本的动物属性和方法。

Dog、Cat和Bird是子类，分别重写了speak方法，提供特定的发声实现。

2. 继承：

Dog类继承自Animal类，并在构造函数中使用super()调用父类的构造函数。

3. 多态：

make_sounds方法展示了多态性，通过调用不同动物的speak方法，输出不同的声音。

4. 静态方法：

Dog类中定义了一个静态方法species，返回狗的物种。

5. 私有属性：

在这个示例中没有使用私有属性，但可以在实际应用中根据需要添加。

6. 动物收容所：

AnimalShelter类用于管理动物，提供添加动物和让动物发声的方法。

16.2

import randomclass Animal:"""父类：动物"""def __init__(self, name, age):self.name = name  # 实例变量self.age = age    # 实例变量self.__health = 100  # 私有属性：健康值def speak(self):"""动物发声，子类需要重写此方法"""raise NotImplementedError("Subclasses must implement this method")def info(self):"""获取动物信息"""return f"{self.name} is {self.age} years old and has {self.__health} health."@propertydef health(self):"""健康值的属性装饰器"""return self.__healthdef take_damage(self, damage):"""减少健康值"""self.__health -= damageif self.__health < 0:self.__health = 0def heal(self, amount):"""恢复健康值"""self.__health += amountif self.__health > 100:self.__health = 100class Dog(Animal):"""子类：狗"""def __init__(self, name, age, breed):super().__init__(name, age)  # 调用父类构造函数self.breed = breed  # 实例变量def speak(self):  # 重写父类的方法return "Woof!"@staticmethoddef species():"""静态方法：返回物种"""return "Canis familiaris"class Cat(Animal):"""子类：猫"""def speak(self):  # 重写父类的方法return "Meow!"class Bird(Animal):"""子类：鸟"""def speak(self):  # 重写父类的方法return "Chirp!"class AdventureGame:"""动物冒险游戏类"""def __init__(self):self.animals = []  # 存储动物的列表def add_animal(self, animal):"""添加动物到游戏"""self.animals.append(animal)def start_adventure(self):"""开始冒险"""print("Welcome to the Animal Adventure Game!")for animal in self.animals:print(f"{animal.info()} says {animal.speak()}")self.adventure(animal)def adventure(self, animal):"""进行一次冒险"""print(f"{animal.name} is going on an adventure!")damage = random.randint(10, 30)  # 随机伤害print(f"{animal.name} encountered a challenge and took {damage} damage!")animal.take_damage(damage)print(animal.info())# 选择是否恢复健康if random.choice([True, False]):heal_amount = random.randint(5, 20)animal.heal(heal_amount)print(f"{animal.name} healed for {heal_amount} health!")print(animal.info())print("-" * 30)# 创建动物实例
dog = Dog("Buddy", 3, "Golden Retriever")
cat = Cat("Whiskers", 2)
bird = Bird("Tweety", 1)# 创建游戏实例
game = AdventureGame()# 添加动物到游戏
game.add_animal(dog)
game.add_animal(cat)
game.add_animal(bird)# 开始冒险
game.start_adventure()

说明:

1. 类定义：