第2章 語言基礎

本章主要介紹Python語言的一些基本知識和基本概念，內容包括：Python語言的基本數據類型、Python語言的數據運算符及表達式、Python語言基本輸入/輸出功能等。它們是學習、理解與編寫Python語言程序的基礎。

學習重點或難點

●Python語言的數據類型

●常量和變量

●運算符和表達式

通過學習本章，讀者將對Python語言的基本數據及其基本運算有個全面了解與把握。

2.1 數據類型

Python 3.6中主要的內置類型有6大類，具體如下。

1）數值（numerics），包括：int（整型）、float（浮點型）、bool（布爾型）、complex（復數型）等。

2）序列（sequence），包括：list（列表）、tuple（元組）、range（范圍）、str（字符串）、bytes（字節串）、set（集合）等。

3）映射（mappings），有dict（字典）。

4）類（class）。

5）實例（instance）。

6）例外（exception）。

這里主要對數值（numerics）、字符串（str）、列表（list）、元組（tuple）、集合（set）、字典（dict）等數據類型進行介紹。

2.1.1 類型常量

在程序執行過程中，其值不發生改變的量稱為常量。下面是常用類型的不同常量情況。

1.整型常量

Python 3.x后不再分long長整型類型，為此，“51924361L”這樣的Python 2.x中的長整型常量，在Python 3.x中不再有效。Python 3.x可使用或支持任意大小的整型數。

1）十進制整型常量：十進制整型常量沒有前綴，其數碼為0～9。

合法的十進制整型常量，如：237、-568、65535、1627；

不合法的十進制整型常量，如：023（不能有前導0）、23D（含有非十進制數碼）。

2）八進制整型常量：八進制整常數必須以0o（或0O）開頭，即以0o（或0O）作為八進制數的前綴，數碼取值為0～7。八進制數通常是無符號數。

合法的八進制數，如：0o15（十進制為13）、0o101（十進制為65）、0o177777（十進制為65535）。

不合法的八進制數，如：256（無前綴0）、03A2（包含了非八進制數碼）、0127（無前綴o）。

3）十六進制整型常量：十六進制整常數的前綴為0X或0x，其數碼取值為0-9，A-F或a-f（代表10-15）。

合法的十六進制整常數，如：0X2A（十進制為42）、0XA0（十進制為160）、0XFFFF（十進制為65535）。

不合法的十六進制整常數，如：5A（無前綴0X）、0X3H（含有非十六進制數碼）。

2.浮點型常量

帶小數點的實數，譬如：0.0，15.20，-21.9，32.3+e18，-90.，-32.54e100，70.2-E12都是正確的浮點數。

不合法的浮點數常量，如：345（無小數點，是整型數了），E7（階碼標志E之前無數字），53.-E3（負號位置不對），2.7E（無階碼）等。

Python 3.x浮點數的表達精度、范圍等技術信息，可以從sys.float_info獲取。譬如：

＞＞＞import sys #先要導入sys模塊

＞＞＞sys.float_info.dig #15#表示浮點數的最大精度，可提供15位有效數位

＞＞＞sys.float_info.epsilon #一個浮點刻度（浮點數間的最小間隔值）

2.220446049250313e-16

＞＞＞sys.float_info.max #1.7976931348623157e+308 #最大浮點數

說明：命令或語句執行結果，往往會如上一樣在注釋中給出。

＞＞＞sys.float_info.max_10_exp #308#浮點數最大指數為308

＞＞＞sys.float_info.min #2.2250738585072014e-308 #最小浮點數

＞＞＞sys.float_info.min_10_exp #-307 #浮點數最小指數

包含浮點類型的其他信息請在sys.float_info結構序列中獲取。

3.復數型常量

復數有實部和虛部，它們都是浮點數。復數的基本形式：a+bj、a+bJ或者complex（a，b）表示，這里a是復數的實部，b是復數的虛部。設z=a+bj，從復數z提取它的實部和虛部，可使用z.real和z.imag方式。

帶j或J的復數，譬如：-5-4.6j，3.14j，45.j，（9.32+2e-36j），.876j，-.6545+0J，3e+26J，4.5+3e-7j等都是正確的復數。

不正確的復數常量，如：（-5-4.6），（-5-4.6）j，（9.322e-36j），4.53e-7j等。

4.布爾常量

布爾常量只有兩個：真（True）和假（False）。注意True與False的字母大小寫要求。

關于布爾值，Python中規定：任何對象都可以用來判斷其真假而用于條件、循環語句或邏輯運算中。對象判斷中None、False、0值（0、0.0、0j）、空的序列值（＂、[]、（））、空的映射值{}都為假（False）值；其他對象值都為真（True）值。

5.其他類型可能的常量形式

（1）字符串（str）

′′、′P′、′Python 3.6′、＂Python 3.6＂、＂Python’3.6＂、…

（2）列表（list）

[]、[1，2，2，3]、[1，2，2，3]、[′1′，′2′，′3′]、[′Python3.6′，100，90]、…

（3）元組（tuple）

（）、（1，2，3）、（′1′，′2′，′3′）、（′Python 3.6′，100，90，80）、…

（4）集合（set）

set（）（空集合）、{1，2，3}、{′1′，′2′，′3′}、{′Python3.6′，100，90，80}、{′Mary′，′Jim′，′Tom′，′Rose′，′Jack′}、…

（5）字典（dict）

{}或dict（）（空字典）、{′Mary′：18，′Jim′：17，′Tom′：18，′Rose：19′，′Jack′：20}、{Jan?uary：1，Feb：2，Mar：3，Apr：4，May：5}、…

2.1.2 類型變量

常量是一塊只讀的內存區域，常量一旦初始化就不能被更改。變量是計算機內存中的一塊區域，變量可以存儲規定范圍內的值，而且值可以改變?；谧兞康臄祿愋?，解釋器會分配指定大小內存，并決定什么數據可以存儲在內存中。變量命名應符合標識符命名的規定。

對于Python而言，Python的一切變量都是對象，變量的存儲采用引用語義的方式，存儲的只是一個變量的值所在的內存地址，而不是這個變量的值本身。

