第四章 序列-1

4.1 序列概述

4.2 字符串

4.3 列表

4.4 元组

4.1序列概述

• Python中，根据容器的存储特点，操作方式，容器可以分为不同的类型，其中序列就是其中的一种内置的容器

• 序列包括字符串，列表和元组

• 序列类型的元素间存在顺序关系，各具体类型使用相同的索引体系，即正向索引和反向索引

• 序列对象是可迭代的

• 序列元素的索引

  ​ 反向从右侧索引-1开始，索引值递减

  ​ ←————————————————————————————————————

  索引	-5	-4	-3	-2	-1
  	100	2.56	"Python"	['a','b']	(10,20)
  索引	0	1	2	3	4

  ​ ————————————————————————————————————→

  ​ 正向从左侧索引0开始，索引值递增

操作符或函数	描述
x in s	如果x是s的元素，返回True；否则返回False
x not in s	如果x不是s的元素，返回True；否则返回False
s+t	连接s和t，使之成为一个序列
s*n或n*s	将序列s复制n次
s[i]	返回序列的索引为i的元素
s[i:j:k]	返回包含序列s索引为i到索引为j（不包括j）以k为步长的子序列
len(s)	序列s的元素个数（长度）
min(s)	序列s中的最小元素
max(s)	序列s中的最大元素
s.index(x)	序列s中第一次出现元素x的位置
s.count(x)	序列s中出现x的总次数
all(s)	判定给定的序列类型s，如果s中的所有元素都是True，则返回True，否则返回False
any(s)	只要序列类型中任何一个元素是True，则返回True；若全部元素都是False，则返回False

需要注意，整数0，空字符串""，空列表[]等都被当作False

4.2 字符串

再识字符串

• 定界符
• 转义字符

字符串基本操作

• 索引与切片
• 运算符
• 内置函数
• 常用方法

字符串特殊应用

• 字符串格式化

再识字符串

定义符

• 字符串是一组不可变且有序的序列，其主要是用来表示文本信息。
• 可以使用单引号、双引号、三引号(三个单引号或三个双引号)作为定界符对字符串进行定义。

>>> print('''蒹葭苍苍，白露为霜。
所谓伊人，在水一方。
溯洄从之，道阻且长。
溯游从之，宛在水中央。''')
> 输出效果
蒹葭苍苍，白露为霜。
所谓伊人，在水一方。
溯洄从之，道阻且长。
溯游从之，宛在水中央。

转义字符（特殊字符串）

思考如何输出？
I'm　Mary
D:\one\two\tree\now

正确用法

>>> print("I'm Mary")

>>> print('I\'m Mary')
>>> print("D:\\one\\two\\tree\\now")

• 转义字符是指在字符串中的某些特定的符号前加一个反斜杠之后，该字符将被解释为另外一种含义。
• 如：print('I'm eva.')

转义	描述	转义	描述
\	在行尾的续行符	\t	水平制表符
\'	单引号	\a	响铃
\"	双引号	\b	退格（Backspace）
\0	空	\\	反斜线
\n	换行符	\0dd	八进制数，如\012代表换行
\r	回车符	\xhh	十六进制数，如\x0a代表换行

字符串表示小结

(1)

 print('Hello Python!')
 print("Hello World!")

(2)

>>> print('''蒹葭萋萋，白露未晞。
所谓伊人，在水之湄。''')
>>> print("""溯洄从之，道阻且跻。
溯游从之，宛在水中坻。""")

(3)

print('Let\'s go')
print("d:\\abc\\123")

字符串基本操作

字符串索引

正向索引	0	1	2	3	4
	温	故	而	知	新
反向索引	-5	-4	-3	-2	-1

格式： <字符串或字符串变量>[索引]

>>> "温故而知新"[0]
'温'
>>> s1= "温故而知新"
>>> s1[3]
'知'
>>> s1[5]
Traceback (most recent call last):
  File "<pyshell#1>", line 1, in <module>
str1[4]
IndexError: string index out of range

>>> "温故而知新"[-5] 
'温'
>>> s1= "温故而知新"
>>> s1[-2]
'知'
>>> s1[-6]
Traceback (most recent call last):
  File "<pyshell#1>", line 1, in <module>
str1[-6]
IndexError: string index out of range

字符串切片

格式：<字符串或字符串变量>[start:end:step]

>>> s1= "温故而知新"
>>> s1[0:4:1]
'温故而知'
>>> s1[0:4:2]
'温而'

>>> s1= "温故而知新"
>>>print( s1[0:4:1])
温故而知
>>> print(s1[0:4:2])
温而
# 注意结果在形式上的区别

s1= "温故而知新"
#切片1 正着数
>>> s1[0:4]   #返回'温故而知's
# 切片2 负着数
>>> s1[-5:-3] #返回'温故's
# 切片3 省略数
>>> s1[:]  #返回'温故而知新'
>>> s1[1:]#返回'故而知新'
>>> s1[:-3]  #返回'温故's
# 切片4 跳着数
>>> s1[::2] #返回'温而新'
>>> s1[1:6:2]#返回'故知'
>>> s1[::-2]#返回'新而温'

字符串运算符

拼接运算符

>>> "温故而知新,"+ " 可以为师矣"
'温度而知新，可以为师矣'
>>> s1="中国女排"
>>> s2="夺冠"
>>> s3,s4=11,"连胜"
>>> print(s1+s2)
中国女排夺冠
>>> print(s1+str(s3)+s4+s2)
中国女排11连胜夺冠

复制运算符

>>> "Go"*3   #将返回由3个'Go'组成的新字符串
'GoGoGo '
>>>3*"Go"
'GoGoGo '

成员运算符

>>> "Python" in "I love Python"
True
>>> "Java " not  in " I love Python "
True

关系运算符

（1）单字符字符串的比较

>>>  "a">"A"   #返回 True
True
>>>  "0">"1"  #返回False
False

（2）多字符字符串的比较

>>> "Hello World!" >"Hello Python!"  
True
>>>"hello"<"hello world!"   
True
>>> ""<"a"   
True

字符串内置函数

• 字符串函数操作是以字符串作为输入条件，经过处理后返回相应的值。
• Python解释器提供了常见的字符串处理相关的内置函数，其调用形式为：<函数名> (<参数>)
  在此处插入表格
• Unicode编码
• Python 3以Unicode字符 为计数基础，中英文字符 及标点字符 都是1个长度单位。
• Unicode又称万国码，是计算机科学领域里的一项业界标准，包括字符集、编码方案等，Python字符串中每个字符 都使用Unicode编码表示。
• ord(s) 返回单个字符表示的Unicode编码
• chr(x) 返回Unicode编码对应的单个字符

【试一试】 读程序，写出程序的功能

#加密小助手
words=input("请输入一句话：")
new_words=""
for w in words:
  new_words+=chr(ord(w)+1)
print("new_words:",new_words)

程序运行结果
请输入一句话：I love 中国
new_words: J!mpwf!丮图

【试一试】 编写程序，输入一个字符串，将其中的小写英文字母变为它的下三个字母，即a变成d，b变成e,…..,z变成c，其它字符变为它的下一个字符。

words=input("请输入一句话：")
new_words=""
for w in words:
  if "a"<=w<"x":
   new_words+=chr(ord(w)+3)
 elif w=="x":
   new_words+="a"
 elif w=="y":
   new_words+="b"
 elif w=="z":
   new_words+="c"
 else:new_words+=chr(ord(w)+1)
print("new_words:",new_words)

程序运行结果
请输入一句话：我喜欢 Python
new_words: 戒喝欣!Qbwkrq

【例4-1】 凯撒密码

明文 密文
DOT GRW
DOTY GRWB
如果原文字符是P,其密文字符C，满足如下条件：
加密：C=（P+3）mod 26
解密：P=(C-3) mod 26

#凯撒密码加密.py
plaintext=input("请输入明文:")
for p in plaintext.lower():  #将明文转换成小写字符，遍历每一个字符
  if "a"<=p<="z":
    print(chr((ord(p)+3-ord("a"))%26+ord("a")),end="")
  else:
    print(p,end='')

字符串的常用方法

• 字符串方法是对字符串进行处理的一个过程，由方法名和用圆括号括起来的参数列表组成。
• Python中，字符串对象有大量自己特定的方法，可用于查找、检测、排版、替换等操作。
• 字符串内置方法众多，根据功能不同，把常用方法从转换、判断、填充、查找、连接与分割等几个方面分类介绍。

格式：<字符串或字符串变量>.<方法名>([<参数1，参数2….>] )

【1】转换方法

方法	例子	值	描述
upper	s.upper()	'MY NAME IS EVA'	全部字符大写
lower	s.lower()	'my name is eva'	全部字符小写
swapcase	s.swapcase()	'mY NAME IS eVA'	字符大小写互换
capitalize	s.capitalize()	'My name is eva'	串首字母大写，其余小写
title	s.title()	'My Name Is Eva'	单词首字母大写，其余小写

>>> s1="A journey of a thousand miles begins with single step."
>>> s1.upper()  #将全部字符转换为大写
'A JOURNEY OF A THOUSAND MILES BEGINS WITH SINGLE STEP.'
>>> s1.lower() #将全部字符转换为小写
'a journey of a thousand miles begins with single step.'
>>> s1.title() #所有单词首字母大写，其余小写
'A Journey Of A Thousand Miles Begins With Single Step.'
>>> s1.capitalize()   #将字符串的第一个字符转换为大写字符，其余小写
'A journey of a thousand miles begins with single step.'
>>> s1.swapcase()#将字符串中大小写字符互换
'a JOURNEY OF A THOUSAND MILES BEGINS WITH SINGLE STEP.'

【2】判断方法

方法	例子	值	描述
isalnum	s.isalnum()	True	全是字母或数字，返回True
isalpha	s.isalpha()	False	全是字母，返回True
isdigit	s.isdigit()	False	全是数字，返回True
islower	s.islower()	True	有区分大小写字符，且全是小写，返回True
isupper	s.isupper()	False	有区分大小写字符，且全是大写，返回True
istitle	s.istitle()	False	首字母为大写字母，返回True
isspace	s.isspace()	False	全是空白字符，返回True
isprintable	s.isprintable()	True	全是可打印字符，返回True

>>> "你好JACK！".isupper( )  #判断字符串中所有的字母是否都为大写
True
>>> "你好JACK！".islower( )  #判断字符串中所有的字母是否都为小写
False
>>>  "你好JACK！".isalpha()  #判断一个字符串是否只包含字母或汉字,如果是返回True,否则返回False.
False
>>> "10086".isdigit()   #判断一个字符串是否只包含数字
True
>>> "中国移动10086".isalnum( )   # 判断一个字符串是否全部由字母、汉字或数字组成
True
>>>  "China Mobile".istitle()  #判断字符串中的所有单词是否都是首字母大写
True

【3】查找方法

S="123,abc,123,abc"

方法	例子	结果	描述
find	s.find("123",1,7) s.find("ab")	-1 4	范围内查找子串，返回首次出现位置，找不着返回-1
rfind	s.rfind("23",1,13) s.rfind("123")	9 12	范围内查找子串，返回末次出现位置，找不着返回-1
index	s.index("123",1,7) s.index("123")	出错 0	范围内查找子串，返回首次出现位置，找不着报错
count	s.count(",") s.count("234")	3 0	返回子字符串在字符串中出现的次数
replace	s.replace("123","456") s.replace("a","4",1)	'456,abc,456,abc' '123,4bc,123,abc'	查找子串并在次数范围内用制定字符串替代，返回新串
startswith	s.startwith("12") s.startwith("12",9)	True False	如果范围字符串以指定子串开始，返回True
endswith	s.endswith("3",1,11) s.endwith("23")	True False	如果范围字符串以指定子串结束，返回True

s1="A journey of a thousand miles begins with single step."
>>> s1.count("th")  #返回子串"th"在字符串s1中指定的区间内出现的次数
2
>>> s1.count("th",10,20) #返回子串"th"在字符串s1的索引序号10到20（不包括）间出现的次数
1

s1="A journey of a thousand miles begins with single step."
>>>  s1.find("th")#在s1中查找子串"th"，返回第一次出现"th"的索引序号
15
>>>  s1.find("th",10,35)#在指定的区间内查找子串"th"，返回"th"首次出现的索引序号
15
>>> s1.find("our",9,20) #在指定的范围内查找子串"our",若没有找到子串，返回-1.
-1

s1="A journey of a thousand miles begins with single step."
>>> s1.index("our")#在s1中查找子串"our"，返回第一次出现"our"的索引序号
3
>>>  s1.index("our",9,20)   #在指定的范围内查找子串"our"，若没找到会产生异常
Traceback (most recent call last):
  File "<pyshell#9>", line 1, in <module>
s1.index("our",9,20)
ValueError: substring not found

s1="A journey of a thousand miles begins with single step."
>>>  s1.strartswith("A")  #返回字符串s1是否以"A"开头
True
>>>   s1.startswith("our",9,20) #在索引区间[9,20] 内的子串若以our开头，则返回True，否则返回False
False
>>>  s1.endswith("our",0,6) #在指定区间内的子串若以our结尾，则返回True，否则返回False
True

>>>  s2="aabbaaccaa"
>>> s2.replace("aa","#") #将s2中所有的子串"aa" 替换为"#"
'#bb#cc#'
>>> s2.replace("aa","#",2)  #将s2中前两个子串"aa" 替换为"#"
'#bb#ccaa'

【4】连接与分割方法

方法	描述
join	用指定字符连接字符串或列表
split	以指定字符为分割符，分割成多个字符串，返回包含分割结果的列表

>>>  "-".join("1234")   #用"-"连接字符串"1234"
'1-2-3-4'
>>> ".".join(["www" ,"lnu", "edu","cn"])   #用"."连接列表中的字符串
'www.lnu.edu.cn'

>>> "abc123@163.com".split("@")  #以指定字符@作为分隔符，返回包含分
['abc123', '163.com']   割结果的列表
>>>  "www.sohu.com".split(".") 
['www', 'sohu', 'com']
>>> "www.sohu.com".split(".",1)  #将字符串以.作为分隔符，分割1次
['www', 'sohu.com']
>>>  "www.sohu.com".split(".",2)
['www', 'sohu', 'com']

#若没有指定分隔符，将以空白字符（空格，\n,\r,\t）分割字符串
>>> "A journey of a thousand miles begins with single step".split()
 ['A', 'journey', 'of', 'a', 'thousand', 'miles', 'begins', 'with', 'single', 'step']
>>>  "hello\nworld!".split()
 ['hello', 'world!']

【5】修剪（格式）方法

S="123,abc,123,abc"

方法	描述
center	返回指定长度的居中对齐字符串副本
ljust	返回指定长度的左对齐字符串副本
rjust	返回指定长度的右对齐字符串副本
zfill	返回指定宽度字符串不足左侧用0补位
strip	删除两边空白字符或指定字符
lstrip	删除左边空白字符或指定字符
rstrip	删除右边空白字符或指定字符

>>> "abc hello ab".strip("ab")  #删除字符串两边的子串"ab"
'c hello '
>>>  "  abc  123  ".strip()   #删除字符串两边的空白字符（空格）
'abc  123'
>>> "\nabc hello ab\n\r".strip()#删除字符串两边的空白字符（\n,\r）
'abc hello ab'

字符串特殊应用

字符串的格式化—format方法

输出的格式：
你好，____，你得到了____分

输出的内容：
你好，张小小，你得到了95分
你好，李云鹏，你得到了120分
你好，陈山山，你得到了215分

格式：<模板字符串>.format(<参数1，参数2……>)

>>> "my {} is {}".format("name","eva")

• format( )方法可以有一个或多个类型不同的对象参数。
• format( )方法执行时，首先进行对象参数与模板字段项的匹配，然后将每个对象参数,按照所匹配的模板字段指定格式转换为字符串，并替换所匹配的模板，返回一个被替换后的字符串。

# { }—位置匹配，不带序号，按顺序填充
>>> print("name is {},id is{}".format("王小瞳","190101"))
name is 王小瞳，id is 190101
# {0},{1}—序号匹配，可调换顺序
>>> print("name is {0},id is{1}".format("王小瞳","190101"))
name is 王小瞳，id is 190101
>>> print("name is {1},id is{0},{1}是计算机专业的学生".format("190101","王小瞳"))
name is 王小瞳,id is 190101,王小瞳是计算机专业的学生
# {name}、{id}—名称匹配，带关键字填充
>>> print("name is {name},id is{id}".format(name="王小瞳",id="190101"))
name is 王小瞳，id is 190101
# {0[0]},{0[1]}—索引下标匹配
>>> print("name is {0[0]},id is{0[1]}".format(["王小瞳","190101"]))
name is 王小瞳,id is190101

• 使用format方法时，在{ }内除了包含参数或参数序号外，还可以包含格式控制信息，用来控制参数显示时的格式，二者中间用冒号隔开。
  格式：{[<参数>|<参数序号>]: <格式控制标记>}

>>> print("我爱你，{:>4}".format("中国"))
我爱你，  中国
>>> print("{0}，{0:^4}，壮丽的{1:>3}".format("中国","山河"))
中国， 中国 ，壮丽的  山河

{[<参数>|<参数序号>]: <格式控制标记>}

:	<填充>	<对齐>	<宽度>	<,>	<精度>	<类型>
引导符号	用于填充的单个字符，默认为空格	<左对齐 >右对齐 ^居中对齐	设置输出宽度	数字的千位分隔符，适用于整数和浮点数	浮点数小数部分的精度或字符串的最大输出长度	整数类型b.c.d.e.x.X 浮点数类型e.E.f.%

>>> print("name is {},id is {:#>8},score is {:>5.1f}".format("王小瞳","190101",98.69))
name is 王小瞳,id is ##190101,score is 98.7

format方法的优势

(1)无需理会填充数据的数据类型问题
(2)单个参数可以多次输出，参数顺序可以不相同
(3)填充方式十分灵活，对齐方式十分强大

【例4-2】下面输出的是前三名同学的成绩排名

#E4-2.py
print("{0:*^30}".format("score ranking"))
print("{0:<5}{1:^20}{2:>5}".format("id","name","score"))
print("{0:<5}{1:^20}{2:>5}".format(1,"eva",100))
print("{0:<5}{1:^20}{2:>5}".format(2,"coco",98))
print("{0:<5}{1:^20}{2:>5}".format(3,"fanny",95))

程序的运行结果为：
********score ranking*********
id name score
1 eva 100
2 coco 98
3 fanny 95