1 >>> a = '''A multiline string
   2 ... is a string that takes multiple
   3 ... lines of text
   4 ... '''
   5 >>> a    # Интерпретатор при выводе использует результат работы метода объекта __repr__ - он представляет в виде строки внутреннюю структуру объекта 
   6 'A multiline string\nis a string that takes multiple\nlines of text\n'
   7 >>> print(a.__str__())    # __str__ задаёт строковое представление объекта - этот-то метод объекта (если он есть) и использует print
   8 A multiline string
   9 is a string that takes multiple
  10 lines of text
  11 
  12 >>> print(a.__repr__())
  13 'A multiline string\nis a string that takes multiple\nlines of text\n'
  14 

   1 >>> print('There will be a\nhuge fall')
   2 There wiil be a
   3 huge fall
   4 >>> print("We need to explore\t\t\touter space")
   5 We need to explore                      outer space
   6 >>> print("I don't want to set the world on fire\rI do!!!")    # Символ возврата каретки переносит наш "курсор" - то место, в которое происходит вывод - в начало строки
   7 I do!!! want to set the world on fire
   8 >>> print("Yep, I'm using \"double quotes\" in a double-quoted string literal")
   9 Yep, I'm using "double quotes" in a double-quoted string literal
  10 

   1 >>> ord("a")    # Получить номер символа в кодировке (ord вернёт десятичное число)
   2 97
   3 >>> ord("abc")    # Обратите внимание, что ord принимает на вход строку именно из одного символа
   4 Traceback (most recent call last):
   5   File "<stdin>", line 1, in <module>
   6 TypeError: ord() expected a character, but string of length 3 found
   7 >>> ord(a)    # И именно строку
   8 Traceback (most recent call last):
   9   File "<stdin>", line 1, in <module>
  10 TypeError: ord() expected a character, but string of length 70 found
  11 >>> ord("ы")    # Символы, не принадлежацие таблице ASCII, кодируются с помощью Юникода
  12 1099
  13 >>> chr(1099)     # chr позволяет по коду символа получить сам символ (символ Юникода тоже)
  14 'ы'
  15 >>> hex(ord("a"))    # Для примера нам потребуются шестнадцатеричные коды символов
  16 '0x61'
  17 >>> hex(ord("ы"))
  18 '0x44b'
  19 >>> print("\x61")    # \xhh - управляющая последовательность, позволяющая вывести ASCII-символ по его коду
  20 a
  21 >>> print("\x04\x4b\x61")    # Для кириллицы не подойдёт
  22 Ka
  23 >>> print("\u044b\x61")    # Символы Юникода задаются с помощью управляющих последовательностей \u и \U (за первой следуют 4 шестнадцатеричные цифры, за второй - 8)
  24 ыa
  25 

   1 >>> for i in "QWERTY":
   2 ...     print(i)
   3 ...
   4 Q
   5 W
   6 E
   7 R
   8 T
   9 Y
  10 

   1 >>> a = "Raxacoricofallapatorius"
   2 >>> a[5]    # Строка из одного символа
   3 'o'
   4 >>> a[5:9]    # Новая строка из 4 символов
   5 'oric'
   6 >>> a[8]
   7 'c'
   8 >>> a[8:9]
   9 'c'
  10 >>> a[8] is a[8:9]    # TODO: В чём принципиальное отличие строки от кортежа, кроме того, что каждый элемент строки - тоже строка? Нужно уточнить
  11 True
  12 >>> a[8] is 'c'
  13 True
  14 

   1 >>> a[6] = "v"
   2 Traceback (most recent call last):
   3   File "<stdin>", line 1, in <module>
   4 TypeError: 'str' object does not support item assignment

   1 >>> a
   2 'Raxacoricofallapatorius'
   3 >>> "o" in a    # Это мы уже видели на примере других последовательностей
   4 True
   5 >>> "fall" in a    # А вот это - нечто новое
   6 True
   7 >>> "gravity fall" in a
   8 False
   9 

   1 >>> a.count("co")    # Потому что вместо подсчёта вхождений одного элемента последовательности мы считаем количество вхождений целой подпоследовательности
   2 2
   3 

   1 >>> a = "asd aSDFSDv  zxcdfg%^ 567567 GFHFG oikpi"
   2 >>> dir(a)
   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 >>> a
   2 'asd aSDFSDv  zxcdfg%^ 567567 GFHFG oikpi'
   3 >>> a.index("SDF")    # Найти индекс первого вхождения подстроки в строку
   4 5
   5 >>> a.index("SDF!")    # Если такой подстроки в строке не содержится, выбросить исключение
   6 Traceback (most recent call last):
   7   File "<stdin>", line 1, in <module>
   8 ValueError: substring not found
   9 >>> a.find("SDF")    # find тоже находит первое вхождение подстроки в строку
  10 5
  11 >>> a.find("SDF!")    # Однако в случае неуспеха не выбрасывает ошибку, а возвращает -1
  12 -1
  13 

   1 >>> b = "123we"
   2 >>> b.isalnum()    # "is alphanumeric" - содержит ли строка только буквы и цифры
   3 True
   4 >>> b = "123we!"
   5 >>> b.isalnum()
   6 False
   7 >>> b = "123we_"    # К слову, нижнее подчёркивание буквой не считается
   8 >>> b.isalnum()
   9 False
  10 >>> b = "йцукен"    # Буквами считаются и буквы в Юникоде
  11 >>> b.isalnum()
  12 True
  13 >>> "1234".isdigit()    # isdecimal, isdigit, isnumeric - проверка, состоит ли строка из цифр (с некоторыми тонкостями)
  14 True
  15 >>> "1234".isdecimal()
  16 True
  17 >>> "1234F".isdecimal()
  18 False
  19 >>> "1234F".isdigit()
  20 False
  21 >>> b = "123qwe"
  22 >>> b.isidentifier()    # Проверка, может ли строка быть идентификатором (именем объекта), т.е. является ли она последовательностью букв, цифр и _, начинающейся не с цифры
  23 False
  24 >>> b = "_123qwe"
  25 >>> b.isidentifier()
  26 True
  27 >>> "asd".islower()    # islower - состоит ли строка только из строчных букв
  28 True
  29 >>> "aSd".islower()
  30 False
  31 >>> "ASD".isupper()    # isupper - состоит ли строка только из прописных букв
  32 True
  33 >>> "AsD".isupper()
  34 False
  35 >>> "word".isprintable()    # isprintable - состоит ли строка только из печатных символов
  36 True
  37 >>> "word\n".isprintable()
  38 False
  39 >>> "\n\t      \t\n".isspace()    # isspace - состоит ли строка только из пробельных символов
  40 True
  41 >>> "\n\t   !   \t\n".isspace()
  42 False
  43 >>> "Avalidtitle".istitle()    # istitle - проверяет, состоит ли строка только из слов, разделённых пробелами, состоящих только из букв и начинающихся с прописной буквы каждое
  44 True
  45 >>> "A nonvalid title".istitle()
  46 False
  47 >>> "A_non-valid_title".istitle()
  48 False
  49 >>> "Anon-validtitle".istitle()
  50 False
  51 >>> "Anon123alidtitle".istitle()
  52 False
  53 >>> "ANonValidTitle".istitle()
  54 False
  55 >>> "A Valid Title".istitle()
  56 True
  57 

   1 >>> s = "qWe"
   2 >>> s.lower()    # lower - преобразование всех букв в строчные
   3 'qwe'
   4 >>> s.upper()    # upper - преобразование всех букв в прописные
   5 'QWE'
   6 >>> a.capitalize()    # capitalize - преобразование первой буквы в прописную
   7 'Asd asdfsdv  zxcdfg%^ 567567 gfhfg oikpi'
   8 >>> a.title()    # title - преобразование первых букв всех слов в прописные
   9 'Asd Asdfsdv  Zxcdfg%^ 567567 Gfhfg Oikpi'
  10 >>> s.swapcase()    # swapcase - сменить регистр всех букв в строке
  11 'QwE'
  12 >>> a.casefold()    # casefold - привести строку к такому виду, в котором её возможно сравнивать (>, <) с другими строками вне зависимости от регистра букв
  13 'asd asdfsdv  zxcdfg%^ 567567 gfhfg oikpi'
  14 

   1 >>> a
   2 'asd aSDFSDv  zxcdfg%^ 567567 GFHFG oikpi'
   3 >>> a.replace("SD","----")    # По умолчанию заменяются все вхождения
   4 'asd a----F----v  zxcdfg%^ 567567 GFHFG oikpi'
   5 >>> a.replace("SD","----",1)    # Но можно и ограничить количество замен
   6 'asd a----FSDv  zxcdfg%^ 567567 GFHFG oikpi'
   7 

   1 >>> b = "   \t   za warudo   \t   "
   2 >>> b.lstrip()
   3 'za warudo   \t   '
   4 >>> b.rstrip()
   5 '   \t   za warudo'
   6 >>> b.strip()
   7 'za warudo'
   8 

   1 >>> s = "1"
   2 >>> s.zfill(10)
   3 '0000000001'
   4 >>> s = "-1"
   5 >>> s.zfill(10)    # Вот и отличие от ljust: zfill интерпретирует строку именно как число (но это работает только с целыми десятичными числами)
   6 '-000000001'
   7 

   1 >>> a
   2 'asd aSDFSDv  zxcdfg%^ 567567 GFHFG oikpi'
   3 >>> a.split()    # Разбить строку на подстроки по пробельным символам (последовательность пробельных символов как бы считается за один символ)
   4 ['asd', 'aSDFSDv', 'zxcdfg%^', '567567', 'GFHFG', 'oikpi']
   5 >>> nn = "123 32 2134 346 657 56 1234    436"    # Это очень удобно для анализа ввода с клавиатуры
   6 >>> [int(n) for n in nn.split()]
   7 [123, 32, 2134, 346, 657, 56, 1234, 436]
   8 >>> nn.split("3")    # Можно и указать подстроку, по которой выполнять разбиение
   9 ['12', ' ', '2 21', '4 ', '46 657 56 12', '4    4', '6']
  10 >>> a = "a,,d,r,,,e,,r"    # Если вы указываете подстроку, по которой разбивать данную, вы можете получить в массиве и пустые строки
  11 >>> a.split(",")
  12 ['a', '', 'd', 'r', '', '', 'e', '', 'r']
  13 >>> a.split(",,")    # Эта подстрока, конечно, не обязана состоять из одного символа
  14 ['a', 'd,r', ',e', 'r']
  15 

   1 >>> s = "This is a long\n text with\n multiple\n line endings\n"
   2 >>> s.splitlines()    # splitlines позволяет разбить строку по символам переноса строки (какой бы символ для этого ни использовался в ос)
   3 ['This is a long', ' text with', ' multiple', ' line endings']
   4 

   1 >>> sn = nn.split()
   2 >>> "__".join(sn)    # Таким образом можно задать тот разделитель, которым нужно соединять строки
   3 '123__32__2134__346__657__56__1234__436'
   4 >>> "".join(sn)    # Т.к. join - метод строки, то, даже если нам не нужен разделитель, хотя бы пустую строку указать придётся
   5 '123322134346657561234436'
   6 

   1 >>> a = '\n\n\n\n'    # Управляющие последовательности интерпретируются
   2 >>> print(a)
   3 
   4 
   5 
   6 
   7 
   8 >>> a = r'\n\n\n\n'    # Управляющие последовательности не интерпретируются
   9 >>> print(a)
  10 \n\n\n\n
  11 

   1 >>> f"____===={10:8}====____"    # Помимо текста снаружи них, в фигурных скобках указывается то выражение, которое должно быть отформатировано; через двоеточие после него можно указать минимальное количество символов, которое должна занимать получаемая подстрока
   2 '____====      10====____'
   3 >>> f"____===={10:08}====____"    # Можно не только указать минимальную ширину подстроки, но и заполнитель, который будет использован
   4 '____====00000010====____'
   5 >>> f"____===={10:<8}====____"    # Можно выровнять подстроку по левому краю
   6 '____====10      ====____'
   7 >>> f"____===={10:^8}====____"    # А можно и по центру (по правому краю она выравнивается по умолчанию)
   8 '____====   10   ====____'
   9 >>> f"____===={10.123456789192:^8}====____"    # Обратите внимание, впрочем, что здесь указывается именно минимальная, но не максимальная допустимая ширина подстроки
  10 '____====10.123456789192====____'
  11 >>> f"____===={10.123456789192:22}====____"
  12 '____====       10.123456789192====____'
  13 >>> f"____===={10.123456789192:22.20}====____"    # Для чисел можно указать, сколько знаков после запятой должно быть выведено
  14 '____==== 10.123456789191999761====____'
  15 >>> n = 100500    # Хуже того, в фигурных скобках могут фигурировать объявленные ранее переменные
  16 >>> f"____{n}____{n:8}____{a}"
  17 '____100500____  100500____\\n\\n\\n\\n'
  18 >>> f"____{n}____{n // 3 :8}____{a}"    # И целые выражения; т.е. сначала для каждого форматируемого фрагмента выполняется eval, и только потом происходит форматирование
  19 '____100500____   33500____\\n\\n\\n\\n'
  20 >>> f"____{n}____{nnn // 3 :8}____{a}"    # Следующие из этого ошибки и потенциальные угрозы - такие же, как у eval
  21 Traceback (most recent call last):
  22   File "<stdin>", line 1, in <module>
  23 NameError: name 'nnn' is not defined

   1 >>> "{1}, {0}, {1}, {2}".format(10,20,30)    # В фигурных скобках указывается индекс параметра, переданного в format, который нужно подставить в данное место строки
   2 '20, 10, 20, 30'
   3 >>> "qqwe {} sdfsdf {}".format(10,20)    # Можно оставить фигурные скобки пустыми, и тогда выбор параметра будет осуществлён автоматически (они будут взяты просто по порядку)
   4 'qqwe 10 sdfsdf 20'
   5 >>> "qqwe {1} sdfsdf {}".format(10,20,30)    # Единственное, смешивать эти два подхода нельзя
   6 Traceback (most recent call last):
   7   File "<stdin>", line 1, in <module>
   8 ValueError: cannot switch from manual field specification to automatic field numbering
   9 >>> "qqwe {} sdfsdf {2}".format(10,20,30)
  10 Traceback (most recent call last):
  11   File "<stdin>", line 1, in <module>
  12 ValueError: cannot switch from automatic field numbering to manual field specification
  13 >>> "qqwe {:8} sdfsdf {}".format(10,20)    # Для форматируемого параметра можно указать дополнительные свойства, например, опять-таки, минимальную ширину занимаемой им подтроки
  14 'qqwe       10 sdfsdf 20'
  15 

   1 >>> import sys    # С помощью специального метода посмотрим, сколько байт занимают наши строки
   2 >>> sys.getsizeof('12345')    # Кроме собственно символов, в строку входит также служебная информация
   3 54
   4 >>> sys.getsizeof('123456')    # Добавим ASCII-символ (пока что вся наша строка состоит только из них)
   5 55
   6 >>> sys.getsizeof('123456w')    # При этом размер, как и ожидалось, увеличивается на 1
   7 56
   8 >>> sys.getsizeof('123456wы')    # А вот при добавлении руской буквы получаем значительное увеличение размера
   9 90
  10 >>> a = "waffle345вафля"    # Почему? Потому что теперь нужно всю строку хранить, выделяя на каждый символ по 2 байта
  11 >>> a[0]    # Такое поведение позволяет при обращении со строками не думать о том, какой кодировке на самом деле принадлежит символ
  12 'w'
  13 >>> a[10]    # Кроме того, оно позволяет обеспечить совместимость с самыми разными кодировками, которые могут использоваться в операционной системе (в одной только windows, в зависимости от ситуации, используется не менее 4 различных кодировок)
  14 'а'
  15 

   1 >>> b = b"qwerqwer"    # Обозначается он как строковый литерал с модификатором `b`
   2 >>> type(b)
   3 <class 'bytes'>
   4 >>> a = 'asdfasdf'    # Для сравнения - строка
   5 >>> type(a)
   6 <class 'str'>
   7 >>> b    # Когда символов несколько - bytes ведёт себя как строка
   8 b'qwerqwer'
   9 >>> b * 3
  10 b'qwerqwerqwerqwerqwerqwer'
  11 >>> b + b'ret'
  12 b'qwerqwerret'
  13 >>> b[0]    # Но вот при индексации мы получим не сами символы (либо части символов, если речь о символах Юникода), а их числовые значения
  14 113
  15 >>> b[1]
  16 119
  17 >>> b[1] = 6    # Тип bytes - неизменяемый, прямо как строка
  18 Traceback (most recent call last):
  19   File "<stdin>", line 1, in <module>
  20 TypeError: 'bytes' object does not support item assignment

   1 >>> ф = '-абвг'    # К слову, идентификаторы не обязаны состоять именно из ascii-символов
   2 >>> a = '-абвг'    # Но мы изгаляться всё же не будем
   3 >>> bytes(a)    # Если строка содержит не-ASCII-символы, для преобразования её в bytes требуется указать кодировку, с помощью которой будет произведено кодирование
   4 Traceback (most recent call last):
   5   File "<stdin>", line 1, in <module>
   6 TypeError: string argument without an encoding
   7 >>> bytes(a, 'UTF-8')    # При этом в различных кодировках получим и различное байтовое представление: в UTF-8 на каждый символ в нашем примере будет отведено по 2 байта
   8 b'-\xd0\xb0\xd0\xb1\xd0\xb2\xd0\xb3'
   9 >>> bytes(a, 'KOI8-R')    # А в некоторых других кодировках - по одному
  10 b'-\xc1\xc2\xd7\xc7'
  11 >>> bytes(a, 'CP1251')
  12 b'-\xe0\xe1\xe2\xe3'
  13 

   1 >>> a = "Вопрос"    # Присылают вам письмо с вопросом, но не указывают, нарушая правила, кодировку, которую используют
   2 >>> a.encode("cp1251")    # Допустим, пользователь использовал кодировку cp1251
   3 b'\xc2\xee\xef\xf0\xee\xf1'
   4 >>> a.encode("cp1251").decode("koi8-r")    # А вы, как администратор на линуксе, со своей KOI8-кодировкой вместо "Вопрос" увидите:
   5 'бНОПНЯ'
   6 

   1 >>> dir(bytes)
   2 ['__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', 'center', 'count', 'decode', 'endswith', 'expandtabs', 'find', 'fromhex', 'hex', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower', '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']
   3 

   1 >>> b = b"12345678999"
   2 >>> b.hex()    # Обратите внимание на повторяющееся "39" в конце строки. И вообще видно, что цифры 1-9 в кодировке имеют номера с 31 по 39
   3 '3132333435363738393939'
   4 

   1 >>> b = bytearray("QWERTY")    # При создании bytearray из строки тоже нужно указывать кодировку
   2 Traceback (most recent call last):
   3   File "<stdin>", line 1, in <module>
   4 TypeError: string argument without an encoding
   5 >>> b = bytearray("QWERTY", "UTF-8")
   6 >>> b
   7 bytearray(b'QWERTY')
   8 >>> print(b)
   9 bytearray(b'QWERTY')
  10 >>> b[0]    # При индексации вы так же будете получать численное значение символа, а не сам символ
  11 81
  12 >>> b[1]
  13 87
  14 >>> b[4] = 32    # Вы можете изменять bytearray - однако помните, что вы работаете с численными значениями
  15 >>> b
  16 bytearray(b'QWER Y')
  17 >>> b[4] = '!'    # Присвоить напрямую желаемый символ не получится
  18 Traceback (most recent call last):
  19   File "<stdin>", line 1, in <module>
  20 TypeError: an integer is required
  21 >>> dir(bytearray)    # У bytearray тоже есть все строковые (и не только) методы
  22 ['__add__', '__alloc__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'capitalize', 'center', 'clear', 'copy', 'count', 'decode', 'endswith', 'expandtabs', 'extend', 'find', 'fromhex', 'hex', 'index', 'insert', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'pop', 'remove', 'replace', 'reverse', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
  23