网站建设购买数据库的流程图,中国机床网,网店代运营是正规的吗,开通微信公众号面向对象编程-下
1.私有化属性
语法#xff1a;两个下划线开头#xff0c;声明该属性为私有#xff0c;不能在类的外部被使用或直接访问。
使用私有化属性的场景#xff1a;
1.把特定的一个属性隐藏起来#xff0c;不让类的外部进行直接调用。
2.不让属性的值随意改变。…面向对象编程-下
1.私有化属性
语法两个下划线开头声明该属性为私有不能在类的外部被使用或直接访问。
使用私有化属性的场景
1.把特定的一个属性隐藏起来不让类的外部进行直接调用。
2.不让属性的值随意改变。
3.不让子类继承。class Person():def __init__(self):self.name里斯self.age30passpass
xlPerson()
print(xl.name)
#私有化
class Pri():def __init__(self):self.__name李四 #如此外界就访问不到了,但是在内部可以访问到self.age12passdef __str__(self):return {}的年龄是{}.format(self.__name,self.age)pass
llPri()
print(ll)
print(ll.__name)#私有化
class Pri():def __init__(self):self.__name李四 #如此外界就访问不到了,但是在内部可以访问到self.age12passdef __str__(self):return {}的年龄是{}.format(self.__name,self.age)pass
class Student(Pri):def pri(self):print(self.__name) ##同样的子类也访问不到私有属性passpass
stuStudent()
stu.pri()小结 1.私有化的实例属性和类属性不能在外部直接访问可以在类的内部随意访问。 2.子类不能继承父类的私有化属性只能继承父类中公开的属性和行为。 3.如果想将属性私有化直接在属性名的前面加两个下划线’__就可以了。 4.私有化属性的值可以在类内部修改。
2.私有化方法
私有化方法即在方法名前面加两个下划线。
class Animal:def eat(self):print(吃)passdef run(self):print(跑)passpass
class Bird(Animal):pass
b1Bird()
b1.eat()
b1.run()
#私有化方法
class Pr():def __eat(self):print(私有化的吃)passdef run(self):self.__eat()print(跑)passpass
b2Pr()
b2.run()
b2.__eat()私有化方法一般是类内部调用子类不能继承外部不能调用 前面一个单下划线标识protected类型即保护类型的变量只能允许其本身与子类进行访问不能使用from ... import *的方式导入
前后两个双下划线魔法方法
后面单下划线避免属性名与python关键字冲突
前面双下划线私有化private#访问私有变量的话一般写两个方法一个访问一个修改由方法去控制访问
class Person:def __init__(self):self.__age19passdef get_age(self): #访问return self.__agedef set_age(self,age): #修改if age0: print(年龄不能小于0)passelse:self.__ageagepasspasspass
pPerson()
p.set_age(12)
print(p.get_age())
p2Person()
p.set_age(-1)3.属性函数property
若想直接像访问公共属性一样访问私有属性而不是如同上述使用方法访问私有属性可以使用属性函数。 法一
#访问私有变量的话一般写两个方法一个访问一个修改由方法去控制访问
class Person:def __init__(self):self.__age19passdef get_age(self):return self.__agedef set_age(self,age):if age0:print(年龄不能小于0)passelse:self.__ageagepasspass#定义一个类属性实现通过直接访问属性的形式去访问私有的属性ageproperty(get_age,set_age)pass
pPerson()
print(p.age)
p.age25
print(p.age)法二使用装饰器
#访问私有变量的话一般写两个方法一个访问一个修改由方法去控制访问
class Person:def __init__(self):self.__age12property #用装饰器添加属性标识,提供一个getter方法def age(self):return self.__ageage.setter #提供一个setter方法def age(self,parms): #修改私有属性的值parms也就是后传入想要修改成的ageif parms0:print(年龄不能小于0)passelse:self.__ageparmspasspasspass
p1Person()
print(p1.age)
p1.age20
print(p1.age)4.__new__方法 5.单例模式
单例模式是常用软件设计模式的一种目的是确保某一个类中只有一个实例存在。如果希望在某个系统中某个类只能出现一个实例整个单例模式就能满足要求。
#创建一个单例对象 基于__new__实现
class DataBaseClass(object):def __new__(cls, *args, **kwargs):#cls._instancecls.__new__(cls) 不能使用自己的new方法容易造成递归死循环应该调用父类的new方法if not hasattr(cls,_instance): #如果不存在就创建cls._instancesuper().__new__(cls,*args,**kwargs)return cls._instancepass
db1DataBaseClass()
print(id(db1))
db2DataBaseClass()
print(id(db2)) #可以看出来都是一个对象
class DBoptSingle(DataBaseClass):pass
d1DBoptSingle()
print(id(d1))
d2DBoptSingle()
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:a1print(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.lenlenpassdef __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.lenlenpassdef __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.namenameself.ageagepassdef __str__(self):return {}的年纪是{}.format(self.name,self.age)pass
s1Student(学生1,20)
print(s1)
s1.grade78 #动态增加属性
print(s1.grade)
print()
s2Student(学生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.namenameself.ageagepassdef __str__(self):return {}的年纪是{}.format(self.name,self.age)pass
s1Student(学生1,20)
print(s1)
s1.grade78 #动态增加属性
print(s1.grade)
print()
Student.school学校 #动态增加类属性
print(s1.school)
print()
#动态添加实例方法
s1.printInfotypes.MethodType(dymicMethod,s1) #dymicMethod是要绑定的方法s1是要和谁绑定
s1.printInfo()class Student:def __init__(self,name,age):self.namenameself.ageagepassdef __str__(self):return {}的年纪是{}.format(self.name,self.age)pass
#给类绑定方法
classmethod
def classTest(cls):print(这是一个类方法)pass
Student.Test1classTest #绑定类方法
Student.Test1()
staticmethod
def staticTest():print(这是一个静态方法)pass
Student.Test2staticTest #绑定一个静态方法
Student.Test2()
s1Student(学生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
s1Student()
s1.name名字
s1.age22
print(s1)
s1.grade98 #因为没在slots属性的范围内所以不能添加这个属性正常情况下类会将所有属性存储在__dict__中但是定义了slots属性后就都存到slots中了不会存在dict中了 #__slots__属性
class Student(object):def __str__(self):return {}....{}.format(self.name,s1.age)pass
s1Student()
s1.names1
s1.age22
print(s1.__dict__)
class Student2(object):__slots__ (name,age)def __str__(self):return {}....{}.format(self.name,s1.age)pass
s2Student2()
s2.names2
s2.age22
print(s2.__dict__)#__slots__属性
class Student(object):__slots__ (name,age)def __str__(self):return {}....{}.format(self.name,s1.age)pass
s1Student()
s1.names1
s1.age22
class subStudent(Student):pass
s2subStudent()
s2.grade24
print(s2.grade) #并没有报错没有继承父类的slots属性
class subStudent2(Student):__slots__ (gra,weight)pass
s3subStudent2()
s3.names3
s3.age22
s3.gra21
s3.weight78
print(s3.name,s3.weight,s3.age,s3.gra) #继承了父类的slots属性自己发挥了
class subStudent3(Student):__slots__ ()pass
s4subStudent3()
s4.gra21
print(s4.gra) #继承了父类的slots属性但是没自己发挥9.实践 9.1 创建person类
class Person():def __init__(self,name,age):self.__namenameself.__ageagepassdef __str__(self):return {}的年龄是{}.format(self.__name,self.__age)def getNameInfo(self):return self.__namedef getAgeInfo(self):return self.__agedef setName(self,name):self.__namenamedef setAge(self,age):if age0 and age120:self.__ageageelse:print(违法)
p1Person(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._instancesuper().__new__(cls,*args,**kwargs)return cls._instancepass9.3 创建类
class A(object):def __init__(self,name,age):self.__namenameself.__ageagepasspropertydef name(self):return self.__namename.setterdef name(self,name):self.__namenamepropertydef age(self):return self.__ageage.setterdef age(self,age):self.__ageagedef __call__(self, *args, **kwargs): #调用这个实例让其以函数的形式调用print({}的年纪是{}.format(self.__name,self.__age))
s1A(s1,22)
s1()
s1.nameds
s1.age23
s1()9.4 创建类
import types
def run(self):print(小猫跑)
class Animal:pass
Animal.color三花
catAnimal()
cat.runtypes.MethodType(run,cat)
cat.run()
print(cat.color)
classmethod
def Info(cls):print(ok)pass
Animal.InfoInfo
Animal.Info()
