Python笔记_第一篇_面向过程_第一部分_5.Python数据类型之列表类型(list)

　　Python中序列是最基本的数据结构。序列中的每个元素都分配一个数字（他的位置或者索引），第一个索引是0，第二个索引是1，依次类推。Python的列表数据类型类似于C语言中的数组，但是不同之处在于列表数据类型可以包含任何类型的元素。列表示Python最常用的数据类型之一，他可以以作为一个方括号内的逗号分割值出现。像字符串一样也具有增删改查的操作。因此列表是一个有序集合。

　　注意：如果列表当中只有一个元素的时候，比如[12, ]，需要加一个逗号。目的是一面误解成数学计算意义上的括号。

1.   列表的简单应用

1.1   创建列表

　　格式：列表名 = [列表选项1，列表选项2，列表选项n]

　　创建一个空列表和一个带有不同元素的列表

 # 创建一个空列表
 list1 = []
 print(list1)  # 输出结果： []
 # 创建一个带有元素的列表
 list1 = [1, ]
 list2 = [18, 19, 20, 21, 22]
 print(list1)  # 输出结果：[1]
 print(list2)  # 输出结果：[18, 19, 20, 21, 22]
 # 创建一个带有不同元素类型的列表
 list3 = [18, 19, 20, "very", "good"]
 print(list3)  # 输出结果：[18, 19, 20, 'very', 'good']

1.2   列表的常规操作

1.2.1   列表元素的访问

　　同字符串一样通过下标来进行访问

 # 列表元素的访问 #
 list4 = [1, 2, 3, 4, 5]
 print(list4[2])
 print(type(list4[2]))
 # 输出结果：
 #
 # <class 'int'>

1.2.2   列表元素的改变

　　通过下标的方式更改列表当中的某个值

 # 列表元素的改变 #
 list4 = [1, 2, 3, 4, 5]
 list4[2] = 300
 print(list4)
 # 输出结果：[1, 2, 300, 4, 5]

1.2.3  列表元素的删除

 # 列表元素的删除 #
 list1 = ['physics', 'chemistry', 1997, 2000]
 del list1[0]
 print(list1)
 # 输出结果：['chemistry', 1997, 2000]

1.2.4   列表的组合

 # 列表组合
 list5 = [1, 2, 3]
 list6 = [4, 5, 6]
 list7 = list5 + list6
 print(list7)
 # 输出结果：[1, 2, 3, 4, 5, 6]

1.2.5   列表的重复

 # 列表的重复
 list8 = [1, 2, 3]
 print(list8 * 3)
 # 输出结果：[1, 2, 3, 1, 2, 3, 1, 2, 3]

1.2.6   判断元素是否在列表中，返回值为False 或 True，成员运算符（in，not in）；身份运算符同理不再举例

 # 判断元素是否在列表中
 list9 = [1, 2, 3, 4, 5]
 print(3 in list9)  # 输出结果：True
 print(6 in list9)  # 输出结果：False
 print(6 not in list9)  # 输出结果：True

1.2.7   列表的切片，与字符串切片原理相同

　　格式：[[start] [,end] [,step]]，开始位置，结束位置，步长

　　注意：几到几的指针是放到元素的前面。

 # 列表的截取(切片)
 # 格式[[start] [,end] [,stet]], 开始位置、结束位置、步长
 list10 = ["wuchao", "jinxing", "xiaohu", "sanpang", "ligang"]
 print(list10[1:]) # 取到最后，默认步长是1
 # 输出结果：['jinxing', 'xiaohu', 'sanpang', 'ligang']

 print(list10[1:-1]) # 取到倒数第二个值，默认步长是1，-1正着取值，指针是放到"ligang"前面的，所以没有"ligang"
 # 输出结果：['jinxing', 'xiaohu', 'sanpang']

 print(list10[1:-1:1])  # 从左到右一个一个去取，步长为1
 # 输出结果：['jinxing', 'xiaohu', 'sanpang']

 print(list10[1::2])  # 从左到右各一个去取
 # 输出结果：['jinxing', 'sanpang']

 print(list10[::-1]) # 把整个表格反转过来
 # 输出结果：['ligang', 'sanpang', 'xiaohu', 'jinxing', 'wuchao']

 print(list10[::-1][1:3]) # 取列表中的后两个，第一步反转表格，第二步取前两个
 # 输出结果：['sanpang']

