devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Python学习笔记--面向对象_python面向对象12篇周记

作者：从前慢现在也慢 | 2024-05-30 15:54:41

赞

踩

python面向对象12篇周记

未完待续。。。。。

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

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

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

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

1.1过程和函数

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

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

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

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

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

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

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

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

特点

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

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

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

 

 

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

 

 （二）类的成员方法

1.类的定义和使用

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

  1. class 类名称：
  2. 	类的属性
  3. 	类的行为

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

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

成员方法的定义语法

  1. # 定义一个带有成员方法的类
  2. class Student:
  3.     name= None
  4.     def say_hi(self):
  5.         print(f"大家好啊,我是{self.name},欢迎大家多多关照")
  6.  
  7.         stu1 = Student()
  8.         stu1.name="王五"
  9.         stu1.say_hi()
  1. # 定义一个带有成员方法的类
  2. class Student:
  3.     name= None
  4.     # def say_hi(self):
  5.     #     print(f"大家好啊,我是{self.name},欢迎大家多多关照")
  6.     def say_hi(self,msg):
  7.         print(f"大家好啊,我是{self.name},{msg}")
  8.  
  9.         stu1 = Student()
  10.         stu1.name="王五"
  11.         stu1.say_hi("哎哟不错哟")

（三）类和对象

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

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

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

  1. if __name__ == '__main__':
  2.     # 设计一个闹钟类
  3.     class Clock:
  4.         id = None # 序列化
  5.         price = None  # 价格
  6.  
  7.         def ring(self):
  8.             import winsound
  9.             winsound.Beep(2000,3000)
  10.  
  11.  
  12.     # 构建2个闹钟对象并让其工作
  13.     clock1 = Clock()
  14.     clock1.id = "003032"
  15.     clock1.price = 19.99
  16.     print(f"闹钟ID: {clock1.id}， 价格: {clock1.price}")
  17.     clock1.ring()
  18.     #######################################
  19.     clock2 = Clock()
  20.     clock2.id = "003033"
  21.     clock2.price = 21.99
  22.     print(f"闹钟ID: {clock2.id}， 价格: {clock2.price}")
  23.     clock2.ring()

 （四）构造方法

 

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

  1. """
  2. 演示类的构造方法
  3. """
  4. # 演示使用构造方法对成员变量进行赋值
  5. # 构造方法的名称__init__
  6. if __name__ == '__main__':
  7.     class Student:
  8.         def __init__(self, name,age, tel):
  9.             self.name = name
  10.             self.age = age
  11.             self.tel = tel
  12.             print("Student类创建了一个类对象")
  13.     stu = Student("周杰轮",31, "18500006666")
  14.     print(stu.name)
  15.     print(stu.tel)
  16.     print(stu.age)

 

 （五）魔术方法

 __ str __

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

  __ lt __小于比较符号方法

  1. if __name__ == '__main__':
  2.     class Student:
  3.         def __init__(self, name, age):
  4.             self.name = name# 学生姓名
  5.             self.age = age# 学生年龄
  6.         # __ str__魔术方法
  7.         def __str__(self):
  8.             return f"Student类对象，name:{self.name}, age:{self.age}"
  9.  
  10.         #__lt__魔术方法.
  11.         def __lt__(self,other):
  12.             return self.age < other.age
  13.  
  14.     stu1 = Student("周杰轮",31)
  15.     stu2 = Student("周轮", 3)
  16.     print(stu1<stu2)
  17.     print(stu1>stu2)

 _le_小于等于比较符号方法

  1. if __name__ == '__main__':
  2.     class Student:
  3.         def __init__(self, name, age):
  4.             self.name = name# 学生姓名
  5.             self.age = age# 学生年龄
  6.         # __ str__魔术方法
  7.         def __str__(self):
  8.             return f"Student类对象，name:{self.name}, age:{self.age}"
  9.  
  10.         #__lt__魔术方法.
  11.         def __lt__(self,other):
  12.             return self.age < other.age
  13.         #__le__魔术方法.
  14.         def __le__(self,one):
  15.             return self.age<=one.age
  16.  
  17.     stu1 = Student("周杰轮",31)
  18.     stu2 = Student("周轮", 35)
  19.     print(stu1<=stu2)
  20.     print(stu1>=stu2)

