文章目錄

• 一、Python基礎
• • 1.注釋
  • 2.輸入輸出
  • 3.數據類型
  • 4.運算符
  • • 4.1.算數運算符
    • 4.2.比較運算符
    • 4.3.邏輯運算符
    • • 4.3.1.短路運算
    • 4.4.賦值運算符
  • 5. 判斷與循環語句
  • • 5. 1.If-else
    • 5. 2.While
    • 5. 3.for
    • 5. 4.break
    • 5. 5.continue
  • 6. 高級數據類型
  • • 6. 1.字符串
    • 6. 2.列表
    • 6. 3.字典
    • 6. 4.元組
    • 6. 5.數組Ndarray（NumPy包中）
    • 6. 6.矩陣庫Matrix（NumPy包中）
    • 6. 7.序列Series（Pandas包中）
    • 6. 8.數據框DataFrame（Pandas包中）
  • 7. 函數
  • • 7.1.參數
    • • 7.1.1.必選參數
      • 7.1.2.默認參數
      • 7.1.3.可選參數：元組類型，參數個數不確定
      • 7.1.4.關鍵字參數：字典類型，key為字符串
    • 7.2.返回值
    • 7.3.局部變量與全局變量
    • 7.4.函數參數引用傳值
    • 7.5.匿名函數（lambda表達式）
    • 7.6.遞歸函數
    • • 7.6.1.文件查找
  • 8. 內置函數
  • • 8.1.數學函數
    • 8.2.類型轉換函數
    • 8.3.序列操作函數
    • 8.4.集合Set
• 二、Python面向對象
• • 1.類（Class）
  • • 1.1.定義類
    • 1.2.類屬性
    • 1.3.實例屬性
    • • 1.3.1.內部添加
      • 1.3.2.外部添加
    • 1.4.實例方法
    • 1.5.類方法
    • 1.6.靜態方法
    • 1.7.__init__方法（初始化）
    • 1.8.Self(當前對象的引用)
    • 1.9.魔術方法
    • • 1.9.1.魔術方法介紹大全
  • 2.方法、繼承、多態
  • • 2.1.析構方法`__del__ `
    • • 2.1.1.釋放對象時調用
      • 2.1.2.手動清空對象
    • 2.2.繼承
    • • 2.2.1.單繼承
      • 2.2.2.多繼承
      • 2.2.3.重寫父類方法
      • 2.2.4.重寫`__init__`方法
      • 2.2.4多態
    • 2.3類屬性和實例屬性區別
    • 2.4類方法和實例方法和靜態方法
  • 3.封裝與單例
  • • 3.1.封裝
    • 3.2.單例模式
    • 3.3.異常處理
    • • 3.3.1.異常類型
      • 3.3.2.自定義異常類型
    • 3.4.動態添加屬性和方法
• 三、Python文件操作
• • 1.打開`open('文件名','打開模式')`
  • 2.寫操作
  • 3.讀操作
  • 4.With上下文管理對象
  • 小結
  • 案例
  • 5.文件定位
• 四、Python模塊
• • 1.import導入模塊
  • 2.from...import導入模塊
  • 3.as 給模塊取別名
  • 4. os模塊
  • 5.自行編寫模塊
  • 6.matplotlib數據可視化包
• -------------------------------ppt警告-------------------------------
• 五、Python垃圾回收
• • 1.引用計數（主）
  • 2.GC負責的主要任務
  • 3.標記-清除
  • 4.引用計數不能回收的案例分析
  • 5.分代收集
  • 6.GC的閾值
  • 7.GC垃圾回收自動觸發機制
  • 7.內存優化
  • 8.pep8原則
  • 9.命令行參數
• 六、Python正則表達式
• • 1.re模塊
  • 2.匹配規則-字符
  • • 2.1`.`的使用
    • 2.2`[]`的使用
    • 2.3`\d`的使用
    • 2.4`\D`的使用
    • 2.5`\s`的使用
    • 2.6`\S`的使用
    • 2.7`\w`的使用
    • 2.8`\W`的使用
  • 3.匹配規則-字符數量
  • • 3.1`*`的使用
    • 3.2`+`的使用
    • 3.3`\?`的使用
    • 3.4`{m}`的使用
    • 3.5`{m,}`的使用
    • 3.6`{n,m}`的使用
  • 4.匹配規則-原生字符串
  • 5.匹配規則-開頭和結尾
  • 6.匹配規則-分組匹配
  • • 6.1`|`的使用
    • 6.2`(ab)`的使用
    • 6.3`\num`的使用
    • 6.4`(?P)`的使用
    • 6.5`(?P=name)`的使用
  • 7.re.compile
  • 8.re.search
  • 9.re.findall
  • 10.re.sub
  • 11.re.split
  • 12.貪婪模式和非貪婪模式

一、Python基礎

1.注釋

注釋代碼

單行注釋	#內容
多行注釋	'''內容'''

• python2需要指定python解析器的路徑，指定編碼格式

#!/usr/bin/python3 #-- coding=utf-8 --

2.輸入輸出

輸入輸出代碼

普通輸入	content = input('請輸入內容')——默認為str類型
普通輸出	print('內容')
格式化輸出1	print('姓名:%s:\n 年齡:%d'%(name,age))
格式化輸出2	print('姓名:{} \n 年齡:{}'.format(name,age))

• 常用的格式化符號

格式符號轉換

%c	字符
%s	通過str()字符串轉換來格式化
%i	有符號十進制整數
%d	有符號十進制整數
%u	無符號十進制整數
%o	八進制整數
%x	十六進制整數（小寫字母）
%e	索引符號（小寫’e‘）
%E	索引符號（大寫’E‘）
%f	浮點實數
%g	%f和%e的簡寫
%G	%f和%E的簡寫

3.數據類型

• type()方法可查看其類型

數據類型代碼

int	a = 10
float	a = 10.5
complex	a = 10j
bool	a = true
str	a = '內容'
dict	dict = {"name":王一,"age":20}
Tuple	tupleA = (1,2,5,'王一')
list	listA = [1,2,5,'王一']

