### 1.3.4 Python 語言的基本成分
在自然語言中,我們用字詞、句子、段落來寫文章表達思想。類似地,編程語言也提供
各種語言成分用于構造程序表達計算。例如 HelloWorld 程序中的 print 是 Python 語言中用 于顯示輸出的一個保留詞,而"Hello, World!"則是被顯示的數據,這兩個成分組合在一 起,就構成了一條完整的語句。本節簡單介紹 Python 語言的基本成分,使讀者對 Python 編 程有個概括的了解,更多細節將在本書后面的章節中介紹。
數據和表達式
程序是處理數據的,編程語言首先要有表達數據的語言成分,例如"Hello, World!" 就是被處理的數據。數據分為不同的類型,"Hello, World!"是字符串類型的數據。除了 字符串,Python 語言還能表達和處理數值型的數據,例如:
```
>>> print 3.14
3.14
```
Python 不但能表達"Hello,World!"和 3.14 這樣的基本數據,還能表達數據運算。將 運算符施加到數據上所得到的語言構造稱為表達式。例如下面的 print 語句顯示一個表達 式的計算結果,該表達式中使用了加法(+)和乘法(*)運算符:
```
>>> print 2 + 3 * 4
14
```
變量與標識符
像"Hello, World!"和 3.14 這樣的數據稱為常量,其數據值由字面決定,并且不可 改變。Python 語言中還可以定義變量,用于表示可變的數據。變量具有名字,不同變量是通 過名字相互區分的,因此變量名具有標識作用,故稱為標識符①。
Python 語言中,標識符的構成必須符合規則:以字母或下劃線開頭,后面跟隨 0 個或多 個字母、數字、下劃線。例如:
```
x xYz x1y2 xy_123 _ (連續兩個下劃線) _123
```
等都是合法的標識符,而
```
3q x-123 first name(中間用了空格)
```
等則是非法的。
> ① Python 程序中還有函數、類、模塊等需要命名的構件,這些名字同樣都屬于標識符。
作為良好的編程風格,標識符的命名是有講究的。首先,要盡量使用有意義的名字,例 如如果要用一個變量來表示工資,可以命名為 salary、gongzi 之類,而 s 或 gz 就不是好的名字。其次,如果用兩個以上單詞組成一個名字,最好能讓人看出單詞之間的分界,具 體做法有后續單詞首字母大寫①或者用下劃線分隔等形式,例如表示出生年份的變量可以命 名為 birthYear 或 birth_year,而 birthyear 就不算是好的風格。第三,每個人應當 前后一致地使用某種命名風格,例如總是用后續單詞首字母大寫或總是用下劃線分隔單詞。 本書的示例程序中,一般以小寫字母開頭的一個或多個英文單詞作為變量名,其中后續 單詞的首字母都大寫,例如 firstName、dateOfBirth。這也是很多人慣用的命名風格。 當然,在很多簡單的示例程序中,我們也會使用很多無意義的單字母的變量名,畢竟這些程序不是正式的應用程序。
語句
語句是編程語言提供的基本命令,是程序的基本組成單元和執行單元。Python 語言提供
了多種語句,分別完成不同的功能,例如我們多次見到的 print 語句。每條語句都有規定 的語法形式和精確的語義,本書將采用“模板”的方式來介紹 Python 語句的語法。例如 print 語句的用法“模板”包括:
```
print <表達式>
print <表達式 1>, <表達式 2>, ..., <表達式 n>
```
在語句模板中我們用“<表達式>”之類的符號表示相應位置上所期待的合法語言成分。
第一個模板表示可以在 print 后面出現一個表達式,其含義是計算表達式的值并在屏幕上 顯示計算結果。第二個模板表示 print 后面可以出現用逗號分隔的多個表達式,其含義是 計算每個表達式的值,并在屏幕的同一行上顯示用空格分隔的各表達式的計算結果。例如:
```
>>> print "2 + 3 =", 2 + 3
2 + 3 = 5
```
最常用的一種語句是賦值語句,用于為變量賦值。最簡單的賦值語句的形式是:
```
<變量> = <表達式>
```
其語義是先計算<表達式>的值,再將該值存儲到<變量>中。例如:
```
>>> x = 2 + 3
```
執行結果是將 5 存儲于變量 x 中,此后在表達式中使用 x 就相當于使用 5。例如:
```
>>> print x
5
>>> print x + 1
6
```
顧名思義,變量的值隨時可以改變,例如下面的賦值語句將 x 的值從 5 改成了"Hello":
```
>>> x = "Hello"
>>> print x
Hello
```
用 Python 語言編程時,通常是使每一條語句獨占一行,而不將兩條以上的語句寫在同一 行上。如果一條語句很長,寫在一行上讀起來不方便,Python 也提供了“續行符”用于換行 繼續輸入:只要在一行的末尾輸入字符“\”再按回車鍵,就表示本行語句未完,換到下一 行繼續。例如:
```
>>> print "This is a very very looooooooooooooooooooooooooong \
sentence."
This is a very very looooooooooooooooooooooooooong sentence.
```
① 順便提一下,首單詞的首字母也大寫習慣用于“類名”,而所有字母都大寫習慣用于“常量名”。
函數
我們經常將一個語句序列定義成一個“函數”,從而將這個語句序列視為一個整體并命名。 今后在程序的任何地方,只要寫下“函數名”,就相當于寫下了構成該函數的語句序列,這稱 為“調用”該函數。例如,我們將程序 1.2 中的三條語句定義成一個函數:
```
>>> def greet():
print "Hello, Lucy."
print "How are you?"
print "Goodbye, Lucy."
>>>
```
第一行的 def 告訴 Python 我們要定義一個函數,其后的 greet 是新定義的函數的名字, greet 后面的一對括號用于表示函數的參數。雖然本例中 greet 函數沒有參數,但括號仍 然不可缺少。接下來三行是構成函數的語句序列,稱為函數體。Python 語言要求:函數體中 的語句與 def 行相比,左邊必須留一點空白(稱為“縮進”),表示它們是函數的一部分。具 體縮進多少不重要,重要的是函數體的各語句左邊要對齊。最后,交互方式下需要用一個空 行(在一行的開始處按回車鍵)來結束函數定義,使解釋器回到提示符狀態。
在此我們說明一下 Python 語言的縮進問題。一般來說,Python 程序中所有語句應該左對 齊。但在某些情況下,下一行語句要比上一行語句左邊多縮進一些空白,這是為了表達一種 隸屬關系:左縮進的語句是上面未縮進語句的下屬部分。同層次的語句總是左對齊的,因此 當下屬部分結束后,后面的語句又要恢復到未縮進的狀態。對于接觸過其他編程語言的人來 說,一開始也許會不習慣 Python 的代碼縮進,但是以后會發現強制縮進的好處,例如程序在 形式上更整齊、更容易排錯等。
上面的函數定義只是告訴 Python 將來看到 greet 時應該做什么,現在并不執行函數體 中的語句序列。將來任何時候如果想執行函數的語句,只需輸入函數名來“調用”函數,例 如:
```
>>> greet()
Hello, Lucy.
How are you?
Goodbye, Lucy.
```
注意函數名 greet 后面的一對括號,這是必須有的,表明這是一個函數調用。
作為慣例,一個 Python 程序中通常會定義一個名叫 main 的函數。對于簡單程序,可以
將程序的所有語句放在 main 函數中;對于由很多函數組成的復雜程序,可以讓 main 作為程 序的執行入口。拿程序 1.2 來說,更常見的是以如下代碼來編寫:
```
def main():
print "Hello, Lucy."
print "How are you?"
print "Goodbye, Lucy."
main()
```
注意最后一行的 main(),它的作用就是調用執行函數 main。沒有這一行,該程序僅僅定義了 函數 main,并沒有要求執行 main 函數。
雖然像程序 1.2 那樣不將所有語句定義放在函數中也是可以的,但習慣上常定義成 main。 這樣做至少有一個好處,那就是一旦導入了模塊文件,就可以通過鍵入 main()來多次執行程 序。沒有函數的話,就只能通過多次導入模塊來執行程序了。
注釋
程序中可以使用注釋,用于解釋變量的含義、函數的功能、模塊文件的創建者、程序版 本等等。注釋不僅可以幫助他人理解程序,甚至對自己也有幫助理解的作用(試想一下當你 重新拿起幾年前寫的程序想擴展程序功能時,注釋對你的幫助)。
Python 中的注釋是以“#”開始的一行,解釋器遇見“#”時會自動忽略其后直到行末的 內容。例如我們將上面的 greet()函數存入文件,并加上合適的注釋,得到以下程序:
【程序 1.3】eg1_3.py
```
# Author: Lu Chaojun
# eg1_3.py (version 1.0)
def greet():
print "Hello, Lucy."
print "How are you?"
print "Goodbye, Lucy."
greet() # call the function
```
- 前言
- 第 1 章 計算與計算思維
- 1.1 什么是計算?
- 1.1.1 計算機與計算
- 1.1.2 計算機語言
- 1.1.3 算法
- 1.1.4 實現
- 1.2 什么是計算思維?
- 1.2.1 計算思維的基本原則
- 1.2.2 計算思維的具體例子
- 1.2.3 日常生活中的計算思維
- 1.2.4 計算思維對其他學科的影響
- 1.3 初識 Python
- 1.3.1 Python 簡介
- 1.3.2 第一個程序
- 1.3.3 程序的執行方式
- 1.3.4 Python 語言的基本成分
- 1.4 程序排錯
- 1.5 練習
- 第 2 章 用數據表示現實世界
- 2.1 數據和數據類型
- 2.1.1 數據是對現實的抽象
- 2.1.1 常量與變量
- 2.1.2 數據類型
- 2.1.3 Python 的動態類型*
- 2.2 數值類型
- 2.2.1 整數類型 int
- 2.2.2 長整數類型 long
- 2.2.3 浮點數類型 float
- 2.2.4 數學庫模塊 math
- 2.2.5 復數類型 complex*
- 2.3 字符串類型 str
- 2.3.1 字符串類型的字面值形式
- 2.3.2 字符串類型的操作
- 2.3.3 字符的機內表示
- 2.3.4 字符串類型與其他類型的轉換
- 2.3.5 字符串庫 string
- 2.4 布爾類型 bool
- 2.4.1 關系運算
- 2.4.2 邏輯運算
- 2.4.3 布爾代數運算定律*
- 2.4.4 Python 中真假的表示與計算*
- 2.5 列表和元組類型
- 2.5.1 列表類型 list
- 2.5.2 元組類型 tuple
- 2.6 數據的輸入和輸出
- 2.6.1 數據的輸入
- 2.6.2 數據的輸出
- 2.6.3 格式化輸出
- 2.7 編程案例:查找問題
- 2.8 練習
- 第 3 章 數據處理的流程控制
- 3.1 順序控制結構
- 3.2 分支控制結構
- 3.2.1 單分支結構
- 3.2.2 兩路分支結構
- 3.2.3 多路分支結構
- 3.3 異常處理
- 3.3.1 傳統的錯誤檢測方法
- 3.3.2 傳統錯誤檢測方法的缺點
- 3.3.3 異常處理機制
- 3.4 循環控制結構
- 3.4.1 for 循環
- 3.4.2 while 循環
- 3.4.3 循環的非正常中斷
- 3.4.4 嵌套循環
- 3.5 結構化程序設計
- 3.5.1 程序開發過程
- 3.5.2 結構化程序設計的基本內容
- 3.6 編程案例:如何求 n 個數據的最大值?
- 3.6.1 幾種解題策略
- 3.6.2 經驗總結
- 3.7 Python 布爾表達式用作控制結構*
- 3.8 練習
- 第 4 章 模塊化編程
- 4.1 模塊化編程基本概念
- 4.1.1 模塊化設計概述
- 4.1.2 模塊化編程
- 4.1.3 編程語言對模塊化編程的支持
- 4.2 Python 語言中的函數
- 4.2.1 用函數減少重復代碼 首先看一個簡單的用字符畫一棵樹的程序:
- 4.2.2 用函數改善程序結構
- 4.2.3 用函數增強程序的通用性
- 4.2.4 小結:函數的定義與調用
- 4.2.5 變量的作用域
- 4.2.6 函數的返回值
- 4.3 自頂向下設計
- 4.3.1 頂層設計
- 4.3.2 第二層設計
- 4.3.3 第三層設計
- 4.3.4 第四層設計
- 4.3.5 自底向上實現與單元測試
- 4.3.6 開發過程小結
- 4.4 Python 模塊*
- 4.4.1 模塊的創建和使用
- 4.4.2 Python 程序架構
- 4.4.3 標準庫模塊
- 4.4.4 模塊的有條件執行
- 4.5 練習
- 第 5 章 圖形編程
- 5.1 概述
- 5.1.1 計算可視化
- 5.1.2 圖形是復雜數據
- 5.1.3 用對象表示復雜數據
- 5.2 Tkinter 圖形編程
- 5.2.1 導入模塊及創建根窗口
- 5.2.2 創建畫布
- 5.2.3 在畫布上繪圖
- 5.2.4 圖形的事件處理
- 5.3 編程案例
- 5.3.1 統計圖表
- 5.3.2 計算機動畫
- 5.4 軟件的層次化設計:一個案例
- 5.4.1 層次化體系結構
- 5.4.2 案例:圖形庫 graphics
- 5.4.3 graphics 與面向對象
- 5.5 練習
- 第 6 章 大量數據的表示和處理
- 6.1 概述
- 6.2 有序的數據集合體
- 6.2.1 字符串
- 6.2.2 列表
- 6.2.3 元組
- 6.3 無序的數據集合體
- 6.3.1 集合
- 6.3.2 字典
- 6.4 文件
- 6.4.1 文件的基本概念
- 6.4.2 文件操作
- 6.4.3 編程案例:文本文件分析
- 6.4.4 緩沖
- 6.4.5 二進制文件與隨機存取*
- 6.5 幾種高級數據結構*
- 6.5.1 鏈表
- 6.5.2 堆棧
- 6.5.3 隊列
- 6.6 練習
- 第 7 章 面向對象思想與編程
- 7.1 數據與操作:兩種觀點
- 7.1.1 面向過程觀點
- 7.1.2 面向對象觀點
- 7.1.3 類是類型概念的發展
- 7.2 面向對象編程
- 7.2.1 類的定義
- 7.2.2 對象的創建
- 7.2.3 對象方法的調用
- 7.2.4 編程實例:模擬炮彈飛行
- 7.2.5 類與模塊化
- 7.2.6 對象的集合體
- 7.3 超類與子類*
- 7.3.1 繼承
- 7.3.2 覆寫
- 7.3.3 多態性
- 7.4 面向對象設計*
- 7.5 練習
- 第 8 章 圖形用戶界面
- 8.1 圖形用戶界面概述
- 8.1.1 程序的用戶界面
- 8.1.2 圖形界面的組成
- 8.1.3 事件驅動
- 8.2 GUI 編程
- 8.2.1 UI 編程概述
- 8.2.2 初識 Tkinter
- 8.2.3 常見 GUI 構件的用法
- 8.2.4 布局
- 8.2.5 對話框*
- 8.3 Tkinter 事件驅動編程
- 8.3.1 事件和事件對象
- 8.3.2 事件處理
- 8.4 模型-視圖設計方法
- 8.4.1 將 GUI 應用程序封裝成對象
- 8.4.2 模型與視圖
- 8.4.3 編程案例:匯率換算器
- 8.5 練習
- 第 9 章 模擬與并發
- 9.1 模擬
- 9.1.1 計算機建模
- 9.1.2 隨機問題的建模與模擬
- 9.1.3 編程案例:乒乓球比賽模擬
- 9.2 原型法
- 9.3 并行計算*
- 9.3.1 串行、并發與并行
- 9.3.2 進程與線程
- 9.3.3 多線程編程的應用
- 9.3.4 Python 多線程編程
- 9.3.5 小結
- 9.4 練習
- 第 10 章 算法設計和分析
- 10.1 枚舉法
- 10.2 遞歸
- 10.3 分治法
- 10.4 貪心法
- 10.5 算法分析
- 10.5.1 算法復雜度
- 10.5.2 算法分析實例
- 10.6 不可計算的問題
- 10.7 練習
- 第 11 章 計算+X
- 11.1 計算數學
- 11.2 生物信息學
- 11.3 計算物理學
- 11.4 計算化學
- 11.5 計算經濟學
- 11.6 練習
- 附錄
- 1 Python 異常處理參考
- 2 Tkinter 畫布方法
- 3 Tkinter 編程參考
- 3.1 構件屬性值的設置
- 3.2 構件的標準屬性
- 3.3 各種構件的屬性
- 3.4 對話框
- 3.5 事件
- 參考文獻