'''
1什么是多态
多态指的是同一种/类事物的不同形态 2 为何要有多态
多态性：在多态的背景下，可以在不用考虑对象具体类型的前提下而直接使用对象
多态性的精髓：统一
多态性的好处：
1增加了程序的灵活性：
以不变应万变，不论对象千变万化，使用者都是同一种形式去调用
2增加了程序可扩展性
继承一个Animal类创建一个新的类，使用者无需更改自己的代码，还是用原来的方式调用
3 如何用多态 '''
'''
class Animal:
def speak(self):
pass class People(Animal):
def speak(self):
print('say hello') class Dog(Animal):
def speak(self):
print('wang wang wang') class Pig(Animal):
def speak(self):
print('哼哼哼') obj1=People()
obj2=Dog()
obj3=Pig() # obj1.speak()
# obj2.speak()
# obj3.speak() def speak(animal):
animal.speak() speak(obj1)
speak(obj2)
speak(obj3)
# say hello
# wang wang wang
# 哼哼哼 多态性带来的好处，比如python的系列类型有多种形态：字符串，列表，元组，多态性提现下 s1='hello'
l1=[1,2,3]
t1=(1,2) 我们可以在不考虑三者类型的前提下使用是 s l t
print(len(s1)) #s1.__len__()
print(len(l1)) #l1.__len__()
print(len(t1)) #t1.__len__() '''
# import abc
#
#
# class Animal(metaclass=abc.ABCMeta):
# @abc.abstractmethod
# def speak(self):
# pass
#
# @abc.abstractmethod
# def run(self):
# pass # Animal() 父类只是用来建立规范的，不能用来实例化的，更无须实现内部的方法
# 只是规定有这些方法或者属性 具体属性或者方法在子类中具体实现
# class People(Animal):
# def speak(self):
# print('say hello')
#
# def run(self):
# pass
#
#
# class Dog(Animal):
# def speak(self):
# print('汪汪汪')
#
# def run(self):
# pass
#
#
# class Pig(Animal):
# def speak(self):
# print("哼哼哼")
#
# def run(self):
# pass
#
#
# obj = People()
# obj2 = Dog()
# obj3 = Pig() # 上面是强制性的，父类有的方法，子类必须有 # obj.speak()
# obj2.speak()
# obj3.speak()
# say hello
# 汪汪汪
# 哼哼哼 # python 崇尚鸭子类型
# 利用标准库中定义的各种‘与文件类似’的对象，尽管这些对象的工作方式像文件，但他们没有继承内置文件对象的方法
# class Disk:
# def read(self):
# print('Disk read')
#
# def write(self):
# print('Disk write')
#
#
# class Memory:
# def read(self):
# print('Mem write')
#
# def write(self):
# print('Mem write')
#
#
# class Cpu:
# def read(self):
# print('Cpu read')
#
# def write(self):
# print('Cpu write') # obj=Disk()
# obj2=Memory()
# obj3=Cpu()
#
# obj.read()
# obj2.read()
# obj3.read() # Disk read
# Mem write
# Cpu read # 反射: 通过字符串来反射/映射到对象/类的属性上
# (之前是 xx.属性来映射或反射到类或对象的属性上)
# class People:
# def __init__(self,name,age):
# self.name=name
# self.age=age
# def run(self):
# print('%s is running' %self.name)
#
#
# obj=People('egon',18) # print(obj.__dict__) #{'name': 'egon', 'age': 18}
# print(obj.name) #obj.__dict__['name'] #egon
# obj.name="EGON" #obj.__dict__['name']="EGON"
# del obj.name #del obj.__dict__['name']
# print(obj.__dict__) #{'age': 18}
# obj.sex='male' #obj.__dict__['sex']='male' # print(hasattr(obj, 'name')) #True 'name' in obj.__dict__ # print(getattr(obj, 'name')) #拿到值egon obj.__dict__['name']
# print(getattr(obj, 'xx', None)) #拿值 没有则返回None obj.__dict__['xx'] # setattr(obj, 'name', 'EGON') #obj.__dict__['name']='EGON' #EGON 有name就改值
# setattr(obj,'xxx','2222') #{'name': 'egon', 'age': 18, 'xxx': '2222'} 没有就创建
# print(obj.name)
# print(obj.__dict__) # delattr(obj,'name')
# print(obj.__dict__) #{'age': 18} # import os
# os.remove
# print(hasattr(os,'remove')) #True # class Ftp:
# def get(self):
# print('get')
# def put(self):
# print('put')
#
# def login(self):
# print('login')
#
# def run(self):
# while True:
# cmd=input(">>>: ").strip() #cmd='get'
# if hasattr(self,cmd): #cmd in self.__dict
# method=getattr(self,cmd) #self.__dict__['cmd']
# method()
#
# else:
# print('输入方法不存在')
#
#
# obj=Ftp()
# obj.run() # 内置方法：
# __str__：在对象被打印时自动触发，可以用来定义对象被打印时的输出信息
# 注意：必须返回一个字符串类型的值
# class People:
# def __init__(self,name,age):
# self.name=name
# self.age=age
#
# def __str__(self):
# # print('run.....')
# return 'name: %s age:%s'%(self.name,self.age)
# obx=People('egon',18)
# print(obx) #print(obx.__str__())
# name: egon age:18 # obj1=list([1,2,3])
# print(obj1) #[1, 2, 3] # __del__:在对象被删除时先自动触发该方法，可以用来回收对象以外其他相关资源，比如系统资源
# class Foo:
# def __init__(self,x,filepath,encoding='utf-8'):
# self.x=x
# self.f=open(filepath,'rt',encoding=encoding)
#
# def __del__(self):
# print('run.....')
# #回收对象关联的其他资源
# self.f.close() # obj=Foo(1,'a.txt')
# print('========》') 1程序结束了会把占用的内存空间回收掉 删除对象 最后执行__del__回收对象关联的其他资源
# ========》
# run..... # obj=Foo(1,'a.txt') #程序没结束提前删除 会先执行__del__ 回收对象关联的其他资源
# del obj
# print('========》')
# run.....
# ========》 '''
1 什么是异常处理
异常是错误发生的信号，一旦程序出错就会产生一个异常，如果该异常
没有被应用程序处理，那么该异常就会被抛出来，程序的执行也随之终止 异常包含三个部分：
1 traceback异常的追踪信息
2 异常的类型
3 异常的信息 错误分为两大类：
1 语法上的错误:在程序运行前就应该立即修正
2 逻辑上的错误 2 为和要有异常处理
避免程序因为异常而崩溃，所以在应用程序中应该对异常进行处理，从而增强程序的健壮性 3 如何异常处理
try:
代码1
代码2 #抛出一种异常 #！！！！下面代码块不会执行
代码3
。。。
except NameError: #捕获异常也只会捕获一种异常下面的except分支不会执行（像if 。。elif...一样）
当抛出的异常是NameError时执行的子代码块
except....:
pass
except...:
pass
else:
pass #else的子代码块会在被检测的代码块没有异常的情况下执行
finally:
pass #无论被检测的代码有没有异常都会执行 '''
# 语法错误
# print('asdjfkj'
# 1 常见的逻辑错误导致的异常
# age=input('>>: ').strip()
# print(age>10) #TypeError # for i in 10: #TypeError
# pass
# import os #AttributeError
# os.xxx
# 1/0 #ZeroDivisionError # print('====1')
# print('====2')
# print('====3')
# # l=[1,2,3]
# # l[100] #IndexError
# print('====4')
# # d={'x':1,'y':2}
# # d['z'] #KeyError
# print('====5') # 2.异常处理
# 异常处理的单分支
# try:
# print('=====1')
# print('=====2')
# print('=====3')
# d = {'x': 1, 'y': 2}
# d['z'] # KeyError
# print('=====4')
# l = [1, 2, 3]
# l[1000] # IndexError
# print('=====5')
# except IndexError:
# print('IndexError')
# print('other code') # 异常处理的多分支
# try:
# print('=====1')
# print('=====2')
# print('=====3')
# d = {'x': 1, 'y': 2}
# d['z'] # KeyError
# print('=====4')
# l = [1, 2, 3]
# l[1000] # IndexError
# print('=====5')
# except KeyError as e:
# print('KeyError',e)
# except IndexError as e:
# print('IndexError',e)
#
# print('other code') # try:
# print('=====1')
# print('=====2')
# print('=====3')
# d = {'x': 1, 'y': 2}
# # d['z'] # KeyError
# print('=====4')
# l = [1, 2, 3]
# l[1000] # IndexError
# print('=====5')
# except (KeyError,IndexError) as e: #except（里面多个错误捕获类型）
# print(e)
# print('other code') # 万能异常类型Exception:可以匹配任意类型的异常
# try:
# print('=====1')
# print('=====2')
# print('=====3')
# d = {'x': 1, 'y': 2}
# # d['z'] # KeyError
# # xxx
# print('=====4')
# l = [1, 2, 3]
# l[1000] # IndexError
# print('=====5')
# except IndexError as e:
# print('IndexError:', e)
# except KeyError as e:
# print('KeyError:', e)
# except Exception as e:
# print('Exception:',e)
#
# print('other code') # 主动触发异常
# print('===>1')
# print('===>2')
# raise TypeError('类型错误') #运行到这里就报错
# print('===>3') # class People:
# def __init__(self,name,age):
# self.__name=name
# self.__age=age
#
# def tell_info(self):
# print(self.__name,self.__age)
#
# def set_info(self,name,age):
# if not isinstance(name,str):
# raise TypeError('名字必须是str类型')
# if not isinstance(age,int):
# raise TypeError('年龄必须是int类型')
# self.__name=name
# self.__age=age # obj=People('egon',18)
# print(obj.__dict__) # {'_People__name': 'egon', '_People__age': 18}
# obj.tell_info() #egon 18 # obj.set_info('alex',123)
# obj.tell_info() #alex 123 # 自定义异常类型（了解）
# class MyException(BaseException):
# def __init__(self,msg):
# super().__init__()
# self.msg=msg
#
# def __str__(self): #在对象被打印时自动触发，可以用来定义对象被打印时的输出信息
# return '<%s>'%self.msg
#
# raise MyException('我自定义的异常')
# # __main__.MyException: <我自定义的异常> # 断言
print('上半部分，生产数据')
l=[1,2,3,4,5] # if len(l)!=5: #满足条件执行里面的 主动触发异常 下面代码不执行
# raise TypeError('类表长度必须为5')
assert len(l)==5 #相当于门槛，满足条件才执行下面的代码
#AssertionError print('下半部分，处理数据')
封装：封装的真谛在于明确地区分内外，封装的属性可以直接在内部使用，而不能被外部直接使用，然而定义属性的目的终归是要用，外部想要类隐藏的属性，需要我们为其开辟接口，让外部能够间接地用到我们隐藏起来的属性，意义：
1封装数据：将数据隐藏起来这不是目的。隐藏起来然后对外提供操作该数据的接口，然后我们可以在接口附加对数据的操作限制，以此完成对数据属性操作的严格控制。
class Teacher:
def __init__(self,name,age):
# self.__name=name
# self.__age=age
self.set_info(name,age) def tell_info(self):
print('姓名:%s,年龄:%s' %(self.__name,self.__age))
def set_info(self,name,age):
if not isinstance(name,str):
raise TypeError('姓名必须是字符串类型')
if not isinstance(age,int):
raise TypeError('年龄必须是整型')
self.__name=name
self.__age=age t=Teacher('egon',18)
t.tell_info() t.set_info('egon',19)
t.tell_info()
2封装方法：目的是隔离复杂度
在编程语言里，对外提供的接口（接口可理解为一个入口），可以是函数，称为接口函数，这与接口的概念还不一样，接口代表一组接口函数的集合体。
#取款是功能,而这个功能有很多功能组成:插卡、密码认证、输入金额、打印账单、取钱
#对使用者来说,只需要知道取款这个功能即可,其余功能我们都可以隐藏起来,很明显这么做
#隔离了复杂度,同时也提升了安全性 class ATM:
def __card(self):
print('插卡')
def __auth(self):
print('用户认证')
def __input(self):
print('输入取款金额')
def __print_bill(self):
print('打印账单')
def __take_money(self):
print('取款') def withdraw(self):
self.__card()
self.__auth()
self.__input()
self.__print_bill()
self.__take_money() a=ATM()
a.withdraw() 隔离复杂度的例子
3在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的
#正常情况
>>> class A:
... def fa(self):
... print('from A')
... def test(self):
... self.fa()
...
>>> class B(A):
... def fa(self):
... print('from B')
...
>>> b=B()
>>> b.test()
from B #把fa定义成私有的，即__fa
>>> class A:
... def __fa(self): #在定义时就变形为_A__fa
... print('from A')
... def test(self):
... self.__fa() #只会与自己所在的类为准,即调用_A__fa
...
>>> class B(A):
... def __fa(self):
... print('from B')
...
>>> b=B()
>>> b.test()
from A
隐藏：在python中用双下划线开头的方式将属性隐藏起来（设置成私有的）
这仅仅只是一种变形操作且仅仅只在类定义阶段发生变形
类中所有双下划线开头的名称如__x都会在类定义时自动变形成：_类名__x的形式。
__delattr__() 删除属性前进行的操作需要继承super().__delattr__(属性）否则删除不了
__del__() 删除对象前进行的操作 释放和对象相关的其他资源
__delete__()删除对象的属性（属性是组合类型的 一个类的对象作为另外一个类的属性）