આ લેક્ચરમાં, આપણે અજગરમાં વર્ગો, રચનાકારો અને વારસા વિશે શીખીશું.
આ વિભાવનાઓ એક વિશાળ પ્રોગ્રામમાં ખરેખર મહત્વપૂર્ણ છે જ્યાં વિવિધ પ્રકારોને વ્યાખ્યાયિત કરવાની જરૂર છે.
વર્ગો
પ્રોગ્રામિંગમાં વર્ગો આવશ્યક છે અને તે પાયથોન માટે વિશિષ્ટ નથી. બીજા ઘણા પ્રોગ્રામિંગ ભાષાઓ વર્ગોની કલ્પનાને સમર્થન આપો. અમે નવા ડેટા પ્રકારોને વ્યાખ્યાયિત કરવા માટે વર્ગોનો ઉપયોગ કરીએ છીએ.
અત્યાર સુધી, આપણે પાયથોનમાં મૂળભૂત ડેટા પ્રકારો જેમ કે નંબરો, સ્ટ્રીંગ્સ અને બુલિયન વિશે શીખ્યા છીએ. પાયથોનમાં આ મૂળભૂત અથવા સરળ ડેટા પ્રકારો છે. અમે સૂચિઓ અને શબ્દકોશો જેવા કેટલાક જટિલ ડેટા પ્રકારો પણ જોયા છે.
આ પ્રકારો અત્યંત ઉપયોગી હોવા છતાં, તેઓ હંમેશા જટિલ વિભાવનાઓને મોડેલ કરવા માટે ઉપયોગમાં લઈ શકાતા નથી. ઉદાહરણ તરીકે, બિંદુ અથવા શોપિંગ કાર્ટના વિચાર વિશે વિચારો. શોપિંગ કાર્ટ એ બુલિયન અથવા સૂચિ નથી. તે એક અલગ પ્રકારનો ડેટા છે. તેથી અમે વાસ્તવિક ખ્યાલોને મોડેલ કરવા માટે નવા પ્રકારોને વ્યાખ્યાયિત કરવા માટે વર્ગોનો ઉપયોગ કરી શકીએ છીએ.
હવે, ચાલો પોઈન્ટ નામના નવા ડેટા પ્રકારને વ્યાખ્યાયિત કરીએ. આ નવા પ્રકારમાં પદ્ધતિઓ હશે જે આપણે પહેલા તપાસી છે.
તમે આ રીતે કરશો:
અમે "ક્લાસ" કીવર્ડનો ઉપયોગ કરીને વર્ગને વ્યાખ્યાયિત કરીને શરૂઆત કરીએ છીએ અને તે પછી અમે અમારા વર્ગને નામ આપીએ છીએ.
class Point
હવે, મેં અહીં જે નામકરણનો ઉપયોગ કર્યો છે તે જુઓ. મેં અહીં પહેલો અક્ષર કેપિટલાઇઝ કર્યો છે, આને આપણે પાસ્કલ નામકરણ સંમેલન કહીએ છીએ. આ સંમેલન અમે અમારા ચલો અને કાર્યોને નામ આપવા માટે જે ઉપયોગ કરીએ છીએ તેનાથી અલગ છે જેના માટે અમે હંમેશા લોઅરકેસ અક્ષરોનો ઉપયોગ કરીએ છીએ અને અન્ડરસ્કોરનો ઉપયોગ કરીને બહુવિધ શબ્દોને અલગ કરીએ છીએ. પરંતુ વર્ગોનું નામકરણ કરતી વખતે, અમે તેના બદલે બહુવિધ શબ્દોને અલગ કરવા માટે અન્ડરસ્કોરનો ઉપયોગ કરતા નથી, અમે દરેક શબ્દના પ્રથમ અક્ષરને કેપિટલાઇઝ કરીએ છીએ.
અમારા વર્ગને વ્યાખ્યાયિત કર્યા પછી, કોલોનનો ઉપયોગ થાય છે જેનો અર્થ છે કે હવે બ્લોક વ્યાખ્યાયિત થયેલ છે.
class Point:
def move (self):
આ બ્લોકમાં, આપણે પોઈન્ટથી સંબંધિત તમામ કાર્યો અથવા પદ્ધતિઓ વ્યાખ્યાયિત કરી શકીએ છીએ. ઉદાહરણ તરીકે, બિંદુને ખસેડવા માટે આપણે "મૂવ" નામના ફંક્શનને વ્યાખ્યાયિત કરી શકીએ છીએ. નોંધ કરો કે જેમ જેમ આપણે ઓપન કૌંસ લખીએ છીએ, PyCharm આપમેળે અહીં "સ્વ" ઉમેરે છે. આ એક ખાસ કીવર્ડ છે અને મને ટૂંક સમયમાં આ પર પાછા આવવા દો. ચાલો ટર્મિનલ પર "મૂવ" પ્રિન્ટ કરીએ.
print("move")
ચાલો “ડ્રો” જેવી બીજી પદ્ધતિ વ્યાખ્યાયિત કરીએ અને તેને ટર્મિનલ પર પ્રિન્ટ કરીએ.
def draw(self):
print("draw")
અમે અમારા "બિંદુ" વર્ગની વ્યાખ્યા પૂરી કરી લીધી છે. આ નવા પ્રકાર સાથે, આપણે નવી વસ્તુઓ બનાવી શકીએ છીએ. એક વર્ગ ફક્ત બ્લુપ્રિન્ટ અથવા ઑબ્જેક્ટ બનાવવા માટેના નમૂનાને વ્યાખ્યાયિત કરે છે જે તે બ્લુપ્રિન્ટ પર આધારિત વાસ્તવિક ઉદાહરણો છે. ઑબ્જેક્ટ બનાવવા માટે, અમે અમારા વર્ગનું નામ ટાઈપ કરીએ છીએ અને પછી તેને ફંક્શનની જેમ કૉલ કરીએ છીએ. આ એક નવો ઑબ્જેક્ટ બનાવે છે અને પછી તેને પરત કરે છે. પછી આપણે તે પદાર્થને વેરીએબલમાં સંગ્રહિત કરી શકીએ છીએ. ચાલો હું તમને બતાવું:
અહીં આપણે "બિંદુ1" ને વ્યાખ્યાયિત કર્યું છે જે ત્રિ-પરિમાણીય બિંદુ છે. તમે જોઈ શકો છો કે, અમે ટર્મિનલ પર વ્યક્તિગત કોઓર્ડિનેટ્સ પ્રિન્ટ કરી શકીએ છીએ.
આપણે આ બિંદુ સાથે "ડ્રો" અને "મૂવ" બે પદ્ધતિઓનો ઉપયોગ કરી શકીએ છીએ.
તેથી રીકેપ કરવા માટે, અમે નવા પ્રકારોને વ્યાખ્યાયિત કરવા માટે વર્ગોનો ઉપયોગ કરીએ છીએ અને આ પ્રકારોમાં એવી પદ્ધતિઓ હોઈ શકે છે જેને આપણે વર્ગના મુખ્ય ભાગમાં વ્યાખ્યાયિત કરીએ છીએ. વર્ગોમાં એવા લક્ષણો હોઈ શકે છે જે અમે અમારા પ્રોગ્રામ્સમાં ગમે ત્યાં સેટ કરી શકીએ છીએ.
કન્સ્ટ્રકટરો
અત્યાર સુધી, અમે વર્ગોનો ઉપયોગ કરીને નવા પ્રકારો કેવી રીતે બનાવવું તે શીખ્યા. હવે આ અમલીકરણમાં એક નાની સમસ્યા છે. આપણે વર્ગોનો ઉપયોગ કરીને x અથવા y સંકલન વિના બિંદુ પદાર્થ બનાવી શકીએ છીએ અને તે આદર્શ નથી. ચાલો હું તમને બતાવું.
ચાલો એક બિંદુ બનાવીએ અને x કોઓર્ડિનેટ સેટ કરતા પહેલા તેને પ્રિન્ટ કરીએ. અમારો પ્રોગ્રામ ચલાવવાનું પરિણામ આના જેવી વિશેષતા ભૂલમાં પરિણમે છે:
તેનો અર્થ એ છે કે પોઈન્ટ ઓબ્જેક્ટમાં x નામની કોઈ વિશેષતા નથી. હવે સમસ્યા એ છે કે x અથવા y કોઓર્ડિનેટ્સ વિના પોઈન્ટ ઓબ્જેક્ટ હોવું શક્ય છે. આનો અર્થ નથી કારણ કે જ્યારે પણ આપણે કોઈ બિંદુ વિશે વાત કરીએ છીએ, ત્યારે આપણે તે બિંદુ ક્યાં સ્થિત છે તે જાણવાની જરૂર છે. આ સમસ્યાને ઉકેલવા માટે, અમે કન્સ્ટ્રક્ટરનો ઉપયોગ કરીએ છીએ. કન્સ્ટ્રક્ટર એ એક કાર્ય છે જે ઑબ્જેક્ટ બનાવતી વખતે બોલાવવામાં આવે છે.
અહીં આપણે કન્સ્ટ્રક્ટરનો ઉપયોગ કેવી રીતે કરીએ છીએ તે છે. પ્રથમ, ચાલો ઉપરના પ્રોગ્રામમાં x અને y કોઓર્ડિનેટ્સ વેલ્યુ પાસ કરીએ.
point = Point(10, 20)
print(point.x)
હવે, આપણે આ વર્ગમાં એક વિશેષ પદ્ધતિ ઉમેરવાની જરૂર છે જેને કન્સ્ટ્રક્ટર કહેવાય છે. તેની વાક્યરચના આ પ્રમાણે છે:
def __init__(self, x, y):
init
આરંભ માટે ટૂંકું છે, અને આ એ ફંક્શન અથવા પદ્ધતિ છે જે જ્યારે નવો પોઈન્ટ ઑબ્જેક્ટ બનાવવામાં આવે ત્યારે કૉલ થાય છે. x અને y બરાબર પછી ઉમેરવામાં આવે છે self
બે વધારાના પરિમાણો ઉમેરવા માટે.
તે પછી, આપણે પાસ કરેલ મૂલ્યો એટલે કે 10 અને 20 સાથે x અને y ને મેપ કરીશું
self.x = x
self.y = y
અમે આનો ઉપયોગ કરીએ છીએ self
વર્તમાન ઑબ્જેક્ટનો સંદર્ભ લેવા માટે અને પછી આપણે "x" ફંક્શનને પસાર કરેલ x દલીલમાં x એટ્રિબ્યુટ સેટ કરીએ છીએ. આ રીતે, ઉપયોગ કરીને init
પદ્ધતિ, અમે અમારા ઑબ્જેક્ટ્સને પ્રારંભ કરી શકીએ છીએ. આ પદ્ધતિને કન્સ્ટ્રક્ટર તરીકે ઓળખવામાં આવે છે. ચાલો અમારો પ્રોગ્રામ ચલાવીએ.
હવે, આપણે પછીથી x અને y કોઓર્ડિનેટ્સ બદલી શકીએ છીએ. ચાલો x કોઓર્ડિનેટ અપડેટ કરીએ:
point = Point(10, 20)
point.x = 11
print(point.x)
હવે, x કોઓર્ડિનેટ મૂલ્ય 11 પર અપડેટ થયેલ છે.
કસરત
અહીં તમારા માટે એક રસપ્રદ કસરત છે.
હું ઈચ્છું છું કે તમે વ્યક્તિ તરીકે ઓળખાતા નવા પ્રકારને વ્યાખ્યાયિત કરો. આ "વ્યક્તિ" ઑબ્જેક્ટ્સમાં "name
" લક્ષણ તેમજ "talk()
”પદ્ધતિ.
તે એક સરળ કાર્ય છે અને તેમાં થોડી મિનિટોથી વધુ સમય લાગવો જોઈએ નહીં.
ઉકેલ
આ રીતે "વ્યક્તિ" વર્ગને વ્યાખ્યાયિત કરીને પ્રારંભ કરો:
class Person:
self.name = name
અમે કન્સ્ટ્રક્ટરને પછીથી વ્યાખ્યાયિત કરીશું. હવે, આપણે "વ્યક્તિ" ઑબ્જેક્ટ બનાવી શકીએ છીએ. ચાલો તેને જ્હોન કહીએ
john = Person("John Smith")
print(john.name)
john.talk()
હવે, કોડના પહેલા ભાગ પર જાઓ અને કન્સ્ટ્રક્ટર બનાવો.
def __init__(self, name):
અંતિમ કોડ આના જેવો દેખાશે:
તમે વર્ગો અને કન્સ્ટ્રક્ટર સાથે જોડાણમાં ફોર્મેટ કરેલ શબ્દમાળાઓ અને અન્ય ખ્યાલોનો પણ ઉપયોગ કરી શકો છો.
વારસો
વારસો એ વર્ગો સાથે સંકળાયેલ બીજો ખ્યાલ છે જે તમને કોડનો ફરીથી ઉપયોગ કરવા દે છે.
કોડના આ ભાગને ધ્યાનમાં લો.
class Dog:
def walk(self):
print("walk")
અમે "વૉક" પદ્ધતિ સાથે "ડોગ" વર્ગ બનાવ્યો છે. આ પદ્ધતિમાં, અમે ફક્ત ટર્મિનલ પર વૉક સંદેશ છાપી રહ્યા છીએ. ચાલો કહીએ કે, એક વાસ્તવિક પ્રોગ્રામમાં, અહીં માત્ર એક લીટીને બદલે કોડની 10 લીટીઓ છે. ભવિષ્યમાં, જો બીજા વર્ગને "વૉક" પદ્ધતિની જરૂર હોય, તો અમારે તે બધા કોડનું પુનરાવર્તન કરવું પડશે. આ આદર્શ નથી.
પ્રોગ્રામિંગમાં, અમારી પાસે DRY નામનો સિદ્ધાંત છે જે તમારી જાતને પુનરાવર્તન ન કરવા માટે ટૂંકો છે. ચાલો કહીએ કે ભવિષ્યમાં કોઈક વાર, અમને અમારી "વૉક" પદ્ધતિમાં સમસ્યા જોવા મળે છે અને જો આપણે આ પદ્ધતિને અન્ય ઘણી જગ્યાએ પુનરાવર્તિત અથવા ડુપ્લિકેટ કરી હોય, તો આપણે પાછા આવવું પડશે અને દરેક એક જગ્યાએ તે સમસ્યાને ઠીક કરવી પડશે જ્યાં અમે આ ડુપ્લિકેટ કર્યું છે. કોડ તેથી જ પ્રોગ્રામિંગમાં આપણે કંઈક બે વાર વ્યાખ્યાયિત ન કરવું જોઈએ.
આ સમસ્યાને દૂર કરવા માટે વિવિધ અભિગમો છે પરંતુ અહીં આપણે શીખવા જઈ રહ્યા છીએ કે જે નવા નિશાળીયા માટે સરળ છે અને તેને વારસાગત કહેવાય છે. આ કિસ્સામાં, અમે અન્ય વર્ગ "સસ્તન પ્રાણી" બનાવીશું અને તે વર્ગમાં અમારી "વૉક" વિશેષતા વ્યાખ્યાયિત કરીશું.
class Mammal:
def walk(self):
print("walk")
અમારા "સસ્તન" વર્ગને વ્યાખ્યાયિત કર્યા પછી આપણે આના જેવા લક્ષણો પસાર કરવા માટે વારસાનો ઉપયોગ કરી શકીએ છીએ:
કૂતરો અને બિલાડી બંને વર્ગો તેમના પિતૃ વર્ગમાં વ્યાખ્યાયિત તમામ વર્ગ પદ્ધતિઓ વારસાગત છે. હવે, અમે કૂતરાઓ માટે આના જેવી વિશિષ્ટ પદ્ધતિઓ ઉમેરી શકીએ છીએ:
class Dog:
def bark(self):
print("bark")
સમેટો!
આ બધું વર્ગો, કન્સ્ટ્રક્ટર્સ અને વારસાગત ખ્યાલો સાથેના વર્ગોમાં કોડનો ફરીથી ઉપયોગ કરવા વિશે હતું. હવે અમે અમારી શ્રેણી સમાપ્ત થવાના આરે છીએ. આ બિંદુએ, તમે પાયથોનમાં સારા, વાંચી શકાય તેવા અને સંક્ષિપ્ત કોડ્સ બનાવવા માટે સમર્થ હોવા જોઈએ.
આપણે હવે પછીના લેક્ચરમાં મોડ્યુલ અને પેકેજનો ખ્યાલ જોઈશું.
એક જવાબ છોડો