1
00:00:03,472 --> 00:00:09,920
[标志嗖嗖声]

2
00:00:11,410 --> 00:00:13,810
您好，欢迎来到 INE。

3
00:00:13,810 --> 00:00:17,030
今天，在这个视频中，我们将
看看内置函数。

4
00:00:17,030 --> 00:00:18,700
现在，我们已经了解了
函数

5
00:00:18,700 --> 00:00:20,530
在一些早期的视频中。

6
00:00:20,530 --> 00:00:23,650
现在的功能基本上是当
你想执行一个脚本

7
00:00:23,650 --> 00:00:28,810
或者重用一个脚本，而你
想要执行一些事情。

8
00:00:28,810 --> 00:00:30,620
那时你
会使用一个函数。

9
00:00:30,620 --> 00:00:33,470
但是，还有一个内置的
功能也可用。

10
00:00:33,470 --> 00:00:35,440

内置函数的重点

11
00:00:35,440 --> 00:00:37,750
是您想要用户输入的时候。

12
00:00:37,750 --> 00:00:40,970
根据用户输入，
它会执行一个动作。

13
00:00:40,970 --> 00:00:43,990
所以内置函数
是可用的——再次，

14
00:00:43,990 --> 00:00:46,120
一个普通函数
我们正在使用定义

15
00:00:46,120 --> 00:00:47,720
可以做完全相同的事情。

16
00:00:47,720 --> 00:00:49,850
然而，这只是一种
不同的方式。

17
00:00:49,850 --> 00:00:52,390
那么今天，我将向您展示
内置函数。

18
00:00:52,390 --> 00:00:55,060
让我们看看一些例子
我们实际上是如何做到的

19
00:00:55,060 --> 00:00:57,470
使用内置函数。

20
00:00:57,470 --> 00:01:00,520
所以我要做的是
我会

21
00:01:00,520 --> 00:01:04,390
创建一个脚本，
这将是

22
00:01:04,390 --> 00:01:06,520
接受用户的输入。

23
00:01:06,520 --> 00:01:11,050
假设您
要计算

24
00:01:11,050 --> 00:01:13,960
交换机上的
接口总数，

25
00:01:13,960 --> 00:01:15,770
假设您
有 10 个开关。

26
00:01:15,770 --> 00:01:20,320
所以如果我输入 10，那
开关的数量等于 10

27
00:01:20,320 --> 00:01:25,840
并且接口的数量是，
比方说，每个交换机 48 个，

28
00:01:25,840 --> 00:01:30,460
它基本上应该给我
有480个接口

29
00:01:30,460 --> 00:01:31,508
需要配置。

30
00:01:31,508 --> 00:01:32,800
事实上，让我告诉你。

31
00:01:32,800 --> 00:01:35,290
是的，我们可以通过
一个正常的定义来做到这一点，

32
00:01:35,290 --> 00:01:37,110
但今天，我们不会那样做。

33
00:01:37,110 --> 00:01:38,800
我们会这样做——我们
基本上会使用

34
00:01:38,800 --> 00:01:41,000
内置输入功能。

35
00:01:41,000 --> 00:01:44,270
所以让我，事实上，
创建一个变量。

36
00:01:44,270 --> 00:01:49,790
假设开关等于，
我会说输入。

37
00:01:49,790 --> 00:01:52,090
所以如果你想使用
内置功能，

38
00:01:52,090 --> 00:01:54,760
输入函数，
你会说输入，

39
00:01:54,760 --> 00:01:58,840
然后在你的括号中，
你可以给出一个字符串

40
00:01:58,840 --> 00:01:59,875
那 -

41
00:01:59,875 --> 00:02:04,060
字符串基本上
将确定

42
00:02:04,060 --> 00:02:06,830
要问什么问题
您的意见。

43
00:02:06,830 --> 00:02:19,980
所以假设我想问
有多少个开关

44
00:02:19,980 --> 00:02:23,290
在数据中心。

45
00:02:23,290 --> 00:02:30,040
这就是我想问我的用户的问题。

46
00:02:30,040 --> 00:02:36,060
所以我所做的就是说开关
等于输入，然后是一个字符串。

47
00:02:36,060 --> 00:02:40,320
字符串只是确定
要问什么问题。

48
00:02:40,320 --> 00:02:45,210
因为我在这里输入了
，所以我的 Python 解释器

