 #White #Dark #txt #download

``````"""
Equivalences

You have a working code, and you want it to be more clean, more pretty, more readable.
This is what we call, refactoring.

You can of course choose to apply the transformation or not.

A "→" means the code will probably be more readable (according to me).

A "↔" means the clarity will depend on the context (neither code is a priori more readable).
"""

##
# inverser if/else
##
if CONDITION:
A
else:
B
# ↔
if not(CONDITION):
B
else:
A

## example 1
if a == 5:
print("hello")
else:
waw = 2
# ↔ (invert if/else)
if not(a == 5):
waw = 2
else:
print("hello")
# ↔ (not == ↔ !=)
if a != 5:
waw = 2
else:
print("hello")

###
# else do nothing
###
if CONDITION:
A
else:
pass  # do nothing
# →
if CONDITION:
A

## example 1
if a != 5:
print("hello")
else:
pass  # do nothing
# → ("else do nothing" is useless)
if a != 5:
print("hello")

## example 2
if a == 5:
pass  # do nothing
else:
print("hello")
# → (invert if/else)
if a != 5:
print("hello")
else:
pass  # do nothing
# → ("else do nothing" is useless)
if a != 5:
print("hello")

###
# simplify not (De Morgan's laws)
###
# De Morgan on "and"
if not(A and B):
...
# ↔
if (not A) or (not B):
...

# De Morgan on "or"
if not(A or B):
...
# ↔
if (not A) and (not B):
...

## example 1
if not(a > 10 or a == 5):
print('hello')
# → (De Morgan)
if a <= 10 and a != 5:
print('hello')

## example 2
if a > 10 or a == 5:
pass
else:
print('hello')
# → (invert if/else)
if not(a > 10 or a == 5):
print('hello')
else:
pass
# → ("else do nothing" is useless)
if not(a > 10 or a == 5):
print('hello')
# → (De Morgan)
if a <= 10 and a != 5:
print('hello')

###
# if followed by if not
###
if a < b:
print("hello")
if a >= b:
# → (à condition que a et b ne soient pas modifiés dans le if !)
if a < b:
print("hello")
else:

###
# if variable
###
if CONDITION:
x = A
else:
x = B
# →
x = A if CONDITION else B
# →
x = (A if CONDITION else B)
# →
x = (A if CONDITION else
B)

## example
if a == 5:
c = 2
else:
c = 0
# → ("one-line if" also called "ternary operator" or "functional if")
c = (5 if a == 5 else 0)
# ↔ (parenthesis are useless)
c = 5 if a == 5 else 0

##
# if elif cascade on variable
##
if CONDITION:
x = A
elif CONDITION_2:
x = B
elif CONDITION_3:
x = C
else:
x = D
# →
x = (A if CONDITION else
B if CONDITION_2 else
C if CONDITION_3 else
D)

## example
if a == 5:
c = 8
elif a == 2:
c = 4
elif a < 0:
c = 1
else:
c = 0
# → (functional if)
c = (8 if a == 5 else
4 if a == 2 else
1 if a < 0 else
0)

##
# renaming
##
#
# You can rename a variable to give it a name more explicit :
e = v * t
i = e / 2.56
# →
distance = velocity * time
distance_inch = distance / 2.56
# Generally variable names of few letters are <strong>too short</strong>
# (except in mathematical expressions or well known variable names like the <code>"i"</code> in a loop)
# and variable names with more than three real words are <strong>too long</strong>
# (a comment next to the variable creation will be probably better).

##
# inline variable
##
x = ...
operation(x)
# → (only possible if x is used only once)
operation(...)
## example
x = size + 1  # x depends on the size
y = size - 1  # y depends on the size
the_coefficent = x + 2 * y  # let's compute the coefficent using the linear formula
print(the_coefficent)       # let's print it

# ↔ (inline variable "the_coefficent")
x = size + 1  # x depends on the size
y = size - 1  # y depends on the size
print(x + 2 * y)  # let's print the result of the linear formula

# ↔ (inline variables "x" and "y")
print((size + 1) + 2 * (size - 1))  # let's print the result of the linear formula depending on the size

##
# boolean return
##
def f(...):
...
if CONDITION:
return True
else:
return False
# →
def f(...):
...
return CONDITION

## avec une variable
if CONDITION:
res = True
else:
res = False
# →
res = CONDITION

