Определение доминирующих цветов: python и метод k-средних

Локальная область видимости

Локальная область видимости наиболее часто используется в Python. Когда мы создаем переменную в блоке кода, она будет разрешена при помощи ближайшей области видимости, или областей. Группирование всех этих областей известно как среда блоков кода. Другими словами, все назначения выполняются в локальной области по умолчанию. Если вам нужно что-то другое, тогда вам нужно настроить свою переменную на глобальную или нелокальную область, которые мы рассмотрим немного позже. Сейчас мы создадим простой пример, используя интерпретатор Python, в котором демонстрируется назначение локальной области видимости.

Python

x = 10

def my_func(a, b):
print(x)
print(z)

my_func(1, 2)

1
2
3
4
5
6
7

x=10

defmy_func(a,b)

print(x)

print(z)

my_func(1,2)

Результат

Python

10
Traceback (most recent call last):
File «», line 1, in
my_func(1, 2)
File «», line 3, in my_func
print(z)
NameError: name ‘z’ is not defined

1
2
3
4
5
6
7

10

Traceback(most recent call last)

File»»,line1,inmodule>

my_func(1,2)

File»»,line3,inmy_func

print(z)

NameErrorname’z’isnotdefined

Здесь мы создаем переменную х и очень простую функцию, которая принимает два аргумента. Далее она выводит х и z

Обратите внимание на то, что мы не определили z, так что когда мы вызываем функцию, мы получаем ошибку NameError. Это происходит в связи с тем, что z не определена, или находится вне области видимости

Если вы определите z перед вызовом функции, тогда она будет найдена и ошибка NameError не возникнет. Ошибка NameError также возникает при попытке получения доступа к переменной, которая находится только внутри функции:

Python

def my_func(a, b):
i = 2
print(x)

if __name__ == ‘__main__’:
x = 10
my_func(1, 2)
print(i)

1
2
3
4
5
6
7
8
9

defmy_func(a,b)

i=2

print(x)

if__name__==’__main__’

x=10

my_func(1,2)

print(i)

Переменная i определена только внутри функции, так что при запуске кода мы получаем ошибку NameError. Давайте немного модифицируем первый пример. Разместим данный код в python-файл и попытаемся его запустить:

Python

def my_func(a, b):
x = 5
print(x)

if __name__ == ‘__main__’:
x = 10
my_func(1, 2)
print(x)

1
2
3
4
5
6
7
8
9

defmy_func(a,b)

x=5

print(x)

if__name__==’__main__’

x=10

my_func(1,2)

print(x)

  1. Что, по-вашему, должно произойти?
  2. Выдаст ли код цифру 10 дважды?

Нет, не выдаст. Причина в том, что мы имеем две переменные х. Переменная х внутри my_func имеет локальную область видимости функции и переопределяет переменную х вне функции. Так что когда мы вызываем функцию my_func, в выдаче мы видим 5, а не 10. Затем, когда функция возвращается, переменная х внутри функции my_func является кучей мусора и область для выдачи х срабатывает еще один раз. По этой причине последний оператор выдачи выдает именно 10. Если вы хотите кое-что поинтереснее, вы можете попытаться вывести х перед тем как назначить его в нашей функции:

Python

def my_func(a, b):
print(x)
x = 5
print(x)

if __name__ == ‘__main__’:
x = 10
my_func(1, 2)
print(x)

1
2
3
4
5
6
7
8
9
10

defmy_func(a,b)

print(x)

x=5

print(x)

if__name__==’__main__’

x=10

my_func(1,2)

print(x)

Кода вы запустите этот код, вы получите ошибку:

Python

UnboundLocalError: local variable ‘x’ referenced before assignment

1 UnboundLocalErrorlocal variable’x’referenced before assignment

Это происходит потому, что Python замечает, что вы назначаете х в функцию my_func позже, что и приводит к ошибке, так как х еще не определен.

Теория и практика. Быстрая проверка задач и подсказки к ошибкам на русском языке.
Работает в любом современном браузере.

Преобразование типа данных

Иногда вам может потребоваться выполнить преобразования между встроенными типами. Чтобы преобразовать типы, вы просто используете имена типов как функцию.

Существует несколько встроенных функций для преобразования из одного типа данных в другой. Эти функции возвращают новый объект, представляющий преобразованное значение.

S.No. Функция & Описание
1


int(x )

Преобразует x в целое число.

2


float(x)

Преобразует x в число с плавающей запятой.

3


complex(real )

Создает комплексное число.

4


str(x)

Преобразует объект x в строковое представление.

5


repr(x)

Преобразует объект x в строковое выражение.

6


eval(str)

Обрабатывает строку и возвращает объект. Используется для выполнения программного кода представленного сторокой.

7


tuple(s)

Преобразует s в кортеж.

8


list(s)

Преобразует s в список.

9


set(s)

Преобразует s в набор.

10


dict(d)

Создает словарь. d должен быть последовательностью (ключ, значение) кортежей.

11


frozenset(s)

Преобразует s в неизменяемый набор.

12


chr(x)

Преобразует целое число в символ.

13


unichr(x)

Преобразует целое число в символ Unicode.

14


ord(x)

Преобразует один символ в его целочисленное значение.

15


hex(x)

Преобразует целое число в шестнадцатеричную строку.

16


oct(x)

Преобразует целое число в восьмеричную строку.

Обзор PEP’ов регламентирующий работу с аннотациями

Начнем наше введение в тему аннотаций в Python с краткого обзора четырех ключевых документов:

Первый из них PEP 3107 — Function Annotations, является исторически первым из перечисленных выше документов. В нем описывается синтаксис использования аннотаций в функциях Python. Важным является то, что аннотации не имеют никакого семантического значения для интерпретатора Python и предназначены только для анализа сторонними приложениями. Аннотировать можно аргументы функции и возвращаемое ей значение.

Следующий документ – PEP 484 — Type Hints. В нем представлены рекомендации по использованию аннотаций типов. Аннотация типов упрощает статический анализ кода, рефакторинг, контроль типов в рантайме и кодогенерацию, использующую информацию о типах. В рамках данного документа, определены следующие варианты работы с аннотациями: использование аннотаций в функциях согласно PEP 3107, аннотация типов переменных через комментарии в формате # type: type_name и использование stub-файлов (см. разделы и ).

В PEP 526 — Syntax for Variable Annotations приводится описание синтаксиса для аннотации типов переменных (базируется на PEP 484), использующего языковые конструкции, встроенные в Python (см. раздел ).

PEP 563 — Postponed Evaluation of Annotations. Данный PEP вступил в силу с выходом Python 3.7. У подхода работы с аннотация до этого PEP’а был ряд проблем связанных с тем, что определение типов переменных (в функциях, классах и т.п.) происходит во время импорта модуля, и может сложится такая ситуация, что тип переменной объявлен, но информации об этом типе ещё нет, в таком случае тип указывают в виде строки – в кавычках. В PEP 563 предлагается использовать отложенную обработку аннотаций, это позволяет определять переменные до получения информации об их типах и ускоряет выполнение программы, т.к. при загрузке модулей не будет тратится время на проверку типов – это будет сделано перед работой с переменными.

Теперь более подробно остановимся на использовании аннотаций, опираясь на перечисленные выше PEP’ы.

Множественное присваивание переменной

Python позволяет присваивать одно значение нескольким переменным одновременно. Таким образом, вы можете инициализировать несколько переменных, а позже переназначить их.

Например, можно задать переменным x, y и z значение 0.

Теперь все три переменные имеют одинаковое значение и принадлежат к одной области памяти.

Python также позволяет присваивать несколько значений нескольким переменным в рамках одной строки. Например:

Как видите, переменной j было присвоено значение 8host, переменной k 1.05, l – 16.

Эта функция позволяет сократить код, и при этом сохранить его читабельность.

Что такое переменная?

С технической точки зрения переменная присваивает значению символическое имя или идентификатор. Имя переменной используется для того, чтобы сослаться на сохраненное значение в компьютерной программе.

Переменную можно представить как метку или ярлык с именем, который привязан к значению.

К примеру, у вас есть целое число 103204934813. Вы можете сохранить его в переменной, и тогда вам не придётся постоянно вводить повторно длинное число. Сохраните число в переменной my_int:

По сути, my_int – это ярлык, привязанный к значению 103204934813.

Фраза my_int = 103204934813 – это операция присваивания, которая состоит из следующих частей:

  • my_int – имя переменной;
  • = – оператор присваивания;
  • 103204934813 – значение.

Таким образом, присваивая значению имя, вы инициализируете, или создаёте переменную. После этого можно использовать переменную вместо значения. В Python, в отличие от некоторых других языков программирования, переменные не нужно явно декларировать. То есть, объявив, что my_int равно 103204934813, вы можете просто использовать my_int вместо числа. Попробуйте запустить:

С помощью переменных можно быстро выполнить вычисления. Попробуйте отнять 813 из my_int:

В качестве значения переменной можно использовать результат математического уравнения. Попробуйте сложить два числа и сохранить значение их суммы в переменной x:

Как видите, это очень похоже на простейшее школьное уравнение; здесь, как и в алгебре, буквы и другие символы используются для представления чисел и величин в формулах и уравнениях. Синтаксис Python подразумевает, что имя переменной находится слева, а значение – справа.

Выведите значение x:

Python выводит 221, потому что именно это число получается в результате сложения 76 и 145.

В виде переменной можно представить любой тип данных, не только числа.

Попробуйте запросить одну из этих переменных. На экране появится значение этой переменной:

Переменная выделяет небольшую область памяти, которая принимает заданное значение.

Объектные переменные

Объектные переменные имеют индивидуальное значение внутри того или иного объекта.

В отличие от переменных класса, объектные переменные определяются внутри метода.

К примеру, в классе Shark переменные name и age являются объектными.

Объектные переменные определяются при создании класса Shark, а затем передаются объекту в качестве параметров метода конструктора или другого метода.

Как и переменные класса, объектные переменные можно отобразить:

Запустите программу:

Полученный результат состоит из значений переменных, которые были инициализированы для объекта new_shark.

Создайте ещё один объект класса Shark (например, stevie):

Объект stevie, как и объект new_shark, передает индивидуальные параметры экземпляра класса Shark.

Объектные переменные имеют разные значения внутри каждого объекта.

Переменные класса

Переменные класса определяются на уровне класса и применяются ко всем объектам, созданным на его основе. Такая переменная, как правило, имеет одно и то же значение внутри всех объектов на основе этого класса (если только она не используется для инициализации переменной).

Переменная класса, определяемая вне метода, как правило, пишется под заголовком класса и перед методом конструктора и другими методами.

Переменная класса выглядит так:

Создайте тестовую программу shark.py. В этом файле можно создать экземпляр класса Shark (например, new_shark) и вывести переменную с помощью точечной нотации:

Запустите программу:

Программа отобразила значение переменной.

Добавьте в класс больше переменных и отобразите их:

Как и другие виды переменных Python, переменные класса могут содержать любой тип данных. В данной программе переменные будут содержать строки и целые числа.

Снова запустите программу:

На экране появится:

Объект new_shark имеет доступ ко всем переменным класса и может отобразить их на экране.

Что такое списки?

Списки в Python — упорядоченные изменяемые коллекции объектов произвольных типов (почти как массив, но типы могут отличаться).

Чтобы использовать списки, их нужно создать. Создать список можно несколькими способами. Например, можно обработать любой итерируемый объект (например, строку) встроенной функцией list:

>>> list('список')

Список можно создать и при помощи литерала:

>>> s = []  # Пустой список
>>> l = 's', 'p', 'isok'], 2
>>> s
[]
>>> l
, 2]

Как видно из примера, список может содержать любое количество любых объектов (в том числе и вложенные списки), или не содержать ничего.

И еще один способ создать список — это генераторы списков. Генератор списков — способ построить новый список, применяя выражение к каждому элементу последовательности. Генераторы списков очень похожи на цикл for.

>>> c = c * 3 for c in 'list'
>>> c

Возможна и более сложная конструкция генератора списков:

>>> c = c * 3 for c in 'list' if c != 'i'
>>> c

>>> c = c + d for c in 'list' if c != 'i' for d in 'spam' if d != 'a'
>>> c

Контроль типов в Python

Рассмотрим небольшую демонстрацию того, как решался вопрос контроля типов в Python без использования аннотаций. Один из возможных вариантов (наверное самый логичный) решения данной задачи – это использование комментариев, составленных определенным образом.

Выглядит это так:

name = "John" # type: str

Мы создали переменную с именем name и предполагаем, что ее тип – str. Естественно, для самого интерпретатора Python это не имеет значения, мы, без труда можем продолжить нашу мини программу таким образом.

name = "John" # type: str
print(name)
name = 10
print(name)

И это будет корректно с точки зрения Python. Но если необходимо проконтролировать, что переменной name будут присваиваться значения только строкового типа, мы должны: во-первых указать в комментарии о нашем намерение – это мы сделали, во-вторых использовать специальный инструмент, который выполнит соответствующую проверку. Таким инструментом является mypy.

Установить его можно с помощью pip

python -m pip install mypy

Если мы сохраним приведенный выше код в файле type_tester.py и выполним следующую команду:

python -m mypy test_type.py

Получим такое сообщение:

test_type.py:3: error: Incompatible types in assignment (expression has type “int”, variable has type “str”)

Оно говорит о том, что обнаружено несоответствие типов в операции присваивание: переменная имеет тип “str“, а ей присвоено значение типа “int“.

Общие преимущества Python

Одним из главных преимуществ данного языка является его универсальность. Питон может использоваться в различных областях прикладного программирования. Еще одним немаловажным плюсом является его молодость. Язык быстро развивается, к нему растет интерес.

Значит функционал питона в дальнейшем будет расширяться еще больше. К тому же поддержка одной из крупнейших IT-корпораций в мире не может не обнадеживать.

Если вы не знаете как начать программировать на Python, почитайте статью.

Вместе с этим синтаксис, включающий в себя правильные отступы, может помочь новичкам набить руку в правильном форматировании своего кода. Впрочем, подобные умения могут пригодиться и многим опытным программистам, ведь без чистого и грамотного кода сегодня сложно найти достойную и высокооплачиваемую работу.

По поводу форматирования, существует специальная инструкция PEP8. В которой описаны все тонкости оформления кода. Я поверхностно пока изучил. Но боюсь, если я хочу стать настоящим профи в области Pythona, то я должен знать это от и до.

P.S. В следующей статье я буду рассматривать 10 редакторов IDE для удобного написания кода! Не пропустите, подписывайтесь на новости блога!

Переменные

Данные хранятся в ячейках памяти компьютера. Когда мы вводим число, оно помещается в какую-то ячейку памяти. Но как потом узнать, куда именно? Как впоследствии обращаться к этим данными? Нужно как-то запомнить, пометить соответствующую ячейку.

Раньше, при написании программ на машинном языке, обращение к ячейкам памяти осуществляли с помощью указания их регистров, т. е. конкретно сообщали, куда положить данные и откуда их взять. Однако с появлением ассемблеров при обращении к данным стали использовать словесные переменные, что куда удобней для человека.

Механизм связи между переменными и данными может различаться в зависимости от языка программирования и типов данных. Пока достаточно запомнить, что в программе данные связываются с каким-либо именем и в дальнейшем обращение к ним возможно по этому имени-переменной.

Слово «переменная» обозначает, что сущность может меняться, она непостоянна. Действительно, вы увидите это в дальнейшем, одна и та же переменная может быть связана сначала с одними данными, а потом – с другими. То есть ее значение может меняться, она переменчива.

В программе на языке Python, как и на большинстве других языков, связь между данными и переменными устанавливается с помощью знака =. Такая операция называется присваивание (также говорят «присвоение»). Например, выражение sq = 4 означает, что на объект, представляющий собой число 4, находящееся в определенной области памяти, теперь ссылается переменная sq, и обращаться к этому объекту следует по имени sq.

Имена переменных могут быть любыми. Однако есть несколько общих правил их написания:

  1. Желательно давать переменным осмысленные имена, говорящие о назначении данных, на которые они ссылаются.

  2. Имя переменной не должно совпадать с командами языка (зарезервированными ключевыми словами).

  3. Имя переменной должно начинаться с буквы или символа подчеркивания (_), но не с цифры.

  4. Имя переменной не должно содержать пробелы.

Чтобы узнать значение, на которое ссылается переменная, находясь в режиме интерпретатора, достаточно ее вызвать, т. е. написать имя и нажать Enter.

>>> sq = 4
>>> sq
4

Вот более сложный пример работы с переменными в интерактивном режиме:

>>> apples = 100
>>> eat_day = 5
>>> day = 7
>>> apples = apples - eat_day * day
>>> apples
65

Здесь фигурируют три переменные: apples, eat_day и day. Каждой из них присваивается свое значение. Выражение сложное. Сначала выполняется подвыражение, стоящее справа от знака равенства. После этого его результат присваивается переменной apples, в результате чего ее старое значение (100) теряется. В подвыражении вместо имен переменных на самом деле используются их значения, т. е. числа 100, 5 и 7.

Зачем нужны аннотации?

Для начала ответим на вопрос: зачем нужны аннотации в Python? Если кратко, то ответ будет таким: для того чтобы повысить информативность исходного кода, и иметь возможность с помощью сторонних инструментов производить его анализ. Одной из наиболее востребованных, в этом смысле, тем является контроль типов переменных. Несмотря на то, что Python – это язык с динамической типизацией, иногда возникает необходимость в контроле типов.

Согласно PEP 3107 могут быть следующие варианты использования аннотаций:

  • проверка типов;
  • расширение функционала IDE в части предоставления информации об ожидаемых типах аргументов и типе возвращаемого значения у функций;
  • перегрузка функций и работа с дженериками;
  • взаимодействие с другими языками;
  • использование в предикатных логических функциях;
  • маппинг запросов в базах данных;
  • маршалинг параметров в RPC (удаленный вызов процедур).

Python Tuples

Кортеж – это другой тип данных последовательности, аналогичный списку. Кортеж состоит из нескольких значений, разделенных запятыми. В отличие от списков, однако, кортежи заключены в круглые скобки.

Основное различие между списками и кортежами состоит в том, что списки заключены в квадратные скобки ([]), и их элементы и размер могут быть изменены, а кортежи заключены в круглые скобки (()) и не могут быть обновлены. Кортежи можно рассматривать как списки только для чтения . Например –

#!/usr/bin/python3

tuple =('abcd',786,2.23,'john',70.2)
tinytuple =(123,'john')print(tuple)# Prints complete tupleprint(tuple])# Prints first element of the tupleprint(tuple13])# Prints elements starting from 2nd till 3rd print(tuple2:])# Prints elements starting from 3rd elementprint(tinytuple *2)# Prints tuple two timesprint(tuple + tinytuple)# Prints concatenated tuple

Это дает следующий результат –

('abcd', 786, 2.23, 'john', 70.200000000000003)
abcd
(786, 2.23)
(2.23, 'john', 70.200000000000003)
(123, 'john', 123, 'john')
('abcd', 786, 2.23, 'john', 70.200000000000003, 123, 'john')

Следующий код недопустим с кортежем, потому что мы попытались обновить кортеж, что недопустимо. Подобный случай возможен со списками –

#!/usr/bin/python3

tuple =('abcd',786,2.23,'john',70.2)
list ='abcd',786,2.23,'john',70.2
tuple2=1000# Invalid syntax with tuple
list2=1000# Valid syntax with list

7 ответов

Python не имеет тех же типов как C/C++, который, кажется, Ваш вопрос.

Попытка это:

различие между интервалом и долго уходит в Python 3.0, все же.

ответ дан gregjor 16 September 2017 в 09:37

Python не имеет таких типов, как Вы описываете. Существует два типа, используемые для представления интегральных значений: , который соответствует международному типу платформы в C, и , который является целым числом произвольной точности (т.е. это растет по мере необходимости и не имеет верхнего предела). с тихо преобразовываются в , если выражение приводит к результату, который не может быть сохранен в .

ответ дан atzz 16 September 2017 в 09:37

Это действительно зависит, на каком уровне Вы имеете в виду. В Python 2.x существует два целых типа, (ограничены к ) и (неограниченная точность), по историческим причинам. В коде Python это не должно иметь небольшого количества значения, потому что интерпретатор автоматически преобразовывает в длинный, когда число является слишком большим. Если Вы хотите знать о фактических типах данных, используемых в базовом интерпретаторе, это является зависящим от реализации. (CPython’s расположен в Objects/intobject.c и Objects/longobject.c.) Узнать о системах вводит взгляд cdleary ответ для использования модуля структуры.

ответ дан Benjamin Peterson 16 September 2017 в 09:37

Вы имеете в виду в Python или использование ctypes?

В первом случае, Вы просто не можете — потому что Python не имеет целых чисел на 16/32 бита, со знаком/неподписанных.

Во втором случае, можно использовать :

Для более ссылочного на ctypes, его типе, см. официальная документация .

ответ дан Peter Mortensen 16 September 2017 в 09:37

я также настоятельно рекомендую IPython интерактивный интерпретатор при контакте с вопросами как это. Это позволяет Вам тип и возвратит целый список информации об объекте включая тип и строку документа для типа.

, например,

Преобразовывают строку или число к целому числу, если это возможно. Аргумент с плавающей точкой будет усеченным по направлению к нулю (это не включает строковое представление числа с плавающей точкой!) При преобразовании строки, используйте дополнительную основу. Это — ошибка предоставить основу при преобразовании нестроки. Если аргумент будет вне целочисленного диапазона, то длинный объект будет возвращен вместо этого.

ответ дан Community 16 September 2017 в 09:37

Вопрос несколько неоднозначен — я не уверен, что Вы подразумеваете под «представлением». Если Вы попробуете к запрос тип собственного объекта Python, регулирует Вас в правильном направлении.

Однако, если Вы пробуете к , генерируют объекты Python, которые имеют семантику примитивных C-типов, (такой как , ), используют модуль. Можно определить число битов в данном C-типе, примитивном таким образом:

Это также отражается в модуль, который может сделать массивы этих типов низшего уровня:

максимальное целое число, поддерживаемое (Python 2 ), дано sys.maxint

существует также , который возвращает фактический размер объект Python в остаточной памяти:

Для данных плавающих и данных точности, используйте :

ответ дан Community 16 September 2017 в 09:37

Можно искать эти функция.

Видят примеры ниже, но нет никакого «неподписанного» типа в Python точно так же, как Java.

Положительное целое число:

Большой положительное целое число:

Отрицательное целое число:

Литеральная последовательность символов:

целое число С плавающей точкой:

ответ дан 3 revs, 2 users 68% 16 September 2017 в 09:37

Другие вопросы по тегам:

Основы типизации данных

Что это значит? Все очень просто. При объявлении переменной в языках такого класса не требуется указывать ее вид. Таким образом, в отличие от, например С++ или Java, объявление переменной в  рассматриваемом ЯП выглядит так:

Python

a = 1

1 a=1

А в языках С++ и Java для объявления переменной требуется указать ее вид. К примеру:

Python

int a = 1;

1 inta=1;

где «int» значит, что мы вводим целочисленную переменную.

Существует два вида типизации в языках программирования — статическая и динамическая. Статическую типизацию отличает определение вида переменной при компиляции программы, тогда как в случае с динамической — на этапе выполнения программы.

Кстати говоря в CoDeSyS как раз таки статическая типизация, с одной стороны это не очень удобно. Всё время нужно думать и смотреть какие переменные ты привёл.

Также типизация может быть сильной или слабой. Слабая типизация позволяет производить различные операции с переменными разных видов, например, складывать строки и целочисленные переменные. При сильной типизации данных требуется сначала перевести переменную в соответствующий вид.

Таблица «методы списков»

Метод Что делает
list.append(x) Добавляет элемент в конец списка
list.extend(L) Расширяет список list, добавляя в конец все элементы списка L
list.insert(i, x) Вставляет на i-ый элемент значение x
list.remove(x) Удаляет первый элемент в списке, имеющий значение x. ValueError, если такого элемента не существует
list.pop() Удаляет i-ый элемент и возвращает его. Если индекс не указан, удаляется последний элемент
list.index(x, ]) Возвращает положение первого элемента со значением x (при этом поиск ведется от start до end)
list.count(x) Возвращает количество элементов со значением x
list.sort() Сортирует список на основе функции
list.reverse() Разворачивает список
list.copy() Поверхностная копия списка
list.clear() Очищает список

Нужно отметить, что методы списков, в отличие от строковых методов, изменяют сам список, а потому результат выполнения не нужно записывать в эту переменную.

>>> l = 1, 2, 3, 5, 7
>>> l.sort()
>>> l

>>> l = l.sort()
>>> print(l)
None

И, напоследок, примеры работы со списками:

>>> a = 66.25, 333, 333, 1, 1234.5
>>> 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

Изредка, для увеличения производительности, списки заменяют гораздо менее гибкими массивами (хотя в таких случаях обычно используют сторонние библиотеки, например NumPy).

Ссылка на основную публикацию