Programowanie w językach skryptowych

1. Programowanie w językach skryptowych Wykład 3: Podstawy Pythona Łańcuchy znakowe Opracował: Dr inż.. Marcin Janaszewski Katedra Informatyki Stosowanej Politechnika Łódzka 1

2. Zawartość wykładu • Definicja łańcucha znakowego • Znaki specjalne • łańcuchy UNICODE

3. Co to jest łańcuch znakowy? Łańcuch znakowy jest sekwencją zawierającą zero lub więcej znaków otoczonych cudzysłowem. Cudzysłów przekazuje do Pythona informację o tym, że znaki należy traktować łącznie jako jedną pozycję, co oznacza, że nie można do łańcucha wstawiać komentarzy, spacji lub czegokolwiek innego, co nie jest jego częścią.

4. Znaki specjalne ZnakOpis \Kontynuacja instrukcji w następnym wierszu (ignorowane) \\ Lewy ukośnik (jeden \) \' Apostrof (jeden ') \" Cudzysłów (jeden ") \a Dzwonek (brzęczyk!) \b Znak cofania \f Przejście do nowej strony \n Przejście do nowego wiersza \r Powrót karetki (różny od \n) \t Znak tabulacji poziomej \v Znak tabulacji pionowej \0 lub\000 Znak o kodzie zerowym. \oooWartość ósemkowa, gdzie ooo oznacza od jednej do trzech cyfr ósemkowych (0...7) \xhh Wartość szesnastkowa, gdzie hh oznacza jedną lub dwie cyfry szesnastkowe (0...9, a...f,A...F) \uxxxx Wartość znaku Unicode, która rozpoznawana jest tylko w łańcuchach Unicode

5. łańcuch surowy Poprzedzony literą r: r "A\nB"

6. łańcuchy Unicode • Łańcuchy Unicode przechowują znaki kodowane w standardzie Unicode, które mają zastosowanie przy tworzeniu różnych wersji językowych programu. Łańcuchy Unicode są zintegrowane z łańcuchami standardowymi i obsługują takie same operacje: indeksowanie, wycinanie, łączenie, porównywanie, przekształcanie, wyszukiwanie i zastępowanie. Można je wykorzystywać jako argumenty funkcji wbudowanych, w kluczach słowników itp. • Poszerzoną analizę tematu można znaleźć w dokumentacji języka oraz na stronie Pythona.

7. Łańcuchy Unicode >>>u'' u'' >>>u1 = u"Politechnika Łódzka" >>>u2 = u"Politechnika\u0020Łódzka" >>>u2 u'Politechnika Łódzka' >>> print u"\u0041\u0020\u0042" A B >>> print u"\u41" UnicodeError: Unicode-Escape decoding error: truncated \uXXXXescape >>> print u"\u0041" A

8. Przekształcenie zwykłego Łańcucha na łańcuch UNICODE • unicode(string [,encoding [,errors]]). • Łańcuch string jest zwykłym łańcuchem, który ma być przekształcony, encoding jest kodekiem użytym do kodowania, a wielkość errors określa, w jaki sposób obsługiwane będą błędy kodowania. Kodek określa sposób, za pomocą którego 8-bitowe kody znaków zwykłego łańcucha są odwzorowywane na 16-bitowe wartości Unicode i odwrotnie. Wielkość encoding może przyjmować jedną z wartości podanych w tabeli na następnym slajdzie. Jeśli ten argument jest pominięty, to będzie zastosowane kodowanie domyślne obowiązujące w danym systemie. Wielkości errors mogą przybierać jedną z wartości podanych w tabeli na slajdzie 10. Jeśli ten argument zostanie pominięty, użyta będzie wartość 'strict'.

