python类和对象

九、类和对象

9.1、创建类和对象

"""格式：
  class 类名：
    类的属性（成员变量）
    类的行为（成员方法）    
"""
​
# 设计类
class 类名：
  name = None
    
# 创建对象---->对象 = 类名（）
stu_1 = 类名()
stu_2 = 类名()
​
# 对象属性赋值
stu_1.name = "值"
stu_2.name = "值"

9.2、成员方法

在类中定义成员方法和定义函数基本一直，但仍有区别：

# 格式：
def 方法名(self,形参1,·······,形参n):
    方法体

self关键字在定义成员方法时必须填写：

• 它表示类对象自身的意思

• 当我们使用类对象调用方法时，self会自动传入

• 在方法内部，想要访问成员变量，必须使用self

  # 创建类
  class 类名：
    name = None
      
      # 定义方法
      def 方法名(self):
          print(f"你好，我是：{self.name}")

9.3、构造方法

python类可以使用：-init-()方法，称之为构造方法

• 在创建对象的时候会自动执行

• 在创建对象的时候会将参数自动传递给init方法使用

class Student:
    name = None
    age = None
    
    # 创建构造方法
    def __init__(self,name,age):
        self.name = name
        self.age = age
        
stu = Student("虾米",18)

注意：init前后各有两个下划线，构造方法也是成员方法，不能少self

9.4、内置方法

内置函数参考表：Python 内置函数 | 菜鸟教程

1）字符串方法：_str_直接打印类名会出现地址，使用str内置方法,可以自定义返回内容

class Student:
    # 定义构造方法
    def __init__(self,name,age):
        self.name = name
        self.age = age
     
    #定义字符串方法
    def __str__(self):
        return f"Student类对象，name={self.name},age={self.age}"
        
        
# 创建对象
stu = Student("xiam",12)

2）小于和大于符号比较：lt

注意：直接使用两个对象比较会报错，调用lt方法，参数为另一个对象

class student:
    def __init__(self,name,age):
        self.name = name 
        self.age = age 
     
    # 定义比较的魔术方法lt
    def __lt__(self,other)
      return self.age < other.age
    
stu_1 = Student("张三",23)
stu_2 = Student("李四",24)
print(sut_1 > stu_2)    # 结果为：True

3）小于等于和大于等于比较：le

class student:
    def __init__(self,name,age):
        self.name = name 
        self.age = age 
     
    # 定义比较的魔术方法le
    def __le__(self,other)
      return self.age <= other.age
    
stu_1 = Student("张三",23)
stu_2 = Student("李四",24)
print(sut_1 >= stu_2)   # 结果为：True

4）比较对象是否相等：eq

• 参数为另一个对象

• 不实现eq方法，对象之间比较的是内存地址

• 实现eq方法，就可以按照自己的想法判断两个对象是否相等

class student:
    def __init__(self,name,age):
        self.name = name 
        self.age = age 
     
    # 定义比较的魔术方法eq
    def __eq__(self,other)
      return self.age == other.age
    
stu_1 = Student("张三",23)
stu_2 = Student("李四",24)
print(sut_1 == stu_2)   # 结果为：False

9.5、封装

将现实中的事物在类中描述为属性和方法，即为封装

1）私有成员和方法：

• 私有成员：变量名以_开头（2个下划线）

• 私有方法：方法名以_开头（2个下换线）

class 类名：
  name = None
    __stu_age = None    # 私有成员变量
    
    def __方法名(self)     #私有方法
      print("这是私有成员方法")

注意：私有成员和方法无法被类对象使用，但可以被类中其他成员使用（只可以在本类内部使用）

9.6、继承

1）python继承分为：单继承和多继承

# 单继承格式：
class 类名(父类名)：
  内容体
    
# 多继承格式：
class 类名(父类1,父类2,·······,父类n):
    内容体

注意1：如果一个类继承了多个父类，且这个类没有内容体，就可以使用pass关键字代替

