Python Language
문자열 메소드

통사론

• str.capitalize () -> str
• str.casefold () -> str [Python> 3.3에만 해당]
• str.center (width [, fillchar]) -> str
• str.count (sub [, start [, end]]) -> int
• str.decode (encoding = "utf-8"[, errors]) -> unicode [파이썬 2.x에서만 가능]
• str.encode (encoding = "utf-8", errors = "strict") -> 바이트
• str.endswith (접미어 [, start [, end]]) -> bool
• str.expandtabs (tabsize = 8) -> str
• str.find (sub [, start [, end]]) -> int
• str.format (* args, ** kwargs) -> str
• str.format_map (매핑) -> 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.ljust (width [, fillchar]) -> str
• str.lower () -> str
• str.lstrip ([chars]) -> str
• 정적 str.maketrans (x [, y [, z]])
• str.partition (sep) -> (머리, sep, 꼬리)
• str.replace (old, new [, count]) -> str
• str.rfind (sub [, start [, end]]) -> int
• str.rindex (sub [, start [, end]]) -> int
• str.rjust (width [, fillchar]) -> str
• str.rpartition (sep) -> (머리, sep, 꼬리)
• str.rsplit (sep = None, maxsplit = -1) -> 문자열 목록
• str.rstrip ([chars]) -> str
• str.split (sep = None, maxsplit = -1) -> 문자열 목록
• str.splitlines ([keepends]) -> 문자열 목록
• str.startswith (접두사 [, start [, end]]) -> 책
• str.strip ([chars]) -> str
• str.swapcase () -> str
• str.title () -> str
• str.translate (table) -> str
• str.upper () -> str
• str.zfill (width) -> str

비고

문자열의 대문자 사용 변경

파이썬의 문자열 유형은 문자열의 대문자로 작동하는 많은 함수를 제공합니다. 여기에는 다음이 포함됩니다.

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

유니 코드 문자열 (파이썬 3에서는 기본값)을 사용하면 이러한 연산이 1 : 1 매핑이 아니 거나 되돌릴 수 있습니다. 이러한 작업의 대부분은 정규화가 아닌 표시 목적으로 사용됩니다.

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

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

str.upper()

