# Комментарий
a = 1 # Комментарий
''' Это тоже комментарий
b = c
c = d
'''

# динамическая типизация переменных
# = копирование значения справа налево
i = 1 #  целое число (int)
f = 2.1 # число с плавающей запятой (float)
s = "a" # строковый тип (string)
b = True # логический тип (boolean)
l = [0,1,2] # массив,список (array)
t = (0,1,2) # кортеж (tuple)
d = {"a":0, "b":1} # словарь, ассоциативный массив
print(i,f,s,b,l,t,d)
# 1 2.1 a True [0, 1, 2] (0, 1, 2) {'a': 0, 'b': 1}
# Когда хотим определить тип, используем type
print(type(i)) # Вывод <class 'int'>
# Переменная не сохраняет, а содержит фактическое значение
# Это, своего рода, переменная-ссылка, указывающая на местоположение значения
# Можно получить идентификатор актуального значения через id
print(id(l)) # 00000000000000 (меняется от исполнения к исполнениюц)
l2 = l # Приведу в пример копию массива, где ссылаюсь на 2 его элемента, а фактический массив - 1.
print(id(l2)) # 00000000000000 (то же значение, что у вышеуказанного id(l))
# Поскольку существует только один фактический массив, кажется, что он был добавлен в массив l, даже если вы добавили элемент со ссылкой на l2.
l2.append(1)

a = 1 # переменная а соответствует значению 1
b = a # b так же соответствует 1
a = 2 # теперь а соответствует 2, но b не изменяется
a += 1 # значение а увеличивается на 1 (на данном этапе а равно 3)
a -= 1 # значение а уменьшается на 1 (на данном этапе а равно 2)
a *= 2 # значение а увеличивается в два раза (на данном этапе а равно 4)
a /= 3 # значение а составляет ⅓ предыдущего значения (на данном этапе а равно 1.3333333333333333)
a = 1+2-3*4/5 # Вычисление в следующем порядке: умножение, деление, сложение, вычитание → a равно 0,6. (Однако, если учитывать погрешность, а равно 0.6000000000000001)

a = 0
# Указываем условие выполнения группы программ, обозначенной отступом.
# Далее прописываются условия, циклы, функционализация и т.д.
if a == 1:
    # Строка, которая смещена вправо на такую ​​же величину в левой части строки от этой строки, составляет одну группу программ.
    print(1)
    print(2)
    pass # Указание на конец группы с отступом
    # при выполнении условия if выполняется группа программ до строки выше
print(3) # вывод независимо от значения а, не подпадающий под условие if
# вывод 3

# Условие, позволяющее программе понять, запускаться или нет
if условие :
    # program group
# Выполнение повторяется только для элементов массива
# Элементы массива присваиваются переменной v в прямом порядке
for v in массив
    # program group
# Выполнение продолжается только при соблюдении условий
while условие:
    # program group
# Тайминг выполнение группы программ определяется позже
# (в первую очередь нужно создать группу программ и дать им имена)
def имя группы():
    # program group
    # После выполнения группы программ, возвращаем результат с помощью return
    # Или можно вернуться к началу
    return
# Ниже описан пример с ошибкой
# print(2) с измененным отступом будет относиться к другой группе программ
# однако, program group 2 не имеет под собой никакого объяснения
if a == 1:
    # выполнение группы program group 1 регулируется условием if a==1:
    print(1)
        # в program group 2 нет регулирующей части, поэтому компилятор выдает ошибку.
        print(2)

a = 1
b = 2
c = 2
# переменные a и b одинаковы, но a и c разные
if a==b and a!=c:
    print("отличается только с")
# а больше или равно b (включает а=b) или а>c (не включает а=с)
elif a>=b or a>c:
    print("а больше или равно b или больше с")
# не подходит под условия if и elif
else:
    print("кроме этого")
# выводит "кроме этого"

a = 1
b = 2
# если а=b, то v=0, если нет, то v=1
v = 0 if a==b else 1
print(v)
# вывод 1

for v in [0,1,2,3]: # Следующая обработка повторяется для элементов [0,1,2,3]в массиве.
    # Проходимся по массиву. Элементы массива выводятся через переменную v в прямом поряке
   print(v)
   pass # Обозначаем конец отступа
# вывод 0 1 2 3
# Используя enumerate, можно получить индекс и значение массива в итеративном процессе.
for i,v in enumerate([5,3,7,8]):
    # i - индекс, v - значение элемента
    print("(",i,v,")")
# вывод ( 0 5 ) ( 1 3 ) ( 2 7 ) ( 3 8 )
# С помощью zip два массива могут быть объединены в один и обработаны итеративно.
for v0,v1 in zip([1,2,3,4],[5,6,7,8]):
    # v0 содержит элементы массива первого аргумента zip, а v1 содержит элементы второго аргумента.
    print("(",v0,v1,")")
# вывод ( 1 5 ) ( 2 6 ) ( 3 7 ) ( 4 8 )

a = 3
# Пока a больше либо равно 0
while a>=0:
    print(a)
    # Уменьшаем значение a на 1
    a -= 1
# вывод 3 2 1 0

# Определение функции: Название - function_name, аргументы: param1 и param2, param2 - аргумент по умолчанию
# В случае, если аргумент не установлен, при вызове функции его значение будет равно 1 (значению по умолчанию)
def function_name(param1,param2=1):
    print("p1:",param1,"p2",param2)
    # Эта функция возращает сумму аргументов param1 и param2
    return param1 + param2
# вызов функции (на данном этапе впервые запускается function_name)
# значение param1 = 5,  param2 не устанавливается (используется аргумент по умолчанию)
v = function_name(5)
# вывод (вывод с помощью оператора print в функции function_name) p1: 5 p2 1
print("возвращаемое значение",v)()
# вывод "возвращаемое значение 6"

# название функции = lambda (входные аргументы) : (возвращаемое значение) - по такому принципу описывается функция.
f = lambda x: x*x
# Вызов функции происходит так же, как и в примере с def
v = f(2)
print(v) # отобразится 4

si = "1"   #Строка
sf = "2.3" #Строка
i = 4      #Целое число
# Преобразовываем целое число i в строку, происходит конкатенация строк
print(str(i)+si)
# 41
# Обратная ситуация - преобразовываем строку si в целое число(int), происходит арифметическое сложение
print(i+int(si))
# 5
# Преобразовываем строку в число с плавающей запятой (float), опять же происходит сложение (число при выводе автоматически заменяется на float)
print(i+float(sf))
# 6.3

# Создание массива
a = [1,1,2,3,2]              # a=[1,1,2,3,2]
b = [n for n in range(8)]  # b=[0, 1, 2, 3, 4, 5, 6, 7]
# Ссылка
# Отрицательные значения становятся индексами, которые выссчитываются с -1 в качестве последнего элемента
v = a[0]  # v=1
v = a[-1] # v=2
# Добавление
a += [4]     # a=[1, 1, 2, 3, 2, 4]
a.append(5)  # a=[1, 1, 2, 3, 2, 4, 5]
# Извлечение (перед выполнением a=[1, 1, 2, 3, 2, 4, 5])
v = a.pop(0) # v=1, a=[1, 2, 3, 2, 4, 5]
# Вырезание (перед выполнением a=[1, 2, 3, 2, 4, 5])
# a[первый индекс: предпоследний индекс]
# если индексы не прописывать, а оставить просто a[:], первоначальный индекс автоматически станет  равен 0, последний - количество элементов)
c = a[1:3] # c=[2, 3]
# Максимум・минимум (перед выполнением а= [1, 2, 3, 2, 4, 5])
mx,mi = max(a),min(a) # mx=5, mi=1
# Среднее значение(mean)、Медианное значение(median)、Наиболее частое значение(mode)、Стандартное отклонение(stdev)、Дисперсия(variance)
# (перед выполнением a=[1, 2, 3, 2, 4, 5])
from statistics import mean,median,mode,stdev,variance
v = mean(a) # v=2.8333333333333335
v = median(a) # v=2.5
v = mode(a) # v=2
v = stdev(a) # v=1.4719601443879744
v = variance(a) #v=2.1666666666666665
# Удаление повторений(перед выполнением a=[1, 2, 3, 2, 4, 5])
c = set(a) # c={1, 2, 3, 4, 5}
# Sorted（Создается новый упорядоченный массив）(перед выполнением a=[1, 2, 3, 2, 4, 5])
c = sorted(a) # c=[1, 2, 2, 3, 4, 5] (массив a остается без изменений)
# Sort（упорядочивает элементы массива）(перед выполнением a=[1, 2, 3, 2, 4, 5])
a.sort()      # a=[1, 2, 2, 3, 4, 5]
# Одинаково преобразует все элементы массива（mapping） (перед выполнением a=[1, 2, 2, 3, 4, 5])
# используем лямбда-выражение x: x+2.Значение элемента x меняется на x+2.
# list преобразует вывод функции map в массив
c = list(map(lambda x:x+2,a)) #c=[3, 4, 4, 5, 6, 7]
# Фильтр　(перед выполнением a=[1, 2, 2, 3, 4, 5])
# используем лямбда-выражение x: x%2==0
# Ищется элемент x、который делится на два без остатка. Подходящие элементы образуют новый массив
c = list(filter(lambda x:x%2==0,a)) #c=[2, 2, 4]
# Из всех элементов массива создается одно значение по заданным условиям
# x - изначальное значение（если запускаем цикл, х - значение первого элемента массива）
# xi - объект текущей операции
from functools import reduce
# задаем x+xi, получаем сумму всех элементов массива（перед выполнением a=[1, 2, 2, 3, 4, 5]）
c = reduce(lambda x,xi:x+xi,a) #c=17
# задаем max(xi,x), получаем наибольшее значение среди элементов массива（перед выполнением a=[1, 2, 2, 3, 4, 5]）
c = reduce(lambda x,xi:max(x,xi),a) #c=5

# Создание. Ключи - Родной язык, Математика, Английский язык, а значения - массивы
d = {
    "Родной язык" : [81, 60, 97, 96],
    "Математика" : [80, 78, 75, 96],
    "Английский язык" : [76, 85, 65, 88],
}
print(d)
# вывод {'Родной язык': [81, 60, 97, 96], 'Математика': [80, 78, 75, 96], 'Английский язык': [76, 85, 65, 88]}
# Инициализация с использованием for
d1 = {name:[0,1] for name in ["Родной язык","Математика","Английский язык"]}
# вывод {'Родной язык': [0, 1], 'Математика': [0, 1], 'Английский язык': [0, 1]}
# Получение значений через указание ключа
a = d["Математика"] # a=[80, 78, 75, 96]
# Замена значений через укзание ключа（Перезапись）
d["Английский язык"] = [77, 61, 91, 87] # d["Английский язык"]=[77, 61, 91, 87]
# Цикл данных
for k,v in d.items():
    print(k,v)
# вывод Родной язык [81, 60, 97, 96] Математика [80, 78, 75, 96] Английский язык [77, 61, 91, 87]
# Максимальное значение、Минимальное значение（в случае с ключом “Родной язык”）
jmx,jmi = max(d["Родной язык"]),min(d["Родной язык"])
#print(jmx,jmi)
# Находим название предмета с наивысшим средним значением
from statistics import mean
# В массивах типа словарь при использовании max можно в качестве ключевого аргумента указать функцию, определяющую, среди чего искать максимальное значение
# В этом случае лямбда-выражение используется для вычисления среднего значения из аргумента k(значение ключа в словаре)
kmx = max(d,key=lambda k:mean(d[k])) # kmx="Родной язык"

# with, файловая операция
# with автоматизирует завершение процессов, требующих запуска и завершения.
# Например, файл, открытый с помощью open, необходимо закрыть с помощью вызова функции close
# Если использовать with и открыть файл с помощью open, при выходе из диапазона with функция close вызовется автоматически.
# mode - r: чтение、w: запись、a: дополнительная запись
# Возвращаемое значение, которое мы получаем с помощью open, назовем f
with open("09_memo.txt",mode="a") as f:
    # Записываем в файл
    f.write("こんにちは\n")
# Чтение файла
with open("09_memo.txt","r") as r:
    print(r.read())

# Использование случайных чисел
import random
# Инициализация генерации случайных чисел
# Случайные числа позволяют генерировать одну и ту же последовательность случайных чисел несколько раз для экспериментальной воспроизводимости.
# Если аргумент seed указать численно, всегда будет выводиться одно и то же число.
random.seed(0)
# Генерация случайных чисел больше или равных 0 и меньше 1.
print(random.random()) # Вывод 0.8444218515250481
# Создает случайные целые числа больше первого аргумента и меньше второго аргумента.
print(random.randint(1,3)) # Вывод одного числа из 1,2,3
# Произвольно выбирает число из массива
print(random.choice([0,1,2])) # Вывод одного числа из 0,1,2
# Извлечение нескольких данных из массива
# Вторым аргументом указывается количества выводимых данных
print(random.sample([0,1,2],2)) # Выводимый массив [1, 2]
# Перемешиваем данные в массиве
# Новый массив не создается - данные перемешиваются непосредственно в массиве а
a = [0,1,2]
random.shuffle(a)
print(a) # вывод [0, 2, 1]
print(random.sample(a,len(a))) # Для создания нового массива можно использовать sample