Python變量及其使用

無論使用什么語言編程，其最終目的都是對數(shù)據(jù)進行處理。程序在編程過程中，為了處理數(shù)據(jù)更加方便，通常會將其存儲在變量中。
形象地看，變量就像一個個小容器，用于“盛裝”程序中的數(shù)據(jù)。除了變量，還有常量，它也能用來“盛裝”數(shù)據(jù)，它們的區(qū)別是，常量一旦保存某個數(shù)據(jù)之后，該數(shù)據(jù)就不能發(fā)生改變；但變量保存的數(shù)據(jù)則可以多次發(fā)生改變，只要程序?qū)ψ兞恐匦沦x值即可。
Python 使用等號（＝）作為賦值運算符，例如 a = 20 就是一條賦值語句，這條語句用于將 20 裝入變量 a 中，這個過程就被稱為賦值，即將 20 賦值給變量 a。
注意，變量名其實就是標(biāo)識符，因此在命名時，既要遵守 Python 標(biāo)識符命名規(guī)范，還要避免和 Python 內(nèi)置函數(shù)以及 Python 保留字重名。
如果你接觸過 C、C++、Java 這些高級編程語言會發(fā)現(xiàn)，它們在使用變量存儲數(shù)據(jù)時，必須指定該變量所能存儲的數(shù)據(jù)類型，以 C 語言為例：int a = 20
這行 C 語言代碼的意思是，聲明一個整形變量 a 來存儲整數(shù) 20，這就意味著，我們無法用 a 存儲小數(shù)、字符以及字符串等其他類型數(shù)據(jù)，這類編程語言被稱為強類型語言。
和強類型語言相對應(yīng)的是弱類型語言，Python 就是典型代表之一。弱類型語言有以下 2 個特征：

變量無須聲明即可直接賦值，對一個不存在的變量賦值就相當(dāng)于定義了一個新變量。

變量的數(shù)據(jù)類型可以動態(tài)改變：同一個變量可以一會兒被賦值為整數(shù)值，一會兒被賦值為字符串。

對于沒有編程基礎(chǔ)的讀者，可以先不編寫真正的 Python 程序，而是先打開 Python 的交互式解釋器，在這個交互式解釋器中“試驗” Python。首先，在 Python 解釋器中輸入如下內(nèi)容：>>> a = 5
>>>
上面代碼沒有生成任何輸出，只是向交互式解釋器中存入了一個變量 a，該變量 a 的值為 5。
如果我們想看到某個變量的值，可以直接在交互式解釋器中輸入該變量。例如，此處想看到變量 a 的值，可以直接輸入 a。>>> a
5
>>>
可以看到，Python 解釋器輸出變量 a 的值為 5。
接下來，我們嘗試改變變量 a 的值，將新的值賦給變量 a，例如：>>>a = 'Hello , Charlie'
>>>
這會導(dǎo)致變量原來的值被新值覆蓋掉，換句話說，此時變量 a 的值就不再是 5 了，而是字符串“Hello , Charlie”，a 的類型也變成了字符串。現(xiàn)在再輸入 a，讓交互式解釋器顯示 a 的值：>>> a
'Hello , Charlie'
如果想查看此時 a 的類型，可以使用 Python 的 type() 內(nèi)置函數(shù)。>>> type(a)
<class 'str'>
>>>
可以看到，a 的類型是 str（表示字符串類型）。
形象地說，函數(shù)就相當(dāng)于一個有魔法的“黑盒子”，你可以向這個“黑盒子“提供”一些數(shù)據(jù)，這個“黑盒子”會對這些數(shù)據(jù)進行處理，這種處理包括轉(zhuǎn)換和輸出結(jié)果。比如 print() 也是一個函數(shù)，它的作用就是輸出傳入的數(shù)據(jù)。此處 type() 函數(shù)的作用則用于輸出傳入數(shù)據(jù)的類型。
最后，如果想把上面的交互過程轉(zhuǎn)換成真正的 Python 程序，只要將過程中輸入的每行代碼放在一個文件中，并使用 print() 函數(shù)來輸出變量，最后將該文件保存為以 .py 結(jié)尾的源文件即可。
在交互式解釋器中，只要輸入變量名，交互式解釋器就會輸出變量的值，但在 Python 程序中則必須使用 print() 函數(shù)來輸出變量。
上面的交互過程對應(yīng)的程序如下：

#定義一個數(shù)值類型變量

a = 5

print(a)

#重新將字符串賦值給a變量

a = 'Hello , Charlie'

print(a)

print(type(a))

Python變量命名規(guī)則（超級詳細(xì)）

Python 需要使用標(biāo)識符給變量命名，其實標(biāo)識符就是用于給程序中變量、類、方法命名的符號（簡單來說，標(biāo)識符就是合法的名字）。
Python 語言的標(biāo)識符必須以字母、下畫線（_）開頭，后面可以跟任意數(shù)目的字母、數(shù)字和下畫線（_）。此處的字母并不局限于 26 個英文字母，可以包含中文字符、日文字符等。
由于 Python 3 支持 UTF-8 字符集，因此 Python 3 的標(biāo)識符可以使用 UTF-8 所能表示的多種語言的字符。Python 語言是區(qū)分大小寫的，因此 abc 和 Abc 是兩個不同的標(biāo)識符。
Python 2.x 對中文支持較差，如果要在 Python 2.x 程序中使用中文字符或中文變量，則需要在 Python 源程序的第一行增加“#coding:utf-8”，當(dāng)然別忘了將源文件保存為 UTF-8 字符集。
在使用標(biāo)識符時，需要注意如下規(guī)則：

標(biāo)識符可以由字母、數(shù)字、下畫線（_）組成，其中數(shù)字不能打頭。

標(biāo)識符不能是 Python 關(guān)鍵字，但可以包含關(guān)鍵字。

標(biāo)識符不能包含空格。

例如下面變量，有些是合法的，有些是不合法的：

• abc_xyz：合法。
• HelloWorld：合法。
• abc：合法。
• xyz#abc：不合法，標(biāo)識符中不允許出現(xiàn)“#”號。
• abc1：合法。
• 1abc：不合法，標(biāo)識符不允許數(shù)字開頭。

Python 的關(guān)鍵字和內(nèi)置函數(shù)
Python 還包含一系列關(guān)鍵字和內(nèi)置函數(shù)，一般也不建議使用它們作為變量名：

• 如果開發(fā)者嘗試使用關(guān)鍵字作為變量名，Python 解釋器會報錯。
• 如果開發(fā)者使用內(nèi)置函數(shù)的名字作為變量名，Python 解釋器倒不會報錯，只是該內(nèi)置函數(shù)就被這個變量覆蓋了，該內(nèi)置函數(shù)就不能使用了。

Python 包含了如表 1 所示的關(guān)鍵字：
表 1 Python 關(guān)鍵字FalseNoneTrueandasassert breakclasscontinuedefdelelifelse exceptfinallyforfromglobalifimportinislambdanonlocalnotorpassraisereturntrywhilewithyield
實際上 Python 非常方便，開發(fā)者可以通過 Python 程序來查看它所包含的關(guān)鍵字。例如，對于如下程序：

#導(dǎo)入keyword 模塊

import keyword

#顯示所有關(guān)鍵字

keyword.kwlist

從上面代碼可以看出，程序只要先導(dǎo)入 keyword 模塊，然后調(diào)用 keyword.kwlist 即可查看 Python 包含的所有關(guān)鍵字。運行上面程序，可以看到如下輸出結(jié)果：
['False','None','True','and','as','assert','break','class','continue','def','del','elif','else','except','finally','for','from','global','if','import','in','is','lambda','nonlocal','not','or','pass','raise','return','try','while','With','yield']
上面這些關(guān)鍵字都不能作為變量名。
此外，Python 3 還提供了如表 2 所示的內(nèi)置函數(shù)。
表 2 Python內(nèi)置函數(shù)abs()all()any()basestring()bin()bool()bytearray()callable()chr()classmethod()cmp()compile() complex()delattr()dict()dir()divmod()enumerate() eval()execfile()file()filter()float() format()frozenset()getattr()globals()hasattr()hash()help()hex()id()input()int() isinstance()issubclass()iter()len()list()locals()long()map() max()memoryview()min()next() object()oct() open() ord()pow()print()property()range()raw_input()reduce()reload()repr()reversed()zip()round() set()setattr()slice()sorted()staticmethod()str()sum()super()tuple()type()unichr()unicode() vars()xrange()Zip()__import__()apply()buffer()coerce()intern
上面這些內(nèi)置函數(shù)的名字也不應(yīng)該作為標(biāo)識符，否則 Python 的內(nèi)置函數(shù)會被覆蓋。

