Python容器：列表、元组、字典与集合
python--序列，字符串，列表，元组，字典，集合内存分析
python--序列，字符串，列表，元组，字典，集合内存分析⼀，什么是序列、 序列是⼀种数据存储⽅式，⽤来存储⼀系列的数据，在内存（堆内存）中，序列是⼀块⽤来存放多个值的连续的内存空间，其存储的值为所指向对象的地址。
⽐如说a = [ 10 , 20 , 30 , 40 ]在内存中实际是按照以下⽅式存储的。
下图中序列存储的是整数对象的地址，⽽不是整数对象的值。
python中常⽤的序列结构有：字符串，列表，元组，字典，集合列表：⼀，什么是列表？ 是⼀种⽤来存储任意数⽬，任意类型的数据集合。
⼆，列表的底层原理是什么？ 参照上图三，列表的三种创建⽅式 1.基本语法 [ ] 创建a = [ 1, 2 , "abc" ]a = [ ] 2，list()创建：使⽤list（）可以将任何可迭代对象转化为列表a = list( )a = list(range(10))注意：range的语法格式： range([start],end,[step]) start:可选，表⽰起始数字，默认是0 end：必选，表⽰结尾数字 step：可选，表⽰步长，默认是1，可正可负 python3中range（）返回的是⼀个range对象，⽽不是列表，我们需要通过list（）⽅法将其转换为列表对象 3.推导式⽣成列表a = [ x*2 for x in range( 5 ) if x%3==0 ]第⼀步：range（5）为，[ 0，1，2，3，4 ]第⼆步：每个x分别乘2。
[ 0，2，4，6，8 ]第三步：判断是否为3的倍数。
[ 6 ]四，对列表的操作（添加元素，删除元素，访问元素，切⽚，排序）添加元素（5种）当列表增加和删除元素时，列表会⾃动进⾏内存管理，⼤⼤减少程序员的负担。
但这个特点涉及列表元素的⼤量移动，效率较低。
（当在中间插⼊或删除元素时，实质上是对数组的拷贝，故⽽效率较低）除⾮必要，我们⼀般只在列表的尾部添加元素或者删除元素，这会⼤⼤提⾼列表的操作效率。
python的标准数据类型
python的标准数据类型
python的标准数据类型有以下几种：
1. 布尔型：布尔型是一种只有两个值True/ False的数据类型，可
用于逻辑判断。
3. 字符串类型：字符串类型，是由0或者多个字符组成的有序序列，可分为字节字符串（bytes）和文本字符串（str）。
4. 列表类型：列表类型，是python中最常用的数据类型，可以包含
任何类型的元素，元素可以是数字、字符串、元组、字典等，也可以是另
一个列表。
5. 元组类型：元组类型，是python中另一种序列类型，元组和列表
相同，都由序列中的元素组成，不同的是，元组中的元素不能修改，元组
可以当做字典中的键使用。
6. 字典类型：字典类型，是python中常用的映射类型，类似于关系
型数据库中的表，由一系列键值对组成，其中的键必须是唯一的，而键对
应的值可以是任何数据类型。
7. 集合类型：集合类型，是python中另一种可变容器，由唯一的元
素组成，可以用来存储不重复的元素，可以用来去重等操作。
8. 文件类型：文件类型，是python中用来操作文件的类型，可以用
来读取文件中的数据，写入数据到文件中等操作。
对列表 元祖 字典和集合总结
对列表元祖字典和集合总结说到列表、元组、字典和集合，它们就像是你日常生活中的四个好朋友，每个都有不同的脾气和特点，就像你身边的同学，有人爱记东西，有人爱丢东西，有人啥都不记，啥都不丢。
你跟这几位打交道的方式，差别也挺大，所以今天就跟大家聊聊这几位“朋友”的事儿，怎么个性分明，每个在什么场合下最好用。
先说说列表（List）。
这哥们儿就跟你平时用的购物清单差不多，总是把需要的东西一个一个列出来，不论多复杂的事，他都能逐项记录。
记得上个月我去超市买菜，照着购物单走了一圈，根本没忘记拿任何东西——香蕉、苹果、鸡胸肉、牛奶，啥都不漏，按顺序一个一个拎。
你看，列表的优点就在那里，顺序感强，每个东西都能按位置拿出来，而且还可以随时改动，加入新的东西或者把不想要的去掉。
遇到不合适的地方，随时插进去，完全不拘泥。
这种灵活性在你搞事情的时候特别有用，像是拿一个大包，你把一件件物品放进去，想加啥都行。
但是，这哥们儿也有个小问题，就是特别爱“变”，你随时可以给他换位置、加东西，弄得他像个大杂烩，有时候你把原来整理得整整齐齐的东西弄乱了，也挺容易的。
记得有次我把购物清单突然改来改去，结果走到结账时，发现香蕉被漏掉了，气得我差点退货。
就是这个“可变性”，有时候真的让人着急。
再说说元组（Tuple）。
这哥们儿就跟你的结婚证或者出生证明差不多，一旦定了，就不能随便改动了。
它的特点就是：一旦创建好，啥都不能改了。
记得我去年跟朋友一起去旅行，做了个旅行计划表，确定了时间、地点、预算，按计划一切都挺顺利。
后来，有个朋友提议说要不要加个新的景点，结果大家一看，计划表一旦定了，谁都不能再随便加改了。
那个时候大家有点后悔没在开始时就加上，但也没办法。
元组就是这么个死板的人，一旦给了你个方向，就得照着走，想加点啥或者改个什么都不行。
你会想，既然不能改动，那它到底有什么好处呢？其实，元组的好处在于它的“稳定性”。
它不会像列表那样轻易被修改，而且比列表要更快，因为它的内容不可变，你不可能突然把它搞乱。
列表 元组 集合 字典 的相同点和不同点
列表元组集合字典的相同点和不同点1. 引言列表、元组、集合和字典是Python中常用的数据结构。
它们都有各自的特点和用途，同时也有许多相同点和不同点。
本文将就这四种数据结构的相同点和不同点展开讨论，旨在帮助读者全面理解它们的特点和适用场景。
2. 列表列表是Python中最常用的数据结构之一，用于存储多个元素。
列表使用方括号[]表示，其中的元素可以是任意数据类型，包括数字、字符串、布尔值等。
列表是可变的，可以通过索引来访问和修改其中的元素。
列表的特点包括：- 有序性：列表中的元素按照插入的顺序排列，并保持不变。
- 可变性：列表中的元素可以随时增加、删除或修改。
- 允许重复元素：列表中的元素可以重复出现。
3. 元组元组与列表类似，也是用于存储多个元素的数据结构。
不同之处在于，元组使用圆括号()表示，并且是不可变的，即一旦创建就不能修改。
元组的特点包括：- 有序性：元组中的元素按照插入的顺序排列，并保持不变。
- 不可变性：元组一旦创建，其中的元素不能被修改、删除或增加。
尽管元组的元素无法修改，但可以通过索引来访问其中的元素。
元组的不可变性使得它在一些场景下更加安全和高效。
4. 集合集合是一种无序的数据结构，用于存储唯一的元素。
集合使用大括号{}表示，其中的元素不允许重复。
集合是可变的，可以通过add()和remove()等方法来增加或删除元素。
集合的特点包括：- 无序性：集合中的元素没有明确的顺序，每次遍历结果可能不同。
- 唯一性：集合中的每个元素都是唯一的，不允许重复。
由于集合的唯一性特点，它常用于去重和判断元素是否存在的场景。
5. 字典字典是一种无序的键值对数据结构，用于存储多个元素。
字典使用大括号{}表示，其中的元素由键和值组成，键和值之间使用冒号:分隔。
字典的特点包括：- 键值对：字典中的元素由键和值组成，用于表示一对一的关系。
- 无序性：字典中的元素没有明确的顺序，每次遍历结果可能不同。
- 键的唯一性：字典中的键是唯一的，不允许重复。
练习题-Python基本数据类型
练习题-Python基本数据类型Python基本数据类型1.说⼀下基本数据类型有哪些整型（int）作⽤：记录年龄、⾝份证号、个数等等定义：age = 1812345浮点型（float）作⽤：记录薪资、⾝⾼、体重定义:salary = 3.3height = 1.87weight = 70.31234567字符串类型（str）作⽤：记录描述性质的状态，名字、⼀段话定义：⽤引号（''，""，''' '''，""" """，）包含的⼀串字符如：name = 'xxq'123456列表（list）按位置记录多个值（同⼀个⼈的多个爱好、同⼀个班级的所有学校姓名、同⼀个⼈12个⽉的薪资）并且可以按照索引取指定位置的值定义：在[]内⽤逗号分隔开多个任意类型的值,⼀个值称之为⼀个元素如：list1 = [1,2,3,4,'5','六']注意点：索引对应值，索引从0开始，0代表第⼀个12345678910字典（dic）作⽤：⽤来存多个值，每个值都有唯⼀⼀个key与其对应，key对值有描述性功能定义：在{}内⽤逗号分开各多个 key：value如：info={"name":'xxq',"age":18, "gender":'male'}123456布尔类型（bool）作⽤：⽤来记录真假这两种状态定义：is_ok = Trueis_ok = False其他使⽤：通常⽤来当作判断的条件，我们将在if判断中⽤到它1234567元组类型（tuple）按照索引/位置存放多个值，只⽤于读，不⽤于改定义：t = (1,1.3,'aaa')注意点：1.单独⼀个括号，代表包含的意思x = (10)2.如果元组中只有⼀个元素，必须加逗号x = (10,)3.元组不能改，指的是不能改⾥⾯的内存地址t = (1,[11,22])print(t,id(t[0]),id(t[1]))t[1][0] = 33 # 元组内的列表的元素还是可以改的print(t,id(t[0]),id(t[1]))(1, [11, 22]) 2038884272 59297864(1, [33, 22]) 2038884272 5929786412345678910111213141516171819集合类型（set）作⽤：关系运算、去重定义：在 {} 内通逗号隔开多个元素，多个元素满⾜以下条件：1.集合内的元素必须为不可变类型2.集合内的元素⽆序3.集合内的元素没有重复12345678 2.说⼀下交互什么是交互？交互就是⼈和计算机互动，⼈输⼊信息，计算机获取后，输出信息给⼈，循环往复的这个过程，就是交互。
Python中的列表、元组、字典和集合教案
Python中的列表、元组、字典和集合教案一、教学目标1.理解Python中列表、元组、字典和集合的基本概念。
2.掌握列表、元组、字典和集合的创建、访问和修改方法。
3.了解列表、元组、字典和集合的常用操作和内置函数。
4.能够根据实际需求选择合适的数据结构解决问题。
二、教学内容1.列表（List）●概念：列表是Python中的一种可变序列类型，可以包含不同类型的元素。
●创建：使用方括号[]或list()函数创建列表。
●访问：通过索引访问列表元素，支持切片操作。
●修改：使用赋值语句修改列表元素，使用append()、insert()、remove()等方法添加、插入或删除元素。
●常用操作：len()、max()、min()、sort()等。
2.元组（Tuple）●概念：元组是Python中的一种不可变序列类型，与列表类似，但元素不能修改。
●创建：使用圆括号()或tuple()函数创建元组。
●访问：通过索引访问元组元素，支持切片操作。
●注意：由于元组不可变，因此没有提供修改元素的方法。
●常用操作：与列表类似，但不包括修改元素的方法。
3.字典（Dictionary）●概念：字典是Python中的一种可变映射类型，用于存储键值对。
●创建：使用花括号{}或dict()函数创建字典。
●访问：通过键访问对应的值，使用get()方法获取指定键的值（可选默认值）。
●修改：使用赋值语句修改键值对，使用del语句删除键值对。
●常用操作：keys()、values()、items()等。
4.集合（Set）●概念：集合是Python中的一种可变无序且不重复的元素集。
●创建：使用花括号{}（不包含键值对）或set()函数创建集合。
●访问：由于集合无序，因此不支持索引访问。
可以判断元素是否存在于集合中。
●修改：使用add()方法添加元素，使用remove()方法删除元素。
还可以使用集合运算符进行并集、交集、差集等操作。
●常用操作：len()、union()、intersection()、difference()等。
python基础笔记
列表常用方法元组常用方法集合常用方法字典常用方法格式转换循环基本语法for变量名in列表:____变量相关操作range的基本语法格式1：range(m) 生成0 到m-1 的整数格式2：range(m，n) 生成m 到n-1 的整数格式3：range(m，n，s) 生成m 到n-1 的整数，整数间隔为srange的应用场景1.配合for循环构造指定次数的循环for _ in range(..):____循环执行的代码2.快速创建由连续的整数作为数据的列表、元组、集合对象list(range(..))tuple(range(..))set(range(..))公共方法len(model)关键词：数据总量获取容器模型中的数据总量model:保存有数据的存储模型，该模型接受各种容器容器模型中数据的总量list1 = [1,2,3,'itcast',"heima"]length = len(list1)max(model)关键词：最大值获取容器模型中的最大值，对于字典获取字典的键key的最大值model:保存有数据的存储模型，该模型接受各种容器容器模型中数据的最大值list1 = [1,2,3,4,5]max_value = max(list1)min(model)关键词：最小值获取容器模型中的最小值，对于字典获取字典的键key的最小值model:保存有数据的存储模型，该模型接受各种容器容器模型中数据的最小值list1 = [1,2,3,4,5]min_value = min(list1)通用运算符运算符功能格式适用范围+ 将两个容器数据合并放入第一个容器list1 + list2列表之间或元组之间（列表与元组之间报错）* 将容器数据复制n次放入容器中list1 * n 列表、元组in 判断容器中是否包含数据data in list1列表、元组、集合、字典（字典判断数据是否在keys（）中）not in 判断容器中是否不包含数据data not in list1列表、元组、集合、字典（字典判断数据是否不在keys（）中）>、>=、==、<=、< 比较两个容器中的数据关系list1 <=list2 列表、元组、集合for…else基本语法for 变量名in 列表:变量相关操作else:循环正常运行结束后执行的操作推导式推导式基本语法基础语法格式：循环变量for循环范例：list1 = [data for data in range(5)]数据处理语法格式：表达式for循环范例：list1 = [data*5 for data in range(5)]数据过滤语法格式：表达式for循环if判断范例：list1 = [data for data in range(5) if data > 200] 推导式的作用推导式可以快速生成数据存储结构中的数据范例1：创建包含1到100所有整数的列表list1 = [data for data in range(1,101)]范例2：创建包含1到10的平方和的列表list2 = [data**2 for data in range(1,11)]。
Python中元组、字典和集合的简单使用
（1）字典的创建 >>>aDict={‘age’:39,’score’:98,’name’:’Dong’,’sex’:’male’} >>>stu={‘name’:’ChenLi’,’age’:18} >>>x=dict()#用dict()函数创建一个空字典 >>>x={}#空字典
Python中元组、字典 和集合的简单使用
01 元组
元组可以看成轻量级的列表，很多地方类似于列表，但功能要简单一些，在某些情况 下也足够了。
元组和列表都属于有序序列，支持使用双向索引访问其中的元素，使用内置函数len（） 统计元素个数、max（）求最大值、min（）求最小值、sum（）求元素之和，使用运 算符in测试是否包含某个元素、使用方法cou1）nt强（吴）强二统计指定元素的出现次数。
1）强吴强二
02 字典
字典是包含若干个“键：值”元素的无序可变容器类对象，字典中每 个元素包含用冒号分隔的“键”和“值”两部分，表示一种映射或对应 关系。
字典中每个元素的“键”可以是任意不可变数据，如整数、实数、字 符串、元组（其中不能包含列表、字典或集合等可变序列）等类型， 但不能使用列表、集合、字典或其他可变类型作为字典的“键”。
_______
>>>x=[-1]
_______
1）强吴强二
>>>x[1]=4 #元组是不可变的，试图改变元素的值会抛出异常 TypeError:’tuple’ object does not support item assignment
（3）常见内置函数对元组的使用 >>>x=(1,2,3,4,5) >>>len(x) _______ >>>max(x) _______ >>>min(x) _______ >>>su创建与删除 >>>a={3,5} >>>a_set=set(range(8,14)) >>>a_set {8,9,10,11,12,13} >>>b_set=set([0,1,2,3,0,1,2,3,7,8])#将列表转换为集合，自动去掉重复元素 >>>b_set ___________________ >>>c_set=set()#创建空集合
python之元组，列表和字典的区别
python之元组，列表和字典的区别Python语⾔包含6种内建的序列，其中，有两种主要的类型：列表和元组。
列表是可以修改的，⽽元组不可以，如果要添加或者删除某些元素，就只能⽤列表，为了限制某些元素，就会⽤到元组。
⼀般来说，列表可以替代元组。
在列表之中，有索引，分⽚，加，乘等等。
⼀、list（列表）⽤⽅括号[]列表是Python的⼀种内置数据类型，list是⼀种有序的集合，可以随时添加和删除其中的元素。
获取list中的元素⽤⾓标获取，⾓标可以使⽤正⾓标，也可以使⽤负⾓标，越界时抛出IndexErrolist中的元素的数据类型也可以不⼀样（就像Java⼀样），也可以在list内放另外⼀个list，这样也就形成了⼀个多维集合常⽤的⽅法有：1.len（）获取列表的长度2.X.append（“你好”）向列表中添加元素3.X.pop（）弹出末尾元素1 zoo = ['pig','tiger','dog']2print(len(zoo))3 zoo.append("nihao")4print(zoo)5print(zoo.pop())6print(zoo[0])7print(zoo[-1])单列表操作1# 元组操作23 x = [5, 6, 2, 1, 6, 7, 2, 7, 9]45# append()⽅法，就是在列表尾部添加元素6 x.append(2)7print(x)89# insert(开始位置，插⼊的值),插⼊⼀个元素到指定位置10 x.insert(2, 99) # 2是索引,表⽰这个元素要放什么位置，99是插⼊的元11print(x)1213# 删除元素 remove()14 x.remove(2) # 这个2是指⼀个元素不是索引，如果多个，默认移除第⼀个15print(x)1617 x.remove(x[2]) # 根据索引，直接移除索引对应的元素18print(x)1920# pop(),移除列表尾部最后⼀个元素21 x.pop()22print(x)2324# 列表引⽤25print(x[0:5]) # 相当于⼀个范围，从左边索引到右边索引，但是不包括右边索引2627# -1 索引代表最后⼀个元素，-2代表倒数第⼆个28# 此时x= [5, 6, 1, 6, 7, 2, 7, 9]29print(x[-1])30print(x[-2])3132# 查找某⼀个元素的索引值，⼀下1的索引应该是233print(x.index(1))3435# 计算某⼀个元素出现的次数36print(x.count(6)) # 元素6出现了2次3738# 排序,默认从⼩到⼤39 x.sort()40print(x)4142# 字母排序43 y = ['Janet', 'Jessy', 'Anthony', 'Tom', 'Alice', 'Bob']44 y.sort()45print(y) # 注此处的y为重新排序的y，，y.sort()没有对应的返回值多列表1# 多维列表23 x = [[5, 6], [6, 7], [7, 2], [2, 5], [4, 9]]456# 根据索引引⽤列表元素,例如打印【6,7】7# print(x[1])8# 打印【6,7】中的79print(x[1][1])101112131415# 三维16 y = [[[5, 7], [6, 6]], [[6, 6], [7, 8]], [7, 2], [2, 5]]17# 打印[[6,6],[7,8]]这个部分中的[6,6]⾥的第⼀个618print(y[1][0][0])19# y看起来有的晕，我们换⼀个写法2021 y = [22 [[5, 7], [6, 6]],23 [[6, 6], [7, 8]],24 [7, 2],25 [2, 5]26 ]27# 这样稍微清晰，⼀点，Y有4个元素，前⾯两个是两两⼆维组成，后⾯两个是单独的⼆维⼆、tuple（元组）⽤⼩括号()元祖也是⼀种有序列表，和list⾮常类似，不同点是tuple⼀旦定义了就不可修改，在⼀定意义上这也提⾼了代码的安全性，查询⽅法和list⼀样，使⽤的时候能⽤tuple的就⽤tuple。
Python的非数字类型
Python的⾮数字类型Python 中数据类型可以分为数字型和⾮数字型数字型：整型 ( int )、浮点型（ float ）、布尔型（ bool ）、复数型 ( complex )⾮数字型：字符串、列表、元组、字典在 Python 中，所有⾮数字型变量都⽀持以下特点： 1. 都是⼀个序列 sequence ，也可以理解为容器 2. 取值 [] 3. 遍历 for in 4. 计算⻓度、最⼤/最⼩值、⽐较、删除 5. 链接 + 和重复 * 6. 切⽚切⽚使⽤索引值来限定范围，从⼀个⼤的字符串中切出⼩的字符串列表和元组都是有序的集合，都能够通过索引值获取到对应的数据字典是⼀个⽆序的集合，是使⽤键值对保存数据⼀、列表（相当于java的数组）列表是有序的集合列表的定义 List （列表）是 Python 中使⽤最频繁的数据类型，在其他语⾔中通常叫做数组 专⻔⽤于存储⼀串数据，存储的数据称为元素 列表⽤ [] 定义，元素之间使⽤ , 分隔 列表的索引从 0 开始注意：从列表中取值时，如果超出索引范围，程序会报错列表常⽤操作1、循环遍历遍历就是从头到尾依次从列表中取出每⼀个元素，并执⾏相同的操作Python中实现遍历的⽅式很多，⽐如while循环、for循环、迭代器等# while循环实现列表的遍历i = 0name_list = ["zhangsan", "lisi", "wangwu"]list_count = len(name_list)while i < list_count:name = name_list[i]print(name)i += 1Python为了提⾼列表的遍历效率，专⻔提供 for循环实现遍历Python中for循环的本质是迭代器# for实现列表的遍历for name in name_list:循环内部针对列表元素进⾏操作print(name)2、列表嵌套⼀个列表中的元素⼜是⼀个列表，那么这就是列表的嵌套schoolNames = [['北京⼤学','清华⼤学'], ['南开⼤学','天津⼤学','天津师范⼤学'], ['⼭东⼤学','中国海洋⼤学']]⽰例：⼀个学校，有3个办公室，现在有8位⽼师等待⼯位的分配，请编写程序: 1> 完成随机的分配 2> 获取办公室信息 (每个办公室中的⼈数，及分别是谁)import random# 定义⼀个列表⽤来保存3个办公室offices = [[],[],[]]# 定义⼀个列表⽤来存储8位⽼师的名字names = ['A','B','C','D','E','F','G','H']# 完成随机分配i = 0for name in names:index = random.randint(0,2)offices[index].append(name)# 获取办公室信息i = 1for tempNames in offices:print('办公室%d的⼈数为:%d'%(i,len(tempNames)))i+=1for name in tempNames:print("%s"%name,end='')print("\n")print("-"*20)⼆、元组元组是有序的集合元组的定义 元组⽤ () 定义 ⽤于存储⼀串数据，元素之间使⽤ , 分隔 元组的索引从 0 开始# 定义元组info_tuple = ("zhangsan", 18, 1.75)# 取出元素的值print(info_tuple[0]) # 输出：zhangsan元组中只包含⼀个元素时，需要在元素后⾯添加逗号info_tuple = (50, )元组常⽤操作Tuple （元组）与列表类似，不同之处在于元组的元素不能修改info_tuple = ("zhangsan", 18, 1.75)info_tuple[0] = "lisi" # 程序报错应⽤场景1、作为⾃动组包的默认类型info = 10, 20print(type(info)) # 输出类型为 tuple# 交换变量的值a = 10b = 20a, b = b, a # 先⾃动组包，后⾃动解包2、格式字符串，格式化字符串后⾯的 () 本质上就是⼀个元组info = ("zhangsan", 18)print("%s 的年龄是 %d" % info)3、让列表不可以被修改，以保护数据安全# 元组和列表之间的转换# 使⽤ `tuple` 函数把列表转换成元组list1 = [10, 11]tuple1 = tuple(list1)# 使⽤ `list` 函数把元组转换成列表# list1 = list(tuple1)三、字典（相当于json）字典是⽆序的集合字典的定义1)、dictionary （字典）是除列表以外 Python 之中最灵活的数据类型2）、字典同样可以⽤来存储多个数据，常⽤于存储描述⼀个物体的相关信息3）、字典⽤ {} 定义4）、字典使⽤键值对存储数据，键值对之间使⽤ , 分隔 键 key 是索引 值 value 是数据 键和值之间使⽤ : 分隔 值可以取任何数据类型，但键只能使⽤字符串、数字或元组 键必须是唯⼀的# 定义字典xiaoming = {"name": "⼩明","age": 18,"gender": True,"height": 1.75}# 取出元素的值print(xiaoming["name"]) # 输出：⼩明字典常⽤操作应⽤场景在开发中，字典的应⽤场景是：使⽤多个键值对，存储描述⼀个物体的相关信息 —— 描述更复杂的数据信息将多个字典放在⼀个列表中，再进⾏遍历，在循环体内部针对每⼀个字典进⾏相同的处理card_list = [ {"name": "张三", "qq": "12345", "phone": "110"}, {"name": "李四", "qq": "54321", "phone": "10086"}]四、字符串字符串的定义1）、字符串就是⼀串字符，是编程语⾔中表⽰⽂本的数据类型2）、在 Python 中可以使⽤⼀对双引号 " 或者⼀对单引号 ' 定义⼀个字符串v 虽然可以使⽤ \" 或者 \' 做字符串的转义，但是在实际开发中： 如果字符串内部需要使⽤ " ，可以使⽤ ' 定义字符串 如果字符串内部需要使⽤ ' ，可以使⽤ " 定义字符串3）、可以使⽤索引获取⼀个字符串中指定位置的字符，索引计数从 0 开始4）、也可以使⽤ for 循环遍历字符串中每⼀个字符⼤多数编程语⾔都是⽤ " 来定义字符串string = "Hello Python"for c in string:print(c)字符串的常⽤操作1、判断2、查找和替换3、拆分和连接4、⼤⼩写转换5、⽂本对齐6、去除空⽩字符提⽰：列表除了查询⽅法和pop⽅法都没有返回值，字符串所有⽅法都有返回值字符串的切⽚切⽚译⾃英⽂单词 slice ，翻译成另⼀个解释更好理解: ⼀部分切⽚使⽤索引值来限定范围，根据步⻓从原序列中取出⼀部分元素组成新序列切⽚⽅法适⽤于字符串、列表、元组字符串[开始索引:结束索引:步⻓]注意：1. 指定的区间属于左闭右开型 [开始索引, 结束索引) 对应开始索引 <= 范围 < 结束索引 从起始位开始，到结束位的前⼀位结束（不包含结束位本⾝)num_str = "0123456789"# 1. 截取从2 ~ 5位置的字符串print(num_str[2:6])2. 从头开始，开始索引数字可以省略，冒号不能省略num_str = "0123456789"# 3. 截取从 `开始` ~ 5位置的字符串print(num_str[:6])3. 到末尾结束，结束索引数字和冒号都可以省略num_str = "0123456789"# 2. 截取从2 ~ `末尾` 的字符串print(num_str[2:])截取完整的字符串num_str = "0123456789"# 4. 截取完整的字符串print(num_str[:])4. 步⻓默认为 1 ，如果元素连续，数字和冒号都可以省略num_str = "0123456789"# 5. 从开始位置，每隔⼀个字符截取字符串print(num_str[::2])# 6. 从索引 1 开始，每隔⼀个取⼀个print(num_str[1::2])索引的顺序和倒序1）、在 Python 中不仅⽀持顺序索引，同时还⽀持倒序索引2）、所谓倒序索引就是从右向左计算索引，最右边的索引值是 -1，依次递减3）、注意：如果步⻓为负数,并省略了开始索引，则开始索引表⽰最后⼀位，并省略了结束索引，则结束索引表⽰第⼀位# 倒序切⽚# -1表⽰倒数第⼀个字符print(num_str[-1])# 7. 截取从2 ~ `末尾 - 1` 的字符串print(num_str[2:-1])# 8. 截取字符串末尾两个字符print(num_str[-2:])# 9. 字符串的逆序（⾯试题）print(num_str[::-1])print（num_str[::-2]）结果五、set集合set的特点：⽆序，没有索引，set中的数据不会重复，格式：{1,2,3,4}主要作⽤：列表或元组数据去重，把列表或元组转换成set类型可以数据去重。
python第4章 列表、元组、字典和集合
>>> "/".join(list_1)
#将list_1中的元素以”/”间隔的方式转化
为'P/y/t/h/o/n'
join()函数还能对字符串进行处理，如将字符串中的每个字符以分隔符“-”分隔，例如如下
第四章
列表、元组、字典和集合
如字符型只能存储字符串，整型只能存储整数，它们并不能很好地满足程序的需 求。为了能存储更复杂的数据，并且更加方便快捷地管理这些数据，Python引入 了4种功能更加强大的标准数据类型：列表（list）、元组（tuple）、字典（dict） 和集合（set），它们能存储几乎所有类型的数据，并且还可以组合到一起使用， 构建更复杂的数据类型。 本章主要讲解列表、元组、字典、集合的定义和使用；列表、元组、字典、集合 函数的使用；列表推导式；列表、元组、字典、集合四种数据类型的特性。
当列表中嵌套有多重列表时依次类推。另外，当列表里的
元素指向列表本身时，并不会造成无限次打印列表的情况， 例如如下的示例：
>>> list_1[5] = list_1
>>> list_1
['Py', 'th', 'on', 3, ['.', 6], [...]]
可以看到，在修改列表元素时，列表能够自动判断元素指 向的是否是列表本身，如果是的话，则以“[…]”代替引用 的列表。
Python
列表list
01
元组tuple
02
字典dict
03
云开发技术应用Python-03-1-数据类型课件
3.1.6 容器类型简介
列表和元组(list & tuple)
类似于C语言中的数组，不过它们支持不同类型的元素，可以是数字、字符串、 其它列表、字典或集合。它们的表面区别在于，列表用方括号来声明和表达，而元 组使用圆括号；它们的内在区别在于，列表是可变对象，元组是不可变对象。
>>> a=[1,2,3] >>> b=(1,2,3) >>> type(a) <class 'list'> >>> type(b) <class 'tuple'>
>>> a=66.6 >>> type(a) <class 'float'> >>> b=int(a) >>> type(b) <class 'int'> >>> b 66 >>> c=float(b) >>> type(c) <class 'float'> >>> c 66.0 >>>
要注意的是：在源代码文件中，直接输入对象不会显示任何结果，你必须通过 其它方法，例如使用print函数。
3.1.6
容器类型简介
容器类型是由基本数据类型组成的复合数据类型，是Python内置的数据结
构，在本课程的现阶段，只对容器类型做最简单的介绍。要了解更多，请参考后
续课程。
字符串
序列
列表
容器数据类型
字典（映射）
集合
列表元祖字典集合的区别与联系
一、列表、元组、字典和集合的定义列表：列表是Python中最常用的数据结构之一，可以存储任意数量的任意类型的元素，用方括号[]来表示。
列表是可变的，可以根据需要对列表中的元素进行增删改操作。
元组：元组和列表类似，也可以存储任意数量的任意类型的元素，不过它的元素不可变，用小括号()来表示。
元组一旦创建就不能再被修改，是不可变的数据结构。
字典：字典是Python中另一个常用的数据结构，用大括号{}来表示，字典由键值对组成，每个键值对之间用逗号隔开。
字典中的键是唯一的，值可以重复，可以通过键来访问值。
集合：集合是由不重复元素组成的无序的集合，用大括号{}或者set()函数来表示。
集合可以进行并集、交集、差集等操作，常用来去重或者判断元素是否存在。
二、列表、元组、字典和集合的区别1. 可变性列表和字典是可变的数据结构，可以根据需要对其中的元素进行增删改操作；而元组和集合是不可变的，一旦创建就不能被修改。
这是列表和字典与元组和集合最显著的区别之一。
2. 存储方式列表和元组是有序的，可以通过下标来访问其中的元素；字典和集合是无序的，不能通过下标来访问其中的元素，而是要通过键来访问字典中的值。
3. 元素的重复性列表和字典中的元素是可以重复的，而且列表可以存储任意类型的元素，字典的值也可以重复；而集合和元组中的元素是不重复的，集合是用来去重的，元组虽然可以存储重复元素，但一般用来存储不可变的数据。
4. 适用场景列表适合用来存储有序的、可变的元素，常用于存储同类型的数据；元组适合用来存储不可变的数据，常用于函数返回多个值时；字典适合用来存储键值对，常用于存储具有映射关系的数据；集合适合用来存储不重复的元素，常用于去重或者判断元素是否存在。
三、列表、元组、字典和集合的通联1. 存储方式列表和元组都是有序的数据结构，可以通过下标来访问其中的元素；字典和集合都是无序的数据结构，不能通过下标来访问其中的元素。
2. 元素的特性列表和字典中的元素可以是任意类型的，可以存储重复的元素；元组和集合中的元素一般是不可变的，且不重复。
Python列表、元组和字典
6.2 列表的嵌套
什么是列表的嵌套
我们首先创建两个列表list_1和list_2如下： >>> list_1=[‘I am a inner list’] >>> list_2=[‘I am a outer list’] 接下来我们将list_1放入list_2中： >>> list_2.append(list_1) >>> list_2 ['I am a outer list', ['I am a inner list']] 以上就是一个最简单的列表的嵌套的例子。
通常我们用循环语句可以很容易地遍历列表中的数据并对其进行处理，
接下来我们以for循环为例， 介绍Python中列表的循环 遍历。
我们首先创建列表list如下： >>> list=['apple','banana','grape','peach','orange','pear','strawberry']
6.2 列表的嵌套
什么是列表的嵌套
依照以上方法，我们可以任意在列表中嵌套列表，以下代码是对任意多重 嵌套列表的遍历：
>>>def printlist(list):
>>> def printlist(list):
...
'''
...
现有一个列表，里面元素包括数字、字母等元素以及包含
这类元素的列表，现在我们输出这个列表中的所有非列表元素，如： [[1,2,3],2,3,[1,3,[12,22]],'a',12]，输出：[1, 2, 3, 2,
列举出python中常用的组合数据类型及其特点
Python中常用的组合数据类型及其特点1. 列表（list）列表是Python中最常用的数据结构之一，它是一种有序、可变的容器，其中的元素可以是任意数据类型。
列表使用方括号[]来表示，元素之间用逗号分隔。
特点：- 可变性：列表中的元素可以修改，可以进行增加、删除、修改等操作。
- 有序性：列表中的元素是有序的，可以通过索引来访问每一个元素。
- 可以包含任意数据类型：列表中的元素可以是数字、字符串、列表、元组、字典等各种类型的数据。
2. 元组（tuple）元组也是一种有序的容器，使用小括号()来表示，其中的元素同样可以是任意数据类型。
不同的是元组一旦创建后就不能再进行修改。
特点：- 不可变性：元组的元素不可被修改，删除或者新增。
- 可以包含任意数据类型：与列表类似，元组中的元素也可以是任意数据类型。
3. 字典（dict）字典是一种无序的数据集，其中的元素是以键值对的形式存储的。
字典以大括号{}表示，每个键值对中的键和值之间用冒号分隔，键值对之间用逗号分隔。
特点：- 键值对的形式：字典中的元素是以键值对的形式存储的，可以通过键来访问值。
- 可变性：字典中的元素可以修改，增加或删除。
- 键的唯一性：字典中的键是唯一的，不允许重复。
4. 集合（set）集合是一种无序、不重复的数据集合，其中的元素是唯一的。
集合使用大括号{}或者set()函数来创建。
特点：- 唯一性：集合中的元素是唯一的，不允许重复。
- 无序性：集合中的元素是无序的，不支持通过索引来访问。
5. 基本操作除了上述数据类型的特点外，它们还有一些共同的基本操作，如索引、切片、长度计算等。
总结：在Python中，列表、元组、字典和集合是最常用的组合数据类型。
它们各自具有不同的特点，可以根据实际需求来选择使用。
对于需要进行增删改查操作的数据，可以选择列表或者字典；对于不需要重复元素的数据，可以选择集合；而当数据集合需要不可变性的时候，可以选择元组。
简述列表、元组和字典的定义与区别
一、列表的定义与特点列表（List）是Python中一种常用的数据类型，用来存储多个元素，并且可以根据需要进行增删改查操作。
列表使用方括号[ ]来表示，元素之间用逗号分隔。
1.1 列表的定义列表是Python中一种有序、可变、可重复的数据类型，可以存储任意类型的元素，比如整数、浮点数、字符串等。
1.2 列表的特点- 有序：列表中的元素是按照插入顺序进行存储的，可以根据索引来访问元素。
- 可变：列表中的元素可以根据需要进行增加、删除或修改。
- 可重复：列表中可以包含重复的元素。
二、元组的定义与特点元组（Tuple）与列表类似，也是用来存储多个元素的数据类型，但元组是不可变的，意味着一旦创建，就不能对元组进行修改。
元组使用圆括号( )来表示，元素之间用逗号分隔。
2.1 元组的定义元组是Python中一种有序、不可变的数据类型，可以存储任意类型的元素，比如整数、浮点数、字符串等。
2.2 元组的特点- 有序：元组中的元素是按照插入顺序进行存储的，可以根据索引来访问元素。
- 不可变：元组一旦创建，就不能对其进行增加、删除或修改。
- 可重复：元组中可以包含重复的元素。
三、字典的定义与特点字典（Dictionary）是Python中一种用于存储键值对数据的数据类型，每个键值对之间用冒号分隔，整个字典用花括号{ }来表示。
3.1 字典的定义字典是Python中一种无序、可变的数据类型，可以存储任意类型的键值对，比如字符串与整数、字符串与列表等。
3.2 字典的特点- 无序：字典中的键值对是无序存储的，无法通过索引来访问元素。
- 可变：字典中的键值对可以根据需要进行增加、删除或修改。
- 键唯一：字典中的键是唯一的，如果存在重复的键，则后面的键值对会覆盖前面的键值对。
四、列表、元组和字典的区别4.1 可变性- 列表是可变的，可以进行增删改操作。
- 元组是不可变的，一旦创建就不能进行修改。
- 字典是可变的，可以根据需要进行增删改操作。
Python列表、元组、字典、集合、字符串的异同总结
Python列表、元组、字典、集合、字符串的异同总结1.数据类型列表、元组、字典、集合、字符串均属于python3的标准数据类型。
字符串和元组属于不可变数据，即创建后不可修改。
列表、字典、集合属于可变数据，即创建后可以修改元素。
2.创建有元素的对象3.创建没有元素的对象列表使⽤eval()或list()或中括号[]进⾏创建，元素之间使⽤逗号分隔。
若不添加任何元素，则创建空列表。
# 使⽤[]创建list_ = [1, 2, 3, 4, 5]print(type(list_)) # <class 'list'># 使⽤eval()创建,eval()⽅法⽤来执⾏⼀个字符串表达式,并返回表达式的值list_ = eval("[1,2,3,4,5]")print(type(list_)) # <class 'list'># 使⽤list()创建,list()⽅法⽤于将元组转换为列表list_ = list((1, 2, 3, 4, 5))print(type(list_)) # <class 'list'>元组使⽤eval()或tuple()或⼩括号()进⾏创建，元素之间使⽤逗号分隔。
若不添加任何元素，则创建空元组。
如果元组只有⼀个元素，则必须在这个元素后⾯加上逗号。
# 使⽤()创建tuple_ = (1, 2, 3, 4, 5)print(type(tuple_)) # <class 'tuple'># 使⽤eval()创建tuple_ = eval("(1,2,3,4,5)")print(type(tuple_)) # <class 'tuple'># 使⽤tuple()创建,tuple()函数⽤于将列表转换为元组tuple_ = tuple([1, 2, 3, 4, 5])print(type(tuple_)) # <class 'tuple'>字典使⽤eval()或dict()函数或者⼤括号{}创建，元素之间⽤逗号分隔。
Python中的列表和元组的区别与应用场景
语法比较
列表使用方括号[] ，元组使用圆括号 ()
列表元素可以修改 ，元组元素不能修 改
列表可以添加和删
除元素，元组不能 添加和删除元素
列表和元组都可以 通过索引访问元素 ，但元组不支持切 片操作
性能比较
列表：动态数据结构，可以修改元素，插入和删除元素 元组：静态数据结构，不能修改元素，插入和删除元素 性能：列表的性能优于元组，因为列表可以动态修改，而元组不能 应用场景：列表适用于需要频繁修改数据的场景，元组适用于数据固定不变的场景
排序和搜索操作
列表的排序：使用sort()函数或sorted()函数对列表进行排序 列表的搜索：使用index()函数或find()函数在列表中查找指定元素 应用场景：在处理大量数据时，排序和搜索操作可以提高效率 示例代码：展示如何使用sort()、index()和find()函数进行排序和搜索操作
04
Python中列表的应用场景
存储多个值
列表可以存储多个值，如数字、字符串、布尔值等 列表中的值可以重复，如[1, 2, 3, 2, 3] 列表中的值可以修改，如list[0] = 4 列表可以存储不同类型的数据，如[1, 'hello', True]
动态数据结构
列表可以动态添加和删除元素，适合需要频繁修改数据的场景 列表可以存储不同类型的数据，适合处理复杂数据结构的场景 列表可以通过索引访问元素，适合需要快速访问数据的场景 列表可以切片操作，适合需要提取部分数据的场景
修改列表中的元素
使用切片修改元 素
使用列表的 extend()方法修 改元素
使用列表的 remove()方法修 改元素
使用列表的 clear()方法修改 元素
使用列表的sort() 方法修改元素
Python标准数据类型
Python标准数据类型标准数据类型：Number(数字)----int float bool complex(复数)String(字符串)List(列表)Tuple(元组)Dictionary(字典)Set(集合)数字1.复数num.real 实部 num.imag 虚部 num.conjugate()共轭复数(实部相同，虚部相反)2.操作符类型转换原则：整转浮，⾮复转复3.算术操作符expr1**expr2 乘⽅ expr1/ expr2 传统除(或真正除) expr1//expr2 地板除4.位操作符（只适⽤于整型）~num 按位取反，0变1，1变0 num1<<num2 num1的⼆进制位左移num2位，右移>>则相反 num1&num2 与，两个1为1，否则为0 num1^num2 异或，相异为1 num1|num2 或，有⼀个1则为15.内建函数和⼯⼚函数转换⼯⼚函数：int() float() complex() hex()⼗六进制 oct()⼋进制功能函数：abs() divmod(a,b)把除数和余数运算结果结合起来，返回⼀个包含商和余数的元组(a // b, a % b) pow(a,b)a的b次⽅ round(a,b)对浮点型进⾏四舍五⼊运算,第⼆参数为精确位数 关于int()：如果是字符串转数字，则字符串必须是数字，不能有⼩数点。
9_6被当作96，但不能以下划线开头序列：字符串、列表、元组1.序列类型操作符seq[ind] 获得下标为ind的元素，下标从0开始seq[ind1:ind2] 获得下标从ind1到ind2的元素集合，含头不含尾seq*expr 序列重复expr次seq1+seq2 连接序列seq1和seq2obj in seq 判断obj元素是否包含在seq中obj not in seq 判断obj元素是否不包含在seq中2.序列类型转换函数list(iter) 把可迭代对象转换成列表str(obj) 把对象转换成字符串tuple(iter) 把可迭代对象转换成元组3.序列类型内建函数len(seq) reversed(seq)seq -- 要转换的序列，可以是 tuple, string, list 或 range，返回⼀个反转的迭代器 sum(seq)上⾯三个函数只能接受可迭代对象作为参数，接下来的还可接受可迭代对象作为参数max()和min() sorted(iterable, key=None, reverse=False)对所有可迭代的对象进⾏排序操作，key=str.lower忽略⼤⼩写排序，默认升序，reverse=True降序sorted()与sort()的区别：sort应⽤在list，sorted可以对所有可迭代的对象进⾏排序操作；sort()是对已经存在的列表进⾏操作，sorted()返回的是⼀个新的list4.字符串(1)Python⾥⾯单引号和双引号的作⽤是相同的，因字符串不可变，不能仅仅删除⼀个字符串⾥的某个字符1 a = 'Hello World!'#去除l2 a = a[:3]+a[4:] #这是⼀个新串字符串做⽐较操作，按ASCII值，a:97 A:65 a-A=321 a = 'Qwer'2 a.upper() #⼩写变⼤写 QWER3 a[:2].upper() #可配合切⽚⽤ QW4 a.lower() #⼤写变⼩写 qwer 这种操作并不会改变原来a的值(2)Python必须为每⼀个参加连接操作的字符串分配新的内存，包括新的字符串，所以出于性能考虑，⽤%或join()连接字符串'%s %s' % ('Chen','hongbing') #'Chen hongbing's = '-'.join(('C','H','B')) #'C-H-B'(3)格式化字符 转换⽅式 %c 转换成字符(ASCII值) %s 优先⽤str()函数进⾏字符串转换 %r 优先⽤repr()函数进⾏字符串转换 r' ' 关闭转义，如print(r'\n %%')输出\n %%(4)内建函数1 len(str) #返回字符数2 max(str)和min(str) #返字符串中ASCII值最⼤或最⼩的字符3 chr(65)--->'A'#参数范围在range(256)返对应字符4 ord('a')--->97 #与chr()对应56 string.find(str,start,end) #如在返索引值，否则返-17 string.strip([chars]) #删除字符串开尾指定的字符，默认空格8 string.split(str,num) #以str为分隔符切⽚string,分隔num个字符串9 string.splitlines() #按照⾏分隔，返列表10 string.replace(str1,str2,num) #把str1换成str2，不超过num次11 string.count(sub,start,end) #统计sub从下标start到end之间出现的次数12 string.encode(encoding='utf-8',errors='strict') #对字符串进⾏编码，strict严格编码，errors可指定ignore⽆视13 string.decode(encoding='utf-8',errors='ignore') #对字符串进⾏解码14 string.center(width) #返回⼀个原字符串居中。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
Python容器：列表、元组、字典与集合posts 列表 元组 字典 集合 python容器Python容器：列表、元组、字典与集合1、列表和元组2、列表2.1、使用[]或list()创建列表2.2、使用list()将其它数据类型转换成列表2.3、使用[offset]获取元素2.4、包含列表的列表2.5、使用[offset]修改列表元素2.6、指定范围并使用切片提取元素2.7、使用append()添加元素至尾部2.8、使用extend()或+=合并列表2.9、使用insert()在指定位置插入元素2.10、使用del删除指定位置的元素2.11、使用remove()删除具有指定值的元素2.12、使用pop()获取并删除指定位置的元素2.13、使用index()查询具有特定值得元素位置2.14、使用in判断值是否存在2.15、使用count()记录特定值出现的次数2.16、使用join()转换为字符串2.17、使用sort()重新排序元素2.18、使用len()获取长度2.19、使用=赋值，使用copy()赋值3、元组3.1、使用()创建元组4、字典4.1、使用{}创建字典4.2、使用dict()转换为字典4.3、使用[key]添加或修改元素4.4、使用update()合并字典4.5、使用del删除具有制定键的元素4.6、使用clear()删除所有元素4.7、使用in判断是否存4.8、使用[key]获取元素4.9、使用keys()获取所有键4.10、使用values()获取所有值4.11、使用items()获取所有键值对4.12、使用=赋值，使用copy()赋值5、集合5.1、使用set()创建集合5.2、使用set()将其他类型转换为集合5.3、使用in测试值是否存在5.4、合并及运算符6、建立大型数据结构反馈与建议1、列表和元组 大多数编程语言都有特定的数据结构来存储由一系列元素组成的序列，这些元素以他们所处的位置来索引：从第一个到最后一个依次编号。
Python的字符串本质上是由字符组成的序列。
除了字符串外，Python还有另外两种序列结构：元组和列表。
它们都可以包含零个或多个元素。
于字符串不同的是，元组和列表并不要求所含元素的种类相同，每个类型都可以是Python类型的对象。
至于Python为什么会同时设置这两种序列，是因为元组所赋值的内容是不可变的，然而列表是可变可更改的，这意味着可以随意的在列表中插入或者删除其中那个的元素。
2、列表 列表非常适合利用顺序和位置来定位某一元素，尤其是当元素的序列或内容经常发生变化时。
列表可以对原始列表进行修改：添加新元素、删除或覆盖已有元素。
列表允许相同值的元素出现多次。
2.1、使用[]或list()创建列表列表可以有多个或多个元素组成，元素之间用逗号隔开，整个列表被方括号所包裹：>>> empty_list = [ ]>>> weekdays = ['Monday','Tuesday','Wednesday','Thursday','Friday'] >>> big_birds = ['emu','ostrich','cassowary',]>>> first_names = ['Graham','John','Terry','Terry','Michagel']#列表允许重复相同的值也可以使用list()函数来创建一个空列表：>>> another_empty_list = list()>>> another_empty_list[]提示：如果你仅仅想要记录一些互不相同的值，而不在乎它们之间的序列关系，集合（set）会是一个更好的选择。
2.2、使用list()将其它数据类型转换成列表 Python的list()函数可以将其他数据类型转换成列表类型。
>>> list('cat')['c', 'a', 't']下面的例子将一个元组转换成了列表：>>> a_tuple = ['ready','fire','aim']>>> list(a_tuple)['ready', 'fire', 'aim']使用split()可以依据分隔符将字符串切割成由若干子串组成的列表：>>> birthday = '1/6/1952'>>> birthday.split('/')['1', '6', '1952']如果在待分割的字符串中包含连续的分隔符，那么在列表中就会返回空串元素：>>> splitme = 'a/b//c/d///e'>>> splitme.split('/')['a', 'b', '', 'c', 'd', '', '', 'e']如果将上面例子中的分隔符改成//会变成下面的结果：>>> splitme = 'a/b//c/d///e'>>> splitme.split('//')['a/b', 'c/d', '/e']2.3、使用[offset]获取元素和字符串一样，通过偏移量可以从列表中提取对应位置的元素：>>> marxes = ['Groucho','Chico','Harpo']>>> marxes[0]'Groucho'>>> marxes[1]'Chico'>>> marxes[2]'Harpo'同样，负偏移量代表从尾部开始计数：>>> marxes[-1]'Harpo'>>> marxes[-2]'Chico'>>> marxes[-3]'Groucho'提示：指定的偏移量对于待访问列表必须有效，该位置中的元素在访问前已经赋值，当制定的偏移量小于起始位置或者大于末尾位置时，会产生异常。
2.4、包含列表的列表列表可以包含各种类型的元素，包括其他列表：>>> small_birds = ['hummingbird','finch']>>> extinct_birds = ['dodo','','Norwegian Blue'] >>> carol_birds = [3,'French hens',2,'turtledoves']>>> all_birds = [small_birds,extinct_birds,'macaw',carol_birds]查看all_birds列表的数据结构：>>> all_birds[['hummingbird', 'finch'], ['dodo', '', 'Norwegia n Blue'], 'macaw', [3, 'French hens', 2, 'turtledoves']]访问第一个元素：>>> all_birds[0]['hummingbird', 'finch']第一个元素还是一个列表，其实第一个元素就是small_birds，也就是创建all_birds列表时设定的第一个元素，查看第二个元素：>>> all_birds[1]['dodo', '', 'Norwegian Blue']如果你想要访问extinct_birds的第一个元素，可以制定双重索引从all_birds中提取：>>> all_birds[1][0]'dodo'2.5、使用[offset]修改列表元素就像可以通过偏移量访问某元素一样，你也可以通过赋值对他们进行修改：>>> names = ['','linux','centos']>>> names[1]'linux'>>> names[1] = 'redhat'>>> names[1]'redhat'>>> names['', 'redhat', 'centos']与之前一样，列表的位置偏移量必须是合法有效的。
提示：通过这种方式无法修改字符串中的制定字符，运维字符串是不可变的。
列表是可变的，一次你可以改变列表中的元素个数，以及元素的值。
2.6、指定范围并使用切片提取元素你可以使用切片提取列表的一个子序列：>>> names = ['','linux','centos']>>> names[0:2]['', 'linux']列表的切片仍然是一个列表。
2.7、使用append()添加元素至尾部传统的向列表中添加元素的方法是利用append()函数将元素一个个添加到尾部。
>>> names = ['','linux','centos']>>> names['', 'linux', 'centos']>>> names.append('redhat')>>> names['', 'linux', 'centos', 'redhat']2.8、使用extend()或+=合并列表使用extend()可以将一个列表合并到另一个列表中：>>> os = ['unix','linux','windows']>>> mac = ['mac os']>>> os.extend(mac)>>> os['unix', 'linux', 'windows', 'mac os']也可以使用+=：>>> os = ['unix','linux','windows']>>> mac = ['mac os']>>> os += mac>>> os['unix', 'linux', 'windows', 'mac os']如果错误地使用了append()，那么mac会被当成一个单独的元素进行添加，而不是将其内容进行合并：>>> os = ['unix','linux','windows']>>> mac = ['mac os']>>> os.append(mac)>>> os['unix', 'linux', 'windows', ['mac os']]2.9、使用insert()在指定位置插入元素append()函数只能将新元素插入到列表的尾部，而是用insert()函数可以将元素插入到列表中的任意位置中。