Python Language
Metody ciągów

Składnia

• str.capitalize () -> str
• str.casefold () -> str [tylko dla Python> 3.3]
• str. centrum (szerokość [, fillchar]) -> str
• str.count (sub [, start [, end]]) -> int
• str.decode (encoding = "utf-8" [, błędy]) -> Unicode [tylko w Python 2.x]
• str.encode (kodowanie = „utf-8”, błędy = „ścisłe”) -> bajty
• str.endswith (sufiks [, start [, koniec]]) -> bool
• str.expandtabs (tabsize = 8) -> str
• str.find (sub [, start [, end]]) -> int
• str.format (* args, ** kwargs) -> str
• str.format_map (mapowanie) -> str
• str.index (sub [, start [, end]]) -> int
• str. isalnum () -> bool
• str. isalpha () -> bool
• str.isdecimal () -> bool
• str.isdigit () -> bool
• str.isidentifier () -> bool
• str. islower () -> bool
• str.isnumeric () -> bool
• str.isprintable () -> bool
• str.isspace () -> bool
• str.istitle () -> bool
• str.isupper () -> bool
• str.join (iterable) -> str
• str. just (szerokość [, fillchar]) -> str
• str. dolna () -> str
• str.lstrip ([chars]) -> str
• static str.maketrans (x [, y [, z]])
• str. partycja (sep) -> (głowa, sep, ogon)
• str .replace (old, new [, count]) -> str
• str.rfind (sub [, start [, end]]) -> int
• str.rindex (sub [, start [, end]]) -> int
• str. rjust (szerokość [, fillchar]) -> str
• str. partycja (sep) -> (głowa, sep, ogon)
• str.rsplit (sep = None, maxsplit = -1) -> lista ciągów
• str.rstrip ([chars]) -> str
• str.split (sep = None, maxsplit = -1) -> lista ciągów
• str.splitlines ([keepends]) -> lista ciągów
• str. startartswith (prefix [, start [, end]]) -> book
• str.strip ([chars]) -> str
• str.swapcase () -> str
• str.title () -> str
• str.translate (table) -> str
• str.upper () -> str
• str. z wypełnienie (szerokość) -> str

Uwagi

Zmiana wielkich liter ciągu

Typ łańcucha Pythona zapewnia wiele funkcji, które działają na wielkie litery. Obejmują one :

• str.casefold
• str.upper
• str.lower
• str.capitalize
• str.title
• str.swapcase

W przypadku łańcuchów Unicode (domyślnie w Pythonie 3) operacje te nie są odwzorowaniami 1: 1 ani odwracalnymi. Większość tych operacji jest przeznaczona raczej do celów wyświetlania niż do normalizacji.

"XßΣ".casefold()
# 'xssσ'

"XßΣ".lower()
# 'xßς'

str.upper()

str.upper pobiera każdy znak w ciągu i konwertuje go na ekwiwalent wielkich liter, na przykład:

"This is a 'string'.".upper()
# "THIS IS A 'STRING'."

str.lower()

str.lower robi str.lower przeciwnego; pobiera każdy znak w ciągu i konwertuje go do swojego małego odpowiednika:

"This IS a 'string'.".lower()
# "this is a 'string'."

str.capitalize()

str.capitalize zwraca wielką str.capitalize łańcucha, co oznacza, że pierwszy znak ma wielkie litery, a pozostałe małe:

"this Is A 'String'.".capitalize() # Capitalizes the first character and lowercases all others
# "This is a 'string'."

str.title()

str.title zwraca tytułową wersję łańcucha, tzn. każda litera na początku słowa jest str.title wielkimi literami, a wszystkie inne są pisane małymi literami:

"this Is a 'String'".title()
# "This Is A 'String'"

str.swapcase()

str.swapcase zwraca nowy obiekt łańcucha, w którym wszystkie małe litery są zamieniane na wielkie litery, a wszystkie wielkie litery na małe:

"this iS A STRiNG".swapcase() #Swaps case of each character
# "THIS Is a strIng"

Zastosowanie jako metody klasy str

Warto zauważyć, że metody te można wywoływać na obiektach łańcuchowych (jak pokazano powyżej) lub jako metoda klasowa klasy str (z wyraźnym wywołaniem str.upper itp.)

str.upper("This is a 'string'")
# "THIS IS A 'STRING'"

Jest to najbardziej przydatne, gdy stosuje się jedną z tych metod do wielu ciągów naraz, powiedzmy, funkcji map .

map(str.upper,["These","are","some","'strings'"])
# ['THESE', 'ARE', 'SOME', "'STRINGS'"]

Podziel ciąg oparty na separatorze na listę ciągów

str.split(sep=None, maxsplit=-1)

str.split pobiera ciąg znaków i zwraca listę podciągów oryginalnego ciągu. Zachowanie różni się w zależności od tego, czy argument sep jest podany, czy pominięty.

Jeśli nie podano sep lub None , to dzielenie odbywa się wszędzie tam, gdzie jest spacja. Jednak początkowe i końcowe białe znaki są ignorowane, a wiele kolejnych znaków białych jest traktowanych tak samo jak pojedynczy znak białych znaków:

>>> "This is a sentence.".split()
['This', 'is', 'a', 'sentence.']

>>> " This is    a sentence.  ".split()
['This', 'is', 'a', 'sentence.']

>>> "            ".split()
[]

Za pomocą parametru sep można zdefiniować ciąg separatora. Oryginalny ciąg jest dzielony tam, gdzie występuje ciąg separatora, a sam separator jest odrzucany. Wiele kolejnych separatorów nie jest traktowanych tak samo jak pojedyncze wystąpienie, ale powoduje tworzenie pustych ciągów.

>>> "This is a sentence.".split(' ')
['This', 'is', 'a', 'sentence.']

>>> "Earth,Stars,Sun,Moon".split(',')
['Earth', 'Stars', 'Sun', 'Moon']

>>> " This is    a sentence.  ".split(' ')
['', 'This', 'is', '', '', '', 'a', 'sentence.', '', '']

>>> "This is a sentence.".split('e')
['This is a s', 'nt', 'nc', '.']

>>> "This is a sentence.".split('en')
['This is a s', 't', 'ce.']

Domyślnie jest to podział przy każdym wystąpieniu ogranicznika, jednak parametr maxsplit ogranicza liczbę występujących maxsplit . Domyślna wartość -1 oznacza brak limitu:

>>> "This is a sentence.".split('e', maxsplit=0)
['This is a sentence.']

>>> "This is a sentence.".split('e', maxsplit=1)
['This is a s', 'ntence.']

>>> "This is a sentence.".split('e', maxsplit=2)
['This is a s', 'nt', 'nce.']

>>> "This is a sentence.".split('e', maxsplit=-1)
['This is a s', 'nt', 'nc', '.']

str.rsplit(sep=None, maxsplit=-1)

str.rsplit („prawy podział”) różni się od str.split („lewy podział”), gdy określono maxsplit . Podział rozpoczyna się na końcu ciągu, a nie na początku:

>>> "This is a sentence.".rsplit('e', maxsplit=1)
['This is a sentenc', '.']

>>> "This is a sentence.".rsplit('e', maxsplit=2)
['This is a sent', 'nc', '.']

Uwaga : Python określa maksymalną liczbę wykonanych podziałów , podczas gdy większość innych języków programowania określa maksymalną liczbę utworzonych podciągów . Może to powodować zamieszanie podczas przenoszenia lub porównywania kodu.

Zamień wszystkie wystąpienia jednego podłańcucha na inny podłańcuch

Typ str Pythona ma również metodę zastępowania wystąpień jednego podciągu innym podciąganem w danym ciągu. W bardziej wymagających przypadkach można użyć re.sub .

str.replace(old, new[, count]) :

