empt1 = [] # это пустой список
empt2 = list()  # и это тоже пустой список

primes.append(13)
primes.append(15)  # ой, ошиблись — 15 составное число!

my_list = [1, 2, 3]
another_list = [4, 5, 6]
my_list.extend(another_list)
print(my_list)
[1, 2, 3, 4, 5, 6]

s = input()
n = len(s)
mid = n//2
if n % 2 == 0:
  mid -= 1
l1 = mid - 1
r = mid+1
if n % 2==0:
  r += 1
print( ' ' * (l1+1), s[l1+1:r], sep='')
while l1 >= 0:
  print(' ' * (l1), s[l1], ' ' * (r-l1-1), s[r], sep='')

list1 = [3, 4, 1, 8, 0]  # Исходный список
n = len(list1)  # Определяем длину списка

for i in range(n):  # Внешний цикл: выполняется n раз (по числу элементов в списке)
    for j in range(1, n - i):  # Внутренний цикл: проходит по неотсортированной части списка
        if list1[j - 1] > list1[j]:  # Если текущий элемент больше следующего:
            list1[j - 1], list1[j] = list1[j], list1[j - 1]  # Меняем их местами

print(list1)  # Выводим отсортированный список


разберем каждую итерацию внешнего и внутреннего циклов, записывая значения всех переменных.

---

### Исходный список:
`list1 = [3, 4, 1, 8, 0]`  
`n = 5` (длина списка)

---

### **Внешний цикл `i=0` (первый проход):**
- Количество итераций внутреннего цикла: `range(1, n - i)` → `range(1, 5)` (проход по индексам `j=1, 2, 3, 4`).

#### Внутренний цикл:
1. **Итерация `j=1`:**
   - Сравниваем: `list1[j-1] = list1[0] = 3` и `list1[j] = list1[1] = 4`.
   - Условие: `3 > 4` — **ложь**, обмена нет.
   - Список: `[3, 4, 1, 8, 0]`.

2. **Итерация `j=2`:**
   - Сравниваем: `list1[j-1] = list1[1] = 4` и `list1[j] = list1[2] = 1`.
   - Условие: `4 > 1` — **истина**, меняем местами.
   - Список: `[3, 1, 4, 8, 0]`.

3. **Итерация `j=3`:**
   - Сравниваем: `list1[j-1] = list1[2] = 4` и `list1[j] = list1[3] = 8`.
   - Условие: `4 > 8` — **ложь**, обмена нет.
   - Список: `[3, 1, 4, 8, 0]`.

4. **Итерация `j=4`:**
   - Сравниваем: `list1[j-1] = list1[3] = 8` и `list1[j] = list1[4] = 0`.
   - Условие: `8 > 0` — **истина**, меняем местами.
   - Список: `[3, 1, 4, 0, 8]`.

---

### **Внешний цикл `i=1` (второй проход):**
- Количество итераций внутреннего цикла: `range(1, n - i)` → `range(1, 4)` (проход по индексам `j=1, 2, 3`).

#### Внутренний цикл:
1. **Итерация `j=1`:**
   - Сравниваем: `list1[j-1] = list1[0] = 3` и `list1[j] = list1[1] = 1`.
   - Условие: `3 > 1` — **истина**, меняем местами.
   - Список: `[1, 3, 4, 0, 8]`.

2. **Итерация `j=2`:**
   - Сравниваем: `list1[j-1] = list1[1] = 3` и `list1[j] = list1[2] = 4`.
   - Условие: `3 > 4` — **ложь**, обмена нет.
   - Список: `[1, 3, 4, 0, 8]`.

3. **Итерация `j=3`:**
   - Сравниваем: `list1[j-1] = list1[2] = 4` и `list1[j] = list1[3] = 0`.
   - Условие: `4 > 0` — **истина**, меняем местами.
   - Список: `[1, 3, 0, 4, 8]`.

---

### **Внешний цикл `i=2` (третий проход):**
- Количество итераций внутреннего цикла: `range(1, n - i)` → `range(1, 3)` (проход по индексам `j=1, 2`).

#### Внутренний цикл:
1. **Итерация `j=1`:**
   - Сравниваем: `list1[j-1] = list1[0] = 1` и `list1[j] = list1[1] = 3`.
   - Условие: `1 > 3` — **ложь**, обмена нет.
   - Список: `[1, 3, 0, 4, 8]`.

