python基礎--經常使用模塊與面向對象基礎

時間 2019-11-20

原文原文鏈接

1經常使用模塊

1.1 xml

　　xml是實現不一樣語言或程序之間進行數據交換的協議python

　　xml的格式以下：linux

<?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>

View Code

　　對xml的基本操做git

import xml.etree.cElementTree as ET
tree = ET.parse("aa.xml")
root = tree.getroot()
for child in root:
    print("=========>",child)
    for item in child:
        print(item.tag, item.attrib, item.text)

1.1.1 查找元素

import xml.etree.cElementTree as ET
tree = ET.parse("aa.xml")
root = tree.getroot()


# 1. iter:掃描整個xml文檔樹，找到全部
years = root.iter("year")
for year in years:
    print(year)

# 2. find:誰來調用，就從誰的下一層開始查找，只找一個
res1 = root.find("country")
print(res1)

# 3. findall:誰來調用，就從誰的下一層開始查找，找到全部
res2 = root.findall("country")
print(res2)

1.1.2 更新

　　找到整個文檔樹下的year標籤，而且把year的值加1，添加屬性updated和version算法

import xml.etree.cElementTree as ET
tree = ET.parse("aa.xml")
root = tree.getroot()

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("aa.xml")

1.1.3 刪除

import xml.etree.cElementTree as ET
tree = ET.parse("aa.xml")
root = tree.getroot()

countries = root.iter("country")
for country in countries:
    rank = country.find("rank")
    if int(rank.text) > 10:
        country.remove(rank)
tree.write("aa.xml")

1.1.4 增長

import xml.etree.cElementTree as ET
tree = ET.parse("aa.xml")
for country in tree.iter("country"):
    e = ET.Element("jack")
    e.text = "jack"
    e.attrib = {"age": "18"}
    country.append(e)
tree.write("aa.xml")

1.2 configparser

配置文件：shell

# a.ini
[egon]
name = egon
age = 18
is_admin = True
salary = 3.1

[jack]
name = jack
age = 25
is_admin = False
salary = 6.5

1.2.1 取值

import configparser

config = configparser.ConfigParser()
config.read("a.ini")

print(config.sections())  # 查看全部的標題
print(config.options(config.sections()[0])) # 查看某個標題下的配置項
res = config.get("jack", "name")  # 查看某個標題下的某個配置項的值
print(res)

res1 = config.getint("egon","age")
print(type(res1))

res2 = config.getfloat("egon", "salary")
print(type(res2))

res3 = config.getboolean("egon", "Is_Admin")
print(type(res3))

1.2.2 修改

import configparser

config = configparser.ConfigParser()
config.read("a.ini")

config.remove_section("jack")
config.remove_option("egon", "age")
config.add_section("alex")
config.set("alex", "name", "SB")

config.write(open("a.ini","w"))

1.3 Hashlib

　　Hashlib：主要是校驗文本內容app

　　hash:是一種算法，python3中代替了md5模塊和sha模塊，主要提供SHA一、SHA22四、SHA25六、SHA38四、SHA512ide

　　hash有三個特色：函數

　　　　1.內容相同則hash運算結果相同，內容稍微改變，則hash值則變化學習

　　　　2.hash結果不可逆推ui

　　　　3.相同算法：不管校驗多大的數據，獲得的哈希值長度固定

import hashlib

m = hashlib.md5()

# md5計算出來的結果，是組合一塊兒的結果
m.update("hello".encode("utf-8"))
m.update("world".encode("utf-8"))
print(m.hexdigest())  # 運行結果：fc5e038d38a57032085441e7fe7010b0

m2 = hashlib.md5()
m2.update("helloworld".encode("utf-8"))
print(m2.hexdigest()) # 運行結果：fc5e038d38a57032085441e7fe7010b0

m = hashlib.md5()
with open("my.txt","rb") as f:
    for line in f:
        m.update(line)
print(m.hexdigest())

# 耗費內存，不推薦使用
m = hashlib.md5()
with open("my.txt","rb") as f:
    m.update(f.read())
print(m.hexdigest())

　　加鹽，防止經過暴力破解密碼

