Python编程基础(中国mooc)5

最新推荐文章于 2024-03-31 11:18:12 发布

gulie8

最新推荐文章于 2024-03-31 11:18:12 发布

阅读量2.2k

点赞数

分类专栏：书摘

本文链接：https://blog.csdn.net/gulie8/article/details/103162889

版权

书摘专栏收录该内容

26 篇文章 3 订阅

订阅专栏

字符串比较规则：

两个字符串按照从左至右的顺序逐个字符比较，如果对应的两个字符相同，则继续比较下一个字符。
如果找到了两个不同的字符，则具有较大ASCII码的字符对应的字符串具有更大的值。
如果对应字符都相同且两个字符串长度相同，则这两个字符串相等。
如果对应字符都相同但两个字符串长度不同，则较长的字符串具有更大的值。

字符串切割：

split方法:

使用字符串中的split方法可以按照指定的分隔符对字符串进行切割，
返回由切割结果组成的列表。split方法语法格式为：str.split(sep=None, maxsplit=-1)
其中，str是待切割的字符串；sep是指定的分隔符，可以由一个或多个
字符组成，其默认值为None，表示按空白符（空格、换行、制表符等）
做字符串切割；maxsplit决定了最大切割次数，如果指定了maxsplit值
则最多可以得到maxsplit+1个切割结果，其默认值为-1，表示不对最大
切割次数做限制。

splitlines方法:

除了split方法，字符串中还提供了一个splitlines方法，该方法固定以
行结束符（'\r'、'\n'、'\r\n'）作为分隔符对字符串进行切割，返回由切
割结果组成的列表。splitlines的语法格式为：str.splitlines([keepends])

其中，str是待切割的字符串；keepends表示切割结果中是否保留最后
的行结束符，如果该参数值为True，则保留行结束符，否则不保留
（默认为False，即在切割结果中不保留行结束符）。

字符串检索和替换：

字符串检索：

字符串中提供了4种用于进行字符串检索的方法，分别是find、index、
rfind、rindex，它们的语法格式分别为：
str.find(sub[, start[, end]])
str.index(sub[, start[, end]])
str.rfind(sub[, start[, end]])
str.rindex(sub[, start[, end]])

字符串替换：

使用字符串中的replace方法可以将字符串中的指定子串替换成其他
内容，replace方法的语法格式为：str.replace(old, new[, max])

其中，str是要做替换操作的字符串；old和new分别是要替换的子串和
替换成的字符串；max是最多替换的子串数量，如果不指定max参数则
将所有满足条件的子串替换掉。replace方法返回替换后的字符串。

s1='abcadca'

s1.replace('a','100')
Out[148]: '100bc100dc100'

s1.replace('a','100',1)
Out[149]: '100bcadca'

去除字符串空格和大小写转换：

去除字符串空格：

如果要去除字符串头部和尾部的空格，则可以使用字符串中的strip、
lstrip和rstrip方法，它们的语法格式为：
str.strip() #去除str中头部和尾部的空格
str.lstrip() #去除str中头部的空格
str.rstrip() #去除str中尾部的空格

s1
Out[158]: 'abcadca '

s1.strip().strip('a')
Out[159]: 'bcadc'

去除所有的字符串空格：

如果要去除所有的空格，则可以使用replace方法，即：
str.replace(' ','') #去除str中所有的空格

s1
Out[163]: 'a bc adca '

s1.replace(' ','')
Out[164]: 'abcadca'

大小写转换：

字符串中有capitalize、lower、upper、swapcase等大小写转换
相关的方法，它们的语法格式分别为：

str.capitalize() #将字符串中的第一个字母大写，其他字母都小写
str.lower() #将字符串中的所有字母都小写
str.upper() #将字符串中的所有字母都大写
str.swapcase() #将字符串中的小写字母变大写、大写字母变小写

复制字符串：

