ಪಾಂಡಾಸ್ ಡೇಟಾಫ್ರೇಮ್ ರಚನೆಯ ಕೌಶಲ್ಯವನ್ನು ಪಡೆದುಕೊಳ್ಳಿ. ಜಾಗತಿಕ ಡೇಟಾ ವೃತ್ತಿಪರರಿಗೆ ಡಿಕ್ಷನರಿಗಳು, ಲಿಸ್ಟ್‌ಗಳು, ನಂಪಿ ಅರೇಗಳು ಮತ್ತು ಹೆಚ್ಚಿನವುಗಳಿಂದ ಡೇಟಾಫ್ರೇಮ್‌ಗಳನ್ನು ಪ್ರಾರಂಭಿಸುವ ಕುರಿತು ಈ ಮಾರ್ಗದರ್ಶಿ ವಿವರಿಸುತ್ತದೆ.
ಪಾಂಡಾಸ್ ಡೇಟಾಫ್ರೇಮ್ ರಚನೆ: ಡೇಟಾ ರಚನೆ ಪ್ರಾರಂಭದ ಆಳವಾದ ಅವಲೋಕನ
ಪೈಥಾನ್‌ನೊಂದಿಗೆ ಡೇಟಾ ಕುಶಲತೆಯ ಜಗತ್ತಿಗೆ ಸ್ವಾಗತ! ಪ್ರತಿಯೊಂದು ಡೇಟಾ ವಿಶ್ಲೇಷಣೆ ಕಾರ್ಯದ ಹೃದಯಭಾಗದಲ್ಲಿ ಪಾಂಡಾಸ್ ಲೈಬ್ರರಿ ಇದೆ, ಮತ್ತು ಇದರ ಮೂಲಾಧಾರವೆಂದರೆ ಡೇಟಾಫ್ರೇಮ್. ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ಸ್ಪ್ರೆಡ್‌ಶೀಟ್ ಅಥವಾ ಡೇಟಾಬೇಸ್ ಟೇಬಲ್‌ನ ಸ್ಮಾರ್ಟ್, ಶಕ್ತಿಯುತ ಮತ್ತು ಹೊಂದಿಕೊಳ್ಳುವ ಆವೃತ್ತಿ ಎಂದು ಭಾವಿಸಿ, ಅದು ನಿಮ್ಮ ಪೈಥಾನ್ ಪರಿಸರದಲ್ಲಿಯೇ ಇರುತ್ತದೆ. ಇದು ಡೇಟಾವನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸಲು, ಪರಿವರ್ತಿಸಲು, ವಿಶ್ಲೇಷಿಸಲು ಮತ್ತು ದೃಶ್ಯೀಕರಿಸಲು ಪ್ರಾಥಮಿಕ ಸಾಧನವಾಗಿದೆ. ಆದರೆ ನೀವು ಈ ಯಾವುದೇ ಡೇಟಾ ಮ್ಯಾಜಿಕ್ ಅನ್ನು ಮಾಡುವ ಮೊದಲು, ನೀವು ಮೊದಲು ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ರಚಿಸುವ ಕಲೆಯನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳಬೇಕು. ಈ ಮೂಲಭೂತ ಡೇಟಾ ರಚನೆಯನ್ನು ನೀವು ಹೇಗೆ ಪ್ರಾರಂಭಿಸುತ್ತೀರಿ ಎಂಬುದು ನಿಮ್ಮ ಸಂಪೂರ್ಣ ವಿಶ್ಲೇಷಣೆಗೆ ವೇದಿಕೆಯನ್ನು ಹೊಂದಿಸುತ್ತದೆ.
ಈ ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿಯನ್ನು ಮಹತ್ವಾಕಾಂಕ್ಷಿ ಮತ್ತು ಅಭ್ಯಾಸ ಮಾಡುವ ಡೇಟಾ ವಿಶ್ಲೇಷಕರು, ವಿಜ್ಞಾನಿಗಳು ಮತ್ತು ಇಂಜಿನಿಯರ್‌ಗಳ ಜಾಗತಿಕ ಪ್ರೇಕ್ಷಕರಿಗಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. ಪಾಂಡಾಸ್ ಡೇಟಾಫ್ರೇಮ್‌ಗಳನ್ನು ಮೊದಲಿನಿಂದ ರಚಿಸಲು ನಾವು ಸಾಮಾನ್ಯ ಮತ್ತು ಶಕ್ತಿಯುತ ವಿಧಾನಗಳನ್ನು ಅನ್ವೇಷಿಸುತ್ತೇವೆ. ನಿಮ್ಮ ಡೇಟಾವು ಡಿಕ್ಷನರಿ, ಲಿಸ್ಟ್, ನಂಪಿ ಅರೇ ಅಥವಾ ಇನ್ನೊಂದು ಫಾರ್ಮ್ಯಾಟ್‌ನಲ್ಲಿದ್ದರೂ, ನಿಮ್ಮ ಡೇಟಾಫ್ರೇಮ್‌ಗಳನ್ನು ಆತ್ಮವಿಶ್ವಾಸ ಮತ್ತು ದಕ್ಷತೆಯಿಂದ ಪ್ರಾರಂಭಿಸಲು ಈ ಲೇಖನವು ನಿಮಗೆ ಜ್ಞಾನ ಮತ್ತು ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ. ನಮ್ಮ ಅಡಿಪಾಯವನ್ನು ನಿರ್ಮಿಸೋಣ.
ಪಾಂಡಾಸ್ ಡೇಟಾಫ್ರೇಮ್ ಎಂದರೇನು?
ನಾವು ನಿರ್ಮಿಸಲು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು, ನಾವು ಏನು ನಿರ್ಮಿಸುತ್ತಿದ್ದೇವೆ ಎಂಬುದನ್ನು ಸ್ಪಷ್ಟಪಡಿಸೋಣ. ಪಾಂಡಾಸ್ ಡೇಟಾಫ್ರೇಮ್ ಎರಡು ಆಯಾಮದ, ಗಾತ್ರವನ್ನು ಬದಲಾಯಿಸಬಹುದಾದ ಮತ್ತು ಸಂಭಾವ್ಯವಾಗಿ ಭಿನ್ನಜಾತಿಯ ಟ್ಯಾಬ್ಯುಲರ್ ಡೇಟಾ ರಚನೆಯಾಗಿದೆ. ಅದನ್ನು ವಿಭಜಿಸೋಣ:
- ಎರಡು ಆಯಾಮಗಳು: ಇದು ಸ್ಪ್ರೆಡ್‌ಶೀಟ್‌ನಂತೆಯೇ ಸಾಲುಗಳು ಮತ್ತು ಕಾಲಮ್‌ಗಳನ್ನು ಹೊಂದಿದೆ.
- ಗಾತ್ರವನ್ನು ಬದಲಾಯಿಸುವುದು: ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ರಚಿಸಿದ ನಂತರ ನೀವು ಸಾಲುಗಳು ಮತ್ತು ಕಾಲಮ್‌ಗಳನ್ನು ಸೇರಿಸಬಹುದು ಅಥವಾ ತೆಗೆದುಹಾಕಬಹುದು.
- ಭಿನ್ನಜಾತಿಯ: ಕಾಲಮ್‌ಗಳು ವಿಭಿನ್ನ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ಹೊಂದಬಹುದು. ಉದಾಹರಣೆಗೆ, ಒಂದು ಕಾಲಮ್ ಸಂಖ್ಯೆಗಳನ್ನು (ಪೂರ್ಣಾಂಕಗಳು ಅಥವಾ ಫ್ಲೋಟ್‌ಗಳು) ಹೊಂದಿರಬಹುದು, ಇನ್ನೊಂದು ಕಾಲಮ್ ಪಠ್ಯವನ್ನು (ಸ್ಟ್ರಿಂಗ್‌ಗಳು) ಹೊಂದಿರಬಹುದು ಮತ್ತು ಮೂರನೆಯದು ದಿನಾಂಕಗಳು ಅಥವಾ ಬೂಲಿಯನ್ ಮೌಲ್ಯಗಳನ್ನು (True/False) ಹೊಂದಿರಬಹುದು.
ಡೇಟಾಫ್ರೇಮ್ ಮೂರು ಪ್ರಮುಖ ಘಟಕಗಳನ್ನು ಹೊಂದಿದೆ:
- ಡೇಟಾ: ರಚನೆಯಲ್ಲಿ ಒಳಗೊಂಡಿರುವ ನೈಜ ಮೌಲ್ಯಗಳು, ಸಾಲುಗಳು ಮತ್ತು ಕಾಲಮ್‌ಗಳಲ್ಲಿ ಆಯೋಜಿಸಲಾಗಿದೆ.
- ಸೂಚ್ಯಂಕ: ಸಾಲುಗಳಿಗಾಗಿ ಲೇಬಲ್‌ಗಳು. ನೀವು ಸೂಚ್ಯಂಕವನ್ನು ನೀಡದಿದ್ದರೆ, ಪಾಂಡಾಸ್ 0 ರಿಂದ ಪ್ರಾರಂಭವಾಗುವ ಡೀಫಾಲ್ಟ್ ಒಂದನ್ನು ರಚಿಸುತ್ತದೆ. ಸೂಚ್ಯಂಕವು ಡೇಟಾವನ್ನು ಪ್ರವೇಶಿಸಲು ಮತ್ತು ಜೋಡಿಸಲು ಪ್ರಬಲ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ.
- ಕಾಲಮ್‌ಗಳು: ಕಾಲಮ್‌ಗಳಿಗಾಗಿ ಲೇಬಲ್‌ಗಳು. ಡೇಟಾಫ್ರೇಮ್‌ನಲ್ಲಿನ ನಿರ್ದಿಷ್ಟ ಡೇಟಾ ಸರಣಿಗಳನ್ನು ಪ್ರವೇಶಿಸಲು ಇವು ನಿರ್ಣಾಯಕವಾಗಿವೆ.
ಈ ರಚನೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಡೇಟಾಫ್ರೇಮ್‌ಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ರಚಿಸಲು ಮತ್ತು ಕುಶಲತೆಯಿಂದ ನಿರ್ವಹಿಸಲು ಪ್ರಮುಖವಾಗಿದೆ.
ಅಡಿಪಾಯ: ಪಾಂಡಾಸ್ ಅನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳುವುದು
ಮೊದಲಿಗೆ ಮುಖ್ಯವಾದ ವಿಷಯಗಳು. ಪಾಂಡಾಸ್ ಅನ್ನು ಬಳಸಲು, ನೀವು ಲೈಬ್ರರಿಯನ್ನು ನಿಮ್ಮ ಪೈಥಾನ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಅಥವಾ ನೋಟ್‌ಬುಕ್‌ಗೆ ಆಮದು ಮಾಡಿಕೊಳ್ಳಬೇಕು. ಜಾಗತಿಕವಾಗಿ ವೃತ್ತಿಪರರು ಅನುಸರಿಸುವ ಸಾರ್ವತ್ರಿಕವಾಗಿ ಅಂಗೀಕರಿಸಲ್ಪಟ್ಟ ಸಮಾವೇಶವೆಂದರೆ ಅದನ್ನು pd ಎಂಬ ಅಲಿಯಾಸ್‌ನೊಂದಿಗೆ ಆಮದು ಮಾಡಿಕೊಳ್ಳುವುದು. ಈ ಸರಳ ಅಲಿಯಾಸ್ ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಹೆಚ್ಚು ಓದಬಲ್ಲ ಮತ್ತು ಸಂಕ್ಷಿಪ್ತಗೊಳಿಸುತ್ತದೆ.
import pandas as pd
import numpy as np # ಸಾಮಾನ್ಯವಾಗಿ ಪಾಂಡಾಸ್‌ನೊಂದಿಗೆ ಬಳಸಲಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ ನಾವು ಅದನ್ನು ಸಹ ಆಮದು ಮಾಡಿಕೊಳ್ಳುತ್ತೇವೆ.
ಈ ಒಂದು ಸಾಲಿನೊಂದಿಗೆ, ನೀವು ಪಾಂಡಾಸ್ ಲೈಬ್ರರಿಯ ಸಂಪೂರ್ಣ ಶಕ್ತಿಯನ್ನು ಅನ್ಲಾಕ್ ಮಾಡಿದ್ದೀರಿ. ಈಗ, ಈ ಮಾರ್ಗದರ್ಶಿಯ ತಿರುಳಿಗೆ ಹೋಗೋಣ: ಡೇಟಾಫ್ರೇಮ್‌ಗಳನ್ನು ರಚಿಸುವುದು.
ಕೋರ್ ರಚನೆ ವಿಧಾನಗಳು: ಸರಳದಿಂದ ಸಂಕೀರ್ಣಕ್ಕೆ
pd.DataFrame() ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ನಂಬಲಾಗದಷ್ಟು ಬಹುಮುಖವಾಗಿದೆ. ಇದು ಹಲವು ವಿಭಿನ್ನ ರೀತಿಯ ಇನ್‌ಪುಟ್ ಅನ್ನು ಸ್ವೀಕರಿಸಬಹುದು. ನಾವು ಈಗ ಸಾಮಾನ್ಯವಾದವುಗಳಿಂದ ಹೆಚ್ಚು ವಿಶೇಷವಾದ ಪ್ರಕರಣಗಳಿಗೆ ಚಲಿಸುವ ಮೂಲಕ ಅತ್ಯಂತ ಅಗತ್ಯವಾದ ವಿಧಾನಗಳನ್ನು ಅನ್ವೇಷಿಸುತ್ತೇವೆ.
1. ಲಿಸ್ಟ್‌ಗಳು ಅಥವಾ ಅರೇಗಳ ಡಿಕ್ಷನರಿಯಿಂದ ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ರಚಿಸುವುದು
ಇದು ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ರಚಿಸಲು ಬಹುಶಃ ಸಾಮಾನ್ಯ ಮತ್ತು ಅಂತರ್ಗತ ವಿಧಾನವಾಗಿದೆ. ನೀವು ಪೈಥಾನ್ ಡಿಕ್ಷನರಿಯೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಿ, ಅಲ್ಲಿ ಕೀಗಳು ಕಾಲಮ್ ಹೆಸರುಗಳಾಗುತ್ತವೆ ಮತ್ತು ಮೌಲ್ಯಗಳು ಪ್ರತಿ ಕಾಲಮ್‌ಗೆ ಡೇಟಾವನ್ನು ಒಳಗೊಂಡಿರುವ ಲಿಸ್ಟ್‌ಗಳಾಗಿರುತ್ತವೆ (ಅಥವಾ ನಂಪಿ ಅರೇಗಳು ಅಥವಾ ಪಾಂಡಾಸ್ ಸರಣಿಗಳು).
ಇದು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ: ಪಾಂಡಾಸ್ ಪ್ರತಿ ಡಿಕ್ಷನರಿ ಕೀಯನ್ನು ಕಾಲಮ್ ಹೆಡರ್‌ಗೆ ಮ್ಯಾಪ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಪ್ರತಿ ಮೌಲ್ಯಗಳ ಪಟ್ಟಿಯನ್ನು ಆ ಕಾಲಮ್‌ನ ಸಾಲುಗಳಿಗೆ ಮ್ಯಾಪ್ ಮಾಡುತ್ತದೆ. ಇಲ್ಲಿ ಒಂದು ನಿರ್ಣಾಯಕ ಅಗತ್ಯವೆಂದರೆ ಎಲ್ಲಾ ಲಿಸ್ಟ್‌ಗಳು ಒಂದೇ ಉದ್ದವನ್ನು ಹೊಂದಿರಬೇಕು, ಏಕೆಂದರೆ ಪ್ರತಿ ಲಿಸ್ಟ್ ಡೇಟಾದ ಸಂಪೂರ್ಣ ಕಾಲಮ್ ಅನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.
ಉದಾಹರಣೆ:
ಜಗತ್ತಿನ ವಿವಿಧ ನಗರಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಒಳಗೊಂಡಿರುವ ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ರಚಿಸೋಣ.
# ಕಾಲಮ್ ಮೂಲಕ ಆಯೋಜಿಸಲಾದ ಡೇಟಾ
city_data = {
'City': ['ಟೋಕಿಯೋ', 'ದೆಹಲಿ', 'ಶಾಂಘೈ', 'ಸಾವೊ ಪಾಲೊ', 'ಮುಂಬೈ'],
'Country': ['ಜಪಾನ್', 'ಭಾರತ', 'ಚೀನಾ', 'ಬ್ರೆಜಿಲ್', 'ಭಾರತ'],
'Population_Millions': [37.3, 32.0, 28.5, 22.4, 20.9],
'Is_Coastal': [True, False, True, False, True]
}
# ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ರಚಿಸಿ
df_from_dict = pd.DataFrame(city_data)
print(df_from_dict)
ಔಟ್ಪುಟ್:
City Country Population_Millions Is_Coastal
0 ಟೋಕಿಯೋ ಜಪಾನ್ 37.3 True
1 ದೆಹಲಿ ಭಾರತ 32.0 False
2 ಶಾಂಘೈ ಚೀನಾ 28.5 True
3 ಸಾವೊ ಪಾಲೊ ಬ್ರೆಜಿಲ್ 22.4 False
4 ಮುಂಬೈ ಭಾರತ 20.9 True
ಪ್ರಮುಖ ಅಂಶ: ನಿಮ್ಮ ಡೇಟಾವನ್ನು ನೈಸರ್ಗಿಕವಾಗಿ ವೈಶಿಷ್ಟ್ಯ ಅಥವಾ ವರ್ಗದಿಂದ ಆಯೋಜಿಸಿದಾಗ ಈ ವಿಧಾನವು ಪರಿಪೂರ್ಣವಾಗಿದೆ. ಇದು ಸ್ವಚ್ಛವಾಗಿದೆ, ಓದಲು ಸುಲಭವಾಗಿದೆ ಮತ್ತು ನಿಮ್ಮ ಡಿಕ್ಷನರಿಯ ರಚನೆಯನ್ನು ನೇರವಾಗಿ ಟ್ಯಾಬ್ಯುಲರ್ ಫಾರ್ಮ್ಯಾಟ್‌ಗೆ ಅನುವಾದಿಸುತ್ತದೆ.
2. ಡಿಕ್ಷನರಿಗಳ ಲಿಸ್ಟ್‌ನಿಂದ ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ರಚಿಸುವುದು
ಒಂದು ಪರ್ಯಾಯ ಮತ್ತು ಸಮಾನವಾಗಿ ಶಕ್ತಿಯುತವಾದ ವಿಧಾನವೆಂದರೆ ಪ್ರತಿಯೊಂದು ಅಂಶವು ಡಿಕ್ಷನರಿಯಾಗಿರುವ ಲಿಸ್ಟ್ ಅನ್ನು ಬಳಸುವುದು. ಈ ರಚನೆಯಲ್ಲಿ, ಪ್ರತಿ ಡಿಕ್ಷನರಿಯು ಒಂದು ಸಾಲನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ ಮತ್ತು ಅದರ ಕೀಗಳು ಆ ಸಾಲಿನ ಡೇಟಾಕ್ಕಾಗಿ ಕಾಲಮ್ ಹೆಸರುಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತವೆ.
ಇದು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ: ಪಾಂಡಾಸ್ ಲಿಸ್ಟ್ ಮೂಲಕ ಪುನರಾವರ್ತಿಸುತ್ತದೆ. ಪ್ರತಿ ಡಿಕ್ಷನರಿಗಾಗಿ, ಇದು ಹೊಸ ಸಾಲನ್ನು ರಚಿಸುತ್ತದೆ. ಕಾಲಮ್‌ಗಳನ್ನು ನಿರ್ಧರಿಸಲು ಡಿಕ್ಷನರಿ ಕೀಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಈ ವಿಧಾನವು ನಂಬಲಾಗದಷ್ಟು ಹೊಂದಿಕೊಳ್ಳುವಂತಿದೆ ಏಕೆಂದರೆ ಡಿಕ್ಷನರಿಯಲ್ಲಿ ಕೀ ಕಾಣೆಯಾಗಿದ್ದರೆ, ಪಾಂಡಾಸ್ ಆ ಸೆಲ್ ಅನ್ನು ಅನುಗುಣವಾದ ಸಾಲಿನಲ್ಲಿ NaN (ಸಂಖ್ಯೆಯಲ್ಲ) ನೊಂದಿಗೆ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ತುಂಬುತ್ತದೆ, ಇದು ಪಾಂಡಾಸ್‌ನಲ್ಲಿ ಕಾಣೆಯಾದ ಡೇಟಾದ ಪ್ರಮಾಣಿತ ಗುರುತುಯಾಗಿದೆ.
ಉದಾಹರಣೆ:
ಅದೇ ನಗರ ಡೇಟಾವನ್ನು ಪ್ರತಿನಿಧಿಸೋಣ, ಆದರೆ ಈ ಬಾರಿ ದಾಖಲೆಗಳ ಲಿಸ್ಟ್ ಆಗಿ ರಚನೆಯಾಗಿದೆ.
# ಸಾಲಿನಿಂದ ಆಯೋಜಿಸಲಾದ ಡೇಟಾ (ದಾಖಲೆ)
records_data = [
{'City': 'ಟೋಕಿಯೋ', 'Country': 'ಜಪಾನ್', 'Population_Millions': 37.3, 'Is_Coastal': True},
{'City': 'ದೆಹಲಿ', 'Country': 'ಭಾರತ', 'Population_Millions': 32.0, 'Is_Coastal': False},
{'City': 'ಶಾಂಘೈ', 'Country': 'ಚೀನಾ', 'Population_Millions': 28.5},
{'City': 'ಸಾವೊ ಪಾಲೊ', 'Country': 'ಬ್ರೆಜಿಲ್', 'Population_Millions': 22.4, 'Is_Coastal': False},
{'City': 'ಕೈರೋ', 'Country': 'ಈಜಿಪ್ಟ್', 'Timezone': 'EET'} # ವಿಭಿನ್ನ ರಚನೆಯನ್ನು ಗಮನಿಸಿ
]
# ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ರಚಿಸಿ
df_from_list_of_dicts = pd.DataFrame(records_data)
print(df_from_list_of_dicts)
ಔಟ್ಪುಟ್:
City Country Population_Millions Is_Coastal Timezone
0 ಟೋಕಿಯೋ ಜಪಾನ್ 37.3 True NaN
1 ದೆಹಲಿ ಭಾರತ 32.0 False NaN
2 ಶಾಂಘೈ ಚೀನಾ 28.5 NaN NaN
3 ಸಾವೊ ಪಾಲೊ ಬ್ರೆಜಿಲ್ 22.4 False NaN
4 ಕೈರೋ ಈಜಿಪ್ಟ್ NaN NaN EET
ಪಾಂಡಾಸ್ ಹೇಗೆ ಸ್ಥಿರತೆಗಳನ್ನು ಅಂದವಾಗಿ ನಿರ್ವಹಿಸಿದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ. ಶಾಂಘೈಗೆ 'Is_Coastal' ಮೌಲ್ಯವು NaN ಆಗಿದೆ ಏಕೆಂದರೆ ಅದು ಅದರ ಡಿಕ್ಷನರಿಯಿಂದ ಕಾಣೆಯಾಗಿತ್ತು. ಕೈರೋಗಾಗಿ ಹೊಸ 'Timezone' ಕಾಲಮ್ ಅನ್ನು ರಚಿಸಲಾಗಿದೆ, ಇತರ ಎಲ್ಲಾ ನಗರಗಳಿಗೆ NaN ಅನ್ನು ನೀಡಲಾಗಿದೆ. JSON API ಗಳಿಂದ ಪ್ರತಿಕ್ರಿಯೆಗಳಂತಹ ಅರೆ-ರಚನಾತ್ಮಕ ಡೇಟಾದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಇದು ಅತ್ಯುತ್ತಮ ಆಯ್ಕೆಯಾಗಿದೆ.
ಪ್ರಮುಖ ಅಂಶ: ನಿಮ್ಮ ಡೇಟಾವು ದಾಖಲೆಗಳು ಅಥವಾ ವೀಕ್ಷಣೆಗಳ ಸರಣಿಯಾಗಿ ಬಂದಾಗ ಈ ವಿಧಾನವನ್ನು ಬಳಸಿ. ಕಾಣೆಯಾದ ಡೇಟಾ ಮತ್ತು ದಾಖಲೆ ರಚನೆಯಲ್ಲಿನ ವ್ಯತ್ಯಾಸಗಳನ್ನು ನಿರ್ವಹಿಸುವಲ್ಲಿ ಇದು ದೃಢವಾಗಿದೆ.
3. ನಂಪಿ ಅರೇಯಿಂದ ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ರಚಿಸುವುದು
ವೈಜ್ಞಾನಿಕ ಕಂಪ್ಯೂಟಿಂಗ್, ಯಂತ್ರ ಕಲಿಕೆ ಅಥವಾ ಭಾರೀ ಸಂಖ್ಯಾತ್ಮಕ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಯಾವುದೇ ಕ್ಷೇತ್ರದಲ್ಲಿ ಕೆಲಸ ಮಾಡುವವರಿಗೆ, ಡೇಟಾವು ಸಾಮಾನ್ಯವಾಗಿ ನಂಪಿ ಅರೇಗಳಲ್ಲಿ ಹುಟ್ಟುತ್ತದೆ. ಪಾಂಡಾಸ್ ಅನ್ನು ನಂಪಿ ಮೇಲೆ ನಿರ್ಮಿಸಲಾಗಿದೆ, ಇದು ಎರಡರ ನಡುವಿನ ಏಕೀಕರಣವನ್ನು ತಡೆರಹಿತ ಮತ್ತು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಮಾಡುತ್ತದೆ.
ಇದು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ: ನೀವು 2D ನಂಪಿ ಅರೇ ಅನ್ನು pd.DataFrame() ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ಗೆ ರವಾನಿಸುತ್ತೀರಿ. ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಪಾಂಡಾಸ್ ಪೂರ್ಣಾಂಕ-ಆಧಾರಿತ ಸೂಚ್ಯಂಕಗಳು ಮತ್ತು ಕಾಲಮ್‌ಗಳನ್ನು ರಚಿಸುತ್ತದೆ. ಆದಾಗ್ಯೂ, ನೀವು index ಮತ್ತು columns ನಿಯತಾಂಕಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಅರ್ಥಪೂರ್ಣ ಲೇಬಲ್‌ಗಳನ್ನು ಒದಗಿಸಬಹುದು (ಮತ್ತು ಮಾಡಬೇಕು).
ಉದಾಹರಣೆ:
ಸಮಯದೊಂದಿಗೆ ಸಂವೇದಕ ರೀಡಿಂಗ್‌ಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಯಾದೃಚ್ಛಿಕವಾಗಿ ರಚಿಸಲಾದ 5x4 ನಂಪಿ ಅರೇನಿಂದ ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ರಚಿಸೋಣ.
# ಯಾದೃಚ್ಛಿಕ ಡೇಟಾದೊಂದಿಗೆ 5x4 ನಂಪಿ ಅರೇ ಅನ್ನು ರಚಿಸಿ
data_np = np.random.rand(5, 4)
# ಕಾಲಮ್ ಮತ್ತು ಇಂಡೆಕ್ಸ್ ಲೇಬಲ್‌ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ
columns = ['Sensor_A', 'Sensor_B', 'Sensor_C', 'Sensor_D']
index = pd.to_datetime(['2023-10-27 10:00', '2023-10-27 10:01', '2023-10-27 10:02', '2023-10-27 10:03', '2023-10-27 10:04'])
# ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ರಚಿಸಿ
df_from_numpy = pd.DataFrame(data=data_np, index=index, columns=columns)
print(df_from_numpy)
ಔಟ್ಪುಟ್ (ನಿಮ್ಮ ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಗಳು ಭಿನ್ನವಾಗಿರುತ್ತವೆ):
Sensor_A Sensor_B Sensor_C Sensor_D
2023-10-27 10:00:00 0.123456 0.987654 0.555555 0.111111
2023-10-27 10:01:00 0.234567 0.876543 0.666666 0.222222
2023-10-27 10:02:00 0.345678 0.765432 0.777777 0.333333
2023-10-27 10:03:00 0.456789 0.654321 0.888888 0.444444
2023-10-27 10:04:00 0.567890 0.543210 0.999999 0.555555
ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ಪ್ರಬಲ ವೈಶಿಷ್ಟ್ಯವನ್ನು ಸಹ ಪರಿಚಯಿಸಿದ್ದೇವೆ: ಸಮಯ-ಸರಣಿ ಡೇಟಾಗಾಗಿ DatetimeIndex ಅನ್ನು ಬಳಸುವುದು, ಇದು ಪಾಂಡಾಸ್‌ನಲ್ಲಿ ಸಮಯ-ಆಧಾರಿತ ವಿಶ್ಲೇಷಣಾ ಸಾಮರ್ಥ್ಯಗಳ ದೊಡ್ಡ ಶ್ರೇಣಿಯನ್ನು ತೆರೆಯುತ್ತದೆ.
ಪ್ರಮುಖ ಅಂಶ: ಏಕರೂಪದ ಸಂಖ್ಯಾತ್ಮಕ ಡೇಟಾದಿಂದ ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ರಚಿಸಲು ಇದು ಅತ್ಯಂತ ಮೆಮೊರಿ-ಸಮರ್ಥ ವಿಧಾನವಾಗಿದೆ. ನಂಪಿ, ಸ್ಕಿಟ್-ಲರ್ನ್ ಅಥವಾ ಟೆನ್ಸರ್‌ಫ್ಲೋನಂತಹ ಲೈಬ್ರರಿಗಳೊಂದಿಗೆ ಇಂಟರ್ಫೇಸಿಂಗ್ ಮಾಡುವಾಗ ಇದು ಪ್ರಮಾಣಿತ ಆಯ್ಕೆಯಾಗಿದೆ.
4. ಲಿಸ್ಟ್‌ಗಳ ಲಿಸ್ಟ್‌ನಿಂದ ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ರಚಿಸುವುದು
ಈ ವಿಧಾನವು ಪರಿಕಲ್ಪನಾತ್ಮಕವಾಗಿ ನಂಪಿ ಅರೇನಿಂದ ರಚಿಸುವುದಕ್ಕೆ ಹೋಲುತ್ತದೆ ಆದರೆ ಪ್ರಮಾಣಿತ ಪೈಥಾನ್ ಲಿಸ್ಟ್‌ಗಳನ್ನು ಬಳಸುತ್ತದೆ. ನೆಸ್ಟೆಡ್ ಲಿಸ್ಟ್ ಫಾರ್ಮ್ಯಾಟ್‌ನಲ್ಲಿ ಸಂಗ್ರಹವಾಗಿರುವ ಟ್ಯಾಬ್ಯುಲರ್ ಡೇಟಾವನ್ನು ಪರಿವರ್ತಿಸಲು ಇದು ನೇರ ಮಾರ್ಗವಾಗಿದೆ.
ಇದು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ: ನೀವು ಒಂದು ಲಿಸ್ಟ್ ಅನ್ನು ಒದಗಿಸುತ್ತೀರಿ, ಅಲ್ಲಿ ಪ್ರತಿ ಒಳಗಿನ ಲಿಸ್ಟ್ ಡೇಟಾದ ಸಾಲನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ನಂಪಿ ಅರೇಗಳಂತೆ, ಸ್ಪಷ್ಟತೆಗಾಗಿ columns ನಿಯತಾಂಕದ ಮೂಲಕ ಕಾಲಮ್ ಹೆಸರುಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ಹೆಚ್ಚು ಶಿಫಾರಸು ಮಾಡಲಾಗಿದೆ.
ಉದಾಹರಣೆ:
# ಸಾಲುಗಳ ಲಿಸ್ಟ್ ಆಗಿ ಡೇಟಾ
product_data = [
['P001', 'ಲ್ಯಾಪ್‌ಟಾಪ್', 1200.00, 'ಎಲೆಕ್ಟ್ರಾನಿಕ್ಸ್'],
['P002', 'ಮೌಸ್', 25.50, 'ಎಲೆಕ್ಟ್ರಾನಿಕ್ಸ್'],
['P003', 'ಡೆಸ್ಕ್ ಕುರ್ಚಿ', 150.75, 'ಫರ್ನಿಚರ್'],
['P004', 'ಕೀಬೋರ್ಡ್', 75.00, 'ಎಲೆಕ್ಟ್ರಾನಿಕ್ಸ್']
]
# ಕಾಲಮ್ ಹೆಸರುಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ
column_names = ['ಉತ್ಪನ್ನ ID', 'ಉತ್ಪನ್ನದ ಹೆಸರು', 'ಬೆಲೆ_USD', 'ವರ್ಗ']
# ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ರಚಿಸಿ
df_from_list_of_lists = pd.DataFrame(product_data, columns=column_names)
print(df_from_list_of_lists)
ಔಟ್ಪುಟ್:
ProductID ProductName Price_USD Category 0 P001 ಲ್ಯಾಪ್‌ಟಾಪ್ 1200.00 Electronics 1 P002 ಮೌಸ್ 25.50 Electronics 2 P003 ಡೆಸ್ಕ್ ಕುರ್ಚಿ 150.75 Furniture 3 P004 ಕೀಬೋರ್ಡ್ 75.00 Electronics
ಪ್ರಮುಖ ಅಂಶ: ನಿಮ್ಮ ಡೇಟಾವನ್ನು ಈಗಾಗಲೇ ಸಾಲುಗಳ ಲಿಸ್ಟ್ ಆಗಿ ರಚಿಸಿದಾಗ ಇದು ಸರಳ ಮತ್ತು ಪರಿಣಾಮಕಾರಿ ವಿಧಾನವಾಗಿದೆ, ಉದಾಹರಣೆಗೆ ಹೆಡರ್‌ಗಳನ್ನು ಹೊಂದಿರದ ಫೈಲ್ ಫಾರ್ಮ್ಯಾಟ್‌ನಿಂದ ಓದುವಾಗ.
ಸುಧಾರಿತ ಪ್ರಾರಂಭ: ನಿಮ್ಮ ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ಕಸ್ಟಮೈಸ್ ಮಾಡುವುದು
ಕಚ್ಚಾ ಡೇಟಾವನ್ನು ಒದಗಿಸುವುದರ ಹೊರತಾಗಿ, pd.DataFrame() ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಅದರ ರಚನೆಯ ಕ್ಷಣದಿಂದ ನಿಮ್ಮ ಹೊಸ ಡೇಟಾಫ್ರೇಮ್‌ನ ರಚನೆ ಮತ್ತು ಗುಣಲಕ್ಷಣಗಳನ್ನು ನಿಯಂತ್ರಿಸಲು ಹಲವಾರು ನಿಯತಾಂಕಗಳನ್ನು ನೀಡುತ್ತದೆ.
ಸೂಚ್ಯಂಕವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುವುದು
ನಾವು ಈಗಾಗಲೇ index ನಿಯತಾಂಕವನ್ನು ಕ್ರಿಯೆಯಲ್ಲಿ ನೋಡಿದ್ದೇವೆ. ಸೂಚ್ಯಂಕವು ಡೇಟಾಫ್ರೇಮ್‌ನ ನಿರ್ಣಾಯಕ ಭಾಗವಾಗಿದೆ, ಸಾಲುಗಳಿಗೆ ಲೇಬಲ್‌ಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ, ಅವುಗಳನ್ನು ವೇಗದ ಲುಕಪ್‌ಗಳು, ಡೇಟಾ ಜೋಡಣೆ ಮತ್ತು ಹೆಚ್ಚಿನವುಗಳಿಗೆ ಬಳಸಲಾಗುತ್ತದೆ. ಪಾಂಡಾಸ್ ಡೀಫಾಲ್ಟ್ ಸಂಖ್ಯಾತ್ಮಕ ಸೂಚ್ಯಂಕವನ್ನು (0, 1, 2, ...) ಒದಗಿಸುತ್ತದೆಯಾದರೂ, ಅರ್ಥಪೂರ್ಣ ಸೂಚ್ಯಂಕವನ್ನು ಹೊಂದಿಸುವುದರಿಂದ ನಿಮ್ಮ ಡೇಟಾದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು ಸುಲಭವಾಗುತ್ತದೆ.
ಉದಾಹರಣೆ: ನಮ್ಮ ಲಿಸ್ಟ್‌ಗಳ ಡಿಕ್ಷನರಿ ಉದಾಹರಣೆಯನ್ನು ಮರು-ಬಳಕೆ ಮಾಡೋಣ ಆದರೆ ರಚನೆಯ ನಂತರ City ಕಾಲಮ್ ಅನ್ನು ಸೂಚ್ಯಂಕವಾಗಿ ಹೊಂದಿಸೋಣ.
city_data = {
'Country': ['ಜಪಾನ್', 'ಭಾರತ', 'ಚೀನಾ', 'ಬ್ರೆಜಿಲ್', 'ಭಾರತ'],
'Population_Millions': [37.3, 32.0, 28.5, 22.4, 20.9],
'Is_Coastal': [True, False, True, False, True]
}
city_names = ['ಟೋಕಿಯೋ', 'ದೆಹಲಿ', 'ಶಾಂಘೈ', 'ಸಾವೊ ಪಾಲೊ', 'ಮುಂಬೈ']
# ಕಸ್ಟಮ್ ಸೂಚ್ಯಂಕದೊಂದಿಗೆ ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ರಚಿಸಿ
df_with_index = pd.DataFrame(city_data, index=city_names)
print(df_with_index)
ಔಟ್ಪುಟ್:
Country Population_Millions Is_Coastal
ಟೋಕಿಯೋ ಜಪಾನ್ 37.3 True
ದೆಹಲಿ ಭಾರತ 32.0 False
ಶಾಂಘೈ ಚೀನಾ 28.5 True
ಸಾವೊ ಪಾಲೊ ಬ್ರೆಜಿಲ್ 22.4 False
ಮುಂಬೈ ಭಾರತ 20.9 True
ಈಗ, ನೀವು ಈ ಅರ್ಥಪೂರ್ಣ ಲೇಬಲ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಸಾಲಿನ ಡೇಟಾವನ್ನು ಪ್ರವೇಶಿಸಬಹುದು, ಉದಾಹರಣೆಗೆ df_with_index.loc['Tokyo'] ನೊಂದಿಗೆ.
ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ನಿಯಂತ್ರಿಸುವುದು (`dtype`)
ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು (ಉದಾಹರಣೆಗೆ, ಸಂಖ್ಯೆಗಳು, ಪಠ್ಯ ಮತ್ತು ಬೂಲಿಯನ್‌ಗಳನ್ನು ಗುರುತಿಸುವುದು) ಊಹಿಸುವಲ್ಲಿ ಪಾಂಡಾಸ್ ತುಂಬಾ ಒಳ್ಳೆಯದು. ಆದಾಗ್ಯೂ, ಕೆಲವೊಮ್ಮೆ ನೀವು ಮೆಮೊರಿ ದಕ್ಷತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಅಥವಾ ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಲು ಕಾಲಮ್‌ಗೆ ನಿರ್ದಿಷ್ಟ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ಜಾರಿಗೊಳಿಸಬೇಕಾಗುತ್ತದೆ. dtype ನಿಯತಾಂಕವು ನಿಮಗೆ ಈ ನಿಯಂತ್ರಣವನ್ನು ನೀಡುತ್ತದೆ.
ಉದಾಹರಣೆ: ಸಂಖ್ಯೆಗಳಂತೆ ಕಾಣುವ ಉತ್ಪನ್ನ ID ಗಳನ್ನು ನಾವು ಹೊಂದಿದ್ದೇವೆ ಎಂದು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ ಆದರೆ ಅವುಗಳನ್ನು ಪಠ್ಯವಾಗಿ ಪರಿಗಣಿಸಬೇಕು (ಸ್ಟ್ರಿಂಗ್‌ಗಳು).
data = {
'ProductID': [101, 102, 103],
'Stock': [50, 75, 0]
}
# 'ProductID' ಗಾಗಿ dtype ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುವಾಗ ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ರಚಿಸಿ
df_types = pd.DataFrame(data, dtype={'ProductID': str, 'Stock': 'int32'})
print(df_types.dtypes)
ಔಟ್ಪುಟ್:
ProductID object Stock int32 dtype: object
ಪಾಂಡಾಸ್‌ನಲ್ಲಿ str ಅನ್ನು object ಎಂದು ಪ್ರತಿನಿಧಿಸಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ. dtype ಅನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಹೊಂದಿಸುವ ಮೂಲಕ, ProductID ಅನ್ನು ಸಂಖ್ಯೆಯಂತೆ ಪರಿಗಣಿಸುವುದನ್ನು ನಾವು ತಡೆಯುತ್ತೇವೆ, ಇದು ಮುಂದಕ್ಕೆ ತಪ್ಪಾದ ಲೆಕ್ಕಾಚಾರಗಳಿಗೆ ಅಥವಾ ವಿಂಗಡಿಸುವ ಸಮಸ್ಯೆಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು. ಡೀಫಾಲ್ಟ್ int64 ಬದಲಿಗೆ int32 ನಂತಹ ಹೆಚ್ಚು ನಿರ್ದಿಷ್ಟ ಪೂರ್ಣಾಂಕ ಪ್ರಕಾರಗಳನ್ನು ಬಳಸುವುದು ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳೊಂದಿಗೆ ಗಮನಾರ್ಹವಾದ ಮೆಮೊರಿಯನ್ನು ಸಹ ಉಳಿಸಬಹುದು.
ಪ್ರಾಯೋಗಿಕ ಸನ್ನಿವೇಶಗಳು ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು
ಸರಿಯಾದ ರಚನೆ ವಿಧಾನವನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು ನಿಮ್ಮ ಡೇಟಾದ ಮೂಲ ಸ್ವರೂಪವನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ. ಇಲ್ಲಿ ಒಂದು ಸರಳ ನಿರ್ಧಾರ ಮಾರ್ಗದರ್ಶಿ ಇದೆ:
- ನಿಮ್ಮ ಡೇಟಾ ಕಾಲಮ್‌ಗಳಲ್ಲಿದೆಯೇ (ಉದಾಹರಣೆಗೆ, ಪ್ರತಿ ವೈಶಿಷ್ಟ್ಯಕ್ಕೆ ಒಂದು ಲಿಸ್ಟ್)? ಲಿಸ್ಟ್‌ಗಳ ಡಿಕ್ಷನರಿಯನ್ನು ಬಳಸಿ. ಇದು ನೈಸರ್ಗಿಕ ಫಿಟ್ ಆಗಿದೆ.
- ನಿಮ್ಮ ಡೇಟಾ ದಾಖಲೆಗಳ ಸರಣಿಯಾಗಿದೆಯೇ (ಉದಾಹರಣೆಗೆ, JSON API ಯಿಂದ)? ಡಿಕ್ಷನರಿಗಳ ಲಿಸ್ಟ್ ಅನ್ನು ಬಳಸಿ. ಇದು ದಾಖಲೆಗಳಲ್ಲಿ ಕಾಣೆಯಾದ ಅಥವಾ ಹೆಚ್ಚುವರಿ ಕ್ಷೇತ್ರಗಳನ್ನು ನಿರ್ವಹಿಸುವಲ್ಲಿ ಉತ್ಕೃಷ್ಟವಾಗಿದೆ.
- ನಿಮ್ಮ ಡೇಟಾ ಸಂಖ್ಯಾತ್ಮಕವಾಗಿದೆಯೇ ಮತ್ತು ಗ್ರಿಡ್‌ನಲ್ಲಿದೆಯೇ (ಉದಾಹರಣೆಗೆ, ವೈಜ್ಞಾನಿಕ ಲೆಕ್ಕಾಚಾರದಿಂದ)? ನಂಪಿ ಅರೇ ಅನ್ನು ಬಳಸಿ. ಈ ಬಳಕೆಯ ಸಂದರ್ಭಕ್ಕೆ ಇದು ಅತ್ಯಂತ ಪರಿಣಾಮಕಾರಿ ಆಯ್ಕೆಯಾಗಿದೆ.
- ನಿಮ್ಮ ಡೇಟಾ ಹೆಡರ್‌ಗಳಿಲ್ಲದ ಸರಳ ಸಾಲಿನಿಂದ ಸಾಲಿಗೆ ಟೇಬಲ್ ಫಾರ್ಮ್ಯಾಟ್‌ನಲ್ಲಿದೆಯೇ? ಲಿಸ್ಟ್‌ಗಳ ಲಿಸ್ಟ್ ಅನ್ನು ಬಳಸಿ ಮತ್ತು ಕಾಲಮ್ ಹೆಸರುಗಳನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ನೀಡಿ.
ತಪ್ಪಿಸಬೇಕಾದ ಸಾಮಾನ್ಯ ಅಪಾಯಗಳು
- ಲಿಸ್ಟ್‌ಗಳ ಡಿಕ್ಷನರಿಯಲ್ಲಿ ಅಸಮಾನ ಉದ್ದಗಳು: ಇದು ಸಾಮಾನ್ಯ ತಪ್ಪು. ಲಿಸ್ಟ್‌ಗಳ ಡಿಕ್ಷನರಿಯಿಂದ ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ರಚಿಸುವಾಗ, ಪ್ರತಿ ಲಿಸ್ಟ್ ನಿಖರವಾದ ಸಂಖ್ಯೆಯ ಅಂಶಗಳನ್ನು ಹೊಂದಿರಬೇಕು. ಇಲ್ಲದಿದ್ದರೆ, ಪಾಂಡಾಸ್
ValueErrorಅನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ. ರಚಿಸುವ ಮೊದಲು ನಿಮ್ಮ ಕಾಲಮ್ ಡೇಟಾವು ಸಮಾನ ಉದ್ದವನ್ನು ಹೊಂದಿದೆಯೇ ಎಂದು ಯಾವಾಗಲೂ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. - ಸೂಚ್ಯಂಕವನ್ನು ನಿರ್ಲಕ್ಷಿಸುವುದು: ಡೀಫಾಲ್ಟ್ 0-ಆಧಾರಿತ ಸೂಚ್ಯಂಕವನ್ನು ಅವಲಂಬಿಸುವುದು ಅನೇಕ ಸಂದರ್ಭಗಳಲ್ಲಿ ಉತ್ತಮವಾಗಿದೆ, ಆದರೆ ನಿಮ್ಮ ಡೇಟಾವು ನೈಸರ್ಗಿಕ ಗುರುತಿಸುವಿಕೆಯನ್ನು ಹೊಂದಿದ್ದರೆ (ಉದಾಹರಣೆಗೆ ಉತ್ಪನ್ನ ID, ಬಳಕೆದಾರ ID ಅಥವಾ ನಿರ್ದಿಷ್ಟ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್), ಅದನ್ನು ಮೊದಲಿನಿಂದಲೂ ಸೂಚ್ಯಂಕವಾಗಿ ಹೊಂದಿಸುವುದರಿಂದ ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ನಂತರ ಸರಳಗೊಳಿಸಬಹುದು.
- ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ಮರೆತುಬಿಡುವುದು: ಪಾಂಡಾಸ್ ಪ್ರಕಾರಗಳನ್ನು ಊಹಿಸಲು ಬಿಡುವುದು ಹೆಚ್ಚಿನ ಸಮಯ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಆದರೆ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳು ಅಥವಾ ಮಿಶ್ರ ಪ್ರಕಾರಗಳ ಕಾಲಮ್‌ಗಳಿಗಾಗಿ, ಕಾರ್ಯಕ್ಷಮತೆ ಕುಸಿಯಬಹುದು. ಮೆಮೊರಿಯನ್ನು ಉಳಿಸಲು ಮತ್ತು ದೋಷಗಳನ್ನು ತಡೆಯಲು ವರ್ಗಗಳು, ಸ್ಟ್ರಿಂಗ್‌ಗಳು ಅಥವಾ ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯಾತ್ಮಕ ಪ್ರಕಾರಗಳಾಗಿ ಪರಿಗಣಿಸಬೇಕಾದ ಕಾಲಮ್‌ಗಳಿಗೆ
dtypeಅನ್ನು ಹೊಂದಿಸುವ ಬಗ್ಗೆ ಪೂರ್ವಭಾವಿಯಾಗಿರಿ.
ಪ್ರಾರಂಭದ ಹೊರತಾಗಿ: ಫೈಲ್‌ಗಳಿಂದ ಡೇಟಾಫ್ರೇಮ್‌ಗಳನ್ನು ರಚಿಸುವುದು
ಈ ಮಾರ್ಗದರ್ಶಿಯು ಇನ್-ಮೆಮೊರಿ ಪೈಥಾನ್ ವಸ್ತುಗಳಿಂದ ಡೇಟಾಫ್ರೇಮ್‌ಗಳನ್ನು ರಚಿಸುವುದರ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸಿದ್ದರೂ, ಹೆಚ್ಚಿನ ನೈಜ-ಪ್ರಪಂಚದ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ನಿಮ್ಮ ಡೇಟಾ ಬಾಹ್ಯ ಫೈಲ್‌ನಿಂದ ಬರುತ್ತದೆ ಎಂದು ತಿಳಿದುಕೊಳ್ಳುವುದು ಬಹಳ ಮುಖ್ಯ. ಈ ಉದ್ದೇಶಕ್ಕಾಗಿ ಪಾಂಡಾಸ್ ಹೆಚ್ಚು ಆಪ್ಟಿಮೈಸ್ ಮಾಡಿದ ರೀಡರ್ ಕಾರ್ಯಗಳ ಸೂಟ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ, ಅವುಗಳೆಂದರೆ:
pd.read_csv(): ಕಾಮಾ-ಬೇರ್ಪಡಿಸಿದ ಮೌಲ್ಯಗಳ ಫೈಲ್‌ಗಳಿಗಾಗಿ, ಡೇಟಾ ಆಮದು ಮಾಡುವ ಕುದುರೆ.pd.read_excel(): ಮೈಕ್ರೋಸಾಫ್ಟ್ ಎಕ್ಸೆಲ್ ಸ್ಪ್ರೆಡ್‌ಶೀಟ್‌ಗಳಿಂದ ಡೇಟಾವನ್ನು ಓದಲು.pd.read_json(): JSON ಫೈಲ್‌ಗಳು ಅಥವಾ ಸ್ಟ್ರಿಂಗ್‌ಗಳಿಂದ ಡೇಟಾವನ್ನು ಓದಲು.pd.read_sql(): ಡೇಟಾಬೇಸ್ ಪ್ರಶ್ನೆಯ ಫಲಿತಾಂಶಗಳನ್ನು ನೇರವಾಗಿ ಡೇಟಾಫ್ರೇಮ್‌ಗೆ ಓದಲು.pd.read_parquet(): ಪರಿಣಾಮಕಾರಿ, ಕಾಲಮ್-ಆಧಾರಿತ ಪಾರ್ಕ್ವೆಟ್ ಫೈಲ್ ಫಾರ್ಮ್ಯಾಟ್‌ನಿಂದ ಓದಲು.
ಈ ಕಾರ್ಯಗಳು ನಿಮ್ಮ ಪಾಂಡಾಸ್ ಪ್ರಯಾಣದಲ್ಲಿ ಮುಂದಿನ ತಾರ್ಕಿಕ ಹಂತವಾಗಿದೆ. ಅವುಗಳನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವುದು ಪ್ರಾಯೋಗಿಕವಾಗಿ ಯಾವುದೇ ಮೂಲದಿಂದ ಶಕ್ತಿಯುತ ಡೇಟಾಫ್ರೇಮ್ ರಚನೆಗೆ ಡೇಟಾವನ್ನು ಸೇವಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.
ತೀರ್ಮಾನ: ಡೇಟಾ ಪ್ರಭುತ್ವಕ್ಕಾಗಿ ನಿಮ್ಮ ಅಡಿಪಾಯ
ಪೈಥಾನ್‌ನಲ್ಲಿ ಯಾವುದೇ ಗಂಭೀರ ಡೇಟಾ ಕೆಲಸಕ್ಕಾಗಿ ಪಾಂಡಾಸ್ ಡೇಟಾಫ್ರೇಮ್ ಕೇಂದ್ರ ಡೇಟಾ ರಚನೆಯಾಗಿದೆ. ನಾವು ನೋಡಿದಂತೆ, ಪಾಂಡಾಸ್ ಈ ರಚನೆಗಳನ್ನು ವ್ಯಾಪಕ ಶ್ರೇಣಿಯ ಸ್ವರೂಪಗಳಿಂದ ಪ್ರಾರಂಭಿಸಲು ಹೊಂದಿಕೊಳ್ಳುವ ಮತ್ತು ಅಂತರ್ಗತ ಪರಿಕರಗಳ ಗುಂಪನ್ನು ನೀಡುತ್ತದೆ. ಡಿಕ್ಷನರಿಗಳು, ಲಿಸ್ಟ್‌ಗಳು ಮತ್ತು ನಂಪಿ ಅರೇಗಳಿಂದ ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ಹೇಗೆ ರಚಿಸುವುದು ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ನಿಮ್ಮ ಡೇಟಾ ವಿಶ್ಲೇಷಣೆ ಯೋಜನೆಗಳಿಗೆ ನೀವು ಘನ ಅಡಿಪಾಯವನ್ನು ನಿರ್ಮಿಸಿದ್ದೀರಿ.
ನಿಮ್ಮ ಡೇಟಾದ ಮೂಲ ರಚನೆಗೆ ಉತ್ತಮವಾಗಿ ಹೊಂದಿಕೆಯಾಗುವ ವಿಧಾನವನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು ಮುಖ್ಯವಾಗಿದೆ. ಇದು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸುವುದು ಮತ್ತು ಹೆಚ್ಚು ಓದಬಲ್ಲದು ಮಾತ್ರವಲ್ಲದೆ ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿದೆ. ಇಲ್ಲಿಂದ, ನೀವು ಡೇಟಾ ಸ್ವಚ್ಛಗೊಳಿಸುವಿಕೆ, ಪರಿಶೋಧನೆ, ಪರಿವರ್ತನೆ ಮತ್ತು ದೃಶ್ಯೀಕರಣದ ಉತ್ತೇಜಕ ಕಾರ್ಯಗಳಿಗೆ ತೆರಳಲು ಸಿದ್ಧರಿದ್ದೀರಿ. ಹ್ಯಾಪಿ ಕೋಡಿಂಗ್!