序列的运用

Posted 2020-12-12 lc-snail

写在前面

在程序设计中，序列是一种常用的数据储存方式，几乎每一种程序设计语言都提供了类似的数据结构，例如C语言，java中的数组。在python中序列是最基本的序列结构，它是一块用于存放多个值的连续内存空间。python内置了列表，元组，集合，字典和字符串5种基本序列结构。

1.索引和切片

（1）索引

序列中每一个元素都有一个编号，这个编号就叫做索引。索引从0开始递增（0，1，2......n），也可以为负数，从左边开始递增（-1，-2，-3.....-n)，通过索引可以访问序列中的元素。

(2)切片

切片操作是访问序列中元素的一种方法，它可以访问一定范围内的元素，通过切片组成新的序列。

sname[start:end:step]
"""
sname : 被切片的序列
start : 开始的位置，包括在内
end : 结束的位置,不包括在内
step : 步长，默认为1
如果要复制整个序列，可以省略start和end保留冒号 sname[:]
"""

demo

str = ‘123456789‘
print(str[0:1])     #输出1
print(str[8:9])     #输出9
print(str[0:6])     #输出123456

2.序列的运算

（1）序列相加

可以把多个相同类型的序列通过加号相加，得到新的序列而原来序列不变。

list1 = [‘str1‘,‘str2‘] 
list2=[1,2,3]
list3 = list1 + list2  #列表和列表相加
print(list1)
print(list2)
print(list3)  
#输出
‘‘‘
[‘str1‘, ‘str2‘]
[1, 2, 3]
[‘str1‘, ‘str2‘, 1, 2, 3]
‘‘‘

(2)序列乘法

在python中一个序列乘于一个数字n，表示将原来序列的内容复制N次，并返回新的序列，原序列不变

list1 = [‘str1‘,‘str2‘]
print(list1*2)  #输出 [‘str1‘, ‘str2‘, ‘str1‘, ‘str2‘]
print(list1)  #输出 [‘str1‘, ‘str2‘]

(3)序列的计算

分别通过内置函数len(x),max(x),min(x)可以的得到序列长度，最大值，最小值。

3.列表

（1）概念

在形式上列表将所有元素放在一对中括号”[ ]“里，元素之间用逗号” ，“隔开，在内容上，可以将整数，实数，字符串，列表，元组等任何类型的内容放入列表中，可以放入不同类型的元素。

（2）列表的增删改查

创建列表

# 方法一 ———— 通过字面量中括号 “[  ]”来创建
#空列表
list2 = []  
#带有值的列表
list1 = [‘str1‘,11,22]

#方法二 ———— 利用内置函数list()把其他类型的序列转换为列表
list(data)

删除列表

del list_name

访问列表

list1 = [‘str1‘,‘str2‘,‘str3‘]
#直接输出  
print(list1)  # 输出[‘str1‘, ‘str2‘, ‘str3‘] 
#采用索引访问,某一个元素  
print(list1[0])    #输出 str1
#采用切片访问
print(list1[1:3])    #输出  [‘str2‘, ‘str3‘]

遍历列表

for循环遍历列表元素

list1 = [‘str1‘,‘str2‘,‘str3‘]
for i in list1:
    print(i)
"""
输出
str1
str2
str3
""" 

for 循环和 enumerate()，实现同时输出列表的索引值和元素内容

list1 = [‘str1‘,‘str2‘,‘str3‘]
for index, item  in enumerate(list1):
    print(index,item)
 """
输出
0 str1
1 str2
2 str3
 """

添加元素

list1 = [‘str1‘,‘str2‘,‘str3‘]
#list_name.append(),在原列表末尾添加，一次只能添加一个
list1.append(‘str4‘)
print(list1)
"""
[‘str1‘, ‘str2‘, ‘str3‘, ‘str4‘]
"""
#list1.extend(list2),把list2中的元素全部添加到list1中
list2 = [11,222,333]
list1.extend(list2)
print(list1)
"""
输出
[‘str1‘, ‘str2‘, ‘str3‘, ‘str4‘, 11, 222, 333]
"""

更改某个元素

#根据索引号进行更改
list1 = [‘str1‘,‘str2‘,‘str3‘]
list1[1] = ‘11111‘
print(list1)
‘‘‘
输出
[‘str1‘, ‘11111‘, ‘str3‘]
‘‘‘

删除元素

list1 = [‘str1‘,‘str2‘,‘str3‘]
#  del listname[x] 根据索引删除
del list1[-1] 
print(list1)
‘‘‘
输出
[‘str1‘, ‘str2‘]
‘‘‘
# listname.remove(x)根据值进行删除
list1.remove(‘str1‘)
print(list1)
‘‘‘
输出
[‘str2‘]
‘‘‘

（3)列表的统计和计算

获取指定元素出现的次数 —— listname.count(obj)

list1 = [‘str1‘,‘str1‘,‘str3‘]
print(list1.count(‘str1‘))   #输出2

获取元素指定元素首次出现的下标(索引）—— listname.index()

list1 = [‘str1‘,‘str1‘,‘str3‘]
print(list1.index(‘str3‘))   #输出2

计算列表中元素(数字型元素）的总和 —— sum(listname[, start])

#start：可选参数，与之相加的数，默认为0
list1 = [1,2,2]
print(sum(list1,1)) #输出6
print(sum(list1,3)) #输出8

（4）列表的排序

方法一

listname.sort(key=None,reverse=False)

注：

sort()是直接在原列表里面更改

key: 可选值，从比较的每个元素中提取一个用于比较的键，比如key=str.lower，表示在排序的时候不区分大小写。

reverse: 可选值，表示排序的方式，默认为升序（False），设置为True表示降序。

demo

num_list= [2,4,7,13,8,1]
print(‘原列表‘,num_list) 
num_list.sort()      
print(‘升序排列‘,num_list)
num_list.sort(reverse=True)
print(‘降序排列‘,num_list)
‘‘‘
输出
原列表 [2, 4, 7, 13, 8, 1]
升序排列 [1, 2, 4, 7, 8, 13]
降序排列 [13, 8, 7, 4, 2, 1]
‘‘‘

方法二

sorted(listname,key=None,reverse=False)

注：

sorted()生成新的列表，原来的列表不进行改变，其他用法和sort（）一样

（5）列表推导式

列表推导式可以快速生成一个列表，或者利用原有的列表生成满足需求的列表。

demo1——带for

list1 = [b for b in range(10)]
print(list1)
#等价于
# for循环
list2 = list()
for a in range(10):
    list2.append(a)
print(list2)
#同样输出
#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

demo2——带if

list1 = [d for d in range(6) if d % 2 != 0]
print(list1)
#等价于
list2=[]
for i in range(6):
    if i % 2 != 0:
        list2.append(i)
print(list2)     
#都输出
#[1, 3, 5]

demo3——嵌套for与元组

list1 = [(e, f * f) for e in range(3) for f in range(5, 15, 5)]
print(list1)
#等价于
list=[]
for e in range(3):
    for f in range(5,15,5):
        temp = (e,f*f)
        list.append(temp)
print(list)
#同样输出 [(0, 25), (0, 100), (1, 25), (1, 100), (2, 25), (2, 100)]

2.元组

（1）概念

元组是不可变的序列，因此也称为不可变列表，元素中所有的元素放在一对括号“（）”里面，中间用逗号隔开，在内容上元素可以是任何类型。

（2)元组的增删改查

创建

#直接用字面量‘（）’赋值创建
tuple1=(‘str1‘,‘str2‘,1)
print(tuple1)  # 输出 (‘str1‘, ‘str2‘, 1)

删除

del tuplename

访问和遍历

tuple1=(‘str1‘,‘str2‘,1)
#直接输出整个元组
print(tuple1)
#for遍历
for i in tuple1:
    print(i)

#输出
"""
str1
str2
1
"""
# for 和 enumerate()
for index,item in enumerate(tuple1):
    print(index,item)

#同时输出索引和值
‘‘‘
0 str1
1 str2
2 1
‘‘‘

改

元组是不可变的序列，不能直接更改或者添加单个元素

#把要添加的元素放在元组里，通过拼接元组的方式，进行添加
tuple1=(‘str1‘,‘str2‘)
tuple2 = (‘str3‘,) #元组里面只有一个元素时，后面要有逗号
print(tuple1+tuple2)
# 输出
# (‘str1‘, ‘str2‘, ‘str3‘)

3.字典

（1）概念

字典是可变的无序序列，形式上采用一对大括号“{ }”括起来，内容上采用键-值对的形式存放。键值之间采用冒号分隔开“ ："，不同键值对用逗号”，“分开。字典有时候也称关联数组或者散列表，通过键来访问值。

注意：

字典是可变的，并且可以任意嵌套

键是唯一的

键必须是不可变的，可以使用数字，字符串或者元组，但不能是列表。

值可以是任何数据类型，不具有唯一性

（2）字典的增删改

创建

#方法一 ———— 通过采用给定键值对的方式直接赋值给变量
dict1 = {‘name‘:‘lc-snail‘,‘age‘:‘18‘,1:‘一号‘}
print(dict1)
{‘name‘: ‘lc-snail‘, ‘age‘: ‘18‘, 1: ‘一号‘}

#方法二 ———— 通过映射函数zip()来创建
# 语法 dictname = dict(zip(list1,list2))
lis1=[1,2,3,4]
list2=[‘一号‘,‘二号‘,‘三号‘,‘四号‘]
dict2 = dict(zip(lis1,list2))
print(dict2)
#输出  {1: ‘一号‘, 2: ‘二号‘, 3: ‘三号‘, 4: ‘四号‘}

zip函数

用于将多个列表或者元组对应位置的元素组合为元组，并返回包含这些内容的zip对象，可以转成需要的序列类型。

lis1=[1,2,3,4]
list2=[‘一号‘,‘二号‘,‘三号‘,‘四号‘]
zip1 = zip(lis1,list2)
print(zip1)
#输出  <zip object at 0x000002A47C742440>
# 转成dict,list,tuple都可以
print(tuple(zip1))
#输出  ((1, ‘一号‘), (2, ‘二号‘), (3, ‘三号‘), (4, ‘四号‘))

访问

#通过键访问 
dict1 = {‘name‘:‘lc-snail‘,‘age‘:‘18‘,1:‘一号‘}
print(dict1[‘name‘]) #输出 lc-snail  

注

如果指定的键不存在则会报错

解决方法

#方法一  ———— 添加in 和 if
print(list1[3] if "瞎搞" in list1 else ‘我的字典里没有这玩意‘) #输出 我的字典里没有这玩意
    
#方法二 ———— 用dictname.get(key,[default])
print(list1.get(3,‘这啥玩意‘))     #输出 这啥玩意儿

遍历

#遍历键和值 ： dict_name.items()
dict1 = {‘name‘:‘lc-snail‘,‘age‘:‘18‘,1:‘一号‘}
for key,value in dict1.items():
    print(key,‘ : ‘,value)
""" 
输出
name  :  lc-snail
age  :  18
1  :  一号 
"""
#遍历值dict_name.values()
dict1 = {‘name‘:‘lc-snail‘,‘age‘:‘18‘,1:‘一号‘}
for value in dict1.values():
    print(value)
""" 
输出
lc-snail
18
一号
"""
#遍历键dict_name.keys()
dict1 = {‘name‘:‘lc-snail‘,‘age‘:‘18‘,1:‘一号‘}
for key in dict1.keys():
    print(key)
""" 
输出
name
age
1
"""

添加

通过赋值的方式添加新的键值对，键不能于原有键冲突，否则就会更改原来的值。

list1 = {1:‘一号‘,2:‘二号‘}
list1[3]="三号"
print(list1)
#输出 {1: ‘一号‘, 2: ‘二号‘, 3: ‘三号‘}

删除

del listname[key]

4.集合

（1）概述

集合分为可变集合和不可变集合。在形式上，集合用一对 ”{ }“来括起来，内容上可以是数字，字符串，元组但不支持，列表和字典。

特点

集合是无序的序列结构，每次输出都有可能不同

集合中每个元素都是唯一的

（2)集合增删改查

创建

#通过直接赋值的方式创建集合
set1 = {1,2,‘str1‘,(‘li‘,2)}
print(set1)  # 输出 {1, 2, ‘str1‘, (‘li‘, 2)}

#通过set()函数，将其他可迭代的对象，转换为集合
set2 = set([1,2,3])
print(set2)
# 输出 {1, 2, 3}

添加

setname.add(element)
#element：只能是字符串，数字以及布尔型的等不可以迭代的对象。

删除

del setname   #删除整个集合
set.pop()和set.remove() #删除单个元素
set.clear() #清除整个集合，使之成为空集合

（3）集合的运算

t = (1,2,3)
s =(3,4,5)
# t 和 s的并集
b = list(set(t)|set(s))          
 # t 和 s的交集
c = list(set(t)&set(s))   
print(b)  # 输出[1, 2, 3, 4, 5]
print(c)     #输出[3]