class Animal:                      # 定义动物的形态def run(self):                 # 定义走passclass People(Animal):                     # 定义人的形态def run(self):print("sey hello!")class Pig(Animal):                       # 定义猪的形态def run(self):print("sey hengheng")class Dog(Animal):                      # 定义狗的形态def run(self):print("sey wangwang")class Cat(Animal):def run(self):print("sey miaomiao!!")peo = People()
pig = Pig()
dog = Dog()           # 定义各自的形态
cat = Cat()peo.run()
pig.run()
dog.run()             # 不考虑实例而使用实例

还可更简单一步（拓展性）
def func(name):     # 定义一个接口，
    name.run()func(peo)
func(pig)
func(dog)
func(cat)

class File:                            # 定义文件类，实现读写方法def read(self):print("open's read")def write(self):print("open's write!")class Disk:                           # 定义磁盘类，实现读写方法def read(self):print("read disk")def write(self):print("disk is write!!")class Txt:                         # 定义文本档， 实现读写功能def read(self):print("txt is read")def write(self):print("write is txt")file = File()
disk = Disk()
txt = Txt()               # 把三类实例化def itea(name):         # 虽然三者没有继承关系，也不属于同一类， 但使用方法相同或相似，就可以定义个接口，以供调用
    name.read()name.write()itea(file)
itea(disk)              # 只传进去各个的类名，在更简洁的代码下，就可以实现相同的功能
itea(txt)# 这就是多态性的优势所在（可以为不同的类设置相同的调用方法（前提是：必须有相同的调用方式）

class A:        # 隐藏属性的写法(字符前加上__)__ppx = 1      # _A__ppx = 1 (后台执行时的名称)def __init__(self, name, age):self.__name = name       # self._A__name = nameself.__age = age         # self._A__age = agedef __foo(self):            # _A__foo(self):print("run.__foo")def dir_name(self):        # 调用时，也自动更改了调用方式self.__foo()            # 后台执行的代码：self._A__foo()print("my is dir_name")a = A("will", 18)
print(a.__ppx)                  # 报错发现不存在
print(a.__name)
print(a.__age, a.__sex)
print(a.__foo)                   # 成功实现所有属性的隐藏print(A.__dict__)                # 通过名称空间查看内部发生了什么变化
print(a.__dict__)
a.dir_name()# 发现命名和类的名称空间结构已经发生变化，实现属性隐藏

class Foo:dog = "dog"def func(self):                 # 没有加 __的属性print("form is func")def __foo(self,):               # 加了 __的属性print("form foo")class Func(Foo):def __foo(self):print("form foo 111111")f = Func()
f.func()      # 调用继承的不加的属性
f.__foo()   # 调用加了__的属性(发现无法覆盖, 在定义类之初，类内部存在__的属性，就会使类的调用方法发生变化，所以，他不会覆盖父类的属性，只是增加了自己的属性)

class B:__xx = 1
print(_B__xx)def __init__(self,  name):self.__name = nameB.__y = "alex"
b = B("will")
b.__f = "f"
print(B.__dict__)    # 发现在定义类体完成之后，再增加的属性不会被隐藏
print(b.__dict__)
print(b.__f)
print(B.__y)          # 发现都可以正常调用

# 验证问题3：实现类体内部自己调用自己，不使用其他的同名变量函数
class K:def __foo(self):print("form is K foo")def bar(self):print("form is bar")self.__foo()class M(K):def __foo(self):print("form is M foo")m = M()
m.bar()

class People:                           # 定义一个类def __init__(self, name, age):      # 设置隐藏属性self.__name = nameself.__age = agedef _format(self):                  # 定义接口并把隐藏属性定义规则（使其他人无法修改）print("name:<%s>, age:<%s>" % (self.__name, self.__age))def alter(self, name, age):         # 为了方便使用， 定义一个修改名称接口，便于多人调用if not isinstance(name, str):   # 可以为其设置条件，print("input error! is not str")returnelse:self.__name = nameif not isinstance(age, int):print("input error! is not int!")returnelse:self.__age = agep = People("will", 25)
p._format()
p.alter(4, 3)
p._format()

class ATM:def __plug(self):print("插卡")def __user(self):print("用户认证")def __money(self):print("取款金额")def __print(self):print("print bill")def __exit(self):print("exit card")def operate(self):self.__plug()self.__user()self.__money()self.__print()self.__exit()a = ATM()a.operate()

class Room:                                         # 定义一个房子类def __init__(self, name, owner, weight, length, height):        # 再次增加一个需求self.name = nameself.owner = ownerself.__weight = weight                      # 把计算面积的数值隐藏self.__length = lengthself.__height = heightdef area(self):                                # 后台计算方式封装成调用接口sum = int(self.__weight) * int(self.__length) * self.__heightprint("房间空间为 %sm³" % sum)r = Room("alex", "厨房", 10, 4, 5)r.area()                                           # 实现查看房屋面积功能（也实现了调用体积的功能）
# 更改了内部属性，但没有更改调用方式， 这就是可扩展性

class People:def __init__(self,name,  weight, height):self.name = nameself.weight = weightself.height = height@property                       # 加上这个功能，相当于在调用时执行 p.bmi 等同于执行 p.bmi()def bmi(self):iminit = self.weight/(self.height ** 2)print("your's BMI %s" % iminit)returnp = People("will", 100, 1.81)
p.bmi                    # 发现 访问数据属性，还要加括号

p.height = 1.88
p.bmi# 小结： property 的封装方法主要应用于正常访问不加括号，但是后台又必须加括号才能执行的地方

class People1:def __init__(self, name):self.__name = name@property                   # 封装调用函数时不加括号def name(self):print("get name")return self.__name@name.setter                # 把 property 封装的函数当做装饰器调用， 修改装饰器def name(self, val):print("revise")if not isinstance(val, str):print("input error!!!")returnelse:self.__name = val@name.deleter             # 封装的删除装饰器def name(self):print("delete")print("not is delete!!")p = People1("will")p.name = "pps"
print(p.name)                   # 成功实现查询、修改、删除的属性
del p.name

class Atm:"""验证绑定对象方法"""def __init__(self, name):self.name = namedef tell(self):print("name is %s" % self.name)f = Atm("will")
print(Atm.tell)                 # 类的函数类型
print(f.tell)                   # 绑定对象的方法class Atm:"""验证绑定到类的方法"""@classmethod                # 新的语法，在类内部调用类并自动传值def func(cls):print(cls)print(Atm.func)                 # 发现调用并绑定了自己
print(Atm)class Atm:"""非绑定方法的额验证"""def __init__(self, name):self.name = name@staticmethod                   # 非绑定方法的调用def tell(x,y):print(x+y)f = Atm
f.tell(3, 5)           # 绑定给对象
Atm.tell(5, 8)         # 类自己调用

# 定义一个类，查看每个人的用户信息
class People:def __init__(self, name, age, sex):self.id = self.class_id()               # 高深之处，先绑定类内的函数再定义函数self.name = nameself.age = ageself.sex = sexdef tell_info(self):            # 绑定到对象的方法"""绑定对象方法"""print("name：%s age:%s sex:%s" %(self.name, self.age, self.sex))@classmethoddef form_conf(cls):     # 需求升级，从文件里导入资料并和类绑定匹配"""绑定类的方法"""obj = cls(sett.name,sett.age,sett.sex)return obj@staticmethoddef class_id():                # 非绑定参数的 实现（独立的不需要传值，也不需要依靠别的）m = hashlib.md5(str(time.time()).encode("utf-8"))return m.hexdigest()

# 定义一个类
class People:def __init__(self, name, age):self.name = nameself.age = agedef prints(self):print("name %s age is %s" % (self.name, self.age))obj = People("will", 22)
obj.prints()

# 1、 hasattr（obj（对象），"name"（字符串形式的属性）） 判断属性（布尔类型返回 True 或 False ）
print(hasattr(obj, "name"))         # 查看对象内部的名称空间(__dict__)内有没有对应的 key
print(hasattr(obj, "prints"))       # 或者说查看绑定类的名称空间内有没有定义或对应的变量名

print(getattr(obj, "name", "ppt"))          # 找得到，返回对应值，
print(getattr(obj, "namexxx", "ppt"))       # 找不到，返回最后的值（ppt）
print(getattr(obj, "prints", "ppt"))        # 查找类内属性会返回对应的绑定方法的函数

print(setattr(obj, "sex", "man"))          # 等同于 obj.sex = "man"
print(obj.sex)

delattr(obj, "age")     # 等同于 del obj.age
print(obj.__dict__)     # 发下已经被删除

# 这几个知识的应用广场景
class Service:"""反射的应用场景"""def run(self):while True:inp = input(">>>:").strip()cmds = inp.split()if hasattr(self, cmds[0]):       # 怎么通过判断用户输入的正确度去执行代码func = getattr(self, cmds[0])func(cmds)def get(self, cmds):print("get 功能", cmds)def put(self, cmds):print("put.....", cmds)# 通过 hasattr 和 getattr 两个功能实现属性准确度判断
s = Service()
s.run()# 需求升级，想通过输入的字符执行相对功能并下载
# 通过相同方法，把输入的字符串格式化成列表，实现最终目的

# 一、item系列：(__setitem__， __getitem__， __delitem__)把对象模拟成调用字典的形式操作
class People:def __init__(self, name):self.name = namedef __getitem__(self, item):"""get：获取属性（查询时会用到）"""return self.__dict__.get(item)              # 设置方法返回调用所获值def __setitem__(self, key, value):"""set:修改与增加属性（修改和增加时会用到）"""# print("setitem")# print(key, value)self.__dict__[key] = value                     # 实现真正操作的一步def __delitem__(self, key):"""del:删除属性（删除时用得到）"""print("delitem")print(key)self.__dict__.pop(key)                          # 删除操作del self.__dict__[key]                        # 效果同上

