Python入门基础(8)--私有化属性和方法/Property属性/_new_方法/单例模式/错误和异常处理/Python动态添加属性和方法/_slots

本章重点

通过声明私有化属性、方法，保护和控制数据（重点）
通过property属性的使用，即控制好数据又方便访问（重点、难点）
明确__new__方法的作用和用法（重点）
通过单例模式，控制实例个数（难点）
使用异常处理机制，处理异常，提高代码健壮性
利用动态语言特点，动态添加属性和方法
利用__slots__属性控制可动态的属性

私有化属性

概述

前面学习面向对象过程中，修改类属性都是直接通过类名修改的。如果有些重要属性不想让别人随便修改，或者防止意外修改，该怎么办？

为了更好的保存属性安全，即不能随意修改，将属性定义为私有属性，添加一个可调用的方法去访问（就像一个安全口，只有在允许的情况下可以从这个入口进入，使用属性）

语法

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

使用私有属性的场景

把特定的一个属性隐藏起来不想让类的外部进行直接调用
我想保护这个属性，不想让属性的值随意的改变
保护这个属性不想让派生类【子类】去继承

特性

私有化属性不能在类外面访问
私有化属性可以在类里面访问，修改
子类不能继承私有化属性

class Person:__hobby='跳舞'  #私有的类属性def __init__(self):self.name='李四' self.age=30pass# xl=Person()
# # print(xl.name) #可以访问######私有化name###################
class Person:def __init__(self):self.__name='李四' #加两个下划线 将此属性私有化之后  就不能再外部直接访问了,当然在类的内部是可以访问的self.age=30pass
#####私有化属性在内部使用#####def __str__(self):'''私有化的属性在内部可以使用 self.__name:return:'''return '{}的年龄是{} 爱好是{}'.format(self.__name,self.age,Person.__hobby)# xl=Person()
# # print(xl.__name) #这样是在外部访问的（离开了类） 不能访问私有属性
# print(xl) ##结果显示了str方法里的内容，可见私有属性是可以在内部使用的######class Person:__hobby='跳舞'  #私有的类属性def __init__(self):self.__name='李四' #加两个下划线 将此属性私有化之后  就不能再外部直接访问了,当然在类的内部是可以防蚊贴self.age=30passdef __str__(self):'''私有化的属性在内部可以使用 self.__name:return:'''return '{}的年龄是{} 爱好是{}'.format(self.__name,self.age,Person.__hobby)def  changeValue(self):Person.__hobby='唱歌'####说明子类是否可用继承私有属性#####3
class Student(Person):def printInfo(self):# print(self.__name)  #在此访问父类中的私有属性 可以吗?   不可以print(self.age)passstu=Student()
# print(stu.__name)####结果显示无法调用父类的私有属性
stu.printInfo()
stu.changeValue() #修改私有属性的值
print(stu)
# print(stu.__hobby) #实例对象访问类属性
# print(Person.__hobby) #实例对象访问类属性

结论

私有化的【实例】属性不能再外部直接的访问可以在类的内部随意的使用
子类不能继承父类的私有化属性【只能继承父类公共的属性和行为】
在属性名的前面直接加‘ __’ （两个下划线）就可以变为私有化了

私有化方法

概述

私有化方法跟私有化属性概念一样，有些重要的方法，不允许外部调用，防止子类意外重写，把普通的方法设置成私有化方法

语法

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

特性

私有化方法一般是类内部调用，子类不能继承，外部不能调用
单下划线、双下划线、头尾双下划线说明

_xxx 前面加一个下划线，以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能使用from xxx import * 的方式导入。
__xxx__ 前后两个下滑线，魔法方法，一般是python自有，开发者不要创建这类型的方法。
xxx_ 后面单下滑线，避免属性名与python关键字冲突

class Animal:def __eat(self):print('吃东西')passdef run(self):self.__eat() #在此调用私有化的方法，类的内部是可用调用私有化方法的print('飞快的跑')passclass Bird(Animal):passb1=Bird()
# print(b1.eat())##不可以
# b1.eat()
b1.run()

