WEBVTT

00:00.360 --> 00:01.200
欢迎回来｡ 

00:01.740 --> 00:03.540
让我们继续讨论列表｡ 

00:04.050 --> 00:07.800
到目前为止, 这些方括号, 我们以前见过, 对吧？

00:07.800 --> 00:10.470
我们在处理字符串时看到了它们｡ 

00:11.010 --> 00:19.050
就像字符串一样, 列表也非常相似, 我们可以使用列表切片｡ 

00:20.100 --> 00:29.220
如果你还记得字符串切片, 我们有像hello这样的东西, 我们可以把它赋给一个字符串, 比如一个变量字符串, 我们可以先做字符串,

00:29.340 --> 00:33.660
然后切片｡

00:33.660 --> 00:35.940
所以做一些像这样的事情｡ 

00:37.020 --> 00:41.970
我们有开始, 停止, 然后一步通过｡ 

00:42.570 --> 00:46.950
所以我们从索引0开始到索引2结束｡ 

00:47.820 --> 00:49.350
然后一个一个地走｡ 

00:49.830 --> 00:53.910
所以我们也可以使用列表切片｡ 

00:54.720 --> 00:57.120
让我们把这张牌放大一点｡ 

00:57.300 --> 01:02.610
你可以通过这样的格式来让它更干净｡ 

01:03.300 --> 01:05.730
好吧, 那我们该往购物车里加什么呢？

01:05.850 --> 01:08.850
我们还将添加一些玩具｡ 

01:09.060 --> 01:10.800
然后你知道吗？

01:10.800 --> 01:12.420
亚马逊现在做杂货｡ 

01:12.420 --> 01:14.190
所以我们再加点美味的葡萄｡ 

01:14.970 --> 01:15.600
太棒了｡ 

01:15.960 --> 01:19.280
现在, 假设我想得到购物车中的每一件商品｡ 

01:19.290 --> 01:21.900
我们就这么做｡ 

01:22.590 --> 01:25.470
我们有完整的名单｡ 

01:25.470 --> 01:27.840
但是让我们使用一些列表切片｡ 

01:28.440 --> 01:33.600
假设我想从第一个项目抓取到第二个项目｡ 

01:34.050 --> 01:35.070
如果我单击“运行”｡ 

01:36.730 --> 01:39.220
我有笔记本和太阳镜｡ 

01:40.160 --> 01:45.950
也许我想一路走到最后, 但跳过每一秒一个｡ 

01:47.660 --> 01:49.790
我有笔记本和玩具｡ 

01:50.210 --> 01:51.410
我们从零开始｡ 

01:51.440 --> 01:55.700
我们一步一步走向玩具, 我们一步一步走过去, 我们就完成了｡ 

01:56.300 --> 01:56.930
太棒了｡ 

01:56.930 --> 02:00.410
这是我们在讨论弦时已经看到的｡ 

02:01.550 --> 02:05.030
但有趣的是｡ 

02:05.420 --> 02:08.740
还记得我说过字符串是不可变的吗？

02:08.750 --> 02:10.820
这意味着我们不能改变他们｡ 

02:11.000 --> 02:11.710
好吧, 我知道了

02:11.720 --> 02:16.790
当我们有一个像Hello这样的字符串的时候, 我们讨论过这个问题｡ 

02:17.060 --> 02:22.370
我不能把问候语零等同于Z｡ 

02:22.610 --> 02:24.350
我会在这里得到一个错误｡ 

02:24.530 --> 02:28.640
我得到字符串对象不支持项分配｡ 

02:29.210 --> 02:30.500
它是不可改变的｡ 

02:31.030 --> 02:36.490
但列表的有趣之处在于它们是可变的｡ 

02:37.280 --> 02:39.890
这样如果我换了我的亚马逊购物车｡ 

02:40.950 --> 02:43.890
然后说, 你知道吗, 我真的不想要笔记本｡ 

02:43.890 --> 02:47.460
我要拿第一件东西, 那就是笔记本｡ 

02:47.460 --> 02:51.570
除了笔记本, 我们还想要什么？

02:51.720 --> 02:53.780
我们会说我们想要一台新的笔记本电脑｡ 

02:53.790 --> 02:54.840
这是一个很大的升级｡ 

02:55.910 --> 02:58.520
当我打印这个亚马逊购物车｡ 

03:01.260 --> 03:02.030
你看那个｡ 

03:02.040 --> 03:05.250
我可以更改此列表｡ 

03:06.670 --> 03:09.860
在这个意义上, 它并没有给予我一个错误｡ 

03:09.880 --> 03:11.280
列表是可变的｡ 

03:11.290 --> 03:18.340
我们只是简单地把笔记本电脑的内存书架换掉, 我说, 嘿, 把它换成笔记本电脑,

03:18.340 --> 03:20.200
他们就让我们这么做了｡

03:21.250 --> 03:23.170
这太棒了｡ 

03:23.350 --> 03:25.360
但让我们在这里尝试一些东西｡ 

03:26.190 --> 03:36.420
如果我在这里创建另一个打印, 在亚马逊购物车中, 我将使用列表切片, 比如说,

03:36.420 --> 03:41.280
我想要从索引1到索引3的项目｡

03:43.110 --> 03:45.130
让我们运行一下, 看看会发生什么｡ 

03:45.150 --> 03:46.110
猜猜看

03:49.280 --> 03:50.960
这是你所期望的吗？

03:51.500 --> 03:52.790
让我们来看看这个代码｡ 

03:53.470 --> 04:04.270
当我们到了第十行, 我们抓住亚马逊购物车已经更新了笔记本电脑, 我抓住项目一｡

04:05.080 --> 04:05.670
二三

04:05.680 --> 04:07.780
这就是太阳镜｡ 

04:08.900 --> 04:09.770
两个玩具｡ 

04:09.770 --> 04:11.960
所以, 01, 2｡ 

04:11.960 --> 04:13.280
然后我们在三点停止｡ 

04:14.580 --> 04:16.200
只是为了让你更容易理解｡ 

04:16.200 --> 04:17.970
让我们从零开始｡ 

04:18.930 --> 04:22.020
这样我们就能看到笔记本电脑被换过了｡ 

04:22.770 --> 04:28.620
然后在第二个, 第11行, 我们打印Amazon购物车｡ 

04:29.340 --> 04:31.110
但等一下｡ 

04:31.740 --> 04:34.200
这份名单没有改变｡ 

04:34.590 --> 04:40.210
这是因为通过列表切片, 我们创建了一个新的列表｡ 

04:40.230 --> 04:42.630
此列表的新副本｡ 

04:43.080 --> 04:53.010
我们在这里创建了一个全新的列表, 这样我就可以将它赋值给一个变量, 新购物车是Amazon购物车.

04:53.490 --> 04:55.350
让我们在这里做同样的事情｡ 

04:56.710 --> 05:01.720
而新卡本身就是一个全新的列表｡ 

05:01.840 --> 05:03.650
我可以换一辆新车｡ 

05:03.670 --> 05:08.590
比如说口香糖里的零｡ 

05:09.190 --> 05:10.840
如果我把这个打印出来｡ 

05:12.420 --> 05:13.170
你看到了吗？

05:13.170 --> 05:22.560
我有两个新的单独的列表, 但是列表是可变的, 因为我可以随时改变索引中的任何内容｡

05:23.040 --> 05:30.180
每次我们进行列表切片时, 我们都会创建一个新的列表副本｡ 

05:30.870 --> 05:33.010
但我有个棘手的问题要问你

05:33.030 --> 05:36.690
如果我这么做会发生什么？

05:39.470 --> 05:40.760
如果我运行这个｡ 

05:43.810 --> 05:44.200
嗯嗯嗯

05:45.200 --> 05:46.040
你看到了吗？

05:47.790 --> 05:54.600
而不是切片我的名单, 我只是说, 新卡将等于亚马逊购物车｡ 

05:55.310 --> 05:59.810
我把一个新的cart索引0改为等于gum｡ 

06:00.050 --> 06:04.400
但是现在我的亚马逊购物车也被修改了｡ 

06:04.820 --> 06:06.050
为什么会这样呢？

06:07.030 --> 06:12.790
这是一个你在面试中可能会遇到的棘手问题｡ 

06:13.520 --> 06:22.910
原因是, 现在我所做的等于的方式意味着, 嘿, 新购物车将等于亚马逊购物车｡

06:23.120 --> 06:25.790
而亚马逊购物车等于什么？

06:26.090 --> 06:33.530
亚马逊购物车指向我们机器内存中的某个地方, 它说, 嘿, 这就是亚马逊购物车｡

06:33.800 --> 06:36.680
因为这里我们没有复制列表｡ 

06:36.680 --> 06:42.620
相反, 我们只是说, 嘿, 新卡的价值是亚马逊购物车内存中的任何东西｡ 

06:43.380 --> 06:52.320
我们现在, 当我们修改新的购物车只是改变亚马逊购物车所有的方式从这里回来｡ 

06:52.740 --> 06:55.050
所以这是一个重要的概念｡ 

06:55.080 --> 07:01.290
如果你想, 比如说复制一个列表, 然后你做这样的事情｡ 

07:02.180 --> 07:04.310
你复制了整个名单｡ 

07:04.310 --> 07:07.160
这是你在代码库中经常看到的东西｡ 

07:07.990 --> 07:12.220
但这行是在说, 嘿, 我想创建一个副本｡ 

07:12.250 --> 07:20.560
使用列表切片来复制这个亚马逊购物车, 它将等于新购物车, 所以现在如果我运行这个｡ 

07:22.130 --> 07:29.240
您将看到原来的Amazon购物车保持不变, 但新购物车现在有所不同｡ 

07:29.990 --> 07:33.200
这是一个快速得到你只需要习惯｡ 

07:33.200 --> 07:39.800
但这是一个重要的概念, 复制和修改列表的概念｡ 

07:40.400 --> 07:44.460
我们会在接下来的几个视频中深入探讨｡ 

07:44.480 --> 07:47.090
现在, 休息一下, 我们下一场见｡ 

07:47.310 --> 07:47.870
再见, 再见, 再见