## example 1
def is_even(x):
if x % 2 == 0:    # if the rest of division by 2 is 0
return True   # Vrai, le nombre est pair
else:             # sinon
return False  # Faux, le nombre n'est pas pair
# → (boolean return)
def is_even(x):
return x % 2 == 0  # x is even iff the rest of division by 2 is 0
# :
if is_even(4):
...

## example 1'
if x % 2 == 0:   # if the rest of division by 2 is 0
res = True   # le résultat est Vrai, le nombre est pair
else:            # sinon
res = False  # le résultat est Faux, le nombre n'est pas pair
# → (boolean return)
res = (x % 2 == 0)  # the result is true iff the rest of division by 2 is 0
# → (renaming)
is_even = (x % 2 == 0)  # on nomme la variable de manière sémantique
# ↔ (parenthesis)
is_even = x % 2 == 0  # parenthèses non nécessaires

## example 2
def vowel(x):
if x == 'a' or x == 'e' or x == 'i' or x == 'o' or x == 'u':
return True
else:
return False
# → (boolean return)
def vowel(x):
return x == 'a' or x == 'e' or x == 'i' or x == 'o' or x == 'u'  # x is a vowel iff x is 'a', 'e', 'i', 'o', 'u'
# :
if vowel('a'):  # if 'a' is a vowel
...

##
# == True
##
# given
def is_even(x):
if x % 2 == 0:  # if the rest of division by 2 is 0
return True
else:
return False
# :
if is_even(4) == True:  # si the is_even function returns True
...
# →
if is_even(4):  # if 4 is even
...

##
# or
##
if CONDITION:
A
elif CONDITION_2:
A  # same A
# →
if CONDITION or CONDITION_2:
A

## example
if a == 5:
x = 2
elif a > 10:
x = 2
# → (or)
if a == 5 or a > 10:
x = 2

##
# or else
##
if CONDITION:
A
elif CONDITION_2:
A  # same A
else:
B
# →
if CONDITION or CONDITION_2:
A
else:
B

## example
if a == 5:
x = 2
elif a > 10:
x = 2
else:
print('error')
# → (or)
if a == 5 or a > 10:
x = 2
else:
print('error')

##
# or return
##
def f(...):
...
if CONDITION:
return True
if CONDITION_2:
return True
return False
# →
def f(...):
...
return CONDITION or CONDITION_2
# ↔
def f(...):
...
return (CONDITION
or CONDITION_2)

## example
def interesting(x):
if x > 10:  # if x > 10
return True  # it's interesting
if x == 5:  # if x == 5
return True  # it's interesting
return False  # otherwise, it's not interesting
# → (or return)
def interesting(x):
return x > 10 or x == 5  # x is interesting if it's > 10 or 5

##
# and
##
if CONDITION:
if CONDITION_2:
A
# →
if CONDITION and CONDITION_2:
A

## example
if a == 5:
if a > 10:
print('waw')
# → (and)
if a == 5 and a > 10:
print('waw')

##
# and else
##
if CONDITION:
if CONDITION_2:
A
else:
B
else:
B  # same b
# →
if CONDITION and CONDITION_2:
A
else:
B

## example
if a == 5:
if b > 10:
waw = 2
else:
print('error')
else:
print('error')
# → (and)
if a == 5 and b > 10:
waw = 2
else:
print('error')

##
# if return
##
def f(...):
...
if CONDITION:
return X
...
# ↔
def f(...):
...
if CONDITION:
return X
else:
...

## example
def f(x):
if x < 0:
return -1
else:
y = x + 2
z = y ** 2
return z
# → (if return)
def f(x):
if x < 0:
return -1
y = x + 2
z = y ** 2
return z

# I generally do that when the <code>"if"</code> is really short like a simple <code>"return"</code>.
# Souvent, ce sont des cas particuliers ou des cas de base, le code du bas est plus intéressant.

##
# for if return True (∃)
## for-if-return-True, any, exists, ∃
# Here is how we code a "∃"
def f(...):
...
for x in L:
if condition:  # this "if" DOESN'T have a "else"
return True
return False
# → (en python, il y a "all")
def f(...):
...
return any(condition for x in L)
# ↔
def f(...):
...
return any(condition
for x in L)

# Note: in python there is also the [for...else](https://stackoverflow.com/questions/9979970/why-does-python-use-else-after-for-and-while-loops#9980752) but not so much people use it

