www.hj8828.com 2

www.hj8828.comPython第二十天 shutil 模块 zipfile tarfile 模块

Python模块知识8:configparser、压缩模块,pythonconfigparser

一、configparser模块

configparser用于处理特定格式的文件,其本质上是利用open来操作文件。

文件格式如:

1.基本的读取配置文件

-read(filename) 直接读取ini文件内容

-sections() 得到所有的section,并以列表的形式返回

-options(section) 得到该section的所有option

-items(section) 得到该section的所有键值对

-get(section,option) 得到section中option的值,返回为string类型

-getint(section,option)
得到section中option的值,返回为int类型,还有相应的getboolean()和getfloat()
函数。

2.基本的写入配置文件

-add_section(section) 添加一个新的section

-set( section, option, value)
对section中的option进行设置,需要调用write将内容写入配置文件。

案例1:取节点、键值对、键、键下面的值

import configparser #导入模块
config=configparser.ConfigParser() #必须的装载语句
config.read('black.txt',encoding='utf-8')#从文件中读取内容
ret=config.sections()#取所有的节点
ret2=config.items("sec1")#取节点值1下的所有的键值对
ret3=config.options('sec1')#获取节点值1下的所有的键
ret4=config.get('sec1',"k1")#获取节点值1,k1键下的值
print(ret)#执行结果['sec1', 'sec2', 'sec3']
print(ret2)#执行结果[('k1', 'v1    # 值'), ('k2', 'v2       # 值')]
print(ret3)#执行结果['k1', 'k2']
print(ret4)#执行结果v1    # 值

执行结果:

案例2:操作节点

#添加节点、键值对

import configparser #导入模块
config=configparser.ConfigParser() #必须的装载语句
config.add_section("sec4")#添加节点
config.set("sec4","k2","jjj")#添加节点下的键值对
config.write(open('black.txt','a'))

执行结果:

案例3:检查节点

#检查节点是否存在

import configparser #导入模块
config=configparser.ConfigParser() #必须的装载语句
config.read('black.txt',encoding='utf-8')#从文件中读取内容
#检查是否有某个节点
has_sec=config.has_section("sec2")#检查是否有节点“sec2”
print(has_sec)

执行结果:TRUE

案例4:删除节点

#删除节点或者节点下的键值对

import configparser #导入模块
config=configparser.ConfigParser() #必须的装载语句
config.read('black.txt',encoding='utf-8')#从文件中读取内容
config.remove_section('sec3')#删除节点
# config.remove_option('sec3','k1')#删除节点
config.write(open('black.txt', 'w'))

二、压缩zipfile模块

1)压缩

import zipfile

z=zipfile.ZipFile(‘a.zip’,’w’)

z.write(‘hh.xml’)

z.write(‘hhnew3’)

z.close()

2)解压缩

import zipfile

z=zipfile.ZipFile(‘a.zip’,’r’)

z.extractall()#解压全部

for item in z.namelist():

    print(item,type(item))

z.close()

三、tar文件夹解压

1)压缩

import  tarfile

tar = tarfile.open(‘your.tar’,’w’)#压缩tar文件

tar.add(‘hh.xml’, arcname=’hh1.xml’)#可以把hh压缩时改名为hh1

tar.add(‘hhnew3′, arcname=’hh3’)

tar.close()

2)解压

tar = tarfile.open(‘your.tar’,’r’)

#tar.extractall()  # 可设置解压所有的问题

#打印所有的对象

for item in tar.getmembers():

    print(item,type(item))

#单个解压缩文件

obj=tar.getmember(“hh1.xml”)

tar.extract(obj)

tar.close()

configparser模块

configparser用于处理特定格式的文件,其本质是利用open来操作文件。

文件a.txt

  1. [section1]

  2. k1 = 123

  3. k2:v2

  4.  

  5. [section2]

  6. k1 = 234

加载文件a.txt

  1. import configparser

  2.  

  3. config = configparser.ConfigParser()

  1. config.read(‘a.txt’,encoding=’utf-8′)

