Python序列是指按特定顺序依次排列的一组数据，包括列表(list)，元组(tuple)，字典(dict)，集合(set).

其中，list和tuple是按顺序保存元素，所有元素占用一块连续的内存，可以通过索引来访问，类似于C语言的数组。list和tuple的区别是list可以修改，后者不行。

dict和set存储的数据都是无序的，dict元素以key-value的形式保存。

序列索引

类似于C语言的数组下标，但是Python有负数，从右向左计数，即最后一个元素为-1。

python列表元组字典集合的区别 python列表,元组,字典,集合_键值对

//支持中文 
str="测试数据"
print("str[-2]","==",str[-2])
print("str[3]","==",str[3])

//输出结果
str[-2] == 数
str[3] == 据

序列切片

序列实现切片操作的语法格式如下：

sname[start : end : step]

其中，各个参数的含义分别是：

  • sname：表示序列的名称；
  • start：表示切片的开始索引位置（包括该位置），此参数也可以不指定，会默认为 0，也就是从序列的开头进行切片；
  • end：表示切片的结束索引位置（不包括该位置），如果不指定，则默认为序列的长度；
  • step：表示在切片过程中，隔几个存储位置（包含当前位置）取一次元素，也就是说，如果 step 的值大于 1，则在进行切片去序列元素时，会“跳跃式”的取元素。如果省略设置 step 的值，则最后一个冒号就可以省略。

序列相加

 使用“+”

序列相乘

使用数字 n 乘以一个序列会生成新的序列，其内容为原来序列被重复 n 次的结果

in/not in-检查是否包含元素

序列相关内置函数

函数

功能

len()

计算序列的长度，即返回序列中包含多少个元素。

max()

找出序列中的最大元素。注意，对序列使用 sum() 函数时，做加和操作的必须都是数字，不能是字符或字符串，否则该函数将抛出异常，因为解释器无法判定是要做连接操作（+ 运算符可以连接两个序列），还是做加和操作。

min()

找出序列中的最小元素。

list()

将序列转换为列表。

str()

将序列转换为字符串。

sum()

计算元素和。

sorted()

对元素进行排序。

reversed()

反向序列中的元素。

enumerate()

将序列组合为一个索引序列，多用在 for 循环中。

list

  • 创建 
1.使用[]创建列表
如 list_a=[2,4,5,6,7,8]
2.使用list()函数创建列表
可以将字符串、元组、字典、区间转换成列表
如 list_b = list("hello world")
  • 访问 
1、直接用索引，类似于C语言的数组
比如list_a[2]
2、使用切片访问
比如print(list_a[2:5:1]) #第2到第5，步长为1
  • 删除
del 列表名
如 del list_a
  • 添加
1、append()
比如 list_a.append(7)
2、extend() 它和append()的区别：extend() 不会把列表或者元祖视为一个整体，而是把它们包含的元素逐个添加到列表中。
3、insert(index,obj) 与上述2个方法不同的是，insert()可以插入到指定位置
如 list_a.insert(2,100)
  • 删除元素
1、删除单个元素
del list_a[index]
2、删除连续元素,从start到end，不包括end
del list+_a[start:end]
3、pop(index) 删除索引处元素,缺省时为最后一个元素
list_a.pop(index)
4、remove(val) 删除指定元素，只匹配一次
5、clear() 删除列表里的所有元素
  • 修改元素
1、修改单个元素，直接赋值
如 list_a[2] = 55
2、修改连续元素，使用切片方式
如 list_a[1:4] =[40,50,60,70]
  • 查找元素
1、index()方法，格式如下：
listname.index(obj, start, end)
start 和 end 参数用来指定检索范围：
start 和 end 可以都不写，此时会检索整个列表；
如果只写 start 不写 end，那么表示检索从 start 到末尾的元素；
如果 start 和 end 都写，那么表示检索 start 和 end 之间的元素。
2、count()方法，统计某个元素在列表中出现的次数
listname.count(obj)

tuple 元组

tuple与list的区别在于，list创建完成后元素可以修改，tuple创建完成后不能修改，可以把tuple看成不可变的list。

  • 创建 
1、使用()创建
如 tuple_a = (1,2,3,4,6)
当元组中只有一个元素时，该元素后面必须加逗号，如tuple_b=("teststring",)
2、使用tuple()函数创建，tuple(data)
如 
#将字符串转换成元组
tup1 = tuple("hello")
print(tup1)
#将列表转换成元组
list1 = ['Python', 'Java', 'C++', 'JavaScript']
tup2 = tuple(list1)
print(tup2)
#将字典转换成元组
dict1 = {'a':100, 'b':42, 'c':9}
tup3 = tuple(dict1)
print(tup3)
#将区间转换成元组
range1 = range(1, 6)
tup4 = tuple(range1)
print(tup4)
#创建空元组
print(tuple())
  • 访问 
使用索引和切片方式，和list一致
  • 修改--不支持，只能重新赋值
  • 删除 del tuplename

dict

类似于C++的map

主要特征

解释

通过键而不是通过索引来读取元素

字典类型有时也称为关联数组或者散列表（hash）。它是通过键将一系列的值联系起来的，这样就可以通过键从字典中获取指定项，但不能通过索引来获取。

字典是任意数据类型的无序集合

和列表、元组不同，通常会将索引值 0 对应的元素称为第一个元素，而字典中的元素是无序的。

字典是可变的，并且可以任意嵌套

字典可以在原处增长或者缩短（无需生成一个副本），并且它支持任意深度的嵌套，即字典存储的值也可以是列表或其它的字典。

字典中的键必须唯一

字典中，不支持同一个键出现多次，否则只会保留最后一个键值对。

字典中的键必须不可变

字典中每个键值对的键是不可变的，只能使用数字、字符串或者元组，不能使用列表。

  • 创建 
1、使用{}创建，包含key和value，之间用:分隔
如 dict_a={'key1':'val1','key2':'val2'}
#使用字符串作为key
scores = {'数学': 95, '英语': 92, '语文': 84}
print(scores)
#使用元组和数字作为key
dict1 = {(20, 30): 'great', 30: [1,2,3]}
print(dict1)
#创建空元组
dict2 = {}
print(dict2)
2、通过fromkeys()方法创建字典dictname = dict.fromkeys(list，value=None)
knowledge = ['语文', '数学', '英语']
scores = dict.fromkeys(knowledge, 60)
3、通过dict()映射函数创建

创建格式

注意事项

a = dict(str1=value1, str2=value2, str3=value3)

str 表示字符串类型的键，value 表示键对应的值。使用此方式创建字典时，字符串不能带引号。

#方式1

demo = [('two',2), ('one',1), ('three',3)]

#方式2

demo = [['two',2], ['one',1], ['three',3]]

#方式3

demo = (('two',2), ('one',1), ('three',3))

#方式4

demo = (['two',2], ['one',1], ['three',3])

a = dict(demo)

向 dict() 函数传入列表或元组，而它们中的元素又各自是包含 2 个元素的列表或元组，其中第一个元素作为键，第二个元素作为值。

keys = ['one', 'two', 'three'] #还可以是字符串或元组

values = [1, 2, 3] #还可以是字符串或元组

a = dict( zip(keys, values) )

通过应用 dict() 函数和 zip() 函数，可将前两个列表转换为对应的字典。

  • 访问 
1、使用key来作为索引，dictname[key]
2、使用get(key,default)函数，当键不存在时返回default，也可缺省
  • 删除 
del dictname
  • 添加键值对 
直接用键值赋值的方式dictname[key]=value
如 dict_a['test']=0
  • 删除指定键值对 
使用del
如 del dict_a['test']
  • 修改现有的键值对 
指修改键值对中的值
如 dict_a['test']=2
  • 判断是否存在指定键值对 
in/not in 判断是否有key
a = {'数学': 95, '语文': 89, '英语': 90}
# 判断 a 中是否包含名为'数学'的key
print('数学' in a) # True
# 判断 a 是否包含名为'物理'的key
print('物理' in a) # False
  • keys()、values()、items()
keys() 方法用于返回字典中的所有键（key）；
values() 方法用于返回字典中所有键对应的值（value）；
items() 用于返回字典中所有的键值对（key-value）

可以使用以下方法来使用上述方法返回的数据
1、使用list()，将数据数据转换成列表
a = {'数学': 95, '语文': 89, '英语': 90}
b = list(a.keys())
print(b)
//['数学', '语文', '英语']
2、使用for in循环遍历其返回值
a = {'数学': 95, '语文': 89, '英语': 90}
for k in a.keys():
    print(k,end=' ')
print("\n---------------")
for v in a.values():
    print(v,end=' ')
print("\n---------------")
for k,v in a.items():
    print("key:",k," value:",v)

copy()方法 复制原数据
update()方法 使用一个字典所包含的键值对来更新已有的字典，不存在的会直接添加进去
pop()和popitem()方法
pop() 和 popitem() 都用来删除字典中的键值对，不同的是，pop() 用来删除指定的键值对，而 popitem() 用来随机删除一个键值对，它们的语法格式如下：
dictname.pop(key)
dictname.popitem()
其中，dictname 表示字典名称，key 表示键。

setdefault()方法
如果该 key 存在，那么直接返回该 key 对应的 value；
如果该 key 不存在，那么先为该 key 设置默认的 defaultvalue，然后再返回该 key 对应的 defaultvalue。

set

和C++里的set类似，都是保存的不重复的元素，但是只能存放相同类型的数据

  • 创建 
1、使用{}创建
2、set()函数创建集合
  • 访问 
使用for循环取出
如
a = {1,'c',1,(1,2,3),'c'}
for ele in a:
    print(ele,end=' ')
  • 删除 del()
  • 添加元素 
setname.add(element)
  • 删除元素 
setname.remove(element)
  • 集合运算：交集、并集、差集

表 1 Python set集合运算

运算操作

Python运算符

含义

例子

交集

&

取两集合公共的元素

>>> set1 & set2

{3}

并集

|

取两集合全部的元素

>>> set1 | set2

{1,2,3,4,5}

差集

-

取一个集合中另一集合没有的元素

>>> set1 - set2

{1,2}

>>> set2 - set1

{4,5}

对称差集

^

取集合 A 和 B 中不属于 A&B 的元素

>>> set1 ^ set2

{1,2,4,5}

set集合方法

set方法

方法名

语法格式

功能

实例

add()

set1.add()

向 set1 集合中添加数字、字符串、元组或者布尔类型

>>> set1 = {1,2,3}

>>> set1.add((1,2))

>>> set1

{(1, 2), 1, 2, 3}

clear()

set1.clear()

清空 set1 集合中所有元素

>>> set1 = {1,2,3}

>>> set1.clear()

>>> set1

set()


set()才表示空集合，{}表示的是空字典

copy()

set2 = set1.copy()

拷贝 set1 集合给 set2

>>> set1 = {1,2,3}

>>> set2 = set1.copy()

>>> set1.add(4)

>>> set1

{1, 2, 3, 4}

>>> set1

{1, 2, 3}

difference()

 set3 = set1.difference(set2)

将 set1 中有而 set2 没有的元素给 set3

>>> set1 = {1,2,3}

>>> set2 = {3,4}

>>> set3 = set1.difference(set2)

>>> set3

{1, 2}

difference_update()

set1.difference_update(set2)

从 set1 中删除与 set2 相同的元素

>>> set1 = {1,2,3}

>>> set2 = {3,4}

>>> set1.difference_update(set2)

>>> set1

{1, 2}

discard()

set1.discard(elem)

删除 set1 中的 elem 元素

>>> set1 = {1,2,3}

>>> set1.discard(2)

>>> set1

{1, 3}

>>> set1.discard(4)

{1, 3}

intersection()

set3 = set1.intersection(set2)

取 set1 和 set2 的交集给 set3

>>> set1 = {1,2,3}

>>> set2 = {3,4}

>>> set3 = set1.intersection(set2)

>>> set3

{3}

intersection_update()

set1.intersection_update(set2)

取 set1和 set2 的交集，并更新给 set1

>>> set1 = {1,2,3}

>>> set2 = {3,4}

>>> set1.intersection_update(set2)

>>> set1

{3}

isdisjoint()

set1.isdisjoint(set2)

判断 set1 和 set2 是否没有交集，有交集返回 False；没有交集返回 True

>>> set1 = {1,2,3}

>>> set2 = {3,4}

>>> set1.isdisjoint(set2)

False

issubset()

set1.issubset(set2)

判断 set1 是否是 set2 的子集

>>> set1 = {1,2,3}

>>> set2 = {1,2}

>>> set1.issubset(set2)

False

issuperset()

set1.issuperset(set2)

判断 set2 是否是 set1 的子集

>>> set1 = {1,2,3}

>>> set2 = {1,2}

>>> set1.issuperset(set2)

True

pop()

a = set1.pop()

取 set1 中一个元素，并赋值给 a

>>> set1 = {1,2,3}

>>> a = set1.pop()

>>> set1

{2,3}

>>> a

1

remove()

set1.remove(elem)

移除 set1 中的 elem 元素

>>> set1 = {1,2,3}

>>> set1.remove(2)

>>> set1

{1, 3}

>>> set1.remove(4)

Traceback (most recent call last):

  File "<pyshell#90>", line 1, in <module>

    set1.remove(4)

KeyError: 4

symmetric_difference()

set3 = set1.symmetric_difference(set2)

取 set1 和 set2 中互不相同的元素，给 set3

>>> set1 = {1,2,3}

>>> set2 = {3,4}

>>> set3 = set1.symmetric_difference(set2)

>>> set3

{1, 2, 4}

symmetric_difference_update()

set1.symmetric_difference_update(set2)

取 set1 和 set2 中互不相同的元素，并更新给 set1

>>> set1 = {1,2,3}

>>> set2 = {3,4}

>>> set1.symmetric_difference_update(set2)

>>> set1

{1, 2, 4}

union()

set3 = set1.union(set2)

取 set1 和 set2 的并集，赋给 set3

>>> set1 = {1,2,3}

>>> set2 = {3,4}

>>> set3=set1.union(set2)

>>> set3

{1, 2, 3, 4}

update()

set1.update(elem)

添加列表或集合中的元素到 set1

>>> set1 = {1,2,3}

>>> set1.update([3,4])

>>> set1

{1,2,3,4}

 frozenset(set集合的不可变版本)