正則表達式、枚舉

正則表達式與 JSON

初識正則表達式

正則表達式是一個特殊的字符序列，可以檢查一個字符串是否與我們所設定的字符序列想匹配

可以用來快速檢索文本和替換文本

比如，檢查一串數字是不是電話號碼，檢查一個字符串是不是 email，把一個文本中指定的單詞替換為另外一個單詞

一個例子：一個字符串是否包含另一個字符串

# 檢查字符串 a 中是否包含 python
a = 'c|c++|go|python|Javascript'
# 使用 python 自帶的 in 來操作
print('python' in a)
# 使用正則表達式來操作
import re
r = re.findall('python', a)
print(r)

結果

True
['python']

一個例子：提取字符串 a 中的所有數字

import re

a = 'c0c++7go8python6Javascript'
r = re.findall('\d', a)
print(r)

結果

['0', '7', '8', '6']

第一個例子中的正則表達式 python 和第二個例子中的正則表達式 \d ，分別稱為普通字符和元字符。

字符集

import re

s = 'abc, acc, adc, aec, afc, ahc'
# 找出字符串 s 中，中間是 c 或 f 的單詞
r = re.findall('a[cf]c', s)
print(r)

# 找出 中間不是 c 或 f 的單詞
r = re.findall('a[^cf]c', s)
print(r)

# 找出 中間是 c 或 d 或 e 或 f 的單詞
r = re.findall('a[c-f]c', s)
print(r)

結果

['acc', 'afc']
['abc', 'adc', 'aec', 'ahc']
['acc', 'adc', 'aec', 'afc']

概括字符集

[\d] 數字字符，是 [0-9] 的概括字符集，[\D] 是 [\d] 的取反

[\w] 單詞字符，是 [A-Za-z0-9_] 的概括字符集，[\W] 是 [\w] 的取反，包括 [' ', '\t', '&', '\n', '\r']

[\s] 空白字符，匹配空白字符，包括 ' ', '\t', \n', '\r' ， [\S] 匹配非空白字符

數量詞

匹配字符串中的語言名稱

import re

a = 'python 1111php678go'

r = re.findall('[a-z]{2,6}', a)
print(r)

結果

['python', 'php', 'go']

貪婪與非貪婪

默認是貪婪匹配，盡可能多的匹配，比如上面的例子中 [a-z]{2,6} 就會盡可能多的匹配到 6

非貪婪匹配，使用問號 [a-z]{2,6}?

import re

a = 'python 1111php678go'

r = re.findall('[a-z]{2,6}?', a)
print(r)

結果

['py', 'th', 'on', 'ph', 'go']

匹配 0 次 1 次或者無限多次

* 對前面的一個字符，匹配 0 次或 無限多 次

import re

a = 'pytho1python2pythonn3'

r = re.findall('python*', a)
print(r)

結果

['pytho', 'python', 'pythonn']

+ 對前面的一個字符，匹配 1 次或 無限多 次

import re

a = 'pytho1python2pythonn3'

r = re.findall('python+', a)
print(r)

結果

['python', 'pythonn']

? 對前面的一個字符，匹配 0 次或 1 次

import re

a = 'pytho1python2pythonn3'

r = re.findall('python?', a)
print(r)

結果

['pytho', 'python', 'python']

邊界匹配符

^ 從字符串的開頭開始匹配

$ 從字符串的末尾開始匹配

匹配長度為 4~8 位的字符

import re

qq = '123456789'
r = re.findall('^\d{4,8}$', qq)
print(r)

結果

[]

組

() 組

[] 字符集，中的每個字符是或的關系，() 組，中的每個字符是且的關系

3 個 python 匹配 1 次：

import re

a = 'PythonPythonPythonPythonPythonPython'
r = re.findall('(Python){3}', a)
print(r)

結果

['Python', 'Python']

匹配模式參數

小寫匹配大寫

import re

lanuage = 'PYTHON'

r = re.findall('python', lanuage)
print(r)

結果，匹配不到

[]

忽略大小寫

import re

lanuage = 'PYTHON'

