Python进阶编程 --- 1.类和对象

文章目录

- 第一章：
- - 1.初始对象
  - - 1.1 使用对象组织数据
    - 1.2 类的成员方法
    - - 1.2.1 类的定义和使用
      - 1.2.2 创建类对象
      - 1.2.3 成员变量和成员方法
      - 1.2.4 成员方法的定义语法
      - 1.2.5 注意事项
    - 1.3 类和对象
    - - 1.3.1 基于类创建对象
    - 1.4 构造方法
    - 1.5 其他内置方法
    - - 1.5.1 魔术方法
      - str字符串方法
        lt小于符号比较方法
        le小于等于、大于等于符号比较方法
        eq比较运算符方法
    - 1.6 封装
    - - 1.6.1 私有成员
      - 定义私有成员：
        使用私有成员：
    - 1.7 继承
    - - 1.7.1 单继承
      - 1.7.2 多继承
      - 1.7.3 复写
      - 1.7.4 调用父类同名成员
    - 1.8 类型注解
    - - 1.8.1 变量的类型注解
      - 类型注解的限制
      - 1.8.2 函数的类型注解
      - 形参注释
        返回值注释
      - 1.8.3 Union类型
    - 1.9 多态
    - - 1.9.1 抽象类

第一章：

1.初始对象

