#你有没有总结那些东西你已打印他是内存地址 #用‘字符串’类型的属性名、方法名 来调用属性和方法地址 #所有可以反射的东西 都是变量 #变量里存的是值，渠道的是 结果 #变量里存的是函数 类 渠道的是内存地址 # 类 #类中的方法 #如何反射变量 a = '反射变量' import sys ret_attr = getattr(sys.modules[__name__],'a') #反射变量'#如何反射函数 def func():print('反射函数') func_addr = getattr(sys.modules[__name__],'func') func_addr() #如何反射类 class Foo:print('反射类') clas = getattr(sys.modules[__name__],'Foo') print(clas) #==Foo obj = clas() #Foo()相当于实例化一个Foo对象的过程 #如何反射类中的成员 #类中的成员：静态属性 静态方法 类方法 对象方法 property方法 #习惯使用类调用的有哪些：静态变量 静态方法 类方法 #对象中的成员 ： # 对象属性 #习惯使用对象调用的有哪些：对象属性 对象方法 property 方法 #类和对象中成员的反射 都是遵循‘调用习惯’的 class Foo: Country = 'China' @classmethod def showCountry(cls): print('in showCountry',cls.Country) @staticmethod def wahah(): print('wahah') #类中的静态属性 Count = getattr(Foo,'Country') print(Count) #类中的类方法 print(getattr(Foo,'showCountry')) #<bound method Foo.showCountry of <class '__main__.Foo'>> getattr(Foo,'showCountry')() #in showCountry China #类中的静态方法 getattr(Foo,'wahah')() class Student: def __init__(self,name,age): self.name = name self.age = age def eat(self): print(self.name + ' is eating') liuyang = Student('liu',23) # liuyang.name getattr(liuyang,'name') getattr(liuyang,'age') getattr(liuyang,'eat')() #模块 import time import re import os import sys import random import json import pickle import collections import hashlib lst = [1,2,3,4,5] random.shuffle(lst) #打乱 print(lst) getattr(random,'shuffle')(lst) print(lst) # isinstance(对象，类) #判断对象是不是这个类或者这个类的子类的对象 # issubclass(类1，类2) #判断类1 是不是 类2 的子类 #和网络相关的 大量用到反射
#__author : 'liuyang' #date : 2019/4/2 0002 上午 9:14 #显示编程功底的很重要的方法 # 90% 不用内置 可以做出来 # 进阶 # 会了 感觉 功底很强 格调很强 不会也无可 # 研究一下 内置方法打开新世界大门 #内置方法 双下方法 魔术方法 # 都是python 的对象内部自带的 #并且都不需要 自己去调用 # __str__ # __repr__ # object.__str__() class Course : def __init__(self,name,price,period): self.name = name self.price = price self.period = period # 备胎 def __repr__(self): #只能返回字符串 别的报错 #当你打印的时候 自动触发 #使用%s f'{}' 进行 字符串的拼接时，自动触发 return '%s,%s,%s'%(self.name,self.price,self.period) # 有了str 不走repr def __str__(self): return self.name python = Course('python',25000,'6 months') # 打印多个 很长 不符合编程习惯 print(python.name,python.price,python.period) #如果 不实现str 方法 ，那么对象打印出来只是一串地址 print('course %s'%python) print(f'course {python}') print(repr(python)) # print() #如果 str 存在，repr 也存在 #那么print（obj）和使用格式化%s format 这两种方式，调用的是————str__ # 而repr(obj) 和 %r 格式化字符串 ，都会调用__repr_) #如果 str 不存在 ，repr 存在 #那么print() 和格式化 %r s f 和 repr(obj)都调用__repr__ #如果 repr 不存在 ，str 存在 #那么pirnt 和 s f 都执行 #%r 和 repr 不执行 l = [1,2,3] #list.__init__ #l 是对象 ，打印的时候直接显示的是元素 print(l) # list.__str__() 方法 class Python(Course): def __repr__(self): return '%s,%s,%s'%(self.name,self.price,self.period) def __str__(self): return "全栈开发"+self.name py20 = Python('python',25000,'6 months') print(py20) # 打印对象 先走自己str 没 走父类的 直到除了object 之外的所有父类都没有str # 再回来 ，找自己的repr ,如果自己没有 再找父类的 #repr 是str 的备胎 #和所有的字符串 格式化以及自己直接打印这个对像相关 #str(obj) ,repr(obj) #流畅的python -------- repr print(str('123')) print(repr('123')) # 有了repr 或者str 在打印对象的时候就不会显示用户不关系的地址了 # 增强了用户的体验 ， 在程序开发的过程中， # 如果们需要频繁的打印 对象中的属性，需要从类的外部做复杂的拼接，实际上是一种麻烦 # 如果这个拼接工作 在类的内部 简单
#__author : 'liuyang' #date : 2019/4/2 0002 上午 10:16 # __new__构造方法 #生产对象的时候使用的 单例模式 #__del__析构方法 #再删除一个对象之前用的 -归还操作系统资源 ''' class Foo: def __new__(cls, *args, **kwargs): print(object.__new__(cls)) return 'in new',object.__new__(cls)#开一个属于我这个类的空间 def __init__(self): print(self) # object.__new__() Foo() # 实例化一个对象 #先开辟一块儿空间,使用的是Foo这个类内部的__new__ #如果我们的Foo类中是没有__new__方法的 #调用object类的__new__方法 class Foo: def __new__(cls, *args, **kwargs): #不能改成self ,还没有 print(object.__new__(cls)) #self 在这里被创造出来的 # return object.__new__(cls) def __init__(self): print(self) Foo() #不执行object.__new__(cls) 下面的init和self 不创建 # 不新建 init 不执行 # 在使用self 之前，都还有一个生产self的过程 #就是在内存中开辟一块属于这个对象的空间，并且在这个空间中存放一个类 #设计模式 #算法导论 #数据结构与算法 #java 多人协作 # 编码的结构上的规范 #设计模式 23 种 - 单例模式 不爱用 不应该不会用 # 一个类 只有一个实例 有且只能有一个实例 class A:print('a') a1 = A() a2 = A() print(a1) print(a2) ''' class A: __flag = None # 只能创建一个 1 个用 # 一个类只能有一个实例 创建了一个多个用 节省内存资源接口 def __new__(cls, *args, **kwargs): if cls.__flag is None: cls.__flag = object.__new__(cls) # cls.__flag = True # print('in_new') return cls.__flag def __init__(self,name=None,age=None): self.name =name self.age = age a1 = A('1','1') print(a1) a2 = A('1',2) print(a2) a3 = A('1',3) # print(a1) # print(a2) print(a3) print(a1.age) # 都指向一个 最后一次修改的 最后一次不修改 则上一次的值 # a1 和 a2 和 a3 都是相同的 亲妈 奶妈 姑妈 的孩子 最后还是那个孩子 # __del__方法 自己承认错的感觉真好 # a = 1 # for i in range(1000000): # a = i a = 1 # 先编译 后逐行解释的语言 编译完后 解释前 已经知道会不会用到了 #__del__方法 所有的没有运行的方法 都被自动地删掉了 # del a # python解释器 有周期 不会及时的删除掉的 #垃圾回收机制 保洁阿姨 #善良 import time class A: def __init__(self,path): self.f = open(path,'w') #删除了之后文件没了 f没了 连接没关 # self.name = name # self.age =age def __del__(self): #归还一些资源的时候使用 操作系统的资源 #包括文件 网络 数据库连接 （不管理操作系统会一直用） self.f.close() # 忘了关闭了 资源会归还的（操作系统） #只和del obj语法有关系,再执行 del obj之前会执行以下__del__中的内容 print('执行') # a = A('liu',22) # print(a.name) # print(a.age) # del a time.sleep(1) # 看执行完del 之后 那个__del__有没有执行 print('adlasf',a) #python 解释器清理内存 #1.我们主动删除del obj #2.python 解释器周期性删除 #3.在程序结束之前，所有的内容都需要清空
#__author : 'liuyang' #date : 2019/4/2 0002 上午 11:38 #__call__ #源码里 用比较多 Flask web 框架 s的框架火 # 对象（）自动 触发__call__中的内容 class A: def __call__(self, *args, **kwargs): #跟类有特殊约定的方法 print('in call') # 了解 def call(self): print('in call1') obj = A() obj() #对象+（）调用了 内置函数 约定好的语法 obj.call() #with 的上下文处理 # f = open() # # 代码 # f.close() # with open() as f: # #代码 class File: def __enter__(self): print('start') def __exit__(self, exc_type, exc_val, exc_tb): print('exit') with File(): print('aaa') # 自己实现上下文 用with class myopen: def __init__(self,path,mode = 'r'): self.path = path self.mode = mode def __enter__(self): print('start') #f局部变量 self .全局 self.f = open(self.path , mode = self.mode) return self.f def __exit__(self, exc_type, exc_val, exc_tb): self.f.close() print('exit') with myopen('userinfo','w') as f:# f 是 enter 的返回值 #之前 enter 执行了 # pass f.write('adaf') # import pickle # f = open('pickle_file','wb') # pickle.dump({121},f) # f.close() import pickle class MypickleDump: def __init__(self,path,mode = 'ab'): self.path = path self.mode = mode def __enter__(self): self.f = open(self.path,self.mode) return self#把对象返回去 def dump(self,obj): pickle.dump(obj,self.f) def __exit__(self, exc_type, exc_val, exc_tb): # print(exc_type, exc_val, exc_tb)# 错误的类型 值 具体 # < class 'IndexError'> list index out of range < traceback object at 0x00000000028C4CC8 > # 会执行 if exc_type: #可以写了文件里 print(exc_type, exc_val, exc_tb) # 错误的类型 值 具体 self.f.close() with MypickleDump('pickle_file') as pickle_obj: pickle_obj.dump({1,2,3}) #self 可以用dump pickle_obj.dump({1,2,3}) pickle_obj.dump({1,2,3}) pickle_obj.dump({1,2,3}) pickle_obj.dump({1,2,3}) # pickle.dump({1,2,3},f) # a,b,c = # lst = [1,2,3] #逻辑错误 死循环 少写了。。。 # lst[4] #语法错误 会停止 但是会执行的 错误的内存也得归还 f = open('pickle_file','rb') while True: try : ret = pickle.load(f) print(ret) except EOFError: break # ''' # 在一个 函数的前后添加功能 # 利用使用 装饰器函数中的内容 # with open() as f: # f #开启关闭 使用文件句柄 # print(123) #习惯了 实际上使用了 '''''' # with 语句 就是和__enter__,__exit__ # with 类(): # 一堆缩进内的代码 import time class Timer: def __enter__(self): self.start = time.time() def __exit__(self, exc_type, exc_val, exc_tb): print(time.time() - self.start) # with Timer(): # func() def func(): print('hah') time.sleep(1) print('haha') with Timer(): func() class Mypickload: def __init__(self,path , mode='rb'): self.path = path self.mode = mode def __enter__(self): self.f = open(self.path,self.mode) return self def load(self): while True: try: ret = pickle.load(f) yield ret except EOFError: break def __exit__(self, exc_type, exc_val, exc_tb): self.f.close() with Mypickload('pickle_file','rb')as mypic: for obj in mypic.load(): print(obj) #with 可以实现装饰器的功能 with MypickleDump('pickle_file','wb') as obj: obj.dump({1,2,3,4}) with Mypickload('pickle_file','wb') as obj: for i in obj.load(): print(i) #操作之前 做什么 操作之后做什么 的都可以用到
new del call
str repr enter exit 必须