പൈത്തൺ സെറ്റ്/ഫ്രോസൺസെറ്റ് ഡാറ്റാ ഘടന പഠിക്കുക - ഭാഗം 4

പൈത്തൺ ഡാറ്റാ സ്ട്രക്ചർ സീരീസിന്റെ ഈ ഭാഗം 4 ൽ, എന്താണ് ഒരു സെറ്റ്, പൈത്തണിലെ മറ്റ് ഡാറ്റാ ഘടനയിൽ നിന്ന് അത് എങ്ങനെ വ്യത്യാസപ്പെട്ടിരിക്കുന്നു, സെറ്റ് ഒബ്uജക്റ്റുകൾ എങ്ങനെ സൃഷ്ടിക്കാം, സെറ്റ് ഒബ്uജക്റ്റുകൾ ഇല്ലാതാക്കാം, സെറ്റ് ഒബ്uജക്റ്റുകളുടെ രീതികൾ എന്നിവ ഞങ്ങൾ ചർച്ച ചെയ്യും.

• ഒരു സെറ്റ് ഒബ്uജക്റ്റ് എന്നത് വ്യതിരിക്തമായ ഹാഷബിൾ ഒബ്uജക്റ്റുകളുടെ ക്രമരഹിതമായ ശേഖരമാണ്.
• സെറ്റ് ഒബ്uജക്റ്റിൽ നിന്ന് തനിപ്പകർപ്പ് ഇനങ്ങൾ സ്വയമേവ നീക്കംചെയ്യുന്നു.
• സെറ്റ് ഒബ്uജക്റ്റുകൾ ഓർഡർ ചെയ്യാത്തതിനാൽ, ഇൻഡെക്uസിംഗ്, സ്ലൈസിംഗ് ഓപ്പറേഷനൊന്നും പിന്തുണയ്uക്കുന്നില്ല.

നിലവിൽ രണ്ട് ബിൽറ്റ്-ഇൻ സെറ്റ് തരങ്ങളുണ്ട്.

1. സെറ്റ് - ഇത് മ്യൂട്ടബിൾ ആയതിനാൽ, ഇതിന് ഹാഷ് മൂല്യമില്ല, ഒരു നിഘണ്ടു കീയായോ മറ്റൊരു സെറ്റിന്റെ ഘടകമായോ ഉപയോഗിക്കാൻ കഴിയില്ല.
2. ഫ്രോസൺസെറ്റ് - മാറ്റമില്ലാത്തതും ഹാഷബിൾ - സൃഷ്ടിച്ചതിന് ശേഷം അതിന്റെ ഉള്ളടക്കം മാറ്റാൻ കഴിയില്ല; അതിനാൽ, ഇത് ഒരു നിഘണ്ടു കീയായോ മറ്റൊരു സെറ്റിന്റെ ഘടകമായോ ഉപയോഗിക്കാം.

സെറ്റ് ഒബ്ജക്റ്റ് നിർമ്മിക്കുക

കൺസ്uട്രക്uടർ രീതി ഉപയോഗിച്ച് ഒരു സെറ്റ് സൃഷ്uടിക്കുക “സെറ്റ്()” അല്ലെങ്കിൽ “{a,b,c}” ഘടകങ്ങളെ വേർതിരിക്കുന്ന കോമ ഉപയോഗിച്ച് ചുരുണ്ട ബ്രേസുകൾ ഉപയോഗിക്കുക.

ശ്രദ്ധിക്കുക: നിഘണ്ടു ഒബ്uജക്റ്റ് സൃഷ്uടിക്കുന്നതിനാൽ ശൂന്യമായ ബ്രേസുകൾ വഴി നിങ്ങൾക്ക് ഒരു സെറ്റ് ഒബ്uജക്റ്റ് നിർമ്മിക്കാൻ കഴിയില്ല.

രീതികൾ സജ്ജമാക്കുക

ലഭ്യമായ സെറ്റ് രീതികളും ആട്രിബ്യൂട്ടുകളും ലിസ്റ്റ് ചെയ്യാൻ ബിൽറ്റ്-ഇൻ “dir()” ഫംഗ്uഷൻ ഉപയോഗിക്കുക.

ഒബ്ജക്റ്റ് സജ്ജീകരിക്കാൻ ഘടകങ്ങൾ ചേർക്കുക

ഇതിനകം പറഞ്ഞതുപോലെ, സെറ്റ് ഒരു മാറ്റാവുന്ന തരമാണ്. നിങ്ങളുടെ സെറ്റ് ഒബ്uജക്റ്റ് സൃഷ്uടിച്ചുകഴിഞ്ഞാൽ അത് ചേർക്കാനും ഇല്ലാതാക്കാനും അപ്uഡേറ്റ് ചെയ്യാനും കഴിയും.

ആഡ്, അപ്uഡേറ്റ് എന്നീ രണ്ട് സെറ്റ് രീതികളെക്കുറിച്ച് നമുക്ക് സംസാരിക്കാം.

