文章目录
- 类和对象
- 构造方法
- 内置方法
- 封装
- 继承
- 类型注解
- 多态
类只是一种程序内的“设计图纸”,需要基于图纸生产实体(对象),才能正常工作
这种套路,称之为:面向对象编程
类和对象
定义类的语法如下:
class 类名称: class是关键字,表示要定义类了类的属性 类的属性,即定义在类中的变量(成员变量)类的行为 类的行为,即定义在类中的函数(成员方法)
创建实例的语法:
对象名= 类名称() 如: user = User()
类中:
不仅可以定义属性用来记录数据
也可以定义函数,用来记录行为
其中:
类中定义的属性(变量),我们称之为:成员变量
类中定义的行为(函数),我们称之为:成员方法
示例:
class Stu:name = Noneage = Nonedef say_hi(self):print(f"Hi大家好,我是{self.name}")stu = Stu()
stu.name="zhang"
stu.say_hi()
在类中定义成员方法和定义函数基本一致,但仍有细微区别:
可以看到,在方法定义的参数列表中,有一个:self关键字
self关键字是成员方法定义的时候,必须填写的。
它用来表示类对象自身的意思
当我们使用类对象调用方法的是,self会自动被python传入
在方法内部,想要访问类的成员变量,必须使用self
self关键字,尽管在参数列表中,但是传参的时候可以忽略它
构造方法
可以通过 需构造方法:init() 来直接为属性赋值,而不用挨个手工赋值。
class Stu:name = Noneage = Nonedef say_hi(self):print(f"Hi大家好,我是{self.name}")def __init__(self,name,age):self.name=nameself.age=agestu = Stu("zhang",18)
stu.say_hi()
构造方法的名称是:init,注意init前后的2个下划线符号
构造方法的作用:
构建类对象的时候会自动运行
构建类对象的传参会传递给构造方法,借此特性可以给成员变量赋值
注意事项:
构造方法不要忘记self关键字
在方法内使用成员变量需要使用self
内置方法
上文学习的__init__ 构造方法,是Python类内置的方法之一。
这些内置的类方法,各自有各自特殊的功能,这些内置方法我们称之为:魔术方法
str
当类对象需要被转换为字符串之时,会输出如上结果(内存地址)
内存地址没有多大作用,我们可以通过__str__方法,控制类转换为字符串的行为。
class Student:def __init__(self,name,age):self.name=nameself.age=age
stu = Student("zhang",18) #<__main__.Student object at 0x000002400CA789D0>
print(stu)class Student:def __init__(self,name,age):self.name=nameself.age=agedef __str__(self):return f"Student类的对象,name={self.name}age={self.age}"
stu = Student("zhang",18) #Student类的对象,name=zhangage=18
print(stu)
lt
直接对2个对象进行比较是不可以的,但是在类中实现__lt__方法,即可同时完成:小于符号 和 大于符号 2种比较
class Student:def __init__(self,name,age):self.name=nameself.age=agedef __str__(self):return f"Student类的对象,name={self.name};age={self.age}"def __lt__(self, other):return self.age<other.agestu = Student("zhang",18) #Student类的对象,name=zhangage=18
#rint(stu)
stu2 = Student("lisa",19)
print(stu<stu2)#True
le
魔术方法:__le__可用于:<=、>=两种比较运算符上
class Student:def __init__(self,name,age):self.name=nameself.age=agedef __str__(self):return f"Student类的对象,name={self.name};age={self.age}"def __lt__(self, other):return self.age<other.agedef __le__(self, other):return self.age<=other.agestu = Student("zhang",18) #Student类的对象,name=zhangage=18
#rint(stu)
stu2 = Student("lisa",18)
print(stu<=stu2)#true
eq
不实现__eq__方法,对象之间可以比较,但是是比较内存地址,也即是:不同对象==比较一定是False结果。
实现了__eq__方法,就可以按照自己的想法来决定2个对象是否相等了。
class Student:def __init__(self,name,age):self.name=nameself.age=agedef __str__(self):return f"Student类的对象,name={self.name};age={self.age}"def __lt__(self, other):return self.age<other.agedef __le__(self, other):return self.age<=other.agedef __eq__(self, other):return self.name==other.name and self.age == other.agestu = Student("zhang",18) #Student类的对象,name=zhangage=18
#rint(stu)
stu2 = Student("zhang",18)
print(stu==stu2)#true
stu2 = Student("zhang",19)
print(stu==stu2)#false
封装
面向对象编程,是许多编程语言都支持的一种编程思想。
简单理解是:基于模板(类)去创建实体(对象),使用对象完成功能开发。
面向对象包含3大主要特性:封装、继承、多态
封装表示的是,将现实世界事物的:属性、行为
封装到类中,描述为:成员变量、成员方法
从而完成程序对现实世界事物的描述
既然现实事物有不公开的属性和行为,那么作为现实事物在程序中映射的类,也应该支持。
类中提供了私有成员的形式来支持 :私有成员变量、私有成员方法
定义私有成员的方式非常简单,只需要:
私有成员变量:变量名以__
开头(2个下划线)
私有成员方法:方法名以__
开头(2个下划线)
即可完成私有成员的设置
class Student:name=Noneage=None__money=Nonedef __init__(self,name,age,money):self.name=nameself.age=ageself.__money=moneydef add_money(self,add_money):self.__money+=add_moneydef __show_money(self ):print(self.__money)def show_money2(self ):print("showmoney2:",self.__money)stu = Student("zhangsan",19,200)
stu.add_money(100)#只能通过非私有方法去操作私有成员
stu.show_money2() # 300
stu.name="lisa"
stu.__money=1000 # 不报错无效
stu.show_money2() # 300
继承
继承分为:单继承和多继承
继承表示:将从父类那里继承(复制)来成员变量和成员方法(不含私有),不用再重新定义。
class ClasA (ClassB) # 单继承
class ClasA (ClassB,ClassC,ClassD) #多继承,即一个类,可以继承多个父类
多个父类中,如果有同名的成员,那么默认以继承顺序(从左到右)为优先级。
即:先继承的保留,后继承的被覆盖
子类构建的类对象,可以:
有自己的成员变量和成员方法
使用父类的非私有成员变量和成员方法
pass是占位语句,用来保证函数(方法)或类定义的完整性,表示无内容,空的意思
class LittleStudent(Student):littleState=Nonedef __init__(self,name,age,lstate):self.name=nameself.age=ageself.littleState=lstate
lstu=LittleStudent("zhang",10,"little")
lstu.add_money(100)#TypeError: unsupported operand type(s) for +=: 'NoneType' and 'int'
lstu.show_money2()
重写
子类继承父类的成员属性和成员方法后,如果对其“不满意”,那么可以进行复写。
即:在子类中重新定义同名的属性或方法即可。
class Car:color="红色"length=3.6def show_info(self):print("汽车信息:color:",self.color,";length:",self.length)
class BMW(Car):color="蓝色"def show_info(self):print("BMW信息:color:",self.color,";length:",self.length)bmw=BMW()
bmw.show_info()#BMW信息:color: 蓝色 ;length: 3.6
只能在子类内调用父类的同名成员。
子类的类对象直接调用会调用子类复写的成员
一旦复写父类成员,那么类对象调用成员的时候,就会调用复写后的新成员
如果需要使用被复写的父类的成员,需要特殊的调用方式:
调用父类成员
使用成员变量:父类名.成员变量
使用成员方法:父类名.成员方法(self)
使用super()调用父类成员
使用成员变量:super().成员变量
使用成员方法:super().成员方法()
class Car:color="红色"length=3.6def show_info(self):print("汽车信息:color:",self.color,";length:",self.length)
class BMW(Car):color = "蓝色"def show_info(self):Car.show_info() #汽车信息:color: 蓝色 ;length: 3.6print(super().color)#红色print("BMW信息:color:",self.color,";length:",self.length)bmw=BMW()
bmw.show_info()#BMW信息:color: 红色 ;length: 3.6
类型注解
为什么PyCharm工具能够正确的提示方法的参数类型、方法名称的?
它是如何知道这个对象有append方法?
因为:PyCharm确定这个对象的类型,是list类型
同样,我们换一份代码:
定义一个函数func,接收一个参数data
PyCharm不会在做出任何提示了
为什么内置模块random的方法可以提示类型
自己定义的就不可以?
因为PyCharm无法通过代码
确定应传入什么类型
Python在3.5版本的时候引入了类型注解,以方便静态类型检查工具,IDE等第三方工具。
类型注解:在代码中涉及数据交互的地方,提供数据类型的注解(显式的说明)。
主要功能:
帮助第三方IDE工具(如PyCharm)对代码进行类型推断,协助做代码提示
帮助开发者自身对变量进行类型注释
支持:
变量的类型注解
函数(方法)形参列表和返回值的类型注解
变量的类型注解
语法
变量: 类型
元组类型设置类型详细注解,需要将每一个元素都标记出来
字典类型设置类型详细注解,需要2个类型,第一个是key第二个是value
print("="*20)#false
var1:int =10
var2:bool=False
var3:str="123"
stu:Student = Student()
my_list:list=[1,2,3]
my_tuple:tuple=(1,2,3)
my_set:set[int]={2,3,4}#容器类型详细注解
my_tuple2:tuple[int,str,bool]=(1,"123",False) #容器类型详细注解
除了使用 变量: 类型, 这种语法做注解外,也可以在注释中进行类型注解。
语法:# type:类型
var3 =10 # type:int
my_dict={"zhang":18} #type:dict[str,int]
一般,无法直接看出变量类型之时会添加变量的类型注解
var4:Student=func()
类型注解主要功能在于:
帮助第三方IDE工具(如PyCharm)对代码进行类型推断,协助做代码提示
帮助开发者自身对变量进行类型注释(备注)
并不会真正的对类型做验证和判断。
也就是,类型注解仅仅是提示性的,不是决定性的
如下代码,是不会报错的哦。
var1:int ="123123"
函数(方法)形参列表和返回值的类型注解
在编写函数(方法),使用形参data的时候,工具没有任何提示
在调用函数(方法),传入参数的时候,工具无法提示参数类型
这些都是因为,我们在定义函数(方法)的时候,没有给形参进行注解
函数和方法的形参类型注解语法
def test_type(a:int,b:int,c:int,d:int):pass
def add(a:int,b:int):return a+b
同时,函数(方法)的返回值也是可以添加类型注解的。
语法如下
def add(a:int,b:int)->int:return a+b
print(add(1,2))
Union类型
使用Union[类型, …, 类型]
可以定义联合类型注解
Union联合类型注解,在变量注解、函数(方法)形参和返回值注解中,均可使用。
多态
多态,指的是:多种状态,即完成某个行为时,使用不同的对象会得到不同的状态
多态常作用在继承关系上.比如
函数(方法)形参声明接收父类对象
实际传入父类的子类对象进行工作
即:
以父类做定义声明
以子类做实际工作
用以获得同一行为, 不同状态
这种设计的含义是:
父类用来确定有哪些方法
具体的方法实现,由子类自行决定
这种写法,就叫做抽象类(也可以称之为接口)
抽象类:含有抽象方法的类称之为抽象类
抽象方法:方法体是空实现的(pass)称之为抽象方法