Python基礎知識整理

vitaminYZZ發表於2019-03-08

Python

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

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

is和is 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()
# 檢查鍵值是否存在
in，not 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

第六章特殊方法

特殊方法不需要手動執行

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)

repr()：對當前物件使用，指定在互動模式中直接輸出的結果

def __repr__(self):
    print("呼叫__repr__()")

比較大小

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)

bool()：將物件轉換成bool值

def __bool__(self):
    return Ture

# 指定轉換規則
def __bool__(self):
    return self._age > 9

其他特殊方法

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

Babel基礎知識整理
2019-06-20
Babel
JS基礎知識整理
2022-03-16
JS
Servlet基礎知識點整理
2018-12-14
Servlet
C++基礎知識整理
2024-04-06
C++
Web前端基礎知識整理
2021-09-09
Web前端
python基礎知識
2024-03-14
Python
python 基礎知識
2021-09-09
Python
linux基礎知識整理（備忘）
2018-11-11
Linux
Java基礎知識整理之this用法
2019-01-19
Java
整理Java基礎知識--Calendar 類
2021-09-09
Java
Python爬蟲筆記（一）——基礎知識簡單整理
2018-07-08
Python爬蟲筆記
Python基礎知識1
2018-11-15
Python
Python基礎知識分享
2018-03-12
Python
Java基礎知識整理之註解
2019-01-19
Java
JavaSE基礎學習知識整理大全
2018-08-30
Java
「整理」前端微知識庫 —— 基礎技能
2018-08-16
前端
時序分析：基礎知識整理（二）
2024-03-22
Python知識體系-Python2基礎知識
2019-05-08
Python
Python基礎知識之字典
2019-02-16
Python
Python基礎知識之集合
2019-02-16
Python
Python基礎知識架構
2019-04-12
Python架構
Python基礎知識之二
2018-09-18
Python
Python——基礎知識細節
2019-08-02
Python
Python基礎知識點梳理
2020-02-08
Python
Java基礎知識整理之程式碼塊
2019-01-19
Java
前端開發基礎知識整理–css篇
2018-03-09
前端CSS
iOS | 面試知識整理 - OC基礎 (一)
2019-09-17
iOS面試
整理Java基礎知識--Number&Math類
2021-09-09
Java
Python基礎知識入門（二）
2020-02-14
Python
Python入門基礎知識（二）
2020-10-14
Python
Python基礎函式使用知識
2020-10-03
Python函式
Java基礎知識整理之static修飾方法
2019-01-19
Java
mysql資料庫學習基礎知識整理
2020-12-12
MySql資料庫
Java基礎知識整理之static修飾屬性
2019-01-19
Java
Jack整理的Win32彙編基礎知識
2020-04-04
Win32
Python入門基礎知識例項，
2018-11-24
Python
Python基礎知識思維導圖
2019-01-30
Python
基礎的python知識2 （變數）
2020-03-18
Python變數