Python面向对象基础-day6

Posted 2020-10-17 Leon-Py

内容介绍：

1. shutil模块
2. configparser模块
3.  shelve模块
4. XML模块
5. subprocess模块
6. hashlib模块
7. re模块
8. 面向对象的的基础
9. 面向对象的特性

 

一、shutil模块

　　shutil.copyfileobj(fsrc,fdst,lenth)

import shutil

f = open(\'access.log\',\'r\')
f2 = open(\'access.log.txt\',\'w\')

#使用copyfileobj需要传两个文件对象
shutil.copyfileobj(f,f2)

　　shutil.copyfile(src,dst)

　　拷贝文件

shutil.copyfile(\'access.log\',\'access.log.bak\')

　　shutil.copymode(src,dst)

　　拷贝文件的的权限相当于Linux的cp -a

shutil.copymode(\'access.log\',\'access.log.bak\')

　　shutil.copy(src,dst)

　　拷贝文件和权限

shutil.copy(\'access.log\',\'access.log.bak\')

　　shutil.ignore_patterns(*patterns) 忽略的文件或者目录
　　shutil.copytree(src, dst, symlinks=False, ignore=None) 拷贝文件夹

shutil.copytree(r\'D:\\DjangoProj\\Jumpserver\\Pythonscript\\leonyan\',r\'D:\\DjangoProj\\Jumpserver\\Pythonscript\\new\',ignore=shutil.ignore_patterns(\'command\'))

　　shutil.rmtree()

　　删除文件

shutil.rmtree(r\'D:\\DjangoProj\\Jumpserver\\Pythonscript\\new\')

　　shutil.move(src,dst)

　　移动文件，或者是重命名文件

shutil.move(\'srcfilename\',\'dstfilename\')

　　shutil.make_archive(base_name, format,...)

　　　　创建压缩包并返回文件路径，例如：zip、tar

　　　　base_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径，
　　　　如：www =>保存至当前路径
　　　　如：/Users/wupeiqi/www =>保存至/Users/wupeiqi/
　　　　format： 压缩包种类，“zip”, “tar”, “bztar”，“gztar”
　　　　root_dir： 要压缩的文件夹路径（默认当前目录）
　　　　owner： 用户，默认当前用户
　　　　group： 组，默认当前组
　　　　logger： 用于记录日志，通常是logging.Logger对象

二、shelve模块

　　- shelve模块也是一个持久化的模块，但事实上用的并不多，首先它底层是pick封装的，所以他只能序列化Python的数据类型，在日常的开发过程中用的最多的是json

import shelve

#shalve的文件对象
s = shelve.open(\'shelve_dump\')

#shalve可以序列化多次到文件中，并生成三个文件
a = [\'yan\',\'weijian\',\'CHEN\',\'DICT\']

class Test(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def your_name(self):
        if self.name == "yan":
            return \'I am king\'
        elif self.age == "18":
            return \'19\'


T = Test(\'yan\',\'20\')

s[\'list\'] = a
s[\'class\'] = T

#关闭对象
s.close()

 

三、XML模块

　　xml是实现不同语言或程序之间进行数据交换的协议，跟json差不多，但json使用起来更简单，不过，古时候，在json还没诞生的黑暗年代，大家只能选择用xml呀，至今很多传统公司如金融行业的很多系统的接口还主要是xml。

 

 

 

四、configparser模块

import configparser

#生成一个configparser对象，不管是在创建一个文件或者是读取配置文件的时候创建对象都是必须的

config = configparser.ConfigParser()
#生成‘DEFAULT’节点
config[\'DEFAULT\']={}
config[\'DEFAULT\'][\'user\']=\'Leon\'
#生成‘globle’节点
config[\'globle\'] = {}
config[\'globle\'][\'ipaddr\'] = \'192.168.2.11\'
config[\'globle\'][\'session_timeout\'] = \'60\'
config[\'globle\'][\'root_dir\'] = \'/home/yan\'

config[\'location\'] = {
    \'type\':\'jpg|html|php\',
    \'http_pass\':"192.168.2.11"
}

#写到文件中
with open(\'config.cfg\',\'w\') as e:
    config.write(e)

　　生成的config.cfg文件

[DEFAULT]
user = Leon

[globle]
ipaddr = 192.168.2.11
session_timeout = 60
root_dir = /home/yan

[location]
http_pass = 192.168.2.11
type = jpg|html|php

　　configparser对类似文件的读取和基本使用

import configparser
#创建configparser对象
config = configparser.ConfigParser()

#从文件读取配置文件
config.read(\'config.cfg\',encoding=\'utf-8\')
#查看文件的节点个数，默认不显示‘DEFAULT’
config.sections()

#将一个节点名称设置为对象
g = config[\'globle\']
#判断‘ipaddr’是否在节点‘globle’中，g是一个列表
if \'ipaddr\' in g:
    print(\'True\')
#对象g拥有字典的所有属性，你可以用字典的方式去修改里面的属性
for k,v in g.items():
    print(k,v)

　　- configparser的增删改查

import ConfigParser
  
config = ConfigParser.ConfigParser()
config.read(\'i.cfg\')
  
# ########## 读 ##########
#secs = config.sections()
#print secs
#options = config.options(\'group2\')
#print options
  
#item_list = config.items(\'group2\')
#print item_list
  
#val = config.get(\'group1\',\'key\')
#val = config.getint(\'group1\',\'key\')
  
# ########## 改写 ##########
#sec = config.remove_section(\'group1\')
#config.write(open(\'i.cfg\', "w"))
  
#sec = config.has_section(\'wupeiqi\')
#sec = config.add_section(\'wupeiqi\')
#config.write(open(\'i.cfg\', "w"))
  
  
#config.set(\'group2\',\'k1\',11111)
#config.write(open(\'i.cfg\', "w"))
  
#config.remove_option(\'group2\',\'age\')
#config.write(open(\'i.cfg\', "w"))

 

 

　　- hashlib模块

　　　　用于加密相关的操作，3.x里代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法

import hashlib

#生成一个对象，包括加密的方式
m = hashlib.md5()
#需要加密的文字
m.update(b\'I think this thing is diff\')
#md5得到的字符串
print(m.hexdigest())

hashlib加密模块

　　这hashlib模块中上面所有的加密算法，代码的写法都和md5的一样。只需要把hashlib.md5()，后面的md5()换成其他的加密算法即可；在我们后面笔记中有机会用到加密模块的机会非常少，在这里我觉得不是专门做加密和解密的，只需要了解MD5的用法即可。

 

　　- subprocess模块

　　　　- subprocess模块是一个可以替用os.system的，在Python的官方文档中也有相关说明。同时这个模块对做运维的同行也是在以后Python使用中不可或缺的一个模块，只要你的程序和Linux系统做了交互，调用器命令，就少不了的它的出现。subprocess不是一个难以理解的模块。它的用法也比较简单，在使用这个模块是的时候我们只需要记住它几个方法就可以将其掌握。

#执行命令，返回命令执行状态 ， 0 or 非0
>>> retcode = subprocess.call(["ls", "-l"])

#执行命令，如果命令结果为0，就正常返回，否则抛异常
>>> subprocess.check_call(["ls", "-l"])

#接收字符串格式命令，返回元组形式，第1个元素是执行状态，第2个是命令结果 
>>> subprocess.getstatusoutput(\'ls /bin/ls\')
(0, \'/bin/ls\')

#接收字符串格式命令，并返回结果
>>> subprocess.getoutput(\'ls /bin/ls\')
\'/bin/ls\'

#执行命令，并返回结果，注意是返回结果，不是打印，下例结果返回给res，这里返回的结果是bytes类型
>>> res=subprocess.check_output([\'ls\',\'-l\'])
>>> res

#执行命令，打印命令执行结果

>>> subprocess.run(\'df -Th\') --> 直接报错,run方法传入的将cmd写到一个字典里面，run无法接收这种参数

>>> subprocess.run([\'df\',\'-Th\']) ->将cmd拆开装入list当中，可以正常返回，或者下面这种方法

>>> subprocess.run(\'df -Th\',shell=True) ,shell=True后面会介绍到

#底层封装-->subprocess.Popen()

poll() --->在call，run。。。方法源码中都可以看下下面这些方法，不过这类属性用的并不是特别多，在linux中一个命令不会结束的非常少，比如top属于一个，但是我们在使用脚本获取top上面数值的时候我们也可以使用top -b -n 1让他只输出一个次就行了
Check if child process has terminated. Returns returncode

wait()
Wait for child process to terminate. Returns returncode attribute.

terminate() 杀掉所启动进程
communicate() 等待任务结束

stdin 标准输入

stdout 标准输出

stderr 标准错误

pid
The process ID of the child process.

 

 #列子(subprccess.PIPE不通进程相互之间通信的管道）

res = subprocess.Popen(\'find / -type f -name *.conf\',shell=True,stdin=subprocess.PIPE,stdout=subprocess.PIPE)

res.stdout.read()

 

可用参数：

• args：shell命令，可以是字符串或者序列类型（如：list，元组）
• bufsize：指定缓冲。0 无缓冲,1 行缓冲,其他 缓冲区大小,负值 系统缓冲
• stdin, stdout, stderr：分别表示程序的标准输入、输出、错误句柄
• preexec_fn：只在Unix平台下有效，用于指定一个可执行对象（callable object），它将在子进程运行之前被调用
• close_sfs：在windows平台下，如果close_fds被设置为True，则新创建的子进程将不会继承父进程的输入、输出、错误管道。
  所以不能将close_fds设置为True同时重定向子进程的标准输入、输出与错误(stdin, stdout, stderr)。
• shell：同上
• cwd：用于设置子进程的当前目录
• env：用于指定子进程的环境变量。如果env = None，子进程的环境变量将从父进程中继承。
• universal_newlines：不同系统的换行符不同，True -> 同意使用 \\n
• startupinfo与createionflags只在windows下有效
  将被传递给底层的CreateProcess()函数，用于设置子进程的一些属性，如：主窗口的外观，进程的优先级等等

终端输入的命令分为两种：

• 输入即可得到输出，如：ifconfig
• 输入进行某环境，依赖再输入，如：python

subproces补充：

 

 

　　- re模块

\'.\'　　默认匹配除\\n之外的任意一个字符，若指定flag_dotall，则匹配任意一个字符，包括换行（这是一个点好）

‘^’　　匹配字符开头，若指定flag MULTILINE,这种也可以匹配上(r"^a","\\nabc\\neee",flags=re.MULTILINE)

\'$\'　　匹配字符结尾，或e.search("foo$","bfoo\\nsdfsf",flags=re.MULTILINE).group()也可以

‘*’　　匹配*号前面字符0次或者是N次，这里千万别把他当做是Linux中的贪婪匹配。这里并不是匹配任意一个字符一次或者是多次

‘+’　　匹配前面的字符1次或者是N次

‘？’　　匹配前面的字符0次或者一次

‘{m}’   匹配一个字符m次

‘{n,m}’ 匹配一个字符n到m次，re.findall("ab{1,3}","abb abc abbcbbb") 结果\'abb\', \'ab\', \'abb\']

\'|\'       匹配|左或|右的字符，re.search("abc|ABC","ABCBabcCD").group() 结果\'ABC\'
\'(...)\'   分组匹配，re.search("(abc){2}a(123|456)c", "abcabca456c").group() 结果 abcabca456c

‘\\A’　　只从字符开头匹配，re.search(\'\\Aabc\',\'yanabc123\') 这样是匹配不到的

\'\\Z\'    匹配字符结尾，同$

\'\\d\' 　匹配数字0-9
\'\\D\'    匹配非数字
\'\\w\'    匹配[A-Za-z0-9]
\'\\W\'   匹配非[A-Za-z0-9]
\'s\'      匹配空白字符、\\t、\\n、\\r , re.search("\\s+","ab\\tc1\\n3").group() 结果 \'\\t\'

 

最常用的匹配方法

re.match() 从头开始匹配

re.findall() 把所有匹配到的字符放入列表当中

re.search() 匹配包含

re.splitall() 以匹配到的字符当做列表中的分隔符

re.sub() 匹配字符并替换

#过滤IP地址
 re.findall(\'[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}\',data)

#过滤手机号码
re.findall(\'^1[3|4|5|8][0-9]\\d{8}$\',data)

#过滤邮箱地址
a = re.findall(\'\\w+@\\w+\\.\\w+\',data)

#上述都是一些非常low的过滤，但是在实际环境中也可以将想要的字符过滤出来并且过滤好的全部放入到列表当中，这样也方便过滤

1、match(pattern, string, flags=0)

从起始位置开始根据模型去字符串中匹配指定内容，匹配单个

• 正则表达式
• 要匹配的字符串
• 标志位，用于控制正则表达式的匹配方式

import re

re.match(\'2\',\'ljsdfj12123ljl\') # 结果为None


re.match(\'2\',\'2lsjdfljsdflij\') #结果为2

#从而得出match是从头开始找，如果第一个字符不是2，就返回None

# flags
I = IGNORECASE = sre_compile.SRE_FLAG_IGNORECASE # ignore case
L = LOCALE = sre_compile.SRE_FLAG_LOCALE # assume current 8-bit locale
U = UNICODE = sre_compile.SRE_FLAG_UNICODE # assume unicode locale
M = MULTILINE = sre_compile.SRE_FLAG_MULTILINE # make anchors look for newline
S = DOTALL = sre_compile.SRE_FLAG_DOTALL # make dot match newline
X = VERBOSE = sre_compile.SRE_FLAG_VERBOSE # ignore whitespace and comments


#flags一般不用，我这是抄的http://www.cnblogs.com/wupeiqi/articles/4963027.html博客

2、search(pattern, string, flags=0)

import re

re.search(\'2\',\'bdjflj2ljds\')

3、group和groups

a = "123abc456"
print re.search("([0-9]*)([a-z]*)([0-9]*)", a).group()

print re.search("([0-9]*)([a-z]*)([0-9]*)", a).group(0)
print re.search("([0-9]*)([a-z]*)([0-9]*)", a).group(1)
print re.search("([0-9]*)([a-z]*)([0-9]*)", a).group(2)

print re.search("([0-9]*)([a-z]*)([0-9]*)", a).groups()

4、sub

s = \'123abc()_\'

new_str = re.sub(\'[0-9]{1,}\',\'CHEN\',s)
print(new_str)

#将后面替换前面的内容

 

 

面向对象的编程

 　　各编程范式

• 面向过程：根据业务逻辑从上到下写垒代码
• 函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
• 面向对象：对函数进行分类和封装，让开发“更快更好更强...”

　　- class（类）
　　　　- 一个类是一类拥有相同数属性的抽象，蓝图（原型），在类中定义了这些对象都具有的属性，共同的方法

　　- object（对象）
　　　　- 一个对象是一个类的实例化后的实例，一个类必须经过实例化后才可以在程序中调用，一个类可以实例化多个对象，每个对象可以有不同的属性，就像人类是指所有人，每个人是指具体的对象，人与人之间有共性，也有不同

 

　　面向对象的三大特性

　　- 封装：
　　　　在类中对数据赋值、内部调用对外部用户是透明的，这使类变成了一个容器，里面包含着类的数据和方法

　　- 继承
　　　　一个类可以拍成出子类，在这个父类里定义的属性，自动被子类继承

　　- 多态：
　　　　“一个接口，多种形态“，Python原生就是多态的，比如调用len()方法，里面传入不同类型的数据就会返回不同数据的长度

 

　　定义一个对基本的类（一个类在没有办调用之前可以看做成一个模板）

class Man(object): #定义类的时候首字母大写

    print("I\'am man")


M = Man()

　　

class Man(object): #定义类的时候首字母大写
    def __init__(self,name,sex):
        self.name = name
        self.sex = sex
    def work(self):
        print("[%s] is am man"%self.name)

M = Man("Leon","F")  #生成了一个人，但是并没有让他走路（没有调用他work的功能）
M.work() # 让一个人走路
print(M.name,M.sex) #打印name 和 sex 属性

加强版

　　面向对象（扫盲）

　　　　- 在学函数的时候我们知道在函数内部的变量叫做“局部变量”，而局部变量是不可以在不同函数中来调用的，但是在面向对象的列子中__init__ 函数中定义的变量却能给 work函数内部使用，这是怎么回事呢？还有__init__()函数是一个什么东西？以及self 有事什么？请看解释

class Man(object): #定义类的时候首字母大写
    def __init__(self,name,sex): # self == > 实例(M)
        self.name = name # ==> M.name = name
        self.sex = sex # ==> M.sex = sex
    def work(self):  # self == > M
        #上面self相当于把M传进入，这样就可以调用d的方法了
        print("[%s] is am man"%self.name)  # ==> self.name = M.name

M = Man("Leon","F")  #生成了一个人，但是并没有让他走路（没有调用他work的功能）
M.work() # M.work() == > Man.work(M,) 默认将把实例本身传进去了
print(M.name,M.sex)

　　如果还不容易理解self？我们可以使用函数的方式表达出来

def man(name):
    data = {\'name\':name}
    return data

def work(self):
    print(\'%s work work\'%self.get(\'name\'))

m1 = man(\'leon\')
work(m1)

函数式

　- 特性--> 封装

　　在了解封装特性之前需要类的几个知识点

• 类变量
  • 类属性就是在一个类中定义的一个变量，这个变量是不能传值的，所以这个变量通常都是一些共有的属性，比方说在在双11的时候所有淘宝用户只要登录淘宝APP就可以领取一张1000的券，这个1000元的券是所有然都可以领取的这个就可以定义成类变量
  • 

     

• 实例变量
  • 每个实例，存在自己空间里的属性
• 共有属性
  • 共有属性 == 类变量
• 私有属性
  • self.__name = name ，这样在变量前面带有两个下划线的变量名就是私有属性，私有属性在类外不可以被实例调用（在实例化的时候必须传值），但是在类里面可以访问到私有属性。
  • 从外访问私有属性（只能看不能改）

 

　-  特性-->继承

面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

通过继承创建的新类称为“子类”或“派生类”。

被继承的类称为“基类”、“父类”或“超类”。

继承的过程，就是从一般到特殊的过程。

要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。

在某些 OOP 语言中，一个子类可以继承多个基类。但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。

继承概念的实现方式主要有2类：实现继承、接口继承。

Ø         实现继承是指使用基类的属性和方法而无需额外编码的能力；

Ø         接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力(子类重构爹类方法)；

 

　　例子

class SchoolMemer(object):  #定义一个父类
    member = 0  #定义一个变量，每次实例化类时可以自动1，用于统计实例个数
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
        SchoolMemer.member += 1 #member加一

    def tell(self):
        info = """
        ------- info of %s -------
         name:%s
         age:%s
         sex:%s
        """%(self.name,self.name,self.age,self.sex)
        return info
    def __del__(self):   #稀释函数，当实例内存释放后自动执行此函数
        SchoolMemer.member -= 1


class Teacher(SchoolMemer): #继承父类
    def __init__(self,name,age,sex,salary):  
        SchoolMemer.__init__(self,name,age,sex) # 重构父类方法，并直接引用父类的__init__方法
        self.salary = salary

    def teach(self):
        return "%s teaching salary is %s"

class Student(SchoolMemer): #继承父类
    def __init__(self,name,age,sex,grade):

        SchoolMemer.__init__(self,name,age,sex)
        self.grade = grade

    def listen(self):
        return "%s teaching listen is %s"

　

　# 面向对象--》多态：

　　定义：多态就是一种事物的不同形态，如序列类型包含字符串，列表，元祖等。python就是一种多态的语言，比如说我在在使用内置函数len的时候传入列表和字符串都可以算出其长度。而这是两种数据类型。

 

　总结

• 直接调用父类方法
• 继承父类方法并重构父类方法，先重构，然后在重构的方法里调用父类的方法
• 可以定义子类自己的方法
• 稀构方法