day21_python_1124

01 昨日内容回顾
类与类之间的关系:
依赖关系：将一个类的对象或者类名传到另一个类中。
关联关系
组合关系：将一个类的对象封装到另一个类的对象属性中。
聚合关系

boy gril
school teacher
多继承：
经典类：不继承object的类，只存在于python2x 深度优先
新式类：继承后object的类，存在python3x，python2x，c3算法。
mro() __mro__
02 作业讲解

03 面向对象的三大特性：封装，多态。
04 类的约束。
05 类的私有成员。
06 类的类方法，静态方法
07 类的属性
08 异常处理

# 03 封装，多态

# 封装：将一些数据，重要的信息等等放到一个地方（空间中）。# 面相对象:

# 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__)

# # 万能的.# print(a1.name)

# 多态# what：一种事物有多种形态。# 水：液态，固态，气态。# 变色龙：各种颜色各种变化。# 超人：带上眼睛就是记者，红内裤外穿就是超人，关上灯，就是男人。# python默认支持多态。

# int i = 7777# int i = 'abc'# 了解# python# class F1:#     pass

# class S1(F1):

#     def show(self):#         print('S1.show')

# class S2(F1):##     def show(self):#         print ('S2.show')

# obj = S1()# obj.show()

# def func(obj):#     obj.show()

# func(11)

# java# class F1:#     pass

# class S1(F1):##     def show(self):#         print('S1.show')

# class S2(F1):

#     def show(self):#         print('S2.show')

# def func(F1, obj):#     obj.show()

# 鸭子类型：看着像鸭子，你就鸭子。

# python 会约定俗称制定一些行为规范，保持一致性。

# class A:#     def func1(self):#         print('in A func1')##     def func2(self):#         print('in A func2')

# class B:#     def func1(self):#         print('in B func1')##     def func2(self):#         print('in B func2')

# str# bytes# 将 A,B里面相似的一些功能命名成相同的名字，隐约制定一个标准# obj1 = A()# obj1.func1()# obj2 = B()# obj2.func1()

# 源码；# str index# class Str_:#     def index(self):#         print('根据元素找索引')

# class List_:#     def index(self):#         print('根据元素找索引')

# class Tuple_:#     def index(self):#         print('根据元素找索引')

# 04 类的约束

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

# 第一版：新员工完成了，老大说了，你需要改进一下同一支付的功能。# class Alipay:

#     def pay(self,money):#         print('此次消费%s'% money)

# class QQpay:#     def pay(self,money):#         print('此次消费%s' % money)

# a = Alipay()# b = QQpay()

# a.pay(100)# b.pay(200)

#修改# class Alipay:

#     def pay(self,money):#         print('此次消费%s'% money)

# class QQpay:#     def pay(self,money):#         print('此次消费%s' % money)

# def pay(obj,money):  # 归一化设计#     obj.pay(money)

# a = Alipay()# a1 = Alipay()# b = QQpay()# pay(a,100)# pay(b,200)# pay(a1,300)

# 此时找来一个野生程序员，春哥，接替小潘的工作，添加一个微信支付功能吧。# class Alipay:

#     def pay(self,money):#         print('此次消费%s'% money)

# class QQpay:#     def pay(self,money):#         print('此次消费%s' % money)

# class Wechatpay:  # 太low了,正规化#     def fuqian(self,money):#         print('此次消费%s' % money)

# def pay(obj,money):  # 归一化设计#     obj.pay(money)

# a = Alipay()# a1 = Alipay()# b = QQpay()# pay(a,100)# pay(b,200)# pay(a1,300)# c = Wechatpay()# c.fuqian(300)

# 上面的没有约束力，不规范，制定一个标准，约束标准。# class A: # 这个父类制定了一个约束，规范，子类一定要有pay方法。#     def pay(self,money):#         pass

# class Alipay(A):

#     def pay(self,money):#         print('此次消费%s'% money)

# class QQpay(A):#     def pay(self,money):#         print('此次消费%s' % money)

# class Wechatpay(A):  # 太low了,正规化#     def pay(self,money):#         print('此次消费%s' % money)

# def pay(obj,money):  # 归一化设计#     obj.pay(money)

# a = Alipay()# a1 = Alipay()# b = QQpay()# c = Wechatpay()# pay(a,100)# pay(b,200)# pay(a1,300)# pay(c,400)

# 春哥会了，跟小潘去了一个组，接下来这个任务需要人接，找了一个其他培训机构，半野生。

# class A: # 这个父类制定了一个约束，规范，子类一定要有pay方法。#     def pay(self,money):#         pass

# class Alipay(A):

#     def pay(self,money):#         print('此次消费%s'% money)

