название текущего локального репозитория
git remote 

возможно пушить в несколько репозиториев, например сразу в github, bitbucket
ссылки на удаленные репозитории
для push и fetch отдельно (возможно пушить в один репозиторий, а подтягивать из другого)

git remote -v

class Parent:
    def print(self):
        print("A")

class Mixin(Parent):
    def print(self):
        print("B")

class Main(Parent, Mixin):
    def print(self):

        super().print()
        print("C")

# What will be printed? Why?
Main().print()

# A
# B
# C

import datetime

datetime.datetime.now = lambda: datetime.datetime(2017, 12, 12)
# Is it correct code? How it can be used?

TypeError: cannot set 'now' attribute of immutable type 'datetime.datetime'

from functools import reduce


def unit_and_sort_lists(lists):
    if len(lists) > 1:
        total_list = reduce(lambda x, y: x + y, lists, [])
    else:
        total_list = lists[0]
    return sorted(total_list)


def factorial(num):
    if num < 0:
        return False
    if num == 0:
        return 0
    result = 1
    for el in range(1, num + 1):
        result *= el
    return result


arr_lists = [[1, 3, 5], [2, 4, 6], [7, 8, 9]]
assert_result = [1, 2, 3, 4, 5, 6, 7, 8, 9]

print(unit_and_sort_lists(arr_lists))


==========*тесты*=========
from src.tasks import factorial, unit_and_sort_lists
import pytest


@pytest.mark.parametrize(
    "n, result",
    [
        (0, 0),
        (1, 1),
        (5, 120),
        (-1, False),

    ]
)
def test_factorial(n, result):
    assert factorial(n) == result


@pytest.mark.parametrize(
    "lists, result", [

        ([[]], []),
        ([[1, 2, 3]], [1, 2, 3]),
        ([[1, 3, 5], [2, 4, 6], [7, 8, 9]], [1, 2, 3, 4, 5, 6, 7, 8, 9]),
        ([[1, 2, 3], [2, 4, 5], [1, 3, 6]], [1, 1, 2, 2, 3, 3, 4, 5, 6]),
        ([[-2, -1, 0], [1, 2, 3]], [-2, -1, 0, 1, 2, 3])
    ]
)
def test_unit_and_sort_lists(lists, result):
    assert unit_and_sort_lists(lists) == result

@pytest.mark.parametrize(
    "num, result", [

        (0, None),
        (1000, 'millennium'),
        (100000000000000, 'millennium'),
        (-20000, 'millennium'),
        (-19999, None)
    ]
)
def test_is_multiple_of_1000(num, result):
    assert is_multiple_of_1000(num) == result


@pytest.mark.parametrize(
    "input_data, result", [
        (60, 'restaurant'),
        (30, 'cafe'),
        (5, 'home'),
        (-20000, None),
        (0, None),
    ]
)
def test_get_venue_by_guest_count(monkeypatch, input_data, result):
    monkeypatch.setattr('builtins.input', lambda _: input_data)
    guest_count = get_user_input()
    assert get_venue_by_guest_count(guest_count) == result


