Как работает этот ТГ канал?

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

WHILE интерес == TRUE { Пишите код and становитесь лучше в разработке }

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

Тенденции в вакансиях игровой индустрии: Недельный обзор

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

Unity и Unreal Engine остаются ключевыми инструментами для разработчиков игр, с 34 и 9 упоминаниями соответственно.

Навыки разработки в целом остаются в высоком спросе, как отмечено 34 раза, включая упоминания "developer" и "lead" для ролей разработчика и руководителя проектов.

Графический дизайн и визуализация также остаются важными, с упоминаниями "artist", "designer", "Adobe" и "Blender".

Важность мобильной разработки подчеркнута 4 упоминаниями "mobile", а технологии Python и React также упоминаются, указывая на их роль в бэкенд-сервисах и инструментальных интерфейсах.

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

Давайте рассмотрим реализацию алгоритма сортировки пузырьком на двух популярных языках программирования: Python и Java.

Python:

python
def bubbleSort(arr):
    n = len(arr)
 
    for i in range(n):
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1] :
                arr[j], arr[j+1] = arr[j+1], arr[j]
                
arr = [64, 34, 25, 12, 22, 11, 90]
bubbleSort(arr)
 
print ("Sorted array is:")
for i in range(len(arr)):
    print ("%d" %arr[i], end = " ")

Java:

java
public class BubbleSort 
{ 
    void bubbleSort(int arr[]) 
    { 
        int n = arr.length; 
        for (int i = 0; i < n-1; i++) 
            for (int j = 0; j < n-i-1; j++) 
                if (arr[j] > arr[j+1]) 
                { 
                    int temp = arr[j]; 
                    arr[j] = arr[j+1]; 
                    arr[j+1] = temp; 
                } 
    } 

    public static void main(String args[]) 
    { 
        BubbleSort bs = new BubbleSort(); 
        int arr[] = {64, 34, 25, 12, 22, 11, 90}; 
        bs.bubbleSort(arr); 
        System.out.println("Sorted array"); 
        int n = arr.length; 
        for (int i=0; i<n; ++i) 
            System.out.print(arr[i] + " "); 
    } 
}

Преимущества и недостатки:

Python является интерпретируемым языком, что означает, что он обрабатывается во время выполнения, а не перед ним. Благодаря этому, код на Python обычно более короткий и читаемый, чем на многих других языках. Это особенно заметно в реализации алгоритма сортировки пузырьком, где Python позволяет легко и быстро обменивать элементы местами.

Java, напротив, является статически типизированным, компилируемым языком. Это означает, что он обычно работает быстрее Python, особенно на больших и сложных проектах. Однако, код на Java обычно длиннее и менее читаемый.

Допустим, мы имеем следующий код на языке Python:

python
def func(l):
    for i in range(len(l)):
        if l[i] == 0:
            l.pop(i)
    return l

Этот код написан с целью удалить все нули из списка. Но он содержит серьезную ошибку: он изменяет список во время его перебора. Это может привести к непредсказуемым результатам и ошибкам в выполнении кода.

Вот исправленная версия этого кода:

python
def func(l):
    return [i for i in l if i != 0]

В этой версии мы используем генератор списка (list comprehension) для создания нового списка, который содержит все элементы исходного списка, кроме нулей. Это более эффективно и безопасно, поскольку мы не изменяем исходный список во время его перебора.

Давайте рассмотрим пример кода на Python, который использует несколько базовых концепций и функций этого языка. Этот код будет генерировать Фибоначчиеву последовательность до заданного числа.

python
def fibonacci(n):
    fib_sequence = [0, 1]
    while len(fib_sequence) < n:
        fib_sequence.append(fib_sequence[-1] + fib_sequence[-2])
    return fib_sequence

print(fibonacci(10))

Вот что делает этот код:

