Программирование с нуля

Как работать с асинхронными запросами в JavaScript: Promises и async/await 🌐

В современной веб-разработке асинхронные операции, такие как запросы к API, играют ключевую роль. JavaScript предоставляет мощные инструменты для работы с асинхронным кодом: Promises (Обещания) и async/await. Давайте разберемся, как их использовать!

### Что такое Promise?

Promise — это объект, который представляет результат асинхронной операции. У него есть три состояния:
- Pending (Ожидание): операция еще не завершена.
- Fulfilled (Выполнено): операция завершена успешно.
- Rejected (Отклонено): операция завершена с ошибкой.

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

const fetchData = new Promise((resolve, reject) => {
    setTimeout(() => {
        const success = true; // Имитация успешного запроса
        if (success) {
            resolve("Данные успешно получены!");
        } else {
            reject("Ошибка при получении данных");
        }
    }, 2000); // Имитация задержки в 2 секунды
});

fetchData
    .then((result) => {
        console.log(result); // Успешный результат
    })
    .catch((error) => {
        console.error(error); // Обработка ошибки
    });

### Что такое async/await?

async/await — это синтаксический сахар над Promise, который делает асинхронный код более читаемым и похожим на синхронный. Ключевое слово async указывает, что функция возвращает Promise, а await приостанавливает выполнение функции до тех пор, пока Promise не будет выполнен.

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

async function fetchData() {
    try {
        const response = await fetch('https://jsonplaceholder.typicode.com/posts/1');
        const data = await response.json();
        console.log(data);
    } catch (error) {
        console.error("Ошибка:", error);
    }
}

fetchData();

Здесь fetchData выполняет асинхронный запрос к API и выводит результат. Если происходит ошибка, она обрабатывается в блоке catch.

### Преимущества async/await

1. Читаемость: Код выглядит как синхронный, что упрощает его понимание.
2. Удобство: Легко обрабатывать ошибки с помощью try/catch.
3. Гибкость: Можно комбинировать с Promise и другими асинхронными конструкциями.

### Когда использовать Promises и async/await?

- Promises: Подходят для простых асинхронных операций или когда нужно работать с несколькими асинхронными задачами одновременно (например, Promise.all).
- async/await: Идеально для сложных асинхронных сценариев, где важна читаемость и последовательность выполнения.

### Пример с Promise.all

Если нужно выполнить несколько асинхронных запросов одновременно:

async function fetchMultipleData() {
    try {
        const [data1, data2] = await Promise.all([
            fetch('https://jsonplaceholder.typicode.com/posts/1').then(res => res.json()),
            fetch('https://jsonplaceholder.typicode.com/posts/2').then(res => res.json())
        ]);
        console.log(data1, data2);
    } catch (error) {
        console.error("Ошибка:", error);
    }
}

fetchMultipleData();

### Заключение

Асинхронное программирование в JavaScript стало проще и удобнее благодаря Promises и async/await. Используйте их, чтобы писать чистый и эффективный код для работы с API и другими асинхронными операциями! 🚀

#JavaScript #AsyncAwait #Promises #АсинхронноеПрограммирование #WebDevelopment

Подписывайтесь на наш канал: @programmirovanies0

45 views12:01

Программирование с нуля

Как использовать генераторы в Python для экономии памяти 🚀

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

### Что такое генератор?

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

### Пример простого генератора

def simple_generator():
    yield 1
    yield 2
    yield 3

gen = simple_generator()
for value in gen:
    print(value)

Вывод:

1
2
3

### Преимущества генераторов

1. Экономия памяти: Генераторы не хранят все значения в памяти, а генерируют их на лету.
2. Ленивые вычисления: Значения вычисляются только тогда, когда они действительно нужны.
3. Удобство: Генераторы позволяют писать более читаемый и компактный код.

### Пример с большими данными

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

def read_large_file(file_path):
    with open(file_path, 'r') as file:
        for line in file:
            yield line.strip()

for line in read_large_file('huge_file.txt'):
    print(line)

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

### Генераторные выражения

Генераторные выражения похожи на списковые включения, но возвращают генератор вместо списка:

gen_exp = (x * x for x in range(10))
for value in gen_exp:
    print(value)

Этот код создаст генератор, который будет возвращать квадраты чисел от 0 до 9.

### Заключение

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

Попробуйте использовать генераторы в своих проектах и убедитесь в их преимуществах! 🚀

#Python #Генераторы #Программирование #Оптимизация #MemoryEfficiency

Подписывайтесь на наш канал: @programmirovanies0

46 views16:01

Программирование с нуля

Как использовать генераторы в Python для экономии памяти 🚀

Генераторы в Python — это мощный инструмент, который позволяет создавать итераторы без необходимости хранить все элементы в памяти. Это особенно полезно при работе с большими объемами данных, когда хранение всего списка в памяти может быть неэффективным.

### Что такое генератор?

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

### Пример простого генератора

def simple_generator():
    yield 1
    yield 2
    yield 3

# Использование генератора
gen = simple_generator()
for value in gen:
    print(value)

Вывод:

1
2
3

### Преимущества генераторов

1. Экономия памяти: Генераторы не хранят все элементы в памяти, а генерируют их на лету.
2. Ленивые вычисления: Элементы вычисляются только тогда, когда они действительно нужны.
3. Удобство: Генераторы позволяют писать более читаемый и компактный код.

### Пример с большими данными

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

def read_large_file(file_path):
    with open(file_path, 'r') as file:
        for line in file:
            yield line.strip()

# Использование генератора для обработки большого файла
for line in read_large_file('large_file.txt'):
    print(line)

### Генераторные выражения

Генераторные выражения похожи на списковые включения, но возвращают генератор вместо списка:

# Списковое включение
squares_list = [x**2 for x in range(10)]

# Генераторное выражение
squares_gen = (x**2 for x in range(10))

# Использование генератора
for square in squares_gen:
    print(square)

### Когда использовать генераторы?

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

Генераторы — это мощный инструмент, который может значительно упростить работу с большими данными и улучшить производительность вашего кода. Попробуйте использовать их в своих проектах! 🚀

#Python #Генераторы #Программирование #Оптимизация #PythonTips

Подписывайтесь на канал @programmirovanies0 для большего количества полезных материалов!

51 views20:01

Программирование с нуля

Как работать с асинхронным программированием в Golang? 🚀

Go (Golang) — это язык, который славится своей простотой и производительностью. Одной из его ключевых особенностей является встроенная поддержка асинхронного программирования с помощью горутин (goroutines) и каналов (channels). Давайте разберем, как это работает и как можно использовать асинхронность в своих проектах.

### Что такое горутины?

Горутины — это легковесные потоки, которые управляются runtime Go. Они позволяют выполнять функции асинхронно, не блокируя основной поток программы. Запустить горутину очень просто — достаточно добавить ключевое слово go перед вызовом функции.

package main

import (
    "fmt"
    "time"
)

func printNumbers() {
    for i := 1; i <= 5; i++ {
        fmt.Println(i)
        time.Sleep(500 * time.Millisecond)
    }
}

func main() {
    go printNumbers() // Запуск горутины
    time.Sleep(3 * time.Second) // Даем горутине время выполниться
    fmt.Println("Главная функция завершена")
}

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

### Каналы для синхронизации

Горутины — это здорово, но как передавать данные между ними? Для этого в Go используются каналы (channels). Каналы позволяют безопасно обмениваться данными между горутинами.

package main

import (
    "fmt"
    "time"
)

func sendData(ch chan string) {
    time.Sleep(2 * time.Second)
    ch <- "Данные отправлены"
}

func main() {
    ch := make(chan string) // Создаем канал
    go sendData(ch)         // Запускаем горутину

    fmt.Println("Ожидание данных...")
    msg := <-ch // Получаем данные из канала
    fmt.Println(msg)
}

Здесь горутина sendData отправляет сообщение в канал, а основная программа ждет его получения.

### Преимущества асинхронного программирования в Go

1. Простота: Горутины и каналы встроены в язык, их легко использовать.
2. Производительность: Go эффективно управляет горутинами, что позволяет создавать высоконагруженные приложения.
3. Безопасность: Каналы обеспечивают безопасный обмен данными между горутинами.

