Первая программа

Суть программирования заключается в автоматизировании рутинных операций.

Программа по сути это просто текстовый файлик, оформленный по особым правилам, который запускается так называемым интерпретатором. Интерпретатор анализирует написанный код и выполняет указанные инструкции.

Самый простой житейский пример программы — это рецепт приготовления блюда. Например:

1. Налить на раскалённую сковороду растительное масло
2. Разбить яйца
3. Посолить
4. Жарить 3 минуты до готовности

тут у нас строгий набор команд, который выполняются последовательно. В качества интерпретатора рецепта выступает человек, который готовит блюда.

Попробуем написать программу.

Открываем папку с интерпретатором:

и запускаем IDLE (Python GUI).exe, увидим что-то такое

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

но работа с интерпретатором в таком режиме это по сути если вы, например, готовите еду вдвоем, причем вы только команды отдаете, а второй человек (интерпретатор) просто следует вашим указаниям.

Поэтому рассмотрим, как можно писать код как набор команд (своего рода рецепт для интерпретатора). Для этого создадим файлик

откроется параллельно редактор файла:

можно теперь загнать туда снова команду на сложение чисел:

нам будет предложено сохранить файл, жмем OK

вводим имя файла:

как только файл сохранится запуститься программа

и слева в интерпретаторе мы увидим

Появилось слово RESTART: с путем к файлу, то есть вроде программа наша запустилась, но только почему-то ничего не вывела. А мы там 5+5 писали, где ж наша десятка?

Дело в том, что, когда мы работает с интерпретатором в ручном режиме, он ведет себя а-ля человек, и если его о чем-то попросить он нам тут же отвечает. А когда мы запускаем программу из файла, то интерпретатор предполагает, что рядом никого нет, а раз никого нет, то и лишний раз ничего говорить не надо.

Поэтому чтобы интерпретатор что-то все-таки написал, надо его явно попросить. Ну типа если вернутся к аналогии с рецептом, мы, например, оставляем товарища следить за кастрюлей, и просим закричать если вода начнет кипеть.

В рамках кода делается это так. Возвращаемся в программы (файлику task01.py) и переписываем код следующим разом:

и снова тыкаем F5 чтобы передать нашу программу интерпретатору, нас снова попросят сохранить файл

жмем OK и видим, как интерпретатор пишет нашу десятку

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

print("5 + 5 =", 5 + 5)

получится

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

print("Сумма 5 плюс 5 равно", 5 + 5)

Переменные

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

1. Добавить соль/перец/куркуму по вкусу

с точки зрения программирования мы можем проинтерпретировать эту фразу более строго:

1. Добавить X по вкусу (где X может быть солью, перцем или куркумой)

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

print("Добавить соль по вкусу")

а теперь воспользуемся переменой чтобы вместо соли был X, а в X положим “соль”, получится как-то так:

X = "соль"
print("Добавить " + X + " по вкусу")

если запустить увидим тоже самое

а можем поменять значение в X на какое-нибудь другое и получить новую фразу

X = "перец"
print("Добавить " + X + " по вкусу")

запускаем:

А можно пойти еще дальше и менять значения не в коде, а запросить значение через интерпретатор. Ну типа с кухни нам орут: “Чего в суп сыпать?!”

делается это так:

X = input("Чего в суп сыпать?!")
print("Добавить " + X + " по вкусу")

запускаем и смотрим что получается:

таким образом мы можем программировать интерпретатор на ведение диалога с пользователем, с помощью которого можно контролировать поведение программы.

Теперь попробуйте написать уже свою собственную первую программу. Которая запросит у вас имя и в ответ поприветствует вас.

Можно программировать арифметические операции, делается это примерно так:

a = 3
b = 4

# посчитаем сумму и сохраним в переменную c
c = a + b
print("Сумма равна", c)

# посчитаем разность и сохраним в переменную c
c = a - b
print("Разность", a, "и", b, "равна", c)  # выводим сложную комбинацию

# посчитаем произведение и сохраним в переменную c
c = a * b
# а вообще, самый лучший способ сформировать строку, это следующим образом
# если перед открывающей кавычкой добавить f, то внутри можно будет указать
# места для подстановки переменных, заключив их в фигурные скобки
# вот так:
print(f"Произведение {a} и {b} равно {c}") 

# посчитаем частное и сохраним в переменную c
c = a / b
print(f"Частное {a} и {b} равно {c}")

Преобразование в число

Важный момент если вы запрашиваете через input значение вы получаете строку, в результате может получится неожиданный результат. Например, я хочу удвоить число введённое пользователем. И делаю так:

a = input("Введите a: ")
c = a + a
print(c)

а вот как поведет себя программа:

она решили, что ее попросили склеить две строки с пятерками и выдала 5 подклеенную к 5.

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

a = input("Введите a: ")
a = int(a) # добавил преобразование введённого значения a в число, (int от английского Integer -- целое число)
c = a + a
print(c)

теперь все четко:

Для работы с математичскими функциями необходимо подключить так называемый модуль с математическими функциями

import math  # подключаем модуль для работы с математическими функциями

# а дальше обращаемся к математическим функцмиям, добавляя префикс math
c = math.sin(0)
print(f"Синус 0 градусов равен {c}")

c = math.cos(0)
print(f"Косинус 0 градусов равен {c}")

# в модуле есть константы, например пи
c = math.cos(math.pi / 2)
print(f"Косинус пи/2 равен {c}")

c = math.degrees(math.pi / 2)
print(f"пи/2 в градусах равно {c}")

c = math.radians(90)
print(f"90 градусов в радианах равно {c}")

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

if какое_то_условие:
    сделать действие1

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

запросить y пользователя значение x
преобразовать x в число

если x больше 0 то
    напечатай  "число положительное"

на python получим такой код:

x = input("Введите X")
x = int(x)

if x > 0:
    print("число положительное")

тут важный момент что print(“число положительное”) должен иметь отступ в 4 пробела, то есть чтобы визуально выглядело будто print лежит внутри конструкции if

