Python 101

Вывод в консоль:

Вывести в консоль:

print($arg1, arg2,...)

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

Базовые типы:

integer(целое число)
float(число с десятичной частью)
string(строка)
boolean(True/False)
none(undefined)

Можно проверить тип любого значения с помощью type()

Преобразование между типами:

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

str()
int()
float()
bool()

Ложные значения:

bool(0)
bool(0.0)
bool(“”) - пустая строка
bool(False)
bool(None)
bool([]) - пустой список
bool({}) - пустой словарь

Выбор названий для переменных и констант:

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

Например:
my_favourite_song

Для констант используются заглавные буквы:

MY_API_KEY

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

Переменные и динамическая типизация:

Объявить переменную просто:

my_name = “Bogdan”

Питон - язык с динамической типизацией. Это означает что мы можем изменить тип значения переменной.

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

is_logged_in = True
my_name = “Bogdan”

Базовые типы копируются по значению:

Можно копировать переменные с базовыми типами:

my_name = “Bogdan”
other_name = my_name
other_name // ‘Bogdan’

Увеличение и уменьшение переменных:

age = 21
age = age + 1
age // 22
age += 2
age // 24
age -= 5
age // 19

Также можно присвоить None любой переменной:

age = None

И удалить переменную:

del age

Списки(list):

a = []

type(a) // <class ‘list’> - тип переменной - список

len(a) // 0 - длина списка

Переменная а, как экземпляр списка, имеет множество методов, которые можно вызывать с помощью точечной записи:
a.+Tab[x2] - покажет доступные методы для переменной.

Индексы списка начинаются с 0, так же как и индексы массива в JS.

.append - используется для добавления элементов в конец существующего списка.

a.append(2)
a.append(‘abc’)
a // [2, ‘abc]

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

a[0] // 2
a[1] // ‘abc’

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

a[-1] // abc
a[-2] // 2

.pop() - удалить последний элемент в списке (как в массиве JS). Вызывается без аргументов.

.clear() - удалить все элементы из списка.

Tuples:

Tuple - неизменяемый контейнерный тип. В него нельзя добавлять новые элементы

b = (2, ‘abc’)
b // (2, ‘abc’)

type(b) // <class ‘tuple’>

У tuple всего 2 метода: .count и .index

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

b[0] // 2
b[1] // ‘abc’

С помощью метода .index можно получить индекс определенного элемента.

b.index(“abc”) // 1

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

Словари(dictionary):

Словари создаются с помощью пары фигурных скобок, внутри которых находятся пары ключ: значение. (Ничего не напоминает?^_^)
Порядок ключей в словаре не имеет значения.

{“key1”: True, “key2” : 10}

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

person = {“name”: “Bogdan”}
person[“name”] // ‘Bogdan’

Также можно получить доступ к ключу с помощью метода .get:

person.get(“name”) // ‘Bogdan’

Также с помощью .get можно получить доступ к несуществующему ключу:

person.get(“age”) //
str(person.get(“age”)) // None - т.к у ключа age нет значения
person.get(“age”, 18) // Таким способом можно присвоить ключу значение.

Добавить новые ключи можно с помощью квадратных скобок:

person[“happy”] = True
person // {‘name’: ‘Bogdan’, ‘happy’: True}

Изменять имеющиеся значения ключей можно используя ту же нотацию.

person[“happy”] = False
person // {‘name’: ‘Bogdan’, ‘happy’: False}

С помощью функции len() можно получить длину словаря.

С помощью метода .keys можно получать ключи словаря:

person.keys() // dict_keys(['name', 'happy'])

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

Аналогичным способом можно получить значения, с помощью метода .values

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

list(person.values())[0] // ‘Bogdan’

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

person["hobbies"] = ["books", "snowboarding"]
person // {'name': 'Bogdan', 'happy': False, 'hobbies': ['books', 'snowboarding']}

Можно изменять элементы списка с помощью такого синтаксиса:

person[“hobbies”].pop() // ‘snowboarding’
person // {'name': 'Bogdan', 'happy': False, 'hobbies': ['books']}

Копирование по ссылке:

Сейчас person является словарем

person
{'name': 'Bogdan', 'happy': False}
another_person = person
another_person["name"] = "Bob"
person // {'name': 'Bob', 'happy': False}

Словарь и список являются ссылочным типом.

Наборы(set):

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

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

my_set.add() - добавить элемент
my_set.remove() - удалить элемент

Итоги по типам контейнеров:

Списки(list) создаются с помощью квадратных скобок и в них могут быть элементы разных типов.
Tuple создаются с помощью круглых скобок и в них могут быть те же элементы что и в списке. Значения типа tuple неизменяемы.
Словари(dictionary) создаются с помощью фигурных скобок и содержат пары ключ: значение.
Наборы(set) создаются с помощью фигурных скобок, но наборы имеют только значения, которые являются уникальными (двух одинаковых значений быть не может).

Разница между этими 4 типами в том, что список и tuple упорядочены, элементы в них имеют собственный уникальный индекс.

Функции:

Функции объявляются с помощью ключевого слова def:

def my_name():
pass

По умолчанию функция возвращает None, если нет инструкции return.

Можно также указать значение по умолчанию для аргумента.