obj = People("will")# 验证get获取和查看属性
print(obj["name"])
obj["name"]# 验证set修改与增加设置方法
# 需求，增加一个属性
obj.age = 18         # 之前的方法可以这样写
obj["sex"] = "man"  # 用字典的方法这样写也可以实现
print(obj.sex)
print(obj.__dict__)# 验证 del 删除属性
del obj["name"]
print(obj.__dict__)

class People:def __init__(self, name, age):self.name = nameself.age = agedef __str__(self):"""调用对象时，设置返回类型为 str需要注意的是：必须以字符串类型返回，否则会报错"""return "hi !! my name's %s. age %s" % (self.name, self.age)p = People("will", 22)              # 实例化后
print(p)                    # 打印对象时， 会触发 __str__  系统自动识别并调用类内的 __str__ 属性

class Open:def __init__(self, filename):print("读取文件.......")self.filename = filenamedef __del__(self):"""这个方法会在程序结束后，自动触发并释放内存这里面一般会写入跟对象相关的其他程序或资源"""print("__del__资源回收")f = Open("sett.py")         # 实例化
del f       # 如果提前删除 变量，也会触发类内定义的 __del__操作
#            （一般定义了__del__也不会 刻意去删除，只是验证下）相比手动操作当然还是自动删除比较好
print("__main__")   # 打印或者再干点其他事，发现类内部定义的 __del__在程序最后才运行，证明是执行的最后一波操作# 小结：如果在类内部定义了 __del__ 方法，所有类内部定义的属性，都是自动绑定给对象的，
#       这个方法在对象被删除的时候，会自动先触发这个方法的执行

g = {"x": 1,"y": 2}f = {}# exec ：把 exec 内的字符串当做函数执行命令，可修改全局作用域的变量，也可创建局部作用域变量
exec("""global x, s
x = 15
s = 33z = 3
""", g, f)      # exec(要执行的命令（字符串形式）， 执行命令的作用域，g = 全局， f = 局部)# print(g)
print(f)

class People:passp = People()
print(type(p))
print(type(People))print(type(print))

# 1、class 定义的类class Chinese:"""之前定义类的方法"""country = "china"def __init__(self, name, age):self.name = nameself.age = agedef talk(self):print("%s is talking" % self.name)obj = Chinese("will", 18)       # 实例化
print(obj, obj.name, obj.age)print(Chinese)

# 定义类的三要素
class_name = "Chinese"    # 三要素之一：类名
class_bases = (object, )     # 三要素之二：基类，如果继承，会有一个或多个，如果不继承，会有一个默认值（ object ）
class_body = """
country = "china"def __init__(self, name, age):self.name = nameself.age = agedef talk(self):print("%s is talking" % self.name)
"""class_dict = {}
class_room = exec(class_body, globals(), class_dict)    # 三要素之三（重点）：类的名称空间
# print(class_dict)                           # 打印验证效果发现名称空间已经生成
Chinese1 = type(class_name, class_bases, class_dict)# print(Chinese1)
obj1 = Chinese1("will", 18)       # 实例化
print(obj1, obj1.name, obj1.age)

 如果定义一个父类，
class My_mete(type):"""自定义元类，也需要继承 type """def __init__(self, class_name, class_bases, class_dict):            # 定义 __init__ 就要继承之前基类所拥有的功能if not class_name.istitle():            # 在元类内部，可以定义其他框架（判断如果类名的首字母不是大写，触发报错机制）raise TypeError("类名的首字母必须大写，")elif "__doc__" not in class_dict or not class_dict["__doc__"].strip():      # 定义元类的其他内置方法raise TypeError("定义类，必须注释且注释不能为空")super(My_mete, self).__init__(class_name, class_bases, class_dict)      # 所以，需要继承基类所拥有的功能且增加自己创建的功能class Chinese(object, metaclass=My_mete):      # 不写继承的基类，也有默认继承，后面的 metaclass = type 也是默认值"""这样写，相当于 Chinese = My_mite(class_name, class_bases, class_dict),也就相当于基类内必须有 __init__ 的方法"""country = "china"def __init__(self, name, age):self.name = nameself.age = agedef talk(self):print("%s is talking" % self.name)

class Chinese(object, metaclass=My_mete):      country = "china"def __init__(self, name, age):self.name = nameself.age = agedef talk(self):print("%s is talking" % self.name)print(Chinese.__dict__)