Python中的變量不需要聲明，每個變量在使用前都必須賦值。變量的賦值操作即是變量的聲明和定義的過程。每個變量在內存中的創建都包括變量的唯一標識id、名稱和數據值這些信息。變量內部結構示意圖如圖2-1所示。在Python中，變量就是變量，本質上變量是沒有類型的，所說的“類型”是變量所指的內存中對象的類型。因此，變量可以指定不同的數據類型，這些變量在不同時候可以存儲整數、浮點數或字符串等。

圖2-1 變量內部結構示意圖

1.變量賦值

每個變量在內存中的創建，都包括變量的標識、名稱和數據值這些信息。每個變量在使用前都必須賦值，變量賦值以后該變量才會被創建。一個變量可以通過賦值指向不同類型的對象。

等號（=）用來給變量賦值。等號（=）運算符左邊是一個變量名，右邊是存儲在變量中的值。例如：

counter=100 #賦整型值

miles=1000.0 #賦浮點型值

name=＂John＂ #賦字符串值

Python中一次新的賦值，將創建一個新的變量。即使變量的名稱相同，變量的標識也不同。例如：

x=1 #變量賦值定義一個變量x

print（id（x）） #打印變量x的標識

print（x+5） #使用變量

x=2 #變量再賦值定義一個新變量x

print（id（x）） #此時的變量x已經是一個新的變量

print（x+5） #名稱相同，但是使用的是新的變量x

x=′hello Python′ #變量繼續賦值再定義一個新變量x

print（id（x））；print（x）

此時，x又將成為一個新的變量，而且變量類型也由于所賦值的數據類型改變而發生改變。

此處，id（）為Python的內置函數，對象的唯一標識整型值。關于id（）內置函數的用法可參閱Python的幫助文檔。

如果變量沒有賦值，Python將認為該變量不存在。如：

＞＞＞print（y）

Traceback（most recent call last）：

File＂＜stdin＞＂，line1，in＜module＞

NameError：name′y′ is not defined

2.多個變量同時賦值

Python可以同時為多個變量賦值，如：a，b，c=1，2，＂john＂，表示兩個整型對象1和2分配給變量a和b，字符串對象＂john＂分配給變量c。

又如：a=b=c=1語句，創建一個整型對象其值為1，3個變量被分配引用到相同的內存空間上。

又如：a=（1，2，3） #定義一個元組

x，y，z=a #把元組序列的值分別賦給變量x、y、z

print（＂a：%d，b：%d，z：%d＂%（x，y，z））#打印結果，x，y，z按順序分

#別對應%d

【例2-1】體會變量間的相互賦值。

說明：Python變量賦值與C語言等高級語言的變量賦值不同，Python變量賦值后變量獲得賦值語句右部的常量、變量或表達式值的引用，賦值變量就成為相應類型的變量，并具有相應類型的值。

3.下畫線（_）開始的特殊變量

Python用下畫線作為變量前綴和后綴指定特殊變量。

1）_xxx變量名_xxx被看作是“私有的”，在模塊或類外不可以使用。當變量是私有的時候，用_xxx來表示變量是很好的習慣。_xxx變量是不能用′from module import?′導入的。在類中“單下畫線”開始（_foo）的成員變量或類屬性叫作保護變量，意思是只有類對象和子類對象自己能訪問到這些變量。

2）__xxx類中的私有變量名?！半p下畫線”開始（__foo）的是私有成員變量，意思是只有類對象自己能訪問，連子類對象也不能訪問到這個數據。

3）__xxx__xxx為系統定義名字。以雙下畫線開頭和結尾的（__foo__）代表Python里特殊方法專用的標識，如__init__（self，...）代表類的構造函數。這樣的系統特殊方法還有許多，如：__new__（cls[，...]）、__del__（self）、__str__（self）、__lt__（self，other）、__getitem__（self，key）、__len__（self）、__repr__（s）、__cmp__（s，o）、__call__（self，?args）等。

注意：避免用下畫線作為一般變量名的開始。

2.1.3 數值（numerics）

Python3支持int、float、bool、complex等數值類型。數值類型是不可改變的數據類型，這意味著改變數值會分配創建一個新的對象。

數值類型的賦值和計算都是很直觀的，就像大多數語言一樣。內置的type（）函數可以用來查詢變量所指的對象類型。

＞＞＞a，b，c，d=20，5.5，True，4+3j

＞＞＞print（type（a），type（b），type（c），type（d））

＜class′int′＞＜class′float′＞＜class′bool′＞＜class′complex′＞

變量賦值可以理解為是對變量數值對象的引用，為此也可以使用del語句刪除對象的引用，這樣變量就因沒定義、不存在而不能使用了。

del語句的語法：delvar1[，var2[，var3[...，varN]]]]

例如：dela，b #這樣a，b就不能使用了

下面是基本的數值運算情況：

＞＞＞5+4 #加法，結果為9

＞＞＞4.3-2 #減法，結果為2.3

＞＞＞3?7 #乘法，結果為21

＞＞＞2/4 #除法，得到一個浮點數，結果為0.5

＞＞＞2//4 #整除法，得到一個整數，結果為0

＞＞＞17%3 #取余，結果為2

＞＞＞2??5 #乘方，結果為32

注意：①數值的除法（/）總是返回一個浮點數，要獲取整數須使用整除操作符“//”；②在混合計算時，Python會把整型數轉換為浮點數。

【例2-2】浮點數運算會有舍入誤差。

#coding：gbk

a=123456.789e9；b=a+56；

print（＂a=%f＂%a）； #a=123456789000000.000000

print（＂b=%f＂%b）； #b=123456789000056.000000

a=123456.789e12；b=a+56；

print（＂a=%f＂%a）； #a=123456789000000000.000000

print（＂b=%f＂%b）； #b=123456789000000064.000000#產生舍入誤差

if1/3?3==0.99999999999999999：

print（＂1.0/3?3＜＞1＂）；#1./3?3＜＞1#說明浮點數運算有誤差

說明：從運行結果看，數值超出有效數字位數，則會產生誤差。

2.1.4 字符串（str）

字符串是一系列的字符序列，Python中用單引號（′′）、雙引號（＂＂）、3個單引號（′′′′′′）或3個雙引號（＂＂＂＂＂＂）來表示字符串常量。同時可使用反斜杠（\）轉義特殊字符（見轉義符表1-1）。

＞＞＞s=′Yes，he doesn\′t′

＞＞＞print（s，type（s），len（s）） #Yes，he doesn′t＜class′str′＞14

＞＞＞＂doesn′t＂ #＂doesn′t＂

＞＞＞′＂Yes，＂hes aid.′ #′＂Yes，＂he said.′

＞＞＞＂\＂Yes，\＂he said.＂ #′＂Yes，＂he said.′

＞＞＞′＂Isn\′t，＂she said.′ #′＂Isn\′t，＂she said.′

如果字符串包含單引號但不含雙引號，則字符串會用雙引號括起來，否則用單引號括起來。對于這樣輸入的字符串，print（）函數會產生更易讀的輸出形式。

1.轉義字符的使用

如果不需要反斜杠發生轉義，可以在字符串前面添加一個r，表示原始字符串：

＞＞＞print（′C：\some\name′）

其輸出如下：

C：\some

ame

而

＞＞＞print（r′C：\some\name′）

其輸出如下：

#C：\some\name

【例2-3】轉義字符的使用。

print（＂ab c\tde\rf\n＂）； #fab c de #注意\t，\r，\n，\b的含義

print（＂hijk\tL\bM\n＂）； #hijk M #\b退格后刪除L

另外，反斜杠可以作為續行符，表示下一行是上一行的延續。還可以使用＂＂＂...＂＂＂或者′′′...′′′跨越多行。

＞＞＞s=′Firstline.\nSecond line.′ #\n意味著新行

＞＞＞s #不使用print（），\n包含在輸出中

其輸出如下：

′First line.\nSecond line.′

而

＞＞＞print（s） #使用print（），\n輸出一個新行

其輸出如下：

First line.

Second line.

以下使用反斜線（\）來續行：

＞＞＞hello=＂This is arather long string containing\n\

...several lines of text just as you would do in C.\n\

... Note that whitespace at thebeginning of the line is\

...significant.＂

＞＞＞hello #其中的換行符仍然要使用\n表示，反斜杠后的換行符被丟棄了

輸出結果：

This is a rather long string containing\nseveral lines of text just as you would do in C.\n Note that

whitespace at the beginning of the line is significant.

＞＞＞print（hello） #產生換行效果

輸出結果：

This is a rather long string containing

several lines of text just as you would do in C.

Note that whitespace at the beginning of the line is significant.

使用3個雙引號時，換行符不需要轉義，它們會包含在字符串中。以下的例子只使用了一個轉義符（\），避免在最開始產生一個不需要的空行。

print（＂＂＂\

Usage：thingy[OPTIONS]

-h Display this usage message

-H hostname Hostname to connect to

＂＂＂）

其輸出如下：

Usage：thingy[OPTIONS]

-h Display this usage message

-H hostname Hostname to connect to

2.字符串的連接

字符串可以使用+運算符串連接在一起，或者用?運算符進行重復。

＞＞＞print（′str′+′ing′，′my′?3） #string mymymy

＞＞＞′str′′ing′ #′string′# 這樣操作正確

＞＞＞′str′.strip（）+′ing′ #′string′# 這樣操作正確

＞＞＞′str′.strip（）′ing′ # # 這樣操作錯誤

3.字符串的索引

Python中的字符串有兩種索引方式，第一種是從左往右，從0開始依次增加；第二種是從右往左，從-1開始依次減少。

第一行的數字0～5給出了字符串中索引的位置；第二行給出了相應的負數索引。分切部分從i到j分別由在邊緣被標記為i和j的全部字符組成。

注意：Python沒有單獨的字符類型，一個字符就是長度為1的字符串。

＞＞＞word=′Python′

＞＞＞print（word[0]，word[5]） #Pn

＞＞＞print（word[-1]，word[-6]） #nP

還可以對字符串進行分切，獲取一段子串。用冒號分隔兩個索引，形式：

變量[頭下標：尾下標]

截取的范圍是前閉后開，并且兩個索引都可以省略。默認的第一個索引為0，第二個索引默認為字符串可以被分切的長度。

＞＞＞word=′ilovePython′

＞＞＞word[1：5] #′love′

＞＞＞word[：] #′ilovePython′

＞＞＞word[：2] #′il′ #前兩個字符

＞＞＞word[5：]#′Python′

＞＞＞word[-10：-6] #′love′

Python中的字符串不能改變。向一個索引位置賦值，比如word[0]=′m′會導致錯誤。然而，用組合內容的方法來創建新的字符串是簡單高效的：

＞＞＞′I′+word[1：] #′IlovePython′

在分切操作字符串時，有一個很有用的規律：s[：i]+s[i：]等于s。

對于有偏差的分切索引的處理方式規定：一個過大的索引將被字符串的實際大小取代，當上限值小于下限值時，將返回一個空字符串。

＞＞＞word[1：100] #′lovePython′

＞＞＞word[20：] # #返回空字符串

＞＞＞word[2：1] # #返回空字符串

在索引中可以使用負數，這將會從右往左計數。例如：

＞＞＞word[-1] #′n′#最后一個字符

＞＞＞word[-2] #′o′#倒數第二個字符

＞＞＞word[-2：] #′on′#最后兩個字符

但要注意，-0和0完全一樣，所以-0不會從右開始計數。

＞＞＞word[-0] #′i′ #（因為-0等同于0）

超出范圍的負數索引會被截去多余負數表示的部分，但不能在一個單元素索引（非分切索引）中使用負數索引：

＞＞＞word[-100：] #′ilovePython′

＞＞＞word[-10：5] #′love′ #分別由負數索引-10與正數索引5所分切的部分

＞＞＞word[-10] #錯誤

對于非負數分切部分，如果索引都在有效范圍內，分切部分的長度就是索引的差值。例如，word[1：3]的長度是2。

內置的函數len（）用于返回一個字符串的長度：

＞＞＞len（word） #11

注意：

1）反斜杠可以用來轉義，使用r可以讓反斜杠不發生轉義。

2）字符串可以用+運算符連接在一起，用?n運算符重復n次。

3）Python中的字符串有兩種索引方式，從左往右以0開始，從右往左以-1開始。

4）Python中的字符串不能改變。

2.1.5 列表（list）

列表（list）是Python中使用最頻繁的數據類型。列表是方括號（[]）中、用逗號分隔開的元素列表。列表中元素的類型可以不相同。列表可以完成大多數集合類的數據結構實現。它支持字符、數字、字符串，甚至可以包含列表（所謂嵌套），是Python最通用的復合數據類型。

列表中值的分割（或分片、分切、切片）可以用“列表變量[頭下標：尾下標：步長]”來截取相應的列表。從左到右索引默認0開始，從右到左索引默認-1開始，下標為空，表示取到頭或尾。

＞＞＞a=[′him′，25，100，′her′]

＞＞＞print（a） #[′him′，25，100，′her′]

1）和字符串一樣，列表同樣可以被索引和切片，列表被切片后返回一個包含所含元素的新列表。首先設列表內容：Array=[2，3，9，1，4，7，6，8]。

這個是一個數字列表 [2，3，9，1，4，7，6，8]

從前面開始的索引號依次為0，1，2，3，4，5，6，7，稱為前面序號。

從后面開始的索引號依次為-8，-7，-6，-5，-4，-3，-2，-1，稱為后面序號。

＞＞＞Array[0：] #切片從前面序號“0”開始到結尾，包括“0”位

結果為：[2，3，9，1，4，7，6，8]

＞＞＞Array[：-1] #切片從后面序號“-1”到最前，不包括“-1”位

結果為：[2，3，9，1，4，7，6]

＞＞＞Array[3：-2] #切從前面序號“3”開始（包括）到從后面序號“-2”結束（不包括）

結果為：[1，4，7]

＞＞＞Array[3：：2] #從前面序號“3”（包括）到最后，其中分隔為“2”

結果為：[1，7，8]

＞＞＞Array[：：2] #從整列表中切出，分隔為“2”

結果為：[2，9，4，6]

＞＞＞Array[3：：] #從前面序號“3”開始到最后，沒有分隔

結果為：[1，4，7，6，8]

＞＞＞Array[3：：-2] #從前面序號“3”開始，往回數第2個，因為分隔為“-2”

結果為：[1，3]

＞＞＞Array[-1] #8#此為切出最后一個

＞＞＞Array[：：-1] #此為倒序

結果為：[8，6，7，4，1，9，3，2]

2）加號（+）是列表連接運算符，星號（?）是重復操作。

＞＞＞a=[1，2，3，4，5]

＞＞＞a+[6，7，8] #[1，2，3，4，5，6，7，8]

＞＞＞a?2 #[1，2，3，4，5，1，2，3，4，5]

3）與Python字符串不一樣的是，列表中的元素是可以改變的。

＞＞＞a=[1，2，3，4，5，6] #賦值

＞＞＞a[0]=9 #元素賦值改變

＞＞＞a[2：5]=[13，14，15] #區段賦值改變

＞＞＞a #[9，2，13，14，15，6]

＞＞＞a[2：5]=[] #刪除

＞＞＞a #[9，2，6]

list內置了有很多方法，例如append（）、pop（）等，這在后面會講到。

注意：

1）list寫在方括號之間，元素用逗號隔開。

2）和字符串一樣，list可以被索引和切片。

3）list中的元素是可以改變的。

2.1.6 元組（tuple）

元組（tuple）與列表類似，不同之處在于元組的元素不能修改。元組寫在小括號“（）”中，元素之間用逗號隔開。元組中的元素類型可以不同：

＞＞＞a=（1991，2014，′physics′，′math′）

＞＞＞print（a，type（a），len（a））

結果為：（1991，2014，′physics′，′math′）＜class′tuple′＞4

元組與字符串類似，可以被索引且下標索引從0開始，也可以進行截取/切片。其實，可以把字符串看作一種特殊的元組。

＞＞＞tup=（1，2，3，4，5，6）

＞＞＞print（tup[0]，tup[1：5]） #1（2，3，4，5）

＞＞＞tup[0]=11 #修改元組元素的操作是非法的

雖然tuple的元素不可改變，但它可以包含可變的對象，比如list列表。

構造包含0個或1個元素的tuple是個特殊的問題，所以有一些額外的語法規則：

tup1=（） #空元組

tup2=（20，） #一個元素，需要在元素后添加逗號

另外，元組也支持用+操作符：

＞＞＞tup1，tup2=（1，2，3），（4，5，6） #同時賦值

＞＞＞print（tup1+tup2） #+操作合并一起

結果為：（1，2，3，4，5，6）

注意：

1）與字符串一樣，元組的元素不能修改。

2）元組也可以被索引和切片，方法一樣。

3）注意構造包含0或1個元素的元組的特殊語法規則。

4）元組也可以使用+操作符進行合并。

2.1.7 集合（set）

set是一個無序不重復元素的集合，基本功能是進行成員關系測試和消除重復元素?？梢允褂么罄ㄌ柣蛘遱et（）函數創建set集合。

注意：創建一個空集合必須用set（），而不是{}，因為{}是用來創建一個空字典的。

＞＞＞student={′Tom′，′Jim′，′Mary′，′Tom′，′Jack′，′Rose′}

＞＞＞print（student） #重復的元素被自動去掉

結果為：{′Mary′，′Jim′，′Tom′，′Rose′，′Jack′}

＞＞＞′Rose′in student #True #成員測試

＞＞＞a=set（′abracadabra′）#set集合運算，先賦值

＞＞＞b=set（′alacazam′）

結果為：a為{′a′，′b′，′c′，′d′，′r′}，b為{′c′，′z′，′l′，′m′，′a′}，則：

＞＞＞a-b #{′b′，′d′，′r′} #a和b的差集

＞＞＞a|b #{′l′，′m′，′a′，′b′，′c′，′d′，′z′，′r′} #a和b的并集

＞＞＞a&b #{′a′，′c′} #a和b的交集

＞＞＞a^b #{′l′，′m′，′b′，′d′，′z′，′r′} #a和b中不同時存在的元素

2.1.8 字典（dict）

字典（dictionary，dict）是Python中非常有用的內置數據類型。字典是一種映射類型（mappingtype），它是一個無序的“鍵：值”對集合。鍵（也稱為關鍵字）必須使用不可變類型，也就是說list和包含可變類型的tuple不能作為關鍵字。在同一個字典中，關鍵字還必須互不相同。列表是有序的對象集合，字典是無序的對象集合。字典用“{}”來標識。字典中元素是通過鍵來存取的，而不是通過偏移存取。

＞＞＞dic={} #創建空字典

＞＞＞tel={′Jack′：1557，′Tom′：1320，′Rose′：1886}

＞＞＞tel

結果為：{′Tom′：1320，′Jack′：1557，′Rose′：1886}

＞＞＞tel[′Jack′] #1557#主要的操作：通過key查詢

＞＞＞deltel[′Rose′] #刪除一個鍵值對

＞＞＞tel[′Mary′]=4127 #添加一個鍵值對

＞＞＞tel

結果為：{′Tom′：1320，′Jack′：1557，′Mary′：4127}

＞＞＞list（tel.keys（）） #返回所有key組成的list

結果為：[′Tom′，′Jack′，′Mary′]

＞＞＞sorted（tel.keys（）） #按key排序

結果為：[′Jack′，′Mary′，′Tom′]

＞＞＞′Tom′in tel #True#成員測試

＞＞＞′Mary′not in tel #False#成員測試

構造函數dict（）直接從鍵值對sequence中構建字典，當然也可以進行推導，如下：

＞＞＞dict（[（′sape′，4139），（′guido′，4127），（′jack′，4098）]）

結果為：{′jack′：4098，′sape′：4139，′guido′：4127}

＞＞＞{x：x??2forxin（2，4，6）} #{2：4，4：16，6：36}

＞＞＞dict（sape=4139，guido=4127，jack=4098）

結果為：{′jack′：4098，′sape′：4139，′guido′：4127}

另外，字典類型也有一些內置的函數，例如clear（）、keys（）、values（）等。

注意：

1）字典是一種映射類型，它的元素是鍵值對。

2）字典的關鍵字必須為不可變類型，且不能重復。

3）創建空字典使用{}。

2.1.9 數據類型轉換

有時候，需要對數據類型進行轉換。數據類型的轉換，只需要將數據類型作為函數名即可。表2-1所示的內置函數可以執行數據類型之間的轉換。這些函數返回一個新的對象，表示轉換的值。

表2-1 類型轉換函數

2.2 運算符與表達式

Python語言同樣有高級語言中常用到的運算符。表達式是將不同類型的數據（常量、變量、函數）用運算符按照一定的規則連接起來的式子。下面分別介紹運算符、表達式及其相關知識。

2.2.1 運算符

Python語言支持以下類型的運算符：算術運算符、比較（關系）運算符、賦值運算符、邏輯運算符、位運算符、成員運算符、身份運算符。

（1）算術運算符

表2-2所示的算術運算符中，假設變量a為10，變量b為20。

表2-2 算術運算符

+，-，?和/等算術運算符和在許多其他語言（如Pascal或C語言）里一樣；括號可以為運算分組。有了這些運算符，Python解釋器可以作為一個簡單的計算器，在其中輸入一個表達式，它將輸出表達式的值。例如：

＞＞＞2+2 #4

＞＞＞50-5?6 #20

＞＞＞（50-5?6）/4 #5.0

＞＞＞8/5 #1.6 #總是返回一個浮點數

注意：在不同的機器上，浮點運算的結果可能會不一樣。

在整數除法中，除法（/）總是返回一個浮點數，如果只想得到整數的結果，丟棄可能的分數部分，可以使用運算符//：

＞＞＞17/3 #5.666666666666667 #整數除法返回浮點型，15～16位有效數位

＞＞＞17//3 #5 #整數除法返回向下取整后的結果

＞＞＞17%3 #2#%操作符返回除法的余數

＞＞＞5?3+2 #17

等號（′=′）用于給變量賦值。賦值后給出下一個提示符，解釋器不會顯示任何結果。

＞＞＞width=20

＞＞＞height=5?9

＞＞＞width?height #900

Python可以使用??操作來進行冪運算：

＞＞＞5??2 #25#5的平方

＞＞＞2??7 #128#2的7次方

變量在使用前必須通過“賦值來獲得定義”（即賦予變量一個值），否則會出現錯誤：

＞＞＞n#嘗試訪問一個未定義的變量

Traceback（most recent call last）：

File＂＜stdin＞＂，line 1，in＜module＞

NameError：name′n′is not defined

不同類型的數混合運算時會將整數轉換為浮點數：

＞＞＞3?3.75/1.5 #7.5

＞＞＞7.0/2 #3.5

在交互模式中，最后被輸出的表達式結果被賦值給變量“_”。這樣用戶在把Python作為一個桌面計算器使用時，可使后續計算更方便，例如：

＞＞＞tax=12.5/100

＞＞＞price=100.50

＞＞＞price?tax #12.5625

＞＞＞price+_ #113.0625 #100.50+12.5625的結果

＞＞＞round（_，2） #113.06

此處，“_”變量應被用戶視為只讀變量。不要顯式地給它賦值，若顯式對“_”變量賦值，將會創建一個具有相同名稱的獨立的本地“_”變量，并且屏蔽了這個內置變量的功能。

【例2-4】整數整除與求余示例。

print（＂%d，%d，%d，%d＂%（20//7，-20//7，20//-7，-20//-7））； #2，-3，-3，2#整除

print（＂%d，%d，%d，%d＂%（20%7，-20%7，20%-7，-20%-7））； #6，1，-1，-6#求余

print（＂%f，%f，%f，%f＂%（20.0/7，-20.0/7，20./-7，-20./-7））； #浮點相除

