Users Artem AppData Local Programs Python Python36 Lib site-packages p

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
# 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)