Python学习----4 列表、元组、字典和集合

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

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

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

序列索引

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

//支持中文 
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集合的不可变版本)