Це завжди мене бентежило. Здається, це було б приємніше:

my_list = ["Hello", "world"]
print(my_list.join("-"))
# Produce: "Hello-world"

Чим це:

my_list = ["Hello", "world"]
print("-".join(my_list))
# Produce: "Hello-world"

Чи є конкретна причина, що вона така?

Це тому, що можна приєднати будь-який ітерабельний (наприклад, список, кортеж, диктант, встановити), але результат і "столяр" повинні бути рядками.

Наприклад:

'_'.join(['welcome', 'to', 'stack', 'overflow'])
'_'.join(('welcome', 'to', 'stack', 'overflow'))

'welcome_to_stack_overflow'

Використання чогось іншого, ніж рядки, призведе до такої помилки:

TypeError: елемент послідовності 0: очікуваний екземпляр str, int знайдено

Про це йшлося в методах String ... нарешті, нитка в архіві Python-Dev і була прийнята Гвідо. Цей потік розпочався в червні 1999 року і str.joinбув включений в Python 1.6, який був випущений у вересні 2000 року (і підтримується Unicode). Python 2.0 ( strвключаючи підтримувані методи join) був випущений у жовтні 2000 року.

• У цій темі запропоновано чотири варіанти:
  • str.join(seq)
  • seq.join(str)
  • seq.reduce(str)
  • join як вбудована функція
• Гвідо хотів підтримувати не тільки lists, tuples, але й усі послідовності / ітерабелі.
• seq.reduce(str) новачкам важко.
• seq.join(str) вводить несподівану залежність від послідовностей до str / unicode.
• join()як вбудована функція підтримувала б лише конкретні типи даних. Тому використовувати вбудований простір імен - це не добре. Якщо join()підтримується багато типів даних, створити оптимізовану реалізацію буде складно, якщо реалізувати за допомогою __add__методу, то це O (n²).
• Рядок розділювача ( sep) не слід опускати. Явне краще, ніж неявне.

Немає інших причин, пропонованих у цій темі.

Ось кілька додаткових думок (мої власні та мої друзі):

• Підтримка Unicode надходила, але вона не була остаточною. У той час UTF-8, швидше за все, збирався замінити UCS2 / 4. Для обчислення загальної довжини буфера рядків UTF-8 необхідно знати правило кодування символів.
• У той час Python вже зважився на загальне правило інтерфейсу послідовностей, де користувач може створити подібний до послідовностей (ітерабельний) клас. Але Python не підтримував розширення вбудованих типів до 2.2. На той час було важко забезпечити базовий ітерабельний клас (про який йдеться в іншому коментарі).

Рішення Гідо записується в історичну пошту , приймаючи рішення про str.join(seq):

Смішно, але це здається правильно! Баррі, піди на це ... -
Гуйдо ван Россум

Тому що join()метод знаходиться в рядковому класі замість класу list?

Я згоден, це виглядає смішно.

Дивіться http://www.faqs.org/docs/diveintopython/odbchelper_join.html :

Історична записка.Коли я вперше дізнався Python, я очікував, що приєднання буде методом списку, який буде брати роздільник як аргумент. Багато людей почуваються так само, і за методом приєднання стоїть історія. До Python 1.6, рядки не мали всіх цих корисних методів. Існував окремий рядковий модуль, який містив усі функції рядка; кожна функція приймала рядок як свій перший аргумент. Функції вважалися достатньо важливими для розміщення на самих рядках, що мало сенс для таких функцій, як нижня, верхня та роздвоєна. Але багато жорстоких програмістів 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>

Якщо приєднання було методом списку, тоді доведеться перевірити його аргументи, щоб вирішити, кого з них викликати. І ви не можете об'єднати байт і str разом, тому спосіб, який вони мають зараз, має сенс.

Чому це string.join(list)замість list.join(string)?

Це тому join, що це "рядковий" метод! Він створює рядок з будь-якого ітерабельного. Якщо ми закріпили метод у списках, що робити, коли у нас є ітерабелі, які не є списками?

Що робити, якщо у вас є кортеж струн? Якби це listметод, вам слід було б передати кожен такий ітератор рядків як a, listперш ніж ви зможете з'єднати елементи в єдиний рядок! Наприклад:

some_strings = ('foo', 'bar', 'baz')

Розгорнемо власний метод приєднання до списку:

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'

Отже, ми бачимо, що ми повинні додати додатковий крок для використання нашого списку, а не просто вбудованого рядкового методу:

>>> ' | '.join(some_strings) # a single step!
'foo | bar | baz'

Продуктивність Caveat для генераторів

Алгоритм, який Python використовує для створення остаточного рядка, str.joinфактично повинен передати ітерабельний двічі, тож якщо ви надаєте йому вираз генератора, він повинен спочатку його матеріалізувати до списку, перш ніж він зможе створити остаточний рядок.

Таким чином, проходження генераторів, як правило, краще, ніж розуміння списку, str.joinє винятком:

>>> 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

Тим не менш, str.joinоперація все ще семантично є "рядковою" операцією, тому все одно має сенс мати її на strоб'єкті, ніж на різних ітерабелях.

Розгляньте це як природну ортогональну операцію з розколу.

Я розумію, чому це застосовно до всього, що можна змінити, і тому його не можна легко реалізувати лише у списку.

Для читабельності я хотів би бачити це мовою, але не думаю, що це реально реально - якщо ітерабельність була інтерфейсом, то її можна було б додати до інтерфейсу, але це лише умова, і тому немає центрального способу додайте його до набору речей, які є ітерабельними.

Передусім тому, що результат а someString.join()є рядком.

Послідовність (список, кортеж чи будь-що інше) не з’являється в результаті, а лише рядок. Оскільки результат - рядок, він має сенс як метод рядка.

- в "-". join (my_list) заявляє, що ви перетворюєтесь на рядок із приєднання елементів до списку. Орієнтований на результат. (просто для зручної пам'яті та розуміння)

Я роблю вичерпну схему методів_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.join (xs, розмежувати) означає, що рядковий модуль знає про існування списку, про який він не знає діла, оскільки модуль рядка працює лише з рядками.

list.join (розмежувати) трохи приємніше, тому що ми так звикли, що струни є основним типом (і в мовному плані вони є). Однак це означає, що приєднання потрібно динамічно відправляти, оскільки в довільному контексті a.split("\n")компілятор python може не знати, що таке a, і йому потрібно буде шукати його (аналогічно пошуку Vtable), що дорого, якщо ви робите це багато разів.

якщо компілятор виконання пітону знає, що список є вбудованим модулем, він може пропустити динамічний пошук і кодувати наміри безпосередньо в байт-код, тоді як в іншому випадку йому потрібно динамічно вирішити "приєднання" "а", яке може бути до декількох шарів спадкування за викликом (оскільки між дзвінками значення приєднання може змінитися, тому що python - це динамічна мова).

на жаль, це головна вада абстракції; незалежно від того, яку абстракцію ви виберете, ваша абстракція матиме сенс лише в контексті проблеми, яку ви намагаєтеся вирішити, і як така ви ніколи не зможете мати послідовну абстракцію, яка не буде суперечити основним ідеологіям, коли ви почнете їх склеювати. разом, не загортаючи їх у погляд, який відповідає вашій ідеології. Знаючи це, підхід python є більш гнучким, оскільки він дешевший, вам належить заплатити більше, щоб він виглядав "приємніше", або виготовивши власну обгортку, або власний препроцесор.

Змінні my_listі "-"є обома об'єктами. Зокрема, це екземпляри класів listі str, відповідно. joinФункція належить до класу str. Тому синтаксис "-".join(my_list)використовується тому, що об'єкт "-"береться my_listза вхід.