Python学习笔记--面向对象

追着太阳跑哈

已于 2023-06-23 11:42:04 修改

阅读量672

点赞数

分类专栏： Python 文章标签：学习笔记 python 开发语言算法

于 2023-04-21 22:43:34 首次发布

本文链接：https://blog.csdn.net/m0_63654706/article/details/130296831

版权

Python 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

未完待续。。。。。

（一）面向对象的基本概念

我们之前学习的编程方式就是面向过程的

面相过程和面相对象，是两种不同的编程方式

对比面向过程的特点，可以更好地了解什么是面向对象

1.1过程和函数

过程是早期的一个编程概念

过程类似于函数，只能执行，但是没有返回值

函数不仅能执行，还可以返回结果

1.2面相过程和面相对象基本概念

1)面相过程——怎么做?

1.把完成某一个需求的所有步骤从头到尾逐步实现

⒉.根据开发需求，将某些功能独立的代码封装成一个又一个函数

3.最后完成的代码，就是顺序地调用不同的函数

特点

1.注重步骤与过程，不注重职责分工

2.如果需求复杂，代码会变得很复杂

3.开发复杂项目，没有固定的套路，开发难度很大!

# 1.设计一个类（类比生活中：设计一张登记表）
class Student:
    name=None  # 记录学生姓名
    gender=None # 记录学生性别
    nationality=None # 记录学生国籍
    native_place=None # 记录学生籍贯
    age=None # 记录学生年龄
# 2.创建一个对象（类比生活中：打印一张登记表）
stu_1=Student()
# 3.对象属性进行赋值（类比生活中：填写表单）
stu_1.name = "林军杰"
stu_1.gender = "男"
stu_1.nationality = "中国"
stu_1.native_place = "山东省"
stu_1.age = 31
# 4.获取对象中记录的信息
print(stu_1.name )
print(stu_1.gender)
print(stu_1.nationality)
print(stu_1.native_place)
print(stu_1.age)

（二）类的成员方法

1.类的定义和使用

在上一节中，我们简单了解到可以使用类去封装属性，并基于类创建出一一个个的对象来使用。
现在我们来看看类的使用语法：

class 类名称：
	类的属性
	类的行为

●class是关键字，表示要定义类了
●类的属性,即定义在类中的变量(成员变量)
● 类的行为，即定义在类中的函数(成员方法)
创建类对象的语法对象=类名称()

类内部的函数叫（成员）方法，不叫函数。

成员方法的定义语法

# 定义一个带有成员方法的类
class Student:
    name= None
    def say_hi(self):
        print(f"大家好啊,我是{self.name},欢迎大家多多关照")

        stu1 = Student()
        stu1.name="王五"
        stu1.say_hi()

# 定义一个带有成员方法的类
class Student:
    name= None
    # def say_hi(self):
    #     print(f"大家好啊,我是{self.name},欢迎大家多多关照")
    def say_hi(self,msg):
        print(f"大家好啊,我是{self.name},{msg}")

        stu1 = Student()
        stu1.name="王五"
        stu1.say_hi("哎哟不错哟")

（三）类和对象

基于类创建对象的语法:对象名=类名称()
为什么非要创建对象才能使用呢?
类只是一种程序内的“设计图纸”,需要基于图纸生产实体(对象),才能正常工作，面向对象编程！！！！

设计类——就是让类干活！

下面代码有声音欧耳机党小心！！！！！

if __name__ == '__main__':
    # 设计一个闹钟类
    class Clock:
        id = None # 序列化
        price = None  # 价格

        def ring(self):
            import winsound
            winsound.Beep(2000,3000)


    # 构建2个闹钟对象并让其工作
    clock1 = Clock()
    clock1.id = "003032"
    clock1.price = 19.99
    print(f"闹钟ID: {clock1.id}， 价格: {clock1.price}")
    clock1.ring()
    #######################################
    clock2 = Clock()
    clock2.id = "003033"
    clock2.price = 21.99
    print(f"闹钟ID: {clock2.id}， 价格: {clock2.price}")
    clock2.ring()

（四）构造方法

之所以可以省略是因为方法中，self.属性名=属性名起到了给成员变量声明且赋值，写了的话那就只是赋值

"""
演示类的构造方法
"""
# 演示使用构造方法对成员变量进行赋值
# 构造方法的名称__init__
if __name__ == '__main__':
    class Student:
        def __init__(self, name,age, tel):
            self.name = name
            self.age = age
            self.tel = tel
            print("Student类创建了一个类对象")
    stu = Student("周杰轮",31, "18500006666")
    print(stu.name)
    print(stu.tel)
    print(stu.age)

