ಪೈಥಾನ್‌ನಲ್ಲಿ ಲೂಪ್‌ಗಾಗಿ. ಸಿಂಟ್ಯಾಕ್ಸ್, ಪಟ್ಟಿ ಪುನರಾವರ್ತನೆ, ಬ್ರೇಕ್, ಮುಂದುವರಿಸಿ ಮತ್ತು ಇತರ ವೈಶಿಷ್ಟ್ಯಗಳು

Цಪೈಥಾನ್ i ಗಾಗಿ ikl ಚಕ್ರ ಸಂದರ್ಭದಲ್ಲಿ - ಹೇಳಿಕೆಗಳು ಸಾಫ್ಟ್ವೇರ್ ಭಾಷೆ, ಅವುಗಳೆಂದರೆ: ಪುನರಾವರ್ತನೆ ನಿರ್ವಾಹಕರು, ಅವಕಾಶING ಪುನರಾವರ್ತಿತ ಕೋಡ್ ನೀಡಿದ ಸಂಖ್ಯೆ ಸಮಯ.

Цಉದಾಹರಣೆಗೆ - сಇಂಟಾಕ್ಸಿಸ್

ಈಗಾಗಲೇ ವಿವರಿಸಿದಂತೆ, ಸಿಪೈಥಾನ್ ಅನ್ನು ಆಧರಿಸಿದ ಪುನರಾವರ್ತಕವಾಗಿದೆй ಪ್ರತಿ ಚಕ್ರಕ್ಕೆಗುರುತನ್ನು. ಅವನ ಕೃತ್ಯಗಳ ಟುಪಲ್ ಅಂಶಗಳಿಂದ и ಪಟ್ಟಿ, ಶಬ್ದಕೋಶ ಕೀಲಿಗಳು ಮತ್ತು ಇತರ ಪುನರಾವರ್ತಿಸಬಹುದಾದ ವಸ್ತುಗಳು.

ಪೈಥಾನ್‌ನಲ್ಲಿನ ಲೂಪ್ ಫಾರ್ ಕೀವರ್ಡ್‌ನೊಂದಿಗೆ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ, ಅದರ ನಂತರ ಅನಿಯಂತ್ರಿತ ವೇರಿಯಬಲ್ ಹೆಸರಿನೊಂದಿಗೆ ಮುಂದಿನ ವಸ್ತುವಿನ ಮೌಲ್ಯವನ್ನು ನಿರ್ದಿಷ್ಟ ಅನುಕ್ರಮದಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ. ಪೈಥಾನ್‌ನಲ್ಲಿ… ಗಾಗಿ ಸಾಮಾನ್ಯ ಸಿಂಟ್ಯಾಕ್ಸ್ ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

ಇನ್: ಬೇರೆ:      

ಘಟಕಗಳು "ಅನುಕ್ರಮಗಳು" ಪಟ್ಟಿ ಮಾಡಲಾಗಿದೆ ಒಂದಾದ ಮೇಲೊಂದು ಸೈಕಲ್ ವೇರಿಯಬಲ್. ಅಥವಾ ಬದಲಿಗೆ, ವೇರಿಯಬಲ್ ಪಾಯಿಂಟ್‌ಗಳಿಗೆ ಇಂತಹ ಅಂಶಗಳು. ಪ್ರತಿಯೊಬ್ಬರಿಗೂ ಅವರಲ್ಲಿ "ಕ್ರಿಯೆ" ನಡೆಸಲಾಗುತ್ತದೆ.

ನಿರ್ದಿಷ್ಟ ಉದಾಹರಣೆಯೊಂದಿಗೆ ಪೈಥಾನ್‌ನಲ್ಲಿ ಲೂಪ್‌ಗಾಗಿ ಸರಳ:

>>> ಭಾಷೆಗಳು = ["C", "C++", "Perl", "Python"] >>> ಭಾಷೆಗಳಲ್ಲಿ x ಗಾಗಿ: ... print(x) ... C C++ Perl Python >>>

ಇತರೆ ಬ್ಲಾಕ್ ವಿಶೇಷವಾಗಿದೆನೇ. ಒಂದು ವೇಳೆ ಪ್ರೋಗ್ರಾಮರ್ыಕೆಲಸ с ಪರ್ಲ್ ಪರಿಚಿತы ಅವನ ಜೊತೆ, ಎಂದು ಸಂವಹನ ಮಾಡುವವರಿಗೆ с C ಮತ್ತು C++ — ಇದು ಒಂದು ನಾವೀನ್ಯತೆ. ಲಾಕ್ಷಣಿಕವಾಗಿ ಇದು ಕಾರ್ಯಗಳನ್ನು тಒಂದೇ ರೀತಿಯಲ್ಲಿ ಲೂಪ್ ಮಾಡುವಾಗ.

ಬ್ರೇಕ್ ಹೇಳಿಕೆಯಿಂದ ಲೂಪ್ ಅನ್ನು "ನಿಲ್ಲಿಸದೆ" ಮಾತ್ರ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಅಂದರೆ, ಎಲ್ಲಾ ಅಂಶಗಳು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಅನುಕ್ರಮದ ಮೂಲಕ ಹಾದುಹೋದ ನಂತರ ಮಾತ್ರ ಅದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ.

ಪೈಥಾನ್‌ನಲ್ಲಿ ಬ್ರೇಕ್ ಆಪರೇಟರ್ - ಬ್ರೇಕ್

ಪ್ರೋಗ್ರಾಂ ಲೂಪ್ ಅನ್ನು ಹೊಂದಿದ್ದರೆ ಅಗತ್ಯ ಅಡ್ಡಿಪಡಿಸುದಿ ಬ್ರೇಕ್ ಹೇಳಿಕೆ, he ಸಂಪೂರ್ಣಇದು ಹೋಗುತ್ತದೆಮತ್ತು ಪ್ರೋಗ್ರಾಂ ಹರಿವು ತಿನ್ನುವೆ ಕಾಂಟ್ಎಂದು ಇಲ್ಲದೆ ಸಕ್ರಿಯಗೊಳಿಸುವಿಕೆ ಬೇರೆಯವರಿಂದ.

ಆಗಾಗ್ಗೆ ಮತ್ತೆ ಮತ್ತೆ ಪೈಥಾನ್‌ನಲ್ಲಿ ನುಡಿಗಟ್ಟುಗಳನ್ನು ಮುರಿಯಿರಿuyutsya ಷರತ್ತುಬದ್ಧ ಹೇಳಿಕೆಗಳೊಂದಿಗೆ.

ತಿನ್ನಬಹುದಾದ ಪದಾರ್ಥಗಳು = ["ಚಾಪ್ಸ್", "ಡಂಪ್ಲಿಂಗ್ಸ್", "ಮೊಟ್ಟೆಗಳು", "ಬೀಜಗಳು"] ಖಾದ್ಯಗಳಲ್ಲಿ ಆಹಾರಕ್ಕಾಗಿ: ಆಹಾರದ ವೇಳೆ == "ಕುಂಬಳಕಾಯಿ": ಪ್ರಿಂಟ್("ನಾನು dumplings ತಿನ್ನುವುದಿಲ್ಲ!") ಬ್ರೇಕ್ ಪ್ರಿಂಟ್("ಗ್ರೇಟ್, ರುಚಿಕರವಾದ " + ಆಹಾರ) ಬೇರೆ: ಮುದ್ರಿಸು("ಕುಂಬಳಕಾಯಿ ಇಲ್ಲದಿರುವುದು ಒಳ್ಳೆಯದು!") ಮುದ್ರಣ("ಭೋಜನ ಮುಗಿದಿದೆ.")

