Гайд от Матвея 🥸

Hello, world!

print("Добрый вечер")

Отступы

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

x = 1
if x == 1:
    # 1 отступ
    print("x это 1")

Переменные и типы

Числа

В Пайтоне два типа чисел - целые и вещественные.

myint = 7 # Целое число
myfloat = 7.0 # Вещественное число
print(myint, myfloat)

Строки

Записываются в одинарных или двойных кавычках.

mystring = 'hello'
print(mystring)
mystring = "hello"
print(mystring)

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

mystring = "Don't worry about apostrophes"
print(mystring)

Правда/Ложь

a = False
b = True

Важно, что True/False записывается с большой буквы.

Конкатенация строк

Конкатенация - сложение строк.

one = 1 # число
two = 2 # число
three = one + two # число
print(three) # 3 - число
hello = "hello"
world = "world"
helloworld = hello + world # через плюс соединяем 2 строки
print(helloworld) # helloworld
print(hello, world) # hello world

“+” не добавляет пробел между строками, “ , ” - добавляет
Переменные могут инициализироваться через запятую или знак равенства.

a, b = 3, 4
c = d = 0
print(a, b) # 3, 4
print(c, d) # 0, 0

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

one = 1
two = 2
hello = "hello"
# число + число + строка
print(one + two + hello) # вернет ошибку

Списки (массивы)

Списки могут содержать любые элементы любых типов.
Списки индексируются с 0. Первый элемент имеет индекс 0. Чтобы взять элемент с конца списка используют -1, -2, -3… в качестве индексов.

mylist = [5, 6, 7, 8]
print(mylist[0]) # 5
print(mylist[-1], mylist[-2]) # 8, 7

Основные методы массивов

mylist.append(x) # добавляет x в конец списка
mylist.remove(x) # удаляет элемент x из списка
mylist.pop(-1) # удаляет элемент списка по индексу. pop(-1) удалит последний элемент
mylist.index(x) # вернет индекс x в списке mylist
mylist.reverse() # НИЧЕГО НЕ ВОЗВРАЩАЕТ. Инвертирует порядок элементов
mylist.sort() # НИЧЕГО НЕ ВОЗВРАЩАЕТ. Сортирует список
mylist.count(x) # вернет колво x в списке mylist

Базовые операторы

• + - сложение
• - - вычитание
• * - умножение
• / - деление
• // - целочисленное деление
• % - деление с остатком
• ** - возведение в степень

x = 2
x = x + 20
# Строку сверху можно заменить на строку снизу
x += 20

По аналогии возможны сокращения -=, *=, /=, %=, //=