对文件相关操作

  1. import configparser

  2.  

  3. config = configparser.ConfigParser()

  1. config.read(‘a.txt’,encoding=’utf-8′)
  1.  

  2. #获取所有节点

  3. ret = config.sections()

  4. print(ret)

  5.  

  6. #获取指定节点下的所有键值对

  7. ret = config.items(‘section1’)

  8. print(ret)

  9.  

  10. #获取指定节点下所有的键

  11. ret = config.options(‘section1’)

  1. print(ret)

  2.  

  3. #获取指定节点下指定key的值

  4.  

  5. ret = config.get(‘section1′,’k1’)

  6. #转换成int

  7. # ret = config.getint(‘section1′,’k1’)

  1. #转换成float

  2. # ret =
    config.getfloat(‘section1′,’k1’)

  3. #转换成boolean

  4. # ret =
    config.getboolean(‘section1′,’k1’)

  5.  

  6. print(ret)

  7.  

  8. #检查、删除、设置指定组内的键值对

  1.  

  2. #检查

  3. has_opt =
    config.has_option(‘section1’)

  4. print(has_opt)

  5.  

  6. #添加节点

  7. config.add_section(‘SEC_1’)

  8. config.write(open(‘a.txt’,’w’))

  9.  

  10. #删除节点

  11. config.remove_section(‘SEC_1’)

  1. config.write(open(‘a.txt’,’w’))

  2.  

  3. #检查、删除、设置指定组内的键值对

  1.  

  2. #检查

  3. has_opt =
    config.has_option(‘section1′,’k1’)

  4. print(has_opt)

  5.  

  6. #删除

  7. config.remove_option(‘section1′,’k1’)

  1. config.write(open(‘a.txt’,’w’))

  2.  

  3. #设置

  4. config.set(‘section1′,’k10′,’123’)

  5. config.write(open(‘a.txt’,’w’))

Python第二十天  shutil 模块  zipfile   tarfile 模块

XML模块

xml是实现不同语言或程序之间进行数据交换的协议。

文件xml_text.xml

  1. <data>

  2.     <country name=”Liechtenstenin”>

  3.         <rank update=”yes”>2</rank>

  4.         <year>2023</year>

  1.         <gdppc>141100</gbppc>
  1.         <neighbor direction=”E” name=”Austria”/>

  2.         <neighbor direction=”W” name=”Switzerland”/>

  3.     </country>

  4.     <country name=”Sinagapore”>

  5.         <rank update=”yes”>5</rank>

  6.         <year>2026</year>

  1.         <gdppc>59900</gdppc>
  1.         <neighbor direction=”N” name=”Malaysia”/>

  2.     </country>

  3.     <country name=”Panama”>

  4.         <rank update=”yes”>69</rank>

  5.         <year>2026</year>

  1.         <gdppc>13600</gdppc>
  1.         <neighbor direction=”W” name=”Costa Rica”/>

  2.         <neighbor direction=”E” name=”Costa Rica”/>

  3.     </country>

  4. </data>

 

xml相关操作

解析xml文件

  1. from xml.etree import ElementTree as ET

  2. #直接解析xml文件

  3. tree = ET.parse(‘xml_test.xml’)

  1.  

  2. #获取xml文件的根节点

  3. root = tree.getroot()

  4. print(root)

  5. print(root.tag)

  6. print(root.attrib)

  7. “””

  8. 输出:

  9. <Element ‘data’ at
    0x00000000006D0688>

  10. data

  11. {‘title_2’: ‘test_2’, ‘title_1’:
    ‘test_1’}

  12. “””

解析字符串

  1. from xml.etree import ElementTree as ET

  2.  

  3. #打开文件,读取xml内容

  4. str_xml =
    open(‘xm_test.xml’,’r’).read()

  5.  

  6. #将字符串解析成xml特殊对象,root代指xml文件的根节点

  1. root = ET.XML(str_xml)