str.replace pobiera dwa argumenty old i new zawierający old ciąg podrzędny, który ma zostać zastąpiony new ciągiem podrzędnym. Opcjonalna count argumentów określa liczbę zamienników, które należy wykonać:

Na przykład, aby zastąpić 'foo' str.replace 'spam' w następującym ciągu, możemy wywołać str.replace ze old = 'foo' i new = 'spam' :

>>> "Make sure to foo your sentence.".replace('foo', 'spam')
"Make sure to spam your sentence."

Jeśli podany ciąg zawiera wiele przykładów pasujących do old argumentu, wszystkie wystąpienia zostaną zastąpione wartością podaną w new :

>>> "It can foo multiple examples of foo if you want.".replace('foo', 'spam')
"It can spam multiple examples of spam if you want."

chyba że oczywiście podamy wartość do count . W takim przypadku count wystąpień zostanie zastąpiona:

>>> """It can foo multiple examples of foo if you want, \
... or you can limit the foo with the third argument.""".replace('foo', 'spam', 1)
'It can spam multiple examples of foo if you want, or you can limit the foo with the third argument.'

str.format i f-string: Formatuj wartości w łańcuch

Python zapewnia interpolację i formatowanie ciągów za pomocą funkcji str.format , wprowadzonej w wersji 2.6 i f-stringów wprowadzonej w wersji 3.6.

Biorąc pod uwagę następujące zmienne:

i = 10
f = 1.5
s = "foo"
l = ['a', 1, 2]
d = {'a': 1, 2: 'foo'}

Wszystkie poniższe oświadczenia są równoważne

"10 1.5 foo ['a', 1, 2] {'a': 1, 2: 'foo'}"

>>> "{} {} {} {} {}".format(i, f, s, l, d)

>>> str.format("{} {} {} {} {}", i, f, s, l, d)

>>> "{0} {1} {2} {3} {4}".format(i, f, s, l, d)

>>> "{0:d} {1:0.1f} {2} {3!r} {4!r}".format(i, f, s, l, d)

>>> "{i:d} {f:0.1f} {s} {l!r} {d!r}".format(i=i, f=f, s=s, l=l, d=d)

>>> f"{i} {f} {s} {l} {d}"

>>> f"{i:d} {f:0.1f} {s} {l!r} {d!r}"

W celach informacyjnych Python obsługuje także kwalifikatory w stylu C do formatowania ciągów. Poniższe przykłady są równoważne z powyższymi, ale preferowane są wersje str.format ze względu na zalety w zakresie elastyczności, spójności zapisu i rozszerzalności:

"%d %0.1f %s %r %r" % (i, f, s, l, d)

"%(i)d %(f)0.1f %(s)s %(l)r %(d)r" % dict(i=i, f=f, s=s, l=l, d=d)

Nawiasy klamrowe używane do interpolacji w str.format można również ponumerować, aby ograniczyć powielanie podczas formatowania ciągów. Na przykład następujące są równoważne:

"I am from Australia. I love cupcakes from Australia!"

>>> "I am from {}. I love cupcakes from {}!".format("Australia", "Australia")

>>> "I am from {0}. I love cupcakes from {0}!".format("Australia")

Chociaż oficjalna dokumentacja Pythona jest, jak zwykle, dość dokładna, pyformat.info ma świetny zestaw przykładów ze szczegółowymi objaśnieniami.

Dodatkowo znaki { i } można uciec za pomocą podwójnych nawiasów:

"{'a': 5, 'b': 6}"

>>> "{{'{}': {}, '{}': {}}}".format("a", 5, "b", 6)

>>> f"{{'{'a'}': {5}, '{'b'}': {6}}"

Aby uzyskać dodatkowe informacje, zobacz Formatowanie ciągów . str.format() został zaproponowany w PEP 3101, a f-string w PEP 498 .

Zliczanie, ile razy podciąg pojawia się w ciągu

