5. Տվյալների կառուցվածքներ

Այս գլուխը ավելի մանրամասն նկարագրում է որոշ բաներ, որոնց մասին դուք արդեն սովորել եք, ինչպես նաև ավելացնում է որոշ նոր բաներ:

5.1: Ավելին Ցուցակների մասին

Ցանկի տվյալների տեսակն ունի ևս մի քանի մեթոդներ: Ահա օբյեկտների ցանկի բոլոր մեթոդները.

list.append(x)
Ցանկի վերջում ավելացրեք տարր: համարժեք է a[len(a):] = [x].
list.extend(կրկնող)
Ընդլայնեք ցանկը՝ ավելացնելով կրկնվողի բոլոր կետերը: համարժեք է a[len(a):] = iterable.
list.insert(ix)
Տեղադրեք առարկա տվյալ դիրքում: Առաջին արգումենտը տարրի ինդեքսն է, որի առաջ պետք է տեղադրվի, այսպես a.insert(0, x) ներդիրներ ցուցակի առջևում, և a.insert(len(a), x) համարժեք է a.append(x).
list.remove(x)
Ցանկից հեռացնել առաջին կետը, որի արժեքը հավասար է x. Այն բարձրացնում է ա ValueError եթե նման կետ չկա.
list.pop([i])
Հեռացրեք ապրանքը ցանկի տվյալ դիրքում և վերադարձրեք այն: Եթե ​​ինդեքս չի նշվում, a.pop() հեռացնում և վերադարձնում է ցանկի վերջին կետը: (Քառակուսի փակագծերը շուրջը i մեթոդի ստորագրության մեջ նշանակում է, որ պարամետրը կամընտիր է, այլ ոչ թե պետք է մուտքագրել քառակուսի փակագծեր այդ դիրքում: Դուք հաճախ կտեսնեք այս նշումը Python գրադարանի հղումում:)
list.clear()
Հեռացրեք բոլոր տարրերը ցանկից: համարժեք է del a[:].
list.index(x[Սկիզբ[վերջ]])
Վերադարձրեք զրոյական ինդեքսը առաջին կետի ցանկում, որի արժեքը հավասար է x. Բարձրացնում է ա ValueError եթե նման կետ չկա.

Ընտրովի փաստարկներ Սկիզբ և վերջ մեկնաբանվում են ինչպես հատվածի նշումով և օգտագործվում են որոնումը սահմանափակելու ցանկի որոշակի ենթահաջորդականությամբ: Վերադարձված ինդեքսը հաշվարկվում է ոչ թե ամբողջական հաջորդականության սկզբի համեմատ Սկիզբ փաստարկ:

list.count(x)
Վերադարձեք անգամների քանակը x հայտնվում է ցուցակում:
list.sort(*հիմնական=Ոչ մեկըհակադիրը=Կեղծ)
Տեսակավորեք ցուցակի տարրերը տեղում (արգումենտները կարող են օգտագործվել տեսակավորման հարմարեցման համար, տես sorted() նրանց բացատրության համար):
list.reverse()
Փոխեք ցուցակի տարրերը տեղում:
list.copy()
Վերադարձեք ցուցակի մակերեսային պատճենը: համարժեք է a[:].

Օրինակ, որն օգտագործում է ցուցակի մեթոդների մեծ մասը.

>>>

Դուք կարող եք նկատել, որ մեթոդները, ինչպիսիք են insertremove or sort որոնք միայն փոփոխում են ցուցակը, վերադարձի արժեք չունեն տպագրված. նրանք վերադարձնում են լռելյայն None1 Սա նախագծման սկզբունք է Python-ի բոլոր փոփոխական տվյալների կառուցվածքների համար:

Մեկ այլ բան, որ դուք կարող եք նկատել, այն է, որ ոչ բոլոր տվյալները կարող են տեսակավորվել կամ համեմատվել: Օրինակ, [None, 'hello', 10] չի դասավորում, քանի որ ամբողջ թվերը չեն կարող համեմատվել տողերի և Ոչ մեկը չի կարելի համեմատել այլ տեսակների հետ: Բացի այդ, կան որոշ տեսակներ, որոնք չունեն սահմանված պատվիրման հարաբերություն: Օրինակ, 3+4j < 5+7j վավեր համեմատություն չէ:

5.1.1: Ցուցակների օգտագործումը որպես կույտեր

Ցուցակի մեթոդները շատ հեշտ են դարձնում ցուցակի օգտագործումը որպես կույտ, որտեղ վերջին ավելացված տարրը վերբերված առաջին տարրն է («վերջին մուտք, առաջին դուրս»): Դույզի վերին մասում տարր ավելացնելու համար օգտագործեք append(). Տարրը բուրգի վերևից վերցնելու համար օգտագործեք pop() առանց հստակ ցուցանիշի: Օրինակ:

>>>

 

5.1.2: Ցուցակների օգտագործումը որպես հերթեր

Հնարավոր է նաև ցուցակ օգտագործել որպես հերթ, որտեղ առաջին ավելացված տարրը վերբերված առաջին տարրն է («առաջին մուտք, առաջին դուրս»); սակայն, ցուցակներն արդյունավետ չեն այս նպատակով: Թեև ցանկի վերջից հավելվածներն ու բացումները արագ են, ցուցակի սկզբից ներդիրները կամ ներդիրները դանդաղ են (քանի որ բոլոր մյուս տարրերը պետք է տեղափոխվեն մեկով):

Հերթ իրականացնելու համար օգտագործեք collections.deque որը նախատեսված էր երկու ծայրերից արագ հավելումներ և ցատկեր ունենալու համար: Օրինակ:

>>>

 

5.1.3: Ցուցակ ըմբռնումներ

Ցուցակների ըմբռնումը տալիս է ցուցակներ ստեղծելու հակիրճ ձև: Ընդհանուր կիրառություններն են՝ ստեղծելու նոր ցուցակներ, որտեղ յուրաքանչյուր տարր արդյունք է որոշակի գործողությունների, որոնք կիրառվել են մեկ այլ հաջորդականության կամ կրկնվողի յուրաքանչյուր անդամի վրա, կամ ստեղծել այդ տարրերի հաջորդականություն, որոնք բավարարում են որոշակի պայման:

Օրինակ, ենթադրենք, որ ցանկանում ենք ստեղծել քառակուսիների ցուցակ, ինչպես.

>>>

 

Նկատի ունեցեք, որ սա ստեղծում է (կամ վերագրում է) անունով փոփոխական x որը դեռ գոյություն ունի օղակի ավարտից հետո: Մենք կարող ենք հաշվարկել քառակուսիների ցանկը առանց կողմնակի ազդեցությունների՝ օգտագործելով.

կամ, համարժեքորեն.

որն ավելի հակիրճ է և ընթեռնելի։

Ցանկի ըմբռնումը բաղկացած է փակագծերից, որոնք պարունակում են արտահայտություն, որին հաջորդում է a for կետ, ապա զրո կամ ավելի for or if դրույթներ. Արդյունքը կլինի նոր ցուցակ, որն առաջանում է արտահայտության գնահատման արդյունքում for և if դրույթները, որոնք հաջորդում են դրան: Օրինակ, այս listcomp-ը միավորում է երկու ցուցակների տարրերը, եթե դրանք հավասար չեն.

>>>

և դա համարժեք է.

>>>

Ուշադրություն դարձրեք, թե ինչպես է կարգը for և if Այս երկու հատվածներում էլ հայտարարությունները նույնն են:

Եթե ​​արտահայտությունը կրկնակի է (օր (x, y) նախորդ օրինակում), այն պետք է փակագծված լինի:

Ցուցակի ըմբռնումները կարող են պարունակել բարդ արտահայտություններ և ներդիր ֆունկցիաներ.

>>>

5.1.4: Nested List Comprehensions

Ցուցակի ըմբռնման սկզբնական արտահայտությունը կարող է լինել ցանկացած կամայական արտահայտություն, ներառյալ մեկ այլ ցուցակի ընկալում:

Դիտարկենք 3×4 մատրիցայի հետևյալ օրինակը, որն իրականացվել է որպես 3 երկարությամբ 4 ցուցակների ցանկ.