遍历xml文档的所有内容

  1. from xml.etree import ElementTree as ET

  2. #直接解析xml文件

  3. tree = ET.parse(‘xml_test.xml’)

  1.  

  2. #获取xml文件的根节点

  3. root = tree.getroot()

  4. #遍历xml文档的第二层

  5. for
    child in root:

  6.     #第二层节点的标签名称和标签属性

  1.     print(child.tag,child.attrib)
  1.     #遍历xml文档的第三层

  2.     for i in
    child:

  3.         #第三层节点的标签名称和内容

  1.         print(i.tag,i.text)

  2. “””

  3. 输出:

  4. country {‘name’: ‘Liechtenstenin’}

  1. rank 2

  2. year 2023

  3. gdppc 141100

  4. neighbor None

  5. neighbor None

  6. country {‘name’: ‘Sinagapore’}

  7. rank 5

  8. year 2026

  9. gdppc 59900

  10. neighbor None

  11. country {‘name’: ‘Panama’}

  12. rank 69

  13. year 2026

  14. gdppc 13600

  15. neighbor None

  16. neighbor None

  17. “””

修改xml

解析字符串方式进行修改

  1. from xml.etree import ElementTree as ET

  2. str_xml =
    open(‘xml_test.xml’,’r’).read()

  3. root = ET.XML(str_xml)

  4.  

  5. #获取顶层标签

  6. print(root.tag)

  7.  

  8. #循环所有的year节点

  9. for
    node in root.iter(‘year’):

  10.     #将year节点中的内容自增一

  11.     new_year = int(node.text) + 1

  12.     node.text = str(new_year)

  13.  

  14.     #设置属性

  15.     node.set(‘name’,’alex’)

  16.     node.set(‘age’,’19’)

  17.  

  18.     #删除属性

  19.     del node.attrib[‘name’]

  20.  

  21. #更新文件

  22. tree = ET.ElementTree(root)

  23. tree.write(“new_xml_test.xml”,encoding=’utf-8′)

解析文件方式进行修改

直接调用tree.write写入即可。

  1. from xml.etree import ElementTree as ET

  2. tree = ET.parse(‘xml_test.xml’)

  1. root = tree.getroot()

  2.  

  3. “””

  4. 操作

  5. “””

  6.  

  7. #更新文件

  8. tree.write(“new_xml_test2.xml”,encoding=’utf-8′)

添加节点

  1. from xml.etree import ElementTree as ET

  2. tree = ET.parse(‘xml_test.xml’)

  1. root = tree.getroot()

  2.  

  3. ele = ET.Element(‘Alex’,{‘k1′:’v1’})

  1. ele.text = “test”

  2. root.append(ele)

  3.  

  4. tree.write(“new.xml”,encoding=’utf-8′)

结果new.xml:

  1. <data title_1=”test_1″ title_2=”test_2″>

  2.  

  3. “””

  4. 原内容

  5. “””

  6.  

  7. <Alex k1=”v1″>test</Alex></data>

由于原生保存xml时默认无缩进,如果要设置缩进需要修改保存方式。

  1. from xml.etree import ElementTree as ET

  2. from xml.dom import minidom

  3.  

  4. def prettify(elem):

  5.     “””

  6.     将节点转换成字符串,并添加缩进

  1.     :param elem:

  2.     :return:

  3.     “””

  4.     rough_string =
    ET.tostring(elem,’utf-8′)

  5.     reparsed =
    minidom.parseString(rough_string)

  6.     return reparsed.toprettyxml(indent=”\t”)

  7.  

  8. #创建根节点

  9. root = ET.Element(“family”)

  10.  

  11. #创建大儿子

  12. # son1 =
    ET.Element(‘son’,{‘name’:’儿1′})

  13. son1 =
    root.makeelement(‘son’,{‘name’:’儿1′})

  14. #创建小儿子

  15. # son2 =
    ET.Element(‘son’,{‘name’:’儿2′})

  16. son2 =
    root.makeelement(‘son’,{‘name’:’儿2′})

  17.  

  18. #在儿子中创建2个孙子

  19. # grandson1 =
    ET.Element(‘grandson’,{‘name’:’儿11′})

  20. grandson1 =
    root.makeelement(‘grandson’,{‘name’:’儿11′})

  21. # grandson2 =
    ET.Element(‘grandon’,{‘name’:’儿12′})

  22. grandson2 =
    root.makeelement(‘grandon’,{‘name’:’儿12′})

  23.  

  24. son1.append(grandson1)

  25. son2.append(grandson2)

  26.  

  27. #把儿子添加到根节点

  28. root.append(son1)

  29. root.append(son2)

  30.  

  31. raw_str = prettify(root)

  32.  

  33. f =
    open(‘family.xml’,’w’,encoding=’utf-8′)

  34. f.write(raw_str)

  35. f.close()