9. parametr encoding Wartość opis 'ascii' ASCII 'iso-8859-1' ISO 8859-1 Latin (używany w wielu krajach zachodnich, jest taki sam jak początkowe 256 znaków Unicode) 'latin-1' Taki sam jak 'iso-8859-1' 'utf-8' Kodowanie 8-bitowe o zmiennej długości 'utf-16' Kodowanie 16-bitowe o zmiennej długości (niezależnie od porządku bajtów) 'utf-16-be' UTF-16 z kodowaniem big-endian (bajt najbardziej znaczący na początku) 'utf-16-le' UTF-16 z kodowaniem little-endian (bajt najmniej znaczący na początku) ' unicode - escape' Taki sam jak literał Unicode u"chars" 'raw-unicode- escape' Taki sam jak surowy literal Unicode ur"chars"

10. parametr errors Wartość Opis 'strict' Powoduje powstanie wyjątku UnicodeError, jeśli Python napotyka na znak, którego nie może przekształcić (zachowanie domyślne) 'ignore' Ignoruje niewłaściwy znak i kontynuuje przetwarzanie następnego ' replace' Zamienia niewłaściwy znak na jego zamiennik: ? w łańcuchach standardowych lub 0xfffd w łańcuchach Unicode

11. funkcja unicode przykład >>> unicode("tekst", "ascii") u'tekst' >>> unicode("tekst", "latin-1") u'tekst' >>> unicode("Łódź", "ascii") Traceback (most recent cali last): File "<stdin>". line 1, in module UnicodeDecodeError: 'ascii' codec can't decode byte 0x9d in position 0: ordinal not in range(128) >>> unicode("Łódź", "latin-1") u'\x9d\xa2d\xab' >>> unicode("Lodź", "ascii", "ignore") u'Lod' >>> unicode("Lodź", "ascii", "replace") u'Lod\ufffd' >>> str(u "Lodz") 'Lodz' >>> str(u"Łódź") Traceback (most recent cali last): File "<stdin>". line 1, in module UnicodeDecodeError: 'ascii' codec can't decode byte 0x9d in position 0: ordinal not in range(128)

12. Przykład funkcja encode >>> s = "gro\341" # kod ósemkowy znaku β >>> s 'gro\xe1' >>> print s groβ >>> u = unicode(s, "latin-1") >>>u u 'gro\xe1' >>> u.encode("latin-1") 'gro\xe1' >>> print u.encode("latin-1") groβ >>> u.encode("utf-8") 'gro\xc3\xa1' >>> u.encode("ascii") Traceback (most recent call last): File "<stdin>". line 1, in ? UnicodeError: ASCII encoding error: ordinal not in range(128)

13. Długość łańcucha • Funkcja len(s), gdzie s jest wyrażeniem łańcuchowym zwraca długość s. • Python używa indeksów elementów łańcucha rozpoczynających się od zera. Indeks ostatniego znaku jest równy długości łańcucha pomniejszonej o 1, czyli len(s) - 1. • Można używać ujemnych indeksów w celu pobrania znaków liczonych od końca łańcucha. Indeks ostatniego znaku jest więc równy -1, przedostatniego -2 itd. (aż do -len(s)).

14. Przykład >>> s[len(s) -1 ] 'a' >>> s[-len(s)] 's' >>> s[-len(s) + 1] 'e' >>> n = -3 >>> s[n] = s[len(s) + n] 1 >>> s[1.5] Traceback (most recent call last): File "<stdin>", line 1. in ? TypeError: sequence index must be integer >>> " sekwoja "[0] 's' >>> ' jeden\ndwa' [5] '\n' >>> s = 'sekwoja' >>> print s[0], s[7/2], s[-3], s[-1] s w o a >>> s[len(s)] Traceback (most recent call last): File "<stdin>", line 1, in ? IndexError: string index out of range

15. Wycinanie łańcucha Wycinek jest częścią łańcucha określoną przez dwa indeksy zaznaczające ciągłą sekwencję znaków. Przy wycinaniu indeksy wskazują miejsca międzyznakami. Jeśli obydwa indeksy są dodatnie, to operacja wycinania zwraca część łańcucha rozpoczynającą się od początkowego i rozciągającą się do końcowego indeksu (bez końcowego). Zliczanie indeksów ujemnych rozpoczyna się od końca łańcucha.

