ಪರಿವಿಡಿ[ಮರೆಮಾಡಿ][ತೋರಿಸಿ]
ಈ ಉಪನ್ಯಾಸವು ಪೈಥಾನ್ನಲ್ಲಿರುವ ಮಾಡ್ಯೂಲ್ಗಳು ಮತ್ತು ಪ್ಯಾಕೇಜುಗಳ ಸುತ್ತಲೂ ವ್ಯಾಪಿಸುತ್ತದೆ.
ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಫೈಲ್ಗಳ ರೂಪದಲ್ಲಿ ಸಂಘಟಿಸಲು ಅವು ಒಂದು ಮಾರ್ಗವಾಗಿದೆ ಮತ್ತು ನೀವು ಪೈಥಾನ್ನೊಂದಿಗೆ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಬಯಸಿದರೆ ಇದು ನಿಜವಾಗಿಯೂ ಮುಖ್ಯವಾಗಿದೆ
ಮಾಡ್ಯೂಲ್ಗಳು
ಪೈಥಾನ್ನಲ್ಲಿನ ಮಾಡ್ಯೂಲ್ ಮೂಲತಃ ನಮ್ಮ ಕೋಡ್ ಅನ್ನು ಫೈಲ್ಗಳಾಗಿ ಸಂಘಟಿಸಲು ನಾವು ಬಳಸುವ ಕೆಲವು ಪೈಥಾನ್ ಕೋಡ್ ಹೊಂದಿರುವ ಫೈಲ್ ಆಗಿದೆ. ಸೂಪರ್ಮಾರ್ಕೆಟ್ನಲ್ಲಿನ ವಿಭಾಗಗಳಂತೆ ಯೋಚಿಸಿ. ನೀವು ಸೂಪರ್ಮಾರ್ಕೆಟ್ಗೆ ಹೋದಾಗ ಹಣ್ಣುಗಳು, ತರಕಾರಿಗಳು, ಶುಚಿಗೊಳಿಸುವ ಉತ್ಪನ್ನಗಳು ಇತ್ಯಾದಿಗಳಿಗೆ ವಿವಿಧ ವಿಭಾಗಗಳಿವೆ. ಎಲ್ಲಾ ಉತ್ಪನ್ನಗಳೊಂದಿಗೆ ನೀವು ಒಂದು ವಿಭಾಗವನ್ನು ನೋಡುವುದಿಲ್ಲ.
ಪ್ರೋಗ್ರಾಮಿಂಗ್ನಲ್ಲೂ ಇದೇ ಪರಿಕಲ್ಪನೆ. main.py ನಲ್ಲಿ ಎಲ್ಲಾ ಕಾರ್ಯಗಳು ಮತ್ತು ತರಗತಿಗಳೊಂದಿಗೆ ನಮ್ಮ ಎಲ್ಲಾ ಕೋಡ್ ಅನ್ನು ಬರೆಯುವ ಬದಲು, ನಾವು ನಮ್ಮ ಕೋಡ್ ಅನ್ನು ಬಹು ಫೈಲ್ಗಳಾಗಿ ವಿಭಜಿಸುತ್ತೇವೆ. ಪ್ರತಿಯೊಂದು ಫೈಲ್ ಅನ್ನು ಮಾಡ್ಯೂಲ್ ಎಂದು ಉಲ್ಲೇಖಿಸಲಾಗುತ್ತದೆ. ಇದರೊಂದಿಗೆ, ನಮ್ಮ ಕೋಡ್ ಉತ್ತಮವಾಗಿ ಸಂಘಟಿತವಾಗಿದೆ ಮತ್ತು ರಚನೆಯಾಗಿದೆ, ಆದರೆ ನಮ್ಮ ಕೋಡ್ ಅನ್ನು ಮರುಬಳಕೆ ಮಾಡುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಸಹ ನಾವು ಹೊಂದಿದ್ದೇವೆ. ಅದನ್ನು ಒಂದು ಉದಾಹರಣೆಯ ಮೂಲಕ ನೋಡೋಣ.
ತೂಕವನ್ನು ಪೌಂಡ್ಗಳಿಂದ ಕಿಲೋಗ್ರಾಮ್ಗಳಿಗೆ ಪರಿವರ್ತಿಸಲು ಮತ್ತು ಪ್ರತಿಯಾಗಿ ಎರಡು ಕಾರ್ಯಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸೋಣ.
def lbs_to_kg(weight):
return weight * 0.45
def kg_to_lbs(weight):
return weight / 0.45
ಈಗ, ನಾವು ಈ ಎರಡು ಕಾರ್ಯಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು ಮತ್ತು ಅವುಗಳನ್ನು "ಪರಿವರ್ತಕಗಳು" ಎಂಬ ಪ್ರತ್ಯೇಕ ಮಾಡ್ಯೂಲ್ನಲ್ಲಿ ಇರಿಸಬಹುದು, ಮತ್ತು ನಂತರ ಈ ಪರಿವರ್ತಕ ಕಾರ್ಯಗಳ ಅಗತ್ಯವಿರುವ ಯಾವುದೇ ಪ್ರೋಗ್ರಾಂಗೆ ಅದನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳಬಹುದು. ಇದನ್ನು ಹೇಗೆ ಮಾಡಬೇಕೆಂದು ನಾನು ನಿಮಗೆ ತೋರಿಸುತ್ತೇನೆ.
ನಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್ ಪ್ಯಾನೆಲ್ ಅನ್ನು ತೆರೆಯೋಣ ಮತ್ತು ಪ್ರಾಜೆಕ್ಟ್ ಮೇಲೆ ಬಲ ಕ್ಲಿಕ್ ಮಾಡಿ ಮತ್ತು ಹೊಸ ಫೈಲ್ ಅನ್ನು ಸೇರಿಸೋಣ. ನಾವು ಈ ಫೈಲ್ ಅನ್ನು "Converters.py" ಎಂದು ಕರೆಯಲಿದ್ದೇವೆ.
ಈಗ ಡೀಫಾಲ್ಟ್ ಫೈಲ್ನಿಂದ ಕೋಡ್ ಅನ್ನು ನಕಲಿಸಿ ಮತ್ತು ಅದನ್ನು "Converters.py" ಗೆ ಅಂಟಿಸಿ.
ಇದರೊಂದಿಗೆ, ನಾವು ನಮ್ಮ ಮುಖ್ಯ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸಿದ್ದೇವೆ ಮತ್ತು ಇದು ವಿಭಿನ್ನ ಕಾರ್ಯಗಳೊಂದಿಗೆ ಉಬ್ಬುವುದಿಲ್ಲ. ನಾವು ತರಗತಿಗಳೊಂದಿಗೆ ಹೆಚ್ಚಿನ ಕಾರ್ಯಗಳನ್ನು ಬರೆಯುವಾಗ, ನಾವು ಅವುಗಳನ್ನು ಅವುಗಳ ಅನುಗುಣವಾದ ಮಾಡ್ಯೂಲ್ಗಳಲ್ಲಿ ಇರಿಸುತ್ತೇವೆ. ಮಾಡ್ಯೂಲ್ ಎಲ್ಲಾ ಸಂಬಂಧಿತ ಕಾರ್ಯಗಳು ಮತ್ತು ವರ್ಗಗಳನ್ನು ಒಳಗೊಂಡಿರಬೇಕು. ಈಗ, ನಾವು ಪರಿವರ್ತಕಗಳ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಮಾಡ್ಯೂಲ್ಗೆ ಆಮದು ಮಾಡಿಕೊಳ್ಳಲು ಬಯಸುತ್ತೇವೆ. ಇದನ್ನು ಮಾಡಲು, ಬರೆಯಿರಿ import converters
".py" ವಿಸ್ತರಣೆಯಿಲ್ಲದೆ ಮೇಲ್ಭಾಗದಲ್ಲಿ.
ವಿಧಾನಗಳಂತೆಯೇ ಡಾಟ್ ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ನಾವು ಮಾಡ್ಯೂಲ್ನ ಸದಸ್ಯರನ್ನು ಪ್ರವೇಶಿಸಬಹುದು.
70 ಕೆಜಿಯನ್ನು ಪೌಂಡ್ಗಳಾಗಿ ಪರಿವರ್ತಿಸೋಣ:
ಮಾಡ್ಯೂಲ್ಗಳನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತೊಂದು ಸಿಂಟ್ಯಾಕ್ಸ್ ಕೂಡ ಇದೆ. ಸಂಪೂರ್ಣ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳುವ ಬದಲು, ನಾವು ಆ ಮಾಡ್ಯೂಲ್ನಿಂದ ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯಗಳನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳಬಹುದು. ನಾವು ಟೈಪ್ ಮಾಡಬಹುದು from Converters import
ಮತ್ತು ಲಭ್ಯವಿರುವ ಕಾರ್ಯಗಳ ಪಟ್ಟಿಯನ್ನು ತೋರಿಸಲು “control + space ಅನ್ನು ಒತ್ತಿರಿ. ಇದರೊಂದಿಗೆ, ನಾವು ಈ ಕಾರ್ಯವನ್ನು ನೇರವಾಗಿ ಕರೆಯಬಹುದು.
ವ್ಯಾಯಾಮ
ನಿಮ್ಮ ವ್ಯಾಯಾಮ ಇಲ್ಲಿದೆ.
ಇದು ನಾವು ಚರ್ಚಿಸಿದ ಉಪನ್ಯಾಸದ ವ್ಯಾಯಾಮಕ್ಕೆ ಸಂಬಂಧಿಸಿದೆ "ಕುಣಿಕೆಗಳಿಗಾಗಿ” ಅಲ್ಲಿ ನಾವು ಪಟ್ಟಿಯಿಂದ ದೊಡ್ಡ ಸಂಖ್ಯೆಯನ್ನು ಕಂಡುಹಿಡಿಯಲು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಬರೆದಿದ್ದೇವೆ
numbers = [8, 3, 6, 10, 5]
max = numbers[0]
for number in numbers:
if number > max:
max = number
print(max)
ಈ ಕೋಡ್ ಪ್ರಸ್ತುತ ಯಾವುದೇ ಸಂಸ್ಥೆಯನ್ನು ಹೊಂದಿಲ್ಲ. ನಾವು ಯಾವುದೇ ಕಾರ್ಯಗಳು ಅಥವಾ ಮಾಡ್ಯೂಲ್ಗಳನ್ನು ಹೊಂದಿಲ್ಲ ಮತ್ತು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಒಂದೇ ಫೈಲ್ನಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ. ಸಣ್ಣ ಕಾರ್ಯಕ್ರಮಗಳಿಗೆ ಅದು ಸರಿ ಆದರೆ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂಗಳು ಬೆಳೆದಂತೆ, ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ತರಗತಿಗಳು ಮತ್ತು ಮಾಡ್ಯೂಲ್ಗಳಾಗಿ ಸರಿಯಾಗಿ ಸಂಘಟಿಸಬೇಕಾಗುತ್ತದೆ. ಆದ್ದರಿಂದ, ಈ ವ್ಯಾಯಾಮದ ಭಾಗವಾಗಿ, ನೀವು ಕಾರ್ಯವನ್ನು ಬರೆಯಲು ನಾನು ಬಯಸುತ್ತೇನೆ, ಅದನ್ನು ಕರೆ ಮಾಡಿ find_max
. ಈ ಕಾರ್ಯವು ಪಟ್ಟಿಯನ್ನು ತೆಗೆದುಕೊಳ್ಳಬೇಕು ಮತ್ತು ಆ ಪಟ್ಟಿಯಲ್ಲಿನ ದೊಡ್ಡ ಸಂಖ್ಯೆಯನ್ನು ಹಿಂತಿರುಗಿಸಬೇಕು. ಅದರ ನಂತರ ಮುಂದುವರಿಯಿರಿ ಮತ್ತು ಈ ಕಾರ್ಯವನ್ನು ಪ್ರತ್ಯೇಕ ಮಾಡ್ಯೂಲ್ನಲ್ಲಿ ಇರಿಸಿ, ಅದನ್ನು ಇಲ್ಲಿಂದ ಹೊರತೆಗೆಯಿರಿ ಮತ್ತು ಅದನ್ನು ಎಂಬ ಮಾಡ್ಯೂಲ್ನಲ್ಲಿ ಇರಿಸಿ utils
. ಈ ಮಾಡ್ಯೂಲ್ ಯುಟಿಲಿಟಿ ಫಂಕ್ಷನ್ಗಳ ಗುಂಪನ್ನು ಒಳಗೊಂಡಿರಬೇಕು. ಆಮದು ಮಾಡಿ utils
ಪ್ರಸ್ತುತ ಮಾಡ್ಯೂಲ್ಗೆ ಮಾಡ್ಯೂಲ್ ಮಾಡಿ ಮತ್ತು ಕರೆ ಮಾಡಿ find_max
ಕಾರ್ಯ. ಅಂತಿಮವಾಗಿ, ಫಲಿತಾಂಶವನ್ನು ಪಡೆಯಿರಿ ಮತ್ತು ಅದನ್ನು ಟರ್ಮಿನಲ್ನಲ್ಲಿ ಮುದ್ರಿಸಿ.
ಈ ವ್ಯಾಯಾಮ ಸ್ವಲ್ಪ ಸವಾಲಾಗಿದೆ ಆದರೆ ಸುಲಭವಾಗಿ ಮಾಡಬಹುದಾಗಿದೆ.
ಪರಿಹಾರ
ಕಾರ್ಯವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಮೂಲಕ ಪ್ರಾರಂಭಿಸಿ find_max
ಮತ್ತು ಸಂಖ್ಯೆಗಳು ಎಂಬ ಪ್ಯಾರಾಮೀಟರ್ ಅನ್ನು ಸೇರಿಸಿ. ಈ ಕಾರ್ಯದ ಒಳಗೆ, ಪಟ್ಟಿಯಲ್ಲಿರುವ ದೊಡ್ಡ ಸಂಖ್ಯೆಯನ್ನು ಕಂಡುಹಿಡಿಯಲು ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಬರೆಯಿರಿ.
def find_max(numbers):
max = numbers[0]
for number in numbers:
if number > max:
max = number
return max
ಈ ಕೋಡ್ ಅನ್ನು "utils.py" ಫೈಲ್ನಲ್ಲಿ ಮಾಡ್ಯೂಲ್ ಆಗಿ ಉಳಿಸಿ.
ನಮ್ಮ ಮುಖ್ಯ ಪ್ರೋಗ್ರಾಂಗೆ ಹಿಂತಿರುಗಿ, ಎರಡು ಸಿಂಟ್ಯಾಕ್ಸ್ಗಳಿಂದ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಆಮದು ಮಾಡಿ ಮತ್ತು ತರ್ಕವನ್ನು ಸರಳವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಿ.
ಒಂದು ವಿಷಯ, ದುರ್ಬಲಗೊಂಡಿರುವ ಬಗ್ಗೆ ನಾನು ನಿಮ್ಮ ಗಮನವನ್ನು ತರಬೇಕಾಗಿದೆ max
. ಅದಕ್ಕೆ ಕಾರಣ ದಿ max
ಪೈಥಾನ್ನಲ್ಲಿ ಅಂತರ್ನಿರ್ಮಿತ ಕಾರ್ಯವಾಗಿದೆ ಮತ್ತು ನಾವು ಅದನ್ನು ಮರುವ್ಯಾಖ್ಯಾನಿಸುತ್ತಿದ್ದೇವೆ. ಆದ್ದರಿಂದ ಇದು ಒಂದು ಎಚ್ಚರಿಕೆ ಪೈಥಾನ್ ಕಂಪೈಲರ್ ನಾವು ಇನ್ನು ಮುಂದೆ ಮ್ಯಾಕ್ಸ್ ಅನ್ನು ಅದರ ಅಂತರ್ನಿರ್ಮಿತ ಕಾರ್ಯವಾಗಿ ಬಳಸಲಾಗುವುದಿಲ್ಲ.
ಪೈಥಾನ್ನಲ್ಲಿ ಅಂತರ್ನಿರ್ಮಿತ ಮಾಡ್ಯೂಲ್ಗಳು
ಇಮೇಲ್ಗಳನ್ನು ಕಳುಹಿಸುವುದು, ದಿನಾಂಕ ಮತ್ತು ಸಮಯದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು, ಯಾದೃಚ್ಛಿಕ ಮೌಲ್ಯಗಳು ಮತ್ತು ಪಾಸ್ವರ್ಡ್ಗಳನ್ನು ರಚಿಸುವುದು ಮತ್ತು ಮುಂತಾದ ಸಾಮಾನ್ಯ ಕಾರ್ಯಗಳಿಗಾಗಿ ಹಲವಾರು ಮಾಡ್ಯೂಲ್ಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಪ್ರಮಾಣಿತ ಲೈಬ್ರರಿಯೊಂದಿಗೆ ಪೈಥಾನ್ ಬರುತ್ತದೆ. ಪೈಥಾನ್ನಲ್ಲಿ ಈಗಾಗಲೇ ಹಲವು ಮಾಡ್ಯೂಲ್ಗಳನ್ನು ನಿರ್ಮಿಸಲಾಗಿದೆ ಅಂದರೆ ನಾವು ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ಸಾಕಷ್ಟು ಕಾರ್ಯಗಳನ್ನು ಈಗಾಗಲೇ ಹೊಂದಿದೆ. ನೀವು ಈ ಮಾಡ್ಯೂಲ್ಗಳನ್ನು ಕಾಣಬಹುದು ಇಲ್ಲಿ.
ಪ್ಯಾಕೇಜುಗಳು
ಮಾಡ್ಯೂಲ್ಗಳ ಮೇಲೆ ನಮ್ಮ ಕೋಡ್ ಅನ್ನು ಸಂಘಟಿಸಲು ಪ್ಯಾಕೇಜುಗಳು ಮೂಲಭೂತವಾಗಿ ಮತ್ತೊಂದು ಮಾರ್ಗವಾಗಿದೆ. ನೈಜ ಯೋಜನೆಯು ನೂರಾರು ಅಥವಾ ಸಾವಿರಾರು ಮಾಡ್ಯೂಲ್ಗಳನ್ನು ಹೊಂದಿರಬಹುದು ಮತ್ತು ಕಾಲಾನಂತರದಲ್ಲಿ ನಮ್ಮ ಡೈರೆಕ್ಟರಿಯು ಹಲವಾರು ಫೈಲ್ಗಳೊಂದಿಗೆ ಉಬ್ಬಿಕೊಳ್ಳುತ್ತದೆ. ಆದ್ದರಿಂದ, ಪ್ಯಾಕೇಜ್ನ ಒಳಗೆ ಸಂಬಂಧಿತ ಮಾಡ್ಯೂಲ್ಗಳನ್ನು ಸಂಘಟಿಸುವುದು ಉತ್ತಮ ವಿಧಾನವಾಗಿದೆ, ಇದು ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಬಹು ಮಾಡ್ಯೂಲ್ಗಳಿಗೆ ಕಂಟೇನರ್ ಮಾಡುತ್ತದೆ.
ಯೋಜನೆಗೆ ಹೊಸ ಡೈರೆಕ್ಟರಿಯನ್ನು ಸೇರಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಎಲ್ಲಾ ಸಂಬಂಧಿತ ಮಾಡ್ಯೂಲ್ಗಳನ್ನು ಆ ಡೈರೆಕ್ಟರಿಗೆ ಸೇರಿಸಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಮಾಲ್ ಬಗ್ಗೆ ಯೋಚಿಸಿ. ಮಾಲ್ನಲ್ಲಿ ಪುರುಷರು, ಮಹಿಳೆಯರು ಮತ್ತು ಮಕ್ಕಳ ಉಡುಪುಗಳಿಗೆ ವಿವಿಧ ವಿಭಾಗಗಳಿವೆ, ಅವುಗಳು ಪ್ಯಾಕೇಜ್ಗಳಂತೆ ಇರುತ್ತವೆ. ಪ್ರತಿಯೊಂದು ವಿಭಾಗವು ಶೂಗಳು, ಟೀ ಶರ್ಟ್ಗಳು ಮತ್ತು ಜಾಕೆಟ್ಗಳಂತಹ ವಿವಿಧ ರೀತಿಯ ಉತ್ಪನ್ನಗಳಿಗೆ ವಿಭಿನ್ನ ಪ್ರದೇಶಗಳನ್ನು ಹೊಂದಿದೆ. ಇವುಗಳನ್ನು ಮಾಡ್ಯೂಲ್ ಎಂದು ಯೋಚಿಸಿ.
ಪೈಥಾನ್ನಲ್ಲಿ ಪ್ಯಾಕೇಜ್ಗಳನ್ನು ಹೇಗೆ ರಚಿಸುವುದು ಮತ್ತು ಬಳಸುವುದು ಎಂದು ನೋಡೋಣ.
ಮೊದಲಿಗೆ, ಪ್ರಾಜೆಕ್ಟ್ ಪ್ಯಾನೆಲ್ನಿಂದ ಹೊಸ ಡೈರೆಕ್ಟರಿಯನ್ನು ಸೇರಿಸಿ. ಅದನ್ನು "ಇಕಾಮರ್ಸ್" ಎಂದು ಕರೆಯೋಣ. ಈ ಪ್ಯಾಕೇಜ್ ಐಕಾಮರ್ಸ್ ಅಪ್ಲಿಕೇಶನ್ಗೆ ಸಂಬಂಧಿಸಿದ ಎಲ್ಲಾ ಮಾಡ್ಯೂಲ್ಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ.
ಇದು ಇನ್ನೂ ಖಾಲಿ ಡೈರೆಕ್ಟರಿಯಾಗಿದೆ ಮತ್ತು ಅದನ್ನು ಪ್ಯಾಕೇಜ್ ಆಗಿ ಪರಿವರ್ತಿಸಲು, ನಾವು ಅದರಲ್ಲಿ ವಿಶೇಷ ಫೈಲ್ ಅನ್ನು ರಚಿಸಬೇಕಾಗಿದೆ. ಈ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ಹೊಸ ಪೈಥಾನ್ ಫೈಲ್ ಅನ್ನು ಸೇರಿಸಿ ಮತ್ತು ಆ ಫೈಲ್ ಅನ್ನು "__init__" ಎಂದು ಹೆಸರಿಸಿ. ಇದು ಪೈಥಾನ್ನಲ್ಲಿನ ವಿಶೇಷ ಸಮಾವೇಶವಾಗಿದೆ ಮತ್ತು ಪೈಥಾನ್ ಇಂಟರ್ಪ್ರಿಟರ್ ಈ ಹೆಸರಿನ ಫೈಲ್ ಅನ್ನು ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ನೋಡಿದಾಗ, ಅದು ಈ ಡೈರೆಕ್ಟರಿಯನ್ನು ಪ್ಯಾಕೇಜ್ನಂತೆ ಪರಿಗಣಿಸುತ್ತದೆ.
ಪ್ಯಾಕೇಜ್ ರಚಿಸಲು ನಾವು ಪರ್ಯಾಯ ಮತ್ತು ಸಂಕ್ಷಿಪ್ತ ವಿಧಾನವನ್ನು ಸಹ ಹೊಂದಿದ್ದೇವೆ. ಪ್ರಾಜೆಕ್ಟ್ ಪ್ಯಾನೆಲ್ ಮೇಲೆ ಬಲ ಕ್ಲಿಕ್ ಮಾಡಿ ಮತ್ತು ಪಟ್ಟಿಯಿಂದ ಪೈಥಾನ್ ಪ್ಯಾಕೇಜ್ ಅನ್ನು ರಚಿಸಿ. ಇದನ್ನು "ಇಕಾಮರ್ಸ್" ಎಂದು ಹೆಸರಿಸಿ ಮತ್ತು ಅಷ್ಟೆ. ಇದು "__init__" ಹೆಸರಿನ ಪೈಥಾನ್ ಫೈಲ್ನೊಂದಿಗೆ ಡೈರೆಕ್ಟರಿಯನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ರಚಿಸುತ್ತದೆ.
ಈಗ, ಪ್ಯಾಕೇಜ್ನಲ್ಲಿ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ರಚಿಸೋಣ ಮತ್ತು ಅದನ್ನು "ಶಿಪ್ಪಿಂಗ್" ಎಂದು ಹೆಸರಿಸೋಣ. ಈ ಮಾಡ್ಯೂಲ್ನಲ್ಲಿ, ಶಿಪ್ಪಿಂಗ್ ವೆಚ್ಚವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ಸರಳವಾದ ಕಾರ್ಯವನ್ನು ರಚಿಸೋಣ.
def calc_shipping():
print("calc_shipping")
ನಮ್ಮ ಮುಖ್ಯ ಮಾಡ್ಯೂಲ್ನಲ್ಲಿ ಈ ಕಾರ್ಯವನ್ನು ಪ್ರವೇಶಿಸಲು, ನಾವು ಅದನ್ನು ಇ-ಕಾಮರ್ಸ್ ಪ್ಯಾಕೇಜ್ ಮೂಲಕ ಪ್ರವೇಶಿಸಬೇಕು. ಮತ್ತೊಮ್ಮೆ ನಾವು ಈ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳಲು ಎರಡು ವಿಧಾನಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ.
ಮೊದಲ ವಿಧಾನದಲ್ಲಿ, ನಾವು ಸಂಪೂರ್ಣ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳಬಹುದು ಮತ್ತು ನಂತರ ಈ ರೀತಿಯ ಕಾರ್ಯವನ್ನು ಸ್ವತಂತ್ರವಾಗಿ ಕರೆಯಬಹುದು:
import eCommerce.shipping
eCommerce.shipping.calc_shipping()
ಆದಾಗ್ಯೂ, ಈ ವಿಧಾನದೊಂದಿಗೆ, ಈ ಮಾಡ್ಯೂಲ್ಗೆ ಕಾರ್ಯಗಳಲ್ಲಿ ಒಂದನ್ನು ಕರೆಯಲು ಅದನ್ನು ಪೂರ್ವಪ್ರತ್ಯಯ ಮಾಡುವ ಅಗತ್ಯವಿದೆ eCommerce.shipping.
ಅದು ತುಂಬಾ ಮೌಖಿಕವಾಗಿದೆ. ಆದ್ದರಿಂದ, ಪ್ಯಾಕೇಜುಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ನಾವು ಸಾಮಾನ್ಯವಾಗಿ ಎರಡನೇ ವಿಧಾನವನ್ನು ಬಳಸುತ್ತೇವೆ ಮತ್ತು ಬಳಸುತ್ತೇವೆ from
ಹೇಳಿಕೆ.
from eCommerce.shipping import calc_shipping
calc_shipping()
ನೀವು ಒಂದು ಮಾಡ್ಯೂಲ್ನಲ್ಲಿ ಬಹು ಕಾರ್ಯಗಳನ್ನು ಹೊಂದಿದ್ದರೆ ಅವುಗಳ ನಡುವೆ ಅಲ್ಪವಿರಾಮಗಳನ್ನು ಬಳಸುವ ಮೂಲಕ ನೀವು ಎಲ್ಲವನ್ನೂ ಒಂದೇ ಸಾಲಿನಲ್ಲಿ ಆಮದು ಮಾಡಿಕೊಳ್ಳಬಹುದು. ನಮ್ಮ ಶಿಪ್ಪಿಂಗ್ ಮಾಡ್ಯೂಲ್ನಲ್ಲಿ ತೆರಿಗೆಯನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ಮತ್ತೊಂದು ಕಾರ್ಯವಿದೆ ಎಂದು ಹೇಳೋಣ. ಇದನ್ನು ಈ ರೀತಿ ಆಮದು ಮಾಡಿಕೊಳ್ಳಲಾಗುತ್ತದೆ:
from eCommerce.shipping import calc_shipping, calc_tax
ನೀವು ವೈಯಕ್ತಿಕ ಮಾಡ್ಯೂಲ್ಗಳನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳಬಹುದು ಮತ್ತು ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ನಂತರದ ಹಂತದಲ್ಲಿ ಕಾರ್ಯಗಳನ್ನು ಕರೆಯಲು ಬಿಡಬಹುದು. ಮಾಡ್ಯೂಲ್ ಶಿಪ್ಪಿಂಗ್ ಅನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳೋಣ ಮತ್ತು ನಂತರ ಕಾರ್ಯವನ್ನು ಕರೆಯಲು ಡಾಟ್ ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸೋಣ calc_shipping.
from eCommerce import shipping
shipping.calc_shipping()
ಅಂತಿಮಗೊಳಿಸು!
ಪೈಥಾನ್ನಲ್ಲಿ ಪ್ಯಾಕೇಜುಗಳು ಮತ್ತು ಮಾಡ್ಯೂಲ್ಗಳು ಬಹಳ ಮುಖ್ಯ. ವಿಶೇಷವಾಗಿ, ನೀವು ನಿರ್ಮಿಸಲು ಬಳಸಲಾಗುವ ಜಾಂಗೊದಂತಹ ಚೌಕಟ್ಟಿನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಬಯಸಿದಾಗ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ಗಳು ಪೈಥಾನ್ ಜೊತೆ. ಮತ್ತೊಂದು ಪೈಥಾನ್ ಕೋರ್ಸ್ ಸಮಯದಲ್ಲಿ ನಾವು ಜಾಂಗೊವನ್ನು ನೋಡುತ್ತೇವೆ.
ಈ ಸರಣಿಯಲ್ಲಿ ಇದು ಕೊನೆಯ ಸಾಂಪ್ರದಾಯಿಕ ಉಪನ್ಯಾಸವಾಗಿತ್ತು. ಮುಂದಿನ ಉಪನ್ಯಾಸವು ನಮ್ಮ ಸಾಮಾನ್ಯ ಸ್ವರೂಪದಿಂದ ವಿಪಥಗೊಳ್ಳುತ್ತದೆ ಮತ್ತು ನಾವು ಪೈಥಾನ್ನಲ್ಲಿ ಕೆಲವು ಪ್ರಮುಖ ಬಳಕೆಯ ಸಂದರ್ಭಗಳನ್ನು ಕಲಿಯುತ್ತೇವೆ. ಅದು ಈ ಸರಣಿಯ ಅಂತ್ಯವನ್ನು ಸೂಚಿಸುತ್ತದೆ ಮತ್ತು ನಾವು ನಮ್ಮ ಮುಂದಿನ ಪೈಥಾನ್ ಸರಣಿಗೆ ಹೋಗುತ್ತೇವೆ. ಅದಕ್ಕಾಗಿ ಕಾಯುತ್ತಿರಿ.
ಪ್ರತ್ಯುತ್ತರ ನೀಡಿ