最后輸出的結果：2.857143，-2.857143，-2.857143，2.857143

（2）關系運算符

表2-3所列的關系（比較）運算符中，假設變量a為10，變量b為20。

表2-3 關系運算符

（續）

注意：所有關系運算符返回1表示真，返回0表示假。這與特殊的變量True和False等價。還需要注意True和False的字母大小寫。

以下演示Python中等于關系運算符的操作：

輸出結果：aisnotequaltob

（3）賦值運算符

表2-4所列的賦值運算符中，假設變量a為10，變量b為20。

表2-4 賦值運算符

以下示例演示Python中賦值運算符的操作：

a=21；b=10；c=0；

c=a+b；print（＂Value of c is＂，c） #Value of c is 31

c+=a；print（＂Value of c is＂，c） #Value of c is 52

c?=a；print（＂Value of c is＂，c） #Value of c is 1092

c/=a；print（＂Value of c is＂，c）#Value of c is 52

c=2；c%=a；print（＂Value of c is＂，c） #Value of c is 2

c??=a；print（＂Value of c is＂，c）#Value of c is 2097152

c//=a；print（＂Value of c is＂，c） #Value of c is 99864

【例2-5】復合賦值舉例。

a=2；a%=4-1； print（＂a=%d＂%a，end=′，′）； #a=2，

a?=3；a-=a；a?=a；a+=a；print（＂a=%d＂%a，end=′，′）； #a=0，

a=12；a-=a?a；a+=a； print（＂a=%d\n＂%a）； #a=-264

（4）位運算符

按位運算符是把整數轉成二進制數來進行計算。按位運算法則如表2-5所示。

表2-5 位運算符

（5）邏輯運算符

表2-6所列的邏輯運算符中，假設變量a為10，變量b為20。

表2-6 邏輯運算符

以下示例演示Python中邏輯運算符的操作：

（6）成員運算符

除了以上的一些運算符之外，Python還支持表2-7中所列的成員運算符，表示成員是否在某序列中。

以下示例演示Python中成員運算符的操作：

a=10；b=20；list=[1，2，3，4，5]；

ainlist #False

bnotinlist #True

a=2；ainlist #True

表2-7 成員運算符

（7）身份運算符

身份運算符用于比較兩個對象的存儲單元是否相同，見表2-8。

表2-8 身份運算符

以下示例演示Python中身份運算符的操作：

2.2.2 優先級

表2-9給出Python的運算符優先級，從最低的優先級（最松散地結合）到最高的優先級（最緊密地結合）。這意味著在一個表達式中，Python會首先計算表中較下面的運算符，然后再計算列在表上部的運算符。

另外，小括號可以改變優先級，有括號的情況優先計算括號中的表達式。

表2-9 運算符優先級（由低到高）

（續）

其中還沒有接觸過的運算符將在后面的章節中介紹。在表中列在同一行的運算符具有相同優先級。例如，+和-有相同的優先級。以下示例演示運算符優先級的操作：

a=20；b=10；c=15；d=5；e=0；e=（a+b）?c/d

print（＂Value of（a+b）?c/d is＂，e） #（30?15）/5=90.0

print（＂Value of（（a+b）?c）/d is＂，（（a+b）?c）/d） #（30?15）/5=90.0

print（＂Value of（a+b）?（c/d）is＂，（a+b）?（c/d）） #（30）?（15/5）=90.0

print（＂Value of a+（b?c）/d is＂，a+（b?c）/d） #20+（150/5）=50.0

2.2.3 表達式與結合性

表達式是將不同類型的數據（常量、變量、函數）用運算符按照一定的規則連接起來的式子。因此，表達式由值、變量和運算符等組成。

Python運算符通常由左向右結合，即具有相同優先級的運算符按照從左向右的順序計算。例如，2+3+4被計算成（2+3）+4。

一些運算符（如賦值運算符）是由右向左結合的，即a=b=c被處理為a=（b=c）。

2.2.4 常用內置函數

Python解釋器有如表2-10所示的有效可用的內置函數。函數的具體含義與使用參考等參考Python官網幫助文檔（注意：Python 2.x與Python 3.x內置函數稍有不同）。

表2-10 Python3.x內置函數

系統內置函數的基本使用示例如下：

abs（-3）；abs（-3.14）；abs（complex（1，-2））； #33.142.23606797749979

bin（3）；bin（-10）； #′0b11′′-0b1010′轉換為二進制

chr（32）；chr（97）；chr（22909）； #′′′a′′好′

Unicode碼轉成Unicode字符（串）。另外，ord（）是與chr（）對應相反的函數。

x=100；y=200；

eval（′x+y??2′） #40100

eval（）是字符串內表達式計算。

float（′+1.23′）；float（′ -12345\n′）；float（′1e-003′）；

結果分別為：1.23 -12345.0 0.001。

類似的類型轉換函數有：int（），str（），complex（）等。

s=input（′--＞′）

--＞Monty Python′s Flying Circus

s為＂Monty Python′s Flying Circus＂

len（′12345′）；len（[1，2，3，4，5]）；len（（1，2，3，4，5））；len（range（1，6））；

len（{1，2，3，4，5}）；len（{1：′a′，2：′b′，3：′c′，4：′d′，5：′e′}）；

結果都是5。

oct（8）；oct（-56）；#′0o10′′-0o70′

oct（）轉為八進制數，hex（）轉為十六進制數。

a=[5，2，3，1，4]

a.sort（）

排序后a為[1，2，3，4，5]。

2.3 基本輸入與輸出

完整的程序一般都要用到輸入和輸出功能。

1.輸出到屏幕

（1）print

用print加上字符串，就可以向屏幕上輸出指定的文字。比如輸出′hello，world′的代碼：

＞＞＞print（′hello，world′）

print語句也可以跟上多個字符串或表達式，用逗號“，”隔開，就可以連成一串一起輸出：

＞＞＞print（′The quick brown fox′，′jumps over′，′the lazy dog′）

輸出結果如下：

The quick brown fox jumps over the lazy dog

print會依次打印每個字符串，遇到逗號“，”會輸出一個空格。

print也可以打印輸出整數或者表達式計算結果：

＞＞＞print（300） #300

＞＞＞print（100+200） #300

還可以把計算100+200的結果打印得更清晰易讀些：

＞＞＞print（′100+200=′，100+200） #100+200=300

或如下：

＞＞＞print（′100+200=%d′%100+200） #100+200=300

注意：對于100+200，Python解釋器自動計算出結果300，但是，′100+200=′是字符串而非數學公式，Python把它視為字符串，將其原樣打印輸出。

（2）格式化輸出值

如果希望輸出的形式更加多樣，可以使用str.format（）函數來格式化輸出值。

str.format（）的基本使用如下：

＞＞＞print（′Wearethe{}whosay＂{}?。ⅰ?format（′knights′，′Ni′））

We are the knights who say＂Ni?。?/p>

在括號中的數字用于指向傳入對象在format（）中的位置，如下所示：

＞＞＞print（′{0}and{1}′.format（′spam′，′eggs′）） #spam and eggs

＞＞＞print（′{1}and{0}′.format（′spam′，′eggs′）） #eggs and spam

位置及關鍵字參數可以任意的結合：

＞＞＞print（′The story of{0}，{1}，and{other}.′.format（′Bill′，′Manfred′，other=′Georg′））

The story of Bill，Manfred，and Georg.

如果希望將輸出的值轉成字符串，可以使用repr（）或str（）函數來實現。

可以使用rjust（）—右對齊、ljust（）—左對齊和center（）—居中，來控制輸出對齊。方法zfill（）會在數字的左邊填充0，如：

＞＞＞′12′.zfill（5） #′00012′

′！a′（使用ascii（））、′！s′（使用str（））和′！r′（使用repr（））可以在格式化某個值之前對其進行轉化：

＞＞＞import math

＞＞＞print（′The value of PI is approximately{}.′.format（math.pi））

The value of PI is approximately 3.14159265359.

則輸出：

＞＞＞print（′The value of PI isapproximately{！r}.′.format（math.pi））

則輸出：

The value of PI isapproximately 3.141592653589793.

%操作符也可以實現字符串格式化。它將左邊的參數作為類似sprintf（）的格式化字符串，而將右邊的代入，然后返回格式化后的字符串。例如：

＞＞＞import math

＞＞＞print（′The value of PI is approximately%5.3f.′%math.pi）

則輸出：

The value of PI is approximately 3.142.

2.鍵盤輸入

現在已經可以用print輸出程序運行結果了。但是，如果要讓用戶從計算機輸入一些字符或數字怎么辦？Python提供了raw_input（僅用于Python2.x）、input兩個內置函數，可以從標準輸入設備（如鍵盤）進行輸入或讀取。用戶可以輸入數值或字符串，并存放到相應的變量中。

（1）raw_input函數

raw_input（[prompt]）函數從標準輸入讀取一個行，并返回一個字符串（不含換行符）：

str=raw_input（＂請你輸入：＂）； #注意Python3.6中已不用raw_input（）了

print（＂你輸入的內容是：＂，str）

在屏幕上顯示提示字符串“請你輸入：”時，輸入＂Hello Python?。?，它的輸出如下：

你輸入的內容是：Hello Python！

（2）input函數

input（[prompt]）函數和raw_input（[prompt]）函數格式基本相同。

比如輸入用戶的名字：

＞＞＞name=input（）

Michael

當輸入name=input（）并按＜Enter＞鍵后，Python交互式命令行就在等待用戶的輸入了。這時，可以輸入任意字符，然后按＜Enter＞鍵后完成輸入。

輸入完成后，不會有任何提示，Python交互式命令行又回到＞＞＞狀態了。那剛才輸入的內容就存放到name變量了。用戶可以直接輸入name或print（）查看變量內容：

＞＞＞name #′Michael′

＞＞＞print（name） #Michael

有了輸入和輸出，就可以把上次打印′hello，world′的程序改成如下的程序：

name=input（′輸入你的姓名：′）；print（′hello，′，name）

運行上面的程序，第一行代碼會讓用戶輸入任意字符作為自己的名字，然后存入name變量中；第二行代碼會根據用戶輸入的名字向用戶說hello，比如輸入Michael：

C：\Python36＞Python hello.py

輸入你的姓名：Michael

hello，Michael

每次運行該程序，根據用戶輸入的不同姓名，輸出結果也會不同。

還有注意，input（）函數在Python2.x與Python3.x中是有所不同的。例如：

str=input（＂Input data：＂）；print（＂Data is：＂，str）；

運行時如下：

Input data：100+200

（′Datais：′，300） #在Python2.x中，讀取，經計算表達式后，得到300

Datais：100+200 #在Python3.x中，讀取后得到100+200，要用eval（str）再求值

Input data：[x?5 for x in range（2，10，2）] #本輸入格式含義見后

（′Datais：′，[10，20，30，40]） #在Python 2.x中的輸出結果

Datais：[x?5 for x in range（2，10，2）] #在Python 3.x中的輸出結果

2.4 應用實例

1.math 數學標準模塊

下面是math數學標準模塊中的函數及其舉例。

（1）Python數學函數（見表2-11）

表2-11 Python數學函數

（續）

使用示例：

import math #導入math模塊

print（＂math.fabs（-45.17）：＂，math.fabs（-45.17）） #math.fabs（-45.17）：45.17

print（＂math.pow（100，-2）：＂，math.pow（100，-2）） #math.pow（100，-2）：0.0001

print（＂math.sqrt（math.pi）：＂，math.sqrt（math.pi）） #math.sqrt（math.pi）：1.77245385091

（2）Python三角函數（見表2-12）

表2-12 Python三角函數

（3）Python數學常量（見表2-13）

表2-13 Python數學常量

使用示例：

import math；

print（＂pi：＂，math.pi） #pi：3.141592653589793

print（＂e：＂，math.e） #e：2.718281828459045

print（＂sin（math.pi）：＂，math.sin（math.pi）） #sin（math.pi）：1.2246467991473532e-16

