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

как с ними работать — гайд для новичков / Skillbox Media

• 7 июл 2023
• 0

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

Марина Демидова

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

Строковый тип данных — один из основных типов данных в Python. Он используется для хранения символьной информации: букв, чисел, знаков препинания и других символов. Например, отлично подходит для записи ФИО или адресов клиентов в базах данных.

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

Содержание

• Вспомним, что такое строки
• Работа со строками в Python: базовые операции

• Сложение (конкатенация)
• Вычитание
• Дублирование (умножение)
• Принадлежность строки
• Определение длины строки
• Доступ по индексу
• Срез строки
• Шаг извлечения среза

• Таблица методов и функций строк
• Примеры кода

Строковый тип данных — это последовательности символов Unicode любой длины, заключённые в одинарные, двойные или тройные кавычки.

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

s1 = 'Hello, world!'
s2 = "Hello, world2"
s3 = '''Используем тройные
кавычки для вывода
многострочного текста'''

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

# Выведем на печать типы переменных s1, s2, s3
s1 = 'Hello, world!'
print(type(s1))
s2 = "Hello, world2"
print(type(s2))
s3 = '''Используем тройные
кавычки для вывода
многострочного текста'''
print(type(s3))

Запустим код и посмотрим на результат:

<class 'str'>
<class 'str'>
<class 'str'>

Да. Все три переменные имеют тип str, то есть являются строковыми.

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

Перед тем как перейти к конкретным действиям, напомним что строки в Python — неизменяемый тип данных. Это означает, что строковую переменную нельзя изменить с помощью операторов, функций и методов. Если мы хотим сохранить результат изменения существующей строки, то надо создать новую переменную.

Начнём! Разберём основные виды операций над строками. Запускайте любимый редактор кода и повторяйте действия за нами.

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

Например:

s1 = 'Skill'
s2 = 'box'
s3 = s1 + s2
print(s3)

Результат:

Skillbox

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

s3 = s2 + s1
print(s3)

Результат

boxSkill

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

Настоящей операции вычитания строк, по аналогии с числами, в Python не существует — мы не сможем отнять символы из строки с помощью операции

Он создаёт новую строку путём замены частей исходной строки. Лучше всего показать это на примере. Попробуем удалить часть слова, заменив её пустой строкой:

# Вычтем часть "box" из строки "Skillbox"
s1 = 'Skillbox'
s2 = 'box'
s3 = s1.replace(s2, '') # Передаём методу два аргумента — то, что хотим убрать из строки, и то, на что планируем заменить удалённый фрагмент
print(s3)

В результате получим:

Skill

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

st = 'ab ' * 6
print(st)

В результате получим:

ab ab ab ab ab ab

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

st = 35 * '*'
print(st)

Результат:

***********************************

Иногда разработчикам приходится проверять, есть ли в составе строки определённый фрагмент, который называют подстрокой. Например, мы хотим подтвердить наличие пользователя с определённым именем в нашей базе данных, где имя хранится вместе с фамилией — Иван Иванов. Строка здесь — это Иван Иванов, а нужная нам подстрока — Иван. Как это проверить? Воспользуемся проверкой принадлежности строки.

Для этого воспользуемся оператором in. Он возвращает True, если одна подстрока входит в состав строки, в противном случае возвращает False.

Например:

s1 = 'Иван Иванов'
s2 = 'Иван'
if s2 in s1: # Проверяем, есть ли «содержимое» строки s2 в s1 
    print('Пользователь Иван есть в нашей базе данных')
else:
    print('Пользователь Иван в базе данных отсутствует')

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

st = 'a'
if st == 'a' or  st == 'b' or  st == 'c' or  st == 'd':
    print('YES')

Выглядит сложно. Упростим его, объединив содержимое переменных в одну строку:

st = 'a'
if st in 'abcd':
    print('YES')

Не забывайте, что регистр символов имеет значение. Например, буквы «A» и «a» компьютер воспринимает как разные.

