Python的数据结构

序列是Python中最基本的数据结构。序列中的每一个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。

Python有6个序列的内置类型，但最多见的是列表和元组。

序列均可以进行的操做包括索引，切片，加，乘，检查成员。

此外，Python已经内置肯定序列的长度以及肯定最大和最小的元素的方法。

1、列表

列表是最经常使用的Python数据类型，它能够做为一个方括号内的逗号分隔值出现。

列表的数据项不须要具备相同的类型，建立一个列表，只要把逗号分隔的不一样的数据项使用方括号括起来便可。

Python中列表是可变的，这是它区别于字符串和元组的最重要的特色，一句话归纳即：列表能够修改，而字符串和元组不能。

list1 = ['XXXX', 'b', 3, 'c',3, '&', 'a', 3, '3', 3, 'aa', '3', 'XXXX']
list2 = ['e', 'f', 'g']

若是想要建立一个空列表，可使用以下的方式。

In [27]: list1=[]                  # 建立一个空的列表

In [28]: type(list1)
Out[28]: list

在实际编写代码的过程当中，咱们会直接使用 list 函数生成一个列表。

In [29]: list2=list()             # 经过list方法建立一个空的列表

In [30]: list2
Out[30]: []

In [31]: type(list2)
Out[31]: list

想要向列表里面添加元素可使用 append 方法。

In [33]: list2.append("a")        # 向列表里面添加"a"元素

In [34]: list2
Out[34]: ['a']

In [35]: list2.append("b")        # 向列表里面添加"b"元素

In [36]: list2
Out[36]: ['a', 'b']

接着咱们连续添加了几个元素以后，想要删除某个元素该怎样呢？

In [39]: list2
Out[39]: ['a', 'b', 'cdewd', 'qewq']

In [40]: del list2[-1]                  # 删除列表中最后一个元素

In [41]: list2        
Out[41]: ['a', 'b', 'cdewd']

也可使用 remove 方法删除指定下标的元素。

In [42]: list2.remove(list2[2])    # 删除列表中下标为2的元素

In [43]: list2
Out[43]: ['a', 'b']

举个例子，如今有两个非空列表 list1 和 list2，咱们将使用一些方法对两个列表进行操做。

list1 = ['XXXX', 'b', 3, 'c',3, '&', 'a', 3, '3', 3, 'aa', '3', 'XXXX']
list2 = ['e', 'f', 'g']

将 list1 取出 ‘XXXX’ 中间的部分，造成一个新的列表list3。

list3=list1[1:-1]
print(list3)

list3 = [ 'b', 3, 'c',3, '&', 'a', 3, '3', 3, 'aa', '3',]

而后删除 list3 中的特殊符号。

del list3[4]
print(list3)

list3 = [ 'b', 3, 'c',3,  'a', 3, '3', 3, 'aa', '3',]

统计 3 在list3中出现的次数。

print(list3.count(3))

对 list3 排序

list3.sort()
print(list3)

 

2、元组

Python 的元组与列表相似，不一样之处在于元组的元素不能修改。

元组使用圆括号括起来，元素之间用逗号分隔；空的圆括号表示空元组；当只有一个元素时，必须以逗号结尾。

tup1 = ('abc', 'def', 1996, 2018);
tup2 = (1, 2, 3, 4, 5 );
tup3 = "a", "b", "c", "d";      # 不须要括号也能够
type(tup3)
<class 'tuple'>

元组中只包含一个元素时，须要在元素后面添加逗号，不然括号会被看成运算符使用。

In [17]: t1=1

In [18]: type(t1)
Out[18]: int                  # 表示的是字符串

In [19]: t2=1,

In [20]: type(t2)
Out[20]: tuple                # 表示的是元组

当对一个元素赋值时，再将该元素加入元组，那么该元素表示的则是实际的值。

In [24]: b="qwe"

In [25]: t=("a",b,"c")

In [26]: t
Out[26]: ('a', 'qwe', 'c')

元组可使用下标索引来访问元组中的值，也能够对元组进行链接组合，可是元组中的元素值是不容许删除的，但咱们可使用 del 语句来删除整个元组。

del tup;   # 慎用

与字符串同样，元组之间可使用 + 号和 * 号进行运算。这就意味着他们能够组合和复制，运算后会生成一个新的元组。

Python 表达式	结果	描述
len((1, 2, 3))	3	计算元素个数
(1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	链接
('Hi!',) * 4	('Hi!', 'Hi!', 'Hi!', 'Hi!')	复制
3 in (1, 2, 3)	True	元素是否存在
for x in (1, 2, 3): print (x,)	1 2 3	迭代

由于元组也是一个序列，因此咱们能够访问元组中的指定位置的元素，也能够截取索引中的一段元素.

L = ('abc', 'qwe', 'asd')

以上面元组 L 为例，归纳以下。

Python 表达式	结果	描述
L[2]	'asd'	读取第三个元素
L[-2]	'qwe'	反向读取；读取倒数第二个元素
L[1:]	('qwe', 'asd')	截取元素，从第二个开始后的全部元素。

 

3、字典

字典是另外一种可变容器模型，且可存储任意类型对象。

字典的每一个键值(key=>value)对用冒号(:)分割，每一个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式以下所示：

d = {key1 : value1, key2 : value2 }

字典是Python中惟一的映射类型（哈希表），其对象是可变的，可是字典的键必须使用不可变对象，一个字典中可使用不一样类型的键值，方法能够有：

keys（）

values（）

items（）

咱们能够像建立列表的方式同样建立一个空字典。

In [11]: dict={}

In [12]: type(dict)
Out[12]: dict

往字典里面添加一些数据。

In [13]: dict={'a':1,1:123} 
In [14]: dictOut[14]: {1: 123, 'a': 1}         # 顺序是可变的

存入字典的数据类型应该用只读的。

In [15]: dict1={'a':1, 1:123, ('qq','wx'):'hello'}

In [16]: dict1
Out[16]: {1: 123, 'a': 1, ('qq', 'wx'): 'hello'}

查看字典的长度，能够看到咱们刚刚定义的字典有3个元素。

In [17]: len(dict1)
Out[17]: 3

在 ipython 中使用tab键咱们能够查看字典有多少种方法。

In [18]: dict.
dict.clear       dict.has_key     dict.itervalues  dict.setdefault  dict.viewkeys
dict.copy        dict.items       dict.keys        dict.update      dict.viewvalues
dict.fromkeys    dict.iteritems   dict.pop         dict.values      
dict.get         dict.iterkeys    dict.popitem     dict.viewitems

查看全部的 keys 值。

In [18]: dict1.keys()
Out[18]: ['a', 1, ('qq', 'wx')]

查看全部的values值，也会一样返回一个列表，里面是字典所存储的全部values值。

In [19]: dict1.values()
Out[19]: [1, 123, 'hello']

使用 keys 值查找 values 值。

In [16]: dict1
Out[16]: {1: 123, 'a': 1, ('qq', 'wx'): 'hello'}

In [22]: dict1.get(1)
Out[22]: 123

若是keys值不在所取的字典里，不会返回值，可是给定了keys，values的话，则会返回给的values值。

In [24]: dict1.get('b')

In [25]: dict1.get('b','c')
Out[25]: 'c'

判断 keys 是否存在于字典。

In [26]: 'v' in dict1
Out[26]: False

In [27]: 'a' in dict1
Out[27]: True

也可使用字典的方法进行判断。

In [28]: dict1.has_key('v')
Out[28]: False

In [29]: dict1.has_key('a')
Out[29]: True

使用 items 能够将字典返回为一个列表，成为列表以后就能够对其遍历，或者切片，而后获得想要的结果。

In [16]: dict1
Out[16]: {1: 123, 'a': 1, ('qq', 'wx'): 'hello'}

In [30]: dict1.items()
Out[30]: [('a', 1), (1, 123), (('qq', 'wx'), 'hello')]

字典的 update 方法把两个字典更新成一个字典：

In [35]: dict1
Out[35]: {1: 123, 'a': 1, ('qq', 'wx'): 'hello'}

In [36]: dict2
Out[36]: {'e': 3, 'q': 1, 'w': 2}

In [37]: dict.update(dict1,**dict2)

In [38]: dict
Out[38]: {1: 123, 'a': 1, 'e': 3, 'q': 1, 'w': 2, ('qq', 'wx'): 'hello'}

好比咱们能够写个 for 循环来遍历出字典的 keys 和 values。

In [47]: for k in dict1:
   ....:     print k,dict1[k]
   ....:     
a 1
1 123
('qq', 'wx') hello

也能够先用 items 方法让字典返回一个列表，再进行 for 循环。

In [50]: dict1.items()
Out[50]: [('a', 1), (1, 123), (('qq', 'wx'), 'hello')]

In [51]: for k, v in dict1.items(): print k,v
a 1
1 123
('qq', 'wx') hello

小练习：

#!/usr/local/python3/bin/python

info={}
name=input("Please input a number : ")
age=input("Please input your age : ")
sex=input("Please input your sex(M/F) : ")

info['name']=name  #下标为name的存到info字典里面
info['age']=age
info['sex']=sex

#print(info)
#print(info.items())

for i,w in info.items():
    print('%s : %s' % (i,w))

运行状况以下：

Please input a number : zyy
Please input your age : 21
Please input your sex(M/F) : F
name : zyy
age : 21
sex : F

 

 

参考资料：

1. http://www.runoob.com/python3/python3-list.html