python自动化_day7_面向对象进阶

面向对象的复习：类--->类的初始化--->对象的创造---->属性和方法，组合，继承，多态，封装

#面向对象复习
# 类  实例化 对象/实例
# 什么是类？拥有相同属性和方法的一类事物
# 什么是对象？类的实际的表现，给类中的属性填上具体的值，能够使用类中的方法
# 实例化的过程当中做了哪些事？
#     对象 = 类名（）
#     首先要创造一个对象
#     被创造出来的这个对象会作为参数传递给init方法中的第一个参数
#     然后才是调用内置的__init__方法，传递一些初始化的参数，init就是初始化方法
#     将初始化之后的对象返回给调用者
# 查看属性和调用方法
#     类名 ： 静态属性 、 类属性
#     对象 ： 调用方法（动态属性）、自动的把对象本身传进去，查看对象的属性
# 组合 ： 两类事物之间的所有（什么有什么）关系，学生有课程 班级有课程
# 继承 ： 两个类之间的包含关系，什么是什么的关系，人是动物 白马是马
#     钻石继承问题：
#         经典类：在一个子类中寻找方法的时候，从子类到父类先找到的名字会被执行
#                 深度优先就是在经典类中找类的顺序的一种算法
#         新式类：广度优先
#         py2中，主动继承object类的都是新式类，他的子类也是新式类
#         py3中，所有的类都是新式类，都继承object
#     super
#         自己有父类也有的时候，单继承super就可以用父类的属性
#         在多继承中，super遵循mro广度优先顺序
#     派生：
#         属性
#         方法
# 多态：
#     py中不需要程序员自己实现多态

封装：把函数和变量放在类中算一种广义的封装，把一些变量和方法隐藏起来，不对外公开，是python中的封装 __名字

#人狗大战，把狗和人的动作放进人和狗的类里 这就算一种封装
class Dog:
    role = 'dog'
    def eat(self):pass
Dog.role
class Person:
#     __country = '中国' #私有的静态属性
#     print(__country)   #类里面的代码什么时候执行。在自定义阶段就执行了，函数永远不执行。
    # def func(self):pass #函数加载到类里的内存空间里
# print(Person.__country) #AttributeError: type object 'Person' has no attribute '__country'
#私有的名字，只能在类的内部使用，不能再类的外部使用
print(Person.__dict__)   #'_Person__country': '中国'
print(Person._Person__country)#不能使用这种方法调用私有变量
# 如果非要在类的外部调用一个私有的名字，必须是在私有的名字前面加_类名__私有名字
Person.__name = 'xxx'  #在类的外部不能定义一个私有变量，只能在类内部
print(Person.__dict__)

私有的变量：类的内部如果使用__变量的形式会发生变形，python会自动的为你机上‘__类名’的形式

class Person:
    __country = '中国'
    def __init__(self,name,pwd):
        self.name = name
        self.__pwd = pwd
    def login(self):
        print(self.__dict__)
        if self.name == 'alex' and alex.__pwd == 'alex3714':
            print('welcome')
alex = Person('alex','alex3714')
print(alex.__dict__)
alex.login()
class Person:
    def __init__(self):pass
    def __制造密码转换(self):print('eating')
    def 注册(self):
        inp = input('>>>>')
        加密之后的密码 = self.__制造密码转换(inp)

静态属性、对象属性、方法 前面加上双下划綫都会变成私有的。只能内部调用，不能外部使用

#面试
class Foo:
    def __init__(self):
        self.__func()
    def __func(self):
        print('in foo')
class Son(Foo):
    def __func(self):
        print('in son')
s = Son()

########################################装饰器方法############################

########property
from math import pi
class Circle:
    def __init__(self,r):
        self.r = r
    @property
    def area(self):
        return self.r ** 2 * pi
    @property
    def perimeter(self):
        return self.r * 2* pi
h = Circle(5)
print(h.area)
print(h.perimeter)
#方法 都是动词 ---- 动作或者技能
#圆形类的面积和周长都是名词 调用的时候是按照方法嗲用的
#将一个函数伪装成为属性 @property
#一个方法已经做了伪装之后就不可以在加（）调用
class Vol:
    def __init__(self,x,y,z):
        self.__x = x
        self.__y = y
        self.__z = z
    @property
    def v(self):
        return 2 * self.__x * self.__y + 2 * self.__y * self.__z + 2 * self.__x * self.__z
c = Vol(5,10,4)
print(c.v)

#########################property 和 __私有的名字合用#############################

class Goods:
    def __init__(self,price,discount):
        self.__price = price  #把原价隐藏起来做成一个私有变量
        self.discount = discount
    @property
    def price(self):
        return self.__price * self.discount
    @price.setter   #修改前提就是已经对price做装饰了，先有了属性伪装才可以修改
    def price(self,new_price):self.__price = new_price
    @price.deleter
    def price(self):del self.__price
apple = Goods(8,0.8)
print(apple.price)
#如果价格变了 应该怎么办 私有变量不可以修改了
apple.price = 10
print(apple.price)
print(apple.__dict__)
del apple.price
print(apple.__dict__)

###############################classmethod类方法###############################

class Foo:
    country = '中国人'
    @classmethod                #把方法变成类方法，
    def func(cls):              #cls指向类的内存空间
        print('当前的角色国籍都是%s' % cls.country)
Foo.func()
#类方法在什么时候使用，如果某一个类中的方法，并没有用这个类的实例中的具体属性
#只是用到了类中的静态变量，就是用类方法

###############################staticmethod方法#################################

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

###############################序列化模块#####################################

#什么叫序列化
    #l = {'101122':{'name':'','age':'1'}}
    #序列化存储 必须转换成字符串才可以存储  str（）
    #拿出数据来   = =  eval（） 不安全会被其他利用 所以不适用eval
 #数据类型转换成字符串的过程就叫序列化
#什么时候要用序列化
    #数据从内存到文件
    #数据在网络上传输  字节<<<---->>>字符串<<<----->>>字典
#python中的序列化模块都有哪些
    #json  是所有语言当初都有的数据类型 支持的数据类型少 list tuple str dict
    #pickle 在python通用的 支持几乎所有python中的数据类型
    #shelve python3版本中不太好用 适用的便捷的序列化工具

#dumps  loads   在内存中序列化的模块
#dump  load     在文件里序列化的模块
import json
dic = {'k':'v'}
json_dic = json.dumps(dic)
dic_new = json.loads(json_dic)
print(dic_new)
print(type(dic_new))
with open('d.txt','a') as f:
    json.dump(dic,f)   #dump  是和文件交互的
with open('d.txt')  as f:
    print(json.load(f))

#如果要dump多条数据
#每条数据先dumps一下，变成字符串 然后打开文件write写进文件里  \n
#读取的时候按照标志读取或者按行读
#读出来之后 在使用loads
with open('aaa','w') as f:
    str_dic = json.dumps(dic)  #把dic dumps到内存里
    f.write(str_dic + '\n')
    f.write(str_dic + '\n')
    f.write(str_dic + '\n')
    f.write(str_dic + '\n')
    f.write(str_dic + '\n')
    f.write(str_dic + '\n')
    f.write(str_dic + '\n')
with open('aaa') as f:
    for line in f:
        print(json.loads(line.strip()))
import pickle
class A:
    def __init__(self,name):
        self.name = name
alex = A('alex')
json.dumps(alex) #json  不可以序列化
print(pickle.dumps(alex))
with open('ccc','ab') as f:
    pickle.dump(alex,f)
    pickle.dump(alex,f)
    pickle.dump(alex,f)
with open('ccc','rb') as f:
    while True:
        try:
            obj = pickle.load(f)
            print(obj.name)
        except EOFError:break
# piekle 好处
#1.pickle 支持更多的数据类型
#2.pickle 的结果是二进制
#3. pickle在和文件交互的时候可以被多次load
# 1、在生产中，dumps和loads只进行一次，而且要用w把原来的数据冲掉，从而保证每次都是最新的。
# 2、虚拟机的快照，是每个快照都有一个文件，而不是全都不放在一起。
# 3、如果想生产好几个序列化，就生成多个文件。
# 4、json和pickle又有相同的方法：
# json：用于（不同平台和多语言）字符串和python数据类型进行转换
# pickle：用于python特有的类型和python的数据类型间进行转换（所有python数据类型）
# json：模块提供了四个功能：dumps dump loads load
# pickle：模块提供了四个功能：dumps dump loads load
# （1）、在内存中修改，通过write和read、for循环的方式读写到文件中：
# dumps：f.write(jsoin | pickle.dumps(info))
# loads：json | pickle.loads(f.read())
#
# （2）、直接写文件，无需其他方法：
# dump： json | pickle.dump(info, f)
# load：data = json | pickle.load(f)

#######################常用模块 hashlib logging  configparserr#######################

#讲一个字符串进行摘要运算 拿到一个固定的值
#不是一个算法，包含多种算法的模块
md5obj = hashlib.sha1()  #md5  sha1 可以随意使用 其他都一样 最常用的是md5和sha
# #一种算法   实例化一个md5摘要算法的对象#能够让一个字符串  唯一的 对应 一个固定的值
md5obj.update('alex3714'.encode('utf-8'))   #使用md5算法的对象来操作字符串  basis类型
ret = md5obj.hexdigest()  #hex  digest 16进制   计算 #获取算法的结果
print(ret,type(ret),len(ret))
#注册  ：输入密码 进行一次摘要 存储到文件里
#登录  ：登录密码 进行摘要 和文件里做对比

#撞库的问题 防止撞库可以做        加盐
md5obj = hashlib.sha1('alex'.encode('utf-8'))
md5obj.update('alex3714'.encode('utf-8'))
ret = md5obj.hexdigest()
print(ret)
#动态加盐  使用注册用户名加盐  用户名注册之后就不能修改了
user = input('')
md5obj = hashlib.sha1(user.encode('utf-8'))
md5obj.update('alex3714'.encode('utf-8'))
ret = md5obj.hexdigest()
print(ret)

#校验文件的一致性
#自动化 ----py的代码做验证
md5obj = hashlib.sha1()
md5obj.update('alex3714'.encode('utf-8'))
ret = md5obj.hexdigest()
print(ret)
md5obj = hashlib.sha1()
md5obj.update('alex'.encode('utf-8'))
md5obj.update('3714'.encode('utf-8'))
ret = md5obj.hexdigest()
print(ret)

#configparser模块
config["DEFAULT"] = {'ServerAliveInterval': '45',
                      'Compression': 'yes',
                     'CompressionLevel': '9',
                     'ForwardX11':'yes'
                     }

config['bitbucket.org'] = {'User':'hg'}
config['topsecret.server.com'] = {'Host Port':'50022','ForwardX11':'no'}
with open('example.ini', 'w') as f:
   config.write(f)
config = configparser.ConfigParser()
config.read('example.ini')
print(config.sections())        #   ['bitbucket.org', 'topsecret.server.com']  # DEFAULT --> 全局

print('bytebong.com' in config) # False
print('bitbucket.org' in config) # True
print(config['bitbucket.org']["user"])  # hg
print(config['DEFAULT']['Compression']) #yes
print(config['topsecret.server.com']['ForwardX11'])  #no
print(config['bitbucket.org'])          #<Section: bitbucket.org> 生成器
for key in config['bitbucket.org']:     # 注意,有default会默认default的键
    print(key)
print(config.options('bitbucket.org'))  # 同for循环,找到'bitbucket.org'下所有键
print(config.items('bitbucket.org'))    #找到'bitbucket.org'下所有键值对
print(config.get('bitbucket.org','compression')) # yes       get方法Section下的key对应的value

import configparser
config = configparser.ConfigParser()
config.read('example.ini')
config.add_section('yuan')
config.remove_section('bitbucket.org')
config.remove_option('topsecret.server.com',"forwardx11")
config.set('topsecret.server.com','k1','11111')
config.set('yuan','k2','22222')
config.write(open('example.ini', "w"))

##############################logging模块######################################

#日志模块
#一些程序的中间过程需要记录下来，作为后期参考数据 对内看的
#对外看的日志 给用户看的日志 记录一些用户行为和代码的执行过程
#简单配置
logging.basicConfig(level=logging.DEBUG,
                     format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
                     datefmt='%a, %d %b %Y %H:%M:%S',
                     filename='test.log',
                     filemode='w')                   #级别控制
logging.debug('debug message')                   #非常细节的日志  排查错误时候使用
logging.info('info message' )                    #正常的日志信息
logging.warning('warning message')               #警告信息
logging.error('error message')                   #错误信息
logging.critical('critical message')            #重大错误  程序直接崩溃
# logger对象的方式配置
logger = logging.getLogger()#使用logger对象的方式跟吸星大法差不多
#先创造一个格式
logger.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
formatter1 = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
fh = logging.FileHandler('log.log',encoding='utf-8')  #往文件输入 #创造了一个能操作文件的对象
fh.setFormatter(formatter)
logger.addHandler(fh)
sh = logging.StreamHandler()
sh.setFormatter(formatter1)
logger.addHandler(sh)
fh.setLevel(logging.DEBUG)
sh.setLevel(logging.DEBUG)
logger.debug('logger debug message')
logger.info('logger info message')
logger.warning('logger warning message')
logger.error('程序出错了')
logger.critical('logger critical message')

######################################反射####################################

#什么叫反射
#通过字符串类型的 变量问来访问变量的值
# name = 'value'
# 获取字符串类型的变量名 来操作文件
#类名反射 静态属性
#对象名反射 对象属性和方法
#模块反射 模块中的名字
#反射自己所在文件中的名字
#   xx.yy 这样的形式都可以用反射
print('aaa'.startswith('a'))
#'startswith'
ret = getattr('aaa','startswith')
print(ret('a'))
class Person:
    role = 'person'
    def __init__(self,name):self.name = name
    def eat(self):print('eating')
    def drink(self):print('drinking')
    def play(self):print('playing')
    def sleep(self):print('sleepping')
alex = Person('alex')
print(getattr(alex,'name'))
print(getattr(alex,'role'))
while True:
    inp = input('>>>>')
    if hasattr(alex,inp):
        getattr(alex,inp)()
#首先使用getattr获取一个名字，如果在这个对象的命名空间中没有这个名字，会报错
#getattr的反射好伴侣 hasattr
#如果使用getattr获取一个方法，那么只能拿到这个方法的内存地址
#加上括号就是执行  当然，括号里的参数可以照传不误
#如果geattr获取一个属性，那么直接使用反射获取值就可以获取到值
import mymodule
import time
mymodule.func1()
getattr(mymodule,'func1')()
getattr(time,'sleep')(1)
print(getattr(mymodule,'money'))
Manager = getattr(mymodule,'Manager')
a = Manager()
a.eat()
import sys
value = '123'
print(sys.modules['__main__'])  #反射自己模块中的
print(getattr(sys.modules['__main__'],'value'))

单例模式和new方法

# 在面向对象的里面 会有很多（__方法__）
# __new__       构造方法 创建一个对象
#__init__       初始化方法 实例化一个对象
class Foo:
    def __new__(cls, *args, **kwargs):
        print('执行我啦')
        return  object.__new__(cls)
    def __init__(self):print('222222')
Foo()
#先执行new方法，object.new（）
#在执行init方法

#Foo() ------>>>  py解释器接收到你的python代码
#pyton解释器替你去做了很多操作
#包括主动帮助你 调用new方法 去创造一个对象 ------>>>开辟内存空间 ----python语言封装了开辟内存的工作
#object的new方法里做了 开辟空间 创建对象的工作
#调用init 用到的self 就是new帮你创造的对象
#翻译成C语言的字节码
#将C语言的字节码解释成机器码  让CPU去执行

#单例模式  #个人理解就是开辟一个最初的命名空间 里面的对象名字可以改变
#什么叫单例模式  某一个类 只有一个实例
class Person:
    __isinstance =  None
    def __new__(cls, *args, **kwargs):
        if not cls.__isinstance:
            obj = object.__new__(cls)
            cls.__isinstance = obj
        return cls.__isinstance
    def __init__(self,name):
        self.name = name
alex = Person('alex')
print(alex.name)
egon = Person('egon')
print(egon.name)

#############内置len方法和内置str方法############################################

class A:
    pass
    def __len__(self):
        return 10
a = A()
print(len(a))
#类中的内置方法 很多都和内置函数相关
#__hash__
class B:
    def __init__(self,name):self.name = name
    def __str__(self):
        return 'b obj of person named %s' %self.name
    def __hash__(self):
        return 1
b = B('alex')
print(hash(b))
print(b)