### Когда использовать асинхронность?

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

### Пример с несколькими горутинами

package main

import (
    "fmt"
    "time"
)

func worker(id int, ch chan int) {
    for task := range ch {
        fmt.Printf("Работник %d выполняет задачу %d\n", id, task)
        time.Sleep(time.Second)
    }
}

func main() {
    ch := make(chan int)

    // Запускаем 3 работников
    for i := 1; i <= 3; i++ {
        go worker(i, ch)
    }

    // Отправляем задачи в канал
    for i := 1; i <= 5; i++ {
        ch <- i
    }

    close(ch) // Закрываем канал после завершения
    time.Sleep(2 * time.Second)
    fmt.Println("Все задачи выполнены")
}

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

### Заключение

Асинхронное программирование в Go — это мощный инструмент для создания быстрых и эффективных приложений. Горутины и каналы делают процесс простым и безопасным, даже для начинающих разработчиков.

#Golang #Асинхронность #Горутины #Каналы #Программирование #JuniorPlus

Подписывайтесь на наш канал: @programmirovanies0 🚀

51 views08:39

Программирование с нуля

Как эффективно работать с асинхронным кодом в Python с помощью asyncio �

Асинхронное программирование — мощный инструмент для повышения производительности приложений, особенно когда речь идет о задачах, связанных с вводом-выводом (I/O). В Python для этого используется библиотека asyncio. Давайте разберем, как с ней работать.

### Основы asyncio

asyncio позволяет писать асинхронный код с использованием ключевых слов async и await. Вот простой пример:

import asyncio

async def say_hello():
    print("Hello")
    await asyncio.sleep(1)
    print("World")

async def main():
    await asyncio.gather(say_hello(), say_hello(), say_hello())

asyncio.run(main())

В этом примере функция say_hello выполняется асинхронно три раза. Благодаря await asyncio.sleep(1), программа не блокируется на время ожидания, а переключается на выполнение других задач.

### Когда использовать asyncio?

- Сетевые запросы: HTTP-запросы, взаимодействие с базами данных.
- Работа с файлами: асинхронное чтение/запись.
- Долгие вычисления: если они могут быть разбиты на части.

### Пример: асинхронные HTTP-запросы

import aiohttp
import asyncio

async def fetch(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            return await response.text()

async def main():
    urls = [
        'https://example.com',
        'https://example.org',
        'https://example.net'
    ]
    tasks = [fetch(url) for url in urls]
    results = await asyncio.gather(*tasks)
    for result in results:
        print(result[:100])  # Печатаем первые 100 символов

asyncio.run(main())

Здесь мы используем библиотеку aiohttp для выполнения асинхронных HTTP-запросов. Это позволяет обрабатывать несколько запросов одновременно, что значительно ускоряет выполнение программы.

### Советы по работе с asyncio

1. Избегайте блокирующего кода: Используйте асинхронные библиотеки для всех операций ввода-вывода.
2. Используйте asyncio.gather: Для параллельного выполнения нескольких задач.
3. Обрабатывайте исключения: Используйте try/except для обработки ошибок в асинхронных функциях.

### Заключение

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

#Python #asyncio #АсинхронноеПрограммирование #Программирование #Код

Подписывайтесь на канал @programmirovanies0 для большего количества интересных материалов! 🚀

48 views10:01

Программирование с нуля

🚀 Асинхронное программирование в Python: как не утонуть в Event Loop?

Асинхронное программирование — это мощный инструмент для повышения производительности вашего кода, особенно когда речь идет о задачах, связанных с ожиданием (например, запросы к API, работа с базами данных или файлами). Но как не запутаться в Event Loop и корутинах? Давайте разберемся!

### Что такое Event Loop?
Event Loop — это механизм, который управляет выполнением асинхронных задач. Он следит за тем, какие задачи готовы к выполнению, а какие еще ждут завершения (например, ответа от сервера).

### Пример: асинхронный запрос к API
Представим, что вам нужно сделать несколько запросов к API и обработать их результаты. Синхронный подход будет медленным, так как каждый запрос будет ждать завершения предыдущего. Асинхронный подход позволяет выполнять запросы параллельно.

import aiohttp
import asyncio

async def fetch_data(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            return await response.json()

async def main():
    urls = [
        "https://api.example.com/data1",
        "https://api.example.com/data2",
        "https://api.example.com/data3"
    ]
    
    tasks = [fetch_data(url) for url in urls]
    results = await asyncio.gather(*tasks)
    
    for result in results:
        print(result)

# Запуск Event Loop
asyncio.run(main())

### Что происходит в этом коде?
1. Мы используем библиотеку aiohttp для асинхронных HTTP-запросов.
2. Функция fetch_data выполняет GET-запрос и возвращает JSON-ответ.
3. В main мы создаем список задач (корутин) для каждого URL.
4. asyncio.gather запускает все задачи параллельно и ждет их завершения.
5. Результаты выводятся на экран.

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

### Советы по работе с асинхронным кодом:
1. Используйте await только там, где это действительно нужно.
2. Не забывайте закрывать сессии (например, aiohttp.ClientSession).
3. Используйте asyncio.gather для параллельного выполнения задач.
4. Будьте осторожны с блокирующими операциями (например, работа с файлами) — они могут "заморозить" Event Loop.

### Когда использовать асинхронность?
- Много операций ввода-вывода (I/O-bound задачи).
- Работа с API, базами данных, файлами.
- Высокая нагрузка на сеть.

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

---
💡 Хотите больше полезного контента? Подписывайтесь на наш канал: @programmirovanies0

#Python #Асинхронность #EventLoop #API #Программирование #JuniorPlus

49 views17:58

Программирование с нуля

🔍 Дебаггинг в Golang: как найти ошибку, не теряя рассудка?

Дебаггинг — это как детективное расследование: вы ищете улики, анализируете данные и пытаетесь понять, где программа пошла не так. В Golang есть свои особенности, которые помогут вам быстрее находить и исправлять ошибки. Давайте разберем несколько полезных инструментов и подходов!

### 1. Используйте fmt.Println, но с умом
Простейший способ дебаггинга — это вывод значений переменных в консоль. Однако, если вы добавляете слишком много fmt.Println, код может превратиться в спагетти. Вместо этого используйте структурированное логирование с помощью библиотеки log.

package main

import (
    "log"
    "os"
)

func main() {
    file, err := os.Open("example.txt")
    if err != nil {
        log.Printf("Ошибка при открытии файла: %v", err)
        return
    }
    defer file.Close()

    log.Println("Файл успешно открыт!")
}

### 2. Встроенный дебаггер Delve
Golang имеет мощный инструмент для дебаггинга — Delve. Он позволяет:
- Устанавливать точки останова (breakpoints).
- Шагать по коду (step into, step over).
- Просматривать значения переменных.

Установите Delve:

go install github.com/go-delve/delve/cmd/dlv@latest

Запустите программу в режиме дебаггинга:

dlv debug main.go

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

(dlv) break main.main
(dlv) continue
(dlv) print err

### 3. Паника (panic) и восстановление (recover)
Иногда программа завершается с паникой, и вы не понимаете, почему. Используйте recover, чтобы перехватить панику и получить больше информации.

package main

import "fmt"

func riskyFunction() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Паника перехвачена:", r)
        }
    }()
    panic("Что-то пошло не так!")
}

func main() {
    riskyFunction()
    fmt.Println("Программа продолжает работу.")
}

### 4. Профилирование с помощью pprof
Если программа работает медленно, используйте pprof для анализа производительности.

Добавьте в код:

import _ "net/http/pprof"

Запустите сервер:

go func() {
    log.Println(http.ListenAndServe("localhost:6060", nil))
}()

Теперь вы можете анализировать профили:

go tool pprof http://localhost:6060/debug/pprof/profile

### 5. Советы по дебаггингу
- Читайте сообщения об ошибках внимательно. Они часто содержат ключ к решению проблемы.
- Используйте тесты. Написание unit-тестов помогает находить ошибки на ранних этапах.
- Документируйте код. Хорошо описанный код легче дебаггить.
- Разбивайте код на мелкие функции. Это упрощает поиск ошибок.

