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("汪汪")

抽象类的作用:多用于顶层设计(设计标准)以便子类做具体实现

你可能感兴趣的:(python,开发语言)