Python: ООП и классы - тест 1

Конструктор класса задается методом с именем:

Если в классе определен деструктор с двумя и более параметрами, то:

Если в классе определены два метода с одинаковыми именами и разными списками параметров, то:

Значением поля класса по умолчанию может являться

В языке 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)