python list create
У овом упутству за Питхон Лист истражићемо начине за стварање, приступ, пресецање, додавање / брисање елемената на Питхон листе који су недвојбено један од најкориснијих типова података:
Питхон укључује 4 типа података о колекцији како је поменуто у наставку:
- Листа
- Комплет
- Речник
- Тупле
У овом упутству детаљно ћемо размотрити Лист и његове различите операције. У Питхону, листа је структура података или је попут низа који се користи за складиштење више података одједном.
=> Овде истражите серију обука за Питхон
Ако имате искуства са било којим другим програмским језицима као што су Јава, Ц, Ц ++ итд., Тада ћете бити упознати са концептом низова. Листа је готово иста као низови.
Шта ћете научити:
- Шта су Питхон листе
- Више о листама у Питхону
- Закључак
Шта су Питхон листе
У Питхону је листа а тип података , који чува колекцију различитих предмета (предмета) у углатим заградама ([]). Свака ставка на листи одвојена је зарезом (,) са првом ставком на индексу 0.
Белешка :Крећући се напред, сви примери у овом упутству ће се директно покретати из Питхон љуске, ако није другачије назначено.
Испод је пример листе са 5 ставки.
>>> l = ['what','who','where','when','how'] >>>l ['what','who','where','when','how']
У горњем примеру можемо видети да листа има Стринг предмети као ставке, а свака ставка је одвојена зарезом.
Карактеристике Питхон листе
Пре него што погледамо како можемо манипулисати ставкама на листи, погледајмо неке карактеристике због којих су Питхон листе фаворизоване.
Питхон листе су секвенце контејнера
За разлику од равних секвенци ( низ , низ.низ , меморивиев , итд.) који могу да садрже само предмете једне врсте, листа је а секвенца контејнера који могу да садрже предмете како једне врсте, тако и различитих врста.
Пример са предметима једне врсте
Отворимо нашу питхон љуску и дефинишемо листу бројева.
>>> numbers = ['one','two','three','four','five'] >>> numbers ['one','two','three','four','five']
Горњи пример приказује листу предмета истог типа, у овом случају типа стринг (стр) .
Пример са предметима различитих врста
Отворимо нашу Питхон љуску и дефинишемо другу верзију листе бројева.
>>> 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
Питхон листа такође може садржати све објекте као што су функције , класе , модула , листе , корице, и још много тога.
Отворите едитор и налепите доњи код:
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)
Оутпут
Питхон листе су уређене секвенце
Питхон листа је уређена колекција објеката. Положај сваке ставке на листи је веома важан. У ствари, две листе са истим ставкама нису исте ако редослед у којем су ставке постављене није исти.
>>> ['a','b','c','d'] == ['a','c','b','d'] False
Ова карактеристика Питхон листе омогућава приступ њеним ставкама индексирањем и резањем (о томе више касније).
Питхон листе су променљиве секвенце
Питхон листе су променљиве. Али шта је променљиви предмет? То је једноставно објекат који се може изменити након што се креира. Примери осталих променљивих секвенци су речник , низ.низ , збирке.декуе .
Зашто променљиво? Секвенце попут листа користе се за сложене операције, па има смисла да би то требало да могу промена , расти , скупља , ажурирање итд . То је могуће само са променљивошћу. Променљивост нам такође омогућава да изменимо постојеће листе (више о томе).
Проверимо променљивост листе помоћу примера у наставку.
Само отворите едитор и налепите код:
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()
Оутпут
Из горњег резултата примећујемо да се листа пре и после модификације разликује. Међутим Ид вредност је иста. Тхе Ид вредност овде представља адресу објекта у меморији - која се добија помоћу Питхона ид () .
То нам говори да је, иако се садржај листе променио, то и даље исти објекат. Дакле, ово задовољава нашу дефиницију: „ То је једноставно објекат који се може изменити након што се креира '
Белешка :У горњем примеру смо користили индексирање (више о томе) за модификовање листе.
Манипулирање Питхон листама
Са Питхон листама, небо је наша граница. Постоји безброј ствари које можемо учинити са листама додавање , брисање , индексирање , резање , провера чланства , и још много тога. Такође, Питхон има уграђене функције које помажу да манипулисање списковима учини узбудљивијим.
У овом одељку ћемо размотрити неке најчешће коришћене операције списка.
Креирање листе
Да бисте креирали листу, једноставно ставите бројне ставке или изразе у углату заграду одвојену зарезима.
[expression1, expression2,...,expresionN]
>>> l = [4,3,5,9+3,False] >>> l [4, 3, 5, 12, False]
Такође, Питхон има уграђени објекат тзв листа () који се могу користити за прављење листа.
list( sequence )
>>> l = list() # create an empty list >>> l []
Питхон листа () могу да узимају врсте секвенци и претварају их у листе. Ово је типичан начин претварања корпице у листу.
>>> t = (4,3,5) # tuple >>>l = list(t) # convert into list [4,3,5]
У горњем примеру смо користили тип података Тупле . Слична је листи, али за разлику од листа, непроменљива је и њени предмети су затворени у заградама.
Још једно средство помоћу којег можемо да направимо листу је коришћење списак схватања која има следећу синтаксу.
[expression for item in sequence]
>>> [i**2 for i in range(4)] [0, 1, 4, 9]
Вреди напоменути да се Питхон листе преносе референцом. Што значи, додељивање листе ће пружити идентитет њене меморијске локације. Грешка коју многи почетници чине је да праве листе на овај начин.
>>> 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]
Примећујемо да модификовање једне променљиве мења другу. То је зато што обе променљиве л1 и л2 имају исти идентитет локације меморије, па обе указују на исти објекат.
Додавање предмета на листу
Питхон има много начина да дода елементе на своју листу. Најчешћи начин је коришћење додати() метода. Други начини су коришћење проширити() метода. Индексирање и резање (о њима више касније) се вероватније користе за замену ставки на листи.
# 1) Коришћењем методе аппенд ()
Овај метод узима једну ставку и додаје је на крај листе. Не враћа нову листу, већ је само модификује на месту (захваљујући својој променљивости).
>>>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, ]
Неколико ствари које треба приметити из горњег примера:
- Ставке овде могу бити изрази, типови података, секвенце и још много тога.
- Тхе додати() метода има временску сложеност од (0) 1. Значи да је константна.
# 2) Користећи методу ектенсион ()
Овај метод узима итерабле као свој аргумент и додаје све ставке с њега на крај листе. Ова метода се углавном користи када желимо да на листу додамо појединачне ставке низа
У основи, проширити() метода превлачи свој аргумент и додаје сваку ставку на листу. Баш као и метода аппенд (), она не враћа нову листу већ модификује листу на месту.
>>> 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']
Неколико ствари које треба приметити из горњег примера:
- Низ је поновљив, па и наш проширити() метода ће се понављати преко својих знакова.
- Тхе проширити() метода има временску сложеност (0) К где је К дужина аргумента.
Приступ предметима са листе
Индексирање и резање су најчешћа средства која се користе за приступ листама. Такође можемо приступити ставкама на листи са петљама попут фор лооп .
# 1) Индексирање
Питхон листа користи нумерација заснована на нули систем. Значи, све његове ставке су јединствено идентификоване бројем индекса који почиње од 0 до н-1, где је н дужина листе.
Размотрите доњу листу:
>>> 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 (н-1) где је н = 5 (дужина објекта боје).
Као што смо видели у карактеристичном одељку изнад, Питхон листе су уређене секвенце. То нам омогућава да помоћу индексирања лако приступимо и манипулишемо њеном ставком.
Користимо индексирање за приступ ставкама на одређеним индексима горњег објекта боје.
>>> 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. На Питхон листи, приступ ставци у индексу који не постоји подићи ће ИндекЕррор изузетак.
Важан концепт индексирања је да можемо користити негативно индексирање, тј. Можемо приступити ставкама листе обрнуто, почевши од -1 за последњу ставку и завршавајући на -н за последњу ставку где је н дужина објекта листе.
У горњој табели, ако користимо негативно индексирање, изгледаће као што је приказано доле:
Предмет | нето | Плави | зелена | жуто | црн |
---|---|---|---|---|---|
Индекс | -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]
Када је н индексни број где одрезак започиње (подразумевано је 0), а м ексклузивни индексни број где се пресек завршава (подразумевана дужина-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'] >>>
У синтакси Л [н: м], н подразумевано износи 0, а м подразумевано дужину листе. Дакле, у примери 1 и 3 горе, могли бисмо изоставити н и м као боје [: 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))
Оутпут
Да завршимо овај одељак, погледајмо две сјајне ствари које се могу урадити резањем.
-
Направите плитку копију листе
То је основни начин употребе копирај () метода објекта листе или уграђена функција цопи.цопи . Међутим, то се може постићи резањем.
>>> 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 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 >>>
Белешка :Изјава дел брише на месту тј. , модификоваће изворни објекат листе, уместо да врати нови објекат листе.
# 2) Коришћење листе.ремове (к)
Уклања прву ставку са листе чија је вредност једнака Икс . Покреће ВалуеЕррор ако нема такве ставке.
Овај метод се углавном користи за уклањање ставки са листе по имену, за разлику од дел израза који користи индексирање и резање.
>>> 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) Коришћење лист.поп ([и])
Уклања и враћа ставку на задатој позицији у објекту листе. Ако није наведен и (индекс), уклања и враћа последњу ставку са листе.
Белешка :Углата заграда око и изнад не значи листу и, већ значи да је и необавезна.
>>> 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'] >>>
Белешка: Листа. поп ([и]) метода брише на месту тј. , модификоваће изворни објекат листе, уместо да врати нови објекат листе. Такође, враћа ставку уклоњену са листе
Замена предмета са листе
Замена предмета је прилично једноставна. У једном од горњих одељака видели смо индексирање и сечење. Они се могу користити за приступ и уклањање ставки са листе.
# 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
Белешка : Вредност треба да буде итерабле или иначе ТипеЕррор биће изузетак.
>>> 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) Шта је листа спискова у Питхону?
Одговор: Листа спискова у Питхону је листа која садржи листе као своју ставку.
На пример
[['a','b'],['c','d']]
Такође се може означити као а угнежђена листа .
П # 2) Како се декларише листа у Питхону?
Одговор: У Питхону се листа може декларисати на два начина. Било помоћу уграђене функције листа() или коришћењем заградног записа []. листа() узима итерабле и [] узима предмете било које врсте одвојене зарезом.
[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) Можете ли ставити листу у Питхон листу?
Одговор: Да, можемо ставити листу унутар листе. У ствари, листа је низ контејнера који узима ставке било ког типа података.
П # 4) Шта лист () ради у Питхону?
Одговор: листа ( ) је уграђена функција у Питхону која креира објекат листе. Као аргумент узима итерабле.
>>> list((3,2,4)) # The iterable object here is a tuple. [3, 2, 4] >>>
П # 5) Може ли Питхон листа садржати различите типове?
Одговор: Листа је низ контејнера који узима предмете било ког типа података ( листа , тупле , цео број , пловак , жице , итд.)
Више о листама у Питхону
Шта је структура података?
Рачунари се користе за складиштење огромног броја података или за обраду огромног броја података великом брзином и тачношћу. Стога је најбоље трајно чувати податке за брзи приступ.
Иако се обрада података дешава, требало би да се догоди у најкраћем могућем року без губитка тачности. Структуру података користимо за организовано бављење подацима и чување података у меморији ради обраде.
Како је Питхон програмски језик на високом нивоу и протумачен, веома је важно користити структуру података у Питхону.
Шта је Лист?
Листа је структура података која се користи за складиштење више података одједном.
Подаци ускладиштени на листи су хомогени и то је заузврат чини најмоћнијом карактеристиком листе у Питхону. На једну листу можемо похранити више података различитих типова података као што су Стринг, Интегерс и објекти.
Листа је променљива у Питхону, па се подаци могу мењати у било ком тренутку, чак и након креирања. Листе су врло моћне за примену стекова и редова у Питхону.
Као што је раније речено, листа складишти податке у уређеном низу, а подацима ускладиштеним на листи приступа се помоћу њиховог индекса, а за листу индекс ће увек почети од нуле. Сваки елемент има одређено место на листи и свим тим подацима се приступа помоћу индекса.
На листи можемо више пута чувати исту вредност и сваки податак ће се сматрати засебним и јединственим елементом. Листе је најбоље за складиштење података и њихово понављање касније.
Креирање листе
Подаци на листи чувају се одвојеним зарезом и затварају у угласту заграду ([]). Ставке на листи не морају бити исте врсте.
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 су типа Интегер, 6.7 је типа флоат, а „Хи“ је типа Стринг, све ове ставке су затворене у листу и то је чини Листом.
Можемо прогласити и празну листу. Такође можемо декларирати листу унутар друге листе и називамо је угнежђеном листом.
Пример 5:
List = [‘Hi’, [2, 4, 5], [‘Hello’]]
У горњем примеру можете приметити да је листа декларисана унутар друге листе.
Приступ вредностима на листи
Постоје различити начини путем којих можемо приступити ставкама присутним на листи у Питхону.
Уз помоћ индекса можемо приступити елементима листе. Индекс почиње од 0, а индекс увек треба да буде целобројни. Ако користимо индекс који није цео број попут флоат, то ће резултирати ТипеЕррор.
Пример 1:
List = [2, 5, 6.7, ‘Hi’] print(“List is:”, List)
Излаз:
Листа је: [2, 5, 6.7, „Здраво“]
Излаз:
која није једна од врста предмета која се тестира током тестирања система?
У горњем примеру, ми директно штампамо листу помоћу функције штампања, не приступамо појединачном елементу са листе.
Приступимо појединачном елементу са листе.
Пример: 2
List = [2, 5, 6.7, ‘Hi’] print(“Second element of the list is:”, List[1])
Излаз:
Други елемент листе је: 5
Излаз:
У горњем примеру можете приметити да штампамо други елемент листе који је 5, али можда ћете добити питање зашто у изјави за штампу штампамо Лист [1]? То је зато што индекс почиње од Нула, па се Листа [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])
Излаз:
Први елемент листе је: и
Елементи присутни на другој листи су: 5
Излаз:
У претходном програму, ако пажљиво посматрате, можете видети да приступамо елементима са угнежђене листе.
Подаци ће се интерно чувати у матричном формату као што је приказано доле:
Здраво
2 4 5
Дакле, када покушамо да приступимо Листу [0] [1], тада ће се указати на 1стред и 2ндступац, при чему ће подаци бити „и“.
Слично томе, када покушамо да приступимо Листу [1] [2], тада ће указати на 2ндред и 3рдколона, при чему ће подаци бити 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]
Излаз:
Такође можемо приступити елементима присутним на листи користећи петљу фор.
Пример: 2
List = [1, 2, 3, 4, 5, 6, 7] forele in List: print(ele)
Излаз:
1
два
3
4
5
6
7
Излаз:
Запамтите формат индексирања испод:
Х. | ИС | Л | Л | ИЛИ | 5 | 7 | 9 | 4 |
0 | 1 | два | 3 | 4 | 5 | 6 | 7 | 8 |
-9 | -8 | -7 | -6 | -5 | -4 | -3 | -два | -1 |
Као што је раније речено, Листа у питхону је променљива, што значи да се елементи могу мењати чак и ако је реч о целом броју или низу или било ком другом типу података.
Списак можемо ажурирати помоћу оператора доделе.
Пример: 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]
У горњем примеру ажурирамо листу података на листу.
Излаз:
Додавање елемената на листу
Постоји неколико начина на које можемо додати елементе на листу, а питхон има уграђену функцију која се назива аппенд ().
Коришћењем аппенд () можемо додати само један елемент на листу, ако желите да додате више елемената на листу онда морамо да користимо фор лооп . функција аппенд () увек додаје елемент на крају листе, функција аппенд () узима само један аргумент.
Ако желите да додате елементе на одређеној позицији, онда само треба да користите методу инсерт (). инсерт () узима два аргумента, тј. позиција и вредност, позиција се односи на индекс, где је потребно додати елементе, а вредност се односи на елемент који се додаје на листу.
Постоји још једна метода која се назива ектенсион (), помоћу које можемо додати елементе на листу. метода ектенсион () користи се за додавање листе елемената на листу. Слично методи аппенд () и ектенсион (), такође ће додати елементе на крају листе.
Пример: 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)
Излаз:
Листа пре додавања вредности је: [„Здраво“, „Добро јутро“]
Листа након додавања вредности је: [„Здраво“, „Добро јутро“, „Питхон“, „Здраво“]
У горњем примеру додајемо вредности „Питхон“ и „Хи“ на крај листе.
Излаз:
Пример: 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
Листа након додавања вредности је: [„Здраво“, „Добро јутро“, „Питхон“, „Здраво“]
Дужина листе након додавања је: 4
Дужину листе можемо пронаћи помоћу функције лен (), као што је приказано у горњем примеру.
Излаз:
Такође можемо додати више вредности на листу помоћу петље фор.
Пример: 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)
Излаз:
Лист1 након додавања Лист2 је: [„Здраво“, „Питхон“, [1, 5, 7, 2]]
Ако приметите у горњем примеру, када додамо Лист2 на Лист1, онда ће Лист1 постати угнежђена листа.
Излаз:
Ако не желите да направите листу као угнежђену листу након додавања листе, онда је боље користити методу ектенсион ().
Пример: 5
List1 = [“Hi”, “Python”] List2 = [1, 5, 7, 2] List1.extend(List2) print(“List1 after appending List2 is: “, List1)
Излаз:
Лист1 након додавања Лист2 је: [„Здраво“, „Питхон“, 1, 5, 7, 2]
Када користимо методу ектенсион (), елементи Лист1 биће проширени елементима Лист2. Имајте на уму да неће додати листу када користимо методу ектенсион ().
Излаз:
Када проширите листу низом, он ће додати сваки знак низа на листу, јер је низ могуће поновити.
Пример: 6
List = [1, 5, 7, 2] List.extend(“Python”) print(“List after extending the String is: “, List)
Излаз:
Листа након продужења низа је: [1, 5, 7, 2, „П“, „и“, „т“, „х“, „о“, „н“]
Излаз:
Листа аппенд () у односу на ектенсион ()
Погледајмо неке примере за ектенсион () и аппенд ().
Пример: 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, „Питхон“]
Листа након додавања листе је: [„Здраво“, 1, „Здраво“, 2, 5, „Питхон“, [„један“, „два“, 3]]
Лист1 након проширења Лист2 је: [„Здраво“, 1, „Здраво“, 2, 5, „Питхон“, [„један“, „два“, 3], „Аппле“, „Наранџаста“, 2, 8]
Излаз:
Пример: 2
List = [“Apple”, “Orange”, “Mango”, “Strawberry”] print(“List before inserting is: “, List) List.insert(2, “Watermelon”) print(“List after inserting is: “, List)
Излаз:
Листа пре уметања је: [„Јабука“, „Наранџа“, „Манго“, „Јагода“]
Листа након уметања је: [„Јабука“, „Наранџа“, „Лубеница“, „Манго“, „Јагода“]
Оутпут
Као што смо раније разговарали, метода инсерт () користи се за уметање вредности на одређени индекс листе.
Пример: 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]
Након поновног додавања истих елемената гласи: [„Хи“, „Хи“, „Хи“, „Хи“, „Хи“]
Излаз:
Брисање или уклањање елемената са листе
Такође можемо избрисати или уклонити елементе са листе помоћу израза дел и ремове ().
Да видимо у доњем примеру.
Пример: 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]
У горњем примеру можете приметити да смо користили дел наредбу за брисање елемента или више израза са листе.
Излаз:
Сада ћемо видети о методи ремове ().
Пример: 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]
У горњем примеру можете приметити да уклањамо елемент са листе методом ремове (). Метода поп () користи се за уклањање / брисање последњег елемента са листе.
Излаз:
Методе пописа
Методе | Опис |
---|---|
јасно() | Да бисте уклонили све елементе са листе. |
додати() | Да бисте додали елемент на крају листе. |
инсерт () | За уметање елемента у одређени индекс листе. |
проширити() | Да бисте додали листу елемената на крај листе. |
цоунт () | Да се врати број елемената са одређеном вредношћу. |
индекс () | Да се врати индекс првог елемента. |
обрнуто () | Да поништи постојећу листу. |
уклони () | Да бисте уклонили елементе са листе. |
Закључак
У овом упутству смо погледали неке карактеристике Питхон листа заједно са разним начинима манипулисања списком као што су стварање листе , приступ ставкама са листе , и замена предмета са списка.
Овај водич на Питхон листи може се закључити следећим Показатељима:
- Листа је један од типова података у Питхону, који се такође назива и структуром података.
- Листа се користи за складиштење великог броја вредности било којих типова података у једној променљивој, што заузврат помаже у лаком приступу.
- Индекс за листу увек почиње од нуле као и остали програмски језици.
- Ако радите на листи, морате запамтити све уобичајене уграђене функције те листе.
=> Посетите овде да бисте научили Питхон од нуле
Препоручено читање
- Питхон Водич за почетнике (Практични БЕСПЛАТНИ Питхон тренинг)
- Питхон променљиве
- Водич за напредне листе за Питхон (сортирање, преокретање, индексирање, копирање, придруживање, збир)
- Водич за Питхон Тупле са практичним примерима
- Питхон Стринг функције
- Листе у СТЛ
- Повезана структура података листе на Ц ++ са илустрацијом
- Структура података кружно повезане листе на Ц ++ са илустрацијом