ZJL的个人博客

[[ slide_text ]]

[[ item.c ]]

Python类

发布时间：2021-07-06 作者：zjl 来源：zjl个人博客

Python

## Python类

#### 类的结构

```python
class Person:
    # 类属性
    species = "Human"
    
    def __init__(self, name, age):
        # 实例属性
        self.name = name
        # 私有属性
        self.__age = age 
        
    def say_hello(self):
        # 实例方法
        print(f"Hello, my name is {self.name}.")
        
    @classmethod
    def get_species(cls):
        # 类方法
        return cls.species
    
    @staticmethod
    def is_adult(age):
        # 静态方法
        return age >= 18

```

**类属性**：

- 类属性是定义在类中，属于类对象的属性。
- 它是类的所有实例共享的属性，可以通过类名或实例对象访问。
- 类属性在所有实例之间保持一致。

**实例属性**：

- 实例属性是定义在类的构造函数 `__init__()` 中，属于实例对象的属性。
- 每个实例对象都有自己的一组实例属性，它们存储特定于该实例的数据。
- 实例属性可以通过实例对象访问。

**构造方法**：

- 构造方法是类中特殊的方法，使用 `__init__()` 命名。
- 构造方法在创建对象时被调用，用于初始化实例的属性。
- 构造方法可以接受参数，并将其分配给实例的属性。

**实例方法（Instance Method）**：

- 实例方法在定义时必须包含一个额外的参数 `self`，用于引用调用该方法的实例对象。
- 实例方法可以访问实例对象的属性，并且可以通过 `self` 参数来修改属性的值。
- 实例方法通过实例对象调用。

**类方法（Class Method）**：

- 类方法是定义在类中的方法，用于操作类对象和类属性。
- 类方法在定义时使用 `@classmethod` 装饰器修饰，并且在定义时必须包含一个额外的参数 `cls`，用于引用类对象。
- 类方法可以访问类属性，并且可以通过 `cls` 参数来修改类属性的值。
- 类方法可以通过类名或实例对象调用，但在内部操作类属性时通常使用类名来访问。

**静态方法（Static Method）**：

- 静态方法是定义在类中的方法，与类和实例对象无关，用于执行独立的功能。
- 静态方法在定义时使用 `@staticmethod` 装饰器修饰，不需要额外的参数来引用类对象或实例对象。
- 静态方法不能访问类属性或实例属性，也不能修改它们。
- 静态方法可以通过类名或实例对象调用，但在内部不能操作类属性或实例属性。

**属性（Property）**：

- 属性是类中的特殊方法，用于访问和修改类的属性值，使其看起来像是直接访问对象的属性。
- 属性通常与 getter 和 setter 方法相关联，用于获取和设置属性的值。
- 在类中定义属性时，可以使用 `@property` 装饰器将方法定义为属性访问器（getter）。
- 可以使用 `@属性名.setter` 装饰器将方法定义为属性修改器（setter），用于设置属性的值。
- 使用属性访问器和修改器可以提供对属性的控制和验证。

#### 类的三大特性

**继承**：

- 继承是一种机制，允许一个类继承另一个类的属性和方法。
- 子类（派生类）可以继承父类（基类）的属性和方法，并且可以添加自己的属性和方法。
- 继承可以创建类的层次结构，实现代码的重用和扩展。

**封装**：

- 封装是将数据和操作封装在类中，对外部隐藏内部实现细节。
- 封装提供了对象的接口，通过接口访问对象的属性和方法。
- 封装提供了数据的保护和对象的安全性。

**多态**：

- 多态是一种能力，允许不同类型的对象对相同的方法进行不同的实现。

- 多态性使得可以通过统一的接口来处理不同类型的对象。

- 多态性可以通过继承和方法重写来实现。

#### `issubclass`  `isinstance`  `type`

```python
isinstance(a,b) a对象是否是b类或者b类子孙类的实例化的对象
issubclass(a,B) a类是否是B类的子孙类
type(a)  获取a这个对象具体从哪个类实例化的 类。
```