1. Определяется функция fibonacci(n), которая принимает один параметр: n - количество чисел Фибоначчи, которые мы хотим сгенерировать.
2. Внутри функции создается список fib_sequence с двумя начальными значениями последовательности Фибоначчи: 0 и 1.
3. Затем в цикле while добавляются новые элементы в список. Каждый новый элемент - это сумма двух последних элементов списка. Это основное свойство последовательности Фибоначчи.
4. Цикл продолжается до тех пор, пока количество элементов в списке не достигнет n.
5. Функция возвращает список с последовательностью Фибоначчи.

Наконец, мы вызываем эту функцию с аргументом 10, чтобы сгенерировать первые 10 чисел Фибоначчи и выводим результат на экран с помощью функции print().

Давайте рассмотрим пример простого веб-скрейпера на Python, использующего библиотеку Beautiful Soup для извлечения данных из веб-страницы.

python
import requests
from bs4 import BeautifulSoup

url = 'https://www.example.com'

response = requests.get(url)

soup = BeautifulSoup(response.text, 'html.parser')

for link in soup.find_all('a'):
    print(link.get('href'))

Этот скрипт делает следующее:

1. Импортирует необходимые библиотеки: requests для выполнения HTTP-запросов и BeautifulSoup из модуля bs4 для обработки HTML.

2. Определяет URL веб-страницы, с которой мы хотим извлечь данные.

3. Выполняет GET-запрос к указанному URL и сохраняет ответ в переменной response.

4. Создает объект BeautifulSoup, который представляет документ в виде вложенной структуры данных, что упрощает работу с HTML-кодом.

5. В цикле перебирает все теги <a> (ссылки) на странице, найденные с помощью метода find_all объекта BeautifulSoup.

6. Выводит атрибут href каждой ссылки, который обычно содержит URL-адрес, на который ведет ссылка.

Пожалуйста, обратите внимание, что этот пример использует 'https://www.example.com' в качестве заглушки для URL. В реальном коде вы должны заменить его на URL сайта, с которого хотите скрейпить данные. Имейте в виду, что скрейпинг веб-сайтов может быть юридически сложным, и перед использованием скрейпера вы должны убедиться, что его использование не нарушает условия использования сайта.

Рассмотрим пример кода на Python, который использует нейронную сеть для классификации образцов из набора данных MNIST (распространенный набор данных, состоящий из рукописных цифр). Для этого мы будем использовать библиотеку Keras, что сильно упрощает процесс.

python
import tensorflow.keras as keras

# Загружаем набор данных MNIST
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

# Нормализуем данные
x_train = x_train / 255.0
x_test = x_test / 255.0

# Создаем модель
model = keras.models.Sequential([
  keras.layers.Flatten(input_shape=(28, 28)),
  keras.layers.Dense(128, activation='relu'),
  keras.layers.Dropout(0.2),
  keras.layers.Dense(10)
])

# Компилируем модель
model.compile(optimizer='adam',
              loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

# Обучаем модель
model.fit(x_train, y_train, epochs=5)

# Оцениваем модель
model.evaluate(x_test, y_test)

Этот скрипт выполняет следующие действия:

1. Загружает набор данных MNIST с помощью встроенной функции load_data() из Keras. Данные разбиваются на обучающий и тестовый наборы.

2. Нормализует данные изображений, делая все значения пикселей между 0 и 1.

3. Создает простую нейронную сеть, состоящую из входного слоя, преобразующего каждое изображение в одномерный массив (28x28 пикселей), скрытого слоя с 128 нейронами и функцией активации ReLU, слоя Dropout для предотвращения переобучения и выходного слоя с 10 нейронами (по одному для каждой цифры от 0 до 9).

4. Компилирует модель с оптимизатором Adam, функцией потерь для мультиклассовой классификации (SparseCategoricalCrossentropy) и метрикой для отслеживания точности.

5. Обучает модель на обучающих данных с использованием 5 эпох.

6. Оценивает модель на тестовых данных и печатает потери и точность.

Это базовый пример нейронной сети с помощью Keras. В реальности вам, скорее всего, потребуется больше настройки и анализа для создания эффективной модели для конкретной задачи.

Давайте рассмотрим другой пример использования нейронных сетей на Python. Мы создадим простую модель для решения задачи бинарной классификации, то есть задачи, где есть два возможных класса или ответа. Мы будем использовать набор данных, который встроен в библиотеку Keras - это набор данных о раке груди из UCI Machine Learning Repository.

python
import numpy as np
import tensorflow.keras as keras

# Загружаем набор данных о раке груди из sklearn
from sklearn.datasets import load_breast_cancer
data = load_breast_cancer()

# Разделяем данные на признаки и целевую переменную
X = data.data
Y = data.target

# Нормализуем данные
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X = sc.fit_transform(X)

# Разбиваем данные на обучающую и тестовую выборку
from sklearn.model_selection import train_test_split
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size = 0.2, random_state = 0)

# Создаем модель
model = keras.models.Sequential([
    keras.layers.Dense(16, activation='relu', input_shape=(X_train.shape[1],)),
    keras.layers.Dense(1, activation='sigmoid')
])

# Компилируем модель
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Обучаем модель
model.fit(X_train, Y_train, epochs=50)

# Оцениваем модель
model.evaluate(X_test, Y_test)

Вот что делает этот скрипт:

1. Загружает набор данных о раке груди с помощью встроенной функции load_breast_cancer() из sklearn. Данные разбиваются на признаки (X) и целевую переменную (Y).

2. Нормализует данные с помощью StandardScaler из sklearn. Это приводит все признаки к одному и тому же масштабу.

3. Разделяет данные на обучающий и тестовый наборы.

4. Создает простую нейронную сеть с одним скрытым слоем, содержащим 16 нейронов и функцией активации ReLU, и выходным слоем с одним нейроном и функцией активации sigmoid (что хорошо подходит для бинарной классификации).

5. Компилирует модель с оптимизатором Adam, функцией потерь binary_crossentropy (хорошо подходит для задач бинарной классификации) и метрикой для отслеживания точности.

6. Обучает модель на обучающих данных с использованием 50 эпох.

Прошу прощения за прерывание. Вот продолжение последней строки:

7. Оценивает модель на тестовых данных и выводит потери и точность.

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

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

Вот пример простейшей нейронной сети с одним скрытым слоем, реализованной на чистом Python:

python
import numpy as np

def sigmoid(x):
    return 1.0/(1+ np.exp(-x))

def sigmoid_derivative(x):
    return x * (1.0 - x)

class NeuralNetwork:
    def __init__(self, x, y):
        self.input = x
        self.weights1 = np.random.rand(self.input.shape[1],4) 
        self.weights2 = np.random.rand(4,1)                 
        self.y = y
        self.output = np.zeros(self.y.shape)

    def feedforward(self):
        self.layer1 = sigmoid(np.dot(self.input, self.weights1))
        self.output = sigmoid(np.dot(self.layer1, self.weights2))

    def backprop(self):
        d_weights2 = np.dot(self.layer1.T, (2*(self.y - self.output) * sigmoid_derivative(self.output)))
        d_weights1 = np.dot(self.input.T,  (np.dot(2*(self.y - self.output) * sigmoid_derivative(self.output), self.weights2.T) * sigmoid_derivative(self.layer1)))

        self.weights1 += d_weights1
        self.weights2 += d_weights2


X = np.array([[0,0,1],
              [0,1,1],
              [1,0,1],
              [1,1,1]])
y = np.array([[0],[1],[1],[0]])
nn = NeuralNetwork(X,y)

for i in range(1500):
    nn.feedforward()
    nn.backprop()

print(nn.output)

Этот скрипт создает простую нейронную сеть с одним скрытым слоем и обучает ее с помощью алгоритма обратного распространения ошибки.

1. Функции sigmoid и sigmoid_derivative используются как функции активации и их производные.

2. Класс NeuralNetwork инициализируется с входными данными, весами для двух слоев сети, вектором целевых значений и пустым вектором для вывода сети.

3. Метод feedforward выполняет прямое распространение входного сигнала через сеть и сохраняет вывод.

