Высокоуровневый язык программирования общего назначения Python ориентирован на повышение производительности разработчика и читаемости кода; синтаксис ядра минималистичен; поддерживает структурное, обобщенное, объектно-ориентированное, функциональное и аспектно-ориентированное программирование. Основные архитектурные черты — динамическая типизация, автоматическое управление памятью, полная интроспекция, механизм обработки исключений, поддержка многопоточных вычислений, высокоуровневые структуры данных. Поддерживается разбиение программ на модули, которые, в свою очередь, могут объединяться в пакеты.

Настоящая публикация содержит конспект изучения языка Python разработчиком привыкшим к классическим языкам (Pascal, C++, Java). Изложение в публикации будет простым, наглядным и слегка вульгарным, как и сама идеология Python.

Официальный сайт //www.python.org
- Python 3.9.0 documentation //docs.python.org
  - Built-in Constants …/3/library/constants.html
  - Built-in Functions …/3/library/functions.html
  - Built-in Types …/3/library/stdtypes.html
и другие источники в конце публикации

Версии языка Python

Python 1.0 был выпущен в январе 1994 года, в декабре 2008 года был выпущен Python 3.0, актуальная версия 3.9 выпущена 5 октября 2020 года (является последней на момент публикации).

Новые интересные функции в Python 3.8 //webdevblog.ru

Основные примитивы

Присваивание в Python на первый взгляд не отличается от классических языков:

one = 1                       # оператор присваивания
half = one / 2                # конец строки завершает синтаксическую конструкцию
one = 3 // 2; half = 3 % 2    # некоторые синтаксические конструкции можно записать в одной строке, разделив точкой с запятой
d = (one                      # синтаксическая конструкция может использовать несколько строк,
     + half * 2               # если обрамлена скобками (), [] или {}
     + c)

one = 1 # оператор присваивания

half = one / 2 # конец строки завершает синтаксическую конструкцию

one = 3 // 2; half = 3 % 2 # некоторые синтаксические конструкции можно записать в одной строке, разделив точкой с запятой

d = (one # синтаксическая конструкция может использовать несколько строк,

+ half * 2 # если обрамлена скобками (), [] или {}

+ c)

Однако важно понимать, что любая переменная Python является объектом (физический идентификатор объекта можно получить функцией id(…)). Присваивание по сути является ассоциированием имени с объектом-значением, что принципиально отличается от классических языков, в которых присваивание является копированием значения в идентифицируемую область памяти. Детальней это принципиальное отличие описано в публикации «Указатели в Python: в чём суть?». Пример:

one = 1  # объект "простого" типа int равный 1 ассоциирован с именем 'one'
id(one)  # 1935699044688 - идентификатор объекта с именем 'one'
one += 1 # инкрементирование объекта создает новый объект с новым идентификатором
id(one)  # 1935699044720 
one += 1 # новый объект может получить идентификатор ранее утилизированного объекта
id(one)  # 1935699044688

one = 1 # объект "простого" типа int равный 1 ассоциирован с именем 'one'

id(one) # 1935699044688 - идентификатор объекта с именем 'one'

one += 1 # инкрементирование объекта создает новый объект с новым идентификатором

id(one) # 1935699044720

one += 1 # новый объект может получить идентификатор ранее утилизированного объекта

id(one) # 1935699044688

Python позволяет выполнить множественное присваивание, в котором сначала вычисляются все выражения правой части, а затем ассоциируются (присваиваются) с именами в левой части:

a, b = b, a                  # выражение перестановки значений a и b, которое является предметом концептуальной гордости Python
prev, next = next, prev+next # выражение для цикла вычисления ряда Фибоначи

1 2	a, b = b, a # выражение перестановки значений a и b, которое является предметом концептуальной гордости Python prev, next = next, prev+next # выражение для цикла вычисления ряда Фибоначи

Версия Python 3.8 добавила возможность walrus, которая позволяет выполнить присваивание внутри выражения. Аналогичная возможность изначально была в C++, и хорошо что Python это заметил через 26 лет:

# цикл обработки команд до получения "quit"
while true: 
  cmd = input("cmd: ")
  if cmd != "quit":
    docmd(cmd)
  else:
    break

# этот же цикл с использованием walrus
while (cmd := input("cmd: ")) != "quit":
  docmd(cmd)

# цикл обработки команд до получения "quit"

while true:

cmd = input("cmd: ")

if cmd != "quit":

docmd(cmd)

else:

break

# этот же цикл с использованием walrus

while (cmd := input("cmd: ")) != "quit":

docmd(cmd)

///

Число <class ‘int’>, <class ‘float’>

Числа в Python бывают целыми и «плавающими», для них определены операции +, -, *, ** (степень), /, // (целочисленное деление), % (остаток от деления). К плавающему значению приводит любое деление, а в остальных операциях, только если хоть один из операндов был плавающим. Самым удивительным результатом является остаток целочисленного деления плавающего:

print(8*2, 8*4/2)          # 16   16.0                # тип результата умножения зависит от типов множителей
print(8**2, 8**2.0)        # 64   64.0                # тип результата степени зависит от обоих типов
print(8**25)               # 37778931862957161709568  # целочисленный результат степени может быть очень-очень большим
print(-8**2, (-8)**2)      # -64  64                  # приоритет степени выше унарного минуса и других арифметических операций
print(8/4, 8/3)            #  2.0  2.6666666666666665 # результат деления всегда плавающий
print(8//3, 8%3)           #  2    2                  # целочисленное деление целого и его целочисленный остаток
print(-8//3, -8%3)         # -3    1                  # целочисленное деление и остаток для отрицательного целого
print(8.2//3, 8.2%3)       #  2.0  2.1999999999999993 # целочисленное деление плавающего остается плавающим, а остаток можно объяснить с большим трудом!
print(-8.2//3, -8.2%3)     # -3.0  0.8000000000000007 # целочисленное деление отрицательного плавающего и удивительный остаток
print(int(8/3), int(-8/3)) #  2   -2                  # приведение к целому положительного и отрицательного плавающего функцией int()

print(8*2, 8*4/2) # 16 16.0 # тип результата умножения зависит от типов множителей

print(8**2, 8**2.0) # 64 64.0 # тип результата степени зависит от обоих типов

print(8**25) # 37778931862957161709568 # целочисленный результат степени может быть очень-очень большим

print(-8**2, (-8)**2) # -64 64 # приоритет степени выше унарного минуса и других арифметических операций

print(8/4, 8/3) # 2.0 2.6666666666666665 # результат деления всегда плавающий

print(8//3, 8%3) # 2 2 # целочисленное деление целого и его целочисленный остаток

print(-8//3, -8%3) # -3 1 # целочисленное деление и остаток для отрицательного целого

print(8.2//3, 8.2%3) # 2.0 2.1999999999999993 # целочисленное деление плавающего остается плавающим, а остаток можно объяснить с большим трудом!

print(-8.2//3, -8.2%3) # -3.0 0.8000000000000007 # целочисленное деление отрицательного плавающего и удивительный остаток

print(int(8/3), int(-8/3)) # 2 -2 # приведение к целому положительного и отрицательного плавающего функцией int()

Строка <class ‘str’>

Строки в Python используют кодировку UTF, .!!!

'abc' == "abc"             # одиночные и двойные кавычки синтаксически эквивалентны
'a"b"c' == "a\"b\"c"       # включение двойных кавычек в строковую константу 
"a'b'c" == 'a\'b\'c'       # включение одиночных кавычек в строковую константу
"c:\bool" == "cool"        # обратный слеш служит признаком одного из служебных символов (в примере: "\b" - забой)
'c:\\bool' == r'c:\bool'   # включение слеш в строковую константу и подавление экранирования
('multy '                  # определение длинной строковой константы несколькими частями в несколько строк
 'parts '
 'of string')
'''multy                   # тройные кавычки позволяют определить многострочную константу в естественном виде
lines''' == 'multy\nlines' 
b'abc' != 'abc'            # строка байтов может быть определена литерами, но строкой не является

'abc' == "abc" # одиночные и двойные кавычки синтаксически эквивалентны

'a"b"c' == "a\"b\"c" # включение двойных кавычек в строковую константу

"a'b'c" == 'a\'b\'c' # включение одиночных кавычек в строковую константу

"c:\bool" == "cool" # обратный слеш служит признаком одного из служебных символов (в примере: "\b" - забой)

'c:\\bool' == r'c:\bool' # включение слеш в строковую константу и подавление экранирования

('multy ' # определение длинной строковой константы несколькими частями в несколько строк

'parts '

'of string')

'''multy # тройные кавычки позволяют определить многострочную константу в естественном виде

lines''' == 'multy\nlines'

b'abc' != 'abc' # строка байтов может быть определена литерами, но строкой не является

Строку не завершает какой-либо, как в С++. Полную длину строки возвращает функция len(…):

print(len('abc\n\0')) # 5

1	print(len('abc\n\0')) # 5

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

'bla'+'bla' == 'bla' * 2 # конкатенация и умножение строк

1	'bla'+'bla' == 'bla' * 2 # конкатенация и умножение строк

Строка являются также python-списком (будет описан ниже), который предусматривает итератор, перечисляющий все символы строки.

for char in 'ABC':      # итератор списка строки
  print(char, end='-')  # A-B-C-

1 2	for char in 'ABC': # итератор списка строки print(char, end='-') # A-B-C-

///

Составные типы данных

В Python предусмотрено несколько составных (compound) типов данных, используемых для группировки других значений, которые привычно называют коллекциями.

Список <class ‘list’>

Список в Python аналогичен классическому массиву и является объектом упорядоченной коллекции значений, которые заключены в квадратные скобки и разделены между собой запятыми:

a = []                              # пустой список
b = [0, 1, [2, 3]]                  # список включающий другой список
c = list('ABC')                     # ['A', 'B', 'C'] список из литер строки
d = list(range(5))                  # [0, 1, 2, 3, 4] список диапазона значений
e = [x*3 for x in d]                # [0, 3, 6, 9, 12] генератор на основе другого списка d
f = [x**2 for x in e if x % 2 == 0] # [0, 36, 144] генератор на основе другого списка с условием

a = [] # пустой список

b = [0, 1, [2, 3]] # список включающий другой список

c = list('ABC') # ['A', 'B', 'C'] список из литер строки

d = list(range(5)) # [0, 1, 2, 3, 4] список диапазона значений

e = [x*3 for x in d] # [0, 3, 6, 9, 12] генератор на основе другого списка d

f = [x**2 for x in e if x % 2 == 0] # [0, 36, 144] генератор на основе другого списка с условием

Срез (slice?)

Срез списка — это новый список <class ‘list’>, содержащий подмножество элементов коллекции исходного списка. Способ задания параметров среза очень напоминает цикл for из C++, в котором задается начальное значение индекса, значение индекса прекращающего цикл, шаг приращения индекса:

a = list(range(8)) # [0, 1, 2, 3, 4, 5, 6, 7] 
print(a[1])        # 1                        # это не срез, а значение по индексу 1
print(a[1:])       # [1, 2, 3, 4, 5, 6]       # срез от индекса 1 до конца
print(a[-7:])      # [1, 2, 3, 4, 5, 6]       # отрицательный индекс отсчитывается в обратном направлении от "запредела" списка
print(a[1:5])      # [1, 2, 3, 4]             # срез от индекса 1 до индекса 5 /"до" в исключительном смысле
print(a[:5:2])     # [0, 2, 4]                # срез от начала до индекса 5 с шагом 2
print(a[1:5:2])    # [1, 3]                   # срез использует от, до и шаг
print(a[-1::-1])   # [7, 6, 5, 4, 3, 2, 1, 0] # срез от конца в обратном порядке /похож на метод a.reverse()

a = list(range(8)) # [0, 1, 2, 3, 4, 5, 6, 7]

print(a[1]) # 1 # это не срез, а значение по индексу 1

print(a[1:]) # [1, 2, 3, 4, 5, 6] # срез от индекса 1 до конца

print(a[-7:]) # [1, 2, 3, 4, 5, 6] # отрицательный индекс отсчитывается в обратном направлении от "запредела" списка

print(a[1:5]) # [1, 2, 3, 4] # срез от индекса 1 до индекса 5 /"до" в исключительном смысле

print(a[:5:2]) # [0, 2, 4] # срез от начала до индекса 5 с шагом 2

print(a[1:5:2]) # [1, 3] # срез использует от, до и шаг

print(a[-1::-1]) # [7, 6, 5, 4, 3, 2, 1, 0] # срез от конца в обратном порядке /похож на метод a.reverse()

Кортеж <class ‘tuple’>

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

а = 0, 1, 2, 3, 4, 5, 6, 7 # (0, 1, 2, 3, 4, 5, 6, 7) # в определении кортежа скобки не обязательны
b = (1, )                                             # определение кортежа из одного элемента имеет нюанс, поскольку просто (1) является числом
print(a[1])                # 1                        # это не срез, а значение по индексу 1
print(a[1:])               # (1, 2, 3, 4, 5, 6)       # срез от индекса 1 до конца
print(a[-7:])              # (1, 2, 3, 4, 5, 6)       # отрицательный индекс отсчитывается в обратном направлении от "запредела" кортежа
print(a[1:5])              # (1, 2, 3, 4)             # срез от индекса 1 до индекса 5 /"до" в исключительном смысле
print(a[:5:2])             # (0, 2, 4)                # срез от начала до индекса 5 с шагом 2
print(a[1:5:2])            # (1, 3)                   # срез использует от, до и шаг
print(a[-1::-1])           # (7, 6, 5, 4, 3, 2, 1, 0) # срез от конца в обратном порядке

а = 0, 1, 2, 3, 4, 5, 6, 7 # (0, 1, 2, 3, 4, 5, 6, 7) # в определении кортежа скобки не обязательны

b = (1, ) # определение кортежа из одного элемента имеет нюанс, поскольку просто (1) является числом

print(a[1]) # 1 # это не срез, а значение по индексу 1

print(a[1:]) # (1, 2, 3, 4, 5, 6) # срез от индекса 1 до конца

print(a[-7:]) # (1, 2, 3, 4, 5, 6) # отрицательный индекс отсчитывается в обратном направлении от "запредела" кортежа

print(a[1:5]) # (1, 2, 3, 4) # срез от индекса 1 до индекса 5 /"до" в исключительном смысле

print(a[:5:2]) # (0, 2, 4) # срез от начала до индекса 5 с шагом 2

print(a[1:5:2]) # (1, 3) # срез использует от, до и шаг

print(a[-1::-1]) # (7, 6, 5, 4, 3, 2, 1, 0) # срез от конца в обратном порядке

Множество <class ‘set’>

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

а = {1, 3, 5, 7} # {0, 1, 2, 3, 4, 5, 6, 7} # в определении кортежа скобки не обязательн
b = set('aeiou') #
c = set('')      #

а = {1, 3, 5, 7} # {0, 1, 2, 3, 4, 5, 6, 7} # в определении кортежа скобки не обязательн

b = set('aeiou') #

c = set('') #

Словарь <class ‘dict’>

Словарь Python является неупорядоченной коллекцией с доступом к каждому элементу по уникальному ключу, сходно классической структуре и php-массиву. Элементы словаря заключаются в фигурные скобки и состоят из пар ключ:значение разделенных между собой запятыми:

a = {0:'zero', 1:'one', 2:'two', 3:'three'}

1	a = {0:'zero', 1:'one', 2:'two', 3:'three'}

Для словаря недоступен итератор, тем не менее из словаря методом .items() можно получить объект типа <class ‘dict_items’>, который по сути является списком кортежей, или использовать список ключей метода .keys() и список значений метода .values() совмещенных функцией zip(…):

a = {0:'zero', 1:'one', 2:'two', 3:'three'} 
for kv in a.items():                        # итератор элементов
  print(kv[0],kv[1])
for k, v in zip(a.keys(), a.values()):      # итератор совмещенных списков ключей и значений
  print(k,v)

a = {0:'zero', 1:'one', 2:'two', 3:'three'}

for kv in a.items(): # итератор элементов

print(kv[0],kv[1])

for k, v in zip(a.keys(), a.values()): # итератор совмещенных списков ключей и значений

print(k,v)

Управление потоком

Блоки кода в Python определяется отступом форматирования, а не синтаксическими средствами, как в классических языках. По стандарту отступ должны формировать четыре пробела, табуляция не допускается (попытка использовать табуляцию вызывает ошибку, т.к. табуляция воспринимается в качестве символа начала выражения).

Условие (if, elif, else)

///

if a < 0: 
    print("negative")
elif 1 <= a <= 5:
    print("positive")
elif a == 0:
    print("zero")
elif a is b:
    print("equivalent to b")
elif a != None:
    print("other value")
else:
    print("value is absent")

A = Y if X else Z #

if a < 0:

print("negative")

elif 1 <= a <= 5:

print("positive")

elif a == 0:

print("zero")

elif a is b:

print("equivalent to b")

elif a != None:

print("other value")

else:

print("value is absent")

A = Y if X else Z #

Цикл (while, continue, break, else)

value = 0; valueMax = 10; valueSum = 0
while value <= valueMax:
    value += 1
    valueSum = valueSum + value
print(valueSum)
#else: !!!

value = 0; valueMax = 10; valueSum = 0

while value <= valueMax:

value += 1

valueSum = valueSum + value

print(valueSum)

#else: !!!

Цикл (for, continue, break, else)

Списки, кортежи, множества и словари могут быть соединены для синхронной итерации в цикле функцией zip(…), при этом число итераций будет определено самой короткой коллекцией:

c = ('', 'First', 'Second') 
l = [0, 1, 2, 3]
s = {'', 'a', 'b', 'c', 'd'}
d = {0:'zero', 1:'one', 2:'two', 3:'three'}
for cv, lv, sv, dkv in zip(c, l, s, d.items()):
    print(cv, lv, sv, dkv[0], dkv[1])

c = ('', 'First', 'Second')

l = [0, 1, 2, 3]

s = {'', 'a', 'b', 'c', 'd'}

d = {0:'zero', 1:'one', 2:'two', 3:'three'}

for cv, lv, sv, dkv in zip(c, l, s, d.items()):

print(cv, lv, sv, dkv[0], dkv[1])

Функция enumerate(…) возвращает полученный из объекта коллекции объект типа <class ‘enumerate’>, итератор которого содержит индекс:

a = set('abc')            # порядок элементов в множестве непредсказуем
for i, c in enumerate(a):
    print(i, c)           # 0 b
                          # 1 c
                          # 2 d

a = set('abc') # порядок элементов в множестве непредсказуем

for i, c in enumerate(a):

print(i, c) # 0 b

# 1 c

# 2 d

Бездействие (pass)

Синтаксис Python не позволяет оставить блок условия или цикла (после двоеточия) пустым, но если так нужно сделать, то следует использовать Pass:

while condition: # цикл с условием зависящим от другого потока
    pass         # пустой блок цикла

1 2	while condition: # цикл с условием зависящим от другого потока pass # пустой блок цикла

Обработка исключений (try, except, finally, …)

///

Функции

Вызов функции print(value, …, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)

print(a, b, c)
print(a, b, c, sep=',', end='')

1 2	print(a, b, c) print(a, b, c, sep=',', end='')

Определение (Def, Return)

def cheeseshop(kind, *arguments, **keywords):

Параметры

Лямбда функции

my_func = lambda a, b: a + b

my_func(1, 2)

Источники

Python //ru.wikipedia.org
История языка программирования Python //ru.wikipedia.org
Devpractice Разработка программного обеспечения, технологии и наука //devpractice.ru
- Python. Уроки …/python-lessons/
- Машинное обучение (ML & DA) …/ml-da/
Python/Учебник Python 3.9 //ru.wikibooks.org
Про PYTHON //pythonz.net
- Версии …/versions/
- Работа …/vacancies
Python //pythonworld.ru
- 10 инструментов Python для работы с изображениями //medium.com
DB
- Python: Работа с базой данных, часть 1/2: Используем DB-API DaneSoul@habr.com (февраль 2017)
- Модуль sqlite — Работаем с базой данных //python-scripts.com
PRO
- Указатели в Python: в чём суть?Logan Jones@habr.com (июнь 2019 )

Пн	Вт	Ср	Чт	Пт	Сб	Вс
« Сен
			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

Model	Type	F.F.	AF	Interface	Cache	Transfer	RPM	Capacity	WL	Warranty	Noise
Blue Desktop	Для рабочих систем Гарантия: 2 года
WD1003FZEX	HDD	3.5″	+	SATA3 6GB/s	64 MB	150 MB/s	7200	1 TB	180 TB/y	2 years	30 dB
Green Desktop	Для накопителей Гарантия: 2 года
WD15EARS	HDD	3.5″	+	SATA2 3GB/s	64 MB		5400	1.5T		2 years	29 dB
Black Desktop	Для высокопроизводительных систем Гарантия: 5 лет
WD1003FZEX	HDD	3.5″	+	SATA3 6GB/s		150	7200	1 TB	180 TB/y	5	30
WD2002FAEX	HDD	3.5″	+	SATA3 6GB/s	7200	150	7200	2 TB		5	34
Red Desktop	Для накопителей NAS и серверных систем (для круглосуточной интенсивной работы) Гарантия: 3 года
WD40EFRX	HDD	3.5″	+	SATA3 6GB/s	5400	150	64	4TB	180 TB/s	3	28 dB
Purple Desktop	Для систем видео наблюдения (оптимизированы для круглосуточной записи) Гарантия: 3 года
	HDD	3.5″	+	SATA3
GOLD	Гарантия: 3 года
	HDD	3.5″	+	SATA3

РеКС — друг в мире компьютеров

Классический взгляд на особенности Python