python修炼第七天

第七天面向对象进阶，面向对象编程理解还是有些难度的，但是我觉得如果弄明白了，要比函数编程过程编程省事多了。继续努力！

1.面向对象补充： 封装

广义上的封装：把变量和函数都放在类中
狭义上的封装：把一些变量或者方法隐藏起来，不对外公开。

静态属性分两种：
    公有的：
    私有的： __名字 就是在名字前面加上两个下划线。这个就是公有的了
    比如：
        class Person:
            name = "jack"        #这个就是公有静态属性
            __country = "中国"   #这个是私有静态属性
        如果是一个私有的属性，那么只能在类的内部使用。不能再类的外部使用
        如果非要在类的外部调用一个私有的属性，那么name必须是在私有去的名字前面加_类名__私有名字
        但是 不能使用上面这种方式去调用私有的变量。

    私有变量：
        在类的内部，如果使用__变量的形式会发生变形，python会自动的为你加上_类名
        在类的外部，不能定义一个私有变量。
        class Person:
            __country = "中国"
            def __init__(self,name,pwd):
                self.name = name
                self.__passwd = pwd
            def login(self):
                if self.name == "alex" and self.__pwd = "alex3714":
                    print("登录成功！")
    私有方法：
        class Person:
            def __init__(self,name.pwd):
                self.name = name
                self.__pwd = pwd
            def __eat(self):
                print("eating")
        alex = Person()
        alex.__eat       # 这种情况就会报错。无法调用私有方法。
        应用场景，比如加密认证。
        比如要做一个密码加密算法
        def.__密码转换器（self,inp）:
            print("eating")
        def.__密码（self）:
            inp = input("pwd")
            self.__密码转换器(inp)
面试题：
    class Foo:
        def __into__(self):
            self.func()
        sef __func(self):
            print("in Foo")
    class Son(Foo):
        def __func(self):
            print("in son")

    s = Son()
    这个会输出 in Foo

2.类中的装饰器方法

三个装饰器函数：
    classmethod
    staticmethod
    property

1 property

2 classmethod
    如果某一个类中的方法 并没有用到这个类的实例中的具体属性
    只用到了类中的静态变量 就是用类方法

3 staticmethod
    如果一个方法既不会用到对象中的属性，也不会用到类中的属性
    就应该被定义为一个静态方法
    比如
    class Student:
        @staticmethod
        def login():
            name = input("name:")
            pwd = input("pwd:")
            if name == "" and pwd == ""
            print("实例化")
    Student.login()

3.面向对象的进阶

反射   重点！  ******
什么叫反射。
    通过字符串数据类型的 变量名 来访问变量的值

1. 类名 反射 静态属性
2. 对象名 反射 对象属性 和方法
3. 模块 反射 模块中的名字
4. 反射 自己所在文件中的名字

    x.y 这样的形式 都可以用反射
        class Person:
            def eat(self):print("eatubg")
            def play(self):print("play")
        alex = Person()
        while True:
            inp = input("insert")
            if hasattr(alex,inp):
                getattr(alex,inp)()
    使用getattr获取一个名字，如果在这个对象的命名空间中没有这个名字，会报错
    getattr的反射好伴侣 hasattr
    如果使用getattr获取一个方法，那么只能拿到这个方法的内存地址，加上括号就可以执行
    如果使用getattr获取一个属性。那么直接使用反射就可以获取到值

    反射自己模块中的名字：
        getattr(sys.modules["__main__"],"value")
    setattr 是给对象赋值   如果有就覆盖了
        setattr(obj,"name","jack")
    delattr  删除属性

    __new__   创建一个对象。这个就是构造方法。 object.__new__(cls)  首先创建对象！
    __init__  初始化方法
        先执行new方法，object.new()
        再执行  init 方法

设计模式 -- JAVA设计语言来的。
    单例模式： 某一个类 只有一个实例
    __new__ 相当于生小孩，__init__就相当于给小孩穿衣服
    单列模式就是只有一个小孩，但是衣服可以谁都要。谁都可以给这个孩子换各种衣服。最后穿的衣服才是他的衣服
    class Person:
        __insta = None
        def __new__(cls,*args,**kwargs)
            if not __insta:
                obj = object(cls)
                __insta = obj
            return obj
        def __init__(self):
            print(obj)

    __str__  可以打印对象的时候不返回内存地址，返回字符串。 注意只能返回字符串。

模块：
    模块导入，就是执行了这个文件而已
    mymodule.py文件
        money = 100
        def func1():
            print("func1")
        class manger:
            def eat(self):
                print("eating")
    在其他的文件中可以引入
        import mymodule
        getattr(mymodule,"moeny")
        getattr(mymodule,"func1")()
        Manger = getattr(mymodule,"Manger")
        a = Manger()
        a.eat()

4 常用模块补齐:

1 序列化模块
    什么叫序列化
        {"1101":{"name":"jack","age":33,"class":"1101"}}
        数据类型 --------  字符串的过程
    为什么要用序列化呢?
        数据从内存到文件便捷
        数据在网络上传输  字节 -- 字符串 -- 字典
    python中的序列化模块都有哪些？
        json    通用  支持的数据类型少。list tuple dict 容器类型
        pickle  在Python中通用的。几乎支持所有的Python中的数据类型
        shelve Python中使用的边界的序列化工具   py2 与 py3 转换可能出现问题。所以用的少

    序列化的方法有四个：
        基于内存的：
            dumps    数据类型转字符串的过程  ---  序列化
            loads    字符串转会其他数据类型  ---  反序列化
        基于文件的：
            dump     把数据类型转换为字符串存到文件  --- 序列化
            load     从文件中把字符串转回数据类型  ---  反序列化
    如果要dump多条数据：
        with open("a.txt","w") as f:
            str_dic = json.dumps(dic)
            f.write(str_dic+"\n")
            f.write(str_dic+"\n")
    读多条数据:
        with open("a.txt") as f:
            for line in f
            print(json.loads(line.strip()))

    存储对象的时候，读可以使用：
        with open("a.txt","rb") as f:
            while True:
                try:
                    obj = pickle.load(f)
                    print(obj)
                except Runerror
                    break

2 hashlib    必须要会
    比如存储用户密码
    存储密码的时候不要用明文的， 需要对用户输入的密码进行一种计算，计算后会得到一个新的固定的字符串
    得到一串16进制的字符串。
    这就需要使用hashlib模块
    hashlib功能：
        将一个字符串进行摘要运算，拿到一个固定的值
        包含额多种算法
        能够让一个字符串 唯一的对应一个固定的值
    hashlib使用方法：
        使用场景1：密码加密验，校验。
        hashlib.md5()   #md5算法。
            md5obj = hashlib.md5("tesla".encode("utf-8"))   #实例化一个md5摘要。 这个可以加点盐
                                                    # 还有动态加盐。用账号名当作盐加。但是账号就没有办法改了。
            md5obj.update("alex3714".encode("utf-8"))  # 使用md5算法的对象来操作字符串
            ret = md5obj.hexdigest()                   # 获取算法的结果 就是 hex + digest 消化　＋16进制
        hashlib.sha1()   #sha算法
            sha1obj = hashlib.sha1()
            sha1obj.update("abcdefg".encode("utf-8"))
            ret = sha1obj.hexdigest()
        使用场景2：校验文件的一致性。

3 configparse
    config.options("bitbucket.org")      同for循环 找到bitbucket,ort下所有的键
    config.items()
    config.get()
    config.remove_setion
    config.remove_option
    config.set("topsecret.server.com","k1","111111")
    config.set("yuan","k2","222222")

4 logging    必须要会
    日志模块：程序出错 --- 日志  对内看的。
              对外看的  用户行为等。
    import logging
        #简单配置,但是对中文不友好。
            logging.debug("debug message")     #非常细节的日志 ---- 排查错误的时候使用
            logging.info("info message")      # 正常的日志信息，操作记录等。
            logging.warning("warning message")   # 系统的小问题，但可以正常运转
            logging.error("error message")       # 已经不能正常处理。但是可以通过一些try处理来越过错误。
            logging.critical("critical message")  # 严重错误。已经不能正常使用了l。
            使用:
                logging.bashConfig(level=logging.DEBUG
                                   format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s ')

        #logger对象的方式配置 ----  一般使用这种进行配置 对中文支持比较好。
            #有点类似吸星大法
                loggers = logging.getLogger()
            # 往文件中输入
                fh = logging.FileHandler("log.log",encoding="utf-8") #创建了一个能操作文件的对象fh,注意指定中文编码。
                loggers.addHandler(fh)
                loggers.debug("warning message")
            # 往屏幕上输入
                sh = logging.StreamHandler()
                loggers.addHandler(sh)
                loggers.warning("warning message")
            # 格式不好看 还可以自定义格式：
                fh = logging.FileHandler("log.log")
                formatter = loggers.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
                fh.setFormatter(formatter)
                loggers.addHandler(fh)
            #

            # 如果要输出那个级别 可以调整：
                fh.setLevel(loggers.DEBUG)
                同时注意如果要输出级别往下的话 还需要修改loggers的级别
                    loggers.setLevel(logging.DEBUG)