#### type与object类的区别与联系

鸡生蛋，蛋生鸡的关系。

python讲究 一切皆对象，变量，字符串，一个实例也是一个对象，一个类是不是对象？一个类也是一个对象，既然是对象，那么就是从一个类实例化得来的，python中的大部分类（自己建的，大部分源码中的类）具体是从哪个类实例化出来的？具体type元类实例化出来的，type元类也称为构建类。

object类是什么？是所有类的基类。 type类也继承object类。

```python
class A:
    pass

print(type(A))  # <class 'type'>
print(type(str))  # <class 'type'>
print(type(list))  # <class 'type'>

# print(type(object))  # <class 'type'>  # object类是从type类构建的来的。
print(issubclass(type,object))  # True  type类继承object类
```

#### 特殊的双下方法

+ `__len__` 对一个实例进行len(obj)自动触发此实例的类中的`__len__`方法

```python
  from dataclasses import dataclass
  
  @dataclass
  class A(object):
  
      name: str
      age: int
      # def __init__(self,name,age):
      #     self.name = name
      #     self.age = age
  
      def func(self):
          pass
  
      def __len__(self):
          print(666)
          # return 10
          return len(self.__dict__)
  obj = A('七个',20)
  print(len(obj))  # 自动执行此对象的__len__方法
  ```

+ `__eq__`

```python
  class A:
  
      def __init__(self,num: int) -> None:
          self.num = num
  
      def __eq__(self, other) -> bool:
          return self.num == other.num
  # print(dir(object))
  obj1 = A(200)
  obj2 = A(200)
  print(obj1 == obj2)
  ```

+ `__call__`

```python
  # __call__ 
  
  class Foo:
  
      def __init__(self):
          print('in init')
  
      def __call__(self, *args, **kwargs):
          print('__call__')
  
  obj = Foo()
  # 对象() 就会触发此类的__call__方法。
  # obj()
  # print(callable(obj))  # callable(对象)判断此类中是否含有__call__方法。
  ```

+ `__str__ __repr__ __format__`

```python
  # __str__  __repr__  __format__
  
  # class A:
  #     def __init__(self,name,age):
  #         self.name = name
  #         self.age = age
  #
  #     def __str__(self):
  #         return f'姓名：{self.name} 年龄：{self.age}'
  #
  #     def __repr__(self):
  #         return f'姓名{self.name} 年龄{self.age}的学生'
  # obj1 = A('小广播',20)
  # obj2 = A('峰哥',20)
  #
  # # print(obj1)  # 打印对象时，自动触发__str__方法。
  # # print(obj2)
  # # print(str(obj1))  # 打印str(对象)时，自动触发__str__方法。
  # # 格式化输出也可以触发__str__方法
  # # print('---->%s' % (obj1,))
  # # print(f'--->{obj1}')
  #
  # # __str__ 优先级高于__repr__
  # # print(obj2)
  
  ```

+ `__del__`析构方法

```python
  # __del__ 析构方法
  
  # print(dir(object))
  
  class A:
  
      def __init__(self,name):
          self.name = name
  
      def __del__(self):
          print(111)
  obj = A('张三')
  print(222)
  import time
  time.sleep(5)
  # print(obj.name)
  ```

+ `__new__`方法

实例化一个对象，发生了三件事

1. 触发object类的`__new__`方法，创建并返回一个对象空间。
  2. 自动执行`__init__`方法，将对象空间传给self.
  3. 执行`__init__`方法 给对象封装属性。

```python
  class A(object):
  
      def __init__(self,name):
          print(222)
          self.name = name
  
      def __new__(cls, *args, **kwargs):
          print(111)
          return super().__new__(cls)
  
  obj = A('老王')
  # print(obj)
  ```

python中的设计模式之一：单例模式。

默认情况下，对一个类实例化多个对象，产生多个对象空间。单例模式是指对一个类实例化多次对象，但是只是第一会产生一个对象空间，剩下的都是沿用第一次的空间。

