Kuunganisha na kuunganisha kamba katika Python: + waendeshaji, kazi za kujiunga, nk.

Yafuatayo ni maelezo ya jinsi ya kubatilisha na kujiunga na kamba kwenye Python.

Kuunganisha na kuunganisha mifuatano mingi:+,+=mwendeshaji
Unganisha na uchanganye nambari na nyuzi:+,+=mwendeshaji,str(),format(),f-kamba
Unganisha na changanya orodha (safu) za mifuatano kwenye mfuatano mmoja:join()
Unganisha na uchanganye orodha (safu) za nambari kwenye mfuatano mmoja:join(),str()

Table of Contents

Kuunganisha na kuunganisha mifuatano mingi:+,+=mwendeshaji
Nambari na mfuatano wa kamba:+,+=mwendeshaji,str(),format(),f-kamba
Unganisha na uunganishe orodha (safu) za mifuatano:join()
Unganisha na changanya orodha (safu) za nambari kama mifuatano:join(),str()

Kuunganisha na kuunganisha mifuatano mingi:+,+=mwendeshaji

uhusiano:+mwendeshaji

Opereta ++ inaweza kutumika kuambatanisha mifuatano ya maneno halisi na viambatisho vya kamba

…’
“…”

s = 'aaa' + 'bbb' + 'ccc'
print(s)
# aaabbbccc

s1 = 'aaa'
s2 = 'bbb'
s3 = 'ccc'

s = s1 + s2 + s3
print(s)
# aaabbbccc

s = s1 + s2 + s3 + 'ddd'
print(s)
# aaabbbcccddd

uhusiano:+=mwendeshaji

Opereta +=, opereta limbikizi ya kazi, pia inaweza kutumika. Tofauti ya kamba kwenye upande wa kushoto imeunganishwa na kamba iliyo upande wa kulia, na inapewa na kusasishwa.

s1 += s2
print(s1)
# aaabbb

Ikiwa ungependa kuongeza mfuatano hadi mwisho wa utofauti wa mfuatano, chakata tu utofauti wa kamba na mfuatano wowote halisi (au utaftaji mwingine wa kamba) na opereta +=.

s = 'aaa'

s += 'xxx'
print(s)
# aaaxxx

Muunganisho unaofuatana wa maandishi ya mfuatano

Ukiandika tu maandishi ya mfuatano kando kando, maneno halisi ya mfuatano yataunganishwa.

s = 'aaa''bbb''ccc'
print(s)
# aaabbbccc

Inakubalika kuwa na nafasi kati ya mistari miwili au mapumziko ya mstari wa nyuma (inazingatiwa kuendelea).

s = 'aaa'  'bbb'    'ccc'
print(s)
# aaabbbccc

s = 'aaa'\
    'bbb'\
    'ccc'
print(s)
# aaabbbccc

Kuna mbinu ya kutumia hii kuandika kamba ndefu kwenye mistari mingi kwenye msimbo.

Makala Zinazohusiana:Kuandika kamba ndefu kwenye mistari mingi kwenye Python

Njia hii ya uandishi haiwezekani kwa vigezo vya kamba.

# s = s1 s2 s3
# SyntaxError: invalid syntax

Nambari na mfuatano wa kamba:+,+=mwendeshaji,str(),format(),f-kamba

Uendeshaji + wa aina tofauti husababisha hitilafu.

s1 = 'aaa'
s2 = 'bbb'

i = 100
f = 0.25

# s = s1 + i
# TypeError: must be str, not int

Ikiwa unataka kubatilisha thamani ya nambari (kwa mfano, aina kamili ya int au aina ya sehemu inayoelea) na kamba, badilisha thamani ya nambari kuwa aina ya kamba na str() na kisha uunganishe na opereta + (au += opereta. )

s = s1 + '_' + str(i) + '_' + s2 + '_' + str(f)
print(s)
# aaa_100_bbb_0.25

Iwapo ungependa kubadilisha umbizo la nambari, kama vile kujaza sifuri au sehemu za desimali, tumia kitendakazi cha umbizo() au umbizo la mbinu ya kamba().

s = s1 + '_' + format(i, '05') + '_' + s2 + '_' + format(f, '.5f')
print(s)
# aaa_00100_bbb_0.25000

