未完待续。。。。。
(一)面向对象的基本概念
我们之前学习的编程方式就是面向过程的
面相过程和面相对象,是两种不同的编程方式
对比面向过程的特点,可以更好地了解什么是面向对象
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)