Продвинутые методы и техники списков в python

18 наиболее распространенных вопросов по list Python

Узнайте, как создать список в Python, выбрать элементы списка, в чем заключается разницу между методами append() и extension(), зачем использовать NumPy и многое другое.

Вот список вопросов по Python, на которые Вы найдете ответы в этой статье:

  1. Когда использовать списки и когда использовать кортежи, словари или наборы?
  2. Как выбрать элемент из списка?
  3. Как преобразовать списки в другие структуры данных?
  4. Как определить размер вашего списка?
  5. В чем разница между методами Python append () и extend ()?
  6. Как объединить списки?
  7. Как отсортировать список?
  8. Как клонировать или скопировать список?
  9. Как работает понимание списков в Python?
  10. Как считать вхождения элемента списка в Python?
  11. Как разбить список на куски одинакового размера?
  12. Как перебрать список?
  13. Как создавать плоские списки из списков?
  14. Как получить пересечение двух списков?
  15. Как удалить дубликаты из списка?
  16. Почему NumPy вместо списков?
  17. Как создать пустые массивы NumPy?
  18. Как сделать математику с помощью списков?

4
4
голоса

Рейтинг статьи

Обработка двумерного массива: пример

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

 
1 0 0 0
2 1 0 0
2 2 1 0
2 2 2 1

Мы стремимся показать вам несколько способов решения этой проблемы

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

Мы получаем следующий алгоритм:

None
n = 4
a =  * n for i in range(n)]
for i in range(n):
    for j in range(n):
        if i < j:
            a = 0
        elif i > j:
            a = 2
        else:
            a = 1
for row in a:
    print(' '.join())

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

Сначала заполните основную диагональ, для которой нам понадобится один цикл:

for i in range(n):
    a = 1

Затем заполните нулями все элементы над главной диагональю. Чтобы сделать это, для каждой строки с номером вам нужно присвоить значение для = , …, . Для этого вам нужны вложенные циклы:

for i in range(n):
    for j in range(i + 1, n):
        a = 0

По аналогии, для = , …, задайте элементы равными :

for i in range(n):
    for j in range(0, i):
        a = 2

Вы можете комбинировать весь этот код и получить другое решение:

None
n = 4
a =  * n for i in range(n)]
for i in range(n):
    for j in range(0, i):
        a = 2
    a = 1
    for j in range(i + 1, n):
        a = 0
for row in a:
    print(' '.join())

Вот еще одно решение, которое повторяет списки для создания следующих строк списка. строка списка состоит из чисел , за которым следует одно целое число , за которым следуют нули:

None
n = 4
a =  * n
for i in range(n):
    a =  * i +  +  * (n - i - 1)
for row in a:
    print(' '.join())    

Как обычно, вы можете заменить петлю генератором:

None
n = 4
a =  * n
a =  * i +  +  * (n - i - 1) for i in range(n)]
for row in a:
    print(' '.join())    

Создание класса в Python:

 Определение класса начинается с ключевого слова class, после него следует имя класса и двоеточие.

class имя_класса:           # тело класса           # объявление конструктора          # объявление атрибутов          # объявление методов 

Основные определения 

Метод __init__  или Конструктор

 В процессе создания объекта  атрибутам класса необходимо задать начальные значения

Это действие  называется инициализацией.  Для этой цели используется   специальный метод __init__(), который  называется методом инициализации или  конструктором.    Метод __init__ запускается при создании экземпляра класса — один раз. Обратите внимание на двойные подчёркивания в начале и в конце имени. Синтаксис метода следующий:

def __init__(self, параметр1, параметр2):self.атрибут1 = параметр1             self.атрибут2 = параметр2

Два символа подчеркивания в начале  __init__ и  два символа подчеркивания в конце обязательны. Параметров у конструктора  параметр1, параметр2 может быть сколько угодно, но первым дожен быть параметр  self.

Добавление элементов в список

Тип данных списка имеет два метода, которые позволяют добавлять элементы в список : и .

Метод добавляет элемент в конец списка. Синтаксис метода следующий:

«Element» — это элемент, который нужно добавить в список. Это может быть любой тип данных, включая список. Вот пример:

Метод рекламирует элемент в определенной позиции в списке и имеет следующий синтаксис:

«Index» — это позиция, в которую вы хотите вставить элемент, а «element» — это элемент, который нужно добавить в список. В следующем примере показано, как добавить элемент в список на первой позиции:

Метод позволяет расширить список несколькими элементами. Он принимает единственный аргумент и имеет следующий синтаксис:

Элементы «списка» добавляются в конец «L». Вот пример:

Атрибуты и методы класса

 Атрибуты класса

Характеристики  объекта, называются атрибутами и записываются в внутри конструктора с помощью переменной self.   Доступ к атрибутам осуществляется через переменную self.

Например, класс имеет атрибут  цвет – color, он должен быть записан как

     self.color

Методы  класса

Методы класса создаются посредством ключевого слова def , имени метода , слова self, которое всегда указывается как первый параметр метода

def имя метода(self, передаваемые параметры):       # тело метода

Пример. Создаем метод, который выводит на печать характеристики мяча

 def Show(self):       print("Мяч: ", self.color, self.size )

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

class Balldef __init__(self, color, size):         self.color =  color         self.size = size    def Show(self):       print("Мяч: ", self.color, self.size )

В каких ситуациях лучше использовать списки, а в каких кортежи, словари или множества?

Материал во введении кажется довольно простым, когда вы просто читаете его, но когда вы на самом деле работаете над небольшим скриптом на Python или над целым проектом, выбор списка или какого-либо другого типа последовательности может быть не таким очевидным для вас.

Но выбор правильной структуры для ваших данных очень важен!

Списки против кортежей

Кортежи используются для хранения неизменяемых упорядоченных наборов элементов. Это означает следующее:

  • вы не можете добавлять элементы в кортеж. Таким образом, методов  или  для кортежей не существует;
  • вы не можете удалять элементы из кортежа. Значит, методов  и  также нет;
  • но вы можете находить элементы в кортеже, так как это его не изменяет;
  • также вы можете использовать оператор  для проверки нахождения элемента в кортеже.

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

Списки против словарей

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

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

Заметим, что при проверке на наличие элемента производительность словарей будет выше.

Списки против множеств

  • Как и словари, множества это неупорядоченные наборы данных (в отличие от списков).
  • Множества требуют, чтобы данные, хранящиеся в них, были хэшируемыми. Списки поддерживают хранение нехэшируемых типов данных.
  • Множества требуют, чтобы элементы, содержащиеся в них, были уникальными и неизменяемыми. Дубликаты недопустимы во множествах, в то время как в списках они возможны, равно как и возможно и изменять сами элементы.

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

Вы не уверены, какие значения можно хэшировать?

Взгляните на таблицу ниже:

ХЭШИРУЕМЫЕ ОБЪЕКТЫ НЕХЭШИРУЕМЫЕ ОБЪЕКТЫ
Floats Dictionaries
Integers Sets
Tuples Lists
Strings  
frozenset()  

Не верьте нам на слово! Поэксперементируйте сами!

# Импортируем библиотеку `collections`
import collections
# Проверяем, можно ли хэшировать словарь
print(isinstance({}, collections.Hashable))
# Проверяем на хэшируемость число с плавающей запятой
print(isinstance(0.125, collections.Hashable))

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

Аргументы — ключевые слова

Основные правила:

  1. Ключевые аргументы указываются перечислением ключ=значение
  2. При вызове функции,  аргументы определяются  по имени.
  3. Это позволяет пропускать аргументы или размещать их не по порядку, поскольку интерпретатор Python может использовать предоставленные ключевые слова (ключи) для сопоставления значений с параметрами.

Пример. Используем ключевые слова  name (имя), age (возраст) для функции person()

# Определение функции

def person( name, age ):    print("Name: " + name + " age: " + str(age))

# Вызов функции person

person( age = 24,   name = «Никита» ) person( name = «Мария»,  age = 22 )

Результат

Операторы сравнения в Python

Операторы сравнения в Python используются для сравнения двух объектов. Возвращаемый результат – логическое значение – True или False.

В Python есть 6 типов операторов сравнения:

== Возвращает True, если два операнда равны, в противном случае – False. a == b
!= Возвращает True, если два операнда не равны, в противном случае – False. a != b
> Возвращает True, если левый операнд больше правого, в противном случае – False. a > b
< Возвращает True, если левый операнд меньше правого, в противном случае – False. a < b
> = Возвращает True, если левый операнд больше или равен правому операнду, в противном случае – False. a > b
<= Возвращает True, если левый операнд меньше или равен правому операнду, в противном случае – False. a < b

Пример

Давайте посмотрим на простой пример использования операторов сравнения с примитивным типом данных, например с целым числом.

Операторы сравнения со строкой

