Գլուխ 7. String

Աշխատանք String-ի հետ

Տողը ներկայացնում է Յունիկոդի նիշերի հաջորդականությունը, որը փակցված է չակերտների մեջ: Ավելին, Python-ը թույլ է տալիս օգտագործել ինչպես միայնակ, այնպես էլ կրկնակի չակերտներ՝ տողերը սահմանելու համար.

message = "Hello World!" print(message) # Hello World! name = "Tom" print(name) # Tom

Եթե տողը երկար է, կարող եք այն բաժանել մասերի և տեղադրել դրանք կոդի տարբեր տողերի վրա: Այս դեպքում ամբողջ տողը փակվում է փակագծերում, իսկ դրա առանձին մասերը՝ չակերտների մեջ.

text = ("Laudate omnes gentes laudate " "Magnificat in secula ") print(text)

Եթե ցանկանում ենք սահմանել բազմագիծ տեքստ, ապա այդպիսի տեքստը կցվում է եռակի կրկնակի կամ մեկ չակերտների մեջ.

''' Это комментарий ''' text = '''Laudate omnes gentes laudate Magnificat in secula Et anima mea laudate Magnificat in secula ''' print(text)

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

Փախուստի հաջորդականությունները տողում

Տողը կարող է պարունակել մի շարք հատուկ նիշեր՝ վերահսկման հաջորդականություն կամ փախուստի հաջորդականություն: Դրանցից մի քանիսը.

\ : թույլ է տալիս շեղ ավելացնել տողի ներսում

\' : թույլ է տալիս ավելացնել մեկ մեջբերում տողի ներսում

" : թույլ է տալիս ավելացնել կրկնակի մեջբերում տողի ներսում


 ՝ ընդմիջում դեպի նոր տող

	 . ավելացնում է ներդիր (4 նահանջ)

Եկեք օգտագործենք մի քանի հաջորդականություն.

text = "Message:\n\"Hello World\"" print(text)

Թեև նման հաջորդականությունները կարող են օգնել մեզ որոշ հարցերում, օրինակ՝ տողի մեջ չակերտ դնելը, ներդիր պատրաստելը կամ այն մեկ այլ տողի վրա փաթաթելը։ Բայց նրանք կարող են նաև խոչընդոտել: Օրինակ:

path = "C:\python\name.txt" print(path)

Այստեղ ուղու փոփոխականը պարունակում է ֆայլի որոշ ճանապարհ: Այնուամենայնիվ, տողի ներսում կան «\n» նիշեր, որոնք կմեկնաբանվեն որպես փախուստի հաջորդականություն: Այսպիսով, մենք կստանանք հետևյալ վահանակի ելքը.

C:\python
ame.txt

Այս իրավիճակից խուսափելու համար r նիշը դրվում է տողից առաջ

path = r"C:\python\name.txt" print(path)

Արժեքների տեղադրում տողի մեջ

Python-ը թույլ է տալիս ներդնել այլ փոփոխականների արժեքները տողի մեջ: Դա անելու համար տողի ներսում փոփոխականները տեղադրվում են գանգուր փակագծերում {}, իսկ f նշանը դրվում է ամբողջ տողի առաջ.

userName = "Tom" userAge = 37 user = f"name: {userName} age: {userAge}" print(user) # name: Tom age: 37

Այս դեպքում {userName}userName փոփոխականի արժեքը կտեղադրվի տեղում: Նմանապես, փոխարենը կտեղադրվի userAge փոփոխականի արժեքը {userAge}:

Տողային նիշերի մուտք

Եվ մենք կարող ենք մուտք գործել տողի առանձին նիշեր՝ ըստ ինդեքսի, քառակուսի փակագծերում.

string = "hello world" c0 = string[0] # h print(c0) c6 = string[6] # w print(c6) c11 = string[11] # error IndexError: string index out of range print(c11)

Ինդեքսավորումը սկսվում է զրոյից, ուստի տողի առաջին նիշը կունենա ինդեքս 0: Եվ եթե մենք փորձենք մուտք գործել ինդեքս, որը տողի մեջ չէ, մենք կստանանք IndexError բացառություն: Օրինակ, վերը նշված դեպքում տողը 11 նիշ է, ուստի նրա նիշերը կունենան 0-ից 10 ինդեքսներ:

Տողի վերջից սկսած նիշերին մուտք գործելու համար կարող եք օգտագործել բացասական ինդեքսներ։ Այսպիսով, -1 ինդեքսը կներկայացնի վերջին նիշը, իսկ -2-ը կներկայացնի երկրորդից վերջին նիշը և այսպես շարունակ.

string = "hello world" c1 = string[-1] # d print(c1) c5 = string[-5] # w print(c5)

Նիշերի հետ աշխատելիս նկատի ունեցեք, որ տողը անփոփոխ տիպ է, հետևաբար, եթե փորձենք փոխել տողի որևէ առանձին նիշ, կստանանք սխալ, ինչպես հետևյալ դեպքում.

string = "hello world" string[1] = "R"

Մենք կարող ենք միայն ամբողջությամբ վերականգնել տողի արժեքը՝ նրան այլ արժեք վերագրելով:

Կրկնել տողի վրա

Դուք կարող եք օգտագործել for loop ՝ տողի բոլոր նիշերի վրա կրկնելու համար.

string = "hello world" for char in string: print(char)

Ստանալով ենթատող

Անհրաժեշտության դեպքում տողից կարող ենք ստանալ ոչ միայն առանձին նիշեր, այլև ենթատող։ Դրա համար օգտագործվում է հետևյալ շարահյուսությունը.

string[:end]հանում է նիշերի հաջորդականությունը՝ սկսած 0-ից մինչև ինդեքսի վերջը (ներառյալ)

string[start:end]: հանում է նիշերի հաջորդականությունը ինդեքսի սկզբից մինչև ինդեքսի վերջ (ներառյալ)

string[start:end:step]: քաղում է նիշերի հաջորդականությունը սկզբի ինդեքսից մինչև վերջի ինդեքսը (չներառյալ) քայլ քայլի միջոցով

Ենթատող ստանալու համար մենք օգտագործում ենք բոլոր տարբերակները՝

string = "hello world" sub_string1 = string[:5] print(sub_string1) # hello sub_string2 = string[2:5] print(sub_string2) # llo sub_string3 = string[2:9:2] print(sub_string3) # lowr

Միացվող տողեր

Լարերի հետ ամենատարածված գործողություններից մեկը դրանց միացումն է կամ միացումը: Տողերը միավորելու համար օգտագործվում է գումարման գործողությունը.

name = "Tom" surname = "Smith" fullname = name + " " + surname print(fullname) # Tom Smith

Երկու տողերի միացումը հեշտ է, բայց ի՞նչ, եթե մեզ անհրաժեշտ լինի տող և թիվ ավելացնել: Այս դեպքում, դուք պետք է համարը փոխանցեք տողի վրա՝ օգտագործելով str() ֆունկցիան.

name = "Tom" age = 33 info = "Name: " + name + " Age: " + str(age) print(info) # Name: Tom Age: 33

Գծի կրկնություն

Տողը որոշակի քանակությամբ անգամ կրկնելու համար օգտագործեք բազմապատկման գործողությունը.

print("a" * 3) # aaa print("he" * 4) # hehehehe

Լարերի համեմատություն

Հատուկ նշվել է String-ի համեմատությունների մասին։ Համեմատությունները կատարվում են բառարանագրական կարգով։ Տողերը համեմատելիս հաշվի են առնվում նիշերը և դրանց գործը: Այսպիսով, թվային նիշը պայմանականորեն փոքր է ցանկացած այբբենական նիշից: Մեծատառ այբբենական նիշը պայմանականորեն ավելի փոքր է, քան փոքրատառ այբբենական նիշերը: Օրինակ:

str1 = "1a" str2 = "aa" str3 = "Aa" print(str1 > str2) # False print(str2 > str3) # True

Հետեւաբար, «1a» տողը պայմանականորեն փոքր է «aa» տողից։ Նախ, համեմատությունը հիմնված է առաջին նիշի վրա: Եթե երկու տողերի առաջատար նիշերը թվանշաններ են ներկայացնում, ապա փոքր թվանշանը համարվում է ավելի փոքր, օրինակ՝ «1a»-ն փոքր է «2a»-ից։

Եթե առաջատար նիշերը ներկայացնում են այբբենական նիշերը նույն դեպքում, ապա նայեք այբբենական կարգով: Այսպիսով, «aa»-ն փոքր է «ba»-ից, իսկ «ba»-ն փոքր է «ca»-ից:

Եթե առաջին նիշերը նույնն են, ապա երկրորդ նիշերը հաշվի են առնվում, եթե դրանք կան:

Գործի զգայունությունը միշտ չէ, որ ցանկալի է, քանի որ, ըստ էության, գործ ունենք միանման լարերի հետ։ Այս դեպքում մենք կարող ենք երկու տողերն էլ փոխանցել գրանցամատյաններից մեկին համեմատելուց առաջ:

Low() ֆունկցիան տողը վերածում է փոքրատառի, իսկ վերին() ֆունկցիան ՝ տողը մեծատառի։

str1 = "Tom" str2 = "tom" print(str1 == str2) # False print(str1.lower() == str2.lower()) # True

Գործառույթները ord և len

Քանի որ տողը պարունակում է Յունիկոդ նիշեր, մենք կարող ենք օգտագործել ord() ֆունկցիան՝ Յունիկոդի կոդավորման մեջ նիշի թվային արժեքը ստանալու համար.

print(ord("A")) # 65

Լարի երկարությունը ստանալու համար կարող եք օգտագործել len() ֆունկցիան.

string = "hello world" length = len(string) print(length) # 11

Որոնել տողի մեջ

Օգտագործելով արտահայտությունը, term in string դուք կարող եք գտնել ենթատողի տերմինը տողի տողում: Եթե ենթատողը գտնվի, ապա արտահայտությունը կվերադարձնի արժեքը True, հակառակ դեպքում արժեքը կվերադարձվի False.

text = "hello world" exist = "hello" in text print(exist) # True exist = "sword" in text print(exist) # False

Համապատասխանաբար, օգտագործելով not in օպերատորները, կարող եք ստուգել տողի մեջ ենթալարի բացակայությունը.

text = "hello world" print("hello" not in text) # False print("sword" not in text) # True