##################################
# Premier point sur les variables#
##################################
## comment rajouter 1 à une variable?
i=10
s=0
def plus1(i):
    s=i+1
    return(s)

print(i)    
print(plus1(i))
print(s)

## la variable 's' est (dans le programme précédent) locale 

i=10
s=0
def pplus1(i):
    global s
    s=i+1
    return(s)

print(i)    
print(pplus1(i))
print(s)

## vers les effets de bords: 
#Définition : une fonction est dite à effet de bord lorsqu'elle modifie un état autre que sa valeur de retour. 

i=10
def ppplus1():
    i+=1
    return(i)
print(i)    
ppplus1()
print(i)
##
def ppplus1():
    global i
    i+=1
    return(i)
print(i)    
ppplus1()
print(i)
##

##################################
# Exercices sur les listes       #
##################################


### la concaténation de 2 listes:
l=[1,2,3]
l1=[4,5,6]

l2=l+l1
l3=l1+l

print(l2)
print(l3)   
    
    
###
# Exercice 1 : (L'aliasing) comprendre la différence entre les deux blocks suivants
##exemple 1:

a=[11,22,33] # a est affectée. Elle pointe vers une liste donnée
b=a # b point vers la même liste que a
a[0:3]=[17,42,561] # nous changeons le contenu de la liste vers qui pointe a
print(a,b) # b change également
print(id(a)==id(b))

##exemple 2:
a=[11,22,33]
b=a
a=[17,42,561]# a point vers une autre liste
print(a,b)
print(id(a)==id(b))


## un autre exemple:
    
a=[ i for i in range(10)]
b=a
print(a,b)
a[0]='a'
print(a,b)


## ou 

a=[ i for i in range(10)]
b=a
print(a,b)
b[0]='a'
print(a,b)
    
## ou 

a=[ i for i in range(10)]
b=a
print(a,b)
a=a+ [i for i in range(1,10)] # a point vers une autre liste
print(a,b)
    
    

## Exercice 2: Que valent a et b après les instructions suivantes?
# quelques exemples pour constater "la profondeur d'une liste". Une liste de listes de listes de listes....
a=[11,22,33]
b=[7,14,a]
print(b)
print(b[2][1]) # le 2eme élément du 3eme élément de b
b[2][1]=17 
print(b)
print(a)
a[0]=19
print(a,b)

    

    
## Tableau ou matrice :
    
a=[0,0]
b=[a,a]
print(b)
b[0][0]=3
print(b)
##
a=[0,0]
c=[0,0]
b=[a,c]
print(b)
b[0][0]=3
print(b)    
##
n=3
a=[0]*n
print(a)


c=[]
c=[a]*n
print(c)
# Quelle est la taille de la matrice c?
c[0][0]=1
print(c) # est-ce cohérent?

##

n=3
a=[0]
b=a*n
print(b)
a[0]=1
print(a,b)# est-ce cohérent?
# l'opérateur * a donc quelques avantages.



## une alternative:

c=[]
for i in range(n):
    c+=[[0]*n]
print(c)
c[0][0]=1
print(c) 

    
## la bonne question: comment faire une copie indépendante d'une liste (à utiliser sans hésitation !).... la copie profonde

import copy as c

a=[ i for i in range(10)]
b=c.deepcopy(a)  
print(a,b)
a[0]='test'
print(a,b)

## pourquoi une copie profonde ? tester les lignes suivantes 
import copy as c

a=[0,[1,2,3]]
b=c.copy(a)  
print(a,b)
a[0]=1
print(a,b)
a[1][0]='test'
print(a,b)
  

## Exercice 3 : Que fait la fonction suivante?

## Une fonction peut changer une liste que l'on appelle 


a=[ i for i in range(10)]
def f(l,x):
    l[0]=1
print(f(a,1)) # une action est effectuée mais laquelle?
print(a) # il y a eu une action sur a.

## comment éviter cela? Ne jamais travailler dans le corps d'une fonction sur une variable appelée.