```python
  # class A:
  #     pass
  
  # obj = A()
  # print(obj)
  # obj = A()
  # print(obj)
  # obj = A()
  # print(obj)
  
  class A:
  
      __instance = None
  
      # def __init__(self,name,age):
      #     self.name = name
      #     self.age = age
  
      def __new__(cls, *args, **kwargs):
          if not cls.__instance:
              cls.__instance = object.__new__(cls)
          return cls.__instance
  
  obj = A()
  print(obj)
  obj = A()
  print(obj)
  obj = A()
  print(obj)
  
  ```

+ 单例模式的优缺点

```
    【优点】
    一、实例控制
    通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。
    二、灵活性
    因为类控制了实例化过程，所以类可以灵活更改实例化过程。
    【缺点】
    一、开销
    虽然数量很少，但如果每次对象请求引用时都要检查是否存在类的实例，将仍然需要一些开销。可以通过使用静态初始化解决此问题。
    二、可能的开发混淆
    使用单例对象（尤其在类库中定义的对象）时，开发人员必须记住自己不能使用new关键字实例化对象。因为可能无法访问库源代码，因此应用程序开发人员可能会意外发现自己无法直接实例化此类。
    三、对象生存期
    不能解决删除单个对象的问题。在提供内存管理的语言中（例如基于.NET Framework的语言），只有单例类能够导致实例被取消分配，因为它包含对该实例的私有引用。在某些语言中（如 C++），其他类可以删除对象实例，但这样会导致单例类中出现悬浮引用
    
    ```

+ `__item__`系列

如果你想要对一个实例，进行类似于字典的操作，可以考虑这个系列。

```python
  # __item__系列
  
  class A:
  
      def __init__(self,name):
          self.name = name
  
      def __getitem__(self, item):
          # print(item)
          # return getattr(self,item)
          return self.__dict__[item]
  
      def __setitem__(self, key, value):
          print(key,value)
          setattr(self,key,value)
  
      def __delitem__(self, key):
          # print(key)
          delattr(self,key)
  obj = A('思密达')
  # print(obj.name)
  # print(obj['name'])  # __getitem__方法
  
  # obj['age'] = 18
  # print(obj['age'])
  
  del obj['name']
  print(obj.__dict__)
  
  ```

+ `__delattr__`方法

del obj.属性 触发这个方法。

````python
  class A:
  
      def __init__(self,name):
          self.name = name
  
      def __delattr__(self, item):
          print(666)
          # delattr(self,item)
          super().__delattr__(item)
  obj = A('石榴')
  
  del obj.name  # 触发__delattr__方法
  # delattr(obj,'name')  # 触发__delattr__方法
  print(obj.__dict__)
  ```

+ `__enter__ __eixt__`

上下文管理的两个双下方法

```python
  # class A:
  #     def __init__(self, text):
  #         self.text = text
  #
  # with A('大爷') as f1:  # f1 = A('大爷')
  #     print(f1.text)
  
  # class A:
  #     def __init__(self, text):
  #         self.text = text
  #         print(111)
  #     def __enter__(self):
  #         print(2222)
  #         return self
  #
  #     def __exit__(self, exc_type, exc_val, exc_tb):
  #         print(333)
  #         pass
  # with A('大爷') as f1:  # f1 = A('大爷')
  #     print(f1)
  #     print(f1.text)
  
  # __init__先执行， 刚进入 with语句时 执行__enter__方法，
  # with语句执行完毕之前，执行__exit__方法。
  
  class A:
      def __init__(self, text):
          self.text = text
  
      def __enter__(self):
          self.text += '您来了'
          return self
  
      def __exit__(self, exc_type, exc_val, exc_tb):
          self.text += '这就走呀'
  with A('大爷') as f1:  # f1 = A('大爷')
      # print(f1)
      print(f1.text)
  print(f1.text)
  ```

你觉得文章怎么样