Python: ООП и классы - ответы на тесты Интуит

• # Конструктор класса задается методом с именем:
• # Если в классе определен деструктор с двумя и более параметрами, то:
• # Если в классе определены два метода с одинаковыми именами и разными списками параметров, то:
• # Значением поля класса по умолчанию может являться
• # В языке Python объектами являются:
• # Деструктор класса задается методом с именем:
• # Укажите результат выполнения скрипта: class Foo: def __init__(self): print ('constructor', end=' ') self.__del__(self) def __del__(self): print ('destructor', end=' ') obj = Foo()
• # Укажите результат выполнения скрипта: x=0 class Foo: count=x def __init__(self): self.count+=1 def __del(self): self.count+=1 obj = Foo() print (obj.count)
• # Укажите результат выполнения скрипта: class Foo: count=0 def __init(self): self.count+=1 obj = Foo() print (obj.count)
• # Укажите результат выполнения скрипта: class Foo: def foo(self): print ('1') def __init__(self): print ('2') x = Foo()
• # Укажите результат выполнения скрипта: class Foo: def foo(self): print ('foo') del self def __del__(self): print ('del') obj = Foo() obj.foo()
• # Укажите результат выполнения скрипта: class Foo: def __init__(self): print ('construct') del self obj = Foo() if obj: print ('exist')
• # Укажите результат выполнения скрипта: class Foo (object): obj=0 def __new__(cls,*dt,**mp): return object.__new__(cls,*dt,**mp).obj def __add__(self, x): return self.obj+2*x o = Foo() o+=1 print (o)
• # Укажите результат выполнения скрипта: class Foo (object): def __new__(cls,*dt,**mp): print ('new', end=' ') def __init__(self): print ('init', end=' ') o = Foo()
• # Укажите результат выполнения скрипта: class Foo (object): obj=0 def __new__(cls,*dt,**mp): print (cls, end=' ') return object.__new__(cls,*dt,**mp).obj def __init__(self): self.obj+=2 print (self, end=' ') def __str__(self, x): return obj o = Foo() print (o, end=' ')
• # Укажите результат выполнения скрипта: class Foo (object): obj=0 def __new__(cls,*dt,**mp): print ('1') return object.__new__(cls,*dt,**mp).obj def __init__(self): print ('2') o = Foo() print (type (o))
• # Укажите результат выполнения скрипта: class Foo (object): obj=0 def __new__(cls,*dt,**mp): obj=1 def __init__(self): self.obj=2 o = Foo() print (o.obj)
• # Укажите результат выполнения скрипта: class Foo (object): obj=0 def __new__(cls,*dt,**mp): cls.obj+=1 return object.__new__(cls,*dt,**mp) def __init__(self): self.obj=self+2 def __add__(self, x): return self.obj+2*x o = Foo() print (o.obj)
• # Укажите результат выполнения скрипта: lst=[1] class Foo (object): lst.append(2) print (lst) ob1 = Foo() ob2 = Foo()
• # Укажите результат выполнения скрипта: lst=[] class Foo (object): obj=0 lst.append(0) ob1 = Foo() ob2 = Foo() print (lst)
• # Укажите результат выполнения скрипта: lst=[0] class Foo (object): lst+=[1] ob = Foo() print (lst, ob.lst)
• # Укажите результат выполнения скрипта: foo = [1] class Foo (object): bar = foo bar += [1] ob = Foo() print (foo)
• # Укажите результат выполнения скрипта: tpl=1,2 class Foo (object): tpl+=(3,) ob = Foo() print (tpl, ob.tpl)
• # Укажите результат выполнения скрипта: lst=[0] class Foo (object): lst=lst+[1] ob = Foo() print (lst, ob.lst)
• # Укажите результат выполнения скрипта: class Foo (object): def obj (self): return [0] def __init__(self,*dt,**mp): self.obj=lambda i : 0 def __new__(cls,*dt,**mp): cls.obj=lambda i : "0" return object.__new__(cls,*dt,**mp) ob = Foo() print (type(ob.obj(0)))
• # Укажите результат выполнения скрипта: class Foo (object): def obj (self): return 0 obj = '0' ob = Foo() print (type(ob.obj()))
• # Укажите результат выполнения скрипта: class Foo (object): def value(self, x): return x.str def value(self, x): pass def value(self, x): return x ob = Foo() print (type(ob.value(0)))
• # Укажите результат выполнения скрипта: class Foo (object): obj=0 def obj(self): return 'x' ob = Foo() print (type(ob.obj)) print (type(ob.obj()))
• # Укажите результат выполнения скрипта: class Foo (object): def value(self, x): return [x] def __init__(self): self.value = lambda i: {'0':i} def value(self, x): return (x,) ob = Foo() print (ob.value(0))
• # Укажите результат выполнения скрипта: class Foo (object): def __new__(cls,*dt,**mp): cls.obj=lambda i : str(i) return object.__new__(cls,*dt,**mp) def obj(self, x): pass ob = Foo() print (type(ob.obj()))
• # В языке Python доступ через instance._class__attribute:
• # В языке Python доступ через instance.attribute разрешен к любым атрибутам кроме:
• # В языке Python доступ через instance._class__attribute разрешен к:
• # В языке Python инкапсуляция достигается:
• # В языке Python прямой доступ:
• # В языке Python доступ через instance.attribute:
• # Встроенный метод __setattr__ вызывается:
• # Встроенный метод __delattr__ вызывается:
• # Одиночное подчеркивание в начале имени атрибута класса указывает на:
• # Прямой доступ к атрибуту класса нельзя получить, если:
• # В языке Python встроенный метод property() используется для:
• # Встроенный метод __getattr__ вызывается:
• # Укажите результат выполнения скрипта: class Foo (object): def method (self): print ('1', end=' ') def _method_ (self): print ('2', end=' ') def __method__ (self): print ('3', end=' ') o=Foo() o.method() o._method_() o.__method__()
• # Укажите результат выполнения скрипта: class Foo (object): x=1 __x=2 x__=3 print (Foo.x) print (Foo.__x) print (Foo.x__)
• # Укажите результат выполнения скрипта: class Foo (object): def method (self): print ('1', end=' ' ) def __method (self): print ('2', end=' ' ) def method__ (self): print ('3', end=' ' ) o=Foo() o.method() o.__method() o.method__()
• # Укажите результат выполнения скрипта: class Foo (object): x=1 _x=2 __x=3 print (Foo.x+Foo._x) print (Foo._x+Foo.__x)
• # Укажите результат выполнения скрипта: class Foo (object): def method (self): print (1) def _method (self): print (2) def __method (self): print (3) o=Foo() o.method() o._method() o.__method()
• # Укажите результат выполнения скрипта: class Foo (object): x=1 _x_=2 __x__=3 print (Foo.x, Foo._x_, Foo.__x__)
• # Укажите результат выполнения скрипта: class Foo(object): __value__=0 def __getattr__(self, name): return (name+'_'+self.__value__.__str__()) def __setattr__(self, name, value): object.__setattr__(self, '__value__', value) o = Foo() o.a=1 print (o.a, o.b)
• # Укажите результат выполнения скрипта: class Foo(object): __value__={} def __getattr__(self, name): if name in self.__value__: return self.__value__[name] else: return name+'_atr' def __setattr__(self, name, value): object.__setattr__(self, '__value__', value) o = Foo() o.a=1 print (o.a, o.b)
• # Укажите результат выполнения скрипта: class Foo(object): __value__=0 def __getattr__(self, name): print (name+'_'+self.__value__.__str__(), end = ' '), def __setattr__(self, name, value): object.__setattr__(self, '__value__', value) o = Foo() o.a=1 print (o.a, o.b)
• # Укажите результат выполнения скрипта: class Foo(object): __value__={} def __getattr__(self, name): if name in self.__value__: return self.__value__[name] else: return (name+'_atr') def __setattr__(self, name, value): self.__value__[name]=value o = Foo() o.a=12 print (o.a, o.b) print (o.__value__)
• # Укажите результат выполнения скрипта: class Foo(object): __value__=0 def __getattr__(self, name): return (name+'_'+self.__value__.__str__()) def __setattr__(self, name, value): self.__value__=value o = Foo() o.a=1 print (o.a, o.b)
• # Укажите результат выполнения скрипта: class Foo(object): __value__={} def __getattr__(self, name): if self.__value__.has_key(name): return self.__value__[name] else: return name+'_atr' def __setattr__(self, name, value): object.__setattr__(self, name, value) o = Foo() o.a=1 print (o.a, o.b)
• # Встроенный атрибут __mro__ в языке Python:
• # При наследовании в языке Python порядок разрешения методов для "новых" классов (т.е. классов, наследников класса object) определяется следующим образом:
• # При наследовании в языке Python порядок разрешения методов для "классических" классов (т.е. классов, не являющихся наследниками класса object) определяется следующим образом:
• # При наследовании в языке Python:
• # При наследовании в языке Python приватные методы:
• # При наследовании в языке Python:
• # Укажите результат выполнения скрипта: class Foo (object): __value__=12 def __truediv__ (self, x): return self.__value__/x*2 class Bar(Foo): pass o = Bar() o=o/3 o=o/2 print (o)
• # Укажите результат выполнения скрипта: class Foo (object): __value__=[] def append(self): self.__value__+=[1] def __append(self): self.__value__+=[2] class Bar(Foo): def append(self): self.__value__+=[3] o = Bar() o.append() o.__append() print (o.__value__)
• # Укажите результат выполнения скрипта: class Foo (object): __value__=0 def __add__ (self, x): ob = Foo() ob.__value__=self.__value__+x*2 return ob def __repr__(self): return str(self.__value__) class Bar(Foo): def __repr__(self): return str(self.__value__+1) o = Bar() o=o+3 print (o)
• # Укажите результат выполнения скрипта: class Foo (object): def __method__ (self): print ('1') def method (self): print ('2') class Bar (Foo): def method (self): print ('3') o = Bar() o.method() o.__method__()
• # Укажите результат выполнения скрипта: class Foo (object): __value__=0 def __add__ (self, x): return self.__value__+x*2 class Bar(Foo): pass o = Bar() o=o+1 o=o+2 print (o)
• # Укажите результат выполнения скрипта: class Foo (object): __value__=0 def add(self): self.__value__+=1 def _add(self): self.__value__+=2 class Bar(Foo): def add(self): self.__value__+=3 o = Bar() o.add() o._add() print (o.__value__)
• # Укажите результат выполнения скрипта: class Foo (object): __val__=0 def m1 (self): self.__val__+=1 def m2 (self): self.__val__+=2 class Bar (Foo): __val__=1 def m2 (self): self.__val__-=1 def m3 (self): self.__val__-=2 class Baz (Bar): __val__=2 def m1 (self): self.__val__+=5 o = Baz() o.m1() o.m2() o.m3() print (o.__val__)
• # Укажите результат выполнения скрипта: class Foo (object): def __init__(self, value): self.__val__=value def __sub__ (self, x): return Foo(self.__val__-x) def __add__ (self, x): return Foo(self.__val__+x) class Bar (Foo): def __sub__ (self, x): return Bar(self.__val__-x*3) def __mul__ (self, x): return Bar(self.__val__*x*3) class Baz (Bar): def __mul__ (self, x): return Baz(self.__val__*x*2) o = Baz(1) o+=3 o*=2 o-=1 print (o.__val__)
• # Укажите результат выполнения скрипта: class Foo (object): __val__=[0] def m1 (self): self.__val__+=[1] def m2 (self): self.__val__+=[2] class Bar (Foo): __val__=[-1] def m1 (self): self.__val__+=[3] def m3 (self): self.__val__+=[4] class Baz (Bar): __val__=[-2] def m2 (self): self.__val__+=[5] o = Baz() o.m1() o.m2() o.m3() print (o.__val__)
• # Укажите результат выполнения скрипта: class Foo (object): def __init__(self, value): self.__val__=value def __sub__ (self, x): return Foo(self.__val__-x) def __add__ (self, x): return Foo(self.__val__+x) class Bar (Foo): def __sub__ (self, x): return Bar(self.__val__-x*2) def __mul__ (self, x): return Bar(self.__val__*x*2) class Baz (Bar): def __mul__ (self, x): return Baz(self.__val__*x) o = Baz(1) o*=2 o-=4 o+=3 print (o.__val__)
• # Укажите результат выполнения скрипта: class Foo (object): def method1 (self): print ('1') def method2 (self): print ('2') class Bar (Foo): def method2 (self): print ('2+') def method3 (self): print ('3+') class Baz (Bar): def method3 (self): print ('3++') o = Baz() o.method1() o.method2() o.method3()
• # Укажите результат выполнения скрипта: class Foo (object): def __init__(self, value): self.__val__=value def __sub__ (self, x): return Foo(self.__val__-x) def __add__ (self, x): return Foo(self.__val__+x) class Bar (Foo): def __sub__ (self, x): return Bar(self.__val__-x*3) def __mul__ (self, x): return Bar(self.__val__*x*3) class Baz (Bar): def __sub__ (self, x): return Baz(self.__val__-x*2) o = Baz(1) o*=2 o-=1 o+=3 print (o.__val__)
• # Скрипт содержит следующий код: class Class1 (object): pass class Class2 (Class1): pass class Class3 (______): pass Среди приведенных ниже фрагментов укажите все варианты кода, при подстановке которого вместо знаков подчеркивания скрипт будет корректным:
• # Скрипт содержит следующий код: class Foo (object): pass class Bar (object): pass class Baz (_____): pass Среди приведенных ниже фрагментов укажите все варианты кода, при подстановке которого вместо знаков подчеркивания скрипт будет корректным:
• # Скрипт содержит следующий код: class Class1 (object): pass class Class2 (Class1): pass class Class3 (______): pass Среди приведенных ниже фрагментов укажите все варианты кода, при подстановке которого вместо знаков подчеркивания скрипт будет корректным:
• # Скрипт содержит следующий код: class Foo (object): pass class Bar (Foo): pass class Baz (_____): pass Среди приведенных ниже фрагментов укажите все варианты кода, при подстановке которого вместо знаков подчеркивания скрипт будет корректным:
• # Скрипт содержит следующий код: class Foo (object): class Class1 (object): pass class Class2 (object): pass class Class3 (______): pass Среди приведенных ниже фрагментов укажите все варианты кода, при подстановке которого вместо знаков подчеркивания скрипт будет корректным:
• # Скрипт содержит следующий код: class Foo (object): pass class Bar (Foo): pass class Baz (_____): pass Среди приведенных ниже фрагментов укажите вариант кода, при подстановке которого вместо знаков подчеркивания скрипт будет корректным:
• # Укажите результат выполнения скрипта: class Foo: def method1 (self): return 1 class Bar (Foo): pass class Baz (Bar): def method1 (self): return 2 class Lo (Baz, Bar): pass o = Lo() print (o.method1())
• # Укажите результат выполнения скрипта: class Foo(object): def method1 (self): return 1 class Bar (Foo): pass class Baz (Foo): def method1 (self): return 2 class Lo (Bar, Foo, Baz): pass o = Lo() print (o.method1())
• # Укажите результат выполнения скрипта: class Foo: def method1 (self): return 1 class Bar (Foo): pass class Baz (Foo): def method1 (self): return 2 class Lo (Bar, Foo): pass o = Lo() print (o.method1())
• # Укажите результат выполнения скрипта: class Foo (object): def method1 (self): return 1 class Bar (Foo): pass class Baz (Foo): def method1 (self): return 2 class Lo (Bar, Baz): pass o = Lo() print (o.method1())
• # Укажите результат выполнения скрипта: class Foo: def method1 (self): return 1 class Bar (Foo): pass class Baz (Foo): def method1 (self): return 2 class Lo (Bar, Baz): pass o = Lo() print (o.method1())
• # Укажите результат выполнения скрипта: class Foo(object): def method1 (self): return 1 class Bar (Foo): pass class Baz (Bar): def method1 (self): return 2 class Lo (Bar, Baz): pass o = Lo() print (o.method1())
• # Укажите результат выполнения скрипта: class Foo(object): def __setattr__(self, name, value): object.__setattr__(self, name+'1', value) class Bar (Foo): a=0 o = Bar() o.a=1 print (o.a)
• # Укажите результат выполнения скрипта: class Foo(object): a=1 def __getattr__(self, name): return (str(self.a)+name) class Bar (Foo): a=0 o = Bar() o.a=2 print (o.a, o.b)
• # Укажите результат выполнения скрипта: class Foo(object): a=1 def __setattr__(self, name, value): object.__setattr__(self, name, value*2) class Bar (Foo): a=0 o = Bar() o.a=-1 print (o.a)
• # Укажите результат выполнения скрипта: class Foo(object): __value__={} def __getattr__(self, name): if self.__value__.has_key(name): return self.__value__[name] else: return (name+'_atr') def __setattr__(self, name, value): self.__value__[name]=value+1 class Bar (Foo): a=0 o = Bar() o.a=5 print (o.a)
• # Укажите результат выполнения скрипта: class Foo(object): def __setattr__(self, name, value): object.__setattr__(self, name, value+1) class Bar (Foo): a=0 o = Bar() o.a=2 print (o.a)
• # Укажите результат выполнения скрипта: class Foo(object): __value__=1 def __getattr__(self, name): return (str(self.__value__)+name) class Bar (Foo): a=0 o = Bar() o.a=3 print (o.a)
• # Для того, чтобы функция, определенная для типа A работала с типом B необходимо:
• # В языке Python метод является абстрактным, если:
• # Исключение NotImplementedError используется для:
• # Для того, чтобы функция, определенная для типа A работала с типом B необходимо:
• # Проверка на совместимость типов производится с помощью оператора
• # Положительный результат выполнения проверки на совместимость типов оператором isinstance означает, что
• # Укажите результат выполнения скрипта: from abc import abstractmethod class Base(): __val__=0 def __add__(self, x): return self.__val__+x.__val__ @abstractmethod def fun (self): pass class Foo(Base): __val__=1 def fun(self): return 2 o=Foo() b=Foo() print ((b+o).fun())
• # Укажите результат выполнения скрипта: from abc import abstractmethod, ABCMeta class Base(metaclass=ABCMeta): def __init__(self, x): self.__val__=x def __add__(self, x): return Base(self.__val__+self.__val__) @abstractmethod def fun (self): pass def val(self): return self.__val__ class Foo(Base): def fun(self): return self.__val__ o=Foo(1) b=Foo(2) print ((b+o.fun()).val())
• # Укажите результат выполнения скрипта: from abc import abstractmethod, ABCMeta class Base(metaclass=ABCMeta): def __init__(self, x): self.__val__=x def __add__(self, x): return Base(self.__val__+self.__val__) @abstractmethod def fun (self): pass def val(self): return self.__val__ class Foo(Base): __val__=0 def __add__(self, x): return Foo(self.__val__+self.__val__) o=Foo(1) b=Foo(2) print (b+o.fun())
• # Укажите результат выполнения скрипта: class base(object): def __init__(self): raise NotImplementedError def fun (self): return 1 class Foo(base): def fun2(self): return 2 o=Foo() print (o.fun()+o.fun2())
• # Укажите результат выполнения скрипта: class base(object): def __add__(self, x): raise NotImplementedError def fun (self): return 1 class Foo(base): def fun(self): return 2 o=Foo() print (o+o.fun())
• # Укажите результат выполнения скрипта: class base(object): def __add__(self, x): raise NotImplementedError def fun (self): return 1 class Foo(base): def fun(self): return 2 o=Foo() print (o.fun()+o.fun())
• # Укажите результат выполнения скрипта: class Foo(object): val = 0 def fun(self): try: self.val[0]=0 return self.val except TypeError: return self.val o=Foo() o.val=(1,2,3) print (o.fun(), end=' ') o.val='123' print (o.fun(), end=' ')
• # Укажите результат выполнения скрипта: class Foo(object): val = 0 def fun(self): try: self.val[0]=0 return self.val except TypeError: return self.val o=Foo() o.val=[1,2,3] print (o.fun(), end=' ') o.val=(1, 2, 3) print (o.fun(), end=' ')
• # Укажите результат выполнения скрипта: class Foo(object): val = 0 def fun(self): try: self.val[0]+=self.val[0] return self.val except TypeError: return self.val o=Foo() o.val=12 print (o.fun(), end=' ') o.val='12' print (o.fun(), end=' ')
• # Укажите результат выполнения скрипта: class Foo(object): val = 0 def fun(self): try: return self.val[-1] except TypeError: return self.val o=Foo() o.val='Hello' print (o.fun()) o.val=15 print (o.fun())
• # Укажите результат выполнения скрипта: class Foo(object): val = 0 def fun(self): try: return self.val[-1] except TypeError: return self.val o=Foo() o.val=(1,2,3,4) print (o.fun()) o.val={'0':1,'1':2,'2':3,'3':4} print (o.fun())
• # Укажите результат выполнения скрипта: class Foo(object): val = 0 def fun(self): try: return self.val[-1] except TypeError: return self.val o=Foo() o.val=[1,2,3,4] print o.fun(), o.val='1234' print (o.fun())
• # Укажите результат выполнения скрипта: class Foo(object): def meth (self, x=1): return x*2 def meth (self, *x): s=0 for i in x: s+=i return s o=Foo() print (o.meth(-1)+o.meth(2))
• # Укажите результат выполнения скрипта: class Foo(object): def meth (self, x): return x*2 def meth (self, x, *y): s=x for i in y: s+=i*2 return s o=Foo() print (o.meth(3)+o.meth(4, 5))
• # Укажите результат выполнения скрипта: class Foo(object): def meth (self, x): return x*2 def meth (self, x, y=-2): return x+y o=Foo() print (o.meth(3)+o.meth(4))
• # Укажите результат выполнения скрипта: class Foo(object): def meth (self, x): return x*2 def meth (self, x, y=3): return (x+y)*3 o=Foo() print (o.meth(1)+o.meth(1, 2))
• # Укажите результат выполнения скрипта: class Foo(object): def meth (self, x=0): return x def meth (self, x, y=2): return (x+y)/2 o=Foo() print (o.meth()+o.meth(2))
• # Укажите результат выполнения скрипта: class Foo(object): def meth (self, x=0): return x*2 def meth (self, *x): s=0 for i in x: s+=i return s o=Foo() print (o.meth(-1)+o.meth(2,3))
• # Укажите результат выполнения скрипта: class Foo(str): def __init__(self, x): self.__val__=x def __add__(self, val): return Foo(int(self.__val__)+int(val.__val__)) def __str__(self): return str(self.__val__) print ((Foo('1')+Foo('2'))*2)
• # Укажите результат выполнения скрипта: class Foo(int): def __init__(self, x): self.__val__=x def __add__(self, val): return Foo(str(self.__val__)+str(val.__val__)) def __str__(self): return str(self.__val__) print ((Foo('1')+Foo('2'))*2)
• # Укажите результат выполнения скрипта: class Foo(float): def __init__(self, x): self.__val__=x def __add__(self, val): return Foo(int(self.__val__)+int(val.__val__)) def __str__(self): return str(self.__val__) print ((Foo('1')+Foo('2'))*2)
• # Укажите результат выполнения скрипта: class Foo(object): def __init__(self, x): self.__val__=x def __add__(self, val): return Foo(self.__val__+val.__val__) def __str__(self): return str(self.__val__) print (Foo(1)+Foo(2), Foo('1')+Foo('2'))
• # Укажите результат выполнения скрипта: class Foo(int): def __init__(self, x): self.__val__=x def __add__(self, val): return Foo(val.__val__.__class__(self.__val__)+val.__val__) def __str__(self): return str(self.__val__) print (Foo(1)+Foo('2'), Foo('1')+Foo(2))
• # Укажите результат выполнения скрипта: class Foo(int): def __init__(self, x): self.__val__=x def __str__(self): return str(self.__val__) print (Foo('12')%Foo('2'))
• # Укажите результат выполнения скрипта: def fun1(f): print (f(1), end=' ') @fun1 @fun1 def m(x): return x+2
• # Укажите результат выполнения скрипта: def fun1(f): return lambda i: f(i)+2 def fun2(f): print (f(3), end=' ') @fun1 @fun2 def m(x): return x+2
• # Укажите результат выполнения скрипта: def fun1(f): print (f(3), end=' ') def fun2(f): return lambda i: f(i)+2 @fun1 @fun2 def m(x): return x+2
• # Укажите результат выполнения скрипта: def fun1(f): print (f(1)) @fun1 def m(x): return x+1 @fun1 def m2(x): return x+2
• # Укажите результат выполнения скрипта: def fun1(f): print (f(1)) def fun2(f): print (f(2)) @fun2 def m(x): return x+1 @fun1 def m(x): return x+2
• # Укажите результат выполнения скрипта: def fun1(f): print (f(1)) @fun1 def m(x): return (x,) @fun1 def m2(x): return [x]
• # Укажите результат выполнения скрипта: class foo(object): def method (self): return '012' val = [method] x = foo() s = x.val del x print (s())
• # Укажите результат выполнения скрипта: class foo(object): val = (1,2,3) x = {'0':foo()} s = x['0'].val del x print (s)
• # Укажите результат выполнения скрипта: class foo(object): def method (): return '012' val = [method] x = foo() s = x.val[0] del x print (s())
• # Укажите результат выполнения скрипта: class foo(object): def __repr__(self): return 'class' x = [foo()] s = x[0] del x print (s)
• # Укажите результат выполнения скрипта: class foo(object): val = [1,2,3] x = foo() s = x.val[0] del x print (s)
• # Укажите результат выполнения скрипта: class foo(object): def method(self): return 'call method' x = (foo().method,) s = x[0] del x print (s())
• # Укажите результат выполнения скрипта: class Foo: def __init__(self, lst): self.lst = lst def __iter__(self): return self def __next__(self): raise StopIteration for i in Foo(range(4)): print (i+1, end=' ')
• # Укажите результат выполнения скрипта: class Foo: def __init__(self, lst): self.lst = lst def __iter__(self): return self def __next__(self): if self.lst: return self.lst.pop() else: raise StopIteration for i in Foo(list(range(4))): print (i+1, end=' ')
• # Укажите результат выполнения скрипта: class Foo: def __init__(self, lst): self.lst = lst def __iter__(self): return self def __next__(self): if self.lst: return self.lst[-1] else: raise StopIteration for i in Foo('Hello'): print (i, end=' ')
• # Укажите результат выполнения скрипта: class Foo: def __init__(self, lst): self.lst = lst def __iter__(self): return self def __next__(self): return self.lst.pop() for i in Foo(list(range(4))): print (i+1, end=' ')
• # Укажите результат выполнения скрипта: class Foo: def __init__(self, lst): self.lst = lst def __iter__(self): return self def __next__(self): if self.lst: return self.lst.pop() else: raise StopIteration for i in Foo(list(range(4))): print (i, end=' ')
• # Укажите результат выполнения скрипта: class Foo: def __init__(self, lst): self.lst = lst def __iter__(self): return self def __next__(self): if self.lst: return self.lst.pop(1) else: raise StopIteration for i in Foo(list(range(4))): print (i + 1, end=' ')
• # Укажите результат выполнения скрипта: class Foo: def __init__(self, lst): self.lst = lst self.cur = 0 def __next__(self): if self.lst: self.cur = 1 ^ self.cur return self.lst.pop(self.cur) else: raise StopIteration def __iter__(self): return self for i in Foo(list(range(3))): print (i, end=' ')
• # Укажите результат выполнения скрипта: class Foo: def __init__(self, lst): self.lst = lst self.cur = 1 def __next__(self): if self.lst: self.cur = 1 ^ self.cur return self.lst.pop(self.cur) else: raise StopIteration def __iter__(self): return self for i in Foo(list(range(3))): print (i, end=' ')
• # Укажите результат выполнения скрипта: class Foo: def __init__(self, lst): self.lst = lst self.cur = 1 def __next__(self): if self.lst: self.cur = 1 ^ self.cur return self.lst.pop(-1*self.cur) else: raise StopIteration def __iter__(self): return self for i in Foo(list(range(4))): print (i, end=' ')
• # Укажите результат выполнения скрипта: class Foo: def __init__(self, lst, n): self.n = n self.lst = lst self.cur=0 def __next__(self): if self.lst: self.cur = (self.cur + self.n - 1) % len(self.lst) return self.lst.pop(self.cur) else: raise StopIteration def __iter__(self): return self for i in Foo(list('Hello!'), 3): print (i, end=' ')
• # Укажите результат выполнения скрипта: class Foo: def __init__(self, lst): self.lst = lst self.cur = 0 def __next__(self): if self.lst: self.cur = 1 ^ self.cur return self.lst.pop(self.cur) else: raise StopIteration def __iter__(self): return self for i in Foo(list('Hello!')): print (i, end=' ')
• # Укажите результат выполнения скрипта: class Foo: def __init__(self, lst): self.lst = lst self.cur = 0 def __next__(self): if self.lst: self.cur = 1 ^ self.cur return self.lst.pop(-1*self.cur) else: raise StopIteration def __iter__(self): return self for i in Foo(list('Hello!')): print (i, end=' ')
• # Скрипт содержит следующий код: import weakref def meth (): return 1 class Foo(object): val = [meth(), meth(), meth()] try: obj = Foo() s = __________ del obj print (s) except ReferenceError: print ('Error') Среди приведенных ниже фрагментов укажите все варианты кода, при подстановке которого вместо знаков подчеркивания результатом выполнения скрипта станет строка Error:
• # Скрипт содержит следующий код: import weakref class Bar(object): def __repr__(self): return '1' class Foo(object): def __init__ (self): self.val = Bar(), Bar(), Bar() try: obj = Foo() s = _____________ del obj print (s) except ReferenceError: print ('Error') Среди приведенных ниже фрагментов укажите все варианты кода, при подстановке которого вместо знаков подчеркивания результатом выполнения скрипта станет строка Error:
• # Скрипт содержит следующий код: import weakref class Bar(object): def __repr__(self): return 1 class Foo(object): val = Bar(), Bar(), Bar() try: obj = Foo() s = _______ del obj print (s) except ReferenceError: print ('Error') Среди приведенных ниже фрагментов укажите все варианты кода, при подстановке которого вместо знаков подчеркивания результатом выполнения скрипта станет строка Error:
• # Скрипт содержит следующий код: import weakref class Foo(object): def __repr__(self): return 'class' try: s = Foo() s1 = __________ del s print (s1) except ReferenceError: print ('Error') Среди приведенных ниже фрагментов укажите все варианты кода, при подстановке которого вместо знаков подчеркивания результатом выполнения скрипта станет строка Error:
• # Скрипт содержит следующий код: import weakref class Foo(object): def __repr__(self): return 'class' try: lst = [Foo(), Foo(), Foo()] s = ________ del lst print (s) except ReferenceError: print ('Error') Среди приведенных ниже фрагментов укажите все варианты кода, при подстановке которого вместо знаков подчеркивания результатом выполнения скрипта станет строка Error:
• # Скрипт содержит следующий код: import weakref class Foo(object): val = 'Error' try: obj = Foo() s = _______ del obj print (s) except ReferenceError: print ('Error') Среди приведенных ниже фрагментов укажите все варианты кода, при подстановке которого вместо знаков подчеркивания результатом выполнения скрипта станет строка Error:
• # Чем отличаются в языке Python обычные модули от модулей расширения?
• # В языке Python при импортировании пакета, если файл __init__.py отсутствует, то:
• # Чем отличаются файлы *.py от файлов *.pyc:
• # В языке Python модулем называют:
• # В языке Python пакетом называют:
• # В языке Python при импортировании модуля с помощью инструкции import M:
• # При импортировании модуля если в пространстве имен уже существует имя импортированного модуля, то:
• # Встроенный атрибут объекта модуля __dict__:
• # В языке Python при импортировании модуля с помощью инструкции from .. import *:
• # В языке Python встроенная функция dir() без аргументов используется для:
• # Встроенный атрибут объекта модуля __dict__ содержит:
• # Встроенный атрибут объекта модуля __name__:
• # Файл foo.py содержит следующий код: def f(x, y): return x+y Скрипт a.py содержит следующий код: _1_ print (_2_) Среди приведенных ниже фрагментов укажите вариант кода, при подстановке которого вместо знаков подчеркивания результатом выполнения скрипта станет строка 5:
• # Файл mod.py содержит следующий код: def fun(): return (1, 2, 3) Скрипт a.py содержит следующий код: _1_ print (_2_) Среди приведенных ниже фрагментов укажите вариант кода, при подстановке которого вместо знаков подчеркивания результатом выполнения скрипта станет строка (1, 2, 3):
• # Файл module.py содержит следующий код: def function(x, y): return x*y Скрипт a.py содержит следующий код: _1_ print (_2_) Среди приведенных ниже фрагментов укажите все варианты кода, при подстановке которого вместо знаков подчеркивания результатом выполнения скрипта станет строка 12:
• # Файл foo.py содержит следующий код: def f(x): return x**2 Скрипт a.py содержит следующий код: _1_ print (_2_) Среди приведенных ниже фрагментов укажите все варианты кода, при подстановке которого вместо знаков подчеркивания результатом выполнения скрипта станет строка 9
• # Файл mod.py содержит следующий код: def fun(): return 'Hello' Скрипт a.py содержит следующий код: _1_ print (_2_) Среди приведенных ниже фрагментов укажите все варианты кода, при подстановке которого вместо знаков подчеркивания результатом выполнения скрипта станет строка Hello:
• # Файл module.py содержит следующий код: def function(x): return [x] Скрипт a.py содержит следующий код: _1_ print (_2_) Среди приведенных ниже фрагментов укажите все варианты кода, при подстановке которого вместо знаков подчеркивания результатом выполнения скрипта станет строка [1]:
• # Файл foo.py содержит следующий код: def f(x): return str(x)+'1' Файл foo2.py содержит следующий код: def f(x): return str(x)+'2' Скрипт a.py содержит следующий код: class Cls (object): def f(self, x): return str(x)+'3' import foo2 as foo import foo foo=Cls() print (foo.f(1)) Укажите результат выполнения скрипта:
• # Файл foo.py содержит следующий код: def f(x): return 4*x Файл foo2.py содержит следующий код: def f(x): return 3*x Скрипт a.py содержит следующий код: def f(x): return 2*x from foo import f from foo2 import * as f print (f(1)) Укажите результат выполнения скрипта:
• # Файл foo.py содержит следующий код: def f(x): x+=[2] return x Файл foo2.py содержит следующий код: def f(x): x+=[3] return x Скрипт a.py содержит следующий код: import foo as list import foo2 as list print (list.f([1])) Укажите результат выполнения скрипта:
• # Файл foo.py содержит следующий код: def f(x): return x**2 Файл foo2.py содержит следующий код: def f(x): return x**3 Скрипт a.py содержит следующий код: def f(x): return x from foo import * from foo2 import * print (f(3)) Укажите результат выполнения скрипта:
• # Файл foo.py содержит следующий код: def f(x): return [x] Файл foo2.py содержит следующий код: def f(x): return (x,) Скрипт a.py содержит следующий код: def f(x): return x from foo import * import foo2 print (f(0)) Укажите результат выполнения скрипта:
• # Файл foo.py содержит следующий код: def f(x): return x**2 Файл foo2.py содержит следующий код: def f(x): return x**3 Скрипт a.py содержит следующий код: class Cls (object): def f(self, x): return x foo=Cls() import foo import foo2 as foo print (foo.f(2)) Укажите результат выполнения скрипта:
• # Файл ../foo_p/__init__.py содержит следующий код: __all__=['foo'] Файл ../foo_p/foo.py содержит следующий код: def f(x): return x**2 Файл ../foo_p/foo1.py содержит следующий код: def f(x): return x**3 Файл ../foo_p/foo2.py содержит следующий код: import foo_p.foo1 def fn(x): return foo1.f(x)*x Скрипт a.py содержит следующий код: _1_ print (_2_) Среди приведенных ниже фрагментов укажите все варианты кода, при подстановке которого вместо подчеркивания результатом выполнения скрипта станет строка 8:
• # Файл ../foo_p/__init__.py содержит следующий код: __all__=['foo1','foo2'] Файл ../foo_p/foo.py содержит следующий код: def f(x): return x**2 Файл ../foo_p/foo1.py содержит следующий код: def f(x): return x**3 Файл ../foo_p/foo2.py содержит следующий код: from foo_p.foo import f def fn(x): return f(x)*x Скрипт a.py содержит следующий код: _1_ print (_2_) Среди приведенных ниже фрагментов укажите все варианты кода, при подстановке которого вместо подчеркивания результатом выполнения скрипта станет строка 32:
• # Файл ../foo_p/__init__.py содержит следующий код: __all__=['foo1'] Файл ../foo_p/foo.py содержит следующий код: def f(x): return x**2 Файл ../foo_p/foo1.py содержит следующий код: def f(x): return x**3 Файл ../foo_p/foo2.py содержит следующий код: from foo_p import foo1 def fn(x): return foo1.f(x)*x Скрипт a.py содержит следующий код: _1_ print (_2_) Среди приведенных ниже фрагментов укажите все варианты кода, при подстановке которого вместо подчеркивания результатом выполнения скрипта станет строка 8:
• # Файл ../foo_p/__init__.py содержит следующий код: __all__=['foo','foo1'] Файл ../foo_p/foo.py содержит следующий код: def f(x): return x**2 Файл ../foo_p/foo1.py содержит следующий код: def f(x): return x**3 Файл ../foo_p/foo2.py содержит следующий код: from foo_p.foo1 import f def fn(x): return f(x)*x Скрипт a.py содержит следующий код: _1_ print (_2_) Среди приведенных ниже фрагментов укажите все варианты кода, при подстановке которого вместо подчеркивания результатом выполнения скрипта станет строка 81:
• # Файл ../foo_p/__init__.py содержит следующий код: __all__=['foo','foo2'] Файл ../foo_p/foo.py содержит следующий код: def f(x): return x**2 Файл ../foo_p/foo1.py содержит следующий код: def f(x): return x**3 Файл ../foo_p/foo2.py содержит следующий код: from foo_p.foo1 import f def fn(x): return f(x)*x Скрипт a.py содержит следующий код: _1_ print (_2_) Среди приведенных ниже фрагментов укажите все варианты кода, при подстановке которого вместо подчеркивания результатом выполнения скрипта станет строка 64:
• # Файл ../foo_p/__init__.py содержит следующий код: __all__=['foo','foo1'] Файл ../foo_p/foo.py содержит следующий код: def f(x): return x**2 Файл ../foo_p/foo1.py содержит следующий код: def f(x): return x**3 Файл ../foo_p/foo2.py содержит следующий код: from foo1 import f def fn(x): return f(x)*x Скрипт a.py содержит следующий код: _1_ print (_2_) Среди приведенных ниже фрагментов укажите все варианты кода, при подстановке которого вместо подчеркивания результатом выполнения скрипта станет строка 32:
• # При попытке повторной сериализации объектов:
• # При сериализации и десериализации объектов произвольного класса необходимо, чтобы:
• # При десериализации объекта произвольного класса конструктор класса:
• # Сериализация произвольных объектов необходима для:
• # Модули Pickle и cPickle отличаются
• # Модули Pickle и cPickle сериализуют данные в формат:
• # Файл foo.py содержит следующий код: class Foo(object): def __init__ (self, x): self.val=x def __str__ (self): return str(self.val) Скрипт a.py содержит следующий код: import pickle, foo o = foo.Foo(list(range(4))) with open('temp.pkl', 'wb') as f: pickle.dump(o, f, pickle.HIGHEST_PROTOCOL) Скрипт b.py содержит следующий код: import pickle with open('temp.pkl', 'rb') as f: x = pickle.load(f) print (x) Укажите результат последовательного выполнения скриптов a.py и b.py:
• # Файл foo.py содержит следующий код: class Foo(object): def __init__ (self, x): self.val=x def __str__ (self): return str(self.val) Укажите результат выполнения скрипта: import pickle, foo, os o = foo.Foo(list(range(4))) with open('temp.pkl', 'wb') as f: pickle.dump(o, f, pickle.HIGHEST_PROTOCOL) with open('temp.pkl', 'rb') as f: x = pickle.load(f) print (x)
• # Файл foo.py содержит следующий код: class Foo(object): def __init__ (self, x): self.val=x def __str__ (self): return str(self.val) Скрипт a.py содержит следующий код: import pickle, foo o = foo.Foo(list(range(4))) with open('temp.pkl', 'wb') as f: pickle.dump(o, f, pickle.HIGHEST_PROTOCOL) Скрипт b.py содержит следующий код: import pickle with open('temp.pkl', 'r') as f: x = pickle.load(f) print (x) Укажите результат последовательного выполнения скриптов a.py и b.py:
• # Файл foo.py содержит следующий код: class Foo(object): def __init__ (self, x): self.val=x def __str__ (self): return str(self.val) Скрипт содержит следующий код: import pickle, foo, os o = foo.Foo(list(range(4))) with open('temp.pkl', 'wb') as f: pickle.dump(o, f, pickle.HIGHEST_PROTOCOL) del foo, o, f with open('temp.pkl', 'rb') as f: x = pickle.load(f) print (str(x)) Укажите результат выполнения скрипта:
• # Файл foo.py содержит следующий код: class Foo(object): def __init__ (self, x): self.val=x def __str__ (self): return str(self.val) Скрипт a.py содержит следующий код: import pickle, foo, os o = foo.Foo(list(range(4))) with open('temp.pkl', 'wb') as f: pickle.dump(o, f, pickle.HIGHEST_PROTOCOL) f.close() Скрипт b.py содержит следующий код: import pickle with open('temp.pkl', 'r') as f: x = pickle.load(f) print (x) Укажите результат последовательного выполнения скриптов a.py и b.py:
• # Файл foo.py содержит следующий код: class Foo(object): def __init__ (self, x): self.val=x def __str__ (self): return str(self.val) Скрипт a.py содержит следующий код: import pickle, foo, os o = foo.Foo(list(range(4))) with open('temp.pkl', 'wb') as f: pickle.dump(o, f, pickle.HIGHEST_PROTOCOL) f.close() Скрипт b.py содержит следующий код: import pickle with open('temp.pkl', 'rb') as f: x = pickle.load(f) print (x) Укажите результат выполнения скрипта b.py:
• # Укажите результат выполнения скрипта: import pickle a = [1, 2] a.append([1, 2]) with open('temp.pkl', 'wb') as f: pickle.dump(a, f, pickle.HIGHEST_PROTOCOL) with open('temp.pkl', 'rb') as f: b, c = pickle.load(f) print (c) print (b is c, b == c)
• # Укажите результат выполнения скрипта: import pickle a = [1, 2] b = [3, 4] a.append(b) b.append(a) with open('temp.pkl', 'w') as f: pickle.dump(a, f, pickle.HIGHEST_PROTOCOL) with open('temp.pkl', 'r') as f: c = pickle.load(f) with open('temp.pkl', 'w') as f: pickle.dump(b, f, pickle.HIGHEST_PROTOCOL) with open('temp.pkl', 'r') as f: d = pickle.load(f) print (c, d)
• # Укажите результат выполнения скрипта: import pickle a = [1, 2] a.append(a) with open('temp.pkl', 'wb') as f: pickle.dump(a, f, pickle.HIGHEST_PROTOCOL) with open('temp.pkl', 'r') as f: b = pickle.load(f) with open('temp.pkl', 'wb') as f: pickle.dump(a[2], f, pickle.HIGHEST_PROTOCOL) with open('temp.pkl', 'r') as f: c = pickle.load(f) print (b, c)
• # Укажите результат выполнения скрипта: import pickle a = [1, 2] b = [3, 4] a.append(b) b.append(a) with open('temp.pkl', 'wb') as f: pickle.dump(a, f, pickle.HIGHEST_PROTOCOL) with open('temp.pkl', 'rb') as f: c= pickle.load(f) print (c) print (c is a, c[2] is b)
• # Укажите результат выполнения скрипта: import pickle a = [1, 2] a.append(a) with open('temp.pkl', 'wb') as f: pickle.dump(a, f, pickle.HIGHEST_PROTOCOL) with open('temp.pkl', 'rb') as f: b= pickle.load(f) print (b) print (b is a, b[2] is b)
• # Укажите результат выполнения скрипта: import pickle a = [1, 2] b = [3, 4] a.append(b) b.append(a) with open('temp.pkl', 'wb') as f: pickle.dump((a,b), f, pickle.HIGHEST_PROTOCOL) with open('temp.pkl', 'rb') as f: c,d= pickle.load(f) print (c) print (c[2] is d, c[2] == d)
• # Укажите результат выполнения скрипта: class str(object): def __new__ (self, lst): res=0 for i in lst: res+=1 return res print (str(range(5, 8)))
• # Укажите результат выполнения скрипта: def add (x, y): return x+y class add(object): def __call__ (self, x, y): return (x+y)*2 f = add() print (f(1, 2))
• # Укажите результат выполнения скрипта: def add (x, y): return x+y class add(object): def __init__ (self, x, y): return (x+y)*2 print (add(1, 2))
• # Укажите результат выполнения скрипта: class len(object): def __call__ (self, lst): res=0 for i in lst: res+=1 return res print (len(range(5, 8)))
• # Укажите результат выполнения скрипта: class len(object): def __call__ (self, lst): res=0 for i in lst: res+=1 return res foo = len() print (foo(range(8)))
• # Укажите результат выполнения скрипта: class str(object): def __init__ (self, lst): res=0 for i in lst: res+=1 return res print (str(range(0, 4)))
• # Укажите результат выполнения скрипта: class Foo(object): def __init__(self, v): self.__val__ = v def __add__(self, y): return Foo(self.__val__ + y - 1) def __repr__ (self): return str(self.__val__) x = Foo(1) print (x+2, 2+x)
• # Укажите результат выполнения скрипта: class Foo(object): def __init__(self, v): self.__val__ = v def __isub__(self, y): return self.__val__ - y + 1 def __sub__(self, y): return self.__val__ - y + 1 def __repr__ (self): return str(self.__val__) x = Foo(3) x-=2 print (x, x-1)
• # Укажите результат выполнения скрипта: class Foo(object): def __init__(self, v): self.__val__ = v def __rsub__(self, y): return self.__val__ - y + 1 def __isub__(self, y): return Foo(self.__val__ - y + 1) def __repr__ (self): return str(self.__val__) x = Foo(5) x-=3 print (x, x-1)
• # Укажите результат выполнения скрипта: class Foo(int): def __init__(self, v): self.__val__ = v def __mul__(self, y): self.__val__ *= y return self x = Foo(2) print (type(x*5), type(5*x))
• # Укажите результат выполнения скрипта: class Foo(int): def __init__(self, v): self.__val__ = v def __imul__(self, y): self.__val__ *= y return self def __rmul__(self, y): self.__val__ *= y return self def __repr__ (self): return str(self.__val__) x = Foo(2) print (x*3, 3*x)
• # Укажите результат выполнения скрипта: class Foo(int): def __init__(self, v): self.__val__ = v def __add__(self, y): return Foo(self.__val__ + y - 1) def __repr__ (self): return str(self.__val__) x = Foo(1) print (x+4, 4+x)
• # Укажите результат выполнения скрипта: class Foo(object): @classmethod def method1(): return 1 @staticmethod def method2(): return 2 def method3(): return 3 method3 = staticmethod(method3) print (Foo.method1(), Foo.method2(), Foo.method3())
• # Укажите результат выполнения скрипта: class Foo(object): @classmethod def method1(cls): return 1 @staticmethod def method2(cls): return 2 def method3(cls): return 3 method3 = classmethod(method3) print (Foo.method1(), end=' ') print (Foo.method2(), end=' ') print (Foo.method3(), end=' ')
• # Укажите результат выполнения скрипта: class Foo(object): @classmethod def method1(cls): return 1 @staticmethod def method2(): return 2 def method3(cls): return 3 method3 = classmethod(method3) print (Foo.method1(), end=' ') print (Foo.method2(), end=' ') print (Foo.method3(), end=' ')
• # Укажите результат выполнения скрипта: class Foo(object): @staticmethod def method1(): return 1 def method2(): return 2 def method3(): return 3 method2 = staticmethod(method2) print (Foo.method1(), Foo.method2(), Foo.method3())
• # Укажите результат выполнения скрипта: class Foo(object): method2 = staticmethod(method2) @staticmethod def method1(): return 1 def method2(): return 2 def method3(): return 3 print (Foo.method1(), Foo.method2(), Foo.method3())
• # Укажите результат выполнения скрипта: class Foo(object): @staticmethod def method1(): return 1 def method2(): return 2 def method3(): return 3 method2 = classmethod(method2) method3 = staticmethod(method3) print (Foo.method1()) print (Foo.method2()) print (Foo.method3())
• # Укажите результат выполнения скрипта: class Foo(int): @classmethod def method(cls, val=3): if cls is Foo: return val+2 else: return val+3 @staticmethod def method1(cls, val=3): if cls is Foo: return val+2 else: return val+3 print (Foo.method(1), Foo.method1(1))
• # Укажите результат выполнения скрипта: class Foo(int): @classmethod def method(cls, val=3): if isinstance (cls, Foo): return val+2 else: return val+3 @staticmethod def method1(cls, val=3): if isinstance (cls, Foo): return val+2 else: return val+3 f=Foo() print (f.method(1), f.method1(1))
• # Укажите результат выполнения скрипта: class Foo(int): def method(cls, val=3): if cls is Foo: return val+2 else: return val+3 method=classmethod(method) method=staticmethod(method) print (Foo.method(1), Foo().method1(1))
• # Укажите результат выполнения скрипта: class Foo(object): def __init__ (self): self.__val__=2 def method(cls, val): if isinstance (cls, Foo): return val+cls.__val__ else: return val+1 method = classmethod(method) f=Foo() print (Foo.method(1), f.method(1))
• # Укажите результат выполнения скрипта: class Foo(int): @staticmethod def method(cls, val=3): if cls == Foo: return val+2 else: return val+1 f=Foo() print (Foo.method(1), f.method(1))
• # Укажите результат выполнения скрипта: class Foo(int): @staticmethod def method(cls, val=3): if cls == Foo: return val+2 else: return val+1 method = classmethod(method) f=Foo() print (Foo.method(1), f.method(1))
• # Методы класса содержатся в пространстве имен:
• # Метакласс класса C можно определить по:
• # Метакласс М для класса C можно задать следующим образом:
• # Метакласс - это:
• # Метаклассами являются следующие встроенные классы:
• # Методы, определенные в метаклассе содержатся в пространстве имен:
• # Скрипт содержит следующий код: def foo(f): class X(object): pass return X def method(x, y): return x+y Cs = foo(method) o = Cs() ___________ print (o.method(2, 3)) Среди приведенных ниже фрагментов укажите все варианты кода, при подстановке которого вместо знаков подчеркивания результатом выполнения скрипта станет строка 5:
• # Скрипт содержит следующий код: def foo(f): class X(object): pass ____________ return X def method(lst): return len(lst) Cs = foo(method) print (Cs.method(range(7))) Среди приведенных ниже фрагментов укажите все варианты кода, при подстановке которого вместо знаков подчеркивания результатом выполнения скрипта станет строка 7:
• # Скрипт содержит следующий код: def foo(f): class X(object): pass return X def method(lst): return len(lst) Cs = foo(method) _________ print (Cs.method(range(3))) Среди приведенных ниже фрагментов укажите все варианты кода, при подстановке которого вместо знаков подчеркивания результатом выполнения скрипта станет строка 3:
• # Скрипт содержит следующий код: def foo(f): class X(object): pass ___________ return X def method(self): return 'hello' Cs = foo(method) o = Cs() print (o.method(), type(o)) Среди приведенных ниже фрагментов укажите все варианты кода, при подстановке которого вместо знаков подчеркивания результатом выполнения скрипта станет строка hello<class '__main__.X'>:
• # Скрипт содержит следующий код: def foo(f): class X(object): pass return X def method(): return 'hello' Cs = foo(method) o = Cs() _________ print (o.method()) Среди приведенных ниже фрагментов укажите все варианты кода, при подстановке которого вместо знаков подчеркивания результатом выполнения скрипта станет строка hello:
• # Скрипт содержит следующий код: def foo(f): class X(object): pass ___________ return X def method(x, y): return x+y Cs = foo(method) o = Cs() print (o.method(1, 2)) Среди приведенных ниже фрагментов укажите все варианты кода, при подстановке которого вместо знаков подчеркивания результатом выполнения скрипта станет строка 3:
• # Укажите результат выполнения скрипта: class foo(type): val=1 class A(object): val=0 __class__=foo print (type(A), A.val)
• # Укажите результат выполнения скрипта: class foo(type): val=1 class bar(type): val=2 class A(object, metaclass=foo): val=-1 class B(object, metaclass=bar): val=-2 class C(A,B): pass print (type(C), C.val)
• # Укажите результат выполнения скрипта: class foo(type): pass class bar(type): pass class A(object, metaclass=foo): val=-1 class B(object, metaclass=bar): val=-2 class baz (foo, bar): pass class C(A, B, metaclass=baz): pass print (type(C), C.val)
• # Укажите результат выполнения скрипта: class foo(type): def __new__(cls, name, bases, dict): return type.__new__(cls, name, bases, dict) o = foo('X', (), {}) print (type(o), o)
• # Укажите результат выполнения скрипта: class foo(type): def __new__(cls, name, bases, dict, defval=0): obj = type.__new__(cls, name, bases, dict) obj.val=defval return obj Cls = foo('X', (), {}) class SCls (Cls): pass print (SCls.val, type(SCls))
• # Укажите результат выполнения скрипта: class foo(type): val=1 class A(object): val=0 __metaclass__=foo print (type(A), A.val)