本文章最初发布在 XJHui’s Blog，未经允许，任何人禁止转载！

注意：最新修改版本已发布在这里，点击前往查看！

私有化属性

有些属性不想让别人随意修改或者防止被意外修改，就要对属性进行私有化

基本概述

定义：

为了保证属性安全（不能被随意修改），可以将属性定义为私有属性
使用场景：
- 属性不想被类的外部直接调用
- 属性值不想随意被改变
- 不想被子类继承

语法：

1 2	class Person: __name = '张三' # 属性名前加两个下划线将该属性私有化

使用私有属性

案例：验证实例属性私有化后在类的外部不可调用

class Person:
       def __init__(self):
           self.name = '张三'  # 实例属性
           self.__age = 17  # 私有属性
           pass
   
       pass
   
   
   p1 = Person()
   print(p1.name)  # 打印实例属性

运行结果：

1	print(p1.age) # 打印私有属性

运行结果：

案例：验证私有化属性可在类的内部调用

class Person:
       def __init__(self):
           self.name = '张三'
           self.__age = 17
           pass
   
       def printData(self):  # 实例方法，打印私有属性age
           print(self.__age)
   
       pass
   
   
   p1 = Person()
   p1.printData()  # 通过调用实例方法，验证在类的内部可直接访问私有属性

运行结果：

总结：将属性私有化后，就不可以在类的外部访问了，但内部使用不受任何影响

私有化属性可继承性：

class Person:  # 父类
    def __init__(self):
        self.__name = '张三'
        pass

    pass


class Teacher(Person):  # 子类调用父类
    def test(self):  # 子类中打印父类中的私有属性
        print(self.__name)


t1 = Teacher()
t1.test()

运行结果：

总结：父类的私有属性不可被子类继承

私有化方法

有些重要的方法，不允许外部调用或防止子类意外重写，可以把普通方法设置成私有化方法

语法规则

1
2
3

class Animal:
    def __showInfo(self):  # 方法名前面加两个下划线
        print('这是动物类！')

使用私有化方法

案例：验证私有方法不可被外部直接访问且不可被继承

class Animal:
    def __showInfo(self):
        print('这是动物类！')
        pass

    pass


class Bird(Animal):
    pass


b1 = Bird()
b1.__showInfo()

运行结果：

案例：私有方法在类的内部可正常访问

class Animal:
    def __showInfo(self):
        print('这是动物类！')
        pass

    def printData(self):
        self.__showInfo()

    pass


class Bird(Animal):
    pass


b1 = Bird()
b1.printData()

运行结果：

总结：
- 私有方法不可被外部访问且不可被继承
- 私有方法在类内部可正常访问

命名规范

头单下划线：保护类变量（不常用） _name
头双下划线：私有属性【方法】 __name
头尾双下划线：魔术方法【系统所有】，不可自定义 _init_
尾单下划线：避免变量名与关键字冲突时可使用 class_

Property属性

获取和修改私有属性的值

方法一：调用set方法

class Animal:
    __name = '张三'

    def getName(self):
        return self.__name

    def setName(self, data):
        self.__name = data


a1 = Animal()
a1.setName('李四')  # 通过调用set方法实现私有属性值的修改
print(a1.getName())  # 调用get方法实现私有属性值的获取

运行结果：

方法二：使用Property属性函数

Property属性函数可以通过点语法来获取、修改私有属性的值

class Animal:
    __name = '张三'

    def getName(self):
        return self.__name

    def setName(self, data):
        self.__name = data

    name = property(getName, setName)  # property()方法有两个参数，分别为get、set的方法名


a1 = Animal()
a1.name = '李四'  # 点语法实现值的修改
print(a1.name)  # 点语法实现值的获取

运行结果：

单例模式

实现整个系统中某个类的实例只创建一次

应用场景

网站登录（例如淘宝网，只允许一个账号同时浏览）

创建单例对象

class People(object):
    __instance = None  # 私有属性用来存放首次创建的对象

    def __init__(self):
        print('对象创建成功！')

    def __new__(cls, *args, **kwargs):
        if not cls.__instance:  # 如果 __instance 为None，说明该类还未曾创建过对象
            cls.__instance = object.__new__(cls)  # 创建一个对象并用__instance记录下来
            return cls.__instance
        else:  # 如果__instance不为None代表，该类已经创建过一个对象了，只需要直接返回之前创建的那个变量【__instance】
            return cls.__instance


p1 = People()
p2 = People()
print(id(p1), id(p2))

运行结果：

错误与异常处理

引入

1
2
3

age = 10
print(name)  # 未定义，运行会报错
print(age)  # 已定义，理论上可以正常显示

上面代码中，未定义name而直接输出，程序会报错如下：

程序报错导致整个程序结束，因此age不能正常显示。

有没有办法可以输出错误内容并使程序正常运行？有，异常处理。

异常处理

try…except

age = 10
try:
    print(name)  # 准备捕获异常的代码
except NameError as msg:  # except后跟错误类型，as将结果重定向
    print('【{}】 异常'.format(msg))
print(age)

运行结果：

拓展：如果可能有多种错误类型怎么办？

try跟随多个except语句

l1 = ['hello', 1, True]
try:
    print(l1[10])
except NameError as msg:
    print('【{}】 异常'.format(msg))
except IndexError as msg:
    print('【{}】 异常'.format(msg))

运行结果：

方法二：捕获所有异常（万能）

l1 = ['hello', 1, True]
try:
   print(l1[10])
except Exception as msg:
   print(msg)

运行结果：

错误栈：

def A(data):
    return data / int(data)


def B(data):
    return A(data) * 10


def Func(data):
    B(data)

Func(0)

分析：上面出现多个函数嵌套调用，每个函数中都需要写try…except？答案是：不需要

def A(data):
    return data / int(data)


def B(data):
    return A(data) * 10


def Func(data):
    try:
        B(data)
    except Exception as msg:
        print(msg)


Func(0)

运行结果：

原理：

如果在函数中出现错误，则会将该错误返回到上一层，直至最顶层
如果错误出现在最顶层，则程序会结束

总结：合适位置添加try…except可以极大的减少代码量

else：

当try中未出现错误，会执行else语句

def Func(data):
    try:
        print(int(10 / int(data)))  # try里面是可以输出内容的
    except Exception as msg:
        print(msg)
    else:
        print('程序无异常！')


Func(5)

运行结果：

finally：

无论是否报错都会执行的语句

def Func(data):
    try:
        print(int(10 / int(data)))  # try里面是可以输出内容的
    except Exception as msg:
        print(msg)
    finally:
        print('程序运行结束！')


Func(5)

运行结果：

注意：虽然finally在这里显得很多余，但用其释放资源很方便。

自定义错误

直接或间接继承Exception类或者Error类

案例：当字符长度超过5时，抛出异常

class LenError(Exception):  # 继承Exception类
    def __str__(self):
        return '您的字符长度超过所限制的5个字符！'  # 自定义异常，msg内容来自__str__方法


str = 'hello python!'
try:
    if len(str) > 5:
        raise LenError  # raise用来抛出异常，不可用return（程序会停止运行）
    else:
        print(str)
except LenError as msg:
    print(msg)

运行结果：

动态属性和方法

动态属性

支持实例属性和类属性的添加

添加实例属性：

通过实例对象添加

class Student:
    def __init__(self, name, age):
        self.name = name  # 初始方法定义实例变量
        self.age = age

    def __str__(self):
        return '【{}】今年【{}】岁了。'.format(self.name, self.age)


zyh = Student('张艳华', 20)
zyh.weight = '101'  # 动态添加实例属性
print(zyh.weight)

运行结果：

动态添加的属性仅对该实例对象有效，验证：

class Student:
    def __init__(self, name, age):
        self.name = name  # 初始方法定义实例变量
        self.age = age

    def __str__(self):
        return '【{}】今年【{}】岁了。'.format(self.name, self.age)