Property属性函数

概述

上节我们讲了访问私有变量的话，一般写两个方法一个访问，一个修改，由方法去控制访问

这样给调用者的感觉就是调用了一个方法，并不是访问属性。我们怎么做到让调用者直接以访问属性的方式，而且我们又能控制的方式提供给调用者？
Python中有一个被称为属性函数(property)的小概念，它可以做一些有用的事情

使用函数可用对私有属性修改，但较为麻烦，因此引入了property属性，实现通过直接访问属性的形式去访问私有的属性

如下为通过函数访问和修改私有属性：

#####通过函数修改和访问私有属性#####3
class Person(object):def __init__(self):self.__age = 18 # 定义一个私有化属性，属性名字前加连个 __ 下滑线# def get_age(self): # 访问私有实例属性#     return self.__age# def set_age(self,age): # 修改私有实例属性#     if age < 0:#         print('年龄不能小于0')#     else:#         self.__age=age#         pass#     pass# p1=Person()p1.ages=''##不可访问p1.get_age()##可以访问p1.set_age()##可以访问

通过propert属性实现方式

1. 类属性,即在类中定义值为property对象的类属性
示例：给age属性设置值时，会自动调用setage方法，获取age属性值时，会自动调用getage方法。

###通过property实现访问和修改私有属性（实现方法1）####class Person(object):def __init__(self):self.__age = 18 # 定义一个私有化属性，属性名字前加连个 __ 下滑线def get_age(self): # 访问私有实例属性return self.__agedef set_age(self,age): # 修改私有实例属性if age < 0:print('年龄不能小于0')else:self.__age=agepasspass#定义一个类属性  实现通过直接访问属性的形式去访问私有的属性age=property(get_age,set_age)##相当于创建属性函数的实例对象p1=Person()
print(p1.age) #可以访问
p1.age=30#可以修改，这里的age相当于property属性函数的对象
print(p1.age)

本质上还是使用函数，但使用方法不是使用函数那样了

2. 装饰器，即在方法上使用装饰器（方法更简洁，推荐使用）

######实现方式2#############
class Person(object):def __init__(self):self.__age = 18 # 定义一个私有化属性，属性名字前加连个 __ 下滑线# 实现方式2  通过装饰器的方式去声明@property  #用装饰器修饰 添加属性标志  提供一个getter方法def age(self):return self.__age@age.setter   #提供一个setter方法def age(self,parms):##多加了一个参数用于设定新的值if parms < 0:print('年龄不能小于0')else:self.__age=parmspasspassp1=Person()
print(p1.age)##调用getter
p1.age=30##有参数调用的是setter
print(p1.age)

__new__方法

概述

_new_方法的作用是，创建并返回一个实例对象，如果__new__只调用了一次，就会得到一个对象。继承自object的新式类才有new这一魔法方法

注意事项

__new__ 是在一个对象实例化的时候所调用的第一个方法
__new__至少必须要有一个参数cls，代表要实例化的类，此参数在实例化时由Python解释器自动提供，其他的参数是用来直接传递给 __init__ 方法
__new__ 决定是否要使用该 __init__ 方法，因为 __new__ 可以调用其他类的构造方法或者直接返回别的实例对象来作为本类的实例，如果 __new__ 没有返回实例对象，则 __init__ 不会被调用（这是一个流程，没有返回就无法接着执行init方法）
在__new__ 方法中，不能调用自己的__new__ 方法，即：return cls.__new__ (cls)，否则会报错（RecursionError: maximum recursion depth exceeded：超过最大递归深度

使用方式

输出结果：

new其实是一个类的静态方法

输出结果：

单例模式

概述

单例模式是常用设计模式的一种，单例就比如我们打开电脑的回收站，在系统中只能打开一个回收站，也就是说这个整个系统中只有一个实例，重复打开也是使用这个实例

简单的说就是不管创建多少次对象，类返回的对象都是最初创建的，不会再新建其他对象

单例模式是一种常用的软件设计模式

目的

确保某一个类只有一个实例存在
#如果希望在整个系统中某个类只能出现一个实例的时候，那么这个单例对象就满足要求

# 创建一个单例对象基于__new__去实现的【推荐的一种】

#节省数据库资源，像是全网在线访问多少人，都返回一个实例，节省资源

实现步骤

1. 利用类属性保存初次创建的实例对象，第二次实例化的时候判断类属性是否有保存实例对象，如果有就返回类属性保存的，如果没有就调用父类__new__方法创建新的实例对象

2. 只执行一次init方法，通过类变量进行标记控制

# 创建一个单例对象 基于__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._instance ##这两种return也是有区别的，这行的return返回的是第一次创建的时候的内存地址，接下来再再这个类下实例化对象，不会走这个条件了，因此这个return就不会被执行，就导致接下来创建的实例对象都是同一个地址return cls._instancepassclass DBoptSingle(DataBaseClass):passdb1=DBoptSingle()##改为父类的实例化对象，也是一样的地址，子类和父类实例化的对象的地址都是相同的
print(id(db1))
db2=DBoptSingle()
print(id(db2))
db3=DBoptSingle()
print(id(db3))
##这三个对象的内存地址都不同，可见每一个对象在创建时都new了一个新的实例对象，这样不符合我们的需求，因此加入了一个判断hasattr，这个判断只会执行一次，一旦给一个类创建了一个实例对象，之后都是指向的这个

错误与异常处理

概述

有时候代码写错了，执行程序的时候，执行到错误代码的时候，程序直接终止报错，这是因为Python检测到一个错误时，解释器就无法继续执行了，出现了错误的提示，这就是"异常"。如果我们能提前对可能出现的情况做了处理，系统就不会把问题一直往上抛，抛给解释器导致程序断掉。
示例：变量b没有定义，直接打印变量b，会报异常。

print(b)
print('初次接触异常处理')
print('HAHAHAHHAHA')
#系统不会输出 后两行，直接报错，因为没有异常处理的步骤

语法格式

try ... except 语句

将可能出错的代码放到try里面，except可以指定类型捕获异常。except里面的代码是捕获到异常时执行,将错误捕获，这样程序就不会因为一段代码包异常而导致整个程序崩溃。
示例1：捕获ZeroDivisionError异常

# import Exception ##查看python中的错误类型
# print(dir(Exception))try:print(b) #捕获逻辑的代码pass
except NameError as msg:
#     # 捕获到的错误 才会在这里执行
#     print(msg)
#     pass# print('初次接触异常处理')
# print('HAHAHAHHAHA')##这样后续的代码就可以执行
##未捕获到的错误类型会报错
try:print(b) #捕获逻辑的代码li=[1,2,34]print(li[10])  #通过下标去访问列表pass
except NameError as msg:
#     # 捕获到的错误 才会在这里执行
#     print(msg)
#     pass
# print('初次接触异常处理')
# print('HAHAHAHHAHA')##添加多个expect处理多种错误 # 用一个块 可以捕获多个不同类型的异常
# except 在捕获错误异常的时候  只要根据具体的错误类型来捕获的
try:# print(b) #捕获逻辑的代码li=[1,2,34]print(li[10])  #通过下标去访问列表a=10/0passexcept  NameError as msg:# 捕获到的错误 才会在这里执行print(msg)passexcept IndexError as msg:print(msg)passexcept ZeroDivisionError as msg:print(msg)pass# print('初次接触异常处理')
# print('HAHAHAHHAHA')

示例2：捕获所有类型的异常（其他的异常类型可以不写）

当我们对于出现的问题或者错误不确定的情况下，可以使用它捕获所有的类型

不要忽略错误，在此尽量处理捕获到的错误