class 类名(父类1,父类2,·······,父类n):
    # 没有内容
    pass

注意2：多个父类中，如果有同名的方法，那么默认以继承顺序（从左到右）为优先级，先继承的保留，后继承的被覆盖

2）复写：子类继承父类的成员方法后，对其内容不满意，可进行复写，在子类中重新定义重名的属性或方法即可

# 定义父类
class Phone:
    adress = None
    def call(self):
        print("父类中的方法")
        
# 定义子类        
class MyPhone(Phone):
    def call(self):
        print("子类复写后的方法")

3）调用父类同名成员：如果子类复写了父类的成员，对象调用时就会走子类中的方法或成员

• 调用父类成员变量：父类名.成员变量

• 调用父类成员方法：父类名.成员方法(self)

• 使用super()调用成员变量：super().成员变量

• 使用super()调用成员方法：super().成员方法()

9.7、类型注解

在代码中涉及到数据交互的地方，提供数据的注解（显示说明）

1）变量的类型注解：

• 格式1：变量名：类型 = 值

• 格式2： # type：类型

# 格式1：变量名：类型 = 值
​
# 基础变量注解：
var_1: int = 10
var_2: float = 12.34
var_1 = 10    # type: int
var_2 = 12.34 # type: float
​
# 类对象注解：标记stu对象的类型为Student
class Student:
    pass
stu: Student = Student()
stu = Student()   # type: Student
​
# 容器类型简易注解：
my_list: list = [1,2,3]
my_tuple: tuple = (1,2,3)
my_list = [1,2,3]   # type: list
my_tuple = (1,2,3)    # type: tuple
​
# 容器类型详细注解
my_list: list[int] = [1,2,3]
my_tuple: tuple[str,int,bool] = ("香米",23,True)
## 注意：元组类型设置详细注解需要将每一个元素标记出来
my_list = [1,2,3]   # type: list[int]
my_tuple = ("香米",23,True) # type: tuple[str,int,bool]

2）函数和方法的类型注解

• 格式： def 函数方法名(形参名：类型,形参名：类型,········)：

• 返回值注解：def 函数方法名(形参名：类型,形参名：类型,········) -> 返回值类型 ：

def 函数方法名（形参1：类型，形参1：类型，·······）：
  函数体
    
def add(x:int,y:int) -> int:
    return x+y
​
def fun(data:list) -> list:
    return data

3）Union联合类型注解：当数据中出现不同类型的数据时，无法注解时使用，在变量，函数（方法）和返回值中均可使用

• 注意：使用时要导包from typing import Union

# 导包
from typing import Union
# Union描述混合类型的数据注解
my_list: list[Union[str,int]] = [1,"虾米",34]
my_dict: dict[str,Union[str,int]] = {"name":"虾米","age":23}
​
def fun(data: Union[int, str]) -> Union[int, str]:
    pass

9.8、多态

多态：指的是多种状态，即完成某个行为时，使用不同的对象会有不同的效果

多态常使用在继承关系上：

• 函数（方法）形参声明使用父类类型

• 实际传入父类的子类类型进行工作

class Animal:
    def speak(self):
        pass
    
class Dog(Animal):
    def speak(self):
        print("汪汪")
        
class Cat(Animal):
    def speak(self):
        print("喵喵")
        
dog = Dog()
cat = Cat()
# 形参类型是父类，传入的是子类类型
speak(dog)
speak(cat)

9.9、抽象类（接口）

抽象类：含有抽象方法的类叫抽象类

抽象方法：方法体是空实现的（pass）

由父类确定有哪些方法，但不做出具体实现，由子类实现具体功能

# 抽象类
class Animal:
    # 抽象方法
    def speak(self):
        pass
    
# 子类实现父类的抽象方法   
class Dog(Animal):
    def speak(self):
        print("汪汪")

抽象类的作用：多用于顶层设计（设计标准）以便子类做具体实现