Данный readme содержит шпаргалки по языку Python
Содержание
- Введение
- Комментарии
- Типы данных
- Интерполяция или f-строки
- Консольный ввод и вывод данных
- Приведение типов
- Математические операторы и функции
- Логические операторы
- Условные конструкции (ветвление)
- Циклы
- Строки
- Списки
- Кортежи
- Словари
- Множества
- Функции
- Работа с файлами
- Модуль ОС
- Модуль shutil
- Распространенные ошибки
Разрешение файла ".py"
Язык Python требователен к отступам (по умолчанию 4) не рекомендовано менять
Полезные плагины для VSCode:
- Python (Microsoft)
# - однострочный комментарий
""" """ - многострочный комментрий
- int - Натуральные числа
- float - вещественные числа
- bool - булев тип (True, False) - С большой буквы
- str - строка (в одинарных '' или двойных "" ковычках)
- list - список (упорядоченный конечный набор элементов)
- tuple - кортеж (неизменяемый список. Работает быстрее, защищает данные)
- dict - словарь (неупорядоченные коллекции произвольных объектов с доступом по ключу)
- set - множества
- Проверка типа данных
type()
Для присвоения пустого значения используется: None
Например num = None
Синтаксис: print(f"{a} - {b} - {c}")
Альтернатива:
print("{} - {} - {}".format(a,b,c))
input("Можно использовать запрос тут")
- получает сроку в качестве ответа
print()
- можно писать через запятую много переменных
Использование функции print() вместе с оператором ‘ * ‘
Для вывода элементов списка без скобок.
Пишем названия типа данных и в скобки вставляем значение для преобразования (может быть или значение или переменная):
a = '5'
b = int(a)
+ сложение
— вычитание
* умножение
/ деление
% остаток от деления
** возведение в степень
// целочисленное деление
round([arg], ['кол-во символов после запятой']) # Округление
ads(-5) # Модуль числа
== равно
!= не равно
> больше
< меньше
>= больше или равно
<= меньше или равно
and логическое И
or логическое ИЛИ
not логическое НЕ
Проверка работает до первого совпадения. Т.е. в преведенном примере ниже если a > b, то код в elif и в else не выполняется.
Не забываем про отступы и двоеточия!
if a > b:
print(a)
elif a == 0:
print(0)
else:
print(b)
While - данный цикл удобен при работе только со внешним флагом (внешней переменной).
Так же именно его используют когда нужен бесконечный цикл, но с бесконечными будь аккуратен, можно повесить среду разработки
flag = True
i = 2
while flag:
if n % i == 0: #если остаток при делении числа n на і равен 0
flag = False
print (i)
elif i › n // 2: # делить числа не может превышать введенное число, деленное на 2
print(n)
flag = False
i += 1
for - Более универсальный цикл. Отлично подходит когда мы знаем количество итерируемых элементов.
for i in 3, 6, -10, 345, 24:
#Действия для каждой итерации. В данном случае i принимает значения из списка
Часто используется с функцией range
range(['Старт=0'], ['Конец не включая'], ['Шаг=1'])
По логике строка - это аналог списка символов, а значит можно использовать такой же подход в работе с ними.
Не все возможности списков будут доступны в строках
Можно обращаться как к элементам массива `str[0]`
len(str) # Длина строки
print('ещё' in text) # Поиск "еще" в переменной text
print(text.lower()) # Преобразование к нижнему регистру
print(text.upper()) # Преобразование к верхнему регистру
print(text.replace("ещё', 'ЕЩЁ")) # Замена строки на другую
print("12, 21, 54, 34".split(", ")) # Преобразование в список
#####################################################
Срез
#####################################################
[:] - Срез. Может принимат от 1 до 3 аргументов, например:
text = "Hello"
print(text[:]) # Выведет все
print(text[:2]) # Выведет начиная с 0 индекса до 2 (не включая 2)
print(text[2:]) # Выведет начиная с 2 индекса до последнего
print(text[2:4]) # Выведет начиная с 2 индекса до 4 (не включая 4)
print(text[::6 ]) # Каждый 6 с 0 до последнего
Список - это упорядоченный конечный набор элементов. Давайте разбираться, по сути список - это тот же самый массив, в котором можно хранить элементы любых типов данных.
list_1 = [] # Пустой список
list_2 = list() # Пустой список
list_3 = [7, 9, 11, 13, 15, 171]
print(list_3) # [7, 9, 11, 13, 15, 171]
print(*list_3) # 7 9 11 13 15 171
print(len(list_1)) # Длина списка
list_3.append(9) # Добавление в конец списка нового элемента
list_3.pop() # Извлекает (возвращает) последний элемент списка
list_3.pop(['индекс удаляемого элемента']) # Извлекает (возвращает) выбранный по индексу элемент списка
list_3.insert(['Индекс позиции для вставки'], ['элемент для вставки']) # Добавление элементов в массив
list_3[2:] # Срез, работает так же как и в сроках (см. работа со строками)
List comprehension — это упрощенный подход к созданию списка, который задействует цикл for, а также инструкции if-else для определения того, что в итоге окажется в финальном списке.
list_1 = [exp for item in iterable] # Простая ситуация—список
list_1 = [exp for item in iterable (if conditional)] # Выборка по заданному условию
# Создать список чисел от 1 до 100
list_1 = []
for i in range(1, 101):
list_1.append(i) print(list_1) # [1, 2, 3,..., 100]
# Альтернатива:
list_1 = [i for i in range(1, 101)] # [1, 2, 3,..., 100]
# Добавить условие (только чётные числа)
list_1 = [i for i in range(1, 101) if i % 2 == 0] # [2, 4, 6,..., 100]
# Также можно умножать, делить, прибавлять, вычитать. Например, умножить значение на 2.
list_1 = [i * 2 for i in range(10) if i % 2 == 0] print(list_1) # [0, 4, 8, 12, 16]
Кортеж — это неизменяемый список.
В случае защиты каких-либо данных от изменений (намеренных или случайных). Кортеж занимает меньше места в памяти и работают быстрее, по сравнению со списками
cort_1 = () # Пустой кортеж
cort_2 = (1,2,3,4,5)
# Можно распаковать кортеж в независимые переменные:
t = tuple(['red', 'green', 'blue'])
red, green, blue = t
print('r:{} g:{} b:{}'.format(red, green, blue)) # r:red g:green b:blue
Словари — неупорядоченные коллекции произвольных объектов с доступом по ключу.
В других языках назвается объектом
В списках в качестве ключа используется индекс элемента. В словаре для определения элемента используется значение ключа (строка, число).
dictionary = {} # Пусто словарь
dictionary ={ # Запись в столбец делает код более читабельным.
'up': '↑',
'left': '←',
'down': '↓',
'right': '→'}
# Поиск ключа по значению, используя понимание списка
students = {
"Alice": "A",
"Bob": "B",
"Charlie": "C",
"Dave": "B",
"Eve": "A"
}
target_grade = "B"
keys = [key for key in students if students[key] == target_grade]
print("Keys with target grade:", keys)
# Поиск ключа по значению с помощью list.index()
students = {
"Alice": "A",
"Bob": "B",
"Charlie": "C",
"Dave": "B",
"Eve": "A"
}
target_grade = "B"
keys = list(students.keys())
index = list(students.values()).index(target_grade)
key = keys[index]
print("Key with target grade:", key)
# Поиск ключа по значению с помощью dict.item()
students = {
"Alice": "A",
"Bob": "B",
"Charlie": "C",
"Dave": "B",
"Eve": "A"
}
target_grade = "B"
keys = [key for key, value in students.items() if value == target_grade]
print("Keys with target grade:", keys)
# Поиск ключа по значению с помощью лямбда-выражения и filter()
students = {
"Alice": "A",
"Bob": "B",
"Charlie": "C",
"Dave": "B",
"Eve": "A"
}
target_grade = "B"
keys = list(filter(lambda key: students[key] == target_grade, students))
print("Keys with target grade:", keys)
# Поиск ключа по значению с помощью модуля re
import re
# Заданный входной словарь с оценками студентов
students = {
"Alice": "A",
"Bob": "B",
"Charlie": "A+",
"David": "B+",
"Eve": "C"
}
# Значение для поиска
value = "B"
# Создание регулярного выражения для точного совпадения значения
pattern = re.compile(r'\b' + re.escape(value) + r'\b')
# Поиск ключа по значению с использованием модуля re
key = next((k for k, v in students.items() if pattern.search(v)), None)
# Вывод результата
if key:
print("Ключ по значению", value, "найден:", key)
else:
print("Ключ по значению", value, "не найден")
Множества содержат в себе уникальные элементы, не обязательно упорядоченные.
Одно множество может содержать значения любых типов. Если у Вас есть два множества, Вы можете совершать над ними любые стандартные операции, например, объединение, пересечение и разность.
Пример работы:
colors = {'red', 'green', 'blue'}
print(colors) # {'red', 'green', 'blue'}
colors.add('red')
print(colors) # {'red', 'green', 'blue'}
colors.add('gray')
print(colors) # {'red', 'green', 'blue','gray'}
colors.remove('red')
print(colors) # {'green', 'blue','gray'}
colors.remove('red') # KeyError: 'red'
colors.discard('red') # ok
print(colors) # {'green', 'blue','gray'}
colors.clear() # { }
print(colors) # set()
Операции со множествами
a = {1, 2, 3, 5, 8}
b = {2, 5, 8, 13, 21}
c = a.copy()
u = a.union(b)
i = a.intersection(b)
dl = a.difference(b)
dr = b.difference(a) q=a.union(b).difference(a.intersection(b)) # {1, 21, 3, 13}
# Проверка на уникальность элементов множеств
my_set_1 = set([1, 2, 3, 4, 5])
my_set_2 = set([5, 6, 7, 8, 9])
my_set_1.intersection(my_set_2) # {5}
my_set_1 & my_set_2 # {5} делат то же самое только короче
Неизменяемое или замороженное множество(frozenset) — множество, с которым не будут работать методы удаления и добавления.
a = {1, 2, 3, 5, 8}
b = frozenset(a)
print(b) # frozenset({1, 2, 3, 5, 8})
Функция — это фрагмент программы, используемый многократно.
# def - служебное слово для создания функции
def add(x, y): # x, y - параметры
return x + y # return - возвращает значение указанное справа от return в место вызова функции
# Безымянные или Лямда функции
foo = lambda a,b: a+b
# Пример применения
def select(f, col):
return [f(x) for x in col]
def where(f, col):
return [x for x in col if f(x)]
data = [1, 2, 3, 5, 8, 15, 23, 38]
res = select(int, data)
print (res)
res = where (lambda x: x % 2 == 0, res)
print(res)
res = list(select(lambda x: (x, x**2), res))
print (res)
# Возможность передачи неограниченного количества аргументов
def concatenatio(*params):
res = ""
for item in params:
res += item
return res
# Встроенные функции в язук Python
filter(f, data) # проверяет соответствие каждого из перебераемых элементов data, если проверка - True, возвращает этот элемент.
map(f, data) # Примерняет функцию для каждого из элементов data, возвращает новое значение
zip([1,2,3], ['q', 'w', 'e'], [3,2,1]) # Возвращает список кортежей из соответствующих индексов [(1, 'q', 3), (2, 'w', 2), (3, 'e', 1)]
#################################################
# В примере выше стоит учитывать длину всех списков
# Если один из списков - короче, то и итоговый будет длиной
# соответствующей самому короткому списку
#################################################
# Функция enumerate0 позволяет пронумеровать набор данных.
users = ['userl', 'user2', 'user3']
data = list (enumerate (users))
print (data) # [(0, 'user1'), (1, 'user2'), (2, 'user3))]
sorted(iterable,key=None,reverse=False) #Сортировка строк осуществляется по ASCII-значениям
# iterable: строка, список, кортеж, множество, словарь
# key (необязательный параметр): если указать ключ, то сортировка будет выполнена по функции этого ключа.
# reverse (необязательный параметр): по умолчанию сортировка выполняется по возрастанию. Если указать reverse=True, то можно отсортировать по убыванию.
Зачастую функции описываются в одном файле, а используются в другом. Для этого необходимо:
- Создать файл с функциями
- Импортировать
- обратиться к названию файла и через "." обратиться к функции:
import modul
modul.some_foo()
# так же можно переименовать длинное название например так:
import modul as m
m.some_foo()
# или импортировать саму функцию так:
from modul import some_foo
# или импортировать все функции из файла так:
from modul import *
Alias (псевдоним) — альтернативное имя, которое даётся функции при её импорте из файла (смотри пример выше во 2м импорте)
Рекурсия — это функция, вызывающая сама себя.
Пример применения: Необходимо вывести n - первых членов последовательности Фибоначчи.
def fib(n):
if n in [1, 2]:
return 1
return fib(n - 1) + fib(n - 2)
Для работы с файлами необходимо использовать:
data = open('file_name.txt', 'a')
Варианты режима (мод):
a
- открыть для добавления данных
- Можно дописать в уже существующий файл
- Если такого файла нет - создаст и запишет
r
- открыть для чтения
- позволяет прочитать данные из файла
- Если такого файла нет - выдаст ошибку
w
- открытие для записи данных
- Позволяет записывать данные и создавать файл если его не существует.
- если файл существовал все данные будут перезаписаны
w+
- открыть для записи и чтения
- Позволяет открыть для записи и чтения из файла
- Если файла не существует - создаст
r+
- Позволяет открыть файл для чтения и записывать в него
- Позволяет открыть файл для чтения и дописать в него
- Если файла не существует - выдаст ошибку
Чтобы добавить запись обращаемся к переменной сохраненной в data:
colors = ['red', 'green', 'yellow']
data = open('file_name.txt', 'a') # Открытие файла для добавления данных
data.writelines(colors) # Добавляем запись
data.close() # После работы с файлом не забудь закрыть его чтобы не забыть лучше использовать такой подход:
with open('file_name.txt', 'w') as data:
data.write('line 1\n')
data.write('line 2\n')
# Для чтения:
path = 'file.txt'
data = open( 'file.txt', 'r')
for line in data:
print(line)
data.close()
Модуль os
предоставляет множество функций для работы с операционной системой, причем их поведение, как правило, не зависит от ОС, поэтому программы остаются переносимыми.
Для того, чтобы начать работать с данным модулем необходимо его импортировать в свою программу:
import os
os.chdir('C:/Users/79190/PycharmProjects/GB') # смена текущей директории.
print(os.getcwd()) # текущая рабочая директория 'C:\Users\79190\PycharmProjects\webproject'
print(os.path.basename('C:/Users/79190/PycharmProjects/webproject/main.py')) # базовое имя пути 'main.py'
print(os.path.abspath('main.py')) # возвращает нормализованный абсолютный путь. 'C:/Users/79190/PycharmProjects/webproject/main.py'
Модуль shutil содержит набор функций высокого уровня для обработки файлов, групп файлов, и папок. В частности, доступные здесь функции позволяют копировать, перемещать и удалять файлы и папки. Часто используется вместе с модулем os. Для того, чтобы начать работать с данным модулем необходимо его импортировать в свою программу:
import shutil
shutil.copyfile(src, dst) # копирует содержимое (но не метаданные) файла src в файл dst.
shutil.copy(src, dst) # копирует содержимое файла src в файл или папку dst.
shutil.rmtree(path) # Удаляет текущую директорию и все поддиректории; path должен указывать на директорию, а не на символическую ссылку.
Тут указаны самые распространенные ошибки при написании кода:
- Отсутствие ":" во всех языковых конструкциях (if, while, for и т.д.)
- Отсутствие отступов во вложенных конструкциях
- Сложение строк и чисел
- Деление на 0
- Отсутсвие вводимого ключа или переменной
- Преобразование типов при невозможности (Например: int("Hello"))