就是二个保留了Python代码的文本,对文本有关操作

加载文件a.txt,就是一个保存了Python代码的文件

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(五)模块,python模块

本章内容:

  • 模块介绍
  • time & datetime
  • random
  • os
  • sys
  • json & picle
  • hashlib
  • XML
  • requests
  • ConfigParser
  • logging
  • shutil
  • subprocess
模块介绍

  Python
Module(模块),正是贰个保留了Python代码的文件。模块能定义函数,类和变量。模块里也能包涵可推行的代码。

  文件名就是模块名加上后缀.py,在模块内部,模块名存款和储蓄在全局变量__name__中,是三个string,能够直接在module中经过__name__引用到module
name。

模块分为二种:

  • 自定义模块
  • 内置标准模块(又称标准库)
  • 开源模块

导入模块:

  • import: 使客户端(导入者)以七个完好获取三个模块。
  • from:容许客户端从三个模块文件中获得特定的变量名。
  • reload:在不刹车Python程序的气象下,提供了贰个再次载入模块文件代码的法子。

import module
from module.xx.xx import xx
from module.xx.xx import xx as rename  
from module.xx.xx import *

 模块路线:

#获取路径
import sys
for i in sys.path:
    print(i)
#输出结果:
S:\Myproject
S:\Python 3.5.1\python35.zip
S:\Python 3.5.1\DLLs
S:\Python 3.5.1\lib                  #存放标准库
S:\Python 3.5.1
S:\Python 3.5.1\lib\site-packages    #存放第三方库,扩充库

#添加路径
import sys
import os
pre_path = os.path.abspath('../')
sys.path.append(pre_path)

 开源模块:

#先安装 gcc 编译和 python 开发环境
yum install gcc
yum install python-devel
或
apt-get python-dev

#安装方式(安装成功后,模块会自动安装到 sys.path 中的某个目录中)
yum 
pip
apt-get
...
#进入python环境,导入模块检查是否安装成功

 

time & datetime 模块

时光相关的操作,时间有两种象征方法:

  • 日子戳              一9陆八年八月二二1九日从此的秒,即:time.time()
  • 格式化的字符串     201四-1壹-1壹 1壹:1一,  
     即:time.strftime(‘%Y-%m-%d’)
  • 结构化时间         元组包涵了:年、日、星期等… time.struct_time  
     即:time.localtime()

import time
print(time.time())                  #返回当前系统时间戳(1970年1月1日0时0分0秒开始)
print(time.ctime())                 #输出Tue May 17 16:07:11 2016,当前系统时间
print(time.ctime(time.time() - 86400))        #将时间戳转换为字符串格式
print(time.gmtime(time.time() - 86400))      #将时间戳转换为struct_time格式
print(time.localtime(time.time() - 86400))     #将时间戳转换为struct_time格式,返回本地时间
print(time.mktime(time.localtime()))         #与time.localtime()功能相反,将struct_time格式转回成时间戳格式
#time.sleep(5)                    #sleep停顿
print(time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime()))  #将struct_time格式转成指定的字符串格式
print(time.strptime("2016-05-17","%Y-%m-%d"))   #将字符串格式转换成struct_time格式


print("----------------------------------------------------------------")
import datetime
print(datetime.date.today())             #输出格式 2016-05-17
print(datetime.date.fromtimestamp(time.time() - 86400)) #2016-05-16 将时间戳转成日期格式
current_time = datetime.datetime.now()
print(current_time)                 #输出2016-05-17 16:18:28.737561
print(current_time.timetuple())          #返回struct_time格式
print(current_time.replace(2008,8,8))         #输出2008-08-08 16:21:34.798203,返回当前时间,但指定的值将被替换

str_to_date = datetime.datetime.strptime("28/7/08 11:20","%d/%m/%y %H:%M")  #将字符串转换成日期格式
new_date = datetime.datetime.now() + datetime.timedelta(days=10)         #比现在加10天
new_date = datetime.datetime.now() + datetime.timedelta(days=-10)       #比现在减10天
new_date = datetime.datetime.now() + datetime.timedelta(hours=-10)       #比现在减10小时
new_date = datetime.datetime.now() + datetime.timedelta(seconds=120)      #比现在+120s
print(new_date)

 

random 模块

随机数:

import random

print(random.random())          #用于生成一个0到1的随机符点数: 0 <= n < 1.0
print(random.randint(1,2))      #用于生成一个指定范围内的整数
print(random.randrange(1,10))   #从指定范围内,按指定基数递增的集合中获取一个随机数
print(random.uniform(1,10))     #用于生成一个指定范围内的随机符点数
print(random.choice('nick'))    #从序列中获取一个随机元素
li = ['nick','jenny','car',]
random.shuffle(li)              #用于将一个列表中的元素打乱
print(li)
li_new = random.sample(li,2)    #从指定序列中随机获取指定长度的片断(从li中随机获取2个元素,作为一个片断返回)
print(li_new)

更换随机验证码:

########## 随机验证码 ############
import random
temp = ''
for i in range(4):
    num = random.randrange(0,4)
    if num == 0 or num == 3:        #一半的概率
        rad2 = random.randrange(0,10)
        temp = temp + str(rad2)
    else:
        rad1 = random.randrange(65,91)
        c1 = chr(rad1)
        temp = temp + c1
print(temp)

 

os模块

os模块用于提供系统等级的操作

os.getcwd()                 获取当前工作目录,即当前python脚本工作的目录路径
os.chdir("dirname")         改变当前脚本工作目录;相当于shell下cd
os.curdir                   返回当前目录: ('.')
os.pardir                   获取当前目录的父目录字符串名:('..')
os.makedirs('dir1/dir2')    可生成多层递归目录
os.removedirs('dirname1')   若目录为空,则删除,并递归到上一级目录,如若也为空,则删除,依此类推
os.mkdir('dirname')         生成单级目录;相当于shell中mkdir dirname
os.rmdir('dirname')         删除单级空目录,若目录不为空则无法删除,报错;相当于shell中rmdir dirname
os.listdir('dirname')       列出指定目录下的所有文件和子目录,包括隐藏文件,并以列表方式打印
os.remove()                 删除一个文件
os.rename("oldname","new")  重命名文件/目录
os.stat('path/filename')    获取文件/目录信息
os.sep                      操作系统特定的路径分隔符,win下为"\\",Linux下为"/"
os.linesep                  当前平台使用的行终止符,win下为"\t\n",Linux下为"\n"
os.pathsep                  用于分割文件路径的字符串
os.name                     字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")   运行shell命令,直接显示
os.environ                  获取系统环境变量
os.path.abspath(path)       返回path规范化的绝对路径
os.path.split(path)         将path分割成目录和文件名二元组返回
os.path.dirname(path)       返回path的目录。其实就是os.path.split(path)的第一个元素
os.path.basename(path)      返回path最后的文件名。如何path以/或\结尾,那么就会返回空值。即os.path.split(path)的第二个元素
os.path.exists(path)        如果path存在,返回True;如果path不存在,返回False
os.path.isabs(path)         如果path是绝对路径,返回True
os.path.isfile(path)        如果path是一个存在的文件,返回True。否则返回False
os.path.isdir(path)         如果path是一个存在的目录,则返回True。否则返回False
os.path.join(path1[, path2[, ...]])  将多个路径组合后返回,第一个绝对路径之前的参数将被忽略
os.path.getatime(path)      返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path)      返回path所指向的文件或者目录的最后修改时间

 

sys模块

用来提供对解释器相关的操作

sys.argv           命令行参数List,第一个元素是程序本身路径
sys.exit(n)        退出程序,正常退出时exit(0)
sys.version        获取Python解释程序的版本信息
sys.maxint         最大的Int值
sys.path           返回模块的搜索路径,初始化时使用PYTHONPATH环境变量的值
sys.platform       返回操作系统平台名称
sys.stdin          输入相关
sys.stdout         输出相关
sys.stderror       错误相关

 

图片 1#
手写进程条 import sys,time for ii in range(拾一): sys.stdout.write(‘\r’)
#每三回清空原行。 sys.stdout.write(“%s%%
|%s|”%(int(int(ii)/拾0*100),int(int(ii)/100*100) * ‘#’))
#1共次数除当前次数算进程 sys.stdout.flush() #强制刷新到荧屏time.sleep(0.0伍) 手写进程条

 

json & picle 模块

用于连串化的七个模块

  • json,用于字符串 和 python数据类型间举办改动
  • pickle,用于python特有的类型 和 python的数据类型间进行改动

Json模块提供了八个效益:dumps、dump、loads、load

pickle模块提供了几个职能:dumps、dump、loads、load

  dump()函数接受三个文本句柄和1个数据对象作为参数,把数量对象以特定的格式保存
到给定的文书中。当大家应用load()函数从文件中抽取已保存的靶卯时,pickle知道怎么回复那几个目的到它们本来的格式。

  dumps()函数实行和dump()
函数相同的种类化。代替接受流对象并将系列化后的数目保存到磁盘文件,那个函数轻便的回到体系化的数额。

  loads()函数实施和load()
函数一样的反种类化。代替接受2个流对象并去文件读取体系化后的数码,它接受包蕴类别化后的数额的str对象,
直接回到的靶子。

图片 2

##### json.loads 将字符串转换为python基本数据类型 列表字典 #####
import json
l = '["nick","jenny","car"]'
print(l,type(l))
l = json.loads(l)
print(l,type(l))

l = '{"k1":"nick","k2:":"jenny"}'
print(l,type(l))
l = json.loads(l)
print(l,type(l))

##### json.dumps 将python的数据类型列表字典转换为字符串 ######
import json
l = ["nick","jenny","car"]
print(l,type(l))
l = json.dumps(l)
print(l,type(l))

l = {"k1":"nick","k2:":"jenny"}
print(l,type(l))
l = json.dumps(l)
print(l,type(l))

##### json dump、load 文件相关 #####
import json
l = {"k1":"nick","k2:":"jenny"}
json.dump(l,open('db','w'))

ret = json.load(open('db'))
print(ret)

 

hashlib 模块

  用于加密相关的操作,替代了md5模块和sha模块,首要提供md五(), sha一(),
sha22肆(), sha25陆(), sha3八四(), and sha51二()算法

import hashlib

# ######## md5 ########
hash = hashlib.md5()
# help(hash.update)
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())
print(hash.digest())


######## sha1 ########

hash = hashlib.sha1()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())

# ######## sha256 ########

hash = hashlib.sha256()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())


# ######## sha384 ########

hash = hashlib.sha384()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())

# ######## sha512 ########

hash = hashlib.sha512()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())


##### 加盐 ######
# ######## md5 ########

hash = hashlib.md5(bytes('898oaFs09f',encoding="utf-8"))
hash.update(bytes('admin',encoding="utf-8"))
print(hash.hexdigest())

#python内置还有一个 hmac 模块,它内部对我们创建 key 和 内容 进行进一步的处理然后再加密

import hmac

h = hmac.new(bytes('898oaFs09f',encoding="utf-8"))
h.update(bytes('admin',encoding="utf-8"))
print(h.hexdigest())

 

XML 模块

   XML是贯彻差异语言或程序之间张开数据交流的情商,XML文件格式如下:

<data>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <year>2023</year>
        <gdppc>141100</gdppc>
        <neighbor direction="E" name="Austria" />
        <neighbor direction="W" name="Switzerland" />
    </country>
    <country name="Singapore">
        <rank updated="yes">5</rank>
        <year>2026</year>
        <gdppc>59900</gdppc>
        <neighbor direction="N" name="Malaysia" />
    </country>
    <country name="Panama">
        <rank updated="yes">69</rank>
        <year>2026</year>
        <gdppc>13600</gdppc>
        <neighbor direction="W" name="Costa Rica" />
        <neighbor direction="E" name="Colombia" />
    </country>