---
💡 Хотите больше полезного контента? Подписывайтесь на наш канал: @programmirovanies0

#Golang #Дебаггинг #Delve #pprof #Программирование #JuniorPlus

50 views18:00

Программирование с нуля

🎯 Работа с массивами и объектами в JavaScript: как избежать ошибок и писать чистый код

Массивы и объекты — это основа JavaScript. Они используются повсеместно, но иногда могут вызывать проблемы, особенно если вы не до конца понимаете, как они работают. Давайте разберем несколько полезных приемов и подводных камней!

### 1. Копирование массивов и объектов
Одна из самых частых ошибок — это неправильное копирование массивов и объектов. Если вы просто присвоите массив или объект новой переменной, это будет ссылка, а не копия.

#### Проблема:

const originalArray = [1, 2, 3];
const copiedArray = originalArray;

copiedArray.push(4);
console.log(originalArray); // [1, 2, 3, 4] 😱

#### Решение:
Используйте spread-оператор или метод slice для массивов и Object.assign или JSON.parse(JSON.stringify(...)) для объектов.

// Для массивов
const copiedArray = [...originalArray];
copiedArray.push(4);
console.log(originalArray); // [1, 2, 3] 👍

// Для объектов
const originalObject = { a: 1, b: 2 };
const copiedObject = { ...originalObject };
copiedObject.c = 3;
console.log(originalObject); // { a: 1, b: 2 } 👍

### 2. Итерация по массивам и объектам
JavaScript предлагает множество способов для итерации. Выбор зависит от задачи.

#### Массивы:
- forEach: для простого перебора.
- map: для создания нового массива на основе существующего.
- filter: для фильтрации элементов.

const numbers = [1, 2, 3, 4];

numbers.forEach(num => console.log(num)); // 1, 2, 3, 4

const doubled = numbers.map(num => num * 2);
console.log(doubled); // [2, 4, 6, 8]

const evens = numbers.filter(num => num % 2 === 0);
console.log(evens); // [2, 4]

#### Объекты:
- for...in: для перебора ключей.
- Object.keys, Object.values, Object.entries: для получения ключей, значений или пар ключ-значение.

const user = { name: "Alice", age: 25 };

for (let key in user) {
    console.log(`${key}: ${user[key]}`);
}

const keys = Object.keys(user);
console.log(keys); // ["name", "age"]

const entries = Object.entries(user);
console.log(entries); // [["name", "Alice"], ["age", 25]]

### 3. Глубокая вложенность объектов
Если вы работаете с глубоко вложенными объектами, используйте опциональную цепочку (?.) для безопасного доступа к свойствам.

const user = {
    profile: {
        address: {
            city: "New York"
        }
    }
};

console.log(user.profile?.address?.city); // "New York"
console.log(user.profile?.contacts?.email); // undefined (без ошибки)

### 4. Удаление дубликатов из массива
Для удаления дубликатов используйте Set.

const numbers = [1, 2, 2, 3, 4, 4, 5];
const uniqueNumbers = [...new Set(numbers)];
console.log(uniqueNumbers); // [1, 2, 3, 4, 5]

### 5. Советы по работе с массивами и объектами
- Используйте деструктуризацию для упрощения работы с объектами и массивами.
- Не забывайте про методы reduce, some, every — они могут быть очень полезны.
- Избегайте мутаций (изменения исходных данных), если это не требуется.

---
💡 Хотите больше полезного контента? Подписывайтесь на наш канал: @programmirovanies0

#JavaScript #Массивы #Объекты #Программирование #JuniorPlus #ЧистыйКод

54 views18:01

Программирование с нуля

🚀 Алгоритмы на Python: как эффективно работать с графами?

Графы — это одна из самых мощных структур данных, которая используется в самых разных областях: от социальных сетей до маршрутизации в GPS. Но как эффективно работать с графами на Python? Давайте разберем основные алгоритмы и их реализацию!

### 1. Представление графа
Граф можно представить двумя способами:
- Список смежности: Каждая вершина хранит список своих соседей.
- Матрица смежности: Двумерный массив, где matrix[i][j] = 1, если есть ребро между вершинами i и j.

