Mga Tuple, na hindi nababago (hindi nababago) na mga sequence na bagay sa Python.
Dapat mag-ingat kapag bumubuo ng mga tuple na may isang elemento o walang laman na tuple.
Ang mga sumusunod na detalye ay inilarawan dito.
- Tuple na may 1 elemento
- Maaaring tanggalin ang mga tuple round bracket.
- Walang laman na tuple
- Tuple sa mga argumento ng function
Tuple na may 1 elemento
Kung susubukan mong bumuo ng isang tuple na may isang elemento at sumulat lamang ng isang bagay sa loob ng mga round bracket (), ang mga round bracket () ay hindi papansinin at ipoproseso at hindi maituturing na isang tuple.
single_tuple_error = (0)
print(single_tuple_error)
print(type(single_tuple_error))
# 0
# <class 'int'>
Ang isang trailing comma ay kinakailangan upang makabuo ng isang tuple na may isang elemento.
single_tuple = (0, )
print(single_tuple)
print(type(single_tuple))
# (0,)
# <class 'tuple'>
Halimbawa, kapag ginagamit ang + operator upang pagsamahin ang maraming tuple, tandaan na kung susubukan mong magdagdag ng isang elemento at makakalimutan ang isang kuwit, magkakaroon ka ng error.
# print((0, 1, 2) + (3))
# TypeError: can only concatenate tuple (not "int") to tuple
print((0, 1, 2) + (3, ))
# (0, 1, 2, 3)
Maaaring tanggalin ang mga tuple round bracket.
Ang dahilan kung bakit ang isang tuple na may isang elemento ay nangangailangan ng kuwit ay dahil ang isang tuple ay hindi isang halaga na nakapaloob sa mga bilog na bracket () ngunit isang halaga na pinaghihiwalay ng kuwit.
Ang kuwit ang lumilikha ng tuple, hindi ang mga bilog na bracket.
Tuples — Built-in Types — Python 3.10.4 Documentation
Kahit na ang mga bilog na bracket () ay tinanggal, ito ay pinoproseso bilang isang tuple.
t = 0, 1, 2
print(t)
print(type(t))
# (0, 1, 2)
# <class 'tuple'>
Tandaan na ang isang hindi kinakailangang kuwit pagkatapos ng isang bagay ay itinuturing na isang tuple.
t_ = 0,
print(t_)
print(type(t_))
# (0,)
# <class 'tuple'>
Walang laman na tuple
Tulad ng nabanggit sa itaas, ang mga round bracket () ay maaaring tanggalin kapag kumakatawan sa isang tuple, ngunit kinakailangan kapag bumubuo ng isang walang laman na tuple.
Ang isang puwang o kuwit lamang ay magreresulta sa isang SyntaxError.
empty_tuple = ()
print(empty_tuple)
print(type(empty_tuple))
# ()
# <class 'tuple'>
# empty_tuple_error =
# SyntaxError: invalid syntax
# empty_tuple_error = ,
# SyntaxError: invalid syntax
# empty_tuple_error = (,)
# SyntaxError: invalid syntax
Ang mga walang laman na tuple ay maaari ding mabuo ng tuple() na walang mga argumento.
empty_tuple = tuple()
print(empty_tuple)
print(type(empty_tuple))
# ()
# <class 'tuple'>
Tuple sa mga argumento ng function
Ang mga tuple round bracket () ay kinakailangan kahit na mayroong syntactic ambiguity.
Ang mga argumento ng function ay pinaghihiwalay ng mga kuwit, ngunit sa kasong ito, kinakailangan na tahasang ipahiwatig kung ang function ay isang tuple o hindi sa pamamagitan ng pagkakaroon o kawalan ng mga bilog na bracket ().
Kung walang panaklong (), ang bawat halaga ay ipinapasa sa bawat argumento; na may mga panaklong (), ang bawat halaga ay ipinapasa bilang isang tuple sa isang argumento.
def example(a, b):
print(a, type(a))
print(b, type(b))
example(0, 1)
# 0 <class 'int'>
# 1 <class 'int'>
# example((0, 1))
# TypeError: example() missing 1 required positional argument: 'b'
example((0, 1), 2)
# (0, 1) <class 'tuple'>
# 2 <class 'int'>
Kung ang tuple ay minarkahan ng asterisk *, ang mga elemento ng tuple ay maaaring palawakin at ipasa bilang mga argumento.
example(*(0, 1))
# 0 <class 'int'>
# 1 <class 'int'>
Para sa karagdagang impormasyon, tingnan ang sumusunod na artikulo.
