Siri Kandungan:

Kami beralih ke salah satu yang paling banyak topik yang menarik gelung - pengaturcaraan berorientasikan objek (OOP) dalam Python. Dari sudut pandangan OOP, kelas ialah koleksi data. Menggunakan kelas memberi kita, pertama sekali, kelebihan pendekatan abstrak untuk pengaturcaraan.

1. Polimorfisme: operasi yang sama boleh dilakukan dalam objek yang berbeza pelbagai fungsi. Perkataan "polimorfisme" berasal dari bahasa Yunani dan bermaksud "mempunyai banyak bentuk." Contoh mudah polimorfisme ialah fungsi count(), yang melakukan tindakan yang sama untuk jenis objek yang berbeza: "abc".count("a") dan .count("a") . Operator tambah adalah polimorfik apabila menambah nombor dan apabila menambah rentetan.
2. Enkapsulasi: Anda boleh menyembunyikan butiran dalaman yang tidak perlu bagi operasi objek daripada dunia luar. Ini adalah prinsip asas kedua abstraksi. Ia berdasarkan penggunaan atribut dalam kelas. Atribut boleh mempunyai keadaan yang berbeza antara panggilan ke kaedah kelas, menyebabkan objek itu sendiri daripada kelas ini juga menerima pelbagai negeri – negeri.
3. Warisan: Anda boleh membuat kelas khusus berdasarkan kelas asas. Ini membolehkan kami mengelak daripada menulis kod berulang.
4. Komposisi: Objek boleh menjadi komposit dan termasuk objek lain.

Pendekatan berorientasikan objek dalam pengaturcaraan membayangkan algoritma seterusnya tindakan.

1. Masalah dihuraikan menggunakan bahasa biasa menggunakan konsep, tindakan, dan kata adjektif.
2. Berdasarkan konsep, kelas dirumuskan.
3. Kaedah direka berdasarkan tindakan.
4. Kaedah dan atribut dilaksanakan.

Kami menerima rangka - model objek. Pewarisan dilaksanakan berdasarkan model ini. Untuk menyemak model:

1. kes penggunaan yang dipanggil ditulis - senario kemungkinan tingkah laku model, di mana semua fungsi diuji;
2. kefungsian boleh diperbetulkan atau ditambah.

Pendekatan berorientasikan objek adalah baik di mana projek melibatkan pembangunan jangka panjang dan terdiri daripada Kuantiti yang besar perpustakaan dan komunikasi dalaman.

Mekanisme Kelas bahasa sawa ialah campuran mekanisme kelas C++ dan Modula-3. Ciri-ciri kelas yang paling penting dalam Python:

1. warisan berbilang;
2. kelas terbitan boleh mengatasi sebarang kaedah kelas asas;
3. di mana-mana sahaja anda boleh memanggil kaedah dengan nama kelas asas yang sama;
4. Semua atribut kelas dalam Python adalah awam secara lalai, i.e. boleh diakses dari mana-mana; semua kaedah adalah maya, i.e. membebankan yang asas.

Hari ini kita akan melihat aspek pengaturcaraan berorientasikan objek berikut.

1. Apa itu kelas?
2. Atribut kelas.
3. diri sendiri.
4. Warisan.
5. OOP dalam tindakan: contoh mencipta kelas.

1. Apakah itu kelas

Kelas ialah jenis yang ditentukan pengguna. Model paling mudah bagi definisi kelas kelihatan seperti ini:

nama_kelas kelas: arahan 1 . arahan no.

Setiap entri tersebut menjana objek kelasnya sendiri. Perbezaan dari C++ ialah, di sisi positifnya, penerangan kelas hanyalah pengisytiharan, manakala dalam Python ia adalah penciptaan objek. Terdapat juga jenis objek lain - contoh kelas, yang dihasilkan apabila dipanggil:

kelas_contoh = kelas_nama()

Objek kelas dan contoh kelas ialah dua objek berbeza. Yang pertama dihasilkan pada peringkat pengisytiharan kelas, yang kedua - apabila memanggil nama kelas. Boleh ada satu objek kelas, tetapi boleh ada seberapa banyak contoh kelas yang dikehendaki.

Arahan biasanya merupakan definisi fungsi. Mentakrifkan kelas mencipta ruang nama baharu dan mencipta objek kelas yang membungkus semua pernyataan.

Objek kelas menyokong dua jenis operasi:

• akses kepada atribut;
• mencipta contoh kelas.

2. Atribut kelas

Terdapat dua jenis atribut kelas:

• atribut data;
• atribut-kaedah.

Atribut data biasanya ditulis di bahagian atas. Memori untuk atribut diperuntukkan apabila ia mula-mula diberikan, sama ada secara luaran atau dalaman kepada kaedah. Kaedah bermula dengan perkataan fungsi def.

Atribut diakses menggunakan skema obj.attrname.

kelas Mudah: u"Kelas ringkas" var = 87 def f(x): kembalikan "Hello dunia"

Di sini Simple.var dan Simple.f ialah atribut tersuai. Terdapat juga atribut standard:

>>> cetak Mudah.__doc__

Integer

>>> cetak Simple.var.__doc__ int(x[, base]) -> integer ...

Menghidupkan kelas adalah serupa dengan membuat panggilan fungsi:

smpl = Mudah()

Objek smpl kosong akan dibuat. Jika kita mahu beberapa tindakan dilakukan semasa penciptaan, kita perlu menentukan pembina yang akan dipanggil secara automatik:

kelas Mudah: def __init__(self): self.list =

Apabila mencipta objek smpl, senarai kosong akan dibuat. Anda boleh menyampaikan hujah kepada pembina:

class Simple: def __init__(self, count, str): self.list = self.count = count self.str = str >>> s = Simple(1,"22") >>> s.count, s.str 1 22

Atribut data boleh dijadikan peribadi - i.e. tidak boleh diakses dari luar - untuk ini anda perlu meletakkan dua garis bawah di sebelah kiri:

kelas Mudah: u"Kelas ringkas dengan atribut peribadi" __private_attr = 10 def __init__(self, count, str): self.__private_attr = 20 print self.__private_attr s = Simple(1,"22") print s.__private_attr

Baris terakhir akan membuang pengecualian - atribut __private_attr adalah untuk kegunaan dalaman sahaja.

Kaedah tidak perlu ditakrifkan di dalam badan kelas:

kaedah def_untuk_mudah(diri, x, y): kembalikan kelas x + y Mudah: f = kaedah_untuk_mudah >>> s = Mudah() >>> cetak s.f(1,2) 3

Kelas kosong boleh digunakan sebagai templat untuk struktur data:

Pelanggan kelas: pas adat = Pelanggan() custom.name = "Vasya" custom.gaji = 100000

3.diri sendiri

Biasanya hujah pertama dalam nama kaedah ialah diri. Seperti yang dikatakan oleh pengarang bahasa, Guido Van Rossum, ini tidak lebih daripada konvensyen: nama diri sama sekali tidak mempunyai makna yang istimewa.

self berguna untuk mengakses atribut kelas lain:

kelas Mudah: def __init__(diri): self.list = def f1(self): self.list.append(123) def f2(self): self.f1() >>> s = Simple() >>> s .f2() >>> cetak s.senarai

Diri adalah bersamaan dengan "ini" dalam C++.

4. Warisan

Takrif kelas terbitan kelihatan seperti ini:

kelas Terbitan (Asas):

Jika kelas asas tidak ditakrifkan dalam modul semasa:

kelas Terbitan(nama_modul.Base):

Peleraian nama atribut berfungsi dari atas ke bawah: jika atribut tidak ditemui dalam kelas semasa, carian diteruskan dalam kelas asas, dan seterusnya secara rekursif. Kelas terbitan boleh mengatasi kaedah kelas asas - semua kaedah adalah maya dalam pengertian ini. Anda boleh memanggil kaedah kelas asas dengan awalan:

Base.method()

Python mempunyai sokongan terhad untuk pelbagai warisan:

kelas Terbitan (Base1, Base2, Base3):

Atribut dicari dalam susunan berikut:

1. dalam Derived;
2. dalam Base1, kemudian secara rekursif dalam kelas asas Base1;
3. dalam Base2, kemudian secara rekursif dalam kelas asas Base2
4. dan lain-lain.

5. Contoh

Mari buat dua kelas: Orang - menyimpan maklumat umum tentang orang - nama, profesion, gaji; kelas Pengurus ialah kelas terbitan khusus. Dalam kelas Person, kami akan mencipta versi kami sendiri bagi fungsi terbina dalam standard str, yang secara lalai dalam mana-mana kelas Python - untuk ini ia akan diawali dengan dua garis bawah di sebelah kiri dan kanan. Apabila kita cuba mencetak contoh kelas, __str__ akan dipanggil.

# -*- pengekodan: utf-8 -*- kelas Orang: def __init__(self, name, job=None, pay=0): self.name = name self.job = job self.pay = pay def lastName(self ): return self.name.split()[-1] def giveRaise(self, percent): self.pay = int(self.pay * (1 + peratus)) def __str__(self): return "" % (self .name, self.pay) Pengurus kelas(Orang): def __init__(diri, nama, bayar): Orang.__init__(diri, nama, "mgr", bayar) def giveRaise(diri, peratus, bonus=100): Orang .giveRaise(diri, peratus + bonus)

Buat contoh pertama kelas Orang:

>>> ivan = Orang("Ivan Petrov")

Buat contoh kedua kelas Orang:

>>> john = Orang("John Sidorov", job="dev", pay=100000)

Panggil fungsi terlebih beban __str__;

>>> cetak(ivan) >>> cetak(john)

Kami memaparkan nama keluarga:

>>> print(ivan.lastName(), john.lastName())

Kami mengenakan bonus:

>>> john.giveRaise(.10)

Dan kami mendapat:

>>> cetak(john)

Buat contoh kelas Pengurus:

>>> tom = Pengurus("Tom Jones", 50000)

Kami memberikan bonus mega:

>>> tom.giveRaise(.10) print(tom.lastName()) print(tom)("Petrov", "Sidorov") Jones

Kesimpulan

Sifat utama OOP ialah polimorfisme, pewarisan, enkapsulasi. Kelas ialah jenis yang ditentukan pengguna yang terdiri daripada kaedah dan atribut. Contoh kelas dicipta dengan memanggil nama kelas sebagai fungsi dengan parameter. Objek terdiri daripada atribut dan kaedah. Atribut ialah pembolehubah, kaedah ialah fungsi. Perbezaan antara kaedah dan fungsi ialah ia mempunyai parameter pertama - diri. Polimorfisme membolehkan kita bekerja dengannya pelbagai jenis objek supaya kita tidak perlu memikirkan jenisnya. Objek boleh menyembunyikan (merangkum) keadaan dalaman mereka. Ini dicapai kerana fakta bahawa atribut tidak diakses secara langsung, tetapi melalui kaedah. Kelas boleh diperoleh daripada satu atau lebih kelas. Kelas terbitan mewarisi semua kaedah kelas asas. Terdapat beberapa kelas asas. Reka bentuk objek mestilah telus, boleh difahami dan diterangkan, seperti yang mereka katakan, dalam "segi bahasa manusia."

Sumber untuk muat turun

static.content.url=http://www.site/developerworks/js/artrating/

Zon=Sumber terbuka, Linux

ArticleID=512105

ArticleTitle=Python Programming: Bahagian 6: Kelas

Operator	Penerangan	Contoh
+	Penambahan - Menjumlahkan nilai ke kiri dan kanan pengendali	15 + 5 keputusan dalam 20 20 + -3 keputusan dalam 17 13.4 + 7 keputusan dalam 20.4
-	Tolak - Menolak operan kanan daripada operan kiri	15 - 5 hasilnya ialah 10 20 - -3 akan menghasilkan 23 13.4 - 7 hasilnya akan menjadi 6.4
*	Pendaraban - Mendarab operan	5 * 5 hasilnya ialah 25 7 * 3.2 hasilnya akan menjadi 22.4 -3 * 12 hasilnya ialah -36
/	Pembahagian - Membahagikan operan kiri dengan operan kanan	15/5 hasilnya akan menjadi 3 5 / 2 menghasilkan 2 (Dalam Python 2.x, membahagikan dua integer menghasilkan integer) 5.0 / 2 hasilnya akan menjadi 2.5 (Untuk mendapatkan hasil "betul" sekurang-kurangnya satu operan mesti terapung)
%	Pembahagian modulo - Membahagikan operan kiri dengan operan kanan dan mengembalikan bakinya.	6% 2 hasilnya akan menjadi 0 7% 2 hasilnya akan menjadi 1 13.2% 5 hasil daripada 3.2
**	Eksponen - menaikkan operan kiri kepada kuasa operan kanan	5 ** 2 hasilnya ialah 25 2 ** 3 hasilnya ialah 8 -3 ** 2 hasilnya ialah -9
//	Pembahagian integer - Pembahagian di mana hanya bahagian integer hasil dikembalikan. Bahagian selepas titik perpuluhan dibuang.	12 // 5 hasilnya akan menjadi 2 4 // 3 akan menghasilkan 1 25 // 6 hasilnya ialah 4

Pengendali perbandingan dalam Python:

Operator	Penerangan	Contoh
==	Menyemak sama ada kedua-dua operan adalah sama. Jika ya, maka syaratnya menjadi benar.	5 == 5 akan menghasilkan True Benar == Salah hasilnya akan Salah "hello" == "hello" akan menghasilkan True
!=		12 != 5 hasilnya akan menjadi Benar False != False the result will be False "hai" != "Hai" hasilnya akan menjadi Benar
<>	Menyemak sama ada kedua-dua operan adalah sama. Jika tidak, maka syaratnya menjadi benar.	12 <>5 akan menghasilkan Benar. Nampak macam operator!=
>	Menyemak sama ada nilai operan kiri lebih besar daripada nilai operan kanan. Jika ya, maka syaratnya menjadi benar.	5 > 2 akan menghasilkan Benar. True > False akan menghasilkan True. "A" > "B" akan menghasilkan Salah.
<	Menyemak sama ada nilai operan kiri kurang daripada nilai operan kanan. Jika ya, maka syaratnya menjadi benar.	3 < 5 в результате будет True. betul< False в результате будет False. "A"< "B" в результате будет True.
>=	Menguji sama ada nilai operan kiri lebih besar daripada atau sama dengan nilai operan kanan. Jika ya, maka syaratnya menjadi benar.	1 >= 1 akan menghasilkan Benar. 23 >= 3.2 hasilnya akan menjadi Benar. "C" >= "D" akan menghasilkan False.
<=	Menguji sama ada nilai operan kiri kurang daripada atau sama dengan nilai operan kanan. Jika ya, maka syaratnya menjadi benar.	4 <= 5 в результате будет True. 0 <= 0.0 в результате будет True. -0.001 <= -36 в результате будет False.

Pengendali tugasan dalam Python:

Operator	Penerangan	Contoh
=	Menetapkan nilai operan kanan kepada operan kiri.	c = 23 akan memberikan nilai 23 kepada pembolehubah c
+=	Menambah nilai operan kanan pada operan kiri dan berikan jumlah itu kepada operan kiri.	c = 5 a = 2 c += a adalah bersamaan dengan: c = c + a. c akan bersamaan dengan 7
-=	Menolak nilai operan kanan daripada operan kiri dan berikan hasilnya kepada operan kiri.	c = 5 a = 2 c -= a adalah bersamaan dengan: c = c - a. c akan sama dengan 3
*=	Mendarab operan kanan dengan operan kiri dan memberikan hasil kepada operan kiri.	c = 5 a = 2 c *= a bersamaan dengan: c = c * a. c akan bersamaan dengan 10
/=	Membahagikan operan kiri dengan operan kanan dan memberikan hasilnya kepada operan kiri.	c = 10 a = 2 c / = a adalah bersamaan dengan: c = c / a. c akan bersamaan dengan 5
%=	Membahagikan modulo operan dan memberikan hasilnya kepada yang kiri.	c = 5 a = 2 c % = a adalah bersamaan dengan: c = c % a. c akan sama dengan 1
**=	Menaikkan operan kiri kepada kuasa operan kanan dan memberikan hasil kepada operan kiri.	c = 3 a = 2 c ** = a adalah bersamaan dengan: c = c ** a. c akan sama dengan 9
//=	Melakukan pembahagian integer bagi operan kiri oleh operan kanan dan memberikan hasilnya kepada operan kiri.	c = 11 a = 2 c //= a bersamaan dengan: c = c // a. c akan bersamaan dengan 5