family.xml:

  1. <?xml version=”1.0″ ?>

  2. <family>

  3.    <son name=”儿1″>

  4.       <grandson name=”儿11″/>

  5.    </son>

  6.    <son name=”儿2″>

  7.       <grandon name=”儿12″/>

  8.    </son>

  9. </family>

os文件的操作还应该包含移动 复制  打包 压缩
解压等操作,这些os模块都没有提供

shutil

高级的文件、文件夹、压缩包处理模块。

shutil.copyfileobj(ferc,fdst[,length])

将文件内容拷贝到另一个文件中

  1. import shutil

  2.  

  3. shutil.copyfileobj(open(‘old.xml’,’r’),open(‘new.xml’,’w’))

shuit.copyfile(src,dst)

拷贝文件

  1. shutil.copyfile(‘f1.log’,’f2.log’)

shutil 模块
shutil.copyfileobj(fsrc, fdst[, length=16*1024])   
#copy文件内容到另一个文件,可以copy指定大小的内容

zipfile、tarfile

zipfile创建压缩包

  1. import zipfile

  2.  

  3. #压缩

  4. z = zipfile.ZipFile(‘test.zip’,’a’)

  1. z.write(‘new.xml’)

  2. z.write(‘family.xml’)

  3. z.close

zipfile解压压缩包

  1. #解压

  2. z = zipfile.ZipFile(‘test.zip’,’r’)

  1.  

  2. #解压全部

  3. # z.extractall()

  4.  

  5. #解压单个文件

  6. z.extract(“new.xml”)

  7.  

  8. #获取压缩包的成员

  9. for
    item in z.namelist():

  10.     print(item)

  11.  

  12. z.close()

tarfile创建压缩包

  1. import tarfile

  2.  

  3. #压缩

  4. tar = tarfile.open(“test.tar”,’w’)

  5. #arcname重命名

  6. tar.add(‘test.py’,arcname=’test_1.py’)

  1. tar.add(‘xml_test.py’,arcname=’xml_test.py’)
  1. tar.close()

tarfile解压压缩包

  1. tar = tarfile.open(‘test.tar’,’r’)
  1.  

  2. #可设置解压路径

  3. # tar.extractall()

  4.  

  5. for
    item in tar.getmembers():

  6.     print(item,type(item))

  7.  

  8. obj = tar.getmember(“test_1.py”)

  9. print(obj,type(obj))

  10. tar.extract(obj)

  11.  

  12. tar.close()

文件拷贝操作
shutil.copyfile(src,dst)  
#copy文件内容,是不是感觉上面的文件复制很麻烦?还需要自己手动用open函数打开文件,在这里就不需要了,事实上,copyfile调用了copyfileobj
shutil.copymode(src,dst)   #仅copy权限,不更改文件内容,组和用户。
shutil.copystat(src,dst)   
#复制所有的状态信息,包括权限,组,用户,时间等
shutil.copy(src,dst)   #复制文件的内容以及权限,先copyfile后copymode

系统命令

shutil.copy2(src,dst)   
#建议使用这个来拷贝,复制文件的内容以及文件的所有状态信息。先copyfile后copystat
示例:shutil.copy2(‘/tmp/123.txt’,’/tmp/mysql/123.txt’)

call

获取状态码,0正常。

  1. import subprocess

  2.  

  3. #shell=False命令传入方式为列表

  4. ret = subprocess.call([“ls”,”-l”],shell=False)

  5.  

  6. #shell=True命令传入方式为字符串

  1. ret = subprocess.call(“ls -l”,shell=True)

目录操作
shutil.copytree(src, dst, symlinks=False, ignore=None,
copy_function=copy2,ignore_dangling_symlinks=False)  
#递归的复制文件内容及状态信息,目标目录不需要预先创建
shutil.rmtree(path, ignore_errors=False, onerror=None)  
#递归地删除文件
示例

check_call

