Codefragen, die in Python-Interviews getestet werden müssen

Der Inhalt dieses Artikels befasst sich mit den Codefragen, die in Python-Interviews getestet werden müssen. Er hat einen gewissen Referenzwert dir geholfen.

Empfohlene verwandte Artikel : „ Zusammenfassung der Python-Interviewfragen im Jahr 2020 (aktuell) “

Frage 1: Was wird das Ergebnis des folgenden Codes sein?

class Parent(object):
    x = 1
 
class Child1(Parent):
    pass
 
class Child2(Parent):
    pass
 
print Parent.x, Child1.x, Child2.x
Child1.x = 2
print Parent.x, Child1.x, Child2.x
Parent.x = 3
print Parent.x, Child1.x, Child2.x

Die Antwort ist

1 1 1
1 2 1
3 2 3

Was Sie verwirren oder überraschen könnte, ist, dass die Ausgabe der letzten Zeile 3 2 3 statt 3 2 1 ist. Warum ändert sich durch eine Änderung des Werts von Parent.x auch der Wert von Child2.x, aber gleichzeitig ändert sich der Wert von Child1.x nicht?

Der Schlüssel zu dieser Antwort liegt darin, dass Klassenvariablen in Python intern als Wörterbücher behandelt werden. Wenn der Name einer Variablen nicht im Wörterbuch der aktuellen Klasse gefunden wird, wird die Vorgängerklasse (z. B. die übergeordnete Klasse) durchsucht, bis der referenzierte Variablenname gefunden wird (wenn der referenzierte Variablenname weder in seiner eigenen Klasse noch in der eigenen Klasse enthalten ist). (in der Vorfahrenklasse) wird eine AttributeError-Ausnahme ausgelöst.

Das Setzen von x = 1 in einer übergeordneten Klasse führt dazu, dass die Klassenvariable X in Verweisen auf diese Klasse und alle ihre Unterklassen den Wert 1 hat. Dies liegt daran, dass die Ausgabe der ersten print-Anweisung 1 1 1 ist.

Wenn anschließend eine ihrer Unterklassen den Wert überschreibt (z. B. führen wir die Anweisung Child1.x = 2 aus), wird der Wert nur in der Unterklasse geändert. Deshalb ist die Ausgabe der zweiten print-Anweisung 1 2 1.

Wenn schließlich der Wert in der übergeordneten Klasse geändert wird (z. B. führen wir die Anweisung Parent.x = 3 aus), wirkt sich diese Änderung auf den Wert in jeder Unterklasse aus, die den Wert nicht überschreibt (in diesem Fall). Die betroffene Unterklasse im Beispiel ist Child2). Deshalb ist die dritte Druckausgabe 3 2 3.

Frage 2: Was wird das Ergebnis des folgenden Codes sein? Sagen Sie uns Ihre Antwort und erklären Sie sie?

def p1(x,y):
    print("%s/%s = %s" % (x, y, x/y))

def p2(x,y):
    print("%s//%s = %s" % (x, y, x//y))

p1(5,2)
p1(5.,2)
p2(5,2)
p2(5.,2.)

5/2 = 2
5.0/2.0=2.5
5/2=2
5/2=2

Antwort

Diese Antwort hängt tatsächlich davon ab, ob Sie Python 2 oder Python 3 verwenden.

In Python 3 lautet die gewünschte Ausgabe:

5/2 = 2.5
5.0/2 = 2.5
5//2 = 2
5.0//2.0 = 2.0

In Python 2 lautet die Ausgabe des obigen Codes jedoch:

5/2 = 2
5.0/2 = 2.5
5//2 = 2
5.0//2.0 = 2.0

Standardmäßig, wenn beide The Operanden sind alle Ganzzahlen und Python 2 führt automatisch Ganzzahlberechnungen durch. Infolgedessen hat 5/2 den Wert 2, wohingegen 5./2 den Wert „2,5“ hat.

Beachten Sie, dass Sie dieses Verhalten in Python 2 jedoch überschreiben können (z. B. um zu erreichen). was Sie in Python 3 wollen), indem Sie den folgenden Import hinzufügen:

from__future__ import pision
Beachten Sie außerdem, dass der Operator „doppelter Bindestrich“ (//) unabhängig vom Operandentyp immer eine ganzzahlige Division durchführt. Aus diesem Grund hat 5.0//2.0 den Wert 2.0.

Hinweis: In Python 3 führt der /-Operator eine Gleitkommadivision und // eine Ganzzahldivision durch (d. h. der Quotient hat keinen Rest, z. B as 10 / Das Ergebnis von / 3 ist 3, und der Rest wird abgeschnitten, während das Ergebnis von (-7) // 3 -3 ist. Es sollte beachtet werden, dass es sich bei diesem Algorithmus um eine Ganzzahl handelt Divisionsoperationen bewegen sich in Richtung 0. Die Richtung des Werts. In Python 2 ist / eine ganzzahlige Division, die mit dem //-Operator in Python 3 identisch ist.)

Frage 3: Was Wird der folgende Code ausgegeben?

list = ['a', 'b', 'c', 'd', 'e']
print list[10:]

Antwort
Der obige Code gibt [ ] aus und verursacht keinen IndexError

Wie man es erwarten würde Der Versuch, auf einen Wert zuzugreifen, der den Listenindex überschreitet, führt zu einem IndexError (z. B. beim Zugriff auf die Liste [10] der oben genannten Liste). verursacht keinen IndexError und gibt einfach eine leere Liste zurück. >

def multipliers():
    return [lambda x : i * x for i in range(4)]

print [m(2) for m in multipliers()]

Antwort

Die Ausgabe des obigen Codes ist [6, 6, 6, 6] (anstelle von [0, 2, 4, 6])

（顺便说下，正如在 The Hitchhiker’s Guide to Python 中指出的，这里有一点普遍的误解，是关于 lambda 表达式的一些东西。一个 lambda 表达式创建的函数不是特殊的，和使用一个普通的 def 创建的函数展示的表现是一样的。）

这里有两种方法解决这个问题。

最普遍的解决方案是创建一个闭包，通过使用默认参数立即绑定它的参数。例如：

def multipliers():
    return [lambda x, i=i : i * x for i in range(4)]

另外一个选择是，你可以使用 functools.partial 函数：

from functools import partial
from operator import mul

def multipliers():
    return [partial(mul, i) for i in range(4)]

问题五：以下的代码的输出将是什么? 说出你的答案并解释？

def extendList(val, list=[]):
    list.append(val)
    return list

list1 = extendList(10)
list2 = extendList(123,[])
list3 = extendList('a')

print "list1 = %s" % list1
print "list2 = %s" % list2
print "list3 = %s" % list3

你将如何修改 extendList 的定义来产生期望的结果

以上代码的输出为：

list1 = [10, 'a']
list2 = [123]
list3 = [10, 'a']

许多人会错误的认为 list1 应该等于 [10] 以及 list3 应该等于 [‘a’]。认为 list 的参数会在 extendList 每次被调用的时候会被设置成它的默认值 [ ]。

尽管如此，实际发生的事情是，新的默认列表仅仅只在函数被定义时创建一次。随后当 extendList 没有被指定的列表参数调用的时候，其使用的是同一个列表。这就是为什么当函数被定义的时候，表达式是用默认参数被计算，而不是它被调用的时候。

因此，list1 和 list3 是操作的相同的列表。而 "`list2是操作的它创建的独立的列表（通过传递它自己的空列表作为list"参数的值）。

extendList 函数的定义可以做如下修改，但，当没有新的 list 参数被指定的时候，会总是开始一个新列表，这更加可能是一直期望的行为。

def extendList(val, list=None):
    if list is None:
        list = []
    list.append(val)
    return list

使用这个改进的实现，输出将是：

list1 = [10]
list2 = [123]
list3 = ['a']

相关学习推荐：python视频教程

Das obige ist der detaillierte Inhalt vonCodefragen, die in Python-Interviews getestet werden müssen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!