r = re.findall('python', lanuage, re.I)
print(r)

結果

['PYTHON']

. 匹配出換行符 \n 之外其他所有字符

用 . 匹配換行符：

import re

lanuage = 'PYTHON\n'

r = re.findall('python.', lanuage, re.I)
print(r)

結果，匹配不到

[]

匹配換行符：

import re

lanuage = 'PYTHON\n'

r = re.findall('python.', lanuage, re.I | re.S)
print(r)

結果

['PYTHON\n']

re.sub 正則替換

匹配到，替換。

re.sub('要匹配的', '替換為', 字符串)

import re

lanuage = 'PythonC++JavaPHPJava'
r = re.sub('Java', 'GO', lanuage)
print(r)

結果

PythonC++GOPHPGO

只替換匹配到的第一個

import re

lanuage = 'PythonC++JavaPHPJava'
r = re.sub('Java', 'GO', lanuage, 1)
print(r)

結果

PythonC++GOPHPJava

第二個參數，可以是一個函數

import re

lanuage = 'PythonC++GOPHPGO'

def convert(value):
    # value 是匹配到的對象
    print(value)
    matched = value.group()
    # return 是替換為
    return '>' +  matched + '<'

r = re.sub('GO', convert, lanuage)
print(r)

結果

<re.Match object; span=(9, 11), match='GO'>
<re.Match object; span=(14, 16), match='GO'>
PythonC++>GO<PHP>GO<

一個字符串，匹配其中的數字，大于 6 的替換成 9，小于 6 的替換成 0：

import re

s = 'A8C3721D86'

def convert(value):
    matched = value.group()
    if int(matched) >= 6:
        return '9'
    else:
        return '0'

r = re.sub('\d', convert, s)
print(r)

結果

A9C0900D99

Search 與 match 函數

re.match() 從首字符開始匹配，如果首字符不匹配，就返回 None，匹配到就返回匹配到的對象，只匹配一次

re.search() 搜索整個字符串，返回匹配到的第一個對象

group 分組

不要首尾

import re

s = 'life is short, i use python'

r = re.search('life(.*)python', s)
print(r.group(1))

結果

 is short, i use

用 findall() 不需要使用 group()

import re

s = 'life is short, i use python'

r = re.findall('life(.*)python', s)
print(r)

結果

[' is short, i use ']

多個分組

import re

s = 'life is short, i use python, i love python'

r = re.search('life(.*)python(.*)python', s)
print(r.group(0))
print(r.group(1))
print(r.group(2))
print(r.groups())

結果

life is short, i use python, i love python
 is short, i use 
, i love 
(' is short, i use ', ', i love ')

理解 JSON

一種輕量級的數據交換格式

  • 易于閱讀
  • 易于解析
  • 網絡傳輸效率高
  • 跨語言交換數據

json 有自己的數據類型

Json Python
object dict
array list
string str
number int
number float
true True
false False
null None

反序列化

import json

json_object = '{"name":"張三", "age":18}'

student = json.loads(json_str)
print(type(student))
print(student)
print(student['name'])
print(student['age'])

結果

<class 'dict'>
{'name': '張三', 'age': 18}
張三
18

import json

json_array = '[{"name":"張三","age":18, "flag":false}, {"name":"小明", "age":18, "flag":true}]'

student = json.loads(json_array)
print(type(student))
print(student)

結果

<class 'list'>
[{'name': '張三', 'age': 18, 'flag': False}, {'name': '小明', 'age': 18, 'flag': True}]

序列化

import json

student = [{'name': 'zhangsan', 'age': 18, 'flag': False}, {'name': 'xiaoming', 'age': 19, 'flag': True}]

json_array = json.dumps(student)
print(type(json_array))
print(json_array)

結果

<class 'str'>
[{"name": "zhangsan", "age": 18, "flag": false}, {"name": "xiaoming", "age": 19, "flag": true}]

枚舉和閉包

枚舉其實是一個類

from enum import Enum

class VIP(Enum):
    YELLOW = 1
    GREEN = 2
    BLACK = 3
    RED = 4

print(VIP.YELLOW)

結果

VIP.YELLOW

枚舉和普通類相比的優(yōu)勢

普通類的類變量，可修改，變量名可重復

枚舉類的類變量，不可修改，變量名不可重復

修改普通類的類變量

class Common:
    YELLOW = 1

Common.YELLOW = 6
print(Common.YELLOW)

結果

6

修改枚舉類的類變量

from enum import Enum

class VIP(Enum):
    YELLOW = 1
    GREEN = 2
    BLACK = 3
    RED = 4

VIP.YELLOW = 6

結果

AttributeError: Cannot reassign members.

普通類的變量名可以重復

class Common:
    YELLOW = 1
    YELLOW = 1

print(Common.YELLOW)

結果

1

枚舉類的變量名不可重復

from enum import Enum

class VIP(Enum):
    YELLOW = 1
    YELLOW = 2
    BLACK = 3
    RED = 4

print(VIP.YELLOW)

結果

TypeError: Attempted to reuse key: 'YELLOW'

枚舉類型、枚舉名稱與枚舉值

獲取 枚舉值 和 枚舉名稱

from enum import Enum

class VIP(Enum):
    YELLOW = 1
    GREEN = 2
    BLACK = 3
    RED = 4

print(VIP.YELLOW.value)
print(VIP.YELLOW.name)

結果

1
YELLOW

枚舉名稱和枚舉類型不同

from enum import Enum

class VIP(Enum):
    YELLOW = 1
    GREEN = 2
    BLACK = 3
    RED = 4

# 枚舉名稱
print(VIP.YELLOW.name)
# 枚舉類型
print(VIP.YELLOW)

print(type(VIP.YELLOW.name))
print(type(VIP.YELLOW))

# 通過枚舉名稱獲取枚舉類型
print(VIP['YELLOW'])

結果

YELLOW
VIP.YELLOW
<class 'str'>
<enum 'VIP'>
VIP.YELLOW

枚舉可以遍歷

通過遍歷枚舉，獲取到這個枚舉下面的所有枚舉類型

from enum import Enum

class VIP(Enum):
    YELLOW = 1
    GREEN = 2
    BLACK = 3
    RED = 4
    
for v in VIP:
    print(v)

結果

VIP.YELLOW
VIP.GREEN
VIP.BLACK
VIP.RED

枚舉的比較運算

枚舉的注意事項

枚舉類型的值可以重復，不過此時后一個可以看做是前一個的別名

from enum import Enum

class VIP(Enum):
    YELLOW = 1
    GREEN = 1
    BLACK = 3
    RED = 4

print(VIP.GREEN)

結果

VIP.YELLOW

在遍歷的時候，別名不會遍歷出來

...
for v in VIP:
    print(v)

結果

VIP.YELLOW
VIP.BLACK
VIP.RED

如果需要遍歷出來：

...
for v in VIP.__members__.items():
    print(v)

結果

('YELLOW', <VIP.YELLOW: 1>)
('GREEN', <VIP.YELLOW: 1>)
('BLACK', <VIP.BLACK: 3>)
('RED', <VIP.RED: 4>)

也可以不加 items() ：

...
for v in VIP.__members__:
    print(v)

結果

YELLOW
GREEN
BLACK
RED

通過枚舉值獲取枚舉名

數據庫中存枚舉值，因為占用空間小，代碼中使用枚舉名，因為可讀性高

通過枚舉值獲取枚舉名

from enum import Enum

class VIP(Enum):
    YELLOW = 1
    GREEN = 1
    BLACK = 3
    RED = 4

a = 1
print(VIP(a))

結果

VIP.YELLOW

枚舉小結

Enum 的枚舉值可以是字符串，如果只有數值類型的枚舉值，可以使用 IntEnum

@unique 可以防止枚舉值相同

枚舉類不能實例化

一切皆對象

python 中一切皆對象

函數也是對象，可以賦值給變量，可以作為另一個函數的參數，可以作為另一個函數的返回值

函數也是對象：

def a():
    pass

print(type(a))

結果

<class 'function'>

什么是閉包