执行命令,如果执行状态码是0,则返回0,否则抛出异常。

  1. ret = subprocess.check_call(“ls -l”,shell=True)
shutil.copytree('/tmp/mysql','/tmp/mysql2') mysql2这个目标目录不需要预先创建

check_output

执行命令,如果状态码是0,则返回执行结果,否则抛出异常。

  1. ret = subprocess.check_output(“ls -l”,shell=True)

 

函数式编程和面向对象编程实现发送邮件功能。

函数实现:

  1. def mail(email,message):

  2.     print(“发送”)

  3.    return True

  4.  

  5. mail(“xxxx.@126.com”,”hello”)

面向对象实现:

  1. class
    Foo:

  2.     #方法

  3.    def mail(self,email,message):

  1.        print(“发送”)

  2.       return True

  3.  

  4. #调用

  5. #1、创建对象,类名()

  6. obj = Foo()

  7. #2、通过对象去执行方法

  8. obj.mail(“xxxx.@126.com”,”hello”)

剪切文件操作
shutil.move(src, dst)    #递归的移动文件
示例:

类和对象

1、创建类:

class 类名:

def 方法名(self,xxx):

pass

2、创建对象

对象 = 类名()

3、通过对象执行方法

对象.方法名(xxx)

函数式

def fetch(host,username,passwd,sql):

pass

def create(host,username,passwd,sql):

pass

def remove(host,username,passwd,sql):

pass

def modify(host,username,passwd,sql):

pass

fetch(…)

面向对象:

class SQLHelper:

def fetch(self,host,username,passwd,sql):

pass

def create(self,host,username,passwd,sql):

pass

def remove(self,host,username,passwd,nid):

pass

def modify(self,host,username,passwd,name):

pass

obj = SQLHelper()

obj.fetch(…)

面向对象优化:

class SQLHelper:

def fetch(self, sql):

pass

def create(self,sql):

pass

def remove(self,nid):

pass

def modify(self,name):

pass

obj = SQLHelper()

obj.hhost = “xxx.xxx.xxx”

obj.uusername = “xxxx”

obj.passwd = “xxxx”

obj.fetch(“sql”)

  1. class
    SQLHelper:

  2.     def fetch(self, sql):

  3.         #链接数据库

  4.         print(self.hhost)

  5.         print(self.uusername)

  6.         print(self.passwd)

  7.         print(sql)

  8.     def create(self,sql):

  9.         pass

  10.     def remove(self,nid):

  11.         pass

  12.     def modify(self,name):

  13.         pass

  14. obj = SQLHelper()

  15. obj.hhost = “xxx.xxx.xxx”

  16. obj.uusername = “xxxx”

  17. obj.passwd = “xxxx”

  18. obj.fetch(“select * from A”)

  19. 输出:

  20. xxx.xxx.xxx

  21. xxxx

  22. xxxx

  23. select * from A

shutil.move('/tmp/mysql','/tmp/mysql2') 在同一个目录下,对于目录就是改名,mysql2这个目标目录不需要预先创建
shutil.move('/tmp/mysql2/123.txt','/tmp/mysql3/123.txt') 对于文件就是剪切

什么时候使用面向对象?

当某些函数具有相同参数时,可以使用面向对象的方式,将参数值一次性封装到对象中,方便以后去对象中取值。

 

self是什么?

self是一个python自动传值的参数,那个对象执行方法,self就是谁。

obj1 = SQLHelper()

obj1.hhost = “1xxx.xxx.xxx”

obj1.uusername = “xxxx”

obj1.passwd = “xxxx”

obj1.fetch(“sql”) #self==obj1

 

obj2 = SQLHelper()

obj2.hhost = “2xxx.xxx.xxx”

obj2.uusername = “xxxx”

obj2.passwd = “xxxx”

obj2.fetch(“sql”) #self==obj2

批量打包压缩操作
make_archive(base_name, format, root_dir=None, base_dir=None,
verbose=0,dry_run=0, owner=None, group=None, logger=None)  #压缩打包
base_name:    压缩打包后的文件名或者路径名
format:          压缩或者打包格式    “zip”, “tar”, “bztar”or “gztar”
root_dir :         将哪个目录或者文件打包(也就是源文件)
base_dir :         将哪个目录或者文件打包(也就是源文件)
root_dir 和 base_dir 默认设置为当前目录,root_dir 和 base_dir
一般可以认为是一样的

