變量，名字和對象

Python 最基本的內(nèi)置數(shù)據(jù)類型包括：
? 布爾型（表示真假的類型，僅包含 True 和 False 兩種取值）
? 整型（整數(shù)，例如 10、100000）
? 浮點(diǎn)型（小數(shù)，例如 3.14，或用科學(xué)計(jì)數(shù)法表示的數(shù)字，例如 1.0e6，它表示 1 乘以 10 的 6 次方，也可寫作 1000000.0）
? 字符串型（字符組成的序列）

Python 里所有數(shù)據(jù)——布爾值、整數(shù)、浮點(diǎn)數(shù)、字符串，甚至大型數(shù)據(jù)結(jié)構(gòu)、函數(shù)以及程序——都是以對象（object）的形式存在的。

可以把對象看作一個(gè)盒子，里面裝著數(shù)據(jù)。對象有不同類型，例如整形和浮點(diǎn)型等。類型決定了可以對它進(jìn)行的操作還決定了它存放的數(shù)據(jù)是可修改的（可變的）還是不可修改的（不可變的）?？梢园巡豢勺儗ο罂醋饕粋€(gè)密閉的透明盒子：你可以看到里面的數(shù)據(jù)，但無法修改它。同理，可以把可變對象看作一個(gè)透明可以打開的盒子：你可以打開盒子修改里面的數(shù)據(jù)。但無法改變這個(gè)盒子本身，就是無法改變對象的類型。

變量就是在程序中為了方便地引用內(nèi)存中的值而為它取的名稱。在python中使用=來為變量賦值。下面這段代碼首先將整數(shù) 1 賦值給了變量 a，之后又將 a 的值打印了出來：

>>> a=1
>>> print(a)
1

要注意賦值操作并不會(huì)實(shí)際復(fù)制值，它只是為數(shù)據(jù)對象取個(gè)相關(guān)的名字。名字是對對象的引用而不是對象本身?？梢园阉胂筚N成盒子上的標(biāo)簽。

圖片1.png

如果我們將a賦值給b，這相當(dāng)于把a(bǔ)標(biāo)簽撕下?lián)Q上b標(biāo)簽。但盒子里的數(shù)據(jù)是不變的。

>>> b=a
>>> print(b)
1

在 Python 中，如果想知道一個(gè)對象（例如一個(gè)變量或者一個(gè)字面值）的類型，可以使用語句：type( thing )。例如：

>>> type(a)
<class 'int'>
>>> type(b)
<class 'int'>
>>> type(10)
<class 'int'>
>>> type(10.1)
<class 'float'>
>>> type('abc')
<class 'str'>

變量名只能包含以下字符：
? 小寫字母（a~z）
? 大寫字母（A~Z）
? 數(shù)字（0~9）
? 下劃線（_）
名字不允許以數(shù)字開頭。以下劃線開頭的名字有特殊的含義。不要使用下面這些詞作為變量名，它們是 Python 保留的關(guān)鍵字：

這些關(guān)鍵字以及其他的一些標(biāo)點(diǎn)符號是用于描述 Python 語法的。

數(shù)字

Python 本 身 支 持 整 數(shù)（ 比 如 1 和 1000000000） 以 及 浮 點(diǎn) 數(shù)（ 比 如 3.14、1.99 和1.87e3）。你可以對這些數(shù)字進(jìn)行下表中的計(jì)算。

整數(shù)

可以定義1個(gè)正整數(shù)可以加+號也可以不加，也可以前面加一個(gè)-號變?yōu)樨?fù)數(shù)?？梢允褂脭?shù)字0，但它不能作為前綴放在其它數(shù)字后。

>>> 123
123
>>> +123
123
>>> -123
-123
>>> 0
0
>>> 01
  File "<stdin>", line 1
    01
     ^
SyntaxError: invalid token

可以使用運(yùn)算符號來進(jìn)行python的常規(guī)運(yùn)算：