2. **Итерация `j=2`:**
   - Сравниваем: `list1[j-1] = list1[1] = 3` и `list1[j] = list1[2] = 0`.
   - Условие: `3 > 0` — **истина**, меняем местами.
   - Список: `[1, 0, 3, 4, 8]`.

---

### **Внешний цикл `i=3` (четвертый проход):**
- Количество итераций внутреннего цикла: `range(1, n - i)` → `range(1, 2)` (проход по индексу `j=1`).

#### Внутренний цикл:
1. **Итерация `j=1`:**
   - Сравниваем: `list1[j-1] = list1[0] = 1` и `list1[j] = list1[1] = 0`.
   - Условие: `1 > 0` — **истина**, меняем местами.
   - Список: `[0, 1, 3, 4, 8]`.

---

### **Внешний цикл `i=4` (пятый проход):**
- Внутренний цикл не выполняется, так как `n - i = 1`.

---

### Итог:
Список отсортирован: `[0, 1, 3, 4, 8]`.

list1 = [3, 4, 1, 8, 0]
n = len(list1)
for i in range(n):
    for j in range(1, n - i):
        if list1[j - 1] > list1[j]:
            list1[j - 1], list1[j] = list1[j], list1[j - 1]
print(list1)

numbers = [1, 2, 3, 4, 5]
squared = [x ** 2 for x in numbers]
print(squared)  # Вывод: [1, 4, 9, 16, 25]

numbers = [1, 2, 3, 4]
results = [x ** 2 if x % 2 == 0 else x ** 3 for x in numbers]
print(results)  # Вывод: [1, 4, 27, 16]

result = [x ** 2 if x > 0 else -x for x in range(-10, 10) if x != 0]

#Вместо этого:
result = []
for x in range(-10, 10):
    if x != 0:
        result.append(x ** 2 if x > 0 else -x)

Кортежи

Кортежи очень похожи на списки, они тоже являются индексированной коллекцией, только вместо квадратных в них используются круглые скобки (причем их часто можно пропускать):

# кортеж из двух элементов; тип элементов может быть любой
card = ('7', 'spades')           
          
# пустой кортеж (из 0 элементов)
empty = ()

# кортеж из 1 элемента - запятая нужна, чтобы отличить от обычных скобок
t = (18,)

# длина, значение отдельного элемента, сложение - как у списков
print(len(card), card[0], card + t)

(1, 2) == (1, 3)    # False
(1, 2) < (1, 3)     # True
(1, 2) < (5,)       # True
('7', 'clubs') > ('7', 'hearts')    # False

# А вот так сравнивать нельзя: элементы кортежей разных типов
(1, 2) < ('7', 'spades')

Неизменяемость

Важнейшее техническое отличие кортежей от списков — неизменяемость. Как и к строке, к кортежу нельзя добавить элемент методом append, а существующий элемент нельзя изменить, обратившись к нему по индексу. Это выглядит недостатком, но в дальнейшем мы поймем, что у кортежей есть и преимущества.

n, s = 10, 'hello'
# то же самое, что
n = 10
s = 'hello'

В примере выше мы создали кортеж, стоящий справа от =, прямо на этой же строчке. Но можно заготовить его и заранее:

cards = [('7', 'spades'), ('Д', 'clubs'), ('Т', 'spades')]
value, suit = cards[0]
print('Достоинство карты:', value) # 7, присваивается по очерёдно первый индекс
print('Масть карты:', suit) # spades, а затем второй

Итак, на данный момент мы знаем уже четыре вида коллекций: строки, списки, множества и кортежи. У вас может возникнуть вопрос: можно ли из одной коллекции сделать другую?

Зачем нужно преобразование коллекций?

Преобразование строки в список позволяет получить список символов. В некоторых задачах это может быть полезно: например, если мы хотим изменить один символ строки:

s = 'beaytiful'   # Написали с ошибкой
a = list(s)         # a == ['b', 'e', 'a', 'y', 't', 'i', 'f,' 'u', 'l']
a[3] = 'u'          # a == ['b', 'e', 'a', 'u', 't', 'i', 'f,' 'u', 'l']

Если ваш код работает, но вы хотите устранить предупреждения:

1. Отключите строгую проверку типов для данного участка
Добавьте комментарий, чтобы анализатор игнорировал это место:

# type: ignore
a[1] = 1828  # type: ignore