try:# print(b) #捕获逻辑的代码li=[1,2,34]print(li[10])  #通过下标去访问列表# a=10/0pass
# except  NameError as msg:
#     # 捕获到的错误 才会在这里执行
#     print(msg)
#     pass
# except IndexError as msg:
#     print(msg)
#     pass
# except ZeroDivisionError as msg:
#     print(msg)
#     pass
except Exception as result:# print(result)# 在此尽量的去处理捕获到的错误##有了这个前三个可以没有pass
# print('初次接触异常处理')
# print('HAHAHAHHAHA')

对于错误的捕获是否是越多越好？

def A(s):return 10/int(s)pass
def B(s):return A(s)*2
def main():try:B('0')passexcept Exception as msg:print(msg)passpassmain()
不需要在每个可能出错的地方去捕获，只需要在合适的层次去捕获错误就可以（在统一调用的函数里同意处理），expect可以跨层次调用def A(s):return 10/int(s)pass
def B(s):return A(s)*2
def main():B(0)
#会报错，没有处理异常的出现，但输出的结果会反映异常的出现的层次

异常的抛出机制

如果在运行时发生异常解释器会查找相应的异常捕获类型
如果在当前函数里面没有找到的话它会将异常传递给上层的调用函数，看能否处理
如果在最外层没有找到的话，解释器就会退出程序down哦

try ... except ... else语句

没有捕获到异常时才执行else语句
示例：

# try:
#     print('我是没有错误产生的')##aa就会作为异常被万能异常处理
#     pass
# except SyntaxError as msg:
#     print(msg)
# except Exception as msg:
#     print('error',msg)
# else:
#     print('当Try里面的代码 没有出现异常的情况下 我才会执行')
#     pass

try ... except ... finally语句

不管有没有错误，finally后的都会被执行

强行处理，用于释放数据库和文件资源

try-except-finally
try:int('34')open('aaaa.txt')
except Exception as msg:print(msg)pass
finally:print('释放文件的资源、数据库连接是资源等等')print('不管有没有出错都执行的代码块')

try嵌套

异常传递

如果多个函数嵌套调用，内层函数异常，异常会往外部传递，直到异常被抛出，或被处理。

示例1:

输出结果：

示例2:

输出结果：

自定义异常

自定义异常，都要直接或间接继承Error或Exception类。（必须）
由开发者主动抛出自定义异常，在python中使用raise关键字

class ToolongMyException(Exception):def __init__(self,leng):''':param leng: 长度'''self.len=lengpassdef __str__(self):return '您输入姓名数据长度是'+str(self.len)+'超过长度了..'passdef name_Test():name=input('请输入姓名.....')try:if  len(name)>5:raise ToolongMyException(len(name))else:print(name)passpassexcept ToolongMyException as result:print(result)passfinally:print('执行完毕了....')name_Test()

抛出捕获到的异常（自定义异常需要自己决定什么时候抛出异常）

在开发中有，有时候会有这样一种功能，由调用者决定是否需要做异常处理，如不处理，可继续抛出。
示例：实例化对象时传入一个参数，判断捕获异常后是否做处理，不做处理用raise关键字重新抛出异常。

动态添加属性和方法

概述

动态语言：运行时可以改变其结构的语言，例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。如php,JavaScript,python都是动态语言，C，C#，java是静态语言。
所以python可以在程序运行过程中添加属性和方法。

动态添加属性（需要import types 方法库）

类对象添加类属性

实例对象添加实例属性

1. 运行中给对象添加属性

class Student:def __init__(self,name,age):self.name=nameself.age=agepassdef __str__(self):return '{}今天{}岁了'.format(self.name,self.age)passzyh=Student('张艳华',20)
zyh.weight=50 #动态添加
print（zyh）
print(zyh.weight)print('-------------另外一个实例对象  张明--------------------------')
zm=Student('张名',20)
zm.weight=80 #动态添加 ##报错，因为是为zyh特有定义的
print(zm)

2. 运行中给类添加属性

需要通过类对象添加

class Student:def __init__(self,name,age):self.name=nameself.age=agepassdef __str__(self):return '{}今天{}岁了'.format(self.name,self.age)passprint('-------------给类对象添加属性--------------------------')
Student.shcool='北京邮电大学' #动态添加类属性
print(zm.shcool)##通过实例对象可以访问新添加的类属性