49
00:02:45,210 --> 00:02:49,135
将等待
用户的输入。

50
00:02:49,135 --> 00:02:50,010
让我告诉你。

51
00:02:50,010 --> 00:02:58,060
我将复制它并返回
我的 Python 解释器，

52
00:02:58,060 --> 00:03:01,938
Python 3，我将粘贴
开关等于--

53
00:03:01,938 --> 00:03:03,730
你现在可以看到，它
在问我一个问题。

54
00:03:03,730 --> 00:03:06,460

数据中心有多少台交换机？

55
00:03:06,460 --> 00:03:10,100
假设我指定 10。

56
00:03:10,100 --> 00:03:13,120
点击 Enter，然后，
现在它有了那个输入。

57
00:03:13,120 --> 00:03:15,063
它有那个信息。

58
00:03:15,063 --> 00:03:16,730
我们在用这些信息做什么
？

59
00:03:16,730 --> 00:03:19,450
是的，我们可以根据输入执行
一些事情。

60
00:03:19,450 --> 00:03:20,980
在这一点
时间，我所做的一切

61
00:03:20,980 --> 00:03:24,550
我正在接受用户的
输入吗？

62
00:03:24,550 --> 00:03:26,830
让我们回到我的开关。

63
00:03:26,830 --> 00:03:34,060
事实上，您还应该做一件事。

64
00:03:34,060 --> 00:03:37,420
假设您的
输入是一个整数，

65
00:03:37,420 --> 00:03:42,670
现在，如果我执行类型 of
switches，这是我的变量，

66
00:03:42,670 --> 00:03:44,930
你会看到
它是一个字符串。

67
00:03:44,930 --> 00:03:47,260
现在，我们进入了。

68
00:03:47,260 --> 00:03:49,750
我们已经放了——用户
基本上放了输入

69
00:03:49,750 --> 00:03:51,350
为 10，这是一个整数。

70
00:03:51,350 --> 00:03:55,960
所以如果你想使用那个
值来做一些动作，

71
00:03:55,960 --> 00:03:58,900
比如计算一下
有多少接口

72
00:03:58,900 --> 00:04:01,300
每个开关和总
开关数量

73
00:04:01,300 --> 00:04:04,060
乘以接口，
那么你需要

74
00:04:04,060 --> 00:04:05,840
将其转换为整数。

75
00:04:05,840 --> 00:04:10,240
所以我们能做的就是回到
这里再做一个变量。

76
00:04:10,240 --> 00:04:17,380
假设，
开关的数量等于整数值

77
00:04:17,380 --> 00:04:20,180
的开关。

78
00:04:20,180 --> 00:04:26,440
所以无论用户
输入什么输入，比如说，如果他输入 10，

79
00:04:26,440 --> 00:04:28,850
那么它就变成了
一个整数值。

80
00:04:28,850 --> 00:04:35,350
因此，让我们按 Enter 并返回
回到我的 Python 解释器。

81
00:04:35,350 --> 00:04:36,520
让我们再次粘贴。

82
00:04:36,520 --> 00:04:38,660
它会再次问我
这个问题。

83
00:04:38,660 --> 00:04:43,640
所以很明显，这个
不应该在这里。

84
00:04:43,640 --> 00:04:45,770
我应该先放
信息。

85
00:04:45,770 --> 00:04:49,840
假设我输入了 10，现在
它已经存储了该信息

86
00:04:49,840 --> 00:04:52,150
该输入存储在
开关中。

87
00:04:52,150 --> 00:04:54,370
现在，如果我输入——

88
00:04:54,370 --> 00:04:58,030
现在，比方说，如果我输入——

89
00:04:58,030 --> 00:04:59,650
等等，等等。

90
00:04:59,650 --> 00:05:06,460
我应该只复制 10 个，
假设我现在输入--

91
00:05:06,460 --> 00:05:09,625
让我们回去
复制一下。

92
00:05:16,140 --> 00:05:21,090
我是说 num_switches
等于整数值

93
00:05:21,090 --> 00:05:23,670
开关的输入。

94
00:05:23,670 --> 00:05:29,490
所以这意味着如果我做
类型的num_switches，

95
00:05:29,490 --> 00:05:32,710
你会看到它
是整数类。

96
00:05:32,710 --> 00:05:35,730
现在我能做什么，如果我愿意，我可以做一些计算。

97
00:05:35,730 --> 00:05:39,570
假设我知道每个
switch有48个接口，那么我

98
00:05:39,570 --> 00:05:47,160
可以做类似
接口数量等于的事情，

99
00:05:47,160 --> 00:05:54,430
我可以说
num_switches 乘以 48。

100
00:05:54,430 --> 00:05:58,800
所以现在我已经存储了
num_interfaces的信息

101
00:05:58,800 --> 00:06:01,950
等于 num_switches 乘以 48。

102
00:06:01,950 --> 00:06:03,660
这变成了 48 的 10 倍。

103
00:06:03,660 --> 00:06:05,020
我现在可以打印了。

104
00:06:05,020 --> 00:06:07,000
现在，如果你还记得
格式字符串，

105
00:06:07,000 --> 00:06:09,667
我可以使用格式字符串或
我可以使用内置格式

106
00:06:09,667 --> 00:06:10,920
打印东西的方法。

107
00:06:10,920 --> 00:06:15,660
所以我可以说 print
格式字符串

108
00:06:15,660 --> 00:06:24,280
我可以说
总共有 10 个开关。

109
00:06:24,280 --> 00:06:25,920
所以我们要打印 10 个开关。

110
00:06:25,920 --> 00:06:28,200
10 个开关将
基于输入

111
00:06:28,200 --> 00:06:30,030
用户提供的。

112
00:06:30,030 --> 00:06:33,610
所以总共有 10 个开关。

113
00:06:33,610 --> 00:06:36,450
所以这将是——

114
00:06:36,450 --> 00:06:38,730
我相信它应该
是大括号，

115
00:06:38,730 --> 00:06:43,320
我们会为 num_switches 调用
。

116
00:06:46,790 --> 00:06:54,620
接口总数
是——

117
00:06:54,620 --> 00:07:02,320
我会在里面调用
num_interfaces。

118
00:07:04,900 --> 00:07:07,030
让我们关闭我的括号。

119
00:07:07,030 --> 00:07:10,090
我相信我什至应该
有双引号，

120
00:07:10,090 --> 00:07:11,630
那应该打印出来。

121
00:07:11,630 --> 00:07:15,760
所以它说
总共有10个开关，

122
00:07:15,760 --> 00:07:19,490

接口总数为480个。

123
00:07:19,490 --> 00:07:25,040
因此，您会根据输入看到我正在提供该信息。

124
00:07:25,040 --> 00:07:28,040
所以让我们把
这个放到一个脚本中。

125
00:07:28,040 --> 00:07:30,890
所以我会复制这个。

126
00:07:30,890 --> 00:07:35,380
让我们将这两件事
复制到我的脚本中。

127
00:07:35,380 --> 00:07:39,640
让我们在此处按 Enter，
然后我们复制它。

128
00:07:43,920 --> 00:07:47,325
让我们来看看这个。

129
00:07:50,000 --> 00:07:54,040
所以首先，我会
获取我的信息。

130
00:08:02,310 --> 00:08:06,250
让我们回到我的
脚本并执行它。

131
00:08:06,250 --> 00:08:10,293
所以现在，我是说
那里有多少个开关。

132
00:08:10,293 --> 00:08:11,710
现在，很明显，我
去追溯

133
00:08:11,710 --> 00:08:13,170
因为我粘贴了
整个内容。

134
00:08:13,170 --> 00:08:16,440
您必须一次粘贴一个
因为我们

135
00:08:16,440 --> 00:08:18,510
必须得到一个输入。

136
00:08:18,510 --> 00:08:20,190
用户需要输入。

137
00:08:20,190 --> 00:08:23,430
所以不要将
整个东西粘贴在一起。

138
00:08:23,430 --> 00:08:26,700
您应该做的是
只需粘贴第一个。

139
00:08:26,700 --> 00:08:27,735
它会问一个问题。

140
00:08:30,860 --> 00:08:34,510
它会问你一个问题。

141
00:08:34,510 --> 00:08:35,309
让我们复制它。

142
00:08:39,440 --> 00:08:46,238
现在，根据我的输入，我会
说出有多少个开关

143
00:08:46,238 --> 00:08:47,030
在数据中心？

144
00:08:47,030 --> 00:08:49,280
假设我说100。

145
00:08:49,280 --> 00:08:52,100
然后我可以使用
那个输入信息