由于字符串是不可变类型，无法修改字符串中的某个元素值，不存
在修改一个字符串值会影响另一个字符串的问题。
因此，直接用赋值运算符“=”实现字符串复制功能即可。

连接字符串：

Ø 作为一种序列数据，直接使用拼接运算（+）即可实现两个字符串
的连接。
Ø 另外，还可以使用字符串中的join方法将序列中的元素以指定的字
符连接成一个新的字符串，join方法的语法格式为：str.join(seq)
Ø 其中，seq是一个序列对象，str是使用的连接符。join方法返回连
接后的字符串。

','.join(list('defg'))
Out[167]: 'd,e,f,g'

获取字符串长度：

使用len函数可以计算一个字符串中包含的字符数量（即字符串长度），len函数的语法格式为：len(str)

测试字符串的组成部分：

如果需要判断一个字符串A是否是另一个字符串B的组成部分（即子串），可以直接使用前面介绍的字符串检索方法，检索成功，则A是B的子串，否则A不是B的子串。另外，也可以使用更简洁的in运算符。

str1='abc'
if 'a' in str1:
print('a在str1里！ or a是str1的子串！')

if str1.find('a')!=-1:
print('a在str1里！ or a是str1的子串！')

out:
a在str1里！ or a是str1的子串！
a在str1里！ or a是str1的子串！

占位符和format方法：

占位符：

format方法：

使用字符串中的format方法也可以进行字符串的格式化操作，其语法格式为：str.format(*args, **kwargs)
其中，str是用于格式化的字符串，可以包含由大括号{}括起来的替换字段。每个替换字段可以是位置参数的数字索引，也可以是
关键字参数的名称。format方法返回的是格式化的字符串副本（即通过format方法调用并不会改变str的值）。

'{name}的数学成绩是{shuxue},语文成绩是{yuwen}'.format(shuxue=100,yuwen=90,name='小张')
Out[189]: '小张的数学成绩是100,语文成绩是90'

'{0}的数学成绩是{1},语文成绩是{2}'.format('小张',100,90)
Out[190]: '小张的数学成绩是100,语文成绩是90'

另外，在format方法格式化字符串时，字符串的替换字段中还可以包含对实参属性的访问。

1. Python 中，创建字符串时，可以使用单引号、双引号和三引号。
2. Python 中，使用字符串的split 方法可以按照指定的分隔符对字符串进行切割，
返回由切割结果组成的列表。
3. 可以利用运算符+连接两个字符串，也可以使用join 方法将序列中的元素以指定
的字符连接成一个新的字符串。
4. Python 中正则表达式中的普通字符需要做精确匹配，而特殊字符指定的匹配模式
则对应了用于模糊匹配的规则。
5. Python 中正则表达式的特殊序列是由 \ 和一个字符构成。
6. 使用Python 提供的re 模块，可以实现基于正则表达式的模糊匹配。
7. compile 函数用于将一个字符串形式的正则表达式编译成一个正则表达式对象，
供 match、search 以及其他一些函数使用。
8. re 模块中的match 函数用于对字符串开头的若干字符进行正则表达式的匹配。匹
配成功，返回一个Match 对象；匹配失败，返回None 。
9. re 模块中的finditer 函数与re.findall 函数功能都是用于在字符串中找到所有与正
则表达式匹配的子串，区别在于re.findall 函数返回列表形式的结果，而
re.finditer 返回迭代器形式的结果。

A. find 方法是在指定检索范围中按照从左至右的顺序检索，找到子串第一次出现
的位置
B. rfind 方法在指定检索范围中按照从右至左的顺序检索，找到子串第一次出现
的位置
C. index 与find 作用相同，rindex 与rfind 作用相同，只是find 和rfind 在检
索不到字符串时返回-1，而index 和rindex 会引发ValueError 异常

A. 使用字符串中的replace 方法可以将字符串中的指定子串替换成其他内容
B. str 是要做替换操作的字符串，old 和new 分别是要替换的子串和替换成的字
符串
D. replace 方法返回替换后的字符串

