零基础入门学Python系列内容的学习目录                                 →                            \rightarrow                 →零基础入门学Python系列内容汇总。

列表、元组和字符串（上）

• 1. 列表
  • 1.1 创建列表
  • 1.2 向列表中添加元素
  • 1.3 从列表中获取元素
  • 1.4 从列表中删除元素
  • 1.5 列表分片
  • 1.6 一些常用操作符
  • 1.7 列表的小伙伴们
  • 1.8 关于分片“拷贝”概念的补充
• 2. 元组
  • 2.1 创建和访问一个元组
  • 2.2 更新和删除元组
• 3. 字符串
• 4. 序列

  需要学习的基础知识有：列表、元组、字符串、序列等。因本部分内容较多，故分为上下两个篇章。
    1、2部分内容见零基础入门学Python（五）—— 列表、元组和字符串（上）
    3、4部分内容见零基础入门学Python（五）—— 列表、元组和字符串（下）

1. 列表

  列表像是一个“打了激素”的数组。有时候我们需要把有某种直接或者间接的联系的东西暂时存储在某种“组”或者“集合”中，将来可能用得到。数组就是把一大堆同种类型的数据摆在一块， 然后通过数组下示进行索引，但数组有一个基本要求是我们放在一起的数据必须类型一 致。 由于Python的变量没有数据类型，也就是说Python是没有数组的，但是Python 加入了更为强大的列表，列表中可以存放任何数据类型。
  Python的列表有多强大?如果把数组比作是一个集装箱的话，那么Python 的列表就是一个工厂的仓库了。列表真的非常有用，基本上所有的Python程序都要使用到列表，包括之前的打飞机游戏，里边的小飞机可以全部扔到一个列表中统一管理。

1.1 创建列表

  创建列表和创建普通变量一样，用中括号将一堆数据括起来就可以了，数据之间用逗号隔开。

  >>>number = [1, 2, 3, 4, 5]
  >>>mix = [1, “hello”, 3.14, [1, 2, 3]]
  >>>empty = [ ]

  我们创建的第一个列表是一个普普通通的列表；第二个列表是一个鱼龙混杂的列表，里有整型、字符串、浮点型数据，甚至还包含了另一个列表；第三个列表是一个空列表。

1.2 向列表中添加元素

  ①列表相当灵活，它的内容不总是固定的。要向列表添加元素，可以使用append()方法。
  example1:>>>number = [1, 2, 3, 4, 5]
       >>>number.append(6)
       >>>number
       [1, 2, 3, 4, 5, 6]
  通过example1可以发现，append()的调用跟平时的BIF内置函数调用不一样，因为这个方法不是一个BIF，它属于列表对象的一个方法。中间的“.”可以理解为范围的意思：append()这个方法是属于一个叫做number的列表对象的。
  但是append()不能同时添加多个元素，否则会报错。
  example2:>>>number = [1, 2, 3, 4, 5, 6]
       >>>number.append(7, 8)
       Traceback (most recent call last):
        File “

  ②我们想要同时向列表末尾添加多个元素时，可以使用extend()方法。
  example3:>>>number = [1, 2, 3, 4, 5, 6]
       >>>number.extend([7, 8])
       >>>number
       [1, 2, 3, 4, 5, 6, 7, 8]

  ③上述两种方法都是在列表的末尾插入元素，想要往列表的任意位置插入元素，就要使用insert()方法。insert()方法有两个参数：第一个参数代表在列表中的位置，第二个参数代表在这个位置处插入一个元素。
  example4:>>>number = [1, 2, 3, 4, 5, 6, 7, 8]
       >>>number.insert(0, 0)
       >>>number
       [0, 1, 2, 3, 4, 5, 6, 7, 8]

1.3 从列表中获取元素

  跟数组一样，可以通过元素的索引值（index）从列表获取单个元素，注意，列表的索引值是从0开始的。

  example1:>>>number = [0, 1, 2, 3, 4, 5, 6, 7, 8]
       >>>number[0]
       0
       >>>number[3]
       3

  按照这个方法可以让3和1的位置互调：

  example2:>>>number = [0, 1, 2, 3, 4, 5, 6, 7, 8]
       >>>number[1], number[3] = number[3], number[1]
       >>>number
       [0, 3, 2, 1, 4, 5, 6, 7, 8]

1.4 从列表中删除元素

  从列表中删除元素，有三种方法：remove()、del()、pop()。

  ①remove()方法： >>>number = [0, 1, 2, 3, 4, 5, 6, 7, 8]
           >>>number.remove(0)
           >>>number
           [1, 2, 3, 4, 5, 6, 7, 8]
  使用remove()删除元素，你并不需要知道这个元素在列表中的具体位置，只需要知道这个元素列表中存在就可以了。如果要删除的元素不在列表中，程序就会报错：
  example1:>>>number = [0, 1, 2, 3, 4, 5, 6, 7, 8]
       >>>number[9]
       Traceback (most recent call last):
         File “

  ②当需要指定删除某个位置的元素时，就要用del来实现。
  example2:>>>number = [0, 2, 3, 4, 5, 6, 7, 8]
       >>>del number[1]
       >>>number
       [0, 3, 4, 5, 6, 7, 8]
  example2中del number[1]删掉的是索引为1的元素，并不是元素1。del是一个语句，不是一个列表的方法，所以我们不必在它后面加上小括号()。如果想要删掉整个列表，还可以直接用del加列表名删除。

  example3:>>>number = [0, 1, 2, 3, 4, 5, 6, 7, 8]
       >>>del number
       >>>number
       Traceback (most recent call last):
         File “

  ③pop()方法是用于“弹出”元素的，默认弹出列表中的最后一个元素，当我们加上一个索引值作为参数的时候，它会弹出这个索引值对应的元素。
  example4:>>>number = [0, 1, 2, 3, 4, 5, 6, 7, 8]
       >>>number.pop()
       8
       >>>number
       [0, 1, 2, 3, 4, 5, 6, 7]

1.5 列表分片

  利用列表分片，我们可以一次性从列表中获取多个元素。

  example1:>>>number = [0, 1, 2, 3, 4, 5, 6, 7, 8]
       >>>number[0:2]
       [0, 1]

  列表分片的使用很简单，用一个冒号隔开两个索引值，左边是开始位置，右边是结束位置，但是结束位置上的元素是不包含的。利用列表分片，我们可以得到一个原来列表的拷贝，原来列表并没有发生改变。

  列表分片也可以简写，如果没有开始位置，Python会默认开始位置是0；同样，如果要得到从指定位置索引值到列表末尾的所有元素，把结束位置省去即可；如果没有放入任何索引值，而只有一个冒号，将得到整个列表的拷贝。

  example2:>>>number = [0, 1, 2, 3, 4, 5, 6, 7, 8]
       >>>number[ : 2]
       [0, 1]
       >>>number[1 : ]
       [1, 2, 3, 4, 5, 6, 7, 8]
       >>>number[ : ]
       [0, 1, 2, 3, 4, 5, 6, 7, 8]

  列表分片就是建立原列表的一个拷贝（副本），所以如果想对列表做出某些修改，但同时还想保持原来的那个列表，那么使用列表分片的方法来获取拷贝就非常的方便。

  列表分片操作实际上还可以接受第三个参数，其代表的是步长，默认情况下该值为1。

  example3:>>>number = [1, 2, 3, 4, 5, 6, 7, 8, 9]
       >>>number[ 0 : 9 : 2]
       [1, 3, 5, 7, 9]

  如果步长为2，那么前进两个元素才从列表取出一个元素出来，其实还可以写成number[ : : 2]。如果步长的值为负数，例如-1，就相当于复制一个反转的列表。

  example4:>>>number = [1, 2, 3, 4, 5, 6, 7, 8, 9]
       >>>number[ : : -1]
       [1, 2, 3, 4, 5, 6, 7, 8]
       >>>number[ : ]
       [9, 8, 7, 6, 5, 4, 3, 2, 1]

1.6 一些常用操作符

  ①加号（+）：连接操作符，用来进行拼接。它允许我们把多个列表对象合并在一起，其实就相当于extend()方法实现的效果。一把情况下，建议用extend()方法来扩展列表，因为这样更加专业和规范。另外，连接操作符并不能实现列表添加新元素的操作。
  example1:>>>list1 = [123, 456]
       >>>list2 = [234, 123]
       >>>list3 = list1 + list2
       >>>list3
       [123, 456, 234, 123]
  example2:>>>list1 = [123, 456]
       >>>list2 = list1 + 789
       [1, 2, 3, 4, 5, 6, 7, 8]
       >>>number[ : ]
       Traceback (most recent call last):
         File “

  ②乘号（*）：重复操作符，用来复制自身若干次。
  example3:>>>list1 = [123]
       >>>list1 * 3
       >>>[123, 123, 123]

  ③当然复合赋值运算符也可以用于列表。
  example4:>>>list1 = [123]
       >>>list1 *= 5
       >>>list1
       [123, 123, 123, 123, 123]

   ④成员关系运算符： in 和 not in。
  example5:>>>list1 = [“小猪”, “小猫”, “小狗”]
       >>>“小猫”  in  list1
       >>>True
       >>>“小鸡”  not  in  list1
       >>>True
   当一个列表中包含另一个列表时，那么对于列表中的列表元素，就不能使用in和not in进行测试了。因为in和not in只能判断一个层次的成员关系。如果要判断列表里边的列表的元素，应该先进入一层列表。
  example6:>>>list1 = [“小猪”, [“小猫”, “小鸡”], “小狗”]
       >>>“小猫”  in  list1
       >>>False
       >>>“小鸡”  not  in  list1
       >>>True
       >>>“小猫”  in  list1[2]
       >>>True
       >>>“小鸡”  not  in  list1[2]
       >>>False

  对于列表中的列表，如果我们想要访问某个元素，可以使用如下方法：
  example7:>>>list1 = [“小猪”, [ “小猫”, “小鸡”], “小狗”]
       >>>list1[1][0]
       ‘小猫’

1.7 列表的小伙伴们

  我们可以通过使用dir(list)来查看列表一个有多少个小伙伴。

        >>>dir(list)

  其中的count()方法的作用是计算它的参数在列表中 出现的次数：
  example1:>>>list1 = [1, 1, 2, 3, 5, 8, 13, 21]
       >>>list1.count(1)
       2
       >>>list1.count(2)
       1

  index()方法会返回它的参数在列表中的位置：
  example2:>>>list1 = [1, 1, 2, 3, 5, 8, 13, 21]
       >>>list1.index(1)
       0
       >>>list1.index(21)
       7
  通过上述例子，我们可以看出index(1)返回目标1在list1中的位置。index()方法还有两个参数，用于限定查找的范围。通过设置限定查找的范围，我们就可以查找第二个目标在list1中的位置。
  example3:>>>list1 = [1, 1, 2, 3, 5, 8, 13, 21]
       >>>start = list1.index(1) + 1
       >>>stop = len(list1)
       >>>list1.index(1, start, stop)
       1

  reverse()方法的作用是将整个列表原地旋转，就是原本排在最后的放到最前边，排最前的放到最后。
  example4:>>>list1 = [1, 2, 3, 4, 5, 6, 7]
       >>>list1.reverse()
       >>>list1
       [7, 6, 5, 4, 3, 2, 1]

  sort()方法是用指定的方式对列表的成员进行排序，默认不需要参数，从小到大排序。
  example5:>>>list1 = [8, 9, 3, 5, 2, 6, 10, 1, 0]
       >>>list1.sort()
       >>>list1
       [0, 1, 2, 3, 5, 6, 8, 9, 10]
  如果需要从大到小排序，我们可以通过先调用sort()方法从小到大排序，再调用reverse()方法进行翻转来实现。不过，sort()方法其实有三个参数，其形式为sort(func, key, reverse)，其中func和key参数用于设置排序的算法和关键字，默认是使用归并排序。第三个参数reverse就是我们第一种方法中的reverse()方法，在sort()方法中的默认值是sort(reverse=False)，表示不颠倒顺序。在我们想要从大到小排序时，只需要把False改为True就可以了。
  example6:>>>list1 = [8, 9, 3, 5, 2, 6, 10, 1, 0]
       >>>list1.sort(reverse=True)
       >>>list1
       [10, 9, 8, 6, 5, 3, 2, 1, 0]

