Python基礎知識

建議有程式語言基礎的童鞋閱讀，零基礎閱讀可能會有點費解

點擊下載 python最新版本

注釋方法

# 單行注釋
''' 多行注釋 '''

資料型別

關鍵字	名稱	示例
chr	單個字符	'', 'd'
str	字串（多個chr）	'dd', '你好'
int	整數	1,2,3,4
float	浮點數	3.1415926
bool	布爾	Ture, False
list	串列	[1,2,3,4]
tuple	元組	('name', 'age')
dict	字典	{'name':'zzl'}
set	集合	{'zzl', 'age', 'gender'}

查看資料型別函式
type(變數) 回傳該變數的資料型別

資料型別轉換函式
int(num) 將num轉換為整數型別
float(num) 將num轉換為浮點數型別
bool(num) 將num轉換為布爾型別
str(num) 將num轉換為字串型別

注：

• int bool float 任何兩種型別都可相互轉換
• 任何型別都可以轉換為字串

注：

• str -> int 要求全部為數字
• str -> float 要求全部為數字，且可存在一個小數點

注：當布林值False轉換為str后， 在轉換為bool會變成True

輸入和輸出

輸入

語法 inp = input('提示文本')

注：輸入結果為str資料型別，如須做其他操作可進行資料轉換

輸出

1. 默認輸出

print('hello, world')

2. 占位符輸出

# %s 的s表示變數的資料型別
print('名字：%s，年齡：%s，性別：%s' % (name, age, sex)) 

3. 推薦使用

print(f'名字：{name}，年齡：{age}，性別：{sex}')

算數運算子

+ - * / ** // %

前四個同其他編程語言用法相同

---

** 表示平方計算 5 ** 2 === 5的2次方
// 表示做除運算后取整
% 取余運算

簡寫形式
+= -= *= /= **= //+ %=

---

注：
+ 也可用于字串拼接
* 當任意一邊為字串時，則表示重復字串

常用運算函式

round(num, count) 表示對num四舍五入，并保留小數點后count位

比較運算子

> < >= <= = !=

常用函式

• ord(chr) 回傳該chr的ASCII碼(只能為單個字符)
• chr(num) 回傳該ASCII對應的字符

邏輯運算子

and ，or ， not

運算子	含義
and	真真為真，其他為假（第一項為真則回傳第二項的值，如第一項為假則回傳第一項的值）
or	假假為假，其他為真（第一項為真，則回傳第一項的值，如第一項為假，則回傳第二項的值）
not	取反

成員運算子

in ，not in

運算子	含義	示例
in	判斷某字符是否存在于某字串	'h' in 'hello'
not in	判斷某字符是否不存在于某字串	'h' not in 'hello'

分支

單分支

# 注意縮進
if bool運算式:  
    print('執行')  

雙分支

# 注意縮進
if bool運算式:  
    print('執行陳述句1')  
else:
    print('執行陳述句2')

分支嵌套

# 注意縮進
if bool運算式:  
    if bool運算式2:
        print('執行嵌套陳述句')
    else:
        print('執行陳述句1')  
else:
    print('執行陳述句2')

多分支

# 注意縮進
if bool運算式1:  
    print('執行陳述句1')  
elif bool運算式2:
    print('執行陳述句2')
elif bool運算式...:
    print('執行陳述句...')
else: 
    print('如上都不滿足，則執行這條陳述句')

回圈

回圈控制

只能在回圈陳述句中使用，只對距離最近的回圈起作用

break # 跳出本回圈
continue # 結束本次回圈，執行下一次回圈 

while回圈

# 注意判斷條件
while bool運算式:
    print('執行陳述句')

for回圈

# range(start, end, rule) 從start開始，到end-1，間隔為rule,rule的正負表示正序或倒序
# range(1, 11) 輸出1~10，不包括最大值11
# range(1, 11, 2) 輸出1~10，不包括最大值11, 第三個引數表示為每次間隔2
# range(11, 1, -2) 輸出11~2，不包括最小值值1, 第三個引數為負數，則表示為倒序且每次間隔2
# range(5) 簡寫形式，0~5的范圍

for i in range(1,11):
    print(i)

回圈else結構

只有回圈完整執行完畢后，才會執行else陳述句
當回圈程序中執行break陳述句后，else將不執行

# while  
while bool運算式:  
    print('執行陳述句')
else:
    print('while  else陳述句')
    
