❗️🆕️یه کد کار بردی جدید

👇این یکی آپدیت اون کدی هست که CPU رو اسکن می‌کرد این یکی یه جدول درست میکنه و اطلاعات سخت افزاری دستگاه نشون می‌ده 👇

🟥البته که این کد روی همه سیستم عامل ها و سخت افزار ها کار می‌کنه ❗️

import psutil
import GPUtil


def get_cpu_specs():
    cpu_freq = psutil.cpu_freq().current
    return f"{cpu_freq / 1000:.2f} GHz"


def get_ram_specs():
    ram = psutil.virtual_memory().total
    return f"{ram / (1024**3):.2f} GB"


def get_gpu_specs():
    gpus = GPUtil.getGPUs()
    if gpus:
        gpu = gpus[0]
        return f"{gpu.name}, {gpu.memoryTotal} MB"
    else:
        return "No GPU found"


def get_ssd_specs():
    disk_info = psutil.disk_usage('/')
    return f"{disk_info.total / (1024**3):.2f} GB"


def draw_specs_table():
    components = {
        'CPU': get_cpu_specs(),
        'RAM': get_ram_specs(),
        'GPU': get_gpu_specs(),
        'SSD': get_ssd_specs()
    }
    
    header = "| Component | Specs         |"
    separator = "+" + "-" * (len(header) - 2) + "+"
    
    print(separator)
    print(header)
    print(separator)
    
    for component, specs in components.items():
        line = f"| {component.ljust(9)} | {specs.ljust(13)} |"
        print(line)
        print(separator)


draw_specs_table()

[اینم کانال منه]

❗️ری اکشن یادتون نره😉

#cpu #پایتون #کاربردی

🖥️ آموزش شبیه‌سازی ساده CPU با پایتون 🐍

سلام دوستان! 😊 امروز می‌خواهیم یاد بگیریم چطور می‌توانیم یک شبیه‌سازی ساده از یک CPU با پایتون ایجاد کنیم تا تأثیر کدهای مختلف روی منابع سیستم را مشاهده کنیم. این کار به ما کمک می‌کند تا بفهمیم چگونه کدهای ما می‌توانند بر عملکرد CPU تأثیر بگذارند. 🌟

🔹 ایجاد شبیه‌سازی ساده CPU

در این شبیه‌سازی، ما یک CPU ساده ایجاد می‌کنیم که می‌تواند دستورات پایه‌ای مانند جمع، تفریق، ضرب و تقسیم را اجرا کند و میزان استفاده از منابع را بررسی کند.

1. نصب کتابخانه‌های مورد نیاز 🛠️

ابتدا، مطمئن شوید که پایتون و کتابخانه‌های مورد نیاز نصب شده‌اند. شما نیاز به نصب psutil برای بررسی میزان استفاده از منابع دارید. برای نصب این کتابخانه، از دستور زیر استفاده کنید:

pip install psutil

2. ایجاد فایل پایتون 📄

یک فایل به نام cpu_simulator.py ایجاد کنید و محتوای زیر را در آن قرار دهید:

import psutil
import time

class SimpleCPU:
    def __init__(self):
        self.register = 0
    
    def execute(self, instructions):
        for instruction in instructions:
            if instruction[0] == "ADD":
                self.register += instruction[1]
            elif instruction[0] == "SUB":
                self.register -= instruction[1]
            elif instruction[0] == "MUL":
                self.register *= instruction[1]
            elif instruction[0] == "DIV":
                if instruction[1] != 0:
                    self.register /= instruction[1]
            print(f"Executed {instruction}: Register = {self.register}")

def monitor_resources(duration=10):
    for _ in range(duration):
        cpu_usage = psutil.cpu_percent(interval=1)
        memory_info = psutil.virtual_memory()
        print(f"CPU Usage: {cpu_usage}%")
        print(f"Memory Usage: {memory_info.percent}%")
        time.sleep(1)

