10.17学习日志

Python类和对象

Python从设计之初就已经是一门面向对象的语言，正因为如此，在Python中创建一个类和对象是很容易的。

如果你以前没有接触过面向对象的编程语言，那你可能需要先了解一些面向对象语言的一些基本特征，在头脑里头形成一个基本的面向对象的概念，这样有助于你更容易的学习Python的面向对象编程。

接下来我们先来简单的了解下面向对象的一些基本特征。

1. 面向对象编程 Object-Oriented Programming

• 什么是对象

  • 对象是指现实中的物体或实体

• 什么是面向对象

  • 把一切看成对象（实例），用各种对象之间的关系来描述事务。

• 对象都有什么特征

  • 对象有很多属性(名词)

    • 姓名, 年龄, 性别,

  • 对象有很多行为(动作,动词)

    • 学习,吃饭,睡觉,踢球, 工作

• 什么是类：

  • 拥有相同属性和行为的对象分为一组,即为一个类

  • 类是用来描述对象的工具,用类可以创建此类的对象(实例)

• 面向对象 示意

       /-------> BYD  E6(京A.88888) 实例，对象
车(类)  
       \-------> BMW  X5(京B.00000) 实例(对象)
    
       /-------> 小京巴(户籍号:000001)
狗(类)  
       \-------> 导盲犬（户籍号:000002）
​
       /-------> 100 (对象)
int(类)  
       \-------> 200 (对象)
​

2. 类和对象的基础语法

2.1 类的定义

类是创建对象的 "模板"。

• 数据成员：表明事物的特征。 相当于变量

• 方法成员：表明事物的功能。 相当于函数

• 通过class关键字定义类。

• 类的创建语句语法:

  class 类名 (继承列表):
      实例属性(类内的变量) 定义
      实例方法(类内的函数method) 定义
      类变量(class variable) 定义
      类方法(@classmethod) 定义
      静态方法(@staticmethod) 定义

类的创建的说明:

• 类名必须为标识符(与变量的命名相同,建议首字母大写)

• 类名实质上就是变量，它绑定一个类

2.2 实例化对象（构造函数）

(1) 构造函数调用表达式

变量 = 类名([参数])

(2) 说明

-- 变量存储的是实例化后的对象地址。

-- 类名后面的参数按照构造方法的形参传递

• 对象是类的实例，具有类定义的属性和方法。

• 通过调用类的构造函数来创建对象。

• 每个对象都有自己的状态，但共享相同的方法定义。

实例说明

• 实例有自己的作用域和名字空间,可以为该实例添加实例变量（也叫属性)

• 实例可以调用类方法和实例方法

• 实例可以访问类变量和实例变量

class Dog:
    a = 10
    name = "布布"

    def eat(self):
        print(f"{self.name}在吃东西")

dog01 = Dog()
print(dog01.name)
dog01.eat()

2.3 self

大家学Python面向对象的时候，总会遇到一个让人难以理解的存在：self

这个self到底是谁啊，为什么每个类实例方法都有一个参数self，它到底有什么作用呢？

「先下结论：类实例化后，self即代表着实例（对象）本身」

想要理解self有个最简单的方法，就是你把self当做**「实例（对象)的身份证」**。

• self是类方法的第一个参数，用于引用对象本身。

• self不是Python关键字，但是约定俗成的命名，可以使用其他名称代替，但通常不建议。

  """
      self
      初始化方法 __init__
  """
  
  class Person:
  
      def __init__(self,name,age,sex):
          # 实例属性
          self.name = name
          self.age = age
          self.sex = sex
  
      def eat(self,a = 0):
          if a > 2:
              print(f"{self.name}吃过饭了")
          else:
              print(f"{self.name}还没吃饭")
  
  person1 = Person("张三",22,"男")
  print(person1.name)
  print(person1.age)
  print(person1.sex)
  person1.eat(1)
  
  person2 = Person("李四",21,"女")
  print(person2.name)
  print(person2.age)
  print(person2.sex)

3. 属性和方法

3.1 属性

• 每个实例可以有自己的变量，称为实例变量(也叫属性)

• 属性的使用语法

    实例.属性名

• 属性的赋值规则

  • 首次为属性赋值则创建此属性.

  • 再次为属性赋值则改变属性的绑定关系.

