1.概述

列表是python的基本数据类型之一,是一个可变的数据类型,用[]方括号表示,每一项元素使用逗号隔开,可以装大量的数据

#先来看看list列表的源码写了什么,方法:按ctrl+鼠标左键点list

class list(object):
"""
list() -> new empty list
list(iterable) -> new list initialized from iterable's items
"""
def append(self, p_object): # real signature unknown; restored from __doc__
""" L.append(object) -- append object to end """
pass def count(self, value): # real signature unknown; restored from __doc__
""" L.count(value) -> integer -- return number of occurrences of value """
return def extend(self, iterable): # real signature unknown; restored from __doc__
""" L.extend(iterable) -- extend list by appending elements from the iterable """
pass def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
"""
L.index(value, [start, [stop]]) -> integer -- return first index of value.
Raises ValueError if the value is not present.
"""
return def insert(self, index, p_object): # real signature unknown; restored from __doc__
""" L.insert(index, object) -- insert object before index """
pass def pop(self, index=None): # real signature unknown; restored from __doc__
"""
L.pop([index]) -> item -- remove and return item at index (default last).
Raises IndexError if list is empty or index is out of range.
"""
pass def remove(self, value): # real signature unknown; restored from __doc__
"""
L.remove(value) -- remove first occurrence of value.
Raises ValueError if the value is not present.
"""
pass def reverse(self): # real signature unknown; restored from __doc__
""" L.reverse() -- reverse *IN PLACE* """
pass def sort(self, cmp=None, key=None, reverse=False): # real signature unknown; restored from __doc__
"""
L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
cmp(x, y) -> -, ,
"""
pass def __add__(self, y): # real signature unknown; restored from __doc__
""" x.__add__(y) <==> x+y """
pass def __contains__(self, y): # real signature unknown; restored from __doc__
""" x.__contains__(y) <==> y in x """
pass def __delitem__(self, y): # real signature unknown; restored from __doc__
""" x.__delitem__(y) <==> del x[y] """
pass def __delslice__(self, i, j): # real signature unknown; restored from __doc__
"""
x.__delslice__(i, j) <==> del x[i:j] Use of negative indices is not supported.
"""
pass def __eq__(self, y): # real signature unknown; restored from __doc__
""" x.__eq__(y) <==> x==y """
pass def __getattribute__(self, name): # real signature unknown; restored from __doc__
""" x.__getattribute__('name') <==> x.name """
pass def __getitem__(self, y): # real signature unknown; restored from __doc__
""" x.__getitem__(y) <==> x[y] """
pass def __getslice__(self, i, j): # real signature unknown; restored from __doc__
"""
x.__getslice__(i, j) <==> x[i:j] Use of negative indices is not supported.
"""
pass def __ge__(self, y): # real signature unknown; restored from __doc__
""" x.__ge__(y) <==> x>=y """
pass def __gt__(self, y): # real signature unknown; restored from __doc__
""" x.__gt__(y) <==> x>y """
pass def __iadd__(self, y): # real signature unknown; restored from __doc__
""" x.__iadd__(y) <==> x+=y """
pass def __imul__(self, y): # real signature unknown; restored from __doc__
""" x.__imul__(y) <==> x*=y """
pass def __init__(self, seq=()): # known special case of list.__init__
"""
list() -> new empty list
list(iterable) -> new list initialized from iterable's items
# (copied from class doc)
"""
pass def __iter__(self): # real signature unknown; restored from __doc__
""" x.__iter__() <==> iter(x) """
pass def __len__(self): # real signature unknown; restored from __doc__
""" x.__len__() <==> len(x) """
pass def __le__(self, y): # real signature unknown; restored from __doc__
""" x.__le__(y) <==> x<=y """
pass def __lt__(self, y): # real signature unknown; restored from __doc__
""" x.__lt__(y) <==> x<y """
pass def __mul__(self, n): # real signature unknown; restored from __doc__
""" x.__mul__(n) <==> x*n """
pass @staticmethod # known case of __new__
def __new__(S, *more): # real signature unknown; restored from __doc__
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """
pass def __ne__(self, y): # real signature unknown; restored from __doc__
""" x.__ne__(y) <==> x!=y """
pass def __repr__(self): # real signature unknown; restored from __doc__
""" x.__repr__() <==> repr(x) """
pass def __reversed__(self): # real signature unknown; restored from __doc__
""" L.__reversed__() -- return a reverse iterator over the list """
pass def __rmul__(self, n): # real signature unknown; restored from __doc__
""" x.__rmul__(n) <==> n*x """
pass def __setitem__(self, i, y): # real signature unknown; restored from __doc__
""" x.__setitem__(i, y) <==> x[i]=y """
pass def __setslice__(self, i, j, y): # real signature unknown; restored from __doc__
"""
x.__setslice__(i, j, y) <==> x[i:j]=y Use of negative indices is not supported.
"""
pass def __sizeof__(self): # real signature unknown; restored from __doc__
""" L.__sizeof__() -- size of L in memory, in bytes """
pass __hash__ = None list

2.列表的索引和切片

#列表和字符串一样拥有索引和切片

#索引:下标从0开始

lst = ["赵四","刘能","谢大脚","谢腾飞","小蒙"]
print(lst[0]) #获取第一个元素
#赵四
print(lst[1])
#刘能
print(lst[2])
#谢大脚 print(lst[3][2]) #飞
#索引下标从0开始,3就是谢腾飞,2就是在谢腾飞中切012,就是飞 print(lst[-2]) #负就是从后面切,从-1开始,-2就是谢腾飞

#切片

lst = ["赵四","刘能","谢大脚","谢腾飞","小蒙"]
print(lst[1:4]) #['刘能','谢大脚','谢腾飞']
#列表和字符串一样,顾头不顾尾,不能切到4print(lst[-3:-1]) #['谢大脚', '谢腾飞'],顾头不顾尾所以不能切到小蒙print(lst[1::2]) #['刘能', '谢腾飞']
#从1开始到结束,每隔2个输出一个print(lst[-1:-5:-2]) #['小蒙', '谢大脚']
#-1到-5,但是顾头不顾尾就不能切到-5,-2就是从右往前切,每隔2个输出一个

3.列表的增删改查

#注意点:列表和str是不一样的,list可以发生改变,所以直接就在原来的对象上进行了操作
#例如:
lst = ["蒋小鱼","张冲","鲁炎","展大鹏"]
lst.append("阿甘")
print(lst) #['蒋小鱼', '张冲', '鲁炎', '展大鹏', '阿甘']

#3.1增加

#关键字
#append() 在后面追加
#insert() 指定位置添加
#extend() 迭代添加,也就是一个一个添加

#例子:

lst = ["蒋小鱼","张冲","鲁炎","展大鹏"]
lst.append("阿甘")
print(lst) #['蒋小鱼', '张冲', '鲁炎', '展大鹏', '阿甘'] lst.insert(2,"项羽") #在鲁炎的位置插入项羽,之前的元素相应的往后移
print(lst) #['蒋小鱼', '张冲', '项羽', '鲁炎', '展大鹏', '阿甘'] #如果使用字符串添加的话那么就是迭代一个一个添加
lst.extend("巴朗") #['蒋小鱼', '张冲', '鲁炎', '展大鹏', '巴', '朗'] #如果使用列表方式添加,那么就是一个元素
lst.extend(["巴朗"]) #['蒋小鱼', '张冲', '鲁炎', '展大鹏', '巴朗']
print(lst) #应用:交互输入员工信息,然后按Q退出,再打印输入的信息出来
# lst=[]
# while 1:
# content = input("请输入员工的信息,输入Q退出:")
# if content.upper() == 'Q':
# break
# lst.append(content)
# print(lst)

#3.2.删除

#pop()  #指定位置删除
#remove() #删除元素
#clear() #清空列表
#del() #切片删除

#例子:

lst = ["蒋小鱼","张冲","鲁炎","展大鹏"]
lst.pop() #不指定位置,默认删除最后一个
print(lst) #['蒋小鱼', '张冲', '鲁炎'] el = lst.pop(2) #删除2号元素
print(el) #可以查看有没有删除
#鲁炎
print(lst) #再返回列表查看有没有删了
# ['蒋小鱼', '张冲', '展大鹏'] lst.remove("张冲") #指定删除的元素
print(lst) #['蒋小鱼', '鲁炎', '展大鹏'] lst.remove("张三") #如果删除不存在的元素就会报错
print(lst) #报错 lst.clear() #清空
print(lst) del lst[1:3] #切片删除,因为顾头不顾尾所以删除1和2
print(lst) #['蒋小鱼', '展大鹏']

#3.3.修改

# 1、索引修改
# 2、切片修改

#例子:

lst = ["蒋小鱼","张冲","鲁炎","展大鹏","黑脸"]
lst[1] = "乌云" #将1号元素修改成乌云,也就是张冲改成乌云
print(lst) #['蒋小鱼', '乌云', '鲁炎', '展大鹏'] #切片:要注意后面的步长和元素的个数如果不对应的话就会报错
lst[1:4:3] = ["龙大队"]
print(lst) #['蒋小鱼', '龙大队', '鲁炎', '展大鹏', '黑脸'] # lst[1:4:3] = ["龙大队","张三"]
#这样就会报错,因为步长是3,上面只能切到一个,但是修改了两个,不对应,所以就会报错
# print(lst) lst[1:4] = ["大佬"] #将下标1-3替换成大佬
#如果切片没有步长或者步长是1,则不用关心个数
print(lst) #['蒋小鱼', '大佬', '黑脸']

#3.4.查询

#列表是一个可迭代对象,所以可以进行for循环
lst = ["张三","李四","王五","李六"]
for el in lst:
print(el)

4.列表的嵌套

#嵌套就是一层套着一层,列表套着列表
#采用降维操作,一层一层的看,
#就像洋葱一样,一层一层的拨开你的心

#例子:

lst = [1,"张三","蒋小鱼",["鲁炎","张冲",3,["黑脸","龙大队","xiaotian",4],],"乌云"]

#找到张冲
print(lst[3][1]) #张冲
#是按照从下标0开始找,3首先是找到第二个列表,然后再在第二个列表里面找到1张冲 #找到黑脸和龙大队
print(lst[3][3][0:2]) #['黑脸', '龙大队']
#也是按照一层一层的找,记住是顾头不顾尾的 #将xiaotian拿到,然后首字母大写,再扔回去
s = lst[3][3][2]
s = s.capitalize()
lst[3][3][2] = s
print(lst) #[1, '张三', '蒋小鱼', ['鲁炎', '张冲', 3, ['黑脸', '龙大队', 'Xiaotian', 4]], '乌云'] #简写
# lst[3][3][2] = lst[3][3][2].capitalize()
# print(lst) #将蒋小鱼替换成参谋长
s = lst[2]
s = s.replace("蒋小鱼","参谋长")
lst[2] = s
print(lst) #[1, '张三', '参谋长', ['鲁炎', '张冲', 3, ['黑脸', '龙大队', 'Xiaotian', 4]], '乌云'] #简写
# lst[2] = lst[2].replace("蒋小鱼","参谋长")
# print(lst)

5.列表的相关操作

#count() #查询出现的次数
#sort() #排序,默认升序
#len() #列表的长度

#例子:

lst = ["蒋小鱼","张冲","鲁炎","展大鹏","黑脸","蒋小鱼"]
c = lst.count("蒋小鱼") #查询蒋小鱼出现的次数
print(c) # lst.reverse() #反向打印
print(lst) #['蒋小鱼', '黑脸', '展大鹏', '鲁炎', '张冲', '蒋小鱼'] l = len(lst) #计算列表的长度
print(l) # #排序,默认升序
lst = [1,2,3,44,11]
lst.sort()
print(lst) #[1, 2, 3, 11, 44] #降序
lst = [1,2,3,44,11]
lst.sort(reverse=True)
print(lst) #[44, 11, 3, 2, 1]

#循环删除的坑点

######循环删除列表中的每一个元素(有坑)####
#方法:1.可以使用clear()清空,
# 2.使用另外一种方法,循环删 #首先来个坑,删不掉的
lst = [11,22,33,44,55]
for e in lst:
lst.remove(e)
print(lst) #[22, 44]
#直接使用remove是删除不了的,因为删除的时候内部的索引在改变
# 当index=0的时候删除0的字符,当index=1的时候就向下移动了一位,但是列表里面的元素已经往前移填充了
# 所以当删除11,22就变成了第0个索引,当下次删除的时候就是删除第一个索引33,然后就漏掉了22,后面同样 #方法
#1.首先需要记录删除的东西
#2.然后循环要删除的列表,删除真正的列表 #例子:删除性张的
lst = ["张冲","张国荣","张曼玉","蒋小鱼"]
zhangs = [] #首先记录性张
for el in lst:
zhangs.append(el) #将之前的列表追加到zhangs里面
for e in zhangs:
lst.remove(e) #再删除原列表
print(lst) #[]
print(zhangs) #['张冲', '张国荣', '张曼玉', '蒋小鱼']

python之路-基本数据类型之list列表的更多相关文章

  1. python之路:数据类型初识

    python开发之路:数据类型初识 数据类型非常重要.不过我这么说吧,他不重要我还讲个屁? 好,既然有人对数据类型不了解,我就讲一讲吧.反正这东西不需要什么python代码. 数据类型我讲的很死板.. ...

  2. Python之路-基础数据类型之字典 集合

    字典的定义-dict 字典(dict)是python中唯⼀的⼀个映射类型.他是以{ }括起来的键值对组成,字典是无序的,key是不可修改的.dic = {1:'好',2:'美',3:'啊'} 字典的操 ...

  3. Python之路-基础数据类型之列表 元组

    列表的定义 列表是Python基础数据类型之一,它是以[ ]括起来, 每个元素用' , '隔开而且可以存放各种数据类型: lst = [1,2,'你好','num'] 列表的索引和切片 与字符串类似, ...

  4. 小白的Python之路 day1 数据类型,数据运算

    一.数据类型初识 1.数字 2 是一个整数的例子.长整数 不过是大一些的整数.3.23和52.3E-4是浮点数的例子.E标记表示10的幂.在这里,52.3E-4表示52.3 * 10-4.(-5+4j ...

  5. Python之路【第二篇】: 列表、元组、字符串、字典、集合

    本文内容: -------------------------------------- 列表.元组操作 字符串操作 字典操作 集合操作 文件操作 字符编码与转码 1. 列表(list) 序列是Pyt ...

  6. 百万年薪python之路 -- 基础数据类型的补充练习

    1.看代码写结果 v1 = [1,2,3,4,5] v2 = [v1,v1,v1] v1.append(6) print(v1) print(v2) [1,2,3,4,5,6] [[1,2,3,4,5 ...

  7. 百万年薪python之路 -- 基础数据类型的补充

    基础数据类型的补充 str: 首字母大写 name = 'alexdasx' new_name = name.capitalize() print(new_name) 通过元素查找下标 从左到右 只查 ...

  8. Python之路-基本数据类型

    一.数据类型 1.数字 包含整型和浮点型,还有复数2.字符 长度,索引,切片也适用于列表的操作 移除空白 strip() 默认字符串前后的空格,制表符,换行符 strip(";") ...

  9. python之路--基础数据类型的补充与深浅copy

    一 . join的用法 lst =['吴彦祖','谢霆锋','刘德华'] s = '_'.join(lst) print(s) # 吴彦祖_谢霆锋_刘德华 # join() "*" ...

随机推荐

  1. Gson、jackson 序列化,反序列化(单个、集合)

    实体类: package com.nf.redisDemo1.entity; public class News { private long id; private String title; pr ...

  2. 系统学习Javaweb7----JavaScript3

    学习内容: 1.JavaScript语法规则----全局函数 2.JavaScript语法规则----自定义函数 3.BOM对象 3.1BOM对象--消息框 3.2BOM对象--循环定时器 3.3BO ...

  3. 用C语言实现的轴对称变换

    #include<stdio.h> main() { int i,p,n,k,f,c,h,g,w; ][]; ;i<=;i++) { ;p<=;p++) { a[i][p]=i ...

  4. VisualStudio使用HALCIN_NET控件

    遵循以下步骤在一个应用中添加Halcon/.Net: 一. 定义工具箱 Halcon/.net 不仅提供了一个类库,而且提供了一个控件:HWindowControl,它包含一个显示图像处理结果的Hal ...

  5. python常用包

    今日所得 collections模块 时间模块 random模块 os模块 sys模块 序列化模块 subprocess模块 collections模块 namedtuple:具名元组 #定义方式一: ...

  6. 一个类似ThinkPHP的Node.js框架——QuickNode

    QuickNode Node.js从QuickNode开始,让restful接口开发更简单! PHP的MVC 作为一名曾经的PHP开发者,我也有过三年多的thinkphp使用经验,那是我学习PHP接触 ...

  7. SpringMVC学习笔记二:参数接受

    该项目用来介绍SpringMVC对参数接受的方法: 项目目录树:在前一个项目上修改添加 新添加了Student类和Group类,用来测试整体参数接受 Student.java package com. ...

  8. PHP常用接口数据过滤的方法

    <?php /** * global.func.php 公共函数库 */ /** * 返回经addslashes处理过的字符串或数组 * @param $string 需要处理的字符串或数组 * ...

  9. java 项目乱码解决(web.xml全局配置编码格式)

    <!-- 乱码解决 --> <filter> <filter-name>encodingFilter</filter-name> //过滤器名称 < ...

  10. 翻译:谷歌HTML、CSS和JavaScript风格规范

    我喜欢浏览风格规范.他们通常有明显的规则,虽然有些有荒诞之感,但是却可以发现之前未注意到的宝石.不幸的是,鲜有公司有这个勇气来发布自己内部的风格规范.BBC 2010年时候公开其文档以及Google最 ...