Advanced Python Programming (4321602) - Winter 2024 Solution (Gujarati)

# ઉદાહરણ
numbers = [1, 2, 3, 4, 5]
numbers.append(6)  # [1, 2, 3, 4, 5, 6]
print(numbers[0])  # આઉટપુટ: 1

# બે ટપલ વેલ્યુઝને સ્વેપ કરવાનો પ્રોગ્રામ
def swap_tuple_values(tup, pos1, pos2):
    # સ્વેપિંગ માટે ટપલને લિસ્ટમાં કન્વર્ટ કરો
    temp_list = list(tup)
    
    # વેલ્યુઝ સ્વેપ કરો
    temp_list[pos1], temp_list[pos2] = temp_list[pos2], temp_list[pos1]
    
    # પાછું ટપલમાં કન્વર્ટ કરો
    return tuple(temp_list)

# ઉદાહરણ ઉપયોગ
original_tuple = (10, 20, 30, 40, 50)
print("મૂળ ટપલ:", original_tuple)

# પોઝિશન 1 અને 3 પર વેલ્યુઝ સ્વેપ કરો
swapped_tuple = swap_tuple_values(original_tuple, 1, 3)
print("સ્વેપિંગ પછી:", swapped_tuple)

# લૂપ વાપરીને ડિક્શનરી ટ્રાવર્સ કરવાનો પ્રોગ્રામ
student_marks = {
    'Alice': 85,
    'Bob': 92,
    'Charlie': 78,
    'Diana': 96,
    'Eve': 89
}

print("ડિક્શનરી ટ્રાવર્સલ મેથડ્સ:")
print("-" * 30)

# મેથડ 1: ફક્ત કીઝ ટ્રાવર્સ કરો
print("1. ફક્ત કીઝ:")
for key in student_marks:
    print(f"   {key}")

# મેથડ 2: ફક્ત વેલ્યુઝ ટ્રાવર્સ કરો
print("\n2. ફક્ત વેલ્યુઝ:")
for value in student_marks.values():
    print(f"   {value}")

# મેથડ 3: કી-વેલ્યુ પેર ટ્રાવર્સ કરો
print("\n3. કી-વેલ્યુ પેર:")
for key, value in student_marks.items():
    print(f"   {key}: {value}")

# મેથડ 4: keys() મેથડ વાપરીને
print("\n4. keys() મેથડ વાપરીને:")
for key in student_marks.keys():
    print(f"   {key} ને {student_marks[key]} માર્ક્સ મળ્યા")

# મેથડ 1: નોર્મલ આયાત
import mypackage.calculator
result = mypackage.calculator.add(5, 3)
print(f"નોર્મલ આયાત પરિણાม: {result}")

# મેથડ 2: ફ્રમ આયાત
from mypackage import calculator
result = calculator.multiply(4, 6)
print(f"ફ્રમ આયાત પરિણાม: {result}")

# પેકેજ સ્ટ્રક્ચર ઉદાહરણ
# mypackage/math_ops/advanced.py
from . import basic  # સેમ પેકેજથી રિલેટિવ આયાત
from ..utils import helpers  # સિબલિંગ પેકેજથી આયાત

def power_operation(base, exp):
    # બેસિક મોડ્યુલથી ફંક્શન વાપરીને
    if basic.is_valid_number(base) and basic.is_valid_number(exp):
        result = base ** exp
        # હેલ્પર ફંક્શન વાપરીને
        return helpers.format_result(result)
    return None

# mypackage/math_ops/basic.py
def is_valid_number(num):
    return isinstance(num, (int, float))

def add(a, b):
    return a + b

# mypackage/utils/helpers.py
def format_result(value):
    return f"પરિણાम: {value:.2f}"

# મેથડ 1: ડાયરેક્ટ આયાત
import math
result1 = math.sqrt(16)
print(f"ડાયરેક્ટ આયાત: {result1}")

# મેથડ 2: ફ્રમ આયાત
from math import pi, sin
result2 = sin(pi/2)
print(f"ફ્રમ આયાત: {result2}")

# circle_operations.py (મોડ્યુલ ફાઈલ)
import math

def area(radius):
    """વતુળનું ક્ષેત્રફળ ગણો"""
    if radius <= 0:
        return 0
    return math.pi * radius * radius

def circumference(radius):
    """વતુળનો પરિઘ ગણો"""
    if radius <= 0:
        return 0
    return 2 * math.pi * radius

def display_info(radius):
    """વતુળની માહિતી દર્શાવો"""
    print(f"ત્રિજ્યા {radius} વાળું વતુળ:")
    print(f"ક્ષેત્રફળ: {area(radius):.2f}")
    print(f"પરિઘ: {circumference(radius):.2f}")

# કોન્સ્ટન્ટ્સ
PI = math.pi

# અ) મોડ્યુલને બીજા પ્રોગ્રામમાં આયાત કરો

# main_program.py
import circle_operations

radius = 5
print("મેથડ 1: સંપૂર્ણ મોડ્યુલ આયાત")
area_result = circle_operations.area(radius)
circumference_result = circle_operations.circumference(radius)

print(f"ક્ષેત્રફળ: {area_result:.2f}")
print(f"પરિઘ: {circumference_result:.2f}")

# બ) મોડ્યુલમાંથી બીજા પ્રોગ્રામમાં ચોક્કસ ફંક્શન આયાત કરો
# specific_import.py
from circle_operations import area, circumference

radius = 7
print("\nમેથડ 2: ચોક્કસ ફંક્શન્સ આયાત")
area_result = area(radius)
circumference_result = circumference(radius)

print(f"ક્ષેત્રફળ: {area_result:.2f}")
print(f"પરિઘ: {circumference_result:.2f}")

# કસ્ટમ એક્સેપ્શન ડિફાઈન કરો
class AgeValidationError(Exception):
    def __init__(self, age, message="અયોગ્ય વય આપેલ છે"):
        self.age = age
        self.message = message
        super().__init__(self.message)

def validate_age(age):
    if age < 0:
        raise AgeValidationError(age, "વય નેગેટિવ હોઈ શકે નહીં")
    elif age > 150:
        raise AgeValidationError(age, "વય 150 કરતાં વધુ હોઈ શકે નહીં")
    else:
        print(f"યોગ્ય વય: {age}")

# કસ્ટમ એક્સેપ્શનનો ઉપયોગ
try:
    validate_age(-5)
except AgeValidationError as e:
    print(f"એરર: {e.message}, વય: {e.age}")

# સંપૂર્ણ એક્સેપ્શન હેન્ડલિંગ ઉદાહરણ
def divide_numbers():
    try:
        print("ભાગાકાર ઓપરેશન શરૂ કરી રહ્યા છીએ...")
        
        # યુઝરથી ઇનપુટ મેળવો
        num1 = float(input("પહેલો નંબર દાખલ કરો: "))
        num2 = float(input("બીજો નંબર દાખલ કરો: "))
        
        # ભાગાકાર કરો
        result = num1 / num2
        
    except ValueError:
        print("એરર: કૃપા કરીને ફક્ત યોગ્ય નંબર્સ દાખલ કરો")
        return None
        
    except ZeroDivisionError:
        print("એરર: શૂન્યથી ભાગાકાર કરી શકાતો નથી")
        return None
        
    except Exception as e:
        print(f"અનપેક્ષિત એરર આવ્યું: {e}")
        return None
        
    else:
        print(f"ભાગાકાર સફળ: {num1} ÷ {num2} = {result}")
        return result
        
    finally:
        print("ભાગાકાર ઓપરેશન પૂર્ણ")
        print("રિસોર્સિસ ક્લીન કરી રહ્યા છીએ...")

# ઉદાહરણ ઉપયોગ
result = divide_numbers()
if result:
    print(f"અંતિમ પરિણાম: {result}")

# ટ્રાય-એક્સેપ્ટ ક્લોઝનું ઉદાહરણ
def safe_division():
    try:
        # એક્સેપ્શન્સ ઉઠાવી શકે તેવો કોડ
        dividend = int(input("ભાજ્ય દાખલ કરો: "))
        divisor = int(input("ભાજક દાખલ કરો: "))
        
        result = dividend / divisor
        print(f"પરિણાम: {dividend} ÷ {divisor} = {result}")
        
    except ValueError:
        print("એરર: કૃપા કરીને ફક્ત યોગ્ય ઇન્ટિજર્સ દાખલ કરો")
        
    except ZeroDivisionError:
        print("એરર: શૂન્યથી ભાગાકાર કરી શકાતો નથી")
        
    except Exception as e:
        print(f"અનપેક્ષિત એરર આવ્યું: {e}")
    
    print("એક્સેપ્શન હેન્ડલિંગ પછી પ્રોગ્રામ ચાલુ રહે છે")

# ઉદાહરણ ઉપયોગ
safe_division()

# ફાઈનલી ક્લોઝ સાથે ડિવાઇડ બાય ઝીરો હેન્ડલ કરવાનો પ્રોગ્રામ
def advanced_calculator():
    """વ્યાપક એક્સેપ્શન હેન્ડલિંગ સાથે કેલ્ક્યુલેટર"""
    
    try:
        print("=== એડવાન્સ કેલ્ક્યુલેટર ===")
        print("ભાગાકાર માટે બે નંબર દાખલ કરો")
        
        # ઇનપુટ સેક્શન
        numerator = float(input("અંશ દાખલ કરો: "))
        denominator = float(input("છેદ દાખલ કરો: "))
        
        print(f"\n{numerator} ને {denominator} થી ભાગવાનો પ્રયાસ કરી રહ્યા છીએ...")
        
        # ક્રિટિકલ ઓપરેશન જે નિષ્ફળ થઈ શકે
        if denominator == 0:
            raise ZeroDivisionError("શૂન્યથી ભાગાકારની મંજૂરી નથી")
        
        result = numerator / denominator
        
        # સફળતાનો સંદેશ
        print(f"✓ ભાગાકાર સફળ!")
        print(f"✓ પરિણામ: {numerator} ÷ {denominator} = {result:.4f}")
        
        return result
        
    except ZeroDivisionError as zde:
        print(f"✗ ઝીરો ડિવિઝન એરર: {zde}")
        print("✗ કૃપા કરીને શૂન્ય સિવાયનો છેદ વાપરો")
        return None
        
    except ValueError as ve:
        print(f"✗ વેલ્યુ એરર: અમાન્ય ઇનપુટ આપ્યું")
        print("✗ કૃપા કરીને ફક્ત નંબરિક વેલ્યુઝ દાખલ કરો")
        return None
        
    except Exception as e:
        print(f"✗ અનપેક્ષિત એરર: {e}")
        return None
        
    finally:
        print("\n" + "="*40)
        print("ક્લીનઅપ ઓપરેશન્સ:")
        print("- કેલ્ક્યુલેટર સેશન બંધ કરી રહ્યા છીએ")
        print("- ઓપરેશન લોગ સેવ કરી રહ્યા છીએ")
        print("- મેમરી રિસોર્સિસ છોડી રહ્યા છીએ")
        print("- કેલ્ક્યુલેટર શટડાઉન પૂર્ણ")
        print("="*40)