4. Метод backprop реализует алгоритм обратного распространения ошибки, который корректирует веса сети на основе ошибки между ее текущим и желаемым выходом.

5. Далее мы определяем входные данные и целевые значения, создаем объект нейронной сети и выполняем 1500 итераций прямого распространения и обратного распространения.

6. Наконец, мы выводим полученные предсказания сети.

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

Важно отметить, что это простой пример, и его не следует использовать для решения сложных проблем машинного обучения. В реальных задачах рекомендуется использовать библиотеки машинного обучения, такие как TensorFlow, Keras или PyTorch, которые содержат множество оптимизаций и могут работать на GPU, что значительно ускоряет обучение и инференцию.

Давайте создадим простую полносвязную нейронную сеть с помощью библиотеки PyTorch. Эта нейронная сеть будет классифицировать изображения из набора данных MNIST.

python
import torch
from torchvision import datasets, transforms
from torch import nn, optim

# Загружаем данные
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])
trainset = datasets.MNIST('~/.pytorch/MNIST_data/', download=True, train=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)

# Определяем модель
model = nn.Sequential(nn.Linear(784, 128),
                      nn.ReLU(),
                      nn.Linear(128, 64),
                      nn.ReLU(),
                      nn.Linear(64, 10),
                      nn.LogSoftmax(dim=1))

# Определяем функцию потерь и оптимизатор
criterion = nn.NLLLoss()
optimizer = optim.SGD(model.parameters(), lr=0.003)

# Обучаем модель
epochs = 5
for e in range(epochs):
    running_loss = 0
    for images, labels in trainloader:
        # Переформатируем images из набора размером (batch_size, 1, 28, 28) в вектор размером (batch_size, 784)
        images = images.view(images.shape[0], -1)
    
        optimizer.zero_grad()
        
        output = model(images)
        loss = criterion(output, labels)
        loss.backward()
        optimizer.step()
        
        running_loss += loss.item()
    else:
        print(f"Training loss: {running_loss/len(trainloader)}")

Вот что делает этот скрипт:

1. Сначала мы загружаем набор данных MNIST с помощью torchvision, нормализуем его и создаем DataLoader.

2. Затем мы определяем модель. В этом случае мы используем полносвязную (или "плотную") нейронную сеть с двумя скрытыми слоями и функцией активации ReLU. Выходной слой использует LogSoftmax для получения вероятностей для каждого класса.

3. Мы определяем функцию потерь (в этом случае, отрицательную логарифмическую вероятность, или NLL) и оптимизатор (SGD - стохастический градиентный спуск).

4. Затем мы обучаем модель за 5 эпох, пройдя по всем изображениям и меткам в trainloader. Мы переформатируем каждое изображение в вектор, затем запускаем его через модель, вычисляем потери, делаем обратный проход и обновляем веса модели.

5. В конце каждой эпохи мы выводим среднюю потерю во время обучения.

Пожалуйста, обратите внимание, что для выполнения этого кода у вас должны быть установлены библиотеки PyTorch и torchvision.

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

Рассмотрим пример на Python. Допустим, у нас есть список, и мы хотим удалить из него все дубликаты.

Неоптимальный вариант:

python
def remove_duplicates(lst):
    result = []
    for item in lst:
        if item not in result:
            result.append(item)
    return result

print(remove_duplicates([1, 2, 2, 3, 4, 4, 4, 5, 6, 6, 7]))

В этом примере функция remove_duplicates проходит по каждому элементу списка и проверяет, есть ли он уже в результирующем списке. Если нет, то элемент добавляется. Это работает, но неэффективно, потому что операция item not in result требует прохода по всему списку result на каждой итерации, что делает сложность алгоритма O(n^2).

Оптимизированный вариант:

python
def remove_duplicates(lst):
    return list(set(lst))

print(remove_duplicates([1, 2, 2, 3, 4, 4, 4, 5, 6, 6, 7]))