# for  
for i in range(10):  
    print('執行陳述句')
else:
    print('for  else陳述句')

串列

物件是存盤單個資料的容器，而串列（陣列）就是存盤多個資料的容器，任何資料型別都可以存放

# 字面量創建新串列
lst = [1,'2','三']

# 使用list函式創建新串列
lst = list([1,'2','三'])

串列的取值

1. 通過索引下標取值
2. 使用for回圈

獲取元素的下標

1. list.index(‘元素’) 找不到元素則拋出例外， 可預先使用in方法判斷是否存在

獲取串列中多個元素（切片）

list[start:end:step]
從start索引位置開始，截取到end-1位置結束，步長為step

其中step可為負值，表示從start位置往左邊截取開始

start默認值為0
end默認值為串列長度
step默認值為1

省略引數但 : 必須存在 list[::]

串列的增刪改操作

增加

• append(item)
  在原有的串列末尾添加一個元素

lst = [10, 20, 30] 
lst.append(100)
print(lst) # [10, 20, 30, 100] 

• extend( [] )
  在原有的串列末尾至少添加一個元素，添加元素必須是串列（添加多個）

lst = [10, 20, 30] 
lst.extend([99, 100])
print(lst) # [10, 20, 30, 99, 100] 

• insert(index, item)
  在原有的串列指定位置添加一個元素

lst = [10, 20, 30] 
lst.insert(1, 99)
print(lst) # [10, 99, 20, 30] 

• 切片添加多個元素(指定位置添加多個元素)
  使用切片把選擇到的元素替換掉

lst = [10, 20, 30] 
lst[1:] = [99]
print(lst) # [10, 99]

洗掉

• remove(item)
  在原有的串列洗掉一個元素，如果有重復元素只洗掉一個，如果元素不存在則拋出例外

lst = [10, 20, 30] 
lst.remove(20)
print(lst) # [10, 30] 

• pop(index)
  洗掉指定索引位置的元素，如果指定索引不存在則拋出例外
  不傳index，則洗掉末尾元素

lst = [10, 20, 30] 
lst.pop(1)
print(lst) # [10, 30] 

• clear()
  清空串列

lst = [10, 20, 30] 
lst.clear()
print(lst) # []  

• 切片洗掉元素
  使用切片把選擇到的元素替換為空

lst = [10, 20, 30] 
lst[1:] = []
print(lst) # [10]

• 洗掉串列，即釋放記憶體（謹慎使用）

lst = [10, 20, 30] 
del lst
print(lst) # 會拋出例外， lst is not defined

修改

• 直接重新賦值

lst = [10, 20, 30] 
lst[1] = 40
print(lst) # [10, 40, 30]  

• 切片修改（批量修改）

lst = [10, 20, 30] 
lst[1:3] = [40, 50, 60]
print(lst) # [10, 40, 50, 60]  

串列的排序

• sort()
  在原串列的基礎上排序
  傳入reserse=True降序排序
  傳入reserse=False生序升序
  不傳默認升序

# sotr()  
lst = [9, 3, 2, 8] 
lst.sort()  
print(lst) # [2, 3, 8, 9]  

# sotr(reserse=True)  
lst = [9, 3, 2, 8] 
lst.sort(reserse=True)  
print(lst) # [9, 8, 3, 2]

# sotr(reserse=False)  
lst = [9, 3, 2, 8] 
lst.sort(reserse=False)  
print(lst) # [2, 3, 8, 9]  

• sorted(lst[,rule ])
  使用內置函式sorted()進行排序，將產生一個新串列物件
  傳入第二引數reserse=True降序排序
  傳入第二引數reserse=False生序升序
  不傳第二引數默認升序

# sorted(lst)  
lst = [9, 3, 2, 8] 
new_list = sorted(lst)  
print(new_list) # [2, 3, 8, 9]  

# sorted(lst, reserse=True) 
lst = [9, 3, 2, 8] 
new_lsit = sorted(lst, reserse=True)  
print(new_list) # [9, 8, 3, 2]

# sorted(lst, reserse=False)  
lst = [9, 3, 2, 8] 
new_lsit = sorted(lst, reserse=False)   
print(new_list) # [2, 3, 8, 9]  

串列生成式

• [i for i in renge(1, 11)]
  串列生成的運算式

lst = [i*i for i in renge(1, 6)]
print(lst) # [1, 4, 9, 16, 25]

串列常用函式