Dostępna jest jedna metoda zliczania liczby wystąpień str.count w innym ciągu, str.count . str.count .

str.count(sub[, start[, end]])

str.count Zwraca int wskazując liczbę niepokrywające występującymi podnapis sub w innym ciągiem. Opcjonalne argumenty start i end wskazują początek i koniec wyszukiwania. Domyślnie start = 0 i end = len(str) co oznacza, że zostanie przeszukany cały ciąg:

>>> s = "She sells seashells by the seashore."
>>> s.count("sh")
2
>>> s.count("se")
3
>>> s.count("sea")
2
>>> s.count("seashells")
1

Określając inną wartość na start , end możemy uzyskać bardziej zlokalizowane wyszukiwanie i liczyć, na przykład, jeśli start jest równy 13 wezwanie do:

>>> s.count("sea", start)
1

jest równa:

>>> t = s[start:]
>>> t.count("sea")
1

Przetestuj początkowe i końcowe znaki ciągu

Aby przetestować początek i koniec danego ciągu w Pythonie, można użyć metod str.startswith() i str.endswith() .

str.startswith(prefix[, start[, end]])

Jak sama nazwa wskazuje, str.startswith służy do testowania, czy dany ciąg zaczyna się od podanych znaków w prefix .

>>> s = "This is a test string"
>>> s.startswith("T")
True
>>> s.startswith("Thi")
True
>>> s.startswith("thi")  
False

Opcjonalne argumenty „ start i end określają punkt początkowy i końcowy, od którego rozpoczyna się i kończy testowanie. W poniższym przykładzie, podając wartość początkową 2 nasz ciąg zostanie przeszukany od pozycji 2 a następnie:

>>> s.startswith("is", 2)
True

Daje to wartość True ponieważ s[2] == 'i' s[3] == 's' .

Możesz także użyć tuple aby sprawdzić, czy zaczyna się od zestawu ciągów

>>> s.startswith(('This', 'That'))
True
>>> s.startswith(('ab', 'bc'))
False

str.endswith(prefix[, start[, end]])

str.endswith jest dokładnie podobny do str.startswith z tą różnicą, że szuka znaków końcowych, a nie znaków początkowych. Na przykład, aby sprawdzić, czy ciąg znaków kończy się kropką, można napisać:

>>> s = "this ends in a full stop."
>>> s.endswith('.')
True
>>> s.endswith('!')
False

tak jak w przypadku startswith z więcej niż jednym znakiem można użyć jako sekwencji końcowej:

>>> s.endswith('stop.')
True
>>> s.endswith('Stop.')
False

Możesz także użyć tuple aby sprawdzić, czy kończy się na którymś z zestawów ciągów

>>> s.endswith(('.', 'something'))
True
>>> s.endswith(('ab', 'bc'))
False

Testowanie, z czego składa się łańcuch

Typ str Pythona zawiera również szereg metod, których można użyć do oceny zawartości łańcucha. Są to str.isalpha str.isdigit , str.isalnum , str.isspace . str.isalnum , str.isspace . str.isspace . str.isupper str.islower można testować za pomocą str.isupper , str.istitle . str.islower i str.istitle .

str.isalpha

str.isalpha nie przyjmuje argumentów i zwraca True jeśli wszystkie znaki w danym ciągu są alfabetyczne, na przykład:

>>> "Hello World".isalpha()  # contains a space
False
>>> "Hello2World".isalpha()  # contains a number
False
>>> "HelloWorld!".isalpha()  # contains punctuation
False
>>> "HelloWorld".isalpha()
True

W przypadku krawędzi pusty łańcuch ma wartość False jeśli jest używany z "".isalpha() .

str.isupper str.islower , str.istitle str.islower , str.istitle

Te metody testują wielkie litery w danym ciągu.

str.isupper to metoda zwracająca wartość True jeśli wszystkie znaki w danym ciągu są wielkie i, w przeciwnym razie, False .

