Python е един от най-популярните езици за програмиране. Той е лесен за научаване и предлага много полезни функции.

Една от важните задачи в програмирането е работата с дата и час. Много приложения изискват тази информация за различни цели.

В тази статия ще научите как да получите текущата дата и час в Python. Ще разгледаме няколко метода и ще обясним всеки от тях.

1. Защо е важно да получаваме текущата дата и час?

Работата с дата и час е полезна в много случаи. Например:

• Записване на времето на дадено събитие
• Изчисляване на разлика между дати
• Организиране на данни по време
• Генериране на уникални идентификатори

Python предоставя няколко начина за работа с дата и час. Най-често използваните са модулите datetime, time и calendar.

Работата с дата и час е важна част от много програми.

Python предлага вградени инструменти за работа с дата и време.

Ще научим как да използваме тези инструменти по прост и разбираем начин.

Тази статия е подходяща за начинаещи в програмирането с Python.

Основни концепции

Първо трябва да разберем какво представлява модулът datetime в Python.

Модулът datetime е вграден инструмент в Python за работа с дати.

Той ни позволява да създаваме, манипулираме и форматираме дати и часове.

За да използваме този модул, първо трябва да го импортираме в нашата програма.

Импортиране на необходимите модули

Нека започнем с импортирането на модула datetime.

from datetime import datetime

Този ред код ни дава достъп до всички функции за работа с дата.

Можем също да импортираме целия модул по следния начин:

import datetime

Разликата между двата начина е в това как достъпваме функциите след това.

Получаване на текущата дата и час

За да вземем текущата дата и час, използваме метода now().

current_datetime = datetime.now()

Този ред създава обект, съдържащ информация за текущата дата и час.

Можем да отпечатаме резултата директно на екрана:

print(current_datetime)

Резултатът ще изглежда примерно така: 2025-02-20 14:30:45.123456

Достъп до отделните компоненти

От обекта datetime можем да извлечем различни части от датата.

Година

current_year = current_datetime.year

Този код ни дава текущата година като число.

Месец

current_month = current_datetime.month

Получаваме номера на текущия месец (1-12).

Ден

current_day = current_datetime.day

Така взимаме деня от месеца като число.

Час

current_hour = current_datetime.hour

Часът се връща във 24-часов формат (0-23).

Минути

current_minute = current_datetime.minute

Получаваме текущите минути като число (0-59).

Секунди

current_second = current_datetime.second

Секундите също са достъпни като число (0-59).

Форматиране на датата

Python позволява да форматираме датата по различни начини.

Методът strftime() ни помага да представим датата в желания формат.

Ето някои често използвани формати:

# Форматиране на датата
formatted_date = current_datetime.strftime("%d/%m/%Y")

Този код ще покаже датата във формат ДД/ММ/ГГГГ.

# Форматиране на часа
formatted_time = current_datetime.strftime("%H:%M:%S")

Този формат показва часа във вид ЧЧ:ММ:СС.

Работа с времеви зони

Python позволява работа с различни времеви зони.

За целта трябва да импортираме допълнителен модул pytz.

from datetime import datetime
import pytz

Можем да създадем обект за конкретна времева зона:

timezone = pytz.timezone('Europe/Sofia')

След това получаваме местното време за тази зона:

local_time = datetime.now(timezone)

Практически примери

Нека разгледаме няколко практически примера за работа с дати.

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

from datetime import datetime

current_date = datetime.now()
print(f"Днес е: {current_date.strftime('%d/%m/%Y')}")

Този код ще покаже днешната дата във формат ДД/ММ/ГГГГ.

Пример 2: Показване на текущия час

from datetime import datetime

current_time = datetime.now()
print(f"Часът е: {current_time.strftime('%H:%M')}")

Кодът извежда текущия час във формат ЧЧ:ММ.

Часът е: 08:01

Пример 3: Пълна информация за датата

from datetime import datetime

now = datetime.now()
print(f"Ден: {now.day}")
print(f"Месец: {now.month}")
print(f"Година: {now.year}")
print(f"Час: {now.hour}")
print(f"Минути: {now.minute}")

Това ще покаже нещо подобно:

Ден: 20
Месец: 2
Година: 2025
Час: 7
Минути: 59

Често срещани грешки

Начинаещите често правят някои типични грешки при работа с дати.

Нека разгледаме как да ги избегнем.

Грешка 1: Неправилно импортиране

Грешно:

import datetime.datetime

Правилно:

from datetime import datetime

Грешка 2: Объркване на формати

Грешно:

date_string = datetime.now().strftime("%Y-%d-%m")

Правилно:

date_string = datetime.now().strftime("%Y-%m-%d")

Полезни съвети

Винаги проверявайте документацията за точните формати на датата.

Използвайте подходящи имена на променливите за по-добра читаемост.

Коментирайте кода си, за да обясните какво прави всяка част.

Тествайте кода с различни входни данни.

Допълнителни функции

Python предлага още много полезни функции за работа с дати.

Сравняване на дати

Можем да сравняваме дати използвайки стандартните оператори.

date1 = datetime.now()
date2 = datetime(2025, 1, 1)

if date1 > date2:
    print("Първата дата е по-късно")

Изчисляване на разлика между дати

from datetime import timedelta

tomorrow = datetime.now() + timedelta(days=1)

Заключение

Работата с дати и часове в Python е лесна с подходящите инструменти.

Модулът datetime предоставя всички необходими функции за манипулация на дати.

Важно е да разбираме основните концепции и формати.

Практиката е ключът към успешното усвояване на тези умения.

Допълнителни ресурси

Официалната документация на Python е отличен източник за повече информация.

Онлайн форумите предлагат много примери и решения.

Практическите упражнения помагат за затвърждаване на наученото.

Експериментирайте с различни формати и функции за по-добро разбиране.

Материалът Как да получите текущата дата и час в Python е публикуван за пръв път на The Fedya' s page.

