Давайте создадим простую программу для генерации паролей. Мы будем использовать библиотеку secrets для генерации безопасных случайных чисел.

python
import secrets
import string

def generate_password(length):
    alphabet = string.ascii_letters + string.digits + string.punctuation
    password = ''.join(secrets.choice(alphabet) for i in range(length))
    return password

if __name__ == "__main__":
    password_length = int(input("Введите длину пароля: "))
    print(generate_password(password_length))

В этом коде:

- string.ascii_letters содержит все буквы английского алфавита (заглавные и строчные).
- string.digits содержит все цифры от 0 до 9.
- string.punctuation содержит все символы пунктуации.
- secrets.choice(alphabet) выбирает случайный символ из alphabet.
- Мы повторяем выбор случайного символа length раз, чтобы создать пароль нужной длины.

Мы используем secrets вместо random, потому что secrets предназначен для работы с данными, которые требуют большей безопасности, такими как пароли, токены и т.д.

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

Давайте создадим программу, которая реализует алгоритм поиска пути A* для навигации по простой двухмерной сетке.

python
from heapq import heappop, heappush

def heuristic(a, b):
    return abs(b[0] - a[0]) + abs(b[1] - a[1])

def a_star_search(grid, start, goal):
    neighbors = [(0,1),(0,-1),(1,0),(-1,0)]
    close_set = set()
    gscore = {start:0}
    fscore = {start:heuristic(start, goal)}
    oheap = []
    heappush(oheap, (fscore[start], start))
    
    while oheap:
        current = heappop(oheap)[1]

        if current == goal:
            return fscore[goal]
        
        close_set.add(current)
        for i, j in neighbors:
            neighbor = current[0] + i, current[1] + j
            tentative_g_score = gscore[current] + 1
            if 0 <= neighbor[0] < grid.shape[0]:
                if 0 <= neighbor[1] < grid.shape[1]:                
                    if grid[neighbor[0]][neighbor[1]] == 1:
                        continue
                else:
                    continue
            else:
                continue
                
            if neighbor in close_set and tentative_g_score >= gscore.get(neighbor, 0):
                continue
                
            if tentative_g_score < gscore.get(neighbor, 0) or neighbor not in [i[1]for i in oheap]:
                gscore[neighbor] = tentative_g_score
                fscore[neighbor] = tentative_g_score + heuristic(neighbor, goal)
                heappush(oheap, (fscore[neighbor], neighbor))
                
    return False

grid = np.array([
    [0, 1, 0, 0, 0, 0],
    [0, 1, 0, 0, 0, 0],
    [0, 1, 0, 0, 0, 0],
    [0, 0, 0, 0, 1, 0],
    [0, 0, 0, 0, 0, 0],
])

start = (0, 0)
goal = (4, 5)

print(a_star_search(grid, start, goal))

В этом примере:

1. Мы определяем сетку, в которой 0 обозначает открытую клетку, а 1 обозначает заблокированную клетку.
2. Мы задаем начальную и конечную точки.
3. Мы вызываем функцию a_star_search, которая возвращает стоимость кратчайшего пути от начала до конца, если таковой существует.

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

pip install numpy

Как насчет создания простого REST API на Python с использованием Flask? Это будет простое API для работы с пользователями.

python
from flask import Flask, jsonify, request

app = Flask(__name__)

users = []

@app.route('/users', methods=['GET'])
def get_users():
    return jsonify(users)

@app.route('/users', methods=['POST'])
def add_user():
    user = request.json
    users.append(user)
    return {'id': len(users)}, 200

@app.route('/users/<int:user_id>', methods=['GET'])
def get_user(user_id):
    user = users[user_id - 1]
    return user, 200

@app.route('/users/<int:user_id>', methods=['DELETE'])
def delete_user(user_id):
    users.remove(users[user_id - 1])
    return '', 204

if __name__ == "__main__":
    app.run(debug=True)

Это очень простое API с использованием Flask, который включает в себя следующие функции:

- Получение списка всех пользователей (GET /users)
- Добавление нового пользователя (POST /users)
- Получение информации о конкретном пользователе по его ID (GET /users/<user_id>)
- Удаление пользователя по его ID (DELETE /users/<user_id>)

Обратите внимание, что данные хранятся в оперативной памяти и будут потеряны, когда сервер будет остановлен.

Для того чтобы установить Flask, используйте следующую команду pip:

pip install flask

Используйте cURL или Postman для тестирования этого API после его запуска.

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

Давайте создадим простой веб-сервер на Python с использованием базового модуля http.server. Этот веб-сервер будет обрабатывать все запросы и отвечать на них простым текстовым сообщением.

python
from http.server import BaseHTTPRequestHandler, HTTPServer

class SimpleHTTPRequestHandler(BaseHTTPRequestHandler):
    def do_GET(self):
        self.send_response(200)
        self.end_headers()
        self.wfile.write(b'Hello, world!')


def run(server_class=HTTPServer, handler_class=SimpleHTTPRequestHandler, port=8000):
    server_address = ('', port)
    httpd = server_class(server_address, handler_class)
    print(f'Starting httpd server on port {port}')
    httpd.serve_forever()


if __name__ == "__main__":
    run()

Этот скрипт запустит простой веб-сервер на порту 8000 (или на любом другом порту, который вы передадите функции run в качестве аргумента).

Обратите внимание, что это очень простой веб-сервер и не предназначен для использования в реальной среде. Для создания реальных веб-приложений лучше использовать фреймворки веб-разработки Python, такие как Flask или Django.

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

Давайте создадим программу, которая создает простой файл с данными в формате CSV с использованием модуля csv в Python.

python
import csv

def create_csv_file():
    header = ['Name', 'Age', 'Profession']
    data = [
        ['John', '28', 'Engineer'],
        ['Sarah', '32', 'Designer'],
        ['Jim', '35', 'Manager']
    ]

    with open('people.csv', 'w', newline='') as file:
        writer = csv.writer(file)
        writer.writerow(header)
        writer.writerows(data)

    print("CSV file was created successfully!")

if __name__ == "__main__":
    create_csv_file()

В этом коде:

- Мы определяем заголовок CSV файла в списке header.
- Мы определяем данные для CSV файла в списке data.
- Мы открываем файл people.csv в режиме записи.
- Мы создаем объект csv.writer, который облегчает запись данных в CSV.
- Мы пишем заголовок и строки в CSV файл с помощью writerow и writerows.
- Файл закрывается автоматически после завершения блока with.

Этот код создаст файл people.csv в той же директории, где он запущен.

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

Давайте напишем небольшую программу, которая создает график функции с помощью библиотеки Matplotlib.

python
import matplotlib.pyplot as plt
import numpy as np

def draw_plot():
    x = np.linspace(-10, 10, 1000)
    y = np.sin(x)

    plt.plot(x, y)
    plt.title("y = sin(x)")
    plt.xlabel("x")
    plt.ylabel("y")

    plt.grid(True)
    plt.show()

if __name__ == "__main__":
    draw_plot()

В этом коде:

- Мы используем numpy.linspace для создания массива значений x от -10 до 10.
- Мы вычисляем sin(x) для каждого значения в x с помощью numpy.sin.
- Мы строим график y в зависимости от x с помощью matplotlib.pyplot.plot.
- Мы добавляем заголовок и метки осей с помощью title, xlabel и ylabel.
- Мы включаем сетку на графике с помощью grid.
- Мы отображаем график с помощью show.

Перед запуском этого кода убедитесь, что у вас установлены библиотеки numpy и matplotlib. Вы можете установить их, используя pip:

pip install numpy matplotlib

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

python
import cv2

def blur_image():
    # Загружаем изображение
    img = cv2.imread('image.jpg')

    # Применяем гауссово размытие
    blurred_img = cv2.GaussianBlur(img, (15, 15), 0)

    # Сохраняем обработанное изображение
    cv2.imwrite('blurred_image.jpg', blurred_img)

    print("Image has been blurred and saved successfully!")