3. 动态添加实例方法
动态添加实例方法需要使用types

import types  #添加方法的库
##需要先定义要添加的方法
def dymicMethod(self):print('{}的体重是:{}kg 在 {} 读大学'.format(self.name,self.weight,Student.shcool))passclass Student:def __init__(self,name,age):self.name=nameself.age=agepassdef __str__(self):return '{}今天{}岁了'.format(self.name,self.age)passprint('-------------给类对象添加属性--------------------------')
Student.shcool='北京邮电大学' #动态添加类属性
print(zm.shcool)zyh=Student('张艳华',20)
zyh.weight=50 #动态添加
zyh.printInfo=types.MethodType(dymicMethod,zyh) #动态的绑定方法print('-------------执行动态调用实例方法--------------------------')
zyh.printInfo() #调用动态绑定的方法
zm.printInfo() #张明不可绑定，因为绑定方法中的weight并没有被动态的添加到zm中，只在zyh中被动态的添加了

4. 动态添加类方法

给类绑定类方法和静态方法（规则差不多）
使用方式：类名.方法名 = xxxx

import types  #添加方法的库def dymicMethod(self):print('{}的体重是:{}kg 在 {} 读大学'.format(self.name,self.weight,Student.shcool))pass
@classmethod
def classTest(cls):print('这是一个类方法')pass@staticmethod
def staticMethodTest():print('这是一个静态方法')passclass Student:def __init__(self,name,age):self.name=nameself.age=agepassdef __str__(self):return '{}今天{}岁了'.format(self.name,self.age)passprint('绑定类方法')
Student.TestMethod=classTest ##Testmethod是随便取的
Student.TestMethod()Student.staticMethodTest=staticMethodTest
Student.staticMethodTest()print('---------------绑定类方法执行结束----------------------')

__slots__属性

概述

python是动态语言，在运行的时候可以动态添加属性。如果要限制在运行的时候给类添加属性，Python允许在定义class的时候，定义一个特殊的__slots__变量，来限制该class实例能添加的属性。

只有在__slots__变量中的属性才能被添加，没有在__slots__变量中的属性会添加失败。可以防止其他人在调用类的时候胡乱添加属性或方法。__slots__属性子类不会继承，只有在当前类中有效。除非在子类中也声明了这样的变量。

规则

在继承关系当中的使用 __slots__
# 子类未声明 __slots__时，那么是不会继承父类的__slots__，此时子类是可以随意的属性赋值的
# 子类声明了__slots__时，继承父类的__slots__，也就是子类__slots__的范围是为其自身+父类的__slots__

#既然子类已经用了slot，那么就会继承父类的slot，所有不要再添加相同的属性在子类的slot中

使用方法

class Student(object):__slots__ = ('name','age')##这里的变量名是字符串形式def __str__(self):return '{}....{}'.format(self.name,self.age)pass
xw=Student()
xw.name='小王'
xw.age=20
xw.score=96 # 没有在范围内 所以报错
print(xw)###添加scoreclass Student(object):__slots__ = ('name','age','score')##这里的变量名是字符串形式def __str__(self):return '{}....{}'.format(self.name,self.age)pass
xw=Student()
xw.name='小王'
xw.age=20
xw.score=96 # 可以打印
print(xw)####没有slot，属性存在字典中，占用空间大class Student(object):def __str__(self):return '{}....{}'.format(self.name,self.age)pass
xw=Student()
xw.name='小王'
xw.age=20
xw.score=96 # 可以打印
print(xw)
print(xw.__dict__) #所有可以用的属性都在这里存储  不足的地方就是占用的内存空间大###在定义了slot方法后，student类的实例已经不能随意的创建不在slot定义的属性了
###同时还可以看到实例当中也不再有__dict__，使用slot存储了属性，空间减小
class Student(object):
__slots__ = ('name','age','score')##这里的变量名是字符串形式def __str__(self):return '{}....{}'.format(self.name,self.age)pass
xw=Student()
xw.name='小王'
xw.age=20
xw.score=96 # 可以打印
print(xw)
print(xw.__dict__) #所有可以用的属性都在这里存储  不足的地方就是占用的内存空间大# 在继承关系当中的使用  __slots__
# 子类未声明  __slots__时，那么是不会继承父类的__slots__，此时子类是可以随意的属性赋值的
# 子类声明 了__slots__时，继承父类的__slots__，也就是子类__slots__的范围是为其自身+父类的__slots__class subStudent(Student):__slots__ = ('gender','pro')pass
ln=subStudent()
ln.gender='男'
ln.pro='计算机信息管理'
print(ln.gender,ln.pro)

