# C:\Users\Artem\AppData\Local\Programs\Python\Python36\Lib\site-packages
py -3 -m pip install pyqt5 # установка PyQt
py -3 -m pip install pyqt5-tools
py -3 -m pip install --upgrade pip # обновление менеджера пакетов
py -3 -m pip install pyinstaller # установка пакета для создания exe
pip install flask
pip install flask-wtf
pip install flask-sqlalchemy
pip install flask-migrate
pip install flask-login
pip install flask-mail
pip install pyjwt
pip install flask-moment
pip install flask-babel
flask db migrate -m "add имя-колонки to имя-таблицы" # каждый раз, когда происходят изменения в моделях баз данных, необходимо выполнить миграцию базы данных
flask db upgrade # Затем необходимо применить миграцию к базе данных
py -3 -m PyQt5.uic.pyuic -x mygui.ui -o mygui.py # конвертация ui в py
py -3 -m PyQt5.uic.pyuic mygui.ui -o mygui.py
pyinstaller -F my_notepad.py # создание exe файла
pyinstaller -w -F -i "C:\Users\Artem\Documents\Artem_Python\prog\PyQt5\20180511\text-editor.ico" my_notepad.py # создание exe файла с иконкой
Виртуальное окружение
Это возможность иметь отдельную версию пакетов для каждого проекта и не пересекаться с системными настройками.
python -m venv имяпапки # создание виртуального окружения
env\Scripts\activate # активизация виртуального окружения
deactivate # отключение виртуального окружения
# - комментарий
'...' # строка
"..." # строка
'''...''' # строка
'''...
...''' # многострочная строка, либо многострочный комментарий
'abc' + 'def' == 'abcdef'
'abc' * 3 == 'abcabcabc'
'abc' == "abc"
'abc' < 'ac'
'abc' > 'ab'
len('abcdef') == 6 # длинна строки
'\n' # символ перервода строки
'\t' # символ табуляции
del ИмяПеременной # удаление переменной
/ - деление
// - деление нацело
% - остаток от деления
** - возведение в степень
+=, -=, *=, /=, //=, %=, **=
mod — это взятие остатка от деления,
pow — возведение в степень,
div — целочисленное деление.
round(1.2234567, 2) - округление до двух знаков после запятой
input('Введите данные') - ввод
input().split() розделяет введеную строку на 2 части, там где пробел. Данные input == "10 10" получаем а= 10 и b = 10
# a, b = input().split()
print() - вывод
end='' - вывод в тойже строке
sep=':' - разделитель между аргументами
id(object) - идентификатор объекта в памяти
ссылаются ли две переменные на один объект можно оператором is. 4 is 4 # возвращатся будет True или False
type(object) - определение типа
float() - тип числа с плавающей точкой
int() - тип числа целого
bool - логические
str - строковые
метод:
.upper() - в верхний регистр
.lower() - в нижний регистр
.title() - в Регистр Заголовка
.strip() - удалить все начальные и конечные пробелы
.trim() - удаление пробелов перед и после
.count('...') - сколько раз строка "..." встречается в нашей строке
.find('...') - первое вхождение (индекс), если не найдено то -1
но лучше: if 'TG' in s:...
.rfind('...') - последее вхождение
.replace('c', 'C') - заменяем одно на другое
.isdigit() - в строке только цифры
.isalpha() - в строке только буквы
.isalnum() - в строке только буквы и цифры
.isupper() - все ли заглавные буквы
.islower() - все ли строчные буквы
.istitle() - начинается с заглавной
.startswith('y') - начинается с 'y'
.split('.') - преобразует в список
.format() - подстановка параметров в строку
- s.upper().count('gt'.upper()))
- reversed(str) - переворачивает строку
Slicing:
dna = 'ATTCGGAGCT'
dna[1] --> 'T'
dna[1:4] --> 'TTC'
dna[:4] --> 'ATTC'
dna[4:] --> 'GGAGCT'
dna[-4:] --> 'AGCT'
dna[1:-1] --> 'TTCGGAGC'
dna[1:-1:2] --> 'TCGG'
dna[::-1] --> 'TCGAGGCTTA'
dna[1:] + dna[0] --> 'TTCGGAGCTA' # передвинули первый символ с начала в конец
#Подстановка параметров в строку
str1 = 'Ася %s Бабася' % 'Бегемот'
str2 = 'Ася %s %s Бабася' % ('Францибуль Адель', 'Бегемот')
ord('#') # 35; получить код символа
chr(35) # получение символа по коду
False(0), True(1)
or, and, not
<, <=, >, >=, ==, !=
10 <= a < 100
x1, x2, x3 = False, True, False
dir(...) - gолучения списка всех методов
help(...) - справка по методу
eval('234') #Вычислить выражение; преобразует строку в число
#--------------------------------------------------------------------------
ТИПЫ встроенного языка
Immutable (не изменяемые типы): Числа(int, float, complex), bool, tuple, str, frozenset
Mutable (изменяемые типы): list, dict, set
#--------------------------------------------------------------------------
Условное выражение
if not(False == True):
a = 1
elif (True):
a = 2
else:
a = 3
Тернарный оператор
a = 'Вася Пупкин' if name != 'Петя' else 'это не Вася'
#--------------------------------------------------------------------------
ЦИКЛЫ
while <логическое условие>:
действие1
действие2
for number in [0, 1, 2, 3, 4]:
print(number)
for number in range(5):
print(number)
Когда вы используете for в словаре, вы увидите, что он автоматически перебирает ключи.
a_dict = {"one":1, "two":2, "three":3}
for key in a_dict:
print(key)
a, b = (int(i) for i in input().split())
#ГЕНЕРАТОРЫ -->
ИмяПеременной=[ЧтоДобавляем_ОткудаБерем_Условие] # генератор списков
a = [int(i) for i in input().split()]
print(a) # [1, 2, 3, 4, 5, 6, 7]
b = [i for i in a if i%3==0] # копируем в новый список значения которые делятся на 3
z = [(x, y) for x in range(3) for y in range(3) if y >= x] # [(0, 0), (0, 1), (0, 2), (1, 1), (1, 2), (2, 2)]
m = 3 # строка
n = 5 # колонка
a = [[i]*n for i in range(m)]
print(a) # [[0, 0, 0, 0, 0], [1, 1, 1, 1, 1], [2, 2, 2, 2, 2]]
m = 3 # строка
n = 5 # колонка
a = [[j+(i*n)+1 for j in range(n)] for i in range(m)]
print(a) # [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15]]
#ГЕНЕРАТОРЫ <--
break - дострочное завершение цикла
continue - переход к следующей итерации цикла
Для цикла так же можно использовать else: срабатывает в том случае если не было вызвано break
range(10) - последовательность чисел от 0 до 9
range(2, 5) - от и до
range(2, 15, 4) - от и до, с шагом
new_list = list(map(int, ['1', '2', '3', '4', '5', '6', '7'])) # map применяет к каждому элементу списка переданную функцию
sorted(map(int, ['4', '2', '5', '1', '7', '6', '3'])) # сортирует список от меньшего к большему
#--------------------------------------------------------------------------
ФУНКЦИИ
def <имя функции>(<параметры>) -> <тип возвращаемого значения>: # функция с анотацией; при вызове процедуры можно явно указать имена передаваемых параметров max1(b=3,a=2)
тело функции
return <возвращаемое значение/пусто>
def empty_func(): # функции с пустым телом запрещены, потому в качестве тела приведенной функции используется «пустой оператор» pass.
pass
def printab(a, b):
print(a)
print(b)
printab(10, 20)
printab(a=10, b=20)
printab(10, b=20)
lst = [10, 20] # пример для списков/либо кортежей
printab(*lst) # = printab(lst[0], lst[1])
args = {'a': 10, 'b': 20} # пример для словарей
printab(**args) # = printab(key1=args[key1], key2=args[key2])
позиционные аргументы
def printab(a, b, *args): #все позиционные элементы которые не нашли себе место помещаются в кортеж args
print(a)
print(b)
for arg is args:
print(arg)
printab(10, 20, 30, 40, 50) # args==(30, 40, 50)
def printab(a, b, **kwargs): #все именованные элементы которые не участвовали в инициализации помещаются в словарь kwargs
print(a)
print(b)
for key is kwargs:
print(key, kwargs[key])
printab(10, 20, c=30, d=40, e=50) # kwargs=={'c':30, 'd':40, 'e':50}
def function_name( [ positional_args, # позиционные аргументы; имена и порядок: a
[ positional_args_with_default, # позиционные аргументы со значениями по умолчанию; имена и порядок: b=10, e=True
[ *pos_args_name, # все позиционные элементы которые в инициализации не участвовали; словарь;*args
[ keyword_only_args, # аргументы которые передаются только по имени, частичаще всего не используется
[ **kw_args_name]]]]]): # ;кортеж; **kwargs
def printab(a, b=10, *args, c=10, d, **kwargs):
print(a, b, c, d)
printab(15, d=15)
#--------------------------------------------------------------------------
ПРОСТРАНСТВА ИМЕН
#Объявление функций возможно внутри других функций, тогда вложенной функции доступны все пространства имен, с текущего до самого главного
# локальный --> global --> builtins
#Переменные бывают:
# 1. локальные
# 2. global a # искать/менять переменную в глобальном неймспейсе
# 3. nonlocal b # искать/менять переменную по пути от текущего пространства имен до неймспейса глобал; в текущем и глоболе не смотрим
#--------------------------------------------------------------------------
СПИСКИ
a = [] # Пустой список
a = list() # Пустой список
student = [] - это пустой список
- доступ осуществляется по индексу
- len(student) - длинна списка
- можно применять Slicing; student[0:3]
# a = [1, 2, 3, 4, 5]
# a[::2] = [0, 0, 0] # --> [0, 2, 0, 4, 0]
- операции:
сложение двух списков [] + []
умножение спискка на число [0, 1] * 4 == [0, 1, 0, 1, 0, 1, 0, 1]
- список является изменяемым
- student.append('...') или student += '...' - добавление нового элемента в конец списка
- student.pop() - по аналогии со стеком, из конца списка забирает последний элемент; есть не обязательный параметр, это индекс удаляемого элемента
- student.insert(1, '...') или student += '...' - добавление нового элемента на конкретную позицию со сдвигом остальных элементов
- student.extend(['Иванов', 'Петров']) - объединение двух списков
- student.sort() - сортировка списка
- student.count(1) - количество вхождений
- if 'qe' in student - проверка вхождения в список
- reversed(student) - переворачивает список
- sorted(student) - возвращает отсортированную версию списка
#--------------------------------------------------------------------------
КОРТЕЖИ
- в отличие от списка, не изменяемы; добавление и сортировка отсутствует
- можно применять Slicing; my_tuple[0:3]
my_tuple = () # создание пустого кортежа
my_tuple = tuple() # создание пустого кортежа
my_tuple = (1, 2, 3, 4, 5)
my_tuple = tuple([1, 2, 3]) # конвертация из списка в кортеж
my_list = list(my_tuple) # конвертация в списка из кортеж
#--------------------------------------------------------------------------
МНОЖЕСТВА - не упорядоченная уникальная колекция
s = set() # создание пустого множества
s = {'apple', 'orange', 'pear', 'apple'} #дублирующие значения убираются автоматически
'orange' in s # True, проверка на вхождение
s.add(element) # добавление
s.remove(element) # удаление, возникнет ошибка если такого элемента нет
s.descart(element) # удаление, без проверки на вхождение, ошибок не будет
s.clear() # удалить все элементы из множества
s.union({'potato'}) # объединение множества
s.difference({'apple', 'potato'}) # сообщает, какие объекты присутствуют только в первом множестве
s.intersection({'apple', 'potato'}) # сообщает, общие объекты
len(s) # число элементов во множестве
for x in s: # обход элементов
print(x)
# поиск уникальных значений в списке
checker = set()
ans = 0
for obj in objects:
if id(obj) not in checker:
checker.add(id(obj))
print(len(checker))
#--------------------------------------------------------------------------
СЛОВАРИ - позволяет хранить пары <ключ: значение>
- Изменяемы
- Элементы не имеют порядка
- Все ключи различны
- Ключи не изменяемы; ключем не может быть список...
d = dict # пустой словарь
d = {} # пустой словарь
d = {'a':256, 125:100}
d.setdefault('a', 256) # заполнение значением по умолчанию, если ключа еще не существует
d.get(key) # получение значения по ключу, если такой пары нет, то вернет None
d.get(key, 'Возвращаемое значение') # получение значения по ключу, если такой пары нет, то вернет 'Возвращаемое значение'
print(d['a'])
print(d[125])
'a' in d # True, проверка на вхождение
125 not in d # False, проверка на вхождение
d['key'] = value # добавление пары в словарь
d[key] # получение значения по ключу, если такой пары нет, то возникнет ошибка
d.get(key) # получение значения по ключу, если такой пары нет, то вернет None
del d[key] # удаление элемента из словаря
for key in d: # перебор ключей словаря
print(key, end=' ')
for key in d.keys(): # перебор ключей словаря
print(key, end=' ')
for value in d.values(): # перебор значений
print(value, end=' ')
for key, value in d.items(): # перебор пар: ключ значение
print(key, value, end=';')
#--------------------------------------------------------------------------
МОДУЛИ
Модуль содержит функции и данные в отдельном файле.
Объекты из модуля можно импортировать в другие модули.
Имя файла = имя модуля + .py
import my_module # Импорт модуля
#import my_module as my_mod # Импорт модуля
my_module.foo() # вызов функции из импортированного модуля
#Импорт from
from my_module import foo #Импорт конкретной функции
foo()
from my_module import * #Импорт всех функций из модуля
foo()
from my_module import foo as my_foo #Импорт конкретной функции и присвоение ей другого имени
my_foo()
# При подключении модуля происходит его выполнение
# и что бы избежать выполнение не желательных конструкций необходимо делать проверку на имя модуля
if __name__ == '__main__':
print(__name__)
import random # Импорт модуля случайных чисел
a = random.randint(0, 10) # получение случайного целого числа от 0 до 10
import time # Импорт модуля time
t = time.time()
time.asctime() # возвращает текущую дату и время в виде строки
time.sleep(5) # приостановить выполнение на 5 секунд
from datetime import datetime # импорт субмодуля из модуля
right_this_minute = datetime.today().minute
import sys
print(sys.stdin.readline()) # считывает строку
import stat # В этом модуле описаны константы, которые можно использовать как индексы к кортежам,
# применяемым функциями os.stat() и os.chmod() (а также некоторыми другими).
import logging # отвечает за логирование
logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
level=logging.INFO,
filename='bot.log')
logging.info('Bot started')
__all__ = ['BadName', 'greet'] # будут доступны только те имена которые импортируем с помощью звездочки
_GREETING = 10 # имена начинающиеся с нижнего подчеркивания не импортируются
#--------------------------------------------------------------------------
КЛАССЫ
#--
class Counter: # Пустой класс
pass
x = Counter() # Создание экземпляра класса Counter
x.count = 0 # Создание нового атрибута в конкретном экземпляре класса
x.count += 1
#--
class Counter:
def __init__(self, start=0): # Определение конструктора с аргументами; self - (обязательное поле) это уже какого то экземпляр (изначально пустой) нашего класса
self.count = start # Создание нового атрибута в конкретном экземпляре класса
def __repr__(self) -> str: # возвращает строковое представление объекта
return str(self.count)
x = Counter(10) # Создание экземпляра класса Counter с передачей аргументов в конструктор
print(x.count)
x.count += 1
#--
class Counter:
tegs = [] # атрибут класса, изменения действуют на все экземпляры
def __init__(self):
self.count = 0
def inc(self): # определение доступных методов
self.count += 1
def reset(self): # определение доступных методов
self.count = 0
x = Counter() # Создание экземпляра класса Counter с передачей аргументов в конструктор
x.inc() # вызов метода класса для экземпляра, через экземпляр; # это эквивалентно Counter.inc(x); происходит связывание метода класса с экземпляром
print(x.count)
Counter.inc(x)
print(x.count)
x.reset()
print(x.count)
#КЛАСС ДИСПЕТЧЕР КОНТЕКСТА и инструкция with
__enter__ - выполняет настройку
__exit__ - выполняет завершающий код
#--------------------------------------------------------------------------
НАСЛЕДОВАНИЕ
class MyList(list): # текщий класс наследуется от (Списков) класса list, и будет вызван конструктор класса list
def even_length(self): # метод определяет, является ли экземпляр класса четной длинны
return len(self) % 2 == 0
x = MyList()
print(x) # []
x.extend([1, 2, 3, 4, 5])
print(x) # [1, 2, 3, 4, 5]
print(x.even_length) # False
x.append(6)
print(x.even_length) # True
# наследование может быть и множественным, наследование осуществляется слева на право
print(x.mro()) # порядок разрешения методов, получает в каком порядке будут наследоваться методы
# Если наследование явно не указывается, то класс все равно наследуется, но уже от класса object
issubclass(MyList, list) # проверяет, является ли первый класс наследником второго
# любой класс является наследником самого себя
isinstance(x, list)# определяет, ведет ли себя объект как экземпляр какого либо класса
# тут мы спрашиваем, можем ли мы использовать экземпляр x в качестве обычного Списка
#---
class EvenLengthMixin:
def even_length(self):
return len(self) % 2 == 0
class MyList(list, EvenLengthMixin)
def pop(self): # тут мы определили метод как в одном из родительских классов
x = super(MyList, self).pop() # первый - класс родителей которых мы хотим проверить, второй - объект с которым мы хотим проассоциировать метод; мы пойдем искать метод pop в родителях класса MyList
print("Last value is", x)
return x
ml = MyList([1, 2, 4, 17])
z = ml.pop() # Last value is 17
print(z) # 17
print(ml) # [1, 2, 4]
#---
#--------------------------------------------------------------------------
ОШИБКИ И ИСКЛЮЧЕНИЯ
Ошибки:
1. Синтаксические
2. В процессе выполнения самого кода, т.е. исключения
Ошибки это тоже объект
1. Тип ошибки (IndexError, TypeError, ZeroDivisionError)
2. Текст описания ошибки
3. Состояние стека вызова на момент возникновения ошибки
# Ловим исключение
try:
x = [1, 2, 's']
x.sort()
except TypeError: # Типы ошибки которую хотим отловить. Это работает так:
# создается объект Ошибка и проверяется < isinstance(Ошибка, TypeError)==True > тогда заходим в этот блок
print('TypeError')
except (ZeroDivisionError, IndexError) as err: # Кортеж возможных исключений; < as err> объект Ошибка; Блоков может быть несколько, но сработает только первый подходящий
print('ZeroDivisionError or IndexError')
except: # Тип ошибки указывать не обязательно
print('ZeroDivisionError or IndexError')
else:
print('Все ОК') # вызывается если исключений не возникло
finally: # вызывается всегда
print('finally') # вызывается даже когда мы не смогли обработать ошибку
# Бросаем исключение
class BadName(Exception): # создаем собственный класс исключения; Собственные классы надо наследовать от Exception
pass
def greet(name):
if name[0].isupper():
return 'Hello, ' + name
else:
#raise ValueError(name + ' is inappropriate name')
raise BadName(name + ' is inappropriate name') # вызываем исключение с типом собственного класса
#--------------------------------------------------------------------------
ИТЕРАТОРЫ
# Для написания собственных итераторов нужно использовать классы
from random import random
class RandomIterator:
def __init__(self, k):
self.k = k
self.i = 0
def __iter__(self):
return self
def __next__(self):
if self.i < self.k:
self.i += 1
return random()
else:
raise StopIteration
# 1.
x = RandomIterator(3)
print(next(x))
print(next(x))
print(next(x))
# 2.
x = RandomIterator(3)
iter_x = iter(x)
while True:
try:
el_x = next(iter_x)
print(el_x)
except StopIteration:
break
#3.
for x in RandomIterator(3):
print(x)
#--------------------------------------------------------------------------
ГЕНЕРАТОРЫ
# это функции в которых вместо слова return мы используем слово yield
# вместо того что бы возвращать она будет генерировать новове значение
# генераторы это удобный синтаксис для написания итераторов
def random_generator(k): # функция генератор
for i in range(k):
yield random()
for x in random_generator(3):
print(x)
#--
z = ((x, y) for x in range(3) for y in range(3) if y >= x)
print(z) # <generator object <genexpr> at 0x00000000038B4D00>
for i in z:
print(i)
# (0, 0)
# (0, 1)
# (0, 2)
# (1, 1)
# (1, 2)
# (2, 2)