python list create
В този урок за списък на Python ще проучим начини за създаване, достъп, нарязване, добавяне / изтриване на елементи към списъци на Python, които са може би един от най-полезните типове данни:
Python включва 4 типа данни за събиране, както е споменато по-долу:
- Списък
- Комплект
- Речник
- Tuple
В този урок ще обсъдим подробно списъка и различните му операции. В Python списъкът е структура от данни или е точно като масив, който се използва за съхраняване на множество данни едновременно.
=> Разгледайте серията за обучение на Python тук
Ако имате опит в други езици за програмиране като Java, C, C ++ и т.н., тогава ще сте запознати с концепцията за масиви. Списъкът е почти същият като масивите.
Какво ще научите:
- Какво представляват списъците на Python
- Повече за списъците в Python
- Заключение
Какво представляват списъците на Python
В Python списъкът е a тип данни , който съхранява колекция от различни обекти (елементи) в квадратна скоба ([]). Всеки елемент в списък е разделен със запетая (,) с първия елемент в индекс 0.
Забележка :Придвижвайки се напред, всички примери в този урок ще се изпълняват директно от обвивка на Python, освен ако не е посочено друго.
По-долу е даден пример за списък с 5 елемента.
>>> l = ['what','who','where','when','how'] >>>l ['what','who','where','when','how']
В горния пример можем да видим, че списъкът има Струнни обекти като елементи и всеки елемент се отделя със запетая.
Характеристики на списъка на Python
Преди да разгледаме как можем да манипулираме елементи в списък, нека разгледаме някои от характеристиките, които правят списъците на Python предпочитани.
Списъците на Python са контейнерни последователности
За разлика от плоските последователности ( низ , масив.масив , memoryview и др.), които могат да съдържат само елементи от един тип, списъкът е a последователност на контейнери които могат да съдържат елементи от един тип, както и от различни видове.
Пример с елементи от един тип
Нека отворим нашата обвивка на python и дефинираме списък с числа.
>>> numbers = ['one','two','three','four','five'] >>> numbers ['one','two','three','four','five']
Примерът по-горе показва списък с елементи от същия тип, в този случай от тип низ (str) .
Пример с елементи от различен тип
Нека отворим нашата обвивка на Python и дефинираме друга версия на списък с числа.
>>> numbers = ['one',2,3,'four',5.0] >>> numbers ['one',2,3,'four',5.0]
Примерът по-горе показва списък с елементи от различен тип. Видовете са низ , цяло число, и плувка .
// a sketch showing the list of items and their types as annotation
Списъкът на Python може да съдържа и всички обекти като функции , класове , модули , списъци , кортежи, и още много.
Отворете редактор и поставете кода по-долу:
def test(): '''This is a function''' print('This is a test') if __name__ == '__main__': print(test) # return instance object of function 'test' instance = type(test) print(instance) # create a list of colors colors = ['red','blue','green'] print(colors) # create a list holding all the various data types defined above, including boolean. my_list = [test, instance, colors, False] print(my_list)
Изход
Списъците на Python са подредени последователности
Списъкът на Python е подредена колекция от обекти. Позицията на всеки елемент в списъка е много важна. Всъщност два списъка с едни и същи елементи не са еднакви, ако редът, в който са позиционирани елементите, не е еднакъв.
>>> ['a','b','c','d'] == ['a','c','b','d'] False
Тази характеристика на списъка на Python дава възможност за достъп до неговите елементи чрез индекс и нарязване (повече за това по-късно).
Списъците на Python са променливи последователности
Списъците на Python са променливи. Но какво е изменяем обект? Това е просто обект, който може да бъде модифициран след създаването му. Примери на други изменяеми последователности са речник , масив.масив , колекции.deque .
Защо променлив? Поредици като списъци се използват за сложни операции, така че има смисъл, че те трябва да могат промяна , растат , свиване , актуализация и т.н. . Това е възможно само при променливост. Изменяемостта също ни позволява да променяме списъците на място (повече за това).
Нека проверим изменчивостта на списък с примера по-долу.
Просто отворете редактор и поставете кода:
def veryfiy_mutability(): # create a list l = [9,0,4,3,5] print('Display before modifying') print('List: {}
Id: {}'.format(l,id(l))) # modify the list by replacing the item at # index 3 to the item -2. l[3] = -2 print('Display after modifying') print('List: {}
Id: {}'.format(l,id(l))) if __name__ == '__main__': veryfiy_mutability()
Изход
От горния изход забелязваме, че списъкът преди и след модификацията е различен. както и да е Документ за самоличност стойността е една и съща. The Документ за самоличност стойност тук представлява адреса на обекта в паметта - който се получава с Python документ за самоличност() .
Това ни казва, че въпреки че съдържанието на списъка се е променило, това все още е същият обект. Следователно това отговаря на нашата дефиниция: „ Това е просто обект, който може да бъде модифициран след създаването му '
Забележка :В горния пример използвахме индексиране (повече за това), за да модифицираме списъка.
Манипулиране на Python списъци
Със списъците на Python небето е нашата граница. Има безброй неща, които можем да направим със списъци като добавяне , изтриване , индексиране , нарязване , проверка за членство , и още много. Също така, Python има вградени функции, които помагат да се направи манипулирането на списъците по-вълнуващи.
В този раздел ще разгледаме някои често използвани операции със списъци.
Създаване на списък
За да създадете списък, просто поставяте няколко елемента или израза в квадратна скоба, разделена със запетаи.
[expression1, expression2,...,expresionN]
>>> l = [4,3,5,9+3,False] >>> l [4, 3, 5, 12, False]
Също така, Python има вграден обект, наречен списък (), които могат да се използват за създаване на списъци.
list( sequence )
>>> l = list() # create an empty list >>> l []
Python списък () може да приема типове последователности и да ги конвертира в списъци. Това е типичният начин за преобразуване на кортеж в списък.
>>> t = (4,3,5) # tuple >>>l = list(t) # convert into list [4,3,5]
В горния пример използвахме типа данни Tuple . Той е подобен на списък, но за разлика от списъците, той е неизменим и елементите му са затворени в скоби.
Друго средство, чрез което можем да създадем списък, е чрез използване разбиране на списъка който има следния синтаксис.
[expression for item in sequence]
>>> [i**2 for i in range(4)] [0, 1, 4, 9]
Заслужава да се отбележи, че списъците на Python се предават чрез препратка. Значение, присвояването на списък ще осигури идентичността на местоположението му в паметта. Грешката, която правят много начинаещи, е да създават списъци по този начин.
>>> l1 = l2 = [4,3] # wrong way to create separate list objects >>> l1 [4,3] >>> l2 [4,3]
Тук може да си помислим, че сме създали два различни списъка, но наистина току-що сме създали един. Нека покажем това, като модифицираме една от променливите.
>>> l1[0] = 0 >>> l1 [0,3] >>> l2 [0,3]
Забелязваме, че модифицирането на една променлива променя другата. Това е така, защото и двете променливи l1 и l2 притежават една и съща идентичност на местоположението на паметта, така че и двете сочат към един и същ обект.
Добавяне на елементи към списък
Python има много начини да добавя елементи към своя списък. Най-често срещаният начин е чрез добавяне () метод. Другите начини са чрез използване на разшири() метод. Индексиране и нарязване (повече за тях по-късно) се използват по-скоро за заместване на елементи в списък.
# 1) Използване на метод append ()
Този метод включва един елемент и го добавя в края на списъка. Той не връща нов списък, а просто го променя на място (благодарение на неговата променливост).
>>>l = list() # create empty list >>> l [] >>> l.append(4) # add an integer >>> l [4] >>> l.append([0,1]) # add a list >>> l [4, [0, 1]] >>> l.append(4 >> l [4, [0, 1], True] >>> l.append(x for x in range(3)) # add result of a tuple comprehension >>> l [4, [0, 1], True, ]
Няколко неща за отбелязване от примера по-горе:
- Елементите тук могат да бъдат изрази, типове данни, последователности и много други.
- The добавяне () методът има времева сложност от (0) 1. Това означава, че е постоянно.
# 2) Използване на метод extension ()
Този метод приема итерация като свой аргумент и добавя всички елементи от него в края на списъка. Този метод се използва най-вече, когато искаме да добавим отделни елементи от последователност в списък
По принцип, разшири() метод се итерира над аргумента си и добавя всеки елемент към списъка. Подобно на метода append (), той не връща нов списък, а променя списъка на място.
>>> l1 = [3,2,5] # create a list of items >>> l1 [3, 2, 5] >>> l2 = [0,0,-1] # create a second list of items >>> l2 [0, 0, -1] >>> str = 'hello' # create a string(iterable) >>> str 'hello' >>> l1.extend(l2) # append all items from l2 to l1 >>> l1 [3, 2, 5, 0, 0, -1] >>> l1.extend(str) # append all items from str to l1 >>> l1 [3, 2, 5, 0, 0, -1, 'h', 'e', 'l', 'l', 'o']
Няколко неща за отбелязване от горния пример:
- Низът е итеративен, така че нашият разшири() метод ще итерира над своите символи.
- The разшири() методът има времева сложност от (0) K, където K е дължината на аргумента му.
Достъп до елементи от списък
Индексиране и нарязване са най-често срещаните средства, които се използват за достъп до списъци. Също така можем да имаме достъп до елементи в списък с цикли като за цикъл .
# 1) Индексиране
Списъкът на Python използва нулево базирано номериране система. Значение, всички негови елементи са уникално идентифицирани с номер на индекс, започващ от 0 до n-1, където n е дължината на списъка.
Обмислете списъка по-долу:
>>> colors = ['red','blue','green','yellow','black'] # create list >>> colors ['red','blue','green','yellow','black'] >>> len(colors) # get list length 5
Таблицата по-долу показва съответните им индекси в нулево базирано номериране на списък.
Вещ | нето | син | зелено | жълт | черен |
---|---|---|---|---|---|
поп () | За да изтриете / премахнете елемента от последния в списък. | ||||
Индекс | 0 | 1 | две | 3 | 4 |
От таблицата по-горе виждаме, че първият елемент („червен“) е на позиция индекс 0, а последният елемент („черен“) е на позиция индекс 4 (n-1), където n = 5 (дължина на обекта цветове).
Както видяхме в горния раздел с характеристики, списъците на Python са подредени последователности. Това ни позволява да използваме индексиране за лесен достъп и манипулиране на неговия елемент.
Нека използваме индексиране за достъп до елементи при определени индекси на обекта с цветове, създаден по-горе.
>>> colors # original list ['red','blue','green','yellow','black'] >>> colors[0] # access item at index 0 'red' >>> colors[4] # access item at index 4 'black' >>> colors[9] # access item at index 9 Traceback (most recent call last): File '', line 1, in IndexError: list index out of range
Забележка :Последното изявление по-горе се опитва да осъществи достъп до елемент в индексна позиция 9 от обект на списък с дължина 5. В списъка на Python достъпът до елемент в индекс, който не съществува, ще повиши IndexError изключение.
Важна концепция за индексиране е, че можем да използваме отрицателно индексиране, т.е.можем да получим достъп до елементи от списък по обратен начин, започвайки от -1 за последния елемент и завършвайки на -n за последния елемент, където n е дължината на обекта на списъка.
В горната таблица, ако използваме отрицателно индексиране, ще изглежда както е показано по-долу:
Вещ | нето | син | зелено | жълт | черен |
---|---|---|---|---|---|
Индекс | -5 | -4 | -3 | -две | -1 |
Нека използваме отрицателно индексиране за достъп до някои елементи от цветния обект, създаден по-горе.
>>> colors # original list ['red','blue','green','yellow','black'] >>> colors[-1] # access item and index -1(first item counting backward) 'black' >>> colors[-3] # access item at index -3(third item counting backward) 'green' >>> colors[-5] # access item at index -5 (last item counting backward) 'red'
# 2) Нарязване
За разлика от индексирането, което връща само един елемент, нарязване от друга страна може да върне редица елементи.
Той има следния синтаксис:
L[n:m]
Когато n е номерът на индекса, откъдето започва среза (по подразбиране е 0), а m е изключителният номер на индекса, където слоят завършва (по подразбиране е дължина-1). Те са разделени с двоеточие (:)
Помислете за долния пример, който използва нарязване за достъп до елементи при определени индекси на обекта с цветове, създаден по-горе.
>>> colors # original list ['red','blue','green','yellow','black'] >>> colors[0:2] # get first two items ['red', 'blue'] >>> colors[1:4] # get items at index 1,2 and 3 ['blue', 'green', 'yellow'] >>> colors[2:len(colors] # get items from index 2 to the last item ['green', 'yellow', 'black'] >>> colors[3:4] # get one item at index 3. Same as colors[3] ['yellow'] >>>
В синтаксиса L [n: m] n по подразбиране е 0, а m по подразбиране дължината на списъка. И така, в примери 1 и 3 по-горе бихме могли да пропуснем n и m като цветове [: 2] и цветове [2:] съответно. Или [:], който в този случай връща плитко копие на целия обект от списъка.
Също така можем да използваме отрицателни индексни числа, докато нарязваме списъци. Това обикновено се използва, когато искаме да получим достъп до списъка по обратен начин.
>>> colors # original list ['red','blue','green','yellow','black'] >>> colors[-3:-2] ['green'] >>> colors[-2:] ['yellow', 'black']
Също така, има трети параметър, който нарезването нарязване поддържа стъпка (с). Той определя колко елемента да се движат напред, след като първият елемент е извлечен от списъка. По подразбиране е 1.
L[n:m:s]
Използвайки същия цветен списък, дефиниран по-горе, нека използваме третия параметър на среза, за да преместим 2 стъпки.
>>> colors # original list ['red','blue','green','yellow','black'] >>> colors[0:3:2] ['red', 'green']
# 3) Използване на цикли
Циклите се използват предимно за достъп до елементи в списък с цел манипулиране на елементите. Така че, в случай че искаме да работим по елементите от списък, можем да използваме за цикъл за достъп до предметите и предаването им, за да бъдат оперирани.
Да речем, ние искаме да преброим броя букви за всеки елемент. Можем да използваме за цикъл за постигане на това.
Отворете редактор и поставете кода по-долу:
def count_letters(l): count = {} # define a dict to hold our count for i in l: # loop through the list count[i] = len(i) # for each item, compute its length and store it in the dict return count # return the count if __name__ == '__main__': colors = ['red', 'blue', 'green', 'yellow', 'black'] print(count_letters(colors))
Изход
За да завършим този раздел, нека разгледаме две страхотни неща, които могат да се направят с нарязване.
-
Направете плитко копие на списък
Това е основният начин за използване на копие() метод на обекта на списъка или вградената функция copy.copy . Това обаче може да се постигне чрез нарязване.
>>> colors # original list ['red','blue','green','yellow','black'] >>> colors_copy = colors[:] # make a shallow copy >>> colors_copy ['red', 'blue', 'green', 'yellow', 'black'] >>> colors_copy[0] = 0 # modify item at index 0 by changing its value to 0 >>> colors_copy # the copied version now has 0 at index 0 [0, 'blue', 'green', 'yellow', 'black'] >>> colors # the original version is unchanged ['red', 'blue', 'green', 'yellow', 'black'] >>>
-
Обърнете списък
Основният начин е да се използва обратен метод на обекта на списъка или вградената функция обърнат () . Това обаче може да се постигне чрез нарязване.
>>> colors # original list object ['red', 'blue', 'green', 'yellow', 'black'] >>> colors[::-1] # returns a reversed shallow copy of the the original list ['black', 'yellow', 'green', 'blue', 'red'] >>>
Премахване на елементи от списък
Тъй като можем да добавим колкото се може повече елементи към списък, те също могат да бъдат премахнати от списък. Трите начина, по които елементите могат да бъдат премахнати, са:
# 1) Използване на декларацията del
Той има следния синтаксис:
del target_list
Целевият списък ( списък с цели ) може да бъде целият списък (в случай че искате да изтриете списъка) или елемент или елементи в списък (в този случай използвате индексиране или нарязване).
Помислете за примера по-долу .
Да кажем, ние искаме да изтрием някои елементи от списъка с цветове, създаден по-горе.
>>> colors # original list ['red', 'blue', 'green', 'yellow', 'black'] >>> c_copy = colors[:] # make a shallow copy to work on >>> del c_copy[0] # delete item at index 0 >>> c_copy ['blue', 'green', 'yellow', 'black'] >>> del c_copy[0:2] # delete items at index 0 and 1(slicing) >>> c_copy ['yellow', 'black'] >>> del c_copy[:] # delete all items in a list. Same as ‘c_copy.clear()’ [] >>> del c_copy # delete the list object >>> c_copy # access object that doesn't exist Traceback (most recent call last): File '', line 1, in NameError: name 'c_copy' is not defined >>>
Забележка :Изразът del се изтрива на място т.е. , той ще модифицира оригиналния обект от списъка, вместо да връща нов обект от списъка.
# 2) Използване на list.remove (x)
Той премахва първия елемент от списъка, чиято стойност е равна на х . Това води до ValueError, ако няма такъв елемент.
Този метод се използва най-вече за премахване на елементи от списък по име, за разлика от оператора del, който използва индексиране и нарязване.
>>> colors # original list ['red', 'blue', 'green', 'yellow', 'black'] >>> c_copy = colors[:] # create shallow copy to work on >>> c_copy ['red', 'blue', 'green', 'yellow', 'black'] >>> c_copy.remove('blue') # remove first item with name 'blue' >>> c_copy ['red', 'green', 'yellow', 'black'] >>> c_copy.remove('blue') # try to remove item that doesn't exist Traceback (most recent call last): File '', line 1, in ValueError: list.remove(x): x not in list >>>
Забележка :Обектът на списъка Премахване() метод изтрива на място т.е. , той ще модифицира оригиналния обект от списъка, вместо да връща нов обект от списъка.
# 3) Използване на list.pop ([i])
Той премахва и връща елемента на дадената позиция в обект от списък. Ако не е предоставен i (индекс), той премахва и връща последния елемент от списъка.
Забележка :Квадратната скоба около i по-горе не означава списък с i, а по-скоро означава, че i е по избор.
>>> colors # original list ['red', 'blue', 'green', 'yellow', 'black'] >>> c_copy = colors[:] # make a shallow copy to work on >>> c_copy ['red', 'blue', 'green', 'yellow', 'black'] >>> c_copy.pop(3) # pop out the item at index 3 'yellow' >>> c_copy ['red', 'blue', 'green', 'black'] >>> c_copy.pop() # pop out the last item in the list 'black' >>> c_copy ['red', 'blue', 'green'] >>>
Забележка: Списъкът. поп ([i]) метод изтрива на място т.е. , той ще модифицира оригиналния обект от списъка, вместо да връща нов обект от списъка. Също така връща елемента, премахнат от списъка
Замяна на елементи от списък
Подмяната на елементи е доста проста. В един от горните раздели видяхме индексиране и нарязване. Те могат да се използват за достъп и премахване на елементи от списък.
# 1) Заменете с помощта на индексиране
L[index] = value
>>> colors # original list ['red', 'blue', 'green', 'yellow', 'black'] >>> c_copy = colors[:] # make a shallow copy to work on >>> c_copy ['red', 'blue', 'green', 'yellow', 'black'] >>> c_copy[0] = 'brown' # replace item at index 0 with 'brown' >>> c_copy ['brown', 'blue', 'green', 'yellow', 'black'] >>>
# 2) Замяна с помощта на нарязване
L[n:m] = value
Забележка : Стойност трябва да бъде итеративен или иначе TypeError ще бъде повдигнато изключение.
>>> colors # original list ['red', 'blue', 'green', 'yellow', 'black'] >>> c_copy = colors[:] # make a shallow copy to work on >>> c_copy[0:2] = ['brown'] # replace items at index 0 and 1 with 'brown' >>> c_copy ['brown', 'green', 'yellow', 'black'] >>> c_copy[1:3] = ['white','purple'] # replace items at index 1 and 2 with 'white' and 'purple' >>> c_copy ['brown', 'white', 'purple', 'black'] >>> c_copy[1:4] = ['white','purple'] # replace items at index 1,2 and 3 with 'white' and 'purple'. Here we replace 3 items with 2 items >>> c_copy ['brown', 'white', 'purple'] >>>
често задавани въпроси
В # 1) Какво представлява списък със списъци в Python?
Отговор: Списък със списъци в Python е списък, който съдържа списъци като свой елемент.
Например
[['a','b'],['c','d']]
Може да се посочи и като вложен списък .
В # 2) Как декларирате списък в Python?
Отговор: В Python списъкът може да бъде деклариран по два начина. Или чрез използване на вградената функция списък () или чрез използване на скобата []. списък () приема итерируемо и [] приема елементи от всякакъв тип, разделени със запетая.
[pytyon]>>> list('hello') # a string is iterable ['h', 'e', 'l', 'l', 'o'] >>> [3,4,5,23] # numbers are separated by comma [3, 4, 5, 23] >>> [/python]
В # 3) Можете ли да поставите списък в списък Python?
Отговор: Да, можем да поставим списък в списъка. Всъщност списъкът е последователност от контейнери, която приема елементи от всякакъв тип данни.
В # 4) Какво прави list () в Python?
Отговор: списък ( ) е вградена функция в Python, която създава списъчен обект. Като аргумент приема итерация.
>>> list((3,2,4)) # The iterable object here is a tuple. [3, 2, 4] >>>
В # 5) Може ли списък на Python да съдържа различни типове?
Отговор: Списъкът е последователност от контейнери, която приема елементи от всякакви типове данни ( списък , кортеж , цяло число , плувка , струни и т.н.)
Повече за списъците в Python
Какво представлява структурата на данните?
Компютрите се използват за съхраняване на огромен брой данни или за обработка на огромен брой данни с висока скорост и точност. Следователно, най-добре е да съхранявате данни постоянно за бърз достъп.
Въпреки че обработката на данни се случва, тя трябва да се случи в най-кратки срокове, без да се губи точност. Използваме структурата на данните, за да се справяме с данните по организиран начин и да съхраняваме данни в паметта за обработка.
Тъй като Python е език за програмиране на високо ниво и интерпретиран, е много важно да се използва структурата на данните в Python.
Какво е Списък?
Списъкът е структура от данни, която се използва за съхраняване на множество данни едновременно.
Данните, съхранявани в списък, са еднородни и това от своя страна го прави най-мощната характеристика на списъка в Python. Можем да съхраняваме множество данни от различни типове данни като String, Integers и обекти, както и в един списък.
Списъкът може да се променя в Python, като по този начин данните могат да се променят по всяко време дори след създаването. Списъците са много мощни за внедряване на стекове и опашки в Python.
Както беше обсъдено по-рано, списъкът съхранява данни в подредена последователност, а данните, съхранявани в списък, се достъпват с помощта на техния индекс, а за списъка индексът винаги ще започва от Нула. Всеки елемент има определено място в списъка и всички тези данни са достъпни с помощта на индекс.
В списъка можем да съхраняваме една и съща стойност няколко пъти и всяка информация ще се разглежда като отделен и уникален елемент. Списъците е най-добре да съхранявате данни и да ги итерирате по-късно.
Създаване на списък
Данните в списък се съхраняват с разделени със запетая и затворени в квадратна скоба ([]). Елементите в списъка не трябва да бъдат от един и същи тип.
Syntax: List = [item1, item2, item3]
Пример 1:
List = [ ]
Пример 2:
List = [2, 5, 6.7]
Пример 3:
List = [2, 5, 6.7, ‘Hi’]
Пример 4:
List = [‘Hi’, ‘Python’, ‘Hello’]
В горните примери можем да забележим, че имаме съхранени елементи от различни типове данни, разделени със запетая, 2 и 5 са от тип Integer, 6.7 е от тип float и „Hi“ е от тип String, всички тези елементи са затворени списък и това го прави Списък.
Можем да декларираме и празен списък. Също така можем да декларираме списък в друг списък и го наричаме като вложен списък.
Пример 5:
List = [‘Hi’, [2, 4, 5], [‘Hello’]]
В горния пример можете да забележите, че списък е деклариран в друг списък.
Достъп до стойности в списъка
Има различни начини, чрез които можем да осъществим достъп до елементите, присъстващи в списъка в Python.
С помощта на индекса можем да получим достъп до елементите от списъка. Индексът започва от 0 и индексът винаги трябва да бъде цяло число. Ако използваме индекс, различен от цяло число като float, това ще доведе до TypeError.
Пример 1:
List = [2, 5, 6.7, ‘Hi’] print(“List is:”, List)
Изход:
Списъкът е: [2, 5, 6.7, „Здравей“]
Изход:
най-добрата програма за наблюдение на процесора и gpu temp
В горния пример ние директно отпечатваме списъка с помощта на функцията за печат, нямаме достъп до отделния елемент от списъка.
Нека да осъществим достъп до отделния елемент от списъка.
Пример: 2
List = [2, 5, 6.7, ‘Hi’] print(“Second element of the list is:”, List[1])
Изход:
Вторият елемент от списъка е: 5
Изход:
В горния пример можете да забележите, че отпечатваме втория елемент от списъка, който е 5, но може да получите въпрос защо в изявлението за печат отпечатваме Списък [1]? Това е така, защото индексът започва от Нула, следователно List [1] се отнася до втория елемент от списъка.
Пример: 3
List = [2, 5, 6.7, ‘Hi’] print(“First element in the List is: ”, List[0]) print(“Last element in the List is: ”, List[3])
Изход:
Първият елемент в списъка е: 2
Последният елемент в списъка е: Здравейте
Изход:
Пример: 4
List = [‘Hi’, [2, 4, 5]] print(“First element of the list is: ”, List[0][1]) print(“Elements present inside another list is: ”, List[1][2])
Изход:
Първият елемент от списъка е: i
Елементите, присъстващи в друг списък, са: 5
Изход:
В горната програма, ако наблюдавате внимателно, можете да видите, че имаме достъп до елементите от вложения списък.
Вътрешно данните ще се съхраняват в матричен формат, както е показано по-долу:
Здравей
2 4 5
Следователно, когато се опитаме да получим достъп до Списък [0] [1], той ще сочи към 1улред и 2ndколона, като по този начин данните ще бъдат „i“.
По същия начин, когато се опитваме да осъществим достъп до Списък [1] [2], той ще сочи към 2ndред и 3rdколона, като по този начин данните ще бъдат 5.
Отрицателно индексиране
Можем да получим достъп до данни и с отрицателен индекс. Отрицателният индекс винаги ще започне от -1 и -1 се отнася до последния елемент, а -2 се отнася до последния втори елемент и т.н.
Пример: 1
List = [2, 5, 7, 3] print(“Last element in the list is: ”, List[-1])
Изход:
Последният елемент в списъка е: 3
Изход:
Пример: 2
List = [2, 5, 7, 3] print(“Second element in the list is: ”, List[-3])
Изход:
Вторият елемент в списъка е: 5
Изход:
Нарязване на списъка
Използвайки оператора за нарязване (:), можем да получим достъп до набор от елементи от списъка
Пример: 1
List = [1, 2, 3, 4, 5, 6, 7] print(“Elements from 2nd to 5th is: ”, List[1:5]) print(“Elements beginning to 2rd is: ”, List[:-3]) print(“Elements 4th to end is: ”, List[3:]) print(“Elements from start to end is: “, List[:])
Изход:
Елементи от 2-ри до 5-ти е: [2, 3, 4, 5]
Елементи, започващи до 2-ро е: [1, 2, 3, 4]
Елементи от 4 до край е: [4, 5, 6, 7]
Елементи от началото до края е: [1, 2, 3, 4, 5, 6, 7]
Изход:
Също така можем да получим достъп до елементите, присъстващи в списъка, като използваме цикъл for.
Пример: 2
List = [1, 2, 3, 4, 5, 6, 7] forele in List: print(ele)
Изход:
1
две
3
4
5
6
7
Изход:
Не забравяйте формата за индексиране по-долу:
З. | Е | L | L | ИЛИ | 5 | 7 | 9 | 4 |
0 | 1 | две | 3 | 4 | 5 | 6 | 7 | 8 |
-9 | -8 | -7 | -6 | -5 | -4 | -3 | -две | -1 |
Както беше обсъдено по-рано, Списъкът в python е променлив, което означава, че елементите могат да се променят, дори ако е Integer или String или някакъв тип данни.
Можем да актуализираме списъка с помощта на оператора за присвояване.
Пример: 3
List = [2, 4, 6, 9] #updating the first element List[0] = 7 print(“Updated list is: ”, List)
Изход:
Актуализираният списък е: [7, 4, 6, 9]
Изход:
В горния пример актуализираме първия елемент от списъка „2“ с нов елемент „7“.
Пример: 4
List = [2, 5, 1, 3, 6, 9, 7] #updating one or more elements of the list at once List[2:6] = [2, 4, 9, 0] print(“Updated List is: ”, List)
Изход:
Актуализираният списък е: [2, 5, 2, 4, 9, 0, 7]
В горния пример актуализираме списъка с данни в списъка.
Изход:
Добавяне на елементи към списъка
Има няколко начина, по които можем да добавяме елементи към списъка, а python има вградена функция, наречена append ().
Използвайки append (), можем да добавим само един елемент към списъка, ако искате да добавите множество елементи към списъка, тогава трябва да използваме за цикъл . Функцията append () винаги добавя елемента в края на списъка, функцията append () взема само един аргумент.
Ако искате да добавите елементи на определена позиция, тогава просто трябва да използвате метода insert (). insert () взема два аргумента, т.е. позиция и стойност, позицията се отнася до индекса, където елементите трябва да бъдат добавени, а стойността се отнася до елемента, който трябва да бъде добавен към списъка.
Има още един метод, наречен extension (), с помощта на който можем да добавяме елементи към списъка. методът extension () се използва за добавяне на списък с елементи към списъка. Подобно на метода append () и extension (), той също ще добавя елементи в края на списъка.
Пример: 1
List = [“Hello”, “Good Morning”] print(“List before appending values is: “, List) List.append(“Python”) List.append(“Hi”) print(“List after appending values is: ”, List)
Изход:
Списъкът преди добавяне на стойности е: [„Здравейте“, „Добро утро“]
Списъкът след добавянето на стойности е: [„Здравей“, „Добро утро“, „Python“, „Здравей“]
В горния пример добавяме стойностите ‘Python’ и ‘Hi’ в края на списъка.
Изход:
Пример: 2
List = [“Hello”, “Good Morning”] print(“List before appending values is: “, List) print(“Length of the list before appending is: “, len(List)) List.append(“Python”) List.append(“Hi”) print(“List after appending values is: ”, List) print(“Length of the list after appending is: “, len(List))
Изход:
Списъкът преди добавяне на стойности е: [„Здравейте“, „Добро утро“]
Дължината на списъка преди добавянето е: 2
Списъкът след добавянето на стойности е: [„Здравей“, „Добро утро“, „Python“, „Здравей“]
Дължината на списъка след добавянето е: 4
Можем да намерим дължината на списъка с помощта на функцията len (), както е показано в горния пример.
Изход:
Също така можем да добавим множество стойности към списъка, като използваме цикъл for.
Пример: 3
List = [7, 9, 8] print(“List before adding elements is: “, List) print(“Length of List before adding elements is: “, len(List)) for i in range(2, 6): List.append(i) print(“List after adding elements is: “, List) print(“Length of List after adding elements is: “, len(List))
Изход:
Списъкът преди добавяне на елементи е: [7, 9, 8]
Дължината на списъка преди добавяне на елементи е: 3
Списъкът след добавяне на елементи е: [7, 9, 8, 2, 3, 4, 5]
Дължината на списъка след добавяне на елементи е: 7
Изход:
Какво се случва, ако добавим списък със списък към списък? Нека да видим това в примера по-долу.
Пример: 4
List1 = [“Hi”, “Python”] List2 = [1, 5, 7, 2] List1.append(List2) print(“List1 after appending List2 is: “, List1)
Изход:
List1 след добавяне на List2 е: [„Здравей“, „Python“, [1, 5, 7, 2]]
Ако забележите в горния пример, когато добавим List2 към List1, тогава List1 ще стане вложен списък.
Изход:
Ако не искате да правите списъка като вложен списък след добавяне на списъка, тогава е по-добре да използвате метода extension ().
Пример: 5
List1 = [“Hi”, “Python”] List2 = [1, 5, 7, 2] List1.extend(List2) print(“List1 after appending List2 is: “, List1)
Изход:
List1 след добавяне на List2 е: [„Здравей“, „Python“, 1, 5, 7, 2]
Когато използваме метода extension (), елементите на List1 ще бъдат разширени с елементите на List2. Не забравяйте, че няма да добави списъка, когато използваме метода extension ().
Изход:
Когато разширите списък със низ, той ще добави всеки символ от низа към списъка, тъй като низът е итеративен.
Пример: 6
List = [1, 5, 7, 2] List.extend(“Python”) print(“List after extending the String is: “, List)
Изход:
Списъкът след удължаване на низа е: [1, 5, 7, 2, „P“, „y“, „t“, „h“, „o“, „n“]
Изход:
Списък append () срещу extension ()
Нека да разгледаме някои примери за extension () и append ().
Пример: 1
def my_fun(): List1 = [“Hi”, 1, “Hello”, 2, 5] print(“The elements of List is: “, List) List.append(“Python”) print(“List after appending the String is: “, List) List.append([“one”, “two”, 3]) print(“List after appending the list is: “, List) List2 = [“Apple”, “Orange”, 2, 8] List1.extend(List2) print(“List1 after extending the List2 is: “, List1) if __name__ == “__main__”: my_fun()
Изход:
Елементите на Списък е: [„Здравей“, 1, „Здравей“, 2, 5]
Списъкът след добавяне на низа е: [„Здравей“, 1, „Здравей“, 2, 5, „Python“]
Списъкът след добавяне на списъка е: [„Здравей“, 1, „Здравей“, 2, 5, „Python“, [„един“, „два“, 3]]
List1 след разширяване на List2 е: [„Здравей“, 1, „Здравей“, 2, 5, „Python“, [„един“, „два“, 3], „Apple“, „Orange“, 2, 8]
Изход:
Пример: 2
List = [“Apple”, “Orange”, “Mango”, “Strawberry”] print(“List before inserting is: “, List) List.insert(2, “Watermelon”) print(“List after inserting is: “, List)
Изход:
Списъкът преди вмъкването е: [„Apple“, „Orange“, „Mango“, „ягода“]
Списъкът след вмъкването е: [„Ябълка“, „Портокал“, „Диня“, „Манго“, „Ягода“]
Изход
Както обсъждахме по-рано, методът insert () се използва за вмъкване на стойности в определен индекс на списъка.
Пример: 3
List1 = [2, 4, 6, 8] print(“List after adding the elements is: “, List1 + [1, 3, 5, 7]) print(“After adding same elements repeatedly is: “, [“Hi”] *5)
Изход:
Списъкът след добавяне на елементите е: [2, 4, 6, 8, 1, 3, 5, 7]
След многократно добавяне на едни и същи елементи е: [„Hi“, „Hi“, „Hi“, „Hi“, „Hi“]
Изход:
Изтриване или премахване на елементи от списък
Също така можем да изтрием или премахнем елементи от списъка, като използваме операторите del и remove ().
разлика между системното тестване и теста за приемане от потребителя
Нека да видим в примера по-долу.
Пример: 1
List = [1, 2, 3, 4, 5, 6, 7, 8, 9] print(“List before deleting 3rd element is: ”, List) del List[3] print(“List after deleting 3rd element is: ”, List) del List[1:3] print(“List after deleting multiple elements is: “, List)
Изход:
Списъкът преди изтриване на 3-ти елемент е: [1, 2, 3, 4, 5, 6, 7, 8, 9]
Списъкът след изтриване на 3-ти елемент е: [1, 2, 3, 5, 6, 7, 8, 9]
Списъкът след изтриване на множество елементи е: [1, 5, 6, 7, 8, 9]
В горния пример можете да забележите, че използваме del оператор за изтриване на елемент или множество изрази от списъка.
Изход:
Сега ще видим за метода remove ().
Пример: 2
List = [1, 2, 3, 4, 5, 6, 7] print(“List before removing a element is: “, List) List.remove(3) print(“List after removing a element is: “, List) List.pop() print(“List after poping the element is: “, List)
Изход:
Списъкът преди премахване на елемент е: [1, 2, 3, 4, 5, 6, 7]
Списъкът след премахване на елемент е: [1, 2, 4, 5, 6, 7]
Списъкът след изскачането на елемента е: [1, 2, 4, 5, 6]
В горния пример можете да забележите, че премахваме елемент от списъка с помощта на метода remove (). Методът pop () се използва за премахване / изтриване на последния елемент от списъка.
Изход:
Методи на списъка
Методи | Описание |
---|---|
изчисти () | За да премахнете всички елементи от списъка. |
добавяне () | За да добавите елемент в края на списъка. |
вмъкване () | За да вмъкнете елемент в определен индекс на списъка. |
разшири() | За да добавите списък с елементи в края на списъка. |
броя() | За връщане на брой елементи с определена стойност. |
индекс () | За връщане на индекса на първия елемент. |
обратен() | За да обърнете съществуващ списък. |
Премахване() | За да премахнете елементите от списъка. |
Заключение
В този урок разгледахме някои характеристики на Python Lists заедно с различните начини за манипулиране на списък като създаване на списък , достъп до елементи от списък , и замяна на елементи от списък.
Този урок от списъка на Python може да бъде завършен със следните указатели:
- List е един от типовете данни в Python, който също се нарича структура на данните.
- Списъкът се използва за съхраняване на голям брой стойности на всякакви типове данни в една единствена променлива, което от своя страна помага за лесен достъп.
- Индексът за списък винаги започва от нула, както другите езици за програмиране.
- Ако работите върху списък, тогава трябва да запомните всички често срещани вградени функции на него.
=> Посетете тук, за да научите Python от нулата
Препоръчително четене
- Урок за Python за начинаещи (практически БЕЗПЛАТНО обучение за Python)
- Променливи на Python
- Урок за разширени списъци на Python (Сортиране по списък, обръщане, индекс, копиране, присъединяване, сума)
- Урок за Python Tuple с практически примери
- Функции на низовете на Python
- Списъци в STL
- Свързана списъчна структура на данните в C ++ с илюстрация
- Структура на данните от кръгов обвързан списък в C ++ с илюстрация