Learn Python Coding

## 🔹 Multimedia Applications ### 1. Audio Player

from PyQt5.QtMultimedia import QMediaPlayer, QMediaContent
from PyQt5.QtMultimediaWidgets import QVideoWidget

class MediaPlayer(QWidget):
    def __init__(self):
        super().__init__()
        self.player = QMediaPlayer()
        self.setup_ui()

    def setup_ui(self):
        # Video display
        video_widget = QVideoWidget()
        
        # Controls
        play_btn = QPushButton("Play")
        pause_btn = QPushButton("Pause")
        stop_btn = QPushButton("Stop")
        volume_slider = QSlider(Qt.Horizontal)
        volume_slider.setRange(0, 100)
        volume_slider.setValue(50)
        
        # Layout
        control_layout = QHBoxLayout()
        control_layout.addWidget(play_btn)
        control_layout.addWidget(pause_btn)
        control_layout.addWidget(stop_btn)
        control_layout.addWidget(volume_slider)
        
        main_layout = QVBoxLayout()
        main_layout.addWidget(video_widget)
        main_layout.addLayout(control_layout)
        self.setLayout(main_layout)
        
        # Connections
        self.player.setVideoOutput(video_widget)
        play_btn.clicked.connect(self.player.play)
        pause_btn.clicked.connect(self.player.pause)
        stop_btn.clicked.connect(self.player.stop)
        volume_slider.valueChanged.connect(self.player.setVolume)
    
    def load_file(self, path):
        self.player.setMedia(QMediaContent(QUrl.fromLocalFile(path)))

### 2. Camera Capture

from PyQt5.QtMultimedia import QCamera, QCameraImageCapture
from PyQt5.QtMultimediaWidgets import QCameraViewfinder

class CameraApp(QWidget):
    def __init__(self):
        super().__init__()
        self.camera = QCamera()
        self.image_capture = QCameraImageCapture(self.camera)
        self.setup_ui()
    
    def setup_ui(self):
        # Camera viewfinder
        viewfinder = QCameraViewfinder()
        self.camera.setViewfinder(viewfinder)
        
        # Controls
        capture_btn = QPushButton("Capture")
        capture_btn.clicked.connect(self.capture_image)
        
        # Layout
        layout = QVBoxLayout()
        layout.addWidget(viewfinder)
        layout.addWidget(capture_btn)
        self.setLayout(layout)
        
        # Start camera
        self.camera.start()
    
    def capture_image(self):
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        path = f"capture_{timestamp}.jpg"
        self.image_capture.capture(path)
        print(f"Image saved to {path}")

--- ## 🔹 Internationalization (i18n) ### 1. Translation Setup

from PyQt5.QtCore import QTranslator, QLocale

class TranslatableApp(QApplication):
    def __init__(self, argv):
        super().__init__(argv)
        self.translator = QTranslator()
        
        # Load system language
        locale = QLocale.system().name()
        self.load_translation(locale)
    
    def load_translation(self, lang):
        # Remove old translator
        self.removeTranslator(self.translator)
        
        # Create new translator
        self.translator = QTranslator()
        if self.translator.load(f":/translations/app_{lang}.qm"):
            self.installTranslator(self.translator)
            return True
        return False

# Mark strings for translation
self.label.setText(self.tr("Welcome to the application"))

### 2. Creating Translation Files 1. Mark strings with self.tr() or QObject.tr() 2. Extract strings:

   pylupdate5 -verbose myapp.pro
   

3. Translate using Qt Linguist 4. Compile translations:

   lrelease myapp.pro

# 📚 PyQt5 Tutorial - Part 5/6: Networking, Multimedia & Internationalization #PyQt5 #Networking #Multimedia #i18n #Deployment Welcome to Part 5 of our PyQt5 series! This comprehensive lesson covers professional networking, multimedia handling, internationalization, and deployment strategies for production applications. --- ## 🔹 Networking with PyQt5 ### 1. HTTP Requests with QNetworkAccessManager

from PyQt5.QtNetwork import QNetworkRequest, QNetworkAccessManager
from PyQt5.QtCore import QUrl

class ApiClient(QObject):
    response_received = pyqtSignal(str)
    error_occurred = pyqtSignal(str)

    def __init__(self):
        super().__init__()
        self.manager = QNetworkAccessManager()
        self.manager.finished.connect(self.handle_response)

    def fetch_data(self, url):
        request = QNetworkRequest(QUrl(url))
        self.manager.get(request)

    def handle_response(self, reply):
        if reply.error():
            self.error_occurred.emit(reply.errorString())
        else:
            data = reply.readAll().data().decode('utf-8')
            self.response_received.emit(data)
        reply.deleteLater()

# Usage
client = ApiClient()
client.response_received.connect(lambda data: print("Received:", data))
client.error_occurred.connect(lambda err: print("Error:", err))
client.fetch_data("https://api.example.com/data")

### 2. WebSocket Communication

from PyQt5.QtWebSockets import QWebSocket

class WebSocketClient(QObject):
    message_received = pyqtSignal(str)
    connected = pyqtSignal()
    disconnected = pyqtSignal()

    def __init__(self):
        super().__init__()
        self.socket = QWebSocket()
        self.socket.textMessageReceived.connect(self.message_received)
        self.socket.connected.connect(self.connected)
        self.socket.disconnected.connect(self.disconnected)

    def connect_to_server(self, url):
        self.socket.open(QUrl(url))

    def send_message(self, message):
        self.socket.sendTextMessage(message)

