# =================================匹配模式=================================
#一對一的匹配
# ‘hello‘.replace(old,new)
# ‘hello‘.find(‘pattern‘)

#正則匹配
import re
#\w與\W
print(re.findall(‘\w‘,‘hello egon 123‘)) #[‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘, ‘e‘, ‘g‘, ‘o‘, ‘n‘, ‘1‘, ‘2‘, ‘3‘]
print(re.findall(‘\W‘,‘hello egon 123‘)) #[‘ ‘, ‘ ‘]

#\s與\S
print(re.findall(‘\s‘,‘hello  egon  123‘)) #[‘ ‘, ‘ ‘, ‘ ‘, ‘ ‘]
print(re.findall(‘\S‘,‘hello  egon  123‘)) #[‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘, ‘e‘, ‘g‘, ‘o‘, ‘n‘, ‘1‘, ‘2‘, ‘3‘]

#\n \t都是空,都可以被\s匹配
print(re.findall(‘\s‘,‘hello \n egon \t 123‘)) #[‘ ‘, ‘\n‘, ‘ ‘, ‘ ‘, ‘\t‘, ‘ ‘]

#\n與\t
print(re.findall(r‘\n‘,‘hello egon \n123‘)) #[‘\n‘]
print(re.findall(r‘\t‘,‘hello egon\t123‘)) #[‘\n‘]

#\d與\D
print(re.findall(‘\d‘,‘hello egon 123‘)) #[‘1‘, ‘2‘, ‘3‘]
print(re.findall(‘\D‘,‘hello egon 123‘)) #[‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘, ‘ ‘, ‘e‘, ‘g‘, ‘o‘, ‘n‘, ‘ ‘]

#\A與\Z
print(re.findall(‘\Ahe‘,‘hello egon 123‘)) #[‘he‘],\A==>^
print(re.findall(‘123\Z‘,‘hello egon 123‘)) #[‘he‘],\Z==>$

#^與$
print(re.findall(‘^h‘,‘hello egon 123‘)) #[‘h‘]
print(re.findall(‘3$‘,‘hello egon 123‘)) #[‘3‘]

# 重復匹配：| . | * | ? | .* | .*? | + | {n,m} |
#.
print(re.findall(‘a.b‘,‘a1b‘)) #[‘a1b‘]
print(re.findall(‘a.b‘,‘a1b a*b a b aaab‘)) #[‘a1b‘, ‘a*b‘, ‘a b‘, ‘aab‘]
print(re.findall(‘a.b‘,‘a\nb‘)) #[]
print(re.findall(‘a.b‘,‘a\nb‘,re.S)) #[‘a\nb‘]
print(re.findall(‘a.b‘,‘a\nb‘,re.DOTALL)) #[‘a\nb‘]同上一條意思一樣

#*
print(re.findall(‘ab*‘,‘bbbbbbb‘)) #[]
print(re.findall(‘ab*‘,‘a‘)) #[‘a‘]
print(re.findall(‘ab*‘,‘abbbb‘)) #[‘abbbb‘]

#?
print(re.findall(‘ab?‘,‘a‘)) #[‘a‘]
print(re.findall(‘ab?‘,‘abbb‘)) #[‘ab‘]
#匹配所有包含小數在內的數字
print(re.findall(‘\d+\.?\d*‘,"asdfasdf123as1.13dfa12adsf1asdf3")) #[‘123‘, ‘1.13‘, ‘12‘, ‘1‘, ‘3‘]

#.*默認為貪婪匹配
print(re.findall(‘a.*b‘,‘a1b22222222b‘)) #[‘a1b22222222b‘]

#.*?為非貪婪匹配：推薦使用
print(re.findall(‘a.*?b‘,‘a1b22222222b‘)) #[‘a1b‘]

#+
print(re.findall(‘ab+‘,‘a‘)) #[]
print(re.findall(‘ab+‘,‘abbb‘)) #[‘abbb‘]

#{n,m}
print(re.findall(‘ab{2}‘,‘abbb‘)) #[‘abb‘]
print(re.findall(‘ab{2,4}‘,‘abbb‘)) #[‘abb‘]
print(re.findall(‘ab{1,}‘,‘abbb‘)) #‘ab{1,}‘ ===> ‘ab+‘
print(re.findall(‘ab{0,}‘,‘abbb‘)) #‘ab{0,}‘ ===> ‘ab*‘

