Как обозначить неизвестную переменную в python

Переменные и вывод информации¶

Настало время приступить к изучению непосредственно Python, ведь по прошествии пары лекций об языке программирования и не говорили вовсе! Начнем со знакомой всем по школьным карандашам формулы \(E=mc^2\) . По ней можно вычислить полную энергию физического объекта \(E\) с помощью известной массы объекта \(m\) и константы \(c\) . Эта постоянная, указывающая на скорость света в вакууме, используется настолько часто, что для нее выделили отдельное обозначение в виде буквы латинского алфавита, как и для многих других аналогичных величин. Если в формуле встречается \(c\) (в известном контексте), то вы всегда уверены, что именно нужно подставить при расчетах.

Этот пример полностью описывает концепцию в языках программирования, и Python не исключение. Запись \(x = 3\) означает, что везде по тексту далее под иксом подразумевается именно тройка, и ничего другого (пока не будет введено новое определение). Этой же логике подчиняется Python. Сначала указывается имя переменной, а затем – ассоциируемое с ней значение.

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

В объявлении переменной нет ничего сложного. Синтаксис и правила интуитивно понятны: это можно делать как в физике/математике, как в учебниках и статьях.
# означает комментарий, то есть произвольный текст, который не воспринимается Python (все кода полностью игнорируется). Служит исключительно для создания подсказок в коде, объяснения происходящего, то есть для удобства.
Числа могут быть . Разряды в целых числах для удобства визуального восприятия можно разделять нижней чертой.
, то есть являться производной от других переменных (как \(E\) , ведь это результат перемножения). На самом деле значение вычисляется в момент объявления переменной (при сложной формуле расчета процесс может занимать некоторое время).
Операция возведения в степень реализуется с помощью ** .
В качестве названия переменных можно использовать и , а также некоторые символы. Однако .
Переменные можно переопределять (и даже менять тип). Однако . В данном примере после выполнения последней строчки нельзя установить, чему было равно \(m\) до того, как переменной было присвоено значение дюжины.

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

[Объявить переменную — значит положить объект в коробку с подписью](https://stevenpcurtis.medium.com/what-is-a-variable-3447ac1331b9)

Типы переменных¶

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

Целочисленный тип называется (от Integer ), вещественный – . Эти типы можно переводить из одного в другой. При переводе вещественного числа в целое теряется часть информации.

– и это относится не только к числам, но и к объекту – можно узнать с помощью функции type . Для вывода информации используется функция print . Что именно представляет собой функция рассмотрим в более поздних лекциях, пока стоит думать об этом как о некотором объекте, который зависит (рассчитывается) от других объектов и выдает некоторый результат. Для передачи аргументов используются круглые скобки (аналогично математике: \(y = F(x)\) ). Давайте скомбинируем эти знания и рассмотрим пример:

Внимательно проанализируйте код выше – в нем продемонстрирован базовый синтаксис и .

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

Арифметические операции с числами¶

Математика Python максимально близка к естественной: + , — , * и ** (рассмотренное ранее возведение в степень) работают в точности как ожидается. С делением / есть нюанс: .

Обратите внимание, что операции не изменяют переменную саму по себе (то есть операция a + b не меняет ни a , ни b ). Чтобы сохранить получаемое значение, нужно присвоить его некоторой переменной (в примере выше это c ). Если хотите изменить непосредственно саму переменную, то можно переприсвоить ей значение на основе расчета: a = a + b или c = c + 12 .

Даже несмотря на то, что пример с делением числа на само себя очевиден (всегда получается единица, кроме деления на нуль), будет выведено вещественное значение. Сами же вещественные значения можно складывать, вычитать, умножать и возводить в степень как с целыми, так и с вещественными числами (и наоборот). Если в таком выражении используется хотя бы одна float -переменная, то и результат будет не целочисленным. Однако:

Это практически все тонкости, которые необходимо знать, чтобы не совершать базовые ошибки.

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

Строковые переменные¶

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

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

Механизм ошибки таков, что Python неясно: строчка намеренно закончена и дальше идет какая-то команда, или же строчка продолжается. В обоих случаях – и тогда все будет хорошо:

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

Строки можно объединять для удобства вывода информации. Склеивание строк называется .

Обратите внимание на пробел между числом и точкой в первом случае. Они добавлены автоматически функцией print – это сделано для того, чтобы разные объекты при последовательном выводе не «склеивались» друг с другом. Во втором случае этого не происходит, так как напрямую склеиваются строки и только затем передается результат конкатенации на печать в print .

Будьте аккуратны со сложением строк. Объединение строк «3» и «5» даст результат «35» , а не 8 – и тип результирующего значения . : получите ошибку и никакого приведения типов не произойдет. Здесь возникнет двусмысленность – нужно привести число к строке и затем сконкатенировать или же строку к числу (а вдруг это невозможно?), после чего сложить.

Попробуйте в объединить строковые, целочисленные и вещественные переменные в разных комбинациях. Разберитесь, что означает ошибка, которая будет выведена в случае, если не делать приведение типов (то есть без str в str(result) ).

Но на практике это не совсем удобно, поэтому в Python придумали f -строки. Их суть в том, что переменная из кода напрямую подставляется (с автоматическим приведением типа к строке) в саму строку! Вот:

Для объявления f -строки нужно

использовать одинаковые кавычки на концах текста
указать литеру f перед самой строкой
обрамить название конкретной переменной ( result в данном случае) в фигурные скобки.

Когда переменная одна, а также нет текста после её использования, то выгода F -строк не так очевидна (относительно простого print(some_string, some_variable) ). Однако представьте, что нужно вывести координаты точки в трехмерном пространстве, значение времени, параметры системы и значение некоторой функции от всех переменных выше!

Объявление неизвестной переменной типа в Python?

У меня есть ситуация в Python (кашель, домашняя работа), где мне нужно умножить КАЖДЫЙ ЭЛЕМЕНТ в заданном списке объектов указанное число раз и вернуть выходные данные элементов. Проблема в том, что приведенные примеры входных данных имеют разные типы. Например, в одном случае можно ввести список строк, элементы которых мне нужно умножить, в то время как другие могут быть целыми числами. Так что мой тип возврата должен варьироваться. Я хотел бы сделать это, не проверяя каждый тип объекта. Есть ли способ сделать это? Я знаю, в C # я мог бы просто использовать «var», но я не знаю, существует ли такая вещь в Python?

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

Посмотрите, как мне нужно добавить к выходной переменной. Если я просто пытаюсь убрать выходное присваивание в первой строке, я получаю ошибку, что переменная не была определена. Но если я назначу ему 0 или «» для пустой строки, может возникнуть исключение, так как вы не можете добавить 3 к строке или «a» к целому числу и т. Д .

Вот несколько примеров входов и выходов:

11 ответов

Очень легко в Python. Вам нужно получить тип данных в вашем списке — используйте функцию type () для первого элемента — type (argsList [0]). Затем, чтобы инициализировать вывод (где у вас теперь есть . ), вам нужно нулевое или нулевое значение для этого типа. Так как int () или float () или str () возвращают ноль или nul для их типа, так и тип (argsList [0]) () возвращает нулевое или nul-значение для любого типа, который есть в вашем списке.

Итак, вот ваша функция с одной незначительной модификацией:

Слова с :: argsList = [1, 2, 3, 4] и [1.0, 2.0, 3.0, 4.0] или «abcdef» . и т. д.,

Благодаря Алексу Мартелли у вас есть наилучшее решение:

Это красиво и элегантно. Сначала мы создаем итератор с iter() , затем мы используем next() , чтобы получить первый объект в списке. Затем мы накапливаем итерацию по остальному списку, и все готово. Нам никогда не нужно знать тип объектов в argsList, и они действительно могут быть разных типов, если ко всем типам может применяться оператор + . Это утка печатать.

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

Аргумент *args функции указывает Python собрать все аргументы этой функции и создать из них кортеж; тогда кортеж привязан к имени args . Вы можете легко сделать из него список, а затем использовать метод .pop(0) , чтобы получить первый элемент из списка. Это требует памяти и времени на создание списка, поэтому решение iter() настолько элегантно.

Это просто решение Вубла, переписанное с использованием * args.

Примеры вызова этого:

Наконец, я собираюсь быть злым и жаловаться на решение, которое вы приняли. Это решение зависит от того, имеет ли базовый класс объекта разумный ноль или ноль, но не у всех классов есть это. int() возвращает 0 , а str() возвращает » (пустая строка), поэтому они работают. Но как насчет этого:

Удачи в учебе, и я надеюсь, что вам нравится Python так же, как и мне.

Если вы просто хотите заполнить пробел в своем коде, вы можете попробовать установить object=arglist[0].__class__() , чтобы присвоить ему нулевое эквивалентное значение этого класса.

Это приведет к сбою, если список пуст, но вы можете проверить это в начале функции и вернуть то, что считаете нужным.

Map выполняет функцию, переданную для каждого элемента списка (возвращает новый список), а затем sum делает + = в списке.

Не нужно тестировать объекты, просто умножьте их!

Все просто работают

Вы дали эти примеры входов и выходов:

Входные данные: (‘a’, ‘b’) Выходные данные: ‘aaaabbbb’ Входные данные: (2,3,4) Выходные данные: 36

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

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

Теперь, как мы можем сделать это расширить за два пункта? Ну, в вашем примере кода вы не были уверены, что назначить выводу вашей переменной. Как насчет назначения lst [0]? Тогда он всегда имеет правильный тип. Затем вы можете перебрать все остальные элементы в lst и накопить в вашей выходной переменной, используя + =, как вы написали. Если вы не знаете, как перебрать список элементов, но пропустите первое, что есть в списке, воспользуйтесь поиском в Google «python list slice».

Теперь, как мы можем сделать так, чтобы пользователь не упаковывал все в список, а просто вызывал функцию? Что мы действительно хотим, так это какой-то способ принять любые аргументы, которые пользователь хочет передать функции, и составить из них список. Возможно, существует специальный синтаксис для объявления функции, в которой вы говорите Python, что хотите просто объединить аргументы в список. Вы можете проверить хороший учебник и посмотреть, что в нем говорится о том, как определить функция.

Теперь, когда мы рассмотрели (в общих чертах), как накапливать ответ с помощью + =, давайте рассмотрим другие способы накапливания ответа. Если вы знаете, как использовать понимание списка, вы можете использовать один из них, чтобы вернуть новый список, основанный на списке аргументов, с умножением, выполненным для каждого аргумента; затем вы можете как-то сократить список до одного элемента и вернуть его. В Python 2.3 и новее есть встроенная функция sum() , и вы можете прочитать об этом. [РЕДАКТИРОВАТЬ: О, черт, sum() работает только с числами. См примечание добавлено в конце.]

Надеюсь, это поможет. Если вы все еще в замешательстве, я предлагаю вам связаться с вашим учителем и попросить разъяснений. Удачи.

Постскриптум В Python 2.x есть встроенная функция reduce() , и ее можно реализовать sum() , используя reduce() . Однако создатель Python считает, что лучше просто использовать sum() , и фактически он удалил reduce() из Python 3.0 (ну, он переместил его в модуль с именем functools ).

P.P.S. Если вы понимаете, как работает список, вот еще одна вещь, о которой стоит подумать. Если вы используете понимание списка, а затем передаете результат sum() , вы создаете список для использования один раз, а затем отбрасываете. Разве не было бы замечательно, если бы мы могли получить результат, но вместо того, чтобы построить весь список и затем отбросить его, мы могли бы просто использовать функцию sum() , которая потребляет элементы списка так же быстро, как они генерируются? Возможно, вы захотите прочитать это: Выражения генератора против понимания списка

РЕДАКТИРОВАТЬ: О, черт возьми, я предполагал, что sum() встроенный Python будет использовать утки. На самом деле документировано работать только с числами. Я разочарован! Мне придется поискать и посмотреть, были ли какие-либо дискуссии по этому поводу, и понять, почему они сделали это так, как сделали; у них, вероятно, были веские причины. Между тем, вы могли бы также использовать ваше решение + =. Прости за это.

РЕДАКТИРОВАТЬ: Хорошо, читая другие ответы, я теперь заметил два способа, предлагаемых для очистки первого элемента в списке.

Как создавать переменную с заранее неизвестным именем

Я хочу создавать объекты класса так, чтобы они назывались по признаку self.name.

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

Если переменная создаётся в глобальной области видимости:

Если переменная создаётся в локальной области видимости (внутри функции):

Если переменная создаётся внутри объекта класса:

Нажимая «Принять все файлы cookie» вы соглашаетесь, что Stack Exchange может хранить файлы cookie на вашем устройстве и раскрывать информацию в соответствии с нашей Политикой в отношении файлов cookie.

Переменные в Python: что это такое и какие они бывают

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

Иллюстрация: Оля Ежак для Skillbox Media

Иван Стуков

Если вы откроете любую программу в Python, то, скорее всего, увидите много таких равенств:

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

Что такое переменная в Python

Переменная — это область памяти компьютера, у которой есть имя. Структурно она состоит из трёх частей:

Имя,или идентификатор, — это название, придуманное программистом, чтобы обращаться к переменной. В примерах выше это x, name и coin_flipping_result.
Значение — это информация, которая хранится в памяти компьютера и с которой работает программа. В примерах выше это 4, ‘Виктория’ и [‘орёл’, ‘решка’, ‘решка’, ‘орёл’]. Они всегда принадлежат к какому-либо типу данных.
Адрес — это номер ячейки памяти, в которой хранится значение переменной.

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

Как давать имена переменным

Создавая переменную на языке Python, программисты придумывают ей названия по определённым правилам именования:

первый символ должен быть заглавной или строчной латинской буквой или нижним подчёркиванием _;
остальные символы могут быть заглавными или строчными латинскими буквами, нижними подчёркиваниями и цифрами;
нельзя использовать пробелы;
имя переменной не должно совпадать ни с каким из зарезервированных в Python ключевых слов .

Приведём несколько примеров.

Какие имена можно давать переменным: x, X, xyz, _x_y_z, XYZ, xyz_123, _123, x1Y2z2.
Как нельзя называть переменные: 1, 1x, x y z, x&y.

Python чувствителен к регистру. Таким образом, name и Name будут считаться разными переменными.

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

Чуть позже мы объясним, почему так происходит.

Стили именования переменных

Синтаксис Python позволяет использовать разные стили для именования переменных:

lowercase — все буквы строчные;
lower_case_with_underscores — все буквы строчные, между словами нижние подчёркивания;
UPPERCASE — все буквы заглавные;
UPPER_CASE_WITH_UNDERSCORES — все буквы заглавные, между словами нижние подчёркивания;
CamelCase — каждое слово начинается с заглавной буквы;
mixedCase — каждое слово, кроме первого, начинается с заглавной буквы;
Camel_Case_With_Underscores — каждое слово начинается с заглавной буквы, между словами нижние подчёркивания (это некрасиво, никогда так не делайте).

Тем не менее среди Python-разработчиков принят стандарт PEP 8 — это руководство, в котором собраны рекомендации по оформлению кода. То есть сообщество само для себя устанавливает дополнительные ограничения при именовании переменных:

использовать lowercase, при необходимости разбивая слова нижними подчёркиваниями, если это нужно для улучшения читаемости;
если в готовом проекте преобладает mixedCase, то писать стоит в этом стиле — чтобы сохранялась обратная совместимость;
не давать имена l (строчная L), O (заглавная o) и I (заглавная i) — в некоторых шрифтах они неотличимы от нуля и единицы.

Следуйте советам PEP 8, чтобы ваш код был понятным и легко поддерживаемым.

Как объявить переменную и присвоить ей значение в Python

Python — язык с динамической типизацией. То есть значения присваиваются переменным не при компиляции, а построчно во время выполнения программы.

Поэтому в Python объявлять переменную отдельно не нужно — достаточно сразу её инициализировать, то есть присвоить значение. Для этого используют знак равно =.

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

В языках со статической типизацией, таких как C++ и Java, подобный трюк не пройдёт: компилятор сообщит об ошибке — ведь переменная изначально хранила целое число, а не строку. А в Python это возможно, потому что переменные ссылаются не на сами данные, а на их адрес в памяти.

Как работает инициализация переменных

В Python все данные представлены в виде объектов. У каждого из них есть свой идентификатор — адрес области памяти, в которой он находится.

Этот идентификатор можно узнать с помощью функции id():

Когда мы инициализировали x, программа создала объект с числом 4, принадлежащий к классу (типу данных) int.

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

Выглядит это так:

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

Теперь x и y ссылаются на другие объекты с другими адресами. И так как больше ни одна переменная не ссылается на объект по адресу 2056817043856, то его автоматически удалит сборщик мусора.

Множественное присваивание значений

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

Для присвоения разных значений тоже есть способ:

Импорт переменных

Если переменную нужно импортировать из другого файла, то используют конструкцию from <имя файла> import <имя переменной>.

Например, у нас есть файл variables1.py:

Используем переменную name в файле variables2.py:

При этом доступа к другим переменным из variables1.py в таком случае нет:

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

Для импорта всех объектов после import ставят звёздочку *:

Удаление переменных

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

Типы переменных в Python

Все переменные существуют внутри определённой области видимости. В Python их три:

локальная — внутри одной функции;
глобальная — внутри целой программы (py-файла);
нелокальная — внутри двух смежных функций (внутренней и внешней).

Переменные, которые принадлежат к той или иной области видимости, образуют её пространство имён.

Локальные переменные

Любые переменные, которые объявлены внутри функции, остаются только в этой функции. Например:

Мы можем, как обычно, распоряжаться x: изменять значение, проводить операции, возвращать — но только до тех пор, пока мы делаем это внутри функции local_namespace().

Если мы решим обратиться к x где-то в другой части программы, то интерпретатор её просто не увидит:

И наоборот: функция может распоряжаться только теми переменными, которые находятся внутри неё:

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

В итоге внутри одной программы может быть сразу несколько переменных с одним и тем же именем. Для этого они должны находиться в разных пространствах имён:

Глобальные переменные

Любая переменная, которую объявляют вне функций, является глобальной. Она существует в пространстве имён всего py-файла.

Как мы показали выше, к ней можно обратиться внутри функции, но нельзя изменять. Чтобы исправить это, существует ключевое слово global:

Если мы создаём новую переменную внутри функции, то тем же ключевым словом global можем сделать её глобальной:

Нелокальные переменные

Нелокальные переменные используются, когда одна функция вложена в другую, и охватывают пространство имён только этих двух функций.

Их создают с помощью ключевого слова nonlocal.

При этом в глобальной области видимости к нелокальной переменной мы обратиться не можем:

Проверка существования переменной

В Python есть функции globals() и locals(). Они возвращают словарь с таблицей глобальных и локальных символов соответственно. В них, помимо прочего, хранятся данные о переменных.

Ключом в этих словарях является строка с именем переменной — так можно проверить её существование:

Также из этого словаря по имени переменной можно достать её значение:

Точно так же можно делать и в локальной области видимости:

Максимально возможное значение переменной

В Python, в отличие от многих других языков программирования, нет особого типа данных для хранения больших чисел. Все целые числа относятся к классу int, все числа с плавающей запятой — к классу float.

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

Печать одиноких и множественных переменных

Для печати в Python используется функция print(). С её помощью можно вывести как одиночную переменную, так и несколько, перечислив их через запятую:

Также в Python можно форматировать печать переменных. Для этого предусмотрено несколько способов, но самый удобный из них — f-строки. Нужно передать функции print() строку c буквой f перед ней. Сами переменные указываются в фигурных скобках: .

Итоги

Переменные в Python состоят из имени и значения. При этом они хранят в себе не само значение, а ссылку на его адрес в памяти.
Для их именования используют цифры (не могут быть первым символом в имени), латинские буквы и нижние подчёркивания.
В Python не надо отдельно объявлять переменную — ей сразу присваивают значение. В одной строке можно создать сразу несколько переменных.
Они существуют внутри определённой области видимости. Переменные бывают глобальные (внутри всей программы), локальные (внутри одной функции) и нелокальные (внутри двух вложенных друг в друга функций).
У переменных в Python нет ограничения по размеру — они могут быть настолько большими, насколько хватит памяти устройства.
Их можно импортировать из других файлов, удалять, проверять их существование в текущей области видимости, печатать в форматированной строке.

Читайте также:

Вот их список: and, as, assert, async, await, break, class, continue, def, del, elif, else, except, False, finally, for, from, global, if, import, in, is, lambda, None, nonlocal, not, or, pass, raise, return, True, try, while, with, yield.

Целое число, число с плавающей запятой, строка, список, словарь и так далее.