• len(list)：串列元素個數
• max(list)：回傳串列元素最大值
• min(list)：回傳串列元素最小值

字典（物件）

python的內置資料結構之一，以鍵值對的方式存盤資料，在其他語言中也叫物件，

字典的創建方式

• info = {'name':'zzl', 'age':18}
• info = dict(name='zzl', age=18)

字典的常用操作

• 獲取字典中的元素

info = {'name':'zzl', 'age':18}  

# []方式
print(info['name']) # zzl  
print(info['sex']) # error: keyError 

# get()方式
print(info.get('name')) # zzl
print(info.get('sex')) # None  
print(info.get('sex', '男')) # 如果sex欄位為None的話，則列印 '男' 默認值

• key的判斷
  in, not in

info = {'name':'zzl', 'age':18}  

# in
print('name' in info) # True  

# not in
print('sex' nor in info) # True

• key的洗掉

info = {'name':'zzl', 'age':18}  

del info['name'] # 洗掉name欄位
print(info) # {'age':18}

info.clear() # 清空該字典  
print(info) # {}

• 新增key

info = {'name':'zzl', 'age':18}  
info['sex'] = '男'
print(info) # {'name':'zzl', 'age':18, 'sex':'男'}  

• 修改key

info = {'name':'zzl', 'age':18}  
info['age'] = 20
print(info) # {'name':'zzl', 'age':20}  

獲取字典的試圖方法

• keys()
  回傳字典的所有key組成的串列

info = {'name':'zzl', 'age':18}  
keys = info.keys()
print(keys) # ['age', 'name']

• values()
  回傳字典的所有value組成的串列

info = {'name':'zzl', 'age':18}  
values = info.value()
print(values) # [18, 'zzl']

• items()
  回傳字典的所有key:value組成的串列

info = {'name':'zzl', 'age':18}  
itmes = info.items()
print(items) # [('age', 18), ('name', 'zzl')]

字典的遍歷

info = {'name':'zzl', 'age':18}  

for item in info:
    print(item，info[item])
# age 'zzl'
# name 18

字典的生成式

items = ['Fruits', 'Books', 'Others'] 
prices = [98, 97, 95] 
d = { item:price for item, price in zip(items, prices) }
print(d) # {'Others': 95, 'Books': 97, 'Fruits': 98}

字典的特點

1. 字典中的所有元素都是一個key-value對，key不允許重復，value可以重復
2. 字典中的元素是無序的
3. 字典中的key必須是不可變物件，（即key不能為變數）
4. 字典也可以根據需要動態的伸縮
5. 字典會浪費較大的記憶體，是一種使用空間換時間的資料結構

元組

串列的另一種形式，是不可變序列

元組的創建方式

# 直接用小括號書寫
t = ('python', 'world', '20') 

# 使用內置函式tuple() 
t1 = tuple( ('python', 'world', '20') )

t3 = ('python',) # 如果元組只有一個元素，則在元素后面加上 ，  

# 獲取元組的元素
t[0] # python

元組的遍歷

t = ('python', 'world', '20') 

for item in t:
    print(item)
# python
# world 
# 20

注：

1. 如果元組中物件本身是不可變物件，則不能再參考其他物件
2. 如果元組中的物件是可變物件，則可變物件的參考不允許改變，但資料可以改變

集合

python語言提供的內置資料結構
與串列、字典都屬于可變型別的序列
集合是沒有value的字典
集合的存盤是無序的

集合的創建

# 集合的value不能重復
s = {2, 3, 4, 5, 2, 4} 
print(s)  # {2,3,4,5}

# set()函式  
s1 = set(range(6)) 
print(s1) # set([0, 1, 2, 3, 4, 5])

s2 = set([1,2,3,5,6,4,3])
print(s2) # set([1, 2, 3, 4, 5, 6])

s3 = set((1,23,5,32,1))
print(s3) # set([32, 1, 5, 23])

s4 = set('python')  
print(s4) # set(['h', 'o', 'n', 'p', 't', 'y'])

s5 = set({12,4,23,4,12})  
print(s5) # set([12, 4, 23])

# 定義集合
s6 = set()

集合的常用操作

s = {10, 20, 30, 40, 50}   

# 判斷是否存在
print(10 in s) # True   
print(70 in s) # False

# 新增  
s.add(80) 
print(s) # {10, 20, 30, 40, 50, 80}  