</data>

1、解析XML

图片 3from
xml.etree import ElementTree as ET # 展开文件,读取XML内容 str_xml =
open(‘xo.xml’, ‘r’).read() #
将字符串解析成xml特殊对象,root代指xml文件的根节点 root =
ET.XML(str_xml) 利用ElementTree.XML将字符串解析成xml对象
图片 4from
xml.etree import ElementTree as ET # 直接解析xml文件 tree =
ET.parse(“xo.xml”) # 获取xml文件的根节点 root = tree.getroot() 利用ElementTree.parse将文件一贯解析成xml对象

2、操作XML

 XML格式类型是节点嵌套节点,对于每二个节点均有以下职能,以便对当前节点开始展览操作:

图片 5class
Element: “””An XML element. This class is the reference implementation
of the Element interface. An element’s length is its number of
subelements. That means if you want to check if an element is truly
empty, you should check BOTH its length AND its text attribute. The
element tag, attribute names, and attribute values can be either bytes
or strings. *tag* is the element name. *attrib* is an optional
dictionary containing element attributes. *extra* are additional
element attributes given as keyword arguments. Example form: <tag
attrib>text<child/>…</tag>tail “”” 当前节点的竹具名 tag
= None “””The element’s name.””” 当前节点的属性 attrib = None
“””Dictionary of the element’s attributes.””” 当前节点的剧情 text = None
“”” Text before first subelement. This is either a string or the value
None. Note that if there is no text, this attribute may be either None
or the empty string, depending on the parser. “”” tail = None “”” Text
after this element’s end tag, but before the next sibling element’s
start tag. This is either a string or the value None. Note that if there
was no text, this attribute may be either None or an empty string,
depending on the parser. “”” def __init__(self, tag, attrib={},
**extra): if not isinstance(attrib, dict): raise TypeError(“attrib
must be dict, not %s” % ( attrib.__class__.__name__,)) attrib =
attrib.copy() attrib.update(extra) self.tag = tag self.attrib = attrib
self._children = [] def __repr__(self): return “<%s %r at
%#x>” % (self.__class__.__name__, self.tag, id(self)) def
makeelement(self, tag, attrib): 成立一个新节点 “””Create a new element
with the same type. *tag* is a string containing the element name.
*attrib* is a dictionary containing the element attributes. Do not
call this method, use the SubElement factory function instead. “””
return self.__class__(tag, attrib) def copy(self): “””Return copy of
current element. This creates a shallow copy. Subelements will be shared
with the original tree. “”” elem = self.makeelement(self.tag,
self.attrib) elem.text = self.text elem.tail = self.tail elem[:] =
self return elem def __len__(self): return len(self._children) def
__bool__(self): warnings.warn( “The behavior of this method will
change in future versions. ” “Use specific ‘len(elem)’ or ‘elem is not
None’ test instead.”, FutureWarning, stacklevel=2 ) return
len(self._children) != 0 # emulate old behaviour, for now def
__getitem__(self, index): return self._children[index] def
__setitem__(self, index, element): # if isinstance(index, slice):
# for elt in element: # assert iselement(elt) # else: # assert
iselement(element) self._children[index] = element def
__delitem__(self, index): del self._children[index] def
append(self, subelement): 为当前节点追加1个子节点 “””Add *subelement*
to the end of this element. The new element will appear in document
order after the last existing subelement (or directly after the text, if
it’s the first subelement), but before the end tag for this element. “””
self._assert_is_element(subelement)
self._children.append(subelement) def extend(self, elements):
为当前节点扩展 n 个子节点 “””Append subelements from a sequence.
*elements* is a sequence with zero or more elements. “”” for element
in elements: self._assert_is_element(element)
self._children.extend(elements) def insert(self, index, subelement):
在日前节点的子节点中插入有些节点,即:为当前节点创立子节点,然后插入钦赐地方”””Insert *subelement* at position *index*.”””
self._assert_is_element(subelement) self._children.insert(index,
subelement) def _assert_is_element(self, e): # Need to refer to the
actual Python implementation, not the # shadowing C implementation. if
not isinstance(e, _Element_Py): raise TypeError(‘expected an Element,
not %s’ % type(e).__name__) def remove(self, subelement):
在眼下节点在子节点中剔除有些节点 “””Remove matching subelement. Unlike
the find methods, this method compares elements based on identity, NOT
ON tag value or contents. To remove subelements by other means, the
easiest way is to use a list comprehension to select what elements to
keep, and then use slice assignment to update the parent element.
ValueError is raised if a matching element could not be found. “”” #
assert iselement(element) self._children.remove(subelement) def
getchildren(self): 获取具备的子节点(甩掉) “””(Deprecated) Return all
subelements. Elements are returned in document order. “”” warnings.warn(
“This method will be removed in future versions. ” “Use ‘list(elem)’ or
iteration over elem instead.”, DeprecationWarning, stacklevel=二 ) return
self._children def find(self, path, namespaces=None):
获取第一个搜索到的子节点 “””Find first matching element by tag name or
path. *path* is a string having either an element tag or an XPath,
*namespaces* is an optional mapping from namespace prefix to full
name. Return the first matching element, or None if no element was
found. “”” return ElementPath.find(self, path, namespaces) def
findtext(self, path, default=None, namespaces=None):
获取第一个搜索到的子节点的始末 “””Find text for first matching element
by tag name or path. *path* is a string having either an element tag
or an XPath, *default* is the value to return if the element was not
found, *namespaces* is an optional mapping from namespace prefix to
full name. Return text content of first matching element, or default
value if none was found. Note that if an element is found having no text
content, the empty string is returned. “”” return
ElementPath.findtext(self, path, default, namespaces) def findall(self,
path, namespaces=None): 获取具备的子节点 “””Find all matching
subelements by tag name or path. *path* is a string having either an
element tag or an XPath, *namespaces* is an optional mapping from
namespace prefix to full name. Returns list containing all matching
elements in document order. “”” return ElementPath.findall(self, path,
namespaces) def iterfind(self, path, namespaces=None):
获取具备钦赐的节点,并创办三个迭代器(能够被for循环) “””Find all
matching subelements by tag name or path. *path* is a string having
either an element tag or an XPath, *namespaces* is an optional mapping
from namespace prefix to full name. Return an iterable yielding all
matching elements in document order. “”” return
ElementPath.iterfind(self, path, namespaces) def clear(self): 清空节点
“””Reset element. This function removes all subelements, clears all
attributes, and sets the text and tail attributes to None. “””
self.attrib.clear() self._children = [] self.text = self.tail = None
def get(self, key, default=None): 获取当前节点的质量值 “””Get element
attribute. Equivalent to attrib.get, but some implementations may handle
this a bit more efficiently. *key* is what attribute to look for, and
*default* is what to return if the attribute was not found. Returns a
string containing the attribute value, or the default if attribute was
not found. “”” return self.attrib.get(key, default) def set(self, key,
value): 为当前节点设置属性值 “””Set element attribute. Equivalent to
attrib[key] = value, but some implementations may handle this a bit
more efficiently. *key* is what attribute to set, and *value* is the
attribute value to set it to. “”” self.attrib[key] = value def
keys(self): 获取当前节点的享有属性的 key “””Get list of attribute names.
Names are returned in an arbitrary order, just like an ordinary Python
dict. Equivalent to attrib.keys() “”” return self.attrib.keys() def
items(self): 获取当前节点的具备属性值,每种属性都以贰个键值对 “””Get
element attributes as a sequence. The attributes are returned in
arbitrary order. Equivalent to attrib.items(). Return a list of (name,
value) tuples. “”” return self.attrib.items() def iter(self, tag=None):
在脚下节点的后生中依据节点名称搜索具备钦点的节点,并赶回二个迭代器(能够被for循环)。
“””Create tree iterator. The iterator loops over the element and all
subelements in document order, returning all elements with a matching
tag. If the tree structure is modified during iteration, new or removed
elements may or may not be included. To get a stable set, use the list()
function on the iterator, and loop over the resulting list. *tag* is
what tags to look for (default is to return all elements) Return an
iterator containing all the matching elements. “”” if tag == “*”: tag =
None if tag is None or self.tag == tag: yield self for e in
self._children: yield from e.iter(tag) # compatibility def
getiterator(self, tag=None): # Change for a DeprecationWarning in 1.四warnings.warn( “This method will be removed in future versions. ” “Use
‘elem.iter()’ or ‘list(elem.iter())’ instead.”,
PendingDeprecationWarning, stacklevel=2 ) return list(self.iter(tag))
def itertext(self):
在脚下节点的后裔中依照节点名称寻觅具备钦命的节点的始末,并回到二个迭代器(能够被for循环)。
“””Create text iterator. The iterator loops over the element and all
subelements in document order, returning all inner text. “”” tag =
self.tag if not isinstance(tag, str) and tag is not None: return if
self.text: yield self.text for e in self: yield from e.itertext() if
e.tail: yield e.tail 源码

