print(True or False) # True
print(True | False)  # True
print(True and False)  # False
print(True & False)  # False

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

def print_and_return(boolean):
	print(boolean)
	return boolean

print("Обычный |")
res1 = print_and_return(True) | print_and_return(False)
print("Словесный or")
res2 = print_and_return(True) or print_and_return(False)

В первом случае, выведутся все 2 значения: результат первой функции, результат второй. А вот во втором случае, нас ждёт сюрприз: второго вызова функции не произойдёт. Почему? Потому что or умеет оптимизировать обработку условий: результат будет истинным независимо от второго условия: ведь первое истинно - так зачем нужно считать второе?

То же самое с and:

  def print_and_return(boolean):
  	print(boolean)
  	return boolean
  
  print("Обычный &")
  res1 = print_and_return(False) & print_and_return(True)
  print("Словесный and")
  res2 = print_and_return(False) and print_and_return(True)

Понятно, что условие ложно после вычисления первого выражения и and пропускает второе, сразу выдавая результат.

Теперь должно стать ясно, что для условий "выгоднее" использовать or и and вместо | и &, кроме тех случаев, когда необходимо выполнение всех частей условия. Например :

(a != 0) and (1 / a)

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

Их можно использовать для inline выражений не только с bool, но и с любыми другими типами, которые приводятся к логическому. Рассмотрим следующие выражения:

print(3 or 10) # 3
print("" or 5) # 5
print("" and 20) # Выведет пустую строку
print(3 and 10) # 10

То есть оператор or работает по принципу: если первое выражение - истина, то возвращаем его, иначе возвращаем второе.

And работает по-другому: если первое - ложь, то возвращаем его, иначе вернём второе.

Думаю, теперь вы разобрались, как работают эти 2 оператора и сможете эффективно использовать их особенности в своих программах.

На этом всё.

До новых встреч в группе SnakeBlog

Примером для дальнейшего описания послужит простенький класс точки на плоскости:

class Point:                                   
  def __init__(self, x, y):                          
    self.x = x                                
    self.y = y 

Давайте, для начала, определим метод __str__ у нашего класса и посмотрим, что выйдет

class Point:                                   
  def __init__(self, x, y):                          
    self.x = x                                
    self.y = y                                
                                         
  def __str__(self, x, y):                           
    return "Point, x={}, y={}".format(x, y)

point = Point(1, 2)
print(point) 

Как мы и ожидаем увидеть, вывод будет следующим:

Point, x=1, y=2

Загвоздка в том, что если мы переименуем __str__ в __repr__, то в выводе изменится... ровно ничего. А теперь давайте определим и тот и другой, но немного по-разному.

class Point:                                   
  def __init__(self, x, y):                          
    self.x = x                                
    self.y = y                                
                                         
  def __repr__(self):                             
    return "repr: Point, x={}, y={}".format(self.x, self.y)         
                                         
  def __str__(self):                              
    return "str: Point, x={}, y={}".format(self.x, self.y)          
                                         
point = Point(5, 6)                               
print(point) 

Вывод будет следующим:

str: Point, x=5, y=6

Значит, при превращении объекта в строку, преимущество имеет __str__, да и его название говорит о том, что это и есть его назначение. Но зачем тогда нужен точно такой же __repr__? Суть в том, что не такой же. Откройте интерпретатор и вставьте туда наш класс. А теперь введите

point = Point(1, 2)
point

Выводом послужит следующая строка:

repr: Point, x=1, y=2

То есть для того, чтобы выводить объект в интерпретаторе, преимущество имеет repr.

Вывод: используйте __str__ для превращения объекта в строку, а __repr__, когда хотите получать какую-то информацию в интерпретаторе при дебаге. Да, они взаимозаменяемы, но созданы они для разных целей.

Тем временем наше маленькое расследование подошло к концу.

Буду рад, если вы подпишетесь на мою группу SnakeBlog

Как вы думаете, что происходит, когда вы пишете следующее выражение?

a = b

Логичным, однако не совсем корректным ответом, будет "переменной a присваивается значение b". Простой пример:

first = [1, 2, 3]
second = first
second[0] = 5
# first = [5, 2, 3]

Если бы second просто присваивалось значение first, то при изменении second first не менялась бы. Однако это произошло. Cуть в том, что в python все объекты передаются по ссылке(а это объекты класса list). То есть для python всё равно, что вы напишете - first или second - они указывают на одну область в памяти и изменения, сделанные в значении одной переменной, отобразятся и во второй. Однако надо понимать разницу между изменением и присвоением ей нового значения:

first = [1, 2, 3]
second = first
second = [2, 3, 4]
# first не изменился

После присвоения second значения [2, 3, 4] эта переменная теперь указывает на новую область памяти и уже никак не связана с first.

Абсолютно тот же механизм использует передача аргументов в функцию:

def change_value(value):
    value[0] = 10
    value = [3, 4, 5]

a = [1, 2, 3]
change_value(a)
# a = [10, 2, 3]

Первая строчка в функции изменяет значение в памяти, а вторая создаёт ссылку на новую область памяти, а значит связь value с a теряется.

Понимание этого механизма может облегчить вам жизнь при работе с данными в Python.

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

a = [[0] * 3] * 3  # a = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]

Однако это не совсем тот список, который мы ожидаем увидеть: список [0, 0, 0] передаётся по ссылке, а значит все три вложенных списка указывают на одну область памяти.

a[0][0] = 1  # [[1, 0, 0], [1, 0, 0], [1, 0, 0]]

Нетрудно заметить, что изменились все 3 списка, то есть толку от них мало. "Правильным" созданием такого списка было бы

a = [[0] * 3 for _ in range(3)]

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

a[0][0] = 1  # [[1, 0, 0], [0, 0, 0], [0, 0, 0]]

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

Подписывайтесь на группу SnakeBlog

Код с подсветкой можете найти на Pastebin:

Файл с функцией: https://pastebin.com/NH5FmLSc

Файл с тестами: https://pastebin.com/BtqXuNiK

Давайте напишем функцию для получения чисел Фибоначчи в файле, который назовём fibonacci.py

def get_fibonacci_numbers(amount):                        
  if amount == 1:                               
    return [1]                                
  result = [1, 1]                               
  for i in range(amount-2):                          
    result.append(result[-1] + result[-2])                  
  return result

Теперь напишем программу, которая будет тестировать эту функцию. Для этого в модуле unittest есть класс TestCase, от которого можно наследоваться и создавать тестирующей класс. У объекта этого класса есть специальные методы вида assert<что-то ещё>, которые сравнивают разные значения с ожидаемыми. Самым распространённым является метод assertEqual, который сравнивает 2 значения и, в случае различия, выдаёт ошибку. Давайте напишем самый простой тест для одного числа в файле fibtest.py

from unittest import TestCase                          
from fibonacci import get_fibonacci_numbers                   
                                         
                                         
class FibonacciTest(TestCase):                        
  def test_single(self):                            
    self.assertEqual(1, get_fibonacci_numbers(1)[0]) 

Мы создаём у этого класса тестирующий метод, название которого обязательно должно начинаться со слова test(требование программы-тестера). Давайте напишем ещё один тест посложнее, который будет проверять всю последовательность на каком-нибудь числе

from unittest import TestCase                          
from fibonacci import get_fibonacci_numbers                   
                                         
                                         
class FibonacciTest(TestCase):                          
  def test_single(self):                            
    self.assertEqual(1, get_fibonacci_numbers(1)[0])             
                                         
  def test_big_number(self):                          
    big_number = 1337                            
    sequence = get_fibonacci_numbers(big_number)               
    self.assertEqual(1, sequence[0])                     
    self.assertEqual(1, sequence[1])                     
    for i in range(2, big_number):                      
      self.assertEqual(sequence[i-1] + sequence[i-2], sequence[i])  

Тесты есть, осталось их запустить. Для этого надо выполнить команду test из модуля unittest на нашем файле:

python -m unittest test fibtest.py

Вывод у команды будет следующего вида:

----------------------------------------------------------------------
Ran 2 tests in 0.003s

OK

Статус OK говорит, что все тесты пройдены успешно. Если бы были ошибки, то там была бы информация о них. Вот так вот можно стандартными средствами тестировать программы.

Надеюсь, статья была вам полезной.

Буду рад видеть вас в группе SnakeBlog

Необходимая информация об API представлена по ссылке api.random.org

Вот на этой странице вы сможете получить токен для API - просто введите свой email и он придёт в письме.

Мы будем пользоваться самым базовым API методом - generateIntegers, который возвращает случайные числа от min до max.

Полный код с подсветкой можете найти на Pastebin

Для начала, импортируем всё необходимое. А нужно нам немного: HTTPSConnection из http.client для того, чтобы отсылать запросы; dumps и loads из json чтобы кодировать и декодировать данные в JSON, который используется этим API.

from http.client import HTTPSConnection                     
from json import dumps, loads                          
                                         
API_TOKEN = 'xxx'# Ваш токен

Теперь давайте создадим словарь с данными для запроса и заголовками. Эти 2 словаря мы запакуем в JSON: теперь они готовы для отправки на сервер.

"""
Больше о формате запроса 
https://api.random.org/json-rpc/1/introduction
"""
request_data = {  # Тело запроса                      
  'jsonrpc': '2.0',                              
  'method': 'generateIntegers',                        
  'params': {                                  
    'apiKey': API_TOKEN,                           
    'min': 1,  # Нижняя граница рандома                       
    'max': 100,  # Верхняя граница        
    'n': 1,  # Количество запрашиваемых чисел          
  },                                      
  'id': 1,                                   
}                                        
encoded_data = dumps(request_data)                        
                                         
headers = {                                
  'Content-Type': 'application/json-rpc',  # Тип запроса              
}                                        
encoded_headers = dumps(headers)  

Теперь непосредственно к обмену данными. Установим соединение и отправим данные:

connection = HTTPSConnection('api.random.org')                  
connection.request('GET', '/json-rpc/1/invoke', encoded_data, headers)  

Получим ответ и распакуем его из JSON:

response = connection.getresponse()                       
response_data = loads(response.read().decode()) 

Если запрос прошёл успешно, то в response_data['result']['random']['data'] будет лежать массив запрошенных чисел. Запрашивали мы одно число, его и выведем на экран.

print(response_data['result']['random']['data'][0])  

Вот так вот просто можно обмениваться данными с любым HTTP API, просто надо внимательно читать описания методов и формата, который требуется.

Жду вас в группе SnakeBlog

Первой я хочу рассмотреть конструкцию lambda. Это способ определения анонимной функции("лямбды", как их ещё называют). Тут слово "анонимный" никак не связано с Роскомнадзором и сетью Tor, просто у таких функций нет имени. Постойте, а как к ним обращаться? А нам это и не нужно, мы хотим просто передать простенькую функцию как аргумент куда-нибудь и забыть про неё.

Объявляются такие функции следующим образом:

lambda <аргументы>: <выражение>

Например вот функция, которая возвращает куб данного числа:

lambda x: x**3

Красиво, просто, пока непонятно зачем. Для примера обратимся к методу sort и сделаем сортировку по обратному значению(даже не спрашивайте зачем).

a = [1, -2, 4, 5, 228, -322]
a.sort(key=lambda x: 1/x)  # [-2, -322, 228, 5, 4, 1]

Теперь перейдём к двум похожим, но разным функциям map и filter, в которые очень часто передают лямбда функции.

map принимает 2 аргумента: функцию и массив, и возвращает список(на самом деле специальный map объект), в котором ко всем элементам массива применили нашу функцию. Так как с map объектом мы ничего интересного сделать не можем, то его мы превратим обратно в список.

a = [1, -2, 4, 5, 228, -322]
mapped = list(map(lambda x: x**2, a))  # Список квадратов чисел

filter принимает всё те же 2 аргумента и возвращает filter объект(который опять же мы превратим в список), в котором остались только те элементы, на которых функция истинна. Например:

a = [1, -2, 4, 5, 228, -322]
filtered = list(filter(lambda x: x < 10, a))  # Список чисел меньше 10

Благодаря этим двум функциям и конструкции lambda можно сократить рутинный код до однострочника. Однако сильно увлекаться этим не стоит, а то рискуете сделать свою программу нечитаемой.

Больше статей в группе SnakeBlog

Немного теории

"Общение" с сервером представляет из себя цепочку запрос-ответ. Мы формируем запрос в специальном HTTP формате, потом отсылаем его на нужный адрес и получаем(или не получаем) ответ от сервера. У адреса есть 2 важные составляющие: домен и метод. Пример: https://api.vk.com/method/messages.send

Домен - https://api.vk.com - это то место в Сети, где располагается наш сервер. Всё, что обращается к нашему домену, будет обрабатываться нашим веб-сервером.

Метод - /method/messages.send - это "функция" нашего сервера, которую мы хотим использовать.

Теперь к делу

Замечание: я пишу команды в консоли в предположении, что ваш интерпретатор называется python , если он называется иначе, то соответственно заменяйте это слово своим названием

Нам понадобится Python и библиотека flask. Её можно установить следующим образом:

python -m pip install flask

Теперь создадим файл app.py , в котором и будет наша программа.

Для начала импортируем в нём модуль Flask из библиотеки flask и создадим объект нашего приложения:

from flask import Flask

app = Flask('hello_world')

Теперь давайте допишем функцию, которая будет отвечать "Hello world!" на запрос к методу /hello_world

from flask import Flask

app = Flask('hello_world')


@app.route('/hello_world')
def hello():
	return "Hello world!"

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

python -m flask run --port 8000

Зайдите теперь в браузер по адресу http://127.0.0.1:8000/hello_world и увидите ту самую строчку. 127.0.0.1 - специальный домен, который отображает наш с вами компьютер, а 8000 - порт нашего подключения.

Эта статья была написана чтобы показать, что веб-сервер - не что-то "волшебное" и очень сложное, а самая обычная программа, к которой мы обращаемся специальным образом. Возможно вы заинтересуетесь темой, тогда вам стоит начать изучать Backend разработку.

До встреч в группе SnakeBlog

C-форматирование

Наверное все, кто программировал на языке C или C++ знают о такой функции, как printf, которая выводит строку, подставляя туда переменные в нужном формате. Чтобы понять о чём я говорю, рассмотрим примеры:

printf("Целое число %d", 5);
printf("Дробное число %f", 2.1);
printf("Строка %s", "какая-то строка");

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

<строка с параметрами>%(<переменные для подстановки>)

Например:

print("%d %f %s"%(1, 2.5, "string")) # Вывод: 1 2.500000 string

Можно записать строку в переменную и потом подставить параметры:

pattern = "%d %f %s"
print(pattern%(2, 3.3, "abc"))  # Вывод: 2 3.300000 abc

Этот способ хорош тем, что можно очень гибко настраивать параметры вывода при помощи модификаторов. Например вот так можно вывести число с точностью 3 знака после запятой:

print("%.3f"%(2.12345))  

Метод format

У строк есть специальный метод format, который выполняет ту же задачу, но немного элегантнее. Он ищет в строке фигурные скобки и подставляет вместо них аргумент. В фигурных скобках можно указать номер аргумента(нумеруются с 0), а можно ничего не указывать и format подставит аргументы по порядку.

Пример:

pattern = "{}:{}:{}"
print(pattern.format(1, 2, 3))  # 1 2 3
another_pattern = "{2}:{1}:{0}"
print(another_pattern.format(1, 2, 3))  # 3 2 1

Этот способ хорош тем, что ему не важен тип аргумента, лишь их порядок.

f-строки

С версии 3.6 существует ещё один способ форматирования. Он очень удобен, однако не без недостатков: подставляет аргументы в строку сразу при объявлении. Рассмотрим пример:

a = 3
b = 2
print(f"{a*b} {a+b} {3*3}")  # 6 5 9

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

Какой из этих способов использовать зависит от вас и от ситуации. В любом случае, один из них точно подойдёт. А эта статья подошла к концу, до встреч в группе SnakeBlog.

Давайте предположим, что у нас есть несколько функций, которые что-то выводят, скажем, логи нашей программы.

from datetime import datetime                          
                                         
                                         
def date_logger(): # Выводит текущую дату и время                
  print(datetime.now().strftime("%Y-%m-%d %H:%M:%S"))             
                                         
                                         
def connection_logger(connected): # Выводит статус соединения          
  if connected:                                
    print("Connected")                            
  else:                                    
    print("Not connected")

Мы где-то используем их в коде. Всё хорошо, но тут заказчик говорит, что перед каждым логом надо выводить "Log:". Зачем? А кто знает, надо и надо.

Конечно можно в начале каждой функции выводить это слово. Однако функций может быть много, а завтра заказчик захочет выводить другое слово. Хочется чего-то более универсального. Тут кто-то предложит глобальную переменную, но это не всегда лучший способ. Сегодня я вам расскажу про другой метод решения этой проблемы и имя ему декоратор.

Давайте рассмотрим следующую функцию - декоратор, которая "оборачивает" другую функцию:

def log_decorator(function):
    def wrapped(*args):  # Вложенная функция-обёртка
        print("Log:", end=' ')
        function(*args)  # Вызываем нашу функцию с параметрами
    return wrapped 

А теперь давайте заменим наши функции на обёрнутые этой.

date_logger = log_decorator(date_logger)
connection_logger = log_decorator(connection_logger)

Действительно, теперь, при вызове будет выводиться "Log: ". Казалось бы, проблема решена. Но как-то не эстетично это выглядит. Поэтому в питоне есть специальный синтаксис для декорации:

@<имя декоратора>
def <декорируемая функция>(...):
	...

То есть наши функции будут выглядеть следующим образом:

@log_decorator
def date_logger():  # Выводит текущую дату и время
	print(datetime.now().strftime("%Y-%m-%d %H:%M:%S"))

@log_decorator
def connection_logger(connected): # Выводит статус соединения
	if connected:
		print("Connected")
	else:
		print("Not connected")

Отлично, но что, если я хочу сделать декоратор с параметром? Здесь надо создать функцию с параметром, которая будет возвращать декоратор. Например так:

def word_log_decorator(word):
   def decorator(function):
       def wrapped(*args):
           print(word, end=': ')
           function(*args)
       return wrapped
   return decorator

Вызывать эту функцию мы будем при декорации следующим образом:

@word_log_decorator("Log")
def date_logger():  # Выводит текущую дату и время
    print(datetime.now().strftime("%Y-%m-%d %H:%M:%S"))

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

Надеюсь, статья была вам полезной.

Надеюсь увидеть вас в моей группе SnakeBlog

for number in fibonacci_numbers:
	print(number)

Наверное у вас появится закономерный вопрос: "Как же так, ведь fibonacci_numbers должен быть ограничен по длине и когда-нибудь цикл закончится?". И вы были бы правы, будь эта переменная списком или чем-то подобным, но в примере выше, она - генератор и не имеет конца. Заинтересовались? Тогда давайте разберёмся, как работает эта сущность в Python.

Для начала, поймём, как работает цикл for. На самом деле, всё, что он делает:

1. Вызывает на нашем объекте "магический" метод __iter__ и получает специальный объект-итератор, у которого есть метод __next__
2. При каждой итерации, этот метод вызывается и значение переменной, указанной нами в цикле обновляется.
3. Итерация прекращается, когда метод __next__ вызывает исключение StopIteration.

То есть, мы можем сделать генератор своими руками. Прикрепляю ссылку на Pastebin потому что там есть подсветка синтаксиса и копировать код оттуда проще.

Код на Pastebin

class FibonacciGenerator:                            
  """                                     
  Класс, объект которого мы будем создавать                  
  """                                     
  class FibonacciIterator:                           
    """                                   
    Вспомогательный класс, который реализует метод __next__         
    Этот метод вызывается на каждой итерации for               
    """                                   
    def __init__(self):                           
      """                                 
      Начинаем нашу последовательность с двух единиц            
      """                                 
      self.first_number = 1                        
      self.second_number = 1                        
      self.iterations = 0                         
                                         
    def __next__(self):                           
      self.iterations += 1                         
      if self.iterations <= 2: # Первые 2 раза мы возвращаем единицу     
        return 1                             
      self.first_number, self.second_number = self.second_number, self.first_number + self.second_number
      return self.second_number                      
                                         
  def __iter__(self):                             
    return self.FibonacciIterator()                     
                                         
fib_gen = FibonacciGenerator()                          
for i in fib_gen:                                
  print(i)

Если вы запустите у себя этот код, то увидите бесконечно выводящиеся числа Фибоначи. Теперь о том, как это работает: for, когда начинает свою работу, вызывает метод __iter__ и получает объект класса FibonacciIterator. На нём, перед каждой итерацией, он запускает метод __next__ и получает следующее число, которое записывается в переменную i. Согласитесь, выглядит не очень красиво.Наверное поэтому в Python существует специальный синтаксис, призванный упростить создание генераторов. Главным средством для этого, является ключевое слово yield. Это как return, но функция не заканчивается, а её состояние запоминается и при вызове __next__ продолжается с того же места. Пример с числами Фибоначи:

Код на Pastebin

def fibonacci_generator():                            
  """                                     
  Эта функция возвращает специальный объект-генератор               
  """                                     
  yield 1                                   
  yield 1                                   
  first, second = 1, 1                             
  while True:                                 
    first, second = second, first + second                  
    yield second                               
                                         
test_generator = fibonacci_generator()                      
for i in test_generator:                             
  print(i)

Эта программа делает всё то же самое. test_generator - объект специального класса generator, который реализует то, что мы описали. Кроме yield есть ещё конструкция yield from <collection>, которая делает yield последовательно каждого элемента <collection>. Выглядит это так:

def yield_from_generator():
	yield from (1,2,3)

Объект, созданный этой функцией вернёт 1, потом 2, потом 3.

Бонус:

У генераторов есть сокращённый синтаксис, как в list comprehensions, но вместо квадратных скобок надо поставить круглые. Например вот генератор квадратов чисел от 1 до 100:

(i**2 for i in range(1, 101))

Генераторы - очень мощный инструмент, который может, при правильном применении, сильно упростить код. Используйте с умом и наслаждайтесь красотой и мощью Python!

До новых встреч в группе SnakeBlog