Python 面试题-(基础知识篇)

Python 面试题-(基础知识篇)

1.写出如下程序的执行结果,如果认为执行报错,请描述原因:

a=(1)
b=(1,2)
print(type(a))
print(type(b))
print(type(()))

知识点-Python内置数据类型列表：tuple:
要定义一个只有1个元素的tuple，如果你这么定义：a=(1)，定义的不是tuple，是1这个数，这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。所以，只有1个元素的tuple定义时必须加一个逗号，来消除歧义：a=(1,) Python在显示只有1个元素的tuple时，也会加一个逗号，以免你误解成数学计算意义上的括号。如果要定义一个空的tuple，可以写成 () 。
运行结果如下:

2.写出如下程序的执行结果,如果认为执行报错,请描述原因:

class PersonA:
	name="aaa"
p1=PersonA()
p2=PersonA()
p1.name="bbb"
print(p1.name)
print(p2.name)
print(PersonA.name)

class PersonB():
	name=[]
p3=PersonB()
p4=PersonB()
p3.name.append(1)
print(p3.name)
print(p4.name)
print(PersonB.name)

知识点-面向对象编程中类(Class)和实例(Instance)：
必须牢记类是抽象的模板,而实例是根据类创建出来的一个个具体的"对象"，每个对象拥有相同的方法,但各自的数据可能不同.创建实例是通过类名+()实现的。
(1) p1,p2 指向的实例及类本身 name 属性指向的是同一个对象 “aaa” ， 当执行 p1.name=“bbb” 后，p1 实例的 name 属性更改指向为对象 “bbb” ，但 p2 实例及类本身的 name 属性指向的还是对象 “aaa” 。
(2) p3,p4 指向的实例及类本身 name 属性指向的是同一个list对象，当执行 p3.name.append(1) 后， list 对象中添加进了数据，但三者的 name 属性指向还是此list对象未改变。
运行结果如下:

3.已知有如下代码,续写代码,利用 mc 打印"Hi,HelloWorld":

class MyClass():
	str0="Hi,"
	def __init__(self):
		self._str1="Hello"
		self._str2="World"

mc=MyClass()

知识点-面向对象编程中的重要特点就是数据封装：
当实例本身就拥有这些数据，要访问这些数据，就没有必要从外面的函数去访问，可以直接在类的内部定义访问数据的函数，这样，就把“数据”给封装起来了。这些封装数据的函数是和类本身是关联起来的，我们称之为类的方法，要定义一个方法，除了第一个参数是self外，其他和普通函数一样。要调用一个方法，只需要在实例变量上直接调用，除了self不用传递，其他参数正常传入。
完整代码如下:

4.写出如下程序的执行结果,如果认为执行报错,请描述原因:

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')

print(a)
print(b)
print(c)
print(d)

知识点-python中的引用：
在Python中对象的赋值其实就是对象的引用。当创建一个对象，把它赋值给另一个变量的时候，python并没有拷贝这个对象，只是拷贝了这个对象的引用而已。
浅拷贝：拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。也就是，把对象复制一遍，但是该对象中引用的其他对象我不复制
深拷贝：外围和内部元素都进行了拷贝对象本身，而不是引用。也就是，把对象复制一遍，并且该对象中引用的其他对象我也复制
运行结果如下:

5.写出 now 函数的执行结果:

def log(text):
	def decorator(func):
		def wrapper(*args,**kw):
			print('%s %s():' % (text,func.__name__))
			return func(*args,**kw)
		return wrapper
	return decorator

@log('execute')
def now():
	print('2017-11-02')

知识点-代码运行期间动态增加功能的方式，称之为装饰器”（Decorator）：
本质上，decorator就是一个返回函数的高阶函数。
now() 为被修饰的函数，log()为装饰器，‘execute’ 即参数。
(1)最里层：参数一定是*args, **kw，一定会在函数内调用func(*args, **kw)
(2)次里层：参数一定是func，也可为其他名字，但参数一定是函数，而且会在最里层的调用func(*args, **kw)
(3)最外层：如果装饰器是不需要带参数的，那次里层也是最外层了，最外层的函数名就是装饰器名称，否则还需要包装多一层去接收装饰器的参数。
装饰器是否带参数决定一个装饰器是两层还是三层，但是最里层和次里层的参数都是确定的。
运行结果如下:

6.写出如下程序的执行结果,如果认为执行报错,请描述原因:

def test(x,y=5,*a,**b):
	print x,y,a,b

test(1)
test(1,2)
test(1,2,3)
test(x=1,y=1,a=1)
test(1,2,y=1)
test(1,2,3,4,k=1,t=2,o=3)

知识点-函数的参数位置参数，默认参数，可变参数和关键字参数：
对于函数test，参数x为位置参数，y为默认参数，*a为可变参数，**b为关键字参数，调用函数时,传入的值按照位置第一个值赋给x，第二个值赋给y，当没有第二个值，y默认为5，*a表示传入的0或任意个参数，这些可变参数在函数调用时自动组装为一个tuple，**b表示传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。
执行报错，语句test(1,2,y=1)出错
错误提示:TypeError: test() got multiple values for argument ‘y’
(TypeError：Test.（）为参数“y”获得多个值)，原因在于y有多个值,传入参数中y=2,关键字参数中y=1。
其他运行结果如下:

7.写出如下程序的执行结果,如果认为执行报错,请描述原因:

odd=lambda x:bool(x%2)
nums=[n for n in range(10)]

for i in range(len(nums)):
	if(odd(nums[i])):
		del nums[i]

print(nums) 

知识点-Python内置数据类型列表：list：
执行报错，语句if(odd(nums[i]))出错
错误提示:IndexError: list index out of range
(索引错误：超出范围的列表索引)，原因在于list是一种有序的集合，用索引来访问list中每一个位置的元素，删除列表元素后，索引范围减小，外层for循环中的i的范围作为索引的范围并没有减小，发生索引越界。

8.写出如下程序的执行结果,如果认为执行报错,请描述原因:

def create_multipliers():
    return [lambda x:i*x for i in range(5)]

for multiplier in create_multipliers():
    print(multiplier(2))

知识点-变量作用域，列表推导式和匿名函数
函数具有调用时才查找变量的特性，在没调用之前，是不会保存也不会关心它内部变量的具体值。只有等调用它的时候才会逐一去找这些变量的具体值，匿名函数引用了i这个变量，作用域在create_multipliers函数中，返回的匿名函数的时候，匿名函数才去确定自己用到的变量的值，而此时i已经经过for循环变成4了，而不是想象中的动态0-4值。
运行结果如下:

如有疑问或侵权行为请留言