Язык программирования Python

Появился в 1991 году. Обрел популярность после инвестирования в него денег компанией Google.

Типы данных:

В Python'е существуют следующие типы данных:

Целые числа - Integer (пример: 23)
Дробные числа - Float (пример: 23.9)
Строки - Sting (пример: "Hello, Python!")
Логический или Булев тип - Boolean (пример: True или False)
Списки - List (пример: [786, 3.14, 'text', True])
Кортежи - Tuple (пример: (786, 3.14, 'text', True))
Словари - Dictionary (пример: {'Number': 786, 'Strings': 'text', "Znachenie": True))
Множества - Set (пример: {786, 3.14, 'text', True})

Работа с переменными
Работа со Словарями

Работа с переменными:

Переменные в Python нельзя начинать с цифр. Нужно только с букв.

Так же, переменные в виде строк можно слаживать или умножать, например:
x = "Строка 1"
y = "Строка 2"
z = x + Y
print(z)

Результат = "Строка 1Строка 2"

Создание переменной «test» и присвоение ей числа «12»
test = 12

Присвоение занчения сразу нескольким переменным:
a = b = c = 1

Удаление переменной «test»
del test

Вывод информации (данных):

Вывод текста
print (“Hello World”)

Вывод текста с последующим отступом строчки
print (“Hello World \n”)

Вывод текста с отступом строчек в начале и конце
print ("\n\nHello World!\n\n\n ")

Вывод текста без перехода на новую строку
print("Ukraine", end = "")

Ввод информации (данных):

Ввод данных и присвоение их переменной «name»
name = input(“Как вас зовут? ”)

Ввод данных, преобразование их в число и присвоение их переменной «name»
name = int (input(“Сколько вам лет? ”))

Преобразование типов данных:

int(x)
Преобразовывает х в целое число. Например, int(12.4) -> 12

long(x)
Преобразовывает х в long. Например, long(20) -> 20L

float(x)
Преобразовывает х в число с плавающей точкой. Например float(10) -> 10.0

complex(real [,imag])
Создает комплексное число. Например complex(20) -> (20+0j)

str(x)
Преобразовывает х в строку. Например str(10) -> '10'

tuple(s)
Преобразовывает s в кортеж. Например tuple("hello") -> ( "h","e","l","l","o" )

list(s)
Преобразовывает s в список. Например list("Python") -> [ "P","y","t","h","o","n" ]

dict(d)
Создает словарь из d. Например dict( [ (1,2), (3,4) ] ) -> { 1:2, 3:4 }

Математические операции:

Сложение
aaa = (3+2)

Вычитание
aaa = (3-2)

Умножение
aaa = (3*2)

Деление
aaa = (3/2)

Возведение в степень. Результат = 9
aaa = (3**2)

Подсчет количества вторых чисел (2) есть в первом числе (6). Результат = 3
aaa = (6//2)

Подсчет остачи при делении ( 60-(13*4) ). Результат = 8
aaa = (60%13)

test += 5
То же , что и «test = test + 5» или « test++ »

test -= 5
То же , что и «test = test - 5» или « test-- »

test *= 5
То же , что и «test = test * 5»

test /= 5
То же , что и «test = test / 5»

test %= 5
То же , что и «test = test % 5»

Округление чисел:

round(1.5)
Результат: 2

round(2.5)
Результат: 2

round(2.65, 1)
Результат: 2.6

round(2.75, 1)
Результат: 2.8

xyz = 34.56789
round(xyz, 3)
Результат: 34.567

Источник

Строки. Функции и методы строк:

# Разбиение строки по разделителю "пробел".
st = "Aaa Bbb Ccc"
st.split(' ')
# Результат ['Aaa', 'Bbb', 'Ccc']

len, ...

Источник

Оператоор IF ELIF ELSE:

Варианты условий: "==" , ">" , ">=" , "<" , "<=" , "!="

if x >= 4:         (првое условие)
    .....
    (код программы)
    .....
elif x <= 10:    (второе условие)
    .....
    (код программы)
    .....
else:
    .....
    (код программы)
    .....

Условие, которое всегда будет выполняться

if 1:
print("XXX")

Условие, которое никогда не будет выполняться

if 0:
print("YYY")

Интересная конструкция:

name = input("Введите Yes или No: ")

aaa = "Да" if name == "Yes" else "Нет"

print(aaa)

Циклы While и For:

while - условно переводиться как "Пока ...."

Пример цикла while:

i = 0
while i <= 10:
    print (i, end = " ")
    i += 2

Результат: 0 2 4 6 8 10

i = 0
while i <= 10:

    if i == 15:
        break			# Пропустить одну итерацию, когда символ = 6

    print (i, end = " ")
    i += 2
else:
    print(" - Цикл пройден. break не сработал!")

Результат: 0 2 4 6 8 10  - Цикл пройден. break не сработал!

Пример цикла For:

for j in "hello world":
    print(j * 2, end = "")

Результат: hheelllloo  wwoorrlldd

for j in "hello world":
    if j == "o":
        continue		# Пропустить одну итерацию, когда символ = "o"
    print(j * 2, end = "")

Результат: hheellll  wwrrlldd

for j in "hello world":
    if j == "r":
        break			# Полностью выйти из цикла, когда символ = "r"
    print(j * 2, end = "")

Результат: hheelllloo  wwoo

for j in "hello world":
    if j == "A":
        break			# Полностью выйти из цикла, когда символ = "A"
    print(j * 2, end = "")
else:
    print(" - Цикл пройден. break не сработал")

Результат: hheelllloo  wwoorrlldd - Цикл пройден. break не сработал!

Списки - List - []:

a = []					# Создание пустого списка
bbb = 999				# Создание переменной
c = [24, 67, 12, 77, ["R", 8, 9, bbb]]	# Создание списка и внутренним подсписком с переменной "bbb"

А теперь работа со списком:

c[0] = 14	  # Заменить значение первого элемента списка на число «14»

print(c[3])	  # Вывод четвертого элемента списка - 77
print(c[4][2])	  # Вывод четвертого элемента списка - 9
print(c[-1])	  # Вывод последнего элемента списка - ['R', 8, 9, 999]
print(c[4][-1])	  # Вывод последнего элемента списка внутреннего подсписка - 999
print(c[-2])	  # Вывод предпоследнего элемента списка - 77

Срезы списков - c[START:STOP:STEP]:

print(c[:])	  # Данный срез выводит полный список - [14, 67, 12, 77, ['R', 8, 9, 999]]
print(c[1:])	  # Данный срез выводит весь список кроме первого элемента - [67, 12, 77, ['R', 8, 9, 999]]
print(c[:4])	  # Данный срез выводит список до пятого элемента (пятый элемент уже не выводит) - [14, 67, 12, 77]
print(c[1:4])	  # Данный срез выводит список с перового по пятый элемент - [67, 12, 77]
print(c[::2])	  # Данный срез выводит каждый второй элемент списка (начиная с нулевого, затем второй, затем четвертый, …) - [14, 12, ['R', 8, 9, 999]]
print(c[::-1])	  # Данный срез выводит список в зеркальном (обратном) порядке - [['R', 8, 9, 999], 77, 12, 67, 14]
print(c[::-2])	  # Данный срез выводит каждый второй элемент списка в зеркальном (обратном) порядке - [['R', 8, 9, 999], 12, 14]

И еще работа со списком:

a.append (23)		  # Добавить в конец списка – число “23”
a.append (34)		  # Добавить в конец списка – число “34”

b = [24, 67]		  # Создание списка со значениями
a.extend (b)		  # Добавить в конец списка "а" – список "b"

Результат = [23, 34, 24, 67]


a.insert (1, 56)	  # Добавить в список элемент – по индексу во второй элемент ставим значение “56” (первый элемент начинается с 0)

Результат = [23, 56, 34, 24, 67]


a.remove (34)		  # Удаляет первый элемент в списке имеющий значение “34”

Результат = [23, 56, 24, 67]


a.pop ()		  # Удаляет последний элемент списка

Результат = [23, 56, 24]


a.pop (0)		  # Удаляет элемент списка под индексом “0” (т.е. первый)

Результат = [56, 24]


print(a.index (24))	  # Находит индекс элемента со значением “24”

Результат = 1


print(a.count (56))	  # Подсчитывает в списке и выводит количество элементов со значением “56”

Результат = 1


a.sort ()		  # Сортирует список в порядке возрастания

Результат = [24, 56]


a.reverse ()		  # Переворот списка в зеркальном (обратном) порядке

Результат = [56, 24]


a.clear ()		  # Очистка всего списка

Результат = []

x = ['one', 'two', 'three', 'four', 'five']	# Создание списка

print('four' in x)				# Проверить, есть ли слово "four" в списке "x"
						# Результат: True

Интересные конструкции:

a = [x + y for x in 'list' for y in 'soup']
print(a)

Результат = ['ls', 'lo', 'lu', 'lp', 'is', 'io', 'iu', 'ip', 'ss', 'so', 'su', 'sp', 'ts', 'to', 'tu', 'tp']

b = [x + y for x in 'list' if x != 's' for y in 'soup' if y != 'u']
print(b)

Результат = ['ls', 'lo', 'lp', 'is', 'io', 'ip', 'ts', 'to', 'tp']

Вывод значений списка через цикл (2 варианта):

my_list = ['a', 'b', 'c', 'd', 'e']

i = 0
while i < len(my_list):
    print (my_list[i], end = "")
    i += 1

Результат = abcde

my_list = ['a', 'b', 'c', 'd', 'e']

for item in my_list:
    print (item, end = "")

Результат = abcde

Кортежи - tuple - ():

cort = (43, 56, 45.23, 'd', 'XYZ')	# Создание Кортежа
lis = [43, 56, 45.23, 'd', 'XYZ']	# Создание Списка

print(cort)				# Вывод на экран Кортежа. Результат - (43, 56, 45.23, 'd', 'XYZ')
print(lis)				# Вывод на экран Списка. Результат - [43, 56, 45.23, 'd', 'XYZ']

print(cort.__sizeof__())		# Посмотреть сколько весит Кортеж. Результат - 32
print(lis.__sizeof__())			# Посмотреть сколько весит Список. Результат - 40

d = tuple ('Hello World')		# Разбивает «Hello World» на отдельные буквы и формирует кортеж.
print(d)				# Результат - ”H”, ”e”, ”l”, ”l”, ”o”, ” ”, ”W”, ”o”, ”r”, ”l”, ”d”

e = 'Hello World', 'd', 345		# Еще один вариант создания кортежа, метод рабочий, но (без скобок) и не совсем правильный
print(e)				# Результат - ('Hello World', 'd', 345)

print (e.index (345))			# Находит индекс элемента со значением “345”. Результат - 2
print (e.count ('d'))			# Подсчитывает в списке и выводит количество элементов со значением “d”. Результат - 1

А это НЕ является кортежем: a = ("Hello World")
Результат - "Hello World"

Словари - Dictionary:

Существуют 4 типа создания словаря.

Вариант № 1:

d = {"key_1" : 1, "key_2" : "Test", "key_3": True}

print(d)		# Вывести весь словарь
print(d["key_2"])	# Вывести только значение ключа "key_2" в словаре

Вариант № 2:

d = dict(short="dict", longer="dictionary")
print(d)

Результат: {'short': 'dict', 'longer': 'dictionary'}


d['short'] = 234
print(d)

Результат: {'short': 234, 'longer': 'dictionary'}

d = dict([(23, 34), (56, 87)])
print(d)

Результат: {23: 34, 56: 87}

Вариант № 3:

d = dict.fromkeys (["a", "b"])
print(d)

Результат: {'a': None, 'b': None}


d = dict.fromkeys (["a", "b", "c"], 1)
print(d)

Результат: {'a': 1, 'b': 1, 'c': 1}

Вариант № 4:

d = {a : a ** 2 for a in range (10)}
print(d)

Результат: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

Пример работы со словарем:

person = {
          'name' : {
                    'last_name': 'Иванов',
                    'first_name': 'Иван',
                    'middle_name': 'Иванович'
                   },
          'address': [
                      'г. Андрюшки',
                      'ул. Васильковская д. 23б',
                      'кв.12'
                     ],
          'phone': {
                    'home_phone': '34-67-12',
                    'mobile_phone': '8-564-345-23-65',
                    'mobile_phone_2': 'Нет'
                   }
         }


print (person['name']['last_name'], person['name']['first_name'], person['name']['middle_name'])

Результат: Иванов Иван Иванович


print (person['phone']['mobile_phone'])

Результат: 8-564-345-23-65


print (person['address'][1])

Результат: ул. Васильковская д. 23б

print (person.keys())		# Показать все ключи соваря
				# Результат: dict_keys(['name', 'address', 'phone'])

print (person.values())		# Показать все значения соваря
				# Результат: dict_values([{'last_name': 'Иванов', 'first_name': 'Иван', 'middle_name': 'Иванович'}, ['г. Андрюшки', 'ул. Васильковская д. 23б', 'кв.12'], {'home_phone': '34-67-12', 'mobile_phone': '8-564-345-23-65', 'mobile_phone_2': 'Нет'}])

person.clear()			# Очистить весь словарь
print (person)			# Результат: {}

Множества - Set:

Множество это тот же список но без повторяющихся элементов и множество всегда выводится в случайном порядке.
Есть 2 варианта создания множества:

Вариант № 1:

a = set ('hello')			# Создание множества (но оно выведется без одной буквы “L”)

print(a)				# Результат: {'e', 'l', 'o', 'h'}

print(type(a))				# Вывод типа данных.

Вариант № 2:

b = {'23', 32, 44, 91, 'xXx'}		# Второй вариант создания множества

print(b)				# Результат: {32, '23', 44, 'xXx', 91}

c = {i ** 2 for i in range (10)}	# Создается множество из десяти элементов

print(c)				# Результат: {0, 1, 64, 4, 36, 9, 16, 49, 81, 25}


c.add ("777")				# Добавить в множество элемент «777» 

bb = "999"
c.add (bb)				# Добавить в множество элемент «999» из переменной «bb»

print(c)				# Результат: {0, 1, 64, '777', 4, 36, 9, '999', 16, 49, 81, 25}

d = frozenset ("Qwerty")		# Множество – в которое после создания мы уже не сможем добавлять элементы (как и в Кортежах)

print(d)				# Результат: frozenset({'Q', 'e', 'r', 'y', 't', 'w'})

f = ['r', 's', 'w', 'a', 's', 'w']	# Создание обычного списка

print(f)				# Вывод списка
					# Результат: ['r', 's', 'w', 'a', 's', 'w']

print(set (f))				# Вывод списка через множество.
					# Результат: {'r', 's', 'w', 'a'}

Методы и свойства:

j = {32, 45, 43.23, 76}			# Создаем обычное множество
h = 45					# Создаем одно дополнительное значение
y = {67, 12, 90}			# Создаем еще одно обычное множество

print (len(j))				# Подсчет количества элементов в множестве.
					# Результат: 4

print (h in j)				# Проверяет есть ли значение переменной «h» в множестве.
					# Результат: True

print (j.isdisjoint (y))		# Проверяет нет ли ни одного одинакового элемента в множествах "j" и "y" 
					# Результат: True (так как одинаковых элементов нет)

print (j == y)				# Проверяет – одинаковые ли множества "j" и "y"
					# Результат: False (так как нет, они не одинаковые)

Операции:

j = {11, 22, 33.44, 55}			# Создаем обычное множество
k = {22, 66, 55, 99}			# Создаем еще одно обычное множество

j.update (k)				# Операция добавляет в множество "J" содержимое множества "K"
print(j)				# Результат: {66, 99, 33.44, 11, 22, 55}

j.intersection_update (k)		# Операция создает пересечение множеств "J" и "K" и выводит только те, которые не повторяются в множествах
print(j)				# Результат: {22, 55}

j.difference_update (k)			# Операция выбирает все элементы множества "J" которых нет в множестве "K"
print(j)				# Результат: {33.44, 11}

j.symmetric_difference_update (k)	# Множество из элементов встречающихся в одном множестве но не встречающихся в обоих
print(j)				# Результат: {66, 99, 33.44, 11}

j.remove (55)				# Удаляет элемент со значением "55" из множества "J". Если такого элемента нет – то программа выдает ошибку "KeyError: 55".
print(j)				# Результат: {11, 33.44, 22}

j.discard (55)				# Удаляет элемент со значением "55" если он находится в множестве. Если такого элемента нет – то программа не выдает ошибку.
print(j)				# Результат: {11, 33.44, 22}

j.pop ()				# Удаляет первый случайный элемент множества "J"
print(j)				# Результат: {33.44, 22, 55}

j.clear ()				# Полностью очищает множество "J" от всех элементов
print (j)				# Результат: set()

Функции:

Функции – это подпрограмма которую можно вызывать из кода.

def aaa():
    print('Text')
    pass				# Ставится, если функция ничего не возвращает

aaa()					# Результат: Text

def aaa(x):
    print('Text - ' * x)
    pass				# Ставится, если функция ничего не возвращает

aaa(4)					# Результат: Text - Text - Text - Text -

def aaa():
    y = 1 + 2
    return y

print(aaa())				# Результат: 3

def aaa(x):
    y = x + 2
    return y

print(aaa(5))				# Результат: 7

def aaa(x, y, z):
    temp = x + y + z
    return temp

print(aaa(5, 10, 15))			# Результат: 30

def aaa(x, y, z):
    return x + y + z

print(aaa("Hello ", "World ", "!"))	# Результат: Hello World !

Пример использования функции в функции:

def func_1 (x):

    def func_2 (y):
        z = x + y
        return z

    return func_2

test = func_1(10)			# Передача значения для "Х" в первую функцию
rez = test(20)				# Передача значения для "Y" во вторую функцию

print(rez)				# Результат: 30

Пример использования аргументов по Умолчанию:

def func_test (x, y, z = 3):			# Аргумент "z" это аргумент по Умолчанию, и обычно такие аргументы указываются в конце, иначе ошибка "SyntaxError:"
    res = x + y + z
    return res

print (func_test(1, 2))				# Передача числа "1" для аргумента "x" и числа "2" для аргумента "y"
						# Результат: 6

print (func_test(1, 2, 10))			# Передача числа "1" для аргумента "x", числа "2" для аргумента "y" и замена в аргументе "z" с числа "3" на новое число "10"
						# Результат: 13

Пример передачи в функцию неограниченного количества параметров - Кортеж:

def func_ar (*args):				# Передача неограниченного количества параметров - Формируется Кортеж
    param = args
    return param

print (func_ar(11, 22, 33, 44.9, 'EEE'))	# Результат: (11, 22, 33, 44.9, 'EEE')

Пример передачи в функцию неограниченного количества параметров - Словарь:

def func_ar (**kwargs):				# Передача неограниченного количества параметров - Формируется Словарь
    param = kwargs
    return param

print (func_ar(a=23, b=56, c=90, xxx='yyy'))	# Создание ключей "a", "b", "c", "xxx" и присвоение им соответствующих значений
						# Результат: {'a': 23, 'b': 56, 'c': 90, 'xxx': 'yyy'}

Пример создания анонимной «Lambda» функции - т.е. функции только на одну операцию:

ttt = lambda x, y: x * y
print (ttt(3, 5))				# Результат: 15

uuu = lambda x, y: x * y
print (uuu('Q ', 5),)				# Результат: Q Q Q Q Q

print ((lambda x, y: x * y)(3, 4))		# Создание анонимной функции в одну строку (без каких либо присвоений)
						# Результат: 12

func_9 = lambda *args: args			# Создание анонимной функции - Кортежем
print (func_9(2, 56, 78.56, 'ppp'))		# Результат: (2, 56, 78.56, 'ppp')

func_9 = lambda **args: args			#Создание анонимной функции - Словарем
print (func_9(zzz = 2, xxx = 56, ccc = 78.56, vvv = 'ppp'))			
						# Результат: {'zzz': 2, 'xxx': 56, 'ccc': 78.56, 'vvv': 'ppp'}

Исключения:

try:
    print(10/0)
except ZeroDivisionError:
    print ('Ошибка!!! Попытка делить на 0')

try:
    print(int('a10'))
except ValueError:
    print ('Ошибка!!! Попытка преобразовать букву в число')

try:
    print('2' + 1)

except TypeError:
    print ('Ошибка!!! Попытка сложить число и строку')

else:								
    print ('Все верно! - Сработает если ошибки не было')

finally:							
    print ('Всегда Выполнится! - Сработает абсолютно всегда, не в зависимости была ошибка или нет')

Работа с файлами:

Для открытия файла существуют следующие параметры:

"r" - Открытие для Чтения
"w" - Открытие для Записи (при этом старое содержимое файла удаляется. Если файла нет – тога создается новый
"x" - Открытие для Записи (если файла нет, иначе исключение)
"a" - Открытие для Дозаписи (новая информация добавляется в конец файла)

"b" - Открытие в Двоичном режиме
"t" - Открытие в Текстовом режиме

"+" - Открытие на Чтение и Запись

Пример программы для чтения файла:

f = open ('test.txt')				# Открытие файла для чтения

print (f.read(1))				# Вывод первого символа файла
print (f.read(2))				# Вывод первых двух символов файла
print (f.read(40))				# Вывод первых сорока символов файла

print (f.read())				# Вывод всего содержимого файла

f.close ()					# Закрытие файла

Пример программы для создания нового файла:

f = open ('test.txt', 'w')			# Создание нового файла для записи

f.write ('Test 1 ')				# Запись данной строки в файл

f.close ()					# Закрытие файла

Пример программы для открытия саществующего файла для дозаписи:

f = open ('test.txt', 'a')			# Открытие существующего файла для дозаписи

f.write ('Test 2 ')				# Запись данной строки в файл

f.close ()					# Закрытие файла

Пример программы для чтения файла построчно:

f = open ('1.py') 

for line in f:					# Создание переменной "line" и проход по всему содержимому файла "f"
    print (line)				# Вывод отдельно каждой строчки содержимого файла

f.close ()

Менеджеры контекста - With ... as:

Предназначены для того, чтобы автоматически срабатывали критические функции (например - закрывать файл или класс) в том случае если программа завершится неверно или с какой-либо ошибкой.

with open ('test.txt', 'wt', encoding='utf-8') as inFile: 	# Открывается или Создается файл для записи в текстовом режиме в переменную "inFile"

    num = int(input())						# Запрос пользователя ввести число

    line = str('1 \ ' + str(num) + ' = ' + str(1 / num))	# Запись в переменную "line" математического выражения
    
    print(line)							# Вывод на экран данного математического выражения
    
    inFile.write (line)						# Запись в файл данного математического выражения

    # inFile.close()
    # Данную функцию Закрытия файла использовать не нужно, так как мы используем менеджеры контекста "with" "as", 
    # которые автоматически выполняют критическую функцию закрытия файла при Ошибке

Модули. Работа с «import» и «from»:

Модули - это сторонние программки, которые мы можем подключать к своей собственной программе.

import math			# Импорт Модуля для работы с математическими операциями

print (math.e)			# Вывод числа "Е" из модуля 

print (math.pi)			# Вывод числа "ПИ" из модуля 

print (math.cos (1))		# Вывод косинуса числа "1"

Подключение нескольких модулей через запятую.
Но правильнее вводить каждый модуль отдельным "import"

import time, os			# Импорт Модуля "time" и "os" для работы со временем и операционной системой.

print (time.time ())		# Вывод количества секунд которые прошли с первого января 1970 года

print (os.getcwd ())		# Вывод пути расположения файла данной программы

#print (os.uname ())		# Вывод всей информации про наш компьютер (в Windows не работает)

import random as r		# Импорт Модуля "random" (для выбора случайного числа) и назначение ему псевдонима "r"

print (r.randint(40, 100))	# Вывод случайного числа в промежутке от 40 до 100

try: 							# Блок проверки модуля на его наличие
    import nomodule					# Импорт несуществующего модуля
except ImportError:					# Проверка на ошибку "ImportError"
    print ('Модуля \"nomodule\" не существует')		# Вывод сообщения

import my_module as m			# Подключение собственного модуля. Сам файл "my_module.py" обязательно должен находиться в папке с данной программой)

m.hi ()					# Запуск функции "hi" из нашего модуля

print (m.add(45, 15))			# Вывод на экран результата функции "add" при вводе в неё двух параметров – это числа "45" и "15"

Содержание нашего созданного модуля "my_module.py"

def hi():
    print("Hi!!!")

def add(x, y):
    return x + y

if __name__ == "__main__":		# Проверка и выполнение данного кода только в том случае, если мы запускаем именно этот файт "my_module.py"
    print("Hello")			# А если мы данный файл просто импортируем - то данный код не сработает

from my_module import hi, add		# Импортирование только функций "hi" и "add" из собственного модуля

hi ()					# Вызов функции "hi"

print (add (45, 15))			# Вывод на экран результата функции "add" при вводе в неё двух параметров – это числа "45" и "15"

from my_module import hi as h, add as a	# Подключение функции "hi" и "add" с назначением им псевдонимов "h" и "a"

h()					# Вызов функции "hi" через псевдоним "h"

print (a (45, 15))			# Вывод на экран результата функции "add" через псевдоним "a" при вводе в неё двух параметров (числа "45" и "15")

Основы ООП в Python:

ООП – это Объектно-Ориентируемое Программирование. По сути это – «Классы» и «Объекты».
На основе Классов создаются Объекты.
ООП - может использоваться в программах, над которыми работает много людей, так как благодаря ООП все моменты разработки программы лучше структурируются и программа получается более читабельной.

class Developres:				# Создание Класса
    name = None					# Создание Поля Имени (значение "None" будет установлено по умолчанию)
    age = None					# Создание Поля Возраста (значение "None" будет установлено по умолчанию)

alexandr = Developres()				# Создание объекта и присвоение ему значений класса "Developres"

print(alexandr.name)				# Результат: None

alexandr.name = "Александр"			# Назначение нового Имени данному объекту
alexandr.age = 26				# Назначение нового возраста данному объекту
print(alexandr.name, alexandr.age)		# Результат: Александр 26

denis = Developres()				# Создание объекта и присвоение ему значений класса "Developres"

denis.name = "Денис"				# Назначение нового Имени данному объекту
denis.age = 28					# Назначение нового возраста данному объекту

print(denis.name, denis.age)			# Результат: Денис 28

class Boys:					# Создание Класса
    name_a = None				# Создание Поля Имени (значение "None" будет установлено по умолчанию)
    age_a = None				# Создание Поля Возраста (значение "None" будет установлено по умолчанию)
    
    def set(self, name_b, age_a):		# Создание Функции / Метода - "set" в котором обязательно должен присутствовать аргумент "self". 
						# Так же в данный метод можно передавать переменные/поля/аргументы (например "name" и "age")

        self.name_a = name_b			# Обращаемся в полю класса "name_a" (благодаря аргументу "self") и присваиваем ему значение "name_b" которое мы передаем из основной программы
        self.age_a = age_b			# Обращаемся в полю класса "age_a" (благодаря аргументу "self") и присваиваем ему значение "age_a" которое мы передаем из основной программы

	
roman = Boys()					# Создание объекта и присвоение ему значений класса "Boys"

roman.set("Роман", 33)				# Использование метода "set" и передача в него двух значений Имени и Возраста

print(roman.name, roman.age)			# Результат: Роман 33

Наследование Классов

class Boys:						# Создание Класса
    name_a = None					# Создание Поля Имени
    age_a = None					# Создание Поля Возраста
    
    def set(self, name_b, age_b):			# Создание Метода
        self.name_a = name_b				# Присвоение полю "name_a" значения "name_b" которое мы передадим из основной программы
        self.age_a = age_b				# Присвоение полю "age_a" значения "age_b" которое мы передадим из основной программы


class Office_Kiyv(Boys):				# Наследование классом "Office_Kiyv" всех полей и методов ранее созданного класса "Boys"

    proffesion = None					# Создание нового поля в новом классе


mark = Office_Kiyv()					# Создание объекта и присвоение ему значений класса "Office_Kiyv"


mark.set("Марк", 24)					# Использование метода "set" и передача в него двух значений Имени и Возраста
mark.proffesion = "HTML+CSS"				# Назначение профессии данному объекту

print(mark.name_a, mark.age_a, mark.proffesion)		# Результат: Марк 24 HTML+CSS

Инкапсуляция - это ограничение доступа к каким либо полям или методам.
Инкапсуляция - это защита данных от того, чтобы мы их использовали в других классах наследниках либо в объектах.

class Boys:						# Создание Класса
    name_a = None
    age_a = None
    
    def __set(self, name_b, age_b):			# Создание Метода
        self.name_a = name_b
        self.age_a = age_b


class Office_Kiyv(Boys):				# Наследование классом "Office_Kiyv" класса "Boys"
    proffesion = None


mark = Office_Kiyv()					# Создание объекта


mark._Boys__set("Марк", 24)				# Обход Инкапсуляции
mark.proffesion = "HTML+CSS"

print(mark.name_a, mark.age_a, mark.proffesion)

Модуль random:

import random

a = random.random()			# Генерирует псевдослучайное число от 0.0 до 1.0

print(a)				# Результат: 0.642772971311735


a = random.uniform(0, 20)		# Генерирует псевдослучайное вещественное число в диапазоне от <Начало> до <Конец>

print(a)				# Результат: 16.836670618111945


a = random.randint(1,27)		# Генерирует псевдослучайное целое число в диапазоне от <Начало> до <Конец>

print(a)				# Результат: 13


a = random.choice('Chewbacca')		# Генерирует случайный элемент из строки
print(a)				# Результат: c

b = random.choice([1, 2, 'a', 'b'])	# Генерирует случайный элемент из списка
print(b)				# Результат: a

c = random.choice((1, 2, 'a', 'b'))	# Генерирует случайный элемент из кортежа
print(c)				# Результат: 2

d = random.randrange(100, 200, 10)	# Генерирует случайно выбранное число из последовательности (<Начало>, <Конец> и при необходимости <Шаг>)
print(d)				# Результат: 170

lis = [1, 2, 3, 4, 5, 6, 7, 8, 9]	# Создание списка чисел
random.shuffle(lis)			# Перемешивает последовательность (изменяется сама последовательность). Поэтому функция не работает для неизменяемых объектов.
print(lis)				# Результат: [9, 5, 4, 1, 7, 3, 2, 8, 6]

Источник - www.ps.readthedocs.io

На земетку:

Книга "Чистый Python - Тонкости программирования для Профи (Ден Бейдер)"
Книга "Укус Питона"
Моя полная инструкция по Python

My experience

1. How I studied

Lesson # 1 - Function - Print (Homework)
Lesson # 2 - Function - Input (Homework)
Lesson # 3 - Mathematical Operations (Homework)
Lesson # 4 - Variable (Homework)
Lesson # 5 - Operator - If (Homework)
Lesson # 6 - Cycle - While and For (Homework)
Lesson # 7 - List (Homework)
Lesson # 8 - Index and sections (Homework)
Lesson # 9 - Cortege (tuple) (Homework)
Lesson # 10 - Dictionary (Homework)
Lesson # 11 - Множества (set и frozenset)
Lesson # 12 - Функции (def, lambda, return)
Lesson # 13 - Исключения (Конструкция try - except)
Lesson # 14 - Работа с файлами
Lesson # 15 - Менеджеры With ... as (Homework)
Lesson # 16 - Модули. Работа с import и from / as
Lesson # 17 - Основы ООП Python
Lesson # 18 - Наследование, инкапсуляция, полиморфизм
Lesson # 19 - Конструкторы в классах, переопределение методов
Lesson # 20 - Декораторы функций