В това ръководство ще научите приликите и разликите между кортежите и списъците на Python. Ще разберете също кога трябва да използвате кортеж.
Списъкът и кортежите са вградени структури от данни в Python. Те могат да се използват за съхраняване на колекция от елементи.
От поддръжка за индексиране и нарязване до съдържащи разнородни типове данни, кортежите и списъците може да изглеждат като имат сходна функционалност. Следователно разбирането на приликите и разликите между двете може да ви помогне да решите коя структура от данни да използвате.
Нека да започнем.
👩🏽💻 Можете да стартирате Python REPL и да следвате този урок. Можете също да използвате онлайн редактора на Python на pctechbg.net, за да кодирате заедно.
Съдържание
Python Tuple срещу List: Какви са приликите?
Нека започнем, като научим приликите между списъци и кортежи. За да улесним по-доброто учене, представяме примери както за списъци, така и за кортежи.
#1. Python Iterables
В Python списъците са оградени в двойка квадратни скоби, докато кортежите са оградени в скоби. Можете също да създадете кортеж като набор от стойности, разделени със запетаи – без скоби.
И двете са итерируеми; така че можете да преминете през тях с помощта на for цикъл.
Клетката с код по-долу показва как да преминете през списък.
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(string) връща списък, чиито елементи от списък са символите в низа.
list_from_str = list(sample_str) print(list_from_str) # Output ['C', 'o', 'd', 'i', 'n', 'g', '!']
По същия начин, кортеж може да бъде създаден от низ или друга последователност с помощта на tuple(sequence). Клетката с код по-долу показва как можете да го направите.
tuple_from_str = tuple(sample_str)
print(tuple_from_str)
# Output
('C', 'o', 'd', 'i', 'n', 'g', '!')
#3. Поддръжка за индексиране и нарязване
Python поддържа нулево индексиране, при което първият елемент е с индекс нула, вторият с индекс едно и т.н. Python също поддържа отрицателно индексиране, където последният елемент е с индекс -1, предпоследният елемент е с индекс -2 и т.н.
list_from_str = ['C', 'o', 'd', 'i', 'n', 'g', '!'] print(list_from_str[1]) # o
Елементът с индекс -2 е предпоследният елемент, ‘g’.
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']
В допълнение към началната и крайната стойност, можете също да посочите стойност на стъпка. tuple(start:end:step) връща част от кортежа от началото до края – 1, на стъпки от стъпка.
tuple_from_str = ('C', 'o', 'd', 'i', 'n', 'g', '!')
print(tuple_from_str[::2])
('C', 'd', 'n', '!')
Тук задаваме стойността на стъпката на 2. Така че срезът съдържа всеки втори елемент.
#4. Колекции от множество типове данни
В примерите, които разгледахме, всички елементи в списъка и кортежите бяха от един и същи тип данни.
Можете обаче да съхранявате стойности от различни типове данни в рамките на един списък или кортеж.
Кодовият фрагмент под student_list съдържа името на ученик като низ, възрастта като цяло число и оценките, защитени като float.
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. Поддръжка за тестване на членство
И списъците, и кортежите ви позволяват да извършвате тестове за членство за наличието на определени елементи. Ако искате да проверите дали конкретен елемент присъства в списък или кортеж, можете да използвате оператора in.
Елементът на израза в iterable се оценява на True, ако iterable съдържа елемента; иначе, False.
"Alex" in student_list # False "Jane" in student_tuple # True
Досега научихте приликите между списъците и кортежите в Python. След това нека научим основните разлики между двете структури от данни.
Python Tuple срещу List: Какви са разликите?
#1. Променливост на списъци и неизменност на кортежи в Python
Най-важната разлика между списък и кортеж в Python е, че кортежът е неизменен. Това означава, че не можете да модифицирате кортеж на място.
▶️ Ето един пример.
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. Списъци с променлива дължина срещу кортежи с фиксирана дължина
Списъкът на Python е структура от данни с променлива дължина.
Можете да направите следното:
- Добавяне на елемент в края на списъка
- Добавете елементи от друг списък в края на текущия списък
- Премахване на елементи с конкретен индекс от списъка
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. Размер в паметта
Сега ще надградим това, което научихме в предишния раздел: списъкът е структура от данни с променлива дължина.
Когато първоначално дефинирате списъка, за него се разпределя определен размер в паметта. Сега, когато модифицирате списък с помощта на методите append() или extend(), трябва да се разпредели допълнителна памет за съхраняване на добавените елементи. Това разпределение почти винаги се извършва повече от броя на елементите, които добавяте.
Така че има нужда да следите броя на елементите в списъка и разпределеното пространство. Освен това, тъй като списъците са с променлива дължина, има указател, който сочи към адреса на елементите от списъка. В резултат списъците с дължина k заемат повече памет от кортеж със същите k елемента.
Ето една проста илюстрация.
Можете да използвате метода getsizeof() на вградения sys модул за обект на Python, за да получите размера на обект в паметта.
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
Кога трябва да използвате кортеж на Python?
От разликите и приликите между списъците и кортежите на Python знаете, че ако имате нужда от променлива колекция, трябва да използвате списък.
Но кога вместо това трябва да използвате кортеж?
Ще разгледаме това в този раздел.
#1. Колекция само за четене
Всеки път, когато искате колекция да бъде неизменна, трябва да я дефинирате като кортеж. Да предположим, че цвят = (243,55,103) кортеж, съдържащ RGB стойностите, съответстващи на цветен нюанс. Дефинирането на цвят като кортеж гарантира, че той не може да бъде модифициран.
По същество, когато имате нужда колекция да бъде само за четене: стойностите не трябва да се променят по време на програмата, трябва да обмислите използването на кортеж. Това ще предотврати нежелана промяна на стойностите.
#2. Ключове на речника
Например създавате речник, като използвате елементите от списъка key_list като ключове. Можете да използвате метода dict.fromkeys(), за да създадете речник от списък.
key_list = list("ABCD")
dict.fromkeys(key_list)
{'A': None, 'B': None, 'C': None, 'D': None}
Да предположим, че модифицирате списъка така, че да съдържа „D“ като първи елемент (индекс 0) — преди да създадете речника.
Сега, какво се случва с речниковия ключ ‘A’?
Ако се опитате да създадете речник от key_list и получите достъп до стойността, съответстваща на ключа „A“, ще попаднете на KeyError.
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'
Ключовете на речника трябва да бъдат уникални. Така че не можете да имате второ „D“ като ключ.
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. Функционални аргументи
Неизменността на кортежите също ги прави подходящи за предаване като аргументи на функцията.
Помислете за следната функция find_volume(), която връща обема на паралелепипед с дадени размери: дължина, ширина и височина.
def find_volume(dimensions): l,b,h = dimensions return l*b*h
Да предположим, че тези измерения са налични в списък, наречен размери. Извикването на find_volume() с размери като аргумент връща обема.
dimensions = [2,8,5] find_volume(dimensions) 80
Винаги можете да промените размерите, съхранени в списък.
dimensions = [20,8,5] find_volume(dimensions) 800
Въпреки това, понякога ще трябва стойностите да останат постоянни и да се противопоставят на промяна. Тогава трябва да обмислите съхраняването на аргументите като кортеж и използването им в извикването на функцията.
#4. Върнати стойности от функции
В Python ще срещнете кортежи в върнатите стойности от функции. Когато върнете множество стойности от функция, Python имплицитно ги връща като кортеж.
Помислете за следната функция return_even():
def return_even(num): even = [i for i in range(num) if (i%2==0)] return even,len(even)
- Той приема число num като аргумент
- Връща списъка с четни числа в интервала [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
Заключение
Надявам се, че този урок предостави цялостно сравнение на Python кортеж срещу списък.
Нека завършим урока с кратко обобщение:
- Списъкът и кортежите са вградени структури от данни в Python.
- Прилики: итерируеми, поддръжка за индексиране, нарязване, различни типове данни и оператор за тестване на членство.
- Ключова разлика: Списъците са променливи, а кортежите са неизменни.
- Други разлики: Фиксирана дължина на кортежите и променлива дължина на списъците, по-малък размер в паметта на кортежите.
- Кога трябва да използвате кортеж? За неизменни колекции, речникови ключове и функционални аргументи.
След това вижте проекти на Python, за да практикувате и да научите. Или научете методи за премахване на дублиращи се елементи от списъците на Python. Приятно учене! тогава, приятно кодиране!👩🏽💻