if __name__ == "__main__":
    blur_image()

В этом коде:

- Мы загружаем изображение с помощью cv2.imread.
- Мы применяем гауссово размытие с помощью cv2.GaussianBlur. Второй аргумент этой функции - это размер ядра, который определяет степень размытия.
- Мы сохраняем обработанное изображение с помощью cv2.imwrite.

Прежде чем запустить этот код, убедитесь, что у вас установлена библиотека OpenCV. Вы можете установить ее, используя pip:

pip install opencv-python

Также убедитесь, что файл 'image.jpg' находится в той же директории, что и ваш скрипт.

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

Давайте создадим классическую игру "Угадай число" на Python. Программа будет генерировать случайное число, а пользователь должен будет угадать это число.

python
import random

def guess_number():
    number_to_guess = random.randint(1, 100)
    guess = None
    while guess != number_to_guess:
        guess = int(input('Guess a number between 1 and 100: '))
        if guess < number_to_guess:
            print("Too low!")
        elif guess > number_to_guess:
            print("Too high!")
    print("Congratulations! You've guessed the number.")

if __name__ == "__main__":
    guess_number()

В этом коде:

- Мы используем функцию random.randint для генерации случайного числа от 1 до 100.
- Мы используем цикл while для повторения запроса на ввод числа от пользователя, пока он не угадает число.
- Если предположение пользователя ниже загаданного числа, программа выводит "Too low!", если выше - "Too high!".
- Когда пользователь угадывает число, программа выводит "Congratulations! You've guessed the number." и цикл заканчивается.

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

Давайте напишем скрипт на Python, который реализует классический алгоритм сортировки - сортировку пузырьком.

python
def bubble_sort(numbers):
    n = len(numbers)

    for i in range(n):
        for j in range(0, n - i - 1):
            if numbers[j] > numbers[j + 1]:
                numbers[j], numbers[j + 1] = numbers[j + 1], numbers[j]

    return numbers

if __name__ == "__main__":
    numbers = [64, 34, 25, 12, 22, 11, 90]
    sorted_numbers = bubble_sort(numbers)
    print(f"Sorted numbers: {sorted_numbers}")

В этом коде:

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

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

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

Давайте создадим Python скрипт, который будет скачивать файл по URL.

Мы будем использовать библиотеку requests для выполнения HTTP запроса и библиотеку os для работы с файловой системой.

python
import os
import requests

def download_file(url):
    response = requests.get(url, stream=True)
    file_size = int(response.headers.get('Content-Length', 0))

    filename = url.split("/")[-1]

    with open(filename, 'wb') as f:
        for data in response.iter_content(1024):
            f.write(data)

    print(f"'{filename}' has been downloaded successfully!")

if __name__ == "__main__":
    url = 'http://example.com/bigfile.dat'  # Replace with your file URL
    download_file(url)

В этом коде:

- Мы создаем GET запрос к URL, указанному в аргументе url.
- Мы получаем размер файла из заголовков ответа.
- Мы извлекаем имя файла из URL.
- Мы открываем файл для записи в бинарном режиме.
- Мы записываем данные в файл по мере их получения.
- В конце мы выводим сообщение о том, что файл успешно скачан.

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

pip install requests

Также замените http://example.com/bigfile.dat на URL файла, который вы хотите скачать.

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

Давайте напишем скрипт, который будет извлекать все ссылки с веб-страницы с использованием модулей requests и BeautifulSoup.

python
import requests
from bs4 import BeautifulSoup

def extract_links(url):
    response = requests.get(url)
    soup = BeautifulSoup(response.text, 'html.parser')

    for link in soup.find_all('a'):
        href = link.get('href')
        if href.startswith('http'):
            print(href)

if __name__ == "__main__":
    url = 'http://example.com'  # Replace with your URL
    extract_links(url)

В этом коде:

- Мы делаем GET запрос к указанному URL.
- Мы создаем объект BeautifulSoup из HTML содержимого ответа.
- Мы находим все теги a (ссылки) на веб-странице с помощью метода find_all.
- Мы извлекаем атрибут href из каждой ссылки, который представляет собой URL.
- Если URL начинается с http, мы выводим его.

Перед запуском этого скрипта убедитесь, что у вас установлены библиотеки requests и beautifulsoup4. Вы можете установить их, используя pip:

pip install requests beautifulsoup4

Также замените http://example.com на URL веб-страницы, с которой вы хотите извлечь ссылки.

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

Окей, давайте создадим простой чат-бота, который будет отвечать на приветствия пользователя. Мы будем использовать библиотеку random для выбора случайного ответа из списка.

python
import random

class ChatBot:
    RESPONSES = [
        "Привет!",
        "Здравствуйте!",
        "Добро пожаловать!",
        "Рад видеть вас!",
        "Приветствую вас!"
    ]

    def greet(self):
        print(random.choice(self.RESPONSES))

if __name__ == "__main__":
    bot = ChatBot()
    while True:
        user_input = input("> ")
        if user_input.lower() in ["привет", "здравствуйте", "добрый день", "добро пожаловать"]:
            bot.greet()
        elif user_input.lower() in ["стоп", "выход", "пока"]:
            break
        else:
            print("Извините, я вас не понимаю.")

В этом коде:

- У нас есть класс ChatBot, который имеет список возможных ответов на приветствия.
- Функция greet выводит случайный ответ из списка.
- В основном блоке кода мы создаем экземпляр чат-бота.
- Мы запрашиваем ввод от пользователя в бесконечном цикле.
- Если ввод пользователя содержит приветствие, бот отвечает приветствием.
- Если ввод пользователя содержит слово для выхода, цикл прекращается.
- Если бот не понимает ввод, он выводит сообщение об ошибке.

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

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

def dfs(graph, start, visited=None):
    if visited is None:
        visited = set()

    visited.add(start)

    print(start)

    for next_node in graph[start] - visited:
        dfs(graph, next_node, visited)

    return visited


if __name__ == "__main__":
    graph = {'A': set(['B', 'C']),
             'B': set(['A', 'E']),
             'C': set(['A', 'F']),
             'E': set(['B', 'F']),
             'F': set(['C', 'E'])}

    dfs(graph, 'A')

В этом коде:

- Функция dfs принимает граф, начальную вершину и список уже посещенных вершин.
- Если список посещенных вершин еще не был инициализирован, мы инициализируем его как пустой set.
- Мы добавляем текущую вершину в список посещенных и выводим ее.
- Для каждой вершины, смежной с текущей и еще не посещенной, мы рекурсивно вызываем dfs.
- В конце мы возвращаем список посещенных вершин.

Запуск этого кода отобразит последовательность вершин, посещенных при обходе в глубину, начиная с вершины 'A'.

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

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

python
import matplotlib.pyplot as plt

def draw_graph():
    x = [1, 2, 3, 4, 5]
    y = [1, 4, 9, 16, 25]

    plt.plot(x, y)
    plt.title('Square Numbers')
    plt.xlabel('Values')
    plt.ylabel('Squares')

    plt.show()

if __name__ == "__main__":
    draw_graph()

В этом коде:

- Мы используем функцию plt.plot для построения графика данных.
- Мы задаем заголовок графика и подписи осей с помощью функций plt.title, plt.xlabel и plt.ylabel.
- В конце мы используем функцию plt.show для отображения графика.

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

pip install matplotlib

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

python
def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n-1)

print(factorial(5))  # Выведет: 120

В этом коде функция factorial вызывает сама себя внутри определения функции. Это и есть рекурсия.

Сначала проверяется базовый случай: если n равно 0, функция просто возвращает 1, потому что факториал 0 равен 1 по определению.

Если n не равно 0, функция возвращает n * factorial(n-1). Это означает, что для вычисления факториала числа n мы умножаем n на факториал от n-1. И так продолжается до тех пор, пока мы не дойдем до 0.

