【python学习笔记】Python数据结构（列表，元组，字典，集合）

说明

数据结构的概念很好理解，就是用来将数据组织在一起的结构。换句话说，数据结构是用来存储一系列关联数据的东西。在Python中有四种内建的数据结构，分别是List、Tuple、Dictionary以及Set。

列表

python里面用的最多最常用的数据类型，可以通过下标来访问，可以理解为java或者c里面的数组.但是功能比数组强大n倍,list可以放任意数量的python对象，可以是字符串，字符，整数，浮点等等都可以，而且创建，添加，删除也很方便.

1.创建list（内部对象可以是字符串，字符，数字，支持混搭）

List = ['aaa', 101, 0.01, 'ccc','A','B','C']

2.访问list

>>>print(List[0])

'aaa'

3.list切片

>>>print(List[1:3])

[101, 0.01]

4.list嵌套

bList=[100,200,['aaa','bbb','ccc']]
>>>print(bList[2][0])
'aaa'

5.list插入删除

//append插入
List.append('D')
>>>print(List)
['aaa', 101, 0.01, 'ccc','A','B','C','D']

//insert插入
List.insert(0,'E')
>>>print(List)
['E',aaa', 101, 0.01, 'ccc','A','B','C','D']

//del删除（明确删除对象位置）
List = ['aaa', 101, 0.01, 'ccc','A','B','C']
del List(0)
>>>print(List)
[101, 0.01, 'ccc','A','B','C']

//remove删除（不知道位置，只知道删除某个对象）
List = ['aaa', 101, 0.01, 'ccc','A','B','C']
List.remove('aaa')
>>>print(List)
[101, 0.01, 'ccc','A','B','C']

//pop删除队尾
List = ['aaa', 101, 0.01, 'ccc','A','B','C']
List.pop()
>>>print(List)
['aaa', 101, 0.01, 'ccc','A','B']

6.list支持+和*

list1=[1,2,3]

list2=[100,200,300]

list3=list1+list2

print(list3)

>>>[1, 2, 3, 100, 200, 300]

list4=['a','b','c']

list5=list4*3

print(list5)

>>>['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']

7.list排序（sort函数传入reverse为True或者False来降序或者升序）

sort方法还有两个可选参数：key和reverse

key在使用时必须提供一个排序过程总调用的函数：

x = ['mmm', 'mm', 'mm', 'm' ]
x.sort(key = len)
print x # ['m', 'mm', 'mm', 'mmm']

reverse实现降序排序，需要提供一个布尔值：

List = [3, 2, 4, 6]
List.sort(reverse=True)
print(List)
List = [6, 4, 3, 2]

8.计算list长度

aList=[1,2,3,4,5]
print(len(aList))
>>>5

9.计算list最大值最小值

aList=[1,2,3,4,5]
print(min(aList))
>>>1
print(max(aList))
>>>5

10.list扩展（用内置extend函数，看起来和+差不多，其实区别在于+是返回一个新的列表，而extend是直接修改了列表）

aList=[1,2,3]
b=[4,5,6]
aList.extend(b)
print(aList)
>>>[1, 2, 3, 4, 5, 6]

11.查找列表中某一个元素的索引//内置函数index

aList=['This','is','a','very','good','idea']
print(alist.index('very'))
>>>3

12.统计某个元组在列表里面的次数,内置函数count

aList=['to','do','or','not','to','do']
print(aList.count('to'))
>>>2

13.list其他操作

产生一个数值递增列表：

1)pList = range(N)，产生一个元素值为0~N-1的列表。如：pList = range(10) ->pList = [0,1,2,3,...,9]。

2)pList = range(sn,en),产生一个元素值为sn~en-1的列表。如：pList =  range(1,5) ->pList = [1,2,3,4]。

3)pList = range(sn,en,inc),产生一个元素值以inc递增的列表。如：pList = range(1,10,2) ->pList = [1,3,5,7,9]

固定值初始化：

pList = [value for index  in range(N)]，产生一个长度为N的列表，元素值都为value.
如：value = "x",N=10,则pLsit = ["x","x",...,"x"]

　　　　更简单的形式：pList = [value]*N。

列表复制：

1)pL1 = pL：pL1为pL的别名，即pL1和pL实质为同一个列表，修改其中一个列表，另一个列表也随之变化。

　　　　　　　　如：pL = [1,2,3],pL1 = pL,pL1[2] = 33,->pL = pL1 = [1,2,33]

2)pL2 = pL[:]：pL2为pL的一个克隆（或拷贝），即pL2和pL为不同的列表，修改其中一个列表，另一个不会受影响。

元组

元组和列表一样，也是一种序列，唯一的不同在于不能修改

创建

t1=1,2,3
t2="jeffreyzhao","cnblogs"
t3=(1,2,3,4)
t4=()
t5=(1,)
print t1,t2,t3,t4,t5
>>>(1, 2, 3) ('jeffreyzhao', 'cnblogs') (1, 2, 3, 4) () (1,)

特点
a、逗号分隔一些值，元组自动创建完成；

b、元组大部分时候是通过圆括号括起来的；

c、空元组可以用没有包含内容的圆括号来表示；

d、只含一个值的元组，必须加个逗号（,）；

tuple函数

tuple函数和序列的list函数几乎一样：以一个序列（注意是序列）作为参数并把它转换为元组。如果参数就算元组，那么该参数就会原样返回：
t1=tuple([1,2,3])
t2=tuple("jeff")
t3=tuple((1,2,3))
print t1
print t2
print t3

>>>
(1, 2, 3)
('j', 'e', 'f', 'f')
(1, 2, 3)

字典

1. 特性：以名称索引的分组数据。元组和列表以数字顺序索引，而字典的索引可以数字，字母，字符串，符号等。

   　　　　在字典中，索引叫做：键，即key,对应的值叫做值，即value。

2. 创建：dic = {key1:value1,key2:value2},可先创建空字典dic =｛｝，然后再初始化，如dic[“one”] = “firstValue”。

   　　　　注：键是唯一的，字典只认最后一个赋的键值。如：dic = {1:1,2:2,1:3} ->dic = {1:3,2:2},最后一个元素（1:3）被“舍弃”。

3. 访问：dic[key]，获得key对应的值，若key不存在，则报错。

4. 常用方法和操作：

    1)D.get(key, defualtValue)：获得key对应的值，若key不存在，则返回设置的默认值defualtValue,若没有设置默认值则返回None。
2)D.has_key(key) ：检查字典中是否存在键key，有该键返回TRUE，否则FALSE。
3)D.keys()：返回由字典所有键构成的列表。
4)D.values()：返回由字典所有值构成的列表。
5)D.items()：返回由字典所有键值对构成的列表，即[(key1,value1),(key2,value2),(key3,value3),...]。

6)D.update(dic2)：将字典dic2中的元素合并到字典D中。
7)D.popitem()：随机删除字典中的一个键值对（一项），并返回值。若字典为空则抛出异常。
8)D.clear()：清空字典中的元素并返回None

9)D.pop(key)：删除指定键所对应的项，并返回key对应的值。key不能为空，也不默认删除排在最后的元素，因为字典是无序的，注意和列表的区别！！！
10)D.copy()：拷贝字典，两个字典不是同一个字典。如d = {1:1,2:2},d1 = d.copy() ->d1 = {1:1,2:2}。
11)cmp(dict1,dict2)：比较字典，(优先级为元素个数、键大小、键值大小)，第一个大则返回1，第一个小则返回-1，一样大则返回0。
12)合并多个字典 dict(dict1.items()+dict2.items()+dict3.items()---)

集合

python的set和其他语言类似, 是一个无序不重复元素集, 基本功能包括关系测试和消除重复元素. 集合对象还支持union(联合), intersection(交), difference(差)和sysmmetric difference(对称差集)等数学运算.

sets 支持 x in set, len(set),和 for x in set。作为一个无序的集合，sets不记录元素位置或者插入点。因此，sets不支持 indexing, slicing, 或其它类序列（sequence-like）的操作。

创建

se = set([11,22,33,44])
print(se)
{33, 11, 44, 22}
print(type(se))
<class 'set'>
或者
>>> se = {'liu','yao'}
>>> se
{'yao', 'liu'}
>>> type(se)
<class 'set'>

1.add(添加元素)

>> se.add('123')
>>> se
{'yao', 'liu', '123'}
2.clear(清空集合)

>>> se.clear()
>>> se
set()
3.copy(浅拷贝)

>>> se_1 = {'liu','yao'}
>>> se_2=se_1.copy()
>>> se_2
{'yao', 'liu'}
4.difference差异比较

>>> se_1 = {'liu','yao','shi','shei'}
>>> se_2 = {'haode','shi','liu'}
#取出se_2中在se_1所没有的元素
>>> se_1.difference(se_2)
{'yao', 'shei'}
#取出se_1中在se_2所没有的元素
>>> se_2.difference(se_1)
{'haode'}
5.difference_update差异更新

>>> se_1
{'shi', 'yao', 'liu'}
>>> se_2
{'shi', 'liu', 'haode'}
>>> se_1.difference_update(se_2)
>>> se_1
{'yao'}
6.discard移除指定元素

>>> se_1
{'shi', 'yao', 'shei', 'liu'}
>>> se_1.discard('shei')
>>> se_1
{'shi', 'yao', 'liu'}
7.intersection取交集并且建立新的集合

>>> se_1={'liu','yao','shi','sha','bi'}
>>> se_2={'liu','yao','shi','er','bi'}
>>> se_1.intersection(se_2)
{'liu', 'shi', 'yao', 'bi'}
8.intersection_update取交集并且更新原来的集合

>>> se_1={'liu','yao','shi','sha','bi'}
>>> se_2={'liu','yao','shi','er','bi'}
>>> se_1.intersection_update(se_2)
>>> se_1
{'liu', 'shi', 'yao', 'bi'}
9.isdisjoint判断没有交集，没有返回true，有返回false

>>> se_1={'liu','yao','shi','sha','bi'}
>>> se_2={'liu','yao','shi','er','bi'}
>>> se_1.isdisjoint(se_2)
False
>>> se_2.isdisjoint(se_1)
False
或
>>> se_1={'liu','yao'}
>>> se_2={'liuu','yaoo'}
>>> se_2.isdisjoint(se_1)
True
10.issubset判断是否为子集

>>> se_1 = {'liu','yao'}
>>> se_2 = {'liu','yao','shabi'}
#判断se_1是否为se_2的子集
>>> se_1.issubset(se_2)
True
11.issuperset判断是否为父集

>>> se_1 = {'liu','yao'}
>>> se_2 = {'liu','yao','shabi'}
#判断se_1是否为se_2的父集
>>> se_1.issuperset(se_2)
False
#判断se_2是否为se_1的父集
>>> se_2.issuperset(se_1)
True
>>>
12.pop移除集合元素

>>> se_1 = {'liu','yao','sha','bi'}
>>> se_1.pop()
'sha'
13.remove删除指定元素集合

>>> se_1 = {'liu','yao','sha','bi'}
>>> se_1.remove('bi')
>>> se_1
{'sha', 'liu', 'yao'}
>>> 
14.symmetric_difference取两个集合的差集，并建立新的元素

>>> se_1 = {'liu','yao','sha','bi'}
>>> se_2 = {'liu','yao','shabi'}
>>> se_1.symmetric_difference(se_2)
{'sha', 'shabi', 'bi'}
>>> b=se_1.symmetric_difference(se_2)
>>> b
{'sha', 'shabi', 'bi'}
15.symmetric_difference_update取两个集合的差集，更新原来的集合对象

>>> se_1 = {'liu','yao','sha','bi'}
>>> se_2 = {'liu','yao','shabi'}
>>> se_1.symmetric_difference_update(se_2)
>>> se_1
{'sha', 'shabi', 'bi'}
16.union并集

>>> se_1
{'sha', 'shabi', 'bi'}
>>> se_2
{'shabi', 'liu', 'yao'}
>>> se_1.union(se_2)
{'yao', 'sha', 'shabi', 'liu', 'bi'}
17.update更新集合

>>> se_1
{'sha', 'shabi', 'bi'}
>>> se_1.update('liuyao')
>>> se_1
{'y', 'o', 'shabi', 'bi', 'u', 'i', 'sha', 'l', 'a'}
案例：

old_dict = {
    "#1":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 },
    "#2":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 },
    "#3":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 }
}
new_dict = {
    "#1":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 800 },
    "#3":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 },
    "#4":{ 'hostname':'c2', 'cpu_count': 2, 'mem_capicity': 80 }
}
#获取old_dict元素
old = set(old_dict.keys())
print(old)
#获取new_dict元素
new = set(new_dict.keys())
print(new)
#要更新的集合元素（交集）
update_set = old.intersection(new)
print(update_set)
#获取要删除的集合元素（差集）
delete_set = old.difference(new)
print(delete_set)
#获取要添加的集合元素()
add_set = new.difference(update_set)
print(add_set)

leason|个人博客