if-ов может быть сколько угодно, например, если мы хотим проверить число сразу на положительность и на отрицательность. На русском будет так:

запросить y пользователя значение x
преобразовать x в число

если x больше 0 то
    напечатай  "число положительное"
		
если x меньше 0 то
    напечатай  "число отрицательное"		

на python вот так:

x = input("Введите X")
x = int(x)

if x > 0:
    print("число положительное")
		
if x < 0:
    print("число отрицательное")

Взаимоисключающие условия

Допустим мы хотим сравнить число с несколькими другими числами. Допустим с 5 и 10. И хотим, чтобы

• если число больше 10 программа написала “число больше 10”,
• если больше либо равно 5, но меньше либо равно 10 написало “число между 5 и 10”
• ну и если число меньше 5 написало “число меньше 5”

тогда на русском будем действовать как-то так:

запросить y пользователя значение x
преобразовать x в число

если x больше 10 то
    напечатай  "число больше 10"
		
если x больше либо равно 5 и x меньше либо равно 10 то
    напечатай  "число между 5 и 10"
		
если x меньше 5 то
    напечатай  "число меньше 5"	

на программистском

x = input("Введите X")
x = int(x)

if x > 10:
    print("число больше 10")
		
# ниже используется проверка сразу на два условия, 
# которые объединены через оператор and, то есть типа: <условие1> and <условие2>
# в принципе так можно объединить сколько угодно условий <условие1> and <условие2> and <условие3>
if x >= 5 and x <= 10:  
    print("число между 5 и 10")
		
if x < 5:
    print("число меньше 5")

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

if x > 10:
    print("число больше 10")
elif x >= 5 and x <= 10:  
    print("число между 5 и 10")		
elif x < 5:
    print("число меньше 5")

то есть мы заменили два последних if на elif, что расшифровывается как else if (с англ. иначе если). На человеческом получится что-то вроде:

если x больше 10 то
     напечатай "число больше 10"
иначе если x больше либо равно 5 и x меньше либо равно 10 то
     напечатай "число между 5 и 10"
иначе если x < 5 то
     напечатай "число меньше 5"

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

Для таких условий в программировании предусмотрена конструкцию else (с англ. иначе).

То есть мы можем переформулировать нашу конструкцию в

если x больше 10 то
     напечатай "число больше 10"
иначе если x больше либо равно 5 и x меньше либо равно 10 то
     напечатай "число между 5 и 10"
иначе
     напечатай "число меньше 5"

на python это получится вот так:

if x > 10:
    print("число больше 10")
elif x >= 5 and x <= 10:  
    print("число между 5 и 10")		
else:
    print("число меньше 5")

Упрощаем условие

Кстати, если присмотреться к первым двум условиям мы увидим, что если оказалось, что x не больше 10, то есть первое условие не выполнилось, то это гарантирует нам что x <= 10, а это означает что мы можем упростить условие 2, до вида x больше либо равно 5 и получим на русском:

если x больше 10 то
     напечатай "число больше 10"
иначе если x больше либо равно 5 то
     напечатай "число между 5 и 10"
иначе
     напечатай "число меньше 5"

код будет такой:

if x > 10:
    print("число больше 10")
elif x >= 5:  
    print("число между 5 и 10")		
else:
    print("число меньше 5")

Ну и уточню, что конструкция if/elif/else это не то же самое что три if-а. Если запустить код выше, то получим вполне корректное поведение:

а теперь попробуем заменить elif на if, то есть таким образом преобразовав его в две конструкции if и if/else:

if x > 10:
    print("число больше 10")
if x >= 5:  
    print("число между 5 и 10")		
else:
    print("число меньше 5")

запускаем и получаем

Вложенные конструкции

В принципе, один блок if может находится внутри другого блока if, правда тогда отступы надо увеличивать на 4 пробела соответственно.

Например, мы можем переписать код выше используя только if и else. Для этого переформулируем нашу фразу

если x больше 10 то
    напечатай "число больше 10"
иначе
    если x больше либо равно 5 и x меньше либо равно 10 то
         напечатай "число между 5 и 10"
    иначе
         напечатай "число меньше 5"

в коде получим

if x > 10:
    print("число больше 10")
else
    if x >= 5 and x <= 10:  
        print("число между 5 и 10")		
    else:
        print("число меньше 5")

иногда такое может пригодится

Проверка на равенство

У нас в примере не было равенства. Поэтому просто уточню. Чтобы проверить число на равенство с другим числом надо использовать ДВОЙНОЕ равно ==

if x == 10:
    print("Число равно 10")

а если хочется наооборот проверить что число не равняется чему-то можно использовать два варианта, так

if not x == 10:
    print("Число не равно 10")

либо так

if x  != 10:
    print("Число не равно 10")

Теперь не забудьте и сделайте что написано в задании:

Запросить у пользователя число и вывести на экран “число положительное”, если число больше нуля, “число отрицательное”, если число меньше нуля и “это ноль” если ложно и первое и второе условие.

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

x = input("Введите X: ")
x = int(x)

y = input("Введите Y: ")
y = int(y)

if x >= y:
    print("x не меньше y")
else:
    print("x меньше y")

Чтобы проверить число на четность надо узнать делится ли оно на два нацело.

Для этого надо узнать остаток от деления числа на 2, если он равен 0 то значит число четное. В python есть специальная операция для того чтобы узнать остаток от деления, работают с ней так:

x = int(input("введите x: "))

ostatok_na_2 = x % 2
print(f"Остаток от деления x на 2 равен {ostatok_na_2}")

если запустить получим что-то такое

таким образом чтобы узнать является ли число четным надо сравнить остаток от деления с нулем:

x = int(input("введите x: "))

ostatok_na_2 = x % 2
if ostatok_na_2 == 0:
    print(f"Число {x} четное")

проверяем

ну а теперь надо задание допилить:

Запросить число от 1 до 99 и проверить число на четность/нечетность и разрядность. То есть например для 7 вывести “однозначное нечетное”, для 92 – “двухзначное четное”

