post

Python ca:Operators and Expressions

Contents

Introducció

La majoria de sentències (línies lògiques) que escriuràs tindran expressions. Un senzill exemple d’una expressió és 2+3. Una expressió es pot agrupar en operadors i operands.

Els Operadors són funcionalitats que fan alguna cosa i que es poden representar per simbols com ara + o per paraules especials (paraules reservades). Els operadors requereixen dades per a fer una operació, aquestes dades són els operands. En aquest cas, 2 i 3 són els operands.

Operadors

Donarem un cop d’ull als operadors i el seu usatge:

Tingues en compte que pots evaluar les expressions donades en els exemples utilitzant l’intèrpret interactiu. Per exemple, per probar l’expressió 2+3,utilitza el prompt de l’intèrpret interactiu del Python:

>>> 2 + 3
5
>>> 3 * 5
15
>>>
Operadors i la seva utilització

Operador

Nom

Explicació

Exemples

+

Més

Suma els dos objectes

3 + 5 dóna 8. 'a' + 'b' dóna 'ab'.

Menys

Dóna la resta entre els dos números; si el primer operand és absent s’assumeix que aquest és zero.

-5.2 dóna un número negatiu i 50 - 24 dóna 26.

*

Multiplica

Dóna la multiplicació entre els dos números o retorna la cadena repetides n vegades.

2 * 3 dóna 6. 'la' * 3 dóna 'lalala'.

**

Potència

Retorna x elevat a la potència y

3 ** 4 dóna 81 (equival a 3 * 3 * 3 * 3)

/

Divideix

Divideix x per y

4 / 3 dóna 1.3333333333333333.

//

Divisió d’Enters

Returna el quocient

4 // 3 dóna 1.

%

Modulo

Retorna el residu de la divisió

8% 3 dóna 2. -25.5% 2.25 dóna 1.5.

<<

Left Shift

Corre els bits del número cap a l’esquerra pel nombre de bits especificats. (Cada número és representat en memòria per bits o dígits binaris, 0 i 1)

2 << 2 dóna 8. 2 és representat per 10 en bits. Corre’l 2 bits a l’esquerra dóna 1000 que representa el decimal 8.

>>

Right Shift

Corre els bits del número a la dreta pel nombre de bits especificat.

11 >> 1 dóna 5. 11 és representat en bits per 1011 que quan es corre 1 bit a la dreta dóna 101 que equival al decimal 5.

&

Bitwise AND

Bitwise AND dels números

5 & 3 dóna 1.

|

Bit-wise OR

Bitwise OR dels números

5 | 3 dóna 7

^

Bit-wise XOR

Bitwise XOR dels números

5 ^ 3 dóna 6

~

Bit-wise invert

La inversió bit-wise de x és -(x+1)

~5 dóna -6.

<

Menor que

Retorna si x és menor que y. Tots els operadors de comparació retornen verdader (True) o fals (False). Fixa’t que comencen amb majúscula.

5 < 3 dóna False i 3 < 5 dóna True.

Les comparacions es poden encadenar arbitràriament: 3 < 5 < 7 dóna True.

>

Major que

Retorna si x és major que y.

5 > 3 retorna True. Si ambdós operands són números, primer es converteixen a un tipus de dada comú. Altrament, sempre retorna fals (False).

<=

Menor que o igual a

Retorna si x és menor que o igual a y.

x = 3; y = 6; x <= y retorna True.

>=

Major que o igual a

Retorna si x és major que o igual a y.

x = 4; y = 3; x >= 3 retorna True.

==

Igual a

Compara si els dos nombres són iguals

x = 2; y = 2; x == y retorna True.

x = 'str'; y = 'stR'; x == y retorna False.

x = 'str'; y = 'str'; x == y returns True.

!=

Diferent a

Compara si els objectes són diferents

x = 2; y = 3; x!= y retorna True.

not

Booleà NOT

Si x és True, retorna False. Si x és False, retorna True.

x = True; not x retorna False.

and

Booleà AND

x AND y retorna False si x és False, altrament retorna l’evaluació de y

x = False; y = True; x and y retorna False car x és False. En aquest cas, Python no evaluarà y car coneix que la part esquerra de l’expressió ‘and’ és False el que implica que tota l’expressió serà False irrespectivament dels altres valors. Això s’anomena evaluació de curt-circuit.

