1 Python簡介

Python是一個高層次的結合了解釋性、編譯性、互動性和面向對象的腳本語言。

• 解釋性：這意味python在運行過程中沒有編譯這個過程
• 交互式：意味著可以直接運行代碼而不用像c語言一樣在main函數中執(zhí)行代碼
• 面向對象的語言：意味著python支持面向對象或代碼封裝的編程技術

2 Python編碼

• 如果 python 源碼文件 沒有聲明編碼格式，python 解釋器會默認使用 ASCII 編碼
• 可以在文件頭寫#encoding=gbk等修改python默認的編碼格式或者# -- coding: UTF-8 --修改
• 若文件中出現與編碼格式不一致的字符時python解釋器就會報錯
  

3 python模塊安裝之pip

• pip是Python的包安裝程序。其實pip就是python標準庫中的一個包，可以用來管理python標準庫中的包，也可以用來安裝非python標準庫的包
• 一般python安裝包已經自帶pip
• pip使用
  • 可以在cmd界面中用pip help install查看安裝使用說明
  • 可以直接pip install+包名來安裝包
  • 安裝時還可以指定版本安裝包,例下：

    pip install SomePackage              # 最新版本
    pip install SomePackage==1.0.4       # 指定版本
    pip install 'SomePackage>=1.0.4'     # 最小版本
    

• 查看安裝包信息
  • pip freeze 查看已經安裝的包及版本信息
  • 還可以導出包信息到指定文件。如：pip freeze > requirements.txt，文件名稱隨意；也可以使用 pip install -r requirements.txt，兩者等效。
• 包卸載
  • 卸載包命令：pip uninstall <包名>
  • 批量卸載，把包信息導入到文件 pip uninstall -r requirements.txt
• 包升級
  • pip install -U <包名> 或：pip install <包名> --upgrade
• 列出安裝包
  • pip list 查看已經安裝的包及版本信息
  • pip list -o 查看可更新的包信息
• 顯示包所在目錄及信息
  • pip show <包名>
  • pip show -f <包名> 查看包的詳細信息
• 搜索包
  • pip search <關鍵字>

4 python的縮進規(guī)則

• python一般用新行作為語句的結束標識
• python中用縮進來區(qū)分代碼塊
• Python PEP8 編碼規(guī)范，指導使用4個空格作為縮進。
• 但是在復雜代碼中會選擇用2個空格作為縮進，使代碼更容易讀懂
• 物理行與邏輯行區(qū)別
  • 物理行：代碼編輯器中顯示的代碼，每一行內容是一個物理行
  • 邏輯行：Python解釋器對待嗎進行介紹，一個語句是一個邏輯行
  • 相同的邏輯行要保持相同的縮進
  • ":"標記一個新的邏輯層
    增加縮進表示進入下一個代碼層
    減少縮進表示返回上一個代碼層
  • 使用；可以把多個邏輯行合成一個物理行
  • 使用\可以把邏輯行分成多行

5 標識符

• 標識符是編程時使用的名字，用于給變量、函數、語句塊等命名，Python 中標識符由字母、數字、下劃線組成，不能以數字開頭，區(qū)分大小寫。
• 以下劃線開頭的標識符有特殊含義
  • _xxx ，表示不能直接訪問的類屬性，需通過類提供的接口進行訪問，不能用 from xxx import * 導入
  • 雙下劃線開頭的標識符，如：__xx，表示私有成員
  • 雙下劃線開頭和結尾的標識符，如：xx，表示 Python 中內置標識，如：init() 表示類的構造函數

5.1 關鍵字

• 自定義標識符時不能使用關鍵字

6 轉義字符

• 需要在字符中使用特殊字符時，就需要用到轉義字符，在python里用反斜杠‘\’轉義字符。
• 當字符串中包含反斜杠、單引號和雙引號等有特殊用途的字符時，必須使用反斜杠對這些字符進行轉義(轉換一個含義)
• ·當字符串中包含換行、回車，水平制表符或退格等無法直接表示的特殊字符時，也可以使用轉義字符當字符串中包含換行、回車，水平制表符或退格等無法直接表示的特殊字符時，也可以使用轉義字符
  