a=[ i for i in range(10)]
def f(l,x):
    l0=c.deepcopy(l)
    l0[0]=1
    return(l0)
print(f(a,1)) # une action est effectuée mais laquelle?
print(a) # il y a eu une action sur a.

## Que font les fonctions suivantes?


def f(l,i,j):
    l[i]=l[i]+l[j]
    l[j]=l[i]-l[j]
    l[i]=l[i]-l[j]
 
a=[ i for i in range(10)]   
f(a,0,1)
print(a)
##
def g(i,j):
    l[i]=l[i]+l[j]
    l[j]=l[i]-l[j]
    l[i]=l[i]-l[j]
    
l=[0,1,2,3]
print(l)
g(0,1)  
print(l)
# Attention aux effets de bords ! 
# Définition : une fonction est dite à effet de bord lorsqu'elle modifie un état autre que sa valeur de retour.  


## Exercice 4: Concaténation
# y-a-t-il une différence ?

a=[2,3,4,6]
print(id(a))
a=a+[2]
print(id(a)) # en rajoutant 2 ... ce n'est plus la même liste.

# comment conserver la même liste ?
a=[2,3,4,6]
print(id(a))
a.append(2)
print(id(a))

# nous l'utiliserons dans le TP sur les piles.


## Exercice 5: Insertion /Suppression
# Que font les fonctions suivantes?
help(range)
help(list)
# toujours penser à utiliser l'aide !

a=list(range(20))
print(a)
a.insert(2, 18)
print(a)

a=list(range(20))
print(a)

del a[3]
print(a)

del a[2:4]
print(a)

a=[1,1,2,2,3,3,4,4,5,5,6,6]
print(a)

## Attention aux effets de bords ! (vers les piles )

a=[1,1,2,2,3,3,4,4,5,5,6,6]
print(a)

print(a.pop())
print(a)
for i in range(3):
    a.pop()
print(a)


print(a.pop(3))
print(a)

a.remove(4)
print(a)


## tester sur les listes les fonctions: sorted, min, max , sum 
a=[]
n=10
a=[n-i**2 for i in range(n)]
print(a)
print(sorted(a), min(a), max(a), sum(a))



##################################
# 2 - Itérations                 #
##################################

#En Python, un objet est dit itérable lorsqu'il est possible de renvoyer un par un tous ses éléments. la syntaxe: "for x in l", la variable x prend successivement toutes les valeurs des éléments de l.
# Les objets itérables: les listes, les chaînes de caractères, les tuples, les "range", les ensembles, les dictionnaires.

l=['a','b', 'c']
s=range(len(l))
print(s)

## on peut écrire
for i in s: 
    print(l[i])
##On prefère
for lettre in l: 
    print(lettre)
   
   
##     

texte="vous avez de la chance!"
for lettre in texte:
    print(lettre)   
   
    
##un autre exemple: calcul de la norme de vecteurs de R2
from math import sqrt # la racine carrée 

vecteurs= [(0,1),(2,2),(2,3)]
for vect in vecteurs:
    norme=sqrt(vect[0]^2+vect[1]^2)
    print('norme=',norme)
   
# Ou sinon
vecteurs= [(0,1),(2,2),(2,3)]
for (x,y) in vecteurs:
    norme=sqrt(x^2+y^2)
    print('norme=',norme)
    
    
    
# LES EXERCICES A TRAITER. 
    
####################################################################
# Exercice 1: Ecrire un fonction "mini" qui renvoie le plus petit élément d'un liste.
#La tester sur une liste de couples, une chaîne de caractères.
####################################################################

####################################################################
# Exercice 2: Ecrire une fonction "bis" qui prend une chaîne de caractères et renvoie une chaîne avec chaque caractère 2 fois de suite
####################################################################


# Itérations avancées: Tester les blocks suivants (reverse , enumerate, zip,...)

