7）封装、反射、序列化以及logging 、configparse 、 hashilib模块

一 、封装使用

封装：

#封装 变量和函数都放在类中,广义
#狭义的封装：吧一些变量或者方法隐藏起来，不对外公开，只提供内部使用
 #共有的
 #私有的：__名字

class Person:
    __country = '中国'

# print(Person.__country)#AttributeError: type object 'Person' has no attribute '__country'
#私有属性，只能在类的内部使用，不能在类的外部使用
print(Person.__dict__)# '_Person__country'
#_Person__country
print(Person._Person__country)#中国
#如果非要在类的外部调用一个私有的名字，name必须是在私有的名字前加_类名__私有的名字
#不能使用上面这种方式去调用私有的变量

#私有的变量：

在类的内部如果使用__变量的形式会发生变形，python会自动加上_类名

class Person:
    __country = '中国'

# print(Person.__country)#AttributeError: type object 'Person' has no attribute '__country'
#私有属性，只能在类的内部使用，不能在类的外部使用
# print(Person.__dict__)# '_Person__country'
# #_Person__country
# print(Person._Person__country)#中国
#如果非要在类的外部调用一个私有的名字，name必须是在私有的名字前加_类名__私有的名字
#不能使用上面这种方式去调用私有的变量

Person.__name = 'XXX'
print(Person.__name) #在类的外部不能定义一个私有的变量
print(Person.__dict__)

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 self.__pwd =='alex3714':
            print('ok')
alex = Person('alex','alex3714')
alex.login()
print(alex.__dict__)

内部方法：

class Person:
    def __init__(self):pass
    def __eat(self):
        print('thins is eating')
alex = Person()
alex.__eat()

#静态属性、对象属性、方法（动态属性）前面加上双下划线会变成私有的

#私有的特定就是只能在类的内部调用，不能再类的外部使用

二、类中的装饰器方法

classmethod staticmethod  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

#将一个函数伪装成一个属性@property

c = Circle(3)
print(c.area)
print(c.perimeter)

验证一个苹果价格折扣例子：

class Goods:
    def __init__(self,price,discount):
        self.__price = price
        self.discount = discount
    @property
    def price(self):
        return self.__price * self.discount
    @price.setter
    def price(self,newprice):
        self.__price = newprice

@price.deleter
    def price(self):
        del self.__price
apple = Goods(8,0.7)
print(apple.price)
apple.price = 10
del apple.price
print(apple.__dict__)
print(apple.price)

Calssmethod模块

class Person:
    country = '中国人'
    @classmethod
    def func(cls):
        print('当前角色国籍是%s'%cls.country)
Person.func()

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

staticmethod 模块
class Student:
    @staticmethod
    def login():
        name = input(">>name")
        pwd = input(">>pwd")
        if name ==' ' and pwd ==' ':
            print('实例化')
Student.login()

序列化模块：

#什么交序列化呢？
#{'11111:{'name:'xx,'age:24}}
    #数据类型---字符串的过程
#为什么要用序列化
    #数据从内存到文件
        #数据在网络上传输  字节--字符串 - 字典
#python序列化模块有哪些
 #json   通用的，支持的数据类型也少   list  tuple  dict
 #pickle    python中通用的 支持几乎所有的数据类型
 #shelve     python中使用的边界的序列话工具
 
 
 # dumps  loads
 #dump   load

多次写读数据

Pickle：

两个必须会：

#登陆
#数据库
#存储用户密码的时候： 不适用明文
#对用户密码进行计算，得到一个新的固定的字符串
#hashlib模块  摘要算法
#包含了多种算法
#将一个字符串进行摘要运算 拿到一个固定的值
import hashlib
hashlib.md5()
#能够让一个字符串唯一的对应一个固定的值
#sha/md5（）

Md5算法

import hashlib
md5obj = hashlib.md5() #实例化一个md5的摘要算法的对象
md5obj.update('alex3714'.encode('utf-8'))#使用md5算法的对象来操作一个字符串
ret = md5obj.hexdigest() #hex+digest  16进制+消化
print(ret,type(ret),len(ret))

1、Sha算法

import hashlib

md5obj = hashlib.sha512() #实例化一个md5的摘要算法的对象
md5obj.update('alex3714'.encode('utf-8'))#使用md5算法的对象来操作一个字符串
ret = md5obj.hexdigest() #hex+digest  16进制+消化
print(ret,type(ret),len(ret))

#撞库
#Md5
#加盐
import hashlib
md5obj = hashlib.md5() #实例化一个md5的摘要算法的对象
md5obj.update('alex3714'.encode('utf-8'))#使用md5算法的对象来操作一个字符串
ret = md5obj.hexdigest() #hex+digest  16进制+消化
print(ret,type(ret),len(ret))

2、#撞库
#Md5
#加盐
md5obj = hashlib.md5('tesla'.encode('utf-8')) #实例化一个md5的摘要算法的对象
md5obj.update('alex3714'.encode('utf-8'))#使用md5算法的对象来操作一个字符串
ret = md5obj.hexdigest() #hex+digest  16进制+消化
print(ret,type(ret),len(ret))

3、#动态加盐
username = 'alex' #用户加盐
md5obj = hashlib.md5(username.encode('utf-8')) #实例化一个md5的摘要算法的对象
md5obj.update('alex3714'.encode('utf-8'))#使用md5算法的对象来操作一个字符串
ret = md5obj.hexdigest() #hex+digest  16进制+消化
print(ret,type(ret),len(ret))

拆分读字节，防止太大5个G

md5obj = hashlib.md5() #实例化一个md5的摘要算法的对象
md5obj.update('alex'.encode('utf-8'))#使用md5算法的对象来操作一个字符串# 等同于alex3714
md5obj.update('3714'.encode('utf-8'))#使用md5算法的对象来操作一个字符串#等同于alex3714
print(md5obj.hexdigest())

Configparse模块：

import configparser

config = configparser.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)

import logging
#日志
#程序出错---日志对内看的
#对外给用户看的

#简单配置
logging.basicConfig(level=logging.DEBUG)
logging.debug('debug message')  #非常细节的日志---排查错误
logging.info('info message')   #正常的日志信息
logging.warning('warning message')#小问题可以运行 警告
logging.error('error message')  #错误
logging.critical('critical message')#严重错误

#logger对象的方式配置

Logget = logging.getLogger()
#吸星大法

#往文件中输入
fh = logging.FileHandler('log.log') #创造了一个能操作文件的对象fh
Logget.addHandler(fh)

sh  = logging.StreamHandler()#控制台输入
Logget.addHandler(sh)

Logget.warning('debug message') #文件中的内容
Logget.error('error message')

#反射
#通过字符串数据类型的变量名 来访问变量的值

name = 'value'
#类名 反射 静态属性 和方法
#模块 反射模块中的名字
#反射 自己搜在文件中的名字
#xx.yy这种形式 都可以用反射

#'startswith'
print('aaa'.startswith('a'))
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')
alex.name
print(getattr(alex,'name'))
print(getattr(Person,'role'))

while True:
    inp = input('>>>')
    if hasattr(alex,inp):
        getattr(alex,inp)()

#首先使用getattr获取一个名字，如果在这个对象的命名空间中没有这个名字 会报错
#getattr的反射好伴侣 hasattr
#如果使用getattr获取一个方法，那么只能拿到一个方法的内存地址
#如果getattr获取一个属性，那么直接使用反射就可以获取到值

#__new__    构造方法  创建一个对象
#__init__  初始化方法

class Foo:
    def __new__(cls, *args, **kwargs):
        print('执行我了')
        return object.__new__(cls)
    def __init__(self):
        print('22222222')

Foo()
#先执行new方法，objectf.new（）
#在执行init

#单列模式
class Persion:
    __isinstace = None
    def __new__(cls, *args, **kwargs):
        if not cls.__isinstace:
            obj = object.__new__(cls)
            cls.__isinstace = obj
        return cls.__isinstace
    def __init__(self,name):
        self.name = name

alex = Persion('alex')
egon = Persion('egon')
print(id(alex))
print(id(egon))

#__new__ 生小孩
#类： 生一个小孩__new__ 给小孩穿衣服__init__

#单类模式下的类： 只有一个小孩

#len 方法
class A:
    def __len__(self):
        return 10

print(len([1,2,3]))
a = A()
print(len(a))
#类中的内置方法 很多都和 内置函数相关

class Person:
    def __init__(self,name):
        self.name = name
    def __str__(self):
        return 'a object of Person named %s'%self.name
    # def __hash__(self):
    #     return 1231212
    # def __len__(self):
    #     return 10
