kode python

Dapatkah Anda membagi kamus python?

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

name ::= othername

and no semantics are given, the semantics of this form of parenth_form ::= "(" [starred_expression] ")" 4 are the same as for parenth_form ::= "(" [starred_expression] ")" 5

6. 1. Arithmetic conversions

When 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

If either argument is a complex number, the other is converted to complex;
otherwise, if either argument is a floating point number, the other is converted to floating point;
otherwise, both must be integers and no conversion is necessary

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. Atoms

Atoms 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

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 ::= "(" [starred_expression] ")" 7 occurring in a class named parenth_form ::= "(" [starred_expression] ")" 8 will be transformed to parenth_form ::= "(" [starred_expression] ")" 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 done

6. 2. 2. Literals

Python supports string and bytes literals and various numeric literals

literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber

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 forms

A parenthesized form is an optional expression list enclosed in parentheses

parenth_form ::= "(" [starred_expression] ")"

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 dictionaries

For constructing a list, a set or a dictionary Python provides special syntax called “displays”, each of them in two flavors

either the container contents are listed explicitly, or
they are computed via a set of looping and filtering instructions, called a comprehension

Common syntax elements for comprehensions are

The comprehension consists of a single expression followed by at least one comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 0 clause and zero or more comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 0 or comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 2 clauses. Dalam hal ini, elemen wadah baru adalah elemen yang akan diproduksi dengan mempertimbangkan masing-masing comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 0 atau comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 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 ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 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 ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 0 clause is evaluated directly in the enclosing scope and then passed as an argument to the implicitly nested scope. Klausa comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 0 berikutnya dan kondisi filter apa pun di klausa comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 0 paling kiri tidak dapat dievaluasi dalam cakupan terlampir karena mungkin bergantung pada nilai yang diperoleh dari iterable paling kiri. Sebagai contoh. comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] _9

Untuk memastikan pemahaman selalu menghasilkan penampung dari jenis yang sesuai, ekspresi list_display ::= "[" [starred_list | comprehension] "]" 0 dan list_display ::= "[" [starred_list | comprehension] "]" 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 ::= "[" [starred_list | comprehension] "]" 2 dapat terdiri dari klausa comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 0 atau list_display ::= "[" [starred_list | comprehension] "]" 3 setelah ekspresi utama, dapat berisi klausa tambahan comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 0 atau list_display ::= "[" [starred_list | comprehension] "]" 3, dan juga dapat menggunakan ekspresi. Jika pemahaman mengandung list_display ::= "[" [starred_list | comprehension] "]" 3 klausa atau list_display ::= "[" [starred_list | comprehension] "]" 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 ::= "[" [starred_list | comprehension] "]" 0 and list_display ::= "[" [starred_list | comprehension] "]" 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 displays

A list display is a possibly empty series of expressions enclosed in square brackets

list_display ::= "[" [starred_list | comprehension] "]"

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 displays

A set display is denoted by curly braces and distinguishable from dictionary displays by the lack of colons separating keys and values

set_display ::= "{" (starred_list | comprehension) "}"

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 ::= "{" (starred_list | comprehension) "}" 4; this literal constructs an empty dictionary

6. 2. 7. Dictionary displays

A dictionary display is a possibly empty series of key/datum pairs enclosed in curly braces

dict_display ::= "{" [key_datum_list | dict_comprehension] "}" key_datum_list ::= key_datum ("," key_datum)* [","] key_datum ::= expression ":" expression | "**" or_expr dict_comprehension ::= expression ":" expression comp_for

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 ::= "{" (starred_list | comprehension) "}" 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 expressions

A generator expression is a compact generator notation in parentheses

generator_expression ::= "(" expression comp_for ")"

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 ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 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 ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 0 clauses and any filter condition in the leftmost comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 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 ::= "{" [key_datum_list | dict_comprehension] "}" key_datum_list ::= key_datum ("," key_datum)* [","] key_datum ::= expression ":" expression | "**" or_expr dict_comprehension ::= expression ":" expression comp_for 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 ::= "[" [starred_list | comprehension] "]" 0 and list_display ::= "[" [starred_list | comprehension] "]" 1 expressions are prohibited in the implicitly defined generator

