第一次测试：
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()
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
