Python学习笔记(12) --对象,类的成员方法,构造方法,其他内置方法,封装,继承,多态,类型注解

传送门==>B站黑马python入门教程

---

目录

• 1.对象
• 2.类的成员方法
• 3.构造方法
• 4.其他内置方法
• • [字符串方法 `str`](#字符串方法 __str__)
  • 小于比较方法`lt`
  • [小于等于比较 `le`](#小于等于比较 __le__)
  • 比较是否相同`eq`
• 5.封装
• 6.继承
• • 对父类的复写和调用父类成员
• 7.类型注解
• • 变量注解
  • 函数方法注解
  • [union 联合类型注解](#union 联合类型注解)
• 8.多态

---

1.对象

---

1.在程序中设计表格,设计类

class Student:
    name = None

2.创建对象;

s1 = Student()
s2 = Student()

3.对象属性赋值;

s1.name = "张三"
s2.name = "张三1"

---

2.类的成员方法

• 类的名称: class关键字,表明可以定义类
• 类的属性:即定义在类中变量(成员变量)
• 类的行为:即定义在类中的函数(成员方法)

创建类对象的语法
对象=类名称()

成员方法

类的方法定义和普通函数基本差不多,但区别在于;
成员方法有参数self

语法:

def 方法名称(self,参数1...参数):
    方法

self 关键字的作用:

• 表明类对象自身
• 在使用类对象调用方法时,self会被python传入
• 在方法内部,想要访问类的成员变量,就得使用self;

---

注: self关键字,虽然在参数列表,调用时也可以不传;

例如:

class Student:
    name = None
    age = None
    sex = None
    def print_info(self):
        print("姓名:%s,年龄:%d,性别:%s"%(self.name,self.age,self.sex))

    def get_msg(self,msg):
        print("接收到的内容为:",msg)

student = Student()
student.name = "张三"
student.age = 18
student.sex = "男"
student.print_info()
student.get_msg("这是一个消息")

---

3.构造方法

成员变量的赋值:

如下的代码,给对象属性赋值的时候要依次进行,有点繁琐;

class Student:
    name = None
    age = None
    score = None

s1 = Student()
s1.name = "张三"
s1.age = 18
s1.score = 90

s2 = Student
s2.name = "张三1"
s2.age = 20

构造方法: _init_()方法, 在创建类对象时,自动执行;且将传入的参数自动传递给了_init_方法使用

class Student:
    name = None
    age = None
    score = None
    def __init__(self,name,age,score):
        self.name = name
        self.age = age
        self.score = score

s1 = Student("小智",18,90)
s2 = Student("小智1",20,80)

---

4.其他内置方法

---

字符串方法 __str__

案例:

class Student:
    name = None
    age = None
    score = None
    def __init__(self, name, age, score):
        self.name = name
        self.age = age
        self.score = score
    

s1 = Student("小智RE0", 18, 90)
print(s1)
print(str(s1))

输出为地址值

加入字符串方法后

class Student:
    name = None
    age = None
    score = None
    def __init__(self, name, age, score):
        self.name = name
        self.age = age
        self.score = score
    def __str__(self):
        return "Student: name=%s, age=%d, score=%d" % (self.name, self.age, self.score)

s1 = Student("小智RE0", 18, 90)
print(s1)
print(str(s1))

小于比较方法__lt__

案例,若直接用比较符号比较对象时,会报错

class Student:
    name = None
    age = None
    score = None
    def __init__(self, name, age, score):
        self.name = name
        self.age = age
        self.score = score

s1 = Student("小智RE0", 18, 90)
print(s1 < Student("小智RE1", 18, 90))
print(s1 < Student("小智RE2", 18, 90))

加入__lt__方法

class Student:
    name = None
    age = None
    score = None
    def __init__(self, name, age, score):
        self.name = name
        self.age = age
        self.score = score
    def __lt__(self, other):
        return self.score < other.score

s1 = Student("小智RE0", 18, 90)
print(s1 < Student("小智RE1", 18, 90))
print(s1 < Student("小智RE2", 18, 90))

小于等于比较 __le__

"""
__le__ 小于等于比较
"""
class Person:
    name = None
    age = None
    score = None

    def __init__(self, name, age, score):
        self.name = name
        self.age = age
        self.score = score

    def __le__(self, other):
        return self.score <= other.score

s1 = Person("小智RE0", 18, 90)
print(s1 <= Person("小智RE1", 18, 90))

比较是否相同__eq__

"""
__eq__ 比较是否相同
"""
class Student:
    name = None
    age = None
    score = None
    def __init__(self, name, age, score):
        self.name = name
        self.age = age
        self.score = score

    def __eq__(self, other):
        return self.score == other.score

s1 = Student("小智RE0", 18, 90)
print(s1 == Student("小智RE1", 20, 90))

---

5.封装

面向对象语言基本都是基于模板类去创建实体对象,然后用对象完成功能开发

对用户隐藏的属性和行为

私有成员:

若类不想公开给外部使用的变量或方法,就可以设置为私有成员;

• 私有成员变量:变量名用__开头;
• 私有方法变量:方法名用__开头;

---

6.继承

单继承: 父类->子类

# 父类:
class Animal():
    name = None
    age = None
    def __init__(self,name):
        self.name = name

    def call(self):
        print(self.name,"在叫")

# 子类:
class Cat(Animal):
    #颜色
    color = None
    def __init__(self,name,color):
        # 调用父类的构造方法
        Animal.__init__(self,name)
        self.color = color

    def call(self):
        print(self.name,"在叫,颜色是:",self.color)

多继承:一个类可以继承多个父类

# 父类1
class Animal():
    name = None
    age = None
    def __init__(self,name):
        self.name = name

    def call(self):
        print(self.name,"在叫")

# 父类2
class Flyable():
    name = None
    age = None
    def __init__(self,name):
        self.name = name
    def fly(self):
        print(self.name,"在飞")

# 子类
class Bird(Animal,Flyable):
    name = None
    age = None
    def __init__(self,name):
        self.name = name
    def fly(self):
        print(self.name,"在飞")
    def call(self):
        print(self.name,"在叫")

---

对父类的复写和调用父类成员

一旦复写父类成员之后,那么类对象调用成员时,就会调用复写后的新成员,

若想要调用父类的成员可使用以下方法;

• 直接强制调用;

父类名.成员变量(方法)

• 使用super()调用

super().成员变量(方法)

---

# 动物类
class Animal:
    name = None
    age = None

    def __init__(self,name,age):
        self.name = name
        self.age = age
    def eat(self):
        print("动物吃")
    def drink(self):
        print("动物喝")

# 猫
class Cat(Animal):
    def eat(self):
        Animal.eat(self)
        print("小猫吃吃吃")
    def drink(self):
        Animal.drink(self)
        print("小猫喝喝喝")
    def catch(self):
        print("小猫抓老鼠")

# 直接强制调用父类成员
cat = Cat("小猫",1)
cat.eat()
cat.drink()
cat.catch()
print("----------------------------------------------------------------------------------------------------------------")
# 使用super()调用父类成员
class Cat(Animal):
    def eat(self):
        super().eat()
    def drink(self):
        super().drink()
    def catch(self):
        print("小猫抓老鼠")

Cat = Cat("小猫",1)
Cat.eat()
Cat.drink()
Cat.catch()

7.类型注解

---

为什么要使用注解

变量注解

基础数据类型注解:

var_1: int = 10
var_2: str = "hello"
var_3: float = 10.0
var_4: bool = True

类对象类型注解:

class Student:
    name = None

stu:  Student = Student()

基础容器类型注解:

my_list: list = [1,2,3,4,5]
my_tuple: tuple = (1,2,3,4,5)
my_str: str = "hello world"
my_set: set = {1,2,3,4,5}
my_dict: dict = {"name":"张三","age":18,"sex":"男"}

容器类型详细注解:

my_list: list[int] = [1,2,3,4,5]
my_tuple: tuple[int,str,float] = (1,"hello",10.0)
my_str: str = "hello world"
my_set: set[int] = {1,2,3,4,5}
my_dict: dict[str,int] = {"name":"张三","age":18,"sex":"男"}

注:元组类型设置类型详细注解,需要将每一个元素都标记出来;

字典类型设置类型详细注解,需要key和value;

除了使用变量类型,这种语法做注解外,也可以在注释中进行类型注解;
语法

语法:#type:类型

案例

class Student:
    pass

var_1 = random.randint(1,10) # type:int
var_2 = "hello" # type:str 
var_3 = json.loads(data) # type:dict
var_4 = func() # type: Student

函数方法注解

函数和方法的形参类型注解语法:

def 函数方法名(形参名:类型,形参名:类型,...)

pass

案例

def add(x:int,y:int):
    return x+y

def func(data:list):
    pass

函数的返回值类型注解:

def 函数方法名(形参:类型...形参:类型)->返回值类型:

pass

---

union 联合类型注解

例如下面的列表和字典存储了相同的类型数据,可以直接指定类型注解;

my_list: list[int] = [1,2,3,4,5]
my_dict: dict[str,int] = {"name":18,"age":18}

但是若果列表和字典存储的元素类型不同,则需要使用元组进行类型注解;

my_list1 = [1,2,3,4,5,"张三"]
my_dict1 = {"name":18,"age":18,"sex":"男"}

可以使用typing模块中的Union类型进行类型注解;

from typing import Union
my_list2: list[Union[int,str]] = [1,2,3,4,5,"张三"]
my_dict2: dict[str,Union[int,str]] = {"name":18,"age":18,"sex":"男"}

---

8.多态

---

---