or

Booleà OR

Si x és True, retorna True, altrament retorna l’evaluació de y

x = True; y = False; x or y retorna True. També és una evaluació de tipus curtcircuit.

Drecera per a operacions matemàtiques i assignació

És comú fer operacions matemàtiques amb una variable i després assignar el resultat de l’operació a aquesta variable, per això hi ha una drecera per aquest tipus d’expressions:

Pots escriure:

a = 2; a = a * 3

com:

a = 2; a *= 3

Fixa’t que var = var operació expressió esdevé var operació= expressió.

Ordre d’Evaluació

Si tens una expressió com ara 2+3*4, s’evalua primer la suma o la multiplicació? Les nocions bàsiques de mates ens diuen que primer s’evaluen les multiplicacions i després les sumes. Això vol dir que l’operador de multiplicació te major precedència que el de suma.

La taula següent ens dona la precedència dels operadors pel Python, del de menor precedència al de major precedència. Això vol dir que donada una expressió, el Python evaluarà primer els operadors i expressions del final de la taula abans que els del principi de la taula.

La taula següent, extreta de Python reference manual, s’afegeix per completar la informació. És molt millor utilitzar parèntesis per tal d’agrupar operadors i operands per tal d’especificar la seva precedència. Això fa també el programa més llegible. Veieu Changing the Order of Evaluation per més detalls.

Operator Precedence

Operator

Description

lambda

Lambda Expression

or

Boolean OR

and

Boolean AND

not x

Boolean NOT

in, not in

Membership tests

is, is not

Identity tests

<, <=, >, >=,!=, ==

Comparisons

|

Bitwise OR

^

Bitwise XOR

&

Bitwise AND

<<, >>

Shifts

+, –

Addition and subtraction

*, /, //, %

Multiplication, Division, Floor Division and Remainder

+x, -x

Positive, Negative

~x

Bitwise NOT

**

Exponentiation

x.attribute

Attribute reference

x[index]

Subscription

x[index1:index2]

Slicing

f(arguments …)

Function call

(expressions, …)

Binding or tuple display

[expressions, …]

List display

{key:datum, …}

Dictionary display

The operators which we have not already come across will be explained in later chapters.

Operators with the same precedence are listed in the same row in the above table. For example, + and - have the same precedence.

Changing the Order Of Evaluation

Per a fer les expressions més fàcils de llegir, podem utilitzar parèntesis. Per exemple, 2 + (3 * 4) és definitivament més fàcil de llegir que 2 + 3 * 4 el qual requereix el coneixement de precedència d’operadors. Com amb qualsevol altra cosa, els parèntesis s’han d’utilitzar amb seny i no sobreutilitzar-los ni crear expressions redundants, com ara (2 + (3 * 4)).

Hi ha un altre avantatge a l’utilitzar parèntesis, ens ajuda a canviar l’ordre d’evaluació. Per exemple, si vols que la suma s’evalui abans que la multiplicació, pots escriure una expressió com per exemple (2 + 3) * 4.

Associativity

Operators are usually associated from left to right. This means that operators with the same precedence are evaluated in a left to right manner. For example, 2 + 3 + 4 is evaluated as (2 + 3) + 4. Some operators like assignment operators have right to left associativity i.e. a = b = c is treated as a = (b = c).

Expressions

Example:

#!/usr/bin/python
# Filename: expression.py

length = 5
breadth = 2

area = length * breadth
print('Area is', area)
print('Perimeter is', 2 * (length + breadth))

Output:

   $ python expression.py
   Area is 10
   Perimeter is 14

How It Works:

The length and breadth of the rectangle are stored in variables by the same name. We use these to calculate the area and perimeter of the rectangle with the help of expressions. We store the result of the expression length * breadth in the variable area and then print it using the print function. In the second case, we directly use the value of the expression 2 * (length + breadth) in the print function.

Also, notice how Python ‘pretty-prints’ the output. Even though we have not specified a space between 'Area is' and the variable area, Python puts it for us so that we get a clean nice output and the program is much more readable this way (since we don’t need to worry about spacing in the strings we use for output). This is an example of how Python makes life easy for the programmer.

Summary

We have seen how to use operators, operands and expressions – these are the basic building blocks of any program. Next, we will see how to make use of these in our programs using statements.