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

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

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

ಪೈಥಾನ್ ಮತ್ತು ಆರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ವಿಶ್ಲೇಷಣಾತ್ಮಕ ವಿಂಡೋ ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸುವವರೆಗೆ ನಾವು ಅದನ್ನು ಲೋಡ್ ಮಾಡುವುದರಿಂದ ಡೇಟಾ ವಿಶ್ಲೇಷಣೆಯ ಸಂಪೂರ್ಣ ಮಾರ್ಗದ ಮೂಲಕ ಹಂತ ಹಂತವಾಗಿ ಹೋಗುತ್ತೇವೆ.

ಪರಿವಿಡಿ

ಪರಿಗಣನೆಯಲ್ಲಿರುವ ಪ್ಯಾಕೇಜ್‌ಗಳಲ್ಲಿ ಕೆಲವು ಡೇಟಾ ಸಂಸ್ಕರಣಾ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸುವುದು ಎಂಬುದನ್ನು ನೀವು ಮರೆತಿದ್ದರೆ ಈ ಲೇಖನವನ್ನು ಚೀಟ್ ಶೀಟ್ ಆಗಿ ಬಳಸಬಹುದು.

R ಮತ್ತು ಪೈಥಾನ್ ನಡುವಿನ ಮುಖ್ಯ ಸಿಂಟ್ಯಾಕ್ಸ್ ವ್ಯತ್ಯಾಸಗಳು
1.1. ಪ್ಯಾಕೇಜ್ ಕಾರ್ಯಗಳನ್ನು ಪ್ರವೇಶಿಸಲಾಗುತ್ತಿದೆ
1.2. ನಿಯೋಜನೆ
1.3. ಸೂಚ್ಯಂಕ
1.4. ವಿಧಾನಗಳು ಮತ್ತು OOP
1.5. ಪೈಪ್ಲೈನ್ಗಳು
1.6. ಡೇಟಾ ರಚನೆಗಳು
ನಾವು ಬಳಸುವ ಪ್ಯಾಕೇಜುಗಳ ಬಗ್ಗೆ ಕೆಲವು ಪದಗಳು
2.1. ಅಚ್ಚುಕಟ್ಟಾದ
2.2. ಡೇಟಾ. ಟೇಬಲ್
2.3. ಪಾಂಡಾಗಳು
ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ಸ್ಥಾಪಿಸಲಾಗುತ್ತಿದೆ
ಡೇಟಾವನ್ನು ಲೋಡ್ ಮಾಡಲಾಗುತ್ತಿದೆ
ಡೇಟಾಫ್ರೇಮ್‌ಗಳನ್ನು ರಚಿಸುವುದು
ನಿಮಗೆ ಅಗತ್ಯವಿರುವ ಕಾಲಮ್‌ಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು
ಫಿಲ್ಟರಿಂಗ್ ಸಾಲುಗಳು
ಗುಂಪುಗಾರಿಕೆ ಮತ್ತು ಒಟ್ಟುಗೂಡಿಸುವಿಕೆ
ಕೋಷ್ಟಕಗಳ ಲಂಬ ಒಕ್ಕೂಟ (UNION)
ಕೋಷ್ಟಕಗಳ ಅಡ್ಡ ಜೋಡಣೆ (ಸೇರಿಸು)
ಮೂಲ ವಿಂಡೋ ಕಾರ್ಯಗಳು ಮತ್ತು ಲೆಕ್ಕಾಚಾರದ ಕಾಲಮ್‌ಗಳು
ಆರ್ ಮತ್ತು ಪೈಥಾನ್‌ನಲ್ಲಿ ಡೇಟಾ ಸಂಸ್ಕರಣಾ ವಿಧಾನಗಳ ನಡುವಿನ ಪತ್ರವ್ಯವಹಾರ ಕೋಷ್ಟಕ
ತೀರ್ಮಾನಕ್ಕೆ
ನೀವು ಯಾವ ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಬಳಸುತ್ತೀರಿ ಎಂಬುದರ ಕುರಿತು ಒಂದು ಸಣ್ಣ ಸಮೀಕ್ಷೆ

ನೀವು ಡೇಟಾ ವಿಶ್ಲೇಷಣೆಯಲ್ಲಿ ಆಸಕ್ತಿ ಹೊಂದಿದ್ದರೆ, ನೀವು ನನ್ನದನ್ನು ಕಾಣಬಹುದು ಟೆಲಿಗ್ರಾಮ್ и YouTube ವಾಹಿನಿಗಳು. ಹೆಚ್ಚಿನ ವಿಷಯವನ್ನು R ಭಾಷೆಗೆ ಮೀಸಲಿಡಲಾಗಿದೆ.

R ಮತ್ತು ಪೈಥಾನ್ ನಡುವಿನ ಮುಖ್ಯ ಸಿಂಟ್ಯಾಕ್ಸ್ ವ್ಯತ್ಯಾಸಗಳು

ಪೈಥಾನ್‌ನಿಂದ R ಗೆ ಬದಲಾಯಿಸಲು ನಿಮಗೆ ಸುಲಭವಾಗುವಂತೆ ಮಾಡಲು, ಅಥವಾ ಪ್ರತಿಯಾಗಿ, ನೀವು ಗಮನ ಹರಿಸಬೇಕಾದ ಕೆಲವು ಮುಖ್ಯ ಅಂಶಗಳನ್ನು ನಾನು ನೀಡುತ್ತೇನೆ.

ಪ್ಯಾಕೇಜ್ ಕಾರ್ಯಗಳನ್ನು ಪ್ರವೇಶಿಸಲಾಗುತ್ತಿದೆ

ಒಮ್ಮೆ ಪ್ಯಾಕೇಜ್ ಅನ್ನು R ಗೆ ಲೋಡ್ ಮಾಡಿದ ನಂತರ, ಅದರ ಕಾರ್ಯಗಳನ್ನು ಪ್ರವೇಶಿಸಲು ನೀವು ಪ್ಯಾಕೇಜ್ ಹೆಸರನ್ನು ಸೂಚಿಸುವ ಅಗತ್ಯವಿಲ್ಲ. ಹೆಚ್ಚಿನ ಸಂದರ್ಭಗಳಲ್ಲಿ ಇದನ್ನು R ನಲ್ಲಿ ಸ್ವೀಕರಿಸಲಾಗುವುದಿಲ್ಲ, ಆದರೆ ಇದು ಸ್ವೀಕಾರಾರ್ಹವಾಗಿದೆ. ನಿಮ್ಮ ಕೋಡ್‌ನಲ್ಲಿ ಅದರ ಕಾರ್ಯಗಳಲ್ಲಿ ಒಂದನ್ನು ನಿಮಗೆ ಅಗತ್ಯವಿದ್ದರೆ ನೀವು ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳಬೇಕಾಗಿಲ್ಲ, ಆದರೆ ಪ್ಯಾಕೇಜ್‌ನ ಹೆಸರು ಮತ್ತು ಕಾರ್ಯದ ಹೆಸರನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುವ ಮೂಲಕ ಅದನ್ನು ಕರೆ ಮಾಡಿ. R ನಲ್ಲಿ ಪ್ಯಾಕೇಜ್ ಮತ್ತು ಫಂಕ್ಷನ್ ಹೆಸರುಗಳ ನಡುವಿನ ವಿಭಜಕವು ಡಬಲ್ ಕೊಲೊನ್ ಆಗಿದೆ. package_name::function_name().

ಪೈಥಾನ್‌ನಲ್ಲಿ, ಇದಕ್ಕೆ ವಿರುದ್ಧವಾಗಿ, ಪ್ಯಾಕೇಜ್‌ನ ಕಾರ್ಯಗಳನ್ನು ಅದರ ಹೆಸರನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಸೂಚಿಸುವ ಮೂಲಕ ಕರೆಯುವುದನ್ನು ಕ್ಲಾಸಿಕ್ ಎಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ. ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಿದಾಗ, ಅದನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಸಂಕ್ಷಿಪ್ತ ಹೆಸರನ್ನು ನೀಡಲಾಗುತ್ತದೆ, ಉದಾ. pandas ಸಾಮಾನ್ಯವಾಗಿ ಒಂದು ಗುಪ್ತನಾಮವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ pd. ಒಂದು ಪ್ಯಾಕೇಜ್ ಕಾರ್ಯವನ್ನು ಡಾಟ್ ಮೂಲಕ ಪ್ರವೇಶಿಸಲಾಗುತ್ತದೆ package_name.function_name().

ನಿಯೋಜನೆ

R ನಲ್ಲಿ, ವಸ್ತುವಿಗೆ ಮೌಲ್ಯವನ್ನು ನಿಯೋಜಿಸಲು ಬಾಣವನ್ನು ಬಳಸುವುದು ಸಾಮಾನ್ಯವಾಗಿದೆ. obj_name <- value, ಒಂದೇ ಸಮ ಚಿಹ್ನೆಯನ್ನು ಅನುಮತಿಸಲಾಗಿದ್ದರೂ, ಆರ್‌ನಲ್ಲಿನ ಏಕ ಸಮಾನ ಚಿಹ್ನೆಯನ್ನು ಪ್ರಾಥಮಿಕವಾಗಿ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಮೌಲ್ಯಗಳನ್ನು ರವಾನಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ.

ಪೈಥಾನ್‌ನಲ್ಲಿ, ನಿಯೋಜನೆಯನ್ನು ಒಂದೇ ಸಮ ಚಿಹ್ನೆಯೊಂದಿಗೆ ಪ್ರತ್ಯೇಕವಾಗಿ ಮಾಡಲಾಗುತ್ತದೆ obj_name = value.

ಸೂಚ್ಯಂಕ

ಇಲ್ಲಿ ಸಾಕಷ್ಟು ಗಮನಾರ್ಹ ವ್ಯತ್ಯಾಸಗಳೂ ಇವೆ. R ನಲ್ಲಿ, ಇಂಡೆಕ್ಸಿಂಗ್ ಒಂದರಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ ಮತ್ತು ಫಲಿತಾಂಶದ ಶ್ರೇಣಿಯಲ್ಲಿನ ಎಲ್ಲಾ ನಿರ್ದಿಷ್ಟ ಅಂಶಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ,

ಪೈಥಾನ್‌ನಲ್ಲಿ, ಸೂಚ್ಯಂಕವು ಶೂನ್ಯದಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ ಮತ್ತು ಆಯ್ದ ಶ್ರೇಣಿಯು ಸೂಚ್ಯಂಕದಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಕೊನೆಯ ಅಂಶವನ್ನು ಒಳಗೊಂಡಿರುವುದಿಲ್ಲ. ಆದ್ದರಿಂದ ವಿನ್ಯಾಸ x[i:j] ಪೈಥಾನ್‌ನಲ್ಲಿ j ಅಂಶವನ್ನು ಒಳಗೊಂಡಿರುವುದಿಲ್ಲ.

R ಸಂಕೇತದಲ್ಲಿ ಋಣಾತ್ಮಕ ಸೂಚಿಕೆಯಲ್ಲಿ ವ್ಯತ್ಯಾಸಗಳಿವೆ x[-1] ಕೊನೆಯದನ್ನು ಹೊರತುಪಡಿಸಿ ವೆಕ್ಟರ್‌ನ ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಪೈಥಾನ್‌ನಲ್ಲಿ, ಇದೇ ರೀತಿಯ ಸಂಕೇತವು ಕೊನೆಯ ಅಂಶವನ್ನು ಮಾತ್ರ ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

ವಿಧಾನಗಳು ಮತ್ತು OOP

R ತನ್ನದೇ ಆದ ರೀತಿಯಲ್ಲಿ OOP ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ, ನಾನು ಈ ಬಗ್ಗೆ ಲೇಖನದಲ್ಲಿ ಬರೆದಿದ್ದೇನೆ "ಆರ್ ಭಾಷೆಯಲ್ಲಿ OOP (ಭಾಗ 1): S3 ತರಗತಿಗಳು". ಸಾಮಾನ್ಯವಾಗಿ, R ಒಂದು ಕ್ರಿಯಾತ್ಮಕ ಭಾಷೆಯಾಗಿದೆ, ಮತ್ತು ಅದರಲ್ಲಿರುವ ಎಲ್ಲವನ್ನೂ ಕಾರ್ಯಗಳ ಮೇಲೆ ನಿರ್ಮಿಸಲಾಗಿದೆ. ಆದ್ದರಿಂದ, ಉದಾಹರಣೆಗೆ, ಎಕ್ಸೆಲ್ ಬಳಕೆದಾರರಿಗೆ, ಹೋಗಿ tydiverse ಇದು ಹೆಚ್ಚು ಸುಲಭವಾಗಿರುತ್ತದೆ pandas. ಇದು ನನ್ನ ವ್ಯಕ್ತಿನಿಷ್ಠ ಅಭಿಪ್ರಾಯವಾಗಿರಬಹುದು.

ಸಂಕ್ಷಿಪ್ತವಾಗಿ, R ನಲ್ಲಿನ ವಸ್ತುಗಳು ವಿಧಾನಗಳನ್ನು ಹೊಂದಿಲ್ಲ (ನಾವು S3 ತರಗತಿಗಳ ಬಗ್ಗೆ ಮಾತನಾಡಿದರೆ, ಆದರೆ ಇತರ OOP ಅಳವಡಿಕೆಗಳು ಕಡಿಮೆ ಸಾಮಾನ್ಯವಾಗಿದೆ). ವಸ್ತುವಿನ ವರ್ಗವನ್ನು ಅವಲಂಬಿಸಿ ಅವುಗಳನ್ನು ವಿಭಿನ್ನವಾಗಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವ ಸಾಮಾನ್ಯೀಕೃತ ಕಾರ್ಯಗಳು ಮಾತ್ರ ಇವೆ.

ಪೈಪ್ಲೈನ್ಗಳು

ಬಹುಶಃ ಇದು ಹೆಸರಾಗಿದೆ pandas ಇದು ಸಂಪೂರ್ಣವಾಗಿ ಸರಿಯಾಗಿರುವುದಿಲ್ಲ, ಆದರೆ ನಾನು ಅರ್ಥವನ್ನು ವಿವರಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತೇನೆ.

ಮಧ್ಯಂತರ ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ಉಳಿಸದಿರಲು ಮತ್ತು ಕೆಲಸದ ವಾತಾವರಣದಲ್ಲಿ ಅನಗತ್ಯ ವಸ್ತುಗಳನ್ನು ಉತ್ಪಾದಿಸದಿರಲು, ನೀವು ಒಂದು ರೀತಿಯ ಪೈಪ್ಲೈನ್ ಅನ್ನು ಬಳಸಬಹುದು. ಆ. ಲೆಕ್ಕಾಚಾರದ ಫಲಿತಾಂಶವನ್ನು ಒಂದು ಕಾರ್ಯದಿಂದ ಇನ್ನೊಂದಕ್ಕೆ ರವಾನಿಸಿ ಮತ್ತು ಮಧ್ಯಂತರ ಫಲಿತಾಂಶಗಳನ್ನು ಉಳಿಸಬೇಡಿ.

ಕೆಳಗಿನ ಕೋಡ್ ಉದಾಹರಣೆಯನ್ನು ತೆಗೆದುಕೊಳ್ಳೋಣ, ಅಲ್ಲಿ ನಾವು ಮಧ್ಯಂತರ ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ಪ್ರತ್ಯೇಕ ವಸ್ತುಗಳಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತೇವೆ:

temp_object <- func1()
temp_object2 <- func2(temp_object )
obj <- func3(temp_object2 )

ನಾವು 3 ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಅನುಕ್ರಮವಾಗಿ ನಿರ್ವಹಿಸಿದ್ದೇವೆ ಮತ್ತು ಪ್ರತಿಯೊಂದರ ಫಲಿತಾಂಶವನ್ನು ಪ್ರತ್ಯೇಕ ವಸ್ತುವಿನಲ್ಲಿ ಉಳಿಸಲಾಗಿದೆ. ಆದರೆ ವಾಸ್ತವವಾಗಿ, ನಮಗೆ ಈ ಮಧ್ಯಂತರ ವಸ್ತುಗಳು ಅಗತ್ಯವಿಲ್ಲ.

ಅಥವಾ ಇನ್ನೂ ಕೆಟ್ಟದಾಗಿದೆ, ಆದರೆ ಎಕ್ಸೆಲ್ ಬಳಕೆದಾರರಿಗೆ ಹೆಚ್ಚು ಪರಿಚಿತವಾಗಿದೆ.

obj  <- func3(func2(func1()))

ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಮಧ್ಯಂತರ ಲೆಕ್ಕಾಚಾರದ ಫಲಿತಾಂಶಗಳನ್ನು ಉಳಿಸಲಿಲ್ಲ, ಆದರೆ ನೆಸ್ಟೆಡ್ ಫಂಕ್ಷನ್‌ಗಳೊಂದಿಗೆ ಕೋಡ್ ಅನ್ನು ಓದುವುದು ಅತ್ಯಂತ ಅನಾನುಕೂಲವಾಗಿದೆ.

R ನಲ್ಲಿ ಡೇಟಾ ಪ್ರಕ್ರಿಯೆಗೆ ಹಲವಾರು ವಿಧಾನಗಳನ್ನು ನಾವು ನೋಡುತ್ತೇವೆ ಮತ್ತು ಅವುಗಳು ಒಂದೇ ರೀತಿಯ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ವಿಭಿನ್ನ ರೀತಿಯಲ್ಲಿ ನಿರ್ವಹಿಸುತ್ತವೆ.

ಗ್ರಂಥಾಲಯದಲ್ಲಿ ಪೈಪ್‌ಲೈನ್‌ಗಳು tidyverse ಆಪರೇಟರ್‌ನಿಂದ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗಿದೆ %>%.

obj <- func1() %>% 
            func2() %>%
            func3()

ಹೀಗಾಗಿ ನಾವು ಕೆಲಸದ ಫಲಿತಾಂಶವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತೇವೆ func1() ಮತ್ತು ಅದನ್ನು ಮೊದಲ ವಾದವಾಗಿ ರವಾನಿಸಿ func2(), ನಂತರ ನಾವು ಈ ಲೆಕ್ಕಾಚಾರದ ಫಲಿತಾಂಶವನ್ನು ಮೊದಲ ಆರ್ಗ್ಯುಮೆಂಟ್ ಆಗಿ ರವಾನಿಸುತ್ತೇವೆ func3(). ಮತ್ತು ಕೊನೆಯಲ್ಲಿ, ನಾವು ನಿರ್ವಹಿಸಿದ ಎಲ್ಲಾ ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ವಸ್ತುವಿನೊಳಗೆ ಬರೆಯುತ್ತೇವೆ obj <-.

ಮೇಲಿನ ಎಲ್ಲವನ್ನೂ ಈ ಮೆಮೆ ಮೂಲಕ ಪದಗಳಿಗಿಂತ ಉತ್ತಮವಾಗಿ ವಿವರಿಸಲಾಗಿದೆ:

В data.table ಸರಪಳಿಗಳನ್ನು ಇದೇ ರೀತಿಯಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ.

newDT <- DT[where, select|update|do, by][where, select|update|do, by][where, select|update|do, by]

ಪ್ರತಿಯೊಂದು ಚದರ ಆವರಣಗಳಲ್ಲಿ ನೀವು ಹಿಂದಿನ ಕಾರ್ಯಾಚರಣೆಯ ಫಲಿತಾಂಶವನ್ನು ಬಳಸಬಹುದು.

В pandas ಅಂತಹ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಚುಕ್ಕೆಗಳಿಂದ ಬೇರ್ಪಡಿಸಲಾಗುತ್ತದೆ.

obj = df.fun1().fun2().fun3()

ಆ. ನಾವು ನಮ್ಮ ಟೇಬಲ್ ತೆಗೆದುಕೊಳ್ಳುತ್ತೇವೆ df ಮತ್ತು ಅವಳ ವಿಧಾನವನ್ನು ಬಳಸಿ fun1(), ನಂತರ ನಾವು ಪಡೆದ ಫಲಿತಾಂಶಕ್ಕೆ ವಿಧಾನವನ್ನು ಅನ್ವಯಿಸುತ್ತೇವೆ fun2()ನಂತರ fun3(). ಪರಿಣಾಮವಾಗಿ ಫಲಿತಾಂಶವನ್ನು ವಸ್ತುವಾಗಿ ಉಳಿಸಲಾಗುತ್ತದೆ ಆಬ್ಜೆಕ್ಟ್ .

ಡೇಟಾ ರಚನೆಗಳು

ಆರ್ ಮತ್ತು ಪೈಥಾನ್‌ನಲ್ಲಿನ ಡೇಟಾ ರಚನೆಗಳು ಒಂದೇ ಆಗಿರುತ್ತವೆ, ಆದರೆ ವಿಭಿನ್ನ ಹೆಸರುಗಳನ್ನು ಹೊಂದಿವೆ.

ವಿವರಣೆ
ಆರ್ ನಲ್ಲಿ ಹೆಸರು
ಪೈಥಾನ್/ಪಾಂಡಗಳಲ್ಲಿ ಹೆಸರು

ಟೇಬಲ್ ರಚನೆ
ಡೇಟಾ.ಫ್ರೇಮ್, ಡೇಟಾ.ಟೇಬಲ್, ಟಿಬಲ್
ಡೇಟಾ ಫ್ರೇಮ್

ಮೌಲ್ಯಗಳ ಒಂದು ಆಯಾಮದ ಪಟ್ಟಿ
ವೆಕ್ಟರ್
ಪಾಂಡಾಗಳಲ್ಲಿ ಸರಣಿ ಅಥವಾ ಶುದ್ಧ ಪೈಥಾನ್‌ನಲ್ಲಿ ಪಟ್ಟಿ

ಬಹು-ಹಂತದ ನಾನ್-ಟ್ಯಾಬ್ಯುಲರ್ ರಚನೆ
ಪಟ್ಟಿ
ನಿಘಂಟು (ಆದೇಶ)

ನಾವು ಕೆಲವು ಇತರ ವೈಶಿಷ್ಟ್ಯಗಳು ಮತ್ತು ಸಿಂಟ್ಯಾಕ್ಸ್‌ನಲ್ಲಿನ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಕೆಳಗೆ ನೋಡುತ್ತೇವೆ.

ನಾವು ಬಳಸುವ ಪ್ಯಾಕೇಜುಗಳ ಬಗ್ಗೆ ಕೆಲವು ಪದಗಳು

ಮೊದಲಿಗೆ, ಈ ಲೇಖನದ ಸಮಯದಲ್ಲಿ ನಿಮಗೆ ತಿಳಿದಿರುವ ಪ್ಯಾಕೇಜ್‌ಗಳ ಬಗ್ಗೆ ನಾನು ನಿಮಗೆ ಸ್ವಲ್ಪ ಹೇಳುತ್ತೇನೆ.

ಅಚ್ಚುಕಟ್ಟಾದ

ಅಧಿಕೃತ ವೆಬ್ಸೈಟ್: tidyverse.org

ಗ್ರಂಥಾಲಯದ tidyverse RStudio ನಲ್ಲಿ ಹಿರಿಯ ಸಂಶೋಧನಾ ವಿಜ್ಞಾನಿ ಹೆಡ್ಲಿ ವಿಕ್‌ಹ್ಯಾಮ್ ಬರೆದಿದ್ದಾರೆ. tidyverse ಡೇಟಾ ಸಂಸ್ಕರಣೆಯನ್ನು ಸರಳಗೊಳಿಸುವ ಪ್ಯಾಕೇಜುಗಳ ಪ್ರಭಾವಶಾಲಿ ಸೆಟ್ ಅನ್ನು ಒಳಗೊಂಡಿದೆ, ಅವುಗಳಲ್ಲಿ 5 ಅನ್ನು CRAN ರೆಪೊಸಿಟರಿಯಿಂದ ಟಾಪ್ 10 ಡೌನ್‌ಲೋಡ್‌ಗಳಲ್ಲಿ ಸೇರಿಸಲಾಗಿದೆ.

ಗ್ರಂಥಾಲಯದ ತಿರುಳು ಈ ಕೆಳಗಿನ ಪ್ಯಾಕೇಜುಗಳನ್ನು ಒಳಗೊಂಡಿದೆ: ggplot2, dplyr, tidyr, readr, purrr, tibble, stringr, forcats. ಈ ಪ್ರತಿಯೊಂದು ಪ್ಯಾಕೇಜ್‌ಗಳು ನಿರ್ದಿಷ್ಟ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುವ ಗುರಿಯನ್ನು ಹೊಂದಿವೆ. ಉದಾಹರಣೆಗೆ dplyr ಡೇಟಾ ಕುಶಲತೆಗಾಗಿ ರಚಿಸಲಾಗಿದೆ, tidyr ಡೇಟಾವನ್ನು ಅಚ್ಚುಕಟ್ಟಾಗಿ ರೂಪಕ್ಕೆ ತರಲು, stringr ತಂತಿಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ, ಮತ್ತು ggplot2 ಅತ್ಯಂತ ಜನಪ್ರಿಯ ಡೇಟಾ ದೃಶ್ಯೀಕರಣ ಸಾಧನಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ.

ಅನುಕೂಲ tidyverse ಸರಳತೆ ಮತ್ತು ಓದಲು ಸುಲಭವಾದ ಸಿಂಟ್ಯಾಕ್ಸ್, ಇದು ಅನೇಕ ರೀತಿಯಲ್ಲಿ SQL ಪ್ರಶ್ನೆ ಭಾಷೆಗೆ ಹೋಲುತ್ತದೆ.

ಡೇಟಾ. ಟೇಬಲ್

ಅಧಿಕೃತ ವೆಬ್ಸೈಟ್: r-datatable.com

ಮೂಲಕ data.table H2O.ai ನ ಮ್ಯಾಟ್ ಡೋಲ್ ಆಗಿದೆ.

ಗ್ರಂಥಾಲಯದ ಮೊದಲ ಬಿಡುಗಡೆ 2006 ರಲ್ಲಿ ನಡೆಯಿತು.

ಪ್ಯಾಕೇಜ್ ಸಿಂಟ್ಯಾಕ್ಸ್ ನಲ್ಲಿರುವಂತೆ ಅನುಕೂಲಕರವಾಗಿಲ್ಲ tidyverse ಮತ್ತು R ನಲ್ಲಿ ಕ್ಲಾಸಿಕ್ ಡೇಟಾಫ್ರೇಮ್‌ಗಳನ್ನು ಹೆಚ್ಚು ನೆನಪಿಸುತ್ತದೆ, ಆದರೆ ಅದೇ ಸಮಯದಲ್ಲಿ ಕ್ರಿಯಾತ್ಮಕತೆಯಲ್ಲಿ ಗಮನಾರ್ಹವಾಗಿ ವಿಸ್ತರಿಸಲಾಗಿದೆ.

ಈ ಪ್ಯಾಕೇಜ್‌ನಲ್ಲಿನ ಟೇಬಲ್‌ನೊಂದಿಗೆ ಎಲ್ಲಾ ಮ್ಯಾನಿಪ್ಯುಲೇಷನ್‌ಗಳನ್ನು ಚದರ ಬ್ರಾಕೆಟ್‌ಗಳಲ್ಲಿ ವಿವರಿಸಲಾಗಿದೆ ಮತ್ತು ನೀವು ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಅನುವಾದಿಸಿದರೆ data.table SQL ನಲ್ಲಿ, ನೀವು ಈ ರೀತಿಯದನ್ನು ಪಡೆಯುತ್ತೀರಿ: data.table[ WHERE, SELECT, GROUP BY ]

ಈ ಪ್ಯಾಕೇಜಿನ ಸಾಮರ್ಥ್ಯವು ದೊಡ್ಡ ಪ್ರಮಾಣದ ಡೇಟಾವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವ ವೇಗವಾಗಿದೆ.

ಪಾಂಡಾಗಳು

ಅಧಿಕೃತ ವೆಬ್ಸೈಟ್: pandas.pydata.org

ಲೈಬ್ರರಿಯ ಹೆಸರು "ಪ್ಯಾನಲ್ ಡೇಟಾ" ಎಂಬ ಇಕೊನೊಮೆಟ್ರಿಕ್ ಪದದಿಂದ ಬಂದಿದೆ, ಇದನ್ನು ಬಹುಆಯಾಮದ ರಚನಾತ್ಮಕ ಮಾಹಿತಿಯ ಸೆಟ್‌ಗಳನ್ನು ವಿವರಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ.

ಮೂಲಕ pandas ಅಮೆರಿಕನ್ ವೆಸ್ ಮೆಕಿನ್ನಿ ಆಗಿದೆ.

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

ಹೆಚ್ಚುವರಿ ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ಸ್ಥಾಪಿಸಲಾಗುತ್ತಿದೆ

ಈ ಲೇಖನದಲ್ಲಿ ಚರ್ಚಿಸಲಾದ ಪ್ಯಾಕೇಜುಗಳನ್ನು ಮೂಲಭೂತ R ಮತ್ತು ಪೈಥಾನ್ ವಿತರಣೆಗಳಲ್ಲಿ ಸೇರಿಸಲಾಗಿಲ್ಲ. ಸಣ್ಣ ಎಚ್ಚರಿಕೆ ಇದ್ದರೂ, ನೀವು Anaconda ವಿತರಣೆಯನ್ನು ಸ್ಥಾಪಿಸಿದರೆ, ನಂತರ ಹೆಚ್ಚುವರಿಯಾಗಿ ಸ್ಥಾಪಿಸಿ pandas ಅಗತ್ಯವಿಲ್ಲ.

R ನಲ್ಲಿ ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ಸ್ಥಾಪಿಸುವುದು

ನೀವು ಒಮ್ಮೆಯಾದರೂ RStudio ಅಭಿವೃದ್ಧಿ ಪರಿಸರವನ್ನು ತೆರೆದಿದ್ದರೆ, R ನಲ್ಲಿ ಅಗತ್ಯವಿರುವ ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಹೇಗೆ ಸ್ಥಾಪಿಸಬೇಕು ಎಂದು ನಿಮಗೆ ಈಗಾಗಲೇ ತಿಳಿದಿರಬಹುದು. ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ಸ್ಥಾಪಿಸಲು, ಪ್ರಮಾಣಿತ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿ install.packages() ಅದನ್ನು ನೇರವಾಗಿ R ನಲ್ಲಿಯೇ ಚಲಾಯಿಸುವ ಮೂಲಕ.

# установка пакетов
install.packages("vroom")
install.packages("readr")
install.packages("dplyr")
install.packages("data.table")

ಅನುಸ್ಥಾಪನೆಯ ನಂತರ, ಪ್ಯಾಕೇಜುಗಳನ್ನು ಸಂಪರ್ಕಿಸಬೇಕಾಗಿದೆ, ಇದಕ್ಕಾಗಿ ಹೆಚ್ಚಿನ ಸಂದರ್ಭಗಳಲ್ಲಿ ಆಜ್ಞೆಯನ್ನು ಬಳಸಲಾಗುತ್ತದೆ library().

# подключение или импорт пакетов в рабочее окружение
library(vroom)
library(readr)
library(dplyr)
library(data.table)

ಪೈಥಾನ್‌ನಲ್ಲಿ ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ಸ್ಥಾಪಿಸಲಾಗುತ್ತಿದೆ

ಆದ್ದರಿಂದ, ನೀವು ಶುದ್ಧ ಪೈಥಾನ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿದ್ದರೆ, ನಂತರ pandas ನೀವು ಅದನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ಸ್ಥಾಪಿಸಬೇಕಾಗಿದೆ. ನಿಮ್ಮ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಅನ್ನು ಅವಲಂಬಿಸಿ ಕಮಾಂಡ್ ಲೈನ್ ಅಥವಾ ಟರ್ಮಿನಲ್ ಅನ್ನು ತೆರೆಯಿರಿ ಮತ್ತು ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ನಮೂದಿಸಿ.

pip install pandas

ನಂತರ ನಾವು ಪೈಥಾನ್‌ಗೆ ಹಿಂತಿರುಗುತ್ತೇವೆ ಮತ್ತು ಆಜ್ಞೆಯೊಂದಿಗೆ ಸ್ಥಾಪಿಸಲಾದ ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳುತ್ತೇವೆ import.

import pandas as pd

ಡೇಟಾವನ್ನು ಲೋಡ್ ಮಾಡಲಾಗುತ್ತಿದೆ

ದತ್ತಾಂಶ ವಿಶ್ಲೇಷಣೆಯಲ್ಲಿ ದತ್ತಾಂಶ ಗಣಿಗಾರಿಕೆಯು ಪ್ರಮುಖ ಹಂತಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ. ಪೈಥಾನ್ ಮತ್ತು ಆರ್ ಎರಡೂ, ಬಯಸಿದಲ್ಲಿ, ಯಾವುದೇ ಮೂಲಗಳಿಂದ ಡೇಟಾವನ್ನು ಪಡೆಯಲು ನಿಮಗೆ ವ್ಯಾಪಕ ಅವಕಾಶಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ: ಸ್ಥಳೀಯ ಫೈಲ್‌ಗಳು, ಇಂಟರ್ನೆಟ್‌ನಿಂದ ಫೈಲ್‌ಗಳು, ವೆಬ್‌ಸೈಟ್‌ಗಳು, ಎಲ್ಲಾ ರೀತಿಯ ಡೇಟಾಬೇಸ್‌ಗಳು.

ಲೇಖನದ ಉದ್ದಕ್ಕೂ ನಾವು ಹಲವಾರು ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ಬಳಸುತ್ತೇವೆ:

Google Analytics ನಿಂದ ಎರಡು ಡೌನ್‌ಲೋಡ್‌ಗಳು.
ಟೈಟಾನಿಕ್ ಪ್ಯಾಸೆಂಜರ್ ಡೇಟಾಸೆಟ್.

ಎಲ್ಲಾ ಡೇಟಾ ನನ್ನ ಮೇಲೆ ಇದೆ GitHub csv ಮತ್ತು tsv ಫೈಲ್‌ಗಳ ರೂಪದಲ್ಲಿ. ನಾವು ಅವರನ್ನು ಎಲ್ಲಿಂದ ವಿನಂತಿಸುತ್ತೇವೆ?

R ಗೆ ಡೇಟಾವನ್ನು ಲೋಡ್ ಮಾಡಲಾಗುತ್ತಿದೆ: ಟೈಡಿವರ್ಸ್, ವ್ರೂಮ್, ರೀಡರ್

ಲೈಬ್ರರಿಗೆ ಡೇಟಾವನ್ನು ಲೋಡ್ ಮಾಡಲು tidyverse ಎರಡು ಪ್ಯಾಕೇಜ್‌ಗಳಿವೆ: vroom, readr. vroom ಹೆಚ್ಚು ಆಧುನಿಕ, ಆದರೆ ಭವಿಷ್ಯದಲ್ಲಿ ಪ್ಯಾಕೇಜುಗಳನ್ನು ಸಂಯೋಜಿಸಬಹುದು.

ನಿಂದ ಉಲ್ಲೇಖ ಅಧಿಕೃತ ದಸ್ತಾವೇಜನ್ನು vroom.

vroom vs ರೀಡರ್
ಏನು ಬಿಡುಗಡೆ ಮಾಡುತ್ತದೆ vroom ಅರ್ಥ readr? ಸದ್ಯಕ್ಕೆ ನಾವು ಎರಡು ಪ್ಯಾಕೇಜುಗಳನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ವಿಕಸನಗೊಳಿಸಲು ಯೋಜಿಸಿದ್ದೇವೆ, ಆದರೆ ಭವಿಷ್ಯದಲ್ಲಿ ನಾವು ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ಒಂದುಗೂಡಿಸುವ ಸಾಧ್ಯತೆಯಿದೆ. ವ್ರೂಮ್‌ನ ಸೋಮಾರಿ ಓದುವಿಕೆಗೆ ಒಂದು ಅನನುಕೂಲವೆಂದರೆ ಕೆಲವು ಡೇಟಾ ಸಮಸ್ಯೆಗಳನ್ನು ಮುಂದೆ ವರದಿ ಮಾಡಲಾಗುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ ಅವುಗಳನ್ನು ಹೇಗೆ ಅತ್ಯುತ್ತಮವಾಗಿ ಏಕೀಕರಿಸುವುದು ಎಂಬುದರ ಕುರಿತು ಸ್ವಲ್ಪ ಚಿಂತನೆಯ ಅಗತ್ಯವಿದೆ.

vroom vs ರೀಡರ್
ಬಿಡುಗಡೆಯ ಅರ್ಥವೇನು? vroom ಗೆ readr? ಈ ಸಮಯದಲ್ಲಿ ನಾವು ಎರಡೂ ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ಅಭಿವೃದ್ಧಿಪಡಿಸಲು ಯೋಜಿಸುತ್ತೇವೆ, ಆದರೆ ಭವಿಷ್ಯದಲ್ಲಿ ನಾವು ಅವುಗಳನ್ನು ಬಹುಶಃ ಸಂಯೋಜಿಸುತ್ತೇವೆ. ಸೋಮಾರಿತನದ ಓದುವಿಕೆಯ ಅನಾನುಕೂಲಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ vroom ಡೇಟಾದೊಂದಿಗಿನ ಕೆಲವು ಸಮಸ್ಯೆಗಳನ್ನು ಮುಂಚಿತವಾಗಿ ವರದಿ ಮಾಡಲಾಗುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ ಅವುಗಳನ್ನು ಹೇಗೆ ಉತ್ತಮವಾಗಿ ಸಂಯೋಜಿಸುವುದು ಎಂಬುದರ ಕುರಿತು ನೀವು ಯೋಚಿಸಬೇಕು.

ಈ ಲೇಖನದಲ್ಲಿ ನಾವು ಎರಡೂ ಡೇಟಾ ಲೋಡಿಂಗ್ ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ನೋಡುತ್ತೇವೆ:

R: vroom ಪ್ಯಾಕೇಜ್‌ಗೆ ಡೇಟಾವನ್ನು ಲೋಡ್ ಮಾಡಲಾಗುತ್ತಿದೆ

# install.packages("vroom")
library(vroom)

# Чтение данных
## vroom
ga_nov  <- vroom("https://raw.githubusercontent.com/selesnow/publications/master/data_example/r_python_data/ga_nowember.csv")
ga_dec  <- vroom("https://raw.githubusercontent.com/selesnow/publications/master/data_example/r_python_data/ga_december.csv")
titanic <- vroom("https://raw.githubusercontent.com/selesnow/publications/master/data_example/r_python_data/titanic.csv")

R: readr ಗೆ ಡೇಟಾವನ್ನು ಲೋಡ್ ಮಾಡಲಾಗುತ್ತಿದೆ

# install.packages("readr")
library(readr)

# Чтение данных
## readr
ga_nov  <- read_tsv("https://raw.githubusercontent.com/selesnow/publications/master/data_example/r_python_data/ga_nowember.csv")
ga_dec  <- read_tsv("https://raw.githubusercontent.com/selesnow/publications/master/data_example/r_python_data/ga_december.csv")
titanic <- read_csv("https://raw.githubusercontent.com/selesnow/publications/master/data_example/r_python_data/titanic.csv")

ಪ್ಯಾಕೇಜಿನಲ್ಲಿ vroom, csv / tsv ಡೇಟಾ ಸ್ವರೂಪವನ್ನು ಲೆಕ್ಕಿಸದೆಯೇ, ಅದೇ ಹೆಸರಿನ ಕಾರ್ಯದಿಂದ ಲೋಡಿಂಗ್ ಅನ್ನು ಕೈಗೊಳ್ಳಲಾಗುತ್ತದೆ vroom(), ಪ್ಯಾಕೇಜ್‌ನಲ್ಲಿ readr ನಾವು ಪ್ರತಿ ಫಾರ್ಮ್ಯಾಟ್‌ಗೆ ವಿಭಿನ್ನ ಕಾರ್ಯವನ್ನು ಬಳಸುತ್ತೇವೆ read_tsv() и read_csv().

R ಗೆ ಡೇಟಾವನ್ನು ಲೋಡ್ ಮಾಡಲಾಗುತ್ತಿದೆ: data.table

В data.table ಡೇಟಾವನ್ನು ಲೋಡ್ ಮಾಡಲು ಒಂದು ಕಾರ್ಯವಿದೆ fread().

R ಗೆ ಡೇಟಾವನ್ನು ಲೋಡ್ ಮಾಡಲಾಗುತ್ತಿದೆ: data.table ಪ್ಯಾಕೇಜ್

# install.packages("data.table")
library(data.table)

## data.table
ga_nov  <- fread("https://raw.githubusercontent.com/selesnow/publications/master/data_example/r_python_data/ga_nowember.csv")
ga_dec  <- fread("https://raw.githubusercontent.com/selesnow/publications/master/data_example/r_python_data/ga_december.csv")
titanic <- fread("https://raw.githubusercontent.com/selesnow/publications/master/data_example/r_python_data/titanic.csv")

ಪೈಥಾನ್‌ನಲ್ಲಿ ಡೇಟಾವನ್ನು ಲೋಡ್ ಮಾಡಲಾಗುತ್ತಿದೆ: ಪಾಂಡಾಗಳು

ನಾವು R ಪ್ಯಾಕೇಜುಗಳೊಂದಿಗೆ ಹೋಲಿಸಿದರೆ, ಈ ಸಂದರ್ಭದಲ್ಲಿ ಸಿಂಟ್ಯಾಕ್ಸ್ ಹತ್ತಿರದಲ್ಲಿದೆ pandas ಇರುತ್ತದೆ readr, ಏಕೆಂದರೆ pandas ಎಲ್ಲಿಂದಲಾದರೂ ಡೇಟಾವನ್ನು ವಿನಂತಿಸಬಹುದು ಮತ್ತು ಈ ಪ್ಯಾಕೇಜ್‌ನಲ್ಲಿ ಸಂಪೂರ್ಣ ಕುಟುಂಬ ಕಾರ್ಯಗಳಿವೆ read_*().

read_csv()
read_excel()
read_sql()
read_json()
read_html()

ಮತ್ತು ವಿವಿಧ ಸ್ವರೂಪಗಳಿಂದ ಡೇಟಾವನ್ನು ಓದಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ಅನೇಕ ಇತರ ಕಾರ್ಯಗಳು. ಆದರೆ ನಮ್ಮ ಉದ್ದೇಶಗಳಿಗೆ ಇದು ಸಾಕು read_table() ಅಥವಾ read_csv() ವಾದವನ್ನು ಬಳಸುವುದು ಸೆಪ್ಟೆಂಬರ್ ಕಾಲಮ್ ವಿಭಜಕವನ್ನು ಸೂಚಿಸಲು.

ಪೈಥಾನ್‌ನಲ್ಲಿ ಡೇಟಾವನ್ನು ಲೋಡ್ ಮಾಡಲಾಗುತ್ತಿದೆ: ಪಾಂಡಾಗಳು

import pandas as pd

ga_nov  = pd.read_csv("https://raw.githubusercontent.com/selesnow/publications/master/data_example/russian_text_in_r/ga_nowember.csv", sep = "t")
ga_dec  = pd.read_csv("https://raw.githubusercontent.com/selesnow/publications/master/data_example/russian_text_in_r/ga_december.csv", sep = "t")
titanic = pd.read_csv("https://raw.githubusercontent.com/selesnow/publications/master/data_example/russian_text_in_r/titanic.csv")

ಡೇಟಾಫ್ರೇಮ್‌ಗಳನ್ನು ರಚಿಸುವುದು

ಟೇಬಲ್ ಟೈಟಾನಿಕ್, ನಾವು ಲೋಡ್ ಮಾಡಿದ, ಒಂದು ಕ್ಷೇತ್ರವಿದೆ ಸೆಕ್ಸ್, ಇದು ಪ್ರಯಾಣಿಕರ ಲಿಂಗ ಗುರುತಿಸುವಿಕೆಯನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ.

ಆದರೆ ಪ್ರಯಾಣಿಕರ ಲಿಂಗದ ವಿಷಯದಲ್ಲಿ ಡೇಟಾದ ಹೆಚ್ಚು ಅನುಕೂಲಕರ ಪ್ರಸ್ತುತಿಗಾಗಿ, ನೀವು ಲಿಂಗ ಕೋಡ್‌ಗಿಂತ ಹೆಸರನ್ನು ಬಳಸಬೇಕು.

ಇದನ್ನು ಮಾಡಲು, ನಾವು ಸಣ್ಣ ಡೈರೆಕ್ಟರಿಯನ್ನು ರಚಿಸುತ್ತೇವೆ, ಇದರಲ್ಲಿ ಕೇವಲ 2 ಕಾಲಮ್‌ಗಳು (ಕೋಡ್ ಮತ್ತು ಲಿಂಗ ಹೆಸರು) ಮತ್ತು 2 ಸಾಲುಗಳು ಮಾತ್ರ ಇರುತ್ತವೆ.

R ನಲ್ಲಿ ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ರಚಿಸುವುದು: ಟೈಡಿವರ್ಸ್, ಡಿಪ್ಲೈರ್

ಕೆಳಗಿನ ಕೋಡ್ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ಬಯಸಿದ ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ tibble() .

R: dplyr ನಲ್ಲಿ ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ರಚಿಸುವುದು

## dplyr
### создаём справочник
gender <- tibble(id = c(1, 2),
                 gender = c("female", "male"))

R ನಲ್ಲಿ ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ರಚಿಸಲಾಗುತ್ತಿದೆ: data.table

R ನಲ್ಲಿ ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ರಚಿಸಲಾಗುತ್ತಿದೆ: data.table

## data.table
### создаём справочник
gender <- data.table(id = c(1, 2),
                    gender = c("female", "male"))

ಪೈಥಾನ್‌ನಲ್ಲಿ ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ರಚಿಸಲಾಗುತ್ತಿದೆ: ಪಾಂಡಾಗಳು

В pandas ಚೌಕಟ್ಟುಗಳನ್ನು ರಚಿಸುವುದು ಹಲವಾರು ಹಂತಗಳಲ್ಲಿ ನಡೆಯುತ್ತದೆ, ಮೊದಲು ನಾವು ನಿಘಂಟನ್ನು ರಚಿಸುತ್ತೇವೆ ಮತ್ತು ನಂತರ ನಾವು ನಿಘಂಟನ್ನು ಡೇಟಾಫ್ರೇಮ್ ಆಗಿ ಪರಿವರ್ತಿಸುತ್ತೇವೆ.

ಪೈಥಾನ್‌ನಲ್ಲಿ ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ರಚಿಸಲಾಗುತ್ತಿದೆ: ಪಾಂಡಾಗಳು

# создаём дата фрейм
gender_dict = {'id': [1, 2],
               'gender': ["female", "male"]}
# преобразуем словарь в датафрейм
gender = pd.DataFrame.from_dict(gender_dict)

ಕಾಲಮ್‌ಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಲಾಗುತ್ತಿದೆ

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

ಆದ್ದರಿಂದ, ಮೂಲ ಕೋಷ್ಟಕದೊಂದಿಗೆ ನೀವು ನಿರ್ವಹಿಸುವ ಮೊದಲ ಕಾರ್ಯಾಚರಣೆಯೆಂದರೆ ಅನಗತ್ಯ ಮಾಹಿತಿಯನ್ನು ತೆರವುಗೊಳಿಸುವುದು ಮತ್ತು ಈ ಮಾಹಿತಿಯು ಆಕ್ರಮಿಸಿಕೊಂಡಿರುವ ಮೆಮೊರಿಯನ್ನು ಮುಕ್ತಗೊಳಿಸುವುದು.

R ನಲ್ಲಿ ಕಾಲಮ್‌ಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಲಾಗುತ್ತಿದೆ: ಟೈಡಿವರ್ಸ್, ಡಿಪ್ಲೈರ್

ವಾಕ್ಯ dplyr SQL ಪ್ರಶ್ನೆ ಭಾಷೆಗೆ ಹೋಲುತ್ತದೆ, ನೀವು ಅದರೊಂದಿಗೆ ಪರಿಚಿತರಾಗಿದ್ದರೆ ನೀವು ಈ ಪ್ಯಾಕೇಜ್ ಅನ್ನು ತ್ವರಿತವಾಗಿ ಕರಗತ ಮಾಡಿಕೊಳ್ಳುತ್ತೀರಿ.

ಕಾಲಮ್ಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಲು, ಕಾರ್ಯವನ್ನು ಬಳಸಿ select().

ನೀವು ಈ ಕೆಳಗಿನ ವಿಧಾನಗಳಲ್ಲಿ ಕಾಲಮ್‌ಗಳನ್ನು ಆಯ್ಕೆಮಾಡಬಹುದಾದ ಕೋಡ್‌ನ ಉದಾಹರಣೆಗಳನ್ನು ಕೆಳಗೆ ನೀಡಲಾಗಿದೆ:

ಅಗತ್ಯವಿರುವ ಕಾಲಮ್‌ಗಳ ಹೆಸರುಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡುವುದು
ನಿಯಮಿತ ಅಭಿವ್ಯಕ್ತಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಕಾಲಮ್ ಹೆಸರುಗಳನ್ನು ನೋಡಿ
ಡೇಟಾ ಪ್ರಕಾರ ಅಥವಾ ಕಾಲಮ್‌ನಲ್ಲಿರುವ ಡೇಟಾದ ಯಾವುದೇ ಇತರ ಆಸ್ತಿಯ ಮೂಲಕ

R: dplyr ನಲ್ಲಿ ಕಾಲಮ್‌ಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಲಾಗುತ್ತಿದೆ

# Выбор нужных столбцов
## dplyr
### выбрать по названию столбцов
select(ga_nov, date, source, sessions)
### исключь по названию столбцов
select(ga_nov, -medium, -bounces)
### выбрать по регулярному выражению, стобцы имена которых заканчиваются на s
select(ga_nov, matches("s$"))
### выбрать по условию, выбираем только целочисленные столбцы
select_if(ga_nov, is.integer)

R ನಲ್ಲಿ ಕಾಲಮ್‌ಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಲಾಗುತ್ತಿದೆ: data.table

ನಲ್ಲಿ ಅದೇ ಕಾರ್ಯಾಚರಣೆಗಳು data.table ಸ್ವಲ್ಪ ವಿಭಿನ್ನವಾಗಿ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ, ಲೇಖನದ ಪ್ರಾರಂಭದಲ್ಲಿ ನಾನು ಚದರ ಆವರಣಗಳಲ್ಲಿ ಯಾವ ವಾದಗಳು ಇವೆ ಎಂಬುದರ ವಿವರಣೆಯನ್ನು ಒದಗಿಸಿದೆ data.table.

DT[i,j,by]

ಎಲ್ಲಿ:
ನಾನು - ಎಲ್ಲಿ, ಅಂದರೆ. ಸಾಲುಗಳ ಮೂಲಕ ಫಿಲ್ಟರಿಂಗ್
j - ಆಯ್ಕೆ|ಅಪ್‌ಡೇಟ್|ಮಾಡು, ಅಂದರೆ. ಕಾಲಮ್ಗಳನ್ನು ಆಯ್ಕೆಮಾಡುವುದು ಮತ್ತು ಅವುಗಳನ್ನು ಪರಿವರ್ತಿಸುವುದು
ಮೂಲಕ - ಡೇಟಾ ಗುಂಪು

R ನಲ್ಲಿ ಕಾಲಮ್‌ಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಲಾಗುತ್ತಿದೆ: data.table

## data.table
### выбрать по названию столбцов
ga_nov[ , .(date, source, sessions) ]
### исключь по названию столбцов
ga_nov[ , .SD, .SDcols = ! names(ga_nov) %like% "medium|bounces" ]
### выбрать по регулярному выражению
ga_nov[, .SD, .SDcols = patterns("s$")]

ವೇರಿಯಬಲ್ .SD ಎಲ್ಲಾ ಕಾಲಮ್‌ಗಳನ್ನು ಪ್ರವೇಶಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ, ಮತ್ತು .SDcols ನಿಮಗೆ ಅಗತ್ಯವಿರುವ ಕಾಲಮ್‌ಗಳ ಹೆಸರುಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಲು ನಿಯಮಿತ ಅಭಿವ್ಯಕ್ತಿಗಳು ಅಥವಾ ಇತರ ಕಾರ್ಯಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಅಗತ್ಯವಿರುವ ಕಾಲಮ್‌ಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಿ.

ಪೈಥಾನ್, ಪಾಂಡಾಗಳಲ್ಲಿ ಕಾಲಮ್‌ಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಲಾಗುತ್ತಿದೆ

ಹೆಸರಿನಿಂದ ಕಾಲಮ್‌ಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಲು pandas ಅವರ ಹೆಸರುಗಳ ಪಟ್ಟಿಯನ್ನು ನೀಡಿದರೆ ಸಾಕು. ಮತ್ತು ನಿಯಮಿತ ಅಭಿವ್ಯಕ್ತಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಹೆಸರಿನಿಂದ ಕಾಲಮ್ಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ಅಥವಾ ಹೊರಗಿಡಲು, ನೀವು ಕಾರ್ಯಗಳನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ drop() и filter(), ಮತ್ತು ವಾದ ಅಕ್ಷ = 1, ಅದರೊಂದಿಗೆ ನೀವು ಸಾಲುಗಳಿಗಿಂತ ಕಾಲಮ್‌ಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಅಗತ್ಯವೆಂದು ಸೂಚಿಸುತ್ತೀರಿ.

ಡೇಟಾ ಪ್ರಕಾರದ ಮೂಲಕ ಕ್ಷೇತ್ರವನ್ನು ಆಯ್ಕೆ ಮಾಡಲು, ಕಾರ್ಯವನ್ನು ಬಳಸಿ select_dtypes(), ಮತ್ತು ವಾದಗಳಿಗೆ ಸೇರಿವೆ ಅಥವಾ ಬಹಿಷ್ಕರಿಸು ನೀವು ಆಯ್ಕೆ ಮಾಡಬೇಕಾದ ಕ್ಷೇತ್ರಗಳಿಗೆ ಅನುಗುಣವಾಗಿ ಡೇಟಾ ಪ್ರಕಾರಗಳ ಪಟ್ಟಿಯನ್ನು ರವಾನಿಸಿ.

ಪೈಥಾನ್‌ನಲ್ಲಿ ಕಾಲಮ್‌ಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಲಾಗುತ್ತಿದೆ: ಪಾಂಡಾಗಳು

# Выбор полей по названию
ga_nov[['date', 'source', 'sessions']]
# Исключить по названию
ga_nov.drop(['medium', 'bounces'], axis=1)
# Выбрать по регулярному выражению
ga_nov.filter(regex="s$", axis=1)
# Выбрать числовые поля
ga_nov.select_dtypes(include=['number'])
# Выбрать текстовые поля
ga_nov.select_dtypes(include=['object'])

ಫಿಲ್ಟರಿಂಗ್ ಸಾಲುಗಳು

ಉದಾಹರಣೆಗೆ, ಮೂಲ ಕೋಷ್ಟಕವು ಹಲವಾರು ವರ್ಷಗಳ ಡೇಟಾವನ್ನು ಒಳಗೊಂಡಿರಬಹುದು, ಆದರೆ ನೀವು ಕಳೆದ ತಿಂಗಳನ್ನು ಮಾತ್ರ ವಿಶ್ಲೇಷಿಸಬೇಕಾಗಿದೆ. ಮತ್ತೊಮ್ಮೆ, ಹೆಚ್ಚುವರಿ ಸಾಲುಗಳು ಡೇಟಾ ಸಂಸ್ಕರಣಾ ಪ್ರಕ್ರಿಯೆಯನ್ನು ನಿಧಾನಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಪಿಸಿ ಮೆಮೊರಿಯನ್ನು ಮುಚ್ಚುತ್ತದೆ.

R ನಲ್ಲಿ ಸಾಲುಗಳನ್ನು ಫಿಲ್ಟರಿಂಗ್: ಟೈಡೈವರ್ಸ್, ಡಿಪ್ಲೈರ್

В dplyr ಸಾಲುಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಲು ಕಾರ್ಯವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ filter(). ಇದು ಮೊದಲ ಆರ್ಗ್ಯುಮೆಂಟ್ ಆಗಿ ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ನಂತರ ನೀವು ಫಿಲ್ಟರಿಂಗ್ ಷರತ್ತುಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡುತ್ತೀರಿ.

ಟೇಬಲ್ ಅನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಲು ತಾರ್ಕಿಕ ಅಭಿವ್ಯಕ್ತಿಗಳನ್ನು ಬರೆಯುವಾಗ, ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಉಲ್ಲೇಖಗಳಿಲ್ಲದೆ ಮತ್ತು ಟೇಬಲ್ ಹೆಸರನ್ನು ಘೋಷಿಸದೆ ಕಾಲಮ್ ಹೆಸರುಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿ.

ಫಿಲ್ಟರ್ ಮಾಡಲು ಬಹು ತಾರ್ಕಿಕ ಅಭಿವ್ಯಕ್ತಿಗಳನ್ನು ಬಳಸುವಾಗ, ಕೆಳಗಿನ ಆಪರೇಟರ್‌ಗಳನ್ನು ಬಳಸಿ:

& ಅಥವಾ ಅಲ್ಪವಿರಾಮ - ತಾರ್ಕಿಕ ಮತ್ತು
| - ತಾರ್ಕಿಕ ಅಥವಾ

R ನಲ್ಲಿ ಸಾಲುಗಳನ್ನು ಫಿಲ್ಟರಿಂಗ್: dplyr

# фильтрация строк
## dplyr
### фильтрация строк по одному условию
filter(ga_nov, source == "google")
### фильтр по двум условиям соединённым логическим и
filter(ga_nov, source == "google" & sessions >= 10)
### фильтр по двум условиям соединённым логическим или
filter(ga_nov, source == "google" | sessions >= 10)

R ನಲ್ಲಿ ಸಾಲುಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಲಾಗುತ್ತಿದೆ: data.table

ನಾನು ಈಗಾಗಲೇ ಮೇಲೆ ಬರೆದಂತೆ, ರಲ್ಲಿ data.table ಡೇಟಾ ಪರಿವರ್ತನೆ ಸಿಂಟ್ಯಾಕ್ಸ್ ಚದರ ಬ್ರಾಕೆಟ್‌ಗಳಲ್ಲಿ ಸುತ್ತುವರಿದಿದೆ.

DT[i,j,by]

ಸಾಲುಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಲು ಆರ್ಗ್ಯುಮೆಂಟ್ ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ i, ಇದು ಚದರ ಆವರಣಗಳಲ್ಲಿ ಮೊದಲ ಸ್ಥಾನವನ್ನು ಹೊಂದಿದೆ.

ಕಾಲಮ್‌ಗಳನ್ನು ಉದ್ಧರಣ ಚಿಹ್ನೆಗಳಿಲ್ಲದೆ ಮತ್ತು ಟೇಬಲ್ ಹೆಸರನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸದೆ ತಾರ್ಕಿಕ ಅಭಿವ್ಯಕ್ತಿಗಳಲ್ಲಿ ಪ್ರವೇಶಿಸಲಾಗುತ್ತದೆ.

ತಾರ್ಕಿಕ ಅಭಿವ್ಯಕ್ತಿಗಳು ಒಂದೇ ರೀತಿಯಲ್ಲಿ ಪರಸ್ಪರ ಸಂಬಂಧ ಹೊಂದಿವೆ dplyr & ಮತ್ತು | ನಿರ್ವಾಹಕರ ಮೂಲಕ.

R ನಲ್ಲಿ ಸಾಲುಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಲಾಗುತ್ತಿದೆ: data.table

## data.table
### фильтрация строк по одному условию
ga_nov[source == "google"]
### фильтр по двум условиям соединённым логическим и
ga_nov[source == "google" & sessions >= 10]
### фильтр по двум условиям соединённым логическим или
ga_nov[source == "google" | sessions >= 10]

ಪೈಥಾನ್‌ನಲ್ಲಿ ಫಿಲ್ಟರಿಂಗ್ ತಂತಿಗಳು: ಪಾಂಡಾಗಳು

ಸಾಲುಗಳ ಮೂಲಕ ಫಿಲ್ಟರ್ ಮಾಡಿ pandas ಫಿಲ್ಟರಿಂಗ್ ಅನ್ನು ಹೋಲುತ್ತದೆ data.table, ಮತ್ತು ಚದರ ಆವರಣಗಳಲ್ಲಿ ಮಾಡಲಾಗುತ್ತದೆ.

ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಡೇಟಾಫ್ರೇಮ್‌ನ ಹೆಸರನ್ನು ಸೂಚಿಸುವ ಮೂಲಕ ಕಾಲಮ್‌ಗಳಿಗೆ ಪ್ರವೇಶವನ್ನು ಅಗತ್ಯವಾಗಿ ಕೈಗೊಳ್ಳಲಾಗುತ್ತದೆ; ನಂತರ ಕಾಲಮ್ ಹೆಸರನ್ನು ಚದರ ಬ್ರಾಕೆಟ್‌ಗಳಲ್ಲಿನ ಉದ್ಧರಣ ಚಿಹ್ನೆಗಳಲ್ಲಿ ಸಹ ಸೂಚಿಸಬಹುದು (ಉದಾಹರಣೆ df['col_name']), ಅಥವಾ ಅವಧಿಯ ನಂತರ ಉಲ್ಲೇಖಗಳಿಲ್ಲದೆ (ಉದಾಹರಣೆ df.col_name).

ನೀವು ಹಲವಾರು ಷರತ್ತುಗಳ ಮೂಲಕ ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಬೇಕಾದರೆ, ಪ್ರತಿ ಷರತ್ತುಗಳನ್ನು ಆವರಣದಲ್ಲಿ ಇರಿಸಬೇಕು. ತಾರ್ಕಿಕ ಪರಿಸ್ಥಿತಿಗಳು ನಿರ್ವಾಹಕರಿಂದ ಪರಸ್ಪರ ಸಂಪರ್ಕ ಹೊಂದಿವೆ & и |.

ಪೈಥಾನ್‌ನಲ್ಲಿ ಫಿಲ್ಟರಿಂಗ್ ತಂತಿಗಳು: ಪಾಂಡಾಗಳು

# Фильтрация строк таблицы
### фильтрация строк по одному условию
ga_nov[ ga_nov['source'] == "google" ]
### фильтр по двум условиям соединённым логическим и
ga_nov[(ga_nov['source'] == "google") & (ga_nov['sessions'] >= 10)]
### фильтр по двум условиям соединённым логическим или
ga_nov[(ga_nov['source'] == "google") | (ga_nov['sessions'] >= 10)]

ಡೇಟಾದ ಗುಂಪು ಮತ್ತು ಒಟ್ಟುಗೂಡಿಸುವಿಕೆ

ದತ್ತಾಂಶ ವಿಶ್ಲೇಷಣೆಯಲ್ಲಿ ಸಾಮಾನ್ಯವಾಗಿ ಬಳಸುವ ಕಾರ್ಯಾಚರಣೆಗಳಲ್ಲಿ ಒಂದು ಗುಂಪು ಮಾಡುವುದು ಮತ್ತು ಒಟ್ಟುಗೂಡಿಸುವುದು.

ಈ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸುವ ಸಿಂಟ್ಯಾಕ್ಸ್ ನಾವು ಪರಿಶೀಲಿಸುವ ಎಲ್ಲಾ ಪ್ಯಾಕೇಜ್‌ಗಳಲ್ಲಿ ಹರಡಿಕೊಂಡಿರುತ್ತದೆ.

ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ಉದಾಹರಣೆಯಾಗಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತೇವೆ ಟೈಟಾನಿಕ್, ಮತ್ತು ಕ್ಯಾಬಿನ್ ವರ್ಗವನ್ನು ಅವಲಂಬಿಸಿ ಟಿಕೆಟ್‌ಗಳ ಸಂಖ್ಯೆ ಮತ್ತು ಸರಾಸರಿ ವೆಚ್ಚವನ್ನು ಲೆಕ್ಕಹಾಕಿ.

R ನಲ್ಲಿ ಡೇಟಾದ ಗುಂಪು ಮತ್ತು ಒಟ್ಟುಗೂಡಿಸುವಿಕೆ: ಟೈಡಿವರ್ಸ್, ಡಿಪ್ಲೈರ್

В dplyr ಕಾರ್ಯವನ್ನು ಗುಂಪು ಮಾಡಲು ಬಳಸಲಾಗುತ್ತದೆ group_by(), ಮತ್ತು ಒಟ್ಟುಗೂಡಿಸುವಿಕೆಗಾಗಿ summarise(). ವಾಸ್ತವವಾಗಿ, dplyr ಕಾರ್ಯಗಳ ಸಂಪೂರ್ಣ ಕುಟುಂಬವಿದೆ summarise_*(), ಆದರೆ ಈ ಲೇಖನದ ಉದ್ದೇಶವು ಮೂಲ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಹೋಲಿಸುವುದು, ಆದ್ದರಿಂದ ನಾವು ಅಂತಹ ಕಾಡಿನೊಳಗೆ ಹೋಗುವುದಿಲ್ಲ.

ಮೂಲ ಒಟ್ಟುಗೂಡಿಸುವ ಕಾರ್ಯಗಳು:

sum() - ಸಂಕಲನ
min() / max() - ಕನಿಷ್ಠ ಮತ್ತು ಗರಿಷ್ಠ ಮೌಲ್ಯ
mean() - ಸರಾಸರಿ
median() - ಮಧ್ಯಮ
length() - ಪ್ರಮಾಣ

R: dplyr ನಲ್ಲಿ ಗುಂಪು ಮಾಡುವಿಕೆ ಮತ್ತು ಒಟ್ಟುಗೂಡಿಸುವಿಕೆ

## dplyr
### группировка и агрегация строк
group_by(titanic, Pclass) %>%
  summarise(passangers = length(PassengerId),
            avg_price  = mean(Fare))

ಕಾರ್ಯದಲ್ಲಿ group_by() ನಾವು ಮೊದಲ ವಾದವಾಗಿ ಟೇಬಲ್ ಅನ್ನು ಹಾದುಹೋದೆವು ಟೈಟಾನಿಕ್, ತದನಂತರ ಕ್ಷೇತ್ರವನ್ನು ಸೂಚಿಸಿದೆ ಪಿಸಿ ವರ್ಗ, ಅದರ ಮೂಲಕ ನಾವು ನಮ್ಮ ಟೇಬಲ್ ಅನ್ನು ಗುಂಪು ಮಾಡುತ್ತೇವೆ. ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಈ ಕಾರ್ಯಾಚರಣೆಯ ಫಲಿತಾಂಶ %>% ಕಾರ್ಯಕ್ಕೆ ಮೊದಲ ಆರ್ಗ್ಯುಮೆಂಟ್ ಆಗಿ ರವಾನಿಸಲಾಗಿದೆ summarise(), ಮತ್ತು ಇನ್ನೂ 2 ಕ್ಷೇತ್ರಗಳನ್ನು ಸೇರಿಸಲಾಗಿದೆ: ಪ್ರಯಾಣಿಕರು и ಸರಾಸರಿ_ಬೆಲೆ. ಮೊದಲನೆಯದಾಗಿ, ಕಾರ್ಯವನ್ನು ಬಳಸುವುದು length() ಟಿಕೆಟ್‌ಗಳ ಸಂಖ್ಯೆಯನ್ನು ಲೆಕ್ಕಹಾಕಲಾಗಿದೆ, ಮತ್ತು ಎರಡನೆಯದರಲ್ಲಿ ಕಾರ್ಯವನ್ನು ಬಳಸಿ mean() ಸರಾಸರಿ ಟಿಕೆಟ್ ದರವನ್ನು ಪಡೆದರು.

R ನಲ್ಲಿ ಡೇಟಾದ ಗುಂಪು ಮತ್ತು ಒಟ್ಟುಗೂಡಿಸುವಿಕೆ: data.table

В data.table ವಾದವನ್ನು ಒಟ್ಟುಗೂಡಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ j ಇದು ಚದರ ಬ್ರಾಕೆಟ್‌ಗಳಲ್ಲಿ ಮತ್ತು ಗುಂಪುಗಾರಿಕೆಗೆ ಎರಡನೇ ಸ್ಥಾನವನ್ನು ಹೊಂದಿದೆ by ಅಥವಾ keyby, ಇದು ಮೂರನೇ ಸ್ಥಾನವನ್ನು ಹೊಂದಿದೆ.

ಈ ಸಂದರ್ಭದಲ್ಲಿ ಒಟ್ಟುಗೂಡಿಸುವ ಕಾರ್ಯಗಳ ಪಟ್ಟಿಯು ವಿವರಿಸಿದಂತೆಯೇ ಇರುತ್ತದೆ dplyr, ಏಕೆಂದರೆ ಇವು ಮೂಲಭೂತ R ಸಿಂಟ್ಯಾಕ್ಸ್‌ನಿಂದ ಕಾರ್ಯಗಳಾಗಿವೆ.

R ನಲ್ಲಿ ಗುಂಪು ಮಾಡುವಿಕೆ ಮತ್ತು ಒಟ್ಟುಗೂಡಿಸುವಿಕೆ: data.table

## data.table
### фильтрация строк по одному условию
titanic[, .(passangers = length(PassengerId),
            avg_price  = mean(Fare)),
        by = Pclass]

ಪೈಥಾನ್‌ನಲ್ಲಿ ಡೇಟಾದ ಗುಂಪು ಮತ್ತು ಒಟ್ಟುಗೂಡಿಸುವಿಕೆ: ಪಾಂಡಾಗಳು

ಗುಂಪು ಮಾಡುವುದು pandas ಹೋಲುತ್ತದೆ dplyr, ಆದರೆ ಒಟ್ಟುಗೂಡಿಸುವಿಕೆಯು ಹೋಲುವಂತಿಲ್ಲ dplyr ಮೇಲೆ ಅಲ್ಲ data.table.

ಗುಂಪು ಮಾಡಲು, ವಿಧಾನವನ್ನು ಬಳಸಿ groupby(), ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ಗುಂಪು ಮಾಡುವ ಕಾಲಮ್‌ಗಳ ಪಟ್ಟಿಯನ್ನು ನೀವು ರವಾನಿಸಬೇಕಾಗುತ್ತದೆ.

ಒಟ್ಟುಗೂಡಿಸಲು ನೀವು ವಿಧಾನವನ್ನು ಬಳಸಬಹುದು agg()ಇದು ನಿಘಂಟನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ. ನಿಘಂಟು ಕೀಗಳು ನೀವು ಒಟ್ಟುಗೂಡಿಸುವ ಕಾರ್ಯಗಳನ್ನು ಅನ್ವಯಿಸುವ ಕಾಲಮ್‌ಗಳಾಗಿವೆ ಮತ್ತು ಮೌಲ್ಯಗಳು ಒಟ್ಟುಗೂಡಿಸುವ ಕಾರ್ಯಗಳ ಹೆಸರುಗಳಾಗಿವೆ.

ಒಟ್ಟುಗೂಡಿಸುವ ಕಾರ್ಯಗಳು:

sum() - ಸಂಕಲನ
min() / max() - ಕನಿಷ್ಠ ಮತ್ತು ಗರಿಷ್ಠ ಮೌಲ್ಯ
mean() - ಸರಾಸರಿ
median() - ಮಧ್ಯಮ
count() - ಪ್ರಮಾಣ

ಕಾರ್ಯ reset_index() ಕೆಳಗಿನ ಉದಾಹರಣೆಯಲ್ಲಿ ನೆಸ್ಟೆಡ್ ಇಂಡೆಕ್ಸ್‌ಗಳನ್ನು ಮರುಹೊಂದಿಸಲು ಇದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ pandas ಡೇಟಾ ಒಟ್ಟುಗೂಡಿಸುವಿಕೆಯ ನಂತರ ಡೀಫಾಲ್ಟ್.

ಚಿಹ್ನೆ ಮುಂದಿನ ಸಾಲಿಗೆ ಹೋಗಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ಪೈಥಾನ್‌ನಲ್ಲಿ ಗುಂಪುಗಾರಿಕೆ ಮತ್ತು ಒಟ್ಟುಗೂಡಿಸುವಿಕೆ: ಪಾಂಡಾಗಳು

# группировка и агрегация данных
titanic.groupby(["Pclass"]).
    agg({'PassengerId': 'count', 'Fare': 'mean'}).
        reset_index()

ಕೋಷ್ಟಕಗಳ ಲಂಬ ಜೋಡಣೆ

ಒಂದೇ ರಚನೆಯ ಎರಡು ಅಥವಾ ಹೆಚ್ಚಿನ ಕೋಷ್ಟಕಗಳನ್ನು ನೀವು ಸೇರುವ ಕಾರ್ಯಾಚರಣೆ. ನಾವು ಲೋಡ್ ಮಾಡಿದ ಡೇಟಾವು ಕೋಷ್ಟಕಗಳನ್ನು ಒಳಗೊಂಡಿದೆ ga_nov и ga_dec. ಈ ಕೋಷ್ಟಕಗಳು ರಚನೆಯಲ್ಲಿ ಒಂದೇ ಆಗಿರುತ್ತವೆ, ಅಂದರೆ. ಅದೇ ಕಾಲಮ್‌ಗಳು ಮತ್ತು ಈ ಕಾಲಮ್‌ಗಳಲ್ಲಿನ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ಹೊಂದಿವೆ.

ಇದು ನವೆಂಬರ್ ಮತ್ತು ಡಿಸೆಂಬರ್ ತಿಂಗಳಿಗೆ Google Analytics ನಿಂದ ಅಪ್‌ಲೋಡ್ ಆಗಿದೆ, ಈ ವಿಭಾಗದಲ್ಲಿ ನಾವು ಈ ಡೇಟಾವನ್ನು ಒಂದು ಟೇಬಲ್‌ಗೆ ಸಂಯೋಜಿಸುತ್ತೇವೆ.

R ನಲ್ಲಿ ಲಂಬವಾಗಿ ಸೇರುವ ಕೋಷ್ಟಕಗಳು: ಟೈಡಿವರ್ಸ್, ಡಿಪ್ಲೈರ್

В dplyr ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು 2 ಕೋಷ್ಟಕಗಳನ್ನು ಒಂದಕ್ಕೆ ಸಂಯೋಜಿಸಬಹುದು bind_rows(), ಅದರ ವಾದಗಳಾಗಿ ಕೋಷ್ಟಕಗಳನ್ನು ಹಾದುಹೋಗುವುದು.

R ನಲ್ಲಿ ಸಾಲುಗಳನ್ನು ಫಿಲ್ಟರಿಂಗ್: dplyr

# Вертикальное объединение таблиц
## dplyr
bind_rows(ga_nov, ga_dec)

R ನಲ್ಲಿ ಕೋಷ್ಟಕಗಳನ್ನು ಲಂಬವಾಗಿ ಸೇರಿಸುವುದು: data.table

ಇದು ಏನೂ ಸಂಕೀರ್ಣವಾಗಿಲ್ಲ, ನಾವು ಬಳಸೋಣ rbind().

R ನಲ್ಲಿ ಸಾಲುಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಲಾಗುತ್ತಿದೆ: data.table

## data.table
rbind(ga_nov, ga_dec)

ಪೈಥಾನ್‌ನಲ್ಲಿ ಲಂಬವಾಗಿ ಸೇರುವ ಕೋಷ್ಟಕಗಳು: ಪಾಂಡಾಗಳು

В pandas ಕಾರ್ಯವನ್ನು ಕೋಷ್ಟಕಗಳನ್ನು ಸೇರಲು ಬಳಸಲಾಗುತ್ತದೆ concat(), ಅವುಗಳನ್ನು ಸಂಯೋಜಿಸಲು ನೀವು ಚೌಕಟ್ಟುಗಳ ಪಟ್ಟಿಯನ್ನು ರವಾನಿಸಬೇಕಾಗುತ್ತದೆ.

ಪೈಥಾನ್‌ನಲ್ಲಿ ಫಿಲ್ಟರಿಂಗ್ ತಂತಿಗಳು: ಪಾಂಡಾಗಳು

# вертикальное объединение таблиц
pd.concat([ga_nov, ga_dec])

ಕೋಷ್ಟಕಗಳ ಸಮತಲ ಜೋಡಣೆ

ಎರಡನೆಯಿಂದ ಕಾಲಮ್‌ಗಳನ್ನು ಕೀಲಿಯಿಂದ ಮೊದಲ ಕೋಷ್ಟಕಕ್ಕೆ ಸೇರಿಸುವ ಕಾರ್ಯಾಚರಣೆ. ಕೆಲವು ಉಲ್ಲೇಖ ಡೇಟಾದೊಂದಿಗೆ (ಉದಾಹರಣೆಗೆ, ಉತ್ಪನ್ನದ ವೆಚ್ಚ) ಫ್ಯಾಕ್ಟ್ ಟೇಬಲ್ ಅನ್ನು (ಉದಾಹರಣೆಗೆ, ಮಾರಾಟದ ಡೇಟಾವನ್ನು ಹೊಂದಿರುವ ಟೇಬಲ್) ಪುಷ್ಟೀಕರಿಸುವಾಗ ಇದನ್ನು ಹೆಚ್ಚಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ.

ಹಲವಾರು ರೀತಿಯ ಜೋಡಣೆಗಳಿವೆ:

ಹಿಂದೆ ಲೋಡ್ ಮಾಡಿದ ಕೋಷ್ಟಕದಲ್ಲಿ ಟೈಟಾನಿಕ್ ನಮಗೆ ಒಂದು ಕಾಲಮ್ ಇದೆ ಸೆಕ್ಸ್, ಇದು ಪ್ರಯಾಣಿಕರ ಲಿಂಗ ಕೋಡ್‌ಗೆ ಅನುರೂಪವಾಗಿದೆ:

1 - ಹೆಣ್ಣು
2 - ಪುರುಷ

ಅಲ್ಲದೆ, ನಾವು ಟೇಬಲ್ ಅನ್ನು ರಚಿಸಿದ್ದೇವೆ - ಉಲ್ಲೇಖ ಪುಸ್ತಕ ಲಿಂಗ. ಪ್ರಯಾಣಿಕರ ಲಿಂಗದ ಡೇಟಾದ ಹೆಚ್ಚು ಅನುಕೂಲಕರ ಪ್ರಸ್ತುತಿಗಾಗಿ, ನಾವು ಡೈರೆಕ್ಟರಿಯಿಂದ ಲಿಂಗದ ಹೆಸರನ್ನು ಸೇರಿಸಬೇಕಾಗಿದೆ ಲಿಂಗ ಟೇಬಲ್ಗೆ ಟೈಟಾನಿಕ್.

R ನಲ್ಲಿ ಸಮತಲವಾದ ಟೇಬಲ್ ಸೇರಿಕೊಳ್ಳುತ್ತದೆ: ಟೈಡಿವರ್ಸ್, ಡಿಪ್ಲೈರ್

В dplyr ಸಮತಲ ಸೇರ್ಪಡೆಗಾಗಿ ಸಂಪೂರ್ಣ ಕುಟುಂಬ ಕಾರ್ಯಗಳಿವೆ:

inner_join()
left_join()
right_join()
full_join()
semi_join()
nest_join()
anti_join()

ನನ್ನ ಅಭ್ಯಾಸದಲ್ಲಿ ಸಾಮಾನ್ಯವಾಗಿ ಬಳಸಲಾಗಿದೆ left_join().

ಮೊದಲ ಎರಡು ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳಂತೆ, ಮೇಲೆ ಪಟ್ಟಿ ಮಾಡಲಾದ ಕಾರ್ಯಗಳು ಸೇರಲು ಎರಡು ಕೋಷ್ಟಕಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತವೆ ಮತ್ತು ಮೂರನೇ ಆರ್ಗ್ಯುಮೆಂಟ್‌ನಂತೆ by ನೀವು ಸೇರಲು ಕಾಲಮ್‌ಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬೇಕು.

R: dplyr ನಲ್ಲಿ ಸಮತಲ ಟೇಬಲ್ ಸೇರಿಕೊಳ್ಳುತ್ತದೆ

# объединяем таблицы
left_join(titanic, gender,
          by = c("Sex" = "id"))

R ನಲ್ಲಿ ಕೋಷ್ಟಕಗಳ ಅಡ್ಡ ಜೋಡಣೆ: data.table

В data.table ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ಕೀಲಿಯಿಂದ ಕೋಷ್ಟಕಗಳನ್ನು ಸೇರಬೇಕಾಗುತ್ತದೆ merge().

ಡೇಟಾ.ಟೇಬಲ್‌ನಲ್ಲಿ ವಿಲೀನ() ಕಾರ್ಯಕ್ಕೆ ವಾದಗಳು

x, y - ಸೇರಲು ಕೋಷ್ಟಕಗಳು
ಮೂಲಕ — ಎರಡೂ ಕೋಷ್ಟಕಗಳಲ್ಲಿ ಒಂದೇ ಹೆಸರನ್ನು ಹೊಂದಿದ್ದರೆ ಅದು ಸೇರಲು ಕೀಲಿಯಾಗಿದೆ
by.x, by.y — ಕೋಷ್ಟಕಗಳಲ್ಲಿ ಬೇರೆ ಬೇರೆ ಹೆಸರುಗಳಿದ್ದರೆ ಕಾಲಮ್ ಹೆಸರುಗಳನ್ನು ವಿಲೀನಗೊಳಿಸಬೇಕು
all, all.x, all.y — ಸೇರು ಪ್ರಕಾರ, ಎಲ್ಲಾ ಎರಡೂ ಕೋಷ್ಟಕಗಳಿಂದ ಎಲ್ಲಾ ಸಾಲುಗಳನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, all.x ಎಡ ಸೇರ್ಪಡೆ ಕಾರ್ಯಾಚರಣೆಗೆ ಅನುರೂಪವಾಗಿದೆ (ಮೊದಲ ಕೋಷ್ಟಕದ ಎಲ್ಲಾ ಸಾಲುಗಳನ್ನು ಬಿಡುತ್ತದೆ), all.y — ಅನುರೂಪವಾಗಿದೆ ಬಲ ಸೇರ್ಪಡೆ ಕಾರ್ಯಾಚರಣೆ (ಎರಡನೆಯ ಕೋಷ್ಟಕದ ಎಲ್ಲಾ ಸಾಲುಗಳನ್ನು ಬಿಡುತ್ತದೆ).

R ನಲ್ಲಿ ಕೋಷ್ಟಕಗಳ ಅಡ್ಡ ಜೋಡಣೆ: data.table

# объединяем таблицы
merge(titanic, gender, by.x = "Sex", by.y = "id", all.x = T)

ಪೈಥಾನ್‌ನಲ್ಲಿ ಸಮತಲ ಕೋಷ್ಟಕ ಸೇರಿಕೊಳ್ಳುತ್ತದೆ: ಪಾಂಡಾಗಳು

ಹಾಗೆಯೇ ರಲ್ಲಿ data.table, ಇನ್ pandas ಕಾರ್ಯವನ್ನು ಕೋಷ್ಟಕಗಳನ್ನು ಸೇರಲು ಬಳಸಲಾಗುತ್ತದೆ merge().

ಪಾಂಡಾಗಳಲ್ಲಿ ವಿಲೀನ() ಕಾರ್ಯದ ವಾದಗಳು

ಹೇಗೆ - ಸಂಪರ್ಕ ಪ್ರಕಾರ: ಎಡ, ಬಲ, ಹೊರ, ಒಳ
ಆನ್ — ಎರಡೂ ಕೋಷ್ಟಕಗಳಲ್ಲಿ ಒಂದೇ ಹೆಸರನ್ನು ಹೊಂದಿದ್ದರೆ ಅದು ಕೀಲಿಯಾಗಿದೆ
left_on, right_on — ಪ್ರಮುಖ ಕಾಲಮ್‌ಗಳ ಹೆಸರುಗಳು, ಅವು ಕೋಷ್ಟಕಗಳಲ್ಲಿ ವಿಭಿನ್ನ ಹೆಸರುಗಳನ್ನು ಹೊಂದಿದ್ದರೆ

ಪೈಥಾನ್‌ನಲ್ಲಿ ಸಮತಲ ಕೋಷ್ಟಕ ಸೇರಿಕೊಳ್ಳುತ್ತದೆ: ಪಾಂಡಾಗಳು

# объединяем по ключу
titanic.merge(gender, how = "left", left_on = "Sex", right_on = "id")

ಮೂಲ ವಿಂಡೋ ಕಾರ್ಯಗಳು ಮತ್ತು ಲೆಕ್ಕಾಚಾರದ ಕಾಲಮ್‌ಗಳು

ವಿಂಡೋ ಫಂಕ್ಷನ್‌ಗಳು ಒಟ್ಟುಗೂಡಿಸುವ ಕಾರ್ಯಗಳಿಗೆ ಸಮಾನವಾಗಿವೆ ಮತ್ತು ಡೇಟಾ ವಿಶ್ಲೇಷಣೆಯಲ್ಲಿ ಸಹ ಬಳಸಲಾಗುತ್ತದೆ. ಆದರೆ ಒಟ್ಟುಗೂಡಿಸುವ ಕಾರ್ಯಗಳಂತೆ, ವಿಂಡೋ ಕಾರ್ಯಗಳು ಹೊರಹೋಗುವ ಡೇಟಾಫ್ರೇಮ್‌ನ ಸಾಲುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಬದಲಾಯಿಸುವುದಿಲ್ಲ.

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

ಉದಾಹರಣೆಗೆ, ಟೇಬಲ್ ತೆಗೆದುಕೊಳ್ಳೋಣ ಟೈಟಾನಿಕ್. ಅದರ ಕ್ಯಾಬಿನ್ ವರ್ಗದಲ್ಲಿ ಪ್ರತಿ ಟಿಕೆಟ್‌ನ ಬೆಲೆ ಎಷ್ಟು ಶೇಕಡಾ ಎಂದು ನಾವು ಲೆಕ್ಕ ಹಾಕಬಹುದು.