В python можно сравнивать не только циферки но и строки. Например можно сымитировать авторизацию:

password = input("Введите пароль: ")
if password == "12345":
    print("Это корректный пароль, добро пожаловать в систему!")
else:
    print("Вы ввели неправильный пароль")

вот так будет работать

Также, внутри if может быть сколько угодно строк кода, например

password = input("Введите пароль: ")

if password == "12345":
    print("Это корректный пароль, добро пожаловать в систему!")
    user = input("Введите ваше имя: ")
    print(f"Приветствую, {user}!")		
else:
    print("Вы ввели неправильный пароль")
    user = input("Сообщите ваше имя: ")
    print(f"{user}, о вас будет доложено в соответствующие органы")

print("сессия завершена")

вот так оно отработает на правильном пароле

а вот так на неправильном:

Часто возникает необходимость проверить сразу несколько условий. У нас уже была конструкция and которая позволяла проверять одновременное выполнение двх условий, типа

if a > 10 and a < 20:
    print(f"Число {a} между 10 и 20, невключительно")

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

То есть 3 подойдет, и 2 подойдет, и -2 подойдет, а -3 уже не подойдет, потому что оно не положительное и не четное.

Для этого мы можем использовать оператор or (англ. “или”)

if a > 0 or a % 2 == 0:
    print(f"Число {a} либо положительное, либо четное")

еще один интересные случай когда нам надо проверить является ли число каким-нибудь конкретным числом. Например нас устраивают только числа 3,5,7.

Используя or мы можем написать это вот так

if a == 3 or a == 5 or a == 7:
    print(f"Число {a} либо тройка, либо пятерка, либо семерка")

такая запись достаточно громоздкая, но есть альтернативный способ сформулировать такое условие, использя оператор in (англ. “в”), используя его можно записать тоже самое следующим образом:

if a in [3, 5, 7]:
    print(f"Число {a} либо тройка, либо пятерка, либо семерка")

согласитесь, что так намного короче. Внутри квадратных скобок можно использовать и строки. Допустим у нас фейс-кнотроль и пускают только Васю, Катю и Лешу:

username = input("Введите ваше имя: ")

if username in ["Вася", "Катя", "Леша"]:
    print(f"{username}, вы можете пройти")
else:
    print(f"{username}, извините, вас нет в списке приглашенных")

В python можно работать со списками (или как их еще иногда называют массивы). Мы уже сталкивались со списками, когда надо было проверить принадлежность x нескольким значениями. Мы писали что-то вроде:

if x in ["июнь", "июль", "август"]:
    print("скоро лето!")

так вот, конструкция в квадратных скобках, и есть собственно список. Со списком можно работать как с переменной. То есть сделать, например, вот так

summer = ["июнь", "июль", "август"]  # вынесли список в переменную summer
if x in summer:  # а тут взаимодействуем уже с переменной
    print("скоро лето!")

как только список привязывается к переменной, им можно начать оперировать разными хитрыми способами.

Простейшая операция — это получить значение элемента списка по номеру его позиции. В большинстве языков программирования нумерация начинается с нуля, и питон не исключение. Допустим мы хотим напечатать первый элемент списка, тогда я напишу вот так:

summer = ["июнь", "июль", "август"] 
print(summer[0])  # для адресации используем квадратные скобки, это строка напечает "июнь"

ну и соответственно я могу вывести список поэлементно

summer = ["июнь", "июль", "август"] 
print(summer[0])  # это строка напечатает "июнь"
print(summer[1])  # это строка напечатает "июль"
print(summer[2])  # это строка напечатает "август"

бывает, что выводить поэлементно не надо, тогда вы можете просто вывести весь список разом:

summer = ["июнь", "июль", "август"] 
print(summer)  # это строка напечатает "['июнь', 'июль', 'август']"

А еще иногда может понадобится узнать количество элементов в списке, для этого можно использовать специальную функцию len (от англ. length – длина), делается это так

summer = ["июнь", "июль", "август"]
c = len(summer)  # вызвали функцию len и передали ей список summer, чтобы она подсчитала количество элементов и сохранили в переменную c
print(f"количество элементов в списке: {c}")  # это строка напечатает "количество элементов в списке: 3"

можно вполне скомбинировать это и вывести что-нибудь поинтереснее

summer = ["июнь", "июль", "август"]
print(f"""
список имеет вид: {summer}
третий элемент в списке: {summer[2]}
количество элементов: {len(summer)}
""")

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

summer = ["июнь", "июль", "август"]
print(f"список имеет вид: {summer}\nтретий элемент в списке: {summer[2]}\nколичество элементов: {len(summer)}")

Итого

• если хотите создать список используйте конструкцию вида items = [3, 5, 7]
• если хотите получить i-ый элемент списка то при обращении указывайте i-1 значение, то есть для 3 элемента я указываю 2, типа: print(items[2])
• чтобы узнать количество элементов используйте len, нпр: c = len(items)
• используйте тройные кавычки чтобы писать многострочный текст """Я потенциально многострочный текст"""

Теперь можно пилить само задание

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

Для этого у списка есть метод index (от англ. таки просто индекс)

Делается это так

summer = ["июнь", "июль", "август"]  # создали список
x = "июль"  # объявили переменную со значением второго элемента
i = summer.index(x)  # запросили порядковый номер значения x в списке summer
print(f"{x} находится на {i} позиции в списке {summer}")  # вывели фразу 

Это нам выдаст

хм, только вот он же на второй должен быть? А ну да нумерация же идет с нуля. Так что, чтобы фраза выглядела корректно надо добавить +1 к i, типа так:

print(f"{x} находится на {i + 1} позиции в списке {summer}")  # вывели фразу 

теперь другое дело.

Кстати можно проверить что index действительно работает правильно, например, взять найти индекс по значению, а потом получить значения по номеру, вот так например