• add(elem) രീതി - ഈ രീതി ഒരു സെറ്റ് ഒബ്uജക്റ്റിലേക്ക് ഒരൊറ്റ ഘടകം ചേർക്കുന്നു.
• അപ്ഡേറ്റ് (*മറ്റുള്ളവ) രീതി - ഈ രീതി ഒരു സെറ്റ് ഒബ്ജക്റ്റിലേക്ക് ഒന്നിലധികം ഘടകങ്ങൾ ചേർക്കുന്നു. നിങ്ങൾക്ക് മാറ്റാവുന്ന/മാറ്റമില്ലാത്ത ഒബ്uജക്റ്റുകൾ ഒരു ആർഗ്യുമെന്റായി അപ്uഡേറ്റ് രീതിയിൽ കൈമാറാൻ കഴിയും.

ശ്രദ്ധിക്കുക: തനിപ്പകർപ്പുകൾ സ്വയമേവ നീക്കം ചെയ്യപ്പെടും.

ഒരു സെറ്റ് ഒബ്ജക്റ്റിൽ നിന്ന് ഘടകങ്ങൾ നീക്കം ചെയ്യുക/മായ്uക്കുക

മറ്റ് ഡാറ്റാ ഘടനാ വിഷയത്തിൽ (നിഘണ്ടു) നിങ്ങൾ മുമ്പ് കണ്ടതുപോലെ, സെറ്റിനായി നിങ്ങൾക്ക് സെറ്റ് ഒബ്uജക്റ്റ് നെയിംസ്uപെയ്uസിൽ നിന്ന് (അതായത് മെമ്മറി) ഇല്ലാതാക്കാൻ ബിൽറ്റ്-ഇൻ കീവേഡ് “ഡെൽ” ഉപയോഗിക്കാം.

ഘടകങ്ങൾ നീക്കം ചെയ്യുന്നതിനുള്ള സെറ്റ് ഒബ്uജക്uറ്റുകൾക്കുള്ള രീതികൾ ചുവടെയുണ്ട്.

• clear() – സെറ്റ് ശൂന്യമാക്കുന്ന എല്ലാ ഘടകങ്ങളും മായ്uക്കും. ഈ വ്യക്തമായ() രീതി സമാന പ്രവർത്തനക്ഷമത നൽകുന്ന മറ്റ് ഡാറ്റാ ഘടനകളിൽ ലഭ്യമാണ്.
• pop() – അനിയന്ത്രിതമായ ഘടകങ്ങൾ നീക്കം ചെയ്യുന്നു.
• നിരസിക്കുക(എലിം) - സെറ്റ് ഒബ്ജക്റ്റിൽ ഇനം കണ്ടെത്തിയില്ലെങ്കിൽ, നിരസിക്കുക() രീതി ഒരു പിശകും ഉയർത്തില്ല.
• നീക്കം ചെയ്യുക(elem) - ഡിസ്uകാർഡ്() രീതി പോലെയാണ്, എന്നാൽ ഒരു ഇനം കണ്ടെത്താനാകാതെ വരുമ്പോൾ അത് കീഎറർ ഉയർത്തും.

പ്രവർത്തനങ്ങൾ സജ്ജമാക്കുക

ഇന്റർസെക്ഷൻ, യൂണിയൻ, വ്യത്യാസം, സമമിതി വ്യത്യാസം തുടങ്ങിയ ഗണിത പ്രവർത്തനങ്ങൾ നടത്തുന്നതിനുള്ള രീതികൾ സെറ്റ് നൽകുന്നു. നിങ്ങളുടെ ഹൈസ്കൂൾ കാലത്തെ വെൻ ഡയഗ്രം ഓർക്കുന്നുണ്ടോ?

ഗണിതശാസ്ത്ര പ്രവർത്തനങ്ങൾ എങ്ങനെ നടത്തുന്നു എന്നതിനെക്കുറിച്ചുള്ള ചുവടെയുള്ള രീതികൾ ഞങ്ങൾ പരിശോധിക്കും.

• യൂണിയൻ
• കവല
• intersection_update
• സമമിതി_വ്യത്യാസം
• symmetric_difference_update
• വ്യത്യാസം
• difference_update
• isdisjoint
• സബ്സെറ്റ്
• ഇഷ്യൂപ്പർസെറ്റ്

• യൂണിയൻ(*മറ്റ്) - സെറ്റിൽ നിന്നും മറ്റെല്ലാ ഘടകങ്ങളിൽ നിന്നും ഒരു പുതിയ സെറ്റ് തിരികെ നൽകുക.
• ഇന്റർസെക്ഷൻ(*മറ്റ്) - സെറ്റിനും മറ്റെല്ലാവർക്കും പൊതുവായ ഘടകങ്ങളുള്ള ഒരു പുതിയ സെറ്റ് തിരികെ നൽകുക.
• വ്യത്യാസം(*മറ്റുള്ളവ) - മറ്റുള്ളവയിൽ ഇല്ലാത്ത ഘടകങ്ങളുള്ള ഒരു പുതിയ സെറ്റ് തിരികെ നൽകുക.
• സമമിതി_വ്യത്യാസം(മറ്റുള്ളവ) - സെറ്റിലെയോ മറ്റെന്തെങ്കിലുമോ മൂലകങ്ങളുള്ള ഒരു പുതിയ സെറ്റ് തിരികെ നൽകുക, എന്നാൽ രണ്ടും അല്ല.

