python中的四种存储结构总结

一起看一下python中的四种存储结构

在python3中, 一共有4种基本的容器类型, list,tuple,dict,set

---

一：list

list相当于js中的array. array能做的事情, 差不多list都可以做到, 比如什么可变性,删除,添加,转变为字符串等基本操作

(一)：我们来看一下,怎么声明一个list

name = ['sam','jimmy'] 

(二)：在python中也是很有用的三个函数 len,max,min.

1，len(): 用来获取list的长度

>>> len(lists)
5

2，max(list|Numbers): 用来判断list中,最大的数字.

>>> max(lists)
5
>>> max(1,2,3,4,5)
5

3，min(list|Numbers): 用来判断list中,最小的数字

另外, 这里补充一个生成有序list最快捷的方式, 使用list comprehension.即,在括号里面使用 for statement. 实际上, 就是一个list 派生出另外一个list. 看一个demo

>>> lists = [x for x in range(10)]
>>> lists
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

range就是用来生成一个iterable

补充：
range(start, stop[, step]) -> range object
具体含义就是born 一定范围的值. 比如range(10): 0~10.
回到 list comprehension, 这个表达式x for x in range(10) 实际上, 就相当于

lists = []
for x in range(10):
   lists.append(x)

了解了LC 之后,我们就可以脱离手码lists的困扰了. python 很方便有木有

(三)： python中的两个特性 切片, 迭代

1，切片

通常,我们想要获取list中的某个元素,直接使用下标即可.但是,如果你想要取出list中间连续的几个,那么就会用到切片这一神奇的功能.

>>> my_list = ['p','r','o','g','r','a','m']
>>> my_list[2:5]    # elements 3rd to 5th
['o', 'g', 'r']
>>> my_list[:-5]    # 可以使用负数的index
['p', 'r', 'o', 'g']
>>> my_list[5:]     # 从5一直到最末
['a', 'm', 'i', 'z']
>>> my_list[:]      # 获取所有的ele
['p', 'r', 'o', 'g', 'r', 'a', 'm']

关于切片,值得补充一下就是colon两边的数字代表的意义特么还不一样：比如: my_list[2:5]实际表现的意义是,获取list中[2,5-1]的元素，Ps: 下标从0开始)实际上, 关于切片,还有一个隐藏的parameter.

>>> len[0:5:2]
[1, 3, 5]

第三个的参数的相当于设置步长,x+step,比如,你可以获得,奇数元素或者偶数元素等等.

2，迭代

实际上,这里的迭代,我们理解为for...in...循环就好.如下格式

>>> for v in len:
        print(v)

v就代表len中的每一个元素,然后你就可以执行相关的操作即可。另外, 如果你的list是这样的

>>> lists = [[1,2],[2,3]]
>>> for [a,b] in lists:
         print(a,b)

套用同样的格式即可

（四):关于python里相关操作list的方法.

list方法

1,添加

在python中, 常有append,extend,insert 3个方法用来进行添加. 不过,在介绍这3个方法之前,我们先要体会一下python flexibility--+,*,切片. 利用这3个trick来进行添加.

+
我们使用+, 来对list进行扩展.但实际上,他并不会修改原始的list。 所以这就有点尴尬了

>>> lists+[1]
[1, 2, 3, 4, 5, 1]

*
使用*进行翻倍扩展.但,同样不会改变原值

>>> lists * 2
[1, 2, 3, 4, 5, 1, 2, 3, 4, 5]

(1),append
这里就是向list中,尾加一个ele.

>>> lists.append(1)

(2),extend
用来向list中,添加多个ele.

>>> lists.extend([1,2,3,4])

他和+操作的区别就是, +不会改变原始的list,而extend会!

(3),insert
用来往指定index后添加一个ele.

>>> lists.insert(0,123)
>>> lists.insert(0,[1,23])

2,切片

使用切片,来对list直接修改.

>>> lists[1:3]=[1,2,3]  //只能使用另外一个list进行替代
>>> lists
[1, 1, 2, 3, 4, 5]

这里简要说一下分片的原理吧. 分片实际上是,内部创建一个list,然后进行替换, 所以,对应的类型只能是list.
比如下面, 就会报错