# 新增多個  
s.update({200, 400})  
print(s) # {10, 20,, 200, 30, 40, 50, 400, 80}  

# 洗掉  
s.remove(10) 
print(s) # {20,, 200, 30, 40, 50, 400, 80} 
s.remove(900) # error: keyError
s.discard(900) # 如果有則洗掉900， 沒有也不會報錯
s.pop() # 隨機洗掉一個， 不能傳參  
s.clear() # 清空集合

集合間的關系

兩個集合是否相等（判斷集合中的元素是否完全相等）

s1 = {10, 20, 30, 40}
s2 = {20, 40, 10, 20} 
print(s1 == s2) # True
print(s1 != s2) # False

一個集合是否是另一個集合的子集

假如集合s1的元素里包括集合s2的全部元素，則s2是s1的子集

s1 = {10, 20, 30, 40}
s2 = {20, 40} 
print(s2.issubset(s1)) # True

一個集合是否是另一個集合的超集

與上相反，假如集合s1的元素里包括集合s2的全部元素，則s1是s2的超集

s1 = {10, 20, 30, 40}
s2 = {20, 40} 
print(s1.issuperset(s2)) # True

一個集合和另一個集合是否無交集

如果一個集合里某個元素，在另一個集合里也有存盤，則兩個集合有交集

s1 = {10, 20, 30, 40}
s2 = {80, 60} 
print(s1.isdisjoint(s2)) # False 無交集

字串的常用操作

字串的查詢操作方法

方法名稱	作用
index()	查找子串第一次出現的位置，如果查找的子串不存在時，則拋出ValueError
rindex()	查找子串最后一次出現的位置，如果查找的子串不存在時，則拋出ValueError
find()	查找子串第一次出現的位置，如果查找的子串不存在時，則回傳-1
rfind()	查找子串最后一次出現的位置，如果查找的子串不存在時，則回傳-1

字串的大小寫轉換操作的方法

方法名稱	作用
upper()	把字串中所有字符都轉成大寫字母
lower()	把字串中所有字符都轉成小寫字母
swapcase()	把字串中所有大寫字母轉成小寫字母，把所有小寫字母轉成大寫字母
capitalize()	把第一個字符轉換為大寫，其余字符小寫
title()	把每個單詞的第一個字符轉換為大寫，把每個單詞的剩余字符轉換為小寫

字串內容對齊操作的方法

方法名稱	作用
center()	居中對齊，第一個引數指定寬度，第二個引數指定填充符，第二個引數是可選的，默認是空格，如果設定寬度小于實際寬度，則回傳原字串
ljust()	左對齊，第一個引數指定寬度，第二個引數指定填充符，第二個引數是可選的，默認是空格，如果設定寬度小于實際寬度，則回傳原字串
rjust()	右對齊，第一個引數指定寬度，第二個引數指定填充符，第二個引數是可選的，默認是空格，如果設定寬度小于實際寬度，則回傳原字串
zfill()	右對齊，左邊用0填充，該方法只接收一個引數，用于指定字串的寬度，如果設定寬度小于實際寬度，則回傳原字串

字串分割操作的方法

方法名稱	作用
split(cha, max)	從字串的左邊開始分割，默認分割符是空格，回傳值是一個串列，第一個引數為分割符，第二個引數為最大分割次數
split(cha, max)	從字串的右邊開始分割，默認分割符是空格，回傳值是一個串列，第一個引數為分割符，第二個引數為最大分割次數

判斷字串操作的方法

方法名稱	作用
isidentifier()	判斷指定字串是不是合法的識別符號
isspace()	判斷指定字串是否由空白字符組成（回車、換行、水平制表符tab）
isalpha()	判斷指定字串是否全部由字母組成
isdecimal()	判斷指定字串是否全部由十進制的數字組成
isnumeric()	判斷指定字串全部由數字組成
isalnum()	判斷指定字串是否全部由字母和數字組成

字串操作的其他方法

方法名稱	作用
replace()	第1個引數指定被替換的子串 第2個引數指定替換子串的字串 該方法回傳替換后的字串，替換前的字串不會發生變化 該方法的第3個引數可以指定最大替換次數
cha.join(lst)	用cha將串列后元組的字串合并成一個字串，使用方法為cha.join(lst)

字串格式化操作

# %s 的s表示資料型別  s:字串  i:整數
print('我叫%s，我今年%i歲' % ('zzl', 18)) # 我叫zzl，我今年18歲'