summer = ["июнь", "июль", "август"]  # создали список
x = "июль"  # объявили переменную со значением второго элемента
i = summer.index(x)  # запросили порядковый номер значения x в списке summer
value = summer[i] # получили значение по найденному порядковому номеру
print(f"{x} равно {value}")  # выдаст "июль равно июль"

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

summer = ["июнь", "июль", "август"]
x = "апрель" 
i = summer.index(x)
print(i)

то получим красную ошибку:

поэтому перед тем как узнать номер, проверяйте есть ли элемент в списке:

summer = ["июнь", "июль", "август"]
x = "апрель"
if x in summer:
    i = summer.index(x)
    print(i)
else:
    print("Элемента нет в списке")

кстати есть возможность проверять не присутствие элемента в списке, а его отсутствие, для этого используется конструкция not in

summer = ["июнь", "июль", "август"]
x = "апрель"
if x not in summer:  # тут теперь у меня будет not in
    print("Элемента нет в списке")
else:
    i = summer.index(x)
    print(i)

выдаст этот код тоже самое:

Итого

• Если хотите узнать номер элемента в списке items, используйте функцию index, нпр: i = items.index(x)
• Если хотите вывести номер элемента в общепринятой системе отсчета, то есть от единицы, добавляйте к индексу 1, нпр: print(f"{i + 1}"
• Перед тем как узнать номер элемента в списке, проверьте его существование через if x in summer
• Либо проверьте его отсутствие чтобы ничего не делать if x not in summer

Теперь поговорим об одной из фундаментальнейших вещей в программировании, а именно о цикле.

Начнем издалека. Рассмотрим задачу. Дан массив из 3 элементов: [“июнь”, “июль”, “август”], надо вывести их поэлементно на экран. Мы уже это делали выше, получилось что-то в этом роде

summer = ["июнь", "июль", "август"]
print(summer[0])
print(summer[1])
print(summer[2])

теперь допустим у нас массив из 12 элементов, весь год загнали в массив, и снова надо вывести все, что будем делать? Попробуем так же:

year = ["январь", "февраль", "март", "апрель", "май",  "июнь", "июль", "август", "сентябрь", "октябрь", "ноябрь", "декабрь"]

print(year[0])
print(year[1])
print(year[2])
print(year[3])
print(year[4])
print(year[5])
print(year[6])
print(year[7])
print(year[8])
print(year[9])
print(year[10])
print(year[11])

ну, э… в общем, терпимо. А теперь представьте у нас список студентов политеха. Тыща людей народу. И чего делать, тоже что-ли print на каждого. Не это будет жестко. Короче, не мы первые с такой проблемой столкнулись. Мы можем попросить python выполнить какое-то действие для каждого элемента списка. Для этого мы пишем следующую конструкцию

year = ["январь", "февраль", "март", "апрель", "май",  "июнь", "июль", "август", "сентябрь", "октябрь", "ноябрь", "декабрь"]

for element in year:  # переводим с инглиша: для каждого element`а в списке year
    print(element)  # напечатай значение element`а

и все, теперь нам все равно сколько элементов в списке, хоть стопяцотмильонов, мы все их выведем парой строк.

Запускаем и проверяем:

ну, как вам? =)

Используем if внутри цикла

Давайте вернемся к циферкам чего-нибудь осознанное сделаем. Допустим напечатаем только четные числа.

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]  # дан список цифр от одного до 10

# творим магию, запихнем в цикл проверку на четность через if
for element in numbers:  # с инглиша: для каждого element`а в списке numbers
    if element % 2 == 0:  # если element делится на 2 без остатка
        print(element)  # напечатай значение element`а

о как:

можно и else туда запихать:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]  # дан список цифр от одного до 10

for element in numbers:  # для каждого element`а в списке numbers
    if element % 2 == 0:  # если element делится на 2 без остатка
        print(f"{element} -- четный")
    else:  # иначе
        print(f"{element} -- нечетный")

проверяем:

Узнаем номер элемента

Снова вернемся к месяцам:

year = ["январь", "февраль", "март", "апрель", "май",  "июнь", "июль", "август", "сентябрь", "октябрь", "ноябрь", "декабрь"]

for element in year: 
    print(element)

допустим я хочу выводить номер месяца в виде “январь - 1 месяц”. Как я буду это делать. Первое что нам приходит в голову, это использовать метод index. По идее если бы не было никакого цикла, то такое бы сработало.

x = "январь"
i = year.index(x)  # узнали номер месяца в списке в системе отсчета от нуля
print(f"{x} - {i + 1} месяц") # вывели "январь - 1 месяц"

мы можем запихать этот код прямо в цикл

year = ["январь", "февраль", "март", "апрель", "май", "июнь", "июль", "август", "сентябрь", "октябрь", "ноябрь", "декабрь"]

for element in year: 
    x = "январь"
    i = year.index(x)  # узнали номер месяца в списке в системе отсчета от нуля
    print(f"{x} - {i + 1} месяц") # вывели "январь - 1 месяц"

запускаем:

ааа, что происходит?!!! Ну конечно! У нас там x используется везде, а цикл кладет элементы в переменную element, надо просто попросить его ложить (или класть, как там правильно…) элементы в x, и тогда все заработает:

year = ["январь", "февраль", "март", "апрель", "май", "июнь", "июль", "август", "сентябрь", "октябрь", "ноябрь", "декабрь"]

for x in year:  # поменяли element на x, теперь очередной элемент списка будет заноситься в x
    x = "январь"
    i = year.index(x)
    print(f"{x} - {i + 1} месяц")

запуск:

ой, блин, надо убрать строчку x = "январь"

year = ["январь", "февраль", "март", "апрель", "май", "июнь", "июль", "август", "сентябрь", "октябрь", "ноябрь", "декабрь"]

for x in year:
    i = year.index(x)
    print(f"{x} - {i + 1} месяц")

проверяем:

Красота! =)

Можно вывести только элементы, у которых порядковый номер (в системе отсчета от 0) больше 4, например, так

year = ["январь", "февраль", "март", "апрель", "май",  "июнь", "июль", "август", "сентябрь", "октябрь", "ноябрь", "декабрь"]