16. Wycinanie łańcucha przykład >>> s = 'sekwoja' >>> print s[-100:100] 'sekwoja' >>> s[1:100] 'ekwoja' >>> s[100:] '' >>> s[:100] 'sekwoja' >>> s[-100:] 'sekwoja' >>> s[:-100] '' >>> s[-100:2] 'se' >>> s[6:2] '' >>> s = 'sekwoja' >>> s[0:2] ' se' >>> s[1:3] 'ek' >>> s[1:-1] 'ekwoj' >>> s[3:-3] 'w' >>> print s[2:], s[:2], s[-2:], s[:-2] kwoja se ja sekwo >>> s[:] 'sekwoja' >>> s[:2] + s[2:] 'sekwoja' >>> s[: -3] + s[-3:] 'sekwoja'

17. Wycinanie łańcucha: uwagi • Indeks o zbyt małej wartości jest zastępowany zerem, zaś indeks o zbyt dużej wartości długością łańcucha. Jeśli drugi indeks wskazuje pozycję znajdującą się przed pierwszym indeksem, to zwracany jest pusty łańcuch. • Łańcuchy są niezmienne. Poniższa instrukcja nie modyfikuje istniejącego obiektu łańcuchowego, lecz tworzy nowy obiekt: s = s[i:j] • Nie można zmodyfikować łańcucha w miejscu za pomocą przypisania pokazanego niżej: s[i:j] = "tekst"

18. Łączenie łańcuchów >>> 'Politechnika' + ' Lodzka' 'Politechnika Lodzka' >>> "" + "" "" >>> r = "A" + "\n" + "\t" + "B" >>> r 'A\n\tB' >>> print r A B >>> s = 'sekwoja' >>> t = s[0:4] + 'ens' >>> print t sekwens >>> a = "To jest test" >>> b = "taki" >>> a[:3] + b + a[3 + len(b):] 'To taki test'

19. Łączenie literałów łańcuchowych >>> "a""b" 'ab' >>> s = 'form' 'al' 'dehyd' >>> print s formaldehyd >>> t = 'Plan ' str(9) File "<stdin>", line 1 t = 'Plan ' str(9) SyntaxError: invalid syntax

20. Łączenie łańcuchów za pomocą przypisania przyrostowego • Podczas łączenia nie są wstawiane spacje między łańcuchami. • Próba połączenia łańcucha z obiektem, który łańcuchem nie jest, wywołuje wyjątek TypeError. Przed połączeniem należy taki obiekt przekształcić w łańcuch za pomocą funkcji str(). • Łączenie działa także w przypadku list i krotek >>> s = 'formal' >>> s += 'de' >>> s+= 'hyd' >>> print s 'formaldehyd'

21. Powtarzanie łańcucha >>> t = "WEEIA " >>> t * 3 'WEEIA WEEIA WEEIA ' >>> t * 0 '' >>> t * 3.5 • Traceback (most recent call last): • File "<stdin>". line 1, in ? • TypeError: unsupported operand type(s) for * >>> " * 1000 '' >>> s = 'sekwoja' >>> s[0:4] + 'ens ' * 3 'sekwens ens ens ' >>> (s[0:4] + 'ens ') * 3 'sekwens sekwens sekwens ' >>> print "<" + s * 3 + ">" <sekwojasekwojasekwoja>

22. Powtarzanie łańcucha za pomocą przypisania przyrostowego s *= n. Wyrażenie s jest wyrażeniem łańcuchowym, a n jest liczbą całkowitą oznaczającą krotność powtórzeń łańcucha s >>> s1 = '1' >>> s2 = '22' >>> s2 *= len(s1) >>> s2 *= len(s2) >>> print s1, s2 1 2222 >>> s3 = 'abc ' >>> s3 *= len(s3) + 1 >>> print s3 abc abc abc abc abc >>> s3 *= 0 >>> s3 ''

23. Zastosowanie metod i funkcji łańcuchowych • W wersji 2.0 języka Python wprowadzono wbudowane metody łańcuchowe, które zastępują większość funkcji o podobnych nazwach pochodzących ze standardowego modułu string. We wcześniejszych wersjach języka należy posługiwać się funkcjami pochodzącymi z modułu string. Przykładowo wywołanie metody: s.find(sub, start, end) jest odpowiednikiem wywołania funkcji: string.find(s, sub, start, end)

24. Zmiana wielkości liter w łańcuchu >>> import string >>> string.capwords(s) 'Politechnika Lodzka' >>> t = " The 5th element:\tMila" >>> print t 'The 5th element: Mila' >>> print string.capwords(t) 'The 5th Element: Mila' >>> r = 'dot.com dot_com dot@com' >>> r.title() 'Dot.Com Dot_Com Dot@Com' >>> s = "Politechnika Lodzka" >>> s.upper() 'POLITECHNIKA LODZKA' >>> s.lower() 'politechnika lodzka' >>> s.swapcaset() pOLITECHNIKA lODZKA >>> s.capitalize() 'Politechnika lodzka' >>> s.title() 'Politechnika Lodzka' capwords – pierwsze litery na duże, pozostałe na małe, kasuje początkowe i końcowe białe znaki, ciągi białych znaków zamienia na pojedyncze spacje

25. Testowanie łańcuchów >>> alpha = "abc" >>> num = "123" >>> space = " \n\t" >>> print alpha.isalpha(), num.isdigit() 1 1 >>> (alpha + num).isdigit() 0 >>> (alpha + num). isalnum() 1 >>> (alpha + num + space).isalnum() 0 >>> space.isspace() 1 >>> "".isalpha() 0

26. Sprawdzanie wielkości liter >>> title.istitle() 1 >>> (title + num).istitle() 1 >>> (num + title).istitle() 1 >>> ("\n" + title).istitle() 1 >>> (num + title).istitle() 1 >>> (upper + title).istitle() 0 >>> upper = "ABC" >>> lower = "xyz" >>> title = "Title" >>> num = "123" >>> print upper.isupper(), lower.islower() 1 1 >>> (upper + num).isupper() 1 >>> title.isupper() 0 >>> title[1:].islower() 1 istitle() sprawdza, czy wszystkie słowa są pisane wielką literą. Sprawdza czy wielkie litery następują po znakach, które nie są literami, a małe litery następują tylko po literach (dowolnej wielkości).

27. Stałe modułu string Moduł string zawiera definicje atrybutów przydatnych do określenia sposobu działania metod is. Na przykład metoda isspace() określa to, czy wszystkie znaki w łańcuchu występują w string.whitespace. Niektóre atrybuty modułu string są łączone w celu utworzenia innych atrybutów. Na przykład atrybut lettersjest kombinacją atrybutów lowercasei uppercase, atrybut printablejest kombinacją digits, letters, punctuationi whitespace. Stałe te można wykorzystać przy samodzielnym tworzeniu funkcji. Można na przykład zdefiniować funkcję ispunc(), która będzie określać to, czy wszystkie znaki w łańcuchu są znakami interpunkcyjnymi. Atrybuty:hexdigits, letters, lowercase, octdigits, punctuation, printable, uppercase, whitespace

28. Przykład >>> string.uppercase 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' >>> string.whitespace '\t\n\x0b\x0c\r' >>> "\n" in string.whitespace 1 >>> "\f" in string.whitespace 1 >>> " " in string.printable 1 >> (string.whitespace).isspace() 1 >>> import string >>> string.digits '0123456789' >>> string.hexdigits '0123456789abcdefABCDEF' >>> string.letters 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' >>> string.lowercase 'abcdefghijklmnopqrstuvwxyz' >>> string.octdigits '01234567' >>> string.punctuation '!''#$%&\' ()*+,-./:;<=>?@[\\] ^_`{|} ~' >>> string.printable '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~ \t\n\r\x0b\x0c'