4.運算符

4.1.算數運算符

算數運算符代碼

+	sum = a+b
-	sum = a-b
*	sum = a*b
/	sum = a/b
**	sum = a**2
%	sum = a%2
//	sum = a//2

4.2.比較運算符

比較運算符代碼

==	a == b
!=	a != b
>	a > b
<	a < b
>=	a >= b
<=	a <= b

4.3.邏輯運算符

邏輯運算符代碼

and	a == 10 and b == 10
or	a == 10 or b == 10
not	not a == 10

4.3.1.短路運算

簡單的說： 表達式用and的則將容易為False的條件放到前面， 表達式有or的則將容易為True的條件放到前面

詳細介紹大家可百度查看

4.4.賦值運算符

賦值運算符代碼

=	a = b
+=	a += b
-=	a -= b
*=	a *= b
/=	a /= b
%=	a %= 2
**=	a **= 2
//=	a //= 2

5. 判斷與循環語句

5. 1.If-else

num =int(input("輸入一個數字：")) if num>2: if num>3: print('數大于3')else: print('數大于2且小于等于3') elif num<2: print('數小于2') else: print('數等于2')

5. 2.While

i = 9 while i >= 1:j = 1 while j <= i:print('%d*%d=%2d\t'%(j,i,i*j),end='') j +=1 i -= 1 print()

5. 3.for

for i in range(0,10) :for j in range(0,i+1) :print('%d * %d = %d'%(i,j,i*j), end=' ')print()

5. 4.break

import random win = 0 while True: if win >= 3: print('你已經勝利三次') break else: # 勝利小于三次，繼續玩 inp = int(input('請出拳：')) computer = random.randint(0,2) print('電腦出拳：%d'%computer) if inp >2: print('輸入錯誤') elif (inp ==0 and computer==2) or \(inp == 1 and computer==0)\or (inp == 2 and computer==1 ): print("厲害了，居然贏了") win += 1 # 如果勝利一次，勝利次數加1 elif inp == computer: # 如果兩個人出異樣就打平 print('不錯，居然打平了') else:print('呵呵，輸了吧')

5. 5.continue

a = 'python' for i in a:if i == 'h'#當循環到h的時候，退出當前循環不打印 continueprint(i)

6. 高級數據類型

• 公有方法

公有方法作用代碼

+	兩個對象相加操作，會合并兩個對象	-
*	對象自身按指定次數進行 + 操作	-
in	判斷指定元素是否存在于對象中	-

6. 1.字符串

strA = 'abc123' 常用方法作用代碼

[起始下標：結束下標：步長]	字符串切片	strA[2:4]
capitalize()	首字母變大寫	-
isalnum()	判斷是否是字母和數字	-
islower()	判斷是否是小寫	-
swapcase()	大寫變小寫，小寫變大寫	-
title()	把每個單詞的首字母變成大寫	-
endswith/startswith()	是否 x結束/開始	-
isalpha()	判斷是否是字母	-
join()	循環取出所有值用xx去連接	-
lstrip/rstrip/strip	移除左/右/兩側空白	-
replace(old, new, count=None)	old被換字符串，new替換字符串，count換多少個。無count表示全部替換	-
find()	檢測x是否在字符串中	-
isdigit()	判斷是否是數字	'abc123’.isdigit()
lower/upper	大小寫轉換	-
split()	切割字符串	-
count()	統計出現的次數	-

6. 2.列表

listA = ['a','b','c',1,2,3] 常用方法作用代碼

[起始下標：結束下標：步長]	字符串切片	listA[2:4]
append()	在列表后面追加元素	-
count()	統計元素出現的次數	-
extend()	擴展，相當于批量添加	-
index()	獲取指定元素索引號	-
insert()	在指定位置插入	-
pop()	刪除最后一個元素	-
remove()	移除左邊找到的第一個元素	-
reverse()	反轉列表	-
sort()	列表排序(reverse=True 倒序)	-

6. 3.字典

scores= [('英語', 58), ('政治', 79)] 常用方法作用代碼

scores[‘語文’]	通過key訪問value	scores['celery']
scores[‘數學’] = 93	修改/增加key-value對	scores['數學'] = 93
del	刪除key-value 對	del scores['數學']
in	判斷是否包換鍵	'數學' in scores
len()	查看字典中有幾個鍵值對	-
keys	返回包含字典所有key值	-
values	返回一個包含所有value值	-
items	返回一個包含所有（鍵，值）元祖的列表	-
pop(‘鍵’)	刪除指定鍵	-

6. 4.元組

tupleA = ('a','b','c',1,2,3)#元組元素不可修改 常用方法作用代碼

[起始下標：結束下標：步長]	字符串切片	listA[2:4]
index()	獲取指定元素索引號	-
count()	統計元素出現的次數	-

6. 5.數組Ndarray（NumPy包中）

Ndarray數組

array01 = numpy.array([1,2,3,4,5,6,7,8,9,10]) # [ 1 2 3 4 5 6 7 8 9 10] array02 = numpy.arange(5)# [0 1 2 3 4] array03 = numpy.ones((2,2))# [[1. 1.]# [1. 1.]] array04 = numpy.empty((2,2))#[[1.81270221e-152 3.53391889e+246]# [6.72795888e+199 1.23479908e-259]] array05 = numpy.random.rand(4,2)# [[0.1655842 0.51305993]# [0.81675055 0.48361912]# [0.76938389 0.51806414]# [0.55784499 0.99445201]] array06 = numpy.linspace(10,30,5)# [10. 15. 20. 25. 30.]

6. 6.矩陣庫Matrix（NumPy包中）

Matrix矩陣庫

import numpy.matlib import numpy as npprint (np.matlib.empty((2,2))) # 填充為隨機數據

6. 7.序列Series（Pandas包中）

序列Series

