Python NumPy ಎಂಬುದು NumPy ಅರೇ ವಸ್ತುವಿನ ಸುತ್ತಲೂ ನಿರ್ಮಿಸಲಾದ ಜನಪ್ರಿಯ ಗ್ರಂಥಾಲಯವಾಗಿದೆ, ಇದು ಪ್ರಮಾಣಿತ ಪೈಥಾನ್ ಪಟ್ಟಿಗಳಿಗೆ ಪ್ರಬಲ ಮತ್ತು ಪರಿಣಾಮಕಾರಿ ಪರ್ಯಾಯವಾಗಿದೆ. ಈ ಲೇಖನದಲ್ಲಿ, ನಾವು NumPy ಲೈಬ್ರರಿಯಲ್ಲಿ ಲಭ್ಯವಿರುವ ಉಪಯುಕ್ತ ಕಾರ್ಯಗಳಲ್ಲಿ ಒಂದನ್ನು ಚರ್ಚಿಸುತ್ತೇವೆ ಅಸ್ಕೊಂಟಿಗ್ಯೂಸರ್ರೇ ಕಾರ್ಯ. ಅರೇಗಳನ್ನು ಪಕ್ಕದ ಅರೇಗಳಾಗಿ ಪರಿವರ್ತಿಸುವ ಮತ್ತು ಟ್ಯೂಪಲ್‌ಗಳಂತಹ ಡೇಟಾ ರಚನೆಗಳನ್ನು ನಿರ್ವಹಿಸುವ ವಿಷಯದಲ್ಲಿ ಅರೇಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಈ ಕಾರ್ಯವು ವಿಶೇಷವಾಗಿ ಪ್ರಯೋಜನಕಾರಿಯಾಗಿದೆ. ಅಸ್ಕಾಂಟಿಗ್ಯೂಸರ್ರೇ ಕಾರ್ಯದ ಮುಖ್ಯ ಉದ್ದೇಶವೆಂದರೆ ಕೊಟ್ಟಿರುವ ಶ್ರೇಣಿಯನ್ನು ಮೆಮೊರಿಯ ಪಕ್ಕದಲ್ಲಿರುವ ಬ್ಲಾಕ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು.
ಪ್ರಾರಂಭಿಸಲು, ಸಮಸ್ಯೆಯನ್ನು ಪರಿಶೀಲಿಸೋಣ. ನೀವು ಸಂಖ್ಯಾತ್ಮಕ ಡೇಟಾವನ್ನು ಹೊಂದಿರುವ ಟ್ಯೂಪಲ್ ಅನ್ನು ಹೊಂದಿದ್ದೀರಿ ಎಂದು ಭಾವಿಸೋಣ ಮತ್ತು ನೀವು ಈ ಟುಪಲ್ ಅನ್ನು ಪಕ್ಕದ NumPy ಅರೇ ಆಗಿ ಪರಿವರ್ತಿಸಲು ಬಯಸುತ್ತೀರಿ. ಇಲ್ಲಿಯೇ ದಿ ಅಸ್ಕೊಂಟಿಗ್ಯೂಸರ್ರೇ ಕಾರ್ಯವು ಸೂಕ್ತವಾಗಿ ಬರುತ್ತದೆ.
import numpy as np # Sample tuple data = (1, 2, 3, 4, 5) # Using ascontiguousarray to convert tuple to a contiguous array contiguous_array = np.ascontiguousarray(data) print(contiguous_array)
ಮೇಲಿನ ಕೋಡ್ ತುಣುಕಿನಲ್ಲಿ, ನಾವು ಮೊದಲು NumPy ಲೈಬ್ರರಿಯನ್ನು np ಎಂದು ಆಮದು ಮಾಡಿಕೊಳ್ಳುತ್ತೇವೆ. ಇದನ್ನು ಅನುಸರಿಸಿ, ನಾವು 1 ರಿಂದ 5 ರವರೆಗಿನ ಸಂಖ್ಯಾತ್ಮಕ ಅಂಶಗಳನ್ನು ಒಳಗೊಂಡಿರುವ 'ಡೇಟಾ' ಹೆಸರಿನ ಟ್ಯೂಪಲ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ. ನಂತರ ನಾವು ಬಳಸುತ್ತೇವೆ ಅಸ್ಕೊಂಟಿಗ್ಯೂಸರ್ರೇ 'ಡೇಟಾ' ಅನ್ನು 'contiguous_array' ಎಂದು ಕರೆಯಲ್ಪಡುವ ಒಂದು ಪಕ್ಕದ ಅರೇ ಆಗಿ ಪರಿವರ್ತಿಸುವ ಕಾರ್ಯ. ಅಂತಿಮವಾಗಿ, ನಾವು ಫಲಿತಾಂಶವನ್ನು ಮುದ್ರಿಸುತ್ತೇವೆ, ಅದು ಹೊಸ ಪಕ್ಕದ ರಚನೆಯನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ.
ಅಸ್ಕಾಂಟಿಗ್ಯೂಸರ್ರೇ ಫಂಕ್ಷನ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು
ನಮ್ಮ ಅಸ್ಕೊಂಟಿಗ್ಯೂಸರ್ರೇ ಒಂದು ಶ್ರೇಣಿಯು ಪಕ್ಕದಲ್ಲಿರುವ ಮೆಮೊರಿ ಲೇಔಟ್‌ನಲ್ಲಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನೀವು ಬಯಸಿದಾಗ NumPy ನಲ್ಲಿನ ಕಾರ್ಯವು ಪ್ರಯೋಜನಕಾರಿಯಾಗಿದೆ. ಇದು ಮುಖ್ಯವಾಗಿದೆ ಏಕೆಂದರೆ ಸತತ ಮೆಮೊರಿ ಲೇಔಟ್ ರಚನೆಯ ಕಾರ್ಯಾಚರಣೆಗಳ ದಕ್ಷತೆಯನ್ನು ಸುಧಾರಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ, ಏಕೆಂದರೆ ಇದು ಉತ್ತಮ ಸಂಗ್ರಹ ಬಳಕೆಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ, ಸಿಸ್ಟಮ್ನ ಪ್ರೊಸೆಸರ್ ಡೇಟಾವನ್ನು ಹೆಚ್ಚು ವೇಗವಾಗಿ ಪ್ರವೇಶಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.
ನ ಮೂಲ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅಸ್ಕೊಂಟಿಗ್ಯೂಸರ್ರೇ ಕಾರ್ಯವು ಈ ಕೆಳಗಿನಂತಿರುತ್ತದೆ:
numpy.ascontiguousarray(a, dtype=None)
ಫಂಕ್ಷನ್ ಎರಡು ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ: ಮೊದಲನೆಯದು ('a') ಇನ್‌ಪುಟ್ ಅರೇ ಆಗಿದ್ದು, ಅದು ಪಕ್ಕದ ಅರೇ ಆಗಿ ಮಾಡಬೇಕಾಗಿದೆ, ಮತ್ತು ಎರಡನೇ ಆರ್ಗ್ಯುಮೆಂಟ್ ('dtype') ಔಟ್‌ಪುಟ್‌ನ ಅಪೇಕ್ಷಿತ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ಸೂಚಿಸುವ ಐಚ್ಛಿಕ ನಿಯತಾಂಕವಾಗಿದೆ. ಶ್ರೇಣಿ.
ಬಹು ಆಯಾಮದ ಅರೇಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು
ನಮ್ಮ ಅಸ್ಕೊಂಟಿಗ್ಯೂಸರ್ರೇ ಕಾರ್ಯವು ಬಹು ಆಯಾಮದ ಅರೇಗಳೊಂದಿಗೆ ಮನಬಂದಂತೆ ಕೆಲಸ ಮಾಡಬಹುದು. ವಾಸ್ತವವಾಗಿ, ಹೆಚ್ಚಿನ ಆಯಾಮದ ಅರೇಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಇದು ವಿಶೇಷವಾಗಿ ಮೌಲ್ಯಯುತವಾಗಿದೆ, ಏಕೆಂದರೆ ಇದು ಸಮರ್ಥ ಮೆಮೊರಿ ನಿರ್ವಹಣೆ ಮತ್ತು ರಚನೆಯ ಅಂಶಗಳಿಗೆ ವೇಗವಾಗಿ ಪ್ರವೇಶವನ್ನು ಖಾತ್ರಿಗೊಳಿಸುತ್ತದೆ.
ಅನ್ನು ಬಳಸುವ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ ಅಸ್ಕೊಂಟಿಗ್ಯೂಸರ್ರೇ ಬಹು ಆಯಾಮದ ಪಟ್ಟಿಯೊಂದಿಗೆ ಕಾರ್ಯ:
import numpy as np # Multi-dimensional list data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] # Using ascontiguousarray to convert the list to a contiguous array contiguous_array = np.ascontiguousarray(data) print(contiguous_array)
ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ಇನ್‌ಪುಟ್ ಡೇಟಾವು ನೆಸ್ಟೆಡ್ ಪಟ್ಟಿಗಳನ್ನು ಹೊಂದಿರುವ ಬಹು ಆಯಾಮದ ಪಟ್ಟಿಯಾಗಿದೆ. ಹಿಂದಿನ ಪ್ರಕರಣದಂತೆಯೇ, ದಿ ಅಸ್ಕೊಂಟಿಗ್ಯೂಸರ್ರೇ ಫಂಕ್ಷನ್ ಅನ್ನು ಈ ಡೇಟಾವನ್ನು ಒಂದು ಪಕ್ಕದ NumPy ಅರೇ ಆಗಿ ಪರಿವರ್ತಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ, ನಂತರ ಫಲಿತಾಂಶವನ್ನು ಪ್ರದರ್ಶಿಸಲು ಮುದ್ರಿಸಲಾಗುತ್ತದೆ.
ಕೊನೆಯಲ್ಲಿ, ದಿ ಅಸ್ಕೊಂಟಿಗ್ಯೂಸರ್ರೇ NumPy ಲೈಬ್ರರಿಯಲ್ಲಿನ ಕಾರ್ಯವು tuple ಮತ್ತು ಬಹು-ಆಯಾಮದ ಅರೇ ಪರಿವರ್ತನೆಗಳನ್ನು ಪಕ್ಕದ ಅರೇಗಳಿಗೆ ನಿರ್ವಹಿಸಲು ಅಮೂಲ್ಯವಾದ ಸಾಧನವಾಗಿದೆ. ಮೆಮೊರಿ-ಸಮರ್ಥ ಸಂಗ್ರಹಣೆ ಮತ್ತು ವೇಗವಾದ ಡೇಟಾ ಪ್ರವೇಶವನ್ನು ಜಾರಿಗೊಳಿಸುವ ಅದರ ಸಾಮರ್ಥ್ಯವು ಸಂಖ್ಯಾತ್ಮಕ ಡೇಟಾದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಯಾವುದೇ ಪೈಥಾನ್ ಪ್ರೋಗ್ರಾಮರ್‌ಗೆ ಇದು ಅತ್ಯಗತ್ಯ ಕಾರ್ಯವಾಗಿದೆ.