# 本节知识储备点：__call__ 方法
class Foo:def __call__(self, *args, **kwargs):        # 定义函数传参的功能（所有类型）"""定义此方法后，对象名加括号（obj()），也可以被调用"""print(self)print(args)print(kwargs)obj = Foo()
obj(1, 2, 10, a=1, b=2, c=5)  # obj() 加括号，也可以调用，需要在类内部增加 __call__ 函数,
# 等同于调用 obj.__call__(obj, 1, 2, 10, a=1, b=2, c=5) 的调用方法
# 用这样的方法，就可以把对象变成一个可调用对象，且可修改调用对象方法
# 元类内部也有同样的内置方法(__call__)可被调用和控制，
# 会在创建类时，自动生成 __call__ 的方法，以备调用并触发，
# 如果调用 Foo(1, 2, a=2, b=4),相当于执行了 Foo.__call__(self, 1, 2, a=2, b=4) 的方法

# 同理以下行为就用到了__call__的方法
class My_mete(type):"""自定义元类，也需要继承 type """def __init__(self, class_name, class_bases, class_dict):if not class_name.istitle():raise TypeError("类名的首字母必须大写，")elif "__doc__" not in class_dict or not class_dict["__doc__"].strip():raise TypeError("定义类，必须注释且注释不能为空")super(My_mete, self).__init__(class_bases, class_bases, class_dict)def __call__(self, *args, **kwargs):"""本方法默认就有，但是，自定义了会按照自定义方法执行，这样就可以在自定义内部增加自定义的任务与格式实现自定义功能""""""后台操作"""print(self)         # self = Chineseprint(args)         # args = ("will", )print(kwargs)       # kwargs = {"age": 22}# 在被调用时，会触发此方法执行三件事#   1、先造出一个新对象 obj（在之前学的 object 方法有一个功能）obj=object.__new__(self)         # 新建对象的语法,会提示传进去 一个类名#   2、初始化obj(触发 __init__() 方法)self.__init__(obj, *args, **kwargs)#   3、返回objreturn objclass Chinese(object, metaclass=My_mete):"""这样写，相当于 Chinese = My_mite(class_name, class_bases, class_dict),也就相当于基类内必须有 __init__ 的方法"""country = "china"def __init__(self, name, age):self.name = nameself.age = agedef talk(self):print("%s is talking" % self.name)obj = Chinese("will", age=22)     # 同理：此操作相当于调用 Chinese.__call__(Chinese, "will", 22)
print(obj.__dict__)     # 验证自定义元类的实例化功能，轻松实现控制实例化过程

# 实现方式一：正常实现
class My_SQL:"""SQL 是一个访问和处理数据库的计算机语言"""__instance = Nonedef __init__(self):self.host = "127.0.0.1"self.port = 3306@classmethoddef singleton(cls):"""为了节省空间，可以判断实例化如果是同一个内容，可以覆盖此处需要用到 装饰器@classmethod """if cls.__instance is None:obj = cls()cls.__instance = objreturn cls.__instancedef conn(self):passdef execute(self):passobj1 = My_SQL.singleton()
obj2 = My_SQL.singleton()
obj3 = My_SQL.singleton()
print(obj1, obj2, obj3)# 通过此方法，实现了单例行为，这样的方式是处理 普通类加装饰器实现此功能，下面用元类控制此功能

# 方式二：元类实现此功能class My_mete(type):"""自定义元类，也需要继承 type """def __init__(self, class_name, class_bases, class_dict):if not class_name.istitle():raise TypeError("类名的首字母必须大写，")elif "__doc__" not in class_dict or not class_dict["__doc__"].strip():raise TypeError("定义类，必须注释且注释不能为空")super(My_mete, self).__init__(class_bases, class_bases, class_dict)self.__instance = Nonedef __call__(self, *args, **kwargs):if not self.__instance:obj = object.__new__(self)self.__init__(obj)self.__instance = objreturn self.__instanceclass Mysql(object, metaclass=My_mete):"""用元类实现此功能就简单多了"""def __init__(self):self.host = "127.0.0.1"self.port = 3306def conn(self):passdef execute(self):passobj1 = Mysql()
obj2 = Mysql()
obj3 = Mysql()print(obj1 is obj2 is obj3)    # 通过自定义元类，轻松实现了重复开辟地址的行为，节省了空间

# 第一题：
# 1、通过自定义元类属性，把自定义类的属性全部大写class Mymete(type):"""判断派生类所有属性必须都要大写"""def __init__(self, class_name, class_bases, class_dict):if not class_name.isupper():raise TypeError("定义类名，必须要大写")for attr in class_dict:if not (attr.startswith("__") and attr.endswith("__")) and not attr.isupper():"""判断不是以 __开头和 __结尾的属性，都必须大写，否则抛出错误"""raise TypeError("所有属性都必须要大写！！！")super(Mymete, self).__init__(class_name, class_bases, class_dict)class CHINESE(object, metaclass=Mymete):"""已完成元类定制 子类所有属性全部大写"""DDD = "QQQ"def __init__(self, name, age, sex):self.name = nameself.age = ageself.sex = sexdef DDD(self):print(self.name)print(self.age)print(self.sex)# 老师的答案：
class Mymetaclass(type):def __new__(cls,name,bases,attrs):update_attrs={}for k,v in attrs.items():if not callable(v) and not k.startswith('__'):update_attrs[k.upper()]=velse:update_attrs[k]=vreturn type.__new__(cls,name,bases,update_attrs)class Chinese(metaclass=Mymetaclass):country='China'tag='Legend of the Dragon' #龙的传人def walk(self):print('%s is walking' %self.name)print(Chinese.__dict__)
'''
{'__module__': '__main__','COUNTRY': 'China','TAG': 'Legend of the Dragon','walk': <function Chinese.walk at 0x0000000001E7B950>,'__dict__': <attribute '__dict__' of 'Chinese' objects>,'__weakref__': <attribute '__weakref__' of 'Chinese' objects>,'__doc__': None}
'''

