《Python语言程序设计》课件 第5、6章 字符串、复合数据类型

第5章字符串与正则表达式第5章

字符串5.1字符串编码5.2字符串的索引和切片5.3字符串的操作5.4正则表达式1．Unicode码Unicode编码标准为表达全世界所有语言的任意字符而设计，它使用4字节的数字编码来表达每个字母、符号或文字。5.1字符串编码2．UTF-8码UTF-8是一种为Unicode字符设计的变长编码系统，即不同的字符可使用不同数量的字节编码。对于ASCII字符，UTF-8仅使用1个字节来编码。UTF-8支持中英文编码，英文系统也可以显示中文。Python支持UTF-8编码，中文字符、希腊字母均可以作为标识符使用。例如：>>>单价=13>>>数量=100>>>print(单价*数量)1300两个内置函数ord()函数：将一个字符转化为Unicode码>>>ord("中")20013>>>print("♈是白羊座的符号，其Unicode码是",ord("♈"))♈是白羊座的符号，其Unicode码是9800chr()函数：将一个整数转换为Unicode字符。>>>chr(10005),chr(10004)('✕','✔’)>>>print("金牛座的Unicode码是9801，其符号为",chr(9801))金牛座的Unicode码是9801，其符号为♉

5.2.1字符串的索引字符串是一种元素为字符的序列类型。5.2字符串的索引与分片注意：索引编号要求为整数，且不能越界。索引编号：正索引：从左向右编号，最左边的字符编号为0，最后一个字符的编号比长度小1。负索引：从右向左编号，最右边的字符编号为-1。通过索引编号可以获取字符串中的某个字符。格式：字符串变量名[索引编号]例如：s[2]、s[-1]在Python中，字符串是不可变对象，不能用下标赋值的方式去改变字符串.>>>s="python">>>s[0]="P"Traceback(mostrecentcalllast):File"<pyshell#17>",line1,in<module>s[0]="P"TypeError:'str'objectdoesnotsupportitemassignment【例5-1】获取星期字符串。weekStr="一二三四五六日"weekId=eval(input("请输入星期数字(1~7)："))print("星期"+weekStr[weekId-1])【例5-2】编写一个程序，判断一个字符串是否为“回文”（顺读和倒读都一样的字符串称为“回文”）。如果输入字符串是回文，则输出“yes”；如果字符串不是回文，则输出“no”。例如：ABCBA或者AACCAA是回文字符串；ABCCA或者AABBCC不是回文字符串。a=input("请输入一个字符串：")n=len(a)i,j,f=0,-1,1whilei<n/2:ifa[i]!=a[j]:f=0breaki=i+1j=j-1iff==1:print("yes")else:print("no")5.2.2字符串的切片字符串的分片就是从给定的字符串中分离出部分字符。格式：字符串[M:N:K]其中M是索引起始位置，N是索引结束位置但不包括N位置上的字符，索引编号每次增加的步长为K。>>>s="0123456789987654321">>>s[0:8:2]'0246'>>>s[-1:-4:-1]'123'>>>s[-9:15:1]'98765'注意：不包括索引结束位置上的字符。正索引范围：0~字符串长度-1负索引范围：-字符串长度~-1当索引起始位置i省略时，从0或-1开始。当结束位置j省略时，默认到最后一个字符。当步长k省略时，默认为1。>>>s="abcdefg">>>s[5:1:-1]'fedc'>>>s[-len(s):-1]'abcdef‘（5）开始和结束的索引值可以超过字符串的长度。>>>s[-100:100]'ABCDEFGHIJK'>>>s="ABCDEFGHIJK">>>s[::]'ABCDEFGHIJK'>>>s[::-1]'KJIHGFEDCBA'>>>s[1::]'BCDEFGHIJK'>>>s[:-1:]'ABCDEFGHIJ'>>>s[::-2]'KIGECA's="teacher",能够显示输出teacher的选项是：（

）。A．print(s[0:-1])B．print(s[-1:0])

C．print(s[:])D．print(s[:6])答案：C设str="hello"，想把字符串的第一个字母大写，其他字母还是小写，正确的选项是：（

）。A．print(str[1].upper()+str[-1:1])B．print(str[0].upper()+str[1:-1])C．print(str[1].upper()+str[2:])D．print(str[0].upper()+str[1:])答案：D【例5-3】用字符串切片的方法解决例题5-2的回文问题。s=input("请输入一个字符串")d=s[::-1]ifd==s:print("yes")else:print("no")5.3.1字符串连接操作1．加号连接操作运算符：+字符串连接表达式的格式是：s1+s2+……+sn例如：>>>"Python"+"语言"+"程序设计基础"'Python语言程序设计基础’5.3字符串的操作>>>"abcd"+1234TypeError:canonlyconcatenatestr(not"int")tostr>>>"abcd"+str(1234)'abcd1234'“1234”+1234的计算结果的是（）（A）“1234”+1234 （B）“12341234”

（C）2468 （D）提示类型错误，无法运行答案：D注意：将字符串和数值数据进行连接时，需要将数值数据用str()函数或repr()函数转换成字符串，再进行连接。字符串是不可变类型，其中的字符不能被赋值更改。>>>s=“abcdefg“s[1]=‘8‘TypeError:'str'objectdoesnotsupportitemassignment错误！如果要把s[1]改为’8’，怎么办？可以利用连接运算新建一个字符串来改变！>>>s=“abcdefg“>>>s=s[0]+'8'+s[2::]>>>s'a8cdefg'2．重复连接格式：s*n或n*s其中s是一个字符串；n是一个正整数，代表重复的次数。作用：构建一个由其自身字符串重复连接而成的字符串。例如：>>>"ABCD"*2'ABCDABCD‘注意：连接操作的复合赋值运算符：+=、*=a+=‘abc‘等价于a=a+”abc”>>>a="go">>>a*=3>>>b="Ale">>>b*=3>>>a+=b>>>a'gogogoAleAleAle'例5-3从键盘输入5个字符串，将它们连接成一个字符串后输出。s=''foriinrange(0,5):c=input("Pleaseenterastring:")s+=cprint(s)3．成员关系操作格式为：s1[not]ins2作用：用于判断字符串s1是否属于字符串s2，其返回值为True或False.例如：>>>"Hi"in"Hi,Python"True>>>"python"in"Hi,Python"False>>>"。"notin"Hi,Python"Truess='AEIOUaeiou's1=''foriinrange(0,10):s=input("Pleaseinputaword:")

ifs[0]inss:s1+=sprint(s1)例5-4从键盘输入10个英文单词，输出其中以元音字母开头的单词。4.r/R原始字符串在字符串的第一个引号前加上字母"r"（或"R"），表示所有的字符串都是直接按照字面的意思来使用，没有转义或不能打印的字符。>>>print(r"hello\nworld")hello\nworld>>>print("hello\nworld")helloworld5．关系运算在进行字符串数据的比较时，遵循以下规则。（1）单个字符比较，按字符ASCII码大小进行比较。空格<数字字符<大写字母<小写字母<中文汉字例如：>>>'D'<'B'False>>>'8'>'2'True（2）两个相同长度的字符串的比较是将字符串中的字符从左向右逐个比较，如果所有字符都相等，则两个字符串相等，如果两个字符串中有不同的字符，以最左边的第1对不同字符的比较结果为准。（3）若两个字符串中字符个数不等时，则将较短的字符串后面补足空格后再比较。>>>'SHANGHAI'<'SHANKONG'True>>>'WHERE'<'WHEREVER'True5.3.2字符串的处理函数str(x)函数：返回x的字符串形式，

其中x可以是数字类型或其他类型。>>>str(3.5)'3.5'函数和方法的比较：相同点：都是具有独立功能、由若干语句组成的一个可执行程序段。区别：函数是结构化程序设计中的概念，方法是面向对象中的概念，是类中的函数。函数可以通过函数名直接调用，如ord(‘A’)；而对象中的方法则要通过对象名和方法名来调用。格式为：对象名.方法名(参数)>>>s='abc123dfg'>>>s.upper()'ABC123DFG’>>>s'abc123dfg'5.3.3字符串处理方法1．字母大小写转换s.upper()：全部转换为大写字母。s.lower()：全部转换为小写字母。s.swapcase()：字母大小写互换。s.capitalize()：首字母大写，其余小写。s.title()：每个单词的首字母均大写。5.3.3字符串的常用方法>>>'Abc123Dfg'.upper()'ABC123DFG'>>>'Abc123Dfg'.lower()'abc123dfg'>>>'Abc123Dfg'.swapcase()'aBC123dFG'>>>'Abc123Dfg'.capitalize()'Abc123dfg'>>>'Abc123dfg'.title()'Abc123Dfg'>>str="Hello">>>str.upper()'HELLO'>>>str.lower()'hello'>>>"hello,kitty".title()'Hello,Kitty'>>>"hello,kitty".capitalize()'Hello,kitty'>>>"Hello,Kitty".swapcase()'hELLO,kITTY'2．字符串对齐处理s.ljust(width,[fillchar])：输出width个字符，s左对齐，右边不足部分用fillchar填充，默认用空格填充。s.rjust(width,[fillchar])：输出width个字符，s右对齐，左边不足部分用fillchar填充，默认用空格填充。s.center(width,[fillchar])输出width个字符，s中间对齐，两边不足部分用fillchar填充，默认用空格填充。s.zfill(width)：把s变成width长，并且右对齐，左边不足部分用0补齐。>>>'Abc123dfg'.ljust(20,'*')'Abc123dfg**********'>>>'Abc123dfg'.rjust(20,'*')'**********Abc123dfg'>>>'Abc123dfg'.center(20,'*')'*****Abc123dfg*****'>>>'Abc123dfg'.zfill(20)'0000000000Abc123dfg'用键盘输入字符串s，按要求输出到屏幕。格式要求：宽度位30个字符，以星号填充，居中对齐。如果输入字符串超出30位，则全部输出。、例如：用键盘输入字符串s:”Congratulations”，屏幕输出：*******Congratulations********方法1：print('{:*^30}'.format(s))方法2：s.center(30,'*')3．字符串查找s.find(substr,[start,[end]])：返回s中出现substr的第1个字符的编号，如果s中没有substr则返回-1。start和end作用就相当于在s[start:end]中搜索。s.index(substr,[start,[end]])：与find()相同，只是在s中没有substr时，会返回一个运行时错误。s.rfind(substr,[start,[end]])：返回s中最后出现的substr的第1个字符的编号，如果s中没有substr则返回-1，也就是说从右边算起的第1次出现的substr的首字符编号。>>>'12341234123'.find('23',4)5>>>'12341234123'.index('23')1>>>'12341234123'.rfind('23',4,8)5s.rindex(substr,[start,[end]])：与rfind()相同，只是在s中没有substr时，会返回一个运行时错误。s.count(substr,[start,[end]])：计算substr在s中出现的次数。s.startswith(prefix[,start[,end]])：是否以prefix开头，若是返回True，否则返回False。s.endswith(suffix[,start[,end]])：以suffix结尾，若是返回True，否则返回False。>>>'12341234123'.rindex('23')9>>>'12341234123'.count('23')3>>>'12341234123'.startswith('23',5)True>>>'12341234123'.endswith('3')True>>>s="Hi,Python!Hi,C!">>>s.find("Hi")0>>>s.rfind("Hi")10>>>s.count("Hi")2>>>s.startswith("Hi")True>>>s.startswith("Hi",3)False>>>s.endswith("C!")True4．字符串替换s.replace(oldstr,newstr,[count])：把s中的oldstar替换为newstr，count为替换次数。这是替换的通用形式，还有一些函数进行特殊字符的替换。s.strip([chars])：把s中前后chars中有的字符全部去掉，可以理解为把s前后chars替换为None。默认去掉前后空格。>>>'12341234123'.replace('23',"ab",2)'1ab41ab4123'>>>'*1234*1234*123*'.strip('*')'1234*1234*123's.lstrip([chars])：把s左边chars中有的字符全部去掉。默认去掉左边空格。s.rstrip([chars])：把s右边chars中有的字符全部去掉。默认去掉右边空格。>>>'*1234*1234*123*'.lstrip('*')'1234*1234*123*'>>>'*1234*1234*123*'.rstrip('*')'*1234*1234*123'5．字符串的拆分与组合s.split([sep,[maxsplit]])：以sep为分隔符，把字符串s拆分成一个列表。默认的分隔符为空格。maxsplit表示拆分的次数，默认取-1，表示无限制拆分。>>>'苹果香蕉桔子葡萄'.split()['苹果','香蕉','桔子','葡萄']>>>'苹果香蕉桔子葡萄'.split('',1)['苹果','香蕉桔子葡萄']s.join(seq)：把seq代表的序列组合成字符串，用s将序列各元素连接起来。>>>''.join(['a','b','c','d'])'abcd'>>>s="abcd">>>s=list(s)>>>s[1]='8'>>>s=''.join(s)>>>s'a8cd’注意:修改字符串的方法：6．字符串类型测试字符串类型测试函数返回的都是逻辑值。s.isalnum()：是否全是字母和数字，并至少有一个字符s.isalpha()：是否全是字母，并至少有一个字符s.isdigit()：是否全是数字，并至少有一个字符s.isspace()：是否全是空格，并至少有一个字符s.islower()：s中的字母是否全是小写s.isupper()：s中的字母是否便是大写s.istitle()：s是否是首字母大写>>>"HelloWorldHelloPython".isalpha()False>>>"python3".isalnum()True>>>"HelloworldHellopython".istitle()False>>>"HelloWorldHelloPython".istitle()True编写程序，输入一段英文句子，统计其字符个数，并统计出其包含多少个单词。如输入“Ilovepython!”，则输出Thelengthis:14，Thecountis:3。s=input("请输入一段英文:")#将以下代码补充完整....................print("Thelengthis:%.f"%len)print("Thecountis:%.f"%count)5.3.4字符串类型的格式化1.format方法格式：

模板字符串.format(参数0，参数1，参数2…)模板字符串由一系列槽{}组成。作用：

将各输出项按照序号替换到格式字符串的槽中（序号从0开始编号）。>>>'{0:.2f},{1}'.format(3.145,500)'3.15,500'槽{}内的格式控制符格式：{<参数序号>:<填充字符><对齐方式><输出宽度><,><.精度><类型>}填充字符：配合“输出宽度”使用，当参数的宽度小于输出宽度时，要用填充的字符补满。缺省时填充空格。例如：“{0:*^10.2f}”.format(3.1415926)对齐方式：控制对齐方式，配合“输出宽度”使用。<:左对齐>:右对齐(默认)^:居中输出宽度：指定格式化后的字符串所占的宽度逗号：为数字添加千分位分隔符精度：指定小数位的精度类型：字符串：s整数类型：b(二进制),c(Unicode字符),d(十进制),o(八进制),x或X(十六进制)浮点数类型：e或E(科学计数法),f(浮点数，默认保留小数点后6位),%(浮点数的百分比形式)>>>"{0:*>10.2f}".format(3.1415926)'******3.14'>>>"{:=^20}".format("PYTHON")'=======PYTHON======='>>>"{:10x}".format(33)'21'>>“六年级1班的数学平均成绩为{:.2f},优秀率为{:.2%}".format(91.1267,0.1534)'六年级1班的数学平均成绩为91.13,优秀率为15.34%'>>>"{0:e},{0:.2E}".format(3.1415926)'3.141593e+00,3.14E+00'2.f-string格式化和format方法一样，都要使用占位符{},它可以把变量、表达式写到占位符{}中，变量、表达式的值会替换掉占位符。>>>price,num=8,3>>>print(F"这个商品的单价是{price}元，数量是{num},总计{price*num}元")这个商品的单价是8元，数量是3,总计24元{变量或表达式:<填充字符><对齐方式><输出宽度><.精度><类型>}若要给数据设置格式：>>>pi=3.1415926>>>print(f"{pi:*^10.2f}")***3.14***假设变量a是一个浮点数，要遵照"a=xxx.xx"的格式（小数点后保留两位）输出变量a，以下写法正确的是（）（A）print("a=35.45") （B）print("{.2f}".format(a))（C）print("a={:.2f}".format(a)) （D）print("a={}".format(a))用键盘输入字符串s，按要求输出到屏幕。格式要求：宽度位30个字符，以星号填充，居中对齐。如果输入字符串超出30位，则全部输出。、例如：用键盘输入字符串s:”Congratulations”，屏幕输出：*******Congratulations********程序代码如下：#请在______处使用一行代码或表达式替换#注意不要修改其他代码s=input('请输入一个字符串：')print(“_________”.format(s))答案：C{:*^30}5.6字符串应用举例例5-11输入一个字符串，每次去掉最后面的字符并输出。程序如下：s=input()foriinrange(-1,-len(s),-1):print(s[:i])输入：hello输出：hellhelhehline1=input()line2=""forc1inline1:ifc1.isalpha():i=ord(c1)j=i+5if(j>ord("z")or(j>ord("Z")andj<ord("Z")+6)):j-=26c2=chr(j)line2+=c2else:line2+=c1print(line2)例5-12翻译密码。为了保密，常不采用明码电文，而用密码电文，按事先约定的规律将一个字符转换为另一个字符，收报人则按相反的规律转换得到原来的字符。例如，将字母“A”→“F”，“B”→“G”，“C”→“H”，即将一个字母变成其后第5个字母。例如，“HeisinBeijing.”应转换为“MjnxnsGjnonsl.”。例5-14从键盘输入几个数字，用逗号分隔，求这些数字之和。分析：输入的数字当作一个字符串来处理，首先分离出数字串，再转换成数值，这样就能求和。s=input('请输入几个数字（用逗号分隔）')d=s.split(',')sum=0forxind:sum+=float(x)print('sum=',sum)请输入几个数字（用逗号分隔）1,2,3,4,5sum=15.05.4正则表达式正则表达式是一种字符串的匹配方法，它能够用来描述一种字符串的模式。5.4.1正则表达式的元字符例：1.匹配身份证：（^\d{17}（[0-9]|X|x）$），18位身份证号码，最后一位是校验位，可能为数字或字符X.2.匹配国内固定电话号码：\d{3，4}-\d{7，8}，3.匹配特定数字^[1-9]\d*$//匹配正整数^-[1-9]\d*$//匹配负整数^-?[1-9]\d*$//匹配整数^[1-9]\d*|0$//匹配非负整数（正整数+0）^-[1-9]\d*|0$//匹配非正整数（负整数+0）^[1-9]\d*.\d*|0.\d*[1-9]\d*$//匹配正浮点数^-（[1-9]\d*.\d*|0.\d*[1-9]\d*）$//匹配负浮点数^-?（[1-9]\d*.\d*|0.\d*[1-9]\d*|0?.0+|0）$//匹配浮点数4.匹配特定字符串：^[A-Za-z]+$//匹配由26个英文字母组成的字符串^[A-Z]+$//匹配由26个英文字母的大写组成的字符串^[a-z]+$//匹配由26个英文字母的小写组成的字符串^[A-Za-z0-9]+$//匹配由数字和26个英文字母组成的字符串^\w+$//匹配由数字、26个英文字母或者下划线组成的字符串5.日期格式：^\d{4}-\d{1，2}-\d{1，2}5.4.2正则表达式模块在Python中，正则表达式的功能通过re模块来实现。re模块提供各种正则表达式的匹配操作，在文本解析、复杂字符串分析和信息提取时是一个非常有用的工具。1.正则表达式的两种书写方式

（1）用“re.函数名（参数）”调用函数，直接在参数里书写正则表达式。（2）先用pile()函数将一个字符串形式的正则表达式编译为正则表达式对象，然后使用正则表达式对象提供的方法进行字符串处理。语法格式如下：对象名=pile（pattern，flags=0）参数

pattern可以取的值如下所示：

re.I、re.IGNORECASE：忽略大小写。re.M、re.MULTILINE：多行模匹配模式re.S、re.DOTALL：匹配包括换行在内的所有字符。re.L、re.LOCALE：做本地化识别（locale-aware）匹配。re.U、re.UNICODE：根据Unicode字符集解析字符，这个标志影响\w、\W、\b、\B、\d、\D。re.X、re.VERBOSE：详细模式。【例5-4】判断用户输入的数据是否为整数importrea=input("请输入一个整数:")ifre.match("^-?[1-9]\d*$",a)!=None:print("输入合法")else:print("输入非法")【例5-5】用pile方法改写例5-4。importrea=input("请输入一个整数:")regex=pile("^-?[1-9]\d*$")ifregex.match(a)!=None:print("输入合法")else:print("输入非法")2.字符匹配和搜索

（1）match()格式1：re.match(pattern,string,flags=0)格式2：正则表达式对象.match(string[,pos[,endpos]])【例5-6】re.match()函数举例importrea="abc123def"m=re.match("([a-z]*)([0-9]*)([a-z]*)",a)ifm!=None:print(m.group())print(m.group(0))print(m.group(1))print(m.group(2))print(m.group(3))else:print("没有匹配到")（2）search()函数格式1：re.search(pattern,string,flags=0)格式2：正则表达式对象.search(string[,pos[,endpos]])【例5-8】match函数和search函数的比较importres="howDOyoudo?"m1=re.match("DO",s,re.M|re.I)m2=re.search("DO",s,re.M|re.I)ifm1:print(m1.group(),m1.span())else:print("match=None")ifm2:print(m2.group(),m2.span())else:print("search=None")（3）findall()函数格式1：re.findall(pattern,string,flags=0)格式2：正则表达式对象.findall(string[,pos[,endpos]])【例5-9】findall函数举例importrer=re.findall("\w+","HappyNewYear,2023")print(r)（4）finditer()函数格式1：re.finditer(pattern,string,flags=0)格式2：正则表达式对象.finditer(string[,pos[,endpos]])【例5-10】finditer函数举例importrer=re.finditer("\w+","HappyNewYear")forxinr:print(x.group(),x.span())3.替换匹配的子串（1）sub()函数格式1：re.sub(pattern,repl,string,count=0,flags=0)格式2：正则表达式对象.sub(repl,string,count=0)【例5-11】把一个电话号码"0086-791-8127312"中的-字符删掉importrephone="0086-791-8127312"phonenum=re.sub("\D","",phone)print("电话号码是:",phonenum)（2）subn()函数格式

1：re.subn(pattern,repl,string,count=0,flags=0)格式

2：正则表达式对象.subn(repl,string,count=0)【例5-12】用subn()函数把一个电话号码"0086-791-8127312"中的-字符删掉。importrephone="0086-791-8127312"pattern=pile("\D")phonenum=pattern.subn("",phone,1)print("电话号码是:",phonenum)4.字符分割split()函数格式1：re.split(pattern,string,maxsplit=0,flags=0))格式2：正则表达式对象.split(string,maxsplit=0)【例5-13】将一个IP地址的四个数字拆分出来importreip="81"pattern=pile("\D")ipnum=pattern.split(ip)print(ipnum)5.5字符串应用举例【例5-14】从键盘输入一个18位的身份证号码，把其中的出生日期截取出来。分析：首先用正则表达式验证输入的身份证号码是否符合规则，直到输入合法的身份证号码。然后用字符串的切片截取生日即可。importreID=input("请输入18位的身份证号码:")m=re.match("^\d{17}([0-9]|X|x)$",ID)whilem==None:print("身份证号码不对，请重新输入!")ID=input("请输入18位的身份证号码:")m=re.match("^\d{17}([0-9]|X|x)$",ID)year=ID[6:10:]month=ID[10:12:]day=ID[12:14:]print("出生日期为："+year+"年"+month+"月"+day+"日")【例5-15】字符串加密。s1=input("请输入原字符串:")s2=""forcins1:ifc.isalnum():ifc.isupper():s2+=chr((ord(c)-ord('A')+2)%26+ord('A'))ifc.islower():s2+=chr((ord(c)-ord('a')+2)%26+ord('a'))ifc.isdigit():s2+=chr((ord(c)-ord('0')-3+10)%10+ord('0'))else:s2+=cprint("加密后的字符串为:",s2)第6章复合数据类型第6章复合数据类型6.1序列的通用操作6.2列表6.3元组6.4集合6.5字典复合数据类型序列类型字符串列表元组集合类型集合映射类型字典序列类型是一个元素向量，元素之间存在先后关系，通过序列中的索引(位置编号)来访问数据元素，元素之间不排他可重复。映射类型是“键-值”数据项的组合，每个元素是一个键值对，表示为(key,value)。集合类型是一个元素集合，元素之间无序、不重复。复合数据类型概述6.1序列的通用操作序列类型包括字符串(str)、列表(list)和元组(tuple)。a=“Monkey“#字符串b==['Alice','Ben','Candy','Mary','Lucy’]#列表c=(=(“Rat”,“OX”,“Tiger”,“Rabbit”,“Dragon”,“Snake”)#元组序列类型都可以进行索引、切片、序列相加、序列相乘以及成员资格检查等操作。Python还有计算序列长度、找出最大元素和最小元素等内置函数。6.1.1序列的索引序列名[索引]有两种索引方式：正向索引和反向索引例如:>>>str1="thisisastring">>>Lst1=["2022100123","张三","男",18]>>>tup1=("物理","化学","地理","生物","历史")>>>print(str1[0],Lst1[-1],tup1[3])t18生物6.1.2序列的切片切片就是取出序列中某个范围内的元素，得到一个新的序列，原序列不变。一般格式为：序列名[M:N:K]>>>Lst2=[1,2,3,4,5,6,7,8,9]>>>Lst2[1:4]#步长缺省为1，索引[1,4)结果：[2,3,4]>>>Lst2[:]#同lst2[::],步长缺省为1，取出从前往后所有元素[1,2,3,4,5,6,7,8,9]>>>Lst2[::-1]#步长为-1，取出从后往前所有元素[9,8,7,6,5,4,3,2,1]>>>Lst2[:-2:2]#步长为2,M缺省为0,取出从[0,-2）步长为2的元素[1,3,5,7]>>>Lst2[3::2]#步长为2,取出从3到末尾的步长为2的元素[4,6,8]>>>lst2[-1::-2]#步长为-2,N为第一个元素，取出从-1到0步长为-2的元素[9,7,5,3,1]6.1.3序列的计算1.序列相加使用加号+可以进行同类型序列的连接操作。例如：>>>[1,2,3]+['a','b','c']#列表相加[1,2,3,'a','b','c']>>>(4,5,6)+(7,8,9)#元组相加(4,5,6,7,8,9)>>>"abc"+"123"#字符串相加'abc123'6.1.3序列的计算2.序列相乘用整数n乘以序列会产生一个新的序列，在新序列中，原序列将重复n次。当n<1,将返回空序列。例如：>>>a=(1,2,3)>>>2*a(1,2,3,1,2,3)>>>-1*a()6.1.3序列的计算3.成员资格检查成员资格检查用于检查一个值是否在序列中，有in和notin两个运算符，返回True或False。例如：>>>tup1=("物理","化学","地理","生物","历史")>>>"音乐"intup1False>>>"音乐"notintup1True6.1.4序列处理函数1.len()、max()、min()函数len(s):返回序列s的元素个数min(s):返回序列s的最小元素max(s):返回序列s的最大元素以下Python表达式中，哪项的值与其它三项不同（