ನೀವು ಈ ಕೋಡ್ ಅನ್ನು ರನ್ ಮಾಡಿದರೆ, ನೀವು ಈ ಕೆಳಗಿನ ಫಲಿತಾಂಶವನ್ನು ಪಡೆಯುತ್ತೀರಿ:

ಅದ್ಭುತ, ರುಚಿಕರವಾದ ಚಾಪ್ಸ್. ನಾನು dumplings ತಿನ್ನುವುದಿಲ್ಲ! ಭೋಜನ ಮುಗಿದಿದೆ.

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

ಅತ್ಯುತ್ತಮ, ರುಚಿಕರವಾದ ಚಾಪ್ಸ್ ಅತ್ಯುತ್ತಮ, ರುಚಿಕರವಾದ ಮೊಟ್ಟೆಗಳು ಅತ್ಯುತ್ತಮ, ರುಚಿಕರವಾದ ಬೀಜಗಳು ಯಾವುದೇ dumplings ಇರಲಿಲ್ಲ ಒಳ್ಳೆಯದು! ಭೋಜನ ಮುಗಿದಿದೆ.

ಪೈಥಾನ್ ಸ್ಕಿಪ್ ಆಪರೇಟರ್ - ಮುಂದುವರಿಸಿ

ಅಂತಹ ಉತ್ಪನ್ನಗಳಿಗೆ ಬಳಕೆದಾರರ ವಿರೋಧವು ಅವರ ಬಳಕೆಯನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ತ್ಯಜಿಸುವಷ್ಟು ಉತ್ತಮವಾಗಿಲ್ಲ ಎಂದು ಹೇಳೋಣ. ಪರಿಣಾಮವಾಗಿ, ಲೂಪ್ ಆಪರೇಟರ್ನೊಂದಿಗೆ ಮುಂದುವರಿಯುತ್ತದೆ continue. ಕೆಳಗಿನ ಸ್ಕ್ರಿಪ್ಟ್ ಹೇಳಿಕೆಯನ್ನು ಬಳಸುತ್ತದೆ continue, "ಡಂಪ್ಲಿಂಗ್ ಸಂಪರ್ಕ" ನಲ್ಲಿ ಪಟ್ಟಿಯ ಮೂಲಕ ಪುನರಾವರ್ತಿಸುವುದನ್ನು ಮುಂದುವರಿಸಲು.

ತಿನ್ನಬಹುದಾದ ಪದಾರ್ಥಗಳು = ["ಚಾಪ್ಸ್", "ಡಂಪ್ಲಿಂಗ್ಸ್", "ಮೊಟ್ಟೆಗಳು", "ಬೀಜಗಳು"] ಖಾದ್ಯಗಳಲ್ಲಿ ಆಹಾರಕ್ಕಾಗಿ: ಆಹಾರ == "ಡಂಪ್ಲಿಂಗ್ಸ್": ಪ್ರಿಂಟ್("ನಾನು dumplings ತಿನ್ನುವುದಿಲ್ಲ!") ಮುದ್ರಣವನ್ನು ಮುಂದುವರಿಸಿ("ಗ್ರೇಟ್, ರುಚಿಕರವಾದ " + ಆಹಾರ) # ಇದು ಆಹಾರವನ್ನು ಆನಂದಿಸಲು ಕೋಡ್ ಆಗಿರಬಹುದು :-) else: print("ನಾನು dumplings ಅನ್ನು ದ್ವೇಷಿಸುತ್ತೇನೆ!") print("ಡಿನ್ನರ್ ಮುಗಿದಿದೆ.")

ಬಾಟಮ್ ಲೈನ್:

ಅದ್ಭುತ, ರುಚಿಕರವಾದ ಚಾಪ್ಸ್. ನಾನು dumplings ತಿನ್ನುವುದಿಲ್ಲ! ಉತ್ತಮ, ರುಚಿಕರವಾದ ಮೊಟ್ಟೆಗಳು ಉತ್ತಮ, ರುಚಿಕರವಾದ ಬೀಜಗಳು ನಾನು dumplings ಅನ್ನು ದ್ವೇಷಿಸುತ್ತೇನೆ! ಭೋಜನ ಮುಗಿದಿದೆ.

