4.1 Python Asoslari — Masalalar
Jami: 25 ta | Yechim bilan: ✅
Asosiy Masalalar (1-10)
Masala 1 ⭐⭐
Sensor qiymatini Celsius dan Fahrenheit ga aylantiring. Formula: F = C × 9/5 + 32
Yechim
def celsius_to_fahrenheit(celsius):
return celsius * 9/5 + 32
# Test
print(celsius_to_fahrenheit(0)) # 32
print(celsius_to_fahrenheit(100)) # 212
print(celsius_to_fahrenheit(25)) # 77
Masala 2 ⭐⭐
Ro'yxatdagi maksimal, minimal va o'rtacha qiymatlarni toping.
Yechim
def analyze_data(data):
return {
"min": min(data),
"max": max(data),
"avg": sum(data) / len(data)
}
# Test
sensor_data = [23, 45, 12, 67, 34, 89, 21]
result = analyze_data(sensor_data)
print(result) # {'min': 12, 'max': 89, 'avg': 41.57...}
Masala 3 ⭐⭐
Batareya foizini hisoblang. 3S LiPo: min=9.0V, max=12.6V.
Yechim
def battery_percent(voltage, v_min=9.0, v_max=12.6):
if voltage <= v_min:
return 0
if voltage >= v_max:
return 100
return (voltage - v_min) / (v_max - v_min) * 100
# Test
print(f"{battery_percent(10.8):.1f}%") # 50.0%
print(f"{battery_percent(12.0):.1f}%") # 83.3%
print(f"{battery_percent(9.5):.1f}%") # 13.9%
Masala 4 ⭐⭐
4 ta motor tezligini ro'yxatda saqlang va ularning o'rtachasini hisoblang.
Yechim
motor_speeds = [1200, 1350, 1180, 1420] # RPM
average_speed = sum(motor_speeds) / len(motor_speeds)
print(f"O'rtacha tezlik: {average_speed:.0f} RPM")
# Yoki NumPy bilan
import numpy as np
print(f"O'rtacha: {np.mean(motor_speeds):.0f} RPM")
Masala 5 ⭐⭐
Koordinatalar orasidagi masofani hisoblang (3D).
Yechim
import math
def distance_3d(p1, p2):
"""Ikki nuqta orasidagi 3D masofa"""
dx = p2[0] - p1[0]
dy = p2[1] - p1[1]
dz = p2[2] - p1[2]
return math.sqrt(dx**2 + dy**2 + dz**2)
# Test
point1 = (0, 0, 0)
point2 = (3, 4, 0)
print(f"Masofa: {distance_3d(point1, point2):.1f} m") # 5.0 m
point3 = (1, 2, 3)
point4 = (4, 6, 3)
print(f"Masofa: {distance_3d(point3, point4):.1f} m") # 5.0 m
Masala 6 ⭐⭐
Tezlikni km/h dan m/s ga aylantiring va aksincha.
Yechim
def kmh_to_ms(kmh):
return kmh / 3.6
def ms_to_kmh(ms):
return ms * 3.6
# Test
print(f"36 km/h = {kmh_to_ms(36):.1f} m/s") # 10.0 m/s
print(f"20 m/s = {ms_to_kmh(20):.1f} km/h") # 72.0 km/h
Masala 7 ⭐⭐
Burchakni radian dan daraja va aksincha aylantiring.
Yechim
import math
def deg_to_rad(degrees):
return degrees * math.pi / 180
def rad_to_deg(radians):
return radians * 180 / math.pi
# Test
print(f"90° = {deg_to_rad(90):.4f} rad") # 1.5708 rad
print(f"π rad = {rad_to_deg(math.pi):.1f}°") # 180.0°
Masala 8 ⭐⭐
Lug'atdan dron konfiguratsiyasini o'qing va ekranga chiqaring.
Yechim
drone_config = {
"name": "QuadX",
"motors": 4,
"max_speed": 20,
"battery": {"voltage": 11.1, "capacity": 5000},
"sensors": ["IMU", "GPS", "Barometer", "Sonar"]
}
print(f"Nomi: {drone_config['name']}")
print(f"Motorlar: {drone_config['motors']} ta")
print(f"Batareya: {drone_config['battery']['voltage']}V, {drone_config['battery']['capacity']}mAh")
print(f"Sensorlar: {', '.join(drone_config['sensors'])}")
Masala 9 ⭐⭐
Ro'yxatdagi juft sonlarni filtrlang.
Yechim
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# Usul 1: for loop
evens = []
for n in numbers:
if n % 2 == 0:
evens.append(n)
print(evens) # [2, 4, 6, 8, 10]
# Usul 2: list comprehension
evens = [n for n in numbers if n % 2 == 0]
print(evens)
# Usul 3: filter
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)
Masala 10 ⭐⭐
PWM qiymatni 0-255 oralig'iga cheklang (clamp).
Yechim
def clamp(value, min_val=0, max_val=255):
"""Qiymatni belgilangan oraliqda cheklash"""
return max(min_val, min(value, max_val))
# Test
print(clamp(300)) # 255
print(clamp(-50)) # 0
print(clamp(128)) # 128
# Ro'yxat uchun
values = [-10, 50, 200, 400, 128]
clamped = [clamp(v) for v in values]
print(clamped) # [0, 50, 200, 255, 128]
O'rtacha Masalalar (11-18)
Masala 11 ⭐⭐⭐
Motor klassini yarating: start(), stop(), set_speed() metodlari bilan.
Yechim
class Motor:
def __init__(self, pin, name="Motor"):
self.pin = pin
self.name = name
self.speed = 0
self.is_running = False
def start(self, speed=50):
self.speed = max(0, min(speed, 100))
self.is_running = True
print(f"{self.name} ishga tushdi: {self.speed}%")
def stop(self):
self.speed = 0
self.is_running = False
print(f"{self.name} to'xtadi")
def set_speed(self, speed):
if not self.is_running:
print(f"{self.name} ishlamayapti!")
return
self.speed = max(0, min(speed, 100))
print(f"{self.name} tezlik: {self.speed}%")
def status(self):
state = "ON" if self.is_running else "OFF"
return f"{self.name}: {state}, {self.speed}%"
# Test
m1 = Motor(9, "Front-Left")
m1.start(75)
m1.set_speed(90)
print(m1.status())
m1.stop()
Masala 12 ⭐⭐⭐
PID controller klassini yarating.
Yechim
class PIDController:
def __init__(self, kp, ki, kd, dt=0.01):
self.kp = kp
self.ki = ki
self.kd = kd
self.dt = dt
self.integral = 0
self.prev_error = 0
def compute(self, setpoint, measured):
error = setpoint - measured
# P
p = self.kp * error
# I
self.integral += error * self.dt
i = self.ki * self.integral
# D
derivative = (error - self.prev_error) / self.dt
d = self.kd * derivative
self.prev_error = error
return p + i + d
def reset(self):
self.integral = 0
self.prev_error = 0
# Test
pid = PIDController(kp=1.0, ki=0.1, kd=0.05)
setpoint = 100
measured = 80
for _ in range(10):
output = pid.compute(setpoint, measured)
measured += output * 0.1 # Simulated response
print(f"Setpoint: {setpoint}, Measured: {measured:.2f}, Output: {output:.2f}")
Masala 13 ⭐⭐⭐
Sensor ma'lumotlarini moving average bilan filtrlang.
Yechim
from collections import deque
class MovingAverage:
def __init__(self, window_size=5):
self.window_size = window_size
self.values = deque(maxlen=window_size)
def add(self, value):
self.values.append(value)
return self.get_average()
def get_average(self):
if not self.values:
return 0
return sum(self.values) / len(self.values)
# Test
filter = MovingAverage(window_size=5)
raw_data = [10, 12, 8, 15, 9, 11, 14, 7, 13, 10]
print("Raw -> Filtered:")
for value in raw_data:
filtered = filter.add(value)
print(f"{value:3} -> {filtered:.1f}")
Masala 14 ⭐⭐⭐
JSON konfiguratsiya faylini o'qing va yozing.
Yechim
import json
def save_config(config, filename):
with open(filename, 'w') as f:
json.dump(config, f, indent=2)
print(f"Konfiguratsiya saqlandi: {filename}")
def load_config(filename):
try:
with open(filename, 'r') as f:
return json.load(f)
except FileNotFoundError:
print(f"Fayl topilmadi: {filename}")
return None
# Test
drone_config = {
"name": "TestDrone",
"pid": {"kp": 1.0, "ki": 0.1, "kd": 0.05},
"max_altitude": 100,
"sensors_enabled": True
}
save_config(drone_config, "drone_config.json")
loaded = load_config("drone_config.json")
print(f"Yuklangan: {loaded}")
Masala 15 ⭐⭐⭐
Exception handling bilan sensor o'qish funksiyasini yozing.
Yechim
import random
class SensorError(Exception):
"""Sensor xatoligi"""
pass
def read_sensor(sensor_id):
"""Sensorni o'qish (simulyatsiya)"""
if sensor_id < 0 or sensor_id > 5:
raise ValueError(f"Noto'g'ri sensor ID: {sensor_id}")
# Random xatolik
if random.random() < 0.1:
raise SensorError(f"Sensor {sensor_id} javob bermadi")
return random.uniform(0, 100)
def safe_read_sensor(sensor_id, retries=3):
"""Xavfsiz sensor o'qish"""
for attempt in range(retries):
try:
value = read_sensor(sensor_id)
return value
except SensorError as e:
print(f"Urinish {attempt+1}: {e}")
if attempt == retries - 1:
return None
except ValueError as e:
print(f"Xatolik: {e}")
return None
# Test
for i in range(3):
value = safe_read_sensor(i)
if value is not None:
print(f"Sensor {i}: {value:.2f}")
Masala 16 ⭐⭐⭐
Waypoint ro'yxatini yarating va eng yaqinini toping.
Yechim
import math
def distance(p1, p2):
return math.sqrt((p2[0]-p1[0])**2 + (p2[1]-p1[1])**2)
def find_nearest_waypoint(current_pos, waypoints):
"""Eng yaqin waypoint ni topish"""
if not waypoints:
return None
nearest = min(waypoints, key=lambda wp: distance(current_pos, wp))
dist = distance(current_pos, nearest)
return nearest, dist
# Test
waypoints = [
(10, 20),
(30, 40),
(15, 25),
(50, 10),
(5, 5)
]
current = (12, 22)
nearest, dist = find_nearest_waypoint(current, waypoints)
print(f"Hozirgi pozitsiya: {current}")
print(f"Eng yaqin waypoint: {nearest}, masofa: {dist:.2f}")
Masala 17 ⭐⭐⭐
Gyroscope ma'lumotlarini simulyatsiya qiling va drift ni hisoblang.
Yechim
import random
import numpy as np
class Gyroscope:
def __init__(self, bias=0.01, noise_std=0.1):
self.bias = bias # Drift per reading
self.noise_std = noise_std
self.angle = 0
def read(self, true_angular_velocity, dt):
# True angle change
true_change = true_angular_velocity * dt
# Add bias and noise
measured = true_angular_velocity + self.bias + random.gauss(0, self.noise_std)
# Integrate
self.angle += measured * dt
return measured
def get_angle(self):
return self.angle
# Test
gyro = Gyroscope(bias=0.02, noise_std=0.05)
true_angle = 0
dt = 0.01
for i in range(1000):
# True angular velocity: 0 (stationary)
measured = gyro.read(0, dt)
print(f"Haqiqiy burchak: {true_angle}°")
print(f"Gyro burchak (drift bilan): {gyro.get_angle():.2f}°")
print(f"Drift: {gyro.get_angle() - true_angle:.2f}°")
Masala 18 ⭐⭐⭐
State machine bilan dron holatlarini boshqaring.
Yechim
from enum import Enum
class DroneState(Enum):
IDLE = "idle"
ARMING = "arming"
ARMED = "armed"
TAKING_OFF = "taking_off"
FLYING = "flying"
LANDING = "landing"
EMERGENCY = "emergency"
class DroneStateMachine:
def __init__(self):
self.state = DroneState.IDLE
self.transitions = {
DroneState.IDLE: [DroneState.ARMING, DroneState.EMERGENCY],
DroneState.ARMING: [DroneState.ARMED, DroneState.IDLE, DroneState.EMERGENCY],
DroneState.ARMED: [DroneState.TAKING_OFF, DroneState.IDLE, DroneState.EMERGENCY],
DroneState.TAKING_OFF: [DroneState.FLYING, DroneState.LANDING, DroneState.EMERGENCY],
DroneState.FLYING: [DroneState.LANDING, DroneState.EMERGENCY],
DroneState.LANDING: [DroneState.IDLE, DroneState.EMERGENCY],
DroneState.EMERGENCY: [DroneState.IDLE]
}
def transition(self, new_state):
if new_state in self.transitions[self.state]:
print(f"{self.state.value} -> {new_state.value}")
self.state = new_state
return True
print(f"Noto'g'ri o'tish: {self.state.value} -> {new_state.value}")
return False
# Test
drone = DroneStateMachine()
drone.transition(DroneState.ARMING)
drone.transition(DroneState.ARMED)
drone.transition(DroneState.TAKING_OFF)
drone.transition(DroneState.FLYING)
drone.transition(DroneState.IDLE) # Noto'g'ri!
drone.transition(DroneState.LANDING)
drone.transition(DroneState.IDLE)
Murakkab Masalalar (19-25)
Masala 19 ⭐⭐⭐⭐
Async/await bilan bir nechta sensorni parallel o'qing.
Yechim
import asyncio
import random
async def read_sensor_async(sensor_id, delay):
"""Asinxron sensor o'qish"""
await asyncio.sleep(delay) # Sensor javob vaqti
value = random.uniform(0, 100)
return sensor_id, value
async def read_all_sensors():
"""Barcha sensorlarni parallel o'qish"""
tasks = [
read_sensor_async("IMU", 0.1),
read_sensor_async("GPS", 0.5),
read_sensor_async("Barometer", 0.2),
read_sensor_async("Sonar", 0.15)
]
results = await asyncio.gather(*tasks)
return dict(results)
# Test
async def main():
import time
start = time.time()
data = await read_all_sensors()
elapsed = time.time() - start
print(f"Vaqt: {elapsed:.2f}s (parallel)")
print(f"Ma'lumotlar: {data}")
asyncio.run(main())
Masala 20 ⭐⭐⭐⭐
Kalman filtr bilan pozitsiyani baholang (1D).
Yechim
class KalmanFilter1D:
def __init__(self, process_variance, measurement_variance, initial_estimate=0):
self.Q = process_variance
self.R = measurement_variance
self.x = initial_estimate # State estimate
self.P = 1.0 # Estimate error
def update(self, measurement):
# Predict
# x = x (no control input)
self.P = self.P + self.Q
# Update
K = self.P / (self.P + self.R) # Kalman gain
self.x = self.x + K * (measurement - self.x)
self.P = (1 - K) * self.P
return self.x
# Test
import random
import matplotlib.pyplot as plt
true_value = 50 # True position
kf = KalmanFilter1D(process_variance=0.01, measurement_variance=1)
measurements = []
estimates = []
for _ in range(100):
# Noisy measurement
measurement = true_value + random.gauss(0, 3)
estimate = kf.update(measurement)
measurements.append(measurement)
estimates.append(estimate)
plt.figure(figsize=(10, 5))
plt.plot(measurements, 'r.', alpha=0.5, label='Measurements')
plt.plot(estimates, 'b-', linewidth=2, label='Kalman Estimate')
plt.axhline(y=true_value, color='g', linestyle='--', label='True Value')
plt.legend()
plt.title('Kalman Filter 1D')
plt.savefig('kalman_filter.png', dpi=150)
plt.show()
Masala 21 ⭐⭐⭐⭐
Path planning: A* algoritmi bilan yo'l toping.
Yechim
import heapq
def astar(grid, start, goal):
"""A* yo'l topish algoritmi"""
rows, cols = len(grid), len(grid[0])
def heuristic(a, b):
return abs(a[0] - b[0]) + abs(a[1] - b[1])
def neighbors(node):
r, c = node
for dr, dc in [(0,1), (1,0), (0,-1), (-1,0)]:
nr, nc = r + dr, c + dc
if 0 <= nr < rows and 0 <= nc < cols and grid[nr][nc] == 0:
yield (nr, nc)
open_set = [(0, start)]
came_from = {}
g_score = {start: 0}
while open_set:
_, current = heapq.heappop(open_set)
if current == goal:
# Yo'lni qayta tiklash
path = []
while current in came_from:
path.append(current)
current = came_from[current]
path.append(start)
return path[::-1]
for neighbor in neighbors(current):
tentative_g = g_score[current] + 1
if neighbor not in g_score or tentative_g < g_score[neighbor]:
came_from[neighbor] = current
g_score[neighbor] = tentative_g
f = tentative_g + heuristic(neighbor, goal)
heapq.heappush(open_set, (f, neighbor))
return None # Yo'l topilmadi
# Test
grid = [
[0, 0, 0, 0, 1],
[1, 1, 0, 1, 0],
[0, 0, 0, 0, 0],
[0, 1, 1, 1, 0],
[0, 0, 0, 0, 0]
]
path = astar(grid, (0, 0), (4, 4))
print(f"Yo'l: {path}")
Masala 22 ⭐⭐⭐⭐
Quaternion bilan 3D rotation.
Yechim
import numpy as np
class Quaternion:
def __init__(self, w=1, x=0, y=0, z=0):
self.w = w
self.x = x
self.y = y
self.z = z
@classmethod
def from_axis_angle(cls, axis, angle):
"""Axis-angle dan quaternion"""
axis = np.array(axis) / np.linalg.norm(axis)
half_angle = angle / 2
w = np.cos(half_angle)
x, y, z = axis * np.sin(half_angle)
return cls(w, x, y, z)
def to_rotation_matrix(self):
"""3x3 rotation matrix"""
w, x, y, z = self.w, self.x, self.y, self.z
return np.array([
[1-2*(y*y+z*z), 2*(x*y-w*z), 2*(x*z+w*y)],
[2*(x*y+w*z), 1-2*(x*x+z*z), 2*(y*z-w*x)],
[2*(x*z-w*y), 2*(y*z+w*x), 1-2*(x*x+y*y)]
])
def rotate_vector(self, v):
"""Vektorni aylantirish"""
R = self.to_rotation_matrix()
return R @ np.array(v)
# Test
q = Quaternion.from_axis_angle([0, 0, 1], np.pi/2) # Z atrofida 90°
v = [1, 0, 0]
v_rotated = q.rotate_vector(v)
print(f"Original: {v}")
print(f"Rotated: {v_rotated}") # [0, 1, 0]
Masala 23 ⭐⭐⭐⭐
Multi-threading bilan sensor va control looplarni ajrating.
Yechim
import threading
import time
import random
from queue import Queue
sensor_data = Queue()
running = True
def sensor_loop():
"""Sensor o'qish (50 Hz)"""
while running:
data = {
"imu": random.gauss(0, 1),
"altitude": random.uniform(0, 100),
"timestamp": time.time()
}
sensor_data.put(data)
time.sleep(0.02) # 50 Hz
def control_loop():
"""Kontrol loop (100 Hz)"""
while running:
if not sensor_data.empty():
data = sensor_data.get()
# Process
output = data["altitude"] * 0.1
# print(f"Control output: {output:.2f}")
time.sleep(0.01) # 100 Hz
# Test
sensor_thread = threading.Thread(target=sensor_loop)
control_thread = threading.Thread(target=control_loop)
sensor_thread.start()
control_thread.start()
time.sleep(1) # 1 sekund ishlash
running = False
sensor_thread.join()
control_thread.join()
print("Done!")
Masala 24 ⭐⭐⭐⭐
Decorator bilan funksiya vaqtini o'lchang.
Yechim
import time
from functools import wraps
def timing(func):
"""Funksiya vaqtini o'lchash decorator"""
@wraps(func)
def wrapper(*args, **kwargs):
start = time.perf_counter()
result = func(*args, **kwargs)
end = time.perf_counter()
print(f"{func.__name__}: {(end-start)*1000:.2f} ms")
return result
return wrapper
def rate_limit(hz):
"""Chastotani cheklash decorator"""
interval = 1.0 / hz
def decorator(func):
last_call = [0]
@wraps(func)
def wrapper(*args, **kwargs):
elapsed = time.time() - last_call[0]
if elapsed < interval:
time.sleep(interval - elapsed)
last_call[0] = time.time()
return func(*args, **kwargs)
return wrapper
return decorator
# Test
@timing
def heavy_computation():
total = sum(i**2 for i in range(100000))
return total
@rate_limit(10) # 10 Hz
def sensor_read():
return time.time()
heavy_computation()
for _ in range(5):
print(f"Sensor: {sensor_read():.3f}")
Masala 25 ⭐⭐⭐⭐
Robot holati uchun dataclass va namedtuple ishlating.
Yechim
from dataclasses import dataclass, field
from typing import List, Optional
from collections import namedtuple
# NamedTuple - oddiy ma'lumot uchun
Vector3 = namedtuple('Vector3', ['x', 'y', 'z'])
Quaternion = namedtuple('Quaternion', ['w', 'x', 'y', 'z'])
# Dataclass - murakkab ma'lumot uchun
@dataclass
class RobotState:
position: Vector3
orientation: Quaternion
velocity: Vector3 = field(default_factory=lambda: Vector3(0, 0, 0))
battery_percent: float = 100.0
is_armed: bool = False
sensors: List[str] = field(default_factory=list)
error: Optional[str] = None
def distance_to(self, other_pos: Vector3) -> float:
dx = self.position.x - other_pos.x
dy = self.position.y - other_pos.y
dz = self.position.z - other_pos.z
return (dx**2 + dy**2 + dz**2) ** 0.5
# Test
state = RobotState(
position=Vector3(10, 20, 5),
orientation=Quaternion(1, 0, 0, 0),
sensors=["IMU", "GPS", "Camera"]
)
print(state)
print(f"Balandlik: {state.position.z} m")
print(f"Batareya: {state.battery_percent}%")
target = Vector3(15, 25, 5)
print(f"Maqsadgacha masofa: {state.distance_to(target):.2f} m")
✅ Tekshirish Ro'yxati
- 1-10: Asosiy Python
- 11-18: OOP va fayllar
- 19-25: Murakkab tushunchalar
Keyingi Qadam
🔬 Amaliyot — Robotika loyihalar!