Python从入门到项目实战————序列

系列文章目录

`

---

`

文章目录

• 系列文章目录
• 前言
• 一、初步认识序列
• • 一、列表
  • • • • • 列表基本定义
          • 索引的详细使用
          • 数据分片
          • 成员运算符
          • 列表操作函数
          • 列表相关操作的详细解释
  • 元组
  • • • • • 元组的乘法和加法运算
        • 序列统计函数
      • 字符串
      • • 字符串的分片操作
        • • 字符串拆分过程中出现乱码的原因
          • 简单的字符串操作认识
        • 字符串格式化
        • • 字符串操作函数
        • 字典
        • • 字典的基本使用
          • 字典的迭代输出
          • 字典操作函数
• 总结

---

前言

`前面学习了Python中的程序逻辑结构，在Pytho中又增加了序列的知识，现在，我们将学习Python中较为重要的知识序列，以及更加深化的讲解对字符串的处理。

---

一、初步认识序列

顾名思义，序列从字面意思就可以得知是一种有序的类容的集合，通过序列不仅可以实现多个数据的的保存，也可以采用相同的方式来访问序列中的数据，最为重要的是，序列可以利用切片的概念获取部分子序列的数据，在Python中，列表，元组，字典，字符串构成了序列的概念。

一、列表

列表（list）是一种常见的序列类型，Python中的列表除了可以保存多个数据外，还可以动态的实现对列表数据的修改。

列表基本定义

在Python中，列表的定义也是采用了赋值的方式，不过形式有点不同于以往变量的赋值。他用了一个[]号。
例如：

infors=["i like you","Python","Hello word"]
#infors就是一个列表，它有三个元素，分别是"i like you" ,"Python","Hello word"。
#如果我们要获取其中某一个元素，那么我们就用索引的方式来获取，和c语言中的数组极为相似。索引的范围为
#0~（列表长度-1）

下面我用一个实例来说明索引：

#关于列表索引的相关的知识点
infors=["I like ","Python ","c++ is better than this","But i think " ]    #定义了一个列表
#通过简单的索引达到对上面的话排序
item=infors[0]+infors[1]+infors[3]+infors[2]  #在c++和python中，字符串可以实现相加
print(item) #输出排序后的语句
#python中的索引和c语言中数组极为相似，但是，索引可以反向索引
del item
item=infors[-4]+infors[-3]+infors[-1]+infors[-2]
print(item)
#看两个语句的运行结果可以发现两者的结果完全一样。
#我们在进行索引的时候，列表的长度又如何获取？如果只是数数，则无疑会增加我们的工作难度，Python提供了一个函数用来计算长度len（）；
print(len(infors))
print(type(infors)) #获取列表的类型

上面的程序我们用到了很多的库函数，下面先介绍一下这些函数：

函数名

功能

id（）

获取变量的存储地址，一般为一串数字

ord（）

获取字符的ASCII码值

type（）

获取变量的类型，一般为字符串类型

str（）

非字符串和字符串连用的时候用，将非字符串转换为字符串

暂时就只介绍这些函数，后面遇到了再详细介绍。
索引图：

索引的详细使用

（1）.通过索引迭代处理序列
用len（）函数得到序列的长度，然后通过for循环，利用range得到序列中的每一个元素。当然，序列中的元素我们也可以通过索引实现数据的更改。和元组不同的是，列表的容量大小可以更改，二元组不可以，但是他们都支持乘法运算。
eg：

# coding:UTF-8
infors=["I like Pthon","and i like c++","我是一名大一学生",20,"喜欢编程"]  #注意逗号必须是英文符号的，容易混淆
#索引迭代
for item in range(len(infors)):
    print(item,end=",")
#序列的乘法运算
infors*=3 #简洁运算符，后面会细讲
print("扩大三倍后的列表为：",infors)
#将列表中置为空
infor=[None]
print("%s" % type(infor))

数据分片

一个列表中往往有很多的数据类容，除了通过索引的方式来获得数据类容，我们也可以通过某些操作来实现对列表中一段数据的提取，这个就叫做分片。
图解：

分片索引格式：
对像（列表）[起始位置:终止位置:步长]
或者
对象（列表）[起始位置，终止位置]
程序实例：

infors=["A","B","C","D","E","F","G","H","I","J","K","L"]
number_a=infors[3:7]
print("第一次截取的类容为：",number_a)
number_b=infors[-3:-8]
print("第二次截取的数据类容为：",number_b)
#通过捷径实现列表分片
#获取索引3以后的类容
print(infors[3:])
#获取索引7之前的所有数据
print(infors[:7]) #未设置步长的时候，系统默认步长是1
#设置截取步长
number_size=infors[:7:2]
print("步长为2的索引：",number_size)

当然索引的操作不仅仅是上面所列举的那样，还有很多方式，在实际的开发过程中，根据需要自己操作。

成员运算符

运算符

描述

in

判断数据是否在列表中

not in

判断数据是否不在列表中

列表操作函数

函数

描述

append（）

在列表后面追加新的类容

clear（）

清楚列表数据

copy（）

列表复制

count（data）

统计某一数据在列表中出现的次数

extend（列表）

在列表后面追加新的列表

index（data）

从列表中查找某一数据第一次出现的位置

insert（index，data）

向列表中指定的位置追加新的数据

pop（index）

从列表中弹出一个数据并删除

remove（data）

删除列表中指定的数据

reverse（）

列表数据逆置

sort（）

列表排序

程序实例：

infors=[1,2,3,4,5,6,7,8,9,10]
infors.append(11) #追加新的类容
print(infors)
infor=infors.copy() #列表复制
print(infor)
num=infors.count(1) #计算1出现的次数
print(num)
infors.extend(infor) #追加新的列表
print(infors)
index=infors.index(8)  #8出现的位置
print(index)
infors.remove(3)  #删除3
print(infors)
infors.reverse() #逆置列表
print(infors)
infors.sort()  #排序
print(infors)
infors.clear()#列表的清除
del infors

列表相关操作的详细解释

(1).pop函数，clear函数和remove函数的区别，clear函数从字面意思就可以理解到，清除函数，则整个列表中的所有的数据元素都会被删除，pop函数，在数据结构中，弹栈就会用到这个，表示弹出某一个元素，也就是从列表中取出来这个数据，也就是常说的函数返回，remove删除的是列表中所有某一特定的值。

列表也是可以进行大小比较的，如果两者相等，则返回True，否则的话，返回False，如果他们之中的数据都一样，但是顺序不一样的话，也是False。

元组

元组（Tuple）是与列表相似的线性数据结构，与列表不同的是，元组中的定义类容不允许被修改，以及容量大小的动态扩充。元组的定义通过“（）”来实现。

# coding:UTF-8
infors=("Pyhton","I like you","i will study you")  #定义元组
for item in infors:
     print(item,end=",")
'''
记住，元组不能修改内容，否则会报错，但是元组是可以进行乘法和加法运算。如果我们定义的元组只有一个元素的话，就在后面加一个逗号，表示该对象是元组，否则就是一般的变量。
'''

元组的乘法和加法运算

这里单独的讲解元组运算的原因是由于，很多人在这里会产生一种错觉，元组的特点就是内容不能被修改，但是我们用了乘法运算，这是由于乘法运算也好，加法运算也好，从根本上并没有修改元组的内容，只是以一个元组创建了另一个元组。

infors=(1,2,3,4,5,6,7,8)
#使用乘法运算的时候，需要用一个元组来接收，不能在原有的基础上增加，
#如果是直接输出，则系统会将返回后的数据输出
print(infors)
print(infors*3)

序列统计函数

项目开发中会使用列表和元组进行数据存储，而且对列表数据可以进行动态配置。所以序列中往往有很多的数据需要处理，如果每次处理都需要自己写函数来实现的话，无疑会增加程序员的工作量，于是，Python提供了一些常用的序列处理函数。

函数

描述

len（）

获取序列长度

max（）

获取序列最大的值

min（）

获取序列最小的值

sum（）

获取序列中所有值的和

any（）

序列中有一个True，则为True，否则，为False

all（）

序列中所有的内容为True的时候，才为True

代码示例：

numbers=[1,2,3,4,5,6,5,4,3,2,1]  #定义列表
print("元素个数：%d" % (len(numbers)))  #统计序列中元素的个数
print("列表中最大的值：%d" % (max(numbers)))
print("列表中最小的值：%d" % (min(numbers)))
print("列表中所有元素的和：%d" % (sum(numbers)))  #计算列表中的所有数据的和
print(any((True,1,"Hello")))  #元组中的的数据都不为False，故为True
print(all((True,None)))  #元组中存在一个None，判断为False

字符串

前面我们提到了在Python中，字符串为Python的默认数据类型，就像double类型是Java的默认数据类型一样。所以对python中的字符 串数据类型，我们需要花费大量的时间和精力来学习，现在将其作为一个单独的板块来讲解。
字符串的讲解大概分为两个板块：字符串的分片和字符串的数据统计。

字符串的分片操作

问题引进：

title="I like Python and I like c++ too"
str_a=title[:7]
print(str_a)
str_b=title[3:9]
print(str_b)
str_c=title[1:5:2]
print(str_c)

上面的程序我们可以发现，其实对于字符串的分片操作和对序列的分片操作很相似。所以可以联想记忆。在Python中，汉字和字母都作为一个字符来处理，这样就减少了切片的过程中产生乱码的情况。

字符串拆分过程中出现乱码的原因

我们都知道，在程序编译的过程中，我们在对字符进行操作的的时候，一般都是对ASCII码进行操作。按照传统的ASCII码来讲，英文字符占一个字节，中文占两个字节，所以如果字符串中要进行截取，就要考虑到截取的字节数，一旦截取位数不对，就会出现乱码。
在项目开发中：常用的编码就有两种：
（1）。UTF-8编码，一个英文字符占一个字节，一个中文占三个字节，中文标点占三个字节，英文标点占一个字节。
（2）.Unicode编码：英文字符占两个字节，中文占两个字节，与之对应的标点也都占两个字节。

简单的字符串操作认识

利用前面的序列操作函数（注意不是列表操作函数）对字符串实现操作。
例如：找出字符串中最大和最小的字符；

# coding:UTF-8
title="i like python"
print("字符串的长度为：%d" % (len(title)))
print("字符串中最大的字符是：%c" % (max(title)))
print("字符串中最小的字符是：%c" % (min(title)))

前面我们在介绍运算符的时候，讲解了成员运算符，在字符串中我们可以使用成员运算符来判断数据是否在字符串中。

# coding:UTF-8
title="study Python now"
if "Python" in title:
    print("字符串“Python”在字符串中")
 else:
 print("no")

字符串格式化

通过前面的学习，我们可以知道，对于Python语言，我们可以选择格式化输出，当然，对于字符串的格式化输出也是可以的。
字符串格式化输出的函数为format（）函数，
函数格式：
“…{成员标记!转换格式：格式描述}…”.format(参数类容)
（1）.成员标记：用于进行成员或参数序号定义，如果不定义，则参数按照顺序进行。
（2）.转换格式：将指定参数的数据类容进行数据格式转换。
（3）.格式描述：提供若干配置选项。
转换标记：

类型符

描述

a

将字符串按照Unicode编码输出

b

将整数转换为二进制数

c

将整数转换为ASCII

d

十进制整数

e

将十进制数转换为用科学计数法表示

E

将十进制数转换为用科学技术法表示（大写E）

f

浮点数表示，会将特殊值（nan，inf）转换为小写

F

浮点数显示，会将特殊值（nan，inf）转换为大写

g

e和f的结合体，若整数部位超过6位用e，否则用f

G

E和F的结合体，整数部位超过6位用E表示，否则用F表示

o

将整数转为八进制数

s

将数据以字符串类型输出

r

将数据转为供解释器输出的信息

x

将十进制整数转换为十六进制数 ，字母部分用小写

X

将十进制转换为十六进制数，字母部分用大写

%

将数值格式化位百分之形式

                               格式描述选项

选项

配置

fill

空白填充配置，默认使用空格实现空白部分的填充

align

<：左对齐，>:右对齐，^：居中对齐，=：将填充数据放在符号和数据之间，仅对数字有效

sign

+：所有数字均带有符号，-：仅负数带有符号（默认配置选项），空格：正数前面带空格，负数前面带符号

数字进制转换配置，自动在二进制，八进制，十六进制和数值前天添加对应的0b，0o，0x标记

.

自动在每三个数字之间添加“，”分隔符

width

定义十进制数字的最小显示宽度，如果未指定，则按照实际的类容来决定宽度

precision

数据保留的精度位数

type

数据类型

字符串提供的format（）函数较为复杂，下面通过几个案例来学习：

name="小明同学"
age=18
score=97.5
message="姓名：{},年龄：{},成绩：{}".format(name,age,score)
print(message)

运行结果:姓名：小明同学,年龄：18,成绩：97.5

上面的程序简单的使用了“{}”进行占位，最终输出的结果就是按照format（）函数标记的顺序，行成最终的输出类容。
当然format（）函数在格式化字符串的时候，也可以通过数字序号，或者是参数来实现定义，从而达到参数和对象的自动匹配。
例如：

name="小明同学"
age=18
score=97.5
#利用参数的形式来实现。
print("姓名：{name_a},年龄：{age_a},成绩：{score_a}".format(name_a=name,age_a=age,score_a=score))
#利用序号来表示
print("姓名：{0},年龄：{1},成绩：{2}".format(name,age,score))  #注意序号和format（）函数中的顺序有关;
运行结果:姓名：小明同学,年龄：18,成绩：97.5
姓名：小明同学,年龄：18,成绩：97.5

通过上面的程序我们可以知道，对于format（）函数的使用，不仅可以方便我们对数据的输出，以及减少了代码量。但是，如果每次都需要定义一个变量来使用，则会显得复杂；我们知道，列表可以存储各种类型的数据，则我们可以通过索引来实现字符串的格式化输出：
代码示例：

infors=["Coco",18,98.5,180,60]
print("姓名{list_pragram[0]}，年龄：{list_pragram[1]},成绩：{list_pragram[2]},身高：{list_pragram[3]},体重：{list_pragram[4]}".format(list_pragram=infors))
运行结果:姓名Coco，年龄：18,成绩：98.5,身高：180,体重：60

一.数据格式化处理

代码示例：

# coding:UTF-8
print("UNICODE编码：{info!a}".format(info="好好学习"))
print("成绩:{info:6.2f}".format(info=98.5674))
print("收入：{numA:G},收入：{numB:E}".format(numA=92393,numB=92393))
print("二进制数：{num:#b}".format(num=10))
print("八进制数：{num:#o}".format(num=10))
print("十六进制数：{num:#x}".format(num=10))
运行结果:
UNICODE编码：'好好学习'
成绩: 98.57
收入：92393,收入：9.239300E+04
二进制数：0b1010
八进制数：0o12
十六进制数：0xa



# coding:UTF-8
msg="I like Python,so i will study hard"
print("数据中显示【{info:^20}】".format(info=msg))
print("数据填充：{info:_^20}".format(info=msg)) #自定义填充符
print("带符号数字填充：{num:^+20.3f}".format(num=12.34578))
print("右对齐：{n:>20.2f}".format(n=25))  #定义对齐方式
print("数字使用“，”分隔：{num:,}".format(num=928239329.99765489090))
print("设置显示精度：{info:.9}".format(info=msg))

运行结果显示：
数据中显示【I like Python,so i will study hard】
数据填充：I like Python,so i will study hard
带符号数字填充：      +12.346       
右对齐：               25.00
数字使用“，”分隔：928,239,329.9976549
设置显示精度：I like Py

上面的程序带我们学会了字符串中的格式操作，但是对于字符串的操作，Python也提供了相关的操作函数，以此来减轻程序员的工作难度。

字符串操作函数

Python中的字符串的处理函数有很多类型，比如大小写转换，替换，拆分，连接等。
下面我们详细的来认识这些函数。

函数

描述

center()

字符串居中显示

find（data）

字符串数据查找，查找到返回索引值，找不到返回-1

join（data）

字符串连接

split（data【，limit】）

字符串拆分

lower（）

字符串转小写

upper（）

字符串转大写

capitalize（）

首字母大写

replace（old，new【，limit】）

字符串替换

translate（mt）

使用指定替换规则实现单个字符的替换

maketrans（oc，nc【，d】 ）

与translate（）函数结合使用，定义要替换的字符内容以及删字符内容

strip（）

删除左右空格

代码示例：

# coding:UTF-8
#字符串的操作函数的示例

#字符串显示控制
info="I like Python,and i want to get good score in Python"
print(info.center(50)) #数据居中显示，长度为50
print(info.upper())          #将字符串中的字母转为大写
print(info.lower())        #将字符串中的字母转为小写
print(info.capitalize())  #首字母转为大写
del info
#总结，在字符串的转换中，对于非字母字符不做任何处理。

#字符串的内容查找
info="New eternity,if i cahnge the word will change"
print(info.find("change")) #返回查询字符串的位置
#find函数不仅仅能够简单的使用查找，还可以使用索引查找，以此来减少查找时间复杂度
print(info.find("word",10,len(info))) #从索引为10 的位置开始查找，直到字符串的最后。
print(info.find("like",20,30)) #运行结果为-1，所以没有查找到，虽然存在like这个单词，但是没在索引的区间内。
del info


#字符串的连接
url=".".join(["I","like","Python"])
autor="_".join("李华")
print(f"姓名：{autor},爱好：{url}")

#字符串的拆分
ip="192.168.1.105"
print("数据全部拆分为：%s" %(ip.split(".")))
print("数据部分拆分为：%s" %(ip.split(".",1))) #拆分一次
data="2022-7-10 22:51:59"
result=data.split(" ")    #此时result相当于列表，用空格将日期和时间分开
print("日期拆分：%s" %(result[0].split("-")))
print("时间拆分为：%s" % (result[1].split(":")))
del ip;del data;del result;

#字符串替换
info="Hello word!Hello Python!Hello c++"
str_a=info.replace("Hello","你好")  #全部替换
str_b=info.replace("Hello","你好",2) #部分替换，替换两次，系统会自动替换匹配的字符串;
print("全部替换后的字符串： %s" % (str_a))
print("部分替换后的字符串：%s" % (str_b))
del info
del str_a
del str_b

#字符替换
str_a="Hello Py th on !H e ll o wo r d!"
#利用maketrans（）函数创建转换表
mt_a=str_a.maketrans(" "," "," ")  #删除空格;
print(str_a.translate(mt_a))
str_b="Hello Pyhton! i like you;i hope get you;"
mt_b=str_b.maketrans(" ",".",";")
print(str_b.translate(mt_b))
del str_a; del str_b;
del mt_a; del mt_b;

#删除左右空格键
"""
我们在输入数据的时候，有时候会出现空格，如果要去掉空格，那么我们就可以使用strip（）函数;
"""
login_info=input("请输入登录信息（格式：名字，密码）").strip()  #删除左右空格;
if len(login_info)==0 or login_info.find(",")==-1:
    print("输入的数据有问题，格式不正确，重新输入;")
else:
    result=login_info.split(",")
    if result[0] and result[1]:
        print("登录成功")
        print("恭喜用户%s登录" % (result[0])) 



运行结果：
I like Python,and i want to get good score in Python
I LIKE PYTHON,AND I WANT TO GET GOOD SCORE IN PYTHON
i like python,and i want to get good score in python
I like python,and i want to get good score in python
39
29
-1
姓名：李_华,爱好：I.like.Python
数据全部拆分为：['192', '168', '1', '105']
数据部分拆分为：['192', '168.1.105']
日期拆分：['2022', '7', '10']
时间拆分为：['22', '51', '59']
全部替换后的字符串： 你好 word!你好 Python!你好 c++
部分替换后的字符串：你好 word!你好 Python!Hello c++
HelloPython!Helloword!
Hello.Pyhton!.i.like.youi.hope.get.you
登录成功
恭喜用户lihua登录

字典

字典（dict）是一种二元偶对象的数据集合（或称之为Hash表），所有的数据存储结构为key=value形式，开发者只需要通过key就可以获取相应的value类容。

字典的基本使用

字典是由多个key=value的映射向组成的特殊列表结构，可以用“{ }”定义字典数据，考虑到用户使用方便，key的值可以是数字，字符或元组。

info={"python":"I like you",1024:"这一天是程序员节日",None:"空的，啥也没有"}
print("Python对应的值为：%s" % (info["python"]))
print("1024对应的是：%s" % (info[1024]))
print("None对应的值为：%s" % (info[None]))

我们发现在Python中的字典的使用中，和数据结构中的哈希表极为相似，所以他和哈希表中的一些特点也很相似，比如key值不允许重复，因为key一旦重复，就会出现新的类容替换旧的类容的情况。

代码示例：使用字典dict（）函数定义字典

infos=dict([["Python","I like Python"],["student","we should study hard"]])  #列表转换为字典;
member=dict(name="李华",age=18,score=97.8)
print(infos)
print(member)

相信很多同学看到这里都会有疑问，既然字典和列表都有多种数据存储的结构，为什么还要实现字典这种结构，这是由于字典结构一般用来进行数据的查询，而列表用来实现数据的输出功能。

字典的迭代输出

字典本质上 是一个由若干映射项形成的列表结构，除了具有数据查询功能，也可以基于for循环是西安全部数据的迭代输出。
字典的迭代输出：

infos=dict([["Python","I like Python"],["student","we should study hard"]])  #列表转换为字典;
member=dict(name="李华",age=18,score=97.8)
print(infos)
print(member)
for key in infos:
    print("%s=%s" % (key,infos[key]))
for key in member:
    print("%s=%s" % (key,member[key]))

在字典中可以直接使用for循环获取字典中对应的所有key的信息，在每次迭代后再通过key实现value数据的查询。通过迭代的方式获取字典中key的值，然后再获得与之对应的value，这种方法虽然简单，但是，如果存储了大量数据，这种方式就会变得特别的耗费时间。于是在实际的开发中可以用items（）的函数直接返回每一组的key和value值。
代码示例：

infos=dict([["Python","I like Python"],["student","we should study hard"]])  #列表转换为字典;
member=dict(name="李华",age=18,score=97.8)
for key,value in infos.items():
    print("%s=%s" % (key,value))
for key,value in member.items():
    print("%s=%s" % (key,value))

字典操作函数

函数

描述

clear（）

清空字典数据

update(k=v,…)

更新字典数据

fromkeys（seq[,value]）

创建字典，使用列表中的数据作为key，所有的key拥有相同的value

get(key[,defaultvalue])

根据key获取数据

popitem()

从字典中弹出一组映射项

keys（）

返回字典中全部key数据

values（）

返回字典中所有的value值

# coding:UTF-8
member=dict(name="李华",age=18,score=97.5)
member.update(name="小明",age=20,score=99)  #字典数据的更新 
for key,value in member.items():
    print("%s:%s" % (key,value))
print("使用pop函数弹出指定的key:%s,剩余的数据为：%s" % (member.pop("name"),member))
del member
member=dict(name="李华",age=18,score=97.5)
print("使用popitem弹出一组数据的值:%s,剩下的数据为：%s" % (member.popitem(),member))

#fromkeys（）函数的使用;
dict_a=dict.fromkeys(("李华","小明"),20) #设置一个元组，元组中的值作为key，并且设置的类容相同
#利用字符串的来设置key，字符串中的每一个字符都会作为一个key
dict_b=dict.fromkeys("Hello",100)
print(dict_a)
print(dict_b)
del dict_a
del dict_b

#使用get函数进行数据的查询
member=({"name":"李晓明","score":90,"age":22})
print("%s" % (member.get("num")))


#利用序列种的函数进行数据的运算
member=dict(chinese=99,english=78,math=100)
print("所有成绩的平均分%.2f" % (sum(member.values())/(len(member))))

运行结果：

总结

（1）.Python中的序列包括；列表，元组，字符串，字典。
（2）.列表是一种可以动态库扩充的数据结构，里面的内容可以依据索引访问，二元组中的类容是不允许被改变的。
（3）.序列中的操作函数max（），min（），sum（），len（），all（），any（）函数对所有的序列结构都有用。
（4）.字符串是一种特殊的序列，有若干的字符所组成，字符串可以利用format（）方法实现强大的格式化操作，也可以利用库函数实现字符串的替换，拆分，查找等操作。
（5）.字典是一种key=value的二元偶对象集合，主要的功能是依据key实现对应value数据的查询，也可以用update（）函数实现对数据的增删查改，或者使用del关键字删除指定key的值。