import hashlib
password = "helloworld"
m = hashlib.md5("yihangbailushangqingtian".encode("utf-8"))
m.update(password.encode("utf-8"))

passwd_md5 = m.hexdigest()
print(passwd_md5)

　　hmac模塊，與md5相似，只是在初始化的時候，必須傳一個key值；首先保證初始的key同樣，隨後屢次update內容同樣，加密結果同樣

import hmac
h = hmac.new("hello".encode("utf-8"))
h.update("world".encode("utf-8"))
print(h.hexdigest())  # 運行結果：0e2564b7e100f034341ea477c23f283b

h2 = hmac.new("hello".encode("utf-8"))
h2.update("wor".encode("utf-8"))
h2.update("ld".encode("utf-8"))
print(h2.hexdigest())  # 運行結果：0e2564b7e100f034341ea477c23f283b

1.4 suprocess

　　suprocess模塊，用來執行命令的；在linux系統中，用來執行shell命令；

import subprocess
res = subprocess.Popen(r"dir D:\python\code\Learning\day07",shell=True,
                       stdout=subprocess.PIPE, stderr=subprocess.PIPE)
# print(res.stdout.read())
print("正確====>",res.stdout.read().decode("gbk"))  # 命令執行正確，輸出結果

res2 = subprocess.Popen(r"error dir D:\python\code\Learning\day07",
                       shell=True,
                       stdout=subprocess.PIPE,
                       stderr=subprocess.PIPE)
# print(res.stdout.read())
print("錯誤====>",res2.stderr.read().decode("gbk"))  # 命令執行錯誤，輸出結果
print("錯誤====>",res2.stderr.read().decode("gbk"))  # 管道的內容已經輸出，管道內已經無內容

#dir file_path | findstr xml$
res2 = subprocess.Popen(r"dir D:\python\code\Learning\day07\xml模塊\aa.xml",
                        shell=True,
                        stdout=subprocess.PIPE)
res3 = subprocess.Popen("findstr xml$",shell=True,
                        stdin=res2.stdout,
                        stdout=subprocess.PIPE)
print(res3.stdout.read().decode("gbk"))

2 面向對象設計

2.1 介紹

　　面向過程：核心是過程二字，過程指的是問題的解決步驟，即先幹什麼再幹什麼，基於面向過程取設計程序就比如在設計一條流水線，是一種機械式的思惟方式

　　優勢：複雜的問題流程化，進而簡單化

　　缺點：可擴展性差

　　應用場景：腳本程序，好比linux系統管理腳本，著名案例：linux內核，httpd，git

　　面向對象：核心是對象二字，對象就是特徵與技能的結合體，若是把設計程序比喻成創造一個世界，那你就是這個世界的上帝，與面向過程機械流水的模擬造成鮮明的對比，面向對象更加註重的對現實世界的模擬

　　優勢：可擴展性強

　　缺點：極易出現過分設計，不能控制流程的進度

　　類即種類、類別，對象是特徵和技能的結合體，那麼類就是一系列對象類似的特徵與技能的結合體

　　在現實世界中：先有一個個具體存在的對象---> 總結類似之處 ---> 現實中的類

　　在程序中：必定是先定義類，後調用類來產生對象

2.2 現實中的對象

　　第一階段：現實中對象，總結出現實中類

obj1：
    特徵
        學校=oldboy
        名字=李大炮
        年齡=18
        性別=女
    技能
        學習
        吃飯

obj2：
    特徵
        學校=oldboy
        名字=張全蛋
        年齡=28
        性別=男
    技能
        學習
        吃飯

obj3：
    特徵
        學校=oldboy
        名字=牛榴彈
        年齡=18
        性別=女
    技能
        學習
        吃飯

　　現實中的老男孩學生類：　　

    類似的特徵
        學校=oldboy
    類似的技能
        學習
        吃飯

2.3 程序中的類

　　第二階段：程序中的類，產生程序中的對象

　　1.怎麼定義類

　　2.類的名稱空間

　　3.類的屬性增刪改查操做

class OldboyStudent:
    school = 'oldboy' # 類的數據屬性，靜態屬性
    def learn(self):  # 類的函數屬性，動態屬性
        print('is learning')

    def eat(self):
        print('is eating')