# 第二题：class Mymetaclass(type):def __new__(cls,name,bases,attrs):update_attrs={}for k,v in attrs.items():if not callable(v) and not k.startswith('__'):update_attrs[k.upper()]=velse:update_attrs[k]=vreturn type.__new__(cls,name,bases,update_attrs)def __call__(self, *args, **kwargs):if args:raise TypeError('must use keyword argument for key function')obj = object.__new__(self) #创建对象，self为类Foofor k,v in kwargs.items():obj.__dict__[k.upper()]=vreturn objclass Chinese(metaclass=Mymetaclass):country='China'tag='Legend of the Dragon' #龙的传人def walk(self):print('%s is walking' %self.name)p=Chinese(name='egon',age=18,sex='male')
print(p.__dict__)

# print("1")
# print("2")
# int("ppr")

例：
if 1>2
# 1不可能大于二，所以是语法书写层次的错误

# ValueError
# int("aaa")# NameError
# name# IndexError
# f = [1, 2, 3]
# f[100]# KeyError
# d = {}
# d["name"]# AttributeError
# class Foo:
#     pass
# Foo.xxx# ZeroDivisionError
# 1/0# TypeError
# for i in 55:
#     print(i)# AttributeError 试图访问一个对象没有的属性，比如foo.x，但是foo没有属性x
# IOError 输入/输出异常；基本上是无法打开文件
# ImportError 无法引入模块或包；基本上是路径问题或名称错误
# IndentationError 语法错误（的子类） ；代码没有正确对齐
# IndexError 下标索引超出序列边界，比如当x只有三个元素，却试图访问x[5]
# KeyError 试图访问字典里不存在的键
# KeyboardInterrupt Ctrl+C被按下
# NameError 使用一个还未被赋予对象的变量
# SyntaxError Python代码非法，代码不能编译(个人认为这是语法错误，写错了）
# TypeError 传入对象类型与要求的不符合
# UnboundLocalError 试图访问一个还未被设置的局部变量，基本上是由于另有一个同名的全局变量，
# 导致你以为正在访问它
# ValueError 传入一个调用者不期望的值，即使值的类型是正确的

age = 10
a = input(">>>:").strip()
if a.isdigit():a = int(a)if age > a:print("")

try:f = open("exec.txt", "r", encoding="utf-8")print(f.__next__(), end="")print(f.__next__(), end="")print(f.__next__(), end="")print(f.__next__(), end="")print(f.__next__(), end="")print(f.__next__(), end="")print(f.__next__(), end="")         # 正常情况下是会报错的print(f.__next__(), end="")print(f.__next__(), end="")print(f.__next__(), end="")f.close()except StopIteration:print("报错了")print("++++>>>1")
print("++++>>>2")
print("++++>>>3")# 这样情况下，就不会报错了

# 一、异常处理之多分支try:print("++++>>>1")# nameprint("++++>>2")l[1000]print("+++++>>3")d = {}d[name]print("++++++>>>4")except NameError as b:print("+++++>", b)
except ImportError as c:            # 有点像elif 的分支结构print("+++++++>", c)
except KeyError as p:print("+++++>", p)# 用多分支处理异常的场景：代码被检测的代码块报出的异常有多种可能性，且需要针对每一种异常类型都定制处理逻辑

try:print("++++>>>1")nameprint("++++>>2")l[1000]print("+++++>>3")d = {}d[name]print("++++++>>>4")except Exception as b:print("异常", b)print("+++++>>>")

try:print("++++>>>1")# nameprint("++++>>2")l[1000]print("+++++>>3")d = {}d[name]print("++++++>>>4")except NameError as b:print("+++++>", b)
except ImportError as c:            # 有点像elif 的分支结构print("+++++++>", c)
except KeyError as p:print("+++++>", p)except Exception as r:              # 在最后再用 万能异常处理不可预知的错误print("万能异常的执行", r)print("++++++>>>>0")

try:print("++++>>>1")# nameprint("++++>>2")# l[1000]print("+++++>>3")d = {}# d[name]print("++++++>>>4")except NameError as b:print("+++++>", b)
except ImportError as c:            # 有点像elif 的分支结构print("+++++++>", c)
except KeyError as p:print("+++++>", p)except Exception as r:              # 在最后再用 万能异常处理不可预知的错误print("万能异常的执行", r)else:print("它的 else 应用场景是：发生异常，就不会执行此处")  # 在被检测的代码没有发生异常时，就要执行这里的代码
print("++++++>>>>0")

