Python基礎知識整理

vitaminYZZ發表於2019-03-08

Python筆記

第一章 Python開發環境

Python直譯器

  • CPython:官方,c語言編寫
  • PyPy:Python語言編寫
  • IPython:.net編寫
  • Jython:Java編寫

Python互動介面

並不適用日常開發

第二章 基本語法

2.1基本語法規則

1、嚴格區分大小寫

2、每一行就是一條語句

3、每一行語句的長度不要過長

4、一條語句可以分多行編寫,語句以’ \ ’ 結尾

5、Python是縮排嚴格的語言,不要隨便寫和空格

6、註釋以#(+空格)開頭

2.2變數

1、字面量和變數

字面量:就是一個值,比如1,2,3…或者’dadasdas’

變數:儲存字面量

2、變數和識別符號

  • 變數:可以直接賦值,但是變數使用前必須賦值
  • Python是動態型別語言,可以任意修改變數值
  • 識別符號:所有可以自主命名的內容
  • 寫類名的時候用發駝峰命名法,其他時候用下劃線命名法

3、資料型別

  • 變數的值的型別,也就是可以為變數賦哪些值
  • 數值:整數、浮點數、複數
  • Python中所有整數都是int型別,Python中整數大小沒有限制,如果數字長度過大可以使用下劃線分割
  • 十進位制不能以0開頭
  • 二進位制0b開頭,八進位制0o開頭,十六進位制0x開頭
  • Python中所有小數都是浮點數,浮點數運算是一個近似值

4、字串

  • 表示一段文字資訊:s = ‘你好’
  • 可以使用單引號或者雙引號,但不能混合使用
  • 相同的引號不能巢狀,單引號和雙引號不能跨行使用
  • 三重引號表示長字元,可以跨行使用