str.upper 는 문자열의 모든 문자를 가져 와서 대문자로 변환합니다 (예 :

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

str.lower()

str.lower 는 그 반대입니다. 문자열의 모든 문자를 소문자로 변환합니다.

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

str.capitalize()

str.capitalize 는 문자열의 대문자로 된 버전을 반환합니다. 즉, 첫 번째 문자를 대문자로, 나머지는 더 낮게 만듭니다.

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

str.title()

str.title 은 문자열의 제목이 str.title 버전을 반환합니다. 즉, 단어의 시작 부분에있는 모든 문자는 대문자로 만들고 나머지는 모두 소문자로 str.title .

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

str.swapcase()

str.swapcase 는 모든 소문자가 대문자로 스왑되고 대문자가 모두 lower로 str.swapcase 새 문자열 객체를 반환합니다.

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

str 클래스 메소드로서의 사용법

이러한 메소드는 문자열 객체 (위 그림 참조) 또는 str 클래스의 클래스 메소드 ( str.upper 등을 명시 적으로 호출 함)에서 호출 할 수 있습니다.

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

A, 말에서 한 번에 여러 문자열에 다음 방법 중 하나를 적용 할 때 가장 유용 map 기능.

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

구분 기호를 기반으로 문자열을 문자열 목록으로 분할합니다.

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

str.split 은 문자열을 취하여 원래 문자열의 하위 문자열 목록을 반환합니다. 이 동작은 sep 인수의 제공 여부에 따라 다릅니다.

sep 가 제공되지 않거나 None 이면 공백이있는 곳이면 어디에서나 분할이 수행됩니다. 그러나 앞과 뒤의 공백은 무시되고 여러 개의 연속 공백 문자는 공백 문자 하나와 동일하게 취급됩니다.

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

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

>>> "            ".split()
[]

sep 매개 변수는 구분 기호 문자열을 정의하는 데 사용할 수 있습니다. 원래. 자열은 분리. 자열이 _ 생하는 곳에 나뉘며, 분리. 자 자체는 v립니다. 여러 개의 연속 구분 기호는 단일 어커런스와 동일하게 취급 되지 않고 빈 문자열을 작성하게합니다.

>>> "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.']

기본값은 구분 기호가 나타날 때마다 분할하는 것이지만 maxsplit 매개 변수는 발생하는 분할 수를 제한합니다. 기본값 -1 은 제한이 없음을 의미합니다.

>>> "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 ( "오른쪽 분할")은 maxsplit 이 지정되면 str.split ( "왼쪽 분할")과 다릅니다. 분할은 처음보다는 문자열의 끝에서 시작됩니다.

>>> "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', '.']

참고 : Python 은 수행되는 분할 의 최대 수를 지정하지만 다른 대부분의 프로그래밍 언어는 생성 된 하위 문자열 의 최대 수를 지정합니다. 코드를 이식하거나 비교할 때 혼란이 생길 ​​수 있습니다.

한 하위 문자열의 모든 항목을 다른 하위 문자열로 바꾸기

파이썬의 str 타입은 또한 하나의 서브 스트링의 발생을 주어진 스트링의 다른 서브 스트링으로 대체하는 메소드를 가지고있다. 더 까다로운 경우에는 re.sub 를 사용할 수 있습니다.

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

str.replace 두 인수 얻어 old 과 new 포함하는 old 에 의해 대체 될 서브 스트링 new 서브 문자열. 선택적 인수 count 는 수행 할 대체 count 지정합니다.

예를 들어 다음 문자열에서 'foo' 를 'spam' 으로 바꾸려면 old = 'foo' 및 new = 'spam' 하여 str.replace 를 호출 할 수 있습니다.

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

주어진 문자열에 old 인수와 일치하는 여러 예제가 들어 있으면 모든 항목이 new 제공된 값으로 대체됩니다.

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

물론 우리가 count 값을 제공하지 않는 한. 이 경우 count 횟수가 대체됩니다.

>>> """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과 f-strings : 값을 문자열로 포맷하십시오.

파이썬은 버전 2.6에서 도입 된 str.format 함수와 버전 3.6에서 도입 된 f- 문자열을 통해 문자열 보간 및 포맷 기능을 제공합니다.

주어진 다음의 변수들 :

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

다음 내용은 모두 동일합니다.

"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}"

참고로 Python은 문자열 형식에 대한 C 스타일 한정자도 지원합니다. 아래 예제는 위와 동일하지만 유연성, 표기법의 일관성 및 확장 str.format 이점 때문에 str.format 버전이 선호됩니다.

"%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)

str.format 보간에 사용되는 중괄호는 문자열 서식을 지정할 때 중복을 줄이기 위해 번호 매기기가 가능합니다. 예를 들어, 다음은 동일합니다.

"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")

공식 python 문서는 늘 그렇듯이 충분히 철저하지만 pyformat.info 에는 상세한 설명이 들어있는 훌륭한 예제 세트가 있습니다.

또한 { 및 } 문자는 이중 대괄호를 사용하여 이스케이프 처리 할 수 ​​있습니다.

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

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

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

자세한 내용은 문자열 서식 을 참조하십시오. str.format() 은 PEP 3101 에서 제안되었고 f-strings는 PEP 498 에서 제안되었습니다.

부분 문자열이 문자열에 나타나는 횟수 계산

하나의 방법은 다른 문자열 str.count 에서 하위 문자열의 발생 횟수를 계산하는 데 사용할 수 있습니다.

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

str.count 는 다른 문자열에있는 하위 문자열 sub 의 중첩되지 않는 항목의 수를 나타내는 int 를 반환합니다. 선택적 인수 start 및 end 는 검색이 시작될 end 및 end 나타냅니다. 기본적으로 start = 0 과 end = len(str) 으로 전체 문자열을 검색합니다.

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

start 다른 값을 지정하면 end 가보다 지역화 된 검색 및 카운트를 얻을 수 있습니다. 예를 들어 start 가 13 과 같으면 다음과 같습니다.

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

다음과 같습니다.

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

문자열의 시작 및 끝 문자 테스트

파이썬에서 주어진 문자열의 시작과 끝을 테스트하기 위해 str.startswith() 와 str.endswith() 메소드를 사용할 수 있습니다.

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

이름에서 알 수 있듯이 str.startswith 는 주어진 문자열이 prefix 에서 주어진 문자로 시작하는지 테스트하는 데 사용됩니다.

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

선택적 인수 인 start 와 end 는 테스트가 시작되고 끝나는 시작과 끝 지점을 지정합니다. 다음 예제에서 시작 값 2 를 지정하면 문자열이 위치 2 에서 검색됩니다.

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

s[2] == 'i' 이고 s[3] == 's' 이므로 True 됩니다.

또한 tuple 을 사용하여 문자열 집합으로 시작하는지 확인할 수 있습니다

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

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

str.endswith 는 str.startswith 와 정확히 비슷하지만 시작 문자가 아닌 끝 문자를 검색한다는 점이 다릅니다. 예를 들어, 문자열이 완전히 끝나는 지 테스트하려면 다음과 같이 작성할 수 있습니다.

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

startswith 와 같이 하나 이상의 문자를 끝 시퀀스로 사용할 수 있습니다.

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

또한 tuple 을 사용하여 문자열 집합으로 끝나는 지 검사 할 수 있습니다

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

문자열이 무엇으로 구성되어 있는지 테스트하기

파이썬의 str 타입에는 문자열의 내용을 평가하는 데 사용할 수있는 여러 가지 메소드가 있습니다. 이들은 str.isalpha , str.isdigit , str.isalnum , str.isspace 입니다. 대문자 사용은 str.isupper , str.islower 및 str.istitle 하여 테스트 할 수 있습니다.

str.isalpha

str.isalpha 는 인수를 취하지 않고 지정된 문자열의 모든 문자가 알파벳 인 경우 True 반환합니다. 예를 들면 다음과 같습니다.

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

가장자리의 경우, 빈 문자열은 "".isalpha() 와 함께 사용되면 False 평가됩니다.

str.isupper , str.islower , str.istitle

이 메소드는 주어진 문자열에서 대문자를 테스트합니다.

str.isupper 는 주어진 문자열의 모든 문자가 대문자이면 True 를 반환하고 False 않으면 False 를 반환하는 메서드입니다.

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

반대로 str.islower 는 주어진 문자열의 모든 문자가 소문자이면 True 를 반환하고 False 않으면 False 를 반환하는 메서드입니다.

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

str.istitle 은 주어진 문자열에 제목이있는 경우 True 반환합니다. 즉, 모든 단어는 대문자와 소문자로 시작됩니다.

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

str.isdecimal , str.isdigit , str.isnumeric

str.isdecimal 은 문자열이 10 진수를 나타내는 데 적합한 십진수 시퀀스인지 여부를 반환합니다.

str.isdigit 에는 십진수를 나타내는 데 적합한 형식이 아닌 숫자 (예 : 위 첨자)가 포함됩니다.

str.isnumeric 은 숫자가 아닐지라도 0-9 범위를 벗어난 값과 같은 모든 숫자 값을 포함합니다.

            isdecimal    isdigit   isnumeric

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

Bytestrings (Python 3의 bytes , Python 2의 str 은 isdigit 만 지원합니다. isdigit 은 기본 ASCII 숫자 만 검사합니다.

str.isalpha 와 마찬가지로 빈 문자열은 False 평가됩니다.

str.isalnum

이것은 str.isalpha 와 str.isnumeric 의 조합입니다. 특히 지정된 문자열의 모든 문자가 영숫자 인 경우 True 평가됩니다. 즉, 알파벳 또는 숫자로 구성됩니다.

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

str.isspace

문자열에 공백 문자 만 포함되어 있으면 True 평가됩니다.

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

때로는 문자열이 "비어 있음"으로 보일 수도 있지만 공백 또는 문자가 전혀 포함되어 있지 않기 때문에 문자열인지 알 수 없습니다

>>> "".isspace()
False

이 경우를 대비하기 위해 추가 테스트가 필요합니다.

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

그러나 문자열이 비어 있거나 공백 문자가 포함되어 있는지 테스트하는 가장 짧은 방법은 strip 을 사용하는 것 strip (인수없이 선행 공백 문자와 후행 공백 문자를 모두 제거합니다)

>>> not my_str.strip()
True

str.translate : 문자열의 문자 변환

파이썬은 str 타입에 대해 translate 메소드를 지원합니다.이 메소드는 치환에서 사용되는 변환 테이블과 프로세스에서 삭제되어야하는 문자를 지정할 수 있도록합니다.

str.translate(table[, deletechars])

maketrans 방법 ( str.maketrans 파이썬 3에서와 string.maketrans 파이썬 2)는 변환 테이블을 생성 할 수 있습니다.

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

translate 메소드는 원래 문자열의 번역 사본 인 문자열을 리턴합니다.

문자를 삭제하기 None table 인수를 None 설정할 수 있습니다.

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

원하지 않는 앞 / 뒤 문자를 문자열에서 스트립하기

str.strip , str.rstrip 및 str.lstrip 과 같이 문자열에서 선행 및 후행 문자를 제거하는 세 가지 방법이 제공됩니다. 세 가지 메소드 모두 동일한 시그니처를 가지며 세 개의 메소드 모두 원하지 않는 문자가 제거 된 새 문자열 오브젝트를 리턴합니다.

str.strip([chars])

str.strip 은 지정된 문자열에서 작동하고 chars 인수에 포함 된 선행 문자 또는 후행 문자를 제거 (제거)합니다. chars 가 제공되지 않거나 None 이면 기본적으로 모든 공백 문자가 제거됩니다. 예 :

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

chars 가 제공되면 문자열에 포함 된 모든 문자가 문자열에서 제거되고 반환됩니다. 예 :

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

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

이러한 메서드는 str.strip() 과 비슷한 의미 및 인수를 가지므로 해당 메서드의 시작과 str.strip() 의 차이가 있습니다. str.rstrip() 은 문자열의 끝에서 시작하는 반면 str.lstrip() 은 문자열의 끝에서 시작합니다.

예를 들어, str.rstrip 사용 :

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

동안, str.lstrip 사용 :

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

대소 문자를 구별하지 않는 문자열 비교

대소 문자를 구별하지 않는 방식으로 문자열을 비교하는 것은 사소한 것처럼 보이지만 그렇지 않습니다. 이 섹션에서는 유니 코드 문자열 만 고려합니다 (Python 3의 기본값). Python 2는 Python 3에 비해 미묘한 약점이있을 수 있습니다. 나중에 유니 코드 처리가 훨씬 더 완벽합니다.

유니 코드에서 대소 문자를 제거하는 변환이 사소한 것은 아니라는 점에 유의해야합니다. "ß" 와 같이 text.lower() != text.upper().lower() 텍스트가 있습니다.

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

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

그러나 "BUSSE" 와 "Buße" 비교할 필요가 없다고 가정 해 봅시다. 지옥, 당신은 아마 "BUSSE" 와 "BUẞE" 평등을 비교하기를 원할 것입니다. 그것은 새로운 자본 형태입니다. casefold 를 사용하는 것이 좋습니다.

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

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

lower 사용하지 마십시오. casefold 를 사용할 수없는 경우 casefold .upper().lower() 하면 도움이됩니다 (그러나 다소 만).

그렇다면 액센트를 고려해야합니다. 폰트 렌더러가 훌륭하다면 "ê" == "ê" 라고 생각할 수도 있지만 그렇지 않습니다 :

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

이것은 실제로 있기 때문입니다.

>>> 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']

이를 처리하는 가장 간단한 방법은 unicodedata.normalize 입니다. 아마도 NFKD 정규화를 사용하고 싶지만 설명서를 확인해보십시오. 그렇다면

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

마무리하려면 여기를 함수로 표현합니다.

import unicodedata

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

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

문자열 목록을 하나의 문자열에 조인하십시오.

문자열을 구분 기호로 사용하여 join() 메서드를 사용하여 문자열 목록을 단일 문자열로 함께 결합 할 수 있습니다. 예를 들어 목록의 각 요소가 공백으로 구분되는 문자열을 만들 수 있습니다.

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

다음 예제에서는 문자열 요소를 세 개의 하이픈으로 구분합니다.

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

문자열 모듈의 유용한 상수

파이썬의 string 모듈은 문자열 관련 연산을위한 상수를 제공합니다. string 모듈을 사용하려면 다음을 입력하십시오.

>>> import string

string.ascii_letters :

ascii_lowercase 와 ascii_uppercase 연결 :

>>> string.ascii_letters
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'

string.ascii_lowercase :

모든 소문자 ASCII 문자가 들어 있습니다.

>>> string.ascii_lowercase
'abcdefghijklmnopqrstuvwxyz'

string.ascii_uppercase :

모든 대문자 ASCII 문자가 들어 있습니다.

>>> string.ascii_uppercase
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

string.digits :

모든 10 진수 문자가 포함됩니다.

>>> string.digits
'0123456789'

string.hexdigits :

모든 16 진수 문자를 포함합니다 :

>>> string.hexdigits
'0123456789abcdefABCDEF'

string.octaldigits :

모든 8 진수 문자를 포함합니다 :

>>> string.octaldigits
'01234567'

string.punctuation :

C 로켈의 구두점으로 간주되는 모든 문자를 포함합니다.

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

string.whitespace :

공백으로 간주되는 모든 ASCII 문자가 포함됩니다.

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

스크립트 모드에서 print(string.whitespace) 는 실제 문자를 인쇄하고, str 을 사용하여 위에 반환 된 문자열을 가져옵니다.

string.printable :

인쇄 가능한 것으로 간주되는 모든 문자를 포함합니다. 의 조합 string.digits , string.ascii_letters , string.punctuation 및 string.whitespace .

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

문자열 반전

문자열은 내장 된 reversed() 함수를 사용하여 역순으로 처리 할 수 ​​있습니다.이 함수는 문자열을 사용하고 역순으로 반복자를 반환합니다.

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

reversed() 는 반복자에서 문자열을 만들기 위해 ''.join() 에 대한 호출에 래핑 될 수 있습니다.

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

reversed() 사용하는 것은 초기화되지 않은 Python 사용자에게 더 읽기 쉬울 수 있지만 -1 의 단계로 확장 슬라이스를 사용하는 것이 더 빠르고 간결합니다. 여기서는 함수로 구현하십시오.

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

문자열 정렬

파이썬은 문자열을 정당화하는 기능을 제공하여 텍스트 패딩을 사용하여 다양한 문자열을 훨씬 쉽게 정렬 할 수 있습니다.

아래는 str.ljust 와 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 와 rjust 는 매우 유사합니다. 둘 다 width 매개 변수와 선택적 fillchar 매개 변수가 있습니다. 이 함수에 의해 생성 된 문자열은 적어도 함수에 전달 된 width 매개 변수만큼 길다. 문자열이 width 보다 길면 잘리지 않습니다. 기본적으로 공백 문자 ' ' fillchar 인수는 다중 문자 문자열이 아닌 단일 문자 여야합니다.

ljust 함수는 width 길 때까지 fillchar 호출 된 문자열의 끝을 ljust . rjust 함수는 문자열의 시작 부분을 비슷한 방식으로 채 rjust . 따라서이 함수의 이름에있는 l 과 r 은 fillchar 아닌 원래 문자열이 출력 문자열에 위치한다는 측면을 나타냅니다.

str 또는 bytes 데이터와 유니 코드 문자 간의 변환

파일 및 네트워크 메시지의 내용은 인코딩 된 문자를 나타낼 수 있습니다. 적절한 표시를 위해 종종 유니 코드로 변환해야합니다.

파이썬 2에서는 str 데이터를 유니 코드 문자로 변환해야 할 수도 있습니다. 기본값 ( '' , "" 등)은 ASCII 문자열이며 ASCII 범위를 벗어난 값은 이스케이프 된 값으로 표시됩니다. 유니 코드 문자열은 u'' (또는 u"" 등)입니다.

# 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

Python 3에서는 바이트 배열 ( '바이트 리터럴'이라고 함)을 유니 코드 문자 열로 변환해야 할 수 있습니다. 기본값은 현재 유니 코드 문자열이며, bytestring 리터럴은 지금과 같이 입력해야합니다 b'' , b"" , 반환 등 바이트 문자 그대로의 True 에 isinstance(some_val, byte) 가정 some_val 인코딩 할 수있는 문자열로 바이트 수.

# 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.

문자열 포함

파이썬은 문자열에 주어진 부분 문자열이 있는지를 확인하는 것을 매우 직관적으로 만듭니다. 그냥 in 연산자를 사용하십시오.

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

참고 : 빈 문자열을 테스트하면 항상 True .

>>> "" in "test"
True