您的位置:首页 > 理论基础 > 数据结构算法

【python学习笔记】Python数据结构(列表,元组,字典,集合)

2017-09-06 16:34 1121 查看

说明

数据结构的概念很好理解,就是用来将数据组织在一起的结构。换句话说,数据结构是用来存储一系列关联数据的东西。在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)


字典

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

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

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

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

访问:dic[key],获得key对应的值,若key不存在,则报错。

常用方法和操作:

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|个人博客
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: