Skip to content

ನೆಸ್ಟೆಡ್ for ಲೂಪ್ (Nested for Loop)

ಪೈಥಾನ್‌ನಲ್ಲಿ, ಒಂದು for ಲೂಪ್‌ನೊಳಗೆ ಮತ್ತೊಂದು for ಲೂಪ್ ಅನ್ನು ಬಳಸುವುದನ್ನು ನೆಸ್ಟೆಡ್ for ಲೂಪ್ (Nested for Loop) ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ಹೊರಗಿನ ಲೂಪ್‌ನ (outer loop) ಪ್ರತಿಯೊಂದು ಇಟರೇಷನ್‌ಗೆ, ಒಳಗಿನ ಲೂಪ್ (inner loop) ಸಂಪೂರ್ಣವಾಗಿ ಚಲಿಸುತ್ತದೆ.

ನೆಸ್ಟೆಡ್ ಲೂಪ್‌ಗಳನ್ನು ಮ್ಯಾಟ್ರಿಕ್ಸ್ (matrix), ಗ್ರಿಡ್, ಅಥವಾ ಇತರ ಬಹು-ಆಯಾಮದ (multi-dimensional) ಡೇಟಾ ರಚನೆಗಳ ಮೇಲೆ ಕೆಲಸ ಮಾಡಲು ಹೆಚ್ಚಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ.


ನೆಸ್ಟೆಡ್ for ಲೂಪ್ ಸಿಂಟ್ಯಾಕ್ಸ್

for item1 in outer_sequence:
    # ಹೊರಗಿನ ಲೂಪ್‌ನ ಕೋಡ್
    for item2 in inner_sequence:
        # ಒಳಗಿನ ಲೂಪ್‌ನ ಕೋಡ್
        # ಈ ಬ್ಲಾಕ್ ಹೊರಗಿನ ಲೂಪ್‌ನ ಪ್ರತಿ ಐಟಂಗೆ ಸಂಪೂರ್ಣವಾಗಿ ಚಲಿಸುತ್ತದೆ
        statement(s)

ಉದಾಹರಣೆ 1: ಮಗ್ಗಿಗಳನ್ನು ಪ್ರಿಂಟ್ ಮಾಡುವುದು (Printing Multiplication Tables)

2 ಮತ್ತು 3 ರ ಮಗ್ಗಿಗಳನ್ನು ಪ್ರಿಂಟ್ ಮಾಡಲು ನೆಸ್ಟೆಡ್ ಲೂಪ್ ಅನ್ನು ಬಳಸೋಣ.

# ಹೊರಗಿನ ಲೂಪ್: ಯಾವ ಸಂಖ್ಯೆಯ ಮಗ್ಗಿ ಎಂದು ನಿರ್ಧರಿಸುತ್ತದೆ
for i in range(2, 4):  # i = 2, 3
    print(f"\n--- {i}ರ ಮಗ್ಗಿ ---")
    # ಒಳಗಿನ ಲೂಪ್: 1 ರಿಂದ 10 ರವರೆಗೆ ಗುಣಿಸುತ್ತದೆ
    for j in range(1, 11): # j = 1, 2, ..., 10
        print(f"{i} x {j} = {i * j}")

ಉದಾಹರಣೆ 2: ಲಿಸ್ಟ್‌ಗಳ ಲಿಸ್ಟ್ ಮೇಲೆ ಇಟರೇಟ್ ಮಾಡುವುದು (Iterating over a List of Lists)

ನಮ್ಮಲ್ಲಿ ವಿದ್ಯಾರ್ಥಿಗಳ ಗುಂಪುಗಳಿದ್ದು, ಪ್ರತಿ ಗುಂಪಿನಲ್ಲಿ ಕೆಲವು ವಿದ್ಯಾರ್ಥಿಗಳಿದ್ದಾರೆ.

student_groups = [
    ["ರವಿಕಿರಣ", "ನಿಶ್ಕಲಾ"],
    ["ಗೋವರ್ಧನ್", "ಮಹಾಲಕ್ಷ್ಮಿ", "ಪಾರ್ವತಮ್ಮ"]
]

# ಹೊರಗಿನ ಲೂಪ್: ಪ್ರತಿ ಗುಂಪನ್ನು ಪ್ರವೇಶಿಸುತ್ತದೆ
for group_index, group in enumerate(student_groups):
    print(f"\n--- ಗುಂಪು {group_index + 1} ---")
    # ಒಳಗಿನ ಲೂಪ್: ಪ್ರತಿ ಗುಂಪಿನಲ್ಲಿರುವ ವಿದ್ಯಾರ್ಥಿಯನ್ನು ಪ್ರವೇಶಿಸುತ್ತದೆ
    for student_name in group:
        print(student_name)
ಔಟ್‌ಪುಟ್:
--- ಗುಂಪು 1 ---
ರವಿಕಿರಣ
ನಿಶ್ಕಲಾ

--- ಗುಂಪು 2 ---
ಗೋವರ್ಧನ್
ಮಹಾಲಕ್ಷ್ಮಿ
ಪಾರ್ವತಮ್ಮ


ಉದಾಹರಣೆ 3: ಪ್ಯಾಟರ್ನ್ (Pattern) ಪ್ರಿಂಟ್ ಮಾಡುವುದು

ನೆಸ್ಟೆಡ್ ಲೂಪ್‌ಗಳನ್ನು ಬಳಸಿ ವಿವಿಧ ರೀತಿಯ ಪ್ಯಾಟರ್ನ್‌ಗಳನ್ನು ರಚಿಸಬಹುದು.

# * ನಿಂದ ಒಂದು ತ್ರಿಕೋನವನ್ನು ರಚಿಸುವುದು
rows = 5

# ಹೊರಗಿನ ಲೂಪ್: ಸಾಲುಗಳನ್ನು ನಿಯಂತ್ರಿಸುತ್ತದೆ
for i in range(1, rows + 1):
    # ಒಳಗಿನ ಲೂಪ್: ಪ್ರತಿ ಸಾಲಿನಲ್ಲಿ ಎಷ್ಟು * ಪ್ರಿಂಟ್ ಮಾಡಬೇಕು ಎಂದು ನಿಯಂತ್ರಿಸುತ್ತದೆ
    for j in range(i):
        print("*", end=" ")
    print()  # ಮುಂದಿನ ಸಾಲಿಗೆ ಹೋಗಲು
ಔಟ್‌ಪುಟ್:
* 
* * 
* * * 
* * * * 
* * * * * 


ಗಮನಿಸಬೇಕಾದ ಅಂಶಗಳು

  • ಕಾರ್ಯಕ್ಷಮತೆ (Performance): ನೆಸ್ಟೆಡ್ ಲೂಪ್‌ಗಳು, ವಿಶೇಷವಾಗಿ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳೊಂದಿಗೆ, ನಿಧಾನವಾಗಬಹುದು. ಹೊರಗಿನ ಲೂಪ್ M ಬಾರಿ ಮತ್ತು ಒಳಗಿನ ಲೂಪ್ N ಬಾರಿ ಚಲಿಸಿದರೆ, ಒಟ್ಟು M * N ಇಟರೇಷನ್‌ಗಳು ಆಗುತ್ತವೆ.
  • ಓದಬಲ್ಲದು (Readability): ಅತಿಯಾದ ನೆಸ್ಟಿಂಗ್ (3-4 ಹಂತಗಳಿಗಿಂತ ಹೆಚ್ಚು) ಕೋಡ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಕಷ್ಟಕರವಾಗಿಸುತ್ತದೆ. ಸಾಧ್ಯವಾದರೆ, ತರ್ಕವನ್ನು ಸರಳಗೊಳಿಸಲು ಅಥವಾ ಫಂಕ್ಷನ್‌ಗಳಾಗಿ ವಿಭಜಿಸಲು ಪ್ರಯತ್ನಿಸಿ.

ನೆಸ್ಟೆಡ್ ಲೂಪ್‌ಗಳು ಸಂಕೀರ್ಣ ಡೇಟಾ ರಚನೆಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಮತ್ತು ಪುನರಾವರ್ತಿತ ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಅತ್ಯಂತ ಉಪಯುಕ್ತವಾಗಿವೆ.