由于 每个节点 都具有以上的方法,并且在上一步骤中解析时均得到了root(xml文件的根节点),so   可以利用以上方法进行操作xml文件。

a. 遍历XML文档的所有内容

from xml.etree import ElementTree as ET ############ 解析方式一 ############ """ # 打开文件,读取XML内容 str_xml = open(‘xo.xml’, ‘r’).read() # 将字符串解析成xml特殊对象,root代指xml文件的根节点 root = ET.XML(str_xml) """ ############ 解析方式二 ############ # 直接解析xml文件 tree = ET.parse("xo.xml") # 获取xml文件的根节点 root = tree.getroot() ### 操作 # 顶层标签 print(root.tag) # 遍历XML文档的第二层 for child in root: # 第二层节点的标签名称和标签属性 print(child.tag, child.attrib) # 遍历XML文档的第三层 for i in child: # 第二层节点的标签名称和内容 print(i.tag,i.text) View Code

b、遍历XML中指定的节点

from xml.etree import ElementTree as ET ############ 解析方式一 ############ """ # 打开文件,读取XML内容 str_xml = open(‘xo.xml’, ‘r’).read() # 将字符串解析成xml特殊对象,root代指xml文件的根节点 root = ET.XML(str_xml) """ ############ 解析方式二 ############ # 直接解析xml文件 tree = ET.parse("xo.xml") # 获取xml文件的根节点 root = tree.getroot() ### 操作 # 顶层标签 print(root.tag) # 遍历XML中所有的year节点 for node in root.iter(‘year’): # 节点的标签名称和内容 print(node.tag, node.text) View Code

c、修改节点内容

由于修改的节点时,均是在内存中进行,其不会影响文件中的内容。所以,如果想要修改,则需要重新将内存中的内容写到文件。

from xml.etree import ElementTree as ET ############ 解析方式一 ############ # 打开文件,读取XML内容 str_xml = open(‘xo.xml’, ‘r’).read() # 将字符串解析成xml特殊对象,root代指xml文件的根节点 root = ET.XML(str_xml) ############ 操作 ############ # 顶层标签 print(root.tag) # 循环所有的year节点 for node in root.iter(‘year’): # 将year节点中的内容自增一 new_year = int(node.text) + 1 node.text = str(new_year) # 设置属性 node.set(‘name’, ‘alex’) node.set(‘age’, ’18’) # 删除属性 del node.attrib[‘name’] ############ 保存文件 ############ tree = ET.ElementTree(root) tree.write("newnew.xml", encoding=’utf-8′) 解析字符串方式,修改,保存 from xml.etree import ElementTree as ET ############ 解析方式二 ############ # 直接解析xml文件 tree = ET.parse("xo.xml") # 获取xml文件的根节点 root = tree.getroot() ############ 操作 ############ # 顶层标签 print(root.tag) # 循环所有的year节点 for node in root.iter(‘year’): # 将year节点中的内容自增一 new_year = int(node.text) + 1 node.text = str(new_year) # 设置属性 node.set(‘name’, ‘alex’) node.set(‘age’, ’18’) # 删除属性 del node.attrib[‘name’] ############ 保存文件 ############ tree.write("newnew.xml", encoding=’utf-8′) 解析文件方式,修改,保存

d、删除节点

from xml.etree import ElementTree as ET ############ 解析字符串方式打开 ############ # 打开文件,读取XML内容 str_xml = open(‘xo.xml’, ‘r’).read() # 将字符串解析成xml特殊对象,root代指xml文件的根节点 root = ET.XML(str_xml) ############ 操作 ############ # 顶层标签 print(root.tag) # 遍历data下的所有country节点 for country in root.findall(‘country’): # 获取每一个country节点下rank节点的内容 rank = int(country.find(‘rank’).text) if rank > 50: # 删除指定country节点 root.remove(country) ############ 保存文件 ############ tree = ET.ElementTree(root) tree.write("newnew.xml", encoding=’utf-8′) 解析字符串方式打开,删除,保存 from xml.etree import ElementTree as ET ############ 解析文件方式 ############ # 直接解析xml文件 tree = ET.parse("xo.xml") # 获取xml文件的根节点 root = tree.getroot() ############ 操作 ############ # 顶层标签 print(root.tag) # 遍历data下的所有country节点 for country in root.findall(‘country’): # 获取每一个country节点下rank节点的内容 rank = int(country.find(‘rank’).text) if rank > 50: # 删除指定country节点 root.remove(country) ############ 保存文件 ############ tree.write("newnew.xml", encoding=’utf-8′) 解析文件方式打开,删除,保存

3、创建XML文档

图片 6from
xml.etree import ElementTree as ET # 创制根节点 root =
ET.Element(“famliy”) # 创制节点小外孙子 son一 = ET.Element(‘son’, {‘name’:
‘儿一’}) # 创制小外甥 son② = ET.Element(‘son’, {“name”: ‘儿贰’}) #
在大外甥中创造五个儿子 grandson壹 = ET.Element(‘grandson’, {‘name’:
‘儿1一’}) grandson二 = ET.Element(‘grandson’, {‘name’: ‘儿1②’})
son一.append(grandson一) son壹.append(grandson二) # 把幼子增加到根节点中
root.append(son一) root.append(son1) tree = ET.ElementTree(root)
tree.write(‘oooo.xml’,encoding=’utf-8′, short_empty_elements=False)
成立情势(壹)
图片 7from
xml.etree import ElementTree as ET # 创立根节点 root =
ET.Element(“famliy”) # 创立小外孙子 # son1 = ET.Element(‘son’, {‘name’:
‘儿1’}) son1 = root.makeelement(‘son’, {‘name’: ‘儿1’}) # 创立三儿子 #
son2 = ET.Element(‘son’, {“name”: ‘儿2’}) son2 = root.makeelement(‘son’,
{“name”: ‘儿2’}) # 在大外甥中开创七个外孙子 # grandson1 =
ET.Element(‘grandson’, {‘name’: ‘儿11’}) grandson1 =
son1.makeelement(‘grandson’, {‘name’: ‘儿11’}) # grandson2 =
ET.Element(‘grandson’, {‘name’: ‘儿12’}) grandson2 =
son1.makeelement(‘grandson’, {‘name’: ‘儿12’}) son1.append(grandson1)
son1.append(grandson2) # 把幼子增加到根节点中 root.append(son一)
root.append(son一) tree = ET.ElementTree(root)
tree.write(‘oooo.xml’,encoding=’utf-8′, short_empty_elements=False)
创建方式(二)
图片 8from
xml.etree import ElementTree as ET # 创建根节点 root =
ET.Element(“famliy”) # 成立节点大孙子 son一 = ET.SubElement(root, “son”,
attrib={‘name’: ‘儿一’}) # 创制大外甥 son贰 = ET.SubElement(root, “son”,
attrib={“name”: “儿2”}) # 在小外甥中开创叁个外甥 grandson一 =
ET.SubElement(son壹, “age”, attrib={‘name’: ‘儿11’}) grandson一.text =
‘孙子’ et = ET.ElementTree(root) #转换文书档案对象 et.write(“test.xml”,
encoding=”utf-八”, xml_declaration=True, short_empty_elements=False)
创制格局(叁)

出于原生保存的XML时默认无缩进,若是想要设置缩进的话, 须要修改保存方法:

图片 9from
xml.etree import ElementTree as ET from xml.dom import minidom def
prettify(elem): “””将节点调换到字符串,并累加缩进。 “”” rough_string =
ET.tostring(elem, ‘utf-8’) reparsed = minidom.parseString(rough_string)
return reparsed.toprettyxml(indent=”\t”) # 成立根节点 root =
ET.Element(“famliy”) # 创制大外孙子 # son1 = ET.Element(‘son’, {‘name’:
‘儿1’}) son1 = root.makeelement(‘son’, {‘name’: ‘儿1’}) # 创设大外孙子 #
son2 = ET.Element(‘son’, {“name”: ‘儿2’}) son2 = root.makeelement(‘son’,
{“name”: ‘儿2’}) # 在小儿子中开创八个外甥 # grandson1 =
ET.Element(‘grandson’, {‘name’: ‘儿11’}) grandson1 =
son1.makeelement(‘grandson’, {‘name’: ‘儿11’}) # grandson2 =
ET.Element(‘grandson’, {‘name’: ‘儿12’}) grandson2 =
son1.makeelement(‘grandson’, {‘name’: ‘儿12′}) son1.append(grandson1)
son1.append(grandson2) # 把幼子加多到根节点中 root.append(son1)
root.append(son一) raw_str = prettify(root) f =
open(“xxxoo.xml”,’w’,encoding=’utf-8′) f.write(raw_str) f.close() 写入缩进

