આ વ્યાખ્યાન પાયથોનની અન્ય આવશ્યક રચના વિશે છે, જેને ટ્યુપલ કહેવાય છે.
ટુપલ્સ
ટ્યૂપલ્સ લિસ્ટ જેવા જ હોય છે, તેથી અમે તેનો ઉપયોગ વસ્તુઓની સૂચિ સ્ટોર કરવા માટે કરી શકીએ છીએ. પરંતુ યાદીઓથી વિપરીત, અમે તેમને સંશોધિત કરી શકતા નથી, નવી આઇટમ ઉમેરી શકતા નથી અથવા હાલની વસ્તુઓને દૂર કરી શકતા નથી. આપણે કહી શકીએ કે ટ્યુપલ્સ અપરિવર્તનશીલ છે.
ચાલો હું તમને બતાવું. સૂચીઓમાં ચોરસ કૌંસને બદલે કૌંસ દ્વારા ટ્યુપલ્સને ઓળખવામાં આવે છે.
numbers = (4, 1, 7, 5, 0, 9)
હવે, જો આપણે ટ્યૂપલ માટે મેથડ લિસ્ટ બહાર કાઢીએ, તો તમે જોઈ શકો છો કે અમારી પાસે એપેન્ડ કે ઇન્સર્ટ મેથડ નથી તેથી આ ટ્યૂપલમાં નવી વસ્તુઓ ઉમેરી શકાતી નથી. અમારી પાસે ફક્ત બે પદ્ધતિઓ છે: ગણતરી અને અનુક્રમણિકા.
આઇટમની ઘટનાઓની સંખ્યા ગણવા માટે અમે "ગણતરી" નો ઉપયોગ કરીએ છીએ. "ઇન્ડેક્સ" નો ઉપયોગ આઇટમની પ્રથમ ઘટનાની અનુક્રમણિકા શોધવા માટે થાય છે. તેથી, અમે ફક્ત ટપલ વિશે માહિતી મેળવી શકીએ છીએ, અને અમે તેને બદલી શકતા નથી. માર્ગ દ્વારા, આ અન્ય પદ્ધતિઓ કે જે તમે અહીં જુઓ છો, બે અન્ડરસ્કોરથી પ્રારંભ કરો.
અમે તેને જાદુઈ પદ્ધતિઓ તરીકે ઓળખીએ છીએ. તે વધુ અદ્યતન વિષય છે, અને અમે અમારી ભાવિ શ્રેણીમાં તેમને સ્પર્શ કરીશું.
અપરિવર્તનશીલ હોવા સિવાય, ટ્યુપલ્સ સૂચિની મોટાભાગની લાક્ષણિકતાઓ શેર કરે છે.
વ્યવહારિક રીતે કહીએ તો, મોટાભાગે તમે સૂચિઓનો ઉપયોગ કરશો, પરંતુ ટ્યુપલ્સ પણ ઉપયોગી છે. જો તમે વસ્તુઓની સૂચિ બનાવવા માંગો છો અને ખાતરી કરો કે તમારા પ્રોગ્રામમાં ક્યાંય તમે ભૂલથી તે સૂચિને સંશોધિત કરી નથી, તો પછી ટ્યુપલનો ઉપયોગ કરવો વધુ સારું છે.
અનપેક કરી રહ્યું છે
આ વિભાગમાં, હું તમને એક શક્તિશાળી લક્ષણ બતાવવા જઈ રહ્યો છું, અમારી પાસે પાયથોનમાં છે જેને અનપેકિંગ કહેવાય છે.
ચાલો ટ્યુપલ "સંકલન" ને વ્યાખ્યાયિત કરીએ
coordinate = (1, 2, 3)
હવે, કલ્પના કરો કે આ 'x', 'y' અને 'z' માટેના કોઓર્ડિનેટ્સ છે. હવે ચાલો કહીએ કે, આપણે આ મૂલ્યો મેળવવા માંગીએ છીએ અને તેને અમારા પ્રોગ્રામમાં થોડા જટિલ સમીકરણોમાં વાપરીએ છીએ. કદાચ, અમે તેમને મોટા જટિલ સૂત્રના ભાગ રૂપે સામેલ કરવા માંગીએ છીએ.
તેથી, આપણે સાથે મળીને આના જેવો કોડ લખવો પડશે:
coordinate[0] * coordinate[1] * coordinate[2]
કોડની આ લાઇન તમામ કોઓર્ડિનેટ્સનો ગુણાકાર કરશે પરંતુ આ રીતે આપણો કોડ લખવા માટે તે બિનકાર્યક્ષમ છે. પ્રથમ, ચાલો વધુ સારા અભિગમનો ઉપયોગ કરીએ અને આ કોઓર્ડિનેટ્સને અલગ ચલોમાં સંગ્રહિત કરીએ.
x = coordinate[0]
y = coordinate[1]
z = coordinate[2]
તે વધુ સારું છે. ખરું ને? તેથી અત્યાર સુધી કંઈ નવું નથી. હવે, ચાલો હું તમને અનપેકિંગ નામની એક શક્તિશાળી સુવિધા બતાવીશ અને તેની સાથે, અમે ઘણા ઓછા કોડ સાથે સમાન પરિણામ પ્રાપ્ત કરી શકીએ છીએ.
x, y, z, = coordinate
હવે, કોડની આ એક લીટી ઉપર લખેલ કોડની ત્રણ લીટીઓની બરાબર સમકક્ષ છે. ચાલો હું તમને સમજાવું કે તે કેવી રીતે કાર્ય કરે છે.
જ્યારે પાયથોન ઈન્ટરપ્રીટર આ સ્ટેટમેન્ટ જુએ છે, ત્યારે તે આ ટ્યુપલમાં પ્રથમ વસ્તુ મેળવશે અને તેને વેરીએબલને સોંપશે. એ જ રીતે, બીજી અને ત્રીજી વસ્તુઓ ચલોને સોંપવામાં આવશે. આમ કરવાથી, અમે આ ટ્યૂપલને 3 ચલોમાં અનપેક કરી રહ્યા છીએ. ચાલો આપણું આઉટપુટ તપાસીએ.
અનપેકીંગ પણ યાદીઓ સાથે કરી શકાય છે.
શબ્દકોશ
આપણે પાયથોનમાં શબ્દકોશો વિશે શીખવા જઈ રહ્યા છીએ. અમે એવી પરિસ્થિતિઓમાં શબ્દકોશોનો ઉપયોગ કરીએ છીએ જ્યાં અમે કી-વેલ્યુ જોડી તરીકે આવતી માહિતી સંગ્રહિત કરવા માંગીએ છીએ.
અહીં એક ઉદાહરણ છે. નામ, ઈમેઈલ, ફોન નંબર, સરનામું વગેરે જેવા અનેક લક્ષણો ધરાવતા ગ્રાહક વિશે વિચારો. હવે આ દરેક વિશેષતાઓનું મૂલ્ય છે. દાખ્લા તરીકે:
name = Jay
email = [email protected]
આ ઉદાહરણમાં, અમારી કી નામ, ઇમેઇલ અને ફોન છે. દરેક કી મૂલ્ય સાથે સંકળાયેલ છે તેથી આ તે છે જ્યાં આપણે શબ્દકોશનો ઉપયોગ કરીએ છીએ. શબ્દકોશ સાથે, અમે કી-વેલ્યુ જોડીઓનો સમૂહ સંગ્રહિત કરી શકીએ છીએ. ચાલો હું તમને બતાવીશ કે python માં ડિક્શનરી કેવી રીતે વ્યાખ્યાયિત કરવી.
customer = {
"name": "Jay",
"email": "[email protected]",
"age": 30,
"is_verified": True
}
કી શબ્દમાળાઓ, સંખ્યાઓ, બુલિયન અથવા કોઈપણ વસ્તુ પર સેટ કરી શકાય છે. ચાવીઓ અનન્ય છે અને માત્ર એક જ વાર વ્યાખ્યાયિત કરી શકાય છે, એટલે કે હું બીજી કોઈ સંખ્યા સાથે "વય" ને ફરીથી વ્યાખ્યાયિત કરી શકતો નથી. તેઓ કેસ-સંવેદનશીલ પણ છે.
હવે, જો હું ટાઇપ કરું customer["name"],
તે ગ્રાહકના નામને બોલાવશે. ચાલો તેને ટર્મિનલ પર છાપીએ:
આપણે શબ્દકોશો સાથેની પદ્ધતિઓનો પણ ઉપયોગ કરી શકીએ છીએ. ઉપર દર્શાવેલ સમાન કાર્ય "ગેટ" પદ્ધતિનો ઉપયોગ કરીને નકલ કરી શકાય છે.
ઉપરોક્ત બે પદ્ધતિઓ વચ્ચે એક ખાસ તફાવત છે. મને તે દર્શાવવા દો.
તમે જોઈ શકો છો કે જ્યારે આપણે બિન-અસ્તિત્વવાળી કી છાપી છે, ત્યારે તે ભૂલમાં પરિણમી છે. બીજી તરફ, અસ્તિત્વમાં ન હોય તેવી કીને કૉલ કરવાની પદ્ધતિનો ઉપયોગ કરીને "કોઈ નહીં" પરિણામમાં પરિણમે છે જે મૂલ્યની ગેરહાજરી દર્શાવે છે. "ગેટ" પદ્ધતિનો ઉપયોગ કરતી વખતે, અમે ડિફોલ્ટ મૂલ્ય પણ આપી શકીએ છીએ.
ઉદાહરણ તરીકે, જો આ શબ્દકોશમાં "જન્મતારીખ" કી નથી, તો અમે તેને આ રીતે સપ્લાય કરી શકીએ છીએ:
customer.get("birthdate", "Jan 01, 1994")
અમે સૂચિની જેમ શબ્દકોશમાં કોઈપણ કીને પણ અપડેટ કરી શકીએ છીએ. ચાલો કહીએ કે અમે અમારા શબ્દકોશમાં નામ કી અપડેટ કરવા માંગીએ છીએ. અમે તે કેવી રીતે કરીશું તે અહીં છે.
customer["name"] = "Shahbaz"
અમારા શબ્દકોશમાં પણ નવી કી ઉમેરવા માટે સમાન વાક્યરચનાનો ઉપયોગ કરી શકાય છે. ચાલો સમાન રીતે કી "જન્મતારીખ" ઉમેરીએ.
customer["birthdate"] = "Jan 01, 1994"
તેથી, આ પાયથોનમાં શબ્દકોશનો ઉપયોગ કરવાની મૂળભૂત બાબતો છે. તેઓ અત્યંત મહત્વપૂર્ણ છે અને વાસ્તવિક દુનિયામાં તેમની પાસે ઘણી બધી એપ્લિકેશનો છે.
કસરત
તમે એક પ્રોગ્રામ લખવા જઈ રહ્યા છો જે અંકોને આના જેવા શબ્દોમાં રૂપાંતરિત કરે છે:
ઉકેલ
અહીં તમારા માટે ઉકેલ છે.
phone = input("Phone: ")
digits_mapping = {
"1": "One",
"2": "Two",
"3": "Three",
"4": "Four",
"5": "Five",
"6": "Six",
"7": "Seven",
"8": "Eight",
"9": "Nine",
"0": "Zero"
}
output = " "
for ch in phone:
output += digits_mapping.get(ch, "!") + " "
print(output)
એ જ રીતે, તમે "ઇમોજી કન્વર્ટર" જેવા અન્ય મનોરંજક પ્રોગ્રામ બનાવી શકો છો, પાયથોનર્સની મજા માણો!
સમેટો!
હું આશા રાખું છું કે તમે આ વ્યાખ્યાન માણ્યું હશે. આગળ, આપણે પાયથોન પ્રોગ્રામિંગ, ફંક્શન્સ અને પેરામીટર્સના નોંધપાત્ર પાસામાં ડાઇવ કરવા જઈ રહ્યા છીએ.
એક જવાબ છોડો