Если вы никогда не писали код и не занимались программированием на компьютере, вся концепция поначалу может показаться пугающей. Однако, хотя передовая разработка программного обеспечения, без сомнения, невероятно сложна, программирование в целом основано только на нескольких ключевых концепциях. Понимая эти концепции с самого начала, вы будете меньше пугаться синтаксиса, которого вы еще не знаете. Если вы можете выразить то, что вы хотите, чтобы программа делала в общих чертах, вы всегда можете поискать в Интернете примеры использования правильного синтаксиса. Фактически, именно так сегодня большинство людей учится программировать. Более того, хотя каждый язык программирования имеет собственный синтаксис, почти все они следуют одним и тем же основным принципам, поэтому изучение этих принципов будет полезно независимо от того, какой язык вы в конечном итоге используете.
Первый фрагмент синтаксиса Python, который мы рассмотрим, - это очень важный «комментарий». Вы указываете комментарий, начиная строку с ’#’, что указывает Python игнорировать все в этой строке после символа ’#’. Попробуйте ввести в редактор следующие строки кода и выполнить сценарий:
#this is a comment print 'this is code' #this is also a comment
Если вы запустите этот код, вы увидите, что он распечатывает «это код», потому что выполняет строку ‹print« это код »›. При этом игнорируются оба комментария, следующие после символа ’#’. Хотя каждый язык определяет их по-разному, комментарии являются важной частью каждого языка программирования, поскольку они позволяют разработчику добавлять дополнительную информацию и описание в свой код, которые не связаны строго с его выполнением.
Теперь, когда мы знаем основы, давайте посмотрим, как мы можем реализовать пять основных элементов компьютерного программирования на Python, начиная с переменных.
Переменные
Вы можете рассматривать переменные как контейнеры, в которых хранятся данные в той или иной форме. Вы можете использовать переменные в Python для хранения фрагментов информации, а затем вызывать их позже, когда они вам понадобятся. Переменные можно свободно объявлять и назначать в Python, в отличие от других языков, где вы должны явно указывать тип данных, которые они будут хранить. Чтобы присвоить значение переменной, используйте оператор ’=’:
a = 2
Здесь «a» - это имя моей переменной, а цифра «2» - это данные, которые я ей присваиваю. С этого момента «a» будет ассоциироваться с числом «2», пока ему не будет присвоено другое значение или пока программа не завершится. Попробуйте этот код:
a = 2 b = 3 print a + b
Это должно распечатать число 5, так как «a» хранит число «2», а «b» сохраняет число «3». Таким же образом можно использовать многие другие распространенные арифметические операторы. Вот некоторые из наиболее распространенных:
- + (сложение)
- - (вычитание)
- * (умножение)
- / (разделение)
- ** (возвести в степень)
- % (по модулю)
В Python вы можете называть свои переменные как угодно, если они начинаются с буквы, не содержат пробелов и не являются зарезервированным ключевым словом (например, «print»). На практике для повышения удобочитаемости большинство программистов соблюдают некоторые соглашения об именах переменных. Один из распространенных подходов - использовать «верблюжий регистр», чтобы переменные, состоящие из нескольких слов, читались без пробелов.
withCamelCaseTheFirstWordIsLowerCaseWhileAllSubsequentWordsAreUpperCase
Также распространено использовать символы подчеркивания (’_’) вместо пробелов в именах переменных. В общем, имена переменных не должны быть слишком длинными, но должны содержать ошибки в описании, а не в краткости, чтобы облегчить читаемость кода. Например, если вы отслеживаете количество ягод черники, лучше называть переменную «numBlueberries», чем просто «n» или «b».
Переменные могут содержать данные разных типов. Хотя Python не требует явного объявления типа данных, которые вы будете использовать, важно знать типы, потому что каждый из них будет вести себя в вашем коде по-разному. Хотя Python поддерживает множество различных типов данных, наиболее распространенными являются:
- int (означает целое или целое число)
- float (означает число с плавающей запятой или десятичное число)
- bool (означает логическое значение или истина / ложь)
- str (означает строку или «кусок текста»)
В 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 = 5 print type(blueberries)
он скажет вам, что это int, потому что «blueberries» теперь является переменной, внутри которой хранится int.
В Python многие операторы «перегружены», что означает, что они работают по-разному в зависимости от типа данных, для которого они используются. Например, если мы введем
print 2 + 2
мы получаем «4». Если даны два числа, оператор ’+’ выполняет арифметическое сложение. Однако, если мы введем
print '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 позволяет вам смешивать разные типы данных в одном списке, поэтому что-то вроде этого совершенно законно:
fruitsAndNumbers = ['apples', 2, 'bananas'] print type(fruitsAndNumbers) print type(fruitsAndNumbers[0]) print type(fruitsAndNumbers[1])
Вы также можете использовать ’:’ в квадратных скобках, чтобы получить диапазон значений из списка, который сформирует новый список:
numbers = [1, 2, 3, 4, 5] newNumbers = numbers[0:3] # [index of first item:index after last item] print newNumbers
Вы даже можете индексировать в обратном направлении, используя отрицательные индексы. Например, это распечатает последний элемент в списке:
numbers = [1, 2, 3, 4, 5] print numbers[-1]
Существуют различные функции, помогающие работать со списками. Чаще всего используется .append (), который добавляет значение в конец списка:
numbers = [1, 2, 3, 4, 5] 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']})
#compound request, should print 'blueberries'
print dict['fruits'][-1]['berries'][1]
JSON, один из наиболее реализуемых и простых для работы с форматами данных, фактически основан на этой концепции вложенных списков и пар ключ-значение и имеет отличную поддержку практически на всех языках программирования, включая Python и JavaScript. Мы начнем реализовывать его позже в ходе курса, а пока вы можете ознакомиться с его документацией здесь: http://json.org/.
