ಟ್ಯೂಪಲ್ (Tuple)
ಪೈಥಾನ್ನಲ್ಲಿ, ಟ್ಯೂಪಲ್ (Tuple) ಎಂದರೆ ಕ್ರಮಬದ್ಧ (ordered) ಮತ್ತು ಬದಲಾಯಿಸಲಾಗದ (immutable) ಐಟಂಗಳ ಸಂಗ್ರಹ. ಒಮ್ಮೆ ಟ್ಯೂಪಲ್ ಅನ್ನು ರಚಿಸಿದ ನಂತರ, ಅದರೊಳಗಿನ ಐಟಂಗಳನ್ನು ಬದಲಾಯಿಸಲು, ಸೇರಿಸಲು, ಅಥವಾ ತೆಗೆದುಹಾಕಲು ಸಾಧ್ಯವಿಲ್ಲ.
- ರಚನೆ: ದುಂಡಗಿನ ಆವರಣ
()ಬಳಸಿ ರಚಿಸಲಾಗುತ್ತದೆ. - ಗುಣಲಕ್ಷಣಗಳು: ಕ್ರಮಬದ್ಧ, ಬದಲಾಯಿಸಲಾಗದ, ನಕಲು ಮೌಲ್ಯಗಳಿಗೆ ಅನುಮತಿ.
ಡೇಟಾ ಬದಲಾಗಬಾರದು ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬೇಕಾದ ಸಂದರ್ಭಗಳಲ್ಲಿ ಟ್ಯೂಪಲ್ಗಳು ಉಪಯುಕ್ತ.
1. ಟ್ಯೂಪಲ್ ಅನ್ನು ರಚಿಸುವುದು (Creating a Tuple)
# ಖಾಲಿ ಟ್ಯೂಪಲ್
empty_tuple = ()
# ಸಂಖ್ಯೆಗಳ ಟ್ಯೂಪಲ್
numbers = (1, 2, 3, 4, 5)
# ಸ್ಟ್ರಿಂಗ್ಗಳ ಟ್ಯೂಪಲ್
cities = ("ಹಾಸನ", "ಚನ್ನರಾಯಪಟ್ಟಣ", "ಬೆಂಗಳೂರು")
# ಒಂದೇ ಐಟಂ ಇರುವ ಟ್ಯೂಪಲ್ (ಕೊನೆಯಲ್ಲಿ ಅಲ್ಪವಿರಾಮ ಮುಖ್ಯ)
single_item_tuple = ("ಒಂದು",)
print(f"ನಗರಗಳ ಟ್ಯೂಪಲ್: {cities}")
print(f"ಒಂದೇ ಐಟಂ: {single_item_tuple}")
2. ಐಟಂಗಳನ್ನು ಪ್ರವೇಶಿಸುವುದು (Accessing Items)
ಟ್ಯೂಪಲ್ನ ಐಟಂಗಳನ್ನು ಅವುಗಳ ಇಂಡೆಕ್ಸ್ (index) ಬಳಸಿ ಪ್ರವೇಶಿಸಬಹುದು. ಇದು ಲಿಸ್ಟ್ನಂತೆಯೇ ಕೆಲಸ ಮಾಡುತ್ತದೆ.
weekdays = ("ಸೋಮವಾರ", "ಮಂಗಳವಾರ", "ಬುಧವಾರ", "ಗುರುವಾರ", "ಶುಕ್ರವಾರ")
# ಮೊದಲ ಐಟಂ
print(f"ವಾರದ ಮೊದಲ ದಿನ: {weekdays[0]}") # Output: ಸೋಮವಾರ
# ಕೊನೆಯ ಐಟಂ
print(f"ವಾರದ ಕೊನೆಯ ದಿನ: {weekdays[-1]}") # Output: ಶುಕ್ರವಾರ
# ಸ್ಲೈಸಿಂಗ್
mid_week = weekdays[1:4]
print(f"ವಾರದ ಮಧ್ಯದ ದಿನಗಳು: {mid_week}") # Output: ('ಮಂಗಳವಾರ', 'ಬುಧವಾರ', 'ಗುರುವಾರ')
3. ಟ್ಯೂಪಲ್ಗಳನ್ನು ಬದಲಾಯಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ (Tuples are Immutable)
ಟ್ಯೂಪಲ್ನ ಪ್ರಮುಖ ಗುಣಲಕ್ಷಣವೆಂದರೆ ಅದು ಬದಲಾಯಿಸಲಾಗದು (immutable). ಒಮ್ಮೆ ರಚಿಸಿದ ನಂತರ, ನೀವು ಅದರ ಐಟಂಗಳನ್ನು ಬದಲಾಯಿಸಲು ಪ್ರಯತ್ನಿಸಿದರೆ TypeError ಬರುತ್ತದೆ.
my_tuple = (10, 20, 30)
# my_tuple[0] = 100 # TypeError: 'tuple' object does not support item assignment
ಆದಾಗ್ಯೂ, ಟ್ಯೂಪಲ್ನೊಳಗೆ ಲಿಸ್ಟ್ನಂತಹ ಬದಲಾಯಿಸಬಹುದಾದ ಐಟಂ ಇದ್ದರೆ, ಆ ಲಿಸ್ಟ್ನೊಳಗಿನ ಐಟಂಗಳನ್ನು ಬದಲಾಯಿಸಬಹುದು.
complex_tuple = (1, 2, ["a", "b"])
complex_tuple[2].append("c")
print(complex_tuple) # Output: (1, 2, ['a', 'b', 'c'])
4. ಟ್ಯೂಪಲ್ ಅನ್ಪ್ಯಾಕಿಂಗ್ (Tuple Unpacking)
ಟ್ಯೂಪಲ್ನಲ್ಲಿರುವ ಐಟಂಗಳನ್ನು ಪ್ರತ್ಯೇಕ ವೇರಿಯೇಬಲ್ಗಳಿಗೆ ನಿಯೋಜಿಸುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಅನ್ಪ್ಯಾಕಿಂಗ್ ಎನ್ನುತ್ತಾರೆ.
person = ("ರವಿಕಿರಣ", 30, "ಹಾಸನ")
# ಅನ್ಪ್ಯಾಕಿಂಗ್
name, age, city = person
print(f"ಹೆಸರು: {name}")
print(f"ವಯಸ್ಸು: {age}")
print(f"ನಗರ: {city}")
5. ಟ್ಯೂಪಲ್ ಮೆಥಡ್ಗಳು (Tuple Methods)
ಟ್ಯೂಪಲ್ಗಳು ಬದಲಾಯಿಸಲಾಗದ ಕಾರಣ, ಅವುಗಳು ಕೇವಲ ಎರಡು ಮುಖ್ಯ ಮೆಥಡ್ಗಳನ್ನು ಹೊಂದಿವೆ:
count(item): ಟ್ಯೂಪಲ್ನಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ಐಟಂ ಎಷ್ಟು ಬಾರಿ ಪುನರಾವರ್ತನೆಯಾಗಿದೆ ಎಂದು ಎಣಿಕೆ ಮಾಡುತ್ತದೆ.index(item): ಟ್ಯೂಪಲ್ನಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ಐಟಂನ ಮೊದಲ ಸಂಭವನೀಯತೆಯ ಇಂಡೆಕ್ಸ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
numbers = (1, 2, 3, 2, 4, 2)
print(f"2ರ ಸಂಖ್ಯೆ: {numbers.count(2)}") # Output: 3
print(f"3ರ ಇಂಡೆಕ್ಸ್: {numbers.index(3)}") # Output: 2
ಟ್ಯೂಪಲ್ಗಳನ್ನು ಯಾವಾಗ ಬಳಸಬೇಕು?
- ಸ್ಥಿರ ಡೇಟಾ: ವಾರದ ದಿನಗಳು, ತಿಂಗಳುಗಳು, ಬಣ್ಣಗಳ ಪಟ್ಟಿಯಂತಹ ಬದಲಾಗದ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು.
- ಫಂಕ್ಷನ್ ರಿಟರ್ನ್ಸ್: ಒಂದು ಫಂಕ್ಷನ್ನಿಂದ ಅನೇಕ ಮೌಲ್ಯಗಳನ್ನು ಹಿಂತಿರುಗಿಸಲು (ಪೈಥಾನ್ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಅವುಗಳನ್ನು ಟ್ಯೂಪಲ್ ಆಗಿ ಹಿಂತಿರುಗಿಸುತ್ತದೆ).
- ಡಿಕ್ಷನರಿ ಕೀಗಳು: ಲಿಸ್ಟ್ಗಳನ್ನು ಡಿಕ್ಷನರಿ ಕೀಗಳಾಗಿ ಬಳಸಲು ಸಾಧ್ಯವಿಲ್ಲ, ಆದರೆ ಟ್ಯೂಪಲ್ಗಳನ್ನು ಬಳಸಬಹುದು (ಏಕೆಂದರೆ ಅವು immutable).
ಟ್ಯೂಪಲ್ಗಳು ಲಿಸ್ಟ್ಗಳಿಗಿಂತ ಸ್ವಲ್ಪ ವೇಗವಾಗಿರುತ್ತವೆ ಮತ್ತು ಕಡಿಮೆ ಮೆಮೊರಿ ಬಳಸುತ್ತವೆ, ಆದ್ದರಿಂದ ಬದಲಾಗದ ಡೇಟಾಕ್ಕಾಗಿ ಅವು ಉತ್ತಮ ಆಯ್ಕೆಯಾಗಿವೆ.