1
00:00:10,170 --> 00:00:12,600
您好，欢迎来到 INE。

2
00:00:12,600 --> 00:00:15,780
今天在这个视频中，我们
来看看 sys argv，

3
00:00:15,780 --> 00:00:18,390
什么是用例
为此，为什么会

4
00:00:18,390 --> 00:00:19,920
我们想这样做吗？

5
00:00:19,920 --> 00:00:21,415
现在，在上一个
视频中，我们有

6
00:00:21,415 --> 00:00:23,040
了解了
输入函数，其中

7
00:00:23,040 --> 00:00:26,460
我们向
用户提出了一个问题，并根据输入，

8
00:00:26,460 --> 00:00:28,860
我们基本上是在
执行某事。

9
00:00:28,860 --> 00:00:31,800
现在，为了执行
输入功能，

10
00:00:31,800 --> 00:00:34,350
我们必须基本上
执行脚本。

11
00:00:34,350 --> 00:00:36,900
那就是
一行一行地去的时候

12
00:00:36,900 --> 00:00:39,750
并问你这个问题。

13
00:00:39,750 --> 00:00:41,910
它等待您的输入。

14
00:00:41,910 --> 00:00:45,930
一旦你提供了
输入，它就会执行那个脚本。

15
00:00:45,930 --> 00:00:48,600
现在，有了 sys
argv，基本上是 sys

16
00:00:48,600 --> 00:00:50,590
是一个内置模块，
是可用的，

17
00:00:50,590 --> 00:00:51,870
但你可以在 Python 中导入。

18
00:00:51,870 --> 00:00:54,840
我们可以提供
论据，

19
00:00:54,840 --> 00:00:57,080
无需直接运行
脚本。

20
00:00:57,080 --> 00:00:58,740
所以从 Ubuntu
机器本身来说，

21
00:00:58,740 --> 00:01:03,960
我可以从系统中指定
参数

22
00:01:03,960 --> 00:01:08,160
到 Python 解释器，并且
我可以执行我的脚本。

23
00:01:08,160 --> 00:01:10,860
早些时候，我不得不去
说——让我们看看

24
00:01:10,860 --> 00:01:13,290
如果您还记得上一个
实验室或上一个视频，

25
00:01:13,290 --> 00:01:15,990
我们基本上是在
问这个问题的地方，

26
00:01:15,990 --> 00:01:20,610
为路由器输入 show 命令
，

27
00:01:20,610 --> 00:01:22,690
为防火墙输入 show 命令
。

28
00:01:22,690 --> 00:01:24,840
所以我们正在执行脚本。

29
00:01:24,840 --> 00:01:28,050
所以我们说的是 Python3，然后是脚本名称 dot py。

30
00:01:28,050 --> 00:01:30,840
我们正在执行
脚本，然后它

31
00:01:30,840 --> 00:01:33,520
是在问你的意见。

32
00:01:33,520 --> 00:01:35,580
一旦你提供了
输入，它

33
00:01:35,580 --> 00:01:38,400
正在为您显示
选项，

34
00:01:38,400 --> 00:01:41,790
或者它基本上是
显示显示IP路由

35
00:01:41,790 --> 00:01:43,860
为你命令。

36
00:01:43,860 --> 00:01:48,330
这里的区别是
sys argv 很漂亮

37
00:01:48,330 --> 00:01:50,550
类似于输入功能。

38
00:01:50,550 --> 00:01:52,150
它做同样的事情。

39
00:01:52,150 --> 00:01:54,330
所以这只是一种不同的
方式，

40
00:01:54,330 --> 00:01:58,170
在你没有真正
提供输入的地方

41
00:01:58,170 --> 00:01:59,700
执行脚本后。

42
00:01:59,700 --> 00:02:02,560
您实际上在执行时提供了
输入。

43
00:02:02,560 --> 00:02:05,400
所以当我实际运行
命令Python3和文件时

44
00:02:05,400 --> 00:02:09,750
名称，我会在该行中提供
输入信息

45
00:02:09,750 --> 00:02:10,389
本身。

46
00:02:10,389 --> 00:02:13,500
所以基本上，我可以运行
脚本，它不需要我。

47
00:02:13,500 --> 00:02:15,960
它可以执行一切，
因为我已经

48
00:02:15,960 --> 00:02:17,760
提供了信息。

49
00:02:17,760 --> 00:02:23,490
实际上，让我向您展示一个
sys argv 的基本示例。

50
00:02:23,490 --> 00:02:32,175
所以我要做的是
我会去我的——

51
00:02:34,770 --> 00:02:39,690
也许实际上，
直接在 Ubuntu 机器上执行此操作。

52
00:02:39,690 --> 00:02:47,040
所以我将创建一个简单的
文件，比如说，

53
00:02:47,040 --> 00:02:48,964
basic_sys_argv.py。

54
00:02:53,200 --> 00:02:56,000
所以我要创建一个
文件，它是一个空文件。

55
00:02:56,000 --> 00:02:59,980
在这里，我将向您展示
我们如何使用 sys argv。

56
00:02:59,980 --> 00:03:02,770
所以假设我想
打印一些东西。

57
00:03:02,770 --> 00:03:08,410
如果我想
打印我的名字，我