_eq_，比较运算符实现方法 

  1. if __name__ == '__main__':
  2.     class Student:
  3.         def __init__(self, name, age):
  4.             self.name = name# 学生姓名
  5.             self.age = age# 学生年龄
  6.         # __ str__魔术方法
  7.         def __str__(self):
  8.             return f"Student类对象，name:{self.name}, age:{self.age}"
  9.  
  10.         #__lt__魔术方法.
  11.         def __lt__(self,other):
  12.             return self.age < other.age
  13.         #__le__魔术方法.
  14.         def __le__(self,one):
  15.             return self.age<=one.age
  16.         #__eq__魔术方法.
  17.         def __eq__(self, other):
  18.             return self.age == other.age
  19.     stu1 = Student("周杰轮",31)
  20.     stu2 = Student("周轮", 31)
  21.     print(stu1==stu2)

（六）封装

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

封装

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

  1. if __name__ == '__main__':
  2.     class Phone:
  3.         __current_voltage = 0.5
  4.         # 当前手机运行电压
  5.         def __keep_single_core(self):
  6.             print("让CPU以单核模式运行")
  7.  
  8.  
  9.         def call_by_5g(self):
  10.             if self.__current_voltage >= 1:
  11.                 print("5g通话已开启")
  12.             else:
  13.                 self.__keep_single_core()
  14.                 print("电量不足，无法使用5g通话，并已设置为单核运行进行省电。")
  15.  
  16.     phone = Phone()
  17.     phone.call_by_5g()

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

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

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

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

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

  1. if __name__ == '__main__':
  2.     class Phone:
  3.         # 提供私有成员变量:__ is_ 5g_ enabZe
  4.         __is_5g_enable = False
  5.         # 5g状态
  6.         # 提供私有成员方法: __ check_ 5g()
  7.         def __check_5g(self):
  8.             if self.__is_5g_enable:
  9.                 print("5g开启")
  10.             else:
  11.                 print("5g关闭，使用4g网络")
  12.         # 提供公开成员方法: call_by_5g()
  13.         def call_by_5g(self):
  14.             self.__check_5g()
  15.             print("正在通话中")
  16.     phone = Phone()
  17.     phone.call_by_5g()
  18.

 (七)继承