146
00:08:52,100 --> 00:08:53,510
计算某事。

147
00:08:53,510 --> 00:08:56,030
那我只能说，
好的，改变值

148
00:08:56,030 --> 00:08:58,610
用户输入的内容
成一个整数，

149
00:08:58,610 --> 00:09:01,740
然后进行数学计算
。

150
00:09:01,740 --> 00:09:05,900
然后显示可能有多少
开关

151
00:09:05,900 --> 00:09:08,480
在数据中心和多少
接口总数

152
00:09:08,480 --> 00:09:09,020
在那里。

153
00:09:09,020 --> 00:09:12,880
所以我可以回去
现在打印那个，

154
00:09:12,880 --> 00:09:16,060
上面说
总共有 100 个开关

155
00:09:16,060 --> 00:09:20,620

接口总数为4800个。

156
00:09:20,620 --> 00:09:27,340
让我们看另一个示例
我们将在其中实际使用它

157
00:09:27,340 --> 00:09:29,150
做一些有趣的事情。

158
00:09:29,150 --> 00:09:31,970
所以，我的意思是，这
只是一个基本示例。

159
00:09:31,970 --> 00:09:37,310
你一定认为这
真的没有任何意义，

160
00:09:37,310 --> 00:09:39,280
但这确实很有意义。

161
00:09:39,280 --> 00:09:44,080
我将向您展示另一个
我们为什么要使用它的示例。

162
00:09:44,080 --> 00:09:48,970
假设您有
50 个路由器并且您

163
00:09:48,970 --> 00:09:52,690
想要使用 netmiko 连接到那些
路由器。

164
00:09:52,690 --> 00:09:55,300
所以你会想要连接
到那些路由器，SSH

165
00:09:55,300 --> 00:10:00,472
到那些路由器，
你想打印--

166
00:10:00,472 --> 00:10:05,230
您想查看 show
IP 接口命令，

167
00:10:05,230 --> 00:10:07,400
显示 IP 接口简介。

168
00:10:07,400 --> 00:10:11,660
所以你想看
也许是路由表。

169
00:10:11,660 --> 00:10:12,910
它可能是路由表。

170
00:10:12,910 --> 00:10:17,170
可能是节目IP
接口简介或节目

171
00:10:17,170 --> 00:10:20,150
接口状态，无论
你想在路由器上看到什么。

172
00:10:20,150 --> 00:10:24,640
所以根据输入，如果
我输入，我想看R1。

173
00:10:24,640 --> 00:10:28,510
所以如果路由器
主机名是R1，那么

174
00:10:28,510 --> 00:10:32,140
是的，给我看看R1的
路由表。

175
00:10:32,140 --> 00:10:35,110
所以我可以用输入命令来做到这一点。

176
00:10:35,110 --> 00:10:37,220
让我告诉你。

177
00:10:37,220 --> 00:10:42,220
所以我要做的是我将为此编写一个脚本。

178
00:10:42,220 --> 00:10:45,335
让我们删除所有这些，
让我们为此编写一个脚本。

179
00:10:45,335 --> 00:10:46,960
所以我要做的第一件事


180
00:10:46,960 --> 00:10:54,373
是，从 netmiko，我会
说导入 ConnectHandler。

181
00:10:54,373 --> 00:10:57,040
所以我要导入它，然后
然后我会建立连接

182
00:10:57,040 --> 00:10:58,300
到我的路由器。

183
00:10:58,300 --> 00:11:04,120
所以R1等于
ConnectHandler，它

184
00:11:04,120 --> 00:11:05,560
会有IP地址。

185
00:11:05,560 --> 00:11:11,950
我相信 IP 地址是 10.8.102.100。

186
00:11:11,950 --> 00:11:19,240
我的用户名
与 Cisco 相同。

187
00:11:19,240 --> 00:11:25,330
然后我有我的密码，
将等于 Cisco。

188
00:11:25,330 --> 00:11:29,050
我有我的秘密
密码，也是

189
00:11:29,050 --> 00:11:30,910
将等于思科。

190
00:11:30,910 --> 00:11:35,110
然后我有了我的 device_type。

191
00:11:35,110 --> 00:11:37,225
我相信我正在使用 iOS XE。

192
00:11:37,225 --> 00:11:39,940
所以cisco_xe。