1.2.8   二维列表和三维列表

　　二维列表和三维列表，以及其他高维列表的逻辑是在列表内在表示一组列表元素。访问也是通过双下标、三下标或高下标的方式访问，操作高维列表和操作一维列表的逻辑是一样的。

 # 二维和三维列表 #
 list11 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
 print(list11[1][1]) # 也是按照下标访问三维列表第二组第二个元素
 # 输出结果：5

 list11[1][1] = 100
 print(list11) # 改变数值与一位里列表一样
 # 输出结果：[[1, 2, 3], [4, 100, 6], [7, 8, 9]]

2.   列表的常见内建函数的应用

 　　函：append

　　　　语：append(x)

　　　　　　用：在列表末尾添加一个新的元素的第一个“元素”

 # append
 # 作用：在列表末尾添加新的元素的第一个“元素”
 list12 = [1, 2, 3, 4, 5]
 list12.append(6)
 list12.append(7)
 list12.append([7, 8, 9])
 print(list12)
 # 输出结果：[1, 2, 3, 4, 5, 6, 7, [7, 8, 9]]

 　　函：extend

　　　　语：extend([list])

　　　　　　用：在列表末尾一次性追加一个列表中的多个值

 # extend
 # 作用：在列表末尾一次性追加一个列表中的多个值
 list13 = [1, 2, 3, 4, 5]
 list13.extend([6, 7, 8, 9, 10])
 print(list13)
 # 输出结果：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

　　函：insert

　　　　语：insert([index] [,x])

　　　　　　用：将数据添加到任意一个位置，在下标处添加一个元素，不覆盖原数据，原数据顺向后延。

 # insert
 # 作用：在下标处添加一个元素，不覆盖原数据，原数据顺向后延
 list14 = [1, 2, 3, 4, 5]
 list14.insert(0, 100)  # 在第一个元素前追加一个100
 print(list14)
 # 输出结果：[100, 1, 2, 3, 4, 5]

　　函：pop、del

　　　　语：pop([index])、del list[index]

　　　　　　用：移除列表中下标处的元素（默认移除最后一个元素[-1]），并返回删除后的数据；删除列表规定下标的某一个元素。

 # pop、del
 # 作用：移除列表中下标处的元素（默认移除最后一个元素[-1]），并返回删除后的数据
 list15 = [1, 2, 3, 4, 5]
 list15.pop(-3) # 删除右边数第三个元素
 del list15[0]
 print(list15)
 # 输出结果：[2, 4, 5]

　　函：remove

　　　　语：remove(x)

　　　　　　用：移除remove指定的元素、只能删除一个，估计当初设计整个函数的时候为了防止误删，所以只能删除一个

 # remove
 # 作用：移除remove指定的元素
 list16 = [1, 2, 3, 4, 4, 5]
 list16.remove(4)  # 移除列表中某个元素第一个匹配结果
 print(list16)
 # 输出结果：[1, 2, 3, 4, 5]

　　函：clear

　　　　语：clear()

　　　　　　用：清除列表中的所有元素

 # clear
 # 作用：清除列表中所有的数据
 list17 = [1, 2, 3, 4, 5]
 list17.clear()
 print(list17)
 # 输出结果：[]

　　函：index

　　　　语：index(x [,start] [,end])

　　　　　　用：从列表中找出某个值的第一个匹配的索引值

 # index
 # 作用：从列表中找出某个值的第一个匹配的索引值
 list18 = [1, 2, 3, 4, 5, 3, 4, 5, 6]
 print(list18.index(3))  # 第一个匹配的位置，同字符串的性质一样如果么有返回报错
 print(list18.index(3, 3, 7)) # 指定位置进行查找
 # 输出结果：2  5

　　函：len

　　　　语：len(list)

　　　　　　用：获取列表的长度

 # len
 # 作用：获取列表的长度
 list19 = [1, 2, 3, 4, 5, 3, 4, 5, 6]
 print(len(list19))
 # 输出结果：9

　　函：max、min

　　　　语：max(list)、min(list)

　　　　　　用：获取列表中的最大值、获取列表中的最小值

 # max、min
 # 作用：获取列表中的最大值、获取列表中的最小值
 list20 = [1, 2, 3, 4, 5, 3, 4, 5, 6]
 print(max(list20), min(list20))
 # 输出结果：6   1

　　函：count

　　　　语：count(x)

　　　　　　用：统计某个元素在列表中出现的次数

 # count
 # 作用：统计某个元素在列表当中出现的次数
 list21 = [1, 2, 3, 4, 5, 3, 4, 5, 6]
 print(list21.count(3))  # 统计某个元素在列表当中出现的次数
 # 输出结果：2

　　函：reverse

　　　　语：reserve()

　　　　　　用：列表中的元素按照倒序进行排列，如果本身序列按照规则就行排列，reverse函数这是是一个翻转函数（升序，变为逆序；逆序变为升序）

 # reverse
 # 作用：列表中的元素按照倒序排列
 list22 = [1, 2, 3, 4, 5, 3, 4, 5, 6]
 list22.reverse()
 print(list22)
 # 输出结果：[6, 5, 4, 3, 5, 4, 3, 2, 1]

　　函：sort

　　　　语：sort(list, key =, reverse = false/true)

　　　　　　用：默认为升序排列的排序方式，其中key可以按照某个键值方式进行排序，reverse可以调用逆序排序。

 # sort
 # 作用：排序（默认为升序排列）key=字符串用法,reverse=反转用法
 list23 = [1, 2, 3, 4, 5, 3, 4, 5, 6]
 list23.sort()
 print(list23)
 # 输出结果：[1, 2, 3, 3, 4, 4, 5, 5, 6]

 list23 = [1, 2, 3, 4, 5, 3, 4, 5, 6]
 list23.sort(reverse=True)  # 改为降序排列
 print(list23)
 # 输出结果：[6, 5, 5, 4, 4, 3, 3, 2, 1]

 list23 = [1, 2, 3, 4, 5, 3, 4, 5, 6]
 list23.sort(reverse=False)  # 默认为升序排列
 print(list23)
 # 输出结果：[1, 2, 3, 3, 4, 4, 5, 5, 6]

 list23 = ['Fast', 'Smooth', 'fast', 'is', 'is', 'smooth']
 list23.sort(key=str.lower)  # 忽略大小写排序
 print(list23)
 # 输出结果：['Fast', 'fast', 'is', 'is', 'Smooth', 'smooth']

 list23 = ['Fast', 'Smooth', 'fast', 'is', 'is', 'smooth']
 list23.sort(key = len)  # 按字符串长度进行排序
 print(list23)
 # 输出结果：['Fast', 'fast', 'is', 'is', 'Smooth', 'smooth']

3.   深拷贝和浅拷贝

　　内存：
　　栈区和堆区
　　普通的变量都存在栈区，程序结束自动释放内存空间(系统自动分配,自动开辟，自动释放)
　　堆区(程序员手动开辟，手动释放，对象一般都存在堆区）
　　变量名存在栈区，通过地址0x1000去访问堆区的数据
　　list27 和 list28 地址一样，所以打印出来是一样。浅拷贝也叫引用拷贝。指向的是一个数据
　　深拷贝也叫内存的拷贝，全新的地址导致两个变量的指向不一样了。在堆区再开辟一片空间

　　举例说明：

 # 浅拷贝举例
 list27 = [1, 2, 3, 4, 5]
 list28 = list27
 list28[1] = 200
 print(list28)
 print(list27)
 print(id(list28))
 print(id(list27))
 # 输出结果：
 # [1, 200, 3, 4, 5]
 # [1, 200, 3, 4, 5]
 # 37310024
 # 37310024
 # 观察这两个列表的id没有发生变化

 # 深拷贝举例
 list29 = [1, 2, 3, 4, 5]
 list30 = list29.copy()
 list30[1] = 200
 print(list29)
 print(list30)
 print(id(list29))
 print(id(list30))
 # 输出结果：
 # [1, 2, 3, 4, 5]
 # [1, 200, 3, 4, 5]
 #
 #
 # 通过深拷贝两个列表的id已经发生变化了。

4.  列表常用技巧

　　4.1   前面的remove命令只能够移除一次需要移除的元素，通过下面的示例可以把需要移除的元素全部移除掉。

 # 累计移除列表中指定的元素
 list24 = [1, 2, 3, 4, 5, 3, 3]
 num25 = 0
 all = list24.count(3)
 while num25 < all:
     list24.remove(3)
     num25 += 1
 print(list24)
 # 输出结果：
 # [1, 2, 4, 5]

　　4.2   任意输出五个数，找出第二大的值。

 # 任意输入5个数，找出第二大的值
 listNum = []
 num = 0
 while num < 5:
     val = int(input("请输入任意五个数： "))
     listNum.append(val)
     num += 1
     print(listNum)
 # 升序方法一
 listNum.sort()
 count = listNum.count(listNum[len(listNum) - 1])
 # print(count)
 c = 0
 while c < count:
     listNum.pop()
     c += 1
 print(listNum[len(listNum) - 1])

 # 精准方法二
 listnum = []
 val = 0
 num = 0
 while num < 5:
     val = int(input("请连续输入五个自然数："))
     listnum.append(val)
     num += 1
 print("您连续输入的数字为：" , listnum)
 listnum.sort(reverse = True)
 print("输入序列的长度为： %d" % len(listnum))

 num1 = 0
 while num1 < len(listnum)-1:
     if listnum[num1 + 1] < listnum[num1]:
         print("您输入序列中的第二大值为： %d" % listnum[num1 + 1])
         break
     num1 += 1
 if listnum.count(listnum[0]) == len(listnum):
     print("不存在第二大值，您输入的值都一样大")
 # 输出结果1：
 # 请连续输入五个自然数：10
 # 请连续输入五个自然数：10
 # 请连续输入五个自然数：20
 # 请连续输入五个自然数：30
 # 请连续输入五个自然数：50
 # 您连续输入的数字为： [10, 10, 20, 30, 50]
 # 输入序列的长度为： 5
 # 您输入序列中的第二大值为： 30

 # 输出结果2：
 # 请连续输入五个自然数：10
 # 请连续输入五个自然数：10
 # 请连续输入五个自然数：10
 # 请连续输入五个自然数：10
 # 请连续输入五个自然数：10
 # 您连续输入的数字为： [10, 10, 10, 10, 10]
 # 输入序列的长度为： 5
 # 不存在第二大值，您输入的值都一样大

4.3   列表的遍历

　　函：enumerate

　　　　语：enumerate(e, start = )

　　　　　　用：枚举函数，start= 表示从数字几开始记录枚举的起始，如果是0，就为0,1,2,3,4......为序号开始标记；如果为1，就为1,2,3,4,5，为序号开始标记；默认为从0开始。

 # 列表的遍历
 for i in [100, 200, 300, 400, 500]:
     print(i, end=" ")
 # 输出结果：100 200 300 400 500

 # 通过枚举的方式遍历列表元素
 for i, v in enumerate([100, 200, 300, 400, 500]):
     print(i, v)
 # 输出结果：
 # 0 100
 # 1 200
 # 2 300
 # 3 400
 # 4 500