Пример списка смежности:

graph = {
    'A': ['B', 'C'],
    'B': ['A', 'D', 'E'],
    'C': ['A', 'F'],
    'D': ['B'],
    'E': ['B', 'F'],
    'F': ['C', 'E']
}

### 2. Поиск в глубину (DFS)
DFS используется для обхода графа "вглубь". Он идеально подходит для поиска путей или проверки связности.

def dfs(graph, start, visited=None):
    if visited is None:
        visited = set()
    visited.add(start)
    print(start, end=" ")

    for neighbor in graph[start]:
        if neighbor not in visited:
            dfs(graph, neighbor, visited)

# Пример использования
dfs(graph, 'A')
# Вывод: A B D E F C

### 3. Поиск в ширину (BFS)
BFS обходит граф "вширь" и часто используется для поиска кратчайшего пути в невзвешенном графе.

from collections import deque

def bfs(graph, start):
    visited = set()
    queue = deque([start])
    visited.add(start)

    while queue:
        vertex = queue.popleft()
        print(vertex, end=" ")

        for neighbor in graph[vertex]:
            if neighbor not in visited:
                visited.add(neighbor)
                queue.append(neighbor)

# Пример использования
bfs(graph, 'A')
# Вывод: A B C D E F

### 4. Алгоритм Дейкстры
Если граф взвешенный, и вам нужно найти кратчайший путь, используйте алгоритм Дейкстры.

import heapq

def dijkstra(graph, start):
    distances = {vertex: float('inf') for vertex in graph}
    distances[start] = 0
    queue = [(0, start)]

    while queue:
        current_distance, current_vertex = heapq.heappop(queue)

        if current_distance > distances[current_vertex]:
            continue

        for neighbor, weight in graph[current_vertex].items():
            distance = current_distance + weight

            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(queue, (distance, neighbor))

    return distances

# Пример использования
weighted_graph = {
    'A': {'B': 1, 'C': 4},
    'B': {'A': 1, 'D': 2, 'E': 5},
    'C': {'A': 4, 'F': 3},
    'D': {'B': 2},
    'E': {'B': 5, 'F': 1},
    'F': {'C': 3, 'E': 1}
}

print(dijkstra(weighted_graph, 'A'))
# Вывод: {'A': 0, 'B': 1, 'C': 4, 'D': 3, 'E': 6, 'F': 4}

### 5. Когда использовать графы?
- Социальные сети (поиск друзей, рекомендации).
- Маршрутизация (GPS, сети).
- Рекомендательные системы.
- Задачи оптимизации.

---
💡 Хотите больше полезного контента? Подписывайтесь на наш канал: @programmirovanies0

#Python #Алгоритмы #Графы #DFS #BFS #Дейкстра #Программирование #JuniorPlus

56 views18:02

Программирование с нуля

graph = {
    'A': ['B', 'C'],
    'B': ['A', 'D', 'E'],
    'C': ['A', 'F'],
    'D': ['B'],
    'E': ['B', 'F'],
    'F': ['C', 'E']
}

def dfs(graph, start, visited=None):
    if visited is None:
        visited = set()
    visited.add(start)
    print(start, end=" ")

    for neighbor in graph[start]:
        if neighbor not in visited:
            dfs(graph, neighbor, visited)

# Пример использования
dfs(graph, 'A')
# Вывод: A B D E F C

from collections import deque

def bfs(graph, start):
    visited = set()
    queue = deque([start])
    visited.add(start)

    while queue:
        vertex = queue.popleft()
        print(vertex, end=" ")

        for neighbor in graph[vertex]:
            if neighbor not in visited:
                visited.add(neighbor)
                queue.append(neighbor)

# Пример использования
bfs(graph, 'A')
# Вывод: A B C D E F

import heapq

def dijkstra(graph, start):
    distances = {vertex: float('inf') for vertex in graph}
    distances[start] = 0
    queue = [(0, start)]

    while queue:
        current_distance, current_vertex = heapq.heappop(queue)

        if current_distance > distances[current_vertex]:
            continue

        for neighbor, weight in graph[current_vertex].items():
            distance = current_distance + weight

            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(queue, (distance, neighbor))

    return distances

