Python строковые функции: Строковые методы в Python. Узнаём популярные и эксклюзивные… | by Андрей Шагин | NOP::Nuances of Programming

Содержание

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



Как я могу определить, может ли строка быть целым числом в Python. Например: если я пишу функции с именами digit() и nondigit(). Строка должна состоять либо из цифр (1-9), либо из букв.

str1 = '4582'
str1.digit() == True
str2 = '458dfr'
str2.digit() == False
str3 = 'abcd'
str3.nondigit() == True
str4 = '258edcx'
str4.nondigit() == False
python string integer boolean digit
Поделиться Источник user3552506     22 апреля 2014 в 17:06

4 ответа


  • C++: строковые функции без <cstring>

    Я начал изучать строки и строковые функции (из книги) , я изучил такие функции, как strcpy , strcat и strncat … и т. д. Поэтому я начал практиковаться в использовании их в простых программах, чтобы понять, что они делают. Позже я был удивлен, что в книге говорится, что я должен использовать. ..

  • PHP строковые функции против функций mbstring

    У меня есть приложение, которое до сих пор было только на английском языке. Кодировка контента во всех шаблонах и базах данных была UTF-8. Теперь я хочу интернационализировать/перевести приложение на языки, которые имеют наборы символов, абсолютно нуждающиеся в UTF-8. Приложение использует…



5

Объекты str имеют метод isdigit , который выполняет одну из ваших задач. С более широкой точки зрения, лучше просто попробовать и посмотреть:

def digit(s):
    try:
        int(s)
        return True
    except ValueError:
        return False

Например, " 1234 ".isdigit() — это False (есть пробелы), но python может преобразовать его в int, поэтому моя функция

digit -это True .

Поделиться mgilson     22 апреля 2014 в 17:08



2

Для этого есть встроенное устройство.

'4582'.isdigit() == True
'458dfr'.isdigit() == False

«Under the hood» это, вероятно, очень похоже на:

def isdigit(self):
    return all(ch in "0123456789" for ch in self)

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

data = "123456"
try:
    data = int(data)
except ValueError:
    # handle this if your data is not a number

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

int приведениям, так и к проверке существования файла перед его открытием. Это создает условие гонки, когда если data может быть превращен в число при проверке, но затем другой поток берет на себя и изменяет его, прежде чем он будет приведен к int , вы получаете ошибку. Аналогично с файлами, если вы проверяете, что файл существует, но что-то удаляет его, прежде чем он может быть открыт, вы SOL.

Вместо этого сделайте то, что вы пытаетесь сделать, и «ask forgiveness», если это приведет к ошибке. Легче просить прощения, чем разрешения .

Поделиться Adam Smith     22 апреля 2014 в 17:07



0

Используйте .isdigit() для встроенного способа сделать это.

>>> string = 'hello'
>>> num = '98'
>>> string.isdigit()
False
>>> num.isdigit()
True
>>> 

Вы также можете создать свою собственную функцию:

>>> def digit(num):
...     try:
...             int(num)
...             return True
...     except ValueError:
...             return False
... 
>>> digit('45')
True
>>> digit('hello')
False
>>> 