zyh = Student('张艳华', 20)
zyh.weight = '101'  # 动态添加实例属性
wh = Student('王浩', 19)
print(wh.weight)

运行结果：

添加类属性：

通过类对象添加

class Student:
    def __init__(self, name, age):
        self.name = name  # 初始方法定义实例变量
        self.age = age

        
zyh = Student('张艳华', 20)
Student.weight = 101  # 动态添加类属性
print(zyh.weight)

运行结果：

动态方法

原理是把一个外部函数通过转换（types.MethodType()）使其成为实例方法

添加实例方法：

通过实例对象添加，仅对该实例对象有效

import types  # 导入用来转换的types包


class Student:
    def __init__(self, name, age):
        self.name = name  # 初始方法定义实例变量
        self.age = age


def func(self):  # 自定义的一个外部函数，self不能忘记
    print('【{}】今年【{}】岁了！'.format(self.name, self.age))


zyh = Student('张艳华', 20)
zyh.printData = types.MethodType(func, zyh)  # 实例对象.方法名=types.MethodType(外部函数名, 实例对象)
zyh.printData()  # 实例对象.方法名（调用定义的实例方法）

运行结果：

添加类方法和静态方法：

通过类对象实现

class Student:
    def __init__(self, name, age):
        self.name = name  # 初始方法定义实例变量
        self.age = age


@classmethod  # 定义的外部方法，要满足类方法的条件：1、注明@classmethod 2、第一个参数默认是cls
def func(cls):
    print('这是一个类方法！')


Student.testFunc = func  # 动态添加类方法（通过类对象实现的），（类对象.方法名=外部方法名）
zyh = Student('张艳华', 20)
zyh.testFunc()  # 验证类方法是否添加成功（实例对象调用类方法）

运行结果：

注意：

静态方法同理（外部方法，要满足静态方法的条件）
类、静态方法不需要导入types包

_slots_

限制属性

添加属性（未使用slots方法）：

class Student:
    pass


xm = Student()
xm.name = '小明'  # 动态添加实例属性
xm.age = 19
print(xm.name, xm.age)

运行结果：

限制属性添加（使用slots方法）：

class Student:  # 使用slots方法限制属性的添加，字符串类型的属性名放入元组中，逗号分隔
    __slots__ = ('name')  # 仅允许添加一个名为name的属性
    pass


xm = Student()
xm.name = '小明'  # 动态添加实例属性
xm.age = 19
print(xm.name, xm.age)

运行结果：

节省内存

dict存放所有属性（消耗内存）：

class Student:
    pass


xm = Student()
xm.name = '小明'  # 动态添加实例属性
xm.age = 19
print(xm.__dict__)  # dict默认存放所有属性及其值

运行结果：

使用slots后dict会被删除（节省内存）：

class Student:
    __slots__ = ('name', 'age')
    pass


xm = Student()
xm.name = '小明'  # 动态添加实例属性
xm.age = 19
print(xm.__dict__)  # dict默认存放所有属性及其值

运行结果：

继承关系

案例1：父类限制属性（name，age），子类不限制，验证slots的限制不可继承

class Student:  # 父类
    __slots__ = ('name', 'age')  # 限制属性
    pass


class Computer(Student):  # 子类继承Student类
    pass


lm = Computer()
lm.sex = '男'  # 动态定义实例属性（该属性不在父类slots限制中）
print(lm.sex)  # 输出实例属性的内容

运行结果：

案例2：父类限制属性（name，age），子类限制属性（sex），验证slots的限制为其并集（父类+子类）

class Student:  # 父类
    __slots__ = ('name', 'age')  # 父类限制属性
    pass


class Computer(Student):  # 子类继承Student类
    __slots__ = ('sex')  # 子类限制属性
    pass


lm = Computer()
lm.name = '李明'  # 父类限制
lm.age = 18  # 父类限制
lm.sex = '男'  # 子类限制
print('我叫【{}】，是个【{}】孩子，今年【{}】岁了！'.format(lm.name, lm.sex, lm.age))  # 输出实例属性的内容