Назад
 Начало |
 Учебные материалы |
Подразделы
Другие разделы
Дата и время
06/12/2025 04:22:07
Язык Python
Обзор Типы данных Переменные Операции и математические функции Управляющие конструкции Последовательности и коллекции Функции Классы Модули
Последовательности и коллекции
Операции над строками:
```run-python
print(ord('Ё')) # перевод символа в номер
print(chr(1025)) # перевод номера символа в символ
n=int("125") # преобразование строки в целое число
s1=str(n) # преобразование числа в строку
b1=bytes(str(n),encoding='utf-8') # преобразование в строку байтов
print(s1, b1)
s="string"
b=b"bytes"
s2="to be or not to be"
print(len(s), len(b)) # длина строки
print(s+s2, b+b"string") # сцепление строк
print(s*3, 3*b) # повторение строки
print('be' in s2, '2b' in s2, b'te' in b) # проверка наличия подстроки
print(s2.find('be'), s2.find('2b'), s2.rfind('be'), b.find(b'te')) # поиск первого и последнего вхождения
print(s2.count('o'), s2.count('be'), b.count(b't')) # количество появлений подстрок
print(s2.startswith('to'), s2.endswith('be'), b.startswith(b'by')) # строка начинается с ..., заканчивается на ...
```
Индексация и подстроки:
```run-python
s="строка"
print(s[2],s[-2]) # получение 2-го символа с начала (нумерация с 0), и 2-го символа с конца (нумерация с -1)
print(s[2:5]) # получение подстроки с 2 по 4 символы "рок"
print(s[2:]) # получение подстроки с 2 до конца строки "рока"
print(s[:5]) # получение подстроки с начала до 4 символа "строк"
print(s[-3:]) # получение подстроки 3 символа с конца до конца строки "ока"
print(s[:]) # вся строка
print(s[1:6:2]) # получение подстроки с шагом 2: "тоа"
print(s[-2:-6:-1]) # получение подстроки с шагом -1: "корт"
print(s[::-1]) # получение строки в обратном порядке "акортс"
b=b"bytes" # аналогично для строк байтов
print(b[2]) # но i-м элементом является целое число, а не символ
print(b[1:-2],b[::-1])
```
Преобразования и классификация символов (для строк из байтов тоже работает):
```run-python
s2="to be or not to be"
print(s2.split(), s2.split(' '), s2.split('o')) # разбиение на слова, по пробелу, по подстроке
print(s2.partition('or')) # разделение на 3 части по первому вхождению подстроки
print(s2.replace('to','2')) # заменить подстроку
print(s2.replace('be','bee',1)) # заменить подстроку 1 раз
a=['abc','x','sample']
a2={1,2,10}
print(''.join(a), '+'.join(str(x) for x in a2)) # соединение набора из строк
s="1239"
print(s.isdigit()) # только цифры
s="abc"
print(s.isalpha(), s.isupper(), s.islower()) # только буквы, прописные, строчные
print(s.upper(), "ABC".lower()) # в прописные или строчные буквы
print(f"|{s.center(7)}|{s.ljust(7)}|{s.rjust(7)}|{s.center(7,'*')}|") # выравнивание через функции
print(f"|{s:^7}|{s:<7}|{s:>7}") # выравнивание через формат
s=" abc "
print(f"|{s.strip()}|{s.lstrip()}|{s.rstrip()}|") # удаление пробелов с обеих сторон, слева или справа
```
#### Списки
Создание списка:
```run-python
s0=[] # или s0=list()
s1=[1,2,"abc"]
s2=[x*x for x in range(1,6)] # список квадратов чисел
s3=3*[1,2] # или [1,2]*3 - повтор списка
print(s0,s1,s2,s3)
s4=list({7,1,25,3}) # преобразование множества в список
s5=list("abac") # преобразование строки в список
s6=list(range(5)) # преобразование диапазона в список
print(s4,s5,s6)
```
Ввод и вывод:
```run-python
s6=[int(x) for x in input().split()] # ввод элементов списка через пробел
# функциональный способ: s6=list(map(int,input().split())) # какой из них "единственный очевидный"?
print(*s6) # вывод элементов через пробел
n=int(input()) # ввод размера списка
s7=[int(input()) for _ in range(n)] # и элементов списка на отдельных строках
print(*s7,sep='\n') # вывод элементов списка на отдельных строках
<<
1 7 10 3
4
11
12
13
14
```
Операции над списками:
```run-python
s1=['I',2,"third",4.5,'V','I']
print(len(s1)) # длина списка
print(s1[1],s1[-2]) # получение 1-го элемента с начала (нумерация с 0), и 2-го элемента с конца (нумерация с -1)
print(s1[1:4], s1[3:], s1[:-2], s1[::2]) # подсписки
print(s1[::-1]) # список в обратном порядке
s2=[1,12,7,-4]
print(s1+s2) # сцепление списков
print('V' in s1, s1.count(1)) # наличие элемента 'V', количество элементов равных 1
print(s1.index('V'),s1.index('I',3)) # поиск индекса элемента равного 'V', поиск элемента, начиная с 3-го
print(max(s2),min(s2),sum(s2)) # максимум, минимум и сумма
```
Операции изменения списка:
```run-python
s2=[1,12,7,-4]
s1=s2 # s1 указывает на тот же список
s1[1]=9 # изменение элемента
print(s2, s1) # изменится s2 и s1
s2.sort() # сортировка
print(s2, s1) # изменится s2 и s1
s1=s2[:] # копирование списка, также s1=s2.copy()
s2.sort(reverse=True) # сортировка в обратном порядке
print(s2, s1) # изменяется только s2
s2.reverse() # изменение порядка элементов
print(s2)
s2.append(7) # добавление элемента
print(s2)
s2.extend(s1) # добавление списка, также s2+=s1
print(s2)
del s2[2:5] # удаление части списка, также s[2:5]=[]
print(s2)
s2.clear() # удаление всех элементов, также s[:]=[]
print(s2)
s1*=3 # повтор последовательности
print(s1)
s1.remove(9) # удаление первого элемента равного 9
print(s1)
s1.insert(4,12) # вставка значение после 4-го элемента
print(s1)
print(s1.pop()) # удаление и возврат последнего элемента
print(s1)
print(s1.pop(2)) # удаление и возврат 2-го элемента
print(s1)
```
``bytearray`` имеет те же операции, но в качестве элементов могут быть только целые числа от 0 до 255, поэтому занимает меньше места в памяти и может выполнять операции быстрее, чем универсальный список.
```run-python
import math
N=1000000 # константа
p=bytearray(N+1) # первоначально все 0
p[0]=p[1]=1 # 0 и 1 не являются простыми
for i in range(2,math.isqrt(N)+1):
if p[i]==0: # не вычеркнуто => простое
for j in range(i*i, N+1, i): p[j]=1 # вычеркнуть числа, кратные i
print(f"Количество простых числе от 1 до {N} равно {p.count(0)}")
```
#### Кортежи
Кортежи похожи на список, но являются неизменяемым типом.
Создание кортежа:
```run-python
s0=() # или s0=tuple()
s1=(1,2,"abc")
s2=3*(1,2) # или (1,2)*3 - повтор кортежа
print(s0,s1,s2)
s3=tuple((x*x for x in range(1,6))) # преобразование генератора в кортеж
s4=tuple({7,1,25,3}) # преобразование множества в кортеж
s5=tuple("abac") # преобразование строки в кортеж
s6=tuple(range(5)) # преобразование диапазона в кортеж
print(s3,s4,s5,s6)
s7=tuple((int(x) for x in input().split())) # ввод элементов кортежа через пробел
print(*s7) # вывод элементов через пробел
<<
1 7 10 3
```
Операции над кортежами:
```run-python
s1=('I',2,"third",4.5,'V','I')
print(len(s1)) # длина кортежа
print(s1[1],s1[-2]) # получение 1-го элемента с начала (нумерация с 0), и 2-го элемента с конца (нумерация с -1)
print(s1[1:4], s1[3:], s1[:-2], s1[::2]) # подкортежи
print(s1[::-1]) # кортеж в обратном порядке
s2=(1,12,7,-4)
print(s1+s2) # сцепление кортежей
print('V' in s1, s1.count(1)) # наличие элемента 'V', количество элементов равных 1
print(s1.index('V'),s1.index('I',3)) # поиск индекса элемента равного 'V', поиск элемента, начиная с 3-го
print(max(s2),min(s2),sum(s2)) # максимум, минимум и сумма
```
#### Диапазоны
Диапазоны являются неизменяемым типом, с точки зрения математики это арифметические прогрессии, которые полностью определяются начальным значением, шагом и конечным значением (которое не входит в последовательность). Операции над диапазонами могут быть выполнены без перебора элементов по математическим формулам.
Создание и операции над диапазонами:
```run-python
s1=range(10)
s2=range(5,15)
s3=range(5,15,3) # c шагом 3
print(s1,s2,s3)
print(s3.start,s3.stop,s3.step) # свойства диапазона
print(len(s1), len(s2), len(s3)) # длины диапазонов
print(*s2) # печать элементов диапазона через пробел
print(*s3, sep='\n') # печать на отдельных строках
print(s2[1],s2[-2]) # получение 1-го элемента с начала (нумерация с 0), и 2-го элемента с конца (нумерация с -1)
print(s2[1:4], s2[3:], s2[:-2], s2[::2]) # поддиапазоны
print(s2[::-1]) # диапазон в обратном порядке
print(9 in s3, s3.count(8)) # наличие элемента, количество элементов равных 8 (варианты: 0 или 1)
print(s2.index(11)) # поиск индекса элемента равного 11
print(max(s2),min(s2),sum(s2)) # максимум, минимум и сумма
```
#### Генераторы
Генераторы позволяют создавать конечные и бесконечные последовательности, но в отличие от других последовательностей и коллекций можно получить только очередной элемент, нет длины и доступа по индексу. Сама последовательность не хранится, только способ получения очередных элементов.
Создание и операции над генераторами:
```run-python
s1=(x*x for x in range(1,6)) # квадраты чисел 1,4,9,16,25
print(9 in s1) # True, генератор передвинется на следующее число после 9
print(next(s1)) # 16
print(next(s1)) # 25
s2=iter([1,12,7]) # преобразование списка в генератор
print(next(s2))
print(next(s2))
print(next(s2))
try: print(next(s2)) # при завершении последовательности возникает ошибка StopIteration
except StopIteration: print('end')
s3=iter(input,'stop') # вызывать функцию без аргументов и возвращать её результат в качестве очередного значения, пока она не вернет указанное значение
print(next(s3))
print(next(s3))
<<
first
second
stop
```
#### Множества
Множества делятся на изменяемые ``set`` и неизменяемые ``frozenset``.
Множества (оба вида) могут включать в себя только неизменяемые типы данных -- bool, числа, строки, кортежи, frozenset.
Включение в множество значений изменяемого типа запрещено, так как распределение элементов в хэш-таблице идет по контрольной сумме значения, то изменяемые значения не будут найдены после изменений.
Все элементы множества – уникальны, повторяющиеся значения игнорируются. Элементы во множествах хранятся в неупорядоченном виде, и к ним нельзя обратиться по индексу. Операции поиска в множестве выполняются гораздо быстрее, чем в списке или кортеже.
Создание и ввод-вывод:
```run-python
s1=set() # пустое множество
s2={1,2,"abc",frozenset({7,'x'}),(3,1)}
s3={x*x for x in range(1,6)} # множество квадратов чисел
print(s1,s2,s3)
s4=set([7,1,3]) # преобразование списка в множество
s5=set("abac") # преобразование строки в множество
s6=set(range(5)) # преобразование диапазона в множество
print(s4,s5,s6)
s7={int(x) for x in input().split()} # ввод элементов множества через пробел
print(*s7) # вывод элементов (как попало) через пробел
print(*sorted(s7)) # вывод элементов в порядке возрастания через пробел
<<
1 7 10 3
```
Операции над множествами
```run-python
s1={1,7,5}
s2={7,5,1,10}
print(len(s1)) # количество элементов в множестве
print(7 in s2) # наличие элемента
print(max(s2),min(s2),sum(s2)) # максимум, минимум и сумма
print(s1==s2, s1<=s2, s1<s2, s1.isdisjoint(s2)) # сравнение множеств на равенство, проверки на подмножества, нет общих элементов
s1.add(10) # добавление элемента
print(s1)
s1.discard(10) # удаление элемента, если есть
print(s1)
s1.clear() # очистить множество
print(s1)
s1={2,5,10,4}
print(s1 | s2, s1 & s2, s1-s2, s1 ^ s2) # объединение, пересечение, разность и симметричная разность
s2|=s1 # добавление элементов другого множества, также работают s1&=s2, s1-=s2, s1^=s2
print(s2)
```
#### Словари
Словарь является ассоциативным массивом, в котором ключ (неизменяемого типа) сопоставлен с некоторым значением (без ограничений на тип).
Словари также реализованы на хэш-таблицах, как и множества, поэтому операции поиска выполняются очень эффективно. За счет хранения пар ключ-значение в отдельной таблице для уменьшения объема памяти, словарь сохраняет порядок добавления ключей при обходе с помощью for или при выводе в отличие от множества, где порядка нет.
Создание словаря:
```run-python
s0={} # или s0=dict()
s1={7:1,'x':2,'third':"abc"}
print(s0,s1)
s2={x*x:x for x in range(1,11)} # квадраты чисел от 1 до 10 -> числа: {1:1, 4:2, …, 100:10}
s3=dict(name='Alex', age=25, position='junior')
print(s2,s3)
s4=dict([('name','Jane'), ('age',23)]) # преобразование списка пар в словарь
s5=dict.fromkeys(range(5), 0) # преобразование последовательности в набор ключей, начальное значение 0
print(s4,s5)
```
Операции над словарями:
```run-python
d1={7:1,'x':2,'third':"abc"}
print(len(d1)) # количество пар в словаре
print(d1[7], d1['x'], 'x' in d1) # получение значения, проверка наличия ключа
d1[10]=2 # добавление значения
d1.setdefault(11, 0) # добавление значения, если его нет
d1.setdefault(7, 0)
print(d1)
print(d1.get(7,'нет'),d1.get(6,'нет')) # получение значения по ключу, если нет, то вернуть 2-й аргумент
del d1[10] # удаление пары по ключу
print(d1)
print(d1.keys(),d1.values(),d1.items()) # получение всех ключей, значений, пар ключ-значение
print(d1.popitem()) # удаление последней пары и возврат её
print(d1)
d2=d1.copy() # создание копии
d2.clear() # очистка словаря
d2={'x':6,"four":5}
print(d1|d2) # объединение словарей
d1|=d2 # добавление значений из другого словаря
print(d1)
```
