Автор: Danil Nagy. Перевод: Дмитрий Булка. Оригинал: https://medium.com/generative-design/fundamentals-of-python-variables-b0523dd698a7
Если вы никогда не писали код или не занимались компьютерным программированием, вся эта концепция может показаться пугающей на первый взгляд. Однако, в то время как передовая разработка программного обеспечения, без сомнения, невероятно сложна, программирование в целом основано только на нескольких ключевых концепциях. Понимая эти понятия с самого начала, вы будете меньше бояться всего конкретного синтаксиса, который вы еще не знаете. До тех пор, пока вы можете выразить то, что вы хотите, чтобы программа делала в общих чертах, вы всегда можете искать в интернете примеры использования правильного синтаксиса. На самом деле, именно так большинство людей и учатся программировать сегодня. Кроме того, хотя каждый язык программирования имеет свой собственный синтаксис, почти все они следуют одним и тем же основным принципам, поэтому изучение этих принципов будет полезно независимо от того, какой язык вы в конечном итоге используете.
Первый бит синтаксиса Python, который мы рассмотрим, - это очень важный комментарий. Чтобы определить комментарий, начинайте строку с символа #, который говорит Python игнорировать все, что находится в этой строке после символа #. Попробуйте ввести в Редактор следующие строки кода и выполнить сценарий:
#это комментарий
print 'это код' #это тоже комментарий
Если вы запустите этот код, вы увидите, что он выводит "это код", потому что он выполняет строку <print ‘это код’>. Между тем он игнорирует оба комментария, происходящие после символа #. Хотя каждый язык определяет их по-разному, комментарии являются важной частью каждого языка программирования, поскольку они позволяют разработчику добавлять дополнительную информацию и описание к своему коду, которые не имеют строгого отношения к его выполнению.
Теперь, когда мы знаем основы, давайте посмотрим, как мы можем реализовать пять основных элементов компьютерного программирования в Python, начиная с переменных.
Переменные можно рассматривать как контейнеры, хранящие некоторую форму данных. Вы можете использовать переменные в Python для хранения фрагментов информации, а затем вызывать их позже, когда они вам понадобятся. В Python переменные могут быть объявлены и назначены свободно, в отличие от других языков, где вы должны явно указать тип данных, которые они будут хранить. Чтобы присвоить значение переменной, используйте оператор = :
a = 2
Здесь а — это имя моей переменной, а число 2 — это данные, которые я ей присваиваю. С этого момента а будет ассоциироваться с числом 2, пока ему не будет присвоено другое значение или программа не завершится. Попробуйте этот код:
a = 2
b = 3
print a + b
Это должно вывести число 5, так как а хранит число 2, а в хранит число 3. Таким же образом можно использовать и многие другие распространенные арифметические операторы. Некоторые из наиболее распространенных являются:
В Python вы можете называть свои переменные как угодно, если они начинаются с буквы, не содержат пробелов и не являются зарезервированным ключевым словом (например, print). На практике для повышения читабельности большинство программистов придерживаются некоторых соглашений об именовании переменных. Один из распространенных подходов заключается в использовании "ВерблюжьегоРегистра", чтобы сделать переменные, состоящие из нескольких слов, читаемыми без пробелов.
вВерблюжьемРегистреПервоеСловоСтрочноевтовремякаквсепоследующиесловапрописные
Также часто вместо пробелов в именах переменных используются символы подчеркивания ( _ ). В общем случае имена переменных не должны быть слишком длинными, но должны грешить на стороне описания, а не краткости, чтобы облегчить читаемость кода. Например, если вы отслеживаете количество черники, то лучше называть переменную numBlueberries, чем просто n или b.
Переменные могут содержать данные различных типов. Хотя Python не заставляет вас явно объявлять тип данных, которые вы будете использовать, важно знать типы, потому что каждый из них будет вести себя по-разному в вашем коде. Хотя существует множество различных типов данных, поддерживаемых Python, наиболее распространенными из них являются:
В Python вы можете использовать функцию type (), чтобы получить тип для любого фрагмента данных. Попробуйте выполнить следующий код:
print type(12)
print type(12.1)
print type(True)
print type('blueberries')
Вы можете видеть, что он печатает четыре типа, описанные выше. Обратите также внимание на особый способ записи данных, чтобы Python не путал их с именем переменной. Числа могут быть записаны непосредственно, потому что вы не можете назвать переменные только числом. Логические значения должны быть написаны с заглавной буквы (True или False), так как это зарезервированные ключевые слова в Python (обратите внимание на синтаксическую раскраску). Строки всегда содержатся в кавычках. Вы можете использовать как одинарные ( ’ ), так и двойные (“) кавычки, но они должны совпадать по обе стороны строки. Если вы попытаетесь написать
print type(blueberries)
без кавычек вы получите следующую ошибку:
NameError: name 'blueberries' is not defined (название "черника" не определено)
ОшибкаИмени: имя 'blueberries' не определено как переменная. Однако, если вы напишете:
blueberries = 5
print type(blueberries)
он скажет вам, что это int, потому что blueberries теперь является переменной с int, хранящейся внутри неё.
В Python многие операторы "перезагружены", что означает, что они функционируют по-разному в зависимости от типа данных, на которых они используются. Например, если мы наберем
print 2 + 2
мы получаем 4. При задании двух чисел оператор + выполняет арифметическое сложение. Однако, если мы наберем
print 'First ' + 'Last'
мы получаем First Last. Когда заданы две строки, оператор + "связывает" или объединяет их вместе в одну строку. Перезагрузка полезна тем, что она создает чистый и читаемый код, не имея специальной функции для каждого типа переменной. Однако вы должны быть осторожны, потому что несовпадение различных типов переменных может привести к ошибкам. Например, эта строка
numBerries = 5
print 'Number of Blueberries: ' + numBerries
будет выдавать ошибку, потому что он пытается выполнить конкатенацию строки и целого числа. Вместо этого вы можете использовать функцию str() для преобразования 5 в строку, прежде чем использовать ее с оператором +.
numBerries = 5
print 'Number of Blueberries: ' + str(numBerries)
В дополнение к хранению отдельных фрагментов данных, вы также можете использовать переменные для хранения многих фрагментов данных, а затем получить к ним структурированный доступ. Существует два основных типа составных переменных:
Список можно создать, используя квадратные скобки и разделяя отдельные элементы запятыми, например:
numbers = [1, 2, 3, 4, 5]
fruits = ['apples', 'oranges', 'bananas']
Чтобы извлечь объект из такого списка, вы снова используете квадратные скобки, но на этот раз добавленные к концу имени переменной. Внутри скобок вы помещаете индекс или место нужной Вам части данных. Например:
numbers = [1, 2, 3, 4, 5]
print numbers[0]
fruits = ['apples', 'oranges', 'bananas']
print fruits[1]
Обратите внимание, что, как и во всех языках, подсчет начинается с 0, поэтому, если вы хотите, чтобы первый элемент в списке был использован [0], второй элемент [1] и т. д. В отличие от многих других языков, Python позволит вам смешивать различные типы данных в одном списке, так что что-то вроде этого совершенно законно:
numbers = [1, 2, 3, 4, 5]
newNumbers = numbers[0:3] # [индекс первого элемента: индекс после последнего элемента]
print newNumbers
Вы даже можете индексировать в обратном направлении, используя отрицательные индексы. Например, это позволит распечатать последний элемент в списке:
numbers = [1, 2, 3, 4, 5]
print numbers[-1]
Существуют различные функции, помогающие работать со списками. Наиболее распространенной является функция .append(), которая добавляет значение в конец списка:
numbers = []
numbers.append(6)
print numbers
Вы даже можете начать с пустого списка и постепенно заполнить его добавлениями:
numbers = []
numbers.append(1)
numbers.append(2)
print numbers
Для других функций списка вы можете обратиться к документации Python.
Списки чрезвычайно полезны для хранения нескольких фрагментов данных в определенной последовательности. Однако иногда вы хотите иметь возможность вспомнить фрагмент данных, не зная его точного положения в списке. Для этого можно воспользоваться словарями. Словари хранят несколько фрагментов данных, привязывая их к уникальным ключам. Затем вы можете использовать ключи для вызова данных. По этой причине словарные статьи часто называют парами ключ-значение.
Чтобы создать словарь, вы используете фигурные скобки, разделяющие ключи и значения с помощью ":", а несколько записей с помощью ",":
dict = {'a': 1, 'b': 2, 'c': 3}
В этом словаре целые числа 1, 2 и 3 привязаны к своим уникальным ключам a, b и c. Обратите внимание, что ключи должны быть строками, А значения — любым типом данных. Чтобы извлечь фрагмент данных из этого словаря, вы можете снова использовать обозначение квадратными скобками, на этот раз передавая ключ вместо индекса:
dict = {'a': 1, 'b': 2, 'c': 3}
print dict['a']
Чтобы добавить записи в словарь, вам просто нужно указать данные, относящиеся к определенному ключу, используя оператор = и тот же синтаксис квадратных скобок:
dict = {'a': 1, 'b': 2, 'c': 3}
dict['d'] = 4
print dict['d']
Как и в случае со списками, вы можете начать с пустого словаря и построить его со временем:
dict = {}
dict['a'] = 1
dict['b'] = 2
print dict
Существует также множество полезных функций для работы со словарями, в том числе функция .keys(), которая возвращает список всех ключей словаря:
dict = {'a': 1, 'b': 2, 'c': 3}
print dict.keys()
Для других полезных функций вы можете обратиться к соответствующему месту в документации.
Наконец, значения в списках и словарях также не ограничиваются отдельными фрагментами данных, а также могут быть списками и словарями. Это позволяет создавать очень сложные структуры данных, которые могут соответствовать потребностям любого проекта. Вы можете получить доступ к элементам внутри такой иерархической структуры, связав запросы в квадратные скобки. Вот вам пример:
dict = {}
dict['numbers'] = [1, 2, 3, 4, 5]
dict['fruits'] = ['apples', 'oranges', 'bananas']
dict['numbers'].append(6)
dict['fruits'].append({'berries':['strawberries', 'blueberries']})
#составной запрос, выводить 'blueberries'
print dict['fruits'][-1]['berries'][1]
JSON, один из наиболее реализованных и простых в работе форматов данных, фактически основан на этой концепции вложенных списков и пар ключ-значение и имеет большую поддержку почти во всех языках программирования, включая Python и JavaScript. Мы начнем внедрять его позже в ходе курса, но пока вы можете ознакомиться с его документацией здесь: https://www.json.org/json-ru.html.