10 приемов для преобразования и декомпозиции строк в python

Содержание:

Помните Дзен Python, где должен быть “один очевидный способ сделать что-то в Python”? Можете почесать голову перед тем, как понять, что зачастую есть целых 4 эффективных способа выполнить в Python.

Давайте приступим к делу, работы много! Чтобы иметь в распоряжении простой пример для эксперимента, представим, что у вас есть следующие переменные (или константы, не важно) для работы:

Python

errno = 50159747054
name = ‘Bob’

1 2	errno=50159747054 name=’Bob’

Основываясь на этих переменных, вы хотите создать строку вывода, содержащую простое уведомление об ошибке:

Python

‘Hey Bob, there is a 0xbadc0ffee error!’

1	‘Hey Bob, there is a 0xbadc0ffee error!’

Эта ошибка может немного подпортить понедельник вашему разрабу… Но мы здесь за тем, чтобы обсудить форматирование строк. Так что приступим к делу.

String Formatting Operator

One of Python’s coolest features is the string format operator %. This operator is unique to strings and makes up for the pack of having functions from C’s printf() family. Following is a simple example −

#!/usr/bin/python

print "My name is %s and weight is %d kg!" % ('Zara', 21)

When the above code is executed, it produces the following result −

My name is Zara and weight is 21 kg!

Here is the list of complete set of symbols which can be used along with % −

Format Symbol	Conversion
%c	character
%s	string conversion via str() prior to formatting
%i	signed decimal integer
%d	signed decimal integer
%u	unsigned decimal integer
%o	octal integer
%x	hexadecimal integer (lowercase letters)
%X	hexadecimal integer (UPPERcase letters)
%e	exponential notation (with lowercase ‘e’)
%E	exponential notation (with UPPERcase ‘E’)
%f	floating point real number
%g	the shorter of %f and %e
%G	the shorter of %f and %E

Other supported symbols and functionality are listed in the following table −

Symbol	Functionality
*	argument specifies width or precision
—	left justification
+	display the sign
<sp>	leave a blank space before a positive number
#	add the octal leading zero ( ‘0’ ) or hexadecimal leading ‘0x’ or ‘0X’, depending on whether ‘x’ or ‘X’ were used.
pad from left with zeros (instead of spaces)
%	‘%%’ leaves you with a single literal ‘%’
(var)	mapping variable (dictionary arguments)
m.n.	m is the minimum total width and n is the number of digits to display after the decimal point (if appl.)

Форматирование строк

Часто возникает ситуация, когда необходимо создать строку, подставив в нее определенные значения, полученные во время выполнения программы. Подстановка данных в таком случае выполняется при помощи форматирования строк, сделать это можно несколькими способами.

Оператор %

Строки в Python обладают встроенной операцией, к которой можно получить доступ оператором %, что дает возможность очень просто делать форматирование. Самый простой пример – когда для подстановки нужен только один аргумент, значением будет он сам:

Если же для подстановки используется несколько аргументов, то значением будет кортеж со строками:

Как видно из предыдущего примера, зависимо от типа данных для подстановки и того, что требуется получить в итоге, пишется разный формат. Наиболее часто используются:

1. ‘%d’, ‘%i’, ‘%u – десятичное число;
2. ‘%c’ – символ, точнее строка из одного символа или число – код символа;
3. ‘%r’ – строка (литерал Python);
4. ‘%s’ – строка.

Такой способ форматирования строк называет «старым» стилем, который в Python 3 был заменен на более удобные способы.

str.format()

В Python 3 появился более новый метод форматирования строк, который вскоре перенесли и в Python 2.7. Такой способ избавляет программиста от специального синтаксиса %-оператора. Делается все путем вызова .format() для строковой переменной. С помощью специального символа – фигурных скобок – указывается место для подстановки значения, каждая пара скобок указывает отдельное место для подстановки, значения могут быть разного типа:

В Python 3 форматирование строк с использованием «нового стиля» является более предпочтительным по сравнению с использованием %-стиля, так как предоставляет более широкие возможности, не усложняя простые варианты использования.

f-строки (Python 3.6+)

В Python версии 3.6 появился новый метод форматирования строк – «f-строки», с его помощью можно использовать встроенные выражения внутри строк:

Такой способ форматирования очень мощный, так как дает возможность встраивать выражения:

Таким образом, форматирование с помощью f-строк напоминает использование метода format(), но более гибкое, быстрое и читабельное.

Стандартная библиотека Template Strings

Еще один способ форматирования строк, который появился еще с выходом Python версии 2.4, но так и не стал популярным – использование библиотеки Template Strings. Есть поддержка передачи значения по имени, используется $-синтаксис как в языке PHP:

Что насчёт поиска в строке?

Самое быстрое — проверить, начинается ли (заканчивается ли) строка с выбранных символов. Для этого в Python предусмотрены специальные строковые методы.

Для поиск подстроки в произвольном месте есть метод с говорящим названием . Он вернет индекс начала найденного вхождения подстроки в строку, либо -1, если ничего не найдено.

Для сложных случаев, когда нужно найти не конкретную последовательность символов, а некий шаблон, помогут регулярные выражения. Они заслуживают отдельной статьи. Глубокого знания регулярок на собеседованиях не требуется, достаточно знать про них, уметь написать несложное выражение и прочитать чуть более сложное. Например, такое:

Атрибут __doc__

Всякий раз, когда строковые литералы присутствуют сразу после определения функции, модуля, класса или метода, они становятся специальным атрибутом этого объекта. Позже мы можем использовать этот атрибут для получения этой строки документации.

Пример 2: Вывод на экран строки документации.

def square(n):
    '''Принимает число n, возвращает квадрат числа n'''
    return n**2

print(square.__doc__)

Результат:

Здесь  мы получили доступ к документации нашей функции с помощью атрибута .

Теперь давайте посмотрим на строки документации для встроенной функции :

Пример 3: строки документации для встроенной функции print().

print(print.__doc__)

Результат:

Здесь мы можем видеть, что документация функции представлена как атрибут этой функции.

О методах¶

До сих пор мы использовали функции, которые были «сами по себе»: ,
. В языке Python существуют специальные функции, привязанные к
объектам. Они называются методы. Сравните вызов обычной свободной функции
и вызов метода строки :

>>> s = "hello"
>>> len(s)
5
>>> s.upper()
'HELLO'

Здесь функция в качестве своего единственного аргумента принимает
строку и возвращает количество символов в ней. Метод
связан с типом и вызывается у объекта с помощью точки.

Аналогично методы можно вызывать и у литералов:

>>> 'world'.upper()
'WORLD'

()

()

()

Методы приводят строку к нижнему, верхнему и title регистру соответственно:

>>> 'world'.upper()
'WORLD'
>>> 'HELLO'.lower()
'hello'
>>> 'hello'.upper()
'HELLO'
>>> 'hello'.title()
'Hello'

(sub)

Возвращает количество вхождений подстроки в строку .

(sub)

Возвращает минимальный индекс вхождения подстроки в строку :

>>> 'otto'.find('t')
1

(sub)

Возвращает максимальный индекс вхождения подстроки в строку :

>>> 'otto'.rfind('t')
2

(width)

Возвращает строку, выровненную по левой границе поля ширины .
Строка дополняется пробелами справа:

>>> 'hello'.ljust(10)
'hello     '

(width)

Возвращает строку, выровненную по правой границе поля ширины .
Строка дополняется пробелами слева:

>>> 'hello'.rjust(10)
'     hello'

python-ideas discussion

Most of the discussions on python-ideas focused on three issues:

• How to denote f-strings,
• How to specify the location of expressions in f-strings, and
• Whether to allow full Python expressions.

Because the compiler must be involved in evaluating the expressions
contained in the interpolated strings, there must be some way to
denote to the compiler which strings should be evaluated. This PEP
chose a leading 'f' character preceding the string literal. This
is similar to how 'b' and 'r' prefixes change the meaning of
the string itself, at compile time. Other prefixes were suggested,
such as 'i'. No option seemed better than the other, so 'f'
was chosen.

Another option was to support special functions, known to the
compiler, such as Format(). This seems like too much magic for
Python: not only is there a chance for collision with existing
identifiers, the PEP author feels that it’s better to signify the
magic with a string prefix character.

This PEP supports the same syntax as str.format() for
distinguishing replacement text inside strings: expressions are
contained inside braces. There were other options suggested, such as
string.Template‘s $identifier or ${expression}.

While $identifier is no doubt more familiar to shell scripters and
users of some other languages, in Python str.format() is heavily
used. A quick search of Python’s standard library shows only a handful
of uses of string.Template, but hundreds of uses of
str.format().

Another proposed alternative was to have the substituted text between
\{ and } or between \{ and \}. While this syntax would
probably be desirable if all string literals were to support
interpolation, this PEP only supports strings that are already marked
with the leading 'f'. As such, the PEP is using unadorned braces
to denoted substituted text, in order to leverage end user familiarity
with str.format().

Strip и zfill

Еще одна важная функция — это возможность удалять из строки лишние начальные и конечные символы. Для этого у нас есть семейство функций :

• Удалить пробелы по умолчанию.
• Удалить пробелы слева или справа.
• Удалить произвольные символы.

test_string_with_spaces = '     The quick brown fox jumps over the lazy dog    '
test_string_with_spaces.strip()

Out: 'The quick brown fox jumps over the lazy dog'

test_string_with_spaces.lstrip()

Out: 'The quick brown fox jumps over the lazy dog    '

test_string_with_spaces.rstrip()

Out: '     The quick brown fox jumps over the lazy dog'

test_string.rstrip('g')

Out: 'The quick brown fox jumps over the lazy do'

Кроме того, есть полезная функция для дополнения чисел ведущими нулями:

'29'.zfill(10)

Out: '0000000029'

'xA1'.zfill(4)

Out: '0xA1'

Разбиение строки

Для анализа текста требуются различные метрики, такие как количество слов, количество символов, средняя длина предложения. Чтобы вычислить эти значения, нам нужно подготовить текст — очистить и разделить. К счастью для нас, в Python есть несколько встроенных функций для разделения текста:

Разбиение по пробелу (по умолчанию):

test_string.split()
Out: 

Разбиение на определенное количество токенов:

test_string.split(' ', 2)
Out: 

Разбиение на определенное количество токенов в обратном направлении:

test_string.rsplit(' ', 2)
Out: 

Разбиение по произвольному символу:

test_string.split('e')
Out: 

Разбиение строки по нужному токену с токенами до и после него:

test_string.partition('fox')
Out: ('The quick brown ', 'fox', ' jumps over the lazy dog')

Triple Quotes

Python’s triple quotes comes to the rescue by allowing strings to span multiple lines, including verbatim NEWLINEs, TABs, and any other special characters.

The syntax for triple quotes consists of three consecutive single or double quotes.

#!/usr/bin/python

para_str = """this is a long string that is made up of
several lines and non-printable characters such as
TAB ( \t ) and they will show up that way when displayed.
NEWLINEs within the string, whether explicitly given like
this within the brackets , or just a NEWLINE within
the variable assignment will also show up.
"""
print para_str

When the above code is executed, it produces the following result. Note how every single special character has been converted to its printed form, right down to the last NEWLINE at the end of the string between the «up.» and closing triple quotes. Also note that NEWLINEs occur either with an explicit carriage return at the end of a line or its escape code (\n) −

this is a long string that is made up of
several lines and non-printable characters such as
TAB (    ) and they will show up that way when displayed.
NEWLINEs within the string, whether explicitly given like
this within the brackets , or just a NEWLINE within
the variable assignment will also show up.

Raw strings do not treat the backslash as a special character at all. Every character you put into a raw string stays the way you wrote it −

#!/usr/bin/python

print 'C:\\nowhere'

When the above code is executed, it produces the following result −

C:\nowhere

Now let’s make use of raw string. We would put expression in r’expression’ as follows −

#!/usr/bin/python

print r'C:\\nowhere'

When the above code is executed, it produces the following result −

C:\\nowhere

Сохранение строк в качестве значения для переменных

В общем смысле слова, переменные являются последовательностью символов, которую вы можете использовать для хранения данных в программе. Например, их можно представить в качестве неких пустых ящиков, в которое вы помещаете различные объекты. Такими объектами может стать любой тип данных, и строки в этом смысле не исключение. Однажды создав переменную, мы сильно упрощаем себе работу со строкой на протяжении всей программы.

Для того чтобы сохранить значение строки внутри переменной, нам просто нужно присвоить строке ее имя. В следующем примере давайте объявим в качестве нашей переменной:

my_str = "Sammy likes declaring strings."

Теперь, когда у нас есть переменная , назначенная нужной нам строке, мы можем вывести ее на экран:

print(my_str)

И получим следующий вывод:

Sammy likes declaring strings.

Использование переменных вместо строк не только дает нам возможность не переписывать строки каждый раз, когда нам это нужно, но также сильно упрощает работу с ними внутри программы.

Совет #4: Обновите BIOS материнской платы

Ещё один способ, позволяющий избавиться от неполадки, вследствие которой БИОС не видит SSD, — выполнение обновления прошивки. Как вы уже знаете, модели от разных производителей отличаются по функционалу — вам придётся искать инструкцию для своей программно-аппаратной связки. Посоветуем лишь несколько направлений для обновления:

При помощи специальной утилиты. Программы должна быть выпущена самим разработчиком, иметь цифровую подпись. Скачивайте приложение только с официального сайта, без каких-либо «надстроек» и «улучшений». Это самый простой вариант: всё, что вам понадобится сделать, это скачать и запустить продукт, после чего начать процесс обновления. На время работы непременно закройте все сторонние приложения, а также постарайтесь не выполнять на ПК никаких действий. В заключение компьютер должен самостоятельно перезапуститься.

• При помощи окружения DOS. Вам придётся скачать образ для записи на любой удобный носитель: флеш-память или оптический диск. В программе будут содержаться новая прошивка и DOS-среда, посредством которой и происходит взаимодействие с BIOS. Последняя может быть представлена в виде файла с расширением BAT/MSI/EXE.
• Непосредственно в меню программно-аппаратной связки БИОС. Самый надёжный вариант, если только вы твёрдо знаете, что скачали и записали на флеш-носитель подходящий релиз. Вам потребуется в очередной раз зайти в меню, выбрать в списке доступных опций утилиту для прошивки (она может называться Q-Flash, EZ-Flash или подобным образом). Теперь укажите, где расположены подготовленные файлы — и дождитесь, пока завершится обновление!

В большинстве случаев пользователю доступно сразу несколько вариантов. Примените на своём ПК любой, который считаете наиболее подходящим, — а по окончании удостоверьтесь, что после обновления диск опознан и готов к работе.

Форматирование строк

Форматирование строк (также известно как замещение) – это замещение значений в базовой строке. Большую часть времени вы будете вставлять строки внутри строк, однако, вам также понадобиться вставлять целые числа и числа с запятыми в строки весьма часто. Существует два способа достичь этой цели. Начнем с старого способа, после чего перейдем к новому:

Python

# -*- coding: utf-8 -*-

my_string = «Я люблю %s» % «Python»
print(my_string) # Я люблю Python

var = «яблоки»
newString = «Я ем %s» % var
print(newString) # Я ем яблоки

another_string = «Я люблю %s и %s» % («Python», var)
print(another_string) # Я люблю Python и яблоки

1 2 3 4 5 6 7 8 9 10 11

# -*- coding: utf-8 -*-   my_string=»Я люблю %s»%»Python» print(my_string)# Я люблю Python var=»яблоки» newString=»Я ем %s»%var print(newString)# Я ем яблоки another_string=»Я люблю %s и %s»%(«Python»,var) print(another_string)# Я люблю Python и яблоки

Как вы могли догадаться, % — это очень важная часть вышеописанного кода. Этот символ указывает Python, что вы скоро вставите текст на его место. Если вы будете следовать за строкой со знаком процента и другой строкой или переменной, тогда Python попытается вставить ее в строку. Вы можете вставить несколько строк, добавив несколько знаков процента в свою строку. Это видно в последнем примере

Обратите внимание на то, что когда вы добавляете больше одной строки, вам нужно закрыть эти строки в круглые скобки. Теперь взглянем на то, что случится, если мы вставим недостаточное количество строк:

Python

another_string = «Я люблю %s и %s» % «Python»

Traceback (most recent call last):
File «<string>», line 1, in <fragment>
TypeError: not enough arguments for format string

1 2 3 4 5

another_string=»Я люблю %s и %s»%»Python» Traceback(most recent call last) File»<string>»,line1,in<fragment> TypeErrornotenough arguments forformatstring

О-па. Мы не передали необходимое количество аргументов для форматирования строки. Если вы внимательно взгляните на пример, вы увидите, что у нас есть два экземпляра %, но для того, чтобы вставить строки, вам нужно передать столько же %, сколько у нас строк. Теперь вы готовы к тому, чтобы узнать больше о вставке целых чисел, и чисел с запятыми. Давайте взглянем.

Python

my_string = «%i + %i = %i» % (1,2,3)
print(my_string) # ‘1 + 2 = 3’

float_string = «%f» % (1.23)
print(float_string) # ‘1.230000’

float_string2 = «%.2f» % (1.23)
print(float_string2) # ‘1.23’

float_string3 = «%.2f» % (1.237)
print(float_string3) # ‘1.24’

1 2 3 4 5 6 7 8 9 10 11

my_string=»%i + %i = %i»%(1,2,3) print(my_string)# ‘1 + 2 = 3’ float_string=»%f»%(1.23) print(float_string)# ‘1.230000’ float_string2=»%.2f»%(1.23) print(float_string2)# ‘1.23’ float_string3=»%.2f»%(1.237) print(float_string3)# ‘1.24’

Первый пример достаточно простой. Мы создали строку, которая принимает три аргумента, и мы передаем их. В случае, если вы еще не поняли, Python не делает никаких дополнений в первом примере. Во втором примере, мы передаем число с запятой

Обратите внимание на то, что результат включает множество дополнительных нулей (1.230000). Нам это не нужно, так что мы указываем Python ограничить выдачу до двух десятичных значений в третьем примере (“%.2f”)

Последний пример показывает, что Python округлит числа для вас, если вы передадите ему дробь, что лучше, чем два десятичных значения. Давайте взглянем на то, что произойдет, если мы передадим неправильные данные:

Python

int_float_err = «%i + %f» % («1», «2.00»)
Traceback (most recent call last):
File «<string>», line 1, in <fragment>
TypeError: %d format: a number is required, not str

1 2 3 4

int_float_err=»%i + %f»%(«1″,»2.00») Traceback(most recent call last) File»<string>»,line1,in<fragment> TypeError%dformatanumber isrequired,notstr

В данном примере мы передали две строки вместо целого числа и дроби. Это привело к ошибке TypeError, что говорит нам о том, что Python ждал от нас чисел. Это указывает на отсутствие передачи целого числа, так что мы исправим это, по крайней мере, попытаемся:

Python

int_float_err = «%i + %f» % (1, «2.00»)

Traceback (most recent call last):
File «<string>», line 1, in <fragment>
TypeError: float argument required, not str

1 2 3 4 5

int_float_err=»%i + %f»%(1,»2.00″) Traceback(most recent call last) File»<string>»,line1,in<fragment> TypeErrorfloatargument required,notstr

Мы получили ту же ошибку, но под другим предлогом, в котором написано, что мы должны передать дробь. Как мы видим, Python предоставляет нам полезную информацию о том, что же пошло не так и как это исправить. Если вы исправите вложения надлежащим образом, тогда вы сможете запустить этот пример. Давайте перейдем к новому методу форматирования строк.

Используем стек

# Python code to reverse a string  
# using stack 
  
# Function to create an empty stack. It  
# initializes size of stack as 0 
def createStack(): 
    stack=[] 
    return stack 
   
# Function to determine the size of the stack 
def size(stack): 
    return len(stack) 
   
# Stack is empty if the size is 0 
def isEmpty(stack): 
    if size(stack) == 0: 
        return true 
   
# Function to add an item to stack . It 
# increases size by 1     
def push(stack,item): 
    stack.append(item) 
   
# Function to remove an item from stack.  
# It decreases size by 1 
def pop(stack): 
    if isEmpty(stack): return
    return stack.pop() 
   
# A stack based function to reverse a string 
def reverse(string): 
    n = len(string) 
       
    # Create a empty stack 
    stack = createStack() 
   
    # Push all characters of string to stack 
    for i in range(0,n,1): 
        push(stack,string) 
   
    # Making the string empty since all 
    # characters are saved in stack     
    string="" 
   
    # Pop all characters of string and put 
    # them back to string 
    for i in range(0,n,1): 
        string+=pop(stack) 
           
    return string 
  
# Driver code 
s = "Pythonist"
print ("The original string  is : ",end="") 
print (s) 
print ("The reversed string(using stack) is : ",end="") 
print (reverse(s)) 

The original string  is : Pythonist
The reversed string(using stack) is : tsinohtyP   

Объяснение: Создаем пустой стек. Один за другим символы строки помещаются в стек. Один за другим выталкиваются все символы из стека и собираются в строку.

Поиск подстроки в строке

Чтобы в Python выполнить поиск в строке, используют метод find(). Он имеет три формы и возвращает индекс 1-го вхождения подстроки в строку:
• find(str): поиск подстроки str производится с начала строки и до её конца;
• find(str, start): с помощью параметра start задаётся начальный индекс, и именно с него и выполняется поиск;
• find(str, start, end): посредством параметра end задаётся конечный индекс, поиск выполняется до него.

Когда подстрока не найдена, метод возвращает -1:

    welcome = "Hello world! Goodbye world!"
index = welcome.find("wor")
print(index)       # 6

# ищем с десятого индекса
index = welcome.find("wor",10)
print(index)       # 21

# ищем с 10-го по 15-й индекс
index = welcome.find("wor",10,15)
print(index)       # -1

