Python序列

一、什么是序列

序列指的是一块可存放多个值的连续内存空间,这些值按一定顺序排列,可通过每个值所在位置的编号(称为索引)访问。主要包括字符串列表元组集合字典,并且集合字典不支持索引、切片、相加和相乘操作。

  1. 序列索引:在序列中,每个元素对应的位置编号。
str = "hello"
1.从左往右,序列的索引由0开始,依次递增
first = str[0]    	## 结果为'h'

2.从右往左,序列索引由-1依次递减
last = str[-1]		## 结果为'o'
  1. 序列切片:是访问序列中元素的另一种方法,它可以访问一定范围内的元素,通过切片操作,可以生成一个新的序列。
语法格式:sname[start : end : step]
	sname:表示序列的名称;
	start:表示切片的开始索引位置(包括该位置),此参数也可以不指定,会默认为 0,也就是从序列的开头进行切片;
	end:表示切片的结束索引位置(不包括该位置),如果不指定,则默认为序列的长度;
	step:表示在切片过程中,隔几个存储位置(包含当前位置)取一次元素,如果省略设置 step 的值,则最后一个冒号就可以省略。
注意:
使用负数索引时,start 值依然是左边的索引,end 依然是右边的值
	
str = "hello world"
1.取索引区间为[0,3]之间(不包括索引3处的字符)的字符串
new_str = str[:3]    	## 结果为"hel",从0开始可以默认不写start参数
2.取索引区间为[3,7]之间(不包括索引7处的字符)的字符串
new_str = str[3:7]    	## 结果为"lo w"
3.取索引区间为[7,字符串结尾]之间的字符串
new_str = str[7:]    	## 结果为"orld",取到结尾可以默认不写end参数
4.隔 1 个字符取一个字符,区间是整个字符串
new_str = str[::2] 		## 结果为"hlowrd"
5.取整个字符串,此时 [] 中只需一个冒号即可
new_str = str[:] 		## 结果为"hello world"
6.使用负数索引来截取一个新的字符串
new_str = str[-6:-1] 		## 结果为"lo worl"
  1. 序列相关的内置函数
    (1)len():计算序列的长度;
    (2)max():找出序列中的最大元素;
    (3)min():找出序列中的最小元素;
    (4)list():将序列转换为列表;
    (5)str():将序列转换为字符串;
    (6)sum():计算元素和;
    (7)sorted():对元素进行排序;
    (8)reversed():反向序列中的元素;
    (9)enumerate():将序列组合为一个索引序列,多用在 for 循环中;

二、列表(list)

列表中可以存储整数、小数、字符串、列表、元组等任何类型的数据,并且同一个列表中元素的类型也可以不同。

  1. 列表的创建
    列表的数据结构由一对中括号 [ ] 包裹,[ ] 里面相邻元素之间用逗号,分隔开。
1.使用 [ ] 直接创建列表
nums = [1, 2, 3, 4, 5, 6, 7]
strs = ["您好", "world"]
others = [1, 2, 3.5, "您好", "world", [4, "hello"], (6, 7, 8.5)]

2.使用 list() 函数创建列表
## 创建空列表
list = list()
## 将字符串转换成列表
list1 = list("hello")
## 将元组转换成列表
tuple1 = ('您好', 'world', 'hello')
list2 = list(tuple1)
## 将字典转换成列表
dict1 = {'a':1, 'b':2, 'c':3}
list3 = list(dict1)
## 将区间转换成列表
range1 = range(1, 10)
list4 = list(range1)
  1. 访问列表元素
list = list("hello world")
1.使用索引访问列表中的某个元素
char1 = list[1]
char2 = list[-1]

2.使用切片访问列表中的一组元素
print(list[1: 5])  #使用正数切片
print(list[0: 7: 2])  #指定步长
print(list[-6: -1])  #使用负数切片
  1. 添加列表元素
1.使用+运算符将多个列表连接起来
list1 = ["hello", "world"]
list2 = ["您好", "世界"]
print(list1 + list2)    ## 结果为:['hello', 'world', '您好', '世界']

2.append()方法添加元素,该方法会在列表的末尾追加元素,追加的可以是单个元素,也可以是列表、元组等
lst = ['a', 'b', 'c']
lst.append('d')
lst.append(['e', 'h'])
lst.append(('i', 'j'))
print(lst)    ## 结果为:['a', 'b', 'c', 'd', ['e', 'h'], ('i', 'j')]

3.extend()方法添加元素,添加到列表末尾的数据,它可以是单个元素,也可以是列表、元组等,
但不能是单个的数字。 append() 的不同之处在于:extend() 不会把列表或者元组视为一个整体,
而是把它们包含的元素逐个添加到列表中。
lst = ['a', 'b', 'c']
lst.extend('d')
lst.extend(['e', 'h'])
lst.extend(('i', 'j'))
print(lst)    ## 结果为:['a', 'b', 'c', 'd', 'e', 'h', 'i', 'j']

4.insert()方法插入元素,可以指定在列表中间某个位置插入元素,当插入列表或者元组时,
也会将它们视为一个整体插入到列表中。
lst = ['a', 'b', 'c']
lst.insert(1, 'd')
print(lst)    ## 结果为:['a', 'd', 'b', 'c']
lst.insert(2, ['e', 'h'])
print(lst)    ## 结果为:['a', 'd', ['e', 'h'], 'b', 'c']
lst.insert(3, ('i', 'j'))
print(lst)    ## 结果为:['a', 'd', ['e', 'h'], ('i', 'j'), 'b', 'c']
  1. 修改列表元素
1.修改单个元素非常简单,直接对元素赋值即可
nums = [1, 2, 3, 4, 5, 6, 7]
nums[2] = -2  
nums[-3] = -9
print(nums)    ## 结果为:[1, 2, -2, 4, -9, 6, 7]

2.通过切片语法给一组元素赋值,不指定步长时,新赋值的元素个数与原来的元素个数可以不同,
如果新赋值的元素个数少于原来的元素个数,则新的列表长度也会减小
nums = [1, 2, 3, 4, 5, 6, 7]
nums[1: 4] = [-2, -3, -4]   		## 个数相同时结果为:[1, -2, -3, -4, 5, 6, 7]
nums[1: 4] = [-2, -3]				## 个数小于时结果为:[1, -2, -3, 5, 6, 7]
nums[1: 4] = [-2, -3, -4, -5, -7]	## 个数大于时结果为:[1, -2, -3, -4, -5, -7, 5, 6, 7]

3.通过切片语法给一组元素赋值,指定步长时,新元素的个数必须与原有元素的个数相同,多了或者少了都会报错
nums = [1, 2, 3, 4, 5, 6, 7]
nums[1:6:2] = [-2, -3, -4]          ## 结果为:[1, -2, 3, -3, 5, -4, 7]

4.使用切片语法给一组元素赋值时,只包含单个元素的话,新元素也的是数组的形式,不能是单个值
nums[2:2] = [-2]
nums[2:2] = []
nums[2:2] = [-2, -3]
nums[2:2] = -2   ## 错误写法
  1. 查找列表元素
nums = [1, 2, 3, 4, 5, 6, 2, 8, 9]
1.从整个列表中检索值为2的索引,存在多个相同的值以最左边的结果为准
print(nums.index(2))   			## 结果为1
2.从索引区间4~7之间检索值为2的索引
print(nums.index(2, 4,7))    	## 结果为6
3.从索引位置4之后检索值为2的索引
print(nums.index(2, 4))   		## 结果为6
  1. 统计列表元素
nums = [1, 6, 3, 4, 3, 6, 2, 8, 6]
print(nums.count(6))  		## 结果为3

三、元组(tuple)

元组一旦被创建,它的元素就不可更改了,所以元组是不可变序列。元组可以存储整数、实数、字符串、列表、元组等任何类型的数据,并且在同一个元组中,元素的类型可以不同。

  1. 元组的创建
    元组的数据结构由一对小括号( )包裹,( )里面元素用逗号,分隔开。
1.常见的元组创建方式
nums = (1, 2, 3, 4, 5, 6, 7)
strs = ("您好", "world")
others = (1, 2, 3.5, "您好", "world", [4, "hello"], (6, 7, 8.5))

2.省略()创建元组,只要将各元素用逗号隔开,也会将其视为元组
strs = "您好", "world"

3.当创建的元组中只有一个字符串类型的元素时,该元素后面必须要加一个逗号,否则解释器会将它视为字符串
strs = ("您好",)

4.使用tuple()函数创建元组
## 创建空元组
tup = tuple()
## 将字符串转换成元组
tup = tuple("hello")
## 将列表转换成元组
list1 = ['您好', 'world', 'hello']
tup = tuple(list1 )
## 将字典转换成列表
dict1 = {'a':1, 'b':2, 'c':3}
tup = tuple(dict1)
## 将区间转换成列表
range1 = range(1, 10)
tup = tuple(range1)
  1. 访问元组
1.使用索引访问元组中的某个元素
tup = tuple("hello")
print(tup[3]) 
print(tup[-2])  

2.使用切片访问元组中的一组元素
print(tup[1: 3])  #使用正数切片
print(tup[0: 4: 2])  #指定步长
print(tup[-3: -1])  #使用负数切片
  1. 修改元组
1.元组是不可变序列,元组中的元素不能被修改,只能创建一个新的元组去替代旧的元组
tup = (1, 2, -3, 4)
tup = (a, d, c, d)
print(tup)

2.使用+拼接元组
tup1 = (1, 2, -3, 4)
tup2 = (a, d, c, d)
print(tup1 + tup2)
  1. 删除元组
tup = (a, d, c, d)
del tup

四、字典(dict)

字典(dict)是一种无序的、可变的序列,它的元素以键值对(key-value)的形式存储,相当于 Java 或者 C++ 中的 Map 集合。字典的主要特征有以下几点:
(1)通过键(key)来读取元素,而不是通过索引。
(2)字典中的元素是无序的,而列表(list)和元组(tuple)都是有序的序列。
(3)字典中的键(key)可以是整数、字符串或者元组,只要保证唯一且不可变就行,不能是列表。
(4)字典的值(value)可以是 Python 支持的任意数据类型。
(5)整个字典是可变的,并且可以任意嵌套 。

  1. 字典的创建
    字典的数据结构是由一对{}包裹,{}中由多个键(key)和值(value)键值对组成,相邻键值对用,隔开,键和值之间使用冒号:分隔开。
1.使用字符串作为key创建字典
ages = {'xiaoming': 15, 'xiaohong': 18, 'xiaojiang': 20}

2.使用元组作为key创建字典
dict = {(1, 2, 3): '数字', ('a', 'b', 'c'): '英文', ('你好', '啊', '哈哈'): '汉字'}

3.使用数组作为key创建字典
dict1 = {1: '一', 2: '二', 3: '三'}

4.通过 fromkeys() 方法创建字典,通常用于初始化字典,设置 value 的默认值
name = ['xiaoming', 'xiaohong', 'xiaojiang']
ages = dict.fromkeys(name, 18)    ## 结果为:{'xiaoming': 18, 'xiaohong': 18, 'xiaojiang': 18}

5.通过 dict() 映射函数创建字典
# 创建一个空字典
dict1 = dict()

# key只能为字符串且不能带引号,value可以是任意值
dict1 = dict(name='xiaoming', age=18, 学科=('语文', '数学')) 
print(dict1)    ## 结果为:{'name': 'xiaoming', 'age': 18, '学科': ('语文', '数学')}

# 向 dict() 函数传入包含 2 个元素的列表或元组,其中第一个元素作为键,第二个元素作为值
#方式1
list = [('two',2), ('one',1), ('three',3)]
#方式2
list = [['two',2], ['one',1], ['three',3]]
print(dict(list))    ## 结果为:{'two': 2, 'one': 1, 'three': 3}
#方式3
tup = (('two',2), ('one',1), ('three',3))
#方式4
tup = (['two',2], ['one',1], ['three',3])
print(dict(tup)) 	## 结果为:{'two': 2, 'one': 1, 'three': 3}

# 通过应用 dict() 函数和 zip() 函数,可将前两个列表转换为对应的字典
keys = ['one', 'two', 'three'] 	#还可以是字符串或元组
values = [1, 2, 3] 	#还可以是字符串或元组
dict1 = dict( zip(keys, values) )
print(dict1)
  1. 字典的访问
dic = dict(name='xiaoming', age=18, 学科=('语文', '数学')) 
1.通过[key]获取字典对应的value,当key不存在时会报错
print(dic['name'])   	## 结果为:xiaoming

2.通过get() 方法来获取字典对应的value,当key不存在时空值 None,也可以手动设置 get() 的第二个参数默认返回值
print(dic.get('age'))	## 结果为:xiaoming
print(dic.get('sex', 'key不存在'))	## 结果为:key不存在
  1. 字典的删除
dic = dict(name='xiaoming', age=18, 学科=('语文', '数学')) 
del dic
  1. 字典基本操作
dic = dict()
1.往字典中添加键值对
dic['name'] = 'xiaoming'
print(dic)   	## 结果为:{'name': 'xiaoming'}
dic[1] = 2		
print(dic)		## 结果为:{'name': 'xiaoming', 1: 2}
dic[(1,2,3)] = [4,5,6]
print(dic)		## 结果为:{'name': 'xiaoming', 1: 2, (1, 2, 3): [4, 5, 6]}

2.修改键值对
dic = {'数学': 95, '语文': 89, '英语': 90}
dic['数学'] = 100   ## key存在则会修改key对应的原value
dic['物理'] = 60	## key不存在则会新增一个键值对

3.删除键值对
dic = {'数学': 95, '语文': 89, '英语': 90}
del dic['数学']		## key存在则会删除对应的键值对
del dic['化学']		## key不存在则会报错

4.使用 in 或 not in 运算符判断key是否存在
dic = {'数学': 95, '语文': 89, '英语': 90}
print('数学' in dic) 		# True
print('物理' not in dic) 	# True

5.keys()、values() 和 items() 方法
dic = {'数学': 95, '语文': 89, '英语': 90}
print(dic.keys())				## dict_keys(['数学', '语文', '英语'])
print(dic.values())				## dict_values([95, 89, 90])
print(dic.items())				## dict_items([('数学', 95), ('语文', 89), ('英语', 90)])
# 使用 list() 函数,将上面返回的数据转换成列表
print(list(dic.keys()))			## ['数学', '语文', '英语']
print(list(dic.values()))		## [95, 89, 90]
print(list(dic.items()))		## [('数学', 95), ('语文', 89), ('英语', 90)]

6.copy() 方法返回一个字典的拷贝
# copy() 方法所遵循的拷贝原理,既有深拷贝,也有浅拷贝,copy() 方法只会对最表层的键值对进行深拷贝,
# 而对于某些列表类型的值来说,此方法对其做的是浅拷贝
a = {'one': 1, 'two': 2, 'three': [1,2,3]}
b = a.copy()
print(b)	## {'one': 1, 'two': 2, 'three': [1, 2, 3]}
## b字典中的'one': 1, 'two': 2是进行的深拷贝,会再申请一块内存用来存放这些数据,
## b字典中的'three': [1, 2, 3]则是进行的浅拷贝,不会再申请内存来存放[1, 2, 3]列表数据,而是和 a 共用同一块内存中的数据
## 如果再进行移除a字典中列表中的第一个元素,则b中的列表数据也会跟着移除
a['three'].remove(1)
print(a)		## {'one': 1, 'two': 2, 'three': [2, 3]}
print(b)		## {'one': 1, 'two': 2, 'three': [2, 3]}

7.update() 方法更新字典中的键值对,如果key已存在会覆盖掉原value,不存在则会添加到字典中
a = {'one': 1, 'two': 2, 'three': 3}
a.update({'one':5, 'four': 4})
print(a)		## {'one': 5, 'two': 2, 'three': 3, 'four': 4}

8.pop() 和 popitem() 方法,pop() 用来删除指定的键值对, popitem() 用来删除字典最右边的键值对
a = {'one': 1, 'two': 2, 'three': [1,2,3]}
a.pop('one')
print(a)		## {'two': 2, 'three': [1, 2, 3]}
a.popitem()
print(a)		## {'two': 2}

9.setdefault() 方法返回某个 key 对应的 value,如果该 key 存在,那么直接返回该 key 对应的实际 value,
如果该 key 不存在,那么先为该 key 设置默认的 defaultvalue,然后再返回该 key 对应的 defaultvalue
a = {'数学': 95, '语文': 89, '英语': 90}
print(a)		## {'数学': 95, '语文': 89, '英语': 90}
# key不存在,指定默认值
a.setdefault('物理', 94)
print(a)		## {'数学': 95, '语文': 89, '英语': 90, '物理': 94}
# key不存在,不指定默认值
a.setdefault('化学')		
print(a)		## {'数学': 95, '语文': 89, '英语': 90, '物理': 94, '化学': None}
# key不存在,定默认值
a.setdefault('生物', 88)
print(a)		## {'数学': 95, '语文': 89, '英语': 90, '物理': 94, '化学': None, '生物': 88}
# key存在,指定默认值
a.setdefault('数学', 100)
print(a)		## {'数学': 95, '语文': 89, '英语': 90, '物理': 94, '化学': None, '生物': 88}

五、集合(set)

集合用来保存不重复的元素,即集合中的元素都是唯一的,互不相同。同一集合中,只能存储不可变的数据类型,包括整形、浮点型、字符串、元组,无法存储列表、字典、集合这些可变的数据类型,否则 Python 解释器会抛出 TypeError 错误。

  1. 集合的创建
    集合的数据结构是由一对大括号 {}包裹, {}里面相邻元素之间用,隔开
1.使用 {} 创建集合
set1 = {1, 2.0, "hello", (1, 2, 3), 'a'}

2.set()函数创建集合
# 将字符串转化成集合,若存在相同的字符只会保存一个
set1 = set("hello")			## {'o', 'h', 'l', 'e'}
print(set1)
# 将列表转化成集合
set2 = set([1,2,3,4,5])		## {1, 2, 3, 4, 5}
print(set2 )
# 将元组转化成集合
set3 = set((1,2,3,4,5))
print(set3 )				## {1, 2, 3, 4, 5}

3.创建空集合
# 只能使用 set() 函数实现,因为直接使用一对 {},Python 解释器会将其视为一个空字典
set1 = set()
  1. 集合的访问
    由于集合中的元素是无序的,因此无法向列表那样使用下标访问元素。Python 中,访问集合元素最常用的方法是使用循环结构,将集合中的数据逐一读取出来。
set1 = {1, 2.0, "hello", (1, 2, 3), 'a'}
for a in set1:
    print(a,end=' ')
  1. 集合的删除
set1 = {1, 2.0, "hello", (1, 2, 3), 'a'}
del(set1)
  1. 集合基本操作
1.add()set 集合中添加元素
a = {1,2,3}
# 只能是数字、字符串、元组或者布尔类型(True 和 False)值,不能添加可变类型的数据
a.add((1,2))

2.remove() 从set集合中删除元素
a = {1,2,3}
a.remove(1)
# 如果被删除元素本就不包含在集合中,则此方法会抛出 KeyError 错误
a.remove(4)

3.set集合做交集、并集、差集运算
set1 = {1,2,3} 
set2 = {3,4,5}
# 交集运算符 & 取两集合公共的元素 
set1 & set2				## {3}

# 并集运算符 | 取两集合全部的元素
set1 | set2				## {1,2,3,4,5}

# 差集运算符 - 取一个集合中另一集合没有的元素
set1 - set2				## {1,2}
set2 - set1				## {4,5}

# 对称差集运算符 ^ 取两个集合中不公有的元素
set1 ^ set2				## {1,2,4,5}

  1. frozenset
    set 集合是可变序列,frozenset 集合是不可变序列。set 集合中所有能改变集合本身的方法,比如 remove()、discard()、add() 等,frozenset 都不支持;set 集合中不改变集合本身的方法,fronzenset 都支持。
1.创建frozenset
fset = frozenset(['hello', 'world'])

2.往set集合中添加frozenset集合
set = {1, 2, 3}
set.add(fset)
  • 1
    点赞
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值