概念：对象是类(相当模板)的实例，是程序的基本单元,要创建一个新的对象，首先必须定义一个类，用以指明该类型的对象所包含的内容(属性和方法）。

1.1 使用对象组织数据

步骤：

设计类(class)
创建对象
对象属性赋值

# 设计类
class Student:
    name =  None
    age = None

# 创建类对象
s1 = Student()

# 为学生1对象属性赋值
s1.name = "小明"
s1.age = 18

1.2 类的成员方法

1.2.1 类的定义和使用

语法：

class 类名称:
    类的属性

    类的行为

class：关键字，表示要定义类
类的属性：定义在类中的变量(成员变量)
类的行为：定义在类中的函数(成员方法)

1.2.2 创建类对象

语法：对象 = 类名称()

1.2.3 成员变量和成员方法

class Student:
    name = None
    age = None
    def print_Info(self):
        print(f"我的名字{self.name},年龄{self.age}")
stu_1 = Student()
stu_1.name = "小明"
stu_1.age = 18
stu_1.print_Info()

类中不仅可定义属性用来记录数据
类中还可定义函数，用来记录行为
类中定义的属性(变量)，称为成员变量
类中定义的行为(函数)，称为成员方法

1.2.4 成员方法的定义语法

语法：

def 方法名(self, 形参1,.....， 形参N):
     方法体

self关键字是成员方法定义时，必须填写的。

用来表示类对象自身
使用类对象调用方法，self会自动被python传入
在方法内部中，想要去访问类的成员变量，必须使用self

1.2.5 注意事项

class Student:
    name  = None
    age = None
    def print_info(self):
        print(f"我叫{self.name}")
    def print2_info(self, msg):
        print(f"我的年龄是{msg}")
stu = Student()
stu.name = "小明"
stu.print_info()    # 调用时无需传参
stu.print2_info(18) # 调用时需要传msg参数

self关键字，就算是在参数列表中，但传参时可忽略。

1.3 类和对象

1.3.1 基于类创建对象

语法：对象名 = 类名称()

class Clock:
    id = None     # 闹钟编号
    price = None  # 闹钟价格
    def ring(self): # 闹钟响铃
        import winsound
        winsound.Beep(1000, 3000) # (频率， 时间)
clock1 = Clock()
clock1.id = "000001"
clock1.price = 12.9
print(f"闹钟编号{clock1.id}, 价格为{clock1.price}")
clock1.ring()

clock2 = Clock()
clock2.id = "000002"
clock2.price = 15.9
print(f"闹钟编号{clock2.id}, 价格为{clock2.price}")
clock2.ring()

clock3 = Clock()
clock3.id = "000003"
clock3.price = 18.9
print(f"闹钟编号{clock3.id}, 价格为{clock3.price}")
clock3.ring()

1.4 构造方法

__init__(),称为构造方法。

创建类对象的时候，会自动执行。
创建类对象的时候，将传入参数自动传递给构造方法(init)使用。

class Student:
    name = None
    age = None
    def __init__(self, name, age):
        self.age = age
        self.name = name
        print("Student创建了一个对象")
stu = Student("小明",18)
print(stu.name)
print(stu.age)

在这里插入图片描述

1.5 其他内置方法

1.5.1 魔术方法

常见：

__init__ 构造方法
__str__  字符串方法
__lt__   小于、大于符号比较
__le__   小于等于、大于等于符号比较
__eq__   ==符号比较

str字符串方法

作用：控制类转换为字符串。

使用前：

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age
stu = Student("小明", 18)
print(stu)
print(str(stu))

在这里插入图片描述

使用后：

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("小明", 18)
print(stu)
print(str(stu))

在这里插入图片描述

lt小于符号比较方法

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

s1 = Student("小明", 20) # False
s2 = Student("小红", 18) # True
print(s1 < s2)
print(s1 > s2)

le小于等于、大于等于符号比较方法

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

s1 = Student("小明", 20) # False
s2 = Student("小红", 18) # True
s3 = Student("小王", 18) # True

print(s1 <= s2)
print(s1 >= s2)
print(s2 >= s3)

eq比较运算符方法

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __eq__(self, other):
       return self.age == other.age

s1 = Student("小明", 18)
s2 = Student("小红", 18)

print(s1 == s2) # True

1.6 封装

面向对象编程，是很多编程语言都支持的一种编程思想，基于模板去创建实体，使用对象去完成功能的开发。

面向对象包含的3大主要特征：

封装
继承
多态

封装的描述：

成员变量(属性)
成员方法(行为)

1.6.1 私有成员

作用：在类中提供仅供内部使用的属性和方法，而不对外开放。

定义私有成员：

私有成员变量：变量名以__开头(2个下划线)
私有成员方法：方法名以__开头(2个下划线)

class Student:
    name = None
    age =  None
    __id = None  # 私有成员变量

    def __stu_info(self):
        print("-----------") # 私有成员方法

使用私有成员：

私有对象无法直接被类对象所使用

class Student:
    name = None
    age =  None
    __id = None  # 私有成员变量

    def __stu_info(self):
        print("-----------") # 私有成员方法

stu = Student()  # 创建对象
stu.__stu_info() # 使用私有方法

在这里插入图片描述

私有变量无法赋值，也无法获取值

class Student:
    name = None
    age =  None
    __id__stu = None  # 私有成员变量

    def __stu_info(self):
        print("-----------") # 私有成员方法

stu = Student()  # 创建对象
stu.__id__stu = 20    # 私有变量赋值  不报错，但无效
print(stu.__id__stu)  # 获取私有变量值 报错，无法使用

1.7 继承

作用：从父类继承来成员变量和成员方法(不包含私有)

语法：class 类名(父类名):

               类内容体

继承分为单继承和多继承

1.7.1 单继承

class Phone:
    cpu = 'A13'
    screen = 'LG'

    def call_by_4g(self):
        print("4G通话")

class newPhone(Phone):
    battery = None

    def call_by_5g(self):
        print("5G通话")

Phone = newPhone()
print(Phone.cpu)
print(Phone.screen)
Phone.call_by_4g()
Phone.call_by_5g()

1.7.2 多继承

语法：class 类名(父类1，父类2，…父类N):

             类内容体

class Phone:
    producer = 'iP'
    cpu = 'A13'

    def call_by_5g(self):
        print("5G通话")

class NFCReader:
    nfs_type = "第六代"
    producer = "iP"

    def read_card(self):
        print("读卡")
    def write_card(self):
        print("写卡")

class RemoteControl:
    rc_type = "红外遥控"

    def control(self):
        print("开启红外遥控")

class MyPhone(Phone, NFCReader, RemoteControl):
    pass

Phone = MyPhone()
print(Phone.producer)
print(Phone.cpu)
print(Phone.rc_type)
print(Phone.nfs_type)
Phone.call_by_5g()
Phone.read_card()
Phone.write_card()
Phone.control()

1.7.3 复写

子类继承父类的成员属性和成员方法后，如果对其不满意，可进行复写。

在子类中重新定义同名的属性即可。

class Phone:
    producer = "iP"
    cpu = "A13"

    def call_by_5g(self):
        print("父类 - 5G通话")

class newPhone(Phone):
    cpu = "A14"

    def call_by_5g(self):
        print("子类 - 5G通话")

phone = newPhone()
print(phone.cpu) # A14
print(phone.producer) # iP
phone.call_by_5g() # 子类 - 5G通话

1.7.4 调用父类同名成员

复写父类成员后，类对象在调用成员时，会调用复写后的新成员

如果还需要使用被复写的父类中的成员，需要特殊调用方式。

方式1：

使用成员变量：父类名.成员变量

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

方式2：

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

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

class Phone:
    producer = "iP"
    cpu = "A13"

    def call_by_5g(self):
        print("父类 - 5G通话")

class newPhone(Phone):
    cpu = "A14"

    def call_by_5g(self):
        # 方式1
        print(f"父类中的处理器是：{Phone.cpu}")
        Phone.call_by_5g(self)

        # 方式2
        print(f"父类中的处理器是：{super().cpu}")
        super().call_by_5g()

        print("子类 - 5G通话")

phone = newPhone()
phone.call_by_5g()

1.8 类型注解

作用：自动提示可用方法。

功能：

帮助第三方IDE工具，对代码进行类型推断，协助做代码提示
帮助开发者对变量进行类型注释

支持：

变量的类型注解
函数形参泪飙和返回值的类型注解

1.8.1 变量的类型注解

语法：变量 : 类型

# 基础数据类型注解
num_1: int = 10
num_2: float = 3.14
num_3: bool = True
num_4: str = "Hello"

# 类对象类型注解
class Student:
    pass
stu: Student = Student()

# 基础容器类型注解
my_list: list = [11, 12, 13, 14, 15]
my_tuple: tuple = (6, 7, 8, 9, 10)
my_set: set = {1, 2, 3, 4, 5}
my_dict: dict = {"py": 10}
my_str: str = "python"

# 容器类型详细注解
my_list: list[int] = [11, 12, 13, 14, 15]
my_tuple: tuple[int, str, bool] = (6, "th", True)
my_set: set[int] = {1, 2, 3, 4, 5}
my_dict: dict[str, int] = {"py": 10}Student()

语法：#type : 类型

该语法做注解外，在注释中进行类型注解。

# 注释外进行类型注解
import random
num_1 = random.randint(1, 10) # type: int
num_2 = {"gate": "road"}      # type: dict[str, str]
def func():
    return 1
num_3 = func()                # type: int

类型注解的限制

类型注释仅是提示性的，不是决定性的。

num_1: int = "python" # 不会报错
num_2: str = 3.14     # 不会报错

1.8.2 函数的类型注解

形参注释

函数与方法的形参类型注释语法：

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

    pass

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

在这里插入图片描述

返回值注释

语法：

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

    pass

def sub(x:int, y: int) -> int:
    z = x - y
    return z
print(sub(20, 10))

1.8.3 Union类型

作用：可定义联合类型注解

语法：Union[类型,…,类型]

使用Union类型前，需先导包：from typing import Union

from typing import Union

my_list: list[Union[int, str]] = [10, 20, "hello", "python"]
def func(data: Union[int, str]) -> Union[int, str]:
    pass
func()

在这里插入图片描述

1.9 多态

概念：多种形态，完成某个行为时，使用不同的对象得到不同的状态。

以父类做定义声明
以子类做实际工作
用于获取同一行为，不同状态

class Drinking:
    def drink(self):
        pass
class Coffee(Drinking):
    def drink(self):
        print("咖啡")
class Tea(Drinking):
    def drink(self):
        print("茶")
def doWork(drinking: Drinking):
    drinking.drink()

coffee = Coffee()
tea = Tea()

doWork(coffee) # 咖啡
doWork(tea) # 茶

1.9.1 抽象类

1.9代码中的父类Drinking的drink方法是空实现。

该设计的意义：1.父类用来确定有哪些方法 2.具体的实现方法，由子类自行决定

该写法，称为抽象类，也可称为接口。

抽象类：含义抽象方法的类称为抽象类。

抽象方法：方法体为空实现的称为抽象方法。

抽象类好比定义一个标准，包含一些抽象方法，要求子类必须实现。

抽象类配合多态：1可完成抽象的父类设计(设计标准） 2.可完成具体的子类实现(实现标准)

class Drinking:
    def ice(self):
        pass
    def milk(self):
        pass
    def feeding(self):
        pass

class Coffee(Drinking):
    def ice(self):
        print("加冰")
    def milk(self):
        print("加燕麦牛奶")
    def feeding(self):
        print("加少糖")

class Tea(Drinking):
    def ice(self):
        print("加冰")
    def milk(self):
        print("加鲜牛奶")
    def feeding(self):
        print("加七分糖")

def doWork(drinking: Drinking):
    drinking.ice()
    drinking.milk()
    drinking.feeding()

coffee = Coffee()
tea  = Tea()
doWork(coffee)
print("--------")
rinking.feeding()

coffee = Coffee()
tea  = Tea()
doWork(coffee)
print("--------")
doWork(tea)