ਪਾਈਥਨ ਵਿੱਚ ਕਾਲਮ ਮੁੱਲਾਂ ਦੇ ਅਧਾਰ ਤੇ ਡੇਟਾਫ੍ਰੇਮ ਕਤਾਰਾਂ ਦੀ ਚੋਣ ਕਰਨਾ

ਪਾਈਥਨ ਵਿੱਚ ਕਾਲਮ ਮੁੱਲਾਂ ਦੇ ਅਧਾਰ ਤੇ ਡੇਟਾਫ੍ਰੇਮ ਕਤਾਰਾਂ ਦੀ ਚੋਣ ਕਰਨਾ
Jules David
ਸੋਮਵਾਰ, 1 ਜੁਲਾਈ 2024 10:27:42 ਪੂ.ਦੁ.
Python

ਕਾਲਮ ਮੁੱਲਾਂ ਦੁਆਰਾ ਡੇਟਾਫ੍ਰੇਮਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਨ ਲਈ ਪਾਂਡਾ ਦੀ ਵਰਤੋਂ ਕਰਨਾ

ਪਾਈਥਨ ਵਿੱਚ ਡੇਟਾ ਦੇ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ, ਪਾਂਡਾਸ ਲਾਇਬ੍ਰੇਰੀ ਡੇਟਾ ਹੇਰਾਫੇਰੀ ਅਤੇ ਵਿਸ਼ਲੇਸ਼ਣ ਲਈ ਸ਼ਕਤੀਸ਼ਾਲੀ ਟੂਲ ਪੇਸ਼ ਕਰਦੀ ਹੈ। ਇੱਕ ਆਮ ਕੰਮ ਇੱਕ ਖਾਸ ਕਾਲਮ ਵਿੱਚ ਮੁੱਲਾਂ ਦੇ ਅਧਾਰ ਤੇ ਡੇਟਾਫ੍ਰੇਮ ਤੋਂ ਕਤਾਰਾਂ ਦੀ ਚੋਣ ਕਰਨਾ ਹੈ। ਇਹ ਓਪਰੇਸ਼ਨ SQL ਪੁੱਛਗਿੱਛ ਦੇ ਸਮਾਨ ਹੈ: ਟੇਬਲ ਤੋਂ ਚੁਣੋ * WHERE column_name = some_value.

ਇਸ ਲੇਖ ਵਿੱਚ, ਅਸੀਂ ਖੋਜ ਕਰਾਂਗੇ ਕਿ ਵੱਖ-ਵੱਖ ਤਰੀਕਿਆਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪਾਂਡਿਆਂ ਵਿੱਚ ਇਸਨੂੰ ਕਿਵੇਂ ਪ੍ਰਾਪਤ ਕਰਨਾ ਹੈ। ਭਾਵੇਂ ਤੁਸੀਂ ਇੱਕ ਸਿੰਗਲ ਮੁੱਲ ਜਾਂ ਕਈ ਮਾਪਦੰਡਾਂ ਦੁਆਰਾ ਫਿਲਟਰ ਕਰ ਰਹੇ ਹੋ, ਪਾਂਡਾ ਅਜਿਹੇ ਓਪਰੇਸ਼ਨਾਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਅਨੁਭਵੀ ਅਤੇ ਕੁਸ਼ਲ ਤਰੀਕੇ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਆਓ ਵੇਰਵਿਆਂ ਵਿੱਚ ਡੁਬਕੀ ਕਰੀਏ।

ਹੁਕਮ ਵਰਣਨ
pd.DataFrame() ਇੱਕ ਡਿਕਸ਼ਨਰੀ ਜਾਂ ਹੋਰ ਡਾਟਾ ਢਾਂਚੇ ਤੋਂ ਇੱਕ ਡਾਟਾਫ੍ਰੇਮ ਆਬਜੈਕਟ ਬਣਾਉਂਦਾ ਹੈ।
df[condition] ਇੱਕ ਸ਼ਰਤ ਦੇ ਅਧਾਰ 'ਤੇ ਡੇਟਾਫ੍ਰੇਮ ਕਤਾਰਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਦਾ ਹੈ, ਸਿਰਫ ਉਹਨਾਂ ਨੂੰ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੋ ਮਾਪਦੰਡਾਂ ਨੂੰ ਪੂਰਾ ਕਰਦੇ ਹਨ।
print() ਨਿਸ਼ਚਿਤ ਸੰਦੇਸ਼ ਜਾਂ ਡੇਟਾਫ੍ਰੇਮ ਨੂੰ ਕੰਸੋਲ ਤੇ ਆਉਟਪੁੱਟ ਕਰਦਾ ਹੈ।
df['column'] == value ਕਤਾਰਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਨ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਇੱਕ ਬੁਲੀਅਨ ਸੀਰੀਜ਼ ਬਣਾਉਂਦਾ ਹੈ ਜਿੱਥੇ ਕਾਲਮ ਨਿਰਧਾਰਤ ਮੁੱਲ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ।
df['column'] >df['column'] > value ਕਤਾਰਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਨ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਇੱਕ ਬੁਲੀਅਨ ਸੀਰੀਜ਼ ਬਣਾਉਂਦਾ ਹੈ ਜਿੱਥੇ ਕਾਲਮ ਦੇ ਮੁੱਲ ਨਿਰਧਾਰਤ ਮੁੱਲ ਤੋਂ ਵੱਧ ਹੁੰਦੇ ਹਨ।
# Comment ਕੋਡ ਦੇ ਅੰਦਰ ਸਪੱਸ਼ਟੀਕਰਨ ਜਾਂ ਨੋਟਸ ਜੋੜਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਜੋ ਸਕ੍ਰਿਪਟ ਦੇ ਹਿੱਸੇ ਵਜੋਂ ਲਾਗੂ ਨਹੀਂ ਕੀਤੇ ਜਾਂਦੇ ਹਨ।

ਪਾਂਡਿਆਂ ਵਿੱਚ ਡੇਟਾਫ੍ਰੇਮ ਕਤਾਰ ਚੋਣ ਨੂੰ ਲਾਗੂ ਕਰਨਾ

ਪ੍ਰਦਾਨ ਕੀਤੀਆਂ ਸਕ੍ਰਿਪਟਾਂ ਵਿੱਚ, ਮੁੱਖ ਕੰਮ ਖਾਸ ਕਾਲਮ ਮੁੱਲਾਂ ਦੇ ਅਧਾਰ ਤੇ ਡੇਟਾਫ੍ਰੇਮ ਤੋਂ ਕਤਾਰਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਨਾ ਹੈ, ਡੇਟਾ ਵਿਸ਼ਲੇਸ਼ਣ ਵਿੱਚ ਇੱਕ ਆਮ ਲੋੜ। ਪਹਿਲੀ ਸਕ੍ਰਿਪਟ ਪਾਂਡਾਸ ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਆਯਾਤ ਕਰਕੇ ਸ਼ੁਰੂ ਹੁੰਦੀ ਹੈ import pandas as pd. ਇਹ ਜ਼ਰੂਰੀ ਹੈ ਕਿਉਂਕਿ ਪਾਂਡਾਸ ਪਾਈਥਨ ਵਿੱਚ ਇੱਕ ਸ਼ਕਤੀਸ਼ਾਲੀ ਡੇਟਾ ਹੇਰਾਫੇਰੀ ਲਾਇਬ੍ਰੇਰੀ ਹੈ। ਅੱਗੇ, ਅਸੀਂ ਇਸਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਨਮੂਨਾ ਡੇਟਾਫ੍ਰੇਮ ਬਣਾਉਂਦੇ ਹਾਂ 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[] ਐਕਸੈਸਰ ਪੂਰਨ ਅੰਕ ਸਥਿਤੀ-ਅਧਾਰਿਤ ਹੈ, ਜਿਸ ਨਾਲ ਤੁਸੀਂ ਕਤਾਰਾਂ ਨੂੰ ਉਹਨਾਂ ਦੇ ਸੂਚਕਾਂਕ ਸਥਿਤੀਆਂ ਦੁਆਰਾ ਫਿਲਟਰ ਕਰ ਸਕਦੇ ਹੋ।

ਪਾਂਡਾਸ ਵਿੱਚ ਇੱਕ ਹੋਰ ਸ਼ਕਤੀਸ਼ਾਲੀ ਵਿਸ਼ੇਸ਼ਤਾ ਡੇਟਾਫ੍ਰੇਮ ਕਤਾਰਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਨ ਦੀ ਯੋਗਤਾ ਹੈ 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() ਡੇਟਾਫ੍ਰੇਮ ਕਤਾਰਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਨ ਲਈ ਫੰਕਸ਼ਨ?
  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() ਇੱਕ lambda ਫੰਕਸ਼ਨ ਨਾਲ ਵਿਧੀ. ਉਦਾਹਰਣ ਲਈ: 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() ਢੰਗ ਕੁਸ਼ਲ ਡਾਟਾ ਫਿਲਟਰਿੰਗ ਲਈ ਸਹਾਇਕ ਹੈ. ਇਹਨਾਂ ਤਕਨੀਕਾਂ ਵਿੱਚ ਮੁਹਾਰਤ ਹਾਸਲ ਕਰਨ ਨਾਲ ਡਾਟਾਸੈਟਾਂ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਹੇਰਾਫੇਰੀ ਅਤੇ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਨ ਦੀ ਤੁਹਾਡੀ ਯੋਗਤਾ ਵਧ ਜਾਂਦੀ ਹੈ।