Pengendali bitwise dalam Python:

Pengendali bitwise direka bentuk untuk bekerja dengan data dalam format bitwise (perduaan). Katakan kita mempunyai dua nombor a = 60; dan b = 13. Dalam format binari mereka akan kelihatan seperti ini:

Operator	Penerangan	Contoh
&	Operator binari DAN menyalin sedikit kepada hasil hanya jika bit terdapat dalam kedua-dua operan.	(a & b) akan memberi kita 12, yang dalam binari kelihatan seperti 0000 1100
|	Operator "ATAU" binari menyalin sedikit jika ia terdapat dalam sekurang-kurangnya satu operan.	(a | b) akan memberi kita 61, dalam binari 0011 1101
^	Operator "Eksklusif ATAU" binari menyalin sedikit hanya jika bit terdapat dalam salah satu operan, tetapi tidak dalam kedua-duanya.	(a^b) akan memberi kita 49, dalam binari 0011 0001
~	Pengendali pelengkap binari. Ia adalah unary (iaitu, ia hanya memerlukan satu operan) dan menukar bit ke sebaliknya, di mana terdapat satu untuk menjadi sifar dan sebaliknya.	(~a) akan menghasilkan -61, yang dalam binari kelihatan seperti 1100 0011.
<<	Anjakan bitwise ke kiri. Nilai operan kiri "beralih" ke kiri dengan bilangan bit yang dinyatakan dalam operan kanan.	a<< 2 в результате даст 240, в двоичном формате 1111 0000
>>	Alih bitwise ke kanan. Nilai operan kiri "dialihkan" ke kanan dengan bilangan bit yang dinyatakan dalam operan kanan.	a >> 2 memberikan 15, dalam binari 0000 1111

Pengendali logik dalam Python:

Operator	Penerangan	Contoh
dan	Operator logik "DAN". Keadaan akan menjadi benar jika kedua-dua operan adalah benar.	Benar dan Benar sama dengan Benar. Betul dan Salah sama dengan Salah. Palsu dan Benar sama Palsu. False dan False sama False.
atau	Operator logik "ATAU". Jika sekurang-kurangnya satu daripada operan adalah benar, maka keseluruhan ungkapan akan menjadi benar.	Benar atau Benar sama dengan Benar. Betul atau Salah sama dengan Betul. Salah atau Betul sama dengan Betul. Palsu atau Palsu sama dengan Palsu.
bukan	Operator logik "TIDAK". Membalikkan nilai Boolean operan.	tidak Benar sama dengan Salah. tidak Salah sama dengan Benar.

Pengendali keahlian dalam Python:

Sebagai tambahan kepada pengendali yang disenaraikan, dalam Ular sawa Terdapat apa yang dipanggil pengendali keahlian yang direka untuk menyemak kehadiran elemen dalam jenis data yang kompleks, seperti rentetan, senarai, tupel atau kamus:

Pengendali identiti dalam Python:

Pengendali identiti membandingkan penempatan dua objek dalam ingatan komputer.

Keutamaan Operator dalam Python

Jadual berikut menerangkan keutamaan pelaksanaan pernyataan dalam Ular sawa daripada yang tertinggi (dilakukan dahulu) kepada yang terendah.

Operator	Penerangan
**	Eksponensiasi
~ + -	Pengendali pelengkap
* / % //	Pendaraban, pembahagian, pembahagian modulo, pembahagian integer.
+ -	Penambahan dan penolakan.
>> <<	Anjak bitwise ke kanan dan bitwise shift ke kiri.
&	Perduaan "DAN".
^ |	Binari "Eksklusif ATAU" dan binari "ATAU"
<= < > >=	Operator Perbandingan
<> == !=	Pengendali kesaksamaan
= %= /= //= -= += *= **=	Operator Tugasan
tidak	Pengendali identiti
dalam bukan dalam	Operator Keahlian
bukan atau dan	Pengendali logik

Kami telah bercakap sedikit, sekarang mari bercakap tentang fungsi dan kaedah rentetan.

Saya cuba mengumpulkan semua kaedah dan fungsi rentetan di sini, tetapi jika saya terlupa sesuatu, sila betulkan saya.

Operasi Asas

Penggabungan (tambahan)

>>> S1 = "spam" >>> S2 = "telur" >>> cetak (S1 + S2 ) "spamegg"

• Baris pendua

  >>> cetak ("spam" * 3 ) spamspam

• Panjang rentetan (fungsi len)

  >>> len ("spam") 4

• Akses mengikut indeks

  >>> S = "spam" >>> S [ 0 ] "s" >>> S [ 2 ] "a" >>> S [ - 2 ] "a"

  Seperti yang anda lihat daripada contoh, akses mengikut indeks negatif juga boleh dilakukan dalam Python, dengan pengiraan bermula dari penghujung rentetan.

• Pengekstrakan Slice

  Operator pengekstrakan kepingan: . X ialah permulaan hirisan, dan Y ialah penghujung;

  Simbol dengan nombor Y tidak termasuk dalam kepingan. Secara lalai, indeks pertama ialah 0 dan yang kedua ialah panjang rentetan.

  >>> s = "spameggs" >>> s [ 3 : 5 ] "me" >>> s [ 2 : - 2 ] "ameg" >>> s [: 6 ] "spameg" >>> s [ 1 :] "pameggs" >>> s [:] "spameggs"

  Di samping itu, anda boleh menentukan langkah di mana anda ingin mengekstrak kepingan.

  >>> s [:: - 1 ] "sggemaps" >>> s [ 3 : 5 : - 1 ] "" >>> s [ 2 :: 2 ] "aeg"

Fungsi dan Kaedah Rentetan Lain

Apabila memanggil kaedah, anda mesti ingat bahawa rentetan dalam Python tergolong dalam kategori urutan tidak berubah, iaitu, semua fungsi dan kaedah hanya boleh mencipta baris baru.

>>> s = "spam" >>> s [ 1 ] = "b" Traceback (panggilan terbaharu terakhir):Fail "", baris 1, dalam s = "b" TypeError: "str" ​​​​objek tidak menyokong penetapan item>>> s = s [ 0 ] + "b" + s [ 2 :] >>> s "sbam"

Oleh itu, semua kaedah rentetan mengembalikan rentetan baharu, yang kemudiannya harus diberikan kepada pembolehubah.

Jadual "Fungsi dan Kaedah Rentetan"

Fungsi atau kaedah	Tujuan
S = "str"; S = "str"; S = """str"""; S = """str"""
S = "s\np\ta\nbbb"	Urutan melarikan diri
S = r"C:\temp\new"	Rentetan tidak diformat (sekat melarikan diri)
S = b"bait"	Talian
S1+S2	Penggabungan (menambah rentetan)
S1*3	Pengulangan baris
S[i]	Akses mengikut indeks
S	Pengekstrakan Slice
len(S)	Panjang tali
S.mencari(str, ,)	Mencari subrentetan dalam rentetan. Mengembalikan bilangan kejadian pertama atau -1
S.rfind(str, ,)	Mencari subrentetan dalam rentetan. Mengembalikan bilangan kejadian terakhir atau -1
S.indeks(str, ,)	Mencari subrentetan dalam rentetan. Mengembalikan bilangan kejadian pertama atau menimbulkan ValueError
S.rindex(str, ,)	Mencari subrentetan dalam rentetan. Mengembalikan bilangan kejadian terakhir atau menimbulkan ValueError
S.ganti(template, penggantian)	Menggantikan templat
S.berpecah(simbol)	Memisahkan rentetan dengan pembatas
S.isdigit()	Adakah rentetan itu terdiri daripada nombor?
S.isalpha()	Adakah rentetan terdiri daripada huruf?
S.isalnum()	Adakah rentetan itu terdiri daripada nombor atau huruf?
S.lebih rendah()	Adakah rentetan itu terdiri daripada aksara kecil?
S.supper()	Adakah rentetan itu terdiri daripada aksara besar?
S.isspace()	Adakah rentetan itu terdiri daripada aksara yang tidak boleh dipaparkan (ruang, suapan halaman ("\f"), baris baharu ("\n"), carriage return ("\r"), tab mendatar ("\t") dan "tab menegak " ("\v"))
S.istitle()	Adakah perkataan dalam baris bermula dengan huruf besar?
S.atas()	Menukar rentetan kepada huruf besar
S. lebih rendah()	Menukar rentetan kepada huruf kecil
S.bermula dengan(str)	Adakah rentetan S bermula dengan corak str
S.berakhir dengan(str)	Adakah rentetan S berakhir dengan corak str
S.menyertai(senarai)	Memasang rentetan daripada senarai dengan pembatas S
ord(simbol)	Satu aksara kepada kod ASCIInya
chr(nombor)	Kod ASCII kepada aksara
S.memodalkan()	Menukar aksara pertama rentetan kepada huruf besar, dan orang lain pergi ke bahagian bawah
S.pusat(lebar, )	Mengembalikan rentetan berpusat bertepi dengan aksara isian (ruang secara lalai)
S.kira(str, ,)	Mengembalikan bilangan kejadian tidak bertindih bagi subrentetan dalam julat [mula, tamat] (0 dan panjang rentetan lalai)
S.expandtabs()	Mengembalikan salinan rentetan dengan semua aksara tab digantikan dengan satu atau lebih ruang, bergantung pada lajur semasa. Jika TabSize tidak dinyatakan, saiz tab diandaikan sebagai 8 ruang
S.lstrip()	Penyingkiran aksara ruang putih pada permulaan baris
S.rstrip()	Mengalih keluar aksara ruang putih di hujung baris
S.jalur()	Mengalih keluar aksara ruang putih pada permulaan dan penghujung baris
S.pembahagian(sampel)	Mengembalikan tupel yang mengandungi bahagian sebelum corak pertama, corak itu sendiri dan bahagian selepas corak. Jika corak tidak ditemui, ia mengembalikan tuple yang mengandungi rentetan itu sendiri dan kemudian dua baris kosong
S.partition(sep)	Mengembalikan tupel yang mengandungi bahagian sebelum corak terakhir, corak itu sendiri dan bahagian selepas corak. Jika corak tidak ditemui, ia mengembalikan tuple yang mengandungi dua rentetan kosong dan kemudian rentetan itu sendiri
S.swapcase()	Menterjemah aksara huruf kecil ke atas, dan atas ke bawah
S.tajuk()	Menukar huruf pertama setiap perkataan kepada huruf besar dan semua yang lain kepada huruf kecil
S.zfill(lebar)	Menjadikan panjang rentetan sekurang-kurangnya sama dengan lebar, mengisi aksara pertama dengan sifar jika perlu
S.hanya(lebar, fillchar="")	Menjadikan panjang rentetan sekurang-kurangnya sama dengan lebar, mengisi aksara terakhir dengan fillchar jika perlu
S.rjust(lebar, fillchar="")	Menjadikan panjang rentetan sekurang-kurangnya sama dengan lebar, mengisi aksara pertama dengan fillchar jika perlu
S.format(*args, **kwargs)

Artikel ini menyediakan perkara utama yang mungkin berguna apabila beralih kepada bahasa pengaturcaraan Python daripada bahasa pengaturcaraan lain, atau untuk belajar sendiri Ular sawa.

Orientasi Objek

Untuk pemula, anda boleh melangkau ini buat masa ini dan kembali selepas membaca bahan yang lain!

>>> q = >>> p = >>> len(p) 3 >>> p >>> p 2 >>> p.append(’xtra’) >>> p , 4] >>> q

Takrif kelas ialah objek, seperti pada asasnya segala-galanya dalam bahasa.

Iaitu, anda boleh menetapkan definisi kelas kepada pembolehubah:

>>> kelas MyClass: ... i = 12345 ... def f(x): ... print dir(x) ... return x ... >>> c = MyClass() >>> i 123 >>> c.i 12345 >>> c.f > >>> d=MyClass >>> e=MyClass() >>> e<__main__.MyClass instance at 0x000000000239E808>>>>c<__main__.MyClass instance at 0x000000000239E7C8>>>> d >>> d.i 12345 >>> c.i 12345 >>> c.f > >>> e.f. > >>> d.f >>> g = d() >>> g.f >

Lekukan

Lekukan digunakan dalam Python untuk menulis arahan pengelompokan. Sebagai contoh, apabila anda mentakrifkan fungsi atau badan gelung, anda menulis semua pernyataan yang harus dimasukkan ke dalam fungsi dengan lekukan yang sama:

Def some_func(z): y = z*2 # Function body return y # Ini juga merupakan fungsi # Tetapi ini bukan lagi y = 1 print(some_func(y))

Pembolehubah dalam Python

Integer dan nombor titik terapung

Dengan memberikan nombor kepada pembolehubah tanpa titik atau menggunakan int(), anda akan mendapat pembolehubah jenis integer. Hasil pembahagian dua integer juga akan menjadi integer; baki bahagian akan dibuang.

Tambahkan noktah pada penghujung nombor untuk mencipta pembolehubah terapung:

Rentetan dalam Python

Menggantikan nilai ke dalam rentetan

Python membolehkan anda membuat rentetan menggunakan templat dan menggantikan nilai pembolehubah ke dalamnya.

Terdapat dua pilihan untuk menggantikan nilai ke dalam rentetan: penggantian kedudukan dan menggunakan parameter bernama.

Penggantian nilai kedudukan

Output = "Produk %s dalam kategori %s" % (produk, kategori) output = "Anda mempunyai %s $" % usd_count

DALAM dalam kes ini Nilai pembolehubah akan dimasukkan secara berurutan ke dalam rentetan.

Menggunakan Parameter Dinamakan

Output = "Hari ini ialah %(bulan)s %(hari)s.") % ("bulan": m, "hari": d)

Apabila menggunakan parameter bernama untuk menggantikan nilai ke dalam rentetan, nilai yang akan digantikan akan dipilih dengan namanya daripada kamus.

Kaedah ini adalah lebih baik jika anda merancang untuk menterjemah projek anda ke dalam pelbagai bahasa, kerana ia akan membolehkan penterjemah menukar susunan perkataan dalam templat asal.

Memformat dan Mengeluarkan Rentetan

Koma di belakang membolehkan anda memasukkan ruang selepas mencetak nilai dan bukannya baris baharu:

>>> manakala b< 10: ... print b, ... b += 1 ... 1 2 3 4 5 6 7 8 9 >>> untuk x dalam julat(1, 11): ... cetak str(x).rjust(2), str(x*x).rjust(3), ... # Perhatikan koma di hujung baris sebelumnya! ... print str(x*x*x).rjust(4) ...

Output berformat:

1 1 1 2 4 8 3 9 27 4 16 64 5 25 125 6 36 216 7 49 343 8 64 512 9 81 729 10 100 1000

Contoh ini menunjukkan penggunaan kaedah rentetan rjust(), yang membenarkan rentetan dalam medan dengan lebar yang ditentukan, melapiknya dengan ruang di sebelah kiri. Kaedah ljust() dan center() beroperasi sama. Mereka tidak mengeluarkan apa-apa - mereka hanya mengembalikan baris baharu. Jika baris asal terlalu panjang, ia tidak dipotong tetapi dikembalikan tidak berubah: biasanya lebih baik untuk mengacaukan susun atur lajur daripada mencetak nilai yang salah. (Jika anda benar-benar ingin memangkasnya, gunakan operator slice: 's.ljust(n)'.)

Fungsi zfill() yang ditakrifkan dalam modul rentetan mungkin juga berguna.
yang melapik rentetan dengan nombor di sebelah kiri dengan sifar, memproses tanda tambah dan tolak dengan betul:

>>> import rentetan >>> string.zfill('12', 5) '00012' >>> string.zfill('-3.14', 7) '-003.14' >>> string.zfill('3.14159265359', 5) '3.14159265359'

Menggunakan operator % kelihatan seperti ini:

>>> import matematik >>> cetak 'Nilai PI ialah lebih kurang %5.3f.' % \ ... math.pi Nilai PI ialah lebih kurang 3.142.

% untuk memaparkan maklumat dalam 3 lajur:

>>> untuk x dalam julat(1,11): ... cetak '%2d %3d %4d' % (x, x*x, x*x*x) ... 1 1 1 2 4 8 3 9 27 4 16 64 5 25 125 6 36 216 7 49 343 8 64 512 9 81 729 10 100 1000