（五）魔术方法

str

if __name__ == '__main__':
    class Student:
        def __init__(self, name, age):
            self.name = name# 学生姓名
            self.age = age# 学生年龄
        # __ str__魔术方法
        def __str__(self):
            return f"Student类对象，name:{self.name}, age:{self.age}"
    stu = Student("周杰轮",31)
    print(stu)
    print(str(stu))

lt 小于比较符号方法

if __name__ == '__main__':
    class Student:
        def __init__(self, name, age):
            self.name = name# 学生姓名
            self.age = age# 学生年龄
        # __ str__魔术方法
        def __str__(self):
            return f"Student类对象，name:{self.name}, age:{self.age}"

        #__lt__魔术方法.
        def __lt__(self,other):
            return self.age < other.age

    stu1 = Student("周杰轮",31)
    stu2 = Student("周轮", 3)
    print(stu1<stu2)
    print(stu1>stu2)

_le_小于等于比较符号方法

if __name__ == '__main__':
    class Student:
        def __init__(self, name, age):
            self.name = name# 学生姓名
            self.age = age# 学生年龄
        # __ str__魔术方法
        def __str__(self):
            return f"Student类对象，name:{self.name}, age:{self.age}"

        #__lt__魔术方法.
        def __lt__(self,other):
            return self.age < other.age
        #__le__魔术方法.
        def __le__(self,one):
            return self.age<=one.age

    stu1 = Student("周杰轮",31)
    stu2 = Student("周轮", 35)
    print(stu1<=stu2)
    print(stu1>=stu2)

_eq_，比较运算符实现方法

if __name__ == '__main__':
    class Student:
        def __init__(self, name, age):
            self.name = name# 学生姓名
            self.age = age# 学生年龄
        # __ str__魔术方法
        def __str__(self):
            return f"Student类对象，name:{self.name}, age:{self.age}"

        #__lt__魔术方法.
        def __lt__(self,other):
            return self.age < other.age
        #__le__魔术方法.
        def __le__(self,one):
            return self.age<=one.age
        #__eq__魔术方法.
        def __eq__(self, other):
            return self.age == other.age
    stu1 = Student("周杰轮",31)
    stu2 = Student("周轮", 31)
    print(stu1==stu2)

（六）封装

面向对象的三大特性
面向对象编程，是许多编程语言都支持的一种编程思想。
简单理解是:基于模板(类)去创建实体(对象) ,使用对象完成功能开发。
面向对象包含3大主要特性：
➢封装
➢继承
➢多态

封装

怎么理解这些属性和行为不能用而变的可以用呢，就类似于苹果越狱和安卓root的行为，我们想获取他不想让我们看到的东西。

if __name__ == '__main__':
    class Phone:
        __current_voltage = 0.5
        # 当前手机运行电压
        def __keep_single_core(self):
            print("让CPU以单核模式运行")


        def call_by_5g(self):
            if self.__current_voltage >= 1:
                print("5g通话已开启")
            else:
                self.__keep_single_core()
                print("电量不足，无法使用5g通话，并已设置为单核运行进行省电。")

    phone = Phone()
    phone.call_by_5g()

****也就是说私有的只可以让我们内部使用，到了外部，也就是类对象哪里是没有办法访问的，只能通过访问公开的成员来间接访问 ****

1.封装的概念是指?
将现实世界事物在类中描述为属性和方法,即为封装。

2.什么是私有成员?为什么需要私有成员?
现实事物有部分属性和行为是不公开对使用者开放的。同样在类中描述
属性和方法的时候也需要达到这个要求，就需要定义私有成员了

3.如何定义私有成员?
成员变量和成员方法的命名均以__作为开头即可

4.私有成员的访问限制?
类对象无法访问私有成员
类中的其它成员可以访问私有成员

if __name__ == '__main__':
    class Phone:
        # 提供私有成员变量:__ is_ 5g_ enabZe
        __is_5g_enable = False
        # 5g状态
        # 提供私有成员方法: __ check_ 5g()
        def __check_5g(self):
            if self.__is_5g_enable:
                print("5g开启")
            else:
                print("5g关闭，使用4g网络")
        # 提供公开成员方法: call_by_5g()
        def call_by_5g(self):
            self.__check_5g()
            print("正在通话中")
    phone = Phone()
    phone.call_by_5g()

(七)继承

1.单继承：

class phone2022(phone)这个类会包含了phone类的所有变量和方法

class 类名(父类名):
	类内容体


# 演示单继承