>>> "HeLLO WORLD".isupper()
False
>>> "HELLO WORLD".isupper()
True
>>> "".isupper()
False

I odwrotnie, str.islower to metoda, która zwraca True jeśli wszystkie znaki w danym ciągu są małe i False przeciwnym razie.

>>> "Hello world".islower()
False
>>> "hello world".islower()
True
>>> "".islower()
False

str.istitle zwraca True jeśli podany ciąg znaków ma tytuł case; to znaczy każde słowo zaczyna się od dużej litery, po której następuje mała litera.

>>> "hello world".istitle()
False
>>> "Hello world".istitle()
False
>>> "Hello World".istitle()
True
>>> "".istitle()
False

str.isdecimal , str.isdigit , str.isnumeric

str.isdecimal zwraca, czy ciąg jest ciągiem cyfr dziesiętnych, odpowiednim do reprezentowania liczby dziesiętnej.

str.isdigit zawiera cyfry nie w formie odpowiedniej do przedstawienia liczby dziesiętnej, takie jak cyfry w indeksie górnym.

str.isnumeric obejmuje dowolne wartości liczbowe, nawet jeśli nie są cyframi, takie jak wartości spoza zakresu 0–9.

            isdecimal    isdigit   isnumeric

12345        True        True       True
១2߃໔5        True        True       True
①²³🄅₅       False       True       True
⑩⒓          False       False      True
Five         False       False      False

Bajtowania ( bytes w Pythonie 3, str w Pythonie 2), obsługują tylko isdigit , który sprawdza tylko podstawowe cyfry ASCII.

Podobnie jak w przypadku str.isalpha , pusty ciąg znaków ma wartość False .

str.isalnum

Jest to kombinacja str.isalpha i str.isnumeric , w szczególności zwraca wartość True jeśli wszystkie znaki w danym ciągu są alfanumeryczne , to znaczy składają się ze znaków alfabetycznych lub numerycznych:

>>> "Hello2World".isalnum()
True
>>> "HelloWorld".isalnum()
True
>>> "2016".isalnum()
True
>>> "Hello World".isalnum()  # contains whitespace
False

str.isspace

Zwraca wartość True jeśli ciąg zawiera tylko znaki spacji.

>>> "\t\r\n".isspace()
True
>>> " ".isspace()
True

Czasami łańcuch wygląda na „pusty”, ale nie wiemy, czy to dlatego, że zawiera tylko białe znaki, czy w ogóle nie ma znaku

>>> "".isspace()
False

Aby objąć tę sprawę, potrzebujemy dodatkowego testu

>>> my_str = ''
>>> my_str.isspace()
False
>>> my_str.isspace() or not my_str
True

Ale najkrótszym sposobem sprawdzenia, czy łańcuch jest pusty lub zawiera tylko znaki spacji, jest użycie strip (bez argumentów usuwa wszystkie wiodące i końcowe znaki spacji)

>>> not my_str.strip()
True

str.translate: Tłumaczenie znaków w ciągu

Python obsługuje metodę translate typu str która pozwala określić tabelę translacji (używaną do zamiany), a także dowolne znaki, które powinny zostać usunięte w tym procesie.

str.translate(table[, deletechars])

Metoda maketrans ( str.maketrans w Pythonie 3 i string.maketrans w Pythonie 2) pozwala wygenerować tabelę tłumaczeń.

>>> translation_table = str.maketrans("aeiou", "12345")
>>> my_string = "This is a string!"
>>> translated = my_string.translate(translation_table)
'Th3s 3s 1 str3ng!'

Metoda translate zwraca ciąg znaków, który jest przetłumaczoną kopią oryginalnego ciągu.

Możesz ustawić argument table na None jeśli potrzebujesz tylko usunąć znaki.

>>> 'this syntax is very useful'.translate(None, 'aeiou')
'ths syntx s vry sfl'

Usuwanie niechcianych znaków wiodących / końcowych z łańcucha

