day 21 封装，多态，类的其他属性

封装

封装：将一些数据，重要的信息等等放到一个地方（空间中）

class A:
    country = 'China'
    area = '深圳'
    def __init__(self,name,age):
        self.name = name
        self.age = age

a1 = A('小明',22)
a2 = A('小华',23)
print(a1.__dict__)
print(a2.__dict__)

多态
python默认支持多态

i = 777alex
i = ‘我是字符串’

鸭子类型：python会约定俗成制定一些行为规范，保持一致性

类的约束

对类进行一些正确的引导，约束，统一规范，满足正确的可发方式

两种约束方法：

方法一：python常用的一种，在父类写一个相同的方法pay，在此方法里面，主动抛出一个错误（raise）

class A:    # 这个父类制定了一个约束，规范，子类一定要有pay方法
    def pay(self,money):
        raise Exception('未定义的方法')

class Alipay(A):
    def pay(self,money):
        print('alipay')

class QQpay(A):
    def zhifu(self,money):  # 未按规定填写pay，而用了zhifu，会报 raise Exception('未定义的方法') 错误
        print('QQpay')

def pay(obj,money):
    obj.pay(money)

q = QQpay()
# pay(q,100)
a = Alipay()
pay(a,200)

方法二：在父类引用元类的抽象方法，抛出异常

from abc import ABCMeta,abstractmethod
class A(metaclass=ABCMeta):    # 这个父类制定了一个约束，规范，子类一定要有pay方法
    '''
    抽象类，接口类：制定一个规范，强制执行。
    '''
    @abstractmethod
    def pay(self,money):
        raise Exception('未定义的方法')

class Alipay(A):
    def pay(self,money):
        print('alipay')

class QQpay(A):
    def zhifu(self,money):  # 未按规定填写pay，而用了zhifu，会报 raise Exception('未定义的方法') 错误
        print('QQpay')

def pay(obj,money):
    obj.pay(money)

q = QQpay()
pay(q,100)
# a = Alipay()
# pay(a,200)

类的私有成员

class Boss:

    name = 'alex'  # 公有静态属性  公有静态字段
    __secretary =['女1', '男2', '眼膜']  # 私有静态属性  私有静态字段，有__表示

    def __init__(self,username,password):
        self.username = username  # 公有对象属性  公有普通字段
        self.__password = password  # 私有对象属性  私有普通字段

    def func(self):   # 用方法查看私有静态属性
        print(self.__secretary)

    def __func(self):  # 私有方法
        print('经常跟秘书加班....')

class Boss_son(Boss):
    def func(self):
        print(self.__secretary)

私有成员：私有静态属性，私有对象属性，私有方法

私有静态属性：
类外部不能访问，通过对象可以外部访问

私有方法：

类外部和派生类不能访问

类的类方法，静态方法

class A:
    name = 'barry'

    def __init__(self,a,b):  # 双下方法
        self.a = a
        self.b = b

    def func(self):  # 普通方法，实例方法
        pass

    @staticmethod  # 静态方法
    def func1():
        print(666)

    @classmethod  # 类方法
    def func2(cls):
        print(777)

    @property  # 属性
    def bim(self):
        print(111)

类方法：  @classmethod

类方法 他是通过类名直接调用的方法，类方法里面至少有一个参数，第一个参数默认cls

class A:
    name = 'ehco'
    @classmethod
    def func(cls):
        print(cls)
        print(111)
    def func1(self):
        print(self)

A.func()      # 可以直接用类名调用的方法，传的参数是类名
A.func1(123)  # 和上面的作对比 ，这个需要传参

# 对象可否调用类方法？
# 通过对象也可以调用类方法，cls 接受的不是对象空间而是类空间。
a = A()
a.func()  # <class '__main__.A'>  类名的内存地址

类方法在哪里用？
对类中的属性方法直接操作，与对象无关，这样才会用到类方法。

# 判断有多少人注册

class ClassTest(object):
    __num = 0

    @classmethod
    def addNum(cls):
        cls.__num += 1

    @classmethod
    def getNum(cls):
        return cls.__num

    # 这里我用到魔术函数__new__，主要是为了在创建实例的时候调用人数累加的函数。
    def __new__(self):
        ClassTest.addNum()   # 实例化一个对象，就调用一次addNum
        return super(ClassTest, self).__new__(self) #返回一个真正的__new__去创建空间

class Student(ClassTest):
    def __init__(self):
        self.name = ''

a = Student()
b = Student()
print(ClassTest.getNum())

静态方法

为什么要静态方法；相似功能，保持一致性     @staticmethod

对象调用类里面的方法，不会影响方法的使用

import time

class TimeTest(object):
    def __init__(self, hour, minute, second):
        self.hour = hour
        self.minute = minute
        self.second = second

    @staticmethod
    def showTime():
        return time.strftime("%H:%M:%S", time.localtime())

