1
00:00:00,150 --> 00:00:04,560
在这门课中，我将教给你们所有你们需要知道的东西来开始编程


2
00:00:04,590 --> 00:00:05,310
python，


3
00:00:05,700 --> 00:00:09,270
python是最流行的编程语言之一，


4
00:00:09,450 --> 00:00:13,200
这是迄今为止最受追捧的工作之一


5
00:00:13,410 --> 00:00:14,910
所以如果你想找一份工作


6
00:00:14,940 --> 00:00:16,170
或者你想知道，


7
00:00:16,230 --> 00:00:17,460
使你的生活自动化


8
00:00:17,520 --> 00:00:20,580
或者你试着写一些很棒的脚本来做一些不同的事情


9
00:00:20,610 --> 00:00:21,840
为你准备的


10
00:00:21,990 --> 00:00:22,410
诚实地


11
00:00:22,440 --> 00:00:27,600
越来越多的开发人员将他们的项目转移到python上，因为它非常强大


12
00:00:27,780 --> 00:00:28,350
还有外科医生


13
00:00:28,380 --> 00:00:29,640
易于使用的语言，


14
00:00:29,910 --> 00:00:33,330
很多编程语言都不是初学者友好的


15
00:00:33,690 --> 00:00:38,490
很多语法都有很多类似的东西如果你错了，程序会对你大吼大叫。


16
00:00:38,700 --> 00:00:39,930
python是完整的


17
00:00:39,960 --> 00:00:40,890
与此相反。


18
00:00:41,010 --> 00:00:45,660
你只要输入你想要在python里做的事情就行了就是这么简单，没有


19
00:00:45,870 --> 00:00:50,460
学习曲线的很多语法都是零，你跳进去，


20
00:00:50,610 --> 00:00:53,100
你可以在几秒钟内开始编写你的第一个程序。


21
00:00:53,370 --> 00:00:54,180
在这门课上


22
00:00:54,210 --> 00:00:55,260
我要教你们。


23
00:00:55,470 --> 00:00:57,840
您需要知道的一切都是从python开始的。


24
00:00:58,020 --> 00:00:59,070
我设计了这门课


25
00:00:59,100 --> 00:01:00,840
特别是对于python来说，


26
00:01:00,960 --> 00:01:03,810
每节课都是用例子特别设计的


27
00:01:03,840 --> 00:01:05,130
这将对你有帮助。


28
00:01:05,190 --> 00:01:07,800
有这么多人开始学习python，问题不是，


29
00:01:08,010 --> 00:01:11,130
为什么你要在这个问题上学习，为什么你不应该学习呢？


30
00:01:11,460 --> 00:01:17,910
我认为对于很多人来说他们不想学习python的原因是因为他们害怕或者害怕这会变得太难。


31
00:01:18,240 --> 00:01:24,810
相信我，我将在这整个课程中掌握你的手我们将会讨论所有的关于python的核心概念我们将会讲到


32
00:01:25,170 --> 00:01:26,490
你需要知道的一切


33
00:01:26,580 --> 00:01:34,110
要开始用python编程，开始自信就可以编写脚本，开始编写那些在你的生活中做一些很酷的事情的程序。


34
00:01:34,320 --> 00:01:34,800
无论如何


35
00:01:34,890 --> 00:01:37,140
我被灌输给了你们这些人。


36
00:01:37,200 --> 00:01:38,850
我等不及要开始这门课了


37
00:01:38,880 --> 00:01:44,100
我希望你们能在这门课上继续学习并学习这门神奇的编程语言


38
00:01:48,150 --> 00:01:52,320
在本教程中，三个人将如何在您的计算机上安装python。


39
00:01:52,650 --> 00:01:56,220
我们还会安装一个文本编辑器我们可以用它来写


40
00:01:56,250 --> 00:01:57,720
我们的python程序


41
00:01:57,780 --> 00:01:58,110
在。


42
00:01:58,590 --> 00:02:01,560
第一个订单是实际安装


43
00:02:01,590 --> 00:02:03,360
在你的电脑上使用python。


44
00:02:03,660 --> 00:02:06,120
所以我们要做的是浏览网页浏览器


45
00:02:06,630 --> 00:02:07,140
并且


46
00:02:07,170 --> 00:02:09,330
你想要到这个页面，它只是


47
00:02:09,690 --> 00:02:12,180
www。dot python。org


48
00:02:12,210 --> 00:02:13,260
正斜杠


49
00:02:13,290 --> 00:02:14,130
下载


50
00:02:14,430 --> 00:02:14,940
在这个问题上


51
00:02:14,970 --> 00:02:15,780
页面上有


52
00:02:15,810 --> 00:02:16,350
即将成为


53
00:02:16,380 --> 00:02:17,700
下面有两个按钮


54
00:02:18,030 --> 00:02:21,540
这是下载python三点六。3。


55
00:02:21,990 --> 00:02:22,590
至少


56
00:02:22,620 --> 00:02:26,850
我现在的版本，或者下载python二点七，点四。


57
00:02:27,420 --> 00:02:31,770
这是关于python的事情实际上有两个主要版本的python


58
00:02:31,800 --> 00:02:32,940
正在使用中


59
00:02:32,970 --> 00:02:33,570
目前


60
00:02:33,930 --> 00:02:34,440
有


61
00:02:34,470 --> 00:02:35,640
python 2


62
00:02:35,700 --> 00:02:38,130
这里有一些你可以看到的python理论，


63
00:02:38,340 --> 00:02:40,920
这是二点七。1。4


64
00:02:41,610 --> 00:02:43,890
基本上任何一个python2


65
00:02:43,980 --> 00:02:46,170
版本，我们只称它为python2


66
00:02:46,440 --> 00:02:47,670
这是最新的


67
00:02:47,700 --> 00:02:49,200
python 3版本。


68
00:02:49,380 --> 00:02:55,230
这是两个版本，你可以下载，我们首先要决定我们要下载哪个版本。


69
00:02:55,500 --> 00:02:56,760
这是基本的区别


70
00:02:56,820 --> 00:02:57,540
蟒蛇


71
00:02:57,570 --> 00:02:58,230
二


72
00:02:58,500 --> 00:03:01,920
是python的遗留版本，这基本上意味着


73
00:03:02,160 --> 00:03:02,760
就像


74
00:03:02,790 --> 00:03:07,170
旧版本，它不像积极维护或支持


75
00:03:07,350 --> 00:03:09,570
就像python的官方语言一样。


76
00:03:10,410 --> 00:03:16,830
3就像python的未来一样它就像最新的版本它是一个被积极维护和支持的版本。


77
00:03:17,130 --> 00:03:19,830
所以选择哪一个都是有利有弊的


78
00:03:20,490 --> 00:03:22,770
很多人也会说，像python一样


79
00:03:22,830 --> 00:03:25,440
已经存在了很长时间，所以更像是


80
00:03:25,590 --> 00:03:30,270
在python中，基本上只有更多的python代码


81
00:03:30,600 --> 00:03:35,400
因此，在管道中你可以做更多的事情你可以在python3里做


82
00:03:35,730 --> 00:03:36,630
但话说回来


83
00:03:36,780 --> 00:03:38,880
python 2不受支持，你知道，


84
00:03:38,970 --> 00:03:40,350
五到十年后


85
00:03:40,380 --> 00:03:42,120
可能没有人会使用它。


86
00:03:42,810 --> 00:03:47,100
python 3，它就像一个网站就像python的未来它是最新的版本它是那个


87
00:03:47,130 --> 00:03:49,800
你知道这是一种持续的维护。


88
00:03:50,280 --> 00:03:53,460
因此，为了本教程的目的，我将教大家


89
00:03:53,490 --> 00:03:54,240
蟒蛇


90
00:03:54,270 --> 00:03:55,020
三


91
00:03:55,200 --> 00:03:57,120
所以我们要下载python


92
00:03:57,840 --> 00:03:58,860
这是模糊的


93
00:03:59,040 --> 00:04:03,450
如果你学习了python3，或者你学习python的区别并不大。


94
00:04:03,720 --> 00:04:07,050
有一些区别就像一些语法一样


95
00:04:07,080 --> 00:04:08,700
你知道这里和那里的小事情，


96
00:04:08,760 --> 00:04:11,700
但是如果你学习了python3，你就能直接跳进去


97
00:04:11,730 --> 00:04:14,610
在python2里的代码也不要让任何人


98
00:04:14,940 --> 00:04:15,630
告诉你


99
00:04:15,720 --> 00:04:17,040
你必须学习其中的一个。


100
00:04:17,100 --> 00:04:21,840
我们将学习python 3，因为我认为这可能是初学者学习的最好方法。


101
00:04:22,050 --> 00:04:26,159
这就是我们想要下载的所以我要点击下载python3


102
00:04:26,489 --> 00:04:27,749
我们将继续下载


103
00:04:27,779 --> 00:04:28,649
这个版本。


104
00:04:29,009 --> 00:04:33,089
当下载完成后，我将进入我的下载文件夹


105
00:04:33,989 --> 00:04:35,969
你会看到这里我们有这个文件


106
00:04:36,989 --> 00:04:37,679
doubleclick，


107
00:04:37,949 --> 00:04:41,609
我们得到了这个，像python安装程序，所以我要点击这里，


108
00:04:42,029 --> 00:04:45,359
我们可以在电脑上安装python 3


109
00:04:45,509 --> 00:04:51,449
当它完成的时候我们可以把它关掉我们应该开始得到我们现在有了python3


110
00:04:51,719 --> 00:04:53,159
安装在我们的电脑上。


111
00:04:53,549 --> 00:04:54,479
下一步


112
00:04:54,509 --> 00:04:56,399
我们需要选择一个文本


113
00:04:56,429 --> 00:04:57,239
编辑


114
00:04:57,899 --> 00:05:04,529
我们将会写一堆代码，所以我们需要一些程序的环境我们可以把所有的代码都写进去。


115
00:05:04,829 --> 00:05:09,959
实际上，你可以在任何文本编辑器中编写python，你可以把它写成一个便签本，或者对它征税，


116
00:05:10,199 --> 00:05:11,099
这并不重要


117
00:05:11,339 --> 00:05:13,019
但是有一些特殊的


118
00:05:13,049 --> 00:05:14,699
设计的文本编辑器


119
00:05:14,729 --> 00:05:16,979
只是为了编写python代码。


120
00:05:17,249 --> 00:05:18,209
这些被称为


121
00:05:18,269 --> 00:05:20,129
我很轻松，不代表


122
00:05:20,159 --> 00:05:22,019
集成开发环境。


123
00:05:22,379 --> 00:05:27,269
它基本上只是一个特殊的环境，我们可以让你知道ron并执行我们的python代码。


124
00:05:27,479 --> 00:05:30,569
它会告诉我们我们是怎么做的


125
00:05:30,629 --> 00:05:32,879
如果我们写错了或者我们写错了


126
00:05:32,909 --> 00:05:34,109
有错误，它会


127
00:05:34,529 --> 00:05:37,259
指出我们需要做的正确的事情来解决这些问题，


128
00:05:37,649 --> 00:05:39,779
在本课程中，我们将使用一个概念


129
00:05:39,809 --> 00:05:40,229
并且


130
00:05:40,259 --> 00:05:41,219
我最喜欢的一个


131
00:05:41,249 --> 00:05:44,879
对于python来说，最流行的一种是pi魅力。


132
00:05:45,239 --> 00:05:46,889
我在这个网站上。


133
00:05:46,949 --> 00:05:47,489
它叫做


134
00:05:47,519 --> 00:05:48,599
喷气脑


135
00:05:48,629 --> 00:05:49,559
网络公司


136
00:05:49,589 --> 00:05:50,519
正斜杠


137
00:05:50,549 --> 00:05:51,329
派魅力。


138
00:05:51,659 --> 00:05:54,569
这就是我们在这门课中要用到的概念


139
00:05:54,599 --> 00:05:57,029
所以我要到这里点击这个大的下载


140
00:05:57,059 --> 00:05:57,809
按钮


141
00:05:58,319 --> 00:05:59,668
然后我们继续


142
00:05:59,698 --> 00:06:00,629
下载这个


143
00:06:00,659 --> 00:06:01,979
馅饼魅力计划


144
00:06:02,309 --> 00:06:06,268
我得到了这个页面你可以看到有两个版本的pi魅力


145
00:06:06,478 --> 00:06:09,958
一个是专业版，一个是付费的，他们必须付费。


146
00:06:10,228 --> 00:06:14,878
但是这里有一个社区版本这是免费的开源的所以我要

147
00:06:15,268 --> 00:06:18,688
这应该是我们开始使用python所需要的所有东西


148
00:06:19,258 --> 00:06:21,658
当下载完成后，我将会


149
00:06:21,688 --> 00:06:23,458
把它放到我的下载文件夹里


150
00:06:23,938 --> 00:06:24,538
并且


151
00:06:24,598 --> 00:06:25,738
我们可以再来一遍


152
00:06:25,768 --> 00:06:26,818
运行这个家伙


153
00:06:26,938 --> 00:06:30,778
我在mac上，所以我要把它拖到我的应用文件夹。


154
00:06:31,258 --> 00:06:33,058
好了，现在有了pi的魅力


155
00:06:33,088 --> 00:06:34,498
我们有python


156
00:06:34,528 --> 00:06:36,328
三个安装在你的电脑上。


157
00:06:36,748 --> 00:06:39,118
我们准备好开始编程了


158
00:06:39,148 --> 00:06:39,868
python。


159
00:06:43,768 --> 00:06:46,108
在本教程中，我们将创建第一个


160
00:06:46,138 --> 00:06:47,248
python程序。


161
00:06:47,518 --> 00:06:48,988
我们将能够运行它


162
00:06:49,048 --> 00:06:50,848
看看一切都是如何运作的。


163
00:06:51,088 --> 00:06:52,708
我要做的第一件事就是打开心扉


164
00:06:52,738 --> 00:06:54,808
圆周率，所以pi的魅力是


165
00:06:54,838 --> 00:06:55,948
他认为


166
00:06:56,008 --> 00:06:57,658
综合开发环境


167
00:06:57,928 --> 00:07:00,388
我们在上一篇教程中下载了


168
00:07:00,658 --> 00:07:02,698
我要出去在我的电脑上搜索它


169
00:07:03,508 --> 00:07:04,708
我可以把它打开


170
00:07:04,768 --> 00:07:07,918
我们首先打开了高魅力我们应该得到一个窗口


171
00:07:07,948 --> 00:07:10,588
促使我们创建一个项目。


172
00:07:10,858 --> 00:07:12,058
你可以在下面看到。


173
00:07:12,328 --> 00:07:15,777
实际上，我要做的第一件事是来这里配置


174
00:07:16,287 --> 00:07:17,247
我要讲的是


175
00:07:17,277 --> 00:07:18,627
单击首选项。


176
00:07:19,077 --> 00:07:20,757
实际上我想要


177
00:07:20,787 --> 00:07:22,347
改变外观


178
00:07:22,377 --> 00:07:22,887
所以


179
00:07:23,337 --> 00:07:24,627
我要继续


180
00:07:25,167 --> 00:07:28,707
给它一个主题我就到这里来展示一下外观和行为的外观


181
00:07:29,067 --> 00:07:30,927
我要把主题改成


182
00:07:31,047 --> 00:07:31,767
深色


183
00:07:31,917 --> 00:07:33,807
因为我觉得这样比较容易


184
00:07:33,897 --> 00:07:35,037
使用和观察，


185
00:07:35,247 --> 00:07:36,957
但是如果你不想要你就不必这么做


186
00:07:38,067 --> 00:07:38,727
在下面


187
00:07:38,757 --> 00:07:39,507
我只需要点击一下


188
00:07:39,537 --> 00:07:40,917
创建新项目


189
00:07:41,307 --> 00:07:41,967
它将会


190
00:07:41,997 --> 00:07:45,567
把这个小窗口给我们，这样我就可以命名我的项目了。


191
00:07:45,897 --> 00:07:47,157
我将命名为


192
00:07:47,217 --> 00:07:47,967
图。


193
00:07:48,597 --> 00:07:51,777
下面还有一个选项，上面写着解释器。


194
00:07:52,167 --> 00:07:52,677
现在


195
00:07:53,487 --> 00:07:54,657
我们想要选择的是


196
00:07:54,687 --> 00:07:55,287
是


197
00:07:55,377 --> 00:07:57,087
python版本3


198
00:07:57,117 --> 00:08:00,837
如果我点击这里，你会发现有几个不同的选项。


199
00:08:01,077 --> 00:08:02,907
我在一台mac电脑上


200
00:08:02,937 --> 00:08:03,387
并且


201
00:08:03,417 --> 00:08:05,517
默认情况下，mac有


202
00:08:05,577 --> 00:08:06,237
蟒蛇


203
00:08:06,267 --> 00:08:08,127
版本2安装在它上面。


204
00:08:08,427 --> 00:08:11,277
如果你在windows机器上，我不确定它是否会


205
00:08:11,907 --> 00:08:16,437
在本教程中，我们将使用python 3因此，你要确保你有python


206
00:08:16,467 --> 00:08:18,807
三位被选为口译员，


207
00:08:19,077 --> 00:08:19,587
否则


208
00:08:19,737 --> 00:08:19,977
你


209
00:08:20,007 --> 00:08:23,007
可能无法完全理解我们在这个视频中所做的。


210
00:08:23,307 --> 00:08:25,377
现在它会在这里点击并点击


211
00:08:25,407 --> 00:08:26,007
创造。


212
00:08:26,277 --> 00:08:28,737
这将会继续，创建我们的项目


213
00:08:28,767 --> 00:08:29,517
为了我们


214
00:08:29,607 --> 00:08:30,807
现在我们有了


215
00:08:30,837 --> 00:08:31,377
我们的


216
00:08:31,407 --> 00:08:32,307
python项目


217
00:08:32,337 --> 00:08:32,967
上了又跑，


218
00:08:33,327 --> 00:08:36,177
我相信你们是怎么创造

219
00:08:36,297 --> 00:08:37,617
python程序，


220
00:08:37,917 --> 00:08:42,297
在这个草稿文件夹里，这就是我们创建的那个项目。


221
00:08:42,747 --> 00:08:43,737
我要右键点击


222
00:08:43,767 --> 00:08:44,937
我说的是新的


223
00:08:45,627 --> 00:08:46,857
我要点击这里，点击


224
00:08:46,887 --> 00:08:50,487
我们想要创建一个新的python文件这将是我们的第一个


225
00:08:50,517 --> 00:08:51,567
python程序。


226
00:08:52,137 --> 00:08:52,467
并且


227
00:08:52,497 --> 00:08:53,787
我可以给它起个名字，


228
00:08:53,847 --> 00:08:55,197
为什么不直接调用这个呢


229
00:08:55,287 --> 00:08:55,617
应用程序


230
00:08:55,737 --> 00:08:56,817
它会点击确定


231
00:08:56,937 --> 00:08:59,097
好了，现在我们有了第一个


232
00:08:59,127 --> 00:08:59,937
python文件


233
00:08:59,967 --> 00:09:00,507
打开


234
00:09:01,017 --> 00:09:04,407
我们可以开始输入一些python，我想给你们展示一下。


235
00:09:04,617 --> 00:09:06,837
是一个非常基本的

236
00:09:07,047 --> 00:09:11,698
这将会是一个hello world程序所以我们要把一些东西打印到屏幕上。


237
00:09:11,998 --> 00:09:12,538
所以当我说


238
00:09:12,598 --> 00:09:15,928
我想要做的是输入p r iyer和prince


239
00:09:16,348 --> 00:09:17,008
想要一个


240
00:09:17,038 --> 00:09:17,938
开放和封闭的


241
00:09:17,968 --> 00:09:18,808
圆括号


242
00:09:19,048 --> 00:09:19,348
现在


243
00:09:19,378 --> 00:09:21,838
在这些括号里面我们可以做一些


244
00:09:21,868 --> 00:09:22,798
引号


245
00:09:23,008 --> 00:09:25,408
在引号里面，我要把它录下来


246
00:09:25,468 --> 00:09:26,218
你好


247
00:09:26,278 --> 00:09:26,818
世界。


248
00:09:27,148 --> 00:09:29,968
这就像一个非常基本的python程序。


249
00:09:30,178 --> 00:09:31,438
它的作用是


250
00:09:31,468 --> 00:09:33,718
它会打印出hello world


251
00:09:33,748 --> 00:09:34,828
在屏幕上。


252
00:09:35,278 --> 00:09:36,568
现在我能做的是


253
00:09:36,658 --> 00:09:41,068
实际上我可以运行这个文件我们在这里得到一个小箭头它想要我们创建一个新行


254
00:09:41,368 --> 00:09:42,448
在文件的最后。


255
00:09:42,988 --> 00:09:47,518
现在为了运行我们的python程序我将会来到这里的顶部


256
00:09:47,908 --> 00:09:49,348
我在电影里


257
00:09:49,468 --> 00:09:51,448
我们点击这里的运行按钮


258
00:09:51,868 --> 00:09:52,948
我看看会发生什么


259
00:09:52,979 --> 00:09:53,729
所以它是


260
00:09:53,789 --> 00:09:56,249
问我想要运行什么我可以点击添加


261
00:09:56,939 --> 00:09:57,359
并且


262
00:09:57,389 --> 00:10:01,679
在下面这里，你会注意到我们的文本刚刚打印出来


263
00:10:01,709 --> 00:10:02,639
你好，世界，


264
00:10:02,999 --> 00:10:03,509
所以


265
00:10:03,569 --> 00:10:04,349
无论我是什么


266
00:10:04,409 --> 00:10:04,919
打印


267
00:10:05,159 --> 00:10:08,219
或者我在这个print语句中放入的任何东西都会被打印出来


268
00:10:08,249 --> 00:10:10,079
在理事会的下面


269
00:10:10,319 --> 00:10:13,019
只要你得到了打印声明，那么你就可以


270
00:10:13,109 --> 00:10:15,359
实际上编写了第一个python程序。


271
00:10:15,659 --> 00:10:16,499
当我们经历它的时候


272
00:10:16,529 --> 00:10:18,059
在这门课上，我们可以写作


273
00:10:18,089 --> 00:10:20,159
各种很棒的python程序。


274
00:10:20,219 --> 00:10:21,059
我们要做的是


275
00:10:21,089 --> 00:10:22,379
各种各样很酷的东西


276
00:10:26,129 --> 00:10:33,299
在本教程中，我想和你们谈谈如何编写一个基本的python程序，所以我们将把它写成一个非常简单的python程序。


277
00:10:33,449 --> 00:10:36,929
我们将会讨论如何继续编写我们将要讨论的程序


278
00:10:37,079 --> 00:10:40,229
我们的程序是如何被python执行的


279
00:10:40,529 --> 00:10:44,099
我们还会在屏幕上画出一个小图形


280
00:10:44,339 --> 00:10:46,109
这将会很酷，我很兴奋


281
00:10:46,139 --> 00:10:47,519
跟你们说说


282
00:10:47,549 --> 00:10:49,200
关于python的基本知识，


283
00:10:49,440 --> 00:10:51,720
我只是给大家介绍一下


284
00:10:51,810 --> 00:10:52,470
在这里


285
00:10:52,650 --> 00:10:53,790
我们有


286
00:10:53,820 --> 00:10:55,320
基本的文本编辑器


287
00:10:55,680 --> 00:10:56,880
任何一个


288
00:10:56,940 --> 00:10:59,790
我在这个文件中写的python代码


289
00:10:59,970 --> 00:11:02,910
实际上是由python执行的


290
00:11:03,120 --> 00:11:04,440
这个python文件


291
00:11:04,470 --> 00:11:05,430
有很多


292
00:11:05,460 --> 00:11:06,960
其中的python代码。


293
00:11:07,410 --> 00:11:09,600
基本上我们在做的事情


294
00:11:09,630 --> 00:11:13,770
用python编程，我们只是给计算机一组指令。


295
00:11:14,070 --> 00:11:18,150
这就是编程的本质就像我们指定一组指令一样


296
00:11:18,390 --> 00:11:22,470
电脑会自动执行我们给它的指令。


297
00:11:22,980 --> 00:11:23,460
所以


298
00:11:23,490 --> 00:11:27,030
我们给计算机的指令越复杂，就越复杂


299
00:11:27,060 --> 00:11:27,900
任务


300
00:11:27,930 --> 00:11:28,890
计算机可以


301
00:11:28,950 --> 00:11:29,610
继续。


302
00:11:30,090 --> 00:11:34,620
我将向你们展示如何使用python指令或python代码


303
00:11:34,890 --> 00:11:37,710
为了在屏幕上画出一个图形


304
00:11:37,950 --> 00:11:39,090
我要把它画出来


305
00:11:39,120 --> 00:11:40,230
一个小三角。


306
00:11:40,650 --> 00:11:41,490
在这里，


307
00:11:41,550 --> 00:11:43,950
我们可以把一些东西打印到


308
00:11:43,980 --> 00:11:48,060
屏幕和python使用一种叫做print语句的东西我可以输入输出


309
00:11:48,090 --> 00:11:48,540
打印。


310
00:11:48,960 --> 00:11:50,970
在括号里面。


311
00:11:51,390 --> 00:11:52,260
我可以输入


312
00:11:52,410 --> 00:11:53,700
一些引号


313
00:11:53,730 --> 00:11:54,990
在引号里面


314
00:11:55,020 --> 00:11:55,410
我们可以


315
00:11:55,440 --> 00:11:57,480
把我们想要打印出来的东西放到屏幕上。


316
00:11:57,990 --> 00:11:58,890
所以我要


317
00:11:58,980 --> 00:12:00,631
复制这个，我要做的是


318
00:12:00,661 --> 00:12:02,761
下面是一些小王子的陈述


319
00:12:02,971 --> 00:12:04,441
我们要画一只羊。


320
00:12:04,801 --> 00:12:05,371
所以


321
00:12:05,431 --> 00:12:06,391
我们要画出


322
00:12:06,421 --> 00:12:07,921
三角形型


323
00:12:07,951 --> 00:12:10,201
所以在这里，它会画出一个正斜杠


324
00:12:10,531 --> 00:12:13,951
然后在这里，我要腾出一个空间，然后再画一个外框


325
00:12:14,371 --> 00:12:14,911
在这里


326
00:12:14,941 --> 00:12:16,051
两个空间


327
00:12:16,411 --> 00:12:17,791
和联合前锋。


328
00:12:18,751 --> 00:12:20,731
我们可以做三个空间，并支付腰带。


329
00:12:21,301 --> 00:12:24,721
现在我要画一个竖条，一直往下。


330
00:12:27,391 --> 00:12:29,701
实际上我们也可以在这里做一些强调。


331
00:12:29,791 --> 00:12:30,511
我想高中


332
00:12:32,011 --> 00:12:35,191
现在我们有了三角形的刮脸你可以看到


333
00:12:35,461 --> 00:12:37,381
它看起来就像一个直角三角形


334
00:12:37,501 --> 00:12:38,911
这样我就可以保存我的文件了。


335
00:12:39,211 --> 00:12:41,971
我可以到这里来运行


336
00:12:42,031 --> 00:12:43,231
点击运行应用程序


337
00:12:43,531 --> 00:12:47,281
或者使用派的魅力你也可以过来点击这个播放按钮


338
00:12:47,881 --> 00:12:51,451
当我点击播放按钮时我想让你们注意到下面发生了什么


339
00:12:51,751 --> 00:12:52,231
所以


340
00:12:52,291 --> 00:12:54,481
在这下面我们有一个小窗口


341
00:12:54,511 --> 00:12:56,101
这叫做领事


342
00:12:56,611 --> 00:13:00,182
基本上，委员会是一个python会去的地方


343
00:13:00,242 --> 00:13:02,042
输出一些信息


344
00:13:02,341 --> 00:13:05,612
当我们使用这个打印语句的时候基本上是在告诉python


345
00:13:05,822 --> 00:13:08,012
你能把什么东西印到领事处吗？


346
00:13:08,642 --> 00:13:12,722
在很多情况下，我们会想看看代码中发生了什么。


347
00:13:13,052 --> 00:13:14,852
我们可以使用这个打印语句


348
00:13:14,912 --> 00:13:16,562
把东西打印出来给委员会。


349
00:13:16,802 --> 00:13:20,582
我们可以从窗口了解我们的程序在做什么


350
00:13:20,972 --> 00:13:24,512
在我们的例子中，我们要把这个三角形打印到领事处。


351
00:13:24,962 --> 00:13:27,242
所以我要到这里点击这个播放按钮


352
00:13:27,722 --> 00:13:28,742
你会看到下面这里


353
00:13:28,772 --> 00:13:30,302
我们实际上是打印出来的


354
00:13:30,332 --> 00:13:30,932
三角形


355
00:13:31,172 --> 00:13:34,172
所以任务完成了我们可以打印出我们的形状。


356
00:13:34,502 --> 00:13:37,592
所以我可以画出任何形状只要我是


357
00:13:37,622 --> 00:13:38,252
能够


358
00:13:38,282 --> 00:13:39,092
指定


359
00:13:39,122 --> 00:13:40,622
在这些打印语句的内部。


360
00:13:41,162 --> 00:13:41,552
所以


361
00:13:41,583 --> 00:13:44,883
本质上，当我点击播放按钮时，python会做什么


362
00:13:45,062 --> 00:13:49,623
它会进入这个文件它会按顺序查看所有这些指令。


363
00:13:49,833 --> 00:13:52,623
所以它首先要做的是它会进入这个指令它会说


364
00:13:52,653 --> 00:13:53,073
好的，


365
00:13:53,253 --> 00:13:57,903
他们想让我在这个垂直的条形图上画出这些小的正斜杠，


366
00:13:58,203 --> 00:14:01,083
一旦它这样做了，它就会下降到这个指令上面说


367
00:14:01,113 --> 00:14:01,413
好的


368
00:14:01,443 --> 00:14:02,883
他们想让我再打印一些东西


369
00:14:03,183 --> 00:14:05,613
当它打印出来的时候它就会下降到这个指令


370
00:14:05,643 --> 00:14:06,273
等等


371
00:14:07,233 --> 00:14:11,223
python实际上会执行我们编写的代码行


372
00:14:11,523 --> 00:14:12,303
按顺序。


373
00:14:12,963 --> 00:14:14,913
我写指令的顺序


374
00:14:14,943 --> 00:14:16,083
这很重要。


375
00:14:16,173 --> 00:14:18,963
举个例子，如果我要把最后一行写在这里


376
00:14:19,263 --> 00:14:20,944
把它放在最上面。


377
00:14:22,264 --> 00:14:23,704
现在当我保存文件时。


378
00:14:23,764 --> 00:14:25,744
而不是画出这个三角形。


379
00:14:26,014 --> 00:14:27,034
它会画出来


380
00:14:27,064 --> 00:14:28,534
这个小小的颠倒


381
00:14:28,564 --> 00:14:30,154
最下面的东西，然后


382
00:14:30,184 --> 00:14:31,864
剩下的三角形在下面


383
00:14:32,194 --> 00:14:35,854
指令的顺序实际上很重要。


384
00:14:35,974 --> 00:14:39,154
这就是你的python程序的基本原理。


385
00:14:39,214 --> 00:14:48,304
当我们学习这门课程的时候我们会学到越来越多的这些小的线所以这里我们只是用这个小的打印函数把一些东西打印到屏幕上，


386
00:14:48,484 --> 00:14:51,634
有很多这样的小事情我们可以在学习的过程中学习


387
00:14:51,844 --> 00:14:55,504
将会学到更多我们可以给计算机的指令。


388
00:14:55,864 --> 00:14:58,984
但在这节课中，我想给大家展示一下基本的知识。


389
00:14:59,224 --> 00:14:59,674
噢


390
00:15:00,184 --> 00:15:03,934
我们可以为计算机定义这些小指令


391
00:15:04,114 --> 00:15:06,004
计算机将会执行它们


392
00:15:06,034 --> 00:15:06,694
按顺序。


393
00:15:10,504 --> 00:15:14,555
本教程我想和你们讨论一下如何使用变量


394
00:15:14,585 --> 00:15:15,395
python。


395
00:15:15,875 --> 00:15:17,945
现在在python里，你要处理的是


396
00:15:17,975 --> 00:15:19,235
大量的数据


397
00:15:19,265 --> 00:15:21,935
所以在我们的项目中，很多时候我们都要和


398
00:15:21,965 --> 00:15:25,205
所有类型的信息，数据和价值，


399
00:15:25,625 --> 00:15:27,005
有时候这些数据


400
00:15:27,035 --> 00:15:28,835
可能很难管理。


401
00:15:29,165 --> 00:15:32,465
在python里，我们有一个叫做变量的东西。


402
00:15:32,705 --> 00:15:34,715
它基本上就是一个容器


403
00:15:34,985 --> 00:15:36,485
我们可以储存一些


404
00:15:36,515 --> 00:15:37,565
数据值。


405
00:15:37,775 --> 00:15:40,055
当我们使用一个变量时


406
00:15:40,115 --> 00:15:42,065
容器内的

407
00:15:42,245 --> 00:15:43,145
这让它变得很多


408
00:15:43,175 --> 00:15:45,605
对我们来说更容易处理和管理


409
00:15:45,635 --> 00:15:46,565
所有的不同


410
00:15:46,595 --> 00:15:48,515
我们的程序内部的数据。


411
00:15:48,815 --> 00:15:51,995
所以变量是非常有用的，它有点像


412
00:15:52,025 --> 00:15:53,585
核心主题


413
00:15:53,735 --> 00:15:56,195
你真正想要了解和掌握的

414
00:15:56,585 --> 00:15:58,655
在本教程中，我们将逐一介绍。


415
00:15:58,745 --> 00:16:02,616
你需要知道的所有东西都是从变量开始的我们将会看到它们是什么


416
00:16:02,826 --> 00:16:05,916
为什么它们是有用的我们会研究不同类型的变量


417
00:16:05,946 --> 00:16:06,936
不同类型的


418
00:16:07,026 --> 00:16:08,616
我们可以存储的数据


419
00:16:08,646 --> 00:16:09,846
在变量中，


420
00:16:10,026 --> 00:16:11,256
在我的世界里


421
00:16:11,286 --> 00:16:13,806
python文件，我有一个非常简单的程序。


422
00:16:14,196 --> 00:16:17,406
它基本上就是在屏幕上打印一些文本。


423
00:16:17,826 --> 00:16:20,556
这实际上是我写的一个小故事。


424
00:16:20,796 --> 00:16:22,686
从前有个叫乔治的人


425
00:16:23,016 --> 00:16:24,636
他七十岁了。


426
00:16:24,966 --> 00:16:26,646
他真的很喜欢乔治这个名字


427
00:16:26,826 --> 00:16:28,836
但不喜欢七十岁。


428
00:16:29,166 --> 00:16:32,136
这是一个有效的python程序，我可以继续


429
00:16:32,166 --> 00:16:33,156
运行这个程序


430
00:16:33,546 --> 00:16:35,676
你会在理事会看到


431
00:16:35,706 --> 00:16:37,056
所有的东西都打印出来了


432
00:16:37,116 --> 00:16:38,076
看起来很棒


433
00:16:38,376 --> 00:16:40,386
我们这里有一个很棒的python程序。


434
00:16:40,806 --> 00:16:44,586
假设在我们的故事里我想要改变


435
00:16:44,617 --> 00:16:46,026
人物的名字


436
00:16:46,057 --> 00:16:49,597
所以我没有命名这个字符george假设我想给这个字符命名


437
00:16:49,627 --> 00:16:50,197
乔恩


438
00:16:50,617 --> 00:16:51,067
井


439
00:16:51,247 --> 00:16:59,557
我将不得不通过，我将不得不手动地把名字改成约翰这个名字，在这个故事里的每个地方都提到了。


440
00:16:59,647 --> 00:17:01,927
所以我不打算到这里来，我会说


441
00:17:01,957 --> 00:17:02,227
好的


442
00:17:02,257 --> 00:17:04,537
john，我将不得不手动改变它


443
00:17:04,777 --> 00:17:05,467
然后


444
00:17:05,497 --> 00:17:09,846
好的，在这里我们要再次手动输入john并把它改成john。


445
00:17:10,386 --> 00:17:15,606
为了改变角色的名字，我必须手动进入并在这两个地方改变它。


446
00:17:16,086 --> 00:17:17,046
现在我们说


447
00:17:17,406 --> 00:17:19,626
也许我们想要改变字符


448
00:17:19,806 --> 00:17:22,446
年龄也是如此，除了改变名字。


449
00:17:22,716 --> 00:17:28,656
我们也想改变年龄让他更年轻一点，为什么我们不认为约翰会是三十五岁。


450
00:17:29,406 --> 00:17:34,747
你看这里，我必须到这里手动改变年龄，然后到这里来


451
00:17:35,017 --> 00:17:36,787
然后再手动修改


452
00:17:37,207 --> 00:17:37,627
对。


453
00:17:38,017 --> 00:17:39,247
现在我们改变了它


454
00:17:39,277 --> 00:17:41,587
它会起作用它会在我们的程序中更新。


455
00:17:41,977 --> 00:17:47,947
但是你会注意到为了做出这样的改变就像我必须检查整个程序一样找到它的位置


456
00:17:47,977 --> 00:17:49,597
价值是改变它，


457
00:17:49,657 --> 00:17:50,077
并且


458
00:17:50,137 --> 00:17:51,517
这仅仅是


459
00:17:51,547 --> 00:17:52,447
四行


460
00:17:52,477 --> 00:17:55,357
在这个故事里，想象一下如果我有一个故事


461
00:17:55,537 --> 00:17:57,067
数千行。


462
00:17:57,337 --> 00:17:59,017
我们提到了这个角色的名字


463
00:17:59,047 --> 00:17:59,707
年龄


464
00:17:59,737 --> 00:18:00,847
数百次。


465
00:18:01,177 --> 00:18:03,637
我们不需要检查每一条线


466
00:18:03,847 --> 00:18:05,887
手动更改字符的名称


467
00:18:06,067 --> 00:18:09,127
这对我们来说不是一个很好的方法


468
00:18:10,117 --> 00:18:14,077
这对我们来说并不是一个很好的方式来管理我们项目中的数据


469
00:18:14,107 --> 00:18:15,637
角色的名字在这个时代。


470
00:18:15,967 --> 00:18:18,187
所以我们可以使用一个变量


471
00:18:18,367 --> 00:18:19,777
为了储存


472
00:18:19,807 --> 00:18:21,788
人物的名字和角色。


473
00:18:21,848 --> 00:18:22,358
年龄。


474
00:18:22,568 --> 00:18:25,147
当我们使用这个变量时它会使它变得很多


475
00:18:25,177 --> 00:18:27,758
我们更容易把角色的名字和年龄写出来。


476
00:18:27,818 --> 00:18:29,648
在我们的小程序里面。


477
00:18:30,038 --> 00:18:33,698
我将向你们展示如何为角色的名字和年龄创建一个变量。


478
00:18:33,998 --> 00:18:36,698
现在它在上面的这个print语句上面。


479
00:18:37,088 --> 00:18:37,508
并且


480
00:18:37,538 --> 00:18:40,238
在这里，我想创建一个变量。


481
00:18:40,538 --> 00:18:42,518
所以当我们创建一个变量时


482
00:18:42,548 --> 00:18:44,828
我们实际上需要提供的是python


483
00:18:45,008 --> 00:18:45,578
蟒蛇


484
00:18:45,608 --> 00:18:47,228
几条信息。


485
00:18:47,708 --> 00:18:53,948
我们需要给python的第一个信息是变量名所以我需要指定一个名字


486
00:18:54,128 --> 00:18:57,218
到这个容器中我们要存储信息。


487
00:18:57,698 --> 00:18:59,528
所以我要做的就是输入输出


488
00:18:59,558 --> 00:19:00,818
变量名


489
00:19:00,848 --> 00:19:02,708
我想要创建一个，所以我要创建一个


490
00:19:02,798 --> 00:19:04,808
变量叫做字符名称。


491
00:19:05,288 --> 00:19:06,338
所以我想说


492
00:19:07,028 --> 00:19:07,808
特性


493
00:19:08,408 --> 00:19:09,758
他们强调的是


494
00:19:09,788 --> 00:19:10,478
名字


495
00:19:10,778 --> 00:19:12,998
所以通常当你创建一个名字的时候


496
00:19:13,028 --> 00:19:14,738
对于python中的一个变量。


497
00:19:14,888 --> 00:19:17,108
你想要区分不同的单词


498
00:19:17,258 --> 00:19:21,788
这里有一个下划线，所以这里有两个单词，我把它们和一个下划线分开。


499
00:19:22,328 --> 00:19:24,249
现在我需要做的是


500
00:19:24,279 --> 00:19:25,359
赋值


501
00:19:25,389 --> 00:19:27,399
在这里面


502
00:19:27,459 --> 00:19:29,229
基本上我能做的是，我可以说


503
00:19:29,649 --> 00:19:30,459
等于


504
00:19:30,579 --> 00:19:32,439
在这里我可以输入一个值


505
00:19:32,469 --> 00:19:34,839
所以我要在里面输入字符的

506
00:19:35,019 --> 00:19:35,859
引号。


507
00:19:36,159 --> 00:19:37,749
所以我们要把约翰打出来。


508
00:19:38,289 --> 00:19:41,499
现在我们有了一个变量来命名字符的

509
00:19:42,159 --> 00:19:46,629
在这个名为变量的字符下面，我想创建另一个变量


510
00:19:47,349 --> 00:19:49,149
年龄肯定会被录下来


511
00:19:49,719 --> 00:19:50,469
特性


512
00:19:50,709 --> 00:19:51,459
下划线


513
00:19:51,519 --> 00:19:52,239
年龄。


514
00:19:52,599 --> 00:19:53,919
我要设置这个


515
00:19:53,949 --> 00:19:56,949
等于字符的年龄，也就是三十五。


516
00:19:58,120 --> 00:19:59,679
现在我们有两个变量，


517
00:19:59,949 --> 00:20:03,069
一个代表人物的名字，一个代表人物


518
00:20:03,819 --> 00:20:06,219
现在我可以做的是


519
00:20:06,249 --> 00:20:08,559
在这个故事里的角色的名字


520
00:20:08,589 --> 00:20:09,069
用


521
00:20:09,189 --> 00:20:10,359
这个变量。


522
00:20:10,659 --> 00:20:12,130
我将向你们展示如何做到这一点


523
00:20:12,160 --> 00:20:15,340
如果我们想在这个print语句中放入一个变量。


524
00:20:15,580 --> 00:20:17,500
实际上我要做一些事情。


525
00:20:17,710 --> 00:20:19,840
我要做的第一件事是


526
00:20:20,020 --> 00:20:21,370
结束这个


527
00:20:21,400 --> 00:20:23,380
在这里输入文本，我将不得不输入


528
00:20:23,770 --> 00:20:24,220
a


529
00:20:24,280 --> 00:20:26,110
这里的引号


530
00:20:26,410 --> 00:20:27,910
你可以看到我基本上是


531
00:20:27,940 --> 00:20:29,890
把整个东西包装成

532
00:20:29,950 --> 00:20:31,750
单引号。


533
00:20:32,320 --> 00:20:36,760
现在我也有了这个税，我要在这里加个引号。


534
00:20:37,210 --> 00:20:37,990
现在我有了


535
00:20:38,531 --> 00:20:40,660
一大堆的纳税年度。


536
00:20:41,080 --> 00:20:43,810
然后这里还有个引号


537
00:20:44,050 --> 00:20:45,520
在这里


538
00:20:45,610 --> 00:20:46,090
代替


539
00:20:46,120 --> 00:20:47,650
说这个角色的名字


540
00:20:47,680 --> 00:20:49,750
我想引用那个字符的名字


541
00:20:49,780 --> 00:20:50,500
变量


542
00:20:50,920 --> 00:20:52,810
所以我要写入加号


543
00:20:54,430 --> 00:20:55,240
特性


544
00:20:56,230 --> 00:20:57,340
下划线名称


545
00:20:57,910 --> 00:21:01,421
我想说另一个加号我想说的是


546
00:21:01,451 --> 00:21:03,100
打印出所有的文本，


547
00:21:03,641 --> 00:21:04,480
加上


548
00:21:04,661 --> 00:21:07,181
在字符名称中存储的值


549
00:21:08,651 --> 00:21:09,791
所有的文本。


550
00:21:10,481 --> 00:21:14,021
这将会打印出这个角色的名字我们打印出来


551
00:21:14,291 --> 00:21:16,031
所以我要继续运行这个程序


552
00:21:16,601 --> 00:21:18,041
你会看到下面这里


553
00:21:18,101 --> 00:21:19,961
我在这里画一个空间，


554
00:21:20,681 --> 00:21:21,641
我们再运行一次。


555
00:21:21,911 --> 00:21:23,381
你可以看到这里，


556
00:21:23,561 --> 00:21:26,171
我们还在印刷，曾经有一个叫


557
00:21:26,201 --> 00:21:26,891
约翰。


558
00:21:27,491 --> 00:21:31,241
所以python所做的就是当它执行这一行代码时


559
00:21:31,541 --> 00:21:33,371
它在这里，它看到了


560
00:21:33,461 --> 00:21:34,931
好的，他们想要结果。


561
00:21:35,021 --> 00:21:37,331
字符名称内的值


562
00:21:37,661 --> 00:21:38,141
所以


563
00:21:38,171 --> 00:21:41,051
python会上升到这里，它会得到这个值，


564
00:21:41,291 --> 00:21:41,801
它将会


565
00:21:41,831 --> 00:21:43,361
把它插入到里面


566
00:21:43,781 --> 00:21:48,611
所以我可以对我的文件中的每个字符的实例进行这样的操作


567
00:21:48,911 --> 00:21:49,271
你知道


568
00:21:49,331 --> 00:21:51,311
r复制了这个东西


569
00:21:51,911 --> 00:21:52,421
并且


570
00:21:52,481 --> 00:21:55,661
我可以把它粘贴到这里字符的名字是


571
00:21:55,871 --> 00:21:56,891
快速地


572
00:21:57,071 --> 00:22:00,912
你可以看到，我们做的和我们在上面做的完全一样。


573
00:22:01,302 --> 00:22:03,792
我也可以为这些字符做这个


574
00:22:03,852 --> 00:22:05,592
让某人来这里


575
00:22:05,832 --> 00:22:07,872
我把它粘贴进来。


576
00:22:08,832 --> 00:22:12,312
我要改变这个，而不是字符名改为字符


577
00:22:12,342 --> 00:22:12,912
年龄。


578
00:22:14,502 --> 00:22:15,552
我要做这个


579
00:22:15,582 --> 00:22:19,302
还有一个地方会在这里做这个我们提到了年龄


580
00:22:19,992 --> 00:22:22,152
我还是把这个改成


581
00:22:22,212 --> 00:22:22,482
进位


582
00:22:22,512 --> 00:22:23,142
你的

583
00:22:23,832 --> 00:22:29,082
所以当我运行这个程序的时候它会打印出之前打印出来的相同的故事，


584
00:22:29,502 --> 00:22:29,892
但是


585
00:22:29,922 --> 00:22:34,632
现在我不需要输入角色的名字和人物的

586
00:22:34,872 --> 00:22:36,312
我可以引用这个


587
00:22:36,342 --> 00:22:37,062
变量。


588
00:22:37,482 --> 00:22:41,352
关于变量的很酷的东西就好像我想要改变角色的名字一样。


589
00:22:41,892 --> 00:22:46,212
现在我要做的就是在这里改变它这样我就可以改变你喜欢的字符名称了


590
00:22:46,242 --> 00:22:47,352
汤姆之类的。


591
00:22:47,682 --> 00:22:49,902
我们也可以改变他们的年龄所以我可以改变


592
00:22:50,052 --> 00:22:51,732
年龄大概是50岁


593
00:22:52,032 --> 00:22:55,872
这将在整个故事中自动更新


594
00:22:56,262 --> 00:22:58,002
当我点击这个播放按钮时你会看到


595
00:22:58,212 --> 00:23:00,312
现在我们用的是tom的名字


596
00:23:00,522 --> 00:23:02,382
他已经五十岁了。


597
00:23:02,652 --> 00:23:04,812
这就是变量的用武之地


598
00:23:04,842 --> 00:23:08,742
这是一种非常棒的控制和管理方式


599
00:23:08,982 --> 00:23:11,172
我们的程序内部的数据


600
00:23:11,592 --> 00:23:13,152
有了变量，你也可以


601
00:23:13,182 --> 00:23:14,742
修改它们的值


602
00:23:14,772 --> 00:23:15,282
所以


603
00:23:15,432 --> 00:23:19,602
例如，在故事的中途我想要改变角色的名字


604
00:23:20,022 --> 00:23:22,122
为什么可以在这里画一些新的线，


605
00:23:22,482 --> 00:23:23,532
下面这里


606
00:23:23,562 --> 00:23:25,452
我可以分配一个新的


607
00:23:25,482 --> 00:23:27,222
对其中一个变量的值。


608
00:23:27,462 --> 00:23:28,662
所以我可以说


609
00:23:29,532 --> 00:23:30,312
特性


610
00:23:30,372 --> 00:23:31,512
下划线，


611
00:23:31,962 --> 00:23:35,442
为了给它一个不同的值我要做的就是说等于


612
00:23:35,472 --> 00:23:37,182
会给它一个不同的值


613
00:23:37,693 --> 00:23:41,293
让我们说到故事的一半我们想把角色的名字改成迈克


614
00:23:42,313 --> 00:23:43,873
当我运行程序时


615
00:23:44,683 --> 00:23:47,263
你会在故事的第一部分看到它说


616
00:23:47,293 --> 00:23:48,433
从前有个叫


617
00:23:48,463 --> 00:23:49,123
汤姆。


618
00:23:49,453 --> 00:23:51,163
在故事的第二部分，


619
00:23:51,253 --> 00:23:53,083
它指的是


620
00:23:53,143 --> 00:23:53,803
迈克。


621
00:23:54,013 --> 00:23:55,033
所以我实际上


622
00:23:55,063 --> 00:23:56,653
更新变量


623
00:23:56,683 --> 00:23:58,153
在我的程序中


624
00:23:58,183 --> 00:23:58,993
在这里


625
00:23:59,383 --> 00:24:00,943
这是一种非常棒的方式


626
00:24:00,973 --> 00:24:05,533
你知道在这些程序中很多时候你会想要修改变量的值


627
00:24:05,743 --> 00:24:06,553
所以你可以这样做


628
00:24:06,583 --> 00:24:07,603
就像这样。


629
00:24:07,663 --> 00:24:10,363
最后，我想和你们谈谈不同的


630
00:24:10,573 --> 00:24:14,293
我们可以在这些变量中存储的数据类型。


631
00:24:15,553 --> 00:24:18,073
我有字符名称和字符年龄


632
00:24:18,313 --> 00:24:18,643
并且


633
00:24:18,703 --> 00:24:21,794
我实际上是在存储所谓的字符串，


634
00:24:21,974 --> 00:24:24,314
所以一个字符串基本上就是


635
00:24:24,524 --> 00:24:25,874
平税


636
00:24:26,114 --> 00:24:28,664
汤姆的名字就是纯文本


637
00:24:29,084 --> 00:24:31,574
下面这些是字符串。


638
00:24:31,844 --> 00:24:34,154
在python中有一个数据类型，


639
00:24:34,394 --> 00:24:36,554
叫做字符串，它只是


640
00:24:36,584 --> 00:24:38,054
基本上是储存


641
00:24:38,115 --> 00:24:38,955
纯文本


642
00:24:38,985 --> 00:24:39,345
所以


643
00:24:39,615 --> 00:24:43,185
你知道，在故事中你会喜欢的任何文本都知道某人的名字


644
00:24:43,395 --> 00:24:45,344
你可以在一个字符串里面存储。


645
00:24:45,885 --> 00:24:47,924
还有另一种类型的数据


646
00:24:47,954 --> 00:24:49,935
我们可以在python里存储


647
00:24:49,965 --> 00:24:51,075
也就是数字


648
00:24:51,105 --> 00:24:53,835
我们还可以存储额外的存储文本


649
00:24:53,865 --> 00:24:54,495
数字。


650
00:24:54,885 --> 00:24:57,165
如果我想要开始一个数字


651
00:24:57,195 --> 00:25:00,705
假设我们想要存储字符年龄而不是字符串内部。


652
00:25:01,005 --> 00:25:03,135
我们可以把它存储在一个数字里面


653
00:25:03,915 --> 00:25:05,805
我可以输入50。


654
00:25:06,255 --> 00:25:09,915
当我们存储一个数字时我们不需要这些引号


655
00:25:09,945 --> 00:25:11,625
你只需要那个引号


656
00:25:11,895 --> 00:25:15,016
当你存储一个字符串时如果我想要一个数字，我可以


657
00:25:15,046 --> 00:25:16,216
像这样写出来，


658
00:25:16,666 --> 00:25:20,295
除了使用整数之外，我还可以使用十进制数。


659
00:25:20,355 --> 00:25:23,205
所以我可以说是五十点五六七八


660
00:25:23,235 --> 00:25:24,196
三分之一


661
00:25:24,586 --> 00:25:26,536
而蟒蛇将能够储存


662
00:25:26,566 --> 00:25:27,886
这个数字也是。


663
00:25:28,126 --> 00:25:29,956
你可以存储所有不同类型的数字


664
00:25:30,286 --> 00:25:32,206
我们也可以储存


665
00:25:32,236 --> 00:25:34,306
所谓的布尔值


666
00:25:34,576 --> 00:25:39,046
布尔值本质上是一个真值或假值。


667
00:25:39,376 --> 00:25:43,306
在编程中有很多实例我们想要表示


668
00:25:43,336 --> 00:25:44,566
真或假


669
00:25:44,626 --> 00:25:45,196
数据


670
00:25:45,616 --> 00:25:47,836
例如，我可以有一个变量


671
00:25:47,956 --> 00:25:48,976
他的信


672
00:25:49,306 --> 00:25:52,156
这可以告诉我，某人是否是男性，


673
00:25:52,486 --> 00:25:55,906
在我的例子中，这是真的因为我是一个人，所以我可以


674
00:25:56,176 --> 00:25:57,346
实际上，这是需要的


675
00:25:57,376 --> 00:25:57,916
资本


676
00:25:58,756 --> 00:25:59,236
所以


677
00:25:59,476 --> 00:26:01,876
我可以对任何一个都有价值


678
00:26:02,416 --> 00:26:02,986
或者


679
00:26:03,916 --> 00:26:04,696
假的。


680
00:26:04,846 --> 00:26:07,036
实际上，如果我们用python命名的话


681
00:26:07,066 --> 00:26:08,896
我们想要使用下划线，我想说


682
00:26:08,956 --> 00:26:10,546
是下划线邮件


683
00:26:10,846 --> 00:26:12,706
这可以是真的，也可以是假的


684
00:26:13,366 --> 00:26:17,957
真或假的值可能不是你习惯在现实世界中处理的东西


685
00:26:18,497 --> 00:26:18,947
但是


686
00:26:18,977 --> 00:26:22,007
在编程中，我们将使用一个真实或错误的值


687
00:26:22,067 --> 00:26:24,707
一直以来它们都是非常重要的


688
00:26:25,427 --> 00:26:29,537
就像我说的，有三种基本类型的数据我们可以在python中使用


689
00:26:29,597 --> 00:26:32,117
字符串就像纯文本一样，


690
00:26:32,177 --> 00:26:36,587
数字就像小数或整数，像这样，


691
00:26:36,827 --> 00:26:38,207
这是真的或假的


692
00:26:38,237 --> 00:26:38,927
价值观。


693
00:26:39,257 --> 00:26:45,857
这些是基本的数据类型我的意思是有很多其他类型的数据我们可以使用但是我想说99%的时间。


694
00:26:46,097 --> 00:26:47,597
作为一个新用户


695
00:26:47,627 --> 00:26:49,398
在python的新程序员中，


696
00:26:49,608 --> 00:26:51,198
你只需要处理这些


697
00:26:51,288 --> 00:26:52,668
三种数据类型


698
00:26:52,698 --> 00:26:53,118
所以


699
00:26:53,388 --> 00:26:54,378
这些都是基础


700
00:26:54,438 --> 00:26:55,398
数据


701
00:26:55,428 --> 00:26:55,818
并且


702
00:26:55,908 --> 00:26:57,228
还有变量


703
00:26:57,288 --> 00:26:58,548
你将会使用变量


704
00:26:58,578 --> 00:27:01,998
在python里的所有时间所以你肯定想要练习并让自己感觉舒服


705
00:27:02,028 --> 00:27:02,748
使用它们


706
00:27:06,768 --> 00:27:11,298
在本教程中，我们将讨论如何在python中使用字符串。


707
00:27:11,748 --> 00:27:13,458
现在最常见的类型是


708
00:27:13,488 --> 00:27:17,148
我们将在python中使用的数据将是字符串


709
00:27:17,418 --> 00:27:19,308
字符串基本上就是


710
00:27:19,428 --> 00:27:21,408
纯文本，任何文本


711
00:27:21,708 --> 00:27:23,478
我们想要在我们的程序里面


712
00:27:23,688 --> 00:27:25,848
我们可以在一个字符串里面存储。


713
00:27:26,148 --> 00:27:30,318
所以我想和你们讨论一下我们可以用字符串做的所有很酷的事情我们基本上只会得到a


714
00:27:30,558 --> 00:27:33,408
完整地介绍为什么字符串是很棒的。


715
00:27:33,948 --> 00:27:34,938
在这里，


716
00:27:35,118 --> 00:27:36,918
我要打印出来


717
00:27:36,948 --> 00:27:39,109
一个字符串，我将写入print


718
00:27:39,919 --> 00:27:41,359
在括号里面。


719
00:27:41,419 --> 00:27:42,799
我可以输入一个字符串


720
00:27:43,219 --> 00:27:47,269
为了创建一个字符串，我需要使用引号，这样我就可以创建一个字符串


721
00:27:47,299 --> 00:27:48,799
开合引号


722
00:27:48,829 --> 00:27:49,729
就像这样


723
00:27:50,059 --> 00:27:50,389
现在


724
00:27:50,449 --> 00:27:51,019
在里面


725
00:27:51,049 --> 00:27:53,209
引号，我可以输入任何文本


726
00:27:53,239 --> 00:27:55,549
我想要这个字符串，所以我们可以说


727
00:27:56,059 --> 00:27:56,689
斜拉


728
00:27:56,749 --> 00:27:57,439
学院。


729
00:27:58,309 --> 00:27:59,989
现在我们有了一个字符串


730
00:28:00,019 --> 00:28:00,829
有了文本


731
00:28:00,859 --> 00:28:02,359
里面的德拉夫学院


732
00:28:02,719 --> 00:28:04,129
如果我运行程序。


733
00:28:04,249 --> 00:28:07,879
下面我们将打印出德拉夫学院，你们可以看到，


734
00:28:08,059 --> 00:28:12,199
当我们有这些弦的时候实际上有很多很酷的东西我们可以用它们来做


735
00:28:12,499 --> 00:28:18,529
我能做的一件事是在弦内创建一条新线如果我想我可以到这里来，


736
00:28:18,799 --> 00:28:20,269
我可以保存反斜杠


737
00:28:20,329 --> 00:28:20,870
n


738
00:28:21,290 --> 00:28:23,840
你可以看到它以不同的颜色高亮显示。


739
00:28:24,140 --> 00:28:30,320
它要做的是将一条新线插入到字符串中所以现在它会在一行中写入draff


740
00:28:30,530 --> 00:28:32,420
在另一条线上。


741
00:28:32,900 --> 00:28:34,400
我点击play。


742
00:28:34,580 --> 00:28:37,130
你会看到这里我们只得到了draff学院，


743
00:28:37,520 --> 00:28:39,110
反斜杠加


744
00:28:39,500 --> 00:28:40,910
我也可以用


745
00:28:41,090 --> 00:28:42,110
反斜线


746
00:28:42,140 --> 00:28:43,430
引号


747
00:28:43,670 --> 00:28:46,760
如果我想在我的字符串里放一个引号。


748
00:28:47,180 --> 00:28:49,370
我不能这样写一个

749
00:28:49,640 --> 00:28:52,371
因为蟒蛇会认为我在试图结束


750
00:28:52,401 --> 00:28:53,421
这种力量。


751
00:28:53,691 --> 00:28:55,881
如果我想要包含一个引号我可以用这个


752
00:28:55,911 --> 00:28:57,531
特殊反斜杠字符


753
00:28:57,981 --> 00:28:59,991
这就叫做转义字符


754
00:29:00,021 --> 00:29:02,031
基本上就是告诉pytho

755
00:29:02,361 --> 00:29:05,391
不管后面的角色是什么，我们想要


756
00:29:05,452 --> 00:29:06,922
从字面上看


757
00:29:07,161 --> 00:29:08,572
当我说反斜杠


758
00:29:08,602 --> 00:29:09,472
引号。


759
00:29:09,652 --> 00:29:10,522
它的意思是


760
00:29:10,552 --> 00:29:11,302
嘿，蟒蛇


761
00:29:11,332 --> 00:29:12,772
我想指出一个

762
00:29:13,102 --> 00:29:14,572
现在我们可以打印出来了


763
00:29:14,602 --> 00:29:14,842
外出


764
00:29:16,072 --> 00:29:16,642
就在这里。


765
00:29:16,972 --> 00:29:20,752
我也可以用这个来打印反斜杠，所以如果我需要反斜杠。


766
00:29:20,812 --> 00:29:22,102
我可以看到反斜杠，


767
00:29:22,402 --> 00:29:22,912
并且


768
00:29:23,152 --> 00:29:25,282
它会打印出一个普通的反斜杠


769
00:29:26,002 --> 00:29:27,622
所以你可以看到这样的情况


770
00:29:27,772 --> 00:29:29,752
如果你想要，你可以用反斜杠来做


771
00:29:29,782 --> 00:29:31,672
新行或读引号，


772
00:29:31,943 --> 00:29:33,683
或者你可以把它当做一个普通的


773
00:29:33,713 --> 00:29:34,373
反斜杠


774
00:29:35,123 --> 00:29:39,503
除了在这里输入字符串之外我还可以创建一个字符串


775
00:29:39,533 --> 00:29:40,283
变量。


776
00:29:40,793 --> 00:29:41,933
所以我可以到这里来


777
00:29:41,963 --> 00:29:44,423
在上面，我们可以创建一个变量，让我们调用它


778
00:29:44,513 --> 00:29:45,443
短语。


779
00:29:45,803 --> 00:29:46,523
我要设置它


780
00:29:46,553 --> 00:29:47,543
等于


781
00:29:47,633 --> 00:29:48,593
离开一个殖民地，


782
00:29:49,073 --> 00:29:49,763
所以我可以


783
00:29:49,823 --> 00:29:54,114
将这个字符串值存储在一个名为短语的变量中


784
00:29:54,384 --> 00:29:55,524
然后当我想要打印的时候


785
00:29:55,554 --> 00:29:56,664
在这个变量中，


786
00:29:56,754 --> 00:29:58,884
或者我想要访问那个字符串

787
00:29:59,094 --> 00:29:59,844
我可以


788
00:30:00,024 --> 00:30:01,344
输入


789
00:30:02,394 --> 00:30:06,204
你会看到它会打印出存储在里面的值。


790
00:30:06,564 --> 00:30:09,534
我也可以使用一种叫做连接的东西


791
00:30:09,774 --> 00:30:13,464
连接基本上就是取一个字符串的过程


792
00:30:13,644 --> 00:30:15,504
将另一个字符串附加到它上面。


793
00:30:15,834 --> 00:30:18,144
所以我可以到这里来，我可以说，


794
00:30:18,414 --> 00:30:18,894
我可以说


795
00:30:18,924 --> 00:30:19,734
另外。


796
00:30:19,884 --> 00:30:23,035
现在我可以添加另一个字符串了所以

797
00:30:23,305 --> 00:30:24,205
很酷。


798
00:30:24,445 --> 00:30:25,795
这就会说


799
00:30:25,825 --> 00:30:26,995
头皮屑学院


800
00:30:27,025 --> 00:30:27,625
是


801
00:30:27,655 --> 00:30:28,195
很酷，


802
00:30:28,675 --> 00:30:31,345
所以我基本上是在附加另一个字符串


803
00:30:31,435 --> 00:30:33,655
在另一个上面，他们称之为串联。


804
00:30:34,045 --> 00:30:38,815
除了做所有这些我们还可以使用一种特殊的东西


805
00:30:38,845 --> 00:30:39,745
功能


806
00:30:40,045 --> 00:30:43,945
一个函数基本上就是我们可以运行的一小块代码


807
00:30:44,215 --> 00:30:45,865
它会执行一个特定的


808
00:30:45,895 --> 00:30:47,275
为我们做手术，


809
00:30:47,515 --> 00:30:50,756
所以我们可以使用函数来修改字符串。


810
00:30:50,996 --> 00:30:55,046
我们也可以使用函数来获取关于字符串的信息。


811
00:30:55,256 --> 00:30:55,736
所以


812
00:30:55,886 --> 00:30:59,486
我将向你们展示一些我们可以用字符串来使用的函数。


813
00:30:59,756 --> 00:31:00,086
并且


814
00:31:00,116 --> 00:31:02,156
他们会做一些很棒的事情


815
00:31:02,426 --> 00:31:06,146
为了访问其中的一个函数我可以直接说短语，然后我可以说


816
00:31:06,176 --> 00:31:06,716
点。


817
00:31:07,466 --> 00:31:10,586
我将向你们展示一个我们可以用来转换这个的函数


818
00:31:10,616 --> 00:31:14,786
字符串完全变成小写，所以我可以直接用小写的。


819
00:31:15,116 --> 00:31:16,136
我要输入一个


820
00:31:16,166 --> 00:31:17,786
开闭括号，


821
00:31:17,996 --> 00:31:19,706
这就用这个短语，


822
00:31:19,826 --> 00:31:22,526
它会取我的字符串，它会把它转换成小写的。


823
00:31:22,706 --> 00:31:27,086
你们可以看到，我们在这里有一个草案，但它完全是小写的。


824
00:31:27,356 --> 00:31:31,076
我也可以对大写字母做同样的事情所以我可以说短语点


825
00:31:31,196 --> 00:31:31,766
上部


826
00:31:32,216 --> 00:31:34,586
这将把整个字符串转换成


827
00:31:34,616 --> 00:31:36,116
上面的例子，你可以看到它是


828
00:31:36,146 --> 00:31:37,406
完全大写。


829
00:31:37,466 --> 00:31:38,996
除了


830
00:31:39,026 --> 00:31:40,587
将字符串转换为大写字母


831
00:31:40,617 --> 00:31:41,157
小写字母


832
00:31:41,187 --> 00:31:41,727
我也可以


833
00:31:41,757 --> 00:31:46,167
检查一个字符串是否是完全大写的，是完全小写的。


834
00:31:46,617 --> 00:31:48,627
举个例子，我可以说，短语点


835
00:31:48,657 --> 00:31:49,647
是上。


836
00:31:49,917 --> 00:31:53,517
这将会给我一个真实或错误的值


837
00:31:53,547 --> 00:31:54,837
所以这是正确的


838
00:31:55,077 --> 00:31:57,057
如果字符串是大写的


839
00:31:57,087 --> 00:31:57,777
或假


840
00:31:57,807 --> 00:31:58,617
如果不是。


841
00:31:59,097 --> 00:32:02,067
你可以看到这里我们得到了一个假值，因为这个


842
00:32:02,097 --> 00:32:02,457
是


843
00:32:02,487 --> 00:32:03,207
大写字母


844
00:32:03,747 --> 00:32:08,817
我也可以把这些函数组合在一起例如，


845
00:32:08,877 --> 00:32:10,647
我可以说


846
00:32:11,457 --> 00:32:11,907
点


847
00:32:11,967 --> 00:32:12,627
上部


848
00:32:13,017 --> 00:32:13,557
这是a


849
00:32:13,617 --> 00:32:14,577
圆括号


850
00:32:14,937 --> 00:32:16,647
在这之后，

851
00:32:17,068 --> 00:32:17,698
在上


852
00:32:17,728 --> 00:32:20,398
现在它要做的是，它会运行这个


853
00:32:20,428 --> 00:32:21,418
上函数，


854
00:32:21,628 --> 00:32:23,458
它会把它转换成大写。


855
00:32:23,638 --> 00:32:24,928
然后它会运行这个


856
00:32:24,988 --> 00:32:27,088
在那之后是上函数


857
00:32:27,208 --> 00:32:33,028
你会看到，我们会得到一个真正的值因为它会把整个东西转换成大写的。


858
00:32:33,298 --> 00:32:36,058
你可以看到，我们得到了一个真正的值


859
00:32:36,388 --> 00:32:37,468
这些功能的新闻


860
00:32:37,498 --> 00:32:39,808
一个接一个地，它真的很有用。


861
00:32:40,318 --> 00:32:43,379
还有一些其他的我想给你们看的所以我们也可以


862
00:32:43,469 --> 00:32:44,849
算出长度


863
00:32:44,909 --> 00:32:45,329
在


864
00:32:45,389 --> 00:32:46,829
这个字符串


865
00:32:47,159 --> 00:32:50,099
如果我想算出里面有多少个字符


866
00:32:50,129 --> 00:32:51,509
我可以这么说


867
00:32:51,539 --> 00:32:52,349
l e n


868
00:32:52,709 --> 00:32:53,759
我要做的是


869
00:32:53,789 --> 00:32:54,959
开括号，


870
00:32:55,169 --> 00:32:57,149
我要做一个闭合的括号。


871
00:32:57,389 --> 00:32:58,679
所以我的意思是


872
00:32:58,709 --> 00:33:01,859
外星人，这是另一个函数它是长度函数。


873
00:33:02,129 --> 00:33:05,519
在这个外星人的函数里，我实际上是在传递


874
00:33:05,549 --> 00:33:06,059
这个


875
00:33:06,269 --> 00:33:07,529
短语变量


876
00:33:07,829 --> 00:33:12,509
基本上是给出长度函数这个它会吐出一个数字告诉我有多少


877
00:33:12,569 --> 00:33:14,369
字符在这个字符串的内部。


878
00:33:15,059 --> 00:33:20,639
正如你们所看到的，我们得到了15个，因为在德拉夫学院里面有15个字符。


879
00:33:20,999 --> 00:33:25,889
这就是你如何得到整个字符串的长度这将会非常有用当我们在python中前进的时候。


880
00:33:25,949 --> 00:33:26,969
我们也可以得到


881
00:33:26,999 --> 00:33:29,789
字符串中的单个字符


882
00:33:30,089 --> 00:33:34,589
想象一下，如果我想要抓住其中的一个字符想象一下如果我想要


883
00:33:34,619 --> 00:33:37,379
找出字符串中的第一个字符是什么


884
00:33:37,739 --> 00:33:38,969
我们将实际使用


885
00:33:39,029 --> 00:33:40,020
打开一个封闭的


886
00:33:40,050 --> 00:33:41,190
方括号


887
00:33:41,220 --> 00:33:42,120
就像这样。


888
00:33:42,360 --> 00:33:44,340
在这里我可以指定


889
00:33:44,370 --> 00:33:46,620
我想要画出的字符的索引。


890
00:33:46,920 --> 00:33:49,860
如果我想要获取字符串中的第一个字符


891
00:33:49,890 --> 00:33:51,390
我可以把它设为零。


892
00:33:51,690 --> 00:33:53,100
所以如果我说


893
00:33:53,130 --> 00:33:54,570
方括号，


894
00:33:54,750 --> 00:33:57,060
这就给了我大写g


895
00:33:57,300 --> 00:33:58,710
你可以看到这里


896
00:33:58,740 --> 00:34:00,090
这就是打印出来的东西。


897
00:34:00,450 --> 00:34:01,771
现在我想指出一点


898
00:34:01,860 --> 00:34:02,401
在


899
00:34:02,521 --> 00:34:03,421
python。


900
00:34:03,541 --> 00:34:05,131
当我们处理字符串时。


901
00:34:05,461 --> 00:34:06,211
一根弦


902
00:34:06,241 --> 00:34:07,141
被索引


903
00:34:07,171 --> 00:34:08,460
从零开始。


904
00:34:08,730 --> 00:34:11,700
所以你会注意到，为了得到这个g。


905
00:34:11,791 --> 00:34:13,501
我必须在这里放一个0。


906
00:34:13,801 --> 00:34:15,361
这是因为在python里。


907
00:34:15,781 --> 00:34:18,931
当我们在一个字符串上使用索引时我们从0开始


908
00:34:19,171 --> 00:34:21,841
如果python在计算字符


909
00:34:22,051 --> 00:34:25,771
或者它对字符串中的字符进行索引它将从0开始，所以它会说


910
00:34:25,981 --> 00:34:27,001
g=0


911
00:34:27,361 --> 00:34:28,981
就像我一样


912
00:34:29,011 --> 00:34:29,761
一段历史。


913
00:34:30,061 --> 00:34:32,431
所以我们说g在位置


914
00:34:32,461 --> 00:34:33,871
在弦中是零。


915
00:34:33,931 --> 00:34:35,402
我在位置1


916
00:34:35,732 --> 00:34:36,962
r在位置2


917
00:34:36,992 --> 00:34:38,702
a在位置3等。


918
00:34:38,942 --> 00:34:40,382
所以我们开始计数


919
00:34:40,412 --> 00:34:41,462
在0点。


920
00:34:42,302 --> 00:34:43,712
如果我想要访问


921
00:34:43,952 --> 00:34:44,672
第一个


922
00:34:45,122 --> 00:34:46,413
字符串中的字符。


923
00:34:46,593 --> 00:34:48,753
这个g，我必须说


924
00:34:48,783 --> 00:34:50,613
零，这是一件很特别的事情


925
00:34:51,062 --> 00:34:53,942
在python和大多数编程语言中


926
00:34:53,972 --> 00:34:55,322
这样他们就从


927
00:34:55,352 --> 00:34:55,982
零。


928
00:34:56,342 --> 00:34:58,262
举个例子，如果我想要访问这个


929
00:34:58,292 --> 00:34:58,802
ei，


930
00:34:59,042 --> 00:35:00,002
我要把它放在


931
00:35:00,032 --> 00:35:00,873
零


932
00:35:02,493 --> 00:35:03,033
一


933
00:35:03,063 --> 00:35:06,213
两个3，所以我在这里放了三个


934
00:35:06,453 --> 00:35:08,643
现在就可以访问它了


935
00:35:08,703 --> 00:35:09,123
a。


936
00:35:09,363 --> 00:35:10,474
正如你所看到的，我们得到了一个


937
00:35:10,504 --> 00:35:11,434
a在这里，


938
00:35:11,824 --> 00:35:12,784
所以这个


939
00:35:12,844 --> 00:35:16,924
能够在字符串中获取特定字符是非常有用的


940
00:35:16,984 --> 00:35:17,914
你将会使用它


941
00:35:17,944 --> 00:35:19,895
在我们前进和python的过程中


942
00:35:20,015 --> 00:35:23,795
这也是我们可以使用的另一个非常棒的函数它被称为


943
00:35:23,825 --> 00:35:24,905
索引函数。


944
00:35:25,685 --> 00:35:28,895
基本上，索引函数会告诉我们


945
00:35:28,925 --> 00:35:30,635
具体的


946
00:35:30,666 --> 00:35:33,335
字符或字符串位于


947
00:35:33,365 --> 00:35:35,615
在我们的弦里，像不安全的短语


948
00:35:36,005 --> 00:35:36,335
点


949
00:35:36,365 --> 00:35:37,085
索引。


950
00:35:37,415 --> 00:35:37,895
并且


951
00:35:38,105 --> 00:35:42,906
我可以给它一个值当我们在python中使用这些函数时，


952
00:35:43,146 --> 00:35:45,966
我们可以给他们提供信息这样我就可以给他们


953
00:35:45,996 --> 00:35:46,746
价值


954
00:35:47,076 --> 00:35:50,286
我们把这个叫做传递一个参数


955
00:35:50,376 --> 00:35:53,076
我把它命名为一个函数值


956
00:35:53,106 --> 00:35:55,266
一个参数，你会经常听到这个词。


957
00:35:55,656 --> 00:35:56,346
所以


958
00:35:56,436 --> 00:35:58,686
例如，我可以在这里说


959
00:35:58,716 --> 00:35:59,886
国会议员，


960
00:36:00,066 --> 00:36:01,926
现在它会返回


961
00:36:01,956 --> 00:36:02,826
索引


962
00:36:02,856 --> 00:36:03,276
在


963
00:36:03,306 --> 00:36:05,526
我们的字符串里面的g


964
00:36:05,736 --> 00:36:07,236
所以它应该还给我们


965
00:36:07,266 --> 00:36:09,907
0因为g在指数的0处


966
00:36:10,267 --> 00:36:13,717
你会看到这里是零，因为g在这里。


967
00:36:14,137 --> 00:36:15,847
举个例子，如果我输入


968
00:36:15,877 --> 00:36:17,677
a里面的这个像小写的


969
00:36:17,707 --> 00:36:18,037
a


970
00:36:18,067 --> 00:36:21,247
它应该给我0 1 2 3


971
00:36:21,457 --> 00:36:22,987
因为这是第一个


972
00:36:23,047 --> 00:36:24,697
援助就在这个弦里，


973
00:36:25,207 --> 00:36:26,527
我可以点击播放按钮


974
00:36:26,917 --> 00:36:28,327
你会看到它给了我们


975
00:36:28,357 --> 00:36:28,957
三。


976
00:36:29,257 --> 00:36:32,647
你也可以把实际的单词放在这里比如我可以把


977
00:36:32,948 --> 00:36:34,177
学院在这里，


978
00:36:34,448 --> 00:36:35,857
或者我可以把它放

979
00:36:35,917 --> 00:36:37,208
a c d。


980
00:36:37,508 --> 00:36:40,507
这将告诉我这是从哪里开始的


981
00:36:40,537 --> 00:36:42,787
在我的字符串里，当我点击播放时，


982
00:36:43,177 --> 00:36:43,957
它会给我一个


983
00:36:44,317 --> 00:36:44,887
因为


984
00:36:44,917 --> 00:36:45,698
这就是


985
00:36:45,758 --> 00:36:47,138
一只猫，他从右边开始


986
00:36:47,438 --> 00:36:49,928
0 1 2 3 4 5 6 7


987
00:36:49,958 --> 00:36:50,319
八


988
00:36:51,129 --> 00:36:55,749
如果我在这里放一些不属于字符串的东西例如，如果我在这里放一个z，


989
00:36:56,109 --> 00:36:57,039
这不在这里。


990
00:36:57,129 --> 00:37:01,389
它实际上会抛出一个错误当我播放这个时你会看到我们在这里得到了这个错误


991
00:37:01,989 --> 00:37:04,809
在我们的程序中没有发现z


992
00:37:04,959 --> 00:37:08,709
下一个函数会很有用我们会经常用到它。


993
00:37:08,769 --> 00:37:11,049
还有一个比我想给你们看的还要多


994
00:37:11,079 --> 00:37:12,579
被称为替代


995
00:37:12,609 --> 00:37:15,010
所以我们可以用短语代替


996
00:37:15,310 --> 00:37:17,410
在这里我可以给出这个


997
00:37:17,440 --> 00:37:20,440
两个参数，我可以给这个替换函数


998
00:37:20,770 --> 00:37:22,510
它可以使用两个值。


999
00:37:22,750 --> 00:37:24,100
首先我想告诉你们的是


1000
00:37:24,130 --> 00:37:27,221
我想要替换的是我想说的


1001
00:37:27,251 --> 00:37:27,941
长颈鹿。


1002
00:37:28,421 --> 00:37:30,341
然后我在这里加个逗号，


1003
00:37:30,611 --> 00:37:33,101
我想把我想要替换的东西放到这里


1004
00:37:33,131 --> 00:37:35,260
所以我可以这样说


1005
00:37:35,381 --> 00:37:36,041
象


1006
00:37:36,401 --> 00:37:39,641
现在，我们不再说draff学院这将会打印出来


1007
00:37:39,671 --> 00:37:40,901
大象学院。


1008
00:37:41,321 --> 00:37:43,991
所以你可以看到这里，它就像大象学院一样


1009
00:37:44,201 --> 00:37:45,161
这个替换


1010
00:37:45,191 --> 00:37:45,701
功能


1011
00:37:45,731 --> 00:37:46,181
可以


1012
00:37:46,211 --> 00:37:47,831
真的很棒因为我们可以替代


1013
00:37:48,041 --> 00:37:48,641
确定的


1014
00:37:48,911 --> 00:37:50,802
单词，甚至是特定的字母


1015
00:37:50,832 --> 00:37:52,092
在我们的弹簧里


1016
00:37:52,182 --> 00:37:52,842
其他的。


1017
00:37:52,932 --> 00:37:58,002
这些是我们在python内部处理字符串的一些基本方法


1018
00:37:58,032 --> 00:37:58,302
并且


1019
00:37:58,542 --> 00:38:01,842
有很多不同的函数我们可以用字符串来使用。


1020
00:38:02,052 --> 00:38:05,202
这些是我刚才给你们看的最常见的一些，


1021
00:38:05,472 --> 00:38:08,263
但是如果你只做一个谷歌搜索你可以找到各种各样的


1022
00:38:08,503 --> 00:38:11,353
你可以尝试使用的python函数，你知道，


1023
00:38:11,563 --> 00:38:12,523
看看他们做了什么，


1024
00:38:12,913 --> 00:38:17,322
但是你肯定想要熟悉字符串和python因为你要和它们一起工作


1025
00:38:17,352 --> 00:38:17,892
很多。


1026
00:38:21,912 --> 00:38:25,902
在本教程中，我想和大家讨论一下如何处理数字


1027
00:38:25,962 --> 00:38:26,652
蟒蛇


1028
00:38:27,042 --> 00:38:28,362
数字是最重要的


1029
00:38:28,392 --> 00:38:30,882
在python中常见的数据类型


1030
00:38:31,212 --> 00:38:35,173
你写的任何python程序都很可能是在处理数字


1031
00:38:35,203 --> 00:38:36,073
某一点


1032
00:38:36,103 --> 00:38:36,403
所以


1033
00:38:36,703 --> 00:38:43,003
我想和你们讨论一下使用数字的基础知识我们可以讨论在python中可以用不同的数字来表示。


1034
00:38:43,453 --> 00:38:44,924
我还想向你们展示一些


1035
00:38:44,954 --> 00:38:51,194
我们可以用数字来做一些很棒的函数这样我们就可以做一个类似于数学运算的机制


1036
00:38:51,224 --> 00:38:52,214
了不起的事情


1037
00:38:52,484 --> 00:38:54,014
有了数字，我将向你们展示


1038
00:38:54,044 --> 00:38:56,385
在这个视频中，所有这些都是很棒的


1039
00:38:57,014 --> 00:38:58,034
我们能做的第一件事是


1040
00:38:58,334 --> 00:39:00,375
实际上我们可以打印出一个数字。


1041
00:39:00,615 --> 00:39:05,865
所以如果我想在python里写一个数字很简单，我只要把数字写出来就可以像打印一样


1042
00:39:05,896 --> 00:39:06,466
还有。


1043
00:39:06,796 --> 00:39:10,096
这将把数字2打印到屏幕上，


1044
00:39:10,666 --> 00:39:15,977
所以我可以用一个像这样的整数我也可以用一个小数所以我可以说是两个点


1045
00:39:16,007 --> 00:39:17,237
哦，九八七


1046
00:39:17,657 --> 00:39:20,988
而蟒蛇也会很好我们可以把它打印出来


1047
00:39:21,018 --> 00:39:21,918
屏幕也一样。


1048
00:39:22,368 --> 00:39:23,658
我也可以做数字


1049
00:39:23,688 --> 00:39:25,428
负的，所以我可以做这个


1050
00:39:25,458 --> 00:39:25,908
二点


1051
00:39:25,938 --> 00:39:26,418
哦，九


1052
00:39:26,478 --> 00:39:27,168
八七


1053
00:39:27,198 --> 00:39:28,668
一个负数


1054
00:39:28,968 --> 00:39:31,548
python也能处理得很好。


1055
00:39:32,358 --> 00:39:35,057
在python中，我们也可以使用


1056
00:39:35,117 --> 00:39:39,048
基本算术我可以做加法减法乘法


1057
00:39:39,348 --> 00:39:40,008
幻想


1058
00:39:40,038 --> 00:39:40,638
三


1059
00:39:40,668 --> 00:39:41,868
加4


1060
00:39:41,958 --> 00:39:45,108
现在要把它打印出来或者他喜欢3+


1061
00:39:45,138 --> 00:39:46,428
四点五。


1062
00:39:46,999 --> 00:39:50,509
这样就能打印出答案，得到七点五。


1063
00:39:50,779 --> 00:39:53,149
我们可以做一道菜，我们可以做减法。


1064
00:39:53,479 --> 00:39:54,530
我们可以做除法


1065
00:39:54,560 --> 00:39:56,930
或者我们也可以做乘法，这样你就可以


1066
00:39:56,960 --> 00:39:59,690
在python里做任何你想做的事，


1067
00:40:00,170 --> 00:40:05,031
如果你想做更复杂的数学方程我们也可以用


1068
00:40:05,571 --> 00:40:08,121
指定操作顺序的东西


1069
00:40:08,151 --> 00:40:09,591
所以我可以用括号。


1070
00:40:10,071 --> 00:40:13,730
举个例子，如果我说3乘以4加5


1071
00:40:14,601 --> 00:40:23,031
python要做的是，它会把3和4相乘，所以它等于12，然后加上5，所以我们应该得到17。


1072
00:40:24,201 --> 00:40:26,301
但是假设我们想要改变顺序


1073
00:40:26,331 --> 00:40:26,631
对的


1074
00:40:26,661 --> 00:40:29,991
我可以在4和5的地方放一个括号


1075
00:40:30,501 --> 00:40:31,401
现在


1076
00:40:31,461 --> 00:40:38,391
它会增加第一个社会广告外国战士将会得到9，并将其乘以3所以我们最终会得到27，


1077
00:40:38,871 --> 00:40:45,141
你可以看到我们可以用这些括号来指定操作的顺序所以我可以把它做成一个非常复杂的


1078
00:40:45,711 --> 00:40:49,011
这里的小方程，用数字和括号。


1079
00:40:49,161 --> 00:40:50,421
我们也可以


1080
00:40:50,481 --> 00:40:54,861
使用另一种操作，它被称为模态运算符所以我可以这样说


1081
00:40:54,891 --> 00:40:55,641
泰德，


1082
00:40:55,941 --> 00:40:57,741
使用这个百分号


1083
00:40:58,011 --> 00:40:59,961
第三个，这是真正的阅读


1084
00:40:59,991 --> 00:41:00,501
十


1085
00:41:00,531 --> 00:41:01,221
模


1086
00:41:01,251 --> 00:41:01,791
三


1087
00:41:02,181 --> 00:41:05,211
基本上它要做的就是取第一个数字


1088
00:41:05,421 --> 00:41:07,221
除以第二个数字，


1089
00:41:07,312 --> 00:41:09,232
它会把剩下的部分吐出来。


1090
00:41:09,472 --> 00:41:10,552
所以它基本上会说


1091
00:41:10,582 --> 00:41:10,912
好的


1092
00:41:10,942 --> 00:41:12,562
10除以3。


1093
00:41:12,772 --> 00:41:14,062
这将是3


1094
00:41:14,092 --> 00:41:15,562
剩下的一个。


1095
00:41:15,832 --> 00:41:17,872
这就得到了余数。


1096
00:41:18,172 --> 00:41:18,682
并且


1097
00:41:18,742 --> 00:41:20,932
你会看到这里我们得到了一个，因为


1098
00:41:20,962 --> 00:41:23,422
这是剩下的10除以3


1099
00:41:23,692 --> 00:41:26,512
这个调节操作符可以很方便地使用。


1100
00:41:26,662 --> 00:41:28,192
我们也可以存储这些


1101
00:41:28,852 --> 00:41:30,623
变量内的数字


1102
00:41:30,653 --> 00:41:32,393
所以我们可以把它们储存在这些里面


1103
00:41:32,423 --> 00:41:33,653
可变容器，


1104
00:41:33,923 --> 00:41:34,523
所以我可以


1105
00:41:34,553 --> 00:41:35,573
到这里来


1106
00:41:35,663 --> 00:41:37,523
我可以创建一个名为like的变量


1107
00:41:37,613 --> 00:41:39,143
我强调的gnome


1108
00:41:39,833 --> 00:41:41,663
我们只需要存储一个值


1109
00:41:41,693 --> 00:41:43,313
假设是5，这里


1110
00:41:43,673 --> 00:41:47,364
你为什么到这里来，我可以把我的下划线打印出来。


1111
00:41:47,694 --> 00:41:50,154
我们可以把这个数字打印到屏幕上


1112
00:41:50,184 --> 00:41:50,964
很好。


1113
00:41:51,114 --> 00:41:54,054
除了做一些基本的算术运算之外


1114
00:41:54,084 --> 00:41:55,584
我们也可以


1115
00:41:55,734 --> 00:42:00,923
做一些其他的事情，我可以做的一件事是我可以把这个数字转换成一个字符串。


1116
00:42:01,283 --> 00:42:05,244
所以如果我想把这个数转换成一个字符串我就可以说s t r


1117
00:42:05,664 --> 00:42:08,274
我可以把我想要转换的数字


1118
00:42:08,304 --> 00:42:10,134
在括号里面。


1119
00:42:10,434 --> 00:42:14,125
所以现在要发生的是这个数字将会被转换


1120
00:42:14,425 --> 00:42:14,905
进入


1121
00:42:14,935 --> 00:42:16,434
当我点击时，字符串


1122
00:42:16,554 --> 00:42:17,694
运行按钮，你会看到它是


1123
00:42:17,904 --> 00:42:22,434
只打印出5个，而不是一个数字，这实际上是一个字符串。


1124
00:42:22,764 --> 00:42:26,814
当你想要打印出数字的时候这就很方便了


1125
00:42:26,844 --> 00:42:27,715
字符串，


1126
00:42:28,045 --> 00:42:29,995
所以我可以到这里来，我可以说


1127
00:42:30,475 --> 00:42:31,195
我的


1128
00:42:32,245 --> 00:42:33,415
最喜欢的数字，


1129
00:42:33,895 --> 00:42:35,395
我们可以打印出来


1130
00:42:35,425 --> 00:42:37,345
与此同时


1131
00:42:37,375 --> 00:42:39,085
所以我点击play，


1132
00:42:39,295 --> 00:42:41,155
这是我最喜欢的5个数字，


1133
00:42:41,485 --> 00:42:43,314
如果我要删掉这个


1134
00:42:43,344 --> 00:42:44,094
弦


1135
00:42:44,155 --> 00:42:44,814
就在这里


1136
00:42:44,844 --> 00:42:47,515
我并没有把这个数字转换成字符串。


1137
00:42:47,815 --> 00:42:49,855
现在，蟒蛇会对这个有问题。


1138
00:42:50,035 --> 00:42:52,585
它不允许我们这样做你可以看到我们得到了一个


1139
00:42:52,615 --> 00:42:53,305
错误


1140
00:42:53,545 --> 00:42:55,255
任何时候你想要打印出一个数字


1141
00:42:55,285 --> 00:42:59,245
在字符串旁边，你要确保你使用了这个小字符串函数。


1142
00:42:59,995 --> 00:43:00,445
所以


1143
00:43:00,475 --> 00:43:03,505
还有很多其他的东西我们可以用数字来做


1144
00:43:03,625 --> 00:43:05,096
在python中很多时候


1145
00:43:05,126 --> 00:43:07,315
你会想要使用特定的


1146
00:43:07,345 --> 00:43:10,135
代谢更高级的数学运算符


1147
00:43:10,525 --> 00:43:12,145
有很多不同的数学


1148
00:43:12,175 --> 00:43:14,605
我们可以在数字上使用的函数


1149
00:43:14,815 --> 00:43:19,435
一个函数基本上就像一个小的代码集合它做了一些事情


1150
00:43:19,705 --> 00:43:24,235
一个函数可以执行一个操作，就像我们的数字上的数学运算一样，


1151
00:43:24,715 --> 00:43:27,385
我们也可以提供关于我们的数字的信息，


1152
00:43:27,625 --> 00:43:32,036
我相信你们会在python中使用一些最常用的函数


1153
00:43:32,066 --> 00:43:33,176
与数字有关。


1154
00:43:33,746 --> 00:43:35,456
第一个叫做


1155
00:43:35,906 --> 00:43:36,626
abs


1156
00:43:36,656 --> 00:43:40,255
它代表绝对值所以我们可以得到绝对值


1157
00:43:40,555 --> 00:43:41,005
在


1158
00:43:41,035 --> 00:43:41,666
一个数字。


1159
00:43:42,476 --> 00:43:43,676
在这里，我要


1160
00:43:43,706 --> 00:43:45,656
使这个变量为-5


1161
00:43:46,135 --> 00:43:47,396
基本上我可以说


1162
00:43:48,476 --> 00:43:49,106
我可以做一个


1163
00:43:49,166 --> 00:43:51,146
在这里开个括号，


1164
00:43:51,536 --> 00:43:54,445
这就给了我一个绝对值


1165
00:43:54,475 --> 00:43:55,825
上面这个数字，


1166
00:43:56,215 --> 00:43:57,655
当我点击播放按钮时，


1167
00:43:57,925 --> 00:44:03,445
你会看到它给出了5，因为5是-5的绝对值，


1168
00:44:03,625 --> 00:44:06,205
我可以使用其他一些函数还有一个函数


1169
00:44:06,235 --> 00:44:07,105
这叫做


1170
00:44:07,225 --> 00:44:09,745
保罗说的是p o w


1171
00:44:10,105 --> 00:44:12,956
实际上我不打算用这个变量我们只是一个普通的数字


1172
00:44:13,436 --> 00:44:13,766
并且


1173
00:44:13,796 --> 00:44:16,166
这个函数可以让我们通过它


1174
00:44:16,226 --> 00:44:19,346
对于信息片段，我可以给出这个函数


1175
00:44:19,376 --> 00:44:20,606
两个信息。


1176
00:44:20,967 --> 00:44:22,227
第一个将会是


1177
00:44:22,646 --> 00:44:23,636
就像一个数字。


1178
00:44:23,816 --> 00:44:28,827
第二个是我想要的第二个数字所以我可以说是3


1179
00:44:29,187 --> 00:44:29,727
逗号


1180
00:44:29,757 --> 00:44:30,327
二


1181
00:44:30,597 --> 00:44:32,517
这基本上就是


1182
00:44:32,577 --> 00:44:33,297
三


1183
00:44:33,327 --> 00:44:34,917
上升到2的幂，


1184
00:44:35,217 --> 00:44:35,757
所以


1185
00:44:35,817 --> 00:44:38,817
它就是3的平方所以我们应该在这里得到9，


1186
00:44:39,177 --> 00:44:40,167
你可以看到我们这样做，


1187
00:44:40,557 --> 00:44:41,787
所以我可以像


1188
00:44:41,817 --> 00:44:42,177
你知道


1189
00:44:42,208 --> 00:44:43,318
一些疯狂的数字


1190
00:44:43,558 --> 00:44:45,088
我们可以通过一个4


1191
00:44:45,118 --> 00:44:47,488
我们可以把它提高到6的幂，


1192
00:44:47,788 --> 00:44:49,588
所以我们应该得到一个相当大的数字


1193
00:44:50,008 --> 00:44:52,648
你可以看到我们得到了四千零九十六


1194
00:44:53,098 --> 00:44:53,458
这个


1195
00:44:53,489 --> 00:44:56,938
幂函数对于把数字精确到具体是很有用的


1196
00:44:56,969 --> 00:44:57,598
权力。


1197
00:44:57,988 --> 00:45:02,638
除了使用这个幂函数之外我们还可以使用另一个函数


1198
00:45:02,668 --> 00:45:03,628
马克斯。


1199
00:45:03,898 --> 00:45:05,188
所以我可以说max。


1200
00:45:05,338 --> 00:45:08,248
它的作用是，它会返回


1201
00:45:08,278 --> 00:45:11,128
我们传递给它的两个数字中较大的一个


1202
00:45:11,398 --> 00:45:12,748
现在我要给出

1203
00:45:12,778 --> 00:45:14,338
4和6


1204
00:45:14,518 --> 00:45:16,828
这应该告诉我们哪个数更高


1205
00:45:17,158 --> 00:45:20,458
所以这里是6，因为这是更大的数。


1206
00:45:20,728 --> 00:45:22,558
我看不出另一个函数


1207
00:45:22,588 --> 00:45:28,739
而男性则会做相反的事情所以现在我们不用打印出最大的数字而是打印出最小的数字。


1208
00:45:29,009 --> 00:45:31,739
就像你们看到的一样，它会在下面出现。


1209
00:45:32,039 --> 00:45:34,919
另一个很酷的函数叫做圆函数


1210
00:45:34,949 --> 00:45:40,409
这将允许我们对一个数字进行四舍五入所以它就像标准的舍入规则一样。


1211
00:45:40,709 --> 00:45:43,469
如果我说的是3点到这里


1212
00:45:43,739 --> 00:45:44,999
现在是绕着它转


1213
00:45:45,029 --> 00:45:47,099
一直到正常的3


1214
00:45:47,129 --> 00:45:49,229
但如果我说的是三点七。


1215
00:45:49,949 --> 00:45:54,150
它会把它四舍五入到4，这样你就可以四舍五入一个数字了。


1216
00:45:54,660 --> 00:45:58,500
这里还有一些其他的函数我想给你们看，但是为了


1217
00:45:58,530 --> 00:46:01,830
访问它们，我要做的是


1218
00:46:01,890 --> 00:46:02,640
进口


1219
00:46:03,180 --> 00:46:05,430
在python里，我们可以


1220
00:46:06,360 --> 00:46:07,650
外部代码


1221
00:46:08,040 --> 00:46:10,890
在我们的文件中如果我想要访问这些文件


1222
00:46:10,920 --> 00:46:11,610
特定的


1223
00:46:11,640 --> 00:46:12,720
数学函数。


1224
00:46:13,260 --> 00:46:15,601
我需要导入一个叫做python数学的东西


1225
00:46:15,631 --> 00:46:17,281
所以我可以从


1226
00:46:17,521 --> 00:46:18,990
这里的数学


1227
00:46:21,331 --> 00:46:24,450
而这个恒星，基本上它会做的是，它会


1228
00:46:24,690 --> 00:46:26,130
走出去，它会抓住


1229
00:46:26,190 --> 00:46:29,371
我们可以使用很多不同的数学函数


1230
00:46:29,611 --> 00:46:33,961
我已经给你们展示了一些拉链的数学函数但实际上还有很多。


1231
00:46:34,322 --> 00:46:38,762
为了访问它们，我们需要将这行代码包含在我们的文件中。


1232
00:46:39,062 --> 00:46:42,032
所以一旦我们有了这个，我就可以访问其他的了


1233
00:46:42,062 --> 00:46:44,942
是另一种叫做地板方法的函数它只是


1234
00:46:45,002 --> 00:46:46,082
f l o r


1235
00:46:46,472 --> 00:46:48,962
它会做的是，它会抓取


1236
00:46:48,992 --> 00:46:49,532
那


1237
00:46:49,562 --> 00:46:53,252
最低的数，所以它本质上就是要把这个小数点切掉。


1238
00:46:53,762 --> 00:46:55,292
你可以看到这里


1239
00:46:55,322 --> 00:46:57,872
我们得到一个3因为我们用的是这个地板函数。


1240
00:46:58,232 --> 00:46:59,462
还有一个叫做


1241
00:46:59,492 --> 00:47:00,302
海豹。


1242
00:47:00,722 --> 00:47:04,382
这就正好相反了所以这就绕着数字转了一圈


1243
00:47:04,412 --> 00:47:05,552
无论如何


1244
00:47:05,612 --> 00:47:07,652
无论什么事情总能得到


1245
00:47:07,922 --> 00:47:10,022
这里我们有一个3点


1246
00:47:10,322 --> 00:47:14,732
还有一个叫做平方根的东西所以它只是问你我们的团队


1247
00:47:15,062 --> 00:47:19,712
本质上，这将返回一个数字的平方根所以我可以说


1248
00:47:19,742 --> 00:47:20,702
三十六。


1249
00:47:20,972 --> 00:47:22,772
现在我们应该得到6。


1250
00:47:23,522 --> 00:47:24,242
所以


1251
00:47:24,332 --> 00:47:26,552
这些都是非常有趣的函数


1252
00:47:26,912 --> 00:47:28,082
在这里面


1253
00:47:28,112 --> 00:47:34,202
数学模块，所以我们把它叫做模块你不用太担心它现在是什么，


1254
00:47:34,532 --> 00:47:37,862
只需要知道当我们把这行代码放到程序中


1255
00:47:37,892 --> 00:47:40,232
它让我们可以接触到更多的东西


1256
00:47:40,262 --> 00:47:41,012
数学


1257
00:47:41,492 --> 00:47:42,332
尽管如此


1258
00:47:42,572 --> 00:47:45,842
它基本上允许我们用数学做更多的事情


1259
00:47:45,872 --> 00:47:46,982
在我们的程序中


1260
00:47:47,312 --> 00:47:49,653
这里有很多不同的数学函数


1261
00:47:49,863 --> 00:47:54,483
在python里，如果你为什么可以上网搜索不同的数学函数。


1262
00:47:54,783 --> 00:47:58,804
我给你们看了一些我想说的是我们在这里看到的


1263
00:47:59,074 --> 00:48:02,524
可能是最常用的，但还有更多。


1264
00:48:02,764 --> 00:48:03,034
并且


1265
00:48:03,124 --> 00:48:04,174
就像我说的，你知道


1266
00:48:04,204 --> 00:48:07,324
关于所有这些东西的大量文档所以你可以查一下


1267
00:48:07,564 --> 00:48:09,004
你的数学函数


1268
00:48:09,034 --> 00:48:12,814
python会有很多很多类似的列表


1269
00:48:13,114 --> 00:48:16,594
你可以在程序里面使用不同的

1270
00:48:16,624 --> 00:48:17,404
操作，


1271
00:48:17,524 --> 00:48:24,334
但现在，这已经有点用数字了一点关于在某些数学运算和使用函数上做的事情


1272
00:48:24,425 --> 00:48:25,625
有了这些数字


1273
00:48:29,495 --> 00:48:31,715
在本教程中，我将向您展示如何获得


1274
00:48:31,745 --> 00:48:33,455
来自用户的输入。


1275
00:48:33,725 --> 00:48:36,575
所以我们基本上允许用户


1276
00:48:36,635 --> 00:48:39,305
输入信息到我们的程序中。


1277
00:48:39,605 --> 00:48:42,785
我将会获取用户输入的信息。


1278
00:48:42,995 --> 00:48:43,895
我要把它储存起来


1279
00:48:43,925 --> 00:48:47,646
在一个变量里面然后我们就可以用它来做一些事情


1280
00:48:47,706 --> 00:48:48,786
那个变量。


1281
00:48:49,266 --> 00:48:52,146
所以我想向你们展示我们如何才能真正做到


1282
00:48:52,206 --> 00:48:53,316
来自某人的输入。


1283
00:48:53,586 --> 00:48:55,656
在我的python文件中。


1284
00:48:56,166 --> 00:48:59,826
我要做的就是从别人那里得到输入我只要输入输出就行了


1285
00:48:59,886 --> 00:49:00,546
输入


1286
00:49:01,026 --> 00:49:02,556
然后是一个开放和封闭的


1287
00:49:02,586 --> 00:49:03,576
括号。


1288
00:49:03,936 --> 00:49:07,056
它的基本功能是它会告诉python


1289
00:49:07,086 --> 00:49:08,315
嘿，我们想要


1290
00:49:09,335 --> 00:49:10,745
python中的用户将会


1291
00:49:10,955 --> 00:49:12,485
允许用户


1292
00:49:12,515 --> 00:49:14,255
输入一些信息


1293
00:49:14,795 --> 00:49:17,585
在这些圆括号里我们可以

1294
00:49:17,615 --> 00:49:18,485
提示


1295
00:49:18,935 --> 00:49:22,175
所以通常当我们想让用户输入一些信息时


1296
00:49:22,205 --> 00:49:23,915
我们想告诉他们我们想要的是什么


1297
00:49:23,945 --> 00:49:24,605
进入。


1298
00:49:24,965 --> 00:49:27,545
这就是我们可以放入的东西，所以我想说。


1299
00:49:28,115 --> 00:49:29,225
进入你的


1300
00:49:29,255 --> 00:49:29,915
名字，


1301
00:49:30,875 --> 00:49:33,966
所以我们要创建一个小的python应用程序，


1302
00:49:34,296 --> 00:49:36,756
这将允许用户输入他们的名字


1303
00:49:37,056 --> 00:49:40,806
然后将名字存储在一个变量中然后我们就会


1304
00:49:40,836 --> 00:49:43,327
向用户问好，这样我们就会说


1305
00:49:43,597 --> 00:49:45,697
然后不管他们的名字是什么


1306
00:49:46,447 --> 00:49:49,117
所以我想要做的是，我想要存储


1307
00:49:49,147 --> 00:49:52,057
不管用户是什么，把它放到我们的程序中


1308
00:49:52,477 --> 00:49:54,007
在一个变量里面。


1309
00:49:54,217 --> 00:49:58,927
所以我可以到这里来创建一个变量我可以叫它名字


1310
00:49:59,347 --> 00:50:01,147
我可以设置这个变量


1311
00:50:01,207 --> 00:50:02,317
等于


1312
00:50:02,737 --> 00:50:03,307
输入。


1313
00:50:03,727 --> 00:50:07,957
所以我现在要做的是取用户输入的值


1314
00:50:08,437 --> 00:50:08,827
我是


1315
00:50:09,037 --> 00:50:10,537
把它存储在这个里面


1316
00:50:10,567 --> 00:50:12,277
可变容器


1317
00:50:12,337 --> 00:50:12,967
名字


1318
00:50:13,447 --> 00:50:14,407
所以现在


1319
00:50:14,827 --> 00:50:17,467
我可以进入他们输入的任何东西。


1320
00:50:17,797 --> 00:50:19,537
所以我们能做的是，我们可以说


1321
00:50:19,567 --> 00:50:20,287
打印


1322
00:50:21,007 --> 00:50:22,027
在里面


1323
00:50:22,057 --> 00:50:24,127
我可以把括号打印出来


1324
00:50:24,577 --> 00:50:25,207
你好


1325
00:50:26,257 --> 00:50:28,028
然后我再加上这个


1326
00:50:29,588 --> 00:50:31,688
实际上想要加一个感叹号。


1327
00:50:32,318 --> 00:50:35,498
本质上，我们从用户那里得到了一个名字。


1328
00:50:35,648 --> 00:50:37,868
在命名变量中恢复它


1329
00:50:38,018 --> 00:50:38,888
我在打印它


1330
00:50:38,918 --> 00:50:40,508
在屏幕上。


1331
00:50:40,778 --> 00:50:42,458
所以我要继续播放这个？


1332
00:50:42,848 --> 00:50:45,698
当我们运行程序时你会注意到这里


1333
00:50:45,728 --> 00:50:47,978
python给了我们这个小问题


1334
00:50:48,008 --> 00:50:48,668
所以它说


1335
00:50:48,698 --> 00:50:49,448
输入你的名字。


1336
00:50:49,838 --> 00:50:50,198
现在


1337
00:50:50,229 --> 00:50:54,099
在这里，我可以输入值，这样我就可以输入了。


1338
00:50:54,999 --> 00:50:56,528
然后点击回车


1339
00:50:57,218 --> 00:51:01,448
而python会继续把这个值存储在那个变量里面


1340
00:51:01,779 --> 00:51:03,159
然后它会打印出来


1341
00:51:03,909 --> 00:51:04,449
迈克。


1342
00:51:04,539 --> 00:51:05,979
这是很酷的


1343
00:51:06,009 --> 00:51:07,989
实际上我们可以做的是


1344
00:51:08,199 --> 00:51:11,919
提示用户输入超过一段信息。


1345
00:51:12,549 --> 00:51:13,839
所以实际上我可以


1346
00:51:13,869 --> 00:51:15,429
复制这行代码。


1347
00:51:16,119 --> 00:51:16,599
我是一个


1348
00:51:16,629 --> 00:51:17,889
粘贴在下面


1349
00:51:18,069 --> 00:51:21,310
为什么我们不让用户输入另一个变量呢？


1350
00:51:21,520 --> 00:51:23,679
所以我们可以让他们进入例如他们的


1351
00:51:23,709 --> 00:51:24,339
年龄。


1352
00:51:24,699 --> 00:51:26,859
在这里我们只想说输入你的


1353
00:51:28,570 --> 00:51:31,750
我们可以从用户那里得到两份信息。


1354
00:51:32,020 --> 00:51:33,640
我还可以打个招呼。


1355
00:51:34,030 --> 00:51:35,020
然后我可以说


1356
00:51:35,830 --> 00:51:36,820
你是


1357
00:51:37,240 --> 00:51:38,410
我把它们打印出来


1358
00:51:38,440 --> 00:51:38,860
年龄


1359
00:51:38,890 --> 00:51:40,030
所以我要打印


1360
00:51:41,170 --> 00:51:45,521
所以现在我基本上可以得到这两种信息


1361
00:51:45,551 --> 00:51:47,831
我可以从用户那里得到他们的名字


1362
00:51:48,161 --> 00:51:50,981
当我们运行这个程序时，我可以得到他们的

1363
00:51:52,421 --> 00:51:55,901
我可以输入这两个信息，当它们输入你的名字时。


1364
00:51:56,231 --> 00:51:56,801
所以


1365
00:51:56,831 --> 00:51:57,371
我们可以


1366
00:51:57,431 --> 00:51:58,961
编一个像约翰一样的名字


1367
00:51:59,261 --> 00:52:02,292
然后进入这个年龄说约翰是二十五岁


1368
00:52:02,802 --> 00:52:05,532
现在我想说你好，约翰，你是二十五岁。


1369
00:52:05,922 --> 00:52:09,102
所以程序可以从用户那里获得输入，然后


1370
00:52:09,132 --> 00:52:11,292
能够使用这些信息


1371
00:52:11,502 --> 00:52:13,572
为了向用户问好


1372
00:52:13,602 --> 00:52:15,102
告诉他们他们多大了，


1373
00:52:15,942 --> 00:52:20,922
从用户那里获得输入是让你的程序更具互动性的好方法


1374
00:52:21,222 --> 00:52:27,012
这里我们只是简单地说一下这个词基本上就是从用户那里了解到一段信息


1375
00:52:27,312 --> 00:52:29,143
你可以用这些输入来做


1376
00:52:29,203 --> 00:52:32,263
在python里，我们经历了这门课。


1377
00:52:32,503 --> 00:52:33,193
你会看到一些


1378
00:52:33,223 --> 00:52:34,903
我们能做的很酷的事情


1379
00:52:34,963 --> 00:52:36,283
有了这些输入


1380
00:52:40,124 --> 00:52:41,984
在本教程中，我将向您展示如何构建


1381
00:52:42,014 --> 00:52:45,254
这是一个非常基本的python计算器。


1382
00:52:45,584 --> 00:52:49,454
我们要建立一个计算器，从用户那里得到数字，


1383
00:52:49,664 --> 00:52:50,174
然后我们会


1384
00:52:50,204 --> 00:52:53,714
把这些数字加在一起，把答案打印出来放到屏幕上。


1385
00:52:54,044 --> 00:52:58,664
这将为我们提供一些从用户那里获取信息的实践我们也会讨论如何获得


1386
00:52:58,694 --> 00:53:01,034
来自用户的数字，而不是


1387
00:53:01,094 --> 00:53:01,904
字符串。


1388
00:53:02,204 --> 00:53:03,434
所以我很兴奋


1389
00:53:03,674 --> 00:53:04,964
开始用这个计算器。


1390
00:53:05,474 --> 00:53:07,005
我们要做的第一件事是


1391
00:53:07,035 --> 00:53:07,665
创造


1392
00:53:07,695 --> 00:53:09,045
两个变量


1393
00:53:09,105 --> 00:53:11,685
在这些变量中，我们想要存储


1394
00:53:11,745 --> 00:53:14,745
用户想要添加的两个数字


1395
00:53:15,195 --> 00:53:16,005
下面这里，


1396
00:53:16,095 --> 00:53:17,086
我只是想说，


1397
00:53:18,046 --> 00:53:18,855
第一，


1398
00:53:19,125 --> 00:53:20,776
这就是我们所说的第一个变量


1399
00:53:21,076 --> 00:53:21,316
是


1400
00:53:21,346 --> 00:53:22,216
等于。


1401
00:53:22,456 --> 00:53:25,396
现在我需要从用户那里得到输入，所以我要说。


1402
00:53:25,456 --> 00:53:26,146
输入


1403
00:53:26,566 --> 00:53:28,006
在这些括号里面


1404
00:53:28,036 --> 00:53:28,846
我要说。


1405
00:53:28,996 --> 00:53:30,826
输入一个数字，


1406
00:53:33,496 --> 00:53:36,046
现在我想要做同样的事情


1407
00:53:36,076 --> 00:53:36,736
东西


1408
00:53:36,766 --> 00:53:37,696
但

1409
00:53:37,726 --> 00:53:38,506
第二个数字，


1410
00:53:38,956 --> 00:53:40,606
我们把这个家伙放在下面，


1411
00:53:41,296 --> 00:53:43,456
我只会说gnome


1412
00:53:43,486 --> 00:53:44,086
二


1413
00:53:44,686 --> 00:53:45,796
然后我们会说


1414
00:53:45,976 --> 00:53:47,356
输入另一个数字。


1415
00:53:47,927 --> 00:53:50,207
现在我们可以存储用户的

1416
00:53:50,447 --> 00:53:51,377
在里面


1417
00:53:51,917 --> 00:53:52,637
变量。


1418
00:53:52,817 --> 00:53:56,507
现在我要做的就是打印出结果


1419
00:53:56,867 --> 00:54:01,308
我要创建一个名为result的变量某人会说一个结果


1420
00:54:01,548 --> 00:54:02,538
等于


1421
00:54:02,568 --> 00:54:06,168
基本上我们只是想把这两个数字加起来作为数字1


1422
00:54:06,468 --> 00:54:06,948
加上


1423
00:54:06,978 --> 00:54:07,518
麻木的


1424
00:54:07,548 --> 00:54:07,998
还有。


1425
00:54:08,988 --> 00:54:12,318
现在我们要做的就是打印出我要打印的结果


1426
00:54:12,918 --> 00:54:13,519
结果


1427
00:54:14,329 --> 00:54:14,899
所以


1428
00:54:14,929 --> 00:54:18,259
我们基本上把整个程序写在这里


1429
00:54:18,469 --> 00:54:22,878
这将允许我们输入两个数字然后把它们加在一起然后打印出答案


1430
00:54:24,948 --> 00:54:25,998
所以我可以玩。


1431
00:54:26,418 --> 00:54:29,268
下面我们可以输入我们的数字，


1432
00:54:29,328 --> 00:54:31,368
所以我要输入第一个数字，我们说5，


1433
00:54:32,088 --> 00:54:35,118
我要输入第二个数字，假设


1434
00:54:35,148 --> 00:54:36,828
八


1435
00:54:37,338 --> 00:54:38,508
或者是一个点


1436
00:54:38,718 --> 00:54:39,258
三


1437
00:54:40,278 --> 00:54:41,958
它现在应该打印出答案，


1438
00:54:42,228 --> 00:54:42,888
但是


1439
00:54:43,038 --> 00:54:44,628
如果你看这里。


1440
00:54:45,288 --> 00:54:49,188
这并不是我们在5+中寻找的答案


1441
00:54:49,218 --> 00:54:49,698
八点


1442
00:54:49,728 --> 00:54:52,968
三肯定不是五十八分

1443
00:54:53,328 --> 00:54:54,558
这就是所发生的事情


1444
00:54:55,218 --> 00:54:57,648
当我们从一个用户那里得到输入


1445
00:54:57,708 --> 00:54:59,178
在默认情况下。


1446
00:54:59,808 --> 00:55:01,518
python会进行转换


1447
00:55:01,548 --> 00:55:02,508
它变成了一个字符串，


1448
00:55:02,718 --> 00:55:04,458
所以不管我们放的是什么


1449
00:55:04,488 --> 00:55:06,408
当我们进入数字的时候


1450
00:55:06,738 --> 00:55:08,328
python总是会像这样。


1451
00:55:08,388 --> 00:55:08,808
好的


1452
00:55:08,838 --> 00:55:09,829
这是一个字符串


1453
00:55:09,859 --> 00:55:10,579
就是这样


1454
00:55:10,969 --> 00:55:12,019
听起来不错吧？


1455
00:55:12,198 --> 00:55:13,879
它会把它变成一个字符串


1456
00:55:14,179 --> 00:55:16,578
为了让我们把这些数字变成1和数字


1457
00:55:16,608 --> 00:55:18,018
两个变量，


1458
00:55:18,168 --> 00:55:22,368
我们需要转换从用户那里得到的字符串


1459
00:55:22,758 --> 00:55:24,018
在数字上，


1460
00:55:24,108 --> 00:55:24,618
所以


1461
00:55:24,858 --> 00:55:26,988
我们能做到的方法是


1462
00:55:27,018 --> 00:55:28,548
基本上就是从这里过来


1463
00:55:28,818 --> 00:55:30,918
当我们把两个数相加


1464
00:55:30,948 --> 00:55:33,618
我可以使用一个特殊的python函数


1465
00:55:33,918 --> 00:55:35,418
为了转换这些


1466
00:55:35,448 --> 00:55:36,378
弦


1467
00:55:36,678 --> 00:55:37,698
变成数字。


1468
00:55:38,118 --> 00:55:39,888
实际上有两个


1469
00:55:39,918 --> 00:55:41,988
我们可以使用的python函数。


1470
00:55:42,228 --> 00:55:43,219
第一个叫做


1471
00:55:43,249 --> 00:55:43,638
int


1472
00:55:43,668 --> 00:55:45,559
所以我可以说我是阿姨。


1473
00:55:45,889 --> 00:55:46,459
我可以做一个


1474
00:55:46,489 --> 00:55:49,489
开括号，我可以做一个闭合的括号


1475
00:55:49,729 --> 00:55:53,988
基本上它要做的就是把里面的东西都转换成


1476
00:55:54,018 --> 00:55:55,398
开或闭括号


1477
00:55:55,668 --> 00:55:56,148
变成


1478
00:55:56,178 --> 00:55:56,838
整数


1479
00:55:56,868 --> 00:55:57,469
数字，


1480
00:55:57,918 --> 00:55:58,248
和


1481
00:55:58,278 --> 00:56:04,219
整数是一个整数所以它是1 2 3 4或5，所以它是a，


1482
00:56:04,458 --> 00:56:07,489
这是一个整数，另一个不能有小数点的词，


1483
00:56:08,749 --> 00:56:10,458
所以我能做的是，我可以说


1484
00:56:10,908 --> 00:56:11,838
我不，


1485
00:56:12,318 --> 00:56:13,308
我可以把这些


1486
00:56:13,338 --> 00:56:14,148
在


1487
00:56:14,328 --> 00:56:15,168
括号。


1488
00:56:15,378 --> 00:56:19,788
现在我们要做的是把这两个数都转化成


1489
00:56:19,848 --> 00:56:21,048
换句话说


1490
00:56:21,408 --> 00:56:22,248
进入


1491
00:56:22,338 --> 00:56:24,528
没有小数的整数，


1492
00:56:24,708 --> 00:56:28,698
它会把它们加在一起然后打印出结果为什么我们不这么做呢


1493
00:56:28,759 --> 00:56:30,528
我们来看看这是否可行，我要


1494
00:56:30,648 --> 00:56:31,578
点击播放按钮


1495
00:56:31,998 --> 00:56:35,688
在下面我们输入第一个数字，可以输入4


1496
00:56:36,078 --> 00:56:37,549
然后我将在五分钟内回答


1497
00:56:37,789 --> 00:56:41,358
现在你可以看到它打印出了正确答案4+


1498
00:56:41,388 --> 00:56:42,018
五


1499
00:56:42,198 --> 00:56:45,168
这就是我们的基本计算器。


1500
00:56:45,228 --> 00:56:46,488
但是我们有一个


1501
00:56:46,518 --> 00:56:50,719
这个计算器大马哈鱼的问题再来一次我给大家展示一下这个问题


1502
00:56:50,749 --> 00:56:52,159
如果我想添加进去


1503
00:56:52,189 --> 00:56:57,169
一个小数，所以我们要加上四点三和五点五。


1504
00:56:58,099 --> 00:56:59,929
你会发现我们得到了这个错误。


1505
00:57:00,169 --> 00:57:02,869
这是因为我在用这个


1506
00:57:02,959 --> 00:57:03,320
不是


1507
00:57:03,350 --> 00:57:05,030
这里和这里的函数


1508
00:57:05,090 --> 00:57:08,029
int函数正在寻找一个完整的数字。


1509
00:57:08,299 --> 00:57:08,659
如果


1510
00:57:08,689 --> 00:57:11,900
我把小数点放在里面，它会破坏程序。


1511
00:57:12,710 --> 00:57:14,510
我们还可以使用另一个函数


1512
00:57:14,570 --> 00:57:15,200
而

1513
00:57:15,230 --> 00:57:16,969
我们可以说是浮点数


1514
00:57:17,240 --> 00:57:18,020
还有一个浮点数


1515
00:57:18,050 --> 00:57:21,709
基本上就是一个有小数的数所以它是一个小数


1516
00:57:22,129 --> 00:57:25,339
所以我可以把这两个都转换成浮点数


1517
00:57:26,119 --> 00:57:29,449
现在我可以使用十进制数字，这样我就可以点击play了。


1518
00:57:29,959 --> 00:57:33,079
我可以输入数字，所以我可以说是4


1519
00:57:33,559 --> 00:57:35,899
我也可以说是五点五。


1520
00:57:36,139 --> 00:57:38,089
现在它可以添加


1521
00:57:38,119 --> 00:57:39,259
这两个数字。


1522
00:57:39,619 --> 00:57:41,060
即使其中一个是小数


1523
00:57:41,090 --> 00:57:44,299
这就是使用这个小浮动函数的美妙之处


1524
00:57:44,599 --> 00:57:49,309
在某些情况下，你可能希望用户只能输入一个整数


1525
00:57:49,579 --> 00:57:50,569
对一个整数。


1526
00:57:50,719 --> 00:57:52,999
但是在很多情况下，比如这个计算器。


1527
00:57:53,059 --> 00:57:56,870
我们希望他们能够回答任何他们想要的数字所以我们要使用这个流程


1528
00:57:57,200 --> 00:57:57,710
函数。


1529
00:57:58,190 --> 00:57:58,580
所以


1530
00:57:58,610 --> 00:58:02,750
我再来回顾一下我们做过的一遍我们创建了两个变量1和2


1531
00:58:03,410 --> 00:58:08,240
我们基本上存储了用户植入这些变量的两个数字，


1532
00:58:08,660 --> 00:58:11,210
然后我们把它们转换成数字


1533
00:58:11,571 --> 00:58:12,141
并且


1534
00:58:12,171 --> 00:58:12,651
杂草


1535
00:58:12,681 --> 00:58:14,990
我们一起把结果打印出来


1536
00:58:15,051 --> 00:58:17,301
这是一个很酷的计算器。


1537
00:58:17,601 --> 00:58:18,951
希望你们学到了一些东西。


1538
00:58:19,161 --> 00:58:26,272
当我们在这个python课程中进行的时候你们将会学到各种各样的方法我们可以让这个计算器变得更复杂


1539
00:58:30,082 --> 00:58:32,452
在本教程中，我想向你们展示如何构建一个


1540
00:58:32,482 --> 00:58:34,372
疯狂的游戏


1541
00:58:34,402 --> 00:58:35,062
python，


1542
00:58:35,482 --> 00:58:41,632
所以一个疯狂的libs游戏基本上就是一个游戏你可以输入一些随机的单词


1543
00:58:41,752 --> 00:58:42,112
你知道


1544
00:58:42,142 --> 00:58:43,342
动词名词


1545
00:58:43,402 --> 00:58:44,302
名字


1546
00:58:44,422 --> 00:58:45,112
颜色


1547
00:58:46,132 --> 00:58:48,022
你基本上把所有这些词都拿出来


1548
00:58:48,052 --> 00:58:50,662
把它们随机地放到一个故事里


1549
00:58:51,412 --> 00:58:52,282
我在这里


1550
00:58:52,312 --> 00:58:53,692
我的网络浏览器


1551
00:58:53,752 --> 00:58:55,912
这是一个疯狂的谎言的例子


1552
00:58:55,942 --> 00:59:00,353
下面是一些随机的词比如形容词，名词或代词


1553
00:59:00,743 --> 00:59:02,153
然后进入


1554
00:59:02,213 --> 00:59:06,083
这是一个故事，就像你在故事中读到的那样，就像突然出现的一个随机的单词


1555
00:59:06,353 --> 00:59:08,423
马尔代夫可以很有趣我相信雅兹迪人


1556
00:59:08,453 --> 00:59:08,723
是的


1557
00:59:08,753 --> 00:59:10,283
他以前听说过疾病，


1558
00:59:10,763 --> 00:59:12,743
但如果不是现在，这只是一个小小的介绍。


1559
00:59:12,803 --> 00:59:14,783
所以我想在这里创建一个疯狂的libs


1560
00:59:14,813 --> 00:59:16,944
python，这将会很酷


1561
00:59:17,244 --> 00:59:18,504
下面是这个湖


1562
00:59:18,534 --> 00:59:19,824
一首小诗，他说。


1563
00:59:20,094 --> 00:59:22,554
玫瑰是红色的紫罗兰，我爱你。


1564
00:59:22,974 --> 00:59:25,194
所以你知道这是一首引人注目的经典诗


1565
00:59:25,224 --> 00:59:25,704
但是


1566
00:59:26,124 --> 00:59:30,954
我想我们应该把它混起来，为这首诗创造一个疯狂的生活。


1567
00:59:31,404 --> 00:59:32,034
所以


1568
00:59:32,064 --> 00:59:34,884
而不是这里的红色。


1569
00:59:35,214 --> 00:59:37,104
我想让用户回答


1570
00:59:37,134 --> 00:59:38,034
他们自己的颜色


1571
00:59:38,964 --> 00:59:40,614
而不是有紫罗兰，


1572
00:59:40,824 --> 00:59:42,354
为什么我们不让他们回答


1573
00:59:42,384 --> 00:59:42,894
a


1574
00:59:42,924 --> 00:59:43,854
复数名词。


1575
00:59:44,574 --> 00:59:46,494
而不是说我爱你


1576
00:59:46,524 --> 00:59:50,184
为什么我们不让他们说我爱，然后是名人


1577
00:59:50,214 --> 00:59:51,414
名人效应。


1578
00:59:52,794 --> 00:59:58,944
这是我们的小madlib右眼的基本结构你需要让用户回答一种颜色


1579
00:59:59,424 --> 01:00:00,925
输入

1580
01:00:01,195 --> 01:00:02,785
一个名人的回答，


1581
01:00:03,055 --> 01:00:03,775
我要


1582
01:00:03,805 --> 01:00:05,185
所有这些词


1583
01:00:05,334 --> 01:00:08,755
把它们放在我们的madlib里面，希望我们能得到一些很有趣的东西。


1584
01:00:09,775 --> 01:00:13,375
我们如何在python中构建这个


1585
01:00:13,555 --> 01:00:19,226
我们要做的第一件事是我们必须能够从用户那里得到这些词这是很明显的。


1586
01:00:19,556 --> 01:00:20,276
所以


1587
01:00:20,366 --> 01:00:23,456
我认为我们应该做的是，我们应该创建三个变量


1588
01:00:23,516 --> 01:00:24,386
被称为颜色


1589
01:00:24,417 --> 01:00:25,797
名人的复数名词


1590
01:00:26,097 --> 01:00:27,057
并将储存


1591
01:00:27,087 --> 01:00:27,747
用户的


1592
01:00:27,777 --> 01:00:28,437
输入。


1593
01:00:28,497 --> 01:00:30,116
在里面


1594
01:00:30,177 --> 01:00:30,896
变量。


1595
01:00:31,257 --> 01:00:33,266
在这里，我们来创建这些变量


1596
01:00:33,296 --> 01:00:35,427
我要创建的第一个很好，将会被调用


1597
01:00:35,457 --> 01:00:36,027
颜色


1598
01:00:36,057 --> 01:00:37,257
这是一种颜色。


1599
01:00:37,407 --> 01:00:38,187
我想设置这个


1600
01:00:38,217 --> 01:00:39,087
等于


1601
01:00:39,117 --> 01:00:39,357
那


1602
01:00:39,448 --> 01:00:41,098
输入将会输入输入


1603
01:00:41,518 --> 01:00:44,968
在这里我要给他们一个提示所有的答案都是a


1604
01:00:44,998 --> 01:00:45,628
颜色。


1605
01:00:46,888 --> 01:00:49,408
我们基本上可以复制这行代码。


1606
01:00:49,858 --> 01:00:50,338
并且


1607
01:00:50,368 --> 01:00:52,319
我要把它粘贴到下面


1608
01:00:52,619 --> 01:00:53,969
我们再粘贴一次。


1609
01:00:54,449 --> 01:00:56,729
现在我们要创建复数名词


1610
01:00:56,759 --> 01:00:58,949
我也会说，皮奥瑞亚


1611
01:00:59,069 --> 01:01:00,149
多元主义


1612
01:01:00,899 --> 01:01:02,760
想说答案a


1613
01:01:03,810 --> 01:01:04,470
复数的


1614
01:01:04,500 --> 01:01:05,010
现在


1615
01:01:06,390 --> 01:01:07,859
实际上这里我想要一个


1616
01:01:07,919 --> 01:01:08,879
煤炭也是。


1617
01:01:09,509 --> 01:01:11,429
最后，我们要创建


1618
01:01:11,609 --> 01:01:14,249
名人变量输入a


1619
01:01:14,939 --> 01:01:16,439
名人


1620
01:01:17,009 --> 01:01:19,859
现在我们创建了三个变量


1621
01:01:19,889 --> 01:01:21,899
名人的彩色复数名词


1622
01:01:22,079 --> 01:01:25,979
里面存储了用户输入的颜色


1623
01:01:26,219 --> 01:01:29,609
用户输入的复数名词和名人的冒险。


1624
01:01:29,909 --> 01:01:30,389
所以


1625
01:01:30,449 --> 01:01:32,189
我们要做的最后一件事是


1626
01:01:32,219 --> 01:01:33,029
替换


1627
01:01:33,059 --> 01:01:34,799
这些有这些变量的人


1628
01:01:35,819 --> 01:01:39,540
我要把这里的颜色加进去


1629
01:01:40,560 --> 01:01:42,930
我们要加入复数名词


1630
01:01:43,650 --> 01:01:44,730
我可以这样


1631
01:01:44,820 --> 01:01:45,810
这个。


1632
01:01:50,940 --> 01:01:53,820
最后是什么是名人。


1633
01:01:57,120 --> 01:01:58,440
现在我们有了一个前传


1634
01:01:58,470 --> 01:02:02,131
它应该是功能性的所有东西都应该工作它看起来是这样的


1635
01:02:02,191 --> 01:02:03,781
很好


1636
01:02:04,291 --> 01:02:06,570
我们到这里来，运行我们的程序


1637
01:02:06,720 --> 01:02:08,610
然后是理事会。


1638
01:02:09,510 --> 01:02:11,700
我们可以玩一些疯狂的游戏


1639
01:02:12,060 --> 01:02:14,160
它们进入了我想说的颜色。


1640
01:02:14,280 --> 01:02:15,030
品红


1641
01:02:15,960 --> 01:02:18,780
现在输入复数，当我们说，


1642
01:02:19,560 --> 01:02:20,850
微波


1643
01:02:21,150 --> 01:02:24,900
然后你就可以进入名人了，比如说汤姆汉克斯。


1644
01:02:25,170 --> 01:02:25,650
所以


1645
01:02:25,710 --> 01:02:29,280
当我点击进入时我们应该得到我们的疯狂的libs


1646
01:02:29,310 --> 01:02:30,120
打印出一些


1647
01:02:30,150 --> 01:02:30,810
良好的进入


1648
01:02:31,290 --> 01:02:34,560
现在我们的方法是玫瑰是洋红色的


1649
01:02:34,590 --> 01:02:36,000
微波是蓝色的


1650
01:02:36,030 --> 01:02:37,590
我爱汤姆汉克斯。


1651
01:02:37,920 --> 01:02:39,330
这是一个很好的madlib


1652
01:02:39,600 --> 01:02:40,890
很明显你知道，


1653
01:02:40,950 --> 01:02:41,880
越多，


1654
01:02:41,970 --> 01:02:44,280
我们在这里放的print语句越多


1655
01:02:44,310 --> 01:02:49,260
苹果酸盐的质量可能会更好我们可以在这里储存尽可能多的变量。


1656
01:02:49,861 --> 01:02:52,500
这是一个非常简单的磁悬浮列车


1657
01:02:52,531 --> 01:02:58,561
三种输入，但你知道你可以看到你如何使用这样的东西创建一个疯狂的libs游戏


1658
01:02:59,071 --> 01:03:05,071
这节课的作业是去做你自己的玛德琳的游戏希望这比我的更有趣。


1659
01:03:05,551 --> 01:03:06,690
但这是最基本的


1660
01:03:06,720 --> 01:03:08,760
创造一个疯狂的libs游戏


1661
01:03:08,790 --> 01:03:09,450
蟒蛇


1662
01:03:13,470 --> 01:03:17,850
在本教程中，我们将介绍如何使用python中的列表进行操作。


1663
01:03:18,300 --> 01:03:23,041
很多时候，当你用python编程时你将会处理大量的数据，


1664
01:03:23,430 --> 01:03:23,850
并且


1665
01:03:23,880 --> 01:03:26,851
当你处理大量的数据时你要确保你能


1666
01:03:26,881 --> 01:03:29,281
管理好并组织好，


1667
01:03:29,581 --> 01:03:34,111
这个列表基本上就是我们可以在python里使用的结构


1668
01:03:34,351 --> 01:03:37,501
存储信息的列表，这样我们就可以


1669
01:03:37,741 --> 01:03:40,561
一堆不同的数据值我们可以把它们放到一个列表中


1670
01:03:40,591 --> 01:03:43,441
它允许我们组织它们并跟踪它们


1671
01:03:43,471 --> 01:03:44,011
很多


1672
01:03:44,071 --> 01:03:44,641
更容易。


1673
01:03:45,001 --> 01:03:48,452
所以一般来说，你会创建一个比你要放一堆的python


1674
01:03:48,872 --> 01:03:50,102
相关值


1675
01:03:50,132 --> 01:03:53,462
在这个列表里面然后你可以在整个程序中使用它


1676
01:03:53,732 --> 01:03:58,443
实际上，眼睛只是使用列表的基础我们将会看到一些常见的用例


1677
01:03:58,713 --> 01:04:02,463
让你快速了解一下列表是什么以及为什么它们是有用的


1678
01:04:02,823 --> 01:04:03,903
在我的程序中


1679
01:04:03,933 --> 01:04:04,623
我要去


1680
01:04:04,653 --> 01:04:06,213
创建一个列表


1681
01:04:06,423 --> 01:04:07,263
我们

1682
01:04:07,293 --> 01:04:09,783
我们可能会创建一个python


1683
01:04:09,813 --> 01:04:11,793
它就像一个普通的python变量


1684
01:04:12,033 --> 01:04:13,984
我们要做的第一件事就是做一个列表


1685
01:04:14,014 --> 01:04:14,823
给它


1686
01:04:14,854 --> 01:04:17,524
一个名字，所以我们想给它一个描述性的名字


1687
01:04:17,764 --> 01:04:21,484
这基本上就是描述列表里面的内容


1688
01:04:21,844 --> 01:04:22,894
以我为例


1689
01:04:22,924 --> 01:04:24,484
这个例子让我们列一个清单


1690
01:04:24,514 --> 01:04:28,714
就像朋友一样所以我们可以说这是我所有朋友的名单所以我可以说


1691
01:04:29,104 --> 01:04:29,854
朋友


1692
01:04:30,244 --> 01:04:31,234
我要设置这个


1693
01:04:31,264 --> 01:04:32,224
等于


1694
01:04:32,314 --> 01:04:34,024
价值列表


1695
01:04:34,084 --> 01:04:35,314
代表我的

1696
01:04:35,584 --> 01:04:38,284
我们想要创建一个列表我们可以使用这些


1697
01:04:38,344 --> 01:04:40,594
打开封闭的方括号。


1698
01:04:40,895 --> 01:04:42,635
所以无论何时你使用这些开放和封闭的


1699
01:04:42,665 --> 01:04:44,945
方括号，基本上是python


1700
01:04:44,975 --> 01:04:47,435
好的，他们想要存储一堆值


1701
01:04:47,465 --> 01:04:48,755
在这个列表里面。


1702
01:04:49,205 --> 01:04:53,705
那么我们为什么不继续添加一些值这样我们就可以像我的朋友们说的那样


1703
01:04:55,115 --> 01:04:56,075
酒馆，


1704
01:04:56,825 --> 01:04:57,785
凯伦


1705
01:04:58,865 --> 01:05:00,275
然后说吉姆。


1706
01:05:00,665 --> 01:05:03,335
这里我有三个值


1707
01:05:03,365 --> 01:05:05,675
在我朋友的数组里。


1708
01:05:06,035 --> 01:05:11,615
所以当我们在python中创建一个普通变量时通常我们只给它一个值


1709
01:05:11,915 --> 01:05:12,125
对的


1710
01:05:12,155 --> 01:05:13,205
现在来创建一个变量


1711
01:05:13,235 --> 01:05:13,745
我会给它


1712
01:05:13,775 --> 01:05:16,925
一个值可以是一个字符串或一个数字或一个金块。


1713
01:05:17,375 --> 01:05:18,875
但是当我们列出清单的时候


1714
01:05:18,905 --> 01:05:21,605
能够存储多个值


1715
01:05:21,906 --> 01:05:23,526
在相同的地方


1716
01:05:23,556 --> 01:05:24,906
里面的小物品


1717
01:05:24,936 --> 01:05:25,866
客体权利


1718
01:05:26,227 --> 01:05:29,737
然后我能做的就是访问这些单独的项目


1719
01:05:29,797 --> 01:05:31,387
在我的程序中


1720
01:05:31,747 --> 01:05:33,457
在这个朋友的内心


1721
01:05:33,517 --> 01:05:35,227
列表基本上是存储


1722
01:05:35,257 --> 01:05:38,707
所有这些不同的值都是非常有用的


1723
01:05:39,067 --> 01:05:42,067
现在我们已经存储了一些值让我们来讨论一下你可以放什么


1724
01:05:42,127 --> 01:05:45,157
在一个列表里面你可以把任何一个


1725
01:05:45,367 --> 01:05:46,507
python中的信息


1726
01:05:46,537 --> 01:05:47,498
我们可以把


1727
01:05:47,798 --> 01:05:49,627
字符串号或金币


1728
01:05:49,688 --> 01:05:54,127
所以如果我不想在这里输入字符串我可以把其中的一个变成一个数字


1729
01:05:54,367 --> 01:05:56,647
我可以把其中一个换成金块


1730
01:05:56,887 --> 01:05:57,698
也没关系


1731
01:05:57,728 --> 01:05:59,588
python会对此很好。


1732
01:06:00,278 --> 01:06:02,198
让我们改变一下他回到了字符串


1733
01:06:02,288 --> 01:06:03,968
为了这个例子


1734
01:06:04,298 --> 01:06:06,518
现在我们已经创建了我们的列表


1735
01:06:06,548 --> 01:06:07,958
我们怎样才能进入


1736
01:06:08,018 --> 01:06:09,278
个别元素


1737
01:06:09,308 --> 01:06:10,388
在这个列表里面


1738
01:06:10,418 --> 01:06:11,228
这是个好问题。


1739
01:06:11,588 --> 01:06:13,899
我要把一些东西打印到屏幕上。


1740
01:06:13,959 --> 01:06:15,430
我们能做的第一件事就是


1741
01:06:15,460 --> 01:06:17,620
打印出实际的列表


1742
01:06:17,830 --> 01:06:19,750
我只能说打印的朋友


1743
01:06:19,930 --> 01:06:21,550
当我运行这个程序的时候。


1744
01:06:21,790 --> 01:06:24,070
如果我们往下看控制台你可以看到它只是


1745
01:06:24,100 --> 01:06:26,351
打印出朋友的真实名单，


1746
01:06:26,951 --> 01:06:28,481
但是假设我想要打印


1747
01:06:28,511 --> 01:06:29,711
特定的


1748
01:06:29,741 --> 01:06:31,301
这个列表中的元素


1749
01:06:31,631 --> 01:06:34,961
我可以用它们来表示元素


1750
01:06:34,991 --> 01:06:35,561
索引


1751
01:06:35,591 --> 01:06:36,101
所以


1752
01:06:36,311 --> 01:06:38,261
这个列表中的每一个元素


1753
01:06:38,292 --> 01:06:39,432
有一个特别的


1754
01:06:40,362 --> 01:06:44,051
这个指数实际上是0，所以我们会说这个


1755
01:06:44,201 --> 01:06:46,151
列表中的第一个元素


1756
01:06:46,301 --> 01:06:47,861
它的指数为0，


1757
01:06:48,161 --> 01:06:49,091
我们会说这个


1758
01:06:49,121 --> 01:06:49,841
其他元素


1759
01:06:49,871 --> 01:06:51,761
凯伦有一个索引。


1760
01:06:52,091 --> 01:06:52,511
这是


1761
01:06:52,541 --> 01:06:55,301
第三个元素，jim的索引值是2。


1762
01:06:55,750 --> 01:06:56,531
尽管如此


1763
01:06:56,561 --> 01:06:59,200
从技术上讲，吉姆是第三个元素


1764
01:06:59,230 --> 01:07:00,461
在列表的内部。


1765
01:07:00,791 --> 01:07:02,651
它的索引是2


1766
01:07:02,891 --> 01:07:06,041
这是因为我们在索引位置开始

1767
01:07:06,071 --> 01:07:06,521
一。


1768
01:07:07,031 --> 01:07:09,341
这就是它的工作原理，这就是列表


1769
01:07:09,371 --> 01:07:10,181
索引工作


1770
01:07:10,211 --> 01:07:10,751
所以


1771
01:07:11,111 --> 01:07:12,221
如果我想


1772
01:07:12,251 --> 01:07:15,611
在我的朋友列表中访问一个特定的元素。


1773
01:07:15,851 --> 01:07:17,411
我可以用它来指代它


1774
01:07:17,471 --> 01:07:18,161
索引。


1775
01:07:18,431 --> 01:07:21,281
在这之后，我买了一些朋友，我要把它录下来


1776
01:07:21,342 --> 01:07:23,172
开闭方括号，


1777
01:07:23,502 --> 01:07:24,132
在里面


1778
01:07:24,162 --> 01:07:25,602
这个开闭的方括号


1779
01:07:25,632 --> 01:07:26,442
我想把


1780
01:07:26,472 --> 01:07:27,132
索引


1781
01:07:27,162 --> 01:07:28,031
元素的


1782
01:07:28,092 --> 01:07:29,232
在列表中


1783
01:07:29,442 --> 01:07:30,672
我想要访问


1784
01:07:30,912 --> 01:07:32,292
因此，我们无法进入


1785
01:07:32,531 --> 01:07:33,101
这个人


1786
01:07:33,131 --> 01:07:34,061
这里是这个元素。


1787
01:07:34,331 --> 01:07:35,441
我可以放一个0。


1788
01:07:35,651 --> 01:07:36,611
所以我可以说是朋友


1789
01:07:36,641 --> 01:07:37,331
零。


1790
01:07:37,601 --> 01:07:39,131
现在当我运行程序时，


1791
01:07:39,401 --> 01:07:42,042
它只会打印出这个值它就会发出


1792
01:07:42,072 --> 01:07:42,552
小木屋，


1793
01:07:42,882 --> 01:07:44,292
如果要访问这个


1794
01:07:44,322 --> 01:07:46,452
这里的gem值我可以放一个


1795
01:07:46,482 --> 01:07:46,992
二


1796
01:07:47,352 --> 01:07:48,852
这就给了我们


1797
01:07:48,942 --> 01:07:49,752
吉姆值


1798
01:07:49,782 --> 01:07:50,862
你可以看到，


1799
01:07:50,952 --> 01:07:52,632
所以我们可以访问元素


1800
01:07:52,662 --> 01:07:53,682
基于


1801
01:07:53,712 --> 01:07:54,762
他们的指数


1802
01:07:54,792 --> 01:07:55,542
我们也可以


1803
01:07:55,572 --> 01:07:56,592
存取元件


1804
01:07:57,402 --> 01:07:58,482
根据

1805
01:07:58,512 --> 01:08:00,013
从列表的后面


1806
01:08:00,043 --> 01:08:00,493
所以


1807
01:08:00,643 --> 01:08:01,783
举个例子，如果我说


1808
01:08:01,813 --> 01:08:03,613
这里的负1，


1809
01:08:03,913 --> 01:08:05,863
这将使我能够访问这个


1810
01:08:05,893 --> 01:08:07,573
这是吉姆的价值。


1811
01:08:07,663 --> 01:08:13,904
你可以看到它是这样做的所以当我们使用底片时它会从列表的后面开始索引如果我从-2开始，


1812
01:08:14,144 --> 01:08:15,404
这将会给我们


1813
01:08:15,434 --> 01:08:16,124
凯伦


1814
01:08:16,334 --> 01:08:18,284
所以你可以用底片来访问


1815
01:08:18,313 --> 01:08:19,543
在列表后面的项目。


1816
01:08:19,994 --> 01:08:22,483
不过要记住，这是一种


1817
01:08:22,573 --> 01:08:23,203
有趣的


1818
01:08:24,283 --> 01:08:28,544
我们说，第一个元素是索引位置0


1819
01:08:29,144 --> 01:08:29,534
对的


1820
01:08:29,564 --> 01:08:32,294
但是我们会说，列表后面的第一个元素


1821
01:08:32,324 --> 01:08:33,434
是索引位置


1822
01:08:33,463 --> 01:08:34,604
负1


1823
01:08:34,633 --> 01:08:35,563
记住这一点。


1824
01:08:35,713 --> 01:08:38,594
实际上，我们还可以通过其他方式访问


1825
01:08:38,624 --> 01:08:40,664
例如，这个列表的一部分，


1826
01:08:40,904 --> 01:08:46,124
假设我只是想选择列表中的最后两个元素我不想让我们喜欢第一个元素


1827
01:08:46,574 --> 01:08:48,555
在这里我只能说一个


1828
01:08:48,584 --> 01:08:49,604
用冒号，


1829
01:08:49,754 --> 01:08:52,965
这将获取索引位置1的元素


1830
01:08:52,995 --> 01:08:53,984
所有的元素


1831
01:08:54,014 --> 01:08:55,935
在那之后我们应该描述


1832
01:08:55,964 --> 01:08:56,924
吉姆和

1833
01:08:58,004 --> 01:08:59,565
或者按照那种顺序去健身房。


1834
01:09:00,045 --> 01:09:01,905
我也可以指定一个范围。


1835
01:09:02,175 --> 01:09:04,845
让我在其他一些元素中，


1836
01:09:04,965 --> 01:09:06,766
这样我们就能更好地说明这一点。


1837
01:09:07,545 --> 01:09:08,956
还有两个名字。


1838
01:09:09,166 --> 01:09:11,446
如果我想要，我可以选择


1839
01:09:11,476 --> 01:09:13,396
元素和说明一


1840
01:09:13,425 --> 01:09:16,486
在索引位置3的元素上


1841
01:09:16,666 --> 01:09:17,477
它会抓住


1842
01:09:17,506 --> 01:09:19,066
这一个说，


1843
01:09:19,396 --> 01:09:20,086
二


1844
01:09:20,356 --> 01:09:24,407
它实际上不会抓住第三个所以它会抓住

1845
01:09:24,437 --> 01:09:27,047
但不包括3，所以它会抓取


1846
01:09:27,077 --> 01:09:28,007
凯伦


1847
01:09:28,037 --> 01:09:28,606
吉姆，


1848
01:09:29,687 --> 01:09:32,686
让我们来运行这个你可以看到它抓取了佳能日本


1849
01:09:33,106 --> 01:09:34,307
你可以把它放在


1850
01:09:34,427 --> 01:09:37,127
一个有冒号后，它会抓住那个


1851
01:09:37,367 --> 01:09:40,248
在它之后的所有内容中，甚至是指定的


1852
01:09:40,277 --> 01:09:41,897
安排你想要从。


1853
01:09:42,018 --> 01:09:43,548
这就是我们可以访问的方式


1854
01:09:43,578 --> 01:09:45,438
这个列表中的元素


1855
01:09:45,468 --> 01:09:47,718
但是我们也可以修改元素


1856
01:09:47,748 --> 01:09:48,498
举个例子


1857
01:09:48,527 --> 01:09:49,547
我可以到这里来。


1858
01:09:49,877 --> 01:09:53,298
假设我想要修改这个值，karen


1859
01:09:53,658 --> 01:09:56,988
你要做的就是访问我能说的元素


1860
01:09:57,408 --> 01:09:58,158
朋友


1861
01:09:58,188 --> 01:09:58,547
并且


1862
01:09:58,577 --> 01:10:00,557
凯伦是对一个人的阐释


1863
01:10:01,007 --> 01:10:03,887
我可以把它改成我想要的所以我可以说是

1864
01:10:03,917 --> 01:10:05,597
在这个位置，一个等于


1865
01:10:05,626 --> 01:10:06,227
迈克？


1866
01:10:06,646 --> 01:10:07,217
现在


1867
01:10:07,247 --> 01:10:08,597
当我们打印朋友的时候


1868
01:10:08,626 --> 01:10:09,827
第一个


1869
01:10:10,187 --> 01:10:13,067
这个值将会被更新所以它会说


1870
01:10:13,097 --> 01:10:14,417
迈克，而不是说


1871
01:10:14,446 --> 01:10:14,926
凯伦


1872
01:10:15,286 --> 01:10:18,976
所以修改里面的值是很有用的


1873
01:10:19,006 --> 01:10:19,486
阵列


1874
01:10:19,516 --> 01:10:23,355
因此，修改python列表中的值是非常有用的。


1875
01:10:23,415 --> 01:10:25,905
这些都是处理列表的基础知识


1876
01:10:25,935 --> 01:10:28,935
在python里，实际上在下一个教程中


1877
01:10:28,995 --> 01:10:30,194
甚至更多


1878
01:10:30,645 --> 01:10:32,655
我们可以少用这些，我们要学习如何链接


1879
01:10:32,685 --> 01:10:35,295
从较少的删除元素中添加元素


1880
01:10:35,745 --> 01:10:37,846
复制列表和一些很酷的东西


1881
01:10:38,386 --> 01:10:38,776
用


1882
01:10:38,836 --> 01:10:41,266
这些列表，但就目前而言，这有点像


1883
01:10:41,506 --> 01:10:43,787
使用列表的基础知识


1884
01:10:47,537 --> 01:10:50,326
在本教程中，我想和你们谈谈使

1885
01:10:50,355 --> 01:10:52,155
带有列表的函数


1886
01:10:52,185 --> 01:10:53,025
在python里，


1887
01:10:53,505 --> 01:10:54,135
和python


1888
01:10:54,165 --> 01:10:58,816
列表是我们可以存储信息的最重要的结构之一。


1889
01:10:59,206 --> 01:11:03,646
一个列表基本上允许你取一堆不同的值并组织它们并存储它们


1890
01:11:03,946 --> 01:11:05,687
在他们自己的小名单里


1891
01:11:05,716 --> 01:11:06,526
结构


1892
01:11:06,917 --> 01:11:09,437
下面是我的程序，你可以看到我有


1893
01:11:09,466 --> 01:11:11,896
少了两个，我有一个幸运数字的列表。


1894
01:11:12,106 --> 01:11:13,816
这只是一堆不同的数字，


1895
01:11:14,116 --> 01:11:15,706
然后我有一份朋友的名单


1896
01:11:15,735 --> 01:11:17,925
所以这可能是某人的朋友的名单


1897
01:11:18,255 --> 01:11:21,135
它基本上就是一串有名字的字符串。


1898
01:11:21,405 --> 01:11:22,785
这两个列表


1899
01:11:22,814 --> 01:11:25,515
存储了很多不同的值


1900
01:11:25,725 --> 01:11:26,985
是什么让这一切变得如此美妙


1901
01:11:27,015 --> 01:11:29,354
我不仅可以存储这么多的值


1902
01:11:29,384 --> 01:11:30,043
我可以储存


1903
01:11:30,073 --> 01:11:32,923
成百上千甚至上百万的价值。


1904
01:11:33,073 --> 01:11:37,573
当你处理大量的数据和大量的信息和python蜜蜂列表时


1905
01:11:37,603 --> 01:11:38,593
无价的。


1906
01:11:38,893 --> 01:11:44,744
因为列表是如此重要实际上有很多不同的函数可以用列表来使用


1907
01:11:45,014 --> 01:11:48,374
这些函数允许我们做一些事情比如修改列表


1908
01:11:48,554 --> 01:11:51,224
然后获取关于列表的信息


1909
01:11:51,974 --> 01:11:52,574
在本教程中


1910
01:11:52,604 --> 01:11:54,254
我只是想给你们看一堆


1911
01:11:54,284 --> 01:11:58,064
函数我们将讨论一些最常见和最流行的函数


1912
01:11:58,334 --> 01:11:59,924
你可以在列表上使用


1913
01:11:59,954 --> 01:12:03,165
让它们更强大，让它们更容易使用。


1914
01:12:03,524 --> 01:12:03,944
所以


1915
01:12:03,974 --> 01:12:06,074
我们能做的第一件事就是打印


1916
01:12:06,104 --> 01:12:09,224
在下面的列表中，我打印出来了


1917
01:12:09,254 --> 01:12:10,154
朋友名单


1918
01:12:10,484 --> 01:12:10,934
当一个温暖的


1919
01:12:10,964 --> 01:12:12,344
当我运行程序时，


1920
01:12:13,094 --> 01:12:14,294
你看这里，我们只是


1921
01:12:14,324 --> 01:12:16,334
打印出列表中的所有元素


1922
01:12:16,575 --> 01:12:17,955
能够打印出来总是好的


1923
01:12:17,984 --> 01:12:18,314
外出


1924
01:12:18,344 --> 01:12:19,994
列表中的所有元素，


1925
01:12:20,054 --> 01:12:22,514
但是还有很多其他的功能我们可以使用


1926
01:12:22,664 --> 01:12:28,695
一个函数在扩展函数中叫做扩展函数基本上允许你取一个列表


1927
01:12:29,025 --> 01:12:29,445
并且


1928
01:12:29,475 --> 01:12:32,774
在它的末尾添加另一个列表，这样我就可以说


1929
01:12:33,524 --> 01:12:34,274
朋友


1930
01:12:34,304 --> 01:12:34,874
点


1931
01:12:34,964 --> 01:12:35,834
延长


1932
01:12:36,284 --> 01:12:37,904
在这些括号里面


1933
01:12:37,934 --> 01:12:39,555
我可以通过列表


1934
01:12:39,584 --> 01:12:41,685
我想把它加到朋友名单上。


1935
01:12:41,955 --> 01:12:42,945
所以我可以说


1936
01:12:43,035 --> 01:12:43,965
幸运的


1937
01:12:44,115 --> 01:12:44,835
数字。


1938
01:12:45,076 --> 01:12:47,236
现在当我打印出这个朋友列表的时候。


1939
01:12:47,386 --> 01:12:50,056
它不仅会包含好友列表中的所有元素


1940
01:12:50,085 --> 01:12:53,265
它也会包含幸运数字列表中的所有元素


1941
01:12:53,535 --> 01:12:55,815
你可以看到这里有我们所有的朋友，


1942
01:12:56,055 --> 01:12:57,015
我们也有


1943
01:12:57,075 --> 01:13:00,586
这些数字听起来很容易就像


1944
01:13:00,916 --> 01:13:02,446
把两个列表加在一起。


1945
01:13:02,956 --> 01:13:04,246
我们也可以加上


1946
01:13:04,275 --> 01:13:06,495
列表中的单个元素


1947
01:13:06,525 --> 01:13:07,065
所以


1948
01:13:07,305 --> 01:13:09,255
我来到这里，我可以说是

1949
01:13:10,275 --> 01:13:11,055
附加


1950
01:13:11,475 --> 01:13:15,136
这将允许我添加另一个项目


1951
01:13:15,166 --> 01:13:16,665
在这个列表的最后，


1952
01:13:16,965 --> 01:13:20,025
在这里我可以添加另一个名字我们可以说


1953
01:13:20,206 --> 01:13:24,646
比如，我想把另一个朋友加到这个列表的最后


1954
01:13:24,675 --> 01:13:25,995
当我运行程序时。


1955
01:13:26,505 --> 01:13:27,915
除了


1956
01:13:28,095 --> 01:13:30,854
上面列出的原始项目。


1957
01:13:31,064 --> 01:13:33,465
我们在最后还会有这个附加项


1958
01:13:33,675 --> 01:13:37,725
而不是钢笔函数总是把项目添加到列表的末尾，


1959
01:13:38,265 --> 01:13:43,097
但是假设你想在列表的中间添加一个项目就像这里，


1960
01:13:43,396 --> 01:13:45,197
还有另一个列表函数


1961
01:13:45,227 --> 01:13:46,427
称为插入


1962
01:13:47,897 --> 01:13:49,157
插入将会


1963
01:13:49,187 --> 01:13:52,157
两个参数第一个参数将是


1964
01:13:52,397 --> 01:13:54,646
你想要插入条目的索引


1965
01:13:54,856 --> 01:13:57,797
我们为什么不把它插入到索引位置1。


1966
01:13:58,067 --> 01:13:59,267
我只想说一个


1967
01:13:59,687 --> 01:14:03,077
然后我要输入我想要添加的元素的名称


1968
01:14:03,107 --> 01:14:04,038
我们可以这样说


1969
01:14:04,278 --> 01:14:04,758
凯莉，


1970
01:14:05,418 --> 01:14:08,088
现在在索引位置1我们将会有


1971
01:14:08,118 --> 01:14:09,288
卷kelly


1972
01:14:09,378 --> 01:14:12,229
所有这些其他的值都会被推到


1973
01:14:12,258 --> 01:14:12,588
向上


1974
01:14:12,618 --> 01:14:13,008
他们将会


1975
01:14:13,068 --> 01:14:14,418
被推到右边


1976
01:14:15,078 --> 01:14:16,938
一个指数位置


1977
01:14:16,998 --> 01:14:18,198
现在我运行程序，


1978
01:14:18,468 --> 01:14:19,968
你可以看到我们有卡文


1979
01:14:20,028 --> 01:14:20,929
这个新元素


1980
01:14:20,958 --> 01:14:21,559
凯利


1981
01:14:21,799 --> 01:14:24,680
然后所有其他元素都被推到右边，


1982
01:14:24,770 --> 01:14:26,450
我们也可以移除元素


1983
01:14:26,479 --> 01:14:27,529
举个例子


1984
01:14:27,559 --> 01:14:29,419
假设我想要移除这个


1985
01:14:29,449 --> 01:14:30,499
吉姆的价值。


1986
01:14:30,859 --> 01:14:33,589
我所要做的只是一个朋友的点移除。


1987
01:14:34,040 --> 01:14:34,430
并且


1988
01:14:34,459 --> 01:14:35,720
我可以输入


1989
01:14:35,750 --> 01:14:37,789
无论我想移除什么元素


1990
01:14:38,059 --> 01:14:38,869
我想要移除


1991
01:14:38,899 --> 01:14:40,159
这个吉姆元素


1992
01:14:40,429 --> 01:14:42,200
当我们运行这个程序时


1993
01:14:42,229 --> 01:14:42,680
吉姆


1994
01:14:42,709 --> 01:14:45,590
会从列表中消失我们只需要这些


1995
01:14:45,830 --> 01:14:47,240
四个人走了。


1996
01:14:47,540 --> 01:14:48,500
你也可以移除


1997
01:14:48,530 --> 01:14:49,520
所有的元素


1998
01:14:49,549 --> 01:14:51,559
从列表中，如果我只是想


1999
01:14:51,588 --> 01:14:52,578
完全像


2000
01:14:52,608 --> 01:14:54,078
重置小于删除的


2001
01:14:54,107 --> 01:14:56,507
我能说的一切都是朋友们的想法。


2002
01:14:56,897 --> 01:14:57,798
这将会


2003
01:14:57,828 --> 01:15:00,288
给我们一个空的列表，删掉


2004
01:15:00,318 --> 01:15:02,448
列表中的每一个元素。


2005
01:15:02,538 --> 01:15:04,278
还有一种很酷的东西


2006
01:15:04,308 --> 01:15:05,148
什么都不叫


2007
01:15:05,178 --> 01:15:05,748
流行


2008
01:15:05,808 --> 01:15:07,878
你可以把它拿出来


2009
01:15:08,058 --> 01:15:10,128
基本上，pop会做的是，它会


2010
01:15:10,158 --> 01:15:10,668
流行音乐


2011
01:15:10,698 --> 01:15:11,148
项目


2012
01:15:11,178 --> 01:15:12,738
从这个列表中


2013
01:15:13,008 --> 01:15:14,088
当我点击播放按钮时，


2014
01:15:14,328 --> 01:15:15,499
你们会看到


2015
01:15:15,559 --> 01:15:16,729
我们只剩下


2016
01:15:16,849 --> 01:15:17,509
凯文


2017
01:15:17,569 --> 01:15:18,289
凯伦


2018
01:15:18,319 --> 01:15:19,909
吉姆和奥斯卡


2019
01:15:20,089 --> 01:15:24,498
我们基本上去掉了列表里的最后一个元素这就是pop的作用


2020
01:15:24,588 --> 01:15:25,848
它会弹出一个元素


2021
01:15:25,908 --> 01:15:29,718
在列表中，可以轻松删除列表中的最后一个元素。


2022
01:15:29,778 --> 01:15:30,828
这是我们的列表


2023
01:15:30,858 --> 01:15:32,868
但是假设我们想要算出


2024
01:15:32,898 --> 01:15:33,228
如果


2025
01:15:33,258 --> 01:15:35,448
这个列表中有一个元素


2026
01:15:35,568 --> 01:15:37,758
如果这里有某个值那么我们说


2027
01:15:37,878 --> 01:15:39,708
我想检查一下


2028
01:15:39,769 --> 01:15:40,459
我的朋友


2029
01:15:40,489 --> 01:15:41,809
凯文在这个名单里。


2030
01:15:42,049 --> 01:15:43,489
为什么说朋友


2031
01:15:43,519 --> 01:15:44,239
点


2032
01:15:44,359 --> 01:15:45,169
索引


2033
01:15:45,379 --> 01:15:46,159
在这里


2034
01:15:46,189 --> 01:15:47,389
我可以通过


2035
01:15:47,629 --> 01:15:49,580
一个值，我可以这样说


2036
01:15:50,120 --> 01:15:50,810
凯文。


2037
01:15:51,530 --> 01:15:53,391
这将告诉我

2038
01:15:53,690 --> 01:15:54,230
在


2039
01:15:54,291 --> 01:15:55,551
洞穴是告诉我

2040
01:15:55,581 --> 01:15:56,631
在名单上的小木屋，


2041
01:15:56,872 --> 01:15:58,102
所以我可以玩


2042
01:15:58,342 --> 01:15:59,632
你可以看到这里写着


2043
01:15:59,662 --> 01:16:00,322
零


2044
01:16:00,532 --> 01:16:01,552
如果我想说


2045
01:16:01,582 --> 01:16:03,142
比如奥斯卡和这里


2046
01:16:03,412 --> 01:16:04,731
现在给我一个

2047
01:16:05,151 --> 01:16:05,781
奥斯卡。


2048
01:16:06,111 --> 01:16:07,372
这是3


2049
01:16:07,762 --> 01:16:10,643
但是如果我在这里放一个不存在的名字


2050
01:16:10,823 --> 01:16:11,843
如果我把迈克


2051
01:16:12,053 --> 01:16:13,223
不在名单上。


2052
01:16:13,433 --> 01:16:14,843
现在我们要回来了


2053
01:16:15,023 --> 01:16:15,653
错误


2054
01:16:15,683 --> 01:16:16,523
因为这是


2055
01:16:16,583 --> 01:16:18,293
迈克不在名单上


2056
01:16:18,503 --> 01:16:22,463
这是一种简单的方法，你可以算出列表中特定的元素。


2057
01:16:22,613 --> 01:16:23,513
如果是的话，


2058
01:16:23,573 --> 01:16:25,522
然后你知道它的应用是什么索引，


2059
01:16:25,583 --> 01:16:29,453
您还可以计算列表中相似元素的数量


2060
01:16:29,723 --> 01:16:31,853
我要在这里复制这个


2061
01:16:31,883 --> 01:16:32,843
宝石元素


2062
01:16:33,113 --> 01:16:34,223
然后再加一个


2063
01:16:34,252 --> 01:16:35,573
吉姆元素到这里


2064
01:16:36,083 --> 01:16:38,453
所以我可以到这里来，我可以说是朋友


2065
01:16:38,482 --> 01:16:38,962
点


2066
01:16:38,992 --> 01:16:39,532
计数


2067
01:16:40,552 --> 01:16:41,062
并且


2068
01:16:41,092 --> 01:16:42,022
将通过


2069
01:16:42,052 --> 01:16:42,622
健身房


2070
01:16:43,012 --> 01:16:45,231
它会告诉我这个值的多少倍


2071
01:16:45,261 --> 01:16:45,831
吉姆


2072
01:16:45,920 --> 01:16:46,610
出现


2073
01:16:46,640 --> 01:16:47,690
在这里面


2074
01:16:47,720 --> 01:16:48,350
列表。


2075
01:16:48,680 --> 01:16:51,591
所以它应该说它在那里做了什么因为


2076
01:16:51,801 --> 01:16:52,581
我们有两个


2077
01:16:52,610 --> 01:16:53,541
价值


2078
01:16:53,570 --> 01:16:54,170
那


2079
01:16:54,500 --> 01:16:55,010
文字


2080
01:16:55,040 --> 01:16:55,610
健身房。


2081
01:16:55,820 --> 01:16:59,691
所以我们有了所有这些值我们也可以对这个列表进行排序


2082
01:16:59,751 --> 01:17:01,221
我可以到这里来，我可以说


2083
01:17:01,551 --> 01:17:03,111
朋友点排序。


2084
01:17:03,621 --> 01:17:06,081
它会做的是对列表进行排序


2085
01:17:06,111 --> 01:17:06,621
在


2086
01:17:06,861 --> 01:17:08,181
升序


2087
01:17:08,391 --> 01:17:09,441
我们有一堆


2088
01:17:09,501 --> 01:17:11,121
这里的文本，你会看到它的作用。


2089
01:17:11,391 --> 01:17:14,841
基本上它要做的是把它按字母顺序排列


2090
01:17:15,081 --> 01:17:16,822
你看，我们有j k


2091
01:17:16,882 --> 01:17:18,112
o和t


2092
01:17:18,382 --> 01:17:23,663
这个列表从一个随机的顺序开始，就像我们现在看到的一样，它是按字母顺序排列的。


2093
01:17:23,873 --> 01:17:27,502
这也适用于幸运数字所以我可以说是晚了


2094
01:17:28,192 --> 01:17:29,602
幸运数字


2095
01:17:29,632 --> 01:17:30,292
点


2096
01:17:30,382 --> 01:17:32,902
排序然后我们会发现

2097
01:17:33,742 --> 01:17:36,353
它们现在应该是升序的，


2098
01:17:37,223 --> 01:17:39,623
我意识到它们已经在上面了但是如果我


2099
01:17:39,653 --> 01:17:41,483
就是把这四十二个


2100
01:17:42,713 --> 01:17:43,913
把它放在这里。


2101
01:17:45,203 --> 01:17:48,593
现在，它会把所有的东西都计算出来，并把它按升序排列。


2102
01:17:48,653 --> 01:17:49,853
我们也可以反过来


2103
01:17:49,883 --> 01:17:50,393
一份清单


2104
01:17:50,423 --> 01:17:52,553
所以如果我想我可以把它反过来


2105
01:17:52,583 --> 01:17:54,173
我可以说幸运数字列表


2106
01:17:54,203 --> 01:17:55,402
幸运数字

2107
01:17:55,522 --> 01:17:56,302
相反。


2108
01:17:56,512 --> 01:18:00,713
现在我们把它打印出来，而不是四十到八十五十六二十三。


2109
01:18:00,893 --> 01:18:03,353
它是二十三十六十五八四十二，


2110
01:18:04,223 --> 01:18:06,624
所以它的顺序是颠倒的


2111
01:18:06,713 --> 01:18:07,313
名单。


2112
01:18:07,403 --> 01:18:09,204
最后还有一个


2113
01:18:09,384 --> 01:18:09,534
或者


2114
01:18:09,563 --> 01:18:11,874
不那么实用的货币眼，就是复制。


2115
01:18:12,144 --> 01:18:12,744
所以


2116
01:18:12,774 --> 01:18:14,124
我可以创建


2117
01:18:14,184 --> 01:18:15,444
另一个列表。


2118
01:18:15,714 --> 01:18:16,254
我可以


2119
01:18:16,284 --> 01:18:18,774
把它做成一个副本，这样我就可以说


2120
01:18:19,884 --> 01:18:21,144
朋友也是。


2121
01:18:21,354 --> 01:18:22,763
我们可以令它等于


2122
01:18:22,823 --> 01:18:23,603
朋友


2123
01:18:23,633 --> 01:18:24,053
医生


2124
01:18:24,083 --> 01:18:24,743
复制


2125
01:18:25,343 --> 01:18:26,333
现在朋友们


2126
01:18:26,363 --> 01:18:28,042
也会有相同的结果


2127
01:18:28,103 --> 01:18:30,143
作为朋友的属性，


2128
01:18:30,982 --> 01:18:32,482
因为它基本上就像


2129
01:18:32,572 --> 01:18:35,662
复制它，基本上拿走了朋友列表的副本


2130
01:18:36,382 --> 01:18:37,792
你可以看到它是一样的


2131
01:18:37,972 --> 01:18:41,722
复制列表在很多不同的情况下都很有用


2132
01:18:41,992 --> 01:18:44,812
这些只是一些基本的列表函数，就像


2133
01:18:45,052 --> 01:18:47,482
你知道，在处理列表的时候会弄湿你的脚


2134
01:18:47,512 --> 01:18:52,612
很明显，你和他们一起工作越多你练习的越多，你就会越舒服


2135
01:18:52,642 --> 01:18:53,032
得到。


2136
01:18:53,182 --> 01:18:56,243
但这只是对你能做什么的基本概述


2137
01:19:00,683 --> 01:19:01,643
在服装上


2138
01:19:01,672 --> 01:19:04,013
跟你们说，你们买了topin


2139
01:19:04,042 --> 01:19:04,822
python。


2140
01:19:05,212 --> 01:19:07,163
topal是一种类型


2141
01:19:07,192 --> 01:19:07,552
在


2142
01:19:07,582 --> 01:19:08,602
数据结构


2143
01:19:08,872 --> 01:19:10,942
这基本上意味着它是一个容器


2144
01:19:11,242 --> 01:19:12,202
我们可以储存


2145
01:19:12,232 --> 01:19:13,612
不同的价值观。


2146
01:19:14,002 --> 01:19:16,102
如果你对列表很熟悉


2147
01:19:16,132 --> 01:19:17,032
在python里


2148
01:19:17,062 --> 01:19:20,302
跌倒实际上和一个列表非常相似。


2149
01:19:20,662 --> 01:19:22,642
它基本上是一个我们可以存储的结构


2150
01:19:22,672 --> 01:19:24,022
多片


2151
01:19:24,052 --> 01:19:24,922
信息，


2152
01:19:25,402 --> 01:19:25,852
但是


2153
01:19:25,942 --> 01:19:29,212
寺庙与列表有一些关键的区别


2154
01:19:29,242 --> 01:19:30,382
我们要讲的是


2155
01:19:31,012 --> 01:19:31,852
本教程。


2156
01:19:32,151 --> 01:19:34,582
我想做的第一件事是我想向你们展示如何


2157
01:19:34,612 --> 01:19:35,751
创建一个表。


2158
01:19:36,142 --> 01:19:38,872
所以我可以到这里来创建一个topal


2159
01:19:39,112 --> 01:19:39,953
最重要的


2160
01:19:40,792 --> 01:19:41,302
普通的


2161
01:19:41,332 --> 01:19:43,912
他的坐标的例子。


2162
01:19:44,122 --> 01:19:47,962
假设我有一系列的x y坐标我可以创建一个变量


2163
01:19:49,282 --> 01:19:50,362
被称为坐标


2164
01:19:50,422 --> 01:19:51,532
亚当将会设置这个


2165
01:19:51,562 --> 01:19:52,492
等于


2166
01:19:52,732 --> 01:19:52,942
一


2167
01:19:52,972 --> 01:19:54,952
开闭括号，


2168
01:19:55,252 --> 01:19:57,682
无论何时我们想要在


2169
01:19:57,742 --> 01:19:59,422
我们将使用这些


2170
01:19:59,452 --> 01:20:00,921
开闭括号


2171
01:20:01,251 --> 01:20:01,492
并且


2172
01:20:01,552 --> 01:20:06,051
在这里，在这些收益中我们将放入我们想要存储的值


2173
01:20:06,381 --> 01:20:08,812
我可以举个例子


2174
01:20:08,842 --> 01:20:09,202
在


2175
01:20:09,262 --> 01:20:09,922
数字，


2176
01:20:10,222 --> 01:20:10,552
所以


2177
01:20:10,582 --> 01:20:14,272
这可能是我的坐标，我可以有4和5。


2178
01:20:14,572 --> 01:20:17,841
这就是我的坐标


2179
01:20:17,871 --> 01:20:18,561
在里面。


2180
01:20:19,011 --> 01:20:21,832
其中的一件事就是让它们变得独一无二


2181
01:20:21,861 --> 01:20:23,031
是一座寺庙


2182
01:20:23,271 --> 01:20:24,082
不可变，


2183
01:20:24,532 --> 01:20:26,932
当我们讨论到顶的时候你会经常听到这个词


2184
01:20:26,992 --> 01:20:28,912
不可变的意思是


2185
01:20:29,001 --> 01:20:31,432
这座寺庙不能被改变或修改。


2186
01:20:31,702 --> 01:20:34,132
一旦我们在这里创建了topal。


2187
01:20:34,372 --> 01:20:35,872
你不能修改它


2188
01:20:35,901 --> 01:20:37,371
不能改变，你不能改变


2189
01:20:37,431 --> 01:20:38,961
添加元素，你不能


2190
01:20:39,351 --> 01:20:41,092
从它中删除元素，你不能


2191
01:20:41,122 --> 01:20:43,492
改变寺庙内的任何元素。


2192
01:20:43,822 --> 01:20:47,092
你所看到的是一旦你创造了颠覆它你会得到什么


2193
01:20:47,242 --> 01:20:48,652
它是这样做的，因为它不能改变


2194
01:20:48,892 --> 01:20:50,932
所以我可以到这里来，我可以


2195
01:20:51,082 --> 01:20:51,952
打印输出


2196
01:20:52,162 --> 01:20:53,362
一些


2197
01:20:54,292 --> 01:20:55,792
神庙内的属性。


2198
01:20:56,122 --> 01:20:57,861
我可以用它来访问它们


2199
01:20:57,891 --> 01:20:58,641
是


2200
01:20:58,671 --> 01:20:59,601
仅仅通过使用


2201
01:20:59,631 --> 01:21:01,491
打开和关闭的方括号。


2202
01:21:01,731 --> 01:21:03,681
在这里我可以通过


2203
01:21:03,711 --> 01:21:04,131
a


2204
01:21:04,161 --> 01:21:04,821
索引


2205
01:21:05,091 --> 01:21:06,411
所以麻烦被索引了


2206
01:21:06,441 --> 01:21:09,532
从0开始，从技术上讲，我们会说4


2207
01:21:09,862 --> 01:21:11,392
这个指数是1


2208
01:21:11,452 --> 01:21:12,142
为了


2209
01:21:12,231 --> 01:21:12,682
工地


2210
01:21:13,551 --> 01:21:15,231
是在博览会0中吗


2211
01:21:15,291 --> 01:21:16,161
其中五个


2212
01:21:16,191 --> 01:21:18,021
这是指数位置，如果我说


2213
01:21:18,051 --> 01:21:19,190
坐标零


2214
01:21:19,250 --> 01:21:21,620
现在它应该打印出四个


2215
01:21:23,090 --> 01:21:25,340
下面是打印出来的4个。


2216
01:21:25,730 --> 01:21:29,960
如果我想把这5个打印出来我们就可以在这些方括号中放入一个


2217
01:21:30,470 --> 01:21:33,080
现在我们打印出5个这样我就可以访问了


2218
01:21:33,109 --> 01:21:34,160
元素


2219
01:21:34,580 --> 01:21:35,390
在


2220
01:21:35,419 --> 01:21:36,169
我可以推翻


2221
01:21:36,199 --> 01:21:37,549
很容易进入


2222
01:21:37,579 --> 01:21:37,819
每一个


2223
01:21:37,849 --> 01:21:38,389
进入。


2224
01:21:38,749 --> 01:21:39,139
但是


2225
01:21:39,169 --> 01:21:42,020
如果我来这里试着改变


2226
01:21:42,170 --> 01:21:44,720
其中一个元素，如果我说坐标


2227
01:21:45,110 --> 01:21:45,740
并且


2228
01:21:45,860 --> 01:21:49,040
坐标1，我试着让它等于其他的东西


2229
01:21:49,430 --> 01:21:50,090
十


2230
01:21:50,780 --> 01:21:52,700
实际上，python会给我们一个


2231
01:21:52,729 --> 01:21:55,219
运行这个程序时，会出现错误，通常运行程序。


2232
01:21:55,429 --> 01:21:57,229
你看，我们得到这个错误它说


2233
01:21:57,739 --> 01:21:58,129
类型


2234
01:21:58,159 --> 01:21:58,668
空气


2235
01:21:58,698 --> 01:21:59,928
倾覆物


2236
01:21:59,958 --> 01:22:01,128
不支持


2237
01:22:01,218 --> 01:22:01,668
项目


2238
01:22:01,698 --> 01:22:02,418
转让


2239
01:22:02,688 --> 01:22:04,068
因为它是不可变的


2240
01:22:04,098 --> 01:22:06,438
因为我们不能改变它


2241
01:22:07,038 --> 01:22:09,168
这就是最基本的东西


2242
01:22:09,198 --> 01:22:10,608
我们如何创造它们


2243
01:22:11,538 --> 01:22:14,658
像我说过的，这很简单，你刚刚创建，然后你有，


2244
01:22:15,048 --> 01:22:15,498
嗯。


2245
01:22:15,978 --> 01:22:20,868
现在我想和你们谈谈在python中一个常见的话题即两者之间的区别


2246
01:22:21,108 --> 01:22:21,798
顶顶


2247
01:22:21,828 --> 01:22:23,148
还有列表。


2248
01:22:23,358 --> 01:22:23,748
所以


2249
01:22:23,778 --> 01:22:26,178
记住，一个列表基本上是在做同样的事情


2250
01:22:26,208 --> 01:22:26,838
一个列表。


2251
01:22:27,018 --> 01:22:30,739
如果要创建一个更少的，我们只需要用方括号来代替那些括号。


2252
01:22:31,189 --> 01:22:32,930
如果我使用的是列表


2253
01:22:32,959 --> 01:22:33,560
我可以


2254
01:22:33,709 --> 01:22:35,810
给它赋值不同的值，


2255
01:22:35,930 --> 01:22:36,950
我基本上可以


2256
01:22:37,459 --> 01:22:40,040
改变任何我可以添加删除的元素


2257
01:22:40,760 --> 01:22:43,430
修改我想要的列表，


2258
01:22:43,580 --> 01:22:44,810
但是有了一个颠覆。


2259
01:22:44,930 --> 01:22:46,669
我们不能那样做，那是


2260
01:22:46,759 --> 01:22:48,350
这是基本的区别


2261
01:22:48,709 --> 01:22:49,640
真正的python


2262
01:22:49,669 --> 01:22:54,471
没有说任何东西它只是说其中一个是不可变的其中一个不是


2263
01:22:54,801 --> 01:22:55,311
但是


2264
01:22:55,551 --> 01:23:01,851
在实际用例中，一般情况下，人们会使用最不可能改变的数据


2265
01:23:02,210 --> 01:23:04,940
所以你会在倾覆的过程中偷取储存的dna


2266
01:23:05,121 --> 01:23:07,070
当这些数据不需要的时候


2267
01:23:07,130 --> 01:23:09,561
突变，这就是为什么像坐标这样的东西


2268
01:23:09,860 --> 01:23:12,230
这对夫妇来说是很好的选择，因为


2269
01:23:12,530 --> 01:23:13,880
一旦你有了像这样的坐标


2270
01:23:13,910 --> 01:23:16,220
我们可能不会对它们进行修改，


2271
01:23:16,280 --> 01:23:17,150
我们可以加上


2272
01:23:17,180 --> 01:23:18,200
其他坐标。


2273
01:23:18,410 --> 01:23:21,740
举个例子，如果我想我可以创建一个隧道列表。


2274
01:23:21,920 --> 01:23:22,671
所以我可以说


2275
01:23:22,731 --> 01:23:23,721
四五


2276
01:23:24,861 --> 01:23:26,061
六七，


2277
01:23:26,751 --> 01:23:28,431
也许我们有其他的坐标


2278
01:23:28,521 --> 01:23:29,331
八十


2279
01:23:29,721 --> 01:23:30,801
三十四。


2280
01:23:31,221 --> 01:23:32,631
这里我有


2281
01:23:32,661 --> 01:23:33,531
我有一个列表


2282
01:23:33,591 --> 01:23:35,091
在里面我们有这些


2283
01:23:35,121 --> 01:23:35,781
隧道。


2284
01:23:36,921 --> 01:23:41,151
但是记住这些元组不能被修改这些值不能被改变


2285
01:23:41,511 --> 01:23:43,401
实际上，这只是一个案例的案例


2286
01:23:43,431 --> 01:23:44,181
我会说


2287
01:23:44,361 --> 01:23:45,921
以绝对多数。


2288
01:23:46,101 --> 01:23:48,231
大多数时候你都在使用列表。


2289
01:23:48,951 --> 01:23:50,991
上层或更多的利基


2290
01:23:51,051 --> 01:23:51,411
你知道


2291
01:23:51,440 --> 01:23:53,811
他们使用的是更特殊的情况。


2292
01:23:54,411 --> 01:23:54,831
但是


2293
01:23:54,951 --> 01:24:01,400
有很多情况下你想要使用被推翻的情况如果你想要存储无法改变或突变的数据


2294
01:24:02,570 --> 01:24:04,041
然后就会有很多的东西


2295
01:24:04,101 --> 01:24:08,121
对俄罗斯来说，一些基本的基本知识是关于两者之间的区别的


2296
01:24:08,301 --> 01:24:09,651
列表和顶部


2297
01:24:09,831 --> 01:24:12,261
因此，在c中加入一个翻滚是一件很棒的事情


2298
01:24:12,291 --> 01:24:13,161
蟒蛇


2299
01:24:13,190 --> 01:24:14,090
曲目


2300
01:24:18,800 --> 01:24:21,170
在本教程中，我想和你们讨论一下


2301
01:24:21,200 --> 01:24:23,120
在python中的函数。


2302
01:24:23,660 --> 01:24:25,249
一个函数基本上就是


2303
01:24:25,279 --> 01:24:27,019
一组代码，


2304
01:24:27,318 --> 01:24:29,599
它执行特定的任务


2305
01:24:29,628 --> 01:24:30,588
所以我可以


2306
01:24:30,829 --> 01:24:33,949
一堆代码基本上是在做一件事


2307
01:24:34,189 --> 01:24:35,750
我可以把它们放到一个函数里面。


2308
01:24:35,990 --> 01:24:37,549
然后当我想要


2309
01:24:37,579 --> 01:24:41,479
做那个任务或者做那个函数正在做的事情，


2310
01:24:41,719 --> 01:24:43,819
我可以调用这个函数


2311
01:24:44,270 --> 01:24:48,770
所以函数可以帮助你更好地组织你的代码它们让你可以


2312
01:24:48,800 --> 01:24:50,690
把你的代码分解成不同的


2313
01:24:50,990 --> 01:24:53,570
你知道小块在做不同的事情


2314
01:24:53,840 --> 01:24:56,900
它们真的很棒所以函数就像一个核心


2315
01:24:56,930 --> 01:24:59,960
当我们讨论用python编程时，


2316
01:25:00,290 --> 01:25:02,601
孤独的眼睛如何创造一个令人敬畏的


2317
01:25:02,630 --> 01:25:03,710
日函数


2318
01:25:04,101 --> 01:25:07,611
我们说，为了本教程的目的我们想要创建一个函数


2319
01:25:07,791 --> 01:25:09,921
这对用户来说是很高的


2320
01:25:10,281 --> 01:25:14,421
我们的函数执行的一个任务就是向大家问好


2321
01:25:14,631 --> 01:25:16,371
不管谁在写程序


2322
01:25:16,761 --> 01:25:17,391
在这里，


2323
01:25:18,111 --> 01:25:20,872
如果我想要写一个函数我要用的第一件事


2324
01:25:20,901 --> 01:25:24,082
是python里的一个关键词，它的冰冷深度


2325
01:25:24,112 --> 01:25:25,102
d e f


2326
01:25:25,612 --> 01:25:26,092
并且


2327
01:25:26,122 --> 01:25:27,232
基本上


2328
01:25:27,262 --> 01:25:29,752
python会看到这个关键词它会说


2329
01:25:29,812 --> 01:25:30,442
好的


2330
01:25:30,562 --> 01:25:33,352
这个人想要使用一个函数。


2331
01:25:33,802 --> 01:25:35,603
所以在我们输入死亡之后


2332
01:25:35,632 --> 01:25:37,282
我们需要给出这个函数


2333
01:25:37,312 --> 01:25:37,912
一个名字，


2334
01:25:38,362 --> 01:25:39,623
就像我们


2335
01:25:39,652 --> 01:25:40,132
是


2336
01:25:40,162 --> 01:25:43,282
创建变量，我们给它们描述性名称。


2337
01:25:43,462 --> 01:25:46,942
我们也想对函数做同样的事情。


2338
01:25:47,182 --> 01:25:52,672
所以如果我创建一个函数我可以给它一个特定的名字它基本上是说它在做什么


2339
01:25:52,912 --> 01:25:55,882
我们要创建一个高的函数所以我要


2340
01:25:55,912 --> 01:25:56,842
调用这个函数，


2341
01:25:57,352 --> 01:25:58,162
嗨，


2342
01:25:58,282 --> 01:25:59,062
就像这样。


2343
01:26:00,232 --> 01:26:02,183
一旦我们输入了函数的名字


2344
01:26:02,212 --> 01:26:05,303
所以我也可以输入高，不，不


2345
01:26:05,633 --> 01:26:08,783
下划线或者我可以用下划线来表示。


2346
01:26:09,143 --> 01:26:10,673
两者都被认为

2347
01:26:10,733 --> 01:26:13,194
好的实践和python，以及很多时候


2348
01:26:13,344 --> 01:26:14,813
如果你有一个简单的


2349
01:26:14,874 --> 01:26:16,553
像这样的两个词函数


2350
01:26:16,583 --> 01:26:19,224
你不需要加下划线但是我们可以在这里加个下划线


2351
01:26:19,764 --> 01:26:20,424
如果我们愿意的话。


2352
01:26:20,694 --> 01:26:22,314
在我们输入函数名之后


2353
01:26:22,344 --> 01:26:24,685
我只需要输入开闭括号。


2354
01:26:25,194 --> 01:26:25,584
并且


2355
01:26:25,614 --> 01:26:26,334
然后我要输入


2356
01:26:26,364 --> 01:26:27,294
结肠


2357
01:26:27,685 --> 01:26:31,015
基本上这就是对python湖说的


2358
01:26:31,345 --> 01:26:31,675
或眼睛


2359
01:26:31,705 --> 01:26:34,615
这一行之后的所有代码


2360
01:26:34,825 --> 01:26:35,665
将会是


2361
01:26:35,695 --> 01:26:37,135
在我们的函数里面。


2362
01:26:37,555 --> 01:26:39,234
为了


2363
01:26:39,294 --> 01:26:43,496
写代码，它最终会在我们实际需要的函数中


2364
01:26:43,556 --> 01:26:44,876
已售出的缩进


2365
01:26:45,236 --> 01:26:45,926
在这里。


2366
01:26:46,166 --> 01:26:48,295
你会注意到当我点击进入的时候


2367
01:26:48,325 --> 01:26:50,065
自动文本编辑器


2368
01:26:50,125 --> 01:26:52,616
缩进式攻击，所以它是自动的


2369
01:26:53,306 --> 01:26:54,836
使用这个缩进


2370
01:26:55,196 --> 01:26:55,646
而且


2371
01:26:55,676 --> 01:26:57,806
有一个规则和python就像


2372
01:26:58,436 --> 01:27:00,986
这个函数内部的代码


2373
01:27:01,016 --> 01:27:02,695
需要缩进。


2374
01:27:02,905 --> 01:27:04,646
如果我要写一些代码


2375
01:27:04,766 --> 01:27:05,696
就像在这里，


2376
01:27:05,906 --> 01:27:09,446
这个函数在函数里面不再被考虑了所以你可以看到


2377
01:27:09,746 --> 01:27:11,756
当我输入代码时，显然这不是


2378
01:27:11,786 --> 01:27:12,656
真正的代码


2379
01:27:12,866 --> 01:27:14,606
当我在这里输入文本时


2380
01:27:14,636 --> 01:27:15,326
发明


2381
01:27:15,536 --> 01:27:17,786
这个有点像这里的标记


2382
01:27:18,026 --> 01:27:19,196
基本上是说


2383
01:27:19,286 --> 01:27:19,646
哦，是的


2384
01:27:19,676 --> 01:27:20,905
这是在函数里面。


2385
01:27:21,265 --> 01:27:22,735
但是当我写代码的时候


2386
01:27:22,765 --> 01:27:24,085
在这里，就像


2387
01:27:24,115 --> 01:27:25,285
不一样


2388
01:27:25,375 --> 01:27:27,145
缩进水平就是这个东西。


2389
01:27:27,325 --> 01:27:30,295
它不再在函数中考虑它了


2390
01:27:30,745 --> 01:27:34,436
这是一个小的东西这个函数里面的任何代码都需要缩进


2391
01:27:35,096 --> 01:27:39,537
对，我们的函数就是向用户打招呼我将会得到它


2392
01:27:39,567 --> 01:27:40,407
打印输出


2393
01:27:42,567 --> 01:27:43,887
有些税会说


2394
01:27:43,917 --> 01:27:44,577
你好。


2395
01:27:44,727 --> 01:27:45,357
用户。


2396
01:27:45,447 --> 01:27:49,587
这是一个非常简单的函数显然我们只有一行代码


2397
01:27:49,797 --> 01:27:51,057
在一个函数里面


2398
01:27:51,087 --> 01:27:53,007
你知道你想要的代码行数


2399
01:27:53,247 --> 01:27:57,268
对于我们的目的，我们只需要一行来执行我们的函数。


2400
01:27:57,598 --> 01:27:58,167
所以


2401
01:27:58,197 --> 01:27:59,638
现在我们要做的是


2402
01:27:59,667 --> 01:28:01,318
调用这个函数


2403
01:28:01,408 --> 01:28:05,487
如果我想要执行这个函数里面的代码我必须做点什么


2404
01:28:05,607 --> 01:28:05,998
呼叫


2405
01:28:06,027 --> 01:28:07,107
这么说


2406
01:28:07,498 --> 01:28:10,407
如果我要像现在这样运行我的程序，


2407
01:28:10,527 --> 01:28:11,428
我要运行它，


2408
01:28:12,088 --> 01:28:14,398
你会发现这里什么都没有发生


2409
01:28:14,458 --> 01:28:14,878
对吧？


2410
01:28:15,658 --> 01:28:16,858
尽管这个函数是


2411
01:28:16,888 --> 01:28:19,528
在运行程序时打印hello用户


2412
01:28:19,558 --> 01:28:20,698
它不是这样做的，


2413
01:28:21,088 --> 01:28:23,278
这是因为函数内部的代码


2414
01:28:23,308 --> 01:28:24,958
不会被执行


2415
01:28:24,988 --> 01:28:26,008
在默认情况下。


2416
01:28:26,788 --> 01:28:32,127
当我们指定想要执行它的时候，函数内的代码只会被执行。


2417
01:28:32,458 --> 01:28:37,377
为了做到这一点，我们需要做一种叫做调用函数的东西为了调用一个函数，


2418
01:28:37,947 --> 01:28:41,608
你只要输入函数名就行了。


2419
01:28:41,968 --> 01:28:43,139
所以我要输入输出


2420
01:28:43,168 --> 01:28:44,278
打招呼


2421
01:28:44,428 --> 01:28:44,698
并且


2422
01:28:44,728 --> 01:28:46,048
开闭括号。


2423
01:28:46,708 --> 01:28:47,877
当我们在，


2424
01:28:48,117 --> 01:28:49,647
当我们再次运行这个程序时，


2425
01:28:50,098 --> 01:28:50,998
你会看到


2426
01:28:51,088 --> 01:28:51,718
打印出来


2427
01:28:51,748 --> 01:28:54,237
你好，用户在执行代码


2428
01:28:54,267 --> 01:28:55,437
在函数内部。


2429
01:28:56,097 --> 01:28:58,557
我想再给你们看一件事


2430
01:28:58,767 --> 01:29:02,158
和你们讨论一下这些函数是如何工作的


2431
01:29:02,638 --> 01:29:04,289
上面这里我要打印顶部


2432
01:29:04,708 --> 01:29:05,758
然后在下面这里


2433
01:29:05,788 --> 01:29:06,658
我要打印


2434
01:29:07,588 --> 01:29:08,128
底部。


2435
01:29:08,398 --> 01:29:10,528
我想给大家展示一下


2436
01:29:10,558 --> 01:29:12,927
这些函数在程序中，所以当我


2437
01:29:12,987 --> 01:29:13,917
运行这个程序


2438
01:29:15,267 --> 01:29:16,737
我们打印出顶部


2439
01:29:17,067 --> 01:29:18,208
你好用户


2440
01:29:18,507 --> 01:29:19,468
然后是bada。


2441
01:29:19,708 --> 01:29:21,418
所以本质上是这样的


2442
01:29:21,479 --> 01:29:22,889
当python完成的时候


2443
01:29:22,918 --> 01:29:24,088
执行这个


2444
01:29:24,269 --> 01:29:24,869
程序，


2445
01:29:25,289 --> 01:29:27,149
它在这里到第一行，上面写着


2446
01:29:27,179 --> 01:29:27,688
好的


2447
01:29:28,258 --> 01:29:30,389
我们想要打印出顶部这个词


2448
01:29:30,569 --> 01:29:32,039
然后它向下到这里，上面写着


2449
01:29:32,129 --> 01:29:34,919
好的，我们想要执行高函数


2450
01:29:35,279 --> 01:29:37,019
所以python实际上是跳跃的


2451
01:29:37,049 --> 01:29:37,469
向上


2452
01:29:37,739 --> 01:29:40,169
它除以这个，高函数，


2453
01:29:40,289 --> 01:29:41,429
它会执行


2454
01:29:41,459 --> 01:29:42,599
所有的代码


2455
01:29:42,659 --> 01:29:44,759
在这个函数里面


2456
01:29:45,029 --> 01:29:47,009
它会执行所有这些代码。


2457
01:29:47,159 --> 01:29:50,309
一旦它完成了所有的代码和函数，


2458
01:29:50,519 --> 01:29:51,659
它会往回跳


2459
01:29:51,688 --> 01:29:57,300
在下面，它会移动到下一行，也就是底部这就是函数的流动，


2460
01:29:57,450 --> 01:29:59,729
同样的，在我们的工作中


2461
01:29:59,759 --> 01:30:01,169
命名这些函数


2462
01:30:01,589 --> 01:30:02,039
并且


2463
01:30:02,159 --> 01:30:03,419
你想让它们被命名


2464
01:30:03,509 --> 01:30:04,890
在所有较低的情况下，


2465
01:30:05,700 --> 01:30:07,890
通常当我们用python命名东西的时候


2466
01:30:07,920 --> 01:30:10,290
如果有两个或两个以上的词我们就会用到


2467
01:30:10,320 --> 01:30:11,280
在太空中


2468
01:30:11,460 --> 01:30:13,110
或者是两者之间的一个下划线。


2469
01:30:13,320 --> 01:30:16,170
所以我可以把它写在分数高的地方。


2470
01:30:16,561 --> 01:30:17,041
但是


2471
01:30:17,130 --> 01:30:21,181
在很多情况下如果我有一个这样的函数名字很短


2472
01:30:21,421 --> 01:30:22,982
可能会更容易离开它


2473
01:30:23,012 --> 01:30:24,062
没有下划线，

2474
01:30:24,091 --> 01:30:26,311
为什么我们现在花在得分上只是为了成为a


2475
01:30:27,121 --> 01:30:28,771
超级python官员。


2476
01:30:29,581 --> 01:30:30,421
好了，现在


2477
01:30:30,571 --> 01:30:37,262
我们可以让这些函数变得更强大我们能做的就是给它们信息。


2478
01:30:37,592 --> 01:30:42,511
所以很多时候，当我们写一个函数时我们会想要得到额外的信息


2479
01:30:42,541 --> 01:30:43,411
通过。


2480
01:30:43,861 --> 01:30:45,691
这些被称为参数


2481
01:30:45,721 --> 01:30:48,480
所以一个参数是一个信息


2482
01:30:48,720 --> 01:30:50,070
我们给予


2483
01:30:50,100 --> 01:30:50,910
函数，


2484
01:30:51,420 --> 01:30:52,020
所以


2485
01:30:52,080 --> 01:30:58,260
在这里，我可以指定这个函数需要接收一些参数我可以这样说


2486
01:30:58,560 --> 01:31:00,450
如果你要调用这个

2487
01:31:00,630 --> 01:31:02,280
你需要给我们一些信息，


2488
01:31:02,460 --> 01:31:03,781
你需要给我们一些参数


2489
01:31:04,261 --> 01:31:10,801
我要做的就是输入我想要接收的参数的名称为什么不允许


2490
01:31:12,031 --> 01:31:15,481
调用这个函数的代码来告诉它hi的名字


2491
01:31:15,901 --> 01:31:17,611
上面这里我可以写上名字


2492
01:31:18,241 --> 01:31:22,501
它的意思是，它的意思是，每当我调用这个函数时


2493
01:31:22,651 --> 01:31:24,361
我们得给它起个名字。


2494
01:31:24,721 --> 01:31:26,551
所以在这里，如果我要调用这个


2495
01:31:26,581 --> 01:31:29,521
我必须在这里加上一个名字，这样我就可以说


2496
01:31:30,242 --> 01:31:30,782
迈克。


2497
01:31:30,872 --> 01:31:35,701
我们现在可以做的是我们可以访问这个参数或者这个变量


2498
01:31:36,151 --> 01:31:37,501
在我们的内部


2499
01:31:37,531 --> 01:31:40,771
函数，所以我可以到这里来，而不是说hello用户。


2500
01:31:41,071 --> 01:31:42,451
我可以打个招呼


2501
01:31:42,571 --> 01:31:43,201
名字


2502
01:31:43,591 --> 01:31:48,992
基本上它会做的是，它会对传入的任何名称表示hello


2503
01:31:49,502 --> 01:31:51,272
所以我要复制这个


2504
01:31:51,302 --> 01:31:51,812
并且


2505
01:31:51,872 --> 01:31:52,622
我们会


2506
01:31:53,102 --> 01:31:55,712
再做两次，你好，我的公斤


2507
01:31:55,742 --> 01:31:56,612
史蒂夫


2508
01:31:57,662 --> 01:31:59,731
现在当我运行这个程序时


2509
01:31:59,972 --> 01:32:01,082
你会看到


2510
01:32:01,292 --> 01:32:02,102
而不是简单地说


2511
01:32:02,132 --> 01:32:03,152
你好用户


2512
01:32:03,272 --> 01:32:05,583
它向任何一个名字问好


2513
01:32:05,612 --> 01:32:07,232
我把它传递给函数。


2514
01:32:07,532 --> 01:32:09,842
这就是为什么这是非常有用的


2515
01:32:10,022 --> 01:32:11,643
给出函数信息


2516
01:32:12,002 --> 01:32:13,833
根据我们提供的信息


2517
01:32:13,922 --> 01:32:15,123
它会执行性能任务


2518
01:32:15,152 --> 01:32:16,292
有一点不同。


2519
01:32:16,743 --> 01:32:17,612
我也可以


2520
01:32:18,092 --> 01:32:20,192
包含不止一个参数，我的意思是


2521
01:32:20,432 --> 01:32:23,013
从技术上讲，你可以有任意多的参数


2522
01:32:23,103 --> 01:32:24,692
所以我可以在这里放另一个


2523
01:32:24,722 --> 01:32:25,322
年龄。


2524
01:32:25,622 --> 01:32:27,332
现在我要把它传递给


2525
01:32:27,362 --> 01:32:27,962
年龄


2526
01:32:27,992 --> 01:32:28,952
除了这些，


2527
01:32:29,252 --> 01:32:30,752
所以我要把它传递进来


2528
01:32:31,712 --> 01:32:32,433
并且


2529
01:32:32,613 --> 01:32:34,293
在这里过了一个年龄，


2530
01:32:35,733 --> 01:32:36,963
我要把它传递进来


2531
01:32:36,993 --> 01:32:37,863
字符串，


2532
01:32:39,003 --> 01:32:40,864
所以我们可以说hello name


2533
01:32:43,414 --> 01:32:44,434
你是


2534
01:32:46,384 --> 01:32:48,785
所以我传递了两段信息。


2535
01:32:49,055 --> 01:32:52,055
当我们运行这个程序时，它会调用这个函数，


2536
01:32:52,625 --> 01:32:55,625
它会同时使用这两种信息所以它是健康的


2537
01:32:55,654 --> 01:32:58,654
就像你三十五岁的你好史蒂夫，你已经七十岁了。


2538
01:32:59,104 --> 01:32:59,644
所以


2539
01:32:59,854 --> 01:33:00,724
本质上


2540
01:33:00,784 --> 01:33:06,004
写这一行代码就像hello一样打印出来


2541
01:33:06,394 --> 01:33:08,824
允许这个函数接收


2542
01:33:08,854 --> 01:33:11,554
两个参数，所以这个年龄的名字


2543
01:33:11,854 --> 01:33:13,444
根据这个年龄的名字，


2544
01:33:13,594 --> 01:33:15,003
这个函数会打印出来


2545
01:33:15,033 --> 01:33:16,503
大家好


2546
01:33:16,533 --> 01:33:17,193
不同的。


2547
01:33:17,434 --> 01:33:20,134
这就是使用函数的美妙之处


2548
01:33:20,404 --> 01:33:23,434
你可以把你想要的任何东西传递到一个函数中，例如，


2549
01:33:23,733 --> 01:33:25,144
我可以通过a


2550
01:33:25,204 --> 01:33:25,894
整数。


2551
01:33:25,954 --> 01:33:27,814
而不是为这个年龄而使用的字符串。


2552
01:33:28,324 --> 01:33:29,764
就像我可以传递一个数字。


2553
01:33:30,004 --> 01:33:32,435
这里唯一的不同之处是


2554
01:33:32,495 --> 01:33:34,115
把它转换成一个字符串，


2555
01:33:34,835 --> 01:33:35,856
但它会起作用。


2556
01:33:35,946 --> 01:33:36,816
同样的，


2557
01:33:37,686 --> 01:33:39,036
所以你可以通过alm


2558
01:33:39,966 --> 01:33:40,687
弦


2559
01:33:40,716 --> 01:33:41,946
数字金块


2560
01:33:41,976 --> 01:33:43,356
你可以通过数组


2561
01:33:43,716 --> 01:33:45,065
任何类型的数据


2562
01:33:45,095 --> 01:33:46,145
变成


2563
01:33:46,235 --> 01:33:47,585
函数，它会起作用


2564
01:33:47,615 --> 01:33:48,035
所以


2565
01:33:48,155 --> 01:33:49,865
你可以看到，我们得到了相同的结果。


2566
01:33:50,285 --> 01:33:53,165
这就是函数的基本原理


2567
01:33:53,225 --> 01:33:54,815
有了python，你就会知道


2568
01:33:54,845 --> 01:33:56,495
越来越多的功能，


2569
01:33:56,765 --> 01:34:03,515
一般来说，把代码分解成不同的函数是一个好主意所以无论何时你有一组代码


2570
01:34:03,785 --> 01:34:04,175
那是


2571
01:34:04,205 --> 01:34:06,514
设计用于执行特定的任务。


2572
01:34:06,814 --> 01:34:10,353
这通常是一个很好的候选函数


2573
01:34:14,193 --> 01:34:18,994
在本教程中，我想和你们讨论如何使用python中的return语句，


2574
01:34:19,054 --> 01:34:19,744
功能


2575
01:34:20,284 --> 01:34:22,234
其他的python函数基本上就是


2576
01:34:22,264 --> 01:34:23,434
收集


2577
01:34:23,463 --> 01:34:26,913
执行特定任务的python代码。


2578
01:34:27,333 --> 01:34:31,894
当我们想在我们的python程序中执行这个任务时我们可以调用


2579
01:34:32,134 --> 01:34:33,364
一个python函数


2580
01:34:33,844 --> 01:34:40,145
很多时候，当我们调用一个python函数时我们会调用它它会做它的事情然后我们继续这个程序。


2581
01:34:40,535 --> 01:34:44,375
但有时当我们调用一个函数时我们实际上会想要得到


2582
01:34:44,405 --> 01:34:45,455
信息


2583
01:34:45,484 --> 01:34:46,024
背面


2584
01:34:46,054 --> 01:34:47,165
从这个函数。


2585
01:34:47,555 --> 01:34:50,255
所以当我调用这个函数时


2586
01:34:50,285 --> 01:34:52,805
执行任务，我想执行所有的代码


2587
01:34:53,165 --> 01:34:54,125
然后我想要


2588
01:34:54,155 --> 01:34:55,745
给我一些

2589
01:34:55,775 --> 01:34:57,905
所以这可以是一个特定的值。


2590
01:34:58,205 --> 01:35:00,785
它可以告诉我任务是如何进行的


2591
01:35:01,055 --> 01:35:01,745
基本上


2592
01:35:01,805 --> 01:35:02,075
那


2593
01:35:02,105 --> 01:35:04,595
函数可以像嘿，


2594
01:35:04,775 --> 01:35:05,945
这里有一些信息。


2595
01:35:06,305 --> 01:35:09,305
这就是return关键字可以让我们做的


2596
01:35:09,695 --> 01:35:11,766
返回关键字基本上可以允许


2597
01:35:11,795 --> 01:35:14,675
python 2返回

2598
01:35:14,765 --> 01:35:15,365
一个函数。


2599
01:35:15,965 --> 01:35:17,375
所以我要给你们展示我们是如何做到的


2600
01:35:17,405 --> 01:35:20,464
这样做，我想创建一个非常简单的函数。


2601
01:35:20,794 --> 01:35:22,174
它将会


2602
01:35:22,204 --> 01:35:28,654
立方体一个数字，所以当我们古巴号的时候我们把它的功率增加到3所以如果我要去古巴


2603
01:35:28,984 --> 01:35:29,375
像


2604
01:35:29,404 --> 01:35:31,564
二人被提升为三


2605
01:35:31,894 --> 01:35:32,494
对，就是这样


2606
01:35:32,523 --> 01:35:33,693
非常基础的数学。


2607
01:35:34,144 --> 01:35:36,813
所以我们要做一个古巴数的函数


2608
01:35:36,843 --> 01:35:39,543
我将向你们展示如何使用返回语句


2609
01:35:39,573 --> 01:35:39,993
所以


2610
01:35:40,323 --> 01:35:42,363
我们要做的第一件事是做

2611
01:35:42,453 --> 01:35:43,323
我只是想说


2612
01:35:43,353 --> 01:35:43,923
死亡


2613
01:35:44,253 --> 01:35:44,883
问：


2614
01:35:44,943 --> 01:35:45,603
我们会给这个国家打电话


2615
01:35:45,633 --> 01:35:46,623
函数立方。


2616
01:35:47,283 --> 01:35:47,763
并且


2617
01:35:47,793 --> 01:35:52,022
在这里，我们可以指定这个函数将要使用的任何参数。


2618
01:35:52,292 --> 01:35:57,934
所以基本上，我们想要赋予这个函数的任何值所以我们要给它一个函数它将会是


2619
01:35:58,174 --> 01:36:00,304
一个数字，所以我把它叫做麻木。


2620
01:36:00,874 --> 01:36:02,284
然后在这里，我要


2621
01:36:02,434 --> 01:36:02,974
输入a


2622
01:36:03,003 --> 01:36:03,724
结肠


2623
01:36:04,444 --> 01:36:05,584
然后在下面，


2624
01:36:05,854 --> 01:36:07,354
我们可以输入任何代码


2625
01:36:07,384 --> 01:36:09,875
我们想要包含在这个函数里。


2626
01:36:10,294 --> 01:36:14,316
所以基本上这个函数就是要保留这个数字所以我们可以


2627
01:36:14,346 --> 01:36:15,545
使麻木


2628
01:36:15,875 --> 01:36:16,955
时间麻木


2629
01:36:18,485 --> 01:36:18,875
对的


2630
01:36:19,055 --> 01:36:20,345
这就给了我们


2631
01:36:20,405 --> 01:36:21,335
麻木的立方。


2632
01:36:21,396 --> 01:36:21,905
所以


2633
01:36:22,055 --> 01:36:23,166
这一切都很好。


2634
01:36:23,226 --> 01:36:24,996
如果我来到这里，我可以


2635
01:36:25,026 --> 01:36:28,956
执行这个函数，我可以把它叫做一个立方体。


2636
01:36:29,286 --> 01:36:31,236
为什么我们不把它传递给3。


2637
01:36:31,626 --> 01:36:33,486
所以我要把它传递给3


2638
01:36:33,906 --> 01:36:35,377
我要保存这个。


2639
01:36:36,457 --> 01:36:36,967
并且


2640
01:36:36,997 --> 01:36:38,617
现在让我们继续运行


2641
01:36:38,646 --> 01:36:39,606
这段代码，


2642
01:36:40,207 --> 01:36:41,557
我们在代码中


2643
01:36:43,146 --> 01:36:44,767
你会看到这里。


2644
01:36:45,307 --> 01:36:46,267
什么也没发生


2645
01:36:46,356 --> 01:36:48,217
所以没有打印出来


2646
01:36:48,607 --> 01:36:49,537
在我们的项目中


2647
01:36:49,567 --> 01:36:50,107
事实


2648
01:36:50,467 --> 01:36:52,387
当我们称这个立方体函数时


2649
01:36:52,417 --> 01:36:53,917
它什么都没做，


2650
01:36:54,427 --> 01:36:57,066
让我试着把它打印出来


2651
01:36:57,366 --> 01:37:00,696
它会给我们提供我们想要的信息


2652
01:37:01,146 --> 01:37:02,045
那么打印呢


2653
01:37:02,135 --> 01:37:03,095
将会打印


2654
01:37:03,125 --> 01:37:05,465
这个函数的值，我很厉害


2655
01:37:06,186 --> 01:37:08,676
我们往下看，它说没有。


2656
01:37:09,096 --> 01:37:10,686
所以当我打印出来的时候


2657
01:37:10,715 --> 01:37:13,475
这个函数的值没有告诉我


2658
01:37:14,105 --> 01:37:17,315
但实际上这个函数应该是q是数字。


2659
01:37:17,706 --> 01:37:18,125
并且


2660
01:37:18,155 --> 01:37:20,765
下面是我们如何使用返回语句和python


2661
01:37:20,795 --> 01:37:22,355
我可以到这里来，我可以说


2662
01:37:22,385 --> 01:37:23,195
返回


2663
01:37:23,885 --> 01:37:24,875
现在


2664
01:37:24,905 --> 01:37:29,135
python会把我们放在右边的任何值返回到右边。


2665
01:37:29,525 --> 01:37:32,975
所以当我调用这个立方体函数时我给它一个3


2666
01:37:33,665 --> 01:37:36,335
python会关闭它会执行这个函数


2667
01:37:36,365 --> 01:37:38,315
当它看到这个返回语句时


2668
01:37:38,345 --> 01:37:38,915
它会说


2669
01:37:38,945 --> 01:37:39,365
好的，


2670
01:37:39,665 --> 01:37:43,685
我想要给这个函数的任何调用赋值。


2671
01:37:43,805 --> 01:37:45,064
它会

2672
01:37:45,094 --> 01:37:45,994
这个值。


2673
01:37:46,474 --> 01:37:48,004
当我打印出来的时候


2674
01:37:48,034 --> 01:37:48,514
立方体


2675
01:37:48,543 --> 01:37:49,173
三


2676
01:37:49,563 --> 01:37:53,643
它应该打印出答案因为我们得到了答案


2677
01:37:53,913 --> 01:37:54,693
当我播放这个的时候


2678
01:37:54,723 --> 01:37:55,503
你会看到


2679
01:37:55,533 --> 01:37:56,343
在下面，


2680
01:37:56,673 --> 01:37:57,093
说


2681
01:37:57,123 --> 01:37:59,643
所以我们得到了正确的答案。


2682
01:37:59,883 --> 01:38:03,273
所以我可以用任意的立方体来做这个


2683
01:38:04,173 --> 01:38:05,104
在这一小时内


2684
01:38:05,374 --> 01:38:09,213
你可以看到我们不断得到正确的答案


2685
01:38:09,243 --> 01:38:09,603
所以


2686
01:38:09,632 --> 01:38:15,122
这是使用这个返回语句的基础它允许我们返回一个值


2687
01:38:15,152 --> 01:38:16,472
换句话

2688
01:38:16,712 --> 01:38:18,602
回到函数的调用。


2689
01:38:18,992 --> 01:38:24,001
我想再进一步说明一下这一点我将在这里创建一个变量


2690
01:38:24,091 --> 01:38:26,491
所以我要创建一个名为result的变量


2691
01:38:26,521 --> 01:38:27,662
我要把它设置好


2692
01:38:27,691 --> 01:38:28,651
等于


2693
01:38:29,762 --> 01:38:30,482
为了


2694
01:38:30,572 --> 01:38:33,092
这个变量的结果将会存储


2695
01:38:33,122 --> 01:38:34,142
价值


2696
01:38:34,382 --> 01:38:35,702
它会返回


2697
01:38:36,001 --> 01:38:37,921
从立方体函数开始


2698
01:38:38,071 --> 01:38:39,091
它不是在商店里


2699
01:38:39,121 --> 01:38:43,890
它将存储从执行该函数返回的值。


2700
01:38:44,250 --> 01:38:46,710
现在，如果我来到这里，打印出结果。


2701
01:38:47,250 --> 01:38:50,221
它实际上会再次变成64，因为


2702
01:38:50,251 --> 01:38:51,811
这就是它存储的值


2703
01:38:52,111 --> 01:38:54,721
所以这个返回语句可以很有用


2704
01:38:54,901 --> 01:38:56,941
从函数中获取信息，


2705
01:38:57,151 --> 01:38:57,871
我们可以使用


2706
01:38:57,901 --> 01:38:59,431
就像一个参数。


2707
01:38:59,701 --> 01:39:01,231
我想作为一个参数。


2708
01:39:01,441 --> 01:39:03,542
我们可以给函数提供信息


2709
01:39:03,841 --> 01:39:07,171
然后我们可以使用return语句获取信息


2710
01:39:07,201 --> 01:39:08,521
从一个函数返回。


2711
01:39:09,001 --> 01:39:11,102
我想再指出一件事


2712
01:39:11,432 --> 01:39:14,103
实际上我不能放任何代码。


2713
01:39:14,522 --> 01:39:18,722
在这个返回语句之后，如果我来到这里，试着像一个王子的陈述。


2714
01:39:19,352 --> 01:39:21,511
这实际上是行不通的


2715
01:39:21,541 --> 01:39:24,662
这是永远不会打印出来的如果我只是打印出来


2716
01:39:24,722 --> 01:39:25,712
代码在这里


2717
01:39:26,342 --> 01:39:28,112
当我们运行这个程序时。


2718
01:39:28,982 --> 01:39:30,633
它不会打印出来


2719
01:39:30,663 --> 01:39:31,232
代码


2720
01:39:31,562 --> 01:39:34,203
因为当我使用这个返回关键字时，


2721
01:39:34,473 --> 01:39:36,693
它使我们脱离了函数


2722
01:39:36,903 --> 01:39:39,483
python会执行它会执行

2723
01:39:39,693 --> 01:39:42,512
在函数中，每当它看到这个返回关键字。


2724
01:39:42,842 --> 01:39:47,133
它会被打断，我们将会完成所以我们将永远无法到达


2725
01:39:47,163 --> 01:39:48,212
这行代码。


2726
01:39:48,692 --> 01:39:52,592
这就是使用返回语句的基础，你可以返回


2727
01:39:52,622 --> 01:39:54,182
你想要的任何数据类型


2728
01:39:54,212 --> 01:39:58,023
我们可以很容易地返回，就像字符串或布尔值或数组一样。


2729
01:39:58,293 --> 01:40:00,543
不管你想要什么，你都可以返回。


2730
01:40:01,203 --> 01:40:05,073
很多情况下，很多情况下你会想要从


2731
01:40:05,133 --> 01:40:05,703
函数


2732
01:40:09,723 --> 01:40:12,243
在本教程中，我想和你们谈谈使用


2733
01:40:12,272 --> 01:40:14,133
如果是python中的语句。


2734
01:40:14,553 --> 01:40:14,853
现在


2735
01:40:14,913 --> 01:40:18,183
如果语句是python中的特殊结构


2736
01:40:18,212 --> 01:40:20,582
我们可以帮助我们的项目


2737
01:40:20,612 --> 01:40:21,062
制造


2738
01:40:21,092 --> 01:40:21,992
决定。


2739
01:40:22,352 --> 01:40:23,882
通过使用if语句


2740
01:40:23,912 --> 01:40:26,072
我可以执行某些代码


2741
01:40:26,102 --> 01:40:27,692
某些条件是正确的，


2742
01:40:27,962 --> 01:40:28,742
我可以执行


2743
01:40:28,772 --> 01:40:29,882
其他代码


2744
01:40:29,972 --> 01:40:31,171
其他条件是正确的。


2745
01:40:31,591 --> 01:40:35,402
所以基本上，如果语句允许我们的程序响应


2746
01:40:35,432 --> 01:40:36,032
到


2747
01:40:36,062 --> 01:40:37,621
它们的输入是这样的


2748
01:40:37,891 --> 01:40:40,681
取决于我们在程序中使用的数据


2749
01:40:41,011 --> 01:40:46,771
当某些数据是特定的值我们可以做某些事情时，程序将能够响应


2750
01:40:47,191 --> 01:40:48,782
当其他数据是，


2751
01:40:48,872 --> 01:40:49,441
其他值


2752
01:40:49,471 --> 01:40:50,461
你可以做其他的事情


2753
01:40:50,521 --> 01:40:50,731
你知道


2754
01:40:50,761 --> 01:40:52,321
你的程序本质上是


2755
01:40:52,351 --> 01:40:53,701
变得更聪明


2756
01:40:54,091 --> 01:40:55,531
实际上，如果语句


2757
01:40:55,561 --> 01:40:59,490
是我们人类每天都在处理的事情


2758
01:40:59,730 --> 01:41:04,740
你知道，当你一整天都在做的时候你总是在处理if语句所以我想要


2759
01:41:05,040 --> 01:41:10,949
给你们简单介绍一下if语句，我们会讨论一些常见的if语句，你们在日常生活中会看到。


2760
01:41:11,279 --> 01:41:14,791
现在我们来做一个非常棒的例子


2761
01:41:14,851 --> 01:41:15,511
当然可以


2762
01:41:15,541 --> 01:41:17,312
如果陈述可以为我们做些什么呢？


2763
01:41:17,671 --> 01:41:18,211
所以


2764
01:41:18,421 --> 01:41:21,482
在我的文本编辑器中，我有一个小文本文件


2765
01:41:21,512 --> 01:41:23,583
在这里我写了一堆


2766
01:41:23,612 --> 01:41:24,362
if语句


2767
01:41:24,392 --> 01:41:24,722
那


2768
01:41:24,992 --> 01:41:30,123
很多人每天都会遇到这样的情况这是第一个我醒来的时候


2769
01:41:30,873 --> 01:41:31,982
如果我饿了。


2770
01:41:32,583 --> 01:41:33,692
我吃早餐。


2771
01:41:34,112 --> 01:41:36,663
让我们把这个分解一下上面写着


2772
01:41:38,042 --> 01:41:39,272
这是一个条件。


2773
01:41:39,692 --> 01:41:40,052
对的


2774
01:41:40,412 --> 01:41:42,182
这是正确的


2775
01:41:42,211 --> 01:41:43,501
或者它会是假的，


2776
01:41:44,281 --> 01:41:45,361
如果这是真的，


2777
01:41:45,691 --> 01:41:47,042
我要继续


2778
01:41:47,222 --> 01:41:48,632
吃早餐


2779
01:41:48,932 --> 01:41:50,342
如果是假的


2780
01:41:50,612 --> 01:41:53,342
在皮肤下，跳过这里的任何东西，继续前进，


2781
01:41:53,762 --> 01:41:54,422
写出来


2782
01:41:54,452 --> 01:41:55,742
if语句的基础知识。


2783
01:41:55,832 --> 01:41:56,972
我们有一个条件


2784
01:41:57,302 --> 01:41:57,992
在这种情况下


2785
01:41:59,102 --> 01:42:00,452
如果条件为真，


2786
01:42:00,692 --> 01:42:02,522
然后我们做这个动作


2787
01:42:02,552 --> 01:42:03,482
我们吃早餐。


2788
01:42:03,812 --> 01:42:05,612
否则我们就跳过它。


2789
01:42:06,452 --> 01:42:07,742
下面这里还有一个。


2790
01:42:07,982 --> 01:42:08,672
上面写着


2791
01:42:08,732 --> 01:42:09,902
我离开了我的家。


2792
01:42:10,532 --> 01:42:11,612
如果是阴天。


2793
01:42:12,182 --> 01:42:13,232
我带了一把雨伞。


2794
01:42:13,652 --> 01:42:14,612
否则


2795
01:42:14,702 --> 01:42:15,152
我带来


2796
01:42:15,182 --> 01:42:16,052
太阳镜。


2797
01:42:16,382 --> 01:42:21,812
所以这个比我们刚才看到的要复杂一点你会发现我们的条件是正确的


2798
01:42:23,372 --> 01:42:24,752
如果这个条件成立


2799
01:42:24,782 --> 01:42:26,072
我们要带雨伞。


2800
01:42:26,672 --> 01:42:27,032
但是


2801
01:42:27,092 --> 01:42:29,462
在这种情况下，如果条件为假


2802
01:42:29,492 --> 01:42:31,742
我们还想做一些其他的事情


2803
01:42:32,012 --> 01:42:35,733
所以在这里，如果这个条件是假的，我们就继续。


2804
01:42:36,033 --> 01:42:38,223
但是如果这个条件是假的


2805
01:42:38,252 --> 01:42:39,693
然后我们继续


2806
01:42:39,753 --> 01:42:40,593
太阳镜


2807
01:42:40,623 --> 01:42:41,013
所以


2808
01:42:41,312 --> 01:42:44,852
这是if语句的另一个例子它更复杂一些。


2809
01:42:45,182 --> 01:42:49,682
最后，我还有一个，这个更复杂，它说我在一家餐馆。


2810
01:42:50,222 --> 01:42:51,392
如果我想要我。


2811
01:42:51,572 --> 01:42:52,651
我点了一份牛排。


2812
01:42:54,751 --> 01:42:55,892
我们点了牛排，


2813
01:42:56,372 --> 01:42:58,292
但是如果这个条件是假的，


2814
01:42:58,352 --> 01:43:00,962
然后我们继续，我们会检查


2815
01:43:00,992 --> 01:43:02,012
另一个条件。


2816
01:43:02,312 --> 01:43:02,942
所以我想说


2817
01:43:02,972 --> 01:43:03,751
否则


2818
01:43:03,781 --> 01:43:05,041
如果我想吃意大利面。


2819
01:43:05,371 --> 01:43:07,021
我点了意大利面和肉丸子。


2820
01:43:07,471 --> 01:43:09,062
这是另一种情况。


2821
01:43:09,602 --> 01:43:11,941
如果这个条件为真，我们就得到意大利面，


2822
01:43:12,122 --> 01:43:13,381
如果不是真的


2823
01:43:13,411 --> 01:43:16,021
最后，我们继续往下移动


2824
01:43:16,231 --> 01:43:19,292
这是默认的顺序


2825
01:43:19,861 --> 01:43:21,751
这三个if语句都是


2826
01:43:21,812 --> 01:43:22,891
有效的if语句


2827
01:43:22,921 --> 01:43:23,431
只是


2828
01:43:23,460 --> 01:43:26,641
随着列表的深入，它们变得越来越复杂


2829
01:43:26,670 --> 01:43:27,150
所以


2830
01:43:27,420 --> 01:43:28,200
希望这是


2831
01:43:28,230 --> 01:43:28,560
你知道


2832
01:43:28,590 --> 01:43:32,730
你可以把你的脑袋绕一圈，如果我们说的是条件的话。


2833
01:43:33,120 --> 01:43:35,790
如果这些条件是真的我们就会做一些事情


2834
01:43:36,030 --> 01:43:38,101
这些条件都是假的我们可以做


2835
01:43:38,130 --> 01:43:38,851
其他的事情。


2836
01:43:38,911 --> 01:43:39,301
或者


2837
01:43:39,331 --> 01:43:39,960
我们可以检查


2838
01:43:39,990 --> 01:43:41,130
其他条件


2839
01:43:41,250 --> 01:43:45,362
不是这样，让我们转到我们的python文件，我们将开始编写一些实际的python。


2840
01:43:46,172 --> 01:43:48,631
在我的app。python文件中。


2841
01:43:49,201 --> 01:43:50,372
我想创建一个


2842
01:43:50,401 --> 01:43:51,091
if语句


2843
01:43:51,121 --> 01:43:54,541
我将在本教程中向你们展示一个非常基本的if语句。


2844
01:43:54,781 --> 01:43:57,812
然后在下一个维多利亚我们会看到一些更先进的


2845
01:43:57,841 --> 01:43:58,501
如果是陈述。


2846
01:43:58,801 --> 01:44:00,752
所以我要做的是创建


2847
01:44:00,782 --> 01:44:02,582
一个恃强凌弱的人。


2848
01:44:03,001 --> 01:44:07,742
所以我要创建一个布尔变量来存储用户是否是男性。


2849
01:44:07,892 --> 01:44:09,002
所以它会被调用


2850
01:44:09,032 --> 01:44:10,802
被强调的邮件


2851
01:44:11,192 --> 01:44:13,651
我要把它设为true


2852
01:44:13,681 --> 01:44:14,761
因为我是男的。


2853
01:44:15,241 --> 01:44:20,251
所以我们有这个布尔变量现在我们还没有设为真。


2854
01:44:21,301 --> 01:44:22,711
我可以用一个


2855
01:44:22,741 --> 01:44:29,250
如果语句要检查这个变量的值是什么如果它是真的，我可以做一些事情


2856
01:44:29,610 --> 01:44:32,191
如果我想使用if语句我要做的就是输入


2857
01:44:32,251 --> 01:44:32,791
如果。


2858
01:44:33,391 --> 01:44:33,991
然后


2859
01:44:34,021 --> 01:44:35,191
我只需要输入输出


2860
01:44:35,221 --> 01:44:36,391
一个条件。


2861
01:44:36,691 --> 01:44:37,141
所以


2862
01:44:37,171 --> 01:44:39,301
基本上，我需要输入


2863
01:44:39,781 --> 01:44:42,061
这是真的或假的


2864
01:44:42,091 --> 01:44:42,601
喜欢


2865
01:44:42,630 --> 01:44:43,740
例如


2866
01:44:43,770 --> 01:44:45,870
我们指定的另一个页面


2867
01:44:46,170 --> 01:44:48,390
如果我饿了，或者是阴天。


2868
01:44:48,570 --> 01:44:50,160
这里我们要检查一下


2869
01:44:50,189 --> 01:44:50,669
如果


2870
01:44:51,060 --> 01:44:51,989
是男性。


2871
01:44:52,379 --> 01:44:53,489
换句话说


2872
01:44:53,519 --> 01:44:55,169
如果这个人

2873
01:44:55,439 --> 01:44:57,060
记住，这必须是a


2874
01:44:57,089 --> 01:44:57,419
湖


2875
01:44:57,449 --> 01:45:01,409
它必须能够被还原成一个真或假的值。


2876
01:45:01,649 --> 01:45:02,579
在我们的案例中


2877
01:45:02,639 --> 01:45:04,649
它使用布尔值的地方，因为它就像


2878
01:45:04,679 --> 01:45:06,029
我们能做的最简单的事。


2879
01:45:06,989 --> 01:45:07,439
我说


2880
01:45:07,858 --> 01:45:09,059
我指定了我的


2881
01:45:09,088 --> 01:45:10,769
真或假条件。


2882
01:45:11,429 --> 01:45:12,989
现在我只是输入一个冒号。


2883
01:45:13,619 --> 01:45:14,099
并且


2884
01:45:14,129 --> 01:45:16,439
我现在要做的是画一条新线。


2885
01:45:16,739 --> 01:45:17,459
所以


2886
01:45:17,759 --> 01:45:21,119
我在这个下面放上缩进的任何东西


2887
01:45:21,628 --> 01:45:23,249
实际上会是


2888
01:45:23,339 --> 01:45:26,219
当条件为真时就执行，所以我可以


2889
01:45:26,279 --> 01:45:26,879
打印


2890
01:45:27,539 --> 01:45:29,309
下面我可以把它放在下面


2891
01:45:29,789 --> 01:45:30,809
你是个男人。


2892
01:45:32,249 --> 01:45:35,220
现在你会看到运行这个程序时会发生什么。


2893
01:45:35,370 --> 01:45:38,970
它会下降到这里，它会说你是一个雄性。


2894
01:45:39,270 --> 01:45:41,940
但是如果我把他的邮件改成了假


2895
01:45:41,970 --> 01:45:44,669
所以不是这个是真的，我只是把它变成假的。


2896
01:45:44,819 --> 01:45:46,499
突然间，它就不会发生了


2897
01:45:46,528 --> 01:45:47,608
打印任何东西。


2898
01:45:47,789 --> 01:45:49,739
所以这里是空的。


2899
01:45:50,039 --> 01:45:52,559
这是因为这个条件不是


2900
01:45:52,588 --> 01:45:53,128
是的。


2901
01:45:53,369 --> 01:45:55,738
所以我在下面放的任何东西


2902
01:45:56,038 --> 01:45:57,568
如果声明


2903
01:45:57,778 --> 01:45:59,788
它有一个缩进


2904
01:46:00,088 --> 01:46:02,458
将在if语句的时候执行


2905
01:46:02,487 --> 01:46:03,447
是真的。


2906
01:46:03,807 --> 01:46:06,357
我们还可以使用另一个关键字


2907
01:46:06,387 --> 01:46:07,438
被调用的python


2908
01:46:07,498 --> 01:46:08,098
其他的


2909
01:46:08,338 --> 01:46:10,408
爱丽丝基本上会像


2910
01:46:10,468 --> 01:46:11,938
否则你会记得，


2911
01:46:12,147 --> 01:46:13,138
在我们说


2912
01:46:13,408 --> 01:46:14,608
如果是阴天。


2913
01:46:14,788 --> 01:46:15,988
我带把伞，


2914
01:46:16,048 --> 01:46:17,218
否则


2915
01:46:17,818 --> 01:46:20,699
我会带着太阳镜这将会是我们的


2916
01:46:20,729 --> 01:46:22,139
所以我可以在下面说。


2917
01:46:23,489 --> 01:46:24,059
现在


2918
01:46:24,088 --> 01:46:26,188
任何我放在下面的东西


2919
01:46:26,309 --> 01:46:27,539
会在什么时候打印出来


2920
01:46:27,569 --> 01:46:28,259
那个条件


2921
01:46:28,289 --> 01:46:28,829
不确定


2922
01:46:28,858 --> 01:46:29,999
我们只要把它放在


2923
01:46:30,358 --> 01:46:31,889
你不是男人。


2924
01:46:33,628 --> 01:46:37,139
我们可以为这个变量覆盖这两种情况。


2925
01:46:37,199 --> 01:46:39,479
如果这是假的，我们可以掩盖这种情况。


2926
01:46:39,719 --> 01:46:40,439
它说


2927
01:46:41,999 --> 01:46:43,049
如果这是真的


2928
01:46:44,039 --> 01:46:46,680
我们也可以覆盖这种情况所以它会说


2929
01:46:46,709 --> 01:46:47,790
你是个男人，


2930
01:46:48,060 --> 01:46:49,050
这很酷。


2931
01:46:49,830 --> 01:46:53,130
但是我们也可以使这些更复杂


2932
01:46:53,160 --> 01:46:58,891
实际上，在我讲这个之前，你可以在if语句中输入任意数量的代码这样我就可以


2933
01:46:59,460 --> 01:47:01,410
如果我需要的话，会有几十行代码。


2934
01:47:02,310 --> 01:47:04,080
我只是给你们举个简单的例子


2935
01:47:04,110 --> 01:47:04,560
所以


2936
01:47:04,740 --> 01:47:08,221
为什么不让这个更复杂，我要添加另一个


2937
01:47:08,250 --> 01:47:09,750
变量混合


2938
01:47:09,780 --> 01:47:13,500
我要在这个混合中加入另一个你知道布尔属性。


2939
01:47:13,770 --> 01:47:15,210
我要再做一个变量


2940
01:47:15,240 --> 01:47:16,440
高


2941
01:47:16,830 --> 01:47:18,961
我们要把它设为true。


2942
01:47:19,801 --> 01:47:20,671
现在我有


2943
01:47:20,701 --> 01:47:22,891
两个变量在混合。


2944
01:47:23,221 --> 01:47:27,931
假设我想写一个if语句来检查这两个变量。


2945
01:47:28,201 --> 01:47:30,181
所以我可以写一个if语句


2946
01:47:30,271 --> 01:47:32,401
如果他们的邮件和他们的高或

2947
01:47:32,431 --> 01:47:34,321
如果他们是男性，他们就不会更

2948
01:47:34,501 --> 01:47:36,122
如果不是像他们那样高的邮件


2949
01:47:36,151 --> 01:47:37,622
我可以写出一堆


2950
01:47:37,682 --> 01:47:38,522
if语句


2951
01:47:38,732 --> 01:47:39,422
检查


2952
01:47:39,752 --> 01:47:42,211
这些变量的组合


2953
01:47:42,571 --> 01:47:45,451
所以我的方法是使用其中一种


2954
01:47:45,480 --> 01:47:46,590
两个关键词


2955
01:47:46,620 --> 01:47:47,040
所以


2956
01:47:47,220 --> 01:47:49,470
我想给大家展示的第一个关键字是


2957
01:47:49,500 --> 01:47:50,460
或者关键字。


2958
01:47:50,850 --> 01:47:52,500
所以我可以到这里来，我可以说


2959
01:47:52,529 --> 01:47:52,859
如果


2960
01:47:52,889 --> 01:47:53,759
是男性


2961
01:47:54,239 --> 01:47:54,959
或者


2962
01:47:55,529 --> 01:47:56,099
是


2963
01:47:56,159 --> 01:47:56,849
下划线


2964
01:47:56,879 --> 01:47:57,449
高。


2965
01:47:57,989 --> 01:48:02,459
这基本上是说如果这个人不

2966
01:48:03,809 --> 01:48:05,039
如果他们个子高，


2967
01:48:05,429 --> 01:48:07,829
然后我们想做点什么


2968
01:48:08,459 --> 01:48:11,880
只有当这些值中的一个值时才会成立


2969
01:48:11,940 --> 01:48:12,570
是真的


2970
01:48:12,600 --> 01:48:15,209
当其中一个或两个值为真时


2971
01:48:16,140 --> 01:48:21,359
所以在这里我们可以把你换成男性我们可以把你放在男性的位置


2972
01:48:21,419 --> 01:48:22,590
或高或高


2973
01:48:22,650 --> 01:48:23,070
两种


2974
01:48:23,100 --> 01:48:23,939
这将会

2975
01:48:23,969 --> 01:48:25,139
更合适。


2976
01:48:25,589 --> 01:48:28,260
然后在下面我们会说，你

2977
01:48:30,150 --> 01:48:31,230
都不

2978
01:48:31,260 --> 01:48:31,860
也不

2979
01:48:31,920 --> 01:48:32,460
高的


2980
01:48:32,820 --> 01:48:33,930
那是因为


2981
01:48:34,110 --> 01:48:36,660
如果我们在这个else中执行代码


2982
01:48:36,689 --> 01:48:37,559
这意味着


2983
01:48:37,589 --> 01:48:39,719
这两个都是假的


2984
01:48:39,989 --> 01:48:40,829
我想说的是


2985
01:48:40,858 --> 01:48:42,868
如果他们是男性或他们的身高，


2986
01:48:43,468 --> 01:48:45,178
我们要执行任何不在这里的东西


2987
01:48:45,928 --> 01:48:46,648
否则


2988
01:48:47,188 --> 01:48:48,178
他们都不是男性


2989
01:48:48,208 --> 01:48:50,608
也不高，我们只需要在下面执行这个


2990
01:48:50,878 --> 01:48:52,588
这一切都是痛苦的


2991
01:48:52,618 --> 01:48:53,458
点击播放。


2992
01:48:53,878 --> 01:48:58,259
这些都是真的，所以它会说你是男性，或者高，或者两者都是。


2993
01:48:58,619 --> 01:49:00,809
如果我把其中一个设为假


2994
01:49:01,648 --> 01:49:03,149
让我们来设置他的雄鹰


2995
01:49:03,179 --> 01:49:03,809
假的。


2996
01:49:04,139 --> 01:49:04,799
现在，


2997
01:49:05,039 --> 01:49:08,340
它仍然会说你是一个男人或高个子，或者两者都是。


2998
01:49:08,760 --> 01:49:11,040
但如果我令它们都等于false。


2999
01:49:11,700 --> 01:49:13,080
现在它将会


3000
01:49:13,110 --> 01:49:14,700
假设你不是男性


3001
01:49:14,760 --> 01:49:15,720
也不高。


3002
01:49:16,080 --> 01:49:16,530
所以


3003
01:49:16,560 --> 01:49:17,880
这就是基本原理


3004
01:49:17,910 --> 01:49:19,860
使用or运算符。


3005
01:49:20,280 --> 01:49:22,710
还有一个我们可以使用的运算符叫做


3006
01:49:22,740 --> 01:49:23,280
并且


3007
01:49:23,820 --> 01:49:24,750
基本上是a


3008
01:49:24,779 --> 01:49:25,529
类似于


3009
01:49:25,559 --> 01:49:26,519
或接受


3010
01:49:26,549 --> 01:49:27,569
这两种情况


3011
01:49:27,599 --> 01:49:29,429
条件必须是正确的


3012
01:49:29,699 --> 01:49:30,959
这基本上是说


3013
01:49:30,989 --> 01:49:32,639
如果这个人是男性，


3014
01:49:33,539 --> 01:49:34,859
他们也很高，


3015
01:49:35,069 --> 01:49:39,149
然后我们将执行这里的任何内容这样我们就可以改变文本了


3016
01:49:39,179 --> 01:49:39,869
说


3017
01:49:40,019 --> 01:49:40,739
你是


3018
01:49:40,769 --> 01:49:41,338
a


3019
01:49:41,579 --> 01:49:42,539
现在高


3020
01:49:42,568 --> 01:49:44,279
因为我们知道一个事实


3021
01:49:44,789 --> 01:49:47,849
如果这是被执行的，那是男性和高的。


3022
01:49:48,269 --> 01:49:49,499
我们也可以改变


3023
01:49:49,529 --> 01:49:51,149
下面这个print语句，


3024
01:49:51,330 --> 01:49:53,250
这可能会说

3025
01:49:53,430 --> 01:49:53,939
或者


3026
01:49:53,969 --> 01:49:56,369
不是邮件，也不是高，


3027
01:49:56,699 --> 01:49:57,539
或者两者都有。


3028
01:49:57,629 --> 01:49:58,109
所以


3029
01:49:58,979 --> 01:50:00,689
你可以看到它基本上只是

3030
01:50:00,869 --> 01:50:01,709
你不是


3031
01:50:01,739 --> 01:50:04,499
不是其中之一，也不是两者都不是


3032
01:50:05,909 --> 01:50:07,019
我们可以播放按钮


3033
01:50:07,048 --> 01:50:09,238
你们会看到因为它们都是假的


3034
01:50:09,268 --> 01:50:12,629
它会说你要么不是邮件，要么不是高，要么两者兼有。


3035
01:50:12,869 --> 01:50:14,279
但是如果我把它们都做了


3036
01:50:14,309 --> 01:50:15,119
是的，


3037
01:50:15,628 --> 01:50:16,769
现在它会说


3038
01:50:16,798 --> 01:50:18,718
你是个高个子男人。


3039
01:50:20,428 --> 01:50:22,889
如果我要让其中一个更快，让我们来做


3040
01:50:22,918 --> 01:50:24,479
高是假的。


3041
01:50:24,659 --> 01:50:29,549
现在它不会执行第一个print语句它会执行else里面的那个，


3042
01:50:29,789 --> 01:50:31,169
所以说你要么


3043
01:50:31,199 --> 01:50:32,939
邮件是不可容忍的。


3044
01:50:33,838 --> 01:50:35,039
这是最基本的


3045
01:50:35,068 --> 01:50:36,059
或者


3046
01:50:36,088 --> 01:50:36,688
你知道


3047
01:50:36,718 --> 01:50:39,599
当你使用if语句时，你会用到很多，


3048
01:50:40,019 --> 01:50:41,729
但实际上还有一个


3049
01:50:41,938 --> 01:50:45,179
我们可以做的事情我们可以添加一些条件


3050
01:50:45,209 --> 01:50:46,679
在这里，我在检查


3051
01:50:46,919 --> 01:50:48,750
如果他们的邮件和他们的高，


3052
01:50:49,110 --> 01:50:52,650
但是如果我想检查他们的邮件是不是很高


3053
01:50:52,680 --> 01:50:54,510
所以他们就像一个矮个子男人


3054
01:50:54,930 --> 01:50:56,160
我可以用另一个


3055
01:50:56,190 --> 01:50:57,720
python中的关键字


3056
01:50:57,780 --> 01:50:58,260
呼叫


3057
01:50:58,560 --> 01:50:59,310
else f


3058
01:50:59,790 --> 01:51:01,020
或者是打印出来的


3059
01:51:01,050 --> 01:51:01,530
是的


3060
01:51:01,560 --> 01:51:02,070
我是，


3061
01:51:02,340 --> 01:51:03,690
它代表lcds。


3062
01:51:04,080 --> 01:51:06,960
在这之后，我们可以放另一个条件


3063
01:51:07,320 --> 01:51:09,360
在这里，我要检查他们是否


3064
01:51:09,450 --> 01:51:11,371
男性和他们不高，


3065
01:51:11,880 --> 01:51:13,140
所以我要说的是


3066
01:51:13,350 --> 01:51:13,830
市长


3067
01:51:13,859 --> 01:51:14,669
伊斯梅尔，


3068
01:51:15,449 --> 01:51:16,079
并且


3069
01:51:16,169 --> 01:51:17,249
现在我可以输入


3070
01:51:17,279 --> 01:51:18,419
不高。


3071
01:51:18,479 --> 01:51:20,100
我的方法是说


3072
01:51:20,129 --> 01:51:20,790
不是


3073
01:51:21,030 --> 01:51:21,150
一


3074
01:51:21,180 --> 01:51:22,590
开闭括号


3075
01:51:22,770 --> 01:51:23,250
说


3076
01:51:23,280 --> 01:51:24,240
高


3077
01:51:24,600 --> 01:51:27,089
基本上，当我使用这个函数时，


3078
01:51:27,270 --> 01:51:28,650
它会抵消


3079
01:51:28,680 --> 01:51:31,679
不管这里是什么，如果这是真的，


3080
01:51:31,919 --> 01:51:35,489
它会使它为假，如果这是假的，它就会使它成立。


3081
01:51:35,789 --> 01:51:38,429
所以基本上这就能告诉我们他们的身

3082
01:51:39,659 --> 01:51:41,580
现在我要用一个冒号


3083
01:51:41,609 --> 01:51:42,599
在下面


3084
01:51:43,049 --> 01:51:47,819
在这里，我们基本上只需要输入我们想要发生的任何代码


3085
01:51:48,060 --> 01:51:49,529
当这个条件为真时


3086
01:51:50,309 --> 01:51:52,290
下面我们可以打印出来


3087
01:51:53,549 --> 01:51:55,229
你很矮


3088
01:51:55,259 --> 01:51:55,919
男，


3089
01:51:56,519 --> 01:51:57,059
并且


3090
01:51:57,269 --> 01:52:03,059
实际上还有一种情况我们想要检查如果它们不是邮件和它们的高，


3091
01:52:03,329 --> 01:52:04,919
所以我们可以再做一个


3092
01:52:04,979 --> 01:52:05,759
lcs。


3093
01:52:06,749 --> 01:52:08,489
我要复制这个家伙


3094
01:52:08,879 --> 01:52:10,320
我们把它粘贴到这里。


3095
01:52:11,070 --> 01:52:12,750
所以我想说，


3096
01:52:13,230 --> 01:52:13,771
如果


3097
01:52:14,161 --> 01:52:14,940
不，


3098
01:52:15,090 --> 01:52:15,900
是男性


3099
01:52:18,630 --> 01:52:19,560
他高大，


3100
01:52:19,920 --> 01:52:22,110
现在我们来看看他们的邮件


3101
01:52:23,250 --> 01:52:25,919
不是现在，也不是他们的高所以我们可以说


3102
01:52:26,250 --> 01:52:26,850
你是


3103
01:52:26,879 --> 01:52:27,389
a


3104
01:52:28,769 --> 01:52:29,759
不是


3105
01:52:30,029 --> 01:52:30,539
男


3106
01:52:30,899 --> 01:52:31,859
但是很高。


3107
01:52:32,369 --> 01:52:32,969
所以


3108
01:52:33,029 --> 01:52:34,619
本质上，我们有一个


3109
01:52:34,648 --> 01:52:36,059
如果这个语句要覆盖


3110
01:52:36,088 --> 01:52:37,679
每一种情况


3111
01:52:37,949 --> 01:52:39,688
对于这两个变量


3112
01:52:40,019 --> 01:52:43,438
在这些变量的两个值的每一个情况下


3113
01:52:43,468 --> 01:52:45,778
我们将能够打印出一些东西


3114
01:52:46,019 --> 01:52:47,669
如果我是说这两个都是真的


3115
01:52:48,089 --> 01:52:49,500
它基本上会告诉我们。


3116
01:52:49,589 --> 01:52:51,000
你是个高个子男人


3117
01:52:51,419 --> 01:52:52,049
如果我做了


3118
01:52:52,109 --> 01:52:53,669
是假的


3119
01:52:54,060 --> 01:52:55,379
它会告诉我们。


3120
01:52:55,949 --> 01:52:57,929
你不是一个男人的黄油


3121
01:52:58,409 --> 01:53:00,359
如果我做的是真的


3122
01:53:01,349 --> 01:53:03,209
而且是高假，


3123
01:53:04,499 --> 01:53:05,129
然后


3124
01:53:05,219 --> 01:53:07,079
它会告诉我们你是一个矮个子男人


3125
01:53:07,409 --> 01:53:09,538
如果我把这两个都做错了


3126
01:53:10,288 --> 01:53:11,548
它会告诉我们


3127
01:53:11,608 --> 01:53:13,018
你不是


3128
01:53:13,198 --> 01:53:16,678
男性或不高两者实际上我们需要改变这一点所以这应该说


3129
01:53:17,848 --> 01:53:19,918
你不是男性


3130
01:53:19,978 --> 01:53:23,068
而不是很高所以这是一个更好的打印输出


3131
01:53:23,608 --> 01:53:24,868
在这种情况下


3132
01:53:25,288 --> 01:53:26,968
你基本上可以看到我们如何使用


3133
01:53:27,028 --> 01:53:27,718
如果


3134
01:53:27,868 --> 01:53:28,798
奥索的


3135
01:53:28,828 --> 01:53:29,278
并且


3136
01:53:29,308 --> 01:53:30,897
其他的


3137
01:53:31,527 --> 01:53:33,267
我是如何制定决策的


3138
01:53:33,477 --> 01:53:34,768
并真正做出回应


3139
01:53:34,797 --> 01:53:36,657
对于我们程序中的不同数据。


3140
01:53:36,957 --> 01:53:40,167
所以无法对每一个组合做出反应


3141
01:53:40,497 --> 01:53:42,207
这两个值的值


3142
01:53:42,236 --> 01:53:44,307
变量，这很酷


3143
01:53:44,727 --> 01:53:48,057
在这个例子中，我们使用的是简单的布尔变量


3144
01:53:48,086 --> 01:53:49,646
但是在下一个教程中，


3145
01:53:49,946 --> 01:53:54,326
我将向你们展示如何使用所谓的比较运算符。


3146
01:53:54,566 --> 01:53:57,685
所以我们可以比较两个数字或两个字符串


3147
01:53:57,955 --> 01:54:00,175
我们可以用这些条件


3148
01:54:00,205 --> 01:54:00,505
但是


3149
01:54:00,685 --> 01:54:04,165
现在我认为这是对if语句的一个很好的介绍。


3150
01:54:04,555 --> 01:54:06,565
下一讲再见，


3151
01:54:11,036 --> 01:54:13,525
在本教程中，我们将进一步讨论


3152
01:54:13,555 --> 01:54:14,425
if语句


3153
01:54:14,455 --> 01:54:15,416
在python中。


3154
01:54:15,746 --> 01:54:19,376
更具体地说，我们将会考虑使用比较


3155
01:54:19,706 --> 01:54:21,416
在我们的if语句中


3156
01:54:21,626 --> 01:54:23,096
如果你跟随这门课


3157
01:54:23,126 --> 01:54:24,836
在上一篇教程中，


3158
01:54:24,896 --> 01:54:26,096
我跟你们说过


3159
01:54:26,246 --> 01:54:30,416
仅仅是if语句的基础我们使用了几个不同的布尔变量


3160
01:54:30,686 --> 01:54:34,736
根据这些金块的日记我们可以做一些事情


3161
01:54:35,156 --> 01:54:40,677
在本教程中，我们将讨论另一种使用if语句的方法，如果是比较的话，


3162
01:54:41,007 --> 01:54:44,816
而不是仅仅使用布尔值我们可以比较


3163
01:54:44,966 --> 01:54:48,026
不同的值，我可以比较几个数字


3164
01:54:48,056 --> 01:54:49,556
比较几个字符串


3165
01:54:49,976 --> 01:54:53,606
根据这些比较的结果我们可以做


3166
01:54:53,636 --> 01:54:54,836
某些事情


3167
01:54:55,286 --> 01:55:00,747
这将会非常酷这将会让你们完全理解如果语句是什么你可以做什么


3168
01:55:01,347 --> 01:55:03,566
对于本教程，我想要创建


3169
01:55:03,596 --> 01:55:04,616
一条巨蟒


3170
01:55:04,646 --> 01:55:05,306
功能


3171
01:55:05,696 --> 01:55:07,497
这个函数将会


3172
01:55:07,526 --> 01:55:10,886
给我们输入的最大数字


3173
01:55:11,276 --> 01:55:14,486
这个函数将取三个参数作为输入，


3174
01:55:14,726 --> 01:55:15,716
它会打印出来


3175
01:55:15,746 --> 01:55:16,196
外出


3176
01:55:16,466 --> 01:55:16,976
那


3177
01:55:17,036 --> 01:55:17,576
最大的


3178
01:55:17,606 --> 01:55:19,196
我们给它的数字


3179
01:55:19,886 --> 01:55:21,896
让我们来创建这个函数，我想说，


3180
01:55:22,136 --> 01:55:22,796
死亡。


3181
01:55:23,486 --> 01:55:25,017
我把它叫做max


3182
01:55:25,047 --> 01:55:25,677
麻木的


3183
01:55:26,247 --> 01:55:26,727
并且


3184
01:55:26,907 --> 01:55:32,036
在这些圆括号里，我要指定我想要三个参数作为输入。


3185
01:55:32,336 --> 01:55:33,086
有人说


3186
01:55:33,116 --> 01:55:33,926
第一，


3187
01:55:34,076 --> 01:55:36,146
第二和第三。


3188
01:55:36,956 --> 01:55:37,646
基本上


3189
01:55:37,675 --> 01:55:39,595
我们传递了三个数字


3190
01:55:39,625 --> 01:55:40,825
这个函数会


3191
01:55:40,885 --> 01:55:41,875
回来。


3192
01:55:42,955 --> 01:55:43,825
这三个。


3193
01:55:44,275 --> 01:55:47,516
所以为了算出这些数字中哪一个是

3194
01:55:47,545 --> 01:55:48,716
我们要用一个


3195
01:55:48,776 --> 01:55:49,496
if语句。


3196
01:55:49,826 --> 01:55:50,696
所以我可以说


3197
01:55:50,756 --> 01:55:51,296
如果。


3198
01:55:52,166 --> 01:55:54,056
在这里我需要指定


3199
01:55:54,085 --> 01:55:55,105
一个条件。


3200
01:55:55,226 --> 01:55:57,596
所以我需要把它设为真或假


3201
01:55:57,625 --> 01:55:58,286
价值。


3202
01:55:58,496 --> 01:56:03,535
所以我们实际上可以做的是我们可以比较这些不同的数字

3203
01:56:03,835 --> 01:56:04,735
num一


3204
01:56:05,335 --> 01:56:07,225
大于或等于


3205
01:56:07,495 --> 01:56:07,885
数


3206
01:56:07,915 --> 01:56:08,395
第二，


3207
01:56:09,745 --> 01:56:10,465
并且


3208
01:56:10,975 --> 01:56:11,875
第一


3209
01:56:13,706 --> 01:56:14,815
麻木三。


3210
01:56:15,565 --> 01:56:17,545
所以基本上我在这里所做的


3211
01:56:17,635 --> 01:56:20,456
我是在比较这些不同的数字所以我想说


3212
01:56:20,846 --> 01:56:23,516
第一个数字大于或等于第二个数字


3213
01:56:24,206 --> 01:56:25,886
这是一个比较


3214
01:56:26,126 --> 01:56:27,146
当你想到它的时候


3215
01:56:27,267 --> 01:56:31,917
当我们比较这两个数字时我们最终会得到一个真值或假值


3216
01:56:32,157 --> 01:56:32,577
写


3217
01:56:32,667 --> 01:56:36,267
num 1要么大于等于要么等于麻木，要么它不是


3218
01:56:36,297 --> 01:56:37,946
它实际上是一个布尔值


3219
01:56:37,976 --> 01:56:38,426
价值


3220
01:56:38,456 --> 01:56:39,566
权利是正确的


3221
01:56:39,807 --> 01:56:40,767
或者它是假的。


3222
01:56:40,917 --> 01:56:42,207
这里也是一样。


3223
01:56:42,477 --> 01:56:44,426
这种比较的结果


3224
01:56:44,606 --> 01:56:45,717
是真的


3225
01:56:45,897 --> 01:56:46,917
或者是假的


3226
01:56:47,067 --> 01:56:50,427
所以从技术上讲，我在这里放了一个真值或假值。


3227
01:56:50,667 --> 01:56:54,807
我只是通过比较来得到真值或假值。


3228
01:56:55,347 --> 01:56:58,827
你会注意到这里我们使用的是比较


3229
01:56:58,887 --> 01:56:59,697
接线员。


3230
01:57:00,087 --> 01:57:01,527
基本上这就像


3231
01:57:01,557 --> 01:57:03,296
我们要如何比较它们


3232
01:57:03,626 --> 01:57:06,656
我们说的是大于或等于在这个例子中


3233
01:57:07,346 --> 01:57:08,336
下面这里。


3234
01:57:08,816 --> 01:57:09,207
如果


3235
01:57:09,236 --> 01:57:11,366
这整个条件是正确的


3236
01:57:11,546 --> 01:57:15,206
换句话说，这两个比较的结果是正确的，


3237
01:57:15,686 --> 01:57:17,937
那么我们就知道没有人是最大的


3238
01:57:17,966 --> 01:57:19,286
所以我可以返回


3239
01:57:19,316 --> 01:57:19,946
num一


3240
01:57:20,006 --> 01:57:21,296
我可以说返回


3241
01:57:21,356 --> 01:57:21,836
不


3242
01:57:21,866 --> 01:57:22,316
一


3243
01:57:22,346 --> 01:57:25,556
但是我们还想检查其他条件所以我可以说


3244
01:57:25,586 --> 01:57:26,186
阿尔夫


3245
01:57:26,666 --> 01:57:27,086
并且


3246
01:57:27,116 --> 01:57:30,026
现在我想做一些其他的比较，我想说，


3247
01:57:31,166 --> 01:57:31,556
没有


3248
01:57:31,586 --> 01:57:32,126
同样


3249
01:57:32,426 --> 01:57:33,625
大于或等于


3250
01:57:33,655 --> 01:57:34,465
第

3251
01:57:35,695 --> 01:57:36,055
数


3252
01:57:36,084 --> 01:57:36,504
二


3253
01:57:38,363 --> 01:57:38,933
三。


3254
01:57:39,503 --> 01:57:44,663
我在这里做的基本上是我在这里做的除了没有，我在比较


3255
01:57:45,022 --> 01:57:49,223
这些不同的数字最终会成为一个真实或错误的值，


3256
01:57:49,463 --> 01:57:51,653
这取决于比较的结果


3257
01:57:52,133 --> 01:57:52,943
所以


3258
01:57:53,483 --> 01:57:54,503
再往下看


3259
01:57:54,533 --> 01:57:55,192
我们可以


3260
01:57:55,433 --> 01:57:56,843
回到家


3261
01:57:57,083 --> 01:58:00,504
因为如果所有这些都是真的那就意味着我们最终会返回


3262
01:58:00,594 --> 01:58:01,374
也没有。


3263
01:58:01,943 --> 01:58:03,923
最后我们可以说


3264
01:58:05,693 --> 01:58:05,933
如果


3265
01:58:05,963 --> 01:58:09,114
num 1不是最大的，麻木的，不是最大的


3266
01:58:09,144 --> 01:58:10,794
我们可以假设


3267
01:58:11,034 --> 01:58:13,435
第三个是最大的


3268
01:58:13,675 --> 01:58:14,665
现在我们有


3269
01:58:14,695 --> 01:58:15,774
我们的函数


3270
01:58:16,584 --> 01:58:17,184
在下面


3271
01:58:17,214 --> 01:58:19,075
我实际上只需要调用这个函数，


3272
01:58:19,945 --> 01:58:21,085
所以我想说，


3273
01:58:21,205 --> 01:58:23,935
实际上我要把结果打印出来，我说max


3274
01:58:24,025 --> 01:58:24,655
麻木的


3275
01:58:25,045 --> 01:58:27,265
会像三四五个一样


3276
01:58:27,595 --> 01:58:28,225
所以


3277
01:58:28,285 --> 01:58:31,435
我们把它叫做我们刚做的新函数。


3278
01:58:33,024 --> 01:58:33,625
并且


3279
01:58:33,654 --> 01:58:35,185
我将继续运行这个程序。


3280
01:58:35,694 --> 01:58:37,074
大家可以看到这里


3281
01:58:37,104 --> 01:58:37,884
在输出中


3282
01:58:37,914 --> 01:58:40,494
我们打印出了5个，因为那是最大的。


3283
01:58:40,824 --> 01:58:44,334
如果我要把中间变成最大的那么我们就把中间的这个变成40


3284
01:58:44,694 --> 01:58:46,224
现在它可以


3285
01:58:46,374 --> 01:58:49,854
考虑到这种情况最后我可以把它变成三百


3286
01:58:50,934 --> 01:58:52,403
它将能够处理这个问题


3287
01:58:52,583 --> 01:58:56,933
不管哪个数字麻木一个数字2或3，最终都是最大的


3288
01:58:57,083 --> 01:58:57,293
它是


3289
01:58:57,323 --> 01:58:58,073
能够


3290
01:58:58,103 --> 01:58:59,482
告诉我们没有问题。


3291
01:59:00,652 --> 01:59:06,652
这些比较是一种非常常见的方式来进行陈述和很多时候


3292
01:59:06,862 --> 01:59:09,442
你会想要比较不同的值


3293
01:59:09,682 --> 01:59:10,762
在python内部，


3294
01:59:10,972 --> 01:59:12,592
这里我们比较一下


3295
01:59:12,652 --> 01:59:13,552
数字。


3296
01:59:13,672 --> 01:59:15,862
但是我们也可以比较字符串


3297
01:59:15,892 --> 01:59:16,522
所以我可以


3298
01:59:16,552 --> 01:59:18,232
很容易让这两个


3299
01:59:18,562 --> 01:59:19,132
你知道我可以


3300
01:59:19,162 --> 01:59:20,542
使它像狗一样


3301
01:59:20,841 --> 01:59:22,551
我可以做这只狗


3302
01:59:23,001 --> 01:59:24,082
我可以说


3303
01:59:24,111 --> 01:59:25,731
一个不同的操作符，所以

3304
01:59:25,761 --> 01:59:29,181
这个双等号意思是相等的所以

3305
01:59:29,451 --> 01:59:32,331
如果这个字符串等于那个字符串。


3306
01:59:32,690 --> 01:59:34,670
你基本上可以比较


3307
01:59:34,700 --> 01:59:37,880
所有不同的数据类型都可以看到耐克在数字字符串中的比较。


3308
01:59:38,121 --> 01:59:39,201
你也可以比较


3309
01:59:39,230 --> 01:59:40,041
金银块


3310
01:59:40,880 --> 01:59:41,300
所以


3311
01:59:41,541 --> 01:59:42,051
再一次


3312
01:59:42,081 --> 01:59:42,891
这些是


3313
01:59:42,920 --> 01:59:43,851
比较


3314
01:59:43,880 --> 01:59:45,020
操作人员


3315
01:59:45,200 --> 01:59:49,851
这个大于或等于但是有很多其他的比较运算符我们可以使用


3316
01:59:50,601 --> 01:59:53,271
最基本的是一个双等号


3317
01:59:53,300 --> 01:59:56,450
并不是简单地检查两个值是否


3318
01:59:56,480 --> 01:59:56,930
相等的


3319
01:59:56,960 --> 01:59:57,831
所以它会说，


3320
01:59:58,101 --> 01:59:58,521
如果


3321
01:59:58,670 --> 02:00:00,381
第一，等于


3322
02:00:00,411 --> 02:00:01,190
第二，


3323
02:00:01,490 --> 02:00:03,530
我们也可以说不等于


3324
02:00:03,830 --> 02:00:06,770
这个惊叹号基本上是指


3325
02:00:06,950 --> 02:00:08,240
不相等，所以它是。


3326
02:00:08,510 --> 02:00:10,760
如果没有人不等于


3327
02:00:10,790 --> 02:00:11,600
也没有。


3328
02:00:12,350 --> 02:00:13,760
我们也有大于，


3329
02:00:14,030 --> 02:00:14,900
小于，


3330
02:00:15,561 --> 02:00:16,971
大于或等于


3331
02:00:17,361 --> 02:00:18,681
小于或等于。


3332
02:00:18,861 --> 02:00:21,411
这些都是所有的运算符


3333
02:00:21,441 --> 02:00:22,791
你们都知道最基本的


3334
02:00:23,121 --> 02:00:26,241
将在python中使用的比较运算符


3335
02:00:26,841 --> 02:00:31,041
使用比较是非常棒的而且会有大量的情况


3336
02:00:31,071 --> 02:00:33,951
在python里你想要比较不同的值


3337
02:00:33,980 --> 02:00:34,400
所以


3338
02:00:34,820 --> 02:00:36,591
这些都是非常有用的


3339
02:00:40,401 --> 02:00:40,701
在这里


3340
02:00:40,731 --> 02:00:44,871
关于如何与你们讨论如何在python中构建一个计算器的教程。


3341
02:00:45,351 --> 02:00:51,982
在这门课上，你们会知道，在课程开始的时候我们实际上创建了一个非常基础的计算器。


3342
02:00:52,462 --> 02:00:59,002
基本上，用户可以输入数字我们的计算器会把数字加起来然后吐出答案


3343
02:00:59,572 --> 02:01:04,072
这是一个很可怕的荣誉人如何建立一个更先进的计算器


3344
02:01:04,372 --> 02:01:08,843
这个计算器将能够执行所有的基本运算


3345
02:01:08,873 --> 02:01:12,113
操作，这样我们就可以加上减法乘法和除法


3346
02:01:12,593 --> 02:01:16,553
实际上允许用户指定他们想要做的是哪一种，


3347
02:01:16,973 --> 02:01:18,684
所以用户会输入一个数字。


3348
02:01:19,134 --> 02:01:23,094
他们会输入任何他们想要使用的运算符所以加上负的


3349
02:01:23,124 --> 02:01:23,813
除


3350
02:01:23,963 --> 02:01:24,653
被嘲笑，


3351
02:01:25,193 --> 02:01:28,523
然后我输入第二个数字，然后执行操作


3352
02:01:28,553 --> 02:01:30,114
对他们来说，这可能很酷。


3353
02:01:30,354 --> 02:01:32,245
它将向你们展示我们如何使用


3354
02:01:32,995 --> 02:01:33,805
if语句


3355
02:01:33,834 --> 02:01:34,435
像


3356
02:01:34,465 --> 02:01:35,755
实际应用


3357
02:01:35,785 --> 02:01:36,745
让我们开始吧。


3358
02:01:37,015 --> 02:01:38,275
我们要做的第一件事


3359
02:01:38,305 --> 02:01:39,535
得到


3360
02:01:39,685 --> 02:01:41,695
来自用户的输入，所以我要创建


3361
02:01:41,905 --> 02:01:45,534
三个变量一个是第一个数字，第二个数字


3362
02:01:45,774 --> 02:01:46,854
一个是操作符


3363
02:01:46,884 --> 02:01:49,853
它会存储用户输入的值


3364
02:01:50,093 --> 02:01:52,854
在这些变量中第一个是第一个


3365
02:01:53,994 --> 02:01:55,615
我要把它设为


3366
02:01:55,645 --> 02:01:56,334
输入


3367
02:01:56,725 --> 02:01:58,315
我们还会给出一个提示


3368
02:01:58,345 --> 02:01:59,005
进入


3369
02:01:59,455 --> 02:02:00,025
首先


3370
02:02:00,085 --> 02:02:00,715
数


3371
02:02:02,065 --> 02:02:05,935
这里的问题是，不管用户是什么


3372
02:02:05,965 --> 02:02:06,685
进入。


3373
02:02:06,925 --> 02:02:07,556
我们想要


3374
02:02:07,585 --> 02:02:09,325
把它转换成一个数字


3375
02:02:09,685 --> 02:02:10,105
所以


3376
02:02:10,135 --> 02:02:17,035
通常在python中，当我们从用户那里得到输入时无论输入的是什么，都会被转换成字符串。


3377
02:02:17,485 --> 02:02:20,036
但是我们不想要一个字符串因为我们需要


3378
02:02:20,065 --> 02:02:23,246
加或减，把这些数字相乘？


3379
02:02:23,666 --> 02:02:25,526
所以当他们进入的时候


3380
02:02:25,556 --> 02:02:27,866
我想要马上把它转换成数字


3381
02:02:27,896 --> 02:02:28,616
到


3382
02:02:28,706 --> 02:02:31,766
一个实际的数字数据类型而不是字符串。


3383
02:02:32,156 --> 02:02:34,466
所以我能做的是，我可以说浮点数。


3384
02:02:34,736 --> 02:02:36,056
我可以把它包围起来


3385
02:02:36,086 --> 02:02:37,976
整个输入标签


3386
02:02:38,216 --> 02:02:39,447
用括号。


3387
02:02:39,567 --> 02:02:40,287
现在，


3388
02:02:40,407 --> 02:02:43,796
它要做的是，它会立即转化


3389
02:02:43,977 --> 02:02:45,837
无论用户输入什么


3390
02:02:46,017 --> 02:02:46,947
变成一个浮点数。


3391
02:02:47,247 --> 02:02:51,117
这就意味着他们要插入一个数字否则我们会得到一个错误


3392
02:02:51,146 --> 02:02:51,537
但是


3393
02:02:51,896 --> 02:02:55,018
在大多数情况下，这对我们来说是可行的所以我实际上要


3394
02:02:55,047 --> 02:02:56,188
复制他们的天空


3395
02:02:57,208 --> 02:02:58,587
然后我们继续


3396
02:02:58,828 --> 02:03:00,208
把它粘贴到这里，


3397
02:03:00,627 --> 02:03:02,278
我们再粘贴一次这样我们就可以


3398
02:03:02,308 --> 02:03:05,218
基本上就是试着从这里得到3个输入


3399
02:03:05,248 --> 02:03:05,877
用户。


3400
02:03:06,777 --> 02:03:10,048
所以我们想要得到的第二件事是操作符所以我想说


3401
02:03:10,108 --> 02:03:10,888
哦，p


3402
02:03:11,368 --> 02:03:14,547
对于操作符，实际上摆脱了这个流


3403
02:03:14,577 --> 02:03:15,147
因为


3404
02:03:15,177 --> 02:03:16,827
我们想把它作为一个字符串。


3405
02:03:17,277 --> 02:03:18,057
我想说


3406
02:03:18,087 --> 02:03:18,777
进入


3407
02:03:20,097 --> 02:03:21,657
操作符，它会是这样的。


3408
02:03:21,717 --> 02:03:22,828
加上负


3409
02:03:23,127 --> 02:03:24,478
乘任何东西。


3410
02:03:25,018 --> 02:03:26,967
最后在这里，我们会变得麻木


3411
02:03:26,997 --> 02:03:27,537
到


3412
02:03:27,567 --> 02:03:30,477
同样，我们要把它转换成浮点数，


3413
02:03:30,747 --> 02:03:31,587
所以我会说


3414
02:03:31,828 --> 02:03:33,208
输入第二个数字


3415
02:03:33,478 --> 02:03:33,958
所以


3416
02:03:34,138 --> 02:03:37,528
现在我们要做的是得到第一个数字我们得到的是


3417
02:03:37,558 --> 02:03:40,918
接线员，我们从用户那里得到第二个号码。


3418
02:03:42,148 --> 02:03:45,208
我们现在要做的是，我们需要弄清楚


3419
02:03:45,237 --> 02:03:46,917
这里面是什么


3420
02:03:47,037 --> 02:03:47,787
哦。


3421
02:03:47,847 --> 02:03:49,467
换句话说，我们需要弄清楚


3422
02:03:49,497 --> 02:03:50,336
接线员。


3423
02:03:50,577 --> 02:03:51,627
用户是


3424
02:03:51,657 --> 02:03:55,406
试着去做额外的事情他们想做减法，比如


3425
02:03:55,646 --> 02:03:56,697
我们想要算出来，


3426
02:03:58,047 --> 02:03:58,678
我们可以用


3427
02:03:58,708 --> 02:03:59,547
if语句


3428
02:03:59,907 --> 02:04:00,867
为了


3429
02:04:00,897 --> 02:04:02,908
把它算出来，我就到这里来


3430
02:04:02,968 --> 02:04:03,538
并且


3431
02:04:03,718 --> 02:04:06,237
我只是想创建一个if语句的歌然后说


3432
02:04:06,267 --> 02:04:06,747
如果。


3433
02:04:08,007 --> 02:04:13,708
我们想要检查一个条件所以我要检查这个运算符是否等于


3434
02:04:14,218 --> 02:04:14,998
加号


3435
02:04:15,027 --> 02:04:16,138
所以我可以说


3436
02:04:16,288 --> 02:04:17,008
o p


3437
02:04:17,488 --> 02:04:18,328
等于


3438
02:04:20,338 --> 02:04:22,737
现在如果算子等于一个正号。


3439
02:04:22,797 --> 02:04:23,668
我要打印


3440
02:04:23,698 --> 02:04:24,178
外出


3441
02:04:25,378 --> 02:04:26,218
第一


3442
02:04:26,248 --> 02:04:26,908
加上


3443
02:04:26,968 --> 02:04:27,748
也没有。


3444
02:04:27,838 --> 02:04:31,377
但是我们说，不是一个加号而是他们输入了别的东西所以我们可以说


3445
02:04:31,407 --> 02:04:32,367
l f


3446
02:04:33,477 --> 02:04:34,527
等于。


3447
02:04:34,767 --> 02:04:36,688
现在我们来检查一下它是不是一个负号。


3448
02:04:37,558 --> 02:04:38,999
这里或者只是打印


3449
02:04:39,148 --> 02:04:39,898
num一


3450
02:04:39,928 --> 02:04:40,648
减去


3451
02:04:40,678 --> 02:04:41,398
没什么。


3452
02:04:42,418 --> 02:04:44,158
实际上我忘了在这里放一个冒号。


3453
02:04:44,728 --> 02:04:47,817
所以我们可以对所有的东西做这些，现在我们可以说。


3454
02:04:47,877 --> 02:04:48,688
低频


3455
02:04:49,288 --> 02:04:50,098
奥佩


3456
02:04:50,548 --> 02:04:51,688
等于


3457
02:04:52,588 --> 02:04:53,488
分割


3458
02:04:53,788 --> 02:04:57,297
这里我们把这两个数分开我可以把它打印出来


3459
02:04:57,597 --> 02:04:59,847
第一，对它麻木，


3460
02:05:00,597 --> 02:05:04,137
最后我们会对乘法做同样的事情，我会说


3461
02:05:04,227 --> 02:05:04,617
l


3462
02:05:04,646 --> 02:05:05,247
如果


3463
02:05:07,077 --> 02:05:07,197
是


3464
02:05:08,787 --> 02:05:09,777
宇航员


3465
02:05:10,167 --> 02:05:11,247
是打印出来的


3466
02:05:11,307 --> 02:05:11,937
外出


3467
02:05:12,597 --> 02:05:14,097
第一遍


3468
02:05:14,127 --> 02:05:14,937
也没有。


3469
02:05:15,627 --> 02:05:18,328
所以基本上在这里我们有


3470
02:05:18,357 --> 02:05:19,407
你知道条件。


3471
02:05:19,707 --> 02:05:21,117
但是我也想把它放在一个


3472
02:05:21,146 --> 02:05:21,477
其他的


3473
02:05:21,506 --> 02:05:22,466
声明


3474
02:05:22,586 --> 02:05:25,556
在用户输入操作的情况下。


3475
02:05:25,855 --> 02:05:26,365
那

3476
02:05:26,395 --> 02:05:27,025
不

3477
02:05:27,055 --> 02:05:31,405
就像我们在这里指定的四个一样我只是想抛出一个错误和


3478
02:05:31,465 --> 02:05:32,155
奥佩


3479
02:05:32,215 --> 02:05:33,055
实际上我们只是说


3480
02:05:33,925 --> 02:05:35,695
这里是这个打印出来的湖


3481
02:05:36,835 --> 02:05:37,735
无效的


3482
02:05:38,425 --> 02:05:39,205
接线员。


3483
02:05:40,345 --> 02:05:40,675
所以


3484
02:05:40,705 --> 02:05:45,354
这个if语句应该给我们所有我们想要的东西基本上我只是检查一下


3485
02:05:45,654 --> 02:05:46,314
如果是


3486
02:05:46,374 --> 02:05:50,363
等于a加上符号a减去符号的符号或者是一个乘法符号！


3487
02:05:50,723 --> 02:05:54,204
取决于哪一个是相等的我们会做一个不同的操作


3488
02:05:54,233 --> 02:05:56,994
让我们来运行一下，看看我们是怎么做的


3489
02:05:57,324 --> 02:05:58,793
我要运行这个程序


3490
02:06:00,233 --> 02:06:03,624
输入第一个数字，输入5


3491
02:06:04,614 --> 02:06:06,534
输入一个操作符，为什么我们

3492
02:06:06,563 --> 02:06:07,643
加法


3493
02:06:08,093 --> 02:06:10,883
然后输入第二个数字做二十三。


3494
02:06:11,363 --> 02:06:11,903
现在


3495
02:06:11,933 --> 02:06:14,244
它打印出答案是28，

3496
02:06:14,484 --> 02:06:15,954
我们的计算器是有效的


3497
02:06:15,984 --> 02:06:17,454
让我们再试一试


3498
02:06:17,514 --> 02:06:19,075
操作人员只是为了确保。


3499
02:06:19,525 --> 02:06:21,085
所以是6


3500
02:06:21,115 --> 02:06:23,185
y乘以它


3501
02:06:23,214 --> 02:06:25,224
我不知道5点


3502
02:06:25,254 --> 02:06:26,094
到三。


3503
02:06:27,084 --> 02:06:31,344
现在我们开始做乘法，看起来我们得到了答案


3504
02:06:31,614 --> 02:06:33,563
我们的计算器似乎在起作用


3505
02:06:33,773 --> 02:06:37,224
基本上我们所做的就是从用户那里得到输入。


3506
02:06:37,434 --> 02:06:38,604
然后我们使用


3507
02:06:38,693 --> 02:06:40,493
如果要算出


3508
02:06:40,523 --> 02:06:45,323
他们想要做的是什么这样我们就可以检查他们是否想要一个我们可以检查的版本


3509
02:06:45,563 --> 02:06:46,673
如果他们想要减法


3510
02:06:46,703 --> 02:06:48,053
除法和乘法。


3511
02:06:48,383 --> 02:06:51,083
我们还可以检查他们是否输入了无效的


3512
02:06:51,113 --> 02:06:54,022
接线员，所以我们为什么不试试呢。


3513
02:06:55,493 --> 02:06:57,233
所以输入5


3514
02:06:57,263 --> 02:06:58,973
现在，不一样的是


3515
02:06:59,633 --> 02:07:01,673
一个开或闭的括号


3516
02:07:01,703 --> 02:07:02,333
四，


3517
02:07:02,603 --> 02:07:03,684
大家可以看到，这是


3518
02:07:03,713 --> 02:07:04,463
能够


3519
02:07:04,493 --> 02:07:07,104
像这个程序一样聪明地告诉你


3520
02:07:07,374 --> 02:07:09,144
这不是一个有效的算子


3521
02:07:09,684 --> 02:07:16,583
这些if语句可以非常强大，我们可以将它们结合起来使用用户输入来创建一个小计算器。


3522
02:07:20,393 --> 02:07:24,983
在本教程中，我们将使用python中的字典。


3523
02:07:25,403 --> 02:07:30,863
现在，字典是python中的一个特殊结构它允许我们存储信息


3524
02:07:31,163 --> 02:07:31,883
被称为


3525
02:07:31,913 --> 02:07:32,542
键


3526
02:07:32,632 --> 02:07:33,982
值对。


3527
02:07:34,402 --> 02:07:37,372
本质上，我可以创建一些不同的


3528
02:07:37,401 --> 02:07:38,721
键

3529
02:07:38,991 --> 02:07:39,321
然后


3530
02:07:39,351 --> 02:07:41,241
我想要访问一个特定的


3531
02:07:41,331 --> 02:07:43,761
字典里的一段信息。


3532
02:07:44,031 --> 02:07:45,981
我可以用它来指代它


3533
02:07:46,011 --> 02:07:46,581
键，


3534
02:07:47,091 --> 02:07:52,551
所以字典这个词在这里是很合适的如果你熟悉一个普通的字典，


3535
02:07:53,031 --> 02:07:55,311
你知道，在普通字典里你会有一个词，


3536
02:07:56,181 --> 02:07:59,181
你会有一个与这个词相关的定义


3537
02:07:59,511 --> 02:08:01,551
在这种情况下，这个词就是


3538
02:08:01,581 --> 02:08:02,211
关键。


3539
02:08:02,541 --> 02:08:05,722
换句话说，这个词是唯一识别它的东西


3540
02:08:05,751 --> 02:08:07,131
在字典里，


3541
02:08:07,881 --> 02:08:11,062
它的值就是实际的定义


3542
02:08:11,272 --> 02:08:14,513
一旦我们开始处理这个问题，这就更有意义了


3543
02:08:15,173 --> 02:08:17,093
我只是想给大家简单介绍一下。


3544
02:08:17,633 --> 02:08:18,593
在这种情况下


3545
02:08:18,623 --> 02:08:20,723
我想创建一个小程序


3546
02:08:20,783 --> 02:08:22,463
这将允许我们进行转换


3547
02:08:22,493 --> 02:08:24,532
一个三个数字月的名字


3548
02:08:24,802 --> 02:08:26,632
进入一个月的名称


3549
02:08:26,873 --> 02:08:28,073
所以我可以转换


3550
02:08:28,103 --> 02:08:29,093
例如


3551
02:08:29,123 --> 02:08:29,692
杰


3552
02:08:29,722 --> 02:08:30,442
n


3553
02:08:30,862 --> 02:08:31,462
二


3554
02:08:32,123 --> 02:08:32,843
一月


3555
02:08:33,203 --> 02:08:34,313
或者我可以转换


3556
02:08:34,403 --> 02:08:34,793
一


3557
02:08:34,823 --> 02:08:35,663
a r


3558
02:08:35,753 --> 02:08:36,413
进入


3559
02:08:36,503 --> 02:08:37,103
三月。


3560
02:08:37,373 --> 02:08:44,274
就像我想要有一个可以为我们做的程序这对字典来说是一个很好的用例


3561
02:08:44,634 --> 02:08:46,253
我们实际上要创建一个字典。


3562
02:08:46,583 --> 02:08:48,653
我相信你们是怎么做到的，


3563
02:08:48,743 --> 02:08:50,003
我们要做的第一件事


3564
02:08:50,033 --> 02:08:52,553
在创建字典的过程中，只给了一个名字，


3565
02:08:52,913 --> 02:08:56,633
所以我想给它一个特定的名称所以我要把它命名为


3566
02:08:56,693 --> 02:08:57,503
月


3567
02:08:58,523 --> 02:08:59,633
转换。


3568
02:09:00,143 --> 02:09:01,673
现在我要设置这个


3569
02:09:01,703 --> 02:09:02,663
等于


3570
02:09:02,723 --> 02:09:04,583
开闭花括号


3571
02:09:04,823 --> 02:09:07,373
所以无论何时我们用python创建字典。


3572
02:09:07,613 --> 02:09:08,693
我们总是想要


3573
02:09:08,723 --> 02:09:11,213
在这些打开和关闭的内部创建


3574
02:09:11,243 --> 02:09:12,232
花括号


3575
02:09:12,532 --> 02:09:12,862
所以


3576
02:09:12,922 --> 02:09:17,662
在字典里我们可以开始定义什么是键


3577
02:09:17,842 --> 02:09:19,252
值对。


3578
02:09:19,312 --> 02:09:22,492
所以我可以定义一个键，我可以给它


3579
02:09:22,522 --> 02:09:22,912
a


3580
02:09:22,942 --> 02:09:24,352
对应的值。


3581
02:09:24,742 --> 02:09:28,131
我们可以这样做的方法是输入输出键然后输入值


3582
02:09:28,582 --> 02:09:31,822
在我们的例子中，我们要转换三个数字月的名字


3583
02:09:31,912 --> 02:09:33,442
进入一个月的名字


3584
02:09:33,472 --> 02:09:35,481
所以我想输入一个例子


3585
02:09:35,511 --> 02:09:36,621
j n


3586
02:09:37,221 --> 02:09:37,551
并且


3587
02:09:37,581 --> 02:09:39,112
然后我可以输入一个冒号。


3588
02:09:39,741 --> 02:09:40,551
我想要打印出来


3589
02:09:40,581 --> 02:09:44,211
我想把它和它联系起来，所以我们可以在一月份说。


3590
02:09:44,452 --> 02:09:48,083
我可以对每一个组合都这样做所以我可以说


3591
02:09:48,712 --> 02:09:49,462
你会


3592
02:09:49,762 --> 02:09:50,752
这是


3593
02:09:50,902 --> 02:09:51,802
二月


3594
02:09:52,222 --> 02:09:55,162
实际上，在每一个之后，我们需要加一个逗号。


3595
02:09:56,092 --> 02:09:59,662
所以我也可以在3月的时候做同样的事情，他们是。


3596
02:10:02,062 --> 02:10:06,083
本质上，我能做的就是指定一个条目


3597
02:10:06,323 --> 02:10:08,243
在这本字典里


3598
02:10:08,273 --> 02:10:09,683
每一个都是这样的


3599
02:10:09,863 --> 02:10:11,993
这是关键字


3600
02:10:12,292 --> 02:10:15,173
在这里，就是这个值。


3601
02:10:15,653 --> 02:10:19,703
这里有一件事是所有这些键都必须是唯一的。


3602
02:10:19,943 --> 02:10:23,063
所以如果我要到这里把这个改成j n，


3603
02:10:23,543 --> 02:10:27,233
这实际上会给我们一些警告你们可以在下面看到它说


3604
02:10:27,503 --> 02:10:28,643
字典包含


3605
02:10:28,672 --> 02:10:29,272
复制


3606
02:10:29,302 --> 02:10:29,902
钥匙


3607
02:10:30,172 --> 02:10:32,842
他们知道没有人我们在创建字典


3608
02:10:33,052 --> 02:10:34,132
你要确保


3609
02:10:34,162 --> 02:10:35,842
键是唯一的


3610
02:10:35,992 --> 02:10:37,131
不是这样我要继续


3611
02:10:37,161 --> 02:10:39,351
在每个月的每一个月里创建一个这样的


3612
02:10:39,381 --> 02:10:41,361
然后我们会回来，我们会讨论这个问题。


3613
02:10:42,861 --> 02:10:47,990
好了，我已经为这12个月的所有12个月创建了一个条目


3614
02:10:48,260 --> 02:10:49,791
我们有一堆独特的


3615
02:10:50,480 --> 02:10:53,150
每一个键都与


3616
02:10:53,180 --> 02:10:54,410
一个不同的值。


3617
02:10:54,860 --> 02:11:00,229
这是创建字典的基础知识我们有很多不同的键值对。


3618
02:11:00,589 --> 02:11:03,019
现在我们可以做的是


3619
02:11:03,079 --> 02:11:04,339
从


3620
02:11:04,369 --> 02:11:06,259
在这本字典里？


3621
02:11:06,649 --> 02:11:08,150
如果我想要访问


3622
02:11:08,180 --> 02:11:08,930
特定的


3623
02:11:08,959 --> 02:11:10,759
键或特定值。


3624
02:11:11,119 --> 02:11:13,609
我所要做的就是到这里来，我要做的就是


3625
02:11:13,639 --> 02:11:15,739
把它打印到屏幕上，这样我们就能看到它了。


3626
02:11:16,759 --> 02:11:20,780
你所要做的就是用名字来称呼字典所以它就叫


3627
02:11:20,840 --> 02:11:22,250
月转换。


3628
02:11:22,581 --> 02:11:23,000
并且


3629
02:11:23,030 --> 02:11:25,220
实际上有很多不同的方法


3630
02:11:25,250 --> 02:11:28,100
我可以访问这些月的名字，


3631
02:11:28,190 --> 02:11:28,700
所以


3632
02:11:29,270 --> 02:11:30,140
我可以访问


3633
02:11:30,169 --> 02:11:32,329
这里面有不同的条目


3634
02:11:32,389 --> 02:11:32,959
字典？


3635
02:11:33,199 --> 02:11:34,910
第一种方法是


3636
02:11:34,939 --> 02:11:35,629
a


3637
02:11:35,750 --> 02:11:37,189
开闭方括号


3638
02:11:37,489 --> 02:11:40,338
在这里，我可以输入其中一个键。


3639
02:11:40,579 --> 02:11:42,559
比如这里我可以输入


3640
02:11:42,948 --> 02:11:43,638
哦，你。


3641
02:11:44,058 --> 02:11:46,789
它应该做的是，它应该还给我们。


3642
02:11:46,849 --> 02:11:47,329
那


3643
02:11:47,358 --> 02:11:48,349
满的


3644
02:11:48,438 --> 02:11:50,809
命名为11月，所以当我把它打印出来时，


3645
02:11:51,589 --> 02:11:53,870
你会看到我们回到这里。


3646
02:11:53,990 --> 02:11:54,770
11月。


3647
02:11:55,160 --> 02:11:56,840
所以我可以做同样的事情


3648
02:11:57,080 --> 02:11:59,210
任何一个我们可以说像一个r。


3649
02:11:59,630 --> 02:12:01,880
现在我们应该回到过去


3650
02:12:02,090 --> 02:12:04,580
我可以参考这个键，


3651
02:12:05,030 --> 02:12:06,951
它会进入字典，它是


3652
02:12:06,980 --> 02:12:10,191
给我一个与量化宽松相关的价值


3653
02:12:10,821 --> 02:12:13,341
实际上是另一种方法我们也可以这样做


3654
02:12:13,401 --> 02:12:13,971
说


3655
02:12:14,001 --> 02:12:16,041
月转换点


3656
02:12:16,341 --> 02:12:17,061
得到


3657
02:12:17,331 --> 02:12:21,711
在这里，我也可以传入键的名字这样我就可以传入了


3658
02:12:22,041 --> 02:12:23,211
d c


3659
02:12:24,081 --> 02:12:25,940
现在我们要打印出来了


3660
02:12:26,000 --> 02:12:26,840
十二月。


3661
02:12:27,800 --> 02:12:30,021
使用这个get函数很酷


3662
02:12:30,051 --> 02:12:34,521
我可以指定我想要使用的默认值。


3663
02:12:34,791 --> 02:12:36,651
如果没有找到这个键


3664
02:12:37,131 --> 02:12:41,122
当我们处理字典的时候会有一些特定的情况你会把它放进一个键


3665
02:12:41,151 --> 02:12:43,131
这可能并不一定


3666
02:12:43,191 --> 02:12:44,572
映射到一个值


3667
02:12:44,752 --> 02:12:47,302
在字典里你把他放进了一个无效的


3668
02:12:47,332 --> 02:12:47,752
关键。


3669
02:12:48,142 --> 02:12:48,952
让我们


3670
02:12:48,982 --> 02:12:51,502
试着这么诚实地说，像aliyu v。


3671
02:12:51,592 --> 02:12:52,372
这不是


3672
02:12:52,462 --> 02:12:53,782
一个月的缩写。


3673
02:12:54,022 --> 02:12:55,402
所以当我试着运行这个时，


3674
02:12:56,032 --> 02:12:57,382
你会看到我们得到这个


3675
02:12:57,412 --> 02:12:58,072
没有


3676
02:12:58,102 --> 02:12:58,792
在下面。


3677
02:12:59,122 --> 02:13:00,232
在很多情况下


3678
02:13:00,262 --> 02:13:01,461
你会想要


3679
02:13:01,491 --> 02:13:03,381
创建某种默认值


3680
02:13:03,411 --> 02:13:04,011
价值。


3681
02:13:04,401 --> 02:13:07,162
所以如果我在这种情况下我有一个键


3682
02:13:07,192 --> 02:13:10,492
它不能映射到里面的任何值


3683
02:13:10,521 --> 02:13:11,361
字典？


3684
02:13:11,661 --> 02:13:14,001
我可以传递一个默认值。


3685
02:13:14,242 --> 02:13:16,491
所以在这个点上，得到函数


3686
02:13:16,521 --> 02:13:16,971
我可以


3687
02:13:17,151 --> 02:13:17,961
做一个逗号。


3688
02:13:18,141 --> 02:13:22,461
我可以像默认值一样通过打印出来这样我就可以说不了


3689
02:13:22,491 --> 02:13:23,301
有效的


3690
02:13:23,361 --> 02:13:23,931
关键。


3691
02:13:24,531 --> 02:13:25,251
现在


3692
02:13:25,431 --> 02:13:28,582
当我输入无效的键而不是说没有。


3693
02:13:28,882 --> 02:13:30,263
它会继续说


3694
02:13:30,292 --> 02:13:31,552
不是

3695
02:13:31,582 --> 02:13:34,613
这将会给我们一个默认值


3696
02:13:34,883 --> 02:13:36,563
我们可以依靠它


3697
02:13:36,894 --> 02:13:38,934
这些字典真的很棒


3698
02:13:40,014 --> 02:13:42,534
这里的键不一定是


3699
02:13:42,563 --> 02:13:44,634
字符串，所以你也可以用数字


3700
02:13:44,904 --> 02:13:47,004
举个例子，我可以看到0


3701
02:13:47,484 --> 02:13:48,354
一


3702
02:13:48,685 --> 02:13:52,405
我可以把任何数字放在这里作为键


3703
02:13:52,615 --> 02:13:55,796
只要它们是唯一的，我就能访问这些键


3704
02:13:55,976 --> 02:13:58,077
就像我通常在这里一样


3705
02:13:58,317 --> 02:13:58,797
有了这个


3706
02:13:58,827 --> 02:14:01,587
得到函数或者是那些开放的和封闭的方括号


3707
02:14:02,037 --> 02:14:03,297
这是最基本的


3708
02:14:03,327 --> 02:14:05,906
使用像我这样的字典真的很有用


3709
02:14:05,936 --> 02:14:07,256
键值对


3710
02:14:07,616 --> 02:14:12,386
老实说，你会在python中使用它们来存储不同类型的数据。


3711
02:14:16,856 --> 02:14:20,786
在本教程中，我想和你们讨论一下python中的野生循环，


3712
02:14:21,176 --> 02:14:21,326
并且


3713
02:14:21,356 --> 02:14:26,696
while循环基本上是python中的一个结构允许我们进行循环


3714
02:14:26,937 --> 02:14:27,837
执行


3715
02:14:27,867 --> 02:14:30,537
一段代码多次。


3716
02:14:30,897 --> 02:14:34,647
所以我可以指定一些不同的代码行然后我就可以


3717
02:14:34,677 --> 02:14:35,637
写代码


3718
02:14:35,697 --> 02:14:37,076
在一个while循环中


3719
02:14:37,586 --> 02:14:44,816
它会让你循环遍历代码，直到某一条件为假为止。


3720
02:14:45,146 --> 02:14:51,537
所以我们的生活可以是很棒的，在python中有很多情况我们想要循环通过特定的代码行，


3721
02:14:51,957 --> 02:14:54,657
在本教程中，我想向你们展示治疗的效果


3722
02:14:54,717 --> 02:14:56,997
关于牛羚如何工作的基本知识


3723
02:14:57,267 --> 02:15:01,797
然后在未来的教程中我们会使用跳跃来创建小游戏之类的东西


3724
02:15:02,577 --> 02:15:04,408
我们来谈谈野生和


3725
02:15:05,158 --> 02:15:06,448
当我创建我的狂野循环时。


3726
02:15:06,868 --> 02:15:08,907
我想做的第一件事是


3727
02:15:09,207 --> 02:15:10,407
创建一个


3728
02:15:10,437 --> 02:15:10,977
整数。


3729
02:15:11,157 --> 02:15:15,626
我基本上是在创建一个变量，它是一个数字你不需要在一段时间内做这个


3730
02:15:15,656 --> 02:15:17,786
但是为了我们的演示，我要。


3731
02:15:18,085 --> 02:15:19,046
我把这个叫做，


3732
02:15:19,106 --> 02:15:19,646
我


3733
02:15:19,676 --> 02:15:21,416
把它设为1。


3734
02:15:22,166 --> 02:15:25,165
现在我要做的是创建一个while循环


3735
02:15:25,195 --> 02:15:26,784
所以我基本上只会说。


3736
02:15:26,934 --> 02:15:27,744
当


3737
02:15:28,554 --> 02:15:29,064
并且


3738
02:15:29,274 --> 02:15:31,284
在这里我要指定


3739
02:15:31,313 --> 02:15:31,854
a


3740
02:15:32,003 --> 02:15:32,843
条件，


3741
02:15:33,323 --> 02:15:36,924
这就是我们的循环条件或者你也可以


3742
02:15:36,984 --> 02:15:38,245
把它当作一个循环


3743
02:15:38,274 --> 02:15:38,844
保护


3744
02:15:38,964 --> 02:15:42,265
基本上我们会一直循环遍历代码


3745
02:15:42,354 --> 02:15:43,794
在while循环中。


3746
02:15:44,154 --> 02:15:46,705
只要这个条件是正确的。


3747
02:15:47,035 --> 02:15:50,245
所以不管我在这里输入什么条件只要它是真的


3748
02:15:50,485 --> 02:15:54,055
我们将继续循环遍历荒野中的代码我只是想说


3749
02:15:55,735 --> 02:15:56,635
小于


3750
02:15:56,665 --> 02:15:56,875
或者


3751
02:15:56,904 --> 02:15:57,714
等于


3752
02:15:57,984 --> 02:15:58,554
十


3753
02:15:59,844 --> 02:16:01,164
现在我要放一个


3754
02:16:01,344 --> 02:16:01,974
结肠


3755
02:16:02,694 --> 02:16:04,044
我要画一条新线。


3756
02:16:04,314 --> 02:16:04,705
所以


3757
02:16:04,734 --> 02:16:08,634
任何低于这个while循环语句的内容


3758
02:16:08,694 --> 02:16:09,564
缩进


3759
02:16:09,864 --> 02:16:10,645
像这样


3760
02:16:10,825 --> 02:16:12,595
将会被认为是代码


3761
02:16:12,625 --> 02:16:14,875
在while循环中，代码中


3762
02:16:15,115 --> 02:16:17,456
会被反复执行


3763
02:16:17,696 --> 02:16:20,306
这里的条件是正确的。


3764
02:16:20,696 --> 02:16:24,027
所以我要在这里放一个非常简单的代码行它会打印出来


3765
02:16:24,057 --> 02:16:24,986
不知道


3766
02:16:25,016 --> 02:16:25,556
我，


3767
02:16:26,126 --> 02:16:28,045
然后在下面这里，我要


3768
02:16:28,075 --> 02:16:28,615
增量


3769
02:16:28,645 --> 02:16:30,145
我要加一个


3770
02:16:30,175 --> 02:16:31,286
我必须说


3771
02:16:31,346 --> 02:16:31,826
我


3772
02:16:32,126 --> 02:16:32,456
是


3773
02:16:32,516 --> 02:16:33,056
等于


3774
02:16:33,596 --> 02:16:34,136
加上


3775
02:16:34,195 --> 02:16:34,766
第一，


3776
02:16:35,006 --> 02:16:38,666
所以基本上，我取这个值，然后加上1


3777
02:16:39,086 --> 02:16:42,057
实际上是我们可以使用的速记法


3778
02:16:42,207 --> 02:16:44,577
用python来做这样的事情，尽管我可以这么说


3779
02:16:46,048 --> 02:16:47,008
等于1


3780
02:16:47,368 --> 02:16:49,619
而不是自动添加一个


3781
02:16:49,649 --> 02:16:50,369
到


3782
02:16:50,850 --> 02:16:52,408
这就像一个速记法


3783
02:16:52,618 --> 02:16:54,778
你会看到人们在管道上使用了很多东西。


3784
02:16:55,469 --> 02:16:55,919
所以


3785
02:16:56,219 --> 02:16:58,348
在这里，我们基本上有


3786
02:16:58,378 --> 02:17:00,088
我的狂野生活


3787
02:17:00,778 --> 02:17:04,198
我们在这里定义了这个变量的轮廓


3788
02:17:04,528 --> 02:17:06,989
我们将继续循环遍历代码


3789
02:17:07,049 --> 02:17:08,399
在while循环中。


3790
02:17:08,669 --> 02:17:11,280
只要这个条件在上面


3791
02:17:11,431 --> 02:17:12,151
是真的。


3792
02:17:12,392 --> 02:17:15,031
如果这个条件是假的例如


3793
02:17:15,062 --> 02:17:15,602
我


3794
02:17:15,752 --> 02:17:16,622
等于


3795
02:17:16,682 --> 02:17:17,401
十一个，


3796
02:17:17,731 --> 02:17:21,061
那么我们就不打算在这家公司进行循环，而不仅仅是继续前进。


3797
02:17:21,421 --> 02:17:23,520
下面这里我要打印


3798
02:17:25,140 --> 02:17:26,430
完成了循环。


3799
02:17:27,000 --> 02:17:29,011
这就是我们的例子。


3800
02:17:29,730 --> 02:17:33,240
让我们运行这个程序，我要运行它


3801
02:17:34,110 --> 02:17:34,561
并且


3802
02:17:34,591 --> 02:17:36,479
你会看到下面这里有一些


3803
02:17:36,510 --> 02:17:37,710
输出


3804
02:17:38,400 --> 02:17:39,690
我们将会得到


3805
02:17:39,900 --> 02:17:41,670
打印出来的数字


3806
02:17:41,700 --> 02:17:42,749
一直往下


3807
02:17:42,779 --> 02:17:43,619
通过


3808
02:17:43,739 --> 02:17:44,459
十


3809
02:17:44,759 --> 02:17:46,949
然后用循环打印出来


3810
02:17:47,279 --> 02:17:50,669
所以基本上，我们打印出来了


3811
02:17:50,909 --> 02:17:52,559
每次我们经过这个循环


3812
02:17:52,589 --> 02:17:52,949
所以


3813
02:17:53,129 --> 02:17:55,078
一开始我等于一。


3814
02:17:55,348 --> 02:17:58,317
当它到达这个while循环时，python会做的第一件事


3815
02:17:58,348 --> 02:18:00,057
它会检查这个条件。


3816
02:18:00,236 --> 02:18:01,915
所以在它做其他事情之前，


3817
02:18:02,095 --> 02:18:04,074
它会检查这个条件，它会说


3818
02:18:04,104 --> 02:18:04,524
好的，


3819
02:18:04,914 --> 02:18:05,395
是


3820
02:18:05,425 --> 02:18:06,145
一


3821
02:18:06,175 --> 02:18:07,556
小于或等于10。


3822
02:18:08,006 --> 02:18:08,937
这是真的。


3823
02:18:09,116 --> 02:18:10,795
只要这个人

3824
02:18:10,825 --> 02:18:11,365
真实的


3825
02:18:11,396 --> 02:18:13,976
我们将遍历并循环遍历这里的所有代码。


3826
02:18:14,186 --> 02:18:15,175
所以我们要打印出来


3827
02:18:15,205 --> 02:18:15,625
我


3828
02:18:15,655 --> 02:18:16,975
它的值是1


3829
02:18:17,574 --> 02:18:18,175
然后我们要


3830
02:18:18,205 --> 02:18:19,015
加

3831
02:18:19,045 --> 02:18:21,386
现在我要从一个开始


3832
02:18:21,416 --> 02:18:22,166
两个人。


3833
02:18:22,616 --> 02:18:23,876
现在我们要做的

3834
02:18:24,116 --> 02:18:26,396
我们会一直到这里


3835
02:18:26,426 --> 02:18:27,565
在这个while循环中


3836
02:18:27,865 --> 02:18:30,086
声明，我们会检查条件


3837
02:18:30,116 --> 02:18:30,776
再一次。


3838
02:18:31,526 --> 02:18:33,086
记住，我检查了条件


3839
02:18:33,116 --> 02:18:33,776
第一次


3840
02:18:33,807 --> 02:18:35,188
然后我把所有的代码都圈了出来，


3841
02:18:35,338 --> 02:18:36,987
然后再回到顶部


3842
02:18:37,018 --> 02:18:38,729
我再检查一遍，所以我想说


3843
02:18:38,760 --> 02:18:39,149
好的


3844
02:18:39,510 --> 02:18:41,460
I小于或等于10


3845
02:18:41,880 --> 02:18:42,839
在这一点上


3846
02:18:42,959 --> 02:18:44,069
I等于2


3847
02:18:44,459 --> 02:18:46,168
所以我小于或等于承租人。


3848
02:18:46,498 --> 02:18:48,147
现在我们要讲的是


3849
02:18:48,178 --> 02:18:50,217
再次执行所有这些代码，所以我要


3850
02:18:50,247 --> 02:18:50,787
打印输出


3851
02:18:50,817 --> 02:18:52,106
我也会这么做的


3852
02:18:52,496 --> 02:18:53,847
我要把它加到眼睛里


3853
02:18:53,877 --> 02:18:55,076
现在我们有三个


3854
02:18:55,616 --> 02:18:56,066
然后


3855
02:18:56,097 --> 02:18:58,677
python会一直走到最顶端


3856
02:18:58,707 --> 02:18:59,607
它会检查


3857
02:18:59,667 --> 02:19:01,018
再一次的情况


3858
02:19:01,287 --> 02:19:01,797
所以


3859
02:19:02,037 --> 02:19:03,988
在循环的每个迭代中


3860
02:19:04,019 --> 02:19:05,278
在python之前


3861
02:19:05,368 --> 02:19:06,957
在这个循环中


3862
02:19:06,987 --> 02:19:08,427
它会检查这个条件。


3863
02:19:08,937 --> 02:19:11,307
只要条件仍然是正确的。


3864
02:19:11,366 --> 02:19:11,877
我们要


3865
02:19:11,907 --> 02:19:13,886
继续执行循环内的代码


3866
02:19:14,366 --> 02:19:15,896
最终在这个项目中


3867
02:19:15,956 --> 02:19:18,057
我将会是11


3868
02:19:18,326 --> 02:19:18,716
对的


3869
02:19:18,806 --> 02:19:19,615
所以我是最后一个


3870
02:19:19,646 --> 02:19:21,806
迭代，最终会成为莱文，


3871
02:19:22,075 --> 02:19:23,455
我们要回到这里，


3872
02:19:23,635 --> 02:19:24,504
我们会说


3873
02:19:24,534 --> 02:19:24,895
哼声


3874
02:19:24,925 --> 02:19:26,726
是11小于等于10


3875
02:19:27,025 --> 02:19:27,535
没有


3876
02:19:27,955 --> 02:19:29,245
所以说，这是不可能的


3877
02:19:29,275 --> 02:19:30,386
我们要到这里来


3878
02:19:30,416 --> 02:19:35,785
我们会用循环线打印出来这就是这些牛羚如何工作的基础


3879
02:19:36,085 --> 02:19:38,156
我们指定了一个循环条件。


3880
02:19:38,396 --> 02:19:40,106
只要条件是正确的


3881
02:19:40,376 --> 02:19:41,875
将继续执行代码


3882
02:19:41,905 --> 02:19:43,046
在这个循环中，


3883
02:19:43,226 --> 02:19:45,385
在每次执行循环之后，


3884
02:19:45,444 --> 02:19:47,635
我们会再回来检查一下这个情况


3885
02:19:47,904 --> 02:19:49,613
这就是我们最终的结果


3886
02:19:49,644 --> 02:19:50,424
这个。


3887
02:19:50,574 --> 02:19:51,444
打印输出


3888
02:19:51,475 --> 02:19:52,195
在下面，


3889
02:19:52,646 --> 02:19:53,785
这就是基本原理


3890
02:19:53,815 --> 02:19:54,176
在


3891
02:19:54,206 --> 02:19:54,866
a while循环


3892
02:19:54,896 --> 02:19:55,286
并且


3893
02:19:55,946 --> 02:19:57,387
我们可以用这些卷来做


3894
02:19:57,417 --> 02:20:00,806
各种各样的东西，比如野生水果都是非常强大的


3895
02:20:04,706 --> 02:20:07,587
在本教程中，他将研究如何构建一个基本的


3896
02:20:07,617 --> 02:20:09,387
用python猜游戏，


3897
02:20:09,896 --> 02:20:15,090
在这个猜谜游戏中我们将会使用各种各样的很酷的编程结构


3898
02:20:15,120 --> 02:20:16,859
在课程中学习到这一点。


3899
02:20:17,159 --> 02:20:18,539
所以我们要用的是


3900
02:20:18,599 --> 02:20:21,208
如果语句，疯狂循环和变量


3901
02:20:21,268 --> 02:20:22,258
所有这些很酷的东西


3902
02:20:22,588 --> 02:20:24,537
为了建立这个游戏，


3903
02:20:24,597 --> 02:20:28,437
基本的想法是，我们将指定一个秘密的单词。


3904
02:20:28,677 --> 02:20:31,707
所以我们会在程序中存储一个秘密的词


3905
02:20:32,127 --> 02:20:35,428
然后用户可以与程序进行交互并尝试猜测


3906
02:20:35,458 --> 02:20:36,509
这个秘密的词。


3907
02:20:36,839 --> 02:20:41,038
所以我们想要发生的是我们希望用户能够继续猜测


3908
02:20:41,068 --> 02:20:44,188
它的秘密是什么，并继续输入不同的响应。


3909
02:20:44,607 --> 02:20:46,947
直到他们得到了这个秘密。


3910
02:20:47,188 --> 02:20:48,358
这就是基本原理


3911
02:20:48,389 --> 02:20:50,158
这个游戏将会是怎样的。


3912
02:20:50,668 --> 02:20:51,088
并且


3913
02:20:51,118 --> 02:20:54,449
现在让我们来创建它我们首先要做的是


3914
02:20:54,479 --> 02:20:57,871
创建一个变量来存储我们的秘密单词。


3915
02:20:58,171 --> 02:20:59,220
所以我可以说


3916
02:20:59,399 --> 02:21:00,119
秘密的


3917
02:21:00,149 --> 02:21:00,779
字。


3918
02:21:01,199 --> 02:21:04,920
我们要把这个设为一个秘密的单词为什么我们不把它写成草稿呢？


3919
02:21:04,979 --> 02:21:06,149
这是个很好的秘密。


3920
02:21:06,899 --> 02:21:10,859
现在我们要做的是创建一个变量来存储


3921
02:21:10,890 --> 02:21:12,750
用户的响应


3922
02:21:13,020 --> 02:21:15,931
我想要一个能像所有猜测一样存储的变量


3923
02:21:15,961 --> 02:21:17,131
用户做的


3924
02:21:17,161 --> 02:21:18,062
所以我要


3925
02:21:18,093 --> 02:21:18,813
叫这个


3926
02:21:18,873 --> 02:21:19,653
猜测


3927
02:21:20,463 --> 02:21:21,062
我要设置它


3928
02:21:21,093 --> 02:21:23,312
现在等于一个空字符串。


3929
02:21:23,433 --> 02:21:23,793
所以


3930
02:21:23,823 --> 02:21:25,202
现在我们有一个秘密的词


3931
02:21:25,232 --> 02:21:25,893
我们有


3932
02:21:25,923 --> 02:21:28,744
用于存储用户猜测的变量


3933
02:21:29,014 --> 02:21:31,473
我们需要做的是，我们需要能够提示


3934
02:21:31,503 --> 02:21:32,343
用户


3935
02:21:32,493 --> 02:21:33,933
输入这个秘密是。


3936
02:21:34,383 --> 02:21:35,612
但这里有个陷阱。


3937
02:21:36,032 --> 02:21:39,331
我们想要的是，我们想让他们输入这个秘密的单词。


3938
02:21:39,571 --> 02:21:41,671
如果他们猜错了


3939
02:21:41,701 --> 02:21:44,072
我们想让他们再次进入。


3940
02:21:44,553 --> 02:21:47,162
所以我们不能只使用一个


3941
02:21:47,192 --> 02:21:49,593
输入语句我们实际上必须使用


3942
02:21:49,772 --> 02:21:51,482
一个叫做while循环的东西。


3943
02:21:51,843 --> 02:21:53,251
我们可以使用while循环


3944
02:21:53,281 --> 02:21:56,161
为了不断地问这个人


3945
02:21:56,341 --> 02:21:57,361
猜出这个词


3946
02:21:57,541 --> 02:21:59,371
直到他们猜对了为止。


3947
02:21:59,791 --> 02:22:03,060
让我们继续创建while循环语句，我将写入while循环语句


3948
02:22:03,449 --> 02:22:03,810
并且


3949
02:22:03,899 --> 02:22:08,879
一段时间后，我需要指定一个循环条件或一个循环警卫。


3950
02:22:09,209 --> 02:22:10,709
基本上这是


3951
02:22:10,739 --> 02:22:12,449
只要这是真的


3952
02:22:12,479 --> 02:22:14,431
我们会一直循环下去


3953
02:22:14,490 --> 02:22:15,061
这个循环。


3954
02:22:15,301 --> 02:22:17,131
所以基本上我想说


3955
02:22:17,161 --> 02:22:19,382
我想一直循环下去


3956
02:22:19,622 --> 02:22:21,092
用户的气体


3957
02:22:21,242 --> 02:22:22,772
不等于


3958
02:22:23,223 --> 02:22:24,304
这个秘密的词。


3959
02:22:24,604 --> 02:22:26,674
所以只要他们还没有猜到


3960
02:22:28,114 --> 02:22:30,214
我将继续这个循环，


3961
02:22:30,634 --> 02:22:32,194
在这个循环里。


3962
02:22:32,314 --> 02:22:35,796
我们要做的是让他们输入这个秘密的单词


3963
02:22:36,246 --> 02:22:37,415
所以我可以接受这个


3964
02:22:37,445 --> 02:22:38,795
气体变量


3965
02:22:39,035 --> 02:22:39,995
我可以设置它


3966
02:22:40,025 --> 02:22:40,865
等于


3967
02:22:41,436 --> 02:22:42,155
输入。


3968
02:22:42,995 --> 02:22:44,016
我只是想说。


3969
02:22:44,586 --> 02:22:45,276
进入


3970
02:22:45,517 --> 02:22:46,207
猜猜看。


3971
02:22:47,438 --> 02:22:51,518
在这里，我们基本上是告诉用户进入他们的客人。


3972
02:22:51,938 --> 02:22:54,008
无论什么时候输入，我都在存储


3973
02:22:54,248 --> 02:22:55,808
在这个猜测中


3974
02:22:55,867 --> 02:22:56,707
变量


3975
02:22:57,007 --> 02:22:59,467
接下来会发生的是我们会回到这里


3976
02:22:59,677 --> 02:23:00,066
我们要


3977
02:23:00,097 --> 02:23:01,508
检查是否有气体


3978
02:23:01,538 --> 02:23:03,158
等于这个秘密的词


3979
02:23:03,578 --> 02:23:04,179
如果客人


3980
02:23:04,209 --> 02:23:05,708
不等于这个秘密的词，


3981
02:23:05,888 --> 02:23:06,997
然后我们再做一次。


3982
02:23:07,567 --> 02:23:08,617
但是

3983
02:23:08,647 --> 02:23:10,087
等于这个秘密的单词，


3984
02:23:10,146 --> 02:23:11,436
然后我们就会中断


3985
02:23:11,466 --> 02:23:12,485
从这个循环中。


3986
02:23:13,205 --> 02:23:14,945
所以我们可以到这里来


3987
02:23:15,815 --> 02:23:17,225
我们可以打印出来


3988
02:23:17,675 --> 02:23:19,445
一个成功的信息，所以我可以说


3989
02:23:19,806 --> 02:23:20,616
你赢了


3990
02:23:20,946 --> 02:23:22,746
因为他们得到了秘密


3991
02:23:23,016 --> 02:23:25,086
因为他们有非常简单的程序


3992
02:23:25,956 --> 02:23:30,037
这基本上就是我们需要的所有代码来构建一个游戏


3993
02:23:30,067 --> 02:23:31,117
就像这样


3994
02:23:31,297 --> 02:23:33,877
让我们继续玩我们的游戏我们可以运行它


3995
02:23:33,907 --> 02:23:35,617
看看他是怎么做的，我要


3996
02:23:35,647 --> 02:23:36,397
点击播放。


3997
02:23:37,298 --> 02:23:42,067
在这里你可以看到它提示我们输入一个客人所以我要输入一些


3998
02:23:42,098 --> 02:23:43,238
你知道随机文本


3999
02:23:43,568 --> 02:23:44,888
我们可以输入你想要的任何东西。


4000
02:23:45,218 --> 02:23:49,867
只要我们不进入那个秘密的词它就会不断地提示我们


4001
02:23:49,897 --> 02:23:51,607
输入不同的信息。


4002
02:23:52,058 --> 02:23:52,567
但是


4003
02:23:52,598 --> 02:23:54,066
如果我输入这个秘密的词


4004
02:23:54,097 --> 02:23:55,416
所以如果我输入了草稿。


4005
02:23:55,986 --> 02:23:56,526
现在


4006
02:23:56,586 --> 02:23:59,467
突然间，程序可以终止，它会说，


4007
02:23:59,677 --> 02:24:00,066
嘿


4008
02:24:00,097 --> 02:24:00,757
你赢了


4009
02:24:01,057 --> 02:24:02,857
因为我们可以猜测


4010
02:24:02,917 --> 02:24:03,847
这个秘密的词。


4011
02:24:04,087 --> 02:24:04,807
这就像


4012
02:24:04,866 --> 02:24:07,807
这是一个很酷的方法，让我们能够做到这一点。


4013
02:24:07,957 --> 02:24:10,927
我们实际上有一个功能齐全的猜谜游戏。


4014
02:24:12,246 --> 02:24:16,116
我认为这个猜谜游戏实际上可以有很大的改进。


4015
02:24:16,446 --> 02:24:18,006
很多时候


4016
02:24:18,036 --> 02:24:20,736
我们在做一个猜谜游戏我们想设定一个极限


4017
02:24:20,767 --> 02:24:23,347
换句话说，我想设定一个极限


4018
02:24:23,497 --> 02:24:26,498
用户可以尝试猜测单词的次数。


4019
02:24:26,918 --> 02:24:28,509
假设用户有


4020
02:24:28,539 --> 02:24:31,868
三次尝试，他们有三个猜测，以便猜出这个单词。


4021
02:24:32,168 --> 02:24:34,628
如果他们在三次尝试后都猜不出这个词。


4022
02:24:34,838 --> 02:24:36,278
然后他们就会输掉这场比赛。


4023
02:24:36,519 --> 02:24:36,938
但是


4024
02:24:37,028 --> 02:24:38,048
如果他们能猜出这个词


4025
02:24:38,078 --> 02:24:39,697
在三次尝试中


4026
02:24:39,728 --> 02:24:40,987
他们将会赢得这场比赛。


4027
02:24:41,197 --> 02:24:44,346
我认为这将会是一个有趣的游戏


4028
02:24:44,376 --> 02:24:45,666
我们为什么不试着编程


4029
02:24:45,696 --> 02:24:46,446
那个游戏，


4030
02:24:46,716 --> 02:24:48,726
基本上，我们要设置一个极限


4031
02:24:48,966 --> 02:24:49,596
关于


4032
02:24:49,626 --> 02:24:50,286
猜测


4033
02:24:50,316 --> 02:24:51,756
用户可以拥有


4034
02:24:51,996 --> 02:24:57,096
为了做到这一点，我们需要在下面再创建几个变量。


4035
02:24:57,396 --> 02:24:57,995
换句话说


4036
02:24:58,025 --> 02:25:01,054
我们还需要存储更多的信息。


4037
02:25:01,504 --> 02:25:04,294
我想要记录的第一个信息是


4038
02:25:04,474 --> 02:25:06,063
有多少次用户


4039
02:25:06,094 --> 02:25:07,174
已经猜到了


4040
02:25:07,264 --> 02:25:07,653
对，


4041
02:25:07,894 --> 02:25:10,234
所以我们可以创建一个变量叫做来宾


4042
02:25:10,265 --> 02:25:10,774
曹


4043
02:25:11,164 --> 02:25:13,653
我们把这个设为零因为一开始


4044
02:25:13,983 --> 02:25:15,033
用户不会有


4045
02:25:15,063 --> 02:25:15,634
客人


4046
02:25:15,784 --> 02:25:17,434
在这个while循环中。


4047
02:25:17,644 --> 02:25:19,833
每次我们经过这个循环，


4048
02:25:20,253 --> 02:25:22,263
我想增加气体的量


4049
02:25:22,743 --> 02:25:24,963
每次我们经过这个while循环时都要这样写


4050
02:25:24,993 --> 02:25:25,593
我想


4051
02:25:25,623 --> 02:25:27,452
增加计数，因为这意味着


4052
02:25:27,632 --> 02:25:29,252
用户可能

4053
02:25:29,552 --> 02:25:31,262
下面我要说的是。


4054
02:25:31,712 --> 02:25:32,252
猜测


4055
02:25:32,282 --> 02:25:32,792
计数


4056
02:25:34,382 --> 02:25:34,892
加上


4057
02:25:34,922 --> 02:25:36,062
等于1


4058
02:25:36,302 --> 02:25:37,473
这是要添加的


4059
02:25:37,503 --> 02:25:39,812
一个到垫圈实际上是鞭子。


4060
02:25:41,191 --> 02:25:41,611
所以


4061
02:25:42,092 --> 02:25:45,812
在这个循环的每次迭代之后我们将继续添加一个


4062
02:25:45,843 --> 02:25:46,953
到气体

4063
02:25:47,104 --> 02:25:50,374
这是我们要用到的第一个变量我们也想要


4064
02:25:50,434 --> 02:25:52,383
存储另一个变量


4065
02:25:52,413 --> 02:25:54,273
这将被称为

4066
02:25:54,304 --> 02:25:54,903
极限


4067
02:25:55,233 --> 02:26:01,145
基本上，这将告诉我们用户能猜出多少次它将会是客人


4068
02:26:02,284 --> 02:26:02,794
并且


4069
02:26:03,334 --> 02:26:06,995
基本上只说3个假设用户有三个尝试


4070
02:26:07,205 --> 02:26:09,935
猜出三振出局，你就出局了


4071
02:26:10,564 --> 02:26:13,025
如果用户不能在三次尝试中得到它


4072
02:26:13,056 --> 02:26:13,565
然后


4073
02:26:13,596 --> 02:26:14,046
我们要


4074
02:26:14,076 --> 02:26:15,968
基本上说他们输了这场比赛。


4075
02:26:16,208 --> 02:26:18,428
我还需要一个


4076
02:26:18,487 --> 02:26:19,837
这里有变量，


4077
02:26:20,317 --> 02:26:20,647
哪个


4078
02:26:20,678 --> 02:26:21,428
我们会打电话给


4079
02:26:21,458 --> 02:26:21,938
外出


4080
02:26:22,419 --> 02:26:22,959
在


4081
02:26:23,649 --> 02:26:24,399
气体。


4082
02:26:25,180 --> 02:26:27,850
我先把它设为false。


4083
02:26:28,119 --> 02:26:28,629
所以这个


4084
02:26:28,659 --> 02:26:31,300
气体变量是一个布尔值。


4085
02:26:31,540 --> 02:26:34,780
它会告诉我们用户是否已经脱离了

4086
02:26:34,990 --> 02:26:36,790
所以如果气体是真实的


4087
02:26:36,820 --> 02:26:40,239
这意味着他们没有更多的猜测他们基本上输掉了比赛


4088
02:26:40,810 --> 02:26:42,039
如果没有猜测


4089
02:26:42,099 --> 02:26:46,601
这是假的，这意味着他们仍然有一些猜测，所以他们可以继续玩。


4090
02:26:47,320 --> 02:26:50,711
让我们用这些不同的变量来做


4091
02:26:50,741 --> 02:26:52,871
使我们的程序或功能


4092
02:26:53,381 --> 02:26:55,151
我要做的第一件事是


4093
02:26:55,722 --> 02:26:57,281
当我经过这个循环。


4094
02:26:57,371 --> 02:27:00,911
我想检查一下，确保用户有更多的猜测，


4095
02:27:01,301 --> 02:27:01,661
对的


4096
02:27:01,871 --> 02:27:04,363
换句话说，在我让用户


4097
02:27:04,394 --> 02:27:05,563
进入喘息。


4098
02:27:05,833 --> 02:27:09,401
我想检查一下，他们还没有把所有的猜测都用完。


4099
02:27:09,701 --> 02:27:10,691
下面这里


4100
02:27:10,722 --> 02:27:12,281
我可以做一个if语句，我可以说


4101
02:27:12,312 --> 02:27:12,792
如果


4102
02:27:13,302 --> 02:27:15,972
在这种情况下，我想检查一下


4103
02:27:16,302 --> 02:27:16,901
猜测


4104
02:27:16,961 --> 02:27:17,501
计数


4105
02:27:18,611 --> 02:27:19,751
更少


4106
02:27:21,041 --> 02:27:21,551
极限


4107
02:27:22,661 --> 02:27:25,031
如果气体的计数小于猜测的极限。


4108
02:27:25,301 --> 02:27:26,651
这意味着他们没有


4109
02:27:27,371 --> 02:27:27,761
那


4110
02:27:27,791 --> 02:27:31,333
他们有猜测的总数，所以他们有一些猜测。


4111
02:27:31,873 --> 02:27:32,263
并且


4112
02:27:32,293 --> 02:27:34,212
如果是这样的话，如果这是真的，


4113
02:27:34,602 --> 02:27:36,282
然后我要继续


4114
02:27:37,572 --> 02:27:40,094
给他们一个猜测，然后我们会增加客人数量。


4115
02:27:40,724 --> 02:27:43,153
如果这不是真的，换句话说，


4116
02:27:43,213 --> 02:27:43,992
如果他们


4117
02:27:44,022 --> 02:27:45,763
已经达到了客人的极限，


4118
02:27:46,213 --> 02:27:47,593
然后我要设置


4119
02:27:47,652 --> 02:27:48,162
外出


4120
02:27:48,492 --> 02:27:48,973
在


4121
02:27:49,423 --> 02:27:50,232
猜测


4122
02:27:50,652 --> 02:27:51,373
等于


4123
02:27:51,403 --> 02:27:51,974
真实的


4124
02:27:52,334 --> 02:27:55,153
因为有猜测，他们没有更多的猜测，因为


4125
02:27:55,333 --> 02:27:58,005
煤气的数量不少于客人的限额。


4126
02:27:58,425 --> 02:28:01,334
这就意味着有两种气体，所以它们没有更多的气体。


4127
02:28:01,394 --> 02:28:02,473
所以实际上


4128
02:28:02,683 --> 02:28:05,023
在这个while循环中我们还需要做一件事


4129
02:28:05,054 --> 02:28:05,863
我们需要


4130
02:28:05,894 --> 02:28:07,333
添加另一个条件


4131
02:28:07,603 --> 02:28:08,863
在这个环卫上。


4132
02:28:09,104 --> 02:28:12,283
所以现在我们要保持循环，只要客人


4133
02:28:12,313 --> 02:28:14,113
不等于这个秘密的词


4134
02:28:14,533 --> 02:28:15,674
但是请记住


4135
02:28:15,914 --> 02:28:20,175
如果用户用气体换句话说，如果他们达到了气体极限


4136
02:28:20,505 --> 02:28:22,185
我们不想让他们再猜了，


4137
02:28:22,274 --> 02:28:24,283
所以如果他们用完了汽油


4138
02:28:24,493 --> 02:28:28,603
我们想要打破这个循环，不再给他们

4139
02:28:28,633 --> 02:28:30,941
我要在这里

4140
02:28:31,331 --> 02:28:32,230
我想说


4141
02:28:32,320 --> 02:28:32,801
哇


4142
02:28:32,831 --> 02:28:34,722
他们没有猜出这个秘密的词


4143
02:28:34,781 --> 02:28:35,411
并且


4144
02:28:35,471 --> 02:28:36,610
他们不是


4145
02:28:37,120 --> 02:28:37,660
外出


4146
02:28:38,021 --> 02:28:40,061
气体，所以它不会


4147
02:28:41,261 --> 02:28:42,011
在


4148
02:28:42,221 --> 02:28:43,001
猜测，


4149
02:28:43,661 --> 02:28:44,291
然后


4150
02:28:44,891 --> 02:28:50,920
我们会一直循环下去只要他们还没猜出这个词只要他们还能猜出一些猜测我们就会一直循环下去


4151
02:28:51,010 --> 02:28:51,460
但是


4152
02:28:51,940 --> 02:28:52,750
否则


4153
02:28:52,780 --> 02:28:54,011
我们要跳出这个循环。


4154
02:28:54,280 --> 02:28:55,571
下面这里


4155
02:28:55,812 --> 02:28:57,672
我们打印出来你赢了，


4156
02:28:58,122 --> 02:29:00,792
但实际上，当我们跳出这个循环时，


4157
02:29:00,852 --> 02:29:02,021
会有两个


4158
02:29:02,051 --> 02:29:03,461
可能的场景。


4159
02:29:03,671 --> 02:29:04,331
所以，


4160
02:29:04,541 --> 02:29:07,780
这个循环有两种可能的方式


4161
02:29:08,050 --> 02:29:10,210
要么是气体等于这个秘密的词。


4162
02:29:10,420 --> 02:29:13,060
因此，无论是正确的用户，


4163
02:29:13,359 --> 02:29:14,050
或者


4164
02:29:14,109 --> 02:29:16,180
用户的猜测没有了


4165
02:29:16,479 --> 02:29:17,020
所以


4166
02:29:17,199 --> 02:29:19,238
这里有两种情况


4167
02:29:19,479 --> 02:29:20,769
这是我们需要考虑的。


4168
02:29:21,129 --> 02:29:23,348
所以我要用if语句来算出


4169
02:29:23,438 --> 02:29:23,857
哪个


4170
02:29:23,888 --> 02:29:24,967
我想说的是


4171
02:29:24,997 --> 02:29:25,507
如果。


4172
02:29:25,927 --> 02:29:26,856
我们会说，


4173
02:29:26,946 --> 02:29:27,456
外出


4174
02:29:27,876 --> 02:29:28,476
在


4175
02:29:28,716 --> 02:29:29,525
气体，


4176
02:29:30,726 --> 02:29:31,115
而且，


4177
02:29:31,175 --> 02:29:32,796
如果用户没有猜测


4178
02:29:32,826 --> 02:29:33,845
我想要打印，


4179
02:29:36,545 --> 02:29:37,385
你输了


4180
02:29:37,415 --> 02:29:38,494
所以我们基本上会像


4181
02:29:38,524 --> 02:29:39,574
你输了这场比赛。


4182
02:29:40,324 --> 02:29:41,435
尽管如此


4183
02:29:41,494 --> 02:29:42,154
如果他们不是


4184
02:29:42,185 --> 02:29:43,294
不受气体的影响。


4185
02:29:43,534 --> 02:29:45,845
这意味着他们猜对了这个词


4186
02:29:45,875 --> 02:29:46,955
所以我们要念出


4187
02:29:46,985 --> 02:29:47,525
你赢了。


4188
02:29:48,695 --> 02:29:52,535
好了，现在我们有了这个小猜谜游戏的所有逻辑


4189
02:29:52,565 --> 02:29:55,534
让我们看看能不能运行它，然后播放它


4190
02:29:56,374 --> 02:29:57,755
我要运行这个程序。


4191
02:29:58,564 --> 02:30:00,635
现在它会告诉我们要输入一个猜测


4192
02:30:00,665 --> 02:30:01,835
我们为什么不呢


4193
02:30:01,895 --> 02:30:05,944
输入更多的猜测，所以我们会尝试输掉比赛所以我要输入一个气体


4194
02:30:06,274 --> 02:30:07,114
两个猜测。


4195
02:30:07,324 --> 02:30:10,805
现在我要做最后的猜测了，如果我不把它弄到这里，


4196
02:30:11,135 --> 02:30:12,725
我们应该输掉这场比赛。


4197
02:30:13,295 --> 02:30:14,435
你可以看到它说


4198
02:30:14,465 --> 02:30:15,995
在猜测中你输了。


4199
02:30:16,115 --> 02:30:17,766
所以我们可以猜出来


4200
02:30:17,796 --> 02:30:19,716
在我们所做的试验的数量上。


4201
02:30:20,346 --> 02:30:21,636
让我们再次运行这个程序


4202
02:30:21,666 --> 02:30:23,046
我们将努力赢得这场比赛。


4203
02:30:23,105 --> 02:30:23,766
所以


4204
02:30:23,825 --> 02:30:25,114
我们会犯一些错误。


4205
02:30:25,475 --> 02:30:27,456
假设我们在最后一个气体上，不像


4206
02:30:27,486 --> 02:30:28,777
好的，我可以这样做


4207
02:30:29,107 --> 02:30:30,817
所以我输入了这个单词


4208
02:30:31,087 --> 02:30:31,687
砰


4209
02:30:31,717 --> 02:30:33,066
我们赢了这场比赛，


4210
02:30:33,876 --> 02:30:36,516
这就是我们可以创建一个游戏的方式


4211
02:30:36,546 --> 02:30:37,536
猜测限度


4212
02:30:38,557 --> 02:30:39,605
这是很多代码


4213
02:30:39,636 --> 02:30:41,885
让我再给你们讲一遍这个问题


4214
02:30:41,915 --> 02:30:44,555
所以你可以完全理解我们在做什么


4215
02:30:45,064 --> 02:30:47,434
上面这里我创建了几个不同的变量


4216
02:30:47,464 --> 02:30:49,504
我们创建了这个秘密的单词变量


4217
02:30:49,714 --> 02:30:51,574
我们创建了这个来宾变量。


4218
02:30:52,024 --> 02:30:52,624
然后


4219
02:30:52,894 --> 02:30:54,124
我们也创造了


4220
02:30:54,154 --> 02:30:56,405
还有一些变量，所以我们创建了这个客户


4221
02:30:56,436 --> 02:30:57,455
count变量。


4222
02:30:57,725 --> 02:31:00,935
这就记录了用户有多少次


4223
02:31:01,085 --> 02:31:01,745
猜测


4224
02:31:01,805 --> 02:31:02,495
这个词。


4225
02:31:02,825 --> 02:31:04,296
你可以看到这里。


4226
02:31:04,656 --> 02:31:05,557
每一次


4227
02:31:05,587 --> 02:31:07,086
我们给他们一个气体


4228
02:31:07,956 --> 02:31:08,946
是递增的


4229
02:31:08,977 --> 02:31:09,727
客人数。


4230
02:31:10,536 --> 02:31:11,706
我们也有客人


4231
02:31:11,736 --> 02:31:12,276
极限


4232
02:31:12,576 --> 02:31:16,688
气体限制告诉程序用户可以猜多少次。


4233
02:31:17,197 --> 02:31:22,178
在我讲这个while循环之前我要做的第一件事就是查看客人的情况


4234
02:31:22,208 --> 02:31:22,718
计数


4235
02:31:23,048 --> 02:31:24,487
比客人的限制少。


4236
02:31:24,787 --> 02:31:25,628
换句话说


4237
02:31:25,778 --> 02:31:27,759
他们仍然有一些

4238
02:31:27,789 --> 02:31:28,389
左边的


4239
02:31:28,599 --> 02:31:29,679
如果他们这样做了，


4240
02:31:30,009 --> 02:31:32,169
然后我们会从用户那里得到输入。


4241
02:31:32,559 --> 02:31:33,639
否则，


4242
02:31:33,698 --> 02:31:34,388
我们有这个


4243
02:31:34,418 --> 02:31:36,158
这里的其他变量叫做


4244
02:31:36,188 --> 02:31:37,328
废气


4245
02:31:37,628 --> 02:31:41,347
气体的流出会告诉我们它们是否有一些猜测。


4246
02:31:41,707 --> 02:31:43,237
所以这等于假。


4247
02:31:43,297 --> 02:31:45,037
这意味着他们有一些猜测，


4248
02:31:45,397 --> 02:31:47,648
如果它等于真，那么它的意思是


4249
02:31:47,979 --> 02:31:48,849
不再掷骰子


4250
02:31:48,879 --> 02:31:50,889
不再猜测他们已经完成了


4251
02:31:50,919 --> 02:31:52,059
所以他们输了这场比赛。


4252
02:31:52,479 --> 02:31:56,558
我们要做的最后一件事是在上面指定一个额外的条件。


4253
02:31:57,038 --> 02:31:57,488
所以


4254
02:31:57,519 --> 02:31:59,708
我们将继续循环遍历代码


4255
02:31:59,738 --> 02:32:01,028
在这个循环中，


4256
02:32:01,418 --> 02:32:03,878
只要上面的条件


4257
02:32:04,088 --> 02:32:04,808
是真的。


4258
02:32:05,527 --> 02:32:07,928
所以只要他们还没有猜出这个词。


4259
02:32:08,408 --> 02:32:08,979
并且


4260
02:32:09,248 --> 02:32:10,598
只要他们不这么做


4261
02:32:10,657 --> 02:32:11,978
出于猜测。


4262
02:32:12,487 --> 02:32:13,718
我们将继续


4263
02:32:13,748 --> 02:32:14,978
循环。


4264
02:32:16,027 --> 02:32:18,697
当最终用户从这个循环中跳出来的时候，


4265
02:32:18,817 --> 02:32:23,319
有两种可能的情况第一种情况是他们的猜测没有了


4266
02:32:23,350 --> 02:32:26,048
所以我们要检查一下是否有这种情况。


4267
02:32:26,408 --> 02:32:28,479
我想看看他们是不是猜不出来。


4268
02:32:28,748 --> 02:32:29,498
如果他们是


4269
02:32:29,528 --> 02:32:31,089
会打印出一条丢失的信息，


4270
02:32:31,299 --> 02:32:32,079
如果不是，


4271
02:32:32,289 --> 02:32:34,208
那么他们一定是猜对了


4272
02:32:34,268 --> 02:32:34,778
他们赢了。


4273
02:32:34,929 --> 02:32:37,149
这就是我们如何在while循环中使用的方法


4274
02:32:37,600 --> 02:32:38,319
if语句


4275
02:32:38,350 --> 02:32:39,400
还有变量


4276
02:32:39,610 --> 02:32:42,762
相互结合，建立一个非常棒的


4277
02:32:42,792 --> 02:32:43,542
猜谜游戏


4278
02:32:47,922 --> 02:32:50,384
在本教程中，我们将使用


4279
02:32:50,414 --> 02:32:52,395
在python中for

4280
02:32:52,814 --> 02:32:53,654
现在是for循环


4281
02:32:53,685 --> 02:32:57,256
是python中的一种特殊类型的循环，它允许我们


4282
02:32:57,286 --> 02:33:00,076
对不同的集合进行循环


4283
02:33:00,376 --> 02:33:00,706
在


4284
02:33:00,736 --> 02:33:01,276
项目。


4285
02:33:01,517 --> 02:33:06,194
所以很多时候会在python中使用for循环来遍历不同的数组


4286
02:33:06,464 --> 02:33:07,185
或者我们可以循环


4287
02:33:07,215 --> 02:33:10,034
就像字符串里面的字母一样


4288
02:33:10,214 --> 02:33:11,504
我们可以像这样循环


4289
02:33:11,534 --> 02:33:11,864
a


4290
02:33:12,194 --> 02:33:13,455
一系列数字


4291
02:33:13,635 --> 02:33:16,453
因此，生命提供了一个非常具体的目的。


4292
02:33:16,663 --> 02:33:18,973
最简单的方法就是把你的头围起来


4293
02:33:19,003 --> 02:33:21,372
为什么有四种生命是有用的，就像我给你们展示的那样


4294
02:33:21,672 --> 02:33:23,021
有很多不同的例子


4295
02:33:23,052 --> 02:33:24,672
这就是我要做的，


4296
02:33:25,062 --> 02:33:29,291
我们来看看为什么有四种生命是如此的令人敬畏


4297
02:33:29,561 --> 02:33:30,790
文本文件和我的

4298
02:33:30,820 --> 02:33:31,751
python文件。


4299
02:33:31,841 --> 02:33:33,160
我要写一些不同的东西


4300
02:33:33,190 --> 02:33:33,851
为了生活。


4301
02:33:34,271 --> 02:33:35,740
我们创建for循环的方式


4302
02:33:35,771 --> 02:33:37,270
仅仅是说4个。


4303
02:33:37,930 --> 02:33:40,749
现在我要做的是指定


4304
02:33:41,229 --> 02:33:42,189
变量


4305
02:33:42,609 --> 02:33:44,979
这个变量将会


4306
02:33:45,009 --> 02:33:46,239
本质上代表


4307
02:33:46,720 --> 02:33:48,100
不同值


4308
02:33:48,489 --> 02:33:51,250
每次我们通过这个for循环


4309
02:33:51,520 --> 02:33:52,539
你们会看到


4310
02:33:52,569 --> 02:33:56,109
它是如何工作的但是只要知道这个变量会


4311
02:33:56,319 --> 02:33:58,390
在每次迭代中使用


4312
02:33:58,420 --> 02:33:59,410
在我们的for循环中，


4313
02:33:59,860 --> 02:34:00,221
并且


4314
02:34:00,251 --> 02:34:01,031
每一次


4315
02:34:01,062 --> 02:34:03,221
它很可能会有不同的


4316
02:34:03,251 --> 02:34:04,211
价值


4317
02:34:04,811 --> 02:34:06,849
在我们的例子中，我将调用这封信。


4318
02:34:07,059 --> 02:34:08,889
我要保存四个字母


4319
02:34:09,278 --> 02:34:09,908
客栈。


4320
02:34:10,628 --> 02:34:13,326
现在我要做的是，我要指定


4321
02:34:13,356 --> 02:34:14,377
收集


4322
02:34:14,407 --> 02:34:15,728
我想要循环一下。


4323
02:34:15,938 --> 02:34:16,418
一


4324
02:34:16,478 --> 02:34:18,669
这个例子就像一个字符串


4325
02:34:18,699 --> 02:34:21,279
所以我可以在这里放一个字符串我可以把它写在草稿上


4326
02:34:21,640 --> 02:34:22,420
学院。


4327
02:34:22,990 --> 02:34:24,490
现在我可以放一个冒号


4328
02:34:24,760 --> 02:34:28,029
所以基本上这就是它的意思所以它会说


4329
02:34:28,089 --> 02:34:29,169
每封信


4330
02:34:29,499 --> 02:34:31,239
在学院的内部。


4331
02:34:31,569 --> 02:34:32,770
我想做点什么


4332
02:34:33,250 --> 02:34:35,800
在这个for循环里


4333
02:34:35,830 --> 02:34:37,630
同样，我们需要缩进


4334
02:34:38,500 --> 02:34:40,358
我们可以把我们想要的


4335
02:34:40,389 --> 02:34:45,158
每个字母，我给你们展示一下这是怎么做的我可以打印出来


4336
02:34:46,148 --> 02:34:48,817
我可以打印出这个字母变量。


4337
02:34:49,117 --> 02:34:52,056
它会打印出不同的字母


4338
02:34:52,086 --> 02:34:54,306
在这个dropoff学院的字符串里面


4339
02:34:54,575 --> 02:34:56,556
在每一次迭代中


4340
02:34:56,586 --> 02:34:57,665
在这个循环中。


4341
02:34:57,935 --> 02:34:58,415
所以


4342
02:34:58,445 --> 02:34:59,706
我要运行这个程序。


4343
02:35:00,576 --> 02:35:00,996
并且


4344
02:35:01,266 --> 02:35:05,347
在我的建议里你会发现我基本上是打印出来了


4345
02:35:05,646 --> 02:35:07,297
德拉夫学院


4346
02:35:07,566 --> 02:35:09,517
在循环的第一个迭代中。


4347
02:35:09,637 --> 02:35:13,026
我打印了学院的第一封信，那是g


4348
02:35:13,477 --> 02:35:15,097
在循环的第二个迭代中


4349
02:35:15,127 --> 02:35:15,847
我打印出来了


4350
02:35:15,906 --> 02:35:16,446
我


4351
02:35:16,626 --> 02:35:18,516
第三个是我们的第四个


4352
02:35:18,546 --> 02:35:18,936
a。


4353
02:35:19,774 --> 02:35:22,023
我只是循环遍历


4354
02:35:22,054 --> 02:35:23,224
所有的字母


4355
02:35:23,283 --> 02:35:24,062
在


4356
02:35:24,093 --> 02:35:25,113
德拉夫学院。


4357
02:35:25,503 --> 02:35:26,254
所以我说


4358
02:35:26,284 --> 02:35:27,004
为了


4359
02:35:27,034 --> 02:35:27,874
每一封信


4360
02:35:27,904 --> 02:35:29,165
在dropoff学院。


4361
02:35:29,345 --> 02:35:30,034
我想打印


4362
02:35:30,064 --> 02:35:30,364
外出


4363
02:35:30,395 --> 02:35:30,845
那


4364
02:35:30,875 --> 02:35:31,325
字母。


4365
02:35:31,625 --> 02:35:33,035
这有点像


4366
02:35:33,065 --> 02:35:36,395
如何使用循环我们可以定义一个变量


4367
02:35:36,755 --> 02:35:38,914
这个变量会改变


4368
02:35:39,094 --> 02:35:39,634
每一个


4369
02:35:39,664 --> 02:35:42,604
循环的迭代，在循环的第一个迭代中。


4370
02:35:42,904 --> 02:35:45,213
这个字母变量代表一个g。


4371
02:35:45,423 --> 02:35:46,952
在循环的第二个迭代中。


4372
02:35:47,162 --> 02:35:48,453
字母变量存储


4373
02:35:48,483 --> 02:35:49,054
价值


4374
02:35:49,113 --> 02:35:49,623
我


4375
02:35:49,683 --> 02:35:50,253
兴奋的


4376
02:35:50,283 --> 02:35:51,482
好了，我们讲完了


4377
02:35:51,872 --> 02:35:53,913
我们可以打印出整个字符串


4378
02:35:54,394 --> 02:35:55,264
每一封信。


4379
02:35:55,533 --> 02:36:02,011
除了使用字符串之外，我们还可以将它与其他集合一起使用例如数组。


4380
02:36:02,280 --> 02:36:04,261
如果我在这里创建数组，


4381
02:36:04,320 --> 02:36:05,160
我们叫它


4382
02:36:05,190 --> 02:36:05,940
朋友。


4383
02:36:06,091 --> 02:36:06,931
我要设置这个


4384
02:36:06,961 --> 02:36:09,362
等于一堆不同的值所以我们可以


4385
02:36:09,452 --> 02:36:11,462
把我们的朋友的名单列出来


4386
02:36:11,492 --> 02:36:12,062
吉姆


4387
02:36:12,872 --> 02:36:13,742
凯伦


4388
02:36:13,982 --> 02:36:14,522
并且


4389
02:36:14,643 --> 02:36:15,183
凯文


4390
02:36:15,692 --> 02:36:18,092
而不是说这封信为什么我们不叫它


4391
02:36:18,122 --> 02:36:18,932
朋友，


4392
02:36:19,622 --> 02:36:21,272
我可以对朋友说


4393
02:36:21,303 --> 02:36:21,933
在


4394
02:36:23,463 --> 02:36:24,303
朋友


4395
02:36:24,723 --> 02:36:26,223
现在打印出来


4396
02:36:27,963 --> 02:36:28,503
所以


4397
02:36:28,533 --> 02:36:29,942
我在这里说


4398
02:36:29,973 --> 02:36:30,812
每个

4399
02:36:30,843 --> 02:36:32,463
在这个朋友的内心


4400
02:36:32,493 --> 02:36:33,184
数组。


4401
02:36:33,363 --> 02:36:35,434
我现在想把这个朋友打印出来


4402
02:36:35,613 --> 02:36:37,174
我们就可以打印出来了


4403
02:36:37,233 --> 02:36:37,533
每一个


4404
02:36:37,563 --> 02:36:40,172
这个数组里面的元素，所以这里你不会看到


4405
02:36:40,472 --> 02:36:41,731
我们在打印健身馆


4406
02:36:41,972 --> 02:36:46,503
然后在第二次迭代中，凯伦和第三个版本将会提到kevin tso，


4407
02:36:46,833 --> 02:36:48,871
他对所有的价值观都是一个循环


4408
02:36:48,931 --> 02:36:50,460
在数组内部。


4409
02:36:50,970 --> 02:36:51,359
并且


4410
02:36:51,390 --> 02:36:52,709
这样你们就知道


4411
02:36:52,829 --> 02:36:55,858
你可以随便命名这个变量我可以命名


4412
02:36:55,889 --> 02:36:58,049
我可以随便给它取个名字，


4413
02:36:58,949 --> 02:37:02,309
如果我想要访问它我必须使用它来访问它


4414
02:37:02,339 --> 02:37:02,969
相同的


4415
02:37:02,999 --> 02:37:03,599
名字


4416
02:37:03,688 --> 02:37:08,040
我们可以像数组一样循环遍历我们也可以循环遍历


4417
02:37:08,070 --> 02:37:09,510
一系列的数字


4418
02:37:09,540 --> 02:37:10,770
所以我可以说


4419
02:37:10,829 --> 02:37:12,029
这里的索引


4420
02:37:12,299 --> 02:37:14,818
这可以是任何我要调用索引的东西


4421
02:37:15,238 --> 02:37:16,947
所以我们可以说索引


4422
02:37:16,978 --> 02:37:17,548
在


4423
02:37:17,998 --> 02:37:18,718
范围


4424
02:37:18,748 --> 02:37:22,228
然后在这里我可以传入一个数字这样我就可以像


4425
02:37:22,258 --> 02:37:23,368
举个例子。


4426
02:37:24,028 --> 02:37:26,308
下面我要打印出索引。


4427
02:37:26,397 --> 02:37:27,627
当我运行这个程序时，


4428
02:37:27,837 --> 02:37:28,946
你们会看到的


4429
02:37:29,456 --> 02:37:32,575
它会打印出范围内的每一个数字


4430
02:37:32,605 --> 02:37:34,105
从0到10，


4431
02:37:34,256 --> 02:37:35,636
不包括10


4432
02:37:35,936 --> 02:37:40,495
所以从0开始，它会输出0 1 2 3 4 5 6 7 8


4433
02:37:40,525 --> 02:37:41,006
九。


4434
02:37:41,546 --> 02:37:43,136
但是请注意，它并没有打印出来


4435
02:37:43,166 --> 02:37:43,526
外出


4436
02:37:43,586 --> 02:37:44,126
十


4437
02:37:44,156 --> 02:37:47,035
所以它实际上就是把所有的数字打印出来


4438
02:37:47,485 --> 02:37:48,626
零和


4439
02:37:49,347 --> 02:37:50,456
不包括吨。


4440
02:37:51,236 --> 02:37:52,376
你也可以指定


4441
02:37:52,406 --> 02:37:52,826
a


4442
02:37:53,156 --> 02:37:55,767
一系列的数字，所以我可以举个例子


4443
02:37:56,156 --> 02:37:57,686
3和10。


4444
02:37:57,955 --> 02:38:01,555
现在这将打印出3到10之间的所有数字


4445
02:38:03,596 --> 02:38:05,097
运行这个程序，


4446
02:38:06,537 --> 02:38:07,467
你可以看到我们打印


4447
02:38:07,497 --> 02:38:08,966
三四五六七


4448
02:38:08,996 --> 02:38:09,775
八九


4449
02:38:09,865 --> 02:38:10,915
十不

4450
02:38:11,365 --> 02:38:13,436
不管你放的是什么值


4451
02:38:14,365 --> 02:38:16,075
在第二个位置


4452
02:38:16,135 --> 02:38:18,295
不会被包括在这个范围内


4453
02:38:18,564 --> 02:38:19,555
范围可以是


4454
02:38:19,734 --> 02:38:22,134
我也可以用一个范围


4455
02:38:22,374 --> 02:38:25,854
像我们之前做的那样，循环遍历一个数组。


4456
02:38:25,975 --> 02:38:28,556
所以如果我想说的话


4457
02:38:28,586 --> 02:38:29,246
索引


4458
02:38:29,306 --> 02:38:30,415
在射程内


4459
02:38:30,475 --> 02:38:31,164
现在


4460
02:38:31,194 --> 02:38:32,693
在这个范围内


4461
02:38:32,724 --> 02:38:33,863
我可以通过


4462
02:38:33,894 --> 02:38:34,703
长度


4463
02:38:34,733 --> 02:38:35,214
在


4464
02:38:35,273 --> 02:38:36,113
数组。


4465
02:38:36,533 --> 02:38:37,014
所以


4466
02:38:37,044 --> 02:38:40,824
你们知道，如果我想要得到这个数组的长度。


4467
02:38:41,214 --> 02:38:44,845
换句话说，如果我想算出它里面有多少个元素。


4468
02:38:45,145 --> 02:38:46,374
我可以输入输出


4469
02:38:46,464 --> 02:38:47,214
阿利端


4470
02:38:47,273 --> 02:38:48,714
然后在括号内。


4471
02:38:49,104 --> 02:38:50,663
数组的名称


4472
02:38:50,903 --> 02:38:54,803
这将会吐出3个元素因为有三个元素


4473
02:38:54,833 --> 02:38:55,673
在这里


4474
02:38:55,703 --> 02:38:56,033
对的


4475
02:38:56,394 --> 02:38:57,264
这是有道理的。


4476
02:38:57,863 --> 02:39:01,854
所以我能做的就是在这个范围内的函数中


4477
02:39:01,884 --> 02:39:02,934
我可以输入


4478
02:39:03,023 --> 02:39:03,804
伊莉安


4479
02:39:04,193 --> 02:39:04,854
然后


4480
02:39:05,094 --> 02:39:05,844
朋友。


4481
02:39:06,144 --> 02:39:09,505
所以它会做的是，它会给我


4482
02:39:09,865 --> 02:39:10,525
一个范围


4483
02:39:10,556 --> 02:39:13,316
在0和朋友之间。


4484
02:39:13,376 --> 02:39:14,606
在这个列表里面


4485
02:39:14,637 --> 02:39:16,735
下面

4486
02:39:17,426 --> 02:39:18,416
朋友


4487
02:39:19,376 --> 02:39:20,096
索引。


4488
02:39:20,396 --> 02:39:21,866
这将允许我访问


4489
02:39:21,896 --> 02:39:22,257
每一个


4490
02:39:22,316 --> 02:39:24,656
在这个列表里的个人

4491
02:39:24,836 --> 02:39:27,086
就像我们之前做的一样但是现在我要做的是


4492
02:39:27,116 --> 02:39:27,836
一个范围，


4493
02:39:28,166 --> 02:39:29,396
所以你可以看到我是


4494
02:39:29,996 --> 02:39:32,126
输入jim care和kevin


4495
02:39:32,396 --> 02:39:33,115
实际上


4496
02:39:33,954 --> 02:39:35,334
循环遍历这个循环


4497
02:39:35,364 --> 02:39:37,344
它基本上会打印出来


4498
02:39:38,634 --> 02:39:39,474
零


4499
02:39:40,283 --> 02:39:41,273
朋友一


4500
02:39:41,543 --> 02:39:42,594
然后是

4501
02:39:42,653 --> 02:39:43,583
因为


4502
02:39:43,913 --> 02:39:46,192
在加热器中，有三个


4503
02:39:46,702 --> 02:39:50,062
记住，当我传入这里时它的范围从0开始


4504
02:39:50,151 --> 02:39:51,620
一直到这个数字


4505
02:39:51,650 --> 02:39:53,540
但不包括这个数字


4506
02:39:53,930 --> 02:39:56,780
这是另一种方法我们可以打印出数组中的所有元素


4507
02:39:56,960 --> 02:39:57,380
并且


4508
02:39:57,439 --> 02:40:02,720
循环通过像数组这样的东西实际上是一个非常常见的用例


4509
02:40:02,750 --> 02:40:03,830
四个循环。


4510
02:40:04,130 --> 02:40:08,510
但就像我说的，我们可以破坏希望循环通过我们所拥有的任何集合


4511
02:40:08,720 --> 02:40:11,630
我们可以像字符串一样进行循环我们也可以循环遍历


4512
02:40:12,260 --> 02:40:13,790
你知道一些类似于数组的东西


4513
02:40:14,180 --> 02:40:17,179
这是非常有用的，蝙蝠是最基本的


4514
02:40:17,209 --> 02:40:18,409
for循环


4515
02:40:18,439 --> 02:40:18,829
在


4516
02:40:18,859 --> 02:40:19,459
python。


4517
02:40:19,789 --> 02:40:22,787
我还想再给你们看一个例子当我们在这里的时候


4518
02:40:22,817 --> 02:40:23,478
所以


4519
02:40:23,987 --> 02:40:25,877
我们为什么不直接打印出一个范围


4520
02:40:25,907 --> 02:40:26,867
直到


4521
02:40:26,927 --> 02:40:27,617
五


4522
02:40:27,647 --> 02:40:29,388
这是一个简单的程序


4523
02:40:29,808 --> 02:40:31,787
你可以使用各种逻辑


4524
02:40:31,817 --> 02:40:33,137
在这四种生活中。


4525
02:40:33,287 --> 02:40:37,787
假设我想在循环的第一个迭代中做一些特别的事情。


4526
02:40:38,087 --> 02:40:39,106
所以我可以说


4527
02:40:39,467 --> 02:40:39,977
如果


4528
02:40:40,366 --> 02:40:41,026
索引


4529
02:40:41,057 --> 02:40:42,316
等于零


4530
02:40:43,217 --> 02:40:43,637
并且


4531
02:40:43,667 --> 02:40:48,943
如果索引为0，我们知道它是循环的第一个迭代所以我可以做一些特别的东西我可以打印出来


4532
02:40:49,063 --> 02:40:49,754
首先


4533
02:40:49,813 --> 02:40:50,594
迭代。


4534
02:40:51,044 --> 02:40:52,993
否则我们就可以


4535
02:40:53,474 --> 02:40:54,374
印刷湖


4536
02:40:56,414 --> 02:40:58,845
不是第一次，所以这是一个类似的例子


4537
02:40:59,055 --> 02:41:01,725
也许你想在循环的第一个迭代中做点什么


4538
02:41:01,965 --> 02:41:03,164
做些其他的事情


4539
02:41:03,404 --> 02:41:05,563
后续的迭代，如果我播放这个


4540
02:41:05,983 --> 02:41:08,323
你只会在第一次迭代中看到


4541
02:41:08,354 --> 02:41:11,146
把它打印出来，否则它会打印出其他东西


4542
02:41:11,415 --> 02:41:11,655
你


4543
02:41:11,686 --> 02:41:12,976
不要害怕


4544
02:41:13,006 --> 02:41:14,625
提出一些复杂的逻辑


4545
02:41:14,655 --> 02:41:16,004
在这四种生活中


4546
02:41:16,304 --> 02:41:16,754
因为


4547
02:41:16,784 --> 02:41:19,305
它可以让你的程序更强大


4548
02:41:23,564 --> 02:41:25,753
在本教程中，我将向你们展示如何构建一个


4549
02:41:25,783 --> 02:41:27,043
指数函数


4550
02:41:27,073 --> 02:41:29,983
指数函数基本上是允许我们这样做的


4551
02:41:30,014 --> 02:41:30,464
到


4552
02:41:30,494 --> 02:41:33,972
取一个特定的数，然后把它提升到一个特定的能量。


4553
02:41:34,332 --> 02:41:38,651
所以在python里有一个很简单的方法我可以到这里来打印。


4554
02:41:39,281 --> 02:41:40,092
我们可以说


4555
02:41:40,122 --> 02:41:40,962
还有。


4556
02:41:41,231 --> 02:41:42,012
我们可以这样做


4557
02:41:42,042 --> 02:41:43,662
两个乘法符号


4558
02:41:43,992 --> 02:41:45,192
我可以说三个


4559
02:41:45,492 --> 02:41:47,742
这基本上就是2


4560
02:41:47,802 --> 02:41:49,632
上升到第三次幂。


4561
02:41:50,142 --> 02:41:50,892
所以


4562
02:41:51,012 --> 02:41:51,461
你可以


4563
02:41:51,491 --> 02:41:53,172
看这里，我可以把它打印出来


4564
02:41:53,202 --> 02:41:53,772
我们得到a


4565
02:41:53,803 --> 02:41:54,433
磁带盒


4566
02:41:54,492 --> 02:41:55,212
立方


4567
02:41:55,902 --> 02:41:58,603
用python来做指数是很容易的。


4568
02:41:59,202 --> 02:42:00,401
但是我想让你们看看，


4569
02:42:00,461 --> 02:42:07,060
我们如何使用像for循环这样的东西来创建一个像我们自己的太阳这样的函数实际上会创建一个


4570
02:42:07,119 --> 02:42:07,839
指数


4571
02:42:07,869 --> 02:42:08,619
功能


4572
02:42:08,919 --> 02:42:11,320
基本上就是这样，我们会用到


4573
02:42:11,351 --> 02:42:12,311
for循环来做


4574
02:42:13,541 --> 02:42:14,741
让我们创建一个函数。


4575
02:42:14,801 --> 02:42:16,030
像死亡一样的东西


4576
02:42:16,061 --> 02:42:17,261
现在我们需要给出这个


4577
02:42:17,291 --> 02:42:19,330
函数一个名字为什么不叫它呢


4578
02:42:19,420 --> 02:42:20,229
举起


4579
02:42:20,260 --> 02:42:21,010
二


4580
02:42:21,340 --> 02:42:21,910
功率


4581
02:42:22,780 --> 02:42:23,860
在这里面，


4582
02:42:24,221 --> 02:42:27,610
我将接受两个参数第一个参数将是


4583
02:42:27,641 --> 02:42:28,780
基数。


4584
02:42:29,290 --> 02:42:30,040
然后是第二个


4585
02:42:30,070 --> 02:42:31,571
参数将是


4586
02:42:31,661 --> 02:42:34,631
所以我们要取底数


4587
02:42:34,811 --> 02:42:35,980
把它提升到


4588
02:42:36,011 --> 02:42:37,031
电源号。


4589
02:42:37,512 --> 02:42:38,172
所以


4590
02:42:38,202 --> 02:42:39,012
在这里，我们可以


4591
02:42:39,042 --> 02:42:39,912
做一个冒号


4592
02:42:40,182 --> 02:42:40,662
现在


4593
02:42:41,172 --> 02:42:44,473
在这个函数的内部，当你开始写一些代码的时候。


4594
02:42:44,742 --> 02:42:45,461
事情是这样的


4595
02:42:46,031 --> 02:42:48,701
在这个函数里面我们不一定知道


4596
02:42:48,731 --> 02:42:50,862
这首诗的价值，


4597
02:42:51,252 --> 02:42:51,612
对的


4598
02:42:51,792 --> 02:42:53,142
对他们来说为什么我们知道


4599
02:42:53,172 --> 02:42:56,921
我们只是想要平方这个数或者这个数。


4600
02:42:57,131 --> 02:42:58,541
我可以返回


4601
02:42:59,021 --> 02:43:00,102
像bass


4602
02:43:00,161 --> 02:43:00,852
num


4603
02:43:01,182 --> 02:43:02,052
时代


4604
02:43:02,231 --> 02:43:02,861
基底细胞


4605
02:43:03,251 --> 02:43:05,771
现在它是平方数或者我可以保留这个数


4606
02:43:06,252 --> 02:43:06,972
低音


4607
02:43:07,031 --> 02:43:08,891
所以这就像数字的立方。


4608
02:43:09,131 --> 02:43:11,981
问题是我们不知道如何


4609
02:43:12,012 --> 02:43:13,661
这个值将会是什么


4610
02:43:13,991 --> 02:43:16,632
这可能会发生变化，就像用户可以决定的那样。


4611
02:43:17,021 --> 02:43:21,433
为了写出这个函数我们实际上需要用到for循环。


4612
02:43:21,763 --> 02:43:23,412
我相信你们都知道它是如何使用for循环的


4613
02:43:23,442 --> 02:43:25,333
基本上是这样想的


4614
02:43:25,693 --> 02:43:28,902
我要做的第一件事是创建一个变量，我将调用它


4615
02:43:28,933 --> 02:43:29,713
结果。


4616
02:43:30,373 --> 02:43:31,633
我们只需要设置结果


4617
02:43:31,663 --> 02:43:34,364
等于1，所以我们要从1开始。


4618
02:43:34,814 --> 02:43:36,074
现在我想创建


4619
02:43:36,104 --> 02:43:37,334
a for循环，


4620
02:43:37,394 --> 02:43:38,953
所以我基本上只会说


4621
02:43:38,983 --> 02:43:39,674
四


4622
02:43:40,574 --> 02:43:41,564
在这里，


4623
02:43:41,834 --> 02:43:43,663
我不想指定


4624
02:43:43,693 --> 02:43:44,144
a


4625
02:43:44,233 --> 02:43:46,123
8月8日指数


4626
02:43:46,363 --> 02:43:46,903
在


4627
02:43:47,023 --> 02:43:48,824
现在要指定一个范围


4628
02:43:48,884 --> 02:43:50,324
基本上是安排


4629
02:43:50,354 --> 02:43:51,044
射程


4630
02:43:51,074 --> 02:43:51,584
通过


4631
02:43:52,184 --> 02:43:53,623
数字的集合。


4632
02:43:53,923 --> 02:43:55,183
所以基本上我想


4633
02:43:55,272 --> 02:43:56,863
乘以低音号


4634
02:43:56,894 --> 02:43:57,974
就其本身而言，


4635
02:43:58,544 --> 02:44:01,064
很多时候，英镑都麻木了


4636
02:44:01,095 --> 02:44:02,114
指定


4637
02:44:02,174 --> 02:44:02,624
对的


4638
02:44:02,954 --> 02:44:04,483
在这里，我可以做这个


4639
02:44:04,514 --> 02:44:05,443
一个范围


4640
02:44:06,283 --> 02:44:06,883
功率


4641
02:44:06,913 --> 02:44:07,453
麻木的


4642
02:44:07,843 --> 02:44:10,512
好的，所以我们基本上是一个循环


4643
02:44:10,542 --> 02:44:11,652
这个for循环


4644
02:44:11,952 --> 02:44:15,281
很多次都是这样的


4645
02:44:15,551 --> 02:44:16,750
将循环遍历两次。


4646
02:44:16,900 --> 02:44:19,301
路德会的经济学家四次


4647
02:44:19,570 --> 02:44:23,170
每次通过循环时，都会将bass num自身相乘


4648
02:44:23,200 --> 02:44:25,631
或者你会看到我们要把它乘以这个结果，


4649
02:44:26,111 --> 02:44:27,191
在下面这里


4650
02:44:28,002 --> 02:44:29,262
我基本上可以说


4651
02:44:29,622 --> 02:44:30,342
结果


4652
02:44:30,372 --> 02:44:31,481
等于


4653
02:44:32,802 --> 02:44:33,762
时代，


4654
02:44:34,332 --> 02:44:35,082
踱步


4655
02:44:35,262 --> 02:44:38,772
这应该会给我们所有我们需要的东西来取这个数


4656
02:44:38,982 --> 02:44:40,723
对于特定的权力


4657
02:44:40,933 --> 02:44:42,162
真实的


4658
02:44:43,212 --> 02:44:44,501
做数学计算


4659
02:44:44,531 --> 02:44:45,762
会被储存起来


4660
02:44:45,792 --> 02:44:46,872
在这里面


4661
02:44:47,652 --> 02:44:48,643
变量


4662
02:44:49,123 --> 02:44:50,293
第一次通过这个循环，


4663
02:44:50,353 --> 02:44:52,692
我们只是把一个盆地乘以一个


4664
02:44:52,752 --> 02:44:53,292
对。


4665
02:44:53,832 --> 02:44:54,912
现在结果是


4666
02:44:54,942 --> 02:44:55,933
将会变成


4667
02:44:55,992 --> 02:44:57,432
相同的值是基于


4668
02:44:57,731 --> 02:45:01,422
第二次通过这个循环，如果我们把这个数平方。


4669
02:45:01,632 --> 02:45:05,383
我们基本上是用脸盆来做的所以它本质上就是


4670
02:45:05,413 --> 02:45:07,184
基于长期的


4671
02:45:07,573 --> 02:45:08,864
第三次通过循环


4672
02:45:08,895 --> 02:45:10,904
我们把结果乘以bass num


4673
02:45:10,935 --> 02:45:12,314
所以我们基本上就像


4674
02:45:12,345 --> 02:45:13,695
保持这个数字


4675
02:45:13,905 --> 02:45:15,586
这就是for循环的本质


4676
02:45:15,616 --> 02:45:16,727
是为我们做的。


4677
02:45:16,937 --> 02:45:18,586
最后我要做的是


4678
02:45:18,676 --> 02:45:20,506
就在这个for循环下面


4679
02:45:20,536 --> 02:45:21,047
我只是想


4680
02:45:21,077 --> 02:45:21,827
返回


4681
02:45:22,308 --> 02:45:22,998
结果


4682
02:45:23,028 --> 02:45:23,568
所以


4683
02:45:23,748 --> 02:45:28,369
我们将能够返回任何将数字提升到幂的

4684
02:45:29,060 --> 02:45:29,961
让我们下来


4685
02:45:29,991 --> 02:45:33,681
在这个函数之后，我们把它叫做，我就会说，


4686
02:45:34,490 --> 02:45:36,170
实际上会打印出答案


4687
02:45:36,320 --> 02:45:38,301
节约用电


4688
02:45:38,751 --> 02:45:41,961
在这些怀孕成员的内部我们可以通过两个数字，让我们


4689
02:45:42,021 --> 02:45:43,400
升高三


4690
02:45:43,910 --> 02:45:47,479
对于第二个能量，我们将会得到3的平方，我们会看到它是如何工作的


4691
02:45:48,350 --> 02:45:49,249
从程序中


4692
02:45:49,639 --> 02:45:53,028
你可以看到在这台控制台上有9个。


4693
02:45:53,088 --> 02:45:54,197
让我们来试一试


4694
02:45:54,527 --> 02:45:55,157
疯狂的


4695
02:45:55,397 --> 02:45:56,508
驱动三


4696
02:45:56,538 --> 02:45:57,738
四次方


4697
02:45:58,309 --> 02:45:59,509
然后运行这个


4698
02:45:59,568 --> 02:46:00,049
聚集


4699
02:46:00,079 --> 02:46:01,428
80个，这是


4700
02:46:01,458 --> 02:46:02,657
3的4次方。


4701
02:46:03,138 --> 02:46:05,718
我们试一下2的3次方


4702
02:46:05,897 --> 02:46:06,767
我们得到了8


4703
02:46:06,797 --> 02:46:07,667
是的，这让我们


4704
02:46:07,697 --> 02:46:08,087
所以


4705
02:46:08,807 --> 02:46:10,787
我们提高了功率函数的作用


4706
02:46:10,817 --> 02:46:13,906
就像预期的那样，这是他必须再做一次的事情。


4707
02:46:14,956 --> 02:46:19,426
在这个函数里面，输入了两个输入，在一个基本数字中。


4708
02:46:19,695 --> 02:46:21,854
我们取一个pow的数字，就像


4709
02:46:22,305 --> 02:46:24,944
底数会被取到幂数


4710
02:46:25,334 --> 02:46:27,824
我定义了一个变量叫做result


4711
02:46:28,124 --> 02:46:30,313
结果就是我们要储存的地方


4712
02:46:30,373 --> 02:46:32,594
计算的实际结果。


4713
02:46:33,014 --> 02:46:34,754
现在我们指定这个


4714
02:46:34,784 --> 02:46:35,414
for循环，


4715
02:46:35,474 --> 02:46:37,305
我的意思是


4716
02:46:37,395 --> 02:46:39,974
我想要循环遍历这一系列的数字。


4717
02:46:40,033 --> 02:46:40,543
当我把


4718
02:46:40,573 --> 02:46:43,123
这里的磅数从0到0


4719
02:46:43,423 --> 02:46:46,633
一直到但不包括电力号丝


4720
02:46:46,783 --> 02:46:49,724
我们基本上会循环遍历数次幂次


4721
02:46:49,754 --> 02:46:50,413
这是有道理的。


4722
02:46:50,894 --> 02:46:54,223
然后每次通过循环我们只是乘以结果


4723
02:46:54,282 --> 02:46:54,942
基本麻木。


4724
02:46:55,272 --> 02:46:57,073
然后我们返回结果


4725
02:46:57,253 --> 02:46:59,052
这是构建a的基础


4726
02:46:59,082 --> 02:46:59,922
幂函数


4727
02:46:59,952 --> 02:47:00,192
并且


4728
02:47:00,252 --> 02:47:01,062
很明显


4729
02:47:01,093 --> 02:47:04,391
如果你只是想在python里取一个数字，这很简单，但是


4730
02:47:04,570 --> 02:47:07,180
这显示了你喜欢内部工作原理


4731
02:47:07,420 --> 02:47:10,269
对于这样的函数，我们必须要


4732
02:47:10,358 --> 02:47:12,218
像这样输入一些东西，


4733
02:47:16,208 --> 02:47:19,957
本教程我想和你们谈谈两个不同的概念


4734
02:47:19,987 --> 02:47:20,407
在


4735
02:47:20,438 --> 02:47:21,098
python。


4736
02:47:21,487 --> 02:47:22,717
这将是一个很酷的教训。


4737
02:47:23,047 --> 02:47:24,845
我想给你们展示的第一件事是


4738
02:47:24,875 --> 02:47:27,784
二维的列表，在这里


4739
02:47:27,964 --> 02:47:28,983
python文件。


4740
02:47:29,163 --> 02:47:30,242
我只是想创造


4741
02:47:30,632 --> 02:47:31,262
a


4742
02:47:31,292 --> 02:47:32,012
基本表


4743
02:47:32,042 --> 02:47:33,632
我把它命名为


4744
02:47:33,722 --> 02:47:34,652
数字网格。


4745
02:47:35,522 --> 02:47:37,232
我要把这个设为


4746
02:47:37,263 --> 02:47:39,152
正常情况下让陌生人这样做


4747
02:47:40,172 --> 02:47:46,112
通常，如果我们创建一个列表，我可以把一些属性和一些元素放在一起，


4748
02:47:46,532 --> 02:47:50,190
现在所有这些元素都在这个数字网格列表中每个人都很高兴。


4749
02:47:50,671 --> 02:47:51,211
但是


4750
02:47:51,601 --> 02:47:52,980
我还能做的另一件事


4751
02:47:53,011 --> 02:47:54,240
我能做吗


4752
02:47:54,271 --> 02:47:55,561
所有的元素


4753
02:47:55,591 --> 02:47:58,052
在这个数字网格列表中


4754
02:47:58,622 --> 02:47:59,492
列表


4755
02:47:59,522 --> 02:48:00,062
所以


4756
02:48:00,093 --> 02:48:00,723
第一个


4757
02:48:00,753 --> 02:48:01,203
项目


4758
02:48:01,233 --> 02:48:03,334
在编号列表中，将会是一个列表。


4759
02:48:03,574 --> 02:48:06,032
第二项和数量减少是一个

4760
02:48:06,062 --> 02:48:06,692
等等。


4761
02:48:07,112 --> 02:48:08,401
所以我要告诉你们，你们必须这样做


4762
02:48:08,432 --> 02:48:10,382
我基本上可以到这里来


4763
02:48:10,412 --> 02:48:12,241
为什么通常是

4764
02:48:12,571 --> 02:48:13,531
列表中的元素


4765
02:48:13,562 --> 02:48:15,332
我可以创建另一个数组


4766
02:48:15,632 --> 02:48:18,392
有人要做一个开放的封闭方括号，


4767
02:48:18,691 --> 02:48:19,411
现在


4768
02:48:19,711 --> 02:48:22,172
我只说一二三


4769
02:48:23,102 --> 02:48:25,111
我可以在列表中创建下一个

4770
02:48:25,142 --> 02:48:26,011
我可以说


4771
02:48:26,610 --> 02:48:28,380
四五六，


4772
02:48:28,710 --> 02:48:30,780
然后让我们在这个列表中再做一个项目。


4773
02:48:32,160 --> 02:48:32,730
七


4774
02:48:32,761 --> 02:48:33,001
八


4775
02:48:33,031 --> 02:48:33,602
九


4776
02:48:33,871 --> 02:48:37,800
最后，我们还会在数字网格列表中添加一个列表


4777
02:48:38,010 --> 02:48:39,089
它将会有


4778
02:48:39,119 --> 02:48:40,648
在里面是零


4779
02:48:41,129 --> 02:48:43,769
在这个被编号的红色嘴唇里面写着


4780
02:48:43,828 --> 02:48:45,808
高水平的总体列表，


4781
02:48:46,048 --> 02:48:46,798
我们有


4782
02:48:46,828 --> 02:48:48,298
四要素


4783
02:48:48,448 --> 02:48:48,658
在


4784
02:48:48,688 --> 02:48:49,888
所有这些元素


4785
02:48:49,918 --> 02:48:50,308
是


4786
02:48:50,338 --> 02:48:51,418
自己


4787
02:48:51,568 --> 02:48:52,559
列表。


4788
02:48:52,679 --> 02:48:55,948
本质上，我们所做的就是创建一个网格


4789
02:48:56,099 --> 02:49:00,059
这个网格有1 2 3 4行


4790
02:49:00,269 --> 02:49:01,108
一个


4791
02:49:01,139 --> 02:49:03,147
两个3个碳


4792
02:49:03,417 --> 02:49:03,807
对的


4793
02:49:03,837 --> 02:49:04,616
玫瑰


4794
02:49:04,646 --> 02:49:06,446
三列，这有点像


4795
02:49:06,927 --> 02:49:10,077
为什么这些可以很有用因为我们可以创建一个网格


4796
02:49:10,107 --> 02:49:11,997
python内部结构


4797
02:49:12,057 --> 02:49:12,717
使用


4798
02:49:12,747 --> 02:49:14,547
二维

4799
02:49:14,787 --> 02:49:17,007
这是一个很酷的列表结构。


4800
02:49:17,487 --> 02:49:18,657
我想让你们看看，


4801
02:49:18,808 --> 02:49:19,888
如何访问


4802
02:49:19,918 --> 02:49:21,447
个别元素


4803
02:49:21,657 --> 02:49:23,698
在这个列表结构中


4804
02:49:24,358 --> 02:49:29,430
例如，假设我想要打印出其中一个值如果他们想要打印出这个值，


4805
02:49:29,790 --> 02:49:31,681
我的方法是说


4806
02:49:32,431 --> 02:49:33,361
数字网格。


4807
02:49:34,352 --> 02:49:34,832
并且


4808
02:49:34,892 --> 02:49:37,952
我要做的第一件事是做一个开放的，封闭的方括号


4809
02:49:38,132 --> 02:49:39,122
在这里


4810
02:49:39,152 --> 02:49:40,953
我想把


4811
02:49:41,223 --> 02:49:43,562
我想要访问的行的索引。


4812
02:49:43,742 --> 02:49:45,782
这就像第0行


4813
02:49:45,962 --> 02:49:48,152
因为它是数组里元素的零。


4814
02:49:48,422 --> 02:49:50,942
这是它的第一行和第一个


4815
02:49:51,122 --> 02:49:54,002
这是行到第三行，所以我可以


4816
02:49:54,212 --> 02:49:55,172
玫瑰生长


4817
02:49:56,012 --> 02:49:56,821
现在


4818
02:49:56,911 --> 02:49:59,610
在这里，我要做另一个方括号，


4819
02:50:01,439 --> 02:50:03,300
列的索引


4820
02:50:03,510 --> 02:50:04,979
这就像第一列一样


4821
02:50:05,009 --> 02:50:06,269
列到第三列。


4822
02:50:06,389 --> 02:50:06,869
所以


4823
02:50:06,899 --> 02:50:08,188
我要把它设为零


4824
02:50:08,219 --> 02:50:09,779
因为这是在


4825
02:50:09,810 --> 02:50:10,350
零


4826
02:50:10,380 --> 02:50:10,979
索引


4827
02:50:11,039 --> 02:50:12,209
首先


4828
02:50:12,239 --> 02:50:13,079
数组


4829
02:50:13,439 --> 02:50:13,529
我


4830
02:50:13,560 --> 02:50:14,819
这里是0。


4831
02:50:15,149 --> 02:50:17,459
现在我们可以把它打印到屏幕上


4832
02:50:18,299 --> 02:50:19,349
你会看到下面这里


4833
02:50:19,589 --> 02:50:20,969
我们得到了那个


4834
02:50:21,329 --> 02:50:25,318
所以我也可以这样做，比如这8个例子，所以这将会是


4835
02:50:25,349 --> 02:50:26,699
零一二


4836
02:50:27,119 --> 02:50:28,858
可以是第二行


4837
02:50:29,368 --> 02:50:30,538
第一列


4838
02:50:30,928 --> 02:50:32,848
现在我们可以把它打印出来


4839
02:50:32,907 --> 02:50:33,207
e。


4840
02:50:34,407 --> 02:50:37,557
这就是我们如何访问元素内部的元素


4841
02:50:37,587 --> 02:50:38,517
二d


4842
02:50:38,547 --> 02:50:39,237
列表。


4843
02:50:39,718 --> 02:50:40,888
接下来我要给你们展示的是


4844
02:50:40,918 --> 02:50:41,188
是


4845
02:50:41,218 --> 02:50:41,938
a


4846
02:50:41,997 --> 02:50:43,437
嵌套for循环


4847
02:50:43,467 --> 02:50:46,137
在超级大的情况下，我们的情况很糟糕


4848
02:50:46,167 --> 02:50:47,098
a for循环


4849
02:50:47,128 --> 02:50:48,267
在for循环中。


4850
02:50:48,566 --> 02:50:51,415
我将向你们展示如何使用这个

4851
02:50:51,835 --> 02:50:57,834
为了打印出这个数组里面的所有元素所以我基本上给你们展示了一个解析


4852
02:50:58,645 --> 02:50:59,755
二维的


4853
02:50:59,905 --> 02:51:01,706
列表或二维数组。


4854
02:51:02,066 --> 02:51:05,514
所以基本上我们要创建一个正常的for循环所以我将写入4


4855
02:51:05,754 --> 02:51:07,644
我要写入行


4856
02:51:08,063 --> 02:51:08,604
在


4857
02:51:08,663 --> 02:51:09,533
数字网格。


4858
02:51:10,253 --> 02:51:12,322
我在这里用row这个词，因为


4859
02:51:12,353 --> 02:51:13,583
我看到了


4860
02:51:13,613 --> 02:51:17,094
这些行是水平行这是一种水平的行


4861
02:51:17,574 --> 02:51:18,895
在我们的小格子里


4862
02:51:19,194 --> 02:51:22,074
对于每一列的每一行


4863
02:51:22,134 --> 02:51:22,794
元素


4864
02:51:22,854 --> 02:51:24,144
在数字网格中。


4865
02:51:24,203 --> 02:51:26,844
我想要循环一下，这样我就可以打印出来了


4866
02:51:27,113 --> 02:51:28,403
现在每一行


4867
02:51:28,613 --> 02:51:31,015
它会打印出里面的所有行


4868
02:51:31,045 --> 02:51:32,486
你可以在下面看到


4869
02:51:32,756 --> 02:51:35,335
我们基本上就是得到了我们所拥有的。


4870
02:51:35,815 --> 02:51:37,285
但是我想要能够访问


4871
02:51:37,345 --> 02:51:39,084
每一个人


4872
02:51:39,114 --> 02:51:39,864
属性


4873
02:51:39,924 --> 02:51:41,635
在每一个里面


4874
02:51:41,694 --> 02:51:42,685
数组

4875
02:51:42,715 --> 02:51:43,225
所以


4876
02:51:43,585 --> 02:51:47,994
我们可以创建另一个for循环，我把它放在这里，


4877
02:51:48,624 --> 02:51:50,514
现在我要讲四个


4878
02:51:51,204 --> 02:51:51,954
柱


4879
02:51:52,224 --> 02:51:52,854
在a


4880
02:51:53,273 --> 02:51:53,964
行。


4881
02:51:54,864 --> 02:51:56,604
这将给我们带来的是


4882
02:51:56,904 --> 02:51:57,265
每一个


4883
02:51:57,295 --> 02:51:58,345
个人的


4884
02:51:58,404 --> 02:52:00,114
列或每个人


4885
02:52:00,145 --> 02:52:02,035
元素内部的元素


4886
02:52:02,095 --> 02:52:02,694
阵列


4887
02:52:02,725 --> 02:52:04,824
例如，在数组中


4888
02:52:04,884 --> 02:52:06,384
数字网格的元素


4889
02:52:07,254 --> 02:52:08,214
这是有道理的


4890
02:52:08,784 --> 02:52:09,474
在下面。


4891
02:52:09,863 --> 02:52:10,433
现在我们可以


4892
02:52:10,463 --> 02:52:10,823
打印


4893
02:52:10,854 --> 02:52:11,304
外出


4894
02:52:12,263 --> 02:52:13,823
这个应该打印出来


4895
02:52:15,144 --> 02:52:17,304
这两个维度数组中的值。


4896
02:52:17,363 --> 02:52:19,163
让我们继续运行这个程序。


4897
02:52:20,063 --> 02:52:23,005
在这里，你会看到我们基本上打印出来了


4898
02:52:23,274 --> 02:52:24,744
一直往下


4899
02:52:24,774 --> 02:52:25,225
到


4900
02:52:25,255 --> 02:52:25,675
零


4901
02:52:25,705 --> 02:52:27,656
我们把所有的都打印出来


4902
02:52:27,716 --> 02:52:28,286
元素


4903
02:52:28,586 --> 02:52:29,396
在


4904
02:52:29,455 --> 02:52:31,944
所有的数组都在数字网格中。


4905
02:52:32,034 --> 02:52:34,523
这就是我们如何使用二维列表的方法


4906
02:52:34,554 --> 02:52:37,193
在这两种情况下都嵌套for循环


4907
02:52:37,253 --> 02:52:39,533
在python中是非常方便的


4908
02:52:44,093 --> 02:52:48,264
在本教程中，我将向您展示如何构建一个基本的翻译器


4909
02:52:48,294 --> 02:52:48,984
python。


4910
02:52:49,314 --> 02:52:50,454
所以基本上我们可以


4911
02:52:50,484 --> 02:52:51,265
接受


4912
02:52:51,295 --> 02:52:54,596
一个字符串我们可以把他当作一个短语或一个词


4913
02:52:54,985 --> 02:52:58,676
并能将其翻译成另一种语言。


4914
02:52:59,096 --> 02:52:59,485
所以


4915
02:52:59,516 --> 02:53:01,135
这里我有一个小文件


4916
02:53:01,165 --> 02:53:03,476
它基本上指定了这种语言


4917
02:53:03,506 --> 02:53:06,175
这是我编的，所以我把它叫做草稿语言


4918
02:53:06,564 --> 02:53:06,925
并且


4919
02:53:06,955 --> 02:53:08,305
在草案中


4920
02:53:08,335 --> 02:53:09,564
全元音


4921
02:53:09,595 --> 02:53:10,285
变成


4922
02:53:10,315 --> 02:53:11,096
克


4923
02:53:11,456 --> 02:53:14,096
所以如果我要把一个英语单词翻译成


4924
02:53:14,126 --> 02:53:15,326
草稿


4925
02:53:15,926 --> 02:53:17,517
比如“狗”这个词，


4926
02:53:17,606 --> 02:53:19,256
我要看一下狗这个词


4927
02:53:19,556 --> 02:53:21,746
任何有元音的例子


4928
02:53:22,406 --> 02:53:23,397
在我们的例子中，我们说


4929
02:53:23,428 --> 02:53:24,777
一个e I o u。


4930
02:53:25,258 --> 02:53:27,028
我要转换那个元音


4931
02:53:27,088 --> 02:53:27,987
变成g


4932
02:53:28,167 --> 02:53:29,906
所以狗会映射到


4933
02:53:30,026 --> 02:53:31,076
数字数据


4934
02:53:31,346 --> 02:53:32,456
cat会被映射


4935
02:53:32,486 --> 02:53:33,177
进入


4936
02:53:33,236 --> 02:53:34,347
c g t。


4937
02:53:34,616 --> 02:53:36,206
这些是基本的翻译规则。


4938
02:53:36,266 --> 02:53:38,425
显然这是一种很简单的语言


4939
02:53:38,665 --> 02:53:41,185
你明白了，任何一个元音都将变成a


4940
02:53:41,215 --> 02:53:42,476
然后我们会得到


4941
02:53:42,506 --> 02:53:43,556
语言草案。


4942
02:53:43,706 --> 02:53:44,395
所以我们要建造


4943
02:53:44,425 --> 02:53:45,205
汇票


4944
02:53:45,235 --> 02:53:46,045
译码器


4945
02:53:46,615 --> 02:53:48,054
在这里


4946
02:53:48,084 --> 02:53:49,074
python文件。


4947
02:53:49,164 --> 02:53:49,584
让我们


4948
02:53:49,614 --> 02:53:54,865
开始做这个翻译我要做的第一件事就是定义一个翻译函数。


4949
02:53:55,375 --> 02:53:57,864
所以我要在这里创建一个函数，我将调用它


4950
02:53:58,914 --> 02:53:59,604
翻译


4951
02:54:00,204 --> 02:54:00,714
并且


4952
02:54:00,773 --> 02:54:02,094
在括号内


4953
02:54:02,124 --> 02:54:03,385
我们想要这个


4954
02:54:03,415 --> 02:54:03,985
一


4955
02:54:04,016 --> 02:54:05,664
这是一个信息，它将会是


4956
02:54:05,904 --> 02:54:06,925
短语


4957
02:54:07,075 --> 02:54:09,024
我们想要翻译，所以我想说


4958
02:54:10,524 --> 02:54:13,403
现在在这个函数里面我们需要算出


4959
02:54:13,493 --> 02:54:13,793
好的


4960
02:54:13,823 --> 02:54:15,594
我们如何

4961
02:54:16,014 --> 02:54:19,284
英语在我们的语言草案中


4962
02:54:19,314 --> 02:54:21,115
规则基本上就是


4963
02:54:21,325 --> 02:54:22,704
任何元音都变成了


4964
02:54:22,734 --> 02:54:23,454
天啊。


4965
02:54:23,874 --> 02:54:26,303
我要做的第一件事是创建一个变量


4966
02:54:26,393 --> 02:54:32,305
这个变量将会是平移所以这就像是我们要返回给用户的最终结果。


4967
02:54:32,665 --> 02:54:33,566
所以我可以说


4968
02:54:35,127 --> 02:54:36,567
现在我要设置它


4969
02:54:36,598 --> 02:54:37,647
等于


4970
02:54:37,827 --> 02:54:39,807
空字符串，所以这就像


4971
02:54:40,076 --> 02:54:42,087
一个完全空的字符串它是不会的


4972
02:54:42,117 --> 02:54:43,137
做任何事。


4973
02:54:43,736 --> 02:54:44,336
并且


4974
02:54:44,696 --> 02:54:47,516
现在我们想要做的是


4975
02:54:47,546 --> 02:54:48,026
循环


4976
02:54:48,057 --> 02:54:48,776
通过


4977
02:54:49,166 --> 02:54:51,656
这句话里的每一个字母。


4978
02:54:52,436 --> 02:54:54,806
如果是元音，我们想把它改成g


4979
02:54:54,836 --> 02:54:57,086
如果不是avowal，我们就不去管它了


4980
02:54:57,896 --> 02:54:58,105
我们


4981
02:54:58,165 --> 02:55:00,055
本质上是循环通过短语。


4982
02:55:00,175 --> 02:55:02,094
我们将会添加这些字母


4983
02:55:02,244 --> 02:55:04,193
在这个翻译上


4984
02:55:04,313 --> 02:55:07,044
一个接一个，确保你们知道我们怎么做。


4985
02:55:07,104 --> 02:55:09,443
我要在一个安全的地方做一个for

4986
02:55:10,014 --> 02:55:11,543
我要写一封信


4987
02:55:12,173 --> 02:55:12,743
在


4988
02:55:13,133 --> 02:55:14,033
短语。


4989
02:55:14,783 --> 02:55:15,503
所以现

4990
02:55:16,193 --> 02:55:18,533
当我在这里循环时，我可以访问


4991
02:55:18,593 --> 02:55:18,982
每一个


4992
02:55:19,013 --> 02:55:20,272
个别字母


4993
02:55:20,362 --> 02:55:22,644
在他们通过的短语里面。


4994
02:55:23,063 --> 02:55:26,094
所以我想做的是检查一下


4995
02:55:26,273 --> 02:55:28,042
这封信是一个元音


4996
02:55:28,072 --> 02:55:28,433
对。


4997
02:55:28,612 --> 02:55:30,264
如果它是一个元音，我们可以


4998
02:55:30,294 --> 02:55:30,684
加


4999
02:55:30,714 --> 02:55:32,604
一个g在翻译上。


5000
02:55:32,934 --> 02:55:34,104
如果没有的话


5001
02:55:34,134 --> 02:55:35,994
然后我们可以添加任何东西


5002
02:55:36,114 --> 02:55:37,913
信是翻译过来的


5003
02:55:37,973 --> 02:55:38,903
不管怎样


5004
02:55:39,354 --> 02:55:39,863
许多用户


5005
02:55:39,894 --> 02:55:40,974
如果我想说


5006
02:55:41,063 --> 02:55:41,453
如果。


5007
02:55:42,113 --> 02:55:47,634
实际上，我们可以用python来做这个特殊的事情我们可以检查一下是否有东西在里面


5008
02:55:47,664 --> 02:55:48,505
其他的


5009
02:55:48,805 --> 02:55:49,854
所以我可以说


5010
02:55:50,604 --> 02:55:51,295
字母


5011
02:55:51,535 --> 02:55:52,105
客栈。


5012
02:55:52,945 --> 02:55:57,296
在这里，我要把所有的元音都去掉，就是e I o u。


5013
02:55:57,355 --> 02:55:57,655
并且


5014
02:55:57,686 --> 02:55:58,375
e


5015
02:55:58,555 --> 02:55:58,795
我


5016
02:55:58,854 --> 02:55:59,364
对你来说。


5017
02:56:00,055 --> 02:56:02,125
我基本上是在检查这封信


5018
02:56:02,305 --> 02:56:03,324
在


5019
02:56:03,354 --> 02:56:04,645
这个字符串


5020
02:56:04,854 --> 02:56:06,774
如果这封信在这里，


5021
02:56:06,984 --> 02:56:08,154
然后我们知道它是


5022
02:56:08,185 --> 02:56:09,115
一个元音


5023
02:56:09,146 --> 02:56:11,097
下面我们可以处理这个案例


5024
02:56:11,127 --> 02:56:12,026
所以我可以说。


5025
02:56:12,687 --> 02:56:13,677
翻译


5026
02:56:14,637 --> 02:56:15,597
等于


5027
02:56:17,247 --> 02:56:18,117
加上


5028
02:56:18,598 --> 02:56:19,138
克


5029
02:56:19,888 --> 02:56:20,697
因为


5030
02:56:21,147 --> 02:56:21,598
如果


5031
02:56:21,928 --> 02:56:25,619
这封信是一个元音，我们只是想把它转换成g。


5032
02:56:26,459 --> 02:56:27,629
尽管如此


5033
02:56:28,739 --> 02:56:30,301
我基本上可以说


5034
02:56:35,552 --> 02:56:36,092
字母。


5035
02:56:36,452 --> 02:56:40,261
在我们有一个元音的情况下，我要加一个g


5036
02:56:41,012 --> 02:56:42,571
我们没有元音的情况。


5037
02:56:42,812 --> 02:56:43,802
我只是在增加


5038
02:56:43,832 --> 02:56:46,622
不管它是怎么翻译的


5039
02:56:47,042 --> 02:56:49,621
最后在这个for循环下面


5040
02:56:49,651 --> 02:56:51,481
我们只是想返回


5041
02:56:51,541 --> 02:56:53,521
我想说的是


5042
02:56:54,002 --> 02:56:54,752
返回


5043
02:56:54,902 --> 02:56:55,742
翻译。


5044
02:56:56,612 --> 02:56:57,332
现在我们有了


5045
02:56:57,362 --> 02:56:57,933
a


5046
02:56:57,963 --> 02:56:59,462
很棒的翻译功能


5047
02:56:59,492 --> 02:57:00,151
它应该


5048
02:57:00,331 --> 02:57:01,651
可能是这样的


5049
02:57:01,921 --> 02:57:03,781
我们到下面来测试一下


5050
02:57:04,021 --> 02:57:07,562
我们只允许用户输入一些信息


5051
02:57:07,592 --> 02:57:09,513
我将调用这个函数。


5052
02:57:09,663 --> 02:57:11,252
实际上我们要把它打印出来


5053
02:57:11,672 --> 02:57:14,281
我们把它打印出来，我将调用这个函数


5054
02:57:15,991 --> 02:57:16,801
翻译


5055
02:57:17,281 --> 02:57:17,642
并且


5056
02:57:17,672 --> 02:57:19,652
在这里，我要


5057
02:57:19,683 --> 02:57:20,492
通过


5058
02:57:20,822 --> 02:57:21,872
不管用户是什么


5059
02:57:21,902 --> 02:57:22,473
输入


5060
02:57:22,503 --> 02:57:23,133
所以


5061
02:57:23,463 --> 02:57:24,453
我只能说


5062
02:57:26,013 --> 02:57:28,773
在这些括号里，我可以说出了问题


5063
02:57:29,313 --> 02:57:30,813
输入一个短语，


5064
02:57:31,174 --> 02:57:31,983
所以现在


5065
02:57:32,224 --> 02:57:36,216
我把所有这些语句组合在一起我想要打印


5066
02:57:36,246 --> 02:57:36,696
外出


5067
02:57:38,887 --> 02:57:41,228
无论用户输入什么内容。


5068
02:57:42,037 --> 02:57:44,107
让我们继续运行这个程序


5069
02:57:44,138 --> 02:57:45,548
我们会看看我们是怎么做的


5070
02:57:46,208 --> 02:57:47,198
我要运行程序


5071
02:57:47,258 --> 02:57:47,858
上面写着


5072
02:57:47,889 --> 02:57:49,389
输入一个短语，让我


5073
02:57:49,479 --> 02:57:50,859
把这个格式写得更好一点。


5074
02:57:52,300 --> 02:57:52,569
好的


5075
02:57:55,209 --> 02:57:57,549
这就是输入一个短语。


5076
02:57:57,608 --> 02:57:58,810
我们来做一下。


5077
02:57:59,079 --> 02:57:59,529
所以


5078
02:57:59,560 --> 02:58:00,579
让我们输入


5079
02:58:00,729 --> 02:58:02,799
我们在他之前使用的例子


5080
02:58:03,339 --> 02:58:05,919
现在我们跳出来回答这个问题


5081
02:58:05,949 --> 02:58:06,520
d


5082
02:58:06,550 --> 02:58:07,450
g g


5083
02:58:07,750 --> 02:58:08,619
这很酷。


5084
02:58:08,709 --> 02:58:12,218
我们可以一直运行这个数，这样我就可以输入了。


5085
02:58:12,397 --> 02:58:14,346
生存还是毁灭，


5086
02:58:14,826 --> 02:58:16,595
这就像一个长了一点的弦，


5087
02:58:16,984 --> 02:58:17,795
你可以看到


5088
02:58:17,825 --> 02:58:19,627
它将其转化为我们的


5089
02:58:19,657 --> 02:58:20,647
语言草案。


5090
02:58:20,917 --> 02:58:23,227
这就是我们的基本原理


5091
02:58:23,467 --> 02:58:25,956
创建我们的小翻译，

5092
02:58:26,256 --> 02:58:28,356
正如你所看到的，我们使用for循环


5093
02:58:28,387 --> 02:58:30,127
结合


5094
02:58:30,157 --> 02:58:32,466
f循环这是一个非常强大的结构


5095
02:58:32,826 --> 02:58:35,287
实际上这里有一个地方我们可以


5096
02:58:35,347 --> 02:58:37,387
让这个更有效率


5097
02:58:37,627 --> 02:58:38,497
而不是说


5098
02:58:38,527 --> 02:58:38,857
如果


5099
02:58:38,888 --> 02:58:40,058
写信


5100
02:58:40,088 --> 02:58:41,078
这个字符串。


5101
02:58:41,378 --> 02:58:43,898
你会注意到这里我要检查它是否在


5102
02:58:44,049 --> 02:58:46,359
所有的小写和大写。


5103
02:58:46,600 --> 02:58:48,009
我可以直接说


5104
02:58:48,039 --> 02:58:48,609
字母


5105
02:58:48,640 --> 02:58:49,149
点


5106
02:58:49,209 --> 02:58:49,929
下的


5107
02:58:50,738 --> 02:58:51,309
在


5108
02:58:51,488 --> 02:58:54,338
现在我只需要输入小写字母，


5109
02:58:54,488 --> 02:58:56,647
它仍然会做同样的事情


5110
02:58:57,008 --> 02:58:58,027
这有点像


5111
02:58:58,058 --> 02:58:58,538
砍


5112
02:58:58,568 --> 02:58:59,858
或者我们可以使用的任何东西


5113
02:58:59,979 --> 02:59:02,499
这个程序还有一个问题


5114
02:59:02,529 --> 02:59:03,640
你会注意到这里


5115
02:59:03,909 --> 02:59:06,490
我们将平移等同于平移


5116
02:59:06,521 --> 02:59:07,301
加上


5117
02:59:07,421 --> 02:59:08,081
g


5118
02:59:08,351 --> 02:59:09,400
但问题是


5119
02:59:09,431 --> 02:59:10,750
我要开始


5120
02:59:11,320 --> 02:59:14,739
我在这个词里面用大写的元音


5121
02:59:14,770 --> 02:59:16,148
换句话说，如果我说


5122
02:59:16,389 --> 02:59:16,869
在，


5123
02:59:17,560 --> 02:59:19,420
你会注意到，当打印出来的时候，


5124
02:59:19,570 --> 02:59:22,271
它会以小写g的形式打印出来


5125
02:59:22,451 --> 02:59:24,191
所以它没有保留我们的


5126
02:59:24,281 --> 02:59:24,911
大写字母


5127
02:59:24,941 --> 02:59:25,722
句法


5128
02:59:25,962 --> 02:59:27,401
这是一个问题


5129
02:59:27,671 --> 02:59:29,802
我们可以在这里使用另一个if语句


5130
02:59:29,892 --> 02:59:31,152
我们可以检查一下


5131
02:59:32,202 --> 02:59:32,742
如果


5132
02:59:33,762 --> 02:59:34,662
字母点


5133
02:59:34,692 --> 02:59:35,473
是


5134
02:59:36,492 --> 02:59:37,002
上部


5135
02:59:37,782 --> 02:59:39,763
如果字母是大写的


5136
02:59:39,793 --> 02:59:40,303
然后


5137
02:59:40,333 --> 02:59:42,583
我们可以把平移设为


5138
02:59:42,823 --> 02:59:43,634
翻译


5139
02:59:43,664 --> 02:59:44,234
加上


5140
02:59:44,265 --> 02:59:45,314
大写g，


5141
02:59:47,954 --> 02:59:48,944
否则，


5142
02:59:49,274 --> 02:59:51,704
我们可以令它等于小写g。


5143
02:59:52,544 --> 02:59:54,254
现在我们可以控制它了


5144
02:59:54,284 --> 02:59:56,054
这两种情况


5145
02:59:56,594 --> 02:59:58,693
我们来测试一下，看看它是否有效


5146
02:59:59,563 --> 03:00:00,613
重新措辞


5147
03:00:00,883 --> 03:00:01,692
说吧。


5148
03:00:02,112 --> 03:00:03,942
现在我们要保持这个


5149
03:00:04,242 --> 03:00:05,352
大写字母


5150
03:00:05,562 --> 03:00:08,771
这些只是我们能让这个程序变得更好的几种不同的方法，


5151
03:00:09,071 --> 03:00:11,172
但是基本的概念是我们有一个for循环


5152
03:00:11,202 --> 03:00:11,803
然后我们有一些


5153
03:00:11,833 --> 03:00:12,882
如果在里面循环，


5154
03:00:13,122 --> 03:00:17,291
我们把这个很棒的函数叫做，它可以为我们翻译一个单词


5155
03:00:21,191 --> 03:00:25,062
在本教程中，我想和你们讨论一下python中的注释。


5156
03:00:25,362 --> 03:00:32,110
这将是一个很短的教程，我只是想让你们大致了解一下什么是评论，以及如何在我们的python程序中使用它们。


5157
03:00:32,591 --> 03:00:33,431
在这里


5158
03:00:33,521 --> 03:00:36,851
在我的python程序中，我有这条线，上面写着print


5159
03:00:36,881 --> 03:00:37,541
评论


5160
03:00:37,571 --> 03:00:38,262
很有趣。


5161
03:00:38,531 --> 03:00:39,881
如果我运行程序


5162
03:00:40,150 --> 03:00:44,949
在理事会内部，它会打印出评论很有趣，


5163
03:00:45,430 --> 03:00:47,619
我在这里写的任何代码都是


5164
03:00:47,649 --> 03:00:49,629
要用python来执行，


5165
03:00:50,079 --> 03:00:52,059
但实际上有一种特殊的


5166
03:00:52,089 --> 03:00:54,010
我们可以编写的代码行


5167
03:00:54,189 --> 03:00:55,449
它被称为

5168
03:00:55,749 --> 03:01:01,899
注释基本上是我们的python文件中的一行它不会被python渲染，


5169
03:01:02,199 --> 03:01:06,639
所以在python里，它会忽略它不会执行它不会输出任何东西。


5170
03:01:07,059 --> 03:01:09,849
它会忽略它，评论是


5171
03:01:09,879 --> 03:01:12,488
基本上只用于人类，


5172
03:01:12,788 --> 03:01:16,658
因此，我或其他开发人员使用注释


5173
03:01:16,898 --> 03:01:21,876
写一点评论，有点像在文件里的普通税


5174
03:01:22,296 --> 03:01:23,105
也不后退


5175
03:01:23,766 --> 03:01:24,695
我可以用这个


5176
03:01:24,726 --> 03:01:25,926
标签符号。


5177
03:01:26,256 --> 03:01:28,146
点击标签，现在我是


5178
03:01:28,205 --> 03:01:29,285
写评论。


5179
03:01:29,705 --> 03:01:32,343
所以我可以在这里写任何我想要的东西


5180
03:01:32,493 --> 03:01:33,213
这个


5181
03:01:33,843 --> 03:01:34,473
程序


5182
03:01:34,503 --> 03:01:35,283
很酷


5183
03:01:36,093 --> 03:01:36,543
并且


5184
03:01:36,603 --> 03:01:38,372
当我运行程序时，你会注意到


5185
03:01:38,972 --> 03:01:40,502
这在任何地方都不会出现。


5186
03:01:40,562 --> 03:01:42,092
什么都不重要


5187
03:01:42,212 --> 03:01:43,592
我在中场休息时


5188
03:01:43,622 --> 03:01:45,602
这就像被python忽略，


5189
03:01:45,871 --> 03:01:49,111
只是为了我或另一个开发人员来这里使用。


5190
03:01:49,441 --> 03:01:51,960
所以很多时候你想要写得像个小纸条


5191
03:01:51,990 --> 03:01:55,770
在你的python文件里，或者你可以给自己写个小提示。


5192
03:01:56,159 --> 03:01:57,209
或者如果你想写


5193
03:01:57,239 --> 03:01:59,939
一行代码解释一行代码


5194
03:02:00,090 --> 03:02:00,689
举个例子


5195
03:02:00,720 --> 03:02:02,879
我可以写一个注释来解释


5196
03:02:02,909 --> 03:02:04,589
这张打印的声明


5197
03:02:05,909 --> 03:02:06,299
打印


5198
03:02:06,329 --> 03:02:06,689
外出


5199
03:02:06,720 --> 03:02:07,799
一根弦


5200
03:02:07,829 --> 03:02:08,189
对的


5201
03:02:08,459 --> 03:02:12,058
现在，任何看着我的文件的人都能读到这篇文章，他们会说，


5202
03:02:12,117 --> 03:02:13,527
哦，这就是它的作用


5203
03:02:13,558 --> 03:02:13,918
冷却


5204
03:02:14,578 --> 03:02:16,199
因此，注释对于


5205
03:02:16,529 --> 03:02:19,019
在python文件中留下很少的注释


5206
03:02:19,318 --> 03:02:20,068
你想要


5207
03:02:20,128 --> 03:02:21,568
多行注释。


5208
03:02:21,778 --> 03:02:24,658
你可以创建一个新行并使用另一个标签


5209
03:02:24,958 --> 03:02:27,566
这样我就可以输入我的下一个评论了


5210
03:02:27,896 --> 03:02:32,877
我的意思是，一般来说如果你要在多行中添加注释你想要使用多个哈希标签


5211
03:02:33,327 --> 03:02:33,657
图


5212
03:02:33,688 --> 03:02:36,746
实际上还有另一种方法可以写出注释


5213
03:02:36,776 --> 03:02:38,486
所以你可以用三倍的


5214
03:02:38,756 --> 03:02:41,485
引号，所以我要输入这些单引号


5215
03:02:42,355 --> 03:02:44,064
我输入的不是三次


5216
03:02:44,095 --> 03:02:45,295
你们可以看到，


5217
03:02:45,625 --> 03:02:48,654
上面这里是三次，我们有三次。


5218
03:02:48,895 --> 03:02:52,586
在这里，我可以写任何我想要的评论，这样我就可以


5219
03:02:52,616 --> 03:02:53,275
让你知道


5220
03:02:53,545 --> 03:02:55,405
在这里我想要的税。


5221
03:02:56,215 --> 03:02:56,814
并且


5222
03:02:56,904 --> 03:02:58,854
当我运行这个程序时也是一样的。


5223
03:02:58,975 --> 03:03:00,774
它是不会被渲染的


5224
03:03:00,805 --> 03:03:02,544
这是另一种方法


5225
03:03:02,574 --> 03:03:04,494
多行注释


5226
03:03:04,854 --> 03:03:08,785
但是链接官方的python喜欢样式指南之类的


5227
03:03:08,995 --> 03:03:14,215
建议如果你要在多行中添加注释你使用了这些标签


5228
03:03:14,515 --> 03:03:17,484
你知道你可以做任何你想做的事但是如果你想成为超级棒


5229
03:03:17,515 --> 03:03:18,925
然后是python官员


5230
03:03:19,255 --> 03:03:20,334
使用这些标签


5231
03:03:21,144 --> 03:03:22,974
注释也可以用于


5232
03:03:23,004 --> 03:03:26,062
做一些事情，叫做注释掉一行代码。


5233
03:03:26,362 --> 03:03:28,221
很多时候，当你在写程序的时候，


5234
03:03:28,431 --> 03:03:30,410
你可能会有一行代码


5235
03:03:30,500 --> 03:03:30,980
那


5236
03:03:31,011 --> 03:03:33,771
可能是在制造东西。


5237
03:03:34,191 --> 03:03:36,411
所以你可以做的是你可以评论


5238
03:03:36,441 --> 03:03:37,971
在这行代码中


5239
03:03:38,181 --> 03:03:40,911
我可以在这行代码前面加上注释。


5240
03:03:41,211 --> 03:03:42,951
现在当我运行程序时。


5241
03:03:43,071 --> 03:03:44,481
程序将会运行，


5242
03:03:44,661 --> 03:03:45,981
但它不会使用


5243
03:03:46,041 --> 03:03:46,851
这条线


5244
03:03:47,061 --> 03:03:49,940
所以有时候，如果你想知道是否像一行代码


5245
03:03:50,091 --> 03:03:54,199
如果没有一行代码，就会给你带来麻烦或者你想知道你的程序会是什么样子


5246
03:03:54,439 --> 03:03:55,939
或者就像一段代码，


5247
03:03:56,119 --> 03:03:57,379
你可以评论一下。


5248
03:03:57,559 --> 03:03:59,989
这样你就不会删除代码了


5249
03:04:00,020 --> 03:04:01,130
从你的档案中


5250
03:04:01,340 --> 03:04:04,130
你只是在评论，所以蟒蛇会忽略它，


5251
03:04:04,460 --> 03:04:08,149
这些都是评论的两种用法用来写小纸条


5252
03:04:08,749 --> 03:04:10,519
对不同事物的评论


5253
03:04:10,549 --> 03:04:11,718
或者评论


5254
03:04:11,748 --> 03:04:12,828
输出代码


5255
03:04:13,038 --> 03:04:14,418
当你前进和python的时候


5256
03:04:14,448 --> 03:04:16,338
我相信你会发现


5257
03:04:16,368 --> 03:04:17,059
评论


5258
03:04:20,839 --> 03:04:23,419
在本教程中，我将向你们介绍


5259
03:04:23,449 --> 03:04:25,220
捕捉错误


5260
03:04:25,250 --> 03:04:25,880
python，


5261
03:04:26,300 --> 03:04:28,549
很多时候我们在编写python程序时


5262
03:04:28,938 --> 03:04:29,898
你会遇到


5263
03:04:29,929 --> 03:04:32,327
错误的情况会出现不同的情况


5264
03:04:32,597 --> 03:04:35,985
你的程序可能会抛出一个错误或者它可能抛出一个异常。


5265
03:04:36,315 --> 03:04:37,604
很多时候


5266
03:04:37,635 --> 03:04:41,234
情况发生时完全停止了你的程序运行。


5267
03:04:41,954 --> 03:04:44,834
我们能做的是，我们可以关注


5268
03:04:44,894 --> 03:04:47,294
你知道会有一些特定的错误


5269
03:04:47,324 --> 03:04:49,904
在我们的程序中出现，我们可以处理它们。


5270
03:04:50,294 --> 03:04:53,475
因此，我们的程序不只是破坏和停止执行，


5271
03:04:53,625 --> 03:04:57,255
我们可以处理这些错误并在发生的时候做一些事情


5272
03:04:57,615 --> 03:05:01,726
我想给你们展示一个用这个的例子我说的是number等于


5273
03:05:01,785 --> 03:05:02,295
它的


5274
03:05:02,745 --> 03:05:03,944
输入输入一个数字，


5275
03:05:04,185 --> 03:05:07,635
基本上，我在提示用户输入一个数字


5276
03:05:07,665 --> 03:05:08,895
使用这个输入命令


5277
03:05:09,404 --> 03:05:11,774
然后我要转换输入的内容


5278
03:05:11,895 --> 03:05:12,824
变成一个整数。


5279
03:05:13,305 --> 03:05:17,685
所以只要它们像一个有效整数一样输入，我就可以把它转换成整数。


5280
03:05:18,104 --> 03:05:20,265
所以我可以把它转换成一个整数


5281
03:05:20,505 --> 03:05:22,695
我可以把它存储在这个数字变量里


5282
03:05:22,726 --> 03:05:25,486
我把它打印出来，让我们试着执行这个程序，


5283
03:05:25,906 --> 03:05:26,985
我要讲的是这个项目


5284
03:05:27,855 --> 03:05:29,834
你会看到这里写着输入一个数字，


5285
03:05:30,134 --> 03:05:32,624
比如，我们可以输入4个


5286
03:05:33,044 --> 03:05:36,942
当我回答4个问题时，一切都会起作用，它会打印出4个


5287
03:05:37,002 --> 03:05:38,261
世界上一切都是正确的。


5288
03:05:38,951 --> 03:05:41,801
实际上我要修改这个看起来更容易看到。


5289
03:05:42,400 --> 03:05:44,260
但是如果我们再次运行这个程序呢？


5290
03:05:44,560 --> 03:05:46,270
它说，好，输入你的数字。


5291
03:05:46,449 --> 03:05:51,640
假设我打破了规则可能不会输入一个数字所以它忽略了提示说了什么我放了


5292
03:05:52,120 --> 03:05:52,480
你知道


5293
03:05:52,511 --> 03:05:53,860
这里有一些随机的文本，


5294
03:05:54,400 --> 03:05:56,142
当我输入这个的时候


5295
03:05:56,741 --> 03:05:58,392
程序会抛出一个错误，


5296
03:05:58,542 --> 03:06:00,853
你看这里，它说的是价值误差


5297
03:06:01,122 --> 03:06:01,632
无效的


5298
03:06:01,662 --> 03:06:03,103
蚂蚁的字面意思


5299
03:06:03,133 --> 03:06:03,673
基础


5300
03:06:03,703 --> 03:06:04,483
用巴斯托芬


5301
03:06:04,813 --> 03:06:05,474
基本上


5302
03:06:05,504 --> 03:06:06,704
铺面和回答


5303
03:06:06,854 --> 03:06:07,694
一个整数


5304
03:06:07,725 --> 03:06:08,504
你说你会


5305
03:06:08,773 --> 03:06:09,193
写。


5306
03:06:09,373 --> 03:06:10,962
我们让他们输入一个数字


5307
03:06:10,992 --> 03:06:12,402
他们输入文本


5308
03:06:12,522 --> 03:06:13,873
所以它破坏了程序。


5309
03:06:14,443 --> 03:06:14,833
并且


5310
03:06:14,863 --> 03:06:20,530
这是一种经常发生的情况所以在我们的项目中有很多事情可能会出错。


5311
03:06:20,920 --> 03:06:24,009
到目前为止，我们已经接受了它作为一个现实


5312
03:06:24,039 --> 03:06:24,520
但是


5313
03:06:24,729 --> 03:06:27,190
如果你正在编写一个真正的实时python程序


5314
03:06:27,221 --> 03:06:30,162
你不想要这样的东西来绊倒你的程序，


5315
03:06:30,312 --> 03:06:34,031
当有人忘记输入数字时你不希望整个程序崩溃


5316
03:06:34,361 --> 03:06:34,571
对的


5317
03:06:34,602 --> 03:06:37,271
你想要能够处理所有这些不同的情况，


5318
03:06:38,142 --> 03:06:39,732
为了处理它们，我们可以使用


5319
03:06:39,763 --> 03:06:42,313
一种叫做尝试的东西


5320
03:06:42,613 --> 03:06:46,364
试着接受博客基本上允许你的程序尝试


5321
03:06:46,994 --> 03:06:47,894
一段代码，


5322
03:06:48,044 --> 03:06:50,204
如果一切顺利，我们就会很好


5323
03:06:50,414 --> 03:06:52,545
我们可以试着输入这个数字


5324
03:06:52,575 --> 03:06:54,555
如果用户输入正确的数字，


5325
03:06:54,854 --> 03:06:58,334
但是如果他们没有输入正确的数字那么我们基本上可以


5326
03:06:58,424 --> 03:07:02,683
因此，当他们被要求以数字形式呈现时，他们会以字符串的形式输入。


5327
03:07:02,982 --> 03:07:05,441
我们可以告诉他们，你输入了错误的东西


5328
03:07:05,892 --> 03:07:09,911
我相信你们可以用这些试着接受块会出现在这里


5329
03:07:10,271 --> 03:07:11,651
我想说的是


5330
03:07:12,432 --> 03:07:13,302
做一个冒号。


5331
03:07:13,602 --> 03:07:14,892
我想要缩进。


5332
03:07:14,981 --> 03:07:15,971
这两件事。


5333
03:07:16,121 --> 03:07:18,760
所以这两个东西都在这个里面


5334
03:07:18,790 --> 03:07:19,900
试块。


5335
03:07:20,290 --> 03:07:23,259
现在我要新建一条线，我要到这里来，我要把它录下来


5336
03:07:24,068 --> 03:07:24,849
除了。


5337
03:07:25,028 --> 03:07:26,707
我还会在这里放一个冒号，


5338
03:07:27,097 --> 03:07:29,917
在这里，我要打印一些东西所以我就说


5339
03:07:30,427 --> 03:07:31,117
无效的


5340
03:07:31,147 --> 03:07:31,657
输入。


5341
03:07:32,167 --> 03:07:32,917
现在


5342
03:07:32,947 --> 03:07:35,945
因为我把这个代码放到这个try块中。


5343
03:07:36,665 --> 03:07:38,766
如果用户输入错误


5344
03:07:38,796 --> 03:07:42,487
它将能够捕捉到它这样它就能捕捉到用户做错了什么


5345
03:07:42,787 --> 03:07:43,627
打印出来


5346
03:07:43,657 --> 03:07:45,547
对流的输入无效。


5347
03:07:45,877 --> 03:07:47,587
让我们继续运行我们的程序。


5348
03:07:48,517 --> 03:07:50,197
它会说输入一个数字。


5349
03:07:50,348 --> 03:07:52,717
所以我们要忽略它会进入这个末端


5350
03:07:53,017 --> 03:07:55,508
而不是在破坏程序时对我们大吼大叫


5351
03:07:55,538 --> 03:07:56,468
只是说，嘿


5352
03:07:56,498 --> 03:07:57,368
无效

5353
03:07:58,059 --> 03:08:02,919
所以能够处理他们被称为的错误它能够处理

5354
03:08:02,949 --> 03:08:03,850
输入误差


5355
03:08:04,180 --> 03:08:05,800
基本上就是告诉我们


5356
03:08:06,100 --> 03:08:06,910
没有任何

5357
03:08:07,330 --> 03:08:07,960
所以


5358
03:08:07,990 --> 03:08:11,200
这是我们在python程序中可以做的非常强大的事情


5359
03:08:11,561 --> 03:08:13,480
基本上就是为了保护我们的项目


5360
03:08:13,511 --> 03:08:13,811
对的


5361
03:08:14,080 --> 03:08:17,050
如果我想让我的程序运行很长一段时间


5362
03:08:17,080 --> 03:08:19,510
我不能有像病人那样简单的东西


5363
03:08:19,540 --> 03:08:19,960
输入


5364
03:08:19,990 --> 03:08:20,650
把它绊倒


5365
03:08:20,920 --> 03:08:24,158
所以我可以用这些方法来捕获无效的

5366
03:08:24,188 --> 03:08:24,729
积木。


5367
03:08:24,969 --> 03:08:26,737
但是你注意到的是


5368
03:08:26,768 --> 03:08:28,447
下面的小男孩


5369
03:08:28,688 --> 03:08:29,348
高亮显示。


5370
03:08:29,768 --> 03:08:32,587
让我们看看它有什么要说的所以它基本上是在说


5371
03:08:32,797 --> 03:08:34,988
两个宽泛的例外条款。


5372
03:08:35,588 --> 03:08:36,038
并且


5373
03:08:36,068 --> 03:08:39,668
这是我们得到的信息因为当我说接受时


5374
03:08:39,758 --> 03:08:40,658
这将会捕捉到


5375
03:08:40,688 --> 03:08:44,587
在太阳下的任何错误都可以在我的程序中出错


5376
03:08:44,617 --> 03:08:46,148
这将会接受它


5377
03:08:46,898 --> 03:08:48,157
让我给你们举个例子，


5378
03:08:48,427 --> 03:08:50,557
假设我在我的程序中


5379
03:08:50,646 --> 03:08:52,388
我在创建一个变量，所以我是


5380
03:08:52,418 --> 03:08:52,628
将要


5381
03:08:52,658 --> 03:08:54,219
创建一个名为


5382
03:08:54,549 --> 03:08:57,877
我把它设为10除以0。


5383
03:08:58,327 --> 03:08:59,467
如果你对数学有所了解的话


5384
03:08:59,497 --> 03:09:02,978
你会知道你不能把一个数字除以0，这是不可能的。


5385
03:09:03,218 --> 03:09:03,698
所以


5386
03:09:03,729 --> 03:09:04,508
程序


5387
03:09:04,538 --> 03:09:08,229
无法处理这个问题，你会发现这将给我们带来一个错误。


5388
03:09:08,498 --> 03:09:09,729
所以我运行程序。


5389
03:09:10,179 --> 03:09:11,169
基本上是说


5390
03:09:11,199 --> 03:09:13,360
零分裂为零，


5391
03:09:13,420 --> 03:09:14,771
我们不允许这样做。


5392
03:09:15,311 --> 03:09:19,062
如果我把这个放到这个try块中。


5393
03:09:20,441 --> 03:09:20,951
并且


5394
03:09:20,981 --> 03:09:22,481
我把它粘贴在这里，


5395
03:09:23,201 --> 03:09:25,452
它会被这个异常所捕获


5396
03:09:25,482 --> 03:09:29,351
我们在这里写的所以它会被那个接受和当我运行程序时


5397
03:09:29,650 --> 03:09:30,850
你会看到它说


5398
03:09:30,909 --> 03:09:31,960
无效输入。


5399
03:09:32,590 --> 03:09:34,449
但问题是我们没有


5400
03:09:34,539 --> 03:09:36,069
输入无效的东西


5401
03:09:36,220 --> 03:09:36,640
对的


5402
03:09:37,000 --> 03:09:38,351
我们只是除以0


5403
03:09:38,381 --> 03:09:39,101
但事实并非如此


5404
03:09:39,131 --> 03:09:40,301
能够处理这个问题。


5405
03:09:40,360 --> 03:09:42,610
所以它不能除以0


5406
03:09:42,700 --> 03:09:43,540
它通过一个错误。


5407
03:09:43,600 --> 03:09:45,580
所以即使我们没有得到一个无效的


5408
03:09:45,610 --> 03:09:49,301
输入，尽管它是由于我们除以0它仍然打印出来。


5409
03:09:49,631 --> 03:09:52,781
这让我想起另一个问题是我们可以抓住


5410
03:09:53,081 --> 03:09:54,191
或者我们可以接受


5411
03:09:54,222 --> 03:09:56,441
特定类型的错误。


5412
03:09:56,711 --> 03:09:57,761
举个例子


5413
03:09:57,940 --> 03:10:00,340
在这种情况下，我们得到了一个零误差的除法


5414
03:10:00,550 --> 03:10:01,779
在这种情况下，我们得到了


5415
03:10:01,869 --> 03:10:03,879
一个无效的输入空气


5416
03:10:03,909 --> 03:10:05,198
把你的东西放进去，你错了


5417
03:10:05,229 --> 03:10:06,699
可以转换值。


5418
03:10:06,879 --> 03:10:12,100
所以我可以创建两个不同的块来捕捉两种不同类型的错误


5419
03:10:12,460 --> 03:10:16,869
我可以创建一个空间，我可以指定我想要捕捉的错误类型。


5420
03:10:17,139 --> 03:10:19,630
所以当我们除以0时


5421
03:10:19,870 --> 03:10:21,490
零分区空气。


5422
03:10:21,910 --> 03:10:24,340
所以如果我在这里输入零除法误差。


5423
03:10:24,580 --> 03:10:27,640
现在它将会在后面捕捉到零分割所以我可以说


5424
03:10:28,239 --> 03:10:29,920
除以0。


5425
03:10:30,310 --> 03:10:32,950
我也可以让另一个接受我可以说


5426
03:10:33,040 --> 03:10:33,790
接受


5427
03:10:34,210 --> 03:10:34,780
并且


5428
03:10:34,900 --> 03:10:38,080
我们可以捕捉到另一个例外情况所以我认为是这样的


5429
03:10:38,320 --> 03:10:40,000
现在的价值空气是


5430
03:10:40,120 --> 03:10:42,220
我们输入了错误的值


5431
03:10:42,580 --> 03:10:43,661
在里面


5432
03:10:43,812 --> 03:10:45,762
输入，现在我们可以打印出来


5433
03:10:46,092 --> 03:10:47,202
无效输入。


5434
03:10:47,442 --> 03:10:47,982
所以


5435
03:10:48,013 --> 03:10:51,854
这两个除外块基本上可以同时处理这两种情况


5436
03:10:51,884 --> 03:10:53,084
情况


5437
03:10:53,414 --> 03:10:54,314
例如，如果


5438
03:10:54,345 --> 03:10:57,314
这就把这个程序分解成零，


5439
03:10:57,675 --> 03:11:00,794
然后它就能捕捉到这一点，它会告诉我们。


5440
03:11:00,854 --> 03:11:01,334
嘿


5441
03:11:01,394 --> 03:11:02,534
你除以0，


5442
03:11:02,954 --> 03:11:04,635
但是如果我要摆脱


5443
03:11:04,665 --> 03:11:05,775
这行代码，


5444
03:11:06,976 --> 03:11:07,695
我只是


5445
03:11:07,905 --> 03:11:09,135
输入错误的数字


5446
03:11:09,375 --> 03:11:10,995
所以我来到这里，我回答


5447
03:11:11,025 --> 03:11:12,346
一串数字。


5448
03:11:12,615 --> 03:11:13,517
现在它将会


5449
03:11:13,547 --> 03:11:15,108
告诉我们无效输入


5450
03:11:15,318 --> 03:11:16,968
我们将能够指定


5451
03:11:16,998 --> 03:11:19,248
当某些东西断裂时会发生什么。


5452
03:11:19,518 --> 03:11:20,777
所以当我们得到一个有效的


5453
03:11:20,837 --> 03:11:23,117
当我们得到一个值错误时我们可以说是无效的


5454
03:11:23,147 --> 03:11:23,628
输入。


5455
03:11:23,688 --> 03:11:29,928
当我们得到一个零除法误差时我们可以说除以0，根据发生的情况而定，


5456
03:11:30,348 --> 03:11:31,548
实际上我们可以


5457
03:11:31,578 --> 03:11:32,868
做不同的事情，


5458
03:11:33,138 --> 03:11:34,067
我想给大家展示一下


5459
03:11:34,098 --> 03:11:35,748
我们还能做的一件事就是


5460
03:11:35,928 --> 03:11:37,578
我们可以储存


5461
03:11:37,608 --> 03:11:38,118
这个


5462
03:11:38,178 --> 03:11:39,768
错误是一个变量。


5463
03:11:39,857 --> 03:11:41,327
所以我只能说


5464
03:11:41,567 --> 03:11:42,798
我可以说


5465
03:11:42,978 --> 03:11:46,216
我可以在这里输入一个名字所以很多时候人们会说。


5466
03:11:46,275 --> 03:11:47,236
你们是我们的


5467
03:11:48,076 --> 03:11:48,976
下面这里


5468
03:11:49,216 --> 03:11:52,306
我可以打印出实际的错误这样我就可以打印出来了


5469
03:11:52,786 --> 03:11:53,656
e r r。


5470
03:11:53,926 --> 03:11:56,027
所以如果我们最后除以0。


5471
03:11:57,047 --> 03:12:00,167
所以如果我说答案等于10除以0。


5472
03:12:00,797 --> 03:12:03,076
我们要抛出这个错误，它会打印出来


5473
03:12:03,106 --> 03:12:04,756
出了什么问题


5474
03:12:04,786 --> 03:12:06,227
现在我可以运行这个程序了


5475
03:12:06,496 --> 03:12:07,636
它只是说


5476
03:12:08,025 --> 03:12:09,105
除以零


5477
03:12:09,136 --> 03:12:09,496
所以


5478
03:12:09,526 --> 03:12:10,486
刚刚打印出来


5479
03:12:10,517 --> 03:12:11,747
我们得到的误差。


5480
03:12:12,077 --> 03:12:14,747
这是另一个有用的东西你可以打印出来


5481
03:12:14,777 --> 03:12:17,209
抛出了一个特定的错误。


5482
03:12:17,389 --> 03:12:17,898
现在


5483
03:12:18,049 --> 03:12:21,081
python的最佳实践是使用这些


5484
03:12:21,111 --> 03:12:23,751
特定的错误，所以你总是想要接受


5485
03:12:23,781 --> 03:12:25,521
除了特定的


5486
03:12:25,552 --> 03:12:25,912
错误


5487
03:12:27,472 --> 03:12:29,271
当你不想做的时候只是说


5488
03:12:29,302 --> 03:12:30,202
除了


5489
03:12:30,592 --> 03:12:31,162
并且


5490
03:12:31,372 --> 03:12:33,472
然后接受太阳底下的任何东西。


5491
03:12:34,042 --> 03:12:35,332
这太宽泛了


5492
03:12:36,022 --> 03:12:40,612
如果不是在好的实践和python中你想要捕捉到这样的具体

5493
03:12:44,422 --> 03:12:47,393
在本教程中，我们将与你们讨论阅读


5494
03:12:47,452 --> 03:12:48,951
外部文件


5495
03:12:48,981 --> 03:12:49,672
python，


5496
03:12:50,152 --> 03:12:52,700
你知道很多时候在python里你会想要


5497
03:12:52,730 --> 03:12:53,330
阅读


5498
03:12:53,360 --> 03:12:56,781
从您的python文件之外的文件中，


5499
03:12:57,081 --> 03:13:02,959
因此，您可能想要从文本文件、csv文件或html文件中读取信息。


5500
03:13:03,890 --> 03:13:06,800
你可以使用一种叫做python的东西


5501
03:13:06,859 --> 03:13:09,229
读命令，它会允许你


5502
03:13:09,260 --> 03:13:10,520
阅读文件


5503
03:13:10,729 --> 03:13:15,980
它存储在你的python文件之外你可以使用这些文件来获取信息或者你可以


5504
03:13:16,190 --> 03:13:18,800
解析不同的文件，做不同的事情。


5505
03:13:19,160 --> 03:13:20,751
所以我要给你们展示一些基础知识


5506
03:13:22,132 --> 03:13:23,692
打开文件关闭文件


5507
03:13:23,723 --> 03:13:24,863
做所有这些事情


5508
03:13:25,224 --> 03:13:26,903
这里是这个


5509
03:13:26,934 --> 03:13:27,653
锉


5510
03:13:28,373 --> 03:13:29,933
被称为员工点文本


5511
03:13:30,232 --> 03:13:33,533
它基本上列出了一群不同的员工


5512
03:13:33,773 --> 03:13:36,204
这些可以是办公室里的员工。


5513
03:13:36,564 --> 03:13:38,484
所以它只是列出了所有这些


5514
03:13:38,515 --> 03:13:39,385
信息。


5515
03:13:39,654 --> 03:13:43,975
假设在我的app中，我想要读取的


5516
03:13:44,034 --> 03:13:45,414
员工


5517
03:13:45,624 --> 03:13:46,974
在这个文件的内部。


5518
03:13:47,273 --> 03:13:49,254
我要做的第一件事是


5519
03:13:49,313 --> 03:13:50,964
从内部打开文件


5520
03:13:50,994 --> 03:13:51,624
python。


5521
03:13:51,954 --> 03:13:53,664
所以我可以使用一个特殊的命令


5522
03:13:53,694 --> 03:13:54,354
呼叫


5523
03:13:54,624 --> 03:13:55,164
打开。


5524
03:13:55,434 --> 03:13:56,454
所以我可以打开


5525
03:13:56,754 --> 03:13:57,084
然后


5526
03:13:57,114 --> 03:14:00,083
在这里，我可以输入我想要的文件的名称


5527
03:14:00,113 --> 03:14:03,232
打开，这要么是文件的相对路径。


5528
03:14:03,502 --> 03:14:05,572
对文件的绝对路径


5529
03:14:05,632 --> 03:14:07,492
只是文件名


5530
03:14:08,332 --> 03:14:09,112
两个文件


5531
03:14:09,143 --> 03:14:10,762
在我的案例中相同的目录中


5532
03:14:11,212 --> 03:14:13,671
应用点python和员工点文本


5533
03:14:13,701 --> 03:14:15,561
在同一个文件夹里


5534
03:14:15,740 --> 03:14:19,997
在同一个目录下，我可以输入文件的名字，喜欢说


5535
03:14:20,327 --> 03:14:22,097
员工点文字。


5536
03:14:22,486 --> 03:14:25,605
我还想再讲一件事


5537
03:14:25,636 --> 03:14:26,535
开放函数，


5538
03:14:26,686 --> 03:14:27,886
它将会是模式


5539
03:14:27,916 --> 03:14:29,626
我想要打开文件


5540
03:14:29,866 --> 03:14:31,516
你可以在里面打开文件


5541
03:14:31,546 --> 03:14:32,835
有几种不同的模式


5542
03:14:33,075 --> 03:14:35,235
第一个模式叫做read


5543
03:14:35,415 --> 03:14:36,194
所以我只写了一个


5544
03:14:36,225 --> 03:14:38,205
这里的r，这将代表一个解读


5545
03:14:38,505 --> 03:14:44,982
这基本上意味着，我只想读取文件中的信息我不想修改它，我不想修改它


5546
03:14:45,013 --> 03:14:45,643
改变它。


5547
03:14:45,973 --> 03:14:50,442
我只是想读一下，我只是想看看文件里有什么，在没有信息的情况下做一些事情。


5548
03:14:50,893 --> 03:14:51,553
另一个


5549
03:14:51,643 --> 03:14:52,902
模式被称为正确


5550
03:14:52,933 --> 03:14:54,372
所以我可以输入这个w


5551
03:14:54,702 --> 03:14:56,532
写作基本上意味着你可以


5552
03:14:56,592 --> 03:14:58,451
修改文件，你可以写


5553
03:14:58,481 --> 03:15:01,032
新的信息，您可以更改现有的信息。


5554
03:15:01,603 --> 03:15:02,593
还有一个叫做


5555
03:15:02,623 --> 03:15:03,163
a


5556
03:15:03,583 --> 03:15:03,883
并且


5557
03:15:03,913 --> 03:15:05,502
a代表钢笔。


5558
03:15:05,802 --> 03:15:07,662
这基本上意味着你可以


5559
03:15:07,782 --> 03:15:10,721
将信息附加到文件的末尾


5560
03:15:10,900 --> 03:15:13,301
您不能修改文件中的任何信息。


5561
03:15:13,451 --> 03:15:15,041
你不能改变任何信息


5562
03:15:15,071 --> 03:15:15,641
但是你可以


5563
03:15:15,700 --> 03:15:16,120
加


5564
03:15:16,150 --> 03:15:17,351
新信息。


5565
03:15:17,681 --> 03:15:19,091
还有一个问题是


5566
03:15:19,181 --> 03:15:19,570
r


5567
03:15:19,601 --> 03:15:20,320
加上


5568
03:15:20,561 --> 03:15:21,971
这基本上意味着


5569
03:15:22,001 --> 03:15:22,601
阅读


5570
03:15:22,631 --> 03:15:24,401
写下来，这样就能给你


5571
03:15:24,461 --> 03:15:26,922
所有的阅读和写作的力量。


5572
03:15:27,072 --> 03:15:27,882
在我们的例子中，


5573
03:15:28,212 --> 03:15:29,562
我们将会和


5574
03:15:29,622 --> 03:15:32,081
有规律的，所以我们要

5575
03:15:32,111 --> 03:15:33,281
从文件中。


5576
03:15:33,791 --> 03:15:36,131
这个开放函数本质上就是


5577
03:15:36,161 --> 03:15:36,791
打开


5578
03:15:36,821 --> 03:15:37,541
那


5579
03:15:37,601 --> 03:15:38,801
文件，所以它会喜欢


5580
03:15:38,831 --> 03:15:40,811
我们的文件系统中的黄金映射文件


5581
03:15:40,841 --> 03:15:41,470
打开它


5582
03:15:41,770 --> 03:15:43,600
它会让我们通读一遍


5583
03:15:43,779 --> 03:15:46,239
但一般来说，我们要存储这个


5584
03:15:46,270 --> 03:15:47,319
打开文件


5585
03:15:47,350 --> 03:15:49,211
在一个变量里面


5586
03:15:49,541 --> 03:15:51,911
我可以创建一个变量，我们可以调用它


5587
03:15:52,392 --> 03:15:53,892
员工档案。


5588
03:15:54,161 --> 03:15:55,090
我要把它设置好


5589
03:15:55,120 --> 03:15:56,440
等于这个


5590
03:15:56,471 --> 03:15:57,370
打开函数。


5591
03:15:57,640 --> 03:15:58,480
所以现在


5592
03:15:58,511 --> 03:16:00,940
开放的员工点文本文件


5593
03:16:00,971 --> 03:16:02,651
里面的所有内容


5594
03:16:03,041 --> 03:16:04,450
存储在这个里面


5595
03:16:04,480 --> 03:16:05,591
员工档案


5596
03:16:05,621 --> 03:16:06,341
变量。


5597
03:16:06,791 --> 03:16:07,211
现在


5598
03:16:07,271 --> 03:16:07,900
无论何时


5599
03:16:08,860 --> 03:16:10,630
你总是想要确保


5600
03:16:10,660 --> 03:16:12,911
关闭文件


5601
03:16:13,271 --> 03:16:15,013
就像我们有这个开放的命令


5602
03:16:15,043 --> 03:16:16,033
我们也有


5603
03:16:16,063 --> 03:16:16,453
在


5604
03:16:16,543 --> 03:16:17,323
关闭


5605
03:16:17,354 --> 03:16:19,334
所以我可以到这里来，说。


5606
03:16:19,844 --> 03:16:20,624
雇员


5607
03:16:20,654 --> 03:16:21,345
锉


5608
03:16:21,375 --> 03:16:21,945
点


5609
03:16:22,096 --> 03:16:22,876
衣服。


5610
03:16:23,236 --> 03:16:23,626
并且


5611
03:16:23,656 --> 03:16:29,177
这本质上就是关闭文件所以我们将不再能够访问它


5612
03:16:29,537 --> 03:16:36,738
一般来说，当你打开一个文件的时候这是个好主意你也要确保你在某一时刻关闭了文件


5613
03:16:36,889 --> 03:16:39,019
一旦你读完它，你就可以把它关掉。


5614
03:16:39,288 --> 03:16:41,778
这就像是我们如何打开和关闭文件。


5615
03:16:42,139 --> 03:16:45,498
现在我们来谈谈如何从最右边获取信息


5616
03:16:45,528 --> 03:16:48,110
没有任何意义的文件我们不知道它里面是什么


5617
03:16:48,141 --> 03:16:48,561
所以


5618
03:16:48,740 --> 03:16:51,680
实际上我们可以使用一些不同的函数


5619
03:16:51,739 --> 03:16:54,800
在这个员工的身上，他想弄清楚里面到底是什么。


5620
03:16:55,250 --> 03:16:56,270
我要给你们看


5621
03:16:56,300 --> 03:16:58,278
其中一些，我要做一个打印声明。


5622
03:16:59,388 --> 03:17:02,688
在这个打印语句里面基本上只打印出一些信息


5623
03:17:02,718 --> 03:17:04,997
关于员工档案


5624
03:17:05,837 --> 03:17:08,747
我们能打印出来的最基本的东西就是整个


5625
03:17:08,897 --> 03:17:10,217
文件的内容。


5626
03:17:10,486 --> 03:17:13,216
但在此之前，我想向你们展示如何检查


5627
03:17:13,246 --> 03:17:15,465
确保文件是可读的。


5628
03:17:15,795 --> 03:17:19,427
所以在我们做其他事情之前通常是一个好主意


5629
03:17:19,457 --> 03:17:21,558
有可能读取这个文件。


5630
03:17:21,947 --> 03:17:22,427
这是


5631
03:17:22,457 --> 03:17:23,597
函数


5632
03:17:23,656 --> 03:17:25,517
在python内部，我们可以使用调用


5633
03:17:25,547 --> 03:17:27,407
可读，所以我要输入输出


5634
03:17:28,308 --> 03:17:29,388
文件不太好


5635
03:17:29,418 --> 03:17:30,048
点


5636
03:17:31,488 --> 03:17:32,179
可读。


5637
03:17:32,629 --> 03:17:33,019
并且


5638
03:17:33,049 --> 03:17:39,677
它会返回一个布尔值它会告诉我们是否可以从这个文件中读取所以我要运行我的程序


5639
03:17:40,547 --> 03:17:43,547
你会看到这里我们得到了一个真值


5640
03:17:43,877 --> 03:17:46,098
这是因为我们把文件设置为


5641
03:17:46,128 --> 03:17:46,998
读


5642
03:17:47,058 --> 03:17:49,396
模式是在阅读模式下，我们可以从中读到。


5643
03:17:49,666 --> 03:17:50,625
如果我要


5644
03:17:50,685 --> 03:17:52,845
这里是w，所以如果我把它放在右边


5645
03:17:53,114 --> 03:17:53,685
现在


5646
03:17:53,715 --> 03:17:58,306
加倍将是错误的因为我们不能再读取我们只能写入的文件


5647
03:17:58,336 --> 03:17:59,506
到文件中


5648
03:17:59,596 --> 03:18:00,705
我要去


5649
03:18:00,735 --> 03:18:03,286
把这个改回我们，这样我们就可以读了。


5650
03:18:03,796 --> 03:18:07,006
所以一旦你弄清楚文件是否可以被读取


5651
03:18:07,036 --> 03:18:07,786
让我们


5652
03:18:08,056 --> 03:18:09,286
实际上是这样读的


5653
03:18:09,586 --> 03:18:15,770
还有另一个函数叫employee file dot read这基本上就是把文件中的所有信息都吐出来了


5654
03:18:15,800 --> 03:18:17,209
当我运行程序时


5655
03:18:17,239 --> 03:18:18,561
它会吐出来


5656
03:18:18,591 --> 03:18:19,642
所有这些


5657
03:18:19,672 --> 03:18:22,701
所有信息都不是那个文件里的信息。


5658
03:18:23,062 --> 03:18:29,392
我也可以到下面这里我们可以在这个文件中读取一条单独的行这样我就可以说是employee归档了


5659
03:18:29,422 --> 03:18:30,412
读行。


5660
03:18:30,652 --> 03:18:33,833
它要做的是读取一条单独的行


5661
03:18:34,253 --> 03:18:35,873
在这个文件的内部


5662
03:18:36,173 --> 03:18:40,972
当我运行这个程序时，你会看到它只是读取文件中的第一行。


5663
03:18:41,092 --> 03:18:43,611
这个红色的线函数实际上是


5664
03:18:43,642 --> 03:18:48,591
读第一行，然后它基本上就像把光标移动到下一行


5665
03:18:48,831 --> 03:18:50,900
如果我要复制这行代码，


5666
03:18:51,530 --> 03:18:51,891
然后


5667
03:18:52,101 --> 03:18:53,570
在这里打印


5668
03:18:54,051 --> 03:18:56,480
我的意思是，员工填写了阅读线。


5669
03:18:56,601 --> 03:18:58,069
所以它会读取第一行


5670
03:18:58,279 --> 03:19:00,621
然后当我再说一遍时它会读


5671
03:19:00,681 --> 03:19:05,688
在这之后，这将会打印出文件的前两行。


5672
03:19:06,198 --> 03:19:09,260
当我运行这个程序时你会看到我们打印出了jim销售人员


5673
03:19:09,470 --> 03:19:10,729
还有德怀特的推销员。


5674
03:19:10,999 --> 03:19:14,808
所以如果我要做很多次，我可以打印出来


5675
03:19:15,197 --> 03:19:17,718
这个文件的每一行。


5676
03:19:18,857 --> 03:19:20,089
你可以看到我们可以做到这一点


5677
03:19:20,779 --> 03:19:27,140
这对于读取文件中的多行是非常有用的但是实际上有另一个函数更擅长于这样做。


5678
03:19:27,590 --> 03:19:29,359
我们可以说，不是员工父亲


5679
03:19:29,390 --> 03:19:31,430
读行，我们可以说点读


5680
03:19:31,460 --> 03:19:32,330
线条。


5681
03:19:32,480 --> 03:19:34,252
它将要做的是，它将会


5682
03:19:34,282 --> 03:19:36,621
我们文件中的所有行


5683
03:19:36,831 --> 03:19:38,511
把它们放在数组里。


5684
03:19:38,780 --> 03:19:42,471
现在当我打印出来的时候你会看到这里有一个数组它说


5685
03:19:42,740 --> 03:19:45,500
吉姆销售人员这是数组中的第一项


5686
03:19:45,680 --> 03:19:46,670
给白人销售员


5687
03:19:46,700 --> 03:19:47,360
第二种


5688
03:19:47,391 --> 03:19:48,320
数组中的项。


5689
03:19:48,620 --> 03:19:51,859
它基本上是把每一行都放到一个数组里。


5690
03:19:52,159 --> 03:19:54,379
如果我想要访问一个特定的行


5691
03:19:54,409 --> 03:19:58,340
我可以用它在数组中的下标来表示它，所以如果我说一个。


5692
03:19:58,609 --> 03:20:00,319
这就给了我们这个


5693
03:20:00,379 --> 03:20:02,089
做白销售员


5694
03:20:02,329 --> 03:20:05,508
因为这是在数组里的索引位置。


5695
03:20:06,107 --> 03:20:08,957
你也可以使用这个信赖函数


5696
03:20:08,987 --> 03:20:09,917
带一个for循环


5697
03:20:09,947 --> 03:20:12,017
所以我可以到这里创建一个for循环


5698
03:20:12,316 --> 03:20:13,696
将会节省4个


5699
03:20:14,116 --> 03:20:15,016
我们会说


5700
03:20:15,676 --> 03:20:16,546
雇员


5701
03:20:16,576 --> 03:20:17,176
并且


5702
03:20:17,565 --> 03:20:18,886
员工档案


5703
03:20:19,756 --> 03:20:22,756
对于每个员工，我们只是想把他们打印出来


5704
03:20:22,876 --> 03:20:23,566
它实际上开始了


5705
03:20:23,597 --> 03:20:25,217
我们必须设置员工文件点


5706
03:20:25,247 --> 03:20:25,907
阅读


5707
03:20:26,417 --> 03:20:27,587
在这里排队


5708
03:20:27,947 --> 03:20:30,587
现在所有的员工都有一个循环


5709
03:20:30,617 --> 03:20:33,168
在这个员工中，他填写了读行数组。


5710
03:20:33,468 --> 03:20:34,607
所以我们可以


5711
03:20:34,638 --> 03:20:35,447
打印输出


5712
03:20:35,808 --> 03:20:37,427
个体

5713
03:20:37,816 --> 03:20:39,796
这将会打印出所有的员工


5714
03:20:39,826 --> 03:20:42,437
这些文件的内部基本上是打印出来的


5715
03:20:42,767 --> 03:20:44,536
文件中的每一行。


5716
03:20:44,776 --> 03:20:46,008
这是非常有用的。


5717
03:20:46,218 --> 03:20:50,807
所以你可以使用所有这些不同的函数比如读读行读行


5718
03:20:51,377 --> 03:20:56,235
可读，你知道有很多不同的东西我们可以从文件中获取信息。


5719
03:20:56,295 --> 03:21:01,635
有很多情况下，你需要能够解析文件中的信息这是a


5720
03:21:01,665 --> 03:21:02,926
这是一种很棒的方式


5721
03:21:03,286 --> 03:21:07,156
回顾一下，当你想打开一个文件并从中读取时你可以使用这个


5722
03:21:07,187 --> 03:21:08,027
开放函数


5723
03:21:08,058 --> 03:21:10,277
输入文件的名称，然后是模式，


5724
03:21:10,428 --> 03:21:12,048
在我们的例子中是r。


5725
03:21:12,317 --> 03:21:15,676
然后你可以用它做各种各样的事情你总是想要确保


5726
03:21:15,735 --> 03:21:19,155
当你完成的时候，你就关闭它，这是一个很好的练习


5727
03:21:19,516 --> 03:21:22,664
这就是从文件中读取的基本知识希望你们能


5728
03:21:22,694 --> 03:21:25,335
在未来，以某种形式或形式使用它。


5729
03:21:29,354 --> 03:21:34,363
在本教程中，我们将讨论如何编写和添加文件


5730
03:21:34,543 --> 03:21:35,143
python。


5731
03:21:35,532 --> 03:21:38,980
关于python的一个很酷的事情是它允许你使用


5732
03:21:39,011 --> 03:21:42,520
外部文件，所以我可以有一个外部文本文件


5733
03:21:42,850 --> 03:21:44,830
我可以完全喜欢


5734
03:21:44,950 --> 03:21:47,531
阅读所有的信息，我可以通过它


5735
03:21:47,562 --> 03:21:49,602
利用这些信息做一些事情，


5736
03:21:50,142 --> 03:21:59,530
但它不是一个读取文件我也可以写一个文件这就是我想和你们讨论的关于今天的新文件和附加到现有文件的内容


5737
03:21:59,620 --> 03:22:01,989
这里我只是写了一些代码


5738
03:22:02,020 --> 03:22:03,280
这基本上就是


5739
03:22:03,490 --> 03:22:08,050
从这个员工的点文本文件中读取信息，这样你就能看到这里，


5740
03:22:08,439 --> 03:22:10,450
我在指定模式


5741
03:22:10,510 --> 03:22:12,221
r代表阅读


5742
03:22:12,521 --> 03:22:14,170
然后在他的阅读下面


5743
03:22:14,200 --> 03:22:17,109
文件的所有内容，并在屏幕上吐出来。


5744
03:22:17,649 --> 03:22:19,448
我要点击这里的播放按钮，


5745
03:22:19,538 --> 03:22:20,138
并且


5746
03:22:20,317 --> 03:22:21,188
你会看到


5747
03:22:21,248 --> 03:22:23,348
如果这个执行，那么它就打印出来了


5748
03:22:23,708 --> 03:22:24,729
所有的


5749
03:22:24,818 --> 03:22:29,529
我们的文本文件中的代码行这里我在这个员工的点文本文件中


5750
03:22:29,859 --> 03:22:31,838
它只包含了所有这些信息


5751
03:22:31,868 --> 03:22:33,309
办公室里的员工。


5752
03:22:33,698 --> 03:22:36,908
但是假设我想在这里添加另一个员工


5753
03:22:37,059 --> 03:22:37,448
对吧？


5754
03:22:37,568 --> 03:22:38,318
假设


5755
03:22:38,408 --> 03:22:39,038
新事物


5756
03:22:39,068 --> 03:22:42,487
加入我们公司的员工是我们想要把他们加到这个名单上。


5757
03:22:42,817 --> 03:22:43,178
井


5758
03:22:43,237 --> 03:22:45,847
我可以到我的app点python文件


5759
03:22:46,836 --> 03:22:47,496
代替


5760
03:22:47,556 --> 03:22:48,906
从文件中读取


5761
03:22:48,937 --> 03:22:49,626
我想


5762
03:22:49,656 --> 03:22:51,726
将它附加到我想说的文件中


5763
03:22:51,756 --> 03:22:52,176
a


5764
03:22:52,656 --> 03:22:54,546
然后将其添加到文件中


5765
03:22:54,576 --> 03:22:56,226
基本上是指你在添加


5766
03:22:56,346 --> 03:22:57,155
一些文本


5767
03:22:57,215 --> 03:22:58,686
在文件的最后


5768
03:22:58,985 --> 03:23:01,537
无论文件在哪里结束你都要添加

5769
03:23:01,567 --> 03:23:02,317
在那里。


5770
03:23:02,888 --> 03:23:06,728
所以我们可以做的是，我们可以在文件中添加另一个员工。


5771
03:23:07,147 --> 03:23:07,718
所以


5772
03:23:07,808 --> 03:23:08,887
而不是打印一些东西


5773
03:23:08,917 --> 03:23:10,657
我只是想说。


5774
03:23:12,157 --> 03:23:12,967
雇员


5775
03:23:12,997 --> 03:23:13,717
锉


5776
03:23:13,776 --> 03:23:14,526
点


5777
03:23:14,706 --> 03:23:15,246
对。


5778
03:23:15,786 --> 03:23:19,837
当我说员工申请的时候我就可以写一些东西


5779
03:23:19,867 --> 03:23:21,427
文件的结尾


5780
03:23:21,907 --> 03:23:25,987
我基本上可以做任何我想做的事情为什么我们不添加另一个员工呢


5781
03:23:26,228 --> 03:23:30,816
在我们的员工中点文本文件这样我们就可以添加另一个员工为什么我们不这样说


5782
03:23:31,116 --> 03:23:31,986
托比


5783
03:23:32,286 --> 03:23:33,938
他将会在


5784
03:23:33,997 --> 03:23:34,807
人类的


5785
03:23:34,986 --> 03:23:36,097
资源。


5786
03:23:36,847 --> 03:23:37,417
现在


5787
03:23:37,717 --> 03:23:39,577
当我运行这个程序时。


5788
03:23:39,938 --> 03:23:40,809
它会添加


5789
03:23:40,839 --> 03:23:44,648
托比的人力资源在我的程序的某个地方。


5790
03:23:45,368 --> 03:23:45,968
并且


5791
03:23:46,298 --> 03:23:48,607
你会发现在委员会里没有任何东西出现。


5792
03:23:48,877 --> 03:23:52,207
但是如果我到我的员工点文本文件。


5793
03:23:52,567 --> 03:23:53,438
突然之间


5794
03:23:53,468 --> 03:23:55,447
我们这里有一个新词条


5795
03:23:56,228 --> 03:23:58,567
从人力资源中是正确的，所以我能够


5796
03:23:58,957 --> 03:24:01,866
在这个文件的末尾添加一条行。


5797
03:24:02,736 --> 03:24:07,597
但是在写文件的时候你需要注意的是你可以把文件弄乱


5798
03:24:07,627 --> 03:24:08,497
很容易


5799
03:24:08,797 --> 03:24:09,487
举个例子


5800
03:24:09,518 --> 03:24:12,277
我已经把托比加到我的档案里了。


5801
03:24:12,487 --> 03:24:14,618
但是如果我要再次运行这个程序，


5802
03:24:15,849 --> 03:24:18,519
你会在这里看到这个员工的点文本文件


5803
03:24:18,759 --> 03:24:19,449
当我没有的时候


5804
03:24:19,479 --> 03:24:20,919
托比又说了一遍


5805
03:24:21,249 --> 03:24:23,710
所以它在这里添加了这个员工


5806
03:24:23,740 --> 03:24:24,311
再一次


5807
03:24:24,490 --> 03:24:26,440
你会注意到，在这种情况下，


5808
03:24:26,740 --> 03:24:29,501
这些员工没有进入下一行


5809
03:24:29,621 --> 03:24:33,221
我不小心把我的文件再次运行了突然间它搞砸了


5810
03:24:33,251 --> 03:24:34,900
这里的文件


5811
03:24:35,051 --> 03:24:39,490
所以附加的你需要小心因为如果你真的再次进入文件或者有你


5812
03:24:39,550 --> 03:24:39,939
你知道，


5813
03:24:40,569 --> 03:24:46,420
在文件中附加一些错误的东西，它是永久保存在文件中的。


5814
03:24:47,020 --> 03:24:49,449
所以我想和你们谈谈你们知道的更多


5815
03:24:49,479 --> 03:24:52,629
我们可以做的另一件事假设我们想要添加另一个


5816
03:24:53,409 --> 03:24:54,100
雇员


5817
03:24:54,279 --> 03:24:56,950
你会注意到这里的员工文本文件


5818
03:24:57,670 --> 03:24:59,230
当我再次添加它的时候


5819
03:24:59,261 --> 03:25:00,161
它被追加了


5820
03:25:00,191 --> 03:25:00,882
到


5821
03:25:00,941 --> 03:25:03,041
现有的行权的终结


5822
03:25:03,281 --> 03:25:04,512
所以我第一次


5823
03:25:04,542 --> 03:25:08,202
这里有一条新线但是如果你的文件的末尾没有一条新线


5824
03:25:08,502 --> 03:25:10,302
你们都想要添加一条新线，


5825
03:25:10,632 --> 03:25:12,701
你需要添加一些特殊的字符


5826
03:25:12,731 --> 03:25:14,621
让我们添加另一个员工


5827
03:25:14,921 --> 03:25:15,851
我们会给她打电话


5828
03:25:15,881 --> 03:25:16,541
凯莉，


5829
03:25:16,631 --> 03:25:18,521
我们就说kelley在


5830
03:25:22,271 --> 03:25:23,621
客户服务


5831
03:25:23,891 --> 03:25:25,569
kelly将会在客户服务中。


5832
03:25:25,779 --> 03:25:27,130
如果我想添加


5833
03:25:27,189 --> 03:25:33,850
这个员工在文件的最后一行我将不得不在它前面放一个新的行字符所以我可以说


5834
03:25:34,149 --> 03:25:34,899
反斜杠


5835
03:25:34,959 --> 03:25:35,439
n


5836
03:25:35,770 --> 03:25:37,149
这将会颠倒


5837
03:25:37,180 --> 03:25:38,170
这个条目


5838
03:25:38,200 --> 03:25:39,160
在文件中


5839
03:25:39,311 --> 03:25:42,250
有了一条新线，在一条新线上，所以当我运行这个的时候，


5840
03:25:42,550 --> 03:25:44,800
你会看到我们从客户服务中得到kelly


5841
03:25:44,830 --> 03:25:46,150
在她自己的立场上。


5842
03:25:46,480 --> 03:25:51,371
所以你要确保你知道这些特殊的字符你可以用它们来称呼它们


5843
03:25:51,401 --> 03:25:52,602
转义字符


5844
03:25:53,082 --> 03:25:58,841
你及时地把奥迪放到了一个文件上，你要确保你添加的是你想要添加的地方。


5845
03:25:58,900 --> 03:26:01,390
除了附加到一个文件之外。


5846
03:26:01,720 --> 03:26:02,979
我也可以


5847
03:26:03,039 --> 03:26:04,899
覆盖一个文件，或者我可以


5848
03:26:04,930 --> 03:26:05,500
写


5849
03:26:05,530 --> 03:26:07,090
一个全新的文件。


5850
03:26:07,240 --> 03:26:10,332
这是我们已经打开的，而不是附加到文件中。


5851
03:26:10,662 --> 03:26:12,042
为什么我们不

5852
03:26:12,162 --> 03:26:13,602
一个文件，所以我要用这个


5853
03:26:13,632 --> 03:26:14,352
w


5854
03:26:15,191 --> 03:26:15,882
现在


5855
03:26:16,151 --> 03:26:18,401
如果我说员工申请的权利


5856
03:26:18,642 --> 03:26:21,161
因为我用的是w，而我没有使用


5857
03:26:21,221 --> 03:26:21,730
a，


5858
03:26:21,940 --> 03:26:22,630
它实际上会


5859
03:26:22,660 --> 03:26:23,530
推翻


5860
03:26:23,561 --> 03:26:27,281
整个文件，它只会把这个放到文件里


5861
03:26:27,581 --> 03:26:28,540
当我运行这个时


5862
03:26:28,720 --> 03:26:30,971
然后我们转到这个员工的点文本文件


5863
03:26:31,360 --> 03:26:35,199
你会看到我们只有一行文件在这个文件里


5864
03:26:35,229 --> 03:26:36,670
凯利客服。


5865
03:26:37,060 --> 03:26:39,009
那是因为我用的是你的替身


5866
03:26:39,039 --> 03:26:39,549
不是


5867
03:26:39,608 --> 03:26:41,497
当你用w时，它只是


5868
03:26:41,527 --> 03:26:44,377
重写现有文件中的所有内容。


5869
03:26:45,127 --> 03:26:47,827
你也可以使用w来创建一个新文件


5870
03:26:47,857 --> 03:26:51,398
在这里，我可以把员工文件说成是员工


5871
03:26:51,458 --> 03:26:52,058
一


5872
03:26:52,088 --> 03:26:52,958
点文本。


5873
03:26:53,408 --> 03:26:59,468
现在，当我运行它的时候它会为我创建另一个文件运行这个


5874
03:27:00,067 --> 03:27:00,548
并且


5875
03:27:00,578 --> 03:27:02,830
您将在我的文件浏览器中看到。


5876
03:27:02,980 --> 03:27:05,829
我们有一个新文件员工一个点文本


5877
03:27:06,069 --> 03:27:07,389
如果我打开这个。


5878
03:27:07,539 --> 03:27:10,389
它和这个员工档案里的东西是一样的，


5879
03:27:10,869 --> 03:27:15,905
但它基本上为我们创建了一个新文件所以很多时候你会想要创建一个新文件，


5880
03:27:16,535 --> 03:27:20,795
你可以使用不同的扩展如果我想要创建一个网页


5881
03:27:20,825 --> 03:27:21,694
我可以说


5882
03:27:23,164 --> 03:27:23,884
指标起动


5883
03:27:23,914 --> 03:27:24,724
每一层梅尔


5884
03:27:25,084 --> 03:27:26,854
我还可以加上一些


5885
03:27:26,885 --> 03:27:28,385
每个团队都是这样的


5886
03:27:28,475 --> 03:27:30,873
如果你不懂html就不用担心


5887
03:27:31,143 --> 03:27:32,312
如果你这样做，我可以把


5888
03:27:32,401 --> 03:27:33,751
一年中的一段


5889
03:27:34,561 --> 03:27:35,910
另一段


5890
03:27:36,630 --> 03:27:37,290
这是


5891
03:27:37,320 --> 03:27:38,070
html


5892
03:27:38,221 --> 03:27:40,262
基本上，就像一个网页。


5893
03:27:41,252 --> 03:27:43,922
我想说的是你可以写一个网页


5894
03:27:43,952 --> 03:27:46,352
在python内部做这样的事情


5895
03:27:46,592 --> 03:27:47,941
当我演奏这个的时候


5896
03:27:47,972 --> 03:27:48,601
我们得到这个


5897
03:27:48,631 --> 03:27:49,291
索引样式


5898
03:27:49,321 --> 03:27:50,491
html文件。


5899
03:27:50,941 --> 03:27:51,992
它有一些


5900
03:27:52,022 --> 03:27:53,672
里面的

5901
03:27:54,032 --> 03:27:57,123
这是写入文件的一种方式可以非常有用


5902
03:27:57,153 --> 03:27:57,903
覆盖


5903
03:27:57,934 --> 03:27:59,104
一个现有的文件，


5904
03:27:59,164 --> 03:28:01,294
你可以写一个新文件，创建它，


5905
03:28:01,384 --> 03:28:01,954
或者


5906
03:28:02,104 --> 03:28:04,414
你可以附加到文件的末尾


5907
03:28:04,924 --> 03:28:05,254
有


5908
03:28:05,313 --> 03:28:09,363
大量的用于编写文件和python的应用程序和优秀的语言


5909
03:28:09,633 --> 03:28:11,344
阅读写作


5910
03:28:11,374 --> 03:28:13,024
用文件做所有事情


5911
03:28:16,925 --> 03:28:21,274
在本教程中，关于在python中使用模块的问题。


5912
03:28:21,604 --> 03:28:25,324
现在一个模块本质上就是一个我们可以使用的python文件


5913
03:28:25,414 --> 03:28:26,884
导入到我们的


5914
03:28:26,914 --> 03:28:28,384
当前的python文件


5915
03:28:28,684 --> 03:28:36,002
例如，如果我写了一个python文件它有很多有用的函数是有用的变量你知道其他类似的东西。


5916
03:28:36,452 --> 03:28:38,312
我可以把那个文件拿出来


5917
03:28:38,372 --> 03:28:40,951
把它导入到我正在处理的文件中


5918
03:28:41,161 --> 03:28:42,451
我可以访问


5919
03:28:42,481 --> 03:28:43,650
所有这些函数


5920
03:28:43,681 --> 03:28:44,881
所有这些变量。


5921
03:28:44,940 --> 03:28:46,201
所有的东西


5922
03:28:46,231 --> 03:28:47,401
外部文件


5923
03:28:47,821 --> 03:28:49,650
在我当前的文件中


5924
03:28:49,681 --> 03:28:50,610
致力于此


5925
03:28:50,971 --> 03:28:53,700
我相信你们是怎么使用模块的然后我们会讨论


5926
03:28:53,970 --> 03:28:58,531
你知道在哪里你可以找到很棒的模块以及为什么模块会生成python


5927
03:28:58,562 --> 03:28:59,161
令人敬畏的


5928
03:28:59,221 --> 03:28:59,881
语言，


5929
03:29:00,271 --> 03:29:04,562
在这里，我的文本编辑器创建了这个文件它被调用了


5930
03:29:04,593 --> 03:29:05,943
有用的工具


5931
03:29:06,273 --> 03:29:07,264
点python


5932
03:29:07,653 --> 03:29:10,684
基本上这个文件有很多


5933
03:29:10,773 --> 03:29:14,344
有点像有用的工具，我可能想在我的一个进步中使用，


5934
03:29:14,824 --> 03:29:20,074
她会看到这里我有一些变量这是告诉我一英里内有多少英尺。


5935
03:29:20,374 --> 03:29:23,193
这个告诉我有多少米或1千米。


5936
03:29:23,313 --> 03:29:26,044
然后我们有了这个列表列出了所有的


5937
03:29:26,074 --> 03:29:27,333
甲壳虫乐队成员，


5938
03:29:27,693 --> 03:29:32,702
我这里也有一些不同的函数所以我有一个文件扩展函数。


5939
03:29:33,122 --> 03:29:33,722
这是


5940
03:29:34,082 --> 03:29:35,012
基本上就是


5941
03:29:35,042 --> 03:29:37,562
你给它一个文件名它会告诉你它的扩展名是什么，


5942
03:29:37,862 --> 03:29:39,961
然后这里还有另一个函数


5943
03:29:40,021 --> 03:29:41,460
模拟掷骰子


5944
03:29:41,490 --> 03:29:42,780
所以你传递一个数字


5945
03:29:43,021 --> 03:29:45,811
绕过它，像6一样，它会滚动一个六面骰子


5946
03:29:46,051 --> 03:29:46,500
被动的


5947
03:29:46,530 --> 03:29:48,300
9在罗兰9面骰子，等等


5948
03:29:48,330 --> 03:29:48,690
所以


5949
03:29:48,780 --> 03:29:50,851
这就像我写的一根管子。


5950
03:29:51,181 --> 03:29:52,710
它里面有一些有用的东西，


5951
03:29:52,950 --> 03:29:56,667
老实说，这里有很多东西我可能想用在


5952
03:29:56,697 --> 03:29:59,066
我使用的其他python文件，


5953
03:29:59,366 --> 03:30:00,986
假设我在这里


5954
03:30:01,046 --> 03:30:01,466
应用程序


5955
03:30:01,496 --> 03:30:01,886
点


5956
03:30:01,916 --> 03:30:03,836
python文件，我在想，


5957
03:30:04,105 --> 03:30:04,676
哈，


5958
03:30:05,126 --> 03:30:07,497
我想我可以用其中一个函数


5959
03:30:07,527 --> 03:30:10,017
那是在那个有用的工具文件里面


5960
03:30:10,047 --> 03:30:10,736
是的


5961
03:30:10,767 --> 03:30:11,606
我需要


5962
03:30:11,637 --> 03:30:13,826
在我的程序中

5963
03:30:14,517 --> 03:30:16,437
而不是必须到这里来


5964
03:30:16,467 --> 03:30:17,696
复制这个


5965
03:30:17,727 --> 03:30:18,626
功能，然后


5966
03:30:18,656 --> 03:30:20,396
把它粘贴到我的程序中


5967
03:30:20,757 --> 03:30:21,838
实际上我可以


5968
03:30:21,958 --> 03:30:22,798
进口


5969
03:30:22,828 --> 03:30:23,278
这个


5970
03:30:23,309 --> 03:30:24,630
有用的工具文件


5971
03:30:24,870 --> 03:30:28,468
我将能够导入所有这些函数以及所有这些函数


5972
03:30:28,498 --> 03:30:29,908
变量和属性。


5973
03:30:30,298 --> 03:30:32,547
我的方法是，到这里来


5974
03:30:32,606 --> 03:30:34,646
我将直接在我的顶部


5975
03:30:34,677 --> 03:30:36,146
文件，我只是想说。


5976
03:30:36,507 --> 03:30:37,197
导入。


5977
03:30:37,527 --> 03:30:41,424
然后我想要输入我想要导入的文件的名字所以我想说，


5978
03:30:41,844 --> 03:30:43,313
有用下划线


5979
03:30:43,344 --> 03:30:44,094
工具


5980
03:30:44,454 --> 03:30:48,054
而蟒蛇会很聪明地知道它应该会爆炸


5981
03:30:48,084 --> 03:30:51,175
从这个有用的工具中获取所有的东西


5982
03:30:51,205 --> 03:30:52,314
pi文件


5983
03:30:52,765 --> 03:30:54,565
一旦我使用了这个重要的语句


5984
03:30:54,596 --> 03:30:56,996
我可以使用所有的函数


5985
03:30:57,026 --> 03:30:58,885
在这个有用的工具文件的内部。


5986
03:30:59,365 --> 03:31:00,056
所以


5987
03:31:00,086 --> 03:31:03,116
例如，我可以模拟掷骰子，我可以说


5988
03:31:03,626 --> 03:31:04,826
有用的工具。


5989
03:31:05,846 --> 03:31:06,596
点，


5990
03:31:06,926 --> 03:31:09,297
现在我可以访问


5991
03:31:09,327 --> 03:31:13,528
所有的属性都来自于那个文件所以当我说有用的工具点时


5992
03:31:13,828 --> 03:31:18,479
你会看到这里和我的小建议菜单它告诉我，就像甲虫的脚一样


5993
03:31:18,929 --> 03:31:21,839
获取文件扩展表和公里掷骰子。


5994
03:31:21,959 --> 03:31:27,269
它让我可以访问文件中的所有内容这里我可以这样说


5995
03:31:28,108 --> 03:31:32,128
掷骰子，我们可以把它像10一样，掷一个十面骰子。


5996
03:31:32,578 --> 03:31:32,998
并且


5997
03:31:33,028 --> 03:31:34,349
这实际上应该是


5998
03:31:34,379 --> 03:31:36,180
能够运行这个函数


5999
03:31:36,239 --> 03:31:39,838
将模拟滚动10个被引用的饮食你可以看到我们得到了4个


6000
03:31:41,277 --> 03:31:45,328
这是python的一个核心概念


6001
03:31:45,718 --> 03:31:46,647
进口


6002
03:31:46,678 --> 03:31:48,027
来自


6003
03:31:48,058 --> 03:31:49,527
外巨蟒


6004
03:31:49,558 --> 03:31:50,757
文件，这就像


6005
03:31:50,967 --> 03:31:54,806
在python中是巨大的这将会改变你创建你的方式


6006
03:31:55,376 --> 03:31:56,396
python文件


6007
03:31:56,936 --> 03:31:57,325
所以


6008
03:31:57,535 --> 03:31:58,165
你会注意到


6009
03:31:58,225 --> 03:31:59,545
我不需要


6010
03:31:59,575 --> 03:32:02,814
复制任何函数或任何变量或任何东西


6011
03:32:03,175 --> 03:32:06,085
在这个文件中，但是我可以使用


6012
03:32:06,115 --> 03:32:08,995
所有这些东西都在这个有用的工具里面


6013
03:32:09,025 --> 03:32:09,596
锉


6014
03:32:09,806 --> 03:32:11,936
这是巨大的，老实说，


6015
03:32:12,056 --> 03:32:15,624
它会为你节省很多时间因为你可以写一些东西，然后你就可以


6016
03:32:15,684 --> 03:32:17,964
把它导入到其他文件中。


6017
03:32:18,264 --> 03:32:24,923
这就是使用模块的基本原理这意味着模块是非常简单的模块作为任何外部

6018
03:32:25,163 --> 03:32:27,292
你想要在里面使用一些东西。


6019
03:32:27,412 --> 03:32:28,402
我想给你们看


6020
03:32:28,433 --> 03:32:29,062
a


6021
03:32:29,242 --> 03:32:32,361
你可以去找一个大的列表


6022
03:32:32,392 --> 03:32:33,651
在模块中


6023
03:32:34,012 --> 03:32:35,602
我将在这里浏览我的web浏览器。


6024
03:32:35,661 --> 03:32:36,231
并且


6025
03:32:36,592 --> 03:32:37,612
在这个网站中


6026
03:32:37,643 --> 03:32:39,083
它实际上就像


6027
03:32:39,143 --> 03:32:40,643
官方python码头


6028
03:32:41,183 --> 03:32:43,343
基本上我所做的就是输入


6029
03:32:43,373 --> 03:32:45,443
python模块和google的列表，


6030
03:32:45,863 --> 03:32:49,792
根据你使用的python版本你会想要确保你点击了正确的那个。


6031
03:32:50,002 --> 03:32:51,532
我在第三版上弹了一下


6032
03:32:51,683 --> 03:32:52,943
在这一页上


6033
03:32:52,974 --> 03:32:55,282
你可以看到这里有一个巨大的列表


6034
03:32:55,312 --> 03:32:57,022
在python模块中，


6035
03:32:57,322 --> 03:32:59,932
这些基本上都是python内部的模块


6036
03:32:59,962 --> 03:33:01,731
你可以直接访问


6037
03:33:02,271 --> 03:33:03,291
本质上是这样的


6038
03:33:03,321 --> 03:33:05,271
所有这些很棒的代码


6039
03:33:05,331 --> 03:33:11,061
已经为你写好了如果你想在你的python程序中有某种功能，


6040
03:33:11,330 --> 03:33:12,200
很有可能


6041
03:33:12,230 --> 03:33:13,791
这里有一个模块


6042
03:33:14,121 --> 03:33:15,980
它的功能是


6043
03:33:16,040 --> 03:33:17,060
各种各样的东西


6044
03:33:17,090 --> 03:33:19,369
我的意思是，如果你只是浏览一下这个列表


6045
03:33:19,489 --> 03:33:21,710
你会看到大量的


6046
03:33:21,979 --> 03:33:22,880
基本上


6047
03:33:23,240 --> 03:33:23,930
你知道很多


6048
03:33:23,960 --> 03:33:26,600
python变量都是python函数


6049
03:33:26,659 --> 03:33:26,989
你知道


6050
03:33:27,020 --> 03:33:29,749
你可以用一些东西来使你的程序更好。


6051
03:33:30,139 --> 03:33:30,499
所以


6052
03:33:30,529 --> 03:33:31,850
以下是我推荐的


6053
03:33:32,060 --> 03:33:33,918
转到这个页面


6054
03:33:34,038 --> 03:33:37,817
要浏览很多不同的模块就看不出你能看到什么


6055
03:33:38,178 --> 03:33:38,958
坦白地说


6056
03:33:38,988 --> 03:33:41,568
如果你点击其中一个，它会把你带到一个页面


6057
03:33:41,658 --> 03:33:43,968
谈论如何使用它们会告诉你


6058
03:33:44,268 --> 03:33:45,767
如何导入它，

6059
03:33:45,797 --> 03:33:47,297
关于它的一些基本知识


6060
03:33:48,106 --> 03:33:49,877
这有点像列表


6061
03:33:49,907 --> 03:33:51,348
这是官方的


6062
03:33:51,647 --> 03:33:52,488
python文档


6063
03:33:52,519 --> 03:33:52,908
但是


6064
03:33:53,269 --> 03:33:54,019
他在用


6065
03:33:54,049 --> 03:33:58,909
python社区是巨大的，有大量的开发人员使用python。


6066
03:33:59,390 --> 03:34:03,980
你可以找到很多第三方模块如果你上网，

6067
03:34:04,011 --> 03:34:07,071
在实际操作中查找python模块


6068
03:34:07,102 --> 03:34:08,692
用于解释原因的python模块


6069
03:34:08,933 --> 03:34:14,212
很可能有人已经编写了一个python模块来完成您想要做的事情。


6070
03:34:14,542 --> 03:34:18,562
如果你擅长使用模块你就会很擅长寻找它们


6071
03:34:18,593 --> 03:34:21,083
你可以节省很多时间，因为


6072
03:34:21,353 --> 03:34:24,682
很可能有人已经写了一个模块来做


6073
03:34:24,712 --> 03:34:25,072
你知道


6074
03:34:25,103 --> 03:34:26,332
你想要做的是


6075
03:34:26,422 --> 03:34:27,801
这是你想要做的事情的一部分。


6076
03:34:28,041 --> 03:34:31,491
现在我们来看看这些不同的python模块


6077
03:34:31,521 --> 03:34:36,771
我想要深入探讨一下我们如何才能真正地使用这些东西


6078
03:34:37,610 --> 03:34:45,408
你会注意到这里有很多文件有很多不同的模块我们可以用python来访问但是问题是


6079
03:34:45,678 --> 03:34:47,928
所有这些文件存储在哪里


6080
03:34:47,958 --> 03:34:48,378
对的


6081
03:34:48,647 --> 03:34:50,867
当我在我的项目中


6082
03:34:51,107 --> 03:34:53,566
例如，我使用了这个有用的工具


6083
03:34:53,776 --> 03:34:54,796
点派火


6084
03:34:54,826 --> 03:34:57,255
我知道我在哪里创建了那个文件。


6085
03:34:57,465 --> 03:34:59,775
我直接参与了制作


6086
03:34:59,835 --> 03:35:02,414
我刚从这里进口很简单，对吧？


6087
03:35:02,804 --> 03:35:05,264
但是所有这些文件呢


6088
03:35:05,713 --> 03:35:07,933
那么所有这些关于healy的模块呢


6089
03:35:07,963 --> 03:35:09,644
所有这些储存在哪里


6090
03:35:10,033 --> 03:35:11,202
基本上


6091
03:35:11,232 --> 03:35:16,812
这里有两种类型的模型都是在模块中构建的这意味着它们只是被构建到python语言中


6092
03:35:17,052 --> 03:35:19,241
我们不能自动地获得它们。


6093
03:35:19,751 --> 03:35:20,290
而且没有


6094
03:35:20,350 --> 03:35:22,029
外部模块


6095
03:35:22,329 --> 03:35:22,869
并且


6096
03:35:23,139 --> 03:35:25,087
很多

6097
03:35:25,146 --> 03:35:26,587
只是储存在


6098
03:35:26,797 --> 03:35:27,907
基本上是一样的


6099
03:35:27,938 --> 03:35:30,549
我们在电脑上安装了python的文件夹


6100
03:35:30,909 --> 03:35:34,148
举个例子，让我们看一下这些链接我们有链接


6101
03:35:34,479 --> 03:35:35,889
基数六十四


6102
03:35:35,919 --> 03:35:37,119
bd be


6103
03:35:37,179 --> 03:35:38,469
像ascii一样


6104
03:35:38,769 --> 03:35:40,087
如果我来到这里，


6105
03:35:40,537 --> 03:35:44,226
你会看到我在这里的米洛文件资源管理器，我有


6106
03:35:44,615 --> 03:35:46,386
python项目是草案。


6107
03:35:46,596 --> 03:35:48,996
这里还有另一个文件夹


6108
03:35:49,026 --> 03:35:50,376
外部库。


6109
03:35:50,706 --> 03:35:52,356
如果我点击这个


6110
03:35:52,416 --> 03:35:53,616
我来到这里


6111
03:35:53,646 --> 03:35:54,636
你可以看到它只是


6112
03:35:54,695 --> 03:35:56,076
我是python的版本


6113
03:35:56,106 --> 03:35:56,767
很有趣。


6114
03:35:57,727 --> 03:35:59,736
这里有一个叫做实验室的文件夹


6115
03:35:59,796 --> 03:36:03,785
这是一个非常重要的文件夹它基本上存储了所有这些


6116
03:36:03,936 --> 03:36:06,755
外部模块你可以看到我向下滚动


6117
03:36:07,085 --> 03:36:09,305
我们有这些不同的东西


6118
03:36:09,364 --> 03:36:10,624
像模一样


6119
03:36:10,864 --> 03:36:14,194
这是60，4听到bd是对的。


6120
03:36:14,555 --> 03:36:17,224
很多外部模块都被存储起来了


6121
03:36:17,283 --> 03:36:19,203
在这个lib文件夹里面


6122
03:36:19,533 --> 03:36:23,823
比如没有外部模块也有一些模块就像内置的模块一样


6123
03:36:23,854 --> 03:36:24,573
模块


6124
03:36:24,693 --> 03:36:26,734
这些不能被存储在这里


6125
03:36:26,975 --> 03:36:28,415
你可以这样说


6126
03:36:28,445 --> 03:36:30,457
举个例子，如果我到这里来点击


6127
03:36:30,487 --> 03:36:31,627
以六十四为基数。


6128
03:36:32,197 --> 03:36:34,628
它告诉我源代码在哪里


6129
03:36:34,658 --> 03:36:37,208
所以在实验室里的原始码


6130
03:36:38,647 --> 03:36:42,397
我们可以看到，我在lib文件夹里看到的是什么


6131
03:36:43,058 --> 03:36:45,876
这是ascii码，例如，如果我点击这个，


6132
03:36:46,086 --> 03:36:47,256
你会注意到


6133
03:36:47,286 --> 03:36:47,886
不是


6134
03:36:48,126 --> 03:36:53,165
给我一个文件夹因为这基本上就像是用python构建的所以我们不用担心


6135
03:36:54,065 --> 03:36:54,546
你


6136
03:36:54,996 --> 03:36:56,556
幸运的是，我只是想


6137
03:36:56,586 --> 03:36:57,516
它就是这样运作的。


6138
03:36:57,756 --> 03:37:00,186
有些是外部的，有些是内置的。


6139
03:37:00,275 --> 03:37:00,695
并且


6140
03:37:00,905 --> 03:37:01,654
我想给你们看


6141
03:37:01,864 --> 03:37:02,225
是


6142
03:37:02,314 --> 03:37:04,895
除了使用这些模块比赛之外。


6143
03:37:05,045 --> 03:37:07,325
这里有很多好东西，老实说你可以花。


6144
03:37:07,535 --> 03:37:11,075
你知道，多年来，你只需要学习所有这些不同的模块。


6145
03:37:11,585 --> 03:37:14,163
但是很多时候你会想要使用模块


6146
03:37:14,223 --> 03:37:15,843
其他人也写过


6147
03:37:16,773 --> 03:37:17,044
你知道


6148
03:37:17,074 --> 03:37:17,823
有很多


6149
03:37:18,003 --> 03:37:18,933
开发人员


6150
03:37:19,383 --> 03:37:25,052
谁在python上工作谁写了不同的模块所以有很多有用的模块要么不包括在内


6151
03:37:25,321 --> 03:37:28,471
在这个列表中，它们不会出现在这个lib中


6152
03:37:28,501 --> 03:37:29,221
文件夹


6153
03:37:29,431 --> 03:37:29,940
通过


6154
03:37:29,971 --> 03:37:30,631
默认。


6155
03:37:31,021 --> 03:37:33,331
我们实际上可以做的

6156
03:37:33,361 --> 03:37:37,381
我们可以安装这些外部模块作为第三方模块


6157
03:37:37,621 --> 03:37:38,971
不只是来了


6158
03:37:39,001 --> 03:37:40,531
用python预先安装，


6159
03:37:40,892 --> 03:37:42,931
我相信你们这些人做得还不够快


6160
03:37:43,051 --> 03:37:45,781
你需要做的第一件事就是找到


6161
03:37:45,812 --> 03:37:49,022
你想要安装的python模块可以下载


6162
03:37:49,952 --> 03:37:51,782
实际上我过去用过一个。


6163
03:37:52,893 --> 03:37:54,453
python文档，它是


6164
03:37:54,604 --> 03:37:56,284
您可以使用的外部模块


6165
03:37:56,524 --> 03:38:00,574
基本上使用python来创建那些非常酷的文档


6166
03:38:00,844 --> 03:38:04,174
格式文件里面的文档所以我要在这里查一下


6167
03:38:04,233 --> 03:38:05,254
在谷歌。


6168
03:38:05,554 --> 03:38:07,114
我只需要输入python


6169
03:38:07,145 --> 03:38:07,715
码头


6170
03:38:08,255 --> 03:38:08,555
并且


6171
03:38:08,765 --> 03:38:10,535
这里有很多这样的东西


6172
03:38:10,565 --> 03:38:13,026
额外的模块，你不需要使用python狗。


6173
03:38:13,236 --> 03:38:14,856
我给大家举个例子


6174
03:38:15,757 --> 03:38:17,196
但实际上，他只是看起来像


6175
03:38:17,256 --> 03:38:21,665
有用的第三方python模块将会在网上列出数百个这样的东西


6176
03:38:22,325 --> 03:38:23,285
或者在我的案例中


6177
03:38:23,315 --> 03:38:24,875
python文档有一个网站


6178
03:38:25,145 --> 03:38:26,705
基本上就是


6179
03:38:26,795 --> 03:38:29,585
有一些安装说明会在这里出现


6180
03:38:29,975 --> 03:38:34,236
它告诉我，我可以使用命令pip安装python文档


6181
03:38:34,597 --> 03:38:36,157
安装python码头。


6182
03:38:36,397 --> 03:38:37,928
这就引出了


6183
03:38:38,138 --> 03:38:39,814
我想跟你们说的是


6184
03:38:39,845 --> 03:38:40,354
脉冲


6185
03:38:40,744 --> 03:38:41,374
和皮普


6186
03:38:41,404 --> 03:38:43,624
本质上是一个程序


6187
03:38:44,044 --> 03:38:49,384
实际上，如果你有一个新版本的python 3它会预装python 3


6188
03:38:49,804 --> 03:38:52,773
您可以使用管道来安装python模块。


6189
03:38:53,043 --> 03:38:54,213
它被称为


6190
03:38:54,243 --> 03:38:54,903
a


6191
03:38:55,083 --> 03:38:56,133
包装经理


6192
03:38:56,433 --> 03:38:59,313
一个包管理器基本上只允许你喜欢


6193
03:38:59,523 --> 03:39:01,023
安装管理


6194
03:39:01,083 --> 03:39:04,083
像不同的python一样更新和卸载


6195
03:39:04,113 --> 03:39:04,804
模块


6196
03:39:05,044 --> 03:39:05,645
所以pip


6197
03:39:05,675 --> 03:39:07,265
是非常有用的。


6198
03:39:07,625 --> 03:39:11,403
为了让我们安装python文档我们需要使用pip


6199
03:39:11,823 --> 03:39:13,563
不知道你们是怎么做到的，


6200
03:39:14,224 --> 03:39:15,904
但是我想要做的是打开


6201
03:39:15,935 --> 03:39:18,665
在我的计算机上命令提示符或终端。


6202
03:39:19,025 --> 03:39:21,217
如果你在mac上，你想打开你的终端。


6203
03:39:21,547 --> 03:39:24,065
如果你在windows电脑上你想要打开你的命令提示符


6204
03:39:24,096 --> 03:39:25,206
我用的是窗户


6205
03:39:25,236 --> 03:39:25,896
现在，


6206
03:39:26,195 --> 03:39:29,255
所以我要到搜索栏输入a和c m d


6207
03:39:29,615 --> 03:39:32,403
这个命令会提示你，我要点击这个


6208
03:39:32,823 --> 03:39:34,801
在命令提示符内部，我们实际上可以使用


6209
03:39:34,831 --> 03:39:35,221
脉冲


6210
03:39:35,311 --> 03:39:38,160
首先，我们要做的是检查确保pips安装


6211
03:39:38,550 --> 03:39:42,839
就像我说的如果你有一个更新的版本的python 3


6212
03:39:42,869 --> 03:39:43,829
漂亮的安装


6213
03:39:44,369 --> 03:39:48,119
如果没有新版本的python3，它应该在这里做一些工作，


6214
03:39:48,299 --> 03:39:50,129
你可能需要安装


6215
03:39:50,550 --> 03:39:51,270
分开地


6216
03:39:51,449 --> 03:39:54,239
网上有大量的指令，以及如何安装pip。


6217
03:39:54,299 --> 03:39:56,340
所以我要检查一下确保我有


6218
03:39:56,550 --> 03:39:57,119
输入


6219
03:39:57,959 --> 03:39:58,948
海文连字符


6220
03:39:59,309 --> 03:40:00,059
版本，


6221
03:40:00,358 --> 03:40:02,127
他们应该把pip的版本吐出来


6222
03:40:02,157 --> 03:40:03,236
我现在有。


6223
03:40:03,506 --> 03:40:04,466
所以只要我们必须


6224
03:40:04,887 --> 03:40:06,686
然后我们就可以安装一个


6225
03:40:06,716 --> 03:40:08,546
外部或第三方


6226
03:40:08,846 --> 03:40:09,565
蟒蛇


6227
03:40:09,596 --> 03:40:10,256
模块。


6228
03:40:10,616 --> 03:40:12,087
我要做的就是选择


6229
03:40:12,177 --> 03:40:13,077
安装


6230
03:40:13,377 --> 03:40:18,146
现在我只想输入python模块的名称，在python的例子中。


6231
03:40:18,807 --> 03:40:20,066
只是


6232
03:40:20,336 --> 03:40:21,596
像这样的巨蟒。


6233
03:40:21,865 --> 03:40:22,466
再一次


6234
03:40:22,496 --> 03:40:23,875
你不需要安装python狗


6235
03:40:23,905 --> 03:40:25,225
我这么做是为了


6236
03:40:25,255 --> 03:40:27,234
本教程将向你们展示


6237
03:40:27,444 --> 03:40:28,644
这是如何运作的。


6238
03:40:28,884 --> 03:40:29,573
但是你知道


6239
03:40:29,604 --> 03:40:31,854
你想做的是上网查一下


6240
03:40:32,214 --> 03:40:34,583
第三方外部python模块，


6241
03:40:34,763 --> 03:40:35,902
一般来说


6242
03:40:35,933 --> 03:40:37,973
我想说90-95%的时间


6243
03:40:38,003 --> 03:40:40,253
你将能够使用pip来安装它们。


6244
03:40:40,643 --> 03:40:43,253
在off情况下，你不能用pip来安装它们，


6245
03:40:43,493 --> 03:40:46,912
很有可能它们会像一些详细的安装说明但是说出来


6246
03:40:47,092 --> 03:40:48,352
在大多数情况下


6247
03:40:48,411 --> 03:40:49,251
合法的


6248
03:40:49,491 --> 03:40:50,182
蟒蛇


6249
03:40:50,241 --> 03:40:53,001
模块将能够使用pip进行安装。


6250
03:40:53,691 --> 03:40:54,142
所以


6251
03:40:54,172 --> 03:40:55,552
这里是为了理解一个脉冲


6252
03:40:55,582 --> 03:40:57,651
安装并添加一个模块名


6253
03:40:58,041 --> 03:40:59,781
python连字符码头


6254
03:41:00,321 --> 03:41:04,400
当我点击进入的时候，它会自动为我们自己安装python狗，


6255
03:41:04,521 --> 03:41:04,641
我们


6256
03:41:04,671 --> 03:41:05,241
进入


6257
03:41:05,841 --> 03:41:09,651
它将会关闭并安装我们需要的python文档。


6258
03:41:10,521 --> 03:41:11,542
你可以看到我们有


6259
03:41:11,572 --> 03:41:13,822
成功安装的python码头


6260
03:41:14,152 --> 03:41:15,833
点八点6，


6261
03:41:16,523 --> 03:41:17,304
我相信你们


6262
03:41:17,334 --> 03:41:18,983
这个上帝到底在哪里


6263
03:41:19,014 --> 03:41:19,943
放置


6264
03:41:19,974 --> 03:41:21,714
通常在我们安装的时候


6265
03:41:21,744 --> 03:41:22,164
a


6266
03:41:22,194 --> 03:41:23,034
外部的


6267
03:41:23,064 --> 03:41:24,055
第三方模块。


6268
03:41:24,354 --> 03:41:25,584
它会被放到里面


6269
03:41:25,614 --> 03:41:26,694
这个肢体文件夹。


6270
03:41:26,874 --> 03:41:30,054
但是它会被放到一个特殊的文件夹里面


6271
03:41:30,084 --> 03:41:31,374
站点包


6272
03:41:31,764 --> 03:41:35,064
所以小的包是一个特殊的文件夹如果我打开这个文件夹，


6273
03:41:35,395 --> 03:41:37,314
你会看到现在我们有了这个


6274
03:41:37,555 --> 03:41:39,715
文档文件夹，还有这个


6275
03:41:39,745 --> 03:41:42,234
python黑暗点八点6


6276
03:41:42,685 --> 03:41:45,266
pi 3点的想法，比如信息文件夹


6277
03:41:45,476 --> 03:41:46,585
这两个文件夹


6278
03:41:46,945 --> 03:41:47,966
基本上


6279
03:41:48,326 --> 03:41:50,726
包括在那个模块安装中


6280
03:41:50,966 --> 03:41:54,596
你可以看到这个文档文件夹有很多不同的python文件


6281
03:41:54,896 --> 03:41:56,905
这里有一些我们可以使用的东西。


6282
03:41:57,205 --> 03:42:00,233
如果我想在我的程序中使用这个


6283
03:42:00,264 --> 03:42:03,534
我只需要参考模块的名称在我们的例子中，


6284
03:42:03,774 --> 03:42:05,395
它将会是码头。


6285
03:42:05,574 --> 03:42:07,344
所以我用了python码头


6286
03:42:07,554 --> 03:42:08,963
为了安装它


6287
03:42:08,993 --> 03:42:11,753
如果我们想要导入它，我们就会使用文档


6288
03:42:11,993 --> 03:42:13,464
我可以到这里来，我可以说


6289
03:42:13,494 --> 03:42:14,124
进口


6290
03:42:14,184 --> 03:42:15,414
交易c。


6291
03:42:15,984 --> 03:42:16,465
并且


6292
03:42:16,495 --> 03:42:22,556
现在我可以用它了，所以我可以像docs一样，随便你可以看到这里有很多不同的东西。


6293
03:42:22,796 --> 03:42:23,846
就像一份文件，


6294
03:42:23,996 --> 03:42:26,487
文档部分的图像部分有很多我们可以做的事情


6295
03:42:26,518 --> 03:42:27,838
使用这个，很明显


6296
03:42:28,048 --> 03:42:29,248
取决于python


6297
03:42:29,278 --> 03:42:30,419
安装模块


6298
03:42:30,449 --> 03:42:31,859
可以有不同的指令。


6299
03:42:32,249 --> 03:42:32,969
但是你可以看到


6300
03:42:32,999 --> 03:42:34,500
把它储存在这里


6301
03:42:34,530 --> 03:42:35,880
站点包文件夹。


6302
03:42:36,120 --> 03:42:37,859
如果我想移除这个


6303
03:42:37,890 --> 03:42:38,609
我可以用


6304
03:42:38,640 --> 03:42:40,501
选择这样做，所以我可以说是小费


6305
03:42:42,511 --> 03:42:44,371
然后安装，我们可以


6306
03:42:45,901 --> 03:42:46,531
再说一遍


6307
03:42:46,562 --> 03:42:47,940
这是一个模块的名称


6308
03:42:47,971 --> 03:42:49,021
蟒蛇


6309
03:42:49,471 --> 03:42:50,520
现在的人们


6310
03:42:50,550 --> 03:42:51,810
安装这个


6311
03:42:52,350 --> 03:42:53,250
在我们的电脑上。


6312
03:42:53,460 --> 03:42:54,449
所以如果我要回去


6313
03:42:54,479 --> 03:42:55,919
到这里


6314
03:42:55,979 --> 03:42:56,608
文件夹，


6315
03:42:56,849 --> 03:42:58,288
你们会看到这两个


6316
03:42:58,318 --> 03:42:59,969
那个文档文件夹，然后


6317
03:42:59,999 --> 03:43:00,509
其他的


6318
03:43:00,809 --> 03:43:03,448
文件夹消失了，所以他们不在这里了，


6319
03:43:03,868 --> 03:43:06,808
实际上我就不能再用这个了


6320
03:43:07,107 --> 03:43:09,688
这是使用的一种方式


6321
03:43:09,718 --> 03:43:11,098
现在又有了模块


6322
03:43:11,308 --> 03:43:12,839
有很多这样的模块


6323
03:43:13,169 --> 03:43:15,119
我可以是几十个python


6324
03:43:15,149 --> 03:43:17,189
课程涵盖了每一个模块，


6325
03:43:17,520 --> 03:43:17,850
你知道


6326
03:43:17,909 --> 03:43:19,500
在模块中构建的


6327
03:43:19,980 --> 03:43:22,141
默认包含的模块


6328
03:43:22,200 --> 03:43:23,161
外部模块。


6329
03:43:23,312 --> 03:43:25,081
有很多这样的东西


6330
03:43:25,411 --> 03:43:31,528
作为一名python程序员，你现在可以做的是，你可以出去玩这些不同的模块。


6331
03:43:31,679 --> 03:43:34,738
我给你们展示了安装它们的细节你们可以使用pip


6332
03:43:35,038 --> 03:43:37,077
要安装所有这些不同的模块


6333
03:43:37,347 --> 03:43:41,847
你可以通过检查网站包文件夹或嘴唇文件夹来确定你已经拥有了


6334
03:43:42,297 --> 03:43:45,026
但是现在你要来了，走出去


6335
03:43:45,206 --> 03:43:49,975
使用这些模块，不要回避这个问题因为模块是一个很大的模块


6336
03:43:50,005 --> 03:43:50,935
python的一部分


6337
03:43:51,175 --> 03:43:54,594
您肯定希望将它们包含在您的python堆栈中。


6338
03:43:58,914 --> 03:44:03,354
在本教程中，我们将讨论课程和对象的内容


6339
03:44:03,413 --> 03:44:04,163
蟒蛇


6340
03:44:04,943 --> 03:44:06,474
类和对象是


6341
03:44:06,533 --> 03:44:11,393
在python编程中非常有用它们可以帮助你制作程序


6342
03:44:11,423 --> 03:44:13,762
更有条理，更有力量。


6343
03:44:14,302 --> 03:44:14,782
所以


6344
03:44:14,842 --> 03:44:17,513
当我们在python里时我们要处理所有类型的数据


6345
03:44:17,603 --> 03:44:18,083
对的


6346
03:44:18,383 --> 03:44:22,853
很多时候，当我们写程序的时候我们需要处理不同类型的数据


6347
03:44:23,272 --> 03:44:27,350
基本上，我们可以处理一些基本类型的数据，比如


6348
03:44:27,380 --> 03:44:29,510
顺子税


6349
03:44:29,689 --> 03:44:33,171
数字和布尔值这三个有点像


6350
03:44:33,381 --> 03:44:36,651
你要处理的主要数据类型


6351
03:44:37,132 --> 03:44:40,762
python和我们有各种各样的结构我们可以用来存储这些数据


6352
03:44:40,792 --> 03:44:42,651
比如列表或字典。


6353
03:44:42,802 --> 03:44:43,642
但问题是


6354
03:44:43,672 --> 03:44:44,122
是吗


6355
03:44:44,212 --> 03:44:44,722
不是


6356
03:44:44,752 --> 03:44:45,592
全部


6357
03:44:45,682 --> 03:44:48,892
信息不是所有的数据，不是所有的东西


6358
03:44:48,922 --> 03:44:49,762
可以


6359
03:44:49,792 --> 03:44:51,022
表示使用


6360
03:44:51,053 --> 03:44:53,332
数字或黄金的权利，


6361
03:44:53,512 --> 03:44:53,961
有很多


6362
03:44:53,991 --> 03:44:58,401
在现实世界中，我们无法在一个字符串或数组的自动化中表现出来，


6363
03:44:58,461 --> 03:44:59,781
或者只是一个数字


6364
03:45:00,142 --> 03:45:02,392
换句话说，像手机之类的东西


6365
03:45:02,451 --> 03:45:03,561
或电脑


6366
03:45:03,860 --> 03:45:04,850
或者一个人


6367
03:45:04,880 --> 03:45:07,130
你不能真正地代表这些东西


6368
03:45:07,580 --> 03:45:10,098
就像一个字符串或一个数字你知道它


6369
03:45:10,188 --> 03:45:11,026
换句话说


6370
03:45:11,086 --> 03:45:14,416
我们在python中可以使用的数据类型


6371
03:45:14,446 --> 03:45:15,646
不能掩盖这一点。


6372
03:45:15,977 --> 03:45:21,015
所以我们可以对类和对象做些什么我们可以创建自己的


6373
03:45:21,045 --> 03:45:22,155
数据类型。


6374
03:45:22,455 --> 03:45:25,483
所以我可以为任何我想要的东西创建自己的数据类型


6375
03:45:25,514 --> 03:45:26,444
python


6376
03:45:26,595 --> 03:45:28,664
我可以创建一个电话数据类型


6377
03:45:28,694 --> 03:45:33,525
它可以代表一个电话这样我就可以储存所有我想知道的关于我手机的信息


6378
03:45:33,945 --> 03:45:35,925
在这个数据类型里面


6379
03:45:36,104 --> 03:45:39,074
我们可以为它创建一个类


6380
03:45:39,284 --> 03:45:41,805
本质上，一个类只是说，嘿


6381
03:45:41,835 --> 03:45:44,415
这是我们想在python中使用的另一种

6382
03:45:44,896 --> 03:45:47,595
对于一个类，你可以定义


6383
03:45:47,625 --> 03:45:48,405
你自己的


6384
03:45:48,436 --> 03:45:49,756
数据类型及其


6385
03:45:49,786 --> 03:45:52,966
超级棒，类是非常有用的


6386
03:45:53,235 --> 03:45:57,227
几乎每一种主要的编程语言都使用了原因


6387
03:45:57,347 --> 03:45:58,547
在本教程中，我只想


6388
03:45:58,577 --> 03:46:00,377
给你们一个基本的介绍


6389
03:46:00,767 --> 03:46:03,646
类并在python中使用它们


6390
03:46:03,706 --> 03:46:05,866
假设我在写一个程序，


6391
03:46:05,956 --> 03:46:07,396
我想


6392
03:46:07,456 --> 03:46:08,086
表示


6393
03:46:08,116 --> 03:46:09,017
学生


6394
03:46:09,047 --> 03:46:13,246
在这个项目中，也许我在写一个像大学或大学一样的项目。


6395
03:46:13,606 --> 03:46:14,867
假设在这个程序中


6396
03:46:16,427 --> 03:46:17,958
模范

6397
03:46:17,988 --> 03:46:21,438
就像我想要一个模型一个真实的世界对象我想成为一名

6398
03:46:21,947 --> 03:46:23,777
在我们没有学生数据类型的地方


6399
03:46:23,987 --> 03:46:28,425
我不能仅仅用一个字符串或一个数字来表示一个学生。


6400
03:46:28,995 --> 03:46:32,056
所以我可以做的是，我可以创建一个类


6401
03:46:32,086 --> 03:46:36,135
对于一个学生来说，我基本上是在创造一个学生数据类型。


6402
03:46:36,615 --> 03:46:40,246
所以我相信你们是怎么做到的并创建我们的学生班


6403
03:46:40,276 --> 03:46:41,026
就在这里。


6404
03:46:41,326 --> 03:46:42,857
我要新建一个文件。


6405
03:46:43,067 --> 03:46:47,269
我们不会得到一个新的管道花瓶我就叫它学生点派


6406
03:46:48,499 --> 03:46:49,099
并且


6407
03:46:49,219 --> 03:46:52,187
在这个学生点pi文件中，我想创建


6408
03:46:52,217 --> 03:46:54,106
一个学生班。


6409
03:46:54,406 --> 03:46:56,686
我可以这样做的方法是通过输入


6410
03:46:56,716 --> 03:46:57,556
上课。


6411
03:46:58,006 --> 03:46:59,146
现在我要输入


6412
03:46:59,176 --> 03:47:00,557
类名


6413
03:47:00,587 --> 03:47:01,756
我想要创造。


6414
03:47:01,996 --> 03:47:05,687
在我们的例子中，我们要创建一个叫做学生的类，所以我只会说学生。


6415
03:47:06,076 --> 03:47:06,945
现在我们要做的是


6416
03:47:06,976 --> 03:47:07,876
结肠


6417
03:47:08,176 --> 03:47:10,695
现在所有的东西都在这里


6418
03:47:10,785 --> 03:47:13,725
会在我们的学生课堂里


6419
03:47:13,875 --> 03:47:15,855
所有发明的东西都是这样的


6420
03:47:15,915 --> 03:47:17,596
会被认为是我们的一部分


6421
03:47:17,626 --> 03:47:18,346
学生


6422
03:47:18,376 --> 03:47:18,976
阶级


6423
03:47:19,396 --> 03:47:24,075
基本上我们可以在这个学生类中做的就是我们可以定义一堆属性


6424
03:47:24,105 --> 03:47:25,305
关于一个学生。


6425
03:47:25,395 --> 03:47:27,944
所以本质上我所做的与建模不同


6426
03:47:27,975 --> 03:47:30,796
我在创建学生数据类型。


6427
03:47:31,065 --> 03:47:32,985
我可以用字符串，


6428
03:47:33,195 --> 03:47:34,846
整数和金块


6429
03:47:35,025 --> 03:47:36,136
为了


6430
03:47:36,195 --> 03:47:36,615
地图


6431
03:47:36,646 --> 03:47:39,915
一个学生应该拥有什么样的学生应该拥有什么。


6432
03:47:40,335 --> 03:47:43,064
所以我想创建一个叫做初始化的东西


6433
03:47:43,095 --> 03:47:43,755
函数。


6434
03:47:44,115 --> 03:47:45,854
我这样做的方式是


6435
03:47:46,004 --> 03:47:47,414
输入d e f


6436
03:47:47,804 --> 03:47:48,643
我要带着


6437
03:47:48,673 --> 03:47:50,082
两个下划线，


6438
03:47:50,502 --> 03:47:51,342
然后这个词


6439
03:47:51,372 --> 03:47:52,752
我是我


6440
03:47:52,992 --> 03:47:54,883
还有

6441
03:47:55,393 --> 03:47:55,812
并且


6442
03:47:55,843 --> 03:47:57,072
你也要输入输出


6443
03:47:57,103 --> 03:47:58,632
开闭括号


6444
03:47:58,752 --> 03:48:01,271
在括号里，我们要输入


6445
03:48:01,301 --> 03:48:02,081
自我，


6446
03:48:02,351 --> 03:48:04,061
之后我在结肠上。


6447
03:48:04,721 --> 03:48:07,630
在这个初始化函数中我能做什么


6448
03:48:07,899 --> 03:48:09,189
我基本上可以映射到


6449
03:48:09,220 --> 03:48:09,609
外出


6450
03:48:09,819 --> 03:48:11,949
一个学生应该具备哪些特质


6451
03:48:11,979 --> 03:48:13,630
所以我们可以定义为


6452
03:48:13,840 --> 03:48:14,320
嘿，


6453
03:48:14,380 --> 03:48:16,149
这是学生数据类型


6454
03:48:16,209 --> 03:48:16,659
在


6455
03:48:16,779 --> 03:48:17,350
蟒蛇


6456
03:48:17,380 --> 03:48:18,789
所以我要做的是添加进去


6457
03:48:18,819 --> 03:48:19,989
某些属性


6458
03:48:20,020 --> 03:48:22,661
在这个自我之后，我就会说self


6459
03:48:22,691 --> 03:48:23,472
一个逗号。


6460
03:48:23,682 --> 03:48:25,541
现在我们可以开始思考


6461
03:48:25,571 --> 03:48:26,052
你知道


6462
03:48:26,111 --> 03:48:27,701
什么价值观


6463
03:48:27,761 --> 03:48:29,860
代表我们的学生


6464
03:48:29,891 --> 03:48:31,211
python程序


6465
03:48:31,541 --> 03:48:32,741
如果我在想湖


6466
03:48:32,831 --> 03:48:34,270
不考虑名字


6467
03:48:34,329 --> 03:48:35,739
所以每个学生


6468
03:48:36,009 --> 03:48:37,659
在我们的程序中应该有一个名字。


6469
03:48:38,140 --> 03:48:40,119
他们也可能想要一个专业


6470
03:48:40,149 --> 03:48:41,590
因为他们在上大学，


6471
03:48:42,280 --> 03:48:45,041
他们可能也会有一个gps，


6472
03:48:45,251 --> 03:48:46,961
所以他们的平均绩点是


6473
03:48:46,991 --> 03:48:48,222
他们在学校的表现


6474
03:48:48,731 --> 03:48:51,460
让我们再来找一个让我思考的问题，


6475
03:48:51,520 --> 03:48:52,270
我们为什么不做


6476
03:48:52,300 --> 03:48:53,561
金银块


6477
03:48:53,980 --> 03:48:55,030
它将被命名为


6478
03:48:55,090 --> 03:48:55,750
是


6479
03:48:55,840 --> 03:48:56,439
在


6480
03:48:57,130 --> 03:48:58,030
试用


6481
03:48:58,391 --> 03:49:01,449
这基本上会告诉你这个学生是否

6482
03:49:01,479 --> 03:49:02,319
缓刑。


6483
03:49:03,010 --> 03:49:03,580
所以


6484
03:49:03,970 --> 03:49:06,100
本质上，我在这里面所做的


6485
03:49:06,130 --> 03:49:07,839
在这个里面初始化方法


6486
03:49:07,869 --> 03:49:09,100
先天功能

6487
03:49:09,430 --> 03:49:11,319
我在定义一个学生


6488
03:49:11,979 --> 03:49:12,909
在我们的项目中。


6489
03:49:13,119 --> 03:49:14,439
在这个项目中


6490
03:49:14,470 --> 03:49:15,189
学生


6491
03:49:15,249 --> 03:49:16,148
有一个名字，


6492
03:49:16,358 --> 03:49:17,408
它有一个专业


6493
03:49:17,588 --> 03:49:18,697
作为一个gps，


6494
03:49:18,817 --> 03:49:21,665
它的价值决定了它是否在试用期。


6495
03:49:21,905 --> 03:49:24,425
这是学生数据类型。


6496
03:49:24,845 --> 03:49:27,876
所以如果我现在代表一个学生在我的程序里，


6497
03:49:28,146 --> 03:49:30,156
它具有所有这些属性


6498
03:49:30,187 --> 03:49:31,446
与之相关。


6499
03:49:31,687 --> 03:49:33,517
这就是我在这里所做的


6500
03:49:33,906 --> 03:49:34,387
现在


6501
03:49:34,446 --> 03:49:36,276
在这个初始化中


6502
03:49:36,427 --> 03:49:38,707
函数我们需要做一些事情


6503
03:49:38,767 --> 03:49:40,627
基本上我想做的是


6504
03:49:41,257 --> 03:49:42,637
分配一些值


6505
03:49:42,667 --> 03:49:45,637
所以我要写一些东西，这可能不会


6506
03:49:45,696 --> 03:49:46,717
总感觉


6507
03:49:46,927 --> 03:49:47,767
现在。


6508
03:49:47,946 --> 03:49:51,365
但这在我们创建第一个之后的一秒钟内是有意义的


6509
03:49:52,145 --> 03:49:52,805
对象。


6510
03:49:53,074 --> 03:49:53,494
所以


6511
03:49:53,524 --> 03:49:56,314
现在就跟我说，基本上


6512
03:49:56,345 --> 03:50:00,155
要知道我们必须要做我在这里做的事情所以我要说的是self。meme


6513
03:50:00,545 --> 03:50:01,505
等于名字。


6514
03:50:02,075 --> 03:50:03,964
然后我会说self。major


6515
03:50:04,233 --> 03:50:05,253
因为你得到了专业


6516
03:50:05,703 --> 03:50:07,173
自点gps


6517
03:50:07,203 --> 03:50:07,504
被使用


6518
03:50:07,534 --> 03:50:08,345
gps。


6519
03:50:08,795 --> 03:50:10,234
我要说的是self。


6520
03:50:10,265 --> 03:50:11,104
是


6521
03:50:11,704 --> 03:50:12,334
在


6522
03:50:13,894 --> 03:50:15,453
试用期等于


6523
03:50:15,483 --> 03:50:16,654
是在缓刑期。


6524
03:50:16,805 --> 03:50:17,645
再一次


6525
03:50:17,675 --> 03:50:19,266
这可能不会有太大的意义


6526
03:50:19,296 --> 03:50:20,196
现

6527
03:50:20,227 --> 03:50:20,677
但

6528
03:50:20,736 --> 03:50:21,485
一点点地


6529
03:50:21,516 --> 03:50:22,295
这将会


6530
03:50:22,325 --> 03:50:23,195
总感觉


6531
03:50:23,226 --> 03:50:23,796
所以


6532
03:50:23,855 --> 03:50:26,405
现在我已经定义了这个学生类


6533
03:50:26,436 --> 03:50:28,145
我可以用这个类


6534
03:50:28,505 --> 03:50:31,055
在我的其他文件中


6535
03:50:31,385 --> 03:50:33,093
我要到这个应用程序中来


6536
03:50:33,123 --> 03:50:34,293
点python文件。


6537
03:50:34,503 --> 03:50:35,943
这是我的主要文件。


6538
03:50:36,123 --> 03:50:37,712
所以我想要创建


6539
03:50:37,742 --> 03:50:39,271
一个学生


6540
03:50:39,571 --> 03:50:41,792
在我们定义的学生类中


6541
03:50:41,912 --> 03:50:45,781
学生数据类型，我们基本上说，嘿，学生有名字，


6542
03:50:46,081 --> 03:50:47,521
一个主要的gps和


6543
03:50:47,730 --> 03:50:49,681
它说他们是否在试用期


6544
03:50:49,891 --> 03:50:52,439
点就像一个学生的模板


6545
03:50:52,470 --> 03:50:52,950
是，


6546
03:50:53,340 --> 03:50:53,939
但是我们可以


6547
03:50:53,970 --> 03:50:55,439
实际创造


6548
03:50:55,499 --> 03:50:56,759
一个学生，所以我们可以


6549
03:50:56,789 --> 03:50:59,789
创建一个真正的学生并给它一些信息。


6550
03:51:00,029 --> 03:51:00,989
这就是所谓的


6551
03:51:01,020 --> 03:51:01,739
对象。


6552
03:51:02,039 --> 03:51:02,639
所以


6553
03:51:02,789 --> 03:51:03,149
这个


6554
03:51:03,180 --> 03:51:05,130
这里的学生类


6555
03:51:05,460 --> 03:51:07,710
基本上就是定义

6556
03:51:07,740 --> 03:51:08,101
是


6557
03:51:08,131 --> 03:51:09,540
所以一个类就像


6558
03:51:09,690 --> 03:51:11,971
对学生数据类型的概述


6559
03:51:12,780 --> 03:51:13,800
一个物体


6560
03:51:14,040 --> 03:51:15,480
是一个真正的学生


6561
03:51:15,570 --> 03:51:19,081
所以这是一个真正的学生，有一个名字，一个专业，一个gps。


6562
03:51:19,471 --> 03:51:21,781
它不再是这个模板了


6563
03:51:21,812 --> 03:51:25,382
实际上就像我们在项目中代表的学生一样


6564
03:51:26,342 --> 03:51:30,331
为了使用这个学生班级并创建一个学生


6565
03:51:30,361 --> 03:51:33,062
对象，我需要导入它


6566
03:51:33,122 --> 03:51:35,012
我在这里要做的只是说


6567
03:51:35,342 --> 03:51:36,092
从


6568
03:51:36,691 --> 03:51:37,531
学生


6569
03:51:37,981 --> 03:51:39,512
这里指的是

6570
03:51:39,542 --> 03:51:40,771
学生档案。


6571
03:51:41,191 --> 03:51:41,942
我可以说


6572
03:51:42,002 --> 03:51:42,752
进口


6573
03:51:45,122 --> 03:51:48,273
基本上这句话的意思是来自

6574
03:51:48,304 --> 03:51:49,084
文件。


6575
03:51:49,294 --> 03:51:51,725
我想导入学生类。


6576
03:51:51,845 --> 03:51:56,613
所以即使这两个都是学生他们指的是不同的东西所以这是指

6577
03:51:56,974 --> 03:51:59,764
这里指的是实际的学生班级。


6578
03:52:00,004 --> 03:52:02,732
所以现在我们做了这个我们可以创建一个

6579
03:52:02,912 --> 03:52:03,692
你可以创建一个


6580
03:52:03,723 --> 03:52:05,072
类对象


6581
03:52:05,103 --> 03:52:07,473
很像你会是一个普通的变量


6582
03:52:07,652 --> 03:52:08,822
我可以给它起个名字


6583
03:52:08,853 --> 03:52:09,873
我把它命名为


6584
03:52:10,053 --> 03:52:11,253
学生一


6585
03:52:11,312 --> 03:52:12,963
我要把它设为


6586
03:52:14,763 --> 03:52:17,013
我要做一个开闭括号


6587
03:52:17,223 --> 03:52:17,792
现在


6588
03:52:17,852 --> 03:52:19,771
在这个括号里。


6589
03:52:19,891 --> 03:52:21,270
我想给这个学生


6590
03:52:21,359 --> 03:52:22,049
一个名字，


6591
03:52:22,739 --> 03:52:23,640
专业的


6592
03:52:23,880 --> 03:52:24,870
全球定位系统


6593
03:52:25,200 --> 03:52:25,771
安


6594
03:52:25,801 --> 03:52:27,211
在试用期间


6595
03:52:27,541 --> 03:52:28,171
价值。


6596
03:52:28,440 --> 03:52:31,407
所以我想说的是，它会创建一个假的学生看到他的名字


6597
03:52:31,438 --> 03:52:32,037
吉姆


6598
03:52:32,518 --> 03:52:33,897
他在学习


6599
03:52:34,138 --> 03:52:35,098
商业


6600
03:52:36,718 --> 03:52:37,468
并且


6601
03:52:37,498 --> 03:52:40,167
我们想给他们一个gps也许有三个点


6602
03:52:40,197 --> 03:52:40,797
一。


6603
03:52:41,997 --> 03:52:45,927
最后，我们想说这个学生是否在试用期，所以我们为什么不说假。


6604
03:52:46,316 --> 03:52:48,087
所以基本上我所做的就是


6605
03:52:48,267 --> 03:52:50,126
说我想创造


6606
03:52:50,156 --> 03:52:51,086
一个学生。


6607
03:52:51,446 --> 03:52:53,726
所以我想要创建一个学生


6608
03:52:53,785 --> 03:52:55,076
物体和橡胶


6609
03:52:55,106 --> 03:52:55,797
对象


6610
03:52:55,827 --> 03:52:56,427
只是


6611
03:52:56,696 --> 03:52:56,966
一


6612
03:52:56,996 --> 03:52:57,716
实例


6613
03:52:57,746 --> 03:52:58,735
在一个班级里。


6614
03:52:58,976 --> 03:53:02,845
所以这个类就像一个整体模板它定义了一个学生是什么


6615
03:53:03,114 --> 03:53:04,104
放一个物体


6616
03:53:04,164 --> 03:53:04,494
是


6617
03:53:04,524 --> 03:53:05,784
实际学生


6618
03:53:05,844 --> 03:53:07,494
实际信息


6619
03:53:07,704 --> 03:53:09,804
我们现在可以给学生打电话了


6620
03:53:09,834 --> 03:53:11,034
这是一个学生


6621
03:53:11,124 --> 03:53:11,904
对象。


6622
03:53:12,354 --> 03:53:13,884
我只是想让你们看看，


6623
03:53:13,943 --> 03:53:18,834
这个学生对象实际上是什么以及我们能用它做什么然后我将会更多地讨论这个问题


6624
03:53:18,864 --> 03:53:19,765
在it函数中


6625
03:53:19,795 --> 03:53:20,845
从那以后


6626
03:53:21,475 --> 03:53:22,435
在这里，我要


6627
03:53:22,465 --> 03:53:23,664
做一个打印语句


6628
03:53:24,474 --> 03:53:26,393
在这里，我只想打印出来


6629
03:53:26,782 --> 03:53:27,473
学生


6630
03:53:27,862 --> 03:53:28,312
并且


6631
03:53:28,433 --> 03:53:29,482
有什么好酷的


6632
03:53:29,542 --> 03:53:29,962
这个


6633
03:53:29,992 --> 03:53:33,022
学生一个对象是我可以访问


6634
03:53:33,082 --> 03:53:35,961
从这个对象内部的每个属性。


6635
03:53:36,261 --> 03:53:39,948
所以如果我想要得到学生的名字我可以说学生一个点名


6636
03:53:40,368 --> 03:53:40,938
现在


6637
03:53:40,969 --> 03:53:42,078
这实际上是打印出来的


6638
03:53:42,108 --> 03:53:43,519
把学生的名字写出来。


6639
03:53:43,969 --> 03:53:45,108
在这里，


6640
03:53:45,259 --> 03:53:46,578
你会看到它打印出来了


6641
03:53:46,608 --> 03:53:47,059
吉姆


6642
03:53:47,389 --> 03:53:49,277
如果我想我可以把学生打印出来


6643
03:53:49,308 --> 03:53:50,147
全球定位系统


6644
03:53:50,537 --> 03:53:52,367
它会打印出

6645
03:53:53,178 --> 03:53:54,048
三点一。


6646
03:53:54,498 --> 03:53:56,237
现在我创建了

6647
03:53:56,958 --> 03:53:57,648
对象。


6648
03:53:57,979 --> 03:54:01,129
我可以获取关于学生的信息


6649
03:54:01,159 --> 03:54:03,710
本质上，我只是创建了一个学生


6650
03:54:03,740 --> 03:54:04,460
数据类型


6651
03:54:04,490 --> 03:54:10,218
所以我可以创造出尽可能多的学生如果我想我可以创造另一个学生我们也可以叫它学生。


6652
03:54:11,388 --> 03:54:12,078
并且


6653
03:54:12,229 --> 03:54:15,560
本质上，我们做同样的事情我们只是给它不同的信息


6654
03:54:15,590 --> 03:54:16,521
我们可以说是湖


6655
03:54:16,971 --> 03:54:17,661
帕姆


6656
03:54:17,841 --> 03:54:19,161
她的专业是


6657
03:54:19,251 --> 03:54:19,731
艺术


6658
03:54:20,151 --> 03:54:21,591
她有一个


6659
03:54:21,831 --> 03:54:23,121
二点五。


6660
03:54:23,481 --> 03:54:25,792
我们假设她在试用期。


6661
03:54:26,362 --> 03:54:29,931
现在我又有了一个学生学生如果我想要


6662
03:54:30,081 --> 03:54:34,703
我可以获取关于那个学生的信息我们可以说，像学生一样，对p a


6663
03:54:35,063 --> 03:54:36,114
这给了我


6664
03:54:36,145 --> 03:54:37,375
日本民主党


6665
03:54:37,435 --> 03:54:38,425
学生也是。


6666
03:54:38,755 --> 03:54:42,177
所以基本上我所做的就是创建了一个学生

6667
03:54:42,267 --> 03:54:44,336
我创建了学生对象


6668
03:54:44,396 --> 03:54:46,677
现在我可以代表一个学生


6669
03:54:46,707 --> 03:54:47,967
在我的程序里。


6670
03:54:48,327 --> 03:54:48,777
所以


6671
03:54:48,808 --> 03:54:52,828
让我们快速地讨论一下这些东西因为我并没有真正解释它


6672
03:54:53,248 --> 03:54:55,139
基本上发生的是


6673
03:54:55,889 --> 03:54:58,139
当我来到这里，我说学生


6674
03:54:58,408 --> 03:55:01,019
我传递了所有这些不同的值。


6675
03:55:01,828 --> 03:55:03,838
这些都被传递到这个


6676
03:55:03,868 --> 03:55:04,857
init函数。


6677
03:55:05,098 --> 03:55:06,988
记住，我以一个名字


6678
03:55:07,019 --> 03:55:09,448
我通过了一个专业的gps。


6679
03:55:09,658 --> 03:55:11,458
当我们创建那个学生时


6680
03:55:11,548 --> 03:55:12,987
我们实际上是在打电话


6681
03:55:13,018 --> 03:55:14,098
这个函数。


6682
03:55:14,458 --> 03:55:16,019
当我传入这个名字的时候


6683
03:55:16,049 --> 03:55:17,519
主要和gps


6684
03:55:17,729 --> 03:55:21,329
这些值实际上是以这个名字存储在这里的。


6685
03:55:21,539 --> 03:55:23,309
这个主要是gps


6686
03:55:23,339 --> 03:55:24,089
等等，


6687
03:55:24,539 --> 03:55:24,869
对的


6688
03:55:24,989 --> 03:55:25,409
所以我


6689
03:55:25,439 --> 03:55:26,459
给予


6690
03:55:26,489 --> 03:55:27,839
学生对象。


6691
03:55:28,199 --> 03:55:29,699
所有的信息。


6692
03:55:29,939 --> 03:55:31,170
在下面这里。


6693
03:55:31,410 --> 03:55:32,371
我在做什么


6694
03:55:32,431 --> 03:55:32,851
我是


6695
03:55:32,881 --> 03:55:33,601
说


6696
03:55:33,721 --> 03:55:35,040
自点名


6697
03:55:35,070 --> 03:55:35,911
就像他说的那样


6698
03:55:35,941 --> 03:55:37,291
基本上这意味着


6699
03:55:37,531 --> 03:55:39,571
实际对象名称


6700
03:55:39,901 --> 03:55:42,602
就等于它们传递的名字


6701
03:55:42,661 --> 03:55:45,271
所以self。name是属性


6702
03:55:45,421 --> 03:55:46,321
学生，


6703
03:55:46,472 --> 03:55:51,271
举个学生正在存储一个名字学生在存储一个学生的主要学生存储和gps，


6704
03:55:51,780 --> 03:55:53,221
但这和


6705
03:55:53,251 --> 03:55:54,121
这个名字


6706
03:55:54,151 --> 03:55:56,161
这是gps的主要功能


6707
03:55:56,521 --> 03:55:59,581
记住，这些都是我传入的值


6708
03:55:59,911 --> 03:56:01,081
只有参数。


6709
03:56:01,441 --> 03:56:04,232
所以我需要取我传入的值


6710
03:56:04,532 --> 03:56:09,450
我需要把它们分配给对象的实际属性所以我需要

6711
03:56:09,720 --> 03:56:10,290
好的。


6712
03:56:10,410 --> 03:56:14,249
这个学生的名字将等于我们传递的名字


6713
03:56:14,759 --> 03:56:15,420
再来一次。


6714
03:56:15,660 --> 03:56:17,311
学生的名字


6715
03:56:17,341 --> 03:56:18,181
对象


6716
03:56:18,271 --> 03:56:19,740
就等于

6717
03:56:19,771 --> 03:56:20,820
我们通过了


6718
03:56:21,061 --> 03:56:23,370
学生的专业名称，


6719
03:56:24,840 --> 03:56:26,311
我们通过的专业


6720
03:56:26,700 --> 03:56:28,471
学生的gps


6721
03:56:28,980 --> 03:56:31,710
就等于我们传递的gps。


6722
03:56:31,860 --> 03:56:34,739
这就是这里所发生的事情所以当我说自我的时候


6723
03:56:35,039 --> 03:56:37,619
指的是实际的物体


6724
03:56:37,889 --> 03:56:39,658
这里我要创建的是


6725
03:56:39,688 --> 03:56:40,769
学生对象。


6726
03:56:41,099 --> 03:56:43,288
我把所有这些信息都给了。


6727
03:56:43,438 --> 03:56:46,799
它将这些信息存储为属性


6728
03:56:46,829 --> 03:56:47,310
为了


6729
03:56:47,340 --> 03:56:48,149
这个物体。


6730
03:56:48,600 --> 03:56:49,050
所以


6731
03:56:49,140 --> 03:56:52,708
希望这讲得通，我认为这是我能做到的


6732
03:56:52,888 --> 03:56:55,168
重点是现在我们有了一个学生


6733
03:56:55,198 --> 03:56:55,888
数据类型。


6734
03:56:56,157 --> 03:56:58,587
现在我可以代表一个学生


6735
03:56:58,977 --> 03:57:00,087
在我的内心


6736
03:57:00,117 --> 03:57:00,867
蟒蛇


6737
03:57:00,897 --> 03:57:01,378
程序


6738
03:57:01,408 --> 03:57:03,028
这就像一个超级强大的。


6739
03:57:03,509 --> 03:57:06,539
对于类和对象，什么是很酷的，因为你可以用任何东西来做这个。


6740
03:57:06,959 --> 03:57:12,270
在这个例子中，我们创建了一个学生类然后我们创建了

6741
03:57:12,479 --> 03:57:13,409
但是我可以建模


6742
03:57:13,439 --> 03:57:14,970
任何现实世界的实体


6743
03:57:15,000 --> 03:57:17,820
在这个程序中，我可以模拟像电话一样的东西


6744
03:57:18,210 --> 03:57:19,410
或者我可以模仿


6745
03:57:19,440 --> 03:57:20,311
水瓶


6746
03:57:20,341 --> 03:57:21,211
或者我可以建模


6747
03:57:21,241 --> 03:57:21,631
你知道


6748
03:57:22,171 --> 03:57:22,921
键盘


6749
03:57:22,951 --> 03:57:25,200
我可以做任何我想做的模型。


6750
03:57:25,470 --> 03:57:26,820
在我的程序中


6751
03:57:26,910 --> 03:57:29,011
我可以给它一些属性


6752
03:57:29,131 --> 03:57:32,821
这就是我们可以模拟真实世界物体的地方。


6753
03:57:32,881 --> 03:57:34,682
我们可以创建自己的


6754
03:57:34,712 --> 03:57:35,853
数据类型


6755
03:57:40,053 --> 03:57:41,644
在本教程中关于军人的


6756
03:57:41,674 --> 03:57:45,124
如何在python中构建一个多选题测试。


6757
03:57:45,604 --> 03:57:46,774
所以基本上我们要


6758
03:57:46,805 --> 03:57:51,843
设置一个小的选择测验我们让用户参加测验当他们进行测验的时候


6759
03:57:52,112 --> 03:57:55,895
会记录他们的分数然后在最后告诉他们他们是怎么做的


6760
03:57:56,164 --> 03:58:02,373
这将是一个很酷的视频我很高兴他知道如何做这个我们会用到一些东西，比如类


6761
03:58:02,403 --> 03:58:03,363
if语句


6762
03:58:03,453 --> 03:58:04,293
松脱


6763
03:58:04,562 --> 03:58:07,172
为了构建这些程序我们将会使用很多很酷的东西


6764
03:58:07,202 --> 03:58:08,433
在python里的东西。


6765
03:58:08,973 --> 03:58:10,322
首先我想给大家展示的是


6766
03:58:10,562 --> 03:58:12,901
在我开始视频之前就做过了


6767
03:58:12,932 --> 03:58:15,571
这个小的射线被称为问题提示。


6768
03:58:15,871 --> 03:58:19,589
我基本上把所有的问题都写出来了。


6769
03:58:19,709 --> 03:58:23,038
或者我应该说我写的所有问题的答案


6770
03:58:23,248 --> 03:58:26,967
这将会是我的多项选择题的内容所以第一个测试是说


6771
03:58:27,267 --> 03:58:29,758
苹果的颜色是什么，答案是


6772
03:58:29,817 --> 03:58:30,447
红色，


6773
03:58:30,867 --> 03:58:32,188
紫色或橙色。


6774
03:58:32,518 --> 03:58:33,447
下一个是


6775
03:58:33,478 --> 03:58:35,577
选择是什么颜色的香蕉


6776
03:58:35,607 --> 03:58:37,528
蓝绿色和黄色，


6777
03:58:38,158 --> 03:58:41,218
第三个问题是草莓是什么颜色的


6778
03:58:41,458 --> 03:58:46,796
选项是黄色的红色和蓝色这显然是一个非常简单的多项选择题


6779
03:58:47,096 --> 03:58:47,667
我只是有点


6780
03:58:47,727 --> 03:58:51,085
提前把问题写出来，这样我就不用花时间去做了。


6781
03:58:51,445 --> 03:58:53,306
让我们来谈谈我们是如何构建的


6782
03:58:53,336 --> 03:58:53,756
a


6783
03:58:53,786 --> 03:58:55,076
多重选择


6784
03:58:55,106 --> 03:58:55,736
测试。


6785
03:58:56,066 --> 03:58:56,456
嗯。


6786
03:58:56,636 --> 03:59:00,325
首先我要考虑的是如何在测试中表示问题


6787
03:59:00,595 --> 03:59:01,045
对的


6788
03:59:01,135 --> 03:59:03,385
这里我们有问题提示。


6789
03:59:03,595 --> 03:59:06,896
但是当你思考这个问题的时候，实际上有两个部分，


6790
03:59:07,136 --> 03:59:09,057
还有一些提示，比如


6791
03:59:09,116 --> 03:59:09,597
那


6792
03:59:09,687 --> 03:59:11,157
实际问题本身。


6793
03:59:11,607 --> 03:59:16,258
这两种属性的答案都是必须的


6794
03:59:16,317 --> 03:59:16,977
跟踪


6795
03:59:17,277 --> 03:59:21,414
我需要记录下我们想要问的问题，我需要一个帽子来记录下答案是什么。


6796
03:59:21,774 --> 03:59:23,664
所以我要做的是创建


6797
03:59:24,085 --> 03:59:25,436
问答类


6798
03:59:25,466 --> 03:59:28,556
所以我要创建一个小数据类型


6799
03:59:28,976 --> 03:59:31,706
在这个问题中，类将能够存储


6800
03:59:31,736 --> 03:59:33,057
问题提示，


6801
03:59:33,297 --> 03:59:35,757
也可以储存这个问题


6802
03:59:35,787 --> 03:59:36,387
回答，


6803
03:59:36,776 --> 03:59:40,706
所以我要到我的文件夹，然后新建一个


6804
03:59:40,886 --> 03:59:42,056
python文件


6805
03:59:42,086 --> 03:59:43,676
我们把它命名为


6806
03:59:43,706 --> 03:59:44,486
问题


6807
03:59:44,517 --> 03:59:45,057
点


6808
03:59:45,087 --> 03:59:47,066
所以我们要把问题提得很高


6809
03:59:48,086 --> 03:59:53,064
在这个问题中，点pi文件，我要做一个类，所以我只会说类


6810
03:59:53,095 --> 03:59:53,904
问题。


6811
03:59:54,234 --> 03:59:55,073
我要放一个


6812
03:59:55,104 --> 03:59:55,974
这里是冒号。


6813
03:59:56,363 --> 03:59:57,653
在这里面


6814
03:59:57,684 --> 04:00:00,323
我们想要定义它并初始化


6815
04:00:00,623 --> 04:00:01,403
功能


6816
04:00:01,764 --> 04:00:02,694
我必须说，耳聋


6817
04:00:03,024 --> 04:00:04,014
强调


6818
04:00:04,044 --> 04:00:04,584
在里面


6819
04:00:04,644 --> 04:00:05,783
太强调了，


6820
04:00:06,173 --> 04:00:06,803
并且


6821
04:00:06,923 --> 04:00:08,151
然后我们要输入一个


6822
04:00:08,182 --> 04:00:09,472
开闭括号


6823
04:00:09,502 --> 04:00:10,222
自我


6824
04:00:10,252 --> 04:00:11,241
这是一个冒号。


6825
04:00:11,781 --> 04:00:15,471
在这个自我之后我们想要找到不同的属性


6826
04:00:15,501 --> 04:00:17,571
这将会描述或将会


6827
04:00:17,602 --> 04:00:19,461
被包含在一个问题中


6828
04:00:20,091 --> 04:00:21,532
我们将包括a


6829
04:00:21,562 --> 04:00:22,282
提示


6830
04:00:22,312 --> 04:00:26,273
每个人都要包含一个答案所以每个问题我们都会有一个问题

6831
04:00:26,604 --> 04:00:28,013
一个问题的答案


6832
04:00:28,253 --> 04:00:31,881
下面我要取这些值并赋值


6833
04:00:31,911 --> 04:00:32,481
到


6834
04:00:32,512 --> 04:00:33,321
实际的


6835
04:00:33,352 --> 04:00:35,782
类对象只是说self


6836
04:00:35,812 --> 04:00:36,322
点


6837
04:00:37,492 --> 04:00:38,632
要么是提示。


6838
04:00:39,172 --> 04:00:40,763
我必须说，self。


6839
04:00:40,942 --> 04:00:42,683
答案等于答案。


6840
04:00:42,982 --> 04:00:47,542
现在我们设置了一个问题类我们可以存储我们需要的所有信息


6841
04:00:47,962 --> 04:00:49,372
关于一个问题。


6842
04:00:49,882 --> 04:00:53,812
现在我要做的是回到我的app点python文件，


6843
04:00:54,411 --> 04:00:57,082
我们会创建一系列的问题。


6844
04:00:57,322 --> 04:01:00,142
这里有三个提示，


6845
04:01:00,472 --> 04:01:03,232
实际上我要创建另一个数组所以我们就叫它


6846
04:01:03,742 --> 04:01:04,672
问题。


6847
04:01:05,062 --> 04:01:06,950
我要把它设为


6848
04:01:07,580 --> 04:01:09,171
开或关的方括号


6849
04:01:09,471 --> 04:01:11,210
我们将开始提出问题


6850
04:01:11,240 --> 04:01:12,830
对象，所以我可以说


6851
04:01:13,130 --> 04:01:15,561
这个问题的第一个元素是


6852
04:01:16,190 --> 04:01:16,940
问题，


6853
04:01:17,421 --> 04:01:18,831
我们想通过


6854
04:01:19,971 --> 04:01:21,351
询问提示


6855
04:01:22,221 --> 04:01:22,971
零。


6856
04:01:23,121 --> 04:01:26,031
第一个问题的答案是


6857
04:01:26,361 --> 04:01:26,751
a


6858
04:01:26,781 --> 04:01:29,389
红色的绿色这是苹果的颜色所以我要通过


6859
04:01:29,599 --> 04:01:30,859
第一个

6860
04:01:30,919 --> 04:01:32,689
我也要通过


6861
04:01:32,749 --> 04:01:34,039
答案是a，


6862
04:01:34,339 --> 04:01:36,468
你可以看到这里，我得到了一个错误


6863
04:01:36,647 --> 04:01:37,667
未解决的


6864
04:01:37,697 --> 04:01:38,357
参考文献


6865
04:01:38,388 --> 04:01:39,107
问题


6866
04:01:39,438 --> 04:01:41,657
所以实际上我们需要做的是


6867
04:01:41,777 --> 04:01:46,098
创建这些问题是我们需要导入mckillop上的这个问题类


6868
04:01:46,128 --> 04:01:47,059
到这里来，说


6869
04:01:47,358 --> 04:01:47,898
从


6870
04:01:49,728 --> 04:01:50,508
进口


6871
04:01:52,698 --> 04:01:53,358
现在


6872
04:01:53,389 --> 04:01:55,278
在这个问题数组中，我们


6873
04:01:55,309 --> 04:01:58,638
不再得到那根头发，所以我们创造了一个问题对象。


6874
04:01:59,088 --> 04:02:00,198
我要讲的是


6875
04:02:00,229 --> 04:02:01,699
再创建几个


6876
04:02:01,729 --> 04:02:02,659
其他的


6877
04:02:02,689 --> 04:02:03,289
所以


6878
04:02:04,009 --> 04:02:05,269
我要复制这个


6879
04:02:05,299 --> 04:02:05,929
并且


6880
04:02:05,988 --> 04:02:08,029
我们将在这里进行调整，


6881
04:02:10,640 --> 04:02:11,899
或者是一个小时的创造


6882
04:02:11,930 --> 04:02:14,391
在这些问题中还有两个问题将会是


6883
04:02:14,480 --> 04:02:16,010
一和二。


6884
04:02:16,310 --> 04:02:18,799
第二个问题的答案是


6885
04:02:18,829 --> 04:02:19,639
c。


6886
04:02:20,119 --> 04:02:22,850
我认为第三个问题的答案是


6887
04:02:23,149 --> 04:02:23,629
纽约


6888
04:02:25,309 --> 04:02:25,608
是的


6889
04:02:25,639 --> 04:02:26,119
所以它是


6890
04:02:26,149 --> 04:02:26,779
cmb。


6891
04:02:27,319 --> 04:02:29,479
所以本质上我们所做的就是创造


6892
04:02:29,510 --> 04:02:30,830
三个问题。


6893
04:02:30,890 --> 04:02:32,929
每一个都有不同的问题提示，


6894
04:02:33,139 --> 04:02:38,147
他们每个人都有不同的答案所以现在我们有了一系列问题我们想问


6895
04:02:38,447 --> 04:02:39,438
在我们的测试中。


6896
04:02:39,798 --> 04:02:44,266
所以下一步是写一个函数来运行这个测试


6897
04:02:44,355 --> 04:02:47,566
它必须问这些问题，它必须检查才能看到


6898
04:02:47,746 --> 04:02:49,306
如果他们得到了正确答案


6899
04:02:49,636 --> 04:02:50,386
在下面


6900
04:02:50,416 --> 04:02:51,285
在文件中


6901
04:02:51,315 --> 04:02:52,635
让我们创建一个函数。


6902
04:02:53,115 --> 04:02:53,926
所以我想说


6903
04:02:53,956 --> 04:02:54,437
死亡。


6904
04:02:54,706 --> 04:02:55,937
我们称之为运行


6905
04:02:55,967 --> 04:02:56,657
试验


6906
04:02:57,228 --> 04:02:57,708
并且


6907
04:02:57,738 --> 04:02:59,178
在他的内心里


6908
04:02:59,237 --> 04:03:02,057
我们将把一个参数带入这个函数。


6909
04:03:02,297 --> 04:03:02,896
我们要做的是


6910
04:03:02,927 --> 04:03:04,968
这是一个问题列表


6911
04:03:05,027 --> 04:03:06,527
我只是想说一些问题。


6912
04:03:07,188 --> 04:03:09,018
所以这基本上就是一个列表


6913
04:03:09,048 --> 04:03:11,928
我们想问用户的问题对象。


6914
04:03:12,348 --> 04:03:13,518
所以一旦我来到这里


6915
04:03:13,548 --> 04:03:14,956
我要做的就是一个循环


6916
04:03:14,986 --> 04:03:16,786
通过所有的问题


6917
04:03:16,966 --> 04:03:18,496
我想对每个问题进行循环


6918
04:03:18,526 --> 04:03:20,206
我想问一下用户。


6919
04:03:20,356 --> 04:03:23,566
我想要得到用户的答案，我想看看它是否正确，


6920
04:03:24,047 --> 04:03:30,465
我们需要能够跟踪用户通过测试的方式所以我要创建一个名为score的变量


6921
04:03:30,885 --> 04:03:32,594
我把它设为零，


6922
04:03:32,894 --> 04:03:36,193
所以每次用户回答一个问题时都会增加这个


6923
04:03:36,224 --> 04:03:37,124
得分


6924
04:03:37,184 --> 04:03:37,903
变量


6925
04:03:38,474 --> 04:03:44,172
对，我想做的是，我说过循环遍历所有问题中的问题数组所以我要创建一个for循环


6926
04:03:44,202 --> 04:03:45,312
我要说的是


6927
04:03:45,941 --> 04:03:46,842
问题


6928
04:03:47,052 --> 04:03:47,651
在


6929
04:03:48,342 --> 04:03:49,212
问题。


6930
04:03:50,052 --> 04:03:52,513
换句话说，对于每个问题对象


6931
04:03:52,843 --> 04:03:54,644
在这个问题数组里。


6932
04:03:54,703 --> 04:03:55,663
我想做点什么。


6933
04:03:56,533 --> 04:03:57,073
并且


6934
04:03:57,104 --> 04:04:00,283
我想做的第一件事就是问用户这个

6935
04:04:00,823 --> 04:04:03,792
我想把它们的响应储存在一个变量里。


6936
04:04:04,092 --> 04:04:05,052
所以我想说


6937
04:04:05,082 --> 04:04:06,853
我想在这里创建一个变量叫做


6938
04:04:07,122 --> 04:04:07,812
回答。


6939
04:04:08,412 --> 04:04:10,423
这就代表了


6940
04:04:10,453 --> 04:04:12,163
用户对这个问题的

6941
04:04:12,223 --> 04:04:12,793
我要


6942
04:04:12,853 --> 04:04:13,183
设置


6943
04:04:13,213 --> 04:04:13,902
等于


6944
04:04:14,263 --> 04:04:14,982
输入


6945
04:04:15,822 --> 04:04:17,472
我需要给它一个提示


6946
04:04:17,502 --> 04:04:18,162
所以


6947
04:04:18,222 --> 04:04:21,792
我将会给出这些问题的提示我可以这么说


6948
04:04:22,122 --> 04:04:23,262
疑问点


6949
04:04:23,321 --> 04:04:24,071
提示。


6950
04:04:24,131 --> 04:04:25,361
现在我有了


6951
04:04:25,722 --> 04:04:29,109
用户输入的答案存储在这个变量中。


6952
04:04:29,649 --> 04:04:32,019
所以我们想看看他们是否答对了。


6953
04:04:32,229 --> 04:04:33,369
我可以用一个


6954
04:04:33,399 --> 04:04:34,568
如果是这样的话，我可以说


6955
04:04:34,599 --> 04:04:35,079
如果


6956
04:04:35,739 --> 04:04:36,399
回答


6957
04:04:36,669 --> 04:04:38,680
这指的是学生的

6958
04:04:40,961 --> 04:04:42,012
问题点


6959
04:04:42,882 --> 04:04:44,951
所以我要检查学生的答案


6960
04:04:44,981 --> 04:04:45,401
给予


6961
04:04:45,461 --> 04:04:48,222
就等于当前问题的答案


6962
04:04:48,252 --> 04:04:48,792
我们是


6963
04:04:48,882 --> 04:04:49,452
询问。


6964
04:04:49,842 --> 04:04:51,222
如果这是真的，


6965
04:04:51,312 --> 04:04:52,421
然后我就想


6966
04:04:52,451 --> 04:04:54,822
增加分数，所以我要写入分数


6967
04:04:55,362 --> 04:04:55,782
加上


6968
04:04:55,812 --> 04:04:58,572
等于1，这基本上意味着我们要加1


6969
04:04:58,603 --> 04:04:59,442
得分。


6970
04:04:59,952 --> 04:05:02,893
所以我在这个函数里面做的最后一件事就是


6971
04:05:02,923 --> 04:05:03,673
打印输出


6972
04:05:03,732 --> 04:05:06,073
我想要打印出用户是怎么做的


6973
04:05:06,854 --> 04:05:08,264
下面我要说的是，


6974
04:05:08,414 --> 04:05:08,834
打印


6975
04:05:08,864 --> 04:05:11,174
我基本上只是往上走不像你说的


6976
04:05:11,204 --> 04:05:14,623
三个问题中有两个是你答对了六个问题中的五个


6977
04:05:14,803 --> 04:05:16,933
或者你在十个问题中得到了零


6978
04:05:16,992 --> 04:05:18,463
他们是怎么做的呢


6979
04:05:18,793 --> 04:05:20,354
对你说。


6980
04:05:21,163 --> 04:05:24,253
现在我想打印出他们有多少问题


6981
04:05:24,283 --> 04:05:25,933
所以这就是这个分数。


6982
04:05:26,263 --> 04:05:27,223
为了

6983
04:05:27,253 --> 04:05:31,542
像这样的一个数字，我将不得不说，s t r，


6984
04:05:31,722 --> 04:05:33,581
然后输入数字，这样说


6985
04:05:33,641 --> 04:05:34,750
str分数


6986
04:05:35,320 --> 04:05:36,850
所以基本上说你有


6987
04:05:36,939 --> 04:05:38,289
不管他们有多好


6988
04:05:38,649 --> 04:05:40,389
所以我们用了这个小点


6989
04:05:40,419 --> 04:05:41,350
正斜杠。


6990
04:05:41,770 --> 04:05:42,310
并且


6991
04:05:43,210 --> 04:05:44,141
现在我们只说


6992
04:05:44,171 --> 04:05:46,512
有多少问题，我们可以说。


6993
04:05:46,752 --> 04:05:50,951
然后我要把它转换成字符串因为它会在数字中我们可以说字符串


6994
04:05:51,551 --> 04:05:55,271
然后想要算出这个问题数组中有多少个问题，所以我可以说。


6995
04:05:55,331 --> 04:05:56,111
埃莉安


6996
04:05:56,472 --> 04:05:57,881
在这里，我们可以说


6997
04:05:57,911 --> 04:05:58,511
问题


6998
04:05:58,541 --> 04:05:59,531
这有点像


6999
04:05:59,591 --> 04:05:59,951
这个


7000
04:05:59,981 --> 04:06:02,831
很长一段时间，我们来看看有多少

7001
04:06:02,951 --> 04:06:04,271
所以在这里


7002
04:06:04,871 --> 04:06:05,591
对。


7003
04:06:06,581 --> 04:06:08,620
现在我们有了这个print语句。


7004
04:06:09,010 --> 04:06:12,398
它将会打印出他们答对了多少问题。


7005
04:06:13,208 --> 04:06:14,197
我们来看看


7006
04:06:14,467 --> 04:06:17,286
我要做的最后一件事就是调用

7007
04:06:17,316 --> 04:06:19,297
运行测试函数，我说


7008
04:06:19,687 --> 04:06:20,677
运行测试。


7009
04:06:20,736 --> 04:06:22,327
我要把它传递下去


7010
04:06:22,447 --> 04:06:24,848
在此之前，问题已经准备好了


7011
04:06:25,208 --> 04:06:28,058
我们用所有这些问题创建了这个问题数组


7012
04:06:28,088 --> 04:06:29,467
里面的对象。


7013
04:06:30,187 --> 04:06:33,155
我将把它传递到这个运行测试中


7014
04:06:33,186 --> 04:06:33,726
函数。


7015
04:06:34,266 --> 04:06:35,976
现在让我们运行我们的程序


7016
04:06:36,006 --> 04:06:37,386
看看我们是怎么没有希望的


7017
04:06:37,416 --> 04:06:38,676
我们不会出错。


7018
04:06:39,006 --> 04:06:40,444
这里有很多代码


7019
04:06:40,714 --> 04:06:41,944
我们有可能。


7020
04:06:42,814 --> 04:06:46,353
好的，这就是苹果的颜色我曾经放过一个很硬的


7021
04:06:46,383 --> 04:06:46,772
a。


7022
04:06:46,832 --> 04:06:48,302
我们会得到第一个问题，对吧？


7023
04:06:48,691 --> 04:06:49,921
香蕉是什么颜色。


7024
04:06:49,980 --> 04:06:51,690
让我们把第二个问题弄错


7025
04:06:51,721 --> 04:06:52,529
所以我想说


7026
04:06:52,680 --> 04:06:54,539
香蕉不是洋红色


7027
04:06:55,199 --> 04:06:58,829
我们会得到第三个问题所以它说的是草莓的颜色


7028
04:06:58,859 --> 04:07:00,930
输出是正确的答案，


7029
04:07:01,470 --> 04:07:02,130
现在


7030
04:07:02,189 --> 04:07:04,109
你会看到我们的程序打印出来了


7031
04:07:04,140 --> 04:07:06,300
你答对了三分之二。


7032
04:07:06,689 --> 04:07:10,740
所以我们不仅要问我们所有的问题并为每个问题获取我们的输入


7033
04:07:10,771 --> 04:07:12,361
但它也记录了


7034
04:07:12,451 --> 04:07:14,491
我们的分数印出来了


7035
04:07:14,852 --> 04:07:16,682
为什么我们不能再重复一遍任务。


7036
04:07:17,132 --> 04:07:17,672
并且


7037
04:07:17,702 --> 04:07:18,392
我们会喜欢


7038
04:07:18,872 --> 04:07:23,464
这次弄错了两次，所以我们会把这个搞错，我把这个搞错了，我把这个写对了。


7039
04:07:23,974 --> 04:07:24,694
现在它说


7040
04:07:24,725 --> 04:07:26,826
你答对了三分之一


7041
04:07:26,946 --> 04:07:28,627
说我们的测试会很好。


7042
04:07:29,166 --> 04:07:31,535
我们刚写的程序很酷


7043
04:07:32,016 --> 04:07:35,075
如果我想我可以在这里添加另一个问题


7044
04:07:35,436 --> 04:07:35,796
它会


7045
04:07:35,826 --> 04:07:40,205
可以自动地问它所以不管我们在这里输入多少问题都不重要


7046
04:07:41,015 --> 04:07:42,035
它只是可以问


7047
04:07:42,065 --> 04:07:42,485
所以


7048
04:07:42,995 --> 04:07:48,365
我想说的是，这整个视频中我想说的是我们如何使用类的东西


7049
04:07:48,605 --> 04:07:49,415
为了


7050
04:07:49,445 --> 04:07:51,096
塑造一个真实的世界


7051
04:07:51,155 --> 04:07:51,755
实体。


7052
04:07:52,055 --> 04:07:53,075
举个例子


7053
04:07:53,105 --> 04:07:55,505
我们创建了这个问题类。


7054
04:07:55,715 --> 04:07:58,356
我们可以储存所有的信息


7055
04:07:58,416 --> 04:08:02,497
关于一个我们可能需要的问题，奇怪的是提示和答案，


7056
04:08:02,947 --> 04:08:04,928
所以我们提出了自己的问题


7057
04:08:04,958 --> 04:08:05,678
数据类型


7058
04:08:05,708 --> 04:08:08,408
然后我们就可以提出一系列不同的问题，


7059
04:08:08,678 --> 04:08:10,717
把它传递给这个ron测试方法，


7060
04:08:10,837 --> 04:08:14,076
它能够对测试进行评分并进行测试


7061
04:08:14,106 --> 04:08:16,026
很简单，这就是重点。


7062
04:08:16,626 --> 04:08:17,916
希望这是有意义的。


7063
04:08:18,186 --> 04:08:19,686
你知道这有很多代码


7064
04:08:19,716 --> 04:08:23,885
所以如果你不完全理解我所做的事情，那就去看你知道的视频，


7065
04:08:23,944 --> 04:08:28,083
试着自己动手，看看你是否能创建自己的多项选择测试


7066
04:08:31,863 --> 04:08:33,934
在本教程中关于你们的讨论


7067
04:08:33,964 --> 04:08:35,674
类函数


7068
04:08:35,704 --> 04:08:36,274
在


7069
04:08:36,334 --> 04:08:37,264
python


7070
04:08:37,504 --> 04:08:40,864
类函数本质上是一个我们可以使用的函数


7071
04:08:40,895 --> 04:08:42,663
在一个类中，它可以


7072
04:08:42,693 --> 04:08:45,934
要么修改该类的对象


7073
04:08:46,203 --> 04:08:48,753
给出关于这些对象的特定信息。


7074
04:08:48,812 --> 04:08:52,082
这里我有一个学生点pi文件


7075
04:08:52,562 --> 04:08:52,982
并且


7076
04:08:53,042 --> 04:08:57,030
在这里，我创建了一个学生班，我是一名学生


7077
04:08:57,391 --> 04:08:58,380
我给了这个学生


7078
04:08:58,410 --> 04:09:00,839
我给它取了几个不同的属性，


7079
04:09:01,229 --> 04:09:03,208
一个主要的和一个gps


7080
04:09:03,238 --> 04:09:04,708
所以我可以给这个学生。


7081
04:09:04,768 --> 04:09:07,467
所有这些信息，当我创建一个学生对象时。


7082
04:09:07,856 --> 04:09:08,456
它会有


7083
04:09:08,516 --> 04:09:09,745
所有这些信息


7084
04:09:09,775 --> 04:09:10,135
在里面。


7085
04:09:10,585 --> 04:09:11,724
在这里


7086
04:09:11,754 --> 04:09:15,083
app点pi文件实际上是为学生创建的


7087
04:09:15,113 --> 04:09:15,684
所以


7088
04:09:15,983 --> 04:09:17,483
学生一


7089
04:09:17,753 --> 04:09:21,263
oscar，他在研究会计并拥有一个gps三点一


7090
04:09:21,652 --> 04:09:24,473
作为学习商业的菲菲的学生


7091
04:09:24,503 --> 04:09:25,822
她有三个点


7092
04:09:25,882 --> 04:09:26,212
e。


7093
04:09:27,532 --> 04:09:29,573
我们实际上可以做的是


7094
04:09:29,693 --> 04:09:35,094
在这些类文件中使用函数这样我就可以定义一个函数


7095
04:09:35,514 --> 04:09:38,604
而不是这个学生班，然后是我所有的


7096
04:09:38,635 --> 04:09:40,495
学生对象可以访问它。


7097
04:09:40,555 --> 04:09:41,515
举个例子，


7098
04:09:41,604 --> 04:09:44,124
我可以到这里来创建一个函数


7099
04:09:44,814 --> 04:09:46,613
假设我们想要创建一个函数


7100
04:09:46,644 --> 04:09:47,153
那


7101
04:09:47,184 --> 04:09:49,582
告诉我们这个学生是否


7102
04:09:49,642 --> 04:09:50,782
有荣誉


7103
04:09:50,812 --> 04:09:52,853
所以不管他们是否在荣誉名册上


7104
04:09:53,093 --> 04:09:53,872
基本上就像，


7105
04:09:54,022 --> 04:09:55,643
他们是否真的是一个好学生


7106
04:09:56,333 --> 04:09:57,893
所以我可以定义一个函数


7107
04:09:58,192 --> 04:09:58,763
呼叫


7108
04:09:58,883 --> 04:09:59,423
在


7109
04:10:00,113 --> 04:10:00,953
荣誉辊


7110
04:10:01,673 --> 04:10:02,243
并且


7111
04:10:02,273 --> 04:10:04,104
基本上它会做什么，


7112
04:10:04,254 --> 04:10:07,764
它会告诉我这个特定的学生是否

7113
04:10:07,823 --> 04:10:08,633
尊敬的


7114
04:10:09,652 --> 04:10:13,490
让我们简单地说，规则是关于荣誉的，你必须要有一个


7115
04:10:13,521 --> 04:10:14,330
gps iif


7116
04:10:14,360 --> 04:10:16,040
三点五或以上。


7117
04:10:16,340 --> 04:10:19,819
这里是gps三点五或以上这意味着你在荣誉榜上


7118
04:10:20,300 --> 04:10:20,689
井


7119
04:10:20,720 --> 04:10:22,550
在这里，我可以


7120
04:10:22,609 --> 04:10:24,198
为它写代码，这样我就可以说


7121
04:10:24,229 --> 04:10:24,709
如果


7122
04:10:25,609 --> 04:10:27,350
self。gps。


7123
04:10:27,830 --> 04:10:29,450
当我在这里说self的时候


7124
04:10:29,601 --> 04:10:31,041
这指的是


7125
04:10:31,101 --> 04:10:33,050
实际的学生gps


7126
04:10:33,500 --> 04:10:33,860
你会


7127
04:10:33,920 --> 04:10:36,229
注意这里，我要把它传递进来


7128
04:10:36,770 --> 04:10:37,729
作为一个参数。


7129
04:10:37,789 --> 04:10:40,490
这必须是第一个参数所以我可以说


7130
04:10:40,730 --> 04:10:42,262
自点j e p a


7131
04:10:42,622 --> 04:10:43,432
大于或等于


7132
04:10:43,462 --> 04:10:44,271
等于


7133
04:10:44,781 --> 04:10:46,011
读点五。


7134
04:10:46,701 --> 04:10:48,322
然后我们可以返回


7135
04:10:48,592 --> 04:10:49,191
真实的


7136
04:10:49,791 --> 04:10:50,812
因为这个学生


7137
04:10:50,842 --> 04:10:52,281
在荣誉榜上


7138
04:10:53,182 --> 04:10:54,292
否则


7139
04:10:54,382 --> 04:10:55,161
其他的


7140
04:10:55,371 --> 04:10:56,660
我们可以返回


7141
04:10:57,950 --> 04:10:59,271
因为


7142
04:10:59,330 --> 04:10:59,961
如果他们的gps


7143
04:10:59,991 --> 04:11:01,642
不超过三点五


7144
04:11:01,672 --> 04:11:02,542
他们没有在


7145
04:11:02,602 --> 04:11:03,441
荣誉榜。


7146
04:11:03,892 --> 04:11:04,372
所以


7147
04:11:04,402 --> 04:11:08,752
这就是我们的小功能，你可以看到它是一个非常小的函数，


7148
04:11:08,992 --> 04:11:10,013
但是它提供了


7149
04:11:10,043 --> 04:11:13,072
对该类对象的服务，对吗？


7150
04:11:13,103 --> 04:11:13,763
它允许


7151
04:11:13,793 --> 04:11:15,263
这个类的对象


7152
04:11:15,652 --> 04:11:19,133
弄清楚当前的学生是否

7153
04:11:19,853 --> 04:11:22,042
在这个应用点pi文件中。


7154
04:11:22,882 --> 04:11:24,142
我可以打印


7155
04:11:24,292 --> 04:11:25,701
我可以这样说


7156
04:11:25,731 --> 04:11:26,182
打印


7157
04:11:26,812 --> 04:11:28,102
我要看看


7158
04:11:28,672 --> 04:11:29,992
学生一


7159
04:11:30,562 --> 04:11:32,063
在荣誉榜上。


7160
04:11:33,983 --> 04:11:37,103
当我运行这个时你会看到它应该打印出错误


7161
04:11:37,312 --> 04:11:38,633
而且是假的


7162
04:11:38,663 --> 04:11:39,533
在下面


7163
04:11:39,713 --> 04:11:41,993
因为学生只有一个gps


7164
04:11:42,023 --> 04:11:42,354
在


7165
04:11:42,413 --> 04:11:43,584
三点一。


7166
04:11:43,944 --> 04:11:46,254
如果我要对学生做同样的事情


7167
04:11:46,884 --> 04:11:48,683
gdp为3分的学生


7168
04:11:48,713 --> 04:11:49,013
八


7169
04:11:49,043 --> 04:11:50,902
所以我们应该返回true。


7170
04:11:51,232 --> 04:11:53,332
这就是所发生的情况


7171
04:11:53,662 --> 04:11:54,742
本质上


7172
04:11:54,772 --> 04:12:01,763
类函数只是一个小的函数可以被类的对象使用我想说这是一个很好的例子


7173
04:12:02,183 --> 04:12:04,043
一个类函数应该做什么


7174
04:12:04,312 --> 04:12:09,979
应该是给我们关于类的信息，也可以是修改关于类的信息。


7175
04:12:10,038 --> 04:12:14,387
这就是使用函数和类的基础我的意思是这是一个非常简单的教程


7176
04:12:14,627 --> 04:12:17,476
我只是想给大家介绍一下这个概念


7177
04:12:18,165 --> 04:12:18,765
布丁


7178
04:12:18,795 --> 04:12:19,875
met函数


7179
04:12:19,935 --> 04:12:22,604
在类中这将会非常有用


7180
04:12:23,023 --> 04:12:27,523
如果你在做一个类你总是想要知道我可以在这里放什么函数


7181
04:12:27,793 --> 04:12:28,394
那将会


7182
04:12:29,624 --> 04:12:32,834
健康的用户可以找到关于对象的信息


7183
04:12:33,284 --> 04:12:33,914
或者


7184
04:12:33,974 --> 04:12:36,734
修改对象中的不同值


7185
04:12:40,544 --> 04:12:43,215
在这篇关于南极的关于遗传的课程中


7186
04:12:43,245 --> 04:12:43,515
在


7187
04:12:43,545 --> 04:12:44,175
python。


7188
04:12:44,685 --> 04:12:49,965
继承基本上就是我们可以定义一堆属性和函数的地方


7189
04:12:50,234 --> 04:12:51,854
以及课堂里的东西，


7190
04:12:52,095 --> 04:12:55,905
然后我们可以创建另一个类我们可以继承所有这些


7191
04:12:55,965 --> 04:12:56,715
属性。


7192
04:12:57,015 --> 04:12:58,215
所以我基本上可以


7193
04:12:58,245 --> 04:12:59,805
有一个类


7194
04:12:59,835 --> 04:13:01,996
另一个类的所有功能


7195
04:13:02,356 --> 04:13:05,296
不需要在物理上写出任何相同的东西


7196
04:13:05,326 --> 04:13:07,066
方法或

7197
04:13:07,336 --> 04:13:09,346
这很让人困惑，不用担心，我是


7198
04:13:09,405 --> 04:13:11,085
你们肯定知道这是什么


7199
04:13:11,385 --> 04:13:12,555
在这个视频中


7200
04:13:13,154 --> 04:13:15,493
让我给你们展示一下我在这里设置的一些地方。


7201
04:13:15,854 --> 04:13:17,654
我创建了这个类


7202
04:13:17,685 --> 04:13:18,404
呼叫


7203
04:13:18,555 --> 04:13:19,335
主厨


7204
04:13:19,815 --> 04:13:21,556
在这里，我们有这个类厨师。


7205
04:13:21,976 --> 04:13:25,034
在这个厨师课程中我们有三个函数


7206
04:13:25,064 --> 04:13:26,924
所以轴可以做三件事。


7207
04:13:27,313 --> 04:13:28,093
厨师可以


7208
04:13:28,123 --> 04:13:28,423
制造


7209
04:13:28,453 --> 04:13:29,023
鸡肉。


7210
04:13:30,614 --> 04:13:31,574
使成固体


7211
04:13:31,844 --> 04:13:32,983
厨师可以做


7212
04:13:33,014 --> 04:13:34,063
一道特别的菜。


7213
04:13:34,363 --> 04:13:36,224
不管厨师做什么菜


7214
04:13:36,254 --> 04:13:37,604
他基本上只是说


7215
04:13:37,874 --> 04:13:40,424
厨师做了一个小妞


7216
04:13:40,454 --> 04:13:41,264
一份沙拉


7217
04:13:41,684 --> 04:13:44,714
或者厨师为这个特别的菜做烧烤架。


7218
04:13:44,983 --> 04:13:46,273
所以基本上


7219
04:13:46,333 --> 04:13:48,643
不管厨师在做什么


7220
04:13:48,883 --> 04:13:51,462
如果我要到我的app点python文件，


7221
04:13:51,731 --> 04:13:53,622
你会注意到我正在导入


7222
04:13:53,742 --> 04:13:54,252
主厨


7223
04:13:54,282 --> 04:13:55,512
所以我基本上


7224
04:13:55,872 --> 04:13:57,823
现在允许使用这个厨师课程，


7225
04:13:58,333 --> 04:13:59,412
我可以说


7226
04:13:59,442 --> 04:14:02,352
我的厨师等于我正在创造一个新的厨师。


7227
04:14:02,682 --> 04:14:05,412
所以现在如果我来到这里，我把我的


7228
04:14:06,192 --> 04:14:06,853
点


7229
04:14:07,122 --> 04:14:07,422
制造


7230
04:14:07,452 --> 04:14:07,962
鸡，


7231
04:14:09,672 --> 04:14:11,171
当我运行程序时。


7232
04:14:11,230 --> 04:14:12,430
现在它会说，


7233
04:14:13,420 --> 04:14:14,709
厨师做了一只鸡。


7234
04:14:14,979 --> 04:14:15,788
如果我说


7235
04:14:18,129 --> 04:14:19,479
特别菜


7236
04:14:20,078 --> 04:14:21,157
在这个项目上。


7237
04:14:21,337 --> 04:14:25,116
现在它会说厨师做烧烤排骨因为这是厨师的


7238
04:14:25,146 --> 04:14:26,076
特别的菜。


7239
04:14:26,316 --> 04:14:29,285
我有一个很棒的厨师课，它很好用。


7240
04:14:29,915 --> 04:14:32,826
但是假设我想创建另一个类


7241
04:14:32,856 --> 04:14:35,257
为另一种类型的厨师建模


7242
04:14:35,646 --> 04:14:36,275
上升到这个


7243
04:14:36,335 --> 04:14:39,455
厨师类只是像一些普通的schafroff一样的建模


7244
04:14:39,485 --> 04:14:41,196
我们代表一些普通的厨师


7245
04:14:41,526 --> 04:14:42,307
在我们的项目中，


7246
04:14:42,787 --> 04:14:44,617
但是假设我想要创建


7247
04:14:44,647 --> 04:14:45,277
a


7248
04:14:45,457 --> 04:14:47,828
对不同类型的厨师进行建模


7249
04:14:47,858 --> 04:14:48,579
例如，


7250
04:14:48,879 --> 04:14:51,908
比如说，我们想要创建一个模仿中国厨师的课程。


7251
04:14:51,968 --> 04:14:53,978
所以，不只是普通的厨师这是

7252
04:14:54,008 --> 04:14:54,998
中国厨师，


7253
04:14:55,479 --> 04:14:57,908
我在这里创建了一个文件


7254
04:14:57,938 --> 04:14:59,648
中国厨师dot python。


7255
04:14:59,948 --> 04:15:02,138
所以我们可以用这个


7256
04:15:02,228 --> 04:15:05,288
中国用python文件来创建我们的中文


7257
04:15:05,318 --> 04:15:05,828
主厨


7258
04:15:05,858 --> 04:15:06,458
阶级


7259
04:15:06,758 --> 04:15:08,168
汤姆要去上课了。


7260
04:15:08,228 --> 04:15:10,058
在这里，我只想说


7261
04:15:10,117 --> 04:15:11,228
中国厨师


7262
04:15:11,678 --> 04:15:12,248
并且


7263
04:15:12,908 --> 04:15:13,898
基本上


7264
04:15:14,019 --> 04:15:16,929
我可以定义中国厨师所能做的一切，


7265
04:15:17,349 --> 04:15:18,519
但是我们说


7266
04:15:18,549 --> 04:15:20,019
我们的

7267
04:15:20,288 --> 04:15:21,068
能做


7268
04:15:21,099 --> 04:15:23,768
所有的普通厨师都能做到。


7269
04:15:23,947 --> 04:15:25,956
所以中国厨师就像一个特别的人


7270
04:15:25,986 --> 04:15:28,296
schafroff是一种非常特殊的厨师。


7271
04:15:28,746 --> 04:15:30,636
但是，假设这位

7272
04:15:30,666 --> 04:15:34,687
可以做普通厨师能做的一切这样中国厨师就能做鸡


7273
04:15:34,866 --> 04:15:35,856
可以做沙拉，


7274
04:15:36,066 --> 04:15:37,267
也可以做


7275
04:15:37,297 --> 04:15:38,406
一道特别的菜。


7276
04:15:38,496 --> 04:15:39,967
如果我想给出这个


7277
04:15:39,997 --> 04:15:40,927
中国厨师，


7278
04:15:40,986 --> 04:15:42,546
所有这些功能。


7279
04:15:42,786 --> 04:15:46,444
我可以到这里来复制所有这些


7280
04:15:46,475 --> 04:15:47,165
函数。


7281
04:15:47,555 --> 04:15:49,685
我可以把它们粘贴到这里


7282
04:15:50,045 --> 04:15:52,564
所以现在中国厨师可以做任何事


7283
04:15:52,595 --> 04:15:54,065
其他厨师可以做的，


7284
04:15:54,155 --> 04:15:57,454
但是我们说除了所有这些东西中国厨师


7285
04:15:57,784 --> 04:15:59,164
也可以


7286
04:15:59,224 --> 04:16:01,264
一种叫做炒饭的特别菜


7287
04:16:01,294 --> 04:16:02,164
所以我可以说


7288
04:16:02,314 --> 04:16:02,795
聋的


7289
04:16:03,125 --> 04:16:04,325
我们可以说


7290
04:16:04,835 --> 04:16:06,154
炒饭。


7291
04:16:06,244 --> 04:16:06,874
所以


7292
04:16:07,144 --> 04:16:09,243
中国厨师有这个额外的


7293
04:16:09,273 --> 04:16:11,403
使它能做炒饭的功能。


7294
04:16:11,703 --> 04:16:13,323
在这里，我们说，


7295
04:16:13,413 --> 04:16:14,764
厨师做的


7296
04:16:16,173 --> 04:16:17,313
我们也说


7297
04:16:17,344 --> 04:16:21,783
中国厨师有一种不同的特殊菜肴，而不是做烧烤排骨。


7298
04:16:22,083 --> 04:16:23,463
中国

7299
04:16:23,522 --> 04:16:24,152
突进


7300
04:16:24,183 --> 04:16:24,663
鸡肉。


7301
04:16:25,863 --> 04:16:28,562
好了，现在我们有了中国的厨师课程


7302
04:16:28,593 --> 04:16:30,872
你会注意到它可以做任何事情


7303
04:16:30,902 --> 04:16:31,353
那


7304
04:16:31,383 --> 04:16:32,854
普通的厨师可以做到。


7305
04:16:33,334 --> 04:16:36,784
让我们回到app点python文件，我想创建


7306
04:16:36,814 --> 04:16:37,265
a


7307
04:16:37,295 --> 04:16:38,045
中国厨师


7308
04:16:38,075 --> 04:16:38,646
对象。


7309
04:16:39,815 --> 04:16:41,766
而不是从厨师那里进口


7310
04:16:41,796 --> 04:16:44,104
我们要从中国厨师那里进口。


7311
04:16:44,585 --> 04:16:45,425
所以我会说


7312
04:16:46,954 --> 04:16:48,094
我们将会雇佣


7313
04:16:48,514 --> 04:16:49,354
中国厨师。


7314
04:16:49,773 --> 04:16:51,032
让我们继续


7315
04:16:52,262 --> 04:16:52,861
对象


7316
04:16:53,731 --> 04:16:56,010
坐下来，我要做一个箭头来说明


7317
04:16:56,069 --> 04:16:56,850
我的。


7318
04:16:57,029 --> 04:16:57,959
然后


7319
04:16:59,099 --> 04:17:00,180
我的

7320
04:17:00,510 --> 04:17:02,699
我们可以把这个特别的菜打印出来


7321
04:17:03,029 --> 04:17:04,529
记住，中国厨师可以做到


7322
04:17:04,560 --> 04:17:06,390
普通厨师所能做的一切


7323
04:17:06,689 --> 04:17:08,850
所以如果我说我的中国厨师达


7324
04:17:08,880 --> 04:17:10,049
做一道特别的菜。


7325
04:17:10,289 --> 04:17:12,179
当我运行这个程序时，你会看到


7326
04:17:12,749 --> 04:17:13,439
那


7327
04:17:13,770 --> 04:17:17,880
普通厨师正在做烧烤排骨而中国厨师正在做橙色的


7328
04:17:17,910 --> 04:17:18,450
胆小鬼


7329
04:17:18,510 --> 04:17:19,619
所以一切都很顺利。


7330
04:17:19,739 --> 04:17:23,189
这位中国厨师还有一个额外的方法叫做make


7331
04:17:24,239 --> 04:17:25,410
炒饭。


7332
04:17:25,891 --> 04:17:26,490
并且


7333
04:17:26,550 --> 04:17:27,390
你也可以


7334
04:17:27,420 --> 04:17:27,810
制造


7335
04:17:28,800 --> 04:17:31,079
但这里有个问题当我到这里的时候


7336
04:17:31,109 --> 04:17:32,850
中国厨师点派。


7337
04:17:33,600 --> 04:17:37,200
我想要使用里面所有的功能


7338
04:17:37,230 --> 04:17:38,250
上节课


7339
04:17:38,580 --> 04:17:42,061
实际上我需要复制和粘贴。


7340
04:17:42,541 --> 04:17:44,281
所有这些函数


7341
04:17:44,312 --> 04:17:45,601
在这个文件中


7342
04:17:45,780 --> 04:17:46,949
这是一种拖累。


7343
04:17:47,219 --> 04:17:49,919
他们特别喜欢想象如果这个厨师喜欢


7344
04:17:49,979 --> 04:17:52,350
其中有20或30个不同的函数。


7345
04:17:52,649 --> 04:17:54,719
我们必须复制，我有节奏。


7346
04:17:54,778 --> 04:17:57,057
所有这些都是中国厨师的


7347
04:17:57,087 --> 04:17:59,786
这就是我们可以使用继承的地方


7348
04:17:59,816 --> 04:18:01,556
所以不需要复制粘贴


7349
04:18:01,586 --> 04:18:03,087
所有这些函数。


7350
04:18:03,327 --> 04:18:05,607
我可以继承这些函数


7351
04:18:05,638 --> 04:18:06,237
从那以后


7352
04:18:06,268 --> 04:18:07,197
厨师班


7353
04:18:07,587 --> 04:18:08,816
为了达到这个目的，


7354
04:18:08,906 --> 04:18:10,766
我可以把这些都去掉，


7355
04:18:11,065 --> 04:18:12,626
我可以到这里来


7356
04:18:12,866 --> 04:18:13,496
并且


7357
04:18:13,916 --> 04:18:16,496
就在我说的中国厨师的旁边


7358
04:18:16,796 --> 04:18:22,254
在括号里，我可以写上我想要继承的类的名字，所以我可以说是一个厨师。


7359
04:18:22,974 --> 04:18:27,054
我还需要导入这首歌到这里来，我们会说


7360
04:18:27,983 --> 04:18:28,674
从


7361
04:18:28,974 --> 04:18:29,693
主厨


7362
04:18:30,563 --> 04:18:31,374
穷困潦倒的


7363
04:18:31,494 --> 04:18:32,124
架子。


7364
04:18:32,754 --> 04:18:34,675
所以基本上这是说


7365
04:18:34,705 --> 04:18:36,686
在这个中国厨师的内部。


7366
04:18:37,136 --> 04:18:40,615
我想要能够使用所有包含的函数


7367
04:18:40,675 --> 04:18:42,415
在厨师课上


7368
04:18:42,685 --> 04:18:43,825
再说一遍


7369
04:18:44,275 --> 04:18:46,376
在这个中国大厨的课堂里


7370
04:18:46,406 --> 04:18:49,557
我想要能够使用所有的函数


7371
04:18:50,937 --> 04:18:51,536
所以


7372
04:18:51,596 --> 04:18:53,576
在这里使用继承


7373
04:18:53,727 --> 04:18:57,118
我可以到这里来看看这个关于pi文件的故事。


7374
04:18:57,178 --> 04:18:57,838
现在


7375
04:18:58,138 --> 04:19:00,508
我仍然可以执行例如


7376
04:19:00,567 --> 04:19:01,107
制作


7377
04:19:01,138 --> 04:19:01,768
胆小鬼


7378
04:19:01,827 --> 04:19:02,457
函数。


7379
04:19:03,057 --> 04:19:07,737
虽然我没有在这里指定做鸡的功能，但我没有把它写出来。


7380
04:19:08,397 --> 04:19:10,827
我仍然可以运行这个程序


7381
04:19:10,887 --> 04:19:12,057
还有中国的东西。


7382
04:19:12,116 --> 04:19:14,636
中国厨师还能做的


7383
04:19:14,666 --> 04:19:15,206
鸡肉。


7384
04:19:15,626 --> 04:19:17,215
当我运行这个程序时


7385
04:19:17,455 --> 04:19:18,895
你会在这里看到它说


7386
04:19:18,925 --> 04:19:20,215
厨师做鸡


7387
04:19:20,635 --> 04:19:24,085
这是因为我继承了制作鸡的方法


7388
04:19:24,115 --> 04:19:24,655
从


7389
04:19:24,686 --> 04:19:25,586
厨师班


7390
04:19:26,156 --> 04:19:27,896
但有一件事


7391
04:19:27,927 --> 04:19:28,377
那


7392
04:19:28,407 --> 04:19:29,247
得到我的东西


7393
04:19:29,307 --> 04:19:31,107
如果我来到这里，我说


7394
04:19:31,138 --> 04:19:32,428
特别的菜。


7395
04:19:32,788 --> 04:19:34,169
记住中国厨师


7396
04:19:34,319 --> 04:19:36,659
特别的菜应该是橙色的

7397
04:19:37,079 --> 04:19:37,739
但是现在


7398
04:19:37,770 --> 04:19:40,620
中国厨师将会做烧烤排骨


7399
04:19:40,650 --> 04:19:41,460
因为


7400
04:19:41,790 --> 04:19:42,990
我继承了


7401
04:19:43,200 --> 04:19:44,850
这是一道特殊的菜


7402
04:19:44,909 --> 04:19:45,600
功能


7403
04:19:45,840 --> 04:19:46,500
从这个


7404
04:19:47,641 --> 04:19:50,400
我能做的就是，我可以来这里，我可以


7405
04:19:50,490 --> 04:19:51,660
推翻


7406
04:19:52,770 --> 04:19:53,880
做特别的抹布


7407
04:19:53,910 --> 04:19:54,510
所以我可以说


7408
04:19:54,540 --> 04:19:55,050
死亡


7409
04:19:55,290 --> 04:19:55,950
制造


7410
04:19:58,410 --> 04:19:59,340
下面这里


7411
04:19:59,460 --> 04:19:59,851
我可以


7412
04:19:59,881 --> 04:20:01,472
推翻它，我可以说，


7413
04:20:02,071 --> 04:20:02,762
主厨


7414
04:20:04,472 --> 04:20:05,012
橙色的


7415
04:20:05,042 --> 04:20:05,522
胆小鬼


7416
04:20:06,362 --> 04:20:07,442
现在


7417
04:20:07,473 --> 04:20:09,542
当我在这里运行时


7418
04:20:09,572 --> 04:20:10,172
这个


7419
04:20:10,202 --> 04:20:11,282
做特别的菜


7420
04:20:11,312 --> 04:20:11,883
函数。


7421
04:20:12,423 --> 04:20:13,863
现在厨师们将会


7422
04:20:13,894 --> 04:20:16,982
回到制作橙鸡的过程中，中国厨师会做他的


7423
04:20:17,013 --> 04:20:18,003
特别的菜。


7424
04:20:18,272 --> 04:20:18,962
这就是


7425
04:20:19,172 --> 04:20:21,992
基本上，继承是什么让我继承了遗产


7426
04:20:22,322 --> 04:20:26,013
从现有的类到新类的功能。


7427
04:20:26,522 --> 04:20:27,062
并且


7428
04:20:27,452 --> 04:20:32,404
我可以把所有的东西都继承而不用写出来所以我不需要写出来


7429
04:20:32,494 --> 04:20:32,854
制造


7430
04:20:32,885 --> 04:20:35,675
鸡在中国的课堂里，


7431
04:20:36,035 --> 04:20:36,516
但是


7432
04:20:36,785 --> 04:20:37,775
中国厨师


7433
04:20:37,806 --> 04:20:38,916
仍然可以


7434
04:20:38,946 --> 04:20:42,576
鸡肉和沙拉因为它继承了厨师类的功能


7435
04:20:46,296 --> 04:20:48,696
在本教程中，我想和你们谈谈


7436
04:20:48,727 --> 04:20:50,376
python解释器。


7437
04:20:50,676 --> 04:20:56,977
python解释器基本上是一个我们可以用来执行python的小环境


7438
04:20:57,007 --> 04:20:57,727
命令。


7439
04:20:58,057 --> 04:21:03,098
这有点像这个小沙盒环境我们可以测试并尝试不同的方法


7440
04:21:03,157 --> 04:21:05,828
python命令是不同的python函数


7441
04:21:06,278 --> 04:21:08,768
在一个非常安全、中立的环境中。


7442
04:21:08,888 --> 04:21:13,418
这就像是一种快速而又脏的方法来编写python并尝试不同的东西。


7443
04:21:13,718 --> 04:21:16,477
我们使用python解释器的方式是开放


7444
04:21:16,507 --> 04:21:18,547
打开我们的命令提示符。


7445
04:21:18,937 --> 04:21:22,536
如果你在windows上有一个程序叫做命令提示符


7446
04:21:22,566 --> 04:21:24,576
如果你在mac上有一个程序叫做


7447
04:21:24,636 --> 04:21:25,266
终端。


7448
04:21:25,596 --> 04:21:27,246
基本上你需要打开


7449
04:21:27,276 --> 04:21:30,365
这个程序是为了使用python解释器，


7450
04:21:30,726 --> 04:21:31,956
我在mac上


7451
04:21:31,986 --> 04:21:33,518
但是如果你在窗户上


7452
04:21:33,577 --> 04:21:35,497
本质上就是我所做的


7453
04:21:35,527 --> 04:21:37,237
在命令提示符的内部。


7454
04:21:37,598 --> 04:21:40,058
在mac上，我要搜索


7455
04:21:40,237 --> 04:21:41,138
我的终点站。


7456
04:21:41,527 --> 04:21:46,326
如果你在windows上，你可以搜索像cmd或者命令提示符，它会弹出，


7457
04:21:46,807 --> 04:21:48,457
所以终端是


7458
04:21:49,147 --> 04:21:51,037
基本上是一个环境


7459
04:21:51,097 --> 04:21:52,626
在我们的电脑上


7460
04:21:52,656 --> 04:21:55,086
与电脑互动，做不同的事情


7461
04:21:55,355 --> 04:21:59,978
在没有图形用户界面的情况下当我们与计算机交互时


7462
04:22:00,338 --> 04:22:05,857
我们使用的是按钮或者是windows你知道我们可以移动什么东西我们可以


7463
04:22:05,888 --> 04:22:07,269
基本上就像


7464
04:22:07,448 --> 04:22:08,889
与计算机交互。


7465
04:22:09,219 --> 04:22:10,269
用图形处理


7466
04:22:10,479 --> 04:22:12,548
使用终端或命令提示符


7467
04:22:12,607 --> 04:22:16,087
是一个你可以使用文本命令与计算机交互的地方。


7468
04:22:16,387 --> 04:22:18,007
所以你知道我要做的事情太多了


7469
04:22:18,037 --> 04:22:21,396
命令提示符的终端是什么，但这就是它的本质。


7470
04:22:21,816 --> 04:22:23,227
所以在这里，


7471
04:22:23,977 --> 04:22:26,228
我们可以使用python解释器


7472
04:22:26,588 --> 04:22:30,009
而python解释器基本上就是一个小程序


7473
04:22:30,039 --> 04:22:31,508
就像我说的，我们可以写


7474
04:22:31,538 --> 04:22:32,858
你知道，有点像python


7475
04:22:32,889 --> 04:22:33,158
在


7476
04:22:33,188 --> 04:22:34,059
所以一般来说，


7477
04:22:34,299 --> 04:22:37,029
你所要做的就是转到终端或命令提示符


7478
04:22:37,299 --> 04:22:38,380
输入


7479
04:22:38,710 --> 04:22:39,520
蟒蛇


7480
04:22:39,550 --> 04:22:40,330
三


7481
04:22:40,570 --> 04:22:43,630
因为我们在单类型python 3上使用了python3。


7482
04:22:44,350 --> 04:22:48,519
但是你也可以像普通的python一样我很确定这给了你两个python。


7483
04:22:49,089 --> 04:22:50,739
这里有一个简短的免责声明。


7484
04:22:50,799 --> 04:22:51,309
我是


7485
04:22:51,549 --> 04:22:52,659
在windows上，


7486
04:22:53,020 --> 04:22:55,028
你可能会遇到一个问题


7487
04:22:55,059 --> 04:22:55,539
在哪里


7488
04:22:55,569 --> 04:22:58,059
你不能使用这个python3命令，


7489
04:22:58,299 --> 04:22:59,919
这是有可能的


7490
04:22:59,949 --> 04:23:01,271
如果你遇到了这个问题


7491
04:23:02,921 --> 04:23:06,280
python 3没有被添加到您的窗口中


7492
04:23:06,370 --> 04:23:07,510
路径变量。


7493
04:23:08,080 --> 04:23:11,919
这就意味着你的电脑无法识别命令


7494
04:23:11,949 --> 04:23:12,970
python 3


7495
04:23:13,239 --> 04:23:14,050
就是这样


7496
04:23:14,080 --> 04:23:16,239
你所要做的就是去谷歌


7497
04:23:16,270 --> 04:23:19,269
如何将python 3添加到您的windows path变量中。


7498
04:23:19,419 --> 04:23:22,390
这很简单，我不打算在这个视频中讲因为它有点像


7499
04:23:22,420 --> 04:23:23,350
超出范围


7500
04:23:23,380 --> 04:23:23,710
但是


7501
04:23:24,040 --> 04:23:25,271
如果你遇到了这个问题。


7502
04:23:25,330 --> 04:23:27,880
这可能不是在你的窗户上


7503
04:23:27,910 --> 04:23:31,271
像google这样的路径变量，你应该能够找到答案，


7504
04:23:31,721 --> 04:23:34,211
但是现场的python3，然后点击回车


7505
04:23:34,241 --> 04:23:37,150
它会在下面打开这个很酷的东西


7506
04:23:37,721 --> 04:23:40,900
你可以看到它基本上是说，这是python的版本。


7507
04:23:41,290 --> 04:23:41,740
现在


7508
04:23:41,830 --> 04:23:41,980
我是


7509
04:23:42,011 --> 04:23:44,169
我们可以有一些像这样的


7510
04:23:44,229 --> 04:23:45,399
新线


7511
04:23:45,789 --> 04:23:46,270
并且


7512
04:23:47,079 --> 04:23:50,077
放在这里，这是python解释器，所以我们可以写


7513
04:23:50,497 --> 04:23:53,107
这里的python代码，它会起作用，所以我可以


7514
04:23:53,287 --> 04:23:54,547
例如，我可以这样写


7515
04:23:54,697 --> 04:23:55,207
打印


7516
04:23:55,627 --> 04:23:57,186
在这里，我可以像这样

7517
04:23:57,365 --> 04:23:58,445
你好，世界。


7518
04:23:59,915 --> 04:24:00,725
当我点击回车时


7519
04:24:00,755 --> 04:24:01,836
你会看到它打印出来了


7520
04:24:02,826 --> 04:24:06,186
我可以创建一个变量例如，我可以说第一个变量


7521
04:24:06,455 --> 04:24:07,596
等于10。


7522
04:24:07,865 --> 04:24:10,475
我可以说，麻木2等于90。


7523
04:24:10,774 --> 04:24:11,645
然后我可以

7524
04:24:11,675 --> 04:24:13,115
第一个


7525
04:24:13,146 --> 04:24:13,806
加上


7526
04:24:13,865 --> 04:24:14,735
也没有


7527
04:24:15,245 --> 04:24:16,864
它能帮我做到这一点吗？


7528
04:24:17,044 --> 04:24:21,093
我也可以用很棒的函数，这样我就可以在这里定义一个函数，


7529
04:24:21,513 --> 04:24:26,431
我们可以做一个叫做hi的函数它会取一个名字参数。


7530
04:24:27,751 --> 04:24:28,351
并且


7531
04:24:28,410 --> 04:24:31,381
你会看到，当它看到我想要创建一个函数时


7532
04:24:31,411 --> 04:24:33,301
把这三个小点


7533
04:24:33,331 --> 04:24:37,290
我可以索引，我们可以为一个函数写代码我可以这样说


7534
04:24:37,320 --> 04:24:37,860
打印


7535
04:24:39,181 --> 04:24:40,051
你好


7536
04:24:42,150 --> 04:24:43,410
姓。


7537
04:24:45,090 --> 04:24:47,250
现在我有一个函数叫


7538
04:24:47,280 --> 04:24:50,521
打个招呼，这样我就可以通过这个进入了


7539
04:24:50,820 --> 04:24:52,770
我把这个函数命名为


7540
04:24:52,920 --> 04:24:53,550
说


7541
04:24:55,230 --> 04:24:56,280
我们会说出来的。


7542
04:24:57,420 --> 04:24:58,079
我就像


7543
04:24:58,109 --> 04:24:59,189
现在它会

7544
04:24:59,220 --> 04:24:59,909
你好，迈克


7545
04:25:00,149 --> 04:25:02,159
所以我可以使用一个函数，我可以用像a这样的函数


7546
04:25:02,189 --> 04:25:02,880
if语句


7547
04:25:02,910 --> 04:25:03,420
你知道


7548
04:25:03,720 --> 04:25:04,500
我可以说，


7549
04:25:05,460 --> 04:25:07,920
我可以很容易地负担得起邪恶的使用。


7550
04:25:08,340 --> 04:25:12,929
我的意思是我们基本上可以使用所有的基本的python命令


7551
04:25:12,959 --> 04:25:15,689
在这个python解释器的内部，就像我之前说过的。


7552
04:25:16,050 --> 04:25:18,300
它本质上是一个可以测试的环境


7553
04:25:18,330 --> 04:25:18,780
外出


7554
04:25:18,960 --> 04:25:19,800
python代码。


7555
04:25:20,100 --> 04:25:22,561
这不是你想要写的地方


7556
04:25:22,650 --> 04:25:24,601
像任何严重的蟒蛇一样


7557
04:25:24,690 --> 04:25:25,471
脚本


7558
04:25:25,501 --> 04:25:28,229
所以如果你想设计和编写一个python程序


7559
04:25:28,260 --> 04:25:29,550
我不推荐


7560
04:25:29,580 --> 04:25:31,230
在这个解释器里做吗？


7561
04:25:31,410 --> 04:25:31,830
它是，


7562
04:25:32,040 --> 04:25:37,079
这不是一个非常直观的环境它只是为一些快速而又脏的测试设置的


7563
04:25:37,259 --> 04:25:40,287
我们需要测试一些东西，这是一个完美的地方。


7564
04:25:40,587 --> 04:25:42,086
你需要设置一个文件


7565
04:25:42,416 --> 04:25:43,526
你必须要用一些


7566
04:25:43,557 --> 04:25:47,607
如果你不需要执行文件，你就会发现它很简单，很脏，


7567
04:25:47,667 --> 04:25:48,356
你完成了。


7568
04:25:48,776 --> 04:25:50,816
但是如果你在写一个实际的程序。


7569
04:25:50,876 --> 04:25:53,485
你绝对肯定想要使用


7570
04:25:53,516 --> 04:25:53,815
a


7571
04:25:53,846 --> 04:25:54,746
文本编辑器。


7572
04:25:55,256 --> 04:26:03,655
文本编辑器会变得更有条理所有的东西都会变得更干净你不会对东西和你所拥有的东西感到困惑


7573
04:26:04,136 --> 04:26:06,176
这是python解释器的基本知识，


7574
04:26:06,266 --> 04:26:07,796
你们知道，在我的课程中


7575
04:26:07,855 --> 04:26:09,655
还没有真正使用过它，


7576
04:26:09,896 --> 04:26:13,375
只是因为我觉得当我们在文件里面的时候，教书会更容易，


7577
04:26:13,525 --> 04:26:15,055
然后在这里


7578
04:26:15,085 --> 04:26:15,445
你知道


7579
04:26:15,476 --> 04:26:16,734
别把这家伙算出来


7580
04:26:16,765 --> 04:26:21,085
python解释器很棒很多人都使用它如果你只需要一个任务就太好了


7581
04:26:21,115 --> 04:26:23,846
你不需要设置一些代码就可以知道


7582
04:26:23,876 --> 04:26:25,346
巨大的环境


7583
04:26:25,796 --> 04:26:26,605
python解释器


7584
04:26:26,636 --> 04:26:29,547
这绝对是很棒的球员你知道有一些乐趣


7585
04:26:29,727 --> 04:26:30,837
好好利用它。


7586
04:26:31,407 --> 04:26:34,436
嘿，如果你喜欢这段视频，就会洗衣服，请留下同样的答案


7587
04:26:34,466 --> 04:26:37,377
垃圾学院成为第一场雪并发布新内容


7588
04:26:37,947 --> 04:26:40,768
同样的，如果你有任何东西


7589
04:26:40,798 --> 04:26:43,828
建设性的批评或问题或任何事情会在下面留下一个共同之处


7590
04:26:44,128 --> 04:26:46,887
最后，如果你在享受工作学院你想帮助我们成长


7591
04:26:47,037 --> 04:26:51,114
回头去起草学院网络福特酱汁，为我们的未来做贡献和投资。