​О переменных окружения.

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

Как можно хранить секретные ключи и переменные:
1. Просто в коде.
Заранее провальный метод, все ключи просто видно.

2. В отдельном файле.
Прекрасно, но обычный файл не так удобен, хотя во многих случаях используют даже такой вариант.

3. В переменных окружения.
Это достаточно унифицированный для всех проектов и программистов способ, а это очень ценится. Очень удобно работать и вот это вот всё.

В общем, об этом много где говорят, даже я использовал это вот в этом посте, но почему-то конкретные вещи никто не раскрывает. В этом посте ответ сразу на 2 вопроса:

1. Как установить переменную окружения?
Нагуглить ответ на этот вопрос крайне просто, если вы пользуетесь UNIX системами (linux/macos и т.д.), но как мы все знает, консоль windows отвратительна. А ещё windows используют всё же большинство, так что поговорим именно о нём.

Чтобы установить переменную окружения в windows необходимо написать следующую команду в консоли:
set VARIABLE_NAME=value

Команда же set выведет в консоль все переменные окружения.

2. Как получить уже установленную переменную окружения?
Всё проще, чем кажется. За это отвечает встроенный модуль os. Получить переменную можно так:

import os 

TOKEN = os.getenv('TOKEN')

На этом всё, это действительно так просто.

Используйте переменные среды, следите за безопасностью,ну и любите и будьте любимы.

#python #useful

​Что такое ifmain конструкция в Python.

Начнём с того, что конструкция выглядит так:

if __name__ == "__main__":
    do_somethink()

Здесь __name__ - это "магическая" переменная, содержащая внутри себя название файла, откуда выполняется какая-то функция или операция. Допустим, что у нас есть 2 файла: main.py и file.py.
Внутри файла file.py имеем код:

def foo():
    print(f"А я {__name__}")

В файле main.py реализуем такой код:

import file

print(f"Я {__name__}")
file.foo()

Тогда получим вывод:

>>> Я __main__
>>> А я file.py

Так вот, вышеописанная конструкция проверяет является ли файл главным в стеке вызовов. Все операции, реализованные внутри условия, не выполнятся, если этот файл не будет главным.

Если в файле file.py мы так же добавим:

if __name__ == "__main__":
    print("Привет из условия file.py")

То данный принт мы не увидим, потому что главным файлом в цепочке является файл main.py, а переменная __name__ у файла file.py равна "file.py".

Надеюсь, что объяснил понятно. Перепишу, если будут вопросы. В будущем планирую сделать ещё более подробный пост о магических методах, так что предлагаю вам читать меня чаще :)

#python

​Тернарный оператор в Python.

Есть такая полезная штука во многих языках программирования, как тернарный оператор. Чтобы понять пользу всей этой конструкции давайте рассмотрим такую задачу:
У нас есть переменная num, в которую пользователь положит число. Если num ≥ 0, то в консоль выведем "Положительное либо ноль", а иначе выведем "Отрицательное".

Реализуем код:

num = int(input())

if num >= 0:
    print("Положительное либо ноль") 
else:
    print("Отрицательное")

С помощью тернарного оператора имплементация решения этой же задачи выглядит так:

num = int(input())

print("Положительное либо ноль" if num >= 0 else "Отрицательное")

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

def abs(num):
    if num >= 0:
        return num
    return -num

Но с тернарным оператором она будет выглядеть вот так:

def abs(num):
    return num if num >= 0 else -num

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

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

#python

​Цикл for для списков и словарей.

Я думаю многие знают стандартный способ запуска цикла for для Python через встроенную функцию range(). Записывается он вот так:

for i in range(10):
    print(i)

Но на самом деле в Python существует намного больше способов итерирования. Сегодня рассмотрим некоторые из них. Для работы нам понадобятся некоторые переменные, которые можно посмотреть тут.

Чтож, предлагаю начать со списков. Для итерирования я предлагаю вам использовать оператор in. Тогда запись будет выглядеть вот так:

for value in object: 
    somethink()

На конкретном примере:

for id_ in subscribersIdList:
    print(id_)

Я использую переменную id_ с нижним подчёркиванием после только для того, чтобы избежать совпадения с зарезервированным именем в Python, функцией id().

Если мы будем рассматривать словари, то всё уже гораздо интереснее. Запишем такой вариант:

for key in dict:
    somethink()

Тогда на примере:

for city in temperature:
    print(f"In {city}: {temperature[city]}°C")

Как вы можете заметить, это очень удобно, но обращаться к словарю temperature по ключу не очень удобно. Чтобы упростить работу придётся познакомиться со встроенным методом списка items(). Он возвращает нам список кортежей формата (key, value). Подробнее смотреть сноску.

Применяя этот метод получаем типовую структуру:

for key, value in dict.items():
    somethink()

На примере это будет выглядеть так:

for city, temp in temperature.items():
    print(f"In {city}: {temp}°C")

Есть ещё несколько удобных способов, но я предлагаю пока что остановиться на этом, а другое разобрать в следующих постах. Декомпозируем, так сказать, очень хорошая привычка. И шизе привет, кстати. Кто понял, тот понял.

#python

​Оператор in и немного о строках.

Раз уж я в прошлом посте вспомнил о списках и словарях, то научимся использовать in не только для итерации, а для булевых функций. Кстати, прошлый пост тоже советуется к прочтению.

Так вот, в дополнение к прошлому посту скажу, что через for in можно перебирать так же и символы в строке:

for char in string:
    print(char)

Как-то совсем забыл об этом, но знать точно стоит. Ну а теперь заведём переменные:

string = "Я бы любил тебя, но ты не Python"

temperature = {
    "Moscow" : 11, 
    "New York": 12,
}
names = [
    "Helen",
    "Denis", 
]

Отлично. С помощью оператора in мы можем проверить почти любое вхождение в объект, вашему вниманию вот такие записи:

>>> "любил тебя" in string // True
>>> "Moscow" in temperature // True
>>> "Helen" in names // True

Я считаю, что они интуитивно понятны. Но стоит обратить внимание вот на что:
>>> "denis" in names // False

В случае строк этот оператор чувствителен к регистру и ищет лишь полное соответствие. Если понадобится найти вхождение независимо, то можно привести строки, например, к нижнему регистру при помощи метода lower().

Удобно? Я думаю, что очень. Уж точно удобнее некоторых методов поиска для строк, так ещё и в разы читабельнее.

Спасибо за прочтение, это правда очень важно ❤️

#python

​Встроенная функция enumerate.

Гениальная и простая и очень полезная функция. Она позволяет вам пронумеровать ваши данные. Рассмотрим на самых простых для понимания примерах, а именно на строках и списках:

string = 'progway'
names = ['Denis', 'Helen', 'Mark']

enumerate(names)
>>> <enumerate object at 0x00D624C8>

list(enumerate(string))
>>> [(0, 'p'), (1, 'r'), (2, 'o'), (3, 'g'), (4, ....]
list(enumerate(names))
>>> [(0, 'Denis'), (1, 'Helen'), (2, 'Mark')]

Как вы можете видеть, функция enumerate возвращает итерируемый объект без представления для пользователя. Поэтому мы делаем списки из этих объектов через конструктор list(). Таким образом, enumerate возвращает список пронумерованных кортежей типа (num, value).

Самый тривиальный вариант применения - цикл for:

for num, name in enumerate(names, 1):
    print(f'{num}: {name}')

Как вы можете заметить, у функции enumerate я указал второй позиционный аргумент. Это число, с которого функция будет нумеровать наши данные. Изначально функция нумерует начиная с нуля, но в данном случае мы начнём с единицы.

Счастья, здоровья вам, и долгих лет жизни. А главное счастья. И здоровья. Счастья.

#python

​Что такое list comprehension в Python.

Очень удобная сущность, которая позволяет определять списки. Самое приятное тут то, что с помощью list comprehension мы определим список быстрее, чем любым другим способом, если я не ошибаюсь.
Итак, вот как выглядит полная структура:
[foo(x) if condition else bar(x) for x in sequence]

Это общая формула. Блоки else и if не обязательны, то есть наше представление списков может быть упрощёно вплоть до:
[x for x in sequence]

Не знаю как объяснить это кратко и понятно, получается либо так, либо так. Так что давайте напишем несколько представлений с пояснениями. Все примеры с красивой подсветкой синтаксиса можно посмотреть тут.

/// квадраты натуральных чисел от 1 до 10
[x ** 2 for x in range(1, 11)]

/// только чётные натуральные числа от 1 до 20
[x for x in range(1, 21) if x % 2 == 0]

Обратите внимание на то, что if тут в конце. Такая запись характерна для list comprehension без блока else

/// получить список символов из строки
[letter for letter in word]

Насчёт многочисленных условий:

/// список чисел от 1 до 200, одновременно делящихся на 2, 7 и 11
[x for x in range(1, 201) if x % 2 == 0 and x % 7 == 0 and x % 11 == 0]

Кстати, такое число всего одно: 154 = 2 * 7 * 11

/// список кортежей типа (type, num) от 1 до 5
[("Нечётное", x) if x % 2 != 0 else ("Чётное", x) for x in range(1,6)]

Надеюсь эти примеры оказались наглядными и помогут вам в понимании темы. Напоминаю, что все примеры с красивой подсветкой синтаксиса можно ещё раз посмотреть тут.

Ну и конечно же спасибо за прочтение, это важно для меня ❤️

#python

Генераторы и comprehensions в Python.

Немного не так подал терминологию в предыдущем посте, на что меня справедливо поправили, спасибо.

Comprehensions ≠ генератор.
Я поспешил упростить теорию, но по хорошему путать эти сущности не нужно. В интернетах ваших часто встречается объяснение comprehensions именно как генераторов, но на самом деле генератор - это уже совершенно иная вещь, о которой я планировал рассказать чуть позже, так что в скором времени будет пост ещё и о них.

На самом деле верно определить list comprehensions как один из вариантов представления списка. Можно получить список в цикле for, например, а можно при помощи list comprehensions. Преимущество такого представления, как я и сказал, в скорости и краткости записи. Но так как эта запись, по сути, возвращает нам новый список, часто её называют генератором, что не верно.

Прошлый пост я поправил, в следующих постах постараюсь больше такого не допускать. Добра вам.

#python

​Представление словарей и множеств.

Совершенно маленькое, но очень полезное дополнение к посту о list comprehensions. Аналогичным способом можно создавать списки и множества. Сразу на примере:

/// список
[x ** 2 for x in range(1, 11)]

/// множество
{x ** 2 for x in range(1, 11)}

/// словарь
{x: x**2 for x in range(1, 11)}

Полная формула для словарей выглядит сложнее:
{ (key if condition else defaultKey):(value if condition
else defaultValue) for key, value in sequence }

А вот для списков она аналогична list comprehensions.

#python