#[]
print(re.findall(‘a[1*-]b‘,‘a1b a*b a-b‘)) #[]內的都為普通字符了，且如果-沒有被轉意的話，應該放到[]的開頭或結尾
print(re.findall(‘a[^1*-]b‘,‘a1b a*b a-b a=b‘)) #[]內的^代表的意思是取反，所以結果為[‘a=b‘]
print(re.findall(‘a[0-9]b‘,‘a1b a*b a-b a=b‘)) #[]內的^代表的意思是取反，所以結果為[‘a=b‘]
print(re.findall(‘a[a-z]b‘,‘a1b a*b a-b a=b aeb‘)) #[]內的^代表的意思是取反，所以結果為[‘a=b‘]
print(re.findall(‘a[a-zA-Z]b‘,‘a1b a*b a-b a=b aeb aEb‘)) #[]內的^代表的意思是取反，所以結果為[‘a=b‘]

#\# print(re.findall(‘a\\c‘,‘a\c‘)) #對於正則來說a\\c確實可以匹配到a\c,但是在python解釋器讀取a\\c時，會發生轉義，然後交給re去執行，所以拋出異常
print(re.findall(r‘a\\c‘,‘a\c‘)) #r代表告訴解釋器使用rawstring，即原生字符串，把我們正則內的所有符號都當普通字符處理，不要轉義
print(re.findall(‘a\\\\c‘,‘a\c‘)) #同上面的意思一樣，和上面的結果一樣都是[‘a\\c‘]

#():分組
print(re.findall(‘ab+‘,‘ababab123‘)) #[‘ab‘, ‘ab‘, ‘ab‘]
print(re.findall(‘(ab)+123‘,‘ababab123‘)) #[‘ab‘]，匹配到末尾的ab123中的ab
print(re.findall(‘(?:ab)+123‘,‘ababab123‘)) #findall的結果不是匹配的全部內容，而是組內的內容,?:可以讓結果為匹配的全部內容
print(re.findall(‘href="(.*?)"‘,‘<a href="http://www.baidu.com">點擊</a>‘))#[‘http://www.baidu.com‘]
print(re.findall(‘href="(?:.*?)"‘,‘<a href="http://www.baidu.com">點擊</a>‘))#[‘href="http://www.baidu.com"‘]

#|
print(re.findall(‘compan(?:y|ies)‘,‘Too many companies have gone bankrupt, and the next one is my company‘))

# ===========================re模塊提供的方法介紹===========================
import re
#1
print(re.findall(‘e‘,‘alex make love‘) )   #[‘e‘, ‘e‘, ‘e‘],返回所有滿足匹配條件的結果,放在列表裏
#2
print(re.search(‘e‘,‘alex make love‘).group()) #e,只到找到第一個匹配然後返回一個包含匹配信息的對象,該對象可以通過調用group()方法得到匹配的字符串,如果字符串沒有匹配，則返回None。

#3
print(re.match(‘e‘,‘alex make love‘))    #None,同search,不過在字符串開始處進行匹配,完全可以用search+^代替match

#4
print(re.split(‘[ab]‘,‘abcd‘))     #[‘‘, ‘‘, ‘cd‘]，先按‘a‘分割得到‘‘和‘bcd‘,再對‘‘和‘bcd‘分別按‘b‘分割

#5
print(‘===>‘,re.sub(‘a‘,‘A‘,‘alex make love‘)) #===> Alex mAke love，不指定n，默認替換所有
print(‘===>‘,re.sub(‘a‘,‘A‘,‘alex make love‘,1)) #===> Alex make love
print(‘===>‘,re.sub(‘a‘,‘A‘,‘alex make love‘,2)) #===> Alex mAke love
print(‘===>‘,re.sub(‘^(\w+)(.*?\s)(\w+)(.*?\s)(\w+)(.*?)$‘,r‘\5\2\3\4\1‘,‘alex make love‘)) #===> love make alex

print(‘===>‘,re.subn(‘a‘,‘A‘,‘alex make love‘)) #===> (‘Alex mAke love‘, 2),結果帶有總共替換的個數

