Python

#你有没有总结那些东西你已打印他是内存地址
#用‘字符串’类型的属性名、方法名 来调用属性和方法地址

#所有可以反射的东西 都是变量
#变量里存的是值，渠道的是 结果
#变量里存的是函数 类 渠道的是内存地址

# 类
#类中的方法

#如何反射变量
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  必须