Python編程基礎(中國mooc)5

字符串比較規則：

兩個字符串按照從左至右的順序逐個字符比較，如果對應的兩個字符相同，則繼續比較下一個字符。
如果找到了兩個不同的字符，則具有較大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}}