注意：在 Python 2.x 中，print 是關(guān)鍵字而不是函數(shù)。上面這些內(nèi)置函數(shù)（如 unicode()）只是 Python 2.x 的內(nèi)置函數(shù)，為了保證 Python 程序具有更好的兼容性，程序也不應(yīng)該使用這些內(nèi)置函數(shù)的名字作為標(biāo)識符。

Python數(shù)值類型（整形、浮點型和復(fù)數(shù)）及其用法

實際開發(fā)中，我們經(jīng)常需要使用數(shù)字記錄游戲中用戶的得分、游戲中角色的生命值、傷害值等信息，Python 語言提供了數(shù)值類型用于保存這些數(shù)值。
需要注意的是，Python 中這些數(shù)值類型都是不可改變的，也就是說，如果我們要修改數(shù)字類型變量的值，那么其底層實現(xiàn)的過程是，先將新值存放到內(nèi)存中，然后修改變量讓其指向新的內(nèi)存地址，換句話說，Python 中修改數(shù)值類型變量的值，其實只是修改變量名所表示的內(nèi)存空間。
數(shù)值類型只是一個泛泛的統(tǒng)稱，Python 中的數(shù)值類型主要包括整形、浮點型和復(fù)數(shù)類型。
Python整型
整形專門用來表示整數(shù)，即沒有小數(shù)部分的數(shù)。在 Python 中，整數(shù)包括正整數(shù)、0 和負(fù)整數(shù)。
和其他強類型語言不同，它們會提供多種整形類型，開發(fā)者要根據(jù)數(shù)值的大小，分別用不同的整形類型存儲，以 C 語言為例，根據(jù)數(shù)值的大小，開發(fā)者要合理選擇 short、int、long 整形類型存儲，大大增加了開發(fā)難度。
Python 則不同，它的整型支持存儲各種整數(shù)值，無論多大或者多小，Python 都能輕松處理（當(dāng)所用數(shù)值超過計算機自身的計算功能時，Python 會自動轉(zhuǎn)用高精度計算）。
例如如下代碼：

#定義變量a，賦值為56

a = 56

print(a)

#為a賦值一個大整數(shù)

a = 9999999999999999999999

print(a)

#type()函數(shù)用于返回變量的類型

print(type (a))

對于沒有編程基礎(chǔ)的讀者， 同樣可以在交互式解釋器中逐行“試驗”上面程序來觀看運行效果。由于篇幅限制，本教程后面的程序不再詳細(xì)列出在交互式解釋器中逐行“試驗”的過程。
上面程序中，將 9999999999999999999999 大整數(shù)賦值給變量 a，Python 也不會發(fā)生溢出等問題，程序運行一樣正常，這足以證明 Python 的強大。
使用 Python 3.x 運行上面程序，可以看到如下輸出結(jié)果：56
9999999999999999999999
<class 'int'>
從上面的輸出結(jié)果可以看出，此時 a 依然是 int 類型。
但如果用 Python 2.x 運行上面程序，由于輸入的數(shù)值比較大，Python 會自動在其后面加上字母 L（或小寫字母 l），如下輸出結(jié)果：
56
9999999999999999999999L
<type 'long'>
對比兩種輸出結(jié)果，不難發(fā)現(xiàn)：不管是 Python 3.x 還是 Python 2.x，Python 完全可以正常處理很大的整數(shù)，只是 Python 2.x 底層會將大整數(shù)當(dāng)成 long 類型處理，但開發(fā)者通常不需要理會這種細(xì)節(jié)。
除此之外，Python 的整型還支持 None 值（空值），例如如下代碼：a = None
print(a) #什么都不輸出
Python 的整型數(shù)值有 4 種表示形式：

十進制形式：最普通的整數(shù)就是十進制形式的整數(shù)，在使用十進制表示整數(shù)值時，不能以 0（零）作為十進制數(shù)的開頭（數(shù)值是 0 除外）。

二進制形式：由 0 和 1 組成，以 0b 或 0B 開頭。例如，101 對應(yīng)十進制數(shù)是 5；

八進制形式：八進制整數(shù)由 0~7 組成，以 0o 或 0O 開頭（第一個字母是零，第二個字母是大寫或小寫的 O）。需要注意的是，在 Python 2.x 中，八進制數(shù)值還可以直接以 0（零）開頭。

十六進制形式：由 0~9 以及 A~F（或 a~f）組成，以 0x 或 0X 開頭，

下面代碼片段使用了其他進制形式的數(shù)：

#以0x或0X開頭的整型數(shù)值是十六進制形式的整數(shù)

hex_value1 = 0x13

hex_value2 = 0xaF

print("hexValue1 的值為：",hex_value1)

print("hexValue2 的值為：",hex_value2)

#以0b或0B開頭的整型數(shù)值是二進制形式的整數(shù)

bin_val = 0b111

print('bin_val的值為：',bin_val)

bin_val = 0B101

print('bin_val的值為：',bin_val)

#以0o或0O開頭的整型數(shù)值是八進制形式的整數(shù)

oct_val = 0o54

print('oct_val 的值為：',oct_val)

oct_val = 0O17

print('oct_val 的值為：',oct_val)

為了提高數(shù)值（包括浮點型）的可讀性，Python 3.x 允許為數(shù)值（包括浮點型）增加下畫線作為分隔符。這些下畫線并不會影響數(shù)值本身。例如如下代碼：

#在數(shù)值中使用下畫線

one_million = 1000000

print(one_million)

price = 234_234_234 #price 實際的值為234234234

android = 1234_1234 #android 實際的值為12341234

Python浮點型
浮點型數(shù)值用于保存帶小數(shù)點的數(shù)值，Python 的浮點數(shù)有兩種表示形式：

• 十進制形式：這種形式就是平常簡單的浮點數(shù)，例如 5.12、512.0、0.512。浮點數(shù)必須包含一個小數(shù)點，否則會被當(dāng)成整數(shù)類型處理。
• 科學(xué)計數(shù)形式：例如 5.12e2（即 5.12×102）、5.12E2（也是 5.12 ×102）。

必須指出的是，只有浮點型數(shù)值才可以使用科學(xué)計數(shù)形式表示。例如 51200 是一個整型值，但 512E2 則是浮點型值。
下面程序示范了上面介紹的關(guān)于浮點數(shù)的各個知識點：

af1 = 5.2345556

#輸出af1的值

print("af1的值為：",af1)

af2 = 25.2345

print("af2的類型為：",type(af2))

f1=5.12e2

print("f1的值為：",f1)

f2 = 5e3

print("f2的值為：",f2)

print("f2的類型為：",type(f2))#看到類型為float

通過第 8 行代碼可以看出，雖然 5e3 的值是 5000，但它依然是浮點型值，而不是整型值，因為 Python 會自動將該數(shù)值變?yōu)?5000.0。
注意，使用浮點數(shù)進行計算時，可能會出現(xiàn)小數(shù)位數(shù)不確定的情況，比如說，計算 0.1+0.2，本來應(yīng)該得到 0.3，但經(jīng)過測試你會發(fā)現(xiàn)，Python解釋器的運行結(jié)果為 0.30000000000000004。幾乎所有編程語言都存在這個問題，這與浮點數(shù)在底層的存儲方式有關(guān)系（后續(xù)章節(jié)會做詳細(xì)介紹）。
Python復(fù)數(shù)
Python 甚至可以支持復(fù)數(shù)，復(fù)數(shù)的虛部用 j 或 J 來表示。
如果讀者對虛數(shù)虛部感到困惑，請直接跳過本節(jié)，大部分編程并不會用到復(fù)數(shù)這么“高級”的數(shù)學(xué)知識。
如果需要在程序中對復(fù)數(shù)進行計算，可導(dǎo)入 Python 的 cmath 模塊（c 代表 complex），在該模塊下包含了各種支持復(fù)數(shù)運算的函數(shù)。
模塊就是一個 Python 程序，Python 正是通過模塊提高了自身的可擴展性的；Python 本身內(nèi)置了大量模塊，此外還有大量第三方模塊，導(dǎo)入這些模塊即可直接使用這些程序中定義的函數(shù)。
下面程序示范了復(fù)數(shù)的用法：
純文本復(fù)制