print(TimeTest.showTime())  # 打印当前时间
t = TimeTest(2, 10, 10)   # 示例对象t
nowTime = t.showTime()  #  t调用静态方法，并不会改变方法的执行
print(nowTime)  # 打印当前时间

类的属性： @property     @xxx.setter    @ xxx.deleter

@property：属性

将一个方法伪装成属性，虽然在代码逻辑上没什么提高。但是让其看起来更合理

# 调用的时候少一个括号，看着没什么用
class Bmi:
    def __init__(self,name,weight,height):
        self.name = name
        self.weight = weight
        self.height = height
    @property
    def bmi(self):
        return self.weight / self.height **2
pang = Bmi('小胖',75,1.76)
# print(pang.bmi())  # 如果没有@property，调用的时候加()
print(pang.bmi)     # 如果有@property，调用的时候不要()

@xxx.setter   @ xxx.deleter  这两个和@property一起使用

class Market:
    def __init__(self, name, price, discount):
        self.name = name
        self.__price = price   # 私有属性
        self.__discount = discount  # 定义折扣

    @property
    def price(self):   # 返回折后价
        return self.__price * self.__discount

    @price.setter
    def price(self, new_price):  # 计算降价后的折扣价
        self.__price = new_price / self.__discount

    @price.deleter
    def price(self):  # 删除价格
        del self.__price
apple = Market('苹果',8,0.95)
print(apple.price)
apple.price = 7.5   # 看到改等式，就执行@price.setter。并把7.5传给 new_price
print(apple.price)
del apple.price   # 看到del price，就执行@price.deleter
print(apple.price)

异常处理 :  多种 try.......except.....

python解释器检测到错误，触发异常（也允许程序员自己触发异常
程序员编写特定的代码，专门用来捕捉这个异常（这段代码与程序逻辑无关，与异常处理有关）
如果捕捉成功则进入另外一个处理分支，执行你为其定制的逻辑，使程序不会崩溃，这就是异常处理

try:
    l1 = [1,2,3]
    l1[100]            # list index out of range
except Exception as e:
    print(e)
print(111)  # 程序即使有错误也不影响后面文件的执行
print(222)
print(333)

单支 try  except

try:
    l1 = [1,2,3]
    l1[100]  # IndexError  # 程序发现错误，直接跳到except。然后执行后续代码
    print(333)
    print(5555)
except IndexError as e:
    print(e)
print(777)

多支 try  except

try:
    l1 = [1,2,3]
    # l1[100]  # IndexError
    print(333)
    print(5555)
    dic = {'key1':'v1'}
    dic['key2']  # KeyError
    num = int(input('请输入选项：'))
    print(777)
except IndexError as e:
    print(e)
except KeyError as e:
    print(e)

接收所有错误：try .except  EXCEPOTION

try:
    l1 = [1,2,3]
    # l1[100]  # IndexError
    print(333)
    print(5555)
    dic = {'key1':'v1'}
    # dic['key2']  # KeyError
    num = int(input('请输入选项：'))
    print(777)
except Exception as e:  # 接收所有错误
    print(e)

# 以上这三种分情况讨论：
# 1，如果你对报错信息不关系，只是想直接跳过报错而不分流执行代码。 万能异常最好。
# 2，如果你想要捕捉具体的错误信息，根据不同的错误执行不同的分支。多分支比较好。

try expcet else  
出现异常不执行else语句，没有异常就执行else语句

try:
    l1 = [1, 2, 3]
    l1[100]  # IndexError
except IndexError:
    print(666)
else:
    print('出现异常不执行else语句，没有异常就执行else语句')

try  except finally  有没有错误finally都会执行
用处： 关闭文件句柄，断开数据库连接

try:
    l1 = [1, 2, 3]
    # l1[100]  # IndexError
    dic = {}
    dic['key1']
except IndexError:
    print(666)
else:
    print('出现异常不执行else语句，没有异常就执行else语句')
finally:
    print('finally有没有异常都执行finally语句')

finally有没有异常都执行finally语句，要他有何用？
1,关闭文件句柄，数据库链接等。
with open('log',encoding='utf-8') as f1:
    try:
    # f1.read() 好几千代码
    finally:
        f1.close()

# 函数,return  循环的break 之前执行finally操作。
def func():
    try:
        return 666
    finally:
        print(111)   # 会执行
func()

while被break打断，finally也会执行
while 1:
    try:
        break
    finally:
        print(777)

raise 主动抛出错误

class MyError(BaseException): # 自定义一个错误
    pass
try:
    raise MyError('我的错误')  # 主动跑出自定义错误
except MyError as e:
    print(e)

assert 1 == 2