58
00:03:08,410 --> 00:03:13,240
想打印也许我的年龄，
你通常会怎么做？

59
00:03:13,240 --> 00:03:15,430
如果你给
输入函数，

60
00:03:15,430 --> 00:03:32,190
然后我会说名字等于，
我会说，输入什么

61
00:03:32,190 --> 00:03:34,950
是你的名字。

62
00:03:34,950 --> 00:03:36,900
所以我基本上
会问一个问题。

63
00:03:36,900 --> 00:03:40,470
根据输入，我
将捕获该信息

64
00:03:40,470 --> 00:03:42,370
并打印出来。

65
00:03:42,370 --> 00:03:45,660
所以我会说，好吧，如果他
键入 Rohit，然后打印出来。

66
00:03:45,660 --> 00:03:47,910
因此，如果我
使用输入功能，我会这样做。

67
00:03:47,910 --> 00:03:50,830
显然，我会
在这里引用引号。

68
00:03:50,830 --> 00:03:54,720
所以我会说，
你叫什么名字？

69
00:03:54,720 --> 00:03:58,250
然后我会打印出来。

70
00:03:58,250 --> 00:04:00,415
所以让我们这样做--
你叫什么名字？

71
00:04:04,150 --> 00:04:06,730
所以像
这样的东西，我会

72
00:04:06,730 --> 00:04:14,935
再次说年龄等于
输入您的年龄。

73
00:04:17,589 --> 00:04:19,279
所以我会完全
做同样的事情。

74
00:04:19,279 --> 00:04:24,520
然后无论他
提供什么输入，我都会说，好吧，打印

75
00:04:24,520 --> 00:04:28,690
像我的，
使用格式字符串，

76
00:04:28,690 --> 00:04:33,070
说，函数，它是
格式字符串，说，

77
00:04:33,070 --> 00:04:36,700
我的名字是，我
会说，名字。

78
00:04:39,370 --> 00:04:42,895
我的年龄是，年龄。

79
00:04:49,165 --> 00:04:50,540
所以我会做这样的事情

80
00:04:50,540 --> 00:04:53,750
如果我使用的是
输入功能。

81
00:04:53,750 --> 00:04:57,650
但是对于我执行这样的事情
，我不得不说，

82
00:04:57,650 --> 00:05:08,120
Python3，以及文件
名称basic_sys_argv.py，

83
00:05:08,120 --> 00:05:09,200
我会执行它。

84
00:05:09,200 --> 00:05:10,580
它会问我一个问题。

85
00:05:10,580 --> 00:05:12,180
我会说罗希特。

86
00:05:12,180 --> 00:05:15,530
它会问我我的年龄，
然后说 41，然后

87
00:05:15,530 --> 00:05:18,500
它打印出我的名字是
Rohit，我的年龄是 41。

88
00:05:18,500 --> 00:05:24,090
所以你看，我必须通过运行脚本来提供输入。

89
00:05:24,090 --> 00:05:27,590
在它运行脚本后，
它会问我一个问题，

90
00:05:27,590 --> 00:05:30,440
然后我不得不
提供信息。

91
00:05:30,440 --> 00:05:33,410
如果我想在我离开时运行
脚本怎么办？

92
00:05:33,410 --> 00:05:36,470
所以我可以提供
信息

93
00:05:36,470 --> 00:05:38,450
当我试图
执行脚本时。

94
00:05:38,450 --> 00:05:41,010
这就是 sys argv 的用武之地。

95
00:05:41,010 --> 00:05:42,890
所以我会用 sys argv 做同样的事情。

96
00:05:45,440 --> 00:05:47,000
同样，不同的用例。

97
00:05:47,000 --> 00:05:48,560
有人喜欢
输入功能，

98
00:05:48,560 --> 00:05:51,290
有些人喜欢 sys argv。

99
00:05:51,290 --> 00:05:57,030
所以让我回过头来说说
vim basic_sys_argv.py。

100
00:05:57,030 --> 00:06:04,286
在这里，而不是我
放入类似的东西，

101
00:06:04,286 --> 00:06:06,463
让我们去这里放一个空间。

102
00:06:06,463 --> 00:06:08,630
所以不是我把
放在像输入这样的东西里

103
00:06:08,630 --> 00:06:14,990
函数，我会
完全删除它。

104
00:06:14,990 --> 00:06:26,900
我会说，名称等于
参数，索引值等于 1。

105
00:06:26,900 --> 00:06:34,050
然后随着年龄的增长，我
也会做同样的事情。

106
00:06:34,050 --> 00:06:41,690
所以年龄等于 arguments
索引值 2。

107
00:06:41,690 --> 00:06:47,910
在此之前，我会
导入我的 sys 模块。

108
00:06:47,910 --> 00:06:52,310
比如说，import sys.

109
00:06:52,310 --> 00:06:55,850
我会说
argument，所以 args，哪个

110
00:06:55,850 --> 00:06:57,110
是我们在这里给的名字。

111
00:06:57,110 --> 00:07:00,530
这只是一个变量
名称，或任意名称。

112
00:07:00,530 --> 00:07:09,360
所以 args 等于 sys.argv，
就是这样，这就是我所需要的。

113
00:07:09,360 --> 00:07:12,030
所以我实际上要说的是，
我正在导入 sys 模块，