Другие методы для работы со строками в Python

В языке Пайтон имеется большое кол-во различных методов для работы со строками. Если рассматривать их все в этой статье, то она может увеличить раза в три, а то и больше. Подробное описание работы всех методов можно найти в официальной документации к языку на сайте https://python.org/

How to access characters in a string?

We can access individual characters using indexing and a range of characters using slicing. Index starts from 0. Trying to access a character out of index range will raise an . The index must be an integer. We can’t use floats or other types, this will result into .

Python allows negative indexing for its sequences.

The index of refers to the last item, to the second last item and so on. We can access a range of items in a string by using the slicing operator (colon).

When we run the above program, we get the following output:

str =  programiz
str =  p
str =  z
str =  rogr
str =  am

If we try to access an index out of the range or use numbers other than an integer, we will get errors.

Slicing can be best visualized by considering the index to be between the elements as shown below.

If we want to access a range, we need the index that will slice the portion from the string.

String Slicing in Python

Python F-Строки: Детали

На данный момент мы узнали почему f-строки так хороши, так что вам уже может быть интересно их попробовать в работе. Рассмотрим несколько деталей, которые нужно учитывать:

Кавычки

Вы можете использовать несколько типов кавычек внутри выражений. Убедитесь в том, что вы не используете один и тот же тип кавычек внутри и снаружи f-строки.

Этот код будет работать:

Python

print(f»{‘Eric Idle’}»)
# Вывод: ‘Eric Idle’

1 2	print(f»{‘Eric Idle’}») # Вывод: ‘Eric Idle’

И этот тоже:

Python

