Python имеет несколько встроенных структур данных. Если вы все еще задаетесь вопросом, что такое структура данных, то это не что иное, как способ хранения данных и наличие определенных методов для извлечения или манипулирования ими. Мы уже видели списки ранее, теперь мы углубимся в детали.
Списки
>>> a = [23, 45, 1, -3434, 43624356, 234]
>>> a.append(45)
>>> a
[23, 45, 1, -3434, 43624356, 234, 45]
Сначала мы создали список a. Затем, чтобы добавить 45 в конец списка, мы вызываем метод a.append(45). Вы можете видеть, что 45 добавлен в конец списка. Иногда может потребоваться вставить данные в любое место внутри списка, для этого у нас есть метод insert().
>>> a.insert(0, 1) # 1 добавлен в 0-ю позицию списка
>>> a
[1, 23, 45, 1, -3434, 43624356, 234, 45]
>>> a.insert(0, 111)
>>> a
[111, 1, 23, 45, 1, -3434, 43624356, 234, 45]
count(s) вернет вам количество раз, когда s встречается в списке. Здесь мы проверяем, сколько раз 45 встречается в списке.
>>> a.count(45)
2
Если вы хотите удалить любое конкретное значение из списка, вы должны использовать метод remove().
>>> a.remove(234)
>>> a
[111, 1, 23, 45, 1, -3434, 43624356, 45]
Теперь, чтобы перевернуть весь список
>>> a.reverse()
>>> a
[45, 43624356, -3434, 1, 45, 23, 1, 111]
Мы можем хранить что угодно в списке, поэтому сначала мы собираемся добавить другой список b в a, затем мы узнаем, как добавить значения b в a.
>>> b = [45, 56, 90]
>>> a.append(b)
>>> a
[45, 43624356, -3434, 1, 45, 23, 1, 111, [45, 56, 90]]
>>> a[-1]
[45, 56, 90]
>>> a.extend(b) # Чтобы добавить значения b, а не сам b
>>> a
[45, 43624356, -3434, 1, 45, 23, 1, 111, [45, 56, 90], 45, 56, 90]
>>> a[-1]
90
Выше вы можете увидеть, как мы использовали метод a.extend() для расширения списка. Для сортировки любого списка у нас есть метод sort().
>>> a.sort()
>>> a
[-3434, 1, 1, 23, 45, 45, 45, 56, 90, 111, 43624356, [45, 56, 90]]
Вы также можете удалить элемент в любой конкретной позиции списка, используя ключевое слово del.
>>> del a[-1]
>>> a
[-3434, 1, 1, 23, 45, 45, 45, 56, 90, 111, 43624356]
Использование списков как стека и очереди
Стеки часто известны как структура LIFO (Last In First Out). Это означает, что данные будут входить в него в конец, и последние данные будут выходить первыми. Самый простой пример — это пара шариков в трубе с одним закрытым концом. Так что если вы хотите достать шарики из нее, вам придется сделать это с конца, куда вы положили последний шарик. Чтобы достичь того же в коде
>>> a
[1, 2, 3, 4, 5, 6]
>>> a.pop()
6
>>> a.pop()
5
>>> a.pop()
4
>>> a.pop()
3
>>> a
[1, 2]
>>> a.append(34)
>>> a
[1, 2, 34]
Мы узнали о новом методе выше pop(). pop(i) извлекает i-й элемент из списка.
В нашей повседневной жизни мы сталкиваемся с очередями много раз, например, на билетных кассах или в библиотеке, или в кассе любого супермаркета. Очередь — это структура данных, в которую можно добавлять данные в конец и извлекать данные из начала. Вот почему она известна как FIFO (First In First Out).
>>> a = [1, 2, 3, 4, 5]
>>> a.append(1)
>>> a
[1, 2, 3, 4, 5, 1]
>>> a.pop(0)
1
>>> a.pop(0)
2
>>> a
[3, 4, 5, 1]
Чтобы извлечь первый элемент списка, мы используем a.pop(0).
List Comprehensions
List comprehensions предоставляют лаконичный способ создания списков. Каждая list comprehension состоит из выражения, за которым следует предложение for, а затем ноль или более предложений for или if. Результатом будет список, полученный в результате оценки выражения в контексте предложений for и if, которые следуют за ним.
Например, если мы хотим создать список из квадратных значений другого списка, то
>>> a = [1, 2, 3]
>>> [x ** 2 for x in a]
[1, 4, 9]
>>> z = [x + 1 for x in [x ** 2 for x in a]]
>>> z
[2, 5, 10]
Выше во втором случае мы использовали две list comprehensions в одной строке.
Кортежи
Кортежи — это данные, разделенные запятой.
>>> a = 'Fedora', 'Debian', 'Kubuntu', 'Pardus'
>>> a
('Fedora', 'Debian', 'Kubuntu', 'Pardus')
>>> a[1]
'Debian'
>>> for x in a:
... print(x, end=' ')
...
Fedora Debian Kubuntu Pardus
Вы также можете распаковать значения любого кортежа в переменные, например:
>>> divmod(15,2)
(7, 1)
>>> x, y = divmod(15,2)
>>> x
7
>>> y
1
Кортежи неизменяемы, это означает, что вы не можете удалять/добавлять/изменять какое-либо значение внутри кортежа. Вот еще один пример:
>>> a = (1, 2, 3, 4)
>>> del a[0]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object doesn't support item deletion
Выше вы можете видеть, что Python выдает ошибку, когда мы пытаемся удалить значение в кортеже.
Чтобы создать кортеж, содержащий только одно значение, вы должны ввести завершающую запятую.
>>> a = (123)
>>> a
123
>>> type(a)
<type 'int'>
>>> a = (123, ) #Обратите внимание на завершающую запятую
>>> a
(123,)
>>> type(a)
<type 'tuple'>
Используя встроенную функцию type(), вы можете узнать тип данных любой переменной. Помните функцию len(), которую мы использовали для определения длины любой последовательности?
>>> type(len)
<type 'builtin_function_or_method'>
Множества
Множества — это еще один тип структуры данных без повторяющихся элементов. Мы также можем выполнять математические операции над множествами.
>>> a = set('abcthabcjwethddda')
>>> a
set(['a', 'c', 'b', 'e', 'd', 'h', 'j', 't', 'w'])
И несколько примеров операций над множествами
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a # уникальные буквы в a
set(['a', 'r', 'b', 'c', 'd'])
>>> a - b # буквы в a, но не в b
set(['r', 'd', 'b'])
>>> a | b # буквы либо в a, либо в b
set(['a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'])
>>> a & b # буквы и в a, и в b
set(['a', 'c'])
>>> a ^ b # буквы в a или b, но не в обоих
set(['r', 'd', 'b', 'm', 'z', 'l'])
Для добавления или удаления значений из множества
>>> a
set(['a', 'c', 'b', 'e', 'd', 'h', 'j', 'q', 't', 'w'])
>>> a.add('p')
>>> a
set(['a', 'c', 'b', 'e', 'd', 'h', 'j', 'q', 'p', 't', 'w'])
Словари
Словари представляют собой неупорядоченный набор ключ: значение, где ключи уникальны. Мы объявляем словари с помощью фигурных скобок {}. Мы используем словари для хранения данных по определенному ключу и последующего их извлечения.
>>> data = {'kushal':'Fedora', 'kart_':'Debian', 'Jace':'Mac'}
>>> data
{'kushal': 'Fedora', 'Jace': 'Mac', 'kart_': 'Debian'}
>>> data['kart_']
'Debian'
Мы можем добавлять данные в словарь просто так:
>>> data['parthan'] = 'Ubuntu'
>>> data
{'kushal': 'Fedora', 'Jace': 'Mac', 'kart_': 'Debian', 'parthan': 'Ubuntu'}
Для удаления конкретной пары ключ:значение:
>>> del data['kushal']
>>> data
{'Jace': 'Mac', 'kart_': 'Debian', 'parthan': 'Ubuntu'}
Чтобы проверить, существует ли определенный ключ в словаре, можно использовать ключевое слово in.
>>> 'Soumya' in data
False
Вы должны помнить, что изменяемый объект не может быть ключом, это означает, что вы не можете использовать список в качестве ключа.
dict() может создавать словари из кортежей ключ,значение.
>>> dict((('Indian','Delhi'),('Bangladesh','Dhaka')))
{'Indian': 'Delhi', 'Bangladesh': 'Dhaka'}
Если вы хотите перебрать словарь, используйте метод iteritems().
>>> data
{'Kushal': 'Fedora', 'Jace': 'Mac', 'kart_': 'Debian', 'parthan': 'Ubuntu'}
>>> for x, y in data.iteritems():
... print("%s использует %s" % (x, y))
...
Kushal использует Fedora
Jace использует Mac
kart_ использует Debian
parthan использует Ubuntu
Многие разы случается, что мы хотим добавить больше данных к значению в словаре, и если ключ не существует, то добавить некоторое значение по умолчанию. Вы можете это сделать эффективно, используя dict.setdefault(key, default).
>>> data = {}
>>> data.setdefault('names', []).append('Ruby')
>>> data
{'names': ['Ruby']}
>>> data.setdefault('names', []).append('Python')
>>> data
{'names': ['Ruby', 'Python']}
>>> data.setdefault('names', []).append('C')
>>> data
{'names': ['Ruby', 'Python', 'C']}
Когда мы пытаемся получить значение по ключу, который не существует, мы получаем KeyError. Мы можем использовать dict.get(key, default) для получения значения по умолчанию, когда ключ не существует.
>>> data['foo']
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'foo'
>>> data.get('foo', 0)
0
Если вы хотите перебрать список (или любую последовательность) и получить номер итерации одновременно, вы должны использовать enumerate().
>>> for i, j in enumerate(['a', 'b', 'c']):
... print(i, j)
...
0 a
1 b
2 c
Вам также может понадобиться перебрать две последовательности одновременно, для этого используйте функцию zip().
>>> a = ['Pradeepto', 'Kushal']
>>> b = ['OpenSUSE', 'Fedora']
>>> for x, y in zip(a, b):
... print("%s использует %s" % (x, y))
...
Pradeepto использует OpenSUSE
Kushal использует Fedora
students.py
В этом примере вам нужно ввести количество студентов, затем запросить оценки по трем предметам: «Физика», «Математика», «История». Если общая сумма баллов для любого студента меньше 120, то вывести, что он не сдал, иначе — что сдал.
#!/usr/bin/env python3
n = int(input("Введите количество студентов:"))
data = {} # здесь мы будем хранить данные
subjects = ('Физика', 'Математика', 'История') # все предметы
for i in range(0, n): # для n количества студентов
name = input('Введите имя студента %d: ' % (i + 1)) # Получить имя студента
marks = []
for x in subjects:
marks.append(int(input('Введите оценки по %s: ' % x))) # Получить оценки по предметам
data[name] = marks
for x, y in data.items():
total = sum(y)
print("%s — общий балл %d" % (x, total))
if total < 120:
print("%s не сдал :(" % x)
else:
print("%s сдал :)" % x)
Результат
[kd@kdlappy book]$ ./students.py
Введите количество студентов:2
Введите имя студента 1: Бабай
Введите оценки по Физике: 12
Введите оценки по Математике: 45
Введите оценки по Истории: 40
Введите имя студента 2: Тесла
Введите оценки по Физике: 99
Введите оценки по Математике: 98
Введите оценки по Истории: 99
Бабай — общий балл 97
Бабай не сдал :(
Тесла — общий балл 296
Тесла сдал :)
matrixmul.py
В этом примере мы умножим две матрицы. Сначала мы введем количество строк/столбцов в матрице (здесь мы предполагаем, что используем матрицу n x n). Затем значения матриц.
#!/usr/bin/env python
n = int(raw_input("Введите значение n: "))
print("Введите значения для матрицы A")
a = []
for i in range(0, n):
a.append([int(x) for x in raw_input("").split(" ")])
print("Введите значения для матрицы B")
b = []
for i in range(0, n):
b.append([int(x) for x in raw_input("").split(" ")])
c = []
for i in range(0, n):
c.append([a[i][j] * b[j][i] for j in range(0,n)])
print("После умножения матриц")
print("-" * 10 * n)
for x in c:
for y in x:
print("%5d" % y, end=' ')
print("")
print("-" * 10 * n)
Результат
[kd@kdlappy book]$ ./matrixmul.py
Введите значение n: 3
Введите значения для матрицы A
1 2 3
4 5 6
7 8 9
Введите значения для матрицы B
9 8 7
6 5 4
3 2 1
После умножения матриц
------------------------------
9 12 9
32 25 12
49 32 9
------------------------------
Здесь мы использовали генераторы списков несколько раз. [int(x) for x in raw_input(“”).split(” ”)] сначала принимает ввод как строку с помощью raw_input(), затем разделяет результат по пробелу, затем для каждого значения создает одно целое число. Мы также используем [a[i][j] * b[j][i] for j in range(0,n)] для получения результирующей строки в одной строке.