Tuples
Introduction
Tuple á Python áážáŹ List áá˛áˇ áá°áá˛áˇ Data Structure áá áşááŻá ááŤááąáááˇáş áĄááąá¸ááźáŽá¸áá˛áˇ áá˝áŹááźáŹá¸ááťááş áá áşáᯠáážááááş áĄá˛áˇá፠Tuple á Immutable (ááźáąáŹááşá¸áá˛áááŻáˇááááŹáá˛)á
áᎠChapter áážáŹ Tuple áá˛áˇ áĄááźáąááś áĄáŹá¸ááŻáśá¸áá˛áˇ List áá˛áˇ áááşááᯠáá˝áŹááźáŹá¸áá˛áááŻááŹááᯠáá˝áąáˇáááŤáááşá
Tuple áááŻáᏠááŹááąáŹááşáá˛?
Tuple áááŻáᏠList áá˛áˇ ááąáŹáşááąáŹáş áá°áááşá áá°áááşá¸ áá ášá ááşá¸áá˝áąááᯠáááşá¸á áŽááŹá¸áá˛áˇ ááąáášáᏠáá˛á
- List ááᯠááąáŹááşááŻááşá¸á ááąá¸ááąáŹááˇáşáá˝ááşá¸
[](Square Brackets) ááŻáśá¸áááşá - Tuple ááᯠááąáŹááşáááşááąáŹáˇ áá˝ááşá¸á
áá˝ááşá¸ááááş
()(Parentheses) ááŻáśá¸áááşá
áĽáááŹ:
# ááááşá¸áá˝áąáá˛áˇ Tuple
my_numbers = (10, 20, 30)
# ááąáŹáááá˝ážáą Tuple
my_stuff = ("Laptop", 1, True, "Mouse")
print(my_numbers)
print(my_stuff)Output:
(10, 20, 30)
('Laptop', 1, True, 'Mouse')Tuple Creation
Tuple ááᯠáááşá¸áĄááťááŻá¸ááťááŻá¸ áá˛áˇ áááşááŽá¸áááŻáˇááááşá
1. áá˝ááşá¸ () áá˛áˇ ááąáŹááşáᏠ(áĄááŻáśá¸áĄááťáŹá¸ááŻáśá¸):
my_tuple = (1, 2, 3)
print(my_tuple)2. áá˝ááşá¸ áááŤáᲠááąáŹáşáᏠ(,) ááśááźáŽá¸ ááąá¸ááŹ:
# ááŤá Pro Tip
another_tuple = "a", "b", "c"
print(another_tuple) # Output á ('a', 'b', 'c') áá˛Output:
('a', 'b', 'c')3. Single Element Tuple (áá áşááŻáááşá¸ ááŤáá˛áˇ Tuple):
# áááááŹá¸: Trailing comma (,) á áĄááąá¸ááźáŽá¸áááş!
single = (5,) # ááŤá Tuple
not_tuple = (5) # ááŤá ááááşá¸ 5 áá˛
print(type(single)) # <class 'tuple'>
print(type(not_tuple)) # <class 'int'>4. Empty Tuple (ááᏠTuple):
empty_tuple = ()
print(empty_tuple)
print(len(empty_tuple)) # 0List áá˛áˇ áá°áá˛áˇ áĄááťááş
List áážáŹ ááŻááşáá˛áˇáá˛áˇ Indexing (áá áşááŻááťááşá¸ áá°ááŹ) áá˛áˇ Slicing (áĄáááŻááşá¸áááŻááş áážáŽá¸ááŹ) áá˝áą... Tuple áážáŹáááşá¸ áá áşááŻáśá áśáááşá¸ ááŻááşáááŻáˇááááşá
Indexing:
my_tuple = ("áááşá¸ááŽá¸", "áááášááąáŹáş", "áážááşááťáąáŹ", "á
ááťá
áş")
# Index: 0 1 2 3
# Indexing (áá°áááş)
print(my_tuple[0]) # Output: "áááşá¸ááŽá¸"
print(my_tuple[-1]) # Output: "á
ááťá
áş"Output:
áááşá¸ááŽá¸
á
ááťá
áşSlicing (áážáŽá¸ááŹ):
my_tuple = ("áááşá¸ááŽá¸", "áááášááąáŹáş", "áážááşááťáąáŹ", "á
ááťá
áş")
# Slicing (áážáŽá¸áááş)
print(my_tuple[1:3]) # Output: ("áááášááąáŹáş", "áážááşááťáąáŹ")
print(my_tuple[:2]) # áĄá
áááą 2 ááŻ
print(my_tuple[2:]) # Index 2 áááą áĄááŻáśá¸ááOutput:
('áááášááąáŹáş', 'áážááşááťáąáŹ')
('áááşá¸ááŽá¸', 'áááášááąáŹáş')
('áážááşááťáąáŹ', 'á
ááťá
áş')Other Similar Operations:
my_tuple = (1, 2, 3, 4, 5)
# Length (áĄááąáĄáá˝ááş)
print(len(my_tuple)) # 5
# Loop áá˛áˇ áááşáááŻáˇááááş
for item in my_tuple:
print(item)
# in operator áá˛áˇ á
á
áşáááŻáˇááááş
print(3 in my_tuple) # TrueááŤááᯠbro áá˝áąá¸ááááááˇáşáááşá á... List áá˛áˇ áá°áá°áá˛áááŻááąáŹáˇá ááŹáááŻáˇ Tuple ááᯠáĄáážáŻááşááśááźáŽá¸ ááŻáśá¸ááąááąá¸áá˛á
áĄá˛áˇááŤá áĄááŻááŹáááˇáş áĄááá áĄááźáąáŹááşá¸áĄáᏠImmutability ááźáąáŹááˇáşáá˛á
áĄááá ááá ášá : Immutability (ááźááşáááŻáˇááááŹ)
ááŤá Tuple áá˛áˇ áážááŻáśá¸ááŹá¸ áá˛á
Immutable áááŻáᏠáááźáąáŹááşá¸áá˛áááŻááşááąáŹá ááźááşáááşáááŻáˇ ááááąáŹ áááŻáˇ áĄáááášááŹááşááááşá
bro áááŻááźáąáŹááźááááşáááŻ:
List áááŻáᏠWhiteboard áá˛áˇáá°áááşá
- bro ááźááŻááşáᏠááąá¸áááŻáˇááááşá (.append)
- áááźááŻááşáááş ááťááşáááŻáˇááááşá (.pop, .remove)
- áážáááźáŽá¸ááŹá¸ááᯠááźááşáááŻáˇááááşá (my_list[0] = "New")
Tuple áááŻáᏠááťáąáŹááşá Ꮰáá˛áˇáá°áááşá
- áá áşá፠áá˝ááşá¸ááźáŽá¸áá˝áŹá¸áááş... áĄááąáá˛á
- áááşáááˇáşáááŻáˇ áááá°á¸á
- ááťááşáááŻáˇ áááá°á¸á
- ááźááşáááŻáˇ áááá°á¸á
á ááşá¸ááźááˇáşáááş:
List áážáŹááᯠááŽááᯠááźááşáááŻáˇááááş:
my_list = [1, 2, 3]
my_list[0] = 100 # Index 0 ááᯠ100 ááźáąáŹááşá¸áááş
my_list.append(4) # 4 ááᯠáááşáááˇáşáááş
print(my_list) # Output: [100, 2, 3, 4] áĄáąá¸ááąá¸áá˛Output:
[100, 2, 3, 4]Tuple áážáŹ áĄá˛áˇááᯠáááááźááˇáşááĄáąáŹááş:
my_tuple = (1, 2, 3)
# áá˛... Index 0 ááᯠ100 ááźáąáŹááşá¸ááźááˇáşáááş
try:
my_tuple[0] = 100 # <--- ááŽáážáŹ áá˝áŹá¸ááźáŽ
except TypeError as e:
print(f"Error: {e}")
print("Tuple ááᯠááźááşáááŻáˇ áááá°á¸!")Output:
Error: 'tuple' object does not support item assignment
Tuple ááᯠááźááşáááŻáˇ áááá°á¸!Python á Error ááąá¸ááááˇáşáááş:
TypeError: 'tuple' object does not support item assignment
Tuple Methods áĄáááˇáşáĄáááş áážá
.append(), .pop(), .remove()... List áážáŹ ááŻáśá¸áá˛áˇáá˛áˇ Methods áá˝áą Tuple áážáŹ áá áşááŻááž ááŻáśá¸áááŻáˇ áááá°á¸á
Tuple áážáŹ Methods áážá áşááŻáᲠáážááááş:
1. .count(item) - Item á áááşáážáᯠáážááᲠááąáááş
my_tuple = (1, 2, 2, 3, 2, 4)
count_of_2 = my_tuple.count(2)
print(f"2 á {count_of_2} á፠áážááááş")Output:
2 á 3 á፠áážááááş2. .index(item) - Item á áááş Index áážáŹ áážááá˛
fruits = ("áááşá¸ááŽá¸", "áááášááąáŹáş", "áážááşááťáąáŹ")
position = fruits.index("áááášááąáŹáş")
print(f"áááášááąáŹáş á Index {position} áážáŹ áážááááş")Output:
áááášááąáŹáş á Index 1 áážáŹ áážááááşList áá˛áˇ Methods áá˝áąááᯠTuple áážáŹ ááŻáśá¸áááŻáˇ áááá°á¸:
my_tuple = (1, 2, 3)
# áᎠmethods áá˝áą Tuple áážáŹ ááážááá°á¸
try:
my_tuple.append(4) # AttributeError!
except AttributeError:
print("append() á Tuple áážáŹ ááážááá°á¸")
try:
my_tuple.remove(1) # AttributeError!
except AttributeError:
print("remove() á Tuple áážáŹ ááážááá°á¸")
try:
my_tuple.pop() # AttributeError!
except AttributeError:
print("pop() á Tuple áážáŹ ááážááá°á¸")Output:
append() á Tuple áážáŹ ááážááá°á¸
remove() á Tuple áážáŹ ááážááá°á¸
pop() á Tuple áážáŹ ááážááá°á¸ááŹáááŻáˇ ááźááşáááŻáˇááááŹááᯠááŻáśá¸áááŹáᲠbro?
1. Safety (ááąá¸áááşá¸áááŻáˇ):
bro áĄááąá¸ááŹá¸áá˛áˇ data áá˝áąááᯠ(áĽáááŹ: GPS áááşááąáᏠ(10.123, 20.456)) áážáŹá¸ááźáŽá¸ áááááá ááźááşáááážáŹ áá ááŻá¸ááááşáááąáŹáˇáá°á¸á ááťáąáŹááşá áŹááᯠáááşáážááşááŹá¸áááŻááşááŹá
# GPS Coordinates - áážáŹá¸ááźááşáááááŻáˇ áááá°á¸
location = (16.8661, 96.1951) # Yangon
# ááąá¸áááşá¸áááş - áááşáá°ááž áážáŹá¸ááźáŽá¸ áááźáąáŹááşá¸áááŻááşáá°á¸
print(f"Latitude: {location[0]}, Longitude: {location[1]}")2. áááŻááźááşáááş:
áá°á ááźááşáááŻáˇ áááĄáąáŹááş fix ááŻááşááŹá¸áá˛áˇáĄáá˝ááşá Python á áá°áˇááᯠList áááş ááᯠááąáŤáˇááąáŤáˇááŤá¸ááŤá¸áá˛áˇ ááźááşááźááş áááŻááşáá˝ááşáááŻááşáááşá áááşá¸áááşá¸áᲠááźááşááŹááŤá ááŤááąáááˇáş áá˝áŹááŹááąáŹáˇ áá˝áŹáááşá
3. Dictionary Keys:
Tuple áá˝áąááᯠDictionary áá˛áˇ Key áĄááźá áş ááŻáśá¸áááŻáˇááááşá List áá˝áąááᯠDictionary Key áĄááźá áş ááŻáśá¸áááŻáˇ áááá°á¸ (Immutable ááźá áşááááş)á
# Tuple ááᯠDictionary key áĄááźá
áş ááŻáśá¸áááŻáˇááááş
locations = {
(16.8661, 96.1951): "Yangon",
(21.9162, 95.9560): "Mandalay"
}
print(locations[(16.8661, 96.1951)])Output:
Yangon4. Data Integrity:
Function áááą ááźááşááąá¸áá˛áˇ values áá˝áąááᯠáááźáąáŹááşá¸á áąááťááşáááş Tuple ááŻáśá¸áááşá
def get_user_info():
# User info ááᯠTuple áĄááąáá˛áˇ ááźááşááąá¸áááş
# áááşáá°ááž áááźáąáŹááşá¸á
áąááťááşáááŻáˇ
return ("ááᯠchou", 25, "Developer")
user = get_user_info()
print(user) # ('ááᯠchou', 25, 'Developer')Packing and Unpacking
Tuple Packing (ááŻááşáááŻá¸ááźááşá¸):
Packing áááŻáᏠvalues áá˝áąááᯠTuple áá áşáᯠáĄááźá áş áĄáááŻááᯠá áŻááąáŤááşá¸áá˝áŹá¸ááŹá
# Packing - áá˝ááşá¸ () áááŤáᲠcomma ááśááŻáśáá˛áˇ Tuple ááźá
áşáá˝áŹá¸áááş
coordinates = 10.5, 20.3, 30.7
print(coordinates)
print(type(coordinates))Output:
(10.5, 20.3, 30.7)
<class 'tuple'>Tuple Unpacking ááźááşááźááş:
Unpacking áááŻáᏠááąáášáᏠ(Tuple) áá˛á áá ášá ááşá¸áá˝áąááᯠáá áşááŻááťááşá¸ áá˝á˛ááŻááşááźáŽá¸ ááŹáááşááąá¸ááŹá¸áá˛áˇ ááŻáśá¸áá˝áą (Variables) áá˛ááᯠáá áşááźááŻááşáááş áááˇáşáááŻááşááŹá
áĄááźáąááś Unpacking:
áĽááᏠbro áážáŹ data áá áşáᯠáážááááş áááŻááŤá ááŻáˇá
# (ááŹáááş, áĄáááş, áĄááŻááş)
user_data = ("ááᯠchou", 30, "Developer")
# áááᯠáááŻáááş ááŽááᯠáá°ááááş
# name = user_data[0]
# age = user_data[1]
# job = user_data[2]
# Unpacking áá˛áˇ áááŻáááş... áá
áşááźáąáŹááşá¸áááşá¸áá˛
name, age, job = user_data
# áĄáᯠá
á
áşááźááˇáş
print(name) # Output: "ááᯠchou"
print(age) # Output: 30
print(job) # Output: "Developer"Output:
ááᯠchou
30
Developeruser_data áá˛á á áᯠá name, age, job áááŻáá˛áˇ variables áá˝áąáá˛ááᯠáá°áˇáĄá ááşáááŻááş áĄáááŻááᯠáááşáá˝áŹá¸ááŹá
Extended Unpacking (with *):
* (asterisk) ááŻáśá¸áááş ááťááşáá˛áˇ items áá˝áą áĄááŻááşááŻáśá¸ááᯠList áĄááźá áş áá°áááŻáˇááááşá
numbers = (1, 2, 3, 4, 5)
# ááá áá˛áˇ áĄááąáŹááşááŻáśá¸ áá°áááşá ááźáŹá¸á áĄááŻááş rest áá˛áááˇáşáááş
first, *rest, last = numbers
print(f"First: {first}")
print(f"Rest: {rest}")
print(f"Last: {last}")Output:
First: 1
Rest: [2, 3, 4]
Last: 5Underscore (_) for Ignoring Values:
ááááŻáĄááşáá˛áˇ values áá˝áąááᯠ_ (underscore) áá˛áˇ ááťá áşááťá°áážáŻáááŻáˇááááşá
user_data = ("ááᯠchou", 30, "Developer", "Yangon")
# ááŹáááş áá˛áˇ áĄááŻááşáᲠáááŻááťááşáááşá ááťááşáᏠááááŻ
name, _, job, _ = user_data
print(f"Name: {name}")
print(f"Job: {job}")Output:
Name: ááᯠchou
Job: DeveloperSwapping Values (áááşáááŻá¸áá˝áą áá˛áááş):
Tuple Packing/Unpacking ááᯠááŻáśá¸ááźáŽá¸ variables áážá áşááŻáá˛áˇ values ááᯠáá˝ááşáá˝ááşáá°áá° áá˛áááŻáˇááááşá
a = 10
b = 20
print(f"Before: a={a}, b={b}")
# Swap
a, b = b, a
print(f"After: a={a}, b={b}")Output:
Before: a=10, b=20
After: a=20, b=10Nested Tuples (Tuple áá˛á Tuple)
Tuple áá˛áážáŹ ááąáŹááşáááş Tuple áááşáááˇáşáááŻáˇááááşá
# Nested Tuple - Tuple áá˛áážáŹ Tuple
matrix = (
(1, 2, 3),
(4, 5, 6),
(7, 8, 9)
)
# áĄáá˝ááşá¸á Tuple ááᯠáá°áááş
print(matrix[0]) # (1, 2, 3)
print(matrix[1][2]) # 6
# Loop áá˛áˇ áááşáááş
for row in matrix:
for item in row:
print(item, end=" ")
print()Output:
(1, 2, 3)
6
1 2 3
4 5 6
7 8 9 Type Conversion
Tuple ááᯠList áĄááźá áşá List ááᯠTuple áĄááźá áş ááźáąáŹááşá¸áááŻáˇááááşá
Tuple â List:
my_tuple = (1, 2, 3, 4)
print(f"Tuple: {my_tuple}")
# Tuple ááᯠList áĄááźá
áş ááźáąáŹááşá¸áááş
my_list = list(my_tuple)
print(f"List: {my_list}")
# áĄáᯠList ááźá
áşáá˝áŹá¸ááźáŽ - ááźááşáááŻáˇáááźáŽ
my_list.append(5)
print(f"Modified List: {my_list}")Output:
Tuple: (1, 2, 3, 4)
List: [1, 2, 3, 4]
Modified List: [1, 2, 3, 4, 5]List â Tuple:
my_list = ["a", "b", "c"]
print(f"List: {my_list}")
# List ááᯠTuple áĄááźá
áş ááźáąáŹááşá¸áááş
my_tuple = tuple(my_list)
print(f"Tuple: {my_tuple}")
# áĄáᯠTuple ááźá
áşáá˝áŹá¸ááźáŽ - ááźááşáááŻáˇ ááááąáŹáˇáá°á¸
try:
my_tuple[0] = "x"
except TypeError:
print("Tuple ááᯠááźááşáááŻáˇ áááá°á¸")Output:
List: ['a', 'b', 'c']
Tuple: ('a', 'b', 'c')
Tuple ááᯠááźááşáááŻáˇ áááá°á¸Practical Example: Function Returning Multiple Values
Function áá áşááŻá áááşáááŻá¸ áĄááťáŹá¸ááźáŽá¸ ááźááşááąá¸ááťááşáááş Tuple ááŻáśá¸ááąáŤáˇá ááŤá Python áážáŹ áĄááŻáśá¸áĄááťáŹá¸ááŻáśá¸ pattern áá˛á
def calculate_statistics(numbers):
"""ááááşá¸áá˝áąáá˛áˇ áĄáááşááŻáśá¸á áĄááźáŽá¸ááŻáśá¸á ááťááşá¸ááťáž áá˝ááşáááş"""
minimum = min(numbers)
maximum = max(numbers)
average = sum(numbers) / len(numbers)
# Tuple áĄááźá
áş áááşáááŻá¸ á áᯠááźááşááąá¸áááş
return minimum, maximum, average # Tuple packing
# Function ááᯠááąáŤáşáááş
data = [10, 20, 30, 40, 50]
min_val, max_val, avg_val = calculate_statistics(data) # Tuple unpacking
print(f"áĄáááşááŻáśá¸: {min_val}")
print(f"áĄááźáŽá¸ááŻáśá¸: {max_val}")
print(f"ááťááşá¸ááťáž: {avg_val}")Output:
áĄáááşááŻáśá¸: 10
áĄááźáŽá¸ááŻáśá¸: 50
ááťááşá¸ááťáž: 30.0á፠Python áážáŹ common pattern áá˛á Function áá áşááŻá áááşáááŻá¸ áĄááťáŹá¸ááźáŽá¸ return ááŻááşááťááşáááş Tuple ááŻáśá¸áááşá
áááşááąáŹáˇ Tuple ááŻáśá¸ááá˛? áááşáĄá፠List ááŻáśá¸ááá˛?
Tuple ááŻáśá¸áááˇáşáá˛áˇ áĄááźáąáĄááąááťáŹá¸:
- Fixed Data: Data á ááźáąáŹááşá¸áážáŹ áááŻááşáá°á¸áááŻáá˛áˇá፠(áĽáááŹ: RGB color (255, 128, 0))
- Safety: áážáŹá¸ááźáŽá¸ ááźááşááááŹááťááŻá¸ áááźá áşá áąááťááşáááş
- Dictionary Keys: Dictionary áá˛áˇ key áĄááźá áş ááŻáśá¸ááťááşáááş
- Function Returns: Function á áááşáááŻá¸ áĄááťáŹá¸ááźáŽá¸ return ááŻááşááťááşáááş
- Performance: Speed áááşá¸áááşá¸ áĄááąá¸ááźáŽá¸áááş
- Heterogeneous Data: data type áĄááťááŻá¸ááťááŻá¸ ááŤáá˛áˇá፠(ááŹáááş, áĄáááş, áĄááŻááş)
List ááŻáśá¸áááˇáşáá˛áˇááąááŹá:
- Dynamic Data: Data á ááźáąáŹááşá¸áá˛áááş (áááˇáşá ááťááşá ááźááş)
- Same Type: áá°ááŽáá˛áˇ data áĄááťááŻá¸áĄá áŹá¸áá˝áą (ááąá¸áááşá áŹáááşá¸)
- Need Methods: append, remove, sort á áá˛áˇ methods áááŻáĄááşáááş
- Unknown Size: áááşáážáᯠáááˇáşáááᲠááźááŻááááááş
Examples:
# Tuple ááŻáśá¸áááˇáşáááş - Fixed data
rgb_color = (255, 128, 0) # Orange color
coordinates = (16.8661, 96.1951) # Yangon
date = (2024, 3, 15) # Year, Month, Day
# List ááŻáśá¸áááˇáşáááş ááŽááąááŹáážáŹ
shopping_list = ["áá°á¸áááşá¸ááŽá¸", "áááŻááŹ", "ááąáá˛ááŻááşáˇ"]
shopping_list.append("áááŻáˇ") # áááşáááˇáşáááŻáˇááááş
grades = [85, 90, 78]
grades.sort() # á
áŽáááŻáˇááááşTuple vs List: áážááŻááşá¸áážááşááťááş
================================================================================
Feature | Tuple | List
================================================================================
Syntax | () | []
Mutable | No (Immutable) | Yes (Mutable)
Speed | Faster | Slower
Memory | Less | More
Methods | count(), index() | append(), pop(), remove(), etc.
Dictionary Key | Yes | No
Use Case | Fixed data | Dynamic data
Example | (1, 2, 3) | [1, 2, 3]
================================================================================print("=== Tuple ===")
my_tuple = (1, 2, 3)
print(f"Type: {type(my_tuple)}")
print(f"Can modify? No")
print(f"Methods: count(), index()")
print("\n=== List ===")
my_list = [1, 2, 3]
print(f"Type: {type(my_list)}")
print(f"Can modify? Yes")
print(f"Methods: append(), pop(), remove(), sort(), etc.")ááąáˇááťááˇáşáááŻáˇ
Exercise 1: Tuple Basics
# TODO:
# 1. Tuple áá
áşáᯠááąáŹááşááźááşáˇ - áá
áşááŽá¸ 4 ááťááŻá¸ áááˇáş
# 2. áááááŻáśá¸ áá
áşááŽá¸ áá˛áˇ áĄááąáŹááşááŻáśá¸ áá
áşááŽá¸ ááᯠprint ááŻááş
# 3. Tuple áá˛áážáŹ áá
áşááŽá¸ áááşáážááťááŻá¸ áážááᲠprint ááŻááş
# 4. Tuple ááᯠááźáąáŹááşá¸ááźááşáážááşááźáŽá¸ print ááŻááşá
ááşá¸ááźááşáˇ (slicing ááŻáśá¸)Exercise 2: Tuple Unpacking
student_info = ("ááąáŹááşááąáŹááş", 20, "Computer Science", 3.8)
# TODO:
# 1. Tuple ááᯠunpack ááŻááşááźáŽá¸ variables áá˝á˛ááŻááş
# 2. ááťáąáŹááşá¸ááŹá¸ áĄááťááşáĄáááş áĄááŻááşááŻáśá¸ááᯠprint ááŻááşá
ááşá¸ááźááşáˇáĄáážá áşááťáŻááş
Tuple áááŻááŹ:
- List áá˛áˇ áááşáááşá ááŤááąáááˇáş Immutable (ááźáąáŹááşá¸áááŻáˇáá)
- áá˝ááşá¸ () (Parentheses) áá˛áˇ ááąáŹááşáááş
- ááťáąáŹááşá Ꮰááᯠ- áá áşá፠ááąá¸ááźáŽá¸áááş ááźááşáááŻáˇááááąáŹáˇáá°á¸
áĄááźáąááś Operations:
- Creation: my_tuple = (1, 2, 3) áááŻáˇáááŻááş 1, 2, 3
- Indexing: my_tuple[0] (0 áááą á áááş)
- Slicing: my_tuple[1:3]
- Cannot Modify: my_tuple[0] = 100 ááŻááşáááŻáˇ áááá°á¸
Tuple Methods (áážá áşááŻáᲠáážááááş):
- count() - Item áááşáážáᯠáážááá˛
- index() - Item áááş Index áážáŹ áážááá˛
Unpacking (áĄáááşá¸á áŹá¸):
- Basic: name, age, job = my_tuple
- Extended: first, *rest, last = my_tuple
- Ignore: name, _, job, _ = my_tuple
ááŹááźáąáŹááˇáş Tuple ááŻáśá¸áážáŹáá˛?
- Safety: áážáŹá¸ááźáŽá¸ ááźááşáááážáŹ áá ááŻá¸ááááşááá°á¸
- Speed: List áááş ááźááşáááş
- Dictionary Keys: Key áĄááźá áş ááŻáśá¸áááŻáˇááááş
Quick Reference
# Creation
my_tuple = (1, 2, 3)
another_tuple = 1, 2, 3
single = (5,)
empty = ()
# Indexing & Slicing
my_tuple[0]
my_tuple[-1]
my_tuple[1:3]
# Methods
my_tuple.count(2)
my_tuple.index(3)
# Packing & Unpacking
coords = 10, 20
x, y = coords
first, *rest, last = my_tuple
name, _, age = ("John", 25, 30)
# Conversion
list(my_tuple)
tuple(my_list)
# Immutable - Cannot do these:
# my_tuple[0] = 100 # TypeError!
# my_tuple.append(4) # AttributeError!
# my_tuple.remove(1) # AttributeError!