આ વ્યાખ્યાન પાયથોનમાં મોડ્યુલો અને પેકેજોની આસપાસ વિસ્તરશે.
તે તમારા કોડને ફાઈલોના રૂપમાં ગોઠવવાની એક રીત છે અને જો તમે Python સાથે વેબ એપ્લિકેશન બનાવવાનો ઈરાદો ધરાવતા હોવ તો તે ખરેખર મહત્વપૂર્ણ છે.
મોડ્યુલો
Python માં મોડ્યુલ મૂળભૂત રીતે અમુક python કોડ સાથેની ફાઇલ છે જેનો ઉપયોગ આપણે આપણા કોડને ફાઈલોમાં ગોઠવવા માટે કરીએ છીએ. તેને સુપરમાર્કેટના વિભાગોની જેમ વિચારો. જ્યારે તમે સુપરમાર્કેટમાં જાઓ છો ત્યારે ફળો, શાકભાજી, સફાઈ ઉત્પાદનો વગેરે માટે જુદા જુદા વિભાગો હોય છે. તમને બધા ઉત્પાદનો સાથેનો એક વિભાગ દેખાતો નથી.
તે પ્રોગ્રામિંગમાં સમાન ખ્યાલ છે. main.py માં તમામ કાર્યો અને વર્ગો સાથે અમારા તમામ કોડ લખવાને બદલે, અમે અમારા કોડને બહુવિધ ફાઇલોમાં વિભાજીત કરીએ છીએ. દરેક ફાઇલને મોડ્યુલ તરીકે ઓળખવામાં આવે છે. આ સાથે, અમારો કોડ માત્ર વધુ સારી રીતે વ્યવસ્થિત અને સંરચિત નથી, પરંતુ અમારી પાસે અમારા કોડનો ફરીથી ઉપયોગ કરવાની ક્ષમતા પણ છે. ચાલો તેને એક ઉદાહરણ દ્વારા જોઈએ.
ચાલો વજનને પાઉન્ડથી કિલોગ્રામ અને તેનાથી વિપરીત બે કાર્યોને વ્યાખ્યાયિત કરીએ.
def lbs_to_kg(weight):
return weight * 0.45
def kg_to_lbs(weight):
return weight / 0.45
હવે, આપણે આ બે ફંક્શન લઈ શકીએ છીએ અને તેને "કન્વર્ટર્સ" નામના અલગ મોડ્યુલમાં મૂકી શકીએ છીએ, અને પછી તે કોઈપણ પ્રોગ્રામમાં આયાત કરી શકાય છે જેને આ કન્વર્ટર ફંક્શન્સની જરૂર હોય. ચાલો હું તમને બતાવું કે આ કેવી રીતે કરવું.
ચાલો અમારી પ્રોજેક્ટ પેનલ ખોલીએ અને પ્રોજેક્ટ પર જમણું-ક્લિક કરીએ અને નવી ફાઇલ ઉમેરીએ. અમે આ ફાઇલને "Converters.py" કહીશું.
હવે ડિફૉલ્ટ ફાઇલમાંથી કોડ કૉપિ કરો અને તેને "Converters.py" માં પેસ્ટ કરો.
આ સાથે, અમે અમારા મુખ્ય મોડ્યુલને સાફ કર્યું છે અને તે વિવિધ કાર્યોથી ફૂલેલું નથી. જેમ જેમ આપણે વર્ગો સાથે વધુ ફંક્શન્સ લખીએ છીએ, અમે તેમને તેમના અનુરૂપ મોડ્યુલોમાં મૂકીએ છીએ. મોડ્યુલમાં તમામ સંબંધિત કાર્યો અને વર્ગો હોવા જોઈએ. હવે, અમે કન્વર્ટર મોડ્યુલને અમારા એપ મોડ્યુલમાં આયાત કરવા માંગીએ છીએ. આ કરવા માટે, લખો import converters
એક્સ્ટેંશન વિના ટોચ પર “.py”.
અમે પદ્ધતિઓની જેમ ડોટ ઓપરેટરનો ઉપયોગ કરીને મોડ્યુલના સભ્યોને ઍક્સેસ કરી શકીએ છીએ.
ચાલો 70 કિલોને પાઉન્ડમાં રૂપાંતરિત કરીએ:
મોડ્યુલો આયાત કરવા માટે અન્ય સિન્ટેક્સ પણ છે. આખા મોડ્યુલને આયાત કરવાને બદલે, અમે તે મોડ્યુલમાંથી ચોક્કસ કાર્યોને આયાત કરી શકીએ છીએ. આપણે ટાઈપ કરી શકીએ છીએ from Converters import
અને ઉપલબ્ધ કાર્યોની સૂચિ બતાવવા માટે "control + space દબાવો. આ સાથે, આપણે આ ફંક્શનને સીધું કૉલ કરી શકીએ છીએ.
કસરત
અહીં તમારી કસરત છે.
આ વ્યાખ્યાનમાંથી એક કસરત સાથે સંબંધિત છે જ્યાં અમે ચર્ચા કરી હતી "આંટીઓ માટેજ્યાં અમે સૂચિમાંથી સૌથી મોટી સંખ્યા શોધવા માટે એક પ્રોગ્રામ લખ્યો હતો
numbers = [8, 3, 6, 10, 5]
max = numbers[0]
for number in numbers:
if number > max:
max = number
print(max)
આ કોડમાં હાલમાં કોઈ સંસ્થા નથી. અમારી પાસે કોઈ ફંક્શન અથવા મોડ્યુલ નથી અને પ્રોગ્રામ એક ફાઇલમાં લખાયેલ છે. તે નાના પ્રોગ્રામ્સ માટે ઠીક છે પરંતુ જેમ જેમ તમારા પ્રોગ્રામ્સ વધે છે, તમારે તમારા કોડને વર્ગો અને મોડ્યુલોમાં યોગ્ય રીતે ગોઠવવાની જરૂર છે. તેથી, આ કવાયતના ભાગ રૂપે, હું ઈચ્છું છું કે તમે એક કાર્ય લખો, તેને કૉલ કરો find_max
. આ ફંક્શને સૂચિ લેવી જોઈએ અને તે સૂચિમાં સૌથી મોટી સંખ્યા પરત કરવી જોઈએ. તે પછી આગળ વધો અને આ ફંક્શનને એક અલગ મોડ્યુલમાં મૂકો, તેને અહીંથી કાઢો અને તેને એક મોડ્યુલમાં મૂકો. utils
. આ મોડ્યુલમાં ઉપયોગિતા કાર્યોનો સમૂહ હોવો જોઈએ. આયાત કરો utils
વર્તમાન મોડ્યુલમાં મોડ્યુલ અને કૉલ કરો find_max
કાર્ય અંતે, પરિણામ મેળવો અને તેને ટર્મિનલ પર છાપો.
આ કસરત થોડી પડકારજનક છે પરંતુ સરળતાથી કરી શકાય તેવી છે.
ઉકેલ
કાર્ય વ્યાખ્યાયિત કરીને પ્રારંભ કરો find_max
અને નંબર્સ નામનું પેરામીટર ઉમેરો. આ કાર્યની અંદર, સૂચિમાં સૌથી મોટી સંખ્યા શોધવા માટે અલ્ગોરિધમ લખો.
def find_max(numbers):
max = numbers[0]
for number in numbers:
if number > max:
max = number
return max
આ કોડને મોડ્યુલ તરીકે “utils.py” ફાઇલમાં સાચવો.
અમારા મુખ્ય પ્રોગ્રામ પર પાછા, ફક્ત બેમાંથી કોઈપણ સિન્ટેક્સ દ્વારા મોડ્યુલને આયાત કરો અને ફક્ત તર્કને ચલાવો.
એક વસ્તુ, મારે તમારું ધ્યાન ખેંચવાની જરૂર છે max
. તેનું કારણ છે max
Python માં બિલ્ટ-ઇન ફંક્શન છે અને અમે તેને ફરીથી વ્યાખ્યાયિત કરી રહ્યા છીએ. તેથી આ તરફથી ચેતવણી છે પાયથોન કમ્પાઇલર કે હવે આપણે તેના બિલ્ટ-ઇન ફંક્શન તરીકે max નો ઉપયોગ કરી શકતા નથી.
Python માં બિલ્ટ-ઇન મોડ્યુલ્સ
પાયથોન પ્રમાણભૂત લાઇબ્રેરી સાથે આવે છે જેમાં સામાન્ય કાર્યો જેવા કે ઈમેઈલ મોકલવા, તારીખ અને સમય સાથે કામ કરવા, રેન્ડમ મૂલ્યો અને પાસવર્ડ્સ જનરેટ કરવા વગેરે જેવા ઘણા મોડ્યુલ હોય છે. પાયથોનમાં પહેલેથી જ ઘણા બધા મોડ્યુલ બનેલા છે જેનો અર્થ છે કે ત્યાં પહેલેથી જ ઘણી બધી કાર્યક્ષમતા છે જેનો આપણે ફરીથી ઉપયોગ કરી શકીએ છીએ. તમે આ મોડ્યુલો શોધી શકો છો અહીં.
પેકેજો
પેકેજો મૂળભૂત રીતે મોડ્યુલોની ટોચ પર અમારા કોડને ગોઠવવાની બીજી રીત છે. એક વાસ્તવિક પ્રોજેક્ટમાં સેંકડો અથવા તો હજારો મોડ્યુલો હોઈ શકે છે અને સમય જતાં અમારી ડિરેક્ટરી ઘણી બધી ફાઇલોથી ફૂલી જશે. તેથી, પેકેજની અંદર સંબંધિત મોડ્યુલોને ગોઠવવાનો વધુ સારો અભિગમ છે જે પેકેજને બહુવિધ મોડ્યુલો માટે કન્ટેનર બનાવે છે.
પ્રોજેક્ટમાં એક નવી ડિરેક્ટરી ઉમેરવામાં આવે છે અને તે ડિરેક્ટરીમાં તમામ સંબંધિત મોડ્યુલો ઉમેરવામાં આવે છે. ઉદાહરણ તરીકે, એક મોલનો વિચાર કરો. મોલમાં પુરૂષો, મહિલાઓ અને બાળકોના વસ્ત્રો માટે અલગ અલગ વિભાગો છે જે પેકેજ જેવા છે. દરેક વિભાગમાં જૂતા, ટી-શર્ટ અને જેકેટ્સ જેવા વિવિધ પ્રકારના ઉત્પાદનો માટે અલગ અલગ વિસ્તારો છે. આને મોડ્યુલો તરીકે વિચારો.
ચાલો જોઈએ, પાયથોનમાં પેકેજો કેવી રીતે બનાવવું અને વાપરવું.
પ્રથમ, પ્રોજેક્ટ પેનલમાંથી નવી ડિરેક્ટરી ઉમેરો. ચાલો તેને "ઈકોમર્સ" કહીએ. આ પેકેજમાં ઈકોમર્સ એપ્લિકેશનથી સંબંધિત તમામ મોડ્યુલ હશે.
તે હજુ પણ ખાલી ડિરેક્ટરી છે અને તેને પેકેજમાં રૂપાંતરિત કરવા માટે, આપણે તેમાં એક વિશિષ્ટ ફાઇલ બનાવવાની જરૂર છે. આ ડિરેક્ટરીમાં નવી પાયથોન ફાઇલ ઉમેરો અને તે ફાઇલને "__init__" નામ આપો. તે પાયથોનમાં એક વિશિષ્ટ સંમેલન છે અને જ્યારે પાયથોન દુભાષિયા ડિરેક્ટરીમાં આ નામની ફાઇલ જુએ છે, ત્યારે તે આ ડિરેક્ટરીને પેકેજ તરીકે માને છે.
અમારી પાસે પેકેજ બનાવવા માટે વૈકલ્પિક અને સંક્ષિપ્ત પદ્ધતિ પણ છે. ફક્ત પ્રોજેક્ટ પેનલ પર જમણું-ક્લિક કરો અને સૂચિમાંથી પાયથોન પેકેજ બનાવો. તેને "ઈકોમર્સ" નામ આપો અને બસ. તે "__init__" નામની પાયથોન ફાઇલ સાથે આપમેળે ડિરેક્ટરી બનાવશે.
હવે, ચાલો પેકેજમાં એક મોડ્યુલ બનાવીએ અને તેને “શિપિંગ” નામ આપીએ. આ મોડ્યુલમાં, ચાલો શિપિંગ ખર્ચની ગણતરી કરવા માટે એક સરળ કાર્ય બનાવીએ.
def calc_shipping():
print("calc_shipping")
અમારા મુખ્ય મોડ્યુલમાં આ ફંક્શનને એક્સેસ કરવા માટે, આપણે તેને ઈ-કોમર્સ પેકેજ દ્વારા એક્સેસ કરવું પડશે. ફરી એકવાર અમારી પાસે આ મોડ્યુલને આયાત કરવાની બે પદ્ધતિઓ છે.
પ્રથમ પદ્ધતિમાં, આપણે આખું મોડ્યુલ આયાત કરી શકીએ છીએ અને પછી ફંક્શનને સ્વતંત્ર રીતે આ રીતે કૉલ કરી શકીએ છીએ:
import eCommerce.shipping
eCommerce.shipping.calc_shipping()
જો કે, આ અભિગમ સાથે, આ મોડ્યુલને ફંક્શનમાંથી એકને કૉલ કરવા માટે તેની સાથે ઉપસર્ગ લગાવવાની જરૂર છે eCommerce.shipping.
તે ખૂબ જ વર્બોઝ છે. તેથી, પેકેજો સાથે કામ કરતી વખતે આપણે ઘણીવાર બીજા અભિગમનો ઉપયોગ કરીએ છીએ અને તેનો ઉપયોગ કરીએ છીએ from
નિવેદન
from eCommerce.shipping import calc_shipping
calc_shipping()
જો તમારી પાસે એક મોડ્યુલમાં બહુવિધ કાર્યો હોય તો તમે તેમની વચ્ચે અલ્પવિરામનો ઉપયોગ કરીને તે બધાને એક જ લાઇનમાં આયાત કરી શકો છો. ચાલો કહીએ કે અમારા શિપિંગ મોડ્યુલમાં ટેક્સની ગણતરી કરવા માટેનું બીજું કાર્ય છે. તે આ રીતે આયાત કરવામાં આવશે:
from eCommerce.shipping import calc_shipping, calc_tax
તમે વ્યક્તિગત મોડ્યુલો પણ આયાત કરી શકો છો અને પ્રોગ્રામમાં પછીના તબક્કે કૉલ કરવા માટે ફંક્શન્સ છોડી શકો છો. ચાલો મોડ્યુલ શિપિંગ આયાત કરીએ અને પછી ફંક્શનને કૉલ કરવા માટે ડોટ ઓપરેટરનો ઉપયોગ કરીએ calc_shipping.
from eCommerce import shipping
shipping.calc_shipping()
સમેટો!
પાયથોનમાં પેકેજો અને મોડ્યુલો અત્યંત મહત્વપૂર્ણ છે. ખાસ કરીને, જ્યારે તમે જેંગો જેવા ફ્રેમવર્ક સાથે કામ કરવા માંગતા હો જેનો ઉપયોગ બિલ્ડિંગ માટે થાય છે વેબ એપ્લિકેશન પાયથોન સાથે. અમે બીજા પાયથોન કોર્સ દરમિયાન ડીજેંગોને જોઈશું.
આ શ્રેણીનું આ છેલ્લું પરંપરાગત વ્યાખ્યાન હતું. આગળનું લેક્ચર આપણા સામાન્ય ફોર્મેટમાંથી વિચલિત થશે અને અમે પાયથોનમાં કેટલાક મહત્વપૂર્ણ ઉપયોગના કિસ્સાઓ શીખીશું. તે આ શ્રેણીના અંતને ચિહ્નિત કરશે અને અમે અમારી આગામી પાયથોન શ્રેણીમાં આગળ વધીશું. તે માટે ટ્યુન રહો.
એક જવાબ છોડો