Python面试题整理-牛客网

1、[单选题]关于Python内存管理，下列说法错误的是 
A. 变量不必事先声明
B. 变量无须先创建和赋值而直接使用
C. 变量无须指定类型
D. 可以使用del释放资源

解析1：B
Python 是弱类型脚本语言，变量就是变量，没有特定类型，因此不需要声明。
但每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
用 del 语句可以释放已创建的变量（已占用的资源）。
解析2：
1.变量无需事先声明
2.变量无需指定类型
3.程序员不用关心内存管理
4.变量名会被“回收”
5.del语句能够直接释放资源
6.变量只有被创建和赋值后才能被使用

2、[单选题]执行下列选项的程序，会抛出异常的是（）
A. 
a = 1
b = 2
a,b = b,a
B. 
a,*b,c = range(5)
print(a,b,c)
C.
lis = ['1','2']
a,b = list(map(int,lis))
print(a,b)
D.
tup = (1,(2,3))
a,b,c = tup
print(a,b,c)

解析：D
1、*args和**kwargs 这两个是python中方法的可变参数。
2、*args表示任何多个无名参数，它是一个tuple；
3、**kwargs表示关键字参数，它是一个dict。并且同时使用*args和**kwargs时，必须*args参数列要在**kwargs前，像foo(a=1, b='2', c=3, a', 1, None, )
这样调用的话，会提示语法错误“SyntaxError: non-keyword arg after keyword arg”。
4、当方法的参数不确定时，可以使用*args 和**kwargs
5、D的正确写法是a,(b,c)=tup

3、[单选题]以下程序输出为：
info = {'name':'班长', 'id':100, 'sex':'f', 'address':'北京'}
age = info.get('age')
print(age)
age=info.get('age',18)
print(age)
A. None 18
B. None None
C. 编译错误
D. 运行错误

解析：A
1、获取字典dict中key的值：dict.get(key,default=None），如果key在dict中则返回对应的值，否则返回default的值，其中default的值可自己指定
https://www.runoob.com/python/att-dictionary-get.html
对比记忆：
dict['key'] 返回指定key在字典中的值，如果key则字典中不存在，则直接报错
dict.setdefault(key,default=None) 如果key在字典中存在，则返回key在字典中指定的值；如果key值不存在，则默认将key添加到字典中去，并将其值设置为default（default默认值为None，也可以自己指定）

4、[单选题]在Python3中，关于字符数组的运行结果为：
names = ["Andrea", "Aaslay", "Steven", "Joa"]
lists = []
for name in names:
    if name.count('a') >= 2:
        lists.append(name)
print(lists)
A. [‘Andrea’, 'Aaslay', 'Joa']
B. []
C. [‘Andrea’, 'Aaslay']
D. ['Aaslay']

解析：D
需要考虑大小写

5、[单选题]为输出一个字典dic = {‘a’:1,'b':2}，下列选项中，做法错误的是（）
lis1 = ['a','b'] 
lis2 = [1,2]
dic = dict(zip(lis1,lis2))
print(dic)
 
tup = ('a','b')
lis = [1,2]
dic = {tup:lis}
print(dic)
 
dic = dict(a=1,b=2)
print(dic)

lis = ['a','b']
dic = dict.fromkeys(lis)
dic['a'] = 1
dic['b'] = 2
print(dic)

解析：B
zip函数：
>>>a = [1,2,3] >>> b = [4,5,6] >>> c = [4,5,6,7,8] >>> zipped = zip(a,b) # 打包为元组的列表 [(1, 4), (2, 5), (3, 6)]
fromkeys() 方法 ：
fromkeys() 函数用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值
**方法只用来创建新字典，不负责保存。当通过一个字典来调用 fromkeys 方法时，如果需要后续使用一定记得给他复制给其他的变量
eg：
>>> dict1={}
>>> dict1.fromkeys((1,2,3),'number')
{1: 'number', 2: 'number', 3: 'number'}
>>> print(dict1)
{}
>>> dict2=dict1.fromkeys((1,2,3),'number')
>>> dict2
{1: 'number', 2: 'number', 3: 'number'} 
B输出的是 {('a', 'b'): [1, 2]}

6、[单选题]Python3中，下列对程序描述正确的是：
lists = [1, 2, 3, 4, 5, 6]
lists.append([7,8,9])
print(lists)
A. [1,2,3,4,5,6]
B. [1,2,3,4,5,6,[7,8,9]]
C. [1,2,3,4,5,6,7,8,9]
D. [7,8,9]

解析：B

7、[单选题]在Python3中，下列程序运行结果为：
strs = ['a', 'ab', 'abc', 'python']
y = filter(lambda s: len(s) > 2, strs)
tmp = list(map(lambda s: s.upper(), y))
print(tmp)
 ['ABC', 'PYTHON']
 ['abc', 'PYTHON']
 ['abc', 'python']
 ['a', 'ab']

解析：A
lambda 传参filter函数。
此时lambda函数用于指定过滤列表元素的条件。例如filter(lambda x: x % 3 == 0, [1, 2, 3])指定将列表[1,2,3]中能够被3整除的元素过滤出来，其结果是[3]。
函数式编程filter、map，针对迭代器进行操作。

8、[单选题]Python函数如下，则输出结果为：
def chanageList(nums):     
    nums.append('c')     
    print("nums", nums)   
str1 = ['a', 'b'] 
# 调用函数 
chanageList(str1) 
print("str1", str1)
A. nums ['a', 'b', 'c']，str1 ['a', 'b', 'c']
B. nums ['a', 'b', 'c']，str1 ['a', 'b']
C. nums ['a', 'b']，str1 ['a', 'b']
D. nums ['a', 'b']，str1 ['a', 'b','c']

解析：A
函数传参是赋值操作，赋值的话，列表是引用关系，底层是同一个列表

9、[单选题]下列代码输出为：
str = "Hello,Python";
suffix = "Python";
print (str.endswith(suffix,2));
A. True
B. False
C. 语法错误
D. P
 
解析：A
str.endswith(suffix[, start[, end]]) 用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回True，否则返回False。
可选参数"start"与"end"为检索字符串的开始与结束位置。 

10、[单选题]在Python3中关于下列字符串程序运行结果为？
str1 = "exam is a example!" 
str2 = "exam" 
print(str1.find(str2, 7))
A. -1
B. 14
C. 0
D. 10

解析：D
从str1第7个字符开始寻找str2，在str1第10个字符处第一次找到str2字符串

11、[单选题]
执行以下程序，输出结果为（）
a = 0 or 1 and True
print(a)
A. 0
B. 1
C. False
D. True

解析：D
优先级从高往低依次为not、and、or。1 and True 结果为True， 0 or True为True

12、[单选题]在Python3中，关于字符串的判断正确的是：
str1 = ''
str2 = ' '
if not str1:
    print(1)
elif not str2:
    print(2)
else:
    print(0)
A. 0
B. 1
C. 2
D. None

解析：B
Python语言中，if后任何非0和非空（null）值为True，0或者null为False。
字符串有值为true 没值为false 进入if判断体 not str1==true 输出

13、[单选题]执行以下程序，结果输出为（）
a = [1]
b = 2
c = 1
def fn(lis,obj):
    lis.append(b)
    obj = obj + 1
    return lis,obj
fn(a,c)
print(fn(a,c))
A. ([1, 2, 2], 2)
B. ([1, 2, 2], 3)
C. ([1, 2], 2)
D. ([1, 2], 3)

解析：A
列表可变对象，在第一次函数运行时更改了，但c是数字不可变对象，又是全局变量，第二次调用函数时c仍然为1

14、[单选题]Assuming the filename for the code below is /usr/lib/python/person.py
and the program is run as: python /usr/lib/python/person.py
What gets printed?()
class Person:
    def __init__(self):
        pass
    def getAge(self):
        print __name__
p = Person()
p.getAge()
A. Person
B. getAge
C. usr.lib.python.person
D. __main__

解析：D
1、__name__这个系统变量显示了当前模块执行过程中的名称，如果当前程序运行在这个模块中，__name__ 的名称就是__main__如果不是，则为这个模块的名称（当这个模块被引用即被其他模块import时，__name__的值就是模块名，也就是py文件名。）
2、__main__一般作为函数的入口，类似于C语言，尤其在大型工程中，常常有if __name__ == "__main__":来表明整个工程开始运行的入口。

15、[单选题] 一个段代码定义如下，下列调用结果正确的是？
def bar(multiple):
    def foo(n):
        return multiple ** n
    return foo
A. bar(2)(3) == 8
B. bar(2)(3) == 6
C. bar(3)(2) == 8
D. bar(3)(2) == 6

解析：A
bar()()
一般而言，调用一个函数是加一个括号。如果看见括号后还有一个括号，说明第一个bar函数返回了一个函数，如果后面还有括号，说明前面那个也返回了一个函数。以此类推。
1.执行bar函数
    bar(2)  返回内层函数foo  传入私有变量 multiple=2
2.执行foo函数
    bar(2)(3)  -> foo(3)  -> 2 * 2 *2 -> 8

16、[单选题]下面哪个是Python中不可变的数据结构？
A. set
B. list
C. tuple
D. dict

解析：C
Python可变数据类型：可改变变量的值，且不会新建对象
 List Dictionary Set
Python不可变数据类型：不允许变量的值发生改变，发生改变时会新建对象
 Tuple string Number

17、[单选题]
在Python3中，程序运行结果为：
a = 100
b = 14
print(divmod(a, b))
A. (7, 0)
B. (7, 2)
C. [7, 2]
D. None

解析：B
python3里面divmod将除数与余数运算结合，返回的是包含除数与余数的元组。（a//b,a%b）

18、[单选题]在python3中，程序运行结果为：
truple = (1, 2, 3)
print(truple*2)
A. (2，4，6)
B. (1, 2, 3, 1, 2, 3)
C. [1, 2, 3, 1, 2, 3]
D. None

解析：B
print(truple*2)
print(truple)
(1, 2, 3, 1, 2, 3)
(1, 2, 3)

19、[单选题]以下代码运行结果为：
func = lambda x:x%2
result = filter(func, [1, 2, 3, 4, 5])
print(list(result))
A. [1,3,5]
B. [1,2,1,0,1]
C. [1, 2, 3, 4, 5]
D. [1,2,3]

解析：A
filter(function, iterable)
filter函数是python中的高阶函数,
第一个参数是一个筛选函数, 第二个参数是一个可迭代对象, 
返回的是一个生成器类型, 可以通过next获取值.
这里大致讲述下原理: filter()把传入的function依次作用于iterable的每个元素, 满足条件的返回true, 不满足条件的返回false, 通过true还是false决定将该元素丢弃还是保留.
所以对2和4取余为0舍弃1,3,5取余为1为真保留

20、[单选题]在Python3中，下列continue的用法：
res = []
for i in 'python':
    if i == 'h':
        continue
    res.append(i)
print(''.join(res))
A. 'p','y','t','h','o','n'
B. 'p','y','t','o','n'
C. 'python'
D. 'pyton'

解析：D
Python join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。
str.join(sequence)，其中str即为指定字符，sequence要连接的元素序列

21、[单选题]在Python3中，下列说法正确的是：
sets = {1, 2, 3, 4, 5}
print(sets[2])
程序运行结果为：
A. 2
B. 3
C. 报错
D. {3}

解析：C
报错：TypeError: 'set' object is not subscriptable
python中集合set主要利用其唯一性，及并集|、交集&等操作，但不可以直接通过下标进行访问，必须访问时可以将其转换成list再访问

22、[单选题]根据以下代码，下列选项中，说法正确的是（）
class Rectangle:
    __count = 0
    def __init__(self,width,height):
        Rectangle.__count += 1
        self.__width = width
        self.__height = height

    @property
    def area(self):
        return self.__height * self.__width

    rectangle = Rectangle(200,100)
A. 创建实例对象rectangle后，可在类外使用rectangle.area()来访问area属性
B. area属性为对象的非私有属性，可以访问和修改
C. 变量__count的作用是为了统计创建对象的个数
D. 因为__width和__height为私有变量，所以在类外不可能访问__width和__height属性

解析：C
@property表示可以使用@property装饰器来创建只读属性，@property装饰器会将方法转换为相同名称的只读属性,可以与所定义的属性配合使用，这样可以防止属性被修改。
A 我们在使用属性的时候 只需要 rectangle.area即可 后面不需要加括号
B 只读不可修改了
C __init__每次实例化对象的时候自动调用，所以C正确
D python里面没有严格的私有属性，还是可以访问的，rectangle_Rectangle__width访问width属性
rectangle_Rectangle__height访问height属性

23、[单选题]如下程序会打印多少个数:（）
k = 1000
while k > 1:
    print k
    k = k/2
A. 1000
B. 10
C. 11
D. 9

解析：D
python2 整数除法/时，会取整的，所以应该是9个。
python3 除法/，结果是浮点的，所以是10个，除非用//取整，是9个

24、[单选题]在Python3中。下列程序运行结果说明正确的是：
strs = 'abcd12efg'
print(strs.upper().title())
A. 'ABCD12EFG'
B. 'Abc12efg'
C. 语法错误
D. 'Abcd12Efg'

解析：D
str.upper() # 把所有字符中的小写字母转换成大写字母 
str.lower() # 把所有字符中的大写字母转换成小写字母 
str.capitalize() # 把第一个字母转化为大写字母，其余小写 
str.title() # 把每个单词的第一个字母转化为大写，其余小写 

25、[单选题]下面程序运行结果为：
for i in range(5):
    i+=1
    print("-------")
    if i==3:
        continue
    print(i)
A. ------- 1 ------- 2 ------- ------- 4 ------- 5
B. ------- 1 ------- 2
C. ------- 1 ------- 2 ------- 3
D. ------- 1 ------- 2 ------- 4 ------- 5

解析：A
1.range(5)返回的是可迭代对象，所以循环次数由可迭代对象决定，语句i+=1并不会影响循环次数
2.但由于i+=1语句，每次循环中print(i)输出的值会比从可迭代对象中取出的值多1
3.continue语句会跳过一次print(i)语句

26、[单选题]下列程序打印结果为（      ）
nl = [1,2,5,3,5]
 
nl.append(4)
nl.insert(0,7)
nl.sort()
 
print nl

A. [1, 2, 3, 4, 5, 5, 7]
B. [0, 1, 2, 3, 4, 5, 5]
C. [1, 2, 3, 4, 5, 7]
D. [7, 5, 4, 3, 2, 1]

解析：A
append()方法是指在列表末尾增加一个数据项。
extend()方法是指在列表末尾增加一个数据集合。
insert()方法是指在某个特定位置前面增加一个数据项,list.insert(index,seq)将指定对象seq插入列表中的指定位置  index为插入位置的索引
sort()是对自己排序，默认为升序，sorted()返回一个排序后的副本

27、[单选题]
列表lis=[1,2,3,4,5,6]，其切片lis[-1:1:-1]结果为（）
A. [6,5]
B. [1,2]
C. [1,2,3,4]
D. [6,5,4,3]

解析：D
start为-1，stop为1，步进值为-1。

28、[单选题]在Python3中，程序运行返回结果为：
lists = [1, 1, 2, 3, 4, 5, 6]
lists.remove(1)
lists.append(7)
print(lists)
A. [2,3,4,5,6]
B. [1,2,3,4,5,6]
C. [2,3,4,5,6,7]
D. [1,2,3,4,5,6,7]

解析：D
remove()为删除首次出现的指定元素,参数是索引
append()为在列表尾部添加新的元素,加的是元素

29、[单选题]以下程序输出为：
def w1():
   print('正在装饰')
   def inner():
        print('正在验证权限')
   return inner()
w1()

A. 正在装饰 正在验证权限
B. 正在装饰
C. 正在验证权限
D. 运行错误

解析：A
如果外层函数返回的是一个函数名的话，运行结果应该是：正在装饰
如果外层函数返回的是函数调用的话，运行结果是：正在装饰 正在验证权限

30、[单选题]What gets printed?()
kvps = { '1' : 1, '2' : 2 }
theCopy = kvps.copy()
kvps['1'] = 5
sum = kvps['1'] + theCopy['1']
print sum
A. 1
B. 2
C. 6
D. 10
E. An exception is thrown

解析1：C
kvps.copy()指的是浅拷贝
在 Python2 和 Python3 中，copy() 方法的意义相同，均为返回一个浅复制的 dict 对象，而浅复制是指只拷贝父对象，不会拷贝对象的内部的子对象，即两个 dict 父对象 kvps 与 theCopy 相互独立，但对它们内部子对象的引用却是共享的，所以 kvps['1'] 的改变不影响 theCopy['1'] 的值（因为改变的是父对象的值）。

顺便一提，深复制是指完全拷贝父对象与子对象，即都相互独立。
注意，这里的子对象不是子类的对象，而是在父对象中的二级对象。

解析2：

1、b = a: 赋值引用，a 和 b 都指向同一个对象。

2、b = a.copy(): 浅拷贝, a 和 b 是一个独立的对象，但他们的子对象还是指向统一对象（是引用）。

3、b = copy.deepcopy(a): 深度拷贝, a 和 b 完全拷贝了父对象及其子对象，两者是完全独立的。

解析3：
import copy

d = {'1': [1, 1, 1], '2': 2}
copy1 = d
copy2 = d.copy()
copy3 = copy.copy(d)
copy4 = copy.deepcopy(d)

d['1'][0] = 3
d['2'] = 3
print(copy1, copy2, copy3, copy4)

打印结果分比为
{'1': [3, 1, 1], '2': 3} 
{'1': [3, 1, 1], '2': 2} 
{'1': [3, 1, 1], '2': 2} 
{'1': [1, 1, 1], '2': 2}

方法1：赋值引用，copy1和d指向同一个对象
方法2：浅复制，复制生成新对象copy2，但是只复制一层，[1, 1, 1]为两者共同子对象，
方法3：浅复制，调用copy模块中的方法，同方法2
方法3：深复制，复制生成新对象copy4，并且递归复制所有子对象，所以d中原来指向[1, 1, 1]的改动不会影响深复制生成的子对象[1, 1, 1]

31、[单选题]在Python3中，关于字符串的运算结果为：
strs = 'abcd'
print(strs.center(10, '*'))
A. 'abcd'
B. '*****abcd*****'
C. '***abcd***'
D. '   abcd   '

解析：C
center() 方法返回一个指定的宽度10，居中字符串，*为填充的字符，默认是空格。

32、[单选题]已知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程序，结果是：
A.
Hello World!
__name__ value: print_func
Done!