九.面向对象基础(下)

1.私有化属性与方法

私有化属性:

概念

有一些属性不希望别人能轻易更改,因此为了更好的保存属性安全,
即不能随意修改,将属性定义为私有属性,添加一个可调用的方法去访问.

语法

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

class 类名(object):
	__属性 = 值

例

class Person(object):
    __Age = 15

¹ 私有化属性不能在类外部访问

class Person(object):
    __Age = 15
    pass
Test = Person()
print(Person.__Age)
print(Test.__Age)
# 执行后程序会报错,因为__Age为私有

² 私有化属性可以在类里面访问和修改

class Person(object):
    __Age = 15
    def Get_Age(self):
        print(Person.__Age)
        pass
    def Set_Age(self,Age):
        Person.__Age = Age
        print(Person.__Age)
        pass
    pass
Test = Person()
Test.Get_Age()
Test.Set_Age(18)
==================结果=================
15
18

³ 子类不能继承私有化属性

class Father(object):
    __Age = 15
    pass
class Son(Father):
    def Test(self):
        print(self.__Age)
    pass
A = Son()
A.Test()
# 程序报错无法执行

私有化方法:

基本与私有化属性一致,有些重要的方法,不允许外部调用,防止子类意外重写,把普通的方法设置成私有化方法.

语法

同私有化属性一样,也是在方法名前加两个下划线

class 类名(object):
	def __方法(self):

例

class Father(object):
    def __Age(self):
        print("15")
        pass
    def Get_Age(self): # 私有化方法只能在类的内部调用
        self.__Age()
    pass
Test = Father()
Test.Get_Age()
==============结果==============
15

特性(摘抄)
私有化方法一般是类内部调用，子类不能继承，外部不能调用。

单下划线、双下划线、头尾双下划线说明

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

2.Property属性与单例模式

Property属性:

概念

property属性可以用来给属性添加约束,比如温度属性,我们不允许低于-273度;成绩属性,我们不允许0分以下等等.而且使用property属性,将来修改约束条件的时候也很方便,可以在代码的调用方式不变的情况下改变结果.

python中使用property属性有两种方法.使用@property装饰器和使用property()函数.

实现方式-1 – 装饰器

class Father(object):
    def __init__(self):
        self.__Age = 15
    @property
    def Age(self):
        return self.__Age
    @Age.setter
    def Age(self,Value):
        print("setting age")
        if Value > 0 and Value <50:
            self.__Age = Value
            pass
        else:
            print("你的输入不符合规范")
            pass
        pass
    pass
Test = Father()
print(Test.Age)
Test.Age = 17
print(Test.Age)
Test.Age = 120
print(Test.Age)
==============结果===============
15
setting age
17
setting age
你的输入不符合规范
17

实现方式-2 – 类属性

class Father(object):
    def __init__(self):
        self.__Age = 15
    def get_Age(self):
        return self.__Age
    def set_Age(self,Value):
        if Value > 0 and Value <50:
            self.__Age = Value
            pass
        else:
            print("你的输入不符合规范")
            pass
        pass
    Age = property(get_Age,set_Age)
    pass
Test = Father()
Test.Age = 100
print(Test.Age)
Test.Age = 20
print(Test.Age)
==============结果=============
你的输入不符合规范
15
20

__new__方法

概述(摘抄)

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

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

例

class Animal(object):
    def __init__(self):
        self.Colour = "white"
        pass
    # 在python当中,如果不重写__new__,默认结构则如下所示
    def __new__(cls, *args, **kwargs):
        return super().__new__(cls, *args, **kwargs)
        # return object.__new__(cls, *args, **kwargs) # 两者皆可
	pass
Test = Animal() # 实例化的过程中会自动调用 __new__ 去创建实例
# 在新式类中 __new__ 才是真正的实例化方法,为类提供外壳制造出实例框架,
# 然后调用该框架内的构造方法 __init__ 进行丰满操作
# 比喻建房子 __new__ 方法负责开发地皮,打地基,并将原料放在工地,而 __init__ 负责从工地取材料
# 建造出地皮开发图纸规定的大楼,负责细节设计,制造,最终完成

单例模式

概述(摘抄)

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

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

基于 __new__ 实现的单例模式

class Single(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)
            pass
        return cls._instance
    pass
class T(Single):
    pass
Test1 = Single()
print(id(Test1))
Test2 = Single()
print(id(Test2))
Test3 = Single()
print(id(Test3))
Test4 = T()
print(id((Test4)))
===============结果================
1465093189488
1465093189488
1465093189488
1465093189488
# 四者内存地址一致,单例模式成功

3.错误与异常处理

概述

有时候代码写错了,执行程序的时候,执行到错误代码的时候,程序直接终止报错,这是因为Python检测到一个错误时,解释器就无法继续执行了,出现了错误的提示,这就是"异常".
因此需要错误检测和处理

格式

try:

可能出现错误的代码块

except:

出错之后执行的代码块

else:

没有出错的代码块

finally:

不管有没有出错都执行的代码块

例
try…except语句:

try:
    print(1/0)
    pass
except Exception as e:
    print("此程序有问题,问题是{}".format(e))
    pass
