现已上线！2025 年 Telegram 研究 — 年度关键洞察 
1 241
订阅者
无数据24 小时
+27 天
+330 天
帖子存档
Основы разработки приложений на базе блокчейн с использованием Hyperledger
В мире, где скорость и безопасность данных становятся приоритетом, блокчейн-технологии приобретают все большую популярность. Однако, когда мы говорим о блокчейн для бизнеса, возникает вопрос: как сделать ее практичной и доступной? Здесь на арену выходит Hyperledger — проект с открытым исходным кодом, разработанный для помощи бизнесу в создании надежных и масштабируемых блокчейн-приложений.
Hyperledger — это своеобразный "швейцарский нож", предлагающий набор инструментов, которые позволяют разработчикам создать частные и общедоступные блокчейн-системы. В отличие от других блокчейн-платформ, таких как Bitcoin или Ethereum, Hyperledger изначально ориентирован на решение бизнес-задач. Он позволяет компаниям создавать сети, где данные доступны только необходимым участникам, что особенно важно для обеспечения конфиденциальности и соблюдения юридических норм.
Прежде чем углубиться в детали, давайте посмотрим на базовые компоненты, которые делают Hyperledger таким мощным инструментом. Главное ядро платформы — это Hyperledger Fabric. Fabric — модульная и адаптируемая архитектура, которая поддерживает выполнение смарт-контрактов на разнообразных языках программирования, включая наш любимый Python.
Давайте рассмотрим небольшой пример, который поможет нам понять принципы работы Hyperledger Fabric. Представьте себе цепочку поставок. Каждый этап — от производителя до конечного покупателя — можно отразить в блокчейн. Каждый участник, будь то поставщик или магазин, получает доступ только к той информации, которая соответствует его роли.
Пример кода для работы со смарт-контрактом в Hyperledger Fabric может выглядеть следующим образом:
from hlf.blockchain import SmartContract, TransactionContext
class SupplyChain(SmartContract):
def __init__(self):
self.records = {}
def create_order(self, context: TransactionContext, order_id, details):
context.stub.put_state(order_id, details)
return f"Order {order_id} created successfully."
def query_order(self, context: TransactionContext, order_id):
details = context.stub.get_state(order_id)
return f"Order Details: {details}"
create_order создает новый заказ, сохраняет его в блокчейн и возвращает подтверждение. Функция query_order позволяет извлечь данные о заказе, что делает процесс быстрым и чистым.
Гибкость Hyperledger проявляется и в его способности интегрироваться с другими системами, что позволяет автоматизировать и оптимизировать операционные процессы компании. Благодаря этому Hyperledger становится идеальной платформой не только для финансовых транзакций, но и для транспортной логистики, медицины и любых других сфер, где важны надёжность и прозрачность данных.
В итоге, если вы заинтересованы в создании безопасных, масштабируемых и высокоэффективных приложений на базе блокчейн, стоит обратить внимание на Hyperledger. Это ваш шанс шагнуть в цифровое будущее, вооружившись современными инструментами и решениями для бизнеса.
Основы разработки приложений на базе блокчейн с использованием Hyperledger.
Ты когда-нибудь задумывался о том, как круто было бы иметь волшебную книгу, которая не только может записывать твои идеи, но и выполнять код прямо на её страницах? Позволь познакомить тебя с Jupyter Notebook — инструментом, который точно оценит каждый, кто занимается исследованием данных.
Jupyter Notebook — это как строительный конструктор для аналитика, предоставляющий гибкость и интерактивность. Он позволяет тебе писать и выполнять код Python прямо из браузера, тут же видеть результаты, и в то же время оставлять текстовые комментарии, графики и диаграммы. Это делает его идеальным инструментом для исследования данных.
Ты спросишь: "А как его установить?" Все просто! Если у тебя установлен Anaconda, то Jupyter уже входит в комплект. В противном случае, достаточно выполнить в командной строке
pip install notebook, и ты в игре.
Откроем наш новоиспеченный Jupyter Notebook, и давайте попробуем простой пример работы с данными. Представь, мы исследуем продажи магазина.
import pandas as pd
import matplotlib.pyplot as plt
# Загрузка данных
sales_data = pd.read_csv('sales.csv')
# Быстрый взгляд на данные
print(sales_data.head())
# Построение графика
plt.figure(figsize=(10, 5))
plt.plot(sales_data['date'], sales_data['revenue'])
plt.title('Sales over Time')
plt.xlabel('Date')
plt.ylabel('Revenue')
plt.show()
%matplotlib inline — поставив эту строку в начале твоей блокноты, ты будешь видеть графики прямо в ноутбуке без дополнительных вызовов отображения.
А теперь представь, что ты можешь делиться этой магией с коллегами или друзьями! Jupyter Notebook легко экспортируется в различные форматы, включая PDF и HTML. При нажатии буквально пары кнопок твои исследования становятся доступными и понятными каждому, кто хочет в них погрузиться.
Подводя итог: Jupyter Notebook — это не просто инструмент, это целая среда для экспериментов и изучения. Он позволяет сосредоточиться на главном — исследовании данных, минимизируя отвлекающие факторы. Однажды попробовав, ты уже не захочешь возвращаться к прежним способам анализа. Открой для себя мир данных по-новому!
Привет, любители Python! Сегодня мы погрузимся в увлекательный мир параллельного программирования с модулем
concurrent.futures. Представьте себе, что ваш код может работать быстрее, разделяя задачи между несколькими потоками или процессами. Модуль concurrent в Python предоставляет простой и мощный интерфейс для реализации этих возможностей.
Итак, что делает concurrent.futures таким особенным? Это библиотека для запуска параллельных задач с использованием пулов потоков (ThreadPoolExecutor) и процессов (ProcessPoolExecutor). Большое преимущество этого модуля в том, что он заботится о сложной части параллельного программирования, что позволяет вам сосредоточиться на задачах, которые должны выполняться параллельно.
Начнем с ThreadPoolExecutor. Он позволяет запускать задачи в отдельные потоки, что полезно, когда вы хотите улучшить производительность I/O-зависимых задач, таких как сетевые запросы.
from concurrent.futures import ThreadPoolExecutor
import requests
urls = ['https://www.example.com', 'https://www.test.com', 'https://www.python.org']
def fetch_url(url):
response = requests.get(url)
return url, response.status_code
with ThreadPoolExecutor(max_workers=3) as executor:
results = executor.map(fetch_url, urls)
for result in results:
print(result)
ThreadPoolExecutor помогает конвейеризировать скачивание веб-страниц. Мы передаем функцию fetch_url и список URL-ов в executor.map(), и он управляет выполнением задач в отдельных потоках.
Теперь перейдем к ProcessPoolExecutor. Этот инструмент полезен для CPU-зависимых задач, таких как вычислительные операции, поскольку процессы запускаются в отдельные пространства памяти, что позволяет обойти ограничения GIL (Глобальная блокировка интерпретатора) в Python.
from concurrent.futures import ProcessPoolExecutor
import math
numbers = [1000000 + x for x in range(10)]
def is_prime(n):
if n <= 1:
return False
for factor in range(2, int(math.sqrt(n)) + 1):
if n % factor == 0:
return False
return True
with ProcessPoolExecutor(max_workers=4) as executor:
results = list(executor.map(is_prime, numbers))
print(results)
is_prime для нескольких чисел, существенно сокращая общее время работы программы.
Используя concurrent.futures, вы можете значительно улучшить производительность вашего приложения. Главное — понять, какие задачи требуют потоков, а какие — процессов. Попробуйте интегрировать эти инструменты в ваши проекты и почувствуйте силу параллелизма!
Попрактикуйтесь с concurrent.futures, и ваш Python-код станет еще более мощным!
В мире программирования паттерны проектирования словно тайные ингредиенты в рецепте успеха. Они помогают решать распространенные проблемы и улучшать архитектуру кода. Сегодня мы заглянем под капот Python и выясним, как эти узоры могут сделать ваши проекты более структурированными и удобными в сопровождении.
Начнем с "Factory Method" — когда нам нужна фабрика для создания объектов. Представьте, что вы создаете игру с разными персонажами. Вместо того чтобы загромождать код созданием каждого типа персонажа, мы создаем фабрику, которая будет отвечать за это.
class CharacterFactory:
def create_character(self, type):
if type == 'knight':
return Knight()
elif type == 'archer':
return Archer()
else:
return None
class Singleton:
_instance = None
def __new__(cls):
if cls._instance is None:
cls._instance = super(Singleton, cls).__new__(cls)
return cls._instance
def sugar_decorator(coffee_func):
def wrapper():
return coffee_func() + ' + sugar'
return wrapper
@sugar_decorator
def make_coffee():
return 'coffee'
class Subject:
def __init__(self):
self._observers = []
def register(self, observer):
self._observers.append(observer)
def notify(self, data):
for observer in self._observers:
observer.update(data)
Произошла ошибка на сервере! Сообщите администратору сайта!Error code: 500 - {'error': {'message': 'Timed out generating response. Please try again with a shorter prompt or with
max_tokens set to a lower value.', 'type': 'internalerror', 'param': None, 'code': 'requesttimeout'}}
💡 Изучение структуры данных обрабатываемого графа с NetworkX
Всем привет! Сегодня мы погружаемся в увлекательный мир графов, а помогать нам в этом будет невероятно мощный инструмент — библиотека NetworkX. Если вы когда-нибудь задавались вопросом, как визуализировать и анализировать сложные сетевые структуры, то этот пост для вас!
### Что такое граф?
Прежде всего, давайте разберёмся с тем, что такое граф. В контексте программирования граф — это набор узлов (или вершин), соединённых рёбрами. Графы могут представлять такие разнообразные структуры, как социальные сети, транспортные маршруты, электрические схемы и многое другое.
### Знакомство с NetworkX
NetworkX — это Python-библиотека, которая делает работу с графами интуитивно понятной. Одной из главных её прелестей является возможность легко создавать и манипулировать как простыми, так и сложными графовыми структурами. Давайте посмотрим, как это можно сделать на практике.
import networkx as nx
# Создаём новый граф
graph = nx.Graph()
# Добавляем узлы
graph.add_node(1)
graph.add_node(2)
# Добавляем рёбра
graph.add_edge(1, 2)
# Вывод всех узлов и рёбер
print("Nodes:", graph.nodes())
print("Edges:", graph.edges())
# Добавим больше узлов и рёбер
graph.add_edges_from([(2, 3), (3, 4)])
neighbors = list(graph.neighbors(2))
print("Neighbors of node 2:", neighbors)
shortest_path = nx.shortest_path(graph, source=1, target=4)
print("Shortest path from 1 to 4:", shortest_path)
import matplotlib.pyplot as plt
nx.draw(graph, with_labels=True)
plt.show()
