ઓઓપીએસ અને પાયથોન પ્રોગ્રામિંગ (4351108) - શિયાળુ 2024 સોલ્યુશન

# Numeric types
age = 25          # int
price = 99.99     # float

# Text type
name = "Python"   # str

# Boolean type
is_valid = True   # bool

# Collection types
numbers = [1, 2, 3]        # list
coordinates = (10, 20)     # tuple
student = {"name": "John"} # dict
unique_ids = {1, 2, 3}     # set

# Arithmetic
a = 10 + 5    # 15
b = 10 // 3   # 3

# Assignment
x = 5
x += 3        # x બને છે 8

# Identity
list1 = [1, 2, 3]
list2 = [1, 2, 3]
print(list1 is list2)      # False
print(list1 is not list2)  # True

# ત્રણ સંખ્યાઓ input લો
num1 = float(input("પ્રથમ સંખ્યા દાખલ કરો: "))
num2 = float(input("બીજી સંખ્યા દાખલ કરો: "))
num3 = float(input("ત્રીજી સંખ્યા દાખલ કરો: "))

# if-elif-else વાપરીને મહત્તમ શોધો
if num1 >= num2 and num1 >= num3:
    maximum = num1
elif num2 >= num1 and num2 >= num3:
    maximum = num2
else:
    maximum = num3

# પરિણામ દર્શાવો
print(f"મહત્તમ સંખ્યા છે: {maximum}")

num1, num2, num3 = map(float, input("3 સંખ્યાઓ દાખલ કરો: ").split())
maximum = max(num1, num2, num3)
print(f"મહત્તમ: {maximum}")

# ખાલી ડિક્શનરી બનાવો
student = {}

# ઘટકો ઉમેરો
student['name'] = 'John'
student['age'] = 20
student['grade'] = 'A'

# ઘટક બદલો
student['age'] = 21

# ઘટક ડિલીટ કરો
del student['grade']

# ડિક્શનરી દર્શાવો
print(student)  # આઉટપુટ: {'name': 'John', 'age': 21}

# અન્ય methods
student.pop('age')           # Remove અને મૂલ્ય return કરે
student.update({'city': 'Mumbai'})  # અનેક items ઉમેરો

# પેટર્ન પ્રોગ્રામ
for i in range(1, 6):
    for j in range(1, i + 1):
        print(j, end=" ")
    print()  # દરેક રો પછી નવી લાઇન

# વપરાશકર્તા પાસેથી સંખ્યા input લો
number = int(input("સંખ્યા દાખલ કરો: "))
original_number = number
sum_digits = 0

# અંકો કાઢો અને સરવાળો કરો
while number > 0:
    digit = number % 10    # છેલ્લો અંક મેળવો
    sum_digits += digit    # સરવાળામાં ઉમેરો
    number = number // 10  # છેલ્લો અંક દૂર કરો

# પરિણામ દર્શાવો
print(f"{original_number} ના અંકોનો સરવાળો છે: {sum_digits}")

number = input("સંખ્યા દાખલ કરો: ")
sum_digits = sum(int(digit) for digit in number)
print(f"અંકોનો સરવાળો: {sum_digits}")

# લિસ્ટ બનાવો
list1 = [1, 2, 3, 4, 5]
list2 = [6, 7, 8]

# સ્લાઇસિંગ ઓપરેશન્સ
print(list1[1:4])    # [2, 3, 4]
print(list1[:3])     # [1, 2, 3]
print(list1[2:])     # [3, 4, 5]
print(list1[::2])    # [1, 3, 5]
print(list1[::-1])   # [5, 4, 3, 2, 1]

# કન્કેટનેશન ઓપરેશન્સ
result1 = list1 + list2           # [1, 2, 3, 4, 5, 6, 7, 8]
list1.extend(list2)               # list2 ને list1 માં ઉમેરે છે
combined = [*list1, *list2]       # Unpacking operator વાપરીને

# લિસ્ટ બનાવો
fruits = ['apple', 'banana']

# અંતમાં ઘટક ઉમેરો
fruits.append('orange')
print(fruits)  # ['apple', 'banana', 'orange']

# મેથડ 1: નેગેટિવ ઇન્ડેક્સ વાપરીને
my_tuple = (10, 20, 30, 40, 50)
last_element = my_tuple[-1]
print(last_element)  # આઉટપુટ: 50

# મેથડ 2: length વાપરીને
last_element = my_tuple[len(my_tuple) - 1]
print(last_element)  # આઉટપુટ: 50

# ખાલી સેટ બનાવો
my_set = set()

# ઘટકો ઉમેરો
my_set.add(10)
my_set.add(20)

# ઘટક દૂર કરો
my_set.remove(10)

# ઓપરેશન્સ માટે બે સેટ બનાવો
A = {1, 2, 3, 4}
B = {3, 4, 5, 6}

# યુનિયન (બધા અનન્ય ઘટકો)
union_result = A.union(B)        # {1, 2, 3, 4, 5, 6}

# છેદ (સામાન્ય ઘટકો)
intersection_result = A.intersection(B)  # {3, 4}

# તફાવત (A - B)
difference_result = A.difference(B)      # {1, 2}

# સિમેટ્રિક તફાવત (A અથવા B માં છે, પરંતુ બંનેમાં નહીં)
sym_diff_result = A.symmetric_difference(B)  # {1, 2, 5, 6}

# સિંગલ અવતરણ
name = 'Python'

# ડબલ અવતરણ
message = "Hello World"

# ટ્રિપલ અવતરણ (મલ્ટિલાઇન)
text = """આ એક
મલ્ટિલાઇન સ્ટ્રિંગ છે"""

word = "PYTHON"
print(word[0])    # P (પ્રથમ અક્ષર)
print(word[2])    # T (ત્રીજો અક્ષર)
print(word[-1])   # N (છેલ્લો અક્ષર)
print(word[-2])   # O (છેલ્લાથી બીજો)

numbers = [10, 20, 30, 40, 50]

# મેથડ 1: સીધો iteration
for num in numbers:
    print(num)

# મેથડ 2: ઇન્ડેક્સ વાપરીને
for i in range(len(numbers)):
    print(f"ઇન્ડેક્સ {i}: {numbers[i]}")

numbers = [10, 20, 30, 40, 50]
i = 0

while i < len(numbers):
    print(f"ઇન્ડેક્સ {i} પર ઘટક: {numbers[i]}")
    i += 1

# વિદ્યાર્થીઓની સંખ્યા input કરો
n = int(input("વિદ્યાર્થીઓની સંખ્યા દાખલ કરો: "))

# ખાલી ડિક્શનરી બનાવો
students = {}

# વિદ્યાર્થીઓનો ડેટા input કરો
for i in range(n):
    print(f"\nવિદ્યાર્થી {i + 1} ની વિગતો દાખલ કરો:")
    roll_no = int(input("રોલ નંબર: "))
    name = input("નામ: ")
    marks = float(input("માર્ક્સ: "))
    
    # ડિક્શનરીમાં સ્ટોર કરો
    students[roll_no] = {
        'name': name,
        'marks': marks
    }

# 75 થી વધુ માર્ક્સ વાળા વિદ્યાર્થીઓ દર્શાવો
print("\n75 થી વધુ માર્ક્સ વાળા વિદ્યાર્થીઓ:")
print("-" * 30)

high_performers = []
for roll_no, data in students.items():
    if data['marks'] > 75:
        high_performers.append(data['name'])
        print(f"નામ: {data['name']}, માર્ક્સ: {data['marks']}")

if not high_performers:
    print("કોઈ વિદ્યાર્થીએ 75 થી વધુ માર્ક્સ મેળવ્યા નથી")
else:
    print(f"\nકુલ હાઇ પર્ફોર્મર્સ: {len(high_performers)}")

import random

# random() - 0.0 અને 1.0 વચ્ચે ફ્લોટ બનાવે છે
num = random.random()
print(num)  # ઉદાહરણ: 0.7234567

# randint() - આપેલ રેન્જ વચ્ચે ઇન્ટીજર બનાવે છે
dice = random.randint(1, 6)
print(dice)  # ઉદાહરણ: 4

# choice() - સિક્વન્સમાંથી રેન્ડમ ઘટક પસંદ કરે છે
colors = ['red', 'blue', 'green']
selected = random.choice(colors)
print(selected)  # ઉદાહરણ: 'blue'

# ફંક્શન વગર (પુનરાવર્તન)
num1 = 5
square1 = num1 * num1
print(square1)

num2 = 8
square2 = num2 * num2
print(square2)

# ફંક્શન સાથે (પુનઃઉપયોગ)
def calculate_square(num):
    return num * num

print(calculate_square(5))  # 25
print(calculate_square(8))  # 64

# વપરાશકર્તા પાસેથી સ્ટ્રિંગ input લો
text = input("સ્ટ્રિંગ દાખલ કરો: ")

# 'a' ની બધી positions શોધો
positions = []
for i in range(len(text)):
    if text[i].lower() == 'a':  # 'a' અને 'A' બંને માટે ચેક કરો
        positions.append(i)

# પરિણામો દર્શાવો
if positions:
    print(f"અક્ષર 'a' આ positions પર મળ્યું: {positions}")
    print("વિગતવાર સ્થાનો:")
    for pos in positions:
        print(f"Position {pos}: '{text[pos]}'")
else:
    print("અક્ષર 'a' સ્ટ્રિંગમાં મળ્યું નથી")

# enumerate વાપરીને વૈકલ્પિક રીત
print("\nવૈકલ્પિક રીત:")
for index, char in enumerate(text):
    if char.lower() == 'a':
        print(f"'a' position {index} પર મળ્યું")

text = input("સ્ટ્રિંગ દાખલ કરો: ")
count = 0

print(f"'{text}' માં 'a' શોધી રહ્યા છીએ")
print("-" * 30)

for i, char in enumerate(text):
    if char.lower() == 'a':
        count += 1
        print(f"'a' ઇન્ડેક્સ {i} પર મળ્યું (અક્ષર: '{char}')")

print(f"\n'a' ની કુલ આવૃત્તિઓ: {count}")

# ગ્લોબલ વેરિયેબલ
global_var = "હું ગ્લોબલ છું"

def my_function():
    # લોકલ વેરિયેબલ
    local_var = "હું લોકલ છું"
    print(global_var)  # ગ્લોબલ એક્સેસ કરી શકાય છે
    print(local_var)   # લોકલ એક્સેસ કરી શકાય છે

my_function()
print(global_var)      # ગ્લોબલ એક્સેસ કરી શકાય છે
# print(local_var)     # એરર - લોકલ એક્સેસ કરી શકાતું નથી

counter = 0  # ગ્લોબલ વેરિયેબલ

def increment():
    global counter  # બદલવા માટે ગ્લોબલ તરીકે declare કરો
    counter += 1

increment()
print(counter)  # આઉટપુટ: 1

def function_name(parameters):
    """વૈકલ્પિક docstring"""
    # ફંક્શન બોડી
    return value  # વૈકલ્પિક

# ફંક્શન વ્યાખ્યા
def greet_user(name, age):
    """નામ અને ઉંમર સાથે વપરાશકર્તાને શુભેચ્છા આપવાનું ફંક્શન"""
    message = f"હેલો {name}! તમારી ઉંમર {age} વર્ષ છે."
    return message