===========结果==========
此程序有问题,问题是division by zero
# Exception意为检测所有异常问题
# 可加入多个execpt检测多个异常问题
# execpt ZeroDivisionError as e
# except NameError as e 等等

try…except…else语句:

try:
    print("hello world")
    pass
except Exception as e:
    print("此程序有问题,问题是{}".format(e))
else:
    print("此程序没有问题,可以执行")
==========结果==========
hello world
此程序没有问题,可以执行

try…except…finally语句:

try:
    print(1/0)
    print(a)
    pass
except Exception as e:
    print("此程序有问题,问题是{}".format(e))
    pass
finally:
    print("hello world")
    pass
==========结果==========
此程序有问题,问题是division by zero
hello world

try嵌套:

try:
    print("hello")
    try:
        print(1/0)
        pass
    except Exception as e:
        print(e)
        pass
    pass
except Exception as e:
    print("问题是{}".format(e))
    pass
==========结果==========
hello
division by zero

异常传递(摘抄):

def a():
    print('执行a函数')
    1/0 # 制造一个异常
    print('a函数执行完成')
def b():
    print('执行b函数')
    a() # 调用a函数
    print('b函数执行完成')
def c():
    print('执行c函数')
    try:
        b() # 调用b函数
    except Exception as e:
        print(e)
    print('c函数执行完成')
c()
==========结果==========
执行c函数
执行b函数
执行a函数
division by zero
c函数执行完成

自定义异常:

class NameExcept(Exception):  # 自定义异常类需要继承Exception
    def __init__(self,leng):
        self.len = leng
        pass
    def __str__(self):
        return '[error:]你输入的名字长度大于5，请出入小于5的名字'
    pass
def Name_Test():
    name = input("请输入你的名字:")
    if len(name) > 5:
        raise NameExcept(len(name))
    else:
        print(name)
        pass
    pass
Name_Test()
==========结果==========
请输入你的名字:小李小红小花
Traceback (most recent call last):
  File "E:\python(day7-day13)\Day9.py", line 189, in <module>
    Name_Test()
  File "E:\python(day7-day13)\Day9.py", line 184, in Name_Test
    raise NameExcept(len(name))
__main__.NameExcept: [error:]你输入的名字长度大于5，请出入小于5的名字

抛出捕获到的异常

class NameExcept(Exception):  # 自定义异常类需要继承Exception
    def __init__(self,leng):
        self.len = leng
        pass
    def __str__(self):
        return '[error:]你输入的名字长度大于5，请出入小于5的名字'
    pass
def Name_Test():
    name = input("请输入你的名字:")
    try:
        if len(name) > 5:
            raise NameExcept(len(name))
        else:
            print(name)
            pass
        pass
    except NameExcept as e:
        print(e)
        pass
    finally:
        print("程序执行完毕")
    pass
Name_Test()
==========结果==========
请输入你的名字:shdjkashfk
[error:]你输入的名字长度大于5，请出入小于5的名字
程序执行完毕

4.动态添加属性和方法

概述(摘抄)

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

运行中为对象添加属性

class Animal(object):
    def __init__(self, Age):
        self.Age = Age
        pass
    pass
Cat = Animal(15)
Cat.Colour = "white"
print(Cat.Colour)
==========结果==========
white
# 给类添加同理	

动态添加实例方法

import types
class Animal(object):
    def __init__(self, Name):
        self.Name = Name
        pass
    pass
def Run(self):
    print("一只名叫{}的猫在{}".format(self.Name, self.Run))
    pass
Cat = Animal("小黑")
Cat.Run = "跑"
# print(Cat.Run)
Cat.Test = types.MethodType(Run,Cat)
Cat.Test()
==========结果==========
一只名叫小黑的猫在跑

给类绑定类方法和静态方法

class Class(object):
    pass
@classmethod
def a(cls):
    print("hello world")
    pass
Class.Test = a
Class.Test()
Class.Test()
print(type(Class.Test))
@staticmethod
def b():
    print("hello")
    pass
Class.Testb = b
Class.Testb()
Class.Testb()
print(type(Class.Testb))
==========结果==========
hello world
hello world
<class 'method'>
hello
hello
<class 'function'>

__slots__属性

概述(摘抄)

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

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

例

class Animal(object):
    __slots__ = ("Name", "Age")
    pass
Dog = Animal()
Dog.Name = "小黑"
print(Dog.Name)
# Dog.Test = "a" # 不在__slots__属性里,无法添加
# print(Dog.Test) # 若取消注释,程序会报错
==========结果==========
小黑

知识总结-1(摘抄)

私有化属性
两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。
私有化方法
私有化方法，即在方法名前面加两个下划线。
Property属性
类属性,即在类中定义值为property对象的类属性
装饰器，即在方法上使用装饰器
__new__方法
__new__方法的作用是，创建并返回一个实例对象
单例模式
不管创建多少次对象，类返回的对象都是最初创建的，不会再新建其他对象。

知识总结-2(摘抄)

错误与异常处理
try: 可能出现错误的代码块 except: 出错之后执行的代码块 else: 没有出错的代码块 finally: 不管有没有出错都执行的代码块
Python动态添加属性和方法
在程序运行过程中添加属性和方法
__slots__方法
在定义class的时候，定义一个特殊的__slots__变量，来限制该class实例能添加的属性