print(2**3) # 8
print(17 % 10) # 7
print(12 / 10) # 1.2
print(12 // 10) # 1

Операторы в строках и списках

a, b = [1, 2], [3, 4]
print(a + b) # [1, 2, 3, 4]
c, d = 'start', 'stop'
print(c + ' ' + d) # start stop

Умножение списков работает так:

print([1, 2, 3] * 2) # [1, 2, 3, 1, 2, 3]

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

В Пайтоне форматирование строк заимствовано у С:

• %s выведет строку или любой объект в представлении строк (например, число)
• %d выведет число
• %f выведет вещественное число
• %.<какоеточисло>f укажет, сколько знаков после запятой вывести
  После строки, которую нужно форматировать, указываются переменные.

print('%s %d лет', 'Мише', 18) # Мише 18 лет

Базовые методы со строками

len(string) # вернет длину строки string. Да, это не метод, а функция
string.split(x) # разделит string через x и вернет в виде списка
string.index(x) # вернет индекс x в строке string
string.count(x) # вернет колво x в строке string
string.upper() # Вернет string, где все буквы в верхнем регистре
string.lower() # Вернет string, где все буквы в нижнем регистре
string.startswith(x) # Вернет True/False начинается ли строка с x
string.endswith(x) # Вернет True/False заканчивается ли строка на x
string.replace('hello', 'hellow') # заменит в string строку hello на строку hellow

Методы проверки строк

isdigit()

Метод isdigit() проверяет, состоит ли строка только из цифр. Он возвращает True, если все символы строки являются цифрами, и False в противном случае.

x = "12345"
y = "12.34"
print(x.isdigit())  # True
print(y.isdigit())  # False

isalpha()

Метод isalpha() проверяет, состоит ли строка только из букв. Он возвращает True, если все символы строки являются буквами, и False в противном случае.

word1 = "Hello"
word2 = "123"
print(word1.isalpha())  # True
print(word2.isalpha())  # False

isalnum()

Метод isalnum() проверяет, состоит ли строка только из букв и цифр. Он возвращает True, если все символы строки являются буквами или цифрами, и False в противном случае.

text1 = "Hello123"
text2 = "Hello, World!"
print(text1.isalnum())  # True
print(text2.isalnum())  # False

isspace()

Метод isspace() проверяет, состоит ли строка только из пробелов. Он возвращает True, если все символы строки являются “пробельными” символами (пробелы, табуляции и переводы строк), и False в противном случае.

space1 = "   "
space2 = "Hello"
print(space1.isspace())  # True
print(space2.isspace())  # False

Срезы

Срез строк и списков указывается в виде variable[start:stop:step].

string = "Hello world!"
# Срезаем начиная с индекса 3 до индекса 7
print(string[3:7]) # lo w
string = "Hello world!"
# Добавляем шаг 2
print(string[3:7:2]) # l
string = "Hello world!"
# Добавляем шаг 1. Ничего не изменяется
print(string[3:7:1]) # lo w

Кстати, чтобы инвертировать строку или список, можно использовать срез с шагом -1.

s = "Hello"[::-1]
print(s) # olleH

Условия

>, <, ==, <=, >= - базовые операторы сравнения.

x = 10
print(x > 10) # False
print(x <= 10) # True
print(7 < x) # True
print(x == 10) # True

Общий вид условий

if statement1: # если выполняется statement1
	pass
# elif = else if = иначе, если
elif statement2: # если statement1 не выполняется, если выполняется statement2
	pass
else: # иначе
	pass

Например:

name = 'Matvey'
if name == 'Matvey':
	print('Привет, Матвей. Классный гайд!')
else:
	print('Ты кто вообще?')

x = 15
if x < 20:
	y = 16
else:
	y = 0

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

y = 16 if x < 20 else 0 # y = 16, если x < 20, иначе y = 0

Операторы in и not

in проверяет, находится ли объект где-то.

even = [2, 4, 6]
string = 'abc'
print(2 in even) # True
print(3 in even) # False
print('a' in string, 'd' in string) # True, False

not отрицает выражение после себя.

print(not False) # True
a = [1, 2]
print(not 3 in a) # True

Циклы

For

Для итерации используется цикл for. Цикл объявляется с указанием переменнной при цикле. Она может быть любой, только не называйте переменные в своих работах по-дебильному.

a = [1, 2, 3]
for digit in a:
	print(digit)
# 1
# 2
# 3

В примере выше digit является 1, потом 2, а потом 3.

range()

Используется для указания числовой последовательности в качестве итерируемого объекта в цикле. Указывается в формате range(start, stop, step). Если start не указан, отрезок начнется с 0.
Важно, что значение stop не входит в диапазон чисел.

for x in range(5):
	print(x)
'''
0
1
2
3
4
'''

# Выводится каждый второй элемент из диапазона 0-4
for x in range(0, 5, 2):
	print(x)
'''
0
2
4
'''

While

Цикл while будет выполнятся, пока выполняется условие после него. Так как while не имеет никаких переменных при себе, в отличии от for, поэтому необходимо изменять переменную вручную, чтобы цикл не выполнялся бесконечно.

x = 5
while x > 0: # пока x > 0
	print(x)
	x -= 1 # уменьшаем x на 1
'''
5
4
3
2
1
'''

Выражение break и continue

break используется для выхода из цикл, в то время как continue - чтобы пропустить текущий блок кода и перескочить на следующую итерацию for или while.

count = 0
while True:
    print(count)
    count += 1
    if count >= 5:
        break
# Выводит только нечетные числа - 1, 3, 5, 7, 9
for x in range(10):
    # Проверяет если x - четное
    if x % 2 == 0:
        continue
    print(x)

Else в for

В отличие от C, C++,… в Пайтоне есть возможно использовать else, когда цикл завершается "естественным" образом, то есть когда не было прерываний с помощью оператора **break**.

for i in range(1, 5):
    if(i % 5==0):
        break
    print(i)
else:
    print("Это собщение показывает, что цикл не вылетел ни разу. Чисел, кратных 5, на промежутке 1-4 не нашлось")

Функции

Функции позволяют заменить постоянный копипаст шаблонного кода на красивые выражения, значения которых зависят от переданных аргументов.
Функция принимает параметры (аргументы), которые доступны только в пределах этой функции. Параметры могут и не указываться.
Для объявления функции используют ключевое слово def (define, definition)

def hello(name):
	print('Привет, ' + name)
hello('Матвей') # Привет, Матвей

Если использовать name вне функции, то появится ошибка.
Функции могут возвращать значения тем, кто их вызвал. Для этого указывается return . Тогда можно присвоить какой-нибудь переменной значение, которое вернула функция.

def sumNumbers(a, b):
	return a + b
x = sumNumbers(1, 2) # 3

Если функция ничего не возвращает, то переменная, к которой приравнивается функция, будет равна None.

Аргументы (параметры)

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

Это аргументы, которые передаются функции в том порядке, в котором они определены.

def example_function(arg1, arg2, arg3):
    # код функции

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

Аргументы, которые передаются с явным указанием имени параметра функции

def example_function(arg1, arg2, arg3):
    # код функции

Вызов функции:

example_function(arg1=1, arg2='two', arg3=3.0)

Аргументы По умолчанию

Значения, которые присваиваются параметрам функции, если эти значения не переданы при вызове.

def example_function(arg1, arg2='default_value', arg3=42):
    # код функции

В этом примере **arg2** по умолчанию равен **'default_value'**, а **arg3** равен **42**. Если эти аргументы не переданы при вызове функции, будут использованы соответствующие значения по умолчанию.

Просто важные знания

int('1') # преобразовывает строку в число
str(1) # преобразовывает число в строку
float(1) # преобразовывает целое число в вещественное
list('123') # преобразует строку в список, отделяя каждый элемент
x.join(listofstrings) # соединит строчные элементы listofstrings в одну строку, используя разделитель x
'.'.join(['1', '2', '3']) # 1.2.3

set()

set - список с фигурными скобками, вместо квадратных, в котором все элементы уникальны. Если список был отсортирован, элементы в сете отсортированы не будут.

myset.add(x) # Добавляет x в myset или не добавляет, если x там уже есть
myset1.union(myset2) # Объединит myset1 и myset2 в один, удаляя все повторения и вернет новый сет
set(x) # Преобразует x (строку или список) в сет

print(set([1, 1, 2, 3])) # {1, 2, 3}
x = set([1, 2, 3])
y = set([3, 5, 6])
x.add(3)
x.add(4)
print(x) # {1, 2, 3, 4}
print(x.union(y)) # {1, 2, 3, 4, 5, 6}

map()

map(func, iterator) используется для применения func ко всем элементам iterator.

x = list(map(str, [1, 2, 3])) # ['1', '2', '3']

map() по умолчанию возвращает, ни строку, ни список, а специальный тип map_object, поэтому следует использовать функцию l``**ist()**, которая конвертирует результат в список.
Мы также можем указать собственную функцию в качестве параметра, только она обязательно должна что-то возвращать:

def f(a):
	return a + 2
print(list(map(f, [1, 2, 3]))) # [3, 4, 5]

Особые правила сортировки

Иногда отсортировать массив или что-нибудь еще только по возрастанию недостаточно, поэтому нужно задавать свои правила сортировки. В этом нам поможет параметр key, у метода .sort или функции sorted().
Ключ должен представлять собой функцию, по логике которой будет производиться сортировка. Например, отсортируем массив строк по количеству повторений в каждой строке цифры 5:

array = ['5', '110', '655', '5175', '1555']
def sort_function(s):
	return s.count('5')
print(sorted(array, key=sort_function)) # ['110', '5', '655', '5175', '1555']

Что здесь происходит? Задаем массив, объявляем функцию. Она принимает строку s и возвращает количество повторений цифры 5 в ней. В функцию sorted() передаем массив и ключ сортировки. Важно, что sort_function() объявлена до того, как она начинает применяться.
Таким образом sort_function() будет применена ко всем элементам массива и для каждой строки вернет какое-то число. Потом все эти полученные числа отсортируются по возрастанию и мы получим массив с исходными элементами, отсортированный по пятеркам в строках.
P.S. Вместо sort_function() можно было использовать лямбда-функцию, но о них мы поговорим позже.

F-строки

f-строки (formatted string literals) - это специальный синтаксис для форматирования строк. Они были введены в Python 3.6 и предоставляют удобный и читаемый способ вставки значений переменных в строки.
f-строки начинаются с префикса 'f' перед открывающей кавычкой строки. Значения переменных вставляются прямо в строку, заключая имя переменной в фигурные скобки **{}**.

name = "Матвей"
age = 19
f_string = f"Меня зовут {name} и мне {age} лет"

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

x = 5
squared = f"Квадрат {x} равен {x**2}"

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

pi = 3.14159265359
formatted_pi = f"Число пи: {pi:.2f}"

Показываю прикол

print(f"{'Hello':.^15}") # .....Hello.....

Что здесь написано? f-строка содержит в себе слово Hello, суммарная длина строки равна 15, а недостающие символы заменены точками. То есть 5 точек + 5 букв + 5 точек будут в консоли. Текст выравнивается по центру, на что указывает ^.
Чтобы точки заменить на другой символ, его нужно указать после двоеточия. Также есть другие варианты выравнивания: > - по левому краю, < - по правому.
Все освоили? Идем дальше!