try:print("++++>>>1")nameprint("++++>>2")l[1000]print("+++++>>3")d = {}d[name]print("++++++>>>4")except NameError as b:print("+++++>", b)
except ImportError as c:            # 有点像elif 的分支结构print("+++++++>", c)
except KeyError as p:print("+++++>", p)except Exception as r:              # 在最后再用 万能异常处理不可预知的错误print("万能异常的执行", r)else:print("它的 else 应用场景是：发生异常，就不会执行此处")  # 在被检测的代码没有发生异常时，就要执行这里的代码
finally:print("不管被检测的代码有没有异常，本方法都会正常执行！")
print("++++++>>>>0")

try:f = open("exec.txt", "r", encoding="utf-8")print(f.__next__(), end="")print(f.__next__(), end="")print(f.__next__(), end="")print(f.__next__(), end="")print(f.__next__(), end="")print(f.__next__(), end="")print(f.__next__(), end="")         # 正常情况下是会报错的print(f.__next__(), end="")# f.close()      # f.close()  写在这里，可能报错之后，不能回收资源。
finally:            # 利用 finally 这样的写法，就可以有效的避免浪费内存资源
    f.close()print("++++>>>1")
print("++++>>>2")
print("++++>>>3")

class People:def __init__(self, name, age, sex):             # 这样定义一个普通类，if not isinstance(name, str):raise TypeError("name not is str!!!")if not isinstance(age, int):raise TypeError("age not is int!!!")self.name = nameself.age = ageself.sex = sex# 在实例化时：
p = People("will", 33, "man")    # 正常传值，是没问题# 主动触发异常
p2 = People(55, "11", 12)   # 但是这样传值（潜规则的错误），也不会报错，但是，人的名字都是字符串形式，所以就用到了主动触发异常

class MyException(BaseException):"""自定义异常时，通常要继承系统异常"""def __init__(self, msg):super(MyException, self).__init__()self.msg = msgdef __str__(self):"""自定义异常，必须要有此格式，否则不能打印异常要求"""print("<%s>" % self.msg)raise TypeError("自定义异常的处理结果！！！")

# 断言（assert）：代码分为 2部分的场景，且互相有依赖
# 第一部分：（定义部分）
info = {}
info["name"] = "will"
info["age"] = 22# 第二部分：（分析与判断部分）
# 常用的写法：
if "name" not in info:          # 分析raise KeyError("必须有 name 这个key！")
if "age" not in info: raise KeyError("必须有 age 这个 key！！！")if info["name"] == "will" and info["age"] > 18:     # 判断print("welcome! ! ")# 断言的写法：
assert "name" in info and "age" in info
"""断言的应用就是符合硬性条件，如果不符合，直接报错"""if info["name"] == "will" and info["age"] > 22:print("welcome!!!!")

