1
00:00:05,844 --> 00:00:08,279
[音乐播放]

2
00:00:10,230 --> 00:00:12,570
您好，欢迎来到 INE。

3
00:00:12,570 --> 00:00:15,540
今天在这个视频中，我们
将看看 Argparse。

4
00:00:15,540 --> 00:00:18,270
现在，Argparse
又是另一种方式

5
00:00:18,270 --> 00:00:21,190
从用户那里获取输入。

6
00:00:21,190 --> 00:00:22,620
但是，最大的
区别是

7
00:00:22,620 --> 00:00:27,270
您可以将
参数传递给脚本。

8
00:00:27,270 --> 00:00:29,280
所以在你真正
执行脚本之前，

9
00:00:29,280 --> 00:00:31,360
你基本上是在
给出一些论据。

10
00:00:31,360 --> 00:00:33,840
现在，我们对 sys arg 做了完全相同的事情。

11
00:00:33,840 --> 00:00:36,150
但唯一的区别
是你真的有

12
00:00:36,150 --> 00:00:38,550
知道论据是什么。

13
00:00:38,550 --> 00:00:40,180
让我给你举个例子。

14
00:00:40,180 --> 00:00:42,420
所以在我真正
向你展示 Argparse 之前，

15
00:00:42,420 --> 00:00:44,910
我将给你一个
问题的简要回顾

16
00:00:44,910 --> 00:00:47,310
我们在 sys arg.

17
00:00:47,310 --> 00:00:52,230
所以假设我
这里有一个脚本。

18
00:00:52,230 --> 00:00:53,280
让我们去做吧。

19
00:00:53,280 --> 00:00:56,490
我想我有一个使用 sys arg 的脚本
，

20
00:00:56,490 --> 00:01:00,420
这是 input_function.py。

21
00:01:00,420 --> 00:01:06,270
所以如果我真的
执行脚本，

22
00:01:06,270 --> 00:01:10,380
python3 输入函数.py。

23
00:01:10,380 --> 00:01:11,920
我执行脚本。

24
00:01:11,920 --> 00:01:13,380
它会问
我这个问题。

25
00:01:13,380 --> 00:01:16,800
并在路由器上显示您要显示的命令
。

26
00:01:16,800 --> 00:01:19,050
我说，显示IP路由。

27
00:01:24,390 --> 00:01:29,850
我相信它会问我
防火墙的问题——

28
00:01:29,850 --> 00:01:33,180
显示您希望
为防火墙显示的命令。

29
00:01:33,180 --> 00:01:37,290
我说，show interface ip brief。

30
00:01:37,290 --> 00:01:39,390
然后它应该向我询问用户名。

31
00:01:39,390 --> 00:01:42,930
比方说，cisco，
密码cisco。

32
00:01:42,930 --> 00:01:45,970
所以这基本上是
使用输入功能。

33
00:01:45,970 --> 00:01:48,240
所以这并不是真的
使用 sys arg。

34
00:01:48,240 --> 00:01:51,540
我是用输入
函数给你的

35
00:01:51,540 --> 00:01:53,160
所有信息--
脚本

36
00:01:53,160 --> 00:01:55,930
使用我提供的所有信息
运行。

37
00:01:55,930 --> 00:01:57,270
所以它执行那个。

38
00:01:57,270 --> 00:01:58,800
这是输入功能。

39
00:01:58,800 --> 00:02:02,850
问题是它有
来执行那个脚本。

40
00:02:02,850 --> 00:02:05,740
并且说，如果有问题，
它会给你一个错误。

41
00:02:05,740 --> 00:02:10,020
但是如果我愿意，我可以
直接给出论据

42
00:02:10,020 --> 00:02:11,140
与系统参数。

43
00:02:11,140 --> 00:02:15,120
所以 sys arg 是在给出
输入命令的同时给出的一种方式

44
00:02:15,120 --> 00:02:17,740
python3 命令。

45
00:02:17,740 --> 00:02:19,860
所以在你真正
执行脚本之前，

46
00:02:19,860 --> 00:02:23,100
您正在给出参数，
以便您可以执行它

47
00:02:23,100 --> 00:02:25,890
没有你在
输入用户名

48
00:02:25,890 --> 00:02:27,160
和密码。

49
00:02:27,160 --> 00:02:34,620
因此，如果我查看 cat
input_function.py，

50
00:02:34,620 --> 00:02:39,910
你会看到我
要求输入。

51
00:02:39,910 --> 00:02:44,280
现在，如果您还记得，我们用 sys arg 做了一个类似的实验。