# ફંક્શન કૉલ
user_name = "જોહન"
user_age = 25
greeting = greet_user(user_name, user_age)
print(greeting)  # આઉટપુટ: હેલો જોહન! તમારી ઉંમર 25 વર્ષ છે.

# ડિફોલ્ટ પેરામીટર સાથે ફંક્શન
def calculate_power(base, exponent=2):
    return base ** exponent

print(calculate_power(5))     # 25 (ડિફોલ્ટ exponent=2 વાપરીને)
print(calculate_power(5, 3))  # 125 (exponent=3 વાપરીને)

def calcFact(number):
    """
    સંખ્યાનું ફેક્ટોરિયલ કેલ્ક્યુલેટ કરવાનું ફંક્શન
    ઇનપુટ: number (integer)
    આઉટપુટ: factorial (integer)
    """
    if number < 0:
        return "નેગેટિવ સંખ્યા માટે ફેક્ટોરિયલ વ્યાખ્યાયિત નથી"
    elif number == 0 or number == 1:
        return 1
    else:
        factorial = 1
        for i in range(2, number + 1):
            factorial *= i
        return factorial

# મુખ્ય પ્રોગ્રામ
try:
    # વપરાશકર્તા પાસેથી ઇનપુટ
    num = int(input("સંખ્યા દાખલ કરો: "))
    
    # ફંક્શન કૉલ
    result = calcFact(num)
    
    # પરિણામ દર્શાવો
    if isinstance(result, str):
        print(result)
    else:
        print(f"{num} નું ફેક્ટોરિયલ છે: {result}")
        
except ValueError:
    print("કૃપા કરીને યોગ્ય ઇન્ટીજર દાખલ કરો")

# વિવિધ મૂલ્યો સાથે ટેસ્ટ કરો
print("\nવિવિધ મૂલ્યો સાથે ટેસ્ટિંગ:")
test_values = [0, 1, 5, 10, -3]
for val in test_values:
    result = calcFact(val)
    print(f"calcFact({val}) = {result}")

def calcFactRecursive(n):
    """ફેક્ટોરિયલ કેલ્ક્યુલેટ કરવાનું રીકર્સિવ ફંક્શન"""
    if n < 0:
        return "નેગેટિવ સંખ્યા માટે અવ્યાખ્યાયિત"
    elif n == 0 or n == 1:
        return 1
    else:
        return n * calcFactRecursive(n - 1)

# ઉદાહરણ ઉપયોગ
number = int(input("સંખ્યા દાખલ કરો: "))
result = calcFactRecursive(number)
print(f"ફેક્ટોરિયલ: {result}")

# ક્લાસ વ્યાખ્યા (બ્લૂપ્રિન્ટ)
class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

# ઓબ્જેક્ટ બનાવટ (ઇન્સ્ટન્સ)
student1 = Student("જોહન", 20)  # ઓબ્જેક્ટ 1
student2 = Student("આલિસ", 19) # ઓબ્જેક્ટ 2

print(student1.name)  # જોહન
print(student2.name)  # આલિસ

class Rectangle:
    def __init__(self, length=0, width=0):  # કન્સ્ટ્રક્ટર
        self.length = length  # એટ્રિબ્યુટ ઇનિશિયલાઇઝ કરો
        self.width = width    # એટ્રિબ્યુટ ઇનિશિયલાઇઝ કરો
        print("રેક્ટેંગલ ઓબ્જેક્ટ બન્યું!")
    
    def area(self):
        return self.length * self.width

# ઓબ્જેક્ટ બનાવટ - કન્સ્ટ્રક્ટર આપોઆપ કૉલ થાય છે
rect1 = Rectangle(10, 5)  # આઉટપુટ: રેક્ટેંગલ ઓબ્જેક્ટ બન્યું!
rect2 = Rectangle()       # ડિફોલ્ટ મૂલ્યો વાપરે છે

print(rect1.area())       # 50
print(rect2.area())       # 0

class Student:
    def __init__(self, name, roll_number, marks):
        """વિદ્યાર્થી એટ્રિબ્યુટ્સ ઇનિશિયલાઇઝ કરવા માટે કન્સ્ટ્રક્ટર"""
        self.name = name
        self.roll_number = roll_number
        self.marks = marks
    
    def display_info(self):
        """વિદ્યાર્થીની માહિતી દર્શાવવાની મેથડ"""
        print("-" * 30)
        print("વિદ્યાર્થીની માહિતી")
        print("-" * 30)
        print(f"નામ: {self.name}")
        print(f"રોલ નંબર: {self.roll_number}")
        print(f"માર્ક્સ: {self.marks}")
        print("-" * 30)
    
    def calculate_grade(self):
        """માર્ક્સ આધારે ગ્રેડ કેલ્ક્યુલેટ કરવાની મેથડ"""
        if self.marks >= 90:
            return 'A+'
        elif self.marks >= 80:
            return 'A'
        elif self.marks >= 70:
            return 'B'
        elif self.marks >= 60:
            return 'C'
        else:
            return 'F'
    
    def display_grade(self):
        """ગ્રેડ દર્શાવવાની મેથડ"""
        grade = self.calculate_grade()
        print(f"ગ્રેડ: {grade}")

# Student ક્લાસના ઓબ્જેક્ટ્સ બનાવવું
print("Student ઓબ્જેક્ટ્સ બનાવી રહ્યા છીએ:")
student1 = Student("જોહન દોય", 101, 85)
student2 = Student("આલિસ સ્મિથ", 102, 92)
student3 = Student("બોબ જોહન્સન", 103, 78)

# માહિતી દર્શાવવા માટે મેથડ્સનો ઉપયોગ
print("\n=== વિદ્યાર્થી 1 ની વિગતો ===")
student1.display_info()
student1.display_grade()

print("\n=== વિદ્યાર્થી 2 ની વિગતો ===")
student2.display_info()
student2.display_grade()

print("\n=== વિદ્યાર્થી 3 ની વિગતો ===")
student3.display_info()
student3.display_grade()

# એટ્રિબ્યુટ્સને સીધી એક્સેસ કરવું
print(f"\nસીધી એક્સેસ - વિદ્યાર્થી 1 નું નામ: {student1.name}")
print(f"સીધી એક્સેસ - વિદ્યાર્થી 2 ના માર્ક્સ: {student2.marks}")

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance  # પ્રાઇવેટ એટ્રિબ્યુટ
    
    def get_balance(self):       # Getter મેથડ
        return self.__balance
    
    def deposit(self, amount):   # નિયંત્રિત એક્સેસ
        if amount > 0:
            self.__balance += amount

account = BankAccount(1000)
print(account.get_balance())     # 1000
# print(account.__balance)       # એરર - સીધી એક્સેસ કરી શકાતી નથી

# લેવલ 1 - મૂળ ક્લાસ
class Vehicle:
    def __init__(self, brand):
        self.brand = brand
    
    def start(self):
        print(f"{self.brand} વાહન શરૂ થયું")

# લેવલ 2 - Vehicle માંથી ઇન્હેરિટ
class Car(Vehicle):
    def __init__(self, brand, model):
        super().__init__(brand)
        self.model = model
    
    def drive(self):
        print(f"{self.brand} {self.model} ચાલી રહી છે")

# લેવલ 3 - Car માંથી ઇન્હેરિટ
class SportsCar(Car):
    def __init__(self, brand, model, top_speed):
        super().__init__(brand, model)
        self.top_speed = top_speed
    
    def race(self):
        print(f"{self.brand} {self.model} {self.top_speed} km/h ઝડપે રેસ કરી રહી છે")

# ઓબ્જેક્ટ બનાવીને મેથડ્સ વાપરવા
ferrari = SportsCar("Ferrari", "F8", 340)
ferrari.start()    # Vehicle ક્લાસમાંથી
ferrari.drive()    # Car ક્લાસમાંથી
ferrari.race()     # SportsCar ક્લાસમાંથી

