Python變量及其使用

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

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

變量的數據類型可以動態改變：同一個變量可以一會兒被賦值為整數值，一會兒被賦值為字符串。

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

#定義一個數值類型變量

a = 5

print(a)

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

a = 'Hello , Charlie'

print(a)

print(type(a))

Python變量命名規則（超級詳細）

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

標識符可以由字母、數字、下畫線（_）組成，其中數字不能打頭。

標識符不能是 Python 關鍵字，但可以包含關鍵字。

標識符不能包含空格。

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

• abc_xyz：合法。
• HelloWorld：合法。
• abc：合法。
• xyz#abc：不合法，標識符中不允許出現“#”號。
• abc1：合法。
• 1abc：不合法，標識符不允許數字開頭。

Python 的關鍵字和內置函數
Python 還包含一系列關鍵字和內置函數，一般也不建議使用它們作為變量名：

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

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

#導入keyword 模塊

import keyword

#顯示所有關鍵字

keyword.kwlist

從上面代碼可以看出，程序只要先導入 keyword 模塊，然后調用 keyword.kwlist 即可查看 Python 包含的所有關鍵字。運行上面程序，可以看到如下輸出結果：
['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']
上面這些關鍵字都不能作為變量名。
此外，Python 3 還提供了如表 2 所示的內置函數。
表 2 Python內置函數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
上面這些內置函數的名字也不應該作為標識符，否則 Python 的內置函數會被覆蓋。

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

Python數值類型（整形、浮點型和復數）及其用法

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

#定義變量a，賦值為56

a = 56

print(a)

#為a賦值一個大整數

a = 9999999999999999999999

print(a)

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

print(type (a))

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

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

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

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

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

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

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

hex_value1 = 0x13

hex_value2 = 0xaF

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

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

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

bin_val = 0b111

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

bin_val = 0B101

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

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

oct_val = 0o54

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

oct_val = 0O17

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

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

#在數值中使用下畫線

one_million = 1000000

print(one_million)

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

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

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

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

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

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 會自動將該數值變為 5000.0。
注意，使用浮點數進行計算時，可能會出現小數位數不確定的情況，比如說，計算 0.1+0.2，本來應該得到 0.3，但經過測試你會發現，Python解釋器的運行結果為 0.30000000000000004。幾乎所有編程語言都存在這個問題，這與浮點數在底層的存儲方式有關系（后續章節會做詳細介紹）。
Python復數
Python 甚至可以支持復數，復數的虛部用 j 或 J 來表示。
如果讀者對虛數虛部感到困惑，請直接跳過本節，大部分編程并不會用到復數這么“高級”的數學知識。
如果需要在程序中對復數進行計算，可導入 Python 的 cmath 模塊（c 代表 complex），在該模塊下包含了各種支持復數運算的函數。
模塊就是一個 Python 程序，Python 正是通過模塊提高了自身的可擴展性的；Python 本身內置了大量模塊，此外還有大量第三方模塊，導入這些模塊即可直接使用這些程序中定義的函數。
下面程序示范了復數的用法：
純文本復制

ac1 = 3 + 0.2j

print (ac1)

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

ac2 = 4 - 0.1j

print(ac2)

#復數運行

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

#導入cmath 模塊

import cmath

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

ac3 = cmath.sqrt(-1)

print (ac3) #輸出1j

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

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

str1 = 'Charlie'

str2 = "C語言中文網"

print(str1)

print(str2)

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

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

對引號進行轉義。

先看第一種處理方式。假如字符串內容中包含了單引號，則可以使用雙引號將字符串括起來。例如：str3 = 'I'm a coder'
由于上面字符串中包含了單引號，此時 Python 會將字符串中的單引號與第一個單引號配對，這樣就會把 'I' 當成字符串，而后面的 m a coder' 就變成了多余的內容，從而導致語法錯誤。
為了避免這種問題，可以將上面代碼改為如下形式：
str3 = "I'm a coder"
上面代碼使用雙引號將字符串括起來，此時 Python 就會把字符串中的單引號當成字符串內容，而不是和字符串開始的引號配對。
假如字符串內容本身包含雙引號，則可使用單引號將字有串括起來，例如如下代碼：
str4 = '"Spring is here,let us jam!", said woodchuck.'
接下來看第二種處理方式：使用轉義字符。Python 允許使用反斜線（）將字符串中的特殊字符進行轉義。假如字符串既包含單引號，又包含雙引號，此時必須使用轉義字符，例如如下代碼：
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 和字符串
有時候，我們需要將字符串與數值進行拼接，而 Python 不允許直接拼接數值和字符串，程序必須先將數值轉換成字符串。
為了將數值轉換成字符串，可以使用 str() 或 repr() 函數，例如如下代碼：

s1 = "這是數字: "

p = 99.8

#字符串直接拼接數值，程序報錯

print(s1 + p)

#使用str()將數值轉換成字符串

print(s1 + str(p))

#使用repr()將數值轉換成字符串

print(s1 + repr(p))

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

st = "I will play my fife"

print (st)

print(repr(st))

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

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

print (type(msg))

print(msg)

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

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

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

they walked to a lake'''

print(s)

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

s2 = 'The quick brown fox

jumps over the lazy dog'

print(s2)

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

num = 20 + 3 / 4 +

2 * 3

print(num)

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

s1 = r'G:publishcodes022.4'

print(s1)

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

# 原始字符串包含的引號，同樣需要轉義

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

print(s2)

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

s3 = r'Good Morning' ''

print(s3)

有什么學的蒙的可以交流

總結

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

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。