મુખ્ય સામગ્રી પર જાઓ
Python Programming (4311601) - Winter 2023 Solution (Gujarati)
  1. સંસાધનો/
  2. અભ્યાસ સામગ્રી/
  3. ઇન્ફોર્મેશન ટેકનોલોજી એન્જિનિયરિંગ/
  4. આઈટી સેમેસ્ટર 1/
  5. પાયથોન પ્રોગ્રામિંગ (4311601)/

Python Programming (4311601) - Winter 2023 Solution (Gujarati)

મિલવ ડબગર
લેખક
મિલવ ડબગર
ઇલેક્ટ્રિકલ અને ઇલેક્ટ્રોનિક મેન્યુફેક્ચરિંગ ઉદ્યોગમાં અનુભવી લેક્ચરર. એમ્બેડેડ સિસ્ટમ્સ, ઈમેજ પ્રોસેસિંગ, ડેટા સાયન્સ, મેટલેબ, પાયથન, STM32માં કુશળ. એલ.ડી. કોલેજ ઓફ એન્જિનિયરિંગ - અમદાવાદથી કમ્યુનિકેશન સિસ્ટમ્સ એન્જિનિયરિંગમાં માસ્ટર્સ ડિગ્રી ધરાવતા મજબૂત શિક્ષણ વ્યાવસાયિક.
અનુક્રમણિકા

પ્રશ્ન 1(અ) [3 ગુણ]
#

ફ્લો ચાર્ટ શું છે? ફ્લો ચાર્ટમાં વપરાતા પ્રતીકોની યાદી બનાવો.

જવાબ:

ફ્લો ચાર્ટ એ અલ્ગોરિધમની ગ્રાફિકલ રજૂઆત છે જે પ્રક્રિયાના પગલાંઓ અને નિર્ણય બિંદુઓ દર્શાવે છે.

ફ્લો ચાર્ટ પ્રતીકોનું ટેબલ:

પ્રતીકનામઉપયોગ
અંડાકારટર્મિનલપ્રારંભ/અંત
લંબચોરસપ્રોસેસપ્રક્રિયા/ગણતરી
હીરોનિર્ણયશરતી નિવેદનો
સમાંતર ચતુષ્કોણઇનપુટ/આઉટપુટડેટા લેવો/આપવો
વૃત્તકનેક્ટરભાગોને જોડવા
તીરફ્લો લાઇનદિશા

મુખ્ય બિંદુઓ:

  • વિઝ્યુઅલ રજૂઆત: પ્રોગ્રામ લોજિક ગ્રાફિકલી દર્શાવે
  • પગલાં દર પગલાં: ક્રમિક ઓપરેશનનો ફ્લો
  • નિર્ણય લેવો: હીરા શરતી શાખાઓ દર્શાવે

મેમરી ટ્રીક: “ફ્લો ચાર્ટ્સ પ્રોગ્રામ સ્ટેપ્સ વિઝ્યુઅલી દર્શાવે”

પ્રશ્ન 1(બ) [4 ગુણ]
#

for લૂપ માટે ટૂંકી નોંધ લખો.

જવાબ:

for લૂપ Python માં સિક્વન્સ (list, tuple, string, range) પર iterate કરવા માટે વપરાય છે.

For લૂપ ટેબલ:

ઘટકસિન્ટેક્સઉદાહરણ
મૂળભૂતfor variable in sequence:for i in range(5):
રેન્જrange(start, stop, step)range(1, 10, 2)
યાદીfor item in list:for x in [1,2,3]:
સ્ટ્રિંગfor char in string:for c in "hello":

સરળ કોડ ઉદાહરણ:

for i in range(3):
    print(i)
# આઉટપુટ: 0, 1, 2

મુખ્ય લક્ષણો:

  • ઓટોમેટિક iteration: મેન્યુઅલ કાઉન્ટરની જરૂર નથી
  • સિક્વન્સ ટ્રાવર્સલ: કોઈપણ iterable ઓબ્જેક્ટ સાથે કામ કરે
  • રેન્જ ફંક્શન: નંબર સિક્વન્સ સરળતાથી બનાવે

મેમરી ટ્રીક: “For લૂપ્સ સિક્વન્સમાં iterate કરે”

પ્રશ્ન 1(ક) [7 ગુણ]
#

ફિબોનાકી શ્રેણીને nમી ટર્મ સુધી દર્શાવવા માટે એક પ્રોગ્રામ લખો જ્યાં યુઝર દ્વારા n આપવામાં આવે છે.

જવાબ:

ફિબોનાકી શ્રેણી પ્રોગ્રામ:

# યુઝર પાસેથી ટર્મ્સની સંખ્યા લો
n = int(input("ટર્મ્સની સંખ્યા દાખલ કરો: "))

# પ્રથમ બે ટર્મ્સ initialize કરો
a, b = 0, 1

# પ્રથમ ટર્મ દર્શાવો
if n >= 1:
    print(a, end=" ")
    
# બીજી ટર્મ દર્શાવો
if n >= 2:
    print(b, end=" ")

# બાકીની ટર્મ્સ જનરેટ કરો
for i in range(2, n):
    c = a + b
    print(c, end=" ")
    a, b = b, c

અલ્ગોરિધમ ફ્લો:

flowchart LR
    A[શરૂ] --> B[n ઇનપુટ]
    B --> C{n >= 1?}
    C -->|હા| D[0 પ્રિન્ટ કરો]
    C -->|ના| H[અંત]
    D --> E{n >= 2?}
    E -->|હા| F[1 પ્રિન્ટ કરો]
    E -->|ના| H
    F --> G[લૂપ i=2 થી n-1]
    G --> I[c = a + b]
    I --> J[c પ્રિન્ટ કરો]
    J --> K[a = b, b = c]
    K --> L{i < n-1?}
    L -->|હા| G
    L -->|ના| H[અંત]

મુખ્ય કોન્સેપ્ટ્સ:

  • સિક્વેન્શિયલ જનરેશન: દરેક ટર્મ = પાછલી બે ટર્મનો સરવાળો
  • વેરિયેબલ સ્વેપિંગ: a, b વેલ્યુઝ અસરકારક રીતે અપડેટ કરો
  • યુઝર ઇનપુટ: ડાયનેમિક શ્રેણી લેન્થ

મેમરી ટ્રીક: “ફિબોનાકી: પાછલા બે નંબરો ઉમેરો”

પ્રશ્ન 1(ક OR) [7 ગુણ]
#

1 થી 100 સુધીના ODD નંબરો પ્રિન્ટ કરવા માટે ફ્લો ચાર્ટ દોરો.

જવાબ:

1 થી 100 ODD નંબરો માટે ફ્લોચાર્ટ:

flowchart LR
    A[શરૂ] --> B[i = 1]
    B --> C{i <= 100?}
    C -->|હા| D{i % 2 != 0?}
    D -->|હા| E[i પ્રિન્ટ કરો]
    D -->|ના| F[i = i + 1]
    E --> F
    F --> C
    C -->|ના| G[અંત]

અનુસંગિક Python કોડ:

for i in range(1, 101):
    if i % 2 != 0:
        print(i, end=" ")

વૈકલ્પિક પદ્ધતિ:

for i in range(1, 101, 2):
    print(i, end=" ")

મુખ્ય તત્વો:

  • લૂપ કંટ્રોલ: i 1 થી 100 સુધી
  • વિષમ ચેક: i % 2 != 0 શરત
  • સ્ટેપ વધારો: આગલા નંબર પર જાઓ

મેમરી ટ્રીક: “વિષમ નંબરો: 2 થી ભાગ્યે 1 બાકી”