114
00:07:12,030 --> 00:07:14,330
然后我说，
好的，争论——

115
00:07:14,330 --> 00:07:15,650
这又是什么名字——

116
00:07:15,650 --> 00:07:22,880
等于 sys.argv，然后 name
等于 arguments 索引值 1。

117
00:07:22,880 --> 00:07:27,020
现在，我说的是索引值
1，然后是索引值 2，

118
00:07:27,020 --> 00:07:28,220
这是为什么？

119
00:07:28,220 --> 00:07:31,820
因为每当我
导入一个系统时，系统

120
00:07:31,820 --> 00:07:36,950
我正在创建
作为参数的 argv，即

121
00:07:36,950 --> 00:07:40,700
将是一个列表，
索引值 0 总是

122
00:07:40,700 --> 00:07:43,218
您的文件名，它总是
将是一个文件名。

123
00:07:43,218 --> 00:07:44,510
事实上，让我告诉你。

124
00:07:44,510 --> 00:07:47,150
让我先保存这个。

125
00:07:47,150 --> 00:07:49,190
我不会执行这个文件。

126
00:07:49,190 --> 00:07:54,830
我只会去
Python3，所以Python3，

127
00:07:54,830 --> 00:07:58,850
我会说 import
sys，只是为了向您展示

128
00:07:58,850 --> 00:08:00,360
它创建一个列表。

129
00:08:00,360 --> 00:08:04,685
所以导入 sys，让我们
说 abc 等于 sys.argv。

130
00:08:07,455 --> 00:08:15,150
现在，如果我执行 sys.argv，您
会看到它是一个列表，

131
00:08:15,150 --> 00:08:17,580
这是一个空列表。

132
00:08:17,580 --> 00:08:23,390
所以索引值 0 总是
是你的文件名，所以

133
00:08:23,390 --> 00:08:25,850
无论您的脚本名称是什么。

134
00:08:25,850 --> 00:08:28,400
所以现在，它
显示为空，

135
00:08:28,400 --> 00:08:31,490
因为我还没有
真正创建文件。

136
00:08:31,490 --> 00:08:38,090
但是对于这个，
猫基本——

137
00:08:38,090 --> 00:08:39,409
我相信是猫。

138
00:08:39,409 --> 00:08:40,770
让我们退出。

139
00:08:40,770 --> 00:08:42,440
所以如果我做 cat basic——

140
00:08:42,440 --> 00:08:48,410
所以这个文件，文件
name是basic_sys_arg.py。

141
00:08:48,410 --> 00:08:55,280
所以在这里，如果我真的添加
命令 sys.argv 你会看到

142
00:08:55,280 --> 00:09:01,460
列表中的第一个索引值
0将是

143
00:09:01,460 --> 00:09:05,390
basic_sys_argv.py。

144
00:09:05,390 --> 00:09:09,620
并且索引值 1 将是我提供的输入。

145
00:09:09,620 --> 00:09:13,790
索引值 2 将是我为年龄提供的
输入。

146
00:09:13,790 --> 00:09:15,110
让我们执行这个。

147
00:09:15,110 --> 00:09:18,770
看看
this和input函数的区别。

148
00:09:18,770 --> 00:09:21,770
在输入函数中，我
正在执行脚本，

149
00:09:21,770 --> 00:09:25,580
然后脚本正在等待
您提供输入。

150
00:09:25,580 --> 00:09:38,400
现在我只能说 Python3，如果
我可以拼写正确的话，Python3，

151
00:09:38,400 --> 00:09:41,040
和文件名，
脚本名，

152
00:09:41,040 --> 00:09:45,690
然后我提供
输入，Rohit 41。

153
00:09:45,690 --> 00:09:49,770
我在这里提供输入，
它基本上会为我打印出来，

154
00:09:49,770 --> 00:09:53,040
我的名字是 Rohit
，我的年龄是 41。

155
00:09:53,040 --> 00:09:54,250
你看出区别了吗？

156
00:09:54,250 --> 00:09:59,490
我实际上是在给出
论据之前

157
00:09:59,490 --> 00:10:01,480
执行该脚本。

158
00:10:01,480 --> 00:10:04,020
如果你真的想
进入解释器——

159
00:10:04,020 --> 00:10:08,820
假设我想执行这个
文件并且我想进入

160
00:10:08,820 --> 00:10:10,410
口译员——

161
00:10:10,410 --> 00:10:11,910
我什至可以再给
一个论据，

162
00:10:11,910 --> 00:10:14,790
类似于减号
I，基本上

163
00:10:14,790 --> 00:10:16,890
说进去
翻译

164
00:10:16,890 --> 00:10:19,260
执行脚本后。

165
00:10:19,260 --> 00:10:23,010
所以在它执行之后，如果你
看到了，我就是 Python 解释器。

166
00:10:23,010 --> 00:10:29,340
让我们做 sys.argv，让我们
看看里面有什么。

167
00:10:29,340 --> 00:10:34,320
看看这个——所以
sys.argv 创建了一个列表，

168
00:10:34,320 --> 00:10:38,070
和索引值 0 将是您的
文件名，您的脚本名称。

169
00:10:38,070 --> 00:10:41,910
索引值 1 是 Rohit，
是我给出的输入，

170
00:10:41,910 --> 00:10:46,950
并且索引值 2 再次
我给出的输入。

171
00:10:46,950 --> 00:10:49,380
所以这是 sys argv。

172
00:10:49,380 --> 00:10:53,840
现在让我们看一个更大的例子，
让我们看看我们能做什么。

173
00:10:53,840 --> 00:10:57,750
所以我要退出
看看

174
00:10:57,750 --> 00:11:02,340
sys argv 的全部功能

175
00:11:02,340 --> 00:11:05,160
使用我们创建的一些较旧的
脚本。

176
00:11:05,160 --> 00:11:07,245
让我们做 LS 看看
我们有什么脚本。

177
00:11:19,180 --> 00:11:21,390
我们这里有所有实验室的所有这些剪辑


178
00:11:21,390 --> 00:11:22,950
从以前。

179
00:11:22,950 --> 00:11:24,255
让我们选择一个。

180
00:11:33,100 --> 00:11:35,860
让我们使用输入函数，
让我们看看它是什么。

181
00:11:35,860 --> 00:11:39,830
让我们做一个猫来
输入函数。

182
00:11:39,830 --> 00:11:47,050
所以我在这里有一个脚本
，上面写着，

183
00:11:47,050 --> 00:11:50,390
导入 netmiko，导入 getpass。

184
00:11:50,390 --> 00:11:53,800
我正在提供
input call show 命令。

185
00:11:53,800 --> 00:11:57,100
无论我指定什么 show
命令，

186
00:11:57,100 --> 00:12:00,370
它连接到 R1 和 R2，
这是我的两个路由器，

187
00:12:00,370 --> 00:12:04,280
并执行该命令，然后
向我显示该命令。

188
00:12:04,280 --> 00:12:06,100
所以让我们先运行这个
脚本，这个

189
00:12:06,100 --> 00:12:07,750
是我们的脚本
我认为是我们创建的

190
00:12:07,750 --> 00:12:09,560
在较早的视频之一中。

191
00:12:09,560 --> 00:12:11,830
所以让我们执行
脚本看看

192
00:12:11,830 --> 00:12:13,720
input
函数是如何工作的，

193
00:12:13,720 --> 00:12:19,630
然后我们将
脚本修改为sys argv。

194
00:12:19,630 --> 00:12:22,630
所以我会说Python3——

195
00:12:22,630 --> 00:12:27,250
所以我相信我出局了——

196
00:12:27,250 --> 00:12:32,290
并说出 input_function.py。

197
00:12:32,290 --> 00:12:34,540
所以它在问我，显示命令。

198
00:12:34,540 --> 00:12:39,050
我会说 show
IP 接口简介。

199
00:12:39,050 --> 00:12:42,670
现在它向
我询问 R1 的用户名。

200
00:12:42,670 --> 00:12:46,540
我说cisco，密码cisco。

201
00:12:46,540 --> 00:12:52,480
它应该问我，也许，
我们的工具用户名，cisco，

202
00:12:52,480 --> 00:12:53,800
思科。

203
00:12:53,800 --> 00:12:56,650
现在它应该向我显示显示 IP 接口

204
00:12:56,650 --> 00:12:59,270
两个路由器的简介。

205
00:12:59,270 --> 00:13:01,940
这就是输入函数。

206
00:13:01,940 --> 00:13:06,020
没有我进来，它什么也做不了。

207
00:13:06,020 --> 00:13:09,080
因此，让我们将
this 更改为 sys arg。

208
00:13:13,190 --> 00:13:23,220
所以我想说让我们做一个vim input_function.py，

209
00:13:23,220 --> 00:13:30,510
我会去
评论这一行。

210
00:13:30,510 --> 00:13:33,060
所以我不会使用
这条线，所以我不会

211
00:13:33,060 --> 00:13:34,140
使用输入功能。

212
00:13:34,140 --> 00:13:37,140
让我们评论一下。

213
00:13:37,140 --> 00:13:42,860
在这里我会说
import sys，然后

214
00:13:42,860 --> 00:13:44,210
让我们给一个任意的名字。

215
00:13:44,210 --> 00:13:49,460
假设参数
等于 sys.argv。

216
00:13:49,460 --> 00:13:52,250
所以这必须是相同的
名称，完全相同的名称，

217
00:13:52,250 --> 00:13:53,570
系统.argv。

218
00:13:53,570 --> 00:13:56,390
这可以是任何名称。

219
00:13:56,390 --> 00:13:59,390
好的，接下来我要
说，论据是什么

220
00:13:59,390 --> 00:14:00,570
我想提供什么？

221
00:14:00,570 --> 00:14:06,320
所以因为我的函数，或者
我的定义，是使用cmd，

222
00:14:06,320 --> 00:14:09,340
我必须将我的
变量名称命名为 cmd，

223
00:14:09,340 --> 00:14:11,840
因为我不想更改
我的脚本，整个脚本。

224
00:14:11,840 --> 00:14:17,270
所以cmd等于参数，
就是args，

225
00:14:17,270 --> 00:14:20,990
这是这个变量
名称，参数列表编号1。

226
00:14:20,990 --> 00:14:25,730
所以我的list number 0，index
value 0，就是文件名，

227
00:14:25,730 --> 00:14:28,310
和索引值 1
将是输入

228
00:14:28,310 --> 00:14:32,360
我在
执行脚本时提供的。

229
00:14:32,360 --> 00:14:34,250
就是这样，这就是我所需要的。

230
00:14:34,250 --> 00:14:39,840
让我们保存它，然后
让我们执行它。

231
00:14:39,840 --> 00:14:48,950
所以 Python3，输入那个函数，
我会提供输入。

232
00:14:48,950 --> 00:14:57,065
让我们显示IP路由。

233
00:15:01,340 --> 00:15:03,530
再次，它会询问
我的用户名。

234
00:15:03,530 --> 00:15:06,035
我可以提供用户名，
也可以作为输入，

235
00:15:06,035 --> 00:15:07,160
我现在没有这样做。

236
00:15:07,160 --> 00:15:08,840
因为我的脚本
并不是真正的模块化，

237
00:15:08,840 --> 00:15:11,210
它在问我
用户名，所以我做了

238
00:15:11,210 --> 00:15:12,680
必须提供用户名--

239
00:15:12,680 --> 00:15:14,840
思科，思科。

240
00:15:14,840 --> 00:15:25,390
R2的工具用户名
也是cisco,cisco,

241
00:15:25,390 --> 00:15:27,170
它为我执行。

242
00:15:27,170 --> 00:15:33,340
所以你看，我实际上在 Python3 文件中提供了
输入

243
00:15:33,340 --> 00:15:38,860
名称和输入信息
在执行脚本时，

244
00:15:38,860 --> 00:15:40,210
所以这是系统 argv。

245
00:15:40,210 --> 00:15:41,540
让我们看另一个例子。

246
00:15:41,540 --> 00:15:43,540
这不是一个很好的例子，
因为我实际上是

247
00:15:43,540 --> 00:15:45,310
在开始时提供用户名
。

248
00:15:45,310 --> 00:15:47,267
让我们再看一个。

249
00:15:47,267 --> 00:15:48,475
让我们看看我们有什么文件。

250
00:15:51,220 --> 00:15:54,580
那么让我们看看rohit_2.py是什么，
我不知道那是什么。

251
00:15:54,580 --> 00:15:55,315
让我们做一只猫——

252
00:15:57,940 --> 00:15:59,590
我相信这是我们必须


253
00:15:59,590 --> 00:16:01,220
在之前的实验室里做过。

254
00:16:01,220 --> 00:16:03,070
让我们做 rohit_2.py。

255
00:16:08,070 --> 00:16:19,580
好的，所以这里
我有一个脚本，

256
00:16:19,580 --> 00:16:23,480
正在导入 netmiko，
正在导入 getpass，

257
00:16:23,480 --> 00:16:26,360
它有 import readline 来做
退格并进行更改

258
00:16:26,360 --> 00:16:27,950
如果你犯了一个错误。

259
00:16:27,950 --> 00:16:29,930
它要求两个命令。

260
00:16:29,930 --> 00:16:32,030
命令等于输入。

261
00:16:32,030 --> 00:16:34,850
输入要显示的路由器显示命令
。

262
00:16:34,850 --> 00:16:38,010
我相信这是我们在上一个视频中所做的
。

263
00:16:38,010 --> 00:16:39,500
所以这是要求
两个输入，

264
00:16:39,500 --> 00:16:42,890
一个是路由器命令，
一个是防火墙命令

265
00:16:42,890 --> 00:16:45,360
你想显示的。

266
00:16:45,360 --> 00:16:47,090
然后它执行
函数，

267
00:16:47,090 --> 00:16:49,220
基于您键入的任何
命令。

268
00:16:49,220 --> 00:16:53,270
所以对于路由器，如果你
输入show IP interface brief，

269
00:16:53,270 --> 00:16:56,330
它会执行这个
一个，这是给路由器的。

270
00:16:56,330 --> 00:17:00,080
而对于防火墙，即
名称是command_firewall，

271
00:17:00,080 --> 00:17:04,609
在这里被调用，this
将执行那个函数。

272
00:17:04,609 --> 00:17:07,800
对于用户名，我再次
提供输入。

273
00:17:07,800 --> 00:17:09,810
所以让我们做一件事。

274
00:17:09,810 --> 00:17:12,260
让我们尝试修改它。

275
00:17:12,260 --> 00:17:17,770
我会说 vim rohit_2.py。

276
00:17:20,770 --> 00:17:29,060
我们先往下
import sys，所以你import sys。

277
00:17:29,060 --> 00:17:35,030
假设 arguments
等于 sys.argv，

278
00:17:35,030 --> 00:17:37,985
然后我会说命令。

279
00:17:37,985 --> 00:17:39,860
所以确保你使用
同名，因为我

280
00:17:39,860 --> 00:17:42,675
不想改变我的
定义，我的功能。

281
00:17:42,675 --> 00:17:44,300
所以我将
使用相同的名称。

282
00:17:44,300 --> 00:17:46,550
我会在这里评论
这两行。

283
00:17:46,550 --> 00:17:59,120
所以命令等于
args 索引值

284
00:17:59,120 --> 00:18:02,570
1，这将
用于路由器。

285
00:18:02,570 --> 00:18:10,010
那么 command_firewall
等于 args 索引值 2。

