Python/ target=_blank class=infotextkey>Python基礎知識
建議有程序語言基礎的童鞋閱讀，零基礎閱讀可能會有點費解
文章目錄
Python基礎知識注釋方法數據類型輸入和輸出輸入輸出算數運算符常用運算函數比較運算符邏輯運算符成員運算符分支循環列表列表的取值獲取元素的下標獲取列表中多個元素（切片）列表的增刪改操作增加刪除修改列表的排序列表生成式列表常用函數字典（對象）字典的創建方式字典的常用操作獲取字典的試圖方法字典的遍歷字典的生成式元組元組的創建方式元組的遍歷集合集合的創建集合的常用操作集合間的關系字符串的常用操作字符串的查詢操作方法字符串的大小寫轉換操作的方法字符串內容對齊操作的方法字符串分割操作的方法判斷字符串操作的方法字符串操作的其他方法字符串格式化操作字符串編碼和解碼操作函數函數的定義和使用函數的返回值函數的默認值函數的參數定義python異常處理機制異常捕獲異常捕獲
elsetry...except...else...finally結構python常見的異常類型類與對象類的創建類實例對象動態綁定屬性和方法面向對象的三大特征模塊和包導入模塊包文件的讀寫內置函數open()創建文件對象常用的文件打開模式文件對象的常用方法with語句（上下文管理器）目錄操作 （os 和 os.path）python內置模塊
注釋方法
# 單行注釋
''' 多行注釋 '''
數據類型
關鍵字名稱示例chr單個字符'', 'd'str字符串（多個chr）'dd', '你好'int整數1,2,3,4float浮點數3.1415926bool布爾Ture, Falselist列表[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數據類型，如須做其他操作可進行數據轉換
輸出
- 默認輸出
print('hello, world')
1
- 占位符輸出
# %s 的s表示變量的數據類型
print('名字：%s，年齡：%s，性別：%s' % (name, age, sex))
12
- 推薦使用
print(f'名字：{name}，年齡：{age}，性別：{sex}')
1
算數運算符
+ - * / ** // %
前四個同其他編程語言用法相同
** 表示平方計算 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('執行')
123
雙分支
# 注意縮進
if bool表達式:
print('執行語句1')
else:
print('執行語句2')
12345
分支嵌套
# 注意縮進
if bool表達式:
if bool表達式2:
print('執行嵌套語句')
else:
print('執行語句1')
else:
print('執行語句2')
12345678
多分支
# 注意縮進
if bool表達式1:
print('執行語句1')
elif bool表達式2:
print('執行語句2')
elif bool表達式...:
print('執行語句...')
else:
print('如上都不滿足，則執行這條語句')
123456789
循環
循環控制
只能在循環語句中使用，只對距離最近的循環起作用
break # 跳出本循環
continue # 結束本次循環，執行下一次循環
12
while循環
# 注意判斷條件
while bool表達式:
print('執行語句')
123
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)
123456789
循環else結構
只有循環完整執行完畢后，才會執行else語句
當循環過程中執行break語句后，else將不執行
# while
while bool表達式:
print('執行語句')
else:
print('while else語句')
# for
for i in range(10):
print('執行語句')
else:
print('for else語句')
1234567891011
列表
對象是存儲單個數據的容器，而列表（數組）就是存儲多個數據的容器，任何數據類型都可以存放
# 字面量創建新列表
lst = [1,'2','三']
# 使用list函數創建新列表
lst = list([1,'2','三'])
12345
列表的取值
- 通過索引下標取值
- 使用for循環
獲取元素的下標
- 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]
123
extend( [] )
在原有的列表末尾至少添加一個元素，添加元素必須是列表（添加多個）
lst = [10, 20, 30]
lst.extend([99, 100])
print(lst) # [10, 20, 30, 99, 100]
123
insert(index, item)
在原有的列表指定位置添加一個元素
lst = [10, 20, 30]
lst.insert(1, 99)
print(lst) # [10, 99, 20, 30]
123
- 切片添加多個元素(指定位置添加多個元素)
使用切片把選擇到的元素替換掉
lst = [10, 20, 30]
lst[1:] = [99]
print(lst) # [10, 99]
123
刪除
remove(item)
在原有的列表刪除一個元素，如果有重復元素只刪除一個，如果元素不存在則拋出異常
lst = [10, 20, 30]
lst.remove(20)
print(lst) # [10, 30]
123
pop(index)
刪除指定索引位置的元素，如果指定索引不存在則拋出異常
不傳index，則刪除末尾元素
lst = [10, 20, 30]
lst.pop(1)
print(lst) # [10, 30]
123
clear()
清空列表
lst = [10, 20, 30]
lst.clear()
print(lst) # []
123
- 切片刪除元素
使用切片把選擇到的元素替換為空
lst = [10, 20, 30]
lst[1:] = []
print(lst) # [10]
123
- 刪除列表，即釋放內存（謹慎使用）
lst = [10, 20, 30]
del lst
print(lst) # 會拋出異常， lst is not defined
123
修改
- 直接重新賦值
lst = [10, 20, 30]
lst[1] = 40
print(lst) # [10, 40, 30]
123
- 切片修改（批量修改）
lst = [10, 20, 30]
lst[1:3] = [40, 50, 60]
print(lst) # [10, 40, 50, 60]
123
列表的排序
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]
1234567891011121314
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]
1234567891011121314
列表生成式
[i for i in renge(1, 11)]
列表生成的表達式
lst = [i*i for i in renge(1, 6)]
print(lst) # [1, 4, 9, 16, 25]
12
列表常用函數
- 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的話，則打印 '男' 默認值
12345678910
- key的判斷
in, not in
info = {'name':'zzl', 'age':18}
# in
print('name' in info) # True
# not in
print('sex' nor in info) # True
1234567
- key的刪除
info = {'name':'zzl', 'age':18}
del info['name'] # 刪除name字段
print(info) # {'age':18}
info.clear() # 清空該字典
print(info) # {}
1234567
- 新增key
info = {'name':'zzl', 'age':18}
info['sex'] = '男'
print(info) # {'name':'zzl', 'age':18, 'sex':'男'}
123
- 修改key
info = {'name':'zzl', 'age':18}
info['age'] = 20
print(info) # {'name':'zzl', 'age':20}
123
獲取字典的試圖方法
keys()
返回字典的所有key組成的列表
info = {'name':'zzl', 'age':18}
keys = info.keys()
print(keys) # ['age', 'name']
123
values()
返回字典的所有value組成的列表
info = {'name':'zzl', 'age':18}
values = info.value()
print(values) # [18, 'zzl']
123
items()
返回字典的所有key:value組成的列表
info = {'name':'zzl', 'age':18}
itmes = info.items()
print(items) # [('age', 18), ('name', 'zzl')]
123
字典的遍歷
info = {'name':'zzl', 'age':18}
for item in info:
print(item，info[item])
# age 'zzl'
# name 18
123456
字典的生成式
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}
1234
字典的特點
- 字典中的所有元素都是一個key-value對，key不允許重復，value可以重復
- 字典中的元素是無序的
- 字典中的key必須是不可變對象，（即key不能為變量）
- 字典也可以根據需要動態的伸縮
- 字典會浪費較大的內存，是一種使用空間換時間的數據結構
元組
列表的另一種形式，是不可變序列
元組的創建方式
# 直接用小括號書寫
t = ('python', 'world', '20')
# 使用內置函數tuple()
t1 = tuple( ('python', 'world', '20') )
t3 = ('python',) # 如果元組只有一個元素，則在元素后面加上 ，
# 獲取元組的元素
t[0] # python
12345678910
元組的遍歷
t = ('python', 'world', '20')
for item in t:
print(item)
# python
# world
# 20
12345678
注：
- 如果元組中對象本身是不可變對象，則不能再引用其他對象
- 如果元組中的對象是可變對象，則可變對象的引用不允許改變，但數據可以改變
集合
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()
1234567891011121314151617181920212223
集合的常用操作
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() # 清空集合
123456789101112131415161718192021
集合間的關系
兩個集合是否相等（判斷集合中的元素是否完全相等）
s1 = {10, 20, 30, 40}
s2 = {20, 40, 10, 20}
print(s1 == s2) # True
print(s1 != s2) # False
1234
一個集合是否是另一個集合的子集
假如集合s1的元素里包括集合s2的全部元素，則s2是s1的子集
s1 = {10, 20, 30, 40}
s2 = {20, 40}
print(s2.issubset(s1)) # True
123
一個集合是否是另一個集合的超集
與上相反，假如集合s1的元素里包括集合s2的全部元素，則s1是s2的超集
s1 = {10, 20, 30, 40}
s2 = {20, 40}
print(s1.issuperset(s2)) # True
123
一個集合和另一個集合是否無交集
如果一個集合里某個元素，在另一個集合里也有存儲，則兩個集合有交集
s1 = {10, 20, 30, 40}
s2 = {80, 60}
print(s1.isdisjoint(s2)) # False 無交集
123
字符串的常用操作
字符串的查詢操作方法
方法名稱作用index()查找子串第一次出現的位置，如果查找的子串不存在時，則拋出ValueErrorrindex()查找子串最后一次出現的位置，如果查找的子串不存在時，則拋出ValueErrorfind()查找子串第一次出現的位置，如果查找的子串不存在時，則返回-1rfind()查找子串最后一次出現的位置，如果查找的子串不存在時，則返回-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歲'
123456789
字符串編碼和解碼操作
# 編碼
s = '好好學習，天天向上'
# 使用GBK格式進行編碼, 此格式中，一個中文占兩個字節
print(s.encode(encoding='GBK')) #b'xbaxc3xbaxc3xd1xa7xcfxb0xa3xacxccxecxccxecxcfxf2xc9xcf'
# 使用UTF-8格式進行編碼 此格式中，一個中文占三個字節
print(s.encode(encoding='UTF-8')) #b'xe5xa5xbdxe5xa5xbdxe5xadxa6xe4xb9xa0xefxbcx8cxe5xa4xa9xe5xa4xa9xe5x90x91xe4xb8x8a'
# 解碼 （使用什么格式編碼，就必須使用什么格式解碼，否則會報錯）
# 使用GBK格式進行編碼
print(s.encode(encoding='GBK').decode(encoding='GBK')) # 好好學習，天天向上
# 使用UTF-8格式進行編碼
print(s.encode(encoding='UTF-8').decode(encoding='UTF-8')) # 好好學習，天天向上
12345678910111213141516171819
函數
函數的定義和使用
# 定義
def 函數名(a, b): # 參數a和b
函數體
return # 返回值
# 使用
函數名()
# 代碼演示
def cals(a, b):
c = a + b
return c
res = cals(20, 30) # 50
1234567891011121314
函數的參數傳遞
位置傳參，cals(20, 30) ，此時a的值是20， b的值是30
關鍵字傳參， cals(b=70, a=30) 此時a的值是30， b的值是70
函數的返回值
- 如果函數沒有返回值（函數執行完畢之后，不需要給調用處提供數據）,return可以省略不寫
- 函數的返回值，如果是1個，直接返回原值
- 函數的返回值，如果是多個，返回的結果為元組
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])
123456789101112
函數的默認值
在定義函數的時候，可以給形參賦上默認值，當沒傳參數的時候，函數會取默認值，如果傳參和默認值同時存在，傳的參數會替換掉默認值
def cals(a, b = 10):
c = a + b
return c
res = cals(20) # 30
res = cals(20, 30) # 50
123456
函數的參數定義
- 個數可變的位置參數
定義函數時，可能無法確定傳遞的實參個數，這個時候就要使用可變的位置形參。使用*定義，結果為一個元組
def fun(*args);
print(args)
fun(1) # (1,)
fun(1,2,3) # (1, 2, 3)
12345
- 個數可變的關鍵字參數（指定參數名傳遞參數）
定義函數時，可能無法確定傳遞的關鍵字實參個數，這個時候就要使用可變的關鍵字形參。使用*定義，結果為一個字典
def fun(**args);
print(args)
fun(a=10) # {'a':10}
fun(a=10, b=20, c=30) # {'a':10, 'b':20, 'c':30}
12345
以上參數在函數定義時，一種方式只能定義一次。
當兩種參數定義方式同時存在時，位置形參必須在關鍵字形參前面
python異常處理機制
異常捕獲
try:
可能出現異常的語句放在這里
except 你要捕獲的異常類型:
捕獲到異常后你想做什么
except 你要捕獲的異常類型:
捕獲到異常后你想做什么
...
except BaseException as e: # 這種情況是以上異常類型都沒捕獲到，則執行這塊代碼
print('出錯了', e)
print('程序照常執行')
12345678910
異常捕獲else
try:
可能出現異常的語句放在這里
except 你要捕獲的異常類型:
捕獲到異常后你想做什么
except 你要捕獲的異常類型:
捕獲到異常后你想做什么
...
except BaseException as e: # 這種情況是以上異常類型都沒捕獲到，則執行這塊代碼
print('出錯了', e)
else:
print('如果沒有異常則執行else部分')
1234567891011
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('無論是否產生異常，總會被執行的代碼')
12345678910
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進行修飾，所以我是類方法')
12345678910111213141516171819202122232425
類實例對象
# 類實例創建語法 stu = Student()
# 假設已存在上面的 Student 類
# stu1就是Student類的實例對象，該實例對象中可以訪問到類中的屬性和方法
stu1 = Student('zzl', 18) # 創建實例
print(stu1.name) # zzl
print(stu1.age) # 18
stu1.eat() # 吃飯
12345678
動態綁定屬性和方法
# 假設已存在Student類
stu = Student('zzl', 18)
# 綁定 gender 屬性
stu.gender = '男'
print(stu.gender) # 男
# 綁定 show 方法
def show():
print('show方法執行')
stu.show = show
stu.show() # show方法執行
12345678910111213
面向對象的三大特征
封裝 （提高程序的安全性）
將數據（屬性）和行為（方法）封裝到類對象中，在方法內部對屬性進行操作，在類對象的外部調用方法。這樣無需關心方法內部的具體實現細節，從而隔離了復雜度。在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
# 方法重寫
# 方法重寫就是在子類里定義與父類重名的方法，這樣就會優先調用子類的定義的方法
12345678910111213141516171819202122232425262728293031323334
模塊和包
定義：每一個.py文件就是一個模塊
使用模塊化的好處
- 方便其他程序和腳本的導入使用
- 避免函數名和變量名沖突
- 提高代碼的可維護性
- 提高代碼的可重用性
導入模塊
# 導入模塊
import 模塊名稱 [as 別名]
# 導入模塊中的指定函數(or 變量 or 類)
from 模塊名稱 import 函數/變量/類
12345
包
包是一個分層次的目錄結構，它將一組功能相近的模塊組織在一個目錄下
作用
- 代碼規范
- 避免模塊名稱沖突
包與目錄的區別
- 包含__init__.py文件的目錄稱為包
- 目錄里通常不存在__init__.py文件
包的導入
import 包名.模塊名
文件的讀寫
內置函數open()創建文件對象
# file = open( filename, [mode, encoding] )
# 假設有一個名為a的文本文件，里面有hello world
file = open('a.txt', 'r')
print(file.readlines()) # ['hello world']
file.close()
123456
常用的文件打開模式
打開模式描述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
123
目錄操作 （os 和 os.path）
- os模塊是python內置的與操作系統功能和文件系統相關的模塊，該模塊中的語句的執行結果通常與操作系統有關，在不同的操作系統上運行，得到的結果可能不一樣
- os模塊與os.path模塊用于對目錄或文件進行操作
import os
# 打開計算器
os.system('calc.exe')
# 打開記事本
os.system('notepad.exe')
# 打開可執行文件
os.startfile('路徑')
12345678
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,否則返回Falsejoin(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提供了靈活的記錄事件、錯誤、警告和調試信息等日志信息的功能