#6
obj=re.compile(‘\d{2}‘)

print(obj.search(‘abc123eeee‘).group()) #12
print(obj.findall(‘abc123eeee‘)) #[‘12‘],重用了obj
 

2.time模塊

import time
#--------------------------我們先以當前時間為準,讓大家快速認識三種形式的時間
print(time.time()) # 時間戳:1487130156.419527
print(time.strftime("%Y-%m-%d %X")) #格式化的時間字符串:‘2017-02-15 11:40:53‘

print(time.localtime()) #本地時區的struct_time
print(time.gmtime())    #UTC時區的struct_time

#--------------------------按圖1轉換時間
# localtime([secs])
# 將一個時間戳轉換為當前時區的struct_time。secs參數未提供，則以當前時間為準。
time.localtime()
time.localtime(1473525444.037215)

# gmtime([secs]) 和localtime()方法類似，gmtime()方法是將一個時間戳轉換為UTC時區（0時區）的struct_time。

# mktime(t) : 將一個struct_time轉化為時間戳。
print(time.mktime(time.localtime()))#1473525749.0

# strftime(format[, t]) : 把一個代表時間的元組或者struct_time（如由time.localtime()和
# time.gmtime()返回）轉化為格式化的時間字符串。如果t未指定，將傳入time.localtime()。如果元組中任何一個
# 元素越界，ValueError的錯誤將會被拋出。
print(time.strftime("%Y-%m-%d %X", time.localtime()))#2016-09-11 00:49:56

# time.strptime(string[, format])
# 把一個格式化時間字符串轉化為struct_time。實際上它和strftime()是逆操作。
print(time.strptime(‘2011-05-05 16:37:06‘, ‘%Y-%m-%d %X‘))
#time.struct_time(tm_year=2011, tm_mon=5, tm_mday=5, tm_hour=16, tm_min=37, tm_sec=6,
#  tm_wday=3, tm_yday=125, tm_isdst=-1)
#在這個函數中，format默認為："%a %b %d %H:%M:%S %Y"。
 

3.logging模塊

#日誌模塊的詳細用法：
import logging
#1、Logger:產生日誌
logger1=logging.getLogger("訪問日誌")
#2、Filter：

#3、Handler:接受傳過來的日誌，進行日誌格式化，可以打印到終端或者文件
sh=logging.StreamHandler()#打印到終端
fh1 = logging.FileHandler(‘s1.log‘,encoding=‘utf-8‘)
fh2 = logging.FileHandler(‘s2.log‘,encoding=‘utf-8‘)

#4、Formatter:日誌格式
formatter1 = logging.Formatter(
    fmt=‘%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s‘,
    datefmt=‘%Y-%m-%d %H:%M:%S %p‘,
)
formatter2 = logging.Formatter(
    fmt=‘%(asctime)s - %(message)s‘,
    datefmt=‘%Y-%m-%d %H:%M:%S %p‘,
)

formatter3=logging.Formatter(
    fmt=‘%(asctime)s : %(module)s : %(message)s‘,
    datefmt=‘%Y-%m-%d %H:%M:%S %p‘,
)

#5、為handler綁定日誌格式
# sh.setFormatter()
 

4.random模塊

#random 生成隨機數模塊

import random
# random.randint(a,b) [a,b]生成a到b之前的隨機整數
# random.random() (0,1) 生成0到1之間的隨機小數
# random.choice()
# random.randrange() [a,b) 生成a到b之間的隨機整數
# random.uniform() (a,b) 生成a到b之間的隨機小數
# 練習：編寫一個隨機驗證碼的函數，驗證碼包含數字，字母大小寫

def make_code(n):
    res = ""
    for i in range(n):
        s1 = str(random.randint(0,9))
        s2 = chr(random.randint(65,90))
        s3 = chr(random.randint(97,122))
        res += random.choice([s1,s2,s3])
    return res

print(make_code(9))
# print(random.random())
# print(random.choice([‘1‘,‘2‘,‘3‘]),2)
# print(random.randrange(1,3))
# print(random.uniform(1,3))

#洗牌操作
item=[1,2,3,4,5,6,7,8,9,10,‘J‘,‘Q‘,‘K‘]
random.shuffle(item)
print(item)

5.os 模塊

import os,sys