Например, вызов factorial(5) приведет к следующей последовательности вызовов функций:

factorial(5)
5 * factorial(4)
5 * (4 * factorial(3))
5 * (4 * (3 * factorial(2)))
5 * (4 * (3 * (2 * factorial(1))))
5 * (4 * (3 * (2 * (1 * factorial(0)))))
5 * (4 * (3 * (2 * (1 * 1))))
5 * (4 * (3 * (2 * 1)))
5 * (4 * (3 * 2))
5 * (4 * 6)
5 * 24
120

Именно так работает рекурсия!

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

Вот небольшой cheat-sheet на Python для новичков:

1. Основы синтаксиса:
- Вывод на экран: print("Текст")
- Присваивание переменной: имя_переменной = значение
- Комментарии: # Это комментарий

2. Типы данных:
- Числа: целые числа (int), числа с плавающей точкой (float)
- Строки: строковые литералы (str)
- Списки: список значений (list)
- Кортежи: неизменяемые списки (tuple)
- Словари: связь ключей и значений (dictionary)

3. Операторы:
- Математические: +, -, *, /, %, ** (сложение, вычитание, умножение, деление, остаток от деления, возведение в степень)
- Сравнения: ==, !=, >, <, >=, <= (равно, не равно, больше, меньше, больше или равно, меньше или равно)
- Логические: and, or, not (и, или, не)

4. Условные конструкции:
- if, elif, else
- Пример:

     if условие:
         блок кода
     elif другое_условие:
         блок кода
     else:
         блок кода
     

5. Циклы:
- for (для перебора элементов в коллекции)
- while (для выполнения блока кода до тех пор, пока выполняется условие)

6. Функции:
- Определение функции: def имя_функции(аргументы):
- Возвращение значения: return значение

7. Ввод и вывод данных:
- Ввод с клавиатуры: input("Сообщение приглашения")
- Пример:

     name = input("Введите ваше имя: ")
     print("Привет, " + name)
     

8. Работа со строками:
- Сцепление строк: +
- Форматирование строк: f"Текст {переменная}"
- Пример:

     name = "Анна"
     age = 25
     print(f"Меня зовут {name} и мне {age} лет.")
     

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

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

Давайте создадим структуру данных для управления метро.

В этом контексте, можно создать классы для станций, веток и поездов. Станция будет содержать имя; ветка будет содержать имя, цвет, номер и список станций; поезд будет содержать текущую станцию и ветку, на которой он находится.

Начнем с класса Station:

python
class Station:
    def __init__(self, name):
        self.name = name

Теперь создадим класс для ветки:

python
class Line:
    def __init__(self, name, color, number):
        self.name = name
        self.color = color
        self.number = number
        self.stations = []

    def add_station(self, station):
        if not isinstance(station, Station):
            raise ValueError("Argument should be an instance of the 'Station' class.")
        self.stations.append(station)

Теперь, создадим класс для поезда:

python
class Train:
    def __init__(self, line, current_station):
        if not isinstance(line, Line) or not isinstance(current_station, Station):
            raise ValueError("Arguments should be instances of the 'Line' and 'Station' classes.")
        self.line = line
        self.current_station = current_station

    def move_to(self, station):
        if station in self.line.stations:
            self.current_station = station
        else:
            raise ValueError("The train cannot move to a station not on its line.")

Теперь можно создать ветки метро, добавить станции и создать поезда.

Например:

python
# Создание веток
red_line = Line("Red Line", "red", 1)
blue_line = Line("Blue Line", "blue", 2)

# Добавление станций на ветки
red_line.add_station(Station("Station A"))
red_line.add_station(Station("Station B"))
blue_line.add_station(Station("Station C"))
blue_line.add_station(Station("Station D"))

# Создание поездов
train1 = Train(red_line, red_line.stations[0]) # на станции "Station A" красной ветки
train2 = Train(blue_line, blue_line.stations[1]) # на станции "Station D" синей ветки