1.8 关于分片“拷贝”概念的补充

  先看一个例子：
  example1:>>>list1 = [1, 3, 2, 9, 7, 8]
       >>>list2 = list1[ : ]
       >>>list2
       [1, 3, 2, 9, 7, 8]
       >>>list3 = list1
       >>>list3
       [1, 3, 2, 9, 7, 8]
  如果我们利用列表的一个小伙伴做以下修改，会得到如下结果：
       >>>list1.sort()
       >>>list1
       [1, 2, 3, 7, 8, 9]
       >>>list2
       [1, 3, 2, 9, 7, 8]
       >>>list3
       [1, 2, 3, 7, 8, 9]
  通过结果我们可以看到，当list1从小到大排好序后，使用分片方式得到的list2并没有因为list1的改变而改变，而list3却跟着list1改变了。这是因为为列表指定另一个名字的做法，只是向同一个列表增加一个新的标签而已，真正的拷贝是要使用分片的方法。

2. 元组

  元组像是一个“戴了枷锁”的列表。元组和列表最大的区别就是我们可以任意修改列表中的元素，可以任意插入或者删除一个元素，而对元组是不行的，元组是不可改变的（就像字符串一样），所以对元组就不能进行排序等高级操作。

2.1 创建和访问一个元组

  元组和列表除了不可改变这个显著特征之外，还有一个明显的区别是：创建列表用的是中括号，而创建元组大部分时候用的是小括号，但使用()并不能代表它就是元组。
  example1:>>>tuple1 = (1, 2, 3, 4, 5, 6, 7, 8)
       >>>tuple1
       (1, 2, 3, 4, 5, 6, 7, 8)

  访问元组的方式与列表无异：
  example2:>>>tuple1[1]
       2
       >>>tuple1[ 5 : ]
       (6, 7, 8)
       >>>tuple1[ : 5 ]
       (1, 2, 3, 4, 5)

  也可以使用分片的方式来复制一个元组：
  example3:>>>tuple2 = tuple1[ : ]
       >>>tuple2
       >>>(1, 2, 3, 4, 5, 6, 7, 8)

  如果试图修改元组的一个元素，那么Python将会报错：
  example4:>>>tuple1[1] = 1
       Traceback (most recent call last):
       File “

  对列表来说，标志性符号是中括号[ ]；对于元组来说，标志性符号不是小括号( )，而是逗号，，小括号只起补充作用。
  example5:>>>temp1 = (1)
       >>>type(temp1)
       

  如果要创建一个空元组，直接使用小括号即可。
  example6:>>>temp = ( )
       >>>type(temp)
       

  如果要创建的元组中只有一个元素，需要在其后面加上一个逗号，这样才能明确告诉Pyhton，我们要创建的是一个元组。
  example7:>>>temp1 = (1, )
       >>>type(temp1)
       

  通过一个例子来看一下逗号，对元组的重要性：
  example8:>>>8 * (8)
       64
       >>>8 * (8, )
       (8, 8, 8, 8, 8, 8, 8, 8)

2.2 更新和删除元组

  我们可以通过拷贝现有的字符串片段构造一个新的字符串的方式解决元组的更新与删除。

  example1:>>>temp = (“小猪”, “小猫”, “小狗”)
       >>>temp = temp[ : 2 ] + (“小鸡”, ) + temp[ 2 : ]
       >>>temp
       (‘小猪’, ‘小猫’, ‘小鸡’, ‘小狗’)

  example2:>>>temp = (‘小猪’, ‘小猫’, ‘小鸡’, ‘小狗’)
       >>>temp = temp[ : 2 ] + temp[ 3 : ]
       >>>temp
       (‘小猪’, ‘小猫’, ‘小狗’)

  上述两个例子中对元组添加和删除元素都是通过将元组拆分为两部分进行操作的，是一种间接操作方式。如果要删除整个元组，使用del语句即可显式地删除一个元组。

  example3:>>>temp = (‘小猪’, ‘小猫’, ‘小鸡’, ‘小狗’)
       >>>del temp
       >>>temp
       Traceback (most recent call last):
        File “

  在实际使用中，其实很少使用del去删除整个元组，因为Python的回收机制会在这个元组不再被使用时自动将其删除。

  后半部分内容见零基础入门学Python（五）—— 列表、元组和字符串（下）。

3. 字符串

4. 序列