# class QQpay(A):#     def pay(self,money):#         print('此次消费%s' % money)

# class Wechatpay(A):  # 太low了,正规化#     def pay(self,money):#         print('此次消费%s' % money)

# class Unitypay(A):#     def zhifu(self,money):#         print('此次消费%s' % money)

# def pay(obj,money):  # 归一化设计#     obj.pay(money)

# # a = Alipay()# # a1 = Alipay()# # b = QQpay()# # c = Wechatpay()# # pay(a,100)# # pay(b,200)# # pay(a1,300)# # pay(c,400)# d = Unitypay()# pay(d,200)# 此时全凭自觉不行了，咱们强制加一个约束，只要不按照我的规则执行，就报错。

# 两种解决方式：# 1，python常用的一种，在父类写一个相同的方法pay 在此方法里面，主动抛出一个错误，你应该在自己的类中定义此方法。# 用第一种是python经常用的解决方式。# class A: # 这个父类制定了一个约束，规范，子类一定要有pay方法。#     def pay(self,money):#         raise Exception('未定义pay方法')# class Alipay(A):

#     def pay(self,money):#         print('此次消费%s'% money)

# class QQpay(A):#     def pay(self,money):#         print('此次消费%s' % money)

# class Wechatpay(A):  # 太low了,正规化#     def pay(self,money):#         print('此次消费%s' % money)

# class Unitypay(A):#     def zhifu(self,money):#         print('此次消费%s' % money)

# def pay(obj,money):  # 归一化设计#     obj.pay(money)

# a = Alipay()# a1 = Alipay()# b = QQpay()# c = Wechatpay()# pay(a,100)# pay(b,200)# pay(a1,300)# pay(c,400)# d = Unitypay()# pay(d,200)  #出问题

# 解决方式2：在父类引用元类的抽象方法，抛出异常。

# from abc import ABCMeta,abstractmethod

# class A(metaclass=ABCMeta): # 这个父类制定了一个约束，规范，子类一定要有pay方法。    '''    抽象类，接口类：制定一个规范，强制执行。    '''#     @abstractmethod#     def pay(self,money):#         pass##     def func(self):#         pass# class Alipay(A):##     def pay(self,money):#         print('此次消费%s'% money)## class QQpay(A):#     def pay(self,money):#         print('此次消费%s' % money)

# class Wechatpay(A):  # 太low了,正规化#     def pay(self,money):#         print('此次消费%s' % money)## class Unitypay(A):#     # def zhifu(self,money):#     #     print('此次消费%s' % money)#     def pay(self,money):#         print('此次消费%s' % money)## def pay(obj,money):  # 归一化设计#     obj.pay(money)

# a = Alipay()# a1 = Alipay()# b = QQpay()# c = Wechatpay()# pay(a,100)# pay(b,200)# pay(a1,300)# pay(c,400)# d = Unitypay()# pay(d,200)

# 05 类的私有成员

'''类的结构：class A:

    静态属性

    方法'''# 按照公有，私有对 类进行划分。

# 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)

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

# 私有静态属性# 类外部访问，类内部访问，派生类访问# print(Boss.name)# print(Boss.__secretary) # 类外部不能访问

# b = Boss('alex123',123)# b.func()  # 类内部可以访问# b2 = Boss_son('smallalex','123')# b2.func()

# class Boss:

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

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

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

# class Boss_son(Boss):#     def func(self):#         # print(self.__secretary)#         self.__func()# a1 = Boss('alex',666)# # a1.__func()  # 类外部不能访问# # a1.func() # 类内部可以访问# b1 = Boss_son('fdsa',123)# b1.func() # 类的派生类不能访问

# 私有成员当真访问不到么？ 不是，python做了一些加工。# 私有属性# class Boss:

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

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

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

# b1 = Boss('alex',123)# print(Boss.__dict__)# python 将我的私有成员  _类名__私有成员# print(Boss._Boss__secretary)# 私有成员虽然在类外面或者派生类可以访问到，但是不要这么做。

# 06 类的类方法，静态方法

# class A:#     name = 'barry'

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

#     def __call__(self, *args, **kwargs):#         pass

#     def __str__(self):#         pass

#     def __new__(cls, *args, **kwargs):#         pass

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

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

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

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

# 类方法# class A:#     name = 'barry'##     @classmethod  # 类方法#     def func2(cls):#         print(cls)#         print(777)##     def func1(self):#         print(self)

# a = A()# # print(a)# # a.func1()

# 类方法 他是通过类名直接调用的方法，类方法里面至少有一个参数，第一个参数默认cls# print(A)# A.func2()# 对象可否调用类方法？# 通过对象也可以调用类方法，cls 接受的不是对象空间而是类空间。# a = A()# a.func2()

