Python基础系列三:序列

序列

序列是一种数据存储方式,用来存储一系列的数据。在内存中,序列是一块用来存放多个值的连续的内存空间。
Python中的序列主要有以下几种,字符串、列表、元组、字典、集合等。

1. 列表

列表是用于存储任意项目、任意类型的数据集合,列表大小可变,根据需要随时增加或缩小。

1.1 列表操作

方法要点描述
list.append(x)增加元素将元素x增加到列表list尾部
list.extend(alist)增加元素将alist增加到列表list尾部
list.insert(index,x)增加元素在列表指定位置index处插入元素x
list.remove(x)删除元素在列表中删除首次出现的元素x
list.pop([index])删除元素用于移除列表中index指定的元素(默认最后一个元素),并且返回该元素的值
list.clear()删除所有元素删除所有元素,保留列表对象
list.index(x)访问元素返回列表中第一个x的位置,如果不存在x则抛出异常
list.count(x)计数统计元素x在list中出现的次数
len(list)列表长度统计列表中元素个数
list.reverse()列表翻转列表元素翻转
list.sort()列表排序所有元素排序
list.copy()浅拷贝返回列表对象的浅拷贝

1.2 列表的创建

1.2.1 基本语法[]创建
a = [] #创建空列表
a = [10,20,'a','b']
1.2.2 list()创建

list()可以将任何可迭代的数据转换成列表

a = list() #空列表
a = list(range(10)) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
a = list("hello,world") #['h', 'e', 'l', 'l', 'o', ',', 'w', 'o', 'r', 'l', 'd']
1.2.3 range()创建整数列表

range()可以创建整数列表,语法格式为

range([start,] end [,step])

start:可选,表示其实数字,默认是0
end:必选,表示结尾数字
step:可选,表示步长,默认是1
Python3中range()返回的是一个range对象,不是列表,需要用list()将range对象转换成列表对象。

a = list(range(10)) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
1.2.4 推导式生成列表
a = [x*2 for x in range(5)] #[0, 2, 4, 6, 8]
a = [x for x in range(100) if x%9==0] #[0, 9, 18, 27, 36, 45, 54, 63, 72, 81, 90, 99]

1.3 列表元素的添加

当列表增加和删除元素时,列表会自动进行内存管理,这个过程涉及列表元素的大量移动,效率较低。一般只在列表的尾部添加元素或删除元素,大大提高列表的操作效率。

1.3.1 append()

在原列表尾部添加新的元素,速度最快

a = [10,20,'a','b']
a.append(30) #[10, 20, 'a', 'b', 30]
1.3.2 +运算符操作

并不是真正的尾部添加元素,而是创建新的列表对象。将原列表的元素和新列表的元素依次复制到一个新的列表对象中,会涉及大量的复制操作,不建议使用。

1.3.3 extend()方法

将目标列表的所有元素添加到本列表的尾部,属于原地操作,不创建新的列表对象。当涉及两表合并时,推荐使用该方法

1.3.4 insert插入元素

将元素插入到列表中任意指定位置,涉及元素移动,影响处理速度。同样发生元素移动的函数还有remove()、pop()、del(),它们在删除非尾部元素时也会发生元素移动操作。

1.3.5 乘法扩展

使用乘法扩展列表,生成一个新列表,新列表元素是原列表元素的多次重复。

a = [10,20]
a = a*3 #[10, 20, 10, 20, 10, 20]

1.4 列表元素的删除

1.4.1 del删除

删除列表指定位置的元素,涉及元素的移动。

a = [10,20,'a','b']
del a[2] #[10, 20, 'b']
1.4.2 pop()方法

pop()删除并返回指定位置的元素,默认列表最后一个元素

a = [10,20,'a','b']
b = a.pop() #b
c = a.pop(2) #a
1.4.3 remove()方法

删除首次出现的指定元素,若不存在该元素,抛出异常

a = [10,20,'a','b',10,20,'a','b']
a.remove(10)
1.4.4 列表元素访问
1.4.4.1 通过索引直接访问元素

可以通过索引直接访问元素,索引的区间在[0,列表长度-1],超出该范围,则会抛出异常。

1.4.4.2 index()获取指定元素在列表中首次出现的索引

index()获取指定元素在列表中首次出现的索引。语法是:index(value,[start,[end]]),其中start和end指定了搜索的范围。

a = [10,20,'a','b',10,20,'a','b']
a.index(10) #0
a.index(10,3) #4,从索引3开始搜索元素10
1.4.5 成员资格判断

判断列表中是否存在指定的元素,一般会使用 in 关键字。

a = [10,20,'a','b',10,20,'a','b']
10 in a # True
30 in a # True

1.5 列表切片操作

列表的切片操作使用slice函数,格式为slice[起始偏移量start:终止偏移量end[:步长step]]

对于a=[10,20,30]

操作说明示例结果
[:]提取整个列表a[:][10,20,30]
[start:]从start开始到结尾a[1:][20,30]
[:end]从开始到end-1a[:2][10,20]
[start:end]从start到end-1a[0:2][10,20]
[start🔚step]从start到end-1,步长stepa[1:3:2][20]

1.6 列表的排序

1.6.1 修改原列表,不建新列表的排序

sort():升序排序
sort(reverse=True):降序 排序
random.shuffle():打乱排序,需提前引入random包

import random
a = [10,20,50,30,40,0]
a.sort() #[0, 10, 20, 30, 40, 50]
a.sort(reverse=True) #[50, 40, 30, 20, 10, 0]
random.shuffle(a) #[40, 30, 10, 0, 20, 50]
1.6.2 返回新列表的排序

sorted():内置函数,升序排序,返回新列表
sorted(reverse=True):内置函数,降序排序,返回新列表

a = [10,20,50,30,40,0]
b = sorted(a) #[0, 10, 20, 30, 40, 50]
c = sorted(a,reverse=True) #[50, 40, 30, 20, 10, 0]
1.6.3 reversed()返回迭代器

内置函数reversed()支持逆序排序,与列表对象reverse()方法不同的是,reversed()不对原列表做任何修改,只返回逆序排序的迭代器对象。

1.6.4 max和min函数

max:返回列表最大值
min:返回列表最小值

a = [10,20,50,30,40,0]
b = max(a) #50
c = min(a) #0
1.6.5 sum函数

sum:返回列表各元素之和,只适用于数值型列表

a = [10,20,50,30,40,0]
b = sum(a) #150

2. 元组tuple

元组属于不可变序列,不能修改元组中的元素,因此元组没有增删改等操作。

2.1 元组的创建

2.1.1 通过()创建元组

元组可以通过()创建,其中小括号可以省略。元组只有一个元素时,后面必须加逗号。

a = (1,)
type(a) #tuple
a = (1)
type(a) #int
a = 1,
type(a) #tuple
a= 1
type(a) #int
a = (10,20,50,30,40,0)
a = 10,20,50,30,40,0
2.1.2 通过tuple()创建元组

tuple(可迭代对象):将其他可迭代对象转换成元组

tuple(range(3)) #(0, 1, 2)
tuple("abc") #('a', 'b', 'c')
tuple([2,3,4]) #(2, 3, 4)
2.1.2 通过tuple()创建元组

2.2 元组的访问和计数

元组的访问和计数和列表相同,参考1.4.4

2.3 元组的总结

元组的核心特点是:不可变序列
元组的访问和处理速度比列表快
与整数和字符串一样,元组可以作为字典的键,列表不能作为字典的键使用。因为整数、字符串以及元组都是不可变的,而列表可变。

3. 字典

字典是“键值对”的无序可变序列,字典中的每个元素都是一个“键值对”,包含:"键对象"和“值对象”。可以通过“键对象”实现快速获取、删除、更新对应的值对象。
键是任意的不可变数据,比如整数、浮点数、字符串、元组。列表、字典、集合这些可变对象,不能作为键,并且键不可重复。

3.1 字典的创建

3.1.1 通过{}和dict()创建字典
a = {'name':'lilei','age':18} #{'name': 'lilei', 'age': 18}
b = dict(name='lilei',age=18) #{'name': 'lilei', 'age': 18}
c = dict([('name','lilei'),('age',18)]) #{'name': 'lilei', 'age': 18}
c = {} #空的字典对象
c = dict(); #空的字典对象
3.1.2 通过zip()创建字典
k = ['name','age']
v = ['lilei','18']
d = dict(zip(k,v)) #{'name': 'lilei', 'age': '18'}
3.1.3 通过fromkeys创建值为空的字典
a = dict.fromkeys(['name','age','job']) #{'name': None, 'age': None, 'job': None}

3.2 字典元素的访问

3.2.1 通过[键]获得值

通过[键]获得值,若键不存在则抛出异常。

a = {'name':'lilei','age':18} #{'name': 'lilei', 'age': 18}
a['name']
3.2.2 通过get()获得值

通过get(键)获得值,推荐使用,若键不存在返回None

a = {'name':'lilei','age':18} #{'name': 'lilei', 'age': 18}
a['name']
3.2.3 列出所有的键值对

items():获取所有键值对,返回列表,每个元素为元组
keys():列出所有的键
values():列出所有的值

a = {'name':'lilei','age':18} #{'name': 'lilei', 'age': 18}
a.items() #dict_items([('name', 'lilei'), ('age', 18)])
a.keys() #dict_keys(['name', 'age'])
a.values() #dict_values(['lilei', 18])
3.2.4 len()键值对的个数
a = {'name':'lilei','age':18} #{'name': 'lilei', 'age': 18}
len(a) #2
3.2.5 检测字典中是否存在该键
a = {'name':'lilei','age':18} #{'name': 'lilei', 'age': 18}
'name' in a #True

3.3 元素添加、修改、删除

给字典新增**“键值对”**。如果键已经存在,则覆盖该键值对,否则新增“键值对”

a = {'name':'lilei','age':18} #{'name': 'lilei', 'age': 18}
a['job'] = 'teacher' #{'name': 'lilei', 'age': 18, 'job': 'teacher'}
len(a) #2

使用update()将新字典中所有键值对全部添加到旧字典上,如果key重复,则直接覆盖。

a = {'name':'lilei','age':18} #{'name': 'lilei', 'age': 18}
b = {'name':'lilei','age':25,'job':'teacher'} #{'name': 'lilei', 'age': 18}
a.update(b) #b覆盖a
len(a) #2

字典中元素的删除,可以使用del()方法,或者clear()删除所有键值对,pop()删除指定键值对,并返回对应的‘值对象’

a = {'name':'lilei','age':18} #{'name': 'lilei', 'age': 18}
del(a['name'])
b = a.pop('age') #18

3.4 序列解包

序列解包用于元组、列表、字典。

a = {'name':'lilei','age':25,'job':'teacher'} #{'name': 'lilei', 'age': 18}
name,age,job = a #默认对键进行操作
name,age,job = a.items() #对键值对进行操作
name,age,job = a.values() #对值进行操作

3.5 字典核心底层原理

字典对象的核心是散列表。散列表是一个稀疏数组(总是有空白元素的数组)

3.6 字典用法总结

  1. 键必须可散列
    1.1 数字、字符串、元组,都是可散列的
    1.2 自定义对象需要支持以下三点:
    支持hash()函数
    支持通过_eq()_方法检测相等性
    若a==b为真,则hash(a) == hash(b) 也为真
  2. 字典在内存中开销巨大,典型的空间换时间
  3. 键查询速度很快
  4. 往字典中添加新键可能导致扩容,导致散列表中键的次序变化。因此,不能够在访问字典的同时修改字典。

4. 集合

集合是无序可变,元素不能重复的对象。集合的底层是字典,集合的所有元素都是字典中的“键”,因此是不能重复且唯一的。

4.1 集合的创建和删除

可以使用{}创建集合对象,并使用add()方法添加元素

a = {3,5,7}
a.add(9) #{9, 3, 5, 7}

可以使用set()函数将列表、元组等可迭代对象转换成集合。如果原始数据存在重复数据,则只保留一个。

a = [3,5,7,3,9,'dd',7]
b = set(a) #{3, 5, 7, 9, 'dd'}

remove()删除指定元素,clear()清空整个集合

a = {3, 5, 7, 9, 'dd'}
b = a.remove(3)

4.2 集合相关操作

Python对集合也提供了并集、交集、差集等运算。

a = {3, 5, 7, 9, 'dd'}
b = {'dd',0,3,20,30}
a|b ##并集 {0, 3, 5, 7, 9, 'dd', 20, 30}
a.union(b) ##并集 {0, 3, 5, 7, 9, 'dd', 20, 30}
a&b #交集 {'dd', 3}
a.intersection(b) #交集 {'dd', 3}
a-b #差集 {9, 5, 7}
a.difference(b) #差集 {9, 5, 7}
  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值