പൈത്തണിലെ കോളം മൂല്യങ്ങളെ അടിസ്ഥാനമാക്കി ഡാറ്റാഫ്രെയിം വരികൾ തിരഞ്ഞെടുക്കുന്നു

കോളം മൂല്യങ്ങൾ അനുസരിച്ച് ഡാറ്റ ഫ്രെയിമുകൾ ഫിൽട്ടർ ചെയ്യാൻ പാണ്ടകൾ ഉപയോഗിക്കുന്നു

പൈത്തണിൽ ഡാറ്റയുമായി പ്രവർത്തിക്കുമ്പോൾ, ഡാറ്റ കൈകാര്യം ചെയ്യുന്നതിനും വിശകലനം ചെയ്യുന്നതിനുമുള്ള ശക്തമായ ടൂളുകൾ പാണ്ടാസ് ലൈബ്രറി വാഗ്ദാനം ചെയ്യുന്നു. ഒരു നിർദ്ദിഷ്ട കോളത്തിലെ മൂല്യങ്ങളെ അടിസ്ഥാനമാക്കി ഒരു ഡാറ്റാഫ്രെയിമിൽ നിന്ന് വരികൾ തിരഞ്ഞെടുക്കുന്നതാണ് ഒരു പൊതു ചുമതല. ഈ പ്രവർത്തനം SQL ചോദ്യത്തിന് സമാനമാണ്: പട്ടികയിൽ നിന്ന് തിരഞ്ഞെടുക്കുക * എവിടെയാണ് column_name = some_value.

ഈ ലേഖനത്തിൽ, വിവിധ രീതികൾ ഉപയോഗിച്ച് പാണ്ടകളിൽ ഇത് എങ്ങനെ നേടാമെന്ന് ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്യും. നിങ്ങൾ ഒരൊറ്റ മൂല്യമോ ഒന്നിലധികം മാനദണ്ഡങ്ങളോ ഉപയോഗിച്ച് ഫിൽട്ടർ ചെയ്യുകയാണെങ്കിലും, അത്തരം പ്രവർത്തനങ്ങൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള അവബോധജന്യവും കാര്യക്ഷമവുമായ വഴികൾ പാണ്ടസ് നൽകുന്നു. വിശദാംശങ്ങളിലേക്ക് കടക്കാം.

പാണ്ടസിൽ ഡാറ്റാഫ്രെയിം വരി തിരഞ്ഞെടുക്കൽ നടപ്പിലാക്കുന്നു

നൽകിയിരിക്കുന്ന സ്ക്രിപ്റ്റുകളിൽ, ഡാറ്റാ വിശകലനത്തിലെ പൊതുവായ ആവശ്യകതയായ നിർദ്ദിഷ്ട കോളം മൂല്യങ്ങളെ അടിസ്ഥാനമാക്കി ഒരു ഡാറ്റാഫ്രെയിമിൽ നിന്ന് വരികൾ ഫിൽട്ടർ ചെയ്യുക എന്നതാണ് പ്രധാന ചുമതല. പാണ്ഡാസ് ലൈബ്രറി ഇറക്കുമതി ചെയ്തുകൊണ്ടാണ് ആദ്യ സ്ക്രിപ്റ്റ് ആരംഭിക്കുന്നത് import pandas as pd. പൈത്തണിലെ ശക്തമായ ഡാറ്റാ മാനിപ്പുലേഷൻ ലൈബ്രറിയായതിനാൽ ഇത് അത്യന്താപേക്ഷിതമാണ്. അടുത്തതായി, ഞങ്ങൾ ഒരു സാമ്പിൾ DataFrame ഉപയോഗിച്ച് സൃഷ്ടിക്കുന്നു pd.DataFrame() പേരുകൾ, പ്രായങ്ങൾ, നഗരങ്ങൾ എന്നിവയ്‌ക്കായുള്ള ഡാറ്റ അടങ്ങുന്ന ഒരു നിഘണ്ടുവിനൊപ്പം. ടാബ്ലർ ഡാറ്റ എളുപ്പത്തിൽ ദൃശ്യവൽക്കരിക്കാനും കൈകാര്യം ചെയ്യാനും ഈ ഘടന ഞങ്ങളെ അനുവദിക്കുന്നു. സ്‌ക്രിപ്റ്റിൻ്റെ നിർണായക ഭാഗം നമ്മൾ എവിടെയാണ് വരികൾ ഫിൽട്ടർ ചെയ്യുന്നത് df[df['city'] == 'New York']. ഈ കമാൻഡ് സിറ്റി കോളത്തിൻ്റെ മൂല്യം 'ന്യൂയോർക്ക്' ആയ എല്ലാ വരികളും തിരഞ്ഞെടുക്കുന്നു. ഫലം വേരിയബിളിൽ സംഭരിച്ചിരിക്കുന്നു ny_rows, അത് പിന്നീട് ഫിൽട്ടർ ചെയ്ത ഡാറ്റാഫ്രെയിം പ്രദർശിപ്പിക്കുന്നതിന് പ്രിൻ്റ് ചെയ്യുന്നു.

രണ്ടാമത്തെ സ്ക്രിപ്റ്റ് സമാനമായ ഒരു ഘടന പിന്തുടരുന്നു, പക്ഷേ ഒരു സംഖ്യാ വ്യവസ്ഥയെ അടിസ്ഥാനമാക്കി വരികൾ ഫിൽട്ടർ ചെയ്യുന്നതിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നു. പാണ്ടകളെ ഇമ്പോർട്ടുചെയ്‌ത് ഉൽപ്പന്നം, വില, അളവ് കോളങ്ങൾ എന്നിവ ഉപയോഗിച്ച് ഒരു ഡാറ്റാഫ്രെയിം സൃഷ്‌ടിച്ച ശേഷം, സ്‌ക്രിപ്റ്റ് ഉപയോഗിക്കുന്നു df[df['price'] > 150] വില 150-ൽ കൂടുതലുള്ള വരികൾ ഫിൽട്ടർ ചെയ്യാൻ. ഈ കമാൻഡ് യഥാർത്ഥ ഡാറ്റാഫ്രെയിമിൻ്റെ ഒരു ഉപവിഭാഗം നിർമ്മിക്കുന്നു, നിർദ്ദിഷ്ട വ്യവസ്ഥ പാലിക്കുന്ന വരികൾ മാത്രം അടങ്ങിയിരിക്കുന്നു. ഫലം സംഭരിച്ചിരിക്കുന്നു expensive_products സ്ഥിരീകരണത്തിനായി അച്ചടിക്കുകയും ചെയ്തു. രണ്ട് സ്ക്രിപ്റ്റുകളും ഡാറ്റ കൃത്രിമത്വത്തിനായി പാണ്ടകളുടെ ശക്തിയും ലാളിത്യവും പ്രകടമാക്കുന്നു. ഡാറ്റ ഫിൽട്ടർ ചെയ്യുന്നതിനായി ശരി/തെറ്റായ മൂല്യങ്ങളുടെ ഒരു ശ്രേണി കൈമാറുന്ന ഒരു രീതിയായ ബൂളിയൻ ഇൻഡക്‌സിംഗ് ഉപയോഗിക്കുന്നതിലൂടെ, വിവിധ വ്യവസ്ഥകളെ അടിസ്ഥാനമാക്കി നമുക്ക് ഡാറ്റയുടെ ഉപസെറ്റുകൾ കാര്യക്ഷമമായി തിരഞ്ഞെടുക്കാനാകും, ഇത് ഡാറ്റാ അനലിസ്റ്റുകൾക്കും ശാസ്ത്രജ്ഞർക്കും അമൂല്യമായ ഉപകരണമാക്കി മാറ്റുന്നു.

കോളം മൂല്യങ്ങളെ അടിസ്ഥാനമാക്കി ഒരു ഡാറ്റ ഫ്രെയിമിൽ വരികൾ ഫിൽട്ടർ ചെയ്യുന്നു