ac1 = 3 + 0.2j

print (ac1)

print(type(ac1)) #輸出復(fù)數(shù)類型

ac2 = 4 - 0.1j

print(ac2)

#復(fù)數(shù)運行

print(ac1 + ac2) #輸出(7+0.1j)

#導(dǎo)入cmath 模塊

import cmath

#sqrt()是cmath 模塊下的商數(shù)，用于計算平方根

ac3 = cmath.sqrt(-1)

print (ac3) #輸出1j

Python字符串及基本操作（入門必看）

字符串的意思就是“一串字符”，比如“Hello,Charlie”是一個字符串，“How are you？”也是一個字符串。
Python 要求字符串必須使用引號括起來，使用單引號也行，使用雙引號也行，只要兩邊的引號能配對即可。
Python字符串和轉(zhuǎn)義字符
字符串的內(nèi)容幾乎可以包含任何字符，英文字符也行，中文字符也行。
Python 3.x 對中文字符支持較好，但 Python 2.x 則要求在源程序中增加“#coding:utf-8”才能支持中文字符。
字符串既可用單引號括起來，也可用雙引號括起來，它們沒有任何區(qū)別。例如如下程序：

str1 = 'Charlie'

str2 = "C語言中文網(wǎng)"

print(str1)

print(str2)

但需要說明的是，Python 有時候沒有我們期望的那么聰明。如果字符串內(nèi)容本身包含了單引號或雙引號，此時就需要進行特殊處理：

使用不同的引號將字符串括起來。

對引號進行轉(zhuǎn)義。

先看第一種處理方式。假如字符串內(nèi)容中包含了單引號，則可以使用雙引號將字符串括起來。例如：str3 = 'I'm a coder'
由于上面字符串中包含了單引號，此時 Python 會將字符串中的單引號與第一個單引號配對，這樣就會把 'I' 當(dāng)成字符串，而后面的 m a coder' 就變成了多余的內(nèi)容，從而導(dǎo)致語法錯誤。
為了避免這種問題，可以將上面代碼改為如下形式：
str3 = "I'm a coder"
上面代碼使用雙引號將字符串括起來，此時 Python 就會把字符串中的單引號當(dāng)成字符串內(nèi)容，而不是和字符串開始的引號配對。
假如字符串內(nèi)容本身包含雙引號，則可使用單引號將字有串括起來，例如如下代碼：
str4 = '"Spring is here,let us jam!", said woodchuck.'
接下來看第二種處理方式：使用轉(zhuǎn)義字符。Python 允許使用反斜線（）將字符串中的特殊字符進行轉(zhuǎn)義。假如字符串既包含單引號，又包含雙引號，此時必須使用轉(zhuǎn)義字符，例如如下代碼：
str5 = '"we are scared,Let's hide in the shade",says the bird'
拼接字符串
如果直接將兩個字符串緊挨著寫在一起，Python 就會自動拼接它們，例如如下代碼：

s1 = "Hello,"'Charlie'

print(s1)

上面代碼將會輸出：Hello,Charlie
上面這種寫法只是書寫字符串的一種特殊方法，并不能真正用于拼接字符串。Python 使用加號（+）作為字符串的拼接運算符，例如如下代碼：

s2 = "Python "

s3 = "iS Funny"

#使用+拼接字符串

s4 = s2 + s3

print(s4)