print(f'{«Eric Idle»}’)
# Вывод: ‘Eric Idle’

1 2	print(f'{«Eric Idle»}’) # Вывод: ‘Eric Idle’

Вы также можете использовать тройные кавычки:

Python

print(f»»»Eric Idle»»»)
# Вывод: ‘Eric Idle’

1 2	print(f»»»Eric Idle»»») # Вывод: ‘Eric Idle’

Python

print(f»’Eric Idle»’)
# Вывод: ‘Eric Idle’

1 2	print(f»’Eric Idle»’) # Вывод: ‘Eric Idle’

Если вам понадобиться использовать один и тот же тип кавычек внутри и снаружи строки, вам может помочь :

Python

print(f»The \»comedian\» is {name}, aged {age}.»)
# Вывод: ‘The «comedian» is Eric Idle, aged 74.’

1 2	print(f»The \»comedian\» is {name}, aged {age}.») # Вывод: ‘The «comedian» is Eric Idle, aged 74.’

Словари

Говоря о кавычках, будьте внимательны при работе со . Вы можете вставить значение словаря по его ключу, но сам ключ нужно вставлять в одиночные кавычки внутри f-строки. Сама же f-строка должна иметь двойные кавычки.

Вот так:

Python

comedian = {‘name’: ‘Eric Idle’, ‘age’: 74}

print(f»The comedian is {comedian}, aged {comedian}.»)
# Вывод: The comedian is Eric Idle, aged 74.

1 2 3 4

comedian={‘name»Eric Idle’,’age’74} print(f»The comedian is {comedian}, aged {comedian}.») # Вывод: The comedian is Eric Idle, aged 74.

Обратите внимание на количество возможных проблем, если допустить ошибку в синтаксисе SyntaxError:

Python

>>> comedian = {‘name’: ‘Eric Idle’, ‘age’: 74}
>>> f’The comedian is {comedian}, aged {comedian}.’
File «<stdin>», line 1
f’The comedian is {comedian}, aged {comedian}.’
^
SyntaxError: invalid syntax

1 2 3 4 5 6

>>>comedian={‘name»Eric Idle’,’age’74} >>>f’The comedian is {comedian}, aged {comedian}.’ File»<stdin>»,line1 f’The comedian is {comedian}, aged {comedian}.’ ^ SyntaxErrorinvalid syntax

Если вы используете одиночные кавычки в ключах словаря и снаружи f-строк, тогда кавычка в начале ключа словаря будет интерпретирован как конец строки.

Скобки

Чтобы скобки появились в вашей строке, вам нужно использовать двойные скобки:

Python

print(f»`74`»)

# Вывод: ‘{ 74 }’

1 2 3

print(f»`74`»)   # Вывод: ‘{ 74 }’

Обратите внимание на то, что использование тройных скобок приведет к тому, что в строке будут только одинарные:

Python

print( f»{`74`}» )

# Вывод: ‘{ 74 }’

1 2 3

print(f»{`74`}»)   # Вывод: ‘{ 74 }’

Однако, вы можете получить больше отображаемых скобок, если вы используете больше, чем три скобки:

Python

print(f»{{`74`}}»)

# Вывод: ‘`74`’

1 2 3

print(f»{{`74`}}»)   # Вывод: ‘`74`’

Бэкслеши

Как вы видели ранее, вы можете использовать бэкслеши в части строки f-string. Однако, вы не можете использовать бэкслеши в части выражения f-string:

Python

>>> f»{\»Eric Idle\»}»
File «<stdin>», line 1
f»{\»Eric Idle\»}»
^
SyntaxError: f-string expression part cannot include a backslash

1 2 3 4 5

>>>f»{\»Eric Idle\»}» File»<stdin>»,line1 f»{\»Eric Idle\»}» ^ SyntaxErrorf-stringexpression part cannot includeabackslash

Вы можете проработать это, оценивая выражение заранее и используя результат в f-строк:

Python

name = «Eric Idle»
print(f»{name}»)

# Вывод: ‘Eric Idle’

1 2 3 4

name=»Eric Idle» print(f»{name}»)   # Вывод: ‘Eric Idle’

Междустрочные комментарии

Выражения не должны включать комментарии с использованием символа #. В противном случае, у вас будет ошибка синтаксиса SyntaxError:

Python

>>> f»Eric is {2 * 37 #Oh my!}.»
File «<stdin>», line 1
f»Eric is {2 * 37 #Oh my!}.»
^
SyntaxError: f-string expression part cannot include ‘#’

1 2 3 4 5

>>>f»Eric is {2 * 37 #Oh my!}.» File»<stdin>»,line1 f»Eric is {2 * 37 #Oh my!}.» ^ SyntaxErrorf-stringexpression part cannot include’#’

Python Tutorial

Python HOMEPython IntroPython Get StartedPython SyntaxPython CommentsPython Variables
Python Variables
Variable Names
Assign Multiple Values
Output Variables
Global Variables
Variable Exercises

Python Data TypesPython NumbersPython CastingPython Strings
Python Strings
Slicing Strings
Modify Strings
Concatenate Strings
Format Strings
Escape Characters
String Methods
String Exercises

Python BooleansPython OperatorsPython Lists
Python Lists
Access List Items
Change List Items
Add List Items
Remove List Items
Loop Lists
List Comprehension
Sort Lists
Copy Lists
Join Lists
List Methods
List Exercises

Python Tuples
Python Tuples
Access Tuples
Update Tuples
Unpack Tuples
Loop Tuples
Join Tuples
Tuple Methods
Tuple Exercises

Python Sets
Python Sets
Access Set Items
Add Set Items
Remove Set Items
Loop Sets
Join Sets
Set Methods
Set Exercises

Python Dictionaries
Python Dictionaries
Access Items
Change Items
Add Items
Remove Items
Loop Dictionaries
Copy Dictionaries
Nested Dictionaries
Dictionary Methods
Dictionary Exercise

Python If…ElsePython While LoopsPython For LoopsPython FunctionsPython LambdaPython ArraysPython Classes/ObjectsPython InheritancePython IteratorsPython ScopePython ModulesPython DatesPython MathPython JSONPython RegExPython PIPPython Try…ExceptPython User InputPython String Formatting

Нарезка строк

Одной из тем, которую вы часто будете делать на практике, является нарезка строк. Помню, меня удивило то, как часто мне нужно было узнать, как это делается в повседневной работе. Давайте посмотрим, как нарезка сработает в следующей строке:

Python

my_string = «I like Python!»

1	my_string=»I like Python!»

Каждый символ в строке может стать доступным при помощи слайсинга (нарезки). Например, если вам нужно взять только первый символ, вы можете сделать это следующим образом:

Python

print( my_string ) # I

1	print(my_string1)# I

Таким образом, мы берем первый символ в строке до второго символа, но, не включая его. Да, в Python отсчет ведется с нуля. Это проще понять, если мы определим позицию каждого символа в таблице:

Python

0 1 2 3 4 5 6 7 8 9 10 11 12 13 — I l i k e P y t h o n !

1	12345678910111213-IlikePython!

Таким образом, у нас есть строка длиной в 14 символов, начиная с нуля и до тринадцати. Давайте приведем несколько примеров, чтобы понять это лучше.

Python

my_string # ‘I’
my_string # ‘I like Pytho’
my_string # ‘I like Python’
my_string # ‘I like Python!’
my_string # ‘I like Py’
my_string # ‘I like Python!’
my_string # ‘like Python!’

1 2 3 4 5 6 7

my_string1# ‘I’ my_string12# ‘I like Pytho’ my_string13# ‘I like Python’ my_string14# ‘I like Python!’ my_string-5# ‘I like Py’ my_string# ‘I like Python!’ my_string2# ‘like Python!’

Как видно в данных примерах, мы можем назначить срез, лишь указав его начало (другими словами, my_string), конец среза (my_string), или оба (my_string). Мы можем даже использовать отрицательные значения, которые начинаются с конца строки. Так что в примере, где мы указали my_string, начало ведется с нуля и заканчивается 5 символами, перед концом строки. Вы можете задаться вопросом «Зачем мне это и где это можно применить?». Лично я использовал это для разбора записей с фиксированной шириной в файлах, или ситуативно для парсинга сложных названий файлов, с очень специфическими наименованиями. Также я использовал это для парсинга значений в бинарных файлах. Любая работа, которая включает в себя обработку текстовых файлов, может быть намного проще, если вы понимаете, как работает нарезка и как эффективно использовать данный инструмент. Вы также можете получить доступ к отдельным символам в строке с помощью индексации. Например:

Python

print(my_string) # I

1	print(my_string)# I

Данный код выдаст первый символ в строке.

Строчные методы

Python имеет набор строчных методов, которые вы можете использовать в строках.

Примечание: Все строчные методы возвращают новые значения. Они не меняют исходную строку.

Метод	Описание
capitalize()	Преобразует первый символ в верхний регистр
casefold()	Преобразует строку в нижний регистр
center()	Возвращает центрированную строку
count()	Возвращает количество раз, когда определенное значение встречается в строке
encode()	Возвращает закодированную версию строки
endswith()	Возвращает true, если строка заканчивается указанным значением
expandtabs()	Устанавливает размер вкладки строки
find()	Ищет строку для указанного значения и возвращает позицию, где оно было найдено
format()	Форматирует указанные значения в строке
format_map()	Форматирует указанные значения в строке
index()	Ищет строку для указанного значения и возвращает позицию, где оно было найдено
isalnum()	Возвращает True, если все символы в строке алфавитно-цифровые
isalpha()	Возвращает True, если все символы в строке находятся по алфавиту
isdecimal()	Возвращает True, если все символы в строке являются десятичными
isdigit()	Возвращает True, если все символы в строке являются цифрами
isidentifier()	Возвращает True, если строка является идентификатором
islower()	Возвращает True, если все символы в строке строчные
isnumeric()	Возвращает True, если все символы в строке являются числовыми
isprintable()	Возвращает True, если все символы в строке пригодны для печати
isspace()	Возвращает True, если все символы в строке являются пробелами
istitle()	Возвращает True, если строка соответствует правилам заголовка
isupper()	Возвращает True, если все символы в строке в верхнем регистре
join()	Объединяет элементы итерируемого до конца строки
ljust()	Возвращает выровненную по левому краю версию строки
lower()	Преобразует строку в нижний регистр
lstrip()	Возвращает левую версию строки
maketrans()	Возвращает таблицу перевода для использования в переводах
partition()	Возвращает кортеж, в котором строка разделена на три части
replace()	Возвращает строку, в которой указанное значение заменено указанным значением.
rfind()	Ищет в строке указанное значение и возвращает последнюю позицию того места, где оно было найдено
rindex()	Ищет в строке указанное значение и возвращает последнюю позицию того места, где оно было найдено
rjust()	Возвращает правильную версию строки
rpartition()	Возвращает кортеж, в котором строка разделена на три части
rsplit()	Разбивает строку в указанном разделителе и возвращает список
rstrip()	Возвращает правильную версию строки
split()	Разбивает строку в указанном разделителе и возвращает список
splitlines()	Разбивает строку при переносе строки и возвращает список
startswith()	Возвращает true, если строка начинается с указанного значения
strip()	Возвращает усеченную версию строки
swapcase()	Меняет регистр в нижний регистр и наоборот
title()	Преобразует первый символ каждого слова в верхний регистр
translate()	Возвращает переведенную строку
upper()	Преобразует строку в верхний регистр
zfill()	Заполняет строку указанным числом 0 значений в начале

❮ Prev
Next ❯

Пожалуйста, включите JavaScript для просмотра комментариев, предоставленных Disqus.