Python基础入门之[高级数据结构]学习笔记（四）

目录
一、Python的列表 list [1,“a”]
二、Python的元组 Tuple (1,“a”)
三、Python的字典 dict ｛k1:v1,k2:v2｝
四、Python的集合 set {1,2,“a”}
五、四种数据结构对比
六、四种数据结构函数、方法大全

个人简化的理解
列表 约等于 数组
元组 约等于 不可修改的数组
字典 约等于 键值数组
集合 约等于 不可重复的键

一、Python的列表 list[1,“a”]
列表list有序、可变。可增、删、改其中的数据。
创建空列表：data=[]
创建有值列表：data=[1,2,3,4]

1. 列表的索引和切片（和字符串类似）
   索引：list[数字下标idx]，访问某个元素，idx>=0 and idx<=len(list)-1，idx可以为负数，从最后往前计数。
   切片：list[开始值：结束值：步长]，三个参数皆可为负数，原理同字符串切片。
   切片可以重新赋值，可以和之前的长度不一样。（字符串不行）

例1
data=[1,2,'a','b','c']
data[2]="g"
print(data)
输出结果：[1, 2, 'g', 'b', 'c']

例2
data=[1,2,'a','b','c']
data[1:2]=["g","g","g","g"]
print(data)
输出结果：[1, 'g', 'g', 'g', 'g', 'a', 'b', 'c']

2. 列表的常用方法
   list.append(3)，在列表末尾新增一个元素。
   list.extend([4,‘a’,6])，在列表末尾新增一个列表。
   list1 + list2 ，两个列表相加，返回一个新的列表。
   list.clear() ，清空列表中的所有元素。
   len(list) ，返回列表的元素个数

• 列表的遍历

例1
data=[1,2,'a','b','c']
for i in data:
    print (i)
输出结果：
1
2
a
b
c

例2(重点语句：range(len(data)))
data=[1,2,'a','b','c']
for i in range(len(data)):
    print (i,data[i])
输出结果：
0 1
1 2
2 a
3 b
4 c

例3（重点enumerate关键字）
data=[1,2,'a','b','c']
for i,j in enumerate(data):
    print(i,j)
输出结果：
0 1
1 2
2 a
3 b
4 c

• 列表的排序

list.reverse()，将整个列表元素翻转。
list.sort(reverse=False)，reverse为F时正序排列；为T时倒序排列（sort()中可以为空，默认为正序排列）。

• 方便的列表推导式
  列表推导式又称列表解析式，提供一种简明扼要的方法来创建列表。

例1：
data=[3,4,50,6,8,1,2,33,11]
data2 = [i*i for i in data if i>10]
#满足条件后执行i*i; for循环遍历序列；条件语句。 
print(data2)
输出结果：[2500, 1089, 121]

例2：
data=[3,4,50,6,8,1,2,33,11]
aa="-".join( [str(i) for i in data] )
print(aa)
输出结果：3-4-50-6-8-1-2-33-11

例3：
fin = open("data.txt")
aa=[i.strip().split("\t")[1] for i in fin if len(i.strip())>0]
print(aa)
fin.close()
先for循环，将txt文档中每行读取出来，判断是否为空行，
如果不是空行，就strip去首尾空格换行，再用"\t"分割，并将第二个元素存放进列表。

二、 Python的元组 Tuple(1,“a”)
一种类似列表的数据序列类型，不可变，不可添加，不可删除，不可修改元素

• 创建方式：
  创建空元组：tup=()
  创建有值元组：tup=(1,‘a’,‘b’,4)
  创建单个元素元组：tup(5,) 这个要注意创建单个元组时不能省略后面的逗号。
  创建多个元素的元组时，也可省略小括号：tup=1,‘a’,‘b’,4

• 元组的索引和切片
  元组和列表一样支持索引和切片，但是不能更改元素。
  tup[下标数字idx]
  对元组进行切片，得到的结果还是元组。
  不能对元组中的元素进行赋值。

• 元组支持的方法
  tuple(list) ，把一个列表变成一个元组
  a,b,c = tup ，把元组中的元素拆包挨个给a,b,c。前后数目要一样多。
  len(tup) ，得到元素的个数
  tup1 + tup2 ，合并两个元组，得到一个新元组
  ‘a’ in tup ，判断元素是否在元组中
  for i in tup: ，用fox循环遍历元组

