Python中的四种数据结构
Posted 德邦总管
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Python中的四种数据结构相关的知识，希望对你有一定的参考价值。
转自 https://www.cnblogs.com/pychina/p/10219772.html
Python中的内置数据结构（Built-in Data Structure）:列表list、元组tuple、字典dict、集合set，涵盖的仅有部分重点。
目录：
list的显著特征：
- 列表中的每个元素都可变的，意味着可以对每个元素进行修改和删除；
- 列表是有序的，每个元素的位置是确定的，可以用索引去访问每个元素；
- 列表中的元素可以是Python中的任何对象；
- 可以为任意对象就意味着元素可以是字符串、整数、元组、也可以是list等Python中的对象。
----数据操作：
1、直接创建列表
mylist = [\'Google\', \'Yahoo\', \'Baidu\']
2、对列表中的指定位置变更数据
mylist = [\'Google\', \'Yahoo\', \'Baidu\'] #变更索引位置1Yahoo的内容为Microsoft mylist[1] = \'Microsoft\' #运行结果： [\'Google\', \'Microsoft\', \'Baidu\']
3、在列表后面追加元素
mylist.append(\'Alibaba\') #运行结果： [\'Google\', \'Microsoft\', \'Baidu\', \'Alibaba\']
4、在指定位置插入元素
mylist.insert(1, \'Tencent\') # [\'Google\', \'Tencent\', \'Microsoft\', \'Baidu\', \'Alibaba\']
5、删除元素
mylist = [\'Google\', \'Tencent\', \'Microsoft\', \'Baidu\', \'Alibaba\'] # 删除尾部元素 mylist.pop() # 会返回被删除元素 # 删除指定位置的元素 mylist.pop(1) # 删除索引为1的元素，并返回删除的元素 mylist.remove(\'Microsoft\') #删除列表中的Microsoft del mylist[1:3] #删除列表中索引位置1到位置 3 的数据
6、替换元素
mylist[0] = \'Baidu\' mylist[1] = [\'python\', \'java\', \'php\'] # 集合的数据类型可以不同，也可以是集合
7、列表排序
mylist = [1, 2, 5, 4] mylist.sort() # [1, 2 ,4, 5]
如果列表里面是字母，则根据Ascii码来排序
8、获取列表长度
mylist = [1, 2, 5, 4] len(mylist)
9、获取列表指定位置的数据
mylist = [\'Google\', \'Tencent\', \'Microsoft\', \'Baidu\', \'Alibaba\',\'Sina\'] #获取索引位置1的数据 mylist[1] #\'Tencent\' #获取索引位置1到5的数据，注意这里只会取到索引位置4,这里叫做取头不取尾 mylist[1:5] # \'Tencent\', \'Microsoft\', \'Baidu\', \'Alibaba\' #获取从最头到索引位置5的数据 mylist[ :5] #\'Google\', \'Tencent\', \'Microsoft\', \'Baidu\', \'Alibaba\' #获取从索引位置2开到最后的数据 mylist[2:] #\'Microsoft\', \'Baidu\', \'Alibaba\',\'Sina\'
10、用循环来创建列表
a = [1,2,3,4,5,6] #在a的数据基础上每个数据乘以10，再生成一个列表b， b = [i*10 for i in a] print(a) print(b) #运行结果如下: # [1, 2, 3, 4, 5, 6] # [10, 20, 30, 40, 50, 60]
11、过滤列表中的内容放入新的列表中
#生成一个从1到20的列表 a = [x for x in range(1,20)] #把a中所有偶数生成一个新的列表b b = [m for m in a if m % 2 == 0] print(b) #运行结果如下: # [2, 4, 6, 8, 10, 12, 14, 16, 18]
12、嵌套式生成列表
#生成一个列表a a = [i for i in range(1,4)] print(a) #生成一个列表b b = [i for i in range(100,400) if i % 100 == 0] print(b) # 嵌套式 c = [m+n for m in a for n in b] print(c) #运行结果： # [1, 2, 3] # [100, 200, 300] # [101, 201, 301, 102, 202, 302, 103, 203, 303]
Python中包含6中內建的序列：列表，元组，字符串、Unicode字符串、buffer对象和xrange对象。
----list函数
>>> list("Hello world")
[\'H\', \'e\', \'l\', \'l\', \'o\', \' \', \'w\', \'o\', \'r\', \'l\', \'d\']
可以通过list将序列创建为列表。
其实list为一种类型并非函数，但此处二者并无多大区别。下面的tuple、dict也是如此。
重点：元组Tuple，用法与List类似，但Tuple一经初始化，就不能修改，没有List中的append(), insert(), pop()等修改的方法，只能对元素进行查询
下面看个例子来证实一下我们说的：
>>> a = (1,2,3,4)
>>> a
(1, 2, 3, 4)
>>> print(type(a))
<class \'tuple\'>
>>> a[1]=5
Traceback (most recent call last):
File "<pyshell#3>", line 1, in <module>
a[1]=5
TypeError: \'tuple\' object does not support item assignment
>>> a[1:1] = 5
Traceback (most recent call last):
File "<pyshell#4>", line 1, in <module>
a[1:1] = 5
TypeError: \'tuple\' object does not support item assignment
>>> a[1]
2
从上面的例子，证实了tuple不支持对元素的修改（包括删除），tuple一初始化便固定下来了。
再来看一个例子：
>>> a = (\'a\',\'b\',[\'A\',\'B\']) >>> print(type(a)) #检测a的数据类型是什么 <class \'tuple\'> #检测出a的类型是元组tuple >>> print(a) (\'a\', \'b\', [\'A\', \'B\']) >>> a[2][0] = \'X\' #尝试变更数据，成功了，为什么？ >>> a[2][1] = \'y\' >>> print(a) #打印出变更后的内容 (\'a\', \'b\', [\'X\', \'y\']) >>> print(type(a[2])) #检测a的数据类型是什么 <class \'list\'> #检测出a[2]的类型是list
这里看似元素中的元素改变了，可是仔细分析下，元组中的第三个元素是一个列表。
代码4,5行改变的是列表中的值，元组所指的这个元素列表并没有改变，需要注意这点！
这就涉及到Python中的可变对象和不可变对象，像list这样的就是可变对象，tuple便是不可变对象。
元组是固定的列表，那么元组的意义何在呢？
因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple并且需要注意元组中元素的可变性！！
空的tuple可以记为()，若只有一个元素的tuple记为(1,)
t = (1,) # 如果需要是Tuple，就必须加上逗号，否则变成成了数字1了 # 这里如果没有“,”就变成了“(1)”
因为记为(1)的话，这个实际代表的是数字1，此时()是数学公式中的小括号
因为元组是固定的列表，所以其内置的大多数的方法和列表是差不多的。
可以通过tuple将序列转换为元组，用法和list一样
>>> tuple(\'Hello,world!\') (\'H\', \'e\', \'l\', \'l\', \'o\', \',\', \'w\', \'o\', \'r\', \'l\', \'d\', \'!\')
字典dictionary全称这个概念就是基于现实生活中的字典原型，生活中的使用名称-内容对数据进行构建，Python中使用键(key)-值(value)存储，也就是java、C++中的map。
dict的显著特征：
- 字典中的数据必须以键值对的形式出现，即k,v：
key:必须是可哈希的值，比如intmstring,float,tuple,但是，list,set,dict不行
value:任何值
- 键不可重复，值可重复
键若重复字典中只会记该键对应的最后一个值
- 字典中键(key)是不可变的，何为不可变对象，不能进行修改；而值(value)是可以修改的，可以是任何对象。
在dict中是根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。
----字典生成创建方式
#创建空字典1
d = {}
print(d)
#创建空字典2
d = dict()
#直接赋值方式
d = {"one":1,"two":2,"three":3,"four":4}
#常规字典生成式
dd = {k:v for k,v in d.items()}
print(dd)
#加限制条件的字典生成方式
ddd = {k:v for k,v in d.items() if v % 2 ==0}
print(ddd)
----字典的常见操作_____访问、删除、变更字典里面的内容
#访问字典中的数据
d = {"one":1,"two":2,"three":3,"four":4}
print(d["one"])
#变更字典里面的数据
d["one"] = "eins"
print(d)
#删除一个数据,使用del
del d["one"]
print(d)
#运行结果如下：
1
{\'one\': \'eins\', \'two\': 2, \'three\': 3, \'four\': 4}
{\'two\': 2, \'three\': 3, \'four\': 4}
----字典中成员检测
d = {"one":1,"two":2,"three":3,"four":4}
if 2 in d:
print("value")
if "two" in d:
print("key")
if ("two",2) in d:
print("kv")
----使用for循环访问字典
d = {"one":1,"two":2,"three":3,"four":4}
#使用for循环，直接按key值访问
for k in d:
print(k,d[k])
#上述代码也可以写成如下
for k in d.keys():
print(k,d[k])
#只访问字典的值
for v in d.values():
print(v)
#以下是特殊用法
for k,v in d.items():
print(k,\'--->\',v)
----字典相关函数
通用函数：len,max,min,dict
d = {"one":1,"two":2,"three":3,"four":4}
print(max(d))
print(min(d))
print(len(d))
dict() 函数的使用方法：
dict0 = dict() # 传一个空字典
print(\'dict0:\', dict0)
dict1 = dict({\'three\': 3, \'four\': 4}) # 传一个字典
print(\'dict1:\', dict1)
dict2 = dict(five=5, six=6) # 传关键字
print(\'dict2:\', dict2)
dict3 = dict([(\'seven\', 7), (\'eight\', 8)]) # 传一个包含一个或多个元祖的列表
print(\'dict3:\', dict3)
dict5 = dict(zip([\'eleven\', \'twelve\'], [11, 12])) # 传一个zip()函数
print(\'dict5:\', dict5)
str(字典)：返回字典的字符串格式
d = {"one":1,"two":2,"three":3,"four":4}
print(str(d))
clear：清空字典
items：返回字典的键值对组成的元组格式
d = {"one":1,"two":2,"three":3,"four":4}
i = d.items()
print(type(i))
print(i)
d.clear()
print(d)
keys：返回字典的键组成的一个结构
d = {"one":1,"two":2,"three":3,"four":4}
k = d.keys()
print(type(k))
print(k)
values：返回字典的值组成的一个结构
d = {"one":1,"two":2,"three":3,"four":4}
v = d.values()
print(type(v))
print(v)
get：根据制定键返回相应的值，好处是可以设置默认值
d = {"one":1,"two":2,"three":3,"four":4}
print(d.get("one333"))
#get默认值是None,可以设置
print(d.get("one",100))
print(d.get("one222",100))
fromkeys：使用指定的序列作为键，使用一个值作为字典的所有的键的值
p = ["one","two","three","four",] #注意fromkeys两个参数的类型 #注意fromkeys的调用主体 d = dict.fromkeys(p,"222") print(d)
- 集合更接近数学上集合的概念。集合中每个元素都是无序的、不重复的任意对象。
- 可以通过集合去判断数据的从属关系，也可以通过集合把数据结构中重复的元素减掉。集合可做集合运算，可添加和删除元素。
- 集合内数据无序，即无法使用索引和分片
- 集合内部数据元素具有唯一性，可以用来排除重复数据
- 集合内的数据:str,int,float,tuple,冰冻集合等，即内部只能放置可哈希数据
----集合的定义
#集合的定义,set()
s = set()
print(type(s))
print(s)
#也可以像下面这样做,大括号内一定要有值，否则定义出的将是一个dict
s = {1,2,3,4,5,6,7}
print(s)
创建集合时需要用list作为输入集合，可通过add()方法增加元素，remove()方法删除元素
s = set([1,2,3]) s.add(6) s.remove(2)
集合的内涵
普通集合内涵
--------以下集合会在初始化后自动过滤掉重复元素
s = {33,1,33,6,9,126,8,6,3,77,88,99,126}
print(s)
普通循环集合内涵
s = {33,1,33,6,9,126,8,6,3,77,88,99,126}
ss = {i for i in s}
print(ss)
带条件的集合内涵
s = {33,1,33,6,9,126,8,6,3,77,88,99,126}
sss = {i for i in s if i % 2 ==0}
print(sss)
多循环集合的内涵
s1 = {1,2,3,4}
s2 = {"nice","to","meet","you"}
s = {m*n for m in s2 for n in s1}
print(s)
----集合函数
- intersection：交集
- difference：差集
- union：并集
- issubset：检查一个集合是否为另一个子集
- issuperset：检查一个集合是否为另一个超集
通过代码来看区别：
s1 = {1,2,3,4,5,6,7}
s2 = {5,6,7,8,9}
#交集
s_1 = s1.intersection(s2)
print("交集:",s_1)
#差集
s_2 = s1.difference(s2)
print("差集:",s_2)
#并集
s_3 = s1.union(s2)
print("并集:",s_3)
#检查一个集合是否为另一个子集
s_4 = s1.issubset(s2)
print("检查子集结果：",s_4)
#检查一个集合是否为另一个超集
s_5 = s1.issuperset(s2)
print("检查超集结果：",s_5)
这里是运行结果：
交集: {5, 6, 7} 差集: {1, 2, 3, 4} 并集: {1, 2, 3, 4, 5, 6, 7, 8, 9} 检查子集结果： False 检查超集结果： False
frozen set:冰冻集合
- 冰冻集合是不可以进行任何修改的集合
- frozenset是一种特殊集合
创建冰冻集合的方式：
s = frozenset()
每天进步一点点，不要停止前进的脚步
以上是关于Python中的四种数据结构的主要内容，如果未能解决你的问题，请参考以下文章