මෙය සැමවිටම මා ව්‍යාකූල කර තිබේ. මෙය වඩා හොඳ වනු ඇති බව පෙනේ:

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

මෙයට වඩා:

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

එය මේ ආකාරයට වීමට නිශ්චිත හේතුවක් තිබේද?

එයට හේතුව ඕනෑම පුනරාවර්තනයක් සම්බන්ධ කළ හැකි බැවිනි (උදා: ලැයිස්තුව, ටුපල්, ඩික්ට්, සෙට්), නමුත් ප්‍රති result ලය සහ “එක්වන තැනැත්තා” නූල් විය යුතුය .

උදාහරණයක් වශයෙන්:

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

'welcome_to_stack_overflow'

නූල් හැර වෙනත් දෙයක් භාවිතා කිරීමෙන් පහත දෝෂය මතු වේ:

TypeError: අනුක්‍රමික අයිතමය 0: අපේක්ෂිත str උදාහරණය, ​​int හමු විය

මෙය සංගීත ක්‍රම වලින් සාකච්ඡා කෙරිණි ... අවසානයේ පයිතන්-දේව් අචයිව් හි නූල් දැමූ අතර එය ගයිඩෝ විසින් පිළිගනු ලැබීය. මෙම නූල 1999 ජුනි මාසයේ ආරම්භ වූ str.joinඅතර එය 2000 සැප්තැම්බර් මාසයේදී නිකුත් කරන ලද පයිතන් 1.6 හි ඇතුළත් කරන ලදී (සහ යුනිකෝඩ් සඳහා සහය දක්වයි). පයිතන් 2.0 (ආධාරක strක්‍රම ඇතුළුව join) 2000 ඔක්තෝම්බර් මාසයේදී නිකුත් කරන ලදී.

• මෙම ත්‍රෙඩ් එකේ විකල්ප හතරක් යෝජනා විය:
  • str.join(seq)
  • seq.join(str)
  • seq.reduce(str)
  • join සාදන ලද ශ්‍රිතයක් ලෙස
• ගයිඩෝට අවශ්‍ය වූයේ lists, tuples පමණක් නොව, සියලු අනුපිළිවෙලවල් / අනුකාරක සඳහා සහාය වීමටය.
• seq.reduce(str) නවකයින්ට එය දුෂ්කර ය.
• seq.join(str) අනුක්‍රමික සිට str / යුනිකෝඩ් දක්වා අනපේක්ෂිත යැපීම හඳුන්වා දෙයි.
• join()ගොඩනංවන ලද ශ්‍රිතයක් සහය දක්වන්නේ නිශ්චිත දත්ත වර්ග වලට පමණි. එබැවින් නාම අවකාශයක් තැනීම හොඳ නැත. join()බොහෝ දත්ත සමුදායන් සඳහා සහය දක්වන්නේ නම් , ප්‍රශස්ත ලෙස ක්‍රියාත්මක කිරීම දුෂ්කර වනු ඇත, __add__ක්‍රමය භාවිතා කර එය ක්‍රියාත්මක කරන්නේ නම් එය O (n²) වේ.
• බෙදුම්කරුගේ නූල් ( sep) මඟ නොහැරිය යුතුය. ව්‍යංගයට වඩා පැහැදිලිය.

මෙම ත්‍රෙඩ් එකේ වෙනත් හේතු නොමැත.

මෙන්න අමතර සිතුවිලි කිහිපයක් (මගේ සහ මගේ මිතුරාගේ):

• යුනිකෝඩ් සහාය පැමිණෙමින් තිබුණද එය අවසාන නොවේ. එකල යූටීඑෆ් -8 යූසීඑස් 2/4 වෙනුවට බොහෝ දුරට ඉඩ තිබුණි. යූටීඑෆ් -8 නූල්වල මුළු බෆරයේ දිග ගණනය කිරීමට එයට අක්ෂර කේතීකරණ රීතිය දැනගත යුතුය.
• එකල, පයිතන් දැනටමත් පොදු අනුක්‍රමික අතුරුමුහුණත් රීතියක් මත තීරණය කර ඇති අතර එහිදී පරිශීලකයෙකුට අනුක්‍රමික-සමාන (නැවත කළ හැකි) පන්තියක් නිර්මාණය කළ හැකිය. නමුත් 2.2 වන තෙක් බිල්ට් වර්ග දීර් ing කිරීමට පයිතන් සහාය නොදක්වයි. එකල මූලික පුනරාවර්තන පංතියක් ලබා දීම දුෂ්කර විය (එය වෙනත් විවරණයක සඳහන් වේ).

ගයිඩෝගේ තීරණය mail තිහාසික තැපෑලක සටහන් වේ str.join(seq).

විහිලු, නමුත් එය නිවැරදි බව පෙනේ! බැරී, ඒ සඳහා යන්න ... -
ගයිඩෝ වැන් රොසුම්

මෙම නිසා join()ක්රමය වෙනුවට ලැයිස්තුව පන්තියේ, වැල පන්තියේ ද?

එය විහිලුවක් බව මම එකඟ වෙමි.

Http://www.faqs.org/docs/diveintopython/odbchelper_join.html බලන්න :

Note තිහාසික සටහන.මම මුලින්ම පයිතන් ඉගෙන ගත් විට, එක්වීම ලැයිස්තුවේ ක්‍රමයක් වනු ඇතැයි මම අපේක්ෂා කළෙමි, එය පරිසීමකය තර්කයක් ලෙස සලකයි. බොහෝ දෙනෙකුට එක හා සමාන හැඟීමක් ඇති අතර, සම්බන්ධ වීමේ ක්‍රමය පිටුපස කතාවක් තිබේ. පයිතන් 1.6 ට පෙර, නූල් වලට මේ සියලු ප්‍රයෝජනවත් ක්‍රම නොතිබුණි. සියළුම සංගීත කාර්යයන් අඩංගු වෙනම නූල් මොඩියුලයක් තිබුණි; සෑම ශ්‍රිතයක්ම එහි පළමු තර්කය ලෙස නූලක් ගත්තේය. පහළ, ඉහළ සහ බෙදීම් වැනි කාර්යයන් සඳහා අර්ථයක් ඇති පරිදි, එම නූල් මතට දැමීමට තරම් කාර්යයන් වැදගත් යැයි සැලකේ. නමුත් බොහෝ දෘඩ-කේන්ද්‍රීය පයිතන් ක්‍රමලේඛකයින් නව සම්බන්ධ වීමේ ක්‍රමයට විරුද්ධ වූ අතර, එය ඒ වෙනුවට ලැයිස්තුවේ ක්‍රමයක් විය යුතු යැයි තර්ක කළහ, නැතහොත් එය කිසිසේත් චලනය නොවිය යුතු අතර පැරණි නූල් මොඩියුලයේ කොටසක් ලෙස රැඳී සිටිය යුතුය (එයට තවමත් ගොඩක් තිබේ එහි ඇති ප්‍රයෝජනවත් දේවල්). මම නව සම්බන්ධ වීමේ ක්‍රමය භාවිතා කරන්නේ තනිකරම,

--- මාර්ක් පිල්ග්‍රිම්, පයිතන්ට කිමිදෙන්න

මුලදී එය ප්‍රතිවිරුද්ධ බව මම එකඟ වෙමි, නමුත් හොඳ හේතුවක් තිබේ. එක්වීම ලැයිස්තුවේ ක්‍රමයක් විය නොහැක, මන්ද:

• එය විවිධ ක්‍රියාකාරීත්වයන් සඳහා ද ක්‍රියා කළ යුතුය (ටුපල්, ජනක යනාදිය)
• එයට විවිධ වර්ගයේ නූල් අතර වෙනස් හැසිරීම් තිබිය යුතුය.

සම්බන්ධ වීමේ ක්‍රම දෙකක් තිබේ (පයිතන් 3.0):

>>> b"".join
<built-in method join of bytes object at 0x00A46800>
>>> "".join
<built-in method join of str object at 0x00A28D40>

බැඳීම ලැයිස්තුවක ක්‍රමයක් නම්, ඔවුන්ගෙන් කුමන අය ඇමතිය යුතුද යන්න තීරණය කිරීම සඳහා එහි තර්ක පරීක්ෂා කළ යුතුය. ඔබට බයිට් හා ස්ට්‍රයි එකට සම්බන්ධ විය නොහැක, එබැවින් ඔවුන් සතුව ඇති ආකාරය දැන් අර්ථවත් කරයි.

ඒ string.join(list)වෙනුවට එය ඇයි list.join(string)?

මෙයට හේතුව join“නූල්” ක්‍රමයක් වීමයි! එය ඕනෑම නැවත සැකසිය හැකි නූලක් සාදයි. අපි ක්‍රමවේදය ලැයිස්තු වල සිර කර ඇත්නම්, අපට ලැයිස්තු නොමැති පුනරාවර්තන ඇති විට කුමක් වේද?

ඔබට නූල් පටියක් තිබේ නම් කුමක් කළ යුතුද? මෙය listක්‍රමවේදයක් නම්, 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'

උත්පාදක යන්ත්ර සඳහා කාර්ය සාධන කේවට්

අවසාන 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විවිධ ක්‍රියාකාරීත්වයන්ට වඩා වස්තුව මත තබා ගැනීම අර්ථවත් කරයි .

එය බෙදීමට ස්වාභාවික විකලාංග මෙහෙයුමක් ලෙස සිතන්න.

එය iterable කිසිවක් අදාළ වන්නේ ඇයි එසේ පහසුවෙන් ක්රියාත්මක කළ නොහැකි මට තේරෙනවා දැන් ලැයිස්තුවේ.

කියවීමේ හැකියාව සඳහා, මම එය භාෂාවෙන් දැකීමට කැමතියි, නමුත් එය සැබවින්ම කළ හැකි යැයි මම නොසිතමි - ක්‍රියාකාරීත්වය අතුරු මුහුණතක් නම් එය අතුරු මුහුණතට එකතු කළ හැකි නමුත් එය සම්මුතියක් පමණක් වන අතර ඒ සඳහා කේන්ද්‍රීය ක්‍රමයක් නොමැත නැවත ලබා ගත හැකි දේවල් සමූහයට එය එක් කරන්න.

මූලික වශයෙන් a හි ප්‍රති result ලය someString.join()නූලක් වන බැවිනි.

අනුක්‍රමය (ලැයිස්තුව හෝ ටුපල් හෝ වෙනත්) ප්‍රති result ලයෙහි නොපෙන්වයි, නූලක් පමණි. ප්‍රති result ලය නූලක් බැවින් එය නූල් ක්‍රමයක් ලෙස අර්ථවත් කරයි.

- "-" හි එක්වන්න (my_list) ප්‍රකාශ කරන්නේ ඔබ ලැයිස්තුවක් සමඟ සම්බන්ධ වීමෙන් නූලකට පරිවර්තනය වන බවයි. එහි ප්‍රති result ල මත පදනම් වූ (පහසු මතකය සහ අවබෝධය සඳහා)

මම ඔබේ යොමු කිරීම සඳහා ක්‍රම_සහ_රැස්වීම් පිළිබඳ සම්පූර්ණ වංචා පත්‍රයක් සාදමි.

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, delimit) යන්නෙන් අදහස් කරන්නේ සංගීත මොඩියුලය ක්‍රියා කරන්නේ නූල් සමඟ පමණක් බැවින් එය පිළිබඳ ව්‍යාපාරයක් නොදන්නා ලැයිස්තුවක පැවැත්ම ගැන නූල් මොඩියුලය දැන සිටින බවයි.

list.join (delimit) ටිකක් හොඳයි, මන්ද අපි නූල් වලට මූලික වර්ගයක් ලෙස පුරුදු වී සිටිමු (සහ භාෂාමය වශයෙන් කිවහොත් ඒවා). කෙසේ වෙතත් මෙයින් අදහස් වන්නේ එක්වීම ගතිකව පිටත් කර යැවිය යුතු නිසා a.split("\n")පයිතන් සම්පාදකයාගේ අත්තනෝමතික සන්දර්භය තුළ එය කුමක්දැයි නොදැන සිටිය හැකි අතර එය සොයා බැලීමට අවශ්‍ය වනු ඇත (සමානව vtable lookup වෙත), ඔබ එය විශාල වශයෙන් කරන්නේ නම් එය මිල අධිකය වාරයක්.

ලැයිස්තුව ගොඩනගා ඇත්තේ මොඩියුලයක බව පයිතන් ධාවන කාල සම්පාදකයා දන්නේ නම්, එයට ගතික පෙනුම මඟ හැර එහි අභිප්‍රාය කෙලින්ම බයිට් කේතයට කේතනය කළ හැකි අතර එසේ නොවුවහොත් එය "අ" හි "එක්වීම" ගතිකව නිරාකරණය කළ යුතු අතර එය ස්ථර කිහිපයක් විය හැකිය. ඇමතුමකට උරුමය (ඇමතුම් අතර, සම්බන්ධ වීමේ අර්ථය වෙනස් වන්නට ඇත, මන්ද පයිතන් ගතික භාෂාවක් වන නිසා).

කනගාටුවට කරුණ නම්, මෙය වියුක්ත කිරීමේ අවසාන දෝෂයයි; ඔබ තෝරාගත් සාරාංශය කුමක් වුවත්, ඔබේ වියුක්ත කිරීම අර්ථවත් වනු ඇත්තේ ඔබ විසඳීමට උත්සාහ කරන ගැටලුවේ සන්දර්භය තුළ පමණක් වන අතර, ඒ නිසා ඔබට කිසි විටෙකත් ස්ථාවර වියුක්තයක් තිබිය නොහැකි අතර ඒවා යටින් පවතින මතවාදයන්ට නොගැලපේ. ඔබේ දෘෂ්ටිවාදයට අනුකූල වන දෘෂ්ටියකින් ඒවා ඔතා නොගෙන එකට. මෙය දැන ගැනීමෙන්, පයිතන්ගේ ප්‍රවේශය වඩා ලාභදායී බැවින් එය වඩාත් නම්‍යශීලී වේ, එය ඔබේම එතුම සෑදීමෙන් හෝ ඔබේම පෙර සැකසුම් යන්ත්‍රයකින් “වඩා හොඳ” පෙනුමක් ලබා දීම සඳහා වැඩි මුදලක් ගෙවිය යුතුය.

විචල්යයන් my_listසහ "-"වස්තු දෙකම වේ. නිශ්චිතවම, ඒවා පන්තිවල අවස්ථා listසහ strපිළිවෙලින්. මෙම joinඋත්සවය පන්තියට අයත් str. එමනිසා, "-".join(my_list)වස්තුව ආදානය ලෙස ගන්නා නිසා සින්ටැක්ස් භාවිතා "-"වේ my_list.