Python 3 работа со строками: Работа со строками в Python – функции, преобразование, форматирование

Содержание

Python 3: работа со строками

Здесь описаны функции и возможности, без которых в питоне будет туго.

Не забывайте, что результаты выполнения всех функций нужно где-то использовать или куда-то присваивать: сама исходная строка не меняется! 🙂

Почти любой тип можно привести к строке с помощью функции (точнее, конструктора) str.

>>> str(5)
'5'
>>> str(2.4)
'2.4'
>>> str(None)
'None'
>>> str([2, 3, 4])
'[2, 3, 4]'
>>> str(Exception)
"<class 'Exception'>"

Обратную операцию (преобразование строки в число) можно произвести с помощью int и float. Причём принимают они не только строки, но и байты.

>>> int(b"5")
5
>>> int("5")
5
>>> int("-28")
-28
>>> float("-24.6")
-24.6
>>> float("-3e11")
-300000000000.0
>>> float("0.3")
0.3

Заведём подопытные объекты bytes и str. Большинство указанных функций работают с обоими типами.

>>> b = b"a,B,c,D"
>>> u = "a,B,c,D"
>>> type(b)
<class 'bytes'>
>>> type(u)
<class 'str'>

С ними можно работать как с массивами. Причём если str по индексу возвращает символ, то bytes — число, и для преобразования его в символ придётся воспользоваться функцией chr.

>>> b[0]
97
>>> chr(b[0])
'a'
>>> u[0]
'a'

Диапазоны тоже работают. Отрицательный индекс означает отсчет с конца.

>>> b[0:2]
b'a,'
>>> b[2:4]
b'B,'
>>> b[1:4]
b',B,'
>>> u[1:4]
',B,'
>>> b[-1]
68
>>> b[:-1]
b'a,B,c,'
>>> b[:-2]
b'a,B,c'
>>> b[1:]
b',B,c,D'
>>> b[2:]
b'B,c,D'

count считает, сколько раз указанная строка находится внутри строки.

>>> u.count("a")
1
>>> u.count("A")
0
>>> b.count(b",")
3

decode у bytes преобразует байты в текст в соответствии с заданной кодировкой.

>>> ub = b.decode("utf-8")
>>> ub
'a,B,c,D'
>>> type(ub)
<class 'str'>

encode у str преобразует текст в байты.

>>> bu = u.encode("utf-8")
>>> bu
b'a,B,c,D'
>>> type(bu)
<class 'bytes'>

endswith проверяет, оканчивается ли строка/байты указанной строкой/байтами.

>>> b.endswith(b"C,d")
False
>>> b.endswith(b"c,D")
True

find ищет первое вхождение указанной строки или байтов в строке или байте. Возвращает позицию (счёт с 0) или -1, если ничего не нашлось. rfind — ищет с конца строки.

>>> b.find(b"c")
4
>>> u.rfind("c")
4

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

>>> sep = ", "
>>> arr = ["Саша", "Женя", "Петя", "Вася"]
>>> sep.join(arr)
'Саша, Женя, Петя, Вася'
>>> ";".join( ["1","2"] )
'1;2'

lower и upper переводят в нижний и верхний регистр соответственно. Для типа bytes будет работать только с английскими буквами.

>>> b.lower()
b'a,b,c,d'
>>> u.upper()
'A,B,C,D'

replace заменяет в строке одну подстроку на другую.

>>> u.replace("a", "Ы")
'Ы,B,c,D'
>>> b.replace(b",", b" or ")
b'a or B or c or D'

rjust позволяет привести короткую строку к нужной длине путём добавления перед ней пробелов или указанного символа. Для заполнения нулями можно использовать функцию zfill.

>>> tm = "18:02:"
>>> sec = "6"
>>> tm + sec
'18:02:6'
>>> tm + sec.rjust(2, "0")
'18:02:06'
>>> tm + sec.zfill(2)
'18:02:06'
>>> b.rjust(20)
b' a,B,c,D'

split разбивает строку на несколько по указанной строке. Можно ограничить количество разбиений. rsplit разбивает строку с обратной стороны. Возвращает массив.

>>> b.split(b",")
[b'a', b'B', b'c', b'D']
>>> u.split(",", 1)
['a', 'B,c,D']
>>> u.split(",", 2)
['a', 'B', 'c,D']
>>> u.rsplit(",", 1)
['a,B,c', 'D']
>>> u.split("а нету такой подстроки!")
['a,B,c,D']

Обработка строк в Python

В Python существуют несколько видов данных. Основные типы данных, с которыми вы столкнетесь – это string, ingteger, float, list, dict и tuple. В данной статье мы рассмотрим тип данных string (строка). Вы удивитесь тому, сколько всего можно делать со строками в Python. Также существует модуль string, который можно импортировать для получения доступа к еще большим возможностям, но мы рассмотрим его в другой статье. Вместо этого, мы пройдемся по следующим разделам:

  • Как создавать строки
  • Конкатенация строк
  • Методы строк
  • Замена строк

Как создать строку

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

my_string = «Добро пожаловать в Python!»
another_string = ‘Я новый текст тут…’

a_long_string = »’А это у нас
новая строка
в троичных скобках»’

my_string = «Добро пожаловать в Python!»

another_string = ‘Я новый текст тут…’

 

a_long_string = »’А это у нас

новая строка

в троичных скобках»’

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

my_string = «I’m a Python programmer!»
otherString = ‘Слово «Python» обычно подразумевает змею’
tripleString = «»»В такой «строке» мы можем ‘использовать’ все.»»»

my_string = «I’m a Python programmer!»

otherString = ‘Слово «Python» обычно подразумевает змею’

tripleString = «»»В такой «строке» мы можем ‘использовать’ все.»»»

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

my_number = 123
my_string = str(my_number)

my_number = 123

my_string = str(my_number)

Если вы впишете данный код в ваш интерпретатор, вы увидите, что вы изменили значение интегратора на строку и присвоили ее переменной my_string. Это называется кастинг, или конвертирование. Вы можете конвертировать некоторые типы данных в другие, например числа в строки. Но вы также заметите, что вы не всегда можете делать обратное, например, конвертировать строку вроде ‘ABC’ в целое число. Если вы сделаете это, то получите ошибку вроде той, что указана в этом примере:

int(‘ABC’)

Traceback (most recent call last):
File «<string>», line 1, in <fragment>
ValueError: invalid literal for int() with base 10: ‘ABC’

int(‘ABC’)

 

Traceback (most recent call last):

    File «<string>», line 1, in <fragment>

ValueError: invalid literal for int() with base 10: ‘ABC’

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

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

my_string = «abc»
my_string[0] = «d»

Traceback (most recent call last):
File «<string>», line 1, in <fragment>
TypeError: ‘str’ object does not support item assignment

my_string = «abc»

my_string[0] = «d»

 

Traceback (most recent call last):

    File «<string>», line 1, in <fragment>

TypeError: ‘str’ object does not support item assignment

Здесь мы пытаемся изменить первую букву с «а» на «d«, в итоге это привело к ошибке TypeError, которая не дает нам сделать это. Теперь вы можете подумать, что присвоение новой строке то же значение и есть изменение строки. Давайте взглянем, правда ли это:

my_string = «abc»
a = id(my_string)
print(a) # 19397208

my_string = «def»
b = id(my_string)
print(b) # 25558288

my_string = my_string + «ghi»
c = id(my_string)
print(c) # 31345312

my_string = «abc»

a = id(my_string)

print(a) # 19397208

 

my_string = «def»

b = id(my_string)

print(b) # 25558288

 

my_string = my_string + «ghi»

c = id(my_string)

print(c) # 31345312

Проверив id объекта, мы можем определить, что когда мы присваиваем новое значение переменной, то это меняет тождество. Обратите внимание, что в версии Python, начиная с 2.0, строки могут содержать только символы ASCII. Если вам нужен Unicode, тогда вы должны вписывать u перед вашей строкой. Пример:

# -*- coding: utf-8 -*-
my_unicode_string = u»Это юникод!»

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

my_unicode_string = u»Это юникод!»

В Python, начиная с версии 3, все строки являются юникодом.

Есть вопросы по Python?

На нашем форуме вы можете задать любой вопрос и получить ответ от всего нашего сообщества!

Telegram Чат & Канал

Вступите в наш дружный чат по Python и начните общение с единомышленниками! Станьте частью большого сообщества!

Паблик VK

Одно из самых больших сообществ по Python в социальной сети ВК. Видео уроки и книги для вас!

Конкатенация строк

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

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

string_one = «Собака съела »
string_two = «мою книгу!»
string_three = string_one + string_two

print(string_three) # Собака съела мою книгу!

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

 

string_one = «Собака съела «

string_two = «мою книгу!»

string_three = string_one + string_two

 

print(string_three) # Собака съела мою книгу!

Оператор + конкатенирует две строки в одну

Методы строк

Строка является объектом в Python. Фактически, все, что есть в Python – является объектом. Если вы хотите узнать больше об Объектно-ориентированном программирование, мы рассмотрим это в другой статье «Классы в Python«. В данный момент достаточно знать, что строки содержат собственные встроенные методы. Например, допустим, у вас есть следующая строка:

my_string = «This is a string!»

my_string = «This is a string!»

Теперь вам нужно сделать так, чтобы вся эта строка была в верхнем регистре. Чтобы сделать это, все, что вам нужно, это вызвать метод upper(), вот так:

Если вы открыли ваш интерпретатор, вы также можете сделать то же самое:

«This is a string!».upper()

«This is a string!».upper()

Существует великое множество других методов строк. Например, если вам нужно, что бы все было в нижнем регистре, вам нужно использовать метод lower(). Если вы хотите удалить все начальные и конечные пробелы, вам понадобится метод strip(). Для получения списка всех методов строк, впишите следующую команду в ваш интерпретатор:

Вы увидите что-то на подобие этого:

[‘__add__’, ‘__class__’, ‘__contains__’, ‘__delattr__’, ‘__doc__’, ‘__eq__’, ‘__format__’,
‘__ge__’, ‘__getattribute__’, ‘__getitem__’, ‘__getnewargs__’, ‘__getslice__’, ‘__gt__’,
‘__hash__’, ‘__init__’, ‘__le__’, ‘__len__’, ‘__lt__’, ‘__mod__’, ‘__mul__’, ‘__ne__’,
‘__new__’, ‘__reduce__’, ‘__reduce_ex__’, ‘__repr__’, ‘__rmod__’, ‘__rmul__’, ‘__-
setattr__’, ‘__sizeof__’, ‘__str__’, ‘__subclasshook__’, ‘_formatter_field_name_split’,
‘_formatter_parser’, ‘capitalize’, ‘center’, ‘count’, ‘decode’, ‘encode’, ‘endswith’, ‘expandtabs’,
‘find’, ‘format’, ‘index’, ‘isalnum’, ‘isalpha’, ‘isdigit’, ‘islower’, ‘isspace’,
‘istitle’, ‘isupper’, ‘join’, ‘ljust’, ‘lower’, ‘lstrip’, ‘partition’, ‘replace’, ‘rfind’, ‘rindex’,
‘rjust’, ‘rpartition’, ‘rsplit’, ‘rstrip’, ‘split’, ‘splitlines’, ‘startswith’, ‘strip’, ‘swapcase’,
‘title’, ‘translate’, ‘upper’, ‘zfill’]

[‘__add__’, ‘__class__’, ‘__contains__’, ‘__delattr__’, ‘__doc__’, ‘__eq__’, ‘__format__’,

‘__ge__’, ‘__getattribute__’, ‘__getitem__’, ‘__getnewargs__’, ‘__getslice__’, ‘__gt__’,

‘__hash__’, ‘__init__’, ‘__le__’, ‘__len__’, ‘__lt__’, ‘__mod__’, ‘__mul__’, ‘__ne__’,

‘__new__’, ‘__reduce__’, ‘__reduce_ex__’, ‘__repr__’, ‘__rmod__’, ‘__rmul__’, ‘__-

setattr__’, ‘__sizeof__’, ‘__str__’, ‘__subclasshook__’, ‘_formatter_field_name_split’,

‘_formatter_parser’, ‘capitalize’, ‘center’, ‘count’, ‘decode’, ‘encode’, ‘endswith’, ‘expandtabs’,

‘find’, ‘format’, ‘index’, ‘isalnum’, ‘isalpha’, ‘isdigit’, ‘islower’, ‘isspace’,

‘istitle’, ‘isupper’, ‘join’, ‘ljust’, ‘lower’, ‘lstrip’, ‘partition’, ‘replace’, ‘rfind’, ‘rindex’,

‘rjust’, ‘rpartition’, ‘rsplit’, ‘rstrip’, ‘split’, ‘splitlines’, ‘startswith’, ‘strip’, ‘swapcase’,

‘title’, ‘translate’, ‘upper’, ‘zfill’]

Вы можете спокойно игнорировать методы, которые начинаются и заканчиваются двойным подчеркиванием, например __add__. Они не используются в ежедневном программировании в Python. Лучше обратите внимание на другие. Если вы хотите узнать, что делает тот или иной метод, просто обратитесь к справке. Например, если вы хотите узнать, зачем вам capitalize, впишите следующее, чтобы узнать:

help(my_string.capitalize)

help(my_string.capitalize)

Вы получите следующую информацию:

Help on built-in function capitalize:

capitalize(…)
S.capitalize() -> string

Выдача копии строки S только с заглавной буквой.

Help on built-in function capitalize:

 

capitalize(…)

    S.capitalize() -> string

 

Выдача копии строки S только с заглавной буквой.

Вы только что узнали кое-что о разделе, под названием интроспекция. Python может исследовать все свои объекты, что делает его очень легким в использовании. В основном, интроспекция позволяет вам спрашивать Python о нём. Вам моет быть интересно, как сказать о том, какой тип переменной был использован (другими словами int или string). Вы можете спросить об этом у Python!

type(my_string) # <type ‘str’>

type(my_string) # <type ‘str’>

Как вы видите, тип переменной my_string является str!

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

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

my_string = «I like Python!»

my_string = «I like Python!»

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

print( my_string[0:1] ) # I

print( my_string[0:1] ) # I

Таким образом, мы берем первый символ в строке до второго символа, но, не включая его. Да, в 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 !

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 !

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

my_string[:1] # ‘I’
my_string[0:12] # ‘I like Pytho’
my_string[0:13] # ‘I like Python’
my_string[0:14] # ‘I like Python!’
my_string[0:-5] # ‘I like Py’
my_string[:] # ‘I like Python!’
my_string[2:] # ‘like Python!’

my_string[:1] # ‘I’

my_string[0:12] # ‘I like Pytho’

my_string[0:13] # ‘I like Python’

my_string[0:14] # ‘I like Python!’

my_string[0:-5] # ‘I like Py’

my_string[:] # ‘I like Python!’

my_string[2:] # ‘like Python!’

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

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

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

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

# -*- 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 и яблоки

# -*- 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 попытается вставить ее в строку. Вы можете вставить несколько строк, добавив несколько знаков процента в свою строку. Это видно в последнем примере. Обратите внимание на то, что когда вы добавляете больше одной строки, вам нужно закрыть эти строки в круглые скобки. Теперь взглянем на то, что случится, если мы вставим недостаточное количество строк:

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

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

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

 

Traceback (most recent call last):

    File «<string>», line 1, in <fragment>