repr 和字符串
有時候，我們需要將字符串與數(shù)值進行拼接，而 Python 不允許直接拼接數(shù)值和字符串，程序必須先將數(shù)值轉(zhuǎn)換成字符串。
為了將數(shù)值轉(zhuǎn)換成字符串，可以使用 str() 或 repr() 函數(shù)，例如如下代碼：

s1 = "這是數(shù)字: "

p = 99.8

#字符串直接拼接數(shù)值，程序報錯

print(s1 + p)

#使用str()將數(shù)值轉(zhuǎn)換成字符串

print(s1 + str(p))

#使用repr()將數(shù)值轉(zhuǎn)換成字符串

print(s1 + repr(p))

上面程序中直接拼接字符串和數(shù)值，程序會報錯。
str() 和 repr() 函數(shù)都可以將數(shù)值轉(zhuǎn)換成字符串，其中 str 本身是 Python 內(nèi)置的類型（和 int、float 一樣），而 repr() 則只是一個函數(shù)。此外，repr 還有一個功能，它會以 Python 表達式的形式來表示值。對比如下代碼：

st = "I will play my fife"

print (st)

print(repr(st))

上面代碼中 st 本身就是一個字符串，但程序依然使用了 repr() 對字符串進行轉(zhuǎn)換。運行上面程序，可以看到如下輸出結(jié)果：
I will play my fife
'I will play my fife'
通過上面的輸出結(jié)果可以看出，如果直接使用 print() 函數(shù)輸出字符串，將只能看到字符串的內(nèi)容，沒有引號；但如果先使用 repr() 函數(shù)對字符串進行處理，然后再使用 print() 執(zhí)行輸出，將可以看到帶引號的字符串，這就是字符串的 Python 的表達式形式。
在交互式解釋器中輸入一個主量或表達式時，Python 會自動使用 repr() 函數(shù)處理該變量或表達式。
使用 input 和 raw_input 獲取用戶輸入
input() 函數(shù)用于向用戶生成一條提示，然后獲取用戶輸入的內(nèi)容。由于 input() 函數(shù)總會將用戶輸入的內(nèi)容放入字符串中，因此用戶可以輸入任何內(nèi)容，input() 函數(shù)總是返回一個字符串。
例如如下程序：

msg ＝ input("請輸入你的值：")

print (type(msg))

print(msg)

第一次運行該程序，我們輸入一個整數(shù)，運行過程如下：
請輸入你的值：2
<class 'str'>
2
第二次運行該程序，我們輸入一個浮點數(shù)，運行過程如下：
請輸入你的值： 1.2
<class 'str'>
1.2
第三次運行該程序，我們輸入一個字符串，運行過程如下：請輸入你的值：Hello
<class 'str'>
Hello
從上面的運行過程可以看出，無論輸入哪種內(nèi)容，始終可以看到 input() 函數(shù)返回字符串，程序總會將用戶輸入的內(nèi)容轉(zhuǎn)換成字符串。
需要指出的是，Python 2.x 提供了一個 raw_input() 函數(shù)，該 raw_input() 函數(shù)就相當(dāng)于 Python 3.x 中的 input() 函數(shù)。
而 Python 2.x 也提供了一個 input() 函數(shù)，該 input() 函數(shù)則比較怪異：要求用戶輸入的必須是符合 Python 語法的表達式。通常來說，用戶只能輸入整數(shù)、浮點數(shù)、復(fù)數(shù)、字符串等。重點是格式必須正確，比如輸入字符串時必須使用雙引號，否則 Python 就會報錯。
使用 Python 2.x 來運行上面程序，假如輸入一個整數(shù)，運行過程如下：
請輸入你的值：2
<class 'int'>
2
使用 Python 2.x 來運行上面程序，假如輸入一個復(fù)數(shù)，運行過程如下：請輸入你的值： 2+3j
<type 'complex'>
(2+3j)
使用 Python 2.x 來運行上面程序，假如輸入一個字符串，運行過程如下：
請輸入你的值：Hello
NameError : name 'Hello' is not defined
上面程序報錯的原因是：Python 2.x 的 input() 函數(shù)要求用戶輸入字符串時必須用引號把字符串括起來。
在 Python 2.x 中應(yīng)該盡量使用 raw_input() 函數(shù)來獲取用戶輸入；Python 2.x 中的 raw_input() 等同于 Python 3.x 中的 input()。
Python長字符串
前面介紹 Python 多行注釋時提到使用三個引號（單引號、雙引號都行）來包含多行注釋內(nèi)容，其實這是長字符串寫法，只是由于在長字符串中可以放置任何內(nèi)容，包括放置單引號、雙引號都可以，如果所定義的長字符串沒有賦值給任何變量，那么這個字符串就相當(dāng)于被解釋器忽略了，也就相當(dāng)于注釋掉了。
實際上，使用三個引號括起來的長字符串完全可以賦值給變量，例如如下程序：

