列表

列表是Python中最基本的数据结构,列表是最常用的Python数据类型,列表是一个数据的集合,集合内可以放任何数据类型,可对集合方便的增删改查操作。Python已经内置确定序列的长度以及确定最大和最小的元素的方法

序号 函数 描述
1 list.append(self,p_object) 给列表后面追加新的对象
2 list.clear(self) 清空列表中的元素
3 list.copy(self) 浅复制列表
4 list.count(self,value) 统计某个元素在列表中出现的次数
5 list.extend(self,iterable) 在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
6

list.index(self, value, start=None, stop=None)

从列表中找出某个值第一个匹配项的索引位置
7 list.insert(self,index,start=None,stop=None) 将对象插入列表
8 list.pop(self,index=None) 移除列表中的一个元素(默认最后一个),并返回该元素的值
9 list.remove(self,value) 移除列表中某个值的第一个匹配项,从左找到第一个指定元素
10 list.reverse(self,value) 反向列表中的元素
11 list.sort(self,key=None,reverse=False) 对原列表进行排序

列表方法

一,List list()方法

  list()方法将元组转换为列表

  注意:元祖与列表是非常相似的,区别在于元组的元素值不能修改,元祖是放在括号中,列表是放在方括号里面的。

  1. a_tuple = ('123','abc',123)
  2. a_list = list(a_tuple)
  3. print(a_tuple)
  4. print(a_list)
  5. 结果:
  6. ('123', 'abc', 123)
  7. ['123', 'abc', 123]

二,创建一个列表

  只要把逗号分隔的不同的数据项使用方括号括起来即可。如下:

  1. a_list = [1,2,3,4,5,6]
  2. b_list = ['a','b','c','d']
  3. c_list = ['a','b','c',1,2,3,4]

三,访问列表中的值

  与字符串的索引一样,列表索引从0开始。列表可以进行截取、组合等。使用下标索引来访问列表中的值,同样你也可以使用方括号的形式截取字符,如下所示:

  1. a_list = [1,2,3,4,5,6]
  2. b_list = ['a','b','c','d']
  3. c_list = ['a','b','c',1,2,3,4]
  4. print(a_list[0])
  5. print(b_list[1:3])
  6. print(c_list[:])
  7. 结果:
  8. 1
  9. ['b', 'c']
  10. ['a', 'b', 'c', 1, 2, 3, 4]

四,更新列表

  可以对列表的数据项进行修改或更新,你也可以使用append()方法来添加列表项,如下所示:

  1. a_list = [1,2,3,4,5,6]
  2. b_list = ['a','b','c','d']
  3. c_list = ['a','b','c',1,2,3,4]
  4. a_list[0] = 123
  5. print(a_list)
  6. b_list.append("efg")
  7. print(b_list)
  8. 结果:
  9. [123, 2, 3, 4, 5, 6]
  10. ['a', 'b', 'c', 'd', 'efg']

五,删除列表元素

  1,可以使用 del 语句来删除列表的的元素,

  2,可以使用pop()移除某元素并返回该元素,

  3,使用remove()删除从左找到的第一个指定元素,如下实例:

  1. a_list = [1,2,3,4,5,6]
  2. b_list = ['a','b','c','d']
  3. c_list = ['a','b','c',1,2,3,41]
  4. del a_list[2]
  5. print(a_list)
  6. b = b_list.pop()
  7. print(b)
  8. c = c_list.pop(2) #也可以删除指定元素,并返回
  9. print(c)
  10. d = c_list.remove(1)
  11. print(c_list)
  12. 结果:
  13. [1, 2, 4, 5, 6]
  14. d
  15. c
  16. ['a','b','c',2,3,41]

六,列表脚本操作符

  列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表,* 号用于重复列表。

Python 表达式 结果 描述
len([1, 2, 3]) 3 长度
[1, 2, 3] + [4, 5, 6] [1, 2, 3, 4, 5, 6] 组合
['Hi!'] * 4 ['Hi!', 'Hi!', 'Hi!', 'Hi!'] 重复
3 in [1, 2, 3] True 元素是否存在于列表中
for x in [1, 2, 3]: print x, 1 2 3 迭代

七,列表操作函数

    1、cmp(list1, list2):比较两个列表的元素 
    2、len(list):列表元素个数 
    3、max(list):返回列表元素最大值 
    4、min(list):返回列表元素最小值 
    5、list(seq):将元组转换为列表

八,列表排序

  注意排序优先级:数字>大写字母>小写字母>符号>中文

  1,永久性排序:sort()

  2,临时性排序:sorted()

  3,反转排序:reverse()

  1. l1 = ["排序","?","123","w","W"]
  2. l2 = ['1','2','3']
  3. a = l1.sort() #永久性排序,就是这个列表就变了
  4. print(l1)
  5. b =sorted(l2) #临时性排序,就是可以赋值某个变量
  6. print(b)
  7. c = l1.reverse()
  8. print(l1)
  9. 结果:
  10. ['123', '?', 'W', 'w', '排序']
  11. ['1', '2', '3']
  12. ['排序', 'w', 'W', '?', '123']

九,遍历列表

  除了一般的遍历,还可以遍历切片列表

  1. list=['1','2','3']
  2. for value in list:#末尾加上冒号
  3. print(value)#每次循环都把list列表中的值赋给value,赋值从索引号0开始#循环的语句需要缩进
  4.  
  5. 结果:
  6. 1
  7. 2
  8. 3
  9.  
  10. list=['1','2','3','4','5','6','7']
  11. for value in list[3:]:#遍历索引3之后的数值
  12. print(value)
  13.  
  14. 结果:
  15. 4
  16. 5
  17. 6
  18. 7

十,创建数值列表

  1,使用range()函数生成一系列数值

  2,遍历range()函数生成的数值

  1. value=list(range(0,6))#range()生成0~6的数值,list()函数把数值转换成列表
  2. print(value)
  3. 结果:
  4. [0, 1, 2, 3, 4, 5]
  5.  
  6. for value in range(0,6):#range(0,6)顺序生成从05的数值
  7. print(value)
  8. 结果:
  9. 0
  10. 1
  11. 2
  12. 3
  13. 4
  14. 5
  15.  
  16. >>> range(1,5)#代表从15(不包含5)----------------[1, 2, 3, 4]
  17. >>> range(1,5,2) #代表从1到5,每次加2(不包含5)-----[1, 3]
  18. >>> range(5) #代表从0到5(不包含5)-----------------[0, 1, 2, 3, 4]

十一,复制列表

  1,复制整个列表

  2,复制切片列表

  1. list=['1','2','3','4','5']
  2. list_2=list[:]#从起始索引到末尾索引
  3. print(list_2)
  4. 结果:
  5. ['1', '2', '3', '4', '5']
  6.  
  7. list=['1','2','3','4','5']
  8. list_2=list[:]#从起始索引到索引3
  9. print(list_2)#输出['1','2','3']
  10. 结果:
  11. ['1', '2', '3', '4', '5']

十二,列表切片

切片操作(slice)可以从一个字符串中获取子字符串(字符串的一部分)。我们使用一对方括号、起始偏移量start、终止偏移量end 以及可选的步长step 来定义一个分片。

格式: [start:end:step]

  • • [:] 提取从开头(默认位置0)到结尾(默认位置-1)的整个字符串
  • • [start:] 从start 提取到结尾
  • • [:end] 从开头提取到end - 1
  • • [start:end] 从start 提取到end - 1
  • • [start:end:step] 从start 提取到end - 1,每step 个字符提取一个
  • • 左侧第一个字符的位置/偏移量为0,右侧最后一个字符的位置/偏移量为-1
  1. list = [1, 2, 3, 4, 5, 6, 7]
  2. >>> list[0:] #列出索引0以后的---------[1, 2, 3, 4, 5, 6, 7]
  3. >>> list[1:] #列出索引1以后的---------[2, 3, 4, 5, 6, 7]
  4. >>> list[:-1] #列出索引-1之前的-------[1, 2, 3, 4, 5, 6]
  5. >>> list[1:3] #列出索引1到3之间的-----[2]
  6.  
  7. #形成reverse函数的效果:
  8. >>> list[::-1]#[7, 6, 5, 4, 3, 2, 1]
  9. >>> list[::-2]#[7, 5, 3, 1]
  10.  
  11. >>> range(1,5)#代表从15(不包含5)----------------[1, 2, 3, 4]
  12. >>> range(1,5,2) #代表从1到5,每次加2(不包含5)-----[1, 3]
  13. >>> range(5) #代表从0到5(不包含5)-----------------[0, 1, 2, 3, 4]

十三,tuple,dict,list之间的转换

  直接声明的list和tuple无法通过dict()转换成dict类型

  直接声明的dict可以通过tuple()和list()分别转换成tuple和list类型(结果只包含了keys),可是此时却能通过dict()反转回原来的dict类型

13-1、字典
  1. dict = {'name': 'Zara', 'age': 7}
  2. #字典转为字符串
  3. str(dict)
  4. #字典可以转为元组
  5. tuple(dict)
  6. #字典可以转为元组
  7. tuple(dict.values())
  8. #字典转为列表
  9. list(dict)
  10. #字典转为列表
  11. dict.values

13-2、元组

  1. tup=(1, 2, 3, 4, 5,6,7,8)
  2. #元组转为字符串
  3. tup.__str__()
  4. #元组转为列表
  5. list(tup)
  6. #元组不可以转为字典

13-3、列表

  1. nums=[1, 3, 5, 7, 9, 11, 13];
  2. #列表转为字符串
  3. str(nums)
  4. #列表转为元组
  5. tuple(nums)
  6. #列表不可以转为字典

13-4、字符串

  1. str="(1,2,3)"
  2. #字符串转为元组
  3. tuple(eval(str))
  4. #字符串转为列表
  5. list(eval("(1,2,3)"))
  6. #字符串转为字典
  7. str1="{'name':'ljq', 'age':24}"
  8. eval(str1)

十四,列表的练习

写代码,要求实现下面每一个功能

  li=['alex','eric','rain']

  1,计算列表长度并输出

  2,列表中追加元素“servn",并输出添加后的列表

  3,请在列表的第一个位置插入元素‘tony’,并输出添加后的列表

  4,请修改列表位置元素‘kelly’,并输出修改后的列表

  5,请在列表删除元素‘eric’,并输出删除后的列表

  6,请删除列表中的第2个元素,并输出删除后的元素的值和删除元素后的列表

  7,请删除列表中的第三个元素,并输出删除后的列表

  8,请删除列表的第2到4个元素,并输出删除元素后的列表

  9,请用for len range输出列表的索引

  10,请使用enumrate输出列表元素和序号

  11,请使用for循环输出列表中的所有元素

  1. # li = ['alex','eric','rain']
  2. # 1,计算列表长度并输出
  3. # print(len(li))
  4. # 列表中追加元素“seven”,并输出添加后的列表
  5. # li.append('seven')
  6. # print(li)
  7. # 请在列表的第1个位置插入元素“Tony”,并输出添加后的列表
  8. # li.insert(1,'tony')
  9. # print(li)
  10. #请修改列表第2个位置的元素为“Kelly”,并输出修改后的列表
  11. # li[1] ='kelly'
  12. # print(li)
  13. # 请删除列表中的元素“eric”,并输出修改后的列表
  14. # a =li.pop(2)
  15. # print(li)
  16. # li.remove('eric')
  17. # print(li)
  18. # 请删除列表中的第2个元素,并输出删除元素后的列表
  19. # b =li.pop(1)
  20. # print(b)
  21. # print(li)
  22. # 请删除列表中的第2至4个元素,并输出删除元素后的列表
  23. # c = li[2:4]
  24. # d = set(li)-set(c)
  25. # # print(list(d))
  26. # del li[1:4]
  27. # print(li)
  28. # 请将列表所有的元素反转,并输出反转后的列表
  29. # e = li.reverse()
  30. # print(li)
  31. # 请使用for、len、range输出列表的索引
  32. # for i in range(len(li)):
  33. # print(i)
  34. # 请使用enumrate输出列表元素和序号(序号从100开始)
  35. # for index in enumerate(li):
  36. # print(index)
  37. # for index,i in enumerate(li,100):
  38. # print(index,i)
  39. # for i in li:
  40. # print(i)

十五,写代码,有如下元组,请按照功能要求实现每一个功能

  tu = ('alex','eric,'rain')

  1,计算元组的长度并输出

  2,获取元祖的第二个元素,并输出

  3,获取元祖的第1-2个元素,并输出

  4,请用for输出元祖的元素

  5,请使用for,len,range输出元组的索引

  6,请使用enumerate输出元组元素和序号,(从10开始)

  1. tu = ('alex','eric','rain')
  2. #   1,计算元组的长度并输出
  3. print(len(tu))
  4. #   2,获取元祖的第二个元素,并输出
  5. print(tu[1])
  6. #   3,获取元祖的第1-2个元素,并输出
  7. print(tu[0:2])
  8. #   4,请用for输出元祖的元素
  9. for i in tu:
  10. print(i)
  11. #   5,请使用for,len,range输出元组的索引
  12. for i in range(len(tu)):
  13. print(i)
  14. #   6,请使用enumerate输出元组元素和序号,(从10开始)
  15. for index,i in enumerate(tu,10):
  16. print(index,i)

十六,list中的append和extend的区别

  • list.append(object) 向列表中添加一个对象object
  • list.extend(sequence) 把一个序列seq的内容添加到列表中

举例如下:

使用append的时候,是将new_media看作一个对象,整体打包添加到music_media对象中。

  1. music_media = ['compact disc', '8-track tape', 'long playing record']
  2. new_media = ['DVD Audio disc', 'Super Audio CD']
  3. music_media.append(new_media)
  4. print music_media
  5. >>>['compact disc', '8-track tape', 'long playing record', ['DVD Audio disc', 'Super Audio CD']]

使用extend的时候,是将new_media看作一个序列,将这个序列和music_media序列合并,并放在其后面。

  1. music_media = ['compact disc', '8-track tape', 'long playing record']
  2. new_media = ['DVD Audio disc', 'Super Audio CD']
  3. music_media.extend(new_media)
  4. print music_media
  5. >>>['compact disc', '8-track tape', 'long playing record', 'DVD Audio disc', 'Super Audio CD']

十七,Python 统计列表中的重复项出现的次数的方法

  对一个列表,比如[1,2,2,2,2,3,3,3,4,4,4,4],现在我们需要统计这个列表里的重复项,并且重复了几次也要统计出来。

  方法1:

  1. mylist = [1,2,2,2,2,3,3,3,4,4,4,4]
  2. #myset是另外一个列表,里面的内容是mylist里面的无重复项
  3. myset = set(mylist)
  4.  
  5. for item in myset:
  6. res = mylist.count(item)
  7. print("the %d has found %d" %(item,mylist.count(item)))

  方法2:

  1. List=[1,2,2,2,2,3,3,3,4,4,4,4]
  2. a = {}
  3. for i in List:
  4. if List.count(i)>1:
  5. a[i] = List.count(i)
  6. print (a)

  利用字典的特性来实现。

  方法3:

  1. >>> from collections import Counter
  2. >>> Counter([1,2,2,2,2,3,3,3,4,4,4,4])
  3. Counter({1: 5, 2: 3, 3: 2})

  方法4:

  1. l=[1,4,2,4,2,2,5,2,6,3,3,6,3,6,6,3,3,3,7,8,9,8,7,0,7,1,2,4,7,8,9]
  2.  
  3. count_times = []
  4. for i in l :
  5. count_times.append(l.count(i))
  6.  
  7. m = max(count_times)
  8. n = l.index(m)
  9.  
  10. print (l[n])

  其实现原理就是把列表中的每一个数出现的次数在其对应的位置记录下来,然后用max求出出现次数最多的位置。只用这段代码的话,有一个缺点,如果有多个结果,最后的现实的结果只是出现在最左边的那一个,不过解决方法也很简单。

十八,sort与sorted函数排序的区别

  Python list内置sort() 方法用来排序,也可以使用Python内置的全局sorted() 方法对可迭代的序列排序生成新的序列。

sort()函数

  首先看一个例子:

  1. lis1 = [3,5,6,8,9]
  2. lis1.sort()
  3. print(lis1)

  使用sort()方法对list排序会修改list本身,不会返回新list,通常此方法不如sorted()方便,但是如果你不需要保留原来的list,此方法将更有效sort()。sort()方法不能对字典dict进行排序。

sorted() 函数

  再看一个例子:

  1. lis1 = [3,5,6,8,9,1]
  2. res = sorted(lis1)
  3. print(lis1)
  4. print(res)
  5. # [3, 5, 6, 8, 9, 1]
  6. # [1, 3, 5, 6, 8, 9]

  sorted()不会改变原来的list,而是会返回一个新的已经排序好的list。

python列表操作方法详解的更多相关文章

  1. python 列表操作方法详解

    列表是Python中最基本的数据结构,列表是最常用的Python数据类型,列表是一个数据的集合,集合内可以放任何数据类型,可对集合方便的增删改查操作.Python已经内置确定序列的长度以及确定最大和最 ...

  2. python 字符串操作方法详解

    字符串序列用于表示和存储文本,python中字符串是不可变对象.字符串是一个有序的字符的集合,用于存储和表示基本的文本信息,一对单,双或三引号中间包含的内容称之为字符串.其中三引号可以由多行组成,编写 ...

  3. python 字典操作方法详解

    字典是一种通过名字或者关键字引用的得数据结构,key 类型需要时被哈希,其键可以是数字.字符串.元组,这种结构类型也称之为映射.字典类型是Python中唯一內建的映射类型. 注意,浮点数比较很不精确, ...

  4. python 集合操作方法详解

    说集合之前,我们先说一个小例子,假设某公司有五个人喜欢打篮球,五个人喜欢打游戏,问即打游戏有打篮球 的人都有哪些? play_basketball = ['a','b','c','d','e'] pl ...

  5. python第七篇:Python 列表操作详解

    Python列表操作详解 list函数 list()   #生成一个空的列表 list(iterable)  #用可迭代对象初始化一个列表 列表的 and 运算和 or 运算 列表and运算 > ...

  6. python字符串操作方法详解

      字符串 字符串序列用于表示和存储文本,python中字符串是不可变对象.字符串是一个有序的字符的集合,用于存储和表示基本的文本信息,一对单,双或三引号中间包含的内容称之为字符串.其中三引号可以由多 ...

  7. python字典操作方法详解

    前言 字典是一种通过名字或者关键字引用的得数据结构,key 类型需要时被哈希,其键可以是数字.字符串.元组,这种结构类型也称之为映射.字典类型是Python中唯一內建的映射类型. 注意,浮点数比较很不 ...

  8. Python列表切片详解([][:][::])

    Python切片是list的一项基本的功能,最近看到了一个程序,里面有这样一句类似的代码: a = list[::10] 1 不太明白两个冒号的意思就上网百度,发现大多数人写的博客中都没有提到这一个用 ...

  9. python集合操作方法详解

    前言 说集合之前,我们先说一个小例子,假设某公司有五个人喜欢打篮球,五个人喜欢打游戏,问即打游戏有打篮球的人都有哪些? play_basketball = ['a','b','c','d','e'] ...

随机推荐

  1. lightoj 1408 概率dp

    https://blog.csdn.net/moon_sky1999/article/details/98097470 博主在此,牛逼神犇 #include<bits/stdc++.h> ...

  2. Spring Cloud netflix feign【服务间通信】

    一.简介 1,进程间通讯的本质是交换消息 2,服务间通信的两种方式 (1)RESTFul风格 (2)RPC风格 (3)两种风格的比较 3.基于RESTFul风格服务调用模型 4.基于Spring Cl ...

  3. 每日扫盲(一):java的rmi

    JAVA RMI 原理和使用浅析 本地对象调用 我们先看看本地对象方法的调用: ObjectClass objectA = new ObjectClass(); String retn = objec ...

  4. 那些年做过的ctf之加密篇(加强版)

    MarkdownPad Document *:first-child { margin-top: 0 !important; } body>*:last-child { margin-botto ...

  5. Vue - 如何使用npm run build后的dist文件夹

    脚手架vue cli生成项目后,使用 npm run build 生成了一个dist文件夹(应该是distribution的缩写) 只要放在http服务器上就可以运行. 使用一句python命令可以搭 ...

  6. Sunday算法浅谈

    一.Sunday算法简介 Sunday算法在我看来比起Kmp和bm都更加容易理解,代码实现也更加简洁.Sunday算法由Daniel M.Sunday在1990年提出,它的思想跟BM算法很相似只不过S ...

  7. Django框架之ORM的相关操作之分页(六)

    分页是每个项目必不可少要写的一个功能,该篇文章就将记录一下使用ORM写分页的过程. 假设我们的数据库里面需要显示一些数据,而这个表中的数据大约有几千条数据,那么我们不可能将所有的数据都显示出来,那么就 ...

  8. PP Bottle Have High Cycle Times

    This year, the participation of 0.1% -0.4% sorbitol nucleating agent in general PP can produce high- ...

  9. sqlserver查询使用with(nolock)详解

    所有Select加 With (NoLock)解决阻塞死锁 在查询语句中使用 NOLOCK 和 READPAST 处理一个数据库死锁的异常时候,其中一个建议就是使用 NOLOCK 或者 READPAS ...

  10. pthon中的基本运算

    格式化输出的三种方式 1.占位符 程序中经常会有这样的场景:要求用户输入信息,然后打印成固定的格式 比如要求用户输入用户名和年龄,然后打印如下格式: my name is xxx,my age is ...