286
00:18:10,010 --> 00:18:13,520
让我们去评论这两个
，我们不需要那个。

287
00:18:20,320 --> 00:18:22,110
所以这两行
被注释掉了，

288
00:18:22,110 --> 00:18:23,650
所以它不会
被执行。

289
00:18:23,650 --> 00:18:28,890
所以我要提供
命令的输入，

290
00:18:28,890 --> 00:18:34,650
我将为 command_firewall 提供
输入，

291
00:18:34,650 --> 00:18:40,010
这将在此处和此处分别执行
。

292
00:18:40,010 --> 00:18:45,420
我认为这应该足够了。

293
00:18:45,420 --> 00:18:51,855
让我们也向下滚动。

294
00:18:59,000 --> 00:19:03,180
让我们保存它，
现在我们可以执行它了。

295
00:19:03,180 --> 00:19:08,330
所以我会说
Python3 rohit_2.py，

296
00:19:08,330 --> 00:19:09,870
我将提供意见。

297
00:19:09,870 --> 00:19:16,100
所以第一个命令输入是
路由器，所以显示IP

298
00:19:16,100 --> 00:19:19,790
界面简介。

299
00:19:19,790 --> 00:19:23,010
第二个输入
用于防火墙，

300
00:19:23,010 --> 00:19:24,740
所以这将是展示 -

301
00:19:27,620 --> 00:19:30,860
让我们为防火墙显示路由
。

302
00:19:30,860 --> 00:19:32,930
就是这样，这就是我所需要的。

303
00:19:32,930 --> 00:19:38,660
用户名、cisco、
密码、cisco等

304
00:19:38,660 --> 00:19:42,200
为我执行整个
脚本。

305
00:19:42,200 --> 00:19:44,930
它应该向我显示
显示 IP 界面

306
00:19:44,930 --> 00:19:47,360
路由器
1、路由器2和它的简介

307
00:19:47,360 --> 00:19:50,075
应该向我展示防火墙的 show
路由。

308
00:19:53,680 --> 00:19:55,960
这是显示IP
接口简介四个R1，

309
00:19:55,960 --> 00:19:58,750
这是路由器 2 的显示 IP
接口简介，

310
00:19:58,750 --> 00:20:03,650
最后一个应该是防火墙的
显示路由。

311
00:20:03,650 --> 00:20:07,210
所以你看， sys
argv 非常了不起，

312
00:20:07,210 --> 00:20:10,180
您实际上可以
提供信息，

313
00:20:10,180 --> 00:20:14,140
在您
实际执行脚本之前提供输入。

314
00:20:14,140 --> 00:20:17,170
但是，
这里有一个问题。

315
00:20:17,170 --> 00:20:19,540
假设我有
运行脚本

316
00:20:19,540 --> 00:20:21,460
我不得不把这个文件
交给某人，

317
00:20:21,460 --> 00:20:24,100
他真的不知道
在这里输入什么。

318
00:20:24,100 --> 00:20:25,660
论据是什么？

319
00:20:25,660 --> 00:20:30,070
他不会真的知道，因为
我作为一个技术人员，

320
00:20:30,070 --> 00:20:32,170
是的，我知道，好的，我已经
写好了剧本，

321
00:20:32,170 --> 00:20:36,700
我知道，好的，我应该
做第 1 个参数是 show

322
00:20:36,700 --> 00:20:38,800
IP接口简介
用于路由器，

323
00:20:38,800 --> 00:20:41,530
参数号 2
用于防火墙。

324
00:20:41,530 --> 00:20:44,810
如果我真的去
做这样的事情怎么办？

325
00:20:44,810 --> 00:20:53,962
比方说 Python3 rohit_2.py，
我说显示路线，

326
00:20:53,962 --> 00:20:55,420
认为这
是防火墙，

327
00:20:55,420 --> 00:20:57,490
参数号 1
是防火墙，

328
00:20:57,490 --> 00:21:02,590
然后我做显示
IP接口简介，

329
00:21:02,590 --> 00:21:05,320
认为这是路由器。

330
00:21:05,320 --> 00:21:08,410
但如果你还记得，
第 1 个论点

331
00:21:08,410 --> 00:21:11,500
用于命令，
用于路由器，

332
00:21:11,500 --> 00:21:14,810
参数编号
2 用于防火墙。

333
00:21:14,810 --> 00:21:17,620
所以这个命令将
在路由器上不起作用。

334
00:21:17,620 --> 00:21:19,690
此命令不会
在防火墙上工作。

335
00:21:19,690 --> 00:21:21,610
让我们看看发生了什么。

336
00:21:21,610 --> 00:21:24,910
我做cisco，我做cisco。

337
00:21:29,130 --> 00:21:35,380
所以当我执行这个时，
我不知道是不是

338
00:21:35,380 --> 00:21:36,710
会给我输出。

339
00:21:36,710 --> 00:21:40,060
它可能会给我一个错误，因为
命令不能真正

340
00:21:40,060 --> 00:21:41,860
在那些路由器上执行。

341
00:21:41,860 --> 00:21:44,470
如果你看到不明确的
命令，那么输出

342
00:21:44,470 --> 00:21:48,245
是模棱两可的命令，我无法真正给出。

343
00:21:48,245 --> 00:21:49,870
并且节目IP
界面简介没有

