a = 0b10111011
b = 0xc5f
print('이진수: %d, 십육진수: %d' % (a, b))
이진수: 187, 십육진수: 3167
C 스타일 형식화의 문제점
key = 'my_var'
value = 1.234
formatted = '%-10s = %.2f' % (key, value)
print(formatted)
my_var = 1.23
reordered_tuple = '%-10s = %.2f' % (value, key)
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-5-3438bf149d3e> in <module> ----> 1 reordered_tuple = '%-10s = %.2f' % (value, key) TypeError: must be real number, not str
reordered_string = '%.2f = %-10s' % (key, value)
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-6-7391cce685e6> in <module> ----> 1 reordered_string = '%.2f = %-10s' % (key, value) TypeError: must be real number, not str
pantry = [
('아보카도', 1.24),
('바나나', 2.5),
('체리', 15),
]
for i, (item, count) in enumerate(pantry):
print('#%d: %-10s = %.2f' % (i, item, count))
#0: 아보카도 = 1.24 #1: 바나나 = 2.50 #2: 체리 = 15.00
for i, (item, count) in enumerate(pantry):
print('#%d: %-10s = %d' % (
i + 1,
item.title(),
round(count)))
#1: 아보카도 = 1 #2: 바나나 = 2 #3: 체리 = 15
template = '%s는 음식을 좋아해, %s가 요리하는 모습을 봐요.'
name = '철수'
formatted = template % (name, name)
print(formatted)
철수는 음식을 좋아해, 철수가 요리하는 모습을 봐요.
# title test
test = 'dongju park'
print(test.title())
# 띄어쓰기 기준으로 문자 맨 앞글자를 대문자로 변경
Dongju Park
위의 문제들 해결 방법
key = 'my_var'
value = 1.234
old_way = '%-10s = %.2f' % (key, value)
new_way = '%(key)-10s = %(value).2f' % {
'key': key, 'value': value} # 원래방식
reordered = '%(key)-10s = %(value).2f' % {
'value': value, 'key': key} # 바꾼 방식
print(old_way)
print(new_way)
print(reordered)
assert old_way == new_way == reordered
my_var = 1.23 my_var = 1.23 my_var = 1.23
template = '%s는 음식을 좋아해, %s가 요리하는 모습을 봐요.'
name = '철수'
before = template % (name, name) # 튜플
template = '%(name)s는 음식을 좋아해, %(name)s가 요리하는 모습을 봐요.'
after = template % {'name': name}
print(before)
print(after)
assert before == after
철수는 음식을 좋아해, 철수가 요리하는 모습을 봐요. 철수는 음식을 좋아해, 철수가 요리하는 모습을 봐요.
for i, (item, count) in enumerate(pantry):
before = '#%d: %-10s = %d' % (
i + 1,
item.title(),
round(count))
after = '#%(loop)d: %(item)-10s = %(count)d' % {
'loop': i + 1,
'item': item.title(),
'count': round(count),
}
print(before)
print(after)
assert before == after
#1: 아보카도 = 1 #1: 아보카도 = 1 #2: 바나나 = 2 #2: 바나나 = 2 #3: 체리 = 15 #3: 체리 = 15
soup = 'lentil'
formatted = 'Today\'s soup is %(soup)s.' % {'soup': soup} # \'를 보여주기 위해 일부러 원서 코드를 그대로 남겨둠
print(formatted)
Today's soup is lentil.
menu = {
'soup': 'lentil',
'oyster': 'tongyoung',
'special': 'schnitzel',
}
template = ('Today\'s soup is %(soup)s, '
'buy one get two %(oyster)s oysters, '
'and our special entrée is %(special)s.')
formatted = template % menu
print(formatted)
Today's soup is lentil, buy one get two tongyoung oysters, and our special entrée is schnitzel.
가독성이 더 나빠지므로 더 나은 방법이 있어야 한다.
format 내장 함수를 통한 고급 문자열 형식화
a = 1234.5678
formatted = format(a, ',.2f')
print(formatted)
1,234.57
b = 'my 문자열'
formatted = format(b, '^20s')
print('*', formatted, '*')
* my 문자열 *
str 타입에 format의 경우 위치 지정자 {}를 사용할 수 있다.
key = 'my_var'
value = 1.234
formatted = '{} = {}'.format(key, value)
print(formatted)
my_var = 1.234
위치 지정자에는 콜론 뒤에 형식 지정자를 넣어 변환 할 수 있다.
help('FORMATTING')
Format String Syntax
********************
The "str.format()" method and the "Formatter" class share the same
syntax for format strings (although in the case of "Formatter",
subclasses can define their own format string syntax). The syntax is
related to that of formatted string literals, but there are
differences.
Format strings contain “replacement fields” surrounded by curly braces
"{}". Anything that is not contained in braces is considered literal
text, which is copied unchanged to the output. If you need to include
a brace character in the literal text, it can be escaped by doubling:
"{{" and "}}".
The grammar for a replacement field is as follows:
replacement_field ::= "{" [field_name] ["!" conversion] [":" format_spec] "}"
field_name ::= arg_name ("." attribute_name | "[" element_index "]")*
arg_name ::= [identifier | digit+]
attribute_name ::= identifier
element_index ::= digit+ | index_string
index_string ::= <any source character except "]"> +
conversion ::= "r" | "s" | "a"
format_spec ::= <described in the next section>
In less formal terms, the replacement field can start with a
*field_name* that specifies the object whose value is to be formatted
and inserted into the output instead of the replacement field. The
*field_name* is optionally followed by a *conversion* field, which is
preceded by an exclamation point "'!'", and a *format_spec*, which is
preceded by a colon "':'". These specify a non-default format for the
replacement value.
See also the Format Specification Mini-Language section.
The *field_name* itself begins with an *arg_name* that is either a
number or a keyword. If it’s a number, it refers to a positional
argument, and if it’s a keyword, it refers to a named keyword
argument. If the numerical arg_names in a format string are 0, 1, 2,
… in sequence, they can all be omitted (not just some) and the numbers
0, 1, 2, … will be automatically inserted in that order. Because
*arg_name* is not quote-delimited, it is not possible to specify
arbitrary dictionary keys (e.g., the strings "'10'" or "':-]'") within
a format string. The *arg_name* can be followed by any number of index
or attribute expressions. An expression of the form "'.name'" selects
the named attribute using "getattr()", while an expression of the form
"'[index]'" does an index lookup using "__getitem__()".
Changed in version 3.1: The positional argument specifiers can be
omitted for "str.format()", so "'{} {}'.format(a, b)" is equivalent to
"'{0} {1}'.format(a, b)".
Changed in version 3.4: The positional argument specifiers can be
omitted for "Formatter".
Some simple format string examples:
"First, thou shalt count to {0}" # References first positional argument
"Bring me a {}" # Implicitly references the first positional argument
"From {} to {}" # Same as "From {0} to {1}"
"My quest is {name}" # References keyword argument 'name'
"Weight in tons {0.weight}" # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}" # First element of keyword argument 'players'.
The *conversion* field causes a type coercion before formatting.
Normally, the job of formatting a value is done by the "__format__()"
method of the value itself. However, in some cases it is desirable to
force a type to be formatted as a string, overriding its own
definition of formatting. By converting the value to a string before
calling "__format__()", the normal formatting logic is bypassed.
Three conversion flags are currently supported: "'!s'" which calls
"str()" on the value, "'!r'" which calls "repr()" and "'!a'" which
calls "ascii()".
Some examples:
"Harold's a clever {0!s}" # Calls str() on the argument first
"Bring out the holy {name!r}" # Calls repr() on the argument first
"More {!a}" # Calls ascii() on the argument first
The *format_spec* field contains a specification of how the value
should be presented, including such details as field width, alignment,
padding, decimal precision and so on. Each value type can define its
own “formatting mini-language” or interpretation of the *format_spec*.
Most built-in types support a common formatting mini-language, which
is described in the next section.
A *format_spec* field can also include nested replacement fields
within it. These nested replacement fields may contain a field name,
conversion flag and format specification, but deeper nesting is not
allowed. The replacement fields within the format_spec are
substituted before the *format_spec* string is interpreted. This
allows the formatting of a value to be dynamically specified.
See the Format examples section for some examples.
Format Specification Mini-Language
==================================
“Format specifications” are used within replacement fields contained
within a format string to define how individual values are presented
(see Format String Syntax and Formatted string literals). They can
also be passed directly to the built-in "format()" function. Each
formattable type may define how the format specification is to be
interpreted.
Most built-in types implement the following options for format
specifications, although some of the formatting options are only
supported by the numeric types.
A general convention is that an empty format string ("""") produces
the same result as if you had called "str()" on the value. A non-empty
format string typically modifies the result.
The general form of a *standard format specifier* is:
format_spec ::= [[fill]align][sign][#][0][width][grouping_option][.precision][type]
fill ::= <any character>
align ::= "<" | ">" | "=" | "^"
sign ::= "+" | "-" | " "
width ::= digit+
grouping_option ::= "_" | ","
precision ::= digit+
type ::= "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%"
If a valid *align* value is specified, it can be preceded by a *fill*
character that can be any character and defaults to a space if
omitted. It is not possible to use a literal curly brace (“"{"” or
“"}"”) as the *fill* character in a formatted string literal or when
using the "str.format()" method. However, it is possible to insert a
curly brace with a nested replacement field. This limitation doesn’t
affect the "format()" function.
The meaning of the various alignment options is as follows:
+-----------+------------------------------------------------------------+
| Option | Meaning |
|===========|============================================================|
| "'<'" | Forces the field to be left-aligned within the available |
| | space (this is the default for most objects). |
+-----------+------------------------------------------------------------+
| "'>'" | Forces the field to be right-aligned within the available |
| | space (this is the default for numbers). |
+-----------+------------------------------------------------------------+
| "'='" | Forces the padding to be placed after the sign (if any) |
| | but before the digits. This is used for printing fields |
| | in the form ‘+000000120’. This alignment option is only |
| | valid for numeric types. It becomes the default when ‘0’ |
| | immediately precedes the field width. |
+-----------+------------------------------------------------------------+
| "'^'" | Forces the field to be centered within the available |
| | space. |
+-----------+------------------------------------------------------------+
Note that unless a minimum field width is defined, the field width
will always be the same size as the data to fill it, so that the
alignment option has no meaning in this case.
The *sign* option is only valid for number types, and can be one of
the following:
+-----------+------------------------------------------------------------+
| Option | Meaning |
|===========|============================================================|
| "'+'" | indicates that a sign should be used for both positive as |
| | well as negative numbers. |
+-----------+------------------------------------------------------------+
| "'-'" | indicates that a sign should be used only for negative |
| | numbers (this is the default behavior). |
+-----------+------------------------------------------------------------+
| space | indicates that a leading space should be used on positive |
| | numbers, and a minus sign on negative numbers. |
+-----------+------------------------------------------------------------+
The "'#'" option causes the “alternate form” to be used for the
conversion. The alternate form is defined differently for different
types. This option is only valid for integer, float, complex and
Decimal types. For integers, when binary, octal, or hexadecimal output
is used, this option adds the prefix respective "'0b'", "'0o'", or
"'0x'" to the output value. For floats, complex and Decimal the
alternate form causes the result of the conversion to always contain a
decimal-point character, even if no digits follow it. Normally, a
decimal-point character appears in the result of these conversions
only if a digit follows it. In addition, for "'g'" and "'G'"
conversions, trailing zeros are not removed from the result.
The "','" option signals the use of a comma for a thousands separator.
For a locale aware separator, use the "'n'" integer presentation type
instead.
Changed in version 3.1: Added the "','" option (see also **PEP 378**).
The "'_'" option signals the use of an underscore for a thousands
separator for floating point presentation types and for integer
presentation type "'d'". For integer presentation types "'b'", "'o'",
"'x'", and "'X'", underscores will be inserted every 4 digits. For
other presentation types, specifying this option is an error.
Changed in version 3.6: Added the "'_'" option (see also **PEP 515**).
*width* is a decimal integer defining the minimum total field width,
including any prefixes, separators, and other formatting characters.
If not specified, then the field width will be determined by the
content.
When no explicit alignment is given, preceding the *width* field by a
zero ("'0'") character enables sign-aware zero-padding for numeric
types. This is equivalent to a *fill* character of "'0'" with an
*alignment* type of "'='".
The *precision* is a decimal number indicating how many digits should
be displayed after the decimal point for a floating point value
formatted with "'f'" and "'F'", or before and after the decimal point
for a floating point value formatted with "'g'" or "'G'". For non-
number types the field indicates the maximum field size - in other
words, how many characters will be used from the field content. The
*precision* is not allowed for integer values.
Finally, the *type* determines how the data should be presented.
The available string presentation types are:
+-----------+------------------------------------------------------------+
| Type | Meaning |
|===========|============================================================|
| "'s'" | String format. This is the default type for strings and |
| | may be omitted. |
+-----------+------------------------------------------------------------+
| None | The same as "'s'". |
+-----------+------------------------------------------------------------+
The available integer presentation types are:
+-----------+------------------------------------------------------------+
| Type | Meaning |
|===========|============================================================|
| "'b'" | Binary format. Outputs the number in base 2. |
+-----------+------------------------------------------------------------+
| "'c'" | Character. Converts the integer to the corresponding |
| | unicode character before printing. |
+-----------+------------------------------------------------------------+
| "'d'" | Decimal Integer. Outputs the number in base 10. |
+-----------+------------------------------------------------------------+
| "'o'" | Octal format. Outputs the number in base 8. |
+-----------+------------------------------------------------------------+
| "'x'" | Hex format. Outputs the number in base 16, using lower- |
| | case letters for the digits above 9. |
+-----------+------------------------------------------------------------+
| "'X'" | Hex format. Outputs the number in base 16, using upper- |
| | case letters for the digits above 9. |
+-----------+------------------------------------------------------------+
| "'n'" | Number. This is the same as "'d'", except that it uses the |
| | current locale setting to insert the appropriate number |
| | separator characters. |
+-----------+------------------------------------------------------------+
| None | The same as "'d'". |
+-----------+------------------------------------------------------------+
In addition to the above presentation types, integers can be formatted
with the floating point presentation types listed below (except "'n'"
and "None"). When doing so, "float()" is used to convert the integer
to a floating point number before formatting.
The available presentation types for floating point and decimal values
are:
+-----------+------------------------------------------------------------+
| Type | Meaning |
|===========|============================================================|
| "'e'" | Exponent notation. Prints the number in scientific |
| | notation using the letter ‘e’ to indicate the exponent. |
| | The default precision is "6". |
+-----------+------------------------------------------------------------+
| "'E'" | Exponent notation. Same as "'e'" except it uses an upper |
| | case ‘E’ as the separator character. |
+-----------+------------------------------------------------------------+
| "'f'" | Fixed-point notation. Displays the number as a fixed-point |
| | number. The default precision is "6". |
+-----------+------------------------------------------------------------+
| "'F'" | Fixed-point notation. Same as "'f'", but converts "nan" to |
| | "NAN" and "inf" to "INF". |
+-----------+------------------------------------------------------------+
| "'g'" | General format. For a given precision "p >= 1", this |
| | rounds the number to "p" significant digits and then |
| | formats the result in either fixed-point format or in |
| | scientific notation, depending on its magnitude. The |
| | precise rules are as follows: suppose that the result |
| | formatted with presentation type "'e'" and precision "p-1" |
| | would have exponent "exp". Then, if "m <= exp < p", where |
| | "m" is -4 for floats and -6 for "Decimals", the number is |
| | formatted with presentation type "'f'" and precision |
| | "p-1-exp". Otherwise, the number is formatted with |
| | presentation type "'e'" and precision "p-1". In both cases |
| | insignificant trailing zeros are removed from the |
| | significand, and the decimal point is also removed if |
| | there are no remaining digits following it, unless the |
| | "'#'" option is used. Positive and negative infinity, |
| | positive and negative zero, and nans, are formatted as |
| | "inf", "-inf", "0", "-0" and "nan" respectively, |
| | regardless of the precision. A precision of "0" is |
| | treated as equivalent to a precision of "1". The default |
| | precision is "6". |
+-----------+------------------------------------------------------------+
| "'G'" | General format. Same as "'g'" except switches to "'E'" if |
| | the number gets too large. The representations of infinity |
| | and NaN are uppercased, too. |
+-----------+------------------------------------------------------------+
| "'n'" | Number. This is the same as "'g'", except that it uses the |
| | current locale setting to insert the appropriate number |
| | separator characters. |
+-----------+------------------------------------------------------------+
| "'%'" | Percentage. Multiplies the number by 100 and displays in |
| | fixed ("'f'") format, followed by a percent sign. |
+-----------+------------------------------------------------------------+
| None | Similar to "'g'", except that fixed-point notation, when |
| | used, has at least one digit past the decimal point. The |
| | default precision is as high as needed to represent the |
| | particular value. The overall effect is to match the |
| | output of "str()" as altered by the other format |
| | modifiers. |
+-----------+------------------------------------------------------------+
Format examples
===============
This section contains examples of the "str.format()" syntax and
comparison with the old "%"-formatting.
In most of the cases the syntax is similar to the old "%"-formatting,
with the addition of the "{}" and with ":" used instead of "%". For
example, "'%03.2f'" can be translated to "'{:03.2f}'".
The new format syntax also supports new and different options, shown
in the following examples.
Accessing arguments by position:
>>> '{0}, {1}, {2}'.format('a', 'b', 'c')
'a, b, c'
>>> '{}, {}, {}'.format('a', 'b', 'c') # 3.1+ only
'a, b, c'
>>> '{2}, {1}, {0}'.format('a', 'b', 'c')
'c, b, a'
>>> '{2}, {1}, {0}'.format(*'abc') # unpacking argument sequence
'c, b, a'
>>> '{0}{1}{0}'.format('abra', 'cad') # arguments' indices can be repeated
'abracadabra'
Accessing arguments by name:
>>> 'Coordinates: {latitude}, {longitude}'.format(latitude='37.24N', longitude='-115.81W')
'Coordinates: 37.24N, -115.81W'
>>> coord = {'latitude': '37.24N', 'longitude': '-115.81W'}
>>> 'Coordinates: {latitude}, {longitude}'.format(**coord)
'Coordinates: 37.24N, -115.81W'
Accessing arguments’ attributes:
>>> c = 3-5j
>>> ('The complex number {0} is formed from the real part {0.real} '
... 'and the imaginary part {0.imag}.').format(c)
'The complex number (3-5j) is formed from the real part 3.0 and the imaginary part -5.0.'
>>> class Point:
... def __init__(self, x, y):
... self.x, self.y = x, y
... def __str__(self):
... return 'Point({self.x}, {self.y})'.format(self=self)
...
>>> str(Point(4, 2))
'Point(4, 2)'
Accessing arguments’ items:
>>> coord = (3, 5)
>>> 'X: {0[0]}; Y: {0[1]}'.format(coord)
'X: 3; Y: 5'
Replacing "%s" and "%r":
>>> "repr() shows quotes: {!r}; str() doesn't: {!s}".format('test1', 'test2')
"repr() shows quotes: 'test1'; str() doesn't: test2"
Aligning the text and specifying a width:
>>> '{:<30}'.format('left aligned')
'left aligned '
>>> '{:>30}'.format('right aligned')
' right aligned'
>>> '{:^30}'.format('centered')
' centered '
>>> '{:*^30}'.format('centered') # use '*' as a fill char
'***********centered***********'
Replacing "%+f", "%-f", and "% f" and specifying a sign:
>>> '{:+f}; {:+f}'.format(3.14, -3.14) # show it always
'+3.140000; -3.140000'
>>> '{: f}; {: f}'.format(3.14, -3.14) # show a space for positive numbers
' 3.140000; -3.140000'
>>> '{:-f}; {:-f}'.format(3.14, -3.14) # show only the minus -- same as '{:f}; {:f}'
'3.140000; -3.140000'
Replacing "%x" and "%o" and converting the value to different bases:
>>> # format also supports binary numbers
>>> "int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}".format(42)
'int: 42; hex: 2a; oct: 52; bin: 101010'
>>> # with 0x, 0o, or 0b as prefix:
>>> "int: {0:d}; hex: {0:#x}; oct: {0:#o}; bin: {0:#b}".format(42)
'int: 42; hex: 0x2a; oct: 0o52; bin: 0b101010'
Using the comma as a thousands separator:
>>> '{:,}'.format(1234567890)
'1,234,567,890'
Expressing a percentage:
>>> points = 19
>>> total = 22
>>> 'Correct answers: {:.2%}'.format(points/total)
'Correct answers: 86.36%'
Using type-specific formatting:
>>> import datetime
>>> d = datetime.datetime(2010, 7, 4, 12, 15, 58)
>>> '{:%Y-%m-%d %H:%M:%S}'.format(d)
'2010-07-04 12:15:58'
Nesting arguments and more complex examples:
>>> for align, text in zip('<^>', ['left', 'center', 'right']):
... '{0:{fill}{align}16}'.format(text, fill=align, align=align)
...
'left<<<<<<<<<<<<'
'^^^^^center^^^^^'
'>>>>>>>>>>>right'
>>>
>>> octets = [192, 168, 0, 1]
>>> '{:02X}{:02X}{:02X}{:02X}'.format(*octets)
'C0A80001'
>>> int(_, 16)
3232235521
>>>
>>> width = 5
>>> for num in range(5,12):
... for base in 'dXob':
... print('{0:{width}{base}}'.format(num, base=base, width=width), end=' ')
... print()
...
5 5 5 101
6 6 6 110
7 7 7 111
8 8 10 1000
9 9 11 1001
10 A 12 1010
11 B 13 1011
Related help topics: OPERATORS
formatted = '{:<10} = {:.2f}'.format(key, value)
print(formatted)
my_var = 1.23
{:.2f}는 format(value, '.2f') 와 같음
특별 메서드인 __format__을 사용해 클래스별로 형식화 방식을 커스텀 가능
이스케이프
print('%.2f%%' % 12.5)
print('{} replaces {{}}'.format(1.23))
12.50%
1.23 replaces {}
위치 지정자 중괄호에 위치 인덱스를 전달 할 수 있음.
formatted = '{1} = {0}'.format(key, value)
print(formatted)
1.234 = my_var
세 번째 문제점도 간단히 해결 가능
name = '철수'
formatted = '{0}는 음식을 좋아해. {0}가 요리하는 모습을 봐요.'.format(name)
print(formatted)
철수는 음식을 좋아해. 철수가 요리하는 모습을 봐요.
두번째는 역시 해결하지 못함
for i, (item, count) in enumerate(pantry):
old_style = '#%d: %-10s = %d' % (
i + 1,
item.title(),
round(count))
new_style = '#{}: {:<10s} = {}'.format(
i + 1,
item.title(),
round(count))
assert old_style == new_style
str.format과 함께 사용하는 형식 지정자에는 딕셔너리 키나 리스트 인덱스를 조합해 위치 지정자에 사용하거나 값을 유니코드나 repr 문자열로 변화나는 등의 고급 옵션이 있다.
formatted = '첫번째 글자는 {menu[oyster][0]!r}'.format(
menu=menu)
print(formatted)
첫번째 글자는 't'
이 기능도 네 번째 문제점인 키가 반복되는 경우의 중복을 줄여주지는 못함
old_template = (
'Today\'s soup is %(soup)s, '
'buy one get two %(oyster)s oysters, '
'and our special entrée is %(special)s.')
old_formatted = template % {
'soup': 'lentil',
'oyster': 'tongyoung',
'special': 'schnitzel',
}
new_template = (
'Today\'s soup is {soup}, '
'buy one get two {oyster} oysters, '
'and our special entrée is {special}.')
new_formatted = new_template.format(
soup='lentil',
oyster='tongyoung',
special='schnitzel',
)
assert old_formatted == new_formatted
이 문제를 한 번에 완전히 해결하기 위해 파이썬 3.6부터는 인터폴레이션을 통한 형식 문자열(f-문자열)이 도입됨
key = 'my_var'
value = 1.234
formatted = f'{key} = {value}'
print(formatted)
my_var = 1.234
formatted = f'{key!r:<10} = {value:.2f}'
print(formatted)
'my_var' = 1.23
다른 포매팅 방식에 비해 짧다.
f_string = f'{key:<10} = {value:.2f}'
c_tuple = '%-10s = %.2f' % (key, value)
str_args = '{:<10} = {:.2f}'.format(key, value)
str_kw = '{key:<10} = {value:.2f}'.format(key=key,
value=value)
c_dict = '%(key)-10s = %(value).2f' % {'key': key,
'value': value}
assert c_tuple == c_dict == f_string
assert str_args == str_kw == f_string
f-문자열을 사용하면 위치 지정자 중괄호 안에 완전한 파이썬 식을 넣을 수 있다.
두 번째 문제점을 해결한다.
for i, (item, count) in enumerate(pantry):
old_style = '#%d: %-10s = %d' % (
i + 1,
item.title(),
round(count))
new_style = '#{}: {:<10s} = {}'.format(
i + 1,
item.title(),
round(count))
f_string = f'#{i+1}: {item.title():<10s} = {round(count)}'
assert old_style == new_style == f_string
f-문자열을 여러 줄로 나눌 수도 있다.
for i, (item, count) in enumerate(pantry):
print(f'#{i+1}: '
f'{item.title():<10s} = '
f'{round(count)}')
#1: 아보카도 = 1 #2: 바나나 = 2 #3: 체리 = 15
파이썬 식을 형식 지정자 옵션에 넣을 수도 있다.
places = 3
number = 1.23456
print(f'내가 고른 숫자는 {number:.{places}f}')
내가 고른 숫자는 1.235
결론 : f-문자열을 쓰자