作用

限制要添加的实例属性
节约内存空间

Python入门基础(8)--私有化属性和方法/Property属性/_new_方法/单例模式/错误和异常处理/Python动态添加属性和方法/_slots_属性相关推荐

Python入门基础知识学什么?
Python基础知识主要是针对一些零基础的同学安排的,虽说Python是相对比较简单的一门编程语言,但是没有基础的同学还是要进行系统的学习,那么Python入门基础知识学什么呢?来看看下面小编的详细介 ...
Python入门基础（下）之魔方方法
Python入门基础(下)之魔方方法一.学习内容概括学习地址:https://tianchi.aliyun.com/s/58327c15d1faee512c008128d3bb9e32 今天主要学 ...
【目录】Python 入门基础篇＜（＾－＾）＞
Python 入门基础篇一.关于Python的介绍与准备工作 Python基础介绍 Jupyter notebook基础介绍 Jupyter notebook打开问题 Jupyter noteboo ...
python入门基础教程-Python入门基础教程：WSGI
原标题:Python入门基础教程:WSGI WSGI 简介 WSGI 是什么 WSGI 是 Python Web Server Gateway Interface 的缩写,是描述 Web 服务器与 P ...
Python入门基础总结笔记——正则表达式
Python入门基础总结笔记--正则表达式完整基础知识参看网站:正则表达式总结重点用\d可以匹配一个数字,\w可以匹配一个字母或数字用*表示任意个字符(包括0个),用+表示至少一个字符用?表 ...
B站马士兵python入门基础版详细笔记（6）
前言: 这篇文章是B站学习python入门基础班的视频的第五六章内容,主要讲述的是列表,主要包括列表的创建,以及他的元素的增.删.查.改操作命令. 一.列表的初始化为什么要使用列表? 列表就好比C ...
B站马士兵python入门基础版详细笔记（4）
前言: 这篇文章是B站学习python入门基础班的视频的第四章内容,主要讲述的是if-else语句,但是不包括循环结构,循环结构在下一章笔记中有记叙一.顺序结构什么是顺序结构呢?比如说 '''把大 ...
python笔记基础-Python入门基础知识学习笔记之一
为什么要写这篇文章? 本人做过Objective-C开发,现在在用C#做WinForm开发.近段时间在学习Python入门基础知识时,发现有很多知识点和Objective-C的不一样.故想通过本文记录 ...
python入门基础代码初学
python入门基础代码初学一.检查python安装二.print使用二.使用python运算三.enumerate()函数一.检查python安装 PS C:\Users\admin> ...
python 判断列表所有元素是否为某个值_这应该是最详细的Python入门基础语法总结！...
这应该是最详细的Python入门基础语法总结! 这应该是最详细的Python入门基础语法总结! 定义变量,使用变量 input 用户自己输入值 print 打印值可以输出多个变量 %d|%s 用于输 ...

Python入门基础(8)--私有化属性和方法/Property属性/_new_方法/单例模式/错误和异常处理/Python动态添加属性和方法/_slots_属性

Python入门基础(8)--私有化属性和方法/Property属性/_new_方法/单例模式/错误和异常处理/Python动态添加属性和方法/_slots_属性相关推荐

最新文章

热门文章