പൈത്തൺ - ഡാറ്റാഫ്രെയിം പ്രവർത്തനങ്ങൾക്കായി പാണ്ടകൾ ഉപയോഗിക്കുന്നു

import pandas as pd
# Create a sample DataFrame
data = {
    'name': ['Alice', 'Bob', 'Charlie', 'David', 'Edward'],
    'age': [24, 27, 22, 32, 29],
    'city': ['New York', 'Los Angeles', 'New York', 'Chicago', 'Los Angeles']
}
df = pd.DataFrame(data)

# Select rows where city is New York
ny_rows = df[df['city'] == 'New York']
print(ny_rows)

# Output:
#       name  age      city
# 0    Alice   24  New York
# 2  Charlie   22  New York

കോളം മൂല്യങ്ങളെ അടിസ്ഥാനമാക്കി ഡാറ്റാഫ്രെയിം വരികൾ അന്വേഷിക്കുന്നു

പൈത്തൺ - പാണ്ടകൾക്കൊപ്പം വിപുലമായ ഫിൽട്ടറിംഗ്

import pandas as pd

# Create a sample DataFrame
data = {
    'product': ['A', 'B', 'C', 'D'],
    'price': [100, 150, 200, 250],
    'quantity': [30, 50, 20, 40]
}
df = pd.DataFrame(data)

# Select rows where price is greater than 150
expensive_products = df[df['price'] > 150]
print(expensive_products)

# Output:
#   product  price  quantity
# 2       C    200        20
# 3       D    250        40

ഡാറ്റാഫ്രെയിം വരികൾ തിരഞ്ഞെടുക്കുന്നതിനുള്ള വിപുലമായ സാങ്കേതിക വിദ്യകൾ

ബൂളിയൻ ഇൻഡക്‌സിംഗ് ഉപയോഗിച്ചുള്ള അടിസ്ഥാന ഫിൽട്ടറിംഗിന് പുറമേ, കോളം മൂല്യങ്ങളെ അടിസ്ഥാനമാക്കി വരികൾ തിരഞ്ഞെടുക്കുന്നതിനുള്ള കൂടുതൽ നൂതന സാങ്കേതിക വിദ്യകൾ പാണ്ടസ് വാഗ്ദാനം ചെയ്യുന്നു. അത്തരത്തിലുള്ള ഒരു രീതിയാണ് query() ഫംഗ്ഷൻ, ഡാറ്റാഫ്രെയിം വരികൾ ഫിൽട്ടർ ചെയ്യുന്നതിന് SQL-പോലുള്ള വാക്യഘടന ഉപയോഗിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് ഉപയോഗിക്കാം df.query('age > 25 and city == "New York"') 25 വയസ്സിനു മുകളിൽ പ്രായമുള്ളതും നഗരം ന്യൂയോർക്കിലുള്ളതുമായ വരികൾ തിരഞ്ഞെടുക്കാൻ. ഈ രീതിക്ക് നിങ്ങളുടെ കോഡ് കൂടുതൽ വായിക്കാൻ കഴിയും, പ്രത്യേകിച്ച് സങ്കീർണ്ണമായ അവസ്ഥകൾക്ക്. കൂടാതെ, പാണ്ഡാസ് നൽകുന്നു loc[] ഒപ്പം iloc[] കൂടുതൽ കൃത്യമായ വരി തിരഞ്ഞെടുക്കുന്നതിനുള്ള ആക്‌സസറുകൾ. ദി loc[] ആക്‌സസർ ലേബൽ അധിഷ്‌ഠിതമാണ്, അതായത് നിങ്ങൾക്ക് വരികൾ അവയുടെ ലേബലുകൾ അല്ലെങ്കിൽ ഒരു ബൂളിയൻ അറേ ഉപയോഗിച്ച് ഫിൽട്ടർ ചെയ്യാം. വിപരീതമായി, ദി iloc[] ആക്‌സസ്സർ പൂർണ്ണസംഖ്യ സ്ഥാനത്തെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്, ഇത് വരികളുടെ സൂചിക സ്ഥാനങ്ങൾ അനുസരിച്ച് ഫിൽട്ടർ ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