# Usage
ws_client = WebSocketClient()
ws_client.connect_to_server("ws://echo.websocket.org")
ws_client.message_received.connect(print)

### 3. TCP Socket Server

from PyQt5.QtNetwork import QTcpServer, QTcpSocket

class TcpServer(QObject):
    new_connection = pyqtSignal(QTcpSocket)

    def __init__(self):
        super().__init__()
        self.server = QTcpServer()
        self.server.newConnection.connect(self.handle_new_connection)

    def start(self, port=12345):
        if not self.server.listen(QHostAddress.Any, port):
            print("Server error:", self.server.errorString())
            return False
        print(f"Server started on port {port}")
        return True

    def handle_new_connection(self):
        client = self.server.nextPendingConnection()
        client.readyRead.connect(lambda: self.read_data(client))
        client.disconnected.connect(client.deleteLater)
        self.new_connection.emit(client)

    def read_data(self, client):
        data = client.readAll().data().decode('utf-8')
        print("Received:", data)
        client.write(f"Echo: {data}".encode())

---

## 🔹 Advanced Widget Customization ### 1. Custom Delegate for Table Views

class ProgressBarDelegate(QStyledItemDelegate):
    def paint(self, painter, option, index):
        progress = index.data(Qt.DisplayRole)
        
        # Draw background
        painter.save()
        painter.setPen(Qt.NoPen)
        painter.setBrush(QColor("#e0e0e0"))
        painter.drawRect(option.rect)
        
        # Draw progress
        if progress > 0:
            width = option.rect.width() * progress / 100
            progress_rect = QRectF(option.rect)
            progress_rect.setWidth(width)
            
            gradient = QLinearGradient(progress_rect.topLeft(), progress_rect.topRight())
            gradient.setColorAt(0, QColor("#4CAF50"))
            gradient.setColorAt(1, QColor("#2E7D32"))
            
            painter.setBrush(QBrush(gradient))
            painter.drawRect(progress_rect)
        
        # Draw text
        painter.setPen(QColor("#333"))
        painter.drawText(option.rect, Qt.AlignCenter, f"{progress}%")
        painter.restore()

# Usage
table = QTableView()
table.setItemDelegateForColumn(2, ProgressBarDelegate())

### 2. Custom Widget with QPainter