В этом случае мы используем структуру данных set, которая автоматически удаляет все дубликаты. После этого мы просто преобразуем set обратно в список. Этот алгоритм имеет сложность O(n), что значительно быстрее предыдущего варианта, особенно для больших списков.

Однако стоит учесть, что set не сохраняет порядок элементов, так что если порядок важен, этот вариант не подойдет. В этом случае можно использовать dict или collections.OrderedDict (в Python 3.7 и выше порядок вставки элементов сохраняется в dict):

python
def remove_duplicates(lst):
    return list(dict.fromkeys(lst))

print(remove_duplicates([1, 2, 2, 3, 4, 4, 4, 5, 6, 6, 7]))

Этот вариант также имеет сложность O(n), но сохраняет порядок элементов.

Вот пример "необычного" кода на Python. Он называется "quine". Quine — это программа, которая выводит свой собственный исходный код. Вот пример простого quine на Python:

python
def quine():
    q = 'def quine():\n    q = {!r}\n    print(q.format(q))\nquine()'
    print(q.format(q))

quine()

Вот что делает этот код:

1. Он определяет функцию quine().
2. Внутри этой функции он определяет строку q, которая содержит исходный код функции quine(), где сама строка q представлена в виде {!r}. {!r} — это placeholder для представления строки в виде строки, экранирующей специальные символы и обрамляющей её в кавычки.
3. Функция quine() затем выводит q.format(q), заменяя {!r} на саму строку q, что даёт нам исходный код функции quine().
4. Наконец, он вызывает функцию quine(), чтобы начать всю эту процедуру.

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

Интересный фильм о технологиях, искусственном интеллекте и сфере digital

Социальная дилемма (2020) - зависимость от социальных сетей возникает не случайно. Популярные приложения манипулируют нами, залезая вглубь подсознания и пользуясь его уязвимостью, о которой многие даже не подозревают. Документальная лента раскрывает тёмную сторону социальных сетей, рассказывая о неоднозначном влиянии информационных технологий.

QR коды – это двумерные коды, используемые для хранения информации. Они обычно состоят из черных квадратов на белом фоне, которые могут быть прочитаны камерой на смартфоне или специализированным программным обеспечением. Информация в QR кодах может быть текстом, ссылкой на веб-сайт или другими данными.

Чтобы парсить QR коды, нам понадобится использовать библиотеку, которая умеет распознавать эти коды. В Python, одной из популярных библиотек для этого является pyzbar.

Вот простой пример кода, который использует pyzbar и opencv для чтения QR кода из изображения:

python
from pyzbar.pyzbar import decode
import cv2

def decode_qr_code(image_path):
    img = cv2.imread(image_path)
    decoded_objects = decode(img)
    for obj in decoded_objects:
        print('Type:', obj.type)
        print('Data:', obj.data.decode('utf-8'))

decode_qr_code('path_to_your_qr_code_image.jpg')

В этом коде:
- cv2.imread(image_path) считывает изображение с QR-кодом.
- decode(img) выполняет декодирование QR-кода.
- for obj in decoded_objects: перебирает все обнаруженные на изображении QR-коды (если их больше одного).
- 'Type:', obj.type показывает тип кода (QR-код, штрих-код и т.д.).
- 'Data:', obj.data.decode('utf-8') выводит данные, которые были закодированы в QR-коде.

Обратите внимание, что для работы этого кода у вас должны быть установлены библиотеки pyzbar и opencv. Вы можете установить их с помощью pip:

bash
pip install opencv-python
pip install pyzbar

QR-коды используют встроенные механизмы коррекции ошибок, основанные на кодах Рида-Соломона, которые позволяют восстановить данные даже при частичном повреждении или загрязнении. Их можно настроить на разные уровни коррекции ошибок: L (7%), M (15%), Q (25%) и H (30%). Более высокий уровень коррекции ошибок означает, что больше информации может быть восстановлено, но это также уменьшает количество информации, которую можно хранить в QR-коде.

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

Пример простой проверки контрольной суммы на Python:

python
def checksum(data):
    return sum(data) % 256

data = [123, 3, 44, 125, 0, 99]
original_checksum = checksum(data)

# Впоследствии, когда мы получим данные, мы можем проверить их целостность:
received_data = [123, 3, 44, 125, 0, 99]  # Предположим, это те же данные
received_checksum = checksum(received_data)

if original_checksum == received_checksum:
    print("Данные целы")
else:
    print("Данные повреждены")

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

Для чтения штрих-кода с использованием Python, можно использовать библиотеку под названием Pyzbar. Вот простой код для этой операции:

python
from pyzbar.pyzbar import decode
from PIL import Image

def read_barcode(file):
    image = Image.open(file)
    result = decode(image)
    for barcode in result:
        print("Тип штрих-кода: ", barcode.type)
        print("Данные штрих-кода: ", barcode.data.decode('utf-8'))

read_barcode('path_to_your_barcode_image.jpg')

В этом коде выполняются следующие действия:

1. Сначала импортируются необходимые библиотеки. Pyzbar используется для распознавания штрих-кода, а PIL (Python Imaging Library) используется для работы с изображениями.

2. Затем определяется функция read_barcode, которая принимает в качестве аргумента путь к файлу изображения.

3. В этой функции изображение открывается с использованием функции Image.open из PIL.

4. Затем функция decode из Pyzbar используется для распознавания штрих-кодов на изображении. Она возвращает список найденных штрих-кодов.

5. Далее мы перебираем все найденные штрих-коды и выводим их тип и данные.

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

Для чтения штрих-кодов в реальном времени, можно использовать библиотеку OpenCV вместе с Pyzbar. Вот базовый код для чтения штрих-кодов с веб-камеры:

python
import cv2
from pyzbar.pyzbar import decode

cap = cv2.VideoCapture(0)  # открывает камеру по умолчанию

while True:
    ret, frame = cap.read()  # читает кадр с камеры
    for barcode in decode(frame):
        print("Тип штрих-кода: ", barcode.type)
        print("Данные штрих-кода: ", barcode.data.decode('utf-8'))
        (x, y, w, h) = barcode.rect  # координаты штрих-кода
        cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)  # обводим штрих-код зеленым прямоугольником

    cv2.imshow('Camera', frame)  # отображаем кадр на экране

    if cv2.waitKey(1) & 0xFF == ord('q'):  # если нажать 'q', то цикл завершается
        break

cap.release()  # освобождаем ресурс камеры
cv2.destroyAllWindows()  # закрываем все окна

В этом коде делаются следующие вещи:

1. Сначала импортируются необходимые библиотеки: cv2 (OpenCV) для работы с изображениями и видео, и pyzbar.pyzbar для распознавания штрих-кодов.

2. Затем открывается поток видео с камеры с помощью функции cv2.VideoCapture.

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

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

5. Полученный кадр с возможным штрих-кодом отображается на экране.

6. Если пользователь нажимает 'q', то цикл завершается, и ресурсы, занятые камерой, освобождаются.

Обратите внимание, что данный код не содержит обработку исключений и может не работать корректно, если камера не доступна или возникают другие проблемы. В реальном приложении следует добавить соответствующую обработку исключений.

Простой блокчейн может быть реализован на Python так:

python
import hashlib
import time

class Block:
    def __init__(self, index, previous_hash, timestamp, data, hash):
        self.index = index
        self.previous_hash = previous_hash
        self.timestamp = timestamp
        self.data = data
        self.hash = hash


def calculate_hash(index, previous_hash, timestamp, data):
    value = str(index) + str(previous_hash) + str(timestamp) + str(data)
    return hashlib.sha256(value.encode('utf-8')).hexdigest()


def create_genesis_block():
    return Block(0, "0", int(time.time()), "Genesis Block", calculate_hash(0, "0", int(time.time()), "Genesis Block"))


def create_new_block(previous_block, data):
    index = previous_block.index + 1
    timestamp = int(time.time())
    hash = calculate_hash(index, previous_block.hash, timestamp, data)
    return Block(index, previous_block.hash, timestamp, data, hash)


# создаем блокчейн и добавляем генезис блок
blockchain = [create_genesis_block()]
previous_block = blockchain[0]

# добавляем блоки в блокчейн
num_blocks_to_add = 10
for i in range(0, num_blocks_to_add):
    block_to_add = create_new_block(previous_block, f"Block #{i} has been added to the blockchain!")
    blockchain.append(block_to_add)
    previous_block = block_to_add
    print(f"Block #{block_to_add.index} has been added to the blockchain!")
    print(f"Hash: {block_to_add.hash}\n")

Объяснение:

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

2. calculate_hash - это функция, которая используется для создания хеша для блока. Она использует функцию sha256 из модуля hashlib для создания хеша из строкового представления индекса блока, хеша предыдущего блока, временной метки и данных.

3. create_genesis_block - это функция, которая создает первый блок в блокчейне, называемый "генезис блоком". Этот блок обычно имеет заранее заданные значения, и у него нет предыдущего блока.

4. create_new_block - это функция, которая создает новый блок на основе предыдущего блока и некоторых данных.

5. Наконец, код создает блокчейн, добавляет генезис блок, а затем добавляет еще 10 блоков, каждый из которых ссылается на предыдущий блок.

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

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

Подпишись 👉🏻 @KodduuPython 🤖

Предположим, что у нас есть система, которая отслеживает приход и уход сотрудников, и мы хотим использовать блокчейн, чтобы гарантировать, что эта информация не может быть изменена. Ниже представлен код на Python, который демонстрирует это:

python
import hashlib
import time

class Block:
    def __init__(self, index, previous_hash, timestamp, data, hash):
        self.index = index
        self.previous_hash = previous_hash
        self.timestamp = timestamp
        self.data = data
        self.hash = hash

def calculate_hash(index, previous_hash, timestamp, data):
    value = str(index) + str(previous_hash) + str(timestamp) + str(data)
    return hashlib.sha256(value.encode('utf-8')).hexdigest()

def create_genesis_block():
    return Block(0, "0", int(time.time()), {"employee_id": "0", "action": "Genesis Block", "time": int(time.time())}, calculate_hash(0, "0", int(time.time()), "Genesis Block"))

def create_new_block(previous_block, data):
    index = previous_block.index + 1
    timestamp = int(time.time())
    hash = calculate_hash(index, previous_block.hash, timestamp, data)
    return Block(index, previous_block.hash, timestamp, data, hash)

blockchain = [create_genesis_block()]
previous_block = blockchain[0]

def log_event(employee_id, action):
    data = {
        "employee_id": employee_id,
        "action": action,
        "time": int(time.time())
    }
    block_to_add = create_new_block(previous_block, data)
    blockchain.append(block_to_add)
    print(f"Employee #{data['employee_id']} has {data['action']} at {data['time']}")
    return block_to_add

# Пример использования:

previous_block = log_event("123", "entered office")
previous_block = log_event("123", "left office")
previous_block = log_event("456", "entered office")

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

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

В зависимости от модели дрона, который вы хотите управлять, будут различные библиотеки и API, которые вы можете использовать. Однако, вот простой пример кода, который бы использовался для управления дроном с помощью библиотеки python-ardrone.

Эта библиотека специально разработана для управления дронами Parrot AR.Drone:

python
import time
from ardrone import ARDrone

# Инициализируем класс ARDrone
drone = ARDrone()

# Стартуем двигатели дрона
drone.takeoff()

# Пауза, чтобы дать дрону время на поднятие в воздух
time.sleep(3)

# Дрон движется вперед
drone.move_forward()
time.sleep(1)

# Дрон поворачивает налево
drone.turn_left()
time.sleep(1)

# Дрон движется назад
drone.move_backward()
time.sleep(1)

# Дрон поворачивает направо
drone.turn_right()
time.sleep(1)

# Дрон приземляется
drone.land()
time.sleep(1)

# Отключаем двигатели
drone.halt()

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

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

Подпишись 👉🏻 @KodduuPython 🤖