>>> lists[1:3]=1
TypeError: can only assign an iterable

3,删除

list里面的移除也是有很多讲究的, 常用的方法有pop,remove,del,clear

(1),pop
这里,我们就要将list理解为一个栈(Ps:一种数据结果). 他的结果就是先进后出(FILO). 相当于一个瓶子,你最后放的,会被最先拿出来. 实际上, 他和append是完全相反的.
append->入栈
pop->出栈
使用pop时, 他会返回被删除的元素

>>> lists = [1,2,3,4]
>>> lists.pop()
4
>>> lists
[1, 2, 3]

我们对比看一下,append

>>> lists.append(4)
>>> lists
[1, 2, 3, 4]

另外, pop还可以用来删除指定index的ele.

//删除第一个元素
>>> lists.pop(0)

(2),remove
remove是用来移除指定值. 并且,一次只会移除一个

>>> lists = [1,2,3,1,1,1]
>>> lists.remove(1)
>>> lists
[2, 3, 1, 1, 1]

(3),del && clear
前面说了pop,用来删除最新的栈元素, 但是我怎么删除list中最先放入, 也就是 list[0]的元素呢？
一个是用remove()造一个trick. 或者上面的pop例子

>>> lists.remove(lists[0])
>>> lists.pop(0)

不过使用remove的可读性超级差(pop的还可以), 所以, 我们可以使用 python中的内置函数, del 进行删除

del lists[0]

这里,我们来对比一下,3者的复杂度

del O(n - i)

pop O(n - i)

remove O(n)

很容器看出, del和pop的复杂度,比remove小, 所以,如果你想删除以下标开始的list的话,pop和del都行.

最后,我们如果想删除list的所有元素的话, 直接刚他. 使用clear()即可.

>>> lists.clear()
>>> lists
[]

4,排序操作

实际上, 这应该算是一切算法的根源了, 算法做的工作就是筛选和排序. 在list中,提供了两个方法供我们选择 sort, reverse.

(1),reverse()
实际上就是倒叙, 将你现在的list的顺序,逆向一遍

>>> lists
[1, 2, 3, 4]
>>> lists.reverse()
>>> lists
[4, 3, 2, 1]
sort([fn])

(2),sort
他根据fn的返回值来判断你原来顺序中的大小. fn接受两个参数fn(pre,next). 代表按照顺序的list的相邻两个元素.

fn>0: 则保持现在的顺序

fn<0: 交换两者顺序继续比较

fn=0: 保留两者的顺序

你可以自定义函数, 也可以直接使用默认的从小到大的排列.
即：

>>> lists = [1,3,2,4,2,3]
>>> lists.sort()
>>> lists
[1, 2, 2, 3, 3, 4]

注： sort本身自带了两个参数,可以用来决定排列的顺序: key,reverse

>>> lists=['ss','sss','s','ss']
>>> lists.sort(key=len)
>>> lists
['s', 'ss', 'ss', 'sss']

或者指明使用reverse=True

>>> lists=['ss','sss','s','ss']
>>> lists.sort(reverse=True)
>>> lists
['sss', 'ss', 'ss', 's']

当然, 如果你不想对原来的list进行改变, 可以使用sorted方法,返回一个新的list进行相关操作.
我们使用,help(sorted)来看一下具体用法

sorted(iterable, key=None, reverse=False)
    Return a new list containing all items from the iterable in ascending order.

同样, 他默认情况下也是升序表示

>>> lists
[5, 4, 3, 2, 1]
>>> sorted(lists)
[1, 2, 3, 4, 5]

同样,你也可以使用reverse和key进行相关指定. 同,list这里就不赘述了.

5,查询

在list 查询中, python也提供了我们两个方法, index,count.

(1),index(ele): 用来查找具体ele,在list中的序号,没有则会出现ValueError的错误.具体表达式为:

L.index(value, [start, [stop]])

看到这个表示之后,我们大概就可以猜到index的基本用法了, 限定范围查找, 也是很重要的一个feature

(2),count(ele):
用来统计具体ele在list中出现的次数.

>>> lists.count(2)
1