Это количество содержащихся в строке символов, включая пробелы. Чтобы определить длину строки, используется функция len() (от англ. length — длина). Например:

ln = len('Skillbox')
print(ln)
s1 = 'skill'
print(len(s1))

8
5

Чтобы выделить один символ строки, используют индексацию. Нумерация символов начинается с нуля и заканчивается длиной строки −1.

Например, посмотрим на индексацию строковой переменной, значение которой равно ‘Skillbox’:

Мы видим, что нумерация начинается с нуля, а заканчивается числом 7, то есть равна количеству символов в строке с вычетом единицы.

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

st = 'Skillbox'
print(st[0])
print(st[1])
print(st[2])
print(st[3])
print(st[4])
print(st[5])
print(st[6])
print(st[7])

В результате выполнения кода получим:

S
k
i
l
l
b
o
x

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

st = 'Skillbox'
print(st[8])

Результат выполнения:

IndexError: string index out of range

Индексацию также можно начинать с конца строки. В таком случае последний символ будет иметь индекс, равный −1, а индекс первого символа будет равен длине строки со знаком −. Посмотрим на такую индексацию на нашем примере:

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

st = 'Skillbox'
print(st[−9])

В результате получим:

IndexError: string index out of range

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

st[начальный индекс:конечный индекс]

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

Например:

st = 'Skillbox'
print(st[0:3])
print(st[2:5])
print(st[4:7])

Результат выполнения кода:

Ski
ill
lbo

Если не указывать начальный индекс, то срез берётся с начала строки. Если не указывать конечный — то до конца строки. Если опустить оба параметра, то срез возвращает всю строку. Попробуем несколько вариантов:

st = 'Skillbox'
print(st[:6]) # Срез с начала строки
print(st[5:]) # Срез до конца строки
print(st[:])  # Целая строка

Получаем срезы:

Skillb
box
Skillbox

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

Например:

st = 'Skillbox'
print(st[:10])

Получим срез:

Skillbox

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

st = 'Skillbox'
print(st[2:2]) # Конечный индекс равен начальному
print(st[5:3]) # Конечный индекс меньше начального

Этот код вернёт пустые строки, но ошибки не будет. Можете проверить в своём редакторе кода.

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

Например, программный код:

st = 'Skillbox'
print(st[−7:−4]) # Срез с отрицательными индексами
print(st[−4:−4]) # Начальный индекс равен конечному
print(st[−4:]) # Срез до конца строки
print(st[:−3]) # Срез с начала строки
print(st[−7:4]) # Срез с положительным и отрицательным индексами

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

kil # Всё сработало как надо
# Возврат пустой строки, так как начальный индекс равен конечному
lbox # Всё сработало как надо
Skill # Всё сработало как надо
kil # Всё сработало как надо

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

Например, если мы возьмём срез st[0:6:2] строки st = ‘Python’, то получим строку ‘Pto’:

Рассмотрим пример с отрицательными индексами. Например, срез st[-6:-1:2] строки st = ‘Python’ тоже будет равен ‘Pto’:

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

Например, срез st[-3:-7:-2] возвращает строку ‘hy’. Как видим, правая граница здесь не включается в срез.

Отрицательный шаг можно использовать с положительными индексами, например:

st = 'Skillbox'
print(st[6:1:−2])

Результат выполнения:

oli

Чтобы вывести символы строки в обратном порядке, удобно использовать срез [::−1], например:

st = 'шорох'
print(st[::−1])  
st = 'город'
print(st[::−1])  
st = 'топор'
print(st[::−1])  

В результате выполнения получим:

хорош
дорог
ропот

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

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

S.find(str, [start], [end])	Поиск подстроки str в строке S в интервале индексов (start, end). Возвращает индекс первого совпавшего значения подстроки. Если подстрока не найдена, возвращает −1. Здесь start и end — необязательные аргументы. Если они не заданы, поиск ведётся во всей строке
S.rfind(str, [start], [end])	Поиск подстроки str в строке S в интервале индексов (start, end). Возвращает индекс последнего совпавшего значения подстроки. Если подстрока не найдена, возвращает −1. Здесь start и end — необязательные аргументы. Если они не заданы, поиск ведётся во всей строке
S.count(t)	Возвращает количество непересекающихся вхождений подстроки t в строку S. То есть метод начинает искать следующую подстроку строго после окончания предыдущей. Например, в строке s = ‘ababab’ есть два пересекающихся вхождения ‘abab’, но непересекающееся вхождение одно. Метод вернёт единицу
S.isdigit()	Проверяет, состоит ли строка из цифр. Если да, возвращает True, иначе — False
S. upper()	Преобразует символы строки к верхнему регистру. Заглавные буквы и символы, которые не относятся к буквам, не меняются
S.lower()	Преобразует символы строки к нижнему регистру. Строчные буквы и символы, которые не относятся к буквам, не меняются
S.lstrip([символ])	Удаляет определённые символы в начале строки. Здесь [символ] — необязательный аргумент. Если он не задан, метод удаляет пробелы
S.rstrip([символ])	Удаляет определённые символы в конце строки. Здесь [символ] — необязательный аргумент. Если он не задан, метод удаляет пробелы
S.split([разделитель [, maxsplit]])	Разбивает строку по разделителю и возвращает список, содержащий подстроки. Если разделитель не задан, то строка разбивается по пробелу, символу перевода строки или табуляции. maxsplit — необязательный аргумент, определяет максимальное количество частей, на которые разбивается строка. Если он не задан, то количество фрагментов не ограничивается. При заданном maxsplit максимальное количество элементов в списке равно maxsplit+1
chr(число)	Преобразует код ASCII в символ
ord(символ)	Преобразует символ в его код ASCII
sorted(строка)	Сортирует символы строки в порядке возрастания их номеров в таблице ASCII
list(строка)	Возвращает список, состоящий из символов строки

Рассмотрим несколько практических примеров использования функций и методов.

К ним относятся два метода: S.find(str, [start], [end]) и S.rfind(str, [start], [end]).

s = 'SkillboxSkillbox'
str = 'box'
print(s.find(str))  # Возвращает индекс первого совпавшего значения подстроки
print(s.rfind(str)) # Возвращает индекс последнего совпавшего значения подстроки

Результат выполнения кода:

5
13

Если подстроки в строке нет, Python возвращает −1:

S = 'SkillboxSkillbox'
print(S.rfind('abc'))

Результат:

-1

Поиск в срезе:

S = 'Skillbox'
str = 'box'
print(S.find(str,0,7))

Результат:

-1

Здесь подстрока str ищется в срезе S[0:7]. Так как правая граница в срез не включается, Python не находит подстроку и выдаёт −1.

Для преобразования используются два метода:

• S.upper() — преобразование всех символов строки S в верхний регистр.
• S.lower() — преобразование всех символов строки S в нижний регистр.

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

Например:

S = 'Skillbox 23'
print(S.upper())  # Переводит все символы в верхний регистр
print(S.lower())  # Переводит все символы в нижний регистр
print(S) # Проверяем значение исходной строки

В результате получим:

SKILLBOX 23
skillbox 23
Skillbox 23

Если мы хотим сохранить результат, то результат выполнения метода надо присвоить новой переменной.

Для разбиения строки по разделителю используется метод S.split([разделитель [, maxsplit]]). Посмотрим на него в коде:

S = 'Cat, Dog,Hamster   Rabbit, Pig'
print(S.split())  # Разделитель не задан. Метод разбивает строку по пробельным символам — пробелу и знаку табуляции
print(S.split(',')) # Разбивает строку по заданному разделителю ','
print(S.split(',', 2)) # Задаёт максимальное количество разбиений, равное 3

Результат:

['Cat,', 'Dog,Hamster', 'Rabbit,', 'Pig']
['Cat', ' Dog', 'Hamster   Rabbit', ' Pig']
['Cat', ' Dog', 'Hamster   Rabbit, Pig']

Методы rjust() и ljust():

S = 'Hi!'
print(S.rjust(10,'*')) # Увеличивает длину строки до 10 и заполняет пробелы слева символами '*'
print(S.ljust(10,'*')) # Увеличивает длину строки до 10 и заполняет пробелы справа символами '*'

В результате выполнения получим:

*******Hi!
Hi!*******

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

Читайте также:

Листая дальше, вы перейдете на страницу курса

Понравилась статья?

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

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

В этом руководстве мы рассмотрим некоторые строковые функции Python 3.

• Работа со строками Python 3 — создание строк в верхнем и нижнем регистре
• Работа со строками Python 3 — логические методы строк питон
• Как определяется длина строки Python?
• Методы join в Python, split() и функция replace Python 3
• Заключение

Функции str.upper() и str.lower() возвращают строку со всеми буквами исходной строки, преобразованными в прописные или строчные буквы.  Символы в строке, которые не являются буквами, меняться не будут.

Преобразуем строку Sammy Shark в верхний регистр:

ss = "Sammy Shark"
print(ss.upper())

Вывод:

SAMMY SHARK

Теперь преобразуем эту же строку в нижний регистр:

print(ss.lower())

Вывод:

sammy shark

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

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

Существует ряд строковых методов, которые возвращают логические значения:

Метод	True если
str.isalnum()	Строка состоит только из буквенно-цифровых символов (без специальных символов).
str.isalpha()	Строка состоит только из буквенных символов (без специальных символов).
str.islower()	Все буквенные символы строки имеют нижний регистр.
str.isnumeric()	Строка состоит только из цифровых символов.
str.isspace()	Строка состоит только из символов пробелов.
str.istitle()	Строка заглавными буквами.
str.isupper()	Все буквенные символы строки имеют верхний регистр.

Рассмотрим несколько методов в действии:

number = "5"
letters = "abcdef"
print(number.isnumeric())
print(letters.isnumeric())
Вывод:
True
False

Метод str.isnumeric() возвращает для строки number = «5» значение True, а тот же метод для строки letters = «abcdef» возвращает значение False.

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

Создадим несколько строк:

movie = "2001: A SAMMY ODYSSEY"
book = "A Thousand Splendid Sharks"
poem = "sammy lived in a pretty how town"

Теперь применим логические методы, которые проверяют регистр:

print(movie. islower())
print(movie.isupper())
print(book.istitle())
print(book.isupper())
print(poem.istitle())
print(poem.islower())

Выполним код и посмотрим на результат:

Вывод для строки movie:

False
True

Вывод для строки book:

True
False

Вывод для строки poem:

False
True

Проверка регистра строки позволяет правильно отсортировать данные. Логические методы также полезны для валидации полей форм на сайте.

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

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

open_source = "Sammy contributes to open source."
print(len(open_source))

Вывод:

Мы инициализируем переменную open_source строковым значением «Sammy contributes to open source.». Затем передаем эту переменную в метод len() с помощью len(open_source).  После этого используем  print() для вывода результата на экран.

Помните, что любой символ, заключенный в одинарные или двойные кавычки, будет учитываться методом len().

Метод join Python объединяет две строки и разделяет их указанным символом.

Давайте создадим строку:

balloon = "Sammy has a balloon."

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

" ".join(balloon)

Если мы выведем это:

print(" ".join(balloon))

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

Вывод:

S a m m y   h a s   a   b a l l o o n .

Функция join python также может использоваться для возврата строки, которая является перевернутой исходной строкой:

print("".join(reversed(balloon)))

Вывод:

.noollab a sah ymmaS

Метод str.join() также полезен для объединения списка строк в новую единственную строку.

Создадим разделенную запятыми строку из списка строк:

print(",". join(["sharks", "crustaceans", "plankton"]))

Вывод:

sharks,crustaceans,plankton

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

".join(["sharks", "crustaceans", "plankton"]).

Также можно и разбивать строки. Для этого используется метод str.split():

