WELCOME

Bienvenue dans mon site qui parlera essentiellement de NSI.

By Salma

CHAPITRE 1: Représentation de chiffre
1/compter en base 10 ,16 ou 2

Cours:

Conversion de nombre binaire en décimal

EX: 77(10) = 1001101

2/ coder 0,125 en binaire. Entiere Decimal

0 , 125*2. 0 0,250

0,250*2. 0 0,500

0,500*2 1 0

0,125(10)=001(2)

4/moyenne en python

En Python, nous pouvons trouver la moyenne d'une liste en utilisant simplement les fonctions sum() et len() .

5/ Tuple

a=(1,2,3). d=( 'a', 3, True, 3 . 23)

b=(1.23,5.65,9.87). e=([ 1,2,3 ],[ 2,4,5])

C=('a','b','c'). c=[ 0 ]

Dans un tuple on peut mettre des entiers , des bouleins , des chaines flottants.

EXEMPLE D'EXERCICE:
EXO 1:Combien de nombre entiers positifs peut-on coder en bin aire sur 4 bits ?
A- 4
B- 16
C- 64
D- 256
La bonne réponse est la réponse B car 2 puissance 4 (car 4 bits) équivaut a 16.

EXO 2:Quelle est l'écriture en hexadécimal (base 16) du nombre entier positif qui s'écrit 1110 1101 en base 2 ?
A- DE

B- ED

C- EDF

D-FEFD

Lorsque l'on regarde dans le tableau des bases de 10 et 16 nous voyons bien que

E= 1110 et D=1101

donc le la bonne réponse et la question B

LA POPULARITÉ D'UN SITE WEB:

import random

PageWeb=

[ "A" , "B" , "C" , "D" , "E" , "F"]

Hypertexte={ }

Hypertexte[ "A" ]=[ "B" , "C" , "D" ]

Hypertexte[ "B" ]=["C"]

Hypertexte[ "C" ]=[ "A", "E" , "D" ]

Hypertexte[ "D" ]=[ "A" , "B" , "C" , "D" , "E" , "F" ]

Hypertexte[ "E" ]=[ "F" , "C" , "D" ]

Hypertexte[ "F" ]=[ "E" , "D" ]

Nb_clic={ }

Nb_clic[ "A" ]=0

Nb_clic[ "B" ]=0

Nb_clic[ "C" ]=0

Nb_clic[ "D" ]=0

Nb_clic[ "E" ]=0

Nb_clic[ "F" ]=0

Total_clic=0

for i in range(1,100):

X=random.choice(PageWeb)

Nb_clic[ X ]=Nb_clic[ X ]+1

X=random.choice(Hypertexte[ X ])

for X in (PageWeb):

print("de" , X , " :" , Nb_clic , " clics")

for i in range(1,1000):

X=random.choice(PageWeb)

while random.random ()< 0.80:

Nb_clic[ X ]=Nb_clic[ X ]+1

Total_clic=Total_clic+1

X=random.choice(Hypertexte[ X ])

for X in (PageWeb):

print("de" ,X, ":" ,Nb_clic, "clics")

Exemple de codage python:

conversion_table = {0: '0', 1: '1', 2: '2', 3: '3', 4: '4',
5: '5', 6: '6', 7: '7',
8: '8', 9: '9', 10: 'A', 11: 'B', 12: 'C',
13: 'D', 14: 'E', 15: 'F'}

# function which converts decimal value
# to hexadecimal value
def decimalToHexadecimal(decimal):
hexadecimal = ''
while(decimal > 0):
remainder = decimal % 16
hexadecimal = conversion_table[remainder] + hexadecimal
decimal = decimal // 16

return hexadecimal

decimal_number = 255
print("The hexadecimal form of", decimal_number,
"is", decimalToHexadecimal(decimal_number))

Trouver le score minimum et maximum:

def score_minimum(score)
min=score[ 0 ]

for element in score :

if element < = min :

min = element

return min #Retourner à min#
print("le score minimum est",score_minimum (score)

def score_maximum(score):

max=score[ 0 ]

for element in score :
if element >=max:
max=element

return max #Retourner à min#
print("le score maximum est",score_maximum(score))

PROJET 1: NOTATION PIX
Utilisateur qui choisit la moyenne:
Moyenne_choisie=
int(input("choisir la moyenne:"))
print(Moyenne_choisie)

Voici comment faire une fonction donnant la moyenne:
def Moyenne(score):
#definir une fonction appelé Moyenne#
return sum(score) / len(score)
#la somme de la liste divisé par le nombre d'éléments #
score=[ 100 , 300 , 600]
#donner le score de chacun en liste#
moyenne=Moyenne(score)
#dire à la fonction moyenne qui a pour paramètre score#
print("la moyenne est",round(moyenne,2))
donner la moyenne arrondie

Score minimum:
score=[ 167,89,344 ]
#exemple#
def score_maximum(score):
min=score[ 0]
for element in score:
if element< =min:
min=element
return min#retourner à min#
print("le score minimum est" , score_minimum (score))

Score maximum:
score=[ 234,123,543]
#exemple#
def score_maximum(score):
max=score[ 0]
for element in score:
if element >=max:
max=element
return max
print("le score maximums" , score_maximum(score))

Ensuite:
score=[ 303,480,600,312,378,473,288,301,371,230,149,265,243,236]
prenom=[ "Maxence" , "Dina" , "Enzo" ,"Fantine" , "Gabin" , "Salma" , "Lila" , "Joseph" , "Alexandre" , "Lilou"]
note_20=[ 12,23,32,42,34,23,12,12,54,6,94,12,34,54]
for i in range(0,14,1):
X=score[ i]
y=note_20[i]
print("Le score",X,"est celui de", prenom[i],"est correspond à",y,"sur 20")

PROJET 2:
n=[ ] #
p=[ ]
r=[ ]

c= False
for i in range( ):
a=n[ i]
b=p[ i]
unite=(a and not(b) and not(c)) or \
(not(a) and b and not(c)) or \
(not(a) and not(b) and (c) or \
(a and b and c)
r=[ int(unite)]=r
c=(a and b) or (b and c) or (a and c)
r= +r

print(r)

a="11010010"
b="00110011"

sum=bin(int(a,2)+int(b,2))

print(sum[ 2:])
print(sum)

n=[ 1,1,0,1,0,0,1,0]
p=[ 0,0,1,1,0,0,1,1]
print(n[ i])

score=[ 303,480,600,312,288,301,371,230,149,265,243,236]
prenom=[ "Maxence" , "Dina" , "Enzo" , "Fantine", "Gabin" , "Léo" , Mathis","Melvyn", "Salma" , "Lila","Joseph" , "Alexandre", "Lilou"]

for i in range(0,13,1):
X=score[ i]
print("Le score",X,"est celui de" , prenom[ i])

Programme python trie a l'aide de sort et sorted:

# pour mesurer des durées d'exécution
from time import *
import random
import matplotlib.pyplot as plt
import numpy as np
# liste initiale générée aléatoirement :

resultats_sort=[]
resultats_sorted=[]
n_liste=[]

def creation_de_liste():
liste = []
n_liste.append(i100000)
for k in range(i100000):
   liste.append(random.randint(0,100))
return liste

# tri par la fonction sorted()

def duree_tri_sort(liste):
t1=time()
liste.sort()
t2=time()
duree=t2-t1
resultats_sort.append(duree)
random.shuffle(liste)

def duree_tri_sorted(liste):
t1=time()
liste_triee=sorted(liste)
t2=time()
duree=t2-t1
resultats_sorted.append(duree)
print("duree du tri",duree)

for i in range(1,11):
print(i)
L= creation_de_liste()
duree_tri_sort(L)
duree_tri_sorted(L)
print(resultats_sort,resultats_sorted)

def tracer_figure(listesort,listesorted , nliste):
plt.figure(figsize = (16, 10))
plt.plot(nliste, listesort,"o", color ='green',label='sort', marker = "+")
plt.plot(nliste, listesorted,"o",color="blue",label='sorted',marker="x")
plt.xlabel('n')
plt.ylabel('Durée')
plt.title("Durée versus n")
plt.legend()
plt.grid(True)
plt.show()

tracer_figure(resultats_sort,resultats_sorted,n_liste)
Les étourderies a éviter qui fausse le programme:
les mots mal écrient peuvent ne pas faire fonctionner le programme, voici quelques erreurs de ma part:
retun=return
resutats=resultats
les paramètres à ne pas oublier, car le programme ne fonctionnera pas. Voici quelques erreurs de ma part:
return tri_rapide(left) + equal + tri_rapide = return tri_rapide(left) + equal + tri_rapide(right)
resultats_tri_rapide.append = resultats_tri_rapide.append(duree)
Au debut je ne comprenais pas pourquoi mon programme ne fonctionné pas , puis en me relisant bien attentivement j'ai remarqué mes étourderies.
Pour moi la partie qui a était le plus dure est lorsque l'on devait faire fonctionner les fonctions J'ai ecrit 10 fonctions en tous, mais seulement 3 ont fonctionné. La fonction tri sort , tri sorted et tri rapide. Apres avoir réussi le programme , il est sensé vous donnez un graphique ou l'on voit 3 fonctions dans un tableau:

puis grâce au programme ci dessous , j'ai pu relier ces points :





tri sort:

   Tri sorted:

Tri rapide:

Dans un premier temps, il faut importer des modules qui ne sont pas les fonctions de base de python. C'est à dire une bibliotheque pour calculer le temps, une autre pour des fonction mathematique"matplotlib.pyplot"et enfin une derniere pour afficher un graphique.

Il faut ensuite créer des listes videos pour les resultats des tris.

Definition de la fonction CREATION_DE_LISTE.Pour k , la fonction LISTE.APPEND va prendre en parametre RAMDOM.RANDINT qui va mélanger les nombres de 0 à 99

j'ai nommé et coloré chaque fonction pour les reconnaitrent dans le graphique , grace au tracer figure.

j'ai trié la liste en fonction du premier élément de chaque liste interne.

la fonction sorted(), renvoie une liste triée de l'objet itérable spécifié

Le tri rapide est un algorithme de division et de conquête. Le tri rapide sélectionne un élément comme pivot et ensuite divise le tableau autour du pivot en mettant les éléments plus petits que le pivot dans un tableau et les éléments plus grands que le pivot dans un autre tableau. Si le tableau contient des éléments en double, alors les éléments égaux au pivot peuvent être placés dans le troisième sous-tableau ou dans l’un des deux sous-tableaux selon l’implémentation de l’algorithme. Le tableau est trié par tri rapide en triant les sous-tableaux par appel récursif.

CONCLUSION

Nous pouvons remarquer que la durée du temps d'exclusion de sorted et sort sont les memes. Or la durée de fonctionnement du tri rapide est plus rapide et ses points ne sont pas alignés. Les tries sont tellement rapide qu'ils semblent tous etre à 0.Nous pouvons ausssi remarquer pour les listes a moins de milles élements vont plus vite.

TROISIEME PROJET: K PLUS PROCHE VOISIN

Dans ce projet , nous avons cherché a déterminer si la fleur est une Sétosa , une Virgina ou un Versicolor. Pour cela, à l'aide d'un fichier "Iris" qui contient les données des fleurs(la longueur, la largeur et l’espèce),nous avons crée un algorithme permettant d'ouvrir le fichier Iris et de prendre toutes les données pour detreminer la catégorie d'une nouvelle plante qui n'est pas encore identifiée.

Cours:
Il existe plusieurs sortes de tries. Pour commencer nous avons le tri a bulle dont le but est de comparer deux element cote à cote de la liste et les interverties si nécessaire .
Le tri par selection a pour but de sélectionner dans une liste le minimum et on le place au debut . Puis dans la liste restante, sélectionner le minimum et le mettre au debut de la liste restante.
Le tri par insertion a pour but de trier une liste deja trier au depart et puis insérer l'element suivant a sa place dans la liste.
Le tri par fusion a pour but de trier des sous listes de deux elements , puis de les fusionner avec les listes voisines jusqu'a ce que l'ensemble de la liste soit trié.

TITANIC

Ce programme fait l'objet d’étude du Titanic. Grace a ce programme nous pourrons déduire la quantité de survivants ou de mort étant soit des hommes ou des femmes, âgées ou pas âgée, ayant une familles ou sans famille . Nous pourrons aussi savoir si il y avait plus de survivant ou de mort en 1er, 2sd ou 3e classe, si le prix du billet compter pour survivre.
explication du programme:

Sur cet histogramme on voit que les personnes âgées de 0 à 10 ans sont la tranche d'age pour laquelle il y a le plus de survivants et pour laquelle les survivants dépassent les victimes . Au contraire la catégorie des 20 ans et des 30ans sont celles qui comptent le plus de victimes car ce sont des catégories qui sont pas privilégiées pour être sauvées . Plus les personnes sont âgées et plus la différence entre les victimes et les survivants diminue.

La classe qui compte le plus de vivants et le moins de victimes est la première classe.

Le prix pour un billet influe aussi sur la chance de survie car plus le billet est cher , plus le passager à de la chance de survivre. En effet, sur cet histogramme on voit que les personnes qui n'ont payé leurs billet que quelques dizaines d'euros sont plus de la moitié des morts.

Dans la colonne de gauches , nous pouvons voir qu'il y avait plus de survivantes femmes et enfants car ils étaient privilégié par rapport au hommes.

Grand projet: Solde bancaire

Séance 1: J'ai essayé de trouver un programme accessible pour moi. J'ai choisie de réalisé est un compte bancaire à contrôle de solde. Il permet d’entrer son nom et son mot de passe pour accéder au compte bancaire. Un mot de passe autre que celui enregistré renverra vers une erreur. Cette idée est du site qui se nomme NSI.XYZ .
Séance 2: J'ai commencé par réecrire ces lignes de code que le site avait donner pour nous aider :

r = int(intput("combien voulez vous créditer? \n"))
sf = sd + r
print("Votre solde est de", sf, "euros.")
dep = int(input("Combien voulez-vous debiter? \n"))
sf = sd - dep
if sf < 0 :
print("Votre solde est de", sf,"euros.")
print("Compte à découvert")
print("Votre solde est de", sf*1.18,"$")
print("Votre solde est de", sf*124.4,"JPY.")
print("Votre solde est de", sf*1.10,"GPT.")
print("Votre solde est de", sf,"euros.")

Séance 3: Apres avoir executé le programme , c'est lignes de code n'ont pas fonctionné.

Séance 4 :après avoir relu mon programme , j'ai décidé de définir "sd" et de remplacer tous les "sf" par des "sd".

Ce qui ma donné cela:

Séance 5 :Après exécution du programme, python me demande le nombre d'argent que je veux créditer ainsi que le nombre que je souhaite débiter, grâce au code ci-dessous.

Python après avoir exécuté ce programme ,me donne mon solde après créditer et débiter les sommes ci-dessous :

Séance 6 :

Après réflexion , j'ai décider de rajouter une fonction pour pouvoir avoir un plafond a ne pas dépasser chaque mois . Pour cela je vais avoir besoin d'une fonction "while" au début de mon programme.

Séance 7 :

Aujourd'hui, grâce au professeur qui m'a aider, j'ai réussie a trouver la fonction ideal pour pouvoir avoir un plafond . Voici le programme en question ci-dessous:

Séance 8 :

Aujourd'hui j'ai finalisé mon programme . En voici une capture: