零基础学习Python

第一步

接下来我们将看见如何在 Python 中运行一个传统的“Hello World”程序。这里将会教你如何编写、保存与运行 Python 程序。

通过 Python 来运行的你的程序有两种方法——使用交互式解释器提示符或直接运行一个源代码文件。我们将了解如何使用他们二者的功能。

使用解释器提示符

在你的操作系统中打开终端(Terminal)程序。

然后通过输入 python3 并按下 enter 键来打开 Python 提示符(Python Prompt)。 当你启动 Python 后,你会看见在你能开始输入内容的地方出现了 >>> 。这个被称作 Python解释器提示符(Python Interpreter Prompt) 。 在 Python 解释器提示符,输入:

print ("HELLO WORLD")

在输入完成后按下 enter 键。你将会看到屏幕上打印出 HELLO WORLD 字样。

下面是一个在 Mac OS X 电脑上你能够看见的结果的示例。有关 Python 软件的细节将会因为 你使用的电脑而有所不同,但是从提示符(如 >>> )开始部分应该是相同的,而不会受到操 作系统的影响。

$ python3
Python 3.7.3 (v3.7.3:ef4ec6ed12, Mar 25 2019, 16:52:21) 
[Clang 6.0 (clang-600.0.57)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> print ("HELLO WORLD")
HELLO WORLD

你自然会注意到,Python 会立即给你输出了一行结果!你刚才所输入的便是一句独立的 Python 语句 。我们使用 print (不必太过惊讶)命令来打印你所提供的信息。在这里,我 们提供了文本 Hello World ,然后它便被迅速地打印到了屏幕上。

如何退出解释器提示符

如果你正在使用一款 GNU/Linux 或 OS X 上的 Shell 程序,你可以通过按下 ctrl + d 组 合键或是输入 exit() (注意:要记住要包含括号 () )并敲下 enter 来退出解释器提示 符。

如果你使用的是 Windows 命令提示符,可以按下 ctrl + z 组合键并敲击 enter 键来 退出。

选择一款编辑器

  • PyCharm
  • Vim
  • Emacs

使用一份源代码文件

现在让我们回到编程中来。在你学习一门新的编程语言时有一项传统,你所编写并运行的第 一个程序应该是 “Hello World” 程序——它所做的全部工作便是宣言你所运行的“Hello World”这句话。

启动你所选择的编辑器,输入如下程序并将它保存为 hello.py 。

打开一个新文件名将其命名为 hello.py ,然后输入如下内容:

 print("hello world")

你应当将文件保存到哪里?保存到任何你知道其位置与路径的文件夹。如果你不了解这句话 是什么意思,那就创建一个新文件夹并用这一路径来保存并运行你所有的 Python 程序

你可以在终端上使用 mkdir 命令,如 mkdir /tmp/py 。

提示:你需要经常确认并确保你为文件赋予了 .py 扩展名,例如 foo.py 。

要想运行你的 Python 程序:

  1. 打开终端窗口(你可查阅先前的安装章节来了解应该怎么做)。
  2. 使用 cd 命令来改变目录到你保存文件的地方,例如 cd /tmp/py 。
  3. 通过输入命令 python3 hello.py 来运行程序。程序的输出结果应如下方所示:
$ python3 hello.py
hello world

如果你得到了与类似的输出结果,那么恭喜你!——你已经成功运行了你的第一个 Python 程序。你亦已经成功穿过了学习编程的最困难的部分,也就是,开始编写你的第一个程序

如果你遭遇了什么错误,请确认是否已经正确地输入了上面所列出的内容,并尝试重新运行 程序。要注意 Python 是区分大小写的,如 print 和 Print 是不同的——注意前者的 p 是 小写的,而后者的 P 是大写的。此外,你需要确保每一行的第一个字符前面都没有任何空格 或制表格——我们会在后面了解 为什么这件事如此重要。

它是如何工作的

一款 Python 程序是由 语句 所构成的。在我们的第一个程序中,我们只有一条语句。在这条

语句中,我们调用 print 语句 来搭配我们提供的文本”hello world“。

获取帮助

如果你需要获得 Python 中有关任何函数或语句的快速信息,你可以使用其内置的 help 功 能。这在使用解释器提示符时十分有用。例如,运行 help(‘len’) 命令——这将显示出有关len 函数的帮助,了解其是用来计算项目数量的。

按下 q 键可以退出帮助。

类似地,你可以通过此方式获得几乎所有有关 Python 的信息。使用 help() 命令来了解有关help 它本身的更多信息吧!

如果你需要获得有关 return 这类运算符的帮助,你需要做的就是将它们放在引号中,就像help(‘return’) 这般,这样 Python 就不会混淆我们正在试图做的事情。


基础

只是打印出 hello world 肯定是不够的,是吗?你会希望做得比这还要多——你想要输入一 些内容,操纵它,然后从中得到一些输出出来的内容。我们可以在 Python 中通过使用变量与 常量来实现这一目标,在本节中我们还会学习其它的一些概念。

注释

注释 是任何存在于 # 号右侧的文字,其主要用作写给程序读者看的笔记。 举个例子:

print ("Hello World") # print 是一个函数

或者:

#print 是一个函数
print ("Hello World")

你应该在你的程序中尽可能多地使用有用的注释:

  • 解释假设
  • 说明重要的决定
  • 解释重要的细节
  • 说明你想要解决的问题 说明你想要在程序中克服的问题,等等。

代码会告诉你怎么做,注释会告诉你为何如此。

这样做对你的程序的读者来说非常有用,他们可以很容易地理解你的程序是做什么的。

字面量常量

一个字面常量(Literal Constants)2的例子是诸如 5 、 1.23 这样的数字,或者是如 这是一

串文本 或 This is a string 这样的文本。用这样的称呼是因为它们是 字面上的 3——你用的就是它字面意义上的值或是内容。数字 2 总是表示它本身而非其他含义——它是一个 常量,因为它的值不能被改变。因此,所有的这 些都被称作字面常量。

数字

数字主要分为两种类型——整数(Integers)与浮点数(Floats)

有关整数的例子即 2 ,它只是一个整数。

有关浮点数(Floating Point Numbers,在英文中也会简写为 floats )的例子是 52.3E-4 。其中, E 表示 10 的幂。在这里, 52.3E-4 表示 52.3 * 10^-4 。

针对有经验的程序员的提示

没有单独的 long 类型。 int 类型可以指任何大小的整数。

字符串

3.23 或52.3E-4 。其中, E 表示 10 的幂。在这里, 52.3E-4 表示 52.3 * 10^-4 。

字符串

一串字符串(String)是 字符(Characters) 的 序列(Sequence)。基本上,字符串就是一 串词汇。

你将会在几乎所有你撰写的 Python 程序中使用字符串,所以对下面的部分你要多上点心。

  1. 单引号

你可以使用单引号来指定字符串,例如 ‘将我这样框进来’ 或 ‘Quote me on this’ 。 所有引号内的空间,诸如空格与制表符,都将按原样保留。

  1. 双引号

被双引号包括的字符串和被单引号括起的字符串其工作机制完全相同。例如 “你的名字是?” 或

“What’s your name?” 。

  1. 三引号

你可以通过使用三个引号—— “”” 或 ”’ 来指定多行字符串。你可以在三引号之间自由地 使用单引号与双引号。来看看这个例子:

'''这是一段多行字符串。这是它的第一行。
This is the second line.
"What's your name?," I asked.
He said "Bond, James Bond."
'''

字符串是不可变的

这意味着一旦你创造了一串字符串,你就不能再改变它。尽管这看起来像是一件坏事,但实 际上并非如此。我们将会在稍后展现的多个程序中看到为何这一点不是一个限制。

针对 C/C++ 程序员的提示

Python 中没有单独的 char 数据类型。它并非切实必要,并且我相信你不会想念它的。 针对 Perl/PHP 程序员的提示 记住单引号括起的字符串和双引号括起的字符串是一样的——它们不存在任何区别。

格式化方法

有时候我们会想要从其他信息中构建字符串。这正是 format() 方法大有用武之地的地方。

将以下内容保存为文件 str_format.py :

age = 20
name = 'Swaroop'
print('{0} was {1} years old when he wrote this book'.format(name, age)) print('Why is {0} playing with that python?'.format(name))

输出:

$ python3 str_format.py
Swaroop was 20 years old when he wrote this book
Why is Swaroop playing with that python?

它是如何工作的

一个字符串可以使用某些特定的格式(Specification),随后, format 方法将被调用,使用 这一方法中与之相应的参数替换这些格式。

在这里要注意我们第一次应用这一方法的地方,此处 {0} 对应的是变量 name ,它是该格式 化方法中的第一个参数。与之类似,第二个格式 {1} 对应的是变量 age ,它是格式化方法 中的第二个参数。请注意,Python 从 0 开始计数,这意味着索引中的第一位是 0,第二位是1,以此类推。

我们可以通过联立字符串来达到相同的效果:

 name + 'is' +str(age) + 'years old'

但这样实现是很丑陋的,而且也容易出错。其次,转换至字符串的工作将由 format 方法自 动完成,而不是如这般需要明确转换至字符串。再次,当时用 format 方法时,我们可以直 接改动文字而不必与变量打交道,反之亦然。

同时还应注意数字只是一个可选选项,所以你同样可以写成:

age = 20
name = 'Swaroop'
print('{} was {} years old when he wrote this book'.format(name, age)) print('Why is {} playing with that python?'.format(name))

这样做同样能得到与前面的程序一样的输出结果。

Python 中 format 方法所做的事情便是将每个参数值替换至格式所在的位置。这之中可以有 更详细的格式,例如:

# 对于浮点数 '0.333' 保留小数点(.)后三位
print('{0:.3f}'.format(1.0/3))
# 使用下划线填充文本,并保持文字处于中间位置
# 使用 (^) 定义 '___hello___'字符串长度为 11
print('{0:_^11}'.format('hello'))
# 基于关键词输出 'Swaroop wrote A Byte of Python'
print('{name} wrote {book}'.format(name='Swaroop', book='A Byte of Python'))

输出:

0.333
___hello___
Swaroop wrote A Byte of Python

由于我们正在讨论格式问题,就要注意 print 总是会以一个不可见的“新一行”字符( n ) 结尾,因此重复调用 print 将会在相互独立的一行中分别打印。为防止打印过程中出现这一 换行符,你可以通过 end 指定其应以空白结尾:

print('a', end='')
print('b', end='')

输出结果如下:

ab

或者你通过 end 指定以空格结尾:

print('a', end=' ')
print('b', end=' ')
print('c')

输出结果如下:

 a b c

转义序列

想象一下,如果你希望生成一串包含单引号( ‘ )的字符串,你应该如何指定这串字符串? 例如,你想要的字符串是 “What’s your name?” 。你不能指定 ‘What’s your name?’ ,因为这 会使 Python 对于何处是字符串的开始、何处又是结束而感到困惑。所以,你必须指定这个单 引号不代表这串字符串的结尾。这可以通过 转义序列(Escape Sequence) 来实现。你通过

\ 来指定单引号:要注意它可是反斜杠。现在,你可以将字符串指定为 ‘What\’s your name?’ 。

另一种指定这一特别的字符串的方式是这样的: “What’s your name?” ,如这个例子般使用 双引号。类似地, 你必须在使用双引号括起的字符串中对字符串内的双引号使用转义序列。 同样,你必须使用转义序列 \\ 来指定反斜杠本身。

如果你想指定一串双行字符串该怎么办?一种方式即使用如前所述的三引号字符串,或者你 可以使用一个表示新一行的转义序列—— \n 来表示新一行的开始。下面是一个例子:

 'This is the first line\n
This is the second line'

另一个你应该知道的大有用处的转义序列是制表符: \t 。实际上还有很多的转义序列,但 我必须只在此展示最重要的一些。

还有一件需要的事情,在一个字符串中,一个放置在末尾的反斜杠表示字符串将在下一行继 续,但不会添加新的一行。来看看例子:

"This is the first sentence. \
This is the second sentence."

相当于

 "This is the first sentence. This is the second sentence."

原始字符串

如果你需要指定一些未经过特殊处理的字符串,比如转义序列,那么你需要在字符串前增加

r 或 R 来指定一个 原始(Raw) 字符串。下面是一个例子:

 r"Newlines are indicated by \n"

针对正则表达式用户的提示 在处理正则表达式时应全程使用原始字符串。否则,将会有大量 Backwhacking 需要处

理。举例说明的话,反向引用可以通过 ‘\\1′ 或 r’\1’ 来实现。

变量

如果只使用字面常量很快就会让人感到无聊——我们需要一些能够存储任何信息并且也能操 纵它们的方式。这便是 变量(Veriables) 登场的时刻。正如其名字所述那般,变量的值是可 以变化的,也就是说,你可以用变量来存储任何东西。变量只是你的计算机内存中用以存储 信息的一部分。与文字常量不同,你需要通过一些方式来访问这些变量,因此,你需要为它 们命名。

标识符命名

变量是标识符的一个例子。标识符(Identifiers) 是为 某些东西 提供的给定名称。在你命名 标识符时,你需要遵守以下规则:

  • 第一个字符必须是字母表中的字母(大写 ASCII 字符或小写 ASCII 字符或 Unicode 字 符)或下划线(_ )。
  • 标识符的其它部分可以由字符(大写 ASCII 字符或小写 ASCII 字符或 Unicode 字符)、 下划线(_ )、数字(0~9)组成。
  • 标识符名称区分大小写。例如, myname 和 myName 并不等同。要注意到前者是小写字 母 n 而后者是大写字母 N 。
  • 有效 的标识符名称可以是 i 或 name_2_3 ,无效 的标识符名称可能是2things , this is spaced out , my-name 和 >a1b2_c3 。

数据类型

变量可以将各种形式的值保存为不同的数据类型(Data Type)。基本的类型是我们已经讨论 过的数字与字符串。在后面的章节中,我们会了解如何通过 类(Classes) 类创建我们自己 的类型。

对象

需要记住的是,Python 将程序中的任何内容统称为 对象(Object)。这是一般意义上的说法。我们以“某某对象(object)”相称,而非“某某东西(something)”。

针对面向对象编程语言用户的提示:Python 是强(Strongly)面向对象的,因为所有的一切都是对象, 包括数字、字符串与 函数。

接下来我们将看见如何使用变量与字面常量。

案例:使用变量与字面常量

输入并运行以下程序:

# 文件名:var.py
i=5
print(i)
i=i+1
print(i)
s = '''This is a multi-line string.
This is the second line.'''
print(s)

输出

5
6
This is a multi-line string.
This is the second line

它是如何工作的

下面是这一程序的工作原理。首先,我们使用赋值运算符( = )将字面常量数值 5 赋值给 变量 i 。这一行被称之为声明语句(Statement)因为其工作正是声明一些在这一情况下应 当完成的事情:我们将变量名 i 与值 5 相连接。然后,我们通过 print 语句来打印变量i 所声明的内容,这并不奇怪,只是将变量的值打印到屏幕上。

接着,我们将 1 加到 i 变量所存储的值中,并将得出的结果重新存储进这一变量。尔后我们将这一变量打印出来,并期望得到的值应为 6 。 类似地,我们将字面文本赋值给变量 s ,并将其打印出来。

针对静态编程语言程序员的提示:变量只需被赋予某一值。不需要声明或定义数据类型。

逻辑行与物理行

所谓物理行(Physical Line)是你在编写程序时 你所看到 的内容。所谓逻辑行(Logical

Line)是 Python 所看到 的单个语句。Python 会假定每一 物理行 会对应一个 逻辑行。 有关逻辑行的一个例子是诸如 print(‘hello world’) 这样一句语句——如果其本身是一行

(正如你在编辑器里所看到的那样),那么它也对应着一行物理行。

Python 之中暗含这样一种期望:Python 鼓励每一行使用一句独立语句从而使得代码更加可 读。

如果你希望在一行物理行中指定多行逻辑行,那么你必须通过使用分号( ; )来明确表明逻辑 行或语句的结束。下面是一个例子:

i = 5
print (i)

实际上等于:

i = 5;
print (i);

同样也可以是:

i = 5; print (i);

也可以这样写:

i = 5 ; print (i)

然而,我强烈建议对于每一行物理行最多只写入一行逻辑行。这个观点就是说你不应该使 用分号。实际上,我从未在 Python 程序中使用过一个分号。

在一类情况下这一方法会颇为有用:如果你有一行非常长的代码,你可以通过使用反斜杠将 其拆分成多个物理行。这被称作显式行连接(Explicit Line Joining):

s = 'This is a string. \
This continues the string.'
print(s)

输出:

This is a string. This continues the string.

类似的还有:

i = \
5

在某些情况下,会存在一个隐含的假设,允许你不使用反斜杠。这一情况即逻辑行以括号开 始,它可以是方括号或花括号,但不能是结束括号。这被称作 隐式行连接(Implicit Line Joining)。在后面当讨论列表(List)的章节时就会了解这一点。

缩进

空白区在 Python 中十分重要。实际上,空白区在各行的开头非常重要。这被称作 缩进 (Indentation)。在逻辑行的开头留下空白区(使用空格或制表符)用以确定各逻辑行的缩 进级别,而后者又可用于确定语句的分组。

这意味着放置在一起的语句必须拥有相同的缩进。每一组这样的语句被称为 块(block)。在后文章节的案例中了解块这一概念是多么重要。

有一件事你需要记住:错误的缩进可能会导致错误。下面是一个例子:

i =5
#注意下面一行开始有一个空格
 print ('Value is ',i)
print ('Value is {}'.format(i))

当你运行这个程序时,你会得到这样的报错:

  line 2
    print ('Value is ',i)
    ^
IndentationError: unexpected indent

Python 指出的错误信息告诉我们程序的语法是无效的, 意即,程序没有被正确地写入。这一信息对你的意义是 你不能任意开始一个新的语句块(当然,除非你一直在使用默认的主代码块)。

如何缩进: 使用四个空格来缩进。这是来自 Python 语言官方的建议。好的编辑器会自动为你完成这 一工作。请确保你在缩进中使用数量一致的空格,否则你的程序将不会运行,或引发不 期望的行为。


运算符与表达式

我们所编写的大多数语句(逻辑行)都包含了表达式(Expressions)。一个表达式的简单例子

便是 2+3 。表达式可以拆分成运算符(Operators)与操作数(Operands)

运算符(Operators)是进行某些操作,并且可以用诸如 + 等符号或特殊关键词加以表达的 功能。运算符需要一些数据来进行操作,这些数据就被称作操作数(Operands)。在上面的 例子中 2 和 3 就是操作数。

运算符

接下来我们将简要了解各类运算符及它们的用法。 要记得你可以随时在解释器中对给出的案例里的表达式进行求值。例如要想测试表达式

2+3 ,则可以使用交互式 Python 解释器提示符:

>>> 2 + 3
5
>>> 3 * 5
15
>>>

下面是可用运算符:

  • + (加)
    两个对象相加。
    3+5 则输出8。’a’+’b’ 则输出’ab’。
  • – (减)
    从一个数中减去另一个数,如果第一个操作数不存在,则假定为零。
    -5.2 将输出一个负数, 50 – 24 输出 26 。
  • * (乘)
    给出两个数的乘积,或返回字符串重复指定次数后的结果。
    2*3 输出6。’la’*3 输出’lalala’。
  • ** (乘方)
    返回 x 的 y 次方。
    3**4 输出81 (即3*3*3*3)。
  • / (除)
    x 除以 y
    13 / 3 输出 4.333333333333333 。
  • // (整除)
    x 除以 y 并对结果向下取整至最接近的整数。
    13//3 输出4 -13//3 输出-5。
  • % (取模)
    返回除法运算后的余数。
    13%3 输出1。-25.5%2.25 输出1.5。
  • << (左移)
    将数字的位向左移动指定的位数。(每个数字在内存中以二进制数表示,即 0 和1) 2<<2 输出8。2 用二进制数表示为10。
    向左移 2 位会得到 1000 这一结果,表示十进制中的 8 。
  • >> (右移)
    将数字的位向右移动指定的位数。
    11>>1 输出5。
    11 在二进制中表示为 1011 ,右移一位后输出 101 这一结果,表示十进制中的 5。
  • & (按位与)
    对数字进行按位与操作。
    5 & 3 输出 1 。
    按位与是针对二进制数的操作,指将两个二进制数的每一位都进行比较,如果两个相应的二进位都为 1 则此位为 1,否则为 0。在本例中, 5 的二进制表达为 101 , 3 的二进制表达为 11 (为补全位数进行按位操作写作 011 ),则按位与操作后的结果为001 ,对应的十进制数为 1 。
  • | (按位或)
    对数字进行按位或操作。
    5 | 3 输出 7 。
    按位或是针对二进制数的操作,指将两个二进制数的每一位都进行比较,如果两个相应的二进位有一个为 1 则此位为 1,否则为 0。在本例中, 101 与 011 进行按位或操作后的结果为 111 ,对应十进制数为 7 。
  • ^ (按位异或)
    对数字进行按位异或操作。
    5 ^ 3 输出 6 。
    按位异或是针对二进制数的操作,指将两个二进制数的每一位都进行比较,如果两个相应的二进位不同则此位为 1,相同为 0。在本例中, 101 与 011 进行按位异或操作的结果为 110 ,对应十进制数为 6 。
  • ~ (按位取反)4
    x 的按位取反结果为 -(x+1)。
    ~5 输出 -6 。
    按位取反也称作“按位取非”或“求非”或“取反”,是针对二进制数的操作,指将两个二进制数的每一二进位都进行取反操作, 0 换成 1 , 1 换成0 。
  • < (小于)
    返回 x 是否小于 y。所有的比较运算符返回的结果均为 True 或 False 。请注意这 些名称之中的大写字母。
    5<3 输出False,3<6 输出True。
    比较可以任意组成组成链接: 3 < 5 < 7 返回 True 。
  • > (大于)
    返回 x 是否大于 y。
    5 > 3 返回 True 。如果两个操作数均为数字,它们首先将会被转换至一种共同的类型。否则,它将总是返回 False 。
  • <= (小于等于)
    返回 x 是否小于或等于 y。 x=3;y=6;x<=y 返回True。
  • >= (大于等于)
    返回 x 是否大于或等于 y。 x=4;y=3;x>=3 返回True。
  • == (等于)
    比较两个对象是否相等。 x=2;y=2;x==y 返回True。 x=’str’;y=’stR’;x==y 返回False。 x=’str’;y=’str’;x==y 返回True。
  • != (不等于)
    比较两个对象是否不相等。 x=2;y=3;x!=y 返回True。
  • not (布尔“非”)5
    如果x是 Ture ,则返回 False 。如果x是 False ,则返回 True 。 x=Ture;notx 返回False。
  • and (布尔“与”)6
    如果x是 False ,则 x and y 返回 False ,否则返回y的计算值。
    当x是 False 时, x = False; y = True; x and y 将返回 False 。在这一情境中, Python 将不会计算 y,因为它已经了解 and 表达式的左侧是 False ,这意味着整个 表达式都将是 False 而不会是别的值。这种情况被称作短路计算(Short-circuit Evaluation)
  • or (布尔“或”)
    如果 x 是 True ,则返回 True ,否则它将返回 y 的计算值。
    x = Ture; y = False; x or y 将返回 Ture 。在这里短路计算同样适用。

数字运算与赋值的快捷方式

一种比较常见的操作是对一个变量进行一项数学运算并将运算得出的结果返回给这个变量, 因此对于这类运算通常有如下的快捷表达方式:

a = 2
a = a * 3

同样也可以写成:

a = 2
a *= 3

要注意到变量=变量 运算 表达式 会演变成变量 运算 = 表达式

求值顺序

如果你有一个诸如 2 + 3 * 4 的表达式,是优先完成加法还是优先完成乘法呢?数学知识会告诉我们应该先完成乘法。这意味着乘法运算符的优先级要高于加法运算符。

下面将给出 Python 中从最低优先级(最少绑定)到最高优先级(最多绑定)的优先级表。这意味着,在给定的表达式中,Python 将优先计算表中位列于后的较高优先级的运算符与表达式。

  • lambda :Lambda 表达式
  • if – else :条件表达式
  • or :布尔“或”
  • and :布尔“与”
  • not x :布尔“非”
  • in, not in, is, is not, <, <=, >, >=, !=, == :比较,包括成员资格测试(Membership Tests)和身份测试(Identity Tests)
  • | :按位或
  • ^ :按位异或
  • & :按位与
  • <<, >> :移动
  • +, – :加与减
  • *, /, //, % :乘、除、整除、取余
  • +x, -x, ~x :正、负、按位取反
  • ** :求幂
  • x[index], x[index:index], x(arguments…), x.attribute :下标、切片、调用、属性引用
  • (expressions…), [expressions…], {key: value…}, {expressions…} :显示绑定或数组、显示列表、显示字典、显示设置

在上表中位列同一行的运算符具有相同优先级。例如 + 和 – 就具有相同的优先级。

改变运算顺序

为了使表达式更加易读,我们可以使用括号。举个例子, 2 + (3 * 4) 自是要比 2 + 3 * 4要更加容易理解,因为后者还要求你要了解运算符的优先级。和其它的一切一样,使用括号同样也要适度(而不要过度),同时亦应不要像 (2 + (3 * 4)) 这般冗余。

使用括号还有一个额外的优点——它能帮助我们改变运算的顺序。同样举个例子,如果你希望在表达式中计算乘法之前应先计算加法,那么你可以将表达式写作 (2 + 3) * 4 。

结合性

运算符通常由左至右结合。这意味着具有相同优先级的运算符将从左至右的方式依次进行求

值。如 2 + 3 + 4 将会以 (2 + 3) +4 的形式加以计算

表达式

# 文件名为 expression.py 
length = 5
breadth = 2
area = length * breadth
print('Area is ', area)
print('Perimeter is ', 2 * (length + breadth))

输出:

$ python3 newone.py 
Area is  10
Perimeter is  14

它是如何工作的

矩形的长度(Length)与宽度(Breadth)存储在以各自名称命名的变量中。我们使用它们并借助表达式来计算矩形的面积(Area)与周长(Perimeter)。我们将表达式 length *breadth 的结果存储在变量 area 中并将其通过使用 print 函数打印出来。在第二种情况中,我们直接在 print 函数中使用了表达式 2 * (length + breadth) 的值。

同时,你需要注意到 Python是如何漂亮地打印出 输出结果的。尽管我们没有特别在 Area is 和变量 area 之间指定空格,Python 会帮我们加上所以我们就能得到一个整洁的输出结果,同时程序也因为这样的处理方式而变得更加易读(因为我们不需要在用以输出的字符串中考虑空格问题)。这便是一个 Python 是如何让程序员的生活变得更加便捷美好的范例。

发表评论

电子邮件地址不会被公开。 必填项已用*标注