Python中class的用法

2024-07-08 1112阅读

文章目录

  • 前言
  • 一、类的定义
  • 二、类的应用场景
    • 1.数据建模-数据抽象和封装
    • 2.创建对象实例，代码重用和多态
    • 3.组织代码管理封装
    • 3.实现设计模式
    • 4.数据验证和封装逻辑
    • 5.模拟现实世界中的事物
    • 6.提供公共接口
    • 7.支持面向对象的分析和设计

      前言

      Python中有很内置数据类型，数值类型int float complex，序列类型str list tuple range，集合类型set frozenset，映射类型dict，布尔类型bool,二进制类型bytes，bytearray。需要使用时，他们都可以去创建实例对象。

      内置数据类型可直接使用，隐式创建，不用关键字int，str等：

      • int：print(type(10)) 输出
      • float print(type(10.007)) 输出
      • complex print(type(4 + 5j)) 输出
      • str print(type('10')) 输出
      • list tuple print(type([1, 3, '1', 4])) 输出；print(type((1, 3, '1', 4)))输出;对应可变、不可变序列。
      • range print(type(range(10))) 输出,range是内置函数，返回一个可迭代对象
      • set frozenset print(type({1, 2, 3, 3, 4})) 输出；对应可变、不可变集合；集合无序，无索引，不能切片。
      • dict print(type({1: 'rat', 2: 'bat', 3: 'bird', 4: 'feather', 5: 'leather'})) 输出；键值对形式。
      • bytes print(type(b'\x01\x02\x03\x04'))输出

        同时，也可使用关键字创建实例，或实现类型转换。

        Python中class的用法

        一、类的定义

        在Python中，类（Class）是一种用户定义的数据类型，它允许你创建具有相同属性和方法的对象（Object）。类是对象的蓝图或模板，而对象则是根据这个蓝图创建的实例。

        class Dog:  
    # 类变量（静态变量），属于类本身，不属于类的任何实例  
    species = "Canis lupus familiaris"  
  
    # 初始化方法，当创建类的新实例时自动调用  
    def __init__(self, name, age):  
        # 实例变量（成员变量），属于类的每个实例  
        self.name = name  
        self.age = age  
  
    # 实例方法，属于类的实例  
    def bark(self):  
        print(f"{self.name} says Woof!")  
  
    # 类方法，通过装饰器@classmethod定义，属于类本身，但可以通过类实例访问  
    @classmethod  
    def class_method(cls):  
        print(f"The species of {cls.__name__} is {cls.species}")  
  
    # 静态方法，通过装饰器@staticmethod定义，不属于类也不属于类的实例，只是和类关联在一起  
    @staticmethod  
    def static_method():  
        print("This is a static method.")  
  
# 创建一个Dog类的实例  
my_dog = Dog("Buddy", 3)  
  
# 访问实例变量  
print(my_dog.name)  # 输出: Buddy  
print(my_dog.age)   # 输出: 3  
  
# 调用实例方法  
my_dog.bark()  # 输出: Buddy says Woof!  
  
# 调用类方法  
Dog.class_method()  # 输出: The species of Dog is Canis lupus familiaris  
my_dog.class_method()  # 同样可以通过实例调用类方法，但不建议这样做，因为这可能使代码更难以理解  
  
# 调用静态方法  
Dog.static_method()  # 输出: This is a static method.  
my_dog.static_method()  # 也可以通过实例调用静态方法，但同样不建议这样做

        二、类的应用场景

        1.数据建模-数据抽象和封装

        类可以将数据（属性）和操作数据的方法（函数）封装在一起，形成一个独立的单元。这种封装隐藏了对象的内部细节，只提供公共的接口供外部使用，从而实现了数据抽象：长方形

        class Rectangle:  
    def __init__(self, width, height):  
        self.width = width  
        self.height = height  
    def area(self):  
        return self.width * self.height  
# 创建一个Rectangle对象  
rect = Rectangle(10, 5)  
print(rect.area())  # 输出：50

        2.创建对象实例，代码重用和多态

        类是对象的蓝图或模板，你可以使用类来创建（实例化）多个具有相同属性和方法的对象。每个对象都是类的一个实例，并且具有自己的状态（属性值）。

        class Dog:  
    def __init__(self, name, breed):  
        self.name = name  
        self.breed = breed  
# 创建两个Dog对象实例  
dog1 = Dog("Buddy", "Labrador")  
dog2 = Dog("Max", "Poodle")  
print(dog1.name)  # 输出：Buddy  
print(dog2.breed)  # 输出：Poodle

        代码重用：通过继承（Inheritance），子类可以重用父类的属性和方法，从而避免了代码的重复编写。这有助于减少代码量，提高代码的可维护性。

        实现多态性：多态性允许你使用相同的接口（方法名）来处理不同类型的对象。在Python中，这通常通过定义接口（如使用abc模块定义的抽象基类）或约定来实现。多态性使得代码更加灵活和可扩展。

        class Animal:
    def __init__(self, name):
        self.name = name
    def speak(self):
        pass  # 抽象方法，具体实现在子类中
    def getLeatherColor(self):
        pass  # 抽象方法，具体实现在子类中
class Dog(Animal):
    def speak(self):
        return "Woof!"
    def getLeatherColor(self):
        return 'a white dog'
class Cat(Animal):
    def speak(self):
        return "Tiger!"
    def getLeatherColor(self):
        return 'an orange cat'
d = Dog("Fido")
c = Cat("Anne")
print(d.name)  # 初始化函数-重用，继承。输出：Fido
print(d.speak())  # 输出：Woof! 多态
print(d.getLeatherColor())  # 输出：'a white dog' 多态
print(c.name)  # 输出：Anne! 多态
print(c.speak())  # 输出：Tiger! 多态
print(c.getLeatherColor())  # 输出：'an orange cat'

        3.组织代码管理封装

        类提供了一种将相关的代码组织在一起的方式。通过将相关的属性和方法封装在类中，你可以更容易地理解和维护代码。此外，类还可以用于创建模块和包，进一步组织和管理代码。

        # 文件名：math_operations.py  
class MathUtils:  
    @staticmethod  
    def add(a, b):  
        return a + b  
    @staticmethod  
    def multiply(a, b):  
        return a * b  
# 在其他文件中  
from math_operations import MathUtils  
print(MathUtils.add(5, 3))  # 输出：8

        注：静态方法，通过装饰器@staticmethod定义，不属于类也不属于类的实例，只是和类关联在一起 。它们就像普通的函数一样，但可以在类的命名空间下调用。

        3.实现设计模式

        设计模式是解决常见软件设计问题的最佳实践。类是实现这些设计模式的基础。例如，你可以使用类来实现单例模式、工厂模式、观察者模式等。

        以单例模式(如果此类还没有实例，就生成一个实例，如果一创建过，则返回那一个实例。)为例:

        class Singleton:  
    _instance = None  
    def __new__(cls, *args, **kwargs):  
        if cls._instance is None:  
            cls._instance = super().__new__(cls)  
        return cls._instance  
a = Singleton()  
b = Singleton()  
print(a is b)  # 输出：True，证明a和b是同一个实例
print('a-id:', id(a))  # 输出id值
print('b-id:', id(b))  # 输出id值同上，说明是同一个内存上的同一个东西。

        Python中class的用法

        注： 输出id值一样，说明是同一个内存上的同一个东西。

        4.数据验证和封装逻辑

        在类的内部，你可以编写用于验证数据有效性的代码，并封装与数据相关的逻辑。这有助于确保数据的完整性和正确性，并减少错误的可能性。

        class BankAccount:  
    def __init__(self, balance):  
        if balance  self._balance or amount  

        5.模拟现实世界中的事物
         

        类可以用于模拟现实世界中的事物，如人、动物、汽车、房屋等。通过定义这些事物的属性和方法，你可以使用代码来模拟它们的行为和交互。
         

        class Person:
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender
    def introduce(self):
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")
    def greet(self, other_person):
        print(f"{self.name} says hello to {other_person.name}!")
