python内置数据结构_Python的4个内置数据结构

Python提供了4个内置数据结构（内置指可以直接使用，无需先导入），可以保存任何对象集合，分别是列表、元组、字典和集合。

一、列表

有序的可变对象集合。

1、列表的创建例子

list1 =[]

list2 = list()

list3= ['hello', 123]

list4= [[1,2],['a','b']]

2、列表常用方法

L.index(v [, begin[, end]]) 　　返回对应元素的索引下标, begin为开始索引，end为结束索引,当 value 不存在时触发ValueError错误

L.insert(index, obj)　　将某个元素插放到列表中指定的位置

L.count(x)　　返回列表中元素的个数

L.remove(x)　　从列表中删除第一次出现在列表中的值

L.copy()　　复制此列表（只复制一层，不会复制深层对象)

L.append(x)　　向列表中追加单个元素

L.extend(lst)　　向列表追加另一个列表

L.clear()　　清空列表,等同于 L[:] = []

L.sort(reverse=False)　　将列表中的元素进行排序，默认顺序按值的小到大的顺序排列

L.reverse()　　列表的反转，用来改变原列表的先后顺序

L.pop([index])　　删除索引对应的元素，如果不加索引，默认删除最后元素，同时返回删除元素的引用关系

使用例子

list1 =[]

list1.append('a')print(list1) #结果：['a']

list1.extend(['c','b','e'])print(list1) #结果：['a', 'c', 'b', 'e']

idx= list1.index('b')print(idx) #结果：2

list1.sort()print(list1) #结果：['a', 'b', 'c', 'd']

list1.insert(3,'d')print(list1) #结果：['a', 'b', 'c', 'd', 'e']

list1.remove('e')print(list1) #结果：['a', 'b', 'c', 'd']

3、列表切片的使用

符合序列的有序序列都支持切片（slice），例如列表，字符串，元组。

格式：【start:stop:step】

start：开始索引，如果没有指定，则默认值为0。负数表示从右边开始算起。

stop：结束索引，如果没有指定，则取列表允许的最大值。（备注：取值不包括结束索引）

step：步长值，如果没有指定，则默认值为1。步长为正时，从左向右取值。步长为负时，反向取值。

使用例子：

a = [1,2,3,4,5,6,7,8,9,10]print(a[0:8:]) #索引0到8（结果不包括索引8值），结果：[1, 2, 3, 4, 5, 6, 7, 8]

print(a[5:]) #只指定开始索引为3，结果：[6, 7, 8, 9, 10]

print(a[-5:]) #从右边开始算起取值，结果：[6, 7, 8, 9, 10]

print(a[:5]) #只指定结果索引为5（结果不包括索引5值），结果：[1, 2, 3, 4, 5]

print(a[::2]) #步长为2，结果：[1, 3, 5, 7, 9]

print(a[::-1]) #反向取值，结果：[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

4、列表推导式

列表推导式是利用其它列表创建新列表的一种方式。

基本格式:

变量名=[表达式 for 变量 in 列表]

变量名= [表达式 for 变量 in 列表 if 条件]

#不使用列表推导式，给list1赋值过程

list1 =[]for i in range(10):

list1.append(i)print(list1) #结果：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

#以下为列表推导式的使用，第一个和上面结果一样

#变量 循环体 条件(可选)

list2 = [i for i in range(10)]print(list2)#结果：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

#条件

list3 = [i for i in range(10) if i < 4]print(list3) #结果：[0, 1, 2, 3]

#函数

deftest(x):return x*2list4= [test(i) for i in range(10)]print(list4) #结果：[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

二、元组

有序的不可变对象集合。

元组创建后就不能修改。

元组创建使用小括号，在括号中添加元素，并使用逗号隔开即可。

如果元组只有一个元素，需要在元素后面加一个逗号。

1、元组的创建例子

tup1 =()

tup2 = tuple()

tup3= (1,)

tup4= ('a','bc');

2、元组一些用法例子

list1 = [1,2,3,4,5]

tup1= tuple(list1) #列表转为元组

print(len(tup1)) #结果：5

print(tup1[0]) #结果：1

print(tup1[1:2]) #结果：(2,)

print(max(tup1)) #结果：5

print(min(tup1)) #结果：1

三、字典

无序的键/值对集合。

1、字典的创建例子

dict1 ={}

dict2 = dict()

dict3= {'id':1,'name':'张三'}

dict4= {'p1':{'id':1,'name':'张三'},'p2':{'id':2,'name':'李四'}}

2、字典常用方法

radiansdict.clear() 删除字典内所有元素

radiansdict.copy() 返回一个字典的浅复制

radiansdict.fromkeys() 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值

radiansdict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值

key in dict 如果键在字典dict里返回true，否则返回false

radiansdict.items() 以列表返回可遍历的(键, 值) 元组数组

radiansdict.keys() 返回一个迭代器，可以使用 list() 来转换为列表

radiansdict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default

radiansdict.update(dict2) 把字典dict2的键/值对更新到dict里

radiansdict.values() 返回一个迭代器，可以使用 list() 来转换为列表

pop(key[,default]) 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。

popitem() 随机返回并删除字典中的一对键和值(一般删除末尾对)。

使用例子

dict = {'id':1,'name':'张三','sex':'男'}#存在直接修改

dict['name'] = '李四'

print(dict) #结果：{'id': 1, 'name': '李四', 'sex': '男'}

#不存在则新增

dict['company'] = 'xx公司'

print(dict) #结果：{'id': 1, 'name': '李四', 'sex': '男', 'company': 'xx公司'}

#设置默认值，不存在键则先创建

dict.setdefault('age',20)#数字类型可以计数，如果键不存在会出错，需要先调用上面setdefault

dict['age'] += 1

print(dict) #结果：{'id': 1, 'name': '李四', 'sex': '男', 'company': 'xx公司', 'age': 21}

#删除方法1

dict.pop('company')print(dict) #结果：{'id': 1, 'name': '李四', 'sex': '男', 'age': 21}

#删除方法2

del dict['sex']print(dict) #结果：{'id': 1, 'name': '李四', 'age': 21}

#判断键是否存在，结果：id存在

if 'id' indict:print('id存在')else:print('id不存在')#循环迭代1

for k indict:print(k, dict[k])"""结果：

id 1

name 李四

age 21"""

#循环迭代2，结果同1：

for k,v indict.items():print(k, v)#循环迭代3：按字母排序

for k,v insorted(dict.items()):print(k, v)"""结果：

age 21

id 1

name 李四"""

#字典嵌套的取值

dict2 = {'p1':{'id':1,'name':'张三'},'p2':{'id':2,'name':'李四'}}print(dict2['p1']['name']) #结果：张三

#字典嵌套的循环迭代

for k,v indict2.items():for k2,v2 inv.items():print(k2, v2)"""结果：

id 1

name 张三

id 2

name 李四"""

3、字典推导式

字典推导式的使用和列表推导式类似

dict1 = {'id':1,'name':'张三','sex':'男'}

dict2= {k : v for k, v in dict1.items() if k in ['id','name']}print(dict2) #结果：{'id': 1, 'name': '张三'}

四、集合

无序的唯一对象集合。

1、集合的创建

可以使用大括号 { } 或者 set() 函数创建集合。

注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

a ={}

b=set()print(type(a)) #结果：

print(type(b)) #结果：

c= {1,2,3,'c','d','e','e'}

d= set([3,4,5,'a','b','c'])print(c) #结果：{'d', 1, 2, 3, 'e', 'c'}

print(d) #结果：{'b', 3, 4, 5, 'a', 'c'}

2、集合常用方法

add()为集合添加元素

clear()移除集合中的所有元素

copy()拷贝一个集合

difference()返回多个集合的差集

difference_update()移除集合中的元素，该元素在指定的集合也存在。

discard()删除集合中指定的元素

intersection()返回集合的交集

intersection_update()删除集合中的元素，该元素在指定的集合中不存在。

isdisjoint()判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。

issubset()判断指定集合是否为该方法参数集合的子集。

issuperset()判断该方法的参数集合是否为指定集合的子集

pop()随机移除元素

remove()移除指定元素

symmetric_difference()返回两个集合中不重复的元素集合。

symmetric_difference_update()移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。

union()返回两个集合的并集

update()给集合添加元素

使用例子

a = {1}#add只能添加一个元素

a.add(2)#update除了添加元素，也可以是列表，无线，字典等

a.update('a')

a.update(['b','c'])print(a) #结果：{1, 2, 'a', 'c', 'b'}

#移除元素，如果元素不存在，会出错

a.remove('c')#移除元素，如果元素不存在，不会出错

a.discard('c')print(a) #结果：{1, 2, 'b', 'a'}

b= {2,'a','c'}#取差集

s1 =a.difference(b)print(s1) #结果：{1, 'b'}

#取差集

s2 =b.difference(a)print(s2) #结果：{'c'}

#取交集

s3 =a.intersection(b)print(s3) #结果：{2, 'a'}

#取并集

s4 =a.union(b)print(s4) #结果：{1, 2, 'b', 'c', 'a'}

3、集合推导式

集合推导式的使用和列表推导式类似

set1 = {i * 2 for i in range(10) if i < 4}print(set1)#结果：{0, 2, 4, 6}