પ્રશ્ન 2(અ) [3 ગુણ]
#

નંબર પેલિન્ડ્રોમ છે કે નહીં તે શોધવા માટે પ્રોગ્રામ લખો.

જવાબ:

પેલિન્ડ્રોમ ચેક પ્રોગ્રામ:

# નંબર ઇનપુટ
num = int(input("નંબર દાખલ કરો: "))
temp = num
reverse = 0

# નંબરને રિવર્સ કરો
while temp > 0:
    reverse = reverse * 10 + temp % 10
    temp = temp // 10

# પેલિન્ડ્રોમ ચેક કરો
if num == reverse:
    print(f"{num} પેલિન્ડ્રોમ છે")
else:
    print(f"{num} પેલિન્ડ્રોમ નથી")

અલ્ગોરિધમ ટેબલ:

પગલુંઓપરેશનઉદાહરણ (121)
1છેલ્લો અંક મેળવો121 % 10 = 1
2રિવર્સ બનાવો0*10 + 1 = 1
3છેલ્લો અંક દૂર કરો121 // 10 = 12
40 સુધી પુનરાવર્તનપ્રક્રિયા ચાલુ રાખો

મુખ્ય બિંદુઓ:

  • ડિજિટ એક્સ્ટ્રેક્શન: મોડ્યુલો (%) ઓપરેટર વાપરો
  • રિવર્સ બિલ્ડિંગ: 10 થી ગુણા કરી ડિજિટ ઉમેરો
  • સરખામણી: મૂળ બરાબર રિવર્સ

મેમરી ટ્રીક: “પેલિન્ડ્રોમ આગળ પાછળ સરખું વાંચાય”

પ્રશ્ન 2(બ) [4 ગુણ]
#

Python પ્રોગ્રામિંગની વિશેષતાઓ સમજાવો.

જવાબ:

Python વિશેષતાઓનું ટેબલ:

વિશેષતાવર્ણનફાયદો
સરળ સિન્ટેક્સસાદો, વાંચી શકાય તેવો કોડઝડપી ડેવલપમેન્ટ
ઇન્ટરપ્રિટેડકમ્પાઇલેશનની જરૂર નથીઝડપી ટેસ્ટિંગ
ઓબ્જેક્ટ-ઓરિએન્ટેડક્લાસ અને ઓબ્જેક્ટ સપોર્ટકોડ રિયુઝેબિલિટી
ઓપન સોર્સવાપરવા માટે ફ્રીલાઇસન્સિંગ કોસ્ટ નથી
ક્રોસ-પ્લેટફોર્મમલ્ટિપલ OS પર ચાલેવ્યાપક કમ્પેટિબિલિટી
મોટી લાઇબ્રેરીઓવ્યાપક બિલ્ટ-ઇન મોડ્યુલ્સસમૃદ્ધ કાર્યક્ષમતા

મુખ્ય ફાયદાઓ:

  • શિખાઉ-મિત્ર: શીખવામાં અને સમજવામાં સરળ
  • વર્સેટાઇલ: વેબ ડેવલપમેન્ટ, AI, ડેટા સાયન્સ
  • કોમ્યુનિટી સપોર્ટ: મોટો ડેવલપર કોમ્યુનિટી
  • ડાયનેમિક ટાઇપિંગ: વેરિયેબલ ટાઇપ ડિક્લેરેશનની જરૂર નથી

મેમરી ટ્રીક: “Python: સરળ, શક્તિશાળી, લોકપ્રિય પ્રોગ્રામિંગ”

પ્રશ્ન 2(ક) [7 ગુણ]
#

Python પ્રોગ્રામની બેસિક સ્ટ્રક્ચર સમજાવો.

જવાબ:

Python પ્રોગ્રામ સ્ટ્રક્ચર:

#!/usr/bin/env python3
# Shebang લાઇન (વૈકલ્પિક)

"""
ડોક્યુમેન્ટેશન સ્ટ્રિંગ (docstring)
પ્રોગ્રામનો હેતુ વર્ણવે છે
"""

# Import સ્ટેટમેન્ટ્સ
import math
from datetime import date

# ગ્લોબલ વેરિયેબલ્સ
PI = 3.14159
count = 0

# ફંક્શન ડેફિનિશન્સ
def calculate_area(radius):
    """વર્તુળનો ક્ષેત્રફળ કેલ્ક્યુલેટ કરે"""
    return PI * radius * radius

# ક્લાસ ડેફિનિશન્સ
class Calculator:
    def __init__(self):
        self.result = 0

# મેઇન પ્રોગ્રામ એક્ઝિક્યુશન
if __name__ == "__main__":
    # પ્રોગ્રામ લોજિક અહીં
    radius = 5
    area = calculate_area(radius)
    print(f"ક્ષેત્રફળ: {area}")

સ્ટ્રક્ચર કમ્પોનન્ટ્સ ટેબલ:

કમ્પોનન્ટહેતુઉદાહરણ
Shebangસિસ્ટમ ઇન્ટરપ્રિટર#!/usr/bin/env python3
Docstringપ્રોગ્રામ ડોક્યુમેન્ટેશન"""પ્રોગ્રામ વર્ણન"""
Importsબાહ્ય મોડ્યુલ્સimport math
વેરિયેબલ્સગ્લોબલ ડેટા સ્ટોરેજPI = 3.14159
ફંક્શન્સપુનઃવપરાશ કોડ બ્લોક્સdef function_name():
ક્લાસીસઓબ્જેક્ટ ટેમ્પ્લેટ્સclass ClassName:
મેઇન બ્લોકપ્રોગ્રામ એક્ઝિક્યુશનif __name__ == "__main__":

મુખ્ય સિદ્ધાંતો:

  • ઇન્ડેન્ટેશન: કોડ બ્લોક્સ વ્યાખ્યાયિત કરે (4 સ્પેસીસ આગ્રહણીય)
  • કોમેન્ટ્સ: સિંગલ લાઇન માટે #, મલ્ટિ-લાઇન માટે """ """
  • મોડ્યુલેરિટી: ફંક્શન અને ક્લાસમાં કોડ ગોઠવો

મેમરી ટ્રીક: “સ્ટ્રક્ચર: ઇમ્પોર્ટ, ડિફાઇન, એક્ઝિક્યુટ”

પ્રશ્ન 2(અ OR) [3 ગુણ]
#

સ્ટ્રિંગને રિવર્સ કરવા માટે પ્રોગ્રામ લખો.

જવાબ:

સ્ટ્રિંગ રિવર્સલ પ્રોગ્રામ:

# પદ્ધતિ 1: સ્લાઇસિંગ વાપરીને
string = input("સ્ટ્રિંગ દાખલ કરો: ")
reversed_string = string[::-1]
print(f"રિવર્સ: {reversed_string}")

# પદ્ધતિ 2: લૂપ વાપરીને
string = input("સ્ટ્રિંગ દાખલ કરો: ")
reversed_string = ""
for char in string:
    reversed_string = char + reversed_string
print(f"રિવર્સ: {reversed_string}")

રિવર્સલ પદ્ધતિઓનું ટેબલ:

પદ્ધતિસિન્ટેક્સઉદાહરણ
સ્લાઇસિંગstring[::-1]“hello” → “olleh”
લૂપકેરેક્ટર દ્વારા કેરેક્ટર બનાવોદરેક char આગળ ઉમેરો
બિલ્ટ-ઇન"".join(reversed(string))રિવર્સ સિક્વન્સ જોડો

