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]))
# 输出结果：
# 3
# <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]
# 33716552
# 37340360
# 通过深拷贝两个列表的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