# વિવિધ સ્થિતિઓ સાથે કેલ્ક્યુલેટર ટેસ્ટ કરવાનું ફંક્શન
def test_calculator():
    """વિવિધ પરિસ્થિતિઓ સાથે કેલ્ક્યુલેટર ટેસ્ટ કરો"""
    
    test_cases = [
        (10, 2),    # સામાન્ય ભાગાકાર
        (15, 0),    # ઝીરો ડિવિઝન
        (7, 3),     # દશાંશ સાથે સામાન્ય ભાગાકાર
    ]
    
    for i, (num, den) in enumerate(test_cases, 1):
        print(f"\n--- ટેસ્ટ કેસ {i} ---")
        print(f"ટેસ્ટિંગ: {num} ÷ {den}")
        
        # વાસ્તવિક પરિસ્થિતિમાં આ ઇન્ટરેક્ટિવ હશે
        # આ ફક્ત ડેમોન્સ્ટ્રેશન માટે છે
        print(f"{num} ને {den} થી ભાગવાનું સિમ્યુલેશન")
        
        try:
            if den == 0:
                raise ZeroDivisionError("શૂન્યથી ભાગાકાર કરી શકાતો નથી")
            result = num / den
            print(f"પરિણામ: {result}")
        except ZeroDivisionError as e:
            print(f"એરર પકડાયું: {e}")
        finally:
            print("ટેસ્ટ કેસ પૂર્ણ")

# કેલ્ક્યુલેટર ચલાવો
if __name__ == "__main__":
    result = advanced_calculator()
    
    if result is not None:
        print(f"\nઅંતિમ ગણેલું પરિણામ: {result}")
    else:
        print("\nએરર્સના કારણે ગણતરી નિષ્ફળ")

# write() અને writelines() ફંક્શન્સનું ઉદાહરણ
def demonstrate_write_functions():
    
    # write() ફંક્શન વાપરીને
    with open("write_demo.txt", "w") as file:
        file.write("નમસ્તે વિશ્વ!\n")
        file.write("આ બીજી લાઈન છે\n")
        file.write("આ ત્રીજી લાઈન છે\n")
    
    # writelines() ફંક્શન વાપરીને
    lines = [
        "writelines વાપરીને પહેલી લાઈન\n",
        "writelines વાપરીને બીજી લાઈન\n", 
        "writelines વાપરીને ત્રીજી લાઈન\n"
    ]
    
    with open("writelines_demo.txt", "w") as file:
        file.writelines(lines)
    
    print("ફાઈલ્સ સફળતાપૂર્વક બનાવાઈ!")

# ડેમોન્સ્ટ્રેશન ચલાવો
demonstrate_write_functions()

# tell() અને seek() ફંક્શન્સનું સંપૂર્ણ ઉદાહરણ
def demonstrate_file_positioning():
    
    # સેમ્પલ ફાઈલ બનાવો
    sample_text = "નમસ્તે વિશ્વ! આ tell() અને seek() ફંક્શન્સ દર્શાવવા માટે સેમ્પલ ફાઈલ છે."
    
    with open("position_demo.txt", "w", encoding='utf-8') as file:
        file.write(sample_text)
    
    # tell() અને seek() દર્શાવો
    with open("position_demo.txt", "r", encoding='utf-8') as file:
        
        # શરૂઆતની પોઝિશન
        print(f"1. શરૂઆતની પોઝિશન: {file.tell()}")
        
        # પહેલા 5 કેરેક્ટર્સ વાંચો
        data1 = file.read(5)
        print(f"2. '{data1}' વાંચ્યું, વર્તમાન પોઝિશન: {file.tell()}")
        
        # પોઝિશન 15 પર જાઓ
        file.seek(15)
        print(f"3. seek(15) પછી, પોઝિશન: {file.tell()}")
        
        # આગળના 10 કેરેક્ટર્સ વાંચો
        data2 = file.read(10)
        print(f"4. '{data2}' વાંચ્યું, વર્તમાન પોઝિશન: {file.tell()}")
        
        # seek(0, 0) વાપરીને શરૂઆતમાં જાઓ
        file.seek(0, 0)
        print(f"5. seek(0,0) પછી, પોઝિશન: {file.tell()}")
        
        # seek(0, 2) વાપરીને અંતમાં જાઓ
        file.seek(0, 2)
        print(f"6. seek(0,2) પછી, પોઝિશન: {file.tell()}")
        
        # વર્તમાન પોઝિશનથી પાછળ જાઓ
        file.seek(-10, 1)
        print(f"7. seek(-10,1) પછી, પોઝિશન: {file.tell()}")
        
        # બાકીનું કન્ટેન્ટ વાંચો
        remaining = file.read()
        print(f"8. બાકીનું કન્ટેન્ટ: '{remaining}'")

# બાઈનરી ફાઈલ સાથે ઉદાહરણ
def binary_file_positioning():
    
    # બાઈનરી ફાઈલ બનાવો
    data = b"Binary file positioning example"
    
    with open("binary_demo.bin", "wb") as file:
        file.write(data)
    
    # પોઝિશનિંગ સાથે વાંચો
    with open("binary_demo.bin", "rb") as file:
        print(f"\nબાઈનરી ફાઈલ પોઝિશન: {file.tell()}")
        
        # પહેલા 6 બાઈટ્સ વાંચો
        chunk1 = file.read(6)
        print(f"વાંચ્યું: {chunk1}, પોઝિશન: {file.tell()}")
        
        # પોઝિશન 20 પર જમ્પ કરો
        file.seek(20)
        chunk2 = file.read(7)
        print(f"વાંચ્યું: {chunk2}, પોઝિશન: {file.tell()}")

# ડેમોન્સ્ટ્રેશન્સ ચલાવો
demonstrate_file_positioning()
binary_file_positioning()

# વિવિધ ફાઈલ મોડ્સના ઉદાહરણો
def demonstrate_file_modes():
    
    # ટેક્સ્ટ ફાઈલ મોડ્સ
    with open("text_file.txt", "w") as f:  # રાઈટ મોડ
        f.write("નમસ્તે વિશ્વ")
    
    with open("text_file.txt", "r") as f:  # રીડ મોડ
        content = f.read()
        print(f"ટેક્સ્ટ કન્ટેન્ટ: {content}")
    
    # બાઈનરી ફાઈલ મોડ્સ
    data = b"Binary data example"
    with open("binary_file.bin", "wb") as f:  # બાઈનરી રાઈટ
        f.write(data)
    
    with open("binary_file.bin", "rb") as f:  # બાઈનરી રીડ
        binary_content = f.read()
        print(f"બાઈનરી કન્ટેન્ટ: {binary_content}")

demonstrate_file_modes()

import pickle
import os

class StudentSubjectRecord:
    """વિદ્યાર્થી વિષય રેકોર્ડ હેન્ડલ કરવા માટેનો ક્લાસ"""
    
    def __init__(self, branch_name, semester, subject_code, subject_name):
        self.branch_name = branch_name
        self.semester = semester
        self.subject_code = subject_code
        self.subject_name = subject_name
    
    def __str__(self):
        return f"શાખા: {self.branch_name}, સેમેસ્ટર: {self.semester}, કોડ: {self.subject_code}, વિષય: {self.subject_name}"

def write_student_records():
    """વિદ્યાર્થી રેકોર્ડ્સ બાઈનરી ફાઈલમાં લખો"""
    
    # સેમ્પલ વિદ્યાર્થી રેકોર્ડ્સ
    records = [
        StudentSubjectRecord("ઈન્ફોર્મેશન ટેક્નોલોજી", 2, "4321602", "એડવાન્સ પાયથન પ્રોગ્રામિંગ"),
        StudentSubjectRecord("ઈન્ફોર્મેશન ટેક્નોલોજી", 2, "4321601", "ડેટાબેસ મેનેજમેન્ટ સિસ્ટમ"),
        StudentSubjectRecord("કમ્પ્યુટર એન્જિનિયરિંગ", 3, "4330701", "ડેટા સ્ટ્રક્ચર"),
        StudentSubjectRecord("ઈન્ફોર્મેશન ટેક્નોલોજી", 2, "4321603", "વેબ ડેવલપમેન્ટ"),
        StudentSubjectRecord("કમ્પ્યુટર એન્જિનિયરિંગ", 3, "4330702", "કમ્પ્યુટર નેટવર્ક્સ")
    ]
    
    # pickle વાપરીને રેકોર્ડ્સને બાઈનરી ફાઈલમાં લખો
    try:
        with open("student_records.bin", "wb") as binary_file:
            pickle.dump(records, binary_file)
        
        print("✓ વિદ્યાર્થી રેકોર્ડ્સ બાઈનરી ફાઈલમાં સફળતાપૂર્વક લખાયા!")
        print(f"✓ કુલ લખાયેલા રેકોર્ડ્સ: {len(records)}")
        
    except Exception as e:
        print(f"✗ બાઈનરી ફાઈલમાં લખવામાં એરર: {e}")

def read_student_records():
    """બાઈનરી ફાઈલમાંથી વિદ્યાર્થી રેકોર્ડ્સ વાંચો"""
    
    try:
        if not os.path.exists("student_records.bin"):
            print("✗ બાઈનરી ફાઈલ મળી નહીં!")
            return
        
        with open("student_records.bin", "rb") as binary_file:
            records = pickle.load(binary_file)
        
        print("\n" + "="*60)
        print("બાઈનરી ફાઈલમાંથી વિદ્યાર્થી વિષય રેકોર્ડ્સ")
        print("="*60)
        
        for i, record in enumerate(records, 1):
            print(f"{i}. {record}")
        
        print("="*60)
        print(f"કુલ વાંચેલા રેકોર્ડ્સ: {len(records)}")
        
    except Exception as e:
        print(f"✗ બાઈનરી ફાઈલમાંથી વાંચવામાં એરર: {e}")

def add_new_record():
    """હાલની બાઈનરી ફાઈલમાં નવો વિદ્યાર્થી રેકોર્ડ ઉમેરો"""
    
    try:
        # હાલના રેકોર્ડ્સ વાંચો
        records = []
        if os.path.exists("student_records.bin"):
            with open("student_records.bin", "rb") as binary_file:
                records = pickle.load(binary_file)
        
        # નવા રેકોર્ડની વિગતો મેળવો
        print("\nનવા વિદ્યાર્થી રેકોર્ડની વિગતો દાખલ કરો:")
        branch = input("શાખાનું નામ: ")
        semester = int(input("સેમેસ્ટર: "))
        code = input("વિષયનો કોડ: ")
        subject = input("વિષયનું નામ: ")
        
        # નવો રેકોર્ડ બનાવો
        new_record = StudentSubjectRecord(branch, semester, code, subject)
        records.append(new_record)
        
        # ફાઈલમાં પાછું લખો
        with open("student_records.bin", "wb") as binary_file:
            pickle.dump(records, binary_file)
        
        print("✓ નવો રેકોર્ડ સફળતાપૂર્વક ઉમેર્યો!")
        
    except Exception as e:
        print(f"✗ નવો રેકોર્ડ ઉમેરવામાં એરર: {e}")

