Строки имеют "методы". После выражения, являющегося строкой, можно поставить точку и вызвать "метод", у метода указывается название и обязательно ставятся скобки. В скобках иногда нужно указывать дополнительные аргументы.
print("abcXYZ".capitalize())
print("xyz".center(9, "-")) # поставить по центру
# можно не указывать символы
print("banana".count("a")) # посчитать, сколько раз встретилось
print("Hello, World!".startswith("Hell"))
print("Hello, World!".endswith("orld!")) # логический результат
print("Hello, World!".find("o")) # индекс первого вхождения, с 0
Abcxyz ---xyz--- 3 True True 4
Форматирование строки можно делать с помощью функции format, она аналогична тому, как мы делали форматирование с помощью f-строчек.
f"Hello, {name}!"
. В принципе, f-строчек часто достаточно, про format нужно знать, потому что его часто используют другие. Для строчек есть еще оператор %
. Он тоже используется для форматирования, но он устарел, просьба избегать его.
print("Hello, {} {}!".format("Ilya", "Posov"))
# обычно достаточно пустых фигурных скобок, но если аргумент нужно
# использовать несколько раз, в скобках можно написать номер
# аргумента
print("Hello, {0} {1}! {0}".format("Ilya", "Posov"))
print("Hello, %s %s!" % ("Ilya", "Posov"))
# наш способ
name = "Ilya"
surname = "Posov"
print(f"Hello, {name} {surname}!")
Hello, Ilya Posov! Hello, Ilya Posov! Ilya Hello, Ilya Posov! Hello, Ilya Posov!
Еще примеры методов:
isalpha
- верно ли, что все символы это буквы?isdigit
- верно ли, что все символы это цифры?islower
, isupper
, istitle
- всё нижний рег., всё верхний рег., первая буква заглавная, последние строчные.lower
, upper
, title
- сделать всё нижним или верхним регистром, сделать каждое слово с заглавной.Методы для удаления или добавления пробелов в конце и начале строки:
print("ABC".ljust(10, '-')) # можно не указывать заполнитель
print("ABC".rjust(10, '-'))
print("---ABC---".rstrip("-")) # если не указывать символ,
print("---ABC---".lstrip("-")) # то удаляются пробельные символы
print("---ABC---".strip("-"))
ABC------- -------ABC ---ABC ABC--- ABC
Методы для соединения и разделения строк:
# получить список элементов, которые разделялись указанной строкой
print("несколько слов по-русски".split(' '))
print("abc, xyz, pqrst".split(', '))
print("abc, xyz, pqrst".split(','))
['несколько', 'слов', 'по-русски'] ['abc', 'xyz', 'pqrst'] ['abc', ' xyz', ' pqrst']
Есть еще метод splitlines
, который разделяет по переводам строк. Т.е. если дана строка из нескольких строк, вернется список строк, которые были в строке.
# объединение списков или других типов-последовательностей в строку
print("+".join(["a", "aa", "bc"]))
print("--".join("a++b++c".split("++")))
a+aa+bc a--b--c
А теперь примеры, как можно комбинировать методы друг с другом:
s = "abc"
print((s + "**").upper()) # не обязательно примянять к литералу
print("abc xyz".upper().split())
print("ABC".find("BC") + 10)
t = "Abc"
print(t.isupper() or t.islower())
ABC** ['ABC', 'XYZ'] 11 False
Последовательность произвольных значений. Значения могут быть разных типов, и эту последовательность можно изменять.
a = [1, 2, 3, 4]
b = ["abc", "xyz"]
empty = []
l = [1, "text", True, 42, [1, 2, 3]] # типы м.б. разные
Значения списка перечисляются через запятую в квадратных скобках.
Тьюплы, как и списки, содержат последовательность значений. Но, в отличие от списков, тьюплы неизменяемые: у них фиксированная длина, в них нельзя добавить элемент и т.п.
Создаются тьюплы оператором "запятая". Т.е. надо поставить запятую, а скобки - не обязательно. Можно ставить универсальные круглые скобки, чтобы показать, какие значения попадают в тьюпл.
a = 1, 2
b = "abc", 10, True
print(b)
c = 10, # тьюпл из одного элемента, ставим в конце запятую
print(c)
# c + 1 -- ошибка
('abc', 10, True) (10,)
r1 = range(10) # числа от 0 до 9 (10 не включается)
r2 = range(1, 10) # числа от 1 до 9
r3 = range(1, 10, 2) # от 1 до 10 с шагом 2. Т.е. это нечетные
Чаще всего этот тип используется в циклах для перебора чисел.
print(10 in [10, 20, 30]) # Оператор in - проверка вхождения
print(10 in (10, 20, 30)) # аналогично для tuple
print("b" in "abc") # для строк
print("bc" in "abcd") # для строк умеет проверять не только один
# элемент, а вхождение подстроки
print(11 not in [10, 20, 30]) # оператор not in, проверка, что не
# Оператор +
print([10, 20, 30] + [40, 50, 60])
print((10, 20, 30) + (40, 50, 60))
print("abc" + "xyz")
# Умножение на число
print([10, 20, 30] * 3)
print(3 * [10, 20, 30])
print(3 * "abc")
True True True True True [10, 20, 30, 40, 50, 60] (10, 20, 30, 40, 50, 60) abcxyz [10, 20, 30, 10, 20, 30, 10, 20, 30] [10, 20, 30, 10, 20, 30, 10, 20, 30] abcabcabc
l = [10, 20, 30, 40]
s = "python language"
print(l[0]) # обращаемся по индексу, индексы с 0
print(l[1])
print(s[0])
print(s[1])
print(l[-1]) # последний элемент
print(l[-2]) # предпоследний элемент
10 20 p y 40 30
print(l[2:4]) # со второго по четвертый элемент, не включительно
print(s[3:12]) # c 3 по 11
print(s[3:-1]) # по последний не влкючительно
print(s[10:]) # не указываем конец, значит, до конца
print(s[:10]) # с начала
print(s[:]) # можно с начала до конца
print(s[1:10:2]) # с первого по десятый с шагом 2
print(s[::2]) # с начала до конца с шагом 2
print(s[::-1]) # с конца в начало
print(l[::-1]) # с конца в начало
[30, 40] hon langu hon languag guage python lan python language yhnln pto agae egaugnal nohtyp [40, 30, 20, 10]
len
- длина последовательностиmin
и max
- ищут минимальный и максимальный элемент пос-ти.s.index()
и s.count()
- см. список методов для строк.Из изменяемых типов пока мы знаем только списки.
l = [10, 20, 30, 40, 50]
l.append(60) # приписать 60 в конец списка
# l.clear() # очистить
l += [70, 80] # приписать список в конец, а потом присвоить
print(l)
l[0] = 11
l[1:3] = [22, 33, 44] # заменить первый и второй элементы
print(l)
l.reverse() # перевернуть
l.insert(3, 100) # вставить элемент 100 по индексу 3
del l[10:12] # удалить 10-ый и 11 элементы
print(l)
del l[5]
print(l)
[10, 20, 30, 40, 50, 60, 70, 80] [11, 22, 33, 44, 40, 50, 60, 70, 80] [80, 70, 60, 100, 50, 40, 44, 33, 22, 11] [80, 70, 60, 100, 50, 44, 33, 22, 11]