sdata = {'a':1,'b':2,'c':3} sp = pandas.Series(sdata) print(sp) # a 1 # b 2 # c 3

6. 8.數據框DataFrame（Pandas包中）

數據框DataFrame

data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) c = ['a', 'b', 'c'] r = ['A', 'B', 'C'] df = pd.DataFrame(data=data, columns=c, index=r)

7. 函數

7.1.參數

• 參數：必選參數、默認參數[缺省參數]、可選參數、關鍵字參數

7.1.1.必選參數

def Sum(a,b) :'''打印函數:return:'''sum1 = a+ b;print(sum1)

7.1.2.默認參數

def Sum(a=0,b=1) :'''打印函數:return:'''sum1 = a+ bprint(sum1)

7.1.3.可選參數：元組類型，參數個數不確定

def Sum(*args):'''計算累加和:param args: 可變長參數類型:return:'''sum1 = 0for item in args :sum1 += itemprint(sum1)

7.1.4.關鍵字參數：字典類型，key為字符串

def keyFunc(**kwargs):'''計算累加和:param args: 可變長參數類型:return:'''print(kwargs)dictA = {'1':2,'2':4}keyFunc(**dictA) keyFunc(name='2',age='3')

7.2.返回值

def Sum(a,b) :'''相加:return:和'''sum1 = a+ breturn sum1

7.3.局部變量與全局變量

• 注意：函數內修改全局變量需要加關鍵字global

mark = '1234' print(mark) def changeInfo() :global markmark = '5678'passchangeInfo() print(mark)

7.4.函數參數引用傳值

python中，萬物皆對象，在函數調用時，實參傳遞的就是對象的引用。
不可變類型（Number（數字）、String（字符串）、Tuple（元組））修改時，修改的是存儲實際數據的引用，對原數據無影響
但可變類型（Set（集合）、List（列表）、Dictionary（字典））修改時，修改的是同一地址下的數據，對原數據有影響。
可以使用id()獲取數據地址

7.5.匿名函數（lambda表達式）

m = lambda x,y:x+y#相加 print(m(1,2))age = 15 print( 'ok' if age>18 else 'no' )#判斷m = lambda x,y : x if x>y else y#判斷 print(m(1,2))m = (lambda x,y : x if x>y else y)(1,2)#直接調用 print(m)

7.6.遞歸函數

def jiecheng(n) :if n==1 :return 1else:return n*jiecheng(n-1)print(jiecheng(5))

7.6.1.文件查找

import osdef findFile(file_Path) :listRs = os.listdir(file_Path) #獲得路徑下所有文件夾for item in listRs :full_path = os.path.join(file_Path,item)#組合完整文件路徑if os.path.isdir(full_path) :#判斷是否是文件夾findFile(full_path) #繼續遞歸遍歷else :print(item+'----------------------')else:returnfindFile('E:\\umengok')

8. 內置函數

8.1.數學函數

函數作用

abs()	絕對值
round()	四舍五入，近似值
pow()	冪運算
divmod()	返回一個包含商和余數的元組
max()	最大值
min()	最小值
sum()	求和
eval()	用來執行一個字符串表達式，并返回表達式的值（動態執行的函數）

8.2.類型轉換函數

函數作用

int()	轉化為int類型
float()	轉化為float類型
str()	轉化為str類型
ord()	字符轉數字（ASCII）
chr()	數字轉字符（ASCII）
bool()	轉化為bool類型
bin()	十進制轉化為二進制
hex()	十進制轉化為十六進制
oct()	十進制轉化為八進制
list()	元組轉化為列表類型
tuple()	列表轉化為元組類型
dict()	創建字典
bytes()	轉化為字節數組

8.3.序列操作函數

函數作用

all()	判斷可迭代對象元素是否全部都為True（除了0，空，False都是）
any()	判斷可迭代對象元素是否全部為False（0，空，False都是）
sorted()	對可迭代對象進行排序（返回新的list）（reverse參數：升序降序）
reverse()	反轉列表中元素
range()	創建一個整數列表
zip()	將可迭代對象打包壓縮為元組，返回元組列表（打包序列對應索引存儲為一個元組，按照最少的元素那個進行壓縮）
enumerate()	可遍歷的數據對象組合為一個索引序列

8.4.集合Set

無序、不重復的數據結構不支持索引和切片（類似于一個只有key的字典），作用去重

set1 = {1,2,3,4} 常用方法作用代碼

add()	添加元素	-
clear()	清空集合	-
difference()	兩個集合的差集(set1-set2)	-
intersection()	兩個集合的交集（set1&set2）	-
union()	兩個集合的并集（set1|set2）	-
pop()	移除數據刪除	-
discard()	移除指定數據刪除	-
update()	把set2更新到set1中	-

二、Python面向對象

1.類（Class）

1.1.定義類

class Person :name = '小明'#類屬性age = '20'#類屬性def eat(self):print('吃飯')passpass

• 使用

xiaoming = Person()

1.2.類屬性

在類的內部，使用def關鍵字定義且有類似(self)的，使用權歸實例所有

name = '小明'#類屬性

1.3.實例屬性

1.3.1.內部添加

在方法的內部，使用self引用的屬性

def __init__(self):self.friend = '小紅'

1.3.2.外部添加

class People :def eat(self):print(self)passpassxiaoming = People() xiaoming.name = '小明' xiaoming.age = 20 print(xiaoming.name)

1.4.實例方法

在類的內部，使用def關鍵字定義且有類似(self)的，使用權歸實例所有

def eat(self):print('吃飯')passpass

1.5.類方法

類對象所擁有的方法，用裝飾器@classmethod來標
識其為類方法，對于類方法，第一個參數必須是類對象，
一般以cls作為第- -個參數，
類方法可以通過類對象，實例對象調用

類方法可以訪問、修改類屬性

name = '小明'@classmethoddef findNameInfo(cls):return cls.namepass

1.6.靜態方法

靜態方法不需要傳參例如（cls/self）
靜態方法不可以訪問類屬性
通常用類直接訪問靜態方法，本身和類與實例無關