ಶ್ರೇಣಿ() ಕಾರ್ಯದೊಂದಿಗೆ ಪಟ್ಟಿಗಳ ಮೇಲೆ ಪುನರಾವರ್ತನೆ

ನೀವು ಪಟ್ಟಿಯ ಸೂಚಿಕೆಗಳನ್ನು ಪ್ರವೇಶಿಸಲು ಬಯಸಿದರೆ, ಈ ಉದ್ದೇಶಕ್ಕಾಗಿ ಲೂಪ್ ಅನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂಬುದು ಸ್ಪಷ್ಟವಾಗಿಲ್ಲ. ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ಪ್ರವೇಶಿಸಲು ಸಾಧ್ಯವಿದೆ, ಆದರೆ ಅಂಶದ ಸೂಚ್ಯಂಕವು ಪ್ರವೇಶಿಸಲಾಗುವುದಿಲ್ಲ. ಆದಾಗ್ಯೂ, ಅಂಶದ ಸೂಚ್ಯಂಕ ಮತ್ತು ಅಂಶ ಎರಡನ್ನೂ ಪ್ರವೇಶಿಸಲು ಒಂದು ವಿಧಾನವಿದೆ. ಈ ಉದ್ದೇಶಕ್ಕಾಗಿ, ಕಾರ್ಯವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ range() ಉದ್ದದ ಕಾರ್ಯದೊಂದಿಗೆ ಸಂಯೋಜಿಸಲಾಗಿದೆ len():

fibonacci = [0,1,1,2,3,5,8,13,21] i ಗಾಗಿ ಶ್ರೇಣಿಯಲ್ಲಿ(len(fibonacci)): print(i,fibonacci[i])

ಪಡೆಯಿರಿ:

0 0 1 1 2 1 3 2 4 3 5 5 6 8 7 13 8

ಗಮನ! ಅನ್ವಯಿಸಿದಾಗ len() к list or tuple, ಕೊಟ್ಟಿರುವ ಅನುಕ್ರಮದ ಅಂಶಗಳ ಅನುಗುಣವಾದ ಸಂಖ್ಯೆಯನ್ನು ಪಡೆಯಲಾಗುತ್ತದೆ.

ಪಟ್ಟಿಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸುವ ತೊಂದರೆಗಳು

ಪಟ್ಟಿಯ ಮೇಲೆ ಪುನರಾವರ್ತಿಸುವಾಗ, ಲೂಪ್ ದೇಹದಲ್ಲಿ ಪಟ್ಟಿ ಡೈನಾಮಿಕ್ಸ್ ಅನ್ನು ತಪ್ಪಿಸಲು ಸೂಚಿಸಲಾಗುತ್ತದೆ. ಸ್ಪಷ್ಟತೆಗಾಗಿ, ನಾವು ಈ ಕೆಳಗಿನ ಆಯ್ಕೆಯನ್ನು ನೀಡಬಹುದು:

ಬಣ್ಣಗಳು = ["ಕೆಂಪು"] ನಾನು ಬಣ್ಣಗಳಲ್ಲಿ: ನಾನು == "ಕೆಂಪು" ವೇಳೆ: ಬಣ್ಣಗಳು += ["ಕಪ್ಪು"] ವೇಳೆ ನಾನು == "ಕಪ್ಪು": ಬಣ್ಣಗಳು += ["ಬಿಳಿ"] ಮುದ್ರಣ(ಬಣ್ಣಗಳು)

ಅನ್ವಯಿಸುವಾಗ ಏನಾಗುತ್ತದೆ print(colours)?

['ಕೆಂಪು', 'ಕಪ್ಪು', 'ಬಿಳಿ']

ಇದನ್ನು ತಪ್ಪಿಸಲು, ಕೆಳಗಿನ ಉದಾಹರಣೆಯಲ್ಲಿರುವಂತೆ ಸ್ಲೈಸ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ನಕಲಿನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು ಶಿಫಾರಸು ಮಾಡಲಾಗಿದೆ:

ಬಣ್ಣಗಳು = ["ಕೆಂಪು"] ನಾನು ಬಣ್ಣಗಳಲ್ಲಿ[:]: ನಾನು == "ಕೆಂಪು" ವೇಳೆ: ಬಣ್ಣಗಳು += ["ಕಪ್ಪು"] ವೇಳೆ ನಾನು == "ಕಪ್ಪು": ಬಣ್ಣಗಳು += ["ಬಿಳಿ"] ಮುದ್ರಣ(ಬಣ್ಣಗಳು )

ಫಲಿತಾಂಶ:

['ಕೆಂಪು ಕಪ್ಪು']

ಪಟ್ಟಿಯನ್ನು ಬದಲಾಯಿಸಲಾಗಿದೆ colours, ಆದರೆ ಈ ಕ್ರಿಯೆಯು ಲೂಪ್ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರಲಿಲ್ಲ. ಲೂಪ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಮಯದಲ್ಲಿ ಪುನರಾವರ್ತನೆ ಮಾಡಬೇಕಾದ ಡೇಟಾವು ಬದಲಾಗದೆ ಉಳಿಯುತ್ತದೆ.

ಪೈಥಾನ್ 3 ರಲ್ಲಿ ಎಣಿಕೆ ಮಾಡಿ

Enumerate ಒಂದು ಅಂತರ್ನಿರ್ಮಿತ ಪೈಥಾನ್ ಕಾರ್ಯವಾಗಿದೆ. ಹೆಚ್ಚಿನ ಆರಂಭಿಕರು, ಹಾಗೆಯೇ ಕೆಲವು ಅನುಭವಿ ಪ್ರೋಗ್ರಾಮರ್ಗಳು ಅದರ ಅಸ್ತಿತ್ವದ ಬಗ್ಗೆ ತಿಳಿದಿರುವುದಿಲ್ಲ. ಲೂಪ್‌ನ ಪುನರಾವರ್ತನೆಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಎಣಿಸಲು ಇದು ನಿಮ್ಮನ್ನು ಅನುಮತಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ:

ಕೌಂಟರ್‌ಗಾಗಿ, ಎಣಿಕೆಯಲ್ಲಿನ ಮೌಲ್ಯ(ಕೆಲವು_ಪಟ್ಟಿ): ಪ್ರಿಂಟ್(ಕೌಂಟರ್, ಮೌಲ್ಯ)

ಕಾರ್ಯ enumerate ಐಚ್ಛಿಕ ವಾದವನ್ನು ಸಹ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ (ಮೂಲದ ಮೌಲ್ಯ, ಡೀಫಾಲ್ಟ್ ಆಗಿ ತೆಗೆದುಕೊಳ್ಳಲಾಗಿದೆ 0) ಇದು ಇನ್ನಷ್ಟು ಪರಿಣಾಮಕಾರಿಯಾಗಿರುತ್ತದೆ.

my_list = ಸಿ ಗಾಗಿ ['ಸೇಬು', 'ಬಾಳೆಹಣ್ಣು', 'ಚೆರ್ರಿ', 'ಪೀಚ್'], ಎಣಿಕೆಯಲ್ಲಿನ ಮೌಲ್ಯ(ನನ್ನ_ಪಟ್ಟಿ, 1): ಪ್ರಿಂಟ್(ಸಿ, ಮೌಲ್ಯ) # ಫಲಿತಾಂಶ: # 1 ಸೇಬು # 2 ಬಾಳೆಹಣ್ಣು # 3 ಚೆರ್ರಿ # 4 ಪೀಚ್