Operasi dan operan

Tugasan

Anda boleh menetapkan nilai kepada beberapa pembolehubah sekaligus

A = b = c = 1 a, b = 0, 1

Eksponensiasi

5 kepada kuasa 2 (5 kuasa dua):

Cetak 5**2

Keadaan logik

Pengendali masuk dan bukan dalam menyemak sama ada nilai yang ditentukan hadir dalam jujukan. Pengendali ialah dan bukan menentukan sama ada dua pembolehubah merujuk kepada objek yang sama. Semua pengendali ini mempunyai keutamaan yang sama, iaitu lebih rendah daripada pengendali aritmetik.

Ungkapan Boolean boleh digabungkan: sebagai contoh, 'a< b == c’ проверяет,
sama ada a kurang daripada b dan sama ada b dan c adalah sama.

Ungkapan Boolean boleh dikumpulkan menggunakan operator Boolean
dan dan atau, serta hasilnya boleh diterbalikkan menggunakan operator bukan. Semua logik
operator mempunyai keutamaan yang lebih rendah daripada operator perbandingan. Antara operator logik, tidak mempunyai keutamaan tertinggi dan atau mempunyai paling sedikit.

Fungsi terbina dalam Python

Semua fungsi terbina dalam bahasa boleh dilihat di sini:

Kitaran

Manakala Gelung

Gelung sementara digunakan untuk melakukan tindakan berulang kali semasa syarat dipenuhi:

Semasa expr: suite1

Pernyataan while dilaksanakan dalam susunan berikut:

1. Ungkapan expr dinilai dan, jika ia palsu, teruskan ke langkah 3.
2. Blok kod Suite1 dilaksanakan. Dalam kes ini, pelaksanaan arahan rehat dalam blok
segera mengganggu pelaksanaan gelung (titik 3 tidak dilaksanakan), dan pelaksanaan
meneruskan kenyataan mengganggu pelaksanaan blok kod, selepas itu pelaksanaan
kitaran diteruskan dari titik 1. Selepas melengkapkan pelaksanaan blok suite1, anda
Gelung diteruskan dari titik 1.
3. Kod blok suite2 (cawangan lain) dilaksanakan. Penyataan rehat dan sambung dalam
blok ini dianggap tergolong dalam gelung luar.

Untuk gelung

Gelung for dalam Python berulang melalui unsur-unsur urutan sewenang-wenang (contohnya, senarai atau rentetan) dalam susunan ia muncul:

A = ['kucing', 'tingkap', 'buang'] >>> untuk x dalam a: ... cetak x, len(x) ... kucing 3 tingkap 4 buang 9

Ciri gelung for dalam Python

Pernyataan for digunakan untuk mengulangi unsur-unsur urutan:

Untuk lnilai dalam urutan: suite1

Urutan ungkapan dinilai sekali dan mesti menghasilkan jujukan (objek yang operasi mendapatkan elemen mengikut indeks ditakrifkan; jika indeks berada di luar julat, pengecualian IndexError mesti dibuang).

Untuk setiap elemen jujukan, dalam tertib indeks menaik, bermula dari 0, penetapan nilai dibuat kepada elemen jujukan dan suite blok kod1 dilaksanakan.

Selepas urutan telah habis (ditentukan oleh IndexError yang dilemparkan), jika cawangan lain hadir, blok suite2 dilaksanakan.

Melaksanakan pernyataan rehat dalam blok suite1 serta-merta memecahkan gelung (cawangan lain diabaikan). Apabila melaksanakan penyataan continue dalam blok suite1, blok selebihnya dilangkau dan gelung diteruskan selepas memberikan nilai l kepada elemen seterusnya bagi jujukan jujukan, atau cabang lain dilaksanakan jika tiada unsur seterusnya dalam jujukan.

Anda boleh menetapkan kepada pembolehubah atau pembolehubah yang merupakan sebahagian daripada nilai tanpa menjejaskan elemen seterusnya yang diperuntukkan kepada nilai. Pembolehubah yang disertakan dalam lvalue tidak dipadamkan selepas penghujung gelung dan mengekalkan nilai terakhir yang diberikan kepada mereka. Walau bagaimanapun, jika jujukan kosong, lvalue tidak akan diberikan sebarang nilai (oleh itu, menggunakan pembolehubah ini tanpa semakan tambahan, anda mempunyai peluang untuk mendapatkan NameError).

Menukar urutan lelaran

Apabila menukar urutan yang elemen yang anda cuba, berhati-hati. Elemen semasa jujukan ditentukan oleh nilai pembilang dalaman. Penghujung jujukan ditentukan oleh pengecualian IndexError apabila cuba mendapatkan elemen seterusnya. Oleh itu, jika dalam blok suite1 anda memadamkan semasa atau salah satu elemen jujukan yang dilalui, elemen seterusnya akan dilangkau.

Begitu juga, jika anda menambah elemen baharu pada jujukan sebelum yang semasa, badan gelung untuk elemen semasa akan dilaksanakan semula. Tingkah laku ini boleh membawa kepada ralat buruk yang biasanya boleh dielakkan dengan mengulangi elemen salinan jujukan asal, contohnya:

Untuk x dalam a[:]: jika x< 0: a.remove(x)

fungsi range() dan xrange().

Jika anda perlu mengulangi urutan nombor, maka terbina dalam
fungsi julat(). Ia mencipta senarai yang mengandungi janjang aritmetik:
>>> julat(10)

Fungsi xrange berfungsi sama, tetapi bukannya menjana senarai, ia mencipta objek jenis xrange - nilainya boleh diulang dalam gelung, tetapi tidak boleh diubah

>>> jenis(julat(2)) >>> jenis(xrange(2))

Pecah dan teruskan arahan, jika tidak bercabang dalam gelung

Pernyataan putus keluar dari gelung bersarang paling dalam untuk atau semasa. Pernyataan continue meneruskan gelung dari lelaran seterusnya.

Gelung boleh mempunyai cawangan lain, yang dilaksanakan pada keluar "biasa" (keletihan urutan dalam untuk gelung, kegagalan untuk memenuhi syarat dalam gelung sementara), tanpa gangguan oleh pernyataan rehat. Mari kita tunjukkan penggunaannya menggunakan contoh mencari nombor perdana:

>>> untuk n dalam xrange(2, 10): ... untuk x dalam xrange(2, n): ... jika n % x == 0: ... print n, '=', x, ' *', n/x ... pecah ... lain: ... cetak n, '- nombor perdana' ... 2 - nombor perdana 3 - nombor perdana 4 = 2 * 2 5 - nombor perdana 6 = 2 * 3 7 - nombor perdana 8 = 2 * 4 9 = 3 * 3

Fungsi

>>> def fib(n):

Arahan yang membentuk badan fungsi ditulis inden, bermula dengan baris seterusnya. Arahan pertama badan fungsi boleh menjadi docstring.

>>> def fib(n): ... '''Memaparkan nombor Fibonacci dalam nombor yang diberi''' ... a, b = 0, 1 ... manakala b< n: ... print b, ... a, b = b, a+b

>>> q = julat(5) >>> def ch(l): ... l.append("Baharu!") ... >>> q >>> ch(q) >>> q

Pernyataan pulangan keluar dari fungsi dan mengembalikan nilai. Tanpa hujah, return digunakan untuk keluar dari tengah-tengah prosedur, di mana tiada satu pun dikembalikan.

Nilai lalai dikira di mana fungsi ditakrifkan dalam skop
keterlihatan definisi, jadi

I = 5 def f(arg = i): print arg i = 6 f() akan mencetak 5.

Nota penting: Nilai lalai dikira sekali sahaja. Ini ditunjukkan apabila argumen lalai ialah objek boleh ubah seperti senarai atau kamus. Sebagai contoh, fungsi berikut mengumpul hujah yang diluluskan.

Def f(a, l = ): l.tambah(a) kembalikan l cetak f(1) cetak f(2) cetak f(3)

Keputusan pelaksanaan adalah seperti berikut:

Set hujah sewenang-wenangnya

Akhir sekali, pilihan yang kurang biasa digunakan ialah mentakrifkan fungsi supaya ia boleh dipanggil dengan bilangan argumen yang sewenang-wenangnya. Dalam kes ini, hujah akan diluluskan sebagai tupel. Sebelum ini nombor berubah-ubah hujah boleh ada bilangan sewenang-wenangnya hujah biasa:

Def fprintf(fail, format, *args): file.write(format % args)

Bernama Hujah

Fungsi ini boleh dipanggil menggunakan argumen bernama (kata kunci
argumen) dalam bentuk 'kata kunci = nilai'.

Contoh def(formal, *argumen, **kata kunci): cetak "Argumen biasa:", cetakan rasmi '-'*40 untuk arg dalam argumen: print arg print '-'*40 untuk kw dalam keywords.keys(): print kw, ':', kata kunci

Fungsi lambda Python

Fungsi lambda melakukan perkara yang sama seperti fungsi biasa.

Tidak seperti lambda biasa, lambda menggunakan sintaks yang dipendekkan: senarai hujah ditulis tanpa kurungan dan tiada kata kunci pulangan. Badan fungsi hanya boleh mengandungi satu ungkapan. Fungsi lambda tidak mempunyai nama, tetapi boleh dipanggil melalui pembolehubah yang ditetapkan.

>>> g = lambda x: x*2 >>> g(3)

Input dan Output Data dalam Python

Membaca dan menulis fail

Fungsi open() terbina dalam mengembalikan objek fail dan biasanya digunakan dengan dua argumen: 'open(nama fail, mod)'.

>>> f=open(’/tmp/workfile’, ‘wb’) >>> print f

Argumen pertama ialah rentetan yang mengandungi nama fail, argumen kedua ialah rentetan yang mengandungi beberapa aksara yang menerangkan mod penggunaan fail. Mod boleh menjadi 'r' jika fail dibuka untuk membaca sahaja, 'w' - untuk menulis sahaja (fail sedia ada akan ditimpa), dan 'a' - untuk menambah pada akhir fail. Dalam mod 'r+', fail dibuka serta-merta untuk membaca dan menulis. Argumen mod adalah pilihan: jika ditinggalkan, 'r' diandaikan.

Pada Windows (dan dalam beberapa kes pada Macintosh), fail dibuka dalam mod teks secara lalai - untuk membuka fail dalam mod binari, anda perlu menambah 'b' pada baris mod. Perlu diingat bahawa data binari, seperti gambar JPEG dan juga teks UNICODE, akan rosak apabila membaca daripada atau menulis ke fail yang dibuka dalam mod teks! Cara terbaik untuk melindungi diri anda daripada masalah adalah dengan sentiasa membuka fail dalam mod binari, walaupun pada platform di mana mod binari adalah lalai (anda mungkin suatu hari nanti mahu menjalankan program pada platform lain).

modul acar

Jika anda mempunyai objek x dan objek fail f terbuka untuk ditulis, cara paling mudah menyimpan objek hanya memerlukan satu baris kod:

Pickle.dump(x, f)

Anda juga boleh memulihkan objek (f ialah objek fail yang dibuka untuk dibaca):

X = pickle.load(f)

Python terbina dalam

Python merangkumi banyak fungsi, seperti map() dan zip(), yang sangat memudahkan pengiraan.

Struktur Data Python

Senarai

Senarai nilai dipisahkan koma yang disertakan dalam petak
kurungan. Elemen senarai tidak perlu daripada jenis yang sama

A = ['spam', 'telur', 100, 1234]

Penomboran elemen senarai adalah serupa dengan baris - elemen pertama bernombor 0.

Kaedah untuk bekerja dengan senarai

tambah, pop dan masukkan

Append menambah elemen baharu pada penghujung senarai.

Kaedah sisipan membolehkan anda memasukkan elemen pada permulaan atau kedudukan lain senarai - anda menentukan indeks elemen sebelum elemen baharu akan ditambah:

>>> a.insert(2, -1)

pop() mengembalikan elemen terakhir senarai, mengalih keluarnya daripada senarai.

indeks dan kiraan

Indeks akan membolehkan anda mencari di kedudukan manakah elemen pertama dengan nilai tertentu berada.

mengalih keluar, menyusun, membalikkan

Menggunakan Senarai

tambah dan pop membolehkan anda menggunakan senarai sebagai timbunan:

>>> tindanan = >>> tindanan.tambah(6) >>> tindanan.tambah(7) >>> tindanan >>> tindanan.pop() 7 >>> tindanan

Ia juga mudah untuk menggunakan senarai sebagai baris gilir elemen - menambah dengan tambah dan mendapatkan semula yang pertama dalam baris gilir dengan pop(0):

>>> baris gilir = ["Eric", "John", "Michael"] >>> queue.append("Terry") # Terry ditambahkan pada baris gilir >>> queue.append("Graham") # Graham ditambahkan ke baris gilir >>> queue.pop(0) 'Eric' >>> queue.pop(0) 'John' >>> baris gilir ['Michael', 'Terry', 'Graham']

hirisan

Potongan tidak boleh dibuat daripada kamus dan set atau koleksi.
Penggunaan hirisan yang paling biasa dalam ular sawa adalah untuk mencipta salinan urutan atau sebahagian daripadanya.
Pertimbangkan kepingan sebagai sebahagian daripada urutan. Sebagai contoh, beberapa keping daripada senarai:

>>> s = #senarai ringkas >>> s[:] #salinan senarai, selalunya sangat berguna >>> s # semua elemen kecuali yang pertama >>> s[-3:] # 3 elemen terakhir >>> s #buang dahulu dan 2 terakhir

Kepingan boleh mempunyai tiga parameter:

S[::2] #elemen berpasangan >>> s #elemen dari yang pertama hingga yang keempat dalam penambahan 2

Semua tindakan ini boleh dilakukan dengan rentetan, tupel dan senarai.

>>> "Hello Dolly!" "el ol!"

Bagaimana untuk "membuka" rentetan (tuple, senarai):

>>> "God saw I was dog"[::-1] "god saw I was doG" >>> #langkah negatif boleh bertukar menjadi garu jika anda tidak mengetahui secara spesifik.

Terdapat beberapa tindakan penghiris yang hanya boleh dilakukan dengan senarai. Hakikatnya ialah mereka adalah satu-satunya urutan asas yang boleh berubah, dan yang mana urutan itu penting. Seterusnya kita akan bercakap tentang kepingan yang mengubah urutan.
Anda boleh memadam:

>>> s = senarai(julat(10)) #isi 0..9 >>> del s #padam elemen antara yang ketiga dan yang terakhir dalam langkah 2 >>> s [ 0, 1, 2, 4, 6 , 8, 9]

Anda juga boleh memasukkan elemen:
Dalam pilihan penggantian:

>>> s=list("AF") #ada senarai, kami menggantikan elemen yang ditentukan dengan ['A','F'] >>> #ya, walaupun dalam reka bentuk sedemikian saiz mesti sepadan, ia lebih mudah untuk memahami dengan mencuba >>> s [0, 1, "A", 4, "F", 8, 9]

Nah, atau pilihan sisipan yang lebih mudah:

>>> s = ["4 berada di sini"] # penggantian sekeping berurutan >>> s [ 0, 1, "A", "4 berada di sini", "F", 8, 9] >>> s = [" selepas sifar"] #atau, ringkasnya, masukkan >>> s [ 0, "selepas sifar", 1, "A", "4 berada di sini", "F", 8, 9]

Anda boleh membuat kelas dari mana anda boleh membuat kepingan.
Gantikan __getitem__, __setitem__ dan __delitem__.
Pada pandangan pertama, segala-galanya kelihatan sangat mudah, tetapi jika anda melihat dengan lebih dekat, __getitem__(diri, kunci) hanya menerima satu parameter, kunci, dan kita boleh mempunyai sebanyak 3 nombor untuk sekeping... Semuanya sangat mudah: dalam kes apabila seseorang cuba memotong sekeping dari objek kami, fungsi akan menerima objek jenis kepingan sebagai nilai utama:

>>> class MySliceble(): def __getitem__(self, key): if isinstance(key, slice): return list(range(key.start, key.stop, key.step)) else: naikkan Exception("Mencuba untuk akses mengikut indeks") >>> my = MySliceble() >>> my

Sudah tentu, contoh ini sangat simbolik, tetapi anda boleh memahami: objek kelas kepingan mempunyai tiga sifat: mula, berhenti dan langkah, sepadan dengan nombor dari kurungan hirisan. Anda perlu berhati-hati, jika nombor tiada, maka nilainya ialah Tiada, contohnya [::] akan dihiris(Tiada, Tiada, Tiada) dan [:-3] akan dihiris(Tiada, -3, Tiada).
Kami melakukan penggantian/penyisipan dan penyingkiran kepingan dengan analogi.

Tuple - tuple

Tuple ialah jujukan unsur yang dipisahkan dengan koma dan disertakan dalam kurungan. Tuple itu sendiri tidak boleh diubah suai, tetapi ia boleh mengandungi unsur boleh ubah.

>>> t = 1, [’foo’, ’bar’] >>> t (1, [’foo’, ’bar’]) >>> t = Traceback (paling dalam terakhir): Fail " ", baris 1, dalam ? TypeError: objek tidak menyokong penetapan item >>> t.append('baz') >>> t(1, ['foo', 'bar', 'baz'])

Mencipta tupel kosong

c = ()

Mencipta Tuple daripada Satu Elemen

c = (1,)

Kamus

Adalah lebih baik untuk menganggap kamus sebagai set pasangan kunci:nilai yang tidak tertib, dengan keperluan bahawa kunci itu unik dalam satu kamus. Sepasang pendakap kerinting () mencipta kamus kosong. Dengan meletakkan senarai kunci: pasangan nilai yang dipisahkan koma dalam pendakap kerinting, anda menentukan kandungan awal kamus. Kamus ditulis dalam bentuk yang sama semasa output.

Untuk mengakses elemen kamus, anda perlu menentukan kuncinya dalam kurungan segi empat sama.

>>> tel = ("jack": 4098, "sape": 4139) >>> tel["guido"] = 4127 >>> tel ("sape": 4139, "guido": 4127, "jack": 4098) >>> tel["jack"] 4098 >>> del tel["sape"] >>> tel["irv"] = 4127 >>> tel ("guido": 4127, "irv": 4127, "jack": 4098) >>> tel.keys() ["guido", "irv", "jack"] >>> "guido" dalam tel True

Modul dalam Python

Modul ialah fail yang mengandungi definisi dan arahan lain bahasa Python. Nama
Fail dibentuk dengan menambahkan akhiran (sambungan) ‘.py’ ​​​​pada nama modul. DALAM
dalam modul, namanya tersedia dalam pembolehubah global __name__.

Modul boleh mengandungi sebarang arahan yang bertujuan untuk memulakannya, bukan hanya definisi fungsi. Mereka hanya dilaksanakan apabila modul diimport buat kali pertama.

Mengimport Fungsi dan Pembolehubah

Versi pernyataan import ini membolehkan anda mengimport semua nama yang ditakrifkan dalam modul, kecuali nama yang bermula dengan garis bawah (‘_’):
>>> dari import fibo *

Bermula dengan Python 2.0, anda boleh mengatasi nama yang diimport apabila melaksanakan pernyataan import:

Import rentetan sebagai _string daripada anydbm import dibuka sebagai dbopen

fungsi dir()

Anda boleh menggunakan fungsi dir() terbina dalam untuk mengetahui nama yang ditakrifkan dalam modul. Ia mengembalikan senarai rentetan yang diisih:

>>> import fibo, sys >>> dir(fibo) ['__name__', 'fib', 'fib2'] >>> dir(sys) ['__name__', 'argv', 'builtin_module_names', 'hak cipta' , 'exit', 'maxint', 'modules', 'path', 'ps1', 'ps2', 'setprofile', 'settrace', 'stderr', 'stdin', 'stdout', 'version']

Tanpa hujah, dir() mengembalikan senarai nama yang ditakrifkan dalam skop semasa:

Senarai yang dikembalikan oleh fungsi dir() tidak mengandungi nama fungsi dan pembolehubah terbina dalam - ia ditakrifkan dalam modul __builtin__ standard:

Fail '__init__.py' diperlukan untuk Python mengenali direktori sebagai mengandungi pakej - sekali gus menghalang modul lengkap di bawah laluan carian daripada disembunyikan oleh direktori dengan nama biasa (seperti 'rentetan'). Dalam kes paling mudah, '__init__.py' ialah fail kosong, tetapi mungkin mengandungi kod permulaan pakej dan/atau tetapkan pembolehubah __all__,

Pernyataan import menggunakan konvensyen berikut: jika senarai bernama __all__ ditakrifkan dalam fail permulaan '__init__.py', ia digunakan sebagai senarai nama modul yang akan diimport apabila menggunakan 'dari import pakej *'. Penyelenggaraan senarai ini mengikut komposisi semasa pakej adalah tanggungjawab penulis. Ia juga mungkin untuk tidak mentakrifkan senarai __all__ jika pengarang tidak fikir ia sesuai untuk mengimport *.

Pengendalian Pengecualian

Contoh berikut menggesa pengguna sehingga integer dimasukkan atau pelaksanaan dihentikan (biasanya Ctrl-C). Dalam kes kedua, pengecualian KeyboardInterrupt dilemparkan.

Manakala 1: cuba: x = int(raw_input("Masukkan integer: ")) break kecuali ValueError: print "Anda membuat kesilapan, cuba lagi..."

Pernyataan cuba boleh mempunyai lebih daripada satu kecuali klausa, mentakrifkan pengendali untuk pengecualian yang berbeza. Hanya satu daripadanya akan dilaksanakan (maksimum). Hanya pengecualian yang dilemparkan dalam cabang percubaan yang sepadan diproses, dan bukan dalam pengendali pernyataan percubaan yang lain. Selepas kata kunci except, beberapa jenis pengecualian boleh ditentukan sebagai tuple:

Kecuali (RuntimeError, TypeError, NameError): ... lulus

Selepas semua cawangan kecuali, pernyataan cuba mungkin mengandungi cawangan lain, yang akan dilaksanakan jika tiada pengecualian dilemparkan semasa pelaksanaan cawangan cuba.

Kelas dalam Python

Ciri kelas yang paling penting: mekanisme pewarisan membenarkan beberapa kelas asas, kelas terbitan boleh mengatasi mana-mana kaedah kelas asas, dan kaedah dengan nama kelas asas yang sama boleh dipanggil daripada kaedah. Objek boleh mengandungi sebarang jumlah data mereka sendiri.

Sintaks Definisi Kelas

Model paling mudah bagi definisi kelas kelihatan seperti ini:

Nama_kelas kelas: some_instruction

Mencipta objek - contoh kelas

Mencipta contoh kelas menggunakan notasi panggilan fungsi. Fikirkan sahaja objek kelas sebagai fungsi tanpa parameter yang mengembalikan contoh kelas yang dibuat.

X = MyClass()

Dalam contoh di atas, objek "kosong" dibuat.

Contoh mencipta kelas dengan atribut dan kaedah:

Kelas MyClass: i = 12345 def f(x): kembali "Hello kepada dunia!"

Dalam banyak kes, adalah perlu untuk mencipta objek dengan keadaan awal tertentu - untuk ini, kelas mesti mengandungi kaedah __init__() khas,

kelas MyClass: def __init__(self): self.data =

Jika kelas mempunyai kaedah __init__() yang ditakrifkan, ia dipanggil secara automatik apabila setiap contoh kelas itu dibuat.

Untuk fleksibiliti yang lebih besar, kaedah __init__() sudah tentu boleh mempunyai hujah. Dalam kes ini, argumen yang digunakan untuk mencipta instance kelas dihantar kepada kaedah __init__(). Sebagai contoh:

>>> kelas Kompleks: ... def __init__(self, realpart, imagpart): ... self.r = realpart ... self.i = imagpart ... >>> x = Complex(3.0, -4.5) >>> x.r, x.i (3.0, -4.5)

Kaedah Contoh Kelas

Biasanya kaedah dipanggil secara langsung:

Dalam contoh kami, ia akan mengembalikan rentetan 'Hello to the world!'. Dalam kes ini, sama sekali tidak perlu memanggil kaedah secara langsung. x.f ialah objek dan boleh disimpan untuk kegunaan kemudian:

Xf = x.f manakala 1: cetak xf()

Keistimewaan kaedah kelas ialah mereka menerima objek yang mereka miliki sebagai hujah pertama mereka. Dalam contoh kami, panggilan ke x.f() adalah setara sepenuhnya dengan MyClass.f(x). Secara umum, memanggil kaedah yang terikat pada objek dengan senarai n argumen adalah sama persis dengan memanggil kaedah fungsi tidak terikat yang sepadan dengan senarai argumen yang diperoleh dengan menambahkan objek sebelum argumen pertama.

Warisan

Takrif kelas terbitan bernama ClassB kelihatan seperti ini:

Kelas KelasB(KelasA): ...

Kelas asas (ClassA) mesti ditakrifkan dalam skop yang mengandungi definisi kelas terbitan ClassB. Anda boleh menggunakan ungkapan dan bukannya nama kelas asas.

Sebagai contoh, jika kelas asas ditakrifkan dalam modul lain:

Kelas KelasB(ModulA.ClassA):

Kelas terbitan boleh mengatasi kaedah kelas asas. Kaedah kelas asas yang memanggil kaedah lain yang ditakrifkan padanya mungkin, sebenarnya,
panggil kaedah kelas terbitan yang mengatasi kaedah ini

>>> kelas KelasA: ... a = "A" ... b = "B" ... def Print_A(self): ... print a ... def Print_B(self): ... print self .b ... def Print_Both(self): ... pring ... def PrintBoth(self): ... print "Cetak A" ... self.Print_A() ... print "Cetakan B" .. .self.Print_B() ... >>> a = "aaa" >>> cc = ClassA() >>> cc.Print_A() aaa >>> cc.Print_B() B >>> cc.PrintBoth( ) Mencetak A aaa Mencetak B B >>> kelas KelasB(KelasA): ... def Cetak_A(diri): ... cetak sendiri.a ... >>> ccc = KelasB() >>> ccc.CetakKedua() Mencetak A A Mencetak B B

Apabila mengatasi kaedah dalam kelas terbitan, anda juga mungkin mahu memanggil kaedah kelas asas dengan nama yang sama. Ini boleh dilakukan: hanya panggil kaedah, dengan jelas menyatakan nama kelas:

>>> kelas ClassC(ClassA): ... def Print_A(self): ... print "Cetak menggunakan kaedah lama daripada ClassA" ... ClassA.Print_A(self) ... >>> c = ClassC() >>> c.PrintBoth() Mencetak A Cetak menggunakan kaedah lama daripada KelasA aaa Pencetakan B B

Pewarisan berbilang dalam Python

Python mempunyai sokongan untuk pelbagai warisan. Untuk awak kelas baru menjadi pewaris kepada atribut dan kaedah beberapa kelas lain, cuma senaraikan mereka dipisahkan dengan koma dalam takrifan kelas baharu:

>>> kelas ClassD(ClassB, ClassA): ... "Menyemak warisan" ... ... >>> d = ClassD() >>> d.PrintBoth() Mencetak A A Mencetak B B

Nuansa penting apabila pusaka berbilang- ini adalah skema untuk mencari objek (resolusi nama) - mula-mula carian adalah mendalam-dahulu, kemudian dari kiri ke kanan.

Ini bermakna jika kaedah atau nama atribut terdapat dalam kedua-dua kelas yang anda warisi, kelas yang terdapat dalam yang pertama atau nenek moyangnya akan digunakan.

Atribut peribadi

>>> kelas clA: ... __privateA = "aaa" ... def prn(s): ... print s.__privateA ... >>> class clB(clA): ... __privateA = "bbb" ... >>> A = clB() >>> A.prn() aaa >>> A.__privateA Traceback (panggilan terbaharu terakhir): Fail "", baris 1, dalam AttributeError: instance clB tidak mempunyai atribut " __privateA" >>> dir(A) ["__doc__", "__module__", "_clA__privateA", "_clB__privateA", "prn"] >>> A._clB__privateA "bbb" >>>

Contoh praktikal

Bagaimana untuk mengalih keluar semua aksara kecuali nombor dari rentetan dalam Python?

>>> import semula >>> re.sub("[^0-9]", "", "sdkjh987978asd098as0980a98sd") "987978098098098"

satu perkara yang menarik Perkara yang saya lihat hari ini ialah apabila saya menetapkan fungsi kepada ahli kelas, ia menjadi kaedah tidak terikat. Seperti:

Ujian Kelas(objek): @classmethod def initialize_class(cls): def print_string(self, str): print(str) # Di sini jika saya mencetak(print_string), saya melihat fungsi cls.print_proc = print_string # Di sini jika saya lakukan print(cls.print_proc), saya melihat kaedah tidak terikat; jadi jika saya # mendapat objek Ujian o, saya boleh memanggil o.print_proc("Hello")

2018-12-04T00:00Z

agak sukar untuk difahami

Nah, ini adalah topik yang agak rumit dan ia ada kaitan dengan deskriptor.

Mari kita mulakan dengan fungsi. Semuanya jelas di sini - anda hanya memanggilnya, semua hujah yang disediakan diluluskan apabila ia dilaksanakan:

>>> f = A.__dict__["f1"] >>> f(1) 1

TypeError biasa berlaku apabila terdapat masalah dengan bilangan parameter:

>>> ", baris 1, dalam TypeError: f1() mengambil tepat 1 hujah (0 diberikan)

Sekarang kaedah. Kaedah adalah fungsi dengan sedikit rempah. Terdapat deskriptor di sini. Seperti yang diterangkan dalam model data, A.f1 dan A().f1 diterjemahkan kepada A.__dict__["f1"].__get__(None, A) dan type(a).__dict__["f1"].__get__(a , taip (a)) masing-masing. Dan keputusan __get__ ini berbeza daripada fungsi f1 mentah. Objek ini adalah pembalut di sekeliling f1 asal dan mengandungi beberapa logik tambahan.

Dalam kes kaedah tidak terikat, logik ini melibatkan pemeriksaan sama ada hujah pertama ialah contoh A:

>>> f = A.f1 >>> f() Traceback (panggilan terbaharu terakhir): Fail " ", baris 1, dalam TypeError: unbound method f1() mesti dipanggil dengan A instance sebagai hujah pertama (tidak mendapat apa-apa) >>> f(1) Traceback (panggilan terbaharu terakhir): Fail " ", baris 1, dalam TypeError: kaedah tidak terikat f1() mesti dipanggil dengan A instance sebagai hujah pertama (dapat int instance sebaliknya)

Jika semakan ini berjaya, ia melaksanakan f1 asal dengan contoh ini sebagai hujah pertama:

>>> f(A())<__main__.A object at 0x800f238d0>

Ambil perhatian bahawa atribut im_self ialah Tiada:

>>> f.im_self is None True

Dalam kes kaedah terikat, logik ini serta-merta membekalkan f1 asal dengan contoh A yang telah dibuat (contoh ini sebenarnya disimpan dalam im_self):

>>> f = A().f1 >>> f.im_self<__main__.A object at 0x800f23950>>>> f()<__main__.A object at 0x800f23950>

Jadi terikat bermakna itu fungsi asas terikat pada beberapa contoh. tidak terikat bermakna ia masih terikat, tetapi hanya kepada kelas.

11-12-2018T00:00Z

Tafsiran saya begini.

Serpihan kelas fungsi:

Fungsi Kelas(objek): . . . def __get__(self, obj, objtype=None): "Simulate func_descr_get() in Objects/funcobject.c" jika obj is None: return self return types.MethodType(self, obj)

Fungsi Kelas(objek): . . . def __get__(self, obj, objtype=None): "Simulate func_descr_get() dalam Objects/funcobject.c" return types.MethodType(self, obj, objtype)

1. Jika fungsi dipanggil tanpa kelas atau contoh, ia adalah fungsi mudah.

Jika fungsi dipanggil daripada kelas atau contoh, __get__nya dipanggil untuk mendapatkan semula fungsi yang dibalut:
A. Bx adalah sama dengan B.__dict__["x"].__get__(Tiada, B) . Dalam Python 3 ini kembali fungsi biasa. Dalam Python 2, ini mengembalikan fungsi tidak terikat.

b. bx adalah serupa dengan type(b).__dict__["x"].__get__(b, type(b) . Ini akan mengembalikan kaedah terikat dalam kedua-dua Python 2 dan Python 3, yang bermaksud diri akan diluluskan secara tersirat sebagai hujah pertama .