import time class Test :def __init__(self,hour,min,second):self.hour = hourself.min = minself.second = second@staticmethoddef showTime():return time.strftime("%H:%M:%S" ,time.localtime())pass passprint(Test(1,2,3).showTime())

1.7.__init__方法（初始化）

*類似于構造函數，對self的屬性進行構造
自動執行的初始化方法,自帶的內置函數

class People :def __init__(self,name,age):self.name = nameself.age = agepassdef showInfo(self):print(self.name+'年齡'+self.age)passpassxiaoming = People('小明',20)

1.8.Self(當前對象的引用)

實例化后，python解釋器會把當前對象自動傳遞給self

1.9.魔術方法

• __str__
  打印時調用的方法

class People :def __init__(self,name,age):self.name = nameself.age = agepassdef __str__(self):return '姓名：%s 年齡：%d'%(self.name,self.age)passpassxiaoming = People('小明',20) print(xiaoming)

• __new__
  創建對象實例的方法，調用一次就會生成新的對象cls（class）cls自動提供
  真正創建實例的方法，經常單例模式使用，必須返回實例

class People :def __init__(self,name,age):self.name = nameself.age = ageprint('__init__')passdef __new__(cls, *args, **kwargs):print('__new__')return object.__new__(cls)passpassxiaoming = People('小明',20)

• 區別__new __和__init__

• __new __類的實例化方法必須要返回該實例否則對象就創建不成功
• __init__用來做數據屬性的初始化工作也可以認為是實例的構造方法接受類的實例self并對其進行構造
• __new __至少有一個參數是cls代表要實例化的類，此參數在實例化時由python解釋器自動提供
• __new __函數執行要是于__init__函數

1.9.1.魔術方法介紹大全

魔術方法介紹大全

2.方法、繼承、多態

2.1.析構方法__del__

當一個對象被刪除或者被銷毀時，python解釋器也會默認調用一個方法，這個方法為__del__ ()方
法，也稱為析構方法

2.1.1.釋放對象時調用

class People :def __init__(self,name,hp):self.name = nameself.hp = hppassdef __del__(self):print('銷毀了')passpassxiaohong = People('xiaohong',100)

2.1.2.手動清空對象

del xiaohong

2.2.繼承

2.2.1.單繼承

class Animal :def eat(self):print('吃')passpassclass Dog(Animal) :def wwj(self):print('汪汪叫')passpass

2.2.2.多繼承

class Animal :def eat(self):print('吃')passpassclass God:def fly(self):print('飛')passpassclass Wukong(Animal,God):def Dayaoguai(self):print('打妖怪')passpass

• 多繼承，同名方法查找父類，如沒有則向父類的父類查找（廣度優先）
• __mro__方法解析順序，用來了解繼承順序

2.2.3.重寫父類方法

class Animal :def eat(self):print('吃')passpassclass Dog(Animal) :def eat(self):print('大口吃')passpass

2.2.4.重寫__init__方法

class People :def __init__(self,name,hp):self.name = nameself.hp = hpprint('調用People__init__')passpassclass Man(People):def __init__(self,name,hp):People.__init__(self,name,hp)#調用父類方法1#super().__init__(name,hp)#調用父類方法2,可在父類逐個查找print('調用Man__init__')passpassman = Man('xxx',100)

2.2.4多態

繼承并擴展父類代碼，不需要修改父類代碼

class Animal :def eat(self):print('吃')passpassclass Dog(Animal) :def eat(self):print('大口吃')passpassclass Cat(Animal) :def eat(self):print('小口吃')passpassdef commonInvoke(obj) :obj.eat()listObj = [Animal(),Cat(),Dog()]for item in listObj :commonInvoke(item)

2.3類屬性和實例屬性區別

實例對象不可以修改類屬性，類屬性所有權歸類所有

2.4類方法和實例方法和靜態方法

1.類方法的第一個參數是類對象cls，通過cls引用的類對象的屬性和方法
2.實例方法的第一個參數是實例對象self,通過self引用的可能是類屬性、也有可能是實例屬
性(這個需要具防分析)，不過在存在相同名稱的類屬性和實例屬性的情況下，實例屬性優先
級更高。
3.靜態方法中不需要額外定義參數，因此在靜態方法中引用類屬性的話，必須通過類對象來引
用。

3.封裝與單例

3.1.封裝

• 屬性私有化，無法外部訪問，不能被繼承，只能內部類使用

class Person :__age = 20 #類屬性私有化def __init__(self):self.__name = '小明'#實例屬性私有化passpass

• 方法私有化，無法外部訪問，不能被繼承，只能內部類使用

class Person :def __run(self): #實例方法私有化print('跑')passpass

• 下劃線類型

下劃線說明

_xxx	protected類型（只允許本身和子類訪問）
__xxx	private類型（只允許本身訪問）
__xxx__	魔術方法，Python內置方法
xxx_	避免屬性名與python關鍵字沖突

• property（屬性函數）

• 類屬性的方式實現

class Person :def __init__(self):self.__name = '小明'passdef get_name(self):return self.__namedef set_name(self,name):if name < 0:print('no')else :self.__name = namepassname = property(get_name, set_name) pass person = Person() print(person.name)#訪問類屬性name

• 裝飾器方式實現

class Person :def __init__(self):self.__name = '小明'pass@property #添加裝飾器 添加屬性標志def name(self):return self.__name@name.setter #提供一個setter方法def name(self,name):if name == '小明':print('no')else :self.__name = namepass pass person = Person() person.name = '小紅' print(person.name)#訪問類屬性name

• __new__實例化方法

class Person :def __init__(self):self.__name = '小明'passdef __new__(cls, *args, **kwargs):return super().__new__(cls, *args, **kwargs)passpass

3.2.單例模式

不能使用自身new方法，會產生深度遞歸

class Person :__instance = Nonedef __new__(cls, *args, **kwargs):if not hasattr(cls,'_instance') :cls.__instance = super().__new__(cls, *args, **kwargs)return cls.__instancepasspass