If a generator expression contains either list_display ::= "[" [starred_list | comprehension] "]" 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 ::= "[" [starred_list | comprehension] "]" 0 and list_display ::= "[" [starred_list | comprehension] "]" 1 prohibited in the implicitly nested scope.

6. 2. 9. Yield expressions

yield_atom ::= "(" yield_expression ")" yield_expression ::= "yield" [expression_list | "from" expression]

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

Due to their side effects on the containing scope, list_display ::= "[" [starred_list | comprehension] "]" 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 ::= "(" expression comp_for ")" 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 ::= "(" yield_expression ")" yield_expression ::= "yield" [expression_list | "from" expression] _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 ::= "(" yield_expression ")" yield_expression ::= "yield" [expression_list | "from" expression] _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)

Berubah di versi 3. 3. Menambahkan yield_atom ::= "(" yield_expression ")" yield_expression ::= "yield" [expression_list | "from" expression] 1 untuk mendelegasikan aliran kontrol ke subiterator.

Tanda kurung dapat dihilangkan ketika ekspresi hasil adalah satu-satunya ekspresi di sisi kanan pernyataan penugasan

Lihat juga

PEP 255 - Generator Sederhana

Proposal untuk menambahkan generator dan pernyataan ke Python

PEP 342 - Coroutine melalui Generator yang Disempurnakan

Proposal untuk meningkatkan API dan sintaks generator, menjadikannya dapat digunakan sebagai coroutine sederhana

PEP 380 - Sintaks untuk Mendelegasikan ke Subgenerator

PEP 525 - Generator Asinkron

Proposal yang diperluas pada PEP 492 dengan menambahkan kemampuan generator ke fungsi coroutine

6. 2. 9. 1. Metode generator-iterator

Subbagian 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 ::= identifier | literal | enclosure enclosure ::= parenth_form | list_display | dict_display | set_display | generator_expression | yield_atom 18 yang ada yang disimpan dalam nilai dapat dihapus

generator. 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. Contoh

Berikut adalah contoh sederhana yang menunjukkan perilaku generator dan fungsi generator

Untuk contoh menggunakan list_display ::= "[" [starred_list | comprehension] "]" _1, lihat di “Yang Baru di Python. ”

6. 2. 9. 3. Fungsi generator asinkron

Kehadiran 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 ::= "(" expression comp_for ")" 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 ::= "(" yield_expression ")" yield_expression ::= "yield" [expression_list | "from" expression] 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 ::= identifier | literal | enclosure enclosure ::= parenth_form | list_display | dict_display | set_display | generator_expression | yield_atom 40 di Lib/asyncio/base_events. py

Ekspresi yield_atom ::= "(" yield_expression ")" yield_expression ::= "yield" [expression_list | "from" expression] _1 adalah kesalahan sintaks saat digunakan dalam fungsi generator asinkron

6. 2. 9. 4. Metode generator-iterator asinkron

Subbagian 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 ::= identifier | literal | enclosure enclosure ::= parenth_form | list_display | dict_display | set_display | generator_expression | yield_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. Primer

Pendahuluan mewakili operasi bahasa yang paling terikat erat. Sintaks mereka adalah

6. 3. 1. Referensi atribut

Referensi atribut adalah yang utama diikuti dengan periode dan nama

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 ::= identifier | literal | enclosure enclosure ::= parenth_form | list_display | dict_display | set_display | generator_expression | yield_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. Langganan

Berlangganan instance dari a umumnya akan memilih elemen dari wadah. Berlangganan a umumnya akan mengembalikan objek

Saat objek disubskrip, interpreter akan mengevaluasi daftar utama dan ekspresi

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