7 注釋

• Python 解釋器在執(zhí)行代碼時會忽略注釋，不做任何處理。
• 注釋最大的作用就是提高代碼的可讀性
  

7.1 單行注釋

# 注釋內容

7.2 多行注釋

Python 使用三個連續(xù)的單引號'''或者三個連續(xù)的雙引號"""注釋多行內容，如：
'''
注釋內容
'''

"""
注釋內容
"""

8 輸出函數

• python輸出函數為print，無論什么類型的數據都可以直接輸出，使用如下：

print(*objects, sep=' ', end='\n', file=sys.stdout)

• objects參數：表示輸出對象。輸出多個對象時，需要用逗號分隔
• sep參數：用來間隔多個對象
• end參數：用來設定以什么結尾
• file參數：要寫入的文件對象

#如果直接輸出字符串，而不是用對象表示的話，可以不使用逗號
print("Duan""Yixuan")
print("Duan","Yixuan")
 
運行結果如下：
DuanYixuan
Duan Yixuan
可知，不添加逗號分隔符，字符串之間沒有間隔

• 在輸出前加r表示原樣輸出

print(r'\hello word')
# \hello word

8.1 格式化輸出

8.2 精度和寬度控制

• 在“：”后分別加^,<,>分別表示輸出居中，左對齊，右對齊
• 第二三種不可控，其他格式控制方式與C語言一樣

8.3 轉換標志

• 轉換標志：-表示左對齊；+表示在數值前要加上正負號；" "(空白字符)表示正數之前保留空格()；0表示轉換值若位數不夠則用0填充。

p=3.141592653
print('%+3.1f'%p)
# +3.1

p=3.141592653
print('%010.1f'%p)
# 00000003.1

p=3.141592653
print('%-3.1f'%p)
#3.1

8.4 格式字符歸納

控制輸出字體樣色

9 輸入函數

• python使用input()控制鍵盤錄入

input('請輸入：')
# 請輸入：

• 一次性輸入多個變量

a,b,c=input('請輸入：').split(',')
# 錄入多個數且用逗號隔開

• 以上一種方式的類型轉換

a,b,c=map(int,input('請輸入：').split(','))
# 這樣就可以把所有數轉換為int類型

10 變量與常量

• 變量：一般值改變后內存地址隨著改變
  
• 局部變量和全局變量
  
• 常量：python沒有常規(guī)意義上的常量，約定用全大寫標識符表示常量，但其值還是可以改變
• 所以后來用戶可以自定義類來實現常量

# -*- coding: utf-8 -*-
# python 3.x
# Filename:const.py
# 定義一個常量類實現常量的功能
# 
# 該類定義了一個方法__setattr()__,和一個異常ConstError, ConstError類繼承 
# 自類TypeError. 通過調用類自帶的字典__dict__, 判斷定義的常量是否包含在字典 
# 中。如果字典中包含此變量，將拋出異常，否則，給新創(chuàng)建的常量賦值。 
# 最后兩行代碼的作用是把const類注冊到sys.modules這個全局字典中。
class _const:
    class ConstError(TypeError):pass
    def __setattr__(self,name,value):
        if name in self.__dict__:
            raise self.ConstError("Can't rebind const (%s)" %name)
        self.__dict__[name]=value
        
import sys
sys.modules[__name__]=_const()

# test.py
import const
const.PI=3.14
print(const.PI)

11 數據類型

• python常用數據類型：

• 整數類型：
  
• 浮點類型：
• 
• 布爾類型：
  
• 字符串類型：
  

11.1 數據類型轉換

• 數據類型轉化事項：
  
• 特別注意int()函數有兩個參數，如果只有一個參數則轉換為整數，如果有第二個參數，則為指定轉換的進制

  c='123'
  print(int(c,16))
  #291
  

12 python運算符

• 算術運算符：
  
  • 整除一正一負向下取整
• 賦值運算符：
  
  • python沒有自增自減運算符，自增自減用+=、-+實現
• 比較運算符：
  
• 布爾運算符：
  
• 位運算符：
  

12.1 算術運算符的優(yōu)先級

• 算術運算符優(yōu)先級：
  

12.2 對象的布爾值

• python一切皆對象，所有對象都有一個布爾值
  • 可以使用內置函數bool()獲取對象的布爾值
• 布爾值為False的對象：

• 其他對象布爾值為True

13 選擇結構

• 語法結構：
  
  • python的選擇條件可以使用數學方式表達：

  # 與c不一樣，c不能連續(xù)比較
  if 90<=score<=100
  

  • else后面不能接條件，只能接：

  if 100>90:
    print('小于')
  else:
    print('大于')
  

  • 嵌套if
    

13.1 條件表達式

• 基本語法：

print(100 if 100>90 else 90)
# 輸出100
# if判斷條件為True輸出前面，否則輸出后面

13.2 pass語句

• pass簡介
  

14 循環(huán)結構

14.1 range函數

• 用于生成一個整數序列,默認從0開始
• 基礎語法：
  

14.2 while循環(huán)

• 基礎語法：

i=0
while i<5:
    print(i)
    i+=1
# 0 1 2 3 4

14.3 for-in循環(huán)

• 基礎語法：
  

for i in range(3):
  print(i)
# 0 1 2

• 不需要變量時：

for _ in range(3):
  print('人生苦短，我用python')

14.4 流程控制語句

• break語句
  • 基礎語法：
    
• continue語句：
  • 基礎語法：
    
• else語句：
  • 基礎語法：
    

14.5 循環(huán)總結

15 列表

• 列表可存儲不同類型的值

15.1 列表的基本操作

• 創(chuàng)建列表：

r=[12,"i"]
print(r)
# [12, 'i']

r=list('1234')
print(r)
# ['1', '2', '3', '4']

• 列表的特點：
  
• 獲取列表指定元素的索引(index()函數)

l=[1,2,3]
print(l.index(1))
# 0

• 獲取列表的多個元素(切片)
  
  • 切片會產生新的列表

l=[1,2,3]
print(l[1:])
# [2, 3]

• 列表查詢與遍歷
  

  l=[1,2,3]
  print(1 in l)
  # True
  

• 列表的增加操作
  

  l=[1,2,3]
  # 在末尾加一個元素
  l.append(4)
  print(l)
  # 在末尾加任意多元素，參數為列表
  l.extend([5,6])
  print(l)
  # 在第6個位置加上一個7元素
  l.insert(6,7)
  print(l)
  # 切片，把切出去的部分用新列表替換
  l[1:]=[8]
  print(l)
  

• 列表的刪除

  

  l=[1,1,2,3]
  # 刪除1元素
  l.remove(1)
  print(l)
  # 刪除第0個元素，若不指定則刪除最后一個元素
  l.pop(0)
  print(l)
  # 切片出第0個到第1個元素
  print(l[0:1])
  # 清除全部元素
  l.clear()
  print(l)
  # 刪除列表
  del(l)
  print(l)
  23
  
  # [1, 2, 3]
  # [2, 3]
  # [2]
  # []
  # 報錯，沒有l(wèi)變量
  

• 列表的排序
  

  • sort()不會產生新列表對象
  • sorted()會產生新的列表對象

  l=[3,2,1]
  # 不會產生新對象
  l.sort()
  print(l)
  # 會產生新對象
  r=sorted(l)
  print(l)
  

• 列表生成式

  • 基本語法：
    • i for i in 迭代器

  # 生成一個1-9元素的列表
  lst=[i for i in range(1,10)]
  

16 字典

• 以鍵值對的方式無序存儲數據
  
• 把key進過哈希函數計算得出位置
• key要求為不可變序列
• key不可重復

16.1 字典的基本操作

• 創(chuàng)建字典：
  
• 字典元素的獲取
  

  s={"張三":100}
  t=s["張三"]
  print(t)
  # 設置默認查找值，當查字典沒有的元素時返回默認值
  t=s.get("lisi",99)
  print(t)
  #100
  #99
  

• key的判斷、元素刪除、元素新增
  
  
• 獲取字典視圖
  

  s={"張三":100}
  # 獲取所有key
  print(s.keys())
  # 獲取所有值
  print(s.values())
  # 獲取所有鍵值對
  print(s.items())
  #dict_keys(['張三'])
  # dict_values([100])
  # dict_items([('張三', 100)])
  

• 字典遍歷

  s={"張三":100}
  # item 獲取的是key
  # s[item]獲取值
  for item in s:
    print(item)
    print(s[item])
  

• 字典生成式
  
  • 基本語法
    • for({列表:列表 for 列表,列表 in zip(列表, 列表)})

    s=[1,2,3]
    t=[4,5]
    print({s: t for s, t in zip(s, t)})
    

    • 若zip打包的兩個列表元素數目不一樣，則按元素數目少的列表打包

16.2 字典總結

17 元組

• 是一個不可變序列

17.1 元組的基本操作

• 元組的創(chuàng)建
  
  • 第一種方式可以省略小括號
  • 第三種方式如果省略逗號，會被認為是元素原來的類型
• 為什么要把元組設計成不可變序列？
  
• 遍歷元組：

  t=1,2,3,4
  for i in t:
    print(i)
  

• 元組生成式
  • 元組沒有生成式

18 集合

• 集合是沒有value的字典
  

18.1 集合的基本操作

• 集合的創(chuàng)建
  
  • 集合的元素不能重復
  • 空集合創(chuàng)建只能用內置函數進行設置
• 集合的判斷，新增，刪除
  

  s={1,2,3}
  # 末尾增加一個元素
  s.add(4)
  print(s)
  # 末尾至少增加一個元素
  s.update([5])
  print(s)
  # 刪除一個指定元素
  s.remove(2)
  print(s)
  # 刪除一個指定元素
  s.discard(1)
  print(s)
  # 一次刪除頭部一個元素
  s.pop()
  print(s)
  # 清空元素
  s.clear()
  

• 集合間的關系
  

  s={1,2,3,4}
  t={3,4}
  # 判斷集合是否相等
  print(s==t)
  # 判斷集合t是否是集合s的子集
  print(t.issubset(s))
  # 判斷集合s的父集是否是t
  print(s.issuperset(t))
  # 判斷兩個集合是否是沒有交集
  print(s.isdisjoint(t))
  
  #False
  #True
  #True
  #False
  

• 集合的數學操作
  

  s={1,2,3,4}
  t={3,4,5,6}
  # 集合的交集
  print(s.intersection(t))
  print(s&t)
  
  # 集合的并集
  print(s.union(t))
  print(s|t)
  
  # 集合的差集
  print(s.difference(t))
  print(s-t)
  
  # 集合的對稱差集
  print(s.symmetric_difference(t))
  print(s^t)
  

• 集合生成式
  

  print({i for i in range(1,10)})
  

18.2 元組與集合總結

19 序列總結

• 不可變序列還有字符串

20 字符串

• python基本數據類型，是一個不可變序列

20.1 字符串的駐留機制

• 基本概述
  
  
  • pycharm中對字符串的駐留機制進行了優(yōu)化，只要是字符串都可以駐留
• 駐留機制優(yōu)缺點
  [外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-SKvBkivX-1645512642755)(https://note.youdao.com/yws/public/resource/92933d878935240680c00793fc3e404c/xmlnote/WEBRESOURCE0dafb644fe2f97462c17e1e63d4b2c26/169)]

20.2 字符串的操作

• 字符串的查詢
  

  s='python人生苦短，我用python'
  # 查找子串第一次出現的位置，無子串報錯
  print(s.index('python'))
  # 查找子串最后一次出現的位置，無子串報錯
  print(s.rindex('python'))
  # 查找子串第一次出現的位置，無子串返回-1
  print(s.find('python'))
  # 查找子串最后一次出現的位置，無子串返回-1
  print(s.rfind('python'))
  
  #0
  #13
  #0
  #13
  

• 字符串的大小寫轉換
  

  s='人生苦短python，我用Python'
  # 全部字符轉換為大寫
  print(s.upper())
  # 全部字符轉換為小寫
  print(s.lower())
  # 大寫轉小寫，小寫轉大寫
  print(s.swapcase())
  # 第一個字符轉換為大寫，其他字符轉換為小寫
  print(s.capitalize())
  # 把每個單詞第一個字母大寫，其他為小寫
  print(s.title())
  
  # 人生苦短PYTHON，我用PYTHON
  # 人生苦短python，我用python
  # 人生苦短PYTHON，我用pYTHON
  # 人生苦短python，我用python
  # 人生苦短Python，我用Python
  

• 字符串對齊
  

  s='人生苦短python，我用Python'
  # 居中
  print(s.center(48))
  # 右對齊
  print(s.rjust(48))
  # 左對齊
  print(s.ljust(48))
  # 右對齊
  print(s.zfill(48))
  

  
• 字符串的劈分
  

  s='hello,world '
  print(s.split(sep=',',maxsplit=1))
  
  # ['hello', 'world ']
  

• 字符串的判斷
  

  s='hello2022'
  # 判斷是否為合法的標識符
  print(s.isidentifier())
  # 判斷是否全由空白字符組成
  print(s.isspace())
  # 判斷是否全為字母
  print(s.isalpha())
  # 判斷是否全為十進制數字
  print(s.isdecimal())
  # 判斷是否全為數字
  print(s.isnumeric())
  # 判斷是否全為字母和數字
  print(s.isalnum())
  
  #True
  #False
  #False
  #False
  #False
  #True
  

• 字符串的替換與合并
  

  s='hello2022'
  lst=["1,2,3",'木頭人']
  # 將指定子串替換
  print(s.replace('2','1'))
  # 在每兩個列表元素中間加一個字符串
  print(s.join(lst))
  
  # hello1011
  # 1,2,3hello2022木頭人
  

• 字符串的比較
  

  s='hello2022'
  r='H'
  print(s>r)
  print(s>=r)
  print(s<r)
  print(s<=r)
  print(s==r)
  print(s!=r)
  
  # True
  # True
  # False
  # False
  # False
  # True
  

• 字符串的切片
  • 由于字符串是不可變序列，字符串的增刪改切片等操作都會產生新的對象
• 字符串的編碼轉換
  
  • 字符串的編碼
    • 使用str類的encode方法
  • 字符串的解碼
    • 使用decode方法

  s='天涯共此時'
  # 編碼
  print(s.encode(encoding='GBK'))
  print(s.encode(encoding='UTF-8'))
  # 解碼
  r=s.encode(encoding='GBK')
  print(r.decode(encoding='GBK'))
  
  # b'\xcc\xec\xd1\xc4\xb9\xb2\xb4\xcb\xca\xb1'
  # b'\xe5\xa4\xa9\xe6\xb6\xaf\xe5\x85\xb1\xe6\xad\xa4\xe6\x97\xb6'
  # 天涯共此時
  

  • 編碼和解碼所使用的的字符編碼必須一致否則會報錯

21 函數

• 函數就是執(zhí)行特定任務和完成特定功能的一段代碼
• 函數的好處
  1. 復用代碼
  2. 隱藏實現細節(jié)
  3. 提高可維護性
  4. 提高可讀性便于調試
• 函數的創(chuàng)建

  def 函數名(輸入參數):
    函數體
    [return xxx]
  

• 函數參數傳遞
  
  • 默認值參數
    
  • 其他類型參數
    
    • 如果兩個參數都有，則可邊的位置參數要在可變的關鍵字參數前面
    • 當*args，**kwargs接受參數后，*args意思為把args元組里的數據打散為位置參數，**kwargs為把kwargs字典里的數據打散為關鍵字參數
• 參數總結
  
• 函數內存分析
  • 如果不可變對象，那么在函數體內的修改不會影響實參的值，如果是可變對象，在函數體的修改會影響到實參
• 函數的返回值
  • python支持多返回值
    1. 如果函數沒有返回值，return可以省略不寫
    2. 函數的返回值如果是一個直接返回類型
    3. 函數的返回值如果是多個，返回的結果是一個元組

21.1 遞歸函數

• 如果一個函數的函數體調用了函數本身，這個函數就被稱為遞歸函數
  

22 異常處理機制

• 被動掉坑類型(try-expect)
  
  • 當存在多個expect結構時應該按照先子類再父類的順序捕獲異常，為避免遺漏可能出現的異常，可以在最后加BaseException
• try-except-else:
  
• try-except-else-finally:
  
• python常見的BUG類型
  
• traceback模塊
  
  • 可以把異常打印在日記文件中
• 手動拋出異常

  if 0<=score<=100:
    print('分數為：',score)
  else:
    raise Exception('分數不正確')
  

  • 當沒有try語句時，異常由python捕獲

22.1 BUG總結

23 python類

• 創(chuàng)建python類
  
  • 類之外的叫函數，類里面的叫方法
  • 類屬性，類方法，靜態(tài)方法都可以直接類名.屬性名調用，不需要創(chuàng)建對象
• 對象的創(chuàng)建
  
• 動態(tài)綁定屬性和方法
  
  

  class Student:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def show(self):
        print('我是{},今年{}'.format(self.name,self.age))
  def show():
      print('我是函數')
  stu=Student('李磊',20)
  stu.show()
  stu.show=show
  stu.show()
  
  #我是李磊,今年20
  #我是函數
  
  

23.1 類總結

24 面向對象的三大特征

24.1 封裝

• python沒有專門的封裝關鍵字，所以在屬性名前用__表示私有

class A:
    __place="吉林"
# 列出A中所有屬性
print(dir(A))
print(A._A__place)
# ['_A__place']
# 吉林

24.2 繼承

class A:
    pass
class B:
    pass
# 繼承A，B類 
class C(A,B):
    pass

• 方法重寫
  

24.3 object類

• object類特殊的方法和屬性
  

class C:
    pass
class B(C):
    pass
class A(B,C):
    pass
a=A()
print(a.__class__)# <class '__main__.A'> 輸出對象所屬類
print(A.__base__)#<class 'object'>  輸出類的基類
print(A.__bases__)# (<class '__main__.B'>, <class '__main__.C'>) 輸出所有父類
print(A.__mro__)#(<class '__main__.A'>, <class '__main__.B'>, <class '__main__.C'>, <class 'object'>) 輸出基礎層次
print(C.__subclasses__())# [<class '__main__.B'>, <class '__main__.A'>]  輸出所有子類的列表

• new__與__init(new在前)
  

24,4 多態(tài)

• 靜態(tài)語言和動態(tài)語言關于多態(tài)的區(qū)別
  

24.5 面向對象總結

25 類的淺拷貝與深拷貝

• 基礎介紹
  
• 淺拷貝

  import copy
  class CPU:
      pass
  class Disk:
      pass
  class Computer:
          def __init__(self,Disk,CPU):
              self.Disk=Disk
              self.CPU=CPU
  disk=Disk()
  cpu=CPU()
  a=Computer(disk,cpu)
  b=copy.copy(a)
  print(a,a.Disk,a.CPU)
  print(b,b.Disk,b.CPU)
  
  # <__main__.Computer object at 0x016B0A18> <__main__.Disk object at 0x00ACE580> <__main__.CPU object at 0x00A9AF40>
  # <__main__.Computer object at 0x016F4310> <__main__.Disk object at 0x00ACE580> <__main__.CPU object at 0x00A9AF40>
  

  
• 深拷貝
  • 在淺拷貝基礎上拷貝子對象

26 模塊化編程

• 模塊基礎
  
• 創(chuàng)建與導入模塊
  
  • 使用import時只能接包名和模塊名，from…import可以導入包，模塊，變量
  • 同一目錄下直接導入
    
    • from post_packaging.method import *
  • 不同目錄下導入
    
• python包
  

26.1 主程序運行

26.2 python常用模塊

26.3 模塊總結

27 python文件操作

• 文件的讀寫
  
  

  file=open(file,mode='r',encoding='gbk')
  

• 常用文件處理方式
  
• 文件常用方法
  
  • 文件對象調用完一定要關閉
• with語句
  

with open('a.txt','r) as file:
  print(file.read())

27.1 os 模塊

• 操作目錄的方法
  
  • os.walk()會把所有子目錄和文件遍歷出來
• os.path操作目錄常用函數
  

28 python文件打包

• Pyinstaller -F py_word.py 打包exe
• Pyinstaller -F -w py_word.py 不帶控制臺的打包
• Pyinstaller -F -w -i chengzi.ico py_word.py 打包指定exe圖標打包

29 正則表達式

文章來源地址http://www.zghlxwxcb.cn/news/detail-620188.html

• 正則支持普通字符
• 元字符：
  • \d:匹配一個數字的數字
  • \w:匹配一個數字、字母、下劃線
  • \W,\D:匹配與上面取反(\D就是取數字以外的內容)
  • []:取范圍
  • .:匹配換行符之外的東西
• 量詞：
  • 控制前面元字符出現的頻次
  • +:前面元字符出現1次或多次
  • *:前面元字符出現0次或多次，盡可能多的匹配結果
  • ？:前面元字符出現0次或多次
• 惰性匹配
  • 1.*2：以1開頭2結尾的盡可能長的字符
  • 1.*？2：以1開頭以2結尾盡可能短的字符(惰性匹配)

29.1 re模塊

• 預加載
  • obj=re.conpile(r"正則表達式")
  • 先創(chuàng)建一個正則表達對象
  • obj.findall(“字符串”)
• 提取惰性匹配的值
  
  • 也可以用groupdict方法，輸出為字典

30 閉包

• 本層函數對外層函數的局部變量的使用，此時內層函數被稱為閉包函數
• nonlocal關鍵字
  • 用來在函數或者其他作用域中使用改變外層(非全局)變量
• global關鍵字
  • 使局部變量改變全局變量
• 閉包作用
  • 讓一個變量常駐于內存
  • 可以在外部使用改變局部變量
  • 可以避免全局變量被修改

def func(fn):
    def inner():
        print('fn進來了')
        fn()
        print('fn出去了')
        return 'f'
    return inner

31 裝飾器

• 裝飾器本質就是閉包，對外部參數的引用
  
• 作用：再不改變原有函數調用下，給函數增加新功能
  
• 被裝飾函數的參數問題
  
  • 被裝飾函數有參數的話，返回函數和目標函數都要加參數
• 一個函數可被多個裝飾器裝飾
  
• 通用裝飾器寫法
  

  32 迭代器

• 迭代器基本概念
  
  
  • 迭代器的特點
    1. 只能向前不能反復
    2. 特別節(jié)省內存
    3. 惰性機制

33 生成器

• 本質就是迭代器
• 生成器函數
  

  def order():
    lst=[]
    for i in range(100):
        lst.append(f"衣服{i}")
        if len(lst)==3:
            yield lst
            lst=[]
  gen=order()
  print(gen.__next__())
  print(gen.__next__())
  
  # ['衣服0', '衣服1', '衣服2']
  # ['衣服3', '衣服4', '衣服5']
  

• 推導式
  
• 生成器表達式
  • 優(yōu)點：用好了特別節(jié)省內存
  • 生成器表達式是一次性的
  • 語法：
    • (數據 for循環(huán) if)

到了這里，關于萬字超詳細python基礎解析的文章就介紹完了。如果您還想了解更多內容，請在右上角搜索TOY模板網以前的文章或繼續(xù)瀏覽下面的相關文章，希望大家以后多多支持TOY模板網！