def search_records_by_branch(branch_name):
    """શાખાના નામ દ્વારા રેકોર્ડ્સ શોધો"""
    
    try:
        if not os.path.exists("student_records.bin"):
            print("✗ બાઈનરી ફાઈલ મળી નહીં!")
            return
        
        with open("student_records.bin", "rb") as binary_file:
            records = pickle.load(binary_file)
        
        # શાખા દ્વારા રેકોર્ડ્સ ફિલ્ટર કરો
        filtered_records = [record for record in records 
                          if record.branch_name.lower() == branch_name.lower()]
        
        if filtered_records:
            print(f"\n{branch_name} માટેના રેકોર્ડ્સ:")
            print("-" * 40)
            for record in filtered_records:
                print(f"  {record}")
        else:
            print(f"શાખા માટે કોઈ રેકોર્ડ મળ્યો નહીં: {branch_name}")
            
    except Exception as e:
        print(f"✗ રેકોર્ડ્સ શોધવામાં એરર: {e}")

# મુખ્ય પ્રોગ્રામ એક્ઝિક્યુશન
def main():
    """બાઈનરી ફાઈલ ઓપરેશન્સ દર્શાવવા માટેનું મુખ્ય ફંક્શન"""
    
    print("=== વિદ્યાર્થી વિષય રેકોર્ડ મેનેજમેન્ટ ===\n")
    
    # શરૂઆતના રેકોર્ડ્સ લખો
    print("1. બાઈનરી ફાઈલમાં વિદ્યાર્થી રેકોર્ડ્સ લખી રહ્યા છીએ...")
    write_student_records()
    
    # રેકોર્ડ્સ વાંચો અને દર્શાવો
    print("\n2. બાઈનરી ફાઈલમાંથી રેકોર્ડ્સ વાંચી રહ્યા છીએ...")
    read_student_records()
    
    # શાખા દ્વારા શોધો
    print("\n3. શાખા દ્વારા રેકોર્ડ્સ શોધી રહ્યા છીએ...")
    search_records_by_branch("ઈન્ફોર્મેશન ટેક્નોલોજી")
    
    # ફાઈલની માહિતી દર્શાવો
    if os.path.exists("student_records.bin"):
        file_size = os.path.getsize("student_records.bin")
        print(f"\nબાઈનરી ફાઈલ સાઈઝ: {file_size} બાઈટ્સ")

# પ્રોગ્રામ એક્ઝિક્યુટ કરો
if __name__ == "__main__":
    main()

import turtle

def draw_square_with_for_loop():
    """for લૂપ વાપરીને ચોરસ દોરો"""
    
    # ટર્ટલ સેટઅપ
    screen = turtle.Screen()
    screen.bgcolor("white")
    square_turtle = turtle.Turtle()
    square_turtle.color("blue")
    square_turtle.pensize(3)
    
    # for લૂપ વાપરીને ચોરસ દોરો
    print("for લૂપ વાપરીને ચોરસ દોરી રહ્યા છીએ...")
    side_length = 100
    
    for i in range(4):
        square_turtle.forward(side_length)
        square_turtle.right(90)
    
    square_turtle.penup()
    square_turtle.goto(150, 0)
    square_turtle.pendown()
    
    return square_turtle

def draw_square_with_while_loop(turtle_obj):
    """while લૂપ વાપરીને ચોરસ દોરો"""
    
    # બીજા ચોરસ માટે રંગ બદલો
    turtle_obj.color("red")
    
    # while લૂપ વાપરીને ચોરસ દોરો
    print("while લૂપ વાપરીને ચોરસ દોરી રહ્યા છીએ...")
    side_length = 100
    sides_drawn = 0
    
    while sides_drawn < 4:
        turtle_obj.forward(side_length)
        turtle_obj.right(90)
        sides_drawn += 1
    
    # ટેક્સ્ટ માટે ટર્ટલને સેન્ટરમાં મૂવ કરો
    turtle_obj.penup()
    turtle_obj.goto(-50, -150)
    turtle_obj.write("નીલો: for લૂપ, લાલ: while લૂપ", 
                    font=("Arial", 12, "normal"))

# મુખ્ય એક્ઝિક્યુશન
def main():
    # ચોરસ દોરો
    turtle_obj = draw_square_with_for_loop()
    draw_square_with_while_loop(turtle_obj)
    
    # વિન્ડો ખુલ્લી રાખો
    turtle.Screen().exitonclick()

# પ્રોગ્રામ ચલાવો
main()

import turtle

def setup_chessboard():
    """ચેસબોર્ડ માટે ટર્ટલ સ્ક્રીન અને પ્રોપર્ટીઝ સેટઅપ કરો"""
    
    screen = turtle.Screen()
    screen.bgcolor("white")
    screen.title("Python ટર્ટલ વાપરીને ચેસબોર્ડ")
    screen.setup(width=600, height=600)
    
    # ડ્રોઈંગ માટે ટર્ટલ બનાવો
    chess_turtle = turtle.Turtle()
    chess_turtle.speed(0)  # સૌથી ઝડપી સ્પીડ
    chess_turtle.penup()
    
    return screen, chess_turtle