പാണ്ഡാസിലെ മറ്റൊരു ശക്തമായ സവിശേഷത, ഉപയോഗിച്ച് DataFrame വരികൾ ഫിൽട്ടർ ചെയ്യാനുള്ള കഴിവാണ് isin() രീതി. മൂല്യങ്ങളുടെ പട്ടികയെ അടിസ്ഥാനമാക്കി വരികൾ ഫിൽട്ടർ ചെയ്യേണ്ടിവരുമ്പോൾ ഈ രീതി ഉപയോഗപ്രദമാണ്. ഉദാഹരണത്തിന്, df[df['city'].isin(['New York', 'Los Angeles'])] നഗര നിരയുടെ മൂല്യം ന്യൂയോർക്ക് അല്ലെങ്കിൽ ലോസ് ഏഞ്ചൽസ് ആയിരിക്കുന്ന വരികൾ തിരഞ്ഞെടുക്കുന്നു. കൂടാതെ, നിങ്ങൾക്ക് ഇത് ഉപയോഗിച്ച് ഒന്നിലധികം വ്യവസ്ഥകൾ ചെയിൻ ചെയ്യാൻ കഴിയും & ഒപ്പം | കൂടുതൽ സങ്കീർണ്ണമായ ഫിൽട്ടറുകൾ സൃഷ്ടിക്കാൻ ഓപ്പറേറ്റർമാർ. ഉദാഹരണത്തിന്, df[(df['age'] > 25) & (df['city'] == 'New York')] 25 വയസ്സിന് മുകളിലുള്ള വരികൾ ഫിൽട്ടർ ചെയ്യുന്നു, നഗരം ന്യൂയോർക്ക് ആണ്. ഈ നൂതന സാങ്കേതിക വിദ്യകൾ ഡാറ്റ ഫിൽട്ടറിംഗിനായി ശക്തമായ ഒരു ചട്ടക്കൂട് നൽകുന്നു, ഡാറ്റാ വിശകലനത്തിനും കൃത്രിമത്വത്തിനുമുള്ള ഒരു ബഹുമുഖ ഉപകരണമാക്കി പാണ്ടകളെ മാറ്റുന്നു.

പാണ്ടസിലെ ഡാറ്റാഫ്രെയിം വരികൾ തിരഞ്ഞെടുക്കുന്നതിനെക്കുറിച്ചുള്ള പൊതുവായ ചോദ്യങ്ങൾ

