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

Разбор Д/З

Повторение

Ещё раз про спецсимволы

   1 >>> print("a\n\nb")
   2 a
   3 
   4 b
   5 >>> print("a\tb")
   6 a       b
   7 >>> print("asdf\tb")
   8 asdf    b
   9 >>> print("123\rqwert")
  10 qwert
  11 >>> print("qwert\r123")
  12 123rt
  13 >>> print("ABCD\b\b1234")
  14 AB1234
  15

"\n" переводит курсор в начало следующейстоки
"\t" подвигает курсор на позицию. кратную *
"\r" возвращает курсор в начало строки и оставшаяся часть выводится «поверх»
"\b" подвигает курсор на одну позицию назад

Чтобы "\что-то" не воспринималось как спецсимвол при задании строки, надо использовать конструктор r"...":

   1 >>> print(r"A\t\nBCD\b1234")
   2 A\t\nBCD\b1234
   3

Про repr()

Для того, чтобы «непечатные» символы не управляли выводом, а отображались как "\что-то", надо использовать функцию repr(строка) (от «representation»). Эта функция, например, применяется по умолчанию, когда мы выводим объект не с помощью print(), а просто по результатам вычислений в командной строке:

   1 >>> s = "first\tsecond\nthird"
   2 >>> print(s)
   3 first   second
   4 third
   5 >>> print(repr(s))
   6 'first\tsecond\nthird'
   7 >>> s
   8 'first\tsecond\nthird'
   9

Методы строковых объектов

Методы — это такие функции, которые изначально заложены в объект (принадлежат его пространству имён). Вызываемый метод знает, какому объекту он принадлежит, и обычно что-нибудь с ним делает. Методы есть у всех объектов, но у строк их особенно много.

Метод вызывается как функция, но с указанием объекта, из которого он взят (это называется инкапсуляция):

объект.метод(возможно, какие-то параметры)

Все методы строк:

   1 >>> s=""
   2 >>> dir(s)
   3 ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
   4

Так как строка — константный объект, его нельзя изменить. Если метод возвращает строку, это новый объект. сконструированный из старого.

Работа с регистром

Здесь всё ясно из примеров.

   1 >>> s = "asdERT ERTsdf 345sdf"
   2 >>> s.capitalize()
   3 'Asdert ertsdf 345sdf'
   4 >>> s.lower()
   5 'asdert ertsdf 345sdf'
   6 >>> s.swapcase()
   7 'ASDert ertSDF 345SDF'
   8 >>> s.title()
   9 'Asdert Ertsdf 345Sdf'
  10 >>> s.upper()
  11 'ASDERT ERTSDF 345SDF'
  12

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

Методы, начинающиеся на «.is…» проверяют, состоит ли строка:

.isdigit() — из цифр
.isalpha() — из букв
.islower() — из маленьких букв
.isupper() — из больших букв
.isalnum() — из букв и/или цифр
.isidentifier() — из букв, цифр и/или "_", причём начинается не с цифры
.isprintable() — из печатных (не управляющих) символов
.isspace() — из пробельных символов (" ", "\t", "\n", и "\r")
… ещё чего-то там

   1 >>> a,b,c,d,e = "456", "asd", "asd345", " \t", "ASD SDF"
   2 >>> print(a.isalnum(), b.isalnum(), c.isalnum()), d.isalnum(), e.isalnum()
   3 True True True False False
   4 >>> print(a.isalpha(), b.isalpha(), c.isalpha()), d.isalpha(), e.isalpha()
   5 False True False False False
   6 >>> print(a.isdigit(), b.isdigit(), c.isdigit()), d.isdigit(), e.isdigit()
   7 True False False False False
   8 >>> print(a.isidentifier(), b.isidentifier(), c.isidentifier()), d.isidentifier(), e.isidentifier()
   9 False True True False False
  10 >>> print(a.islower(), b.islower(), c.islower()), d.islower(), e.islower()
  11 False True True False False
  12 >>> print(a.isprintable(), b.isprintable(), c.isprintable()), d.isprintable(), e.isprintable()
  13 True True True False True
  14 >>> print(a.isspace(), b.isspace(), c.isspace()), d.isspace(), e.isspace()
  15 False False False True False
  16 >>> print(a.isupper(), b.isupper(), c.isupper()), d.isupper(), e.isupper()
  17 False False False False True
  18

Кстати, ничего нет худого в том, чтобы проверить часть строки:

   1 >>> c
   2 'asd345'
   3 >>> c.isdigit()
   4 False
   5 >>> c[3:].isdigit()
   6 True
   7

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

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

   1 >>> s = "AsdF"
   2 >>> s.center(10, "=")
   3 '===AsdF==='
   4 >>> s.rjust(12)
   5 '        AsdF'
   6 >>> s.ljust(12,"_")
   7 'AsdF________'
   8

Удаление пробельных символов по краям строки:

   1 >>> s = " \tWER \n"
   2 >>> print(s)
   3         WER 
   4 
   5 >>> s
   6 ' \tWER \n'
   7 >>> s.strip()
   8 'WER'
   9 >>> s.lstrip()
  10 'WER \n'
  11 >>> s.rstrip()
  12 ' \tWER'
  13

Методы последовательностей

Как мы уже знаем, строка — не «простая» последовательность: операции, которые в списках или кортежах проводятся только над элементами, в стоке работают также и для подстрок не единичной длины, например, операция in:

   1 >>> s = "QWE qwe QWE qwe QWE"
   2 >>> 'W' in s
   3 True
   4 >>> 'WE' in s
   5 True
   6 >>> 'WEq' in s
   7 False
   8 >>> s.count("QWE")
   9 3
  10 >>> s.count("QwE")
  11 0
  12 >>> s.count("w")
  13 2
  14 >>> s.index("we")
  15 5
  16 >>> s.rindex("we")
  17 13
  18 >>> s.index("wer")
  19 Traceback (most recent call last):
  20   File "<stdin>", line 1, in <module>
  21 ValueError: substring not found
  22 >>> s.find("we")
  23 5
  24 >>> s.rfind("we")
  25 13
  26 >>> s.find("wer")
  27 -1
  28 >>> s.find("WE",4)
  29 9
  30 >>> s.find("WE",12)
  31 17
  32 >>> s.find("WE",18)
  33 -1
  34

Метод find() отличается от index() только тем, что не приводит к ошибке, если подстрока не найдена, а возвращает -1. У обоих методов есть вариант. начинающийся на "r" — в этом случае поиск идёт с конца строки. Необязательный второй параметр — позиция, откуда начинать поиск.

Замена и быстрый поиск

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

   1 >>> s = "ASD-efg-123-10050"
   2 >>> s.replace("-","===")
   3 'ASD===efg===123===10050'
   4 >>> s.replace("-","===",2)
   5 'ASD===efg===123-10050'
   6 >>> s.replace("-","===",1)
   7 'ASD===efg-123-10050'
   8 >>> s.replace("-1","===")
   9 'ASD-efg===23===0050'
  10 >>> s.replace("-1","==1")
  11 'ASD-efg==123==10050'
  12

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

Проверка, начинается ли строка подстрокой, если её реализовывать вручную, — не такая уж и простая операция: либо нам следует обратиться к методу .find(), который просматривает всю строку (а нам-то надо только начало), либо изготавливать с помощью сечения новую подстроку. Специальный метод .startswith(подстока) (и .endswith() до кучи)для этого предпочтительнее:

   1 >>> s
   2 'ASD-efg-123-10050'
   3 >>> s.find("ASD") == 0
   4 True
   5 >>> s.find("ef") == 0
   6 False
   7 >>> s[:3] == "ASD"
   8 True
   9 >>> s[:3] == "SD"
  10 False
  11 >>> s.startswith("ASD")
  12 True
  13 >>> s.startswith("SD")
  14 False
  15 >>> s.endswith("0050")
  16 True
  17

Д/З

Ещё раз прочитать (и прощёлкать, если ещё не ) восьмую главу учебника
EJudge: AllLower 'Все маленькие'

Ввести произвольную стоку и проверить, что все буквы, которые в ней встречаются — маленькие. Если нет ни одной большей буквы, вывести "YES", иначе "NO".
Input:
```
123hj4g 23hj4g123@#kjh2345jk#$
```
Output:
```
YES
```
EJudge: DrawTriangle 'Плакат с треугольником'

Ввести целое число N и вывести прямоугольник из N строк, в котором с помощью "="и "*" изображён треугольник:
Input:
```
6
```
Output:
```
=====*=====
====***====
===*****===
==*******==
=*********=
***********
```
EJudge: DeleteChars 'Удалить символы'

Ввести строку чётной длины и удалить все точки и запятые из первой её половины, и все восклицательные и вопросительные знаки — из второй. Вывести результат.
Input:
```
qwe! qwe. qwe, qwe?  asd! asd. asd, asd?
```
Output:
```
qwe! qwe qwe qwe?  asd asd. asd, asd
```

Python/PsyPython2018/10_StringMethods (последним исправлял пользователь FrBrGeorge 2018-11-28 01:21:31)