class Man(Person):
    def __init__(self, name, age):
        super().__init__(name, age, "Male")
    def goto_date(self, woman):
        if isinstance(woman, Woman):  # 类型限定
            print(f"{self.name} go to date {woman.name}!")
        else:
            print(f"{self.name} can only go to date a Woman, not a {type(woman).__name__}!")
class Woman(Person):
    def __init__(self, name, age):
        super().__init__(name, age, "Female")
    def smile(self, man):
        if isinstance(man, Man):
            print(f"{self.name} smiles at {man.name}!")
        else:
            print(f"{self.name} can only smile at a Man, not a {type(man).__name__}!")
        # 创建对象并调用方法
john = Man("John", 30)
alice = Woman("Alice", 25)
john.introduce()
alice.introduce()
# 数据交互：问候
john.greet(alice)
alice.greet(john)
# 数据交互：特定于男人和女人的行为-约会
john.goto_date(alice)
alice.smile(john)
# 尝试不合适的交互（只是为了演示）
john.goto_date(john)  # 这应该输出一个错误消息

         

        Python中class的用法
        在这个示例中，Person类有一个greet方法，它允许任何Person对象与其他Person对象打招呼。Man类添加了一个goto_date方法，专门用于与Woman对象约会。类似地，Woman类添加了一个smile方法，专门用于对Man对象微笑。添加了一些类型检查，以确保flirt和smile方法只与预期的对象类型一起使用。如果传递了错误的对象类型，则会打印出错误消息。
         
 
 
        使用类，可简化复杂系统:对于大型和复杂的系统，使用类可以帮助你简化和组织代码。通过将系统的不同部分划分为不同的类，你可以更容易地理解和维护系统的各个组件。
         
 

        6.提供公共接口
         

        类提供了一个公共的接口，使得外部代码可以通过该接口与类的实例进行交互。这有助于隐藏类的内部实现细节，并使得代码更加模块化和可维护。
         

        # 公共接口模块
class PersonInterface:
    @staticmethod
    def interact_with_person(person1, person2):
        person1.introduce()
        person2.introduce()
        person1.greet(person2)
        person2.greet(person1)
    # 使用示例
# Man，Woman接上一个示例
john = Man("John", 30)
alice = Woman("Alice", 25)
# 通过公共接口进行交互
PersonInterface.interact_with_person(john, alice)

         

        7.支持面向对象的分析和设计
         

        在软件开发过程中，面向对象的分析和设计（OOAD）是一种常用的方法。类作为面向对象编程的核心概念之一，支持这种分析和设计方法，并有助于创建出更加健壮、可维护和可扩展的软件系统。
        应用示例：python的GUI之计算器
         

        Tips
        __new__方法是一个特殊的静态方法，用于实例化对象。通常不需要直接调用__new__方法，Python会自动调用它来分配内存空间并返回一个新对象。特殊情况下，使用__new__方法来限制只能创建特定数量的实例；需要重写__new__方法来控制对象的创建过程。
VPS购买请点击我

免责声明：我们致力于保护作者版权，注重分享，被刊用文章因无法核实真实出处，未能及时与作者取得联系，或有版权异议的，请联系管理员，我们会立即处理! 部分文章是来自自研大数据AI进行生成,内容摘自(百度百科,百度知道,头条百科,中国民法典,刑法,牛津词典,新华词典,汉语词典,国家院校,科普平台)等数据,内容仅供学习参考,不准确地方联系删除处理! 图片声明：本站部分配图来自人工智能系统AI生成,觅知网授权图片,PxHere摄影无版权图库和百度，360，搜狗等多加搜索引擎自动关键词搜索配图，如有侵权的图片，请第一时间联系我们，邮箱：ciyunidc@ciyunshuju.com。本站只作为美观性配图使用,无任何非法侵犯第三方意图,一切解释权归图片著作权方,本站不承担任何责任。如有恶意碰瓷者,必当奉陪到底严惩不贷!

相关阅读

目录[+]