print(len("中国\"china"))的输出结果是8；

A. ^用于匹配字符串开头的若干字符
B. *用于匹配前一个模式0 次或多次
C. ?用于匹配前一个模式0 次或1 次

A. \A 匹配字符串开头的若干字符，功能同^
B. \d 匹配任一数字字符，等价于[0-9]
D. \D 与\d 作用相反，匹配任一非数字字符，等价于[^0-9]

18. 写出下面程序的运行结果。
s1="I am a student."
s2="C++90 分Python88 分Java85 分"
s3="I am a student.\nI like programming.\n"
print(s1.split())
print(s2.split("分"))
print(s2.split("分",2))
print(s3.splitlines())
答：运行结果为：
['I', 'am', 'a', 'student.']
['C++90', 'Python88', 'Java85', '']
['C++90', 'Python88', 'Java85 分']
['I am a student.', 'I like programming.']
19. 写出下面程序的运行结果。
str=" a b c "
print("123"+str.strip()+"456")
print("123"+str.lstrip()+"456")
print("123"+str.rstrip()+"456")
答：运行结果为：
123a b c456
123a b c 456
123 a b c456

20. 写出下面程序的运行结果。
n,f=34,56.78
print("%d,%o,%x"%(n,n,n))
print("%f,%e"%(f,f))
r=5
s=3.14*r*r
s1="半径为{0}的圆面积为{1}"
s2="半径为{radius}的圆面积为{area}"
print(s1.format(r,s))
print(s2.format(area=s,radius=r))
答：运行结果为：
34,42,22
56.780000,5.678000e+01
半径为5 的圆面积为78.5
半径为5 的圆面积为78.5
21. 写出下面程序的运行结果。
import re
pattern=re.compile(r'Student', re.I) #生成正则表达式对象
r1=pattern.match('Students study programming')
r2=pattern.match('I am a student！',3)
r3=pattern.match('I am a student！',7)
r4=re.search(r'Student','I am a student',re.I)
r5=re.match(r'Student','I am a student',re.I)
print(r1)
print(r2)
print(r3)
print(r4)
print(r5)

答：运行结果为：
<_sre.SRE_Match object; span=(0, 7), match='Student'>
None
<_sre.SRE_Match object; span=(7, 14), match='student'>
<_sre.SRE_Match object; span=(7, 14), match='student'>
None

22. 写出下面程序的运行结果。
import re
str='''sno:#1810101#,name:#李晓明#,age:#19#,major:#计算机#
sno:#1810102#,name:#马红#,age:#20#,major:#数学#'''
rlt=re.search(r'sno:#([\s\S]*?)#[\s\S]*?major:#([\s\S]*?)#', str, re.I)
if rlt: #判断是否有匹配结果
   print('匹配到的整个字符串:', rlt.group())
   print('sno:%s, startpos:%d, endpos:%d'%(rlt.group(1), rlt.start(1),rlt.end(1)))
   print('major:%s, startpos:%d, endpos:%d'%(rlt.group(2), rlt.start(2),rlt.end(2)))
   print('所有分组匹配结果:', rlt.groups())
else:
   print('未找到匹配信息')

答：运行结果为：
匹配到的整个字符串: sno:#1810101#,name:#李晓明#,age:#19#,major:#计算
机#
sno:1810101, startpos:5, endpos:12
major:计算机, startpos:41, endpos:44
所有分组匹配结果: ('1810101', '计算机')

23. 写出下面程序的运行结果。
import re
html='''%abc%%def%python(ghi)'''
content=re.sub(r'%[\s\S]*%', '&', html)
content=content.strip()
print('替换之后的内容为: ', content)
content2=re.subn(r'%[\s\S]*%', '&', html)
print('替换之后的内容及替换次数为: ', content2)

答：运行结果为：
替换之后的内容为: &python(ghi)
替换之后的内容及替换次数为: ('&python(ghi)', 1)

24. 下面程序从键盘输入一个字符串，然后将其中的大写字母转换为小写字母，小写
字母转换为大写字母，其他字符不变，请将程序填写完整。
str = input("请输入一个字符串")
ns=''
for c in str:
   if c>='A' and c<='Z':
       ns+=c.lower()
   elif c>='a'and c<='z': 或 'a'<=c<='z':
       ns+=c.upper()
   else:
       ns+=c 或ns=ns+c
print(ns)

1. Python 中，通过列表中的index 方法可以根据指定值查找第一个匹配的列表元素
的位置。
2. Python 中，通过列表中的insert 方法可以将一个元素插入到列表的指定位置。
3. 若在列表的最后添加新元素，则可以直接使用列表的append 方法。
4. 使用del 语句可以删除某个变量或列表中的某个元素。
5. 使用max 方法可以获取一个列表中最大元素的值。
6. 使用min 方法可以获取一个列表中最小元素的值。
7. 使用列表中的count 方法可以统计某个值在列表中出现的次数。
8. Python 中集合有两种插入元素的方法，分别是add 和update。
9. 集合中的issubset 方法可以用于判断一个集合是否是另一个集合的子集。
10. 集合中的issuperset 方法可以用于判断一个集合是否是另一个集合的父集。
11. 使用del 可以删除某个元素，也可以使用字典中的pop 方法删除指定键的元素。
12. 使用字典中的clear 方法可以一次将一个字典中的所有元素都清除。
13. 判断字典中是否存在某个键可以使用字典中的get 方法，也可以使用成员运算符
in。
14. 已知ls=[x*2 for x in range(5)]，则print(ls)的输出结果为[0,2,4,6,8]。
15. 迭代器是指可以通过next 函数不断获取下一个值的对象。

16. 下列属于可变类型的是（A）
A. 列表
B. 元组
C. 字符串
D. 数字

B. 列表是用一对中括号括起来的多个元素的有序集合，各元素之间用逗号分隔，
元组是用一对小括号括起来的多个元素的有序集合，各元素之间用逗号分隔

A. Python 中，通过赋值运算实际上是将两个变量指向同一个对象，而不是将一
个变量的值赋给另一个变量。
B. 采用元素截取的方法，可以根据一个已有列表对象复制出另一个新的列表对
象，后面对两个对象的操作完全独立
D. 为了真正实现列表的复制操作，可以使用Python 在copy 模块中提供的
deepcopy 函数

19. 已知学生类中有属性name 和sno，列表ls 中含有若干学生对象，若要求列表ls
按照学生的姓名的降序排序，相应的语句是（A）
A. ls.sort(key=lambda stu:stu.name,reverse=True)

A. 可以使用一对大括号{}或set 函数创建集合
B. 可以使用一对大括号{}或dict 函数创建字典
D. 可以使用{}或dict()创建空字典

21. 已知定义：
d=dict(sno='1810100', name='李晓明', age=19,t=(3,4),s=[3,4,5])
则len(d)的值为（A）
A. 5

22. 已知字典d，获取字典中键值集合的语句是（C）
C. d.keys()

A. 将列表生成表达式中的一对中括号改为一对小括号即可得到生成器
B. 对于生成器对象，也可以像其他可迭代对象一样使用for 循环遍历对象中的每
一个元素
C. 如果生成元素的方法比较复杂，不适合用for 循环方式实现，我们还可以借助
yield 关键字利用函数实现生成器的功能

B. 列表是可迭代对象、但不是迭代器；而生成器既是可迭代对象、又是迭代器

25. 写出下面程序的运行结果。
t1=("zhangsan",18,95.5)
t2=()
t3=(33,)
t4=([44,55,66])
t5=t1+t3
print(t1,t2,t3,t4,t5)
print(t5)
print(max(t4))
print(min(t4))

答：运行结果为：
('zhangsan', 18, 95.5) () (33,) [44, 55, 66] ('zhangsan', 18, 95.5, 33)
('zhangsan', 18, 95.5, 33)
66
44

26. 写出下面程序的运行结果。
ls=[1,2,3,2,3,4]
print(ls.index(4))
print(ls.count(3))
print(max(ls))
print(min(ls))
print(len(ls))
del ls[3]
print(ls)
ls.sort(reverse=True)
print(ls)
答：运行结果为：
5
2
4
1
6
[1, 2, 3, 3, 4]
[4, 3, 3, 2, 1]

27. 写出下面程序的运行结果。
import copy
s1=[4,5,6]
s2=s1
s2[1]="nk"
print(s1,s2)
s3=s1[1:3]
s3[1]="cn"
print(s1,s3)
s4=copy.deepcopy(s1)
s4[1]=333
print(s1,s4)
s5=[4,[5,6]]
s6=s5[1:3]
s5[1][0]="cn"
print(s5,s6)
s7=copy.deepcopy(s5)
s7[1]="nk"
print(s5,s7)
答：运行结果为：
[4, 'nk', 6] [4, 'nk', 6]
[4, 'nk', 6] ['nk', 'cn']
[4, 'nk', 6] [4, 333, 6]
[4, ['cn', 6]] [['cn', 6]]
[4, ['cn', 6]] [4, 'nk']

28. 写出下面程序的运行结果。
s1={1,2,3}
s2=set([2,3,3,4])
s1.add(3)
s2.update('ab')
s3=s1.intersection(s2)
s4=s1.union(s2)
s5=s1.difference(s2)
s6=s1.symmetric_difference(s2)
print(s1)
print(s2)
print(s3)
print(s4)
print(s5)
print(s6)
答：运行结果为：
{1, 2, 3}
{2, 3, 4, 'b', 'a'}
{2, 3}
{1, 2, 3, 4, 'a', 'b'}
{1}
{1, 4, 'b', 'a'}

29. 写出下面程序的运行结果。
d1={'name':"zhangsan",'sno':"001",'score':99}
d2=dict().fromkeys(['radius','height'],0)
print(d1)
print(d2)
d1.update({'age':19})
d2.update(radius=10)
print(d1)
print(d2)
del d1['age']
height=d2.pop('height','not found')
print(d1)
print(d2)
print(height)
print(len(d1))
print(len(d2))
答：运行结果为：
{'name': 'zhangsan', 'sno': '001', 'score': 99}
{'radius': 0, 'height': 0}
{'name': 'zhangsan', 'sno': '001', 'score': 99, 'age': 19}
{'radius': 10, 'height': 0}
{'name': 'zhangsan', 'sno': '001', 'score': 99}
{'radius': 10}
0
3
1

30. 写出下面程序的运行结果。
s1=[1,2,3,4,5,6,7,8,9,10]
s2=list(range(10,20))
s3=s1[2:8:2]
s4=s2[-8::-2]
print(s1)
print(s2)
print(s3)
print(s4)
答：运行结果为：
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
[3, 5, 7]
[12, 10]

31. 该程序用到字典的浅拷贝和深拷贝，已知程序运行结果，请将程序填写完整。
import copy
d1={'name':"zhangsan",'sno':"001",'score':{'math':99,'C++':88}}
d2=d1.copy()
d3=copy.deepcopy(d1)
d1['name']="li"
d1['score']['C++']=90
print(d1)
print(d2)
print(d3)
已知程序运行结果为：
{'name': 'li', 'sno': '001', 'score': {'math': 99, 'C++': 90}}
{'name': 'zhangsan', 'sno': '001', 'score': {'math': 99, 'C++': 90}}
{'name': 'zhangsan', 'sno': '001', 'score': {'math': 99, 'C++': 88}}