3.3.異常處理

try#可能出現錯誤的代碼塊 except:#出錯之后執行的代碼塊 else:#沒有出錯的代碼塊 finally:#不管出沒出錯都會執行的代碼塊

根據錯誤類型來捕獲的（NameError 、IndexError …）
自上而下依次判斷

try :print(b)li = [1,2,3,4]print(li[100]) except NameError as msg:print('出錯')print(msg) except IndexError as msg:print('出錯')print(msg) except Exception as msg:#所有異常print('出錯')print(msg)

3.3.1.異常類型

當前函數沒找到，則向上層一層層傳遞查找

異常導致的錯誤

AssertionError	當assert語句失敗時引發。
AttributeError	當 屬性分配或引用失敗時引發。
EOFError	當input()函數達到文件結束條件時引發。
FloatingPointError	當浮 點運算失敗時引發。
GeneratorExit	調用 生成器的close()方法時引發。
ImportError	找不到導入的模塊時引發。
IndexError	當序 列的索引超出范圍時引發。
KeyError	在字典中找不到鍵時引發。
KeyboardInterrupt	當用戶 按下中斷鍵(Ctrl+c或delete)時引發。
MemoryError	當操作耗盡內存時引發。
NameError	在局部或全局范圍內找不到變量時引發。
NotImplementedError	由抽象方法提出。
OSError	當系統操作導致系統相關錯誤時引發。
Overf lowError	當算術運算的結果太大而無法表示時引發。
ReferenceError	使用弱引用代理訪問垃圾收集的引用時引發。
Runt imeError	當錯誤不屬于任何其他類別時引發。
StopIteration	函數引發，以指示迭代器不再返回任何項。
SyntaxError	遇到語法錯誤時由解析器引發。
Indentat ionError	當縮進不正確時引發。
TabError	當縮進由不一致的制表符和空格組成時引發。
SystemError	當解釋器檢測到內部錯誤時引發。
Sys temExit	由sys. exit()函數引發。
TypeError	將函數或操作應用于類型不正確的對象時引發。
UnboundLocalError	當在函數或方法中引用局部變量，但沒有將值綁定到該變量時引發。
UnicodeError	當 發生與unicode相關的編碼或解碼錯誤時引發。
UnicodeEncodeError	當編碼過程中發生與unicode相關的錯誤時引發。
UnicodeDecodeError	當解碼過程中出現與unicode相關的錯誤時引發。
UnicodeTrans lateError	翻譯過程中發生與unicode相關的錯誤時引發。
ValueError	當函數得到類型正確但值不正確的參數時引發。
ZeroDivisionError	當除法或模運算的第二個操作數為零時引發。

3.3.2.自定義異常類型

class LenException(Exception):def __init__(self,leng):self.len = lengpassdef __str__(self):return '長度超了'passdef name_Test():try :name = '1111111111'if len(name)>5:raise LenException(len(name))else:print(name)passpassexcept LenException as msg:print(msg) passname_Test()

3.4.動態添加屬性和方法

• 動態添加屬性

class Student :def __init__(self,name):self.name = namepassdef __str__(self):return '姓名:%s' %(self.name) student = Student('小明') student.age = 20 # 動態添加實例屬性 Student.age = 20 # 動態添加類屬性 print(student) print(student.age)

• 動態添加實例方法

import types #添加方法的庫def runA(self):print(self.name)passclass Student :def __init__(self):self.name = '小明'passpass stu = Student() stu.run = types.MethodType(runA , stu)#動態添加實例方法 stu.run()#調用

• 動態添加類方法

@classmethod def runA(self):print(self.name)passclass Student :name = '小明'pass Student.run = runA#動態添加實例方法 Student.run()#調用

• 動態添加靜態方法

@staticmethod def runA():print('55555')passclass Student :name = '小明'pass Student.run = runA#動態添加實例方法 Student.run()#調用

• __slots__屬性
  來限制該class能添加的屬性。
  子類不會繼承，只有在當前類中有效。
  子類聲明__slots__屬性才會繼承
• 限制添加的屬性

class Student(object) :__slots__ = ('name','age') # 限制添加的屬性，避免存儲多余的數據def __str__(self):return '{},{}' .format(self.name,self.age)passpassstu = Student() stu.name = '1' stu.age = 20 stu.high = 20 # 添加不了報錯了 print(stu) print(stu.__dict__)#所有可以用的屬性都在這里，占空間大 print(stu.__slots__ )#存儲限制添加的屬性，避免存儲多余的數據

• __call__屬性

class Student(object) :def __call__(self, *args, **kwargs):print('1111')passstu = Student() stu()

三、Python文件操作

1.打開open('文件名','打開模式')

fileA = open('./Test.txt','w',encoding='utf-8')

• 打開模式

打開模式模式說明

r	以只讀方式打開文件。文件的指針將會放在文件的開頭。這是默認模式。
w	打開一個文件只用于寫入。 如果該文件已存在則將其覆蓋。如果該文件不存在， 創建新文件。
a	打開一個文件用于追加。如果該文件已存在，文件指針將會放在文件的結尾。也就是說，新的內容將會被寫入到已有內容之后。如果該文件不存在，創建新文件進行寫入。
rb	以二進制格式打開-一個文件用于只讀。文件指針將會放在文件的開頭。這是默認模式。
wb	以二進制格式打開一個文件只用于寫入。如果該文件已存在則將其覆蓋。如果該文件不存在，創建新文件。
ab	以二進制格式打開-一個文件用于追加。如果該文件已存在，文件指針將會放在文件的結尾。也就是說，新的內容將會被寫入到已有內容之后。如果該文件不存在，創建新文件進行寫入。
r+	打開一個文件用于讀寫。文件指針將會放在文件的開頭。
w+	打開一個文件用于讀寫。如果該文件已存在則將其覆蓋。如果該文件不存在，創建新文件。
a+	打開一個文件用于讀寫。如果該文件已存在，文件指針將會放在文件的結尾。文件打開時會是追加模式。如果該文件不存在，創建新文件用于讀寫。
rb+	以二進制格式打開-一個文件用于讀寫。文件指針將會放在文件的開頭。
wb+	以二進制格式打開-一個文件用于讀寫。如果該文件已存在則將其覆蓋。如果該文件不存在，創建新文件。
ab+	以二進制格式打開-一個文件用于追加。如果該文件已存在，文件指針將會放在文件的結尾。如果該文件不存在，創建新文件用于讀寫。

2.寫操作

• 字符串形式，默認gbk編碼

fileA = open('./Test.txt','w',encoding='utf-8') fileA.write('寫入的內容') fileA.close()

• 二進制形式寫入

fileA = open('./Test2.txt','wb') fileA.write('寫入的內容'.encode('utf-8')) fileA.close()

• 追加寫入a

fileA = open('./Test.txt','a') fileA.write('寫入的內容') fileA.close()

• 追加寫入ab

fileA = open('./Test.txt','ab') fileA.write('寫入的內容'.encode('utf-8')) fileA.close()

3.讀操作

• 讀取所有

fileA = open('./Test.txt','r',encoding='utf-8') print(fileA.read()) fileA.close()

• 讀取幾個

fileA = open('./Test.txt','r',encoding='utf-8') print(fileA.read(4)) fileA.close()

• 讀一行

fileA = open('./Test.txt','r',encoding='utf-8') print(fileA.readline()) fileA.close()

• 讀所有行

fileA = open('./Test.txt','r',encoding='utf-8') print(fileA.readlines()) fileA.close()

• 讀取二進制

fileA = open('./Test.txt','rb') data = fileA.read() print(data) print(data.decode('utf-8')) fileA.close()

4.With上下文管理對象

自動釋放打開關聯對象

with open('./Test.txt','rb') as fileA :data = fileA.read()print(data)print(data.decode('utf-8'))#自動釋放

小結

文件讀寫的幾種操作方式
read r r+ rb rb+
r r+ 只讀使用普通讀取場景
rb rb+ 適用于文件圖片視頻音頻這樣文件讀取
write WW+ wb+
w ba ab w wb+ W+每次都會去創建文件
二進制讀寫的時候要注意編碼問題，默認情況下我們寫入文件的編碼是gbk
a ab a+ 在原有的文件的基礎之后去[文件指針的末尾]去追加，并不會每次的都去創建一個新的文件

案例

old_file = input('請輸入 要備份的文件名:') file_list=old_file.split('.') #構造新的文件名.加上備份的后綴 new_file=file_list[0]+'_ 備份. '+file_list[1] try:#監視啊喲處理的邏輯with open(old_file,'r') as old_f,open(new_file,'w')as new_f:while True:content=old_f.read(1024) #-次讀取1024字符new_f.write( content)if len( content)<1024:break except Exception as msg:print (msg ) pass

5.文件定位

• tell() 返回指針當前所在的位置

with open('./Test.txt','r',encoding='utf-8') as fileA :fileA.read(1)print(fileA.tell())fileA.read(2)print(fileA.tell())

• truncate() 對源文件進行截取操作

with open('./Test.txt','r+') as fileA :fileA.truncate(2)print(fileA.read())

• seek() 更改光標指針位置
  只有二進制模式打開文件才能更改光標指針位置

fileA.seek(-2,0)#0初始位置開始 fileA.seek(-2,1)#1當前位置開始 fileA.seek(-2,2)#2末尾位置開始 with open('./test.txt','rb') as fileA :data=fileA.read(2)print(data.decode('gbk'))fileA.seek(-2,1)#當前位置向前移動2格ok = fileA.read(2)print(ok.decode('gbk'))

四、Python模塊

1.import導入模塊

import 到首次導入模塊的時候會發生如下3步操作

打開模塊文件

執行模塊對應的文件，將執行過程中產生的名字都丟到模塊的名稱空間

在程序中會有一個模塊的名稱指向模塊的名稱空間去

第三方模塊安裝位置，在python安裝 目錄下的lib/site- packages/目錄下。

import time print(time.ctime())

2.from…import導入模塊

導入模塊中部分函數，可以不用加模塊名前綴，直接使用

from … import 首次導入發生了3個步驟

以模塊為準創造個模塊的名稱空間

執行模塊對應的文件了，將執行過程中產生的名字都丟到模塊的名稱空間

在當前執行文件的名稱空間中拿到一個名字，該名字直接指向模塊中的某一個名字

from time import ctime print(ctime())

3.as 給模塊取別名

import time as timeA print(timeA.ctime())

4. os模塊

方法解釋