# {}里的數字表示后面變數的索引，可重復使用
print('我叫{0}，我今年{1}歲，我真的叫{0}'.format('zzl', 18)) # 我叫zzl，我今年18歲，我真的叫zzl'

# 前面加f  可在{}中直接填寫變數
print(f'我叫{'zzl'}，我今年{18}歲') # 我叫zzl，我今年18歲'

字串編碼和解碼操作

# 編碼

s = '好好學習，天天向上'
# 使用GBK格式進行編碼, 此格式中，一個中文占兩個位元組
print(s.encode(encoding='GBK')) #b'\xba\xc3\xba\xc3\xd1\xa7\xcf\xb0\xa3\xac\xcc\xec\xcc\xec\xcf\xf2\xc9\xcf'

# 使用UTF-8格式進行編碼 此格式中，一個中文占三個位元組
print(s.encode(encoding='UTF-8')) #b'\xe5\xa5\xbd\xe5\xa5\xbd\xe5\xad\xa6\xe4\xb9\xa0\xef\xbc\x8c\xe5\xa4\xa9\xe5\xa4\xa9\xe5\x90\x91\xe4\xb8\x8a'



# 解碼  （使用什么格式編碼，就必須使用什么格式解碼，否則會報錯）

# 使用GBK格式進行編碼
print(s.encode(encoding='GBK').decode(encoding='GBK')) # 好好學習，天天向上

# 使用UTF-8格式進行編碼
print(s.encode(encoding='UTF-8').decode(encoding='UTF-8')) # 好好學習，天天向上

函式

函式的定義和使用

# 定義
def 函式名(a, b): # 引數a和b
    函式體  
    return  # 回傳值  
    
# 使用  
函式名()  

# 代碼演示  
def cals(a, b):
    c = a + b 
    return c
    
res = cals(20, 30) # 50  

函式的引數傳遞

• 位置傳參，cals(20, 30) ，此時a的值是20， b的值是30
• 關鍵字傳參， cals(b=70, a=30) 此時a的值是30， b的值是70

函式的回傳值

1. 如果函式沒有回傳值（函式執行完畢之后，不需要給呼叫處提供資料）,return可以省略不寫
2. 函式的回傳值，如果是1個，直接回傳原值
3. 函式的回傳值，如果是多個，回傳的結果為元組

def fun(lst):
    odd = [] # 存放奇數  
    even = [] # 存放偶數
    for i in lst:
        if (i%2) :
            odd.append(i)
        else:
            even.append(i)
    return odd,even

lst = [10, 23, 65, 78, 32, 77] 
print(fun(lst)) # ([23, 65, 77], [10, 78, 32])

函式的默認值

在定義函式的時候，可以給形參賦上默認值，當沒傳引數的時候，函式會取默認值，如果傳參和默認值同時存在，傳的引數會替換掉默認值

def cals(a, b = 10):
    c = a + b 
    return c
    
res = cals(20) # 30  
res = cals(20, 30) # 50

函式的引數定義

• 個數可變的位置引數
  定義函式時，可能無法確定傳遞的實參個數，這個時候就要使用可變的位置形參，使用*定義，結果為一個元組

def fun(*args);
    print(args)

fun(1)  # (1,)
fun(1,2,3)  # (1, 2, 3)

• 個數可變的關鍵字引數（指定引數名傳遞引數）
  定義函式時，可能無法確定傳遞的關鍵字實參個數，這個時候就要使用可變的關鍵字形參，使用*定義，結果為一個字典

def fun(**args);
    print(args)

fun(a=10)  # {'a':10}
fun(a=10, b=20, c=30)  # {'a':10, 'b':20, 'c':30}

以上引數在函式定義時，一種方式只能定義一次，
當兩種引數定義方式同時存在時，位置形參必須在關鍵字形參前面

python例外處理機制

例外捕獲

try:
    可能出現例外的陳述句放在這里 
except 你要捕獲的例外型別:
    捕獲到例外后你想做什么
except 你要捕獲的例外型別:
    捕獲到例外后你想做什么
...
except BaseException as e: # 這種情況是以上例外型別都沒捕獲到，則執行這塊代碼
    print('出錯了', e)
print('程式照常執行')

例外捕獲else

try:
    可能出現例外的陳述句放在這里 
except 你要捕獲的例外型別:
    捕獲到例外后你想做什么