1. ഒന്നിലധികം കോളം മൂല്യങ്ങളെ അടിസ്ഥാനമാക്കി ഡാറ്റാഫ്രെയിമിലെ വരികൾ എങ്ങനെ ഫിൽട്ടർ ചെയ്യാം?
2. ഒന്നിലധികം വ്യവസ്ഥകൾ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ബൂളിയൻ ഇൻഡക്‌സിംഗ് ഉപയോഗിക്കാം & ഒപ്പം |. ഉദാഹരണത്തിന്: df[(df['age'] > 25) & (df['city'] == 'New York')].
3. എന്താണ് തമ്മിലുള്ള വ്യത്യാസം loc[] ഒപ്പം iloc[]?
4. loc[] ലേബൽ അടിസ്ഥാനമാക്കിയുള്ളതാണ്, അതേസമയം iloc[] പൂർണ്ണസംഖ്യ സ്ഥാനം അടിസ്ഥാനമാക്കിയുള്ളതാണ്. ഉപയോഗിക്കുക loc[] ലേബലുകൾ ഉപയോഗിച്ച് ഫിൽട്ടർ ചെയ്യുന്നതിനും iloc[] സൂചിക സ്ഥാനങ്ങൾ ഉപയോഗിച്ച് ഫിൽട്ടർ ചെയ്യുന്നതിന്.
5. എനിക്ക് എങ്ങനെ ഉപയോഗിക്കാം query() DataFrame വരികൾ ഫിൽട്ടർ ചെയ്യുന്നതിനുള്ള പ്രവർത്തനം?
6. ദി query() SQL പോലുള്ള വാക്യഘടന ഉപയോഗിക്കാൻ ഫംഗ്ഷൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഉദാഹരണത്തിന്: df.query('age > 25 and city == "New York"').
7. മൂല്യങ്ങളുടെ ഒരു ലിസ്റ്റ് അടിസ്ഥാനമാക്കി എനിക്ക് വരികൾ ഫിൽട്ടർ ചെയ്യാൻ കഴിയുമോ?
8. അതെ, നിങ്ങൾക്ക് ഉപയോഗിക്കാം isin() രീതി. ഉദാഹരണത്തിന്: df[df['city'].isin(['New York', 'Los Angeles'])].
9. സ്ട്രിംഗ് മാച്ചിംഗിനെ അടിസ്ഥാനമാക്കി വരികൾ ഫിൽട്ടർ ചെയ്യുന്നതിനുള്ള മികച്ച മാർഗം ഏതാണ്?
10. നിങ്ങൾക്ക് ഉപയോഗിക്കാം str.contains() രീതി. ഉദാഹരണത്തിന്: df[df['city'].str.contains('New')].
11. കോളം മൂല്യങ്ങൾ നഷ്ടപ്പെട്ട വരികൾ എങ്ങനെ തിരഞ്ഞെടുക്കാം?
12. നിങ്ങൾക്ക് ഉപയോഗിക്കാം isna() രീതി. ഉദാഹരണത്തിന്: df[df['age'].isna()].
13. ഒരു ഇഷ്‌ടാനുസൃത ഫംഗ്‌ഷൻ ഉപയോഗിച്ച് എനിക്ക് എങ്ങനെ വരികൾ ഫിൽട്ടർ ചെയ്യാം?
14. നിങ്ങൾക്ക് ഉപയോഗിക്കാം apply() ഒരു ലാംഡ ഫംഗ്ഷനോടുകൂടിയ രീതി. ഉദാഹരണത്തിന്: df[df.apply(lambda row: row['age'] > 25, axis=1)].
15. സൂചിക മൂല്യങ്ങളെ അടിസ്ഥാനമാക്കി എനിക്ക് വരികൾ ഫിൽട്ടർ ചെയ്യാൻ കഴിയുമോ?
16. അതെ, നിങ്ങൾക്ക് ഉപയോഗിക്കാം index.isin() രീതി. ഉദാഹരണത്തിന്: df[df.index.isin([1, 3, 5])].

ഡാറ്റാഫ്രെയിം വരി തിരഞ്ഞെടുക്കുന്നതിനുള്ള പ്രധാന ടേക്ക്അവേകൾ

കോളം മൂല്യങ്ങളെ അടിസ്ഥാനമാക്കി ഡാറ്റാഫ്രെയിമിൽ നിന്ന് വരികൾ തിരഞ്ഞെടുക്കുന്നത് പാണ്ടകളുമായുള്ള ഡാറ്റാ വിശകലനത്തിലെ ഒരു അടിസ്ഥാന വൈദഗ്ധ്യമാണ്. ബൂളിയൻ ഇൻഡക്‌സിംഗ് ഉപയോഗിക്കുന്നത്, loc[], iloc[], query(), ഒപ്പം isin() കാര്യക്ഷമമായ ഡാറ്റ ഫിൽട്ടറിംഗ് രീതികൾ അനുവദിക്കുന്നു. ഈ സാങ്കേതിക വിദ്യകളിൽ പ്രാവീണ്യം നേടുന്നത് ഡാറ്റാസെറ്റുകൾ ഫലപ്രദമായി കൈകാര്യം ചെയ്യാനും വിശകലനം ചെയ്യാനുമുള്ള നിങ്ങളുടെ കഴിവ് വർദ്ധിപ്പിക്കുന്നു.