193
00:11:39,940 --> 00:11:41,950
这就是我与 R1 的连接。

194
00:11:41,950 --> 00:11:45,800
让我们也连接到 R2。

195
00:11:45,800 --> 00:11:50,448
所以R2，这
会变成103，

196
00:11:50,448 --> 00:11:51,990
其他一切
保持不变。

197
00:11:51,990 --> 00:11:54,480
所以现在我已经
连接到我的路由器了。

198
00:11:54,480 --> 00:11:57,560
现在我可以使用输入了。

199
00:11:57,560 --> 00:12:01,700
我可以使用 input
函数来推导

200
00:12:01,700 --> 00:12:04,520
根据用户输入的内容。

201
00:12:04,520 --> 00:12:08,780
它将连接到路由器
并向我显示路由表

202
00:12:08,780 --> 00:12:09,780
那个路由器的。

203
00:12:09,780 --> 00:12:11,850
所以让我们这样做。

204
00:12:11,850 --> 00:12:20,554
所以我会说 device
等于，让我们说 input--

205
00:12:20,554 --> 00:12:21,820
输入什么？

206
00:12:21,820 --> 00:12:23,830
再次，首先，提出问题。

207
00:12:23,830 --> 00:12:26,930
问题是什么？

208
00:12:26,930 --> 00:12:36,580
你想看哪个路由表
？

209
00:12:36,580 --> 00:12:40,680
这就是我要问的问题，


210
00:12:40,680 --> 00:12:43,930
这将
存储在设备中。

211
00:12:43,930 --> 00:12:45,870
那我要输入什么？

212
00:12:45,870 --> 00:12:52,020
也许我输入了R1，这里
就是这个名字。

213
00:12:52,020 --> 00:12:54,000
所以我会放R1。

214
00:12:54,000 --> 00:12:59,430
所以如果我放R1，那么
命令是什么

215
00:12:59,430 --> 00:13:02,040
我想
发送到路由器？

216
00:13:02,040 --> 00:13:04,140
我想发送显示 IP 路由。

217
00:13:04,140 --> 00:13:09,010
再说一次，我会
说 show 命令。

218
00:13:09,010 --> 00:13:11,040
再说一遍，这只是
任何名称，变量名称。

219
00:13:11,040 --> 00:13:22,620
show 命令等于
所需命令的输入。

220
00:13:22,620 --> 00:13:27,060
比方说希望执行的
命令。

221
00:13:30,900 --> 00:13:32,180
所以我想——

222
00:13:32,180 --> 00:13:33,945
我又问了
一个问题。

223
00:13:33,945 --> 00:13:36,320
因此，我需要用户提供两个输入字符串
。

224
00:13:36,320 --> 00:13:39,320
首先是，你想看哪个路由表？

225
00:13:39,320 --> 00:13:43,010
所以我会根据情况输入 R1
或 R2 或 R3

226
00:13:43,010 --> 00:13:44,660
关于我有多少连接。

227
00:13:44,660 --> 00:13:47,180
所以我现在只有两个
R1和R2。

228
00:13:47,180 --> 00:13:49,010
所以我会放R1。

229
00:13:49,010 --> 00:13:54,080
如果我输入 R1，它会问我的下一个问题是，

230
00:13:54,080 --> 00:13:57,380
您要
执行哪个命令或想要的命令

231
00:13:57,380 --> 00:13:58,580
执行？

232
00:13:58,580 --> 00:14:01,070
我会说显示IP路由。

233
00:14:01,070 --> 00:14:04,070
所以如果我确实显示
IP路由，那么它

234
00:14:04,070 --> 00:14:06,590
应该连接到路由器。

235
00:14:06,590 --> 00:14:10,250
发送该命令 show
IP route 到该路由器

236
00:14:10,250 --> 00:14:12,150
并向我展示。

237
00:14:12,150 --> 00:14:16,940
那么我基本上可以去
创建一个 If 语句。

238
00:14:16,940 --> 00:14:23,210
也许一个条件
说如果 device.lower，所以

239
00:14:23,210 --> 00:14:26,660
小写，因为您
可以将 R1 输入为大写

240
00:14:26,660 --> 00:14:28,440
或者您可以将 r1 键入为小写。

241
00:14:28,440 --> 00:14:31,550
所以我只是确保
您输入的是小写字母。

242
00:14:31,550 --> 00:14:38,390
所以我说如果 device.lower
equals 等于 r1--