三、Python的字典 dict｛k1:v1,k2:v2｝
字典是一种key:value的数据结构，可以根据key设置和获取对应的value。

• 创建方式
  d = {key1:value1,key2:value2}
  d = {} 创建空字典
  d = {“id”:123,“name”:“xiaoming”,“age”:20}

• 获取数据
  print(d[“id”],d[“name”])
  如果key值不存在，就会报错。

• 新增修改数据
  d[“id”]=456
  如果“id”这个key不存在，就新增一对键值
  如果“id”这个key存在，就修改对应value的值
  字典的key不能重复，不能更改。 key可以是数字，字符串，元组，不能是可变的列表。

• 字典的常用方法
  len(dict) ，字典key:value的对数。
  dict.clear() ，清空字典
  str(dict) ，将整个字典转为字符串形式。
  key in dict ，判断key是否在dict的键中。
  dict.get(key,“bucunzai”) ，获取key的内容，如果key不存在，返回默认值"bucunzai"
  dict1.update(dict2) ，将dict2的所有键值对，加到dict1后面。

例：**字典推导式**
d = {"id":11,"name":"xiaoming","age":22}
bb={i:d[i] for i in d if len(str(d[i]))<3}
print(bb)

• 字典的遍历
  dict.items() ，以列表返回可遍历的（键，值）元组数组，常常用于for遍历。
  dict.keys() ，以列表返回字典所有的键
  dict.values() ,以列表返回字典所有的值

例1：打印字典的key，换成values也可以。
for i in dict.keys() :
    print(i)

例2：这个因为返回的列表中每队（键，值）是以元组存在的，
所以这里通过i,j两个变量，直接将元组中对应的两个值取出来。（不是特别理解）
d = {"id":11,"name":"xiaoming","age":22}
for i,j in d.items():
    print(i,j)

四、Python的集合 set
集合是一组无序、没有重复元素的key的集合，和字典非常类似。和字典一样，不能通过下标数字的方式访问元素，所以也都不支持切片。
主要用于：去重元素；访问效率高。

1. 创建方式：
   创建空集合：s = set()
   创建集合：s = {1,2,3,4}
   转换为集合：s = set(列表、元组、字符串)
   创建空集合不能用s = {} ，因为这是创建了一个字典dict。

2. 集合的常用方法
   len(set) ，取集合的元素个数
   for i in set ，对集合进行遍历
   set.add(key) ,新增一个key，如果有重复会自动去重。这时的key不能为列表等可变的内容。
   set.remove(key) ，删除一个key
   set.clear() ，清空set
   x in set ，判断元素是否在set集合中
   set1.update(set2) ，将set2中所有key添加到set1中，会去重。
   set1 & set2 或者set1.intersection(set2) ，求两个集合的交集（两个集合中都含有的元素）
   set1 | set2 或者set1.union(set2) ，求两个集合的并集（两个集合所有不重复值）
   set1 - set2 或者set1.difference(set2) ，求两个集合的差集（在set1集合中，不在set2集合中的元素）

集合推导式：s = {x for x in “abcd” if x not in “bc”}
这个和字典的推导式很接近，区别在于最前面的问题，一个是X；一个是X：X*X。

五、四种数据结构对比

六、四种数据结构函数、方法大全

# 个人简化的理解
# 列表 list[1,"a"]          约等于 数组
# 元组 tuple(1,"a")         约等于 不可修改的数组
# 字典 dict{k1:v1,k2:v2}    约等于 键值数组
# 集合 set{1,2,"a"}         约等于 不可重复的键

#-----------------------------------list 列表 [ ]
list1 = [88,99,11,22,33,66,22]
list2 = ["a","ee","b","cc"]
list3 = ["a",99,11,"ee","af"]

#函数
print(len(list1))#取列表元素个数
print(max(list2))#取列表元素中的最大值。元素类型要相同。
print(min(list1))#取列表元素中的最小值。元素类型要相同。
seq = (1,2,3,4)
print(list(seq))#将一个元组转为列表

#方法
list1.append("abc")#在列表1后面添加对象（可以是元素,列表，元组），对象转为1个元素
print(list1)
list1.extend(list2)#在列表1后面添加对象（可以是元素,列表，元组）,对象转为多个元素
print(list1)