52
00:02:44,280 --> 00:02:46,450
我相信那是实验室 11。

53
00:02:46,450 --> 00:02:50,100
让我们检查一下 cat Lab11.py。

54
00:02:50,100 --> 00:02:52,973
这是在之前的一个
视频中，当我们这样做时，

55
00:02:52,973 --> 00:02:54,390
我相信，
实验室——或者我认为

56
00:02:54,390 --> 00:02:56,830
在上一个视频中是rohit2。

57
00:02:56,830 --> 00:02:59,580
所以猫 rohit2.py。

58
00:02:59,580 --> 00:03:04,170
这就是我们
为我使用 sys arg 的地方

59
00:03:04,170 --> 00:03:05,310
向你展示。

60
00:03:05,310 --> 00:03:10,970
如果你看到这里，我
我有系统

61
00:03:10,970 --> 00:03:12,810
arg，你可以在这里看到。

62
00:03:12,810 --> 00:03:15,380
所以我已经注释了
输入函数。

63
00:03:15,380 --> 00:03:17,670
我正在使用 sys arg。

64
00:03:17,670 --> 00:03:19,980
但是这里有什么问题？

65
00:03:19,980 --> 00:03:29,570
问题是当我给
python3和给rohit2.py时，

66
00:03:29,570 --> 00:03:32,690
我需要知道要给出哪些
论据。

67
00:03:32,690 --> 00:03:33,770
所以我需要知道这一点。

68
00:03:33,770 --> 00:03:36,710
如果我真的做减
h并寻求帮助，

69
00:03:36,710 --> 00:03:39,260
我真的没有
这方面的任何帮助。

70
00:03:39,260 --> 00:03:42,410
所以 sys arg
的问题在于它做同样的事情

71
00:03:42,410 --> 00:03:43,520
比如输入功能。

72
00:03:43,520 --> 00:03:46,220
但不同的是
你可以

73
00:03:46,220 --> 00:03:49,860
在你
实际执行脚本之前给出参数。

74
00:03:49,860 --> 00:03:52,710
这就是
输入函数与系统之间的区别

75
00:03:52,710 --> 00:03:53,210
参数。

76
00:03:53,210 --> 00:03:56,750
所以 sys arg，你可以在
之前给出参数。

77
00:03:56,750 --> 00:03:58,700
我可以提供
show IP route 命令。

78
00:03:58,700 --> 00:04:01,610
我可以简要介绍一下防火墙的显示 IP 接口。

79
00:04:01,610 --> 00:04:03,350
或者我可以提供
用户名和密码。

80
00:04:03,350 --> 00:04:07,310
但问题是
作为用户，

81
00:04:07,310 --> 00:04:10,440
我需要知道在哪里放置这些参数。

82
00:04:10,440 --> 00:04:13,070
所以我实际上必须
去打开文件

83
00:04:13,070 --> 00:04:17,120
并查看文件，
好吧，你知道，参数

84
00:04:17,120 --> 00:04:19,459
数字 1 用于命令。

85
00:04:19,459 --> 00:04:22,610
参数 2 是
防火墙命令。

86
00:04:22,610 --> 00:04:27,140
然后参数 number
3 是用户名。

87
00:04:27,140 --> 00:04:30,080
参数 number
4 是密码。

88
00:04:30,080 --> 00:04:31,890
所以我真的必须知道这一点。

89
00:04:31,890 --> 00:04:36,786
所以我必须提供一些东西
比如python3、rohit2.py。

90
00:04:39,980 --> 00:04:44,810
然后，我可以给
show ip interface简要，

91
00:04:44,810 --> 00:04:46,550
这是路由器命令。

92
00:04:46,550 --> 00:04:48,620
然后，我给出我的第二个论点，即

93
00:04:48,620 --> 00:04:52,160
将要显示界面
ip简要，即将进行

94
00:04:52,160 --> 00:04:54,690
成为防火墙的论据。

95
00:04:54,690 --> 00:04:59,420
所以这将是
show interface ip brief。

96
00:04:59,420 --> 00:05:02,300
那是我的防火墙
论点——论点 2。

97
00:05:02,300 --> 00:05:06,560
然后，我给出我的参数编号
3，即用户名 cisco。

98
00:05:06,560 --> 00:05:10,190
然后第四个参数
是密码cisco。

99
00:05:10,190 --> 00:05:12,170
所以你看，我以正确的顺序给出
这个。

100
00:05:12,170 --> 00:05:13,980
我无法替换此订单。

101
00:05:13,980 --> 00:05:15,590
这就是 sys arg 的
问题，

102
00:05:15,590 --> 00:05:18,470
你必须知道
哪个论点是为了什么。

103
00:05:18,470 --> 00:05:20,750
所以作为一个用户——比如说，
如果我要提供脚本

104
00:05:20,750 --> 00:05:22,940
对于某人，他将
必须打开文件

105
00:05:22,940 --> 00:05:26,150
看看他需要给出哪些论据。

106
00:05:26,150 --> 00:05:30,020
这就是
Argparse 的用武之地，

107
00:05:30,020 --> 00:05:33,560
在 Argparse 中，我会
查看所有参数列表

108
00:05:33,560 --> 00:05:34,700
只是帮助。

109
00:05:34,700 --> 00:05:37,230
可以这样想——
当我使用 Cisco 路由器时。

110
00:05:37,230 --> 00:05:40,160
假设我正在尝试
运行 show 命令，

111
00:05:40,160 --> 00:05:44,240
我真的不记得了，
是不是显示IP接口简介，

112
00:05:44,240 --> 00:05:46,310
还是显示
接口IP简介？

113
00:05:46,310 --> 00:05:48,590
我总是可以做一个显示
空格问号。

114
00:05:48,590 --> 00:05:49,880
这给了我帮助——

115
00:05:49,880 --> 00:05:54,020
它
具有一些描述的命令列表。

116
00:05:54,020 --> 00:05:55,340
那是完全一样的。

117
00:05:55,340 --> 00:05:58,730
Argparse 与输入函数的作用完全相同


118
00:05:58,730 --> 00:06:00,630
或 sys arg 做什么。

119
00:06:00,630 --> 00:06:03,350
但是，不同的是
现在你得到了帮助，

120
00:06:03,350 --> 00:06:07,880
这样您就可以查看
参数——它所期望的——

121
00:06:07,880 --> 00:06:12,680
以及
参数的顺序，也，也许

122
00:06:12,680 --> 00:06:15,350
如果它不是作为可选参数完成的。

123
00:06:18,230 --> 00:06:19,470
所以它有效。

124
00:06:19,470 --> 00:06:21,240
所以我的 sys arg 有效。

125
00:06:21,240 --> 00:06:23,630
但同样，我需要
了解我的论点。

126
00:06:23,630 --> 00:06:26,840
我需要知道那个论点的确切
顺序。

127
00:06:26,840 --> 00:06:28,650
这就是 Argparse 的用武之地。

128
00:06:28,650 --> 00:06:32,030
因此，我现在将向您展示 Argparse。

129
00:06:32,030 --> 00:06:35,450
因此，Argparse 是您通常会做很多的事情。

130
00:06:35,450 --> 00:06:37,400
我真的没有
看到输入功能

131
00:06:37,400 --> 00:06:38,810
被大量使用。

132
00:06:38,810 --> 00:06:41,450
我不经常使用 sys arg
。

133
00:06:41,450 --> 00:06:43,340
但是，Argparse
是你需要的东西

134
00:06:43,340 --> 00:06:45,890
如果您想要
来自用户的输入，将使用，

135
00:06:45,890 --> 00:06:51,060
但同时，你
想要所有的论点

136
00:06:51,060 --> 00:06:54,510
这是
执行该脚本所必需的。

137
00:06:54,510 --> 00:06:57,980
所以我要做的是
我会去我的 Atom

138
00:06:57,980 --> 00:07:04,010
并且只需创建一个简单的
基本 Argparse 脚本，它

139
00:07:04,010 --> 00:07:07,490
也许只是添加一些数字。

140
00:07:07,490 --> 00:07:10,730
让我们做{}它只是
添加了一些数字。

141
00:07:10,730 --> 00:07:17,090
它减去，或它
乘，或除。

142
00:07:17,090 --> 00:07:18,490
所以我们可以
做类似的事情。

143
00:07:18,490 --> 00:07:24,280
因此，对于进行 Argparse，您需要做的第一件事

144
00:07:24,280 --> 00:07:26,600
是先保存这个。

145
00:07:26,600 --> 00:07:29,780
让我们将它保存为
basic_argparse.py。

146
00:07:34,970 --> 00:07:37,340
你会说的第一件事


147
00:07:37,340 --> 00:07:41,105
就是，导入 argparse。

148
00:07:41,105 --> 00:07:42,980
所以这是你要做的第一件事--

149
00:07:42,980 --> 00:07:44,210
导入模块——

150
00:07:44,210 --> 00:07:46,520
Argparse 的模块。

151
00:07:46,520 --> 00:07:53,675
您要做的下一件事
将是创建一个包裹。

152
00:07:53,675 --> 00:07:56,180
包裹什么都不是
只是一个容器

153
00:07:56,180 --> 00:07:57,620
坚持你的论点。

154
00:07:57,620 --> 00:07:59,660
这就是我们需要做的。

155
00:07:59,660 --> 00:08:01,220
同样，这可以是任何名称。

156
00:08:01,220 --> 00:08:04,318
所以我会说解析器——

157
00:08:04,318 --> 00:08:05,360
我可以把它命名为任何东西。

158
00:08:05,360 --> 00:08:06,290
它只是一个容器。

159
00:08:06,290 --> 00:08:08,360
所以解析器等于。

160
00:08:08,360 --> 00:08:11,240
在这里，我将
提供 argparse--

161
00:08:11,240 --> 00:08:13,896
所以 argparse 是我的模块——

162
00:08:13,896 --> 00:08:15,304
.ArgumentParser。

163
00:08:18,710 --> 00:08:21,260
在这里，我也许可以
给出一些描述。

164
00:08:21,260 --> 00:08:37,610
比方说，描述等于
比方说，做数学。

165
00:08:37,610 --> 00:08:39,140
同样，这只是
任何描述。

166
00:08:39,140 --> 00:08:41,272
我会告诉你这个
将在哪里显示。

167
00:08:41,272 --> 00:08:42,980
所以就像当你
打一个问号，

168
00:08:42,980 --> 00:08:45,170
它给你一个标题
，好的，这些

169
00:08:45,170 --> 00:08:46,310
是参数列表。

170
00:08:46,310 --> 00:08:50,310
它会显示一个标题
这是用来做数学的。

171
00:08:50,310 --> 00:08:53,130
好的，所以我创建了一个
容器——

172
00:08:53,130 --> 00:08:54,590
我们就叫这个解析器——

173
00:08:54,590 --> 00:08:58,670
这将
持有我所有的论点。

174
00:08:58,670 --> 00:09:01,270
下一步是
创建这些参数。

175
00:09:01,270 --> 00:09:02,720
所以让我们创建一个。

176
00:09:02,720 --> 00:09:04,325
我会说，解析器.-

177
00:09:08,102 --> 00:09:12,410
事实上，让我们
增大它的大小。

178
00:09:12,410 --> 00:09:13,945
所以 parser.add_argument。

179
00:09:16,570 --> 00:09:18,920
那么我要添加什么参数
？

180
00:09:18,920 --> 00:09:21,910
所以在这里，我可以说——

181
00:09:21,910 --> 00:09:23,830
假设我想
做一些数学运算。

182
00:09:23,830 --> 00:09:27,010
也许我要向他
要三个数字。

183
00:09:27,010 --> 00:09:29,570
我希望他们被添加。

184
00:09:29,570 --> 00:09:32,590
因此，如果我有三个数字，
我希望将它们相加，

185
00:09:32,590 --> 00:09:35,120
我将不得不
创建论点。

186
00:09:35,120 --> 00:09:39,100
因此，让我们创建论点。

187
00:09:39,100 --> 00:09:41,110
假设这是第一名。

188
00:09:41,110 --> 00:09:42,950
同样，这只是任何名称。

189
00:09:42,950 --> 00:09:44,920
所以我只是给参数一个
名字。

190
00:09:44,920 --> 00:09:48,250
这就像说，当您
想要输入用户名时，

191
00:09:48,250 --> 00:09:49,600
减 u--

192
00:09:49,600 --> 00:09:53,950
这是用户名的选项
。

193
00:09:53,950 --> 00:09:56,740
所以我说的是同样的事情，
这是第一，

194
00:09:56,740 --> 00:09:58,990
就像一个临时的
占位符。

195
00:09:58,990 --> 00:10:01,030
这是我
实际输入的地方

196
00:10:01,030 --> 00:10:03,500
整数或数字。

197
00:10:03,500 --> 00:10:09,820
所以第一，让我们
做类型等于整数。

198
00:10:09,820 --> 00:10:12,940
然后也许我们可以对此进行一些描述。

199
00:10:12,940 --> 00:10:24,840
比方说，帮助，这
是整数一。

200
00:10:24,840 --> 00:10:26,530
就是这样。

201
00:10:26,530 --> 00:10:29,830
让我们完全复制这一行
并将其粘贴到这里。

202
00:10:29,830 --> 00:10:32,130
这将是
我的第二个论点——

203
00:10:32,130 --> 00:10:33,420
2号。

204
00:10:33,420 --> 00:10:37,350
这是整数 2。

205
00:10:37,350 --> 00:10:38,950
让我们再添加一个。

206
00:10:38,950 --> 00:10:42,030
这将是
整数 3。

207
00:10:42,030 --> 00:10:47,490
所以我基本上从用户那里得到三个
参数——

208
00:10:47,490 --> 00:10:50,570
1号，2号，3号。

209
00:10:50,570 --> 00:10:52,280
接下来
我要做的事

210
00:10:52,280 --> 00:10:59,700
我要创建一个args吗？

211
00:10:59,700 --> 00:11:01,160
同样，这可以是任何名称。

212
00:11:01,160 --> 00:11:05,660
所以 args 等于我的解析器——

213
00:11:05,660 --> 00:11:07,550
所以我基本上是在做解析。

214
00:11:07,550 --> 00:11:09,650
所以 parser.parse_args。

215
00:11:15,680 --> 00:11:17,130
现在我可以打印它了。

216
00:11:17,130 --> 00:11:18,680
那我要打印什么？

217
00:11:18,680 --> 00:11:20,750
假设我想
做一些数学。

218
00:11:20,750 --> 00:11:23,120
比方说，我会说，打印。

219
00:11:23,120 --> 00:11:24,270
我要打印什么？

220
00:11:24,270 --> 00:11:29,390
我想打印，
比方说，第一。

221
00:11:29,390 --> 00:11:30,860
所以我可以说功能。

222
00:11:30,860 --> 00:11:34,410
同样，我正在使用
内置函数。

223
00:11:34,410 --> 00:11:38,630
所以我可以说，函数——
基本上是我的格式字符串。

224
00:11:38,630 --> 00:11:51,220
在这里，我想说，
这是整数 1。

225
00:12:04,610 --> 00:12:06,530
让我们放一些
类似arg.num1的东西。

226
00:12:10,460 --> 00:12:13,462
所以这是我的临时
占位符。

227
00:12:13,462 --> 00:12:15,170
这就是
争论的所在。

228
00:12:15,170 --> 00:12:18,680
并且 args 等于
parser.parse_args。

229
00:12:18,680 --> 00:12:20,840
所以无论他
在这里输入什么

230
00:12:20,840 --> 00:12:23,780
什么会放在这里。

231
00:12:23,780 --> 00:12:26,870
比方说，如果我放
2，那么 2

232
00:12:26,870 --> 00:12:30,940
为整数 1。

233
00:12:30,940 --> 00:12:32,320
让我们再打印一张。

234
00:12:32,320 --> 00:12:33,115
让我们复制一下。

235
00:12:38,750 --> 00:12:39,995
这将是第二个。

236
00:12:43,290 --> 00:12:44,520
让我们再次打印。

237
00:12:44,520 --> 00:12:46,980
这是3号——

238
00:12:46,980 --> 00:12:48,150
论据编号 3。

239
00:12:53,450 --> 00:12:57,350
我应该在这里有我的
双引号。

240
00:13:04,090 --> 00:13:07,232
让我们继续复制
这个并执行它。

241
00:13:07,232 --> 00:13:08,190
让我们看看发生了什么。

242
00:13:08,190 --> 00:13:09,810
在这个
时间点，它应该只

243
00:13:09,810 --> 00:13:12,570
为我打印这些数字。

244
00:13:12,570 --> 00:13:13,620
让我们执行这个。

245
00:13:13,620 --> 00:13:16,950
我将返回
我的本地机器--

246
00:13:16,950 --> 00:13:19,980
CD桌面，CD rohit。

247
00:13:19,980 --> 00:13:23,595
比方说，sftp 到我的机架。

248
00:13:28,840 --> 00:13:34,300
让我们确保我的 Ubuntu to
机器在正确的文件夹中。

249
00:13:34,300 --> 00:13:36,910
我可以说，放。

250
00:13:36,910 --> 00:13:39,316
名称是 basic_argparse.py。

251
00:13:44,620 --> 00:13:46,690
所以如果我现在回首
做LS，我

252
00:13:46,690 --> 00:13:51,730

这里应该有那个脚本，这是基本的。

253
00:13:51,730 --> 00:13:53,260
哪里是？

254
00:14:00,170 --> 00:14:03,655
让我们继续将
这个复制到正确的文件夹中。

255
00:14:10,480 --> 00:14:15,220
所以把它放在这个文件夹里。

256
00:14:18,600 --> 00:14:20,550
让我们回去做LS。