print（＂radians（30）：＂，math.radians（30）） #radians（30）：0.5235987755982988

2.random隨機數標準模塊

隨機數可以用于數學、游戲、安全等領域中，還經常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。Python包含表2-14中所列的常用隨機數函數。

表2-14 Python常用隨機數函數

使用示例：

import random

print（＂choice（[1，2，3，5]）：＂，random.choice（[1，2，3，5]）） #choice（[1，2，3，5]）：5

print（＂choice（′String′）：＂，random.choice（′String′）） #choice（′String′）：n

print（＂[0，1）間隨機數為：＂，random.random（））

結果為：[0，1）間隨機數為：0.05701773692696488

list=[20，16，10，5]；random.shuffle（list）；

print（＂重新洗牌的列表：＂，list）

結果為：重新洗牌的列表：＂，[16，10，5，20]

print（＂隨機浮點數uniform（7，14）：＂，random.uniform（7，14））

結果為：隨機浮點數uniform（7，14）：11.978279154880667

print（random.sample（range（10），6）） #[4，0，6，9，5，8] #可能的一組值

【例2-6】用random模塊來編程生成一個隨機驗證碼。

一般隨機驗證碼由大小寫字母、數學組成，下面是生成一個隨機驗證碼的程序。

import random

#生成一個65～90（大寫字母），97～122（小寫字母），48～57（數字）的序列

numbers=list（range（65，91））+list（range（97，123））+list（range（48，58））

random.shuffle（numbers） #把序列進行打亂

random_strs=random.sample（numbers，6） #得到隨機取6個數形成的列表

code=＂

for random_str in random_strs：

code+=chr（random_str） #用for循環轉成字符串，for循環詳見下章

print（code） #ov6WS3#一個隨機驗證碼

3.實踐本章例題及下列應用實例

【例2-7】給出下列關于：字符串、列表、元組、字典等的相關輸出結果。

str=＂Hello World！＂

print（str，str[0]，str[2：5]，str[2：]，str?2，str+＂TEST＂）

輸出結果：

Hello World！H llo llo World！Hello World！Hello World！Hello World！TEST

List=[＂abcd＂，786，2.23，＂john＂，70.2]

tinylist=[123，＂john＂]

print（List，List[0]，List[1：3]，List[2：]，tinylist?2，List+tinylist）

Tuple=（＂abcd＂，786，2.23，＂john＂，70.2）

tinytuple=（123，＂john＂）

print（Tuple，Tuple[0]，Tuple[1：3]，Tuple[2：]，tinytuple?2，Tuple+tinytuple）

輸出結果：

[′abcd′，786，2.23，′john′，70.2]abcd[786，2.23][2.23，′john′，70.2][123，′john′，123，′john′][′abcd′，786，2.23，′john′，70.2，123，′john′]

Tuple=（＂abcd＂，786，2.23，＂john＂，70.2）；List=[＂abcd＂，786，2.23，＂john＂，70.2]；

Tuple[2]=1000 #錯誤！元組元素不可更新

List[2]=1000 #正確！列表元素可更新

dict={}；dict[＂one＂]=＂This is one＂；dict[2]=＂This is two＂

tinydict={＂name＂：＂john＂，＂code＂：6734，＂dept＂：＂sales＂}

print（dict[＂one＂]，dict[2]，tinydict，tinydict.keys（），tinydict.values（））

輸出結果（分兩行）：

This is one{′name′：′john′，′code′：6734，′dept′：′sales′}dict_keys（[′name′，′code′，′dept′]）

dict_values（[′john′，6734，′sales′]）

【例2-8】已知A=23456，B=56789，C=A+B，打印一個求A、B兩數和C的豎式。

a=23456；b=56789；

print（＂%8d\n＂%a）；

print（＂%2c%6d\n＂%（′+′，b））；

print（＂%8s\n＂%＂--------＂）；

c=a+b；print（＂%8d\n＂%c）；

運行結果：

【例2-9】混合運算示例。

x=5；y=6；a=7.89；b=8.9；

c=x+a； d=y+b； #混合運算

print（c）；print（d）； #12.89 14.9

print（＂x+a=%f，y+b=%f\n＂%（c，d））； #x+a=12.890000，y+b=14.900000

【例2-10】不借助第三個變量，通過計算的方法交換兩個變量的值。

a=10；b=20；

print（＂a=%d，b=%d\n＂%（a，b））； #a=10，b=20

a+=b； #此時，a是a+b的值30

b=a-b； #此時，b是30-20的值10，即原來的a

a-=b； #此時，a是30-10的值20，即原來的b

print（＂a=%d，b=%d\n＂%（a，b））； #a=20，b=10

2.5 習題

一、選擇題

1.下面屬于合法變量名的是（ ）。

A.y_XYZ B.234BCD C.and D.x-y

2.下面屬于合法的整常數的是（ ）。

A.100 B.&O100 C.&H100 D.%100

3.表達式16/4-2??5?8/4%5//2的值是（ ）。

A.14.0 B.4.0 C.20.0 D.2.0

4.一條語句要在下一行繼續寫，用（ ）符號作為續行符。

A.+ B.\ C._ D.；

二、簡答與編程題

1.將數學公式

轉換成Python語言表達式。

2.求表達式“3.5+（8/2?（3.5+6.7）/2）%4”的值。

3.設整型變量x，y，z均為3，則執行“x-=y-x”后，x等于多少？執行“x%=y+z”后，x等于多少？

4.若有x=32，y=3；求表達式～x&y的值。

5.已知a=37，b=28；求解如下各輸出結果。

print（＂%d＂%（a&b））；print（＂%d＂%（a|b））； print（＂%d＂%（a^b））；

print（＂%d＂%（a＞＞2））； print（＂%d＂%（b＜＜2））；

6.編程序從鍵盤輸入一個字符，然后輸出該字符及其ASCII碼值。

7.輸入一個華氏溫度，輸出攝氏溫度。公式：C=5/9（F-32），結果取兩位小數。

8.編程計算e^3.1415926的值，精確到6位小數（e^x的庫函數為exp（））。