#  #號是對代碼的注釋，是用來對代碼執(zhí)行的部分進(jìn)行說明，程序不執(zhí)行前面有#號的代碼
>>> 5 + 1
6
>>> 100 - 7
93　　
>>> 4 - 10
-6
>>> 10 + 9 + 3
22
>>> 4 + 3 - 2 - 1 + 6
10
#格式提示：數(shù)字和運(yùn)算符之間的空格不是強(qiáng)制的，你也可以寫成下面這種格式：
>>> 5+9 + 3
17
#只不過添加空格會(huì)使代碼看起來更工整。
>>> 5 * 3
15
>>> 3 * 5
15
>>> 3 * 5 * 2
30

Python 里有兩種除法：
? / 用來執(zhí)行浮點(diǎn)除法（十進(jìn)制小數(shù)）
? // 用來執(zhí)行整數(shù)除法（整除）
即使運(yùn)算對象是兩個(gè)整數(shù)，使用 / 仍會(huì)得到浮點(diǎn)型的結(jié)果：

>>> 9 / 5
1.8
#使用整除運(yùn)算得到的是一個(gè)整數(shù)，余數(shù)會(huì)被截去：
>>> 9 // 5
1
#如果除數(shù)為 0，任何一種除法運(yùn)算都會(huì)產(chǎn)生 Python 異常：
>>> 5 / 0
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero
>>> 7 // 0
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
ZeroDivisionError: integer division or modulo by z

也可以用數(shù)字賦值變量來進(jìn)行運(yùn)算：

>>> a=9
>>> a
9
>>> a-3
6
#上面代碼中出現(xiàn)了 a - 3，但并沒有將結(jié)果賦值給 a，因此 a 的值并未發(fā)生改變：
>>> a
9
#如果想要改變 a 的值，可以這樣寫：
>>> a = a - 3
>>> a
6

也可以先計(jì)算a-3的值，將運(yùn)算結(jié)果保存在一個(gè)臨時(shí)變量中，再將這個(gè)臨時(shí)變量的值賦回給a：

>>> a = 9
>>> temp = a - 3
>>> a = temp

當(dāng)然也可以進(jìn)一步簡化，將運(yùn)算和賦值過程合并。例如， a -= 3 等價(jià)與 a = a - 3，以此類推a += 9 等價(jià)于a = a + 9等等：

>>> a = 9
>>> a -= 3
>>> a
6
>>> a += 9
>>> a
15
>>> a *= 2
>>> a
30
>>> a /= 9
>>> a
3.3333333333333335
>>> a = 13
>>> a //= 4
>>> a
3

優(yōu)先級

在使用python運(yùn)算符時(shí)要遵循運(yùn)算符的優(yōu)先級，優(yōu)先級高的先運(yùn)行。例如：

>>> 1 / 2 + 3 * 4
12.5

/ 和 * 具有相同的優(yōu)先級并且高于 + 的優(yōu)先級，就和數(shù)學(xué)運(yùn)算一樣先有乘除，后算加減。如果想要先算加減，可以和數(shù)學(xué)運(yùn)算一樣使用括號。

>>> 1 / (2 + 3) * 4
0.8

下面這張表是官方文檔中關(guān)于優(yōu)先級的混合，高優(yōu)先級的運(yùn)算符在上面。

類型轉(zhuǎn)換

在Python當(dāng)中可以使用int()函數(shù)將其他數(shù)據(jù)類型轉(zhuǎn)換為整數(shù)，它會(huì)保留傳入數(shù)據(jù)的整數(shù)部分，并舍去小數(shù)部分。
Python 里最簡單的數(shù)據(jù)類型是布爾型，它只有兩個(gè)可選值：True 和 False。當(dāng)轉(zhuǎn)換為整數(shù)時(shí)，它們分別代表 1 和 0：

>>> int(True)
1
>>> int(False)
0

當(dāng)將浮點(diǎn)數(shù)轉(zhuǎn)換為整數(shù)時(shí)，所有小數(shù)點(diǎn)后面的部分會(huì)被舍去：

>>> int(18.6)
18
>>> int(1.0e3)
1000

也可以將僅包含數(shù)字和正負(fù)號的字符串轉(zhuǎn)換為整數(shù)，下面有幾個(gè)例子：

>>> int('99')
99
>>> int('-23')
-23
>>> int('+12')
12

將一個(gè)整數(shù)轉(zhuǎn)換為整數(shù)沒有太多意義：

>>> int(12345)
12345

如果將一個(gè)與數(shù)字無關(guān)的類型轉(zhuǎn)化為整數(shù)，會(huì)得到一個(gè)異常：

>>> int('I am batman')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 'I am batman'
>>> int('')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: ''
>>> int('5batman')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '5batman'

盡管上面例子中的字符串的確是以有效數(shù)字（5）開頭的，但它沒有就此截止，后面的內(nèi)容不是純數(shù)字，無法被 int() 函數(shù)識別，因此拋出異常。

int() 可以接受浮點(diǎn)數(shù)或由數(shù)字組成的字符串，但無法接受包含小數(shù)點(diǎn)或指數(shù)的字符串：

>>> int('98.6')
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '98.6'
>>> int('1.0e3')
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '1.0e3'

如果混合使用多種不同的數(shù)字類型進(jìn)行計(jì)算，Python 會(huì)自動(dòng)地進(jìn)行類型轉(zhuǎn)換：

>>> 4 + 7.0
11.0

與整數(shù)或浮點(diǎn)數(shù)混合使用時(shí)，布爾型的 False 會(huì)被當(dāng)作 0 或 0.0，Ture 會(huì)被當(dāng)作 1 或 1.0：

>>> True + 2
3
>>> False + 5.0
5.0

浮點(diǎn)數(shù)

整數(shù)全部由數(shù)字組成，而浮點(diǎn)數(shù)（在 Python 里稱為 float）包含非數(shù)字的小數(shù)點(diǎn)。
使用 float() 函數(shù)可以將其他數(shù)字類型轉(zhuǎn)換為浮點(diǎn)型。與之前一樣，布爾型在計(jì)算中等價(jià)于 1.0 和 0.0：

>>> float(True)
1.0
>>> float(False)
0.0

將整數(shù)轉(zhuǎn)換為浮點(diǎn)數(shù)僅僅需要添加一個(gè)小數(shù)點(diǎn)：

>>> float(98)
98.0
>>> float('99')
99.0

此外，也可以將包含有效浮點(diǎn)數(shù)（數(shù)字、正負(fù)號、小數(shù)點(diǎn)、指數(shù)及指數(shù)的前綴 e）的字符串轉(zhuǎn)換為真正的浮點(diǎn)型數(shù)字：

>>> float('98.6')
98.6
>>> float('-1.5')
-1.5
>>> float('1.0e3')
1000.0

字符串

Python 字符串是不可變的。你無法對原字符串進(jìn)行修改，但可以將
字符串的一部分復(fù)制到新字符串，來達(dá)到相同的修改效果。

使用引號創(chuàng)建

將一系列字符包裹在一對單引號或一對雙引號中即可創(chuàng)建字符串，就像下面這樣：

>>> 'XSS'
'XSS'
>>> "SQL"
'SQL'

解釋器輸出的字符串永遠(yuǎn)是用單引號包裹的，但無論使用哪種引號，Python 對字符串的處理方式都是一樣的，沒有任何區(qū)別。
既然如此，為什么要使用兩種引號？這么做的好處是可以創(chuàng)建本身就包含引號的字符串，而不用使用轉(zhuǎn)義符?？梢栽陔p引號包裹的字符串中使用單引號，或者在單引號包裹的字符串中使用雙引號：

>>> "hello 'world'."
"hello 'world'."
>>> 'hello "world".'
'hello "world".'

