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

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

a = [1, 2, 1, 1, 2, 2, 3, 3]
print('Количество элементов в списке без повторений: ', len(set(a))) # 3

ДЛЯ СОЗДАНИЯ ПУСТОГО КОРТЕЖА ИСПОЛЬЗУЕТСЯ:

empty_tuple = tuple()

Документация о типах методов и их использовании:
https://docs.python.org/3/library/stdtypes.html