for x in year:
    i = year.index(x)
    if i > 4:
        print(f"{x} - {i + 1} месяц")

больше 4 в системе от нуля, это то бишь выше 5-го месяца, то есть от июня. Проверяем:

работает! =Р

Ну все, думаю теперь можно задание пилить!

И так, до этого мы создавали наши списки вручную. Теперь посмотрим какие возможности дает питон при создании последовательностей.

Вспомним пример из предыдущих задачек. Там нам надо было обработать список из чисел [1,2,3,4,5,6,7,8,9,10]. Мы там делали что-то такое

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

for element in numbers:
    print(element)

если это добро запустить получим:

давайте кстати попробуем вывести их в строчку

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

for element in numbers:
    print(element, end=" ")

вот эта end, которая появилась в качестве второго аргумента функции print, означает что я хочу, чтобы после каждого символа в конце ставился пробел, по умолчанию там используется перенос на следующую строку, поэтому и выводятся числа в столбик.

Запускаем:

так определено компактнее. Можно тирешку поставить

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

for element in numbers:
    print(element, end="-")

бззз:

только зачем?

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

Именно поэтому в питон встроены функции, которые позволяют создавать эти самые упорядоченные последовательности более простым способом. Самая простая функция это range (от англ. диапазон, ряд)

С помощью нее мы можем быстро создать последовательность из 10 чисел, вот так:

numbers = range(10)

for element in numbers:
    print(element, end=" ")

правда с небольшой оговоркой, она выдает числа от 0 до 9:

мы можем попросить ее выдавать числа с 1, вот так:

numbers = range(1, 10)

for element in numbers:
    print(element, end=" ")

правда их получится уже только девять:

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

numbers = range(1, 11)

for element in numbers:
    print(element, end=" ")

тада!

эка невидаль, заменил 30 символов на 10? Ха! А как тебе такое Илон Маск!

это я решил 11 на 1000 заменить. На самом деле нет разумного объяснения зачем я это сделал. Ну а чё?

Генерируем нечетные числа

Короче, так. Теперь умеем упорядоченный набор чисел, причем любой длины. Сделаем что-нибудь разумное. Например, сгенерируем первые сто нечетных чисел.

Чтобы сгенерировать первые сто нечетных чисел, надо сначала создать просто первые сто чисел. Готово:

numbers = range(1, 101)  # помним что последнее число не включается, поэтому 101

for i in numbers:
    print(i, end=" ")

проверяем:

теперь надо из 100 чисел сделать нечётные. С этим сложно… давайте тогда сначала четные сделаем. Какие у нас там четные:

• первое - 2
• второе - 4
• третье - 6
• четвертое - 8
• и т. д.

То есть если так предположить, то сотое число будет либо 200 либо 202. Надо бы посчитать в уме, но мы ж не для того программирования учим, чтобы сами считать.

Зато мы возможно видим закономерность что i-ое четное число есть 2 * i,

Попробуем принтовать вместо i, два умножить на i, вот так:

numbers = range(1, 101)  # помним что последнее число не включается, поэтому 101

for i in numbers:
    chetnoe = 2 * i
    print(chetnoe, end=" ")

уи!

Теперь мы знаем, что сотое четное число – это таки 200. Это даже можно сказать теперь научно доказано!

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

numbers = range(1, 101)  # помним что последнее число не включается, поэтому 101

for i in numbers:
    nechetnoe = 2 * i + 1
    print(nechetnoe, end=" ")

ура:

а! нет, где-то единицу потеряли…

а! да, там вверху под “добавить 1”, я имел ввиду, конечно, “отнять 1”

numbers = range(1, 101)  # помним что последнее число не включается, поэтому 101

for i in numbers:
    nechetnoe = 2 * i - 1
    print(nechetnoe, end=" ")

теперь другое дело

Продолжаем наши изыскания. В предыдущей задачи мы научились, используя упорядоченный набор чисел создавать новый набор чисел. Делали что-то такое:

numbers = range(1, 11)

for i in numbers:
    print(i, end=" ")

а что если вместо print, запихать в цикл input? Давайте попробуем

numbers = range(1, 11)

for i in numbers:
    x = input(f"Введите {i} число: ")

запускаем

прикольно, да? Мы то есть как бы последовательно запрашиваем у пользователя значения. Правда пока ничего с ними не делаем.

А что если попробовать из этих чисел создать новую последовательность? И мы можем такое сделать. Оказывается, в python можно добавлять элементы к списку. И таким образом формировать новые списки.

Более того можно создать пустой список и потом его заполнить. Для добавления элемента к списку используется функция append. Работает это так:

items = []  # создали пустой список
print(items)  # напечатает "[]"

# добавляем элемент
items.append(7)
print(items)  # напечатает "[7]"

# добавляем еще один элемент, как видите элемент добавляется в конец списка
items.append(9)
print(items)  # напечатает "[7, 9]"

теперь попробуем воспользоваться таким подходом внутри цикла:

numbers = range(1, 11)

items = []  # создали пустой список

for i in numbers:
    x = input(f"Введите {i} число: ")  # запрашиваем значение
    x = int(x)  # преобразуем в число
    items.append(x)  # добавляем в список
		
print(f"Вы сформировали следующий список: {items}")

проверяем:

таким образом мы как бы используя одну последовательность чисел умудрились сформировать новую последовательность чисел.

Вообще, если так посмотреть, то заводить специальный список numbers не обязательно, ведь мы его по сути и не используем.

Так что мы можем просто подставить в цикл for, на место numbers этот самый range, вот так:

items = []

for i in range(1, 11):  # numbers вверху убрали, а сюда перенесли range(1, 11)
    x = input(f"Введите {i} число: ")
    x = int(x)
    items.append(x)
		
print(f"Вы сформировали следующий список: {items}")

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

items = []