if __name__ == "__main__":
    cpu = SimpleCPU()
    instructions = [
        ("ADD", 10),
        ("MUL", 2),
        ("SUB", 5),
        ("DIV", 3)
    ]
    
    print("Starting CPU simulation...")
    cpu.execute(instructions)
    
    print("Monitoring system resources...")
    monitor_resources()

3. اجرای شبیه‌سازی 🚀

برای اجرای شبیه‌سازی، دستور زیر را در خط فرمان (Command Line) وارد کنید:

python cpu_simulator.py

این کد ابتدا یک سری دستورات را روی شبیه‌سازی CPU اجرا می‌کند و سپس میزان استفاده از منابع سیستم را به مدت 10 ثانیه مانیتور می‌کند.

🔹 توضیحات:

- SimpleCPU Class: این کلاس یک CPU ساده را شبیه‌سازی می‌کند که دارای یک رجیستر است و می‌تواند دستورات پایه‌ای را اجرا کند.
- execute Method: این متد دستورات را یکی یکی اجرا می‌کند و نتیجه را در رجیستر ذخیره می‌کند.
- monitor_resources Function: این تابع میزان استفاده از CPU و حافظه را به مدت 10 ثانیه مانیتور می‌کند و نتایج را چاپ می‌کند.

🌟 نکات تکمیلی
- این شبیه‌سازی بسیار ساده است و فقط برای درک اولیه از نحوه عملکرد CPU و تاثیر دستورات مختلف بر روی منابع سیستم طراحی شده است.
- برای شبیه‌سازی‌های پیچیده‌تر، می‌توانید به مطالعه معماری کامپیوتر و سیستم‌های دیجیتال بپردازید.

(My chanel)

#پایتون #شبیه_سازی #CPU #برنامه_نویسی #آموزش #تلگرام #Python #تلگرام

❗️اینم ایک نمونه CPU شبیح سازی شده با پایتون 👇

import psutil
import time

class AdvancedCPU:
    def __init__(self):
        self.registers = [0] * 8  # Initialize 8 registers
        self.program_counter = 0  # Initialize program counter
        self.instructions = []  # List to store instructions
    
    def load_instructions(self, instructions):
        """ Load instructions into CPU """
        self.instructions = instructions
    
    def execute(self):
        """ Execute loaded instructions """
        while self.program_counter < len(self.instructions):
            instruction = self.instructions[self.program_counter]
            self.program_counter += 1
            self._execute_instruction(instruction)
    
    def _execute_instruction(self, instruction):
        """ Execute a single instruction """
        cmd, *args = instruction
        if cmd == "ADD":
            self._add(args)
        elif cmd == "SUB":
            self._sub(args)
        elif cmd == "MUL":
            self._mul(args)
        elif cmd == "DIV":
            self._div(args)
        elif cmd == "MOV":
            self._mov(args)
        elif cmd == "PRT":
            self._prt(args)
    
    def _add(self, args):
        """ Add values in registers """
        reg1, reg2 = args
        self.registers[reg1] += self.registers[reg2]
    
    def _sub(self, args):
        """ Subtract values in registers """
        reg1, reg2 = args
        self.registers[reg1] -= self.registers[reg2]
    
    def _mul(self, args):
        """ Multiply values in registers """
        reg1, reg2 = args
        self.registers[reg1] *= self.registers[reg2]
    
    def _div(self, args):
        """ Divide values in registers """
        reg1, reg2 = args
        if self.registers[reg2] != 0:
            self.registers[reg1] /= self.registers[reg2]
    
    def _mov(self, args):
        """ Move value to register """
        reg, value = args
        self.registers[reg] = value
    
    def _prt(self, args):
        """ Print value of register """
        reg = args[0]
        print(f"Register {reg} = {self.registers[reg]}")

def monitor_resources(duration=10):
    """ Monitor CPU and memory usage """
    for _ in range(duration):
        cpu_usage = psutil.cpu_percent(interval=1)
        memory_info = psutil.virtual_memory()
        print(f"CPU Usage: {cpu_usage}%")
        print(f"Memory Usage: {memory_info.percent}%")
        time.sleep(1)