243
00:14:38,390 --> 00:14:44,520
所以如果是r1，如果他输入r1，
那我应该执行什么？

244
00:14:44,520 --> 00:14:48,610
走吧——让我
先保存这个文件。

245
00:14:48,610 --> 00:14:50,830
应该是冒号。

246
00:14:50,830 --> 00:14:52,120
我应该执行什么？

247
00:14:52,120 --> 00:14:57,490
如果是r1，那么你应该
先启用，所以r1.enable。

248
00:14:57,490 --> 00:15:02,030
我们应该做终端和0。

249
00:15:02,030 --> 00:15:09,580
所以r1.send_command，我们
应该发送调用的命令

250
00:15:09,580 --> 00:15:14,140
终端长度等于 0。

251
00:15:14,140 --> 00:15:17,710
所以发送这个命令
到那个路由器，

252
00:15:17,710 --> 00:15:25,450
也许我们可以做一个打印声明。

253
00:15:25,450 --> 00:15:40,500
打印这个，是r1的路由表，可能是打印这个。

254
00:15:40,500 --> 00:15:43,320
然后我应该发送
命令show IP route。

255
00:15:43,320 --> 00:15:44,745
所以这将是——

256
00:15:47,280 --> 00:15:49,146
所以我可以做 r1.send_command。

257
00:15:54,670 --> 00:16:01,380
所以命令，并发送
命令show IP route。

258
00:16:01,380 --> 00:16:04,060
所以发送这个命令
到那个路由器。

259
00:16:04,060 --> 00:16:06,450
但是，我确实希望
帮我打印出来。

260
00:16:06,450 --> 00:16:10,120
所以我会将
这捕获到一个变量中。

261
00:16:10,120 --> 00:16:17,750
所以假设输出
等于r1.send_command。

262
00:16:17,750 --> 00:16:20,555
然后我可以
说打印输出。

263
00:16:25,140 --> 00:16:26,090
所以打印输出。

264
00:16:26,090 --> 00:16:26,760
就是这样。

265
00:16:26,760 --> 00:16:27,720
这就是我所需要的。

266
00:16:27,720 --> 00:16:29,790
显然，我应该
断开我的会话。

267
00:16:29,790 --> 00:16:33,140
所以r1.disconnect。

268
00:16:33,140 --> 00:16:35,150
所以我要断开我的会话。

269
00:16:35,150 --> 00:16:37,280
然后我会有
另一个声明，它

270
00:16:37,280 --> 00:16:39,740
将是我的 else if。

271
00:16:39,740 --> 00:16:52,310
所以 else if 或 elf
device.lower 等于 r2。

272
00:16:52,310 --> 00:16:55,250
那么如果是r2，
我们该怎么办呢？

273
00:16:55,250 --> 00:16:56,520
我们将复制这个。

274
00:16:56,520 --> 00:16:59,702
让我们复制一下。

275
00:16:59,702 --> 00:17:06,500
这将是
r2.enable, r2.send,

276
00:17:06,500 --> 00:17:08,339
这就是印刷品。

277
00:17:08,339 --> 00:17:11,990
这是r2的路由表，然后

278
00:17:11,990 --> 00:17:14,030
捕获输出——

279
00:17:14,030 --> 00:17:16,819
捕获命令，
show IP root 输出

280
00:17:16,819 --> 00:17:23,930
在一个名为 as
的可用输出中，然后打印输出。

281
00:17:23,930 --> 00:17:26,630
让我们断开它。

282
00:17:26,630 --> 00:17:32,420
让我们换个说法，
这将是我的 else。

283
00:17:32,420 --> 00:17:39,260
否则，我会说打印，
比方说无效设备。

284
00:17:41,870 --> 00:17:44,520
好的，这应该足够了。

285
00:17:44,520 --> 00:17:51,470
所以让我们保存这个
并执行这个

286
00:17:51,470 --> 00:17:53,880
来自我们的 Python 解释器。

287
00:17:53,880 --> 00:17:58,160
所以我要做的是
我将连接到我的路由器。

288
00:17:58,160 --> 00:17:59,610
连接到我的 Ubuntu 机器。

289
00:17:59,610 --> 00:18:03,980
让我们做一个 pwd cd
桌面，cd rohit。

290
00:18:03,980 --> 00:18:08,480
让我们回到
我的 Ubuntu 机器