TypeError: not enough arguments for format string

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

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’

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 округлит числа для вас, если вы передадите ему дробь, что лучше, чем два десятичных значения. Давайте взглянем на то, что произойдет, если мы передадим неправильные данные:

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

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

В данном примере мы передали две строки вместо целого числа и дроби. Это привело к ошибке TypeError, что говорит нам о том, что 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

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

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

Шаблоны и новая методика форматирования строк

Этот метод был добавлен в Python 2.4 в виде шаблонов строк, но в качестве обычного метода string, работающего через метод format в версии 2.6. Так что это не самый свежий метод, просто обновленный. В любом случае, приступим к работе с шаблонами!

print(«%(lang)s is fun!» % {«lang»:»Python»}) # Python is fun!

print(«%(lang)s is fun!» % {«lang»:»Python»}) # Python is fun!

Должно быть это выглядит странно, но на самом деле мы сменили наши % на %(lang), с тем отличием, что данный объект идет в комплекте с переменной. Вторая часть пример вызывает словарь Python, который мы рассмотрим в следующей статье. В основном, это пара key:value, так что когда Python ищет ключ lang в строке и в указанном словаре ключей, он заменяет этот ключ его значением. Давайте взглянем на следующие примеры:

a = «%(value)s %(value)s %(value)s !» % {«value»:»SPAM»}
print(a) # SPAM SPAM SPAM !

b = «%(x)i + %(y)i = %(z)i» % {«x»:1, «y»:2}
print(b)

Traceback (most recent call last):
File «<string>», line 1, in <fragment>
KeyError: ‘z’

c = «%(x)i + %(y)i = %(z)i» % {«x»:1, «y»:2, «z»:3}
print(c) # 1 + 2 = 3

a = «%(value)s %(value)s %(value)s !» % {«value»:»SPAM»}

print(a) # SPAM SPAM SPAM !

 

b = «%(x)i + %(y)i = %(z)i» % {«x»:1, «y»:2}

print(b)

 

Traceback (most recent call last):

   File «<string>», line 1, in <fragment>

KeyError: ‘z’

 

c = «%(x)i + %(y)i = %(z)i» % {«x»:1, «y»:2, «z»:3}

print(c) # 1 + 2 = 3

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

a = «Python is as simple as {0}, {1}, {2}».format(«a», «b», «c»)
print(a) # ‘Python is as simple as a, b, c’

b = «Python is as simple as {1}, {0}, {2}».format(«a», «b», «c»)
print(b) # ‘Python is as simple as b, a, c’

xy = {«x»:0, «y»:10}
c = «Graph a point at where x={x} and y={y}».format(**xy)
print(c) # Graph a point at where x=0 and y=10

a = «Python is as simple as {0}, {1}, {2}».format(«a», «b», «c»)

print(a) # ‘Python is as simple as a, b, c’

 

b = «Python is as simple as {1}, {0}, {2}».format(«a», «b», «c»)

print(b) # ‘Python is as simple as b, a, c’

 

xy = {«x»:0, «y»:10}

c = «Graph a point at where x={x} and y={y}».format(**xy)

print(c) # Graph a point at where x=0 and y=10

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

Подведем итоги

Мы проработали большой объем в данной статье. Давайте разберемся:
Сначала мы узнали, как создавать строки, после чего мы перешли к вопросу об их конкатенации. После этого, мы взглянули на несколько методов, которые предлагает нам объект string. Далее, мы рассмотрели нарезку строк и закончили замещением строк.

Являюсь администратором нескольких порталов по обучению языков программирования Python, Golang и Kotlin. В составе небольшой команды единомышленников, мы занимаемся популяризацией языков программирования на русскоязычную аудиторию. Большая часть статей была адаптирована нами на русский язык и распространяется бесплатно.

E-mail: [email protected]

Образование
Universitatea Tehnică a Moldovei (utm.md)

  • 2014 — 2018 Технический Университет Молдовы, ИТ-Инженер. Тема дипломной работы «Автоматизация покупки и продажи криптовалюты используя технический анализ»
  • 2018 — 2020 Технический Университет Молдовы, Магистр, Магистерская диссертация «Идентификация человека в киберпространстве по фотографии лица»

Строки в Python. Создание, объединение, повторение.

Введение

Строки (strings) в Python представляют собой последовательности из одного или более знаков (букв, цифр, символов). И хотя мы можем использовать эту последовательность в каких-то операциях, сама она является неизменной. То есть строку нельзя изменить, не создав при этом другой объект, занимающий иной адрес в памяти.

Благодаря широкому распространению текста в повседневной жизни, строка является важным типом данных, присутствующим в мире программирования.

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

Создание строк и вывод их на экран

Строки в Python записываются либо с помощью одинарных » либо с помощью двойных «» кавычек. Поэтому, для того, чтобы создать строку, давайте заключим последовательность символов в один из видов этих кавычек.

'Это строка заключена в одинарные кавычки'
"Это строка заключена в двойные кавычки"

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

Мы можем выводить на экран наши строки просто используя функцию print().

print("Давайте выведем на экран эту строку!")

Давайте выведем на экран эту строку!

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

Конкатенация строк

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

Давайте соединим строки "Sammy" и "Shark" вместе с помощью функции print():

 print("Sammy" + "Shark")

SammyShark

Следите за тем, чтобы никогда не использовать оператор «+» между двумя разными типами данных. Например, мы не можем объединять строки и числа вместе. И вот что произойдет, если мы вдруг попробуем это сделать:

print("Sammy" + 27)

TypeError: Can't convert 'int' object to str implicitly

Если бы мы захотели создать строку "Sammy27", мы могли бы это сделать поставив число 27 в кавычки "27", таким образом превратив его из целого числа в строку. Преобразование числа в строку может быть полезным, когда мы, например, имеем дело с индексами или телефонными номерами. Например, когда нам нужно объединить телефонный код страны и телефонный номер, но при этом мы не хотим их складывать .

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

Как работает конкатенация строк в Python 3? Примеры.

Повторение строк

Однажды у вас могут возникнуть обстоятельства, при которых вы захотите использовать Python для автоматизации некоторых задач. И одной из таких задач может стать многократное повторение строки в тексте. Для того чтобы это осуществить, потребуется воспользоваться оператором *, который, как и оператор +, отличается от того, что используется вместе с числами. При использовании с одной строкой и одним числом * становится оператором повторения, а не умножения. Он лишь повторяет заданный текст указанное число раз.

Давайте выведем на экран "Sammy" 9 раз с помощью оператора *.

print("Sammy" * 9)

SammySammySammySammySammySammySammySammySammy

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

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

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

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

my_str = "Sammy likes declaring strings."

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

print(my_str)

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

Sammy likes declaring strings.

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

Заключение

Итак, в этом руководстве мы рассмотрели основы работы со строковыми данными в Python 3. А именно, научились создавать и выводить на экран строки, объединять их и повторять, а также сохранять строки в переменных. Но все это конечно же является лишь самыми начальными знаниями о возможностях использования строк в Python 3.

Марк Лутц «Изучаем Python»

Скачивайте книгу у нас в телеграм

Скачать

×

Лабораторная работа 5 Работа со строками в Python

Результат выполнения программы с использованием функций и методов работы со строками

Проверить, будет ли строка читаться одинаково справа налево и слева направо (т. е. является ли она палиндромом).

Сначала введём строку командой: s=input(‘Введите строку ‘).

Затем определим логическую переменную  flag и присвоим ей значение 1: flag=1.

Для начала в введённой строке нужно удалить пробелы. Для этого воспользуемся циклической конструкцией for, которая выполнится столько раз, какую имеет длину строка. Длину строки определим функцией len(s).

В теле цикла будем проверять следующее условие: s[i]!=’ ‘. Данное логическое выражение будет истинно в том случае, если i-ый элемент строки не будет равен пробелу, тогда выполнится команда следующая после двоеточия: string+=s[i].

К сроке string, которая была объявлена в начале программы, будет добавляться посимвольно строка s, но уже без пробелов.

Для проверки строки на «палиндром» воспользуемся циклической конструкцией for.

Длина половины строки находится делением нацело на 2.  Если количество символов нечетно,  то стоящий в середине не учитывается, т.к. его сравниваемая пара — он сам.

Количество повторов цикла равно длине половины строки. Длину строки определим функцией len(s), где аргумент введённая нами строка s. Зная длину строки, можно вычислить количество повторов цикла. Для этого целочисленно разделим длину строки на 2: len(s)//2.

Для задания диапазона для цикла используем функцию range(), в которой аргументом будет являться половина длины строки: range(len(s//2 )).

for i in range(len(s//2 )).

Если символ с индексом i не равен «симметричному» символу с конца строки (который находится путем индексации с конца)

if s[i] != s[-1-i],

то переменной flag присваивается значение 0 и происходит выход из цикла командой break. 

Далее, при помощи условной конструкции if-else в зависимости от значения flag либо — 0, либо -1 выводится сообщение, что строка палиндром, либо нет.

Пример программы на PythonРезультат выполнения программы

Задания для самостоятельной работы (по вариантам)

Работа со строками в Python OTUS

Язык программирования Python поддерживает разные виды данных. В этой статье, предназначенной для начинающих, будет рассмотрен строковый тип string и основные операции, связанные с обработкой строк. Среди них:

  • создание строк;
  • конкатенация строк;
  • выборка символов по индексам.

Создание строки

Строки (strings) используются для хранения текстовых данных. Их создание возможно одним из 3-х способов. Тут все просто, т. к. возможно применение разных кавычек: одинарных, двойных либо тройных. То есть в эти кавычки и нужно обернуть текст:

otus_string_1 = 'Привет, друзья!'

otus_string_2 = "Хотите выучить Python?"

otus_string_3 = """Ждем вас на наших курсах!"""

Кавычки в данном случае — это строковые литералы, позволяющие создавать в памяти программы Python объект типа string.

Нужно понимать, что разницы, какие именно кавычки использует разработчик, нет. Главное — открывающие и закрывающие кавычки должны быть однотипными. Если же поставить вначале одинарную кавычку, а в конце двойную — ошибки не избежать.

Можно ли применять кавычки внутри строк?

Можно, для чего есть несколько вариантов. Один из них — использовать внутри строки кавычки другого типа. К примеру, наружные кавычки являются двойными, а внутренние — одинарными. Или наоборот:

otus_string_1 = 'Хотите выучить "Пайтон?" и стать профессионалом'

otus_string_2 = "Запишитесь на курс в 'Отус' уже сегодня!"

Второй метод — экранирование. Для экранирования используется обратный слэш. Вот, как это выглядит в коде:

otus_string_1 = "Я и \'Пайтон\' созданы друг для друга"

У тройных кавычек есть особенности. Заключенные в них строки поддерживают многострочность, то есть для переноса не нужен символ \n. А еще внутри тройных кавычек можно вставлять как двойные, так и одинарные кавычки:

my_string = """Учитесь

программированию

в "Отус"!"""

print (my_string)

Вывод будет следующим:

Строки являются неизменяемыми объектами (как и числа). В этом легко убедиться, если создать переменные с одинаковыми именами, а потом вывести на экран их id — идентификаторы будут различаться:

otus_string = 'Привет, друзья!'

print(id(otus_string))

otus_string = "Хотите выучить Python?"

print(id(otus_string))

Рекомендуется повторить вышеописанные операции самостоятельно и попрактиковаться. Сделать это можно, даже не устанавливая «Пайтон», используя любой онлайн-компилятор.  

Конкатенация строк

Конкатенация — это сложение строк, в результате чего они соединяются друг с другом. Самый простой способ сделать это — использовать простейший оператор сложения, то есть знак «+».

Это простейший синтаксис, причем можно брать сколько угодно строк и соединять их:

otus_string = "Я " + "просто " + "обожаю " + "Python!"

print(otus_string)

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

otus_string = "Code" * 10

print(otus_string)

Важное свойство строк — длина (число символов). Узнать количество символов, из которых состоит строка, можно, задействовав встроенную функцию len (от англ. length — длина).

Код ниже посчитает число символов:

otus_string = "Python is a good for coding"

print(len(otus_string))

Итого: строка содержит 27 символов (пробел — тоже символ):

Можно попробовать передать пустую строку и постараться посчитать число символов в ней. Если вставить хотя бы пробел, на выходе получится 1 символ, если не вставлять вообще ничего, число символов будет равняться нулю.

otus_string_1 = ""

print(len(otus_string_1))

otus_string_2 = " "

print(len(otus_string_2))

Несколько слов о методах строк

Ранее уже использовались такие методы, как print и id. Есть свои методы и у строковых данных — они принадлежат конкретному классу str. Чтобы вывести их, можно воспользоваться функцией dir:

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

string_1 = "oTUs"

string_1 = string_1.title()

print(string_1)

string_1 = string_1.upper()

print(string_1)

string_1 = string_1.lower()

print(string_1)

Что отображено на скриншоте выше:

  • была создана новая строка string_1 с содержимым “oTUs”;
  • вначале задействовали метод title — вывод слова получился с заглавной буквы;
  • потом использовали метод для верхнего регистра upper — заглавными (прописными)  стали все символы строки;
  • далее применили lower — все символы стали маленькими (строчными), то есть перешли в нижний регистр.  

Какие еще есть методы:

  • replace —для замены одной части исходной строки (подстроки) на другую;
  • split — позволяет разделить (не удалить!) строку по переданному делителю, возвращает список;
  • join — склеивает подстроки по конкретному разделителю;
  • strip. В языке программирования Python strip используется для обрезки ненужных символов, причем ненужный символ передается в виде аргумента. Обрезку можно выполнять по-разному: если с первого символа слева, то применяют не strip, а lstrip, если справа, то rstrip (с конца строки, если интересует последний символ).

Индексы

В «Питоне» у каждого символа есть свой номер — индекс. Если разработчика интересует поиск какого-нибудь символа, к нему можно обратиться. Код ниже возвращает индекс для каждого символа из слова Otus:

string_1 = "Otus"

print(string_1[0])

print(string_1[1])

print(string_1[2])

print(string_1[3])

Тут важен один момент: индексация начинается не с единицы, а с нуля, поэтому первый символ имеет индекс 0.

Дополнительно: преобразование символа в целое число

Компьютеры хранят все данные в виде цифр, и символьных данных это тоже касается. Для представления символов строкового типа String применяют схему перевода. Самая простая из них — ASCII. Если нужно вернуть число для какого-нибудь конкретного символа, используют функцию ord. К примеру, для символа «a» кодовое значение по ASCII будет равняться 97, а для «#» — 35.

Кроме ASCII, также широко известен  Unicode, который тоже поддерживается «Питоном».

Источники:

  • https://zen.yandex.ru/media/id/5cab3ea044061700afead675/vse-o-strokah-v-python-5f60744e5622142b93b2031e;
  • https://pythonru.com/osnovy/stroki-python.

Python. Строки. Общие понятия. Объявление строки. Операции над строками. Примеры

Строки. Общие понятия. Объявление строки. Операции над строками. Примеры


Содержание


Поиск на других ресурсах:

1. Определение строки. Назначение строк

В языке программирования Python строка – это встроенный тип, который предназначен для сохранения и представления символьной или текстовой информации в упорядоченном виде. С синтаксической точки зрения строка – это последовательность символов, которая взятая в одинарные или двойные кавычки.

Строки обеспечивают использование всего что может быть представлено в текстовой форме, например:

  • информацию в файлах;
  • данные об именах, описаниях, комментариях в базах данных;
  • доменные имена в сети Internet;
  • информационные тексты в документах, которые поддерживают кодирование Unicode;
  • другое.

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

Примеры строк литералов.

"Hello world!"
'bestprog.net'
'1234567890'
"1234567890"
"I'm" # строка I'm - одинарные кавычки в двойных кавычках
'I"m' # строка I"m - двойные кавычки в одинарных кавычках

  ⇑

2. Какие строковые типы поддерживаются в Python?

В языке Python поддерживаются три типа строк:

  • строки типа str – предназначенные для представления текста в формате Unicode и других системах кодирования. Этот формат содержит символы в кодировке ASCII и символы в других кодировках;
  • строки типа bytes – предназначенные для представления двоичных данных;
  • строки типа bytearray – предназначенные для представления двоичных данных с учетом изменений в типе bytes.

В версии Python 2.6 для представления текста Unicode используется тип unicode.

  ⇑

3. Как объявить переменную типа «строка»? Общая форма

Чтобы объявить переменную типа строка достаточно использовать оператор присваивания =. Общая форма объявления переменной следующая

variable_name = string

где

  • variable_name – имя создаваемой переменной. В дальнейшем это имя используется в программе и связано со строкой string;
  • string – строка (литерал), размещенная между одинарными или двойными кавычки.


  ⇑

4. Примеры объявления строковых переменных

 

a = 'abcde' # объявление с помощью одинарной кавычки
b = "abcde" # объявление с помощью двойной кавычки
line = '' # пустая строка
block_s = """abcde""" # блок в тройной кавычке
s1 = b'hello' # строка байт в версиях 3.0 и старше
s2 = u'hello' # строка с символами Unicode
s3 = 's\np\ta\x00m' # экранированные последовательности
s4 = r'c:\myfolder\myfile1.txt' # неформатированная строка

  ⇑

5. Существует ли в Python тип, который описывает одиночный символ (например char)?

Нет, не существует. Для описания одиночного символа используется одна и та же строка, которая содержит только один символ (односимвольная строка), например:

firstLetter = 'A'
lastLetter = 'Z'
zero = '0'

  ⇑

6. Базовые операторы для работы со строками. Таблица

Над строками можно выполнять типичные операции. Для этого в языке Python перегружены соответствующие операторы.

Ниже в таблице приведен перечень операторов для работы с строками.

Оператор (операция) Использование в программах Объяснение
+ s1+s2 Конкатенация
* s*2 Повторение
[ ] s[i] Обращение к символу строки s по индексу i
[:] s[i:j] Вытягивание подстроки из позиции i до позиции j

  ⇑

7. Пример использования оператора + конкатенации (сложение) строк

Оператор конкатенации или сложения строк обозначается символом +. Оператор может использоваться в выражениях различной сложности.

Пример.

# Оператор конкатенации - сложение строк
s1 = 'Hello'
s2 = 'world!'
s3 = s1 + ' ' + s2 # s3 = 'Hello world!'

  ⇑

8. Пример использования оператора * повторения строк

Оператор повторения строк обозначается символом *. Оператор образовывает новый объект-строку, который повторяется заданное количество раз.

Пример. В примере строка s2 равна трем строкам s1

# Оператор повторения строк *
s1 = 'abc'
s2 = s1*3 # 'abcabcabc'

  ⇑

9. Пример использования оператора [] вытягивания элемента строки по ее индексу

Чтобы получить один символ строки, используется операция индексирования []. Ниже приведены примеры получения символа строки по ее индексу. Нумерация индексов начинается с 0.

Пример. В примере переменной c присваивается символ с индексом [1] строки s.

# Оператор [] - вытягивание символа в строке по ее индексу
s1 = 'abc'
c = s1[1] # c = 'b'

  ⇑

10. Пример использования оператора [:] вытягивания подстроки из строки

Оператор [:] используется для обработки подстрок в строках. Этот оператор имеет много разновидностей. Более подробно о работе оператора [:] описывается здесь. В данной теме приведены несколько ограниченных примеров использования оператора вытягивания строки из подстроки.

Пример.

# Оператор [:] - вытягивание символа в строке по индексу
s1 = '01234567890'
s2 = s1[2:4] # s2 = '23'
s3 = s1[:5] # s3 = '01234'
s4 = s1[:-1] # s4 = '0123456789'

  ⇑

11. Пример обхода строки с помощью оператора цикла for

В примере демонстрируется просмотр всех символов строки с помощью оператора цикла for. Решается задача просмотра количества символов ‘z’ в строке. Строка вводится с клавиатуры.

# Строки
# Пример обхода элементов строки в цикле

# 1. Ввод строки
s = str(input("Enter string: "))

# 2. Вывод строки для проверки - цикл обхода строки
for c in s:
    print(c, end=' ') # посимвольный вывод строки
print()

# 3. Определение количества символов 'z' в строке
count = 0;
for c in s:
    if c=='z':
        count = count+1

# вывод результата
print("count = ", count)

Результат выполнения программы

Enter string: zero z1sdlkj 12+laksd
z e r o   z 1 s d l k j   1 2 + l a k s d
count = 2

  ⇑

12. Сравнение строк. Рисунок. Примеры

Строки можно сравнивать между собой с помощью операций сравнения >, <, >=, <=, ==, !=.

Строки сравниваются по следующим правилам (рисунок 1):

  1. Направление сравнения происходит слева направо;
  2. Строки сравниваются посимвольно. Сравниваются коды соответствующих символов;
  3. Сравнение строк завершается при выполнении одного из следующих условий:
    • нарушается равенство кодов;
    • одна из строк оканчивается;
    • обе строки оканчиваются.

Рисунок 1. Сравнение строк: а) строки разной длины; б) строки одинаковой длины

Две строки считаются равными если их длина одинакова и они совпадают посимвольно (рисунок 2).

Рисунок 2. Пример одинаковых строк. Строка s1 равна строке s2

Пример. В примере демонстрируется ввод строк и вывод результата их сравнения.

# Ввод строк для сравнения
s1 = input("s1 = ")
s2 = input("s2 = ")

# Сравнение строк и вывод результата
if s1>s2:
    print("s1 > s2")
elif s1==s2:
    print("s1 == s2")
else:
    print("s1 < s2")

  ⇑


Связанные темы

  ⇑


 

Введение в Python. Часть 2. Строки

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

Съемка, монтаж: Глеб Лиманский

Давайте попробуем это сделать и напишем тему урока. Сегодня мы поговорим о таком типе данных в Python как строки. Чтобы сделать заголовок «Строки», прописываем текст в первой ячейке, затем в верхнем меню выбираем тип Heading и активируем ячейку (shift и enter). Теперь она выглядит как заголовок. Чтобы добавить подзаголовок «Как выглядят строки», делаем все то же самое, но выбираем тип Markdown.

Кроме этого, мы можем делать текстовые пометки в ячейке с кодом. Для этого перед текстом нужно поставить знак #. Когда мы запустим эту ячейку, программа выполнит код и проигнорирует текст после #.

Что такое строки

Строка в Python – это последовательный набор символов, который может состоять как из цифр, так и из букв, и разделителей. Для создания строки мы используем кавычки (одинарные или двойные – не имеет значения). Я напишу пример строки и присвою его переменной а. Например: a=’важные истории’ или b=’0123456789’. Давайте проверим, что а и b действительно строки. Определяем их тип: type(a) и type(b). И видим str (string) – это и означает, что перед нами именно строки.

Сложение строк

Первая операция со строками, которую мы изучим – конкатенация (или сложение строк). Давайте создадим две новые строки a=’важные’, b=’истории’. Строки в Python относятся к категории неизменяемых последовательностей, то есть все функции и методы могут лишь создавать новую строку. Поэтому, чтобы соединить a и b в одну новую строку – мы должны создать переменную c, и положить в нее a+b. И тогда мы получим новую строку, в которой будут соединены две предыдущие. Так как они соединились без разделителя, чтобы между словами был пробел, нам надо прописать его внутри первой строки: a=’важные ’, b=’истории’. Если мы сложим эти две строки, внутри которых находятся числа, эта операция не сложит эти цифры, а соединит их в одно выражение: a=’1 ’, b=’2’, с=a+b, c=’12’.

Дублирование строк 

Строки также можно дублировать. Для этого применяется операция умножения (*). Например, если мы умножим a*3, получим слово ’важные ’ с пробелом, записанное 3 раза.

Длина строк

Мы можем измерить длину строки, она равна количеству символов в строке. Давайте снова положим в переменную а слова ’важные истории’: a=’важные истории’ И измерим длину строки. Делается это так: len(a). Мы увидим, что длина строки равна количеству букв в словах ’важные истории’ плюс еще один символ – пробел.

Индексы

Каждый символ в строке имеет свой индекс – то есть порядковый номер. Но в Python эти номера начинаются не с 1, а с 0. То есть первый символ будет нулевым, второй первым, третий вторым и так далее. Давайте посмотрим на примере. Чтобы узнать индекс конкретного символа, есть специальная операция index(). Например, a.index(‘в’), где a – это название переменной, а в скобках искомое значение. Эта операция выдаст нам 0. Это значит, что буква «в» имеет нулевой индекс. Если мы таким же образом найдем индекс буквы «а», мы получим 1. Буква «и» встречается в строке 3 раза. Если мы попытаемся узнать индекс повторяющегося символа, мы получим индекс первой по порядку буквы «и», в данном случае – 7. Мы также можем узнать, какой символ записан под тем или иным индексом. Например, чтобы узнать, какой символ имеет нулевой индекс, мы должны написать следующую строчку кода: a[0]. Мы получим букву «в». Соответственно, a[1] покажет букву «а», и так далее. Индексы можно рассчитывать и с обратной стороны строки. Например, если мы напишем a[-3], то получим букву «р», которая стоит на третьем с конца месте строки.

Извлечение среза

Мы можем извлекать из строк не только отдельные символы, но и целые отрезки. Например, из выражения «важные истории», можно извлечь только слово «важные». Для этого нам надо написать конструкцию вида a[x:y], где x – индекс первого символа, а y – индекс последнего символа + 1. Так как индекс, записанный в «y» не включается, то например, когда мы указываем 6, мы подразумеваем, что последний индекс будет равен 5. К примеру, если мы укажем a[0:6], то получим первые 6 символов – слово «важные», несмотря на то, что индекс буквы «е» равен 5.

Если мы не укажем никаких символов – a[:], то код выдаст нам строку целиком, потому что по умолчанию x=0, а y=длине строки. Поэтому мы можем указывать только индекс начала отрезка или только индекс конца. a[7:] или a[:6].

Шаг среза

Мы так же можем указать шаг среза через еще одно двоеточие. Давайте сначала положим в переменную а цифры от 0 до 9: a=’0123456789′. И затем попросим отрезать все символы от первого до последнего с шагом 2: a[0:10:2]. Это означает, что мы выведем первый символ, второй пропустим, третий возьмем, четвертый пропустим и так далее.

Замена шаблона

Мы можем заменить часть строки на новую. Например, давайте превратим «важные истории» в «грустные истории». Делается это так: a=’важные истории’, b=a.replace(‘важные’,’грустные’), где на первом месте в скобках указывается старое значение, а на втором новое.

Изменение регистра текста

Можно изменить регистр текста внутри строки. Например, сейчас «важные истории» написаны в нижнем регистре, но с помощью операции upper() мы можем перевести буквы в верхний регистр и потом обратно в нижний с помощью операции lower().

Разделение строк

Строки можно разделять. За это отвечает операция split(). Например, b=a.split(). Тогда наше выражение поделится на два слова. В данном случае программа сама нашла разделитель – это пробел. Но не все символы он не считывает как разделители. Если бы слово «важные» было поделено на буквы с точками – «в.а.ж.н.ы.е.», операция разделения выдала бы следующий результат: [‘в.а.ж.н.ы.е’]. Чтобы получить список из букв слова «важные», мы можем указать разделитель – точку – самостоятельно: b=a.split(‘.’).

Если мы узнаем тип данных получившегося объекта, мы увидим, что это list – то есть список. О том, что такое списки в Python, мы расскажем в следующий выпусках мастерской. А пока рекомендую вам выполнить все операции из этого урока самостоятельно. А если что-то не получится, вы можете написать в наш чат в Telegram, и мы вам поможем. Кроме этого, практически на любой вопрос можно найти ответ на сайте Stack Overflow – это сервис вопросов и ответов о программировании, в котором пользователи помогают друг другу. Почти на все вопросы, которые возникали в процессе обучения Python у меня, там уже были ответы.

Работа со строками в Python 3

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

Создание строки

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

Python3

Строка = 'Hello Geek'

print ( "Создание строки с одинарными кавычками:" , String)

String = «да, я компьютерщик»

print ( «Создание строки с двойными кавычками:» , String)

String =

print ( "Создание строки с тройными кавычками:" , String)

Вывод

 Создание строки с одинарными кавычками: Hello Geek
Создание строки с двойными кавычками: да, я компьютерщик
Создание строки с тройными кавычками: да, я компьютерщик
 

Примечание: Будьте осторожны с цитатами!

Python3

Строка = 'Да' Я компьютерщик '

печать (Строка)

Вывод

 Файл "  ", строка 3
    String = 'Да, я компьютерщик'
                   ^
SyntaxError: недопустимый синтаксис
 

Причиной указанной выше ошибки является одинарная кавычка в Yes ’I остановил строку.Если вы хотите напечатать ‘WithQuotes’ на Python, это не может быть сделано только с одинарными (или двойными) кавычками, это требует одновременного использования обоих. Лучший способ избежать этой ошибки — использовать двойные кавычки.

Пример:

Python3

печать ( «WithQuotes» )

печать ( «Hello 'Python» )

печать ( '"WithQuotes"' )

печать ( 'Hello "Python"' )

Выход

 'WithQuotes'
Привет, Python
"WithQuotes"
Привет "Python"
 

Примечание: Для получения дополнительной информации см. Одинарные и двойные кавычки | Python

Индексирование строк

Строки — это последовательность символов, что означает, что Python может использовать индексы для вызова частей последовательности.Есть два способа индексации.

  • Положительное индексирование
  • Отрицательное индексирование

Положительное индексирование

Python3

Строка = "GEEK"

0

(печать) «Первый элемент:« , String [ 0 ]])

print ( »Второй элемент:« , String [ 1 ])

print ( "Третий элемент:" , String [ 2 ]])

print ( "Четвертый элемент это: « , String [ 3 ])

Выход

 Первый элемент: G
Второй элемент: E
Третий элемент: E
Четвертый элемент: K
 

Отрицательная индексация

Python3

Строка = "GEEK"

print ( "Строка, 4-й элемент:" " [ - 1 ])

print ( "Третий элемент:" , String [ - 2 ])

print ( "Второй элемент:" , String [ - 3 ]])

print ( "1-й элемент:" , String [ - 4 ])

Выход

 Четвертый элемент: K
Третий элемент: E
Второй элемент: E
1-й элемент: G
 

Обновление строк

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

Python3

Строка = «Гики»

Строка [ 0 ] = «Привет !, Гики»

Вывод

Прослеживание (последний звонок последним):
Файл «/ home / b298782a4e04df4950426bf4bd5bee99.py », строка 5, в
String [0] =« Hi !, Geeks »
TypeError: объект ‘str’ не поддерживает назначение элементов

Обновление всей строки

Python3

Строка = «Hello Geeks»

print ( «Перед обновлением:» , String)

String = «Geeksforgeeks»

print ( "После обновления:" , String)

String = 'Hello World!'

печать ( "Обновленная строка: -" , строка [: 6 ] + 'Python' )

Вывод

 До обновление: Hello Geeks
После обновления: Geeksforgeeks
Обновленная строка: - Hello Python
 

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

Нарезка Python — это получение подстроки из заданной строки путем нарезки ее соответственно от начала до конца.
Нарезку Python можно выполнить двумя способами.

  • Конструктор slice ()
  • Расширение индексации

Python3

Строка = «Geekforgeeks»

s18 s18 s18 slice 3 )

печать (строка [s1])

печать (строка [: 6 ])

печать (Строка [ 1 : 7 ])

Нарезка с отрицательным индексом.

Python3

Строка = «Geekforgeeks»

s1 = срез ( - ) 1

печать (строка [s1])

печать (строка [ 0 : - 3 ])

Выход

 Geekforgeek
Geekforge
 

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

Python3

Строка = "Geekforgeeks"

печать (Строка [:: 1 ])

печать (строка [ 2 :: 2 ])

печать (строка [:: - 1 ])

Выход

 Geekforgeeks
Эфрек
skeegrofkeeG
 

Примечание: Дополнительные сведения см. В разделе «Нарезка строки в Python»

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

str.format () и f-strings Методы используются для добавления форматированных объектов в напечатанные строковые операторы. Метод string format () форматирует данную строку. Он допускает множественные замены и форматирование значений.

Python3

Строка = 'Geeksforgeeks'

print ( "{}, портал информатики для вундеркиндов"

. формат (Строка))

Строка = «Компьютерщики»

печать ( «Привет {}, как дела?» . формат (Строка))

val = 2

печать ( «Я хочу {} Бургеры!» . формат ( val))

Вывод

 Geeksforgeeks, Портал информатики для гиков.Привет, выродки, как дела?
Я хочу 2 бургера!
 

Примечание: Для получения дополнительной информации см. Python | format () function

Форматированная f-строка литерала имеют префикс «f» и фигурные скобки {}, содержащие выражения, которые будут заменены их значениями.

Python3

String = 'GeekForGeeks'

print (f "{String}: портал компьютерных наук для вундеркиндов" )

String = 'Geek'

print (f «Да, я {String}» )

мешков = 3

book_in_bag = 12

print (f 'Всего {мешков * book_in_bag} книг' )

Dic = { 'Portal' : 'Geeksforgeeks' , 'для' : 'Geeks' }

print (f "{Dic ['Portal']} - это портал информатики для {Dic ['for']}" )

Вывод

 GeekForGeeks: A Computer Science портал для гиков
Да я компьютерщик
Всего 36 книг
Geeksforgeeks - портал компьютерных наук для компьютерных фанатов.
 

Примечание: Для получения дополнительной информации см. F-строки в Python 3 - форматированные строковые литералы

Внимание, компьютерщик! Укрепите свои основы с помощью курса Python Programming Foundation и изучите основы.

Для начала подготовьтесь к собеседованию. Расширьте свои концепции структур данных с помощью курса Python DS . И чтобы начать свое путешествие по машинному обучению, присоединяйтесь к Машинное обучение - курс базового уровня

Python Strings


Струны

Строки в Python заключаются в одинарные или двойные кавычки.

«привет» - это то же самое, что «привет».

Вы можете отобразить строковый литерал с помощью функции print () :


Назначить строку переменной

Присваивание строки переменной выполняется с именем переменной, за которым следует
знак равенства и строка:


Многострочные струны

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

Пример

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

a = "" "Lorem ipsum dolor sit amet,
consctetur adipiscing elit,
sed do
eiusmod tempor incididunt
ut labore et dolore magna aliqua."" "
принт (а)

Попробуй сам "

Или три одинарные кавычки:

Пример

a = '' 'Lorem ipsum dolor sit amet,
consctetur adipiscing elit,
sed do
eiusmod tempor incididunt
ut labore et dolore magna aliqua. ''
print (a)

Попробуй сам "

Примечание: в результате разрывы строк вставляются в ту же позицию, что и в коде.

Строки - это массивы

Как и во многих других популярных языках программирования, строки в Python представляют собой массивы байтов, представляющих символы Юникода.

Однако Python не имеет символьного типа данных, одиночный символ - это просто строка длиной 1.

Квадратные скобки могут использоваться для доступа к элементам строки.

Пример

Получить символ в позиции 1 (помните, что первый символ имеет
позиция 0):

a = "Привет, мир!"
отпечаток (a [1])

Попробуй сам "


Зацикливание на строке

Поскольку строки представляют собой массивы, мы можем перебирать символы в строке с помощью цикла для .

Пример

Прокрутите буквы в слове "банан":

для x в "банане":
print (x)

Попробуй сам "

Узнайте больше о циклах For Loops в нашей главе Python For Loops.


Длина строки

Чтобы получить длину строки, используйте функцию len () .

Пример

Функция len () возвращает длину строки:

a = "Привет, мир!"
принт (len (a))

Попробуй сам "


Контрольная строка

Чтобы проверить, присутствует ли в строке определенная фраза или символ, мы можем использовать
ключевое слово
в .

Пример

Проверьте, присутствует ли слово «бесплатно» в следующем тексте:

txt = "Все самое лучшее в жизни - бесплатно!"
print («бесплатно» в txt)

Попробуй сам "

Используйте его в заявлении if :

Пример

Печатать только при наличии «бесплатно»:

txt = "Все самое лучшее в жизни - бесплатно!"
если "бесплатно" в txt:
print ("Да, присутствует" бесплатный ".")

Попробуй сам "

Узнайте больше об операторах If в нашем Python
Если...Эта глава.


Проверить, НЕ

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

Пример

Проверьте, НЕ присутствует ли "дорого" в следующем тексте:

txt = "Все самое лучшее в жизни - бесплатно!"
print ("дорого" не в txt)

Попробуй сам "

Используйте его в заявлении if :

Пример

печатать только если "дорого" НЕТ:

txt = "Все самое лучшее в жизни - бесплатно!"
если "дорого" нет в txt:
print ("Нет," дорого "НЕТ.")

Попробуй сам "


Учебные пособия и примечания для струнных | Python

Строка Python:

Строки - это последовательности символов. Ваше имя можно рассматривать как строку. Или, скажем, вы живете в Замбии, тогда ваша страна называется «Замбия» , что является строкой.

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

Как создать строку и присвоить ее переменной

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

Например, вы можете присвоить символ «а» переменной single_quote_character . Обратите внимание, что строка представляет собой один символ и «заключена» в одинарные кавычки.

  >>> single_quote_character = 'a'
>>> print (одиночный_цифровый_символ)
а
>>> print (type (single_quote_character)) # проверяем тип переменной.<класс 'str'>
  

Аналогично, вы можете присвоить одиночный символ переменной double_quote_character . Обратите внимание, что строка состоит из одного символа, но «заключена» в двойные кавычки.

  >>> double_quote_character = "b"
>>> print (двойной_цифровый_символ)
б
>>> print (type (двойной_цифтовый_символ))
<класс 'str'>
  

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

  >>> double_quote_multiple_characters = "aeiou"
>>> single_quote_multiple_characters = 'aeiou'
>>> print (тип (двойные_цитаты_множественные_символы), тип (одинарные_цифровые_множественные_символы))
<класс 'str'> <класс 'str'>
  

Интересно, что если вы проверите эквивалентность одного другому с помощью ключевого слова is , оно вернет True.

  >>> print (double_quote_multiple_characters равно double_quote_multiple_characters)
Правда
  

Взгляните на присвоение строк с использованием тройных кавычек и проверьте, принадлежат ли они также к классу str .

  >>> triple_quote_example = "" "это предложение, написанное в тройных кавычках" ""
>>> print (введите (тройной_цифтовый_пример))
<класс 'str'>
  

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

Строковые стандартные методы

2 возвращается, потому что позиция отдельных букв в строках имеет нулевой индекс. Таким образом, индекс «a» в «abcde» равен 0, индекс «b» равен 1 и так далее.

  • Проверяет, является ли подстрока членом большей строки. Это делается с помощью ключевого слова в и написания теста. Скелет показан ниже.

    подстрока в строке

      >>> # например, проверить, присутствует ли строка "i" в строке "pythonic" хотя бы один раз.«i» присутствует в строке. Следовательно, результат должен быть верным.
    >>> "я" в "питоническом"
    Правда
    >>> # поскольку "x" не присутствует в строке "pythonic", приведенный ниже тест должен вернуть false
    >>> "x" в "pythonic" # "x" не присутствует в "pythonic"
    Ложь
      
  • Присоединитесь к списку строк, используя метод соединения. Список строк записывается путем разделения последовательности запятой , и заключения всей группы скобками [...] .Для более подробного руководства по спискам перейдите к руководству по спискам Python.
    Вы можете присоединиться к списку строк, указав разделитель в качестве объекта, на который будет действовать метод join , и список строк в качестве аргумента.

      >>> # объединить список строк 1, 2, 3 с пробелом в качестве разделителя и 1,2,3 в качестве списка строк. Итак, результатом будут строки с пробелами между ними.
    >>> Combined_string = "" .join (["1", "2", "3"])
    '1 2 3'
      
  • Разорвать строку по некоторому правилу.Это принимает строку как объект, которому передается метод split с использованием оператора точки. В качестве параметра по умолчанию для разделения используется пробел.

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

  >>> # разделить строку «1 2 3» и вернуть список чисел.
    >>> "1 2 3" .split () # разделение
    ['1', '2', '3']
  

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

  >>> «1: 2: 3» .split («:»)
     [‘1’, ‘2’, ‘3’]
  

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

Строковый объект можно форматировать. Вы можете использовать % s в качестве средства форматирования, которое позволит вам вставлять различные значения в строку во время выполнения и, таким образом, форматировать строку. Символ % s заменяется тем, что передается в строку.

  >>> print ("Я люблю% s в% s"% ("программирование", "Python")) # шаблонные строки
    'Я люблю программировать на Python'
  

Вы также можете использовать ключевое слово в формате .Это позволит вам установить собственные средства форматирования вместо % s .

  >>> print ("Я люблю {программирование} на {python}". Формат (программирование = "программирование", python = "Python"))
'Я люблю программировать на Python'
  

Проверка истинности строки

Строка в Python считается верной, если это не пустая строка. Итак, получаем следующее:

  # Проверить истинность пустой строки
>>> print (bool (""))
Ложь

# Проверить значение истинности непустой строки "x"
>>> print (bool ("x"))
Правда
  

Предоставил: Джойдип Бхаттачарджи

строк - Консервативное руководство по переносу Python 3 1.0 документация

С точки зрения разработчика, самое большое изменение в Python 3
это обработка строк.
В Python 2 тип str использовался для двух разных типов значений:
текст и байты , тогда как в Python 3 это отдельные и несовместимые типы.

  • Текст содержит удобочитаемые сообщения, представленные как последовательность
    Кодовые точки Unicode.
    Обычно он не содержит непечатаемых управляющих символов, таких как \ 0 .

    Этот тип доступен как str в Python 3 и unicode
    в Python 2.

    В коде мы будем называть этот тип unicode - короткий, однозначный
    name, хотя оно не встроено в Python 3.
    В некоторых проектах он обозначается как six.text_type
    (из шести библиотек).

  • Байт или строка байтов - это двоичный формат сериализации, подходящий для
    сохранение данных на диске или отправка по сети.Это последовательность
    целые числа от 0 до 255.
    Большинство данных - изображения, звук, информация о конфигурации или текст - могут быть
    сериализован (закодирован) в байты и десериализован (декодирован) из
    байтов, используя соответствующий протокол, такой как PNG, VAW, JSON
    или UTF-8.

    В Python 2.6+ и 3 этот тип доступен как байт .

В идеале каждое «вязкое» значение явно и недвусмысленно должно быть одним из
эти типы (или собственная строка ниже).
Это означает, что вам нужно просмотреть всю кодовую базу и решить
какое значение какого типа.К сожалению, этот процесс, как правило, нельзя автоматизировать.

Мы рекомендуем заменить слово «строка» в документации для разработчиков.
(включая строки документации и комментарии) с «текстом» / «текстовой строкой» или
«Байты» / «байтовая строка», в зависимости от ситуации.

Собственная строка

Кроме того, код, который поддерживает Python 2 и 3 в одной и той же кодовой базе.
можно использовать то, что концептуально является третьим типом:

  • Собственная строка ( str ) - текст в Python 3, байты в Python 2

Пользовательские методы __str__ и __repr__ и код, который имеет дело с
Объекты языка Python (например, имена атрибутов / функций) всегда должны
используйте собственную строку, потому что это то, что использует каждая версия Python
для внутренних текстовых данных.Тексты, ориентированные на разработчиков, такие как сообщения об исключениях, также могут быть родными
струны.

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

  • вы работаете с текстовыми данными,
  • В Python 2 каждое значение «собственной строки» имеет одно четко определенное
    кодировка (например, UTF-8 или locale.getpreferredencoding () ) и
  • вы не смешиваете собственные строки ни с байтами, ни с текстом - всегда
    усердно кодировать / декодировать при преобразовании в эти типы.

Нативные строки как можно меньше влияют на семантику в Python 2,
при этом не требуя, чтобы итоговый API Python 3 чувствовал себя плохо. Но, имея
третий несовместимый тип усложняет процесс переноса.
Родные струны подходят в основном для консервативных проектов, где обеспечение
стабильность под Python 2 оправдывает дополнительные усилия по переносу.

Преобразование текста в байты

Можно кодировать () текст в двоичные данные или
decode () байтов в текстовую строку с использованием определенной кодировки.Сам по себе объект bytes не имеет собственной кодировки, поэтому это невозможно.
кодировать / декодировать, не зная кодировки.

Это похоже на изображения: открытый файл изображения может быть закодирован в PNG, JPG или
другой формат изображения, поэтому файл невозможно "просто прочитать"
не полагаясь ни на внешние данные (такие как имя файла), ни эффективно
пробуя все альтернативы.
В отличие от изображений, одна строка байтов часто может быть успешно декодирована с использованием нескольких
чем одна кодировка.

Кодировки

Никогда не принимайте кодировку текста, не ознакомившись с соответствующей документацией.
и / или изучение вариантов использования строки.Если определена кодировка для конкретного варианта использования, задокументируйте ее.
Например, строка документации функции может указывать, что некоторый аргумент
«Строка байтов, содержащая текстовые данные в кодировке UTF-8», либо документация модуля может
поясните, что «согласно RFC 4514 имена атрибутов LDAP кодируются в UTF-8.
для трансмиссии ».