s = '{}_{:05}_{}_{:.5f}'.format(s1, i, s2, f)
print(s)
# aaa_00100_bbb_0.25000

Bila shaka, inawezekana pia kupachika thamani ya kutofautisha moja kwa moja kwenye mfuatano bila umbizo. Hii ni rahisi kuandika kuliko kutumia + operator.

s = '{}_{}_{}_{}'.format(s1, i, s2, f)
print(s)
# aaa_100_bbb_0.25

Tazama nakala ifuatayo kwa maelezo ya jinsi ya kubainisha umbizo.

Makala Zinazohusiana:Ubadilishaji wa umbizo katika Python, umbizo (kujaza-0, nukuu ya ufafanuzi, heksadesimali, n.k.)

Tangu Python 3.6, utaratibu unaoitwa f-strings (f-string) pia umeanzishwa, ambayo ni rahisi zaidi kuandika kuliko format().

s = f'{s1}_{i:05}_{s2}_{f:.5f}'
print(s)
# aaa_00100_bbb_0.25000

s = f'{s1}_{i}_{s2}_{f}'
print(s)
# aaa_100_bbb_0.25

Unganisha na uunganishe orodha (safu) za mifuatano:join()

Njia ya mfuatano join() inaweza kutumika kuambatanisha orodha ya mifuatano kwenye mfuatano mmoja.

str.join(iterable) — Built-in Types — Python 3.10.2 Documentation

Ifuatayo ni jinsi ya kuiandika.

'String to be inserted between'.join([List of strings to be concatenated])

Piga join() njia iliyo na ‘kamba ya kuingiza kati’ na kupitisha [orodha ya mifuatano ya kubatilisha] kama hoja.

Mfuatano tupu ukitumiwa, [orodha ya mifuatano itakayounganishwa] itaunganishwa kwa urahisi, ikiwa koma itatumika, mifuatano itatenganishwa kwa koma, na ikiwa herufi mpya itatumika, kila kipengele cha mfuatano kitawekwa mstari mpya.

l = ['aaa', 'bbb', 'ccc']

s = ''.join(l)
print(s)
# aaabbbccc

s = ','.join(l)
print(s)
# aaa,bbb,ccc

s = '-'.join(l)
print(s)
# aaa-bbb-ccc

s = '\n'.join(l)
print(s)
# aaa
# bbb
# ccc

Ingawa ni mfano tu wa orodha umetolewa hapa, vitu vingine vinavyoweza kutekelezeka kama vile nakala vinaweza kubainishwa kama hoja za join() pia.

Tofauti na join(), split() inatumika kugawanya kamba iliyotengwa na kikomo maalum na kuipata kama orodha.

Unganisha na changanya orodha (safu) za nambari kama mifuatano:join(),str()

Hitilafu hutokea ikiwa hoja ya join() ni orodha ambayo vipengele vyake sio kamba.

l = [0, 1, 2]

# s = '-'.join(l)
# TypeError: sequence item 0: expected str instance, int found

Ili kuunganisha orodha ya nambari katika mfuatano mmoja, tumia str() chaguo la kukokotoa kwa kila kipengele kwenye nukuu ya ufahamu wa orodha ili kubadilisha nambari kuwa mfuatano, na kisha uziunganishe na join().

s = '-'.join([str(n) for n in l])
print(s)
# 0-1-2

Inaweza pia kuandikwa kama usemi wa jenereta, ambayo ni toleo la jenereta la ufahamu wa orodha. Semi za jenereta zimefungwa kwenye mabano, lakini mabano yanaweza kuachwa ikiwa usemi wa jenereta ndio hoja pekee ya chaguo za kukokotoa au mbinu.

s = '-'.join((str(n) for n in l))
print(s)
# 0-1-2

s = '-'.join(str(n) for n in l)
print(s)
# 0-1-2

Maneno ya jenereta kwa ujumla yana faida ya kutumia kumbukumbu kidogo kuliko ufahamu wa orodha, lakini hakuna faida fulani ya kutumia misemo ya jenereta kwani join() inabadilisha jenereta kuwa orodha katika usindikaji wake wa ndani. Kwa kweli, ni haraka kidogo kutumia ufahamu wa orodha tangu mwanzo.