当前位置：首页 > news >正文

python学习笔记-10

news 来源：原创 2024/9/28 13:08:57

面向对象编程-下

1.私有化属性

语法：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。

使用私有化属性的场景：
1.把特定的一个属性隐藏起来，不让类的外部进行直接调用。
2.不让属性的值随意改变。
3.不让子类继承。

class Person():def __init__(self):self.name='里斯'self.age=30passpass
xl=Person()
print(xl.name)
#私有化
class Pri():def __init__(self):self.__name='李四'  #如此外界就访问不到了,但是在内部可以访问到self.age=12passdef __str__(self):return '{}的年龄是{}'.format(self.__name,self.age)pass
ll=Pri()
print(ll)
print(ll.__name)

在这里插入图片描述

#私有化
class Pri():def __init__(self):self.__name='李四'  #如此外界就访问不到了,但是在内部可以访问到self.age=12passdef __str__(self):return '{}的年龄是{}'.format(self.__name,self.age)pass
class Student(Pri):def pri(self):print(self.__name)  ##同样的，子类也访问不到私有属性passpass
stu=Student()
stu.pri()

在这里插入图片描述
小结：
1.私有化的实例属性和类属性不能在外部直接访问，可以在类的内部随意访问。
2.子类不能继承父类的私有化属性，只能继承父类中公开的属性和行为。
3.如果想将属性私有化，直接在属性名的前面加两个下划线’__'就可以了。
4.私有化属性的值可以在类内部修改。

2.私有化方法

私有化方法即在方法名前面加两个下划线。

class Animal:def eat(self):print('吃')passdef run(self):print('跑')passpass
class Bird(Animal):pass
b1=Bird()
b1.eat()
b1.run()
#私有化方法
class Pr():def __eat(self):print('私有化的吃')passdef run(self):self.__eat()print('跑')passpass
b2=Pr()
b2.run()
b2.__eat()

在这里插入图片描述

私有化方法一般是类内部调用，子类不能继承，外部不能调用

前面一个单下划线：标识protected类型即保护类型的变量，只能允许其本身与子类进行访问，不能使用from ... import *的方式导入
前后两个双下划线：魔法方法
后面单下划线：避免属性名与python关键字冲突
前面双下划线：私有化，private

#访问私有变量的话一般写两个方法，一个访问一个修改，由方法去控制访问
class Person:def __init__(self):self.__age=19passdef get_age(self):   #访问return self.__agedef set_age(self,age):     #修改if age<0:  print('年龄不能小于0')passelse:self.__age=agepasspasspass
p=Person()
p.set_age(12)
print(p.get_age())
p2=Person()
p.set_age(-1)

在这里插入图片描述

3.属性函数property

若想直接像访问公共属性一样访问私有属性而不是如同上述使用方法访问私有属性，可以使用属性函数。
法一：

#访问私有变量的话一般写两个方法，一个访问一个修改，由方法去控制访问
class Person:def __init__(self):self.__age=19passdef get_age(self):return self.__agedef set_age(self,age):if age<0:print('年龄不能小于0')passelse:self.__age=agepasspass#定义一个类属性，实现通过直接访问属性的形式去访问私有的属性age=property(get_age,set_age)pass
p=Person()
print(p.age)
p.age=25
print(p.age)

在这里插入图片描述
法二：使用装饰器

#访问私有变量的话一般写两个方法，一个访问一个修改，由方法去控制访问
class Person:def __init__(self):self.__age=12@property   #用装饰器添加属性标识,提供一个getter方法def age(self):return self.__age@age.setter   #提供一个setter方法def age(self,parms):   #修改私有属性的值，parms也就是后传入想要修改成的ageif parms<0:print('年龄不能小于0')passelse:self.__age=parmspasspasspass
p1=Person()
print(p1.age)
p1.age=20
print(p1.age)

在这里插入图片描述

4.new方法

在这里插入图片描述

5.单例模式

单例模式是常用软件设计模式的一种，目的是确保某一个类中只有一个实例存在。如果希望在某个系统中，某个类只能出现一个实例，整个单例模式就能满足要求。

#创建一个单例对象 基于__new__实现
class DataBaseClass(object):def __new__(cls, *args, **kwargs):#cls._instance=cls.__new__(cls)   不能使用自己的new方法，容易造成递归死循环，应该调用父类的new方法if not hasattr(cls,'_instance'):  #如果不存在就创建cls._instance=super().__new__(cls,*args,**kwargs)return cls._instancepass
db1=DataBaseClass()
print(id(db1))
db2=DataBaseClass()
print(id(db2))   #可以看出来都是一个对象
class DBoptSingle(DataBaseClass):pass
d1=DBoptSingle()
print(id(d1))
d2=DBoptSingle()
print(id(d2))   #子类继承后也都是一个