def draw_square(turtle_obj, size, fill_color):
    """આપેલા રંગ સાથે એક ચોરસ દોરો"""
    
    turtle_obj.pendown()
    turtle_obj.fillcolor(fill_color)
    turtle_obj.begin_fill()
    
    # ચોરસ દોરો
    for _ in range(4):
        turtle_obj.forward(size)
        turtle_obj.right(90)
    
    turtle_obj.end_fill()
    turtle_obj.penup()

def draw_chessboard():
    """સંપૂર્ણ 8x8 ચેસબોર્ડ દોરો"""
    
    screen, chess_turtle = setup_chessboard()
    
    # ચેસબોર્ડ પેરામીટર્સ
    square_size = 40
    board_size = 8
    start_x = -160
    start_y = 160
    
    print("ચેસબોર્ડ દોરી રહ્યા છીએ...")
    
    # બોર્ડ દોરો
    for row in range(board_size):
        for col in range(board_size):
            
            # પોઝિશન ગણો
            x = start_x + (col * square_size)
            y = start_y - (row * square_size)
            
            # ટર્ટલને પોઝિશન પર મૂવ કરો
            chess_turtle.goto(x, y)
            
            # ચોરસનો રંગ નક્કી કરો (અલ્ટર્નેટિંગ પેટર્ન)
            if (row + col) % 2 == 0:
                color = "white"
            else:
                color = "black"
            
            # ચોરસ દોરો
            draw_square(chess_turtle, square_size, color)
    
    # ચેસબોર્ડની આસપાસ બોર્ડર ઉમેરો
    draw_border(chess_turtle, start_x, start_y, square_size, board_size)
    
    # લેબલ્સ ઉમેરો
    add_chessboard_labels(chess_turtle, start_x, start_y, square_size, board_size)
    
    return screen

def draw_border(turtle_obj, start_x, start_y, square_size, board_size):
    """ચેસબોર્ડની આસપાસ બોર્ડર દોરો"""
    
    turtle_obj.goto(start_x - 5, start_y + 5)
    turtle_obj.pencolor("brown")
    turtle_obj.pensize(3)
    turtle_obj.pendown()
    
    # બોર્ડર રેક્ટેંગલ દોરો
    border_width = board_size * square_size + 10
    border_height = board_size * square_size + 10
    
    for _ in range(2):
        turtle_obj.forward(border_width)
        turtle_obj.right(90)
        turtle_obj.forward(border_height)
        turtle_obj.right(90)
    
    turtle_obj.penup()
    turtle_obj.pensize(1)
    turtle_obj.pencolor("black")