）。A．len("Nicetomeetyou".split()) B．len("Nice".split())C．sum（[1，2，1，0]）

D．max（[1，2，3，4]）2.index方法和count方法s.index(x[,i[,j]])：返回序列s中索引为第i到第j-1项元素中第一次出现元素x的位置。s.count(x)：返回序列s中出现x的次数。6.2列表列表（list）是Python中最常用的复合数据类型，可以完成大多数复合数据结构的操作。列表元素是可变的，也就是列表中的元素的值可修改，也可以增加元素或删除元素。字符串和元组的元素是不可变的。所以除了序列的通用操作外，列表还有许多专有的操作6.2.1列表的创建1.用[]创建列表列表是用方括号“[]”括起来、用逗号分隔的元素序列>>>elist=[]#创建空列表>>>names=['Alice','Ben','Candy','Mary','Lucy']>>>stud=["2022100212","张三",18,[88,77,89]]>>>print("{}的三门课的成绩是{},{},{}".format(stud[1],stud[3][0],stud[3][1],stud[3][2]))张三的三门课的成绩是88,77,89>>>names[::2]#通过切片访问列表中的元素['Alice','Candy','Lucy']6.2.1列表的创建2.用list()函数创建列表列表也可以用list()函数将range()对象、元组、字符串或其他可迭代类型的数据转换为列表。>>>numlist=list(range(1,6))#创建一个包含1到5的整数列表>>>numlist[1,2,3,4,5]>>>strlist=list("hello")#将字符串转为列表>>>strlst['h','e','l','l','o']>>>tlist=list((1,2,3,4))#将元组(1,2,3,4)转为列表>>>tlist[1,2,3,4] >>>elist2=list()#创建空列表>>>elist2[]列表的注意事项：列表必须通过显示的数据赋值才能生成，简单将一个列表变量赋值给另一个列表变量不会生成新的列表通过切片操作可以生成新的列表，不会改变原来的列表>>>lst1=[70,80,90]>>>lst2=lst1

>>>id(lst1),id(lst2)(50784384,50784384)>>>lst2[0]=72>>>lst1[72,80,90]>>>x=[1,2,3,4,5,6]>>>y=x[:]>>>y[1,2,3,4,5,6]>>>id(x),id(y)(51019904,51370112)6.2.2列表的专有操作1.列表元素的添加ls.append(x)方法：在列表末尾追加元素ls.insert(i,x)方法：在列表第i个位置增加新元素xls.extend(lst)方法：将列表lst元素追加到列表ls尾部“+=”运算符：

ls+=lst将列表lst元素追加到列表ls尾部“*=”运算符：ls*=n更新列表ls，其元素重复n次append、insert、extend、+=、*=这些操作在添加了新元素后，内存地址没有发生变化，属于原地操作，不会创建新的列表对象>>>names=['Alice','Ben']>>>id(names)51371264>>>names.append("Yoyo")#['Alice','Ben','Yoyo']>>>names.insert(2,"Lily")

#['Alice','Ben','Lily','Yoyo']>>>n=["张三","李四"]>>>names.extend(n)#['Alice','Ben','Lily','Yoyo','张三','李四’]>>>n1=["王五"]>>>names+=n1#与names=names+n1不等价#['Alice','Ben','Lily','Yoyo','张三','李四','王五’]>>>names*=2#结果为：[‘Alice’,‘Ben’,‘Lily’,‘Yoyo’,‘张三’,‘李四’,‘王五’，'Alice','Ben','Lily','Yoyo','张三','李四','王五’]>>>id(names)51371264下列Python程序的运行结果是（

）。s=[1,2,3,'a']s.append([4,5])print(len(s))A．2

B．4

C．5

D．66.2.2列表的专有操作2.列表元素的删除del语句dells：删除列表ls对象dells[i]：删除列表ls第i项的元素dells[i:j:k]：删除列表ls第i到第j-1项以k为步长的元素ls.pop(i)方法：返回列表ls第i项元素并删除该元素，缺省i删最后一个ls.remove(x)方法：将列表中第一个出现的元素x删除ls.clear()方法：

删除列表ls中的所有元素，把ls变为空列表6.2.2列表的专有操作>>>names=['Alice','Ben','Candy','Mary','Lucy']>>>delnames[0]>>>names['Ben','Candy','Mary','Lucy']>>>delnames[2:]>>>names['Ben','Candy']>>>delnames>>>names=['Alice','Ben','Candy','Mary','Lucy']>>>names.pop()'Lucy'>>>names.pop(0)'Alice'>>>names['Ben','Candy','Mary’]>>>names=['Alice','Ben','Candy','Ben','Lucy']>>>names.remove('Ben')>>>names['Alice','Candy','Ben','Lucy’]>>>names=['Alice','Ben','Candy','Mary','Lucy']>>>names.clear()>>>names[]以下代码的输出结果是（

）。list1=[1,2,3,4]list2=list1list2.clear()print(list1)A．[1,2,3,4]

B．1,2,3,4

C．[]

D．错误6.2.2列表的专有操作3.列表元素的修改可以通过索引或切片直接修改列表元素的值。ls[i]=xls[i:j:k]=lst当使用切片赋值将一个列表赋给另一个列表时，Python不要求两个列表长度一样，但遵循“多增少减”的原则。可以通过赋给更多或更少元素实现列表元素的插入或删除6.2.2列表的专有操作>>>a=[1,2,3,4,5]>>>a[2::]=[7,8,9,10]#把下标从2到所有的元素改为[7,8,9,10]>>>a[1,2,7,8,9,10]>>>a[0:2]=[6]#把下标为0和1的元素改[6]>>>a[6,7,8,9,10]6.2.2列表的专有操作4.对列表进行排序和逆置ls.sort(key=None,reverse=False)：reverse=True表示降序排列，reverse参数缺省，或reverse=False表示升序排列。key参数用于指定一个函数，此函数将在每个元素比较前被调用。ls.reverse()：

反转逆置列表ls中的元素。内置函数sorted(ls[,reverse=False])：将列表ls默认升序排列后生成的新列表返回，原列表ls的值不变。若reverse=True，表示降序。6.2.2列表的专有操作>>>s=[23,21,45,67,12,9]>>>s.reverse()>>>s[9,12,67,45,21,23]>>>s.sort()>>>s[9,12,21,23,45,67]>>>s.sort(reverse=True)>>>s[67,45,23,21,12,9]内置函数sorted(ls[,reverse=False])的举例如下：>>>s=[23,21,45,67,12,9]>>>t=sorted(s)>>>s[23,21,45,67,12,9]>>>t[9,12,21,23,45,67]字符串str="catdogtiger"，以下程序的输出结果是：（

）。str="catdogtiger"ls=str.split()ls.reverse()print(ls)A．'tiger','dog','cat’B．tigerdogcatC．NoneD．['tiger','dog','cat']6.2.3遍历列表1.用for循环语句遍历列表格式:for变量名in列表名：语句块【例

6‑1】用for循环遍历列表，将列表中的每个元素星期几的英文全称改为缩写，输出时用空格隔开。week_list=["Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"]i=0foriteminweek_list:week_list[i]=item[0:3]i=i+1foriteminweek_list:print(item,end="")6.2.3遍历列表2.用while循环语句遍历列表用while循环语句遍历列表时，需要先计算列表的长度，将获得的长度作为循环的条件,用索引访问列表元素。【例

6‑2】用列表的方法输出斐波那契数列：1,1,2,3,5,8…前10项，并计算这10项的和。lst=[1,1]i=2whilei<=10:lst.append(lst[i-1]+lst[i-2])i=i+1print(lst)i=0s=0whilei<len(lst):s+=lst[i]i=i+1print(s)lst=[1,1]i=2whilei<=10:lst.append(lst[i-1]+lst[i-2])i=i+1print(lst)print(sum(lst))6.2.4列表推导式列表推导式可以利用range对象、元组、列表、字典和集合等数据类型，快速生成一个满足条件的列表。语法格式如下：[表达式for迭代变量in迭代对象

[if条件表达式]]其中[if条件表达式]可缺省。将每个符合if条件的迭代变量计算一次表达式的值，这些值就是新生成的列表中的每个元素。1.不加if条件的列表推导式创建一个1到10的整数列表，代码如下：>>>a=[x+1forxinrange(10)]>>>a[1,2,3,4,5,6,7,8,9,10]>>>importrandom>>>b=[random.randint(0,100)foriinrange(10)]>>>b[76,17,98,10,56,22,43,2,66,86]2.加if条件的列表推导式创建一个1到20间奇数的平方的列表，代码如下：>>>b=[x*xforxinrange(1,21)ifx%2==1]>>>b[1,9,25,49,81,121,169,225,289,361]3.多重循环的列表推导式上面的列表推导式都只包含一个循环，实际上可以使用多重循环，举例如下：>>>c=[[x,y]forxinrange(3)foryinrange(3)]>>>c[[0,0],[0,1],[0,2],[1,0],[1,1],[1,2],[2,0],[2,1],[2,2]]【例63】用随机函数生成n个0-100的随机整数，降序排列输出。分析：用列表推导式生成由n个随机数组成的列表，然后用列表的方法sort对数据进行排序。代码如下：importrandomrandom.seed()n=eval(input("输入要生成多少个随机数："))alist=[random.randint(0,100)foriinrange(n)]print("排序前：",alist)alist.sort(reverse=True)print("排序后：",alist)6.3元组Python中元组是序列类型中比较特殊的类型，因为它一旦创建就不能被修改。元组类型在表达固定数据项、函数多返回值、多变量同步赋值、循环遍历等情况下十分有用。6.3.1元组的基本操作1.创建元组创建元组用使用圆括号“()”，所有元素放在一对圆括号“()”中，并用逗号“,”分隔；也可用tuple()函数将range()对象、列表、字符串或其他可迭代类型的数据转为元组。>>>tup0=()#空元组>>>tup1=("Rat","OX")#用圆括号创建元组>>>tup2="Horse","Sheep"#圆括号可省略>>>tup3=(1,2,3,"a","b","c")#元组中包含不同类型的数据>>>tup4=(100,)#只有一个元素时，逗号不能省略>>>tup5=tuple(range(5))>>>list1=[70,80,90,99]>>>tup6=tuple(list1)>>>tup7=tuple("hello")6.3.1元组的基本操作2.访问元组可以使用下标索引和切片来访问或获取指定的元素，但只能访问不能修改元素的值>>>tup6=(70,80,90,99)>>>print(tup6[0],tup6[-1],tup6[1:3])7099(80,90)>>>tup6[3]=100Traceback(mostrecentcalllast):File"<pyshell#6>",line1,in<module>tup6[3]=100TypeError:'tuple'objectdoesnotsupportitemassignment下面代码的输出结果是（

）。t1=('a','b','c',['a','b','c'])t1[-1][-1]='d'print(t1)A．('a','b','c',’d’)B．('a','b','c',['a','b','d’])

C．('a','b','c',['a','b','c'],'d')D．异常6.3.1元组的基本操作3.元组的常用内置函数和操作符元组可以使用所有适用于序列的通用操作符和函数，元组的常用内置函数有len()、max()、min()等，通用操作符+、*、in、notin同6.1.3节4.删除元组元组是不可变序列，无法删除元组中的元素，只能使用del命令删除整个元组对象【例67】获取用户输入的一组数据，采用逗号分隔输入，输出其中的最大值。data=eval(input("请输入一组数据，以逗号分隔："))m=data[0]foriindata:ifi>m:m=iprint("最大值是：",m)data=eval(input("请输入一组数据，以逗号分隔："))print("最大值是：",max(data))6.3.2元组与列表的转换元组和列表可以通过list()函数和tuple()函数实现相互转换。如果想要修改其元素值，可以将元组转换为列表，修改完毕后，再转换为元组。>>>tup=(1,2,3,4)>>>lst=list(tup)>>>lst.append(5)>>>lst[1,2,3,4,5]>>>tup=tuple(lst)>>>tup(1,2,3,4,5)6.4集合集合是包含0个或多个数据元素的无序组合。集合中的元素不可重复，元素类型只能是整数、浮点数、字符串、元组等不可变数据类型，且这些数据元素是无序的，没有索引位置的概念，不能切片。Python中的集合类型与数学中集合的概念一致，可对其进行交、并、差等集合运算6.4.1集合的创建1.使用花括号{}将多个用逗号隔开的数据括起来2.使用set()函数，它将range()对象、列表、字符串或其他可迭代类型的数据转换为集合，但会将重复的元素删掉>>>s1={1,2,3,4,5}>>>s2=set("happy")>>>s3=set([1,2,3,5,2])>>>s4=set()#空集合，注意不是{}，{}表示空字典。>>>s1,s2,s3,s4({1,2,3,4,5},{'p','a','y','h'},{1,2,3,5},set())设a=set([1,2,2,3,3,3,4,4,4,4])，则a.remove(4)的值是（）。A．{1,2,3}B．{1,2,2,3,3,3,4,4,4}C．{1,2,2,3,3,3}D．[1,2,2,3,3,3,4,4,4]以下不能创建集合的语句是（）。A．s1={}B．s2=set()C．s3=set(“abcd”)D．s4={1,2,3,4}6.4.2集合运算有4种基本操作：交集(&)、并集(|)、差集(-)、补集(^)运算符功能描述S&T或S.intersection(T)交集：返回一个新集合，包含同时在集合S和T中的元素。S|T或S.union(T)并集：返回一个新集合，包含集合S和T中的所有元素S-T或S.difference(T)差集：返回一个新集合，包含在集合S中但不在集合T中的元素S^T或S.symmetric_difference_update(T)补集：返回一个新集合，包含集合S和T中的元素，但不包含同时在这两集合中的元素S<=T或S.issubset(T)子集测试：若S与T相同或S是T的子集，返回True，否则返回False。S<T表示S是否是T的真子集S>=T或S.issuperset(T)超集测试：若S与T相同或S是T的超集，返回True，否则返回False。S>T表示S是否是T的真超集set1=set("字典"),set2=set("集合"),set1|set2的结果可能是（）。

A.{"字典集合"}B.{"典","字","集","合"}C."字典集合"D.["字典集合"]6.4.3集合的常用方法

方法或函数功能描述S.add(x)添加元素：若数据元素x不在集合S中，将x添加到S中S.clear()清空元素：移除集合S中的所有元素S.copy()复制集合：返回集合S的一个副本S.pop()随机删除元素：随机返回并移除一个元素，S为空时产生KeyError异常S.discard(x)删除指定元素：若x在集合S中，移除该元素；x不存在时，不报异常S.remove(x)删除指定元素：若x在集合S中，移除该元素；x不存在时，产生KeyError异常S.isdisjoint(T)若集合S和T没有相同元素，返回True，否则返回Falselen(S)返回集合S的元素个数xinS若x是S的元素，返回True，否则返回FalsexnotinS若x不是S的元素，返回True，否则返回False【例