મુખ્ય કોન્સેપ્ટ્સ:

  • સ્લાઇસિંગ: સૌથી અસરકારક પદ્ધતિ
  • કન્કેટેનેશન: કેરેક્ટર દ્વારા કેરેક્ટર સ્ટ્રિંગ બનાવો
  • ઇન્ડેક્સિંગ: સ્ટ્રિંગ પોઝિશન્સ એક્સેસ કરો

મેમરી ટ્રીક: “રિવર્સ: છેલ્લો કેરેક્ટર પહેલો”

પ્રશ્ન 2(બ OR) [4 ગુણ]
#

લોજિકલ ઓપરેટર્સને ઉદાહરણ સાથે સમજાવો.

જવાબ:

Python લોજિકલ ઓપરેટર્સ:

ઓપરેટરસિમ્બોલવર્ણનઉદાહરણપરિણામ
ANDandબંને શરતો સાચીTrue and FalseFalse
ORorઓછામાં ઓછી એક શરત સાચીTrue or FalseTrue
NOTnotશરતની વિરુદ્ધnot TrueFalse

ઉદાહરણ કોડ:

a = 10
b = 5

# AND ઓપરેટર
if a > 5 and b < 10:
    print("બંને શરતો સાચી")

# OR ઓપરેટર  
if a > 15 or b < 10:
    print("ઓછામાં ઓછી એક શરત સાચી")

# NOT ઓપરેટર
if not (a < 5):
    print("a 5 કરતાં નાનું નથી")

ટ્રુથ ટેબલ:

ABA and BA or Bnot A
TTTTF
TFFTF
FTFTT
FFFFT

મુખ્ય ઉપયોગો:

  • જટિલ શરતો: બહુવિધ ચેક્સ કંબાઇન કરો
  • નિર્ણય લેવો: પ્રોગ્રામ ફ્લો કંટ્રોલ કરો
  • બુલિયન લોજિક: True/False ઓપરેશન્સ

મેમરી ટ્રીક: “AND બધાની જરૂર, OR એકની જરૂર, NOT ઉલટાવે”

પ્રશ્ન 2(ક OR) [7 ગુણ]
#

Python માં વિવિધ ડેટા પ્રકારો સમજાવો

જવાબ:

Python ડેટા ટાઇપ્સ વર્ગીકરણ:

graph TD
    A[Python ડેટા ટાઇપ્સ] --> B[સંખ્યાત્મક]
    A --> C[સિક્વન્સ]
    A --> D[બુલિયન]
    A --> E[સેટ]
    A --> F[ડિક્શનરી]
    B --> G[int]
    B --> H[float]
    B --> I[complex]
    C --> J[str]
    C --> K[list]
    C --> L[tuple]

ડેટા ટાઇપ્સ ટેબલ:

ટાઇપઉદાહરણવર્ણનMutable
int42પૂર્ણ સંખ્યાઓના
float3.14દશાંશ સંખ્યાઓના
str"hello"ટેક્સ્ટ ડેટાના
list[1,2,3]ક્રમાંકિત સંગ્રહહા
tuple(1,2,3)ક્રમાંકિત અપરિવર્તનીયના
dict{"a":1}કી-વેલ્યુ જોડીઓહા
boolTrue/Falseબુલિયન વેલ્યુઝના
set{1,2,3}યુનિક તત્વોહા

ઉદાહરણ કોડ:

# સંખ્યાત્મક ટાઇપ્સ
age = 25          # int
price = 99.99     # float
complex_num = 3+4j # complex

# સિક્વન્સ ટાઇપ્સ
name = "Python"         # string
numbers = [1,2,3,4]     # list
coordinates = (10,20)   # tuple

# અન્ય ટાઇપ્સ
is_active = True        # boolean
unique_items = {1,2,3}  # set
student = {"name":"John", "age":20}  # dict

મુખ્ય લક્ષણો:

  • ડાયનેમિક ટાઇપિંગ: વેરિયેબલ ટાઇપ ડિક્લેર કરવાની જરૂર નથી
  • ટાઇપ કન્વર્ઝન: સુસંગત ટાઇપ્સ વચ્ચે કન્વર્ટ કરો
  • બિલ્ટ-ઇન ફંક્શન્સ: ચેકિંગ માટે type(), isinstance()

મેમરી ટ્રીક: “Python ટાઇપ્સ: નંબર્સ, સિક્વન્સીસ, કલેક્શન્સ”

પ્રશ્ન 3(અ) [3 ગુણ]
#

Python માં ફ્લો કંટ્રોલ શું છે? ઉદાહરણ સાથે સમજાવો

જવાબ:

ફ્લો કંટ્રોલ શરતી અને લૂપ સ્ટ્રક્ચર્સ વાપરીને પ્રોગ્રામ સ્ટેટમેન્ટ્સનો એક્ઝિક્યુશન ઓર્ડર મેનેજ કરે છે.

ફ્લો કંટ્રોલ પ્રકારોનું ટેબલ:

પ્રકારસ્ટેટમેન્ટહેતુઉદાહરણ
સિક્વેન્શિયલસામાન્ય એક્ઝિક્યુશનલાઇન બાય લાઇનprint("Hello")
સિલેક્શનif, elif, elseનિર્ણય લેવોif x > 0:
Iterationfor, whileપુનરાવર્તનfor i in range(5):
Jumpbreak, continueલૂપ કંટ્રોલbreak

ઉદાહરણ કોડ:

# સિલેક્શન ઉદાહરણ
age = 18
if age >= 18:
    print("પુખ્ત")
else:
    print("બાલક")

# Iteration ઉદાહરણ
for i in range(3):
    print(f"ગણતરી: {i}")

મુખ્ય કોન્સેપ્ટ્સ:

  • શરતી એક્ઝિક્યુશન: શરતોના આધારે કોડ ચાલે
  • લૂપ સ્ટ્રક્ચર્સ: કોડ બ્લોક્સ પુનરાવર્તન
  • પ્રોગ્રામ ફ્લો: એક્ઝિક્યુશન પાથ કંટ્રોલ

મેમરી ટ્રીક: “ફ્લો કંટ્રોલ: નિર્ણય, પુનરાવર્તન, Jump”

પ્રશ્ન 3(બ) [4 ગુણ]
#

નેસ્ટેડ if સ્ટેટમેન્ટ સમજાવવા માટે પ્રોગ્રામ લખો.

જવાબ:

નેસ્ટેડ If સ્ટેટમેન્ટ પ્રોગ્રામ:

# નેસ્ટેડ if વાપરીને ગ્રેડ કેલ્ક્યુલેશન
marks = int(input("માર્ક્સ દાખલ કરો: "))

if marks >= 0 and marks <= 100:
    if marks >= 90:
        grade = "A+"
    elif marks >= 80:
        if marks >= 85:
            grade = "A"
        else:
            grade = "B+"
    elif marks >= 70:
        grade = "B"
    elif marks >= 60:
        grade = "C"
    else:
        grade = "F"
    print(f"ગ્રેડ: {grade}")
else:
    print("અયોગ્ય માર્ક્સ")

નેસ્ટેડ સ્ટ્રક્ચર ડાયાગ્રામ:

marAk+s>=T9r0uem0a<r=kmsa.r.ik.nsp<u=t100FalsIenvalid

મુખ્ય લક્ષણો:

  • બહુવિધ સ્તરો: if સ્ટેટમેન્ટ્સ અંદર if સ્ટેટમેન્ટ્સ
  • જટિલ શરતો: બહુવિધ માપદંડો હેન્ડલ કરો
  • લોજિકલ સ્ટ્રક્ચર: નિર્ણય વૃક્ષો ગોઠવો

મેમરી ટ્રીક: “નેસ્ટેડ If: નિર્ણયોની અંદર નિર્ણયો”

પ્રશ્ન 3(ક) [7 ગુણ]
#