Pemetaan. Jika yang utama adalah , daftar ekspresi harus dievaluasi ke objek yang nilainya merupakan salah satu kunci pemetaan, dan langganan memilih nilai dalam pemetaan yang sesuai dengan kunci tersebut. Contoh kelas pemetaan bawaan adalah kelas
Urutan. Jika yang utama adalah a , daftar ekspresi harus dievaluasi menjadi an atau a (seperti yang dibahas di bagian berikut). Contoh kelas urutan bawaan termasuk , dan kelas

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 ::= identifier | literal | enclosure enclosure ::= parenth_form | list_display | dict_display | set_display | generator_expression | yield_atom 78 memilih item terakhir dari atom ::= identifier | literal | enclosure enclosure ::= parenth_form | list_display | dict_display | set_display | generator_expression | yield_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 ::= identifier | literal | enclosure enclosure ::= parenth_form | list_display | dict_display | set_display | generator_expression | yield_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. Irisan

Pemotongan 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

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)

6. 3. 4. Panggilan

Panggilan memanggil objek yang dapat dipanggil (mis. g. , a ) dengan rangkaian kemungkinan kosong

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 ::= identifier | literal | enclosure enclosure ::= parenth_form | list_display | dict_display | set_display | generator_expression | yield_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 ::= "(" expression comp_for ")" 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 sintaks literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 01 muncul di pemanggilan fungsi, atom ::= identifier | literal | enclosure enclosure ::= parenth_form | list_display | dict_display | set_display | generator_expression | yield_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 ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber _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 ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 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 ::= "{" (starred_list | comprehension) "}" 5, jika ada, atau jika tidak ada, pengecualian akan dimunculkan

Berubah di versi 3. 5. Panggilan fungsi menerima sejumlah literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 12 dan set_display ::= "{" (starred_list | comprehension) "}" 5 unpacking, argumen posisi dapat mengikuti unpacking berulang (literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 12), dan argumen kata kunci dapat mengikuti unpacking kamus (set_display ::= "{" (starred_list | comprehension) "}" 5). Awalnya diusulkan oleh PEP 448.

Panggilan selalu mengembalikan beberapa nilai, mungkin generator_expression ::= "(" expression comp_for ")" 1, kecuali jika memunculkan pengecualian. Bagaimana nilai ini dihitung bergantung pada jenis objek yang dapat dipanggil

Jika memang-

fungsi yang ditentukan pengguna

Blok 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 bawaan

Hasilnya terserah penerjemah;

objek kelas

Contoh baru dari kelas itu dikembalikan

metode instance kelas

Fungsi yang ditentukan pengguna yang sesuai dipanggil, dengan daftar argumen yang lebih panjang dari daftar argumen panggilan. instance menjadi argumen pertama

contoh kelas

6. 4. Menunggu ekspresi

Tangguhkan eksekusi pada objek. Hanya dapat digunakan di dalam a

Baru di versi 3. 5

6. 5. Operator listrik

Operator daya mengikat lebih erat daripada operator unary di sebelah kirinya; . Sintaksnya adalah

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

Meningkatkan literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber _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 ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 30 khusus

6. 6. Operasi aritmatika dan bitwise unary

Semua operasi aritmatika dan bitwise unary memiliki prioritas yang sama

literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 0

Operator unary literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 31 (minus) menghasilkan negasi dari argumen numeriknya;

Operator unary literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 33 (plus) menghasilkan argumen numeriknya tidak berubah;

Dalam ketiga kasus tersebut, jika argumen tidak memiliki tipe yang tepat, pengecualian akan dimunculkan

6. 7. Operasi aritmatika biner

Operasi 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 ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 1

Operator literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber _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;

Operator literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber _43 (at) dimaksudkan untuk digunakan untuk perkalian matriks. Tidak ada tipe Python bawaan yang mengimplementasikan operator ini

Baru di versi 3. 5

