python數據結構之數字和字符串

python數據類型：

1. Number（數字）
2. String(字符串)
3. List(列表)
4. Dictonary（字典）
5. Tuple(元組)
6. sets(集合)

其中數字、字符串、元組是不可變的，列表、字典是可變的。
對不可變類型的變量重新賦值，實際上是重新創建一個不可變類型的對象，并將原來的變量重新指向新創建的對象（如果沒有其他變量引用原有對象的話（即引用計數為0），原有對象就會被回收）。

數字

• int:整數
  ?? 1.正負數
  ? ?2.十六進制(表示方式為0x或者0X開頭。例如：0xff)
  ? ?3.八進制(表示方式為0o或者0O開頭。例如：0o632457)
  ?? 4.二進制 (表示方式為0b或者0B開頭。例如：0b101100)
• fraction:分數
• float:浮點數
• complex:復數
• bool:布爾型(特殊的數值類型，只有True和False兩個值)

  進制轉換

  整數轉其他進制

  使用bin(i),oct(i),hex(i)函數可以將十進制數分別轉換為二進制，八進制，十六進制

  >>> s=10
  >>> bin(s)
  '0b1010'
  >>> oct(s)
  '0o12'
  >>> hex(s)
  '0xa'

  使用int(str,base)可以將非十進制的數轉換成整數
  ，其中str是文本形式的數字，base可以為2,8,16數字，分別代表二進制，八進制，十六進制，最高到36位，最低為2

  >>> int('0b10010',2)
  18
  >>> int('0o52415',8)
  21773
  >>> int('0x134ab',16)
  79019
  >>> int('s',32)
  28
  >>> int('yz',36)
  1259

  當然也可以進行16進制轉二進制八進制，八進制可以轉其他進制

  >>> hex(0b1001)
  '0x9'
  >>> hex(0o1234)
  '0x29c'
  >>> oct(0b101)
  '0o5'
  >>> oct(0xff)
  '0o377'
  >>> bin(0xff)
  '0b11111111'
  >>> bin(0o7777)
  '0b111111111111'

  各類運算符

• 算數運算符：+,-,*,/,%.//,**
• 比較運算符：==，!=,>,<,<=,>=
• 賦值運算符：=,+=,-=,*=,/=,%=,//=.**=
• 位運算符：&,|,^,~,<<,>>
• 邏輯運算符：and,or,not
• 成員運算符：in,not in
• 身份運算符：is,is not

  >>> a=12
  >>> f=~a
  >>> f
  -13
  >>> bin(f)
  '-0b1101'
  >>> bin(a)
  '0b1100'
  >>> bin(a<<1)
  '0b11000'
  >>> bin(a>>1)
  '0b110'
  >>> list=[1,2,3,4,5]
  >>> a=3
  >>> print (a in list)
  True
  >>> print (a not in list)
  False
  >>> a=['1,2,3,4,5']
  >>> b=a
  >>> print (b is a )
  True
  >>> print (b is not a )
  False
  >>> b=a[:]
  >>> print (b is a)  #這是因為字符串是不可變的
  False
  >>> print (id(a))
  42473480
  >>> print (id(b))
  42485000

  運算符優先級

• ** （優先級最高的是冪運算）
• ~,+,- (加和減都是一元運算符)
• *，/，%，//
• +,-
• <<,>>
• &
• ^,|
• <=,>=,<,>
• ==,!=
• =,+=,-=,*=,/=,%=,//=,**=

  數學函數的應用

• power：冪函數，功能與運算符**一樣

  >>> pow(2,3)
  8

• sqrt：取當前數的平方根

  >>> import math
  >>> math.sqrt(4)
  2.0

• max：最大值

  >>>max(2,3,4,5,1,9,6)
  9

• min：最小值

  >>> min(2,3,4,5,1,9,6)
  1

