Python中的四种数据结构
Python中的内置数据结构（Built-in Data Structure）:列表list、元组tuple、字典dict、集合set，涵盖的仅有部分重点。 ⽬录：
⼀、列表list
list的显著特征：
1. 列表中的每个元素都可变的，意味着可以对每个元素进⾏修改和删除；2. 列表是有序的，每个元素的位置是确定的，可以⽤索引去访问每个元素；3. 列表中的元素可以是Python中的任何对象；
4. 可以为任意对象就意味着元素可以是字符串、整数、元组、也可以是list等Python中的对象。
----数据操作：1、直接创建列表
mylist = ['Google', 'Yahoo', 'Baidu']
2、对列表中的指定位置变更数据
mylist = ['Google', 'Yahoo', 'Baidu']#变更索引位置1Yahoo的内容为Microsoftmylist[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') #删除列表中的Microsoftdel 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中所有偶数⽣成⼀个新的列表bb = [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
重点：元组Tuple，⽤法与List类似，但Tuple⼀经初始化，就不能修改，没有List中的append(), insert(), pop()等修改的⽅法，只能对元素进⾏查询
下⾯看个例⼦来证实⼀下我们说的：
>>> a = (1,2,3,4)>>> a(1, 2, 3, 4)
>>> print(type(a))>>> a[1]=5Traceback (most recent call last):
File \"\ a[1]=5TypeError: 'tuple' object does not support item assignment>>> a[1:1] = 5
Traceback (most recent call last):
File \"\ a[1:1] = 5TypeError: 'tuple' object does not support item assignment>>> a[1]2
从上⾯的例⼦，证实了tuple不⽀持对元素的修改（包括删除），tuple⼀初始化便固定下来了。再来看⼀个例⼦：
>>> a = ('a','b',['A','B'])
>>> print(type(a)) #检测a的数据类型是什么 #检测出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的数据类型是什么 #检测出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', '!')
三、字典dict（dictionary）
字典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)#创建空字典2d = 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)
#删除⼀个数据,使⽤deldel 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\ 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\print(d.get(\"one222\
fromkeys：使⽤指定的序列作为键，使⽤⼀个值作为字典的所有的键的值
p = [\"one\#注意fromkeys两个参数的类型
#注意fromkeys的调⽤主体d = dict.fromkeys(p,\"222\")print(d)
四、集合set
集合更接近数学上集合的概念。集合中每个元素都是⽆序的、不重复的任意对象。
可以通过集合去判断数据的从属关系，也可以通过集合把数据结构中重复的元素减掉。集合可做集合运算，可添加和删除元素。
集合内数据⽆序，即⽆法使⽤索引和分⽚
集合内部数据元素具有唯⼀性，可以⽤来排除重复数据
集合内的数据:str,int,float,tuple,冰冻集合等，即内部只能放置可哈希数据
----集合的定义#集合的定义,set()s = set()print(type(s))print(s)
#也可以像下⾯这样做,⼤括号内⼀定要有值，否则定义出的将是⼀个dicts = {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\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_2 = s1.difference(s2)print(\"差集:\#并集
s_3 = s1.union(s2)print(\"并集:\
#检查⼀个集合是否为另⼀个⼦集s_4 = s1.issubset(s2)
print(\"检查⼦集结果：\#检查⼀个集合是否为另⼀个超集s_5 = s1.issuperset(s2)print(\"检查超集结果：\这⾥是运⾏结果：交集: {5, 6, 7}差集: {1, 2, 3, 4}
并集: {1, 2, 3, 4, 5, 6, 7, 8, 9}检查⼦集结果： False检查超集结果： False
frozen set:冰冻集合
冰冻集合是不可以进⾏任何修改的集合frozenset是⼀种特殊集合
创建冰冻集合的⽅式：
s = frozenset()
每天进步⼀点点，不要停⽌前进的脚步
