Python全栈之路----数据结构—列表

1.列表是一个数据的集合,集合内可以放任何数据类型,可对集合进行方便的增删改查操作。列表里面的数可以重复。

L1 = [ ] #定义空列表
L2 = [ ‘a‘ , ‘b‘ , ‘c‘ , ‘d‘ ] #存四个值,索引为0-3
L3 = [ ‘abc‘ , [ ‘def‘ , ‘ghi‘ ] ] #嵌套列表

2.列表的功能:

创建,查询( L[n]索引值为n的元素;L.count(n)查找有多少个元素为n;L.index(n)查找元素为n的索引值),切片,增加(L.append(n)在最后加入为n的元素;L.insert(m,n)在索引值为m的位置插入元素n),修改,删除(L del[n]删除索引值为n的元素;L.remove(n)删除从左边数第一个为n的元素;L.pop()删除最后一个元素,返回最后一个元素的值),循环,排序(字符和数字单独排序,L.sort()正序 ;L.reserve()倒序)。

 1 >>> L2 = [‘a‘,‘b‘,‘c‘,‘d‘,‘e‘,1,2] #创建一个列表
 2 >>> L2[2] #通过索引取值
 3   ‘c‘
 4  >>> L2[-1] #通过索引从裂变右边开始取值
 5   2
 6  >>> L2.index(‘a‘) #返回指定元素索引值,从左向右查找,找到第一个匹配的字符的位置
 7   0
 8  >>> L3 = [1,1,1,1,1,1,2,2,2,2,2,3,3,3,3,3,3,3,4,4,4,5,5,8,8,8,8,8,8]
 9  >>> L3[2] #通过索引值取值
10  1
11  >>> L3.count(3) #查找有多少个字符为3的索引
12  7
13  >>> n = L3.index(2)
14  >>> L3[n] #n是L3种2的索引值,L3[n]是索引值为n的元素
15  2
16  >>> L3[L3.index(2)]
17  2
18  >>> L3[0:3] #列表切片,顾头不顾尾
19  [1, 1, 1]
20  >>> L3[-5:-1] #后面的列表切片,顾头不顾尾
21  [8, 8, 8, 8]
22  >>> L3[-5:] #-5位置的字符及其后面的所有字符
23  [8, 8, 8, 8, 8]
24  >>> L3[:3]
25  [1, 1, 1]
26  >>> L3[:] #和L3输出结果一致
27  [1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 5, 5, 8, 8, 8, 8, 8, 8]
28  >>> L3[:7:2] #0-6切片,先取L3[0],然后每两个取一个
29  [1, 1, 1, 2]
30  >>> L3[:9:3] #3叫做步长
31  [1, 1, 2]
32  >>> L3.append(‘Alex‘) #在列表最后面追加字符
33  >>> L3
34  [1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 5, 5, 8, 8, 8, 8, 8, 8, ‘Alex‘]
35  >>> L3.insert(0,‘Jane‘) #在列表索引值为0的位置插入数据Jane
36  >>> L3
37  [‘Jane‘, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 5, 5, 8, 8, 8, 8, 8, 8, ‘Alex‘]
38  >>> L3[3] = ‘Mary‘ #把索引值为3的位置的元素替换成Mary
39  >>> L3
40  [‘Jane‘, 1, 1, ‘Mary‘, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 5, 5, 8, 8, 8, 8, 8, 8, ‘Alex‘]
41  >>> L3[4:6] = ‘PeiQi‘ #批量修改,由于位置不够,PeiQi被拆分,后面的元素后移
42 >>> L3
43  [‘Jane‘, 1, 1, ‘Mary‘, ‘P‘, ‘e‘, ‘i‘, ‘Q‘, ‘i‘, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 5, 5, 8, 8, 8, 8, 8, 8, ‘Alex‘]
44  >>> L3.pop() #删除最后一个元素,返回最后一个元素的值
45  ‘Alex‘
46  >>> L3.remove(4) #删除从左边数第一个为4的元素
47  >>> L3
48  [‘Jane‘, 1, 1, ‘Mary‘, ‘P‘, ‘e‘, ‘i‘, ‘Q‘, ‘i‘, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 5, 5, 8, 8, 8, 8, 8, 8]
49  >>> del L3[3] #全局性指令,删除索引值为3的元素
50  >>> L3
51  [‘Jane‘, 1, 1, ‘P‘, ‘e‘, ‘i‘, ‘Q‘, ‘i‘, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 5, 5, 8, 8, 8, 8, 8, 8]
52  >>> del L3[8:16] #批量删除,顾头不顾尾
53  >>> L3
54  [‘Jane‘, 1, 1, ‘P‘, ‘e‘, ‘i‘, ‘Q‘, ‘i‘, 3, 3, 3, 3, 3, 4, 4, 5, 5, 8, 8, 8, 8, 8, 8]

(3)列表是有序的,但int和str类型不能一起排序。str按照ASCII排序,sort是排序,reverse是顺序反过来,extend是扩展,clear是把整个列表清空,copy是拷贝。

copy:  查看内存地址  id(i)  变量有地址,列表本身有一个地址,列表中的每一个元素又都有自己单独的地址

如果 a = 1   a = b  ,b指向的是1,不是a,b不随着a的变化而变化;

如果L1 = L ,L1指向L的内存地址,将L的内存地址比作一个装了很多水果的果盘,那么L1也指的是这个果盘,那么L变化实际是果盘变化,所以L1随L的变化而变化,同时L也会随L1的变化而变化;

如果L1 = L.copy(),将L的内存地址比作一个装了很多水果的果盘,那么L1指的是将这个果盘复制的一个新果盘,但是果盘里的水果并没有被复制,水果是两个果盘共享,所以L变化是旧果盘变化,新果盘不变,所以L1不随L的变化而变化;

>>> L = [‘a‘,‘d‘,‘b‘,‘r‘,‘A‘]
>>> L.sort() #将L排序
>>> L
[‘A‘, ‘a‘, ‘b‘, ‘d‘, ‘r‘]>>> L.insert(2,‘*‘)
>>> L.insert(3,‘#‘)
>>> L
[‘A‘, ‘a‘, ‘*‘, ‘#‘, ‘b‘, ‘d‘, ‘r‘]
>>> L.sort() #按照ASCI码排序
>>> L
[‘#‘, ‘*‘, ‘A‘, ‘a‘, ‘b‘, ‘d‘, ‘r‘]
>>> L.reverse() #把顺序反过来
>>> L
[‘r‘, ‘d‘, ‘b‘, ‘a‘, ‘A‘, ‘*‘, ‘#‘]
>>> L4 = [1,2,3,4]
>>> L + L4 #L和L4拼接在一起
[‘r‘, ‘d‘, ‘b‘, ‘a‘, ‘A‘, ‘*‘, ‘#‘, 1, 2, 3, 4]
>>> L.extend(L4) #把L4扩展到L里面
>>> L
[‘r‘, ‘d‘, ‘b‘, ‘a‘, ‘A‘, ‘*‘, ‘#‘, 1, 2, 3, 4]
>>> L.clear() #清空
>>> L
[]
>>> L = [1,2,4,5]
>>> L.copy()
[1, 2, 4, 5]
>>> L1 = L.copy()
>>> L1
[1, 2, 4, 5]
>>> L=[3,4,5]
>>> L1
[1, 2, 4, 5]
>>> L1 = L
>>> L[2] = ‘Alex‘
>>> L
[3,4, ‘Alex‘]
>>> L1
[3,4, ‘Alex‘]

(4)深浅copy

①浅copy:n3 = names   两个列表中的小列表元素改变同步,其余元素独立改变

>>> names = [‘alex‘,‘jack‘,‘jane‘,[‘LT‘,‘19‘]]
>>> n3 = names.copy()
>>> names
[‘alex‘, ‘jack‘, ‘jane‘, [‘LT‘, ‘19‘]]
>>> n3
[‘alex‘, ‘jack‘, ‘jane‘, [‘LT‘, ‘19‘]]
>>> names[0] = ‘Alex‘
>>> names
[‘Alex‘, ‘jack‘, ‘jane‘, [‘LT‘, ‘19‘]]
>>> n3
[‘alex‘, ‘jack‘, ‘jane‘, [‘LT‘, ‘19‘]]
>>> n3[2] = ‘Jane‘
>>> n3
[‘alex‘, ‘jack‘, ‘Jane‘, [‘LT‘, ‘19‘]]
>>> names
[‘Alex‘, ‘jack‘, ‘jane‘, [‘LT‘, ‘19‘]]
>>> n3[3][1] = 20
>>> n3
[‘alex‘, ‘jack‘, ‘Jane‘, [‘LT‘, 20]]
>>> names
[‘Alex‘, ‘jack‘, ‘jane‘, [‘LT‘, 20]]

②深copy:将列表完全复制,两个列表完全独立

>>> import copy
>>> n = copy.deepcopy(names)
>>> n
[‘Alex‘, ‘jack‘, ‘jane‘, [‘LT‘, 20]]
>>> n[3][0] = ‘LongTing‘
>>> n
[‘Alex‘, ‘jack‘, ‘jane‘, [‘LongTing‘, 20]]
>>> names
[‘Alex‘, ‘jack‘, ‘jane‘, [‘LT‘, 20]]

原文地址:https://www.cnblogs.com/Moxiaoyu666/p/10257606.html

时间: 2024-07-29 20:30:47

Python全栈之路----数据结构—列表的相关文章

Python全栈之路系列之赋值与运算符

Python全栈之路系列之赋值与运算符 在继续下面的文章之前我们先来浏览一下Python为我们提供的几种运算符,定义两个变量,分别是a和b,a的值是10,b的值是20. 算术运算符 运算符 描述 实例 + 加,两个对象相加 a+b=30 - 减,两个对象相减,可能会得到负数 a-b=-10 * 乘,两数相称或是返回一个被重复若干次的字符串 a*b=200 / 除,两个对象相除 b/a=2 % 取膜,返回除法的余数 b%a=0 ** 幂,返回x的y次幂 a**b=10000000000000000

Python全栈之路_01

Python全栈之路 前言:因为Python主要是在Linux和widows操作系统上使用所以,首先就介绍Pyhton在这两个平台上的安装和一些基础知识 Linux系统下安装Pyhton 1.工具 虚拟机:VMware workstation 12 Pro Linux系统:CentOS 64 位 VMware虚拟机安装很简单就不说明了. 在虚拟机安装CentOS 需要注意的是: 运行内存分配1G左右即可 可以开机按F2进入bios界面boot目录下选择启动设备选择Hard Drive为优先启动位

python 全栈之路

python 全栈之路 一. python 1. Python基础知识部分 Python Python那点事 Python windows和linux下 安装 Python2,Python3 Python 开启入坑之路 Python 基本数据类型 Python 那些零碎的知识点 Python -函数 Python - 面对对象 Python - 模块 Python - 文件操作 Python - python中经常踩得的坑 2. Python - 网络编程 3. Python - 并发编程 二.

Python全栈之路----常用模块----hashlib加密模块

加密算法介绍 HASH       Python全栈之路----hash函数 Hash,一般翻译做“散列”,也有直接音译为”哈希”的,就是把任意长度的输入(又叫做预映射,pre-image),通过散列算法,变换成固定长度的输出,该输出就是散列值.这种转换是一种压缩映射,也就是,散列值的空间通常远小于输入的空间,不同的输入可能会散列成相同的输出,而不可能从散列值来唯一的确定输入值. 简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数. HASH主要用于信息安全领域中加密算法,他把一

Python全栈之路Day22

初次编辑2017年10月28日,星期六 摘要一. 上节课复习二. 协程函数初始化装饰器三. send实现爬网页四. 面向过程的程序设计五. 列表生成式六. 三元表达式七.生成器表达式八. 声明式编程作业今日总结 摘要 引用:百度 列表生成式 生成器表达式 面向过程编程 递归 一. 上节课复习 可迭代的:对象有__iter__方法的都是可迭代的对象 迭代器:对象 .iter()得到的结果就是迭代器 迭代器的特征: 迭代器.next()取下一个值 优点: 提供了一种统一的迭代对象的方式,不依赖于索引

Python全栈之路----函数----返回值

函数外部的代码想要获取函数的执行结果,就可以在函数里用return语句,把结果返回. def stu_register(name,age,course='PY',country='CN'): print('----注册学生信息----') print('姓名:',name) print('年龄:',age) print('国籍:',country) print('课程:',course) if age > 22: return False else: return True registriat

Python全栈之路---运算符与基本的数据结构

运算符 一.算术运算符: 练习: + 加法 两个对象相加 1 + 2得到3:'a' + 'b'得到'ab'. - 减法 一个数减去另一个数或者是负数 5 - 3得到2:-2得到一个负数 * 乘法 两个数相乘或者返回一个被重复若干次的字符串 -5.2得到一个负数.50 - 24得到26. ** 幂 返回x的y次幂 3 ** 4得到81(即3 * 3 * 3 * 3) / 除 x除以y 4/3得到1(整数的除法得到整数结果).4.0/3或4/3.0得到1.3333333333333333 // 取整

Python全栈之路系列----之-----面向对象4接口与抽象,多继承与多态)

接口类与抽像类 在python中,并没有接口类这种东西,即便不通过专门的模块定义接口,我们也应该有一些基本的概念 编程思想 归一化设计: 1.接口类 不实现具体的方法,并且可以多继承 2.抽象类 可以做一些基础实现,并且不推荐多继承 编程的几类原则: 开放封闭原则:对扩展示开放的,对修改是封闭的依赖倒置原则:高层模块不应该依赖低层模块,二者都应该依赖其抽象:抽象不应该应该依赖细节:细节应该依赖抽象.换言之,要针对接口编程,而不是针对实现编程接口隔离原则:使用多个专门的接口,而不使用单一的总接口.

python全栈之路【四】测试 2

1.请用代码实现:利用下划线将列表的每一个元素拼接成字符串,li = ['alex', 'eric', 'rain'] li = ['alex', 'eric', 'rain'] v = "_".join(li) print(v) alex_eric_rain 2.查找列表中元素,移除每个元素的空格,并查找以 a 或 A 开头 并且以 c 结尾的所有元素. li = ["alec", " aric", "Alex", &quo