29. Przycinanie i wyrównywanie łańcucha Przycinanie polega na usuwaniu zbędnych białych znaków występujących na początku i na końcu łańcucha. >>> s = " Politechnika Lodzka " >>> s.lstrip() 'Politechnika Lodzka ' >>> s.rstrip() ' Politechnika Lodzka' >>> t = "\t \t Middle \n Part \n \n " >>> t.lstrip() 'Middle \n Part \n \n ' >>> t.rstrip() '\t \t Middle \n Part' >>> t.strip() 'Middle \n Part'

30. Wyrównywanie łańcucha Wyrównywanie polega na wstawianiu dodatkowych spacji na początku lub na końcu łańcucha. >>> s = "Maria Sklodowska-Curie" >>> len(s) 22 >>> s.ljust(25) 'Maria Sklodowska-Curie ' >>> s.rjust(25) ' Maria Sklodowska-Curie' >>> s.center(len(s) + 4) ' Maria Sklodowska-Curie ' >>> s.rjust(0) 'Maria Sklodowska-Curie' >>> s.ljust(-2) 'Maria Sklodowska-Curie' >>> s.center(10) 'Maria Sklodowska-Curie' >>> s.rjust(len(s) + 2.99) __main__:1: deprecationWarning: integer argument expected, got float ' Maria Sklodowska-Curie'

31. funkcja string.zfill() >>> inport string >>> s = '123.45' >>>len(s) 6 >>>string.zfill(s,8) '00123.45' string.zfill(s,4) '173.45' >>> string.zfill(-11,5) '-0011' >>> string.zfill(0.01,6) '000.01' string.zfill ('1' * 3, 5) '00111'

32. Wyszukiwanie łańcuchów podrzędnych Metody wyszukiwania służą do zliczania i znajdowania łańcuchów podrzędnych w łańcuchach. Przeszukiwanie może odbywać się od początku lub od końca łańcucha. Metody te mogą opcjonalnie pobierać argumenty start i end ograniczające zakres poszukiwań. Normalnie przeszukiwany jest cały łańcuch s,lecz po podaniu argumentów start i end zakres zostaje zawężany do s[start:end]. Interpretacja tych argumentów jest taka sama jak w przypadku operacji wycinania. Jeśli nie są one podane w sposób jawny, to użyte zostają ich wartości domyślne (czyli zero dla start i długość łańcucha dla end).

