a class object: A new instance of that class is returned. 

a class instance method: The corresponding user-defined function is called, with an argument list that is one longer than the argument list of the call: the instance becomes the first argument. 

a class instance: The class must define a __call__() method; the effect is then the same as if that method was called. 

## 6.4 Await expression 

Suspend the execution of coroutine on an awaitable object. Can only be used inside a coroutine function . 

await_expr ::= "await" primary 

New in version 3.5. 

## 6.5 The power operator 

The power operator binds more tightly than unary operators on its left; it binds less tightly than unary operators on its right. The syntax is: 

power ::= ( await_expr | primary ) ["**" u_expr ] 

Thus, in an unparenthesized sequence of power and unary operators, the operators are evaluated from right to left (this does not constrain the evaluation order for the operands):$_{-1**2}$ results in$_{-1}$ . 

The power operator has the same semantics as the built-in$_{pow()}$ function, when called with two arguments: it yields its left argument raised to the power of its right argument. The numeric arguments are first converted to a common type, and the result is of that type. 

For int operands, the result has the same type as the operands unless the second argument is negative; in that case, all arguments are converted to float and a float result is delivered. For example,$_{10**2}$ returns$_{100}$ , but$_{10**-2}$ returns$_{0.01}$ . 

Raising$_{0.0}$ to a negative power results in a$_{ZeroDivisionError}$ . Raising a negative number to a fractional power results in a$_{complex}$ number. (In earlier versions it raised a$_{ValueError}$.) 

## 6.6 Unary arithmetic and bitwise operations 

All unary arithmetic and bitwise operations have the same priority: 

u_expr ::= power | "-" u_expr | "+" u_expr | "~" u_expr 

The unary$_{-}$(minus) operator yields the negation of its numeric argument. 

The unary$_{+}$(plus) operator yields its numeric argument unchanged. 

The unary$_{~}$ (invert) operator yields the bitwise inversion of its integer argument. The bitwise inversion of$_{x}$is defined as$_{-(x+1)}$ . It only applies to integral numbers. 

In all three cases, if the argument does not have the proper type, a$_{TypeError}$ exception is raised. 