@pytest.mark.parametrize(
    "list_in, result", [
        ([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [-2, -4, -6, -8, -10, -12, -14, -16, -18, -20]),
        ([-3, -5, 2, 13, -100, 1, 0], [6, 10, -4, -26, 200, -2, 0]),
        ([], []),
        ([0], [0]),
        ([1], [-2])
    ]
)
def test_multiply_by_neg2(list_in, result):
    assert multiply_by_neg2(list_in) == result


@pytest.mark.parametrize(
    "num_list, even_num_count", [
        ([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 5),
        ([-3, -5, 2, 13, -100, 1, 0], 3),
        ([], 0),
        ([0], 1),
        ([1, 3, 13, 17], 0)
    ]
)
def test_get_even_num_count(num_list, even_num_count):
    assert get_even_num_count(num_list) == even_num_count


@pytest.mark.parametrize("input_dict, expected_output", [
    ({'test': 'test_value', 'europe': 'eur', 'dollar': 'usd', 'ruble': 'rub'},
     {'test4': 'test_value', 'europe6': 'eur', 'dollar6': 'usd', 'ruble5': 'rub'}),

    ({'key': 'value'}, {'key3': 'value'}),

    ({'empty': '', 'long_key': 'value'}, {'empty5': '', 'long_key8': 'value'}),

    ({'a': 'alpha', 'b': 'beta'}, {'a1': 'alpha', 'b1': 'beta'})
])
def test_add_dict_key_len_into_key(input_dict, expected_output):
    assert add_dict_key_len_into_key(input_dict) == expected_output


# Параметризованные тесты для функции shift_left
@pytest.mark.parametrize("input_list, expected_output", [
    ([1, 2, 3, 4, 5], [2, 3, 4, 5, 1]),  # Простой случай
    ([7, 8, 9], [8, 9, 7]),  # Случай с 3 элементами
    ([10], [10]),  # Случай с одним элементом
    ([], []),  # Случай с пустым списком
    ([1, 2], [2, 1]),  # Случай с двумя элементами
])
def test_num_list_shift(input_list, expected_output):
    assert num_list_shift(input_list) == expected_output


@pytest.mark.parametrize("fib_list_count, expected_output", [
    (1, [0]),  # 1-е число Фибоначчи
    (5, [0, 1, 1, 2, 3]),  # [0, 1, 1, 2, 3] -> [1, 1, 2, 3, 0]
    (8, [0, 1, 1, 2, 3, 5, 8, 13]),  # [0, 1, 1, 2, 3, 5, 8, 13] -> [1, 1, 2, 3, 5, 8, 13, 0]
    (15, [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]),  # [0, 1, ..., 377] -> [1, 1, ..., 0]
    (30, [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657,
          46368, 75025, 121393, 196418, 317811, 514229])  # [0, 1, ..., 832040] -> [1, 1, ..., 0]
])
def test_get_fibonacci_sequence(fib_list_count, expected_output):
    assert get_fibonacci_sequence(fib_list_count) == expected_output

#Для заданного числа N составьте программу вычисления суммы
#S=1+1/2+1/3+1/4+...+1/N, где N – натуральное число.

def get_harmonic_series_sum(n):
    if n <= 0:
        return False
    if n == 1:
        return Decimal(1)
    harmonic_sum = reduce(lambda x, a: x + (Decimal(1) / Decimal(a)), range(1, n + 1))
    return harmonic_sum.quantize(Decimal('0.000001'), ROUND_FLOOR)

@pytest.mark.parametrize(
    "num, exp_res", (
            [1, Decimal(1.0)],
            [2, Decimal(1.5)],
            [3, Decimal('1.833333')],
            [10, Decimal('2.928968')],
            [100, Decimal('5.187377')],
            [0, False],
            [-5, False]
    )
)
def test_get_harmonic_series(num, exp_res):
    assert get_harmonic_series_sum(num) == exp_res

ssh -vT git@github.com

"""
Для каждого натурального числа в промежутке от m до n вывести все делители,
кроме единицы и самого числа. m и n вводятся с клавиатуры.
"""
def get_interval_dividers(x, y):
    dividers_dict = {}
    for el in range(x, y + 1):
        dividers_dict[el] = []
        for divider in range(2, int(sqrt(el)) + 1):
            if el % divider == 0:
                dividers_dict[el].append(divider)
                if divider != el // divider:  # Добавляем сопряженный делитель
                    dividers_dict[el].append(el // divider)
    return dividers_dict


def get_interval():
    interval = list(map(int, input('press x y').strip().split(' ')))
    if len(interval) != 2 or interval[0] >= interval[1]:
        raise ValueError
    return interval


def run_interval_dividers_script():
    intervals = get_interval()
    pprint.pprint(get_interval_dividers(*intervals))



"""
Создать список поездов. Структура словаря: номер поезда,
пункт и время прибытия, пункт и время отбытия. Вывести все сведения о поездах,
время пребывания в пути которых превышает 7 часов 20 минут.
"""
cities_us = [
    "New York",
    "Los Angeles",
    "Chicago",
    "Houston",
    "Phoenix",
    "Philadelphia",
    "San Antonio",
    "San Diego",
    "Dallas",
    "San Jose",
    "Austin",
    "Jacksonville",
    "Fort Worth",
    "Columbus",
    "San Francisco",
    "Charlotte",
    "Indianapolis",
    "Seattle",
    "Denver",
    "Washington, D.C.",
    "Boston"
]

def generate_train_schedule(train_count):
    trains_schedule = {}
    now = datetime.datetime.now()
    for _ in range(0, train_count):
        arrival_time = datetime.datetime.combine(now.date(), datetime.time(randint(0, 23), randint(0, 59)))
        departure_time = arrival_time + datetime.timedelta(hours=randint(1, 23), minutes=randint(1, 59))
        trains_schedule[randint(1000, 9999)] = {
            'arrival': {
                'location': random.choice(cities_us),
                'time': arrival_time},
            'departure': {
                'location': random.choice(cities_us),
                'time': departure_time
            }
        }
    return trains_schedule


def get_long_way_trips(trains_schedule):
    return {
        train_num for train_num in trains_schedule if
        (trains_schedule[train_num]['departure']['time'] - trains_schedule[train_num]['arrival'][
            'time']) > datetime.timedelta(hours=7, minutes=20)
    }

Общий конфиг, в одной команде, username, email, ссылки для репозиториев(git remote -v) и их названия и тд 
git config --list

\l - список имеющихся баз данных
\c some_db - подключиться к бд some_db
\c - посмотреть к какой бд ты сейчас подключен
\dt - список таблиц в текущей db 
SELECT * FROM "some_table"; - содержимое выбранной таблицы (в postgres двойные ковычки и ; в конце критичны)

def binary_search(numbers_list, target_num):

    if not numbers_list: # пустой список
        return -1

    if len(numbers_list) == 1: # один элемент важно проверять на соответствие искомому
        if numbers_list[0] == target_num:
            return 0
        else:
            return -1

    low = 0
    high = len(numbers_list) - 1
    while low <= high: #понять почему допускается = вместо строгого <

        mid = (low + high) // 2 # как в python работает деление, почему 5//2=2, но -5//2=-3

        if numbers_list[mid] == target_num: # должна ли проверка находиться до очередного деления mid или после
            return mid 

        if numbers_list[mid] > target_num:
            high = mid - 1 # почему уменьшаем 
        else:
            low = mid + 1 # и увеличиваем
    return -1

def bubble_sort(num_list: list[int]) -> list[int]:
    # border cases как [ ], [1], обработает range, отдельно писать не нужно 
    is_swap = True
    while is_swap:
        is_swap = False
        for i in range(len(num_list)-1):
            if num_list[i] > num_list[i + 1]:
                num_list[i], num_list[i + 1] = num_list[i + 1], num_list[i] # python позволяет 1 строчкой менять элементы местами вместо temp переменной, техника называется кортежный своп(tuple swap)
                is_swap = True
    return num_list

def dumb_sort(num_list: list[int]) -> list[int]:
    is_swap = True
    while is_swap:
        is_swap = False
        for i in range(len(num_list)-1):
            if num_list[i] > num_list[i + 1]:
                num_list[i], num_list[i + 1] = num_list[i + 1], num_list[i]
                is_swap = True
            continue
    return num_list

def shake_sort(num_list: list[int]) -> list[int]:
    if len(num_list) < 2:
        return num_list
    low = 0
    high = len(num_list) - 1
    while low < high:
        for i in range(low, high):
            if num_list[i] > num_list[i + 1]:
                num_list[i], num_list[i + 1] = num_list[i + 1], num_list[i]
        high -= 1
        for i in range(high, low, -1):
            if num_list[i] < num_list[i - 1]:
                num_list[i], num_list[i - 1] = num_list[i - 1], num_list[i]
        low += 1
    return num_list

def even_odd_sort(num_list: list[int]) -> list[int]:
    if len(num_list) < 2:
        return num_list
    even_odd_switch = 0
    low = 0
    high = len(num_list) - 1
    pure_sort_passing = []
    while len(pure_sort_passing) < 2:
        pure_sort_passing.append(even_odd_switch)
        for i in range(low + even_odd_switch, high, 2):
            if num_list[i] > num_list[i + 1]:
                num_list[i], num_list[i + 1] = num_list[i + 1], num_list[i]
                if even_odd_switch in pure_sort_passing:
                    pure_sort_passing.remove(even_odd_switch)
        even_odd_switch = 1 - even_odd_switch  # swap even to odd and vice versa.
    return num_list

def comb_sort(num_list: list[int]) -> list[int]:
    if len(num_list) < 2:
        return num_list
    # Общепризнанный оптимальный фактор уменьшения
    reduction_factor = 1.247
    count = len(num_list)
    between_el_dist = count
    is_swap = True
    # если проходы с расстоянием больше 1 закончены, нужна финальная проверка классическим пузырьком
    # которая вызывается условием or between_el_dist > 1
    while is_swap or between_el_dist > 1:
        between_el_dist = max(1, int(between_el_dist // reduction_factor))

        high = count - between_el_dist

        is_swap = False
        for i in range(0, high):
            if num_list[i] > num_list[i + between_el_dist]:
                num_list[i], num_list[i + between_el_dist] = num_list[i + between_el_dist], num_list[i]
                is_swap = True
    return num_list

def insertion_sort(num_list: list[int]) -> list[int]:
    # моржовый оператор := позволяет внутри выражения присвоить переменную для дальнейшего использования 
    if (length := len(num_list)) < 2:
        return num_list

    for i in range(1, length):
        for j in range(i, 0, -1):
            if num_list[j - 1] > num_list[j]:
                num_list[j], num_list[j - 1] = num_list[j - 1], num_list[j]
            else:
                break
    return num_list

def selection_sort(num_list: list[int]) -> list[int]:
    if (length := len(num_list)) < 2:
        return num_list

    for i in range(length):
        current_max_index = 0
        for j in range(length - i):
            if num_list[j] > num_list[current_max_index]:
                current_max_index = j
        # no swap if index don't changed
        if current_max_index != length - i - 1:
            num_list[length - i - 1], num_list[current_max_index] = num_list[current_max_index], num_list[length - i - 1]
    return num_list