COURS PYTHON

7 Septembre 2022

Le nombre de visite :

Essayer de programmer cette étoile ci-dessous :

##################################

# import for turtle

##################################
import turtle
##################################
# Starting a Working Screen
ws = turtle.Screen()

# initializing a turtle instance
geekyTurtle = turtle.Turtle()

# executing loop 5 times for a star
for i in range(10):

# moving turtle 100 units forward
geekyTurtle.forward(100)

# rotating turtle 144 degree right
geekyTurtle.right(108)

##################################

Flocon de Koch

from turtle import *

###################################
# Dessin de fractales

###################################
def Dessin(Chaine, n, x, X0, Y0):
for i in range(0,len(Chaine)):
if Chaine[i]=='A':
forward(n)
elif Chaine[i]=='+':
right(x)
elif Chaine[i]=='-':
left(x)

def Substitution(Chaine, regle):
#Cette fonction va remplacer 'A' dans la chaine par la regle.
C2=str()
#C2 sera la nouvelle chaine, notre sortie
for i in range(0,len(Chaine)):
if Chaine[i]=='A':
C2=C2+regle
elif Chaine[i]=="-":
C2=C2 + "-"
elif Chaine[i]=="+":
C2=C2 + "+"
return(C2)

def Fractale(Chaine, regle, n):
#Cette fonction sert a tracer des fractales a partir d'une chaine
C=Chaine
for k in range(0,n):
C=Substitution(C,regle)
Dessin(C,2,60,-200,0)

#################################

Fractale('A',"A-A++A-A", 5)

#################################

Essayer de programmer cette étoile ci-dessous :

##################################

# import for turtle
import turtle

# Starting a Working Screen
ws = turtle.Screen()

# initializing a turtle instance
geekyTurtle = turtle.Turtle()

# executing loop 5 times for a star
for i in range(10):

# moving turtle 100 units forward
geekyTurtle.forward(100)

# rotating turtle 144 degree right
geekyTurtle.right(108)

##################################

UN TRAITEMENT DE TEXTE PYTHON :

##################################

from tkinter import Tk, Text, Scrollbar, Menu, messagebox, filedialog, Frame

import os

##################################
class Editor:
def __init__(self, root):
self.root = root
self.TITLE = "Subedi Editor"
self.file_path = None
self.set_title()

frame = Frame(root)
self.yscrollbar = Scrollbar(frame, orient="vertical")
self.editor = Text(frame, yscrollcommand=self.yscrollbar.set)
self.editor.pack(side="left", fill="both", expand=1)
self.editor.config(wrap="word", # use word wrapping
undo=True, # Tk 8.4
width=80)
self.editor.focus()
self.yscrollbar.pack(side="right", fill="y")
self.yscrollbar.config(command=self.editor.yview)
frame.pack(fill="both", expand=1)

# instead of closing the window, execute a function
root.protocol("WM_DELETE_WINDOW", self.file_quit)

# create a top level menu
self.menubar = Menu(root)
# Menu item File
filemenu = Menu(self.menubar, tearoff=0) # tearoff = 0 => can't be seperated from window
filemenu.add_command(label="New", underline=1, command=self.file_new, accelerator="Ctrl+N")
filemenu.add_command(label="Open...", underline=1, command=self.file_open, accelerator="Ctrl+O")
filemenu.add_command(label="Save", underline=1, command=self.file_save, accelerator="Ctrl+S")
filemenu.add_command(label="Save As...", underline=5, command=self.file_save_as, accelerator="Ctrl+Alt+S")
filemenu.add_separator()
filemenu.add_command(label="Exit", underline=2, command=self.file_quit, accelerator="Alt+F4")
self.menubar.add_cascade(label="File", underline=0, menu=filemenu)
# display the menu
root.config(menu=self.menubar)

def save_if_modified(self, event=None):
if self.editor.edit_modified(): # modified
response = messagebox.askyesnocancel("Save?",
"This document has been modified. Do you want to save changes?") # yes = True, no = False, cancel = None
if response: # yes/save
result = self.file_save()
if result == "saved": # saved
return True
else: # save cancelled
return None
else:
return response # None = cancel/abort, False = no/discard
else: # not modified
return True

def file_new(self, event=None):
result = self.save_if_modified()
if result != None: # None => Aborted or Save cancelled, False => Discarded, True = Saved or Not modified
self.editor.delete(1.0, "end")
self.editor.edit_modified(False)
self.editor.edit_reset()
self.file_path = None
self.set_title()

def file_open(self, event=None, filepath=None):
result = self.save_if_modified()
if result != None: # None => Aborted or Save cancelled, False => Discarded, True = Saved or Not modified
if filepath == None:
filepath = filedialog.askopenfilename()
if filepath != None and filepath != '':
with open(filepath, encoding="utf-8") as f:
fileContents = f.read() # Get all the text from file.
# Set current text to file contents
self.editor.delete(1.0, "end")
self.editor.insert(1.0, fileContents)
self.editor.edit_modified(False)
self.file_path = filepath

def file_save(self, event=None):
if self.file_path == None:
result = self.file_save_as()
else:
result = self.file_save_as(filepath=self.file_path)
return result

def file_save_as(self, event=None, filepath=None):
if filepath == None:
filepath = filedialog.asksaveasfilename(filetypes=(
('Text files', '*.txt'), ('Python files', '*.py *.pyw'), ('All files', '*.*'))) # defaultextension='.txt'
try:
with open(filepath, 'wb') as f:
text = self.editor.get(1.0, "end-1c")
f.write(bytes(text, 'UTF-8'))
self.editor.edit_modified(False)
self.file_path = filepath
self.set_title()
return "saved"
except FileNotFoundError:
print('FileNotFoundError')
return "cancelled"

def file_quit(self, event=None):
result = self.save_if_modified()
if result != None: # None => Aborted or Save cancelled, False => Discarded, True = Saved or Not modified
self.root.destroy() # sys.exit(0)

def set_title(self, event=None):
if self.file_path != None:
title = os.path.basename(self.file_path)
else:
title = "Untitled"
self.root.title(title + " - " + self.TITLE)

def undo(self, event=None):
self.editor.edit_undo()

def redo(self, event=None):
self.editor.edit_redo()

##################################

def bind_keys(self, event=None):
self.editor.bind("<Control-o>", self.file_open)
self.editor.bind("<Control-O>", self.file_open)
self.editor.bind("<Control-S>", self.file_save)
self.editor.bind("<Control-s>", self.file_save)
self.editor.bind("<Control-N>", self.file_new)
self.editor.bind("<Control-n>", self.file_new)
self.editor.bind("<Control-y>", self.redo)
self.editor.bind("<Control-Y>", self.redo)
self.editor.bind("<Control-Z>", self.undo)
self.editor.bind("<Control-z>", self.undo)

##################################
if __name__ == "__main__":
main = Tk()
# root.wm_state('zoomed')
editor = Editor(main)
editor.bind_keys()
main.mainloop()

L'art

lES MENUS ET LES BOUTONS EN PYTHON. CALCULETTE PYTHON

Expression fonctionnelle entre le nombre d’or et la suite de Fibonacci:Modifier

Le calcul du $n$ -ième terme de la suite de Fibonacci via la formule de récurrence requiert le calcul des termes précédents. Au contraire, une expression fonctionnelle de la suite de Fibonacci est une expression où le calcul du $n$ -ième terme ne présuppose pas la connaissance des termes précédents. Binet a redécouvert une formule en 1843^{[réf. nécessaire]}, qui avait déjà été obtenue par de Moivre^{[réf. nécessaire]} en 1718 et par Euler en 1765^[4]. Cette expression fonctionnelle s'appelle la formule de Binet :

F_{n}={\frac {1}{\sqrt {5}}}(\varphi ^{n}-\varphi '^{n}),\qquad {\text{avec}}\qquad \varphi ={\frac {1+{\sqrt {5}}}{2}}\qquad {\text{et}}\qquad \varphi '={\frac {1-{\sqrt {5}}}{2}}=-{\frac {1}{\varphi }}.

Démonstration

Comme la suite de Fibonacci est linéairement récurrente d’ordre 2, son équation caractéristique est une équation du second degré :

x^{2}-x-1=0

dont les deux solutions sont :

\varphi ={\frac {1+{\sqrt {5}}}{2}}\qquad {\text{et}}\qquad \varphi '=-{\frac {1}{\varphi }}={\frac {1-{\sqrt {5}}}{2}}

où $φ$ est le nombre d'or. Les suites $(φ n)$ et $(φ' n)$ engendrent alors l'espace vectoriel des suites vérifiant $u n + 2 = u n + 1 + u n$ . Il en résulte que :

F_{n}=\alpha {}\varphi ^{n}+\beta \varphi '^{n}

F_{0}

F_1

Les conditions initiales $F_{0}=0$ et $F_{1}=1$ conduisent au système suivant :

\left\{{\begin{matrix}\alpha +\beta =0\\\alpha -\beta ={\frac {2}{\sqrt {5}}}\end{matrix}}\right.

On obtient alors :

\alpha ={\frac {1}{\sqrt {5}}}\qquad {\text{et}}\qquad \beta =-{\frac {1}{\sqrt {5}}}.

Nous obtenons finalement l'expression fonctionnelle recherchée.

(Ces calculs restent valables pour $n$ entier négatif quand la suite est prolongée comme ci-dessous.)

Quand $n$ tend vers $+\infty$ , $F_{n}$ est équivalent à ${\frac {\varphi ^{n}}{\sqrt {5}}}$ . Plus précisément, $φ n$ tend vers l'infini et $φ' n$ tend vers zéro car $|\varphi '|<1<\varphi$ .

La suite de Fibonacci comme limite d une fraction du nombre d’or

(Ces calculs restent valables pour $n$ entier négatif quand la suite est prolongée comme ci-dessous.)

Quand $n$ tend vers $+\infty$ , $F_{n}$ est équivalent à ${\frac {\varphi ^{n}}{\sqrt {5}}}$ . Plus précisément, $φ n$ tend vers l'infini et $φ' n$ tend vers zéro car $|\varphi '|<1<\varphi$ .

En fait, dès le rang $n = 1$ , le deuxième terme ${\varphi '^{n} \over {\sqrt {5}}}$ est assez petit pour que les nombres de Fibonacci puissent être obtenus uniquement à partir du premier terme :

F_{n}

Est l’entier le plus proche de

{\frac {\varphi ^{n}}{\sqrt {5}}}

Comme l'avait déjà remarqué Johannes Kepler^[6], le taux de croissance des nombres de Fibonacci, c'est-à-dire ${\frac {F_{n+1}}{F_{n}}}$ , converge vers le nombre d'or $φ$ .

En effet, puisque la suite $F_{n}$ est équivalente à ${\frac {\varphi ^{n}}{\sqrt {5}}}$ (cf. supra, section Expression fonctionnelle), la suite ${\frac {F_{n+1}}{F_{n}}}$ est équivalente à ${\frac {\frac {\varphi ^{n+1}}{\sqrt {5}}}{\frac {\varphi ^{n}}{\sqrt {5}}}}=\varphi ,$ qui est donc sa limite.

La suite de Fibonacci et les matrices :

Il existe d'autres démonstrations de la formule de Binet, telles que la transformation en Z et la technique des fonctions génératrices.

Remarquons qu'une fois découverte, cette formule se démontre aussi par récurrence (y compris pour $n$ entier négatif).

un autre manière de défit la suite de Finobacci matricielle ment est la suivante :

On a la relation de récurrence suivante : ${\begin{pmatrix}F_{n}\\F_{n+1}\end{pmatrix}}={\begin{pmatrix}0&1\\1&1\end{pmatrix}}{\begin{pmatrix}F_{n-1}\\F_{n}\end{pmatrix}}$ et donc ${\begin{pmatrix}F_{n}\\F_{n+1}\end{pmatrix}}={\begin{pmatrix}0&1\\1&1\end{pmatrix}}^{n}{\begin{pmatrix}F_{0}\\F_{1}\end{pmatrix}}$

Plusieurs formules existent notamment celle des nombres de Lucas ou par leur fonction génératrice :

Série génératriceModifier

La série génératrice de la suite de Fibonacci donne une série entière dont le rayon de convergence vaut 1/ $φ$ (d'après le théorème de Cauchy-Hadamard ou plus simplement, la règle de d'Alembert). Pour tout complexe z de module strictement inférieur à $1/ φ$ , la sériecorrespondante (absolument convergente) est égale à : $\sum _{n\in \mathbb {N} }F_{n}z^{n}={\frac {z}{1-z-z^{2}}}$

(donc à $z\sum _{m\in \mathbb {N} }(z+z^{2})^{m}=\sum _{m,k\in \mathbb {N} }{m \choose k}z^{1+m+k}$ , où les coefficients binomiaux $m \choose k$ sont nuls pour $k > m$ ).

Le triangle de Pascal et la suite de Fibonacci :

Propriété : $\forall n\in \mathbb {N} ,~F_{n}=\sum _{k\in \mathbb {Z} }{n-1-k \choose k}$ (somme finie car les coefficients binomiaux ${n-1-k \choose k}$ sont nuls si $k < 0$ ou si $k > n - 1 - k$ ).

Cette propriété se déduit immédiatement de l'expression de la série génératrice (voir supra). On peut aussi la démontrer par une récurrence d'ordre 2 sur $n$ .

ce qui signifie que dans Cela signifie que, dans un triangle de Pascal, les nombres de Fibonacci s'obtiennent en sommant les termes situés sur une diagonale (du bas vers la droite)

via RSS

#Dessins 1