Файл: Установка Python.docx

1

Установка Python

1.1

Зайти на https://www.python.org/downloads/, загрузить и запустить инсталлятор



1.2

Выбрать опцию:



1.3

Тут заполнить:



1.4

Нажать install и дождаться завершения установки. В результате в указанной директории должна получиться такая картина:



2.

Использование Python

2.1 Установить Pycharm https://www.jetbrains.com/ru-ru/pycharm/download/ (или любую другую пригодную IDE (вроде даже в VisualStudio можно создавать проекты на python))

2.1 Писать код в простом редакторе типа Notepad++ (https://notepad-plus-plus.org/downloads/) или любом другом

Например:

1. 
   Создать новый файл Notepad++ и ввести одну строчку кода:
   

2. 
   Сохранить с расширением .py:
   

3. 
   Открыть cmd командную строку (зажав клавиши Win+R и введя cmd в строку):
   

4. 
   Запустить скрипт указав путь до python и до файла скрипта:
   

Обзор основных возможностей Python (v3)

Базовый синтаксис

Первое, что, как правило, бросается в глаза, если говорить о синтаксисе в Python, это то, что отступы имеют значение:

• 
  они определяют, какой код попадает в блок
  
• 
  когда блок кода начинается и заканчивается
  

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

a = 10
b = 5

if a > b:
print("A больше B")
print(a - b)
else:
print("B больше или равно A")
print(b - a)

Комментарии

Комментарии в Python могут быть однострочными. Однострочные комментарии начинаются со знака решётки:

# Очень важный комментарий
a = 10
b = 5 # Очень нужный комментарий

---

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

"""
Многострочный
комментарий
"""

'''
Тоже
многострочный
комментарий
'''

Переменные

Переменные в Python не требуют объявления типа переменной (так как Python – язык с динамической типизацией) и являются ссылками на область памяти. Правила именования переменных:

• 
  имя переменной может состоять только из букв, цифр и знака подчёркивания
  
• 
  имя не может начинаться с цифры
  
• 
  имя не может содержать специальных символов @, $, %.
  

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

• 
  имена переменных обычно пишутся или полностью большими или полностью маленькими буквами (например DB_NAME, db_name);
  
• 
  имена функций задаются маленькими буквами, с подчёркиваниями между словами (например, get_names);
  
• 
  имена классов задаются словами с заглавными буквами без пробелов, это так называемый CamelCase (например, CiscoSwitch)
  

a = 3
b = 'Hello'
c, d = 9, 'Test'

def get_string():
return "string"

class StringsProducer:
pass

Типы данных

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

• 
  None (ничто)
  

obj = None

• 
  Boolean (логический тип данных)
  

correct = True
correct = False

• 
  Numbers (числа) (целые и с плавающей точкой)
  

number = 5
fraction = 5.45

number = int(5.45) # 5
fraction = float(4) # 5.0

• 
  Strings (строки)
  

label = "Обычная строка"
byte_string = b"byte string"

label = 'Обычная строка'
byte_string = b'byte string'

byte_string = label.encode('utf-8') # байтовую строку можно получить закодировав обычную
label = byte_string.decode('utf-8') # обычную строку можно получить декодировав байтовую

• 
  Lists (списки)
  

array = ['п', 'р', 'и', 'в', 1, 2, 3, True, None] # список значений любых типов

• 
  Tuples (кортежи)
  

array = ('п', 'р', 'и', 'в', 1, 2, 3, True, None) # похожи на списки, только не могут быть изменены

• 
  Sets (множества)
  

array = {'п', 'р', 'и', 'в', 1, 2, 2, 2, 2, 3, True, None} # хранят только уникальные значения, поэтому 2 останется только одна

• 
  Dictionaries (словари)
  

"""
Хранят пары ключей и значений
Используются для доступа к значениям по ключу вместо числового индекса
Ключи указываются перед двоеточием, значения после
Пары ключей и значений разделяются запятой
В качестве ключей используются значения любых неизменяемых типов

---

В качестве значений можно использовать значения любых типов
"""
mixed_example = {
4: 1,
3.445: 2,
'key': 3,
b'key': 4,
False: 5,
None: 6,
(1, 2, 3): 7
}


"""
Но обычно в качестве ключей используются строки
Пример списка продуктов и их стоимости:
"""
goods_to_price_map = {
"сахар": 45.0,
"молоко": 51.5,
"масло": 120.0
}

Эти типы данных можно, в свою очередь, классифицировать по нескольким признакам:

• 
  Изменяемые (mutable) (списки, словари и множества)
  

"""
Операции со списками
"""
list_of_fruits = ['Яблоко', 'Апельсин']


# Добавление элементов в конец списка
list_of_fruits.append('Абрикос') # стало ['Яблоко', 'Апельсин', 'Абрикос']

list_of_fruits += ['Груша', 'Персик'] # стало ['Яблоко', 'Апельсин', 'Абрикос', 'Груша', 'Персик']


# Изменение элементов списка по их порядковому номеру
list_of_fruits[0] = 'Слива' # стало ['Слива', 'Апельсин', 'Абрикос', 'Груша', 'Персик']

list_of_fruits[2] = 'Гранат' # стало ['Слива', 'Апельсин', 'Гранат', 'Груша', 'Персик']

list_of_fruits[-2] = 'Абрикос' # второй элемент с конца изменён, стало ['Слива', 'Апельсин', 'Гранат', 'Абрикос', 'Персик']


# удаление элементов из списка по их порядковому номеру
del list_of_fruits[1] # стало ['Слива', 'Гранат', 'Абрикос', 'Персик']

del list_of_fruits[-1] # первый элемент с конца удалён, стало ['Слива', 'Гранат', 'Абрикос']


# извлечь элемент из списка по индексу (по умолчанию -1 (первый с конца)) и записать его в переменную
last_fruit = list_of_fruits.pop()


"""
Операции с множествами
"""
cities = {'Москва', 'Москва', 'Лондон'} # повторные значения не добавляются {'Москва', 'Лондон'}


# Добавление элемента в множество
cities.add('Москва') # не добавится, так как уже есть

cities.add('Париж') # стало {'Москва', 'Париж', 'Лондон'}

cities.update({'Париж', 'Мадрид', 'Пекин'}) # 'Париж' уже есть, стало {'Лондон', 'Мадрид', 'Пекин', 'Париж', 'Москва'}


# Ещё один список городов
another_cities = {'Москва', 'Лондон', 'Лиссабон'}


# Операции со множествами
common_cities = cities.intersection(another_cities) # Общие города {'Москва', 'Лондон'}

unique_cities1 = cities.difference(another_cities) # Города, которые есть в первом множестве, и которых нет во втором {'Пекин', 'Париж', 'Мадрид'}

different_cities = cities.symmetric_difference(another_cities) # Города, которые есть только в первом и втором множествах (которые не общие) {'Мадрид', 'Лиссабон', 'Париж', 'Пекин'}

all_cities = cities.union(another_cities) # Объединение городов из двух множеств {'Москва', 'Париж', 'Мадрид', 'Лиссабон', 'Лондон', 'Пекин'}

contains = cities.issubset(another_cities) # False, так как первый список не является подмножеством второго

contains = cities.issubset(all_cities) # True, так как первый список является частью объединённого множества


# Удаление элемента из множества

---

all_cities.remove('Пекин') # {'Лиссабон', 'Мадрид', 'Париж', 'Лондон', 'Москва'}

random_city = all_cities.pop() # Извлекает произвольный элемент и присваивает в переменную


"""
Операции со словарями
"""
goods_to_price_map = {
"сахар": 45.0,
"молоко": 51.5,
"масло": 120.0
}


# Добавление пары ключ-значение в словарь
goods_to_price_map["мука"] = 42.0


# Добавление нескольких пар ключ-значение в словарь
goods_to_price_map.update({
"соль": 14.5,
"перец": 25
}) # цена на перец будет добавлена, цена на соль обновлена


# Удаление пар ключ-значение из словаря
del goods_to_price_map["молоко"]

salt_price = goods_to_price_map.pop("соль") # пара с ключом "соль" извлечена из словаря, а значение записано в переменную

product = goods_to_price_map.popitem() # крайняя пара извлечена из словаря и записана в переменную в виде кортежа из двух значений (ключа и значения)

• 
  Неизменяемые (immutable) (числа, строки и кортежи)
  

# Обычные строки, байтовые строки и кортежи не могут быть изменены
label = "Я строка"
lyrics = ("Из", "песни", "слов", "не", "выкинешь")

# Попытка изменения символа в строке приведёт к ошибке
# label[0] = 'I'


# Также ошибка произойдёт при попытке изменить или удалить символ/элемент в строках или кортежах
# del lyrics[3]

• 
  Упорядоченные (ordered) (списки, кортежи, строки)
  

numbers = ['Zero', 'One', 'Two', 'Three', 'Four', 'Five', 'Six', 'Seven', 'Eight', 'Nine']

# Доступ по порядковому номеру. Работает аналогично для списков, кортежей и строк
numbers[0] # 'Zero'
numbers[1] # 'One'
numbers[-2] # 'Eight'


# Срезы. Работают аналогично для списков, кортежей и строк
# Если делаете срез списка, будет получен новый список, оригинал не меняется
# Если делаете срез кортежа, будет получен новый кортеж, оригинал не меняется
# Если делаете срез строки, будет получена новая строка, оригинал не меняется
numbers[1:4] # ['One', 'Two', 'Three']
numbers[:4] # ['Zero', 'One', 'Two', 'Three']
numbers[6:-2] # ['Six', 'Seven']
numbers[6:] # ['Six', 'Seven', 'Eight', 'Nine']
numbers[:] # ['Zero', 'One', 'Two', 'Three', 'Four', 'Five', 'Six', 'Seven', 'Eight', 'Nine']
numbers[::2] # ['Zero', 'Two', 'Four', 'Six', 'Eight']
numbers[::-1] # ['Nine', 'Eight', 'Seven', 'Six', 'Five', 'Four', 'Three', 'Two', 'One', 'Zero']

• 
  Неупорядоченные (unordered) (множества, словари)
  

Проверка и преобразование типов

# Коллекции
numbers = ['Zero', 'One', 'Two', 'Three', 'Four', 'Five', 'Six', 'Seven', 'Eight', 'Nine']
isinstance(numbers, list) # True
type(numbers) == tuple # False

numbers = tuple(numbers) # ('Zero', 'One', 'Two', 'Three', 'Four', 'Five', 'Six', 'Seven', 'Eight', 'Nine')
isinstance(numbers, tuple) # True
type(numbers) == set # False

numbers = set(numbers) # {'Seven', 'Five', 'Two', 'Four', 'Nine', 'Zero', 'One', 'Three', 'Six', 'Eight'}
isinstance(numbers, set) # True
type(numbers) == list # False


# Числа
digit = 42
isinstance(digit, int) # True

---

type(digit) == float # False

digit = float(digit) # 42.0
isinstance(digit, float) # True
type(digit) == int # False


# Булевы преобразования
bool(42) # True
bool(0) # False

bool(-2) # True !!!
bool([1, 2, 3]) # True
bool([]) # False

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

# Арифметика чисел
a = 12 + 2 # 14
b = 12 * 2 # 24
c = 12 - 2 # 10
d = 12 / 2 # 6

e = 14 // 3 # 4 (целочисленное деление, дробная часть отбрасывается)
f = 12 % 3 # 0 (остаток от деления)
g = 12 ** 2 # 144 (возведение в степень)
h = 9 ** (1 / 2) # 3 (извлечение корня)


# Списковые типы
i = [1, 1, 1] + [2, 2, 2] # [1, 1, 1, 2, 2, 2]
j = [1, 1, 1] * 2 # [1, 1, 1, 1, 1, 1]


k = "Hello" + " " + "world" # "Hello world"
l = "Hello" * 2 # "HelloHello"

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

Конструкция if – elif – else

goods_to_price_map = {
"сахар": 45.0,
"молоко": 51.5,
"масло": 120.0
}

if "сыр" in goods_to_price_map:
print("Сыр есть в наличии, можно брать")
elif goods_to_price_map:
print("Сыра нет, но можно взять что-то другое")
else:
print("На витрине пусто =(")

# Тернарный оператор
honey_price = goods_to_price_map["мёд"] if "мёд" in goods_to_price_map else 0

Логические операции not, and, or, is, in…

# Функция проверяет списки на идентичность
def is_list_equal(list_a, list_b):
return list_a == list_b


# Функция проверяет ссылаются ли переменные на один и тот же список
def is_the_same_list(list_a, list_b):
return list_a is list_b


# Функция добавляет значение в список, если значения нет в этом списке
def add_to_list(value, target_list):
if value not in target_list:
target_list.append(value)


# Функция проверяет является ли первое значение меньше второго
def is_less_than(a, b):
return a < b


# Функция проверяет является ли первое значение больше второго
def is_greater_than(a, b):
return a > b


# Функция проверяет входит ли значение в диапазон
def is_in_range(a, value, b):
return a <= value <= b

Циклы while – else и for – else, break, continue

command = None
history = []

while True:
command = input()

if command == "quit":
break
else:
history.append(command)
else:
print("Ввод команд завершён") # тело в секции else не выполнится, если цикл прерван используя break
# выполнится только если цикл доработал до конца по условию в while
for command in history:
if "echo" in command:
continue
else:
print(command)
else:
print("Вся история команд распечатана")

Пропуск реализации pass

# pass требуется чтобы явно обозначить пустое тело цикла, условия или описания функции или класса, так как после двоеточия ожидается тело с отступом
while True:
pass
# Функция, логика которой будет реализована позже
def future_function():
# TODO: реплизация будет написана позже
pass

Обработка исключений, конструкция try – except – else – finally

Конструкция try – except используется для обработки исключений вызываемых при возникновении ошибок во время исполнения кода. Код, который потенциально может «кинуть исключение» выполняется в теле секции try, а код, который должен обработать исключение в теле секций except. Конструкция позволяет отлавливать и обрабатывать исключения нескольких типов, при этом будет вызван только один обработчик, для которого указан наиболее подходящий тип. Все исключения наследуют класс Exception, поэтому, если ни один из ожидаемых типов исключений не совпадает с вызванным, конструкция попытается использовать обработчик исключения Exception (except Exception… или просто except: …), если общий обработчик не указан, исключение не будет обработано, и программа завершится с ошибкой.

---