for i in range(10):  # просто указываем что нам надо 10 элементов
    x = input(f"Введите {i + 1} число: ")  # но тут к i теперь прибавляем 1, так как range(10) выдает числа начиная с 0
    x = int(x)
    items.append(x)
		
print(f"Вы сформировали следующий список: {items}")

а используя такую конструкцию, уже можно не только запрашивать сами значения, но и их количество, как-то так:

# запросим сначала количество элементов у пользователя
n = input("Сколько чисел изволите? ")
n = int(n)

items = []

for i in range(n):  # вместо 10 подставляем n
    x = input(f"Введите {i + 1} число: ")
    x = int(x)
    items.append(x)
		
print(f"Вы сформировали следующий список: {items}")

проверяем

красота! =)

Считаем сумму элементов последовательности

Теперь, когда у нас есть последовательность, введенная пользователем, можно с чистой совестью ее обработать. Например, подсчитать сумму элементов. Давайте продумаем как будем это делать, но сначала без циклов и без запроса значений. Получится как-то так:

items = [1, 2, 3, 4, 5]

# считаем сумму
s = items[0] + items[1] + items[2] + items[3] + items[4]
print(s)

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

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

items = [1, 2, 3, 4, 5]

# считаем сумму
s = items[0]  # изначальна сумма равна значению первого элемента, т.е. после выполнения этой команды s = 1
s = s + items[1]  # пересчитываем сумму, как предыдущее рассчитанное значение суммы плюс второй элемент, тут s = 1 + 2
s = s + items[2]  # добавляем третий элемент, получим s = 3 + 3
s = s + items[3]  # добавляем четвертый элемент: s = 6 + 4
s = s + items[4]  # добавляем пятый элемент: s = 10 + 5

print(s)  # итого напечатается 15

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

items = [1, 2, 3, 4, 5]

s = items[0]  # изначальна сумма равна значению первого элемента, т.е. после выполнения этой команды s = 1

# считаем сумму в цикле
for x in items:
    s = s + x

print(s)

проверяем:

хм, почему же получилось 16 а не 15. Откуда взялась лишняя единица?

А! Я вроде понял! Дело в том, что цикл проходит по всем элементам цикла, а так как мы в начале присваиваем сумме значение первого элемента, мы как бы два раза прибавляем его, то есть без цикла наш код сейчас выглядел бы так:

s = items[0]
# вот тут внизу аналог цикла пошел:
s = s + items[0]
s = s + items[1]
s = s + items[2]
s = s + items[3]
s = s + items[4]

таким образом, чтобы первый элемент не дублировался, надо сумму изначально инициализировать нулем, вот так:

s = 0
# вот тут внизу аналог цикла пошел:
s = s + items[0]
s = s + items[1]
s = s + items[2]
s = s + items[3]
s = s + items[4]

и тогда вариант с циклом будет выглядеть вот так:

items = [1, 2, 3, 4, 5]

s = 0  # изначальна сумма равна нулю

# считаем сумму в цикле
for x in items:
    s = s + x

print(s)

вот теперь другое дело:

Собственно реализуем алгоритм формирования последовательности из википедии:

Берём любое натуральное число n. Если оно чётное, то делим его на 2, а если нечётное, то умножаем на 3 и прибавляем 1 (получаем 3n + 1). Над полученным числом выполняем те же самые действия, и так далее.

Гипотеза Коллатца заключается в том, что какое бы начальное число n мы ни взяли, рано или поздно мы получим единицу.

проще всего внутри цикла брать и пересчитывать значение n, как в прошлой задаче мы пересчитывали сумму

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

items = [11, 12, 13, 14, 15, 16, 17]

мы можем откусить от него кусок списка слева и сформировать новый

items = [11, 12, 13, 14, 15, 16, 17]
left_4_elements = items[:4]  # новый список из четырех левых элементов 
print(left_4_elements)  # выведет [11, 12, 13, 14]

# на самом деле мы конечно не откусываем ничего от оригинального списка, а просто копируем их
print(items)  # все еще напечатает [11, 12, 13, 14, 15, 16, 17]

мы можем получить оставшуюся половину списка если расположим двоеточие не перед цифрой, а после:

items = [11, 12, 13, 14, 15, 16, 17]
rest_elements = items[4:]  # список из элементов начиная с индекса 4 (нумерация с нуля)
print(rest_elements)  # выведет [15, 16, 17]

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

items = [11, 12, 13, 14, 15, 16, 17]
elements_from_1_to_3 = items[1:3] 
print(elements_from_1_to_3)  # выведет [12, 13]

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

items = [11, 12, 13, 14, 15, 16, 17]
n = 3
elements = items[2 : 2+n] 
print(elements)  # выведет [13, 14, 15]

Как только у меня есть подсписок с ним можно взаимодействовать как с обыкновенным списком

items = [11, 12, 13, 14, 15, 16, 17]
n = 3
elements = items[n : n + 2] 

print(elements)  # выведет [14, 15]
print(elements[0])  # выведет 14
print(elements[1])  # выведет 15
print(len(elements))  # выведет 2

то есть он про оригинальный список ничего не помнит и становится такой себе индивидуальной сущностью

• Заведите две переменные под подсписок элементов слева, назовем его A и по подсписок элементов справа, назовем его B
• Рассчитайте сумму элементов списка A, сохраните ее в переменную sA
• Рассчитайте сумму элементов списка B, сохраните ее в sB
• ???
• готово

• Рассчитайте сколько у вас должно получится подсписков и сохраните значение в переменную k
• Добавьте цикл который должен по i отщелкать k итераций (range вам в помощь, см. подсказку к 17 задаче), ну там for i in ...
• Попробуйте сначала вывести элементы начиная с i, то есть [i:], гляньте что получится
• Попробуйте вывести элементы начиная с i * n, то есть [i*n:]
• ???
• готово

А еще в python есть отрицательные индексы, не скажу, что они особо часто используются. Но тем не менее их очень удобно юзать когда нужно получить последние или предпоследние элементы. Что сильно пригождается при расчёте рекуррентных формул. То есть формул где значение n-го элемента рассчитывается как некая комбинация предыдущих.

Одна из самых простых рекуррентных формул это формула факториала. Выглядит она так

хитрость такой записи в том, что во второй строчке на самом деле запрятано целых n-1 строк, например, для n = 5 формула разворачивается в

что есть

теперь попробуем из этого сварганить цикл чтобы научится считать факториал.

Что у нас тут есть?

Есть перебор значений от 1-го до 5. Чтобы сделать такой перебор мы умеем писать так:

for i in range(1, 6):  # шестерка потому что крайний элемент не включатся
    print(i)

проверяем

Мы уже умеем создавать новые списки из пустых. Так что попробуем сгенерировать последовательность вида:

[f(1), f(2), f(3), f(4), f(5)]

добавляем пока пустую:

result_list = [] # пустая последовательность
for n in range(1, 6): 
    print(n)

смотрим нашу формулу и видим там строку

которая гласит что формула равна 1 когда n = 1, пропишем это условие:

result_list = []
for n in range(1, 6): 
    if n == 1:
        value = 1
        
    result_list.append(value) # добавляем элемент в результат

print(result_list)

если запустить получим массив из пяти элементов:

А для всех остальных случаев у нас получается формула вида $f(n-1) * n$, мы его можем загнать в else, вот так:

result_list = []
for n in range(1, 6): 
    if n == 1:
        value = 1
    else:
        # я беру (n - 1) - 1 элемент в списке, потому что n-1 у меня по формуле,
				# и еще -1 потому что нумерация элементов не с 1, а с нуля
        f_n_minus_1 = result_list[(n - 1) - 1]  #
        value = f_n_minus_1 * n  
        
    result_list.append(value)
		
print(result_list)

проверяем:

ура!

Индексация списков

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

Возьмем для примера массив

numbers = [8, 6, 4, 2, 1]

мы уже владеем способностью доступа к элементам массива по индексу вот так:

print(numbers[0])  # выведет 8
print(numbers[1])  # выведет 6
print(numbers[2])  # выведет 4
print(numbers[3])  # выведет 2
print(numbers[4])  # выведет 1

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

print(numbers[-1])  # выведет 1
print(numbers[-2])  # выведет 2
print(numbers[-3])  # выведет 4
print(numbers[-4])  # выведет 6
print(numbers[-5])  # выведет 8

то есть элементы нумеруются отрицательными индексами с конца начиная с -1

как это нам может помочь при реализации рекуррентной формулы? Чтобы было яснее, добавим print-ов в цикл, чтобы видеть, как он работает.

result_list = []
for n in range(1, 6):
    print(f"n = {n}")
    print(f"Список до добавления элемента: {result_list}")
    if n == 1:
        value = 1
    else:
        f_n_minus_1 = result_list[(n - 1) - 1]        
        value = f_n_minus_1 * n
        print(f"Значение f_n_minus_1 = f(n-1) = f({n-1}) = {f_n_minus_1}")
        print(f"Значение нового элемента списка который будем добавлять: f(n) = f({n}) = {value}")
        
    result_list.append(value)
    print(f"Список после добавления элемента {result_list}")
    print()

запускаем:

у нас самая страшная и запутанная формула в расчёте это

f_n_minus_1 = result_list[(n - 1) - 1]

если глянуть на элементы, которые у нас содержаться в списке на момент до добавления и что такое f_n_minus_1 то увидим

то есть по сути f_n_minus_1 – это просто последний элемент в списке. А значит можно вместо страшного индекса (n - 1) - 1 воспользоваться отрицательной индексацией и переписать строчку как:

f_n_minus_1 = result_list[-1]  # -1 -- значит последний элемент

итого получим такой код

result_list = []
for n in range(1, 6): 
    if n == 1:
        value = 1
    else:
        f_n_minus_1 = result_list[-1] 
        value = f_n_minus_1 * n  
        
    result_list.append(value)

print(result_list)

получим тоже самое:

Изучим еще один краеугольный тип данных в программировании. Так называемый словарик. Как и список одна из его целей — это сократить количество кода которые надо писать и сделать его более простым для восприятия

Вернемся к нашей пресловутой задаче на сезоны. Вот есть у нас четыре сезона и надо нам выдать какие месяцы в них попадают. Мы решали проблему через if, как-то так:

x = input("Введите сезон: ")

if x == "Зима":
    months = ["Декабрь", "Январь", "Февраль"]
elif x == "Весна":
    months = ["Март", "Апрель", "Май"]
elif x == "Лето":
    months = ["Июнь", "Июль", "Август"]
elif x == "Осень":
    months = ["Сентябрь", "Октябрь", "Ноябрь"]
else:
    months = "Нет такого сезона"

print(months)

и вроде все прекрасно, но было бы здорово если бы мы могли просто прописать сопоставление сезон -> список месяцев, а всю обработку по выбору сделал бы кто-то за нас.

Так вот, словарик как раз для этого используется. Выглядит это так:

x = input("Введите сезон: ")

# объявляем переменную seasons и присваиваем ей словарик, 
# словарик всегда начинается с фигурной скобки { и заканчивается фигурной скобкой }
# внутри прописываются пары <ключ>: <значение>, каждая пара отделяется от другой через запятую
seasons = {
    "Зима": ["Декабрь", "Январь", "Февраль"],  # пара номер 1, ключ "Зима", значение: список ["Декабрь", "Январь", "Февраль"]
    "Весна": ["Март", "Апрель", "Май"],  # пара номер 2, ключ "Весна", значение: список ["Март", "Апрель", "Май"]
    "Лето": ["Июнь", "Июль", "Август"],  # и т. д.
    "Осень": ["Сентябрь", "Октябрь", "Ноябрь"],
}

# ключ используется чтобы получить значения, привязанные к нему
# то есть он скорее не ключ, а дверь, 
# типа что там за дверью "Зима":
print(seasons["Зима"])  # напечатает ["Декабрь", "Январь", "Февраль"]

