提供了编程的基础技术教程

zl程序教程

您现在的位置是：首页 >  后端

当前栏目

预备小菜：Python入门之数据结构

Python入门数据结构 预备 小菜
2023-06-13 09:17:15 时间

如果把程序员比喻成厨师的话，那么数据结构就是初始最常用的工具，那就是锅碗瓢盆。这些也叫容器，因为能存放东西，不管是放切好的菜，还是煮开的水。

同样在代码的世界中，也需要一些容器来存放数据或者信息，供后续加工使用，那么不同的容器有不同的特点，在对应不同的场景中存放数据使用。

Python中有四个内置数据结构（Built-in Data Structure）:分别是列表list、元组tuple、字典dict、集合set，它们也是一个容器，里面存放数据。下面我们来认识下这四个数据结构各自的特点。

列表List

特点：

  1. 列表使用“[ ]”来表示，里面可以储存任意对象。
  2. 列表中的元素是可变的、可重复的，可以对每个元素修改、删除，也可以新增元素
  3. 列表是有序的，可以通过索引访问每个元素

常用操作：

1．创建列表

列表定义

myList = ['a', 'b', 'c']print(myList)['a', 'b', 'c']

2. 新增元素

新增元素,默认是在列表尾添加

myList.append("d")print(myList)['a', 'b', 'c', 'd']

在指定位置添加元素，下标从0开始计

myList.insert(2, "e")print(myList)['a', 'b', 'e', 'c', 'd']

append方法是在末尾添加元素，insert是在指定位置添加元素。insert需要两个参数，如果只是传一个参数，并不是在末尾添加元素，而是报错TypeError: insert expected 2 arguments, got 1 。如果添加多个元素怎么处理？或者说如何合并两个列表。

两个list合并

方法1：使用extend（）方法

 myList=['a', 'b', 'c'] 
 myList2=[1,2]
 myList.extend(myList2) 
 print(myList)['a', 'b', 'c', 1, 2]

方法2:直接使用“+”，将两个list合并

myList = myList + myList3print(myList)['a', 'b', 'c', 1, 2, 3, 4]

如果使用append添加一个list会完成两个list的合并？

myList4 = ["A", "B"]myList.append(myList4)print(myList)['a', 'b', 'c', 1, 2, 3, 4, ['A', 'B']]

所以append的参数如果是一个list，那么它会将list作为一个对象进行添加，而不对list内的元素进行合并，这也正印证了在Python中一切皆对象。而且也可以看出来list里面啥都可以装，并不是限制对象类型，字符串、整数甚至list对象都可以存。

3.修改元素

修改指定位置的元素

myList=['a', 'b', 'c', 'd']myList[2] = "B"print(myList)['a', 'B', 'c', 'd']

4.删除元素

删除尾部元素

myList.pop()
print(myList)['a', 'B', 'c']

删除指定位置（下标）元素

myList.pop(2)print(myList)['a', 'B']

删除列表中某个元素

myList.remove("B")print(myList)['a']

5.遍历列表

for循环 遍历列表

myList=['a', 'b', 'c']for i in myList:print(i)#运行结果：abc

遍历列表是在数据处理中使用频率很高的场景，当然并不仅仅只有for循环，使用while循环也可以完成。

while循环 遍历列表

myList = ['a', 'b', 'c']
count = 0
while count < len(myList):
print(myList[count])
count = count + 1
#运行结果：
a
b
c

其实上述while循环本质上也是在使用下标来访问每一个元素，在简洁性不如for循环直接。除此之外还可以使用Python内置函数iter()来生成一个迭代器，遍历list。

iter（）遍历列表

myList=['a', 'b', 'c']for val in iter(myList):       print(val)

元组Tuple

特点：

  1. 元组使用“( )”来表示，里面可以储存任意对象
  2. 元组中的元素是不可变的、可重复的
  3. 元组是有序的，可以通过索引访问每个元素

简单理解元组就是一个固定的列表，没有列表的增加删除修改的方法，只能查询。那元组存在的目的是什么呢？因为元组不可变，所以代码更安全。这就是跟Java中的final关键词修饰的常量是一个效果的。

问题：如果Tuple里的元素包含list，那么list是可以修改的吗？

修改Tuple中的list的元素

myTuple = ('a', 'b', ['A', 'B'])
print(myTuple)
myTuple[2][0] = "a"
myTuple[2].append("c")
print(myTuple)

运行结果：

('a', 'b', ['A', 'B'])

('a', 'b', ['a', 'B', 'c'])

可见Tuple中的list是可以修改的，还可以增加。那为什么还说Tuple是不可变的，注意这里变化的是什么，是list，而不是Tuple本身。

集合Set

特点：

  1. 集合使用“｛｝”来表示，里面可以储存任意对象
  2. 集合中的元素是可变的、不可重复的，可以增加删除修改
  3. 元组是无序的

Python中的set跟Java中的set特点类似，都是不可重复，或者是存入的重复对象只是保留一个，也正是因为这一个特点，在数据分析中，经常用set来做数据去重。

Python中的集合跟中学数学的集合功能比较像，支持union(联合), intersection(交), difference(差)和sysmmetric difference (对称差集)等数学运算。

常用操作：

1．创建集合

创建set

mySet=set('abcdabcd')print(mySet){'c', 'a', 'b', 'd'}

再次运行结果：

{'c', 'd', 'b', 'a'}

如果这一段代码运行两次，反而打印的结果并不一样，这就是因为元组是无序的。在Python中字典类型数据也是用“｛｝”来表示，但是内容不一样，后面会有详细讲解。不过如果仅仅一个空的｛｝表示的是一个空字典，而不是空集合。创建空集合只能使用set()函数，不传参数得到的结果就是一个空集合。

2. 集合运算

创建两个set

a = {'a', 'b', 'c'}b = {'a', 'b', 'd'}

a和b的并集：

print(a&b)  #也可以用 a.union(b){'a', 'b'}

a和b的交集：

print(a|b) #也可以用 a.intersection(b){'b', 'c', 'a', 'd'}

a和b的差集：

print(a-b)  #也可以用 a.difference(b)
{'c'}

b和a的差集：

print(b-a)
{'d'}

a和b的对称差集（在a或者b中出现，但不能同时出现）

print(a ^b)  #也可以用 a.symmetric_difference(b){'c', 'd'}

3. 添加元素

#创建setmySet = {'a', 'b', 'c'}# 添加一个元素mySet.update("ad")print(mySet){'b', 'a', 'd', 'c'}mySet.add("ad")print(mySet){'d', 'a', 'ad', 'b', 'c'}

从上面可以看出集合中有两个函数,add()和update(),两者的区别在于，add()做新增时候，参数作为一个整体字符串添加，update()新增的时候，字符串会拆分成当个字符添加到set中，也就是update会进行将对象迭代添加，这样update()的参数中必须是一个可迭代的对象。

注意：集合中可以添加str、num、tuple对象，不能添加list、dict、set对象。update()的参数可以是str或tuple，不能是num，因为它不可迭代。

4.删除元素

remove方法删除一个元素

mySet = {'a', 'b', 'c'}
mySet. remove ("b")
print(mySet){'c', 'a'}
mySet.remove("b")
print(mySet)

报错：KeyError: 'b'

discard方法删除一个元素

mySet = {'a', 'b', 'c'}mySet.discard("b")print(mySet){'c', 'a'}mySet.discard("b")print(mySet){'c', 'a'}

从上面代码中可以看出，remove()和discard()的区别是，remove()删除一个不存在的key会报KeyError的错误，discard()如果删除一个set中本不存在的key时，将不进行任何操作。

4. 元素去重

由于集合中的元素不能重复的特性，经常用来给list去重，然后得到的集合还可以通过list()函数转回list对象，得到新的list是原来list去重数据。

myList = ['a', 'b', 'b', 'c', 'c']mySet = set(myList)print(mySet){'a', 'b', 'c'}#list转set再转回listmyNewList = list(mySet)

5. 元素是否(不)包含在Set中

mySet = {'a', 'b', 'c'}
#判断一个元素是否在集合中
if 'a' in mySet:
  print(True)
else:
  print(False)
# 判断一个元素是否不在集合中
if 'd' not in mySet:
  print(True)
else:    
  print(False)
#程序运行结果：
True
True

字典Dict

字典（Dictionary）是一种以键值对作为元素的存储的容器，跟Java语言中的map集合大同小异，是使用频率很高的数据结构之一。

特点：

1. 字典是一个可变的容器，且可存储任意类型对象。

2. 整个字典包括在 “{ }”中。

3. 字典的每个键值 key：value 对，中间用冒号 : 分割，每个键值对之间用逗号 , 分割

4. 值可以取任何数据类型，但键必须是不可变的对象，如字符串，数字或元组。

5. 键（key）唯一，可以为空（None）。值可以空，可以为任意对象，可重复。

常用操作：

1.创建字典

#创建dict
myDict = { None: 1, "a": 2, "b": 3}
print(myDict)
{None: 1, 'a': 2, 'b': 3}
#参数赋值创建
myDict =dict(a=1,b=2)
print(myDict)
{ 'a': 1, 'b': 2}

2.添加元素

myDict = { "a": 1, "b": 2}
myDict['c'] = 3 #根据键值对添加{'a': 1, 'b': 2, 'c': 3} 
temp = {'d': 4, 'e': 5}
myDict.update(temp) #使用update方法添加
print(myDict)
{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

3.删除元素

myDict = {'a': 1, 'b': 2, 'c': 3}del myDict['a']  #使用del()函数删除print(myDict){'b': 2, 'c': 3}myDict.pop('b') #使用pop()函数删除2print(myDict){'c': 3}myDict.clear() #使用clear ()函数清空字典print(myDict) #得到空字典{}

pop函数是功能是取出key返回值，并将其键值对删除，所以pop()函数是有返回值的。

4.查询字典

myDict = {'a': 1, 'b': 2, 'c': 3}
print(myDict['a']) #通过“键值对”访问
1
print(myDict.get('d', '没有d')) #使用get()访问
没有d

字典get()函数为dict.get(key,[default])，default为可选项，用于指定当‘键’不存在时 返回一个默认值，如果省略，默认返回None。如果直接使用myDict[‘a’]取值方式会报KeyError:的异常。

5.遍历字典

myDict = {'a': 1, 'b': 2, 'c': 3}#使用字典对象的dict.items()方法获取字典的各个元素的元祖列表for item in myDict.items():       print(item)#代码结果：('a', 1)('b', 2)('c', 3)# key, value可以分别获取每个键值对for key, value in myDict.items():       print(key, value)#代码结果：a 1b 2c 3#keys()和values()方法获取字典的键和值列表for key in myDict.keys ():       print(key)#代码结果：abcfor value in myDict.values():       print(value)#代码结果：123

字典的遍历是很常用的一个场景，尤其是在数据采集的时候，经常会将字符串数据转成字典对象来进行迭代或者取值。

相关文章