調用函數 curve

def a():
    def b():
        pass

b()

結果

NameError: name 'b' is not defined

因為函數 curve 的作用域只在函數 curve_pre 內部。

函數可以作為另一個函數的返回值，也可以賦值給變量

def a():
    def b():
        print('This is a function')
    # 函數可以作為另一個函數的返回值
    return b

# 函數可以賦值給變量
f = a()
# f() 相當于 b()
f()

結果

This is a function

傳個參數

def a():
    x = 1
    def b(y):
        return x + y
    # 函數可以作為另一個函數的返回值
    return b

# 函數可以賦值給變量
f = a()
# f(2) 相當于 b(2)
result = f(2)
print(result)

結果

3

閉包 = 函數 + 環(huán)境變量

在上面的代碼中，return b 其實并不只是返回了函數 b ，與函數 b 一起返回的，還有它的環(huán)境變量 x = 1 ，它們是一個整體，也就是一個閉包。

獲取這個環(huán)境變量的值：

...
print(f.__closure__[0].cell_contents)

結果

1

一個示例看看閉包

def f1():
    a = 10
    def f2():
        a = 20
        print(a)
    print(a)
    f2()
    print(a)

f1()

結果

10
20
10

閉包的經典誤區(qū)

如果函數對它的環(huán)境變量重新賦值，那么這個變量會變成一個普通的局部變量

def f1():
    a = 10
    def f2():
        # 對環(huán)境變量重新賦值，a 會被 python 認為是一個局部變量
        a = 20
        return a
    return f2

f = f1()
print(f.__closure__)

結果

None

閉包解決問題

計算步數

初始步數 x = 0 ，走 3 步 result = 3，停一停，走 5 步，result = 8，休息一下，走 3 步， result = 11

不使用閉包的實現方法

steps = 0

def go(step):
    global steps
    steps += step
    return steps

result1 = go(3)
print(result1)
result2 = go(5)
print(result2)
result3 = go(3)
print(result3)

結果

3
8
11

使用閉包實現

steps = 0

def factory(steps):
    def go(step):
        # 聲明 steps 不是局部變量
        nonlocal steps
        steps += step
        return steps
    return go

# 調用 factory 函數
g = factory(steps)

# 第一次調用 go 函數
result1 = g(3)
# 結果
print(result1)
# 環(huán)境變量
print(g.__closure__[0].cell_contents)
# 全局變量
print(steps)

result2 = g(5)
print(result2)
print(g.__closure__[0].cell_contents)
print(steps)

result3 = g(3)
print(result3)
print(g.__closure__[0].cell_contents)
print(steps)

結果

3
3
0
8
8
0
11
11
0

全局變量 steps = 0 始終沒有被改變，這是使用閉包的好處，因為如果每個函數都修改全局變量，容易亂。

最后編輯于 ：
?著作權歸作者所有,轉載或內容合作請聯系作者
【社區(qū)內容提示】社區(qū)部分內容疑似由AI輔助生成，瀏覽時請結合常識與多方信息審慎甄別。
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發(fā)布，文章內容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務。

相關閱讀更多精彩內容

  • localStorage 永久存儲 本地永久存儲，就算你關閉了瀏覽器，數據依然存在，除非你手動清空掉它 local...
    曹昆_09a6閱讀 517評論 0贊 0
  • 簡介 這是一個Swift語言教程，基于最新的iOS 9，Xcode 7.3和Swift 2.2，會為你介紹Swif...
    張嘉夫閱讀 3,234評論 0贊 49
  • 簡書第二次 內容全局變量和局部變量switch語句for循環(huán)while循環(huán)break和continue作用prin...
    三生枕上書_0f49閱讀 777評論 0贊 0
  • 1..sort 排序原理 冒泡排序法解析：冒泡排序法的原理：比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。...
    耶啵_閱讀 223評論 0贊 1
  • Python 轉義字符 在需要在字符中使用特殊字符時，python 用反斜杠\轉義字符。如下表： 轉義字符描述 \...
    薔北閱讀 572評論 0贊 0

友情鏈接更多精彩內容