14: നെസ്റ്റഡ് ഡാറ്റയും ഘടന തിരഞ്ഞെടുക്കലും
യഥാർത്ഥ ഡാറ്റ പലപ്പോഴും ഒറ്റ ലിസ്റ്റോ ഒറ്റ ഡിക്ഷനറിയോ അല്ല — അവ ഒന്നിനുള്ളിൽ ഒന്നായി സംയോജിപ്പിച്ചാണ് കാണപ്പെടുന്നത്. ഉദാഹരണത്തിന്, ഒരു ക്ലാസ്സിലെ എല്ലാ വിദ്യാർത്ഥികളുടെയും വിവരങ്ങൾ സൂക്ഷിക്കണമെങ്കിൽ, ഓരോ വിദ്യാർത്ഥിക്കും ഒരു ഡിക്ഷനറി, അവയെല്ലാം ഒരു ലിസ്റ്റിനുള്ളിൽ എന്ന രീതി വേണ്ടി വരും.
ലിസ്റ്റ് ഓഫ് ഡിക്ഷനറികൾ
ഒരേ ആകൃതിയിലുള്ള പല റെക്കോർഡുകൾ (ഉദാ: പല വിദ്യാർത്ഥികൾ) സൂക്ഷിക്കാൻ ഏറ്റവും സാധാരണമായ രീതി ഇതാണ്: ഓരോ റെക്കോർഡും ഒരു ഡിക്ഷനറി, അവയെല്ലാം ഒരു ലിസ്റ്റിനുള്ളിൽ.
students = [
{"name": "Anu", "marks": 90},
{"name": "Ravi", "marks": 75},
{"name": "Meera", "marks": 82}
]
print(students[0])
print(students[0]["name"])students[0] ലിസ്റ്റിലെ ആദ്യത്തെ ഡിക്ഷനറി തരുന്നു. students[0]["name"] ആ ഡിക്ഷനറിയിലെ "name" എന്ന കീയുടെ മൂല്യം തരുന്നു.
students = [
{"name": "Anu", "marks": 90},
{"name": "Ravi", "marks": 75}
]
for student in students:
print(student["name"], "-", student["marks"])ഡിക്ഷനറിക്കുള്ളിൽ ലിസ്റ്റ്
മറിച്ചും ചെയ്യാം — ഒരു ഡിക്ഷനറി വാല്യൂ ആയി ഒരു ലിസ്റ്റ് സൂക്ഷിക്കാം.
class_info = {
"class_name": "10A",
"students": ["Anu", "Ravi", "Meera"]
}
print(class_info["students"])
print(class_info["students"][0])നെസ്റ്റഡ് ഡിക്ഷനറി
ഒരു ഡിക്ഷനറിയുടെ മൂല്യമായി മറ്റൊരു ഡിക്ഷനറി തന്നെ വെക്കാം.
person = {
"name": "Anu",
"address": {
"city": "Kochi",
"pin": "682001"
}
}
print(person["address"])
print(person["address"]["city"])ഓരോ [] ഒരു ഘട്ടം അകത്തേക്ക് പോകുന്നു — person["address"]["city"] എന്നാൽ ആദ്യം "address" എന്ന കീയിലേക്ക്, എന്നിട്ട് അതിനുള്ളിലെ "city" എന്ന കീയിലേക്ക്.
നെസ്റ്റഡ് ഡാറ്റ അപ്ഡേറ്റ് ചെയ്യുന്നു
students = [
{"name": "Anu", "marks": 90},
{"name": "Ravi", "marks": 75}
]
students[1]["marks"] = 80 # Ravi-യുടെ മാർക്ക് അപ്ഡേറ്റ് ചെയ്യുന്നു
print(students)ഏത് ഘടന എപ്പോൾ ഉപയോഗിക്കണം
| ഘടന | ക്രമം ഉണ്ടോ? | മാറ്റാമോ? | ആവർത്തനം അനുവദനീയമോ? | എപ്പോൾ ഉപയോഗിക്കും |
|---|---|---|---|---|
ലിസ്റ്റ് [] | അതെ | അതെ | അതെ | ഒരേ തരം ഇനങ്ങളുടെ ക്രമപ്പെടുത്തിയ ശേഖരം |
ട്യൂപ്പിൾ () | അതെ | ഇല്ല | അതെ | മാറാൻ പാടില്ലാത്ത, സ്ഥിരമായ ഡാറ്റ |
സെറ്റ് {} | ഇല്ല | അതെ | ഇല്ല | യൂണിക് മൂല്യങ്ങൾ, വേഗത്തിലുള്ള മെമ്പർഷിപ്പ് പരിശോധന |
ഡിക്ഷനറി {} | അതെ* | അതെ | കീ ആവർത്തിക്കില്ല | കീ ഉപയോഗിച്ച് പെട്ടെന്ന് കണ്ടെത്തേണ്ട ഡാറ്റ |
*പൈത്തൺ 3.7 മുതൽ, ഡിക്ഷനറികൾ ഇനങ്ങൾ ചേർത്ത ക്രമം ഓർത്തുവെക്കുന്നു — പക്ഷേ ഡിക്ഷനറിയുടെ പ്രധാന ഉദ്ദേശ്യം ക്രമമല്ല, കീ വഴി വേഗത്തിൽ കണ്ടെത്തലാണ്.
യഥാർത്ഥ ജീവിത ഉദാഹരണം: ചെറിയ വിദ്യാർത്ഥി ഡാറ്റാബേസ്
students = [
{"name": "Anu", "marks": 90},
{"name": "Ravi", "marks": 65},
{"name": "Meera", "marks": 82}
]
total = 0
for student in students:
total += student["marks"]
average = total / len(students)
print(f"Average marks: {average}")
print("Students above 80:")
for student in students:
if student["marks"] > 80:
print(student["name"])സാധാരണ തുടക്കക്കാരുടെ തെറ്റുകൾ
- ലിസ്റ്റ് ഇൻഡെക്സും ഡിക്ഷനറി കീയും മാറിപ്പോകുന്നു (
students[0]["name"]എന്നത് ശ്രദ്ധയോടെ എഴുതണം) - നെസ്റ്റഡ് ഡിക്ഷനറിയിലെ ഒരു കീയുടെ പേര് തെറ്റായി എഴുതി
KeyErrorവരുത്തുന്നു - ഏത് ഘടന വേണമെന്ന് ചിന്തിക്കാതെ, എപ്പോഴും ലിസ്റ്റ് മാത്രം ഉപയോഗിക്കുന്നു
ഈ അധ്യായത്തിന്റെ സംഗ്രഹം
- ലിസ്റ്റ് ഓഫ് ഡിക്ഷനറികൾ ഉപയോഗിച്ചു
- ഡിക്ഷനറിക്കുള്ളിൽ ലിസ്റ്റും, ഡിക്ഷനറിക്കുള്ളിൽ ഡിക്ഷനറിയും ഉപയോഗിച്ചു
- നെസ്റ്റഡ് ഡാറ്റ ആക്സസ് ചെയ്യാനും അപ്ഡേറ്റ് ചെയ്യാനും പഠിച്ചു
- ലിസ്റ്റ്, ട്യൂപ്പിൾ, സെറ്റ്, ഡിക്ഷനറി എന്നിവ എപ്പോൾ ഉപയോഗിക്കണം എന്ന് താരതമ്യം ചെയ്തു
- ഒരു ചെറിയ വിദ്യാർത്ഥി ഡാറ്റാബേസ് ഉദാഹരണം പരീക്ഷിച്ചു
വ്യായാമങ്ങൾ
- 3 പുസ്തകങ്ങളുടെ വിവരം (പേര്, രചയിതാവ്) ഓരോ ഡിക്ഷനറിയായി, എല്ലാം ഒരു ലിസ്റ്റിനുള്ളിൽ സൂക്ഷിച്ച്, ലൂപ്പ് ഉപയോഗിച്ച് പ്രിന്റ് ചെയ്യുക
- ഒരു വ്യക്തിയുടെ പേരും, ഒരു നെസ്റ്റഡ് ഡിക്ഷനറിയായി വിലാസവും (നഗരം, പിൻ കോഡ്) സൂക്ഷിച്ച് ആക്സസ് ചെയ്യുക
- വിദ്യാർത്ഥികളുടെ ലിസ്റ്റ് ഓഫ് ഡിക്ഷനറികളിൽ നിന്ന്, ഏറ്റവും കൂടുതൽ മാർക്ക് നേടിയ വിദ്യാർത്ഥിയെ ലൂപ്പ് ഉപയോഗിച്ച് കണ്ടെത്തുക
Quiz & Self Assessment
students = [{"name": "Anu"}] എന്നതിൽ, "Anu" എന്ന മൂല്യം എങ്ങനെ ആക്സസ് ചെയ്യാം?അടുത്ത അധ്യായത്തിൽ, കോഡ് ആവർത്തിക്കാതെ പുനരുപയോഗിക്കാൻ സഹായിക്കുന്ന ഫംഗ്ഷനുകൾ നിങ്ങൾ പഠിക്കും.