在这里插入图片描述

6.错误与异常处理

有时候代码写错了执行程序的时候，执行到错误代码程序会直接种植报错，这是因为python检测到一个错误时，解释器就无法继续执行了，出现了错误的提示，这就是“异常”。

#语法格式：
try：可能出现错误的代码块
except：出错之后执行的代码块
else：没有出错的代码块
finally：不管有没有出错都执行的代码块将可能出错的代码放到try里面，except可以指定类型捕获异常。except里面的代码是捕获到异常时执行。

#异常处理
try:print(b)  #要捕获异常的代码pass
except NameError as msg:   #将异常信息输出#处理异常，捕获到异常就来这里print(msg)pass
print('处理好了Name异常')

在这里插入图片描述
如果不是一个类型的异常是不会捕获的

#异常处理
try:li=[1,2,3,3]  #要捕获异常的代码print(li[10])pass
except NameError as msg:#处理错误，捕获到错误就来这里print(msg)pass   
print('处理好了Name异常')

在这里插入图片描述
因为是index异常而不是name异常，所以try-except语句没起到捕获异常的作用。

#异常处理
try:li=[1,2,3,3]  #要捕获异常的代码print(li[10])pass
except NameError as msg:#处理错误，捕获到错误就来这里print(msg)pass
except IndexError as msg:print(msg)pass
print('处理好了异常')

在这里插入图片描述
这样就捕获到了。

在这里插入图片描述
python中内置的异常类型👆

#异常处理
try:li=[1,2,3,3]  #要捕获异常的代码print(li[10])pass
except Exception as msg:  #可以直接抛出所有异常#处理错误，捕获到错误就来这里print(msg)pass
print('处理好了异常')

在这里插入图片描述 Exception可以捕获所有异常。

def A(s):return 10/int(s)
def B(a):return 2*A(a)
def main():try:B(0)passexcept Exception as msg:print(msg)passpass
main()
#不用在每个可能出异常的地方去捕获，可以嵌套捕获

在这里插入图片描述

try:print(a)pass
except Exception as msg:print(msg)pass
else:print('当没异常我才执行')pass
finally:print('不管怎样我都会执行')print('=========================')
try:a=1print(a)pass
except Exception as msg:print(msg)pass
else:print('当没异常我才执行')pass
finally:print('不管怎样我都会执行')

在这里插入图片描述
自定义异常： 直接或间接继承Error或Exception类，由开发者主动抛出自定义异常，在python中使用raise关键字。

抛出自定义异常：

#自定义异常
class ToolongMyException(Exception):def __init__(self,len):''':param len: 长度'''self.len=lenpassdef __str__(self):return '您输入的数据长度是{}，超过长度了'.format(self.len)pass
while True:name = input('请输入姓名：')if len(name) > 5:raise ToolongMyException(len(name))else:print(name)pass

在这里插入图片描述
捕获自定义异常：

#自定义异常
class ToolongMyException(Exception):def __init__(self,len):''':param len: 长度'''self.len=lenpassdef __str__(self):return '您输入的数据长度是{}，超过长度了'.format(self.len)pass
while True:name = input('请输入姓名：')try:if len(name) > 5:raise ToolongMyException(len(name))else:print(name)passexcept ToolongMyException as msg:print(msg)passelse:print('没有异常')finally:print('执行完毕')

在这里插入图片描述

7.Python动态添加属性和方法

动态语言： 在运行时可以改变其结构的语言。

class Student:def __init__(self,name,age):self.name=nameself.age=agepassdef __str__(self):return '{}的年纪是{}'.format(self.name,self.age)pass
s1=Student('学生1',20)
print(s1)
s1.grade=78   #动态增加属性
print(s1.grade)
print('====================')
s2=Student('学生2',22)
print(s2)
print(s2.grade)  #s2就没有，有点像个性化定制

在这里插入图片描述

