### 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.
```
![](img/程序设计思想与方法25151.png)① 顺便提一下,首单词的首字母也大写习惯用于“类名”,而所有字母都大写习惯用于“常量名”。
函数
我们经常将一个语句序列定义成一个“函数”,从而将这个语句序列视为一个整体并命名。 今后在程序的任何地方,只要写下“函数名”,就相当于写下了构成该函数的语句序列,这称 为“调用”该函数。例如,我们将程序 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 事件
- 参考文献