Catatan Sintaks. Dalam bab ini dan bab selanjutnya, notasi BNF yang diperluas akan digunakan untuk mendeskripsikan sintaksis, bukan analisis leksikal. Ketika (salah satu alternatif) aturan sintaks memiliki bentuk Show
name ::= and no semantics are given, the semantics of this form of parenth_form ::= "(" [ 4 are the same as for parenth_form ::= "(" [ 56. 1. Arithmetic conversionsWhen a description of an arithmetic operator below uses the phrase “the numeric arguments are converted to a common type”, this means that the operator implementation for built-in types works as follows
Some additional rules apply for certain operators (e. g. , a string as a left argument to the ‘%’ operator). Extensions must define their own conversion behavior 6. 2. AtomsAtoms are the most basic elements of expressions. The simplest atoms are identifiers or literals. Forms enclosed in parentheses, brackets or braces are also categorized syntactically as atoms. The syntax for atoms is atom ::= 6. 2. 1. Identifiers (Names)An identifier occurring as an atom is a name. See section for lexical definition and section for documentation of naming and binding When the name is bound to an object, evaluation of the atom yields that object. When a name is not bound, an attempt to evaluate it raises a exception Private name mangling. When an identifier that textually occurs in a class definition begins with two or more underscore characters and does not end in two or more underscores, it is considered a private name of that class. Private names are transformed to a longer form before code is generated for them. The transformation inserts the class name, with leading underscores removed and a single underscore inserted, in front of the name. For example, the identifier parenth_form ::= "(" [ 7 occurring in a class named parenth_form ::= "(" [ 8 will be transformed to parenth_form ::= "(" [ 9. This transformation is independent of the syntactical context in which the identifier is used. If the transformed name is extremely long (longer than 255 characters), implementation defined truncation may happen. If the class name consists only of underscores, no transformation is done6. 2. 2. LiteralsPython supports string and bytes literals and various numeric literals literal ::= Evaluation of a literal yields an object of the given type (string, bytes, integer, floating point number, complex number) with the given value. The value may be approximated in the case of floating point and imaginary (complex) literals. See section for details All literals correspond to immutable data types, and hence the object’s identity is less important than its value. Multiple evaluations of literals with the same value (either the same occurrence in the program text or a different occurrence) may obtain the same object or a different object with the same value 6. 2. 3. Parenthesized formsA parenthesized form is an optional expression list enclosed in parentheses parenth_form ::= "(" [ A parenthesized expression list yields whatever that expression list yields. if the list contains at least one comma, it yields a tuple; otherwise, it yields the single expression that makes up the expression list An empty pair of parentheses yields an empty tuple object. Since tuples are immutable, the same rules as for literals apply (i. e. , two occurrences of the empty tuple may or may not yield the same object) Note that tuples are not formed by the parentheses, but rather by use of the comma. The exception is the empty tuple, for which parentheses are required — allowing unparenthesized “nothing” in expressions would cause ambiguities and allow common typos to pass uncaught 6. 2. 4. Displays for lists, sets and dictionariesFor constructing a list, a set or a dictionary Python provides special syntax called “displays”, each of them in two flavors
Common syntax elements for comprehensions are comprehension ::= The comprehension consists of a single expression followed by at least one comprehension ::=0 clause and zero or more comprehension ::=0 or comprehension ::=2 clauses. Dalam hal ini, elemen wadah baru adalah elemen yang akan diproduksi dengan mempertimbangkan masing-masing comprehension ::=0 atau comprehension ::=2 klausa blok, bersarang dari kiri ke kanan, dan mengevaluasi ekspresi untuk menghasilkan elemen setiap kali blok terdalam tercapai Namun, selain dari ekspresi iterable di klausa comprehension ::=0 paling kiri, pemahaman dijalankan dalam lingkup bersarang implisit yang terpisah. This ensures that names assigned to in the target list don’t “leak” into the enclosing scope The iterable expression in the leftmost comprehension ::=0 clause is evaluated directly in the enclosing scope and then passed as an argument to the implicitly nested scope. Klausa comprehension ::=0 berikutnya dan kondisi filter apa pun di klausa comprehension ::=0 paling kiri tidak dapat dievaluasi dalam cakupan terlampir karena mungkin bergantung pada nilai yang diperoleh dari iterable paling kiri. Sebagai contoh. comprehension ::=_9 Untuk memastikan pemahaman selalu menghasilkan penampung dari jenis yang sesuai, ekspresi list_display ::= "[" [0 dan list_display ::= "[" [1 dilarang dalam lingkup tersarang secara implisit Sejak Python 3. 6, dalam suatu fungsi, klausa ________20______3 dapat digunakan untuk mengulang. Pemahaman dalam fungsi list_display ::= "[" [2 dapat terdiri dari klausa comprehension ::=0 atau list_display ::= "[" [3 setelah ekspresi utama, dapat berisi klausa tambahan comprehension ::=0 atau list_display ::= "[" [3, dan juga dapat menggunakan ekspresi. Jika pemahaman mengandung list_display ::= "[" [3 klausa atau list_display ::= "[" [9 ekspresi atau pemahaman asinkron lainnya, itu disebut pemahaman asinkron. Pemahaman asinkron dapat menangguhkan eksekusi fungsi coroutine yang muncul. Lihat juga PEP 530 Baru di versi 3. 6. Asynchronous comprehensions were introduced. Changed in version 3. 8. list_display ::= "[" [0 and list_display ::= "[" [1 prohibited in the implicitly nested scope. Changed in version 3. 11. Asynchronous comprehensions are now allowed inside comprehensions in asynchronous functions. Outer comprehensions implicitly become asynchronous. 6. 2. 5. List displaysA list display is a possibly empty series of expressions enclosed in square brackets list_display ::= "[" [ A list display yields a new list object, the contents being specified by either a list of expressions or a comprehension. When a comma-separated list of expressions is supplied, its elements are evaluated from left to right and placed into the list object in that order. When a comprehension is supplied, the list is constructed from the elements resulting from the comprehension 6. 2. 6. Set displaysA set display is denoted by curly braces and distinguishable from dictionary displays by the lack of colons separating keys and values set_display ::= "{" ( A set display yields a new mutable set object, the contents being specified by either a sequence of expressions or a comprehension. When a comma-separated list of expressions is supplied, its elements are evaluated from left to right and added to the set object. When a comprehension is supplied, the set is constructed from the elements resulting from the comprehension An empty set cannot be constructed with set_display ::= "{" (4; this literal constructs an empty dictionary 6. 2. 7. Dictionary displaysA dictionary display is a possibly empty series of key/datum pairs enclosed in curly braces dict_display ::= "{" [ A dictionary display yields a new dictionary object If a comma-separated sequence of key/datum pairs is given, they are evaluated from left to right to define the entries of the dictionary. each key object is used as a key into the dictionary to store the corresponding datum. This means that you can specify the same key multiple times in the key/datum list, and the final dictionary’s value for that key will be the last one given A double asterisk set_display ::= "{" (5 denotes dictionary unpacking. Its operand must be a . Setiap item pemetaan ditambahkan ke kamus baru. Later values replace values already set by earlier key/datum pairs and earlier dictionary unpackings New in version 3. 5. Unpacking into dictionary displays, originally proposed by PEP 448. A dict comprehension, in contrast to list and set comprehensions, needs two expressions separated with a colon followed by the usual “for” and “if” clauses. When the comprehension is run, the resulting key and value elements are inserted in the new dictionary in the order they are produced Restrictions on the types of the key values are listed earlier in section . (To summarize, the key type should be , which excludes all mutable objects. ) Clashes between duplicate keys are not detected; the last datum (textually rightmost in the display) stored for a given key value prevails Changed in version 3. 8. Prior to Python 3. 8, in dict comprehensions, the evaluation order of key and value was not well-defined. In CPython, the value was evaluated before the key. Starting with 3. 8, the key is evaluated before the value, as proposed by PEP 572. 6. 2. 8. Generator expressionsA generator expression is a compact generator notation in parentheses generator_expression ::= "(" A generator expression yields a new generator object. Its syntax is the same as for comprehensions, except that it is enclosed in parentheses instead of brackets or curly braces Variables used in the generator expression are evaluated lazily when the method is called for the generator object (in the same fashion as normal generators). However, the iterable expression in the leftmost comprehension ::=0 clause is immediately evaluated, so that an error produced by it will be emitted at the point where the generator expression is defined, rather than at the point where the first value is retrieved. Subsequent comprehension ::=0 clauses and any filter condition in the leftmost comprehension ::=0 clause cannot be evaluated in the enclosing scope as they may depend on the values obtained from the leftmost iterable. For example. dict_display ::= "{" [0 The parentheses can be omitted on calls with only one argument. See section for details To avoid interfering with the expected operation of the generator expression itself, list_display ::= "[" [0 and list_display ::= "[" [1 expressions are prohibited in the implicitly defined generator If a generator expression contains either list_display ::= "[" [3 clauses or expressions it is called an asynchronous generator expression. An asynchronous generator expression returns a new asynchronous generator object, which is an asynchronous iterator (see ) New in version 3. 6. Asynchronous generator expressions were introduced. Changed in version 3. 7. Prior to Python 3. 7, asynchronous generator expressions could only appear in coroutines. Starting with 3. 7, any function can use asynchronous generator expressions. Changed in version 3. 8. list_display ::= "[" [0 and list_display ::= "[" [1 prohibited in the implicitly nested scope. 6. 2. 9. Yield expressionsyield_atom ::= "(" The yield expression is used when defining a function or an function and thus can only be used in the body of a function definition. Using a yield expression in a function’s body causes that function to be a generator function, and using it in an function’s body causes that coroutine function to be an asynchronous generator function. For example atom ::=0 Due to their side effects on the containing scope, list_display ::= "[" [0 expressions are not permitted as part of the implicitly defined scopes used to implement comprehensions and generator expressions Changed in version 3. 8. Yield expressions prohibited in the implicitly nested scopes used to implement comprehensions and generator expressions. Generator functions are described below, while asynchronous generator functions are described separately in section When a generator function is called, it returns an iterator known as a generator. That generator then controls the execution of the generator function. Eksekusi dimulai ketika salah satu metode generator dipanggil. Pada saat itu, eksekusi berlanjut ke ekspresi hasil pertama, yang ditangguhkan lagi, mengembalikan nilai ke pemanggil generator, atau generator_expression ::= "("1 jika dihilangkan. By suspended, we mean that all local state is retained, including the current bindings of local variables, the instruction pointer, the internal evaluation stack, and the state of any exception handling. When the execution is resumed by calling one of the generator’s methods, the function can proceed exactly as if the yield expression were just another external call. The value of the yield expression after resuming depends on the method which resumed the execution. Jika digunakan (biasanya melalui a atau builtin) maka hasilnya adalah. Otherwise, if is used, then the result will be the value passed in to that method All of this makes generator functions quite similar to coroutines; they yield multiple times, they have more than one entry point and their execution can be suspended. The only difference is that a generator function cannot control where the execution should continue after it yields; the control is always transferred to the generator’s caller Yield expressions are allowed anywhere in a construct. Jika generator tidak dilanjutkan sebelum diselesaikan (dengan mencapai jumlah referensi nol atau dengan mengumpulkan sampah), metode generator-iterator akan dipanggil, memungkinkan setiap klausa yang tertunda untuk dieksekusi Saat yield_atom ::= "("_1 digunakan, ekspresi yang diberikan harus iterable. Nilai yang dihasilkan oleh iterasi yang iterable diteruskan langsung ke pemanggil metode generator saat ini. Nilai apa pun yang diteruskan dengan dan pengecualian apa pun yang diteruskan dengan diteruskan ke iterator yang mendasarinya jika memiliki metode yang sesuai. Jika tidak demikian, maka akan menaikkan atau , while hanya akan menaikkan pengecualian dengan segera Ketika iterator yang mendasarinya selesai, atribut yield_atom ::= "("_8 dari instance yang dimunculkan menjadi nilai dari ekspresi hasil. Itu dapat diatur secara eksplisit saat menaikkan , atau secara otomatis saat subiterator adalah generator (dengan mengembalikan nilai dari subgenerator)
Tanda kurung dapat dihilangkan ketika ekspresi hasil adalah satu-satunya ekspresi di sisi kanan pernyataan penugasan Lihat juga PEP 255 - Generator SederhanaProposal untuk menambahkan generator dan pernyataan ke Python PEP 342 - Coroutine melalui Generator yang DisempurnakanProposal untuk meningkatkan API dan sintaks generator, menjadikannya dapat digunakan sebagai coroutine sederhana PEP 380 - Sintaks untuk Mendelegasikan ke SubgeneratorProposal untuk memperkenalkan sintaks atom ::=03, membuat pendelegasian ke subgenerator menjadi mudahPEP 525 - Generator Asinkron Proposal yang diperluas pada PEP 492 dengan menambahkan kemampuan generator ke fungsi coroutine 6. 2. 9. 1. Metode generator-iteratorSubbagian ini menjelaskan metode iterator generator. Mereka dapat digunakan untuk mengontrol pelaksanaan fungsi generator Perhatikan bahwa memanggil salah satu metode generator di bawah saat generator sudah dijalankan akan memunculkan pengecualian generator. __selanjutnya__()Memulai eksekusi fungsi generator atau melanjutkannya pada ekspresi hasil yang terakhir dieksekusi. Saat fungsi generator dilanjutkan dengan metode, ekspresi hasil saat ini selalu dievaluasi menjadi. Eksekusi kemudian berlanjut ke ekspresi hasil berikutnya, di mana generator ditangguhkan lagi, dan nilai dikembalikan ke pemanggil. Jika generator keluar tanpa menghasilkan nilai lain, pengecualian akan dimunculkan Metode ini biasanya disebut secara implisit, e. g. dengan satu lingkaran, atau dengan fungsi bawaan generator. kirim(nilai)Melanjutkan eksekusi dan "mengirim" nilai ke fungsi generator. Argumen nilai menjadi hasil dari ekspresi hasil saat ini. Metode mengembalikan nilai berikutnya yang dihasilkan oleh generator, atau memunculkan jika generator keluar tanpa menghasilkan nilai lain. Kapan dipanggil untuk memulai generator, harus dipanggil dengan argumen, karena tidak ada ekspresi hasil yang dapat menerima nilai generator. melempar(nilai)generator. melempar(ketik[ , value[, traceback]])Memunculkan pengecualian pada titik di mana generator dijeda, dan mengembalikan nilai berikutnya yang dihasilkan oleh fungsi generator. Jika generator keluar tanpa menghasilkan nilai lain, pengecualian akan dimunculkan. Jika fungsi generator tidak menangkap pengecualian yang diteruskan, atau memunculkan pengecualian yang berbeda, maka pengecualian tersebut menyebar ke pemanggil Dalam penggunaan biasa, ini disebut dengan contoh pengecualian tunggal yang mirip dengan cara penggunaan kata kunci Namun, untuk kompatibilitas mundur, tanda tangan kedua didukung, mengikuti konvensi dari versi Python yang lebih lama. Argumen tipe harus kelas pengecualian, dan nilai harus menjadi contoh pengecualian. Jika nilainya tidak diberikan, konstruktor tipe dipanggil untuk mendapatkan sebuah instance. Jika traceback disediakan, itu disetel pada pengecualian, jika tidak, atribut atom ::=18 yang ada yang disimpan dalam nilai dapat dihapusgenerator. tutup() Menaikkan a pada titik di mana fungsi generator dijeda. Jika fungsi generator kemudian keluar dengan anggun, sudah ditutup, atau dinaikkan (dengan tidak menangkap pengecualian), tutup kembali ke pemanggilnya. Jika generator menghasilkan nilai, a dinaikkan. Jika generator memunculkan pengecualian lain, itu disebarkan ke pemanggil. tidak melakukan apa-apa jika generator sudah keluar karena pengecualian atau keluar normal 6. 2. 9. 2. ContohBerikut adalah contoh sederhana yang menunjukkan perilaku generator dan fungsi generator atom ::=1 Untuk contoh menggunakan list_display ::= "[" [_1, lihat di “Yang Baru di Python. ” 6. 2. 9. 3. Fungsi generator asinkronKehadiran ekspresi hasil dalam suatu fungsi atau metode yang didefinisikan menggunakan selanjutnya mendefinisikan fungsi sebagai fungsi Saat fungsi generator asinkron dipanggil, ia mengembalikan iterator asinkron yang dikenal sebagai objek generator asinkron. Objek itu kemudian mengontrol eksekusi fungsi generator. Objek generator asinkron biasanya digunakan dalam pernyataan dalam fungsi coroutine secara analog dengan bagaimana objek generator akan digunakan dalam pernyataan Memanggil salah satu metode generator asinkron akan mengembalikan objek, dan eksekusi dimulai saat objek ini ditunggu. Pada saat itu, eksekusi berlanjut ke ekspresi hasil pertama, yang ditangguhkan lagi, mengembalikan nilai ke coroutine yang menunggu. Seperti halnya generator, penangguhan berarti bahwa semua status lokal dipertahankan, termasuk binding variabel lokal saat ini, penunjuk instruksi, tumpukan evaluasi internal, dan status penanganan pengecualian apa pun. Saat eksekusi dilanjutkan dengan menunggu objek berikutnya yang dikembalikan oleh metode generator asinkron, fungsi dapat dilanjutkan persis seolah-olah ekspresi hasil hanyalah panggilan eksternal lainnya. Nilai ekspresi hasil setelah melanjutkan bergantung pada metode yang melanjutkan eksekusi. Jika digunakan maka hasilnya adalah. Jika tidak, jika digunakan, maka hasilnya adalah nilai yang diteruskan ke metode tersebut Jika generator asinkron keluar lebih awal pada , tugas pemanggil dibatalkan, atau pengecualian lainnya, kode pembersihan asinkron generator akan berjalan dan mungkin memunculkan pengecualian atau mengakses variabel konteks dalam konteks yang tidak diharapkan–mungkin setelah tugas seumur hidup tergantung, atau . Untuk mencegah hal ini, pemanggil harus secara eksplisit menutup generator async dengan memanggil metode untuk menyelesaikan generator dan akhirnya melepaskannya dari loop kejadian. Dalam fungsi generator asinkron, ekspresi hasil diizinkan di mana saja dalam konstruksi. Namun, jika generator asinkron tidak dilanjutkan sebelum diselesaikan (dengan mencapai jumlah referensi nol atau dengan mengumpulkan sampah), maka ekspresi hasil dalam konstruksi generator_expression ::= "("8 dapat mengakibatkan kegagalan untuk mengeksekusi klausa yang tertunda. Dalam hal ini, perulangan peristiwa atau penjadwal yang menjalankan generator asinkron bertanggung jawab untuk memanggil metode iterator-generator asinkron dan menjalankan objek coroutine yang dihasilkan, sehingga mengizinkan klausa yield_atom ::= "("0 yang tertunda untuk dieksekusi Untuk menangani finalisasi setelah penghentian loop peristiwa, loop peristiwa harus menentukan fungsi finalizer yang menggunakan generator-iterator asinkron dan mungkin memanggil serta mengeksekusi coroutine. Finalizer ini dapat didaftarkan dengan menelepon. Saat pertama kali diulang, generator-iterator asinkron akan menyimpan finalizer terdaftar untuk dipanggil setelah finalisasi. Untuk contoh referensi metode finalizer, lihat implementasi atom ::=40 di Lib/asyncio/base_events. py Ekspresi yield_atom ::= "("_1 adalah kesalahan sintaks saat digunakan dalam fungsi generator asinkron 6. 2. 9. 4. Metode generator-iterator asinkronSubbagian ini menjelaskan metode iterator generator asinkron, yang digunakan untuk mengontrol eksekusi fungsi generator coroutine agen. __berikut__()Mengembalikan sebuah menunggu yang ketika dijalankan mulai mengeksekusi generator asinkron atau melanjutkannya pada ekspresi hasil yang terakhir dieksekusi. Ketika fungsi generator asinkron dilanjutkan dengan suatu metode, ekspresi hasil saat ini selalu mengevaluasi ke dalam pengembalian yang dapat ditunggu, yang ketika dijalankan akan berlanjut ke ekspresi hasil berikutnya. Nilai ekspresi hasil adalah nilai pengecualian yang diangkat oleh coroutine pelengkap. Jika generator asinkron keluar tanpa menghasilkan nilai lain, yang ditunggu malah memunculkan pengecualian, menandakan bahwa iterasi asinkron telah selesai Metode ini biasanya disebut secara implisit oleh sebuah loop coroutine agen. asend(nilai)Mengembalikan sebuah menunggu yang ketika dijalankan melanjutkan eksekusi generator asinkron. Seperti metode untuk generator, ini "mengirimkan" nilai ke fungsi generator asinkron, dan argumen nilai menjadi hasil dari ekspresi hasil saat ini. Awaitable yang dikembalikan oleh metode akan mengembalikan nilai berikutnya yang dihasilkan oleh generator sebagai nilai dari Raised , atau Raise jika generator asinkron keluar tanpa menghasilkan nilai lain. Kapan dipanggil untuk memulai generator asinkron, itu harus dipanggil dengan argumen, karena tidak ada ekspresi hasil yang dapat menerima nilai coroutine agen. lempar(ketik[ , value[, traceback]])Mengembalikan sebuah menunggu yang memunculkan pengecualian tipe atom ::=54 pada titik di mana generator asinkron dijeda, dan mengembalikan nilai berikutnya yang dihasilkan oleh fungsi generator sebagai nilai pengecualian yang dimunculkan. Jika generator asinkron keluar tanpa menghasilkan nilai lain, pengecualian akan dimunculkan oleh yang ditunggu. Jika fungsi generator tidak menangkap pengecualian yang diteruskan, atau memunculkan pengecualian yang berbeda, maka saat menunggu dijalankan, pengecualian tersebut menyebar ke pemanggil dari yang ditunggu.coroutine agen. dekat() Mengembalikan sebuah awaitable yang ketika dijalankan akan melemparkan a ke fungsi generator asinkron pada titik di mana ia dijeda. Jika fungsi generator asinkron keluar dengan anggun, sudah ditutup, atau dimunculkan (dengan tidak menangkap pengecualian), maka awaitable yang dikembalikan akan memunculkan pengecualian. Setiap menunggu lebih lanjut yang dikembalikan oleh panggilan berikutnya ke generator asinkron akan menimbulkan pengecualian. Jika generator asinkron menghasilkan nilai, a dimunculkan oleh yang ditunggu. Jika generator asinkron memunculkan pengecualian lain, itu disebarkan ke pemanggil yang dapat ditunggu. Jika generator asinkron telah keluar karena pengecualian atau keluar normal, maka panggilan lebih lanjut ke akan mengembalikan awaitable yang tidak melakukan apa-apa 6. 3. PrimerPendahuluan mewakili operasi bahasa yang paling terikat erat. Sintaks mereka adalah atom ::=2 6. 3. 1. Referensi atributReferensi atribut adalah yang utama diikuti dengan periode dan nama atom ::=_3 Primer harus mengevaluasi objek dari tipe yang mendukung referensi atribut, yang dilakukan sebagian besar objek. Objek ini kemudian diminta untuk menghasilkan atribut yang namanya adalah identifier. Produksi ini dapat disesuaikan dengan mengganti metode atom ::=63. Jika atribut ini tidak tersedia, pengecualian akan dimunculkan. Sebaliknya, jenis dan nilai objek yang dihasilkan ditentukan oleh objek tersebut. Beberapa evaluasi referensi atribut yang sama dapat menghasilkan objek yang berbeda 6. 3. 2. LanggananBerlangganan instance dari a umumnya akan memilih elemen dari wadah. Berlangganan a umumnya akan mengembalikan objek atom ::=_4 Saat objek disubskrip, interpreter akan mengevaluasi daftar utama dan ekspresi Primer harus mengevaluasi objek yang mendukung langganan. Sebuah objek dapat mendukung langganan melalui pendefinisian satu atau kedua dari dan. Saat primer disubskrip, hasil evaluasi dari daftar ekspresi akan diteruskan ke salah satu metode ini. Untuk detail lebih lanjut tentang kapan atom ::=_67 dipanggil alih-alih atom ::=68, lihat Jika daftar ekspresi berisi setidaknya satu koma, itu akan dievaluasi menjadi berisi item dari daftar ekspresi. Jika tidak, daftar ekspresi akan mengevaluasi nilai dari satu-satunya anggota daftar Untuk objek bawaan, ada dua jenis objek yang mendukung langganan via
Sintaks formal tidak membuat ketentuan khusus untuk indeks negatif di. Namun, semua urutan bawaan menyediakan metode yang menginterpretasikan indeks negatif dengan menambahkan panjang urutan ke indeks sehingga, misalnya, atom ::=78 memilih item terakhir dari atom ::=79. Nilai yang dihasilkan harus berupa bilangan bulat bukan negatif yang lebih kecil dari jumlah item dalam urutan, dan langganan memilih item yang indeksnya adalah nilai tersebut (dihitung dari nol). Karena dukungan untuk indeks negatif dan pemotongan terjadi pada metode atom ::=65 objek, subkelas yang menggantikan metode ini perlu secara eksplisit menambahkan dukungan itu A adalah jenis urutan khusus yang itemnya adalah karakter. Karakter bukanlah tipe data yang terpisah tetapi string yang terdiri dari tepat satu karakter 6. 3. 3. IrisanPemotongan memilih rentang item dalam objek urutan (mis. g. , string, tupel atau daftar). Irisan dapat digunakan sebagai ekspresi atau sebagai target dalam penugasan atau pernyataan. Sintaks untuk mengiris atom ::=5 Ada ambiguitas dalam sintaks formal di sini. apa pun yang terlihat seperti daftar ekspresi juga terlihat seperti daftar irisan, jadi langganan apa pun dapat diartikan sebagai irisan. Daripada memperumit sintaks lebih lanjut, ini disamarkan dengan mendefinisikan bahwa dalam hal ini interpretasi sebagai langganan diprioritaskan daripada interpretasi sebagai pengiris (ini adalah kasus jika daftar irisan tidak berisi irisan yang tepat) Semantik untuk slicing adalah sebagai berikut. Primer diindeks (menggunakan metode atom ::=65 yang sama seperti langganan normal) dengan kunci yang dibuat dari daftar irisan, sebagai berikut. Jika daftar irisan berisi setidaknya satu koma, kuncinya adalah tupel yang berisi konversi item irisan; . Konversi item irisan yang merupakan ekspresi adalah ekspresi itu. Konversi irisan yang tepat adalah objek irisan (lihat bagian ) yang atribut atom ::=84, atom ::=85 dan atom ::=86 masing-masing adalah nilai ekspresi yang diberikan sebagai batas bawah, batas atas, dan langkah, menggantikan generator_expression ::= "("1 untuk ekspresi yang hilang 6. 3. 4. PanggilanPanggilan memanggil objek yang dapat dipanggil (mis. g. , a ) dengan rangkaian kemungkinan kosong atom ::=6 Koma tambahan opsional mungkin ada setelah argumen posisi dan kata kunci tetapi tidak mempengaruhi semantik Primer harus mengevaluasi ke objek yang dapat dipanggil (fungsi yang ditentukan pengguna, fungsi bawaan, metode objek bawaan, objek kelas, metode instance kelas, dan semua objek yang memiliki metode atom ::=88 dapat dipanggil). Semua ekspresi argumen dievaluasi sebelum pemanggilan dilakukan. Silakan merujuk ke bagian untuk sintaks daftar formal Jika ada argumen kata kunci, pertama kali dikonversi menjadi argumen posisi, sebagai berikut. Pertama, daftar slot yang tidak terisi dibuat untuk parameter formal. Jika ada N argumen posisional, mereka ditempatkan di slot N pertama. Selanjutnya, untuk setiap argumen kata kunci, pengidentifikasi digunakan untuk menentukan slot yang sesuai (jika pengidentifikasi sama dengan nama parameter formal pertama, slot pertama digunakan, dan seterusnya). Jika slot sudah terisi, pengecualian akan dimunculkan. Jika tidak, argumen ditempatkan di slot, mengisinya (bahkan jika ekspresinya adalah generator_expression ::= "("1, mengisi slot). Saat semua argumen telah diproses, slot yang masih belum terisi diisi dengan nilai default yang sesuai dari definisi fungsi. (Nilai default dihitung, sekali, saat fungsi ditentukan; dengan demikian, objek yang dapat diubah seperti daftar atau kamus yang digunakan sebagai nilai default akan digunakan bersama oleh semua panggilan yang tidak menentukan nilai argumen untuk slot yang sesuai; ini seharusnya . ) Jika ada slot yang tidak terisi yang tidak ditentukan nilai defaultnya, pengecualian akan dimunculkan. Jika tidak, daftar slot yang terisi akan digunakan sebagai daftar argumen untuk panggilan tersebut Detail implementasi CPython. Implementasi dapat menyediakan fungsi bawaan yang parameter posisinya tidak memiliki nama, bahkan jika mereka 'bernama' untuk tujuan dokumentasi, dan karenanya tidak dapat disediakan oleh kata kunci. Di CPython, ini adalah kasus untuk fungsi yang diimplementasikan di C yang digunakan untuk mengurai argumennya Jika ada lebih banyak argumen posisi daripada slot parameter formal, pengecualian akan dimunculkan, kecuali ada parameter formal yang menggunakan sintaks atom ::=94; Jika ada argumen kata kunci yang tidak sesuai dengan nama parameter formal, pengecualian akan dimunculkan, kecuali ada parameter formal yang menggunakan sintaks atom ::=96; Jika sintaks atom ::=_97 muncul di pemanggilan fungsi, atom ::=98 harus dievaluasi menjadi. Elemen dari iterables ini diperlakukan seolah-olah merupakan argumen posisi tambahan. Untuk pemanggilan atom ::=_99, jika y mengevaluasi urutan y1, …, yM, ini setara dengan pemanggilan dengan argumen posisional M+4 x1, x2, y1, …, yM, x3, x4 Konsekuensi dari ini adalah bahwa meskipun sintaks atom ::=_97 mungkin muncul setelah argumen kata kunci eksplisit, itu diproses sebelum argumen kata kunci (dan argumen literal ::=01 apa pun – lihat di bawah). Jadi atom ::=_7 Argumen kata kunci dan sintaks atom ::=97 tidak biasa digunakan dalam panggilan yang sama, jadi dalam praktiknya kebingungan ini tidak sering muncul Jika sintaks literal ::=01 muncul di pemanggilan fungsi, atom ::=98 harus dievaluasi menjadi a , yang isinya diperlakukan sebagai argumen kata kunci tambahan. Jika parameter yang cocok dengan kunci telah diberi nilai (oleh argumen kata kunci eksplisit, atau dari pembongkaran lainnya), pengecualian akan dimunculkan Saat literal ::=_01 digunakan, setiap kunci dalam pemetaan ini harus berupa string. Setiap nilai dari pemetaan ditetapkan ke parameter formal pertama yang memenuhi syarat untuk penetapan kata kunci yang namanya sama dengan kunci. Kunci tidak harus berupa pengidentifikasi Python (mis. g. literal ::=07 dapat diterima, meskipun tidak akan cocok dengan parameter formal apa pun yang dapat dideklarasikan). Jika tidak ada kecocokan dengan parameter formal, pasangan nilai kunci dikumpulkan oleh parameter set_display ::= "{" (5, jika ada, atau jika tidak ada, pengecualian akan dimunculkan Parameter formal yang menggunakan sintaks atom ::=94 atau atom ::=96 tidak dapat digunakan sebagai slot argumen posisional atau sebagai nama argumen kata kunci Berubah di versi 3. 5. Panggilan fungsi menerima sejumlah literal ::=12 dan set_display ::= "{" (5 unpacking, argumen posisi dapat mengikuti unpacking berulang ( literal ::=12), dan argumen kata kunci dapat mengikuti unpacking kamus ( set_display ::= "{" (5). Awalnya diusulkan oleh PEP 448. Panggilan selalu mengembalikan beberapa nilai, mungkin generator_expression ::= "("1, kecuali jika memunculkan pengecualian. Bagaimana nilai ini dihitung bergantung pada jenis objek yang dapat dipanggil Jika memang- fungsi yang ditentukan penggunaBlok kode untuk fungsi dijalankan, meneruskannya ke daftar argumen. Hal pertama yang akan dilakukan blok kode adalah mengikat parameter formal ke argumen; . Ketika blok kode mengeksekusi pernyataan, ini menentukan nilai kembalian dari pemanggilan fungsi fungsi atau metode bawaanHasilnya terserah penerjemah; objek kelasContoh baru dari kelas itu dikembalikan metode instance kelasFungsi yang ditentukan pengguna yang sesuai dipanggil, dengan daftar argumen yang lebih panjang dari daftar argumen panggilan. instance menjadi argumen pertama contoh kelasKelas harus mendefinisikan metode atom ::=_88; 6. 4. Menunggu ekspresiTangguhkan eksekusi pada objek. Hanya dapat digunakan di dalam a atom ::=8 Baru di versi 3. 5 6. 5. Operator listrikOperator daya mengikat lebih erat daripada operator unary di sebelah kirinya; . Sintaksnya adalah atom ::=_9 Jadi, dalam urutan operator unary dan power yang tidak dikurung, operator dievaluasi dari kanan ke kiri (ini tidak membatasi urutan evaluasi untuk operan). literal ::=19 menghasilkan literal ::=20 Operator daya memiliki semantik yang sama dengan fungsi bawaan, saat dipanggil dengan dua argumen. itu menghasilkan argumen kirinya yang dinaikkan ke kekuatan argumen kanannya. Argumen numerik pertama-tama dikonversi ke tipe umum, dan hasilnya adalah tipe itu Untuk operan int, hasilnya memiliki tipe yang sama dengan operan kecuali argumen kedua negatif; . Misalnya, literal ::=_22 mengembalikan literal ::=23, tetapi literal ::=24 mengembalikan literal ::=25 Meningkatkan literal ::=_26 menjadi pangkat negatif menghasilkan a. Menaikkan bilangan negatif menjadi pangkat pecahan menghasilkan bilangan. (Dalam versi sebelumnya itu mengangkat a. ) Operasi ini dapat disesuaikan menggunakan metode literal ::=30 khusus 6. 6. Operasi aritmatika dan bitwise unarySemua operasi aritmatika dan bitwise unary memiliki prioritas yang sama literal ::=0 Operator unary literal ::=31 (minus) menghasilkan negasi dari argumen numeriknya; Operator unary literal ::=33 (plus) menghasilkan argumen numeriknya tidak berubah; Operator unary literal ::=35 (invert) menghasilkan inversi bitwise dari argumen integernya. Inversi bitwise dari atom ::=_79 didefinisikan sebagai literal ::=37. Ini hanya berlaku untuk bilangan integral atau objek khusus yang menggantikan metode khusus literal ::=38 Dalam ketiga kasus tersebut, jika argumen tidak memiliki tipe yang tepat, pengecualian akan dimunculkan 6. 7. Operasi aritmatika binerOperasi aritmatika biner memiliki tingkat prioritas konvensional. Perhatikan bahwa beberapa operasi ini juga berlaku untuk jenis non-numerik tertentu. Selain operator listrik, hanya ada dua level, satu untuk operator multiplikatif dan satu lagi untuk operator aditif literal ::=1 Operator literal ::=_12 (perkalian) menghasilkan produk dari argumennya. Argumen harus berupa angka, atau salah satu argumen harus berupa bilangan bulat dan argumen lainnya harus berupa urutan. Dalam kasus sebelumnya, angka diubah menjadi tipe umum dan kemudian dikalikan bersama. Dalam kasus terakhir, pengulangan urutan dilakukan; Operasi ini dapat disesuaikan menggunakan metode khusus literal ::=41 dan literal ::=42 Operator literal ::=_43 (at) dimaksudkan untuk digunakan untuk perkalian matriks. Tidak ada tipe Python bawaan yang mengimplementasikan operator ini Baru di versi 3. 5 Operator literal ::=_44 (divisi) dan literal ::=45 (floor division) menghasilkan hasil bagi dari argumen mereka. Argumen numerik pertama-tama dikonversi ke tipe umum. Pembagian bilangan bulat menghasilkan pelampung, sedangkan pembagian dasar bilangan bulat menghasilkan bilangan bulat; . Pembagian dengan nol menimbulkan pengecualian Operasi ini dapat disesuaikan menggunakan metode khusus literal ::=47 dan literal ::=48 Operator literal ::=_49 (modulo) menghasilkan sisa dari pembagian argumen pertama dengan argumen kedua. Argumen numerik pertama-tama dikonversi ke tipe umum. Argumen nol kanan memunculkan pengecualian. Argumennya mungkin berupa angka floating point, mis. g. , literal ::=_51 sama dengan literal ::=52 (karena literal ::=53 sama dengan literal ::=54. ) Operator modulo selalu menghasilkan hasil dengan tanda yang sama dengan operan keduanya (atau nol); Pembagian lantai dan operator modulo dihubungkan dengan identitas berikut. literal ::=55. Pembagian lantai dan modulo juga terhubung dengan fungsi bawaan. literal ::=_57. Selain melakukan operasi modulo pada angka, operator literal ::=49 juga dibebani oleh objek string untuk melakukan pemformatan string gaya lama (juga dikenal sebagai interpolasi). Sintaks untuk pemformatan string dijelaskan dalam Referensi Perpustakaan Python, bagian Operasi modulo dapat dikustomisasi menggunakan metode literal ::=59 khusus Operator pembagian lantai, operator modulo, dan fungsinya tidak ditentukan untuk bilangan kompleks. Alih-alih, konversikan ke angka floating point menggunakan fungsi jika sesuai Operator literal ::=_33 (tambahan) menghasilkan jumlah argumennya. Argumen harus berupa angka atau keduanya berupa urutan dari tipe yang sama. Dalam kasus sebelumnya, angka diubah menjadi tipe umum dan kemudian dijumlahkan. Dalam kasus terakhir, urutan digabungkan Operasi ini dapat disesuaikan menggunakan metode khusus literal ::=63 dan literal ::=64 Operator literal ::=_31 (pengurangan) menghasilkan selisih argumennya. Argumen numerik pertama-tama dikonversi ke tipe umum Operasi ini dapat dikustomisasi menggunakan metode literal ::=66 khusus 6. 8. Pengalihan operasiOperasi pergeseran memiliki prioritas lebih rendah daripada operasi aritmatika literal ::=2 Operator ini menerima bilangan bulat sebagai argumen. Mereka menggeser argumen pertama ke kiri atau kanan dengan jumlah bit yang diberikan oleh argumen kedua Operasi ini dapat disesuaikan menggunakan metode khusus literal ::=67 dan literal ::=68 Pergeseran ke kanan sebanyak n bit didefinisikan sebagai pembagian lantai oleh literal ::=69. Pergeseran ke kiri sebanyak n bit didefinisikan sebagai perkalian dengan literal ::=69 6. 9. Operasi bitwise binerMasing-masing dari tiga operasi bitwise memiliki tingkat prioritas yang berbeda literal ::=3 Operator literal ::=_71 menghasilkan bitwise AND dari argumennya, yang harus berupa bilangan bulat atau salah satunya harus berupa objek khusus yang mengesampingkan literal ::=72 atau literal ::=73 metode khusus Operator literal ::=_74 menghasilkan XOR bitwise (OR eksklusif) dari argumennya, yang harus berupa bilangan bulat atau salah satunya harus berupa objek khusus yang mengesampingkan literal ::=75 atau literal ::=76 metode khusus Operator literal ::=_77 menghasilkan bitwise (inklusif) OR dari argumennya, yang harus berupa bilangan bulat atau salah satunya harus berupa objek khusus yang menggantikan literal ::=78 atau literal ::=79 metode khusus 6. 10. PerbandinganTidak seperti C, semua operasi perbandingan di Python memiliki prioritas yang sama, yang lebih rendah daripada operasi aritmatika, pergeseran, atau bitwise. Juga tidak seperti C, ekspresi seperti literal ::=_80 memiliki interpretasi yang konvensional dalam matematika literal ::=4 Perbandingan menghasilkan nilai boolean. literal ::=81 atau literal ::=82. Metode perbandingan kaya khusus dapat mengembalikan nilai non-boolean. Dalam hal ini Python akan memanggil nilai tersebut dalam konteks boolean Perbandingan dapat dirantai secara sewenang-wenang, mis. g. , literal ::=_84 setara dengan literal ::=85, kecuali bahwa literal ::=86 dievaluasi hanya sekali (tetapi dalam kedua kasus literal ::=87 tidak dievaluasi sama sekali ketika literal ::=88 ditemukan salah) Secara formal, jika a, b, c, …, y, z adalah ekspresi dan op1, op2, …, opN adalah operator perbandingan, maka literal ::=89 setara dengan literal ::=90, kecuali bahwa setiap ekspresi dievaluasi paling banyak satu kali Note that literal ::=91 doesn’t imply any kind of comparison between a and c, so that, e. g. , literal ::=92 is perfectly legal (though perhaps not pretty) 6. 10. 1. Value comparisonsThe operators literal ::=93, literal ::=94, literal ::=95, literal ::=96, literal ::=97, and literal ::=98 compare the values of two objects. The objects do not need to have the same type Chapter states that objects have a value (in addition to type and identity). The value of an object is a rather abstract notion in Python. For example, there is no canonical access method for an object’s value. Also, there is no requirement that the value of an object should be constructed in a particular way, e. g. comprised of all its data attributes. Comparison operators implement a particular notion of what the value of an object is. One can think of them as defining the value of an object indirectly, by means of their comparison implementation Because all types are (direct or indirect) subtypes of , they inherit the default comparison behavior from . Types can customize their comparison behavior by implementing rich comparison methods like parenth_form ::= "(" [ 01, described in The default behavior for equality comparison ( literal ::=95 and literal ::=98) is based on the identity of the objects. Hence, equality comparison of instances with the same identity results in equality, and equality comparison of instances with different identities results in inequality. A motivation for this default behavior is the desire that all objects should be reflexive (i. e. parenth_form ::= "(" [ 04 implies parenth_form ::= "(" [ 05)A default order comparison ( literal ::=93, literal ::=94, literal ::=97, and literal ::=96) is not provided; an attempt raises . A motivation for this default behavior is the lack of a similar invariant as for equality The behavior of the default equality comparison, that instances with different identities are always unequal, may be in contrast to what types will need that have a sensible definition of object value and value-based equality. Such types will need to customize their comparison behavior, and in fact, a number of built-in types have done that The following list describes the comparison behavior of the most important built-in types
User-defined classes that customize their comparison behavior should follow some consistency rules, if possible
Python does not enforce these consistency rules. In fact, the not-a-number values are an example for not following these rules 6. 10. 2. Membership test operationsThe operators and test for membership. parenth_form ::= "(" [ 74 evaluates to literal ::=81 if x is a member of s, and literal ::=82 otherwise. parenth_form ::= "(" [ 77 returns the negation of parenth_form ::= "(" [ 74. All built-in sequences and set types support this as well as dictionary, for which parenth_form ::= "(" [ 72 tests whether the dictionary has a given key. For container types such as list, tuple, set, frozenset, dict, or collections. deque, the expression parenth_form ::= "(" [ 80 is equivalent to parenth_form ::= "(" [ 81For the string and bytes types, parenth_form ::= "(" [ 80 is literal ::=81 if and only if x is a substring of y. An equivalent test is parenth_form ::= "(" [ 84. Empty strings are always considered to be a substring of any other string, so parenth_form ::= "(" [ 85 will return literal ::=81 For user-defined classes which define the parenth_form ::= "(" [ 87 method, parenth_form ::= "(" [ 80 returns literal ::=81 if parenth_form ::= "(" [ 90 returns a true value, and literal ::=82 otherwise For user-defined classes which do not define parenth_form ::= "(" [ 87 but do define parenth_form ::= "(" [ 93, parenth_form ::= "(" [ 80 is literal ::=81 if some value literal ::=87, for which the expression parenth_form ::= "(" [ 97 is true, is produced while iterating over literal ::=86. If an exception is raised during the iteration, it is as if raised that exception Lastly, the old-style iteration protocol is tried. if a class defines atom ::=65, parenth_form ::= "(" [ 80 is literal ::=81 if and only if there is a non-negative integer index i such that comprehension ::=03, and no lower integer index raises the exception. (If any other exception is raised, it is as if raised that exception) The operator is defined to have the inverse truth value of 6. 10. 3. Perbandingan identitasOperator dan uji identitas objek. parenth_form ::= "(" [ 04 is true if and only if x and y are the same object. An Object’s identity is determined using the function. comprehension ::=12 yields the inverse truth value. 6. 11. Boolean operationsliteral ::=5 Dalam konteks operasi Boolean, dan juga ketika ekspresi digunakan oleh pernyataan alur kontrol, nilai berikut ini diinterpretasikan sebagai salah. literal ::=82, generator_expression ::= "("1, numerik nol dari semua jenis, dan string kosong dan container (termasuk string, tupel, daftar, kamus, set dan frozenset). Semua nilai lain ditafsirkan sebagai benar. Objek yang ditentukan pengguna dapat menyesuaikan nilai kebenarannya dengan menyediakan metode comprehension ::=15 Operator menghasilkan literal ::=_81 jika argumennya salah, literal ::=82 sebaliknya Ekspresi comprehension ::=_19 pertama mengevaluasi x; Ekspresi comprehension ::=_20 pertama mengevaluasi x; Note that neither nor restrict the value and type they return to literal ::=82 and literal ::=81, but rather return the last evaluated argument. This is sometimes useful, e. g. , if comprehension ::=25 is a string that should be replaced by a default value if it is empty, the expression comprehension ::=26 yields the desired value. Because has to create a new value, it returns a boolean value regardless of the type of its argument (for example, comprehension ::=28 produces literal ::=82 rather than comprehension ::=30. ) 6. 12. Assignment expressionsliteral ::=6 An assignment expression (sometimes also called a “named expression” or “walrus”) assigns an to an , while also returning the value of the One common use case is when handling matched regular expressions literal ::=7 Or, when processing a file stream in chunks literal ::=8 Assignment expressions must be surrounded by parentheses when used as sub-expressions in slicing, conditional, lambda, keyword-argument, and comprehension-if expressions and in comprehension ::=34 and comprehension ::=35 statements. In all other places where they can be used, parentheses are not required, including in comprehension ::=2 and comprehension ::=37 statements New in version 3. 8. See PEP 572 for more details about assignment expressions. 6. 13. Conditional expressionsliteral ::=9 Conditional expressions (sometimes called a “ternary operator”) have the lowest priority of all Python operations The expression comprehension ::=38 first evaluates the condition, C rather than x. If C is true, x is evaluated and its value is returned; otherwise, y is evaluated and its value is returned See PEP 308 for more details about conditional expressions 6. 14. Lambdasparenth_form ::= "(" [ 0Lambda expressions (sometimes called lambda forms) are used to create anonymous functions. The expression comprehension ::=39 yields a function object. The unnamed object behaves like a function object defined with parenth_form ::= "(" [ 1See section for the syntax of parameter lists. Note that functions created with lambda expressions cannot contain statements or annotations 6. 15. Expression listsparenth_form ::= "(" [ 2Except when part of a list or set display, an expression list containing at least one comma yields a tuple. The length of the tuple is the number of expressions in the list. The expressions are evaluated from left to right An asterisk literal ::=12 denotes iterable unpacking. Its operand must be an . The iterable is expanded into a sequence of items, which are included in the new tuple, list, or set, at the site of the unpacking New in version 3. 5. Iterable unpacking in expression lists, originally proposed by PEP 448. The trailing comma is required only to create a single tuple (a. k. a. a singleton); it is optional in all other cases. A single expression without a trailing comma doesn’t create a tuple, but rather yields the value of that expression. (To create an empty tuple, use an empty pair of parentheses. comprehension ::=41. ) 6. 16. Evaluation orderPython evaluates expressions from left to right. Notice that while evaluating an assignment, the right-hand side is evaluated before the left-hand side In the following lines, expressions will be evaluated in the arithmetic order of their suffixes parenth_form ::= "(" [ 36. 17. Operator precedenceThe following table summarizes the operator precedence in Python, from highest precedence (most binding) to lowest precedence (least binding). Operators in the same box have the same precedence. Unless the syntax is explicitly given, operators are binary. Operators in the same box group left to right (except for exponentiation and conditional expressions, which group from right to left) Note that comparisons, membership tests, and identity tests, all have the same precedence and have a left-to-right chaining feature as described in the section Operator Description comprehension ::=42, comprehension ::=43, comprehension ::=44, comprehension ::=45 Binding or parenthesized expression, list display, dictionary display, set display comprehension ::=46, comprehension ::=47, comprehension ::=48, comprehension ::=49 Subscription, slicing, call, attribute reference Await expression set_display ::= "{" (5 Exponentiation comprehension ::=52, comprehension ::=53, comprehension ::=54 Positive, negative, bitwise NOT literal ::=12, literal ::=43, literal ::=44, literal ::=45, literal ::=49 Multiplication, matrix multiplication, division, floor division, remainder literal ::=33, literal ::=31 Addition and subtraction comprehension ::=62, comprehension ::=63 Shifts literal ::=71 Bitwise AND literal ::=74 Bitwise XOR literal ::=77 Bitwise OR , , , , literal ::=93, literal ::=97, literal ::=94, literal ::=96, literal ::=98, literal ::=95 Comparisons, including membership tests and identity tests Boolean NOT Boolean AND Boolean OR – comprehension ::=81 Conditional expression Lambda expression comprehension ::=83 Assignment expression Footnotes While comprehension ::=84 is true mathematically, for floats it may not be true numerically due to roundoff. For example, and assuming a platform on which a Python float is an IEEE 754 double-precision number, in order that comprehension ::=85 have the same sign as comprehension ::=86, the computed result is comprehension ::=87, which is numerically exactly equal to comprehension ::=86. The function returns a result whose sign matches the sign of the first argument instead, and so returns comprehension ::=90 in this case. Which approach is more appropriate depends on the application If x is very close to an exact integer multiple of y, it’s possible for comprehension ::=91 to be one larger than comprehension ::=92 due to rounding. In such cases, Python returns the latter result, in order to preserve that comprehension ::=93 be very close to atom ::=79 The Unicode standard distinguishes between code points (e. g. U+0041) and abstract characters (e. g. “LATIN CAPITAL LETTER A”). While most abstract characters in Unicode are only represented using one code point, there is a number of abstract characters that can in addition be represented using a sequence of more than one code point. For example, the abstract character “LATIN CAPITAL LETTER C WITH CEDILLA” can be represented as a single precomposed character at code position U+00C7, or as a sequence of a base character at code position U+0043 (LATIN CAPITAL LETTER C), followed by a combining character at code position U+0327 (COMBINING CEDILLA) The comparison operators on strings compare at the level of Unicode code points. This may be counter-intuitive to humans. For example, comprehension ::=95 is literal ::=82, even though both strings represent the same abstract character “LATIN CAPITAL LETTER C WITH CEDILLA” To compare strings at the level of abstract characters (that is, in a way intuitive to humans), use Karena pengumpulan sampah otomatis, daftar gratis, dan sifat dinamis deskriptor, Anda mungkin melihat perilaku yang tampaknya tidak biasa dalam penggunaan operator tertentu, seperti yang melibatkan perbandingan antara metode instan, atau konstanta. Check their documentation for more info The power operator set_display ::= "{" (5 binds less tightly than an arithmetic or bitwise unary operator on its right, that is, list_display ::= "[" [00 is list_display ::= "[" [01 Can you divide dictionaries in Python?Method #2 . Using Counter() + “//” operator
The combination of above method can be used to perform this particular task. In this, the Counter function converts the dictionary in the form in which the divide operator can perform the task of division.
How do you divide a value in a dictionary?To divide each value in a dictionary by a total value. . Use a dict comprehension to iterate over the dictionary's items On each iteration, divide the current value by the total The new dictionary will contain the division results How do you separate a dictionary in Python?How do you split a dictionary in Python? . Method 1. Split dictionary keys and values using inbuilt functions Method 2. Split dictionary keys and values using zip() Method 3. Split dictionary keys and values using items() Can you slice dictionaries?In Python, a dictionary is a collection of key-value pairs. Dictionaries are unordered, which means that the items in a dictionary do not have a specific order or index. As a result, it is not possible to slice a dictionary in the same way that you can slice a list or a string. |