当然, 如果有同学相到, in 关键字能否实现这个查询的功能呢？答案 is yes!!!
即, 我们判断一个ele 是否存在于list 可以使用in 来判断

>>> if 1 in lists:
...     print(1)
... 
1
//或者使用index
>>> if lists.index(1):
     print(1)
1

这都是完全行得通的

6,复制

(1),分片
如果你想复制一个list最快的方法就是使用分片. 即

>>> lists
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> newOne = lists[0:3]
>>> newOne
[0, 1, 2]

(2),copy()

newOne = lists.copy();
//或者使用
newOne = lists[:]

这样,就避免了 内存地址重叠的problem了.

7，额外方法

除了上面说了的max,min,list等转换方法外, python 内置的还有sum,all,any.

(1),sum()
返回 list中所有元素之和

sum(lists)

(2),all()
是为了判断, lists中所有元素通过bool(ele)之后都为True,则返回True，所以,当list元素中有'',0,[]的话,则会返回False。另外,如果list为空的话,返回的也是True

(3),any()
使用bool(ele) 判断list中的每一个元素, 如果有一个为ture的话, 返回True, 相当于或的意思. 如果list为空的话返回的是False

>>> lists
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> any(lists)
True
>>> all(lists)  //存在0
False
>>> lists = []
>>> any(lists) //没有元素,不通过
False
>>> all(lists)  //没有元素,通过
True

---

二：Tuple

另外, 还有一个和list 很像的数据tuple.中文叫元组.他和list的主要区别就是, tuple是一开始就定义好的, 即, assign first,之后就永远不能被改变了. 所以, 一般全局比较重要的数据,我们都是使用tuple进行存放的.

(一)我们来创建一个Tuple

创建一个Tuple
通常来说,Tuple是放在parentheses 即, 圆括号() 内部.

>>> tub = (1,2,3)
>>> type(tub)
<class 'tuple'>

不过, 最近很流行的是 without parentheses. 即, 不加括号的方式. show:

>>> tub = 1,2,3
>>> type(tub)
<class 'tuple'>

这个名叫, tuple packing. 个人翻译为元组包.
不过在, 使用tuple的时候,需要注意,只有一个元素的tuple的创建(md,一个元素你还创建tuple干嘛,浪费内存?)一个元素的tuple创建, 需要在末尾+, 进行相关标识

>>> tub = 1,
// 或者
>>> tub = (1,)
>>> type(tub)
<class 'tuple'>

如果,你想访问tuple的话, 和访问list 是一个道理

>>> tub = (1,2,3,4,5,6,7)
>>> tub[0]
1
//当然,你也可以取负值
>>> tub[-1]
7

所以,这里我们也可以使用for...in...进行 遍历.

(二):不变的Tuple

一般创建了一个tuple, 之后你就用于无法改变他的值了, 也就是你不能删除,或者添加。不过,如果你的tuple里面放一些可变的内容的话, 比如,list的话,那情况就不一样了。基于这一点,我们理解tuple 应该说为 shallow不变形。即,不能改变值类型,但可以改变引用类型.

>>> tup
(1, 2, 3, [2, 3], 5)
>>> tup[3]
[2, 3]
>>> tup[3].append(1)
>>> tup
(1, 2, 3, [2, 3, 1], 5)
//删除tup, 会报错
>>> del tup[0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object doesn't support item deletion

虽然,我们不能对tuple执行CD操作, 但相关的查询方法我们还是可以使用的

(三):Tuple 查询

在tuple里面有两个查询方法, index和count, 另外你使用in也是没有问题的

>>> my_tuple = ('a','p','p','l','e',)
>>> my_tuple.count('p')
2
>>> my_tuple.index('l')
3
>>> 'a' in my_tuple
True

同样, 关于list的一些built-in methond. 在tuple身上也是使用的, 有 max,min,sum,all,any,len,sorted. 这几个, 都是木有问题的

总结一下: tuple方法什么时候我们用Tuple?
tuple就是用来放不变的数据,并且tuple在内部中有遍历加速(因为不变).

---

三：dict

(一):dict的特性

　　dict是python中的一个可变的数据类型，用{}表示，dict的key必须是不可变的数据类型，而value的数据类型可以任意。
　　格式：{key:value,key:value,key:value}
注： 键值对如果是字符串使用单引号，最后一个键值对没有逗号
dict的优点：
　　　　①：查询速度快，可以二分查找
　　　　②：key是不可以重复的
注：　　　
　　　　不可变数据类型： 元组，bool，int , str 可以hash
　　　　可变数据类型： dict ，list， set

(二),dict的方法：

1，增加的方法：dict有两种增加的方法

　(1),如果没有的键值对，则进行添加，如果有，则将值进行覆盖

dict1={'name':'jinxin','age':18,'male':'男'}
print(dict1)
dict1['high']=185
print(dict1)  # {'name': 'jinxin', 'age': 18, 'male': '男', 'high': 185}
dict1['age']=16
print(dict1) #  {'name': 'jinxin', 'age': 16, 'male': '男', 'high': 185}

　(2),如果有键值对，不做任何改变，没有键值对，才进行添加

dict1.setdefault("weight")
print(dict1)  #{'name': 'jinxin', 'age': 16, 'male': '男', 'high': 185, 'weight': None}
dict1.setdefault('weight','65kg')
print(dict1)  #{'name': 'jinxin', 'age': 16, 'male': '男', 'high': 185, 'weight': None}
dict1.setdefault('address','北京')
print(dict1)  #{'name': 'jinxin', 'age': 16, 'male': '男', 'high': 185, 'weight': None, 'address': '北京'}

2,dict的删除方法

　(1),使用pop()删除，如果有键，则删除，如果没有则会报错，如果不希望出现报错信息，可以在删除的后面添加信息

delDict={'name': 'jinxin', 'age': 16, 'male': '男', 'high': 185, 'weight': None, 'address': '北京'}
# delDict.pop('age')  #dict的删除操作是有返回值的
print(delDict.pop('age'))  # 16
print(delDict)  #{'name': 'jinxin', 'male': '男', 'high': 185, 'weight': None, 'address': '北京'}
print(delDict.pop('职业','没有此键'))  #没有此键

　(2),使用popitem()删除，随机删除，返回的是一个元组，元组里面存储的删除的键值，推荐使用pop()方法进行删除

print(delDict.popitem())  # ('address', '北京')

随机删除，返回值是删除的键值对

print(delDict)  #{'name': 'jinxin', 'male': '男', 'high': 185, 'weight': None}

　(3),使用del()删除，del()可以删除整个字典，也可以删除字典的某个键，如果删除的键不存在，则会出现报错

del delDict['name']
print(delDict)  #{'male': '男', 'high': 185, 'weight': None}
#使用del清空列表
del delDict
print(delDict)  #delDict已经删除,报错

　(4),清空列表也可以使用clear()
4,dict的修改

#直接修改
updateDict={'name':'jinxin','age':18,'male':'男'}
updateDict['name']='Jordan'
print(updateDict['name']) #Jordan

#调用update()修改
dictDemo={'name':"Jordan",'age':18}
dictDemo1={'address':'北京海淀','age':22}
dictDemo.update(dictDemo1)
print(dictDemo)

4,字典的查询

　　(1)查询字典的键：调用keys()方法
　　　查询字典的值：调用values()方法

# 字典的查
dict1={'name':'jinxin','age':18,'male':'男'}
print(dict1.keys()) #dict_keys(['name', 'age', 'male'])
print(dict1.values()) #dict_values(['jinxin', 18, '男'])
print(dict1.items())# dict_items([('name', 'jinxin'), ('age', 18), ('male', '男')])

#打印dict1的键
for i in dict1.keys():
    print(i )  # name age value

#打印dict的值
for v  in dict1.values():
    print(v) #jinxin 18 男

#打印字典的键值：

dict1={'name':'jinxin','age':18,'male':'男'}

for i in dict1.items():
    print(i)  # ('name', 'jinxin') ('age', 18) ('male', '男')
    
for k,v in dict1.items():
    print(k,v)  # name jinxin  age 18   male 男

　(2),字典的get()方法：使用get()方法可以查询某个键是否存在，如果不存在此键，则会返回None，但是可以在get()方法中添加信息避免出现None

dict1={'name':'jinxin','age':18,'male':'男'}
print(dict1.get('name')) #jinxin
print(dict1.get('address')) # None
print(dict1.get('address','没有此键'))  #没有此键

---

四：set

python的set和其他语言类似,是一个无序不重复元素集,基本功能包括关系测试和消除重复元素.集合对象还支持union(联合),intersection(交), difference(差)和sysmmetric difference(对称差集)等数学运算,sets 支持 x in set, len(set),和 for x in set。作为一个无序的集合，sets不记录元素位置或者插入点。因此，sets不支持indexing,slicing,或其它类序列（sequence-like）的操作。

下面来点简单的小例子说明吧。

>>> x = set('spam')
>>> y = set(['h','a','m'])
>>> x, y
(set(['a', 'p', 's', 'm']), set(['a', 'h', 'm']))

再来些小应用。

>>> x & y # 交集
set(['a', 'm'])
>>> x | y # 并集
set(['a', 'p', 's', 'h', 'm'])
>>> x - y # 差集
set(['p', 's'])

去除列表里重复元素，用hash来解决也行，只不过感觉在性能上不是很高，用set解决还是很不错的，示例如下：

>>> a = [11,22,33,44,11,22]
>>> b = set(a)
>>> b
set([33, 11, 44, 22])
>>> c = [i for i in b]
>>> c
[33, 11, 44, 22]

一：集合

集合用于包含一组无序的对象。要创建集合，可使用set()函数并像下面这样提供一系列的项：

s = set([3,5,9,10])      #创建一个数值集合
t = set("Hello")         #创建一个唯一字符的集合

注： 与列表和元组不同，集合是无序的，也无法通过数字进行索引。此外，集合中的元素不能重复。例如，如果检查前面代码中t集合的值，结果会是：

>>> t
set(['H', 'e', 'l', 'o'])

注意: 只出现了一个'l'。

二：集合操作

集合支持一系列标准操作，包括并集、交集、差集和对称差集，例如：

a = t | s          # t 和 s的并集
b = t & s          # t 和 s的交集
c = t – s          # 求差集（项在t中，但不在s中）
d = t ^ s          #对称差集（项在t或s中，但不会同时出现在二者中）

基本操作：

(1),add()
使用add()可以添加一项：

t.add('x')            # 添加一项
s.update([10,37,42])  # 在s中添加多项

(2),remove()
使用remove()可以删除一项：

t.remove('H')

(3),len()

len(s)#s的长度

(4),in

x in s #测试 x 是否是 s 的成员

(5),not in
x not in s
测试 x 是否不是 s 的成员

(6),<= >=

s.issubset(t)
s <= t # 测试是否 s 中的每一个元素都在 t 中
s.issuperset(t)
s >= t # 测试是否 t 中的每一个元素都在 s 中

(7),|

s.union(t)
s | t # 返回一个新的 set 包含 s 和 t 中的每一个元素

(8),&

s.intersection(t)
s & t #返回一个新的 set 包含 s 和 t 中的公共元素

(9),-

s.difference(t)
s - t #返回一个新的 set 包含 s 中有但是 t 中没有的元素

(10),^

s.symmetric_difference(t)
s ^ t #返回一个新的 set 包含 s 和 t 中不重复的元素

(11),copy()

s.copy() #返回 set “s”的一个浅复制

请注意: union(), intersection(), difference() 和 symmetric_difference() 的非运算符（non-operator，就是形如 s.union()这样的）版本将会接受任何 iterable 作为参数。相反，它们的运算符版本（operator based counterparts）要求参数必须是sets。这样可以避免潜在的错误，如：为了更可读而使用set('abc')&'cbs'来替代set('abc').intersection('cbs')。从 2.3.1 版本中做的更改：以前所有参数都必须是 sets。
另外，Set 和 ImmutableSet 两者都支持 set 与 set之间的比较。两个 sets 在也只有在这种情况下是相等的：每一个set中的元素都是另一个中的元素（二者互为subset）。一个set比另一个set小，只有在第一个et 是第二个 set 的subset时（是一个subset，但是并不相等）。一个set 比另一个set打，只有在第一个set是第二个set的superset时（是一个superset，但是并不相等）。子set和相等比较并不产生完整的排序功能。例如：任意两个sets都不相等也不互为子set，因此以下的运算都会返回 False：a<b, a==b, 或者a>b。因此，sets 不提供 cmp 方法。
因为 sets 只定义了部分排序功能（subset 关系），list.sort() 方法的输出对于 sets 的列表没有定义。

运算符
运算结果

hash(s) #返回 s 的 hash 值

下面这个表列出了对于 Set 可用二对于 ImmutableSet 不可用的运算：

运算符（voperator）
等价于
运算结果

s.update(t)
s |= t
返回增加了 set “t”中元素后的 set “s”

s.intersection_update(t)
s &= t
返回只保留含有 set “t”中元素的 set “s”

s.difference_update(t)
s -= t
返回删除了 set “t”中含有的元素后的 set “s”

s.symmetric_difference_update(t)
s ^= t
返回含有 set “t”或者 set “s”中有而不是两者都有的元素的 set “s”

s.add(x)

向 set “s”中增加元素 x

s.remove(x)

从 set “s”中删除元素 x, 如果不存在则引发 KeyError

s.discard(x)

如果在 set “s”中存在元素 x, 则删除

s.pop()

删除并且返回 set “s”中的一个不确定的元素, 如果为空则引发 KeyError

s.clear()

删除 set “s”中的所有元素

请注意： 非运算符版本的 update(), intersection_update(), difference_update()和symmetric_difference_update()将会接受任意 iterable 作为参数。从 2.3.1 版本做的更改：以前所有参数都必须是 sets。这个模块还包含一个 union_update() 方法，它是 update() 方法的一个别名。包含这个方法是为了向后兼容。程序员们应该多使用 update() 方法，因为这个方法也被内置的 set() 和 frozenset() 类型支持。

---

五：list，tuple，dict，set特点对比总结：

1 .list

1），list是一个使用方括号括起来的有序元素集合;

2），List 可以作为以 0 下标开始的数组,任何一个非空 list 的第一个元素总是 L[0],负数索引从 list 的尾部开始向前计数来存取元素。任何一个非空的 list 最后一个元素总是 L[-1];

3），有分片功能，两个list可以相加；

4），append 向 list 的末尾追加单个元素；

5），insert 将单个元素插入到 list 中；

6），extend 用来连接 list，使用一个 list 参数进行调用；

7），append 接受一个参数,这个参数可以是任何数据类型,并且简单地追加到 list 的尾部；

8），index 在 list 中查找一个值的首次出现并返回索引值；

9），要测试一个值是否在 list 内, 使用 in, 如果值存在, 它返回 True, 否则返为 False ；

10），remove 从 list 中删除一个值的首次出现；

11），pop 可以删除list的最后一个元素,然后返回删除元素的值，用索引删除制定位置的值；

2.tuple

1），tuple是不可变的list，创建了一个tuple就不能以任何方式改变它；

2），定义tuple是将整个元素集是用小括号括起来，是有序集合；

3），tuple的索引与list一样从0开始,所以一个非空的tuple的第一个元素总是t[0]；

4），负数索引与 list 一样从 tuple 的尾部开始计数；

5），与 list 一样分片 (slice) 也可以使用。分割一个 tuple 时, 会得到一个新的 tuple；

6），没有 append、extend、remove或pop方法以及index方法；

7），可以使用in来查看一个元素是否存在于tuple 中。

3.dict

1），dict定义了键和值之间的一一对应关系，每个元素都是一个key-value对；

2），整个元素集合用大括号括起来，有序集合；可以通过 key 得到value, 但不能通过vaule获取 key；在一个 dict中不能有重复的 key, 并且 key 是大小写敏感的；

3），键可以是数字、字符串或者是元组等不可变类型；

4），用del使用key可以删除dict中的独立元素；

5），用clear可以清除dict中的所有元素。

4.set

1），set是建立一系列无序的，不重复的元素；

2），创建set的方式是调用set()并传入一个list，list的元素将作为set的元素；

3），set和dict的唯一区别仅在于没有存储对应的value。