Поделиться A. J. Uppal     22 апреля 2014 в 17:11


  • JSTL 1.0 Строковые Функции

    Я пытаюсь использовать некоторые строковые функции, такие как trim или concat , используя JSTL. Я попробовал следующее. Я попытался добавить <%@ taglib prefix=fn uri=http://java.sun.com/jsp/jstl/functions %> , но в итоге получил ошибку. Я думаю, что это для другой версии JSTL, такой как 1.2…

  • Javascript переменные / строковые функции?

    Я практикую читабельность кода и beautifying мой код, поэтому я хочу узнать, как это реализовать. Я видел, как это делают другие коды, но не помню, какие и как они это делали. Я хочу создать свои собственные функции .string, например: var rmbrackets = new function() { return…



0

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

(И кстати, он выглядит еще красивее.)

Я положил его в блокнот IPython, если вы хотите запустить его на своей машине:

И вот результаты, если:

import timeit

def string_is_int(a_str):
    try:
        int(a_str)
        return True
    except ValueError:
        return False

an_int = '123'
no_int = '123abc'

%timeit string_is_int(an_int)
%timeit string_is_int(no_int)
%timeit an_int.isdigit()
%timeit no_int.isdigit()

1000000 loops, best of 3: 401 ns per loop
100000 loops, best of 3: 3.04 µs per loop
10000000 loops, best of 3: 92.1 ns per loop
10000000 loops, best of 3: 96.3 ns per loop

Кроме того, я проверил более общий случай:

import timeit

def string_is_number(a_str):
    try:
        float(a_str)
        return True
    except ValueError:
        return False

a_float = '1.234'
no_float = '123abc'

a_float.replace('.','',1).isdigit()
no_float.replace('.','',1).isdigit()


%timeit string_is_number(an_int)
%timeit string_is_number(no_int)
%timeit a_float.
replace('.','',1).isdigit() %timeit no_float.replace('.','',1).isdigit() 1000000 loops, best of 3: 400 ns per loop 1000000 loops, best of 3: 1.15 µs per loop 1000000 loops, best of 3: 452 ns per loop 1000000 loops, best of 3: 394 ns per loop

Поделиться Unknown     22 апреля 2014 в 17:35


Похожие вопросы:


Являются ли строковые функции ASCII-безопасными в PHP?

Некоторые строковые функции PHP (например, strtoupper и т. д.) зависят от locale. Но до сих пор неясно, важно ли locale, когда я действительно знаю, что конкретная строка состоит только из ASCII…


Android Строковые Функции Renderscript?

Существуют ли какие-либо строковые функции в Renderscript? Как, например, vsprintf? В частности, я хотел бы преобразовать поплавок в строку. Неужели я должен писать это с нуля? Спасибо!


PHP Многобайтовые Строковые Функции

Сегодня я столкнулся с проблемой с функцией php strpos() , потому что она возвращала FALSE, даже если правильный результат был явно 0. Это произошло потому, что один параметр был закодирован в…


C++: строковые функции без <cstring>

Я начал изучать строки и строковые функции (из книги) , я изучил такие функции, как strcpy , strcat и strncat … и т. д. Поэтому я начал практиковаться в использовании их в простых программах,…


PHP строковые функции против функций mbstring

У меня есть приложение, которое до сих пор было только на английском языке. Кодировка контента во всех шаблонах и базах данных была UTF-8. Теперь я хочу интернационализировать/перевести приложение…


JSTL 1.0 Строковые Функции

Я пытаюсь использовать некоторые строковые функции, такие как trim или concat , используя JSTL. Я попробовал следующее. Я попытался добавить <%@ taglib prefix=fn…


Javascript переменные / строковые функции?

Я практикую читабельность кода и beautifying мой код, поэтому я хочу узнать, как это реализовать.

Я видел, как это делают другие коды, но не помню, какие и как они это делали. Я хочу создать свои…


Форматированные строковые литералы в Python 3.6+

Форматированные строковые литералы в Python 3.6+ Я читал в форматированные строковые литералы (a.k.a f-string ), которые являются функцией, добавленной из обновления Python 3.6. Мне легче читать,…


Как деконструировать строковые данные в python?

>>> st[‘xy’][0] >>> ‘(35.25792753, 129.2127994)’ >>> filled[‘xy’][0] >>> (37.77432579, 128.9071418) Мне нужен формат ( х , г ) данных( Х , Y ) ‘ для использования…


Python POST строковые данные

Мне нужно опубликовать строковые данные, и я могу сделать это с помощью curl, но не с помощью модуля запросов python. CURL пример: curl -XPOST https://hostname/apisyntax?queryparams -d…

Строковые методы в Python

Узнайте, какие встроенные методы Python используются в строковых последовательностях

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

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

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

Код для этой статьи можно взять из соответствующего репозитория Github Repository.

1. center( )

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

Синтаксис

str.center(length, fillchar), где:

  • length — это длина строки [обязательный параметр]
  • fillchar—это символ, задающий выравнивание [на выбор]
Пример

2.

count( )

Метод count() возвращает счёт или число появлений в строке конкретного значения.

Синтаксис

str.count

(value, start, end), где:

  • value — это подстрока, которая должна быть найдена в строке [обязательный параметр]
  • start — это начальное значение индекса в строке, где начинается поиск заданного значения [на выбор]
  • end — это конечное значение индекса в строке, где завершается поиск заданного значения [на выбор]
Пример

3. find( )

Метод find() возвращает наименьшее значение индекса конкретной подстроки в строке. Если подстрока не найдена, возвращается -1.

Синтаксис

str.find(value, start, end), где:

  • value или подстрока, которая должна быть найдена в строке [обязательный параметр]
  • start — это начальное значение индекса в строке, где начинается поиск заданного значения [на выбор]
  • end — это конечное значение индекса в строке, где завершается поиск заданного значения [на выбор]
Типы

rfind(): метод rfind() такой же, как find(), за исключением того, что он возвращает наибольшее значение индекса подстроки.

Пример

4. swapcase( )

Метод swapcase() возвращает копию строки, преобразуя все заглавные буквы в строчные, и наоборот. 

Синтаксис

string.swapcase()

Пример

5. startswith( ) and endswith( )

Метод startswith() возвращает True, если строка начинается с заданного значения. В противном случае возвращает False.

С другой стороны, функция endswith() возвращает True, если строка заканчивается заданным значением. В противном случае возвращает False.

Синтаксис

string.startswith(value, start, end)

string.endsswith(value, start, end)

  • value — это искомая строка в строке [обязательный параметр]
  • start — это начальное значение индекса в строке, где начинается поиск заданного значения [на выбор]
  • end — это конечное значение индекса в строке, где завершается поиск заданного значения [на выбор]
Пример

6.

split( )

Метод split() возвращает список слов в строке, где разделителем по умолчанию является пробел.

Синтаксис

string.split(sep, maxsplit)

  • sep: разделитель, используемый для разделения строки. Если не указано иное, разделителем по умолчанию является пробел [на выбор]
  • maxsplit: обозначает количество разделений. Значение по умолчанию -1, что значит «все случаи» [на выбор]
Вариант
  • rsplit(): разделяет строку справа.
Пример

7. Строка заглавными буквами

1. capitalize( )

Метод capitalize() меняет на заглавную букву только первый символ строки.

Синтаксис

string.capitalize()

2. upper( )

Метод upper() делает заглавными все буквы в строке.

Синтаксис

string.upper()

3. string.title( )

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

Синтаксис

string.title()

Пример

8. ljust( ) и rjust( )

С помощью заданного символа (по умолчанию пробел) метод ljust() возвращает вариант выбранной строки с левым выравниванием. Метод rjust() выравнивает строку вправо.

Синтаксис

string.rjust/ljust(length, character)

  • length: длина строки, которая должна быть возвращена [обязательный параметр]
  • character: символ для заполнения незанятого пространства, по умолчанию являющийся пробелом [на выбор]
Пример

9. strip( )

Метод strip() возвращает копию строки без первых и последних символов. Эти отсутствующие символы — по умолчанию пробелы.

Синтаксис

string.strip(character)

character: набор символов для удаления [на выбор]

Варианты
  • rstrip(): удаляет символы с начала строки.
  • lstrip(): удаляет символы с конца строки.

10. zfill( )

Метод zfill() добавляет нули в начале строки. Длина возвращаемой строки зависит от заданной ширины.

Синтаксис

string.zfill(width)

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

Заключение

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

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


Перевод статьи Parul Pandey: Useful String Method

Полезные строковые методы в Python

Дата публикации Aug 12, 2019

Исходное изображение:Терри БликернаUnsplash

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

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

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

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


center()Метод center выравнивает строку. Выравнивание выполняется с использованием указанного символа (пробел по умолчанию)

Синтаксис

str.center(length, fillchar), где :

  • длинадлина строки [необходимые]
  • FillCharэто символ, который определяет выравнивание [Необязательный]

пример


count()Метод возвращает количество или количество раз, когда определенное значение появляется в строке.

Синтаксис

str.count(value, start, end), где :

  • ценностьподстрока, которая должна быть найдена в строке [необходимые]
  • Началоявляется начальным индексом в строке, где начинается поиск указанного значения [Необязательный]
  • конецэто конечный индекс в строке, где поиск указанного значения заканчивается [Необязательный]

пример


find()Метод возвращает самый низкий индекс определенной подстроки в строке. Если подстрока не найдена, возвращается -1.

Синтаксис

str.find(value, start, end), где :

  • ценностьили подстрока, которая должна быть найдена в строке [необходимые]
  • Началоявляется начальным индексом в строке, где начинается поиск указанного значения [Необязательный]
  • конецэто конечный индекс в строке, где поиск указанного значения заканчивается [Необязательный]

Типы

RFIND ():RFIND ()метод аналогичен find () за исключением того, что он возвращает самое высокое значение индекса подстроки

пример


swapcase ()Метод возвращает копию строки со всеми ее заглавными буквами, преобразованными в строчные и наоборот.

Синтаксис

string.swapcase()

пример


startswith()метод возвращает True, если строка начинается с указанного значения; в противном случае возвращается False.

endswith()Функция, с другой стороны, возвращает True, если строка заканчивается указанным значением, иначе возвращает False.

Синтаксис

string.startswith(value, start, end)

string.endsswith(value, start, end)

  • ценностьстрока для поиска в строке [необходимые]
  • Началоявляется начальным индексом в строке, где начинается поиск указанного значения [Необязательный]
  • конецэто конечный индекс в строке, где поиск указанного значения заканчивается [Необязательный]

пример


Трещина()Метод возвращает список слов в строке, где разделителем по умолчанию является любой пробел.

Синтаксис

string.split(sep, maxsplit)

  • сентябрь: Разделитель, который будет использоваться для разделения строки. если ничего не указано, пробел является разделителем по умолчанию [Необязательный]
  • maxsplit:обозначает количество расколов. По умолчанию -1, что означает «все вхождения» [Необязательный]

Версия

  • rsplit (): разбивает строку справа.

пример


1. использовать заглавные буквы ()

прописные буквы ()Метод использует только первый символ строки.

Синтаксис

string.capitalize()

2. верхняя ()

Верхняя ()Метод использует все буквы строки.

Синтаксис

string.upper()

3. string.title ()

заглавие()Метод использует все первые буквы данной строки.

Синтаксис

string. title()

пример


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

Синтаксис

string.rjust/ljust(length, character)

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

пример


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

Синтаксис

string.strip(character)

персонаж:набор символов для удаления [Необязательный]

Версии

  • rstrip (): удаляет символы справа от строки.
  • lstrip (): удаляет символы слева от строки.

Метод zfill () добавляет нули (0) в начале строки Длина возвращаемой строки зависит от предоставленной ширины.

Синтаксис

string.zfill(width)

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

пример


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

Оригинальная статья

Strings — Learn Python 3


Строку можно считывать со стандартного ввода, используя функцию input() или определяемую в одинарных или двойных кавычках. Две строки могут быть объединены, и мы также можем повторить строку n раз, умножая ее на integer:

None
print('>_< ' * 5)  # &gt; _ &lt;&gt; _ &lt;&gt; _ &lt;&gt; _ &lt;&gt; _ &lt;

Строка в Python представляет собой последовательность символов. Функция len(some_string) возвращает количество символов в строке:

None
print(len('abcdefghijklmnopqrstuvwxyz'))  # 26

Каждый объект в Python может быть преобразован в строку с помощью функции str(some_object) . Поэтому мы можем преобразовать числа в строки:

None
s = str(2 ** 100)
print(s)  # 1267650600228229401496703205376
print(len(s))  # 31

Срез дает из заданной строки один символ или некоторый фрагмент: подстрока или подпоследовательность.

Существует три формы срезов. Простейшая форма среза: один фрагмент символа S[i] дает i й символ строки. Мы будем считать символы, начинающиеся с 0. То есть, если S = 'Hello' , S[0] == 'H' , S[1] == 'e' , S[2] == 'l' , S[3] == 'l' , S[4] == 'o' . Обратите внимание, что в Python для символов строки не существует отдельного типа. S[i] также имеет тип str , как и исходная строка.

Число i в S[i] называется индексом .

Если вы укажете отрицательный индекс, то он подсчитывается с конца, начиная с номера -1 . То есть S[-1] == 'o' , S[-2] == 'l' , S[-3] == 'l' , S[-4] == 'e' , S[-5] == 'H' .

Подведем итог в таблице:

Строка S ЧАС е L L о
Индекс S [0] S [1] S [2] S [3] S [4]
Индекс S [-5] S [-4] S [-3] S [-2] S [-1]

Если индекс в срезе S[i] больше или равен len(S) или меньше, чем -len(S) , следующая ошибка вызывает IndexError: string index out of range .

Slice с двумя параметрами S[a:b] возвращает подстроку длины b - a , начиная с символа в индексе a и продолжая до символа с индексом b , не считая последнего. Например, S[1:4] == 'ell' , и вы можете получить ту же подстроку, используя S[-4:-1] . Вы можете смешивать положительные и отрицательные индексы в одном и том же фрагменте, например, S[1:-1] — это подстрока без первого и последнего символов строки (срез начинается с символа с индексом 1 и заканчивается индексом от -1, не считая его).

Срез с двумя параметрами никогда не вызывает IndexError . Например, для S == 'Hello' срез S[1:5] возвращает строку 'ello' , и результат будет таким же, даже если второй индекс очень большой, например S[1:100] .

Если вы опустите второй параметр (но сохраните двоеточие), то срез идет до конца строки. Например, чтобы удалить первый символ из строки (ее индекс равен 0), возьмите срез S[1:] . Аналогично, если вы опускаете первый параметр, Python берет срез из начала строки. То есть, чтобы удалить последний символ из строки, вы можете использовать срез S[:-1] . Срез S[:] соответствует самой строке S

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

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

Давайте продемонстрируем, что:

None
s = 'Hello'
t = s  # s и t указывают на одну и ту же строку
t = s[2:4]  # теперь t указывает на новую строку &#39;ll&#39;
print(s)  # печатает «Hello», так как s не изменяется
print(t)  # отпечатки &#39;ll&#39;

Если вы укажете срез с тремя параметрами S[a:b:d] , третий параметр указывает шаг, такой же, как для range() функций range() . В этом случае берутся только символы со следующим индексом: a a + d , a + 2 * d и т. Д. До и без символа с индексом b . Если третий параметр равен 2, срез принимает каждый второй символ, и если шаг среза равен -1 , символы идут в обратном порядке. Например, вы можете изменить строку следующим образом: S[::-1] . Давайте посмотрим на примеры:

None
s = 'abcdefg'
print(s[1])
print(s[-1])
print(s[1:3])
print(s[1:-1])
print(s[:3])
print(s[2:])
print(s[:-1])
print(s[::2])
print(s[1::2])
print(s[::-1])
Обратите внимание, как третий параметр среза похож на третий параметр range() функций range() :
None
s = 'abcdefghijklm'
print(s[0:10:2])
for i in range(0, 10, 2):
    print(i, s[i])

Метод — это функция, привязанная к объекту. Когда метод вызывается, метод применяется к объекту и выполняет некоторые вычисления, связанные с ним. Методы вызываются как object_name.method_name(arguments) . Например, в s.find("e") метод string find() применяется к строке s с одним аргументом "e" .

Метод find() выполняет поиск подстроки, переданной как аргумент, внутри строки, на которую он вызывается. Функция возвращает индекс первого вхождения подстроки. Если подстрока не найдена, метод возвращает -1.

None
s = 'Hello'
print(s.find('e'))
# 1
print(s.find('ll'))
# 2
print(s.find('L'))
# -1

Аналогично, метод rfind() возвращает индекс последнего вхождения подстроки.

None
s = 'abracadabra'
print(s.find('b'))
# 1
print(s.rfind('b'))
# 8

Если вы вызываете find() с тремя аргументами s.find(substring, left, right) , поиск выполняется внутри среза s[left:right] . Если вы укажете только два аргумента, например s.find(substring, left) , поиск выполняется в срезе s[left:] , то есть начиная с символа с индексом left до конца строки. Метод s.find(substring, left, right) возвращает абсолютный индекс относительно всей строки s , а не срез.

None
s = 'my name is bond, james bond, okay?'
print(s.find('bond'))
# 11
print(s.find('bond', 12))
# 23

Метод replace() заменяет все вхождения данной подстроки на другую. Синтаксис: s.replace(old, new) принимает строку S и заменяет все вхождения подстроки old на подстроку new . Пример:

None
print('a bar is a bar, essentially'.replace('bar', 'pub'))
# «Паб - это паб, по сути,

Можно пройти третий count аргумента, например: s.replace(old, new, count) . Это делает replace() , чтобы заменить только первый count вхождений , а затем остановится.

None
print('a bar is a bar, essentially'.replace('bar', 'pub', 1))
# «Паб - это бар,

Этот метод подсчитывает количество вхождений одной строки в другую строку. Простейшая форма: s.count(substring) . Учитываются только неперекрывающиеся вхождения:

None
print('Abracadabra'.count('a'))
# 4
print(('aaaaaaaaaa').count('aa'))
# 5

Если вы укажете три параметра s.count(substring, left, right) , подсчет выполняется внутри среза s[left:right] .

Строки. Функции и методы строк — Питошка

S = ‘str’; S = «str»; S = »’str»’; S = «»»str»»» Литералы строк
S = «s\np\ta\nbbb» Экранированные последовательности
S = r»C:\temp\new» Неформатированные строки (подавляют экранирование)
S = b»byte» Строка байтов
S1 + S2 Конкатенация (сложение строк)
S1 * 3 Повторение строки
S[i] Обращение по индексу
S[i:j:step] Извлечение среза
len(S) Длина строки
S. find(str, [start],[end]) Поиск подстроки в строке. Возвращает номер первого вхождения или -1
S.rfind(str, [start],[end]) Поиск подстроки в строке. Возвращает номер последнего вхождения или -1
S.index(str, [start],[end]) Поиск подстроки в строке. Возвращает номер первого вхождения или вызывает ValueError
S.rindex(str, [start],[end]) Поиск подстроки в строке. Возвращает номер последнего вхождения или вызывает ValueError
S.replace(шаблон, замена) Замена шаблона
S.split(символ) Разбиение строки по разделителю
S.isdigit() Состоит ли строка из цифр
S.isalpha() Состоит ли строка из букв
S.isalnum() Состоит ли строка из цифр или букв
S.islower() Состоит ли строка из символов в нижнем регистре
S. isupper() Состоит ли строка из символов в верхнем регистре
S.isspace() Состоит ли строка из неотображаемых символов (пробел, символ перевода страницы (‘\f’), «новая строка» (‘\n’), «перевод каретки» (‘\r’), «горизонтальная табуляция» (‘\t’) и «вертикальная табуляция» (‘\v’))
S.istitle() Начинаются ли слова в строке с заглавной буквы
S.upper() Преобразование строки к верхнему регистру
S.lower() Преобразование строки к нижнему регистру
S.startswith(str) Начинается ли строка S с шаблона str
S.endswith(str) Заканчивается ли строка S шаблоном str
S.join(список) Сборка строки из списка с разделителем S
ord(символ) Символ в его код ASCII
chr(число) Код ASCII в символ
S. capitalize() Переводит первый символ строки в верхний регистр, а все остальные в нижний
S.center(width, [fill]) Возвращает отцентрованную строку, по краям которой стоит символ fill (пробел по умолчанию)
S.count(str, [start],[end]) Возвращает количество непересекающихся вхождений подстроки в диапазоне [начало, конец] (0 и длина строки по умолчанию)
S.expandtabs([tabsize]) Возвращает копию строки, в которой все символы табуляции заменяются одним или несколькими пробелами, в зависимости от текущего столбца. Если TabSize не указан, размер табуляции полагается равным 8 пробелам
S.lstrip([chars]) Удаление пробельных символов в начале строки
S.rstrip([chars]) Удаление пробельных символов в конце строки
S.strip([chars]) Удаление пробельных символов в начале и в конце строки
S. partition(шаблон) Возвращает кортеж, содержащий часть перед первым шаблоном, сам шаблон, и часть после шаблона. Если шаблон не найден, возвращается кортеж, содержащий саму строку, а затем две пустых строки
S.rpartition(sep) Возвращает кортеж, содержащий часть перед последним шаблоном, сам шаблон, и часть после шаблона. Если шаблон не найден, возвращается кортеж, содержащий две пустых строки, а затем саму строку
S.swapcase() Переводит символы нижнего регистра в верхний, а верхнего – в нижний
S.title() Первую букву каждого слова переводит в верхний регистр, а все остальные в нижний
S.zfill(width) Делает длину строки не меньшей width, по необходимости заполняя первые символы нулями
S.ljust(width, fillchar=» «) Делает длину строки не меньшей width, по необходимости заполняя последние символы символом fillchar
S. rjust(width, fillchar=» «) Делает длину строки не меньшей width, по необходимости заполняя первые символы символом fillchar
S.format(*args, **kwargs) Форматирование строки

10 классных функций Python 3.9

Перевод подготовлен совместно с факультетом Python-разработки GeekBrains. Автор оригинального текста Farhad Malik.

***

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

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

***

Было добавлено несколько новых функций, включая объединение и обновление словарей, строковые методы и внедрение модуля zoneinfo. Также нам представили стабильный и высокопроизводительный парсер.

Давайте разбираться с нововведениями.

1. Операторы обновления и слияния словарей

Во встроенный класс dict добавлено два оператора: | и |=.

| используется для объединения словарей, |= – для их обновления.

PEP 584

Код:

Объединение: |

        >>> a = {‘farhad’: 1, 'blog’: 2, 'python’: 3}

>>> b = {’farhad’: 'malik’, 'topic’: 'python3.9’}

>>> a | b

{’blog’: 2, 'python’: 3, ’farhad’:’malik’, 'topic’: 'python3.9’}

>>> b | a

{’farhad’: 1,’blog’: 2, 'python’: 3, 'topic’:’python3.9’ }
    

Обновление: |=

        >>> a |= b

>>> a

{’blog’: 2, 'python’: 3,’farhad’:’malik’}
    

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

Более детально

Как мы видим, добавлены новые операторы | и |=.

| можно рассматривать как оператор + (сложения) в списках, а |= – как оператор += (расширения).

В Python 3.8 есть несколько способов слияния и обновления словарей.

К примеру, можно использовать first_dict.update(second_dict). Проблема этого метода в том, что он изменит first_dict на месте. Чтобы этого избежать, нужно объявить временную переменную, сохранить в ней first_dict, а затем выполнить операцию обновления. Но появляется лишняя строка кода, просто чтобы оператор объединения/обновления работал.

Также мы можем применить {**first_dict, **second_dict}. Сложность этого метода в том, что его трудно обнаружить и сложнее понять смысл кода. Кроме того, исключаются типы mapping и учитывается только тип dict. Например, если first_dict – это defaultdict, а second_dict – это тип dict, то программа завершится ошибкой.

Этот способ не работает с подклассами dict, которые содержат функцию _init_.

Наконец, библиотека collections содержит функцию ChainMap. Она может принять два словаря, как ChainMap(first_dict, second_dict), и вернуть объединенный словарь, но об этой библиотеке знают немногие.

***

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

https://www.python.org/dev/peps/pep-0584

2. Новый высокопроизводительный парсер на основе PEG

С Python 3.9 можно отказаться от использования LL (1) в пользу более гибкого и стабильного синтаксического анализатора на основе PEG.

PEP: 617

Более детально

Текущий парсер CPython основан на LL (1). Грамматика основана на LL (1), что позволяет парсить ее с помощью LL (1) анализатора. Парсер LL (1) работает сверху вниз и анализирует входные данные слева направо. Грамматика является контекстно-свободной, поэтому контекст токенов не учитывается.

Python 3.9 предлагает заменить его новым парсером на основе PEG, который снимет ограничения Python грамматики LL (1). Будет удален ряд хаков, существующих в текущем синтаксическом анализаторе. В долгосрочной перспективе это снизит стоимость обслуживания.

Несмотря на то, что синтаксические анализаторы и грамматики LL (1) просты в реализации, ограничения не позволяют им выражать общие конструкции естественным образом для разработчика языка и читателя. Парсер смотрит только на один токен вперед, чтобы различать возможности.

Оператор выбора | упорядоченный. Рассмотрим следующее правило:

rule: A|B|C

Контекстно-свободный парсер грамматики LL (1) будет генерировать конструкции, которые при заданной входной строке определят, нужно ли расширять A, B или C. Анализатор PEG отличается. Он проверит, успешна ли первая переменная, и только в случае провала перейдет ко второй или третьей.

Парсер PEG генерирует ровно одно допустимое дерево для строки. Он определенный, в отличие парсер LL (1).

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

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

***

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

https://www.python.org/dev/peps/pep-0617

3.

Новые строковые функции для удаления префикса и суффикса

К объекту str добавлено две новых функции.

1. Первая удаляет префикс – str.removeprefix(‘префикс’).

2. Вторая удаляет суффикс – str.removesuffix(‘суффикс’).

PEP: 616

Код:

        'farhad_python'.removeprefix('farhad_')

#возвращает python

'farhad_python'. removesuffix('_python')

#возвращает farhad
    

Более детально

Одна из обыденных задач в приложении data science, которое включает в себя манипулирование текстом – удалить префикс/суффикс строк. Добавленные к объекту str функции можно использовать для удаления ненужных префиксов и суффиксов из строки.

Как мы уже знаем, первая функция удаляет префикс. Это str.removeprefix(‘префикс’). Вторая функция удаляет суффикс. Это str.removesuffix(‘суффикс’).

Строка – это набор символов, и каждый символ имеет индекс в строке. Индексы можно использовать вместе с : , чтобы вернуть подмножество строки. Эта функция известна как slice (срез) строки.

Если мы говорим о функциях, они проверяют, начинается ли строка с префикса (заканчивается ли она суффиксом), и если да, то возвращают строку без префикса или после суффикса, используя функцию среза str[:].

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

***

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

https://www. python.org/dev/peps/pep-0616

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

Аннотирование программ стало проще за счет удаления иерархии параллельных типов в Python.

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

Мы можем использовать встроенные типы коллекций list или dict в качестве универсальных типов вместо использования typing.List или typing.Dict в сигнатуре нашей функции.

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

PEP: 585

Более детально

Несмотря на то, что Python – это язык с динамической типизацией, аннотация типов в программе позволяет проводить самоанализ. Впоследствии аннотацию можно использовать для создания API проверки типов во время выполнения.

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

Универсальный тип – это обычно контейнер, к примеру list. Это тип, который можно параметризовать. Параметризованный тип – это пример универсального дженерика с ожидаемыми типами для элементов контейнера типа list[str].

Мы можем использовать встроенные типы коллекций list или dict в качестве универсальных типов вместо использования typing.List или typing.Dict.

Например, мы могли бы управлять проверкой типов среды выполнения Python, аннотируя код:

        print_value(input: str):

print(input)

# Мы получим уведомление, если входные данные не являются строкой
    

Ряд функций статической типизации был постепенно построен поверх существующей среды выполнения Python. Некоторые из них были ограничены существующим синтаксисом и поведением во время выполнения. Поэтому в модуле типизации возникла дублированная иерархия коллекций из-за дженериков.

Например, мы увидим typing.List, typing.Dictionary вместе со встроенными list, dictionary и т. д. Это позволяет писать код:

        def read_blog_tags(tags: list[str]) -> None:

for tag in tags:

print("Tag Name", tag)
    

***

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

https://www. python.org/dev/peps/pep-0585

5. Поддержка часового пояса IANA в DateTime

Модуль zoneinfo был создан в качестве поддержки базы данных часовых поясов IANA. Эта поддержка была добавлена в стандартную библиотеку.

PEP: 615

Часовые пояса IANA часто называют tz или zone info. Существует много часовых поясов IANA с разными путями поиска для указания часового пояса IANA объекта datetime. Например, мы можем передать имя пути поиска объекту datetime как Continent/City, чтобы установить его tzinfo.

dt = datetime(2000, 01, 25, 01, tzinfo=ZoneInfo("Europe/London"))

Если мы передадим неверный ключ, возникнет ошибка zoneinfo. ZoneInfoNotFoundError.

Более детально

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

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

Можно создать объект zoneinfo.ZoneInfo(key), где ключ имеет строковый тип, указывающий путь поиска файла зоны в базе данных часовых поясов системы. Объект zoneinfo.ZoneInfo(key) может быть создан и установлен как свойство tzinfo объекта datetime.

Код:

        from zoneinfo import ZoneInfo

from datetime import datetime

dt = datetime(2000, 01, 25, 01, tzinfo=ZoneInfo("America/Los_Angeles"))
    

***

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

https://www.python.org/dev/peps/pep-0615

6. Возможность отмены одновременных фьючерсов.

В concurrent. futures.Executor.shutdown() добавлен новый параметр cancel_futures.

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

До версии 3.9 процесс ожидал их завершения перед завершением работы исполнителя.

Пояснение

Новый параметр cancel_futures был добавлен в ThreadPoolExecutor и ProcessPoolExecutor. Это работает так: если его значение – True, все ожидающие фьючерсы отменяются при вызове функции shutdown().

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

Когда не остается незавершенных рабочих элементов, он завершает работу.

***

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

https://bugs.python.org/issue30966

7. Улучшения AsyncIO и многопроцессорности

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

Например:

1. Параметр reuse_address asyncio.loop.create_datagram_endpoint() больше не поддерживается из-за серьезных пробелов в безопасности.

2. Добавлены новые сопрограммы: shutdown_default_executor() и asyncio.to_thread(). shutdown_default_executor назначает завершение работы для исполнителя по умолчанию, который ждет завершения ThreadPoolExecutor. asyncio.to_thread() в основном используется для запуска функций, связанных с вводом-выводом, в отдельном потоке, чтобы избежать блокировки цикла событий.

Что касается улучшений библиотеки многопроцессорности, в класс multiprocessing. SimpleQueue был добавлен новый метод close().

Этот метод точно закрывает очередь. Это гарантирует, что очередь будет закрыта и не останется дольше ожидаемого. Помните, что методы get(), put(), empty() не должны вызываться после закрытия очереди.

***

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

https://bugs.python.org/issue30966

8. Постоянные ошибки импорта пакетов

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

Встроенная функция __import__() вызывает ошибку ValueError, а importlib.__import__() вызывает ошибку ImportError.

Теперь это исправили. __import__() вызывает ImportError вместо ValueError.

***

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

https://bugs.python.org/issue37444

9. Генерация случайных байтов

Еще одна функция, добавленная в версии 3. 9 – random.Random.randbytes(). Эта функция может использоваться для генерации случайных байтов.

Можно генерировать случайные числа, но что, если нужно генерировать случайные байты? Раньше разработчикам приходилось для этого проявлять изобретательность. Хотя можно использовать os.getrandom(), os.urandom() или secrets.token_bytes(), но нельзя генерировать псевдослучайные паттерны.

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

В результате был введен метод random.Random.randbytes(). Он также может генерировать случайные байты контролируемым способом.

***

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

https://bugs.python.org/issue40286

10. Исправление функции замены строки

Раньше "".replace("", s, n) возвращал пустую строку вместо s для всех ненулевых n.

Этот баг сбивал с толку пользователей и приводил к нестабильному поведению приложений.

В Python 3.9 проблема была устранена, и теперь функция замены совместима с "".replace("", s).

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

string.replace(s, old, new[, maxreplace])

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

До этого функция replace имела непоследовательное поведение

        "". replace("", "blog", 1)

Возвращает ''

Ожидалось увидеть blog

"".replace("", "|", 1)

Возвращает ''

Ожидалось увидеть |

"".replace("", "prefix")

Но возвращает 'prefix'
    

Теперь:

        "".replace("",s,n) возвращает s вместо пустой строки для всех ненулевых n
    

В Python 3.9 также был исключен ряд избыточных функций, таких как Py_UNICODE_MATCH.

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

***

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

NumPy — Строковые функции — CoderLessons.com

Следующие функции используются для выполнения векторизованных строковых операций для массивов dtype numpy.string_ или numpy.unicode_. Они основаны на стандартных строковых функциях встроенной библиотеки Python.

Sr.No. Описание функции
1 добавлять()

Возвращает поэлементную конкатенацию строк для двух массивов str или Unicode

2 многократно ()

Возвращает строку с множественной конкатенацией, поэлементно

3 центр()

Возвращает копию данной строки с элементами по центру в строке указанной длины

4 прописные буквы ()

Возвращает копию строки только с первым заглавным символом

5 заглавие()

Возвращает поэлементную заглавную версию строки или Unicode.

6 ниже ()

Возвращает массив с элементами, преобразованными в нижний регистр

7 Верхняя ()

Возвращает массив с элементами, преобразованными в верхний регистр

8 Трещина()

Возвращает список слов в строке, используя разделитель

9 splitlines ()

Возвращает список строк в элементе, ломающихся на границах строк

10 полоса ()

Возвращает копию с удаленными начальными и последними символами

11 присоединиться()

Возвращает строку, которая является объединением строк в последовательности

12 заменить ()

Возвращает копию строки со всеми вхождениями подстроки, замененной новой строкой

13 декодировать ()

Вызывает str.decode поэлементно

14 кодировать ()

Вызывает str. encode поэлементно

Возвращает поэлементную конкатенацию строк для двух массивов str или Unicode

Возвращает строку с множественной конкатенацией, поэлементно

Возвращает копию данной строки с элементами по центру в строке указанной длины

Возвращает копию строки только с первым заглавным символом

Возвращает поэлементную заглавную версию строки или Unicode.

Возвращает массив с элементами, преобразованными в нижний регистр

Возвращает массив с элементами, преобразованными в верхний регистр

Возвращает список слов в строке, используя разделитель

Возвращает список строк в элементе, ломающихся на границах строк

Возвращает копию с удаленными начальными и последними символами

Возвращает строку, которая является объединением строк в последовательности

Возвращает копию строки со всеми вхождениями подстроки, замененной новой строкой

Вызывает str.decode поэлементно

Вызывает str. encode поэлементно

Эти функции определены в классе символьных массивов (numpy.char). Более старый пакет Numarray содержал класс chararray. Вышеуказанные функции в классе numpy.char полезны при выполнении векторизованных строковых операций.

3.6.1 Строковые методы

3.6.1 Строковые методы


3.6.1 Строковые методы

Это строковые методы, которые используют как 8-битные строки, так и Unicode. поддержка объектов:

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

Для 8-битных строк этот метод зависит от языкового стандарта.

центр ( ширина [, fillchar ] )
Возврат по центру строки длиной шириной .Заполнение сделано с использованием указанного fillchar (по умолчанию — пробел). Изменено в версии 2.4: Поддержка аргумента fillchar .
количество ( sub [, начало [, конец ] ] )
Вернуть количество вхождений подстроки sub в строку S [ начало : конец ] . Необязательные аргументы запускают и конец интерпретируются как в нотации среза.
декодировать ( [ кодировка [, ошибки ] ] )
Декодирует строку, используя кодек, зарегистрированный для кодирования . Кодировка по умолчанию используется строковая кодировка по умолчанию. ошибки может быть задан для установки другой схемы обработки ошибок. По умолчанию "строгий" , что означает, что ошибки кодирования вызывают UnicodeError. Другие возможные значения: 'игнорировать' , "заменяет" и любое другое имя, зарегистрированное через кодеки.register_error, см. раздел 4.8.1. Новое в версии 2.2. Изменено в версии 2.3: Добавлена ​​поддержка других схем обработки ошибок.
кодировать ( [ кодировка [, ошибки ] ] )
Вернуть закодированную версию строки. Кодировка по умолчанию — текущая кодировка строки по умолчанию. ошибки могут быть заданы для установки другого схема обработки ошибок. По умолчанию для ошибок "строгий" , что означает, что ошибки кодирования вызывают UnicodeError.Другие возможные значения: 'игнорировать' , 'заменить' , 'xmlcharrefreplace' , 'заменить косую черту' и любое другое имя, зарегистрированное через codecs. register_error, см. раздел 4.8.1. Список возможных кодировок см. В разделе 4.8.3. Новое в версии 2.0. Изменено в версии 2.3: Поддержка 'xmlcharrefreplace' и Добавлена ​​обратная косая черта, и другие схемы обработки ошибок.
заканчивается с ( суффикс [, начало [, конец ] ] )
Вернуть Истина , если строка заканчивается указанным суффиксом , в противном случае верните False . суффикс также может быть кортежем суффиксы, которые нужно искать. С опциональным start , испытание начинается с эта позиция. С опциональным и концом прекратите сравнение в этой позиции.

Изменено в версии 2.5: Принимать кортежи как суффикс .

Вернуть копию строки, в которой раскрыты все символы табуляции используя пробелы. Если размер табуляции не указан, размер табуляции 8 предполагается наличие символов.
найти ( sub [, начало [, конец ] ] )
Вернуть самый низкий индекс в строке, где подстрока sub — найдено, так что sub содержится в диапазоне [ start , конец ].Необязательные аргументы начало и конец являются интерпретируется как в нотации среза. Вернуть -1 , если sub не найден.
индекс ( sub [, начало [, конец ] ] )
Подобно find (), но вызывает ValueError, когда подстрока не найдена.
Вернуть истину, если все символы в строке буквенно-цифровые и есть хотя бы один символ, иначе false.

Для 8-битных строк этот метод зависит от языкового стандарта.

Вернуть истину, если все символы в строке буквенные и есть хотя бы один символ, иначе false.

Для 8-битных строк этот метод зависит от языкового стандарта.

Вернуть истину, если все символы в строке являются цифрами и есть хотя бы один символ, иначе false.

Для 8-битных строк этот метод зависит от языкового стандарта.

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

Для 8-битных строк этот метод зависит от языкового стандарта.

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

Для 8-битных строк этот метод зависит от языкового стандарта.

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

Для 8-битных строк этот метод зависит от языкового стандарта.

Вернуть истину, если все символы в строке в верхнем регистре и есть хотя бы один символ в регистре, иначе false.

Для 8-битных строк этот метод зависит от языкового стандарта.

Вернуть строку, которая является объединением строк в последовательность последовательность . Разделителем между элементами служит строка предоставляя этот метод.
ljust ( ширина [, fillchar ] )
Вернуть строку, выровненную по левому краю, в строке длиной и шириной . Заполнение выполняется с использованием указанного fillchar (по умолчанию Космос). Исходная строка возвращается, если ширина меньше лен ( с ) . Изменено в версии 2. 4: Поддержка аргумента fillchar .
Вернуть копию строки, преобразованную в нижний регистр.

Для 8-битных строк этот метод зависит от языкового стандарта.

Вернуть копию строки с удаленными ведущими символами. В символов аргумент — строка, определяющая набор символов быть удаленным. Если опущено или Нет , символов аргумент по умолчанию удаляются пробелы. Аргумент символов не является префикс; скорее, все комбинации его значений удаляются:
    >>> 'просторный'.lstrip ()
    'просторный'
    >>> 'www.example.com'.lstrip (' cmowz. ')
    example.com
 
Изменено в версии 2.2.2: Поддержка аргумента символов .
Разделите строку при первом появлении sep и верните 3-кортеж, содержащий часть перед разделителем, разделитель сама и часть после разделителя. Если разделитель не найдено, вернуть 3-кортеж, содержащий саму строку, за которой следует две пустые строки. Новое в версии 2.5.
заменить ( старый, новый [, кол-во ] )
Вернуть копию строки со всеми вхождениями подстроки старый заменен на новый . Если необязательный аргумент отсчет дан, только первые отсчет вхождения заменены.
).
rfind ( sub [, начало [, конец ] ] )
Возвращает наивысший индекс в строке, где подстрока sub — найдено, так что sub содержится в s [начало, конец].Необязательный аргументы начало и конец интерпретируются как в срезе обозначение. Вернуть -1 в случае неудачи.
rindex ( sub [, начало [, конец ] ] )
Подобно rfind (), но вызывает ValueError, когда подстрока подстрока не найдена.
rjust ( ширина [, fillchar ] )
Вернуть строку, выровненную по правому краю, в строке длиной и шириной .Заполнение выполняется с использованием указанного fillchar (по умолчанию — пробел). Исходная строка возвращается, если ширина меньше лен ( с ) . Изменено в версии 2.4: Поддержка аргумента fillchar .
Разделить строку на последнее вхождение sep и вернуть 3-кортеж, содержащий часть перед разделителем, разделитель сама и часть после разделителя. Если разделитель не найдено, вернуть 3-кортеж, содержащий две пустые строки, за которыми следует сама струна.Новое в версии 2.5.
rsplit ( [ сен [, maxsplit ] ] )
Вернуть список слов в строке, используя sep в качестве строка-разделитель. Если указано maxsplit , максимум maxsplit деления сделаны, крайних правых . Если сен не указан или Нет , любая строка с пробелами является разделителем.За исключением разделения справа rsplit () ведет себя как split (), который подробно описывается ниже. Новое в версии 2.4.
Вернуть копию строки с удаленными завершающими символами. В символов аргумент — строка, определяющая набор символов быть удаленным. Если опущено или Нет , символов аргумент по умолчанию удаляются пробелы. Аргумент символов не является суффикс; скорее, все комбинации его значений удаляются:
    >>> 'просторный'.rstrip ()
    'просторный'
    >>> 'миссисипи'.rstrip (' ipz ')
    'миссис'
 
Изменено в версии 2.2.2: Поддержка аргумента символов .
раздельный ( [ сен [, maxsplit ] ] )
Вернуть список слов в строке, используя sep в качестве строка-разделитель. Если указано maxsplit , максимум maxsplit деления сделаны.(таким образом, в списке будет не более maxsplit +1 элементы). Если maxsplit не указан, то там нет ограничения на количество разбиений (делаются все возможные разбиения). Последовательные разделители не группируются вместе и считается ограничивающим пустые строки (например, «‘1„ 2’.split (‘, ‘) «возвращает» [‘ 1 ‘,’ ‘,’ 2 ‘] «). Аргумент sep может состоять из несколько символов (например, «’1, 2, 3′.split (‘, ‘)» возвращает «[‘1’, ‘2’, ‘3’]»). Разделение пустой строки указанным разделитель возвращает «[»]».

Если sep не указан или None , другое разделение алгоритм применяется. Во-первых, пробельные символы (пробелы, табуляции, новые строки, возвраты и переводы форм) удаляются с обоих концов. Потом, слова разделяются строками пробелов произвольной длины символы. Последовательные разделители пробелов обрабатываются как один delimiter («‘1 2 3’. split ()» возвращает «[‘ 1 ‘,’ 2 ‘,’ 3 ‘]»). Разделение пустой строки или строки, состоящей только из пробелов возвращает пустой список.

Вернуть список строк в строке с разрывом в строке границы. Разрывы строк не включаются в результирующий список, если только keepends дано и верно.
начинается с ( префикс [, начало [, конец ] ] )
Вернуть Истина , если строка начинается с префикса , в противном случае return Ложь .Префикс также может быть кортежем префиксы, которые нужно искать. При необязательном start , тестовая строка начинается с эта позиция. С необязательным end прекратите сравнение строки на этом позиция.

Изменено в версии 2. 5: Принимать кортежи как префикс .

Вернуть копию строки с начальными и конечными символами удалено. Аргумент символов — это строка, определяющая набор удаляемые символы.Если опущено или Нет , символа по умолчанию аргумент удаляет пробелы. Аргумент символов не является префикс или суффикс; скорее, все комбинации его значений удаляются:
    >>> 'просторный' .strip ()
    'просторный'
    >>> 'www.example.com'.strip (' cmowz. ')
    'пример'
 
Изменено в версии 2.2.2: Поддержка аргумента символов .
Вернуть копию строки с символами верхнего регистра, преобразованными в строчные буквы и наоборот.

Для 8-битных строк этот метод зависит от языкового стандарта.

Возвращает версию строки с заглавными буквами: слова начинаются с верхнего регистра символы, все остальные символы в регистре — строчные.

Для 8-битных строк этот метод зависит от языкового стандарта.

перевести ( таблица [, символы удаления ] )
Вернуть копию строки, в которой все символы, встречающиеся в необязательный аргумент , удаляемые символы удаляются, а оставшиеся символы были отображены через данную таблицу перевода, которая должна быть строкой длиной 256.

Вы можете использовать вспомогательную функцию maketrans () в строковый модуль для создания таблицы перевода.

Для объектов Unicode метод translate () не принять необязательный аргумент deletechars . Вместо этого возвращает копию s , где все символы были сопоставлены через данную таблицу трансляции, которая должна быть отображением Порядковые номера Unicode в порядковые номера Unicode, строки Unicode или Нет . Неотмеченные символы остаются нетронутыми. Символы сопоставлены с Нет удалены. Обратите внимание, что более гибкий подход — создать собственный кодек отображения символов с использованием модуля кодеков (см. encodings.cp1251 для примера).

Вернуть копию строки, преобразованную в верхний регистр.

Для 8-битных строк этот метод зависит от языкового стандарта.

Вернуть числовую строку, заполненную слева нулями в строке длины ширины . Исходная строка возвращается, если ширина меньше лен ( с ) .Новое в версии 2.2.2.

Release 2.5.4, документация обновлена ​​23 декабря 2008 г.
См. Об этом документе … для получения информации о предложениях изменений.

строковых функций в Python 3

Введение

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

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

Изготовление струн в верхнем и нижнем регистре

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

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

  ss = "Сэмми Шарк"
печать (ss.upper ())
  
  

Выход

SAMMY SHARK

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

  печать (ss.lower ())
  
  

Ouput

Sammy Shark

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

Логические методы

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

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

Метод Истинно , если
str.isalnum () Строка состоит только из буквенно-цифровых символов (без символов)
str. isalpha () Строка состоит только из буквенных символов (без символов)
ул. Ниже () Все буквенные символы строки — строчные.
ул.isnumeric () Строка состоит только из цифровых символов
ул. Пространство () Строка состоит только из пробелов
стр. Название () Строка в заглавном регистре
стр. Верхняя () Все буквенные символы строки — прописные.

Давайте посмотрим на некоторые из них в действии:

  число = "5"
письма = "abcdef"

печать (число.isnumeric ())
печать (letter.isnumeric ())
  
  

Выход

True Ложь

Использование метода str.isnumeric () в строке 5 возвращает значение True , а использование того же метода в строке abcdef возвращает значение False .

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

  movie = "2001: САМАЯ ОДИССЕЯ"
book = "Тысяча великолепных акул"
poem = "Сэмми жил в красивом городке"
  

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

  печать (фильм.islower ())
печать (movie.isupper ())
  
  печать (book.istitle ())
печать (book.isupper ())
  
  принт (название стихотворения ())
печать (poem.islower ())
  

Теперь мы можем запустить эти небольшие программы и увидеть результат:

  

Вывод строки фильма

Ложь Истинный
  

Вывод книжной строки

True Ложь
  

Вывод строки стихотворения

Ложь Истинный

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

Логические строковые методы полезны, когда мы хотим проверить, соответствует ли что-то, что вводит пользователь, заданным параметрам.

Определение длины строки

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

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

  open_source = "Сэмми участвует в разработке открытого исходного кода."
печать (len (open_source))
  
  

Выход

33

Мы устанавливаем переменную open_source равной строке «Сэмми способствует открытому исходному коду». , а затем мы передали эту переменную в функцию len () с len (open_source) . Затем мы передали этот метод в метод print () , чтобы мы могли видеть вывод на экране нашей программы.

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

Методы join (), split () и replace ()

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

Метод str.join () объединяет две строки, но таким образом, что одна строка проходит через другую.

Создадим строку:

  Balloon = "У Сэмми воздушный шарик."
  

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

  "" .join (баллон)
  

Если это распечатать:

  печать ("" .join (баллон))
  

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

  

Ouput

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

Мы также можем использовать метод str.join () для возврата строки, которая является разворотом исходной строки:

  печать ("".присоединиться (перевернутый (воздушный шар)))
  
  

Ouput

.noollab a sah ymmaS

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

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

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

  print (",". Join (["акулы", "ракообразные", "планктон"]))
  
  

Выход

акулы, ракообразные, планктон

Если мы хотим добавить запятую и пробел между строковыми значениями в нашей новой строке, мы можем просто переписать наше выражение с пробелом после запятой: ",".присоединиться ([«акулы», «ракообразные», «планктон»]) .

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

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

Ouput

['Сэмми', 'имеет', 'а', 'баллон.']

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

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

.
  печать (Balloon.split ("a"))
  
  

Ouput

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

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

Метод str.replace () может принимать исходную строку и возвращать обновленную строку с некоторой заменой.

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

  печать (Balloon.replace ("имеет", "имел"))
  

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

  

Выход

У Сэмми был воздушный шар.

Использование строковых методов str.join () , str.split () и str.replace () предоставит вам больше возможностей для управления строками в Python.

Заключение

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

Вы можете узнать больше о других типах данных в разделе «Общие сведения о типах данных», узнать больше о строках в разделе «Введение в работу со строками» и узнать об изменении внешнего вида строк в разделе «Как форматировать текст в Python 3.

Python 3-х строковые методы

Метод Описание Примеры
увеличить ()

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

Используйте title () , если вы хотите, чтобы первый символ всех слов был заглавным (т. Е. Регистр заголовка).

a = «пчелиный укус» печать (a.capitalize ())

Результат

  Укус пчелы  
кожух () Возвращает копию строки в развернутом виде. Строки с регистром могут использоваться для сопоставления без регистра. a = «BEE» print (a.casefold ())

Результат

  пчела  
центр ( ширина [, fillchar ]) Возвращает строку с центром в строке длиной шириной . Заполнение может быть выполнено с использованием указанного fillchar (заполнение по умолчанию использует пространство ASCII). Исходная строка возвращается, если ширина меньше или равна лен (ов) а = «пчела» b = a.center (12, «-«) print (b)

Результат

  ---- пчела -----  
count ( sub [, start [, end ]])

Возвращает количество неперекрывающихся вхождений подстроки ( sub ) в диапазоне [ начало , конец ].Необязательные аргументы начало и конец интерпретируются как в нотации среза.

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

a = «Шашлычный суп» print (a.count («O»)) print (a.count («o»)) print (a.count («oo»)) печать (a.count («ооо»)) print (a.count («Гомер»)) print (a.count («o», 4, 7)) print (a.count («o», 7))

Результат

  0
5
2
1
0
2
3  
кодировать (encoding = "utf-8", errors = "strict")

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

  • strict (ошибки кодирования вызывают UnicodeError )
  • игнорировать
  • заменить
  • xmlcharrefreplace
  • обратная косая черта заменить
  • любое другое имя, зарегистрированное с помощью codecs. register_error ()
из base64 импортировать b64encode a = «Банан» печать (а) a = b64encode (a.кодировать ()) print (a)

Результат

  Банан
b'QmFuYW5h ' 
заканчивается на ( суффикс [, начало [, конец ]])

Возвращает True , если строка заканчивается указанным суффиксом, в противном случае возвращает False . суффикс также может быть кортежем суффиксов. Если указан (необязательный) аргумент start , тест начинается с этой позиции.С опциональным и концом тест прекращает сравнение в этой позиции.

a = «Банан» print (a.endswith («a»)) print (a.endswith («нана»)) print (a.endswith («z»)) print (a.endswith («an», 1, 3))

Результат

  Верно
Истинный
Ложь
Правда  
expandtabs (tabsize = 8)

Возвращает копию строки, в которой все символы табуляции заменены одним или несколькими пробелами, в зависимости от текущего столбца и заданного размера табуляции.Позиции табуляции встречаются для каждого символа табуляции (по умолчанию 8 , что дает позиции табуляции в столбцах 0, 8, 16 и так далее).

а = «1 \ t2 \ t3» печать (а) печать (a.expandtabs ()) печать (a.expandtabs (tabsize = 12)) print (a.expandtabs (tabsize = 2))

Результат

  1 2 3
1 2 3
1 2 3
1 2 3  
find ( sub [, start [, end ]])

Возвращает наименьший индекс в строке, где подстрока sub находится в пределах сегмента s [начало: конец] .Необязательные аргументы начало и конец интерпретируются как в нотации среза. Возвращает -1 , если sub не найден.

Метод find () следует использовать только в том случае, если вам нужно знать позицию подстроки. Если вам не нужно знать его позицию (т.е. вам нужно только знать, существует ли подстрока в строке), используйте оператор in . См. Строковые операторы для примера в .

a = «Фитнес» print (a.find («F»)) print (a.find («f»)) print (a.find («n»)) print (a.find («сущность»)) print (a.find («ess»)) print (a.find («z»)) print (a.find («Homer»))

Результат

  0
-1
3
3
4
-1
-1  
формат (* args , ** kwargs )

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

# Пример 1 print («{} и {}».формат («Чай», «Кофе»)) # Пример 2 print («{1} и {0}». format («Чай», «Кофе»)) # Пример 3 print («{обед} и {ужин}». format (обед = «Горошек», ужин = «Фасоль»)) # Пример 4 print («{0}, {1}, {2}». формат (* «123»)) # Пример 5 обед = {«food»: «Пицца», «drink»: «Вино»} print («Обед: {еда}, {напиток}». format (** обед))

Результат

  Чай и кофе
Кофе и чай
Горох и фасоль
1, 2, 3
Обед: пицца, вино  
format_map ( отображение )

Подобен формату (** отображение) , за исключением того, что отображение используется напрямую и не копируется в словарь.Это полезно, если, например, отображение является подклассом dict.

# Пример 1 обед = {«Еда»: «Пицца», «Напиток»: «Вино»} print («Обед: {Еда}, {Напиток}». format_map (Обед)) # Пример 2 класс по умолчанию (dict): def __missing __ (я, ключ): ключ возврата обед = {«Еда»: «Пицца»} print («Обед: {Еда}, {Напиток}». format_map (По умолчанию (обед))) обед = {«Напиток»: «Вино»} print («Обед: {Еда}, {Напиток}». format_map (По умолчанию (обед)))

Результат

  Обед: пицца, вино
Обед: пицца, напитки
Обед: еда, вино  
индекс ( sub [, начало [, конец ]])

Подобно find () (выше), но вызывает ValueError , если подстрока не найдена ( find () возвращает -1 , если подстрока не найдена).

a = «Фитнес» print (a.index («F»)) print (a.index («n»)) print (a.index («сущность»)) print (a.index («ess»)) print (a.index («z»)) #Error

Результат

  0
3
3
4
ValueError: подстрока не найдена  
исальнум ()

Возвращает Истина , если все символы в строке буквенно-цифровые и есть хотя бы один символ.В противном случае возвращает False .

Символ c считается буквенно-цифровым, если одно из следующих значений возвращает True :

  • c.isalpha ()
  • c.isdecimal ()
  • c.isdigit ()
  • c. Числовой ()
c = «Фитнес» печать (c.isalnum ()) c = «123» печать (c.isalnum ()) c = «1,23» печать (c.isalnum ()) c = «$ *% !!!» печать (c.isalnum ()) c = «0,34j» print (c.isalnum ())

Результат

  Верно
Истинный
Ложь
Ложь
Ложь  
исальфа ()

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

Обратите внимание, что «алфавитными» в данном случае являются те символы, которые определены в базе данных символов Unicode как «Letter». Это персонажи, общее свойство категории которых может быть одним из «Lm», «Lt», «Lu», «Ll» или «Lo». Это отличается от свойства «Alphabetic», определенного в стандарте Unicode.

c = «Фитнес» печать (c.isalpha ()) c = «123» печать (c.isalpha ()) c = «$ *% !!!» print (c.isalpha ())

Результат

  Верно
Ложь
Ложь  
десятичное ()

Возвращает Истинно , если все символы в строке являются десятичными и имеется хотя бы один символ.В противном случае возвращает False .

Десятичные символы — это те, которые могут использоваться для формирования чисел с основанием 10. Десятичные символы — это символы из общей категории Unicode «Nd».

Вы можете увидеть разницу между isdigit () и isdecimal () по тому, как они обрабатывают второй пример ( u "\ u00B2" ).

c = «123» печать (c.isdecimal ()) c = u «\ u00B2» печать (c.isdecimal ()) c = «1,23» печать (c.isdecimal ()) c = «u123» печать (c.isdecimal ()) c = «Фитнес» печать (c.isdecimal ()) c = «$ *% !!!» print (c.isdecimal ())

Результат

  Верно
Ложь
Ложь
Ложь
Ложь
Ложь  
isdigit ()

Возвращает Истина , если все символы в строке являются цифрами и имеется хотя бы один символ. В противном случае возвращает False .

Метод isdigit () часто используется при работе с различными символами Юникода, например с надстрочными индексами (например, 2 ).

Цифра — это символ, имеющий значение свойства Numeric_Type = Digit или Numeric_Type = Decimal .

Вы можете увидеть разницу между isdigit () и isdecimal () по тому, как они обрабатывают второй пример ( u "\ u00B2" ).

c = «123» печать (c.isdigit ()) c = u «\ u00B2» печать (c.isdigit ()) c = «1,23» печать (c.isdigit ()) c = «u123» печать (c.isdigit ()) c = «Фитнес» печать (c.isdigit ()) c = «$ *% !!!» print (c.isdigit ())

Результат

  Верно
Истинный
Ложь
Ложь
Ложь
Ложь  
идентификатор ()

Возвращает true, если строка является допустимым идентификатором в соответствии с определением языка, разделом «Идентификаторы» и ключевыми словами из документации Python.

Используйте keyword.iskeyword () для проверки зарезервированных идентификаторов, таких как def , для и class .

а = «123» печать (a.isidentifier ()) a = «_user_123» печать (a.isidentifier ()) a = «_user-123» печать (a.isidentifier ()) a = «Гомер» печать (a.isidentifier ()) a = «для» print (a.isidentifier ())

Результат

  Ложь
Истинный
Ложь
Истинный
Правда  
нижний ()

Возвращает Истина , если все символы в регистре в строке строчные и имеется хотя бы один символ в регистре.В противном случае возвращает False .

Символы в регистре — это символы, общее свойство категории которых является одним из «Lu» (буква, верхний регистр), «Ll» (буква, нижний регистр) или «Lt» (буква, регистр заголовка).

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

а = «» печать (a.islower ()) а = «123» печать (a.islower ()) a = «_user_123» печать (a.islower ()) a = «Гомер» печать (a.islower ()) a = «HOMER» печать (a.islower ()) а = «гомер» печать (a.islower ()) a = «HOMER» a = a.casefold () # Принудительно строчные print (a.islower ())

Результат

  Ложь
Ложь
Истинный
Ложь
Ложь
Истинный
Правда  
является числовым ()

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

Числовые символы включают цифровые символы и все символы, которые имеют свойство числового значения Unicode. Числовые символы — это символы со значением свойства Numeric_Type = Digit , Numeric_Type = Decimal или Numeric_Type = Numeric .

c = «123» печать (c.isnumeric ()) c = u «\ u00B2» печать (c.isnumeric ()) c = «1,23» печать (c.isnumeric ()) c = «u123» печать (c.isnumeric ()) c = «Фитнес» печать (c.isnumeric ()) c = «$ *% !!!» print (c.isnumeric ())

Результат

  Верно
Истинный
Ложь
Ложь
Ложь
Ложь  
для печати ()

Возвращает Истина , если все символы в строке печатаются или строка пуста. В противном случае возвращает False .

Непечатаемые символы — это те символы, которые определены в базе данных символов Unicode как «Другое» или «Разделитель», за исключением пробела ASCII ( 0x20 ), который считается печатаемым.

Печатные символы в этом контексте — это те, которые не должны экранироваться, когда repr () вызывается для строки. Он не имеет отношения к обработке строк, записанных в sys.stdout или sys.stderr .

а = «» печать (a.isprintable ()) а = «» печать (a.isprintable ()) a = u «\ u00B2» печать (a.isprintable ()) a = «Барт» печать (a.isprintable ()) а = «\ т» печать (a.isprintable ()) a = «\ r \ n» печать (a.isprintable ()) a = «Барт \ r» print (a.isprintable ())

Результат

  Верно
Истинный
Истинный
Истинный
Ложь
Ложь
Ложь  
isspace ()

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

Пробельные символы — это те символы, которые определены в базе данных символов Юникода как «Другой» или «Разделитель», а также те, для которых свойство двунаправленности является одним из «WS», «B» или «S».

а = «» печать (a.isspace ()) а = «» печать (a.isspace ()) a = «Барт» печать (a.isspace ()) а = «\ т» печать (a.isspace ()) a = «\ r \ n» печать (a.isspace ()) a = «Барт \ r» print (a.isspace ())

Результат

  Ложь
Истинный
Ложь
Истинный
Истинный
Ложь  
название ()

Возвращает True , если строка является строкой с заглавными буквами и содержит хотя бы один символ (например, символы верхнего регистра могут следовать только за символами без регистра, а символы нижнего регистра — только за символами в регистре).В противном случае возвращает False .

Пробельные символы — это те символы, которые определены в базе данных символов Юникода как «Другой» или «Разделитель», а также те, для которых свойство двунаправленности является одним из «WS», «B» или «S».

а = «» печать (a.istitle ()) а = «» печать (a.istitle ()) а = «т» печать (a.istitle ()) а = «Т» печать (a.istitle ()) a = «Чай» печать (a.istitle ()) a = «Чай и кофе» печать (a.istitle ()) a = «Чай и кофе» печать (a.istitle ()) a = «1. Чай и кофе \ r» print (a.istitle ())

Результат

  Ложь
Ложь
Ложь
Истинный
Истинный
Ложь
Истинный
Правда  
верхний ()

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

Символы в регистре — это символы, общее свойство категории которых является одним из «Lu» (буква, верхний регистр), «Ll» (буква, нижний регистр) или «Lt» (буква, регистр заголовка).

а = «» печать (a.isupper ()) а = «123» печать (a.isupper ()) a = «_USER_123» печать (a.isupper ()) a = «Гомер» печать (a.isupper ()) a = «HOMER» печать (a.isupper ()) а = «гомер» печать (a.isupper ()) a = «HOMER» a = a.casefold () # Принудительно строчные print (a.isupper ())

Результат

  Ложь
Ложь
Истинный
Ложь
Истинный
Ложь
Ложь  
соединение (итерация)

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

а = «-» print (a.join («123»)) a = «.» print (a.join («США»)) a = «.» print (a.join ((«Dr», «Who»)))

Результат

  1-2-3
СОЕДИНЕННЫЕ ШТАТЫ АМЕРИКИ
Доктор Кто  
ljust ( ширина [, fillchar ]) Возвращает строку, выровненную по левому краю, в строке длиной и шириной .Заполнение может быть выполнено с использованием указанного fillchar (заполнение по умолчанию использует пространство ASCII). Исходная строка возвращается, если ширина меньше или равна лен (ов) а = «пчела» b = a.ljust (12, «-«) print (b)

Результат

  пчела ---------  
нижний ()

Возвращает копию строки, в которой все символы в регистре преобразованы в нижний регистр.

casefold () — это более агрессивный метод перевода строки в нижний регистр, и он подходит для сопоставления регистра.

a = «BEE» print (a.lower ())

Результат

  пчела  
lstrip ([ chars ])

Вернуть копию строки с удаленными ведущими символами.Аргумент chars — это строка, определяющая набор символов, которые необходимо удалить. Если опущено или установлено значение None , аргумент chars по умолчанию удаляет пробелы.

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

a = «Пчела» print (a.lstrip (), «!») a = «—— Пчела ——» print (a.lstrip («-«))

Результат

  Пчела!
Пчела -----  
maketrans ( x [, y [, z ]])

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

  • Если есть только один аргумент, это должен быть словарь, отображающий порядковые номера Unicode (целые числа) или символы (строки длиной 1) в порядковые номера Unicode, строки (произвольной длины) или установить значение Нет . После этого символьные ключи будут преобразованы в порядковые.
  • Если есть два аргумента, они должны быть строками одинаковой длины, и в результирующем словаре каждый символ в x будет сопоставлен с символом в той же позиции в y .
  • Если есть третий аргумент, это должна быть строка, символы которой в результате будут сопоставлены с Нет .
frm = «SecrtCod» to = «12345678» trans_table = str.maketrans (frm, to) secret_code = «Секретный код» .translate (trans_table) print (secret_code)

Результат

  123425 6782  
перегородка ( сен )

Разделяет строку при первом появлении sep и возвращает кортеж из трех частей, содержащий часть перед разделителем, сам разделитель и часть после разделителя.Если разделитель не найден, он возвращает 3-кортеж, содержащий саму строку, за которой следуют две пустые строки.

a = «Python-программа» print (a.partition («-«)) print (a.partition («.»))

Результат

  ('Python', '-', 'программа')
('Python-программа', '', '')  
заменить ( старый , новый [, count ])

Возвращает копию строки со всеми вхождениями подстроки старый , замененной на новый .Если указан необязательный аргумент count , заменяются только первые count вхождений. Например, если count равно 3 , заменяются только первые 3 вхождения.

a = «Чайный пакетик. Чайная чашка. Чайные листья.» print (a.replace («Чай», «Кофе»)) print (a.replace («Чай», «Кофе», 2))

Результат

  Пакетик для кофе. Кофейная чашка. Листья кофе.
Пакетик кофе. Кофейная чашка. Чайные листья. 
rfind ( sub [, начало [, конец ]])

Возвращает наивысший индекс в строке, в которой найдена подстрока sub , так что sub содержится в пределах с [начало: конец] . Необязательные аргументы начало и конец интерпретируются как в нотации среза. Этот метод возвращает -1 в случае ошибки.

a = «Да, фитнес» print (a.rfind («Y»)) print (a.rfind («е»)) print (a.rfind («s»)) print (a.rfind («сс»)) print (a.rfind («y»)) print (a.rfind («z»)) print (a.rfind («Homer»))

Результат

  0
8
10
9
-1
-1
-1  
rindex ( sub [, начало [, конец ]])

Подобно rfind () , но вызывает ValueError , если подстрока sub не найдена.

a = «Да, фитнес» print (a.rindex («Y»)) print (a.rindex («e»)) print (a.rindex («s»)) print (a.rindex («сс»)) print (a.rindex («y»)) print (a.rindex («z»)) print (a.rindex («Homer»))

Результат

  0
8
10
9
ValueError: подстрока не найдена
ValueError: подстрока не найдена
ValueError: подстрока не найдена  
rjust ( ширина [, fillchar ]) Возвращает строку, выровненную по правому краю, в строке длиной шириной .Заполнение может быть выполнено с использованием указанного fillchar (заполнение по умолчанию использует пространство ASCII). Исходная строка возвращается, если ширина меньше или равна лен (ов) а = «пчела» b = a.rjust (12, «-«) print (b)

Результат

  --------- пчела  
r раздел ( sep )

Разбивает строку в последнем вхождении sep и возвращает кортеж из трех частей, содержащий часть перед разделителем, сам разделитель и часть после разделителя.Если разделитель не найден, он возвращает 3-кортеж, содержащий саму строку, за которой следуют две пустые строки.

a = «Гомер-Джей-Симпсон» print (a.rpartition («-«)) print (a.rpartition («.»))

Результат

  ('Гомер-Джей', '-', 'Симпсон')
('', '', 'Гомер-Джей-Симпсон')  
rsplit (sep = None, maxsplit = -1)

Возвращает список слов в строке, используя sep в качестве строки-разделителя.Если задано maxsplit , выполняется не более maxsplit разбиений, крайних правых единиц. Если sep не указано или установлено значение None , любая строка с пробелами является разделителем.

За исключением разделения справа, rsplit () ведет себя как split () , описанный ниже.

a = «Гомер Джей Симпсон» печать (a.rsplit ()) a = «Гомер-Джей-Симпсон» печать (a.rsplit (sep = «-«, maxsplit = 1))

Результат

  [«Гомер», «Джей», «Симпсон»]
[«Гомер-Джей», «Симпсон»]  
rstrip ([ символов ])

Вернуть копию строки с удаленными завершающими символами. Аргумент chars — это строка, определяющая набор символов, которые необходимо удалить. Если опущено или установлено значение None , аргумент chars по умолчанию удаляет пробелы.

Обратите внимание, что аргумент chars не является суффиксом — все комбинации его значений удаляются.

a = «Пчела» print (a.rstrip (), «!») a = «—— Пчела ——» print (a.rstrip («-«))

Результат

  Пчела!
----- Пчела  
разделить (sep = None, maxsplit = -1)

Возвращает список слов в строке, используя sep в качестве строки-разделителя.Если задано maxsplit , будет выполнено не более maxsplit разбиений. Если maxsplit не указан или -1 , то количество разделений не ограничено.

Если задано sep , последовательные разделители не группируются вместе и считаются разделителями пустых строк (например, '1`` 2'.split (', ') возвращает [' 1 ',' ', '2'] ).

Аргумент sep может состоять из нескольких символов (например, '1 <> 2 <> 3'.split ('<>') возвращает ['1', '2', '3'] ). Разделение пустой строки указанным разделителем возвращает [''] .

Если sep не указано или установлено значение None , применяется другой алгоритм разделения: последовательности последовательных пробелов рассматриваются как один разделитель, и результат не будет содержать пустых строк в начале или в конце, если строка имеет начальные или конечные пробелы. Следовательно, разделение пустой строки или строки, состоящей только из пробелов, с помощью разделителя None возвращает значение [] .

a = «Гомер Джей Симпсон» печать (a.split ()) a = «Гомер-Джей-Симпсон» print (a.split (sep = «-«, maxsplit = 1)) a = «Гомер, Барт,» print (a.split («,»)) a = «Гомер ,, Барт» print (a.split («,», maxsplit = 1)) a = «Гомер <> Барт <> Мардж» print (a.split («<>«))

Результат

  [«Гомер», «Джей», «Симпсон»]
["Гомер", "Джей-Симпсон"]
['Гомер', '', 'Барт', '']
['Гомер', ', Барт']
[«Гомер», «Барт», «Мардж»]  
Splitlines ([keepends])

Возвращает список строк в строке с разрывом по границам строки.Разрывы строк не включаются в результирующий список, если не указан keepends и его значение составляет True .

Этот метод разбивается на следующие границы строки.

Представительство Описание
\ п Перевод строки
\ r Возврат каретки
\ n \ r Возврат каретки + перевод строки
\ v или \ x0b Таблица строк
\ f или \ x0c Подача формы
\ x1c Разделитель файлов
\ x1d Групповой разделитель
\ x1e Разделитель записей
\ x85 Следующая строка (контрольный код C1)
\ u2028 Разделитель линий
\ u2029 Разделитель абзацев
a = «Чай \ n \ nи кофе \ rчашки \ r \ n» печать (a.splitlines ()) print (a.splitlines (keepends = True))

Результат

  ["Чай", "", "и кофе", "чашки"]
['Чай \ n', '\ n', 'и кофе \ r', 'чашки \ r \ n']  
начинается с ( префикс [, начало [, конец ]])

Возвращает True , если строка начинается с указанного префикса, в противном случае возвращает False .Префикс также может быть кортежем префиксов. Если указан (необязательный) аргумент start , тест начинается с этой позиции. С опциональным и концом тест прекращает сравнение в этой позиции.

a = «Гомер» print (a.startswith («H»)) print (a.startswith («h»)) print (a.startswith («Гомер»)) print (a.startswith («z»)) print (a.startswith («om», 1, 3))

Результат

  Верно
Ложь
Истинный
Ложь
Правда  
полоса ([ chars ])

Возвращает копию строки с удаленными начальными и конечными символами.Аргумент chars — это строка, определяющая набор символов, которые необходимо удалить. Если опущено или установлено значение None , аргумент chars по умолчанию удаляет пробелы.

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

a = «Пчела» print (a.strip (), «!») a = «—— Пчела ——» print (a.strip («-«))

Результат

  Пчела!
Пчела  
свопкейс ()

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

Обратите внимание, что использование swapcase () дважды в строке не всегда возвращает ее к исходному состоянию. В некоторых случаях два разных символа нижнего регистра используют один символ верхнего регистра, поэтому замена регистра может иметь непредвиденный эффект. См. Этот вопрос / ответ о переполнении стека для примеров.

a = «Гомер Симпсон» print (a.swapcase ())

Результат

  ГОМЕР СИМПСОН  
название ()

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

Используйте capitalize () , если вы хотите, чтобы первое слово было заглавным.

a = «чай и кофе» print (a.title ()) a = «ЧАЙ И КОФЕ» print (a.title ())

Результат

  Чай и кофе
Чай и кофе  
перевести ( таблица )

Возвращает копию строки, в которой каждый символ был сопоставлен с данной таблицей перевода.Таблица должна быть объектом, который реализует индексацию через __getitem __ () , обычно это отображение или последовательность.

Вы можете использовать maketrans () для создания карты перевода из символьных отображений в различных форматах.

frm = «SecrtCod» to = «12345678» trans_table = str.maketrans (frm, to) secret_code = «Секретный код» .translate (trans_table) print (secret_code)

Результат

  123425 6782  
верх ()

Возвращает копию строки, в которой все символы в регистре преобразованы в верхний регистр.

а = «пчела» print (a.upper ())

Результат

  ПЧЕЛ  
zfill ( ширина )

Возвращает копию строки, заполненную слева цифрами ASCII 0 , чтобы сделать строку длиной шириной . Префикс ведущего знака ( + / - ) обрабатывается путем вставки отступа после символа знака, а не перед ним.Исходная строка возвращается, если ширина меньше или равна лин (с) .

а = «36» печать (a.zfill (5)) а = «-36» печать (a.zfill (5)) а = «+36» print (a.zfill (5))

Результат

  00036
-0036
+0036  

Строки Python | Python Education | Разработчики Google

Python имеет встроенный строковый класс с именем «str» ​​со множеством удобных функций (есть более старый модуль с именем «string», который вам не следует использовать).Строковые литералы могут быть заключены в двойные или одинарные кавычки, хотя чаще используются одинарные кавычки. Экраны с обратной косой чертой работают обычным образом в литералах с одинарными и двойными кавычками — например, \ n \ ‘\ «. Строковый литерал в двойных кавычках может содержать одинарные кавычки без всякой суеты (например,« Я этого не делал »), а аналогичная строка в одинарных кавычках может содержать двойные кавычки. Строковый литерал может охватывать несколько строк, но есть должен быть обратной косой чертой \ в конце каждой строки, чтобы избежать новой строки. Строковые литералы в тройных кавычках, «» «или » ‘, могут охватывать несколько строк текста.

Строки Python являются «неизменяемыми», что означает, что они не могут быть изменены после создания (строки Java также используют этот неизменный стиль). Поскольку строки не могут быть изменены, мы создаем * новые * строки по мере представления вычисленных значений. Так, например, выражение («привет» + «там») принимает две строки «привет» и «там» и строит новую строку «hellothere».

Доступ к символам в строке можно получить с помощью стандартного синтаксиса [], и, подобно Java и C ++, Python использует индексирование с отсчетом от нуля, поэтому, если s равно ‘hello’ s [1] равно ‘e’.Если индекс выходит за пределы строки, Python выдает ошибку. Стиль Python (в отличие от Perl) заключается в том, чтобы останавливаться, если он не может сказать, что делать, а не просто создавать значение по умолчанию. Удобный синтаксис «среза» (см. Ниже) также позволяет извлекать любую подстроку из строки. Функция len (строка) возвращает длину строки. Синтаксис [] и функция len () действительно работают с любым типом последовательности — строками, списками и т. Д. Python пытается заставить свои операции работать согласованно для разных типов.У новичка в Python: не используйте «len» в качестве имени переменной, чтобы не блокировать функцию len (). Оператор ‘+’ может объединять две строки. Обратите внимание, что в приведенном ниже коде переменные не объявлены заранее — просто назначьте их и приступайте.

  s = 'привет'
  печать s [1] ## i
  распечатать len (s) ## 2
  напечатайте s + 'там' ## привет там
 

В отличие от Java, знак «+» не преобразует автоматически числа или другие типы в строковую форму. Функция str () преобразует значения в строковую форму, чтобы их можно было комбинировать с другими строками.

  пи = 3,14
  ## text = 'Значение пи' + pi ## НЕТ, не работает
  text = 'Значение пи' + str (pi) ## да
 

Для чисел стандартные операторы +, /, * работают обычным образом. Оператора ++ нет, но работают + =, — = и т.д. Если вы хотите целочисленное деление, правильнее всего использовать две косые черты — например, 6 // 5 равно 1 (до python 3000 единичное / делает деление int на целые числа в любом случае, но движение вперед // является предпочтительным способом указать, что вы хотите деление int.)

Оператор print выводит на печать один или несколько элементов Python, за которыми следует новая строка (оставьте запятую в конце элементов, чтобы запретить перевод строки). «Необработанный» строковый литерал имеет префикс ‘r’ и пропускает все символы без специальной обработки обратных косых черт, поэтому r’x \ nx ‘оценивается как строка длины 4’ x \ nx ‘. Префикс ‘u’ позволяет вам писать строковый литерал Unicode (Python имеет множество других функций поддержки Unicode — см. Документы ниже).

  raw = r 'это \ t \ n и это'

  # это \ t \ n и это
  печать в сыром виде

  multi = "" "Это были лучшие времена.Это был худший из времен "" "

  # Это были лучшие времена.
  # Это были худшие времена.
печать мульти
 

Строковые методы

Вот некоторые из наиболее распространенных строковых методов. Метод похож на функцию, но запускается «на» объекте. Если переменная s является строкой, то код s.lower () запускает метод lower () для этого строкового объекта и возвращает результат (эта идея метода, работающего на объекте, является одной из основных идей, составляющих Object Ориентированное программирование, ООП).Вот некоторые из наиболее распространенных строковых методов:

  • s.lower (), s.upper () — возвращает строчную или прописную версию строки
  • s.strip () — возвращает строку с удаленными пробелами в начале и в конце
  • s.isalpha () / s.isdigit () / s.isspace () … — проверяет, все ли строковые символы принадлежат к разным классам символов.
  • s.startswith (‘other’), s.endswith (‘other’) — проверяет, начинается ли строка или заканчивается заданной другой строкой
  • с.find (‘other’) — ищет заданную другую строку (не регулярное выражение) в s и возвращает первый индекс, с которого она начинается, или -1, если не найдено
  • s.replace (‘old’, ‘new’) — возвращает строку, в которой все вхождения ‘old’ были заменены на ‘new’.
  • s.split (‘delim’) — возвращает список подстрок, разделенных заданным разделителем. Разделитель — это не регулярное выражение, это просто текст. ‘aaa, bbb, ccc’.split (‘, ‘) -> [‘ aaa ‘,’ bbb ‘,’ ccc ‘]. Как удобный частный случай s.split () (без аргументов) разбивается на все пробельные символы.
  • s.join (list) — противоположно split (), объединяет элементы в данном списке вместе, используя строку в качестве разделителя. например ‘—‘. join ([‘aaa’, ‘bbb’, ‘ccc’]) -> aaa — bbb — ccc

Поиск в Google по запросу «python str» должен привести вас к официальным строковым методам python.org, в которых перечислены все методы str.

Python не имеет отдельного символьного типа. Вместо этого выражение типа s [8] возвращает строку длиной-1, содержащую символ.С этой строкой-1 операторы ==,

Ломтики струн

Синтаксис «среза» — удобный способ ссылаться на части последовательностей — обычно строки и списки. Срез s [начало: конец] — это элементы, начинающиеся с начала и продолжающиеся до конца, но не включая его. Предположим, у нас есть s = «Hello»

  • s [1: 4] — это ‘ell’ — символы, начинающиеся с индекса 1 и продолжающиеся до индекса 4, но не включая его.
  • s [1:] — это ‘ello’ — исключение значений индекса по умолчанию до начала или конца строки
  • s [:] — это ‘Hello’ — исключение обоих всегда дает нам копию целого (это питонический способ скопировать последовательность, такую ​​как строка или список)
  • s [1: 100] — это ‘ello’ — слишком большой индекс усекается до длины строки

Стандартные отсчитываемые от нуля порядковые номера обеспечивают легкий доступ к символам в начале строки.В качестве альтернативы Python использует отрицательные числа, чтобы обеспечить легкий доступ к символам в конце строки: s [-1] — последний символ ‘o’, s [-2] — ‘l’ предпоследний char и так далее. Отрицательные номера индекса отсчитываются от конца строки:

  • s [-1] is ‘o’ — последний символ (1-й с конца)
  • с [-4] — это ‘e’ — 4-я с конца
  • s [: — 3] — это «Он» — идет вверх, но не включая последние 3 символа.
  • s [-3:] — это ‘llo’ — начиная с 3-го символа с конца и продолжаясь до конца строки.

Это чистый трюизм срезов, что для любого индекса n s [: n] + s [n:] == s . Это работает даже для n отрицательных или выходящих за пределы. Или, используя другой способ, s [: n] и s [n:] всегда разделяют строку на две части, сохраняя все символы. Как мы увидим позже в разделе списков, срезы тоже работают со списками.

Строка%

Python имеет похожее на printf () средство для объединения строк. Оператор% принимает строку формата printf слева (% d int,% s строка,% f /% g с плавающей запятой) и соответствующие значения в кортеже справа (кортеж состоит из значений, разделенных запятые, обычно сгруппированные в круглых скобках):

  #% оператор
  text = "% d поросят вылезут, или я% s, я% s, и я взорву ваш% s."% (3, 'huff', 'puff', 'house')
 

Вышеупомянутая строка довольно длинная — предположим, вы хотите разбить ее на отдельные строки. Вы не можете просто разделить строку после символа «%», как в других языках, поскольку по умолчанию Python обрабатывает каждую строку как отдельный оператор (с положительной стороны, вот почему нам не нужно вводить точки с запятой на каждом линия). Чтобы исправить это, заключите все выражение в круглые скобки — тогда выражение может занимать несколько строк. Этот метод сквозного кода работает с различными конструкциями группирования, подробно описанными ниже: (), [], {}.

  # Добавьте круглые скобки, чтобы длинная строка работала:
  текст = (
    «% d поросят вылезут, или я% s, я% s, и я взорву ваш% s».
    % (3, 'фырка', 'затяжка', 'хаус'))
 

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

  # Разбиваем строку на куски, которые Python автоматически объединяет
  текст = (
    "% d поросят вышли",
    "или я% s, и я% s,"
    "и я взорву ваш% s."
    % (3, 'фырка', 'затяжка', 'хаус'))
 

Строки i18n (Unicode)

Обычные строки Python * не * являются Unicode, это просто байты. Чтобы создать строку Unicode, используйте префикс u в строковом литерале:

> ustring = u'A unicode \ u018e string \ xf1 '
> ustring
u'A unicode \ u018e строка \ xf1 '
 

Строка Юникода — это объект, отличный от обычной строки «str», но строка Юникода совместима (они используют общий суперкласс «basestring»), и различные библиотеки, такие как регулярные выражения, работают правильно, если вместо этого передается строка Юникода. обычной строки.

Чтобы преобразовать строку Unicode в байты с кодировкой, такой как ‘utf-8’, вызовите метод ustring.encode (‘utf-8’) для строки Unicode. В другом направлении функция unicode (s, encoding) преобразует закодированные простые байты в строку Unicode:

## (ustring сверху содержит строку юникода)
> s = ustring.encode ('utf-8')
> с
'Строка Unicode \ xc6 \ x8e \ xc3 \ xb1' ## байтов в кодировке utf-8
> t = unicode (s, 'utf-8') ## Конвертировать байты обратно в строку Unicode
> t == ustring ## Он такой же, как оригинал, ура!
 

Правда

Встроенная функция печати не полностью работает со строками Unicode.Вы можете сначала encode () печатать в utf-8 или что-то еще. В разделе чтения файлов приведен пример, показывающий, как открыть текстовый файл с некоторой кодировкой и прочитать строки Unicode. Обратите внимание, что обработка Unicode — это одна из областей, где Python 3000 значительно очищен по сравнению с поведением Python 2.x, описанным здесь.

Если заявление

Python не использует {} для включения блоков кода для if / loops / function и т. Д. Вместо этого Python использует двоеточие (:) и отступы / пробелы для группировки операторов.Логический тест для if необязательно заключать в скобки (большое отличие от C ++ / Java), и он может иметь предложения * elif * и * else * (мнемоника: слово «elif» имеет ту же длину, что и слово « еще»).

Любое значение может использоваться как if-test. Все «нулевые» значения считаются ложными: нет, 0, пустая строка, пустой список, пустой словарь. Существует также логический тип с двумя значениями: True и False (преобразованный в int, это 1 и 0). Python имеет обычные операции сравнения: ==,! =, <, <=,>,> =.В отличие от Java и C, == перегружен для правильной работы со строками. Логические операторы — это прописанные слова * и *, * или *, * not * (Python не использует C-стиль && ||!). Вот как может выглядеть код, если полицейский тянет спидер — обратите внимание, как каждый блок операторов then / else начинается с:, а операторы сгруппированы по их отступам:

  если скорость> = 80:
    распечатать 'Лицензия и регистрация, пожалуйста'
    если настроение == 'ужасное' или скорость> = 100:
      print 'Вы имеете право хранить молчание.'
    elif mood == 'bad' или speed> = 90:
      print "Мне придется выписать вам билет".
      write_ticket ()
    еще:
      print "Давай попробуем сохранить меньше 80, ладно?"
 

Я считаю, что пропуск «:» является моей самой распространенной синтаксической ошибкой при вводе кода вышеупомянутого типа, вероятно, потому, что это дополнительная вещь для ввода по сравнению с моими привычками C ++ / Java. Кроме того, не помещайте логический тест в скобки — это привычка C / Java. Если код короткий, вы можете поместить его в ту же строку после «:», как это (это относится к функциям, циклам и т. Д.также), хотя некоторые люди считают, что удобнее размещать элементы на отдельных строках.

  если скорость> = 80: print 'Вы так разорились'
  else: print "Хорошего дня"
 

Упражнение: string1.py

Чтобы попрактиковаться в материале этого раздела, попробуйте упражнение string1.py в Базовых упражнениях.

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

Строковые функции Python Описание
capitalize () Эта строковая функция преобразует первый символ в регистр, а следующие символы в нижний регистр.
casefold () Этот метод возвращает заданную строку в нижнем регистре.
center () Этот метод заключается в выравнивании строки по центру и заполнении оставшейся ширины пробелами по умолчанию
count () Эта строковая функция python считает, сколько раз встречается строка.
encode () Этот метод возвращает закодированную версию строкового объекта
endwith () Этот метод возвращает TRUE, если строка заканчивается указанной подстрокой
expandtabs () Это Метод возвращает копию данной строки, где все символы табуляции заменены одним или несколькими пробелами.
find () Возвращает позицию индекса первого вхождения указанной строки. Он возвращает -1, если указанная строка не найдена
format () Эта строковая функция полезна для форматирования строки
format_map () Этот метод полезен для форматирования строки
index () Возвращает позицию индекса первого вхождения указанной строки. Он вызывает ValueError, если указанная строка не найдена.
isalnum () Эта строковая функция Python возвращает ИСТИНА, если строка содержит буквы и числа
isalpha () Этот метод возвращает ИСТИНА, если в строке есть хотя бы одна буква, а все буквы алфавитные.
isdecimal () Этот метод возвращает ИСТИНА, если в строке есть хотя бы одна буква, а все буквы являются десятичными
isdigit () Эта строковая функция Python возвращает ИСТИНА, если в строке есть хотя бы один letter, а все буквы — цифры
isidentifier () Этот метод возвращает ИСТИНА, если строка является допустимым идентификатором.
islower () Этот метод возвращает ИСТИНА, если строка содержит хотя бы одну букву, и все буквы в нижнем регистре
isnumeric () Он возвращает ИСТИНА, если в строке есть хотя бы одна буква, а все буквы числовые 90 021
isprintable () Эта строковая функция python возвращает TRUE, если все буквы являются Printable
isspace () Она возвращает TRUE, если строка содержит только пробелы
istitle () This Метод возвращает TRUE, если в строке есть хотя бы одна буква, и это заголовок.
isupper () Эта строковая функция python возвращает TRUE, если строка содержит хотя бы одну букву, и все буквы находятся в верхнем регистре
join () Этот метод полезен для соединения (объединения) a список строк
ljust () Этот метод заключается в выравнивании строки по левому краю и заполнении оставшейся ширины пробелами по умолчанию
lower () Он преобразует данную строку в нижний регистр букв и возвращает новую строку.
lstrip () Эта строковая функция Python удаляет пробелы с левой стороны строки
maketrans () Она возвращает таблицу транзакций. В дальнейшем мы можем использовать эту транзакцию в методе translate ().
partition () Он разделяет заданную строку при первом появлении указанного разделителя и возвращает кортеж с тремя аргументами.
replace () Эта строковая функция Python ищет указанную строку и заменяет ее новым строковым значением.
rfind () Возвращает позицию индекса последнего вхождения указанной строки. Он возвращает -1, если указанная строка не найдена.
rindex () Возвращает позицию индекса последнего вхождения указанной строки. Он вызывает ValueError, если указанная строка Python не найдена
rjust () Этот метод заключается в выравнивании строки по правой стороне и заполнении оставшейся ширины пробелами по умолчанию
rpartition () Эта строковая функция python разделяет заданную строку с помощью указанного разделителя и возвращает кортеж с тремя аргументами.
rsplit () Этот метод полезен для разделения строки на список строк на основе указанного разделителя. Это происходит справа налево
rstrip () Удаляет пробелы с правой стороны строки
split () Эта строковая функция Python очень полезна для разделения строки на список строк на основе указанного разделителя
splitlines () Он возвращает список строк в данной строке, разбивая данную строку по границам строки.
startwith () Этот метод возвращает ИСТИНА, если строка начинается с указанной подстроки
strip () Он удаляет пробелы с обоих концов. Выполняет как lstrip (), так и rstrip ()
swapcase () Этот метод преобразует строчные буквы в прописные. И буквы верхнего регистра в нижний регистр
title () Эта строковая функция python преобразует первый символ в каждом слове в верхний регистр, а следующие символы в нижний регистр
translate () Возвращает копию данной строки, в которой каждый символ сопоставлен с таблицей транзакций.
upper () Этот метод преобразует заданную строку в прописные буквы и возвращает новую строку.
zfill () Эта строковая функция python возвращает копию строки, заполненную цифрами «0» ASCII в левой части строки, чтобы длина строки была заданной ширины.

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

В этом руководстве описаны различные строковые (символьные) функции, используемые в Python.Для управления строками и значениями символов в python есть несколько встроенных функций. Это означает, что вам не нужно импортировать или иметь зависимость от какого-либо внешнего пакета для работы со строковым типом данных в Python. Это одно из преимуществ использования Python перед другими инструментами анализа данных. Работа со строковыми значениями очень распространена в реальном мире. Предположим, у вас есть полное имя клиента, и ваш менеджер попросил вас извлечь имя и фамилию клиента. Или вы хотите получить информацию обо всех продуктах, код которых начинается с QT.

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

В таблице ниже показаны многие общие строковые функции, а также их описание и эквивалентная функция в MS Excel. Все мы используем MS Excel на своем рабочем месте и знакомы с функциями, используемыми в MS Excel. Сравнение строковых функций в MS EXCEL и Python поможет вам быстро изучить функции и проанализировать их перед собеседованием.
Функция Описание ФУНКЦИЯ MS EXCEL
mystring [: N] Извлечь N символов из начала строки. ЛЕВАЯ ()
mystring [-N:] Извлечь N символов из конца строки ПРАВАЯ ()
mystring [X: Y] Извлечь символы из середины строки, начиная с позиции X и заканчивая Y MID ()
ул. Сплит (sep = ») Разделенные струны
str.replace (old_substring, new_substring) Заменить часть текста другой подстрокой ЗАМЕНА ()
ул.нижний () Преобразование символов в нижний регистр НИЖНИЙ ()
стр. Верх () Преобразование символов в верхний регистр ВЕРХНИЙ ()
str.contains (‘pattern’, case = False) Проверить соответствие шаблону (функция Pandas) Оператор SQL LIKE
стр. Экстракт (регулярное_выражение) Возврат согласованных значений (функция Pandas)
ул.count (‘sub_string’) Подсчитать появление шаблона в строке
ул. Найти () Возврат позиции подстроки или шаблона НАЙТИ ()
str.isalnum () Проверить, состоит ли строка только из буквенно-цифровых символов
ул. Нижняя () Проверить, все ли символы в нижнем регистре
ул.isupper () Проверить, все ли символы в верхнем регистре
ул. Числовая () Проверить, состоит ли строка только из цифровых символов
ул. Пробел () Проверить, состоит ли строка только из пробельных символов
лин () Рассчитать длину строки LEN ()
кот () Объединить строки (функция Pandas) СЦЕПИТЬ ()
сепаратор.присоединиться (ул.) Конкатенация строк СЦЕПИТЬ ()

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

Если вы являетесь промежуточным пользователем MS Excel, вы должны были использовать функции LEFT, RIGHT и MID. Эти функции используются для извлечения N символов или букв из строки.

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

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

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

 mystring [-2:]
 
Приведенная выше команда возвращает p? . -2 начинает диапазон от второй последней позиции до максимальной длины строки.

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

 mystring [1: 3]
 
 Out [1]: 'ey'
 
mystring [1: 3] возвращает второй и третий символы. 1 относится ко второму символу, поскольку индекс начинается с 0.

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

 mystring [:: - 1]
 
 Out [1]: '? Pussaw, yddub yeH'
 
-1 указывает Python начинать его с конца и увеличивать его на 1 справа налево.

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

Для иллюстрации создадим поддельный фрейм данных.В приведенном ниже коде мы создаем фрейм данных с именем df , содержащий только 1 переменную с именем var1 .
импортировать панд как pd
df = pd.DataFrame ({"var1": ["A_2", "B_1", "C_2", "A_2"]})

  var1
0 A_2
1 B_1
2 C_2
3 А_2
 
Для работы с текстовыми данными в Python Pandas Dataframe мы можем использовать атрибут str . Его можно использовать для нарезки символьных значений.
 df ['var1']. Str [0] 
В этом случае мы получаем первый символ из переменной var1 . Смотрите результат, показанный ниже.
  Выход 
0 А
1 млрд
2 С
3 А
 

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

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

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

 mystring.split () [0]
 
 Out [1]: 'Привет'
 

Как это устроено?

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

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

 mystring.split (',') [0]
 
 Out [1]: 'Привет, дружище'
 

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

 mystring.split () [- 1]
 
 Из [1]: 'wassup?' 

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

Создадим фиктивный фрейм данных, состоящий из имен клиентов, и назовем его переменной custname .
mydf = pd.DataFrame ({"custname": ["Priya_Sehgal", "David_Stevart", "Kasia_Woja", "Sandy_Dave"]})
 
        custname
0 Priya_Sehgal
1 David_Stevart
2 Kasia_Woja
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 , в которых хранятся имя и фамилия.
  3.   Выход 
            custname fname lname
    0 Priya_Sehgal Прия Сегал
    1 David_Stevart Дэвид Стеварт
    2 Kasia_Woja Касия Воя
    3 Sandy_Dave Сэнди Дэйв
     

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

В SQL оператор LIKE используется, чтобы узнать, соответствует ли символьная строка шаблону или содержит ли он его.Мы можем реализовать аналогичную функциональность в Python, используя функцию str.contains () .
df2 = pd.DataFrame ({"var1": ["AA_2", "B_1", "C_2", "a_2"],
                    "var2": ["X_2", "Y_1", "Z_2", "X2"]})
 
   var1 var2
0 AA_2 X_2
1 B_1 Y_1
2 C_2 Z_2
3 а_2 Х2
 

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

 df2 ['var1']. Str.contains ('A | B') 
str.contains (pattern) используется для сопоставления с шаблоном в Pandas Dataframe.
  Выход 
0 Верно
1 Верно
2 ложь
3 ложь
 
Приведенная выше команда возвращает FALSE для четвертой строки, поскольку функция чувствительна к регистру. Чтобы игнорировать чувствительность к регистру, мы можем использовать параметр case = False . См. Рабочий пример ниже.
 df2 ['var1']. Str.contains ('A | B', case = False) 

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

В следующей программе мы просим Python разделить данные с условием — содержать символьные значения A или B. — это токен регулярного выражения, что означает начало с определенного элемента.
  var1 var2
1 B_1 Y_1
2 C_2 Z_2
3 а_2 Х2
 

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

str.find (шаблон) используется для поиска позиции подстроки. В этом случае подстрокой является ‘_’.
df2 ['var1']. str.find ('_')
 
0 2
1 1
2 1
3 1
 

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

str.replace (old_text, new_text, case = False) используется для замены определенного символа (ов) или шаблона некоторым новым значением или шаблоном.В приведенном ниже коде мы заменяем _ на — в переменной var1.
df2 ['var1']. str.replace ('_', '-', case = False)
 
  Выход 
0 AA - 2
1 В - 1
2 С - 2
3 А - 2
 
Мы также можем сложные шаблоны, подобные следующей программе. + означает, что элемент встречается один или несколько раз. В этом случае алфавит встречается 1 или более раз.
df2 ['var1']. str.replace ('[A-Z] + _', 'X', case = False)
 
0 X2
1 х 1
2 х 2
3 X2
 

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

len (строка) используется для вычисления длины строки.В фрейме данных pandas вы можете применить str.len () для того же.
df2 ['var1']. str.len ()
 
  Выход 
0 4
1 3
2 3
3 3
 
Чтобы найти количество вхождений определенного символа (скажем, сколько раз «A» появляется в каждой строке), вы можете использовать функцию str.count (pattern) .
 df2 ['var1']. Str.count ('A') 

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

str.lower () и str.upper () функции используются для преобразования строки в значения нижнего и верхнего регистра.
# Преобразовать в нижний регистр
mydf ['custname']. str.lower ()

# Преобразовать в верхний регистр
mydf ['custname']. str.upper ()
 

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

  1. str.strip () удаляет как начальные, так и конечные пробелы.
  2. str.lstrip () удаляет ведущие пробелы (в начале).
  3. str.rstrip () удаляет конечные пробелы (в конце).
df1 = pd.DataFrame ({'y1': ['jack', 'jill', 'jesse', 'frank']})
df1 ['оба'] = df1 ['y1'].str.strip ()
df1 ['left'] = df1 ['y1']. str.lstrip ()
df1 ['right'] = df1 ['y1']. str.rstrip ()
 
        y1 оба слева направо
0 jack jack jack jack
1 джилл джилл джилл джилл
2 Джесси Джесси Джесси Джесси
3 фрэнк фрэнк фрэнк
 

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

С помощью функции str () вы можете преобразовать числовое значение в строку.
myvariable = 4
mystr = str (моя переменная)
 

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

Просто используя + , вы можете объединить два строковых значения.
x = "Дипаншу"
y = "Бхалла"
х + у
 
DeepanshuBhalla
 
Если вы хотите добавить пробел между двумя строками, вы можете использовать это — x + '' + y возвращает Deepanshu Bhalla Предположим, у вас есть список, содержащий несколько строковых значений, и вы хотите их объединить. Вы можете использовать функцию join () .
string0 = ['Рам', 'Кумар', 'Сингх']
'' .join (строка0)
 
  Выход 
Рам Кумар Сингх
 
Предположим, вы хотите объединить или объединить два столбца фрейма данных pandas.
mydf [‘полное имя’] = mydf [‘fname’] + » + mydf [‘lname’]
ИЛИ
mydf [‘fullname’] = mydf [[‘fname’, ‘lname’]]. Apply (лямбда x: » .join (x), axis = 1)
     custname fname lname полное имя
0 Priya_Sehgal Priya Sehgal Priya Sehgal
1 David_Stevart Дэвид Стеварт Дэвид Стеварт
2 Kasia_Woja Касиа Воя Касиа Воя
3 Sandy_Dave Сэнди Дэйв Сэнди Дэйв
 

Оператор SQL IN в пандах

Мы можем использовать функцию isin (list) , чтобы включить несколько значений в наши критерии фильтрации или подмножества.
mydata = pd.DataFrame ({'product': ['A', 'B', 'B', 'C', 'C', 'D', 'A']})
mydata [mydata ['продукт']. isin (['A', 'B'])]
 
  товар
0 А
1 млрд
2 млрд
6 А
 

Как применить критерии НЕ при выборе нескольких значений?

Мы можем использовать знак ~ , чтобы указать питону, что нужно отрицать условие.
mydata [~ mydata ['продукт']. isin (['A', 'B'])]
 

Извлечь определенный шаблон из строки

str.extract (r'regex-pattern) используется для этой задачи.[A-Z] _) ‘). Dropna ()

Функции и методы для символьных строк

Функции и методы для символьных строк
Далее: Числовые данные Up: Строковые операции Предыдущая: Индексирование и нарезка & nbsp Содержание


Функции и методы для символьных строк Основной язык предоставляет только одну полезную функцию. для работы со струнами; функция len, которая возвращает количество символов который содержит строка символов.В версиях Python ранее, чем 2.0, инструменты для работа со строками была предоставлена строковый модуль (раздел 8.4). Начиная с версии 2.0, строки в python стали « настоящими » объектами, и для работы со строками было введено множество методов. Если вы обнаружите, что строковые методы, описанные в этом разделе, недоступны в вашем версии ython, обратитесь к Разделу 8.4 за эквивалентными возможностями через строковый модуль. (Обратите внимание, что в некоторых системах более новая версия Python может быть доступна через имя python2.)

Поскольку строки — это первые истинные объекты, мы встретили краткое описание методов по порядку. Как упоминалось ранее (раздел 1.4.3), при работе с объектами функции называются методами. Кроме По терминологии, методы вызываются несколько иначе, чем функции. Когда ты вызовите функцию типа len, вы передаете аргументы в виде списка, разделенного запятыми в круглых скобках после имени функции. Когда вы вызываете метод, вы указываете имя объекта, над которым должен действовать метод, за которым следует период, за которым следует имя метода и список в скобках дополнительные аргументы.Не забудьте указать пустые скобки, если метод не принимать никаких аргументов, чтобы python мог различать вызов метода без аргументы из ссылки на переменную, хранящуюся в объекте.

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

Таблица 2.2: Строковые методы
Разделить и объединить
Название Назначение Аргументы
присоединиться к Вставить строку между каждым элементом последовательности последовательность
сплит Создать список из « слов » в строке сен (опционально)
maxsplit (опционально)
Splitlines Создать список из строк в строке keepends (опционально)
Методы поиска
Примечание: Каждая из этих функций принимает необязательные аргументы start и end
которые ограничивают диапазон поиска.
Название Назначение Аргументы
количество Подсчитать количество появлений подстроки подстрока
найти Вернуть наименьший индекс, в котором найдена подстрока, подстрока
и -1, если не найдено
индекс Как find, но вызывает ошибку ValueError, если не найден подстрока
rfind Вернуть наивысший индекс, если подстрока найдена, подстрока
и -1, если не найдено
rindex Как rfind, но вызывает ошибку ValueError, если не найден подстрока
Методы обоснования
Название Назначение Аргументы
центр Центрирует строку по заданной ширине ширина
ljust Выравнивает строку по левому краю ширина
lstrip Удаляет начальные пробелы
rjust Выравнивает строку по правому краю ширина
rstrip Удаляет завершающие пробелы
полоса Удаляет начальные и конечные пробелы
Методы для корпуса (верхний / нижний)
Название Назначение Аргументы
заглавная буква Сделать первую букву строки заглавной
нижний Сделать все символы строчными
свопкейс Изменить верхнее на нижнее и нижнее на верхнее
название Делать первые буквы каждого слова в строке заглавными
верхний Сделать все символы в верхнем регистре

Многие строковые методы, предоставляемые python, перечислены в таблице 2.2. Среди наиболее полезными являются методы split и join. Сплит-метод работает со строкой и возвращает список, каждый из элементов которого является словом исходной строки, где слово по умолчанию определяется как группа непробельных символов, к которым присоединяются один или несколько пробельные символы. Если вы предоставите один необязательный аргумент методу разделения, это будет используется для разделения строки в качестве альтернативы одному или нескольким пробельным символам. Обратите внимание на тонкий разница между вызовом split без аргументов и аргументом, состоящим из одно пустое пространство:

>>> str = 'Этот попугай мертв'
>>> ул.Трещина()
["Это", "попугай", "есть", "мертв"]
>>> str.split ('')
['This', 'parrot', '', 'is', 'dead']
 
Когда в строке встречается более одного пробела, метод по умолчанию рассматривает его как если бы это был просто один пробел, но когда мы явно устанавливаем символ-разделитель на один пробел, несколько пробелов в строке приводят к появлению дополнительных элементов в результирующем списке. Вы также можете получить поведение по умолчанию для разделения, указав None для аргумента sep.

Аргумент maxsplit метода split приведет к списку с maxsplit + 1 элементы.Это может быть очень полезно, когда вам нужно разделить только часть строки, так как оставшиеся части будет помещен в единственный элемент возвращаемого списка. Например, предположим, что у вас есть файл, содержащий определения слов, причем слово является первой строкой, а определение состоит из остатка линия. Если установить maxsplit на 1, слово станет первым элементом возвращаемого списка, а определение станет вторым элементом списка, как показано в следующем примере:

>>> line = 'Ни звука, который издает рыцарь'
>>> линия.сплит (maxsplit = 1)
['Ni', 'звук, который издает рыцарь']
 
В некоторых версиях Python метод split не принимает именованный аргумент для maxsplit. В этом случае вам нужно будет явно указать разделитель, используя None для получения поведения по умолчанию.
>>> line.split (Нет, 1)
['Ni', 'звук, который издает рыцарь']
 

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

>>> words = ['спам', 'спам', 'бекон', 'спам']
>>> '' .join (слова)
'спам спам бекон спам'
 
Конечно, вы можете присвоить переменной значение », чтобы улучшить внешний вид такого заявления.

Функции index и find могут быть полезны при попытке извлечь подстроки, хотя методы, использующие модуль re (раздел 8.5) обычно более мощный. В качестве примера использование этих функций, предположим, что у нас есть строка с подстрокой в ​​скобках, и мы хотим извлечь именно эту подстроку.Используя методы нарезки, описанные в Разделе 2.4.3, и находя подстроку с помощью, например index и rindex, вот один из способов решения проблемы:

>>> model = 'Turbo Accelerated Widget (MMX-42b) Press'
>>> попробуйте:
... модель [model.index ('(') + 1: model.rindex (')')]
... кроме ValueError:
... напечатать "Скобки не найдены"
...
'MMX-42b'
 
Когда вы используете эти функции, обязательно проверьте случай, когда подстрока не найдена, либо ValueError, вызванное индексными функциями, либо возвращенное значение -1 из поиска функции.

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

>>> язык = 'питон'
>>> language = language.upper ()
>>> язык
'ПИТОН'
 

Наконец, python предлагает множество так называемых методов предиката, которые не требуют аргументы и вернуть 1, если все символы в строка имеет определенный тип и 0 в противном случае.Эти функции, использование которых должно быть очевидно из их имена, включая isalnum, isalpha, isdigit, islower, isspace, istitle и isupper.

Связанные модули: строка, ре, строкаIO.

Связанные исключения: TypeError, IndexError.



Далее: Числовые данные Up: Строковые операции Предыдущая: Индексирование и нарезка & nbsp Содержание
Фил Спектор 2003-11-12
.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *

Theme: Overlay by Kaira Extra Text
Cape Town, South Africa