def add_chessboard_labels(turtle_obj, start_x, start_y, square_size, board_size):
    """ચેસબોર્ડમાં રો અને કોલમ લેબલ્સ ઉમેરો"""
    
    turtle_obj.color("blue")
    
    # કોલમ લેબલ્સ (A-H)
    columns = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']
    for i, letter in enumerate(columns):
        x = start_x + (i * square_size) + (square_size // 2)
        y = start_y - (board_size * square_size) - 20
        turtle_obj.goto(x, y)
        turtle_obj.write(letter, align="center", font=("Arial", 12, "bold"))
    
    # રો લેબલ્સ (1-8)
    for i in range(board_size):
        x = start_x - 20
        y = start_y - (i * square_size) - (square_size // 2)
        turtle_obj.goto(x, y)
        turtle_obj.write(str(8-i), align="center", font=("Arial", 12, "bold"))
    
    # શીર્ષક
    turtle_obj.goto(0, start_y + 30)
    turtle_obj.write("Python ટર્ટલ ચેસબોર્ડ", align="center", 
                    font=("Arial", 16, "bold"))

def draw_enhanced_chessboard_with_pieces():
    """ચેસ પીસ ઈન્ડિકેટર્સ સાથે એન્હાન્સ વર્ઝન"""
    
    screen = draw_chessboard()
    
    # પીસીસ માટે નવો ટર્ટલ બનાવો
    piece_turtle = turtle.Turtle()
    piece_turtle.speed(0)
    piece_turtle.penup()
    
    # કેટલાક પીસ સિમ્બોલ્સ ઉમેરો (સિમ્પ્લિફાઈડ)
    pieces = [
        (-120, 120, "♜"), (-80, 120, "♞"), (-40, 120, "♝"), (0, 120, "♛"),
        (-120, -120, "♖"), (-80, -120, "♘"), (-40, -120, "♗"), (0, -120, "♕")
    ]
    
    piece_turtle.color("red")
    for x, y, symbol in pieces:
        piece_turtle.goto(x, y)
        piece_turtle.write(symbol, align="center", font=("Arial", 20, "normal"))
    
    piece_turtle.hideturtle()
    
    # આંકડાકીય માહિતી દર્શાવો
    total_squares = 64
    black_squares = 32
    white_squares = 32
    
    piece_turtle.goto(0, -200)
    piece_turtle.color("green")
    piece_turtle.write(f"ચેસબોર્ડ: {total_squares} ચોરસ ({black_squares} કાળા, {white_squares} સફેદ)", 
                      align="center", font=("Arial", 12, "normal"))
    
    return screen

# મુખ્ય એક્ઝિક્યુશન
def main():
    """ચેસબોર્ડ બનાવવા માટેનું મુખ્ય ફંક્શન"""
    
    print("Python ટર્ટલ વાપરીને ચેસબોર્ડ બનાવી રહ્યા છીએ...")
    screen = draw_enhanced_chessboard_with_pieces()
    
    print("ચેસબોર્ડ સફળતાપૂર્વક બનાવ્યું!")
    print("વિન્ડો બંધ કરવા માટે સ્ક્રીન પર ક્લિક કરો.")
    
    # ક્લિક કરવામાં આવે ત્યાં સુધી વિન્ડો ખુલ્લી રાખો
    screen.exitonclick()

# પ્રોગ્રામ ચલાવો
if __name__ == "__main__":
    main()

import turtle

def draw_circle_example():
    screen = turtle.Screen()
    circle_turtle = turtle.Turtle()
    
    # 50 ત્રિજ્યા સાથે વતુળ દોરો
    circle_turtle.circle(50)
    
    screen.exitonclick()

draw_circle_example()

import turtle

def demonstrate_basic_methods():
    # ટર્ટલ બનાવો
    demo_turtle = turtle.Turtle()
    
    # 1. આગળની મૂવમેન્ટ
    demo_turtle.forward(100)  # 100 પિક્સલ્સ આગળ મૂવ કરો
    
    # 2. જમણે ટર્ન
    demo_turtle.right(90)     # 90 ડિગ્રી જમણે ટર્ન કરો
    
    # 3. પાછળની મૂવમેન્ટ  
    demo_turtle.backward(50)  # 50 પિક્સલ્સ પાછળ મૂવ કરો
    
    # 4. ડાબે ટર્ન
    demo_turtle.left(135)     # 135 ડિગ્રી ડાબે ટર્ન કરો
    
    turtle.done()

demonstrate_basic_methods()

import turtle
import math

def setup_drawing_environment():
    """ટર્ટલ સ્ક્રીન અને ડ્રોઈંગ એન્વાયરનમેન્ટ સેટઅપ કરો"""
    
    screen = turtle.Screen()
    screen.bgcolor("lightblue")
    screen.title("આકાર દોરવા: ચોરસ, લાંબચોરસ, વતુળ")
    screen.setup(width=800, height=600)
    
    # મુખ્ય ડ્રોઈંગ ટર્ટલ બનાવો
    shape_turtle = turtle.Turtle()
    shape_turtle.speed(3)
    shape_turtle.pensize(2)
    
    return screen, shape_turtle

def draw_square(turtle_obj, size, color, position):
    """આપેલા સાઈઝ અને કલર સાથે ચોરસ દોરો"""
    
    x, y = position
    turtle_obj.penup()
    turtle_obj.goto(x, y)
    turtle_obj.pendown()
    
    turtle_obj.color(color)
    turtle_obj.fillcolor(color)
    turtle_obj.begin_fill()
    
    # 4 સમાન બાજુઓ વાપરીને ચોરસ દોરો
    for _ in range(4):
        turtle_obj.forward(size)
        turtle_obj.right(90)
    
    turtle_obj.end_fill()
    
    # લેબલ ઉમેરો
    turtle_obj.penup()
    turtle_obj.goto(x + size//2, y - 30)
    turtle_obj.color("black")
    turtle_obj.write(f"ચોરસ ({size}x{size})", align="center", 
                    font=("Arial", 10, "bold"))

def draw_rectangle(turtle_obj, width, height, color, position):
    """આપેલા dimensions અને કલર સાથે લાંબચોરસ દોરો"""
    
    x, y = position
    turtle_obj.penup()
    turtle_obj.goto(x, y)
    turtle_obj.pendown()
    
    turtle_obj.color(color)
    turtle_obj.fillcolor(color)
    turtle_obj.begin_fill()
    
    # લંબાઈ અને પહોળાઈ બદલીને લાંબચોરસ દોરો
    for _ in range(2):
        turtle_obj.forward(width)
        turtle_obj.right(90)
        turtle_obj.forward(height)
        turtle_obj.right(90)
    
    turtle_obj.end_fill()
    
    # લેબલ ઉમેરો
    turtle_obj.penup()
    turtle_obj.goto(x + width//2, y - height - 20)
    turtle_obj.color("black")
    turtle_obj.write(f"લાંબચોરસ ({width}x{height})", align="center", 
                    font=("Arial", 10, "bold"))

def draw_circle(turtle_obj, radius, color, position):
    """આપેલા ત્રિજ્યા અને કલર સાથે વતુળ દોરો"""
    
    x, y = position
    turtle_obj.penup()
    turtle_obj.goto(x, y - radius)  # વતુળના તળિયે પોઝિશન
    turtle_obj.pendown()
    
    turtle_obj.color(color)
    turtle_obj.fillcolor(color)
    turtle_obj.begin_fill()
    
    # વતુળ દોરો
    turtle_obj.circle(radius)
    
    turtle_obj.end_fill()
    
    # ક્ષેત્રફળ ગણતરી સાથે લેબલ ઉમેરો
    area = math.pi * radius * radius
    turtle_obj.penup()
    turtle_obj.goto(x, y - radius - 30)
    turtle_obj.color("black")
    turtle_obj.write(f"વતુળ (r={radius}, ક્ષેત્રફળ={area:.1f})", align="center", 
                    font=("Arial", 10, "bold"))

def draw_all_shapes():
    """ત્રણેય આકાર દોરવા માટેનું મુખ્ય ફંક્શન"""
    
    screen, shape_turtle = setup_drawing_environment()
    
    print("ભૌમિતિક આકાર દોરી રહ્યા છીએ...")
    
    # ચોરસ દોરો
    print("1. ચોરસ દોરી રહ્યા છીએ...")
    draw_square(shape_turtle, 80, "red", (-300, 100))
    
    # લાંબચોરસ દોરો  
    print("2. લાંબચોરસ દોરી રહ્યા છીએ...")
    draw_rectangle(shape_turtle, 120, 80, "green", (-50, 100))
    
    # વતુળ દોરો
    print("3. વતુળ દોરી રહ્યા છીએ...")
    draw_circle(shape_turtle, 60, "blue", (200, 100))
    
    # શીર્ષક અને માહિતી ઉમેરો
    add_shape_information(shape_turtle)
    
    print("બધા આકાર સફળતાપૂર્વક દોર્યા!")
    return screen

def add_shape_information(turtle_obj):
    """શીર્ષક અને આકારની માહિતી ઉમેરો"""
    
    # શીર્ષક
    turtle_obj.penup()
    turtle_obj.goto(0, 200)
    turtle_obj.color("purple")
    turtle_obj.write("Python ટર્ટલ આકારો", align="center", 
                    font=("Arial", 18, "bold"))
    
    # આકારની પ્રોપર્ટીઝ ટેબલ
    turtle_obj.goto(-350, -50)
    turtle_obj.color("black")
    turtle_obj.write("આકારની પ્રોપર્ટીઝ:", font=("Arial", 12, "bold"))
    
    properties = [
        "• ચોરસ: 4 સમાન બાજુઓ, 4 કાટકોણ",
        "• લાંબચોરસ: 4 બાજુઓ, સામેની બાજુઓ સમાન", 
        "• વતુળ: કેન્દ્રથી બધા બિંદુઓ સમાન અંતરે"
    ]
    
    for i, prop in enumerate(properties):
        turtle_obj.goto(-350, -80 - (i * 20))
        turtle_obj.write(prop, font=("Arial", 10, "normal"))
    
    # ગાણિતિક સૂત્રો
    turtle_obj.goto(-350, -170)
    turtle_obj.color("blue")
    turtle_obj.write("સૂત્રો:", font=("Arial", 12, "bold"))
    
    formulas = [
        "• ચોરસ ક્ષેત્રફળ: બાજુ²",
        "• લાંબચોરસ ક્ષેત્રફળ: લંબાઈ × પહોળાઈ",
        "• વતુળ ક્ષેત્રફળ: π × ત્રિજ્યા²"
    ]
    
    for i, formula in enumerate(formulas):
        turtle_obj.goto(-350, -200 - (i * 20))
        turtle_obj.write(formula, font=("Arial", 10, "normal"))

def interactive_shape_drawer():
    """યુઝર ઇન્ટરેક્શન સાથે એન્હાન્સ વર્ઝન"""
    
    screen, shape_turtle = setup_drawing_environment()
    
    # યુઝર પ્રાથમિકતાઓ મેળવો
    print("\n=== ઇન્ટરેક્ટિવ આકાર ડ્રોવર ===")
    
    try:
        # ચોરસ પેરામીટર્સ
        square_size = int(input("ચોરસ સાઈઝ દાખલ કરો (50-100): ") or "80")
        square_color = input("ચોરસ રંગ દાખલ કરો (લાલ/નીલો/લીલો): ") or "red"
        
        # લાંબચોરસ પેરામીટર્સ  
        rect_width = int(input("લાંબચોરસ પહોળાઈ દાખલ કરો (80-150): ") or "120")
        rect_height = int(input("લાંબચોરસ ઊંચાઈ દાખલ કરો (60-100): ") or "80")
        rect_color = input("લાંબચોરસ રંગ દાખલ કરો: ") or "green"
        
        # વતુળ પેરામીટર્સ
        circle_radius = int(input("વતુળ ત્રિજ્યા દાખલ કરો (40-80): ") or "60")
        circle_color = input("વતુળ રંગ દાખલ કરો: ") or "blue"
        
        # યુઝર પેરામીટર્સ સાથે આકાર દોરો
        draw_square(shape_turtle, square_size, square_color, (-300, 100))
        draw_rectangle(shape_turtle, rect_width, rect_height, rect_color, (-50, 100))
        draw_circle(shape_turtle, circle_radius, circle_color, (200, 100))
        
        add_shape_information(shape_turtle)
        
    except ValueError:
        print("અમાન્ય ઇનપુટ! ડિફોલ્ટ વેલ્યુઝ વાપરી રહ્યા છીએ...")
        return draw_all_shapes()
    
    return screen

# મુખ્ય એક્ઝિક્યુશન
def main():
    """વિકલ્પો સાથે મુખ્ય ફંક્શન"""
    
    print("ડ્રોઈંગ મોડ પસંદ કરો:")
    print("1. ડિફોલ્ટ આકારો")
    print("2. ઇન્ટરેક્ટિવ મોડ")
    
    choice = input("પસંદગી દાખલ કરો (1 અથવા 2): ").strip()
    
    if choice == "2":
        screen = interactive_shape_drawer()
    else:
        screen = draw_all_shapes()
    
    print("\nવિન્ડો બંધ કરવા માટે સ્ક્રીન પર ક્લિક કરો.")
    screen.exitonclick()

# પ્રોગ્રામ ચલાવો
if __name__ == "__main__":
    main()