print(list1.count(22))#统计22在列表中出现的次数
print(list1.index("a",5,10))#在5-8位置中，找到a的位置数，未找到报错。

list1.insert(10,"dddd")#在10的位置插入对象（可以是元素,列表，元组），对象转为1个元素
print(list1)

print(list1.pop(1))#删除指定下标的元素，可以为负数，返回要删除的元素内容
print(list1)
print(list1.remove(88))#删除指定名称的元素，无返回值。
print(list1)

list1.reverse()#将列表元素倒序排列
print(list1)

list2.sort(reverse=True)#对列表进行排序，T降序，F升序。元素类型要相同。
print(list2)

list3.clear()#清空列表
print(list3)

list3 = list2.copy()#复制list2给list3
print(list3)
print()

#-----------------------------------tuple 元组 ( )
tuple1 = ("a","99","11","ee","af")

#函数
#len、max、min  #取元素个数；最大值；最小值（与list相同）
print(tuple(list2))#将列表转化为元组


#-----------------------------------dict 字典 {k1:v1,k2:v2} 
dict1 = {"name":"xiaoming","age":22,"class":"first","china":"明明"}

#函数
#len、max、min  #取元素个数；最大值；最小值（与list相同）
print(str(dict1)) #将字典转为字符串

#方法
#print(dict1.clear())#清空字典所有元素

dict2 = dict1.copy() #对一个字典的浅复制
dict3 = dict1        #dict3对dict1进行了深拷贝[*这样拷贝两个字典值会同步发生变化]
dict3["age"] = 100
print(dict1,dict2,dict3)

list1 = ["cc","dd","ee","ff","hh"]
print(dict2.fromkeys(list1,"AA"))#创建一个新字典dict2,键为tup1,所有健的值为"AA"

print(dict1.get("age","BB"))#取键age的值，如果没有该键就返回"BB"
print(dict1.setdefault("age1","BB"))#取键age的值，如果没有该键就返回"BB"，并创建该键

print("name" in dict1)#判断键"name"是否在字典dict1中。

for i,j in dict1.items(): #将字典的键和值以列表的形式返回
    print(i,j)

print(list(dict1.keys()))#以列表的形式返回dict1的所有键
print(list(dict1.values()))#以列表的形式返回dict1的所有值

print(dict1.update(dict2))#将dict2的键值更新至dict1中，如果有重复键，值以dict2为准
print(dict1)

print(dict1.pop("age","CCC"))#删除键age，成功返回该键的值，失败返回CCC
print(dict1.popitem())#删除字典中最后一组键值，返回删除的键值。

#$save
#-----------------------------------set 集合 {1,2,"a"}  
set1 = {1,2,"aa","bb","cc"}
print(set1.add("dd"))#向set1集合中添加[一个]元素，如果已存在，则不添加
print(set1.update(["ee","hh","ab"]))#向set1集合中添加[一组]，如果已存在，则不添加，无返回
print(set1)

#print(set1.clear())#删除集合set1中所有元素
set2 = set1.copy()#复制set1给set2

set2 = {7,8.9,10,1,2}
print(set1,set2,set1.difference(set2))#取set1和set2的差集，结果返回新集合
print(set1.difference_update(set2))#取set1和set2的差集，结果返回给set1
print(set1)

print(set1.discard("aa"))#删除set1中指定元素
print(set1)

set1 = {1,2,"aa","bb","cc"}
print(set1,set2,set1.intersection(set2))#取set1和set2的交集，结果返回新集合
print(set1.intersection_update(set2))#取set1和set2的交集，结果返回给set1
print(set1)

set1 = {1,2,"aa","bb","cc"}
set2 = {7,8.9,10,1,2}
print(set1.isdisjoint(set2))#判断两个集合有无相同元素，没有返回真
print(set1.issubset(set2))#判断set1包含set2，包含返回真
print(set1.issuperset(set2))#判断set2包含set1，包含返回真
print(set1.pop())#随机移除set1中的一个元素
print(set1.remove("aa"))#移除set1中的指定元素，如果没有指定元素报错。
print(set1)

print(set1,set2,set1.symmetric_difference(set2))#移除两个集合中都存在的元素,结果返回新集合
print(set1.symmetric_difference_update(set2))#移除两个集合中都存在的元素,结果返回给set1
print(set1)

print(set1.union(set2))#返回两个集合中的所有不重复元素