Это всегда меня смущало. Кажется, что это было бы приятнее:
my_list = ["Hello", "world"]
print(my_list.join("-"))
# Produce: "Hello-world"
Чем так:
my_list = ["Hello", "world"]
print("-".join(my_list))
# Produce: "Hello-world"
Есть ли конкретная причина, по которой это происходит?
Это связано с тем, что объединить можно любую итерируемую переменную, а не только списки, но результат и "объединитель" всегда являются строками.
Например:
import urllib2
print('\n############\n'.join(
urllib2.urlopen('http://data.stackexchange.com/users/7095')))
Об этом шла речь в String методы... наконец резьба в языке Python-разработчиков достичь, и было принято Гвидо. Этот поток начался в июне 1999, и str.присоединяйтесь к
был включен в Python 1.6, которая была выпущена в сентябре 2000 года (и поддерживает Юникод). Питон 2.0 (поддерживаемые методы стр
в том числе присоединиться
) был выпущен в октябре 2000.
.присоединяйтесь к(сл)
сл.присоединиться(ул.)
сл.уменьшить(ул.)
списка
в кортеже, но все последовательности/итераторы.сл.присоединиться(ул.)
вводит неожиданные зависимости от последовательности до ул./Юникод.сентября
) не должен быть пропущен. Явное лучше, чем неявное.Нет никаких других причин, предлагаемых в этой теме.
Вот некоторые дополнительные мысли (мои собственные, и моего друга'ы):
Гвидо'решение записывается в [исторические почта][2], определения ул. присоединяйтесь к(сл)
:
смешно, но это не кажется правильным! Барри, дерзайте... --Гвидо ван Россум
[2]: http://mail.python.org/pipermail/python-dev/1999-June/095436.html на "историческую почте и"
Потому что метод join()
находится в классе string, а не в классе list?
Я согласен, что это выглядит забавно.
Смотрите http://www.faqs.org/docs/diveintopython/odbchelper_join.html:
Историческая справка. Когда я впервые изучал Python, я ожидал, что join будет методом списка, который в качестве аргумента будет принимать разделитель в качестве аргумента. Многие людей считают так же, и есть история, стоящая за методом join. До до Python 1.6 у строк не было всех > этих полезных методов. этих полезных методов. Существовал отдельный модуль string, который содержал все строковые функции; каждая из них функция принимала строку в качестве первого > аргумента. аргумент. Эти функции были сочтены достаточно важными, чтобы поместить их на самих строках, что имело смысл для таких функций, как нижняя, верхняя и split. Но многие приверженцы Python программисты возражали против нового метода присоединения. метода, утверждая, что он должен быть > методом списка. методом списка, или что он > должен > перемещаться. вообще не должен перемещаться, а просто оставаться частью старого модуля string (который в котором все еще есть много полезных вещей). Я использую исключительно новый метод join, но вы увидите код, написанный любым > способом. способом, и если это действительно беспокоит вас, вы можете использовать старую функцию string.join. вместо нее.
--- Марк Пилгрим, Погружение в Python
Я согласен, что это'ы нелогичным на первый, но там'ы веская причина. Присоединиться может'т быть способ из списка, потому что:
Существует два метода связывания (в Python 3.0):
>>> b"".join
<built-in method join of bytes object at 0x00A46800>
>>> "".join
<built-in method join of str object at 0x00A28D40>
Если Join был метод список, то он будет должен проверить его параметры, чтобы решить, какой из них позвонить. И вы можете'т присоединиться ул. байта и вместе, так как они уже сейчас имеет смысл.
почему это строки.присоединиться(список) "вместо" список.присоединяйтесь(строка)`?
Это потому, что "присоединиться" - это на "строка" и способ! Он создает строку из любой итерируемый. Если мы застряли метод в списках, а когда мы итерируемые объекты, которые еще'т списки?
Что если у вас есть набор строк? Если бы это было список
метод, вам придется сбросить все такое итератор строк, как список
, прежде чем вы могли бы объединить элементы в одну строку! Например:
some_strings = ('foo', 'bar', 'baz')
Позвольте'ы ролл наш собственный список метода Join:
class OurList(list):
def join(self, s):
return s.join(self)
И чтобы его использовать, обратите внимание, что мы должны сначала создать список из каждой повторяемое присоединиться к строкам в том, что повторяемое, теряя памяти и вычислительной мощности:
>>> l = OurList(some_strings) # step 1, create our list
>>> l.join(', ') # step 2, use our list join method!
'foo, bar, baz'
Итак, мы видим, мы должны добавить дополнительный шаг, чтобы использовать наш метод списка, а не просто используя метод String строение:
>>> ' | '.join(some_strings) # a single step!
'foo | bar | baz'
Алгоритм Python использует, чтобы создать итоговую строку с `стр.присоединись к фактически передавать повторяемое дважды, так что если вы не предоставите его выражение генератора, он должен материализоваться его в список, прежде чем он может создать итоговую строку.
Таким образом, при прохождении вокруг генераторы, как правило, лучше, чем списочные включения, ул.`.присоединяйтесь-это исключение:
>>> import timeit
>>> min(timeit.repeat(lambda: ''.join(str(i) for i in range(10) if i)))
3.839168446022086
>>> min(timeit.repeat(lambda: ''.join([str(i) for i in range(10) if i])))
3.339879313018173
Тем не менее, НТР.присоединиться к операции до сих пор семантически и "строка" в эксплуатацию, так что все равно есть смысл иметь его на
ул` объект, чем на разное итерируемые объекты.
Считайте это естественным ортогональным операции в Сплит.
Я понимаю, почему оно применимо к чему Iterable и так можете'т быть легко реализованы просто о списке.
Для удобства чтения, я'd, как, чтобы увидеть его на языке, но я не'т думаю, что это на самом деле возможно - если iterability были интерфейсе, то он может быть добавлен к интерфейсу, но это всего лишь условность и так там's нет централизованного способа, чтобы добавить его в набор вещей, которые повторяемое.
В первую очередь потому, что результатом someString.join()
является строка.
Последовательность (список, кортеж или что-то еще) не появляется в результате, только строка. Поскольку результатом является строка, это имеет смысл как метод строки.
-
в "-то".присоединиться(списка my_list) заявляет, что при преобразовании к строке от вхождения элементов в список.Это'ы, ориентированных на результат.(просто для простоты памяти и понимания)
Я сделаю исчерпывающий шпаргалка из methods_of_string для вашей справки.
string_methonds_44 = {
'convert': ['join','split', 'rsplit','splitlines', 'partition', 'rpartition'],
'edit': ['replace', 'lstrip', 'rstrip', 'strip'],
'search': ['endswith', 'startswith', 'count', 'index', 'find','rindex', 'rfind',],
'condition': ['isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isnumeric','isidentifier',
'islower','istitle', 'isupper','isprintable', 'isspace', ],
'text': ['lower', 'upper', 'capitalize', 'title', 'swapcase',
'center', 'ljust', 'rjust', 'zfill', 'expandtabs','casefold'],
'encode': ['translate', 'maketrans', 'encode'],
'format': ['format', 'format_map']}
Оба не симпатичны.
строку.присоединиться(хз, размежевать) означает, что модуль string известно о существовании списка, который он имеет дело знать об этом, поскольку строка модуль работает только со строками.
список.объединить(разделить) - это немного лучше, потому что мы'вновь так привыкли струн фундаментальный тип(и на разных языках говорящие, они). Однако это означает, что присоединиться должна быть динамически отправляется, потому что в произвольном контексте а.Сплит (на"\Н", у)
питона компилятор может не знать, что это, и нужно искать его(аналогично таблица подстановки), который является дорогим, если вы делаете это много раз.
если в Python во время выполнения компилятор знает, что список представляет собой встроенный модуль, он может пропустить динамический поиск и кодирования намерениях в байт-код напрямую, тогда как в противном случае он должен динамически решить, что "присоединиться" из "А", которая может быть до нескольких слоев наследованию на вызов(т. к. между вызовами, смысл присоединиться может измениться, потому что Python-это динамический язык).
к сожалению, это основной недостаток абстракции; неважно, какой забор вы выберете, ваш забор будет иметь смысл только в контексте проблемы вы'вновь пытается решить, и как таковой вы никогда не может быть последовательной абстракции, которая не'т быть согласованы с идеологиям, как вы начнете клеить их вместе, не оборачивая их в вид, который соответствует вашей идеологии. Зная это, питон'ы подход является более гибким, поскольку он'ы дешевле, это's до вас, чтобы платить больше, чтобы это выглядело как "приятнее" ну, либо сделать свой собственный завертчицы, или свой собственный препроцессор.
Списка my_list переменные `и в
"-"в оба объекты. В частности, они'вэ экземпляры перечислить классы
иул
, соответственно. "Присоединиться" функция принадлежит к ул. класс. Таким образом, синтаксис в
"-то".присоединиться(списка my_list) используется потому, что объект в "-" у
принимает списка my_list
в качестве входных данных.