except 你要捕獲的例外型別:
    捕獲到例外后你想做什么
...
except BaseException as e: # 這種情況是以上例外型別都沒捕獲到，則執行這塊代碼
    print('出錯了', e)
else:
    print('如果沒有例外則執行else部分')

try…except…else…finally結構

try:
    a = int(input('請輸入第一個整數'))
    b = int(input('請輸入另一個整數'))
    res = a/b
except BaseException as e:
    print('出錯了', e)
else:
    print('結果為:'res)
finlly:
    print('無論是否產生例外，總會被執行的代碼')

python常見的例外型別

例外型別	描述
ZeroDivisionError	除零or向零取余
IndexError	序列中沒有此索引
KeyError	映射中沒有這個鍵
NameError	未宣告or未定義
SyntaxError	語法錯誤
ValueError	傳入無效的引數

類與物件

類的創建

• 類屬性: 類中方法外的變數稱為類屬性，被該類的所有實體物件共享
• 類方法: 使用@classmethod修飾的方法，可使用類名直接訪問
• 靜態方法: 使用@staticmethod修飾的方法，可使用類名直接訪問

# Stubent為類的名稱，由一個或多個單詞組成，（建議類名書寫方式為每個單詞首字母大寫）
class Student:
    native_pace = '河南' # 直接寫在類里的變數，稱為屬性
    
    # 初始化函式( 建構式 )
    def __init__(self, name ,age):
        # 創建實體的時候 對name和age屬性進行賦值
        self.name = name
        self.age = age
    
    # 定義在類里面的方法為實體方法
    def eat(self):
        print('吃飯')
    
    # 靜態方法 （靜態方法里不允許寫self）
    @staticmethod 
    def method():
        print('使用staticmethod進行修飾，所以我是靜態方法')
        
        
    # 類方法
    @classmethod 
    def cm(cls):
        print('使用calssmethod進行修飾，所以我是類方法')
    

類實體物件

# 類實體創建語法  stu = Student()
# 假設已存在上面的 Student 類  

# stu1就是Student類的實體物件，該實體物件中可以訪問到類中的屬性和方法
stu1 = Student('zzl', 18) # 創建實體
print(stu1.name) # zzl
print(stu1.age) # 18
stu1.eat() # 吃飯

動態系結屬性和方法

# 假設已存在Student類  
stu = Student('zzl', 18)  

# 系結 gender 屬性 
stu.gender = '男' 
print(stu.gender) # 男

# 系結 show 方法
def show():
    print('show方法執行')
stu.show = show
stu.show() # show方法執行

面向物件的三大特征

• 封裝 （提高程式的安全性）
  將資料（屬性）和行為（方法）封裝到類物件中，在方法內部對屬性進行操作，在類物件的外部呼叫方法，這樣無需關心方法內部的具體實作細節，從而隔離了復雜度，在python中沒有專門的修飾符用戶屬性的私有化，如果該屬性不想被類物件訪問，可以在屬性名前面加兩個 ‘_’

• 繼承

• 多型

代碼演示

# 繼承
class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def info(self):
        print(self.name, self.age)


class Student(Person):
    def __init__(self, name, age, stu_no):
        super().__init__(name, age)
        self.stu_no = stu_no


class Teacher(Person):
    def __init__(self, name, age, teachofyear):
        super().__init__(name, age)
        self.teachofyear = teachofyear


stu = Student('張三', 20, 10001)
teacher = Teacher('李四', 35, 10)

stu.info() # 張三 20
teacher.info() # 李四 35

# python 支持多繼承 
class A(class1, class2):  
    pass
    
# 方法重寫  
# 方法重寫就是在子類里定義與父類重名的方法，這樣就會優先呼叫子類的定義的方法

模塊和包

定義：每一個.py檔案就是一個模塊

使用模塊化的好處

1. 方便其他程式和腳本的匯入使用
2. 避免函式名和變數名沖突
3. 提高代碼的可維護性
4. 提高代碼的可重用性

匯入模塊

# 匯入模塊
import 模塊名稱 [as 別名]  

# 匯入模塊中的指定函式(or 變數 or 類)
from 模塊名稱 import 函式/變數/類

包

包是一個分層次的目錄結構，它將一組功能相近的模塊組織在一個目錄下

作用

1. 代碼規范
2. 避免模塊名稱沖突

包與目錄的區別

1. 包含__init__.py檔案的目錄稱為包
2. 目錄里通常不存在__init__.py檔案