# 类方法在哪里用？# 对类中的属性方法直接操作，与对象无关，这样才会用到类方法。# 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()#         return super(ClassTest, self).__new__(self)

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

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

# 静态方法

# class A:

#     name = 'barry'

#     @staticmethod#     def func():#         print(666)# obj = A()# # A.func()# obj.func()

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

import time

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

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

# print(TimeTest.showTime())# t = TimeTest(2, 10, 10)# nowTime = t.showTime()# print(nowTime)

# 07 类的属性

# 属性

# 体质指数（BMI）=体重（kg）÷身高^2（m）

# 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('小胖',83,1.78)# barry = Bmi('太白',80,1.76)# # print(barry.bmi())# print(barry.bmi)# 属性：将一个方法伪装成属性，虽然在代码逻辑上没什么提高，# 但是让其看起来更合理一些。

# class A:

    # def __init__(self,username,password):    #     self.__username = username    #     self.__password = password

    # @property    # def name(self):    #     return self.__username

    # @name.setter    # def name(self,a):    #     if type(a) is str:    #         self.__username = a    #     else:    #         print('账号必须是字符串类型')

    # @name.deleter    # def name(self):    #     print(888)

# p1 = A('barry',123)# print(p1.__username)  # 这样访问不到

# print(p1.name)# p1.name# p1.name = '春哥'# print(p1.name)# # del p1.name# # p1 = A('barry',123)# # # p1.name = 111# # p1.name = '春哥'# # print(p1.name)

# class Market:#     def 商品名，商品价格，商品折扣

#     @property#     def price

#     @price.setter#     #通过传入的价格/折扣

# 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# print(apple.price)# del apple.price# print(apple.price)

# 08 异常处理

# 异常？报错#报错分为两个方面：#语法错误。# 1name = 'alex'# name1 = name2# if 3 > 2#     print(666)# 以上的这些语法错误，开发的时候一定要避免。

# 逻辑错误。# num = int(input('请输入选项：'))

# 异常：在程序中只要出现了这种异常，程序会立马停掉，体验感极差，# 遇到类似于这种逻辑上的异常，要先捕捉异常，根据不同异常，进行不同处理。

# 逻辑错误。# num = int(input('请输入选项：'))

# 异常：在程序中只要出现了这种异常，程序会立马停掉，体验感极差，# 遇到类似于这种逻辑上的异常，要先捕捉异常，根据不同异常，进行不同处理。

# num = int(input('请输入选项：'))  ValueError

# l1 = [1,2,3]# l1[100]  # IndexError# dic = {'key1':'v1'}# dic['key2']  # KeyError

# 解决异常的方式：# 1，利用if语句解决异常,只能处理简单少量的异常。

# num = input('请输入选项：')

# if num.isdigit():#     int(num)#     if#         if#             if

# else:#     pass

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

# try .except 单支# try:#     l1 = [1,2,3]#     l1[100]  # IndexError#     print(333)#     print(5555)#     # dic = {'key1':'v1'}#     # dic['key2']  # KeyError#     print(777)# except IndexError as e:#     print(e)

# try .except  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:#             num = input('请输入你要办理的业务：').strip()#             num = int(num)#             menu_dict[num]()#         except ValueError:#             print('请输入数字')#         except KeyError:#             print('超出范围，请重新输入')#         except Exception :#             print("出现未知错误.....")

# 4, 一般会采取多分支 + 万能异常的形式。'''        try:            num = input('请输入你要办理的业务：').strip()            num = int(num)            menu_dict[num]()        except ValueError:            print('请输入数字')        except KeyError:            print('超出范围，请重新输入')        except Exception :            print("出现未知错误.....")'''

# try:#     l1 = [1,2,3]

#     # l1[100]  # IndexError

#     dic = {'key1':'v1'}#     # dic['key2']  # KeyError#     num = int(input('请输入选项：'))

# except IndexError as e:#     print(e)#     print(333)#     print(5555)# except KeyError as e:#     print(e)#     print(777)

# 剩余代码：# if 3 > 2:#     print(666)

# try expcet else

# try:#     l1 = [1, 2, 3]#     l1[100]  # IndexError# except IndexError:#     print(666)# print(111)# print(2)

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

# try expcet else Fianlly

# 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 1:#     try:#         break#     finally:#         print(777)

# 主动抛出异常（用过）。# try:#     raise TypeError('类型错误')# except Exception as e:#     print(e)

# 很重要。

# class PhoneconnectionError(BaseException):#     pass## try:#     raise PhoneconnectionError('连接错误...')# except PhoneconnectionError as e:#     print(e)

# 条件不成立 主动报错# assert 1 == 2