# Перемещение поезда
train1.move_to(red_line.stations[1]) # перемещение поезда на станцию "Station B"

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

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

Попробуем добавить несколько настоящих веток и станций Московского метро:

python
# Создание веток
sokolnicheskaya_line = Line("Сокольническая линия", "red", 1)
zamoskvoretskaya_line = Line("Замоскворецкая линия", "green", 2)

# Добавление станций на ветки
sokolnicheskaya_line.add_station(Station("Бульвар Рокоссовского"))
sokolnicheskaya_line.add_station(Station("Черкизовская"))
sokolnicheskaya_line.add_station(Station("Преображенская площадь"))

zamoskvoretskaya_line.add_station(Station("Речной вокзал"))
zamoskvoretskaya_line.add_station(Station("Водный стадион"))
zamoskvoretskaya_line.add_station(Station("Войковская"))

# Создание поездов
train1 = Train(sokolnicheskaya_line, sokolnicheskaya_line.stations[0]) # на станции "Бульвар Рокоссовского" Сокольнической линии
train2 = Train(zamoskvoretskaya_line, zamoskvoretskaya_line.stations[1]) # на станции "Водный стадион" Замоскворецкой линии

# Перемещение поезда
train1.move_to(sokolnicheskaya_line.stations[1]) # перемещение поезда на станцию "Черкизовская"

Здесь мы создаем две ветки (Сокольническую и Замоскворецкую) и добавляем три станции на каждую. Затем создаем поезда на этих ветках и перемещаем один из них на другую станцию.

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

Давайте добавим проверку, что станция, на которую хочет переместиться поезд, является соседней для текущей станции поезда. Кроме того, мы добавим атрибут direction в класс Train, который будет указывать направление движения поезда.

python
class Train:
    def __init__(self, line, current_station, direction):
        if not isinstance(line, Line) or not isinstance(current_station, Station):
            raise ValueError("Arguments should be instances of the 'Line' and 'Station' classes.")
        self.line = line
        self.current_station = current_station
        self.direction = direction

    def move_to(self, station):
        if station in self.line.stations:
            # Проверка на соседнюю станцию
            current_station_index = self.line.stations.index(self.current_station)
            destination_station_index = self.line.stations.index(station)
            if abs(destination_station_index - current_station_index) != 1:
                raise ValueError("The train can only move to the next station.")
            # Проверка направления движения
            if (destination_station_index - current_station_index) * self.direction < 0:
                raise ValueError("The train cannot move in the opposite direction.")
            self.current_station = station
        else:
            raise ValueError("The train cannot move to a station not on its line.")

В этом коде, direction - это число, которое равно 1, если поезд движется в прямом направлении (от начала списка станций к концу), и -1, если движение идет в обратном направлении (от конца списка к началу).

Создание и перемещение поезда может выглядеть следующим образом:

python
train1 = Train(sokolnicheskaya_line, sokolnicheskaya_line.stations[0], 1) # на станции "Бульвар Рокоссовского" Сокольнической линии, движение в прямом направлении
train1.move_to(sokolnicheskaya_line.stations[1]) # перемещение поезда на станцию "Черкизовская"

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

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

python
import string
import random

def generate_password(length):
    all_characters = string.ascii_letters + string.digits + string.punctuation
    if length < 4:
        print("Password length should be at least 4 characters.")
        return None
    password = []
    password.append(random.choice(string.ascii_uppercase))
    password.append(random.choice(string.ascii_lowercase))
    password.append(random.choice(string.digits))
    password.append(random.choice(string.punctuation))
    for i in range(length-4):
        password.append(random.choice(all_characters))
    random.shuffle(password)
    return ''.join(password)

print(generate_password(12))  # For example, generate a 12-character password

В этом скрипте мы используем модули string и random. Модуль string содержит различные полезные константы, такие как все буквы алфавита (в верхнем и нижнем регистрах), все цифры и все символы пунктуации.

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

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

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

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