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

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

·
Study-Material Solutions Python 4311601 2023 Winter 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 TD
    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 TD
    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.k.s<=100False

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

  • બહુવિધ સ્તરો: 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}")

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

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

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

સંબંધિત

Object Oriented Programming with Java (4341602) - Winter 2023 Solution (Gujarati)
Study-Material Solutions Java Oop 4341602 2023 Winter Gujarati
આઈટી સિસ્ટમ્સનો પરિચય (4311602) - શિયાળો 2023 ઉકેલ
Study-Material Solutions It-Systems 4311602 2023 Winter Gujarati
માઇક્રોપ્રોસેસર અને માઇક્રોકંટ્રોલર સિસ્ટમ્સ (1333202) - શિયાળો 2023 સોલ્યુશન
23 મિનિટ
Study-Material Solutions Microprocessor Microcontroller 1333202 2023 Winter Gujarati
# OOPS & Python Programming (4351108) - Winter 2023 Solution (ગુજરાતી)
Study-Material Solutions Python Oop 4351108 2023 Winter
Embedded System & Microcontroller Application (4351102) - Winter 2023 Solution (Gujarati)
Study-Material Solutions Embedded-System 4351102 2023 Winter Gujarati
માઇક્રોપ્રોસેસર અને માઇક્રોકન્ટ્રોલર (4341101) - વિન્ટર 2023 સોલ્યુશન
20 મિનિટ
Study-Material Solutions Microprocessor 4341101 2023 Winter Gujarati