344
00:21:49,870 --> 00:21:54,070
存在于 ASA
防火墙上，该命令

345
00:21:54,070 --> 00:21:57,310
是显示接口 IP 简介。

346
00:21:57,310 --> 00:22:01,450
所以你看，使用
sys argv，这个人

347
00:22:01,450 --> 00:22:03,460
谁在执行
脚本，他有

348
00:22:03,460 --> 00:22:07,060
真正知道哪个是参数 1，哪个是参数 2，

349
00:22:07,060 --> 00:22:09,230
他必须真正知道这一点。

350
00:22:09,230 --> 00:22:13,580
所以还有另一个
可用的功能，

351
00:22:13,580 --> 00:22:15,760
这被称为arg pass。

352
00:22:15,760 --> 00:22:18,610
所以这比 sys argv 更好
，

353
00:22:18,610 --> 00:22:21,490
因为我实际上可以
定义论点。

354
00:22:21,490 --> 00:22:24,740
那么让我给你一个
例子，一个简单的例子。

355
00:22:24,740 --> 00:22:30,410
假设我去任何路由器，
假设我去路由器 1，

356
00:22:30,410 --> 00:22:34,070
我正在尝试
运行一些命令，

357
00:22:34,070 --> 00:22:36,710
假设我正在尝试
运行 show 命令，

358
00:22:36,710 --> 00:22:39,890
但我真的不记得
命令是什么，

359
00:22:39,890 --> 00:22:42,530

显示之后的语法是什么，我该怎么办？

360
00:22:42,530 --> 00:22:44,630
我确实有帮助，像问号之类的东西。

361
00:22:44,630 --> 00:22:45,500
它给了我什么？

362
00:22:45,500 --> 00:22:49,620
它给了我所有的论点
和一些关于它的描述，

363
00:22:49,620 --> 00:22:51,530
所以arg pass就是这样。

364
00:22:51,530 --> 00:22:53,750
所以一个
真的不知道的人

365
00:22:53,750 --> 00:22:56,150
脚本中的内容，
这是参数 1，

366
00:22:56,150 --> 00:22:58,490
是论点2，他能做的就是他

367
00:22:58,490 --> 00:23:01,820
可以查看该脚本的帮助
他会看到，

368
00:23:01,820 --> 00:23:06,830
好的，参数号 1 是
this，描述​​是

369
00:23:06,830 --> 00:23:09,950
对于路由器，参数
数字 2 是为此，

370
00:23:09,950 --> 00:23:12,980
它用于防火墙。

371
00:23:12,980 --> 00:23:14,810
所以通过 arg pass，我可以做到这一点。

372
00:23:14,810 --> 00:23:18,920
使用 sys argv，真的很好，但我真的

373
00:23:18,920 --> 00:23:21,590
必须知道
论点是什么

374
00:23:21,590 --> 00:23:26,360
你的论点的顺序是什么。

375
00:23:26,360 --> 00:23:28,800
所以这个系统 argv。

376
00:23:28,800 --> 00:23:33,500
在我的下一个视频中，我们
将专注于 arg 传递。

377
00:23:33,500 --> 00:23:36,320
现在，在结束
这个视频之前，我还

378
00:23:36,320 --> 00:23:39,350
想向您展示如何
甚至添加用户名

379
00:23:39,350 --> 00:23:45,240
和密码作为一个
变量，所以作为一个参数。

380
00:23:45,240 --> 00:23:48,380
所以早些时候，当我们运行脚本时，


381
00:23:48,380 --> 00:23:54,140
我们给了 Python3 rohit_2.py，然后我们提供了两个参数，

382
00:23:54,140 --> 00:23:56,510
一个是路由器的show IP interface
简介，

383
00:23:56,510 --> 00:23:59,480
然后是防火墙的 show
路由。

384
00:23:59,480 --> 00:24:02,990
但是，我们仍然必须手动输入用户名密码。

385
00:24:02,990 --> 00:24:05,240
所以如果你愿意，你甚至可以
添加用户名密码

386
00:24:05,240 --> 00:24:06,200
论据内。

387
00:24:06,200 --> 00:24:10,100
所以我能做的就是，
让我们回到我的脚本

388
00:24:10,100 --> 00:24:11,540
rohit_2.py。

389
00:24:19,590 --> 00:24:24,060
而这里我有
论据之一，它

390
00:24:24,060 --> 00:24:26,490
是路由器的显示命令
。

391
00:24:26,490 --> 00:24:29,730
参数二是防火墙的 show
命令。

392
00:24:29,730 --> 00:24:32,610
我会向下滚动，
将我的用户名作为输入，

393
00:24:32,610 --> 00:24:34,030
我们将对此发表评论。

394
00:24:34,030 --> 00:24:40,060
所以在这里我要做的就是评论用户名。

395
00:24:40,060 --> 00:24:44,310
所以我会评论我的
用户名，评论我的密码，

396
00:24:44,310 --> 00:24:48,990
并创建一个新用户名。

397
00:24:48,990 --> 00:24:51,870
所以用户名等于，
我会说，

398
00:24:51,870 --> 00:24:58,290
args 为索引值
3，密码

399
00:24:58,290 --> 00:25:03,390
等于 args 索引值 4。

400
00:25:03,390 --> 00:25:05,370
就是这样，这就是我所需要的。

401
00:25:05,370 --> 00:25:06,960
让我们保存它。

402
00:25:06,960 --> 00:25:14,610
现在，如果我说 Python3
rohit_2.py 然后执行——

403
00:25:14,610 --> 00:25:16,330
索引值 1
是一个路由器命令，

404
00:25:16,330 --> 00:25:19,560
让我们做一个显示IP
接口简介。

405
00:25:19,560 --> 00:25:28,260
索引值 2 是防火墙
命令，让我们显示路由。

406
00:25:28,260 --> 00:25:31,950
索引值 3 是
用户名，因此是 cisco。

407
00:25:31,950 --> 00:25:35,130
索引值 4 是
密码，cisco。

408
00:25:35,130 --> 00:25:35,970
就是这样。

409
00:25:35,970 --> 00:25:39,240
我执行此操作，它
不会问你任何事情。

410
00:25:39,240 --> 00:25:41,010
我已经
提供了用户名，

411
00:25:41,010 --> 00:25:42,630
我已经
给了密码，

412
00:25:42,630 --> 00:25:45,752
我已经给出了路由器的 show
命令，

413
00:25:45,752 --> 00:25:47,710
我已经给出了防火墙的 show
命令。

414
00:25:47,710 --> 00:25:51,600
所以它应该执行所有的事情
没有我进去和给予

415
00:25:51,600 --> 00:25:53,620
一些信息。

416
00:25:53,620 --> 00:25:55,590
所以你现在看到了，它有
显示IP接口

417
00:25:55,590 --> 00:25:58,230
路由器简介
1，路由器2，

418
00:25:58,230 --> 00:26:01,480
然后显示防火墙的路由。

419
00:26:01,480 --> 00:26:04,140
所以你看，你甚至可以提供
用户名和密码

420
00:26:04,140 --> 00:26:05,850
使用系统 argv。

421
00:26:05,850 --> 00:26:08,160
但是，我再次
重复一遍，

422
00:26:08,160 --> 00:26:10,110
只有一个问题——

423
00:26:10,110 --> 00:26:12,030

执行脚本的人，

424
00:26:12,030 --> 00:26:15,960
他必须知道我有
输入用户名密码

425
00:26:15,960 --> 00:26:18,060
在索引值 3 和 4 中。

426
00:26:18,060 --> 00:26:20,670
所以我得先给
router命令，然后给

427
00:26:20,670 --> 00:26:23,010
防火墙命令，
然后给出用户名，

428
00:26:23,010 --> 00:26:24,270
然后给出密码。

429
00:26:24,270 --> 00:26:31,050
我不能做类似
Python3 rohit_2.py、空格、

430
00:26:31,050 --> 00:26:34,380
cisco，然后
cisco作为密码，

431
00:26:34,380 --> 00:26:37,650
然后是路由器命令，
然后是防火墙命令。

432
00:26:37,650 --> 00:26:42,240
因为如果我把
cisco放在这里，脚本

433
00:26:42,240 --> 00:26:45,540
将在路由器上运行 cisco 命令，因为索引值

434
00:26:45,540 --> 00:26:48,600
1 被映射为路由器的
定义，

435
00:26:48,600 --> 00:26:51,300
并且索引值 2
与定义映射

436
00:26:51,300 --> 00:26:53,080
对于防火墙。

437
00:26:53,080 --> 00:26:54,540
所以必须按这个顺序。

438
00:26:54,540 --> 00:26:56,820
这是 sys arg 的唯一
问题。

439
00:26:56,820 --> 00:27:02,180
使用 arg pass，我可以指定
一个参数说，好的，你

440
00:27:02,180 --> 00:27:02,820
知道什么？

441
00:27:02,820 --> 00:27:07,110
对于路由器，将参数
设为，假设 r 减去 r。

442
00:27:07,110 --> 00:27:11,910
所以我会做类似
这样的事情，我会做——

443
00:27:11,910 --> 00:27:13,623
没关系
我按什么顺序，

444
00:27:13,623 --> 00:27:15,290
但我会做
这样的事情。

445
00:27:15,290 --> 00:27:17,082
我只是要给你一个快速预览。

446
00:27:17,082 --> 00:27:20,310
因此，假设用户名 cisco 减去 u
。

447
00:27:20,310 --> 00:27:23,940
减去 p 表示密码，cisco。

448
00:27:23,940 --> 00:27:26,910
然后让我们说路由器命令的减号
r，

449
00:27:26,910 --> 00:27:31,080
显示 IP 接口简介。

450
00:27:31,080 --> 00:27:38,435
然后为防火墙减去 f，
我会说显示路由。

451
00:27:38,435 --> 00:27:39,810
所以我会做这样的事情

452
00:27:39,810 --> 00:27:42,570
在 arg pass 中，这要简单得多
因为现在你

453
00:27:42,570 --> 00:27:46,950
可以查看帮助并查看
什么参数是什么。

454
00:27:46,950 --> 00:27:49,960

我放它们的顺序无关紧要。

455
00:27:49,960 --> 00:27:54,690
与 sys arg 不同，它
必须以正确的顺序排列。

456
00:27:54,690 --> 00:27:57,850
好的，所以我希望这个视频
对你有用，