# а за дверью "Весна"
print(seasons["Весна"])  # напечатает ["Март", "Апрель", "Май"]

# а что открывает ключик "Лето"
print(seasons["Лето"])  # напечатает ["Июнь", "Июль", "Август"]

# ну, в общем, вы поняли
print(seasons["Осень"])  # напечатает ["Сентябрь", "Октябрь", "Ноябрь"]

# ну и естественно никто не мешает использовать в качестве ключа переменную
months = seasons[x]
print(months)

как и с массивом тут важно проверять наличие ключа в словарике, если использовать такой код

x = input("Введите сезон: ")

seasons = {
    "Зима": ["Декабрь", "Январь", "Февраль"],
    "Весна": ["Март", "Апрель", "Май"],
    "Лето": ["Июнь", "Июль", "Август"],
    "Осень": ["Сентябрь", "Октябрь", "Ноябрь"],
}

months = seasons[x]
print(months)

затем попробовать ввести что-то некорректное, то получим красную ошибку

так что по идее надо добавлять проверку на наличие ключа в словаре

x = input("Введите сезон: ")

seasons = {
    "Зима": ["Декабрь", "Январь", "Февраль"],
    "Весна": ["Март", "Апрель", "Май"],
    "Лето": ["Июнь", "Июль", "Август"],
    "Осень": ["Сентябрь", "Октябрь", "Ноябрь"],
}

# проверяем корректность сезона
if x in seasons:
    months = seasons[x]
else:
    months = "Нет такого сезона"

print(months)

тогда все работает как надо

но мы ж не для того словарик вводили чтобы большой if заменить на маленький. Оказывается, мы можем запихать своего рода else прямо в момент получения значения. Правда в этом случае немного меняется форма записи. Работает это так:

x = input("Введите сезон: ")

seasons = {
    "Зима": ["Декабрь", "Январь", "Февраль"],
    "Весна": ["Март", "Апрель", "Май"],
    "Лето": ["Июнь", "Июль", "Август"],
    "Осень": ["Сентябрь", "Октябрь", "Ноябрь"],
}

# мы заменяем seasons[x] на seasons.get(x, "Нет такого сезона"), 
# где второй аргумент в get -- это то значение, которое выдается если ключ не найден
months = seasons.get(x, "Нет такого сезона")
print(months)

и получаем такое же поведение

кстати после того как значение взято по ключу с ним можно работать уже как с привычным объектом, в нашем случае это простой список, поэтому мы можем например выдать за одно сколько элементов в нем:

x = input("Введите сезон: ")

seasons = {
    "Зима": ["Декабрь", "Январь", "Февраль"],
    "Весна": ["Март", "Апрель", "Май"],
    "Лето": ["Июнь", "Июль", "Август"],
    "Осень": ["Сентябрь", "Октябрь", "Ноябрь"],
}

# мы заменяем seasons[x] на seasons.get(x, "Нет такого сезона"), 
# где второй аргумент в get -- это то значение, которое выдается если ключ не найден
months = seasons.get(x, "Нет такого сезона")
print(f"Список: {months}")
print(f"Первый элемент в списке: {months[0]}")
print(f"Количество элементов: {len(months)}")

тада:

Помима как объявлять словарики вручную, есть возможность их заполнять на автомате. Это может пригодится когда мы хотим группировать объекты по какому-то признаку и нам лень заводить новые переменные.

Допустим есть у нас список чисел [1,2,3,4,5,6,7,8] и надо его разбить на четные и нечетные числа. Как бы мы это делали чере переменные, ну как-то так:

numbers = [1,2,3,4,5,6,7,8]

even = []  # завели переменную под четные числа
odd = []  # завели переменную под нечетные числа

# пошли последовательно проверять все элементы
for x in numbers: 
    if x % 2 == 0:  # если четный
        even.append(x)  # то кладем в список с четными элементами
    elif x % 2 == 1:  # если нечетный
        odd.append(x)  # то кладем в список с нечетными элементами

# выводим четные
print(even)
# выводим нечетные
print(odd)

как нам тут поможет словарик, ну как-то так:

numbers = [1,2,3,4,5,6,7,8]

# вместо переменных заводим словарик
data = {
    "четные": [],
    "нечетные": [],
}

# пошли последовательно проверять все элементы
for x in numbers: 
    if x % 2 == 0:  # если четный
        data['четные'].append(x)  # то кладем в ключ с четными элементами
    elif x % 2 == 1:  # если нечетный
        data['нечетные'].append(x)  # то кладем в ключ с нечетными элементами

# выводим все сразу
print(data)

ну если по количеству кода мы особо не выиграли то по читабельности явно в плюсе.

Генерация списка случайных чисел

Мы часто работаем со списками и как правило мы либо сами их заранее прописываем в коде либо заставляем пользователя вводить либо юзаем range (но он выдает только упорядоченные последовательности).

В общем, надо кончать с этим безобразием и свалить задачу создания списка на программу. Делается это легко. Для этого есть модуль random который предоставляет нам функции для создания случайных последовательностей.

Использовать его очень легко

import random  # подключили модуль

x = random.randint(-50, 50)  # сгенерировали случайно число от -50 до 50 включительно

print(f"Ваше случайное число: {x}")  # напечатали

если позапускать несколько раз, то будем получать разные числа

сразу возникает вопрос, как из этого получить последовательность? Ну тут очень просто, генери числа, и пихай их в список. И будет тебе счастье:

import random  

numbers = []  # завели пустой список
n = 30  # количество случайных чисел
for i in range(n):  # запускаем цикл, чтобы щелкал 30 раз
    x = random.randint(-50, 50)  # создаем случайное число
    numbers.append(x)  # пихаем в список

print(f"Ваши случайные числа: {numbers}")

запуская по несколько раз будем получать разные последовательности

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

import random  

n = 30
numbers = list(random.randint(-50, 50) for i in range(n))  # упрощенная форма записи цикла которые был вверху

print(f"Ваши случайные числа: {numbers}")

работает все так же:

Динамическая генерация ключа