if __name__ == "__main__":
    cpu = AdvancedCPU()
    instructions = [
        ("MOV", 0, 10),    # Move 10 to register 0
        ("MOV", 1, 20),    # Move 20 to register 1
        ("ADD", 0, 1),     # Add register 0 and 1, store in register 0
        ("MUL", 0, 1),     # Multiply register 0 and 1, store in register 0
        ("SUB", 0, 1),     # Subtract register 1 from register 0, store in register 0
        ("DIV", 0, 1),     # Divide register 0 by register 1, store in register 0
        ("PRT", 0)         # Print value of register 0
    ]
    
    print("Loading instructions into CPU...")
    cpu.load_instructions(instructions)
    
    print("Starting CPU simulation...")
    cpu.execute()
    
    print("Monitoring system resources...")
    monitor_resources()

(کانال اموزش پایتون)

#پایتون #نمونه #کد #CPU

🎯 روش پخش کردن بار پردازشی کد روی تمام هسته‌های CPU برای افزایش سرعت اجرا 🚀

امروزه که پردازنده‌ها چند‌هسته‌ای شده‌اند، یکی از بهترین راه‌های بهینه‌سازی کد و افزایش سرعت اجرای برنامه‌ها، استفاده از تمام هسته‌های CPU است. 🖥️ اگر کد شما فقط روی یک هسته اجرا شود، توانایی‌های کامل سیستم را به کار نمی‌گیرد و سرعت اجرای برنامه کمتر از حد انتظار خواهد بود.

🔍 مقدمه
پردازنده‌های مدرن (CPU) معمولاً دارای چندین هسته هستند که به شما این امکان را می‌دهند تا چندین کار را به طور همزمان اجرا کنید. استفاده از این توانایی‌ها برای تقسیم بار پردازشی به "چند وظیفه‌ای" یا "چند نخی" معروف است. در پایتون، به دلیل محدودیت‌های GIL (Global Interpreter Lock) ممکن است نتوان به راحتی از تمام هسته‌ها استفاده کرد. اما با استفاده از کتابخانه‌های خاص مثل multiprocessing می‌توانید این محدودیت را دور بزنید و بار پردازشی را به خوبی بین هسته‌های مختلف پخش کنید. ⚙️

🚧 موضوع: پخش بار پردازشی با multiprocessing در پایتون
کتابخانه‌ی multiprocessing به شما این امکان را می‌دهد که فرآیندهای مختلفی را به‌طور همزمان اجرا کنید و از همه‌ی هسته‌های CPU بهره ببرید. هر فرآیند مستقل از دیگری عمل می‌کند، بنابراین مشکلات GIL دیگر وجود نخواهد داشت.

💻 مثال کد:

import multiprocessing

def task(n):
    print(f"Running task {n}...")

if __name__ == "__main__":
    processes = []
    for i in range(multiprocessing.cpu_count()):  # تعداد هسته‌های CPU
        p = multiprocessing.Process(target=task, args=(i,))
        processes.append(p)
        p.start()

    for p in processes:
        p.join()

🔍 توضیح کد:
1. ما از کتابخانه‌ی multiprocessing استفاده می‌کنیم که امکان ایجاد فرآیندهای جداگانه برای اجرای کد را فراهم می‌کند. 🧠
2. تابع task یک وظیفه‌ی ساده است که برای هر فرآیند اجرا می‌شود.
3. در قسمت اصلی برنامه، با استفاده از multiprocessing.cpu_count() تعداد هسته‌های CPU را شناسایی کرده و به ازای هر هسته یک فرآیند ایجاد می‌کنیم. 🔄
4. در نهایت، فرآیندها را با start() اجرا می‌کنیم و با join() مطمئن می‌شویم که همه فرآیندها به اتمام برسند. ✅

این روش می‌تواند به طرز چشمگیری سرعت اجرای برنامه‌های شما را افزایش دهد، به خصوص در پردازش‌های سنگین و زمان‌بر. ⏳

(اینجا عضو شو تا بیشتر بدونی)

#بهینه_سازی #برنامه_نویسی #چند_نخی #پایتون #CPU #Multiprocessing #افزایش_سرعت #پردازش