os.getcwd()	獲取當前工作目錄，即當前python腳本工作的目錄路徑
os.chdir (“dimname”)	改變當前腳本工作目錄:相當于shell下cd
os.curdir	返回當前目錄:()
os.pardir	獲取當前目錄的父目錄字符串名: ("…")
os.makedirs("dir1/dir2)	可生成多層遞歸目錄
os.removedirs( dirname1)	若目錄為空，則刪除，并遞歸到上一級目錄，如若也為空則刪除，依此類推
os.mkdir(’ dimname’)	生成單級目錄:相當于shell中mkdir dimname
os.rmdir( dimname’)	刪除單級空目錄，若目錄不為空則無法刪除，報錯列
os.llistdir( dirname)	出指定目錄下的所有文件和子目錄，包括隱藏文件，并以列表方式打印
os.remove()	刪除一個文件
os.rename(“oldname”,“new”)	重命名文件/目錄
os.stat( path/filename’)	獲取文件/目錄信息
os.sep	操作系統特定的路徑分隔符，win下 為"\\",Linux下為"/"
os.linesep	當前平臺使用的行終止符，win 下為"\t\n".Linux下為"\n”
os.pathsep	用于分割文件路徑的字符串
os.name	字符串指示當前使用平臺。win->‘nt’: Linux->‘posix’
os. system/(“bash command”)	運行shell命令，直接顯示
os.environ	獲取系統環境變量:
os path.abspath(path)	返回path規范化的絕對路徑
os.path.split(path)	將path分割成目錄和文件名二元組返回
os.path.dirname(path)	返回path的目錄。其實就是os path slit(path)的第一個元素
os.path basename(path)	返回path最后的文件名。如何path以/或\結尾，那么就會返回空值。即os path, split(path)的第=個元素
os.path.exists(path)	如果path存在，返回True; 如果path不存在，返回False
os.path.isabs(path)	如果path是絕對路徑，返回True
os.path.isfile(path)	如果path是一個存在的文件，返回True。 否則返回False
os.path.isdir(path)	如果path是一個存在的目錄，則返回True。 否則返回False
os.path.join(path1[ path2[ ]]	將多個路徑組合后返回，第一個絕對路徑之前的參數將被忽略
os.path.getatime(path)	返回path所指向的文件或者目錄的最后存取時間
os.path.getmtime(path)	返回path所指向的文件或者目錄的最后修改時間

• 案例

import os os.rename( 'Test.txt','Test_ 重命名.txt' ) os.remove('File del.py') #刪除文件前提是文件必須存在 os.mkdir('TestCJ') #創建文件夾 os.rmdir('TestCJ') #刪除文件夾文件必須存在 #mkdir創建一級目錄 os.mkdir( 'd: /Python編程/sub核心') #不允許創建多級 #創建多級目錄 os.makedirs( 'd:/Python編程/sub核心/三級sub') #允許 os.rmdir('d:/Python編程') #只能刪除空目錄 # 如果要刪除非空目錄的話，需要調用shutil模塊 # 非空多級刪除 shutil.rmtree('d: /Python編程') #獲取當前的目錄 print(os. getcwd()) #路徑的拼接 # print(os.path) print (os . path. join(os . getcwd(),'veny' )) #獲取python中的目錄列表 listRs=os .listdir( 'd:/') for dirname in listRs:print(dirname) #scandir和with一起來使用這樣的話上下文管理器會在迭代器遍歷完成后自動去釋放資源 with os. scandir('d:/') as entries:for entry in entries:print( entry . name) #是否是文件，是否是文件夾目錄 basePath= 'H:/' for entry in os .listdir(basePath):if os.path. isfile(os.path. join(basePath, entry)):print(entry)if os.path. isdir(os.path. join(basePath, entry)):print(entry)

5.自行編寫模塊

.py就是模塊，以庫的形式去封裝，可以定義類、函數、變量，只在本模塊中使用

• 三種導入方式

import MTest from MTest import add from MTest import *

• 模塊內測試代碼，模塊調用時不會執行，未判斷則會執行

if __name__=='__main__':print('測試')

• 限定調用函數（使用from MTest import *）

__all__=['add']

• 發布
  編寫setup.py

from distutils.core import setup # name模塊名稱 # version 版本號 # description 描述 # author 作者 # py_ modules 要發布的內容 setup(name="MTest", version="1.0",description="my module", author="lilei", py_modules=[ 'MTest'])

• 創建模塊

python setup.py build

• 生成壓縮包

python setup.py sdist

• 安裝

pip install MTest-1.0.tar.gz

6.matplotlib數據可視化包

matplotlib數據可視化包

import numpy as np from matplotlib import pyplot as plt x = np.arange(1,11) y = 2 * x + 5 plt.title("Matplotlib demo") plt.xlabel("x axis caption") plt.ylabel("y axis caption") plt.plot(x,y) plt.show()

-------------------------------ppt警告-------------------------------

五、Python垃圾回收

1.引用計數（主）

import sys a=[] print(sys.getrefcount(a))#兩次引用計數

2.GC負責的主要任務

3.標記-清除

4.引用計數不能回收的案例分析

5.分代收集

6.GC的閾值

有三種情況會觸發垃圾回收:
1.當gc模塊的計數器達到閥值的時候，自動回收垃圾
2.調用gc. collect()，手動回收垃圾
3.程序退出的時候，python解釋 器來回收垃圾

7.GC垃圾回收自動觸發機制

7.內存優化

• 大整數池和小整數池的區別是:

從結果來看是一樣的

大整數池是沒有提前的創建好對象，是個空池子，需要我們自己去創建，創建好之后，會把整數對象保存到池子里面，后面都不需要再創建了直接拿來使用，小整數池是提前將[-5,256]的數據都提前創建好

8.pep8原則

9.命令行參數

import sys print(len(sys.argv)) print(str(sys.argv))

• 案例

import argparse#創建一個解析器對象 parse=argparse.ArgumentParser(prog= '系統登錄',usage= '%(prog)s[options] usage',description='系統自定義命令行的文件',epilog= 'my - epilog') #添加位置參數[必選參數] parse.add_argument('loginType ',type=str, help=' 登錄系統類型') #添加可選參數 parse.add_argument('-u',dest='user',type=str,help= '你的用戶名') parse.add_argument('-p',dest='pwd',type=str,help= '你的密碼') result=parse.parse_args() #開始解析參數 if (result.user=='root' and result.pwd== '111111' ):print( ' login sucess!' ) else:print('login fail ' ) python test.py mysql -u root -p 111111

六、Python正則表達式

1.re模塊

import re str = 'best language in the world' result = re.match('b',str) print(result.group())

2.匹配規則-字符

2.1.的使用

# .的使用:匹配除了換行符之外的字符 data = '王一' partternA = '王.' res = re.match(partternA,data) if res :print(res.group())

2.2[]的使用

# []的使用:匹配中括號中任意一個字符 data = 'sdfg' partternA = '[a-z]' res = re.match(partternA,data) if res :print(res.group())

2.3\d的使用

# \d的使用:匹配數字0-9 data = '9g' partternA = '\d' res = re.match(partternA,data) if res :print(res.group())

2.4\D的使用

# \D的使用:匹配非數字0-9 data = 's9g' partternA = '\D' res = re.match(partternA,data) if res :print(res.group())

2.5\s的使用

# \s的使用:匹配空白字符或tab data = ' s9g' partternA = '\s' res = re.match(partternA,data) if res :print(res.group())

2.6\S的使用

# \S的使用:匹配非（空白字符或tab） data = 's9g' partternA = '\S' res = re.match(partternA,data) if res :print(res.group())

2.7\w的使用

# \w的使用:匹配單詞字符，a-z，A-Z，0-9，_ data = 's9g' partternA = '\w' res = re.match(partternA,data) if res :print(res.group())

2.8\W的使用

# \W的使用:匹配非單詞字符 data = '@s9g' partternA = '\W' res = re.match(partternA,data) if res :print(res.group())

3.匹配規則-字符數量

3.1*的使用

匹配前一個字符出現0次或者無限次，即可有可無

data = 'Any' partternA = '[A-Z][a-z]*'#從第二位開始后邊都匹配小寫字符 res = re.match(partternA,data) if res :print(res.group())

3.2+的使用

匹配前一個字符出現1次或者無限次，即至少有1次

#不能以數字開頭，只包含數字字母xia'huai'x'na data = 'MY_Name' partternA = '[a-zA-Z_]+[\w]*' res = re.match(partternA,data) if res :print(res.group())

3.3\?的使用

匹配前一個字符出現1次或者0次，即要么有1次，要么沒有

data = '7' partternA = '[a-zA-Z_]+?[0-9]'#第一位可有可無 res = re.match(partternA,data) if res :print(res.group())

3.4{m}的使用

匹配前一個字符出現m次

data = '12345' partternA = '\d{4}'#精確匹配多少個數字 res = re.match(partternA,data) if res :print(res.group())

3.5{m,}的使用

匹配前-一個字符至少出現m次 data = '12345' partternA = '\d{4,}'#精確匹配4-max個數字 res = re.match(partternA,data) if res :print(res.group())

3.6{n,m}的使用

匹配前一個字符出現從n到m次

匹配前-一個字符至少出現m次 data = '12345' partternA = '\d{4,5}'#精確匹配4-5個數字 res = re.match(partternA,data) if res :print(res.group())

• 郵箱

data = '123456@163.com' partternA = '[a-zA-Z0-9]{6,11}@163.com' res = re.match(partternA,data) if res :print(res.group())

4.匹配規則-原生字符串

一般運用在路徑上

data = 'c\\a.txt' partternA = r'c\\a.txt'#正則前面加r，不轉義 res = re.match(partternA,data) if res :print(res.group())

5.匹配規則-開頭和結尾

data = 'Myname' partternA = '^M.*'#以M開頭 res = re.match(partternA,data) if res :print(res.group()) data = 'Myname' partternA = '^M\w{5}'#以M開頭后邊5個長度任意字符 res = re.match(partternA,data) if res :print(res.group()) data = 'Myname123@163.com' partternA = '[\w]{6,11}@[\w]{3}.com$'#以.com結尾 res = re.match(partternA,data) if res :print(res.group())

6.匹配規則-分組匹配

6.1|的使用

匹配左右任意-一個表達式

data = 'zzz-123456789' partternA = '([0-9]*)-(\d*)|([a-z]*)-(\d*)'#以.com結尾 res = re.match(partternA,data) if res :print(res.group())

6.2(ab)的使用

將括號中字符作為一個分組data = 'zzz-123456789' partternA = '([0-9]*)-(\d*)|([a-z]*)-(\d*)'#以.com結尾 res = re.match(partternA,data) if res :print(res.group())

6.3\num的使用

引用分組num匹配到的字符串

• 一般應用于html文檔

data = '<html><h1>測試數據</h1></html>' partternA = r'<(.+)><(.+)>(.+)</\2></\1>'#以.com結尾 res = re.match(partternA,data) if res :print(res.group())

6.4(?P)的使用

分組起別名

data = '<div><h1>測試數據</h1></div>' partternA = r'<(?P<div>\w*)><(?P<d>\w*)>.*</(?P=d)></(?P=div)>'#以.com結尾 res = re.match(partternA,data) if res :print(res.group())

6.5(?P=name)的使用

引用別名為name分組匹配到的字符串_

data = '<div><h1>測試數據</h1></div>' partternA = r'<(?P<div>\w*)><(?P<d>\w*)>.*</(?P=d)></(?P=div)>'#以.com結尾 res = re.match(partternA,data) if res :print(res.group())

7.re.compile

• compile函數根據- -個模式字符串和可選的標志參數生成一-個正則表達式對象。該對象擁有- -系列方法用于正則表達式匹配和替換。re 模塊也提供了與這些方法功能完全一致的函數，這些函數使用一個模式字符串做為它們的第一個參數。

compile re模塊中的編譯方法可以把個 字符串編譯成字節碼
優點:在使用正則表達式進行match的操作時，python會將 字符串轉為正則表達式對象，而如果使用complie則只需要完成次轉換即可， 以后再使用模式對 象的話無需重復轉換，

reobj = re.compile('\d{4}') res = reobj.match('1234567') print(res.group())

8.re.search

str = 'best language in the world' res =re.search('world',str) print(res.group())

9.re.findall

str = 'best language in the world in in' res =re.findall('i.',str) print(res)

10.re.sub

str = 'best language in the world in in' pat = '[a-zA-Z]+' res =re.sub(pat,'C#',str) res =re.subn(pat,'C#',str) print(res)

11.re.split

str = 'best language in the world in in' pat = 'in' res =re.split('in',str) print(res)

12.貪婪模式和非貪婪模式

• 圖片匹配
  貪婪

parttern = ‘<img src = ''(.*)>’

非貪婪

parttern = ‘<img src = ''(.*?)>’

總結

以上是生活随笔為你收集整理的【Python】学习笔记总结（第一阶段（1-6）——汇总篇）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。