构造方法

类中有一个特殊的方法__init__,类()自动被执行。

  1. class
    SQLHelper:

  2.     def __init__(self,a1,a2,a3):

  1.         self.hhost = a1

  2.         self.uusername = a2

  3.         self.passwd = a3

  4.         print(“自动执行init”)

  5.     def fetch(self, sql):

  6.         #链接数据库

  7.         print(self.hhost)

  8.         print(self.uusername)

  9.         print(self.passwd)

  10.         print(sql)

  11.     def create(self,sql):

  12.         pass

  13.     def remove(self,nid):

  14.         pass

  15.     def modify(self,name):

  16.         pass

  17. obj1 = SQLHelper(“1xxx.xxx.xxx”,”xxxx”,”xxxx”)

  18. obj1.fetch(“select * from A”)

  19. obj2 = SQLHelper(“2xxx.xxx.xxx”,”xxxx”,”xxxx”)

  20. obj2.fetch(“select * form A”)

  21. 输出:

  22. 自动执行init

  23. 1xxx.xxx.xxx

  24. xxxx

  25. xxxx

  26. select * from A

  27. 自动执行init

  28. 2xxx.xxx.xxx

  29. xxxx

  30. xxxx

  31. select * form A

面向对象三大特性:封装、继承、多态。

shutil.make_archive(‘tarball’,’gztar’,root_dir=’/tmp/mysql’)

封装

面向对象的程序设计中,某个类把所需要的数据(类的属性)和对数据的操作(类的行为)全部都封装在类中,分别称为类的成员变量和方法(成员函数)。这种把成员变量和成员函数封装在一起的编程特性称为封装。

  1. class
    c1:

  2.     def __init__(self,name,obj):

  1.         self.name = name

  2.         self.obj = obj

  3.  

  4. class
    c2:

  5.     def __init__(self,name,age):

  1.         self.name = name

  2.         self.age = age

  3.  

  4.     def show(self):

  5.         print(self.name)

  6.  

  7. class
    c3:

  8.     def __init__(self,a1):

  9.         self.money = 123

  10.         self.aaa = a1

  11.  

  12.  

  13. c2_obj = c2(‘aa’,11)

  14.  

  15. c1_obj = c1(“alex”,c2_obj)

  16. print(c1_obj.obj.age)

  17.  

  18. c3_obj = c3(c1_obj)

  19. print(c3_obj.aaa.obj.age)

  20. 输出:

  21. 11

  22. 11


继承

继承是两个类或多个类之间的父子关系,子进程继承父进程的所有公有实例变量和方法。继承实现了代码的重用。重用已经存在的数据和行为,减少代码的重新编写,python在类名后用一对圆括号表示继承关系,括号中的类表示父类,如果父类定义了__init__方法,则子类必须显示地调用父类的__init__方法,如果子类需要扩展父类的行为,可以添加__init__方法的参数。

zipfile

单继承

  1. class
    F1:#父类、基类

  2.     def show(self):

  3.         print(‘show’)

  4.  

  5. #F2继承F1

  6. class
    F2(F1):#子类、派生类

  7.     def bar(self):

  8.         print(‘bar’)

  9.  

  10. obj = F2()

  11. obj.bar()

  12. obj.show()

  13. 输出:

  14. bar

  15. show

 

  1. class
    F1:#父类、基类

  2.     def show(self):

  3.         print(‘show’)

  4.  

  5.     def foo(self):

  6.         print(self.name)

  7.  

  8. #F2继承F1

  9. class
    F2(F1):#子类、派生类

  10.     def __init__(self,name):

  1.         self.name = name

  2.  

  3.     def bar(self):

  4.         print(‘bar’)

  5.  

  6.     def show(self):#自己的优先级更高

  1.         print(‘F2 show’)

  2.  

  3. obj = F2(‘alex’)

  4. obj.bar()

  5. obj.show()

  6. obj.foo()

  7. 输出:

  8. bar

  9. F2 show

  10. alex

 

  1. class
    S1:

  2.     def F1(self):

  3.         self.F2()

  4.  

  5.     def F2(self):

  6.         print(‘S1.F2()’)

  7.  

  8. class
    S2(S1):

  9.     def F3(self):

  10.         self.F1()

  11.  

  12.     def F2(self):

  13.         print(‘S2.F2()’)

  14.  

  15. obj = S2()

  16. obj.F3()

  17. 输出:

  18. S2.F2()