• 作用

• 记录每个对象自身的数据

3.2 方法

class 类名(继承列表):
    def 实例方法名(self, 参数1, 参数2, ...):
        "文档字符串"
        语句块

• 实例方法的作用

• 用于描述一个对象的行为,让此类型的全部对象都拥有相同的行为

• 实例方法说明

  • 实例方法的实质是函数，是定义在类内的函数

  • 实例方法至少有一个形参，第一个形参绑定调用这个方法的实例,一般命名为"self"

  • 实例方法名是类属性

• 实例方法的调用语法

  实例.实例方法名(调用传参)
  # 或
  类名.实例方法名(实例, 调用传参)

"""
手机类 属性 苹果 华为 价格
      方法 打电话 存号码 玩游戏  
"""
class Phone:
    def __init__(self,brand,price):
        self.brand = brand
        self.price = price
        self.list1 = {}

    def call(self,a = 1):
        if a:
            print(f"{self.brand}的手机信号好")
        else:
            print(f"{self.brand}的手机信号不好")

    def cun(self,name,number):
        self.list1[name] = number
        print(self.list1)

phone1 = Phone("Apple",8000)
phone1.call(a = 0)
phone1.cun("张三",12345)

phone2 = Phone("Huawei",10000)

3.3 类属性

• 类属性是类的属性，此属性属于类，不属于此类的实例

• 作用：

  • 通常用来存储该类创建的对象的共有属性

• 类属性说明

  • 类属性,可以通过该类直接访问

  • 类属性,可以通过类的实例直接访问

3.4 类方法

• 类方法是用于描述类的行为的方法，类方法属于类，不属于该类创建的对象

• 说明

  • 类方法需要使用@classmethod装饰器定义

  • 类方法至少有一个形参，第一个形参用于绑定类，约定写为'cls'

  • 类和该类的实例都可以调用类方法

  • 类方法不能访问此类创建的对象的实例属性

cls

在Python中，cls 是一个约定俗成的名称，用于表示类本身。在类方法（使用 @classmethod 装饰的方法）中，cls 作为第一个参数传递给方法。这使得类方法可以访问和修改类属性以及调用其他类方法，而不需要引用具体的实例。

cls 的作用

1. 访问类属性 ：类方法可以通过 cls 访问和修改类属性。

2. 调用类方法 ：类方法可以通过 cls 调用其他类方法。

3. 创建类实例 ：类方法可以使用 cls 来创建类的实例。

3.5 静态方法 @staticmethod

• 静态方法是定义在类的内部函数，此函数的作用域是类的内部

• 说明

  • 静态方法需要使用@staticmethod装饰器定义

  • 静态方法与普通函数定义相同，不需要传入self实例参数和cls类参数

  • 静态方法只能凭借该类或类创建的实例调用

  • 静态方法可以访问类属性但是不能访问实例属性

"""
    类方法 类属性
    工商银行总行 all_price
    分行 拿钱
"""
class Zonghang:
    all_price = 100000000

    @classmethod
    def print_price(cls):
        print(f'总行剩余{cls.all_price}')

    def __init__(self, name,price):
        self.name = name
        self.price = price
        # 总行的钱减少
        Zonghang.all_price -= price

fenhang1 = Zonghang("支行1",300000)
fenhang2 = Zonghang("支行2",5000000)

Zonghang.print_price()


"""
    计数器
    统计当前类创建了多少对象
    
"""
class Count:
    number = 0

    @classmethod
    def count(cls):
        print(f"共创建了{cls.number}个实例对象")

    def __init__(self,name):
        self.name = name
        Count.number += 1

    # def count1(self):
    #     if self.name:
    #        Count.number += 1

name1 = Count("张三")
name2 = Count("李四")
# name1.count1()
# name2.count1()

Count.count()

3.6 初始化方法

• 初始化方法的作用：

  对新创建的对象添加属性

• 初始化方法的语法格式：

  class 类名(继承列表):
      def __init__(self[, 形参列表]):
          语句块
  # [] 代表其中的内容可省略

• 初始化方法的说明：

  • 初始化方法名必须为__init__ 不可改变

  • 初始化方法会在构造函数创建实例后自动调用,且将实例自身通过第一个参数self传入__init__方法

  • 构造函数的实参将通过__init__方法的参数列表传入到 __init__方法中

  • 初始化方法内如果需要return语句返回，则必须返回None