Python 3.14 носи значителни подобрения в скоростта на изпълнение на програмите. Новият интерпретатор прави кода с 3 до 30% по-бърз. Това е важна стъпка напред за езика, който става все по-предпочитан за разработчиците.

В тази статия ще разгледаме основните промени в Python 3.14. Ще обясним как новият интерпретатор подобрява производителността и какви предимства носи за разработчиците.

Какво представлява интерпретаторът на Python?

Интерпретаторът е програмата, която изпълнява Python кода. Той превежда изходния код в машинни инструкции, които компютърът разбира.

Python традиционно използва CPython като основен интерпретатор. Всяка нова версия на езика се стреми да подобри скоростта и ефективността на този интерпретатор.

С Python 3.14 идват значителни подобрения, които увеличават бързодействието на езика.

Как Python 3.14 ускорява изпълнението на кода?

1. Оптимизация на байткода

Python използва байткод – междинен код, който се изпълнява от интерпретатора. В новата версия байткодът е по-ефективен.

Това води до по-бързо изпълнение на програмите, защото процесорът обработва инструкциите по-оптимално.

2. Подобрено управление на паметта

Python 3.14 използва нови алгоритми за управление на паметта. Това намалява времето, необходимо за освобождаване и разпределение на паметта.

Резултатът е по-гладка работа на програмите, особено при работа с големи обеми данни.

3. По-бърза интерпретация на кода

Новият интерпретатор намалява времето за обработка на инструкциите. Това означава, че Python кодът се изпълнява с по-малко забавяне.

Тази промяна е особено полезна за интерактивни приложения и програми, които изискват бърза реакция.

4. Подобрена работа с многопоточност

Python 3.14 прави работата с нишки (threads) по-ефективна. Това е важно за приложения, които изпълняват паралелни задачи.

Тази промяна води до по-добра производителност при многозадачност и по-добро използване на процесорните ядра.

Какви са предимствата за разработчиците?

1. По-бързо изпълнение на скриптове

Python 3.14 намалява времето за изпълнение на кода, което е полезно за всички програмисти.

Това позволява по-ефективно разработване и тестване на приложения.

2. По-добра производителност на уеб приложения

Много уеб платформи, като Django и Flask, ще работят по-бързо с новата версия.

Това подобрява работата на сървъри и намалява времето за обработка на заявки.

3. Оптимизация за машинно обучение

Python е широко използван в областта на машинното обучение. По-бързият интерпретатор намалява времето за изпълнение на модели и анализи.

Това е от голямо значение за научни изчисления и изкуствен интелект.

4. По-лесно мащабиране на приложения

С по-бърза интерпретация на кода, Python 3.14 улеснява разгръщането на мащабни приложения.

Големи проекти, които обработват голям обем данни, ще работят по-ефективно.

Сравнение на производителността с предишни версии

Python 3.14 е значително по-бърз от предходните версии.

Тези резултати показват, че Python 3.14 предлага значително подобрение.

Как да преминем към Python 3.14?

1. Актуализиране на съществуващата инсталация

Потребителите могат да обновят Python чрез следната команда:

pip install --upgrade python

На Linux и macOS може да се използва:

sudo apt update && sudo apt upgrade python3

2. Проверка на версията

След обновяване, проверете инсталираната версия с командата:

python --version

Трябва да видите съобщение като:

Python 3.14.0

3. Тестване на съвместимостта на кода

Някои библиотеки може да изискват промени. Препоръчително е да се тества съвместимостта на проектите преди пълната миграция.

Заключение

Python 3.14 предлага значителни подобрения в скоростта на изпълнение на кода. Новият интерпретатор прави програмите с 3 до 30% по-бързи.

Това улеснява разработката на уеб приложения, машинно обучение и мащабни проекти.

Препоръчително е всички разработчици да обновят своите среди към най-новата версия.

Python продължава да се развива, предлагайки по-добра производителност и нови възможности.

Материалът Python 3.14 предлага нов интерпретатор с 3~30% по-бърз код е публикуван за пръв път на The Fedya' s page.

Урок 7: Уеб разработка с Flask в Python

В този урок ще се запознаем със Flask – микро уеб рамка за Python, която позволява бързо и лесно създаване на уеб приложения. Ще научим как да създадем базово уеб приложение с Flask, как да работим с шаблони и как да изграждаме API.

Въведение в Flask

Flask е лека и гъвкава уеб рамка за Python, която е идеална за създаване на малки и средни уеб приложения. Тя предлага минималистичен подход към разработката на уеб приложения, като по този начин е лесна за изучаване и употреба.

Инсталиране на Flask

За да започнем, трябва да инсталираме Flask. Можем да го направим чрез pip:

pip install Flask

Създаване на базово уеб приложение

Основен файл на приложението

Създайте файл с име app.py и добавете следния код:

from flask import Flask

# Създаване на инстанция на Flask
app = Flask(__name__)

# Дефиниране на маршрути и функции за тях
@app.route('/')
def index():
    return 'Welcome to my Flask App!'

@app.route('/about')
def about():
    return 'This is an about page.'

# Стартиране на приложението
if __name__ == '__main__':
    app.run(debug=True)

Обяснение

• Flask е импортиран от библиотеката flask.
• app = Flask(__name__) създава инстанция на Flask приложение.
• @app.route('/') и @app.route('/about') са декоратори, които асоциират URL маршрутите с функции.
• Всяка функция, маркирана с декоратора @app.route(), се изпълнява при достъпване на съответния URL път.
• app.run(debug=True) стартира уеб приложението в режим на отладка.

Шаблони и рендериране

Flask позволява използването на HTML шаблони за по-добро организиране на уеб приложението.

Създаване на папка за шаблони

Създайте нова папка templates в директорията на проекта. В нея ще съхранявате HTML шаблоните на вашето приложение.

Използване на шаблони

Променете файлът app.py, за да включите използването на шаблони:

from flask import Flask, render_template