class Phone:
    IMEI = None  # 序列号
    producer="huawei"  # 厂商

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

class Phone2023(Phone):
    face_id="1001" # 面部识别

    def call_by_5g(self):
        print("2023新功能")

phone=Phone2023()
print(phone.producer)
phone.call_by_4g()
phone.call_by_5g()

2.多继承：


# 演示多继承

class Phone:
    IMEI = None  # 序列号
    producer="huawei"  # 厂商

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

class NFC:
    nfc_type = "第五代"
    producer = "小米"

    def read_card(self):
        print("NFC读卡")

    def write_card(self):
        print("NFC写卡")

class RemotrControl:
    rc_type = "红外遥控"

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

class MyPhone(Phone,NFC,RemotrControl):
    pass  #pass在这里的功能就是补全代码，因为想的是MyPhone继承很多父类了，不想写了，于是用pass补全

phone = MyPhone()
phone.call_by_4g()
phone.read_card()
phone.write_card()
phone.control()

其中pass关键字是补全语法。让语法补充，避免错误。当输出同名属性时，以前面为准，听大爸的。但是却不能空着不写，哪怕你写成face_id=”1001“，最后答案也是一样的。

注意，当继承多个父类，比如父类Phone中producer="huawei" ，NFC中producer = "小米"，那么子类在调用属性时print(phone.producer)=huawei,因为父类Phone在前先执行！

（八）复写父类成员和调用父类成员

#  复写

if __name__ == '__main__':
    class Phone:
        IMEI = None  # 序列号
        producer = "ITCAST"  # 厂商
        def call_by_5g(se1f):
            print("父类的5g通话")


    class MyPhone(Phone):
        proucer = "ITHEIMA"
        # 复写父类属性
        def call_by_5g(se1f):
            # 复写父类方法
            print("子类的5g通话")

    phone = MyPhone()
    print(phone.proucer)
    phone.call_by_5g()

if __name__ == '__main__':
    class Phone:
        IMEI = None # 序列号
        producer = "ITCAST"  # 厂商
        def call_by_5g(se1f):
            print("父类的5g通话")


    class MyPhone(Phone):
        proucer = "ITHEIMA"
        # 复写父类属性
        def call_by_5g(se1f):
            # 方式1
            print(f"父类的厂商是：{Phone.producer}")
            # 复写父类方法
            print("子类的5g通话")
            Phone.call_by_5g(se1f)
            # 方式2
            print(f"父类的厂商是：{super().producer}")
            super().call_by_5g()
    phone = MyPhone()
    print(phone.proucer)
    phone.call_by_5g()

（九）变量的类型注解

if __name__ == '__main__':
    # 基础数据类型注解
    var_1: int = 10
    var_2: str = "itheima"
    var_3: bool = True
    # 类对象类型注解
    class Student:
        pass
    stu:Student = Student()
    # 基础容器类型注解.
    my_list: list = [1, 2, 3]
    my_tupLe: tuple = (1, 2,3)
    my_dict: dict = {"itheima": 666}

    # 在注释中进行类型注解
    my_list: list[int]= [1,2, 3] #type:list
    my_tuple: touple[int,str,bool]= ("itheima", 666, True)#type:tuple[str, int, bool]

    # 类型注解的限制
    var_7: str = 10 #没事 但是是给自己看的

（十）函数和方法类型注解

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

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

同时，函数(方法)的返回值也是可以添加类型注解的。

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

Union联合类型注解

Union类型

"""
使用union联合类型注解
"""
# 使用union类型，必须先导包
from typing import Union
my_list: list[Union[int,str]] = [1,2,"itheima","itcat"]
def func(data:Union[int,str]) ->Union[int,str]:
    pass
func()

（十一）多态

#  演示抽象类
class AC:
    def cool_wind(self):
        """制冷"""
        pass
    def hot_wind(self):
        """制热"""
        pass
    def swing_l_r(self):
        """左右摇摆"""
        pass
    
    class Midea_AC(AC):
        def cool_wind(self):
            print("美的空调制冷")
        def hot_wind(self):
            print("美的空调制热")
        def swing_l_r(self):
            print("美的空调左右摇摆")
            
    class GREE_AC(AC):
        def cool_wind(self):
            print("格力空调制冷")
        def hot_wind(self):
             print("格力空调制热")
        def swing_l_r(self):
             print("格力空调左右摇摆")
            
def make_cool(ac:AC):
    ac.cool_wind()

    midea_ac=Midea_AC()
    gree_ac=GREE_AC()

    make_cool(midea_ac)
    make_cool(gree_ac)