l=[1,2,'a','b',4,'test']
l1=reversed(l)   
print(l,l1)
l1=list(l1)
print(l,l1)



####################################################################
# Exercice 3: Ecrire une fonction qui à une liste renvoie la liste renversée (sans utiliser "reversed")
####################################################################

# Enumerate : enumerate(l) est un itérateur paresseux qui renvoie les couples i, l[i](pour i variant de 0 à len(l)-1)

s='un test facile'
for c in enumerate(s):
    print(c)

for (i,x) in enumerate(s):
    print(x)

for (i,x) in enumerate(s):
    print(x,end='')
print()

####################################################################
# Exercice 4: Ecrire une fonction minind(l) qui renvoie le couple contenant le minimum de l et la liste des indices associées.
####################################################################


# l'itérateur zip

lettre=['a','b','c']
nbr=[1,2,3,4,5]

for x in zip(lettre, nbr):
    print(x)

####################################################################
# Exercice 5: 
#Ecrire une fonction moycoef(notes, coefs) qui prend une liste de notes et une liste de coefficients et renvoie la moyenne pondérée.
####################################################################



##################################
# Boucle While                   #
##################################

## premiers pas ....

i=0
while (i<10):
    i+=1
    print(i)
##    
i=1
u=1
while (u>10**(-5)):
    i+=1
    u/=10
print(i,u)
## le compteur i 
i=0
u=1.
while (u>10**(-5)):
    i+=1
    u/=2.
    
print(u,i)
print(i)
from math import *
print(floor((5*log(10)/log(2)))+1 )

##Pourquoi la valeur finale de i est-elle égale à la partie entière +1 de 5*log_2(10) ?

## un jeu de dé: 

from random import *
 
print(dir(Random))

print(randint(1,6))
print(random())
 

## un petit jeu
print('voulez-vous jouer au dés (le temps dattente dun 6)? o/n')
r=input()
if r=='n':
    print('a plus ... alors')
else:
    d=0
    i=0
    while (d<6):
        print('lance le dé')
        input()
        d=randint(1,6)
        i+=1
        if d==6:
            print('tu as obtenu un ', d, ' en ', i,' étapes')
        else:
            print('tu as obtenu un ', d)
 


##################################
# 3 - Compréhension              #
##################################
## Python permet de définir facilement des listes par «compréhension»

l=[3*i**2 + 1 for i in range(1,10)]
print(l)

l=[(i,j) for i in range(4) for j in range(i)]
print(l)

l=[[(i,j) for i in range(2)] for j in range(i)]
print(l)

l=[[(i,j) for j in range(i)] for i in range(2)]
print(l)


## On peut également filtrer 

l=[i for i in range(10) if i%2]
print(l)

l=[i if i%3 else 0 for i in range(10)]
print(l)

# Comment comprendre %2 ?
#il faut comprendre "if i%3" comme "if i%3 == 0". 
#En Python, toutes les valeurs sont comprises comme vrai sauf
#• la constante False
#• la constante None 
#•0
#• la liste vide []
#• le tuple vide ()
#• l’ensemble vide set() 
#• le dictionnaire vide {}

####################################################################
# Exercice 6:
    # -Ecrire une fonction imp(n) qui renvoie la liste des nombres impairs inférieur à n
    # -Calculer la somme des i**2 pour i inférieur à 100
    # -Déterminer la somme des i**j pour i, j vérifiant 0<i<=j<101
####################################################################    
     
     

##################################
# 4 - Exercices                  #
##################################

####################################################################
# Exercice 7: Ecrire une fonction qui à x et n renvoie x**n sans utiliser "**"
# Exercice 8: Ecrire des fonctions renvoyant la somme des éléments d'une liste et son maximum.
# Exercice 9: Ecrire une fonction calculant le n ième terme d'une suite arithmético-géométrique vérifiant u[n+1]=au[n]+b
# Exercice 10: Ecrire une fonction qui permet de savoir si un mot est dans une phrase.
####################################################################