print(balloon.split())

Вывод:

['Sammy', 'has', 'a', 'balloon.']

Метод str.split() возвращает список строк, разделенных пробелами, если никакой другой параметр не задан.

Также можно использовать str.split() для удаления определенных частей строки. Например, давайте удалим из строки букву a:

print(balloon.split("a"))

Вывод:

['S', 'mmy h', 's ', ' b', 'lloon.']

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

Метод str.replace() применять для замены части строки. Допустим, что  шарик, который был у Сэмми, потерян. Поскольку у Сэмми больше нет этого шарика, изменим подстроку «has» на новую строку «had»:

print(balloon. replace("has","had"))

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

Вывод:

Sammy had a balloon.

Методы строк Python str.join(), str.split() и str replace Python позволяют более эффективно управлять строками в Python.

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

Вадим Дворниковавтор-переводчик статьи «An Introduction to String Functions in Python 3»

Пожалуйста, опубликуйте ваши отзывы по текущей теме материала. За комментарии, подписки, отклики, лайки, дизлайки низкий вам поклон!

строковых функций в Python с примерами

Список часто используемых строковых функций

Функция	Описание	MS EXCEL ФУНКЦИЯ
моя строка[:N]	Извлечь N символов из начала строки.	ЛЕВЫЙ( )
моя строка[-N:]	Извлечь N символов из конца строки	ПРАВО( )
моя строка[X:Y]	Извлечь символы из середины строки, начиная с позиции X и заканчивая Y	СРЕДНИЙ( )
ул. split(sep=’ ‘)	Разделенные струны	—
ул.заменить (старая_подстрока, новая_подстрока)	Заменить часть текста другой подстрокой	ЗАМЕНИТЬ( )
ул.нижний()	Преобразование символов в нижний регистр	НИЖНИЙ( )
стр.верхний()	Преобразование символов в верхний регистр	ВЕРХНЯЯ( )
str.contains(‘шаблон’, case=False)	Проверка соответствия шаблону (функция Pandas)	Оператор SQL LIKE
стр.экстракт(regular_expression)	Возврат совпадающих значений (функция Pandas)	—
количество ул(‘sub_string’)	Количество вхождений шаблона в строке	—
ул. найти()	Возврат позиции подстроки или шаблона	НАЙТИ()
улица isalnum()	Проверить, состоит ли строка только из буквенно-цифровых символов	—
улица islower()	Проверить, все ли символы в нижнем регистре	—
ул. верхний()	Проверить, все ли символы в верхнем регистре	—
числовая строка()	Проверить, состоит ли строка только из цифр	—
ул.isspace()	Проверить, состоит ли строка только из пробельных символов	—
лен( )	Вычислить длину строки	ДЛИН( )
кот( )	Объединение строк (функция Pandas)	СЦЕПИТЬ( )
separator.join(str)	Объединить строки	СЦЕПИТЬ( )

Функции LEFT, RIGHT и MID

1. Извлечь первые два символа из начала строки

 mystring = "Эй, приятель, как дела?"
моя строка[:2]
 

 Выход[1]: 'Он'
 

1. string[start:stop:step] означает начало элемента от 0 (по умолчанию) до (stop-1), шаг за шагом 1 (по умолчанию).
2. mystring[:2] эквивалентно mystring[0:2]
3. mystring[:2] сообщает Python, что нужно извлечь первые 2 символа из строкового объекта mystring .
4. Индексирование начинается с нуля, поэтому оно включает первый, второй элемент и исключает третий.

2. Найти два последних символа строки

 mystring[-2:]
 

3. Найти символы из середины строки

 mystring[1:3]
 

 Исходящий[1]: 'эй'
 

4. Как перевернуть строку?

 моя строка[::-1]
 

 Out[1]: '?pussaw ,yddub yeH'
 

5. Как извлечь символы из строковой переменной в Pandas DataFrame?

.
импортировать панд как pd
df = pd.DataFrame({"var1": ["A_2", "B_1", "C_2", "A_2"]})
  переменная1
0 А_2
1 Б_1
2 С_2
3 А_2
 

 df['var1'].str[0] 

  Выход 
0 А
1 Б
2 С
3 А
 

Извлечение слов из строки

1. Найти первое слово строки

 mystring. split()[0]
 

 Исх[1]: 'Эй'
 

Как это работает?

1. функция split() разбивает строку, используя пробел в качестве разделителя по умолчанию
2. mystring.split() возвращает ['Эй', 'приятель', 'как дела?']
3. 0 возвращает первый элемент или слово Hey

2. Запятая как разделитель слов

 mystring.split(',')[0]
 

 Исходящий[1]: 'Эй, приятель'
 

3. Как извлечь последнее слово

 mystring.split()[-1]
 

 Out[1]: 'как дела?' 

4. Как извлечь слово из DataFrame

mydf = pd.DataFrame({"custname": ["Priya_Sehgal", "David_Stevart", "Kasia_Woja", "Sandy_Dave"]})
 

        пользовательское имя
0 Прия_Сегал
1 Дэвид_Стеварт
2 Кася_Воя
3 Сэнди_Дэйв
 

#Первое слово
mydf['fname'] = mydf['custname']. str.split('_').str[0]
#Последнее слово
mydf['lname'] = mydf['custname'].str.split('_').str[1]
 

Подробное объяснение

1. str.split() аналогичен split() . Он используется для активации функции разделения во фрейме данных pandas в Python.
2. В приведенном выше коде мы создали два новых столбца с именами fname и lname , в которых хранятся имя и фамилия.

  Выход 
        имя пользователя fname lname
0 Priya_Sehgal Прия Сегал
1 David_Stevart Дэвид Стюарт
2 Kasia_Woja Кася Воя
3 Сэнди_Дэйв Сэнди Дэйв
 

Оператор SQL LIKE в Pandas DataFrame

df2 = pd.DataFrame({"var1": ["AA_2", "B_1", "C_2", "a_2"],
                    "var2": ["X_2", "Y_1", "Z_2", "X2"]})
 

   вар1 вар2
0 АА_2 Х_2
1 Б_1 Д_1
2 C_2 Z_2
3 а_2 Х2
 

Как найти строки, содержащие либо A, либо B в переменной var1?

 df2['var1']. str.contains('A|B') 

  Выход 
0 Верно
1 правда
2 Ложь
3 Ложь
 

Приведенная выше команда возвращает ЛОЖЬ для четвертой строки, поскольку функция чувствительна к регистру. Чтобы игнорировать чувствительность к регистру, мы можем использовать параметр case=False . См. рабочий пример ниже.

 df2['var1'].str.contains('A|B', case=False) 

Как фильтровать строки, содержащие определенный шаблон?

  вар1 вар2
1 Б_1 Д_1
2 C_2 Z_2
3 а_2 Х2
 

Найти позицию определенного символа или ключевого слова

df2['var1'].str.find('_')
 

0 2
1 1
2 1
3 1
 

Заменить подстроку

df2['var1'].str.replace('_', '--', case=False)
 

  Выход 
0 АА--2
1 Б--1
2 С--2
3 А--2
 

df2['var1'].str.replace('[A-Z]+_', 'X', case=False)
 

0 х2
1 х 1
2 х 2
3 х 2
 

Найти длину строки

df2['var1']. str.len()
 

  Выход 
0 4
1 3
2 3
3 3
 

 df2['var1'].str.count('A') 

Преобразование в нижний и верхний регистр

# Преобразовать в нижний регистр
mydf['имя пользователя'].str.lower()
# Преобразовать в верхний регистр
mydf['имя пользователя'].str.upper()
 

Удалить начальные и конечные пробелы

1. str.strip() удаляет как начальные, так и конечные пробелы.
2. стр.lstrip() удаляет начальные пробелы (в начале).
3. str.rstrip() удаляет конечные пробелы (в конце).

df1 = pd.DataFrame({'y1': ['Джек', 'Джилл', 'Джесси', 'Фрэнк']})
df1['оба']=df1['y1']. str.strip()
df1['left']=df1['y1'].str.lstrip()
df1['право']=df1['y1'].str.rstrip()
 

        y1 оба слева направо
0 джек джек джек джек
1 Джилл Джилл Джилл Джилл
2 Джесси Джесси Джесси Джесси
3 Фрэнк Фрэнк Фрэнк Фрэнк
 

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

моя переменная = 4
mystr = str (моя переменная)
 

Объединение или объединение строк

х = "Дипаньшу"
у = "Бхалла"
х+у
 

ДипаншуБхалла
 

string0 = ['Рам', 'Кумар', 'Сингх']
' .присоединиться (строка0)
 

  Выход 
'Рам Кумар Сингх'
 

mydf[‘полное имя’] = mydf[‘fname’] + ‘ ‘ + mydf[‘lname’]

mydf[‘полное имя’] = mydf[[‘fname’, ‘lname’]].apply(лямбда x: ‘ ‘.join(x), ось=1)

     пользовательское имя fname lname полное имя
0 Priya_Sehgal Прия Сегал Прия Сегал
1 David_Stevart Дэвид Стюарт Дэвид Стюарт
2 Kasia_Woja Kasia Woja Kasia Woja
3 Sandy_Dave Сэнди Дэйв Сэнди Дэйв
 

Оператор SQL IN в Pandas

mydata = pd.DataFrame({'продукт': ['A', 'B', 'B', 'C','C','D','A']})
мои данные[мои данные['продукт'].isin(['A', 'B'])]
 9[A-Z]_)').dropna()
 

Встроенные строковые функции в Python

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