app = Flask(__name__)

@app.route('/')
def index():
    return render_template('index.html', title='Home', content='Welcome to my Flask App!')

@app.route('/about')
def about():
    return render_template('about.html', title='About')

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

Пример на шаблон index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{{ title }}</title>
</head>
<body>
    <h1>{{ content }}</h1>
</body>
</html>

Пример на шаблон about.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{{ title }}</title>
</head>
<body>
    <h1>About Page</h1>
    <p>This is an about page for my Flask App.</p>
</body>
</html>

Изграждане на API с Flask

Flask позволява лесно създаване на API чрез връзките между маршрути и функции.

Пример за API

from flask import Flask, jsonify

app = Flask(__name__)

# Пример за данни
books = [
    {'title': 'Python Programming', 'author': 'Guido van Rossum'},
    {'title': 'Flask Essentials', 'author': 'O'Reilly Media'}
]

@app.route('/api/books', methods=['GET'])
def get_books():
    return jsonify(books)

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

Обяснение

• jsonify() конвертира Python обекти в JSON формат.
• Методът get_books() връща списък от книги в JSON формат при достъпване на URL път /api/books.

Решения за стартиране на Flask приложение, което продължава да работи след затваряне на терминала:

Когато стартирате Flask приложение в терминала и след това затворите терминала или излезете от сесията, приложението спира да работи, защото то е свързано с текущата сесия на терминала. Когато тази сесия приключи, всички свързани с нея процеси, включително Flask приложението, също спират.

1. Използване на nohup:

Можете да използвате командата nohup, за да стартирате Flask приложението и да го отделите от терминалната сесия. Това ще позволи на приложението да продължи да работи дори след като затворите терминала.

nohup python3 app.py &

• nohup (no hang up): Приложението ще продължи да работи след затваряне на терминала.
• &: Това ще стартира приложението на заден план, така че да можете да продължите да използвате терминала за други задачи.

2. Използване на screen:

Можете да използвате screen, за да стартирате Flask приложението в нова сесия, която продължава да работи след затваряне на терминала.

1. Инсталирайте screen, ако още не е инсталиран:

sudo apt-get install screen

2. Стартирайте нова screen сесия:

screen

3. Стартирайте Flask приложението:

python3 app.py

4. За да се отделите от сесията, без да я прекъсвате, натиснете Ctrl + A, последвано от D.

5. Можете да се върнете в сесията по-късно с командата:

screen -r

Настройка на Flask с Gunicorn

Flask по подразбиране използва вградения си уеб сървър, който не е предназначен за използване в производствени среди поддържа само една връзка. За да може вашето Flask приложение да обслужва множество връзки и да бъде по-устойчиво в производствени условия, трябва да го използвате заедно с по-стабилен уеб сървър и/или WSGI сървър като Gunicorn или uWSGI.

Стъпки за настройка на Flask с Gunicorn

Gunicorn е WSGI сървър, който е подходящ за производствени среди и може да обработва множество връзки едновременно.

1. Инсталиране на Gunicorn

Първо, инсталирайте Gunicorn с помощта на pip:

pip3 install gunicorn

2. Стартиране на Flask приложението с Gunicorn

След като инсталирате Gunicorn, можете да стартирате вашето Flask приложение с него:

gunicorn -w 4 -b 0.0.0.0:8000 app:app

-w 4: Задава броя на работните процеси (workers). В този случай използваме 4 работни процеси. Броят на работниците зависи от броя на ядрата на вашия процесор. Общо правило е да използвате 2-4 работници на ядро.

-b 0.0.0.0:8000: Свързва приложението на всички IP адреси на порт 8000

.app:app: Това казва на Gunicorn да зареди обекта app от модула app.py.

Заключение

В този урок научихме как да създадем базово уеб приложение с Flask, как да работим с HTML шаблони и как да изградим прост API. Flask предоставя множество възможности за разширяване на функционалността и създаване на различни типове уеб приложения. Практикувайте редовно и експериментирайте с различни маршрути и шаблони, за да затвърдите наученото.

Материалът Уеб разработка с Flask в Python е публикуван за пръв път на The Fedya' s page.

Урок 6: Работа с бази данни в Python

В този урок ще разгледаме как да работим с бази данни в Python. Ще научим как да създаваме и манипулираме бази данни, както и как да използваме SQL за заявяване и управление на данни. Ще използваме SQLite, вградена база данни, която не изисква допълнителна инсталация и е идеална за обучение и малки проекти.

Запознаване със SQLite

SQLite е лека библиотека за релационни бази данни, която се съхранява в един файл на диска. Тя е чудесна за прототипиране, тестване и малки приложения.

Инсталиране на SQLite

SQLite е включен в стандартната библиотека на Python, така че не е необходимо допълнително инсталиране. Ще използваме модула sqlite3 за работа с базата данни.

Свързване с база данни

Първата стъпка е да се свържем с база данни. Ако базата данни не съществува, тя ще бъде създадена.

import sqlite3

# Свързване с база данни
conn = sqlite3.connect('example.db')

# Създаване на курсор
cursor = conn.cursor()

Създаване на таблица

Създаваме таблица, като изпълним SQL заявка с метода execute().

# Създаване на таблица
cursor.execute('''CREATE TABLE IF NOT EXISTS users (
                    id INTEGER PRIMARY KEY,
                    name TEXT NOT NULL,
                    age INTEGER NOT NULL
                )''')

# Потвърждаване на промените
conn.commit()

Добавяне на записи

Можем да добавяме записи в таблицата с SQL командата INSERT.

# Добавяне на записи
cursor.execute("INSERT INTO users (name, age) VALUES (?, ?)", ("Alice", 30))
cursor.execute("INSERT INTO users (name, age) VALUES (?, ?)", ("Bob", 25))

# Потвърждаване на промените
conn.commit()

Четене на записи

Можем да четем данни от таблицата с командата SELECT.

# Четене на всички записи
cursor.execute("SELECT * FROM users")
rows = cursor.fetchall()

for row in rows:
    print(row)

Актуализиране на записи

За актуализиране на данни използваме командата UPDATE.

# Актуализиране на запис
cursor.execute("UPDATE users SET age = ? WHERE name = ?", (35, "Alice"))

# Потвърждаване на промените
conn.commit()

Изтриване на записи

За изтриване на данни използваме командата DELETE.

# Изтриване на запис
cursor.execute("DELETE FROM users WHERE name = ?", ("Bob",))

# Потвърждаване на промените
conn.commit()

Затваряне на връзката

След като приключим с работата с базата данни, трябва да затворим връзката.

# Затваряне на връзката
conn.close()

Примерна програма: Управление на потребители

Нека създадем програма за управление на потребители, която използва SQLite за съхранение на данни.

Дефиниране на функции

database.py

import sqlite3

def connect():
    return sqlite3.connect('users.db')

def create_table(conn):
    cursor = conn.cursor()
    cursor.execute('''CREATE TABLE IF NOT EXISTS users (
                        id INTEGER PRIMARY KEY,
                        name TEXT NOT NULL,
                        age INTEGER NOT NULL
                    )''')
    conn.commit()

def add_user(conn, name, age):
    cursor = conn.cursor()
    cursor.execute("INSERT INTO users (name, age) VALUES (?, ?)", (name, age))
    conn.commit()

def get_users(conn):
    cursor = conn.cursor()
    cursor.execute("SELECT * FROM users")
    return cursor.fetchall()

def update_user(conn, user_id, age):
    cursor = conn.cursor()
    cursor.execute("UPDATE users SET age = ? WHERE id = ?", (age, user_id))
    conn.commit()

def delete_user(conn, user_id):
    cursor = conn.cursor()
    cursor.execute("DELETE FROM users WHERE id = ?", (user_id,))
    conn.commit()

Основна програма

main.py

import database

# Свързване с базата данни
conn = database.connect()

# Създаване на таблица
database.create_table(conn)

# Добавяне на потребители
database.add_user(conn, "Alice", 30)
database.add_user(conn, "Bob", 25)

# Изброяване на потребителите
users = database.get_users(conn)
print("Users:")
for user in users:
    print(user)

# Актуализиране на възрастта на потребител
database.update_user(conn, 1, 35)

# Изтриване на потребител
database.delete_user(conn, 2)

# Изброяване на потребителите след промените
users = database.get_users(conn)
print("\nUsers after updates:")
for user in users:
    print(user)

# Затваряне на връзката
conn.close()

Заключение

В този урок разгледахме как да работим с бази данни в Python, използвайки SQLite. Научихме как да създаваме таблици, да добавяме, четем, актуализираме и изтриваме записи. Също така, създадохме примерна програма за управление на потребители. В следващите уроци ще разгледаме мрежово програмиране и уеб разработка с Python. Практикувайте редовно и експериментирайте с различни SQL заявки, за да затвърдите наученото.

Материалът Работа с бази данни в Python е публикуван за пръв път на The Fedya' s page.

Урок 5: Работа с файлове и директории в Python

В този урок ще разгледаме как да работим с файлове и директории в Python. Ще научим как да четем и записваме файлове, както и как да манипулираме директории. Тези умения са основни за създаването на приложения, които трябва да съхраняват и извличат данни от файловата система.

Четене и записване на текстови файлове

Работата с текстови файлове в Python се осъществява чрез вградената функция open().

Отваряне на файл

За да отворим файл за четене или запис, използваме функцията open(), която приема два основни аргумента: името на файла и режима на отваряне.

• r: четене (read)
• w: запис (write) – създава нов файл или презаписва съществуващ
• a: добавяне (append) – добавя към края на файла
• b: двоичен режим (binary)

file = open("example.txt", "r")  # Отваряме файла в режим на четене

Четене на съдържание

Можем да четем съдържанието на файла с методите read(), readline() или readlines().

file = open("example.txt", "r")

# Четене на целия файл
content = file.read()
print(content)

# Четене на един ред
file.seek(0)  # Връщане на указателя в началото на файла
line = file.readline()
print(line)

# Четене на всички редове
file.seek(0)
lines = file.readlines()
print(lines)

file.close()  # Затваряне на файла

Записване в файл

За да записваме данни във файл, отваряме го в режим на запис или добавяне и използваме метода write().

file = open("example.txt", "w")

file.write("Hello, world!\n")
file.write("This is a new line.")

file.close()  # Затваряне на файла

Контекстни мениджъри

Контекстните мениджъри са препоръчителен начин за работа с файлове, защото автоматично затварят файла след като сме приключили с него.

with open("example.txt", "r") as file:
    content = file.read()
    print(content)

# Файлът се затваря автоматично тук

Работа с двоични файловеДвоичните файлове се отварят в двоичен режим с добавяне на b към режима на отваряне.

# Записване в двоичен файл
with open("example.bin", "wb") as file:
    file.write(b'\xDE\xAD\xBE\xEF')

# Четене на двоичен файл
with open("example.bin", "rb") as file:
    content = file.read()
    print(content)

Работа с директории

Модулът os предоставя функции за работа с директории и файлове в тях.

Проверка дали файл или директория съществува

import os

# Проверка дали файл съществува
print(os.path.exists("example.txt"))  # True или False

# Проверка дали пътят е директория
print(os.path.isdir("example_directory"))  # True или False

# Проверка дали пътят е файл
print(os.path.isfile("example.txt"))  # True или False

Създаване и изтриване на директории

# Създаване на нова директория
os.mkdir("new_directory")

# Изтриване на директория
os.rmdir("new_directory")

Навигация в файловата система

# Получаване на текущата директория
print(os.getcwd())

# Промяна на текущата директория
os.chdir("new_directory")
print(os.getcwd())

# Връщане в предишната директория
os.chdir("..")
print(os.getcwd())

Изброяване на файлове и директории

# Изброяване на всички файлове и директории в текущата директория
print(os.listdir("."))

# Изброяване на всички файлове и директории в конкретна директория
print(os.listdir("/path/to/directory"))

Работа с модула shutil

Модулът shutil предоставя функции за копиране и изтриване на файлове и директории.

Копиране на файл

import shutil

# Копиране на файл
shutil.copy("example.txt", "example_copy.txt")

Преместване на файл или директория

# Преместване на файл или директория
shutil.move("example.txt", "new_directory/example.txt")

Изтриване на директория с цялото ѝ съдържание

# Изтриване на директория с цялото ѝ съдържание
shutil.rmtree("example_directory")

Примерна програма: Управление на бележки

Нека създадем програма за управление на бележки, която позволява добавяне, четене и изтриване на бележки.

Дефиниране на функции

notes.py

import os

def add_note(filename, content):
    with open(filename, "w") as file:
        file.write(content)

def read_note(filename):
    if os.path.exists(filename):
        with open(filename, "r") as file:
            return file.read()
    else:
        return "Note does not exist."

def delete_note(filename):
    if os.path.exists(filename):
        os.remove(filename)
        return "Note deleted."
    else:
        return "Note does not exist."

def list_notes(directory="."):
    return [f for f in os.listdir(directory) if os.path.isfile(f)]

Основна програма

main.py

import notes

# Добавяне на бележки
notes.add_note("note1.txt", "This is the first note.")
notes.add_note("note2.txt", "This is the second note.")

# Четене на бележки
print(notes.read_note("note1.txt"))

# Изтриване на бележка
print(notes.delete_note("note1.txt"))

# Изброяване на бележки
print("Notes in directory:")
for note in notes.list_notes():
    print(note)

Заключение

В този урок разгледахме основните концепции за работа с файлове и директории в Python. Научихме как да четем и записваме текстови и двоични файлове, как да използваме контекстни мениджъри, и как да манипулираме директории с помощта на модулите os и shutil. В следващите уроци ще разгледаме работа с бази данни и мрежово програмиране, за да разширим още повече нашите знания и умения в Python. Практикувайте редовно и експериментирайте с различни операции с файлове и директории, за да затвърдите наученото.

Материалът Работа с файлове и директории в Python е публикуван за пръв път на The Fedya' s page.

Урок 4: Обектно-ориентирано програмиране (ООП) в Python

Обектно-ориентираното програмиране (ООП) е парадигма за програмиране, която използва „обекти“ и „класове“. Обектите са конкретни екземпляри на класовете и могат да съдържат данни и методи за работа с тези данни. В този урок ще се запознаем с основните концепции на ООП и ще разгледаме как да ги приложим в Python.

Класове и обекти

Дефиниране на клас

Класовете в Python се дефинират с ключовата дума class, последвана от името на класа и двоеточие.

class Person:
    pass  # Използваме 'pass', за да създадем празен клас

Създаване на обект

Обектите се създават като извикаме класа, като използваме скоби:

person1 = Person()
person2 = Person()

Конструктор и атрибути

Конструкторът е специален метод, който се изпълнява при създаването на обект. В Python той се нарича __init__.

Дефиниране на конструктор и атрибути

class Person:
    def __init__(self, name, age):
        self.name = name  # Атрибут на класа
        self.age = age    # Атрибут на класа

Създаване на обект с параметри

person1 = Person("Alice", 30)
person2 = Person("Bob", 25)

print(person1.name)  # Отпечатва "Alice"
print(person2.age)   # Отпечатва 25

Методи в класове

Методите са функции, които са дефинирани в рамките на клас и оперират с обектите на този клас.

Дефиниране на метод

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def greet(self):
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")

Извикване на метод

person1 = Person("Alice", 30)
person1.greet()  # Отпечатва "Hello, my name is Alice and I am 30 years old."

Наследяване

Наследяването е механизъм, при който един клас (подклас) наследява атрибутите и методите на друг клас (базов клас).

Дефиниране на базов и подклас

class Employee(Person):
    def __init__(self, name, age, job_title):
        super().__init__(name, age)  # Викаме конструктора на базовия клас
        self.job_title = job_title

    def work(self):
        print(f"{self.name} is working as a {self.job_title}.")

Създаване на обект на подклас

employee1 = Employee("Charlie", 28, "Software Developer")
employee1.greet()  # Отпечатва "Hello, my name is Charlie and I am 28 years old."
employee1.work()   # Отпечатва "Charlie is working as a Software Developer."

Инкапсулация

Инкапсулацията е концепция, при която данните в класа са скрити от външния свят и могат да бъдат достъпвани само чрез методи на класа.

Пример за инкапсулация

class Person:
    def __init__(self, name, age):
        self.__name = name  # Приватен атрибут
        self.__age = age    # Приватен атрибут

    def get_name(self):
        return self.__name

    def set_name(self, name):
        self.__name = name

    def get_age(self):
        return self.__age

    def set_age(self, age):
        if age > 0:
            self.__age = age
        else:
            print("Invalid age")

person1 = Person("Alice", 30)
print(person1.get_name())  # Отпечатва "Alice"
person1.set_age(35)
print(person1.get_age())   # Отпечатва 35

Полиморфизъм

Полиморфизмът е концепция, при която различни класове могат да имат методи със същото име, но с различно поведение.

Пример за полиморфизъм

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

animals = [Dog(), Cat()]
for animal in animals:
    print(animal.speak())  # Отпечатва "Woof!" и "Meow!"

Абстракция

Абстракцията е концепция, при която се дефинират абстрактни класове и методи, които трябва да бъдат имплементирани в подкласи.

Пример за абстракция

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius * self.radius

shapes = [Rectangle(3, 4), Circle(5)]
for shape in shapes:
    print(shape.area())  # Отпечатва 12 и 78.5

Практическа програма: Управление на библиотека с ООП

Нека създадем програма за управление на библиотека с книги, използвайки ООП концепциите.

Дефиниране на класове

book.py

class Book:
    def __init__(self, title, author):
        self.title = title
        self.author = author

    def __str__(self):
        return f"{self.title} by {self.author}"

library.py

from book import Book

class Library:
    def __init__(self):
        self.books = []

    def add_book(self, book):
        self.books.append(book)

    def remove_book(self, title):
        self.books = [book for book in self.books if book.title != title]

    def list_books(self):
        for book in self.books:
            print(book)

Основна програма

main.py

from book import Book
from library import Library

library = Library()

book1 = Book("The Great Gatsby", "F. Scott Fitzgerald")
book2 = Book("1984", "George Orwell")

library.add_book(book1)
library.add_book(book2)

print("Books in library:")
library.list_books()

library.remove_book("1984")

print("\nBooks in library after removal:")
library.list_books()

Заключение

В този урок разгледахме основните концепции на обектно-ориентираното програмиране (ООП) в Python. Научихме как да дефинираме класове и обекти, как да използваме конструктори и методи, какво представлява наследяването, инкапсулацията, полиморфизмът и абстракцията. В следващите уроци ще продължим да разширяваме нашите знания за Python и ще се запознаем с работа с файлове, бази данни и мрежово програмиране. Практикувайте редовно и експериментирайте с различни класове и обекти, за да затвърдите наученото.

Материалът Обектно-ориентирано програмиране (ООП) в Python е публикуван за пръв път на The Fedya' s page.

Урок 3: Функции и модули в Python

В този урок ще се запознаем с функциите и модулите в Python. Ще разгледаме как да създаваме, използваме и организираме функции, както и как да използваме модули за структуриране на кода и повторно използване на функционалност.

Функции в Python

Функциите са основен елемент в програмирането, който ни позволява да организираме кода си в многократно използваеми блокове. Те се дефинират с ключовата дума def.

Дефиниране на функция

Ето пример за проста функция, която отпечатва съобщение:

def greet():
    print("Hello, world!")

Извикване на функция

За да използваме функцията, просто я извикваме по име:

greet()  # Отпечатва "Hello, world!"

Функции с параметри

Функциите могат да приемат параметри, които им позволяват да работят с различни входни данни. Ето пример:

def greet(name):
    print(f"Hello, {name}!")

greet("Alice")  # Отпечатва "Hello, Alice!"
greet("Bob")    # Отпечатва "Hello, Bob!"

Функции с връщане на стойност

Функциите могат да връщат стойности с помощта на ключовата дума return. Ето пример за функция, която изчислява квадрата на дадено число:

def square(number):
    return number * number

result = square(4)
print(result)  # Отпечатва 16

Обхват на променливите (Variable Scope)

Променливите в Python имат различен обхват в зависимост от това къде са дефинирани.

Локални променливи

Локалните променливи се дефинират вътре в функция и съществуват само в нейните граници:

def my_function():
    local_var = 10
    print(local_var)

my_function()  # Отпечатва 10
print(local_var)  # Грешка: local_var не е дефинирана извън функцията

Глобални променливи

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

global_var = 20

def my_function():
    print(global_var)

my_function()  # Отпечатва 20
print(global_var)  # Отпечатва 20

Рекурсия

Рекурсията е техника, при която функция извиква самата себе си. Тя е полезна за решаване на задачи, които могат да бъдат разделени на по-малки подзадачи.

Пример за рекурсивна функция, която изчислява факториал на число:

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

print(factorial(5))  # Отпечатва 120

Модули в Python

Модулите са начин за организиране на кода в отделни файлове и повторно използване на функционалност. Всеки файл с разширение .py е модул.

Импортиране на модули

Можем да импортираме съществуващи модули с ключовата дума import. Пример с вградения модул math:

import math

print(math.sqrt(16))  # Отпечатва 4.0

Импортиране на конкретни функции

Можем да импортираме конкретни функции от модул:

from math import sqrt

print(sqrt(25))  # Отпечатва 5.0

Създаване на собствен модул

За да създадем собствен модул, просто създаваме файл с Python код и го импортираме в друг файл.

Пример:

mymodule.py

def greet(name):
    print(f"Hello, {name}!")

main.py

import mymodule

mymodule.greet("Alice")  # Отпечатва "Hello, Alice!"

Полезни вградени модули

Python предоставя множество вградени модули, които можем да използваме за различни задачи.

Модулът os

Модулът os предоставя функции за работа с операционната система.

Пример:

import os

# Показване на текущата директория
print(os.getcwd())

# Създаване на нова директория
os.mkdir("new_directory")

# Промяна на текущата директория
os.chdir("new_directory")
print(os.getcwd())

Модулът datetime

Модулът datetime предоставя функции за работа с дати и часове.

Пример:

import datetime

# Получаване на текущата дата и час
now = datetime.datetime.now()
print(now)

# Форматиране на дата
formatted_date = now.strftime("%Y-%m-%d %H:%M:%S")
print(formatted_date)

Организация на кода

Добрата организация на кода прави проектите по-лесни за поддържане и разбиране. Използването на функции и модули е ключово за тази цел.

Структуриране на проект

Добра практика е да организирате кода си в папки и файлове по следния начин:

project/
├── main.py
├── mymodule.py
└── utils/
    └── helper.py

Използване на __init__.py

Файлът __init__.py се използва за обозначаване на директория като пакет. Това ни позволява да импортираме модули от тази директория.

utils/init.py

# Този файл може да бъде празен или да съдържа код за инициализация на пакета

main.py

from utils.helper import helper_function

helper_function()

Примерна програма: Управление на библиотека

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

library.py

books = []

def add_book(title, author):
    book = {"title": title, "author": author}
    books.append(book)

def remove_book(title):
    global books
    books = [book for book in books if book["title"] != title]

def list_books():
    for book in books:
        print(f"Title: {book['title']}, Author: {book['author']}")

main.py

import library

library.add_book("The Great Gatsby", "F. Scott Fitzgerald")
library.add_book("1984", "George Orwell")

print("Books in library:")
library.list_books()

library.remove_book("1984")

print("\nBooks in library after removal:")
library.list_books()

В този урок разгледахме как да създаваме и използваме функции и модули в Python. Научихме как да организираме кода си и как да използваме вградени модули за различни задачи. В следващите уроци ще продължим да разширяваме нашите знания за Python и ще се запознаем с по-напреднали теми като обектно-ориентираното програмиране и работа с файлове. Практикувайте редовно и експериментирайте с различни функции и модули, за да затвърдите наученото.

Материалът Функции и модули в Python е публикуван за пръв път на The Fedya' s page.

Урок 2: Работа с данни и структури от данни в Python

В този урок ще разгледаме как да работим с различни видове данни в Python. Ще се запознаем с основните структури от данни като списъци, кортежи, речници и множества.

Списъци (Lists)

Списъците са структури от данни, които могат да съдържат множество елементи от различни типове. Те се дефинират с квадратни скоби [].

Създаване на списък

fruits = ["apple", "banana", "cherry"]

Достъп до елементи

Елементите в списъка се достъпват чрез индекс, като индексирането започва от 0.

print(fruits[0])  # Отпечатва "apple"
print(fruits[1])  # Отпечатва "banana"

Добавяне на елементи

Можем да добавяме нови елементи в списъка с помощта на метода append().

fruits.append("orange")
print(fruits)  # Отпечатва ["apple", "banana", "cherry", "orange"]

Премахване на елементи

Можем да премахваме елементи с метода remove().

fruits.remove("banana")
print(fruits)  # Отпечатва ["apple", "cherry", "orange"]

Дължина на списъка

За да разберем колко елемента има в списъка, използваме функцията len().

print(len(fruits))  # Отпечатва 3

Кортежи (Tuples)

Кортежите са подобни на списъците, но са неизменяеми (immutable). Те се дефинират с кръгли скоби ().

Създаване на кортеж

colors = ("red", "green", "blue")

Достъп до елементи
Кортежите се достъпват по същия начин като списъците.

print(colors[0])  # Отпечатва "red"

Предимства на кортежите

• Те са неизменяеми, което ги прави по-безопасни за използване в някои случаи.
• Заемат по-малко памет от списъците.

Речници (Dictionaries)

Речниците съхраняват данни като ключ-стойност двойки. Те се дефинират с къдрави скоби {}.

Създаване на речник

person = {
    "name": "Alice",
    "age": 25,
    "city": "New York"
}

Достъп до стойности

Стойностите в речника се достъпват чрез ключовете.

print(person["name"])  # Отпечатва "Alice"
print(person["age"])   # Отпечатва 25

Добавяне на елементи

Можем да добавяме нови ключ-стойност двойки по следния начин:

person["email"] = "alice@example.com"
print(person)

Премахване на елементи

Можем да премахваме елементи с помощта на ключовете.

del person["age"]
print(person)  # Отпечатва {'name': 'Alice', 'city': 'New York', 'email': 'alice@example.com'}

Множества (Sets)

Множествата са структури от данни, които съдържат уникални елементи. Те се дефинират с къдрави скоби {} или с функцията set().

Създаване на множество

fruits = {"apple", "banana", "cherry"}

Добавяне на елементи

Можем да добавяме нови елементи с метода add().

fruits.add("orange")
print(fruits)  # Отпечатва {'apple', 'orange', 'banana', 'cherry'}

Премахване на елементи

Можем да премахваме елементи с метода remove().

fruits.remove("banana")
print(fruits)  # Отпечатва {'apple', 'orange', 'cherry'}

Проверка за наличие на елемент

Можем да проверим дали даден елемент е в множеството с оператор in.

print("apple" in fruits)  # Отпечатва True
print("banana" in fruits) # Отпечатва False

Итерираме през структури от данни

Можем да използваме цикли за итерираме през различни структури от данни.

Итериране през списък

for fruit in fruits:
    print(fruit)

Итериране през речник

for key, value in person.items():
    print(f"{key}: {value}")

Примерна програма: Управление на контактна книга

Нека създадем програма, която управлява контактна книга с имена и телефонни номера.

# Създаваме празен речник за контактите
contacts = {}

# Функция за добавяне на контакт
def add_contact(name, phone):
    contacts[name] = phone

# Функция за премахване на контакт
def remove_contact(name):
    if name in contacts:
        del contacts[name]
    else:
        print(f"Контактът {name} не съществува.")

# Функция за показване на всички контакти
def show_contacts():
    for name, phone in contacts.items():
        print(f"{name}: {phone}")

# Добавяме контакти
add_contact("Alice", "123-456-789")
add_contact("Bob", "987-654-321")

# Показваме контактите
show_contacts()

# Премахваме контакт
remove_contact("Alice")

# Показваме контактите отново
show_contacts()

Заключение

В този урок научихме как да работим с различни структури от данни в Python. Списъците, кортежите, речниците и множествата са основни елементи в програмирането. Те позволяват съхраняване и обработка на данни по различни начини. В следващия урок ще разгледаме функции и модули в Python.

Материалът Работа с данни и структури от данни в Python е публикуван за пръв път на The Fedya' s page.

Урок 1: Въведение в Python и основи на програмирането

Добре дошли в света на програмирането с Python!

Този урок е предназначен за абсолютни начинаещи, които нямат предишен опит с програмиране. Ще ви преведем през основите на Python, като започнем от инсталирането му до писането на прости скриптове.

Какво е Python?

Python е популярен език за програмиране, известен със своята простота и четимост. Той е идеален за начинаещи и е широко използван в различни области като уеб разработка, наука за данни, изкуствен интелект и автоматизация.Използва се за различни задачи, включително:

• Уеб разработка: Създаване на динамични уебсайтове и приложения.
• Анализ на данни: Обработка и анализ на големи набори от данни.
• Машинно обучение: Създаване на модели за прогнозиране и класификация.
• Автоматизация: Автоматизиране на задачи, които иначе биха отнели много време.
• Системно администриране: Управление на компютърни системи и мрежи.

Защо Python?

Има много причини да изберете Python за първия си език за програмиране:

• Лесен за изучаване: Python има прост синтаксис, който е лесен за четене и разбиране.
• Безплатен и с отворен код: Python е безплатен за изтегляне и използване, и има голяма общност от разработчици, които допринасят за неговото развитие.
• Мощен: Python е мощен език, който може да се използва за решаване на широк спектър от задачи.
• Гъвкав: Python може да се използва за различни задачи, от уеб разработка до машинно обучение.
• Широко разпространен: Python се използва от много компании и организации, включително Google, Facebook и NASA.

Какво ще ви е необходимо?

За да започнете с Python, ще ви е необходима следното:

• Компютър: Python може да работи на различни операционни системи, включително Windows, macOS и Linux.
• Текстов редактор: Ще ви е необходим текстов редактор за писане на Python код. Някои популярни опции са Notepad++ (Windows), Sublime Text (macOS/Windows/Linux) и Visual Studio Code (macOS/Windows/Linux).
• Интерпретатор на Python: Интерпретаторът е програма, която изпълнява Python код. Можете да изтеглите интерпретатор на Python от https://www.python.org/downloads/.

Инсталиране на Python

1. Отидете на https://www.python.org/downloads/.
2. Изберете подходящата версия на Python за вашата операционна система.
3. Изтеглете и инсталирайте Python.
4. Уверете се, че сте отметнали опцията „Add Python to PATH“.

Първият ви Python скрипт

Нека започнем с проста програма, която отпечатва „Hello, World!“. Това е традиционният начин за започване на програмирането.

Нека започнем с проста програма, която отпечатва „Hello, World!“. Това е традиционният начин за започване на програмирането.

1. Отворете текстов редактор (например Notepad, Notepad++ или VS Code).
2. Напишете следния код

print("Hello, World!")

3. Запазете файла с разширение .py (например hello.py).
4. Отворете командния ред или терминала и отидете до мястото, където сте запазили файла.
5. Изпълнете програмата с командата python hello.py в Windows и python3 hello.py в Linux.
6. Трябва да се отпечата „Hello, World!“ на вашия екран.

Обяснение на кода

• print(): Това е функция в Python, която отпечатва текста в скобите на екрана.
• "Hello, World!": Това е текстов низ (string), който искаме да отпечатаме.

Основи на синтаксиса в Python

Променливи и типове данни

Променливите в Python се използват за съхранение на данни. Те не изискват деклариране на тип, защото Python е динамично типизиран език.

Примери за променливи и типове данни:

# Цели числа (int)
x = 10

# Дробни числа (float)
y = 3.14

# Текстови низове (string)
name = "Alice"

# Булеви стойности (boolean)
is_student = True

Оператори

Операторите в Python се използват за извършване на аритметични, логически и други операции.

Примери за оператори:

# Аритметични оператори
a = 5 + 3     # Събиране
b = 10 - 2    # Изваждане
c = 4 * 2     # Умножение
d = 8 / 2     # Деление

# Логически оператори
is_equal = (a == b)  # Равно на
is_greater = (a > b) # По-голямо от

Коментари

Коментарите се използват за обясняване на кода и се игнорират от интерпретатора.

# Това е едноредов коментар

"""
Това е
многоредов
коментар
"""

Условни оператори

Условните оператори се използват за вземане на решения въз основа на условия.

Пример:

x = 10

if x > 5:
    print("x е по-голямо от 5")
else:
    print("x не е по-голямо от 5")

Обяснение:

• if и else са ключови думи, които определят условието.
• Условното изразяване се поставя в скоби след if.
• Ако условието е вярно, се изпълнява кодът под if.
• Ако условието не е вярно, се изпълнява кодът под else.

Цикли

Циклите се използват за повторно изпълнение на блок от код.

Цикъл for

Пример:

for i in range(5):
    print(i)

Обяснение:

• for е ключова дума за започване на цикъл.
• range(5) генерира последователност от числа от 0 до 4.
• Кодът в тялото на цикъла се изпълнява за всяко число в последователността.

Цикъл while

Пример:

count = 0

while count < 5:
    print(count)
    count += 1

Обяснение:

• while е ключова дума за започване на цикъл.
• Условното изразяване след while се проверява преди всяко изпълнение на тялото на цикъла.
• Цикълът продължава, докато условието е вярно.

Функции

Функциите се използват за организиране на кода в по-малки, многократно използвани блокове.

Пример:

def greet(name):
    print(f"Hello, {name}!")

greet("Alice")
greet("Bob")

Обяснение:

• def е ключова дума за дефиниране на функция.
• greet е името на функцията.
• name е параметър на функцията.
• Кодът в тялото на функцията се изпълнява всеки път, когато функцията се извика.

Практически пример

Нека създадем малка програма, която изчислява площта на правоъгълник.

def calculate_area(width, height):
    area = width * height
    return area

w = 5
h = 3
area = calculate_area(w, h)
print(f"Площта на правоъгълника е {area}")

Обяснение:

• Дефинираме функцията calculate_area с два параметъра: width и height.
• Изчисляваме площта, като умножаваме ширината по височината.
• Връщаме изчислената площ.
• Присвояваме стойности на w и h.
• Извикваме функцията и отпечатваме резултата.

Заключение

В този урок научихме основите на Python и написахме няколко прости програми. В следващите уроци ще разгледаме по-сложни концепции и ще пишем по-интересни програми. Практикувайте редовно и експериментирайте с различни примери, за да затвърдите наученото.

Материалът Въведение в Python и основи на програмирането е публикуван за пръв път на The Fedya' s page.