Строка – это объект в программировании на Python. Посмотрим, работают ли операторы сравнения со строками или нет.

Значит ли это, что операторы сравнения будут работать с любыми объектами Python?

Давайте проверим это, создав собственный класс.

Почему оператор equals и not-equals работал, а другие – нет?

Это потому, что «объект» является основой каждого класса в Python. И объект предоставляет реализацию функций, которые используются для операторов равенства и не равно.

Функции

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

== __eq __ (self, other)
!= __ne __ (self, other)
> __gt __ (self, other)
< __lt __ (self, other)
> = __ge __ (self, other)
<= __le __ (self, other)

Резюме

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

Вложенные списки: создание

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

Очевидное решение кажется неправильным:

a =  * m] * n

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

Используя наш визуализатор, отслеживайте идентификатор списков. Если два списка имеют одинаковый номер id, это фактически тот же список в памяти.

None
n = 3
m = 4
a =  * m] * n
a = 5
print(a)

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

Возможный способ: вы можете создать список из элементов (например, из нулей), а затем сделать каждый из элементов ссылкой на другой одномерный список из элементов:

None
n = 3
m = 4
a =  * n
for i in range(n):
    a =  * m

Другой (но похожий) способ: создать пустой список, а затем к нему новый элемент раз (этот элемент должен быть списком длины ):

None
n = 3
m = 4
a = []
for i in range(n):
    a.append( * m)

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

None
n = 3
m = 4
a =  * m for i in range(n)]

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

Как удалить элемент из списка Python?

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

Следовательно, если вам нужно убрать из списка исключительно тот элемент, которым он завершается, то не нужно искать его индекс, достаточно просто использовать функцию pop() без аргументов. Если же нужен конкретный элемент, то используется его цифровое обозначение.

code_example = my_gfgg.pop(6)

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

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

del my_list

Списки (list)

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

Создание

Создание пустого списка:

names = []
names = list()

Создание списка с элементами:

names = 

Создание списка на основе другого списка:

names = 
new_names = list(names)

Создание списка повторением какого-либо элемента или другого списка:

names = 
new_names = names * 2

Создание списка с помощью конструкции range():

numbers = list(range(10))

Функция range(10) возвращает числа от 0 до 9, на основе которых создаётся новый список.

Обращение к элементу

Обращение к элементу списка производится по индексу элемента:

names

Индексы элементов начинаются с нулевого, то есть первый элемент списка имеет индекс «0», а второй — «1».

Элементы списка можно обходить циклами for и while:

for name in names:
    print(name)

Сравнение

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

list1 = 
list2 = list(range(10))

Размерность

Список в Python может быть как одномерным, так и многомерным. Выше были приведены примеры одномерных списков. Чтобы список был многомерным, например, двухмерным, каждый элемент списка должен представлять собой другой список:

names = ,
        ,
        ]

В данном примере список состоит из трёх списков, каждый из которых содержит имя и возраст. Аналогично можно создавать списки с большим количеством измерений — с большим количеством уровней вложенности.

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

names = ,
        ,
        ]
names

Преобразование

Двумерный список можно преобразовать в словарь с парами «ключ-значение»:

names = ,
        ,
        ]
new_dict = dict(names)

Матрицы

Двумерный список является матрицей, которую визуально можно представить в следующем виде:

В данном примере переменная А содержит двумерный список, т.е. список списков, каждый из которых состоит из трёх элементов. Тип list в Python не поддерживает работу со списками как с матрицами, но, тем не менее, позволяет матрицы хранить.

Set() функция и оператор ==

Функция Python set() преобразовывает список в набор, не заботясь о порядке элементов. Кроме того, мы используем оператор равенства (==) для сравнения элементов данных в списке. Разберем на следующем примере.

Пример –

 
list1 =  
list2 =  
 
a = set(list1) 
b = set(list2) 
 
if a == b: 
    print("The list1 and list2 are equal") 
else: 
    print("The list1 and list2 are not equal") 

Выход:

The list1 and list2 are equal 

Объяснение:

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

Сортировка с помощью функции sorted()

Давайте ещё раз вернёмся к вопросу сортировки в Python. Чтобы отсортировать данные и найти нужные значения, используют простую встроенную функцию sorted(), принимающую итерируемый тип и возвращающую отсортированный список.

Стандартная сортировка:

a = 3, 2, 5 ,4, 7, 1
a = sorted(a)
 print(a) # 

Сортировка кортежа:

t = ('Zane', 'Bob', 'Janet')
t = sorted(t)
 print(t) # 

Сортировка словаря:

d = {1'a', 2'b', 3'c'}
d = sorted(d)
print(d) # 

Помните, что функция sorted() возвратит список каждый раз вне зависимости от того, какой тип будет передан.

Идём дальше. Мы уже упоминали ранее метод list.sort(). Так вот, он определён только для списков, зато функция sorted() позволит отсортировать любые итерируемые объекты:

>>> sorted({1 'D', 2 'B', 3 'B', 4 'E', 5 'A'})
1, 2, 3, 4, 5

Объединение списков с помощью функции join()

Функция join() используется для присоединения повторяющегося списка к другому списку, разделенному указанными разделителями, такими как запятая, символы, дефис и т. д.

Синтаксис

 
str_name.join( iterable) 

str_name: это имя разделителя, разделяющего повторяющийся список.

iterable: это список, который содержит набор элементов и объединяется с разделителем.

Возвращаемое значение: возвращает объединенный список, разделенный указанными разделителями.

Программа для объединения двух списков с помощью функции join() и разделителя

Join.py

 
List1 =  
Str2 = ", " # It is the comma delimiter 
# use join() function to join List1 with the " . " delimiter  
Str2 = Str2.join( List1) 
 
# print the join list  
print(" Display the concatenated List1 using join() function and delimiter", Str2) 
 
List2 =  
Str3 = " - " # It is the hyphen delimiter 
# use join() function to join List2 with the " - " delimiters  
Str3 = Str3.join( List2) 
 
# print the join list  
print(" Display the concatenated List2 using join() function and delimiter", Str3) 

Выход:

Display the concatenated List1 using join() function and delimiter Apple, Orange, Banana, Mango, Grapes 
 Display the concatenated List2 using join() function and delimiter Sunday - Monday - Tuesday - Wednesday - Thursday 

Программа для присоединения к списку без использования разделителя

Prog.py

 
# declare a python list  
Lt1 =  
print( " Display the elements of the List L1 " , Lt1) 
L2 = '  '  # declare any empty string without defining any delimiter 
Ret = L2.join( Lt1) # use join method to join L1 list with L2 
print( " Display the List without using delimiters", Ret)   

Выход:

Display the elements of the List L1   
 Display the List without using delimiters j  a  v  a  t  p  o  i  n  t 

Метод Python collection.counter()

Метод collection.counter() можно использовать для эффективного сравнения списков. Функция counter() подсчитывает частоту элементов в списке и сохраняет данные в виде словаря в формате <значение>: <частота>.

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

Примечание. Порядок в списке не влияет на метод counter().

Пример:

import collections 


l1 =  
l2 =  
l3 =  

if collections.Counter(l1) == collections.Counter(l2):
    print ("The lists l1 and l2 are the same") 
else: 
    print ("The lists l1 and l2 are not the same") 

if collections.Counter(l1) == collections.Counter(l3):
    print ("The lists l1 and l3 are the same") 
else: 
    print ("The lists l1 and l3 are not the same") 

Выход:

The lists l1 and l2 are not the same
The lists l1 and l3 are the same

Ключевое слово in / not in

Проверить, содержится ли элемент в кортеже, можно с помощью ключевого слова in.

Поместите перед in ключевое слово not для проверки отсутствия элемента в кортеже.

Те же операции с ключевыми словами in и not in сработают и со списками.

Сложение кортежей и списков

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

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

Итерирование

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

В следующем примере элемент Москва записан в списке с индексом 0, Хельсинки с индексом 1, а ‘Анкара’ с индексом 2.

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

Например, с помощью цикла for, выполняющего перебор списка строк, и метода upper() можно сделать символы каждой строки прописными:

Как показано в примерах выше, цикл for определяется синтаксисом: for имя_переменной in имя_итерируемого_объекта: где *имя_переменной – выбранное вами имя переменной, в которую каждую итерацию
цикла будет записываться очередное значение из итерируемого объекта.

Рейтинг
( Пока оценок нет )
Editor
Editor/ автор статьи

Давно интересуюсь темой. Мне нравится писать о том, в чём разбираюсь.

Понравилась статья? Поделиться с друзьями:
Люкс-хост
Добавить комментарий

;-) :| :x :twisted: :smile: :shock: :sad: :roll: :razz: :oops: :o :mrgreen: :lol: :idea: :grin: :evil: :cry: :cool: :arrow: :???: :?: :!:

Adblock
detector