В чем разница между методами списка append () и extend ()?

3113
Claudiu 31 Окт 2008 в 08:55

20 ответов

Лучший ответ

append: добавляет объект в конце .

x = [1, 2, 3]
x.append([4, 5])
print (x)

Дает вам: [1, 2, 3, [4, 5]]


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

x = [1, 2, 3]
x.extend([4, 5])
print (x)

Дает вам: [1, 2, 3, 4, 5]

5405
Karl Knechtel 6 Окт 2019 в 20:39
129
В чем разница между extend и простым использованием оператора сложения - в приведенном выше примере x = x + [4, 5]?
 – 
Rohan
30 Май 2017 в 01:10
326
На самом деле существует большая разница - x + [4, 5] дает вам новый список, назначенный x - x.extend() изменяет исходный список. Я уточняю в своем ответе ниже.
 – 
Aaron Hall♦
17 Июл 2017 в 20:14
1
@ Рохан, но он такой же, как x += [4,5].
 – 
Astitva Srivastava
13 Дек 2018 в 17:54
2
На самом деле, я думаю, что расширение быстрее с точки зрения байт-кода
 – 
MilkyWay90
21 Дек 2018 в 19:22
2
Ключевое слово при использовании append - Объект . Если вы попытаетесь использовать extend и передадите словарь , он добавит ключ , а не весь хеш в конец массива.
 – 
Anthony
15 Мар 2019 в 17:53

append добавляет элемент в список, а extend объединяет первый список с другим списком (или другим повторяемым, не обязательно списком).

>>> li = ['a', 'b', 'mpilgrim', 'z', 'example']
>>> li
['a', 'b', 'mpilgrim', 'z', 'example']

>>> li.append("new")
>>> li
['a', 'b', 'mpilgrim', 'z', 'example', 'new']

>>> li.append(["new", 2])
>>> li
['a', 'b', 'mpilgrim', 'z', 'example', 'new', ['new', 2]]

>>> li.insert(2, "new")
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', ['new', 2]]

>>> li.extend(["two", "elements"])
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', ['new', 2], 'two', 'elements']
667
Jason Short 4 Сен 2019 в 18:28

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

  • append добавляет свой аргумент как отдельный элемент в конец списка. Длина самого списка увеличится на единицу.
  • extend перебирает свой аргумент, добавляя каждый элемент в список, расширяя список. Длина списка будет увеличиваться на сколько элементов было в итерируемом аргументе.

append

Метод list.append добавляет объект в конец списка.

my_list.append(object) 

Каким бы ни был объект, будь то число, строка, другой список или что-то еще, он добавляется в конец my_list как отдельная запись в списке.

>>> my_list
['foo', 'bar']
>>> my_list.append('baz')
>>> my_list
['foo', 'bar', 'baz']

Так что имейте в виду, что список - это объект. Если вы добавите еще один список в список, первый список будет одним объектом в конце списка (что может быть не тем, что вам нужно):

>>> another_list = [1, 2, 3]
>>> my_list.append(another_list)
>>> my_list
['foo', 'bar', 'baz', [1, 2, 3]]
                     #^^^^^^^^^--- single item at the end of the list.

extend

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

my_list.extend(iterable)

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

>>> my_list
['foo', 'bar']
>>> another_list = [1, 2, 3]
>>> my_list.extend(another_list)
>>> my_list
['foo', 'bar', 1, 2, 3]

Имейте в виду, что строка является итерируемой, поэтому, если вы расширяете список строкой, вы добавляете каждый символ при итерации по строке (что может быть не тем, что вам нужно):

>>> my_list.extend('baz')
>>> my_list
['foo', 'bar', 1, 2, 3, 'b', 'a', 'z']

Перегрузка оператора, __add__ (+) и __iadd__ (+=)

Оба оператора + и += определены для list. Они семантически похожи на extension.

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

my_list += another_list изменяет список на месте (это оператор на месте, а списки являются изменяемыми объектами, как мы видели), поэтому он не создает новый список. Он также работает так же, как и extend, в том смысле, что вторая итерация может быть любой итерируемой.

Не запутайтесь - my_list = my_list + another_list не эквивалентно += - он дает вам новый список, назначенный my_list.

Сложность времени

Append имеет постоянную временную сложность, O (1).

Extend имеет временную сложность O (k).

Итерации по множеству вызовов append усложняются, делая его эквивалентным расширению, и, поскольку итерация расширения реализована в C, это всегда будет быстрее, если вы намереваетесь добавлять последовательные элементы из итерируемого объекта в список.

Производительность

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

def append(alist, iterable):
    for item in iterable:
        alist.append(item)

def extend(alist, iterable):
    alist.extend(iterable)

Итак, рассчитаем время для них:

import timeit

>>> min(timeit.repeat(lambda: append([], "abcdefghijklmnopqrstuvwxyz")))
2.867846965789795
>>> min(timeit.repeat(lambda: extend([], "abcdefghijklmnopqrstuvwxyz")))
0.8060121536254883

Обращение к комментарию по расписанию

Комментатор сказал:

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

Делайте семантически правильные вещи. Если вы хотите добавить все элементы в итерацию, используйте extend. Если вы просто добавляете один элемент, используйте append.

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

def append_one(a_list, element):
    a_list.append(element)

def extend_one(a_list, element):
    """creating a new list is semantically the most direct
    way to create an iterable to give to extend"""
    a_list.extend([element])

import timeit

И мы видим, что попытки создать итерацию просто для использования extension - это (незначительная) трата времени:

>>> min(timeit.repeat(lambda: append_one([], 0)))
0.2082819009956438
>>> min(timeit.repeat(lambda: extend_one([], 0)))
0.2397019260097295

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

Кроме того, эти тайминги не так важны. Я просто показываю им, что в Python выполнение семантически правильных действий означает выполнение действий Правильно Way ™.

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

Вывод

Мы видим, что extend семантически понятнее и может работать намного быстрее, чем append, , когда вы намереваетесь добавить каждый элемент в итерацию к списку.

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

528
stillanoob 3 Окт 2018 в 17:22
1
Холл. Одно небольшое замечание по алгоритму расчета времени. «extend_one» может возвращать «немного неправильное» время, потому что также задействовано создание списка. Возможно, лучше создать элементы как переменные (ex1 = 0 и ex2 = [0]) и передать эти переменные, если вы хотите быть более строгими.
 – 
ilias iliadis
31 Мар 2018 в 21:06
20
Действительно прекрасный ответ. А как насчет производительности l1 += l2 по сравнению с l1.extend(l2)?
 – 
Jean-Francois T.
23 Апр 2018 в 06:54
7
@ Jean-FrancoisT: l1 += l2 и l1.extend(l2) в конечном итоге выполняют один и тот же код (функция list_extend в listobject.c). Единственные различия: 1. += переназначает l1 (самому себе для list s, но переназначение поддерживает неизменяемые типы, которые не являются одним и тем же объектом после), что делает его незаконным, если l1 на самом деле является атрибутом неизменяемого объекта; например, t = ([],), t[0] += lst не сработает, а t[0].extend(lst) будет работать. 2. l1 += l2 использует выделенные байт-коды, а l1.extend(l2) использует обобщенный метод диспетчеризации; это делает += быстрее, чем extend.
 – 
ShadowRanger
17 Авг 2018 в 22:10
3
Тот факт, что += должен переназначить l1, действительно означает, что в некоторых случаях более медленная отправка extend частично или полностью компенсируется отсутствием повторного назначения для левой стороны. Например, если list является атрибутом объекта, self.l1 += l2 и self.l1.extend(l2) имеют одинаковую производительность в моей установке Python 3.6 просто потому, что реальная операция больше похожа на self.l1 = self.l1.__iadd__(l2), это означает, что он должен выполнять умеренно дорогостоящий STORE_ATTR, в котором self.l1.extend(l2) не должен.
 – 
ShadowRanger
17 Авг 2018 в 22:20
2
Простое сравнение в локальных тестах: для локальной переменной (так что += просто использует STORE_FAST, что очень дешево), где добавляемым значением является существующий list с одним элементом в если операция повторяется 1000 раз, на += в среднем ушло около 33 нс, а на extend - 78 нс, то есть разница в 45 нс. Если l1 является глобальным (требуется более дорогой STORE_GLOBAL), разница уменьшается до 17 нс. Если l1 на самом деле является local.l1 (требуется еще более дорогой STORE_ATTR), значимой разницы между += и extend нет (время примерно одинаково; extend иногда выигрывает).
 – 
ShadowRanger
17 Авг 2018 в 22:32

append добавляет один элемент. extend добавляет список элементов.

Обратите внимание, что если вы передадите список для добавления, он все равно добавит один элемент:

>>> a = [1, 2, 3]
>>> a.append([4, 5, 6])
>>> a
[1, 2, 3, [4, 5, 6]]
126
Greg Hewgill 31 Окт 2008 в 08:57

Добавить vs Расширить

enter image description here

С помощью append вы можете добавить один элемент, который расширит список:

>>> a = [1,2]
>>> a.append(3)
>>> a
[1,2,3]

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

>>> a.append([4,5])
>>> a
>>> [1,2,3,[4,5]]

Чтобы у вас получился вложенный список

Вместо этого вы можете расширить один элемент следующим образом

>>> a = [1,2]
>>> a.extend([3])
>>> a
[1,2,3]

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

>>> a.extend([4,5,6])
>>> a
[1,2,3,4,5,6]

Добавление одного элемента обоими методами

enter image description here

Как append, так и extend могут добавить один элемент в конец списка, хотя append проще.

Добавить 1 элемент

>>> x = [1,2]
>>> x.append(3)
>>> x
[1,2,3]

Расширить один элемент

>>> x = [1,2]
>>> x.extend([3])
>>> x
[1,2,3]

Добавление дополнительных элементов ... с разными результатами

Если вы используете добавление более чем для одного элемента, вам нужно передать список элементов в качестве аргументов, и вы получите ВЛОЖЕННЫЙ список!

>>> x = [1,2]
>>> x.append([3,4])
>>> x
[1,2,[3,4]]

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

>>> z = [1,2] 
>>> z.extend([3,4])
>>> z
[1,2,3,4]

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

enter image description here

enter image description here

74
Clint Chelak 8 Май 2020 в 13:02

Следующие два фрагмента семантически эквивалентны:

for item in iterator:
    a_list.append(item)

А также

a_list.extend(iterator)

Последнее может быть быстрее, поскольку цикл реализован в C.

63
Kenly 24 Ноя 2016 в 14:00
21
Расширение на моей машине примерно в 4 раза быстрее, чем добавление в цикле (16us против 4us для 100 циклов нулей)
 – 
Alex L
27 Дек 2012 в 12:29
6
extend(), вероятно, выделяется заранее, а append() - нет.
 – 
Mad Physicist
23 Окт 2015 в 16:43
@MadPhysicist: Для полноты картины будут моменты, когда extend() не может разумно выполнить предварительное выделение, поскольку некоторые итерации не реализуют __len__(), но, как и вы, я бы удивлен, если не попробует. Некоторый выигрыш в производительности также достигается за счет выполнения итерационной части на чистом C вместо Python, как указано в ответе Аарона.
 – 
Soren Bjornstad
28 Июл 2019 в 06:43

Метод append() добавляет один элемент в конец списка.

x = [1, 2, 3]
x.append([4, 5])
x.append('abc')
print(x)
# gives you
[1, 2, 3, [4, 5], 'abc']

Метод extend() принимает один аргумент, список, и добавляет каждый из элементов аргумента в исходный список. (Списки реализованы как классы. «Создание» списка на самом деле создает экземпляр класса. Таким образом, список имеет методы, которые работают с ним.)

x = [1, 2, 3]
x.extend([4, 5])
x.extend('abc')
print(x)
# gives you
[1, 2, 3, 4, 5, 'a', 'b', 'c']

Из Погрузитесь в Python .

45
Georgy 21 Май 2019 в 12:08
Вы не можете расширить только с помощью 6, поскольку он не повторяется. И второй вывод в вашем примере неверен. 'abc' добавляется как отдельный элемент, поскольку вы передали его в extend как список с одним элементом ['abc']: [1, 2, 3, 4, 5, 'abc']. Чтобы ваш пример вывода был правильным, измените строку abc на: x.extend('abc'). И удалите x.extend(6) или измените его на x.extend([6]).
 – 
aneroid
25 Сен 2014 в 13:28

append(object) - обновляет список, добавляя объект в список.

x = [20]
# List passed to the append(object) method is treated as a single object.
x.append([21, 22, 23])
# Hence the resultant list length will be 2
print(x)
--> [20, [21, 22, 23]]

extend(list) - по существу объединяет два списка.

x = [20]
# The parameter passed to extend(list) method is treated as a list.
# Eventually it is two lists being concatenated.
x.extend([21, 22, 23])
# Here the resultant list's length is 4
print(x)
[20, 21, 22, 23]
22
Peter Mortensen 5 Июн 2018 в 12:22

extend() можно использовать с аргументом итератора. Вот пример. Вы хотите составить список из списка списков следующим образом:

Из

list2d = [[1,2,3],[4,5,6], [7], [8,9]]

Вы хотите

>>>
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Вы можете использовать для этого itertools.chain.from_iterable(). Результатом этого метода является итератор. Его реализация эквивалентна

def from_iterable(iterables):
    # chain.from_iterable(['ABC', 'DEF']) --> A B C D E F
    for it in iterables:
        for element in it:
            yield element

Вернемся к нашему примеру, мы можем сделать

import itertools
list2d = [[1,2,3],[4,5,6], [7], [8,9]]
merged = list(itertools.chain.from_iterable(list2d))

И получите список разыскиваемых.

Вот как эквивалентно extend() можно использовать с аргументом итератора:

merged = []
merged.extend(itertools.chain.from_iterable(list2d))
print(merged)
>>>
[1, 2, 3, 4, 5, 6, 7, 8, 9]
20
Peter Mortensen 5 Июн 2018 в 12:16
2
Этот ответ не контрастирует с дополнением и, следовательно, не отвечает на вопрос
 – 
pppery
13 Июл 2018 в 06:20

Это эквивалент append и extend с использованием оператора +:

>>> x = [1,2,3]
>>> x
[1, 2, 3]
>>> x = x + [4,5,6] # Extend
>>> x
[1, 2, 3, 4, 5, 6]
>>> x = x + [[7,8]] # Append
>>> x
[1, 2, 3, 4, 5, 6, [7, 8]]
19
Peter Mortensen 14 Янв 2015 в 22:14
2
Почему нет = +?! Более кратким
 – 
denfromufa
13 Сен 2015 в 05:18

append () : в основном используется в Python для добавления одного элемента.

Пример 1:

>> a = [1, 2, 3, 4]
>> a.append(5)
>> print(a)
>> a = [1, 2, 3, 4, 5]

Пример 2:

>> a = [1, 2, 3, 4]
>> a.append([5, 6])
>> print(a)
>> a = [1, 2, 3, 4, [5, 6]]

extend () : где extend () используется для объединения двух списков или вставки нескольких элементов в один список.

Пример 1:

>> a = [1, 2, 3, 4]
>> b = [5, 6, 7, 8]
>> a.extend(b)
>> print(a)
>> a = [1, 2, 3, 4, 5, 6, 7, 8]

Пример 2:

>> a = [1, 2, 3, 4]
>> a.extend([5, 6])
>> print(a)
>> a = [1, 2, 3, 4, 5, 6]
16
Bahrom 10 Окт 2017 в 22:56

Интересный момент, на который намекали, но не объясняли, заключается в том, что расширение выполняется быстрее, чем добавление. Любой цикл, который имеет добавление внутри, следует рассматривать как замененный на list.extend (loaded_elements).

Имейте в виду, что добавление новых элементов может привести к перераспределению всего списка в лучшее место в памяти. Если это сделать несколько раз, потому что мы добавляем по одному элементу за раз, общая производительность снизится. В этом смысле list.extend аналогичен "" .join (stringlist).

12
bconstanzo 6 Авг 2014 в 16:46

Добавить добавляет сразу все данные. Все данные будут добавлены во вновь созданный индекс. С другой стороны, extend, как следует из названия, расширяет текущий массив.

Например

list1 = [123, 456, 678]
list2 = [111, 222]

С append мы получаем:

result = [123, 456, 678, [111, 222]]

На extend мы получаем:

result = [123, 456, 678, 111, 222]
12
Peter Mortensen 9 Апр 2017 в 09:29

Английский словарь определяет слова append и extend как:

добавить : добавить (что-нибудь) в конец письменного документа.
расширить : увеличить. Увеличить или расширить


Обладая этими знаниями, теперь давайте разберемся

1) Разница между append и extend

append :

  • Добавляет любой объект Python как есть в конец списка (т. Е. Как последний элемент в списке).
  • Результирующий список может быть вложенным и содержать разнородные элементы (например, список, строку, кортеж, словарь, набор и т. Д.).

extend :

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

2) Сходство между append и extend

  • Оба приводят ровно один аргумент.
  • Оба изменяют список на месте .
  • В результате оба возвращают None.

Пример

lis = [1, 2, 3]

# 'extend' is equivalent to this
lis = lis + list(iterable)

# 'append' simply appends its argument as the last element to the list
# as long as the argument is a valid Python object
list.append(object)
8
Gavriel Cohen 12 Сен 2019 в 15:02

Надеюсь, что смогу внести полезное дополнение к этому вопросу. Если в вашем списке хранится объект определенного типа, например Info, вот ситуация, в которой метод extend не подходит: в цикле for и генерации объекта Info каждый раз, используя extend для сохранения его в вашем списке, он терпит неудачу. Исключение, как показано ниже:

TypeError: объект Info не повторяется

Но если вы используете метод append, результат нормальный. Поскольку каждый раз, используя метод extend, он всегда будет рассматривать его как список или любой другой тип коллекции, перебирать его и помещать после предыдущего списка. Очевидно, что конкретный объект не может быть повторен.

5
Peter Mortensen 9 Апр 2017 в 09:55

Чтобы различать их интуитивно

l1 = ['a', 'b', 'c']
l2 = ['d', 'e', 'f']
l1.append(l2)
l1
['a', 'b', 'c', ['d', 'e', 'f']]

Это как l1 воспроизвести тело внутри своего тела (вложенное).

# Reset l1 = ['a', 'b', 'c']
l1.extend(l2)
l1
['a', 'b', 'c', 'd', 'e', 'f']

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

Кроме того, для вашей справки я составляю исчерпывающий список всех методов списка.

list_methods = {'Add': {'extend', 'append', 'insert'},
                'Remove': {'pop', 'remove', 'clear'}
                'Sort': {'reverse', 'sort'},
                'Search': {'count', 'index'},
                'Copy': {'copy'},
                }
4
Calculus 7 Июн 2018 в 04:44

extend(L) расширяет список, добавляя все элементы в данном списке L.

>>> a
[1, 2, 3]
a.extend([4])  #is eqivalent of a[len(a):] = [4]
>>> a
[1, 2, 3, 4]
a = [1, 2, 3]
>>> a
[1, 2, 3]
>>> a[len(a):] = [4]
>>> a
[1, 2, 3, 4]
2
Georgy 21 Май 2019 в 12:31

append «расширяет» список (на месте) на только один элемент , единственный переданный объект (в качестве аргумента).

extend «расширяет» список (на месте) на столько элементов, сколько содержит переданный объект (в качестве аргумента).

Это может немного сбивать с толку для объектов str.

  1. Если вы передадите строку в качестве аргумента: append добавит одну строку в конце, но extend добавит столько "одиночных" элементов 'str', сколько длина этой строки.
  2. Если вы передадите список строк в качестве аргумента: append все равно добавит один элемент "список" в конец и extend добавит столько элементов списка, сколько длина переданного списка.
def append_o(a_list, element):
    a_list.append(element)
    print('append:', end = ' ')
    for item in a_list:
        print(item, end = ',')
    print()

def extend_o(a_list, element):
    a_list.extend(element)
    print('extend:', end = ' ')
    for item in a_list:
        print(item, end = ',')
    print()
append_o(['ab'],'cd')

extend_o(['ab'],'cd')
append_o(['ab'],['cd', 'ef'])
extend_o(['ab'],['cd', 'ef'])
append_o(['ab'],['cd'])
extend_o(['ab'],['cd'])

Производит:

append: ab,cd,
extend: ab,c,d,
append: ab,['cd', 'ef'],
extend: ab,cd,ef,
append: ab,['cd'],
extend: ab,cd,
0
ilias iliadis 31 Мар 2018 в 21:46

Добавление и расширение - это один из механизмов расширяемости в Python.

Добавить: добавляет элемент в конец списка.

my_list = [1,2,3,4]

Чтобы добавить новый элемент в список, мы можем использовать метод append следующим образом.

my_list.append(5)

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

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

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

Example: my_list = [1,2,3,4]
my_list[4, 'a']
my_list
[1,2,3,4,'a']

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

a = [1,2]
b = [3]
a.append(b)
print (a)
[1,2,[3]]

Если мы попытаемся получить доступ к элементу на позиции 2, мы получим список ([3]) вместо элемента. Чтобы объединить два списка, нам нужно будет использовать append.

a = [1,2]
b = [3]
a.extend(b)
print (a)
[1,2,3]

Чтобы присоединиться к нескольким спискам

a = [1]
b = [2]
c = [3]
a.extend(b+c)
print (a)
[1,2,3]
0
vivek 17 Июл 2018 в 10:19
2
Почему вы отвечаете на вопрос, на который уже много раз отвечали? Этому вопросу 10 лет ...
 – 
Mike - SMT
3 Авг 2018 в 16:19

Вы можете использовать "+" для возврата расширения вместо расширения на месте.

l1=range(10)

l1+[11]

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11]

l2=range(10,1,-1)

l1+l2

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4, 3, 2]

Аналогично += для поведения на месте, но с небольшими отличиями от append и extend. Одно из самых больших отличий += от append и extend заключается в том, что он используется в областях видимости функций, см. это сообщение в блоге .

37
Prakhar Trivedi 5 Янв 2017 в 13:30
Влияет ли использование «+» для возврата расширения на временную сложность?
 – 
franklin
19 Июл 2015 в 06:59
5
@franklin, подробности см. в этом ответе: stackoverflow.com/a/28119966/2230844
 – 
denfromufa
21 Июл 2015 в 17:50
1
Я не понимаю, как это отвечает на вопрос
 – 
pppery
13 Июл 2018 в 06:20