简单学python《八》——数据结构

很多时候在程序中我们需要处理一个数据集，里面包含很多数据，如果使用基本类型进行一个个储存，非常不方便，为了解决基本类型在存储数据量上的不足，各编程语言都有实现数据结构来存储数据集。Python中主要有列表list，元组tuple，字典dict等数据结构。

 

1) 列表

 

列表是一种有序的可改变集合，通过偏移（位置索引）来获取元素，支持嵌套，并可以储存不同类型的数据。创建列表需注意：

Ø 每个元素之间用逗号隔开；

Ø 各个元素应包括在方括号中；

Ø 一个列表中可以存放不同数据类型的元素；

 

l 创建列表

citys = ['shanghai', 'beijing', 'hangzhou'] # 创建列表，每个元素都是字符串

info = ['xiaoming', 30, 178, 'beijing'] # 包含多种数据

infos = [['xiaohei', 28], ['xiaohong', 26]] # 列表的元素是列表

ints = list(range(10))

'''

range(0, 10, 1)生成从0-10步长为1的整数，不包含10

第一个和第三个参数可以不写，默认从0开始，步长为1

即生成0，1，2，3，4，5，6，7，8，9

list将其转换成列表

'''

print(citys)

print(info)

print(infos)

print(ints)

 

l 获取元素

创建列表后就可以对其进行操作，首先是获取元素。列表元素的获取是通过元素所在位置进行索引，并支持切片操作获取多个元素。

 

sh  = citys[0] # 获取城市列表的第0个元素

hz = citys[2] # 获取城市列表的第2个元素

xiaohei = infos[0] # 获取xiaohei的信息

xiaohei_age = infos[0][1] # 获取嵌套列表内列表元素的数据

range_1_3 = ints[1:4] # 获取数字列表的第1到第3个数字，后面数字位置是不包含的

odd = ints[1:10:2] # 获取1-10数字之间的奇数

even = ints[-2:0:-2] # 获取偶数

all_int = ints[:] # 取出所有元素

print(sh)

print(hz)

print(xiaohei)

print(xiaohei_age)

print(range_1_3)

print(odd)

print(even)

print(all_int)

 

注意：位置索引需要写在方括号中，索引从0开始，并且不能超过列表的长度；获取一组数据使用切片操作，需要用冒号分割的两个或三个数字，三个数字时第三个是设置步长，切片操作不包含第二个索引位置的数字，并支持负数索引，倒数第一个数字的索引为-1，以此类推，切片操作的索引可以越界，表示取到最大。

 

l 列表修改

 

computer = ['cpu', 'gpu', 'screen', 'disk', 'keyboard']

computer[4] = 'mouse' # 修改'keyboard'为'mouse'

print(computer) # ['cpu', 'gpu', 'screen', 'disk', 'mouse']

computer[2:] = ['other'] # 修改索引2后的元素为'other'

print(computer) # ['cpu', 'gpu', 'other']

 

l 列表运算

 

列表支持的运算与字符串一样，只支持连接操作包括加列表与乘整数

ops = [3,2,1,4]

print(ops + [3,4]) # [3, 2, 1, 4, 3, 4]

print(ops * 2) # [3, 2, 1, 4, 3, 2, 1, 4]

 

l 列表操作

列表操作是指每个列表可调用的函数，这些函数可以对列表进行添加元素，删除元素，获取元素的索引等。

 

append : 附加一个元素在列表末尾

citys = ['上海', '杭州']

citys.append('北京')

print(citys) # ['上海', '杭州', '北京']

citys.append(['广州', '深圳'])

print(citys) # ['上海', '杭州', '北京', ['广州', '深圳']]

 

copy : 复制列表的元素

xueke = ['英语', '数学', '语文']

xueke_copy = xueke.copy()

print(xueke_copy) # ['英语', '数学', '语文']

 

count : 获取指定元素的计数

numbers = [1,2,3,4,2,1,2,3]

print(numbers.count(2)) # 3，查看元素2有多少个

print(numbers.count(3)) # 2 查看元素3有多少个

 

extend : 扩展列表

langs = ['中文', '英文', '德语']

langs.extend('日语')

print(langs) # ['中文', '英文', '德语', '日', '语']

langs.extend(['汉语', False])

print(langs) # ['中文', '英文', '德语', '日', '语', '汉语', False]

 

index : 获取指定元素的索引

 

chats = ['微信', 'QQ', '旺旺', '飞信', 'QQ']

print(chats.index('旺旺')) # 2

print(chats.index('QQ')) # 1, 若存在多个元素，则返回第一个元素的索引

 

insert : 在指定索引位置插入一个元素

 

list_insert = [1,2,3,4]

list_insert.insert(0, 0) # 在索引0处插入数字0

print(list_insert) # [0, 1, 2, 3, 4]

list_insert.insert(5, True) # 在索引5处插入True

print(list_insert) # [0, 1, 2, 3, 4, True]

 

pop : 删除末尾元素或指定索引删除元素

 

list_pop = list(range(6)) #

print(list_pop) # [0, 1, 2, 3, 4, 5]

print(list_pop.pop()) # 5, pop默认从末尾进行删除，并返回删除的元素

print(list_pop) # [0, 1, 2, 3, 4]

print(list_pop.pop(0)) # 0, 若传入数字,则删除该索引的元素并返回

print(list_pop) # [1, 2, 3, 4]

 

remove : 删除指定元素

 

list_remove = ['a', 'b', 'c', 'd', 'e']

list_remove.remove('c') # 删除元素'c'

print(list_remove) # ['a', 'b', 'd', 'e']

 

reverse : 反转元素

 

list_reverse = [1,2,3,4]

list_reverse.reverse() # 反转元素

print(list_reverse) # [4, 3, 2, 1]

 

sort : 对元素进行排序

 

list_sort = [13,4,3,8,1]

list_sort.sort() # 对元素排序

print(list_sort) # [1, 3, 4, 8, 13]

 

clear : 清空列表元素

 

list_clear = [1, 'a', True]

list_clear.clear() # 清空

print(list_clear) # [] 得到空列表

 

l 其他操作

 

print(len([1,2,3,4])) # 4 获取列表元素个数

print(max([3,4,1,7])) # 7 获取列表元素最大值

print(min(['n', 'f', 'g', 'l'])) # 'f' 获取列表元素最小值

print(list('hello')) # ['h', 'e', 'l', 'l', 'o'] 将字符串转换为列表

 

2) 元组

 

元组是一种不可变的有序集合，创建与列表相似，只需将方括号改为小括号，除了列表中可修改的部分，操作与列表基本相同。

 

l 创建元组

tuple_create_int = (1, 2, 3, 4) # 创建一个元组

tuple_create_tuple = (0, (1, 2, 3), 4) # 创建嵌套元组

print(tuple_create_int) # (1, 2, 3, 4)

print(tuple_create_tuple) # (0, (1, 2, 3), 4)

 

l 获取元组元素

该操作与列表相同，通过索引和切片都可以获取，不再赘述。

 

l 元组操作

因为元组不可修改，与列表比较少了很多操作，比如append、insert 等。

count : 获取指定元素的数目

Index : 获取指定元素的第一个索引

 

l 其他操作

 

print(len((1,2,3,4))) # 4 获取元组元素个数

print(max((3,4,1,7))) # 7 获取元组元素最大值

print(min(('n', 'f', 'g', 'l'))) # 'f' 获取元组元素最小值

print(tuple('hello')) # ('h', 'e', 'l', 'l', 'o') 将字符串转换为元组

print(tuple([1,2,3,4])) # (1, 2, 3, 4) 将列表转换为元组

print(list((1,2,3,4))) # [1, 2, 3, 4] 将元组转换为列表

 

 

3) 字典

 

列表和元组两种数据结构都是使用索引获取对应元素，而字典实现了便于使用的键作为值的索引，所以其操作更加直观和方便，这种类型不但在各种程序里广泛使用，它也是 Python 语言的基石，模块的命名空间，实例的属性和函数的关键字参数中都可以看到字典的身影。正是因为字典至关重要， Python 对它的实现做了高度优化，所以不用担心其性能问题。

字典是Python语言中的映射类型，并且是可改变的，它是一个容器，能存储任意个数的Python对象，其中也可包括其他容器类型。

 

l 字典创建

字典使用大括号包括，键索引与值之间使用冒号分隔，各元素之间使用逗号分隔。键可以是我们所讲的基本类型和元组，但不允许重复，值可以存储任意数据。

 

people = {'name':'my name', 'age':30, 'height':178} # 定义字典

print(people) # {'name': 'my name', 'age': 30, 'height': 178}

person = {'xiaoming':{'age':28, 'height':176, 'city':'上海'}, 'xiaohei':{'age':30, 'height':174, 'city':'上海'}} # 嵌套字典

print(person) # {'xiaoming': {'age': 28, 'height': 176, 'city': '上海'}, 'xiaohei': {'age': 30, 'height': 174, 'city': '上海'}}

py = dict(name='Python', learn='simple') # 使用dict创建字典

print(py) # {'name': 'Python', 'learn': 'simple'}

 

l 获取元素

字典通过键获取值，字典是无序的，不支持使用所在第几个位置获取,并且键必须保证已经。

print(people['name']) # my name, 通过'name'键获取值

print(person['xiaoming']) # {'age': 28, 'height': 176, 'city': '上海'}，获取字典中的字典

print(person['xiaoming']['city']) # 上海, 获取嵌套字典内的数据

 

l 修改元素

通过键设置其值，即可修改，当见不存在时，添加新元素。

py['learn'] = 'complex' # 修改键是’learn‘的元素

py['type'] = 'big data' # 键'type'不存在，添加新元素

print(py) # {'name': 'Python', 'learn': 'complex', 'type': 'big data'}

 

l 字典操作

copy : 获取字典的拷贝

py_copy = py.copy()

print(py_copy) # {'name': 'Python', 'learn': 'complex', 'type': 'big data'}

 

get : 使用键获取元素，当键不存在时不会出错

print(person.get('xiaoming')) # 获取’xiaoming‘对应的值

print(person.get('xiaolan')) # 当键不存在时，返回None表示没有

print(person.get('xiaolan', {'age':27, 'height':168, 'city':'杭州'})) # 当键不存在时，第二个参数即为默认值

 

items : 返回一个(key, value)的序列

print(list(people.items())) # [('name', 'my name'), ('age', 30), ('height', 178)]

print(list(py.items())) # [('name', 'Python'), ('learn', 'complex'), ('type', 'big data')]

 

keys : 返回所有键组成的序列

print(list(people.keys())) # ['name', 'age', 'height']

print(list(person.keys())) # ['xiaoming', 'xiaohei']

 

pop : 指定键删除元素，并返回该元素

print(people.pop('name')) # 删除'name'对应的值

print(people) # {'age': 30, 'height': 178}

#print(people.pop('a')) # 删除不存在的键会报错

print(people.pop('a', 1)) # 当传入第二个参数时，删除不存在的键时不会报错，返回指定的值

 

popitem : 随机删除元素，并返回该元素

print(py) # {'name': 'Python', 'learn': 'complex', 'type': 'big data'}

print(py.popitem()) # ('type', 'big data') 随机删除

print(py) # {'name': 'Python', 'learn': 'complex'}

print(py.popitem()) # ('learn', 'complex') # 随机删除

print(py) # {'name': 'Python'}

 

update : 参数与创建字典时相同，更新或添加元素

print(py) # {'name': 'Python'}

py.update(a=1,b=2) # 当键值不存在时进行添加元素

print(py) # {'name': 'Python', 'a': 1, 'b': 2}

py.update({'a':'a', 'b':'b'}) # 当键值存在时进行更新元素

print(py) # {'name': 'Python', 'a': 'a', 'b': 'b'}

 

values : 获取所有值组成序列

print(py) # {'name': 'Python', 'a': 'a', 'b': 'b'}

print(list(py.values())) # ['Python', 'a', 'b']