257
00:14:20,550 --> 00:14:23,250
我现在应该看到文件
--basic_argparse.py。

258
00:14:23,250 --> 00:14:30,540
所以现在我可以说python3，
argparse，或者basic_argparse.py，

259
00:14:30,540 --> 00:14:31,947
并提供论据。

260
00:14:31,947 --> 00:14:33,030
看看最好的部分。

261
00:14:33,030 --> 00:14:36,900
如果我减 h，这
是内置帮助

262
00:14:36,900 --> 00:14:39,450
参数的特征--
如果我减去 h，

263
00:14:39,450 --> 00:14:43,350
它向我展示了
三个位置参数。

264
00:14:43,350 --> 00:14:45,630
现在有两种
类型的参数

265
00:14:45,630 --> 00:14:46,830
你实际上可以给。

266
00:14:46,830 --> 00:14:48,030
一种是可选的。

267
00:14:48,030 --> 00:14:49,500
一是定位。

268
00:14:49,500 --> 00:14:53,790
位置意味着它们必须
按正确的顺序排列。

269
00:14:53,790 --> 00:14:57,190
这不是强制性的，但它们
必须按正确的顺序排列。

270
00:14:57,190 --> 00:14:59,580
所以如果我给出数字 1--

271
00:14:59,580 --> 00:15:08,850
比方说，如果我输入诸如 2、5、8 之类的东西
。

272
00:15:08,850 --> 00:15:11,190
所以在这种情况下，
这是第一。

273
00:15:11,190 --> 00:15:14,910
这是2号，
这是3号。

274
00:15:14,910 --> 00:15:19,770
以上是我的三个
立场论点。

275
00:15:19,770 --> 00:15:22,020
所以位置意味着他们有

276
00:15:22,020 --> 00:15:25,390
处于那个特定的位置。

277
00:15:25,390 --> 00:15:28,710
因此，如果我查看订单，
无论哪个在最上面，

278
00:15:28,710 --> 00:15:30,330
这是第一个论点。

279
00:15:30,330 --> 00:15:33,090
无论哪个在中间，
那是你的第二个论点。

280
00:15:33,090 --> 00:15:34,920
而这个
是你的最后一个论点。

281
00:15:34,920 --> 00:15:36,960
所以这是你的论点的顺序。

282
00:15:36,960 --> 00:15:42,180
这是你的描述，
我们在里面给出的，

283
00:15:42,180 --> 00:15:44,910
我相信，脚本——我们
说过，这是整数 1。

284
00:15:44,910 --> 00:15:45,952
这是整数 2。

285
00:15:45,952 --> 00:15:47,400
这是整数 3。

286
00:15:47,400 --> 00:15:54,900
现在，如果我给出这个
参数并按 Enter，

287
00:15:54,900 --> 00:16:02,445
我看到一个错误，它说
arg.num1 是整数 1。

288
00:16:05,000 --> 00:16:07,770
并且名称 arg 未定义。

289
00:16:07,770 --> 00:16:08,690
我相信我做到了。

290
00:16:08,690 --> 00:16:10,160
哦，是args。

291
00:16:10,160 --> 00:16:14,760
让我们返回并将其更改为 args。

292
00:16:14,760 --> 00:16:17,860
同样，这与我们在此处给出的
名称相同。

293
00:16:17,860 --> 00:16:22,305
让我们将其更改为
args 并保存

294
00:16:22,305 --> 00:16:25,320
然后回去重新复制我的文件。

295
00:16:30,480 --> 00:16:34,170
让我们返回并
再次执行此操作。

296
00:16:34,170 --> 00:16:37,160
所以你应该看到
2是数字1，

297
00:16:37,160 --> 00:16:41,030
5是整数2，
8是整数3。

298
00:16:41,030 --> 00:16:43,460
现在，如果我想做一些数学，我可以做数学。

299
00:16:43,460 --> 00:16:45,440
我可以
回到我的剧本

300
00:16:45,440 --> 00:16:53,390
并且说，好的，n1 等于
参数的整数--

301
00:16:53,390 --> 00:16:54,260
args.num1。

302
00:16:56,870 --> 00:17:05,910
并且 2 等于
args.num2 的整数。

303
00:17:09,310 --> 00:17:17,470
并且数字 3-- 和 3 是 num3 的 args 的整数。

304
00:17:17,470 --> 00:17:20,349
所以无论我输入什么数字
我都会去

305
00:17:20,349 --> 00:17:24,910
将其存储在一个名为 n1、n2 和 n3 的变量中。

306
00:17:24,910 --> 00:17:30,700
然后，我可以
也许做一些计算。