3.7 魔术方法

Python中的魔术方法（Magic Methods）是一种特殊的方法，它们以双下划线开头和结尾，例如__init__，__str__，__add__等。这些方法允许您自定义类的行为，以便与内置Python功能（如+运算符、迭代、字符串表示等）交互。

以下是一些常用的Python魔术方法：

1. __init__(self, ...): 初始化对象，通常用于设置对象的属性。

2. __str__(self): 定义对象的字符串表示形式，可通过str(object)或print(object)调用。例如，您可以返回一个字符串，描述对象的属性。

3. __repr__(self): 定义对象的"官方"字符串表示形式，通常用于调试。可通过repr(object)调用。

4. __len__(self): 定义对象的长度，可通过len(object)调用。通常在自定义容器类中使用。

5. __getitem__(self, key): 定义对象的索引操作，使对象可被像列表或字典一样索引。例如，object[key]。

6. __setitem__(self, key, value): 定义对象的赋值操作，使对象可像列表或字典一样赋值。例如，object[key] = value。

7. __delitem__(self, key): 定义对象的删除操作，使对象可像列表或字典一样删除元素。例如，del object[key]。

8. __iter__(self): 定义迭代器，使对象可迭代，可用于for循环。

9. __next__(self): 定义迭代器的下一个元素，通常与__iter__一起使用。

10. __add__(self, other): 定义对象相加的行为，使对象可以使用+运算符相加。例如，object1 + object2。

11. __sub__(self, other): 定义对象相减的行为，使对象可以使用-运算符相减。

12. __eq__(self, other): 定义对象相等性的行为，使对象可以使用==运算符比较。

13. __lt__(self, other): 定义对象小于其他对象的行为，使对象可以使用<运算符比较。

14. __gt__(self, other): 定义对象大于其他对象的行为，使对象可以使用>运算符比较。

15. __call__(self, other) 是一个特殊的方法（也称为"魔法方法"），它允许一个对象像函数一样被调用。

4. 继承/派生

• 什么是继承／派生

  • 继承是从已有的类中派生出新的类，新类具有原类的数据属性和行为，并能扩展新的能力。

  • 派生类就是从一个已有类中衍生出新类，在新的类上可以添加新的属性和行为

• 为什么继承/派生

  • 继承的目的是延续旧的类的功能

  • 派生的目地是在旧类的基础上添加新的功能

• 继承/派生的作用

  • 用继承派生机制，可以将一些共有功能加在基类中。实现代码的共享。

  • 在不改变基类的代码的基础上改变原有类的功能

• 继承/派生名词：

  • 基类(base class)/超类(super class)/父类(father class)

  • 派生类(derived class)/子类(child class)

4.1 单继承

• 单继承的语法:

  class 类名(基类名):
      语句块

  单继承说明:

• 单继承是指派生类由一个基类衍生出来的

4.2 多继承

Python支持多继承形式。多继承的类定义形如下例:

class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    .
    .
    .
    <statement-N>

需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索 即方法在子类中未找到时，从左到右查找父类中是否包含方法。

4.3 覆盖 override

• 覆盖是指在有继承关系的类中，子类中实现了与基类同名的方法,在子类的实例调用该方法时，实际调用的是子类中的覆盖版本,这种现象叫覆盖

• 作用：

  • 实现和父类同名，但功能不同的方法

"""
    继承的演示

"""
# 父类 基类
class Hunman:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def say(self,what):
        print(f"说了{what}")

    def walk(self,step):
        print(f"走了{step}")

class Teacher:
    def teach(self):
        print('正在教书')

class Student(Hunman,Teacher):
    def __init__(self,score,name,age):
        # 调用父类的构造函数
        Hunman.__init__(self,name,age)
        self.score = score
    def study(self,hour):
        print(f"学习了{hour}小时")

    # 跟父类的方法同名 那么会覆盖父类的方法
    def say(self):
        print(f"我得名字{self.name},我得年龄{self.age}，我得得分{self.score}")

h01 = Hunman("小红",20)
s01 = Student(100,"小王",18)
s01.say()
s01.teach()