1.单继承：

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

  1. class 类名(父类名):
  2. 	类内容体
  1.  
  2. # 演示单继承
  3.  
  4. class Phone:
  5.     IMEI = None  # 序列号
  6.     producer="huawei"  # 厂商
  7.  
  8.     def call_by_4g(self):
  9.         print("4g通话")
  10.  
  11. class Phone2023(Phone):
  12.     face_id="1001" # 面部识别
  13.  
  14.     def call_by_5g(self):
  15.         print("2023新功能")
  16.  
  17. phone=Phone2023()
  18. print(phone.producer)
  19. phone.call_by_4g()
  20. phone.call_by_5g()

 2.多继承：

  1.  
  2. # 演示多继承
  3.  
  4. class Phone:
  5.     IMEI = None  # 序列号
  6.     producer="huawei"  # 厂商
  7.  
  8.     def call_by_4g(self):
  9.         print("4g通话")
  10.  
  11. class NFC:
  12.     nfc_type = "第五代"
  13.     producer = "小米"
  14.  
  15.     def read_card(self):
  16.         print("NFC读卡")
  17.  
  18.     def write_card(self):
  19.         print("NFC写卡")
  20.  
  21. class RemotrControl:
  22.     rc_type = "红外遥控"
  23.  
  24.     def control(self):
  25.         print("红外遥控开启")
  26.  
  27. class MyPhone(Phone,NFC,RemotrControl):
  28.     pass  #pass在这里的功能就是补全代码，因为想的是MyPhone继承很多父类了，不想写了，于是用pass补全
  29.  
  30. phone = MyPhone()
  31. phone.call_by_4g()
  32. phone.read_card()
  33. phone.write_card()
  34. phone.control()

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

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

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

  1. #  复写
  2.  
  3. if __name__ == '__main__':
  4.     class Phone:
  5.         IMEI = None  # 序列号
  6.         producer = "ITCAST"  # 厂商
  7.         def call_by_5g(se1f):
  8.             print("父类的5g通话")
  9.  
  10.  
  11.     class MyPhone(Phone):
  12.         proucer = "ITHEIMA"
  13.         # 复写父类属性
  14.         def call_by_5g(se1f):
  15.             # 复写父类方法
  16.             print("子类的5g通话")
  17.  
  18.     phone = MyPhone()
  19.     print(phone.proucer)
  20.     phone.call_by_5g()
  21.

 

  1. if __name__ == '__main__':
  2.     class Phone:
  3.         IMEI = None # 序列号
  4.         producer = "ITCAST"  # 厂商
  5.         def call_by_5g(se1f):
  6.             print("父类的5g通话")
  7.  
  8.  
  9.     class MyPhone(Phone):
  10.         proucer = "ITHEIMA"
  11.         # 复写父类属性
  12.         def call_by_5g(se1f):
  13.             # 方式1
  14.             print(f"父类的厂商是：{Phone.producer}")
  15.             # 复写父类方法
  16.             print("子类的5g通话")
  17.             Phone.call_by_5g(se1f)
  18.             # 方式2
  19.             print(f"父类的厂商是：{super().producer}")
  20.             super().call_by_5g()
  21.     phone = MyPhone()
  22.     print(phone.proucer)
  23.     phone.call_by_5g()
  24.  
  25.  
  26.

 （九）变量的类型注解

  1. if __name__ == '__main__':
  2.     # 基础数据类型注解
  3.     var_1: int = 10
  4.     var_2: str = "itheima"
  5.     var_3: bool = True
  6.     # 类对象类型注解
  7.     class Student:
  8.         pass
  9.     stu:Student = Student()
  10.     # 基础容器类型注解.
  11.     my_list: list = [1, 2, 3]
  12.     my_tupLe: tuple = (1, 2,3)
  13.     my_dict: dict = {"itheima": 666}
  14.  
  15.     # 在注释中进行类型注解
  16.     my_list: list[int]= [1,2, 3] #type:list
  17.     my_tuple: touple[int,str,bool]= ("itheima", 666, True)#type:tuple[str, int, bool]
  18.  
  19.     # 类型注解的限制
  20.     var_7: str = 10 #没事 但是是给自己看的

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

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

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

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

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

Union联合类型注解

Union类型

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

（十一）多态

 

  1. #  演示抽象类
  2. class AC:
  3.     def cool_wind(self):
  4.         """制冷"""
  5.         pass
  6.     def hot_wind(self):
  7.         """制热"""
  8.         pass
  9.     def swing_l_r(self):
  10.         """左右摇摆"""
  11.         pass
  12.     
  13.     class Midea_AC(AC):
  14.         def cool_wind(self):
  15.             print("美的空调制冷")
  16.         def hot_wind(self):
  17.             print("美的空调制热")
  18.         def swing_l_r(self):
  19.             print("美的空调左右摇摆")
  20.             
  21.     class GREE_AC(AC):
  22.         def cool_wind(self):
  23.             print("格力空调制冷")
  24.         def hot_wind(self):
  25.              print("格力空调制热")
  26.         def swing_l_r(self):
  27.              print("格力空调左右摇摆")
  28.             
  29. def make_cool(ac:AC):
  30.     ac.cool_wind()
  31.  
  32.     midea_ac=Midea_AC()
  33.     gree_ac=GREE_AC()
  34.  
  35.     make_cool(midea_ac)
  36.     make_cool(gree_ac)

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/647642
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号