Arguments અને Parameters ના પ્રકારો સમજાવવા માટે એક પ્રોગ્રામ લખો.

જવાબ:

Arguments અને Parameters ના પ્રકારો:

# 1. પોઝિશનલ Arguments
def greet(name, age):
    print(f"હેલો {name}, તમારી ઉંમર {age} વર્ષ છે")

greet("જોન", 25)  # પોઝિશનલ arguments

# 2. કીવર્ડ Arguments  
greet(age=30, name="એલિસ")  # કીવર્ડ arguments

# 3. ડિફૉલ્ટ Parameters
def introduce(name, city="અજાણ"):
    print(f"{name} {city} માં રહે છે")

introduce("બોબ")  # ડિફૉલ્ટ વેલ્યુ વાપરે
introduce("કેરોલ", "મુંબઈ")  # ડિફૉલ્ટ ઓવરરાઇડ

# 4. વેરિયેબલ-લેન્થ Arguments (*args)
def sum_all(*numbers):
    return sum(numbers)

result = sum_all(1, 2, 3, 4, 5)
print(f"સરવાળો: {result}")

# 5. કીવર્ડ વેરિયેબલ Arguments (**kwargs)
def display_info(**info):
    for key, value in info.items():
        print(f"{key}: {value}")

display_info(name="ડેવિડ", age=28, city="બોસ્ટન")

Parameters પ્રકારોનું ટેબલ:

પ્રકારસિન્ટેક્સઉદાહરણવર્ણન
પોઝિશનલdef func(a, b):func(1, 2)ક્રમ મહત્વનો
કીવર્ડdef func(a, b):func(b=2, a=1)નામ સ્પેસિફાઇડ
ડિફૉલ્ટdef func(a, b=10):func(5)ડિફૉલ્ટ વેલ્યુ
*argsdef func(*args):func(1,2,3)વેરિયેબલ પોઝિશનલ
**kwargsdef func(**kwargs):func(a=1, b=2)વેરિયેબલ કીવર્ડ

મુખ્ય કોન્સેપ્ટ્સ:

  • લવચીકતા: ડેટા પાસ કરવાની વિવિધ રીતો
  • ક્રમ મહત્વ: પોઝિશનલ vs કીવર્ડ
  • વેરિયેબલ arguments: અજાણી સંખ્યાના ઇનપુટ્સ હેન્ડલ કરો

મેમરી ટ્રીક: “Parameters: પોઝિશન, કીવર્ડ્સ, ડિફૉલ્ટ્સ, વેરિયેબલ્સ”

પ્રશ્ન 3(અ OR) [3 ગુણ]
#

break અને continue statement ને ઉદાહરણ સાથે સમજાવો.

જવાબ:

Break અને Continue સ્ટેટમેન્ટ્સ:

Break સ્ટેટમેન્ટ:

# Break ઉદાહરણ - લૂપમાંથી બહાર નીકળો
for i in range(10):
    if i == 5:
        break
    print(i)
# આઉટપુટ: 0, 1, 2, 3, 4

Continue સ્ટેટમેન્ટ:

# Continue ઉદાહરણ - iteration છોડો
for i in range(5):
    if i == 2:
        continue
    print(i)
# આઉટપુટ: 0, 1, 3, 4

સરખામણી ટેબલ:

સ્ટેટમેન્ટહેતુક્રિયાઉદાહરણ ઉપયોગ
breakલૂપમાંથી બહાર નીકળોસંપૂર્ણ લૂપ સમાપ્ત કરેશરત પર બહાર નીકળો
continueiteration છોડોઆગલા iteration પર જાઓસ્પેસિફિક વેલ્યુઝ છોડો

મુખ્ય તફાવતો:

  • Break: લૂપમાંથી સંપૂર્ણે બહાર નીકળે
  • Continue: માત્ર વર્તમાન iteration છોડે
  • ફ્લો કંટ્રોલ: લૂપ એક્ઝિક્યુશન મેનેજ કરે

મેમરી ટ્રીક: “Break બહાર નીકળે, Continue છોડે”

પ્રશ્ન 3(બ OR) [4 ગુણ]
#

નીચેની પેટર્ન દર્શાવવા માટે એક પ્રોગ્રામ બનાવો

1
12
123
1234
12345

જવાબ:

નંબર પેટર્ન પ્રોગ્રામ:

# પદ્ધતિ 1: નેસ્ટેડ લૂપ્સ વાપરીને
rows = 5
for i in range(1, rows + 1):
    for j in range(1, i + 1):
        print(j, end="")
    print()  # નવી લાઇન

# પદ્ધતિ 2: સ્ટ્રિંગ મેનિપ્યુલેશન વાપરીને
for i in range(1, 6):
    line = ""
    for j in range(1, i + 1):
        line += str(j)
    print(line)

# પદ્ધતિ 3: join વાપરીને
for i in range(1, 6):
    numbers = [str(j) for j in range(1, i + 1)]
    print("".join(numbers))

પેટર્ન લોજિક ટેબલ:

પંક્તિનંબર્સરેન્જઆઉટપુટ
111 થી 11
21,21 થી 212
31,2,31 થી 3123
41,2,3,41 થી 41234
51,2,3,4,51 થી 512345

મુખ્ય કોન્સેપ્ટ્સ:

  • નેસ્ટેડ લૂપ્સ: બાહ્ય પંક્તિઓ માટે, અંદરૂની નંબર્સ માટે
  • રેન્જ ફંક્શન: નંબર સિક્વન્સ જનરેટ કરે
  • પ્રિન્ટ કંટ્રોલ: નવી લાઇનો ટાળવા માટે end="" વાપરો

મેમરી ટ્રીક: “પેટર્ન: પંક્તિ નંબર કોલમ કાઉન્ટ નક્કી કરે”

પ્રશ્ન 3(ક OR) [7 ગુણ]
#

દરેક માટે કોડ લખીને નીચેના ગાણિતિક કાર્યો સમજાવો: 1. abs() 2. max() 3. pow() 4. sum()

જવાબ:

Python માં ગાણિતિક ફંક્શન્સ:

# 1. abs() - એબ્સોલ્યુટ વેલ્યુ
numbers = [-5, 3.7, -10.2, 0]
print("abs() ફંક્શન ઉદાહરણો:")
for num in numbers:
    print(f"abs({num}) = {abs(num)}")

# 2. max() - મહત્તમ વેલ્યુ
list1 = [4, 7, 2, 9, 1]
print(f"\nmax() ફંક્શન ઉદાહરણો:")
print(f"max({list1}) = {max(list1)}")
print(f"max(10, 25, 5) = {max(10, 25, 5)}")
print(f"max('hello') = {max('hello')}")  # વર્ણમાળા પ્રમાણે

# 3. pow() - પાવર ફંક્શન
print(f"\npow() ફંક્શન ઉદાહરણો:")
print(f"pow(2, 3) = {pow(2, 3)}")      # 2^3 = 8
print(f"pow(5, 2) = {pow(5, 2)}")      # 5^2 = 25
print(f"pow(8, 1/3) = {pow(8, 1/3)}")  # 8 નો ઘન મૂળ

# 4. sum() - સરવાળો ફંક્શન
numbers = [1, 2, 3, 4, 5]
print(f"\nsum() ફંક્શન ઉદાહરણો:")
print(f"sum({numbers}) = {sum(numbers)}")
print(f"sum({numbers}, 10) = {sum(numbers, 10)}")  # શરૂઆતી વેલ્યુ સાથે

ફંક્શન્સ સારાંશ ટેબલ:

ફંક્શનસિન્ટેક્સહેતુઉદાહરણપરિણામ
abs()abs(x)એબ્સોલ્યુટ વેલ્યુabs(-5)5
max()max(iterable)મહત્તમ વેલ્યુmax([1,5,3])5
pow()pow(x, y)x ને y ની પાવરpow(2, 3)8
sum()sum(iterable)વેલ્યુઝનો સરવાળોsum([1,2,3])6

મુખ્ય ઉપયોગો:

  • abs(): અંતર ગણતરી, એરર હેન્ડલિંગ
  • max(): મહત્તમ શોધવું, સ્પર્ધાના પરિણામો
  • pow(): વૈજ્ઞાનિક ગણતરી, ચક્રવૃદ્ધિ વ્યાજ
  • sum(): કુલ ગણતરી, આંકડાશાસ્ત્ર

મેમરી ટ્રીક: “Math ફંક્શન્સ: એબ્સોલ્યુટ, મહત્તમ, પાવર, સરવાળો”

પ્રશ્ન 4(અ) [3 ગુણ]
#

Variables નો scope સમજાવો.

જવાબ:

વેરિયેબલ સ્કોપ એ પ્રોગ્રામમાં તે પ્રદેશનો સંદર્ભ આપે છે જ્યાં વેરિયેબલ એક્સેસ કરી શકાય.

સ્કોપ પ્રકારોનું ટેબલ:

સ્કોપવર્ણનજીવનકાળએક્સેસ
લોકલફંક્શનની અંદરફંક્શન એક્ઝિક્યુશનમાત્ર ફંક્શન
ગ્લોબલફંક્શનોની બહારપ્રોગ્રામ એક્ઝિક્યુશનઆખો પ્રોગ્રામ
બિલ્ટ-ઇનPython કીવર્ડ્સPython સેશનબધે

ઉદાહરણ કોડ:

x = 10  # ગ્લોબલ વેરિયેબલ

def my_function():
    y = 20  # લોકલ વેરિયેબલ
    print(f"લોકલ y: {y}")
    print(f"ગ્લોબલ x: {x}")

my_function()
print(f"ગ્લોબલ x: {x}")
# print(y)  # એરર: y અહીં એક્સેસિબલ નથી

મુખ્ય નિયમો:

  • લોકલ વેરિયેબલ્સ: ફંક્શનોની અંદર બનાવાય
  • ગ્લોબલ વેરિયેબલ્સ: સમગ્ર પ્રોગ્રામમાં એક્સેસિબલ
  • LEGB નિયમ: Local → Enclosing → Global → Built-in

મેમરી ટ્રીક: “સ્કોપ: લોકલ ફંક્શનમાં રહે, ગ્લોબલ બધે રહે”

પ્રશ્ન 4(બ) [4 ગુણ]
#

નેસ્ટેડ LOOP અને નંબર્સ ડિસ્પ્લે કરવા માટે પ્રોગ્રામ ડેવલપ કરો.

જવાબ:

નેસ્ટેડ લૂપ પ્રોગ્રામ:

# ઉદાહરણ 1: નંબર ગ્રિડ
print("નંબર ગ્રિડ પેટર્ન:")
for i in range(1, 4):
    for j in range(1, 5):
        print(f"{i}{j}", end=" ")
    print()  # દરેક પંક્તિ પછી નવી લાઇન

# ઉદાહરણ 2: ગુણાકાર ટેબલ
print("\nગુણાકાર ટેબલ:")
for i in range(1, 4):
    for j in range(1, 6):
        result = i * j
        print(f"{result:3}", end=" ")
    print()

# ઉદાહરણ 3: નંબર પિરામિડ
print("\nનંબર પિરામિડ:")
for i in range(1, 5):
    for j in range(1, i + 1):
        print(j, end=" ")
    print()

નેસ્ટેડ લૂપ સ્ટ્રક્ચર:

j=i1i,=2=,132,4(i)(j)

મુખ્ય કોન્સેપ્ટ્સ:

  • બાહ્ય લૂપ: પંક્તિઓ/મુખ્ય iterations કંટ્રોલ કરે
  • અંદરૂની લૂપ: કોલમ્સ/નાના iterations કંટ્રોલ કરે
  • એક્ઝિક્યુશન ફ્લો: અંદરૂનું પૂર્ણ થાય પછી બાહ્ય વધે

મેમરી ટ્રીક: “નેસ્ટેડ લૂપ્સ: બાહ્ય અંદરૂનીને કંટ્રોલ કરે”

પ્રશ્ન 4(ક) [7 ગુણ]
#

1 થી 50 ની રેન્જમાં ODD અને EVEN નંબરોની LIST બનાવવા માટે પ્રોગ્રામ લખો.

જવાબ:

ODD અને EVEN નંબર્સ પ્રોગ્રામ:

# પદ્ધતિ 1: લૂપ્સ અને શરતો વાપરીને
odd_numbers = []
even_numbers = []

for i in range(1, 51):
    if i % 2 == 0:
        even_numbers.append(i)
    else:
        odd_numbers.append(i)

print("વિષમ નંબર્સ (1-50):")
print(odd_numbers)
print(f"ગણતરી: {len(odd_numbers)}")

print("\nસમ નંબર્સ (1-50):")
print(even_numbers)
print(f"ગણતરી: {len(even_numbers)}")

# પદ્ધતિ 2: લિસ્ટ કમ્પ્રીહેન્શન વાપરીને
odd_list = [i for i in range(1, 51) if i % 2 != 0]
even_list = [i for i in range(1, 51) if i % 2 == 0]

print(f"\nવિષમ (લિસ્ટ કમ્પ્રીહેન્શન): {odd_list[:10]}...")  # પ્રથમ 10
print(f"સમ (લિસ્ટ કમ્પ્રીહેન્શન): {even_list[:10]}...")  # પ્રથમ 10

# પદ્ધતિ 3: સ્ટેપ સાથે રેન્જ વાપરીને
odd_range = list(range(1, 51, 2))   # શરૂ 1, સ્ટેપ 2
even_range = list(range(2, 51, 2))  # શરૂ 2, સ્ટેપ 2

print(f"\nવિષમ (રેન્જ પદ્ધતિ): {odd_range[:10]}...")
print(f"સમ (રેન્જ પદ્ધતિ): {even_range[:10]}...")

નંબર વર્ગીકરણ ટેબલ:

પ્રકારશરતરેન્જ 1-10કાઉન્ટ (1-50)
વિષમn % 2 != 01,3,5,7,925
સમn % 2 == 02,4,6,8,1025

મુખ્ય તકનીકો:

  • મોડ્યુલો ઓપરેટર: બાકીની ચેક માટે %
  • લિસ્ટ કમ્પ્રીહેન્શન: સંક્ષિપ્ત લિસ્ટ સર્જન
  • રેન્જ ફંક્શન: સિક્વન્સ અસરકારક રીતે જનરેટ કરે

મેમરી ટ્રીક: “વિષમ/સમ: 2 થી ભાગ્યે બાકી 1/0”

પ્રશ્ન 4(અ OR) [3 ગુણ]
#

સ્ટ્રિંગ સ્લાઇસિંગને ઉદાહરણ સાથે સમજાવો.

જવાબ:

સ્ટ્રિંગ સ્લાઇસિંગ [start:stop:step] સિન્ટેક્સ વાપરીને સ્ટ્રિંગના ભાગો એક્સ્ટ્રેક્ટ કરે છે.

સ્લાઇસિંગ સિન્ટેક્સ ટેબલ:

સિન્ટેક્સવર્ણનઉદાહરણપરિણામ
s[start:stop]start થી stop-1 સુધી"hello"[1:4]“ell”
s[start:]start થી અંત સુધી"hello"[2:]“llo”
s[:stop]શરૂઆતથી stop-1 સુધી"hello"[:3]“hel”
s[::step]દરેક step કેરેક્ટર"hello"[::2]“hlo”
s[::-1]સ્ટ્રિંગ રિવર્સ"hello"[::-1]“olleh”

ઉદાહરણ કોડ:

text = "Python Programming"

# મૂળભૂત સ્લાઇસિંગ
print(f"પ્રથમ 6 અક્ષરો: {text[:6]}")      # "Python"
print(f"છેલ્લા 11 અક્ષરો: {text[7:]}")      # "Programming"
print(f"મધ્ય ભાગ: {text[2:8]}")       # "thon P"

# સ્ટેપ સ્લાઇસિંગ
print(f"દર 2જો અક્ષર: {text[::2]}")    # "Pto rgamn"

# નેગેટિવ ઇન્ડેક્સિંગ
print(f"છેલ્લો અક્ષર: {text[-1]}")     # "g"
print(f"રિવર્સ: {text[::-1]}")          # "gnimmargorP nohtyP"

મુખ્ય લક્ષણો:

  • ઝીરો-બેસ્ડ ઇન્ડેક્સિંગ: 0 થી શરૂ
  • નેગેટિવ ઇન્ડેક્સિંગ: અંતથી ગણતરી (-1)
  • અપરિવર્તનીય: મૂળ સ્ટ્રિંગ અપરિવર્તિત

મેમરી ટ્રીક: “સ્લાઇસ: શરૂ, બંધ, સ્ટેપ”

પ્રશ્ન 4(બ OR) [4 ગુણ]
#

આપેલ સંખ્યાના ફેક્ટોરિયલ શોધવા માટે user defined function નો ઉપયોગ કરીને પ્રોગ્રામ લખો.

જવાબ:

ફેક્ટોરિયલ ફંક્શન પ્રોગ્રામ:

def factorial(n):
    """રિકર્શન વાપરીને ફેક્ટોરિયલ કેલ્ક્યુલેટ કરે"""
    if n == 0 or n == 1:
        return 1
    else:
        return n * factorial(n - 1)

def factorial_iterative(n):
    """લૂપ વાપરીને ફેક્ટોરિયલ કેલ્ક્યુલેટ કરે"""
    result = 1
    for i in range(1, n + 1):
        result *= i
    return result

# મુખ્ય પ્રોગ્રામ
number = int(input("સંખ્યા દાખલ કરો: "))
if number < 0:
    print("નેગેટિવ સંખ્યાઓ માટે ફેક્ટોરિયલ વ્યાખ્યાયિત નથી")
else:
    result1 = factorial(number)
    result2 = factorial_iterative(number)
    print(f"{number} નું ફેક્ટોરિયલ = {result1}")

ફેક્ટોરિયલ ટેબલ:

nફેક્ટોરિયલગણતરી
01બેઝ કેસ
11બેઝ કેસ
363 × 2 × 1
51205 × 4 × 3 × 2 × 1

મુખ્ય કોન્સેપ્ટ્સ:

  • રિકર્શન: ફંક્શન પોતાને કોલ કરે
  • બેઝ કેસ: રિકર્સિવ કોલ્સ બંધ કરે
  • યુઝર-ડિફાઇન્ડ: કસ્ટમ ફંક્શન સર્જન

મેમરી ટ્રીક: “ફેક્ટોરિયલ: નીચેના બધા નંબર્સ ગુણા કરો”

પ્રશ્ન 4(ક OR) [7 ગુણ]
#

આપેલ સ્ટ્રિંગમાં સબ સ્ટ્રિંગ હાજર છે કે કેમ તે તપાસવા માટે user defined function લખો.

જવાબ:

સબસ્ટ્રિંગ ચેક ફંક્શન:

def find_substring(main_string, sub_string):
    """મુખ્ય સ્ટ્રિંગમાં સબસ્ટ્રિંગ અસ્તિત્વ ચેક કરે"""
    if sub_string in main_string:
        index = main_string.find(sub_string)
        return True, index
    else:
        return False, -1

def count_substring(main_string, sub_string):
    """સબસ્ટ્રિંગની ઘટનાઓ ગણે"""
    return main_string.count(sub_string)

def find_all_positions(main_string, sub_string):
    """સબસ્ટ્રિંગની બધી પોઝિશન્સ શોધે"""
    positions = []
    start = 0
    while True:
        pos = main_string.find(sub_string, start)
        if pos == -1:
            break
        positions.append(pos)
        start = pos + 1
    return positions

# મુખ્ય પ્રોગ્રામ
text = input("મુખ્ય સ્ટ્રિંગ દાખલ કરો: ")
search = input("શોધવા માટે સબસ્ટ્રિંગ દાખલ કરો: ")

found, position = find_substring(text, search)
if found:
    print(f"સબસ્ટ્રિંગ '{search}' પોઝિશન {position} પર મળ્યું")
    count = count_substring(text, search)
    all_pos = find_all_positions(text, search)
    print(f"કુલ ઘટનાઓ: {count}")
    print(f"બધી પોઝિશન્સ: {all_pos}")
else:
    print(f"સબસ્ટ્રિંગ '{search}' મળ્યું નથી")

સ્ટ્રિંગ મેથડ્સ ટેબલ:

મેથડહેતુઉદાહરણપરિણામ
find()પ્રથમ પોઝિશન શોધે"hello".find("ll")2
count()ઘટનાઓ ગણે"hello".count("l")2
inઅસ્તિત્વ ચેક કરે"ll" in "hello"True
index()પોઝિશન શોધે (ન મળે તો એરર)"hello".index("e")1

મુખ્ય લક્ષણો:

  • બહુવિધ પદ્ધતિઓ: શોધવાની વિવિધ રીતો
  • પોઝિશન ટ્રેકિંગ: મળેલ સબસ્ટ્રિંગનો ઇન્ડેક્સ પરત કરે
  • એરર હેન્ડલિંગ: પ્રોસેસિંગ પહેલાં ચેક કરે

મેમરી ટ્રીક: “સબસ્ટ્રિંગ: શોધ, મેળવ, ગણ, પોઝિશન”

પ્રશ્ન 5(અ) [3 ગુણ]
#

ઉદાહરણ સાથે List કેવી રીતે બનાવવી અને એક્સેસ કરવી તે સમજાવો.

જવાબ:

લિસ્ટ સર્જન અને એક્સેસ:

# લિસ્ટ બનાવવી
empty_list = []
numbers = [1, 2, 3, 4, 5]
mixed = [1, "hello", 3.14, True]
nested = [[1, 2], [3, 4], [5, 6]]

# તત્વો એક્સેસ કરવા
print(f"પ્રથમ તત્વ: {numbers[0]}")      # 1
print(f"છેલ્લું તત્વ: {numbers[-1]}")      # 5
print(f"સ્લાઇસ: {numbers[1:4]}")           # [2, 3, 4]

લિસ્ટ એક્સેસ પદ્ધતિઓ:

પદ્ધતિસિન્ટેક્સઉદાહરણપરિણામ
ઇન્ડેક્સlist[i][1,2,3][1]2
નેગેટિવlist[-i][1,2,3][-1]3
સ્લાઇસlist[start:stop][1,2,3,4][1:3][2,3]

મુખ્ય લક્ષણો:

  • ક્રમાંકિત સંગ્રહ: તત્વોની પોઝિશન્સ છે
  • પરિવર્તનશીલ: સર્જન પછી સુધારી શકાય
  • મિશ્ર પ્રકાર: વિવિધ ડેટા ટાઇપ્સની મંજૂરી