import types  #动态增加实例方法需要导入的库
def dymicMethod(self):print('{}的成绩是：{}在{}读大学'.format(self.name,self.grade,Student.school))pass
class Student:def __init__(self,name,age):self.name=nameself.age=agepassdef __str__(self):return '{}的年纪是{}'.format(self.name,self.age)pass
s1=Student('学生1',20)
print(s1)
s1.grade=78   #动态增加属性
print(s1.grade)
print('===================')
Student.school='学校'  #动态增加类属性
print(s1.school)
print('===================')
#动态添加实例方法
s1.printInfo=types.MethodType(dymicMethod,s1)  #dymicMethod是要绑定的方法，s1是要和谁绑定
s1.printInfo()

在这里插入图片描述

class Student:def __init__(self,name,age):self.name=nameself.age=agepassdef __str__(self):return '{}的年纪是{}'.format(self.name,self.age)pass
#给类绑定方法
@classmethod
def classTest(cls):print('这是一个类方法')pass
Student.Test1=classTest    #绑定类方法
Student.Test1()
@staticmethod
def staticTest():print('这是一个静态方法')pass
Student.Test2=staticTest   #绑定一个静态方法
Student.Test2()
s1=Student('学生1',20)
print(s1)
print('实例对象调用绑定的方法：')
s1.Test1()
s1.Test2()

在这里插入图片描述

8.slots属性

在这里插入图片描述

#__slots__属性
class Student(object):__slots__ = ('name','age')def __str__(self):return '{}....{}'.format(self.name,s1.age)pass
s1=Student()
s1.name='名字'
s1.age=22
print(s1)
s1.grade=98  #因为没在slots属性的范围内，所以不能添加这个属性

在这里插入图片描述

正常情况下，类会将所有属性存储在__dict__中，但是定义了slots属性后就都存到slots中了不会存在dict中了

#__slots__属性
class Student(object):def __str__(self):return '{}....{}'.format(self.name,s1.age)pass
s1=Student()
s1.name='s1'
s1.age=22
print(s1.__dict__)
class Student2(object):__slots__ = ('name','age')def __str__(self):return '{}....{}'.format(self.name,s1.age)pass
s2=Student2()
s2.name='s2'
s2.age=22
print(s2.__dict__)

在这里插入图片描述

#__slots__属性
class Student(object):__slots__ = ('name','age')def __str__(self):return '{}....{}'.format(self.name,s1.age)pass
s1=Student()
s1.name='s1'
s1.age=22
class subStudent(Student):pass
s2=subStudent()
s2.grade=24
print(s2.grade)   #并没有报错，没有继承父类的slots属性
class subStudent2(Student):__slots__ = ('gra','weight')pass
s3=subStudent2()
s3.name='s3'
s3.age=22
s3.gra=21
s3.weight=78
print(s3.name,s3.weight,s3.age,s3.gra)   #继承了父类的slots属性自己发挥了
class subStudent3(Student):__slots__ = ()pass
s4=subStudent3()
s4.gra=21
print(s4.gra)   #继承了父类的slots属性但是没自己发挥

在这里插入图片描述

9.实践

在这里插入图片描述
9.1 创建person类

class Person():def __init__(self,name,age):self.__name=nameself.__age=agepassdef __str__(self):return '{}的年龄是{}'.format(self.__name,self.__age)def getNameInfo(self):return self.__namedef getAgeInfo(self):return self.__agedef setName(self,name):self.__name=namedef setAge(self,age):if age>0 and age<120:self.__age=ageelse:print('违法')
p1=Person('p1',22)
print(p1)
p1.setAge(123)
p1.setAge(77)
print(p1)

在这里插入图片描述
9.2 创建单例模式

class A(object):def __new__(cls, *args, **kwargs):if not hasattr(cls,'_instance'):cls._instance=super().__new__(cls,*args,**kwargs)return cls._instancepass

9.3 创建类

class A(object):def __init__(self,name,age):self.__name=nameself.__age=agepass@propertydef name(self):return self.__name@name.setterdef name(self,name):self.__name=name@propertydef age(self):return self.__age@age.setterdef age(self,age):self.__age=agedef __call__(self, *args, **kwargs):    #调用这个实例，让其以函数的形式调用print('{}的年纪是{}'.format(self.__name,self.__age))
s1=A('s1',22)
s1()
s1.name='ds'
s1.age=23
s1()

在这里插入图片描述
9.4 创建类

import types
def run(self):print('小猫跑')
class Animal:pass
Animal.color='三花'
cat=Animal()
cat.run=types.MethodType(run,cat)
cat.run()
print(cat.color)
@classmethod
def Info(cls):print('ok')pass
Animal.Info=Info
Animal.Info()