第一次測試：
1.計算機是按照摩爾定律發展的。
2.C語言需要通過編譯方式進行執行。（T）
3.python語言通過解釋執行源代碼。
4.python是一種靜態語言。（F）
第二次測試：
1.python是(1991)年誕生的。
2.python3.x版本可以兼容python2.x版本（F）
3.idle是python自帶的IDE。
第四次測試：
1。python是一門通用，腳本，開源，跨平台，多模型，膠水或粘性語言
2.python的編譯方式有交互式和文件式。
3.python是一門超級語言。
4.請用文件方式編寫python程序，繪制一個五角星。
第五次測試：
1.python采用縮進來表示程序的格式框架。
2.python中縮進是語法的一部分，如果縮進不正確，會導致程序運行錯誤。
3.縮進是表達代碼間包含層次關系的唯一手段。（T）
4.python一段代碼可以采用4個空格和一個tab混合使用模式表示縮進。（？）
5.python以(#)開頭表示單行注釋，以“”” “””開頭和結尾表示多行注釋。
6.python可以采用保留字對變量進行命名（F）
7.python命名對大小寫敏感，也就是說大寫和小寫表示不同的名字。（T）
8.python命名首字符可以是數字（F）
9.為防止語法歧義，python需要規定數據類型（F）
10.python可以采用（單引號）和（雙引號）表示字符串。
11.IF是python的保留字（F）
12.C=“請輸入帶有符號的溫度值”，請問想單個獲取這個字符串中額“請”的索引方式應為：C[0]或者C[-11].
13.C=“請輸入帶有符號的溫度值”,切片C[1:3]獲取的是字符串是哪些字符？ 輸入
14.C=“請輸入帶有符號的溫度值”，C[0:-1] 獲取的是字符串中的哪些字符？ 請輸入帶有符號的溫度
15.python采用input()進行輸入（T）
16.eval("2+3")的結果是：5
第六次測試：
下面哪些是python的整數類型：ABDE
A 234 B-0b1101 c0b1102 d0o234 d0x9a
2.IDLE中輸入0.1+0.2結果顯示為0.3000000000000000004，這是bug，（F）
3.python中浮點數類型是有大小限制的，但實際運算中這個可以忽略不計。（T）
4.如何解決輸入“0.1+0.2==0.3”輸出“false”的問題？ round（0.1+0.2==0.3）
5.在python中，0.089可以用8.9e-2或者8.9E-2表示
6.python可以進行復數運算（T）
7.python中兩個整數x和y。x/y的結果是一個浮點數（T）
8.x**y可以進行開方運算（T）
9.python中運行x=4.57+5J，123+x會報錯，因為不同數據類型不能混合運算（F）
第七次測試：
1.“請輸入本地的地名” [1::2]的輸出結果是： 輸本的名
2.python語言中字符串使用一下那些符號進行表示？ABCD
A一對單引號 B一對雙引號 C一對三單引號 D一對三雙引號
3.C=“一二三四五六七八九”，C[1：：-1]得到的結果是
4.python字符串的編碼方式為：Unicode編碼
5.一對單引號和一對雙引號表示的多行字符串，如果不進行任何操作，就可認為是多行注釋。
第八次測試：
1.python安裝擴展庫常用的工具是pip和conda，其中后者需要安裝python集成開發環境Anaconda3之后才可以使用。
2.python程序文件擴展名主要有.py和.pyw兩種，其中.pyw常用於GUI程序
3.使用pip工具升級科學計算擴展庫numpy的完整命令是：pip install --upgrade numpy
4.使用pip工具把本機已經安裝的python擴展庫以及版本信息輸出掃文本文件requirements.txt中的完整命令是：pip freeze > requirements.txt
5.使用pip工具查看當前已經安裝的python擴展庫的完整命令是：pip list
6.列表，元組，字符串是python中的有序序列。
7.查看變量類型的python內置函數是type()和isinstance()
8.查看變量內存地址的python內置函數是：id（）
9.python運算符用來計算集合並集的是|
10.如果想得到輸出C:\windows\notepad.exe課采用哪些語句？
print（‘C:\windows\\notepad.exe’）
print(r'C:\windows\notepad.exe')
11.python可以計算‘m’+7（F）
12.（1,2,3）*3的結果是（1,2,3,1,2,3,1,2,3）
13.range(2,5,1)對應於哪個數列？ 2,3,4
14.a={1,2,3},b={3,1,2},輸入a==b結果是True
第九次測試：
1.python交互模式下一次可以執行（1）條語句。
2.windows系統如何進入命令提示符環境？ 在開始菜單中輸入cmd並回車，或者在相應的文件夾下同時按下shift+鼠標右鍵
3.python中處理的一切都是對象（T）
4.python中的非內置對象可以直接使用（F）
5.python的類和函數兩種對象均可調用（T）
6.python總下列屬於不可變序列：字符串和元組
7.3 and 5 輸出為：5
8.3 in [1,2,3],'a' 輸出結果為：（True,'a'）
9.3 in [1,2,3,'a'] 輸出結果為：True
10,x=3+4,7輸出結果是：（7,7）
第九（2）次測試：
1.查看指定對象的所有成員用函數dir()
2.可以使用chr('a') (F)
3.list(str([1,2,3,4])) 輸出結果任然是[1,2,3,4] (F)
4.x=max('1121','3434','9','92') 輸出結果為 92
5.x=min('1121','3434','9','92') 輸出結果為 1121
6.x=['1121','3434','9','92'] max(x,key=int) 輸出結果為：3434
7.在python3.x中使用input()返回的都是字符串，通常需要經過轉換格式才能用於后續程序。
第十次測試：
1.del()命令既可以刪除列表中的一個元素，也可以刪除整個列表。
2.表達式int('123',8)的值為83
3.表達式int('123')的值是123
4.python3.x語句print（1,2,3，sep=“：”）的輸出結果是1:2:3
5.表達式8**（1/3）的值是2
6.python內置函數len（）可以返回列表，元組，字典，集合，字符串以及range對象中元素的個數
7.表達式3|5的值是7
8.表達式13/4的值是3
9.表達式-13/4的值是-4
10.表達式type({3})結果是set
11.表達式5>3 is False的值是False
12.表達式{1,2,3,4}-{2,4,5}的值為{1,3}
13.寫代碼應該盡量減少空行和空格，讓代碼緊湊一些（F）
14.請使用python編程實現1+2+3+。。。+100的加法 sum(range(101))
第十二次測試：
1.在jupyter notebook中編寫python代碼時，后面的cell不能訪問前面cell中定義的變量（F）
2.下面是正確的python標准庫對象導入方式是：from math import sin 和from math import *
3.已知x=[1,2,3],執行語句x.append(4)之后，x的值是[1,2,3,4]
4.x=[1,2,3,4,5,6,7],那么x.pop() 結果是7
5.x=[1,2]和y=[3,4] 那么x+y的值是[1,2,3,4]
6.sum(i*I for i in range(3))的結果是5
7.for i in range(3): print(2,end=",") 的結果是 2,2,2，
8.集合的元素可以是列表（F）
9.集合中的元素可以是集合（F）
10.在字典和集合中新增和刪除元素速度比較快（T）
11.列表中的各個元素的數據類型可以各不相同（T）
12.a=[2,4,6] b=[1,2,2],a.extend(b)的值是[2,4,6,1,2,2]
13.a=[1,4,5,'f',5] a.remove(5) a的值是[1,4,'f',5]
14.a=list((1,3,5,7)) b=a*3 b的值是[1,3,5,7,1,3,5,7,1,3,5,7]
15.a=[1,4,3,2] del a[1] a的值是[1,3,2]
16.列表最好采用從后往前的順序才不會出錯。（T）
17.如果列表a中各個元素都是可變數據類型，b=a，改變b中元素，列表a會發生同樣的變化，反之亦然。（T）
18.如果列表a中的各個元素都是可變數據類型，b=copy.deepcopy(a)，改變b中的元素，列表a會發生同樣的變化，反之亦然（F）
19,如果想從列表a=[1,2,3,4,2,3]中刪除第5個元素2使得a=[1,2,3,4,3] ，可以使用什么語句？ del a[4]或者a.pop(4)
20.現有一列表lst=[5,66,3,4,8],如果想使得列表lst個元素按照降序排列，應該使用什么語句？lst.sort(reverse=True) 或者lst=sorted(lst,reverse=True)
第十三次測試：
1.vex[[1,2,3],[4,5,6],[7,8,9]] [num for elem in vec for num]可以完成嵌套列表vec內元素的平鋪，其中第二條語句中的‘vec’,'num','elem'均可以改成其他的名字（F）
2.import os [a for a in os.listdir('.') if a.endswith(('.dox','.docx'))] 可以得出當前目錄下的所有文檔（T）
3.在python中，我們可以使用語句a，b=b,a交換兩個變量的值（T）
4.python 3.5以上的版本對將a=[1,5,3]和b=（66,5,7）中的元素組合在一起形成新的列表[1,5,3,66,5,7],可以使用語句[*a,*b] 和a.extend(b)
5.生成器對象，map對象，filter對象都無法再次訪問已經訪問過的元素（T）
6.表達式[x for x in [1,2,3,4,5] if x%2==1]的值為 [1,3,5]
7.python3.5版本以上運行表達式list(map(list,zip(*[[1,2,3],[4,5,6]])))的結果是[[1,4],[2,5],[3,6]]
8.[index for index ,value in enumerate([3,5,7,3,7])] if value==max([3,5,7,3,7]) 結果是[2,4]
9.已知vec=[[1,2],[3,4]],則表達式[[row[i] for row in vec] for i in range(len(vec[0])) 結果是[[1,3],[2,4]]
第十五次測試：
1.創建一個空集合可以使用語句 a=set()
2.a=dict(name='Lily',age=31) 創建的字典可能是：{‘name’:'Lily','age':31}
3.想要返回字典的鍵值對，應使用字典對象的方法 items()
4.字典也有推導式，外面采用大括號，總體與列表推導式類似（T）
5.想在集合里面添加一個元素，采用集合方法 add()
6.集合的元素可以是列表（F）
7.使用語句a=set（[0,1,2,3,0,1,2,7,8]），得到的a是{0,1,2,3,7,8}
8.python中字典的鍵不允許重復（T）
9.python中字典的“值”不允許重復（F）
10.列表可以作為字典的鍵（F）
11.集合支持雙向索引，-1表示最后一個元素的下標（F）
12.對於關鍵字in，集合的測試速度比列表快的多（T）
13表達式a={}得到的是空字典
14.lst1=['jay','jj'] lst2=['周傑倫'，‘林俊傑’] a={lst1[i]:lst2[i] for i in range(len(lst1))} print(a) 的結果是{‘jay’:'周傑倫','jj':'林俊傑'}
15.lst=[1,-1,8,-8,12,-12] s={abs(i) for i in lst} print(s)的結果是{8,12,1}
16.推導式有很多種，比如列表推導式，字典推導式，集合推導式，和元組推導式。（F）
第十六次測試：
1.sorted([1,2,3],reverse=True)==reversed([1,2,3])執行結果為False。
2.C=‘python’ C[:-1]的結果是‘pytho’
3.sorted([111,233],key=lambda x:-len(str(x)))的值為：[111,33,2]
4.max([111,22,3],key=str)的值為：3
5.語句x=3，執行后的結果是（3，）
6.x=[3,5,7],那么執行語句x=x.sort(reverse=True)之后，x的值為None
7.已知列表x=[1,3,2],那么執行語句a,b,c=map(str,sorted(x))之后，c的值為‘3’
8.x=([1],[2]),那么執行語句x[0].append(3)后的值為([1,3],[2])
9.已知x=[1:9,5:2],那么執行語句x[3]=3之后，表達式sorted(x.items())的值為[(1,9),(3,3),(5,2)]
10.表達式sorted({'a':3,'b':9,'c':78})的值為['a','b','c']
11.sorted({'a':3,'b':9,'c':78}).value())的值是[3,9,78]
第十八次測試：
1.‘ab’ in ‘acbed’的值為：False
2.關鍵字in用於測試一個對象是否為可迭代對象的元素（T）
3.表達式3<5>2的值是True
4.已知x={‘a’:'b','c':'d'},那么表達式'b' in x的值為False
5.表達式3 or 5的值為 3
6.表達式0 or 5的值為 5
7.對於帶有else子句的for循環和while循環，當循環因循環條件不成立而自然結束時，會執行else語句。
8.在循環語句中，break語句的作用是提前結束本層循環，continue語句是提前進入下一次循環
9.表達式5 if 5>6 else (6 if 3>2 else 4)的值是6
10.表達式5 if 5>6 else(6 if 1>2 else 4) 的值是4
第十九次測試：
1.在python中，字符串屬於不可變序列類型，使用單引號，雙引號，三單引號，三雙引號作為界定符，並且不同的界定符之間可以互相嵌套（T）
2.字符串可以直接修改內容（F）
3.python3.x對中文支持不夠，在處理中文時需要在不同的編碼格式之間進行必要的轉換。（F）
4.對於短字符串，python支持駐留機制，即相同的字符串在內存中只有一個副本，長字符串不具有這個特性。（T）
5.在格式化字符串時，優先考慮使用format()方法
6.在python3.6x以上版本中下列語句
width=3
precision=3
value=17/3
f‘result：{value:{width}.{precision}}’
的結果是 ‘result:5.67’
7.上一題的最后一句等價於：print('result:{0:{1}.{2}}'.format(value,width,precision))
第二十一次測試：
1.字符串的方法lower(),replace().strip()方法可以修改字符串內容（F）
2.字符串的strip(),rstrip()和lstrip()方法是將括號內的字符串參數作為一個整體看待，對比原字符進行刪除（F）
3.s='aaaafdadfssbb' s.strip('afd') 的結果是 ‘ssbb’
4.‘123a2c’.isalpha()結果是 False
5.‘123a2c’.isalnum()結果是True
6.‘1234.0’.isdigit()結果是False
7.‘一三十八’.isnumeric()結果是True
第二十三次：
1.表達式re.split('\.+','alpha.beta...gamma..delta')的值為 ['alpha','beta','gamma','delta']
2.已知x='a234b123c',並且re模塊已經導入，則表達式re.split('\d+',x)的值為['a','b','c']
3.上一題的x如果是使用表達式','.join(re.split('\d+',x))的結果是‘a,b,c’
4.表達式re.findall('(\d)\1+','33abcd112')的值為['3','1']
5.表達式re.sub('\d+','1','a12345bbbb67c890d0e')的值為‘a1bbbb1c1d1e’
6.正則表達式元字符(+)表示之前的字符串或子模式1次或多次出現
第二十五次測試：
1.表達式''.join(re.split(['sd','asdssfff']))的值為：‘afff’
2.假設已經導入re模塊，那么語句print(re.match('abc','defg'))的結果是None
3.當字符串串前加字母（r）或者（R）時，不對其中的任何字符串進行轉義。
4.表達式re.findall('\d+','abcd1234')的值是 ['1234']
5.表達式re.findall('\d+?','abcd1234‘)的值是['1','2','3','4']
第二十六次測試：
1.一個函數可以沒有形參也就是可以不加后面的圓括號，這樣表示一個函數不接受參數（F）必須要帶圓括號
2.def f(a=1,b,c=2)語法正確（F）默認值參數必須在非默認值參數的后面
3.不論return語句出現在函數的什么位置，一旦可以執行將直接結束函數的執行（T） return函數用來從一個函數中返回一個，並結束函數
4.調用帶有默認值參數的函數時，不能為默認值參數傳遞任何值，必須使用函數定義時設置的默認值。（F）
5.已知表達式x=[[1,3,3],[2,3,1]] 那么表達式sorted(x,key=lambda item:item[0]+item[2])的值為[[2,3,1],[1,3,3]]
對於[1,3,3] item[0]+item[2]=1+3=4
對於[2,3,1] item[0]+item[2]=2+1=3
3<4,所以小的放前面，即[2,3,1]放前面
6.已知表達式x=[[1,3,3],[2,3,1]] 那么表達式sorted(x,key=lambda item:item[1]，-item[2])的值為[[1,3,3],[2,3,1]]
對於[1,3,3]來說，item[1]=3，item[2]=3
對於[2,3,1]來說，item[1]=3 item[2]=1
因為第一位都是3，所以看第二位，符號表示是逆序，所以把第二位大的那個序列放前面，即[1,3,3]放前面
7.在調用函數的時候，必須牢記函數形參順序才能正確傳值（F）通過關鍵參數，形參和實參的順序可以不一致
8.包含yield語句的函數一般稱為生成器函數，可以用來創建生成器對象（T）
9.在調用函數時，如果傳遞列表，字典等可變序列作為實參，並且在函數內部使用下標或可變序列對象自身的方法，是可以影響實參的值的（T）
def modify(v): #修改列表元素值
v[0] += 1
a = [2]
>>> modify(a)
>>> a
[3]
詳細介紹見此篇博文：
https://www.cnblogs.com/avention/p/8597775.html
第二十七次測試：
1.面向對象程序設計的三個特征（三要素）分別是:繼承，封裝，多態
2.假設a為類的對象且包含一個私有屬性__value,那么在類的外部通過a直接將私有屬性__value的值設置為5的語句可以寫作 ：a._A__value=5
3.在類定義外沒有任何方法可以訪問對象的私有屬性（F）
在python中私有只是形式上的私有，其實可以使用對象名._類名__屬性的形式進行訪問，這點也是和其他語言不同的地方。
4.python使用關鍵字class來定義類
5.一般建議使用（self）作為實例方法的第一個參數名字
6.定義類時，如果在某個方法之前加上修飾器@classmethod,則表示這是一個類方法
7.在python中，不論類的名字是什么，構造方法的名字都是__init__
8.如果在設計一個類時實現了__contains__()方法，那么該類的對象會自動支持in運算符。
9.定義類時，所有的實例方法的第一個參數都用來表示對象本身，在類的外部通過對象名來調用實例方法時不需要為該參數傳值。（T）
10.python沒有嚴格意義上的私有屬性和私有方法（T）
11.在IDLE模式下，一個下划線"_"表示解釋器中最后一次顯示的內容或者最后一次正確執行的輸出結果（T）
12.定義類時實現__pow__()方法，該類對象可以支持運算符** (T)
13.如果在類外想實現類實例化對象的減法，應該在類內定義(__sub__)特殊方法
14.構造的類可以放在任何位置，只要執行時其存在於python內存即可（T）
15.類的描述，在類定義后的首行以獨立字符串形式存在，如果想要在類外看到類的描述，可以采用（__doc__）特殊方法實現
16.我們一般不在類的定義中直接包含一些可執行的語句，而是通過屬性和方法來實現相關的操作，（T）
因為在類的定義中直接包含一些可執行的語句，他會自動執行，所以一般不在類內直接定義可執行語句
第二十九次測試
1.calss Demo(Asb)這個語法是正確的，其中括號內的Asb是Demo類的參數 （F）
2.isinstance(obj,Cls) 可以用來判斷某對象obj是否是類Cls的實例或者子類實例（T）
3.issubclass(Cls1,Cls2)可以判斷類Cls是否是類Cls2的子類（T）
4.object類是python中所有類的基類(T)
5.__init__方法可以使用return語句(F)
6.如果我們在定義類時暫時未確定某些功能或者為以后軟件升級預留空間，可以使用關鍵字pass占位
7.所有的實例方法都必須朱少有一個參數代表對象本身，這個參數必須是第一個參數，一般習慣為self(T)
8.
class Car:
price=1000 #類屬性
def __init__(self,c):
self.color=c #實例屬性
a=Car("red")
a.color="Yellow" #顏色是實例屬性，只能通過對象名調用
print(Car.price) #1000
a.price=2000
print(a.price) #2000
print(Car.price) #1000
Car.price=3000
print(a.price) #2000
print(Car.price) #3000
#經過上面的價格修改和輸出可以看出來，實例調用類屬性和類名調用類屬性進行修改時，是不互相干擾的，各分各的。
Car.name="QQ" #這種方法可以增加類屬性，
print(Car.name)
a.name="OK" #這種方法也可以增加類屬性
print(a.name)
9.靜態方法定義時可以沒有參數（T）
#靜態方法的例子
class demo:
count=0
def __init__(self,name):
self.name=name
demo.count+=1
@staticmethod #靜態方法
def foo():
demo.count*=100
return demo.count
dc1=demo('老王')
print(demo.foo())
print(dc1.foo())
10.類方法定義時可以沒有參數
#類方法舉例
#類方法至少包含一個參數，表示類對象，建議用cls，@classmethod是裝飾器，
#類方法定義所必須，類方法只能操作類屬性和其他方法，不能操作實例方法,類方法調用可以使用類名或對象名
#2.類方法舉例：
class demo:
count=0
def __init__(self,name):
self.name=name
demo.count+=1
@classmethod
def getChrCount(cls):
s="零一二三四五六七八九十多"
return s[demo.count]
dc1=demo("老王")
dc2=demo('老王')
print(dc1.getChrCount())
print(demo.getChrCount())
11.類方法可以操作實例屬性（F）
類方法只能操作類屬性和其他方法，不能操作實例方法和實例屬性，類方法可以使用類名或對象名
12.各種屬性都可以通過前面增加兩個下划線變成私有屬性（T）
13.各種方法都可以通過前面增加兩個下划線變成私有方法（T）
14.類屬性還有一種屬性叫做保留屬性，是以雙下划線開始，雙下划線結束。
除了上面的三種保留屬性，其他的保留屬性都可以通過對象名或類名訪問。
15.如果是實例方法前面添加兩個下滑線變成私有方法，南無可以使用對象名._類名__方法名()在類外使用（T）
第三十次測試：
1.派生類不可以直接使用基類的實例屬性（F）
2.派生類可以直接使用基類的公開方法和公開屬性（T）
3.如果在派生類內調用基類的類方法或者類屬性，可以使用“派生類.基類的類方法()/.基類類屬性”（F）
4.如果在派生類中調用基類的實例方法，可以使用“派生類.基類的實例方法()” (T)
5.判斷一個類是必死另一個類的子類，使用內置函數issubclass()
6.如果派生類和基類中有相同名字的屬性和方法（內容可能不同），我們對派生類生成一個實例化對象，該對象的這個相同名字的屬性和方法對應的是基類還是派生類？ 派生類
7.如果想在派生類中增量重載基類的實例方法，則使用函數supper()調用基類方法。
8.python支持多繼承，如果多個符類中有相同名字的成員（即屬性和方法），而在子類中使用該成員時沒有指定其所屬的父類名，則python解釋器采用深度優先，從左至右的順序進行搜索。（T）
第三十二次測試：
1.使用open(<文件名>[,<打開方式>,[<緩沖區>]])打開D盤python文件夾下的文件f.txt.語句中<文件名>可以是下面這些方式
（1）“D:/python/f.txt”
（2）“D:\\python\\f.txt”
（3）“./python/f.txt”
（4）r“D:\python\f.txt”
2.使用open語句打開一個文件，如果該文件不存在則創建文件，如果該文件存在則在當前文件后面追加內容，應該采用‘a’打開方式，如果文件已經存在但要覆蓋掉原先的內容，應采用‘w’打開方法。
3.語句f=open('f.txt')和f=open('f.txt','rt')等同。（T）
4.寫程序時應該盡量在操作完成后用<變量名>.close()方法關閉。（T）
5.如果使用.read(size=-1)讀入的將是文本文件的全部內容
6.使用<>.writelines(lines)將字符串列表lines分行寫入文件（F）
7.<>.seek(0)會使指針指向文件末尾（F）
8.下面的代碼結果是：無任何輸出
f=open('f.txt','w+')
f.writelines(lst)
for line in f:
print(line)
f.close()