开始
在本章中,我们将介绍在Windows、Ubuntu、Linux和macOS系统上获取和安装Python。我们还将编写第一个基本的Python代码,并熟悉基本的Python编程文化,例如Python的禅宗,同时永远不会忘记该语言名称的滑稽起源。
获取并安装Python
Python语言有两个主要版本,Python 2 哪个是广泛部署的遗留语言和Python 3 这是语言的现在和未来。许多Python代码无需修改Python 2的上一个版本即可正常工作<一个href="https://www.python.org/download/releases/2.7/" class="" target="_blank">Python 2.7一个>)和Python 3的最新版本,例如<一个href="https://www.python.org/download/releases/3.5.1/" class="" target="_blank">Python 3.5一个>.然而,主要版本之间存在一些关键差异,严格意义上讲,语言是不兼容的。在本书中,我们将使用Python 3.5,但我们将指出与Python 2的关键区别。这也是很有可能的,因为这是一本关于Python基础知识的书,我们所介绍的所有内容都将适用于Python 3的未来版本,所以当它们可用时,不要害怕尝试。
在开始用Python编程之前,我们需要掌握一个Python环境。Python是一种高度可移植的语言,在所有主要操作系统上都可用。你将能够在Windows、Mac或Linux上阅读这本书,我们唯一涉及到平台细节的主要部分即将到来——当我们安装Python 3时。当我们介绍这三个平台时,可以跳过与您无关的部分。
窗户
- 对于Windows,您需要访问<一个href="http://python.org" class="" target="_blank">Python官方网站一个>,然后点击左边的链接进入下载页面。对于Windows,你应该选择一个MSI安装程序,这取决于你是在32位还是64位平台上运行。
- 下载并运行安装程序。
- 在安装程序中,决定是只为自己安装Python,还是为机器的所有用户安装Python。
- 为Python发行版选择一个位置。默认值将在
C: \ Python35 的根C: 开车。我们不建议将Python安装到程序文件 因为在Windows Vista及以后的版本中,用于隔离应用程序的虚拟化文件存储可能会影响轻松安装第三方Python包。
- 在
自定义Python 页面的向导,我们建议保持默认值,使用小于40 MB的空间。
- 除了安装Python运行时和标准库之外,安装程序还将注册各种文件类型,例如
* . py 文件,Python解释器。
- 安装Python之后,需要将Python添加到系统中
路径 环境变量。要做到这一点,从控制面板选择系统与安全 ,然后系统 .另一种轻松到达这里的方法是按住Windows键并按下键盘上的Break键。使用左侧的任务窗格进行选择系统高级设置 打开先进的 的标签。系统属性 对话框。点击环境变量 打开子对话框。
- 如果您拥有管理员权限,您应该能够添加路径
C: \ Python35 而且C: \ Python35 \脚本 属性关联的分号分隔的项列表路径 系统变量。如果没有,则应该能够创建或添加路径 变量中包含相同的值。
- 现在打开
新 控制台窗口- Powershell或cmd都可以工作-并验证您可以从命令行运行python:
>pythonPython3.5.0(v3.5.0:374年f501f4567,9月132015,02:27:37)[MSC v.190064位(AMD64)]在\win32类型“帮助”,“版权”,“信用”orgydF4y2Ba“许可证”为更多的信息.>>>
欢迎来到Python!
三箭头提示符显示Python正在等待您的输入。
在这一点上,当我们展示如何在Mac和Linux上安装Python时,您可能想要跳过。
macOS
- 对于macOS,您需要访问Python官方网站<一个href="http://python.org" class="" target="_blank">http://python.org一个>.点击左边的链接进入下载页面。在“下载”页面,找到与您的macOS版本匹配的macOS安装程序,并单击链接下载。
- 下载DMG磁盘映像文件,您可以从下载堆栈或查找器中打开该文件。
- 在打开的Finder窗口中,您将看到该文件
Python.mpkg 多包安装文件。使用“辅助”单击操作打开该文件的上下文菜单。从菜单中选择“打开”。
- 在某些版本的macOS上,您现在会被告知该文件来自一个身份不明的开发人员。按下对话框上的“打开”按钮继续安装。
- 您现在处于Python安装程序中。按照指示,点击向导。
- 不需要自定义安装,您应该保持标准设置。当它可用时,单击“安装”按钮来安装Python。您可能会被要求输入密码以授权安装。安装完成后,点击“关闭”关闭安装程序。
- 现在已经安装了Python 3,打开一个终端窗口,并验证您可以从命令行运行Python 3:
>pythonPython3.5.0(默认的,11月3.2015,13:17:02)[海湾合作委员会4.2.1兼容Apple LLVM6.1.0(铿锵声-602.053)]在达尔文类型“帮助”,“版权”,“信用”orgydF4y2Ba“许可证”为更多的信息.>>>
欢迎来到Python!
三个箭头提示符表明Python正在等待您的输入。
Linux
- 要在Linux上安装Python,您需要使用系统的包管理器。我们将展示如何在最新版本的Ubuntu上安装Python,但在大多数其他现代Linux发行版上,这个过程非常相似。
- 在Ubuntu上,首先启动“Ubuntu软件中心”。这通常可以通过点击启动器中的图标来运行。或者,你也可以通过在仪表板上搜索“Ubuntu软件中心”并点击选择来运行它。
- 进入软件中心后,在右上角的搜索栏中输入搜索词“python 3.5”,然后按回车键。
- 其中一个结果将显示“Python (v3.5)”,下面以较小的字体显示“Python解释器(v3.5)”。选择该条目并单击出现的“Install”按钮。
- 此时,您可能需要输入密码来安装软件。
- 您现在应该看到出现了一个进度指示器,安装完成后该指示器将消失。
- 打开终端(使用
Ctrl-Alt-T ),并验证您可以从命令行运行Python 3.5:
python3美元.5Python3.5.0+(默认的,10月112015,09:05:38)[海湾合作委员会5.2.120151010]在linux上类型“帮助”,“版权”,“信用”orgydF4y2Ba“许可证”为更多的信息.>>>
欢迎来到Python!
三箭头提示符显示Python正在等待您的输入。
启动Python命令行REPL
现在Python已经安装并运行,您可以立即开始使用它。这是了解语言的好方法,也是在正常开发过程中进行实验和快速测试的有用工具。
这个Python命令行环境是一个Read-Eval-Print-Loop .Python会读 不管输入什么,EVAL uate它,打印 结果是循环 回到最开始。你会经常听到它被缩写为“REPL”。
当启动时,REPL将打印一些关于正在运行的Python版本的信息,然后它将给您一个三重箭头提示。这个提示符告诉您Python正在等待您输入一些内容。
在交互式Python会话中,您可以输入Python程序片段并看到即时结果。让我们从一些简单的算术开始:
>>>2+24>>>6*742
正如你所看到的,Python读取我们的输入,求值,打印结果,然后循环执行同样的操作。
我们可以在REPL中为变量赋值:
>>>x=5
通过输入它们的名称打印它们的内容:
>>>x5
并在表达式中引用它们:
>>>3.*x15
在REPL中,你可以使用特殊的下划线变量来引用最近打印的值,这是Python中为数不多的晦涩快捷方式之一:
>>>_15
或者你可以在表达式中使用特殊的下划线变量:
>>>_*230.
请注意
记住,这个有用的技巧只在REPL中有效;下划线在Python脚本或程序中没有任何特殊行为。
注意,并非所有语句都有返回值。当我们把5赋值给x 没有返回值,只有带来变量的副作用x 。其他的说法有更明显的副作用。
试一试:
>>>打印(“你好,Python”)你好,Python
您将看到Python立即计算并执行此命令,打印字符串“Hello, Python”并返回到另一个提示符。重要的是要理解这里的响应不是REPL计算和显示的表达式的结果,而是方法的副作用print () 函数。
顺便说一句,打印 是Python 2和Python 3之间最大的区别之一。在python3中,圆括号是必需的,而在python2中则不是。这是因为在Python 3中,print () 是函数调用。稍后将详细介绍函数。
离开REPL
此时,我们应该向您展示如何退出REPL并返回系统shell提示符。我们通过发送文件尾 控制字符,但不幸的是,发送该字符的方法因平台而异。
窗户
如果你在Windows上,按ctrl - z 退出。
Unix
如果你用的是Mac或Linux,按一下ctrl - d 退出。
如果你经常在平台之间切换,不小心按下了ctrl - z 在类似unix的系统上,您会无意中挂起Python解释器并返回到操作系统shell。要通过使Python再次成为前台进程来重新激活它,请运行成品 命令:
fg美元
并按输入 并多次返回Python的三重箭头提示符:
>>>
代码结构和重要缩进
启动Python 3解释器:
>python
在Windows或:
python3美元
在Mac或Linux上。
Python的控制流结构,如for-loops、while-loops和if-statements,都是由以冒号结束的语句引入的,这表明后面是构造体。例如,For循环需要一个正文,所以如果你输入:
>>>为我在范围(5):...
Python将向您显示由三个点组成的提示符,要求您提供正文。
Python的一个独特(有时是有争议的)方面是前导空格在语法上很重要。这意味着Python使用缩进级别,而不是其他语言使用的大括号来划分代码块。按照惯例,现代Python代码每层缩进四个空格。
因此,当Python给出三个点提示符时,我们提供了这四个空格和一条语句来形成循环体:
...x=我*10
循环体将包含第二个语句,因此在按下返回 在下一个三点提示符中,我们将输入另外四个空格,然后调用内置的print () 功能:
...打印(x)
为了终止我们的块,我们必须在REPL中输入一个空行:
...
代码块完成后,Python执行挂起的代码,打印出小于50的10的倍数:
01020.30.40
看一屏Python代码,我们可以清楚地看到缩进是如何匹配的——事实上必须 匹配-程序的结构。
Python源代码
即使我们用灰线替换代码,程序的结构也是清晰的。
灰色代码
以冒号结束的每个语句开始一个新行,并引入一个额外的缩进级别,直到缩进将缩进恢复到以前的级别。每一层缩进通常是四个空格,不过我们稍后将更详细地讨论这些规则。
Python处理重要空白的方法有三个很大的优点:
- 它迫使开发人员在代码块中使用单一级别的缩进。在任何语言中,这通常都被认为是很好的实践,因为它使代码更具可读性。
- 有重要空格的代码不需要用不必要的大括号来混淆,而且您永远不需要对大括号应该放在哪里进行代码标准的争论。Python代码中的所有代码块都很容易识别,并且每个人都以相同的方式编写它们。
- 重要的空白要求作者、Python运行时系统和未来需要阅读代码的维护者必须对代码结构给出一致的解释。因此,从Python的角度来看,你永远不会有包含块的代码,但从粗略的人类角度来看,它看起来不像包含块。
Python缩进的规则看起来很复杂,但在实践中非常简单。
- 您使用的空白可以是空格或制表符。普遍的共识是
空格比制表符更可取 ,四个空格已经成为Python社区的标准 .
- 一个基本规则是
从来没有 混合空格和制表符。Python解释器会抱怨,你的同事会找你麻烦。
- 如果您愿意,您可以在不同的时间使用不同数量的缩进。基本规则是
相同缩进级别的连续代码行被认为是同一代码块的一部分 .
- 这些规则也有一些例外,但它们几乎总是与以其他方式提高代码可读性有关,例如将必要的长语句拆分为多行。
这种严格的代码格式化方法是“按照Guido的意愿编程”,或者更恰当地说,“按照Guido的意愿编程”缩进 它”!高度重视代码质量(如可读性)的哲学是Python文化的核心,现在我们将稍事休息来探索一下。
Python文化
许多编程语言处于文化运动的中心。它们有自己的社区、价值观、实践和哲学,Python也不例外。Python语言本身的开发是通过一系列名为Python增强建议 ,或锐气 .其中一个PEP叫做PEP 8,它解释了应该如何格式化代码,我们在本书中遵循它的指导方针。例如,PEP 8建议我们在新的Python代码中使用四个空格作为缩进。
这些PEP中的另一个,叫做PEP 20,被称为“Python的禅宗”。它引用了20条描述Python指导原则的格言,其中只有19条被记录下来。方便的是,Python的Zen永远不会比最近的Python解释器更远,因为它总是可以通过输入以下命令从REPL访问:
>>>进口这Python的禅宗,蒂姆·彼得斯美丽的是比丑陋好.显式的是比含蓄要好.简单的是比复杂的.复杂的是好于复杂.平是比嵌套更好.稀疏的是比密集要好.可读性计数.特殊情况并不特别到打破规则.尽管实用性胜过纯洁性.永远不要犯错误通过默默地.除非明确保持沉默.面对模棱两可,不要去猜测.应该有一个--而且最好只有一个--很明显的方法.尽管那样可能不除非你是荷兰人.现在是聊胜于无.虽然从来没有是通常比*正确的*现在.如果实现是很难解释,这是个坏主意.如果实现是很容易解释,这可能是个好主意.命名空间是一个非常棒的想法--让我们多做一些吧!
在这本书中,我们将强调来自Python禅宗的智慧禅的时刻 理解它们如何应用于我们所学的知识。因为我们刚刚介绍了Python重要缩进,所以现在是时候开始第一个缩进了禅宗时刻 .
随着时间的推移,您将逐渐欣赏Python中重要的空白所带来的优雅你的 代码,以及阅读的便利性其他的 .
导入标准库模块
如前所述,Python附带了一个广泛的标准库,Python的一个方面通常被称为“包含电池”。标准库的结构为模块 ,我们稍后将深入讨论这个话题。在此阶段,重要的是要知道您可以通过使用进口 关键字。
导入模块的基本形式是进口 关键字,后跟空格和模块名称。例如,让我们看看如何使用标准库数学 模块来计算平方根。在三箭头提示符下,我们输入:
>>>进口数学
自进口 是一个不返回值的语句,如果导入成功,Python不会打印任何内容,我们立即返回到提示符。我们可以通过以下方式访问导入模块的内容:模块名,后跟一个点,再后跟模块中所需的属性名。像许多面向对象的语言一样,点运算符用于向下钻取对象结构。作为Pythonistas的专家,我们知道数学 模块包含一个名为sqrt () .让我们试着使用它:
>>>数学.√6(81)9.0
得到
帮助()
但是,我们如何才能找到在数学 模块?
REPL有一个特殊的功能帮助() 它可以从提供文档的对象(如标准库模块)中检索任何嵌入式文档。
要获得帮助,请在提示符处输入“help”:
>>>帮助类型帮助()为互动帮助,orgydF4y2Ba帮助(对象)为帮助关于对象.
我们将让您在自己的时间探索第一种形式-交互式帮助。这里我们选择第二个选项,通过数学 模块作为我们需要帮助的对象:
>>>帮助(数学)模块数学方面的帮助:的名字数学模块引用http://文档.python.org/3.3/图书馆/数学以下文档是自动生成的从Python源文件.可能是不完整的,不正确的orgydF4y2Ba包括以下特性被认为是实现细节而且可能在Python之间有所不同实现.当在怀疑,的模块参考上面列出的地点.描述这个模块是总是可用的.对象的访问由C标准定义的数学函数.功能这些“可信赖医疗组织”(...)这些“可信赖医疗组织”(x)返回arccos(测量在弧度)(x).
你可以使用空格键来翻页帮助,如果你在Mac或Linux上使用方向键来上下滚动。
浏览这些函数,你会看到有一个数学函数,的阶乘 ,用于计算阶乘。按“q”退出帮助浏览器,并返回到Python REPL。
现在练习使用帮助() 请求特定的帮助的阶乘 功能:
>>>帮助(数学.的阶乘)建立帮助-在功能!在模块的数学:的阶乘(...)的阶乘(x)->积分找到x !.引发ValueError如果x是负orgydF4y2Ba非-积分.
按' q '返回REPL。
让我们使用阶乘() 一点。该函数接受一个整型参数并返回一个整型值:
>>>数学.的阶乘(5)120>>>数学.的阶乘(6)720
注意我们需要如何用模块名称空间限定函数名。这通常是很好的实践,因为它使函数的来源非常清楚。也就是说,它可能导致代码过于冗长。
数水果
数学.的阶乘()
让我们用阶乘来计算从5个水果中抽取3个水果的方法有多少种,使用我们在学校学过的数学:
>>>n=5>>>k=3.>>>数学.的阶乘(n)/(数学.的阶乘(k)*数学.的阶乘(n-k))10.0
这个简单的表达式包含了对数学模块的所有引用,非常冗长。Python进口 语句具有另一种形式,该形式允许我们使用从 关键字:
>>>从数学进口的阶乘>>>的阶乘(n)/(的阶乘(k)*的阶乘(n-k))10.0
这是一个很好的改进,但是对于这样一个简单的表达式来说还是有点啰嗦。
import语句的第三种形式允许我们重命名导入的函数。这对于可读性或避免名称空间冲突很有用。虽然它很有用,但是我们建议不要经常使用这个功能,并且要明智地使用:
>>>从数学进口的阶乘作为前沿空中管制官>>>前沿空中管制官(n)/(前沿空中管制官(k)*前沿空中管制官(n-k))10.0
不同类型的数字
记住,当我们用阶乘() 单独返回一个整数。但是我们上面用来计算组合的更复杂的表达式是产生一个浮点数。这是因为我们用过/ , Python的浮点除法运算符。因为我们知道我们的运算只会返回积分结果,我们可以通过使用改进表达式// , Python的整数除法运算符:
>>>从数学进口的阶乘作为前沿空中管制官>>>前沿空中管制官(n)//(前沿空中管制官(k)*前沿空中管制官(n-k))10
值得注意的是,许多其他编程语言即使是中等值的n .在大多数编程语言中,普通的有符号整数只能存储小于的值<我mg width="20" class="lazyload inline justify-self-center" src="https://learnable-static.s3.amazonaws.com/premium/reeedr/books/the-python-apprentice/images/000056.png" alt="2 ^ {31}gydF4y2Ba" loading="lazy">:
>>>2**31-12147483647
然而,阶乘增长得如此之快,以至于您可以放入32位有符号整数的最大阶乘是12!因为13 !太大:
>>>前沿空中管制官(13)6227020800
在大多数广泛使用的编程语言中,你要么需要更复杂的代码,要么需要更复杂的数学,仅仅是计算从13个水果中抽出3个水果的方法有多少种。
Python不会遇到这样的问题,它可以计算任意大的整数,只受计算机内存的限制。为了进一步证明这一点,让我们尝试一个更大的问题,计算我们可以从100种不同的水果中挑选多少对不同的水果(假设我们可以找到这么多水果!):
>>>n=One hundred.>>>k=2>>>前沿空中管制官(n)//(前沿空中管制官(k)*前沿空中管制官(n-k))4950
只是为了强调这个表达式的第一项有多大,计算100!就其本身而言:
>>>前沿空中管制官(n)93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463\976156518286253697920827223758251185210916864000000000000000000000000
这个数字甚至比已知宇宙中的原子数量还要大得多,有很多数字。如果你像我们一样好奇到底有多少位数字,我们可以将整数转换为文本字符串,并像这样计算其中的字符数:
>>>len(str(前沿空中管制官(n)))158
这肯定有很多数字。还有很多水果。它还开始展示Python的不同数据类型(在本例中是整数、浮点数和文本字符串)如何以自然的方式协同工作。在下一节中,我们将以这一经验为基础,更详细地讨论整数、字符串和其他内置类型。
标量数据类型:整数、浮点数、None和bool
Python自带许多内置数据类型。这些类型包括像整数这样的基本标量类型以及像字典这样的集合类型。这些内置类型功能强大,可以单独用于许多编程需求,并且可以用作创建更复杂数据类型的构建块。
我们将讨论的基本内置标量类型有:
int-带符号的、无限精度的整数
浮动- IEEE 754浮点数
没有一个-一个特殊的、奇异的空值
保龄球- true/false布尔值
现在我们只看它们的基本细节,展示它们的文字形式以及如何创建它们。
int
我们已经见过很多Python整数的应用。Python整数是有符号的,并且在实际应用中具有无限的精度。这意味着它们所能保存的值的大小没有预先定义的限制。
Python中的整数字面量通常以十进制指定:
>>>1010
它们也可以用二进制文件指定0 b 前缀:
>>>b10 02
八进制,带a0啊 前缀:
>>>0 o108
或者带a的十六进制0 x 前缀:
>>>0 x1016
方法也可以构造整数int 构造函数,可以将其他数值类型(如浮点数)转换为整数:
>>>int(3.5)3.
注意,当使用int 构造函数时,舍入总是趋于零:
>>>int(-3.5)-3.>>>int(3.5)3.
我们还可以将字符串转换为整数:
>>>int(“496”)496
但是请注意,如果字符串不表示整数,Python将抛出异常(后面会详细介绍!)。
在从字符串转换时,甚至可以提供一个可选的数字基数。例如,要从以3为基数进行转换,只需将3作为第二个参数传递给构造函数:
>>>int(“10000”,3.)81
浮动
类在Python中支持浮点数浮动 类型。Python浮点数实现为<一个href="https://en.wikipedia.org/wiki/IEEE_floating_point" class="" target="_blank">IEEE-754双精度浮点数一个>具有53位二进制精度。这相当于十进制中的15到16位有效数字。
任何包含小数点的文字数字都被Python解释为浮动 :
>>>3.1253.125
可以使用科学记数法,因此对于较大的数字,例如<我mg width="55" class="lazyload inline justify-self-center" src="https://learnable-static.s3.amazonaws.com/premium/reeedr/books/the-python-apprentice/images/000029.png" alt="3 \ times10 ^ 8gydF4y2Ba" loading="lazy">,即光速的近似速度(以米每秒为单位),可写成:
>>>3 e8300000000.0
以及像普朗克常数这样的小数值<我mg width="104" class="lazyload inline justify-self-center" src="https://learnable-static.s3.amazonaws.com/premium/reeedr/books/the-python-apprentice/images/000011.png" alt="1.616\times10^{- 35}gydF4y2Ba" loading="lazy">我们可以进入:
>>>1.616 e-351.616 e-35
请注意Python如何自动将显示表示转换为最易读的形式。
类将其他数值或字符串类型转换为浮点数浮动 构造函数。例如,构造函数可以接受int :
>>>浮动(7)7.0
或者字符串:
>>>浮动(“1.618”)1.618
特殊的浮点值
通过将某些字符串传递给浮动 构造函数时,可以创建特殊的浮点值南 (简称N 不一个 NUmber)以及正无穷和负无穷:
>>>浮动(“南”)南>>>浮动(“正”)正>>>浮动(“负”)-正
上市推广
计算结果:涉及的任何计算的结果int 而且浮动 被提升为浮动 :
>>>3.0+14.0
你可以阅读更多关于Python的数字类型<一个href="http://docs.python.org/3/library/stdtypes.html" class="" target="_blank">在Python文档中一个>.
没有一个
Python有一个特殊的空值叫做没有一个 ,用大写的“N”拼写。没有一个 常用于表示值的缺失。Python REPL从不打印没有一个 结果,所以打字没有一个 进入REPL没有效果:
>>>没有一个>>>
没有一个可以像其他对象一样绑定到变量名:
>>>一个=没有一个
我们可以测试一个物体是否没有一个 使用Python的是 接线员:
>>>一个是没有一个真正的
我们可以看到这里的响应是真正的 ,这就很方便地把我们带到了保龄球 类型。
保龄球
的保龄球 type表示逻辑状态,在Python的几个控制流结构中扮演着重要的角色,我们很快就会看到。
正如你所期望的,有两个bool值,真正的 而且假 ,都用首字母大写:
>>>真正的真正的>>>假假
还有一个保龄球 构造函数,可用于从其他类型转换为保龄球 .让我们看看它是如何工作的。为int S, 0被认为是“假的”,所有其他值被认为是“真的”:
>>>保龄球(0)假>>>保龄球(42)真正的>>>保龄球(-1)真正的
我们看到同样的行为浮动 S,其中只有0被认为是“假的”:
>>>保龄球(0.0)假>>>保龄球(0.207)真正的>>>保龄球(-1.117)真正的>>>保龄球(浮动(“南”))真正的
当从集合(如字符串或列表)进行转换时,只有空集合被视为“伪集合”。当从列表进行转换时——我们很快就会看到——我们只看到空列表(这里显示为的字面形式)[] )计算为假 :
>>>保龄球([])假>>>保龄球([1,5,9])真正的
类似地,对于字符串只有空字符串,"" ,计算为假 当传递给保龄球 :
>>>保龄球("")假>>>保龄球(“垃圾邮件”)真正的
特别是,不能使用保龄球 的字符串表示形式进行转换真正的 而且假 :
>>>保龄球(“假”)真正的
由于字符串" False "不是空的,它将求值为真正的 !
这些转换为保龄球 是重要的,因为它们在Python的if语句和while循环中被广泛使用保龄球 值。
关系运算符
布尔值通常由Python的关系操作符产生,可用于比较对象。
使用最广泛的两个关系操作符是Python的相等和不相等测试,它们实际上测试值的等价性或不相等性。也就是说,两个对象是等效 如果一个能代替另一个。我们将在本书后面了解更多关于对象等价的概念。现在,我们将比较简单的整数。
让我们从给变量赋值或绑定值开始g :
>>>g=20.
我们测试平等= = :
>>>g= =20.真正的>>>g= =13假
或者用不等式! = :
>>>g! =20.假>>>g! =13真正的
丰富的比较运算符
我们还可以使用丰富的比较运算符来比较数量的顺序。使用< 确定第一个参数是否小于第二个参数:
>>>g<30.真正的
同样,使用> 判断第一个是否大于第二个:
>>>g>30.假
您可以测试小于或等于< = :
>>>g< =20.真正的
大于或等于> = :
>>>g> =20.真正的
如果您有使用其他语言的关系操作符的经验,那么Python的操作符可能一点也不奇怪。请记住,这些运算符比较的是等价性,而不是恒等性,我们将在接下来的章节中详细讨论这一区别。
控制流:if语句和while循环
现在我们已经研究了一些基本的内置类型,让我们看看两个重要的控制流结构,它们依赖于转换到保龄球 类型:if语句和while循环。
条件控制流:if语句
条件语句允许我们基于表达式的值进行分支执行。陈述的形式是如果 关键字,后跟表达式,以冒号结束以引入新块。让我们在REPL试试这个:
>>>如果真正的:
记住在块内缩进四个空格,我们添加一些代码,如果条件为真正的 ,后面跟着一个空行来终止该块:
...打印(“这是真的!”)...这是真的!
此时块将执行,因为不言而喻的条件是真正的 .相反,如果条件是假 ,块中的代码不会执行:
>>>如果假:...打印(“这是真的!”)...>>>
与if语句一起使用的表达式将转换为a保龄球 就好像布尔值() 构造函数已经被使用,因此:
>>>如果保龄球(“鸡蛋”):...打印(“是的,请!”)...是的,请!
完全等价于:
>>>如果“鸡蛋”:...打印(“是的,请!”)...是的,请!
多亏了这个有用的简写,显式转换为保龄球 使用保龄球 构造函数在Python中很少使用。
如果...其他的
if语句支持可选的“else”子句,该子句位于语句引入的块中其他的 关键字(后跟冒号),缩进到与如果 关键字。让我们先创建(但不是结束)一个if-block:
>>>h=42>>>如果h>50:...打印(“大于50”)
开始其他的 在这种情况下,我们只是省略了三个点后的缩进:
...其他的:...打印(“50或以下”)...50orgydF4y2Ba小
如果...elif...其他的
在多种情况下,你可能会这样做:
>>>如果h>50:...打印(“大于50”)...其他的:...如果h<20.:...打印(“少于20”)...其他的:...打印(“20到50岁之间”)...之间的20.而且50
当你发现自己的else-block中包含嵌套的if语句时,你应该考虑使用Python的if语句elif 关键字,这是一个组合else if .
正如Python的禅宗所提醒我们的,“扁平比嵌套好”:
>>>如果h>50:...打印(“大于50”)...elifh<20.:...打印(“少于20”)...其他的:...打印(“20到50岁之间”)...之间的20.而且50
这个版本更容易阅读。
条件重复:while循环
Python有两种类型的循环:for循环和while循环。在介绍重要的空格时,我们已经简单地遇到过for循环,我们很快就会回到它们,但现在我们将介绍while循环。
类引入了Python中的while循环而 关键字,后面跟着一个布尔表达式。与if-语句的条件一样,表达式隐式转换为布尔值,就好像它已传递给布尔值() 构造函数。的而 语句以冒号结束,因为它引入了一个新的块。
让我们在REPL中写一个从5到1的循环。我们将初始化一个计数器变量c 到5,一直循环直到0。这里的另一个新语言特性是使用了增广赋值运算符,- = ,以便在每次迭代时从计数器的值中减去1。类似的增广赋值运算符也存在于其他基本数学运算中,如加法和乘法:
>>>c=5>>>而c! =0:...打印(c)...c- =1...543.21
因为条件(或谓词)将隐式转换为保龄球 ,就好像一声呼唤布尔值() 构造函数存在时,我们可以用以下版本替换上面的代码:
>>>c=5>>>而c:...打印(c)...c- =1...543.21
这是因为整数值的转换c 来保龄球 结果真正的 直到我们得到0,它转化为假 .也就是说,在这种情况下使用这种简短的形式可能会被描述为非Python的,因为,回顾Python的禅宗,显式比隐式更好。我们更看重第一种形式的可读性,而不是第二种形式的简洁。
而在Python中,循环通常用于需要无限循环的地方。我们通过传递来实现这一点真正的 作为while结构的谓词表达式:
>>>而真正的:...打印(“循环!”)...循环!循环!循环!循环!循环!循环!循环!循环!
现在您可能想知道我们如何摆脱这个循环并重新控制我们的REPL!简单的新闻ctrl - c :
循环!循环!循环!循环!循环!循环!^C回溯(最近一次通话):文件“< stdin >”,行2,在<模块>KeyboardInterrupt>>>
Python拦截键击并引发一个终止循环的特殊异常。我们将在后面的第6章中详细讨论异常是什么,以及如何使用它们。
退出循环
打破
许多编程语言都支持将谓词测试放在循环的末尾而不是开头的循环构造。例如,C、c++、c#和Java都支持do-while结构。其他语言也有repeat-until循环。在Python中不是这样,在Python中习惯用法是使用而真正的 加上提前退出,由打破 声明。
的打破 语句跳出循环(如果嵌套了几个循环,则只跳出最内层的循环),在循环体结束后立即继续执行。
让我们看一个例子打破 ,在此过程中介绍了其他一些Python特性,并逐行检查:
>>>而真正的:...响应=输入()...如果int(响应)%7= =0:...打破...
我们从a开始而真正的: 对于一个无限循环。在while块的第一条语句中,我们使用内置的输入() 函数向用户请求字符串。我们把这个字符串赋值给一个变量响应 .
现在我们使用if语句来测试所提供的值是否能被7整除。方法将响应字符串转换为整数int () 构造函数,然后使用模运算符,% 除以7,得到余数。如果余数等于0,则响应可以被7整除,然后进入If块体。
在if-块中,现在有两层缩进深,我们从八个空格开始,并使用打破 关键字。打破 终止最内部的循环(在本例中为while循环),并使执行跳转到循环后的第一个语句。
在这里,“语句”是程序的结束。我们在三点提示符处输入空行,关闭if-块和while-块。
我们的循环将开始执行,并在调用输入() 等着我们输入数字。让我们试几个:
673428>>>
只要输入一个能被7整除的数,谓词就变成真正的 ,我们进入if-块,然后从字面上跳出循环,直到程序结束,返回到REPL提示符。
总结
- 从Python开始
- 获取并安装Python
- 启动Read-Eval-Print-Loop或REPL
- 简单的算术
- 通过将对象绑定到名称来创建变量
- 内置打印
print () 函数
- 退出REPL
ctrl - z (Windows)或ctrl - d (Unix)
被预言的
明显的压痕
PEP 8 - Python代码的风格指南
PEP 20 - Python的禅
使用import语句以各种形式导入模块
查找和浏览帮助()
基本类型和控制流
int年代,浮动 年代,没有一个 ,保龄球 ,加上它们之间的转换
用于相等性和排序测试的关系运算符
if指令与其他的 而且elif 块
带有隐式转换的while循环保龄球
中断无限循环ctrl - c
打破循环与打破
从用户请求文本输入()
增广赋值运算符
预览结束
注册解锁剩余的标题。一个>
社区问题
关闭
Python语言有两个主要版本,
在开始用Python编程之前,我们需要掌握一个Python环境。Python是一种高度可移植的语言,在所有主要操作系统上都可用。你将能够在Windows、Mac或Linux上阅读这本书,我们唯一涉及到平台细节的主要部分即将到来——当我们安装Python 3时。当我们介绍这三个平台时,可以跳过与您无关的部分。
窗户
- 对于Windows,您需要访问<一个href="http://python.org" class="" target="_blank">Python官方网站一个>,然后点击左边的链接进入下载页面。对于Windows,你应该选择一个MSI安装程序,这取决于你是在32位还是64位平台上运行。
- 下载并运行安装程序。
- 在安装程序中,决定是只为自己安装Python,还是为机器的所有用户安装Python。
- 为Python发行版选择一个位置。默认值将在
C: \ Python35 的根C: 开车。我们不建议将Python安装到程序文件 因为在Windows Vista及以后的版本中,用于隔离应用程序的虚拟化文件存储可能会影响轻松安装第三方Python包。 - 在
自定义Python 页面的向导,我们建议保持默认值,使用小于40 MB的空间。 - 除了安装Python运行时和标准库之外,安装程序还将注册各种文件类型,例如
* . py 文件,Python解释器。 - 安装Python之后,需要将Python添加到系统中
路径 环境变量。要做到这一点,从控制面板选择系统与安全 ,然后系统 .另一种轻松到达这里的方法是按住Windows键并按下键盘上的Break键。使用左侧的任务窗格进行选择系统高级设置 打开先进的 的标签。系统属性 对话框。点击环境变量 打开子对话框。 - 如果您拥有管理员权限,您应该能够添加路径
C: \ Python35 而且C: \ Python35 \脚本 属性关联的分号分隔的项列表路径 系统变量。如果没有,则应该能够创建或添加路径 变量中包含相同的值。 - 现在打开
新 控制台窗口- Powershell或cmd都可以工作-并验证您可以从命令行运行python:
>pythonPython3.5.0(v3.5.0:374年f501f4567,9月132015,02:27:37)[MSC v.190064位(AMD64)]在\win32类型“帮助”,“版权”,“信用”orgydF4y2Ba“许可证”为更多的信息.>>>
欢迎来到Python!
三箭头提示符显示Python正在等待您的输入。
在这一点上,当我们展示如何在Mac和Linux上安装Python时,您可能想要跳过。
macOS
- 对于macOS,您需要访问Python官方网站<一个href="http://python.org" class="" target="_blank">http://python.org一个>.点击左边的链接进入下载页面。在“下载”页面,找到与您的macOS版本匹配的macOS安装程序,并单击链接下载。
- 下载DMG磁盘映像文件,您可以从下载堆栈或查找器中打开该文件。
- 在打开的Finder窗口中,您将看到该文件
Python.mpkg 多包安装文件。使用“辅助”单击操作打开该文件的上下文菜单。从菜单中选择“打开”。 - 在某些版本的macOS上,您现在会被告知该文件来自一个身份不明的开发人员。按下对话框上的“打开”按钮继续安装。
- 您现在处于Python安装程序中。按照指示,点击向导。
- 不需要自定义安装,您应该保持标准设置。当它可用时,单击“安装”按钮来安装Python。您可能会被要求输入密码以授权安装。安装完成后,点击“关闭”关闭安装程序。
- 现在已经安装了Python 3,打开一个终端窗口,并验证您可以从命令行运行Python 3:
>pythonPython3.5.0(默认的,11月3.2015,13:17:02)[海湾合作委员会4.2.1兼容Apple LLVM6.1.0(铿锵声-602.053)]在达尔文类型“帮助”,“版权”,“信用”orgydF4y2Ba“许可证”为更多的信息.>>>
欢迎来到Python!
三个箭头提示符表明Python正在等待您的输入。
Linux
- 要在Linux上安装Python,您需要使用系统的包管理器。我们将展示如何在最新版本的Ubuntu上安装Python,但在大多数其他现代Linux发行版上,这个过程非常相似。
- 在Ubuntu上,首先启动“Ubuntu软件中心”。这通常可以通过点击启动器中的图标来运行。或者,你也可以通过在仪表板上搜索“Ubuntu软件中心”并点击选择来运行它。
- 进入软件中心后,在右上角的搜索栏中输入搜索词“python 3.5”,然后按回车键。
- 其中一个结果将显示“Python (v3.5)”,下面以较小的字体显示“Python解释器(v3.5)”。选择该条目并单击出现的“Install”按钮。
- 此时,您可能需要输入密码来安装软件。
- 您现在应该看到出现了一个进度指示器,安装完成后该指示器将消失。
- 打开终端(使用
Ctrl-Alt-T ),并验证您可以从命令行运行Python 3.5:
python3美元.5Python3.5.0+(默认的,10月112015,09:05:38)[海湾合作委员会5.2.120151010]在linux上类型“帮助”,“版权”,“信用”orgydF4y2Ba“许可证”为更多的信息.>>>
欢迎来到Python!
三箭头提示符显示Python正在等待您的输入。
启动Python命令行REPL
现在Python已经安装并运行,您可以立即开始使用它。这是了解语言的好方法,也是在正常开发过程中进行实验和快速测试的有用工具。
这个Python命令行环境是一个Read-Eval-Print-Loop .Python会读 不管输入什么,EVAL uate它,打印 结果是循环 回到最开始。你会经常听到它被缩写为“REPL”。
当启动时,REPL将打印一些关于正在运行的Python版本的信息,然后它将给您一个三重箭头提示。这个提示符告诉您Python正在等待您输入一些内容。
在交互式Python会话中,您可以输入Python程序片段并看到即时结果。让我们从一些简单的算术开始:
>>>2+24>>>6*742
正如你所看到的,Python读取我们的输入,求值,打印结果,然后循环执行同样的操作。
我们可以在REPL中为变量赋值:
>>>x=5
通过输入它们的名称打印它们的内容:
>>>x5
并在表达式中引用它们:
>>>3.*x15
在REPL中,你可以使用特殊的下划线变量来引用最近打印的值,这是Python中为数不多的晦涩快捷方式之一:
>>>_15
或者你可以在表达式中使用特殊的下划线变量:
>>>_*230.
请注意
记住,这个有用的技巧只在REPL中有效;下划线在Python脚本或程序中没有任何特殊行为。
注意,并非所有语句都有返回值。当我们把5赋值给x 没有返回值,只有带来变量的副作用x 。其他的说法有更明显的副作用。
试一试:
>>>打印(“你好,Python”)你好,Python
您将看到Python立即计算并执行此命令,打印字符串“Hello, Python”并返回到另一个提示符。重要的是要理解这里的响应不是REPL计算和显示的表达式的结果,而是方法的副作用print () 函数。
顺便说一句,打印 是Python 2和Python 3之间最大的区别之一。在python3中,圆括号是必需的,而在python2中则不是。这是因为在Python 3中,print () 是函数调用。稍后将详细介绍函数。
离开REPL
此时,我们应该向您展示如何退出REPL并返回系统shell提示符。我们通过发送文件尾 控制字符,但不幸的是,发送该字符的方法因平台而异。
窗户
如果你在Windows上,按ctrl - z 退出。
Unix
如果你用的是Mac或Linux,按一下ctrl - d 退出。
如果你经常在平台之间切换,不小心按下了ctrl - z 在类似unix的系统上,您会无意中挂起Python解释器并返回到操作系统shell。要通过使Python再次成为前台进程来重新激活它,请运行成品 命令:
fg美元
并按输入 并多次返回Python的三重箭头提示符:
>>>
代码结构和重要缩进
启动Python 3解释器:
>python
在Windows或:
python3美元
在Mac或Linux上。
Python的控制流结构,如for-loops、while-loops和if-statements,都是由以冒号结束的语句引入的,这表明后面是构造体。例如,For循环需要一个正文,所以如果你输入:
>>>为我在范围(5):...
Python将向您显示由三个点组成的提示符,要求您提供正文。
Python的一个独特(有时是有争议的)方面是前导空格在语法上很重要。这意味着Python使用缩进级别,而不是其他语言使用的大括号来划分代码块。按照惯例,现代Python代码每层缩进四个空格。
因此,当Python给出三个点提示符时,我们提供了这四个空格和一条语句来形成循环体:
...x=我*10
循环体将包含第二个语句,因此在按下返回 在下一个三点提示符中,我们将输入另外四个空格,然后调用内置的print () 功能:
...打印(x)
为了终止我们的块,我们必须在REPL中输入一个空行:
...
代码块完成后,Python执行挂起的代码,打印出小于50的10的倍数:
01020.30.40
看一屏Python代码,我们可以清楚地看到缩进是如何匹配的——事实上必须 匹配-程序的结构。
Python源代码
即使我们用灰线替换代码,程序的结构也是清晰的。
灰色代码
以冒号结束的每个语句开始一个新行,并引入一个额外的缩进级别,直到缩进将缩进恢复到以前的级别。每一层缩进通常是四个空格,不过我们稍后将更详细地讨论这些规则。
Python处理重要空白的方法有三个很大的优点:
- 它迫使开发人员在代码块中使用单一级别的缩进。在任何语言中,这通常都被认为是很好的实践,因为它使代码更具可读性。
- 有重要空格的代码不需要用不必要的大括号来混淆,而且您永远不需要对大括号应该放在哪里进行代码标准的争论。Python代码中的所有代码块都很容易识别,并且每个人都以相同的方式编写它们。
- 重要的空白要求作者、Python运行时系统和未来需要阅读代码的维护者必须对代码结构给出一致的解释。因此,从Python的角度来看,你永远不会有包含块的代码,但从粗略的人类角度来看,它看起来不像包含块。
Python缩进的规则看起来很复杂,但在实践中非常简单。
- 您使用的空白可以是空格或制表符。普遍的共识是
空格比制表符更可取 ,四个空格已经成为Python社区的标准 .
- 一个基本规则是
从来没有 混合空格和制表符。Python解释器会抱怨,你的同事会找你麻烦。
- 如果您愿意,您可以在不同的时间使用不同数量的缩进。基本规则是
相同缩进级别的连续代码行被认为是同一代码块的一部分 .
- 这些规则也有一些例外,但它们几乎总是与以其他方式提高代码可读性有关,例如将必要的长语句拆分为多行。
这种严格的代码格式化方法是“按照Guido的意愿编程”,或者更恰当地说,“按照Guido的意愿编程”缩进 它”!高度重视代码质量(如可读性)的哲学是Python文化的核心,现在我们将稍事休息来探索一下。
Python文化
许多编程语言处于文化运动的中心。它们有自己的社区、价值观、实践和哲学,Python也不例外。Python语言本身的开发是通过一系列名为Python增强建议 ,或锐气 .其中一个PEP叫做PEP 8,它解释了应该如何格式化代码,我们在本书中遵循它的指导方针。例如,PEP 8建议我们在新的Python代码中使用四个空格作为缩进。
这些PEP中的另一个,叫做PEP 20,被称为“Python的禅宗”。它引用了20条描述Python指导原则的格言,其中只有19条被记录下来。方便的是,Python的Zen永远不会比最近的Python解释器更远,因为它总是可以通过输入以下命令从REPL访问:
>>>进口这Python的禅宗,蒂姆·彼得斯美丽的是比丑陋好.显式的是比含蓄要好.简单的是比复杂的.复杂的是好于复杂.平是比嵌套更好.稀疏的是比密集要好.可读性计数.特殊情况并不特别到打破规则.尽管实用性胜过纯洁性.永远不要犯错误通过默默地.除非明确保持沉默.面对模棱两可,不要去猜测.应该有一个--而且最好只有一个--很明显的方法.尽管那样可能不除非你是荷兰人.现在是聊胜于无.虽然从来没有是通常比*正确的*现在.如果实现是很难解释,这是个坏主意.如果实现是很容易解释,这可能是个好主意.命名空间是一个非常棒的想法--让我们多做一些吧!
在这本书中,我们将强调来自Python禅宗的智慧禅的时刻 理解它们如何应用于我们所学的知识。因为我们刚刚介绍了Python重要缩进,所以现在是时候开始第一个缩进了禅宗时刻 .
随着时间的推移,您将逐渐欣赏Python中重要的空白所带来的优雅你的 代码,以及阅读的便利性其他的 .
导入标准库模块
如前所述,Python附带了一个广泛的标准库,Python的一个方面通常被称为“包含电池”。标准库的结构为模块 ,我们稍后将深入讨论这个话题。在此阶段,重要的是要知道您可以通过使用进口 关键字。
导入模块的基本形式是进口 关键字,后跟空格和模块名称。例如,让我们看看如何使用标准库数学 模块来计算平方根。在三箭头提示符下,我们输入:
>>>进口数学
自进口 是一个不返回值的语句,如果导入成功,Python不会打印任何内容,我们立即返回到提示符。我们可以通过以下方式访问导入模块的内容:模块名,后跟一个点,再后跟模块中所需的属性名。像许多面向对象的语言一样,点运算符用于向下钻取对象结构。作为Pythonistas的专家,我们知道数学 模块包含一个名为sqrt () .让我们试着使用它:
>>>数学.√6(81)9.0
得到
帮助()
但是,我们如何才能找到在数学 模块?
REPL有一个特殊的功能帮助() 它可以从提供文档的对象(如标准库模块)中检索任何嵌入式文档。
要获得帮助,请在提示符处输入“help”:
>>>帮助类型帮助()为互动帮助,orgydF4y2Ba帮助(对象)为帮助关于对象.
我们将让您在自己的时间探索第一种形式-交互式帮助。这里我们选择第二个选项,通过数学 模块作为我们需要帮助的对象:
>>>帮助(数学)模块数学方面的帮助:的名字数学模块引用http://文档.python.org/3.3/图书馆/数学以下文档是自动生成的从Python源文件.可能是不完整的,不正确的orgydF4y2Ba包括以下特性被认为是实现细节而且可能在Python之间有所不同实现.当在怀疑,的模块参考上面列出的地点.描述这个模块是总是可用的.对象的访问由C标准定义的数学函数.功能这些“可信赖医疗组织”(...)这些“可信赖医疗组织”(x)返回arccos(测量在弧度)(x).
你可以使用空格键来翻页帮助,如果你在Mac或Linux上使用方向键来上下滚动。
浏览这些函数,你会看到有一个数学函数,的阶乘 ,用于计算阶乘。按“q”退出帮助浏览器,并返回到Python REPL。
现在练习使用帮助() 请求特定的帮助的阶乘 功能:
>>>帮助(数学.的阶乘)建立帮助-在功能!在模块的数学:的阶乘(...)的阶乘(x)->积分找到x !.引发ValueError如果x是负orgydF4y2Ba非-积分.
按' q '返回REPL。
让我们使用阶乘() 一点。该函数接受一个整型参数并返回一个整型值:
>>>数学.的阶乘(5)120>>>数学.的阶乘(6)720
注意我们需要如何用模块名称空间限定函数名。这通常是很好的实践,因为它使函数的来源非常清楚。也就是说,它可能导致代码过于冗长。
数水果
数学.的阶乘()
让我们用阶乘来计算从5个水果中抽取3个水果的方法有多少种,使用我们在学校学过的数学:
>>>n=5>>>k=3.>>>数学.的阶乘(n)/(数学.的阶乘(k)*数学.的阶乘(n-k))10.0
这个简单的表达式包含了对数学模块的所有引用,非常冗长。Python进口 语句具有另一种形式,该形式允许我们使用从 关键字:
>>>从数学进口的阶乘>>>的阶乘(n)/(的阶乘(k)*的阶乘(n-k))10.0
这是一个很好的改进,但是对于这样一个简单的表达式来说还是有点啰嗦。
import语句的第三种形式允许我们重命名导入的函数。这对于可读性或避免名称空间冲突很有用。虽然它很有用,但是我们建议不要经常使用这个功能,并且要明智地使用:
>>>从数学进口的阶乘作为前沿空中管制官>>>前沿空中管制官(n)/(前沿空中管制官(k)*前沿空中管制官(n-k))10.0
不同类型的数字
记住,当我们用阶乘() 单独返回一个整数。但是我们上面用来计算组合的更复杂的表达式是产生一个浮点数。这是因为我们用过/ , Python的浮点除法运算符。因为我们知道我们的运算只会返回积分结果,我们可以通过使用改进表达式// , Python的整数除法运算符:
>>>从数学进口的阶乘作为前沿空中管制官>>>前沿空中管制官(n)//(前沿空中管制官(k)*前沿空中管制官(n-k))10
值得注意的是,许多其他编程语言即使是中等值的n .在大多数编程语言中,普通的有符号整数只能存储小于的值<我mg width="20" class="lazyload inline justify-self-center" src="https://learnable-static.s3.amazonaws.com/premium/reeedr/books/the-python-apprentice/images/000056.png" alt="2 ^ {31}gydF4y2Ba" loading="lazy">:
>>>2**31-12147483647
然而,阶乘增长得如此之快,以至于您可以放入32位有符号整数的最大阶乘是12!因为13 !太大:
>>>前沿空中管制官(13)6227020800
在大多数广泛使用的编程语言中,你要么需要更复杂的代码,要么需要更复杂的数学,仅仅是计算从13个水果中抽出3个水果的方法有多少种。
Python不会遇到这样的问题,它可以计算任意大的整数,只受计算机内存的限制。为了进一步证明这一点,让我们尝试一个更大的问题,计算我们可以从100种不同的水果中挑选多少对不同的水果(假设我们可以找到这么多水果!):
>>>n=One hundred.>>>k=2>>>前沿空中管制官(n)//(前沿空中管制官(k)*前沿空中管制官(n-k))4950
只是为了强调这个表达式的第一项有多大,计算100!就其本身而言:
>>>前沿空中管制官(n)93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463\976156518286253697920827223758251185210916864000000000000000000000000
这个数字甚至比已知宇宙中的原子数量还要大得多,有很多数字。如果你像我们一样好奇到底有多少位数字,我们可以将整数转换为文本字符串,并像这样计算其中的字符数:
>>>len(str(前沿空中管制官(n)))158
这肯定有很多数字。还有很多水果。它还开始展示Python的不同数据类型(在本例中是整数、浮点数和文本字符串)如何以自然的方式协同工作。在下一节中,我们将以这一经验为基础,更详细地讨论整数、字符串和其他内置类型。
标量数据类型:整数、浮点数、None和bool
Python自带许多内置数据类型。这些类型包括像整数这样的基本标量类型以及像字典这样的集合类型。这些内置类型功能强大,可以单独用于许多编程需求,并且可以用作创建更复杂数据类型的构建块。
我们将讨论的基本内置标量类型有:
int-带符号的、无限精度的整数
浮动- IEEE 754浮点数
没有一个-一个特殊的、奇异的空值
保龄球- true/false布尔值
现在我们只看它们的基本细节,展示它们的文字形式以及如何创建它们。
int
我们已经见过很多Python整数的应用。Python整数是有符号的,并且在实际应用中具有无限的精度。这意味着它们所能保存的值的大小没有预先定义的限制。
Python中的整数字面量通常以十进制指定:
>>>1010
它们也可以用二进制文件指定0 b 前缀:
>>>b10 02
八进制,带a0啊 前缀:
>>>0 o108
或者带a的十六进制0 x 前缀:
>>>0 x1016
方法也可以构造整数int 构造函数,可以将其他数值类型(如浮点数)转换为整数:
>>>int(3.5)3.
注意,当使用int 构造函数时,舍入总是趋于零:
>>>int(-3.5)-3.>>>int(3.5)3.
我们还可以将字符串转换为整数:
>>>int(“496”)496
但是请注意,如果字符串不表示整数,Python将抛出异常(后面会详细介绍!)。
在从字符串转换时,甚至可以提供一个可选的数字基数。例如,要从以3为基数进行转换,只需将3作为第二个参数传递给构造函数:
>>>int(“10000”,3.)81
浮动
类在Python中支持浮点数浮动 类型。Python浮点数实现为<一个href="https://en.wikipedia.org/wiki/IEEE_floating_point" class="" target="_blank">IEEE-754双精度浮点数一个>具有53位二进制精度。这相当于十进制中的15到16位有效数字。
任何包含小数点的文字数字都被Python解释为浮动 :
>>>3.1253.125
可以使用科学记数法,因此对于较大的数字,例如<我mg width="55" class="lazyload inline justify-self-center" src="https://learnable-static.s3.amazonaws.com/premium/reeedr/books/the-python-apprentice/images/000029.png" alt="3 \ times10 ^ 8gydF4y2Ba" loading="lazy">,即光速的近似速度(以米每秒为单位),可写成:
>>>3 e8300000000.0
以及像普朗克常数这样的小数值<我mg width="104" class="lazyload inline justify-self-center" src="https://learnable-static.s3.amazonaws.com/premium/reeedr/books/the-python-apprentice/images/000011.png" alt="1.616\times10^{- 35}gydF4y2Ba" loading="lazy">我们可以进入:
>>>1.616 e-351.616 e-35
请注意Python如何自动将显示表示转换为最易读的形式。
类将其他数值或字符串类型转换为浮点数浮动 构造函数。例如,构造函数可以接受int :
>>>浮动(7)7.0
或者字符串:
>>>浮动(“1.618”)1.618
特殊的浮点值
通过将某些字符串传递给浮动 构造函数时,可以创建特殊的浮点值南 (简称N 不一个 NUmber)以及正无穷和负无穷:
>>>浮动(“南”)南>>>浮动(“正”)正>>>浮动(“负”)-正
上市推广
计算结果:涉及的任何计算的结果int 而且浮动 被提升为浮动 :
>>>3.0+14.0
你可以阅读更多关于Python的数字类型<一个href="http://docs.python.org/3/library/stdtypes.html" class="" target="_blank">在Python文档中一个>.
没有一个
Python有一个特殊的空值叫做没有一个 ,用大写的“N”拼写。没有一个 常用于表示值的缺失。Python REPL从不打印没有一个 结果,所以打字没有一个 进入REPL没有效果:
>>>没有一个>>>
没有一个可以像其他对象一样绑定到变量名:
>>>一个=没有一个
我们可以测试一个物体是否没有一个 使用Python的是 接线员:
>>>一个是没有一个真正的
我们可以看到这里的响应是真正的 ,这就很方便地把我们带到了保龄球 类型。
保龄球
的保龄球 type表示逻辑状态,在Python的几个控制流结构中扮演着重要的角色,我们很快就会看到。
正如你所期望的,有两个bool值,真正的 而且假 ,都用首字母大写:
>>>真正的真正的>>>假假
还有一个保龄球 构造函数,可用于从其他类型转换为保龄球 .让我们看看它是如何工作的。为int S, 0被认为是“假的”,所有其他值被认为是“真的”:
>>>保龄球(0)假>>>保龄球(42)真正的>>>保龄球(-1)真正的
我们看到同样的行为浮动 S,其中只有0被认为是“假的”:
>>>保龄球(0.0)假>>>保龄球(0.207)真正的>>>保龄球(-1.117)真正的>>>保龄球(浮动(“南”))真正的
当从集合(如字符串或列表)进行转换时,只有空集合被视为“伪集合”。当从列表进行转换时——我们很快就会看到——我们只看到空列表(这里显示为的字面形式)[] )计算为假 :
>>>保龄球([])假>>>保龄球([1,5,9])真正的
类似地,对于字符串只有空字符串,"" ,计算为假 当传递给保龄球 :
>>>保龄球("")假>>>保龄球(“垃圾邮件”)真正的
特别是,不能使用保龄球 的字符串表示形式进行转换真正的 而且假 :
>>>保龄球(“假”)真正的
由于字符串" False "不是空的,它将求值为真正的 !
这些转换为保龄球 是重要的,因为它们在Python的if语句和while循环中被广泛使用保龄球 值。
关系运算符
布尔值通常由Python的关系操作符产生,可用于比较对象。
使用最广泛的两个关系操作符是Python的相等和不相等测试,它们实际上测试值的等价性或不相等性。也就是说,两个对象是等效 如果一个能代替另一个。我们将在本书后面了解更多关于对象等价的概念。现在,我们将比较简单的整数。
让我们从给变量赋值或绑定值开始g :
>>>g=20.
我们测试平等= = :
>>>g= =20.真正的>>>g= =13假
或者用不等式! = :
>>>g! =20.假>>>g! =13真正的
丰富的比较运算符
我们还可以使用丰富的比较运算符来比较数量的顺序。使用< 确定第一个参数是否小于第二个参数:
>>>g<30.真正的
同样,使用> 判断第一个是否大于第二个:
>>>g>30.假
您可以测试小于或等于< = :
>>>g< =20.真正的
大于或等于> = :
>>>g> =20.真正的
如果您有使用其他语言的关系操作符的经验,那么Python的操作符可能一点也不奇怪。请记住,这些运算符比较的是等价性,而不是恒等性,我们将在接下来的章节中详细讨论这一区别。
控制流:if语句和while循环
现在我们已经研究了一些基本的内置类型,让我们看看两个重要的控制流结构,它们依赖于转换到保龄球 类型:if语句和while循环。
条件控制流:if语句
条件语句允许我们基于表达式的值进行分支执行。陈述的形式是如果 关键字,后跟表达式,以冒号结束以引入新块。让我们在REPL试试这个:
>>>如果真正的:
记住在块内缩进四个空格,我们添加一些代码,如果条件为真正的 ,后面跟着一个空行来终止该块:
...打印(“这是真的!”)...这是真的!
此时块将执行,因为不言而喻的条件是真正的 .相反,如果条件是假 ,块中的代码不会执行:
>>>如果假:...打印(“这是真的!”)...>>>
与if语句一起使用的表达式将转换为a保龄球 就好像布尔值() 构造函数已经被使用,因此:
>>>如果保龄球(“鸡蛋”):...打印(“是的,请!”)...是的,请!
完全等价于:
>>>如果“鸡蛋”:...打印(“是的,请!”)...是的,请!
多亏了这个有用的简写,显式转换为保龄球 使用保龄球 构造函数在Python中很少使用。
如果...其他的
if语句支持可选的“else”子句,该子句位于语句引入的块中其他的 关键字(后跟冒号),缩进到与如果 关键字。让我们先创建(但不是结束)一个if-block:
>>>h=42>>>如果h>50:...打印(“大于50”)
开始其他的 在这种情况下,我们只是省略了三个点后的缩进:
...其他的:...打印(“50或以下”)...50orgydF4y2Ba小
如果...elif...其他的
在多种情况下,你可能会这样做:
>>>如果h>50:...打印(“大于50”)...其他的:...如果h<20.:...打印(“少于20”)...其他的:...打印(“20到50岁之间”)...之间的20.而且50
当你发现自己的else-block中包含嵌套的if语句时,你应该考虑使用Python的if语句elif 关键字,这是一个组合else if .
正如Python的禅宗所提醒我们的,“扁平比嵌套好”:
>>>如果h>50:...打印(“大于50”)...elifh<20.:...打印(“少于20”)...其他的:...打印(“20到50岁之间”)...之间的20.而且50
这个版本更容易阅读。
条件重复:while循环
Python有两种类型的循环:for循环和while循环。在介绍重要的空格时,我们已经简单地遇到过for循环,我们很快就会回到它们,但现在我们将介绍while循环。
类引入了Python中的while循环而 关键字,后面跟着一个布尔表达式。与if-语句的条件一样,表达式隐式转换为布尔值,就好像它已传递给布尔值() 构造函数。的而 语句以冒号结束,因为它引入了一个新的块。
让我们在REPL中写一个从5到1的循环。我们将初始化一个计数器变量c 到5,一直循环直到0。这里的另一个新语言特性是使用了增广赋值运算符,- = ,以便在每次迭代时从计数器的值中减去1。类似的增广赋值运算符也存在于其他基本数学运算中,如加法和乘法:
>>>c=5>>>而c! =0:...打印(c)...c- =1...543.21
因为条件(或谓词)将隐式转换为保龄球 ,就好像一声呼唤布尔值() 构造函数存在时,我们可以用以下版本替换上面的代码:
>>>c=5>>>而c:...打印(c)...c- =1...543.21
这是因为整数值的转换c 来保龄球 结果真正的 直到我们得到0,它转化为假 .也就是说,在这种情况下使用这种简短的形式可能会被描述为非Python的,因为,回顾Python的禅宗,显式比隐式更好。我们更看重第一种形式的可读性,而不是第二种形式的简洁。
而在Python中,循环通常用于需要无限循环的地方。我们通过传递来实现这一点真正的 作为while结构的谓词表达式:
>>>而真正的:...打印(“循环!”)...循环!循环!循环!循环!循环!循环!循环!循环!
现在您可能想知道我们如何摆脱这个循环并重新控制我们的REPL!简单的新闻ctrl - c :
循环!循环!循环!循环!循环!循环!^C回溯(最近一次通话):文件“< stdin >”,行2,在<模块>KeyboardInterrupt>>>
Python拦截键击并引发一个终止循环的特殊异常。我们将在后面的第6章中详细讨论异常是什么,以及如何使用它们。
退出循环
打破
许多编程语言都支持将谓词测试放在循环的末尾而不是开头的循环构造。例如,C、c++、c#和Java都支持do-while结构。其他语言也有repeat-until循环。在Python中不是这样,在Python中习惯用法是使用而真正的 加上提前退出,由打破 声明。
的打破 语句跳出循环(如果嵌套了几个循环,则只跳出最内层的循环),在循环体结束后立即继续执行。
让我们看一个例子打破 ,在此过程中介绍了其他一些Python特性,并逐行检查:
>>>而真正的:...响应=输入()...如果int(响应)%7= =0:...打破...
我们从a开始而真正的: 对于一个无限循环。在while块的第一条语句中,我们使用内置的输入() 函数向用户请求字符串。我们把这个字符串赋值给一个变量响应 .
现在我们使用if语句来测试所提供的值是否能被7整除。方法将响应字符串转换为整数int () 构造函数,然后使用模运算符,% 除以7,得到余数。如果余数等于0,则响应可以被7整除,然后进入If块体。
在if-块中,现在有两层缩进深,我们从八个空格开始,并使用打破 关键字。打破 终止最内部的循环(在本例中为while循环),并使执行跳转到循环后的第一个语句。
在这里,“语句”是程序的结束。我们在三点提示符处输入空行,关闭if-块和while-块。
我们的循环将开始执行,并在调用输入() 等着我们输入数字。让我们试几个:
673428>>>
只要输入一个能被7整除的数,谓词就变成真正的 ,我们进入if-块,然后从字面上跳出循环,直到程序结束,返回到REPL提示符。
总结
- 从Python开始
- 获取并安装Python
- 启动Read-Eval-Print-Loop或REPL
- 简单的算术
- 通过将对象绑定到名称来创建变量
- 内置打印
print () 函数
- 退出REPL
ctrl - z (Windows)或ctrl - d (Unix)
被预言的
明显的压痕
PEP 8 - Python代码的风格指南
PEP 20 - Python的禅
使用import语句以各种形式导入模块
查找和浏览帮助()
基本类型和控制流
int年代,浮动 年代,没有一个 ,保龄球 ,加上它们之间的转换
用于相等性和排序测试的关系运算符
if指令与其他的 而且elif 块
带有隐式转换的while循环保龄球
中断无限循环ctrl - c
打破循环与打破
从用户请求文本输入()
增广赋值运算符
预览结束
注册解锁剩余的标题。一个>
社区问题
关闭
现在Python已经安装并运行,您可以立即开始使用它。这是了解语言的好方法,也是在正常开发过程中进行实验和快速测试的有用工具。
这个Python命令行环境是一个
当启动时,REPL将打印一些关于正在运行的Python版本的信息,然后它将给您一个三重箭头提示。这个提示符告诉您Python正在等待您输入一些内容。
在交互式Python会话中,您可以输入Python程序片段并看到即时结果。让我们从一些简单的算术开始:
>>>2+24>>>6*742
正如你所看到的,Python读取我们的输入,求值,打印结果,然后循环执行同样的操作。
我们可以在REPL中为变量赋值:
>>>x=5
通过输入它们的名称打印它们的内容:
>>>x5
并在表达式中引用它们:
>>>3.*x15
在REPL中,你可以使用特殊的下划线变量来引用最近打印的值,这是Python中为数不多的晦涩快捷方式之一:
>>>_15
或者你可以在表达式中使用特殊的下划线变量:
>>>_*230.
请注意
注意,并非所有语句都有返回值。当我们把5赋值给
试一试:
>>>打印(“你好,Python”)你好,Python
您将看到Python立即计算并执行此命令,打印字符串“Hello, Python”并返回到另一个提示符。重要的是要理解这里的响应不是REPL计算和显示的表达式的结果,而是方法的副作用
顺便说一句,
打印 是Python 2和Python 3之间最大的区别之一。在python3中,圆括号是必需的,而在python2中则不是。这是因为在Python 3中,print () 是函数调用。稍后将详细介绍函数。
离开REPL
此时,我们应该向您展示如何退出REPL并返回系统shell提示符。我们通过发送文件尾 控制字符,但不幸的是,发送该字符的方法因平台而异。
窗户
如果你在Windows上,按ctrl - z 退出。
Unix
如果你用的是Mac或Linux,按一下ctrl - d 退出。
如果你经常在平台之间切换,不小心按下了ctrl - z 在类似unix的系统上,您会无意中挂起Python解释器并返回到操作系统shell。要通过使Python再次成为前台进程来重新激活它,请运行成品 命令:
fg美元
并按输入 并多次返回Python的三重箭头提示符:
>>>
代码结构和重要缩进
启动Python 3解释器:
>python
在Windows或:
python3美元
在Mac或Linux上。
Python的控制流结构,如for-loops、while-loops和if-statements,都是由以冒号结束的语句引入的,这表明后面是构造体。例如,For循环需要一个正文,所以如果你输入:
>>>为我在范围(5):...
Python将向您显示由三个点组成的提示符,要求您提供正文。
Python的一个独特(有时是有争议的)方面是前导空格在语法上很重要。这意味着Python使用缩进级别,而不是其他语言使用的大括号来划分代码块。按照惯例,现代Python代码每层缩进四个空格。
因此,当Python给出三个点提示符时,我们提供了这四个空格和一条语句来形成循环体:
...x=我*10
循环体将包含第二个语句,因此在按下返回 在下一个三点提示符中,我们将输入另外四个空格,然后调用内置的print () 功能:
...打印(x)
为了终止我们的块,我们必须在REPL中输入一个空行:
...
代码块完成后,Python执行挂起的代码,打印出小于50的10的倍数:
01020.30.40
看一屏Python代码,我们可以清楚地看到缩进是如何匹配的——事实上必须 匹配-程序的结构。
Python源代码
即使我们用灰线替换代码,程序的结构也是清晰的。
灰色代码
以冒号结束的每个语句开始一个新行,并引入一个额外的缩进级别,直到缩进将缩进恢复到以前的级别。每一层缩进通常是四个空格,不过我们稍后将更详细地讨论这些规则。
Python处理重要空白的方法有三个很大的优点:
- 它迫使开发人员在代码块中使用单一级别的缩进。在任何语言中,这通常都被认为是很好的实践,因为它使代码更具可读性。
- 有重要空格的代码不需要用不必要的大括号来混淆,而且您永远不需要对大括号应该放在哪里进行代码标准的争论。Python代码中的所有代码块都很容易识别,并且每个人都以相同的方式编写它们。
- 重要的空白要求作者、Python运行时系统和未来需要阅读代码的维护者必须对代码结构给出一致的解释。因此,从Python的角度来看,你永远不会有包含块的代码,但从粗略的人类角度来看,它看起来不像包含块。
Python缩进的规则看起来很复杂,但在实践中非常简单。
- 您使用的空白可以是空格或制表符。普遍的共识是
空格比制表符更可取 ,四个空格已经成为Python社区的标准 .
- 一个基本规则是
从来没有 混合空格和制表符。Python解释器会抱怨,你的同事会找你麻烦。
- 如果您愿意,您可以在不同的时间使用不同数量的缩进。基本规则是
相同缩进级别的连续代码行被认为是同一代码块的一部分 .
- 这些规则也有一些例外,但它们几乎总是与以其他方式提高代码可读性有关,例如将必要的长语句拆分为多行。
这种严格的代码格式化方法是“按照Guido的意愿编程”,或者更恰当地说,“按照Guido的意愿编程”缩进 它”!高度重视代码质量(如可读性)的哲学是Python文化的核心,现在我们将稍事休息来探索一下。
Python文化
许多编程语言处于文化运动的中心。它们有自己的社区、价值观、实践和哲学,Python也不例外。Python语言本身的开发是通过一系列名为Python增强建议 ,或锐气 .其中一个PEP叫做PEP 8,它解释了应该如何格式化代码,我们在本书中遵循它的指导方针。例如,PEP 8建议我们在新的Python代码中使用四个空格作为缩进。
这些PEP中的另一个,叫做PEP 20,被称为“Python的禅宗”。它引用了20条描述Python指导原则的格言,其中只有19条被记录下来。方便的是,Python的Zen永远不会比最近的Python解释器更远,因为它总是可以通过输入以下命令从REPL访问:
>>>进口这Python的禅宗,蒂姆·彼得斯美丽的是比丑陋好.显式的是比含蓄要好.简单的是比复杂的.复杂的是好于复杂.平是比嵌套更好.稀疏的是比密集要好.可读性计数.特殊情况并不特别到打破规则.尽管实用性胜过纯洁性.永远不要犯错误通过默默地.除非明确保持沉默.面对模棱两可,不要去猜测.应该有一个--而且最好只有一个--很明显的方法.尽管那样可能不除非你是荷兰人.现在是聊胜于无.虽然从来没有是通常比*正确的*现在.如果实现是很难解释,这是个坏主意.如果实现是很容易解释,这可能是个好主意.命名空间是一个非常棒的想法--让我们多做一些吧!
在这本书中,我们将强调来自Python禅宗的智慧禅的时刻 理解它们如何应用于我们所学的知识。因为我们刚刚介绍了Python重要缩进,所以现在是时候开始第一个缩进了禅宗时刻 .
随着时间的推移,您将逐渐欣赏Python中重要的空白所带来的优雅你的 代码,以及阅读的便利性其他的 .
导入标准库模块
如前所述,Python附带了一个广泛的标准库,Python的一个方面通常被称为“包含电池”。标准库的结构为模块 ,我们稍后将深入讨论这个话题。在此阶段,重要的是要知道您可以通过使用进口 关键字。
导入模块的基本形式是进口 关键字,后跟空格和模块名称。例如,让我们看看如何使用标准库数学 模块来计算平方根。在三箭头提示符下,我们输入:
>>>进口数学
自进口 是一个不返回值的语句,如果导入成功,Python不会打印任何内容,我们立即返回到提示符。我们可以通过以下方式访问导入模块的内容:模块名,后跟一个点,再后跟模块中所需的属性名。像许多面向对象的语言一样,点运算符用于向下钻取对象结构。作为Pythonistas的专家,我们知道数学 模块包含一个名为sqrt () .让我们试着使用它:
>>>数学.√6(81)9.0
得到
帮助()
但是,我们如何才能找到在数学 模块?
REPL有一个特殊的功能帮助() 它可以从提供文档的对象(如标准库模块)中检索任何嵌入式文档。
要获得帮助,请在提示符处输入“help”:
>>>帮助类型帮助()为互动帮助,orgydF4y2Ba帮助(对象)为帮助关于对象.
我们将让您在自己的时间探索第一种形式-交互式帮助。这里我们选择第二个选项,通过数学 模块作为我们需要帮助的对象:
>>>帮助(数学)模块数学方面的帮助:的名字数学模块引用http://文档.python.org/3.3/图书馆/数学以下文档是自动生成的从Python源文件.可能是不完整的,不正确的orgydF4y2Ba包括以下特性被认为是实现细节而且可能在Python之间有所不同实现.当在怀疑,的模块参考上面列出的地点.描述这个模块是总是可用的.对象的访问由C标准定义的数学函数.功能这些“可信赖医疗组织”(...)这些“可信赖医疗组织”(x)返回arccos(测量在弧度)(x).
你可以使用空格键来翻页帮助,如果你在Mac或Linux上使用方向键来上下滚动。
浏览这些函数,你会看到有一个数学函数,的阶乘 ,用于计算阶乘。按“q”退出帮助浏览器,并返回到Python REPL。
现在练习使用帮助() 请求特定的帮助的阶乘 功能:
>>>帮助(数学.的阶乘)建立帮助-在功能!在模块的数学:的阶乘(...)的阶乘(x)->积分找到x !.引发ValueError如果x是负orgydF4y2Ba非-积分.
按' q '返回REPL。
让我们使用阶乘() 一点。该函数接受一个整型参数并返回一个整型值:
>>>数学.的阶乘(5)120>>>数学.的阶乘(6)720
注意我们需要如何用模块名称空间限定函数名。这通常是很好的实践,因为它使函数的来源非常清楚。也就是说,它可能导致代码过于冗长。
数水果
数学.的阶乘()
让我们用阶乘来计算从5个水果中抽取3个水果的方法有多少种,使用我们在学校学过的数学:
>>>n=5>>>k=3.>>>数学.的阶乘(n)/(数学.的阶乘(k)*数学.的阶乘(n-k))10.0
这个简单的表达式包含了对数学模块的所有引用,非常冗长。Python进口 语句具有另一种形式,该形式允许我们使用从 关键字:
>>>从数学进口的阶乘>>>的阶乘(n)/(的阶乘(k)*的阶乘(n-k))10.0
这是一个很好的改进,但是对于这样一个简单的表达式来说还是有点啰嗦。
import语句的第三种形式允许我们重命名导入的函数。这对于可读性或避免名称空间冲突很有用。虽然它很有用,但是我们建议不要经常使用这个功能,并且要明智地使用:
>>>从数学进口的阶乘作为前沿空中管制官>>>前沿空中管制官(n)/(前沿空中管制官(k)*前沿空中管制官(n-k))10.0
不同类型的数字
记住,当我们用阶乘() 单独返回一个整数。但是我们上面用来计算组合的更复杂的表达式是产生一个浮点数。这是因为我们用过/ , Python的浮点除法运算符。因为我们知道我们的运算只会返回积分结果,我们可以通过使用改进表达式// , Python的整数除法运算符:
>>>从数学进口的阶乘作为前沿空中管制官>>>前沿空中管制官(n)//(前沿空中管制官(k)*前沿空中管制官(n-k))10
值得注意的是,许多其他编程语言即使是中等值的n .在大多数编程语言中,普通的有符号整数只能存储小于的值<我mg width="20" class="lazyload inline justify-self-center" src="https://learnable-static.s3.amazonaws.com/premium/reeedr/books/the-python-apprentice/images/000056.png" alt="2 ^ {31}gydF4y2Ba" loading="lazy">:
>>>2**31-12147483647
然而,阶乘增长得如此之快,以至于您可以放入32位有符号整数的最大阶乘是12!因为13 !太大:
>>>前沿空中管制官(13)6227020800
在大多数广泛使用的编程语言中,你要么需要更复杂的代码,要么需要更复杂的数学,仅仅是计算从13个水果中抽出3个水果的方法有多少种。
Python不会遇到这样的问题,它可以计算任意大的整数,只受计算机内存的限制。为了进一步证明这一点,让我们尝试一个更大的问题,计算我们可以从100种不同的水果中挑选多少对不同的水果(假设我们可以找到这么多水果!):
>>>n=One hundred.>>>k=2>>>前沿空中管制官(n)//(前沿空中管制官(k)*前沿空中管制官(n-k))4950
只是为了强调这个表达式的第一项有多大,计算100!就其本身而言:
>>>前沿空中管制官(n)93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463\976156518286253697920827223758251185210916864000000000000000000000000
这个数字甚至比已知宇宙中的原子数量还要大得多,有很多数字。如果你像我们一样好奇到底有多少位数字,我们可以将整数转换为文本字符串,并像这样计算其中的字符数:
>>>len(str(前沿空中管制官(n)))158
这肯定有很多数字。还有很多水果。它还开始展示Python的不同数据类型(在本例中是整数、浮点数和文本字符串)如何以自然的方式协同工作。在下一节中,我们将以这一经验为基础,更详细地讨论整数、字符串和其他内置类型。
标量数据类型:整数、浮点数、None和bool
Python自带许多内置数据类型。这些类型包括像整数这样的基本标量类型以及像字典这样的集合类型。这些内置类型功能强大,可以单独用于许多编程需求,并且可以用作创建更复杂数据类型的构建块。
我们将讨论的基本内置标量类型有:
int-带符号的、无限精度的整数
浮动- IEEE 754浮点数
没有一个-一个特殊的、奇异的空值
保龄球- true/false布尔值
现在我们只看它们的基本细节,展示它们的文字形式以及如何创建它们。
int
我们已经见过很多Python整数的应用。Python整数是有符号的,并且在实际应用中具有无限的精度。这意味着它们所能保存的值的大小没有预先定义的限制。
Python中的整数字面量通常以十进制指定:
>>>1010
它们也可以用二进制文件指定0 b 前缀:
>>>b10 02
八进制,带a0啊 前缀:
>>>0 o108
或者带a的十六进制0 x 前缀:
>>>0 x1016
方法也可以构造整数int 构造函数,可以将其他数值类型(如浮点数)转换为整数:
>>>int(3.5)3.
注意,当使用int 构造函数时,舍入总是趋于零:
>>>int(-3.5)-3.>>>int(3.5)3.
我们还可以将字符串转换为整数:
>>>int(“496”)496
但是请注意,如果字符串不表示整数,Python将抛出异常(后面会详细介绍!)。
在从字符串转换时,甚至可以提供一个可选的数字基数。例如,要从以3为基数进行转换,只需将3作为第二个参数传递给构造函数:
>>>int(“10000”,3.)81
浮动
类在Python中支持浮点数浮动 类型。Python浮点数实现为<一个href="https://en.wikipedia.org/wiki/IEEE_floating_point" class="" target="_blank">IEEE-754双精度浮点数一个>具有53位二进制精度。这相当于十进制中的15到16位有效数字。
任何包含小数点的文字数字都被Python解释为浮动 :
>>>3.1253.125
可以使用科学记数法,因此对于较大的数字,例如<我mg width="55" class="lazyload inline justify-self-center" src="https://learnable-static.s3.amazonaws.com/premium/reeedr/books/the-python-apprentice/images/000029.png" alt="3 \ times10 ^ 8gydF4y2Ba" loading="lazy">,即光速的近似速度(以米每秒为单位),可写成:
>>>3 e8300000000.0
以及像普朗克常数这样的小数值<我mg width="104" class="lazyload inline justify-self-center" src="https://learnable-static.s3.amazonaws.com/premium/reeedr/books/the-python-apprentice/images/000011.png" alt="1.616\times10^{- 35}gydF4y2Ba" loading="lazy">我们可以进入:
>>>1.616 e-351.616 e-35
请注意Python如何自动将显示表示转换为最易读的形式。
类将其他数值或字符串类型转换为浮点数浮动 构造函数。例如,构造函数可以接受int :
>>>浮动(7)7.0
或者字符串:
>>>浮动(“1.618”)1.618
特殊的浮点值
通过将某些字符串传递给浮动 构造函数时,可以创建特殊的浮点值南 (简称N 不一个 NUmber)以及正无穷和负无穷:
>>>浮动(“南”)南>>>浮动(“正”)正>>>浮动(“负”)-正
上市推广
计算结果:涉及的任何计算的结果int 而且浮动 被提升为浮动 :
>>>3.0+14.0
你可以阅读更多关于Python的数字类型<一个href="http://docs.python.org/3/library/stdtypes.html" class="" target="_blank">在Python文档中一个>.
没有一个
Python有一个特殊的空值叫做没有一个 ,用大写的“N”拼写。没有一个 常用于表示值的缺失。Python REPL从不打印没有一个 结果,所以打字没有一个 进入REPL没有效果:
>>>没有一个>>>
没有一个可以像其他对象一样绑定到变量名:
>>>一个=没有一个
我们可以测试一个物体是否没有一个 使用Python的是 接线员:
>>>一个是没有一个真正的
我们可以看到这里的响应是真正的 ,这就很方便地把我们带到了保龄球 类型。
保龄球
的保龄球 type表示逻辑状态,在Python的几个控制流结构中扮演着重要的角色,我们很快就会看到。
正如你所期望的,有两个bool值,真正的 而且假 ,都用首字母大写:
>>>真正的真正的>>>假假
还有一个保龄球 构造函数,可用于从其他类型转换为保龄球 .让我们看看它是如何工作的。为int S, 0被认为是“假的”,所有其他值被认为是“真的”:
>>>保龄球(0)假>>>保龄球(42)真正的>>>保龄球(-1)真正的
我们看到同样的行为浮动 S,其中只有0被认为是“假的”:
>>>保龄球(0.0)假>>>保龄球(0.207)真正的>>>保龄球(-1.117)真正的>>>保龄球(浮动(“南”))真正的
当从集合(如字符串或列表)进行转换时,只有空集合被视为“伪集合”。当从列表进行转换时——我们很快就会看到——我们只看到空列表(这里显示为的字面形式)[] )计算为假 :
>>>保龄球([])假>>>保龄球([1,5,9])真正的
类似地,对于字符串只有空字符串,"" ,计算为假 当传递给保龄球 :
>>>保龄球("")假>>>保龄球(“垃圾邮件”)真正的
特别是,不能使用保龄球 的字符串表示形式进行转换真正的 而且假 :
>>>保龄球(“假”)真正的
由于字符串" False "不是空的,它将求值为真正的 !
这些转换为保龄球 是重要的,因为它们在Python的if语句和while循环中被广泛使用保龄球 值。
关系运算符
布尔值通常由Python的关系操作符产生,可用于比较对象。
使用最广泛的两个关系操作符是Python的相等和不相等测试,它们实际上测试值的等价性或不相等性。也就是说,两个对象是等效 如果一个能代替另一个。我们将在本书后面了解更多关于对象等价的概念。现在,我们将比较简单的整数。
让我们从给变量赋值或绑定值开始g :
>>>g=20.
我们测试平等= = :
>>>g= =20.真正的>>>g= =13假
或者用不等式! = :
>>>g! =20.假>>>g! =13真正的
丰富的比较运算符
我们还可以使用丰富的比较运算符来比较数量的顺序。使用< 确定第一个参数是否小于第二个参数:
>>>g<30.真正的
同样,使用> 判断第一个是否大于第二个:
>>>g>30.假
您可以测试小于或等于< = :
>>>g< =20.真正的
大于或等于> = :
>>>g> =20.真正的
如果您有使用其他语言的关系操作符的经验,那么Python的操作符可能一点也不奇怪。请记住,这些运算符比较的是等价性,而不是恒等性,我们将在接下来的章节中详细讨论这一区别。
控制流:if语句和while循环
现在我们已经研究了一些基本的内置类型,让我们看看两个重要的控制流结构,它们依赖于转换到保龄球 类型:if语句和while循环。
条件控制流:if语句
条件语句允许我们基于表达式的值进行分支执行。陈述的形式是如果 关键字,后跟表达式,以冒号结束以引入新块。让我们在REPL试试这个:
>>>如果真正的:
记住在块内缩进四个空格,我们添加一些代码,如果条件为真正的 ,后面跟着一个空行来终止该块:
...打印(“这是真的!”)...这是真的!
此时块将执行,因为不言而喻的条件是真正的 .相反,如果条件是假 ,块中的代码不会执行:
>>>如果假:...打印(“这是真的!”)...>>>
与if语句一起使用的表达式将转换为a保龄球 就好像布尔值() 构造函数已经被使用,因此:
>>>如果保龄球(“鸡蛋”):...打印(“是的,请!”)...是的,请!
完全等价于:
>>>如果“鸡蛋”:...打印(“是的,请!”)...是的,请!
多亏了这个有用的简写,显式转换为保龄球 使用保龄球 构造函数在Python中很少使用。
如果...其他的
if语句支持可选的“else”子句,该子句位于语句引入的块中其他的 关键字(后跟冒号),缩进到与如果 关键字。让我们先创建(但不是结束)一个if-block:
>>>h=42>>>如果h>50:...打印(“大于50”)
开始其他的 在这种情况下,我们只是省略了三个点后的缩进:
...其他的:...打印(“50或以下”)...50orgydF4y2Ba小
如果...elif...其他的
在多种情况下,你可能会这样做:
>>>如果h>50:...打印(“大于50”)...其他的:...如果h<20.:...打印(“少于20”)...其他的:...打印(“20到50岁之间”)...之间的20.而且50
当你发现自己的else-block中包含嵌套的if语句时,你应该考虑使用Python的if语句elif 关键字,这是一个组合else if .
正如Python的禅宗所提醒我们的,“扁平比嵌套好”:
>>>如果h>50:...打印(“大于50”)...elifh<20.:...打印(“少于20”)...其他的:...打印(“20到50岁之间”)...之间的20.而且50
这个版本更容易阅读。
条件重复:while循环
Python有两种类型的循环:for循环和while循环。在介绍重要的空格时,我们已经简单地遇到过for循环,我们很快就会回到它们,但现在我们将介绍while循环。
类引入了Python中的while循环而 关键字,后面跟着一个布尔表达式。与if-语句的条件一样,表达式隐式转换为布尔值,就好像它已传递给布尔值() 构造函数。的而 语句以冒号结束,因为它引入了一个新的块。
让我们在REPL中写一个从5到1的循环。我们将初始化一个计数器变量c 到5,一直循环直到0。这里的另一个新语言特性是使用了增广赋值运算符,- = ,以便在每次迭代时从计数器的值中减去1。类似的增广赋值运算符也存在于其他基本数学运算中,如加法和乘法:
>>>c=5>>>而c! =0:...打印(c)...c- =1...543.21
因为条件(或谓词)将隐式转换为保龄球 ,就好像一声呼唤布尔值() 构造函数存在时,我们可以用以下版本替换上面的代码:
>>>c=5>>>而c:...打印(c)...c- =1...543.21
这是因为整数值的转换c 来保龄球 结果真正的 直到我们得到0,它转化为假 .也就是说,在这种情况下使用这种简短的形式可能会被描述为非Python的,因为,回顾Python的禅宗,显式比隐式更好。我们更看重第一种形式的可读性,而不是第二种形式的简洁。
而在Python中,循环通常用于需要无限循环的地方。我们通过传递来实现这一点真正的 作为while结构的谓词表达式:
>>>而真正的:...打印(“循环!”)...循环!循环!循环!循环!循环!循环!循环!循环!
现在您可能想知道我们如何摆脱这个循环并重新控制我们的REPL!简单的新闻ctrl - c :
循环!循环!循环!循环!循环!循环!^C回溯(最近一次通话):文件“< stdin >”,行2,在<模块>KeyboardInterrupt>>>
Python拦截键击并引发一个终止循环的特殊异常。我们将在后面的第6章中详细讨论异常是什么,以及如何使用它们。
退出循环
打破
许多编程语言都支持将谓词测试放在循环的末尾而不是开头的循环构造。例如,C、c++、c#和Java都支持do-while结构。其他语言也有repeat-until循环。在Python中不是这样,在Python中习惯用法是使用而真正的 加上提前退出,由打破 声明。
的打破 语句跳出循环(如果嵌套了几个循环,则只跳出最内层的循环),在循环体结束后立即继续执行。
让我们看一个例子打破 ,在此过程中介绍了其他一些Python特性,并逐行检查:
>>>而真正的:...响应=输入()...如果int(响应)%7= =0:...打破...
我们从a开始而真正的: 对于一个无限循环。在while块的第一条语句中,我们使用内置的输入() 函数向用户请求字符串。我们把这个字符串赋值给一个变量响应 .
现在我们使用if语句来测试所提供的值是否能被7整除。方法将响应字符串转换为整数int () 构造函数,然后使用模运算符,% 除以7,得到余数。如果余数等于0,则响应可以被7整除,然后进入If块体。
在if-块中,现在有两层缩进深,我们从八个空格开始,并使用打破 关键字。打破 终止最内部的循环(在本例中为while循环),并使执行跳转到循环后的第一个语句。
在这里,“语句”是程序的结束。我们在三点提示符处输入空行,关闭if-块和while-块。
我们的循环将开始执行,并在调用输入() 等着我们输入数字。让我们试几个:
673428>>>
只要输入一个能被7整除的数,谓词就变成真正的 ,我们进入if-块,然后从字面上跳出循环,直到程序结束,返回到REPL提示符。
总结
- 从Python开始
- 获取并安装Python
- 启动Read-Eval-Print-Loop或REPL
- 简单的算术
- 通过将对象绑定到名称来创建变量
- 内置打印
print () 函数
- 退出REPL
ctrl - z (Windows)或ctrl - d (Unix)
被预言的
明显的压痕
PEP 8 - Python代码的风格指南
PEP 20 - Python的禅
使用import语句以各种形式导入模块
查找和浏览帮助()
基本类型和控制流
int年代,浮动 年代,没有一个 ,保龄球 ,加上它们之间的转换
用于相等性和排序测试的关系运算符
if指令与其他的 而且elif 块
带有隐式转换的while循环保龄球
中断无限循环ctrl - c
打破循环与打破
从用户请求文本输入()
增广赋值运算符
预览结束
注册解锁剩余的标题。一个>
社区问题
关闭
此时,我们应该向您展示如何退出REPL并返回系统shell提示符。我们通过发送
窗户
如果你在Windows上,按
Unix
如果你用的是Mac或Linux,按一下
如果你经常在平台之间切换,不小心按下了
fg美元
并按
>>>
代码结构和重要缩进
启动Python 3解释器:
>python
在Windows或:
python3美元
在Mac或Linux上。
Python的控制流结构,如for-loops、while-loops和if-statements,都是由以冒号结束的语句引入的,这表明后面是构造体。例如,For循环需要一个正文,所以如果你输入:
>>>为我在范围(5):...
Python将向您显示由三个点组成的提示符,要求您提供正文。
Python的一个独特(有时是有争议的)方面是前导空格在语法上很重要。这意味着Python使用缩进级别,而不是其他语言使用的大括号来划分代码块。按照惯例,现代Python代码每层缩进四个空格。
因此,当Python给出三个点提示符时,我们提供了这四个空格和一条语句来形成循环体:
...x=我*10
循环体将包含第二个语句,因此在按下返回 在下一个三点提示符中,我们将输入另外四个空格,然后调用内置的print () 功能:
...打印(x)
为了终止我们的块,我们必须在REPL中输入一个空行:
...
代码块完成后,Python执行挂起的代码,打印出小于50的10的倍数:
01020.30.40
看一屏Python代码,我们可以清楚地看到缩进是如何匹配的——事实上必须 匹配-程序的结构。
Python源代码
即使我们用灰线替换代码,程序的结构也是清晰的。
灰色代码
以冒号结束的每个语句开始一个新行,并引入一个额外的缩进级别,直到缩进将缩进恢复到以前的级别。每一层缩进通常是四个空格,不过我们稍后将更详细地讨论这些规则。
Python处理重要空白的方法有三个很大的优点:
- 它迫使开发人员在代码块中使用单一级别的缩进。在任何语言中,这通常都被认为是很好的实践,因为它使代码更具可读性。
- 有重要空格的代码不需要用不必要的大括号来混淆,而且您永远不需要对大括号应该放在哪里进行代码标准的争论。Python代码中的所有代码块都很容易识别,并且每个人都以相同的方式编写它们。
- 重要的空白要求作者、Python运行时系统和未来需要阅读代码的维护者必须对代码结构给出一致的解释。因此,从Python的角度来看,你永远不会有包含块的代码,但从粗略的人类角度来看,它看起来不像包含块。
Python缩进的规则看起来很复杂,但在实践中非常简单。
- 您使用的空白可以是空格或制表符。普遍的共识是
空格比制表符更可取 ,四个空格已经成为Python社区的标准 .
- 一个基本规则是
从来没有 混合空格和制表符。Python解释器会抱怨,你的同事会找你麻烦。
- 如果您愿意,您可以在不同的时间使用不同数量的缩进。基本规则是
相同缩进级别的连续代码行被认为是同一代码块的一部分 .
- 这些规则也有一些例外,但它们几乎总是与以其他方式提高代码可读性有关,例如将必要的长语句拆分为多行。
这种严格的代码格式化方法是“按照Guido的意愿编程”,或者更恰当地说,“按照Guido的意愿编程”缩进 它”!高度重视代码质量(如可读性)的哲学是Python文化的核心,现在我们将稍事休息来探索一下。
Python文化
许多编程语言处于文化运动的中心。它们有自己的社区、价值观、实践和哲学,Python也不例外。Python语言本身的开发是通过一系列名为Python增强建议 ,或锐气 .其中一个PEP叫做PEP 8,它解释了应该如何格式化代码,我们在本书中遵循它的指导方针。例如,PEP 8建议我们在新的Python代码中使用四个空格作为缩进。
这些PEP中的另一个,叫做PEP 20,被称为“Python的禅宗”。它引用了20条描述Python指导原则的格言,其中只有19条被记录下来。方便的是,Python的Zen永远不会比最近的Python解释器更远,因为它总是可以通过输入以下命令从REPL访问:
>>>进口这Python的禅宗,蒂姆·彼得斯美丽的是比丑陋好.显式的是比含蓄要好.简单的是比复杂的.复杂的是好于复杂.平是比嵌套更好.稀疏的是比密集要好.可读性计数.特殊情况并不特别到打破规则.尽管实用性胜过纯洁性.永远不要犯错误通过默默地.除非明确保持沉默.面对模棱两可,不要去猜测.应该有一个--而且最好只有一个--很明显的方法.尽管那样可能不除非你是荷兰人.现在是聊胜于无.虽然从来没有是通常比*正确的*现在.如果实现是很难解释,这是个坏主意.如果实现是很容易解释,这可能是个好主意.命名空间是一个非常棒的想法--让我们多做一些吧!
在这本书中,我们将强调来自Python禅宗的智慧禅的时刻 理解它们如何应用于我们所学的知识。因为我们刚刚介绍了Python重要缩进,所以现在是时候开始第一个缩进了禅宗时刻 .
随着时间的推移,您将逐渐欣赏Python中重要的空白所带来的优雅你的 代码,以及阅读的便利性其他的 .
导入标准库模块
如前所述,Python附带了一个广泛的标准库,Python的一个方面通常被称为“包含电池”。标准库的结构为模块 ,我们稍后将深入讨论这个话题。在此阶段,重要的是要知道您可以通过使用进口 关键字。
导入模块的基本形式是进口 关键字,后跟空格和模块名称。例如,让我们看看如何使用标准库数学 模块来计算平方根。在三箭头提示符下,我们输入:
>>>进口数学
自进口 是一个不返回值的语句,如果导入成功,Python不会打印任何内容,我们立即返回到提示符。我们可以通过以下方式访问导入模块的内容:模块名,后跟一个点,再后跟模块中所需的属性名。像许多面向对象的语言一样,点运算符用于向下钻取对象结构。作为Pythonistas的专家,我们知道数学 模块包含一个名为sqrt () .让我们试着使用它:
>>>数学.√6(81)9.0
得到
帮助()
但是,我们如何才能找到在数学 模块?
REPL有一个特殊的功能帮助() 它可以从提供文档的对象(如标准库模块)中检索任何嵌入式文档。
要获得帮助,请在提示符处输入“help”:
>>>帮助类型帮助()为互动帮助,orgydF4y2Ba帮助(对象)为帮助关于对象.
我们将让您在自己的时间探索第一种形式-交互式帮助。这里我们选择第二个选项,通过数学 模块作为我们需要帮助的对象:
>>>帮助(数学)模块数学方面的帮助:的名字数学模块引用http://文档.python.org/3.3/图书馆/数学以下文档是自动生成的从Python源文件.可能是不完整的,不正确的orgydF4y2Ba包括以下特性被认为是实现细节而且可能在Python之间有所不同实现.当在怀疑,的模块参考上面列出的地点.描述这个模块是总是可用的.对象的访问由C标准定义的数学函数.功能这些“可信赖医疗组织”(...)这些“可信赖医疗组织”(x)返回arccos(测量在弧度)(x).
你可以使用空格键来翻页帮助,如果你在Mac或Linux上使用方向键来上下滚动。
浏览这些函数,你会看到有一个数学函数,的阶乘 ,用于计算阶乘。按“q”退出帮助浏览器,并返回到Python REPL。
现在练习使用帮助() 请求特定的帮助的阶乘 功能:
>>>帮助(数学.的阶乘)建立帮助-在功能!在模块的数学:的阶乘(...)的阶乘(x)->积分找到x !.引发ValueError如果x是负orgydF4y2Ba非-积分.
按' q '返回REPL。
让我们使用阶乘() 一点。该函数接受一个整型参数并返回一个整型值:
>>>数学.的阶乘(5)120>>>数学.的阶乘(6)720
注意我们需要如何用模块名称空间限定函数名。这通常是很好的实践,因为它使函数的来源非常清楚。也就是说,它可能导致代码过于冗长。
数水果
数学.的阶乘()
让我们用阶乘来计算从5个水果中抽取3个水果的方法有多少种,使用我们在学校学过的数学:
>>>n=5>>>k=3.>>>数学.的阶乘(n)/(数学.的阶乘(k)*数学.的阶乘(n-k))10.0
这个简单的表达式包含了对数学模块的所有引用,非常冗长。Python进口 语句具有另一种形式,该形式允许我们使用从 关键字:
>>>从数学进口的阶乘>>>的阶乘(n)/(的阶乘(k)*的阶乘(n-k))10.0
这是一个很好的改进,但是对于这样一个简单的表达式来说还是有点啰嗦。
import语句的第三种形式允许我们重命名导入的函数。这对于可读性或避免名称空间冲突很有用。虽然它很有用,但是我们建议不要经常使用这个功能,并且要明智地使用:
>>>从数学进口的阶乘作为前沿空中管制官>>>前沿空中管制官(n)/(前沿空中管制官(k)*前沿空中管制官(n-k))10.0
不同类型的数字
记住,当我们用阶乘() 单独返回一个整数。但是我们上面用来计算组合的更复杂的表达式是产生一个浮点数。这是因为我们用过/ , Python的浮点除法运算符。因为我们知道我们的运算只会返回积分结果,我们可以通过使用改进表达式// , Python的整数除法运算符:
>>>从数学进口的阶乘作为前沿空中管制官>>>前沿空中管制官(n)//(前沿空中管制官(k)*前沿空中管制官(n-k))10
值得注意的是,许多其他编程语言即使是中等值的n .在大多数编程语言中,普通的有符号整数只能存储小于的值<我mg width="20" class="lazyload inline justify-self-center" src="https://learnable-static.s3.amazonaws.com/premium/reeedr/books/the-python-apprentice/images/000056.png" alt="2 ^ {31}gydF4y2Ba" loading="lazy">:
>>>2**31-12147483647
然而,阶乘增长得如此之快,以至于您可以放入32位有符号整数的最大阶乘是12!因为13 !太大:
>>>前沿空中管制官(13)6227020800
在大多数广泛使用的编程语言中,你要么需要更复杂的代码,要么需要更复杂的数学,仅仅是计算从13个水果中抽出3个水果的方法有多少种。
Python不会遇到这样的问题,它可以计算任意大的整数,只受计算机内存的限制。为了进一步证明这一点,让我们尝试一个更大的问题,计算我们可以从100种不同的水果中挑选多少对不同的水果(假设我们可以找到这么多水果!):
>>>n=One hundred.>>>k=2>>>前沿空中管制官(n)//(前沿空中管制官(k)*前沿空中管制官(n-k))4950
只是为了强调这个表达式的第一项有多大,计算100!就其本身而言:
>>>前沿空中管制官(n)93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463\976156518286253697920827223758251185210916864000000000000000000000000
这个数字甚至比已知宇宙中的原子数量还要大得多,有很多数字。如果你像我们一样好奇到底有多少位数字,我们可以将整数转换为文本字符串,并像这样计算其中的字符数:
>>>len(str(前沿空中管制官(n)))158
这肯定有很多数字。还有很多水果。它还开始展示Python的不同数据类型(在本例中是整数、浮点数和文本字符串)如何以自然的方式协同工作。在下一节中,我们将以这一经验为基础,更详细地讨论整数、字符串和其他内置类型。
标量数据类型:整数、浮点数、None和bool
Python自带许多内置数据类型。这些类型包括像整数这样的基本标量类型以及像字典这样的集合类型。这些内置类型功能强大,可以单独用于许多编程需求,并且可以用作创建更复杂数据类型的构建块。
我们将讨论的基本内置标量类型有:
int-带符号的、无限精度的整数
浮动- IEEE 754浮点数
没有一个-一个特殊的、奇异的空值
保龄球- true/false布尔值
现在我们只看它们的基本细节,展示它们的文字形式以及如何创建它们。
int
我们已经见过很多Python整数的应用。Python整数是有符号的,并且在实际应用中具有无限的精度。这意味着它们所能保存的值的大小没有预先定义的限制。
Python中的整数字面量通常以十进制指定:
>>>1010
它们也可以用二进制文件指定0 b 前缀:
>>>b10 02
八进制,带a0啊 前缀:
>>>0 o108
或者带a的十六进制0 x 前缀:
>>>0 x1016
方法也可以构造整数int 构造函数,可以将其他数值类型(如浮点数)转换为整数:
>>>int(3.5)3.
注意,当使用int 构造函数时,舍入总是趋于零:
>>>int(-3.5)-3.>>>int(3.5)3.
我们还可以将字符串转换为整数:
>>>int(“496”)496
但是请注意,如果字符串不表示整数,Python将抛出异常(后面会详细介绍!)。
在从字符串转换时,甚至可以提供一个可选的数字基数。例如,要从以3为基数进行转换,只需将3作为第二个参数传递给构造函数:
>>>int(“10000”,3.)81
浮动
类在Python中支持浮点数浮动 类型。Python浮点数实现为<一个href="https://en.wikipedia.org/wiki/IEEE_floating_point" class="" target="_blank">IEEE-754双精度浮点数一个>具有53位二进制精度。这相当于十进制中的15到16位有效数字。
任何包含小数点的文字数字都被Python解释为浮动 :
>>>3.1253.125
可以使用科学记数法,因此对于较大的数字,例如<我mg width="55" class="lazyload inline justify-self-center" src="https://learnable-static.s3.amazonaws.com/premium/reeedr/books/the-python-apprentice/images/000029.png" alt="3 \ times10 ^ 8gydF4y2Ba" loading="lazy">,即光速的近似速度(以米每秒为单位),可写成:
>>>3 e8300000000.0
以及像普朗克常数这样的小数值<我mg width="104" class="lazyload inline justify-self-center" src="https://learnable-static.s3.amazonaws.com/premium/reeedr/books/the-python-apprentice/images/000011.png" alt="1.616\times10^{- 35}gydF4y2Ba" loading="lazy">我们可以进入:
>>>1.616 e-351.616 e-35
请注意Python如何自动将显示表示转换为最易读的形式。
类将其他数值或字符串类型转换为浮点数浮动 构造函数。例如,构造函数可以接受int :
>>>浮动(7)7.0
或者字符串:
>>>浮动(“1.618”)1.618
特殊的浮点值
通过将某些字符串传递给浮动 构造函数时,可以创建特殊的浮点值南 (简称N 不一个 NUmber)以及正无穷和负无穷:
>>>浮动(“南”)南>>>浮动(“正”)正>>>浮动(“负”)-正
上市推广
计算结果:涉及的任何计算的结果int 而且浮动 被提升为浮动 :
>>>3.0+14.0
你可以阅读更多关于Python的数字类型<一个href="http://docs.python.org/3/library/stdtypes.html" class="" target="_blank">在Python文档中一个>.
没有一个
Python有一个特殊的空值叫做没有一个 ,用大写的“N”拼写。没有一个 常用于表示值的缺失。Python REPL从不打印没有一个 结果,所以打字没有一个 进入REPL没有效果:
>>>没有一个>>>
没有一个可以像其他对象一样绑定到变量名:
>>>一个=没有一个
我们可以测试一个物体是否没有一个 使用Python的是 接线员:
>>>一个是没有一个真正的
我们可以看到这里的响应是真正的 ,这就很方便地把我们带到了保龄球 类型。
保龄球
的保龄球 type表示逻辑状态,在Python的几个控制流结构中扮演着重要的角色,我们很快就会看到。
正如你所期望的,有两个bool值,真正的 而且假 ,都用首字母大写:
>>>真正的真正的>>>假假
还有一个保龄球 构造函数,可用于从其他类型转换为保龄球 .让我们看看它是如何工作的。为int S, 0被认为是“假的”,所有其他值被认为是“真的”:
>>>保龄球(0)假>>>保龄球(42)真正的>>>保龄球(-1)真正的
我们看到同样的行为浮动 S,其中只有0被认为是“假的”:
>>>保龄球(0.0)假>>>保龄球(0.207)真正的>>>保龄球(-1.117)真正的>>>保龄球(浮动(“南”))真正的
当从集合(如字符串或列表)进行转换时,只有空集合被视为“伪集合”。当从列表进行转换时——我们很快就会看到——我们只看到空列表(这里显示为的字面形式)[] )计算为假 :
>>>保龄球([])假>>>保龄球([1,5,9])真正的
类似地,对于字符串只有空字符串,"" ,计算为假 当传递给保龄球 :
>>>保龄球("")假>>>保龄球(“垃圾邮件”)真正的
特别是,不能使用保龄球 的字符串表示形式进行转换真正的 而且假 :
>>>保龄球(“假”)真正的
由于字符串" False "不是空的,它将求值为真正的 !
这些转换为保龄球 是重要的,因为它们在Python的if语句和while循环中被广泛使用保龄球 值。
关系运算符
布尔值通常由Python的关系操作符产生,可用于比较对象。
使用最广泛的两个关系操作符是Python的相等和不相等测试,它们实际上测试值的等价性或不相等性。也就是说,两个对象是等效 如果一个能代替另一个。我们将在本书后面了解更多关于对象等价的概念。现在,我们将比较简单的整数。
让我们从给变量赋值或绑定值开始g :
>>>g=20.
我们测试平等= = :
>>>g= =20.真正的>>>g= =13假
或者用不等式! = :
>>>g! =20.假>>>g! =13真正的
丰富的比较运算符
我们还可以使用丰富的比较运算符来比较数量的顺序。使用< 确定第一个参数是否小于第二个参数:
>>>g<30.真正的
同样,使用> 判断第一个是否大于第二个:
>>>g>30.假
您可以测试小于或等于< = :
>>>g< =20.真正的
大于或等于> = :
>>>g> =20.真正的
如果您有使用其他语言的关系操作符的经验,那么Python的操作符可能一点也不奇怪。请记住,这些运算符比较的是等价性,而不是恒等性,我们将在接下来的章节中详细讨论这一区别。
控制流:if语句和while循环
现在我们已经研究了一些基本的内置类型,让我们看看两个重要的控制流结构,它们依赖于转换到保龄球 类型:if语句和while循环。
条件控制流:if语句
条件语句允许我们基于表达式的值进行分支执行。陈述的形式是如果 关键字,后跟表达式,以冒号结束以引入新块。让我们在REPL试试这个:
>>>如果真正的:
记住在块内缩进四个空格,我们添加一些代码,如果条件为真正的 ,后面跟着一个空行来终止该块:
...打印(“这是真的!”)...这是真的!
此时块将执行,因为不言而喻的条件是真正的 .相反,如果条件是假 ,块中的代码不会执行:
>>>如果假:...打印(“这是真的!”)...>>>
与if语句一起使用的表达式将转换为a保龄球 就好像布尔值() 构造函数已经被使用,因此:
>>>如果保龄球(“鸡蛋”):...打印(“是的,请!”)...是的,请!
完全等价于:
>>>如果“鸡蛋”:...打印(“是的,请!”)...是的,请!
多亏了这个有用的简写,显式转换为保龄球 使用保龄球 构造函数在Python中很少使用。
如果...其他的
if语句支持可选的“else”子句,该子句位于语句引入的块中其他的 关键字(后跟冒号),缩进到与如果 关键字。让我们先创建(但不是结束)一个if-block:
>>>h=42>>>如果h>50:...打印(“大于50”)
开始其他的 在这种情况下,我们只是省略了三个点后的缩进:
...其他的:...打印(“50或以下”)...50orgydF4y2Ba小
如果...elif...其他的
在多种情况下,你可能会这样做:
>>>如果h>50:...打印(“大于50”)...其他的:...如果h<20.:...打印(“少于20”)...其他的:...打印(“20到50岁之间”)...之间的20.而且50
当你发现自己的else-block中包含嵌套的if语句时,你应该考虑使用Python的if语句elif 关键字,这是一个组合else if .
正如Python的禅宗所提醒我们的,“扁平比嵌套好”:
>>>如果h>50:...打印(“大于50”)...elifh<20.:...打印(“少于20”)...其他的:...打印(“20到50岁之间”)...之间的20.而且50
这个版本更容易阅读。
条件重复:while循环
Python有两种类型的循环:for循环和while循环。在介绍重要的空格时,我们已经简单地遇到过for循环,我们很快就会回到它们,但现在我们将介绍while循环。
类引入了Python中的while循环而 关键字,后面跟着一个布尔表达式。与if-语句的条件一样,表达式隐式转换为布尔值,就好像它已传递给布尔值() 构造函数。的而 语句以冒号结束,因为它引入了一个新的块。
让我们在REPL中写一个从5到1的循环。我们将初始化一个计数器变量c 到5,一直循环直到0。这里的另一个新语言特性是使用了增广赋值运算符,- = ,以便在每次迭代时从计数器的值中减去1。类似的增广赋值运算符也存在于其他基本数学运算中,如加法和乘法:
>>>c=5>>>而c! =0:...打印(c)...c- =1...543.21
因为条件(或谓词)将隐式转换为保龄球 ,就好像一声呼唤布尔值() 构造函数存在时,我们可以用以下版本替换上面的代码:
>>>c=5>>>而c:...打印(c)...c- =1...543.21
这是因为整数值的转换c 来保龄球 结果真正的 直到我们得到0,它转化为假 .也就是说,在这种情况下使用这种简短的形式可能会被描述为非Python的,因为,回顾Python的禅宗,显式比隐式更好。我们更看重第一种形式的可读性,而不是第二种形式的简洁。
而在Python中,循环通常用于需要无限循环的地方。我们通过传递来实现这一点真正的 作为while结构的谓词表达式:
>>>而真正的:...打印(“循环!”)...循环!循环!循环!循环!循环!循环!循环!循环!
现在您可能想知道我们如何摆脱这个循环并重新控制我们的REPL!简单的新闻ctrl - c :
循环!循环!循环!循环!循环!循环!^C回溯(最近一次通话):文件“< stdin >”,行2,在<模块>KeyboardInterrupt>>>
Python拦截键击并引发一个终止循环的特殊异常。我们将在后面的第6章中详细讨论异常是什么,以及如何使用它们。
退出循环
打破
许多编程语言都支持将谓词测试放在循环的末尾而不是开头的循环构造。例如,C、c++、c#和Java都支持do-while结构。其他语言也有repeat-until循环。在Python中不是这样,在Python中习惯用法是使用而真正的 加上提前退出,由打破 声明。
的打破 语句跳出循环(如果嵌套了几个循环,则只跳出最内层的循环),在循环体结束后立即继续执行。
让我们看一个例子打破 ,在此过程中介绍了其他一些Python特性,并逐行检查:
>>>而真正的:...响应=输入()...如果int(响应)%7= =0:...打破...
我们从a开始而真正的: 对于一个无限循环。在while块的第一条语句中,我们使用内置的输入() 函数向用户请求字符串。我们把这个字符串赋值给一个变量响应 .
现在我们使用if语句来测试所提供的值是否能被7整除。方法将响应字符串转换为整数int () 构造函数,然后使用模运算符,% 除以7,得到余数。如果余数等于0,则响应可以被7整除,然后进入If块体。
在if-块中,现在有两层缩进深,我们从八个空格开始,并使用打破 关键字。打破 终止最内部的循环(在本例中为while循环),并使执行跳转到循环后的第一个语句。
在这里,“语句”是程序的结束。我们在三点提示符处输入空行,关闭if-块和while-块。
我们的循环将开始执行,并在调用输入() 等着我们输入数字。让我们试几个:
673428>>>
只要输入一个能被7整除的数,谓词就变成真正的 ,我们进入if-块,然后从字面上跳出循环,直到程序结束,返回到REPL提示符。
总结
- 从Python开始
- 获取并安装Python
- 启动Read-Eval-Print-Loop或REPL
- 简单的算术
- 通过将对象绑定到名称来创建变量
- 内置打印
print () 函数
- 退出REPL
ctrl - z (Windows)或ctrl - d (Unix)
被预言的
明显的压痕
PEP 8 - Python代码的风格指南
PEP 20 - Python的禅
使用import语句以各种形式导入模块
查找和浏览帮助()
基本类型和控制流
int年代,浮动 年代,没有一个 ,保龄球 ,加上它们之间的转换
用于相等性和排序测试的关系运算符
if指令与其他的 而且elif 块
带有隐式转换的while循环保龄球
中断无限循环ctrl - c
打破循环与打破
从用户请求文本输入()
增广赋值运算符
预览结束
注册解锁剩余的标题。一个>
社区问题
关闭
启动Python 3解释器:
>python
在Windows或:
python3美元
在Mac或Linux上。
Python的控制流结构,如for-loops、while-loops和if-statements,都是由以冒号结束的语句引入的,这表明后面是构造体。例如,For循环需要一个正文,所以如果你输入:
>>>为我在范围(5):...
Python将向您显示由三个点组成的提示符,要求您提供正文。
Python的一个独特(有时是有争议的)方面是前导空格在语法上很重要。这意味着Python使用缩进级别,而不是其他语言使用的大括号来划分代码块。按照惯例,现代Python代码每层缩进四个空格。
因此,当Python给出三个点提示符时,我们提供了这四个空格和一条语句来形成循环体:
...x=我*10
循环体将包含第二个语句,因此在按下
...打印(x)
为了终止我们的块,我们必须在REPL中输入一个空行:
...
代码块完成后,Python执行挂起的代码,打印出小于50的10的倍数:
01020.30.40
看一屏Python代码,我们可以清楚地看到缩进是如何匹配的——事实上
Python源代码
即使我们用灰线替换代码,程序的结构也是清晰的。
灰色代码
以冒号结束的每个语句开始一个新行,并引入一个额外的缩进级别,直到缩进将缩进恢复到以前的级别。每一层缩进通常是四个空格,不过我们稍后将更详细地讨论这些规则。
Python处理重要空白的方法有三个很大的优点:
- 它迫使开发人员在代码块中使用单一级别的缩进。在任何语言中,这通常都被认为是很好的实践,因为它使代码更具可读性。
- 有重要空格的代码不需要用不必要的大括号来混淆,而且您永远不需要对大括号应该放在哪里进行代码标准的争论。Python代码中的所有代码块都很容易识别,并且每个人都以相同的方式编写它们。
- 重要的空白要求作者、Python运行时系统和未来需要阅读代码的维护者必须对代码结构给出一致的解释。因此,从Python的角度来看,你永远不会有包含块的代码,但从粗略的人类角度来看,它看起来不像包含块。
Python缩进的规则看起来很复杂,但在实践中非常简单。
- 您使用的空白可以是空格或制表符。普遍的共识是
空格比制表符更可取 ,四个空格已经成为Python社区的标准 . - 一个基本规则是
从来没有 混合空格和制表符。Python解释器会抱怨,你的同事会找你麻烦。 - 如果您愿意,您可以在不同的时间使用不同数量的缩进。基本规则是
相同缩进级别的连续代码行被认为是同一代码块的一部分 . - 这些规则也有一些例外,但它们几乎总是与以其他方式提高代码可读性有关,例如将必要的长语句拆分为多行。
这种严格的代码格式化方法是“按照Guido的意愿编程”,或者更恰当地说,“按照Guido的意愿编程”
Python文化
许多编程语言处于文化运动的中心。它们有自己的社区、价值观、实践和哲学,Python也不例外。Python语言本身的开发是通过一系列名为Python增强建议 ,或锐气 .其中一个PEP叫做PEP 8,它解释了应该如何格式化代码,我们在本书中遵循它的指导方针。例如,PEP 8建议我们在新的Python代码中使用四个空格作为缩进。
这些PEP中的另一个,叫做PEP 20,被称为“Python的禅宗”。它引用了20条描述Python指导原则的格言,其中只有19条被记录下来。方便的是,Python的Zen永远不会比最近的Python解释器更远,因为它总是可以通过输入以下命令从REPL访问:
>>>进口这Python的禅宗,蒂姆·彼得斯美丽的是比丑陋好.显式的是比含蓄要好.简单的是比复杂的.复杂的是好于复杂.平是比嵌套更好.稀疏的是比密集要好.可读性计数.特殊情况并不特别到打破规则.尽管实用性胜过纯洁性.永远不要犯错误通过默默地.除非明确保持沉默.面对模棱两可,不要去猜测.应该有一个--而且最好只有一个--很明显的方法.尽管那样可能不除非你是荷兰人.现在是聊胜于无.虽然从来没有是通常比*正确的*现在.如果实现是很难解释,这是个坏主意.如果实现是很容易解释,这可能是个好主意.命名空间是一个非常棒的想法--让我们多做一些吧!
在这本书中,我们将强调来自Python禅宗的智慧禅的时刻 理解它们如何应用于我们所学的知识。因为我们刚刚介绍了Python重要缩进,所以现在是时候开始第一个缩进了禅宗时刻 .
随着时间的推移,您将逐渐欣赏Python中重要的空白所带来的优雅你的 代码,以及阅读的便利性其他的 .
导入标准库模块
如前所述,Python附带了一个广泛的标准库,Python的一个方面通常被称为“包含电池”。标准库的结构为模块 ,我们稍后将深入讨论这个话题。在此阶段,重要的是要知道您可以通过使用进口 关键字。
导入模块的基本形式是进口 关键字,后跟空格和模块名称。例如,让我们看看如何使用标准库数学 模块来计算平方根。在三箭头提示符下,我们输入:
>>>进口数学
自进口 是一个不返回值的语句,如果导入成功,Python不会打印任何内容,我们立即返回到提示符。我们可以通过以下方式访问导入模块的内容:模块名,后跟一个点,再后跟模块中所需的属性名。像许多面向对象的语言一样,点运算符用于向下钻取对象结构。作为Pythonistas的专家,我们知道数学 模块包含一个名为sqrt () .让我们试着使用它:
>>>数学.√6(81)9.0
得到
帮助()
但是,我们如何才能找到在数学 模块?
REPL有一个特殊的功能帮助() 它可以从提供文档的对象(如标准库模块)中检索任何嵌入式文档。
要获得帮助,请在提示符处输入“help”:
>>>帮助类型帮助()为互动帮助,orgydF4y2Ba帮助(对象)为帮助关于对象.
我们将让您在自己的时间探索第一种形式-交互式帮助。这里我们选择第二个选项,通过数学 模块作为我们需要帮助的对象:
>>>帮助(数学)模块数学方面的帮助:的名字数学模块引用http://文档.python.org/3.3/图书馆/数学以下文档是自动生成的从Python源文件.可能是不完整的,不正确的orgydF4y2Ba包括以下特性被认为是实现细节而且可能在Python之间有所不同实现.当在怀疑,的模块参考上面列出的地点.描述这个模块是总是可用的.对象的访问由C标准定义的数学函数.功能这些“可信赖医疗组织”(...)这些“可信赖医疗组织”(x)返回arccos(测量在弧度)(x).
你可以使用空格键来翻页帮助,如果你在Mac或Linux上使用方向键来上下滚动。
浏览这些函数,你会看到有一个数学函数,的阶乘 ,用于计算阶乘。按“q”退出帮助浏览器,并返回到Python REPL。
现在练习使用帮助() 请求特定的帮助的阶乘 功能:
>>>帮助(数学.的阶乘)建立帮助-在功能!在模块的数学:的阶乘(...)的阶乘(x)->积分找到x !.引发ValueError如果x是负orgydF4y2Ba非-积分.
按' q '返回REPL。
让我们使用阶乘() 一点。该函数接受一个整型参数并返回一个整型值:
>>>数学.的阶乘(5)120>>>数学.的阶乘(6)720
注意我们需要如何用模块名称空间限定函数名。这通常是很好的实践,因为它使函数的来源非常清楚。也就是说,它可能导致代码过于冗长。
数水果
数学.的阶乘()
让我们用阶乘来计算从5个水果中抽取3个水果的方法有多少种,使用我们在学校学过的数学:
>>>n=5>>>k=3.>>>数学.的阶乘(n)/(数学.的阶乘(k)*数学.的阶乘(n-k))10.0
这个简单的表达式包含了对数学模块的所有引用,非常冗长。Python进口 语句具有另一种形式,该形式允许我们使用从 关键字:
>>>从数学进口的阶乘>>>的阶乘(n)/(的阶乘(k)*的阶乘(n-k))10.0
这是一个很好的改进,但是对于这样一个简单的表达式来说还是有点啰嗦。
import语句的第三种形式允许我们重命名导入的函数。这对于可读性或避免名称空间冲突很有用。虽然它很有用,但是我们建议不要经常使用这个功能,并且要明智地使用:
>>>从数学进口的阶乘作为前沿空中管制官>>>前沿空中管制官(n)/(前沿空中管制官(k)*前沿空中管制官(n-k))10.0
不同类型的数字
记住,当我们用阶乘() 单独返回一个整数。但是我们上面用来计算组合的更复杂的表达式是产生一个浮点数。这是因为我们用过/ , Python的浮点除法运算符。因为我们知道我们的运算只会返回积分结果,我们可以通过使用改进表达式// , Python的整数除法运算符:
>>>从数学进口的阶乘作为前沿空中管制官>>>前沿空中管制官(n)//(前沿空中管制官(k)*前沿空中管制官(n-k))10
值得注意的是,许多其他编程语言即使是中等值的n .在大多数编程语言中,普通的有符号整数只能存储小于的值<我mg width="20" class="lazyload inline justify-self-center" src="https://learnable-static.s3.amazonaws.com/premium/reeedr/books/the-python-apprentice/images/000056.png" alt="2 ^ {31}gydF4y2Ba" loading="lazy">:
>>>2**31-12147483647
然而,阶乘增长得如此之快,以至于您可以放入32位有符号整数的最大阶乘是12!因为13 !太大:
>>>前沿空中管制官(13)6227020800
在大多数广泛使用的编程语言中,你要么需要更复杂的代码,要么需要更复杂的数学,仅仅是计算从13个水果中抽出3个水果的方法有多少种。
Python不会遇到这样的问题,它可以计算任意大的整数,只受计算机内存的限制。为了进一步证明这一点,让我们尝试一个更大的问题,计算我们可以从100种不同的水果中挑选多少对不同的水果(假设我们可以找到这么多水果!):
>>>n=One hundred.>>>k=2>>>前沿空中管制官(n)//(前沿空中管制官(k)*前沿空中管制官(n-k))4950
只是为了强调这个表达式的第一项有多大,计算100!就其本身而言:
>>>前沿空中管制官(n)93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463\976156518286253697920827223758251185210916864000000000000000000000000
这个数字甚至比已知宇宙中的原子数量还要大得多,有很多数字。如果你像我们一样好奇到底有多少位数字,我们可以将整数转换为文本字符串,并像这样计算其中的字符数:
>>>len(str(前沿空中管制官(n)))158
这肯定有很多数字。还有很多水果。它还开始展示Python的不同数据类型(在本例中是整数、浮点数和文本字符串)如何以自然的方式协同工作。在下一节中,我们将以这一经验为基础,更详细地讨论整数、字符串和其他内置类型。
标量数据类型:整数、浮点数、None和bool
Python自带许多内置数据类型。这些类型包括像整数这样的基本标量类型以及像字典这样的集合类型。这些内置类型功能强大,可以单独用于许多编程需求,并且可以用作创建更复杂数据类型的构建块。
我们将讨论的基本内置标量类型有:
int-带符号的、无限精度的整数
浮动- IEEE 754浮点数
没有一个-一个特殊的、奇异的空值
保龄球- true/false布尔值
现在我们只看它们的基本细节,展示它们的文字形式以及如何创建它们。
int
我们已经见过很多Python整数的应用。Python整数是有符号的,并且在实际应用中具有无限的精度。这意味着它们所能保存的值的大小没有预先定义的限制。
Python中的整数字面量通常以十进制指定:
>>>1010
它们也可以用二进制文件指定0 b 前缀:
>>>b10 02
八进制,带a0啊 前缀:
>>>0 o108
或者带a的十六进制0 x 前缀:
>>>0 x1016
方法也可以构造整数int 构造函数,可以将其他数值类型(如浮点数)转换为整数:
>>>int(3.5)3.
注意,当使用int 构造函数时,舍入总是趋于零:
>>>int(-3.5)-3.>>>int(3.5)3.
我们还可以将字符串转换为整数:
>>>int(“496”)496
但是请注意,如果字符串不表示整数,Python将抛出异常(后面会详细介绍!)。
在从字符串转换时,甚至可以提供一个可选的数字基数。例如,要从以3为基数进行转换,只需将3作为第二个参数传递给构造函数:
>>>int(“10000”,3.)81
浮动
类在Python中支持浮点数浮动 类型。Python浮点数实现为<一个href="https://en.wikipedia.org/wiki/IEEE_floating_point" class="" target="_blank">IEEE-754双精度浮点数一个>具有53位二进制精度。这相当于十进制中的15到16位有效数字。
任何包含小数点的文字数字都被Python解释为浮动 :
>>>3.1253.125
可以使用科学记数法,因此对于较大的数字,例如<我mg width="55" class="lazyload inline justify-self-center" src="https://learnable-static.s3.amazonaws.com/premium/reeedr/books/the-python-apprentice/images/000029.png" alt="3 \ times10 ^ 8gydF4y2Ba" loading="lazy">,即光速的近似速度(以米每秒为单位),可写成:
>>>3 e8300000000.0
以及像普朗克常数这样的小数值<我mg width="104" class="lazyload inline justify-self-center" src="https://learnable-static.s3.amazonaws.com/premium/reeedr/books/the-python-apprentice/images/000011.png" alt="1.616\times10^{- 35}gydF4y2Ba" loading="lazy">我们可以进入:
>>>1.616 e-351.616 e-35
请注意Python如何自动将显示表示转换为最易读的形式。
类将其他数值或字符串类型转换为浮点数浮动 构造函数。例如,构造函数可以接受int :
>>>浮动(7)7.0
或者字符串:
>>>浮动(“1.618”)1.618
特殊的浮点值
通过将某些字符串传递给浮动 构造函数时,可以创建特殊的浮点值南 (简称N 不一个 NUmber)以及正无穷和负无穷:
>>>浮动(“南”)南>>>浮动(“正”)正>>>浮动(“负”)-正
上市推广
计算结果:涉及的任何计算的结果int 而且浮动 被提升为浮动 :
>>>3.0+14.0
你可以阅读更多关于Python的数字类型<一个href="http://docs.python.org/3/library/stdtypes.html" class="" target="_blank">在Python文档中一个>.
没有一个
Python有一个特殊的空值叫做没有一个 ,用大写的“N”拼写。没有一个 常用于表示值的缺失。Python REPL从不打印没有一个 结果,所以打字没有一个 进入REPL没有效果:
>>>没有一个>>>
没有一个可以像其他对象一样绑定到变量名:
>>>一个=没有一个
我们可以测试一个物体是否没有一个 使用Python的是 接线员:
>>>一个是没有一个真正的
我们可以看到这里的响应是真正的 ,这就很方便地把我们带到了保龄球 类型。
保龄球
的保龄球 type表示逻辑状态,在Python的几个控制流结构中扮演着重要的角色,我们很快就会看到。
正如你所期望的,有两个bool值,真正的 而且假 ,都用首字母大写:
>>>真正的真正的>>>假假
还有一个保龄球 构造函数,可用于从其他类型转换为保龄球 .让我们看看它是如何工作的。为int S, 0被认为是“假的”,所有其他值被认为是“真的”:
>>>保龄球(0)假>>>保龄球(42)真正的>>>保龄球(-1)真正的
我们看到同样的行为浮动 S,其中只有0被认为是“假的”:
>>>保龄球(0.0)假>>>保龄球(0.207)真正的>>>保龄球(-1.117)真正的>>>保龄球(浮动(“南”))真正的
当从集合(如字符串或列表)进行转换时,只有空集合被视为“伪集合”。当从列表进行转换时——我们很快就会看到——我们只看到空列表(这里显示为的字面形式)[] )计算为假 :
>>>保龄球([])假>>>保龄球([1,5,9])真正的
类似地,对于字符串只有空字符串,"" ,计算为假 当传递给保龄球 :
>>>保龄球("")假>>>保龄球(“垃圾邮件”)真正的
特别是,不能使用保龄球 的字符串表示形式进行转换真正的 而且假 :
>>>保龄球(“假”)真正的
由于字符串" False "不是空的,它将求值为真正的 !
这些转换为保龄球 是重要的,因为它们在Python的if语句和while循环中被广泛使用保龄球 值。
关系运算符
布尔值通常由Python的关系操作符产生,可用于比较对象。
使用最广泛的两个关系操作符是Python的相等和不相等测试,它们实际上测试值的等价性或不相等性。也就是说,两个对象是等效 如果一个能代替另一个。我们将在本书后面了解更多关于对象等价的概念。现在,我们将比较简单的整数。
让我们从给变量赋值或绑定值开始g :
>>>g=20.
我们测试平等= = :
>>>g= =20.真正的>>>g= =13假
或者用不等式! = :
>>>g! =20.假>>>g! =13真正的
丰富的比较运算符
我们还可以使用丰富的比较运算符来比较数量的顺序。使用< 确定第一个参数是否小于第二个参数:
>>>g<30.真正的
同样,使用> 判断第一个是否大于第二个:
>>>g>30.假
您可以测试小于或等于< = :
>>>g< =20.真正的
大于或等于> = :
>>>g> =20.真正的
如果您有使用其他语言的关系操作符的经验,那么Python的操作符可能一点也不奇怪。请记住,这些运算符比较的是等价性,而不是恒等性,我们将在接下来的章节中详细讨论这一区别。
控制流:if语句和while循环
现在我们已经研究了一些基本的内置类型,让我们看看两个重要的控制流结构,它们依赖于转换到保龄球 类型:if语句和while循环。
条件控制流:if语句
条件语句允许我们基于表达式的值进行分支执行。陈述的形式是如果 关键字,后跟表达式,以冒号结束以引入新块。让我们在REPL试试这个:
>>>如果真正的:
记住在块内缩进四个空格,我们添加一些代码,如果条件为真正的 ,后面跟着一个空行来终止该块:
...打印(“这是真的!”)...这是真的!
此时块将执行,因为不言而喻的条件是真正的 .相反,如果条件是假 ,块中的代码不会执行:
>>>如果假:...打印(“这是真的!”)...>>>
与if语句一起使用的表达式将转换为a保龄球 就好像布尔值() 构造函数已经被使用,因此:
>>>如果保龄球(“鸡蛋”):...打印(“是的,请!”)...是的,请!
完全等价于:
>>>如果“鸡蛋”:...打印(“是的,请!”)...是的,请!
多亏了这个有用的简写,显式转换为保龄球 使用保龄球 构造函数在Python中很少使用。
如果...其他的
if语句支持可选的“else”子句,该子句位于语句引入的块中其他的 关键字(后跟冒号),缩进到与如果 关键字。让我们先创建(但不是结束)一个if-block:
>>>h=42>>>如果h>50:...打印(“大于50”)
开始其他的 在这种情况下,我们只是省略了三个点后的缩进:
...其他的:...打印(“50或以下”)...50orgydF4y2Ba小
如果...elif...其他的
在多种情况下,你可能会这样做:
>>>如果h>50:...打印(“大于50”)...其他的:...如果h<20.:...打印(“少于20”)...其他的:...打印(“20到50岁之间”)...之间的20.而且50
当你发现自己的else-block中包含嵌套的if语句时,你应该考虑使用Python的if语句elif 关键字,这是一个组合else if .
正如Python的禅宗所提醒我们的,“扁平比嵌套好”:
>>>如果h>50:...打印(“大于50”)...elifh<20.:...打印(“少于20”)...其他的:...打印(“20到50岁之间”)...之间的20.而且50
这个版本更容易阅读。
条件重复:while循环
Python有两种类型的循环:for循环和while循环。在介绍重要的空格时,我们已经简单地遇到过for循环,我们很快就会回到它们,但现在我们将介绍while循环。
类引入了Python中的while循环而 关键字,后面跟着一个布尔表达式。与if-语句的条件一样,表达式隐式转换为布尔值,就好像它已传递给布尔值() 构造函数。的而 语句以冒号结束,因为它引入了一个新的块。
让我们在REPL中写一个从5到1的循环。我们将初始化一个计数器变量c 到5,一直循环直到0。这里的另一个新语言特性是使用了增广赋值运算符,- = ,以便在每次迭代时从计数器的值中减去1。类似的增广赋值运算符也存在于其他基本数学运算中,如加法和乘法:
>>>c=5>>>而c! =0:...打印(c)...c- =1...543.21
因为条件(或谓词)将隐式转换为保龄球 ,就好像一声呼唤布尔值() 构造函数存在时,我们可以用以下版本替换上面的代码:
>>>c=5>>>而c:...打印(c)...c- =1...543.21
这是因为整数值的转换c 来保龄球 结果真正的 直到我们得到0,它转化为假 .也就是说,在这种情况下使用这种简短的形式可能会被描述为非Python的,因为,回顾Python的禅宗,显式比隐式更好。我们更看重第一种形式的可读性,而不是第二种形式的简洁。
而在Python中,循环通常用于需要无限循环的地方。我们通过传递来实现这一点真正的 作为while结构的谓词表达式:
>>>而真正的:...打印(“循环!”)...循环!循环!循环!循环!循环!循环!循环!循环!
现在您可能想知道我们如何摆脱这个循环并重新控制我们的REPL!简单的新闻ctrl - c :
循环!循环!循环!循环!循环!循环!^C回溯(最近一次通话):文件“< stdin >”,行2,在<模块>KeyboardInterrupt>>>
Python拦截键击并引发一个终止循环的特殊异常。我们将在后面的第6章中详细讨论异常是什么,以及如何使用它们。
退出循环
打破
许多编程语言都支持将谓词测试放在循环的末尾而不是开头的循环构造。例如,C、c++、c#和Java都支持do-while结构。其他语言也有repeat-until循环。在Python中不是这样,在Python中习惯用法是使用而真正的 加上提前退出,由打破 声明。
的打破 语句跳出循环(如果嵌套了几个循环,则只跳出最内层的循环),在循环体结束后立即继续执行。
让我们看一个例子打破 ,在此过程中介绍了其他一些Python特性,并逐行检查:
>>>而真正的:...响应=输入()...如果int(响应)%7= =0:...打破...
我们从a开始而真正的: 对于一个无限循环。在while块的第一条语句中,我们使用内置的输入() 函数向用户请求字符串。我们把这个字符串赋值给一个变量响应 .
现在我们使用if语句来测试所提供的值是否能被7整除。方法将响应字符串转换为整数int () 构造函数,然后使用模运算符,% 除以7,得到余数。如果余数等于0,则响应可以被7整除,然后进入If块体。
在if-块中,现在有两层缩进深,我们从八个空格开始,并使用打破 关键字。打破 终止最内部的循环(在本例中为while循环),并使执行跳转到循环后的第一个语句。
在这里,“语句”是程序的结束。我们在三点提示符处输入空行,关闭if-块和while-块。
我们的循环将开始执行,并在调用输入() 等着我们输入数字。让我们试几个:
673428>>>
只要输入一个能被7整除的数,谓词就变成真正的 ,我们进入if-块,然后从字面上跳出循环,直到程序结束,返回到REPL提示符。
总结
- 从Python开始
- 获取并安装Python
- 启动Read-Eval-Print-Loop或REPL
- 简单的算术
- 通过将对象绑定到名称来创建变量
- 内置打印
print () 函数
- 退出REPL
ctrl - z (Windows)或ctrl - d (Unix)
被预言的
明显的压痕
PEP 8 - Python代码的风格指南
PEP 20 - Python的禅
使用import语句以各种形式导入模块
查找和浏览帮助()
基本类型和控制流
int年代,浮动 年代,没有一个 ,保龄球 ,加上它们之间的转换
用于相等性和排序测试的关系运算符
if指令与其他的 而且elif 块
带有隐式转换的while循环保龄球
中断无限循环ctrl - c
打破循环与打破
从用户请求文本输入()
增广赋值运算符
预览结束
注册解锁剩余的标题。一个>
社区问题
关闭
许多编程语言处于文化运动的中心。它们有自己的社区、价值观、实践和哲学,Python也不例外。Python语言本身的开发是通过一系列名为
这些PEP中的另一个,叫做PEP 20,被称为“Python的禅宗”。它引用了20条描述Python指导原则的格言,其中只有19条被记录下来。方便的是,Python的Zen永远不会比最近的Python解释器更远,因为它总是可以通过输入以下命令从REPL访问:
>>>进口这Python的禅宗,蒂姆·彼得斯美丽的是比丑陋好.显式的是比含蓄要好.简单的是比复杂的.复杂的是好于复杂.平是比嵌套更好.稀疏的是比密集要好.可读性计数.特殊情况并不特别到打破规则.尽管实用性胜过纯洁性.永远不要犯错误通过默默地.除非明确保持沉默.面对模棱两可,不要去猜测.应该有一个--而且最好只有一个--很明显的方法.尽管那样可能不除非你是荷兰人.现在是聊胜于无.虽然从来没有是通常比*正确的*现在.如果实现是很难解释,这是个坏主意.如果实现是很容易解释,这可能是个好主意.命名空间是一个非常棒的想法--让我们多做一些吧!
在这本书中,我们将强调来自Python禅宗的智慧
随着时间的推移,您将逐渐欣赏Python中重要的空白所带来的优雅
导入标准库模块
如前所述,Python附带了一个广泛的标准库,Python的一个方面通常被称为“包含电池”。标准库的结构为模块 ,我们稍后将深入讨论这个话题。在此阶段,重要的是要知道您可以通过使用进口 关键字。
导入模块的基本形式是进口 关键字,后跟空格和模块名称。例如,让我们看看如何使用标准库数学 模块来计算平方根。在三箭头提示符下,我们输入:
>>>进口数学
自进口 是一个不返回值的语句,如果导入成功,Python不会打印任何内容,我们立即返回到提示符。我们可以通过以下方式访问导入模块的内容:模块名,后跟一个点,再后跟模块中所需的属性名。像许多面向对象的语言一样,点运算符用于向下钻取对象结构。作为Pythonistas的专家,我们知道数学 模块包含一个名为sqrt () .让我们试着使用它:
>>>数学.√6(81)9.0
得到
帮助()
但是,我们如何才能找到在数学 模块?
REPL有一个特殊的功能帮助() 它可以从提供文档的对象(如标准库模块)中检索任何嵌入式文档。
要获得帮助,请在提示符处输入“help”:
>>>帮助类型帮助()为互动帮助,orgydF4y2Ba帮助(对象)为帮助关于对象.
我们将让您在自己的时间探索第一种形式-交互式帮助。这里我们选择第二个选项,通过数学 模块作为我们需要帮助的对象:
>>>帮助(数学)模块数学方面的帮助:的名字数学模块引用http://文档.python.org/3.3/图书馆/数学以下文档是自动生成的从Python源文件.可能是不完整的,不正确的orgydF4y2Ba包括以下特性被认为是实现细节而且可能在Python之间有所不同实现.当在怀疑,的模块参考上面列出的地点.描述这个模块是总是可用的.对象的访问由C标准定义的数学函数.功能这些“可信赖医疗组织”(...)这些“可信赖医疗组织”(x)返回arccos(测量在弧度)(x).
你可以使用空格键来翻页帮助,如果你在Mac或Linux上使用方向键来上下滚动。
浏览这些函数,你会看到有一个数学函数,的阶乘 ,用于计算阶乘。按“q”退出帮助浏览器,并返回到Python REPL。
现在练习使用帮助() 请求特定的帮助的阶乘 功能:
>>>帮助(数学.的阶乘)建立帮助-在功能!在模块的数学:的阶乘(...)的阶乘(x)->积分找到x !.引发ValueError如果x是负orgydF4y2Ba非-积分.
按' q '返回REPL。
让我们使用阶乘() 一点。该函数接受一个整型参数并返回一个整型值:
>>>数学.的阶乘(5)120>>>数学.的阶乘(6)720
注意我们需要如何用模块名称空间限定函数名。这通常是很好的实践,因为它使函数的来源非常清楚。也就是说,它可能导致代码过于冗长。
数水果
数学.的阶乘()
让我们用阶乘来计算从5个水果中抽取3个水果的方法有多少种,使用我们在学校学过的数学:
>>>n=5>>>k=3.>>>数学.的阶乘(n)/(数学.的阶乘(k)*数学.的阶乘(n-k))10.0
这个简单的表达式包含了对数学模块的所有引用,非常冗长。Python进口 语句具有另一种形式,该形式允许我们使用从 关键字:
>>>从数学进口的阶乘>>>的阶乘(n)/(的阶乘(k)*的阶乘(n-k))10.0
这是一个很好的改进,但是对于这样一个简单的表达式来说还是有点啰嗦。
import语句的第三种形式允许我们重命名导入的函数。这对于可读性或避免名称空间冲突很有用。虽然它很有用,但是我们建议不要经常使用这个功能,并且要明智地使用:
>>>从数学进口的阶乘作为前沿空中管制官>>>前沿空中管制官(n)/(前沿空中管制官(k)*前沿空中管制官(n-k))10.0
不同类型的数字
记住,当我们用阶乘() 单独返回一个整数。但是我们上面用来计算组合的更复杂的表达式是产生一个浮点数。这是因为我们用过/ , Python的浮点除法运算符。因为我们知道我们的运算只会返回积分结果,我们可以通过使用改进表达式// , Python的整数除法运算符:
>>>从数学进口的阶乘作为前沿空中管制官>>>前沿空中管制官(n)//(前沿空中管制官(k)*前沿空中管制官(n-k))10
值得注意的是,许多其他编程语言即使是中等值的n .在大多数编程语言中,普通的有符号整数只能存储小于的值<我mg width="20" class="lazyload inline justify-self-center" src="https://learnable-static.s3.amazonaws.com/premium/reeedr/books/the-python-apprentice/images/000056.png" alt="2 ^ {31}gydF4y2Ba" loading="lazy">:
>>>2**31-12147483647
然而,阶乘增长得如此之快,以至于您可以放入32位有符号整数的最大阶乘是12!因为13 !太大:
>>>前沿空中管制官(13)6227020800
在大多数广泛使用的编程语言中,你要么需要更复杂的代码,要么需要更复杂的数学,仅仅是计算从13个水果中抽出3个水果的方法有多少种。
Python不会遇到这样的问题,它可以计算任意大的整数,只受计算机内存的限制。为了进一步证明这一点,让我们尝试一个更大的问题,计算我们可以从100种不同的水果中挑选多少对不同的水果(假设我们可以找到这么多水果!):
>>>n=One hundred.>>>k=2>>>前沿空中管制官(n)//(前沿空中管制官(k)*前沿空中管制官(n-k))4950
只是为了强调这个表达式的第一项有多大,计算100!就其本身而言:
>>>前沿空中管制官(n)93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463\976156518286253697920827223758251185210916864000000000000000000000000
这个数字甚至比已知宇宙中的原子数量还要大得多,有很多数字。如果你像我们一样好奇到底有多少位数字,我们可以将整数转换为文本字符串,并像这样计算其中的字符数:
>>>len(str(前沿空中管制官(n)))158
这肯定有很多数字。还有很多水果。它还开始展示Python的不同数据类型(在本例中是整数、浮点数和文本字符串)如何以自然的方式协同工作。在下一节中,我们将以这一经验为基础,更详细地讨论整数、字符串和其他内置类型。
标量数据类型:整数、浮点数、None和bool
Python自带许多内置数据类型。这些类型包括像整数这样的基本标量类型以及像字典这样的集合类型。这些内置类型功能强大,可以单独用于许多编程需求,并且可以用作创建更复杂数据类型的构建块。
我们将讨论的基本内置标量类型有:
int-带符号的、无限精度的整数
浮动- IEEE 754浮点数
没有一个-一个特殊的、奇异的空值
保龄球- true/false布尔值
现在我们只看它们的基本细节,展示它们的文字形式以及如何创建它们。
int
我们已经见过很多Python整数的应用。Python整数是有符号的,并且在实际应用中具有无限的精度。这意味着它们所能保存的值的大小没有预先定义的限制。
Python中的整数字面量通常以十进制指定:
>>>1010
它们也可以用二进制文件指定0 b 前缀:
>>>b10 02
八进制,带a0啊 前缀:
>>>0 o108
或者带a的十六进制0 x 前缀:
>>>0 x1016
方法也可以构造整数int 构造函数,可以将其他数值类型(如浮点数)转换为整数:
>>>int(3.5)3.
注意,当使用int 构造函数时,舍入总是趋于零:
>>>int(-3.5)-3.>>>int(3.5)3.
我们还可以将字符串转换为整数:
>>>int(“496”)496
但是请注意,如果字符串不表示整数,Python将抛出异常(后面会详细介绍!)。
在从字符串转换时,甚至可以提供一个可选的数字基数。例如,要从以3为基数进行转换,只需将3作为第二个参数传递给构造函数:
>>>int(“10000”,3.)81
浮动
类在Python中支持浮点数浮动 类型。Python浮点数实现为<一个href="https://en.wikipedia.org/wiki/IEEE_floating_point" class="" target="_blank">IEEE-754双精度浮点数一个>具有53位二进制精度。这相当于十进制中的15到16位有效数字。
任何包含小数点的文字数字都被Python解释为浮动 :
>>>3.1253.125
可以使用科学记数法,因此对于较大的数字,例如<我mg width="55" class="lazyload inline justify-self-center" src="https://learnable-static.s3.amazonaws.com/premium/reeedr/books/the-python-apprentice/images/000029.png" alt="3 \ times10 ^ 8gydF4y2Ba" loading="lazy">,即光速的近似速度(以米每秒为单位),可写成:
>>>3 e8300000000.0
以及像普朗克常数这样的小数值<我mg width="104" class="lazyload inline justify-self-center" src="https://learnable-static.s3.amazonaws.com/premium/reeedr/books/the-python-apprentice/images/000011.png" alt="1.616\times10^{- 35}gydF4y2Ba" loading="lazy">我们可以进入:
>>>1.616 e-351.616 e-35
请注意Python如何自动将显示表示转换为最易读的形式。
类将其他数值或字符串类型转换为浮点数浮动 构造函数。例如,构造函数可以接受int :
>>>浮动(7)7.0
或者字符串:
>>>浮动(“1.618”)1.618
特殊的浮点值
通过将某些字符串传递给浮动 构造函数时,可以创建特殊的浮点值南 (简称N 不一个 NUmber)以及正无穷和负无穷:
>>>浮动(“南”)南>>>浮动(“正”)正>>>浮动(“负”)-正
上市推广
计算结果:涉及的任何计算的结果int 而且浮动 被提升为浮动 :
>>>3.0+14.0
你可以阅读更多关于Python的数字类型<一个href="http://docs.python.org/3/library/stdtypes.html" class="" target="_blank">在Python文档中一个>.
没有一个
Python有一个特殊的空值叫做没有一个 ,用大写的“N”拼写。没有一个 常用于表示值的缺失。Python REPL从不打印没有一个 结果,所以打字没有一个 进入REPL没有效果:
>>>没有一个>>>
没有一个可以像其他对象一样绑定到变量名:
>>>一个=没有一个
我们可以测试一个物体是否没有一个 使用Python的是 接线员:
>>>一个是没有一个真正的
我们可以看到这里的响应是真正的 ,这就很方便地把我们带到了保龄球 类型。
保龄球
的保龄球 type表示逻辑状态,在Python的几个控制流结构中扮演着重要的角色,我们很快就会看到。
正如你所期望的,有两个bool值,真正的 而且假 ,都用首字母大写:
>>>真正的真正的>>>假假
还有一个保龄球 构造函数,可用于从其他类型转换为保龄球 .让我们看看它是如何工作的。为int S, 0被认为是“假的”,所有其他值被认为是“真的”:
>>>保龄球(0)假>>>保龄球(42)真正的>>>保龄球(-1)真正的
我们看到同样的行为浮动 S,其中只有0被认为是“假的”:
>>>保龄球(0.0)假>>>保龄球(0.207)真正的>>>保龄球(-1.117)真正的>>>保龄球(浮动(“南”))真正的
当从集合(如字符串或列表)进行转换时,只有空集合被视为“伪集合”。当从列表进行转换时——我们很快就会看到——我们只看到空列表(这里显示为的字面形式)[] )计算为假 :
>>>保龄球([])假>>>保龄球([1,5,9])真正的
类似地,对于字符串只有空字符串,"" ,计算为假 当传递给保龄球 :
>>>保龄球("")假>>>保龄球(“垃圾邮件”)真正的
特别是,不能使用保龄球 的字符串表示形式进行转换真正的 而且假 :
>>>保龄球(“假”)真正的
由于字符串" False "不是空的,它将求值为真正的 !
这些转换为保龄球 是重要的,因为它们在Python的if语句和while循环中被广泛使用保龄球 值。
关系运算符
布尔值通常由Python的关系操作符产生,可用于比较对象。
使用最广泛的两个关系操作符是Python的相等和不相等测试,它们实际上测试值的等价性或不相等性。也就是说,两个对象是等效 如果一个能代替另一个。我们将在本书后面了解更多关于对象等价的概念。现在,我们将比较简单的整数。
让我们从给变量赋值或绑定值开始g :
>>>g=20.
我们测试平等= = :
>>>g= =20.真正的>>>g= =13假
或者用不等式! = :
>>>g! =20.假>>>g! =13真正的
丰富的比较运算符
我们还可以使用丰富的比较运算符来比较数量的顺序。使用< 确定第一个参数是否小于第二个参数:
>>>g<30.真正的
同样,使用> 判断第一个是否大于第二个:
>>>g>30.假
您可以测试小于或等于< = :
>>>g< =20.真正的
大于或等于> = :
>>>g> =20.真正的
如果您有使用其他语言的关系操作符的经验,那么Python的操作符可能一点也不奇怪。请记住,这些运算符比较的是等价性,而不是恒等性,我们将在接下来的章节中详细讨论这一区别。
控制流:if语句和while循环
现在我们已经研究了一些基本的内置类型,让我们看看两个重要的控制流结构,它们依赖于转换到保龄球 类型:if语句和while循环。
条件控制流:if语句
条件语句允许我们基于表达式的值进行分支执行。陈述的形式是如果 关键字,后跟表达式,以冒号结束以引入新块。让我们在REPL试试这个:
>>>如果真正的:
记住在块内缩进四个空格,我们添加一些代码,如果条件为真正的 ,后面跟着一个空行来终止该块:
...打印(“这是真的!”)...这是真的!
此时块将执行,因为不言而喻的条件是真正的 .相反,如果条件是假 ,块中的代码不会执行:
>>>如果假:...打印(“这是真的!”)...>>>
与if语句一起使用的表达式将转换为a保龄球 就好像布尔值() 构造函数已经被使用,因此:
>>>如果保龄球(“鸡蛋”):...打印(“是的,请!”)...是的,请!
完全等价于:
>>>如果“鸡蛋”:...打印(“是的,请!”)...是的,请!
多亏了这个有用的简写,显式转换为保龄球 使用保龄球 构造函数在Python中很少使用。
如果...其他的
if语句支持可选的“else”子句,该子句位于语句引入的块中其他的 关键字(后跟冒号),缩进到与如果 关键字。让我们先创建(但不是结束)一个if-block:
>>>h=42>>>如果h>50:...打印(“大于50”)
开始其他的 在这种情况下,我们只是省略了三个点后的缩进:
...其他的:...打印(“50或以下”)...50orgydF4y2Ba小
如果...elif...其他的
在多种情况下,你可能会这样做:
>>>如果h>50:...打印(“大于50”)...其他的:...如果h<20.:...打印(“少于20”)...其他的:...打印(“20到50岁之间”)...之间的20.而且50
当你发现自己的else-block中包含嵌套的if语句时,你应该考虑使用Python的if语句elif 关键字,这是一个组合else if .
正如Python的禅宗所提醒我们的,“扁平比嵌套好”:
>>>如果h>50:...打印(“大于50”)...elifh<20.:...打印(“少于20”)...其他的:...打印(“20到50岁之间”)...之间的20.而且50
这个版本更容易阅读。
条件重复:while循环
Python有两种类型的循环:for循环和while循环。在介绍重要的空格时,我们已经简单地遇到过for循环,我们很快就会回到它们,但现在我们将介绍while循环。
类引入了Python中的while循环而 关键字,后面跟着一个布尔表达式。与if-语句的条件一样,表达式隐式转换为布尔值,就好像它已传递给布尔值() 构造函数。的而 语句以冒号结束,因为它引入了一个新的块。
让我们在REPL中写一个从5到1的循环。我们将初始化一个计数器变量c 到5,一直循环直到0。这里的另一个新语言特性是使用了增广赋值运算符,- = ,以便在每次迭代时从计数器的值中减去1。类似的增广赋值运算符也存在于其他基本数学运算中,如加法和乘法:
>>>c=5>>>而c! =0:...打印(c)...c- =1...543.21
因为条件(或谓词)将隐式转换为保龄球 ,就好像一声呼唤布尔值() 构造函数存在时,我们可以用以下版本替换上面的代码:
>>>c=5>>>而c:...打印(c)...c- =1...543.21
这是因为整数值的转换c 来保龄球 结果真正的 直到我们得到0,它转化为假 .也就是说,在这种情况下使用这种简短的形式可能会被描述为非Python的,因为,回顾Python的禅宗,显式比隐式更好。我们更看重第一种形式的可读性,而不是第二种形式的简洁。
而在Python中,循环通常用于需要无限循环的地方。我们通过传递来实现这一点真正的 作为while结构的谓词表达式:
>>>而真正的:...打印(“循环!”)...循环!循环!循环!循环!循环!循环!循环!循环!
现在您可能想知道我们如何摆脱这个循环并重新控制我们的REPL!简单的新闻ctrl - c :
循环!循环!循环!循环!循环!循环!^C回溯(最近一次通话):文件“< stdin >”,行2,在<模块>KeyboardInterrupt>>>
Python拦截键击并引发一个终止循环的特殊异常。我们将在后面的第6章中详细讨论异常是什么,以及如何使用它们。
退出循环
打破
许多编程语言都支持将谓词测试放在循环的末尾而不是开头的循环构造。例如,C、c++、c#和Java都支持do-while结构。其他语言也有repeat-until循环。在Python中不是这样,在Python中习惯用法是使用而真正的 加上提前退出,由打破 声明。
的打破 语句跳出循环(如果嵌套了几个循环,则只跳出最内层的循环),在循环体结束后立即继续执行。
让我们看一个例子打破 ,在此过程中介绍了其他一些Python特性,并逐行检查:
>>>而真正的:...响应=输入()...如果int(响应)%7= =0:...打破...
我们从a开始而真正的: 对于一个无限循环。在while块的第一条语句中,我们使用内置的输入() 函数向用户请求字符串。我们把这个字符串赋值给一个变量响应 .
现在我们使用if语句来测试所提供的值是否能被7整除。方法将响应字符串转换为整数int () 构造函数,然后使用模运算符,% 除以7,得到余数。如果余数等于0,则响应可以被7整除,然后进入If块体。
在if-块中,现在有两层缩进深,我们从八个空格开始,并使用打破 关键字。打破 终止最内部的循环(在本例中为while循环),并使执行跳转到循环后的第一个语句。
在这里,“语句”是程序的结束。我们在三点提示符处输入空行,关闭if-块和while-块。
我们的循环将开始执行,并在调用输入() 等着我们输入数字。让我们试几个:
673428>>>
只要输入一个能被7整除的数,谓词就变成真正的 ,我们进入if-块,然后从字面上跳出循环,直到程序结束,返回到REPL提示符。
总结
- 从Python开始
- 获取并安装Python
- 启动Read-Eval-Print-Loop或REPL
- 简单的算术
- 通过将对象绑定到名称来创建变量
- 内置打印
print () 函数
- 退出REPL
ctrl - z (Windows)或ctrl - d (Unix)
被预言的
明显的压痕
PEP 8 - Python代码的风格指南
PEP 20 - Python的禅
使用import语句以各种形式导入模块
查找和浏览帮助()
基本类型和控制流
int年代,浮动 年代,没有一个 ,保龄球 ,加上它们之间的转换
用于相等性和排序测试的关系运算符
if指令与其他的 而且elif 块
带有隐式转换的while循环保龄球
中断无限循环ctrl - c
打破循环与打破
从用户请求文本输入()
增广赋值运算符
预览结束
注册解锁剩余的标题。一个>
社区问题
关闭
如前所述,Python附带了一个广泛的标准库,Python的一个方面通常被称为“包含电池”。标准库的结构为
导入模块的基本形式是
>>>进口数学
自
>>>数学.√6(81)9.0
得到
帮助()
但是,我们如何才能找到在数学 模块?
REPL有一个特殊的功能帮助() 它可以从提供文档的对象(如标准库模块)中检索任何嵌入式文档。
要获得帮助,请在提示符处输入“help”:
>>>帮助类型帮助()为互动帮助,orgydF4y2Ba帮助(对象)为帮助关于对象.
我们将让您在自己的时间探索第一种形式-交互式帮助。这里我们选择第二个选项,通过数学 模块作为我们需要帮助的对象:
>>>帮助(数学)模块数学方面的帮助:的名字数学模块引用http://文档.python.org/3.3/图书馆/数学以下文档是自动生成的从Python源文件.可能是不完整的,不正确的orgydF4y2Ba包括以下特性被认为是实现细节而且可能在Python之间有所不同实现.当在怀疑,的模块参考上面列出的地点.描述这个模块是总是可用的.对象的访问由C标准定义的数学函数.功能这些“可信赖医疗组织”(...)这些“可信赖医疗组织”(x)返回arccos(测量在弧度)(x).
你可以使用空格键来翻页帮助,如果你在Mac或Linux上使用方向键来上下滚动。
浏览这些函数,你会看到有一个数学函数,的阶乘 ,用于计算阶乘。按“q”退出帮助浏览器,并返回到Python REPL。
现在练习使用帮助() 请求特定的帮助的阶乘 功能:
>>>帮助(数学.的阶乘)建立帮助-在功能!在模块的数学:的阶乘(...)的阶乘(x)->积分找到x !.引发ValueError如果x是负orgydF4y2Ba非-积分.
按' q '返回REPL。
让我们使用阶乘() 一点。该函数接受一个整型参数并返回一个整型值:
>>>数学.的阶乘(5)120>>>数学.的阶乘(6)720
注意我们需要如何用模块名称空间限定函数名。这通常是很好的实践,因为它使函数的来源非常清楚。也就是说,它可能导致代码过于冗长。
数水果
数学.的阶乘()
让我们用阶乘来计算从5个水果中抽取3个水果的方法有多少种,使用我们在学校学过的数学:
>>>n=5>>>k=3.>>>数学.的阶乘(n)/(数学.的阶乘(k)*数学.的阶乘(n-k))10.0
这个简单的表达式包含了对数学模块的所有引用,非常冗长。Python进口 语句具有另一种形式,该形式允许我们使用从 关键字:
>>>从数学进口的阶乘>>>的阶乘(n)/(的阶乘(k)*的阶乘(n-k))10.0
这是一个很好的改进,但是对于这样一个简单的表达式来说还是有点啰嗦。
import语句的第三种形式允许我们重命名导入的函数。这对于可读性或避免名称空间冲突很有用。虽然它很有用,但是我们建议不要经常使用这个功能,并且要明智地使用:
>>>从数学进口的阶乘作为前沿空中管制官>>>前沿空中管制官(n)/(前沿空中管制官(k)*前沿空中管制官(n-k))10.0
不同类型的数字
记住,当我们用阶乘() 单独返回一个整数。但是我们上面用来计算组合的更复杂的表达式是产生一个浮点数。这是因为我们用过/ , Python的浮点除法运算符。因为我们知道我们的运算只会返回积分结果,我们可以通过使用改进表达式// , Python的整数除法运算符:
>>>从数学进口的阶乘作为前沿空中管制官>>>前沿空中管制官(n)//(前沿空中管制官(k)*前沿空中管制官(n-k))10
值得注意的是,许多其他编程语言即使是中等值的n .在大多数编程语言中,普通的有符号整数只能存储小于的值<我mg width="20" class="lazyload inline justify-self-center" src="https://learnable-static.s3.amazonaws.com/premium/reeedr/books/the-python-apprentice/images/000056.png" alt="2 ^ {31}gydF4y2Ba" loading="lazy">:
>>>2**31-12147483647
然而,阶乘增长得如此之快,以至于您可以放入32位有符号整数的最大阶乘是12!因为13 !太大:
>>>前沿空中管制官(13)6227020800
在大多数广泛使用的编程语言中,你要么需要更复杂的代码,要么需要更复杂的数学,仅仅是计算从13个水果中抽出3个水果的方法有多少种。
Python不会遇到这样的问题,它可以计算任意大的整数,只受计算机内存的限制。为了进一步证明这一点,让我们尝试一个更大的问题,计算我们可以从100种不同的水果中挑选多少对不同的水果(假设我们可以找到这么多水果!):
>>>n=One hundred.>>>k=2>>>前沿空中管制官(n)//(前沿空中管制官(k)*前沿空中管制官(n-k))4950
只是为了强调这个表达式的第一项有多大,计算100!就其本身而言:
>>>前沿空中管制官(n)93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463\976156518286253697920827223758251185210916864000000000000000000000000
这个数字甚至比已知宇宙中的原子数量还要大得多,有很多数字。如果你像我们一样好奇到底有多少位数字,我们可以将整数转换为文本字符串,并像这样计算其中的字符数:
>>>len(str(前沿空中管制官(n)))158
这肯定有很多数字。还有很多水果。它还开始展示Python的不同数据类型(在本例中是整数、浮点数和文本字符串)如何以自然的方式协同工作。在下一节中,我们将以这一经验为基础,更详细地讨论整数、字符串和其他内置类型。
标量数据类型:整数、浮点数、None和bool
Python自带许多内置数据类型。这些类型包括像整数这样的基本标量类型以及像字典这样的集合类型。这些内置类型功能强大,可以单独用于许多编程需求,并且可以用作创建更复杂数据类型的构建块。
我们将讨论的基本内置标量类型有:
int-带符号的、无限精度的整数
浮动- IEEE 754浮点数
没有一个-一个特殊的、奇异的空值
保龄球- true/false布尔值
现在我们只看它们的基本细节,展示它们的文字形式以及如何创建它们。
int
我们已经见过很多Python整数的应用。Python整数是有符号的,并且在实际应用中具有无限的精度。这意味着它们所能保存的值的大小没有预先定义的限制。
Python中的整数字面量通常以十进制指定:
>>>1010
它们也可以用二进制文件指定0 b 前缀:
>>>b10 02
八进制,带a0啊 前缀:
>>>0 o108
或者带a的十六进制0 x 前缀:
>>>0 x1016
方法也可以构造整数int 构造函数,可以将其他数值类型(如浮点数)转换为整数:
>>>int(3.5)3.
注意,当使用int 构造函数时,舍入总是趋于零:
>>>int(-3.5)-3.>>>int(3.5)3.
我们还可以将字符串转换为整数:
>>>int(“496”)496
但是请注意,如果字符串不表示整数,Python将抛出异常(后面会详细介绍!)。
在从字符串转换时,甚至可以提供一个可选的数字基数。例如,要从以3为基数进行转换,只需将3作为第二个参数传递给构造函数:
>>>int(“10000”,3.)81
浮动
类在Python中支持浮点数浮动 类型。Python浮点数实现为<一个href="https://en.wikipedia.org/wiki/IEEE_floating_point" class="" target="_blank">IEEE-754双精度浮点数一个>具有53位二进制精度。这相当于十进制中的15到16位有效数字。
任何包含小数点的文字数字都被Python解释为浮动 :
>>>3.1253.125
可以使用科学记数法,因此对于较大的数字,例如<我mg width="55" class="lazyload inline justify-self-center" src="https://learnable-static.s3.amazonaws.com/premium/reeedr/books/the-python-apprentice/images/000029.png" alt="3 \ times10 ^ 8gydF4y2Ba" loading="lazy">,即光速的近似速度(以米每秒为单位),可写成:
>>>3 e8300000000.0
以及像普朗克常数这样的小数值<我mg width="104" class="lazyload inline justify-self-center" src="https://learnable-static.s3.amazonaws.com/premium/reeedr/books/the-python-apprentice/images/000011.png" alt="1.616\times10^{- 35}gydF4y2Ba" loading="lazy">我们可以进入:
>>>1.616 e-351.616 e-35
请注意Python如何自动将显示表示转换为最易读的形式。
类将其他数值或字符串类型转换为浮点数浮动 构造函数。例如,构造函数可以接受int :
>>>浮动(7)7.0
或者字符串:
>>>浮动(“1.618”)1.618
特殊的浮点值
通过将某些字符串传递给浮动 构造函数时,可以创建特殊的浮点值南 (简称N 不一个 NUmber)以及正无穷和负无穷:
>>>浮动(“南”)南>>>浮动(“正”)正>>>浮动(“负”)-正
上市推广
计算结果:涉及的任何计算的结果int 而且浮动 被提升为浮动 :
>>>3.0+14.0
你可以阅读更多关于Python的数字类型<一个href="http://docs.python.org/3/library/stdtypes.html" class="" target="_blank">在Python文档中一个>.
没有一个
Python有一个特殊的空值叫做没有一个 ,用大写的“N”拼写。没有一个 常用于表示值的缺失。Python REPL从不打印没有一个 结果,所以打字没有一个 进入REPL没有效果:
>>>没有一个>>>
没有一个可以像其他对象一样绑定到变量名:
>>>一个=没有一个
我们可以测试一个物体是否没有一个 使用Python的是 接线员:
>>>一个是没有一个真正的
我们可以看到这里的响应是真正的 ,这就很方便地把我们带到了保龄球 类型。
保龄球
的保龄球 type表示逻辑状态,在Python的几个控制流结构中扮演着重要的角色,我们很快就会看到。
正如你所期望的,有两个bool值,真正的 而且假 ,都用首字母大写:
>>>真正的真正的>>>假假
还有一个保龄球 构造函数,可用于从其他类型转换为保龄球 .让我们看看它是如何工作的。为int S, 0被认为是“假的”,所有其他值被认为是“真的”:
>>>保龄球(0)假>>>保龄球(42)真正的>>>保龄球(-1)真正的
我们看到同样的行为浮动 S,其中只有0被认为是“假的”:
>>>保龄球(0.0)假>>>保龄球(0.207)真正的>>>保龄球(-1.117)真正的>>>保龄球(浮动(“南”))真正的
当从集合(如字符串或列表)进行转换时,只有空集合被视为“伪集合”。当从列表进行转换时——我们很快就会看到——我们只看到空列表(这里显示为的字面形式)[] )计算为假 :
>>>保龄球([])假>>>保龄球([1,5,9])真正的
类似地,对于字符串只有空字符串,"" ,计算为假 当传递给保龄球 :
>>>保龄球("")假>>>保龄球(“垃圾邮件”)真正的
特别是,不能使用保龄球 的字符串表示形式进行转换真正的 而且假 :
>>>保龄球(“假”)真正的
由于字符串" False "不是空的,它将求值为真正的 !
这些转换为保龄球 是重要的,因为它们在Python的if语句和while循环中被广泛使用保龄球 值。
关系运算符
布尔值通常由Python的关系操作符产生,可用于比较对象。
使用最广泛的两个关系操作符是Python的相等和不相等测试,它们实际上测试值的等价性或不相等性。也就是说,两个对象是等效 如果一个能代替另一个。我们将在本书后面了解更多关于对象等价的概念。现在,我们将比较简单的整数。
让我们从给变量赋值或绑定值开始g :
>>>g=20.
我们测试平等= = :
>>>g= =20.真正的>>>g= =13假
或者用不等式! = :
>>>g! =20.假>>>g! =13真正的
丰富的比较运算符
我们还可以使用丰富的比较运算符来比较数量的顺序。使用< 确定第一个参数是否小于第二个参数:
>>>g<30.真正的
同样,使用> 判断第一个是否大于第二个:
>>>g>30.假
您可以测试小于或等于< = :
>>>g< =20.真正的
大于或等于> = :
>>>g> =20.真正的
如果您有使用其他语言的关系操作符的经验,那么Python的操作符可能一点也不奇怪。请记住,这些运算符比较的是等价性,而不是恒等性,我们将在接下来的章节中详细讨论这一区别。
控制流:if语句和while循环
现在我们已经研究了一些基本的内置类型,让我们看看两个重要的控制流结构,它们依赖于转换到保龄球 类型:if语句和while循环。
条件控制流:if语句
条件语句允许我们基于表达式的值进行分支执行。陈述的形式是如果 关键字,后跟表达式,以冒号结束以引入新块。让我们在REPL试试这个:
>>>如果真正的:
记住在块内缩进四个空格,我们添加一些代码,如果条件为真正的 ,后面跟着一个空行来终止该块:
...打印(“这是真的!”)...这是真的!
此时块将执行,因为不言而喻的条件是真正的 .相反,如果条件是假 ,块中的代码不会执行:
>>>如果假:...打印(“这是真的!”)...>>>
与if语句一起使用的表达式将转换为a保龄球 就好像布尔值() 构造函数已经被使用,因此:
>>>如果保龄球(“鸡蛋”):...打印(“是的,请!”)...是的,请!
完全等价于:
>>>如果“鸡蛋”:...打印(“是的,请!”)...是的,请!
多亏了这个有用的简写,显式转换为保龄球 使用保龄球 构造函数在Python中很少使用。
如果...其他的
if语句支持可选的“else”子句,该子句位于语句引入的块中其他的 关键字(后跟冒号),缩进到与如果 关键字。让我们先创建(但不是结束)一个if-block:
>>>h=42>>>如果h>50:...打印(“大于50”)
开始其他的 在这种情况下,我们只是省略了三个点后的缩进:
...其他的:...打印(“50或以下”)...50orgydF4y2Ba小
如果...elif...其他的
在多种情况下,你可能会这样做:
>>>如果h>50:...打印(“大于50”)...其他的:...如果h<20.:...打印(“少于20”)...其他的:...打印(“20到50岁之间”)...之间的20.而且50
当你发现自己的else-block中包含嵌套的if语句时,你应该考虑使用Python的if语句elif 关键字,这是一个组合else if .
正如Python的禅宗所提醒我们的,“扁平比嵌套好”:
>>>如果h>50:...打印(“大于50”)...elifh<20.:...打印(“少于20”)...其他的:...打印(“20到50岁之间”)...之间的20.而且50
这个版本更容易阅读。
条件重复:while循环
Python有两种类型的循环:for循环和while循环。在介绍重要的空格时,我们已经简单地遇到过for循环,我们很快就会回到它们,但现在我们将介绍while循环。
类引入了Python中的while循环而 关键字,后面跟着一个布尔表达式。与if-语句的条件一样,表达式隐式转换为布尔值,就好像它已传递给布尔值() 构造函数。的而 语句以冒号结束,因为它引入了一个新的块。
让我们在REPL中写一个从5到1的循环。我们将初始化一个计数器变量c 到5,一直循环直到0。这里的另一个新语言特性是使用了增广赋值运算符,- = ,以便在每次迭代时从计数器的值中减去1。类似的增广赋值运算符也存在于其他基本数学运算中,如加法和乘法:
>>>c=5>>>而c! =0:...打印(c)...c- =1...543.21
因为条件(或谓词)将隐式转换为保龄球 ,就好像一声呼唤布尔值() 构造函数存在时,我们可以用以下版本替换上面的代码:
>>>c=5>>>而c:...打印(c)...c- =1...543.21
这是因为整数值的转换c 来保龄球 结果真正的 直到我们得到0,它转化为假 .也就是说,在这种情况下使用这种简短的形式可能会被描述为非Python的,因为,回顾Python的禅宗,显式比隐式更好。我们更看重第一种形式的可读性,而不是第二种形式的简洁。
而在Python中,循环通常用于需要无限循环的地方。我们通过传递来实现这一点真正的 作为while结构的谓词表达式:
>>>而真正的:...打印(“循环!”)...循环!循环!循环!循环!循环!循环!循环!循环!
现在您可能想知道我们如何摆脱这个循环并重新控制我们的REPL!简单的新闻ctrl - c :
循环!循环!循环!循环!循环!循环!^C回溯(最近一次通话):文件“< stdin >”,行2,在<模块>KeyboardInterrupt>>>
Python拦截键击并引发一个终止循环的特殊异常。我们将在后面的第6章中详细讨论异常是什么,以及如何使用它们。
退出循环
打破
许多编程语言都支持将谓词测试放在循环的末尾而不是开头的循环构造。例如,C、c++、c#和Java都支持do-while结构。其他语言也有repeat-until循环。在Python中不是这样,在Python中习惯用法是使用而真正的 加上提前退出,由打破 声明。
的打破 语句跳出循环(如果嵌套了几个循环,则只跳出最内层的循环),在循环体结束后立即继续执行。
让我们看一个例子打破 ,在此过程中介绍了其他一些Python特性,并逐行检查:
>>>而真正的:...响应=输入()...如果int(响应)%7= =0:...打破...
我们从a开始而真正的: 对于一个无限循环。在while块的第一条语句中,我们使用内置的输入() 函数向用户请求字符串。我们把这个字符串赋值给一个变量响应 .
现在我们使用if语句来测试所提供的值是否能被7整除。方法将响应字符串转换为整数int () 构造函数,然后使用模运算符,% 除以7,得到余数。如果余数等于0,则响应可以被7整除,然后进入If块体。
在if-块中,现在有两层缩进深,我们从八个空格开始,并使用打破 关键字。打破 终止最内部的循环(在本例中为while循环),并使执行跳转到循环后的第一个语句。
在这里,“语句”是程序的结束。我们在三点提示符处输入空行,关闭if-块和while-块。
我们的循环将开始执行,并在调用输入() 等着我们输入数字。让我们试几个:
673428>>>
只要输入一个能被7整除的数,谓词就变成真正的 ,我们进入if-块,然后从字面上跳出循环,直到程序结束,返回到REPL提示符。
总结
- 从Python开始
- 获取并安装Python
- 启动Read-Eval-Print-Loop或REPL
- 简单的算术
- 通过将对象绑定到名称来创建变量
- 内置打印
print () 函数
- 退出REPL
ctrl - z (Windows)或ctrl - d (Unix)
被预言的
明显的压痕
PEP 8 - Python代码的风格指南
PEP 20 - Python的禅
使用import语句以各种形式导入模块
查找和浏览帮助()
基本类型和控制流
int年代,浮动 年代,没有一个 ,保龄球 ,加上它们之间的转换
用于相等性和排序测试的关系运算符
if指令与其他的 而且elif 块
带有隐式转换的while循环保龄球
中断无限循环ctrl - c
打破循环与打破
从用户请求文本输入()
增广赋值运算符
预览结束
注册解锁剩余的标题。一个>
社区问题
关闭
帮助()
但是,我们如何才能找到在
REPL有一个特殊的功能
要获得帮助,请在提示符处输入“help”:
>>>帮助类型帮助()为互动帮助,orgydF4y2Ba帮助(对象)为帮助关于对象.
我们将让您在自己的时间探索第一种形式-交互式帮助。这里我们选择第二个选项,通过
>>>帮助(数学)模块数学方面的帮助:的名字数学模块引用http://文档.python.org/3.3/图书馆/数学以下文档是自动生成的从Python源文件.可能是不完整的,不正确的orgydF4y2Ba包括以下特性被认为是实现细节而且可能在Python之间有所不同实现.当在怀疑,的模块参考上面列出的地点.描述这个模块是总是可用的.对象的访问由C标准定义的数学函数.功能这些“可信赖医疗组织”(...)这些“可信赖医疗组织”(x)返回arccos(测量在弧度)(x).
你可以使用空格键来翻页帮助,如果你在Mac或Linux上使用方向键来上下滚动。
浏览这些函数,你会看到有一个数学函数,
现在练习使用
>>>帮助(数学.的阶乘)建立帮助-在功能!在模块的数学:的阶乘(...)的阶乘(x)->积分找到x !.引发ValueError如果x是负orgydF4y2Ba非-积分.
按' q '返回REPL。
让我们使用
>>>数学.的阶乘(5)120>>>数学.的阶乘(6)720
注意我们需要如何用模块名称空间限定函数名。这通常是很好的实践,因为它使函数的来源非常清楚。也就是说,它可能导致代码过于冗长。
数水果
数学.的阶乘()
让我们用阶乘来计算从5个水果中抽取3个水果的方法有多少种,使用我们在学校学过的数学:
>>>n=5>>>k=3.>>>数学.的阶乘(n)/(数学.的阶乘(k)*数学.的阶乘(n-k))10.0
这个简单的表达式包含了对数学模块的所有引用,非常冗长。Python
>>>从数学进口的阶乘>>>的阶乘(n)/(的阶乘(k)*的阶乘(n-k))10.0
这是一个很好的改进,但是对于这样一个简单的表达式来说还是有点啰嗦。
import语句的第三种形式允许我们重命名导入的函数。这对于可读性或避免名称空间冲突很有用。虽然它很有用,但是我们建议不要经常使用这个功能,并且要明智地使用:
>>>从数学进口的阶乘作为前沿空中管制官>>>前沿空中管制官(n)/(前沿空中管制官(k)*前沿空中管制官(n-k))10.0
不同类型的数字
记住,当我们用
>>>从数学进口的阶乘作为前沿空中管制官>>>前沿空中管制官(n)//(前沿空中管制官(k)*前沿空中管制官(n-k))10
值得注意的是,许多其他编程语言即使是中等值的
>>>2**31-12147483647
然而,阶乘增长得如此之快,以至于您可以放入32位有符号整数的最大阶乘是12!因为13 !太大:
>>>前沿空中管制官(13)6227020800
在大多数广泛使用的编程语言中,你要么需要更复杂的代码,要么需要更复杂的数学,仅仅是计算从13个水果中抽出3个水果的方法有多少种。
Python不会遇到这样的问题,它可以计算任意大的整数,只受计算机内存的限制。为了进一步证明这一点,让我们尝试一个更大的问题,计算我们可以从100种不同的水果中挑选多少对不同的水果(假设我们可以找到这么多水果!):
>>>n=One hundred.>>>k=2>>>前沿空中管制官(n)//(前沿空中管制官(k)*前沿空中管制官(n-k))4950
只是为了强调这个表达式的第一项有多大,计算100!就其本身而言:
>>>前沿空中管制官(n)93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463\976156518286253697920827223758251185210916864000000000000000000000000
这个数字甚至比已知宇宙中的原子数量还要大得多,有很多数字。如果你像我们一样好奇到底有多少位数字,我们可以将整数转换为文本字符串,并像这样计算其中的字符数:
>>>len(str(前沿空中管制官(n)))158
这肯定有很多数字。还有很多水果。它还开始展示Python的不同数据类型(在本例中是整数、浮点数和文本字符串)如何以自然的方式协同工作。在下一节中,我们将以这一经验为基础,更详细地讨论整数、字符串和其他内置类型。
标量数据类型:整数、浮点数、None和bool
Python自带许多内置数据类型。这些类型包括像整数这样的基本标量类型以及像字典这样的集合类型。这些内置类型功能强大,可以单独用于许多编程需求,并且可以用作创建更复杂数据类型的构建块。
我们将讨论的基本内置标量类型有:
int-带符号的、无限精度的整数
浮动- IEEE 754浮点数
没有一个-一个特殊的、奇异的空值
保龄球- true/false布尔值
现在我们只看它们的基本细节,展示它们的文字形式以及如何创建它们。
int
我们已经见过很多Python整数的应用。Python整数是有符号的,并且在实际应用中具有无限的精度。这意味着它们所能保存的值的大小没有预先定义的限制。
Python中的整数字面量通常以十进制指定:
>>>1010
它们也可以用二进制文件指定0 b 前缀:
>>>b10 02
八进制,带a0啊 前缀:
>>>0 o108
或者带a的十六进制0 x 前缀:
>>>0 x1016
方法也可以构造整数int 构造函数,可以将其他数值类型(如浮点数)转换为整数:
>>>int(3.5)3.
注意,当使用int 构造函数时,舍入总是趋于零:
>>>int(-3.5)-3.>>>int(3.5)3.
我们还可以将字符串转换为整数:
>>>int(“496”)496
但是请注意,如果字符串不表示整数,Python将抛出异常(后面会详细介绍!)。
在从字符串转换时,甚至可以提供一个可选的数字基数。例如,要从以3为基数进行转换,只需将3作为第二个参数传递给构造函数:
>>>int(“10000”,3.)81
浮动
类在Python中支持浮点数浮动 类型。Python浮点数实现为<一个href="https://en.wikipedia.org/wiki/IEEE_floating_point" class="" target="_blank">IEEE-754双精度浮点数一个>具有53位二进制精度。这相当于十进制中的15到16位有效数字。
任何包含小数点的文字数字都被Python解释为浮动 :
>>>3.1253.125
可以使用科学记数法,因此对于较大的数字,例如<我mg width="55" class="lazyload inline justify-self-center" src="https://learnable-static.s3.amazonaws.com/premium/reeedr/books/the-python-apprentice/images/000029.png" alt="3 \ times10 ^ 8gydF4y2Ba" loading="lazy">,即光速的近似速度(以米每秒为单位),可写成:
>>>3 e8300000000.0
以及像普朗克常数这样的小数值<我mg width="104" class="lazyload inline justify-self-center" src="https://learnable-static.s3.amazonaws.com/premium/reeedr/books/the-python-apprentice/images/000011.png" alt="1.616\times10^{- 35}gydF4y2Ba" loading="lazy">我们可以进入:
>>>1.616 e-351.616 e-35
请注意Python如何自动将显示表示转换为最易读的形式。
类将其他数值或字符串类型转换为浮点数浮动 构造函数。例如,构造函数可以接受int :
>>>浮动(7)7.0
或者字符串:
>>>浮动(“1.618”)1.618
特殊的浮点值
通过将某些字符串传递给浮动 构造函数时,可以创建特殊的浮点值南 (简称N 不一个 NUmber)以及正无穷和负无穷:
>>>浮动(“南”)南>>>浮动(“正”)正>>>浮动(“负”)-正
上市推广
计算结果:涉及的任何计算的结果int 而且浮动 被提升为浮动 :
>>>3.0+14.0
你可以阅读更多关于Python的数字类型<一个href="http://docs.python.org/3/library/stdtypes.html" class="" target="_blank">在Python文档中一个>.
没有一个
Python有一个特殊的空值叫做没有一个 ,用大写的“N”拼写。没有一个 常用于表示值的缺失。Python REPL从不打印没有一个 结果,所以打字没有一个 进入REPL没有效果:
>>>没有一个>>>
没有一个可以像其他对象一样绑定到变量名:
>>>一个=没有一个
我们可以测试一个物体是否没有一个 使用Python的是 接线员:
>>>一个是没有一个真正的
我们可以看到这里的响应是真正的 ,这就很方便地把我们带到了保龄球 类型。
保龄球
的保龄球 type表示逻辑状态,在Python的几个控制流结构中扮演着重要的角色,我们很快就会看到。
正如你所期望的,有两个bool值,真正的 而且假 ,都用首字母大写:
>>>真正的真正的>>>假假
还有一个保龄球 构造函数,可用于从其他类型转换为保龄球 .让我们看看它是如何工作的。为int S, 0被认为是“假的”,所有其他值被认为是“真的”:
>>>保龄球(0)假>>>保龄球(42)真正的>>>保龄球(-1)真正的
我们看到同样的行为浮动 S,其中只有0被认为是“假的”:
>>>保龄球(0.0)假>>>保龄球(0.207)真正的>>>保龄球(-1.117)真正的>>>保龄球(浮动(“南”))真正的
当从集合(如字符串或列表)进行转换时,只有空集合被视为“伪集合”。当从列表进行转换时——我们很快就会看到——我们只看到空列表(这里显示为的字面形式)[] )计算为假 :
>>>保龄球([])假>>>保龄球([1,5,9])真正的
类似地,对于字符串只有空字符串,"" ,计算为假 当传递给保龄球 :
>>>保龄球("")假>>>保龄球(“垃圾邮件”)真正的
特别是,不能使用保龄球 的字符串表示形式进行转换真正的 而且假 :
>>>保龄球(“假”)真正的
由于字符串" False "不是空的,它将求值为真正的 !
这些转换为保龄球 是重要的,因为它们在Python的if语句和while循环中被广泛使用保龄球 值。
关系运算符
布尔值通常由Python的关系操作符产生,可用于比较对象。
使用最广泛的两个关系操作符是Python的相等和不相等测试,它们实际上测试值的等价性或不相等性。也就是说,两个对象是等效 如果一个能代替另一个。我们将在本书后面了解更多关于对象等价的概念。现在,我们将比较简单的整数。
让我们从给变量赋值或绑定值开始g :
>>>g=20.
我们测试平等= = :
>>>g= =20.真正的>>>g= =13假
或者用不等式! = :
>>>g! =20.假>>>g! =13真正的
丰富的比较运算符
我们还可以使用丰富的比较运算符来比较数量的顺序。使用< 确定第一个参数是否小于第二个参数:
>>>g<30.真正的
同样,使用> 判断第一个是否大于第二个:
>>>g>30.假
您可以测试小于或等于< = :
>>>g< =20.真正的
大于或等于> = :
>>>g> =20.真正的
如果您有使用其他语言的关系操作符的经验,那么Python的操作符可能一点也不奇怪。请记住,这些运算符比较的是等价性,而不是恒等性,我们将在接下来的章节中详细讨论这一区别。
控制流:if语句和while循环
现在我们已经研究了一些基本的内置类型,让我们看看两个重要的控制流结构,它们依赖于转换到保龄球 类型:if语句和while循环。
条件控制流:if语句
条件语句允许我们基于表达式的值进行分支执行。陈述的形式是如果 关键字,后跟表达式,以冒号结束以引入新块。让我们在REPL试试这个:
>>>如果真正的:
记住在块内缩进四个空格,我们添加一些代码,如果条件为真正的 ,后面跟着一个空行来终止该块:
...打印(“这是真的!”)...这是真的!
此时块将执行,因为不言而喻的条件是真正的 .相反,如果条件是假 ,块中的代码不会执行:
>>>如果假:...打印(“这是真的!”)...>>>
与if语句一起使用的表达式将转换为a保龄球 就好像布尔值() 构造函数已经被使用,因此:
>>>如果保龄球(“鸡蛋”):...打印(“是的,请!”)...是的,请!
完全等价于:
>>>如果“鸡蛋”:...打印(“是的,请!”)...是的,请!
多亏了这个有用的简写,显式转换为保龄球 使用保龄球 构造函数在Python中很少使用。
如果...其他的
if语句支持可选的“else”子句,该子句位于语句引入的块中其他的 关键字(后跟冒号),缩进到与如果 关键字。让我们先创建(但不是结束)一个if-block:
>>>h=42>>>如果h>50:...打印(“大于50”)
开始其他的 在这种情况下,我们只是省略了三个点后的缩进:
...其他的:...打印(“50或以下”)...50orgydF4y2Ba小
如果...elif...其他的
在多种情况下,你可能会这样做:
>>>如果h>50:...打印(“大于50”)...其他的:...如果h<20.:...打印(“少于20”)...其他的:...打印(“20到50岁之间”)...之间的20.而且50
当你发现自己的else-block中包含嵌套的if语句时,你应该考虑使用Python的if语句elif 关键字,这是一个组合else if .
正如Python的禅宗所提醒我们的,“扁平比嵌套好”:
>>>如果h>50:...打印(“大于50”)...elifh<20.:...打印(“少于20”)...其他的:...打印(“20到50岁之间”)...之间的20.而且50
这个版本更容易阅读。
条件重复:while循环
Python有两种类型的循环:for循环和while循环。在介绍重要的空格时,我们已经简单地遇到过for循环,我们很快就会回到它们,但现在我们将介绍while循环。
类引入了Python中的while循环而 关键字,后面跟着一个布尔表达式。与if-语句的条件一样,表达式隐式转换为布尔值,就好像它已传递给布尔值() 构造函数。的而 语句以冒号结束,因为它引入了一个新的块。
让我们在REPL中写一个从5到1的循环。我们将初始化一个计数器变量c 到5,一直循环直到0。这里的另一个新语言特性是使用了增广赋值运算符,- = ,以便在每次迭代时从计数器的值中减去1。类似的增广赋值运算符也存在于其他基本数学运算中,如加法和乘法:
>>>c=5>>>而c! =0:...打印(c)...c- =1...543.21
因为条件(或谓词)将隐式转换为保龄球 ,就好像一声呼唤布尔值() 构造函数存在时,我们可以用以下版本替换上面的代码:
>>>c=5>>>而c:...打印(c)...c- =1...543.21
这是因为整数值的转换c 来保龄球 结果真正的 直到我们得到0,它转化为假 .也就是说,在这种情况下使用这种简短的形式可能会被描述为非Python的,因为,回顾Python的禅宗,显式比隐式更好。我们更看重第一种形式的可读性,而不是第二种形式的简洁。
而在Python中,循环通常用于需要无限循环的地方。我们通过传递来实现这一点真正的 作为while结构的谓词表达式:
>>>而真正的:...打印(“循环!”)...循环!循环!循环!循环!循环!循环!循环!循环!
现在您可能想知道我们如何摆脱这个循环并重新控制我们的REPL!简单的新闻ctrl - c :
循环!循环!循环!循环!循环!循环!^C回溯(最近一次通话):文件“< stdin >”,行2,在<模块>KeyboardInterrupt>>>
Python拦截键击并引发一个终止循环的特殊异常。我们将在后面的第6章中详细讨论异常是什么,以及如何使用它们。
退出循环
打破
许多编程语言都支持将谓词测试放在循环的末尾而不是开头的循环构造。例如,C、c++、c#和Java都支持do-while结构。其他语言也有repeat-until循环。在Python中不是这样,在Python中习惯用法是使用而真正的 加上提前退出,由打破 声明。
的打破 语句跳出循环(如果嵌套了几个循环,则只跳出最内层的循环),在循环体结束后立即继续执行。
让我们看一个例子打破 ,在此过程中介绍了其他一些Python特性,并逐行检查:
>>>而真正的:...响应=输入()...如果int(响应)%7= =0:...打破...
我们从a开始而真正的: 对于一个无限循环。在while块的第一条语句中,我们使用内置的输入() 函数向用户请求字符串。我们把这个字符串赋值给一个变量响应 .
现在我们使用if语句来测试所提供的值是否能被7整除。方法将响应字符串转换为整数int () 构造函数,然后使用模运算符,% 除以7,得到余数。如果余数等于0,则响应可以被7整除,然后进入If块体。
在if-块中,现在有两层缩进深,我们从八个空格开始,并使用打破 关键字。打破 终止最内部的循环(在本例中为while循环),并使执行跳转到循环后的第一个语句。
在这里,“语句”是程序的结束。我们在三点提示符处输入空行,关闭if-块和while-块。
我们的循环将开始执行,并在调用输入() 等着我们输入数字。让我们试几个:
673428>>>
只要输入一个能被7整除的数,谓词就变成真正的 ,我们进入if-块,然后从字面上跳出循环,直到程序结束,返回到REPL提示符。
总结
- 从Python开始
- 获取并安装Python
- 启动Read-Eval-Print-Loop或REPL
- 简单的算术
- 通过将对象绑定到名称来创建变量
- 内置打印
print () 函数
- 退出REPL
ctrl - z (Windows)或ctrl - d (Unix)
被预言的
明显的压痕
PEP 8 - Python代码的风格指南
PEP 20 - Python的禅
使用import语句以各种形式导入模块
查找和浏览帮助()
基本类型和控制流
int年代,浮动 年代,没有一个 ,保龄球 ,加上它们之间的转换
用于相等性和排序测试的关系运算符
if指令与其他的 而且elif 块
带有隐式转换的while循环保龄球
中断无限循环ctrl - c
打破循环与打破
从用户请求文本输入()
增广赋值运算符
预览结束
注册解锁剩余的标题。一个>
社区问题
关闭
Python自带许多内置数据类型。这些类型包括像整数这样的基本标量类型以及像字典这样的集合类型。这些内置类型功能强大,可以单独用于许多编程需求,并且可以用作创建更复杂数据类型的构建块。
我们将讨论的基本内置标量类型有:
int-带符号的、无限精度的整数
浮动- IEEE 754浮点数
没有一个-一个特殊的、奇异的空值
保龄球- true/false布尔值
现在我们只看它们的基本细节,展示它们的文字形式以及如何创建它们。
int
我们已经见过很多Python整数的应用。Python整数是有符号的,并且在实际应用中具有无限的精度。这意味着它们所能保存的值的大小没有预先定义的限制。
Python中的整数字面量通常以十进制指定:
>>>1010
它们也可以用二进制文件指定
>>>b10 02
八进制,带a
>>>0 o108
或者带a的十六进制
>>>0 x1016
方法也可以构造整数
>>>int(3.5)3.
注意,当使用
>>>int(-3.5)-3.>>>int(3.5)3.
我们还可以将字符串转换为整数:
>>>int(“496”)496
但是请注意,如果字符串不表示整数,Python将抛出异常(后面会详细介绍!)。
在从字符串转换时,甚至可以提供一个可选的数字基数。例如,要从以3为基数进行转换,只需将3作为第二个参数传递给构造函数:
>>>int(“10000”,3.)81
浮动
类在Python中支持浮点数
任何包含小数点的文字数字都被Python解释为
>>>3.1253.125
可以使用科学记数法,因此对于较大的数字,例如<我mg width="55" class="lazyload inline justify-self-center" src="https://learnable-static.s3.amazonaws.com/premium/reeedr/books/the-python-apprentice/images/000029.png" alt="3 \ times10 ^ 8gydF4y2Ba" loading="lazy">,即光速的近似速度(以米每秒为单位),可写成:
>>>3 e8300000000.0
以及像普朗克常数这样的小数值<我mg width="104" class="lazyload inline justify-self-center" src="https://learnable-static.s3.amazonaws.com/premium/reeedr/books/the-python-apprentice/images/000011.png" alt="1.616\times10^{- 35}gydF4y2Ba" loading="lazy">我们可以进入:
>>>1.616 e-351.616 e-35
请注意Python如何自动将显示表示转换为最易读的形式。
类将其他数值或字符串类型转换为浮点数
>>>浮动(7)7.0
或者字符串:
>>>浮动(“1.618”)1.618
特殊的浮点值
通过将某些字符串传递给
>>>浮动(“南”)南>>>浮动(“正”)正>>>浮动(“负”)-正
上市推广
计算结果:涉及的任何计算的结果
>>>3.0+14.0
你可以阅读更多关于Python的数字类型<一个href="http://docs.python.org/3/library/stdtypes.html" class="" target="_blank">在Python文档中一个>.
没有一个
Python有一个特殊的空值叫做
>>>没有一个>>>
没有一个可以像其他对象一样绑定到变量名:
>>>一个=没有一个
我们可以测试一个物体是否
>>>一个是没有一个真正的
我们可以看到这里的响应是
保龄球
的
正如你所期望的,有两个bool值,
>>>真正的真正的>>>假假
还有一个
>>>保龄球(0)假>>>保龄球(42)真正的>>>保龄球(-1)真正的
我们看到同样的行为
>>>保龄球(0.0)假>>>保龄球(0.207)真正的>>>保龄球(-1.117)真正的>>>保龄球(浮动(“南”))真正的
当从集合(如字符串或列表)进行转换时,只有空集合被视为“伪集合”。当从列表进行转换时——我们很快就会看到——我们只看到空列表(这里显示为的字面形式)
>>>保龄球([])假>>>保龄球([1,5,9])真正的
类似地,对于字符串只有空字符串,
>>>保龄球("")假>>>保龄球(“垃圾邮件”)真正的
特别是,不能使用
>>>保龄球(“假”)真正的
由于字符串" False "不是空的,它将求值为
这些转换为
关系运算符
布尔值通常由Python的关系操作符产生,可用于比较对象。
使用最广泛的两个关系操作符是Python的相等和不相等测试,它们实际上测试值的等价性或不相等性。也就是说,两个对象是等效 如果一个能代替另一个。我们将在本书后面了解更多关于对象等价的概念。现在,我们将比较简单的整数。
让我们从给变量赋值或绑定值开始g :
>>>g=20.
我们测试平等= = :
>>>g= =20.真正的>>>g= =13假
或者用不等式! = :
>>>g! =20.假>>>g! =13真正的
丰富的比较运算符
我们还可以使用丰富的比较运算符来比较数量的顺序。使用< 确定第一个参数是否小于第二个参数:
>>>g<30.真正的
同样,使用> 判断第一个是否大于第二个:
>>>g>30.假
您可以测试小于或等于< = :
>>>g< =20.真正的
大于或等于> = :
>>>g> =20.真正的
如果您有使用其他语言的关系操作符的经验,那么Python的操作符可能一点也不奇怪。请记住,这些运算符比较的是等价性,而不是恒等性,我们将在接下来的章节中详细讨论这一区别。
控制流:if语句和while循环
现在我们已经研究了一些基本的内置类型,让我们看看两个重要的控制流结构,它们依赖于转换到保龄球 类型:if语句和while循环。
条件控制流:if语句
条件语句允许我们基于表达式的值进行分支执行。陈述的形式是如果 关键字,后跟表达式,以冒号结束以引入新块。让我们在REPL试试这个:
>>>如果真正的:
记住在块内缩进四个空格,我们添加一些代码,如果条件为真正的 ,后面跟着一个空行来终止该块:
...打印(“这是真的!”)...这是真的!
此时块将执行,因为不言而喻的条件是真正的 .相反,如果条件是假 ,块中的代码不会执行:
>>>如果假:...打印(“这是真的!”)...>>>
与if语句一起使用的表达式将转换为a保龄球 就好像布尔值() 构造函数已经被使用,因此:
>>>如果保龄球(“鸡蛋”):...打印(“是的,请!”)...是的,请!
完全等价于:
>>>如果“鸡蛋”:...打印(“是的,请!”)...是的,请!
多亏了这个有用的简写,显式转换为保龄球 使用保龄球 构造函数在Python中很少使用。
如果...其他的
if语句支持可选的“else”子句,该子句位于语句引入的块中其他的 关键字(后跟冒号),缩进到与如果 关键字。让我们先创建(但不是结束)一个if-block:
>>>h=42>>>如果h>50:...打印(“大于50”)
开始其他的 在这种情况下,我们只是省略了三个点后的缩进:
...其他的:...打印(“50或以下”)...50orgydF4y2Ba小
如果...elif...其他的
在多种情况下,你可能会这样做:
>>>如果h>50:...打印(“大于50”)...其他的:...如果h<20.:...打印(“少于20”)...其他的:...打印(“20到50岁之间”)...之间的20.而且50
当你发现自己的else-block中包含嵌套的if语句时,你应该考虑使用Python的if语句elif 关键字,这是一个组合else if .
正如Python的禅宗所提醒我们的,“扁平比嵌套好”:
>>>如果h>50:...打印(“大于50”)...elifh<20.:...打印(“少于20”)...其他的:...打印(“20到50岁之间”)...之间的20.而且50
这个版本更容易阅读。
条件重复:while循环
Python有两种类型的循环:for循环和while循环。在介绍重要的空格时,我们已经简单地遇到过for循环,我们很快就会回到它们,但现在我们将介绍while循环。
类引入了Python中的while循环而 关键字,后面跟着一个布尔表达式。与if-语句的条件一样,表达式隐式转换为布尔值,就好像它已传递给布尔值() 构造函数。的而 语句以冒号结束,因为它引入了一个新的块。
让我们在REPL中写一个从5到1的循环。我们将初始化一个计数器变量c 到5,一直循环直到0。这里的另一个新语言特性是使用了增广赋值运算符,- = ,以便在每次迭代时从计数器的值中减去1。类似的增广赋值运算符也存在于其他基本数学运算中,如加法和乘法:
>>>c=5>>>而c! =0:...打印(c)...c- =1...543.21
因为条件(或谓词)将隐式转换为保龄球 ,就好像一声呼唤布尔值() 构造函数存在时,我们可以用以下版本替换上面的代码:
>>>c=5>>>而c:...打印(c)...c- =1...543.21
这是因为整数值的转换c 来保龄球 结果真正的 直到我们得到0,它转化为假 .也就是说,在这种情况下使用这种简短的形式可能会被描述为非Python的,因为,回顾Python的禅宗,显式比隐式更好。我们更看重第一种形式的可读性,而不是第二种形式的简洁。
而在Python中,循环通常用于需要无限循环的地方。我们通过传递来实现这一点真正的 作为while结构的谓词表达式:
>>>而真正的:...打印(“循环!”)...循环!循环!循环!循环!循环!循环!循环!循环!
现在您可能想知道我们如何摆脱这个循环并重新控制我们的REPL!简单的新闻ctrl - c :
循环!循环!循环!循环!循环!循环!^C回溯(最近一次通话):文件“< stdin >”,行2,在<模块>KeyboardInterrupt>>>
Python拦截键击并引发一个终止循环的特殊异常。我们将在后面的第6章中详细讨论异常是什么,以及如何使用它们。
退出循环
打破
许多编程语言都支持将谓词测试放在循环的末尾而不是开头的循环构造。例如,C、c++、c#和Java都支持do-while结构。其他语言也有repeat-until循环。在Python中不是这样,在Python中习惯用法是使用而真正的 加上提前退出,由打破 声明。
的打破 语句跳出循环(如果嵌套了几个循环,则只跳出最内层的循环),在循环体结束后立即继续执行。
让我们看一个例子打破 ,在此过程中介绍了其他一些Python特性,并逐行检查:
>>>而真正的:...响应=输入()...如果int(响应)%7= =0:...打破...
我们从a开始而真正的: 对于一个无限循环。在while块的第一条语句中,我们使用内置的输入() 函数向用户请求字符串。我们把这个字符串赋值给一个变量响应 .
现在我们使用if语句来测试所提供的值是否能被7整除。方法将响应字符串转换为整数int () 构造函数,然后使用模运算符,% 除以7,得到余数。如果余数等于0,则响应可以被7整除,然后进入If块体。
在if-块中,现在有两层缩进深,我们从八个空格开始,并使用打破 关键字。打破 终止最内部的循环(在本例中为while循环),并使执行跳转到循环后的第一个语句。
在这里,“语句”是程序的结束。我们在三点提示符处输入空行,关闭if-块和while-块。
我们的循环将开始执行,并在调用输入() 等着我们输入数字。让我们试几个:
673428>>>
只要输入一个能被7整除的数,谓词就变成真正的 ,我们进入if-块,然后从字面上跳出循环,直到程序结束,返回到REPL提示符。
总结
- 从Python开始
- 获取并安装Python
- 启动Read-Eval-Print-Loop或REPL
- 简单的算术
- 通过将对象绑定到名称来创建变量
- 内置打印
print () 函数
- 退出REPL
ctrl - z (Windows)或ctrl - d (Unix)
被预言的
明显的压痕
PEP 8 - Python代码的风格指南
PEP 20 - Python的禅
使用import语句以各种形式导入模块
查找和浏览帮助()
基本类型和控制流
int年代,浮动 年代,没有一个 ,保龄球 ,加上它们之间的转换
用于相等性和排序测试的关系运算符
if指令与其他的 而且elif 块
带有隐式转换的while循环保龄球
中断无限循环ctrl - c
打破循环与打破
从用户请求文本输入()
增广赋值运算符
预览结束
注册解锁剩余的标题。一个>
社区问题
关闭
布尔值通常由Python的关系操作符产生,可用于比较对象。
使用最广泛的两个关系操作符是Python的相等和不相等测试,它们实际上测试值的等价性或不相等性。也就是说,两个对象是
让我们从给变量赋值或绑定值开始
>>>g=20.
我们测试平等
>>>g= =20.真正的>>>g= =13假
或者用不等式
>>>g! =20.假>>>g! =13真正的
丰富的比较运算符
我们还可以使用丰富的比较运算符来比较数量的顺序。使用
>>>g<30.真正的
同样,使用
>>>g>30.假
您可以测试小于或等于
>>>g< =20.真正的
大于或等于
>>>g> =20.真正的
如果您有使用其他语言的关系操作符的经验,那么Python的操作符可能一点也不奇怪。请记住,这些运算符比较的是等价性,而不是恒等性,我们将在接下来的章节中详细讨论这一区别。
控制流:if语句和while循环
现在我们已经研究了一些基本的内置类型,让我们看看两个重要的控制流结构,它们依赖于转换到保龄球 类型:if语句和while循环。
条件控制流:if语句
条件语句允许我们基于表达式的值进行分支执行。陈述的形式是如果 关键字,后跟表达式,以冒号结束以引入新块。让我们在REPL试试这个:
>>>如果真正的:
记住在块内缩进四个空格,我们添加一些代码,如果条件为真正的 ,后面跟着一个空行来终止该块:
...打印(“这是真的!”)...这是真的!
此时块将执行,因为不言而喻的条件是真正的 .相反,如果条件是假 ,块中的代码不会执行:
>>>如果假:...打印(“这是真的!”)...>>>
与if语句一起使用的表达式将转换为a保龄球 就好像布尔值() 构造函数已经被使用,因此:
>>>如果保龄球(“鸡蛋”):...打印(“是的,请!”)...是的,请!
完全等价于:
>>>如果“鸡蛋”:...打印(“是的,请!”)...是的,请!
多亏了这个有用的简写,显式转换为保龄球 使用保龄球 构造函数在Python中很少使用。
如果...其他的
if语句支持可选的“else”子句,该子句位于语句引入的块中其他的 关键字(后跟冒号),缩进到与如果 关键字。让我们先创建(但不是结束)一个if-block:
>>>h=42>>>如果h>50:...打印(“大于50”)
开始其他的 在这种情况下,我们只是省略了三个点后的缩进:
...其他的:...打印(“50或以下”)...50orgydF4y2Ba小
如果...elif...其他的
在多种情况下,你可能会这样做:
>>>如果h>50:...打印(“大于50”)...其他的:...如果h<20.:...打印(“少于20”)...其他的:...打印(“20到50岁之间”)...之间的20.而且50
当你发现自己的else-block中包含嵌套的if语句时,你应该考虑使用Python的if语句elif 关键字,这是一个组合else if .
正如Python的禅宗所提醒我们的,“扁平比嵌套好”:
>>>如果h>50:...打印(“大于50”)...elifh<20.:...打印(“少于20”)...其他的:...打印(“20到50岁之间”)...之间的20.而且50
这个版本更容易阅读。
条件重复:while循环
Python有两种类型的循环:for循环和while循环。在介绍重要的空格时,我们已经简单地遇到过for循环,我们很快就会回到它们,但现在我们将介绍while循环。
类引入了Python中的while循环而 关键字,后面跟着一个布尔表达式。与if-语句的条件一样,表达式隐式转换为布尔值,就好像它已传递给布尔值() 构造函数。的而 语句以冒号结束,因为它引入了一个新的块。
让我们在REPL中写一个从5到1的循环。我们将初始化一个计数器变量c 到5,一直循环直到0。这里的另一个新语言特性是使用了增广赋值运算符,- = ,以便在每次迭代时从计数器的值中减去1。类似的增广赋值运算符也存在于其他基本数学运算中,如加法和乘法:
>>>c=5>>>而c! =0:...打印(c)...c- =1...543.21
因为条件(或谓词)将隐式转换为保龄球 ,就好像一声呼唤布尔值() 构造函数存在时,我们可以用以下版本替换上面的代码:
>>>c=5>>>而c:...打印(c)...c- =1...543.21
这是因为整数值的转换c 来保龄球 结果真正的 直到我们得到0,它转化为假 .也就是说,在这种情况下使用这种简短的形式可能会被描述为非Python的,因为,回顾Python的禅宗,显式比隐式更好。我们更看重第一种形式的可读性,而不是第二种形式的简洁。
而在Python中,循环通常用于需要无限循环的地方。我们通过传递来实现这一点真正的 作为while结构的谓词表达式:
>>>而真正的:...打印(“循环!”)...循环!循环!循环!循环!循环!循环!循环!循环!
现在您可能想知道我们如何摆脱这个循环并重新控制我们的REPL!简单的新闻ctrl - c :
循环!循环!循环!循环!循环!循环!^C回溯(最近一次通话):文件“< stdin >”,行2,在<模块>KeyboardInterrupt>>>
Python拦截键击并引发一个终止循环的特殊异常。我们将在后面的第6章中详细讨论异常是什么,以及如何使用它们。
退出循环
打破
许多编程语言都支持将谓词测试放在循环的末尾而不是开头的循环构造。例如,C、c++、c#和Java都支持do-while结构。其他语言也有repeat-until循环。在Python中不是这样,在Python中习惯用法是使用而真正的 加上提前退出,由打破 声明。
的打破 语句跳出循环(如果嵌套了几个循环,则只跳出最内层的循环),在循环体结束后立即继续执行。
让我们看一个例子打破 ,在此过程中介绍了其他一些Python特性,并逐行检查:
>>>而真正的:...响应=输入()...如果int(响应)%7= =0:...打破...
我们从a开始而真正的: 对于一个无限循环。在while块的第一条语句中,我们使用内置的输入() 函数向用户请求字符串。我们把这个字符串赋值给一个变量响应 .
现在我们使用if语句来测试所提供的值是否能被7整除。方法将响应字符串转换为整数int () 构造函数,然后使用模运算符,% 除以7,得到余数。如果余数等于0,则响应可以被7整除,然后进入If块体。
在if-块中,现在有两层缩进深,我们从八个空格开始,并使用打破 关键字。打破 终止最内部的循环(在本例中为while循环),并使执行跳转到循环后的第一个语句。
在这里,“语句”是程序的结束。我们在三点提示符处输入空行,关闭if-块和while-块。
我们的循环将开始执行,并在调用输入() 等着我们输入数字。让我们试几个:
673428>>>
只要输入一个能被7整除的数,谓词就变成真正的 ,我们进入if-块,然后从字面上跳出循环,直到程序结束,返回到REPL提示符。
总结
- 从Python开始
- 获取并安装Python
- 启动Read-Eval-Print-Loop或REPL
- 简单的算术
- 通过将对象绑定到名称来创建变量
- 内置打印
print () 函数
- 退出REPL
ctrl - z (Windows)或ctrl - d (Unix)
被预言的
明显的压痕
PEP 8 - Python代码的风格指南
PEP 20 - Python的禅
使用import语句以各种形式导入模块
查找和浏览帮助()
基本类型和控制流
int年代,浮动 年代,没有一个 ,保龄球 ,加上它们之间的转换
用于相等性和排序测试的关系运算符
if指令与其他的 而且elif 块
带有隐式转换的while循环保龄球
中断无限循环ctrl - c
打破循环与打破
从用户请求文本输入()
增广赋值运算符
预览结束
注册解锁剩余的标题。一个>
社区问题
关闭
现在我们已经研究了一些基本的内置类型,让我们看看两个重要的控制流结构,它们依赖于转换到
条件控制流:if语句
条件语句允许我们基于表达式的值进行分支执行。陈述的形式是
>>>如果真正的:
记住在块内缩进四个空格,我们添加一些代码,如果条件为
...打印(“这是真的!”)...这是真的!
此时块将执行,因为不言而喻的条件是
>>>如果假:...打印(“这是真的!”)...>>>
与if语句一起使用的表达式将转换为a
>>>如果保龄球(“鸡蛋”):...打印(“是的,请!”)...是的,请!
完全等价于:
>>>如果“鸡蛋”:...打印(“是的,请!”)...是的,请!
多亏了这个有用的简写,显式转换为
如果...其他的
if语句支持可选的“else”子句,该子句位于语句引入的块中
>>>h=42>>>如果h>50:...打印(“大于50”)
开始
...其他的:...打印(“50或以下”)...50orgydF4y2Ba小
如果...elif...其他的
在多种情况下,你可能会这样做:
>>>如果h>50:...打印(“大于50”)...其他的:...如果h<20.:...打印(“少于20”)...其他的:...打印(“20到50岁之间”)...之间的20.而且50
当你发现自己的else-block中包含嵌套的if语句时,你应该考虑使用Python的if语句
正如Python的禅宗所提醒我们的,“扁平比嵌套好”:
>>>如果h>50:...打印(“大于50”)...elifh<20.:...打印(“少于20”)...其他的:...打印(“20到50岁之间”)...之间的20.而且50
这个版本更容易阅读。
条件重复:while循环
Python有两种类型的循环:for循环和while循环。在介绍重要的空格时,我们已经简单地遇到过for循环,我们很快就会回到它们,但现在我们将介绍while循环。
类引入了Python中的while循环
让我们在REPL中写一个从5到1的循环。我们将初始化一个计数器变量
>>>c=5>>>而c! =0:...打印(c)...c- =1...543.21
因为条件(或谓词)将隐式转换为
>>>c=5>>>而c:...打印(c)...c- =1...543.21
这是因为整数值的转换
而在Python中,循环通常用于需要无限循环的地方。我们通过传递来实现这一点
>>>而真正的:...打印(“循环!”)...循环!循环!循环!循环!循环!循环!循环!循环!
现在您可能想知道我们如何摆脱这个循环并重新控制我们的REPL!简单的新闻
循环!循环!循环!循环!循环!循环!^C回溯(最近一次通话):文件“< stdin >”,行2,在<模块>KeyboardInterrupt>>>
Python拦截键击并引发一个终止循环的特殊异常。我们将在后面的第6章中详细讨论异常是什么,以及如何使用它们。
退出循环
打破
许多编程语言都支持将谓词测试放在循环的末尾而不是开头的循环构造。例如,C、c++、c#和Java都支持do-while结构。其他语言也有repeat-until循环。在Python中不是这样,在Python中习惯用法是使用
的
让我们看一个例子
>>>而真正的:...响应=输入()...如果int(响应)%7= =0:...打破...
我们从a开始
现在我们使用if语句来测试所提供的值是否能被7整除。方法将响应字符串转换为整数
在if-块中,现在有两层缩进深,我们从八个空格开始,并使用
在这里,“语句”是程序的结束。我们在三点提示符处输入空行,关闭if-块和while-块。
我们的循环将开始执行,并在调用
673428>>>
只要输入一个能被7整除的数,谓词就变成
总结
- 从Python开始
- 获取并安装Python
- 启动Read-Eval-Print-Loop或REPL
- 简单的算术
- 通过将对象绑定到名称来创建变量
- 内置打印
print () 函数
- 退出REPL
ctrl - z (Windows)或ctrl - d (Unix)
被预言的
明显的压痕
PEP 8 - Python代码的风格指南
PEP 20 - Python的禅
使用import语句以各种形式导入模块
查找和浏览帮助()
基本类型和控制流
int年代,浮动 年代,没有一个 ,保龄球 ,加上它们之间的转换
用于相等性和排序测试的关系运算符
if指令与其他的 而且elif 块
带有隐式转换的while循环保龄球
中断无限循环ctrl - c
打破循环与打破
从用户请求文本输入()
增广赋值运算符
预览结束
注册解锁剩余的标题。一个>
- 从Python开始
- 获取并安装Python
- 启动Read-Eval-Print-Loop或REPL
- 简单的算术
- 通过将对象绑定到名称来创建变量
- 内置打印
print () 函数- 退出REPL
ctrl - z (Windows)或ctrl - d (Unix)
int年代,浮动 年代,没有一个 ,保龄球 ,加上它们之间的转换
用于相等性和排序测试的关系运算符
if指令与其他的 而且elif 块
带有隐式转换的while循环保龄球
中断无限循环ctrl - c
打破循环与打破