四、命名空间

图片 10from
xml.etree import ElementTree as ET
ET.register_namespace(‘com’,”http://www.company.com“) #some name #
build a tree structure root =
ET.Element(“{http://www.company.com}STUFF“) body = ET.SubElement(root,
“{http://www.company.com}MORE\_STUFF“,
attrib={“{http://www.company.com}hhh“: “123”}) body.text = “STUFF
EVERYWHERE!” # wrap it in an ElementTree instance, and save as XML tree
= ET.ElementTree(root) tree.write(“page.xml”, xml_declaration=True,
encoding=’utf-8′, method=”xml”) 命名空间

 

requests 模块

  Python标准库中提供了:urllib等模块以供Http请求,不过,它的 API
太渣了。它是为另3个一代、另一个互连网所开创的。它供给大批量的办事,甚至席卷各类艺术覆盖,来成功最简便易行的职分。

图片 11import
urllib.request
f=urllib.request.urlopen(‘http://www.webxml.com.cn//webservices/qqOnlineWebService.asmx/qqCheckOnline?qqCode=424662508‘)
result = f.read().decode(‘utf-8’) 发送GET请求
图片 12import
urllib.request req = urllib.request.Request(‘http://www.example.com/‘)
req.add_header(‘Referer’, ‘http://www.python.org/‘) r =
urllib.request.urlopen(req) result = f.read().decode(‘utf-8’) 发送教导请求头的GET请求

*  注:愈多见Python官方文书档案:https://docs.python.org/3.5/library/urllib.request.html\#module-urllib.request*

  Requests 是运用 Apache2 Licensed 许可证的 基于Python开荒的HTTP
库,其在Python内置模块的基本功上拓展了中度的包裹,从而使得Pythoner举行互联网请求时,变得美好了许多,使用Requests能够一蹴即至的姣好浏览器可有个别任何操作。

1、安装模块

pip3 install requests

2、使用模块

图片 13#
1、无参数实例 import requests ret =
requests.get(‘https://github.com/timeline.json‘) print(ret.url)
print(ret.text) # 二、有参数实例 import requests payload = {‘key一’:
‘value1’, ‘key二’: ‘value二’} ret = requests.get(“http://httpbin.org/get“,
params=payload) print(ret.url) print(ret.text) GET请求
图片 14#
1、基本POST实例 import requests payload = {‘key1’: ‘value1’, ‘key2’:
‘value2’} ret = requests.post(“http://httpbin.org/post“, data=payload)
print(ret.text) # 二、发送请求头和数码实例 import requests import json
url = ‘https://api.github.com/some/endpoint‘ payload = {‘some’: ‘data’}
headers = {‘content-type’: ‘application/json’} ret = requests.post(url,
data=json.dumps(payload), headers=headers) print(ret.text)
print(ret.cookies) POST请求
图片 15requests.get(url,
params=None, **kwargs) requests.post(url, data=None, json=None,
**kwargs) requests.put(url, data=None, **kwargs) requests.head(url,
**kwargs) requests.delete(url, **kwargs) requests.patch(url,
data=None, **kwargs) requests.options(url, **kwargs) #
以上措施均是在此方法的基本功上营造 requests.request(method, url,
**kwargs) 其余请求

更加多requests模块相关的文书档案见:http://cn.python-requests.org/zh\_CN/latest/

3、Http请求和XML实例

实例:检验QQ账号是或不是在线

图片 16import
urllib import requests from xml.etree import ElementTree as ET #
使用内置模块urllib发送HTTP请求,可能XML格式内容 “”” f =
urllib.request.urlopen(‘http://www.webxml.com.cn//webservices/qqOnlineWebService.asmx/qqCheckOnline?qqCode=630571017‘)
result = f.read().decode(‘utf-8’) “”” #
使用第3方模块requests发送HTTP请求,恐怕XML格式内容 r =
requests.get(‘http://www.webxml.com.cn//webservices/qqOnlineWebService.asmx/qqCheckOnline?qqCode=424662508‘)
result = r.text # 解析XML格式内容 node = ET.XML(result) # 获取内容 if
node.text == “Y”: print(“在线”) else: print(“离线”) 检验QQ账号是不是在线

实例:查看高铁停靠信息

图片 17import
urllib import requests from xml.etree import ElementTree as ET #
使用内置模块urllib发送HTTP请求,只怕XML格式内容 “”” f =
urllib.request.urlopen(‘http://www.webxml.com.cn/WebServices/TrainTimeWebService.asmx/getDetailInfoByTrainCode?TrainCode=G666&UserID=‘)
result = f.read().decode(‘utf-8’) “”” #
使用第二方模块requests发送HTTP请求,只怕XML格式内容 r =
requests.get(‘http://www.webxml.com.cn/WebServices/TrainTimeWebService.asmx/getDetailInfoByTrainCode?TrainCode=G666&UserID=‘)
result = r.text # 解析XML格式内容 root = ET.XML(result) for node in
root.iter(‘TrainDetailInfo’):
print(node.find(‘TrainStation’).text,node.find(‘StartTime’).text,node.tag,node.attrib)
查看高铁停靠音信

实例:查看天气新闻

图片 18import
requests response =
requests.get(“http://www.weather.com.cn/data/sk/101010100.html“)
response.encoding = “utf-八” result = response.text print(result) 查看天气新闻

 

configparser 模块

  configparser用于拍卖特定格式的文件,其本质上是选取open来操作文件。

#指定格式

#注释
;注释2

[nick]           #节点
age = 18         #值
gender = ning    #值
dearm = girl     #值

[jenny]          #节点
age = 21         #值 
gender = jia     #值

一、获取具备节点

import configparser

con = configparser.ConfigParser()
con.read("ini",encoding="utf-8")

result = con.sections()
print(result)

二、获取钦命节点下全部的键值对

import configparser

con = configparser.ConfigParser()
con.read("ini",encoding="utf-8")

result = con.items("nick")
print(result)

3、获取钦命节点下有所的键

import configparser

con = configparser.ConfigParser()
con.read("ini",encoding="utf-8")

ret = con.options("nick")
print(ret)

四、获取内定节点下钦命key的值

import configparser

con = configparser.ConfigParser()
con.read("ini",encoding="utf-8")

v = con.get("nick","age")
v = con.get("nick","gender")
v = con.get("jenny","age")
v = con.get("jenny","gender")
print(v)

伍、检查、删除、增添节点

#检查、删除、添加节点
import configparser

con = configparser.ConfigParser()
con.read("ini",encoding="utf-8")

#检查
has_sec = con.has_section("nick")
print(has_sec)

#添加节点
con.add_section("car")
con.write(open("ini","w"))

#删除节点
con.remove_section("car")
con.write(open("ini","w"))

6、检查、删除、设置内定组内的键值对

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

con = configparser.ConfigParser()
con.read("ini",encoding="utf-8")

#检查
hac_opt = con.has_option("nick","age")
print(hac_opt)

#删除
con.remove_option("nick","dearm")
con.write(open("ini","w"))

#设置
con.set("nick","dearm","girl")
con.write(open("ini","w"))

 

logging 模块

  用于便捷记录日志且线程安全的模块

一、单日志文件

import logging

logging.basicConfig(filename="log.log",
                    format="%(asctime)s - %(name)s - %(levelname)s - %(module)s: %(message)s",
                    datefmt="%Y-%m-%d %H:%M:%S %p",
                    level=logging.INFO)

logging.critical("critical")
logging.fatal("fatal")
logging.error("error")
logging.warn("warn")
logging.warning("warning")
logging.info("info")
logging.debug("debug")
logging.log(8,"log")

日记等第

"""
CRITICAL = 50
FATAL = CRITICAL
ERROR = 40
WARNING = 30
WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0
"""

 

 

 

 

 

 

 

 

注:唯有【当前写等第】大于【日志等第】时,日志文件才被记录。

图片 19

二、多文本日志

对此上述记录日志的效应,只好将日志记录在单文件中,假使想要设置五个日志文件,logging.basicConfig将无法产生,需求自定义文件和日志操作对象。

图片 20#
定义文件 file_1_1 = logging.FileHandler(‘l1_1.log’, ‘a’) fmt =
logging.Formatter(fmt=”%(asctime)s – %(name)s – %(levelname)s
-%(module)s: %(message)s”) file_1_1.setFormatter(fmt) file_1_2 =
logging.FileHandler(‘l1_2.log’, ‘a’) fmt = logging.Formatter()
file_1_2.setFormatter(fmt) # 定义日志 logger壹 = logging.Logger(‘s一’,
level=logging.E奇骏ROMurano) logger一.addHandler(file_1_1)
logger1.addHandler(file_1_2) # 写日志 logger1.critical(‘1111’) 日志(一)
图片 21#
定义文件 file_2_1 = logging.FileHandler(‘l2_1.log’, ‘a’) fmt =
logging.Formatter() file_2_1.setFormatter(fmt) # 定义日志 logger二 =
logging.Logger(‘s二’, level=logging.INFO) logger二.addHandler(file_2_1)
日志(二)

如上述创制的四个日志对象

  • 当使用【logger1】写日记时,会将相应的始末写入 l一_1.log 和 l1_2.log
    文件中
  • 当使用【logger二】写日记时,会将相应的内容写入 l二_1.log 文件中

 

shutil 模块

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

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

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

import shutil

shutil.copyfileobj(open('old.xml','r'), open('new.xml', 'w'))

shutil.copyfile(src, dst)

拷贝文件

shutil.copyfile('f1.log', 'f2.log')

shutil.copymode(src, dst)

仅拷贝权限。内容、组、用户均不改变

shutil.copymode('f1.log', 'f2.log')

shutil.copystat(src, dst)

拷贝状态的音信,包括:mode bits, atime, mtime, flags

shutil.copystat('f1.log', 'f2.log')

shutil.copy(src, dst)

拷贝文件和权力

import shutil

shutil.copy('f1.log', 'f2.log')

shutil.copy2(src, dst)

拷贝文件和状态新闻

import shutil

shutil.copy2('f1.log', 'f2.log')

shutil.ignore_patterns(*patterns)
shutil.copytree(src, dst, symlinks=False, ignore=None)

递归的去拷贝文件夹

import shutil

shutil.copytree('folder1', 'folder2', ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))

shutil.rmtree(path[, ignore_errors[, onerror]])

递归的去删除文件

import shutil

shutil.rmtree('folder1')

shutil.move(src, dst)

递归的去运动文件,它好像mv命令,其实便是重命名。

import shutil

shutil.move('folder1', 'folder3')

shutil.make_archive(base_name, format,…)

创制压缩包并再次回到文件路线,例如:zip、tar

创立压缩包并赶回文件路线,例如:zip、tar

  • base_name:
    压缩包的公文名,也足以是压缩包的路径。只是文件名时,则保留至当前目录,不然保存至钦点路径,
  • 如:www                        =>保存至最近路径
  • 如:/Users/wupeiqi/www =>保存至/Users/wupeiqi/
  • format: 压缩包连串,“zip”, “tar”, “bztar”,“gztar”
  • root_dir: 要减弱的文书夹路线(暗中同意当前目录)
  • owner: 用户,暗许当前用户
  • group: 组,默许当前组
  • logger: 用于记录日志,日常是logging.Logger对象

#将 /Users/wupeiqi/Downloads/test 下的文件打包放置当前程序目录
import shutil
ret = shutil.make_archive("wwwwwwwwww", 'gztar', root_dir='/Users/wupeiqi/Downloads/test')


#将 /Users/wupeiqi/Downloads/test 下的文件打包放置 /Users/wupeiqi/目录
import shutil
ret = shutil.make_archive("/Users/wupeiqi/wwwwwwwwww", 'gztar', root_dir='/Users/wupeiqi/Downloads/test')

shutil 对压缩包的处理是调用 ZipFile 和 TarFile 五个模块来展开的,详细:

图片 22import
zipfile z = zipfile.ZipFile(“ini.zip”,”w”) z.write(“ini”) z.write(“pip”)
z.close() #压缩包里增添内容(展开形式变为a) #z =
zipfile.ZipFile(“ini.zip”,”a”) #z.write(“db”) z.close() #解压 z =
zipfile.ZipFile(“ini.zip”,”r”) z.extractall() #解压全体 #
z.extract(“pip”) #解压钦赐文件 z.close() zipfile解压缩
图片 23import
tarfile #压缩 tar = tarfile.open(“ini.zip”,”w”)
tar.add(“S:\stud\ini”,arcname=”iiini.txt”) #路径、重命名
tar.add(“./pip”,arcname=”pip.log”) tar.close() #解压 tar =
tarfile.open(“ini.zip”,”r”) tar.extractall() #可安装解压地址
tar.close() tarfile解压缩

 

subprocess

可以试行shell命令的连锁模块和函数有:

  • os.system
  • os.spawn*
  • os.popen*          –废弃
  • popen2.*           –废弃
  • commands.*      –扬弃,三.x中被移除

图片 24import
commands result = commands.getoutput(‘cmd’) result =
commands.getstatus(‘cmd’) result = commands.getstatusoutput(‘cmd’) commands

上述施行shell命令的相关的模块和函数的机能均在 subprocess
模块中贯彻,并提供了更拉长的作用。

call

实践命令,重回状态码

ret = subprocess.call(["ls", "-l"], shell=False)
ret = subprocess.call("ls -l", shell=True)

check_call

施行命令,假若实施状态码是 0 ,则重临0,否则抛分外

subprocess.check_call(["ls", "-l"])
subprocess.check_call("exit 1", shell=True)

check_output

推行命令,借使状态码是 0 ,则赶回推行结果,否则抛极度

subprocess.check_output(["echo", "Hello World!"])
subprocess.check_output("exit 1", shell=True)

subprocess.Popen(…)

用于试行复杂的系统命令

参数:

  • 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()函数,用于设置子进度的片段性质,如:主窗口的外观,进度的优先级等等 

图片 25import
subprocess ret1 = subprocess.Popen([“mkdir”,”t1″]) ret贰 =
subprocess.Popen(“mkdir t贰”, shell=True) 推行日常命令

极端输入的命令分为两种:

  • 输入就可以得到输出,如:ifconfig
  • 输入举办某环境,正视再输入,如:python

图片 26import
subprocess obj = subprocess.Popen(“mkdir t3”, shell=True,
cwd=’/home/dev’,) View Code
图片 27import
subprocess obj = subprocess.Popen([“python”], stdin=subprocess.PIPE,
stdout=subprocess.PIPE, stderr=subprocess.PIPE,
universal_newlines=True) obj.stdin.write(“print(1)\n”)
obj.stdin.write(“print(2)”) obj.stdin.close() cmd_out =
obj.stdout.read() obj.stdout.close() cmd_error = obj.stderr.read()
obj.stderr.close() print(cmd_out) print(cmd_error) View Code
图片 28import
subprocess obj = subprocess.Popen([“python”], stdin=subprocess.PIPE,
stdout=subprocess.PIPE, stderr=subprocess.PIPE,
universal_newlines=True) obj.stdin.write(“print(1)\n”)
obj.stdin.write(“print(2)”) out_error_list = obj.communicate()
print(out_error_list) View
Code
图片 29import
subprocess obj = subprocess.Popen([“python”], stdin=subprocess.PIPE,
stdout=subprocess.PIPE, stderr=subprocess.PIPE,
universal_newlines=True) out_error_list =
obj.communicate(‘print(“hello”)’) print(out_error_list) View Code

 

http://www.bkjia.com/Pythonjc/1130132.htmlwww.bkjia.comtruehttp://www.bkjia.com/Pythonjc/1130132.htmlTechArticlePython(五)模块,python模块 本章内容: 模块介绍
time datetime random os sys json picle hashlib XML requests ConfigParser
logging shutil subprocess 模块介绍 Py…

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. #在外孙子中开创二个儿子

  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>

shutil

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

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

将文件内容拷贝到另3个文书中

  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’)

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()

系统命令

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)

check_call

施行命令,假如实行情形码是0,则重回0,否则抛出非常。

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

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. #壹、创造对象,类名()

  6. obj = Foo()

  7. #二、通过对象去实践格局

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

类和目的

1、创建类:

class 类名:

def 方法名(self,xxx):

pass

二、创造对象

对象 = 类名()

三、通过对象进行措施

对象.方法名(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

如哪一天候利用面向对象?

当某个函数具备一样参数时,可以使用面向对象的点子,将参数值贰回性打包到目的中,方便以往去对象中取值。

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

构造方法

类中有三个区别日常的法子__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

面向对象3大特点:封装、继承、多态。

封装

面向对象的次第设计中,有些类把所要求的数量(类的习性)和对数据的操作(类的表现)全体都封装在类中,分别名为类的分子变量和形式(成员函数)。那种把成员变量和成员函数封装在共同的编制程序性格称为封装。

  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__艺术的参数。

单继承

  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()

多继承

  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()

延续总括

对此后续其艺术(属性)也许定义在最近类,也说不定出自于基类,所以在艺术调用时就要求对脚下类和基类进行查找以分明方法所在的义务。而追寻的相继便是所谓的主意分析顺序(MRO、Method
Resolution
Order)。对于单承继来讲,MRO一般相比轻松,而对此多接二连三来讲,MRO相比较复杂。上边就二种为主的后续形式解析。

图片 30

图片 31