Operator literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber _44 (divisi) dan literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 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

Selain melakukan operasi modulo pada angka, operator literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 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 ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 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 ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber _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

Operator literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber _31 (pengurangan) menghasilkan selisih argumennya. Argumen numerik pertama-tama dikonversi ke tipe umum

Operasi ini dapat dikustomisasi menggunakan metode literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 66 khusus

6. 8. Pengalihan operasi

Operasi pergeseran memiliki prioritas lebih rendah daripada operasi aritmatika

literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 2

Operator ini menerima bilangan bulat sebagai argumen. Mereka menggeser argumen pertama ke kiri atau kanan dengan jumlah bit yang diberikan oleh argumen kedua

6. 9. Operasi bitwise biner

Masing-masing dari tiga operasi bitwise memiliki tingkat prioritas yang berbeda

literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 3

6. 10. Perbandingan

Tidak 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 ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber _80 memiliki interpretasi yang konvensional dalam matematika

literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 4

6. 10. 1. Value comparisons

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 ::= "(" [starred_expression] ")" 01, described in

The default behavior for equality comparison (literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 95 and literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 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 ::= "(" [starred_expression] ")" 04 implies parenth_form ::= "(" [starred_expression] ")" 05)

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

Numbers of built-in numeric types () and of the standard library types and can be compared within and across their types, with the restriction that complex numbers do not support order comparison. Within the limits of the types involved, they compare mathematically (algorithmically) correct without loss of precision
The not-a-number values parenth_form ::= "(" [starred_expression] ")" 13 and parenth_form ::= "(" [starred_expression] ")" 14 are special. Setiap perbandingan yang diurutkan dari angka ke nilai bukan angka adalah salah. A counter-intuitive implication is that not-a-number values are not equal to themselves. For example, if parenth_form ::= "(" [starred_expression] ")" 15, parenth_form ::= "(" [starred_expression] ")" 16, parenth_form ::= "(" [starred_expression] ")" 17 and parenth_form ::= "(" [starred_expression] ")" 18 are all false, while parenth_form ::= "(" [starred_expression] ")" 19 is true. This behavior is compliant with IEEE 754
generator_expression ::= "(" expression comp_for ")" 1 and parenth_form ::= "(" [starred_expression] ")" 21 are singletons. PEP 8 advises that comparisons for singletons should always be done with parenth_form ::= "(" [starred_expression] ")" 22 or parenth_form ::= "(" [starred_expression] ")" 23, never the equality operators
Binary sequences (instances of or ) can be compared within and across their types. They compare lexicographically using the numeric values of their elements
Strings (instances of ) compare lexicographically using the numerical Unicode code points (the result of the built-in function ) of their characters.
Strings and binary sequences cannot be directly compared
Sequences (instances of , , or ) can be compared only within each of their types, with the restriction that ranges do not support order comparison. Equality comparison across these types results in inequality, and ordering comparison across these types raises
Sequences compare lexicographically using comparison of corresponding elements. The built-in containers typically assume identical objects are equal to themselves. That lets them bypass equality tests for identical objects to improve performance and to maintain their internal invariants
Lexicographical comparison between built-in collections works as follows
- For two collections to compare equal, they must be of the same type, have the same length, and each pair of corresponding elements must compare equal (for example, parenth_form ::= "(" [starred_expression] ")" 32 is false because the type is not the same)
- Collections that support order comparison are ordered the same as their first unequal elements (for example, parenth_form ::= "(" [starred_expression] ")" 33 has the same value as parenth_form ::= "(" [starred_expression] ")" 34). If a corresponding element does not exist, the shorter collection is ordered first (for example, parenth_form ::= "(" [starred_expression] ")" 35 is true)
Mappings (instances of ) compare equal if and only if they have equal parenth_form ::= "(" [starred_expression] ")" 37 pairs. Equality comparison of the keys and values enforces reflexivity
Order comparisons (literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 93, literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 94, literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 97, and literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 96) raise
Sets (instances of or ) can be compared within and across their types
They define order comparison operators to mean subset and superset tests. Those relations do not define total orderings (for example, the two sets parenth_form ::= "(" [starred_expression] ")" 45 and parenth_form ::= "(" [starred_expression] ")" 46 are not equal, nor subsets of one another, nor supersets of one another). Accordingly, sets are not appropriate arguments for functions which depend on total ordering (for example, , , and produce undefined results given a list of sets as inputs)
Comparison of sets enforces reflexivity of its elements
Most other built-in types have no comparison methods implemented, so they inherit the default comparison behavior

