Phenquestions
Virkne ir viens no populārākajiem python datu tipiem. Jebkura teksta datu glabāšanai mēs varam izmantot virknes datu tipu. Pitonā jebkura rakstzīme ar vienreizējām vai dubultām pēdiņām tiek uzskatīta par virknēm. Šīs rakstzīmes var būt jebkuras no Unicode rakstzīmēm, kuras atbalsta pitonā. Šajā apmācībā mēs uzzināsim gandrīz visu par virknes datu tipu pitonā.
Lai sekotu šai apmācībai, ieteicams savā sistēmā instalēt jaunāko python versiju. Ja jūsu sistēmā ir instalēta vecāka pitona versija, varat sekot mūsu ceļvedim par pitona atjaunināšanu Linux.
Virkņu izveide Python
Lai izveidotu virkni pitonā, mums ir jāievieto rakstzīmju masīva apakškvotas. Python gan vienoto, gan dubultās pēdiņas apstrādā kā vienādas, tāpēc, veidojot virkni, mēs varam izmantot jebkuru no tām. Skatiet tālāk minētos piemērus, kur mēs izveidojam virkni, glabājam tos mainīgajos un pēc tam izdrukājam.
# virknes izveide
sveiciens = "Sveika pasaule"
# virknes drukāšana
izdrukāt (sveiciens)
Palaižot iepriekš minēto kodu, jūs iegūsiet izvadi Sveika pasaule.
Šajā kodā mēs esam izveidojuši virkni Sveika pasauleun saglabāja to mainīgajā nosaukumā sveiciens. Tad mēs izmantojam Python drukas funkciju, lai parādītu mainīgajā saglabāto virkni. Palaižot kodu, jūs iegūsiet šādu izvadi. Mēs varam arī izveidot daudzrindu virkni, izmantojot trīskārtīgas pēdiņas zemāk esošajā koda piemērā.
var = "" "Lorem ipsum dolor sit amet,
consectetur adipiscing elit,
sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua."" "
drukāt (var)
Šeit ir izeja.
Programmā Python virknes ir baitu masīvi, kas attēlo Unicode rakstzīmes. Bet tam nav iebūvēta datu veida atsevišķām rakstzīmēm, piemēram, C vai C++. Jebkura virkne, kuras garums ir viens, tiek uzskatīta par rakstzīmi.
Stīgu garums
Daudzās situācijās mums var būt nepieciešams aprēķināt virknes garumu. Ir iebūvēta funkcija, kas var aprēķināt virknes garumu. Funkcija, kuru mēs izmantosim, ir len () funkciju.
Lai redzētu praktisku piemēru len () funkciju, palaidiet šo kodu savā Python IDE.
var = "Šī ir virkne"
print ("Virknes garums ir:", len (var))
Izeja:
Mēs varam arī izmantot pitonu ciklam, kuru es apspriedu šajā apmācībā, lai aprēķinātu virknes garumu.
Piemērs:
var = "Šī ir virkne"
skaits = 0
priekš i var:
skaits = skaitīt + 1
print ("Virknes garums ir:", skaits)
Izeja:
Stīgu savienošana
Stīgu savienošana ir divu virkņu apvienošana vai apvienošana. Izmantojot operatoru +, mēs varam viegli pievienoties divām virknēm. Apskatīsim divu virkņu savienošanas piemēru pitonā.
# izveido divas virknes
string1 = "Labdien"
string2 = "Pasaule"
# apvienojot abas virknes
sveiciens = virkne1 + virkne2
izdrukāt (sveiciens)
Iepriekš minētajā kodā mēs esam izveidojuši divas virknes, proti, “Labdien” un “Pasaule”, un glabājam tās divos mainīgajos ar nosaukumu virkne1 un virkne2. Tad mēs izmantojām operatoru +, lai savienotu abas virknes un saglabātu tās mainīgajā ar nosaukumu sveiciens un parādītu to, izmantojot izdrukāt () funkciju.
Izeja:
Stīgu atkārtošana
Mēs varam atkārtot virkni vairākas reizes pitonā, izmantojot operatoru *. Piemēram, lai divas reizes drukātu virkni “Fosslinux”, mums jāuzraksta šāds kods.
drukāt ("Fosslinux" * 2) Izeja:
Virkņu formatēšana
Veidlapu formatēšana Python ir bez piepūles. Ir trīs veidi:
1. Vecais formatēšanas stils
Vecais stīgu formatēšanas stils tiek veikts, izmantojot operatoru%. Mums jāizmanto īpaši simboli, piemēram, “% s”, “% d”, “% f”, “%.f ”. ar virkni un pēc tam norādiet datu kopu, kuru vēlamies formatēt šajā vietā. Apskatīsim, kādi ir dati, kurus pieņem iepriekš minētie simboli.
- % s: Tas pieņem virknes vai citus datus ar virkņu attēlojumu, piemēram, skaitļiem.
- % d:To izmanto, lai veselu skaitļu datus norādītu virknē.
- % f:To lieto peldošā komata skaitļiem.
- %.f: To lieto ar fiksētu precizitāti peldošā komata skaitļiem.
Piemēram, skatiet zemāk esošo kodu. Jūs varat kopēt un palaist kodu savā iecienītajā pitona IDE.
string1 = "Tā ir formatēta virkne ar veselu skaitli% d"% (1)
string2 = "Tā ir formatēta virkne ar virkni% s"% ("Fosslinux")
string3 = "Tā ir formatēta virkne ar pludiņa datiem% f"% (1.01)
drukāt (string1)
drukāt (string2)
drukāt (string3)
Izeja:
Kā redzam izvadē, virknes esam formatējuši ar vesela skaitļa, pludiņa un virknes datiem. Šī virkņu formatēšanas metode ir vecākais veids, taču mūsdienās tā tiek izmantota mazāk.
2. Izmantojot formātu () metodi
Šī ir jauna virkņu formatēšanas tehnika, kas ieviesta Python 3. Funkcijas format () datus uztver kā argumentu un aizstāj tos virknē, kur vietturis ir klāt.
Piemērs:
string1 = "Tā ir formatēta virkne ar veselu skaitli ".formāts (1)
string2 = "Tā ir formatēta virkne ar virkni ".formāts ("Fosslinux")
string3 = "Tā ir formatēta virkne ar pludiņa datiem ".formāts (1.01)
drukāt (string1)
drukāt (string2)
drukāt (string3)
print (" ir lieliska vietne, kur mācīties un ".formāts ("FossLinux", "Linux", "Python"))
Formatētā virkne tiks iegūta kā izeja, darbinot iepriekš minēto kodu, kā parādīts zemāk esošajā attēlā.
3. f-stīgas
Jaunākā virkņu formatēšanas tehnika ir virkņu interpolācija vai f-virknes, kas ieviestas python 3. versijā.6. Mēs varam norādīt mainīgā nosaukumu tieši f-virknē, un Python tulks aizstās mainīgā nosaukumu ar tam atbilstošo datu vērtību. F-virknes sākas ar burtu f, un mēs varam tieši ievadīt datus to attiecīgajās pozīcijās. Šī virkņu formatēšanas tehnika pēdējās dienās ir kļuvusi diezgan populāra. Lai skatītu tā darba demonstrāciju, nokopējiet zemāk esošo kodu un palaidiet to savā python IDE.
string1 = f "Tā ir formatēta virkne ar veselu skaitli 1"
string2 = f "Tā ir formatēta virkne ar virkni 'fosslinux'"
string3 = f "Tā ir formatēta virkne ar pludiņa datiem 0.01 "
drukāt (string1)
drukāt (string2)
drukāt (string3)
a = "Fosslinux"
b = "Linux"
c = "Python"
drukāt (f "a ir lieliska vietne b un c" apgūšanai)
Mēs izmantojām virkņu interpolācijas metodi virkņu formatēšanai iepriekš minētajā kodā. Stīgas, kas sāktas ar f rakstzīmi, ir f-virknes. F-virkne ir padarījusi mūsu darbu vienkāršu, un mēs varam rakstīt mainīgos tieši virknēs, norādot mainīgos zem vietturis. Palaižot iepriekš minēto kodu, mēs iegūsim šādu izvadi.
Pārbaudiet apakšsadaļu
Bieži vien mēs varam vēlēties pārbaudīt rakstzīmes esamību vai apakšvirkni virknē. To var izdarīt, izmantojot iekšā un nav iekšā Python atslēgvārdi. Piemēram, lai pārbaudītu, vai Sveiki ir virknē Sveika pasaule, mums ir jāpalaiž šāds kods.
x = "sveiki" "sveiki pasaulē"
drukāt (x)
Palaižot iepriekš minēto kodu pitona IDE, mēs iegūsim būla vērtību Patiesi kā izvadi, kas nozīmē, ka apakšsadaļa “sveiki” ir “sveiki pasaulē”.
Ļaujiet redzēt citu demonstrāciju, lai uzzinātu, kā tā darbojas labāk.
string = "FossLinux ir lieliska vietne, lai iemācītos Linux un Python"
drukāt ("Fosslinux" virknē)
drukāt ("FossLinux" virknē)
drukāt ("Foss" virknē)
drukāt ("Pyt" virknē)
drukāt ("hon" virknē)
drukāt ("Python" nav virknē)
Izeja:
Iepriekš minētajā kodā mēs izmantojām abus iekšā un nav iekšā atslēgvārdi, lai pārbaudītu apakšvirkni vecāku virknē.
Virkne kā rakstzīmju secība
Pitona virkne ir rakstzīmju secība; tie ir gandrīz līdzīgi citām Python pasūtītajām sekvencēm, piemēram, saraksts, kopa utt. Mēs varam dažādos veidos izvilkt atsevišķas rakstzīmes no virknēm, piemēram, izpakot tās, izmantojot mainīgos un indeksējot, ko es apspriedīšu nākamajā tēmā. Mēs varam izsaiņot virknes, piešķirot tās mainīgajiem. Lai redzētu, kā tas darbojas, vienkārši nokopējiet un palaidiet šo kodu iecienītākajā python IDE.
valoda = 'Fosslinux'
# virknes izpakošana mainīgajos
a, b, c, d, e, f, g, h, i = valoda
druka (a)
drukāt (b)
druka (c)
drukāt (d)
drukāt (e)
druka (f)
druka (g)
druka (h)
drukāt (i)
Izeja:
Indeksēšanas virknes
Stīgu indeksēšana ir fundamentāla un populāra tehnika, ar kuras palīdzību mēs varam viegli piekļūt virknes raksturam un veikt daudzas virkņu darbības. Programmēšanā skaitīšana sākas ar nulli (0), tāpēc, lai iegūtu virknes pirmo rakstzīmi, indeksā mums jānorāda nulle. Lai skatītu praktisku indeksēšanas piemēru, kopējiet un palaidiet šo kodu Python IDE.
string = "Fosslinux"
drukāt (virkne [0])
drukāt (virkne [1])
drukāt (virkne [2])
drukāt (virkne [3])
Iepriekš minētajā kodā vispirms izveidojam virkni ar nosaukumu Fosslinux, un pēc tam mēs izmantojam pitona virknes indeksēšanu, lai iegūtu virknes pirmo, otro, trešo un ceturto rakstzīmi. Palaižot kodu, terminālā mēs iegūsim šādu izvadi.
Python atbalsta arī negatīvu indeksēšanu, kas ir ļoti noderīgi, ja mēs varam sākt skaitīšanu no labās puses. Piemēram, lai iegūtu virknes “Fosslinux” otro pēdējo rakstzīmi, mums jāuzraksta zemāk redzamais kods.
string = "Fosslinux"
print ("Virknes otrais pēdējais termins ir:", virkne [-2])
Palaižot kodu, mēs iegūsim virknes “Fosslinux” otro pēdējo terminu, kā parādīts zemāk esošajā attēlā.
Saņemot virknes pēdējo terminu
Dažreiz mēs varam vēlēties iegūt virknes pēdējo terminu. Mums ir divi veidi, kā to izdarīt: pirmais izmanto negatīvo indeksēšanu, bet otrais - funkciju len () ar indeksēšanu.
Lai iegūtu virknes pēdējo terminu, izmantojot negatīvo indeksēšanu, skatiet zemāk esošo kodu.
string = "Fosslinux"
print ("Virknes pēdējais termins ir:", virkne [-1])
Izeja:
Lai iegūtu pēdējo vārdu, mēs varam izmantot arī funkciju len () ar indeksēšanu. Lai to izdarītu, mums jāaprēķina virknes garums, un pēc tam jāatrod raksturs, indeksējot vērtību, kas ir par vienu mazāka par virknes garumu. Skatiet zemāk redzamo piemēru.
string = "Fosslinux"
garums = len (virkne)
last_index = garums-1
print ("Virknes pēdējais termins ir:", virkne [last_index])
Iepriekš minētajā kodā mēs vispirms izveidojām virkni un saglabājām to mainīgajā nosaukumā virkne. Pēc tam mēs aprēķinām virknes garumu, izmantojot len () metodi. Tā kā indeksēšana pitonā sākas ar nulli, mums no garuma jāatņem viens. Tad mēs to nododam kā indeksu virkne. Tādējādi mēs iegūstam virknes pēdējo rakstzīmi.
Izeja:
Stīgu sagriešana
Python mums ir lieliska tehnika, paplašināta indeksēšanas forma, kas pazīstama kā virknes sagriešana. To var izmantot, lai virkni sagrieztu apakšstruktūrā. Lai veiktu sagriešanu, mums ir jānorāda virknes indeksa apakšraksta pirmās un pēdējās rakstzīmes indeksa numurs, to vidū ievietojot semikolu. Praktisku demonstrāciju skatiet zemāk redzamajā koda piemērā.
string = "Fosslinux"
drukāt (virkne [1: 6])
drukāt (virkne [0: 4])
Izeja:
Izlaižot rakstzīmes par sagriešanu
Mēs varam arī izlaist rakstzīmes, sagriežot virkni. Virknes sagriešanas laikā mums ir šāda sintakse.
virkne [sākums: stop: solis]
Sākums un beigas ir noklusējuma indeksa numuri, kurus līdz šim izmantojām iepriekš minētajā sintaksē. Step parametrs pieņem veselu skaitli, ko izmanto, lai norādītu katrā rakstā atstājamo rakstzīmju skaitu.
Atpakaļgaitas stīgas
Mēs varam viegli mainīt virkni, izmantojot sagriešanas metodi. Piemēram, skatiet zemāk esošo kodu. Kopējiet zemāk esošo kodu savā Python IDE un palaidiet to.
string = "Fosslinux"
print ("Reverse string of", string, "is", string [:: - 1])
Šis kods mainīs virkni “Fosslinux.Palaižot kodu, mēs iegūsim šādu izvadi.
Bēgšanas raksturs virknēs
Escape rakstzīmes programmēšanā ir lielisks veids, kā virknēs pievienot neizdrukājamas rakstzīmes. Piemēram, lai virknēs pievienotu jauno līnijas rakstzīmi, mēs izmantojam evakuācijas rakstzīmi “\ n”. Skatiet zemāk redzamo demonstrācijas kodu.
drukāt ("\ n \ n \ n Sveiki \ n \ n Pasaule") Palaižot kodu, mēs iegūsim šādu izvadi.
Kā redzam kodā, “\ n” vietā automātiski tiek pievienotas jaunas rindas. Tieši šeit parādās bēgšanas secība. Pitonā ir daudz secības rakstzīmju. Es tos visus šeit uzskaitīšu; jūs varat izmēģināt tos visus, lai redzētu, kā katrs darbojas.
- \ ': To lieto, lai virknē sniegtu vienu citātu. Tāpat kā dažās vietās, mēs nevaram tieši sniegt atsevišķas pēdiņas.
- \\: Šis simbols tiek izmantots, lai attēlotu slīpsvītru, jo daudzviet mēs nevaram izmantot \ tieši.
- \ n: Šis raksturs apzīmē jauno līnijas rakstzīmi, kas pievienos jaunu līniju.
- \ r: apzīmē pārvadājuma atgriešanos.
- \ t: apzīmē cilni.
- \ b: apzīmē atpakaļatkāpes rakstzīmi.
- \ f: Šī aizbēgšanas secība tiek izmantota, lai attēlotu veidlapas padevi.
- \ ooo: Šis simbols tiek izmantots, lai attēlotu oktālo vērtību.
- \ xhh: Šis simbols tiek izmantots, lai attēlotu heksadecimālo vērtību.
- \ a: Šis raksturs tiek izmantots, lai brīdinātu.
- \ s: Šis raksturs tiek izmantots, lai piešķirtu vietu.
- \ v: apzīmē vertikālu cilni.
Stīgu metodes
Mēs esam iemācījušies daudzas lietas par pitona virknēm, taču šī daļa ir daudz noderīgāka nekā jebkura cita šī raksta daļa. Python nāk ar lielu skaitu iebūvētu funkciju darbam ar virknēm. Izmantojot tos, mēs varam viegli veikt daudzas operācijas ar stīgām.
Stīgu lietu pārveidošana
Mums ir dažas iebūvētas funkcijas, kuras var izmantot virkņu lietu pārveidošanai. Ļaujiet mums tos visus apspriest.
virkne.izmantot lielo burtu ()
Šo metodi izmanto, lai kapitalizētu mērķa virkni. Kad mēs izmantojam metodi kā virkne.rakstīt ar lielajiem burtiem, tas atgriezīs virkni ar lielo burtu, t.i.e., pārveidojot pirmo rakstzīmi par lielajiem un visas pārējās rakstzīmes par mazajiem burtiem. Lai skatītu tā darba kopijas praktisko demonstrāciju un palaistu šo kodu savā Python IDE.
string = "fosslinux"Mēs izmantojām izmantot lielo burtu () String objekta metode, to lietojot ar lielo burtu. Palaižot kodu, mēs iegūsim šādu izvadi.
drukāt (virkne.rakstīt ar lielajiem burtiem ())
.augšējais ()
Šo metodi izmanto, lai virkni pārveidotu par lielajiem burtiem, t.i.e., ar lielajiem burtiem raksturo visas virknē esošās rakstzīmes.
Piemērs:
string = "Fosslinux"
drukāt (virkne.augšējais ())
Izeja:
virkne.zemāks ()
Šo metodi izmanto, lai virkni pārveidotu par mazajiem burtiem, t.i.e., maina visas virknē esošās rakstzīmes uz mazajiem burtiem.
Piemērs:
string = "FOSSLinux"
drukāt (virkne.zemāks ())
Izeja:
virkne.maiņas kaste ()
Šī ir lieliska metode, kā nomainīt virknes rakstzīmju lietu. Tas pārveido mazos burtus par lielajiem un otrādi. Lai redzētu tā darbību, vienkārši nokopējiet un palaidiet šo kodu.
string = "FOSSlinux"
drukāt (virkne.maiņas kaste ())
Izeja:
virkne.nosaukums ()
Arī šī ir lieliska virknes manipulācijas metode, jo tā pārveido katra virknē esošā vārda pirmo rakstzīmi lielajiem burtiem.
Piemērs:
string = "Fosslinux ir lielisks"
drukāt (virkne.nosaukums ()
Izeja:
Jūs, iespējams, pamanījāt atšķirību starp izmantot lielo burtu () un nosaukums () metodi. The izmantot lielo burtu () metode tikai ar lielo burtu raksta virknes pirmā vārda pirmo rakstzīmi, bet nosaukums () metodi ar lielo burtu raksturo katra virknē esošā vārda pirmā rakstzīme.
Rakstzīmju klasifikācija
Mums ir arī metodes, lai pārbaudītu virknes reģistru, neatkarīgi no tā, vai tie ir lielie, mazie utt. Ļaujiet mums tos īsumā apspriest ar piemēriem.
virkne.isalnum ()
Šo metodi izmanto, lai pārbaudītu, vai virkne satur tikai burtciparu skaitļus, vai ne.e., visām tā rakstzīmēm jābūt cipariem vai alfabētiem, bet ne citām rakstzīmēm, ieskaitot atstarpi.
Piemērs:
string1 = "Fosslinux123"
string2 = "Fosslinux ir lielisks"
string3 = "Fosslinux @ # 123"
drukāt (virkne1.isalnum ()) # satur tikai alfabētu un ciparus
drukāt (virkne2.isalnum ()) # satur atstarpi
drukāt (string3.isalnum ()) # satur īpašas rakstzīmes
Izeja:
virkne.isalpha ()
Šī virkņu metode ir līdzīga iepriekš aprakstītajai metodei, taču tā pārbauda tikai alfabētus, nevis ciparus i virkni, kas nozīmē, ka virknē ir jābūt tikai alfabētiem. Piemēram, palaidiet šo kodu.
string1 = "Fosslinux123"
string2 = "Fosslinux"
drukāt (virkne1.isalpha ()) # satur alfabētu un ciparus
drukāt (virkne2.isalpha ()) # satur tikai alfabētu
Par pirmo mēs saņemsim False, jo tajā ir skaitļi, un nākamajam mēs iegūstam True, jo tajā ir tikai alfabēti.
Izeja:
virkne.isdigit ()
Šī metode ir līdzīga iepriekšējai, taču alfabētu vietā tā pārbauda, vai virkne sastāv tikai no cipariem. Tas atgriež vērtību True, ja katrs rakstzīme, kas atrodas virknē, ir cipari; else atgriež False.
virkne.identifikators ()
Šī ir arī lieliska pitona virkņu metode. Izmantojot šo metodi, mēs varam pārbaudīt, vai virkne ir derīgs pitona identifikators. Esmu apspriedis derīga pitona identifikatora izvēles noteikumus pitona apmācības pamatos.
Piemērs:
string1 = "Fosslinux123"
string2 = "123Fosslinux"
string3 = "_Fosslinux"
string4 = "Fosslinux @ 1234"
drukāt (virkne1.isidentifier ()) # True
drukāt (virkne2.isidentifier ()) # False (sākts ar skaitļiem)
drukāt (string3.isidentifier ()) # True
drukāt (string4.isidentifier ()) # False (satur īpašas rakstzīmes @)
Izeja:
virkne.islower ()
Šī virknes metode pārbauda, vai visas virknes rakstzīmes ir mazās. Ja jā, tas atgriež Patiesais cits atgriež False.
virkne.isupper ()
Šī virknes metode pārbauda, vai visas virknē esošās rakstzīmes ir ar lielajiem burtiem. Ja jā, tad tā atgriež Patiesais cits atgriež False.
virkne.istitle ()
The istitle () virknes metode atgriezīsies True, ja visu virknē esošo vārdu pirmais alfabēts ir lielais un visas pārējās rakstzīmes ir mazie.
virkne.nav izdrukājams ()
Tas atgriež vērtību True, ja visas virknē esošās rakstzīmes ir izdrukājamas, t.e., neizbēgamie varoņi; pretējā gadījumā tas atgriež False. Lai redzētu, kā tas darbojas, palaidiet šo kodu.
string1 = "Fosslinux"
string2 = "\ nFosslinux"
drukāt (virkne1.isprintable ()) # True
drukāt (virkne2.isprintable ()) # False (Tas satur jauno līnijas rakstzīmi)
Izeja:
virkne.isspace ()
The virkne.isspace () metode atgriezīs True, ja visas virknes rakstzīmes ir atstarpes; citādi tas atgriezīs False.
Citas svarīgas funkcijas
virkne.skaitīt ()
Objekta String skaitīšanas () metodi izmanto, lai iegūtu norādīto vērtību parādīšanās reižu skaitu.
Piemērs:
string = "Fosslinux"
drukāt (virkne.skaits ("s"))
Iepriekš minētajā kodā mēs izmantojām skaitīt () metodi, lai uzzinātu, cik reizes rakstzīme “s” parādās virknē “Fosslinux.”
Izeja:
virkne.startswith ()
Šī virknes metode pārbauda, vai virkne sākas ar apakšstringu, kas norādīts metodes argumentā. Lai skatītu praktisku tā demonstrāciju, kopējiet un palaidiet zemāk esošo kodu Python IDE.
string = "Fosslinux"
drukāt (virkne.startswith ("F"))
drukāt (virkne.startswith ("Fo"))
drukāt (virkne.startswith ("Foss"))
drukāt (virkne.startswith ("Fosss"))
Palaižot iepriekš minēto kodu, mēs saņemsim True pirmajiem trim, bet pēdējais atgriež False, kā parādīts zemāk esošajā izvades attēlā.
virkne.endswith ()
Tas ir līdzīgs iepriekš aprakstītajai metodei, taču atšķirība ir tāda, ka, kamēr iepriekšējā pārbauda virknes sākumu, tā pārbaudīs virknes beigās.
virkne.atrast ()
Objekta String metode find () ir svarīga metode, kā atrast rakstzīmi vai apakšvirkni virknē. Tas pieņem apakšvirkni kā argumentu un atgriež apakšvirknes indeksu, ja tas ir virknē; else atgriež -1.
Piemērs:
string = "Fosslinux"
drukāt (virkne.atrast ("lin"))
Palaižot iepriekš minēto kodu, mēs iegūsim rezultātu 4, kas ir apakšvirsraksta “lin” sākuma indekss sadaļā “Fosslinux”.”
virkne.aizvietot()
Šīs metodes sintakse ir aizstāt (vecā, jaunā). Tam nepieciešami divi argumenti; viens ir vecais apakšvirsraksts, un jaunais ir apakšvirsraksts. Tas aizstāj visu veco apakšvirkni ar jauno apakšvirsrakstu visā virknē.
Piemērs:
string = "Fosslinux"Mēs iegūsim tikai Linux drukāts uz ekrāna kā Foss palaižot iepriekš minēto kodu, tiek aizstāts ar atstarpi. Izeja:
drukāt (virkne.aizstāt ("Foss", ""))
virkne.sadalīt ()
Šī metode atdala atdalītāju kā argumentu, sadala virkni atbilstoši atdalītājam un atgriež pitonu sarakstu.
Piemērs:
string = "Fosslinux ir lieliska vieta, kur sākt mācīties linux un python"Palaižot iepriekš minēto kodu, mēs saņemsim virknes vārdu sarakstu. Tā kā mēs kā argumentu izmantojām sadalīšanas funkciju ar atstarpi, tā, saņemot atstarpi, tā sadala virkni. Izeja:
drukāt (virkne.sadalīt (""))
virkne.sloksne ()
Šo metodi izmanto, lai no virknes noņemtu visas vadošās un aizmugurējās atstarpes.
Secinājums
Tas viss ir par virknēm un to izmantošanu Python. Izmeklējot apmācību, jūs iegūsit priekšstatu par to, cik noderīgi tas darbojas ar virknēm pitonā. Iespējams, vēlēsities redzēt arī apmācību par cilpas izmantošanu pitonā, galīgo cilpu iterācijai pitonā. Visbeidzot, pirms mēs aizbraucam, iespējams, vēlēsities apskatīt metodi, kā mainīt virkni Python, kas ir noderīga, apstrādājot virknes.