Dostępne są trzy metody, które umożliwiają usuwanie znaków wiodących i końcowych z ciągu: str.strip , str.lstrip . str.rstrip i str.lstrip . str.lstrip . Wszystkie trzy metody mają tę samą sygnaturę i wszystkie trzy zwracają nowy ciąg znaków z usuniętymi niechcianymi znakami.

str.strip([chars])

str.strip działa na dany ciąg i usuwa (pasków) na początku ani spływu znaków zawartych w parametrze chars ; jeśli chars nie są dostarczane lub ma wartość None , wszystkie białe znaki są domyślnie usuwane. Na przykład:

>>> "    a line with leading and trailing space     ".strip() 
'a line with leading and trailing space'

Jeśli podano chars , wszystkie zawarte w nim znaki są usuwane z ciągu, który jest zwracany. Na przykład:

>>> ">>> a Python prompt".strip('> ')  # strips '>' character and space character 
'a Python prompt'

str.rstrip([chars]) i str.lstrip([chars])

Metody te mają podobną semantykę i argumenty z str.strip() , ich różnica polega na kierunku, od którego zaczynają. str.rstrip() zaczyna się od końca łańcucha, a str.lstrip() dzieli się od początku łańcucha.

Na przykład za pomocą str.rstrip :

>>> "     spacious string      ".rstrip()
'     spacious string'

str.lstrip używając str.lstrip :

>>> "     spacious string      ".rstrip()
'spacious string      '

Porównywanie ciągów znaków bez rozróżniania wielkości liter

Porównywanie łańcucha znaków bez rozróżniania wielkości liter wydaje się trywialne, ale tak nie jest. Ta sekcja dotyczy tylko ciągów znaków Unicode (domyślnie w Pythonie 3). Zauważ, że Python 2 może mieć subtelne słabości w stosunku do Python 3 - późniejsza obsługa Unicode jest znacznie bardziej kompletna.

Pierwszą rzeczą, na którą należy zwrócić uwagę, że konwersje z usuwaniem wielkości liter w Unicode nie są trywialne. Istnieje tekst, dla którego text.lower() != text.upper().lower() , na przykład "ß" :

>>> "ß".lower()
'ß'

>>> "ß".upper().lower()
'ss'

Powiedzmy, że chciałeś bezmyślnie porównać "BUSSE" i "Buße" . Cholera, prawdopodobnie chcesz również porównać "BUSSE" i "BUẞE" równe - to nowsza forma kapitału. Zalecanym sposobem jest użycie casefold :

>>> help(str.casefold)
"""
Help on method_descriptor:

casefold(...)
      S.casefold() -> str
    
     Return a version of S suitable for caseless comparisons.
"""

Nie używaj tylko lower . Jeśli casefold nie są dostępne, wykonanie .upper().lower() pomaga (ale tylko w niewielkim stopniu).

Następnie powinieneś rozważyć akcenty. Jeśli Twój renderer czcionek jest dobry, prawdopodobnie myślisz "ê" == "ê" - ale tak nie jest:

>>> "ê" == "ê"
False

To dlatego, że tak naprawdę jest

>>> import unicodedata

>>> [unicodedata.name(char) for char in "ê"]
['LATIN SMALL LETTER E WITH CIRCUMFLEX']

>>> [unicodedata.name(char) for char in "ê"]
['LATIN SMALL LETTER E', 'COMBINING CIRCUMFLEX ACCENT']

Najprostszym sposobem na poradzenie sobie z tym jest unicodedata.normalize . Prawdopodobnie chcesz skorzystać z normalizacji NFKD , ale sprawdź dokumentację. Potem się robi

>>> unicodedata.normalize("NFKD", "ê") == unicodedata.normalize("NFKD", "ê")
True

Aby zakończyć, tutaj jest to wyrażone w funkcjach:

import unicodedata

def normalize_caseless(text):
    return unicodedata.normalize("NFKD", text.casefold())

def caseless_equal(left, right):
    return normalize_caseless(left) == normalize_caseless(right)

