Python刷题-7654321py9大题库
Python刷题-1
1、下列代码运行结果是？
a = map(lambda x: x**3, [1, 2, 3])
list(a)
[1, 8, 27]
2、Which numbers are printed?()
for i in range(2):
print i
for i in range(4,6):
print i
0, 1, 4, 5 答：range，左闭右开，range(2)输出的是0,1，range(4,6)表示在4和6之间左闭右开，是4,5
range()函数的语法如下：
range(start, end[, step])
参数说明：
start: 计数从 start 开始。默认是从 0 开始。例如 range(5) 等价于 range(0, 5);
end: 计数到 end 结束，但不包括 end。例如：range(0, 5) 等于 [0, 1, 2, 3, 4]，没有5;
step：步长，默认为1。例如：range(0, 5) 等价于 range(0, 5, 1)
详情请参考：
http://www.runoob.com/python/python-func-range.html
因此上述代码实际将输出：
0
1
4
5
3、for i in range(2):
print i
for i in range(4,6):
print I
打印的结果是（）
0, 1, 4, 5
4、下列哪种不是Python元组的定义方式？
(1)
(1, )
(1, 2)
(1, 2, (3, 4))
Python 中的 tuple 结构为 “不可变序列”，用小括号表示。为了区别数学中表示优先级的小括号，当 tuple 中只含一个元素时，需要在元素后加上逗号。
>>> print(type((1,)))
<class 'tuple'>
>>> print(type((1)))
<class 'int'>
5、What gets printed?()
print r"\nwoow"
the text like exactly like this: \nwoow 前导标识符 r 不会被输出，只起标记作用，ｒ代表不被转义
Python 中字符串的前导 r 代表原始字符串标识符，该字符串中的特殊符号不会被转义，适用于正则表达式中繁杂的特殊符号表示。
最典型的例子，如要输出字符串 \n，由于反斜杠的转义，因此一般的输出语句为：
print "\\n"
这里的 \\ 将被转义为 \ 。而采用原始字符串输出时，则不会对字符串进行转义：
print r"\n"
因此本题答案为 C，输出 \nwoow 。注意前导标识符 r 不会被输出，只起标记作用。
6、以下声明错误的是：D
A、dic = {}
B、dic = {100:200}
C、dic = {(1,2,3):'test'}
D、dic = {[1,2,3]:'test'}
字典的键值必须是不可变类型，如数字，字符串，元组，而列表是可变类型。
可变(mutable)对象类型 ：list、dict、set、bytearray、user-defined classes (unless specifically made immutable)
不可变(immutable)对象类型： int、float、decimal、complex、bool、str、tuple、range、frozenset、bytes
7、对于以下代码，描述正确的是：
list = ['1', '2', '3', '4', '5']
print list[10:]
A、导致 IndexError
B、输出['1', '2', '3', '4', '5']
C、编译错误
D、输出[]
切片操作不会引起下标越界异常
索引会报错，如list［10］, list index out of range，而切片不会，只会给空列表如list[10：11]结果是空列表
8、下列程序运行结果为：
a=[1, 2, 3, 4, 5]
sums = sum(map(lambda x: x + 3, a[1::3]))
print(sums)
13
a=[1, 2, 3, 4, 5]
sums = sum(map(lambda x: x + 3, a[1::3]))
'''
a[1::3]意思是切片取值
a[1]=2,
: 代表取值到列表结尾，3为步长 ，取值结果为[2,5]
lambda 匿名函数 返回x+3，则为[5,8]，再求合13
'''
print(sums)
a[1::3]的意思是，从下标1开始步长为3的元素，在这道题里也就是2、5；
两个冒号中间的数字代表从开始到小于该下标，留空则直到结尾，比如a[0:4:1]则是从下标0开始到下标4之间步长为1的元素。
这是Python里面的切片步长写法，它的原始形式应该是这样的：[start: end : step]
表示“从开始索引位置的那个值计算，经过多少步长到结束索引位置”，有时候end会被省略。
所以这里就表示从索引为1的（a=[1, 2, 3, 4, 5]）数字，就是这里的2（因为索引都是从0开始计算）开始计算 三步，下一个就是5。
9、有如下类定义，下列描述错误的是？ D
class A(object):
pass
class B(A):
pass
b = B()
A、isinstance(b, A) == True
B、isinstance(b, object) == True
C、issubclass(B, A) == True
D、issubclass(b, B) == True
abc isinstance（object，classinfo），用于判断object是否是classinfo的一个实例，或者object是否是classinfo类的子类的一个实例，如果是返回True. issubclass（class，classinfo），用于判断class是否是classinfo类的子类，如果是返回True.
新式类：class 类（object基类）
继承类：class 子类（父类1[,父类2，父类3]）#在继承元组中列了一个以上的类，那么它就被称作"多重继承"
class A(object):#新式类，相当于A继承object基类
pass
class B(A):#B类继承A类
pass
b = B()#实例化
10、已知print_func.py的代码如下：
print('Hello World!')
print('__name__ value: ', __name__)
def main():
print('This message is from main function')
if __name__ == '__main__':
main()
print_module.py的代码如下：
import print_func
print("Done!")
运行print_module.py程序，结果是：
Hello World!
__name__ value: print_func
Done!
如果是直接执行print_func文件，则__name__的值为__main__；
如果是以导入模块的形式执行print_func文件，则__name__的值为该文件名print_func。
__name__的目的就是如果是以导入模块的形式执行文件，不会执行if __name__ == '__main__'下面的语句。
分类: 刷题
Python刷题-2
1、下面哪个是Python中的不变的数据结构？ tuple
A、set
B、list
C、tuple
D、dict
#可变数据类型：列表list[ ]、字典dict{ }
#数据发生改变，但内存地址不变
#不可变数据类型：整型int、字符串str' '、元组tuple（）
#当该数据类型的对应变量的值发生了改变，那么它对应的内存地址也会改变；
2、以下程序输出为： 11 22 (33, 44, 55, 66, 77, 88, 99)
def test(a,b,*args):
print(a)
print(b)
print(args)
test(11,22,33,44,55,66,77,88,99)
# 11给a, 22给b，剩下的包装成元组给了不定长参数 *args
# python参数传递里的不定长参数：加了*的参数以元组方式传入，加了**的参数会以字典方式传入
4、下列哪个语句在Python中是非法的？
A、 x = y = z = 1
B、 x = (y = z + 1)
C、 x, y = y, x
D、 x += y
# y = z + 1 的结果没有返回值，就无法赋值到 x
5、下面代码运行后，a、b、c、d四个变量的值，描述错误的是？ （ D ）
import copy
a = [1, 2, 3, 4, ['a', 'b']]
b = a
c = copy.copy(a)
d = copy.deepcopy(a)
a.append(5)
a[4].append('c')
A、 a == [1,2, 3, 4, ['a', 'b', 'c'], 5]
B、 b == [1,2, 3, 4, ['a', 'b', 'c'], 5]
C、 c == [1,2, 3, 4, ['a', 'b', 'c']]
D、 d == [1,2, 3, 4, ['a', 'b', ‘c’]]
import copy
a = [1, 2, 3, 4, ['a', 'b']]
b = a # 引用，除非直接给a重新赋值，否则a变则b变，b变则a变
c = copy.copy(a) # 浅复制，只会拷贝父对象， 不会拷贝父对象中的子对象，所以若a的子对象变则c 变,但是父对象变c不会变
d = copy.deepcopy(a) #深拷贝，完全拷贝，完全独立于原对象，a变也不变
a.append(5) # 改变父对象
a[4].append('c') #改变父对象中的 ['a', 'b']子对象
# a=[1, 2, 3, 4, ['a', 'b','c'],5]
b=[1, 2, 3, 4, ['a', 'b','c'],5]
c=[1, 2, 3, 4, ['a', 'b','c']]
d=[1, 2, 3, 4, ['a', 'b']]
6、以下程序输出为：
正在装饰
正在验证权限
def w1():
print('正在装饰')
def inner():
print('正在验证权限')
return inner()
w1()
# 因为return inner()后面有括号所以会执行函数，如果改为
def w1():
print("正在装饰")
def inner():
print("正在验证权限")
return inner
w1()
# 最后一行的括号去掉，那么结果就是“正在装饰”
如果外层函数返回的是一个函数名的话，运行结果应该是：正在装饰
如果外层函数返回的是函数调用的话，运行结果是：正在装饰 正在验证权限
7、假设可以不考虑计算机运行资源（如内存）的限制，以下 python3 代码的预期运行结果是：（B）
import math
def sieve(size):
sieve= [True] * size
sieve[0] = False
sieve[1] = False
for i in range(2, int(math.sqrt(size)) + 1):
k= i * 2
while k < size:
sieve[k] = False
k += i
return sum(1 for x in sieve if x)
print(sieve(10000000000))
A、455052510
B、455052511
C、455052512
D、455052513
这是一个求质数个数的题不说了，简单做一个递归的优化，每次都用质数筛
#这个地方以100举例
import math
def sieve(size):
sieve= [True] * size
sieve[0] = False
sieve[1] = False # 这100个数除了0和1其余默认为True
for i in range(2, int(math.sqrt(size)) + 1): # 从2开始一直到10
k= i * 2
while k < size:
sieve[k] = False
k += i # 4为首项，公差为2的数为False;6为首项公差为3的数，以此类推，直到20为首项公差为10的数
# 对sieve中每个元素进行遍历，如果x为真，则计算器加1
return sum(1 for x in sieve if x) # 统计True的个数
print(sieve(100))
8、what gets printed? Assuming python version 2.x( A )
print type(1/2)
A、 <type 'int'>
B、 <type 'number'>
C、 <type 'float'>
D、<type 'double'>
E、<type 'tuple'>
# Python2 中除法默认向下取整，因此 1/2 = 0，为整型。
# 而 Python3 中的除法为正常除法，会保留小数位，因此 1/2 = 0.5，为浮点型。
9、从运行层面上来看，从四个选项选出不同的一个。python
JAVA
Python
objectC
C#
Python 只有它是动态语言
动态语言的定义：动态编程语言 是 高级程序设计语言 的一个类别，在计算机科学领域已被广泛应用。它是一类 在 运行时可以改变其结构的语言 ：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。动态语言目前非常具有活力。众所周知的 ECMAScript （ JavaScript ）便是一个动态语言，除此之外如 PHP 、 Ruby 、 Python 等也都属于动态语言，而 C 、 C++ 等语言则不属于动态语言
10、关于return说法正确的是（ B D ）
A、python函数中必须有return
B、return可以返回多个值
C、return没有返回值时，函数自动返回Null
D、执行到return时，程序将停止函数内return后面的语句
# return会跳出函数（遇到它，函数就结束）
# break会跳出当前循环
# continue 跳出当前循环并执行下一次
# C. return没有返回值时，函数自动返回None，Python没有Null
Python刷题-3
1、关于Python中的复数，下列说法错误的是（C）
A、表是复数的语法是real + image j
B、实部和虚部都是浮点数
C、虚部必须后缀j，且必须小写
D、方法conjugate返回复数的共轭复数
分析：
A，Python中复数表达形式：real + image j/J；
B，Python实部和虚部均浮点类型；
C，虚部后缀为j或J；
D，方法conjugate返回复数的共轭复数，如1+2j调用此方法后变为1-2j;
2、What gets printed?（ 4 ）
nums=([1,1,2,3,3,3,4])
print(len(nums))
set 类型的特性是会移除集合中重复的元素，因此变量 nums 实际上等于：set中的数据不能重复，会自动去除重复的值
nums = {1, 2, 3, 4}
3、以下程序输出为：None 18
info = {'name':'班长', 'id':100, 'sex':'f', 'address':'北京'}
age = info.get('age')
print(age)
age=info.get('age',18)
print(age)
dict.get(key, value=None)
当value的值存在时返回其本身，当key的值不存在时返回None（即默认参数）。
5、已知a = [1, 2, 3]和b = [1, 2, 4]，那么id(a[1])==id(b[1])的执行结果 （ TRUE ）
print(id(a[1]) ==id (b[1])) True
print((a[1]) is (b[1])) True
1、is 比较两个对象的 id 值是否相等，是否指向同一个内存地址；
2、== 比较的是两个对象的内容是否相等，值是否相等
在python3.6中对于小整数对象有一个小整数对象池，范围不止在[-5,257）之间。我试了百万以上的数地址都是相同的。
id（object）是python的一个函数用于返回object的内存地址。但值得注意的是，python 为了提高内存利用效率会对一些简单的对象（如数值较小的int型对象，字符串等）采用重用对象内存的办法。
6、以上函数输出结果为： 一个 shape = (10,5) 的 one-hot 矩阵
import numpy as np
a = np.repeat(np.arange(5).reshape([1,-1]),10,axis = 0)+10.0
b = np.random.randint(5, size= a.shape)
c = np.argmin(a*b, axis=1)
b = np.zeros(a.shape)
b[np.arange(b.shape[0]), c] = 1
print b
>>> a = np.repeat(np.arange(5).reshape([1,-1]),10)
>>> a
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4])
>>> a = np.repeat(np.arange(5).reshape([1,-1]),10,axis=0)
>>> a
array([[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4]])
a = np.repeat(np.arange(5).reshape([1,-1]),10,axis = 0)+10.0
>>> a
array([[ 10., 11., 12., 13., 14.],
[ 10., 11., 12., 13., 14.],
[ 10., 11., 12., 13., 14.],
[ 10., 11., 12., 13., 14.],
[ 10., 11., 12., 13., 14.],
[ 10., 11., 12., 13., 14.],
[ 10., 11., 12., 13., 14.],
[ 10., 11., 12., 13., 14.],
[ 10., 11., 12., 13., 14.],
[ 10., 11., 12., 13., 14.]])
#生成数组[0,1,2,3,4]
np.arange(5)
#原数组共有x个元素，reshape([n,-1])意思是将原数组重组为n行x/n列的新数组
#所以数组共有5个元素，重组为1行5列的数组
reshape([1,-1])
#因为axis=0，所以是沿着竖轴方向重复，增加列数（行的方向上（axis=1），在列的方向上（axis=0））
#所以原数组增加10行
repeat(np.arange(5).reshape([1,-1]), 10, axis = 0)
#数组每个元素都+10
a = repeat(np.arange(5).reshape([1,-1]), 10, axis = 0) + 10
>>> b = np.random.randint(5, size= a.shape) # 随机生成大小为a.shape的数组，数组元素为[0,5)区间范围的整数。
>>> b
array([[0, 4, 3, 0, 2],
[0, 0, 3, 3, 3],
[3, 1, 4, 3, 1],
[3, 2, 3, 0, 2],
[3, 4, 4, 0, 3],
[0, 3, 2, 4, 3],
[0, 4,