# Пример использования
weighted_graph = {
    'A': {'B': 1, 'C': 4},
    'B': {'A': 1, 'D': 2, 'E': 5},
    'C': {'A': 4, 'F': 3},
    'D': {'B': 2},
    'E': {'B': 5, 'F': 1},
    'F': {'C': 3, 'E': 1}
}

print(dijkstra(weighted_graph, 'A'))
# Вывод: {'A': 0, 'B': 1, 'C': 4, 'D': 3, 'E': 6, 'F': 4}

61 views18:03

Программирование с нуля

graph = {
    'A': ['B', 'C'],
    'B': ['A', 'D', 'E'],
    'C': ['A', 'F'],
    'D': ['B'],
    'E': ['B', 'F'],
    'F': ['C', 'E']
}

def dfs(graph, start, visited=None):
    if visited is None:
        visited = set()
    visited.add(start)
    print(start, end=" ")

    for neighbor in graph[start]:
        if neighbor not in visited:
            dfs(graph, neighbor, visited)

# Пример использования
dfs(graph, 'A')
# Вывод: A B D E F C

from collections import deque

def bfs(graph, start):
    visited = set()
    queue = deque([start])
    visited.add(start)

    while queue:
        vertex = queue.popleft()
        print(vertex, end=" ")

        for neighbor in graph[vertex]:
            if neighbor not in visited:
                visited.add(neighbor)
                queue.append(neighbor)

# Пример использования
bfs(graph, 'A')
# Вывод: A B C D E F

import heapq

def dijkstra(graph, start):
    distances = {vertex: float('inf') for vertex in graph}
    distances[start] = 0
    queue = [(0, start)]

    while queue:
        current_distance, current_vertex = heapq.heappop(queue)

        if current_distance > distances[current_vertex]:
            continue

        for neighbor, weight in graph[current_vertex].items():
            distance = current_distance + weight

            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(queue, (distance, neighbor))

    return distances

# Пример использования
weighted_graph = {
    'A': {'B': 1, 'C': 4},
    'B': {'A': 1, 'D': 2, 'E': 5},
    'C': {'A': 4, 'F': 3},
    'D': {'B': 2},
    'E': {'B': 5, 'F': 1},
    'F': {'C': 3, 'E': 1}
}

print(dijkstra(weighted_graph, 'A'))
# Вывод: {'A': 0, 'B': 1, 'C': 4, 'D': 3, 'E': 6, 'F': 4}

78 views18:04

Программирование с нуля

graph = {
    'A': ['B', 'C'],
    'B': ['A', 'D', 'E'],
    'C': ['A', 'F'],
    'D': ['B'],
    'E': ['B', 'F'],
    'F': ['C', 'E']
}

def dfs(graph, start, visited=None):
    if visited is None:
        visited = set()
    visited.add(start)
    print(start, end=" ")

    for neighbor in graph[start]:
        if neighbor not in visited:
            dfs(graph, neighbor, visited)

# Пример использования
dfs(graph, 'A')
# Вывод: A B D E F C

from collections import deque

def bfs(graph, start):
    visited = set()
    queue = deque([start])
    visited.add(start)

    while queue:
        vertex = queue.popleft()
        print(vertex, end=" ")

        for neighbor in graph[vertex]:
            if neighbor not in visited:
                visited.add(neighbor)
                queue.append(neighbor)

# Пример использования
bfs(graph, 'A')
# Вывод: A B C D E F

import heapq

def dijkstra(graph, start):
    distances = {vertex: float('inf') for vertex in graph}
    distances[start] = 0
    queue = [(0, start)]

    while queue:
        current_distance, current_vertex = heapq.heappop(queue)

        if current_distance > distances[current_vertex]:
            continue

        for neighbor, weight in graph[current_vertex].items():
            distance = current_distance + weight

            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(queue, (distance, neighbor))

    return distances

