Задачи по Python и машинному обучению

from collections import deque
q = deque(maxlen=3)
q.append(1)
print(q)
q.appendleft(2)
print(q)
q.append(3)
print(q)
q.append(4)
print(q)
q.popleft()
print(q.popleft())

a, b, *c, d = (1,2,3,4,5,6)
print(c)

class A:
    def __init__(self):
        self.i = 0
    def __iter__(self):
        return self
    def __next__(self):
        if self.i > 2:
            raise StopIteration
        self.i += 1
        return self.i
a, b, c = A()
print(a, b, c)

def f():
    yield 1
    yield 2
    yield 3
a, *b = f()
print(a, b)

with open('sample.txt', "w") as file_object:
    a = file_object.closed
b = file_object.closed        
print(a, b)

L = ['abc' , [(1, 2) , ([3] , 4)] , 5]
L[1][1][0][0]

D = {}
A = D
B = D.copy()
B[ 'b' ] = 2
A[ 'b' ] = 3
print(D, B, A)

import numpy as np
a = np.array([1, 2, -1])
b = np.diff(a)
print(*b)

import numpy as np
a = np.array([0, 1, -2, 3])
b = a[abs(a) % 2 == 0]
print(*b)

import numpy as np
a, b = np.ones(1), np.ones(1)
a.dtype = 'int'
b = b.astype('int')
print(a[0] == 1, b[0] == 1)

import numpy as np
a, b = np.zeros(1), np.zeros(1)
a.dtype = 'int'
b = b.astype('int')
print(a[0] == 0, b[0] == 0)

import numpy as np
a = np.array([1, 1])
b = np.ndarray([1, 1])
print(*(a.shape + b.shape))

import numpy as np
a = np.array([0.1, 0.25])
b = np.array([0.1, 0.26])
c = np.allclose(a, b, atol=1e-1)
print(c)

import numpy as np
a = np.array([0.1, 0.25])
b = np.array([0.3, 0.26])
c = np.isclose(a, b, atol=1e-1)
print(*c)

import numpy as np
a = np.array([1, 1j])
x = np.isreal(a)
y = np.iscomplex(a)
z = x.sum() + y.sum()
print(z)

import numpy as np
a = np.array([True, False])
print(np.all(a), np.any(a))

import numpy as np
r = np.array([3, 4, 5])

import numpy as np
a = np.array([[0], [1]])
b = np.array([[1], [-1]])

import numpy as np
a = np.array([[0], [1]])
b = np.array([[1], [-1]])

import numpy as np
a = [('x', 6.0, 1), ('y', 5.0, 2), ('z', 5.0, 3)]
dtype = [('val', 'S1'), ('float', 'f8'), ('int', 'i4')]
b = np.array(a, dtype=dtype)
b.sort(order=['float', 'int'])
print(b[1][0].decode())

import numpy as np
dt = np.dtype([('x', 'f8')])
a = np.zeros(4, dtype=dt)
a['x'] = np.array((0., 1., 2., 3.))
print(a['x'][2] + a['x'][3])

import numpy as np
a = np.ones(2, dtype='int8,float32,complex')
a[0][0] = 2
a[1][1] = 3
a[0][2] = 4j
print(sum(a[0]).imag + sum(a[1]).real)

import numpy as np
a = np.array([1, 2, 3, 4])
b = np.searchsorted(a, 3.5)
print(b)

import numpy as np
a = np.array([30, 0, -1, 7])
x = np.argsort(a)
print(x[0])

import numpy as np
a = np.array([[3, 2], [1, -1]])
a.sort()
print(a[-1, 0])

import numpy as np
a = np.array([[1, 2], [3, 4]])
x = a.argmin()
y = a.argmax()
print(a.ravel()[x + y])

import numpy as np
a = np.array([[1, 2], [3, 4]])
b = (a.max(axis=1) - a.min(axis=0)).max()
print(b)

import numpy as np
x = np.linspace(0, 1, 2)
y = np.linspace(0, 1, 3)
X1, Y1 = np.meshgrid(x, y)
X2, Y2 = np.meshgrid(x, y, sparse=True)
print(*X1.shape, *Y1.shape, *X2.shape, *Y2.shape)

import numpy as np
x = np.linspace(0, 2, 3)
y = np.linspace(0, 1, 2)
X, Y = np.meshgrid(x, y)
print(int(X.sum()), int(Y.sum()))

import numpy as np
a = np.arange(4).reshape(2, 2)
b = a[:, np.newaxis, :]
print(b.shape)

import numpy as np
np.newaxis is None

import numpy as np
vals = np.arange(1, 10)
bools = (vals % 2 == 0) | (vals % 3 == 0) & ~(vals % 9 == 0)
print(vals[bools])

import numpy as np
a = np.array([1, 2, 3])
ia = np.array([True >> 0, False, True])
print(a[ia].sum())

import numpy as np
a = np.array([3, 1, 2])
ia = np.array([True, False, True])
print(a[ia].sum())

import numpy as np
a = np.arange(6).reshape(3, 2)
ia = np.array(((0, 0), (0, 1)))
ja = np.array(((1, 0), (0, 0)))
b = a[ia, ja]
print(b.sum() + b.ndim + b.size)

import numpy as np
a = np.array([[1, 3], [5, 7]])
a[:, 0] = 0
a[1, :] = 1
print(a.sum())

import numpy as np
a = np.array([1, 2, 3, 4, 5])
b = a[[0, 1, 2]]
c = a[0:3]
b[0] = -1
c[1] = -1
print(a[0], a[1])

import numpy as np
a = np.arange(8).reshape((2, 2, 2))
x = np.dsplit(a, 2)[0].sum()
print(x)

import numpy as np
a = np.arange(6)
a = a.reshape(-1, 1)
x = np.vsplit(a, 2)[-1].sum()
print(x)

import numpy as np 
a = np.arange(4)
x = np.hsplit(a, 2)[0]
print(x.sum())

import numpy as np
a = np.array([1, 2])
b = np.array([3, 4])
c = np.dstack((a, b))
print(c.shape)

import numpy as np
a = np.array([1, 2])
b = np.array([3, 4])
c = np.vstack((a, b))
print(c.shape)

import numpy as np
a = np.array([1, 2])
b = np.array([3, 4])
c = np.hstack((a, b))
print(c.shape)

import numpy as np
a = np.arange(4)
b = a.transpose()
x = a.shape == b.shape
print(x)

import numpy as np
a = np.linspace(1, 4, 4)
b = a.reshape(2, 2)
b[0, 0] = 0
print(a[0] + b[0, 0] + b[1, 1])

import numpy as np
a = np.linspace(1, 4, 4)
# ваш код
print(a)

import numpy as np
a = np.array(((1, 0, 1), (0, 1, 0)))
print(a.ndim)

import numpy as np
a = np.array(((1, 0, 1), (0, 1, 0)))
print(a.shape)

import numpy as np
x = np.fromfunction(lambda i, j: 2 * i * j, (3, 3), dtype=int)
y = np.sum(x[1])
print(y)

def f(i, j):
    return i * j

x = np.fromfunction(f, (3, 3), dtype=int)
y = np.sum(x)
print(y)

import numpy as np
x = np.linspace(0, 5, 5, endpoint=False)
y = np.linspace(0, 5, 5, endpoint=True)
print(x.size - y.size)

import numpy as np
x, dx = np.linspace(0, 8, 9, retstep=True)
print(dx)

import numpy as np
a = np.arange(1, 2, 1)
b = np.linspace(1, 2, 1, dtype=int)
print(a + b)

import numpy as np
a = np.array((100, 101, 102, 103))
b = np.zeros_like(a)
print(np.sum(b))

import numpy as np
a = np.array((100, 101, 102, 103))
b = np.ones_like(a)
print(np.sum(b))

import numpy as np
b = np.array([[1., 2.], [3., 4.]])
b[0, 0] = 0
b[1, 1] = 0
a = np.sum(b)
print(a)

it = (lambda: i for i in [1, 2])
vals = [f() for f in [*it]]
print(sum(vals))

it = (lambda: i for i in [1, 2])
vals = [f() for f in it]
print(sum(vals))

a, *b = (1, 2, 3)
x = hasattr(a, '__iter__')
y = hasattr(b, '__iter__')
print(x, y)

import struct
s = struct.pack('fhb', 1, 1, 1)
print(len(s))

import pickle
s = pickle.dumps({"x": 1})
a = pickle.loads(s[1:])["x"]
print(a)

def dec(f):
  # Ваш код...
  def wrapper(*args, **kwargs):
    return f(*args, **kwargs)
  return wrapper

@dec
def add(a, b):
  return a + b

print(add.__name__)

from decimal import Decimal, ROUND_UP, ROUND_DOWN
a = Decimal(1)
b = Decimal(7)
c = a / b
x1 = c.quantize(Decimal('0.1'), rounding=ROUND_DOWN)
x2 = c.quantize(Decimal('0.1'), rounding=ROUND_UP)
print(x2 - x1)

class A:
    def __call__(self):
        return self
a = A()
print(a is a(), a() == a()())

def f(f): f(f)
res = f(f)
print(res)

def f(x):
    return x**3 + 6*x**2 + 12*x + 75
l = [f(i) for i in range(1, 2021, 3)]
s1 = sum([x // 2 for x in l])
s2 = sum([x >> 1 for x in l])
print(s1 - s2)

class Number(int, float): pass
x1 = Number(1)
x2 = Number(1.0)
print(x1 == x2)

s = set(dir('a')) - set(dir(b'a'))
x = 'encode' in s
y = 'decode' in s
print(x, y)

from functools import reduce
vals = (chr(x) for x in range(ord('a'), ord('d')))
print(reduce(lambda acc, x: x + acc[::-1] + x, vals, ''))

type(None) == NoneType

class MyBool(bool): pass
b = MyBool(True)
print(b == True, b is True)

try:
    raise IOError()
except OSError as err:
    print(isinstance(err, OSError), isinstance(err, IOError))

def a(z):
    x = 0
    try:
        x += 1
        100/z
        x += 1
    except ZeroDivisionError:
        try:
            x += 1
        finally:
            x += 1
            return x
    finally:
        x += 1
    return -1

print(a(0))

S = 'hello'
C = bytearray(S, encoding="ascii")

from collections import namedtuple  
rec = namedtuple('rec', ['x', 'y', 'z']) 
comp = rec(1, 2, [4, 5])

s = bytearray("hello", encoding="ascii")

import numpy as np
m = np.arange(4).reshape(2, 2)
d = np.fliplr(m).diagonal()
print(sum(d), np.trace(m))

a = [1]
a.insert(0, a)
a[0][0][-2][-2].append([2])
a[0][0][-1].append(3)
a[0][0][0][0][-1][0] *= -1
s = a[0][1] + a[0][0][2][-1] + a[0][0][2][-2]
print(s)