# મૂળ ક્લાસ
class Animal:
    def __init__(self, name):
        self.name = name
        print(f"પ્રાણી {self.name} બન્યું")
    
    def eat(self):
        print(f"{self.name} ખાય છે")
    
    def sleep(self):
        print(f"{self.name} સૂએ છે")

# Animal માંથી સિંગલ ઇન્હેરિટન્સ
class Mammal(Animal):
    def __init__(self, name, fur_color):
        super().__init__(name)
        self.fur_color = fur_color
    
    def give_birth(self):
        print(f"{self.name} જીવતા બાળકોને જન્મ આપે છે")

# Animal માંથી સિંગલ ઇન્હેરિટન્સ
class Bird(Animal):
    def __init__(self, name, wing_span):
        super().__init__(name)
        self.wing_span = wing_span
    
    def fly(self):
        print(f"{self.name} {self.wing_span}cm પાંખો સાથે ઉડે છે")
    
    def lay_eggs(self):
        print(f"{self.name} ઇંડા આપે છે")

# Mammal માંથી સિંગલ ઇન્હેરિટન્સ
class Dog(Mammal):
    def __init__(self, name, fur_color, breed):
        super().__init__(name, fur_color)
        self.breed = breed
    
    def bark(self):
        print(f"{self.name} {self.breed} કૂકે છે")
    
    def guard(self):
        print(f"{self.name} ઘરની રક્ષા કરે છે")

# Dog અને Bird માંથી મલ્ટિપલ ઇન્હેરિટન્સ (હાઇબ્રિડ)
class FlyingDog(Dog, Bird):
    def __init__(self, name, fur_color, breed, wing_span):
        # બંને પેરેન્ટ ક્લાસને ઇનિશિયલાઇઝ કરો
        Dog.__init__(self, name, fur_color, breed)
        Bird.__init__(self, name, wing_span)
        print(f"જાદુઈ {self.name} બન્યું જેમાં mammal અને bird બંનેના લક્ષણ છે!")
    
    def fly_and_bark(self):
        print(f"{self.name} એક સાથે ઉડે છે અને કૂકે છે!")
    
    def show_abilities(self):
        print(f"\n{self.name} ની ક્ષમતાઓ:")
        print("-" * 25)
        self.eat()          # Animal માંથી
        self.sleep()        # Animal માંથી
        self.give_birth()   # Mammal માંથી
        self.bark()         # Dog માંથી
        self.guard()        # Dog માંથી
        self.fly()          # Bird માંથી
        self.lay_eggs()     # Bird માંથી
        self.fly_and_bark() # પોતાની મેથડ

# પ્રદર્શન
print("=== હાઇબ્રિડ ઇન્હેરિટન્સ ડેમો ===\n")

# ઓબ્જેક્ટ્સ બનાવો
print("1. સામાન્ય કૂતરો બનાવી રહ્યા છીએ:")
dog1 = Dog("બડી", "સુવર્ણ", "રિટ્રીવર")
dog1.bark()
dog1.guard()

print("\n2. સામાન્ય પક્ષી બનાવી રહ્યા છીએ:")
bird1 = Bird("ગરુડ", 200)
bird1.fly()
bird1.lay_eggs()

print("\n3. જાદુઈ ઉડતો કૂતરો બનાવી રહ્યા છીએ:")
flying_dog = FlyingDog("સુપરડોગ", "રજતી", "હસ્કી", 150)
flying_dog.show_abilities()

# મેથડ રિઝોલ્યુશન ઓર્ડર
print(f"\nFlyingDog માટે મેથડ રિઝોલ્યુશન ઓર્ડર:")
for i, cls in enumerate(FlyingDog.__mro__):
    print(f"{i+1}. {cls.__name__}")