291
00:18:08,480 --> 00:18:13,730
做 pwd cd Desktop, cd rohit。

292
00:18:19,850 --> 00:18:21,080
让我们复制。

293
00:18:26,460 --> 00:18:30,060
让我们对我的 Ubuntu 机器进行 SFTP。

294
00:18:37,470 --> 00:18:40,035
说把 input_function.py。

295
00:18:43,770 --> 00:18:48,130
将此文件放在我的 Ubuntu
机器的本地目录中。

296
00:18:48,130 --> 00:18:50,470
所以现在，如果我回到
这里做一个 ls，

297
00:18:50,470 --> 00:18:54,240
我应该把那个文件
放在这里，我相信，

298
00:18:54,240 --> 00:18:56,880
它的 input_function.py。

299
00:18:56,880 --> 00:18:58,000
让我们执行这个。

300
00:18:58,000 --> 00:19:07,110
所以 Python 3 input_function.py--

301
00:19:07,110 --> 00:19:11,130
一旦我执行了这个，它
应该问我一个问题。

302
00:19:11,130 --> 00:19:17,080
它应该问我是哪个设备，
或者我相信，问题是，

303
00:19:17,080 --> 00:19:18,780
连接哪个设备？

304
00:19:18,780 --> 00:19:21,570
或者你想看哪个路由表
？

305
00:19:21,570 --> 00:19:27,700
所以无论我输入 R1 大写
还是输入 R1 小写，

306
00:19:27,700 --> 00:19:33,030
没关系，因为我
在我的函数中使用过，

307
00:19:33,030 --> 00:19:34,590
我用过 -

308
00:19:34,590 --> 00:19:41,340
我相信它是 device.lower。

309
00:19:41,340 --> 00:19:43,530
那么无论设备内部是什么，
设备内部是什么？

310
00:19:43,530 --> 00:19:44,380
输入。

311
00:19:44,380 --> 00:19:46,770
因此，如果他键入 R1
大写，则不会

312
00:19:46,770 --> 00:19:49,380
重要，因为我会
认为它较低。

313
00:19:49,380 --> 00:19:54,070
所以R1.lower--如果是
R1，那么执行这个。

314
00:19:54,070 --> 00:19:57,390
因此，让我们返回并键入 R1。

315
00:19:57,390 --> 00:20:00,108
所以我输入大写的R1。

316
00:20:00,108 --> 00:20:01,650
现在它在问我
下一个问题。

317
00:20:01,650 --> 00:20:03,360
想要执行的命令。

318
00:20:03,360 --> 00:20:07,310
我想说的是显示IP路由。

319
00:20:07,310 --> 00:20:09,970
所以显示IP路由。

320
00:20:09,970 --> 00:20:13,060
一旦我这样做了，它
就会给我一条消息。

321
00:20:13,060 --> 00:20:15,280
这是R1的路由表，然后

322
00:20:15,280 --> 00:20:17,350
向我展示了 R1 的
路由表。

323
00:20:17,350 --> 00:20:22,360
现在，如果我再次执行相同的操作
这次我输入 R2，

324
00:20:22,360 --> 00:20:24,205
它会显示 R2 的
路由表。

325
00:20:28,855 --> 00:20:30,230
这需要一点时间，因为它

326
00:20:30,230 --> 00:20:34,230
必须建立连接，
SSH 到路由器。

327
00:20:34,230 --> 00:20:36,830
所以我想看看R2。

328
00:20:36,830 --> 00:20:43,040
假设我想
再次查看 R2 的显示 IP 路由，

329
00:20:43,040 --> 00:20:43,910
它打印出来。

330
00:20:43,910 --> 00:20:46,680
这是
R2的路由表，可以看这里

331
00:20:46,680 --> 00:20:49,160
现在我有了 R2 的
路由表。

332
00:20:49,160 --> 00:20:51,710
所以你看，这个
内置输入函数

333
00:20:51,710 --> 00:20:54,980
真的很有帮助，因为
基于输入，

334
00:20:54,980 --> 00:20:56,788
我可以执行一些事情。

335
00:20:56,788 --> 00:20:58,080
让我们尝试做其他事情。

336
00:20:58,080 --> 00:21:01,460
让我们尝试不给 R1，
也许我会放防火墙 1。

