python常用数据结构例题 python基础数据结构

数据结构

• 简介
• 一、列表

• 1.列表的增删改查
• 2.列表基本操作

• 列表嵌套

• 3.列表函数&方法

• 列表中的内置函数:
• 列表中的内置方法:

• 二、元组

• 1.元组增删改查
• 2.元组截取与拼接
• 3.元组内置函数

• 三、字典

• 1.字典增删改查
• 2.字典内置函数
• 3.字典内置方法

• 四、集合

• 1.集合增删改查
• 2.集合间运算
• 3.集合内置方法

简介

Python3基本的数据结构有列表（list）、元组（tuple）、字典（dictionary）、集合（set）四种结构如下：

list = ['Google', 1, 2000, (1, 'xiaobai')]
tuple = ('a', 'Python', 1, 5.3)
dict = {"name": "xiaoming", "age": 16, "class":"python"}
set = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}

一、列表

列表是 Python 中最基本的数据结构。

列表中的每个值都有对应的位置值，称之为索引，第一个索引是 0，第二个索引是 1，依此类推。

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

列表都可以进行的操作包括索引，切片，加，乘，检查成员。

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

列表是最常用的 Python 数据类型，它可以作为一个方括号内的逗号分隔值出现。

列表的数据项不需要具有相同的类型

list = ['Google', 1, 2000, (1, 'xiaobai')]

列表索引从0开始。列表可以进行索引，切片，加，乘，检查成员等操作，此外，列表是支持添加，更新，删除等修改操作的。

1.列表的增删改查

#       0  1   2     3       4     5
list = [1, 2, False, True, 'one', 'two']
#      -6 -5    -4    -3     -2    -1

print("list[0]:", list[0])    # 下标索引访问
list[2] = 200
print('修改后第三个元素为：', list[2])  # 列表修改
del list[4]         # 删除列表元素
print('删除第三个元素：', list)

输出结果为：
list[0] 1
修改后第三个元素为： 200
删除第三个元素： [1, 2, 200, True, 'two']

除了关键字del，列表的删除操作还可以使用列表方法中的list.pop([index=-1])、
list.remove(obj)
列表的增加操作在列表方法中的list.append(obj)

2.列表基本操作

nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
nums_add = [1, 2, 'e']
# 截取
print(nums[2:6])    # [30, 40, 50, 60]
# 使用负数索引值截取：
print(nums[1:-3])   # [20, 30, 40, 50, 60]
# 截取第一位到最后
print(nums[1:])     # [20, 30, 40, 50, 60, 70, 80, 90]
# 拼接
print(nums + nums_add)    # [10, 20, 30, 40, 50, 60, 70, 80, 90, 1, 2, 'e']
print(nums_add * 3)      # [1, 2, 'e', 1, 2, 'e', 1, 2, 'e']
# 元素是否存在于列表中
print(2 in nums_add)   # True
# 迭代
for x in nums:
    print(x, end='')    # 102030405060708090
# 长度
print(len(list))

列表嵌套

a = ['a', 'b', 'c']
b = [1, 'm']
c = [a, b]
print(c)      # [['a', 'b', 'c'], [1, 'm']]

3.列表函数&方法

列表中的内置函数:

函数	作用
len(list)	列表元素个数
max(list)	返回列表元素最大值
min(list)	返回列表元素最小值
list(seq)	将元组转换为列表

列表中的内置方法:

list.append(obj)         #在列表末尾添加新的对象
list.count(obj)          #统计某个元素在列表中出现的次数
list.extend(seq)         #在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.index(obj)          #从列表中找出某个值第一个匹配项的索引位置
list.insert(index, obj)  #将对象插入列表
list.pop([index=-1])     #移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.remove(obj)         #移除列表中某个值的第一个匹配项
list.reverse()           #反向列表中元素
list.sort()              #对原列表进行排序
list.clear()             #清空列表
list.copy()              #复制列表

二、元组

Python 的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号 ( )，列表使用方括号 [ ]。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

Python 的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号 ( )，列表使用方括号 [ ]。
tup1 = ('Google', 'Runoob', 1997, 2000)  #元组
tup2 = "a", "b", "c", "d";               #不需要括号也可以
tup3 = ();                               #空元组
# 元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用：
tup4 = (50)                              #<class 'int'>
tup5 = (50,)

1.元组增删改查

元组不能修改和增加，元组的访问与列表相同，元组同样可以使用del关键字，但是作用是删除整个元组。

tup = ('Google', 'Runoob', 1997, 2000) 
del tup;
print ("删除后的元组 tup : ")
print (tup)

打印结果：
删除后的元组 tup :
Traceback (most recent call last):
File “test.py”, line 8, in
print (tup)
NameError: name ‘tup’ is not defined

2.元组截取与拼接

与列表相同

3.元组内置函数

len(list) #元组元素个数
max(list) #返回元组元素最大值
min(list) #返回元组元素最小值
list(seq) #将列表转换为元组

三、字典

字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ，如下：

{key1 ：value， key2：value}

字典中键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
一个简单的字典实例：

dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

1.字典增删改查

dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
print ("dict['Name']: ", dict['Name'])      #需要按照键值访问
print ("dict['Alice']: ", dict['Alice'])    #如果用字典里没有的键访问数据，会出现KeyError: 'Alice'
dict['Age'] = 8                             # 修改键Age的值
del dict['Name']                            # 删除键 'Name'
dict.clear()                                # 清空字典
del dict                                    # 删除字典

2.字典内置函数

len(dict)      #计算字典元素个数，即键的总数
str(dict)      #输出字典，以可打印的字符串表示
type(variable) #返回输入的变量类型，如果变量是字典就返回字典类型

3.字典内置方法

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()                                #随机返回并删除字典中的最后一对键和值。

四、集合

集合（set）是一个无序的不重复元素序列，集合是可变类型。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

>>>basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # 集合的不重复性
{'orange', 'banana', 'pear', 'apple'}

1.集合增删改查

合增删改查

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(basket[1])             		# 错误，集合是无序的
'orange' in basket

由于集合的无序性，没有修改操作，集合的添加、删除操作使用集合内置方法完成。

2.集合间运算

>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b                              # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b                              # 不同时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}

3.集合内置方法

set.add()	                      #为集合添加元素
set.clear()	                      #移除集合中的所有元素
set.copy()	                      #拷贝一个集合
set.difference()	              #返回多个集合的差集
set.difference_update()	          #移除集合中的元素，该元素在指定的集合也存在。
set.discard()	                  #删除集合中指定的元素
set.intersection()	              #返回集合的交集
set.intersection_update()	      #返回集合的交集。
set.isdisjoint()	              #判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
set.issubset()	                  #判断指定集合是否为该方法参数集合的子集。
set.issuperset()	              #判断该方法的参数集合是否为指定集合的子集
set.pop()	                      #随机移除元素
set.remove()	                  #移除指定元素
set.symmetric_difference()	      #返回两个集合中不重复的元素集合。
set.symmetric_difference_update() #移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
set.union()	                      #返回两个集合的并集
set.update()	                  #给集合添加元素