User-defined classes that customize their comparison behavior should follow some consistency rules, if possible

Equality comparison should be reflexive. In other words, identical objects should compare equal
parenth_form ::= "(" [starred_expression] ")" 04 implies parenth_form ::= "(" [starred_expression] ")" 05
Comparison should be symmetric. In other words, the following expressions should have the same result
parenth_form ::= "(" [starred_expression] ")" 05 and parenth_form ::= "(" [starred_expression] ")" 53
parenth_form ::= "(" [starred_expression] ")" 54 and parenth_form ::= "(" [starred_expression] ")" 55
literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 88 and parenth_form ::= "(" [starred_expression] ")" 57
parenth_form ::= "(" [starred_expression] ")" 34 and parenth_form ::= "(" [starred_expression] ")" 59
Comparison should be transitive. The following (non-exhaustive) examples illustrate that
parenth_form ::= "(" [starred_expression] ")" 60 implies parenth_form ::= "(" [starred_expression] ")" 61
literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 85 implies parenth_form ::= "(" [starred_expression] ")" 63
Inverse comparison should result in the boolean negation. In other words, the following expressions should have the same result
parenth_form ::= "(" [starred_expression] ")" 05 and parenth_form ::= "(" [starred_expression] ")" 65
literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 88 and parenth_form ::= "(" [starred_expression] ")" 67 (for total ordering)
parenth_form ::= "(" [starred_expression] ")" 68 and parenth_form ::= "(" [starred_expression] ")" 69 (for total ordering)
The last two expressions apply to totally ordered collections (e. g. to sequences, but not to sets or mappings). See also the decorator
The result should be consistent with equality. Objects that are equal should either have the same hash value, or be marked as unhashable

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 operations

The operators and test for membership. parenth_form ::= "(" [starred_expression] ")" 74 evaluates to literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 81 if x is a member of s, and literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 82 otherwise. parenth_form ::= "(" [starred_expression] ")" 77 returns the negation of parenth_form ::= "(" [starred_expression] ")" 74. All built-in sequences and set types support this as well as dictionary, for which parenth_form ::= "(" [starred_expression] ")" 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 ::= "(" [starred_expression] ")" 80 is equivalent to parenth_form ::= "(" [starred_expression] ")" 81

For the string and bytes types, parenth_form ::= "(" [starred_expression] ")" 80 is literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 81 if and only if x is a substring of y. An equivalent test is parenth_form ::= "(" [starred_expression] ")" 84. Empty strings are always considered to be a substring of any other string, so parenth_form ::= "(" [starred_expression] ")" 85 will return literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 81

For user-defined classes which define the parenth_form ::= "(" [starred_expression] ")" 87 method, parenth_form ::= "(" [starred_expression] ")" 80 returns literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 81 if parenth_form ::= "(" [starred_expression] ")" 90 returns a true value, and literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 82 otherwise

For user-defined classes which do not define parenth_form ::= "(" [starred_expression] ")" 87 but do define parenth_form ::= "(" [starred_expression] ")" 93, parenth_form ::= "(" [starred_expression] ")" 80 is literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 81 if some value literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 87, for which the expression parenth_form ::= "(" [starred_expression] ")" 97 is true, is produced while iterating over literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 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 ::= identifier | literal | enclosure enclosure ::= parenth_form | list_display | dict_display | set_display | generator_expression | yield_atom 65, parenth_form ::= "(" [starred_expression] ")" 80 is literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 81 if and only if there is a non-negative integer index i such that comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 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 identitas

Operator dan uji identitas objek. parenth_form ::= "(" [starred_expression] ")" 04 is true if and only if x and y are the same object. An Object’s identity is determined using the function. comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 12 yields the inverse truth value.

6. 11. Boolean operations

literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 5

Dalam konteks operasi Boolean, dan juga ketika ekspresi digunakan oleh pernyataan alur kontrol, nilai berikut ini diinterpretasikan sebagai salah. literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 82, generator_expression ::= "(" expression comp_for ")" 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 ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 15

Ekspresi comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] _19 pertama mengevaluasi x;

Note that neither nor restrict the value and type they return to literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 82 and literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 81, but rather return the last evaluated argument. This is sometimes useful, e. g. , if comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 25 is a string that should be replaced by a default value if it is empty, the expression comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 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 ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 28 produces literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 82 rather than comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 30. )

6. 12. Assignment expressions

literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 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 ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 7

Or, when processing a file stream in chunks

literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 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 ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 34 and comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 35 statements. In all other places where they can be used, parentheses are not required, including in comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 2 and comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 37 statements

New in version 3. 8. See PEP 572 for more details about assignment expressions.

6. 13. Conditional expressions

literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 9

Conditional expressions (sometimes called a “ternary operator”) have the lowest priority of all Python operations

The expression comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 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. Lambdas

parenth_form ::= "(" [starred_expression] ")" 0

Lambda expressions (sometimes called lambda forms) are used to create anonymous functions. The expression comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 39 yields a function object. The unnamed object behaves like a function object defined with

parenth_form ::= "(" [starred_expression] ")" 1

See section for the syntax of parameter lists. Note that functions created with lambda expressions cannot contain statements or annotations

6. 15. Expression lists

parenth_form ::= "(" [starred_expression] ")" 2

Except 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 ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 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 ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 41. )

6. 16. Evaluation order

Python 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 ::= "(" [starred_expression] ")" 3

6. 17. Operator precedence

The 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 ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 43, comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 44, comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 45

Binding or parenthesized expression, list display, dictionary display, set display

comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 46, comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 47, comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 48, comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 49

Subscription, slicing, call, attribute reference

Await expression

set_display ::= "{" (starred_list | comprehension) "}" 5

Exponentiation

comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 52, comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 53, comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 54

Positive, negative, bitwise NOT

Multiplication, matrix multiplication, division, floor division, remainder

Addition and subtraction

Shifts

literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 71

Bitwise AND

literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 74

Bitwise XOR

literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 77

Bitwise OR

Comparisons, including membership tests and identity tests

Boolean NOT

Boolean AND

Boolean OR

– comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 81

Conditional expression

Lambda expression

Assignment expression

Footnotes

While comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 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 ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 85 have the same sign as comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 86, the computed result is comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 87, which is numerically exactly equal to comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 86. The function returns a result whose sign matches the sign of the first argument instead, and so returns comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 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 ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 91 to be one larger than comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 92 due to rounding. In such cases, Python returns the latter result, in order to preserve that comprehension ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 93 be very close to atom ::= identifier | literal | enclosure enclosure ::= parenth_form | list_display | dict_display | set_display | generator_expression | yield_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 ::= assignment_expression comp_for comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter] comp_iter ::= comp_for | comp_if comp_if ::= "if" or_test [comp_iter] 95 is literal ::= stringliteral | bytesliteral | integer | floatnumber | imagnumber 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 ::= "{" (starred_list | comprehension) "}" 5 binds less tightly than an arithmetic or bitwise unary operator on its right, that is, list_display ::= "[" [starred_list | comprehension] "]" 00 is list_display ::= "[" [starred_list | comprehension] "]" 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.