ಪರಿಹರಿಸಲಾಗಿದೆ: ಜನ್ಮ ದಿನಾಂಕದ ಕಾಲಮ್ ಅನ್ನು ವಯಸ್ಸಿನ ಪಾಂಡಾಗಳಿಗೆ ಪರಿವರ್ತಿಸಿ

ಇಂದಿನ ಜಗತ್ತಿನಲ್ಲಿ, ದತ್ತಾಂಶ ವಿಶ್ಲೇಷಣೆಯು ಹೆಚ್ಚು ಪ್ರಾಮುಖ್ಯತೆಯನ್ನು ಪಡೆದುಕೊಂಡಿದೆ ಮತ್ತು ದತ್ತಾಂಶ ವಿಶ್ಲೇಷಕರು ಮತ್ತು ಡೇಟಾ ವಿಜ್ಞಾನಿಗಳು ಬಳಸುವ ಅತ್ಯಂತ ಜನಪ್ರಿಯ ಸಾಧನವೆಂದರೆ ಪಾಂಡಾಸ್ ಲೈಬ್ರರಿಯೊಂದಿಗೆ ಪೈಥಾನ್. ಪಾಂಡಾಗಳು ಶಕ್ತಿಯುತವಾದ, ತೆರೆದ ಮೂಲ ಡೇಟಾ ವಿಶ್ಲೇಷಣೆ ಮತ್ತು ಮ್ಯಾನಿಪ್ಯುಲೇಷನ್ ಸಾಧನವಾಗಿದ್ದು ಅದು ಡೇಟಾ ರಚನೆಗಳು ಮತ್ತು ಸರಣಿಗಳ ಸುಲಭವಾದ ಕುಶಲತೆಯನ್ನು ಅನುಮತಿಸುತ್ತದೆ. ಬಳಕೆದಾರರು ಎದುರಿಸುವ ಒಂದು ಸಾಮಾನ್ಯ ಸಮಸ್ಯೆಯು ಹೆಚ್ಚು ನಿಖರವಾದ ಮತ್ತು ಪ್ರಾಯೋಗಿಕ ವಿಶ್ಲೇಷಣೆಗಾಗಿ ಜನ್ಮ ದಿನಾಂಕಗಳನ್ನು ವಯಸ್ಸಿಗೆ ಪರಿವರ್ತಿಸುವುದು. ಈ ಲೇಖನದಲ್ಲಿ, ಕೋಡ್ ಅನುಷ್ಠಾನದ ಸ್ಪಷ್ಟ ಉದಾಹರಣೆಗಳು ಮತ್ತು ವಿವರಣೆಗಳೊಂದಿಗೆ ಈ ಸಮಸ್ಯೆಯನ್ನು ಹೇಗೆ ಎದುರಿಸಬೇಕೆಂದು ನಾವು ಪರಿಶೀಲಿಸುತ್ತೇವೆ.

ಪಾಂಡಾಗಳು ಬಹುಮುಖ ಸಾಧನವಾಗಿದ್ದು, ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಡೇಟ್‌ಟೈಮ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ - ಜನ್ಮ ದಿನಾಂಕಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ ಇದು ಸಂಭವಿಸುತ್ತದೆ. ಜನ್ಮ ದಿನಾಂಕಗಳನ್ನು ವಯಸ್ಸಿಗೆ ಪರಿವರ್ತಿಸುವ ಮೊದಲ ಹಂತಕ್ಕೆ ಡೇಟ್‌ಟೈಮ್ ಲೈಬ್ರರಿಯೊಂದಿಗೆ ಸರಳ ಅಂಕಗಣಿತದ ಅಗತ್ಯವಿದೆ. ಇದು ವ್ಯಕ್ತಿಗಳ ಜನ್ಮ ದಿನಾಂಕ ಮತ್ತು ಪ್ರಸ್ತುತ ದಿನಾಂಕದ ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವ ಮೂಲಕ ಅವರ ವಯಸ್ಸನ್ನು ಕಂಡುಹಿಡಿಯಲು ನಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

ಅಗತ್ಯ ಗ್ರಂಥಾಲಯಗಳನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ ಪ್ರಾರಂಭಿಸೋಣ:

import pandas as pd
from datetime import datetime

ಮುಂದೆ, ವ್ಯಕ್ತಿಗಳ ಬಗ್ಗೆ ಈ ಕೆಳಗಿನ ಡೇಟಾವನ್ನು ಹೊಂದಿರುವ ಸರಳ ಡೇಟಾಸೆಟ್ ಅನ್ನು ಪರಿಗಣಿಸಿ:

data = {'Name': ['John', 'Paul', 'George', 'Ringo'],
        'Birth_Date': ['1940-10-09', '1942-06-18', '1943-02-25', '1940-07-07']
       }

df = pd.DataFrame(data)
df['Birth_Date'] = pd.to_datetime(df['Birth_Date'])

ಮೇಲಿನ ಕೋಡ್‌ನಲ್ಲಿ, ನಾವು 'Birth_Date' ಕಾಲಮ್ ಅನ್ನು DateTime ಆಬ್ಜೆಕ್ಟ್‌ಗಳಿಗೆ ಪರಿವರ್ತಿಸುತ್ತಿದ್ದೇವೆ.

ವಯಸ್ಸಿನ ಲೆಕ್ಕಾಚಾರ

ಈಗ, ಈ ವ್ಯಕ್ತಿಗಳ ಜನ್ಮ ದಿನಾಂಕ ಮತ್ತು ಪ್ರಸ್ತುತ ದಿನಾಂಕದ ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ಕಂಡುಹಿಡಿಯುವ ಮೂಲಕ ಅವರ ವಯಸ್ಸನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ನಾವು ಸಿದ್ಧರಿದ್ದೇವೆ. ಇದನ್ನು ಮಾಡಲು, ಈ ಹಂತಗಳನ್ನು ಅನುಸರಿಸಿ:

1. ಜನ್ಮದಿನಾಂಕವನ್ನು ಇನ್‌ಪುಟ್ ಆಗಿ ತೆಗೆದುಕೊಳ್ಳುವ ಮತ್ತು ವ್ಯಕ್ತಿಯ ವಯಸ್ಸನ್ನು ಹಿಂದಿರುಗಿಸುವ 'calculate_age' ಎಂಬ ಕಾರ್ಯವನ್ನು ರಚಿಸಿ.
2. ಡೇಟಾಫ್ರೇಮ್‌ನಲ್ಲಿನ 'Birth_Date' ಕಾಲಮ್‌ಗೆ ಈ ಕಾರ್ಯವನ್ನು ಅನ್ವಯಿಸಿ.

ಮೇಲಿನ ತರ್ಕವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಕೋಡ್ ಇಲ್ಲಿದೆ:

def calculate_age(birth_date):
    today = datetime.now()
    age = today.year - birth_date.year - ((today.month, today.day) <
                                          (birth_date.month, birth_date.day))
    return age

df['Age'] = df['Birth_Date'].apply(calculate_age)

ಈ ಕೋಡ್ ತುಣುಕಿನಲ್ಲಿ, ನಾವು ಜನ್ಮ_ದಿನಾಂಕವನ್ನು ಇನ್‌ಪುಟ್ ಆಗಿ ಸ್ವೀಕರಿಸುವ 'calculate_age' ಎಂಬ ಕಾರ್ಯವನ್ನು ರಚಿಸಿದ್ದೇವೆ, datetime.now() ಅನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ರಸ್ತುತ ದಿನಾಂಕವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತೇವೆ ಮತ್ತು ಪ್ರಸ್ತುತ ವರ್ಷದಿಂದ ಅವರ ಜನ್ಮ ವರ್ಷವನ್ನು ಕಳೆಯುವ ಮೂಲಕ ವ್ಯಕ್ತಿಯ ವಯಸ್ಸನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತೇವೆ. ಒಂದು ವೇಳೆ ಅವರ ಈ ವರ್ಷ ಜನ್ಮದಿನಾಂಕ ಬಂದಿಲ್ಲ, ನಾವು ಹೆಚ್ಚುವರಿ ವರ್ಷವನ್ನು ಕಳೆಯುತ್ತೇವೆ.

ಅಂತಿಮವಾಗಿ, ನಾವು ಅನ್ವಯಿಸು() ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು 'Birth_Date' ಕಾಲಮ್‌ನಲ್ಲಿ ಈ ಕಾರ್ಯವನ್ನು ಅನ್ವಯಿಸುತ್ತೇವೆ ಮತ್ತು ಡೇಟಾಫ್ರೇಮ್‌ನಲ್ಲಿ ಹೊಸ 'ವಯಸ್ಸು' ಕಾಲಮ್‌ನಲ್ಲಿ ಲೆಕ್ಕಾಚಾರ ಮಾಡಿದ ವಯಸ್ಸನ್ನು ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ.

ವಯಸ್ಸಿನ ಲೆಕ್ಕಾಚಾರಕ್ಕಾಗಿ ನಂಬಿ ಮತ್ತು ಪಾಂಡಾಗಳನ್ನು ಬಳಸುವುದು

ಪರ್ಯಾಯವಾಗಿ, ಈ ಕಾರ್ಯಕ್ಕಾಗಿ ನಾವು ಪಾಂಡಾಗಳ ಸಂಯೋಜನೆಯಲ್ಲಿ ಶಕ್ತಿಯುತವಾದ ನಂಬಿ ಲೈಬ್ರರಿಯನ್ನು ಬಳಸಿಕೊಳ್ಳಬಹುದು. ನಂಬಿ ಬಳಸಿ ಜನ್ಮ ದಿನಾಂಕಗಳನ್ನು ವಯಸ್ಸಿಗೆ ಪರಿವರ್ತಿಸಲು, ಈ ಹಂತಗಳನ್ನು ಅನುಸರಿಸಿ:

1. ನಂಬಿ ಲೈಬ್ರರಿಯನ್ನು ಆಮದು ಮಾಡಿ.
2. ವಯಸ್ಸನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು numpy 'floor' ಕಾರ್ಯವನ್ನು ಬಳಸಿ.

ಇದನ್ನು ಹೇಗೆ ಮಾಡಬೇಕೆಂಬುದರ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:

import numpy as np

df['Age'] = np.floor((datetime.now() - df['Birth_Date']).dt.days / 365.25)

ಈ ಕೋಡ್ ನಮ್ಪಿಯ 'ಫ್ಲೋರ್' ಫಂಕ್ಷನ್ ಅನ್ನು ಫ್ಲೋಟಿಂಗ್-ಪಾಯಿಂಟ್ ಡಿವಿಷನ್ ಫಲಿತಾಂಶವನ್ನು ಪೂರ್ತಿಗೊಳಿಸಲು ಬಳಸುತ್ತದೆ. ದಿನಗಳ ಸಂಖ್ಯೆ ಹುಟ್ಟಿದ ದಿನಾಂಕದಿಂದ 365.25 (ಅಧಿಕ ವರ್ಷಗಳನ್ನು ಗಣನೆಗೆ ತೆಗೆದುಕೊಂಡು).

ಸಾರಾಂಶದಲ್ಲಿ, ಪಾಂಡಾಗಳು ಮತ್ತು ಡೇಟ್‌ಟೈಮ್ ಅಥವಾ ಪಾಂಡಾಗಳು ಮತ್ತು ನಂಬಿಗಳಂತಹ ಲೈಬ್ರರಿಗಳನ್ನು ನಿಯಂತ್ರಿಸುವ ಮೂಲಕ, ಡೇಟಾಸೆಟ್‌ನಲ್ಲಿ ಜನ್ಮ ದಿನಾಂಕದ ಕಾಲಮ್‌ಗಳನ್ನು ವಯಸ್ಸಿಗೆ ಪರಿವರ್ತಿಸಲು ಇದು ತಡೆರಹಿತವಾಗಿರುತ್ತದೆ. ವಿವರಿಸಿದ ಹಂತಗಳನ್ನು ಅನುಸರಿಸಿ ಮತ್ತು ಈ ಲೇಖನದಲ್ಲಿ ಒದಗಿಸಲಾದ ಕೋಡ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಅಂತಹ ಡೇಟಾವನ್ನು ಕುಶಲತೆಯಿಂದ ಮತ್ತು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿ ಮತ್ತು ನಿಖರವಾದ ವಿಶ್ಲೇಷಣೆಯನ್ನು ಕೈಗೊಳ್ಳಲು ನಿಮಗೆ ಜ್ಞಾನವನ್ನು ನೀಡುತ್ತದೆ.