337
00:21:01,460 --> 00:21:05,160
让我们重新执行一下。

338
00:21:05,160 --> 00:21:09,015
而这一次，我会
给出一个错误的名字。

339
00:21:12,730 --> 00:21:20,510
假设防火墙1，并决定
来执行show route。

340
00:21:20,510 --> 00:21:22,660
我看到无效的设备。

341
00:21:22,660 --> 00:21:24,830
所以它与
else 语句相匹配。

342
00:21:24,830 --> 00:21:26,330
让我们尝试重新执行它。

343
00:21:26,330 --> 00:21:28,880
而这一次，我会给出，但是
我会给出一个不同的命令。

344
00:21:28,880 --> 00:21:31,205
我可能会给出一个show
IP 接口简介。

345
00:21:36,680 --> 00:21:43,198
所以我会说 R1 和
显示 IP 接口简介。

346
00:21:43,198 --> 00:21:44,740
所以如果我做一个show
IP接口简介，

347
00:21:44,740 --> 00:21:46,660
它仍然向我显示
路由表

348
00:21:46,660 --> 00:21:50,230
因为此时我的脚本非常
静态

349
00:21:50,230 --> 00:21:58,010
我说过如果
是这个设备，那又是什么

350
00:21:58,010 --> 00:21:58,510
我应该怎么做？

351
00:21:58,510 --> 00:22:01,840
我还没有真正说过
我应该如何处理输入

352
00:22:01,840 --> 00:22:05,530
显示所需的命令
或显示_command。

353
00:22:05,530 --> 00:22:07,720
我在这里只使用了
设备，它

354
00:22:07,720 --> 00:22:12,910
你可以在这里看到 if
device.lower 等于 R1。

355
00:22:12,910 --> 00:22:18,700
我可以放一些
之类的东西，也许是 show_command

356
00:22:18,700 --> 00:22:22,510
可能等于 show
IP interface brief 或者可能

357
00:22:22,510 --> 00:22:24,520
显示 IP 路由，然后执行此操作。

358
00:22:24,520 --> 00:22:29,290
现在，我还没有
在这里真正做过任何事情。

359
00:22:29,290 --> 00:22:31,710
对于任何条件，我都不符合此
。

360
00:22:31,710 --> 00:22:33,460
我匹配的唯一条件


361
00:22:33,460 --> 00:22:38,680
if语句是device.lower，
表示如果是R1，

362
00:22:38,680 --> 00:22:40,340
执行这个。

363
00:22:40,340 --> 00:22:45,270
所以这里的这个问题--
问这个问题是--

364
00:22:45,270 --> 00:22:46,520
它并没有真正做任何事情。

365
00:22:46,520 --> 00:22:49,450
假设我真的
去删除它，

366
00:22:49,450 --> 00:22:51,490
我不需要那个。

367
00:22:51,490 --> 00:22:58,400
让我们保存它，然后
重新传输该文件。

368
00:22:58,400 --> 00:23:03,440
所以，我会
重新传输文件，

369
00:23:03,440 --> 00:23:07,055
然后让我们
重新执行该脚本。

370
00:23:07,055 --> 00:23:10,730
它只会问我一个问题
因为现在，我的脚本

371
00:23:10,730 --> 00:23:13,800
是基于路由表的。

372
00:23:13,800 --> 00:23:19,160
所以我可以使它更加模块化以基于输入

373
00:23:19,160 --> 00:23:25,690
在输入时，我会显示该设备的
路由表。

374
00:23:25,690 --> 00:23:27,440
那么你想看哪个路由表
？

375
00:23:27,440 --> 00:23:29,390
让我们看看，如果我这样做
R1，它只是显示

376
00:23:29,390 --> 00:23:31,610
我R1的路由表
不问我

377
00:23:31,610 --> 00:23:32,960
第二个问题。

378
00:23:32,960 --> 00:23:35,750
所以你看，输入函数
很有意义。

379
00:23:35,750 --> 00:23:39,990
是的，我们可以使用
法线定义函数来做到这一点。

380
00:23:39,990 --> 00:23:42,380
但同样，这
主要用于

381
00:23:42,380 --> 00:23:49,040
您想从
用户、字符串和输入中获取输入

382
00:23:49,040 --> 00:23:52,820
并基于，
执行某事。

383
00:23:52,820 --> 00:23:54,870
我希望此视频
对您有所帮助，