python−面接対象に向け番

1、以前対象者の3大の特性。

  • パッケージは、パッケージを指す一堆データの属性と方法でデータを一つの容器の中で、この容器の対象だ。

  • 相続:相続というのは父類のデータの属性と相続できる方法子类属性を修正したりしが、その使用。

  • 余りの実態は、pythonでの実態と言うのは、あまり多种类をすれば、類似のデータの属性と方法、属性が統一いい命名规范を高めることができるよう、

2、アヒルの模型とは何か?

pythonで強制ないすべての人のコードが統一规范を要求しない統一界でもない、抽象的に類を使用すればpytさせる

3、スーパーの役割は?
スーパーの使用を()できる子类で発進父类の方法や属性、あなたは、子类もともと呼出すように父の类ができる

4、mroとは何か?
法mroフルネームresolution order方法というのは、解析の順。
方法を呼出すように必要と当面の類と基類に対する方法の位置検索で確定した。

5、c3アルゴリズムとは何か?
c3アルゴリズムはlisp用の提起され、早ければ応用pythonでは従来の解決のために基づいて深優先的に検索アルゴリズム不満
地元の優先順位は声明を指す時父類の順に、c (a、b)が、例えばもしc类対象の属性を訪問した際、順番によって声明、優
単調性:もしcの解析の順で、aでbの前に、そんなにc子类のすべての里では、この順にも満足しなければならない。

6、下の列挙する対象に足を向け特殊方法。

#__setattr__: 添加/修改属性会触发它的执行
#__delattr__: 删除属性的时候会触发
#__getattr__: 只有在使用点调用属性且属性不存在的时候才会触发
#__getattribute__: 不管是否存在,我都会执行

7、下の下と片双違いがあるのか。

「単次」からのメンバーの変数と呼ば変数を保護し、意味は類の対象と子类自分がこれらの変数まで訪問対象。

「二次」からの私有のメンバーは、意味は類の対象は自分だけが、訪問子类対象すら、このデータに訪問できない。

8、実例変数と類の変数の区别?

類の変数は、すべての対象には、一つの対象はその値を変えて、他の対象が変わった後の结果;

9、静止画の方法と類の区別方法?

pythonの类は文法糖。

10、isinstance typeの役割とか。

  • typeとisinstanceも変数であるかどうかを判断できる内に建てタイプ
  • type受信一パラメータだけでは、変数であるかどうかを判断できるタイプで、しかもパラメータ変数未知の所属のタイプを受けることができる;
  • isinstanceしか判断がある既知のタイプに属するか、直接得ない変数未知の所属のタイプ

11、有用过with statement(有)?
with有が象嵌戸のコードを執行後、自動閉鎖ファイル。

12、下记のデータ構造で、どちらには超の

'''
    A.  dict
    B.  object
    C.  set
    D.  str
'''

# 答え:
B

13、一singleton単例類の実現、要求基本言語プログラミング规范に従う(できるだけ多くのやり方で)。

1.__new__
class Borg(object):
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls, '_instance'):
            ob = super(Borg, cls)
            cls._instance = ob.__new__(cls, *args, **kwargs)
        return cls._instance
        
class MyClass(Borg):
    def __init__(self):
        self.a = 1
        
2.共享属性
class Borg2(object):
    _state = {}

    def __new__(cls, *args, **kwargs):
        ob = super(Borg2, cls).__new__(cls, *args, **kwargs)
        ob.__dict__ = cls._state
        return ob

class MyClass(Borg2):
    def __init__(self):
        self.a = 1
        
3.装饰器
def singleton(cls, *args, **kwargs):
    instances = {}

    def getinstance():
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]

    return getinstance

@singleton
class MyClass(object):
    def __init__(self):
        self.a = 1

4.import方法
# mysingleton .py
class MyClass(object):
    def __init__(self):
        self.a = 1

s_myclass = MyClass()

from mysingleton import s_myclass

s_myclass.a

14、口述くださいwithの使い方、自分の類ばwith有支持、书写はどうすれば?
基本形式

with context_expression [as target(s)]:
    with-body

context_expressionならここにある文脉管理器を対象として、この対象は賦値をas子句__enter__()方法の値賦値を东京(s)に帰った。
いくた(s)が一つの変数は、あるいは、⑤「()」の元チーム(だけではない、「、」を作りの変数の一覧

カスタムの文脉の管理器が実現しなければならない管理に必要な合意文脉__enter__()__exit__()二つの方法
context_manager.__enter__()、文脉管理器の運行に入る時は文脉で有体執行前発進。
context_manager.__exit__(exc_type, exc_value, exc_traceback)脱退は文脉と管理器関連の運行時、文脉に一ボーア値は異常が発生したかどうかを処理している。

15、python一つでどう判断を対象として活用できるのか?

# 答え:
# python 中如何判断一个对象是否可调用
def func():
    pass
print(callable(func))  # True

# 哪些对象可以是可调用对象
1.类对象
2.所有带有_call_()方法的对象

# 如何定义一个类,使其对象本身就是可调用对象
一个类实例也可以变成一个可调用对象,只需要实现一个特殊方法call()

16、棧洞実現一つください。

# 答え:
class Stack(object) :
  def __init__(self,size):
    #类的构造函数
    self.size = size
    self.stack = []

  def __str__(self):
    #类的字符串输出方法,类似于java的.toString()方法
    return str(self.stack)

  def getSize(self) :
    #获取栈当前大小
    return len(self.stack)

  def push(self, x) :
    #入栈,栈满抛异常
    if self.isfull() :
      #return -1
      raise Exception("Stack is full")
    self.stack.append(x)

  def pop(self) :
    #出栈,栈空抛异常
    if self.isempty() :
      #return -1
      raise Exception("Stack is empty")
    topElement = self.stack[-1] 
    self.stack.remove(topElement)
    return topElement

  def isempty(self) :
    #判断栈空
    if len(self.stack) == 0 :
      return True
    return False

  def isfull(self) :
    #判断栈满
    if len(self.stack) == self.size :
      return True
    return False

17、python類の相続について正しい言い方ではないのか。

 A. Python类无法继承
 B. 可以继承, 无法执行父类的构造函数 
 C. 可以有多个父类
 D. 只能有一个父类 
 
 # 答え
 '''
 A
 B
 D
 '''

18、一hashtable類の実現、対外露出のaddとget方法があって、満足して以下のテストコード

def test():
    import uuid
    names = {"name", "web", "python"}
    ht = HashTable()
    for key in names:
        value = uuid.uuid4()
        ht.add(key, value)
        print("add 元素", key, value)
    for key in names:
        v = ht.get(key)
        print("get 元素", key, v)
 
# 答え:
class HashMap(object):
     def __init__(self):
         # 初始化总表为,容量为2的表格(含两个子表)
         self.maps = BetterMap(2)
         self.num = 0        # 表中数据个数
     
     def get(self,k):        
         return self.maps.get(k)
    
     def add(self, k, v):
         # 若当前元素数量达到临界值(子表总数)时,进行重排操作
         # 对总表进行扩张,增加子表的个数为当前元素个数的两倍!
         if self.num == len(self.maps.maps): 
             self.resize()
         
         # 往重排过后的 self.map 添加新的元素
         self.maps.add(k, v)
         self.num += 1
         
     def resize(self):
         """ 重排操作,添加新表, 注意重排需要线性的时间 """
         # 先建立一个新的表,子表数 = 2 * 元素个数
         new_maps = BetterMap(self.num * 2)
         
         for m in self.maps.maps:  # 检索每个旧的子表
             for k,v in m.items:   # 将子表的元素复制到新子表
                 new_maps.add(k, v)
         
         self.maps = new_maps      # 令当前的表为新表

19、どうぞ一つ二つの行列で実現棧洞(ば与え偽コード)

# 答え:
class StackWithTwoQueues(object):
    #定义两个空队列
    def __init__(self):
        self.queue1 = []
        self.queue2 = []
    #入栈
    def push(self, item):
        self.queue1.append(item)
    #出栈
    def pop(self):
        if len(self.queue1) == 0:
            return(None)
        while(len(self.queue1) != 1):
            self.queue2.append(self.queue1.pop(0))
        self.queue1, self.queue2 = self.queue2, self.queue1
        return (self.queue2.pop())
#test
if __name__ == '__main__':
    ss = StackWithTwoQueues()
    list = [0, 1, 2, 3, 4]
    for i in range(5):
        ss.push(list[i])
    print(list)
    for i in range(5):
        print(ss.pop(), ',', end = '')
#output
#[0, 1, 2, 3, 4]
#4, 3, 2, 1, 0

20、既知の鎖表類、実現单链表逆付けてください

class Node:
    def __init__(self, value, next):
        self.value = value
        self.next = next

# 答え:
class Solution:
    def ReverseList(self, pHead):
        if not pHead or not pHead.next:
            return pHead
          
        last = None
          
        while pHead:
            tmp = pHead.next
            pHead.next = last
            last = pHead
            pHead = tmp
        return last

21、類の登録順(類のうち、相続の构造が静的な)?

  • 堆ラムで生成class対象を静的な変数と静止画にノードの方法の区は、この山のメモリのclass対象者は
  • 静的な変数を黙認初期化
  • 静的な変数顕式の初期化
  • 執行の静的なブロック
  • メンバーの変数を黙認初期化となり、初期化
  • 執行の构造関数

22、参考下コードエピソード

class Context:
    pass

with Context as ctx:
    ctx.do_something()

context類でください添加严肃コード完成の実現

# 答え:
class Context(object):
    def __enter__(self):
        pass

    def __exit__(self, exc_type, exc_val, exc_tb):
        if all([exc_type, exc_val, exc_tb]):
            print 'handler except'
            print 'exception {}'.format(exc_val)
        return True

def main():
    with tornado.stack_context.StackContext(Contextor):
        async_task()

23、以下のコードの出力は何か。

class Parent:
    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)
Child1.x = 3
print(Parent.x, Child1.x, Child2.x)

# 答え
'''
1 1 1
1 2 1
1 3 1
'''

24、関数del_node (self、data)の機能は根ノード指針はrootの二分木(別名バイナリ列

class Node(object):
    def __init__(self, data):
        self.data = data  # 节点的数值 
        self.left_child = Node  # 指向左右子树的指针 
        self.right_child = Node
        
    def set_data(self, data):
        self.data = data

25、お与え下コードのエピソードの出力、以前の上にコードの改良を必要とする地方ください?

class Singleton:
    _instance = None
    def __new__(cls, *args, **kwargs):
        print("New")
        if cls._instance is None:
            print("Create")
            cls._instance = super().__new__(cls,*args, **kwargs)
        return cls._instance
    def __init__(self):
        print("Initalize")
        self.prop = None

s1 = Singleton()
s2 = Singleton()
# 答え:
New
Create
Initalize
New
Initalize

26、简単に解釈してpythonのstaticmethod(静的な方法)とclassmethod(類の方法

class A:
    def foo(self, x):
        print('executing class_foo(%s, %s)' % (self, x))

    @classmethod
    def class_foo(cls, x):
        print('executing class_foo(%s, %s)' % (cls, x))

    @staticmethod
    def static_foo(x):
        print('executing static_foo(%s)' % (x))

a = A()
# 调用 foo 函数,参数传入 1
# ____________________
# 调用 class_foo 函数,参数传入 1
# ____________________
# 调用 static_foo 函数,参数传入 1
# ____________________

# 答え:
a.foo(1)
A.class_foo(1)
a.static_foo(1)
A.static_foo(1)

28、书コード(棧洞と行列)
プログラミング先の列類を一つの先進化を実現できる初期化の時の列の大きさ、指定、enqueue dequeu

s = Queue(2)  # 初始化一个大小为 2 的队列
s.is_empty()  # 初始化后, 队列为空, 返回 True
s.enqueue(1)  # 将 1 加入队列
s.enqueue(2)  # 将 2 加入队列
s.isfull()  # 加入了两个元素, 队列已满, 返回 True 6. s.dequeue() # 移除一个元素, 返回 1
s.dequeue()  # 移除一个元素, 返回 2
s.is_empty()  # 队列已经为空, 返回 True

答え

class Queue(object):
    def __init__(self, size):
        self.__size = size
        self.__queue = []

    def enqueue(self, x):
        if len(self.__queue) < self.__size:
            self.__queue.insert(0,x)
        else:
            return 'The queue is full!!!'

    def dequeue(self):
        return None if not len(self.__queue) else self.__queue.pop()

    def is_empty(self):
        return not len(self.__queue)

    def isfull(self):
        return len(self.__queue) == self.__size

s = Queue(2)
print(s.is_empty())
s.enqueue(1)
s.enqueue(2)
print(s.isfull())
print(s.dequeue())
print(s.dequeue())
print(s.is_empty())
ソースネットワーク 戻る