a = Person('alex')
b = Person('egon')
# print(len(a))
# print(hash(a))
print(a)
print(b)

原文地址：http://blog.51cto.com/xiaorenwutest/2119126

时间： 2024-10-17 09:38:33

7）封装、反射、序列化以及logging 、configparse 、 hashilib模块的相关文章

python学习笔记-Day5（反射、特殊方法、OS模块）

反射 # 反射(或叫自省): 有时候我们会碰到这样的需求,需要执行对象的某个方法,或是需要对对象的某个字段赋值,而方法名或是字段名在编码代码时并不能确定,需要通过参数传递字符串的形式输入 # 这就是我们反射功能: 通过字符串形式去调用对象 # 例, 我有一个导向页面commons.py def login(): print('登录') def home(): print('HOME PAGE') def logout(): print('logout !!!') # 我需要根据用户输入,去执行对

python oop 多态 封装 反射

python中关于OOP的常用术语 抽象/实现 抽象指对现实世界问题和实体的本质表现,行为和特征建模,建立一个相关的子集,可以用于 绘程序结构,从而实现这种模型.抽象不仅包括这种模型的数据属性,还定义了这些数据的接口. 对某种抽象的实现就是对此数据及与之相关接口的现实化(realization).现实化这个过程对于客户 程序应当是透明而且无关的. 封装/接口 封装描述了对数据/信息进行隐藏的观念,它对数据属性提供接口和访问函数.通过任何客户端直接对数据的访问,无视接口,与封装性都是背道而驰的,除

封装通用序列化类

import lombok.extern.slf4j.Slf4j;import java.io.*;import java.util.ArrayList;import java.util.List; import static com.alibaba.druid.util.JdbcUtils.close; /** * @author: wsj * @date: 2018/10/10 * @time: 17:46 */@Slf4jpublic class ListTranscoder { publ

python3 json、logging、sys模块

json模块 import json dic = {'name':'egon','age':32} # ------------------------------>序列化 f = open('json.txt','w') data = json.dumps(dic) print(data) print(type(data)) f.write(data) f.close() # ------------------------------>返序列化 f = open('json.txt','r

Python time、datetime、os、random、sys、hashlib、json、shutil、logging、paramiko模块的使用

1.time & datetime模块 #_*_coding:utf-8_*_ import time import datetime print(time.clock()) #返回处理器时间,3.3开始已废弃 print(time.process_time()) #返回处理器时间,3.3开始已废弃 print(time.time()) #返回当前系统时间戳 print(time.ctime()) #输出Tue Jan 26 18:23:48 2016 ,当前系统时间 print(time.ct

python3 logging 日志记录模块

#coding:utf-8 import logginglogging.basicConfig(filename='log1.log', format='%(asctime)s -%(name)s-%(levelname)s-%(module)s:%(message)s', datefmt='%Y-%m-%d %H:%M:%S %p', level=logging.DEBUG) while True: option = input("input a digit:") if option

光模块有哪些封装类型？图文介绍：光模块类型和作用

在向大家介绍光模块类型之前,首先说说:光模块是什么? 光模块由光电子器件.功能电路和光接口等组成,光电子器件包括发射和接收两部分.简单的说,光模块的作用就是光电转换,发送端把电信号转换成光信号,通过光纤传送后,接收端再把光信号转换成电信号. 通过上面,我们知道什么是光模块了,可是对于不是很精通这个行业的人来说,每个光模块长得都差不多,好像是没有太多的区别.可是,事实真的是这样吗? 其实,不同类型的光模块分类区别是很大的.那么,光模块有着哪些分类呢?通过资料的分析收集,通常光模块的分类可以按一下几

day17——logging、os模块、commands模块、sys模块

logging的使用 日志是我们排查问题的关键利器,写好日志记录,当我们发生问题时,可以快速定位代码范围进行修改.Python有给我们开发者们提供好的日志模块,我们我们就来介绍一下logging模块: 首先,我们先来看一个例子: import logging logging.debug("This is debug message") logging.info("The is info message") logging.warning("This is

python(logging,hashlib与模块导入)

logging模块 # encoding:utf-8import logging logging.basicConfig( level=logging.DEBUG, filename='logger.log', #保存到文件 filemode='w', #不会以追加显示重复保存 format='%(asctime)s %(filename)s %(lineno)d %(message)s' #添加时间,文件名,行数,信息 )logging.debug("debug message")l