# وارد کردن کتابخانه‌های مورد نیاز
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score

# آماده‌سازی داده‌ها
data = {
    'ساعت_مطالعه': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
    'نمره': [2, 3, 6, 8, 11, 12, 15, 16, 18, 20]
}
df = pd.DataFrame(data)

# تقسیم داده‌ها به دو دسته آموزش و آزمون
X = df[['ساعت_مطالعه']]
y = df['نمره']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# ایجاد مدل رگرسیون خطی
model = LinearRegression()
model.fit(X_train, y_train)

# پیش‌بینی و ارزیابی مدل
y_pred = model.predict(X_test)
mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

# نمایش نتایج
print(f"Mean Squared Error: {mse}")
print(f"R2 Score: {r2}")

# نمایش گرافیکی نتایج
plt.scatter(X_test, y_test, color='blue', label='Actual')
plt.plot(X_test, y_pred, color='red', linewidth=2, label='Predicted')
plt.xlabel('ساعت مطالعه')
plt.ylabel('نمره')
plt.legend()
plt.show()

# وارد کردن کتابخانه‌های مورد نیاز
from tkinter import *

# ایجاد و پیکربندی پنجره اصلی
root = Tk()
root.title("ماشین حساب")
root.geometry("400x600")

# تعریف نمایشگر
display = Entry(root, font=('Arial', 24), borderwidth=2, relief="solid", justify='right')
display.grid(row=0, column=0, columnspan=4, pady=20)

# تعریف توابع عملیات
def button_click(value):
    current_text = display.get()
    display.delete(0, END)
    display.insert(0, current_text + value)

def button_clear():
    display.delete(0, END)

def button_equal():
    try:
        result = eval(display.get())
        display.delete(0, END)
        display.insert(0, str(result))
    except:
        display.delete(0, END)
        display.insert(0, "خطا")

# تعریف دکمه‌ها
buttons = [
    '7', '8', '9', '/',
    '4', '5', '6', '*',
    '1', '2', '3', '-',
    '0', '.', '=', '+'
]

row_val = 1
col_val = 0

for button in buttons:
    if button == '=':
        btn = Button(root, text=button, font=('Arial', 18), command=button_equal)
    elif button == 'C':
        btn = Button(root, text=button, font=('Arial', 18), command=button_clear)
    else:
        btn = Button(root, text=button, font=('Arial', 18), command=lambda b=button: button_click(b))
    btn.grid(row=row_val, column=col_val, ipadx=10, ipady=10, padx=5, pady=5, sticky="nsew")
    col_val += 1
    if col_val > 3:
        col_val = 0
        row_val += 1

# دکمه پاک کردن
btn_clear = Button(root, text='C', font=('Arial', 18), command=button_clear)
btn_clear.grid(row=row_val, column=col_val, ipadx=10, ipady=10, padx=5, pady=5, sticky="nsew")

# راه‌اندازی برنامه
root.mainloop()

def memoize(f):
    memo = {}
    def helper(x):
        if x not in memo:            
            memo[x] = f(x)
        return memo[x]
    return helper

@memoize
def some_expensive_computation(x):
    # اینجا محاسبات پرهزینه‌ای که نیاز به بهینه‌سازی دارد قرار می‌گیرد
    pass

import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)
GPIO.setup(18, GPIO.OUT)

while True:
    GPIO.output(18, GPIO.HIGH)
    time.sleep(1)
    GPIO.output(18, GPIO.LOW)
    time.sleep(1)

import serial

ser = serial.Serial('/dev/ttyUSB0', 9600)

while True:
    line = ser.readline()
    print(line.decode('utf-8').strip())

import adafruit_dht
import board

dhtDevice = adafruit_dht.DHT22(board.D4)

while True:
    try:
        temperature = dhtDevice.temperature
        humidity = dhtDevice.humidity
        print(f"Temp: {temperature:.1f} C    Humidity: {humidity:.1f}% ")
    except RuntimeError as error:
        print(error.args[0])

my_list = [1, 2, 3, 4, 5]
print(my_list)
# خروجی: [1, 2, 3, 4, 5]

my_list.append(6)
print(my_list)
# خروجی: [1, 2, 3, 4, 5, 6]

my_list.remove(3)
print(my_list)
# خروجی: [1, 2, 4, 5, 6]

print(my_list[2])
# خروجی: 4

stack = []
stack.append(1)
stack.append(2)
print(stack)
# خروجی: [1, 2]

stack.pop()
print(stack)
# خروجی: [1]

stack.append(3)
print(stack)
# خروجی: [1, 3]

class Node:
    def __init__(self, key):
        self.left = None
        self.right = None
        self.val = key

root = Node(1)
root.left = Node(2)
root.right = Node(3)
print(root.val) # 1
print(root.left.val) # 2
print(root.right.val) # 3

from collections import deque
queue = deque([1, 2, 3])
queue.append(4)
queue.popleft()
print(queue)
# خروجی: deque([2, 3, 4])

hash_map = {}
hash_map['key1'] = 'value1'
print(hash_map['key1'])
# خروجی: value1

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

def unique_paths(m, n):
    dp = [[1] * n for _ in range(m)]
    for i in range(1, m):
        for j in range(1, n):
            dp[i][j] = ___
    return dp[m-1][n-1]

   curl -L https://astral.sh/uv/install.sh | sh
   

   uv install <package-name>
   

   uv install numpy
   

   uv install -r requirements.txt
   

   uv install /path/to/package
   

   uv env create
   

   source uv-env/bin/activate
   

   deactivate
   

   uv install git+https://github.com/user/repo.git
   

   uv install -e .
   

pip install theano

import theano
import theano.tensor as T

# تعریف متغیرها
x = T.dscalar('x')
y = T.dscalar('y')

# تعریف تابع
z = x + y

# کامپایل کردن تابع
f = theano.function([x, y], z)

# استفاده از تابع
result = f(2, 3)
print(result)  # خروجی: 5

import numpy as np

# تعریف متغیرهای ورودی و وزن‌ها
X = T.dmatrix('X')
W = theano.shared(np.random.randn(2, 1), name='W')
b = theano.shared(0., name='b')

# تعریف تابع شبکه عصبی
output = T.nnet.sigmoid(T.dot(X, W) + b)

# کامپایل کردن تابع
predict = theano.function([X], output)

# ورودی نمونه
X_sample = np.array([[1, 2], [3, 4], [5, 6]])

# پیش‌بینی
predictions = predict(X_sample)
print(predictions)