Tutorial Python untuk bukan pengatur cara/Dendam String

Dan sekarang kita persembahkan muslihat licik yang boleh dilakukan dengan string:

def jerit(string):
    for aksara in string:
        print "Beri saya " + aksara
        print "'" + aksara + "'"
jerit("Menang")
 
def tengah(string):
    print "Aksara tengah ialah:", string[len(string) / 2]
 
tengah("abcdefg")
tengah("Pasukan Bola Sepak")
tengah("Malaya")

Dan outputnya ialah:

Beri saya M
'M'
Beri saya e
'e'
Beri saya n
'n'
Beri saya a
'a'
Beri saya n
'n'
Beri saya g
'g'

Aksara tengah ialah: d
Aksara tengah ialah: o
Aksara tengah ialah: a

Apa yang ditunjukkan program-program ini ialah string seakan-akan list dalam banyak segi. Fungsi jerit() menunjukkan gelung for boleh digunakan dengan string sama seperti list. Prosedur tengah menunjukkan string juga boleh menggunakan fungsi len() dan menyusun indeks dan hirisan. Kebanyakan ciri list juga bekerja dengan string.

Ciri seterusnya menunjukkan sebahagian ciri khusus string:

def jadi_huruf_besar(rentetan):
    ## Mengubah rentetan ("string") kepada huruf besar
    huruf_besar = ""
    for aksara in rentetan:
        if 'a' <= aksara <= 'z':
            lokasi = ord(aksara) - ord('a')
            ascii_baru = lokasi + ord('A')
            aksara = chr(ascii_baru)
        huruf_besar = huruf_besar + aksara
    return huruf_besar

print jadi_huruf_besar("Ini adalah Teks")

dengan outputnya menjadi:

INI ADALAH TEKS 

Ini bekerja kerana komputer mewakilkan aksara-aksara sesuatu rentetan sebagai nombor dari 0 ke 255. Python mempunyai fungsi digelar ord() (pendek untuk ordinal) yang memulangkan sesuatu aksara sebagai nombor. Juga terdapat fungsi sepadan yang dipanggil chr() yang menukar sesebuah nombor kepada aksara. Dengan ini, program seharusnya menjadi lebih jelas. Perincian pertama adalah baris: if 'a' <= aksara <= 'z': yang memeriksa sama ada sebuah huruf itu huruf kecil atau tidak. Jika ya, program bergerak ke baris berikutnya. Pertama, ia diubah menjadi lokasi agar a = 0, b = 1, c = 2 dan seterusnya dengan baris: lokasi = ord(aksara) - ord('a'). Kemudian, nilai baharu ditemui dengan ascii_baru = lokasi + ord('A'). Nilai ini ditukar kembali menjadi aksar yang berbentuk huruf besar.

Sekarang kita berlatih menaip secara interaktif:

>>> # Integer ke Rentetan
>>> 2
2
>>> repr(2)
'2'
>>> -123
-123
>>> repr(-123)
'-123'
>>> `123`
'123'
>>> # Rentetan ke Integer
>>> "23"
'23'
>>> int("23")
23
>>> "23" * 2
'2323'
>>> int("23") * 2
46
>>> # Nombor apung ke Rentetan
>>> 1.23
1.23
>>> repr(1.23)
'1.23'
>>> # Nombor apung ke Integer
>>> 1.23
1.23
>>> int(1.23)
1
>>> int(-1.23)
-1
>>> # Rentetan ke Nombor apung
>>> float("1.23")
1.23
>>> "1.23" 
'1.23'
>>> float("123")
123.0
>>> `float("1.23")`
'1.23'

Jika anda belum mengagaknya lagi, fungsi repr() boleh mengubah integer kepada rentetan dan fungsi int() melakukan operasi sebaliknya. Fungsi float() boleh mengubah rentetan kepada floating point number atau nombor titik apung. Fungsi repr() memulangkan wakil sesuatu yang dapat dicetak. Kod `...` juga mengubah hampir semua kepada rentetan. Berikut beberapa contoh:

>>> repr(1)
'1'
>>> repr(234.14)
'234.14'
>>> repr([4, 42, 10])
'[4, 42, 10]'
>>> `[4, 42, 10]`
'[4, 42, 10]'

Fungsi int() cuba mengubah rentetan (atau nombor apung) kepada integer. Juga terdapat fungsi yang sama yang dipanggil float() yang akan mengubah integer atau rentetan kepada nombor apung. Satu lagi fungsi yang dimiliki Python adalah fungsi eval(). Fungsi eval() mengambil rentetan dan memulangkan data jenis yang difikirkan Python telah ditemuinya. Contoh:

>>> v = eval('123')
>>> print v, type(v)
123 <type 'int'>
>>> v = eval('645.123')
>>> print v, type(v)
645.123 <type 'float'>
>>> v = eval('[1, 2, 3]')
>>> print v, type(v)
[1, 2, 3] <type 'list'>

Jika anda mengguna fungsi eval() anda harus pastikan yang ia memulangkan jenis yang anda sangka.

Satu fungsi rentetan atau string adalah kaedah split() (pisah). Ini contoh:

>>> "Ini adalah beberapa perkataan".split()
['Ini', 'adalah', 'beberapa', 'perkataan']
>>> text = "Kelompok pertama, kelompok kedua, ketiga, keempat"
>>> text.split(",")
['Kelompok pertama', ' kelompok kedua', ' ketiga', ' keempat']

Perhatikan bagaimana split() mengubah rentetan menjadi satu senarai rentetan. Rentetan dipisah dengan ruang putih secara lalai atau dengan argumen pilihan (dalam kes ini, tanda koma). Anda juga boleh menambah argumen yang memberitahu split() berapa kali pemisah akan digunakan bagi memisah teks. Contoh:

>>> list = text.split(",")
>>> len(list)
4
>>> list[-1]
' keempat'
>>> list = text.split(",", 2)
>>> len(list)
3
>>> list[-1]
' ketiga, keempat'

Menghiris string (dan list)

String atau rentetan dapat dihiris — dengan cara yang sama yang ditunjukan dengan list atau senarai dalam bab sebelum ini — dengan menggunakan "operator" penghiris [:]. Operator penghiris bekerja dengan cara yang sama seperti dahulu: teks[indeks_pertama:indeks_terakhir] (dalam kes-kes yang jarang diketemu, sebuah tanda titik berganda dan argumen ketiga boleh digunakan, seperti dipaparkan dalam contoh berikut).

Agar kita tidak terkeliru dengan angka indeks, paling mudah jika kita melihatnya sebagai tempat ketip, di mana kita dapat menghiris rentetan kepada bahagian-bahagiannya. Ini satu contoh yang menunjukkan tempat ketip (kuning) dan nombor-nombor indeks (merah dan biru) buat rentetan teks:

		0		1		2		...		-2		-1
		↓		↓		↓		↓		↓		↓		↓
text =	"		S		T		R		I		N		G		"
		↑												↑
		[:												:]

Perhatikan bahawa indeks merah dikira bermula dari permulaan string dan yang biru pula dari akhir string (perhatikan bahawa tiada -0 biru, dan ini logik jika dilihat dari segi akhir rentetan). Oleh sebab -0 == 0, (-0 juga bermaksud "permulaan rentetan"). Sekarang kita bersedia untuk menggunakan indeks buat operasi hirisan:

text[1:4]	→	"TRI"
text[:5]	→	"STRIN"
text[:-1]	→	"STRIN"
text[-4:]	→	"RING"
text[2]	→	"R"
text[:]	→	"STRING"
text[::-1]	→	"GNIRTS"

• text[1:4] memberikan semua rentetan text di antara tempat ketip 1 dan 4, "TRI". Jika anda abaikan satu daripada argumen [indeks_pertama:indeks_akhir], anda akan mendapat permulaan atau akhir rentetan sebagai lalai: text[:5] memberi "STRIN".
• Bagi kedua-dua indeks_pertama dan indeks_akhir, kita boleh menggunakan kedua-dua skema penomboran merah dan biru: text[:-1] memberikan rentetan yang sama dengan text[:5], kerana indeks -1 berada pada tempat yang sama dengan 5 dalam kes ini.
• Jika kita tidak menggunakan argumen yang mengandungi tanda ttik berganda (":"), nombor akan dikendalikan dengan cara lain: text[2] memberi kita satu aksara selepas tempat ketip, "R".
• Operasi hirisan khas text[:] bermakna" dari permulaan hingga ke akhir" dan mewujudkan salinan rentetan (atau senarai).

Akhir sekali, operasi hirisan boleh mengandungi tanda titik berganda kedua dan argumen ketiga yang ditakrifkan sebagai "saiz tingkat": text[::-1] bermakna text dari permulaan sehingga ke akhir, dengan saiz tingkat -1. Angka -1 bermaksud "setiap aksara, akan tetapi dari arah sebaliknya". "STRING" terbalik adalah "GNIRTS" (uji saiz tingkat 2 jika anda masih musykil).

Semua operasi hiris bekerja dengan senarai atau list. Dalam hal ini, rentetan boleh dikatakan sebentuk senarai yang istimewa dan unsur-unsur list merupakan aksara-aksara individu. Anda hanya perlu ingat konsep tempat ketip dan indeks bagi menghiris akan kelihatan lebih jelas.

Contoh

# Program ini memerlukan pemahaman nombor perpuluhan 
def to_string(in_int):
    """Mengubah integer kepada string"""
    out_str = ""
    prefix = ""
    if in_int < 0:
        prefix = "-"
        in_int = -in_int
    while in_int / 10 != 0:
        out_str = chr(ord('0') + in_int % 10) + out_str
        in_int = in_int / 10
    out_str = chr(ord('0') + in_int % 10) + out_str
    return prefix + out_str

def to_int(in_str):
    """Mengubah string kepada integer"""
    out_num = 0
    if in_str[0] == "-":
        multiplier = -1
        in_str = in_str[1:]
    else:
        multiplier = 1
    for x in range(0, len(in_str)):
        out_num = out_num * 10 + ord(in_str[x]) - ord('0')
    return out_num * multiplier

print to_string(2)
print to_string(23445)
print to_string(-23445)
print to_int("14234")
print to_int("12345")
print to_int("-3512")

Outputnya:

2
23445
-23445
14234
12345
-3512