# 類體的代碼在類定義階段就會執行,
# 必然會產生類的名稱空間，用__dict__屬性查看
print(OldboyStudent.__dict__)
print(OldboyStudent.__dict__['school'])
print(OldboyStudent.__dict__['learn'])

# 類的屬性訪問，包括數據屬性、函數屬性
print(OldboyStudent.school)
print(OldboyStudent.learn)

# 利用名稱空間，調用類的函數
OldboyStudent.learn(12)    # 執行結果：is learning

# 操做屬性
OldboyStudent.x=1111             # 新增屬性
OldboyStudent.school='Oldboy'    # 修改屬性
del  OldboyStudent.school        # 刪除屬性

2.4 程序中的對象

　　產生程序中的對象：類名加括號，調用類，產生一個該類的實際存在的對象，該調用過程稱爲實例化，產生的結果又能夠成爲實例

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

    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,'女')

 

# python中禁止經過__dict__操做類，但能夠經過字典操做對象
print(obj1.name)  # obj1.__dict__['name']
obj1.name='大炮'
print(obj1.__dict__)
obj1.__dict__['name']='炮'
print(obj1.name)

obj1.__dict__.pop('name')
print(obj1.__dict__)

2.5 init

　　__init__:在初始化對象時，進行初始化工做，在實例化時，產生對象以後執行

obj1 = OldboyStudent('李大炮',18,'女')
# 第一步：先產生一個空對象obj1
# 第二步：OldboyStudent.__init__(obj1,'李大炮',18,'女')

　　__init__:不只僅爲定製對象添加數據屬性代碼，能夠添加任何可執行代碼，其中包括用戶數據檢查代碼；既然是函數，必須有返回值，可是該函數必須None

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

2.6 類的數據屬性

　　對象能夠訪問類的數據屬性，結論：類的數據屬性共享給全部對象使用，id都同樣

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

# 對象能夠訪問類的數據屬性，結論：類的數據屬性共享給全部對象使用，id都同樣
obj1 = OldboyStudent('李大炮', 18, '女')
obj2 = OldboyStudent('張全蛋', 28, '男')
obj3 = OldboyStudent('牛榴彈', 18, '女')
print(obj1.school,id(obj1.school))      # 運行結果：oldboy 32215480
print(obj2.school,id(obj2.school))      # 運行結果：oldboy 32215480
print(obj3.school,id(obj3.school))      # 運行結果：oldboy 32215480
print(OldboyStudent.school,id(OldboyStudent.school))  # 運行結果：oldboy 32215480

2.7 類的函數屬性

　　類的函數屬性是綁定給全部對象使用的，綁定給不一樣的對象就是不一樣的綁定方法，類能夠訪問本身的函數屬性

　　綁定方法：綁定給誰，就由誰來調用，誰來調用就把「誰」自己當作第一個參數傳入

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, '女')
# 類的函數屬性是綁定給全部對象使用的，綁定給不一樣的對象是不一樣的綁定方法
# 類確定能夠訪問本身的函數屬性
OldboyStudent.learn(obj1)
OldboyStudent.learn(obj2)
OldboyStudent.learn(obj3)

# 綁定方法：綁定給誰，就由誰來調用，誰來調用就把「誰」自己當作第一個參數傳入
obj1.learn() # OldboyStudent.learn(obj1)
obj2.learn() # OldboyStudent.learn(obj1)
obj3.learn() # OldboyStudent.learn(obj1）
 

# 在python3中類型就類，python3中一切皆爲對象
l1=list()
l2=list()

# l1.append(3) 等價於 list.append(l1,3)
list.append(l1,3)
print(l1)
print(l2)

2.8 屬性查找順序

　　屬性查找順序：先從對象的__dict__中找，而後到類的__dict__中找，而後再從父類中進行查找...

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, '女')
# 屬性查找順序：先從對象的__dict__中找，而後到類的__dict__中找，而後再從父類中進行查找...
OldboyStudent.school = 'oldgirl'
obj1.school = 'self school'
print(obj1.__dict__)
print(obj1.school)

2.9 類實例化次數

　　統計類被實例化對象次數的計數功能，就是經過類的數據屬性進行實現的

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)

2.10 對象之間的交互

class Garen:
    camp = 'Demacia'
    def __init__(self,nickname, life_value = 100, aggresivity = 50):
        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 = 60):
        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)

3 繼承

　　繼承的基本功能是解決代碼重複的問題

　　繼承的特色：

　　1 繼承的功能之一：解決類與類之間的代碼重複問題

　　2 繼承是類與類之間的關係，是一種什麼是什麼的關係

　　3 在子類派生出的新的屬性，以本身的爲準

　　4 在子類派生出的新的方法內重用父類的功能的方式：指名道姓法；例如：OldboyPeople.__init__，這種調用方式自己與繼承是沒有關係

3.1 繼承的基本形式

# 繼承的基本形式
class ParentClass1(object): #定義父類
    pass

class ParentClass2: #定義父類
    pass

class SubClass1(ParentClass1): #單繼承，基類是ParentClass1，派生類是SubClass
    pass

class SubClass2(ParentClass1,ParentClass2): #python支持多繼承，用逗號分隔開多個繼承的類
    pass

print(SubClass1.__bases__)   # 運行結果：(<class '__main__.ParentClass1'>,)
print(SubClass2.__bases__)   # 運行結果：(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)

3.2 經典類與新式類

　　1.只有在python2中財分新式類和經典類，python3中統一都是新式類

　　2.在python2中，沒有顯示的繼承object類的類，以及該類的子類，都是經典類

　　3.在python2中，顯式的聲明繼承object的類，以及該類的子類，都是新式類

　　4.在python3中，不管是否繼承object，都默認繼承object，即python3中全部類均爲新式類

3.3 繼承使用案例

class Animal:
    x = 1
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
    def eat(self):
        print('%s eat' %self.name)

    def talk(self):
        print('%s say' %self.name)

class People(Animal):
    pass

class Dog(Animal):
    pass

peo1 = People('alex', 18, 'male')
print(peo1.__dict__)
peo1.talk()
print(peo1.x)

dog1 = Dog('yuanhao', 28, 'male')

print(peo1.name)
print(dog1.name)

3.4 指名道姓的調用

　　經過類的方式調用類的方法，例如：Animal.__init__(self,name,age,sex)

class Animal:
    x = 1
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
    def eat(self):
        print('%s eat' %self.name)

    def talk(self):
        print('%s say' %self.name)

class People(Animal):
    x = 10
    def __init__(self,name,age,sex,education):
        Animal.__init__(self,name,age,sex)
        self.education = education

    def talk(self):
        Animal.talk(self)
        print('這是人在說話')

class Dog(Animal):
    pass

peo1 = People('alex', 18, 'male', '小學肄業')
print(peo1.__dict__)
peo1.talk()
print(peo1.x)

dog1 = Dog('yuanhao', 28, 'male')

print(peo1.name)
print(dog1.name)

3.5 組合

　　組合：也是解決代碼重用的問題，解決什麼有什麼的關係。

　　組合：一個對象的屬性，來自與其餘類實例化的結果；什麼有什麼的屬性，利用組合；做業，利用了大量的組合

class OldboyPeople:
    school = 'oldboy'
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex
    def eat(self):
        print('is eating')

class OldboyStudent(OldboyPeople):
    def __init__(self, name, age, sex):
        OldboyPeople.__init__(self, name, age, sex)
        self.course = []
    def learn(self):
        print('%s is learning'  %self.name)

class OldboyTeacher(OldboyPeople):
    def __init__(self, name, age, sex, salary, title):
        OldboyPeople.__init__(self, name, age, sex)
        self.salary = salary
        self.title = title
        self.course = []
    def teach(self):
        print('%s is teaching'  %self.name)

class Course:
    def __init__(self, name, period, price):
        self.name = name
        self.period = period
        self.price = price
    def tell_info(self):
        print('<課程名:%s 週期：%s 價格：%s>' %(self.name,self.period,self.price))

python = Course('Python','6mons',3000)
linux = Course('Lnux','3mons',2000)
bigdata = Course('BigData','1mons',1000)

egon_obj=OldboyTeacher('egon', 18, 'male', 3.1, '沙河霸道金牌講師')

egon_obj.course.append(python)
egon_obj.course.append(linux)
for course in egon_obj.course:
    course.tell_info()

yl_obj=OldboyStudent('yanglei',28,'female')
yl_obj.course.append(python)

for obj in yl_obj.course:
    obj.tell_info()

3.7 繼承順序

　　繼承的查找順序，經過MRO列表順序進行查找的

class J:
    def test(self):
        print('J')
class A(J):
    pass
class E(J):
    def test(self):
        print('E')
    pass
class H(J):
    def test(self):
        print('H')

class G(H):
    def test(self):
        print('G')
    pass
class B(A):
    pass
class D(E):
    def test(self):
        print('D')
    pass
class F(G):
    def test(self):
        print('F')
    pass
class C(B,D,F):
    pass

c=C()

#MRO列表
print(C.mro())
# [<class '__main__.C'>, <class '__main__.B'>,
# <class '__main__.A'>, <class '__main__.D'>,
# <class '__main__.E'>, <class '__main__.F'>,
# <class '__main__.G'>, <class '__main__.H'>,
# <class '__main__.J'>, <class 'object'>]

#C B A D E F G H J object

3.8 子類重用父類的功能

　　子類重用父類的功能

　　1.利用指名道姓的方式進行調用

　　2.利用super的方式，進行調用；與繼承有關，依賴於繼承。

　　super與繼承有關，依賴於繼承；super，基於mro列表，向後查找

class OldboyPeople:
    school = 'oldboy'
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex

    def eat(self):
        print('is eating')
    def teach(self):
        print('這是父類的teach')

class OldboyTeacher(OldboyPeople):
    def __init__(self,name,age,sex,salary,title):
        # OldboyPeople.__init__(self,name,age,sex)
        # 在Python2中須要寫全：super(OldboyTeacher,self)
        # 利用super，專門父類的屬性，綁定方法
        super().__init__(name,age,sex)
        self.salary=salary
        self.title=title

    def teach(self):
        # OldboyPeople.teach(self)
        super().teach()  # 父類的teach函數屬性，是綁定方法
        print('%s is teaching'  %self.name)
print(OldboyTeacher.mro())

egon_obj=OldboyTeacher('egon',18,'male',3.1,'沙河霸道金牌講師')
print(egon_obj.__dict__)
egon_obj.teach()

3.9 綁定方法與非綁定方法

3.9.1 綁定到類的方法

　　classmethod

　　類方法的應用場景：方法跟類有關係，跟對象沒有關係，就能夠綁定到類的方法

　　從配置文件讀取配置信息，進行實例化

import settings

class MySql:
    def __init__(self,host,port):
        self.host = host
        self.port = port

    # 綁定給類的裝飾器
    @classmethod
    def from_conf(cls):
        # 等價於MySql(settings.HOST, settings.PORT)
        # 經過返回值，做爲實例化的結果
        return cls(settings.HOST, settings.PORT)

    def func1(self):pass

conn1 = MySql('127.0.0.1',3306)
conn2 = MySql.from_conf()   # 綁定方法，就是把類做爲第一個參數傳入
print(conn1.host, conn2.host)

　　classmethod，綁定到類的方法

　　綁定方法，綁定給對象、綁定給類；

　　綁定給對象，用對象來調用，就能夠自動傳值

　　綁定給類，類來調用；

3.9.2 非綁定方法

　　staticmethod

　　利用裝飾器，進行非綁定方式

import settings
import uuid
class MySql:
    def __init__(self,host,port):
        self.host=host
        self.port=port
        self.id=self.create_id()

    @classmethod
    def from_conf(cls): # 綁定給類的
        # print(cls)
        return cls(settings.HOST,settings.PORT)
    def func1(self): # 綁定給對象的
        pass
    @staticmethod
    def create_id(): # 非綁定方法
        return str(uuid.uuid1())

conn1=MySql('127.0.0.1',3306)
conn2=MySql('127.0.0.2',3306)
conn3=MySql('127.0.0.3',3306)

print(conn1.id,conn2.id,conn3.id)