# -*- coding:utf-8 -*-
# author:Will Loong# 本章节作业：
# 角色：学校，学生，课程，讲师
# 要求：
# 1、创建北京、上海2个学校
# 2、创建 linux、python、go 三种课程，linux在北京开、go 在上海开
# 3、课程包括：周期、价格、通过学校创建课程
# 4、通过学校创建班级，班级关联课程、讲师
# 5、创建学时、选择学校，关联班级
# 6、创建讲师角色时要关联学校
#    提供 2 种接口
# 6.1、学员视图：可以注册、交学费、选班级
# 6.2、讲师视图，讲师可以管理自己的班级，查看班级学员列表，修改所管理的学员成绩
# 6.3、管理视图，创建讲师，创建班级，创建课程
# 7、上面的操作产生的数据通过 pickle 序列化保存到文件里# 作业分析：
# 1、场景、角色、（类） ———> 属性、方法
# ①、课程类：课程没有具体的动作和方法，所以只需要设计属性
# 属性：课程名、周期、老师# ②、学生类：
# 属性：姓名、对应课程
# 方法及流程：查看可选课程、选择对应课程、查看所选课程、退出程序# ③、管理员：
# 属性：姓名
# 方法：创建课程、创建学生账号、查看所有课程信息、查看所有学生信息、查看所有学生的选课情况、退出程序# 2、站在每个角色的角度上去思考程序执行流程
import os
import sys
import pickle
from color import font_color# class Pea():
#     while True:
#         try:
#             with open("student_info", "rb") as f8:
#                 cde = pickle.load(f8)
#             print(cde.name)
#         except EOFError:
#             print("aaa")
# p = Pea()
# print(p)
class Course:"""定义课程类"""def __init__(self, name, price, period, teacher):"""定义属性并初始化赋值"""self.name = nameself.price = priceself.period = periodself.teacher = teacherclass Person:"""把打印课程提取出来，创建一个父类"""def show_course(self):"""查询课程"""with open("course_info", "rb") as f:count = 0while True:try:count += 1course_obj = pickle.load(f)font_color("%s.%s-%s-%s-%s" % (count, course_obj.name, course_obj.price, course_obj.period,course_obj.teacher), "noting")except EOFError:breakclass Student(Person):"""创建学生类"""operate_lst = [("查看可选课程", "show_course"),("选择课程", "select_course"),("查看已选课程！", "check_selected_course"),("退出", "exit")]def __init__(self, name):"""一个学生不一定只有一门课程，所以在定义学生课程时，格式化一个列表"""self.name = nameself.course_name = []def select_course(self):self.show_course()num = int(input("Number >>>:").strip())count = 1with open("course_info", "rb") as f:while True:try:course_obj = pickle.load(f)if count == num:self.course_name.append(course_obj)print(len(self.course_name))font_color("You chose the %s course !!!" % course_obj.name, "true")breakcount += 1except EOFError:font_color("there is not course!!!", "error")breakdef check_selected_course(self):"""查看已选课程"""print(self.course_name)for cou in self.course_name:print(cou.name, cou.teacher)def exit(self):"""把写入的文件创建在最后，如果修改完了退出，再写入文件"""with open("student_info", "rb") as f1,  open("student_info_back", "wb") as f2:"""在内存打开2个文件，f1， f2"""while True:try:student_f = pickle.load(f1)if student_f.name == self.name:"""如果相等，就把修改后的文件存入 f2 文件"""pickle.dump(self, f2)else:"""否则，原内容保持不变"""pickle.dump(student_f, f2)except EOFError:breakos.remove("student_info")os.rename("student_info_back", "student_info")exit()@staticmethoddef init(name):"""返回一个学生对象，在student内"""with open("student_info", "rb") as f:while True:try:stu_obj = pickle.load(f, encoding="utf-8")if stu_obj.name == name:return stu_objexcept EOFError:font_color("学生账号不存在！！！", "error")breakclass Manager(Person):"""创建管理员"""operate_lst = [("创建课程", "create_course"),("创建学生账号", "create_student"),("查看所有课程", "show_course"),("查看所有学生", "show_student"),("查看所有学生选课情况", "show_student_course"),("退出", "exit")]def __init__(self, name):self.name = namedef create_course(self):"""创建课程"""name = input("course name:").strip()price = input("course price:").strip()period = input("course period:").strip()teacher = input("course teacher:").strip()course_obj = Course(name, price, period, teacher)with open("course_info", "ab") as f:pickle.dump(course_obj, f)font_color("%s 课程创建完毕！" % course_obj.name, "yes")def create_student(self):"""创建学生账号：1、用户名和密码以及身份记录到 user_info 文件内2、将学生对象存进student 文件"""stu_name = input("student name:")if isinstance(stu_name.strip(), str) is not None:stu_pwd = input("student password:").strip()if isinstance(stu_pwd.strip(), (str or int)) is not None:stu_pwd2 = input("student password:").strip()if stu_pwd2 == stu_pwd:stu_auth = "%s|%s|Student" % (stu_name, stu_pwd2) + "\n"stu_obj = Student(stu_name)with open("user_info.txt", "a", encoding="utf-8") as f:f.write(stu_auth)with open("student_info", "ab") as f:pickle.dump(stu_obj, f)font_color("%s学生账号创建成功！！！" % stu_obj.name, "yes")else:font_color("2次密码输入不一致！！！", "error")else:font_color("学生账号必须是 str 格式！！！", "error")def show_student(self):"""查询学生"""with open("student_info", "rb") as f:count = 0while True:try:count += 1student_obj = pickle.load(f, encoding="utf-8")font_color("%s.%s" % (count, student_obj.name), "yes")except EOFError:breakfont_color("-----------end------------", "false")def show_student_course(self):with open("student_info", "rb") as f:while True:try:student_obj = pickle.load(f)course_list = [cor for cor in student_obj.courses]font_color("%s.opt course %s " % (student_obj.name, "|".join(course_list)), "false")except EOFError:break@classmethoddef init(cls, name):return cls(name)def exit(self):exit()# 学生角度：登录就可以选课了
#             已经有账号，已经有课程# 管理员：登录就可以完成以下操作：
#         学生账号由管理员创建
#         学生课程由管理员创建# 应该先创建管理员角色更合适着手开发
# 登录需求：
#           必须自动识别身份（存在文件内的信息：账号、密码、身份）def login():user_name = input("username:").strip()passwod = input("password:").strip()with open("user_info", "r", encoding="utf-8") as f:for line in f:user, pwd, identify = line.strip().split("|")if user == user_name and passwod == pwd:return {"state": True, "name": user_name, "id": identify}else:return {"state": False,  "name": user_name}log_res = login()
if log_res["state"]:font_color("登录成功！！！", "yes")if hasattr(sys.modules[__name__], log_res["id"]):cls = getattr(sys.modules[__name__], log_res["id"])obj = cls(log_res["name"])while True:for idx, nature in enumerate(cls.operate_lst, 1):font_color("%s.%s" % (idx, nature[0]), "noting")inp = input("please>>>:").strip()if inp.isdigit() and len(cls.operate_lst) >= int(inp):func_str = cls.operate_lst[int(inp) - 1][1]if hasattr(obj, func_str):getattr(obj, func_str)()else:font_color("No such option!!!", "error")
else:font_color("登录失败！！！", "error")

# -*- coding: utf-8 -*-
# @Time    : 2018/8/31 10:59
# @Author  : 骑士计划
# @Email   : customer@luffycity.com
# @File    : 5.作业讲解.py
# @Software: PyCharmimport os
import sys
import picklestudent_info = 'student_info'
course_info = 'course_info'
userinfo = 'userinfo'
class Base:def __str__(self):return self.name
class Course(Base):def __init__(self,name,price,period,teacher):self.name = nameself.price = priceself.period = periodself.teacher = teacherdef __repr__(self):return ' '.join([self.name, self.price, self.period, self.teacher])class Person:@staticmethoddef get_from_pickle(path):with open(path,'rb') as f:while True:try :stu_obj = pickle.load(f)yield stu_objexcept EOFError:breakdef show_courses(self):for count,course in enumerate(self.get_from_pickle(course_info),1):print(count,repr(course))def dump_obj(self,path,obj):with open(path,'ab') as f:pickle.dump(obj,f)class Student(Person,Base):operate_lst = [('查看所有课程', 'show_courses'),('选择课程', 'select_course'),('查看已选课程', 'check_selected_course'),('退出', 'exit')]def __init__(self,name):self.name = nameself.courses = []def __repr__(self):# course_name = [course.name for course in self.courses]course_name = [str(course) for course in self.courses]return '%s %s'%(self.name,'所选课程%s' % '|'.join(course_name))def select_course(self):self.show_courses()num = int(input('num >>>'))for count,course in enumerate(self.get_from_pickle(course_info),1):if count == num:self.courses.append(course)print('您选择了%s课程' % (course))breakelse:print('没有您要找的课程')def check_selected_course(self):for course in self.courses:print(course.name,course.teacher)def exit(self):with open(student_info+'_bak', 'wb') as f2:for stu in self.get_from_pickle(student_info):if stu.name == self.name:  # 如果从原文件找到了学生对象和我当前的对象是一个名字，就认为是一个人pickle.dump(self, f2)  # 应该把现在新的学生对象写到文件中else:pickle.dump(stu, f2)  # 反之，应该原封不动的把学生对象写回f2
        os.remove(student_info)os.rename(student_info+'_bak',student_info)exit()@classmethoddef init(cls,name):for stu in cls.get_from_pickle(student_info):if stu.name == name:return stuelse:print('没有这个学生')class Manager(Person):operate_lst = [('创建课程','create_course'),('创建学生','create_student'),('查看所有课程','show_courses'),('查看所有学生','show_students'),('查看所有学生的选课情况','show_student_course'),('退出','exit')]def __init__(self,name):self.name = namedef create_course(self):name = input('course name : ')price = input('course price : ')period = input('course period : ')teacher = input('course teacher : ')course_obj = Course(name,price,period,teacher)self.dump_obj(course_info, course_obj)print('%s课程创建成功'%course_obj.name)def create_student(self):# 用户名和密码记录到userinfo文件，将学生对象存储在student_info文件stu_name =input('student name : ')stu_pwd =input('student password : ')stu_auth = '%s|%s|Student\n'%(stu_name,stu_pwd)stu_obj = Student(stu_name)with open(userinfo,'a',encoding='utf-8') as f:f.write(stu_auth)self.dump_obj(student_info, stu_obj)print('%s学生创建成功'%stu_obj.name)def show_students(self):for count,stu in enumerate(self.get_from_pickle(student_info),1):print(count,stu)def show_student_course(self):for stu in self.get_from_pickle(student_info):print(repr(stu))def exit(self):exit()@classmethoddef init(cls,name):return cls(name)   # 管理员的对象def login():name = input('username : ')pawd = input('password : ')with open(userinfo,encoding='utf-8') as f:for line in f:usr,pwd,identify = line.strip().split('|')if usr == name and pawd == pwd:return {'result':True,'name':name,'id':identify}else:return {'result':False,'name':name}ret = login()
if ret['result']:print('\033[1;32;40m登录成功\033[0m')if hasattr(sys.modules[__name__],ret['id']):cls = getattr(sys.modules[__name__],ret['id'])obj = cls.init(ret['name'])   # 实例化while True:for id,item in enumerate(cls.operate_lst,1):print(id,item[0])func_str = cls.operate_lst[int(input('>>>')) - 1][1]print(func_str)if hasattr(obj,func_str):getattr(obj,func_str)()
else:print('登录失败')