'''sjajfkfjlsfjl
sfjlf
jslfj'''
  • \為轉義字元

  • 格式化

    a = 'hello' + 'world'
    print('a = ',a)
    

    佔位符:

    %s在字串中表示任意字元

    %f表示小數佔位符

    %d表示整數佔位符

    b = 'hello %s'%"world"
    c = 'hello %s 你好 %s' % ('Tom',"Jack")
    d = 'hello %3s'%"w" #新增最少三個字元
    e = 'hello %3.5s'%"w" #字串長度限制在3-5之間 
    

    格式化字串:在格式化字串中可以直接嵌入變數

    a = 10
    b = 'hello'
    c = f'666 {a} {b}'
    print(f'c = {c})
    

    字串複製:

    a = "hello"
    b = a*2
    

5、布林值和空值

bool:True&False

空值:None表示不存在

6、型別檢查

type()函式,檢查結果作為返回值

7、物件

物件結構:每個物件都要儲存三種資料

  • id(標識)

    用來標識物件的唯一性,由解析器生成,就是記憶體地址,不能改變,通過id()函式檢視

  • type

    <class ‘int’> <class ‘bool’>等等

    決定物件有哪些功能

  • value

第三章 序列

  • 序列是Python中一種基本的資料結構

  • 分類:1、可變序列:序列中元素可變,如列表list

    ​ 2、不可變序列:序列中元素不能改變,如字串str,元組tuple

3.1列表

  • 列表是一種物件,可以儲存多個有序物件(資料)
  • 列表中的資料稱為元素,元素可以為任意物件:字串,列表,函式,bool值,None…
  • 列表中的物件會按照插入順序儲存在列表中
  • 可以通過索引獲取列表中的元素,索引從0開始
  • len()獲取列表長度
  • 如果索引是負數表示倒著數

3.1.1列表的使用

# 建立列表
myList = []
# 建立有元素的列表
myList = [10,20,20,34,75,78,55,73,7,True,print]
print(myList[2])

3.1.2列表切片

  • 切片:獲取子列表
  • 語法:列表[起始位置:結束位置]
  • 會包括起始位置元素,但不包括結束位置元素
  • 切片會產生新的列表,不影響原來的列表
  • 省略結束位置,一直擷取到最後;省略起始位置,從開始位置擷取;開始位置,結束位置都省略,相當於複製列表
  • 改變步長:列表[起始位置:結束位置:步長]
students = ['Tom','Jack','Mark','Lee','Ming','Xioahu']
print(students = [0:2])

3.1.3通用操作

  • "+"可以將兩個列表拼接為一個列表
  • "*"可以將列表複製(重複)
  • in用來檢查元素是否存在於列表中,存在返回True
  • not in用來檢查元素是否存在於列表中,不存在返回True
  • min獲取列表最小值
  • max獲取列表最大值
  • s.index(a,x,y)獲取指定元素在列表中的位置,引數為:元素,起始位置,結束位置
  • s.count()統計元素出現次數
list = [1,23,31,42,45] + [3,7,8,63,53,2]
list = [1,4,7,9]*2

3.1.4修改列表元素

只適用於可變序列

list()將其他序列轉換為列表

students = ['Tom','Jack','Mark','Lee','Ming','Xioahu']
# 通過索引修改
students[4] = 'superman‘
# 刪除索引為2的元素
del students[3]
# 通過切片修改列表,用切片賦值只能使用序列
students[2:4] = 'wer'
# 在x位置插入元素
students [x:x] = 'hello'

3.1.5列表的方法

s = ['Tom','Jack','Mark','Lee','Ming','Xioahu']
# 尾部新增元素
s.append('大傻子') 
# 指定位置插入元素:插入位置和插入元素
s.insert(2,'6666')
# 使用新的序列擴充套件原序列,需要一個序列作為引數
s.extend(['a','b'])
# 清空
s.clear()
# 根據“索引”刪除並返回指定元素,有返回值!
s.pop(2)
# 刪除指定元素,只刪除第一個
s.remove("a")
# 反轉列表
s.reverse()
# 排序,預設生序排列
s.sort()
s.sort(reverse = True)

3.1.6遍歷列表

# while迴圈遍歷
s = ['Tom','Jack','Mark','Lee','Ming','Xioahu']
i = 0
while i < len(s):
    print(s[i])
    i += 1
# for迴圈遍歷
for i in s:
    print(i)

3.1.7序列生成器

# range():引數為起始位置,結束位置和步長
r = range(10)
print(list(r))
# 使用range()建立for迴圈
for i in range(100):
    print(i)

3.2元組

  • 元組是不可變序列,但操作與列表相同
  • 希望資料不變時使用元組

3.2.1基本使用

# 建立元組,至少有一個逗號
tuple = ()
# 非空元組括號可以省略
tuple = 10,20,30,40
# 元組的解包,將其中的每一個元素分別賦值給變數
a,b,c,d = tuple
# 交換兩個變數的值
a,b = b,a
# 變數前邊新增*可以讓變數獲取剩餘所有值
a,b,*c = tuple
a,*b,c = tuple

3.3可變物件

  • value可變的物件
  • 列表就是一種可變物件
  • 改物件:修改物件時,如果有其他變數也指向該物件,則修改在其他同時發生在其他物件中
  • 改變數:為一個變數重新賦值,不影響其他變數
# 修改物件的值——>改物件,物件id不變
a[0] = 10
# 改變變數所指向的物件——>改變數,物件id改變
a = [4,5,6]
b = a
b[0] = 44444

3.3.1

**==!=**比較的是物件的值是否相等

isis not比較物件id是否相等

a = [1,2,4]
b = [1,2,3]
print(a == b)
print(a is b)

3.4字典

  • 屬於一種新的資料結構–對映

  • 都是用來儲存物件的容器

  • 列表儲存效能很好,查詢效能很差

  • 字典中每個元素都有唯一的名字,通過名字可以快速查詢指定元素

  • 字典也稱為鍵值對結構key-value:

    唯一的名字稱為鍵,key

    物件稱為值,value

    一個鍵值對稱為一個item

3.4.1使用

# 建立字典,空字典
dict = {}  
# 語法:{key:value}
# key鍵值只能是不可變物件:int,str,bool,tuple;鍵值不能重複
# value可以是任意物件
dict = {'name':"孫悟空"'age':25,'gender':'man'}
# 按鍵值取值
print(dict['name'])

3.4.2序列轉換字典

雙值序列,序列中中有兩個值,如[1,2],(‘w’,2),‘cv’,可以轉換為字典

d = dict(['q',3])

3.4.3常用方法

淺複製:簡單複製一個物件內部的值,如果值也是一個可變物件,這個物件不會被複制,如字典內部的字典不會被複制,而是用同一個物件

len()
# 檢查鍵值是否存在
innot in
# 通過鍵值獲取value,不存在會返回None
d.get()
# 修改和新增,若不存在則會新增鍵值對
d['key'] = 'value'
# 新增鍵值對,如果key已經存在則返回key值,字典不變
# 如果不存在則新增key並設定value
d.setdefault('key',value)
# 合併字典,鍵值重複則被替換
d.update(d2)
# 刪除鍵值對 
del d['key']
# 刪除最後鍵值對,並返回刪除的鍵值對,元組形式 
d.popitem()
# 根據key值刪除,並返回value
d.pop('key')
# 清空
d.clear()
# 對字典進行淺複製
d2 = d.copy()

3.4.4遍歷字典

dict = {'name':"孫悟空"'age':25,'gender':'man'}
# keys()該方法返回一個序列,序列中儲存字典的所有鍵
#pirnt(dict.keys())
for i in dict.keys():
    print(dict[i])
# values()返回一個序列,儲存values
for i in dict.values():
    print(i)
# items()返回一個序列,序列包含爽值子序列
# print(dict.items())
for x,y in d.items():
    print(x , '=' , y)

3.5集合

  • 集合和列表類似但又不同
  • 集合中只能儲存不可變物件,字元常量,數字等
  • 集合中儲存的物件是無序的(不安插入順序儲存,自動排序)
  • 不能出現重複元素

3.5.1使用集合

# 建立集合
set = {1,10,55,4}
print(set, type(set))
# 建立空集合
set = set()
# 將其他序列轉換為集合
s = set([213,5353,5645,33,5455,333,7,7,44,4])
# 對字典使用set()只保留key
s = set({'a':1,'b':2,'c':3})

3.5.2常用方法

in
not in
len()
# 向集合中新增元素
set.add(2222222)
# 將一個集合新增到另一個集合
# update()也可以傳入str,set,dict,list
s.update(s2)
# 隨機刪除一個元素,並返回刪除的元素
s.pop()
# 刪除集合中的指定元素
s.remove(1)
# 清空
s.clear()
# 淺複製
s.copy()

3.5.3集合的運算

  • 對集合作運算時不影響原來的集合,而是將結果返回
s1 = {1,2,3,4,5,6,7,8,9,10}
s2 = {2,4,6,8,10}
s3 = {1,2,4,8,16}
# 交集運算
s = s1 & s2
print(s)
# 並集運算
s = s1 | s3
print(s)
# 差集運算
s = s1 -s2
# 異或運算,獲取只在一個集合出現的元素
s = s1 ^ s2
# 檢查是否為子集
print(s1 <= s2)

第四章 函式

  • 函式也是物件,物件是記憶體中儲存資料的區域
  • 函式可以儲存程式碼塊,並且可以在需要時多次呼叫
# def 函式名([形參]):
#	程式碼塊
def fun():
    print("my first function")
    
fun()

4.1函式引數

  • 函式名後面的括號定義形參
  • 形參:形式引數,在函式中宣告變數但不賦值
  • 實參:如果函式定義時指定了形參,那麼呼叫時必須傳遞實參,實參可以是任何型別
def sum(a,b):
    print(a+b)
    
sum(3,5)

4.1.1實參傳遞方式

  • 位置引數:對應位置的實參傳遞給對應位置的形參
  • 關鍵字引數:根據引數名傳遞
  • 位置引數和關鍵字引數可以混合使用,但是位置引數必須在前
  • 在函式中對形參重新賦值,不會影響其他變數;如果形參是一個物件,會影響到所有指向該物件的變數
  • 不希望改變物件,可以傳遞拷貝或者切片:c.copy()c[:]
def fn(a):
	a = 10000
	print(a)
c = 35
print(c)
fn(c)

4.1.2不定長引數

  • 定義函式時在形參前邊加上*,這個形參將會獲得所有實參,它會將所有的實參儲存在元組中
  • *a會接受所有位置實參,將所有的實參儲存在元組中
  • *的引數只能有一個
  • *引數後面的引數必須以關鍵字引數形式傳遞
  • 形參開頭直接寫*則所有引數必須以關鍵字形式傳遞fn(*, a=1, b=2)
def sum(*nums):
    for i in nums:
    	result += i
    print(result)
  • **形參可以接受其他關鍵字引數,並將引數儲存在字典值中
  • **引數只能有一個,且必須放在最後
def fn(b,c,**a):
    print('a = ',a,type(a))
    print('b = ',b,type(b))
    print('c = ',c,type(c))
    
fn(10,20,a1=30,a2=40,a3=50)

4.1.3引數解包

  • 傳遞實參時,也可以在序列型別的引數前新增幸好*,這樣會自動將序列中的元素一次作為引數傳遞;序列中元素個數要和引數一樣多
  • **對字典解包
def fn(a,b,c,d):
    print(a)
    print(b)
    print(c)
    print(d)
t = (1,2,3,4)
fn(*t)

4.2返回值

  • 可以返回任意物件list,dict…
  • 函式預設返回None
def fn(x):
    return x + 100
print(fn(4))

4.3文件字串

  • 文件字串是:函式說明
  • 函式第一行,一般用三引號
# 幫助函式
help(print)
# 引數型別描述,預設值描述
def fn(a:int,b:str,c:tuple=(1,2,3,4))

4.4名稱空間

  • 名稱空間就是字典
  • **locals()**獲取當前作用域的名稱空間
  • **global()**獲取全域性名稱空間
# 列印當前名稱空間
scope = locals()
print(scope)
# 向名稱空間新增變數,不建議這麼做
scope['m'] = 21111

4.5函式遞迴

  • 遞迴式函式:函式呼叫自己

  • def fn():

    fn()

  • 遞迴是將大問題分解為小問題,類似於迴圈

  • 遞迴的兩個條件:

    1、基線條件:問題可以被分解為最小的問題,當基線條件滿足,遞迴不再執行

    2、遞迴條件:將問題繼續分解的條件

# for迴圈求階乘
def fn(n):
    result = n
    for i in range(1,n):
        result *= i
        
# 遞迴分解:n! = n*(n-1)!
# 基線條件:n=1?
def fac(n):
    if(n == 1):
        return 1
    return n * fac(n-1)
# 檢查字串是否是迴文 遞迴練習
# 遞迴條件:str[0] == str[n-1]?,str[1] == str[n-2]?......
# 基線條件:有不同或者全相同,有不同結束遞迴不是迴文
def fn(string):
    n = len(stirng) - 1
    if(string[0] != string[n]):
        print("不是迴文字元")
        return False
    if(n >= 2):
    	return fn(stirng[1:n])
    if(n < 2):
        print("是迴文字元")
        return True

4.6高階函式

  • 可以接受一個或者多個函式作為引數:實際是將程式碼傳入函式,可以靈活使用函式
  • 可以將函式作為返回值
# 將函式作為引數
# 找出列表中大於5的數
def up5(lst):
    up5 = []
    for i in lst:
        if i > 5:
            up5.append(i)
    return up5
            
# 找出列表中的奇數
def odd(lst):
    odd = []
    for i in lst:
        if i % 2 != 0:
        odd.append(i)
	return odd
        
def fun(func,lst):
    result = []
    result = func(lst)
    return result

4.6.1過濾函式:filter(function,iterator)

引數:1、函式,根據該函式來過濾序列(可迭代的結構)

​ 2、需要過濾的序列(可迭代結構)

返回值:過濾後的新序列(可迭代結構)

print(list(filter(fn,lst)))

4.6.2匿名函式lambda函式表示式

  • 專門用來建立簡單函式
  • 語法:lambda 引數列表 :返回值
  • 一般作為函式引數使用
lambda a, b : a + b
# 語法糖
r = filter(lambda i : i % 2 == 0, x)

4.6.3map()遍歷可迭代物件

  • **map()**可以將可迭代物件中的所有元素做指定操作,然後新增到新的物件中返回
lst = [2,3,445,645,3,32,667,122]
r = map(lambda i : i*2+3-i*i, lst)
print(list(r))

4.6.4sort()引數排序

  • sort()可以接受一個關鍵字key,key需要一個函式作為引數,每次都會以列表中的一個元素作為引數來呼叫函式,並使用函式返回值來比較元素大小
lst = [2,3,445,645,3,32,667,122]
lst.sort(key=len)
lst.sort(key=int)
print(lst)
  • sorted()可以接受任一序列,不影響原來的物件而是返回新物件
lst = [2,3,445,645,3,32,667,122]
list = sorted(lst, key=int)
print(l)

4.6.5閉包

  • 將函式作為返回值
  • 返回的函式可以訪問函式內部變數
  • 可以建立只有當前函式能訪問的變數,可以將私有資料藏到閉包中
def fn():
    def fn2():
        print("fn2")
    return fn2
  • 閉包要件:函式巢狀、函式作為返回值、內部函式用到外部函式變數
# 求多個數的平均值
def makeAverage():
    nums = []
    def Average(n):
        nums.append(n)
        return sum(nums)/len(nums)
    return Average

ave = makeAverage()

print(ave(10))
print(ave(235))

4.6.6裝飾器

  • 開閉原則:對擴充套件開放,對修改關閉
  • @裝飾器:使用裝飾器,可以同時使用多個裝飾器(就近原則)
def beginEnd(fn):
    '''對其他函式進行擴充套件'''
    def newFun(*args, **kwargs):# 舊函式引數
        print("開始執行")
        result = fn(*args, **kwargs)# 舊函式
        print("結束執行")
        return result
    # 返回新函式
    return newFun

# 典型用法
@beginEnd
def hello():
    print('Hello')
    
hello()

第五章 物件

  • 物件是記憶體中用來儲存資料的一塊區域
  • 物件可以存放各種資料:數字、bool值、程式碼
  • 物件由三部分組成:標識、型別、值

5.1類(class)簡介

  • 類是物件的圖紙,物件是類的例項
  • 如果多個物件通過一個類建立,稱這些類為一類物件
  • 自定義的類需要大寫字母開頭
  • 檢查obj是否是class的例項:isinstance(obj,class)
class 類名(父類):
	公共屬性......
    
# 初始化
	def __init__(...):
        ......
	
# 其他方法
	def fun(...):
        ......

5.1.1向物件中新增屬性

  • 語法:物件.屬性 = 屬性值
class myclass:
    pass
mc = myclass()
mc.name = "烏龍"

print(mc.name)

5.2類的屬性和方法

  • 建立一個“人”的類
class human:
# 類中定義的變數會成為所有物件的公共屬性
	name = "None"
    age = 0
# 類中的函式稱為方法,該類的所有例項都可訪問
# 函式呼叫,則呼叫時傳幾個引數,就會有幾個實參
# 方法呼叫,預設傳遞一個引數,也就是方法至少有一個引數
# 這個引數指的是呼叫物件本身命名為self
	def hello(self):
        print("Hello,你好啊,我是%s" % self.name)

Jack = human()
Merry = human()

Jack.hello()
  • 如果屬性(方法)是所有例項共享的,則應將其儲存到類物件中;如果是某個例項獨有,應儲存到例項物件中
  • 一般情況下,屬性儲存到例項物件,方法儲存到類物件

5.2.1類的特殊方法init()

  • 一個屬性是必須的,但是此屬性有不同,每次建立物件都手動新增屬性,容易出錯,麻煩;因此希望建立物件時應該給物件傳入引數

  • 特殊方法以 雙下劃線開頭, 以雙下劃線結尾,特殊方法會自動呼叫

  • 特殊方法的關鍵:呼叫時刻、作用

    1、init()會在物件建立後立即執行

    2、作用:初始化變數

class human:
	def __init__(self,name):
    	self.name = name
        
	def hello(self):
        print("Hello,你好啊,我是%s" % self.name)

5.3物件導向的三大特性

5.3.1封裝

  • 隱藏物件中不希望被外部訪問的屬性和方法
  • 提供getter和setter方法,如果init()中沒有對應屬性,則getter和setter會報錯
  • 可以在setter方法中增加錯誤控制,也可以在setter和getter中增加其他操作
class human:
	def __init__(self,name):
    	self.hidden_name = name
    
    # setter方法
    	def set_name(self,name):
            self.hidden_name
    
    # getter方法
    def get_name(self):
        return self.hidden_name
    
	def hello(self):
        print("Hello,你好啊,我是%s" % self.hidden_name)
        
Pet = human("Pet")
print(Pet.get_name())
Pet.hello()
class Rectangle:
    '''矩形'''
    def __init__(self,width,height):
        self.hidden_width = width
        self.hidden_height = height
        
    def get_width(self):
        return self.hidden_width
    
    def get_height(self):
        return self.hidden_height
    
    def set_width(self,width):
    	self.hidden_width = width
        
    def set_height(self,height):
    	self.hidden_width = height
        
# 可以表示計算屬性     
    def get_area(self);
    	return self.hidden_width * self.hidden_height
  • 以雙下劃線開頭的屬性是物件的隱藏屬性,只能在類內部訪問,方法也一樣;但一般不使用
  • 隱藏屬性只是Python為屬性改了名字:_類__屬性名
  • 一般只在私有屬性或方法前用一個下劃線,表示私有
class human:
	def __init__(self,name):
    	self.__name = name
    
    # setter方法
    	def set_name(self,name):
            self.__name = names
    
    # getter方法
    def get_name(self):
        return self.__name
    
	def hello(self):
        print("Hello,你好啊,我是%s" % self.__name)
        
Pet = human("Pet")
print(Pet.get_name())
Pet.hello()
  • 將getter方法改名,方便使用,再增加property裝飾器
class human:
	def __init__(self,name):
    	self._name = name
    
    # getter方法改名,並增加裝飾器
    # property需要先宣告,再寫setter,順序不能倒過來
    @property
    def name(self):
        return self._name
    
    # setter方法改名,並增加裝飾器
    @name.setter
    	def name(self,name):
            self._name = name
    
	def hello(self):
        print("Hello,你好啊,我是%s" % self._name)
        
Pet = human("Pet")
# 增加裝飾器後使用getter
print(Pet.name)
# 增加裝飾器後使用setter
Pet.name = "BIG"
print(Pet.name)
Pet.hello()

5.3.2繼承

class Animal:
    def __init__(self,name):
        self._name = name
        
    @property
    def name(self):
        return self._name
    
    @name.setter
    def name(self,name):
        self._name = name
        
    def sleep(self):
        print("動物會睡覺(~﹃~)~zZ")
        
    def run(self):
        print("動物會跑")
        
# 基類寫在括號裡,基類的所有方法都會被繼承,包括__init__()
class Dog(Animal):
    def bark(self):
        print("狗會叫:汪汪汪")
        
mydog = Dog("xiaoming")
mydog.run()
mydog.bark()
  • 多重繼承(儘量少用)
  • ____bases()____獲取當前類的所有父類
  • 多個父類中有同名方法,會用第一個父類的方法
class C(A,B):
    pass

5.3.3多型

class A:
    def __init__(self,name):
        self._name = name
        
    @property
    def name(self):
        return self._name
    
    @name.setter
    def name(self,name):
        self._name = name
        
class B:
    def __init__(self,name):
        self._name = name
        
    @property
    def name(self):
        return self._name
    
    @name.setter
    def name(self,name):
        self._name = name        

a = A("Marry")
b = B("Marry")

# 多型,只要有name屬性就可以傳入函式
def hello(obj):
    print("hello 我是 %s" % obj.name)
    
hello(a)
hello(b)

5.4重寫

class Animal:
    def __init__(self,name):
        self._name = name
        
    def sleep(self):
        print("動物會睡覺(~﹃~)~zZ")
        
    def run(self):
        print("動物會跑")
        
# 基類寫在括號裡
class Dog(Animal):
    def __init__(self,name):
        self._name = name
        self._age = age
    
    @property
    def name(self):
        return self._name
    
    @name.setter
    def name(self,name):
        self._name = name
    
    @property
    def age(self):
        return self._age
    
    @age.setter
    def age(self,age):
        self._age = age
    
    def bark(self):
        print("狗會叫:汪汪汪")
        
    def run (self):
        print("狗會跑")
        
mydog = Dog()
mydog.run()
mydog.bark()
  • super()動態獲取基類
class Animal:
    def __init__(self,name):
        self._name = name
        
     @property
    def name(self):
        return self._name
    
    @name.setter
    def name(self,name):
        self._name = name
        
    def sleep(self):
        print("動物會睡覺(~﹃~)~zZ")
        
    def run(self):
        print("動物會跑")
        
# 基類寫在括號裡
class Dog(Animal):
    def __init__(self,name):
        super().__init__(name)
        self._age = age
    
    @property
    def age(self):
        return self._age
    
    @age.setter
    def age(self,age):
        self._age = age
    
    def bark(self):
        print("狗會叫:汪汪汪")
        
    def run (self):
        print("狗會跑")
        
mydog = Dog()
mydog.run()
mydog.bark()

5.5垃圾回收

  • 給類寫一個特殊方法____del()____
class A:
    def __init__(self):
        self._name = A
        
    # 特殊方法
    def __del__(self):
        print("物件被刪除")
       
# a = None後被刪除    
a = A()
a = None
b = a
# b = None才能刪除a
b = None

第六章 特殊方法

  • 特殊方法不需要手動執行
  1. str():列印一個物件時,實際列印的是__str__的返回值
class human:
	def __init__(self, name, age):
    	self._name = name
        self._age = age
    
    def __str__(self):
        return 'Person [name=% age=%d]' % (self._name,self._age)
    
    @property
    def age(self):
        return self._age
    
    @age.setter
    def age(self,age):
        self._age = age
    
    @property
    def name(self):
        return self._name
    
    # setter方法改名,並增加裝飾器
    @name.setter
    	def name(self,name):
            self._name = name
    
	def hello(self):
        print("Hello,你好啊,我是%s" % self._name)
        
Pet = human("Pet",22)
Big = human("Big",23)
# 列印一個物件時,實際列印的是__str__的返回值
print(Pet)
  1. repr():對當前物件使用,指定在互動模式中直接輸出的結果
def __repr__(self):
    print("呼叫__repr__()")
  1. 比較大小
obj.__lt__(self,other)  # 小於
obj.__le__(self,other)  # 小於等於
obj.__eq__(self,other)  # 等於
obj.__ne__(self,other)  # 不等於
obj.__gt__(self,other)  # 大於
obj.__ge__(self,other)  # 小於等於
class human:
	def __init__(self, name, age):
    	self._name = name
        self._age = age
    
    def __str__(self):
        return 'Person [name=% age=%d]' % (self._name,self._age)
    
    # __gt__()會在物件做大於比較時呼叫,該方法的返回值會作為比較結果
    # self表示當前物件,other表示和當前物件比較的物件:self > other,self在左,other在右側
    def __gt__(self,other):
        return self._age > other._age
    
    @property
    def age(self):
        return self._age
    
    @age.setter
    def age(self,age):
        self._age = age
    
    @property
    def name(self):
        return self._name
    
    # setter方法改名,並增加裝飾器
    @name.setter
    	def name(self,name):
            self._name = name
    
	def hello(self):
        print("Hello,你好啊,我是%s" % self._name)
        
Pet = human("Pet",22)
Big = human("Big",23)
# 列印一個物件時,實際列印的是__str__的返回值
print(Pet)
  1. bool():將物件轉換成bool值
def __bool__(self):
    return Ture

# 指定轉換規則
def __bool__(self):
    return self._age > 9
  1. 其他特殊方法
obj.__add__(self,other)
obj.__sub__(self,other)
obj.__mul__(self,other)
obj.__matmul__(self,other)
obj.__truediv__(self,other)
obj.__floordiv__(self,other)
obj.__mod__(self,other)
obj.__divmod__(self,other)
obj.__pow__(self,other)
obj.__rshift__(self,other)
obj.__lshift__(self,other)
obj.__and__(self,other)
obj.__or__(self,other)
obj.__xor__(self,other)

第七章 模組

7.1模組化簡介

  • 將一個完整程式分解為一個個小的模組

  • 優點:1、方便開發

    ​ 2、方便維護

    ​ 3、模組可以複用

  • 一個.py檔案就是一個模組

# import module  引入其他模組,引入其他模組時去掉其他模組的副檔名(.py)
import turtle
# import module as aothername 將模組名改名引入
import turtle as t
from module import ttttt as t
# 只引入模組中的部分內容
from module import (what you want)
# 引入模組的所有內容,不建議使用,程式臃腫,容易衝突
from module *
# __main__為主模組,即直接執行的模組
print(__name__)

7.2模組使用

# 訪問模組屬性
模組名.屬性名
# 訪問模組函式
模組名.函式名
# 建立模組中類的物件
物件 = 模組.類名
# 新增了下劃線的變數只能在模組內部訪問
# import * 不會引入下劃線開頭的變數
_a = 10
# 測試程式碼只在當前檔案中執行,而被引入其他模組時不執行則應寫為
if __name__ == '__main__':
    # 測試程式碼
    test()
    ......

7.4包

  • 當一個模組要被分解為多個模組,將多個模組打包
  • 包是一個資料夾
  • 包中必須有__init.py__
  • __pycache__是包的快取檔案

7.5Python標準庫

  • sys模組:獲得Python解析器的資訊;用函式來操作Python解析器
import sys
# 獲取執行程式碼時,命令列中包含的引數
# 返回一個列表,包含命令列中包含的所有引數
print(sys.argv)
# 獲取當前程式中引入的所有模組
print(sys.modules)
# 返回一個列表,儲存模組的搜尋路徑
print(sys.path)
# 執行的系統
print(sys.platform)
# 直接結束程式
sys.exit()
  • pprint簡單格式化輸出結果
import pprint
import sys
# 獲取當前程式中引入的所有模組
pprint.pprint(sys.modules)
  • os模組:對作業系統進行訪問
import os
import pprint
# 獲取環境變數
pprint.pprint(os.environ)
pprint.pprint(os.environ['path'])
# 執行作業系統命令
os.system('ls')

第八章 異常

  • 異常會導致程式終止,後面的程式碼不會執行

7.1處理異常

出現異常時可以寫程式碼進行處理:try語句

try:
    程式碼塊(可能出現錯誤的語句)
except:
    程式碼塊(處理方式)
else:
    程式碼(未出錯處理方式)

7.2異常傳播

  • 函式中出現異常時,如果在函式中對異常進行了處理,則異常不會再繼續傳播;如果函式中沒有對異常進行處理,異常會向呼叫處傳播;呼叫後異常被處理才停止傳播;如果傳遞到全域性也沒處理則程式終止
  • 當程式出現異常後,異常資訊會被儲存到專門的異常物件中,異常傳播時實際就是異常物件拋給了呼叫處
  • ZeroDivisionError:專門用來表示÷0的異常
  • NameError:類的物件用來專門處理變數異常

7.3異常物件

  • Exception是所有異常類的基類
try:
    程式碼塊(可能出現錯誤的語句)
except:
# except後不寫任何內容,則此時會捕獲所有異常
    程式碼塊(處理方式)
else:
    程式碼(未出錯處理方式)
try:
    程式碼塊(可能出現錯誤的語句)
except NameError:
# except後寫異常類,則捕獲特定的異常
    程式碼塊(處理方式)
except ZeroDivisionError:
# except後寫異常類,則捕獲特定的異常
    程式碼塊(處理方式)
else:
    程式碼(未出錯處理方式)
# 列印異常資訊
try:
    程式碼塊(可能出現錯誤的語句)
except Exception as e:
    print(e)#列印資訊
    程式碼塊(處理方式)
else:
    程式碼(未出錯處理方式)
try:
    程式碼塊(可能出現錯誤的語句)
except:
# except後不寫任何內容,則此時會捕獲所有異常
    程式碼塊(處理方式)
else:
    程式碼(未出錯處理方式)
# finally 無論是否異常都會執行
finally:
    程式碼
  • 自定義異常類
# 自定義異常類
class MyError(Exception);
	pass

7.4丟擲異常

def add(a,b):
    if a < 0 or b < 0:
        # raise 向外丟擲異常
        raise Exception('兩個引數中不能有負數')
    return a + b

第九章 檔案操作

  • 開啟\rightarrow讀、寫\rightarrow儲存\rightarrow關閉
  • 檔案操作標準格式
file_name = "demo.txt"
try:
    with open(file_name) as file_obj:
        pass
except:
    print(f'{fileName}檔案不存在')

9.1開啟檔案open()函式

  • open(file, mode=‘r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
  • open()函式有返回值,返回值就是開啟的檔案;當獲取檔案物件以後,所有操作都應該通過物件來進行
# file 是要開啟檔案的名字(路徑)
# 建立變數儲存檔名
fileName = "Demo.txt"
# 開啟檔案
obj = open(fileName)

9.2關閉檔案

# file 是要開啟檔案的名字(路徑)
# 建立變數儲存檔名
fileName = "Demo.txt"
# 開啟檔案
obj = open(fileName)
# 關閉檔案
obj.close()
fileName = "Demo.txt"
#with ... as 語句;with語句結束檔案自動關閉
with open(fileNmae) as obj:
    pass

9.3檔案讀取

  • read()會讀取檔案全部內容
fileName = "Demo.txt"
try:
	with open(fileName,encoding='utf-8') as obj:
    	content = obj.read()
        print(content)
except:
    print(f'{fileName}檔案不存在')
  • read()可以接收引數,設定讀取字元數量
fileName = "Demo.txt"
try:
	with open(fileName,encoding='utf-8') as obj:
    	content = obj.read(8)# 讀取八個字元,讀取檔案結尾則返回空字串
        print(content)
except:
    print(f'{fileName}檔案不存在')
  • 讀取大檔案
file_name = "demo.txt"

try:
	with open(file_name,encoding='utf-8') as flie_obj:
	# 定義一個變數來儲存檔案內容
	file_contnet = ''
	# 定義一個變數來指定每次讀取的大小
	chunk = 100
	# 建立一個迴圈來讀取檔案內容
	while:
	# 讀取chunk大小的內容
	content = flie_obj.read(chunk)
	# 檢查是否讀取到了內容
	if not content:
		break

	# 輸出內容
	# print(content,end='')
	file_contnet += content

except FileNotFoundError:
	print(f"{file_name}這個檔案不存在")
  • readline()
import pprint
file_name = "demo.txt"
with open(file_name,'x',encoding='utf-8')as flie_obj:

print(file_obj.readline(),' ')

r = file_obj.readlines()
pprint(r[0])
pprint(r[1])

9.4檔案寫入

file_name = "demo.txt"
with open(file_name,'x',encoding='utf-8')as flie_obj:

file_obj.write('aaaaaaaa\n')
r = file_obj.write('今天天氣不錯\n')

print(r)

9.5二進位制檔案

file_name = "demo.txt"

try:
	with open(file_name,‘rb') as flie_obj:
    # 讀取文字檔案時,size以字元為單位
    # 讀取二進位制檔案時,size以位元組為單位
	# 將內容讀到新定義的一個檔案
	new_name = 'a.txt'
	with open(file_name,‘wb') as new_obj:
	chunk = 1024*100
	# 建立一個迴圈來讀取檔案內容
	while true:
	# 讀取chunk大小的內容
	content = flie_obj.read(chunk)
	# 檢查是否讀取到了內容
	if not content:
		break

	# 內容寫到新物件中
	new_obj.write(content)

except FileNotFoundError:
	print(f"{file_name}這個檔案不存在")

9.6讀取檔案位置

  • seek和tell
file_name = "demo.txt"
with open(file_name,encoding='utf-8')as flie_obj:
    # seek修改當前讀取位置
    flie_obj.seek(30)
    print(flie_obj.read())

    # tell方法檢視當前讀取位置
    print("當前讀取到了->",file_obj.tell())

相關文章