也可以使用連續(xù)三個(gè)單引號 '''，或者三個(gè)雙引號 """ 創(chuàng)建字符串：

>>> '''sql'''
'sql'
>>> """sql"""
'sql'

三引號在創(chuàng)建短字符串時(shí)沒有什么特殊用處。它多用于創(chuàng)建多行字符串。下面的例子我們來創(chuàng)建一個(gè)多行字符串：

>>> Weather_Control = '''Lightling storm ready
... Warning:lightling storm created
... '''
>>>

（上面這段代碼是在交互式解釋器里輸入的，第一行的提示符為 >>>，后面行的提示符為 ...，直到再次輸入三引號暗示賦值語句的完結(jié)，此時(shí)光標(biāo)跳轉(zhuǎn)到下一行并再次以 >>>提示輸入。）
如果通過單獨(dú)的單雙引號創(chuàng)建多行字符串，在輸入第一行并按下回車時(shí)，Python會(huì)彈出錯(cuò)誤提示：

>>> Weather_Control = 'Lightling storm ready
  File "<stdin>", line 1
    Weather_Control = 'Lightling storm ready
                                           ^
SyntaxError: EOL while scanning string literal

在引號包裹的字符串中，每行的換行符以及行首或行末的空格都會(huì)被保留：

>>> Weather_Control = '''Lightling storm ready
...             Warning:lightling storm created
... '''
>>> print(Weather_Control)
Lightling storm ready
                Warning:lightling storm created

>>>

值得注意的是，print() 函數(shù)的輸出與交互式解釋器的自動(dòng)響應(yīng)輸出存在一些差異：

>>> Weather_Control
'Lightling storm ready\n\t\tWarning:lightling storm created\n'

print() 會(huì)把包裹字符串的引號截去，僅輸出其實(shí)際內(nèi)容，易于閱讀。它還會(huì)自動(dòng)地在各個(gè)輸出部分之間添加空格，并在所有輸出的最后添加換行符：

>>> print('This', 1, 'car')
This 1 car

Python 允許空字符串的存在，它不包含任何字符且完全合法。可以使用前面提到的任意一種方法創(chuàng)建一個(gè)空串：

>>> ''
''
>>> ""
''
>>> ''''''
''
>>> """"""
''

為什么會(huì)用到空字符串？有些時(shí)候你想要?jiǎng)?chuàng)建的字符串可能源自另一字符串的內(nèi)容，這時(shí)需要先創(chuàng)建一個(gè)空字符串。

>>> stature = 188
>>> weight = 95
>>> batman = ''
>>> batman += 'stature:'
>>> batman += str(stature)
>>> batman += ','
>>> batman += 'weight:'
>>> batman += str(weight)
>>> batman
'stature:188,weight:95'

使用str()進(jìn)行類型轉(zhuǎn)換

使用 str() 可以將其他 Python 數(shù)據(jù)類型轉(zhuǎn)換為字符串：

>>> str(98.6)
'98.6'
>>> str(1.0e3)
'1000.0'
>>> str(True)
'True'

使用\轉(zhuǎn)義

Python 允許你對某些字符進(jìn)行轉(zhuǎn)義操作，在字符的前面添加反斜線符號 \ 會(huì)使該字符的意義發(fā)生改變。最常見的轉(zhuǎn)義符是 \n，它代表換行符，便于在一行內(nèi)創(chuàng)建多行字符串。

>>> StarCraft =  'Protoss\nZerg\nTerran'
>>> print(StarCraft)
Protoss
Zerg
Terran

轉(zhuǎn)義符 \t（tab 制表符）常用于對齊文本：

>>> print('\tabc')
        abc
>>> print('a\tbc')
a       bc
>>> print('ab\tc')
ab      c
>>> print('abc\t')
abc

（上面例子中，最后一個(gè)字符串的末尾包含了一個(gè)制表符，當(dāng)然你無法在打印的結(jié)果中看到它。）
有時(shí)你可能還會(huì)用到 ' 和 " 來表示單、雙引號，尤其當(dāng)該字符串由相同類型的引號包裹時(shí)：

>>> batman = "\"Because I am batman\""
>>> print(batman)
"Because I am batman"
>>> batman = "\'Because I am batman\'"
>>> print(batman)
'Because I am batman'

如果需要輸出一個(gè)反斜線字符，連續(xù)輸入兩個(gè)反斜線即可：

>>> print('hahaha \n')
hahaha

>>> print('hahaha \\n')
hahaha \n

python字符串格式化

Python 支持格式化字符串的輸出 。最基本的用法是將一個(gè)值插入到一個(gè)有字符串格式符 %s 的字符串中。

>>> 'hello %s' %'world'
'hello world'
>>> 'Π = %.2f' % 3.14159  # %.2f是保留兩位小數(shù)
'Π = 3.14'
>>> 'xiaoming is %d years old' % 10
'xiaoming is 10 years old'

使用+拼接

在 Python 中，你可以使用 + 將多個(gè)字符串或字符串變量拼接起來，就像下面這樣：

>>> 'Because ' + 'I am batman'
'Because I am batman'

也可以直接將一個(gè)字面字符串（非字符串變量）放到另一個(gè)的后面直接實(shí)現(xiàn)拼接：

>>> 'Because ' 'I am batman'
'Because I am batman'

進(jìn)行字符串拼接時(shí)，Python 并不會(huì)自動(dòng)添加空格。但當(dāng)調(diào)用print() 進(jìn)行打印時(shí)，Python 會(huì)在各個(gè)參數(shù)之間自動(dòng)添加空格并在結(jié)尾添加換行符：

>>> a = 'ha.'
>>> b = a
>>> c = 'haha!'
>>> a + b + c
'ha.ha.haha!'
>>> print(a,b,c)
ha. ha. haha!

使用*復(fù)制

使用 * 可以進(jìn)行字符串復(fù)制：

>>> a = 'Ha ' * 3 + '\n'
>>> b = 'Xi ' * 3 + '\n'
>>> c = 'Bye.'
>>> print(a + b + c)
Ha Ha Ha
Xi Xi Xi
Bye.

使用[ ]提取字符

在字符串名后面添加 []，并在括號里指定偏移量可以提取該位置的單個(gè)字符。第一個(gè)字符（最左側(cè)）的偏移量為 0，下一個(gè)是 1，以此類推。最后一個(gè)字符（最右側(cè)）的偏移量也可以用 -1 表示，這樣就不必從頭數(shù)到尾。偏移量從右到左緊接著為 -2、-3，以此類推。

圖片1.png

>>> str = '12345'
>>> str[0]
'1'
>>> str[1]
'2'
>>> str[-1]
'5'

如果指定的偏移量超過了字符串的長度會(huì)得到一個(gè)異常提醒：

>>> str[10]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range

位置索引在其他序列類型（列表和元組）中的使用也是如此，由于字符串是不可變的，因此你無法直接插入字符或改變指定位置的字符?？纯串?dāng)我們試圖將 'abc' 改變?yōu)?'bbc' 時(shí)會(huì)發(fā)生什么：

>>> name = 'abc'
>>> name[0] = 'b'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

為了改變字符串，我們需要組合使用一些字符串函數(shù)，例如 replace()，以及分片操作：

>>> name = 'abc'
>>> name.replace('a', 'b')
'bbc'
>>> 'b' + name[1:]
'bbc'

使用[start:end:step]分片

分片操作（slice）可以從一個(gè)字符串中抽取子字符串（字符串的一部分）。我們使用一對方
括號、起始偏移量 start、終止偏移量 end 以及可選的步長 step 來定義一個(gè)分片。其中一
些可以省略。分片得到的子串包含從 start 開始到 end 之前的全部字符。
? [:] 提取從開頭到結(jié)尾的整個(gè)字符串
? [start:] 從 start 提取到結(jié)尾
? [:end] 從開頭提取到 end - 1
? [start:end] 從 start 提取到 end - 1
? [start:end:step] 從 start 提取到 end - 1，每 step 個(gè)字符提取一個(gè)
與之前一樣，偏移量從左至右從 0、1 開始，依次增加；從右至左從 -1、-2 開始，依次減
小。如果省略 start，分片會(huì)默認(rèn)使用偏移量 0（開頭）；如果省略 end，分片會(huì)默認(rèn)使用
偏移量 -1（結(jié)尾）。
我們來創(chuàng)建一個(gè)由小寫字母組成的字符串：

>>> words = 'abcdefghijklmnopqrstuvwxyz'

使用 : 分片等價(jià)于使用 0 : -1（也就是提取整個(gè)字符串）：

>>> words[:]
'abcdefghijklmnopqrstuvwxyz'

下面是一個(gè)從偏移量 10 提取到字符串結(jié)尾的例子：

>>> words[10:]
'klmnopqrstuvwxyz'

從偏移量 10 提取到15：

>>> words[10:15]
'klmno'

提取最后 3 個(gè)字符：

>>> words[-3:]
'xyz'

下面一個(gè)例子提取了從偏移量為 18 的字符到倒數(shù)第 3 個(gè)字符：

>>> words[18:-2]
'stuvwx'

提取從倒數(shù)第 6 個(gè)字符到倒數(shù)第 2 個(gè)字符：

>>> words[-6:-2]
'uvwx'

如果需要的步長不是默認(rèn)的 1，可以在第二個(gè)冒號后面進(jìn)行指定，就像下面幾個(gè)例子所示。
從開頭提取到結(jié)尾，步長設(shè)為 6：

>>> words[::6]
'agmsy'

從偏移量 5 提取到偏移量 19，步長設(shè)為 3：

>>> words[5:20:3]
'filor'

從偏移量 20 提取到結(jié)尾，步長設(shè)為 5：

>>> words[20::5]
'uz'

（分片中 end 的偏移量需要比實(shí)際提取的最后一個(gè)字符的偏移量多 1。）
如果指定的步長為負(fù)數(shù)，Python 還會(huì)從右到左反向進(jìn)行提取操作。下面這個(gè)例子便從右到左以步長為 1 進(jìn)行提?。?/p>

>>> words[-1::-1]
'zyxwvutsrqponmlkjihgfedcba'

還可以簡寫：

>>> words[::-1]
'zyxwvutsrqponmlkjihgfedcba'

分片操作對于無效偏移量的容忍程度要遠(yuǎn)大于單字符提取操作。在分片中，小于起始位置的偏移量會(huì)被當(dāng)作 0，大于終止位置的偏移量會(huì)被當(dāng)作 -1，就像接下來幾個(gè)例子展示的一樣。
提取倒數(shù) 30 個(gè)字符：

>>> words[-30:]
'abcdefghijklmnopqrstuvwxyz'

提取從倒數(shù)第 31 到倒數(shù)第 30 個(gè)字符：

>>> words[-31:-30]
''

從開頭提取到偏移量為 31 的字符：

>>> words[:30]
'abcdefghijklmnopqrstuvwxyz'

從偏移量為 30 的字符提取到偏移量為 31 的字符：

>>> words[30:31]
''

python字符串函數(shù)

python有許多的內(nèi)置字符串函數(shù)，可以去搜索python的字符串函數(shù)。這里使用幾種常見的字符串函數(shù)來舉例。

使用len()獲取字符串長度

>>> a = 'abcdef'
>>> len(a)
6

使用split()分割

字符串函數(shù) split() 可以基于分隔符將字符串分割成由若干子串組成的列表。列表（list）是由一系列值（可以是字符串或數(shù)字等等）組成的序列，值與值之間由逗號隔開，整個(gè)列表被方括號所包括。

>>> animals = 'dog, cat rabbit. bird, wolf'
>>> animals.split(',')
['dog', ' cat rabbit. bird', ' wolf']

上面例子中，字符串名為 animals，傳入的參數(shù)為分隔符 ','。字符串將按','來進(jìn)行分割。如果不指定分隔符，那么 split() 將默認(rèn)使用空白字符。

>>> animals.split()
['dog,', 'cat', 'rabbit.', 'bird,', 'wolf']

使用join()合并

join() 函數(shù)與 split() 函數(shù)正好相反：它將包含若干子串的列表分解，并將這些子串合成一個(gè)完整的大的字符串。首先指定粘合用的字符串，然后再指定需要合并的列表：string.join(list)。下面的例子將列表中的名字通過逗號及空格粘合在一起：

>>> animals_list = ['dog', 'cat', 'panda']
>>> animals = ', '.join(animals_list)
>>> animals
'dog, cat, panda'
>>> print(animals)
dog, cat, panda

使用replace()替換

使用 replace() 函數(shù)可以進(jìn)行簡單的子串替換。你需要傳入的參數(shù)包括：需要被替換的子串，用于替換的新子串，以及需要替換多少處：

>>> animals = 'cat, cat, dog, dog, duck, rabbit, bird'
>>> animals.replace('cat', 'dog')
'dog, dog, dog, dog, duck, rabbit, bird'

只允許替換一個(gè)：

>>> animals.replace('cat', 'dog', 1)
'dog, cat, dog, dog, duck, rabbit, bird'