Połącz listę ciągów w jeden ciąg

Ciąg może być używany jako separator do łączenia listy ciągów razem w pojedynczy ciąg przy użyciu metody join() . Na przykład możesz utworzyć ciąg, w którym każdy element na liście jest oddzielony spacją.

>>> " ".join(["once","upon","a","time"])
"once upon a time"

Poniższy przykład rozdziela elementy łańcucha za pomocą trzech łączników.

>>> "---".join(["once", "upon", "a", "time"])
"once---upon---a---time"

Przydatne stałe modułu łańcuchowego

Moduł string Pythona zapewnia stałe dla operacji związanych z łańcuchem. Aby ich użyć, zaimportuj moduł string :

>>> import string

string.ascii_letters :

ascii_lowercase i ascii_uppercase :

>>> string.ascii_letters
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'

string.ascii_lowercase :

Zawiera wszystkie małe litery ASCII:

>>> string.ascii_lowercase
'abcdefghijklmnopqrstuvwxyz'

string.ascii_uppercase :

Zawiera wszystkie wielkie litery ASCII:

>>> string.ascii_uppercase
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

string.digits :

Zawiera wszystkie znaki dziesiętne:

>>> string.digits
'0123456789'

string.hexdigits :

Zawiera wszystkie znaki szesnastkowe:

>>> string.hexdigits
'0123456789abcdefABCDEF'

string.octaldigits :

Zawiera wszystkie znaki ósemkowe:

>>> string.octaldigits
'01234567'

string.punctuation :

Zawiera wszystkie znaki, które są uważane za interpunkcję w lokalizacji C :

>>> string.punctuation
'!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'

string.whitespace :

Zawiera wszystkie znaki ASCII uważane za białe znaki:

>>> string.whitespace
' \t\n\r\x0b\x0c'

W trybie skryptowym print(string.whitespace) wypisze rzeczywiste znaki, użyj str aby otrzymać ciąg znaków zwrócony powyżej.

string.printable :

Zawiera wszystkie znaki, które są uważane za drukowalne; kombinacja string.digits , string.ascii_letters , string.punctuation i string.whitespace .

>>> string.printable
'0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~ \t\n\r\x0b\x0c'

Odwracanie ciągu

Ciąg można odwrócić za pomocą wbudowanej funkcji reverse reversed() , która pobiera ciąg i zwraca iterator w odwrotnej kolejności.

>>> reversed('hello')
<reversed object at 0x0000000000000000>
>>> [char for char in reversed('hello')]
['o', 'l', 'l', 'e', 'h']

reversed() może być zawinięty w wywołanie do ''.join() celu utworzenia łańcucha z iteratora.

>>> ''.join(reversed('hello'))
'olleh'

Podczas gdy stosowanie reversed() może być bardziej czytelne dla niewtajemniczonych użytkowników Pythona, korzystanie z rozszerzonego krojenia z krokiem -1 jest szybsze i bardziej zwięzłe. Tutaj spróbuj zaimplementować go jako funkcję:

>>> def reversed_string(main_string):
...     return main_string[::-1]
...
>>> reversed_string('hello')
'olleh'

Wyjustuj ciągi

Python udostępnia funkcje uzasadniania ciągów, umożliwiając wstawianie tekstu, aby znacznie łatwiej wyrównywać różne ciągi.

Poniżej znajduje się przykład str.ljust i str.rjust :

interstates_lengths = {
    5: (1381, 2222),
    19: (63, 102),
    40: (2555, 4112),
    93: (189,305),
}
for road, length in interstates_lengths.items():
    miles,kms = length
    print('{} -> {} mi. ({} km.)'.format(str(road).rjust(4), str(miles).ljust(4), str(kms).ljust(4)))

  40 -> 2555 mi. (4112 km.)
  19 -> 63   mi. (102  km.)
   5 -> 1381 mi. (2222 km.)
  93 -> 189  mi. (305  km.)

ljust i rjust są bardzo podobne. Oba mają parametr width i opcjonalny parametr fillchar . Każdy ciąg utworzony przez te funkcje jest co najmniej tak długi, jak parametr width , który został przekazany do funkcji. Jeśli ciąg znaków jest dłuższy niż width ustawiona, nie jest obcinany. Argument fillchar , domyślnie spacja ' ' musi być pojedynczym znakiem, a nie ciągiem wieloznakowym.

Funkcja ljust fillchar koniec łańcucha, do którego jest wywołany, za pomocą fillchar aż ma width znaków width . Funkcja rjust początek łańcucha w podobny sposób. Dlatego l i r w nazwach tych funkcji odnoszą się do strony, w której oryginalny ciąg znaków, a nie fillchar , jest umieszczony w ciągu wyjściowym.

Konwersja danych str lub bajtów i znaków Unicode

Zawartość plików i wiadomości sieciowych może reprezentować zakodowane znaki. Często trzeba je przekonwertować na Unicode, aby wyświetlać poprawnie.

W Pythonie 2 konieczna może być konwersja danych str na znaki Unicode. Domyślnie ( '' , "" itd.) Jest łańcuchem ASCII, a wszelkie wartości poza zakresem ASCII są wyświetlane jako wartości specjalne. Ciągi znaków Unicode to u'' (lub u"" itp.).

# You get "© abc" encoded in UTF-8 from a file, network, or other data source

s = '\xc2\xa9 abc'  # s is a byte array, not a string of characters
                    # Doesn't know the original was UTF-8
                    # Default form of string literals in Python 2
s[0]                # '\xc2' - meaningless byte (without context such as an encoding)
type(s)             # str - even though it's not a useful one w/o having a known encoding

u = s.decode('utf-8')  # u'\xa9 abc'
                       # Now we have a Unicode string, which can be read as UTF-8 and printed properly
                       # In Python 2, Unicode string literals need a leading u
                       # str.decode converts a string which may contain escaped bytes to a Unicode string
u[0]                # u'\xa9' - Unicode Character 'COPYRIGHT SIGN' (U+00A9) '©'
type(u)             # unicode

u.encode('utf-8')   # '\xc2\xa9 abc'
                    # unicode.encode produces a string with escaped bytes for non-ASCII characters

W Pythonie 3 konieczna może być konwersja tablic bajtów (zwanych „literałami bajtów”) na ciągi znaków Unicode. Domyślnie jest to teraz ciąg znaków Unicode, a literały bajtowe należy teraz wprowadzić jako b'' , b"" itp. Literał bajtowy zwróci wartość True to isinstance(some_val, byte) , zakładając, że some_val jest łańcuchem, który może być zakodowany jako bajty.

# You get from file or network "© abc" encoded in UTF-8

s = b'\xc2\xa9 abc' # s is a byte array, not characters
                    # In Python 3, the default string literal is Unicode; byte array literals need a leading b
s[0]                # b'\xc2' - meaningless byte (without context such as an encoding)
type(s)             # bytes - now that byte arrays are explicit, Python can show that.

u = s.decode('utf-8')  # '© abc' on a Unicode terminal
                       # bytes.decode converts a byte array to a string (which will, in Python 3, be Unicode)
u[0]                # '\u00a9' - Unicode Character 'COPYRIGHT SIGN' (U+00A9) '©'
type(u)             # str
                    # The default string literal in Python 3 is UTF-8 Unicode

u.encode('utf-8')   # b'\xc2\xa9 abc'
                    # str.encode produces a byte array, showing ASCII-range bytes as unescaped characters.

Ciąg zawiera

Python sprawia, że niezwykle intuicyjne jest sprawdzanie, czy łańcuch zawiera dany podciąg. Wystarczy użyć operatora in :

>>> "foo" in "foo.baz.bar"
True

Uwaga: testowanie pustego łańcucha zawsze da wynik True :

>>> "" in "test"
True