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

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

November 25, 2024

study-material solutions python oops 4351108 2024 winter gujarati

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

પાયથોન પ્રોગ્રામિંગ ભાષાના લક્ષણોની યાદી બનાવો.

જવાબ:

લક્ષણ	વર્ણન
સરળ અને સહેલું	સ્વચ્છ, વાંચી શકાય તેવું syntax
મફત અને ઓપન સોર્સ	કોઈ કિંમત નહીં, community driven
ક્રોસ-પ્લેટફોર્મ	Windows, Linux, Mac પર ચાલે છે
Interpreted	compilation ની જરૂર નથી
Object-Oriented	classes અને objects ને support કરે છે
મોટી લાઇબ્રેરીઓ	સમૃદ્ધ standard library

યાદી રાખવાની ટ્રિક: "સરળ મફત ક્રોસ Interpreted ઓબ્જેક્ટ મોટી"

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

પાયથોન પ્રોગ્રામિંગ ભાષાની એપ્લિકેશનો લખો.

જવાબ:

એપ્લિકેશન ક્ષેત્ર	ઉદાહરણો
વેબ ડેવલપમેન્ટ	Django, Flask frameworks
ડેટા સાયન્સ	NumPy, Pandas, Matplotlib
મશીન લર્નિંગ	TensorFlow, Scikit-learn
ડેસ્કટોપ GUI	Tkinter, PyQt applications
ગેમ ડેવલપમેન્ટ	Pygame library
ઓટોમેશન	Scripting અને testing

યાદી રાખવાની ટ્રિક: "વેબ ડેટા મશીન ડેસ્કટોપ ગેમ ઓટો"

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

પાયથોનમાં વિવિધ ડેટાટાઇપ્સ સમજાવો.

જવાબ:

ડેટા ટાઇપ	ઉદાહરણ	વર્ણન
int	`x = 5`	પૂર્ણાંક સંખ્યાઓ
float	`y = 3.14`	દશાંશ સંખ્યાઓ
str	`name = "John"`	ટેક્સ્ટ ડેટા
bool	`flag = True`	True/False મૂલ્યો
list	`[1, 2, 3]`	ક્રમબદ્ધ, બદલી શકાય તેવું
tuple	`(1, 2, 3)`	ક્રમબદ્ધ, બદલી ન શકાય તેવું
dict	`{"a": 1}`	Key-value જોડી
set	`{1, 2, 3}`	અનન્ય ઘટકો

કોડ ઉદાહરણ:

Python

યાદી રાખવાની ટ્રિક: "Integer Float String Boolean List Tuple Dict Set"

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

એરિથમેટિક, એસાઇનમેન્ટ અને આઇડેન્ટિટી ઓપરેટરો ઉદાહરણ સાથે સમજાવો.

જવાબ:

એરિથમેટિક ઓપરેટરો:

ઓપરેટર	ઓપરેશન	ઉદાહરણ
`+`	બાકીદારી	`5 + 3 = 8`
`-`	બાદબાકી	`5 - 3 = 2`
`*`	ગુણાકાર	`5 * 3 = 15`
`/`	ભાગાકાર	`10 / 3 = 3.33`
`//`	Floor Division	`10 // 3 = 3`
`%`	બાકી	`10 % 3 = 1`
`**`	ઘાત	`2 ** 3 = 8`

એસાઇનમેન્ટ ઓપરેટરો:

ઓપરેટર	ઉદાહરણ	સમકક્ષ
`=`	`x = 5`	મૂલ્ય આપો
`+=`	`x += 3`	`x = x + 3`
`-=`	`x -= 2`	`x = x - 2`
`*=`	`x *= 4`	`x = x * 4`

આઇડેન્ટિટી ઓપરેટરો:

ઓપરેટર	હેતુ	ઉદાહરણ
`is`	સમાન ઓબ્જેક્ટ	`x is y`
`is not`	વિવિધ ઓબ્જેક્ટ	`x is not y`

કોડ ઉદાહરણ:

Python

યાદી રાખવાની ટ્રિક: "Add Assign Identity"

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

નીચેનામાંથી કયા આઇડેન્ટિફાયર્સ ના નામો અમાન્ય છે? (i) Total Marks (ii)Total_Marks (iii)total-Marks (iv) Hundred$ (v) _Percentage (vi) True

જવાબ:

આઇડેન્ટિફાયર	માન્ય/અમાન્ય	કારણ
Total Marks	અમાન્ય	સ્પેસ છે
Total_Marks	માન્ય	અન્ડરસ્કોર મંજૂર છે
total-Marks	અમાન્ય	હાઇફન મંજૂર નથી
Hundred$	અમાન્ય	$ સિમ્બોલ મંજૂર નથી
_Percentage	માન્ય	અન્ડરસ્કોરથી શરૂ થઈ શકે છે
True	અમાન્ય	આરક્ષિત કીવર્ડ છે

અમાન્ય આઇડેન્ટિફાયર્સ: Total Marks, total-Marks, Hundred$, True

યાદી રાખવાની ટ્રિક: "સ્પેસ હાઇફન ડોલર કીવર્ડ = અમાન્ય"

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

આપેલ ત્રણ સંખ્યાઓમાંથી મહત્તમ સંખ્યા શોધવા માટે પ્રોગ્રામ લખો.

જવાબ:

Python

max() ફંક્શન વાપરીને વૈકલ્પિક રીત:

Python

યાદી રાખવાની ટ્રિક: "Input Compare Display"

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

પાયથોનમાં ડિક્શનરી સમજાવો. ડિક્શનરીમાં ઘટકો ઉમેરવા, બદલવા અને કાઢી નાખવા માટેના સ્ટેટમેન્ટ લખો.

જવાબ:

ડિક્શનરી એ key-value જોડીઓનો સંગ્રહ છે જે ક્રમબદ્ધ, બદલાય તેવો અને ડુપ્લિકેટ keys નથી મંજૂર કરે છે.

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

ઓપરેશન	સિન્ટેક્સ	ઉદાહરણ
બનાવો	`dict_name = {}`	`student = {}`
ઉમેરો	`dict[key] = value`	`student['name'] = 'John'`
બદલો	`dict[key] = new_value`	`student['name'] = 'Jane'`
ડિલીટ કરો	`del dict[key]`	`del student['name']`
એક્સેસ કરો	`dict[key]`	`print(student['name'])`

કોડ ઉદાહરણ:

Python

ડિક્શનરીના ગુણધર્મો:

ક્રમબદ્ધ: insertion order જાળવે છે (Python 3.7+)
બદલાય તેવું: બનાવ્યા પછી બદલી શકાય છે
ડુપ્લિકેટ્સ નહીં: Keys અનન્ય હોવા જરૂરી છે

યાદી રાખવાની ટ્રિક: "Key-Value ક્રમબદ્ધ બદલાય અનન્ય"

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

નીચેની પેટર્ન દર્શાવવા માટેનો પ્રોગ્રામ લખો.

જવાબ:

Python

આઉટપુટ:

યાદી રાખવાની ટ્રિક: "બાહ્ય રો આંતરિક કોલમ પ્રિન્ટ"

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

વપરાશકર્તા દ્વારા દાખલ કરેલ પૂર્ણાંક સંખ્યાના અંકોનો સરવાળો શોધવા માટે પ્રોગ્રામ લખો.

જવાબ:

Python

વૈકલ્પિક રીત:

Python

યાદી રાખવાની ટ્રિક: "Input કાઢો સરવાળો દર્શાવો"

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

લિસ્ટમાં સ્લાઇસિંગ અને કન્કેટનેશન ઓપરેશન સમજાવો.

જવાબ:

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

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

સિન્ટેક્સ	વર્ણન	ઉદાહરણ
`list[start:stop]`	start થી stop-1 સુધીના ઘટકો	`nums[1:4]`
`list[:stop]`	શરૂઆતથી stop-1 સુધી	`nums[:3]`
`list[start:]`	start થી અંત સુધી	`nums[2:]`
`list[::step]`	step સાથે બધા ઘટકો	`nums[::2]`
`list[::-1]`	રિવર્સ લિસ્ટ	`nums[::-1]`

કન્કેટનેશન: બે અથવા વધુ લિસ્ટને + ઓપરેટર અથવા extend() મેથડ વાપરીને જોડવું.

કોડ ઉદાહરણ:

Python

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

સ્લાઇસિંગ: મૂળ લિસ્ટ બદલ્યા વગર નવી લિસ્ટ બનાવે છે
કન્કેટનેશન: લિસ્ટને એક લિસ્ટમાં જોડે છે
નેગેટિવ ઇન્ડેક્સિંગ: list[-1] છેલ્લો ઘટક આપે છે

યાદી રાખવાની ટ્રિક: "સ્લાઇસ કાઢો કન્કેટ જોડો"

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

પાયથોનમાં લિસ્ટ વ્યાખ્યાયિત કરો. લિસ્ટના અંતમાં એલિમેન્ટ ઉમેરવા માટે વપરાતા ફંક્શનનું નામ લખો.

જવાબ:

લિસ્ટ વ્યાખ્યા: એક લિસ્ટ એ આઇટમ્સનો ક્રમબદ્ધ સંગ્રહ છે જે બદલાય તેવો અને ડુપ્લિકેટ મૂલ્યો મંજૂર કરે છે.

ગુણધર્મો ટેબલ:

ગુણધર્મ	વર્ણન
ક્રમબદ્ધ	આઇટમ્સનો નિશ્ચિત ક્રમ છે
બદલાય તેવું	બનાવ્યા પછી બદલી શકાય છે
ડુપ્લિકેટ્સ	ડુપ્લિકેટ મૂલ્યો મંજૂર કરે છે
ઇન્ડેક્સ્ડ	ઇન્ડેક્સ દ્વારા આઇટમ્સ access કરવાય છે

ઘટક ઉમેરવા માટેનું ફંક્શન: append()

ઉદાહરણ:

Python

યાદી રાખવાની ટ્રિક: "લિસ્ટ append અંત"

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

પાયથોનમાં ટ્યુપલ વ્યાખ્યાયિત કરો. ટ્યુપલના છેલ્લા એલિમેન્ટને એક્સેસ કરવા માટેનું સ્ટેટમેન્ટ લખો.

જવાબ:

ટ્યુપલ વ્યાખ્યા: એક ટ્યુપલ એ આઇટમ્સનો ક્રમબદ્ધ સંગ્રહ છે જે બદલાય તેવો નથી અને ડુપ્લિકેટ મૂલ્યો મંજૂર કરે છે.

ગુણધર્મો ટેબલ:

ગુણધર્મ	વર્ણન
ક્રમબદ્ધ	આઇટમ્સનો નિશ્ચિત ક્રમ છે
બદલાય તેવું નથી	બનાવ્યા પછી બદલી શકાય નહીં
ડુપ્લિકેટ્સ	ડુપ્લિકેટ મૂલ્યો મંજૂર કરે છે
ઇન્ડેક્સ્ડ	ઇન્ડેક્સ દ્વારા આઇટમ્સ access કરવાય છે

છેલ્લા એલિમેન્ટને એક્સેસ કરવું:

Python

યાદી રાખવાની ટ્રિક: "ટ્યુપલ બદલાય નહિ નેગેટિવ ઇન્ડેક્સ"

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

નીચેના સેટ ઓપરેશન્સ માટે સ્ટેટમેન્ટ લખો: ખાલી સેટ બનાવો, સેટમાં એક ઘટક ઉમેરો, સેટમાંથી એક ઘટક દૂર કરો, બે સેટનું યુનિયન, બે સેટનું છેદ, બે સેટ વચ્ચેનો તફાવત અને બે સેટ વચ્ચે સિમેટ્રિક તફાવત.

જવાબ:

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

ઓપરેશન	મેથડ	ઓપરેટર	ઉદાહરણ
ખાલી બનાવો	`set()`	-	`s = set()`
ઘટક ઉમેરો	`add()`	-	`s.add(5)`
ઘટક દૂર કરો	`remove()`	-	`s.remove(5)`
યુનિયન	`union()`	`	`
છેદ	`intersection()`	`&`	`A.intersection(B)` અથવા `A & B`
તફાવત	`difference()`	`-`	`A.difference(B)` અથવા `A - B`
સિમેટ્રિક તફાવત	`symmetric_difference()`	`^`	`A.symmetric_difference(B)` અથવા `A ^ B`

કોડ ઉદાહરણ:

Python

યાદી રાખવાની ટ્રિક: "બનાવો ઉમેરો દૂર કરો યુનિયન છેદ તફાવત સિમેટ્રિક"

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

પાયથોનમાં સ્ટ્રિંગ વ્યાખ્યાયિત કરો. ઉદાહરણ વાપરીને સમજાવો (i) સ્ટ્રિંગ કેવી રીતે બનાવવી. (ii) ઇન્ડેક્સિંગનો ઉપયોગ કરીને વ્યક્તિગત અક્ષરોને એક્સેસ કરવું.

જવાબ:

સ્ટ્રિંગ વ્યાખ્યા: એક સ્ટ્રિંગ એ અવતરણચિહ્ન (સિંગલ અથવા ડબલ) માં બંધ કરેલા અક્ષરોનો ક્રમ છે.

(i) સ્ટ્રિંગ બનાવવું:

Python

(ii) અક્ષરોને એક્સેસ કરવું:

Python

યાદી રાખવાની ટ્રિક: "સ્ટ્રિંગ અવતરણ ઇન્ડેક્સ એક્સેસ"

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

ફોર લૂપ અને વ્હાઇલ લૂપનો ઉપયોગ કરીને લિસ્ટ ટ્રાવર્સિંગ સમજાવો.

જવાબ:

લિસ્ટ ટ્રાવર્સિંગ મતલબ લિસ્ટના દરેક ઘટકને એક પછી એક મુલાકાત લેવી.

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

Python

વ્હાઇલ લૂપ ટ્રાવર્સિંગ:

Python

તુલના ટેબલ:

લૂપ પ્રકાર	ફાયદો	ઉપયોગ
ફોર લૂપ	સરળ સિન્ટેક્સ	જ્યારે iteration ની સંખ્યા ખબર હોય
વ્હાઇલ લૂપ	વધુ નિયંત્રણ	જ્યારે શરત આધારિત iteration જોઈએ

યાદી રાખવાની ટ્રિક: "ફોર સરળ વ્હાઇલ નિયંત્રણ"

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

એક એવો પ્રોગ્રામ લખો કે જેનાથી વર્ગમાં n વિદ્યાર્થીઓના રોલ નંબર, નામ અને માર્ક્સ સાથેની ડિક્શનરી બનાવી શકાય અને 75 થી વધુ ગુણ મેળવનારા વિદ્યાર્થીઓના નામ ડિસ્પ્લે કરી શકાય.

જવાબ:

Python

સેમ્પલ આઉટપુટ:

વિદ્યાર્થીઓની સંખ્યા દાખલ કરો: 2

વિદ્યાર્થી 1 ની વિગતો દાખલ કરો:
રોલ નંબર: 101
નામ: John
માર્ક્સ: 80

વિદ્યાર્થી 2 ની વિગતો દાખલ કરો:
રોલ નંબર: 102
નામ: Alice
માર્ક્સ: 70

75 થી વધુ માર્ક્સ વાળા વિદ્યાર્થીઓ:
------------------------------
નામ: John, માર્ક્સ: 80.0

કુલ હાઇ પર્ફોર્મર્સ: 1

યાદી રાખવાની ટ્રિક: "Input સ્ટોર ફિલ્ટર ડિસ્પ્લે"

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

રેન્ડમ મોડ્યુલમાં ઉપલબ્ધ કોઈપણ ત્રણ ફંક્શન લખો. દરેક ફંક્શનનું સિન્ટેક્સ અને ઉદાહરણ લખો.

જવાબ:

રેન્ડમ મોડ્યુલ ફંક્શન્સ:

ફંક્શન	સિન્ટેક્સ	હેતુ	ઉદાહરણ
random()	`random.random()`	0.0 થી 1.0 સુધી રેન્ડમ ફ્લોટ	`0.7534`
randint()	`random.randint(a, b)`	a થી b સુધી રેન્ડમ ઇન્ટીજર	`randint(1, 10)`
choice()	`random.choice(seq)`	સિક્વન્સમાંથી રેન્ડમ ઘટક	`choice(['a', 'b', 'c'])`

કોડ ઉદાહરણ:

Python

યાદી રાખવાની ટ્રિક: "Random Randint Choice"

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

ફંક્શનના ફાયદા લખો.

જવાબ:

ફંક્શનના ફાયદા:

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

ઉદાહરણ:

Python

યાદી રાખવાની ટ્રિક: "પુનઃઉપયોગ મોડ્યુલર ડીબગ વાંચો જાળવો ટાળો"

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

એક પ્રોગ્રામ લખો જે વપરાશકર્તાને સ્ટ્રિંગ માટે પૂછે અને સ્ટ્રિંગમાં દરેક 'a' નું સ્થાન પ્રિન્ટ કરે.

જવાબ:

Python

સેમ્પલ આઉટપુટ:

સ્ટ્રિંગ દાખલ કરો: Python Programming

અક્ષર 'a' આ positions પર મળ્યું: [12]
વિગતવાર સ્થાનો:
Position 12: 'a'

વૈકલ્પિક રીત:
'a' position 12 પર મળ્યું

સુધારેલું વર્ઝન:

Python

યાદી રાખવાની ટ્રિક: "Input લૂપ ચેક સ્ટોર ડિસ્પ્લે"

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

લોકલ અને ગ્લોબલ વેરિયેબલ સમજાવો.

જવાબ:

વેરિયેબલ સ્કોપ પ્રકારો:

વેરિયેબલ પ્રકાર	સ્કોપ	એક્સેસ	ઉદાહરણ
લોકલ	ફંક્શનની અંદર જ	ફંક્શનની અંદર	`def func(): x = 5`
ગ્લોબલ	આખા પ્રોગ્રામમાં	પ્રોગ્રામમાં ગમે ત્યાં	`x = 5` (ફંક્શનની બહાર)

કોડ ઉદાહરણ:

Python

ગ્લોબલ કીવર્ડ:

Python

યાદી રાખવાની ટ્રિક: "લોકલ અંદર ગ્લોબલ બધે"

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

યુઝર ડિફાઇન્ડ ફંક્શનનું બનાવટ અને ઉપયોગ ઉદાહરણ સાથે સમજાવો.

જવાબ:

ફંક્શન બનાવટ સિન્ટેક્સ:

Python

ફંક્શનના ઘટકો:

ઘટક	હેતુ	ઉદાહરણ
def	ફંક્શન વ્યાખ્યાયિત કરવાનું કીવર્ડ	`def`
function_name	ફંક્શનનું નામ	`calculate_area`
parameters	ઇનપુટ મૂલ્યો	`(length, width)`
return	આઉટપુટ મૂલ્ય	`return result`

ઉદાહરણ:

Python

યાદી રાખવાની ટ્રિક: "વ્યાખ્યાયિત કૉલ રિટર્ન પેરામીટર"

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

calcFact() નામનું યુઝર ડિફાઇન્ડ ફંક્શન બનાવવા માટેનો પ્રોગ્રામ લખો કે જે આર્ગ્યુમેન્ટ તરીકે આપેલ સંખ્યાના ફેક્ટોરિયલની ગણતરી કરી તેને ડિસ્પ્લે કરે.

જવાબ:

Python

રીકર્સિવ વર્ઝન:

Python

સેમ્પલ આઉટપુટ:

સંખ્યા દાખલ કરો: 5
5 નું ફેક્ટોરિયલ છે: 120

વિવિધ મૂલ્યો સાથે ટેસ્ટિંગ:
calcFact(0) = 1
calcFact(1) = 1
calcFact(5) = 120
calcFact(10) = 3628800
calcFact(-3) = નેગેટિવ સંખ્યા માટે ફેક્ટોરિયલ વ્યાખ્યાયિત નથી

યાદી રાખવાની ટ્રિક: "વ્યાખ્યાયિત ચેક લૂપ ગુણાકાર રિટર્ન"

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

ક્લાસ અને ઓબ્જેક્ટ વચ્ચે તફાવત આપો.

જવાબ:

ક્લાસ વર્સિસ ઓબ્જેક્ટ તુલના:

બાબત	ક્લાસ	ઓબ્જેક્ટ
વ્યાખ્યા	બ્લૂપ્રિન્ટ/ટેમ્પ્લેટ	ક્લાસનું ઇન્સ્ટન્સ
મેમરી	મેમરી એલોકેટ નથી	મેમરી એલોકેટ છે
બનાવટ	`class` કીવર્ડ વાપરીને વ્યાખ્યાયિત	ક્લાસના નામ વાપરીને બનાવાય છે
એટ્રિબ્યુટ્સ	વ્યાખ્યાયિત પરંતુ ઇનિશિયલાઇઝ નથી	વાસ્તવિક મૂલ્યો છે
ઉદાહરણ	`class Car:`	`my_car = Car()`

કોડ ઉદાહરણ:

Python

યાદી રાખવાની ટ્રિક: "ક્લાસ બ્લૂપ્રિન્ટ ઓબ્જેક્ટ ઇન્સ્ટન્સ"

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

ક્લાસમાં કન્સ્ટ્રક્ટરનો હેતુ જણાવો.

જવાબ:

કન્સ્ટ્રક્ટરનો હેતુ:

હેતુ	વર્ણન
ઓબ્જેક્ટ ઇનિશિયલાઇઝ કરો	એટ્રિબ્યુટ્સને પ્રારંભિક મૂલ્યો આપો
ઓટોમેટિક એક્ઝીક્યુશન	ઓબ્જેક્ટ બનાવતી વખતે આપોઆપ કૉલ થાય છે
મેમરી સેટઅપ	ઓબ્જેક્ટ એટ્રિબ્યુટ્સ માટે મેમરી એલોકેટ કરે છે
ડિફોલ્ટ મૂલ્યો	એટ્રિબ્યુટ્સને ડિફોલ્ટ મૂલ્યો આપે છે

કન્સ્ટ્રક્ટરના પ્રકારો:

પ્રકાર	વર્ણન	ઉદાહરણ
ડિફોલ્ટ	કોઈ પેરામીટર નથી	`def __init__(self):`
પેરામીટરાઇઝ્ડ	પેરામીટર લે છે	`def __init__(self, name):`

ઉદાહરણ:

Python

યાદી રાખવાની ટ્રિક: "ઇનિશિયલાઇઝ ઓટોમેટિક મેમરી ડિફોલ્ટ"

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

"Student" નામનો ક્લાસ બનાવવા માટે પ્રોગ્રામ લખો જેમાં નામ, રોલ નંબર અને માર્ક્સ જેવા એટ્રિબ્યુટ્સ હોય. વિદ્યાર્થીની માહિતી પ્રદર્શિત કરવાની મેથડ બનાવો. "Student" ક્લાસનો ઓબ્જેક્ટ બનાવો અને મેથડનો ઉપયોગ કેવી રીતે કરવો તે બતાવો.

જવાબ:

Python

સેમ્પલ આઉટપુટ:

Student ઓબ્જેક્ટ્સ બનાવી રહ્યા છીએ:

=== વિદ્યાર્થી 1 ની વિગતો ===
------------------------------
વિદ્યાર્થીની માહિતી
------------------------------
નામ: જોહન દોય
રોલ નંબર: 101
માર્ક્સ: 85
------------------------------
ગ્રેડ: A

=== વિદ્યાર્થી 2 ની વિગતો ===
------------------------------
વિદ્યાર્થીની માહિતી
------------------------------
નામ: આલિસ સ્મિથ
રોલ નંબર: 102
માર્ક્સ: 92
------------------------------
ગ્રેડ: A+

ક્લાસના ઘટકો:

એટ્રિબ્યુટ્સ: name, roll_number, marks
કન્સ્ટ્રક્ટર: __init__() મેથડ
મેથડ્સ: display_info(), calculate_grade(), display_grade()
ઓબ્જેક્ટ્સ: student1, student2, student3

યાદી રાખવાની ટ્રિક: "ક્લાસ એટ્રિબ્યુટ્સ કન્સ્ટ્રક્ટર મેથડ્સ ઓબ્જેક્ટ્સ"

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

એન્કેપ્સ્યુલેશનનો હેતુ જણાવો.

જવાબ:

એન્કેપ્સ્યુલેશનનો હેતુ:

હેતુ	વર્ણન
ડેટા છુપાવવું	આંતરિક implementation વિગતો છુપાવે છે
ડેટા સુરક્ષા	અનધિકૃત એક્સેસથી ડેટાને બચાવે છે
નિયંત્રિત એક્સેસ	મેથડ્સ દ્વારા નિયંત્રિત એક્સેસ આપે છે
કોડ સિક્યુરિટી	ડેટાના આકસ્મિક ફેરફારને અટકાવે છે
મોડ્યુલરિટી	સંબંધિત ડેટા અને મેથડ્સ એકસાથે રાખે છે

અમલીકરણ ઉદાહરણ:

Python

ફાયદા:

સિક્યુરિટી: ડેટાને સીધી એક્સેસ કરી શકાતી નથી
જાળવણી: આંતરિક implementation સહેલાઈથી બદલી શકાય છે
વેલિડેશન: getter/setter મેથડ્સમાં વેલિડેશન ઉમેરી શકાય છે

યાદી રાખવાની ટ્રિક: "છુપાવો સુરક્ષા નિયંત્રણ સિક્યુર મોડ્યુલર"

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

મલ્ટિલેવલ ઇન્હેરિટન્સ સમજાવો.

જવાબ:

મલ્ટિલેવલ ઇન્હેરિટન્સ એ જ્યારે એક ક્લાસ બીજી ક્લાસમાંથી ઇન્હેરિટ કરે છે, જે બદલામાં બીજી ક્લાસમાંથી ઇન્હેરિટ કરે છે, આમ એક શૃંખલા બને છે.

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

goat

લક્ષણો ટેબલ:

લેવલ	ક્લાસ	ઇન્હેરિટ કરે છે	એક્સેસ કરે છે
લેવલ 1	GrandPa	કોઈથી નહીં	પોતાની મેથડ્સ
લેવલ 2	Parent	GrandPa	GrandPa + પોતાની મેથડ્સ
લેવલ 3	Child	Parent	GrandPa + Parent + પોતાની

કોડ ઉદાહરણ:

Python

યાદી રાખવાની ટ્રિક: "શૃંખલા ઇન્હેરિટ લેવલ એક્સેસ"

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

હાઇબ્રિડ ઇન્હેરિટન્સનું કાર્ય દર્શાવતો પાયથોન પ્રોગ્રામ લખો.

જવાબ:

હાઇબ્રિડ ઇન્હેરિટન્સ એક પ્રોગ્રામમાં બહુવિધ પ્રકારની ઇન્હેરિટન્સ (સિંગલ, મલ્ટિપલ, મલ્ટિલેવલ) ને જોડે છે.

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

goat

કોડ ઉદાહરણ:

Python

સેમ્પલ આઉટપુટ:

=== હાઇબ્રિડ ઇન્હેરિટન્સ ડેમો ===

1. સામાન્ય કૂતરો બનાવી રહ્યા છીએ:
પ્રાણી બડી બન્યું
બડી રિટ્રીવર કૂકે છે
બડી ઘરની રક્ષા કરે છે

2. સામાન્ય પક્ષી બનાવી રહ્યા છીએ:
પ્રાણી ગરુડ બન્યું
ગરુડ 200cm પાંખો સાથે ઉડે છે
ગરુડ ઇંડા આપે છે

3. જાદુઈ ઉડતો કૂતરો બનાવી રહ્યા છીએ:
પ્રાણી સુપરડોગ બન્યું
પ્રાણી સુપરડોગ બન્યું
જાદુઈ સુપરડોગ બન્યું જેમાં mammal અને bird બંનેના લક્ષણ છે!

સુપરડોગ ની ક્ષમતાઓ:
-------------------------
સુપરડોગ ખાય છે
સુપરડોગ સૂએ છે
સુપરડોગ જીવતા બાળકોને જન્મ આપે છે
સુપરડોગ હસ્કી કૂકે છે
સુપરડોગ ઘરની રક્ષા કરે છે
સુપરડોગ 150cm પાંખો સાથે ઉડે છે
સુપરડોગ ઇંડા આપે છે
સુપરડોગ એક સાથે ઉડે છે અને કૂકે છે!

આ ઉદાહરણમાં ઇન્હેરિટન્સના પ્રકારો:

સિંગલ: Mammal ← Animal, Bird ← Animal, Dog ← Mammal
મલ્ટિપલ: FlyingDog ← Dog + Bird
મલ્ટિલેવલ: FlyingDog ← Dog ← Mammal ← Animal
હાઇબ્રિડ: ઉપરોક્ત બધાનું સંયોજન

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

મલ્ટિપલ પેરેન્ટ ક્લાસ: FlyingDog Dog અને Bird બંનેમાંથી ઇન્હેરિટ કરે છે
મેથડ રિઝોલ્યુશન ઓર્ડર: Python MRO ને અનુસરીને મેથડ conflicts ને હલ કરે છે
super() નો ઉપયોગ: પેરેન્ટ ક્લાસના યોગ્ય ઇનિશિયલાઇઝેશન માટે
સંયુક્ત કાર્યક્ષમતા: બધી પેરેન્ટ ક્લાસની મેથડ્સ તકે પહોંચ

યાદી રાખવાની ટ્રિક: "હાઇબ્રિડ મલ્ટિપલ સિંગલ મલ્ટિલેવલ સંયુક્ત"