33. Zliczanie łańcuchów podrzędnych >>> s.count("pe") 2 >>> s.lower().count("pe") 3 >>> s.count("X") 0 >>> s.count(" ") 2 >>> s.count("") 20 >>> s.count(", 0, 6) 7 count(sub [,start [,end]]) >>> s = "Peter: pepper eater" >>> len(s) 19 >>> s. count ("ter") 2 >>> s. count ("er") 3 >>> s.count("er", 7) 2 >>> s.count("er", 7, 13) 1

34. Wyszukiwanie łańcuchów: przykład >>> s.find("\n" ) -1 >>> s.find("X") -1 >>> s.index("X") Traceback (most recent call last): file "<stdin>". line 1, in ? ValueError: substring not found in string.index >>> s.find(" ") 6 >>>s.find("") 0 >>> s.find(" ", 7) 7 s.find (sub [,start [, end]]) >>> s ="Peter: pepper eater" >>> len(s) 19 >>> s.find("er") 3 >>> s.find("er", 7) 11 >>> s.find("er", 13) >>>s.find("pe") 7 >>> s.lower().find("pe") 0

35. Wyszukiwanie od końca >>> s.rfind("X") -1 >>> s.rindex("X") Traceback (most recent call last): File "<stdin>", line 1, in ? ValueError: substring not found in string, rindex >>> s.rfind("") 13 >>> s.rfind("") 19 >>> s.rfind("", 0, 7) 7 s.rfind (sub [,start [,end]]) >>> s = "Peter: pepper eater" >>> len(s) 19 >>> s.rfind("er") 17 >>> s.rfind("er", 7, 13) 11 >>> s.rfind("er", 0, 7) 3 >>> s.rfind("pe") 10 >>> s.rfind("Pe") 0 >>> s.rfind("\n") -1

36. Znajdowanie początkowego lub końcowego łańcucha s.startswith(prefix [,start [,end]]) s.endswith(suffix [,start [,end]]) >>> s = "Peter: pepper eater" >>> len(s) 19 >>> s.startswith("Pe") 1 >>> s.startswith("Pe", 7) 0 >>> s.startswith("pe", 7) 1 >>> s.endswith("er") 1 >>> s.endswith("er", 0, 13) 1 >>> s.endswith("er", 0, 5) 1 >>> s.startswith("") 1 >>> s.endswith("") 1 >>> t = "\t" + s + "\n" >>> t.startswith("Pe") 0 >>> t.startswith("\t") 1 >>> t.endswith("er\n") 1

37. Wskazówki dotyczące wyszukiwania • Przy zliczaniu i wyszukiwaniu ważna jest wielkość liter. • Podczas zliczania i wyszukiwania znajdowane są łańcuchy podrzędne, które się nie pokrywają. Oznacza to, że łańcuch "Ba-booom" zawiera tylko jeden łańcuch podrzędny "oo" (a nie dwa). • Do sprawdzenia tego, czy łańcuch zawiera jakiś określony znak, można wykorzystać operatory ini not in.

38. Zamiana łańcuchów podrzędnych >>> s.replace("X", "Y") 'Peter: pepper eater' >>> s.replace("er", "") 'Pet: pepp eat' >>> s. replace("er", "", 1) 'Pet: pepper eater' >>> s.replace("", "X") Traceback (most recent call last): File "<stdin>", line 1, in ValueError: empty pattern string >>> s.replace("e", "E").replace("p","P") 'PEtEr: PEPPEr EatEr' s.replace(old, new[,maxreplace]) >>> s = "Peter: pepper eater" >>> s.replace("eat", "purg") 'Peter: pepper purger' >>> s.replace("Pe", "Dei") 'Deiter: pepper eater' >>> print s.replace(" ", \n") Peter: pepper eater >>> t = "pepper" >>> s[s.find(t):].replace(t, "lotus") 'lotus eater'

39. Zamiana znaków tabulacji na spacje >>> print s.expandtabs(-1) ABC >>> print s.expandtabs(1) ABC >>> print s.expandtabs(2) A B C >>> print s.expandtabs(2.5) A B C >>> print s.expandtabs(4) A B C >>> print s.expandtabs(12) ABC s.expandtabs([tabsize]) >>> s = "A\tB\tC" >>> t = s.expandtabs() s, t ('A\tB\tC', 'AB C') >>> print s ABC >>> print t ABC >>> print s.expandtabs(0) ABC

40. Konwersja łańcucha Gdy wykonuje się kilka zamian pojedynczych znaków w łańcuchu, wygodniej jest użyć metody translate(), zamiast wielokrotnie wywoływać metodę replace(). Metoda translate()wykorzystuje podczas zamiany 256-znakowy łańcuch zwany tablicą konwersji. Tablica konwersji może być utworzona ręcznie, lecz łatwiej można to zrobić z wykorzystaniem funkcji string.maketrans(). >>> s = "sekwoja" >>> import string >>> table = string.maketrans("aeo", "AEO") >>> s.translate(table) 'sEkwOjA' >>> t = "Peter: pepper eater" >>> t.translate(table, "pt") 'PEEr: EEr EAEr' >>> t.translate(table, "e") . 'Ptr: pppr Atr'

41. Rozdzielanie i łączenie łańcuchów Rozdzielanie łańcucha polega na podzieleniu go na fragmenty i utworzeniu listy tych fragmentów. Łączenie jest odwrotnością rozdzielania i polega na połączeniu wszystkich pozycji listy (lub krotki) w jeden łańcuch. Poszczególne pozycje podczas rozdzielania lub łączenia zostają odseparowane od siebie co najmniej jednym znakiem pełniącym role ogranicznika. Jako przykład można podać pola we wpisie do bazy danych odseparowane od siebie przecinkami. Rozdzielanie i łączenie często bywa wykorzystywane podczas wstępnego rozbioru i przygotowania danych dla bazy danych lub dla plików dziennika.

42. funkcja split s. split([delim [,maxsplit]]), zwraca listę zawierającą słowa, które w łańcuchu sbyły oddzielone ogranicznikami deltim. W zwracanej liście usunięte zostają znaki ogranicznika. Jeśli wyrażenie deltim jest pominięte, to jako domyślne ograniczniki przyjmuje się odstępy (spacje, znaki tabulacji, znaki nowego wiersza itd.). Następujące po sobie znaki odstępów są traktowane jako pojedyncze ograniczniki. Łańcuch jest dzielony na maxsplitfragmentów. Jeśli wyrażenie maxsplit zostanie pominięte, to nastąpi rozdzielenie na wszystkie słowa. Wyrażenia s i deltim są wyrażeniami łańcuchowymi, zaś maxsplitjest wyrażeniem całkowitoliczbowym.

43. Łączenie łańcuchów delim.join(sequence), zwraca łańcuch zawierający pozycje występujące w sekwencji sequence i oddzielone w niej za pomocą ograniczników delim. Wyrażenie delim jest wyrażeniem łańcuchowym, zaś sequence jest listą lub krotką zawierającą tylko pozycje łańcucha. W metodzie join() wszystkie pozycje listy lub krotki muszą być wyrażeniami łańcuchowymi. W przeciwnym wypadku Python zwraca wyjątek TypeError. Podczas łączenia wielu łańcuchów wygodniej jest posłużyć się metodą join() z pustym ogranicznikiem ("") niż stosować operator +, ponieważ join() tworzy mniej łańcuchów pośrednich. Zazwyczaj argument sequencew metodzie join() jest listą lub krotką. Może on również być łańcuchem (czyli sekwencją znaków). Oto przykład takiego zastosowania łańcucha: >>>print "\n". join("321") 3 2 1

44. Rozdzielanie i łączenie łańcucha: przykład ['543235', '3800 Waldo Ave,Bronx,NY,10463'] >>> t.split(",", 2) ['543235', '3800 Waldo Ave','Bronx,NY,10463'] >>> r = "Peter: pepper eater" >>> r.split("er") ['Pet', ': pepp'. ' eat', ''] >>> r.lower().split("pe") [" , 'ter: ', 'p', 'r eater'] >>> "Ja odpowiadam \n od \trazu.\n".split() ['Ja', 'odpowiadam', 'od', 'razu.'] >>> s = "Ja odpowiadam od razu." >>> lst = s.split() >>> lst ['Ja', 'odpowiadam', 'od', 'razu.'] >>> " ".join(lst) 'ja odpowiadam od razu.' >>> "".join(lst) 'Jaodpowiadamodrazu.' >>> print "\n".join(lst) Ja odpowiadam od razu. >>> print ". ".join(lst).title() Ja. Odpowiadam. Od. Razu. >>> t = "543235,3800 Waldo Ave,Bronx,NY,10463" >>> t.split(',") ['543235', '3800 Waldo Ave', 'Bronx', 'NY',V10463'] >>> t.split(",", 1)

45. Rozdzielanie łańcucha na wiersze s.splitlines([keepends]), zwraca listę zawierającą wiersze łańcucha s. Jeśli keepends jest prawdą, to znaki nowego wiersza zostaną włączane do listy. Jeśli keepends jest fałszem lub zostało pominięte, to znaki nowego wiersza nie będą zachowywane. Wyrażenie s jest wyrażeniem łańcuchowym, a keepends jest wyrażeniem logicznym. >>> s = "Wiersz 1\nWiersz 2\nWiersz 3" >>> print s Wiersz 1 Wiersz 2 Wiersz 3 >>> s.split("\n") ['Wiersz 1', 'Wiersz 2', 'Wiersz 3'] >>> s.splitlines() ['Wiersz 1', 'Wiersz 2', 'Wiersz 3'] >>> s.splitlines(1) ['Wiersz 1\n', 'Wiersz 2\n', 'Wiersz 3'] >>> t = "Wiersz 1\n\nWiersz 3" >>> print t Wiersz 1 Wiersz 3 >>> t.splitlines() ['Wiersz 1', " , 'Wiersz 3'] >>> t.splitlines(1) ['Wiersz 1\n', '\n', 'Wiersz 3']

46. Operacje listowe stosowane w łańcuchach Jak wiadomo, łańcuchy są niezmienne i nie można ich modyfikować w miejscu tak, jak dzieje się to w przypadku list. Czasami przydaje się jednak potraktowanie łańcucha jako sekwencji znaków i przekształcenie go w taki sposób, jakby był listą. >>> s = "wielostop" >>> s = list(s) >>> print s ['w', 'i', 'e', 'l', 'o', 's', 't', 'o', 'p'] >>> s[4:] = [] >>> print s ['w','i','e','l'] >>> s.sort() >>>s.reverse() >>> s = "".join(s) >>> s 'wlie' Uwaga: Przekształcenia typów łańcuchowych i listowych wymagają dużo zasobów obliczeniowych

47. Przekształcanie obiektów na łańcuch Funkcje str() i repr() przekształcają prawie każdy typ obiektu na łańcuch. Zazwyczaj obie zwracają taką samą wartość, lecz str() jest bardziej zwięzła i czytelna. Odpowiednikiem funkcji repr() jest zapis obiektu w odwrotnych apostrofach. Znak odwrotnego apostrofu (') na klawiaturze jest zazwyczaj umieszczony ponad klawiszem tabulatora. Przekształcanie obiektu na łańcuch: str(expr) repr(expr) `expr`

48. Przekształcenie obiektu na łańcuch repr(math.pi) '3.1415926535897931' >>>lst = ['one' + str(2), len, (math.pi, 1/3.0)] >>> str(lst) ['one2', <built-in function len>, p(3.1415926535897931, 0.33333333333333331)]" >>> `lst` "['one2', <built-in function len>, (3.1415926535897931, 0.33333333333333331)] " >>>str(SyntaxError) 'exceptions.SyntaxError' >>>repr(SyntaxError) '<class exceptions.SyntaxError at 007AB8F0' >>>str(None) 'None' >>> s = "mimetyczny" >>> s, str(s), repr(s) ['mimetyczny', 'mimetyczny', "'mimetyczny'") >>> print s, str(s), repr(s) mimetyczny mimetyczny 'mimetyczny' >>> t = s + "\n" >>> t, str(t), repr(t) ('mimetyczny\n', 'mimetyczny\n', '"mimetyczny\\n"') >>> print t, str(t), repr(t) mimetyczny mimetyczny mimetyczny\n' >>> repr(len) <bui11-in function len>' >>> import math >>> repr(math) "<module 'math' (built-in)>" >>> str(math.pi) '3.14159265359'

49. Porównywanie łańcuchów >>> 'Zero' == 'zero' 0 >>> 'zero' == ('zero' + '') 1 >>> "A" < "a" 1 >>> "A" < "AA" 1 >>> "A" < "" 0 >>> 'formal' >= 'formaldehyd' 0 >>> 'able' <= 'baker' != 'c' 1 >>> '\t' < '\n' < '.' < '4' < 'A' < 'z' 1 >>> 'home wrecker' < 'home_wrecker' <' homewrecker' 1

50. Przekształcenie znaku na wartość ASCII ord(c), gdzie c jest jednoznakowym wyrażeniem łańcuchowym >>> print ord('\t'), ord('\n'), ord('.') 9 10 46 >>> print ord('A'), ord('Z'), ord('a'), ord('z') 65 90 97 122 >>> ord( '' ) Traceback (most recent call last): File "<stdin>". line 1. in ? TypeError: ord() expected a character, but string of length 0 found >>> ord('Zzz') Traceback (most recent call last): File "<stdin>", line 1. in ? TypeError: ord() expected a character, but string of length 3 found