Некоторые общие текстовые кодировки:

  • UTF-8 : широко используемая кодировка, которая может кодировать любой текст Unicode,
    используя от одного до четырех байтов на символ.
  • UTF-16 : Используется в некоторых API, особенно в Windows и Java.Может также кодировать весь набор символов Unicode, но использует от двух до четырех байтов.
    на персонажа.
  • ascii : 7-битная (128-символьная) кодировка, полезная для некоторых
    машиночитаемые идентификаторы, такие как имена хостов ( 'python.org' ),
    или текстовые представления чисел ( '1234' , '127.0.0.1' ).
    Всегда проверяйте соответствующий стандарт / протокол / документацию, прежде чем принимать
    строка может быть только чистым ASCII.
  • locale.getpreferredencoding () : «Предпочтительная кодировка» для
    аргументы командной строки, переменные среды и ввод / вывод терминала.

Если , вы выбираете кодировку для использования - например, ваше приложение
определяет формат файла, а не использует формат, стандартизованный извне -
рассмотрим UTF-8 .
И что бы вы ни выбрали, явно задокументируйте это.

Преобразование в текст

В обеих версиях Python нет встроенной функции преобразования текста.
Библиотека six предоставляет six.text_type , и это нормально, если
появляется один или два раза в незамысловатом коде.Для лучшей читаемости мы рекомендуем использовать unicode ,
который недвусмысленен и понятен, но его нужно вводить с
следующий код в начале файла:

 попробовать:
    # Python 2: "юникод" встроен
    юникод
кроме NameError:
    unicode = str
 

Преобразование в байты

Нет хорошей функции, конвертирующей произвольный объект в байты,
поскольку эта операция не имеет смысла для произвольных объектов.
В зависимости от того, что вам нужно, явно используйте функцию сериализации
(е.грамм. pickle.dumps () ) или преобразовать в текст и закодировать текст.

Строковые литералы

  • Установщик: Нет
  • Распространенность: очень часто

Строковые литералы в кавычках могут иметь префикс b или u для получения байтов или
текст соответственно.
Эти префиксы работают как в Python 2 (2.6+), так и в 3 (3.3+).
Литералы без этих префиксов приводят к появлению собственных строк.

В Python 3 префикс u ничего не делает; это разрешено только назад
совместимость.Точно так же префикс b ничего не делает в Python 2.

Добавить префикс b или u ко всем строкам, кроме исходной строки
желательно.
К сожалению, выбор между текстом и байтами, как правило, нельзя автоматизировать.

Необработанные строки Unicode

  • Установщик: Нет
  • Распространенность: редко

В Python 2 префикс r может быть объединен с u , чтобы избежать обработки
обратная косая черта экранируется.
Однако этот не отключал обработку escape-последовательностей Unicode ( \ u.... или
\ U ........ ), поскольку префикс u имел приоритет над r :

 >>> print u "\ x23☺ \ u2744" # Python 2 с кодировкой: UTF-8
# ☺❄
>>> напечатайте ur "\ x23☺ \ u2744" # Python 2 с кодировкой: UTF-8
\ x23☺❄
 

Сначала это может сбивать с толку.
Сохранение этого было бы еще более запутанным в Python 3, где префикс u
не работает с обратной совместимостью.
Python 3 избегает выбора между запутанной или обратной несовместимостью
семантика, запретив вообще ur .

Избегайте префикса ur в строковых литералах.

Самый простой способ сделать это - использовать простые литералы и .
с \ для буквальной обратной косой черты:

 >>> print (u "\\ x23☺ \ u2744")
\ x23☺❄
 

Строковые операции

В Python 3 нельзя смешивать текст и байты.
Например, все это незаконно:

 b'one '+' two '

b ',' .join (['один', 'два'])

импортный ре
шаблон = re.compile (b'a + ')
шаблон.совпадение ('аааааа')
 

Кодировать или декодировать данные, чтобы типы совпадали.

Проверка типа

  • Исправитель: python-modernize -wnf libmodernize.fixes.fix_basestring
  • Распространенность: редко

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

, если isinstance (значение, базовая строка):
    print ("Тягучий!")
 

В Python 3 концепция базовой строки не имеет смысла: текст - это только
в лице ул. .

Для проверки типов текстовых строк в коде, совместимом с обеими версиями,
шесть библиотек предлагают string_types , что составляет (базовая строка,)
в Python 2 и (str,) в Python 3.
Приведенный выше код можно заменить на:

 импортные шесть

если isinstance (значение, six.string_types):
    print ("Тягучий!")
 

Рекомендуемый фиксатор импортирует шесть и заменит любое использование
basestring на string_types .

Файловый ввод / вывод

  • Исправитель: python-modernize -wnf libmodernize.fixes.fix_open
  • Распространенность: Обычный

В Python 2 чтение из файла, открытого с помощью open () , дало общий
ул. .
В Python 3 тип содержимого файла зависит от режима, в котором файл был открыт.
с участием. По умолчанию это текстовые строки; b в режиме выбирает байты:

 с открытым ('/ etc / passwd') как f:
    f.read () # текст

с open ('/ bin / sh', 'rb') как f:
    f.read () # байтов
 

На диске все файлы хранятся в байтах.Для файлов текстового режима их содержимое декодируется автоматически.
Кодировка по умолчанию - locale.getpreferredencoding (False) , но это может
не всегда подходят и могут вызывать разное поведение в разных системах.
Если кодировка файла известна, мы рекомендуем всегда указывать ее:

 с open ('data.txt', encoding = 'utf-8') как f:
    f.read ()
 

Аналогичные соображения применимы при записи в файлы.

Поведение open сильно различается между Python 2 и 3.Однако начиная с Python 2.6 версия Python 3 доступна в io .
модуль.
Мы рекомендуем заменить встроенную функцию open на io.open ,
и используя новую семантику - то есть текстовые файлы содержат unicode :

 из io import open

с open ('data.txt', encoding = 'utf-8') как f:
    f.read ()
 

Обратите внимание, что в Python 2 объект, возвращаемый io.open , имеет другой
типа, чем тот, который возвращается open .Если в вашем коде выполняется строгая проверка типов, ознакомьтесь с примечаниями к
file () встроенный.

Рекомендуемый фиксатор добавит из io import open import, но он
не будет добавлять аргументы кодировки .
Мы рекомендуем добавлять их вручную, если кодировка известна.

Тестовые строки

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

Многие из рекомендованных ниже тестов определяют поведение, которое
«Работает» в Python 2 (не вызывает исключения, но может приводить к незначительным ошибкам
результаты), а версия Python 3 потребует больше размышлений и кода.

Вы можете обнаружить ошибки в том, как версия Python 2 обрабатывает строки.
В этих случаях было бы неплохо включить новые тесты только для Python 3:
если некоторые ошибки в крайних случаях сохранились до сих пор, они, вероятно, доживут до
Python 2 больше не используется. Применяйте собственное суждение.

Вот что нужно проверить.

Данные, отличные от ASCII

Убедитесь, что ваше программное обеспечение работает (или, если необходимо, полностью дает сбой)
с вводом, отличным от ASCII, особенно от конечных пользователей.
Примеры символов для проверки:

  • é ñ ü Đ ř ů Å ß ç ı İ (от европейских личных имен)
  • A ffl ℚ ½ (альтернативные формы и лигатуры)
  • € ₹ ¥ (символы валюты)
  • η 글 ओ କ じ 字 (разные шрифты)
  • 🐍 💖 ♒ ♘ (символы и эмодзи)

Кодировки и локали

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

В Linux запустите свое программное обеспечение с переменной среды LC_ALL .
установить C и tr_TR.utf8 . Проверьте обработку любой командной строки
аргументы и переменные среды, которые могут содержать символы, отличные от ASCII.

Неверный ввод

Проверьте, как код обрабатывает недопустимый ввод текста.
Если ваше программное обеспечение работает с файлами, попробуйте использовать его с именем файла, отличным от UTF8.

Используя Python 3, такой файл может быть создан:

 с открытым (b'bad- \ xFF-filename ',' wb ') как файл:
    файл.написать (b'binary- \ xFF-data ')
 

Как соединить строки в Python 3

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

По этой причине неплохо на раннем этапе освоить все тонкости работы со строками. В Python это включает в себя обучение соединению строк.

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

Рекомендуемый курс обучения Python

Курс: Python 3 для начинающих

Более 15 часов видеоконтента с пошаговыми инструкциями для начинающих. Узнайте, как создавать реальные приложения, и освоите основы.

Маленькая теория струн

Как вы помните, в Python строки представляют собой массив символьных данных.

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

Мы можем проверить эту особенность Python, создав новую строковую переменную. Если мы попытаемся изменить символ в строке, Python выдаст нам ошибку трассировки.

  >>> my_string = "Python для начинающих"
>>> my_string [0]
'П'
>>> my_string [0] = 'p'
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
TypeError: объект 'str' не поддерживает назначение элементов
  

При написании кода Python следует помнить о неизменном качестве строк.

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

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

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

Объединение строк с помощью оператора «+»

Объединение - это соединение двух или более строк для создания единой новой строки.

В Python строки можно объединять с помощью оператора «+». Подобно математическому уравнению, этот способ соединения строк является прямым, что позволяет «сложить» множество строк.

Давайте взглянем на несколько примеров:

  # соединение строк с помощью оператора '+'
first_name = "Бильбо"
last_name = "Бэггинс"

# соединяем имена, разделенные пробелом
full_name = first_name + "" + last_name

print ("Привет," + полное_имя + ".")  

В нашем первом примере мы создали две строки, first_name и last_name, а затем соединили их с помощью оператора '+'. Для ясности мы добавили пробел между именами.

Запустив файл, мы видим следующий текст в командной строке:

  Привет, Бильбо Бэггинс.  

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

Рассмотрим другой пример. На этот раз мы воспользуемся циклом for для объединения наших строковых данных.

  # некоторые персонажи из "Властелина колец"
characters = ["Фродо", "Гэндальф", "Сэм", "Арагорн", "Эовин"]

сюжетная линия = ""

# прокручиваем каждого персонажа и добавляем его в сюжетную линию
для i в диапазоне (len (символы)):
    # включить "и" перед последним символом в списке
    если i == len (символы) -1:
        сюжетная линия + = "и" + персонажи [i]
    еще:
        сюжетная линия + = персонажи [i] + ","

сюжетная линия + = "направляются в Мордор, чтобы уничтожить кольцо."

печать (сюжетная линия)
  

Этот более сложный пример показывает, как можно использовать конкатенацию для создания удобочитаемого текста из списка Python. Используя цикл for, список персонажей (взятых из романов «Властелин колец») один за другим присоединяется к строке сюжета.

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

Вот окончательный результат:

  Фродо, Гэндальф, Сэм, Арагорн и Эовин направляются в Мордор, чтобы уничтожить кольцо.  

Этот метод НЕ будет работать, если оба объекта не являются жалами. Например, попытка соединить строку с числом приведет к ошибке.

  >>> строка = "один" + 2
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
TypeError: можно только объединить str (не "int") с str
  

Как видите, Python позволяет нам только объединять строку с другой строкой.Наша задача как программистов - понимать ограничения языков, с которыми мы работаем. В Python нам нужно убедиться, что мы объединяем объекты правильного типа, если мы хотим избежать ошибок.

Объединение списков с помощью оператора «+»

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

  hobbits = [«Фродо», «Сэм»]
эльфы = ["Леголас"]
люди = ["Арагорн"]

печать (хоббиты + эльфы + люди)
  

Как видите, оператор «+» имеет множество применений. С его помощью программисты Python могут легко комбинировать строковые данные и списки строк.

Соединение строк с помощью метода .join ()

Если вы имеете дело с итерируемым объектом в Python, скорее всего, вы захотите использовать метод .join () . Итерируемый объект , такой как строка или список, можно легко объединить с помощью .join () метод.

Любая итерация или последовательность Python может быть объединена с помощью метода .join () . Сюда входят списки и словари.

Метод .join () - это метод экземпляра строки. Синтаксис следующий:

имя_строки.join (итерация)

Вот пример использования метода .join () для объединения списка строк:

  числа = ["один", "два "," три "," четыре "," пять "]

Распечатать(','.присоединиться (числа))
  

Запустив программу в командной строке, мы увидим следующий результат:

  один, два, три, четыре, пять  

Метод .join () вернет новую строку, включающую все элементы в итерации, соединенные разделителем . В предыдущем примере разделителем была запятая, но для соединения данных можно использовать любую строку.

  числа = ["один", "два", "три", "четыре", "пять"]
print ('and' .join (numbers))  

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

  title = ['L', 'o', 'r', 'd', '', 'o', 'f', '', 't', 'h', 'e', ​​'' ' , 'R', 'i', 'n', 'g', 's']
печать («». присоединиться (заголовок))
  

Метод .join () также можно использовать для получения строки с содержимым словаря. При использовании .join () таким образом метод будет возвращать только ключи в словаре, а не их значения.

  number_dictionary = {"one": 1, "two": 2, "three": 3, "four": 4, "five": 5}
print (',' .join (словарь_числов))
  

При объединении последовательностей с помощью .join () , результатом будет строка с элементами из обеих последовательностей.

Копирование строк с помощью оператора «*»

Если вам нужно объединить две или более одинаковых строк, можно использовать оператор «*».

С помощью оператора «*» вы можете повторять строку любое количество раз.

  фрукт = «яблоко»
print (fruit * 2)  

Оператор «*» можно комбинировать с оператором «+» для объединения строк. Объединение этих методов позволяет нам воспользоваться преимуществами многих расширенных функций Python.

  fruit1 = "яблоко"
fruit2 = "апельсин"

fruit1 + = ""
fruit2 + = ""

печать (fruit1 * 2 + "" + fruit2 * 3)
  

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

Поскольку строки в Python неизменяемы, их довольно часто разделять и объединять.

. split () - еще один метод экземпляра строки. Это означает, что мы можем вызвать его в конце любого строкового объекта.

Как и метод .join () , метод .split () использует разделитель для анализа строковых данных.По умолчанию в этом методе в качестве разделителя используется пробел.

Давайте посмотрим на метод .split () в действии.

  names = "Фродо Сэм Гэндальф Арагорн"

печать (names.split ())
  

Этот код выводит список строк.

  ['Фродо', 'Сэм', 'Гэндальф', 'Арагорн']  

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

  story = "Фродо взял кольцо силы на гору гибели."
слова = story.split ()
печать (слова)
  

Использование. split () Метод возвращает новый итерируемый объект. Поскольку объект является итеративным, мы можем использовать метод .join () , о котором мы узнали ранее, чтобы «склеить» строки вместе.

  original = "Фродо взял кольцо силы на гору гибели."
слова = original.split ()

remake = '' .join (слова)
распечатать (переделать)
  

Используя строковые методы в Python, мы можем легко разделять и объединять строки.Эти методы имеют решающее значение для работы со строками и повторяемыми объектами.

Связывание свободных концов

К настоящему времени вы должны иметь более глубокие знания о строках и о том, как их использовать в Python 3. Работа с примерами, приведенными в этом руководстве, станет отличным началом вашего пути к освоению Python.

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

С помощью и терпением любой может изучить основы Python. Если работа по объединению строк в Python кажется сложной задачей, потратьте некоторое время на то, чтобы попрактиковаться в приведенных выше примерах. Ознакомившись со строковыми переменными и работая с методами, вы быстро откроете неограниченный потенциал языка программирования Python.

Рекомендуемый курс обучения Python

Курс: Python 3 для начинающих

Более 15 часов видеоконтента с пошаговыми инструкциями для начинающих.Узнайте, как создавать реальные приложения, и освоите основы.

Python 3 строки: определение строк, операторы и форматирование - Учебник Python3

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

Определить строку

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

  string_1 = "Пример строки №1"
string_2 = 'Пример строки # 2'  

Оба метода эквивалентны. Если строка разделена двойными кавычками, любые двойные кавычки внутри строки необходимо экранировать обратной косой чертой ( \ ):

  "Мой учитель сказал \" Не забывай домашнее задание \ ""  

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

  'Это сайт документации Linode.' 

Доступ к значениям в строках

Python не поддерживает символьный тип; они рассматриваются как строки длины один, поэтому также считаются подстрокой.

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

  #! / Usr / bin / python3

var1 = 'Привет, мир!'
var2 = "Программирование на Python"

print ("var1 [0]:", var1 [0])
print ("var2 [1: 5]:", var2 [1: 5])  

Когда приведенный выше код выполняется, он дает следующий результат:

  var1 [0]: H
var2 [1: 5]: ytho  

Строковые операторы

Операторы + и * переопределяются для строкового класса, что позволяет складывать и умножать строки.Строки в Python неизменяемы. После создания они не могут быть изменены.

Использование оператора add для объединения строк называется конкатенацией. Строки имени и фамилии остаются без изменений. Объединение двух строк возвращает новую строку.

Предположим, строковая переменная a содержит «Hello», а переменная b содержит «Python», затем

Формат

Оператор Описание Пример
+ Конкатенация - складывает значения по обе стороны от оператора a + b даст HelloPython
* Повторение - Создает новые строки, объединяя несколько копий одной и той же строки a * 2 даст HelloHello
[] Slice - дает символ из заданного индекса a [1] даст e
[:] Range Slice - дает символы из заданного диапазона a [1: 4] даст ell
дюйм Членство - Возвращает истину, если символ существует в данной строке H в а даст 1
нет в Членство - Возвращает истину, если символ не существует в данной строке M не в сдам 1
r / R Необработанная строка - подавляет фактическое значение escape-символов.Синтаксис необработанных строк точно такой же, как и для обычных строк, за исключением оператора необработанной строки, буквы «r», которая предшествует кавычкам. Буква «r» может быть в нижнем регистре (r) или в верхнем регистре (R) и должна быть помещена непосредственно перед первой кавычкой. print r '\ n' печатает \ n и печатает R '\ n'prints \ n
% - выполняет форматирование строки См. Следующий раздел

Оператор форматирования строк

До Python 3.6, у вас было два основных способа встраивания выражений Python в строковые литералы для форматирования:% -форматирование и str.format () . Вы скоро узнаете, как их использовать и каковы их ограничения.

Вариант № 1:% -форматирование

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

«Операции форматирования, описанные здесь, демонстрируют множество причуд, которые приводят к ряду распространенных ошибок (таких как неправильное отображение кортежей и словарей).

Использование новых форматированных строковых литералов или интерфейса str.format () помогает избежать этих ошибок. Эти альтернативы также предоставляют более мощные, гибкие и расширяемые подходы к форматированию текста ». (Источник)

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

  >>> name = "Эрик"
>>> "Привет,% s." % имя
«Привет, Эрик».  

Чтобы вставить более одной переменной, вы должны использовать кортеж этих переменных. Вот как это сделать:

  >>> name = "Эрик"
>>> возраст = 74
>>> "Привет,% s. Вы% s." % (Назовите возраст)
«Привет, Эрик. Вам 74 года.  

Вот полный набор символов, которые можно использовать вместе с %

Преобразование строки

Имя оператора Описание
% в символ
% s через str () до форматирования
% я целое десятичное число со знаком
% d целое десятичное число со знаком
% и целое десятичное без знака
% о целое восьмеричное
% x шестнадцатеричное целое число (строчные буквы)
% X шестнадцатеричное целое число (заглавные буквы)
% e экспоненциальная запись (со строчной буквой e)
% E экспоненциальная запись (с ЗАГЛАВНЫМ регистром 'E')
% f вещественное число с плавающей запятой
% г короче% f и% e
% G короче% f и% E

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

  >>> first_name = "Эрик"
>>> last_name = "Бездействие"
>>> возраст = 74
>>> профессия = "комик"
>>> affiliation = "Монти Пайтон"
>>> "Привет,% s% s. Вы% s. Вы% s. Вы были членом% s." % (имя, фамилия, возраст, профессия, принадлежность)
«Привет, Эрик Айдл.Вам 74 года. Вы комик. Вы были членом «Монти Пайтон».  

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

Вариант 2: str.format ()

Этот новый способ выполнения работы был представлен в Python 2.6. Вы можете проверить документацию Python для получения дополнительной информации.

str.format () - это улучшение% -форматирования.Он использует обычный синтаксис вызова функций и может быть расширен с помощью метода __format __ () для объекта, преобразуемого в строку.

При использовании str.format () заменяемые поля помечаются фигурными скобками:

  >>> "Здравствуйте, {}. Вы {}.". Формат (имя, возраст)
«Привет, Эрик. Вам 74 года.  

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

  >>> "Здравствуйте, {1}.Вы {0}. ". Format (возраст, имя)
«Привет, Эрик. Вам 74 года.  

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

  >>> person = {'name': 'Eric', 'age': 74}
>>> «Привет, {имя}. Тебе {возраст}.». Формат (имя = человек ['имя'], возраст = человек ['возраст'])
«Привет, Эрик. Вам 74 года.  

Вы также можете использовать ** , чтобы проделать этот изящный трюк со словарями:

  >>> person = {'name': 'Eric', 'age': 74}
>>> "Здравствуйте, {имя}.Вам {возраст}. ". Формат (** человек)
«Привет, Эрик. Вам 74 года.  

str.format () определенно является улучшением по сравнению с% -форматированием, но это еще не все розы и солнце.

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

  >>> first_name = "Эрик"
>>> last_name = "Бездействие"
>>> возраст = 74
>>> профессия = "комик"
>>> affiliation = "Монти Пайтон"
>>> print (("Здравствуйте, {first_name} {last_name}.Вам {возраст}. "+
>>> "Вы - {профессия}. Вы были членом {членской организации}.") \
>>> .format (first_name = first_name, last_name = last_name, age = age, \
>>> профессия = профессия, принадлежность = принадлежность))
«Привет, Эрик Айдл. Вам 74 года. Вы комик. Вы были членом «Монти Пайтон».  

Если у вас есть переменные, которые вы хотите передать в .format () в словаре, вы можете просто распаковать их с помощью .format (** some_dict) и ссылаться на значения по ключу в строке, но должен быть лучший способ сделать это.

Вариант № 3: f-струны

Python 3.6 представил более простой способ форматирования строк: форматированные строковые литералы, обычно называемые f-строками .

Синтаксис аналогичен синтаксису, который вы использовали с

str.format () , но менее подробен. Посмотрите, насколько легко это читать:

  >>> name = "Эрик"
>>> возраст = 74
>>> f "Здравствуйте, {name}.Вам {возраст}. "
«Привет, Эрик. Вам 74 года.  

Также можно использовать заглавную букву F ​​:

  >>> F "Здравствуйте, {имя}. Тебе {возраст}."
«Привет, Эрик. Вам 74 года.  

Любое выражение Python можно поместить в скобки в строке f, что придаст им еще большую гибкость:

  >>> orders = [14.99,19.99,10]
>>> f'У вас есть {len (orders)} товаров в корзине на общую сумму $ {sum (orders)}. 

У вас могут быть многострочные строки:

  >>> name = "Эрик"
>>> профессия = "комик"
>>> affiliation = "Монти Пайтон"
>>> message = (
... f "Привет, {имя}."
... f "Вы - {профессия}".
... f "Вы состояли в {affiliation}."
...)
>>> сообщение
«Привет, Эрик. Вы комик. Вы были в «Монти Пайтоне».  

Но помните, что вам нужно поместить f перед каждой строкой многострочной строки.

Побег персонажей

Следующая таблица представляет собой список управляющих или непечатаемых символов, которые могут быть представлены с помощью обратной косой черты.

Интерпретируется escape-символ; в строках как в одинарных, так и в двойных кавычках.

Обозначение обратной косой черты Шестнадцатеричный символ Описание
\ а 0x07 Звонок или тревога
\ б 0x08 Backspace
\ сх Control-x
\ C-x Control-x
\ e 0x1b Побег
\ f 0x0c Подача формы
\ M- \ C-x Meta-Control-x
\ п 0x0a Новая строка
\ nnn Восьмеричное представление, где n находится в диапазоне 0.7
\ r 0x0d Возврат каретки
\ с 0x20 Космос
\ т 0x09 Вкладка
\ v 0x0b Вертикальный выступ
\ х символов x
\ xnn Шестнадцатеричное представление, где n находится в диапазоне 0.9, a.f, или A.F

Справочник по манипулированию строками в Python

Манипуляции со строками - одно из тех действий в программировании, которым мы, программисты, занимаемся постоянно.

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

В Python, с другой стороны, у вас есть несколько встроенных функций в стандартной библиотеке, которые помогут вам управлять строками разными способами.

В этой статье я покажу вам, как конкретно работать со строками, а также некоторые интересные приемы.

Краткая информация: здесь вы можете скачать PDF-версию этого Руководства по манипулированию строками Python.

Готовы погрузиться?

Содержание

  1. Основы работы со строками Python
  2. Как разбить строку в Python
  3. Как удалить все пробелы в строке в Python
  4. Как обрабатывать многострочные строки в Python
  5. lstrip (): как удалить пробелы и символы в начале строки в Python
  6. rstrip (): как удалить пробелы и символы в конце строки в Python
  7. strip (): как удалить пробелы и символы в начале и конце строки в Python
  8. Как сделать целую строку строчными буквами в Python
  9. Как сделать целую строку в верхнем регистре в Python
  10. Как использовать регистр заголовка в Python
  11. Как использовать регистр подкачки в Python
  12. Как проверить, пуста ли строка в Python
  13. rjust (): как выровнять строку по правому краю в Python
  14. ljust (): как выровнять строку по левому краю в Python
  15. isalnum (): как проверить наличие буквенно-цифровых символов только в строке в Python
  16. isprintable (): как проверить печатаемые символы в строке в Python
  17. isspace (): как проверить наличие пробелов только в строке в Python
  18. playswith (): как проверить, начинается ли строка с определенного значения в Python
  19. capitalize (): как установить только верхний регистр для первого символа в строке в Python
  20. isupper (): как проверить только верхний регистр в строке в Python
  21. join (): как объединить элементы итерации в одну строку в Python
  22. splitlines (): как разделить строку по разрывам строки в Python
  23. islower (): как проверить только нижний регистр в строке в Python
  24. isnumeric (): как проверить числовые значения только в строке в Python
  25. isdigit (): как проверить только цифры в строке в Python
  26. isdecimal (): как проверить наличие десятичных знаков только в строке в Python
  27. isalpha (): как проверить наличие букв только в строке в Python
  28. istitle (): как проверить, начинается ли каждое слово с символа верхнего регистра в строке в Python
  29. expandtabs (): Как установить количество пробелов для табуляции в строке в Python
  30. center (): как центрировать строку в Python
  31. zfill (): как добавить нули в строку в Python
  32. find (): как проверить, имеет ли строка определенную подстроку в Python
  33. Как удалить префикс или суффикс в строке в Python
  34. lstrip () против removeprefix () и rstrip () против removesuffix ()
  35. Как работает нарезка в Python
  36. Как перевернуть строку в Python
  37. Заключение

Основы работы со строками Python

Текст Тип является одним из наиболее распространенных типов и часто называется строкой или, в Python, просто str .

  my_city = "Нью-Йорк"
print (введите (my_city))

# Одиночные цитаты содержат ровно
# то же самое, что и двойные кавычки
my_city = 'Нью-Йорк'
print (введите (my_city))

# Явная установка типа переменной
my_city = str ("Нью-Йорк")
print (введите (my_city))
  
  <класс 'str'>
<класс 'str'>
<класс 'str'>
  

Как объединить строки

Для объединения строк можно использовать оператор + .

Конкатенация - это когда у вас есть две или более строк, и вы хотите объединить их в одну.

  word1 = «Новый»
word2 = 'Йорк'

печать (слово1 + слово2)
  
  Нью-Йорк
  

Как выбрать символ

Чтобы выбрать символ, используйте [] и укажите положение символа.

Позиция 0 относится к первой позиции.

  >>> word = "Рио-де-Жанейро"
>>> char = word [0]
>>> печать (символ)
р
  

Как получить размер строки

Функция len () возвращает длину строки.

  >>> len ('Рио')
3
>>> len ('Рио-де-Жанейро')
14
  

Как заменить часть строки

Метод replace () заменяет часть строки другой. В качестве примера заменим «Рио» на «Мар».

  >>> 'Рио-де-Жанейро'. Заменить ('Рио', 'мар')
'Мар де Жанейро'
  

Рио означает «река» на португальском языке, а «мар» означает «море» - просто чтобы вы знали, я выбрал эту замену не так случайно.

Как считать

Укажите, что считать аргументом.

В данном случае мы подсчитываем, сколько мест существует в «Рио-де-Жанейро», а это 2.

  >>> word = "Рио-де-Жанейро"
>>> print (word.count (''))
2
  

Как повторить строку

Для повторения строки можно использовать символ * .

Здесь мы умножаем слово «Токио» на 3.

  >>> words = "Токио" * 3
>>> печать (слова)
ТокиоТокиоТокио
  

Как разбить строку в Python

Разделение строки на более мелкие части - очень распространенная задача.Для этого мы используем метод split () в Python.

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

Пример 1: использовать пробелы в качестве разделителей

В этом примере мы разбиваем фразу на пробелы, создавая список с именем my_words с пятью элементами, соответствующими каждому слову во фразе.

  my_phrase = "пойдем на пляж"
my_words = my_phrase.split ("")

слово в my_words:
    печать (слово)
#выход:
#Давайте
#идти
#к
# the
#пляж

печать (мои_слова)
#выход:
# [«давай», «иди», «в», «в», «пляж»]
  

Обратите внимание, что по умолчанию метод split () использует любое последовательное количество пробелов в качестве разделителей.Мы можем изменить приведенный выше код на:

  my_phrase = "пойдем на пляж"
my_words = my_phrase.split ()

слово в my_words:
    печать (слово)

#выход:
#Давайте
#идти
#к
# the
#пляж
  

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

Пример 2: передача разных аргументов в качестве разделителей

При работе с данными очень часто читают некоторые файлы CSV, чтобы извлечь из них информацию.

Таким образом, вам может потребоваться сохранить некоторые конкретные данные из определенного столбца.

CSV-файлы обычно имеют поля, разделенные точкой с запятой ";" или запятую ",".

В этом примере мы собираемся использовать метод split () , передающий в качестве аргумента определенный разделитель «;» в этом случае.

  my_csv = "Мэри; 32; Австралия; [email protected]"
my_data = my_csv.split (";")

для данных в my_data:
    печать (данные)

#выход:
#Мэри
# 32
#Австралия
#[email protected]

печать (my_data [3])
#выход:
# [email protected]
  

Как удалить все пробелы в строке в Python

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

Вам необходимо импортировать модуль re , который предоставляет операции с регулярными выражениями.

Обратите внимание, что \ s представляет не только пространство '' , но также подачу формы \ f , перевод строки \ n , возврат каретки \ r , табуляцию \ t и вертикальную табуляцию \ v .

Таким образом, \ s = [\ f \ n \ r \ t \ v] .

Символ + называется квантификатором и читается как «один или несколько».Это означает, что в этом случае он будет учитывать одно или несколько пробелов, поскольку он расположен сразу после \ s .

  импорт ре

фраза = 'Делай или не делай, попытки не предпринимаются'

фраза_no_space = re.sub (r '\ s +', '', фраза)

печать (фраза)
# Делай или не делай, нет попытки

печать (фраза_но_пространство)
#Doordonotthereisnotry
  

Исходная переменная , фраза остается прежней. Вы должны назначить новую очищенную строку новой переменной, в данном случае фраза_но_пространство .

Как обрабатывать многострочные строки в Python

Тройные цитаты

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

В этом первом примере используются двойные кавычки.

  long_text = "" "Это многострочный,

длинная строка с большим количеством текста,

Я заключил его в тройные кавычки, чтобы он работал. "" "

печать (длинный_текст)
#выход:
# Это многострочный,
#
# длинная строка с большим количеством текста,
#
# Я заключил его в тройные кавычки, чтобы он работал. 

Теперь то же, что и раньше, но с одинарными кавычками:

  long_text = '' 'Это многострочный,

длинная строка с большим количеством текста,

Я заключил его в тройные кавычки, чтобы он работал ''.

печать (длинный_текст)
#выход:
# Это многострочный,
#
# длинная строка с большим количеством текста,
#
# Я заключил его в тройные кавычки, чтобы он работал.
  

Обратите внимание, что оба выхода одинаковы.

Круглые скобки

Давайте посмотрим на пример со скобками.

  long_text = ("Это многострочный,"
"длинная строка с большим количеством текста"
"Я заключаю его в скобки, чтобы он работал.")
печать (длинный_текст)
# Это многострочная длинная строка с большим количеством текста. Я заключил ее в тройные кавычки, чтобы она работала.
  

Как видите, результат не тот. Чтобы получить новые строки, мне нужно добавить \ n , например:

  long_text = ("Это многострочный, \ n \ n"
"длинная строка с большим количеством текста \ n \ n"
«Я заключаю его в скобки, чтобы оно работало»).
печать (длинный_текст)
# Это многострочный,
#
# длинная строка с большим количеством текста
#
# Я заключил его в тройные кавычки, чтобы он работал. 

обратная косая черта

Наконец, возможны также обратные косые черты.

Обратите внимание, что после символа \ нет пробела, так как это вызовет ошибку.

  long_text = "Это многострочный, \ n \ n" \
"длинная строка с большим количеством текста \ n \ n" \
«Я использую люфт, чтобы это работало».
печать (длинный_текст)
# Это многострочный,
#
# длинная строка с большим количеством текста
#
# Я заключил его в тройные кавычки, чтобы он работал.
  

lstrip (): как удалить пробелы и символы в начале строки в Python

Используйте метод lstrip () для удаления пробелов в начале строки.

  regular_text = "Это обычный текст."

no_space_begin_text = обычный_текст.lstrip ()

печать (обычный_текст)
# 'Это обычный текст.'

печать (no_space_begin_text)
# 'Это обычный текст.'
  

Обратите внимание, что исходная переменная regular_text остается неизменной, поэтому вам необходимо назначить возврат метода новой переменной, в данном случае no_space_begin_text .

Как удалить символы

Метод lstrip () также принимает определенные символы для удаления в качестве параметров.

  regular_text = "$ @ G # Это обычный текст."

clean_begin_text = regular_text.lstrip ("# $ @ G")

печать (обычный_текст)
# $ @ G # Это обычный текст.

печать (чистый_начальный_текст)
# Это обычный текст.
  

rstrip (): как удалить пробелы и символы в конце строки в Python

Используйте метод rstrip () для удаления пробелов в конце строки.

  regular_text = "Это обычный текст."

no_space_end_text = обычный_текст.rstrip ()

печать (обычный_текст)
# 'Это обычный текст. '

печать (no_space_end_text)
# 'Это обычный текст.'
  

Обратите внимание, что исходная переменная regular_text остается неизменной, поэтому вам необходимо назначить возврат метода новой переменной, в данном случае no_space_end_text .

Метод rstrip () также принимает определенные символы для удаления в качестве параметров.

  regular_text = "Это обычный текст[email protected]#"

clean_end_text = обычный_текст.rstrip ("# $ @ G")

печать (обычный_текст)
# Это обычный текст. [email protected]#

печать (clean_end_text)
# Это обычный текст.
  

strip (): как удалить пробелы и символы в начале и конце строки в Python

Используйте метод strip () для удаления пробелов в начале и в конце строки.

  regular_text = "Это обычный текст."

no_space_text = обычный_текст.strip ()

печать (обычный_текст)
# 'Это обычный текст. '

печать (no_space_text)
# 'Это обычный текст.'
  

Обратите внимание, что исходная переменная regular_text остается неизменной, поэтому вам необходимо назначить возврат метода новой переменной, в данном случае no_space_text .

Метод strip () также принимает определенные символы для удаления в качестве параметров.

  regular_text = "AbC # Это обычный текст. [email protected]#"

clean_text = regular_text.strip ("AbC # $ @ G")

печать (обычный_текст)
# AbC # Это обычный текст. [email protected]#

печать (чистый_текст)
# Это обычный текст. 

Как сделать целую строку строчными буквами в Python

Используйте метод lower () для преобразования всей строки в нижний регистр.

  regular_text = "Это обычный ТЕКСТ."

lower_case_text = обычный_текст.lower ()

печать (обычный_текст)
# Это обычный ТЕКСТ.

печать (нижний_текст)
# это обычный текст.
  

Обратите внимание, что исходная переменная regular_text остается неизменной, поэтому вам необходимо назначить возврат метода новой переменной, в данном случае lower_case_text .

Как сделать целую строку в верхнем регистре в Python

Используйте метод upper () для преобразования всей строки в верхний регистр.

  regular_text = "Это обычный текст."

upper_case_text = обычный_текст.upper ()

печать (обычный_текст)
# Это обычный текст.

печать (upper_case_text)
# ЭТО ОБЫЧНЫЙ ТЕКСТ.
  

Обратите внимание, что исходная переменная regular_text остается неизменной, поэтому вам необходимо назначить возврат метода новой переменной, в данном случае upper_case_text .

Как использовать регистр заголовка в Python

Используйте метод title () , чтобы преобразовать первую букву каждого слова в верхний регистр, а остальные символы - в нижний регистр.

  regular_text = "Это обычный текст."

title_case_text = regular_text.title ()

печать (обычный_текст)
# Это обычный текст.

печать (title_case_text)
# Это обычный текст.
  

Обратите внимание, что исходная переменная regular_text остается неизменной, поэтому вам нужно назначить возврат метода новой переменной, в данном случае title_case_text .

Как использовать случай подкачки в Python

Используйте метод swapcase () для преобразования символов верхнего регистра в нижний регистр и наоборот.

  regular_text = "Это обычный текст."

swapped_case_text = обычный_текст.swapcase ()

печать (обычный_текст)
# Это обычный текст.

печать (swapped_case_text)
# ЭТО ОБЫЧНЫЙ ТЕКСТ.
  

Обратите внимание, что исходная переменная regular_text остается неизменной, поэтому вам нужно назначить возврат метода новой переменной, в данном случае swapped_case_text .

Как проверить, пуста ли строка в Python

Питонический способ проверить, пуста ли строка , использует оператор , а не .

  my_string = ''
если не my_string:
  print ("Моя строка пуста !!!")
  

Чтобы проверить обратное и увидеть, является ли строка не пустой , сделайте следующее:

  my_string = 'Амазонка, Майкрософт'
если my_string:
  print ("Моя строка НЕ ​​пуста !!!")
  

rjust (): как выровнять строку по правому краю в Python

Используйте rjust () для выравнивания строки по правому краю.

  word = 'пляж'
number_spaces = 32

word_justified = word.rjust (число_пространств)

печать (слово)
#'пляж'

печать (word_justified)
#'                           пляж'
  

Обратите внимание на пробелы во второй строке. Слово «пляж» состоит из 5 символов, что дает нам 27 пробелов, которые нужно заполнить пустым пространством.

Исходная переменная word, остается неизменной, поэтому нам нужно присвоить возврат метода новой переменной, в данном случае word_justified .

rjust () также принимает определенный символ в качестве параметра для заполнения оставшегося места.

  word = 'пляж'
number_chars = 32
char = '$'

word_justified = word.rjust (число_символов, символ)

печать (слово)
#пляж

печать (word_justified)
# $$$$$$$$$$$$$$$$$$$$$$$$$$$ пляж
  

Как и в первой ситуации, у меня есть 27 знаков $ , чтобы получилось 32, когда я считаю 5 символов, содержащихся в слове «пляж».

ljust (): как выровнять строку по левому краю в Python

Используйте ljust () для выравнивания строки по левому краю.

  word = 'пляж'
number_spaces = 32

word_justified = word.ljust (число_пространств)

печать (слово)
#'пляж'

печать (word_justified)
#'пляж                           '
  

Обратите внимание на пробелы во второй строке. Слово «пляж» состоит из 5 символов, что дает нам 27 пробелов, которые нужно заполнить пустым пространством.

Исходная переменная word, остается неизменной, поэтому нам нужно присвоить возврат метода новой переменной, в данном случае word_justified .

ljust () также принимает определенный символ в качестве параметра для заполнения оставшегося места.

  word = 'пляж'
number_chars = 32
char = '$'

word_justified = word.ljust (число_символов, символ)

печать (слово)
#пляж

печать (word_justified)
# пляж $$$$$$$$$$$$$$$$$$$$$$$$$$
  

Как и в первой ситуации, у меня есть 27 знаков $ , чтобы получилось 32, когда я считаю 5 символов, содержащихся в слове «пляж».

isalnum (): как проверить буквенно-цифровые символы только в строке в Python

Используйте метод isalnum () , чтобы проверить, содержит ли строка только буквенно-цифровые символы.

  word = 'пляж'
печать (word.isalnum ())
#output: True

слово = '32'
печать (word.isalnum ())
#output: True

word = 'number32' # обратите внимание, что нет пробела
печать (word.isalnum ())
#output: True

word = 'Любимое число 32' # обратите внимание на пробел между словами
печать (word.isalnum ())
#output: False

word = '@ number32 $' # обратите внимание на специальные символы '@' и '$'
печать (word.isalnum ())
#output: False
  

isprintable (): как проверить печатаемые символы в строке в Python

Используйте метод isprintable () , чтобы проверить, можно ли распечатать символы в строке.

  text = '' # обратите внимание, что это пустая строка, здесь нет пробелов
печать (text.isprintable ())
#output: True

text = 'Это обычный текст'
печать (text.isprintable ())
#output: True

text = '' # один пробел
печать (text.isprintable ())
#output: True

text = '' # много пробелов
печать (text.isprintable ())
#output: True

текст = '\ f \ n \ r \ t \ v'
печать (text.isprintable ())
#output: False
  

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

Последний пример возвращает False , показывая 5 видов непечатаемых символов: подача формы \ f , подача строки \ n , возврат каретки \ r , табуляция \ t и вертикальная табуляция. \ в .

Некоторые из этих «невидимых» символов могут испортить вашу печать, давая вам неожиданный результат, даже если все «выглядит» нормально.

isspace (): как проверить наличие пробелов только в строке в Python

Используйте метод isspace () , чтобы проверить, все ли символы в строке являются пробелами.

  текст = ''
печать (text.isspace ())
#output: True

текст = '\ f \ n \ r \ t \ v'
печать (text.isspace ())
#output: True

текст = ''
печать (text.isspace ())
#output: True

text = '' # обратите внимание, что это пустая строка, здесь нет пробелов
печать (text.isspace ())
#output: False

text = 'Это обычный текст'
печать (text.isspace ())
#output: False
  

Обратите внимание, что во втором примере пробел - это не только '' , но также подача формы \ f , подача строки \ n , возврат каретки \ r , табуляция \ t и вертикальная табуляция \ v .

playswith (): как проверить, начинается ли строка с определенного значения в Python

Используйте метод startwith () , чтобы проверить, начинается ли строка с определенного значения.

  фраза = "Это обычный текст"

print (фраза.startswith ('Это'))
#output: True

печать (фраза.startswith ('текст'))
#output: False
  

Вы также можете указать, хотите ли вы начинать сопоставление в определенной позиции и заканчивать его в другой определенной позиции строки.

  фраза = "Это обычный текст"

печать (фраза.startwith ('regular', 10)) # слово regular начинается с 10 позиции фразы
#output: True

print (фраза.startswith ('normal', 10, 22)) # искать в 'обычном тексте'
#output: True

print (фраза.startswith ('regular', 10, 15)) ## ищите в 'Regular'
#output: False
  

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

  фраза = "Это обычный текст"

печать (фраза.начинается с (('обычный', 'это')))
#output: True

print (фраза.startswith (('обычный', 'текст')))
#output: False

print (фраза.startswith (('обычный', 'текст'), 10, 22)) # искать в 'обычном тексте'
#output: True
  

capitalize (): как установить только верхний регистр для первого символа в строке в Python

Используйте метод capitalize () для преобразования в верхний регистр только первого символа в строке.

Остальная часть строки преобразуется в нижний регистр.

  text = 'это обычный текст'
печать (текст.капитализировать ())
# Это обычный текст

text = 'ЭТО ОБЫЧНЫЙ ТЕКСТ'
печать (text.capitalize ())
# Это обычный текст

text = 'ЭТО $ 1S @ ЧИСТЫЙ ТЕКСТ!'
печать (text.capitalize ())
# Это $ 1s @ обычный текст!

text = '3ЭТО $ 1S @ ПРАВИЛЬНЫЙ ТЕКСТ!'
печать (text.capitalize ())
# 3это $ 1s @ обычный текст!
  

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

isupper (): как проверить только верхний регистр в строке в Python

Используйте метод isupper () , чтобы проверить, все ли символы в строке написаны в верхнем регистре.

  text = 'Это обычный текст'
печать (text.isupper ())
#output: False

text = 'ЭТО ОБЫЧНЫЙ ТЕКСТ'
печать (text.isupper ())
#output: True

text = 'ЭТО $ 1S @ ЧИСТЫЙ ТЕКСТ!'
печать (text.isupper ())
#output: True
  

Если вы обратили внимание на последний пример, числа и специальные символы, такие как @ и $ в строке, не имеют значения, а isupper () по-прежнему возвращает True , потому что метод проверяет только алфавитные символы.

join (): как объединить элементы итерации в одну строку в Python

Используйте метод join () для объединения всех элементов, если они итерируемы в строку.

Базовый синтаксис: string.join (итерация)

Согласно синтаксису выше, в качестве разделителя требуется строка.

Метод возвращает новую строку, что означает, что исходный итератор остается неизменным.

Поскольку метод join () принимает только строки, если какой-либо элемент в итерации имеет другой тип, будет выдана ошибка.

Давайте посмотрим на несколько примеров: строка, список, кортеж, набор и словарь

join (): Строки

Метод join () помещает знак $ в качестве разделителя для каждого символа в строке.

  my_string = 'пляж'

печать ('$'. присоединиться (моя_строка))
#output: b $ e $ a $ c $ h
  

join (): Списки

У меня есть простой список из трех пунктов, представляющих марки автомобилей.

Метод join () будет использовать знак $ в качестве разделителя.

Он объединяет все элементы в списке и помещает между ними знак $ .

  my_list = ['bmw', 'ferrari', 'mclaren']

print ('$'. присоединиться (my_list))
# выход: bmw $ ferrari $ mclaren
  

Этот пример напоминает вам, что join () не работает с нестроковыми элементами.

При попытке объединить элементы int возникает ошибка.

  my_list = [1, 2, 3]

print ('$'. присоединиться (my_list))
#выход:
#Traceback (последний вызов последний):
# Файл "", строка 1, в 
#TypeError: элемент последовательности 0: ожидаемый экземпляр str, найдено int
  

join (): кортежи

Кортеж следует той же логике, что и пример со списком, описанный ранее.

Опять же, я использую знак $ в качестве разделителя.

  my_tuple = ('bmw', 'феррари', 'макларен')

print ('$'. присоединиться (my_tuple))
# выход: bmw $ ferrari $ mclaren
  

join (): устанавливает

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

  my_set = {'bmw', 'ferrari', 'mclaren'}
печать ('|' .join (my_set))
# выход: ferrari | bmw | mclaren
  

join (): словари

У словаря есть ловушка, когда вы используете метод join () : он объединяет ключи, а не значения.

В этом примере показано объединение ключей.

  my_dict = {'bmw': 'BMW I8', 'ferrari': 'Ferrari F8', 'mclaren': 'McLaren 720S'}

print (','. join (my_dict))
# выход: bmw, ferrari, mclaren
  

splitlines (): как разбить строку по разрывам строки в Python

Используйте метод splitlines () для разделения строки по разрывам строки.

Возвращаемый метод - список строк.

  my_string = 'чемпионат мира \ n'

печать (my_string.splitlines ())
#output: ['мир', 'чашка']
  

Если вы хотите сохранить разрыв строки, splitlines () принимает параметр, который может быть установлен на True , по умолчанию False .

  my_string = 'чемпионат мира \ n'

печать (my_string.splitlines (Истина))
#output: ['мир \ n', 'чашка']
  

islower (): как проверить только строчные буквы в строке в Python

Используйте метод islower () , чтобы проверить, все ли символы в строке в нижнем регистре.

  text = 'Это обычный текст'
печать (text.islower ())
#output: False

text = 'это обычный текст'
печать (text.islower ())
#output: True

text = 'этот $ 1s @ обычный текст!'
печать (text.islower ())
#output: True
  

Если вы заметили в последнем примере, числа и специальные символы, такие как @ и $ в строке, не имеют значения, а islower () по-прежнему возвращает True , потому что метод проверяет только алфавитные символы.

isnumeric (): как проверить только числа в строке в Python

Используйте метод isnumeric () , чтобы проверить, содержит ли строка только числовые символы.

Числа включают числа от 0 до 9 и их комбинации, римские цифры, верхние индексы, нижние индексы, дроби и другие варианты.

  слово = '32'
печать (word.isnumeric ())
#output: True

print ("\ u2083" .isnumeric ()) #unicode для нижнего индекса 3
#output: True

print ("\ u2169" .isnumeric ()) #unicode для римской цифры X
#output: True

слово = 'пляж'
печать (слово.isnumeric ())
#output: False

слово = 'число32'
печать (word.isnumeric ())
#output: False

word = '1 2 3' # обратите внимание на пробел между символами
печать (word.isnumeric ())
#output: False

word = '@ 32 $' # обратите внимание на специальные символы '@' и '$'
печать (word.isnumeric ())
#output: False
  

isdecimal () строже, чем isdigit () , что, в свою очередь, строже, чем isnumeric () .

isdigit (): как проверить только цифры в строке в Python

Используйте метод isdigit () , чтобы проверить, содержит ли строка только цифры.

Цифры включают числа от 0 до 9, а также надстрочные и подстрочные индексы.

  слово = '32'
печать (word.isdigit ())
#output: True

print ("\ u2083" .isdigit ()) #unicode для нижнего индекса 3
#output: True

слово = 'пляж'
печать (word.isdigit ())
#output: False

слово = 'число32'
печать (word.isdigit ())
#output: False

word = '1 2 3' # обратите внимание на пробел между символами
печать (word.isdigit ())
#output: False

word = '@ 32 $' # обратите внимание на специальные символы '@' и '$'
печать (word.isdigit ())
#output: False
  

isdecimal () строже, чем isdigit () , что, в свою очередь, строже, чем isnumeric () .

isdecimal (): как проверить наличие десятичных знаков только в строке в Python

Используйте метод isdecimal () , чтобы проверить, содержит ли строка только десятичные числа, то есть только числа от 0 до 9 и комбинации этих чисел.

Подстрочные и надстрочные индексы, римские цифры и другие варианты будут возвращены как False .

  слово = '32'
печать (word.isdecimal ())
#output: True

слово = '954'
печать (word.isdecimal ())
#output: True

print ("\ u2083".isdecimal ()) #unicode для нижнего индекса 3
#output: False

слово = 'пляж'
печать (word.isdecimal ())
#output: False

слово = 'число32'
печать (word.isdecimal ())
#output: False

word = '1 2 3' # обратите внимание на пробел между символами
печать (word.isdecimal ())
#output: False

word = '@ 32 $' # обратите внимание на специальные символы '@' и '$'
печать (word.isdecimal ())
#output: False
  

isdecimal () более строгий, чем isdigit () , который, в свою очередь, более строг, чем isnumeric () .

isalpha (): как использовать Chedck для букв только в строке в Python

Используйте метод isalpha () , чтобы проверить, содержит ли строка только буквы.

  word = 'пляж'
печать (word.isalpha ())
#output: True

слово = '32'
печать (word.isalpha ())
#output: False

слово = 'число32'
печать (word.isalpha ())
#output: False

word = 'Любимый номер синий' # обратите внимание на пробел между словами
печать (word.isalpha ())
#output: False

word = '@ beach $' # обратите внимание на специальные символы '@' и '$'
печать (слово.isalpha ())
#output: False
  

istitle (): Как проверить, начинается ли каждое слово с символа верхнего регистра в строке в Python

Используйте метод istitle () , чтобы проверить, является ли первый символ каждого слова в строке прописным, а остальные символы - строчными.

  text = 'Это обычный текст'
печать (text.istitle ())
#output: False

text = 'Это обычный текст'
печать (text.istitle ())
#output: True

text = 'Это $ Is @ Обычный 3 текста!'
печать (текст.istitle ())
#output: True
  

Если вы заметили в последнем примере, числа и специальные символы, такие как @ и $ в строке, не имеют значения, а istitle () по-прежнему возвращает True , потому что метод проверяет только алфавитные символы.

expandtabs (): Как установить количество пробелов для табуляции в строке в Python

Используйте метод expandtabs () , чтобы задать количество пробелов для табуляции.

Вы можете установить любое количество пробелов, но если аргумент не указан, по умолчанию используется 8.

Обычное использование

  my_string = 'B \ tR'

печать (my_string.expandtabs ())
#output: B R
  

Обратите внимание на 7 пробелов между буквами B и R.

\ t находится на второй позиции после одного символа, поэтому он будет заменен 7 пробелами.

Рассмотрим другой пример.

  my_string = 'МИР \ tD'

печать (my_string.expandtabs ())
#output: WORL D
  

Так как WORL состоит из четырех символов, \ t заменяется 4 пробелами, чтобы их всего было 8, размер табуляции по умолчанию.

Приведенный ниже код дает нам 4 пробелов для первой табуляции после четырех символов «МИР» и 7 пробелов для второй табуляции после одного символа «D».

  my_string = 'МИР \ tD \ tCUP'

печать (my_string.expandtabs ())
#output: КУБОК МИРА D
  

Пользовательский размер табуляции

Можно установить размер табуляции по мере необходимости.

В этом примере размер табуляции 4 , что дает нам 3 пробела после символа 'B'.

  my_string = 'B \ tR'

печать (my_string.expandtabs (4))
#output: B R
  

В этом коде размер табуляции установлен на 6 , что дает нам 5 пробелов после символа 'B'.

  my_string = 'B \ tR'

печать (my_string.expandtabs (6))
#output: B R
  

center (): как центрировать строку в Python

Используйте метод center () для центрирования строки.

  word = 'пляж'
number_spaces = 32

word_centered = word.center (число_пространств)

печать (слово)
#'пляж'

печать (word_centered)
## output: 'beach'
  

Обратите внимание на пробелы во второй строке.Слово «пляж» состоит из 5 символов, что дает нам 28 пробелов, которые нужно заполнить пустым пространством, 14 пробелов до и 14 после центрирования слова.

Исходная переменная word, остается неизменной, поэтому нам нужно присвоить возврат метода новой переменной, в данном случае word_centered .

center () также принимает определенный символ в качестве параметра для заполнения оставшегося места.

  word = 'пляж'
number_chars = 33
char = '$'

word_centered = слово.центр (number_chars, char)

печать (слово)
#пляж

печать (word_centered)
# выход: $$$$$$$$$$$$$$ пляжная $$$$$$$$$$$$$$
  

Как и в первой ситуации, у меня есть 14 $ на каждой стороне, чтобы получилось 33, когда я считаю 5 символов, содержащихся в слове «пляж».

zfill (): как добавить нули в строку в Python

Используйте zfill () , чтобы вставить нули 0 в начало строки.

Количество нулей определяется числом, переданным в качестве аргумента, за вычетом количества символов в строке.

Слово «пляж» состоит из 5 символов, что дает нам 27 пробелов, которые нужно заполнить нулями, чтобы получилось 32, как указано в переменной size_string

  word = 'пляж'
size_string = 32

word_zeros = word.zfill (size_string)

печать (слово)
#пляж

печать (word_zeros)
# 000000000000000000000000000пляж
  

Исходная переменная word, остается неизменной, поэтому нам нужно присвоить возврат метода новой переменной, в данном случае word_zeros .

Также обратите внимание, что если аргумент меньше количества символов в строке, ничего не меняется.

В приведенном ниже примере «пляж» имеет 5 символов, и мы хотим добавлять нули, пока не достигнем size_string из 4, что означает, что ничего не поделаешь.

  word = 'пляж'
size_string = 4

word_zeros = word.zfill (size_string)

печать (слово)
#пляж

печать (word_zeros)
#'пляж'
  

find (): как проверить, имеет ли строка определенную подстроку в Python

Используйте метод find () , чтобы проверить, есть ли в строке определенная подстрока.

Метод возвращает индекс первого появления заданного значения.

Помните, что счет индекса начинается с 0.

  фраза = "Это обычный текст"

print (фраза.find ('Это'))

печать (фраза.find ('обычный'))

печать (фраза.find ('текст'))
  
  0
10
18
  

Если значение не найдено, возвращается -1 .

  фраза = "Это обычный текст"

печать (фраза.find ('поезд'))
  
  -1
  

Вы также можете начать поиск в определенной позиции и закончить его в другой определенной позиции строки.

  фраза = "Это обычный текст"

# ищите в "This is", остальная часть фразы не включается
print (фраза.find ('Это', 0, 7))

# ищите в "Это обычный"
print (фраза.find ('обычный', 0, 17))

# ищите в "Это правило"
print (фраза.find ('a', 0, 15))
  
  0
10
8
  

Как удалить префикс или суффикс в строке в Python

Начиная с Python 3.9, тип String будет иметь два новых метода.

Вы можете специально удалить префикс из строки с помощью метода removeprefix () :

  >>> 'Рио-де-Жанейро'.removeprefix ("Рио")
'де Жанейро'
  

Или удалите суффикс с помощью метода removeuffix () :

  >>> 'Рио-де-Жанейро'.removesuffix ("eiro")
"Рио-де-Жан"
  

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

Я рекомендую прочитать PEP 616 в официальной документации, если вам интересно, как эти функции добавлены в язык.

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

lstrip () против removeprefix () и rstrip () против removesuffix ()

Это вызывает у многих недоумение.

Легко взглянуть на lstrip () и removeprefix () и задаться вопросом, в чем реальная разница между ними.

При использовании lstrip () аргумент представляет собой набор начальных символов, которые будут удаляться столько раз, сколько они встречаются:

  >>> word = 'hubbubbubboo'
>>> слово.lstrip ('концентратор')
'оо'
  

В то время как removeprefix () удалит только точное совпадение:

  >>> word = 'hubbubbubboo'
>>> word.removeprefix ('концентратор')
'bubbubboo'
  

Вы можете использовать одно и то же объяснение, чтобы различать rstrip () и removesuffix () .

  >>> word = 'peekeeneee'
>>> word.rstrip ('урожденная')
'заглянуть'
  
  >>> word = 'peekeeneee'
>>> слово.[ami] * (. *?) [ami] * $ ', word) .group (1)
"зона"
  

Как работает нарезка в Python

Нарезка - один из самых полезных инструментов языка Python.

Таким образом, важно хорошо понимать, как это работает.

Базовая нотация нарезки

Допустим, у нас есть массив под названием «список».

  список [начало: остановка: шаг]
  
  • начало: где вы хотите начать нарезку
  • стоп: до тех пор, пока вы не хотите, чтобы нарезка продолжалась, но помните, что значение стоп не включено
  • Шаг

  • : если вы хотите пропустить элемент, по умолчанию 1, поэтому вы просматриваете все элементы в массиве

Индексы

При нарезке индексы - это точки в между символами, а не на символах.

Для слова «фильм»:

  + --- + --- + --- + --- + --- +
 | м | о | v | я | е |
 + --- + --- + --- + --- + --- +
 0 1 2 3 4 5
-5-4-3-2 -1
  

Если я разрежу от 0 до 2, я получу «mo» в приведенном выше примере, а , а не «mov».

Поскольку строка - это просто список символов, то же самое относится и к списку:

  my_list = [1, 2, 3, 4, 5]
  

Стало:

  + --- + --- + --- + --- + --- +
 | 1 | 2 | 3 | 4 | 5 |
 + --- + --- + --- + --- + --- +
 0 1 2 3 4 5
-5-4-3-2 -1
  

Примеры нарезки в Python

У нас есть переменная, содержащая строку «фильм», например:

  word = 'фильм'
  

Все приведенные ниже примеры будут применены к этому слову.

Пример 1

Чтобы получить первые два символа:

  нарезанный = слово [: 2]
печать (нарезка)
мес
  

Обратите внимание, что мы могли использовать 0 для обозначения начала, но это не обязательно.

Пример 2

Последний товар:

  нарезано = слово [-1]
печать (нарезка)
е
  
Пример 3

Пропуск букв с шагом 2:

  нарезанный = слово [:: 2]
печать (нарезка)
мве
  

Как перевернуть строку в Python

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

  my_string = "феррари"

my_string_reversed = моя_строка [:: - 1]

печать (моя_строка)

печать (my_string_reversed)
  
  феррари

Ирарреф
  

Синтаксис среза позволяет вам установить шаг, который в примере равен -1 .

Шаг по умолчанию - 1 , то есть продвигаться вперед на 1 символ строки за раз.

Если вы установите шаг -1 , у вас будет обратное, возвращайтесь на 1 символ за раз.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *