dialect+driver://username:password@host:port/database

Основа:
Linux + Docker | Windows(bash, sudo)
python или JavaScript или TypeScript

Доп:
Опыт в Solidity, BAS(BrowserAutomationStudio), Zennoposter, GO, Rust, git, node.js, а также автоматизации браузерной работы.

python 
import time


def timer(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        f = func(*args, **kwargs)
        end = time.time()
        print(end - start)

    return wrapper

[random.randint(0, 100) for _ in range(31)]

 выводы 
- в гите после каждой микрозадачи коммит, для наглядности процесса 
- найти паттерны тестирования, было неожиданным ступором вопрос, какие кейсы  тестировать 
- postman незаменим, функциональщина для запросов на сервер
- чем лучше программист вначале познал всю инфраструктуру проекта, тем быстрее он будет выполнять задачи в будущем, скурпулезное чтение кода маст хев
- + asyncio, pytest, fastapi, bidict(нужно узнать получше)

название текущего локального репозитория
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