In [1]:
print(type(42))
Suposons que l'on veux calculer l'aire d'un cercle $A=\pi.r^2$, où $r$ est le rayon, qui peux être variable et $\pi=3.14159$ pour simplifier.
In [2]:
pi=3.14159
r=11.2
A=pi*r**2
print("L'aire du disque de rayon {0} m, est A={1} m^2".format(r,A))
print("l'adresse du rayon est {0}, celle de l'aire est {1}".format(id(r),id(A)))
In [3]:
r=14.3
A=pi*r**2
######## On à changé le rayon
print("L aire du disque de rayon {0} m, est A={1} m^2".format(r,A))
print("l'adresse du rayon est {0}, celle de l'aire est {1}".format(id(r),id(A)))
Le contenant n'est rien d'autre que l'association par adressage, d'un nom et d'un pointeur vers le contennu, soit la valeur associé à ce nom. L'affectation est l'opération qui permet d'associer un contenu (opérande de droite) à un contennant (opérande de gauche) et donc d'associer un nom avec un pointeur vers une valeur. L'unique moyen de suprimer cette association entre contennu et contennant est de supprimer m'asociation entre le nom et le pointeur.
In [4]:
del(r)
r=15e-3
A=pi*r**2
print("L aire du disque de rayon {0} m, est A={1} m^2".format(r,A))
print("l'adresse du rayon est {0}, celle de l'aire est {1}".format(id(r),id(A)))
In [5]:
#Variables permetant la reafectation
a=(1,)
print("le Type de la variable a est {}".format(type(a)))
print("Son identifiant est {}".format(id(a)))
In [6]:
a+=(2,)
print("le Type de la variable a est {}".format(type(a)))
print("Son identifiant est {}".format(id(a)))
In [7]:
#Variables permetant le changement de place sans réaffectation
a=[1]
print("le Type de la variable a est {}".format(type(a)))
print("Son identifiant est {}".format(id(a)))
In [8]:
a+=[2]
print("le Type de la variable a est {}".format(type(a)))
print("Son identifiant est {}".format(id(a)))
In [12]:
# Ici on relance le Kernel, ce qui néttoie toute affectation
%reset
My_Variable_Number=42
globals()
Out[12]:
Certains blocs introduisent un nouvel espace de nomage
In [14]:
# On déclare une variable
My_Variable_Fetiche_Number=42
# Puis on cree une fonction ou cette même variable est déclarée
def f():
My_Variable_Fetiche_Number=4200000000000000000000
print('Dans la fonction la valeur de ma variable fétiche est {}'.format(My_Variable_Fetiche_Number))
# On execute la fonction
f()
# On veux savoir quelle est la valeur de la variable
print('La valeur de ma variable fétiche est {}'.format(My_Variable_Fetiche_Number))
In [15]:
# Here a function that prints something visual
# This function has no output variable
def do_twice(f):
"""
This function has a docstring
It executes twice the function f
The program it is used by functions:
- do_eight()
- print_posts()
- print_beams()
"""
f()
f()
def do_eight(f):
"""
Usage:
do_eight(function)
It executes eight times the passed function
Input:
The function f is passed as a variable
No global variables are passed
Local variables
No local variables are needed
Dependencies
The program it is used by functions:
-print_grid()
"""
do_twice(f)
do_twice(f)
do_twice(f)
do_twice(f)
def print_beam():
print('| - - - -',end=" "),
def print_post():
print('| ',end=" "),
def print_beams():
do_twice(print_beam)
print('|',end="\n")
def print_posts():
do_twice(print_post)
print('|',end="\n")
def print_row():
print_beams()
def print_grid():
print_row()
do_eight(print_posts)
Titre1='Premier'
Titre2='Second'
print('| '+Titre1+' | '+Titre2+' |')
print_grid()
| Premier | Second |
|---|---|
In [2]:
## On appelle de 'Doctring' de la fonction do_eight
##
help(do_eight)
In [ ]:
def My_function_scare_of_n(n):
n *= n
return n
#print(n)
n=5
Carre=My_function_scare_of_n(n)
print("Le carré de {0} est {1}".format(n,Carre))
In [ ]:
# Voici une fonction qui rend le carré de n
def My_function_scare_of_n(n):
square = n*n
return square
# Je l'execute
My_number_to_scare = 5
print("le resultat de {0} au carré est {1}" \
.format(My_number_to_scare,My_function_scare_of_n(My_number_to_scare)))
Attention return est indispensable pour que cette fonction rende quelque chose
In [ ]:
# Voici une fonction ne rend rien mais c'est prévu
# “Pass" means this method has not been implemented yet, but this will be the place to do it
def update_agent(agent):
s='Congratulate '+agent.upper()+' he doubles his salary'
return s
def time_step(agents):
for agent in agents:
s=update_agent(agent)
print('Case of Agent {}:'.format(agent))
print(s)
#On appelle cette fonction à l'intérieur
#Mais pour le moment je ne sais pas
#ce que je vais faire avec les agents
In [ ]:
agents=['bob','jim','joe']
time_step(agents)
In [ ]:
# Voici une fonction ne rend rien mais c'est une ERREUR DE PROGRAMMATION
# “Pass" means this method has not been implemented yet, but this will be the place to do it
def My_function(self):
My_Variable_Fetiche_Number=4200000000
print('La valeur de ma variable fétiche est {}'.format(My_Variable_Fetiche_Number))
In [1]:
import random
words = ['chicken', 'dog', 'cat', 'mouse', 'frog','horse','pig']
def pick_a_word():
word_position = random.randint(0, len(words) - 1)
return words[word_position]
word=pick_a_word()
print('The secret word is "{}" '.format(word))
In [ ]:
lives_remaining = 14 #this will become a global variable
guessed_letters = ''
# Here are the first STUBS
def get_guess(word):
pass
def process_guess(guess, word):
pass
###############################
def play():
word = pick_a_word()
while True:
guess = get_guess(word)
if process_guess(guess, word):
print('You win! Well Done!')
break
if lives_remaining == 0:
print('You are Hung!')
print('The word was: ' + word)
break
play()
In [2]:
import random
words = ['chicken', 'dog', 'cat', 'mouse', 'frog']
lives_remaining = 14
############A do-always-wrong STUB
def get_guess(word):
return 'a'
############################
def play():
word = pick_a_word()
while True:
guess = get_guess(word)
if process_guess(guess, word):
print('You win! Well Done!')
break
if lives_remaining == 0:
print('You are Hung!')
print('The word was: ' + word)
break
def pick_a_word():
word_position = random.randint(0, len(words) - 1)
return words[word_position]
def process_guess(guess, word):
global lives_remaining
lives_remaining = lives_remaining -1
return False
play()
###########
def print_word_with_blanks(word):
pass
###########
def get_guess(word):
print_word_with_blanks(word)
print('Lives Remaining: ' + str(lives_remaining))
guess = input(' Guess a letter or whole word?')
return guess
get_guess(word)
In [3]:
#04_06_hangman_get_guess
import random
words = ['chicken', 'dog', 'cat', 'mouse', 'frog']
lives_remaining = 14
def play():
word = pick_a_word()
while True:
guess = get_guess(word)
if process_guess(guess, word):
print('You win! Well Done!')
break
if lives_remaining == 0:
print('You are Hung!')
print('The word was: ' + word)
break
def pick_a_word():
word_position = random.randint(0, len(words) - 1)
return words[word_position]
def get_guess(word):
print_word_with_blanks(word)
print('Lives Remaining: ' + str(lives_remaining))
guess = input(' Guess a letter or whole word?')
return guess
def process_guess(guess, word):
global lives_remaining
lives_remaining = lives_remaining -1
return False
def print_word_with_blanks(word):
print('print_word_with_blanks: not done yet')
play()
In [4]:
guessed_letters=''
def print_word_with_blanks(word):
display_word = ''
for letter in word:
if guessed_letters.find(letter) > -1:
# letter found
display_word = display_word + letter
else:
# letter not found
display_word = display_word + '-'
print(display_word)
Pour le moment process_guess est toujours un stub
####### STUB
def single_letter_guess(guess, word):
pass
def whole_word_guess(guess, word):
pass
############
def process_guess(guess, word):
if len(guess) > 1 and len(guess) == len(word):
return whole_word_guess(guess, word)
else:
return single_letter_guess(guess, word)
In [5]:
#04_07_hangman_print_word
import random
words = ['chicken', 'dog', 'cat', 'mouse', 'frog']
lives_remaining = 14
guessed_letters = ''
def play():
word = pick_a_word()
while True:
guess = get_guess(word)
if process_guess(guess, word):
print('You win! Well Done!')
break
if lives_remaining == 0:
print('You are Hung!')
print('The word was: ' + word)
break
def pick_a_word():
word_position = random.randint(0, len(words) - 1)
return words[word_position]
def get_guess(word):
print_word_with_blanks(word)
print('Lives Remaining: ' + str(lives_remaining))
guess = input(' Guess a letter or whole word?')
return guess
def process_guess(guess, word):
global lives_remaining
global guessed_letters
lives_remaining = lives_remaining - 1
guessed_letters = guessed_letters + guess
return False
def print_word_with_blanks(word):
display_word = ''
for letter in word:
if guessed_letters.find(letter) > -1:
# letter found
display_word = display_word + letter
else:
# letter not found
display_word = display_word + '-'
print(display_word)
play()
On n'a pas encore gagné... et en plus on voudrait que le joueur puisse entrer une lettre ou un mot complet... On va maintenat ecrire les fonction single_letter_guess et whole_world_guess
In [6]:
def whole_word_guess(guess, word):
global lives_remaining
if guess.lower() == word.lower():
return True
else:
lives_remaining = lives_remaining - 1
return False
def single_letter_guess(guess, word):
global guessed_letters
global lives_remaining
if word.find(guess) == -1:
# letter guess was incorrect
lives_remaining = lives_remaining - 1
guessed_letters = guessed_letters + guess.lower()
if all_letters_guessed(word):
return True
return False
def all_letters_guessed(word):
for letter in word:
if guessed_letters.find(letter.lower()) == -1:
return False
return True
Maintenant le jeu est complet
In [8]:
#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
Created on Tue Sep 20 22:11:59 2016
"""
import random
words = ['chicken', 'dog', 'cat', 'mouse', 'frog']
lives_remaining = 14
guessed_letters = ''
def play():
word = pick_a_word()
while True:
guess = get_guess(word)
if process_guess(guess, word):
print('You win! Well Done!')
break
if lives_remaining == 0:
print('You are Hung!')
print('The word was: ' + word)
break
def pick_a_word():
word_position = random.randint(0, len(words) - 1)
return words[word_position]
def get_guess(word):
print_word_with_blanks(word)
print('Lives Remaining: ' + str(lives_remaining))
guess = input(' Guess a letter or whole word?')
return guess
def print_word_with_blanks(word):
display_word = ''
for letter in word:
if guessed_letters.find(letter) > -1:
# letter found
display_word = display_word + letter
else:
# letter not found
display_word = display_word + '-'
print(display_word)
def process_guess(guess, word):
if len(guess) > 1 and len(guess) == len(word):
return whole_word_guess(guess, word)
else:
return single_letter_guess(guess, word)
def whole_word_guess(guess, word):
global lives_remaining
if guess.lower() == word.lower():
return True
else:
lives_remaining = lives_remaining - 1
return False
def single_letter_guess(guess, word):
global guessed_letters
global lives_remaining
if word.find(guess) == -1:
# letter guess was incorrect
lives_remaining = lives_remaining - 1
guessed_letters = guessed_letters + guess.lower()
if all_letters_guessed(word):
return True
return False
def all_letters_guessed(word):
for letter in word:
if guessed_letters.find(letter.lower()) == -1:
return False
return True
play()
# Here a function that prints something visual
# This function has no output variable
def do_twice(f):
"""
Usage: It executes twice the function f
Inputs: It requires a function as argument
Links: The program it is used by functions:
- do_eight()
- print_posts()
- print_beams()
"""
f()
f()
def do_eight(f):
"""
This function has a docstring
It executes eight times the function
The program it is used by functions:
-print_grid()
"""
do_twice(f)
do_twice(f)
do_twice(f)
do_twice(f)
def print_beam():
print('| - - - -',end=" "),
def print_post():
print('| ',end=" "),
def print_beams():
do_twice(print_beam)
print('|',end="\n")
def print_posts():
do_twice(print_post)
print('|',end="\n")
def print_row():
print_beams()
def print_grid():
print_row()
do_eight(print_posts)
Titre1='Premier'
Titre2='Second'
print('| '+Titre1+' | '+Titre2+' |')
print_grid()
In [ ]: