#Python
Вы всегда мечтали стать программистом, но не знаете, с чего начать? Или уже являетесь опытным разработчиком и хотите проверить свои знания? Тогда канал "Python | Тесты для программистов" идеально подойдет для вас! Этот канал предлагает ежедневные тесты, которые помогут вам проверить свои знания и улучшить навыки программирования на Python.
Канал @pythontest_it также предоставляет ссылку на портал @Portal_v_IT, где можно найти еще больше полезной информации о программировании. Кроме того, вы можете связаться с учредителями канала по вопросам сотрудничества: @oleginc, @tatiana_inc. Менеджер канала @Spiral_Yuri всегда готов помочь и ответить на ваши вопросы.
Присоединяйтесь к каналу "Python | Тесты для программистов" и станьте лучшим программистом с каждым днем! Ссылка на канал на бирже: https://telega.in/c/pythontest_it
08 Feb, 15:25
07 Feb, 15:07
28 Jan, 14:07
28 Jan, 09:07
25 Jan, 16:12
25 Jan, 09:07
24 Jan, 09:07
23 Jan, 16:09
names = ['Alice', 'Bob', 'Charlie']
numbers = [1, 2, 3, 4]
result = dict(zip(names, numbers))
print(result)
23 Jan, 11:07
def greet(name=None):
if name:
print(f"Hi {name}")
else:
print("Hi")
return name
result = greet()
print(f"Result: {result}")
12 Jan, 16:08
def make_handlers():
events = []
handlers = []
def register(event):
events.append(event)
def decorator(f):
handlers.append(f)
return f
return decorator
def dispatch(event):
return [h() for i, h in enumerate(handlers) if events[i] == event]
return register, dispatch
reg, disp = make_handlers()
@reg('click')
def handler1():
return 1
@reg('click')
def handler2():
return 2
@reg('submit')
def handler3():
return 3
print(disp('click'))
12 Jan, 12:18
from contextlib import contextmanager
def gen():
try:
yield 1
yield 2
finally:
print("Gen", end=" ")
@contextmanager
def ctx():
try:
yield from gen()
finally:
print("Ctx", end=" ")
g = gen()
with ctx():
print(next(g), end=" ")
raise ValueError
12 Jan, 10:16
12 Jan, 08:07
def outer(lst=[]):
def inner(val):
lst.append(val)
return lst
return inner
f1 = outer()
f2 = outer()
print(f1(1))
print(f1(2))
print(f2(3))
11 Jan, 16:08
def track_sum(method):
total = 0
def wrapper(self, x):
nonlocal total
total += x
print(f"Sum: {total}", end=" ")
return method(self, x)
return wrapper
class Calc:
@track_sum
def double(self, x):
return x * 2
@track_sum
def triple(self, x):
return x * 3
c = Calc()
print(c.double(2))
print(c.triple(3))
print(c.double(1))
11 Jan, 11:08
class Integer:
def __init__(self, value=0):
self._value = value
def __get__(self, obj, owner=None):
return self._value
def __set__(self, obj, value):
self._value = value + 1
class Counter:
x = Integer()
@property
def value(self):
return self.x
@value.setter
def value(self, val):
self.x = val - 1
c1 = Counter()
c2 = Counter()
c1.value = 5
print(c2.value)
print(c1.value)
11 Jan, 08:07
class Wrapper:
def __init__(self, value):
self.value = value
def __call__(self):
return self.value
def make_wrapper():
value = 10
w = Wrapper(value)
def change():
nonlocal value
value += 1
return w()
return change
func = make_wrapper()
print(func())
print(func())
print(func())
10 Jan, 16:09
class A:
def __init__(self):
self.x = self.value()
def value(self):
return 1
class B(A):
def __init__(self):
self.y = self.value()
super().__init__()
def value(self):
return super().value() + 1
b = B()
print(b.x)
print(b.y)
10 Jan, 12:22
def repeat(times):
def decorator(func):
def wrapper():
gen = func()
result = []
for _ in range(times):
try:
result.append(next(gen))
except StopIteration:
break
return result
return wrapper
return decorator
@repeat(3)
def sequence():
yield 1
yield 2
@repeat(2)
def infinite():
num = 0
while True:
yield num
num += 5
print(sequence())
print(infinite())
10 Jan, 08:07
def make_funcs(defaults=[]):
def append(x):
defaults.append(x)
return defaults
def get():
return defaults
return append, get
f1_append, f1_get = make_funcs()
f2_append, f2_get = make_funcs()
f1_append(1)
f2_append(2)
print(f1_get())
print(f2_get())
09 Jan, 14:10
09 Jan, 11:07
class TypeCheck:
def __init__(self, cls):
self.cls = cls
def __call__(self, val):
if not isinstance(val, self.cls):
raise TypeError
return val
class Meta(type):
def __new__(cls, name, bases, attrs):
new_attrs = {}
for key, value in attrs.items():
if hasattr(value, '__annotations__'):
orig_func = value
def wrapped(*args, **kwargs):
return_val = orig_func(*args, **kwargs)
return value.__annotations__['return'](return_val)
wrapped.__annotations__ = value.__annotations__
new_attrs[key] = wrapped
else:
new_attrs[key] = value
return super().__new__(cls, name, bases, new_attrs)
class Test(metaclass=Meta):
@staticmethod
def test() -> TypeCheck(int):
return "123"
print(Test.test())
print(type(Test.test()))
09 Jan, 09:07
09 Jan, 08:07
def wrap(f):
def inner(self):
self.x *= 2
return f(self)
return inner
class Outer:
x = 1
class Inner:
def __init__(self):
self.x = Outer.x
@wrap
def get(self):
return self.x
@classmethod
def create(cls):
return cls.Inner()
a = Outer.create()
b = Outer.create()
print(a.get())
Outer.x = 5
print(b.get())
08 Jan, 16:08
class Wrapper:
def __init__(self, value):
self.value = value
def __iter__(self):
return iter(range(self.value))
def __next__(self):
self.value -= 1
if self.value < 0:
raise StopIteration
return self.value
x = Wrapper(3)
print(sum(x))
print(next(x))
print(next(x))
print(sum(x))
08 Jan, 14:07
08 Jan, 11:07
class MetaCount(type):
_count = 0
def __call__(cls, *args, **kwargs):
cls._count += 1
return super().__call__(*args, **kwargs)
class Counter:
def __get__(self, obj, owner):
return owner._count
def __set__(self, obj, val):
obj.__class__._count = val
class A(metaclass=MetaCount):
count = Counter()
a1 = A()
a2 = A()
print(A.count)
a1.count = 10
print(a2.count)
print(A.count)
08 Jan, 09:06
08 Jan, 08:07
from contextlib import contextmanager
@contextmanager
def ctx(x):
print(f"Enter {x}", end=" ")
yield x
print(f"Exit {x}", end=" ")
def deco(func):
def wrapper(*args):
with ctx(1):
return func(*args)
return wrapper
@deco
def test():
with ctx(2):
print("Mid", end=" ")
test()
07 Jan, 08:07
class A:
x = 1
def __init__(self):
self.y = self.x
self.x = 2
class B(A):
x = 3
def __init__(self):
self.y = self.x
super().__init__()
class C(B):
def __init__(self):
super().__init__()
print(self.x, self.y)
c = C()
06 Jan, 16:07
class MetaA(type):
def __new__(cls, name, bases, dct):
def wrap(f):
def wrapper(*args, **kwargs):
wrapper.calls = getattr(wrapper, 'calls', 0) + 1
if wrapper.calls > 1:
return None
return f(*args, **kwargs)
return wrapper
for key, value in dct.items():
if callable(value):
dct[key] = wrap(value)
return super().__new__(cls, name, bases, dct)
class A(metaclass=MetaA):
def m(self): return 1
a = A()
print(a.m())
print(a.m())
print(a.m())
06 Jan, 11:07
from contextlib import contextmanager
@contextmanager
def ctx(x):
print(f"Enter {x}", end=" ")
yield x + 1
print(f"Exit {x}", end=" ")
def gen():
with ctx(1) as x:
with ctx(2) as y:
return x + y
g = gen()
print(g)
06 Jan, 09:15
06 Jan, 08:07
class Descriptor:
def __init__(self):
self._value = 0
def __get__(self, obj, owner):
self._value += 1
return self._value
def __set__(self, obj, val):
self._value = val
class C:
x = Descriptor()
@property
def y(self):
self._y = getattr(self, '_y', 0) + 1
return self._y
a = C()
b = C()
print(a.x, b.x, a.y, b.y)
05 Jan, 16:53
import asyncio
async def f():
a = 2
await asyncio.sleep(0)
a = 3
return a
async def main():
tasks = [f(), f()]
done, _ = await asyncio.wait(tasks)
print(sum(t.result() for t in done))
asyncio.run(main())
05 Jan, 11:07
def log_init(cls):
orig_init = cls.__init__
def __init__(self, *args, **kwargs):
self.calls = getattr(self, 'calls', 0)
self.calls += 1
orig_init(self, *args, **kwargs)
cls.__init__ = __init__
return cls
class Meta(type):
def __new__(cls, name, bases, dct):
x = super().__new__(cls, name, bases, dct)
return log_init(x)
class A(metaclass=Meta):
pass
a = A()
b = A()
print(a.calls)
print(b.calls)
print(A().calls)
05 Jan, 08:07
def counter():
counter.count = getattr(counter, 'count', 0) + 1
yield counter.count
counter.count += 2
yield counter.count
c1 = counter()
c2 = counter()
print(next(c1))
print(next(c2))
print(next(c1))
04 Jan, 16:09
f = lambda n: 1 if n <= 2 else f(n-1) + f(n-2)
print(f(4))
g = lambda n: n if n <= 2 else g(n-1) + g(n-2)
print(g(4))
04 Jan, 11:07
def make_decorator(start):
def decorator(func):
nonlocal start
def wrapper():
nonlocal start
start += 2
return func() + start
return wrapper
return decorator
@make_decorator(3)
def value():
return 10
print(value())
print(value())
27 Dec, 16:07
def make_closure():
value = [10]
def closure():
value[0] += 5
return value[0]
return closure
func = make_closure()
print(func())
print(func())
27 Dec, 14:07
27 Dec, 11:07
a = [1, 2, 3]
b = [4, 5]
zipped = zip(a, b)
unzipped = zip(*zipped)
print(list(unzipped))
27 Dec, 09:07
27 Dec, 08:07
data = {1: 'a', 2: 'b', 3: 'c'}
for key in list(data.keys()):
data[key + 3] = data.pop(key)
print(data)
26 Dec, 18:37
def outer():
x = 10
def inner():
nonlocal x
x += 5
return x
return inner
func = outer()
print(func())
print(func())
26 Dec, 15:50
26 Dec, 11:07
a = 3
b = 5
c = 7
result = a < b < c == (a + b)
print(result)
26 Dec, 08:07
def copy_and_modify(lst):
copy = lst[:]
copy.append(4)
return copy
original = [1, 2, 3]
result = copy_and_modify(original)
print(original)
print(result)
25 Dec, 16:07
def extend_list(value, lst=[]):
lst.append(value)
return lst
list1 = extend_list(1)
list2 = extend_list(2, [])
list3 = extend_list(3)
print(list1)
print(list2)
print(list3)
25 Dec, 14:07
25 Dec, 11:07
def modify_list(lst):
lst += [4, 5]
return lst
my_list = [1, 2, 3]
result = modify_list(my_list)
print(my_list)
print(result)
25 Dec, 09:07
25 Dec, 08:07
def multiplier(factor):
def multiply_by(value):
return value * factor
factor = 10
return multiply_by
double = multiplier(2)
print(double(3))
print(double(4))
24 Dec, 16:59
def append_value(value, lst=None):
if lst is None:
lst = []
lst.append(value)
return lst
list1 = append_value(1)
list2 = append_value(2)
print(list1)
print(list2)
24 Dec, 14:58
24 Dec, 11:07
counter = 0
def increment():
global counter
counter += 1
return counter
print(increment())
print(increment())
print(counter)
24 Dec, 08:07
def outer_func():
result = []
def inner_func(value):
result.append(value)
return sum(result)
return inner_func
calc = outer_func()
print(calc(10))
print(calc(20))
print(calc(30))
23 Dec, 16:07
def add_to_list(value, lst=[]):
lst.append(value)
return lst
list1 = add_to_list(1)
list2 = add_to_list(2)
print(list1)
print(list2)
23 Dec, 11:07
def update_data(data, value):
data['key'] = value
data = {'key': value * 2}
my_dict = {'key': 1}
update_data(my_dict, 5)
print(my_dict)
09 Dec, 16:07
class A:
def process(self):
return "A"
class B(A):
def process(self):
return f"B -> {super().process()}"
class C(A):
def process(self):
return f"C -> {super().process()}"
class D(B, C):
def process(self):
return f"D -> {super().process()}"
obj = D()
print(obj.process())
09 Dec, 11:07
def decorator_one(func):
def wrapper(*args, **kwargs):
return f"One({func(*args, **kwargs)})"
return wrapper
def decorator_two(func):
def wrapper(*args, **kwargs):
return f"Two({func(*args, **kwargs)})"
return wrapper
@decorator_one
@decorator_two
def say_hello(name):
return f"Hello, {name}"
print(say_hello("Python"))
09 Dec, 09:07
09 Dec, 08:07
class Meta(type):
def __new__(cls, name, bases, dct):
dct['greet'] = lambda self: f"Hello from {self.__class__.__name__}"
return super().__new__(cls, name, bases, dct)
class Base(metaclass=Meta):
pass
class Derived(Base):
pass
obj = Derived()
print(obj.greet())
08 Dec, 16:07
def create_multiplier(n):
return lambda x: x * n
mult_by_2 = create_multiplier(2)
mult_by_3 = create_multiplier(3)
print(mult_by_2(mult_by_3(4)))
08 Dec, 11:07
x = (1, [2, 3], 4)
x[1].append(5)
print(x)
08 Dec, 08:07
x = [1, 2, 3]
y = x
y.append(4)
print(len(x))
29 Nov, 10:34
28 Nov, 14:07
28 Nov, 10:39
25 Nov, 14:07
24 Nov, 14:07
23 Nov, 09:13
18 Nov, 15:07
18 Nov, 09:07
17 Nov, 09:50
14 Nov, 15:03
14 Nov, 09:07
08 Nov, 14:07
07 Nov, 14:12
07 Nov, 09:07
27 Oct, 10:34
26 Oct, 14:07
25 Oct, 14:37
25 Oct, 09:07
24 Oct, 14:07
22 Oct, 10:11
21 Oct, 09:07
20 Oct, 14:14
19 Oct, 14:07
18 Oct, 15:43