Format
우리는 지금까지 텍스트 서식을 거의 무시해 왔다. 2장에는 몇 가지 문자열 정렬 기능이 나와 있으며 코드 예제는 간단한 인쇄() 문을 사용하거나 대화형 인터프리터가 값을 표시하도록 합니다. 하지만 이제는 다양한 형식을 사용하여 데이터 값을 문자열로 변환하는 방법, 즉 문자열 내부에 값을 넣는 방법에 대해 알아보아야 합니다. 이를 통해 보고서 및 기타 출력물을 생성할 수 있으며, 이를 위해 분배가 필요할 수 있습니다.
Python은 문자열을 포맷하는 두 가지 방법, 즉 느슨하게 옛날 스타일과 새로운 스타일이라고 불린다. 두 스타일 모두 Python 2 및 3에서 지원됩니다(Python 2.6 이상의 새로운 스타일). 구식이 더 간단하니까 거기서부터 시작하죠.
이전 스타일(% 포함)
이전 스타일의 문자열 형식에는 형식 문자열% 데이터가 있습니다. 문자열 내부에는 보간 시퀀스가 있습니다. 아래는 가장 간단한 시퀀스가 % 다음에 형식화할 데이터 유형을 나타내는 문자가 있음을 보여준다.
%s string
%d decimal integer
%x hex integer
%o octal integer
%f decimal float
%e exponential float
%g decimal or exponential float %% a literal%
다음은 몇 가지 간단한 예입니다. 첫째, 정수:
>>> '%s' % 42
'42'
>>> '%d' % 42
'42'
>>> '%x' % 42
'2a'
>>> '%o' % 42
'52'
플로트:
>>> '%s' % 7.03
'7.03'
>>> '%f' % 7.03
'7.030000'
>>> '%e' % 7.03
'7.030000e+00'
>>> '%g' % 7.03
'7.03'
정수 및 리터럴 %:
>>> '%d%%' % 100
'100%'
일부 문자열 및 정수 보간법:
>>> actor = 'Richard Gere'
>>> cat = 'Chester'
>>> weight = 28
>>> "My wife's favorite actor is %s" % actor
"My wife's favorite actor is Richard Gere"
>>> "Our cat %s weighs %s pounds" % (cat, weight)
'Our cat Chester weighs 28 pounds'
문자열 내부의 %s은 문자열을 보간한다는 의미입니다. 문자열에 나타나는 % 개수는 % 이후의 데이터 항목 개수와 일치합니다. 행위자와 같은 단일 데이터 항목은 % 바로 뒤에 있습니다. (cat, weight)와 같은 튜플(괄호로 묶고 쉼표로 구분)로 여러 데이터를 그룹화해야 합니다.
가중치가 정수임에도 불구하고 문자열 안에 있는 %s이(가) 문자열로 변환했습니다.
%와 형식 지정자 사이에 다른 값을 추가하여 최소값을 지정할 수 있습니다.
최대 너비, 정렬 및 문자 채우기:
변수의 경우 정수 n, 플로트 f 및 문자열 s를 정의하겠습니다.
>>>n=42 >>>f=7.03
>>> s = 'string cheese'
기본 너비를 사용하여 형식 지정:
>>>'%d%f%s'%(n,f,s) '42 7.030000 string cheese'
각 변수에 대해 최소 필드 너비를 10자로 설정하고 오른쪽에 정렬하여 왼쪽의 사용되지 않는 부분을 공백으로 채웁니다.
>>> '%10d %10f %10s' % (n, f, s)
' 42 7.030000 string cheese'
동일한 필드 너비를 사용하지만 왼쪽으로 정렬합니다.
>>> '%-10d %-10f %-10s' % (n, f, s)
'42 7.030000 string cheese'
이번에는 필드 너비는 같지만 최대 문자 너비는 4이고 오른쪽에 정렬됩니다. 이 설정을 사용하면 문자열이 잘리고 소수점 뒤의 부동자리가 4자리로 제한됩니다.
>>> '%10.4d %10.4f %10.4s' % (n, f, s)
' 0042 7.0300 stri'
이전과 동일하지만, 오른쪽 정렬:
>>> '%.4d %.4f %.4s' % (n, f, s)
'0042 7.0300 stri'
마지막으로, 인수에서 필드 너비를 하드 코딩하지 않고 가져옵니다.
>>> '%*.*d %*.*f %*.*s' % (10, 4, n, 10, 4, f, 10, 4, s)
' 0042 7.0300 stri'
New style formatting with {} and format
이전 스타일 형식은 여전히 지원됩니다. 버전 2.7에서 동결되는 파이썬 2에서는 영원히 지원될 것이다. 그러나 파이썬 3을 사용하는 경우에는 새로운 스타일 포맷이 권장됩니다.
가장 간단한 용법은 다음과 같습니다.
>>> '{} {} {}'.format(n, f, s)
'42 7.03 string cheese'
이전 형식의 인수는 해당 자리 표시자의 %가 문자열에 나타나는 순서로 제공되어야 합니다. 새 유형을 사용하여 순서를 지정할 수 있습니다.
>>> '{2} {0} {1}'.format(f, s, n)
'42 7.03 string cheese'
값 0은 첫 번째 인수인 f를 가리킨 반면, 1은 문자열 s를 가리켰고 2는 마지막 인수인 정수 n을 가리켰습니다.
인수는 사전 또는 명명된 인수일 수 있으며 지정자에는 다음과 같은 인수의 이름이 포함될 수 있습니다.
>>> '{n} {f} {s}'.format(n=42, f=7.03, s='string cheese')
'42 7.03 string cheese'
다음 예에서는 세 가지 값을 사전으로 결합해 보겠습니다. 다음과 같습니다.
>>> d = {'n': 42, 'f': 7.03, 's': 'string cheese'}
다음 예제에서 {0}은(는) 전체 사전이고 {1}은(는) 문자열 '기타'입니다.
사전 다음에 나오는 내용:
>>> '{0[n]} {0[f]} {0[s]} {1}'.format(d, 'other')
'42 7.03 string cheese other'
이 예들은 모두 기본 형식으로 인수를 인쇄했습니다. 이전 형식에서는 문자열의 % 뒤에 형식 지정자를 사용할 수 있지만 새 형식에서는 : 뒤에 붙입니다. 첫째, 위치 인수:
>>> '{0:d} {1:f} {2:s}'.format(n, f, s)
'42 7.030000 string cheese'
이 예에서는 동일한 값을 사용하지만 명명된 인수와 같습니다.
>>> '{n:d} {f:f} {s:s}'.format(n=42, f=7.03, s='string cheese')
'42 7.030000 string cheese'
다른 옵션(최소 필드 너비, 최대 문자 너비, 정렬 등)도 지원됩니다.
최소 필드 너비 10, 오른쪽 정렬(기본값):
>>> '{0:10d} {1:10f} {2:10s}'.format(n, f, s)
' 42 7.030000 string cheese'
앞의 예제와 동일하지만 > 문자는 오른쪽 정렬을 더 명확하게 만듭니다.
>>> '{0:>10d} {1:>10f} {2:>10s}'.format(n, f, s)
' 42 7.030000 string cheese'
최소 필드 폭 10, 왼쪽 정렬:
>>> '{0:<10d} {1:<10f} {2:<10s}'.format(n, f, s)
'42 7.030000 string cheese'
최소 필드 폭 10, 가운데:
>>> '{0:^10d} {1:^10f} {2:^10s}'.format(n, f, s)
' 42 7.030000 string cheese'
이전 스타일에서 한 가지 변경 사항이 있습니다. 즉, 소수점 뒤의 정밀도 값은 부동 소수점 뒤의 자릿수와 문자열의 최대 문자 수를 의미하지만 정수에 대해서는 사용할 수 없습니다.
>>> '{0:>10.4d} {1:>10.4f} {2:10.4s}'.format(n, f, s)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: Precision not allowed in integer format specifier >>> '{0:>10d} {1:>10.4f} {2:>10.4s}'.format(n, f, s)
' 42 7.0300 stri'
마지막 옵션은 채우기 문자입니다. 공백이 아닌 다른 출력 필드를 채우려면 :, 정렬(<, >, ^) 또는 너비 지정 피어 바로 앞에 놓습니다.
>>> '{0:!^20s}'.format('BIG SALE')
'!!!!!!BIG SALE!!!!!!'
Match with Regular Expressions
이전포스팅에서는 간단한 문자열 연산에 대해 다루었다. 입문 정보로 무장한 여러분은 명령행에서 .py로 끝나는 모든 파일 이름을 나열하는 것을 의미하는 ls *.py와 같은 단순한 "와일드카드" 패턴을 사용해 본 적이 있을 것이다.
이제 정규식을 사용하여 더 복잡한 패턴 일치를 살펴볼 차례입니다. 이것들은 우리가 수입할 표준 모듈 re에 제공된다. 일치시킬 문자열 패턴과 일치시킬 소스 문자열을 정의합니다. 단순 일치의 경우 용도는 다음과 같습니다.
result = re.match('You', 'Young Frankenstein')
여기서 'You'가 패턴이고 'Young Frankenstein'이 그 근원이다. 즉, 당신이 만든 끈이다.
want to check. match()는 소스가 패턴으로 시작하는지 여부를 확인합니다.
더 복잡한 일치의 경우 먼저 패턴을 컴파일하여 일치 속도를 높일 수 있습니다.
나중에:
youpattern = re.compile('You')
그런 다음 컴파일된 패턴에 대해 일치를 수행할 수 있습니다.
result = youpattern.match('Young Frankenstein')
match()만이 패턴과 소스를 비교하는 유일한 방법은 아니다. 다음은 사용할 수 있는 몇 가지 다른 방법입니다.
• 검색 결과 첫 번째 일치 항목이 있는 경우 반환됩니다.
• findall은 모든 비반복 일치 항목(있는 경우) 목록을 반환합니다.
• 분할은 패턴과 일치할 때 소스를 분할하고 문자열 조각 목록을 반환합니다.
• 하위 항목에서는 다른 교체 인수를 사용하여 패턴별로 일치하는 소스의 모든 부분을 교체로 변경합니다.
Exact match with match()
'Young Frankenstein'이라는 문자열은 'You'라는 단어로 시작되나요? 설명과 함께 몇 가지 코드가 있습니다.
>>> import re
>>> source = 'Young Frankenstein'
>>> m = re.match('You', source) # match starts at the beginning of source >>> if m: # match returns an object; do this to see what matched
... print(m.group())
...
You
>>> m = re.match('^You', source) # start anchor does the same
>>> if m:
... print(m.group())
...
You
'프랭크'는 어때?
>>> m = re.match('Frank', source) >>> if m:
... print(m.group())
...
이번에는 일치하는()이 반환되지 않았고 if가 인쇄 문을 실행하지 않았습니다. 앞에서 말했듯이 패턴이 원본의 시작 부분에 있을 경우에만 일치()가 작동합니다. 그러나 패턴이 있는 경우 검색()이 작동합니다.
>>> m = re.search('Frank', source) >>> if m:
... print(m.group())
...
Frank
패턴을 변경해 보겠습니다.
>>> m = re.match('.*Frank', source) >>> if m: # match returns an object ... print(m.group())
...
Young Frank
패턴을 변경합니다.• .는 단일 문자를 의미합니다.
• *는 앞의 모든 것을 의미합니다. 합쳐서 .*는 임의의 수의 문자 행위자(심지어 0)를 의미합니다.
• Frank는 우리가 일치시키고자 했던 문구입니다. match()는 일치하는 문자열을 반환했습니다.프랭크: '젊은 프랭크'.
First match with search()
검색()을 사용하여 .* 와일드카드를 사용하지 않고도 소스 문자열 'Young Frankenstein'의 아무 곳에서나 'Frank' 패턴을 찾을 수 있습니다.
>>> m = re.search('Frank', source) >>> if m: # search returns an object ... print(m.group())
...
Frank
All matches with findall()
위의 예들은 한 가지 일치만 찾았다. 하지만 단일 문자 문자열 'n'의 인스턴스 수를 알고 싶다면 어떻게 해야 할까요?
>>> m = re.findall('n', source)
>>> m # findall returns a list ['n', 'n', 'n', 'n']
>>> print('Found', len(m), 'matches') Found 4 matches
'n' 뒤에 오는 글자는 어떤가?
>>> m = re.findall('n.', source)
>>> m
['ng', 'nk', 'ns']
그것이 최종 'n'과 일치하지 않는다는 것을 주목하라. 우리는 'n' 뒤에 오는 문자는 ?:의 옵션이라고 말할 필요가 있습니다.
>>> m = re.findall('n.?', source)
>>> m
['ng', 'nk', 'ns', 'n']
Split at matches with split()
다음 예제에서는 일반 문자열 분할() 메서드와 같이 단순 문자열이 아닌 패턴별로 목록으로 문자열을 분할하는 방법을 보여 줍니다.
>>> m = re.split('n', source)
>>> m # split returns a list ['You', 'g Fra', 'ke', 'stei', '']
Patterns: special characters
정규식에 대한 많은 설명은 정규식을 정의하는 방법에 대한 모든 세부 정보에서 시작됩니다. 그건 실수라고 생각해요. 정규 표현은 그 자체로 그리 작지 않은 언어이며, 여러분의 머릿속에 한번에 들어가기에는 너무 많은 세부 사항들을 가지고 있다. 그들은 너무 많은 펑크 표현을 써서 마치 만화 속 캐릭터들이 욕을 하는 것처럼 보인다.
벨트 아래에 있는 식(일치), 검색() 및 findall() 및 sub()을 사용하여 작성에 대한 세부 정보를 살펴보겠습니다. 사용자가 만든 패턴은 다음 함수에 적용됩니다.
기본 사항을 살펴보았습니다.
• 특수하지 않은 문자와 문자 그대로 일치
• 가 있는 \n을 제외한 모든 단일 문자.
• *가 포함된 임의의 숫자(0 포함)
• 선택 사항(0 또는 1)은?
첫째, 특수 문자는 아래에 나와 있습니다.
\d a single digit
\D a single non-digit
\w an alphanumeric character
\W a non-alphanumeric character
\s a whitespace character
\S a non-whitespace character
\b a word boundary (between a\wand a\W, in either order) \B a non-word boundary
파이썬 문자열 모듈에는 테스트에 사용할 수 있는 미리 정의된 문자열 상수가 있습니다. 인쇄 가능한 ASCII 문자(경우, 숫자, 공백 문자, 구두점 등): 100개의 인쇄 가능한 ASCII 문자를 사용합니다.
>>> import string
>>> printable = string.printable
>>> len(printable)
100
>>> printable[0:50] '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMN'
>>> printable[50:] 'OPQRSTUVWXYZ!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~ \t\n\r\x0b\x0c'
인쇄 가능한 문자는 어떤 것입니까?
>>> re.findall('\d', printable)
['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
숫자, 문자 또는 밑줄 문자는 무엇입니까?
>>> re.findall('\w', printable)
['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b',
'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L',
'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
'Y', 'Z', '_']
공백은 무엇입니까?
>>> re.findall('\s', printable)
[' ', '\t', '\n', '\r', '\x0b', '\x0c']
정규식은 ASCII에만 국한되지 않습니다. \d는 단지 ASCII 문자 '0'에서 '9'까지가 아니라 유니코드가 숫자를 호출하는 것과 일치합니다. FileFormat.info에서 ASCII가 아닌 두 개의 소문자를 추가해 보겠습니다.
이 테스트에서는 다음을 포함시킵니다.
• 세 개의 ASCII 문자
• \w와 일치하지 않아야 하는 세 개의 구두점 기호
• 서클플렉스를 포함한 유니코드 라틴 소형 문자 E(\u00ea)
• BREVE가 포함된 유니코드 라틴 소형 문자 E(\u0115)
- >>> x = 'abc' + '-/*' + '\u00ea' + '\u0115'
예상대로 이 패턴에는 다음과 같은 문자만 있습니다.
- >>> re.findall('\w', x)
- ['a', 'b', 'c', 'ê', 'ĕ']
Patterns: using specifiers
이제 아래에 나와 있는 일반적인 ex press pressions의 주요 패턴 지정자를 사용하여 "punctionation pizza"를 만들어 봅시다.
표에서 expr 및 다른 기울임꼴 단어는 유효한 정규식을 의미합니다.
abc
(expr) expr1|expr2
.
^
$
prev?
prev*
prev *?
prev+
prev +? prev{m} prev{m, n} prev{m, n}? [abc] [^abc]
prev (?= next ) prev (?! next ) (?<=prev)next (?<!prev)next
literal abc
expr
expr1 or expr2
any character except \n start of source string end of source string zero or one prev
zero or more prev, as many as possible zero or more prev, as few as possible one or more prev, as many as possible one or more prev, as few as possible m consecutive prev
m to n consecutive prev, as many as possible m to n consecutive prev, as few as possible aorborc(same asa|b|c)
not (aorborc)
prev if followed by next prev if not followed by next next if preceded by prev next if not preceded by prev
이 예들을 읽으려고 할 때 여러분의 눈은 영구적으로 교차할 수 있습니다. 먼저 소스 문자열을 정의하겠습니다.
>>> source = '''I wish I may, I wish I might
... Have a dish of fish tonight.'''
첫째, 어디서든 소원을 찾으세요.
>>> re.findall('wish', source)
['wish', 'wish']
다음으로, 어디에서나 소원이나 물고기를 찾으세요.
>>> re.findall('wish|fish', source)
['wish', 'wish', 'fish']
시작 부분에서 소원을 찾으세요.
>>> re.findall('^wish', source)
[]
시작 부분에서 내 바람 찾기:
>>> re.findall('^I wish', source)
['I wish']
마지막에 물고기 찾기:
>>> re.findall('fish$', source)
[]
마지막에 물고기 찾기:
마지막으로, 오늘밤 물고기를 찾으세요.
>>> re.findall('fish tonight.$', source)
['fish tonight.']
^ 및 $ 문자를 앵커(anchor)라고 합니다. ^ 검색의 시작 부분에 앵커(anchor)를 지정하고, $는 마침표를 포함하여 줄 끝에 있는 모든 문자와 일치하므로 효과가 있었습니다. 좀 더 정확히 말하자면, 우리는 문자 그대로 일치시키기 위해 점을 탈출해야 한다:
>>> re.findall('fish tonight\.$', source)
['fish tonight.']
w 또는 f를 찾은 다음 ish를 찾습니다.
>>> re.findall('[wf]ish', source)
['wish', 'wish', 'fish']
하나 이상의 w, s 또는 h 런을 찾습니다.
>>> re.findall('[wsh]+', source)
['w', 'sh', 'w', 'sh', 'h', 'sh', 'sh', 'h']
영숫자가 아닌 ght 다음에 오는 영숫자를 찾습니다.
>>> re.findall('ght\W', source)
['ght\n', 'ght.']
소원이 따라오는 것을 찾아라:
>>> re.findall('I (?=wish)', source)
['I ', 'I ']
그리고 마지막으로, I 앞에 소원이 있습니다.
>>> re.findall('(?<=I) wish', source)
[' wish', ' wish']
정규식 패턴 규칙이 파이썬 문자열 규칙과 충돌하는 몇 가지 경우가 있습니다. 다음 패턴은 피시로 시작하는 모든 단어와 일치해야 합니다.
>>> re.findall('\bfish', source) []
왜 안되죠? 이전포스팅에서 논의한 바와 같이, 파이썬은 문자열에 몇 가지 특수 이스케이프 문자 액터를 사용한다. 예를 들어, \b는 문자열의 백스페이스를 의미하지만 정규식의 미니 언어에서는 단어의 시작을 의미합니다. 정규식 문자열을 정의할 때 파이썬의 원시 문자열을 사용하여 이스케이프 문자를 실수로 사용하지 않도록 합니다. 정규식 패턴 문자열 앞에 항상 r 문자를 넣으십시오. 여기서 설명한 것처럼 파이썬 이스케이프 문자를 사용할 수 없습니다.
>>> re.findall(r'\bfish', source)
['fish']
Patterns: specifying match output
일치() 또는 검색()을 사용하면 결과 개체 m에서 모든 일치 항목이 m.group()으로 반환됩니다. 패턴을 괄호로 묶으면 일치 항목이 해당 그룹에 저장되며, 이 중 튜플은 다음과 같이 m.group()으로 사용할 수 있습니다.
>>> m = re.search(r'(. dish\b).*(\bfish)', source)
>>> m.group()
'a dish of fish'
>>> m.groups()
('a dish', 'fish')
이 패턴을 사용하면(?)P<name>expr), 일치 항목을 그룹에 저장합니다.
이름:
>>> m = re.search(r'(?P<DISH>. dish\b).*(?P<FISH>\bfish)', source)
>>> m.group()
'a dish of fish'
>>> m.groups()
('a dish', 'fish')
>>> m.group('DISH')
'a dish'
>>> m.group('FISH')
'fish'
bytes and bytearray
파이썬 3은 다음과 같은 8비트 정수 시퀀스를 도입했으며, 0부터 255까지의 값을 두 가지 유형으로 사용할 수 있다.
• 바이트는 불변입니다. 바이트 튜플처럼 • 바이트 목록처럼 bytray는 변경할 수 있습니다.
블리스트라는 목록으로 시작하여 다음 예제는 바이트 변수인 바이트 변수와 바이트_array라는 바이어레이 변수를 생성합니다.
>> blist = [1, 2, 3, 255]
>>> the_bytes = bytes(blist)
>>> the_bytes
b'\x01\x02\x03\xff'
>>> the_byte_array = bytearray(blist) >>> the_byte_array bytearray(b'\x01\x02\x03\xff')
바이트 값의 표현은 b와 따옴표 문자 다음에 \x02 또는 ASCII charac sequences ters와 같은 16진수 시퀀스로 시작하고 일치하는 따옴표 문자로 끝납니다. 파이썬은 16진수 시퀀스 또는 ASCII 문자를 작은 정수로 변환하지만 유효한 ASCII 인코딩인 바이트 값을 ASCII 문자로 표시합니다.
>>> b'\x61' b'a'
>>> b'\x01abc\xff' b'\x01abc\xff'
다음 예에서는 바이트 변수를 변경할 수 없음을 보여줍니다.
>>> the_bytes[1] = 127
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'bytes' object does not support item assignment
그러나 곁눈질 변수는 부드럽고 변이성이 있습니다.
>>> the_byte_array = bytearray(blist) >>> the_byte_array bytearray(b'\x01\x02\x03\xff')
>>> the_byte_array[1] = 127
>>> the_byte_array bytearray(b'\x01\x7f\x03\xff')
각 값은 0에서 255 사이의 값을 갖는 256 요소 결과를 생성합니다.
>>> the_bytes = bytes(range(0, 256))
>>> the_byte_array = bytearray(range(0, 256))
바이트 또는 byterray 데이터를 인쇄할 때 Python은 인쇄할 수 없는 바이트에 \x x를 사용하고 인쇄 가능한 바이트에 ASCII 등가(및 \x0a 대신 \n과 같은 일반적인 이스케이프 문자)를 사용합니다. 다음은_bytes의 인쇄된 표현입니다(한 줄당 16바이트를 표시하도록 수동 참조).
>>> the_bytes b'\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f \x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !"#$%&\'()*+,-./
0123456789:;<=>?
@ABCDEFGHIJKLMNO
PQRSTUVWXYZ[\\]^_
`abcdefghijklmno
pqrstuvwxyz{|}~\x7f \x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f \x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f \xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf \xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf \xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf \xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf \xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef \xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff'
문자가 아닌 바이트(10개의 정수)이기 때문에 헷갈릴 수 있습니다.
해야 할 일
7.1. mystery라는 유니코드 문자열을 만들고 값을 '\U0001f4a9'로 지정합니다. 미스테리를 인쇄하다. 유니코드 이름을 찾아보십시오.
7.2. 이번에는 UTF-8을 사용하여 미스터리를 바이트 변수 pop_bytes로 인코딩합니다. pop_bytes를 인쇄합니다.
7.3. UTF-8을 사용하여 pop_bytes를 문자열 변수 pop_string으로 디코딩한다. pop_string을 인쇄합니다. 팝 스트링이 미스터리와 같은가?
7.4. 다음 시를 구식으로 쓰세요. 'roast beef', 'ham', 'head' 및 'clam' 문자열을 다음 문자열로 대체하십시오.
My kitty cat likes %s,
My kitty cat likes %s,
My kitty cat fell on his %s
And now thinks he's a %s.
7.5. 새로운 서식을 사용해서 양식 편지를 쓰세요. 다음 문자열을 문자로 저장합니다(다음 연습에서 사용합니다).
Dear {salutation} {name},
Thank you for your letter. We are sorry that our {product} {verbed} in your
{room}. Please note that it should never be used in a {room}, especially
near any {animals}.
Send us your receipt and {amount} for shipping and handling. We will send
you another {product} that, in our tests, is {percent}% less likely to
have {verbed}.
Thank you for your support.
Sincerely,
{spokesman}
{job_title}
7.6. 문자열 키 'salutation', 'name', 'product', 'verbed'(과거 시제 동사), 'room', 'animals', '양', 'per cent', 'spokesman', 'job_title'의 값을 가진 response라는 사전을 만드십시오. 반응 값이 포함된 문자를 인쇄합니다.
7.7. 텍스트 작업을 할 때 정규 표현식이 매우 유용합니다. 여러 가지 방법으로 특집 텍스트 샘플에 적용할 것입니다. 이 시는 1866년 제임스 맥킨타이어가 온타리오에서 만들어 국제 순회공연을 위해 보낸 7천 파운드짜리 치즈에 경의를 표하기 위해 쓴 "매머드 치즈 송가"라는 제목의 시입니다. 모든 것을 입력하지 않으려면, 좋아하는 검색 엔진을 사용하여 단어를 잘라내어 파이썬 프로그램에 붙여 넣으십시오. 아니면, 프로젝트 구텐베르크에서 가져와요. 텍스트 문자열을 매머드라고 합니다.
We have seen thee, queen of cheese,
Lying quietly at your ease,
Gently fanned by evening breeze,
Thy fair form no flies dare seize.
All gaily dressed soon you'll go
To the great Provincial show,
To be admired by many a beau
In the city of Toronto.
Cows numerous as a swarm of bees,
Or as the leaves upon the trees,
It did require to make thee please,
And stand unrivalled, queen of cheese.
May you not receive a scar as
We have heard that Mr. Harris
Intends to send you off as far as
The great world's show at Paris.
Of the youth beware of these,
For some of them might rudely squeeze
And bite your cheek, then songs or glees
We could not sing, oh! queen of cheese.
We'rt thou suspended from balloon,
You'd cast a shade even at noon,
Folks would think it was the moon
About to fall and crush them soon.
7.8. 파이썬의 정규식 함수를 사용하려면 re 모듈을 가져옵니다. re.findall()을 사용하여 c로 시작하는 모든 단어를 인쇄합니다.
7.9. c로 시작하는 4글자를 모두 찾아라.
7.10. r로 끝나는 모든 단어를 찾아라.
7.11. 정확히 세 개의 모음을 연속으로 포함하는 모든 단어들을 찾아라.
7.12. unexlify를 사용하여 이 16진수 문자열(페이지에 맞도록 두 개의 문자열에서 조합됨)을 gif라는 바이트 변수로 변환합니다.
'47494638396101000100800000000000ffffff21f9' +
'0401000000002c000000000100010000020144003b'