#拼接項目所在跟路徑
print(os.path.normpath(os.path.join(
    os.path.abspath(__file__),
    ‘..‘,
    ‘..‘
)))
# print(os.path.dirname(__file__)) #獲取當前文件的目錄路徑
# print(os.path.abspath(__file__)) #獲取當前文件的絕對路徑
# print(os.path.exists(__file__)) #判斷文件是否存在
# print(os.path.join(‘C:‘,‘a‘,‘D:‘,‘b‘,‘c‘)) #從最右邊的根目錄開始拼接文件路徑
print(os.path.split(‘D:b\c\d\a.txt‘)) #將路徑拆成分
# print(os.name) #操作系統的類型
# print(os.pardir) #上級目錄

6.sys模塊

import sys,time,os

#打印進度條
def progress(percent,width=50):
    ‘‘‘print process ‘‘‘
    if percent > 1:
        percent = 1
    show_str = ((‘[%%-%ds]‘ %width) %(‘#‘*int(percent*width)))
    print(‘\r%s %d%%‘ %(show_str,int(percent*100)),end=‘‘)

revc_size = 0
total_size = 10242

while revc_size < total_size:
    revc_size+=1024
    time.sleep(0.1)
    progress(revc_size/total_size)

#打印進度條  簡版
# for n in range(50):
#     sys.stdout.write(‘#‘)
#     sys.stdout.flush()
#     time.sleep(0.05)

# sys.argv[1]  #傳入的第一個參數
# print(sys.path ) #打印系統環境變量
# sys.exit(n) # 定義退出時的狀態碼
# print(sys.platform) #系統的類型

7.json/pikle模塊

之前我們學習過用eval內置方法可以將一個字符串轉成python對象，不過，eval方法是有局限性的，對於普通的數據類型，json.loads和eval都能用，但遇到特殊類型的時候，eval就不管用了,所以eval的重點還是通常用來執行一個字符串表達式，並返回表達式的值。

1 import json
2 x="[null,true,false,1]"
3 print(eval(x)) #報錯，無法解析null類型，而json就可以
4 print(json.loads(x)) 
什麽是序列化？

我們把對象(變量)從內存中變成可存儲或傳輸的過程稱之為序列化，在Python中叫pickling，在其他語言中也被稱之為serialization，marshalling，flattening等等，都是一個意思。

為什麽要序列化？

1：持久保存狀態

需知一個軟件/程序的執行就在處理一系列狀態的變化，在編程語言中，‘狀態‘會以各種各樣有結構的數據類型(也可簡單的理解為變量)的形式被保存在內存中。

內存是無法永久保存數據的，當程序運行了一段時間，我們斷電或者重啟程序，內存中關於這個程序的之前一段時間的數據（有結構）都被清空了。

在斷電或重啟程序之前將程序當前內存中所有的數據都保存下來（保存到文件中），以便於下次程序執行能夠從文件中載入之前的數據，然後繼續執行，這就是序列化。

具體的來說，你玩使命召喚闖到了第13關，你保存遊戲狀態，關機走人，下次再玩，還能從上次的位置開始繼續闖關。或如，虛擬機狀態的掛起等。

2：跨平臺數據交互

序列化之後，不僅可以把序列化後的內容寫入磁盤，還可以通過網絡傳輸到別的機器上，如果收發的雙方約定好實用一種序列化的格式，那麽便打破了平臺/語言差異化帶來的限制，實現了跨平臺數據交互。

反過來，把變量內容從序列化的對象重新讀到內存裏稱之為反序列化，即unpickling。

如何序列化之json和pickle：

json

如果我們要在不同的編程語言之間傳遞對象，就必須把對象序列化為標準格式，比如XML，但更好的方法是序列化為JSON，因為JSON表示出來就是一個字符串，可以被所有語言讀取，也可以方便地存儲到磁盤或者通過網絡傳輸。JSON不僅是標準格式，並且比XML更快，而且可以直接在Web頁面中讀取，非常方便。

JSON表示的對象就是標準的JavaScript語言的對象，JSON和Python內置的數據類型對應如下：

import json

dic={‘name‘:‘alvin‘,‘age‘:23,‘sex‘:‘male‘}
print(type(dic))#<class ‘dict‘>

j=json.dumps(dic)
print(type(j))#<class ‘str‘>

f=open(‘序列化對象‘,‘w‘)
f.write(j)  #-------------------等價於json.dump(dic,f)
f.close()
#-----------------------------反序列化<br>
import json
f=open(‘序列化對象‘)
data=json.loads(f.read())#  等價於data=json.load(f)

import json
#dct="{‘1‘:111}"#json 不認單引號
#dct=str({"1":111})#報錯,因為生成的數據還是單引號:{‘one‘: 1}

dct=‘{"1":"111"}‘
print(json.loads(dct))

#conclusion:
#        無論數據是怎樣創建的，只要滿足json格式，就可以json.loads出來,不一定非要dumps的數據才能loads

 註意點

import pickle

dic={‘name‘:‘alvin‘,‘age‘:23,‘sex‘:‘male‘}

print(type(dic))#<class ‘dict‘>

j=pickle.dumps(dic)
print(type(j))#<class ‘bytes‘>

f=open(‘序列化對象_pickle‘,‘wb‘)#註意是w是寫入str,wb是寫入bytes,j是‘bytes‘
f.write(j)  #-------------------等價於pickle.dump(dic,f)

f.close()
#-------------------------反序列化
import pickle
f=open(‘序列化對象_pickle‘,‘rb‘)

data=pickle.loads(f.read())#  等價於data=pickle.load(f)

print(data[‘age‘])

8.configparse模塊

對類似於mysql php等配置文件進行操作

import configparser
config = configparser.ConfigParser()

config.read(‘my.ini‘)
#增加配置項
# config.add_section(‘mysqld‘)
# config.set(‘mysqld‘,‘port‘,‘3306‘)
# config.set(‘mysqld‘,‘character-server-set‘,‘utf8‘)
# config.set(‘mysqld‘,‘db-engin‘,‘innodb‘)
#
# config.add_section(‘client‘)
# config.set(‘client‘,‘name‘,‘huazai‘)
# config.set(‘client‘,‘password‘,‘123456‘)

#修改配置項
config.set(‘client‘,‘password‘,‘abc123‘)
config.write(open(‘my.ini‘,‘w‘,encoding=‘utf-8‘))  #最後

# config.add_section(‘hehe‘)
#查看section下的配置內容
print(config.get(‘mysqld‘,‘port‘))

9.hashlib模塊

#hashlib加密三個特點：
    #hash值長度固定
    #不可逆
    #str相同加密後，hash值相同
#用途：
#文件下載，校驗文件的完整

# import hashlib
# md5=hashlib.md5()
# md5.update(‘hello‘.encode(‘utf-8‘))
# md5.update(‘hello‘.encode(‘utf-8‘))
# print(md5.hexdigest())

#加鹽
# import hashlib
# md5 = hashlib.md5()
# md5.update(‘兩個黃鸝鳴翠柳‘.encode(‘utf-8‘))
# md5.update(‘hello‘.encode(‘utf-8‘))
# md5.update(‘一行白鷺上青天‘.encode(‘utf-8‘))
# print(md5.hexdigest())
# md = hashlib.md5()
#
# md.update(‘兩個黃鸝鳴翠柳hello一行白鷺上青天‘.encode(‘utf-8‘))
# print(md.hexdigest())

import hmac
h=hmac.new(‘slat‘.encode(‘utf-8‘))
h.update(‘hello‘.encode(‘utf-8‘))
print(h.hexdigest())

10.shutil模塊

import shutil
#對文件操作
# shutil.copyfileobj() #將文件內容拷貝到另一個文件中
# shutil.copyfile() #拷貝文件
# shutil.copymode() #僅拷貝權限。內容、組、用戶均不變
# shutil.copystat() #僅拷貝狀態的信息，包括：mode bits, atime, mtime, flags
# shutil.copy() #拷貝文件和權限
# shutil.copy2() #拷貝文件和狀態信息
# shutil.copytree() #遞歸的去拷貝文件夾
# shutil.ignore_patterns() #忽略一些文件，和其他命令組合使用
# shutil.rmtree() #遞歸的去刪除文件
# shutil.move() #遞歸的去移動文件，它類似mv命令，其實就是重命名。
# shutil.make_archive() #創建壓縮包並返回文件路徑
# 將 /data 下的文件打包放置當前程序目錄
import shutil

# ret = shutil.make_archive("data_bak", ‘gztar‘, root_dir=‘/data‘)

# 將 /data下的文件打包放置 /tmp/目錄
import shutil

ret = shutil.make_archive("/tmp/data_bak", ‘gztar‘, root_dir=‘/data‘)

11.shelve模塊

 # shelve模塊比pickle模塊簡單，只有一個open函數，返回類似字典的對象，可讀可寫;key必須為字符串，而值可以是python所支持的數據類型

import shelve

f=shelve.open(r‘sheve.txt‘)
# f[‘stu1_info‘]={‘name‘:‘egon‘,‘age‘:18,‘hobby‘:[‘piao‘,‘smoking‘,‘drinking‘]}
# f[‘stu2_info‘]={‘name‘:‘gangdan‘,‘age‘:53}
# f[‘school_info‘]={‘website‘:‘http://www.pypy.org‘,‘city‘:‘beijing‘}

print(f[‘stu1_info‘][‘hobby‘])
f.close()

12.xml模塊

xml是實現不同語言或程序之間進行數據交換的協議，跟json差不多，但json使用起來更簡單，不過，古時候，在json還沒誕生的黑暗年代，大家只能選擇用xml呀，至今很多傳統公司如金融行業的很多系統的接口還主要是xml。

xml的格式如下，就是通過<>節點來區別數據結構的:

xml是實現不同語言或程序之間進行數據交換的協議，跟json差不多，但json使用起來更簡單，不過，古時候，在json還沒誕生的黑暗年代，大家只能選擇用xml呀，至今很多傳統公司如金融行業的很多系統的接口還主要是xml。

xml的格式如下，就是通過<>節點來區別數據結構的:

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

xml協議在各個語言裏的都 是支持的，在python中可以用以下模塊操作xml：

# print(root.iter(‘year‘)) #全文搜索
# print(root.find(‘country‘)) #在root的子節點找，只找一個
# print(root.findall(‘country‘)) #在root的子節點找，找所有

import xml.etree.ElementTree as ET

tree = ET.parse("xmltest.xml")
root = tree.getroot()
print(root.tag)

#遍歷xml文檔
for child in root:
    print(‘========>‘,child.tag,child.attrib,child.attrib[‘name‘])
    for i in child:
        print(i.tag,i.attrib,i.text)

#只遍歷year 節點
for node in root.iter(‘year‘):
    print(node.tag,node.text)
#---------------------------------------

import xml.etree.ElementTree as ET

tree = ET.parse("xmltest.xml")
root = tree.getroot()

#修改
for node in root.iter(‘year‘):
    new_year=int(node.text)+1
    node.text=str(new_year)
    node.set(‘updated‘,‘yes‘)
    node.set(‘version‘,‘1.0‘)
tree.write(‘test.xml‘)

#刪除node
for country in root.findall(‘country‘):
   rank = int(country.find(‘rank‘).text)
   if rank > 50:
     root.remove(country)

tree.write(‘output.xml‘)

#在country內添加（append）節點year2
import xml.etree.ElementTree as ET
tree = ET.parse("a.xml")
root=tree.getroot()
for country in root.findall(‘country‘):
    for year in country.findall(‘year‘):
        if int(year.text) > 2000:
            year2=ET.Element(‘year2‘)
            year2.text=‘新年‘
            year2.attrib={‘update‘:‘yes‘}
            country.append(year2) #往country節點下添加子節點

tree.write(‘a.xml.swap‘)

自己創建xml文檔：

import xml.etree.ElementTree as ET

new_xml = ET.Element("namelist")
name = ET.SubElement(new_xml,"name",attrib={"enrolled":"yes"})
age = ET.SubElement(name,"age",attrib={"checked":"no"})
sex = ET.SubElement(name,"sex")
sex.text = ‘33‘
name2 = ET.SubElement(new_xml,"name",attrib={"enrolled":"no"})
age = ET.SubElement(name2,"age")
age.text = ‘19‘

et = ET.ElementTree(new_xml) #生成文檔對象
et.write("test.xml", encoding="utf-8",xml_declaration=True)

ET.dump(new_xml) #打印生成的格式

Day6-常用模塊