Метод	Описание
капитализировать ()	Возвращает копию строки, в которой первый символ заглавный, а остальные буквы — строчные.
чехол()	Возвращает строку в нижнем регистре. Он похож на метод lower(), но метод casefold() преобразует больше символов в нижний регистр.
центр()	Возвращает новую центрированную строку указанной длины, дополненную указанным символом. Символ по умолчанию — пробел.
считать()	Ищет (с учетом регистра) указанную подстроку в заданной строке и возвращает целое число, указывающее вхождения подстроки.
заканчивается()	Возвращает True, если строка заканчивается указанным суффиксом (с учетом регистра), в противном случае возвращает False.
расширить вкладки ()	Возвращает строку, в которой все символы табуляции \t заменены одним или несколькими пробелами, в зависимости от количества символов перед \t и указанного размера табуляции.
находить()	Возвращает индекс первого вхождения подстроки в заданной строке (с учетом регистра). Если подстрока не найдена, возвращается -1.
индекс()	Возвращает индекс первого вхождения подстроки в заданной строке.
Изальнум ()	Возвращает True, если все символы в строке являются буквенно-цифровыми (буквами или цифрами). Если нет, возвращается False.
альфа()	Возвращает True, если все символы в строке являются буквенными (как строчными, так и прописными), и возвращает False, если хотя бы один символ не является алфавитом.
isascii ()	Возвращает True, если строка пуста или все символы в строке ASCII.
десятичный()	Возвращает True, если все символы в строке являются десятичными. Если нет, возвращается False.
isdigit()	Возвращает True, если все символы в строке являются цифрами или символами Unicode цифры. Если нет, возвращается False.
идентификатор()	Проверяет, является ли строка допустимой строкой идентификатора или нет. Он возвращает True, если строка является допустимым идентификатором, в противном случае возвращает False.
ниже()	Проверяет, все ли символы данной строки в нижнем регистре или нет. Он возвращает True, если все символы в нижнем регистре, и False, даже если один символ в верхнем регистре.
числовой()	Проверяет, все ли символы строки являются числовыми или нет. Он вернет True, если все символы являются числовыми, и вернет False, даже если один символ не является числовым.
печатаемый ()	Возвращает True, если все символы данной строки являются Printable. Он возвращает False, даже если один символ является непечатаемым.
isspace()	Возвращает True, если все символы заданной строки являются пробелами. Он возвращает False, даже если один символ не является пробелом.
istitle()	Проверяет, является ли первый символ каждого слова прописным, а остальные строчными или нет. Он возвращает True, если строка имеет заглавный регистр; в противном случае возвращается False. Символы и цифры игнорируются.
выше()	Возвращает True, если все символы в верхнем регистре, и False, даже если один символ не в верхнем регистре.
присоединиться()	Возвращает строку, которая представляет собой конкатенацию строки (для которой она вызывается) со строковыми элементами указанного итерируемого объекта в качестве аргумента.
просто()	Возвращает выровненную по левому краю строку с указанной шириной. Если указанная ширина больше длины строки, то оставшаяся часть строки заполняется указанным fillchar.
ниже()	Возвращает копию исходной строки, в которой все символы преобразованы в нижний регистр.
lstrip()	Возвращает копию строки, удаляя начальные символы, указанные в качестве аргумента.
сделатьтранс()	Возвращает таблицу сопоставления, которая сопоставляет каждый символ в заданной строке с символом во второй строке в той же позиции. Эта таблица сопоставления используется с методом translate(), который заменяет символы в соответствии с таблицей сопоставления.
раздел()	Разбивает строку при первом появлении указанного аргумента разделителя строк и возвращает кортеж, содержащий три элемента: часть перед разделителем, сам разделитель и часть после разделителя.
заменять()	Возвращает копию строки, в которой все вхождения подстроки заменены другой подстрокой.
найти()	Возвращает наивысший индекс указанной подстроки (последнее вхождение подстроки) в данной строке.
риндекс()	Возвращает индекс последнего вхождения подстроки в заданной строке.
просто()	Возвращает выровненную по правому краю строку с указанной шириной. Если указанная ширина больше длины строки, то оставшаяся часть строки заполняется указанным заполняющим символом.
рраздел()	Разбивает строку в последнем вхождении указанного аргумента sep разделителя строк и возвращает кортеж, содержащий три элемента: часть перед разделителем, сам разделитель и часть после разделителя.
rsplit()	Разделяет строку с указанным разделителем и возвращает объект списка со строковыми элементами.
рстрип()	Возвращает копию строки, удаляя конечные символы, указанные в качестве аргумента.
расколоть()	Разделяет строку с указанным разделителем и возвращает объект списка со строковыми элементами.
линии разделения()	Разбивает строку по границам строк и возвращает список строк в строке.
начинается с()	Возвращает True, если строка начинается с указанного префикса. Если нет, возвращается False.
полоска()	Возвращает копию строки, удаляя как начальные, так и конечные символы.
свопкейс()	Возвращает копию строки с преобразованием символов верхнего регистра в нижний регистр и наоборот. Символы и буквы игнорируются.
название ()	Возвращает строку, в которой каждое слово начинается с символа верхнего регистра, а остальные символы — строчными.
переводить()	Возвращает строку, в которой каждый символ сопоставляется с соответствующим символом в таблице перевода.
верхний()	Возвращает строку в верхнем регистре. Символы и цифры остаются неизменными.
zfill()	Возвращает копию строки с символами ‘0’, дополненными слева. No related posts. Вперед Легкие языки программирования для начинающих: Языки программирования для начинающих: критерии выбора Назад Как убрать пиксели на фото в фотошопе: Разглаживание пиксельной лесенки по контуру объекта в Фотошопе Добавить комментарий Отменить ответ Ваш адрес email не будет опубликован. Обязательные поля помечены * Комментарий * Имя * Email * Сайт Рубрики Css Html Http Javascript Photoshop Верстка Вопросы и ответы Макет Развитие сайтов Сайт Шаблон Шрифт Разное Рубрики Css Html Http Javascript Linux Photoshop Адаптив Верстка Вопросы и ответы Макет Развитие сайтов Разное Сайт Советы Шаблон Шаблоны Шрифт Шрифты