• abs與fabs：取絕對值，fabs取出的是浮點數

  >>> abs(-1)
  1
  >>> math.fabs(-1)
  1.0

• round：四舍五入（當小數為5的時候會向靠近偶數的一端進）

  >>> round(3.5)
  4
  >>> round(2.5)
  2
  >>> round(2.54)
  3
  >>> round(2.45)
  2

• ceil：向上取整

  >>> math.ceil(1.7)
  2
  >>> math.ceil(1.3)
  2

• floor：向下取整

  >>> math.floor(1.7)
  1
  >>> math.floor(1.3)
  1

• cmp：python2中的比較函數，當前面數值大返回-1，一樣大返回0，后面數值大返回1

  >>> cmp(1,2)
  -1
  >>> cmp(1,1)
  0
  >>> cmp(2,1)
  1

• 隨機數函數
  ??- 取0-1之間的隨機小數：

  >>> import random
  >>> random.random()
  0.18001643527271916

  ??????- 取自定義數里的隨機數：(可以取多個元素)

  >>> random.choice([1,2,3,4,5])
  2
  >>> random.choice([1,2,3,4,5])
  3
  >>> random.sample([1,2,3,4,5,6,7,8,9],2)
  [3, 7]
  >>> random.sample([1,2,3,4,5,6,7,8,9],3)
  [4, 9, 3]

  ??????- 隨機打亂順序：

  >>> a=[1,2,3,4,5,8]
  >>> random.shuffle(a)
  >>> a
  [1, 8, 2, 3, 4, 5]

  ??????- 獲取N位隨機數：(二進制)

  >>> random.getrandbits(6)
  55
  >>> random.getrandbits(6)
  48
  >>> random.getrandbits(7)
  104

• modf：把浮點數的整數位和小數位單獨取出來

  >>> math.modf(1.4)
  (0.3999999999999999, 1.0)
  >>> math.modf(1.5)
  (0.5, 1.0)
  >>> math.modf(2.8)
  (0.7999999999999998, 2.0)
  >>> math.modf(3.1)
  (0.10000000000000009, 3.0)

• log：指數函數。默認e為底數，結果為浮點數。也可以自定義底數

  >>> math.log(4,2)
  2.0
  >>> math.log2(4)
  2.0
  >>> math.log10(100)
  2.0
  >>> math.log(100,10)
  2.0

• 格式化輸出：格式化輸出保留有效數字,格式化輸出的是字符串

  >>> s=format(2.345,'0.2f')
  >>> s
  >>> type (s)
  <class 'str'>
  >>> round(2.5)
  2
  >>> format(2.5,'0.0f')
  '2'

• Decimal模塊：在使用浮點數的時候，因為計算機是使用二進制表示，所以會出現精度問題，可以使用Deciamal模塊來解決精度問題

  >>> a=4.2
  >>> b=2.1
  >>> a+b
  6.300000000000001
  >>> from decimal import Decimal
  >>> a=Decimal('2.1')
  >>> b=Decimal('4.2')
  >>> a+b
  Decimal('6.3')

• 格式化輸出——format：使用format進行進制轉換

  >>> a=20
  >>> bin(a)
  '0b10100'
  >>> oct(a)
  '0o24'
  >>> hex(a)
  '0x14'
  >>> format(a,'b')
  '10100'
  >>> format(a,'o')
  '24'
  >>> format(a,'x')
  '14'

  字符串

  字符串(python2默認使用ascii編碼，使用Unicode編碼須在字符串前加u,python3使用unicode編碼）
  a='str'
  a=u'str'

  字符串表示方法

• 單引號：'str' '1'
• 雙引號："str""1"
• 三引號：'''...str...''' """...str..."""
• 轉義字符：“str1 \tadded tab\nstr2”

• Raw字符串：r"C:\user\administrator"(無法進行轉義操作)

  字符串操作

  字符串合并

  >>> 'abc'+'def'
  'abcdef'
  >>> 'hello' *5
  'hellohellohellohellohello'
  >>> print ('-'*50)
  --------------------------------------------------
  >>> "aa""bb"
  'aabb'
  >>> 'ab''cd'
  'abcd'

  字符串取值

  a="text"
  >>> for c in a:
  ...     print (c,end='')
  ...
  text
  >>> for c in a:
  ...     print (c,end='-')
  ...
  t-e-x-t-
  >>> 'x' in a
  True
  >>> text='this_is_str'
  >>> text[0:4]
  'this'
  >>> text[5:7]
  'is'
  >>> text[:4]
  'this'
  >>> text[-3:]
  'str'
  >>> text[-12:-7]
  'this'
  >>> text[::2]
  'ti_***'
  >>> text[8:1:-2]
  'ss_i'

  字符串編碼轉換

  >>> ord('d')
  100
  >>> chr(99)
  'c'
  >>> ord('王')
  29579
  >>> chr(29579)
  '王'

  字符串大小寫轉換

• 這里利用ascii編碼進行大小寫轉換

  >>> Text=""   #初始化Text
  >>> text="aSdFgHjK"  
  >>> for i in text:
  ...     i_code=ord(i)
  ...     if 97<=i_code and i_code<=122:
  ...             Text+=chr(i_code-32)
  ...     else:
  ...             Text+=i
  ...
  >>> Text
  'ASDFGHJK'
  >>> for x in text:
  ...     x_code=ord(x)
  ...     if 65<=x_code and x_code<=90:
  ...             Text+=chr(x_code+32)
  ...     else:
  ...             Text+=x
  ...
  >>> Text
  'ASDFGHJKasdfghjk'

• 這里利用字符串的方法進行轉換

  >>> str='asdFGHzxcVBN'
  >>> str.replace('asd','ASD')
  'ASDFGHzxcVBN'

• 除此之外，還可以使用字符串的大小寫方法進行大小寫轉換

字符串方法

字符串大小寫相關的方法

• capitalize()：字符串首字母大寫

  >>> str='hello world'
  >>> str.capitalize()
  'Hello world'

• title()：字符串中單詞的首字母大寫

  >>> str.title()
  'Hello World'

• upper()：字符串轉換成大寫

  >>> str.upper()
  'HELLO WORLD'

• lower()：字符串轉換成小寫

  >>> str.lower()
  'hello world'

• swapcase()：字符串大小寫互轉

  >>> str='HellO wORld'
  >>> str.swapcase()
  'hELLo WorLD'

  字符串排版相關的方法

• center()：居中對齊

  >>> str='hello'
  >>> str.center(11)
  '   helloo  '
  >>> str.center(11,'_')
  '___helloo__'

• ljust()：居左對齊

  >>> str.ljust(11,'_')
  'helloo_____'
  >>> str.ljust(11)
  'helloo     

• rjust()：居右對齊

  >>> str.rjust(11)
  '     hello'
  >>> str.rjust(11,'_')
  '_____hello'

  • expandtabs()：修改tab空格的個數

    >>> str='hello\tworld'
    >>> print (str)
    hello   world
    >>> str.expandtabs(9)
    'hello    world'
    >>> str.expandtabs(4)
    'hello   world'

  • zfill()：將字符串擴充到指定長度，前面使用0填充

    >>> str.zfill(20)
    '000000000hello\tworld'
    >>> 'sad'.zfill(10)
    '0000000sad'

  • strip()：刪除字符串兩邊(左邊lstrip或右邊rstrip)的指定字符（默認為空格和換行符）

    >>> str='   hello world   '
    >>> str.strip()
    'hello world'
    >>> str.lstrip()
    'hello world   '
    >>> str.rstrip()
    '   hello world'
    >>> str='hello,world'
    >>> str.strip('h')
    'ello,world'
    >>> str.strip('[held]')
    'o,wor'

    字符串查找相關的方法

  • startswith(prefix[,start[,end]])/endswith(suffix[,start[,end]]) 判斷是否以特定字符串開頭或者結尾

    >>> str='hello,world'
    >>> str.startswith('hello')
    True
    >>> str.startswith('hello',0,5)
    True
    >>> str.startswith('hello',1,5)
    False
    >>> str.endswith('rld',8)
    True
    >>> str.endswith('rld',9)
    False
    >>> str.endswith('rld',8,11)
    True

• count(sub[,start[,end]])：相應字符串在文本中的個數

  >>> str='hello,world'
  >>> str.count('l')
  3
  >>> str.count('ll')
  1

• find/rfind()：分別從字符串前后開始查找第一個匹配到的字符串的位置,找不到就返回-1

  str='hello,world'
  >>> str.find('l')
  2
  >>> str.rfind('l')
  9

• index/rindex()：與find方法類似，但是找不到會報錯

  >>> str.index('l')
  2
  >>> str.rindex('l')
  9
  >>> str.index('a')
  Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  ValueError: substring not found
  >>> str.find('a')

• replace(old,new[,count])：替換字符串，count代表替換個數

  >>> str.replace('l','L')
  'heLLo,worLd'
  >>> str.replace('l','L',1)
  'heLlo,world'

  格式判斷相關方法

• isalpha() ：判斷是否是字母
• isdigit()：判斷是否是數字
• isalnum()：判斷是否是數字和字母
• islower()：判斷是否有字母，且字母為小寫字母
• isupper()：判斷是否有字幕，且字母為大寫字母
• isspace()：判斷是不是只有空格和換行符號
• istitle()：判斷字符串每個單詞的首字母是否大寫
• isdecimal()：判斷是不是數字
• isnumeric()：判斷是不是數字
• isidentifier()：判斷字符能否成為標識符
• isprintable()：判斷字符是否全部能打印的

isdigit、isdecimal、isnumeric三者的區別
isdigit()
True: Unicode數字，byte數字（單字節），全角數字（雙字節），羅馬數字
False: 漢字數字
Error: 無

isdecimal()
True: Unicode數字，，全角數字（雙字節）
False: 羅馬數字，漢字數字
Error: byte數字（單字節）

isnumeric()
True: Unicode數字，全角數字（雙字節），羅馬數字，漢字數字
False: 無
Error: byte數字（單字節）

字符串分隔

• split([sep[,maxsplit]])/rsplit([sep[,maxsplit]])：分別從左右按照sep字符串分隔，最多分隔maxsplit此，默認無數次

  >> str='asd,fgh,jkl'
  >> str.split(',')
  ['asd', 'fgh', 'jkl']
  >> str.rsplit(',',1)
  ['asd,fgh', 'jkl']

• splitlines()以\n或者\r或者\n\r分隔

  >> str='asd\nfgh\njkl'
  >> str.splitlines()
  ['asd', 'fgh', 'jkl']

• partition(sep)：將分隔符也作為一個元素列出來

  >> 'http://www.baidu.com'.partition('://')
  ('http', '://', 'www.baidu.com')

  字符串其他方法

• join()：以特定的分隔符將字符串分隔

  >> str='asdfg'
  >> '-'.join(str)
  'a-s-d-f-g'

字符串格式化輸出

python字符串格式化輸出的三種方式

1. 使用字符串格式格式化操作符——百分號%
2. 使用字符串方法 format
3. 使用 f-strings進行字符串格式化

   使用%進行格式化

   這種格式化表達式類似于C語言

注：Python中百分號格式化是不存在自動將整數轉換成二進制表示的方式

舉例

>>> "%s|%r|%c" %("this is str","this is repr","C")
"this is str|'this is repr'|C"
>>> "%d|%i|%o|%x|%X|" %(3,5,12,13,14)
'3|5|14|d|E|'
>>> "%e|%E|%f|%F|%g|%G" %(1.5E3,1.5e3,13.5,13.5,1.5e13,13.5E15)
'1.500000e+03|1.500000E+03|13.500000|13.500000|1.5e+13|1.35E+16'
>>> "%(string)-10s"%({'string':'1'})
'1 
>>> "%(float)+10.2F"%({'float':3.1})
'     +3.10'
>>> "%(float)-10.2f"%({'float':3.1})
'3.10      '

使用format方法

語法：{}.format(value)
參數:
（value):可以是整數，浮點數，字符串，字符甚至變量。
Returntype：返回一個格式化字符串，其值在占位符位置作為參數傳遞。

#位置參數
>>> username='wanger'
>>> password=123456
>>> print ("{}'s password is {}".format(username,password))
wanger's password is 123456  

>>> username='wanger'
>>> password=123456
>>> print ("{1}'s password is {0}".format(password,username))
wanger's password is 123456 

#下標參數
>>> si=['KB','MB','GB','TB','PB','EB','ZB','YB']
>>> '1000{0[0]}=1{0[1]}'.format(si)
'1000KB=1MB'

#浮點數精度
>>> '{:.4f}'.format(3.1415926)
'3.1416'
>>> '{:>10.4f}'.format(3.1415926)
'    3.1416'

>>> 'this is a test {t[0]}'.format(t='hello')
'this is a test h'
>>> 'this is a test {t[1]}'.format(t='hello')
'this is a test e'

#使用模塊作為參數
>>> import sys
>>> sys.platform
'win32'
>>> "{0.platform}".format(sys)
'win32'
>>> 'my laptop platform is {s}'.format(s=sys.platform)
'my laptop platform is win32'
>>> 'my laptop platform is (s.platform)'.format(s=sys)
'my laptop platform is (s.platform)'

#關鍵字參數
>>> 'my name is {name} ,age is {age}'.format(name='wanger',age='25')
'my name is wanger ,age is 25

當占位符{}為空時，Python將按順序替換通過str.format（）傳遞的值。
str.format（）方法中存在的值本質上是元組數據類型，元組中包含的每個單獨值都可以通過索引號調用，索引號以索引號0開頭。
第三段代碼的變量si是一個列表，{0}就代表format()方法的第一個參數，那么{0[0]}就代表列表的第一個元素，{0[1]}就代表列表的第二個元素
這個例子說明格式說明符可以通過利用（類似） Python 的語法
訪問到對象的元素或屬性。這就叫做復合字段名 (compound field names) 。

以下復合字段名都是“ 有效的 ” 。
? 使用列表作為參數，并且通過下標索引來訪問其元素（跟上
一例類似）
? 使用字典作為參數，并且通過鍵來訪問其值
? 使用模塊作為參數，并且通過名字來訪問其變量及函數
? 使用類的實例作為參數，并且通過名字來訪問其方法和屬性
? 以上方法的任意組合

表達式：format_spec ::= [[fill]align][sign][#][0][width][,][.precision][type]

• fill ::= <'any character'>
• align ::= "<"'左對齊' | ">"‘右對齊’ | "="‘在數字里，符號左對齊，數字右對齊 | "^"‘居中’
• sign ::= "+" | "-" | " "（當sign=’+‘時，即使是正數也會顯示符號，-只有為負數的時候才顯示負號，為空格時，會在正數前面留下符號位）
• width ::= integer (定義輸出的寬度)

fill和align以及后面的width相當于str方法中的center，ljust,rjust

>>> '{:+^15}'.format('start')
'+++++start+++++'
>>> '{:+^15}'.format('end')
'++++++end++++++'
>>> '{:*<15}'.format('end')
'end************'
>>> '{:*>15}'.format('start')
'**********start'
>>> '{:=+20}'.format(10)
'+                 10'
>>> print("{:=10}\n{:=+20}\n{:-^10}\n{:=-13}".format(10,10,'-',-15))
        10
+                 10
----------
-          15

• #只有在數字顯示里，顯示二進制數，八進制數，十六進制數的時候，需要顯示前面的0b,0o,0x的時候才會用到

  >>> "{0:8b},{0:8o},{0:8x}".format(10)
  '    1010,      12,       a'
  >>> "{0:b},{0:o},{0:x}".format(10)
  '1010,12,a'
  >>> ("{0:#8b},{0:#8o},{0:#8x}".format(10))
  '  0b1010,    0o12,     0xa'

• ,符號是表示數字時每三位中間加，

  >>> '{:,}'.format(100000000000)
  '100,000,000,000'

• 0是固定寬度前面補0
• .precision ::= integer(精度顯示)

  >>> '{:010.5}'.format(3.1415926)
  '00003.1416'

• type ::= "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%" (跟之前使用%表示的相等)
  ??- 當為字符時：使用s，默認就是s
  ??- 當為整數時：b,o,x和X是二進制、八進制、十六進制，c是數字按Unicode轉換成字符，d是正常十進制，默認就是d。也可以使用n來代替d

  >>> "{0:d},{0:b},{0:o},{0:x},{0:X}".format(10)
  '10,1010,12,a,A'

  ??????- 為浮點數時：e和E是指數，f和F是浮點數。g和G是同一的，也可以使用n來代替g, %是顯示百分比

  >>> "{0:e},{0:F},{0:g},{0:n},{0:%}".format(10.3)
  '1.030000e+01,10.300000,10.3,10.3,1030.000000%'

使用f-strings方法進行格式化

f-strings也稱為“格式化字符串文字”，f字符串是f在開頭有一個字符串文字，其中以 {} 包含的表達式會進行值替換。表達式在運行時進行評估，然后使用format協議進行格式化。其中以 {} 包含的表達式會進行值替換。

1. 代碼簡潔，沒有多余的引號
2. 括號{}里面的變量，可以是字符串類型，也可以是整型、浮點型，或者是復雜類型，比如數組、詞典等，會自動轉換成成字符串形式。
3. 括號{}里面還可以是函數，比如 f'數組a的長度為:{len(a)}'。一句話，只要是位于 {} 中的，都會當做 python 代碼來執行。但里面只能寫表達式，不能寫執行語句如{a=2}之類的。
4. f-string在本質上并不是字符串常量，而是一個在運行時運算求值的表達式，速度非常快

簡單舉例

>>> name='wanger'
>>> age=25
>>> f"hello,I'm {name},my age {age} "
"hello,I'm wanger,my age 25 "
#也可以使用大寫F
>>> F"hello, I'm {name},my age {age} "
"hello, I'm wanger,my age 25 "

當然也可以進行簡單的計算

>>> f"{2*3}"
'6'

也可以調用函數

>>> def test(input):
...     return input.lower()
...
>>> name='WangEr'
>>> f"{test(name)} is funny"
'wanger is funny'

還可以選擇直接調用方法

>>> name='WangEr'
>>> f"{name.lower()} is funny"
'wanger is funny'

在使用字典的時候。如果要為字典的鍵使用單引號，請記住確保對包含鍵的f字符串使用雙引號。

comedian = {'name': 'wanger', 'age': 25}
f"The comedian is {comedian['name']}, aged {comedian['age']}."
'The comedian is wanger, aged 25.'

使用字符串的場景

• 使用多個界定符分隔字符串
  split只能使用單一字符串，如果要使用多個分隔符的話，就要用到正則表達式模塊了

  >>> str='asd,dfg;zxc ert  uio'
  >>> import re
  >>> re.split(r'[;,\s]\s*',str)
  ['asd', 'dfg', 'zxc', 'ert', 'uio']

  []表示里面字符任意匹配。[;, ]表示；或者，或者空格，\s*表示任意個前面字符

• 字符串開頭或結尾匹配
  比如要看一個地址是否是http://或者ftp://開頭
  或者查看文件后綴是不是TXT格式
  可以這樣查看

  >>> url='http://www.baidu.com'
  >>> ftp='ftp://www.baidu.com'
  >>> url.startswith(('http://','ftp://'))
  True
  >>> txt='ziyuan.txt'
  >>> txt.endswith('txt')
  True
  >>> url[0:7]=="http://" or url[0:6]=="ftp://"
  True
  >>> txt[7:10]=="txt"
  True

• 用shell通配符
  我們還可以使用shell通配符來檢查文件的結尾，這需要用到fnmatch模塊
  fnmatch不區分大小寫，fnmatchcase是區分大小寫的

  >>> from fnmatch import fnmatch,fnmatchcase
  >>> fnmatch('log.txt','*.txt')
  True
  >>> fnmatch('log.TXT','*.txt')
  True
  >>> fnmatchcase('log.TXT','*.txt')
  False
  >>> fnmatchcase('log.TXT','*.TXT')
  True

• 匹配和搜索特定格式的文本
  普通匹配可以使用find方法，如果是特定格式的話還是會用到正則模塊

  >>> date1='2018/10/24'
  >>> date2='2018/12/21'
  >>> date3='2018-12-05'
  >>> def isdate(date):
  ...     if re.match(r'\d+/\d+/\d+',date):
  ...             print ('match OK')
  ...     else:
  ...             print ('not match')
  >>> isdate(date1)
  match OK
  >>> isdate(date2)
  match OK
  >>> isdate(date3)
  not match

  在正則模塊re中\d表示單個數字，+表示一個或多個前面的字段

• 搜索和替換特定的文本格式
  普通的匹配可以使用replace方法，如果匹配特定格式，還是要用正則模塊re

  >>> import re
  >>> date='today is 13/12/2018'
  >>> re.sub(r'(\d+)/(\d+)/(\d+)',r'\3,-\2-\1',date)
  'today is 2018-12-13'
  >>> datepat=re.compile(r'(\d+)/(\d+)/(\d+)')   #為了防止每次都要定義匹配模式，可以在這里定義一個匹配的變量，以后匹配直接調用這個變量
  >>> datepat.sub(r'\3,-\2-\1',date)
  'today is 2018-12-13'
  >>> date='yestory is 12/12/2018,today is 13/12/2018'
  >>> datepat.subn(r'\3,-\2-\1',date)
  ('yestory is 2018-12-12,today is 2018-12-13', 2)

  \1,\2,\3分別代表前面匹配模式中的第一個括號匹配到的，第二個括號匹配到的，第三個括號匹配到的，使用subn方法可以看到匹配到幾次

• 忽略大小寫的搜索替換
  如果要忽略大小寫還是要用到re模塊，需要用到的是re的IGNORECASE方法

  >>> import re
  >>> re.findall('replace','Replace,replace,REPLACE')
  ['replace']
  >>> re.findall('replace','Replace,replace,REPLACE',flags=re.IGNORECASE)
  ['Replace', 'replace', 'REPLACE']
  >>> str='Replace is the same as REPLACE'
  >>> re.sub('replace','WORD',str,flags=re.IGNORECASE)
  'WORD is the same as WORD'

• 最短匹配模式
  用正則表達式匹配某個文本模式，而他找到的是最長匹配，如果要匹配最短字符，可以用下面的方法

  >>> strpat=re.compile(r'\"(.*)\"')
  >>> text='this is my "name"'
  >>> strpat.findall(text)
  ['name']
  >>> text='this is my "name" and this is my "age"'
  >>> strpat.findall(text)
  ['name" and this is my "age']
  >>> strpat=re.compile(r'\"(.*?)"')
  >>> strpat.findall(text)
  ['name', 'age']

歡迎各位關注本人微信公眾號，“沒有故事的陳師傅”