zipfile模块
ZipFile类
zipfile.ZipFile(zipfilename, ‘a’)
a:添加文件到压缩包
r:读取压缩包内容
w:生成一个压缩包

多继承

  1. class
    C1:

  2.     def f1(self):

  3.         pass

  4.  

  5. class
    C2:

  6.     def f2(self):

  7.         pass

  8.  

  9. class
    C3(C2,C1):

  10.     pass

  11.  

  12. obj = C3()

 

  1. class
    C1:

  2.     def f1(self):

  3.         print(“C1.f1()”)

  4.  

  5. class
    C2:

  6.     def f1(self):

  7.         print(“C2.f1()”)

  8.  

  9. class
    C3(C2,C1):

  10.     pass

  11.  

  12. obj = C3()

  13. obj.f1()

  14. 输出:

  15. C2.f1()

 

  1. class
    C0:

  2.     def f1(self):

  3.         print(“C0.f1()”)

  4.  

  5. class
    C1():

  6.     def f1(self):

  7.         print(“C1.f1()”)

  8.  

  9. class
    C2(C0):

  10.     def f2(self):

  11.         print(“C2.f1()”)

  12.  

  13. class
    C3(C2,C1):

  14.     pass

  15.  

  16. obj = C3()

  17. obj.f1()

  18. 输出:

  19. C0.f1()

 

  1. class
    C_2:

  2.     def f1(self):

  3.         print(“C_2.f1()”)

  4.  

  5. class
    C_1(C_2):

  6.     def f1(self):

  7.         print(“C_1.f1()”)

  8.  

  9. class
    C0(C_2):

  10.     def f2(self):

  11.         print(“C0.f1()”)

  12.  

  13. class
    C1(C_1):

  14.     def f1(self):

  15.         print(“C1.f1()”)

  16.  

  17. class
    C2(C0):

  18.     def f2(self):

  19.         print(“C2.f1()”)

  20.  

  21. class
    C3(C2,C1):

  22.     pass

  23.  

  24. obj = C3()

  25. obj.f1()

  26. 输出:

  27. C1.f1()

ZipFile.write(filename, arcname, compress_type)
arcname:使用ZipFile.write增加文件时,会把文件本身的路径也加进去,加上arcname就能根据自己的命名规则将文件加入zip包

继承总结

对于继承其方法(属性)可能定义在当前类,也可能来自于基类,所以在方法调用时就需要对当前类和基类进行搜索以确定方法所在的位置。而搜索的顺序就是所谓的方法解析顺序(MRO、Method
Resolution
Order)。对于单继承来说,MRO一般比较简单,而对于多继承来说,MRO比较复杂。下面就二种基本的继承模式解析。

www.hj8828.com 1

www.hj8828.com 2

ZipFile.extractall(path, members, pwd)
path:解压到指定目录
members:只解压压缩包里某个文件
pwd:指定压缩包里的解压密码,zip可以加密压缩

注意:python2.6不支持with xx
as的写法,不管是zipfile 还是 tarfile 模块
z = zipfile.ZipFile(‘/tmp/aa.zip’,’w’,zipfile.ZIP_DEFLATED)
z.write(‘/tmp/aa.py’)
z.close()

python2.6不支持with xx
as的写法github地址:

 

示例
压缩单个文件
如果要对文件进行压缩,zlib模块是必须的,如果zlib可以使用,你可以使用zipfile.ZIP_DEFLATED设置压缩模式为单个文件或者归档一个整体。
默认的压缩模式是zipfile.ZIP_STORED。

import zipfile
import os
with zipfile.ZipFile('/tmp/aa.zip','w',zipfile.ZIP_DEFLATED)  as z:
    z.write('/tmp/aa.py')