安装 Python
最后更新于 2020 年 7 月 27 日
本课将指导您完成在 Windows、Ubuntu 和 Mac OS 中安装 Python 的过程。虽然整个教程是面向 Python 3.4 的，但是如果您选择使用高于 3.4 的 Python，那就完全没问题了。只是不要用 Python 2。
在 Windows 上安装 Python
要在 Windows 中安装 Python，请前往https://www.python.org/downloads/release/python-344/，向下滚动页面，直到看到“文件”标题。在那里你可以找到不同版本的 Python，你可以下载。
如果您使用的是 32 位版本的 Windows，请下载 Windows x86 安装程序，如果您使用的是 64 位版本的 Windows，请下载 Windows x86-64 安装程序。请注意，Windows x86 安装程序将在 32 位和 64 位上工作。
下载安装程序后，双击它开始安装过程。安装非常简单，只需接受所有默认值。安装过程中唯一关键的一步是当您被要求定制 Python 安装时。
当此窗口出现时，使用滚动条向下滚动列表。在最后一项，即“将 python.exe 添加到路径”前面，使用下拉菜单选择“将安装在本地硬盘上”。该选项允许我们从命令提示符下的任何工作目录调用python.exe，而无需指定其完整路径。
要验证安装，请打开命令提示符并输入以下命令。
C:\Users\Q>python --version
Python 3.4.4
C:\Users\Q>
在 Ubuntu 中安装 Python
像大多数 Linux 发行版一样，Ubuntu 预装了 Python。事实上，现在的一些 Linux 发行版默认安装了 Python 2 和 Python 3。要测试机器上的 Python 版本，请执行以下命令。
q@vm:~$ python3 --version
Python 3.5.2
q@vm:~$
如您所见，我的 Ubuntu 安装有 Python 3.5，这意味着我可以开始了。但是，如果您得到如下输出:
q@vm:~$ python3 --version
python3: command not found
这意味着您的计算机上没有安装 Python 3。要安装 Python 3.4，请在终端中逐一执行以下命令。
q@vm:~$: sudo add-apt-repository ppa:fkrull/deadsnakes
q@vm:~$: sudo apt-get update
q@vm:~$: sudo apt-get install python3.4
执行完这些命令后，再次运行python3 --version。这次您应该会得到以下输出:
q@vm:~$ python3 --version
Python 3.4.5
q@vm:~$
在苹果电脑上安装 Python
大多数苹果电脑已经安装了 Python 2。要在 Mac 上安装 Python 3.4，请访问https://www.python.org/downloads/release/python-344/并向下滚动到“文件”标题下的底部，选择与您的 Mac OS 版本相对应的安装程序。
如果您使用的是 Mac OS X 32 位系统，请下载 Mac OS X 32 位 i386/PPC 安装程序，如果您使用的是 Mac OS X 64 位，请下载 Mac OS X 64 位/32 位安装程序。在 64 位系统上，两个安装程序都可以工作。
双击下载的文件开始安装过程，并接受所有默认值。与 Windows 不同的是，Macs 的 Python 安装程序会自动将python添加到 PATH 环境变量中，因此您不需要做任何事情。要验证安装，请执行以下命令。
Qs-Mac:~ q$ python3 --version
Python 3.4.4
Qs-Mac:~ q$
IDLE 和 Python Shell
最后更新于 2020 年 9 月 6 日
在本课程中，我们将使用 Python 3.4，但是如果您选择使用 Python 3.4 或更高版本，那就没问题了。
在最后一章，我们已经安装了 Python 解释器。解释器是一个把你的代码翻译成机器语言，然后一行一行执行的程序。
我们可以在两种模式下使用 Python 解释器:
- 互动模式。
- 脚本模式。
在交互模式下，Python 解释器等待您输入命令。当您键入命令时，Python 解释器会继续执行该命令，然后它会再次等待您的下一个命令。
在脚本模式下，Python 解释器从源文件运行程序。
对话方式
交互模式下的 Python 解释器俗称 Python Shell。要启动 Python Shell，请在终端或命令提示符下输入以下命令:
C:\Users\Q>python
Python 3.4.4 (v3.4.4:737efcadf5a6, Dec 20 2015, 20:20:57) [MSC v.1600 64 bit (AM
D64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>
例如，如果您的系统同时安装了 Python 2 和 Python 3，Ubuntu 默认情况下会安装 Python 2 和 3。要启动 Python 3 Shell，请输入python3而不仅仅是python。
q@vm:~$ python3
Python 3.5.2 (default, Nov 17 2016, 17:05:23)
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>
你现在看到的叫做 Python Shell。>>>被称为提示字符串，它只是意味着 Python shell 已经准备好接受你的命令了。Python shell 允许您键入 Python 代码，并立即看到结果。在技术术语中，这也被称为 REPL，是读-评估-打印-循环的缩写。每当你听到 REPL 的话，你就会想到一个环境，它可以让你快速测试代码片段，并立即看到结果，就像一个计算器一样。在 Python shell 中，逐个输入以下计算，然后按 enter 键即可获得结果。
>>>
>>> 88 + 4
92
>>>
>>> 45 * 4
180
>>>
>>> 17 / 3
5.666666666666667
>>>
>>> 78 - 42
36
>>>
在 Python 中，我们使用print()函数在屏幕上打印一些东西。
在 Python shell 中键入print("Big Python")并点击回车:
>>>
>>> print("Big Python")
Big Python
>>>
我们刚刚使用了两个重要的编程构造——一个函数和一个字符串。
-
print()是一个函数——编程中的函数是一堆代码，做一些非常具体的事情。在我们的例子中，print()函数打印它被给予控制台的参数(即"Big Python")。 -
字符串只是括在单引号或双引号内的一系列字符串。例如:
"olleh"、'print it'是弦而1、3不是。
别担心，我们不指望你在这一点上理解这些事情。在接下来的课程中，我们将详细讨论这些概念。
像17 / 3、print("Big Python")这样的命令在编程中被称为语句。语句只是 Python 解释器要执行的指令。正如我们将看到的，语句有不同的类型。程序通常由一系列语句组成。
要退出 Windows 中的 Python shell，请按 Ctrl+Z 后按回车键，在 Linux 或 Mac 上，请按 Ctrl+D 后按回车键。
脚本模式
Python shell 非常适合测试小块代码，但是有一个问题——您在 Python Shell 中输入的语句不会保存在任何地方。
如果您想多次执行同一组语句，最好将整个代码保存在一个文件中。然后，在脚本模式下使用 Python 解释器执行文件中的代码。
创建一个名为python101的新目录，你可以在任何你想创建的地方创建这个目录，只要记住位置就可以了，因为我们会用这个目录来存储我们整个课程的所有程序。在python101内创建另一个名为Chapter-03的目录来存储本章的源文件。
要创建可以使用任何文本编辑器的程序，只需确保将文件保存为纯文本即可。然而，如果你拼命寻找推荐，去崇高的文本。
在Chapter-03目录中创建一个名为hello.py的新文件，并添加以下代码:
蟒蛇 101/章-03/hello.py
print("Woods are lovely dark and deep")
print("but I have promises to keep")
print("and miles to go before I sleep")
按照惯例，所有 Python 程序都有.py扩展名。文件hello.py称为源代码或源文件或脚本文件或模块。要执行程序，打开终端或命令提示符，使用cd命令将当前工作目录更改为python101，然后键入以下命令:
Woods are lovely dark and deep
but I have promises to keep
and miles to go before I sleep
注意:在 Windows 上使用python hello.py执行程序。
该命令以脚本模式启动 Python 解释器，并执行hello.py文件中的语句。
我们知道，在 Python Shell 中，如果您键入任何表达式并按 enter 键，Python 解释器会计算该表达式并显示结果。
>>>
>>> 12+8
20
>>> 75/2
37.5
>>> 100*2
200
>>> 100-24
76
>>>
但是，如果您在文件中键入这些语句并运行该文件，您将根本得不到任何输出。在Chapter-03目录中创建新的名为no_output.py的文件，并向其中添加以下代码。
蟒蛇 101/第-03 章/no_output.py
12+8
75/2
100*2
100-24
要运行文件，请输入以下命令。
q@vm:~/python101/Chapter-03$ python3 no_output.py
q@vm:~/python101/Chapter-03$
如您所见，程序没有输出任何内容。
要从 Python 脚本打印值，您必须显式使用print()函数。用以下代码创建一个名为no_output2.py的新文件:
蟒蛇 101/章-03/no_output2.py
print(12+8)
print(75/2)
print(100*2)
print(100-24)
输出:
20
37.5
200
76
闲置的
除了安装 Python 解释器，Mac 和 Windows 的 Python 安装程序还安装了一个轻量级的集成开发环境，简称 IDLE。
那么什么是 IDLE？
IDLE 允许在同一屋檐下创建/读取/编辑和执行您的程序，而无需接触命令行。也可以从 IDLE 访问 Python Shell。
要在 Windows 上启动 IDLE，请单击开始菜单并搜索“IDLE”或“IDLE”。如图所示，单击 IDLE，您将看到一个类似如下的窗口:
这还是 Python Shell，只需键入命令，按 enter 键，它就会显示结果。
>>>
>>> print("Big Python")
Big Python
>>>
>>> 12 + 774
786
>>> 89 * 321
28569
>>>
要在 Mac 上启动 IDLE，只需在终端中键入idle3。
Ubuntu 没有安装 IDLE。无论您使用的是 Ubuntu 预装的 Python，还是您自己通过在课程安装 Python 中输入命令安装的 Python，都是如此。
要安装 IDLE，在终端中发出以下命令。
q@vm:~/python101/Chapter-03$ sudo apt-get install idle3
要启动 IDLE，输入idle3并在终端中输入:
q@vm:~/python101/Chapter-03$ idle3
现在让我们使用 IDLE 创建一个 Python 程序。IDLE 还有一个内置的文本编辑器来编写 Python 程序。要创建新程序，请转到文件>新建文件。将会打开一个新的无标题窗口。该窗口是一个文本编辑器，您可以在其中编写程序。
在编辑器中键入以下代码:
print("Big Python")
点击 Ctrl + S 或转到文件>另存为。将文件保存为Chapter-03目录中的from_idle.py。要运行程序，请转到运行>运行模块或点击 F5。
您的编辑器窗口将移动到后台，Python Shell 将变为活动状态，您将看到您的from_idle.py程序的输出，如下所示:
错误的类型
在编程中错误是不可避免的，迟早你会遇到一个。编程错误主要分为三种类型:
- 语法错误。
- 运行时错误。
- 逻辑错误。
句法误差
语法是正确编写计算机语言的一套规则。如果不遵守语法规则，就会出现语法错误。它们通常出现在你的代码中，是因为一个错别字。当程序中遇到语法错误时，程序的执行会暂停，Python 解释器会显示一条错误消息，解释错误的可能原因。当语句被翻译成机器语言时，但在执行之前，会出现语法错误。名为 parser 的解释器组件发现了这些错误。
以下是语法错误的一些常见原因:
- 拼错的关键字。
- 操作员使用不正确。
- 在函数调用中省略括号。
- 不要用单引号或双引号将字符串括起来。
等等。
以下 Python Shell 会话演示了一些语法错误:
例 1:
>>>
>>> 4 +
File "<stdin>", line 1
4 +
^
SyntaxError: invalid syntax
>>>
在上面的例子中，我们试图添加两个数字，但是我们忘记了包括第二个数字。这就是 Python 解释器报告SyntaxError的原因。另外，请注意插入符号(^)指向 Python 解释器认为是问题原因的位置。
例 2:
>>>
>>> print("Big Python)
File "<stdin>", line 1
print("Big Python)
^
SyntaxError: EOL while scanning string literal
>>>
在这种情况下，我们忘记了用双引号结束字符串，这就是在遇到语法错误的原因。再次注意，插入符号指向 Python 解释器认为是问题原因的位置。
修复语法错误相当容易，你只需要训练你的眼睛去寻找插入符号(^)。
运行时错误
顾名思义，运行时错误是程序运行时发生的错误。就像语法错误一样，当遇到语法错误时，程序的执行会暂停，解释器会显示一条关于问题可能原因的消息。
它们通常发生在解释器处理无法执行的操作时。一个这样的操作是将一个数除以0。因为用0除一个数是没有定义的。当解释器遇到被0操作除的情况时，它会如下提升ZeroDivisionError:
>>>
>>> 99/0
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero
>>>
以下是运行时错误的一些其他常见原因:
- 当您尝试创建新变量时，系统内存不足，可能会出现运行时错误。
- 试图使用尚未定义的函数或变量。
- 访问不存在的文件。
等等。
逻辑错误
当程序产生不正确的结果时，就会出现逻辑错误。例如，假设我们正在创建一个简单的程序，将温度从华氏温度转换为摄氏温度，如下所示:
蟒蛇 101/章节-03/fah_to_cel.py
print("20 degree Fahrenheit in degree Celsius is: ")
print(5 / 9 * 20 - 32)
输出:
20 degree Fahrenheit in degree Celsius is:
-20.88888888888889
以上程序输出-20.88888888888889，有误。正确的数值是-6.666。这些类型的错误被称为逻辑错误。要获得正确答案，请使用5 / 9 * (20 - 32)代替5 / 9 * 20 - 32。20 - 32周围的括号强制 Python 在除法和乘法之前执行减法。我们将在 Python 中的运算符一课中了解这样做的原因。
Python 中的数据类型和变量
原文：https://overiq.com/python-101/data-types-and-variables-in-python/
最后更新于 2020 年 9 月 6 日
数据类型
数据类型只不过是不同类型数据的分类。数据类型定义了一组值以及可以对这些值执行的操作。我们在程序中使用的显式值被称为字面量。例如，10、88.22、'pypi'称为文字。每个文字都有一个关联的类型。例如10为int型，88.22为float型，'pypi'为str型(或弦)。文字的类型决定了可以对其执行哪些类型的操作。下表显示了 Python 中的一些基本数据类型以及示例:
| 数据类型 | 在 Python 中，我们称之为 | 例子 |
|---|---|---|
| 整数 | int |
12、-999、0、900000等 |
| 实数 | float |
4.5、0.0003、-90.5、3.0；等等 |
| 特性 | str |
'hello'、"100"、"$$$"、""；等等 |
Python 有一个名为type()的内置函数，我们可以用它来确定文字的数据类型。
>>>
>>> type(54)
<class 'int'>
>>>
>>> type("a string")
<class 'str'>
>>>
>>> type(98.188)
<class 'float'>
>>>
>>> type("3.14")
<class 'str'>
>>>
>>> type("99")
<class 'str'>
>>>
<class 'int'>表示54的类型为int。同样，<class 'str'>、<class 'float'>表示"a string"、98.188分别为str、float型。
一开始，你可能会认为"3.14"是float类型，但是因为3.14是用双引号括起来的，所以它实际上是一个字符串。出于同样的原因"99"也是一根弦。
Python 还有许多其他数据类型，我们将在后面讨论。
变量
变量用于在我们的程序中存储数据。我们还使用变量来访问数据和操作数据。变量之所以这样叫，是因为它的值可以改变。
创建变量
为了在 Python 中创建一个变量，我们使用赋值语句，其格式如下。
variable_name = expression
variable_name是变量的名称，(=)被称为赋值运算符，expression只是值、变量和运算符的组合。这里有一个例子:
homerun = 6
该语句创建一个名为homerun的变量，并为其赋值6。当 Python 解释器遇到这样的语句时，它会在幕后做以下事情。
- 将变量
6存储在内存的某个地方。 - 使变量
homerun参考它。
这里需要理解的重要一点是，变量homerun本身并不包含任何值，它只是指一个包含实际值的内存位置。
与 C、C++和 Java 等语言不同，在 Python 中，我们不会提前声明变量的类型。事实上，如果您尝试这样做，它是一个语法错误。
>>>
>>> int homerun
File "<stdin>", line 1
int homerun
^
SyntaxError: invalid syntax
>>>
为变量赋值时，始终将变量名写在赋值(=)运算符的左侧。如果不这样做，您将得到如下语法错误:
>>>
>>> 100 = words
File "<stdin>", line 1
SyntaxError: can't assign to literal
>>>
Python 会根据变量包含的值的类型自动检测变量的类型以及可以对其执行的操作。在编程术语中，这种行为被称为动态类型。这意味着我们可以使用同一个变量来引用与它最初指向的完全不同类型的数据。例如:
>>>
>>> homerun = 6 # at this point, homerun contains an int or integer
>>> homerun
6
>>> homerun = "now" # now homerun contains a string
>>> homerun
'now'
>>>
>>> type(homerun)
<class 'str'>
>>>
>>> homerun = 2.3 # now homerun contains a float
>>> homerun
2.3
>>> type(homerun)
<class 'float'>
>>>
当我们给一个变量赋值时，对旧值的引用就会丢失。例如，当"now"被分配给homerun时，对值6的引用丢失。此时，没有任何变量指向该内存位置。当这种情况发生时，Python 解释器会通过一个称为垃圾收集的过程自动从内存中移除该值。
如果在给变量赋值之前试图访问它。你会得到这样的NameError错误:
>>>
>>> age
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'age' is not defined
>>>
我们也可以使用print()函数来打印一个变量值，如下所示:
>>>
>>> age = 100
>>> print(age)
100
>>>
变量名
在 Python 中，我们有以下规则来创建有效的变量名。
-
只允许使用字母(
a-z、A-Z)、下划线(_)和数字(0-9)来创建变量名，其他不允许。 -
它必须以下划线(
_)或字母开头。 -
您不能使用保留关键字来创建变量名称。(见下文)。
-
变量名可以是任意长度。
Python 是区分大小写的语言，这意味着HOME和home是两个不同的变量。
Python 关键字
Python 关键字是在 Python 语言中表示特定事物的单词。这就是为什么，我们不允许使用它们作为变量名称。下面是 Python 关键字的列表:
随着本课程的进行，我们将进一步了解这里提到的一些关键字。
以下是一些有效和无效的变量名:
home4you -有效
after_you -有效
_thatsall -有效
all10 -有效
python_101 -有效
$money -无效，变量不能以$字符
hello pi开头-无效，变量之间不能有空格
2001 -无效，变量不能以数字
break开头-无效，关键字不能是变量名
评论
注释用于给程序添加注释。在大型程序中，注释可能描述程序的目的及其工作方式。它们只针对那些试图理解程序源代码的人。它们不是编程语句，因此在执行程序时会被 Python 解释器忽略。
在 Python 中，从#到行尾的所有内容都被视为注释。例如:
# This is a comment on a separate line
print("Testing comments") # This is a comment after print statement
命名常量
常量是在程序生命周期内其值不变的变量。不像 C 或 Java 这样的语言；Python 没有创建常量的特殊语法。我们像普通变量一样创建常量。但是，为了将它们与普通变量分开，我们使用了所有大写字母。
>>>
>>> MY_CONST = 100 # a constant
>>>
注意MY_CONST只是一个变量，指的是int类型的值。它没有其他特殊属性。
您甚至可以通过给MY_CONST常量赋值来改变它的值，如下所示:
>>>
>>> MY_CONST = "new value"
>>>
我们将在程序中不时使用命名常量。
使用打印()功能显示多个项目
我们也可以使用print()语句，通过用逗号(,)分隔每个项目，在一次调用中打印多个项目。当多个参数被传递到print()函数时，它们被打印到控制台，用空格隔开。例如:
>>>
>>> message = "item2"
>>> print("item1", message, "item3")
item1 item2 item3
>>>
同时分配
我们可以使用具有以下语法的同时赋值来同时为多个变量赋值:
var1, var2, var3, ... varN = exp1, exp2, exp3, ... expN
当 Python 遇到同时赋值语句时，它首先计算右侧的所有表达式，然后将它们的值赋给左侧相应的变量。例如:
>>>
>>> name, age, designation = "tom", 25, "Lead Developer"
>>>
>>> name
'tom'
>>>
>>> age
25
>>>
>>> designation
'Lead Developer'
>>>
>>>
在两个变量之间交换值是一种常见的编程操作。在像 C 这样的语言中，要执行交换，你必须创建一个额外的变量来临时存储数据。例如:
int i = 10, j = 20;
int tmp; // variable to store data temporary
tmp = i; // now tmp contains 10
i = j; // now i contains 20
j = tmp; // now j contains 10
在 Python 中，我们可以使用同时赋值来交换值，如下所示:
>>>
>>> x, y = 10, 20
>>> print(x, y)
10 20 # initial value
>>>
>>> x, y = y, x ## swapping values
>>> print(x, y)
20 10 # final value
>>>
Python 中的函数
函数是一段代码，它执行一些非常具体的任务。在这一点上，我们只讨论了print()和type()函数，但是 Python 标准库实际上有成千上万个执行各种操作的内置函数。
一个函数不能自己做任何事情，除非你调用它。要调用一个函数，请在括号内键入该函数的名称，后跟参数列表，即()，如下所示:
function_name(arg1, arg2, arg3, arg4, ..., argN)
那么什么是论点呢？
参数是函数执行任务所需的附加数据。有些函数需要参数，有些则不需要。要调用不接受任何参数的函数，请键入函数名，后跟空括号，如下所示:
function_name()
参数通常也称为参数。
在语句中，print("Big Python")、"Big Python"是一个自变量。
当一个函数完成它的任务时，它通常会返回值。并非所有函数都返回值，有些函数返回值，而有些函数不返回值。如果一个函数没有显式返回任何值，那么它会返回一个名为None的特殊值，这是 Python 中保留的关键字之一。这就是你现在需要知道的。我们将在第课中详细讨论 Python 中的函数。
Python 中的模块
Python 使用模块对相似的函数、类、变量等进行分组。例如，math模块包含各种数学函数和常量，datetime模块包含各种处理日期和时间等的类和函数。要使用模块中定义的函数、常量或类，我们首先必须使用import语句导入它。import语句的语法如下:
import module_name
要在 Python Shell 中导入math模块，请键入以下代码:
>>>
>>> import math
>>>
要使用模块类型中的方法或常量，模块名称后跟点(.)运算符，运算符后跟要访问的方法或变量的名称。例如，math模块有sqrt()函数，它的任务是返回一个数的平方根。要使用此函数，请在 Python shell 中键入以下代码。
>>>
>>> math.sqrt(441)
21.0
>>>
math模块还有两个常用的数学常量pi和e。要访问它们，请键入以下代码:
>>>
>>> math.pi
3.141592653589793
>>>
>>> math.e
2.718281828459045
>>>
要查看由math模块提供的函数和常量的完整列表，请查看math模块的文档。
像print()、type()、input()这样的内置功能(我们接下来讨论这个功能)属于一个叫做__builtin__的特殊模块。但是为什么它是特别的呢？因为__builtin__模块中的功能总是可以使用的，而无需显式导入__builtin__模块。
从键盘读取输入
Python 有一个名为input()的内置函数，用于读取键盘输入。它的语法如下:
var = input(prompt)
prompt指的是指示用户输入的可选字符串。input()功能从键盘读取输入数据，并将其作为字符串返回。然后将输入的数据分配给一个名为var的变量进行进一步处理。
不管输入的数据是类型int、float还是其他什么，最终input()函数会将数据转换为字符串。
当遇到input()语句时，程序暂停，等待用户输入。完成输入后，按回车键提交输入。input()函数然后将输入的数据作为字符串返回。
>>>
>>> name = input("Enter your name: ")
Enter your name: Tom
>>>
>>> name
'Tom'
>>>
>>> type(name)
<class 'str'>
>>>
>>>
使用帮助()函数获取帮助
文档是任何计算机语言的重要组成部分，作为一名初露头角的程序员，您应该知道如何访问 Python 的文档，以了解更多关于语言及其提供的各种功能的信息。
我们可以使用help()命令来了解更多关于函数、类或模块的信息。要使用help()函数，只需传递函数、类或模块的名称。例如，要了解input()函数调用help()函数如下:
>>>
>>> help(input)
Help on built-in function input in module builtins:
input(...)
input([prompt]) -> string
Read a string from standard input. The trailing newline is stripped.
If the user hits EOF (Unix: Ctl-D, Windows: Ctl-Z+Return), raise EOFError.
On Unix, GNU readline is used if enabled. The prompt string, if given,
is printed without a trailing newline before reading.
>>>
>>>
第input([prompt]) -> string行称为函数签名。函数签名定义了它的参数和返回值。如果一个参数是可选的，那么它将被包装在方括号[]中。
第input([prompt]) -> string行表示input()函数接受一个名为prompt的可选参数，并返回一个字符串类型的值。
请注意，help()功能不使用互联网连接来获取文档，而是使用存储在硬盘中的文档的离线副本。Python 文档也可以在线获得，要访问它，请访问https://docs.python.org/3/。
Python 中的数字
最后更新于 2020 年 9 月 17 日
Python 中的数字
在 Python 中，数字有 4 种类型:
- 整数。
- 浮点或实数。
- 复数。
- 布尔型。
整数或简称int是没有小数点的数字。比如100、77、-992是int但是0.56、-4.12、2.0不是。
浮点或实数或float是有小数点的数字。比如1.2、0.21、-99.0是浮动的而102、-8不是。我们也可以用科学记数法写浮点数。以a x 10^b形式书写的数字被称为科学符号。科学符号对于写非常小或非常大的数字非常有用。例如，float 0.000000123在科学记数法中可以简洁地写成1.23 x 10^-7。Python 使用一种特殊的语法来用科学符号写数字。比如0.000000123可以写成1.23E-7。字母E叫指数，用e还是E都无所谓。
复数是我们不能在一条数字线上表示的数字。复数的形式是a + ib，其中a是实部，bi是虚部。比如2 + 3i是复数。Python 对复数也使用特殊的语法。尾随的整数或浮点数j在 Python 中被视为复数，因此10j、9.12j都是复数。
>>>
>>> type(5) # an integer
<class 'int'>
>>>
>>> type(3.4) # a float
<class 'float'>
>>>
>>> type(5j) # a complex number
<class 'complex'>
>>>
注意5j只代表复数的虚部。要创建一个有实部和虚部的复数，只需在虚部上加上一个数字。比如复数2 + 3i可以用 Python 写成2 + 3j。
布尔类型将在本章后面讨论。
常见的数学函数
Python 提供了以下内置函数来帮助您完成常见的编程任务:
| 功能 | 它有什么作用？ | 例子 |
|---|---|---|
abs(number) |
返回数字的绝对值。换句话说，abs()函数只是返回没有任何符号的数字。 |
abs(-12)是12，abs(112.21)是112.21。 |
pow(a, b) |
返回a^b。 |
pow(2, 3)是8，pow(10, 3)是1000 |
round(number) |
将数字舍入到最接近的整数。 | round(17.3)是17，round(8.6)是9 |
round(number, ndigits) |
小数点后将number舍入到ndigits |
round(3.14159, 2)是3.14，round(2.71828, 2)是2.72 |
min(arg1, arg2, ... argN) |
返回arg1、arg2中最小的项目，…argN |
min(12, 2, 44, 199)是2，min(4, -21, -99)是-99 |
max(arg1, arg2, ... argN) |
返回arg1、arg2中最大的项目，…argN |
max(991, 22, 19)是991，max(-2, -1, -5)是-1 |
abs()功能
>>>
>>> abs(-100) # absolute value of -100
100
>>>
>>> abs(291.121) # absolute value of 291.121
291.121
>>>
>>> abs(88) # absolute value of 88
88
>>>
power()函数
>>>
>>> pow(3, 3) # calculate 3^3
27
>>>
>>> pow(0.35, 2) # calculate 0.35^2
0.12249999999999998
>>>
>>> pow(9, -2) # calculate 9^-2
0.012345679012345678
>>>
round()函数
>>>
>>> round(32.3) # round 32.3 to the nearest integer
32
>>> round(99.7) # round 99.7 to the nearest integer
100
>>> round(-5.23) # round -5.23 to the nearest integer
-5
>>>
>>> round(3.14159, 2) # round 3.14159 to 2 decimal places
3.14
>>>
>>> round(2.71828, 3) # round 2.71828 to 3 decimal places
2.718
>>>
最大()和最小()函数
>>>
>>> max(1, 4, 100) # Find the largest among 1, 4 and 100
100
>>>
>>> max(-21, 4.5, 91.12) # Find the largest among -21, 4.5 and 91.12
91.12
>>>
>>> max(-67, -17, 0) # Find the largest among -67, 417 and 0
0
>>>
>>> min(0, -1.23e10, -9921) # Find the smallest among 0, -1.23e10 and -9921
-12300000000.0
>>>
>>>
>>> min(92, 6, -102) # Find the largest among 92, 6, -102
-102
>>>
Python 的math模块也提供了一些标准的数学函数和常量。回想一下，要使用数学模块，我们首先需要使用import语句导入它，如下所示:
import math
下表列出了math模块中的一些标准数学函数和常量。
| 功能 | 它有什么作用？ | 例子 |
|---|---|---|
math.pi |
返回pi的值 |
math.pi是3.141592653589793 |
math.e |
返回e的值 |
math.e是2.718281828459045 |
math.ceil(n) |
返回大于或等于n的最小整数 |
math.ceil(3.621)是4 |
math.floor(n) |
返回小于或等于n的最大整数 |
math.floor(3.621)是3 |
math.fabs(n) |
将x的绝对值返回为float |
math.fabs(5)是5.0 |
math.sqrt(n) |
以浮点形式返回 x 的平方根 | math.sqrt(225)是15.0 |
math.log(n) |
将n的自然对数返回到基数e |
math.log(2)是0.6931 |
math.log(n, base) |
将n的日志返回给定的基数 |
math.log(2, 2)是1.0 |
math.sin(n) |
返回n弧度的正弦值 |
math.sin(math.pi/2)是1.0 |
math.cos(n) |
返回n弧度的余弦值 |
math.cos(0)是1.0 |
math.tan(n) |
返回n弧度的正切值 |
math.tan(45)是1.61 |
math.degrees(n) |
将角度从弧度转换为 | math.degrees(math.pi/2)是90 |
math.radians() |
将角度从度转换为弧度 | math.radians(90)是1.5707 |
数学π和数学 e 常量
>>>
>>> math.pi
3.141592653589793
>>>
>>> math.e
2.718281828459045
>>>
math.ceil()和 math.floor()函数
>>>
>>> math.ceil(3.5) # find the smallest integer greater than or equal to 3.5
4
>>> math.floor(3.5) # find the largest integer smaller than or equal to 3.5
3
>>>
math.fabs()和 math.sqrt()函数
>>>
>>> math.fabs(2) # absolute value of 2 in float
2.0
>>>
>>> math.fabs(-53.3) # absolute value of -53.3
53.3
>>>>
>>> math.sqrt(9801) # square root of 9801
99.0
>>>
>>> math.sqrt(4.3) # square root of 4.3
2.073644135332772
>>>
math.log()函数
>>>
>>> math.log(2) # find log of 2 to the base e
0.6931471805599453
>>>
>>> math.log(2, 5) # find log of 2 to the base 5
0.43067655807339306
>>>
math.sin()，math.cos()和 math.tan()函数
>>>
>>> math.sin(math.pi/2)
1.0
>>>
>>> math.cos(0)
1.0
>>>
>>> math.tan(45)
1.6197751905438615
>>>
math.degrees()和 math.radians()函数
>>>
>>> math.degrees(math.pi/2)
90.0
>>>
>>> math.radians(90)
1.5707963267948966
>>>
这只是数学模块中函数和常量的一个简短列表，要查看完整列表请访问https://docs.python.org/dev/library/math.html。
格式化数字
有时希望以特定的格式打印数字。考虑以下示例:
蟒蛇 101/第-05 章/简单 _ 兴趣 _ 计算器. py
# Program to calculate the Simple Interest
#
# The formula for Simple Interest is
# si = p * r * t
# where si is the simple interest
# p is principal
# r is interest rate
# t is number of years
p = 18819.99 # principal
r = 0.05 # rate of interest
t = 2 # years
si = p * r * t
print("Simple interest at the end of 2 years $", si)
输出:
Simple interest at the end of 2 years $ 1881.9990000000003
注意货币在输出中是如何显示的，它包含小数点后的13位。当执行计算后打印浮点数时，这是一个非常常见的问题。由于金额是货币，将其格式化为两位小数是有意义的。我们可以使用round()函数轻松地将数字四舍五入到小数点后 2 位，但是round()函数并不总是给出正确的答案。考虑以下代码:
>>>
>>> round(1234.5012, 2)
1234.5
>>>
我们要输出1234.50而不是1234.5。我们可以使用format()功能解决这个问题。下面是使用format()方法的上述程序的修订版。
python 101/章节-05/simple _ interest _ calculator _ using _ format _ function . py
# Program to calculate the Simple Interest
#
# The formula for Simple Interest is
# si = p * r * t
# where si is the simple interest
# p is principal
# r is interest rate
# t is number of years
p = 18819.99 # principal
r = 0.05 # rate of interest
t = 2 # years
si = p * r * t
print("Simple interest at the end of 2 years $", format(si, "0.2f"))
输出:
Simple interest at the end of 2 years $ 1882.00
下一节将解释format()功能。
格式()函数
format()函数的语法如下:
format(value, format-specifier)
value是我们要格式化的数据。
format-specifier是一个字符串，它决定了如何格式化传递给format()函数的值。
成功后format()返回一个格式化的字符串。
格式化浮点数
为了格式化浮点数，我们使用下面的格式说明符。
width.precisionf
width是为一个值保留的最小字符数，precision是小数点后的字符数。width包括小数点前后的数字和小数点字符本身。precision后面的f字符表示format()函数将以浮点数的形式输出该值。字符f也称为类型代码或说明符。正如我们将看到的，还有许多其他说明符。
默认情况下，所有类型的数字都右对齐。如果宽度大于值的长度，则数字以右对齐方式打印，前导空格由宽度减去值的长度确定。另一方面，如果宽度小于值的长度，则宽度的长度会自动增加以适应值的长度，并且不会添加前导空格
为了使一切具体化，让我们举几个例子:
例 1 :
>>>
>>> print(format(34.712, "9.2f"))
34.71
>>>
这里宽度为9字符长，精度为2。数字34.712的长度是6，但是由于精度是2，所以数字会四舍五入到2小数位。所以实际长度值为5。这意味着宽度大于值的长度，因此值以4 ( 9-5=4)前导空格右对齐。
例 2 :
>>>
>>> print(format(567.123, "5.2f"))
567.12
>>>
这种情况下，宽度为5，数值的实际长度为6(因为数字会四舍五入到2小数位)。因此，宽度小于值的长度，因此，宽度的长度会自动增加以适应值的长度，并且不会添加前导空格
我们也可以完全省略宽度，在这种情况下，它是由值的长度自动确定的。
>>>
>>> import math
>>> print(format(math.pi, ".2f"))
3.14
>>>
宽度通常用于整齐地排列列中的数据。
用科学符号格式化数字
要格式化科学记数法中的数字，只需将类型代码从f替换为e或E。
>>>
>>> print(format(5482.52291, "10.2E"))
5.48E+03
>>>
>>>
>>> print(format(5482.52291, "5.2e"))
5.48e+03
>>>
>>>
>>> print(format(00000.212354, ".3E"))
2.124E-01
>>>
>>>
插入逗号
阅读大量数字可能很难读懂。我们可以用逗号(,)来分隔它们，让它们更易读。要使用逗号分隔符，请在格式说明符的宽度之后或精度之前键入,字符。
>>>
>>> print(format(98813343817.7129, "5,.2f"))
98,813,343,817.71
>>>
>>>
>>> print(format(98813343817.7129, ",.2f"))
98,813,343,817.71
>>>
如果您只想打印带逗号(,)的浮点数，但不应用任何格式，请执行以下操作:
>>>
>>> print(format(98813343817.7129, ",f"))
98,813,343,817.712906
>>>
将数字格式化为百分比
我们可以使用%类型代码将数字格式化为百分比。当在格式说明符中使用%时，它将数字乘以100，并将结果作为后跟%符号的浮点数输出。我们也可以像往常一样指定宽度和精度。
>>>
>>> print(format(0.71981, "%"))
71.981000%
>>>
>>>
>>>
>>> print(format(0.71981, "10.2%"))
71.98%
>>>
>>>
>>>
>>> print(format(52, "%"))
5200.000000%
>>>
>>>
>>>
>>> print(format(95, ".2%"))
9500.00%
>>>
设置对齐方式
我们已经讨论过，默认情况下，数字是正确打印的。例如:
>>>
>>> import math
>>>
>>> print(format(math.pi, "10.2f"))
3.14
>>>
>>>
我们可以通过使用以下两个符号来更改默认对齐方式:
| 标志 | 描述 |
|---|---|
> |
输出在指定宽度内右对齐的值 |
< |
输出在指定宽度内左对齐的值 |
对齐符号必须在指定宽度之前。
>>>
>>> print(format(math.pi, "<10.2f")) # output the value left justfied
3.14
>>>
这里我们打印的是左对齐的数字，结果添加了尾随空格而不是前导空格。
注意语句format(math.pi, ">10.2f")和format(math.pi, "10.2f")相同，右对齐是打印数字的默认格式。
格式化整数
我们也可以使用format()函数来格式化整数。类型码d、b、o、x可分别格式化为十进制、二进制、八进制和十六进制。请记住，格式化整数时，只允许宽度，不允许精度。
>>>
>>> print(format(95, "5d"))
95
>>>
>>>
>>> print(format(4, "b")) # prints the binary equivalent of decimal 4
100
>>>
>>>
>>> print(format(255, "x")) # prints the hexadecimal equivalent of decimal 255
ff
>>>
>>>
>>> print(format(9, "o")) # prints the octal equivalent of decimal 9
11
>>>
>>>
>>> print(format(100, "<10d")) # Left align the number within specified width
100
>>>
Python 中的运算符
最后更新于 2020 年 9 月 17 日
在本课中，我们将学习 Python 提供的表达式和各种运算符。
操作符:操作符是指定特定动作的符号。
操作数:操作数是操作符作用的数据项。
一些运算符需要两个操作数，而另一些只需要一个。
表达式:表达式只不过是运算符、变量、常量和函数调用的组合，最终得到一个值。例如:
## some valid expressions
1 + 8
(3 * 9) / 5
a * b + c * 3
a + b * math.pi
d + e * math.sqrt(441)
让我们从算术运算符开始。
算术运算符
算术运算符通常用于执行数值计算。Python 有以下算术运算符。
| 操作员 | 描述 | 例子 |
|---|---|---|
+ |
加法运算符 | 100 + 45 = 145 |
- |
减法运算符 | 500 - 65 = 435 |
* |
乘法运算符 | 25 * 4 = 100 |
/ |
浮点除法运算符 | 10 / 2 = 5.0 |
// |
整数除法运算符 | 10 / 2 = 5 |
** |
幂运运算符 | 5 ** 3 = 125 |
% |
余数运算符 | 10 % 3 = 1 |
我们在日常生活中使用+、-、*运算符，不值得任何解释。但是，需要注意的重要一点是+和-运算符既可以是二元的，也可以是一元的。一元运算符只有一个操作数。我们可以使用-运算符来否定任何正数。例如:-5，在这种情况下-运算符充当一元运算符，而在100 - 40中，-运算符充当二元运算符。同样，我们可以使用一元+运算符。比如+4。由于表达式4和+4相同，在表达式中应用一元+运算符一般没有意义。
浮点除法运算符(/)
/运算符执行浮点除法。简单的说就是/返回一个浮点结果。例如:
>>>
>>> 6/3
2.0
>>>
>>> 3.14/45
0.06977777777777779
>>>
>>>
>>> 45/2.5
18.0
>>>
>>>
>>> -5/2
-2.5
>>>
整数除法运算符(//)
//运算符的工作方式类似于/运算符，但它返回的不是浮点值，而是整数。例如:
>>>
>>> 6//3
2
>>>
>>> 100//6
16
>>>
与/运算符不同，当结果为负时，//运算符将结果从零舍入到最接近的整数。
>>>
>>> -5//2
-3
>>>
>>> -5/2
-2.5
>>>
幂运运算符(**)
我们用**运算符计算a^b。例如:
>>>
>>> 21**2
441
>>>
>>> 5**2.2
34.493241536530384
>>>
余数运算符(%)
%运算符返回左操作数除以右操作数后的余数。例如:
>>>
>>> 5%2
1
>>>
余数运算符%是编程中非常有用的运算符。%运算符的一个常见用法是判断一个数是否为偶数。
一个数即使被2整除也是偶数。换句话说，一个数即使被2除，剩下0作为余数。我们将在第课中学习如何用 Python 编写这样的程序。
运算符优先级和结合性
考虑以下表达式:
10 * 5 + 9
它的结果会是什么？
如果在加法之前进行乘法运算，那么答案将是59。另一方面，如果在乘法之前进行加法，那么答案将是140。为了解决这个难题，我们使用了运算符优先级。
Python 中的运算符被组合在一起，并被赋予一个优先级。下表列出了运算符的优先级。
| 操作员 | 描述 | 结合性 |
|---|---|---|
[ v1, … ]、{ v1, …}、{ k1: v1, …}、(…) |
列表/集合/字典/生成器创建或理解，带圆括号的表达式 | 从左到右 |
seq [ n ]、seq [ n : m ]、func ( args… )、obj.attr |
索引、切片、函数调用、属性引用 | 从左到右 |
** |
幂运算 | 从右向左 |
+x、-x、~x |
正、负、按位非 | 从左到右 |
*、/、//、% |
乘法、浮点除法、整数除法、余数 | 从左到右 |
+、- |
加法、减法 | 从左到右 |
<<、>> |
按位左移、右移 | 从左到右 |
& |
按位“与” | 从左到右 |
| | | 按位“或” | 从左到右 |
in、not in、is、is not、<、<=、>、>=、!=、== |
比较、成员资格和身份测试 | 从左到右 |
not x |
布尔非 | 从左到右 |
and |
布尔与 | 从左到右 |
or |
布尔或 | 从左到右 |
if-else |
条件表达式 | 从左到右 |
| 希腊字母的第 11 个 | λ表达式 | 从左到右 |
上面几行中的运算符优先级最高，随着我们向表格底部移动，优先级会降低。每当我们有一个表达式，其中涉及的运算符具有不同的优先级，具有较高优先级的运算符将首先被计算。因此，在表达式10 * 5 + 9中，首先对*运算符进行评估，然后对+运算符进行评估。
=> 10 * 5 + 9 (multiplication takes place first)
=> 50 + 9 (followed by addition)
=> 59 (Ans)
运算符的结合性
在优先级表中，同一组中的运算符具有相同的优先级，例如，(*、/、//、%)具有相同的优先级。现在考虑以下表达式:
5 + 12 / 2 * 4
从优先级表中我们知道/和*的优先级都比+高，但是/和*的优先级是一样的，那么你认为先评估哪个算符/还是*？
当运算符优先级相同时，为了确定求值顺序，我们使用运算符关联性。运算符关联性定义了计算具有相同优先级的运算符的方向，它可以是从左到右或从右到左。同一组中的运算符具有相同的关联性。从表中可以看出，/和*的关联性是从左到右。所以在表达中:
5 + 12 / 2 * 4
首先评估/运算符，然后评估*运算符。最后对+运算符进行了评价。
=> 5 + 12 / 2 * 4 (/ operator is evaluated first)
=> 5 + 6 * 4 (then * operator is evaluated)
=> 5 + 24 (at last + operator is evaluated)
=> 29 (Ans)
以下是关于优先表需要记住的两点。
-
同一组中除幂运运算符(
**)外，大多数运运算符的结合性都是从左到右。幂运运算符(**)的结合性是从右到左。 -
我们有时使用括号，即
()来改变评估的顺序。例如:
2 + 10 * 4
在上面的表达式中*将首先执行，然后是+。我们可以通过在要首先求值的表达式或子表达式周围加上圆括号来轻松更改运算符优先级。例如:
(2 + 10) * 4
由于()运算符的优先级高于*运算符(见优先级表)，将首先执行加法，然后是*。
以下是一些表达式及其计算顺序:
例 1:
Expression: 10 * 3 + (10 % 2) ** 1
1st Step: 10 * 3 + 0 ** 1
2nd Step: 10 * 3 + 0
3rd Step: 30 + 0
4th Step: 30
例 2:
Expression: 45 % 2 - 5 / 2 + ( 9 * 3 - 1 )
1st Step: 45 % 2 - 5 / 2 + 26
2nd Step: 1 - 2.5 + 26
3rd Step: 24.5
复合赋值运算符
在编程中，增加或减少变量值，然后将该值重新分配回同一个变量是非常常见的。例如:
x = 10
x = x + 5
x的初始值为10。在第二个表达式中，我们将10添加到 x 的现有值中，然后将新值重新分配回x。所以现在x的价值是15。
第二个语句x = x + 5可以使用复合赋值运算符以更简洁的方式编写，如下所示:
x += 5
这里+=被称为复合赋值运算符。下表列出了 Python 中可用的其他复合赋值运算符。
| 操作员 | 例子 | 等效语句 |
|---|---|---|
+= |
x += 4 |
x = x + 4 |
-= |
x -= 4 |
x = x - 4 |
*= |
x *= 4 |
x = x * 4 |
/= |
x /= 4 |
x = x / 4 |
//= |
x //= 4 |
x = x // 4 |
%= |
x %= 4 |
x = x % 4 |
**= |
x **= 4 |
x = x ** 4 |
不像其他基于 C 的语言，比如 Java、PHP、JavaScriptPython 没有递增运算符(++)和递减运算符(--)。在这些语言中，++和--运算符通常分别用于通过1增加和减少变量值。例如，要在 JavaScript 中将变量值增加/减少1，您可以这样做:
x = 10;
x++; // increment x by 1
console.log(x); // prints 11
x = 10;
x--; // decrement x by 1
console.log(x); // prints 9
我们可以很容易地使用复合赋值运算符来模拟这种行为，如下所示:
x = 10
x += 1
print(x) ## prints 11
x = 10
x -= 1
print(x) ## prints 9
类型变换
到目前为止，我们还没有考虑在 Python Shell 和我们的程序中的表达式中使用的数据类型。说到执行涉及不同类型数据的计算，Python 有以下规则:
-
当一个表达式中涉及的两个操作数都是
int时，那么结果就是int。 -
当一个表达式中涉及的两个操作数都是
float时，那么结果就是float。 -
当一个操作数为
float类型，另一个操作数为int类型时，结果将始终是一个float值。在这种情况下，Python 解释器会自动将int值临时转换为float，然后执行计算。这个过程称为类型转换。
以下是一些例子:
>>>
>>> 45 * 3
135 # result is int because both operands are int
>>>
>>>
>>>
>>> 3.4 * 5.3
18.02 # result is float because both operands are float
>>>
>>>
>>>
>>> 88 * 4.3
378.4 # result is float because one operand is float
>>>
在最后一个表达式中，文字88首先转换为88.0，然后进行乘法运算。
有时，我们希望根据自己的意愿将数据从一种类型转换为另一种类型。为了处理这种情况，Python 为我们提供了以下功能:
| 函数名 | 描述 | 例子 |
|---|---|---|
int() |
它接受字符串或数字，并返回类型为int的值。 |
int(2.7)返回2，int("30")返回30 |
float() |
它接受一个字符串或数字，并返回一个类型为float的值 |
float(42)返回42.0，float("3.4")返回3.4 |
str() |
它接受任何值并返回值类型str |
str(12)返回"12"，str(3.4)返回"3.4" |
以下是一些例子:
int()函数
>>>
>>> int(2.7) # convert 2.7 to int
2
>>>
>>> int("30") # convert "30" to int
30
>>>
注意当int()函数将一个浮点数转换为int时，它只是去掉小数点后的数字。如果你想取整一个数字，使用round()功能。
>>>
>>> int(44.55)
44
>>> round(44.55)
45
>>>
float()函数
>>>
>>> float(42) # convert 42 to float
42.0
>>>
>>> float("3.4") # convert "3.4" to float
3.4
>>>
str()函数
>>>
>>> str(12) # convert 12 to str
'12'
>>>
>>> str(3.4) # convert 3.4 to str
'3.4'
>>>
将语句分成多行
到目前为止，我们写的所有声明都仅限于一行。如果你的陈述变得太长了怎么办？
在一行中输入长语句在屏幕上和纸上都很难阅读。
Python 允许我们使用行延续符号(\)将长表达式拆分成多行。\符号告诉 Python 解释器语句在下一行继续。例如:
>>>
>>> 1111100 + 45 - (88 / 43) + 783 \
... + 10 - 33 * 1000 + \
... 88 + 3772
1082795.953488372
>>>
要将一条语句扩展为多行，请在要中断该语句的位置键入行延续符号(\)，然后按回车键。
当 Python Shell 遇到扩展到多行的语句时，会将提示字符串从>>>改为...。当你完成输入语句后，点击回车查看结果。
下面是另一个将print()语句分成多行的例子:
>>>
>>> print("first line\
... second line\
... third line")
first line second line third line
>>>
>>>
以下示例显示了如何在 Python 脚本中编写多行语句。
python 101/章节-06/multiline_statements.py
result = 1111100 + 45 - (88 / 43) + 783 \
+ 10 - 33 * 1000 + \
88 + 3772
print(result)
print("first line\
second line\
third line")
输出:
1082795.953488372
first line second line third line
布尔类型
bool数据类型代表两种状态，即真或假。Python 分别使用保留关键字True和False来定义值 true 和 false。bool类型的变量只能包含这两个值中的一个。例如:
>>>
>>> var1 = True
>>> var2 = False
>>>
>>> type(var1)
<class 'bool'> # type of var1 is bool
>>>
>>> type(var2)
<class 'bool'> # type of var2 is bool
>>>
>>>
>>> type(True)
<class 'bool'> # type of True keyword is bool
>>>
>>> type(False)
<class 'bool'> # type of False keyword is bool
>>>
>>> var1
True
>>>
>>> var2
False
>>>
计算出bool值True or False的表达式称为布尔表达式。
我们通常使用bool变量作为标志。标志只不过是一个变量，它表示程序中的某种情况。如果标志变量设置为假，则意味着条件不为真。另一方面，如果它是真的，那么它意味着条件是真的。
在内部，Python 使用1和0分别表示True和False。我们可以通过使用True和False关键字上的int()功能来验证这个事实，如下所示:
>>>
>>> int(True) # convert keyword True to int
1
>>>
>>> int(False) # convert keyword False to int
0
>>>
真理和谬误的价值
真值:相当于真值的值称为真值。
虚假值:相当于布尔值 False 的值称为虚假值。
在 Python 中，以下值被认为是错误的。
NoneFalse- 零，即
0、0.0 - 空序列，例如，
''、[]、() - 空字典即
{}
**注:**顺序和字典在后面章节讨论。
其他一切都被认为是真实的。我们也可以使用bool()函数来测试一个值是真还是假。如果值为真，则bool()函数返回真，否则返回False。以下是一些例子:
>>>
>>> bool("") # an empty string is falsy value
False
>>>
>>> bool(12) # int 12 is a truthy value
True
>>>
>>> bool(0) # int 0 is falsy a value
False
>>>
>>> bool([]) # an empty list is a falsy value
False
>>>
>>> bool(()) # an empty tuple is a falsy value
False
>>>
>>> bool(0.2) # float 0.2 is truthy a value
True
>>>
>>> bool("boolean") # string "boolean" is a truthy value
True
>>>
在接下来的课程中，真理和谬误价值观的重要性将变得更加明显。
关系运算符
为了比较值，我们使用关系运算符。包含关系运算符的表达式称为关系表达式。如果表达式为真，则返回布尔值True，如果表达式为假，则返回布尔值False。关系运算符是二元运算符。下表列出了 Python 中可用的关系运算符。
| 操作员 | 描述 | 例子 | 返回值 |
|---|---|---|---|
< |
小于 | 3 < 4 |
True |
> |
大于 | 90 > 450 |
False |
<= |
小于或等于 | 10 <= 11 |
True |
>= |
大于或等于 | 31 >= 40 |
False |
!= |
不等于 | 100 != 101 |
True |
== |
等于 | 50==50 |
True |
>>>
>>> 3 < 4 # Is 3 is smaller than 4 ? Yes
True
>>>
>>> 90 > 450 # Is 90 is greater than 450 ? No
False
>>>
>>> 10 <= 11 # Is 10 is smaller than or equal to 11 ? Yes
True
>>>
>>> 31 >= 40 # Is 31 is greater than or equal to 40 ? No
False
>>>
>>> 100 != 101 # Is 100 is not equal to 101 ? Yes
True
>>>
>>> 50 == 50 # Is 50 is equal to 50 ? Yes
True
>>>
初学者经常混淆==和=运算符。永远记住=是赋值运算符，用于给变量赋值。另一方面，==是一个相等运算符，用于测试两个值是否相等。
逻辑运算符
逻辑运算符用于组合两个或多个布尔表达式，并测试它们是真还是假。包含逻辑运算符的表达式称为逻辑表达式。下表列出了 Python 中可用的逻辑运算符。
| 操作员 | 描述 |
|---|---|
and |
逻辑积算符 |
or |
或运算符 |
not |
“非”算符 |
and和or是二元运算符，not是一元运算符。
逻辑积算符
如果两个操作数都为真，and运算符将返回一个bool值True。否则返回False。
语法: operand_1 and operand_2
and运算符的真值表如下:
| 操作数 _1 | 操作数 _2 | 结果 |
|---|---|---|
False |
False |
False |
False |
True |
False |
True |
False |
False |
True |
True |
True |
以下是一些例子:
| 表示 | 中间表达 | 结果 |
|---|---|---|
(10>3) and (15>6) |
True and True |
True |
(1>5) and (43==6) |
False and False |
False |
(1==1) and (2!=2) |
True and False |
False |
>>>
>>> (10>3) and (15>6) # both conditions are true so, the result is true
True
>>>
>>> (1>5) and (43==6) # both conditions are false so, the result is false
False
>>>
>>> (1==1) and (2!=2) # one condition is false(right operand) so, the result is false
False
>>>
关系运算符(即>、>=、<、<=、==和!=)的优先级大于and运算符，因此以上表达式中的括号不是必须的，这里添加它只是为了使代码更易读。例如:
>>>
>>> (10>3) and (15>6)
True
>>>
>>> 10 > 3 and 15 > 6 # this expression is same as above
True
>>>
可以看到(10>3) and (15>6)这个表达比10 > 3 and 15 > 6要清晰的多。
在and运算符中，如果第一个操作数被求值为False，那么第二个操作数根本不会被求值。例如:
>>>
>>> (10>20) and (4==4)
False
>>>
在这种情况下，(10>20)为 False，整个逻辑表达式也是如此。因此，无需评估表达式(4==4)。
或运算符
当两个操作数都为False时，or运算符返回False。否则返回True。它的语法是:
语法 : operand_1 or operand_2
or运算符的真值表如下:
| 操作数 _1 | 操作数 _2 | 结果 |
|---|---|---|
False |
False |
False |
False |
True |
True |
True |
False |
True |
True |
True |
True |
以下是一些例子:
| 表示 | 中间表达 | 结果 |
|---|---|---|
(100<200) or (55<6) |
True or False |
True |
(11>55) or (6==6) |
False or True |
True |
(1>12) or (2==3) |
False or False |
False |
(10<22) or (20>3) |
True or True |
True |
>>>
>>> (100<200) or (55<6)
True
>>>
>>> (11>55) or (6==6)
True
>>>
>>> (1>12) or (2==3)
False
>>>
>>> (10<22) or (20>3)
True
>>>
在or运算符中，如果第一个操作数被求值为True，那么第二个操作数根本不会被求值。例如:
>>>
>>> (100>20) or (90<30)
True
>>>
在这种情况下，(100>20)就是True，整个逻辑表达式也是如此。因此没有必要评价(90<30)这个表达。
or运算符的优先级低于and运算符。
“非”算符
not运算符否定表达式的值。换句话说，如果表达式为True，则 not 运算符返回False，如果表达式为False，则返回True。与其他两个逻辑运算符不同，not 是一元运算符。not运算符的优先级高于and运算符和or运算符。它的语法是:
语法 : not operand
not运算符的真值表如下:
| 操作数 | 结果 |
|---|---|
True |
False |
False |
True |
以下是一些例子:
| 表示 | 中间表达 | 结果 |
|---|---|---|
not (200==200) |
not True |
False |
not (10<=5) |
not False |
True |
>>>
>>> not (200==200)
False
>>>
>>> not (10<=5)
True
>>>
Python 中的字符串
最后更新于 2020 年 9 月 21 日
字符串是用单引号('')或双引号("")括起来的字符序列。下面是如何在 python 中创建字符串。
>>>
>>> s1 = 'String in single quotes'
>>> s1
'String in single quotes'
>>>
>>> s2 = "String in double quotes"
>>> s2
'String in double quotes'
>>>
>>>
>>> 'hello everyone'
'hello everyone'
>>>
>>> "hello everyone"
'hello everyone'
>>>
在 Python Shell 或 IDLE 中，字符串总是用单引号显示。但是，如果使用print()功能，则仅显示字符串的内容。
>>>
>>> print(s1)
String in single quotes
>>> print(s2)
String in double quotes
>>>
有些语言像 C、C++、Java 把单个字符当作一种特殊类型叫做char，但是在 Python 中单个字符也是一个字符串。
>>>
>>> achar = 'a' # string containing a single character
>>> type(achar)
<class 'str'>
>>>
>>> type("a string") # string containing multiple characters
<class 'str'>
>>>
使用 len()函数计算字符数
len()内置函数统计字符串中的字符数。
>>>
>>> len("a string")
8
>>>
>>> s = "a long string"
>>>
>>> len(s)
13
>>>
>>> len("")
0
>>>
创建空字符串
>>>
>>> s3 = '' # empty string using single quotes
>>> s3
''
>>>
>>> s4 = "" # empty string using double quotes
>>> s4
''
>>>
虽然变量s3和s4不包含任何字符，但它们仍然是有效的字符串。您可以使用type()功能来验证这一事实。
>>>
>>> type(s3)
<class 'str'>
>>>
>>> type(s4)
<class 'str'>
>>>
那么在创建字符串时，我应该使用单引号还是双引号呢？
当字符串中有单引号时，双引号就派上用场了。例如:
>>>
>>> print("I'm learning python")
I'm learning python
>>>
如果我们使用单引号，我们会得到以下错误:
>>>
>>> print('I'm learning python')
File "<stdin>", line 1
print('I'm learning python')
^
SyntaxError: invalid syntax
>>>
这里的问题是 Python 解释器认为第二个引号，就在字符I之后，标志着字符串的结束，不知道如何处理剩下的字符。
同样，如果要在字符串中打印双引号，只需将整个字符串用单引号而不是双引号括起来。
>>>
>>> print('John says "Hello there !"')
John says "Hello there !"
>>>
还有一种使用转义序列在字符串中嵌入单引号或双引号的方法，这将在下面讨论。
转义序列
转义序列是一组特殊字符，用于打印无法使用键盘直接键入的字符。每个转义序列都以反斜杠(\)字符开始。
下表列出了一些常见的转义序列。
| 换码顺序 | 意义 |
|---|---|
\n |
换行符-打印换行符 |
\t |
制表符-打印制表符 |
\\ |
反斜杠-打印反斜杠(\)字符 |
\' |
单引号-打印单引号 |
\" |
双引号-打印双引号 |
当转义序列在字符串中使用时，Python 将它们视为特殊命令。例如，字符串中的\t字符打印一个制表符(一个制表符等于打印四个空格)。例如:
>>>
>>> s = "Name\tAge\tMarks"
>>> s
'Name\tAge\t\\Marks'
>>> print(s)
Name Age Marks
>>>
类似地，字符串中的\n字符打印一个换行符。换行符不会显示在屏幕上，而是会使光标从下一行的开头开始打印后续字符。例如:
>>>
>>> s2 = 'One\nTwo\nThree'
>>> s2
'One\nTwo\nThree'
>>> print(s2)
One
Two
Three
>>>
也可以使用(\')和(\")转义序列在字符串中打印单引号或双引号。例如:
>>>
>>> print('I\'m learning python')
I'm learning python
>>>
>>> print("John says \"Hello there !\"")
John says "Hello there !"
>>>
当我们使用转义序列来打印单引号或双引号时，字符串是否包装在单引号或双引号中并不重要。
同样，要打印单个反斜杠字符(\)请使用(\\)转义序列。
>>>
>>> s3 = 'C:\\Users\\Q'
>>> s3
'C:\\Users\\Q'
>>> print(s3)
C:\Users\Q
>>>
串并置
字符串串联意味着将一个或多个字符串连接在一起。为了在 Python 中连接字符串，我们使用+运算符。
>>>
>>> s1 = "This is " + "one complete string"
>>> print(s1)
This is one complete string
>>>
>>> s2 = "One " + "really really " + "long string"
>>> print(s2)
One really really long string
>>>
请注意，+运算符在与两个数字一起使用时会执行数学加法。但是，当与字符串一起使用时，它会将它们连接起来。
>>>
>>> 98+57 # when used with numbers + operators adds them
155
>>>
如果其中一个操作数不是字符串，会发生什么？例如:
>>>
>>> s = "Python" + 101
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: Can't convert 'int' object to str implicitly
>>>
这里 wear 试图连接字符串"Python"和数字101，但是 Python 报告了以下错误:
TypeError: Can't convert 'int' object to str implicitly
由于 Python 是一种强类型语言，它不能自动将一种类型的数据转换成完全不同的类型。
那么解决办法是什么呢？
解决方法是使用str()函数将整数转换为字符串，如下所示:
>>>
>>> s = str(100)
>>> s
'100'
>>> type(s)
<class 'str'>
>>>
>>>
>>> s = "Python" + str(101)
>>> s
'Python101'
>>>
字符串重复运算符(*)
就像数字一样，我们也可以使用带字符串的*运算符。当与琴弦一起使用时*操作者重复琴弦n的次数。它的一般格式是:
string * n
其中n是一个数字类型int。
>>>
>>> s = "www " * 5 # repeat "www " 5 times
>>> s
'www www www www www '
>>>
>>>
>>>
>>> print("We have got some", "spam" * 5)
We have got some spamspamspamspamspam
>>>
注意5 * "www "和"www " * 5产生相同的结果。
n必须是int。否则，你会得到一个错误。例如:
>>> "www" * "e" # n is a string
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: can't multiply sequence by non-int of type 'str'
>>>
>>>
>>> "www" * 1.5 # n is a float
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: can't multiply sequence by non-int of type 'float'
>>>
请注意，错误消息清楚地告诉我们，字符串不能乘以非 int 类型。
成员资格运算符-在和不在
in或not in运算符用于检查一个字符串是否存在于另一个字符串中。例如:
>>>
>>> s1 = "object oriented"
>>>
>>> "ted" in s1 # Does "ted" exists in s1 ?
True
>>>
>>>
>>> "eject" in s1 # Does "eject" exists in s1 ?
False
>>>
>>>
>>> "orion" not in s1 # Doesn't "orion" exists in s1 ?
True
>>>
>>> "en" not in s1 # Doesn't "en" exists in s1 ?
False
>>>
>>>
访问字符串中的单个字符
在 Python 中，字符串中的字符是按顺序存储的。我们可以通过使用索引来访问字符串中的单个字符。索引是指字符串中字符的位置。在 Python 中，字符串被0索引，这意味着第一个字符在索引0处，第二个字符在索引1处，以此类推。最后一个字符的索引位置比字符串长度少一个字符。
要访问字符串中的单个字符，我们键入变量的名称，后跟方括号[]中字符的索引号。
>>>
>>> s1 = "hello"
>>>
>>> s1[0] # get the first character
'h'
>>> s1[1] # get the second character
'e'
>>> s1[2] # get the third character
'l'
>>> s1[3] # get the fourth character
'l'
>>> s1[4] # get the fifth character
'o'
>>>
字符串s1的最后一个有效索引是4，如果您试图访问最后一个有效索引之外的字符，您将获得如下的IndexError:
>>>
>>> s1[5] # get the sixth character
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: string index out of range
>>>
不用手动统计字符串中最后一个字符的索引位置，我们可以使用len()函数计算字符串，然后从中减去1得到最后一个字符的索引位置。
>>>
>>> quote = "The best is the enemy of the good"
>>>
>>> quote[len(quote)-1]
'd'
>>>
我们也可以使用负指数。负索引允许我们从字符串的末尾访问字符。负索引从-1开始，所以最后一个字符的索引位置是-1，第二个最后一个字符是-2等等。
>>>
>>> s = "markdown"
>>>
>>> s[-1] # get the last character
'n'
>>>
>>> s[-2] # get the second last character
'w'
>>>
>>> s[-8] # get the first character
'm'
>>>
>>> s[-len(s)] # get the first character
'm'
>>>
如果负指数小于最后一个有效指数(-8)，那么IndexError将出现如下情况:
>>>
>>> s[-9]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: string index out of range
>>>
切割字符串
字符串切片允许我们从字符串中获取一部分字符。为了获得字符串的切片，我们使用切片操作符([start_index:end_index])。它的语法是:
str_name[start_index:end_index]
str_name[start_index:end_index]从索引start_index到end_index返回一段字符串。end_index处的字符将不包含在切片中。考虑以下示例:
>>>
>>> s = "markdown"
>>>
>>>
>>> s[0:3] # get a slice of string starting from index 0 to 3, not including the character at index 3
'mar'
>>>
>>>
>>> s[2:5] # get a slice of string starting from index 2 to 5, not including the character at index 5
'rkd'
>>>
如果end_index大于字符串的长度，则切片操作符返回从start_index开始到字符串末尾的字符串切片。
>>>
>>> s[2:len(s)+200]
'rkdown'
>>>
start_index和end_index可选。如果未指定start_index，则切片从字符串的开头开始，如果未指定end_index，则切片继续到字符串的结尾。例如:
>>>
>>> s[:4] # start slicing from the beginning
'mark'
>>>
在上面的表达式中，切片从字符串的开头开始，所以上面的表达式与s[0:4]相同。
>>>
>>> s[5:]
'own'
>>>
在这种情况下，结果省略了end_index，切片继续到字符串的末尾，因此s[5:]与s[5:len(s)]相同。
>>>
>>> s[:]
'markdown'
>>>
这里我们省略了start_index和end_index，因此切片将从开始开始，一直到字符串的结尾。换句话说，s[:]和s[0:len(s)]是一样的
我们也可以在字符串切片中使用负索引。
因此s[1:-1]将从索引1开始返回一个切片到-1，不包括索引-1处的字符。
>>>
>>> s[1:-1]
'arkdow'
>>>
Python 中的一切都是对象
在 Python 中，所有数据都是对象。这意味着一个数字，一个字符串，其他类型的数据实际上是一个对象。为了确定物体的类型，我们使用type()功能。
但是什么是对象呢？
类和对象-第一印象
在我们学习对象之前，我们必须先学习类。类只是一个定义数据和方法的模板。类内定义的函数称为方法。
class our_class
data
methods
当我们定义一个新的类时，我们实际上创建了一个新的数据类型。要使用我们的新类或数据类型，我们必须创建该类的对象。请注意，定义一个类不会占用任何内存空间。只有当我们基于该类创建对象时，才会分配内存。
根据这些新获得的知识，让我们看看当我们给一个变量赋值int时会发生什么。
>>> num = 100
在上面的陈述中，我们给变量num赋值100。用面向对象的术语来说，我们刚刚创建了一个对象。要了解对象的类别或类型的更多信息，请使用如下的type()方法:
>>>
>>> type(num)
<class 'int'>
>>>
<class 'int'>表示num变量是类int的对象。同样，每根弦和float分别是str和float类的对象。
内置类或类型，如int、float、str；定义了许多有用的方法。要调用这些方法，我们使用以下语法:
object.method_name()
这里有一个例子:
str类提供了像upper()和lower()这样的方法，分别将字符串转换成大写和小写后返回字符串。
>>>
>>> s1 = "A String"
>>>
>>> s2 = s.lower()
>>> s2
'a string'
>>>
>>> s3 = s1.upper()
>>> s3
'A STRING'
>>>
>>> s3
>>>
这些方法不会改变原始对象(s1)的值。这就是为什么在调用lower()和upper()变量s1后仍然指向"A String"字符串对象的原因。
>>>
>>> s1
'A String'
>>>
>>>
要知道对象的内存地址，我们可以使用id()函数，如下所示:
>>>
>>> id(s1)
15601373811
>>>
注意15601373811是'A String'字符串对象的地址，不是s1变量的地址。在程序执行过程中，对象的内存地址不会改变。但是，它可能会在您每次运行程序时发生变化。如果两个对象相同，那么将具有相同的 id(或地址)。
ASCII 字符
在计算机中，一切都以 0 和 1 的序列存储。存储数字很容易，只要把它们转换成二进制就可以了。
但是字符是如何存储在内存中的呢？
电脑不能直接在内存中存储'a'、'b'、'1'、'$'等字符串。相反，它们存储的是代表字符的数字代码。字符及其数字代码的映射称为 ASCII(美国信息交换标准代码)字符集。ASCII 字符集有 128 个字符。
除了在美国键盘中找到的字符，ASCII 集还定义了一些控制字符。控制字符用于发出命令，它们是不可打印的字符。
控制字符的一个例子是 Ctrl+D，它通常用于终止 Shell 窗口。ASCII 表中的这个字符用EOT(传输结束)表示，ASCII 值为 4。
下表显示了 ASCII 字符集的所有 128 个字符。
这里有几件事需要注意:
- 从
A到Z的所有大写字母都有从65到90的 ASCII 值。 - 从
'a'到'z'的所有小写字母都有从97到122的 ASCII 值。 - 当我们在字符串中使用数字(
0-9)时，它们是用从48到57的 ASCII 值来表示的。
order()和 chr()函数
ord()函数返回一个字符的 ASCII 值，chr()函数返回由 ASCII 值表示的字符。
order()函数
>>>
>>> ord("a") # print the ASCII value of character a
97
>>>
>>> ord("5") # print the ASCII value of character 5
53
>>>
chr()函数
>>>
>>> chr(97) # print the character represented by ASCII value 97
'a'
>>>
>>> chr(53) # print the character represented by ASCII value 53
'5'
>>>
print()函数中抑制换行符
默认情况下，print()函数打印给定的参数，后跟一个换行符(\n)。例如:
蟒蛇 101/章节-07/换行符 _ at _ end . py
print("first line")
print("second line")
输出:
first line
second line
请注意，字符串"second line"打印在下一行的开头，这是因为第一个print()调用打印的换行符(\n)导致输出从下一行开始。
我们可以通过传递一个名为end的特殊参数来改变print()函数的这种行为。假设我们想在输出的末尾打印$字符，而不是换行符(\n)。为此调用print()函数如下:
蟒蛇 101/章-07/dollor _ at _ end . py
print("first string", end="$")
print("second string", end="$")
输出:
first string$second string$
请注意两个字符串末尾的'$'字符。由于第一条语句没有在输出的末尾打印一个换行符，所以第二条print()的输出从同一行开始。
如果您不想在输出结束时打印任何内容，请将end=""传递到print()功能，如下所示:
蟒蛇 101/第-07 章/无 _at_end.py
print("first", end="")
print("second", end="")
print("third")
输出:
firstsecondthird
在这种情况下，前两个语句在输出的末尾打印一个空字符串("")，但是最后一个语句打印"third"，后跟一个换行符('\n')。
在打印中指定分隔符()函数
我们已经在第课中讨论了 Python 中的数据类型和变量，当我们将多个参数传递给print()函数时，它们被打印到控制台上，用空格隔开。
>>>
>>> print("first", "second", "third")
first second third
>>>
为了覆盖这个行为，我们使用了另一个特殊的参数sep作为分隔符的缩写。假设我们想通过#将每个项目分开。为此，调用print()函数如下:
>>>
>>> print("first", "second", "third", sep="#")
first#second#third
>>>
字符串比较
就像数字一样，我们也可以使用关系运算符来比较字符串。但是，与数字不同，字符串比较稍微复杂一些。Python 中的字符串使用其对应字符的 ASCII 值进行比较。比较从比较两个字符串的第一个字符开始。如果它们不同，则比较相应字符的 ASCII 值以确定比较结果。另一方面，如果它们相等，则比较下两个字符。这个过程一直持续到任何一个字符串用完。如果一个短字符串出现在另一个长字符串的开头，那么短字符串就是较小的字符串。在技术术语中，这种类型的比较被称为词典式比较。
让我们举一些例子:
例 1:
>>>
>>> "linker" > "linquish"
False
>>>
以下是评估上述表达式的步骤:
第一步:"link"的"l"与"linq"的"l"比较。由于它们相等，接下来的两个字符将被比较。
第二步:"link"的"i"与"linq"的"i"进行对比。同样，它们是相等的，接下来的两个字符进行比较。
第三步:"link"的"n"与"linq"的"n"进行对比。同样，它们是相等的，接下来的两个字符进行比较。
第四步:将"link"的"k"与"linq"的"q"进行比较。因为对应的字符不相同，所以比较在这一步停止。k的 ASCII 值是107，q的 ASCII 值是113，也就是说"k"比"q"小。因此弦"linker"比"linquish"小。因此"linker" > "linquish"这个表达是错误的。
例 2:
>>>
>>> "qwerty" > "abc"
True
>>>
"qwerty"的"q"与"abc"的"a"相比较。此时，比较停止，因为对应的字符不相同。由于"q"的 ASCII 值为113，"a"的 ASCII 值为97，所以"q"大于"a"。因此弦"qwerty"大于"abc"。
例 3:
>>>
>>> "ab" > "abc"
False
>>>
这里短弦"ab"出现在另一个长弦"abc"的开始处。因此"ab"是较小的一个。
更多示例:
>>>
>>> "tree" == "tree"
True
>>>
>>> "pass" != "password"
True
>>>
>>> "@@@" <= "123"
False
>>>
>>> "" <= "123"
True
>>>
字符串比较是编程中常见的操作。字符串比较的一个实际用途是按升序或降序对字符串进行排序。
字符串是不可变的
字符串对象是不可变的。这意味着我们不能在字符串对象创建后更改其内容。考虑以下示例:
>>>
>>> s = "hello"
>>>
>>> id(s)
35145912
>>>
这里我们已经创建了一个新的字符串对象，然后我们使用id()函数来知道我们的字符串对象的地址。
让我们看看如果我们试图通过在字符串对象的末尾添加" world"来修改现有的字符串对象s会发生什么。
>>>
>>> s += " world"
>>> s
'hello world'
>>>
>>> id(s)
35150448
>>>
请注意，变量s现在指向一个全新的地址，这是因为每次我们修改一个字符串对象，我们都会在这个过程中创建新的字符串对象。这证明了字符串对象是不可变的。
形式variable[index]的表达式就像一个变量。因此，它们也可以出现在赋值运算符的左侧。例如:
>>>
>>> s[0] = 'y'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>>
这里，我们试图通过为索引0处的元素分配一个新字符串来更新它。操作失败，因为字符串对象是不可变的。如果字符串是可变的，上述操作就会成功。
使用 format()函数格式化字符串
就像数字一样，我们也可以使用format()函数来格式化字符串。要格式化字符串，我们使用类型代码s和指定的宽度，例如:
>>>
>>> print(format("Python", "10s"))
Python
>>>
与数字不同，字符串默认为左对齐。这意味着，当宽度大于值的长度时，该值将左对齐打印，用尾随空格代替前导空格。
如果字符串的长度大于指定的宽度，则宽度会自动增加以匹配字符串的长度。
>>>
>>> print(format("Python", "4s"))
Python
>>>
要右对齐一个字符串，请使用如下符号>:
>>>
>>> print(format("Python", ">10s"))
Python
>>>
>>>
语句print(format("Python", "<10s"))与print(format("Python", "10s"))相同，因为默认情况下字符串是左对齐打印的。