def my_name(name="No name"):
return name
print(my_name("Bogdan")) // Bogdan
print(my_name()) // No name

Позиционные аргументы:

Тело функции всегда нужно писать после отступа, иначе питон выдаст ошибку.

def person_info(name,age):
print(name)
print(age)
person_info("Bob", 25) // аргумент name получил значение “Bob”, age - 25
person_info(25, "Bob") // аргумент name получил значение 25, age - “Bob”

В данном примере аргументы “Bob” и 25 - позиционные, т.е. важен порядок их указания.

Именованные аргументы:

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

person_info(name=”Bob”, age=25)
person_info(age=25, name=”Bob”)

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

Также можно смешивать позиционные аргументы и именованные аргументы.

person_info(”Bob”, age=25)

Сбор всех аргументов в Tuple:

Если мы не знаем точно, сколько аргументов будет принимать функция, можно использовать специальную переменную args. В таком случае переданные значения будут записаны в переменную args, тип которой - tuple.

Перебор значений с использованием цикла for..in:

def sum(*args):
total = 0
for arg in args:
total += arg
return total
print(sum(5, 2, 10, 15))

Поскольку args имеет тип tuple мы можем перебирать его элементы. Сама функция почти идентична методу .reduce для массива в javascript.

Использование kwargs в функциях:

kwargs - аргументы с ключевыми словами.

def person_info(**args):
print(args)
person_info(name="Bob", age=25)

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

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

Описание функций:

Признаком хорошего тона является добавление описания к каждой функции.
Делается это следующим образом:

def sum(a, b):
"""Sums two numbers
Numbers must be integers"""
return a + b

Операторы сравнения:

== - равно

!= - не равно

> - больше

< - меньше

>= - больше или равно

<= - меньше или равно

Логический оператор and:

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

Если все значения верны, то вернется последнее.

Если передать функции bool такое выражение, то при хотя бы одном ложном значении результат будет false, без ложных - true.

Оценка короткого замыкания(Short-circuit evaluation):

Если питон видит ложное значение он не идет дальше. Например, если у выражения

a and b and c, a имеет ложное значение то питон остановится после оценки первого операнда.
Это называется оценкой короткого замыкания. Не имеет значения, что будет дальше, если мы уже нашли первое ложное значение в таком выражении, оно немедленно возвращается как результат этого выражения, а оставшаяся часть не обрабатывается.

Логический оператор or:

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

Логический оператор or также является оператором короткого замыкания.

Логический оператор not:

Возвращает True/False, противоположно значению. Например:

a = None
print(not a) // True

Можно использовать оператор дважды, например чтобы проверить правдивость выражия

print(not not a) = print(bool(a))

Для проверки, все же, лучше использовать функцию bool(), а не двойное отрицание.

Комбинация операторов и приоритет:

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

print(5 or “abc” and not 3) // 5 (т.к. оператор or находит правдивое значение, и функция замыкается)
print((5 or “abc”) and not 3) // False (т.к. сначала обрабатывается значение в скобках, затем not 3, и поскольку одно из значений ложно, and отдает False.

Условные инструкции if:

Условные и логические операторы чаще всего используются в условных инструкциях if.

Синтаксис состоит из таких ключевых слов, как:

if
elif
else

Инструкция if:

name = “Bogdan”
if name:
print(name) // Bogdan, поскольку name = True, если условие ложно, то блок кода не исполнится

Инструкция if else:

name = “”
if name:
print(name)
else:
print(“Name is empty”) // Name is empty, т.к. условие ложно.

Инструкция elif:

name = None
surname = “Stashchuk”
if name:
print(name)
elif surname:
print(surname)
else:
print(“Name and surname are empty”) // Stashchuk

Здесь если первое условие ложно, то будет проверяться второе условие, если оно тоже ложно, то выполняется третий блок кода. В данном примере второе условие истинно, поэтому мы видим фамилию.

Если подытожить то в конструкции if всегда выполняется только один блок кода.

if name:        =       if bool(name and surname) == True:

Форматирование строк:

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

Можно сделать так:

name = “Bogdan”
drink = “tea”
print(name + “ likes to drink “ + drink);

Но это неудобно, можно сделать иначе:

print(f”{name} likes to drink {drink})

Это называется интерполяция строк. (как шаблонные строки в JS).

Можно даже использовать методы, например {drink.upper()}

Интерполяция строк появилась в версии 3.6

Обработка ошибок с использованием try..except:

10 / 0
print(“Continue”) // ZeroDivisionError: division by zero.

Обернем в блок try..except:

try:
10 / 0
except:
pass

Инструкция if:

DivisionError as e:
print(e)
print("Continue...") 
// 
division by zero 
Continue…

Модули в Python:

Python Package Index (PyPi) - является репозиторием пакетов Python
pypi.org

pip install $package_name

С помощью import можно импортировать либо определенные переменные из модуля, либо весь модуль целиком.

import math
// math. - покажет все доступные методы модуля math
print(math.pi) // 3.141592653589793

Для того чтобы импортировать из своего модуля, нужно только указать в том файле куда импортируем import $module_name

После этого можно получить доступ к переменным через точечную запись $module_name.$method

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

Python 101

No Comments