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

最新文章

  1. C++获取当前目录
  2. UIButton在Disabled状态下标题混乱的问题
  3. macOSX 访问 win7共享文件
  4. ligerui ligerTip气泡提示信息
  5. Java多线程-新特征-阻塞队列ArrayBlockingQueue
  6. Java与WCF交互（一)：Java客户端调用WCF服务
  7. windows下游戏服务器端框架Firefly安装说明及demo运行
  8. xp主机用VMware9和10安装Ubuntu12.04后无法进入图像界面
  9. Spark任务调度流程及调度策略分析
  10. PHP实现简单爬虫
  11. Google SRE
  12. vue的一些注意点
  13. 汇编语言--CPU资源和存储器（二）
  14. ThreadLocal终极源码剖析-一篇足矣！
  15. 老男孩Python全栈视频
  16. 揭开Redis的神秘面纱
  17. js--call( )/apply()/bind()--应用
  18. WPF datagrid 设置表头线与颜色、透明度
  19. ubantu 操作
  20. QT编译错误：invalid application of &#39;sizeof&#39; to incomplete type &#39;Qt3DRender::QPickEvent&#39;

热门文章

  1. yarn storm spark
  2. 前台图片Canvas压缩上传小结
  3. SpringMVC使用可以访问静态资源，但是导致Controller访问失败
  4. 发送邮件的几种方法（C#发邮件 和 js前台实现都有）C#后台自动发邮件 js发邮件
  5. mysql初始化出现：FATAL ERROR: Neither host &#39;DB01&#39; nor &#39;localhost&#39; could be looked up with
  6. c# 数据库操作,多数据库操作、数据库操作异常报错等问题
  7. quartz详解3：quartz数据库集群-锁机制
  8. 为什么 execute(`echo 中文`) 输出中文源码？
  9. 前端框架vue学习笔记
  10. CodeForces - 748F Santa Clauses and a Soccer Championship