s = '''"Let's go fishing", said Mary.

"OK, Let's go", said her brother.

they walked to a lake'''

print(s)

上面程序使用三個引號定義了長字符串，該長字符串中既可包含單引號，也可包含雙引號。
當(dāng)程序中有大段文本內(nèi)容要定義成字符串時，優(yōu)先推薦使用長字符串形式，因為這種形式非常強大，可以讓字符串中包含任何內(nèi)容，既可包含單引號，也可包含雙引號。
此外，Python 還允許使用轉(zhuǎn)義字符（）對換行符進行轉(zhuǎn)義，轉(zhuǎn)義之后的換行符不會“中斷”字符串。例如如下代碼：

s2 = 'The quick brown fox

jumps over the lazy dog'

print(s2)

上面 s2 字符串的內(nèi)容較長，故程序使用了轉(zhuǎn)義字符（）對內(nèi)容進行了轉(zhuǎn)義，這樣就可以把一個字符串寫成兩行。
需要說明的是，Python 不是格式自由的語言，因此 Python 程序的換行、縮進都有其規(guī)定的語法。所以，Python 的表達式不允許隨便換行。如果程序需要對 Python 表達式換行，同樣需要使用轉(zhuǎn)義字符（）進行轉(zhuǎn)義，代碼如下：

num = 20 + 3 / 4 +

2 * 3

print(num)

上面程序中有一個表達式，為了對該表達式換行，程序需要使用轉(zhuǎn)義字符。
Python原始字符串
由于字符串中的反斜線都有特殊的作用，因此當(dāng)字符串中包含反斜線時，就需要對其進行轉(zhuǎn)義。
比如寫一條 Windows 的路徑 G:publishcodes022.4，如果在 Python 程序中直接這樣寫肯定是不行的，需要寫成 G:publishcodes022.4，這很煩人，此時可借助于原始字符串來解決這個問題。
原始字符串以“r”開頭，原始字符串不會把反斜線當(dāng)成特殊字符。因此，上面的 Windows 路徑可直接寫成 r'G:publishcodes022.4'。
關(guān)于原始字符串的用法看如下程序：

s1 = r'G:publishcodes022.4'

print(s1)

如果原始字符串中包含引號，程序同樣需要對引號進行轉(zhuǎn)義（否則 Python 同樣無法對字符串的引號精確配對），但此時用于轉(zhuǎn)義的反斜線會變成字符串的一部分。
例如如下代碼：

# 原始字符串包含的引號，同樣需要轉(zhuǎn)義

s2 = r'"Let's go", said Charlie'

print(s2)

上面代碼會生成如下輸出結(jié)果："Let's go", said Charlie
由于原始字符串中的反斜線會對引號進行轉(zhuǎn)義，因此原始字符串的結(jié)尾處不能是反斜線，否則字符串結(jié)尾處的引號就被轉(zhuǎn)義了，這樣就導(dǎo)致字符串不能正確結(jié)束。
如果確實要在原始字符串的結(jié)尾處包含反斜線怎么辦呢？一種方式是不要使用原始字符串，而是改為使用長字符串寫法（三引號字符串）；另一種方式就是將反斜線單獨寫。
例如如下代碼：
純文本復(fù)制

s3 = r'Good Morning' ''

print(s3)

有什么學(xué)的蒙的可以交流

總結(jié)

以上是生活随笔為你收集整理的python计算运动会某个参赛选手的得分。数据保存在文件中_Python基础教程之第二章---变量和字符串(1) 搬运...的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。