包的匯入
import 包名.模塊名

檔案的讀寫

內置函式open()創建檔案物件

# file = open( filename, [mode, encoding] )

# 假設有一個名為a的文本檔案，里面有hello world
file = open('a.txt', 'r')
print(file.readlines()) # ['hello world']
file.close()

常用的檔案打開模式

打開模式	描述
r	以只讀模式打開檔案，檔案的指標將會放在檔案的開頭
w	以只寫模式打開檔案，如果檔案不存在則創建，如果檔案存在，則覆寫原有內容，檔案指標在檔案的開頭
a	以追加模式打開檔案，如果檔案不存在則創建，檔案指標在檔案開頭，如果檔案存在，則在檔案末尾追加內容
b	以二進制方式打開檔案，不能單獨使用，需要與其他模式一起使用，rb,后者wb
+	以讀寫方式打開檔案，不能單獨使用，需要與其他模式一起使用，如a+

檔案物件的常用方法

方法名	描述
read([size])	從檔案中讀取size個位元組或字符的內容回傳，若省略size，則讀取到檔案末尾，即一次讀取檔案所有內容
readline()	從文本檔案中讀取一行內容
readlines()	把文本檔案中每一行都作為獨立的字串物件，并將這些物件放入串列回傳
write(str)	將字串str內容寫入檔案
writelines(s_list)	將字串串列s_list寫入文本檔案，不添加換行符
seek(offset[, whence])	把檔案指標移動到新的位置，offset表示相對與whence的位置： offset：為正則往結束方向移動，為負則往開始方向移動 whence不同的值代表不同含義： 0：從檔案頭開始計算（默認值） 1：從當前位置開始計算 2：從檔案末尾開始計算
tell()	回傳檔案指標的當前位置
flush()	把緩沖區的內容寫入檔案，但不關閉檔案
close()	把緩沖區的內容寫入檔案，同時關閉檔案，釋放檔案物件相關資源

with陳述句（背景關系管理器）

with陳述句可以自動管理背景關銑澩，不論什么原因跳出with陳述句都能確保檔案正確的關閉，以此來達到釋放資源的目的

# with使用  
with open(filename, mode) as file:
    pass 

目錄操作 （os 和 os.path）

1. os模塊是python內置的與作業系統功能和檔案系統相關的模塊，該模塊中的陳述句的執行結果通常與作業系統有關，在不同的作業系統上運行，得到的結果可能不一樣
2. os模塊與os.path模塊用于對目錄或檔案進行操作

import os
# 打開計算器
os.system('calc.exe')
# 打開記事本
os.system('notepad.exe')

# 打開可執行檔案
os.startfile('路徑')

os模塊操作目錄相關函式

函式	說明
getcwd()	回傳當前的作業目錄
listdir(path)	回傳指定路徑下的檔案和目錄資訊
mkdir(path[, mode])	創建目錄
makedirs(path1/path2…[, mode])	創建多級目錄
rmdir(path)	洗掉目錄
removedirs(path1/path2…)	洗掉多級目錄
chdir(path)	將path設定為當前作業目錄

os.path模塊操作目錄相關函式

函式	說明
abspath(path)	用于獲取檔案或目錄的絕對路徑
exists(path)	用于判斷檔案或目錄是否存在，如果存在回傳True,否則回傳False
join(path, name)	將目錄與目錄，或者目錄與檔案名連接起來
split(path)	分離目錄和檔案名
splittext(name)	分離檔案名和擴展名
basename(path)	從一個目錄中提取檔案名
dirname(path)	從一個路徑中提取檔案路徑，不包括檔案名
isdir(path)	判斷是否為路徑

python內置模塊

使用import關鍵字引入

模塊	描述
random	亂數生成
traceback	處理例外
sys	與python解釋器及環境操作相關的標準庫
time	提供與時間相關的各種函式的標準庫
os	提供了訪問作業系統服務功能的標準庫
calendar	提供與日期相關的各種函式的標準庫
urllib	用于讀取來自網上（服務器）資料的標準庫
json	用于使用JSON序列化和反序列化物件
re	用于在字串中執行正則運算式匹配和替換
math	提供標準算術運算函式的標準庫
decimal	用于進行精準控制運算精度、有效數位和四舍五入操作的十進制運算
logging	提供了靈活的記錄事件、錯誤、警告和除錯資訊等日志資訊的功能