## example
def contains_a_negative(L):
for x in L:  # for each element in the list
if x < 0:  # if it's < 0
return True  # the list contains_a_negative
return False  # in the end, it means it doesn't contain one
# → (any)
def contains_a_negative(L):
return any(x < 0 for x in L)
# We'll read it as <em>A list L contains_a_negative if...</em>
# <ul>
# <li> there is a x < 0
# <li> there exists any x such that x < 0
# <li> ∃ x ∈ L: x < 0
# </ul>

##
# for if return False (∀)
## for-if-return-False, all, forall, ∀
# Here is how we code a "∀"
def f(...):
...
for x in L:
if condition:  # this "if" DOESN'T have a "else"
return False
return True
# → (en python, il y a "all")
def f(...):
return all(not condition for x in L)
# ↔
def f(...):
return all(not condition
for x in L)

# Note: in python there is also the [for...else](https://stackoverflow.com/questions/9979970/why-does-python-use-else-after-for-and-while-loops#9980752) but not so much people use it

## example
def totally_positive(L):
for x in L:  # for each element in the list
if x < 0:  # if it's < 0
return False  # the list is not totally_positive
return True  # in the end, the list is totally_positive
# → (all)
def totally_positive(L):
return all(x >= 0 for x in L)
# We'll read it as <em>A list L is totalement_positive if</em>...
# <ul>
# <li> A list is totally positive if all its elements x are >= 0
# <li> for all its elements x one have x >= 0
# <li> any element x ∈ L satisfies x >= 0
# <li> ∀ x ∈ L : x >= 0
# </ul>

##
# not ∀/∃ (De Morgan's laws)
## not-any, not-all
# De Morgan on "∀"
not all(condition for x in L)
# →
any(not condition for x in L)

# De Morgan on "∃"
not any(condition for x in L)
# →
all(not condition for x in L)

## example
if not all(x >= 0 for x in L):  # si on n'a pas tous les nombres >= 0
...
# → (if non empty)
if any(x < 0 for x in L):  # c'est qu'il existe un nombre < 0
...
# <strong>Attention</strong>: cette transformation ne marche pas si L est vide !
#

##
# for if return else return
##
# Here is how one code a linear search
def f(...):
for x in L:
if condition:
return a
return b
# → (in python, one can use "next")
def f(...):
return next((a for x in L if condition), b)
# ↔
def f(...):
return next((a for x in L if condition),
b)

# Note: in python there is also the [for...else](https://stackoverflow.com/questions/9979970/why-does-python-use-else-after-for-and-while-loops#9980752) but not so much people use it

## example
#
# <em>Le super_nombre d'une liste est le <strong>premier</strong> x dans la liste tel que x > 10</em> :
def super_number(L):
for x in L:  # for each element in the list
if x > 10:  # if it's > 10
return x  # it's the super_number of that list
return 0  # il n'y a pas de super nombre, on renvoie 0
# →
def super_number(L):
return next((x for x in L if x > 10), 0)

##
# for append
##
L = []
for x in iterable:
L.append(e)
# →
L = [e for x in iterable]

##
# for append f(x)
## +, map
L = []
for x in iterable:
L.append(f(x))
# →
L = list(map(f, iterable))
# ↔
L = [f(x) for x in iterable]

##
# for if append
##
L = []
for x in iterable:
if condition:
L.append(e)
# →
L = [e for x in iterable if condition]

##
# for if f(x) append x
## +, filter
L = []
for x in iterable:
if f(x):
L.append(x)
# →
L = list(filter(f, iterable))
# ↔
L = [x for x in iterable if f(x)]

##
# iterate a generator (python)
##
for x in list(generator):
...
# →
for x in generator:
...

## example 1
for x in list(map(f, L)):  # map, filter, zip...
...
# →
for x in map(f, L):
...

## example 2
# with
def operation(x):
return (x + 1) * 2 - x
# :
for x in list(map(operation, [1,2,3])):
print(x)
# →
for x in map(operation, [1,2,3]):
print(x)

##
# sum
##

## example
s = 0
for x in L:
s += a
# → (sum)
s = sum(a for x in L)

# technically, "sum" is a particular case of "reduce" but "reduce" is a bit useless in python

##
# join
##

## example
s = ''
for x in L:
s += a
# → (join)
s = ''.join(a for x in L)

# technically, "join" is a particular case of "reduce" but "reduce" is a bit useless in python

##
# in tuple (python)
##

## example
if x == 'a' or x == 'e' or x == 'i' or x == 'o' or x == 'u':
...
# → (in)
if x in ('a', 'e', 'i', 'o', 'u'):
...

# it's a particular case of linear search in a list

``````