>>>

Հետևյալ ցուցակի ըմբռնումը կփոխադրի տողեր և սյունակներ.

>>>

Ինչպես տեսանք նախորդ բաժնում, nested listcomp-ը գնահատվում է համատեքստում for որ հետևում է դրան, ուստի այս օրինակը համարժեք է.

>>>

որն իր հերթին նույնն է, ինչ.

>>>

Իրական աշխարհում դուք պետք է գերադասեք ներկառուցված գործառույթները բարդ հոսքի հայտարարություններից: Այն zip() գործառույթը հիանալի աշխատանք կկատարի այս օգտագործման դեպքում.

>>>

Տեսնել Փաստարկների ցուցակների բացում այս տողում նշված աստղանիշի մանրամասների համար:

5.2: The del հայտարարություն

Տարրը ցուցակից հեռացնելու միջոց կա՝ հաշվի առնելով դրա ինդեքսը դրա արժեքի փոխարեն del հայտարարություն. Սա տարբերվում է pop() մեթոդ, որը վերադարձնում է արժեք: Այն del հայտարարությունը կարող է օգտագործվել նաև ցուցակից հատվածները հեռացնելու կամ ամբողջ ցուցակը մաքրելու համար (ինչը մենք արել ենք ավելի վաղ՝ այդ հատվածին դատարկ ցուցակ հատկացնելով): Օրինակ:

>>>

del կարող է օգտագործվել նաև ամբողջ փոփոխականները ջնջելու համար.

>>>

Անվանումը հղում անելով a այսուհետ սխալ է (առնվազն այնքան ժամանակ, քանի դեռ դրան այլ արժեք չի հատկացվել): Մենք կգտնենք այլ կիրառումներ del ավելի ուշ:

5.3: Tuples և Sequences

Մենք տեսանք, որ ցուցակներն ու տողերն ունեն շատ ընդհանուր հատկություններ, ինչպիսիք են ինդեքսավորման և կտրման գործողությունները: Դրանք երկու օրինակ են հերթականություն տվյալների տեսակները (տես Հաջորդականության տեսակները — ցուցակ, բազմապատկած, տիրույթ): Քանի որ Python-ը զարգացող լեզու է, հաջորդականության տվյալների այլ տեսակներ կարող են ավելացվել: Կա նաև մեկ այլ ստանդարտ հաջորդականության տվյալների տեսակ՝ the շղարշ.

Թուպլիկը բաղկացած է մի շարք արժեքներից, որոնք բաժանված են ստորակետերով, օրինակ.

>>>

Ինչպես տեսնում եք, ելքային tuples-ները միշտ փակագծերում են փակագծերում, այնպես, որ տեղադրված tuples-ները ճիշտ են մեկնաբանվում. դրանք կարող են մուտքագրվել շրջապատող փակագծերով կամ առանց դրանց, թեև հաճախ փակագծերը, այնուամենայնիվ, անհրաժեշտ են (եթե կրկնապատիկը ավելի մեծ արտահայտության մաս է): Հնարավոր չէ վերագրել tuple-ի առանձին տարրերին, սակայն հնարավոր է ստեղծել tuples, որոնք պարունակում են փոփոխական օբյեկտներ, ինչպիսիք են ցուցակները:

Թեև զույգերը կարող են թվալ ցուցակների նման, դրանք հաճախ օգտագործվում են տարբեր իրավիճակներում և տարբեր նպատակների համար: Tuples են անփոփոխև սովորաբար պարունակում են տարրերի տարասեռ հաջորդականություն, որոնց հասանելի են դառնում ապափաթեթավորումը (տե՛ս այս բաժնում ավելի ուշ) կամ ինդեքսավորումը (կամ նույնիսկ հատկանիշի դեպքում՝ namedtuples): Ցուցակներն են փոփոխական, և դրանց տարրերը սովորաբար միատարր են և հասանելի են՝ ցուցակի վրայով կրկնելով:

Հատուկ խնդիր է 0 կամ 1 տարր պարունակող tuples-ների կառուցումը. շարահյուսությունն ունի որոշ լրացուցիչ տարօրինակություններ՝ դրանք տեղավորելու համար: Դատարկ զույգերը կառուցվում են դատարկ զույգ փակագծերով. մեկ տարրով բազմոցը կառուցվում է ստորակետով արժեքին հետևելով (փակագծերում մեկ արժեք փակցնելը բավարար չէ): Տգեղ, բայց արդյունավետ. Օրինակ:

>>>

Հայտարարությունը t = 12345, 54321, 'hello!' օրինակ է բազմակի փաթեթավորում: արժեքները 1234554321 և 'hello!' փաթեթավորված են միասին բազմակի մեջ: Հակադարձ գործողությունը նույնպես հնարավոր է.

>>>

Սա կոչվում է, համապատասխանաբար, հաջորդականության ապափաթեթավորում և աշխատում է աջ կողմի ցանկացած հաջորդականության համար: Հերթականության ապափաթեթավորումը պահանջում է, որ հավասարության նշանի ձախ կողմում այնքան փոփոխական լինի, որքան հաջորդականության մեջ կան տարրեր: Նկատի ունեցեք, որ բազմակի հանձնարարությունը իրականում ընդամենը բազմակի փաթեթավորման և հաջորդականության ապափաթեթավորման համադրություն է:

5.4: Կոմպլեկտներ

Python-ը ներառում է նաև տվյալների տեսակը սահմանում. Կոմպլեկտը չպատվիրված հավաքածու է՝ առանց կրկնօրինակ տարրերի: Հիմնական օգտագործումը ներառում է անդամակցության փորձարկումը և կրկնօրինակ գրառումների վերացումը: Սահմանված օբյեկտները նաև աջակցում են մաթեմատիկական գործողություններ, ինչպիսիք են միավորումը, խաչմերուկը, տարբերությունը և սիմետրիկ տարբերությունը:

Գանգուր բրեկետներ կամ set() ֆունկցիան կարող է օգտագործվել հավաքածուներ ստեղծելու համար: Նշում. դատարկ հավաքածու ստեղծելու համար դուք պետք է օգտագործեք set()Ոչ {}; վերջինս ստեղծում է դատարկ բառարան, տվյալների կառուցվածք, որը մենք կքննարկենք հաջորդ բաժնում:

Ահա մի կարճ ցուցադրություն.

>>>

Նմանապես թվարկել հասկացությունները, սահմանված ըմբռնումները նույնպես աջակցվում են.

>>>

5.5: Բառարաններ

Python-ում ներկառուցված մեկ այլ օգտակար տվյալների տեսակ է բառարան (Տես Քարտեզագրման տեսակները — թելադրանք): Երբեմն այլ լեզուներով բառարանները հանդիպում են որպես «ասոցիատիվ հիշողություններ» կամ «ասոցիատիվ զանգվածներ»: Ի տարբերություն հաջորդականությունների, որոնք ինդեքսավորվում են մի շարք թվերով, բառարանները ինդեքսավորվում են ստեղները, որը կարող է լինել ցանկացած անփոփոխ տեսակ; տողերը և թվերը միշտ կարող են բանալիներ լինել: Tuples-ը կարող է օգտագործվել որպես բանալիներ, եթե դրանք պարունակում են միայն տողեր, թվեր կամ tuples; եթե tuple-ը պարունակում է որևէ փոփոխական օբյեկտ՝ ուղղակիորեն կամ անուղղակիորեն, այն չի կարող օգտագործվել որպես բանալի: Դուք չեք կարող օգտագործել ցուցակները որպես բանալիներ, քանի որ ցուցակները կարող են փոփոխվել տեղում՝ օգտագործելով ինդեքսի հանձնարարությունները, հատվածների նշանակումները կամ այնպիսի մեթոդներ, ինչպիսիք են. append() և extend().

Լավագույնն այն է, որ բառարանը ընկալվի որպես մի շարք բանալին՝ արժեք զույգեր՝ ստեղների եզակի լինելու պահանջով (մեկ բառարանում)։ Զույգ փակագծերը ստեղծում են դատարկ բառարան. {}. Ստորակետերով բաժանված բանալին:արժեք զույգերի ցանկը փակագծերի մեջ դնելը բառարանին ավելացնում է սկզբնական key:value զույգեր; Այսպես են գրվում նաև բառարանները արդյունքի վրա:

Բառարանի վրա կատարվող հիմնական գործողություններն են՝ ինչ-որ բանալիով արժեք պահելը և բանալի տրված արժեքը հանելը: Հնարավոր է նաև ջնջել key:value զույգը del. Եթե ​​դուք պահում եք՝ օգտագործելով բանալի, որն արդեն օգտագործվում է, այդ բանալի հետ կապված հին արժեքը մոռացվում է: Գոյություն չունեցող բանալի օգտագործելով արժեք հանելը սխալ է:

Կատարողական list(d) բառարանի վրա վերադարձնում է բառարանում օգտագործված բոլոր ստեղների ցանկը՝ զետեղման կարգով (եթե ցանկանում եք, որ այն տեսակավորվի, պարզապես օգտագործեք sorted(d) փոխարենը): Ստուգելու համար, թե արդյոք մեկ բանալի կա բառարանում, օգտագործեք in բանալի բառ

Ահա մի փոքրիկ օրինակ՝ օգտագործելով բառարան.

>>>

The dict() կոնստրուկտորը կառուցում է բառարաններ անմիջապես բանալի-արժեք զույգերի հաջորդականություններից.

>>>

Բացի այդ, թելադրանքի ըմբռնումները կարող են օգտագործվել կամայական բանալի և արժեքային արտահայտություններից բառարաններ ստեղծելու համար.

>>>

Երբ ստեղները պարզ տողեր են, երբեմն ավելի հեշտ է զույգեր նշել՝ օգտագործելով հիմնաբառերի արգումենտները.

>>>

5.6: Looping տեխնիկա

Բառարանների միջով պտտվելիս բանալին և համապատասխան արժեքը կարող են միաժամանակ առբերվել՝ օգտագործելով items() մեթոդ է.

>>>

Հերթականության միջով պտտվելիս դիրքի ինդեքսը և համապատասխան արժեքը կարող են միաժամանակ վերցվել՝ օգտագործելով enumerate() գործառույթը:

>>>

Միաժամանակ երկու կամ ավելի հաջորդականությունների վրա պտտելու համար գրառումները կարող են զուգակցվել zip() գործառույթը:

>>>

Հերթականության վրա հակառակ ուղղությամբ պտտելու համար նախ նշեք հաջորդականությունը դեպի առաջ և այնուհետև զանգահարեք reversed() գործառույթը:

>>>

Տեսակավորված հերթականությամբ հաջորդականությունը պտտելու համար օգտագործեք sorted() ֆունկցիա, որը վերադարձնում է նոր տեսակավորված ցուցակ՝ աղբյուրը թողնելով անփոփոխ:

>>>

Օգտագործելով set() հաջորդականության վրա վերացնում է կրկնօրինակ տարրերը: -ի օգտագործումը sorted() հետ միասին set() հաջորդականության վրայով հաջորդականության եզակի տարրերը դասավորված հերթականությամբ շրջելու իդիոմատիկ միջոց է:

>>>

Երբեմն գայթակղիչ է լինում փոխել ցուցակը, մինչ դուք շրջում եք դրա վրա. սակայն, հաճախ ավելի պարզ և անվտանգ է փոխարենը նոր ցուցակ ստեղծելը:

>>>

5.7: Ավելին՝ Պայմանների մասին

Օգտագործված պայմանները while և if հայտարարությունները կարող են պարունակել ցանկացած օպերատոր, ոչ միայն համեմատություններ:

Համեմատության օպերատորներ in և not in անդամակցության թեստեր են, որոնք որոշում են՝ արդյոք արժեքը կոնտեյների մեջ է (թե ոչ): Օպերատորները is և is not համեմատեք, արդյոք երկու առարկաները իսկապես նույն առարկան են: Բոլոր համեմատական ​​օպերատորներն ունեն նույն առաջնահերթությունը, որն ավելի ցածր է, քան բոլոր թվային օպերատորները:

Համեմատությունները կարող են շղթայական լինել: Օրինակ, a < b == c թեստեր, թե արդյոք a պակաս է b և ավելին b հավասար է c.

Համեմատությունները կարող են համակցվել Բուլյան օպերատորների միջոցով and և or, և համեմատության (կամ որևէ այլ բուլյան արտահայտության) արդյունքը կարող է ժխտվել not. Սրանք ավելի ցածր առաջնահերթություններ ունեն, քան համեմատական ​​օպերատորները. նրանց միջեւ, not ունի ամենաբարձր առաջնահերթությունը և or ամենացածրը, այնպես որ A and not B or C համարժեք է (A and (not B)) or C. Ինչպես միշտ, փակագծերով կարելի է արտահայտել ցանկալի կազմը։

Բուլյան օպերատորներ and և or այսպես կոչված են կարճ միացում օպերատորներ. նրանց փաստարկները գնահատվում են ձախից աջ, և գնահատումը դադարում է արդյունքը որոշվելուն պես: Օրինակ, եթե A և C ճշմարիտ են, բայց B կեղծ է, A and B and C չի գնահատում արտահայտությունը C. Երբ օգտագործվում է որպես ընդհանուր արժեք և ոչ որպես բուլյան, կարճ միացման օպերատորի վերադարձի արժեքը վերջին գնահատված արգումենտն է:

Հնարավոր է համեմատության կամ այլ բուլյան արտահայտության արդյունք վերագրել փոփոխականին: Օրինակ,

>>>

Նկատի ունեցեք, որ Python-ում, ի տարբերություն C-ի, արտահայտությունների ներսում նշանակումը պետք է կատարվի բացահայտորեն ծովափի օպերատոր :=. Սա խուսափում է C ծրագրերում հանդիպող խնդիրների ընդհանուր դասից՝ մուտքագրում = արտահայտության մեջ, երբ == նախատեսված էր.

5.8: Հաջորդականությունների և այլ տեսակների համեմատություն

Հերթականության առարկաները սովորաբար կարելի է համեմատել նույն հաջորդականության տիպով այլ օբյեկտների հետ: Համեմատության օգտագործումը բառարանագրական Պատվիրել. նախ համեմատվում են առաջին երկու կետերը, և եթե դրանք տարբերվում են, դա որոշում է համեմատության արդյունքը. եթե դրանք հավասար են, ապա հաջորդ երկու կետերը համեմատվում են և այդպես շարունակ, մինչև որ հաջորդականությունը սպառվի: Եթե ​​համեմատվող երկու տարրերն իրենք նույն տիպի հաջորդականություններ են, բառարանագրական համեմատությունն իրականացվում է ռեկուրսիվ: Եթե ​​երկու հաջորդականության բոլոր տարրերը համեմատվում են հավասար, ապա հաջորդականությունները համարվում են հավասար: Եթե ​​մի հաջորդականությունը մյուսի սկզբնական ենթահաջորդականությունն է, ապա կարճ հաջորդականությունը փոքրն է (փոքրը): Տողերի բառարանագրական դասավորությունը օգտագործում է Unicode կոդը կետի համարը՝ առանձին նիշեր պատվիրելու համար: Նույն տիպի հաջորդականությունների համեմատության որոշ օրինակներ.

Նկատի ունեցեք, որ տարբեր տիպի օբյեկտների համեմատելով < or > օրինական է, պայմանով, որ օբյեկտներն ունենան համապատասխան համեմատական ​​մեթոդներ: Օրինակ, խառը թվային տիպերը համեմատվում են ըստ իրենց թվային արժեքի, ուստի 0-ը հավասար է 0.0-ի և այլն: Հակառակ դեպքում, կամայական դասավորություն տրամադրելու փոխարեն, թարգմանիչը կբարձրացնի TypeError բացառություն:

Հղումներ

1
Այլ լեզուները կարող են վերադարձնել մուտացված օբյեկտը, որը թույլ է տալիս շղթայել մեթոդները, ինչպես օրինակ d->insert("a")->remove("b")->sort();.
ArmenianEnglish