У овом водичу ћете научити сличности и разлике између Питхон торки и листа. Такође ћете разумети када треба да користите тупле.
Листа и тупле су уграђене структуре података у Питхон-у. Могу се користити за чување колекције елемената.
Од подршке за индексирање и сечење до садржаја хетерогених типова података, може се чинити да тупле и листе имају сличну функционалност. Стога вам разумевање сличности и разлика између њих може помоћи да одлучите коју структуру података да користите.
Почнимо.
👩🏽💻 Можете покренути Питхон РЕПЛ и пратити овај водич. Такође можете користити вдзвдз-ов онлајн Питхон едитор за кодирање.
Преглед садржаја
Питхон Тупле против листе: Које су сличности?
Почнимо тако што ћемо научити сличности између листа и торки. Да бисмо олакшали боље учење, представљамо примере и листа и торки.
#1. Питхон Итераблес
У Питхон-у, листе су затворене у пар угластих заграда, док су тупле затворене у заградама. Такође можете да креирате тупле као скуп вредности раздвојених зарезима — без заграда.
Обоје су итерабле; тако да можете проћи кроз њих користећи фор петљу.
Ћелија кода испод показује како да се понављате кроз листу.
nums = [2,6,7,10]
print(f"Type of nums is {type(nums)}")
for num in nums:
print(num)
# Output
Type of nums is <class 'list'>
2
6
7
10
Као што је објашњено у наставку, такође можете итерирати кроз тупле користећи петљу
nums = (2,6,7,10)
# Note: nums = 2,6,7,10 is a valid tuple as well. If needed, run a quick check!
print(f"Type of nums is {type(nums)}")
for num in nums:
print(num)
# Output
Type of nums is <class 'tuple'>
2
6
7
10
#2. Подршка за стварање из других секвенци
Следећа сличност између листа и торки је та што се оне могу креирати од постојећих секвенци као што су стрингови.
sample_str = "Coding!"
Следећа ћелија кода показује како листа(стринг) враћа листу, чије ставке листе су знакови у стрингу.
list_from_str = list(sample_str) print(list_from_str) # Output ['C', 'o', 'd', 'i', 'n', 'g', '!']
Слично томе, тупле се може креирати од стринга или друге секвенце користећи тупле(секвенцу). Ћелија кода испод показује како то можете учинити.
tuple_from_str = tuple(sample_str)
print(tuple_from_str)
# Output
('C', 'o', 'd', 'i', 'n', 'g', '!')
#3. Подршка за индексирање и резање
Питхон подржава нулто индексирање у којем је први елемент на индексу нула, други на индексу један итд. Питхон такође подржава негативно индексирање, где је последњи елемент на индексу -1, претпоследњи елемент на индексу -2, итд.
list_from_str = ['C', 'o', 'd', 'i', 'n', 'g', '!'] print(list_from_str[1]) # o
Ставка са индексом -2 је претпоследња ставка, ‘г’.
tuple_from_str = ('C', 'o', 'd', 'i', 'n', 'g', '!')
print(tuple_from_str[-2])
# g
Можете да користите сечење када желите да радите са малим делом листе или торком. листа[start:end] враћа део листе почевши од почетка индекса и протеже се до краја – 1. Подразумевана вредност за почетак је 0, а крај је последњи елемент у итерабле.
Можете да исечете тупле користећи исту синтаксу. Хајде да направимо делове листе и тупле које смо креирали раније.
list_from_str = ['C', 'o', 'd', 'i', 'n', 'g', '!'] print(list_from_str[0:5]) ['C', 'o', 'd', 'i', 'n']
Поред почетне и крајње вредности, можете одредити и вредност корака. тупле(старт:енд:степ) враћа исечак тупле од почетка до краја – 1, у корацима корака.
tuple_from_str = ('C', 'o', 'd', 'i', 'n', 'g', '!')
print(tuple_from_str[::2])
('C', 'd', 'n', '!')
Овде постављамо вредност корака на 2. Дакле, исечак садржи сваки други елемент.
#4. Збирке више типова података
У примерима које смо размотрили, све ставке на листи и тупле били су истог типа података.
Међутим, можете да складиштите вредности различитих типова података унутар једне листе или тупле.
Исечак кода испод студент_лист садржи име ученика као стринг, узраст као цео број и ознаке обезбеђене као флоат.
student_list = ["John",22,96.5]
for item in student_list:
print(f"{item} is of type {type(item)}")
# Output
John is of type <class 'str'>
22 is of type <class 'int'>
96.5 is of type <class 'float'>
Можемо смислити сличан пример за тупле.
student_tuple = ("Jane",23,99.5)
for item in student_tuple:
print(f"{item} is of type {type(item)}")
# Output
Jane is of type <class 'str'>
23 is of type <class 'int'>
99.5 is of type <class 'float'>
#5. Подршка за тестирање чланства
И листе и торке вам омогућавају да извршите тестирање чланства за присуство одређених ставки. Ако желите да проверите да ли је одређена ставка присутна на листи или у низу, можете користити ин оператор.
Израз итем у итерабле процењује се на Тачно ако итерабле садржи ставку; иначе, Нетачно.
"Alex" in student_list # False "Jane" in student_tuple # True
До сада сте научили сличности између листа и торки у Питхон-у. Затим, хајде да научимо кључне разлике између две структуре података.
Питхон Тупле против листе: Које су разлике?
#1. Променљивост листа и непроменљивост тупле у Питхон-у
Најважнија разлика између листе и торке у Питхон-у је у томе што је торка непроменљива. То значи да не можете да мењате тупле на месту.
▶ Ево примера.
tuple1 = ("Java","Python","C++")
tuple1[0] = "Rust"
# Output
----> 2 tuple1[0] = "Rust"
TypeError: 'tuple' object does not support item assignment
Листа је променљива структура података, тако да можемо да изменимо листу променом ставке на одређеном индексу, као у следећој ћелији кода.
list1 = ["Java","Python","C++"] list1[0] = "Rust" print(list1) # Output ['Rust', 'Python', 'C++']
#2. Листе променљиве дужине наспрам низова фиксне дужине
Питхон листа је структура података променљиве дужине.
Можете урадити следеће:
- Додајте ставку на крај листе
- Додајте ставке са друге листе на крај тренутне листе
- Уклоните ставке на одређеном индексу са листе
list1 = [2,3,4,5] # add an item to the end list1.append(9) print(list1) # add items from list2 to the end of list1 list2 = [0,7] list1.extend(list2) print(list1) # remove an item from list1 list1.pop(0) print(list1)
▶ Излаз горњег исечка кода.
# Output [2, 3, 4, 5, 9] [2, 3, 4, 5, 9, 0, 7] [3, 4, 5, 9, 0, 7]
Торке су структуре података фиксне дужине. Дакле, не можете да додајете или уклањате елементе из постојећег тупле. Али можете редефинисати тупле тако да садржи различите елементе.
tuple1 = (2,4,6,8) tuple1 = (1,8,9) print(tuple1) # Output (1, 8, 9)
#3. Величина у меморији
Сада ћемо се надовезати на оно што смо научили у претходном одељку: листа је структура података променљиве дужине.
Када првобитно дефинишете листу, у меморији јој се додељује одређена величина. Сада, када модификујете листу користећи методе аппенд() или ектенд(), требало би да се додели додатна меморија за складиштење додатих елемената. Ова алокација се скоро увек врши више од броја ставки које додате.
Дакле, постоји потреба да се води евиденција о броју ставки на листи и додељеном простору. Поред тога, пошто су листе променљиве дужине, постоји показивач који указује на адресу ставки листе. Као резултат, листе дужине к заузимају више меморије од торке са истим к елемената.
Ево једноставне илустрације.
Можете користити метод гетсизеоф() уграђеног сис модула на Питхон објекту да бисте добили величину објекта у меморији.
import sys
list1 = [4,5,9,14]
list_size = sys.getsizeof(list1)
print(f"Size of list:{list_size}")
tuple1 = (4,5,9,14)
tuple_size = sys.getsizeof(tuple1)
print(f"Size of tuple:{tuple_size}")
Листа заузима више меморије него тупле за исти број и вредност елемената, као што је потврђено у доњем излазу.
# Output Size of list:104 Size of tuple:88
Када треба да користите Питхон тупле?
Из разлика и сличности између Питхон листа и торки, знате да ако вам је потребна променљива колекција, требало би да користите листу.
Али када би требало да користите тупле уместо тога?
О томе ћемо говорити у овом одељку.
#1. Колекција само за читање
Кад год желите да колекција буде непроменљива, требало би да је дефинишете као тупле. Претпоставимо да је боја = (243,55,103) тупле који садржи РГБ вредности које одговарају нијанси боје. Дефинисање боје као тупле осигурава да се не може мењати.
У суштини, када вам је потребно да колекција буде само за читање: вредности не би требало да се мењају током програма, требало би да размислите о коришћењу тупле. Ово ће спречити ненамерну модификацију вредности.
#2. Дицтионари Кеис
На пример, креирате речник користећи ставке листе кеи_лист као кључеве. Можете користити методу дицт.фромкеис() да креирате речник са листе.
key_list = list("ABCD")
dict.fromkeys(key_list)
{'A': None, 'B': None, 'C': None, 'D': None}
Претпоставимо да измените листу тако да садржи ‘Д’ као први елемент (индекс 0)—пре него што креирате речник.
Сада, шта се дешава са кључем речника ‘А’?
Ако покушате да направите речник из листе кључева и приступите вредности која одговара кључу ‘А’, наићи ћете на КеиЕррор.
key_list[0] = 'D' dict.fromkeys(key_list)['A'] --------------------------------------------------------------------------- KeyError Traceback (most recent call last) <ipython-input-31-c90392acc2cf> in <module>() ----> 1 dict.fromkeys(key_list)['A'] KeyError: 'A'
Кључеви речника треба да буду јединствени. Дакле, не можете имати друго ‘Д’ као кључ.
dict.fromkeys(key_list)
{'B': None, 'C': None, 'D': None} # A is no longer a key.
Ако уместо тога користите тупле, таква модификација је немогућа и мање је вероватно да ћете наићи на грешке. Због тога би требало да радије креирате речник користећи ставке из корке као кључеве.
key_tuple = tuple("ABCD")
dict.fromkeys(key_tuple)
{'A': None, 'B': None, 'C': None, 'D': None}
key_tuple[0] = 'D'
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-12-2cecbefa7db2> in <module>()
----> 1 key_tuple[0] = 'D'
TypeError: 'tuple' object does not support item assignment
#3. Аргументи функције
Непроменљивост торки такође их чини погодним за прослеђивање као аргументе функције.
Размотрите следећу функцију финд_волуме() која враћа запремину квадра с обзиром на димензије: дужину, ширину и висину.
def find_volume(dimensions): l,b,h = dimensions return l*b*h
Претпоставимо да су ове димензије доступне на листи која се зове димензије. Позив функције финд_волуме() са димензијама као аргументом враћа запремину.
dimensions = [2,8,5] find_volume(dimensions) 80
Увек можете да промените димензије сачуване на листи.
dimensions = [20,8,5] find_volume(dimensions) 800
Међутим, понекад ће вам требати да вредности остану константне и да се одупру променама. Тада би требало да размислите о чувању аргумената као торку и њиховом коришћењу у позиву функције.
#4. Повратне вредности из функција
У Питхон-у ћете наићи на тупле у повратним вредностима из функција. Када вратите више вредности из функције, Питхон их имплицитно враћа као тупле.
Размотрите следећу функцију ретурн_евен():
def return_even(num): even = [i for i in range(num) if (i%2==0)] return even,len(even)
- Као аргумент узима број нум
- Враћа листу парних бројева у интервалу [0,num) and the length of that list.
Let’s set the value of num 20 and call the function.
num = 20
Calling return_even() returns the two values in a tuple. You can call the type() function with the function call as the verification argument.
type(return_even(num)) # <class 'tuple'>
You can print out the return value to verify that it’s a tuple containing the list of even numbers as the first item and the length of the list as the second item.
print(return_even(num)) ([0, 2, 4, 6, 8, 10, 12, 14, 16, 18]10)
Пошто постоје две ставке у тупле-у, можете их распаковати у две променљиве, као што је приказано испод.
even_nums, count = return_even(num) print(even_nums) print(count) [0, 2, 4, 6, 8, 10, 12, 14, 16, 18] 10
Закључак
Надам се да је овај водич пружио свеобухватно поређење Питхон тупле и листе.
Хајде да завршимо водич са кратким резимеом:
- Листа и тупле су уграђене структуре података у Питхон-у.
- Сличности: итерабле, подршка за индексирање, сечење, различити типови података и оператор за тестирање чланства.
- Кључна разлика: листе су променљиве, а тупле су непроменљиве.
- Остале разлике: Фиксна дужина торки и променљива дужина листа, мања величина у меморији торки.
- Када треба да користите тупле? За непроменљиве колекције, кључеве речника и аргументе функција.
Затим погледајте Питхон пројекте за вежбање и учење. Или научите методе за уклањање дупликата са Питхон листа. Срећно учење! онда, срећно кодирање!👩🏽💻