ಇದನ್ನು ಮಾಡಲು, ಈ ಸಾಲಿನಲ್ಲಿನ ಟಿಕೆಟ್ ಸೇರಿರುವ ಪ್ರಸ್ತುತ ಕ್ಯಾಬಿನ್ ವರ್ಗದ ಟಿಕೆಟ್‌ನ ಒಟ್ಟು ವೆಚ್ಚವನ್ನು ನಾವು ಪ್ರತಿ ಸಾಲಿನಲ್ಲಿ ಪಡೆಯಬೇಕು, ನಂತರ ಪ್ರತಿ ಟಿಕೆಟ್‌ನ ವೆಚ್ಚವನ್ನು ಅದೇ ಕ್ಯಾಬಿನ್ ವರ್ಗದ ಎಲ್ಲಾ ಟಿಕೆಟ್‌ಗಳ ಒಟ್ಟು ವೆಚ್ಚದಿಂದ ಭಾಗಿಸಿ .

R ನಲ್ಲಿ ವಿಂಡೋ ಕಾರ್ಯಗಳು: ಟೈಡಿವರ್ಸ್, ಡಿಪ್ಲೈರ್

ಹೊಸ ಕಾಲಮ್‌ಗಳನ್ನು ಸೇರಿಸಲು, ಸಾಲು ಗುಂಪನ್ನು ಬಳಸದೆ, in dplyr ಕಾರ್ಯವನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ mutate().

ಕ್ಷೇತ್ರದ ಮೂಲಕ ಡೇಟಾವನ್ನು ಗುಂಪು ಮಾಡುವ ಮೂಲಕ ನೀವು ಮೇಲೆ ವಿವರಿಸಿದ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಬಹುದು ಪಿಸಿ ವರ್ಗ ಮತ್ತು ಕ್ಷೇತ್ರವನ್ನು ಹೊಸ ಕಾಲಮ್‌ನಲ್ಲಿ ಒಟ್ಟುಗೂಡಿಸಿ ಶುಲ್ಕ. ಮುಂದೆ, ಟೇಬಲ್ ಅನ್ನು ಅನ್ಗ್ರೂಪ್ ಮಾಡಿ ಮತ್ತು ಕ್ಷೇತ್ರ ಮೌಲ್ಯಗಳನ್ನು ಭಾಗಿಸಿ ಶುಲ್ಕ ಹಿಂದಿನ ಹಂತದಲ್ಲಿ ಏನಾಯಿತು.

R ನಲ್ಲಿ ವಿಂಡೋ ಕಾರ್ಯಗಳು: dplyr

group_by(titanic, Pclass) %>%
  mutate(Pclass_cost = sum(Fare)) %>%
  ungroup() %>%
  mutate(ticket_fare_rate = Fare / Pclass_cost)

R ನಲ್ಲಿ ವಿಂಡೋ ಕಾರ್ಯಗಳು: data.table

ಪರಿಹಾರ ಅಲ್ಗಾರಿದಮ್ ನಲ್ಲಿರುವಂತೆಯೇ ಇರುತ್ತದೆ dplyr, ನಾವು ಟೇಬಲ್ ಅನ್ನು ಕ್ಷೇತ್ರದಿಂದ ವಿಂಡೋಗಳಾಗಿ ವಿಭಜಿಸಬೇಕಾಗಿದೆ ಪಿಸಿ ವರ್ಗ. ಪ್ರತಿ ಸಾಲಿಗೆ ಅನುಗುಣವಾದ ಗುಂಪಿನ ಮೊತ್ತವನ್ನು ಹೊಸ ಕಾಲಮ್‌ನಲ್ಲಿ ಪ್ರದರ್ಶಿಸಿ ಮತ್ತು ಅದರ ಗುಂಪಿನಲ್ಲಿರುವ ಪ್ರತಿ ಟಿಕೆಟ್‌ನ ವೆಚ್ಚದ ಪಾಲನ್ನು ನಾವು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವ ಕಾಲಮ್ ಅನ್ನು ಸೇರಿಸಿ.

ಗೆ ಹೊಸ ಕಾಲಮ್‌ಗಳನ್ನು ಸೇರಿಸಲು data.table ಆಪರೇಟರ್ ಪ್ರಸ್ತುತ :=. ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುವ ಉದಾಹರಣೆಯನ್ನು ಕೆಳಗೆ ನೀಡಲಾಗಿದೆ data.table

R ನಲ್ಲಿ ವಿಂಡೋ ಕಾರ್ಯಗಳು: data.table

titanic[,c("Pclass_cost","ticket_fare_rate") := .(sum(Fare), Fare / Pclass_cost), 
        by = Pclass]

ಪೈಥಾನ್‌ನಲ್ಲಿ ವಿಂಡೋ ಕಾರ್ಯಗಳು: ಪಾಂಡಾಗಳು

ಹೊಸ ಕಾಲಮ್ ಅನ್ನು ಸೇರಿಸಲು ಒಂದು ಮಾರ್ಗ pandas - ಕಾರ್ಯವನ್ನು ಬಳಸಿ assign(). ಕ್ಯಾಬಿನ್ ವರ್ಗದ ಮೂಲಕ ಟಿಕೆಟ್ಗಳ ಬೆಲೆಯನ್ನು ಸಂಕ್ಷಿಪ್ತಗೊಳಿಸಲು, ಸಾಲುಗಳನ್ನು ಗುಂಪು ಮಾಡದೆಯೇ, ನಾವು ಕಾರ್ಯವನ್ನು ಬಳಸುತ್ತೇವೆ transform().

ನಾವು ಟೇಬಲ್‌ಗೆ ಸೇರಿಸುವ ಪರಿಹಾರದ ಉದಾಹರಣೆಯನ್ನು ಕೆಳಗೆ ನೀಡಲಾಗಿದೆ ಟೈಟಾನಿಕ್ ಅದೇ 2 ಕಾಲಮ್‌ಗಳು.

ಪೈಥಾನ್‌ನಲ್ಲಿ ವಿಂಡೋ ಕಾರ್ಯಗಳು: ಪಾಂಡಾಗಳು

titanic.assign(Pclass_cost      =  titanic.groupby('Pclass').Fare.transform(sum),
               ticket_fare_rate = lambda x: x['Fare'] / x['Pclass_cost'])

ಕಾರ್ಯಗಳು ಮತ್ತು ವಿಧಾನಗಳು ಪತ್ರವ್ಯವಹಾರ ಕೋಷ್ಟಕ

ನಾವು ಪರಿಗಣಿಸಿದ ಪ್ಯಾಕೇಜ್‌ಗಳಲ್ಲಿನ ಡೇಟಾದೊಂದಿಗೆ ವಿವಿಧ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸುವ ವಿಧಾನಗಳ ನಡುವಿನ ಪತ್ರವ್ಯವಹಾರದ ಕೋಷ್ಟಕವನ್ನು ಕೆಳಗೆ ನೀಡಲಾಗಿದೆ.

ವಿವರಣೆ
ಅಚ್ಚುಕಟ್ಟಾದ
ಡೇಟಾ. ಟೇಬಲ್
ಪಾಂಡಾಗಳು

ಡೇಟಾವನ್ನು ಲೋಡ್ ಮಾಡಲಾಗುತ್ತಿದೆ
vroom()/ readr::read_csv() / readr::read_tsv()
fread()
read_csv()

ಡೇಟಾಫ್ರೇಮ್‌ಗಳನ್ನು ರಚಿಸುವುದು
tibble()
data.table()
dict() + from_dict()

ಕಾಲಮ್‌ಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಲಾಗುತ್ತಿದೆ
select()
ಒಂದು ವಾದ j, ಚದರ ಆವರಣಗಳಲ್ಲಿ ಎರಡನೇ ಸ್ಥಾನ
ನಾವು ಚದರ ಬ್ರಾಕೆಟ್‌ಗಳಲ್ಲಿ ಅಗತ್ಯವಿರುವ ಕಾಲಮ್‌ಗಳ ಪಟ್ಟಿಯನ್ನು ರವಾನಿಸುತ್ತೇವೆ / drop() / filter() / select_dtypes()

ಫಿಲ್ಟರಿಂಗ್ ಸಾಲುಗಳು
filter()
ಒಂದು ವಾದ i, ಚದರ ಆವರಣಗಳಲ್ಲಿ ಮೊದಲ ಸ್ಥಾನ
ನಾವು ಫಿಲ್ಟರಿಂಗ್ ಪರಿಸ್ಥಿತಿಗಳನ್ನು ಚದರ ಆವರಣಗಳಲ್ಲಿ ಪಟ್ಟಿ ಮಾಡುತ್ತೇವೆ / filter()

ಗುಂಪುಗಾರಿಕೆ ಮತ್ತು ಒಟ್ಟುಗೂಡಿಸುವಿಕೆ
group_by() + summarise()
ವಾದಗಳು j + by
groupby() + agg()

ಕೋಷ್ಟಕಗಳ ಲಂಬ ಒಕ್ಕೂಟ (UNION)
bind_rows()
rbind()
concat()

ಕೋಷ್ಟಕಗಳ ಅಡ್ಡ ಜೋಡಣೆ (ಸೇರಿಸು)
left_join() / *_join()
merge()
merge()

ಮೂಲ ವಿಂಡೋ ಕಾರ್ಯಗಳು ಮತ್ತು ಲೆಕ್ಕ ಹಾಕಿದ ಕಾಲಮ್ಗಳನ್ನು ಸೇರಿಸುವುದು
group_by() + mutate()
ಒಂದು ವಾದ j ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸುವುದು := + ವಾದ by
transform() + assign()

ತೀರ್ಮಾನಕ್ಕೆ

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

ನಾನು ಮೇಲೆ ಬರೆದಂತೆ, ಲೇಖನದ ಉದ್ದೇಶವು ಯಾವ ಭಾಷೆ ಉತ್ತಮವಾಗಿದೆ ಎಂಬುದರ ಕುರಿತು ಒಬ್ಬರ ಅಭಿಪ್ರಾಯವನ್ನು ಹೇರುವುದು ಅಲ್ಲ, ಆದರೆ ಎರಡೂ ಭಾಷೆಗಳನ್ನು ಕಲಿಯುವ ಅವಕಾಶವನ್ನು ಸರಳಗೊಳಿಸುವುದು ಅಥವಾ ಅಗತ್ಯವಿದ್ದರೆ, ಅವುಗಳ ನಡುವೆ ವಲಸೆ ಹೋಗುವುದು.

ನೀವು ಲೇಖನವನ್ನು ಇಷ್ಟಪಟ್ಟರೆ, ನನ್ನ ಹೊಸ ಚಂದಾದಾರರನ್ನು ಹೊಂದಲು ನನಗೆ ಸಂತೋಷವಾಗುತ್ತದೆ YouTube и ಟೆಲಿಗ್ರಾಮ್ ವಾಹಿನಿಗಳು.

ಪೋಲ್

ನಿಮ್ಮ ಕೆಲಸದಲ್ಲಿ ನೀವು ಈ ಕೆಳಗಿನ ಯಾವ ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ಬಳಸುತ್ತೀರಿ?

ಕಾಮೆಂಟ್‌ಗಳಲ್ಲಿ ನಿಮ್ಮ ಆಯ್ಕೆಯ ಕಾರಣವನ್ನು ನೀವು ಬರೆಯಬಹುದು.

ನೋಂದಾಯಿತ ಬಳಕೆದಾರರು ಮಾತ್ರ ಸಮೀಕ್ಷೆಯಲ್ಲಿ ಭಾಗವಹಿಸಬಹುದು. ಸೈನ್ ಇನ್ ಮಾಡಿ, ದಯವಿಟ್ಟು.

ನೀವು ಯಾವ ಡೇಟಾ ಸಂಸ್ಕರಣಾ ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಬಳಸುತ್ತೀರಿ (ನೀವು ಹಲವಾರು ಆಯ್ಕೆಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಬಹುದು)

45,2%ಅಚ್ಚುಕಟ್ಟು 19
33,3%ಡೇಟಾ.ಟೇಬಲ್ 14
54,8%ಪಾಂಡಾಗಳು23

42 ಬಳಕೆದಾರರು ಮತ ಹಾಕಿದ್ದಾರೆ. 9 ಬಳಕೆದಾರರು ದೂರ ಉಳಿದಿದ್ದಾರೆ.

ಮೂಲ: www.habr.com