307
00:17:35,860 --> 00:17:42,140
我会说，结果等于无。

308
00:17:42,140 --> 00:17:44,580
并且说，如果 args.-

309
00:17:50,770 --> 00:17:52,420
如果我必须做数学，我可能会

310
00:17:52,420 --> 00:17:56,710
必须在这里再做一个论点
来做数学。

311
00:17:56,710 --> 00:18:05,254
让我们复制这个并说，这
将是计算。

312
00:18:10,170 --> 00:18:13,480
并且类型不需要
在那里。

313
00:18:13,480 --> 00:18:15,870
所以类型整数确实
不需要在那里。

314
00:18:15,870 --> 00:18:25,350
帮助是这将做数学。

315
00:18:25,350 --> 00:18:31,970
所以在我的论点
称为计算，

316
00:18:31,970 --> 00:18:35,300
我可以定义我想做什么。

317
00:18:35,300 --> 00:18:38,795
所以我可以添加。

318
00:18:38,795 --> 00:18:42,320
我可以做乘法。

319
00:18:42,320 --> 00:18:47,990
我可以做一些事情
比如除法。

320
00:18:47,990 --> 00:18:51,080
我可以做减法。

321
00:18:51,080 --> 00:18:52,940
所以我可以减去一些东西。

322
00:18:52,940 --> 00:18:54,090
我可以做到这一切。

323
00:18:54,090 --> 00:19:00,220
所以也许，比方说，如果
计算帮助是——

324
00:19:06,603 --> 00:19:07,520
这将做数学。

325
00:19:07,520 --> 00:19:08,640
让我们回到这里。

326
00:19:08,640 --> 00:19:19,910
所以如果arguments.calculation
等于，等于add--

327
00:19:19,910 --> 00:19:36,520
所以如果是加法，那么我们应该
结果等于n1，n2加n3。

328
00:19:39,970 --> 00:19:59,170
else/if args.calculation 是
减法，那么我应该说，

329
00:19:59,170 --> 00:20:07,960
结果等于——

330
00:20:07,960 --> 00:20:19,450
也许我可以做一些事情
像n1减n2减n3。

331
00:20:19,450 --> 00:20:21,250
所以我可以做类似的事情。

332
00:20:21,250 --> 00:20:25,740
让我们在 else/if 中再添加一个
语句。

333
00:20:25,740 --> 00:20:38,290
如果是乘法，那么结果
应该是n1乘以n2乘以n3。

334
00:20:38,290 --> 00:20:46,510
然后我可以
说，打印结果。

335
00:20:46,510 --> 00:20:48,720
那么让我们看看我们的脚本。

336
00:20:48,720 --> 00:21:03,460
所以它基本上说if
参数计算是add，

337
00:21:03,460 --> 00:21:04,850
然后这样做。

338
00:21:04,850 --> 00:21:11,360
如果是减法，则执行此操作。

339
00:21:11,360 --> 00:21:13,400
如果是乘法，则执行此操作。

340
00:21:13,400 --> 00:21:14,770
所以我只是把它说出来了。

341
00:21:14,770 --> 00:21:16,792
让我们来实际测试一下。

342
00:21:16,792 --> 00:21:17,875
所以我要保存这个。

343
00:21:20,390 --> 00:21:24,635
让我们将这个
文件重新复制到我的 Ubuntu 机器上。

344
00:21:29,730 --> 00:21:37,260
然后回到这里，
让我们做 python3 说，

345
00:21:37,260 --> 00:21:41,670
基本 argparse 减去 h。

346
00:21:41,670 --> 00:21:43,450
所以这些是我的论点。

347
00:21:43,450 --> 00:21:45,120
所以第一个参数是数字。

348
00:21:45,120 --> 00:21:48,130
它必须是整数类型。

349
00:21:48,130 --> 00:21:51,270
第二个是我的数字 2，
再次输入整数。

350
00:21:51,270 --> 00:21:55,650
第三个参数也是 number
3，同样是一个整数。

351
00:21:55,650 --> 00:21:58,570
第四个，我没有
给出整数类型，

352
00:21:58,570 --> 00:22:00,160
这意味着它可以是一个字符串。

353
00:22:00,160 --> 00:22:02,730
所以第四个称为
最后一个计算。

354
00:22:02,730 --> 00:22:06,610
我会做的，我会
放一些字符串，基本上。

355
00:22:06,610 --> 00:22:09,990
因此，如果我添加添加，它
应该添加所有这些。