intersection_update(*others) - സെറ്റ് അപ്uഡേറ്റ് ചെയ്യുക, അതിൽ കാണുന്ന ഘടകങ്ങൾ മാത്രം സൂക്ഷിക്കുക.

വ്യത്യാസം_അപ്uഡേറ്റ് (*മറ്റുള്ളവ) – സെറ്റ് അപ്uഡേറ്റ് ചെയ്യുക, അതിൽ കണ്ടെത്ത                   ഘടകങ്ങൾ                                                            എല്ലാ            എല്ലാം        അപ്uഡേറ്റ്  (* മറ്റുള്ളവ                                            എല്ലാ അപ്uഡേറ്റ  (*മറ്റുള്ളവ * മറ്റുള്ളവ          എല്ലാം   മാത്രം   അപ്uഡേറ്റ് അപ്uഡേറ്റ് (*മറ്റുള്ളവ ) -അപ്uഡേറ്റ് (*മറ്റുള്ളവ)

Symmetirich_differment_update (മറ്റുള്ളവ), സെറ്റിൽ കണ്ടെത്തിയ ഘടകങ്ങൾ മാത്രം നിലനിർത്തുക, പക്ഷേ രണ്ടിലും അല്ല.

• isdisjet (മറ്റുള്ളവ) - സെറ്റിന് മറ്റ് പക്കൽ ഘടകങ്ങളൊന്നുമില്ലെങ്കിൽ ശരിയാക്കുക. സെറ്റുകൾ വിഭജിക്കപ്പെടും
• ഇസ്uസബ്uസെറ്റ്() – സെറ്റിലെ എല്ലാ ഘടകങ്ങളും മറ്റൊരെണ്ണത്തിലാണോ എന്ന് പരീക്ഷിക്കുക.
• ഇസ്uസൂപ്പർസെറ്റ്() – മറ്റുള്ള എല്ലാ എലമെന്റുകളും സെറ്റിലാണോ         ഉണ്ടോ        പരിശോധന       ല                     ഉള്ള                                  ഇസ്uസുപ്പർസെറ്റ്.

നിങ്ങൾക്ക് കോപ്പി() രീതി ഉപയോഗിച്ച് നിലവിലുള്ള സെറ്റ് ഒബ്uജക്റ്റിന്റെ സമാന പകർപ്പ് സൃഷ്ടിക്കാൻ കഴിയും. ലിസ്റ്റ്, നിഘണ്ടു തുടങ്ങിയ മറ്റ് ഡാറ്റാ ഘടന തരങ്ങൾക്കും ഈ രീതി ലഭ്യമാണ്...

ഒരു ബിൽറ്റ്-ഇൻ ഡെൽ കീവേഡ് ഉപയോഗിച്ച് നെയിംസ്പേസിൽ നിന്ന് സെറ്റ് ഒബ്ജക്റ്റ് ഇല്ലാതാക്കുക.

• ഫ്രോസൺ സെറ്റ് മാറ്റാനാവാത്ത തരമാണ്. ഒരിക്കൽ നിർമ്മിച്ചുകഴിഞ്ഞാൽ നിങ്ങൾക്ക് ലിസ്റ്റിൽ നിന്ന് ഘടകങ്ങൾ ചേർക്കാനോ നീക്കം ചെയ്യാനോ അപ്ഡേറ്റ് ചെയ്യാനോ കഴിയില്ല.
• ഫ്രോസൺ സെറ്റ് മാറ്റാനാകാത്തത് ഹാഷബിൾ ആണ്, നിഘണ്ടുക്കൾക്കായുള്ള ഒരു കീ ആയി ഉപയോഗിക്കാം അല്ലെങ്കിൽ മറ്റൊരു സെറ്റ് ഒബ്uജക്റ്റിന്റെ ഘടകങ്ങൾ.
• ഫ്രോസൺ സെറ്റ് നിർമ്മിച്ചിരിക്കുന്നത് “ഫ്രോസൺസെറ്റ്()” ഫംഗ്uഷൻ ഉപയോഗിച്ചാണ്.
• യൂണിയൻ(), ഇന്റർസെക്ഷൻ, കോപ്പി(), isdisjoint() മുതലായ “സെറ്റ്” മായി താരതമ്യപ്പെടുത്തുമ്പോൾ ഫ്രോസൺ സെറ്റ് സമാന രീതികൾ നൽകുന്നു.

ഈ ലേഖനത്തിൽ നിങ്ങൾ എന്താണ് സജ്ജീകരിച്ചിരിക്കുന്നത്, സെറ്റും ഫ്രോസൻ സെറ്റും തമ്മിലുള്ള വ്യത്യാസം, സെറ്റ് ഘടകങ്ങൾ എങ്ങനെ സൃഷ്ടിക്കുകയും ആക്uസസ് ചെയ്യുകയും ചെയ്യാം, സെറ്റ് രീതികൾ മുതലായവ കണ്ടു ...