મેમરી ટ્રીક: “લિસ્ટ્સ: બનાવો, ઇન્ડેક્સ, એક્સેસ”

પ્રશ્ન 5(બ) [4 ગુણ]
#

LIST પર કરી શકાય તેવી કામગીરીની યાદી બનાવો. એક લિસ્ટને બીજી લિસ્ટમાં બનાવવા અને કૉપી કરવા માટે પ્રોગ્રામ લખો.

જવાબ:

લિસ્ટ ઓપરેશન્સ અને કૉપી પ્રોગ્રામ:

# મૂળ લિસ્ટ
original = [1, 2, 3, 4, 5]
print(f"મૂળ લિસ્ટ: {original}")

# કૉપી કરવાની પદ્ધતિઓ
shallow_copy = original.copy()
slice_copy = original[:]
list_copy = list(original)

# મૂળ લિસ્ટ સુધારો
original.append(6)
print(f"append પછી: {original}")
print(f"શેલો કૉપી: {shallow_copy}")

# લિસ્ટ ઓપરેશન્સ પ્રદર્શન
numbers = [10, 20, 30]
numbers.append(40)          # અંતે ઉમેરો
numbers.insert(1, 15)       # પોઝિશન પર ઇન્સર્ટ કરો
numbers.remove(20)          # સ્પેસિફિક વેલ્યુ દૂર કરો
popped = numbers.pop()      # છેલ્લું દૂર કરી પરત કરો

લિસ્ટ ઓપરેશન્સ ટેબલ:

ઓપરેશનમેથડઉદાહરણપરિણામ
ઉમેરોappend()[1,2].append(3)[1,2,3]
ઇન્સર્ટinsert()[1,3].insert(1,2)[1,2,3]
દૂર કરોremove()[1,2,3].remove(2)[1,3]
પોપpop()[1,2,3].pop()[1,2]

મુખ્ય કોન્સેપ્ટ્સ:

  • શેલો કૉપી: સમાન તત્વો સાથે સ્વતંત્ર લિસ્ટ
  • ડીપ કૉપી: નેસ્ટેડ સ્ટ્રક્ચર માટે જરૂરી
  • બહુવિધ પદ્ધતિઓ: કૉપી કરવાની વિવિધ તકનીકો

મેમરી ટ્રીક: “લિસ્ટ ઓપરેશન્સ: ઉમેરો, ઇન્સર્ટ, દૂર કરો, પોપ, કૉપી”

પ્રશ્ન 5(ક) [7 ગુણ]
#

LIST ની વિવિધ બિલ્ટ-ઇન methods ની સૂચિ બનાવો અને ઉપયોગ દર્શાવો

જવાબ:

બિલ્ટ-ઇન લિસ્ટ મેથડ્સ:

# નમૂના લિસ્ટ પ્રદર્શન માટે
fruits = ['apple', 'banana', 'cherry', 'apple']
numbers = [3, 1, 4, 1, 5, 9, 2]

# સુધારણા મેથડ્સ
fruits.append('date')              # અંતે ઉમેરો
fruits.insert(1, 'avocado')       # ઇન્ડેક્સ પર ઇન્સર્ટ કરો
fruits.remove('apple')            # પ્રથમ occurrence દૂર કરો
last_fruit = fruits.pop()         # છેલ્લું દૂર કરી પરત કરો
fruits.clear()                    # બધા તત્વો દૂર કરો

# શોધ અને ગણતરી મેથડ્સ
fruits = ['apple', 'banana', 'apple', 'cherry']
count = fruits.count('apple')     # occurrences ગણો
index = fruits.index('banana')    # પ્રથમ ઇન્ડેક્સ શોધો

# સોર્ટિંગ અને રિવર્સિંગ
numbers.sort()                    # in place સોર્ટ કરો
numbers.reverse()                 # in place રિવર્સ કરો
sorted_copy = sorted(fruits)      # સોર્ટેડ કૉપી પરત કરો

# એક્સ્ટેન્શન
more_fruits = ['grape', 'orange']
fruits.extend(more_fruits)        # બહુવિધ આઇટમ્સ ઉમેરો

લિસ્ટ મેથડ્સ સારાંશ:

કેટેગરીમેથડહેતુપરત કરેમૂળ સુધારે
ઉમેરોappend(x)અંતે આઇટમ ઉમેરોNoneહા
ઉમેરોinsert(i,x)પોઝિશન પર ઇન્સર્ટ કરોNoneહા
ઉમેરોextend(list)બહુવિધ આઇટમ્સ ઉમેરોNoneહા
દૂર કરોremove(x)પ્રથમ x દૂર કરોNoneહા
દૂર કરોpop(i)ઇન્ડેક્સ પર દૂર કરોદૂર કરેલ આઇટમહા
દૂર કરોclear()બધું દૂર કરોNoneહા
શોધindex(x)પોઝિશન શોધોઇન્ડેક્સના
શોધcount(x)occurrences ગણોકાઉન્ટના
સોર્ટsort()in place સોર્ટ કરોNoneહા
સોર્ટreverse()ક્રમ ઉલટાવોNoneહા
કૉપીcopy()શેલો કૉપીનવી લિસ્ટના

વ્યવહારિક ઉદાહરણો:

# શોપિંગ કાર્ટ ઉદાહરણ
cart = []
cart.append('દૂધ')
cart.extend(['બ્રેડ', 'ઈંડા', 'માખણ'])
print(f"કાર્ટમાં વસ્તુઓ: {len(cart)}")

if 'દૂધ' in cart:
    cart.remove('દૂધ')
    print("દૂધ કાર્ટમાંથી દૂર કર્યું")

cart.sort()
print(f"સોર્ટેડ કાર્ટ: {cart}")

મુખ્ય ઉપયોગો:

  • ડેટા મેનેજમેન્ટ: આઇટમ્સ ઉમેરો, દૂર કરો, ગોઠવો
  • શોધ ઓપરેશન્સ: તત્વો શોધો અને ગણો
  • સોર્ટિંગ: ડેટાને ક્રમમાં ગોઠવો

મેમરી ટ્રીક: “લિસ્ટ મેથડ્સ: ઉમેરો, દૂર કરો, શોધો, સોર્ટ, કૉપી”

પ્રશ્ન 5(અ OR) [3 ગુણ]
#

ઉદાહરણ આપીને string ને કેવી રીતે create અને traverse કરવી તે સમજાવો.

જવાબ:

સ્ટ્રિંગ સર્જન અને ટ્રાવર્સલ:

# સ્ટ્રિંગ સર્જન પદ્ધતિઓ
string1 = "Hello World"        # ડબલ કોટ્સ
string2 = 'Python Programming' # સિંગલ કોટ્સ
string3 = """મલ્ટિ-લાઇન
સ્ટ્રિંગ ઉદાહરણ"""              # ટ્રિપલ કોટ્સ

# સ્ટ્રિંગ ટ્રાવર્સલ પદ્ધતિઓ
text = "Python"

# પદ્ધતિ 1: for લૂપ વાપરીને
for char in text:
    print(char, end=" ")
print()

# પદ્ધતિ 2: ઇન્ડેક્સ વાપરીને
for i in range(len(text)):
    print(f"{text[i]} ઇન્ડેક્સ {i} પર")

# પદ્ધતિ 3: enumerate વાપરીને
for index, char in enumerate(text):
    print(f"ઇન્ડેક્સ {index}: {char}")

ટ્રાવર્સલ પદ્ધતિઓનું ટેબલ:

પદ્ધતિસિન્ટેક્સઉપયોગ કેસ
ડાયરેક્ટfor char in string:સાદી કેરેક્ટર એક્સેસ
ઇન્ડેક્સfor i in range(len(s)):પોઝિશન માહિતી જોઈએ
Enumeratefor i, char in enumerate(s):ઇન્ડેક્સ અને કેરેક્ટર બંને

મુખ્ય કોન્સેપ્ટ્સ:

  • અપરિવર્તનીય: સ્ટ્રિંગ્સ બદલી શકાતી નથી
  • Iterable: કેરેક્ટર્સમાં લૂપ કરી શકાય
  • ઇન્ડેક્સિંગ: વ્યક્તિગત કેરેક્ટર્સ એક્સેસ કરી શકાય

મેમરી ટ્રીક: “સ્ટ્રિંગ્સ: બનાવો, લૂપ, એક્સેસ”

પ્રશ્ન 5(બ OR) [4 ગુણ]
#

સ્ટ્રિંગ પર કરી શકાય તેવી કામગીરીની યાદી બનાવો. કોઈપણ 2 કામગીરી માટે કોડ લખો

જવાબ:

સ્ટ્રિંગ ઓપરેશન્સ:

# સ્ટ્રિંગ ઓપરેશન્સ ઉદાહરણો
text = "Python Programming"

# ઓપરેશન 1: સ્ટ્રિંગ કન્કેટેનેશન અને ફોર્મેટિંગ
first_name = "જોન"
last_name = "ડો"
full_name = first_name + " " + last_name
formatted = f"નમસ્તે, {full_name}!"
print(f"કન્કેટેનેશન: {full_name}")
print(f"ફોર્મેટિંગ: {formatted}")

# ઓપરેશન 2: સ્ટ્રિંગ કેસ કન્વર્ઝન અને સ્પ્લિટિંગ
sentence = "python programming સરળતાથી શીખો"
title_case = sentence.title()
upper_case = sentence.upper()
words = sentence.split()
print(f"ટાઇટલ કેસ: {title_case}")
print(f"અપર કેસ: {upper_case}")
print(f"સ્પ્લિટ શબ્દો: {words}")

સ્ટ્રિંગ ઓપરેશન્સ ટેબલ:

કેટેગરીઓપરેશનઉદાહરણપરિણામ
જોડાણકન્કેટેનેશન"Hello" + " World"“Hello World”
કેસupper()"hello".upper()“HELLO”
કેસlower()"HELLO".lower()“hello”
કેસtitle()"hello world".title()“Hello World”
સ્પ્લિટsplit()"a,b,c".split(",")[‘a’,‘b’,‘c’]
રિપ્લેસreplace()"hello".replace("l","x")“hexxo”
સ્ટ્રિપstrip()" hello ".strip()“hello”
શોધfind()"hello".find("e")1

મુખ્ય લક્ષણો:

  • અપરિવર્તનીય: ઓપરેશન્સ નવી સ્ટ્રિંગ્સ પરત કરે
  • મેથડ ચેઇનિંગ: બહુવિધ ઓપરેશન્સ કંબાઇન કરો
  • લવચીક: ઘણા બિલ્ટ-ઇન ઓપરેશન્સ ઉપલબ્ધ

મેમરી ટ્રીક: “સ્ટ્રિંગ ઓપરેશન્સ: જોડો, કેસ, સ્પ્લિટ, શોધો”

પ્રશ્ન 5(ક OR) [7 ગુણ]
#

સ્ટ્રિંગની વિવિધ બિલ્ટ-ઇન methods ની સૂચિ બનાવો અને ઉપયોગ દર્શાવો.

જવાબ:

બિલ્ટ-ઇન સ્ટ્રિંગ મેથડ્સ:

# પ્રદર્શન માટે નમૂના સ્ટ્રિંગ
text = "  Python Programming Language  "
sample = "Hello World Programming"

# કેસ કન્વર્ઝન મેથડ્સ
print(f"મૂળ: '{text}'")
print(f"upper(): {text.upper()}")
print(f"lower(): {text.lower()}")
print(f"title(): {text.title()}")
print(f"capitalize(): {text.capitalize()}")
print(f"swapcase(): {'Hello'.swapcase()}")

# વ્હાઇટસ્પેસ મેથડ્સ
print(f"strip(): '{text.strip()}'")
print(f"lstrip(): '{text.lstrip()}'")
print(f"rstrip(): '{text.rstrip()}'")

# શોધ અને ચેક મેથડ્સ
print(f"find('Python'): {text.find('Python')}")
print(f"count('o'): {sample.count('o')}")
print(f"startswith('  Py'): {text.startswith('  Py')}")
print(f"endswith('ge  '): {text.endswith('ge  ')}")

# કેરેક્ટર ટાઇપ ચેકિંગ
test_string = "Python123"
print(f"isalpha(): {'Python'.isalpha()}")
print(f"isdigit(): {'123'.isdigit()}")
print(f"isalnum(): {test_string.isalnum()}")

# સ્પ્લિટ અને જોઇન મેથડ્સ
words = sample.split()
joined = "-".join(words)
print(f"split(): {words}")
print(f"join(): {joined}")

# રિપ્લેસ મેથડ
replaced = sample.replace("World", "Universe")
print(f"replace(): {replaced}")

સ્ટ્રિંગ મેથડ્સ વર્ગીકરણ:

કેટેગરીમેથડ્સહેતુઉદાહરણ
કેસupper(), lower(), title(), capitalize()કેસ બદલો"hello".upper() → “HELLO”
વ્હાઇટસ્પેસstrip(), lstrip(), rstrip()સ્પેસીસ દૂર કરો" hi ".strip() → “hi”
શોધfind(), index(), count()સબસ્ટ્રિંગ્સ શોધો"hello".find("e") → 1
ચેકstartswith(), endswith()સ્ટ્રિંગ અંત ટેસ્ટ કરો"hello".startswith("h") → True
ટાઇપ ચેકisalpha(), isdigit(), isalnum()કેરેક્ટર પ્રકાર"123".isdigit() → True
સ્પ્લિટ/જોઇનsplit(), join()તોડો/જોડો"a-b".split("-") → [‘a’,‘b’]
રિપ્લેસreplace()ટેક્સ્ટ બદલો"hi".replace("i","o") → “ho”

વાસ્તવિક જીવનના ઉદાહરણો:

# ઈમેઇલ વેલિડેશન ઉદાહરણ
email = "  USER@EXAMPLE.COM  "
clean_email = email.strip().lower()
is_valid = "@" in clean_email and "." in clean_email
print(f"સાફ ઈમેઇલ: {clean_email}")
print(f"યોગ્ય ફોર્મેટ: {is_valid}")

# ટેક્સ્ટ પ્રોસેસિંગ ઉદાહરણ
user_input = "python programming"
formatted_title = user_input.title()
word_count = len(user_input.split())
print(f"ફોર્મેટેડ: {formatted_title}")
print(f"શબ્દ ગણતરી: {word_count}")

મુખ્ય ઉપયોગો:

  • ડેટા ક્લીનિંગ: અનઇચ્છિત સ્પેસીસ દૂર કરો, કેસ ઠીક કરો
  • ટેક્સ્ટ પ્રોસેસિંગ: સર્ચ, રિપ્લેસ, સ્પ્લિટ કન્ટેન્ટ
  • વેલિડેશન: સ્ટ્રિંગ ફોર્મેટ અને કન્ટેન્ટ ચેક કરો
  • ફોર્મેટિંગ: ડિસ્પ્લે માટે ટેક્સ્ટ તૈયાર કરો

મેમરી ટ્રીક: “સ્ટ્રિંગ મેથડ્સ: કેસ, સાફ, ચેક, બદલો”