python_day07 經常使用模塊xml/configparser/hashlib/subprocess 面向對象程序設計

經常使用模塊
shutil
xml
configparser
hashlib
suprocess
面向對象的程序設計

 

經常使用模塊

xml模塊

 1 <?xml version="1.0"?>
 2 <data>
 3     <country name="Liechtenstein">
 4         <rank updated="yes">2</rank>
 5         <year>2008</year>
 6         <gdppc>141100</gdppc>
 7         <neighbor name="Austria" direction="E"/>
 8         <neighbor name="Switzerland" direction="W"/>
 9     </country>
10     <country name="Singapore">
11         <rank updated="yes">5</rank>
12         <year>2011</year>
13         <gdppc>59900</gdppc>
14         <neighbor name="Malaysia" direction="N"/>
15     </country>
16     <country name="Panama">
17         <rank updated="yes">69</rank>
18         <year>2011</year>
19         <gdppc>13600</gdppc>
20         <neighbor name="Costa Rica" direction="W"/>
21         <neighbor name="Colombia" direction="E"/>
22     </country>
23 </data>

xml數據（a.xml）

import xml.etree.ElementTree as ET
tree=ET.parse('a.xml')
root=tree.getroot()
for child in root:
    print('====>',child.tag)
    for i in child:
        print(i.tag,i.attrib,i.text)
關注：標籤名、屬性、文本內容

#查找element元素的三種方式
years=root.iter('year') #掃描整個xml文檔樹，找到全部
for i in years:
    print(i)

res1=root.find('country') #誰來調，就從誰下一層開始找,只找一個
print(res1)
res2=root.findall('country') #誰來調，就從誰下一層開始找,只找一個
print(res2)

#修改子節點
years=root.iter('year') #掃描整個xml文檔樹，找到全部
for year in years:
    year.text=str(int(year.text)+1)
    year.set('updated','yes')
    year.set('version','1.0')
tree.write('a.xml')

#刪除
for county in root.iter('country'):
    # print(county.tag)
    rank=county.find('rank')
    if int(rank.text) > 10:
        county.remove(rank)
tree.write('a.xml')

#增長節點
for county in root.iter('country'):
    e=ET.Element('egon')
    e.text='hello'
    e.attrib={'age':'18'}
    county.append(e)

#前面增刪改操做必定要寫入到a.xml纔會生效
xmltree.write('a.xml')

configparser

[egon]
name = egon
is_admin = False
salary = 3.1

[alex]
name = alex
is_admin = True

a.ini

import configparser
config=configparser.ConfigParser()
config.read('a.ini')
#取配置
print(config.sections()) #看標題
print(config.options(config.sections()[0])) #查看某個標題下的配置項
res=config.get('alex','name')#查看某個標題下的某個配置項的值
print(type(res))
# getint/getfloat/getboolean
res1=config.getfloat('egon','salary')#查看某個標題下的某個配置項的值
print(type(res1))
res1=config.getboolean('egon','is_admin')#查看某個標題下的某個配置項的值
print(type(res1))
#修改
config.remove_section('alex')
config.remove_option('egon','age')
#添加
config.add_section('alex')
config.set('alex','name','SB')
#寫入文件
config.write(open('a.ini','w'))

hashlib

三個特色：
1.內容相同則hash運算結果相同，內容稍微改變則hash值則變
2.不可逆推
3.相同算法：不管校驗多長的數據，獲得的哈希值長度固定。

import hashlib
#以下幾種加密方式結果同樣
m=hashlib.md5()
m.update('hello'.encode('utf-8'))
m.update('world'.encode('utf-8'))
print(m.hexdigest())

m=hashlib.md5()
m.update('helloworld'.encode('utf-8'))
print(m.hexdigest())

m=hashlib.md5('helloworld'.encode('utf-8'))
print(m.hexdigest())

m=hashlib.md5('h'.encode('utf-8'))
m.update('elloworld'.encode('utf-8'))
print(m.hexdigest())

#加密文件
m=hashlib.md5()
with open('a.xml','rb') as f:
    for line in f:
        m.update(line)
print(m.hexdigest())
#耗費內存不推薦使用
m=hashlib.md5()
with open('a.xml','rb') as f:
    m.update(f.read())
print(m.hexdigest())

#加鹽
password='alex3714'
m=hashlib.md5('yihangbailushangqingtian'.encode('utf-8'))
m.update(password.encode('utf-8'))
passwd_md5=m.hexdigest()
print(passwd_md5)

#hmac模塊
#默認第一次加密就會加鹽
import hmac
h=hmac.new('hello'.encode('utf-8'))
h.update('world'.encode('utf-8'))
print(h.hexdigest())
#0e2564b7e100f034341ea477c23f283b
h=hmac.new('hel'.encode('utf-8'))
h.update('loworld'.encode('utf-8'))
print(h.hexdigest())
#2b8861887b9670e3b042475182619b5d
h=hmac.new('hello'.encode('utf-8'))
h.update('w'.encode('utf-8'))
h.update('or'.encode('utf-8'))
h.update('ld'.encode('utf-8'))
print(h.hexdigest())
#0e2564b7e100f034341ea477c23f283b

suprocess

import subprocess
res=subprocess.Popen(r'deeddddir D:\04-視頻錄製存放目錄\python18期\day7\xml模塊',
                     shell=True,
                     stdout=subprocess.PIPE,
                     stderr=subprocess.PIPE)
print('=================>') #程序會先打印此處
print('=================>',res)
print('-========>',res.stdout.read())
print('-========>',res.stderr.read().decode('gbk'))     #windows爲gbk解碼，Linux爲ut-8解碼
print('-========>',res.stderr.read().decode('gbk'))     #管道信息只獲取一次，以後再獲取就沒有了

#dir file_path | findstr xml$
res1=subprocess.Popen(r'dir E:\獲取的資料\老男孩教育-Python自動化課程-20170701\day07\day7純代碼\xml模塊',
                     shell=True,
                     stdout=subprocess.PIPE,)
stdin=res1.stdout    #輸出做爲下一次的輸入
res2=subprocess.Popen(r'findstr xml$',
                     shell=True,
                     stdin=res1.stdout,
                     stdout=subprocess.PIPE,)
print(res2.stdout.read().decode('gbk'))

面向對象的程序設計

面向過程：核心是過程二字，過程指的是問題的解決步驟，即先幹什麼再幹什麼，基於
面向過程去設計程序就比如在設計一條流水線，是一種機械式的思惟方式
優勢：複雜的問題流程化，進而簡單化
缺點：可擴展性差
應用：腳本程序，好比linux系統管理腳本，著名案例：linux內核，httpd，git

面向對象：核心是對象二字，對象就是特徵與技能的結合體，若是把設計程序比喻成
創造一個世界，那你就是這個世界的上帝，與面向過程對機械流水的模擬形式鮮明的對比
面向對象更加註重的對現實時間的模擬。
優勢：可擴展性
缺點：複雜性高

類即種類，類別，對象是特徵和與技能的結合體，那麼類就是一系列對象類似的
特徵與技能的結合體
在現實世界中：先有一個個具體存在的對象----》（總結類似之處）---》現實中的類
在程序中：必定是先定義類，後調用類來產生對象
類與對象

#第一階段：現實中的對象----》現實中類
obj1：
    特徵
        學校=oldboy
        名字=李大炮
        年齡=18
        性別=女
    技能
        學習
        吃飯
obj2：
    特徵
        學校=oldboy
        名字=張全蛋
        年齡=28
        性別=男
    技能
        學習
        吃飯

obj3：
    特徵
        學校=oldboy
        名字=牛榴彈
        年齡=18
        性別=女
    技能
        學習
        吃飯
現實中的老男孩學生類：
    類似的特徵
        學校=oldboy
    類似的技能
        學習
        吃飯
#第二階段：程序中的類----》程序中的對象
class OldboyStudent:
    school = 'oldboy' #類的數據屬性
    def learn(self): #類的函數屬性
        print('is learning')

    def eat(self):
        print('is eating')
    print('======>')
#類體的代碼在類定義階段就會執行,理所應當會產生類的名稱空間，用__dict__屬性查看
print(OldboyStudent.__dict__)
print(OldboyStudent.__dict__['school'])
print(OldboyStudent.__dict__['learn'])
#類的屬性操做
print(OldboyStudent.school)
print(OldboyStudent.learn)
def func():pass
print(func)
OldboyStudent.learn(123)

OldboyStudent.x=1111111111111111111111
OldboyStudent.school='Oldboy'
del  OldboyStudent.school
print(OldboyStudent.__dict__)

OldboyStudent.__dict__['x']=1111111111111111111111
class OldboyStudent:
    school = 'oldboy'
    #obj1,'李大炮',18,'女'
    def __init__(self,name,age,sex): #在實例化時,產生對象以後執行
        # if not isinstance(name,str):
        #     raise TypeError('名字必須是字符串類型')
        self.name=name
        self.age=age
        self.sex=sex
        # return None #__init__方法必須返回None
        #obj1.name='李大炮'
        #obj1.age=18
        #obj1.sex='女'
    def learn(self):
        print('is learning')
    def eat(self):
        print('is eating')
obj1=OldboyStudent('李大炮',18,'女') #
#分兩步：
#第一步：先產生一個空對象obj1
#第二步：OldboyStudent.__init__(obj1,'李大炮',18,'女')
print(obj1.__dict__)
obj2=OldboyStudent('張全蛋',28,'男')
obj3=OldboyStudent('牛榴彈',18,'女')
print(obj2.__dict__)
print(obj3.__dict__)
print(obj1.name)#obj1.__dict__['name']
obj1.name='大炮'
print(obj1.__dict__)
obj1.__dict__['name']='炮'
print(obj1.name)
obj1.__dict__.pop('name')
# print(obj1.name)
print(obj1.__dict__)
obj1=OldboyStudent(123123123,18,'女') #

school='hahahahahahaah'
class OldboyStudent:
    # school = 'oldboy'
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
    def learn(self):
        print('%s is learning'  %self.name)
    def eat(self):
        print('is eating')
obj1=OldboyStudent('李大炮',18,'女')
obj2=OldboyStudent('張全蛋',28,'男')
obj3=OldboyStudent('牛榴彈',18,'女')
print(obj1.__dict__)
print(obj1.name,obj1.age,obj1.sex)
#對象能夠訪問類的數據屬性，結論：類的數據屬性共享給全部對象使用，id對同樣
print(obj1.school,id(obj1.school))
print(obj2.school,id(obj2.school))
print(obj3.school,id(obj3.school))
print(OldboyStudent.school,id(OldboyStudent.school))
#類的函數屬性是綁定給全部對象使用的，綁定給不一樣的對象是不一樣的綁定方法，綁定方法有何特殊之處？
#暫且拋開綁定方法，類確定能夠訪問本身的函數屬性
OldboyStudent.learn(obj1)
OldboyStudent.learn(obj2)
OldboyStudent.learn(obj3)
print(obj1.learn)
print(obj2.learn)
print(obj3.learn)
print(OldboyStudent.learn)
#綁定方法：綁定給誰，就由誰來調用，誰來調用就把「誰」自己當作第一個參數傳入
obj1.learn() #OldboyStudent.learn(obj1)
obj2.learn() #OldboyStudent.learn(obj1)
obj3.learn() #OldboyStudent.learn(obj1)
#在python3中類型就類
print(OldboyStudent)
print(list)

l1=list()
l2=list()
l3=list()
print(type(l1))
print(type(obj1))
l1.append(3) #list.append(l1,3)
list.append(l1,3)
print(l1)
print(l2)
print(l3)
#屬性查找順序：先從對象的__dict__中找，而後到類的__dict__中找，而後父類....
OldboyStudent.school='哈佛'
obj1.school='hahahahahahahhahahahahahah'
print(obj1.__dict__)
print(obj1.school)
print(obj2.school)
print(obj3.school)

class Foo:
    count=0
    def __init__(self,x,y,z):
        self.x=x
        self.y=y
        self.z=z
        Foo.count+=1
obj1=Foo(1,1,1)
obj2=Foo(1,2,1)
obj3=Foo(1,2,3)
print(obj1.count)
print(Foo.count)

class OldboyStudent:
    # school = 'oldboy'
    def __init__(self,name,age,sex='male'):
        self.name=name
        self.age=age
        self.sex=sex
    def learn(self):
        print('%s is learning'  %self.name)
    def eat(self,y):
        print('is eating')
obj1=OldboyStudent('李大炮',18)
OldboyStudent.eat()
obj1.eat(1)
obj1.learn()

對象直接的交互

class Garen:
    camp='Demacia'
    def __init__(self,nickname,life_value=100,aggresivity=80):
        self.nickname=nickname
        self.life_value=life_value
        self.aggresivity=aggresivity
    def attack(self,enemy):
        enemy.life_value-=self.aggresivity
class Riven:
    camp = 'Noxus'
    def __init__(self, nickname, life_value=80, aggresivity=100):
        self.nickname = nickname
        self.life_value = life_value
        self.aggresivity = aggresivity
    def attack(self, enemy):
        enemy.life_value -= self.aggresivity
g1=Garen('草叢猥瑣男')
r1=Riven('兔女郎')
print(r1.life_value)
g1.attack(r1)
print(r1.life_value)