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
第九章 檔案操作
- 開啟讀、寫儲存關閉
- 檔案操作標準格式
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基礎知識整理Babel
- JS基礎知識整理JS
- Web前端基礎知識整理Web前端
- Servlet基礎知識點整理Servlet
- C++基礎知識整理C++
- 整理Java基礎知識--Calendar 類Java
- Java基礎知識整理之this用法Java
- OC UIApplication基礎知識整理UIAPP
- python 基礎知識Python
- python基礎知識Python
- iOS | 面試知識整理 - OC基礎 (一)iOS面試
- JavaSE基礎學習知識整理大全Java
- 「整理」前端微知識庫 —— 基礎技能前端
- Java基礎知識整理之註解Java
- linux基礎知識整理(備忘)Linux
- 架構設計基礎知識整理架構
- Linux系統基礎知識整理Linux
- OC UIViewController基礎知識整理UIViewController
- Java基礎複習,整理知識點Java
- 時序分析:基礎知識整理(二)
- Python爬蟲筆記(一)——基礎知識簡單整理Python爬蟲筆記
- Python基礎知識1Python
- Python基礎知識分享Python
- Python 基礎知識教程Python
- 整理Java基礎知識--Number&Math類Java
- Java基礎知識整理之程式碼塊Java
- 前端開發基礎知識整理–css篇前端CSS
- Python知識體系-Python2基礎知識Python
- Python基礎知識點梳理Python
- Python——基礎知識細節Python
- Python基礎知識架構Python架構
- Python基礎知識之字典Python
- Python基礎知識之集合Python
- Python基礎知識之二Python
- Java基礎知識整理之static修飾方法Java
- mysql資料庫學習基礎知識整理MySql資料庫
- Python基礎知識入門(二)Python
- Python入門基礎知識(二)Python