Привет, Хабр! Представляю вашему вниманию перевод статьи "Python?0????????????????????(2. Python????????)".

Данная статья — вторая в серии. Первую вы можете найти здесь.

2.1 Комментарии обозначаются # или ''' (три одинарные кавычки)

# Комментарий
a = 1 # Комментарий 

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

2.2 Использование динамической типизации (тип определяется автоматически)

# динамическая типизация переменных
# = копирование значения справа налево
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)

2.3 Арифметические операторы (Вычисление и присвоение значений. Результат вычисления, как правило, помещается в переменную)

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)

2.4 Создание группы программ через отступ

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

# вывод 3

2.4.1 Сгруппированным программам даётся контроль над выполнением операций

# Условие, позволяющее программе понять, запускаться или нет
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)

2.4.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("кроме этого")

# выводит "кроме этого"

2.4.2.1 Другой пример написания условий

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

2.4.3 Формирование циклов (for)

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 )

2.4.4 Цикл while

a = 3

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

# вывод 3 2 1 0

2.4.5 Функции и методы

# Определение функции: Название - 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"

2.4.5.1 Лямба-выражение, пример написания функции

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

2.5 Преобразование строки в число

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

2.6 Массив, список

# Создание массива
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

2.7 Словарь (dictionary)?ассоциативный массив

# Создание. Ключи - Родной язык, Математика, Английский язык, а значения - массивы
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="Родной язык"

2.8 Файловая операция with open

# 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())

2.9 Случайное число random

# Использование случайных чисел
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

Спасибо за прочтение!

Мы будем очень рады, если вы расскажете нам, понравилась ли вам данная статья, понятен ли перевод, была ли она вам полезна?