class GaugeWidget(QWidget):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.value = 0
        self.min_value = 0
        self.max_value = 100
    
    def set_value(self, value):
        self.value = max(self.min_value, min(value, self.max_value))
        self.update()
    
    def paintEvent(self, event):
        painter = QPainter(self)
        painter.setRenderHint(QPainter.Antialiasing)
        
        # Draw background
        rect = self.rect().adjusted(5, 5, -5, -5)
        painter.setPen(QPen(QColor("#333"), 2)
        painter.setBrush(QColor("#f5f5f5"))
        painter.drawEllipse(rect)
        
        # Draw gauge
        angle = 180 * (self.value - self.min_value) / (self.max_value - self.min_value)
        span_angle = -angle * 16  # 1/16th of a degree
        
        pen = QPen(QColor("#FF5722"), 10)
        pen.setCapStyle(Qt.RoundCap)
        painter.setPen(pen)
        
        painter.drawArc(rect, 180 * 16, span_angle)
        
        # Draw text
        font = painter.font()
        font.setPointSize(20)
        painter.setFont(font)
        painter.drawText(rect, Qt.AlignCenter, f"{self.value}%")

--- ## 🔹 Best Practices 1. Separate database logic from UI code 2. Use transactions for batch database operations 3. Optimize chart performance with limited data points 4. Follow MVC pattern for complex applications 5. Document custom widgets thoroughly --- ### 📌 What's Next? In Part 5, we'll cover: ➡️ Networking & Web APIs ➡️ Multimedia Applications ➡️ Internationalization ➡️ Deployment & Packaging #PyQt5 #Database #DataVisualization 🚀 Practice Exercise: 1. Build a sales dashboard with database-backed charts 2. Create a custom weather widget with API data 3. Implement an MVC-based inventory management system

## 🔹 Model-View-Controller (MVC) Pattern ### 1. MVC Implementation

# Model
class DataModel(QObject):
    data_changed = pyqtSignal(list)
    
    def __init__(self):
        super().__init__()
        self._data = []
    
    def load_data(self, source):
        # Simulate data loading
        self._data = [(i, random.randint(0, 100)) for i in range(10)]
        self.data_changed.emit(self._data)
    
    def get_data(self):
        return self._data

# View
class DataView(QWidget):
    def __init__(self, controller):
        super().__init__()
        self.controller = controller
        self.table = QTableWidget()
        
        layout = QVBoxLayout()
        layout.addWidget(self.table)
        self.setLayout(layout)
    
    def update_view(self, data):
        self.table.setRowCount(len(data))
        self.table.setColumnCount(2)
        
        for row, (x, y) in enumerate(data):
            self.table.setItem(row, 0, QTableWidgetItem(str(x)))
            self.table.setItem(row, 1, QTableWidgetItem(str(y)))

# Controller
class DataController:
    def __init__(self):
        self.model = DataModel()
        self.view = DataView(self)
        
        self.model.data_changed.connect(self.handle_data_change)
        self.model.load_data("dummy_source")
    
    def handle_data_change(self, data):
        self.view.update_view(data)
    
    def show_view(self):
        self.view.show()

### 2. Advanced MVC with SQL

class SqlController:
    def __init__(self):
        self.db = setup_database()  # From earlier example
        self.model = QSqlTableModel()
        self.model.setTable("contacts")
        self.model.select()
        
        self.view = ContactView(self)
    
    def add_contact(self, name, email, phone):
        record = self.model.record()
        record.setValue("name", name)
        record.setValue("email", email)
        record.setValue("phone", phone)
        return self.model.insertRecord(-1, record)
    
    def delete_contact(self, row):
        return self.model.removeRow(row)

class ContactView(QWidget):
    def __init__(self, controller):
        super().__init__()
        self.controller = controller
        self.setup_ui()
    
    def setup_ui(self):
        # Form setup
        self.name_input = QLineEdit()
        self.email_input = QLineEdit()
        self.phone_input = QLineEdit()
        
        add_btn = QPushButton("Add Contact")
        add_btn.clicked.connect(self.on_add)
        
        # Table setup
        self.table = QTableView()
        self.table.setModel(self.controller.model)
        
        # Layout
        form_layout = QFormLayout()
        form_layout.addRow("Name:", self.name_input)
        form_layout.addRow("Email:", self.email_input)
        form_layout.addRow("Phone:", self.phone_input)
        form_layout.addRow(add_btn)
        
        main_layout = QVBoxLayout()
        main_layout.addLayout(form_layout)
        main_layout.addWidget(self.table)
        
        self.setLayout(main_layout)
    
    def on_add(self):
        name = self.name_input.text()
        email = self.email_input.text()
        phone = self.phone_input.text()
        
        if name:
            if self.controller.add_contact(name, email, phone):
                self.controller.model.submitAll()
                self.clear_form()
    
    def clear_form(self):
        self.name_input.clear()
        self.email_input.clear()
        self.phone_input.clear()

---

## 🔹 Data Visualization ### 1. QtCharts Basic Setup

from PyQt5.QtChart import QChart, QChartView, QBarSet, QBarSeries, QBarCategoryAxis

class SalesChart(QWidget):
    def __init__(self, data):
        super().__init__()
        self.chart = QChart()
        self.chart.setTitle("Quarterly Sales")
        self.chart.setAnimationOptions(QChart.SeriesAnimations)
        
        self.setup_series(data)
        self.setup_axes()
        
        chart_view = QChartView(self.chart)
        chart_view.setRenderHint(QPainter.Antialiasing)
        
        layout = QVBoxLayout()
        layout.addWidget(chart_view)
        self.setLayout(layout)
    
    def setup_series(self, data):
        series = QBarSeries()
        
        for product, values in data.items():
            bar_set = QBarSet(product)
            bar_set.append(values)
            series.append(bar_set)
        
        self.chart.addSeries(series)
    
    def setup_axes(self):
        categories = ["Q1", "Q2", "Q3", "Q4"]
        
        axis_x = QBarCategoryAxis()
        axis_x.append(categories)
        self.chart.addAxis(axis_x, Qt.AlignBottom)
        
        axis_y = QValueAxis()
        axis_y.setRange(0, 1000)
        self.chart.addAxis(axis_y, Qt.AlignLeft)
        
        for series in self.chart.series():
            series.attachAxis(axis_x)
            series.attachAxis(axis_y)

### 2. Interactive Line Chart

from PyQt5.QtChart import QLineSeries, QValueAxis

class InteractiveChart(QChartView):
    def __init__(self, data):
        super().__init__()
        self.series = QLineSeries()
        self.series.setName("Data Series")
        
        for point in data:
            self.series.append(*point)
        
        self.chart = QChart()
        self.chart.addSeries(self.series)
        self.chart.createDefaultAxes()
        self.chart.setTitle("Interactive Chart")
        
        self.setChart(self.chart)
        self.setRubberBand(QChartView.RectangleRubberBand)
        self.setRenderHint(QPainter.Antialiasing)
    
    def mousePressEvent(self, event):
        if event.button() == Qt.LeftButton:
            point = self.chart.mapToValue(event.pos())
            self.series.append(point.x(), point.y())
        super().mousePressEvent(event)

### 3. Real-Time Data Visualization

class RealTimeChart(QThread):
    data_updated = pyqtSignal(list)
    
    def __init__(self):
        super().__init__()
        self.running = True
    
    def run(self):
        x = 0
        while self.running:
            time.sleep(0.1)
            y = random.randint(0, 100)
            self.data_updated.emit([(x, y)])
            x += 1
    
    def stop(self):
        self.running = False
        self.wait()

class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.series = QLineSeries()
        
        self.chart = QChart()
        self.chart.addSeries(self.series)
        self.chart.createDefaultAxes()
        
        self.chart_view = QChartView(self.chart)
        self.setCentralWidget(self.chart_view)
        
        self.thread = RealTimeChart()
        self.thread.data_updated.connect(self.update_chart)
        self.thread.start()
    
    def update_chart(self, points):
        for x, y in points:
            self.series.append(x, y)
            if self.series.count() > 100:
                self.series.remove(0)
            self.chart.axisX().setRange(x-100, x)
    
    def closeEvent(self, event):
        self.thread.stop()
        super().closeEvent(event)

---

# 📚 PyQt5 Tutorial - Part 4/6: Database Integration & Data Visualization #PyQt5 #SQL #DataViz #MVC #ProfessionalDevelopment Welcome to Part 4 of our PyQt5 series! This comprehensive lesson covers professional database integration, data visualization, and architectural patterns for building robust desktop applications. --- ## 🔹 Database Integration with PyQt5 ### 1. SQLite Connection & Setup

from PyQt5.QtSql import QSqlDatabase, QSqlQuery

def setup_database():
    db = QSqlDatabase.addDatabase("QSQLITE")
    db.setDatabaseName("app_data.db")
    
    if not db.open():
        QMessageBox.critical(None, "Database Error", db.lastError().text())
        return False
    
    # Create tables if they don't exist
    query = QSqlQuery()
    query.exec_("""
        CREATE TABLE IF NOT EXISTS contacts (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            name TEXT NOT NULL,
            email TEXT UNIQUE,
            phone TEXT,
            created_at DATETIME DEFAULT CURRENT_TIMESTAMP
        )
    """)
    return True

### 2. SQL Model-View Integration

from PyQt5.QtSql import QSqlTableModel

class ContactManager(QWidget):
    def __init__(self):
        super().__init__()
        self.model = QSqlTableModel()
        self.model.setTable("contacts")
        self.model.select()
        
        self.setup_ui()
    
    def setup_ui(self):
        layout = QVBoxLayout()
        
        # Table View
        self.table = QTableView()
        self.table.setModel(self.model)
        self.table.setSelectionBehavior(QTableView.SelectRows)
        self.table.setEditTriggers(QTableView.DoubleClicked)
        
        # Buttons
        add_btn = QPushButton("Add Contact")
        add_btn.clicked.connect(self.add_contact)
        
        del_btn = QPushButton("Delete Selected")
        del_btn.clicked.connect(self.delete_contact)
        
        # Layout
        btn_layout = QHBoxLayout()
        btn_layout.addWidget(add_btn)
        btn_layout.addWidget(del_btn)
        
        layout.addWidget(self.table)
        layout.addLayout(btn_layout)
        self.setLayout(layout)
    
    def add_contact(self):
        name, ok = QInputDialog.getText(self, "Add Contact", "Name:")
        if ok and name:
            record = self.model.record()
            record.setValue("name", name)
            self.model.insertRecord(-1, record)
            self.model.submitAll()
    
    def delete_contact(self):
        selected = self.table.selectionModel().selectedRows()
        for index in sorted(selected, reverse=True):
            self.model.removeRow(index.row())
        self.model.submitAll()

### 3. PostgreSQL Connection

def connect_postgresql():
    db = QSqlDatabase.addDatabase("QPSQL")
    db.setHostName("localhost")
    db.setDatabaseName("myapp")
    db.setUserName("postgres")
    db.setPassword("password")
    db.setPort(5432)
    
    if not db.open():
        error = db.lastError()
        QMessageBox.critical(None, "Database Error", 
                           f"Code: {error.number()}\n{error.text()}")
        return False
    return True

---

⚠ Message was hidden by channel owner

⚠ Message was hidden by channel owner

⚠ Message was hidden by channel owner

⚠ Message was hidden by channel owner

    def show_error(self, message):
        self.thread.quit()
        QMessageBox.critical(self, "Error", message)

class FileWorker(QObject):
    progress = pyqtSignal(int)
    finished = pyqtSignal()
    error = pyqtSignal(str)
    
    def __init__(self):
        super().__init__()
        self.files = []
    
    def set_files(self, files):
        self.files = files
    
    def process(self):
        try:
            total = len(self.files)
            for i, file in enumerate(self.files):
                # Simulate processing
                time.sleep(0.5)
                
                # Check for cancellation
                if QThread.currentThread().isInterruptionRequested():
                    break
                
                # Update progress
                self.progress.emit(int((i + 1) / total * 100))
            
            self.finished.emit()
        except Exception as e:
            self.error.emit(str(e))

--- ## 🔹 Best Practices 1. Always clean up threads - Use finished signals 2. Never update UI from worker threads - Use signals 3. Validate file operations - Check permissions/existence 4. Handle drag-and-drop properly - Check MIME types 5. Make dialogs modal/non-modal appropriately - exec_() vs show() --- ### 📌 What's Next? In Part 4, we'll cover: ➡️ Database Integration (SQLite, PostgreSQL) ➡️ Data Visualization (Charts, Graphs) ➡️ Model-View-Controller Pattern ➡️ Advanced Widget Customization #PyQt5 #ProfessionalDevelopment #PythonGUI 🚀 Practice Exercise: 1. Build a thumbnail generator with progress reporting 2. Create a JSON config editor with file monitoring 3. Implement a thread-safe logging system for background tasks

### 2. Custom Drag Sources

class DraggableList(QListWidget):
    def __init__(self):
        super().__init__()
        self.setDragEnabled(True)
        self.setAcceptDrops(True)
        self.setDragDropMode(QAbstractItemView.InternalMove)
        
        for i in range(5):
            self.addItem(f"Item {i+1}")
    
    def startDrag(self, supportedActions):
        item = self.currentItem()
        mime_data = QMimeData()
        mime_data.setText(item.text())
        
        drag = QDrag(self)
        drag.setMimeData(mime_data)
        drag.exec_(Qt.MoveAction)

--- ## 🔹 Threading with QThread ### 1. Worker Thread Pattern

class Worker(QObject):
    finished = pyqtSignal()
    progress = pyqtSignal(int)
    
    def run(self):
        for i in range(1, 101):
            time.sleep(0.1)
            self.progress.emit(i)
        self.finished.emit()

class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        
        self.thread = QThread()
        self.worker = Worker()
        self.worker.moveToThread(self.thread)
        
        self.thread.started.connect(self.worker.run)
        self.worker.finished.connect(self.thread.quit)
        self.worker.finished.connect(self.worker.deleteLater)
        self.thread.finished.connect(self.thread.deleteLater)
        self.worker.progress.connect(self.update_progress)
        
        self.thread.start()
    
    def update_progress(self, value):
        print("Progress:", value)

### 2. Thread Pool for Concurrent Tasks

from PyQt5.QtCore import QRunnable, QThreadPool

class Task(QRunnable):
    def __init__(self, task_id):
        super().__init__()
        self.task_id = task_id
    
    def run(self):
        print(f"Starting task {self.task_id}")
        time.sleep(2)
        print(f"Finished task {self.task_id}")

pool = QThreadPool.globalInstance()
for i in range(5):
    pool.start(Task(i))
print("Max threads:", pool.maxThreadCount())

--- ## 🔹 Practical Example: File Processor

class FileProcessor(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setup_ui()
        self.setup_thread()
    
    def setup_ui(self):
        self.setWindowTitle("File Processor")
        
        # Central Widget
        widget = QWidget()
        layout = QVBoxLayout()
        
        # File Selection
        self.file_list = QListWidget()
        self.file_list.setSelectionMode(QAbstractItemView.MultiSelection)
        
        add_btn = QPushButton("Add Files")
        add_btn.clicked.connect(self.add_files)
        
        # Processing Controls
        self.progress = QProgressBar()
        process_btn = QPushButton("Process Files")
        process_btn.clicked.connect(self.process_files)
        
        # Layout
        layout.addWidget(QLabel("Files to Process:"))
        layout.addWidget(self.file_list)
        layout.addWidget(add_btn)
        layout.addWidget(self.progress)
        layout.addWidget(process_btn)
        
        widget.setLayout(layout)
        self.setCentralWidget(widget)
    
    def setup_thread(self):
        self.thread = QThread()
        self.worker = FileWorker()
        self.worker.moveToThread(self.thread)
        
        self.thread.started.connect(self.worker.process)
        self.worker.progress.connect(self.progress.setValue)
        self.worker.finished.connect(self.on_processing_finished)
        self.worker.error.connect(self.show_error)
    
    def add_files(self):
        files, _ = QFileDialog.getOpenFileNames(
            self, "Select Files", "", "All Files (*)")
        self.file_list.addItems(files)
    
    def process_files(self):
        if self.file_list.count() == 0:
            QMessageBox.warning(self, "Warning", "No files selected!")
            return
        
        files = [self.file_list.item(i).text() 
                for i in range(self.file_list.count())]
        self.worker.set_files(files)
        self.thread.start()
    
    def on_processing_finished(self):
        self.thread.quit()
        QMessageBox.information(self, "Done", "Processing completed!")

# 📚 PyQt5 Tutorial - Part 3/6: Dialogs, Files & Threading #PyQt5 #Python #Threading #FileDialogs #DragAndDrop Welcome to Part 3 of our PyQt5 series! This comprehensive lesson dives into professional dialog handling, file operations, drag-and-drop functionality, and threading - essential for building production-grade applications. --- ## 🔹 Professional Dialog Handling ### 1. Standard Dialogs PyQt5 provides built-in dialogs for common tasks:

from PyQt5.QtWidgets import (QFileDialog, QColorDialog, 
                            QFontDialog, QInputDialog, QMessageBox)

# File Dialog
file_path, _ = QFileDialog.getOpenFileName(
    self, "Open File", "", "Text Files (*.txt);;All Files (*)")

# Color Dialog
color = QColorDialog.getColor()

# Font Dialog
font, ok = QFontDialog.getFont()

# Input Dialog
text, ok = QInputDialog.getText(self, "Input", "Enter your name:")

# Message Box
reply = QMessageBox.question(
    self, "Message", "Are you sure?",
    QMessageBox.Yes | QMessageBox.No, QMessageBox.No)

### 2. Custom Dialog Classes Create reusable dialog windows:

class LoginDialog(QDialog):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setWindowTitle("Login")
        
        self.username = QLineEdit()
        self.password = QLineEdit()
        self.password.setEchoMode(QLineEdit.Password)
        
        buttons = QDialogButtonBox(
            QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
        buttons.accepted.connect(self.accept)
        buttons.rejected.connect(self.reject)
        
        layout = QFormLayout()
        layout.addRow("Username:", self.username)
        layout.addRow("Password:", self.password)
        layout.addRow(buttons)
        
        self.setLayout(layout)
    
    def get_credentials(self):
        return (self.username.text(), self.password.text())

# Usage
dialog = LoginDialog()
if dialog.exec_():
    username, password = dialog.get_credentials()

--- ## 🔹 File System Operations ### 1. File and Directory Handling

from PyQt5.QtCore import QDir, QFile, QFileInfo

# Check file existence
file_info = QFileInfo("path/to/file")
if file_info.exists():
    print("File size:", file_info.size())

# Directory operations
directory = QDir()
directory.mkdir("new_folder")
print("Current path:", directory.currentPath())

# File reading/writing
file = QFile("data.txt")
if file.open(QIODevice.ReadOnly | QIODevice.Text):
    stream = QTextStream(file)
    content = stream.readAll()
    file.close()

### 2. Monitoring File Changes

from PyQt5.QtCore import QFileSystemWatcher

class FileMonitor(QObject):
    def __init__(self):
        super().__init__()
        self.watcher = QFileSystemWatcher()
        self.watcher.fileChanged.connect(self.on_file_changed)
    
    def add_file(self, path):
        self.watcher.addPath(path)
    
    def on_file_changed(self, path):
        print(f"File changed: {path}")

monitor = FileMonitor()
monitor.add_file("important_file.txt")

--- ## 🔹 Drag and Drop ### 1. Enabling Drag-and-Drop

class DropArea(QLabel):
    def __init__(self):
        super().__init__("Drop files here")
        self.setAcceptDrops(True)
        self.setAlignment(Qt.AlignCenter)
        self.setStyleSheet("border: 2px dashed #aaa;")
    
    def dragEnterEvent(self, event):
        if event.mimeData().hasUrls():
            event.acceptProposedAction()
    
    def dropEvent(self, event):
        for url in event.mimeData().urls():
            file_path = url.toLocalFile()
            print("Dropped file:", file_path)

## 🔹 Multi-Window Applications ### 1. Creating Secondary Windows

class SettingsWindow(QDialog):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Settings")
        layout = QVBoxLayout()
        layout.addWidget(QLabel("Application Settings"))
        self.setLayout(layout)

# In main window:
def show_settings(self):
    settings = SettingsWindow()
    settings.exec_()  # Modal dialog
    # OR settings.show() for non-modal

### 2. Window Communication

# Main window with signal
class MainWindow(QMainWindow):
    settings_changed = pyqtSignal(dict)
    
    def open_settings(self):
        dialog = SettingsDialog(self)  # Pass parent
        if dialog.exec_():
            self.settings_changed.emit(dialog.get_settings())

# Settings dialog
class SettingsDialog(QDialog):
    def __init__(self, parent=None):
        super().__init__(parent)
        # ... setup UI ...
    
    def get_settings(self):
        return {"theme": self.theme_combo.currentText()}

--- ## 🔹 Model-View Architecture ### 1. QListView with StringListModel

model = QStringListModel()
model.setStringList(["Item 1", "Item 2", "Item 3"])

list_view = QListView()
list_view.setModel(model)

# Add items
model.insertRow(model.rowCount())
model.setData(model.index(model.rowCount()-1), "New Item")

### 2. Custom Table Model

class CustomTableModel(QAbstractTableModel):
    def __init__(self, data):
        super().__init__()
        self._data = data
    
    def rowCount(self, parent=None):
        return len(self._data)
    
    def columnCount(self, parent=None):
        return len(self._data[0]) if self._data else 0
    
    def data(self, index, role=Qt.DisplayRole):
        if role == Qt.DisplayRole:
            return str(self._data[index.row()][index.column()])
        return None

# Usage
data = [[1, "Alice"], [2, "Bob"], [3, "Charlie"]]
model = CustomTableModel(data)
table = QTableView()
table.setModel(model)

--- ## 🔹 Practical Example: Text Editor

class TextEditor(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setup_ui()
        self.setup_menu()
    
    def setup_ui(self):
        self.text_edit = QTextEdit()
        self.setCentralWidget(self.text_edit)
        
        # Status bar
        self.statusBar().showMessage("Ready")
        
        # Toolbar
        toolbar = self.addToolBar("Tools")
        save_act = QAction(QIcon("save.png"), "Save", self)
        save_act.triggered.connect(self.save_file)
        toolbar.addAction(save_act)
    
    def setup_menu(self):
        menubar = self.menuBar()
        
        # File menu
        file_menu = menubar.addMenu("File")
        
        open_act = QAction("Open", self)
        open_act.triggered.connect(self.open_file)
        file_menu.addAction(open_act)
        
        # Edit menu
        edit_menu = menubar.addMenu("Edit")
        edit_menu.addAction("Copy", self.text_edit.copy)
        edit_menu.addAction("Paste", self.text_edit.paste)
    
    def open_file(self):
        path, _ = QFileDialog.getOpenFileName()
        if path:
            with open(path, 'r') as f:
                self.text_edit.setText(f.read())
    
    def save_file(self):
        path, _ = QFileDialog.getSaveFileName()
        if path:
            with open(path, 'w') as f:
                f.write(self.text_edit.toPlainText())

--- ## 🔹 Best Practices 1. Separate UI code from business logic 2. Use models for complex data views 3. Optimize performance for large datasets 4. Localize strings for internationalization 5. Document signals and public methods --- ### 📌 What's Next? In Part 3, we'll cover: ➡️ Dialogs & Message Boxes ➡️ File System Operations ➡️ Drag & Drop ➡️ Threading with QThread #PyQt5 #GUIPython #ProfessionalDevelopment 🚀 Practice Exercise: 1. Create a contacts app with tree view and detail form 2. Build a styled calculator with custom buttons 3. Implement a multi-window image viewer with thumbnails

# 📚 PyQt5 Tutorial - Part 2/6: Advanced Widgets & Customization #PyQt5 #PythonGUI #AdvancedWidgets #QSS #SignalsSlots Welcome to Part 2 of our PyQt5 series! This in-depth lesson covers advanced widgets, custom styling, multi-window applications, and professional patterns. --- ## 🔹 Advanced Widgets Overview ### 1. Tabbed Interfaces (QTabWidget)

from PyQt5.QtWidgets import QTabWidget, QTextEdit, QWidget

class TabDemo(QWidget):
    def __init__(self):
        super().__init__()
        
        tabs = QTabWidget()
        
        # Tab 1: Text Editor
        tab1 = QWidget()
        text_edit = QTextEdit()
        tab1_layout = QVBoxLayout()
        tab1_layout.addWidget(text_edit)
        tab1.setLayout(tab1_layout)
        
        # Tab 2: Settings
        tab2 = QWidget()
        tab2_layout = QVBoxLayout()
        tab2_layout.addWidget(QLabel("Settings Panel"))
        tab2.setLayout(tab2_layout)
        
        tabs.addTab(tab1, "Editor")
        tabs.addTab(tab2, "Settings")
        
        main_layout = QVBoxLayout()
        main_layout.addWidget(tabs)
        self.setLayout(main_layout)

### 2. Tree Widget (QTreeWidget)

def setup_file_tree(self):
    tree = QTreeWidget()
    tree.setHeaderLabels(["Name", "Size", "Type"])
    
    # Add parent items
    root = QTreeWidgetItem(tree)
    root.setText(0, "Project Root")
    
    # Add children
    for file in ["main.py", "config.ini", "README.md"]:
        child = QTreeWidgetItem(root)
        child.setText(0, file)
        child.setText(1, "10 KB")
        child.setText(2, "Python" if file.endswith(".py") else "Text")
    
    tree.expandAll()
    return tree

### 3. Table Widget (QTableWidget)

def setup_data_table(self):
    table = QTableWidget(5, 3)  # Rows, columns
    table.setHorizontalHeaderLabels(["ID", "Name", "Status"])
    
    sample_data = [
        [101, "Product A", "Active"],
        [102, "Product B", "Inactive"],
        [103, "Product C", "Pending"]
    ]
    
    for row, data in enumerate(sample_data):
        for col, text in enumerate(data):
            item = QTableWidgetItem(str(text))
            table.setItem(row, col, item)
    
    table.resizeColumnsToContents()
    return table

--- ## 🔹 Custom Signals & Slots ### 1. Creating Custom Signals

from PyQt5.QtCore import pyqtSignal, QObject

class Worker(QObject):
    progress_changed = pyqtSignal(int)
    task_completed = pyqtSignal(str)
    
    def run_task(self):
        for i in range(1, 101):
            time.sleep(0.05)
            self.progress_changed.emit(i)
        self.task_completed.emit("Task finished!")

### 2. Advanced Signal-Slot Connections

# Multiple signals to single slot
button1.clicked.connect(self.handle_click)
button2.clicked.connect(self.handle_click)

# Signal with arguments
self.worker.progress_changed.connect(self.update_progress_bar)

# Lambda slots
button.clicked.connect(lambda: self.process_data(param1, param2))

# Slot decorator
@pyqtSlot()
def on_button_click(self):
    print("Button clicked!")

--- ## 🔹 Styling with Qt Style Sheets (QSS) ### 1. Basic Styling

app.setStyleSheet("""
    QPushButton {
        background-color: #4CAF50;
        border: none;
        color: white;
        padding: 8px 16px;
        font-size: 14px;
    }
    QPushButton:hover {
        background-color: #45a049;
    }
    QLineEdit {
        padding: 5px;
        border: 1px solid #ccc;
        border-radius: 3px;
    }
""")

### 2. Advanced Selectors

/* Style only buttons in the toolbar */
QToolBar QPushButton {
    min-width: 80px;
}

/* Style checked checkboxes differently */
QCheckBox:checked {
    color: #0085FF;
}

/* Style odd/even table rows */
QTableView::item:alternate {
    background: #f0f0f0;
}

### 3. Dynamic Style Changes

# Change style programmatically
button.setStyleSheet("""
    QPushButton {
        background-color: red;
        font-weight: bold;
    }
""")

# Reset to default
button.setStyleSheet("")

---

from PyQt5.QtWidgets import (QApplication, QWidget, QVBoxLayout, 
                            QLabel, QLineEdit, QPushButton)

class ConverterApp(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Temperature Converter")
        self.setup_ui()
    
    def setup_ui(self):
        # Create widgets
        self.celsius_input = QLineEdit()
        self.fahrenheit_input = QLineEdit()
        self.convert_btn = QPushButton("Convert")
        self.result_label = QLabel("Enter temperature to convert")
        
        # Set up layout
        layout = QVBoxLayout()
        layout.addWidget(QLabel("Celsius:"))
        layout.addWidget(self.celsius_input)
        layout.addWidget(QLabel("Fahrenheit:"))
        layout.addWidget(self.fahrenheit_input)
        layout.addWidget(self.convert_btn)
        layout.addWidget(self.result_label)
        
        # Connect button click
        self.convert_btn.clicked.connect(self.convert)
        
        self.setLayout(layout)
    
    def convert(self):
        try:
            if self.celsius_input.text():
                # Celsius to Fahrenheit
                celsius = float(self.celsius_input.text())
                fahrenheit = (celsius * 9/5) + 32
                self.fahrenheit_input.setText(f"{fahrenheit:.2f}")
                self.result_label.setText("Conversion complete!")
            elif self.fahrenheit_input.text():
                # Fahrenheit to Celsius
                fahrenheit = float(self.fahrenheit_input.text())
                celsius = (fahrenheit - 32) * 5/9
                self.celsius_input.setText(f"{celsius:.2f}")
                self.result_label.setText("Conversion complete!")
        except ValueError:
            self.result_label.setText("Please enter a valid number!")

if __name__ == "__main__":
    app = QApplication([])
    window = ConverterApp()
    window.show()
    app.exec_()

--- ## 🔹 PyQt5 Designer Tool Qt Designer lets you create UIs visually: 1. Launch Designer:

   pyqt5-tools designer
   

2. Design your interface (saves as .ui file) 3. Convert to Python code:

   pyuic5 input.ui -o output.py
   

Example Usage:

from PyQt5 import uic
class MyApp(QMainWindow):
    def __init__(self):
        super().__init__()
        uic.loadUi('design.ui', self)  # Load UI file

--- ## 🔹 Event Handling Basics PyQt5 uses signals and slots for interactivity:

# Connecting signals to slots
button.clicked.connect(self.on_button_click)
checkbox.stateChanged.connect(self.on_checkbox_change)
line_edit.textChanged.connect(self.on_text_change)

# Example slot methods
def on_button_click(self):
    print("Button clicked!")

def on_checkbox_change(self, state):
    print("Checkbox state:", state)

def on_text_change(self, text):
    print("Text changed to:", text)

--- ## 🔹 Best Practices for Beginners 1. Organize code in classes/methods 2. Use layouts instead of absolute positioning 3. Name widgets clearly (e.g., self.login_btn) 4. Separate UI code from business logic 5. Handle errors gracefully in event handlers --- ### 📌 What's Next? In Part 2, we'll cover: ➡️ Advanced Widgets (Tables, Trees, Tabs) ➡️ Custom Signals ➡️ Styling with QSS ➡️ Multiple Windows #PyQt5Tutorial #GUIPython #LearnToCode 🚀 Practice Exercise: 1. Create a simple calculator app 2. Build a text editor with save/load buttons 3. Make a color picker that changes window background

# 📚 PyQt5 Tutorial - Part 1/6: Introduction to GUI Programming #PyQt5 #Python #GUI #BeginnerFriendly #Qt Welcome to Part 1 of our comprehensive PyQt5 series! This lesson will introduce you to GUI development with Python and PyQt5, perfect for beginners. --- ## 🔹 What is PyQt5? PyQt5 is a set of Python bindings for Qt (a powerful C++ GUI framework). It lets you create: - Desktop applications - Cross-platform GUIs - Professional-looking interfaces - Apps with databases, networking, and multimedia Key Features: ✔️ 620+ classes ✔️ 6,000+ functions ✔️ Windows, Mac, Linux support ✔️ Open-source (GPL/commercial licenses) --- ## 🔹 Installation Install PyQt5 and tools:

pip install PyQt5 PyQt5-tools

Verify Installation:

import PyQt5
print(PyQt5.__version__)  # Should show version like 5.15.4

--- ## 🔹 Your First PyQt5 App Let's create a simple window:

import sys
from PyQt5.QtWidgets import QApplication, QLabel, QWidget

# 1. Create the application object
app = QApplication(sys.argv)

# 2. Create main window
window = QWidget()
window.setWindowTitle("My First App")
window.setGeometry(100, 100, 400, 200)  # x, y, width, height

# 3. Add a label
label = QLabel("Hello PyQt5!", parent=window)
label.move(150, 80)  # x, y position

# 4. Show the window
window.show()

# 5. Run the application
sys.exit(app.exec_())

Code Breakdown: 1. QApplication: Manages app control flow 2. QWidget: Base class for all UI objects 3. QLabel: Displays text/images 4. exec_(): Starts the event loop --- ## 🔹 Core PyQt5 Components ### 1. Main Window Types | Class | Purpose | |-------|---------| | QWidget | Basic empty window | | QMainWindow | With menu bar, status bar, toolbars | | QDialog | Popup dialog windows | ### 2. Common Widgets

from PyQt5.QtWidgets import (
    QPushButton,  # Clickable button
    QLineEdit,    # Single-line text input
    QTextEdit,    # Multi-line text area
    QCheckBox,    # Toggle option
    QRadioButton, # Exclusive choice
    QComboBox,    # Dropdown menu
    QSlider       # Value selector
)

### 3. Layout Managers

from PyQt5.QtWidgets import (
    QVBoxLayout,  # Vertical arrangement
    QHBoxLayout,  # Horizontal arrangement
    QGridLayout   # Grid arrangement
)

--- ## 🔹 Creating a Functional App Let's build a temperature converter:

🙏💸 500$ FOR THE FIRST 500 WHO JOIN THE CHANNEL! 🙏💸 Join our channel today for free! Tomorrow it will cost 500$! https://t.me/+QHlfCJcO2lRjZWVl You can join at this link! 👆👇 https://t.me/+QHlfCJcO2lRjZWVl

We need a 5 girls programmers from italy , Ukraine, Russia, Spain Salary: 6500$ Job: online Requirements: send your cv as pdf Contact @AbbyTatum t.me/AbbyTatum | #InsideAds