Что такое питон простыми словами
Для того чтобы понять, что такое Python нужно разобраться зачем вообще нужны языки программирования. Они нужны для взаимодействия человека и компьютера. Между собой люди общаются на естественном языке.
Язык программирования Python
Питон является относительно простым высокоуровневым скриптовым языком, который служит для создания различных сценариев. Это означает, что для программирования на Python, не требуется знания машинных кодов — команд для компьютера.
Программирование при помощи машинных кодов ускоряет программу, но очень трудоемко и требует хорошего знания архитектуры компьютера. Одним из таких низкоуровневых языков является ассемблер. Чаще всего низкоуровневое программирование используется в промышленности для специализированных контроллеров, где нет большого объема памяти.
Python может использоваться для программирования контроллеров в станках ЧПУ и в робототехнике. Популярный во всем мире одноплатный микрокомпьютер Raspberry Pi также программируется на питоне. С помощью «малинки» можно программировать роботов, умные дома, квадрокоптеры и множество других вещей. Pi в названии миникомпьютера обозначает, что программирование происходит на Python.
одноплатный микрокомпьютер Raspberry Pi
На языке высокого уровня нужно уметь программировать при помощи понятий, обозначаемых словами. Чаще всего это английский язык, но есть и примеры кодирования на других языках. Например, программу «Бухгалтерия 1С» можно редактировать и изменять на русском.
Питон поддерживает объектно-ориентированное программирование и является интерпретируемым языком. Это означает, что программа выполняется построчно и для ее выполнения на компьютере должен быть установлен интерпретатор. Самым распространенным и популярным интерпретатором является CPython.
Массивы
В массивах «array» хранятся однотипные данные, структурированные определенным образом. Они похожи на списки, но ограничены размером и типом входных данных. Для создания нового массива нужно импортировать библиотеку, которая может с ним работать. Ячейки массива имеют одинаковый размер.
одномерные и многомерные массивы в Python
Массивы бывают одномерными, двумерными, многомерными. Размерность массива можно изменять, поэтому предусмотрена функции, позволяющие измерить его размер. В массиве можно добавлять и удалять элементы.
В качестве примера приведу синтаксис метода для списка: spisok . append (аргумент), где аргументом могут быть данные любого типа и аргумент является обязательным. Название метода записывается после названия списка через точку «. append». Этот метод принимает только один аргумент и вставляет его в конец списка. Синтаксис других методов аналогичен.
Предварительные требования
Для работы с этим кратким руководством необходимо следующее.
-
База данных SQL на одной из следующих платформ:
- Службы машинного обучения SQL Server. Сведения об установке см. в руководстве по установке для Windows или руководстве по установке для Linux.
- Кластеры больших данных SQL Server. Применение служб машинного обучения в кластерах больших данных SQL Server.
- Службы машинного обучения в управляемом экземпляре SQL Azure. Дополнительные сведения см. в статье Общие сведения о службах машинного обучения в управляемом экземпляре SQL Azure.
-
Средство для выполнения SQL-запросов, содержащих сценарии Python. В этом кратком руководстве используется Azure Data Studio.
Вложенный список понимание
списки Python также могут быть вложены.
В следующем примере показан список 3X4 матрицы:
>>> matrix = , ... , ... , ... ]
В следующем примере перечислены 3×4 матрицы к списку преобразования 4×3:
>>> for row in matrix] for i in range(4)] , , , ]
Следующие примеры также можно использовать следующие методы:
>>> transposed = [] >>> for i in range(4): ... transposed.append( for row in matrix]) ... >>> transposed , , , ]
Другой метод:
>>> transposed = [] >>> for i in range(4): ... # the following 3 lines implement the nested listcomp ... transposed_row = [] ... for row in matrix: ... transposed_row.append(row) ... transposed.append(transposed_row) ... >>> transposed , , , ]
Dictionaries
Словари – структура данных такая как Map в Java. Элементы хранятся как пары “ключ – значение“. Словарь записывается в фигурные скобки {} . Доступ к элементу осуществляется по ключу. Опять же в силу динамической типизации в одном словаре могут хранится разнотипные значения.
my_map = {‘k1’:1, ‘k2′:’Igor’,’k3′:}
print(my_map) # вывод списка, который лежит в словаре в обратном порядке
# Вывод
|
1 |
my_map={‘k1’1,’k2»Igor’,’k3’1,2,3} print(my_map’k3′::-1)# вывод списка, который лежит в словаре в обратном порядке # Вывод 3,2,1 |
Как видите из примера, синтаксис языка очень прост и понятен. Позволяет делать сложные операции в одной строке.
5.7. Подробнее об условиях¶
Условия, используемые в операторах и , могут содержать
операции, а не только операции сравнения.
Операции сравнения и проверяют, встречается значение в
последовательности или нет. Операторы и проверяют, не
являются ли два объекта на самом деле одним и тем же (это имеет смысл
лишь для изменяемых объектов, таких как списки). Все операции сравнения
имеют один и тот же приоритет, меньший чем у любых операций над числами.
Сравнения могут быть связаны цепочкой. Например, проверяет, является
ли меньше и при этом равно .
Сравнения могут быть объединены с использованием логических операторов
и , а результат сравнения (или любого другого логического выражения)
может отрицать . Они имеют более низкие приоритеты, чем
операторы сравнения; среди них у имеет наивысший приоритет и
наименьший, так что эквивалентен . Как всегда, явно
заданные скобки помогут выразить желаемый порядок выполнения операций.
Логические операторы и являются так называемыми
короткозамкнутые операторы: их операнды вычисляются слева
направо и вычисление заканчивается как только результат становится определён (очевиден).
Например, если и
True, а false, не вычисляет выражение
. Короткозамкнутый оператор возвращает последний элемент, который был
вычислен, что может быть применено не только в целях задания логики.
Можно присвоить результат сравнения, или другого булева выражения, переменной. Например:
>>> string1, string2, string3 = '', 'Trondheim', 'Hammer Dance' >>> non_null = string1 or string2 or string3 >>> non_null 'Trondheim'
Делаем свой ассоциативный массив
Реализация будет очень простой — связный список из пар «ключ — значение». Например, эквивалент ассоциативного массива
{12,34} будет
(1,2),(3,4). Она значительно медленнее встроенной: например, поиск значения элемента по ключу будет требовать O(n) операций, в то время как встроенная требует O(1). Для демонстрации, впрочем, вполне сойдет.
Свой класс мы назовем
Assoc. Определим класс и его конструктор:
|
1 |
classAssoc(object) def __init__(self,contents=) self._contents=contents |
Для удобства тестирования мы сделали, чтобы начальное значение можно было передать в конструкторе, вроде
Assoc((1,2),(3,4)).
Теперь приступим к магии! Будем считать, что код мы сохранили в файл
assoc.py.
Реализация Pipeline как класса Python
Теперь, когда мы рассмотрели основы классов и пользовательских операторов в Python, давайте использовать их для реализации нашего конвейера (pipeline). Конструктор принимает три аргумента: functions, input и terminals. Аргумент «functions» это одна или несколько функций. Эти функции являются этапами в конвейере, которые работают с входными данными.
Аргумент «input» это список объектов, над которыми работает конвейер. Каждый элемент input будет обрабатываться всеми функциями конвейера. Аргумент «terminal» это список функций и когда встречается одна из них, конвейер пропускает их через себя и возвращает результат. Terminals по умолчанию используют только функцию печати (в Python 3, «print» является функцией).
Обратите внимание, что внутри конструктора, к terminals добавляется таинственная «Ω». Я объясню это позже
Конструктор конвейера
Вот определение класса и конструктора :
Python 3 полностью поддерживает Unicode в названиях идентификаторов. Это означает, что мы можем использовать классные символы типа «Ω» для названий переменных и функций. Здесь я объявил функцию тождества, называемую «Ω», которая служит в качестве терминальной функции:
Я мог бы использовать и традиционный синтаксис:
Операторы «__or__» и «__ror__»
Здесь идет ядро класса Pipeline. Чтобы использовать «|» (символ вертикальной черты), нам нужно переопределить пару операторов. Символ «|» используется Python для битовых или целых чисел. В нашем случае мы хотим переопределить это для реализации цепочки функций, а также для подачи ввода в начале конвейера. Это две отдельные операции.
Оператор «__ror__» вызывается, когда второй операнд является экземпляром конвейера Pipeline, а первый не является. Он рассматривает первый операнд как входной и сохраняет его в атрибуте и возвращает экземпляр Pipeline обратно (себе). Это позволяет позже связывать больше функций.
Вот пример, где будет вызываться оператор :
Оператор «__or__» вызывается, когда первый операнд является конвейером (даже если второй операнд также является конвейером). Он принимает операнд как вызываемую функцию и это доказывает, что операнд «func» действительно является вызываемым.
Затем он добавляет функцию в атрибут и проверяет, является ли функция одной из функций terminal. Если это terminal, весь конвейер просчитывается и возвращается результат. Если это не terminal, возвращается сам конвейер.
Оценка Pipeline
При добавлении в конвейер больше и больше не-терминальных функций, ничего не происходит. Фактическая оценка отложена до тех пор, пока не будет вызван метод . Это может произойти либо путём добавления терминальной функции в конвейер, либо путём прямого вызова .
Оценка состоит из итерации по всем функциям в конвейере (включая терминальную функцию, если она есть) и их выполнение по порядку на выходе предыдущей функции. Первая функция в конвейере получает элемент ввода.
Массивы
Массив в Python – это также линейная структура данных, в которой хранятся данные. Он также упорядочен, изменяем и заключен в квадратные скобки. Он может хранить неуникальные элементы. Но есть ограничения на хранение значений разных типов данных.
Для работы с массивом в Python нам нужно импортировать либо модуль массива, либо Numpy.
import array as arr or import numpy as np
Элементы размещаются в непрерывной области памяти, что позволяет нам легко изменять, добавлять, удалять и получать доступ к элементу. Более того, нам нужно указать тип данных. Давайте разберемся в следующих примерах.
Пример – 1
Import array as arr
array_1 = arr.array("i", )
print(array_1)
print(type(array_1))
Выход:
array('i', )
<class 'array.array'>
Пример – 2: Использование массива Numpy
import numpy as np array_sample = np.array() print(array_sample) print(type(array_sample))
Выход:
<class 'numpy.ndarray'>
Мы указали тип строки и сохранили строковое значение.
Стеки и потоки Python
Мы также можем использовать стек Python в многопоточной программе. Это сложная тема, но она используется не часто, поэтому вы можете пропустить этот раздел, если вас не интересует многопоточность.
Список и двухсторонняя очередь ведут себя по-разному, если мы используем многопоточность в нашей программе. Использование списка в многопоточном программировании не является потокобезопасным.
С другой стороны, двухсторонняя очередь немного сложна, потому что ее методы append() и pop() являются атомарными, что означает, что они не будут прерываться другим потоком.
Мы можем построить многопоточную программу, используя двухстороннюю очередь, но это может вызвать некоторые сложности в будущем. Теперь возникает вопрос, как мы можем построить программу из стека Python с потоковой передачей.
Ответ заключается в том, что мы можем использовать LIFOqueue, и мы знаем, что LIFO означает Last In First Out. Он использует put() и gets() для добавления и удаления элемента стека.
Лучший выбор по умолчанию: collections.deque
Если нет необходимости параллельной обработки (или ручной блокировки и разблокировки), то выбор сводится к встроенному типу или . Разница заключается в структуре данных «под капотом» и в простоте использования.
- есть динамический массив, который отлично подходит для быстрого произвольного доступа, но требует периодического изменения размера при добавлении или удалении элементов. Список перераспределяет свое пространство хранения, так что не каждый или требует изменения размера, обеспечивая производительность . Но нужно быть осторожным при вставке и удалении элементов только справа ( и ), иначе произойдёт снижение производительности до .
- является двусвязным списком, который оптимизирован для добавления и удаления с любой стороны и обеспечивает одинаковую производительность для этих операций. Производительность не только стабильна, но и сам класс проще, поскольку не нужно беспокоиться о добавлении или удалении элементов с «неправильного конца».
Что такое стек в Python?
Стек в Python – это линейная структура данных, в которой данные расположены объектами друг над другом. Он хранит данные в режиме LIFO (Last in First Out). Данные хранятся в том же порядке, в каком на кухне тарелки располагаются одна над другой. Мы всегда выбираем последнюю тарелку из стопки тарелок. В стеке новый элемент вставляется с одного конца, и элемент может быть удален только с этого конца.
Простым примером стека является функция «Отменить» в редакторе. Функция отмены работает с последним выполненным нами событием. Мы можем выполнять две операции в стеке – PUSH и POP. Операция PUSH – это когда мы добавляем элемент, а операция POP – когда мы удаляем элемент.
String
Python имеет очень сильную поддержку и простоту в работе со строками. Как и в Java, объекты Sting являются неизменяемыми (Immutable). Строку можно записывать как в одинарные кавычки, так и в двойные, и тройные, и любое другое количество кавычек, даже 7:
s1 = «Igor ivanovich»
s2 = ‘Igor Ivanovich’
s3 = «»»Igor Ivanovich»»»
s4 = «»»»»»»Igor Ivanovich»»»»»»»
print(s1)
print(s2)
print(s3)
print(s4)
# Вывод
Igor ivanovich
Igor Ivanovich
Igor Ivanovich
Igor Ivanovich
|
1 |
s1=»Igor ivanovich» s2=’Igor Ivanovich’ s3=»»»Igor Ivanovich»»» s4=»»»»»»»Igor Ivanovich»»»»»»» print(s1) print(s2) print(s3) print(s4) # Вывод Igor ivanovich Igor Ivanovich Igor Ivanovich Igor Ivanovich |
Интересной особенностью Python в работе как со строками так и со списками, является индексирование. Оно двунаправленное: от 0 до длины строки – 1, и в обратную сторону от -1 до -длины строки:
s1 = «Igor vanovich»
print(s1)
print(s1)
#Вывод
I
h
|
1 |
s1=»Igor vanovich» print(s1) print(s1-1) #Вывод |
Классной фичей языка является метод “нарезки” (slicing) – получение подстроки, перебор всех элементов списка с определенным шагом с определенной позиции. Прозрачный и простой синтаксис. Рассмотрим на примере и сразу все будет ясно:
s1 = «Igor_ivanovich»
print(s1) # Получение строки начиная с символа индекса 1
print(s1) # Получение подстроки с индекса 1 (включительно) по индекс 5 (не включая)
print(s1) # вывод строки в обратном порядке
print(s1) # вывод строки с шагом 2
#Вывод
gor_ivanovich
gor_
hcivonavi_rogI
Io_vnvc
|
1 |
s1=»Igor_ivanovich» print(s11)# Получение строки начиная с символа индекса 1 print(s115)# Получение подстроки с индекса 1 (включительно) по индекс 5 (не включая) print(s1::-1)# вывод строки в обратном порядке print(s1::2)# вывод строки с шагом 2 #Вывод |
Работает следующим образом: строка
Обратите внимание, что поля могут быть пустыми. Если указать отрицательный шаг, то проход будет осуществляться в обратную сторону! Данный функционал работает так же для списков и других итерируемых структур
Для строк работает операция умножение (*) – увеличивает количество символов на множитель.
s1 = «Igor ivanovich «<br>print(s1*5)<br># Вывод<br><br>Igor ivanovich Igor ivanovich Igor ivanovich Igor ivanovich Igor ivanovich
| 1 | s1=»Igor ivanovich «<br>print(s1*5)<br># Вывод<br><br>Igor ivanovich Igor ivanovich Igor ivanovich Igor ivanovich Igor ivanovich |
Длина и логическое представление
Для определения длины структуры данных применяется метод
__len__.
Добавим в наш класс следующий тривиальный метод:
|
1 |
def __len__(self) returnlen(self._contents) |
Убедимся, что он работает как ожидалось:
|
1 |
>>>len(Assoc((1,2),(2,3))) 2 >>>len(Assoc()) |
Мы привыкли, что любое значение в Python можно использовать в условном операторе. По соглашению пустые структуры данных (пустая строка, пустой список и так далее) в логическом контексте эквивалентны
False. В общем случае Python преобразует объект в логическое значение с помощью метода
__bool__.
Если метод
__bool__ не определен, объект считается эквивалентным
True. Мы могли бы легко определить его, например:
|
1 |
def __bool__(self) return(Trueifself._contents!=elseFalse) |
Можно написать даже просто
returnbool(self._contents), пользуясь тем, что внутри это список и его пустота и так отлично определяется функцией
bool().
Но мы воспользуемся особым случаем и совместим два метода в одном. Дело в том, что если у объекта есть метод
__len__, но нет метода
__bool__, то сначала вызывается
__len__, и если он возвращает ноль, то значение объекта считается ложным. Убедимся в этом на практике:
|
1 |
>>>»Non-empty»ifAssoc(1,2)else»Empty» ‘Non-empty’ >>>»Non-empty»ifAssoc()else»Empty» ‘Empty’ |
Реализация Python по умолчанию
Python – это объектно-ориентированный язык программирования с открытым исходным кодом, который по умолчанию реализован на языке программирования C. Это очень интересный факт – язык, который так популярен, написан на другом языке? Но это является правдой лишь отчасти.
В основном язык Python написан на английском языке. Однако это определено в справочном руководстве, что само по себе бесполезно. Итак, нам нужен код, основанный на интерпретаторе правила в руководстве.
Преимущество реализации по умолчанию заключается в том, что она выполняет код Python на компьютере, а также преобразует наш код Python в инструкции. Итак, мы можем сказать, что реализация Python по умолчанию удовлетворяет обоим требованиям.
Программа, которую мы пишем на языке Python, сначала преобразует в байт-код компьютерных инструкций. Виртуальная машина интерпретирует этот байт-код.
Что такое кучи в Python?
Кучи в Python являются полными двоичными деревьями, в которых каждый узел либо меньше, чем равен или больше, чем равен всем своим детям (меньше или больше, в зависимости от того, является ли это макс-кучу или мин-куча).
Следовательно, корневой узел кучи – это либо самый маленький, либо самый большой элемент. Структура данных кучи обычно используется для представления очереди приоритета Отказ
Как правило, куча из двух форм:
- Мин-куча : Min Heap – это куча, в которой все узлы меньше, чем их дети. Корень содержит самую низкую ценность в мин-куче.
- Макс-куча : Макс куча – это куча, в которой все узлы больше, чем их дети. Корень содержит наибольшее значение в максимальной куче.
Ниже приведен пример для Min Heap и Max Heap.
Куча в Python, по умолчанию, мин-куча, а дальше в этой статье мы будем рассматривать мин-кучу, когда мы говорим о куче. Давайте теперь посмотрим, как структура данных кучи фактически реализована.
Где используется
Данные используются в программирования повсеместно, поэтому важно понимать, с какими именно вы сейчас работаете, и какие последствия это накладывает на процесс взаимодействия. Существует множество типов данных, но только некоторые из них используются каждым программистом.
— тип данных для работы с целыми числами, а — для работы с числами с плавающей точкой
хранит данные в строковом формате и может включать буквы, символы и цифры. В то же время в и использовать символы нельзя — только числа.
тип состоит всего из двух значений: или . Важно отметить, что при инициализации или присваивании значения типа или нужно вводить без кавычек. Строковые же значения наоборот всегда заключены в кавычки.
Рекомендации по работе с типами данных
- Нужно всегда помнить о следующих особенностях типов данных: их форматах, областях применения и возможностях.
- Строковые значения всегда заключены в кавычки, тогда как , или записываются без них.
Кортеж¶
Кортежи служат для хранения нескольких объектов вместе. Их можно рассматривать
как аналог списков, но без такой обширной функциональности, которую
предоставляет класс списка. Одна из важнейших особенностей кортежей заключается
в том, что они неизменяемы, так же, как и строки. Т.е. модифицировать
кортежи невозможно.
Кортежи обозначаются указанием элементов, разделённых запятыми; по желанию
их можно ещё заключить в круглые скобки.
Кортежи обычно используются в тех случаях, когда оператор или пользовательская
функция должны наверняка знать, что набор значений, т.е. кортеж значений, не
изменится.
Пример: (сохраните как )
zoo = ('питон', 'слон', 'пингвин') # помните, что скобки не обязательны
print('Количество животных в зоопарке -', len(zoo))
new_zoo = 'обезьяна', 'верблюд', zoo
print('Количество клеток в зоопарке -', len(new_zoo))
print('Все животные в новом зоопарке:', new_zoo)
print('Животные, привезённые из старого зоопарка:', new_zoo2])
print('Последнее животное, привезённое из старого зоопарка -', new_zoo2])
print('Количество животных в новом зоопарке -', len(new_zoo)-1+len(new_zoo2]))
Вывод:
$ python3 using_tuple.py
Количество животных в зоопарке - 3
Количество клеток в зоопарке - 3
Все животные в новом зоопарке: ('обезьяна', 'верблюд', ('питон', 'слон', 'пингвин'))
Животные, привезённые из старого зоопарка: ('питон', 'слон', 'пингвин')
Последнее животное, привезённое из старого зоопарка - пингвин
Количество животных в новом зоопарке - 5
Как это работает:
Скобки
Хотя скобки и не являются обязательными, я предпочитаю всегда указывать
их, чтобы было очевидно, что это кортеж, особенно в двусмысленных случаях.
Например, и делают разные вещи:
первое выражение выводит три числа, тогда как второе – кортеж, содержащий
эти три числа.
Кортеж, содержащий 0 или 1 элемент
Пустой кортеж создаётся при помощи пустой пары скобок – “”.
Однако, с кортежем из одного элемента не всё так просто. Его нужно
указывать при помощи запятой после первого (и единственного) элемента, чтобы
Python мог отличить кортеж от скобок, окружающих объект в выражении. Таким
образом, чтобы получить кортеж, содержащий элемент , вам потребуется
указать “”.
Словарь¶
Словарь – это некий аналог адресной книги, в которой можно найти адрес или
контактную информацию о человеке, зная лишь его имя; т.е. некоторые ключи
(имена) связаны со значениями (информацией). Заметьте, что ключ должен быть
уникальным – вы ведь не сможете получить корректную информацию, если у вас
записаны два человека с полностью одинаковыми именами.
Обратите также внимание на то, что в словарях в качестве ключей могут
использоваться только неизменяемые объекты (как строки), а в качестве значений
можно использовать как неизменяемые, так и изменяемые объекты. Точнее говоря,
в качестве ключей должны использоваться только простые объекты
Пары ключ-значение указываются в словаре следующим образом:
“”
Обратите внимание, что ключ и
значение разделяются двоеточием, а пары друг от друга отделяются запятыми, а
затем всё это заключается в фигурные скобки
Помните, что пары ключ-значение никоим образом не упорядочены в словаре. Если
вам необходим некоторый порядок, вам придётся отдельно отсортировать словарь
перед обращением к нему.
Словари являются экземплярами/объектами класса .
Пример: (сохраните как )
# 'ab' - сокращение от 'a'ddress'b'ook
ab = { 'Swaroop' '[email protected]',
'Larry' '[email protected]',
'Matsumoto' '[email protected]',
'Spammer' '[email protected]'
}
print("Адрес Swaroop'а:", ab'Swaroop'])
# Удаление пары ключ-значение
del ab'Spammer'
print('\nВ адресной книге {0} контакта\n'.format(len(ab)))
for name, address in ab.items():
print('Контакт {0} с адресом {1}'.format(name, address))
# Добавление пары ключ-значение
ab'Guido' = '[email protected]'
if 'Guido' in ab
print("\nАдрес Guido:", ab'Guido'])
Вывод:
$ python3 using_dict.py Адрес Swaroop'а: [email protected] В адресной книге 3 контакта Контакт Swaroop с адресом [email protected] Контакт Matsumoto с адресом [email protected] Контакт Larry с адресом [email protected] Адрес Guido: [email protected]
Как это работает:
Чтобы просмотреть список всех методов класса смотрите .
список
Список Python является переменной величиной, которая является наиболее важной особенностью отличает его от строк и кортежей, а именно одно предложение: список могут быть изменены, в то время как строки и кортежи не могут. Вот список Python:
Вот список Python:
| способ | описание |
|---|---|
| list.append (х) | Чтобы добавить элемент в конец списка, что эквивалентно = . |
| list.extend (L) | Добавляя все элементы указанного списка, чтобы развернуть список, эквивалент = L. |
| list.insert (я, х) | Вставьте элемент в указанном месте. Первый параметр должен быть вставлен в свой индекс перед элементами, такими как a.insert (0, х) будет вставлен перед весь список, но a.insert (LEN (а), х) эквивалентно a.append ( х). |
| list.remove (х) | Удаляет первый элемент из списка, значение которого равно х. Если нет такого элемента, то он вернет ошибку. |
| list.pop () | Удалить элементы из указанной позиции в этом списке, и вернуть его. Если вы не указали индекс, a.pop () возвращает последний элемент. Элемент был немедленно удален из списка. (Метод квадратных скобок вокруг I указывает на то, что параметр является необязательным, не то, что вы должны ввести квадратные скобки, вы часто будете видеть эту запись в Python Library Reference.) |
| list.clear () | Удалить все элементы в списке, равный дель в . |
| list.index (х) | Возвращает индекс списка со значением х в первом элементе. Если соответствующий элемент не будет возвращать ошибку. |
| list.count (х) | Возвращает число х раз появляется в списке. |
| list.sort () | Из элементов в списке, подлежащих сортировке. |
| list.reverse () | Перевернутые элементы в списке. |
| list.copy () | Возвращает неполную копию списка равна . |
Следующий пример иллюстрирует, большинство из списка методов:
>>> a =
>>> print(a.count(333), a.count(66.25), a.count('x'))
2 1 0
>>> a.insert(2, -1)
>>> a.append(333)
>>> a
>>> a.index(333)
1
>>> a.remove(333)
>>> a
>>> a.reverse()
>>> a
>>> a.sort()
>>> a
Примечание: Как и вставить, удалить или изменить метод списка критериев сортировки и т.д. без возвращаемого значения.
Освойте словарное включение
По аналогии со списками нам доступно словарное включение:
Здесь словарь объявляется оператором , а внутри происходит его наполнение. Вначале указывается пара «ключ: значение», а затем цикл .
Распаковка словаря
Термин «распаковка» применяется относительно структур данных. Он означает выбор данных в структуре и последующее представления в виде отдельных типов.
Распаковка совершается циклом , который итерирует по непустой структуре данных.
Распакуем элементы предыдущего словаря:
В теле цикла метод , представленный в виде псевдонима kmy_dict_1print()` выводит не словарь целиком, как в предыдущем примере, а каждый элемент в виде отдельного типа:
Распаковка списка кортежей
Кортеж — очередная структура данных. В отличие от списка, который можно изменять, данные в кортеже остаются неизменными. Используйте кортеж для хранения чувствительных данных, например, реквизитов.
Для закрепления вашего понимания принципа распаковки, воспользуемся списком кортежей.
Объявим список кортежей:
Обратите внимание, что кортежи в списке разделены запятыми, и являются элементами списка. Цикл для распаковки:
Цикл для распаковки:
Переменные и принимают значения каждого элемента кортежей в списке. Каждая новая итерация выводит значения одного кортежа:
Широк-первый поиск (BFS)
Последние методы прохождения наших деревьев используют уровень уровней от поперечного порта в ширину, который состоит в том, чтобы получить значения слоями. Вы проходите дерево горизонтально, пока не получите доступ к всем значениям.
Этот немного сложнее, потому что нам нужна дополнительная структура данных: очередь. Думайте о очередях как массивы, где вы можете получить только первый элемент. Вы можете добавлять элементы в конце очереди и удалить их обратно с самого начала. Как и кинотеатр, где люди покупают свои билеты в порядке, следуя очереди. Это называется FIFO, где первым вначале сначала. Например:
let queue = [] queue.push(1) queue.push(2) queue.push(3) // Now our queue is queue.get() // Returns "1" queue.shift() // Removes "1" console.log(queue) // Returns
Шаги следующие:
- Распечатайте значение первого элемента очереди.
- Добавьте весь левый узел в очередь.
- Добавьте весь правый узел в очередь.
Вы начинаете с добавления всего корневого узла в очередь. Вот как это выглядит в JavaScript:
bfs() {
let queue = []
queue.push(this)
while (queue.length > 0) {
const active = queue
console.log(active.value)
if (active.left) queue.push(active.left)
if (active.right) queue.push(active.right)
queue.shift()
}
}
Вот полная реализация:
class Tree {
value = null
left = null
right = null
constructor(value) {
this.value = value
}
addLeft(value) {
this.left = new Tree(value)
}
addRight(value) {
this.right = new Tree(value)
}
bfs() {
let queue = []
queue.push(this)
let counter = 0
while (queue.length > 0 && counter < 100) {
const active = queue
console.log(active.value)
if (active.left) queue.push(active.left)
if (active.right) queue.push(active.right)
queue.shift()
counter++
}
}
}
const myTree = new Tree(1)
Сейчас это полная реализация первого поиска и сначала поиска по глубину и широко распространена, что вы только что видели для вашего будущего ссылки:
class Tree {
value = null
left = null
right = null
constructor(value) {
this.value = value
}
addLeft(value) {
this.left = new Tree(value)
}
addRight(value) {
this.right = new Tree(value)
}
preOrder() {
console.log(this.value)
if (this.left) this.left.preOrder()
if (this.right) this.right.preOrder()
}
inOrder() {
if (this.left) this.left.inOrder()
console.log(this.value)
if (this.right) this.right.inOrder()
}
postOrder() {
if (this.left) this.left.postOrder()
if (this.right) this.right.postOrder()
console.log(this.value)
}
bfs() {
let queue = []
queue.push(this)
let counter = 0
while (queue.length > 0 && counter < 100) {
const active = queue
console.log(active.value)
if (active.left) queue.push(active.left)
if (active.right) queue.push(active.right)
queue.shift()
counter++
}
}
}
const myTree = new Tree(1)
А в Python:
from Queue import Queue
class Node:
value = None
left = None
right = None
def __init__(self, value):
self.value = value
def add_left(self, value):
self.left = Node(value)
def add_right(self, value):
self.right = Node(value)
def pre_order(self):
print(self.value)
if self.left:
self.left.pre_order()
if self.right:
self.right.pre_order()
def in_order(self):
if self.left:
self.left.in_order()
print(self.value)
if self.right:
self.right.in_order()
def post_order(self):
if self.left:
self.left.post_order()
if self.right:
self.right.post_order()
print(self.value)
def breadth_first_search(self):
queue = Queue()
queue.put(self)
while not queue.empty():
active = queue.get()
print(active.value)
if active.left:
queue.put(active.left)
if active.right:
queue.put(active.right)
# Some sample data
tree = Node('html')
tree.add_right('body')
tree.right.add_left('h1')
tree.right.add_right('h2')
# A few examples here
tree.pre_order()
print('\n')
tree.in_order()
print('\n')
tree.post_order()
print('\n')
tree.breadth_first_search()
Описание чертежа:
Повторный анализ:
Для вычисления 1 + 2 + 3 +… + (n-1) = n * (n-1) / 2, поэтому такжеO(n^2)。
Пять, встроенный в Python анализ производительности типов
timeitМодуль используется для проверки времени выполнения фрагмента кода: Три параметра:stmt, setup, timer т.е.Timer: Класс для проверки времени выполнения небольшого фрагмента кода;stmt: Оператор кода для тестирования;setup: Настройки, необходимые при запуске кода;timer: Параметр таймера связан с платформой.
Распечатать
Легко понять, что первый метод самый медленный, метод insert () немного быстрее, append () быстрее, а остальные также быстрее.
Шесть, введение структуры данных
Разные методы хранения данных приведут к разным алгоритмам обработки, и эффективность их выполнения будет разной. , например При использовании типов в Python для хранения информации об учащихся в классе можно рассмотреть два способа: списки и словари. При получении информации через имя студента, например, через список, необходимо пройти по списку, а временная сложность равна O (n) (при условии, что размер студента равен n), а когда он сохраняется в словаре, вы можете использовать имя ученика в качестве ключа словаря, а информацию ученика в качестве значения.Информацию об ученике можно быстро получить без обхода при запросе, а временная сложность равна O (1). Это показывает, что разные методы хранения данных действительно приведут к разным алгоритмам, и эффективность использования алгоритмов для решения проблем также будет различной. Данные — это абстрактное понятие. После их классификации получаются основные типы языков программирования, такие как общие int, float, char и т. д. Элементы данных не являются независимыми, существуют определенные отношения, и эти отношения являются структурами. Определение: Структура данных относится к отношениям между элементами данных в объекте данных, то есть к способу организации данных. В Python структура данных делится на: Встроенная структура данных: реализован Python, нам не нужно определять, например списки, кортежи, словари и т. д .; Расширенная структура данных: Python не определяет, нам нужно определить организацию этих данных, такую как стеки, очереди и т. д.Программа = структура данных + алгоритм Резюме. Алгоритм предназначен для решения практических задач, а структура данных является носителем, с которым алгоритм должен иметь дело.Абстрактный тип данных (ADT)： относится к типу данных и набору операций, определенных в этой модели данных, то есть тип данных и операции с этим типом данных объединяются и инкапсулируются. Цель введения абстрактных типов данных — отделить представление типов данных и реализацию операций над типами данных от ссылок на эти типы данных и операции в программе и сделать их независимыми от друг друга. Вы также можете подписаться на мою официальную учетную запись:Сообщество гиков PythonВ моем публичном аккаунте я часто делюсь множеством статей о Python, а также делюсь множеством инструментов, учебных ресурсов и т. Д. Кроме того, ответьте «электронная книга», чтобы получить десять тщательно собранных мной электронных книг о Python.