# Пример использования
weighted_graph = {
    'A': {'B': 1, 'C': 4},
    'B': {'A': 1, 'D': 2, 'E': 5},
    'C': {'A': 4, 'F': 3},
    'D': {'B': 2},
    'E': {'B': 5, 'F': 1},
    'F': {'C': 3, 'E': 1}
}

print(dijkstra(weighted_graph, 'A'))
# Вывод: {'A': 0, 'B': 1, 'C': 4, 'D': 3, 'E': 6, 'F': 4}

92 views18:04

Программирование с нуля

🚀 Node.js: Как создать REST API с Express и MongoDB?

Создание REST API — это один из ключевых навыков для backend-разработчика. В Node.js с помощью фреймворка Express и базы данных MongoDB это можно сделать быстро и эффективно. Давайте разберем, как создать простое API для управления списком задач!

### 1. Установка зависимостей
Для начала установим необходимые пакеты:

npm init -y
npm install express mongoose body-parser

- express: фреймворк для создания сервера.
- mongoose: библиотека для работы с MongoDB.
- body-parser: middleware для обработки JSON-запросов.

### 2. Подключение к MongoDB
Создадим файл server.js и подключимся к базе данных:

const express = require('express');
const mongoose = require('mongoose');
const bodyParser = require('body-parser');

const app = express();
const PORT = 3000;

// Подключение к MongoDB
mongoose.connect('mongodb://localhost:27017/todoapp', {
    useNewUrlParser: true,
    useUnifiedTopology: true,
});

app.use(bodyParser.json());

app.listen(PORT, () => {
    console.log(`Сервер запущен на http://localhost:${PORT}`);
});

### 3. Создание модели задачи
Определим модель задачи с помощью Mongoose:

const taskSchema = new mongoose.Schema({
    title: String,
    description: String,
    completed: { type: Boolean, default: false },
});

const Task = mongoose.model('Task', taskSchema);

### 4. Создание маршрутов API
Теперь добавим маршруты для создания, чтения, обновления и удаления задач (CRUD).

#### Создание задачи (POST)

app.post('/tasks', async (req, res) => {
    const task = new Task(req.body);
    await task.save();
    res.status(201).send(task);
});

#### Получение всех задач (GET)

app.get('/tasks', async (req, res) => {
    const tasks = await Task.find();
    res.send(tasks);
});

#### Получение задачи по ID (GET)

app.get('/tasks/:id', async (req, res) => {
    const task = await Task.findById(req.params.id);
    if (!task) return res.status(404).send('Задача не найдена');
    res.send(task);
});

#### Обновление задачи (PUT)

app.put('/tasks/:id', async (req, res) => {
    const task = await Task.findByIdAndUpdate(req.params.id, req.body, { new: true });
    if (!task) return res.status(404).send('Задача не найдена');
    res.send(task);
});

#### Удаление задачи (DELETE)

app.delete('/tasks/:id', async (req, res) => {
    const task = await Task.findByIdAndDelete(req.params.id);
    if (!task) return res.status(404).send('Задача не найдена');
    res.send(task);
});

### 5. Запуск сервера
Теперь можно запустить сервер и протестировать API с помощью Postman или curl.

node server.js

### 6. Пример запросов
- Создание задачи:

  curl -X POST -H "Content-Type: application/json" -d '{"title": "Learn Node.js", "description": "Study Express and MongoDB"}' http://localhost:3000/tasks

- Получение всех задач:

  curl http://localhost:3000/tasks

- Обновление задачи:

  curl -X PUT -H "Content-Type: application/json" -d '{"completed": true}' http://localhost:3000/tasks/<task_id>

- Удаление задачи:

  curl -X DELETE http://localhost:3000/tasks/<task_id>

### 7. Советы по улучшению
- Добавьте валидацию данных (например, с помощью библиотеки Joi).
- Реализуйте пагинацию для списка задач.
- Добавьте аутентификацию (например, с помощью JWT).
- Используйте middleware для обработки ошибок.

---
💡 Хотите больше полезного контента? Подписывайтесь на наш канал: @programmirovanies0

#NodeJS #Express #MongoDB #RESTAPI #Программирование #JuniorPlus

127 views18:06

About

Blog

Apps

Platform