356
00:22:09,990 --> 00:22:10,960
让我们这样做。

357
00:22:10,960 --> 00:22:13,230
所以我会说，python3——

358
00:22:13,230 --> 00:22:17,880
让我们输入一些数字--
然后输入 2、4 和 6。

359
00:22:17,880 --> 00:22:22,230
所以我的数字 1 是 2，数字
2 是 4，数字 3 是 6。

360
00:22:22,230 --> 00:22:24,750
现在让我们把
第四个参数。

361
00:22:24,750 --> 00:22:27,270
比方说，如果我不提出
论点，它会说什么？

362
00:22:27,270 --> 00:22:31,080
它说，以下
参数是必需的——

363
00:22:31,080 --> 00:22:32,130
计算。

364
00:22:32,130 --> 00:22:36,220
因为我给出了四个
参数，所以它们是必需的。

365
00:22:36,220 --> 00:22:39,390
您需要输入
这些论点。

366
00:22:39,390 --> 00:22:41,290
你必须把所有的
四个参数。

367
00:22:41,290 --> 00:22:43,420
你不能只是
跳过任何论点。

368
00:22:43,420 --> 00:22:48,540
所以我想说，第四个
参数将被添加。

369
00:22:48,540 --> 00:22:49,770
结果应该是什么？

370
00:22:49,770 --> 00:22:53,470
应该是2加4
加6，也就是12。

371
00:22:53,470 --> 00:22:56,580
所以我看到了结果 12。

372
00:22:56,580 --> 00:23:00,330
它首先带来了这个，
根据我的脚本，

373
00:23:00,330 --> 00:23:02,130
它打印这些东西。

374
00:23:02,130 --> 00:23:03,390
然后它打印结果。

375
00:23:03,390 --> 00:23:09,240
也许我可以在这里放一些东西
比如格式字符串，

376
00:23:09,240 --> 00:23:20,330
这说最终的答案是。

377
00:23:20,330 --> 00:23:27,820
我可以说，打印
结果。所以最后的答案

378
00:23:27,820 --> 00:23:33,790
是什么结果。

379
00:23:33,790 --> 00:23:39,850
好的，让我们保存它，然后将它复制回我的 Ubuntu 机器。

380
00:23:45,400 --> 00:23:48,920
现在让我们执行这个。

381
00:23:48,920 --> 00:23:53,690
因此，如果我说，添加，它会为我计算
并添加。

382
00:23:53,690 --> 00:23:55,820
它说，最终答案是 12。

383
00:23:55,820 --> 00:24:00,440
比方说，如果我做减法——

384
00:24:00,440 --> 00:24:04,850
如果我做减法，我得到
最终答案是负 8。

385
00:24:04,850 --> 00:24:08,930
所以它是 2 减 4 减 6。

386
00:24:08,930 --> 00:24:11,300
这将是
减 2 和减 6。

387
00:24:11,300 --> 00:24:12,950
那将是负8。

388
00:24:12,950 --> 00:24:14,870
比方说，如果
我确实乘法--

389
00:24:17,780 --> 00:24:22,415
如果我做乘法，它会乘以
2 乘以 4，即 8--

390
00:24:22,415 --> 00:24:24,740
8乘以6，即48。

391
00:24:24,740 --> 00:24:27,260
所以这就是我得到答案的方式。

392
00:24:27,260 --> 00:24:29,240
所以你看这是Argparse。

393
00:24:29,240 --> 00:24:34,910
你可能会问我，好的，
如果我看帮助，

394
00:24:34,910 --> 00:24:39,500
我真的不知道
我应该输入什么？

395
00:24:39,500 --> 00:24:40,790
我应该输入添加吗？

396
00:24:40,790 --> 00:24:43,910
我应该输入减法吗？

397
00:24:43,910 --> 00:24:45,747
或者我应该输入乘法？

398
00:24:45,747 --> 00:24:46,580
我真的不知道。

399
00:24:46,580 --> 00:24:49,560
如果您愿意，您也可以
输入选项。

400
00:24:49,560 --> 00:24:54,270
所以现在，假设我
做除法之类的事情——

401
00:24:54,270 --> 00:25:01,140
所以如果我做除法，它
什么都做不了，

402
00:25:01,140 --> 00:25:02,230
因为结果没有。

403
00:25:05,175 --> 00:25:06,550
所以它
并没有真正做任何事情。

404
00:25:13,340 --> 00:25:21,950
但我可以把它放在
脚本中，说，也许，否则，

405
00:25:21,950 --> 00:25:38,620
结果等于，也许，
打印，不正确的选项。