# data[].attributes.attachment_link.readable_text
import matplotlib.pyplot as plt
from numpy import log10, arange
Vb = [ , , ,  , , ] # en L
pH = [ , , , , , ]
R=[]
for i in Vb :
    R.append(log10(*i/(/*i)))
plt.title('Courbe pH en fonction de R')
plt.xlabel('R')
plt.ylabel('pH')
plt.axis(xmin=-0.5,xmax=0.5,ymin=3,ymax=4.5)
plt.xticks(arange(-0.5,0.6,0.1))
plt.yticks(arange(3,4.6,0.1))
plt.grid(linestyle="-.")
plt.plot(R, pH, 'ro')
plt.show()

# data[].attributes.attachment_link.readable_text
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit
import numpy as np

'''---------------- VOS MESURES ----------------'''
t = np.array([  0  ,    10,    20,   30,    40,     50,    60,    70,    80,    90,    100,    110,   120,    130,    140]) # temps mesur�� en seconde
uc = np.array([ 0.0,      ,      ,     ,      ,       ,      ,      ,      ,      ,       ,       ,      ,       ,       ]) # tension aux bornes du condensateur en V


'''---------------- MODELISATION ---------------'''
def modelecharge(t, E, tau):
    return E * (1 - np.exp(-t / tau))


E_init = uc[-1]
tau_init =XXX
popt, pcov = curve_fit(modelecharge, t, uc, p0=[E_init, tau_init])
E, tau = popt

# Cr��er un tableau
t_modele = np.linspace(0, t.max(), 500)  # 500 points entre 0 et 140
y = modelecharge(t_modele, *popt)

# ---------- Valeurs utiles ----------
uc_final = np.ceil(uc[-1] * 10) / 10  # asymptote (arrondie)
uc_tau = XXX * E                    # valeur �� tau

'''---------------- GRAPHE ---------------------'''
fig, ax = plt.subplots(figsize=(10, 7))

ax.plot(t, uc, marker='+', linestyle='', label='Mesures', zorder=4, markersize=10, markeredgewidth=2) # donn��es
ax.plot(t_modele, y, 'r-', label='Mod��lisation de $u_c(t)$', zorder=3, linewidth=2) # mod��le LISSE

ax.axhline(uc_final, color='blue', linestyle='-', label='Tension aux bornes du g��n��rateur', zorder=2) # asymptote

# tangente (pente correcte �� l'origine = E/tau)
t_tangente = np.linspace(0, 1.3 * tau, 100)
tangente = (E / tau) * t_tangente
ax.plot(t_tangente, tangente, color='green', label='Tangente �� l\'origine', zorder=3)


# ---------- Axes "fl��ches" ----------
x_pad = 0.08 * t.max()
y_pad = 0.18 * uc_final
x_left, x_right = -x_pad, t.max() + x_pad
y_bottom, y_top = -0.08 * uc_final, uc_final + y_pad

ax.set_xlim(x_left, x_right)
ax.set_ylim(y_bottom, y_top)

for sp in ['top', 'right', 'left', 'bottom']:
    ax.spines[sp].set_visible(False)

# fl��ches des axes
ax.annotate('', xy=(x_right, 0), xytext=(x_left, 0),
            arrowprops=dict(arrowstyle='->', linewidth=1.5), clip_on=False, zorder=10)
ax.annotate('', xy=(0, y_top), xytext=(0, y_bottom),
            arrowprops=dict(arrowstyle='->', linewidth=1.5), clip_on=False, zorder=10)

# ---------- Graduations personnalis��es ----------
x_ticks = np.arange(0, 150, 20)
y_ticks = np.arange(0, 14, 2)

# Graduations sur l'axe des x
for x_val in x_ticks:
    if x_val > 0:
        ax.plot([x_val, x_val], [0, 0.3], 'black', linewidth=1.5, zorder=10)
        ax.text(x_val, -0.2, str(int(x_val)), ha='center', va='top', fontsize=10)

# Graduations sur l'axe des y
for y_val in y_ticks:
    if y_val > 0:
        ax.plot([0, 2], [y_val, y_val], 'black', linewidth=1.5, zorder=10)
        ax.text(-1.5, y_val, str(int(y_val)), ha='right', va='center', fontsize=10)

ax.set_xticks([])
ax.set_yticks([])

# ---------- Labels et annotations ----------
ax.annotate('0', xy=(0, 0), xytext=(-6, -6), textcoords='offset points',ha='right', va='top', fontsize=10)

ax.annotate(r'$t$ (s)', xy=(x_right, 0), xytext=(5, -10),textcoords='offset points', ha='center', va='top', fontsize=12)
ax.annotate(r'$u_c$ (V)', xy=(0, y_top), xytext=(-30, 5),textcoords='offset points', ha='left', va='bottom', rotation=0, fontsize=12)

ax.set_title('Evolution de la tension aux bornes du condensateur au cours du temps')

# ---------- Grille personnalis��e ----------
for x_val in x_ticks:
    if x_val > 0 and x_val <= t.max():
        ax.plot([x_val, x_val], [0, y_top], 'lightgray', linewidth=0.5, zorder=1)

for y_val in y_ticks:
    if y_val > 0 and y_val <= uc_final:
        ax.plot([0, x_right], [y_val, y_val], 'lightgray', linewidth=0.5, zorder=1)

ax.legend(loc='lower right', bbox_to_anchor=(0.95, 0.32))
plt.show()

# data[].attributes.attachment_link.readable_text
import matplotlib.pyplot as plt
import numpy as np

def navant(i):
    V.append(i)
    n_Ag.append((0.1*10-0.14*i)*0.001)
    n_Cl.append(0)
    n_Na.append(0.14*i*0.001)
    n_AgCl.append(0.14*i*0.001)
    n_NO3.append(1.0e-3)

def  napres(i) :
     V.append(i)
     n_Ag.append(0)
     n_Cl.append((0.14*i-0.1*10)*0.001)
     n_Na.append(0.14*i*0.001)
     n_AgCl.append(0.001)
     n_NO3.append(1.0e-3)

VE = 7.1 #saisie du volume ��quivalent en mL
Veau = 0 #saisie du volume d���eau ajout�� en mL
n_Ag, n_Cl, n_Na, n_AgCl,n_NO3, V = [], [], [], [], [] , []# initialisation de 6 listes
for i in np.arange(0,12,0.5) :
    if i <= VE :
        #appelle une fonction qui calcule les quantit��s avant et �� l�����quivalence
        navant(i)
    else :
        #appelle une fonction qui calcule les quantit��s apr��s l�����quivalence
        napres(i)
# Expression de la conductivit��
Conduct = 10*(6.19*np.array(n_Ag)+5.0*np.array(n_Na)+7.63*np.array(n_Cl) + 7.14*np.array(n_NO3))/(Veau*1E-3+1E-3*np.array(V)+0.010)
# affichage des courbes
plt.subplot(121) # subplot permet d���af���cher deux graphes
plt.plot(V, n_Ag,'bx-', linewidth=0.5, label="n_Ag")
plt.plot(V, n_Cl, 'rx-', label="n_Cl")
plt.plot(V, n_Na, 'mx-', label="n_NA")
plt.plot(V, n_AgCl, 'gx-', label="n_AgCl")
plt.plot(V, n_NO3, 'g+:', label="n_NO3")

plt.legend()
plt.subplot(122)
plt.scatter(V, Conduct, label="Conductivit�� en $\mathrm{mS\cdot cm^{-1}}$")
#plt.ylim(0,2.8)
plt.grid()
plt.legend()

plt.show()

# data[].attributes.attachment_link.title
CORRIGETP Interferences sonores et lumineuses(2) (3)

# data[].attributes.attachment_link.readable_text
���# Cr���� par noel, le 10/09/2025 en Python 3.4
# Influence du d��phasage sur l'��tat vibratoire d'un point
from matplotlib import pyplot as plt
from math import pi
import numpy as np

T=3  # p��riode en ms entre 1 et 3
t=np.linspace(0,8,800)  # tableau de valeurs
A1= ...   # amplitude du signal 1 en P entre 1 et 2
A2= ...   # amplitude du signal 2 en Pentre 1 et 2
phi= ...    # �� choisir
S1=....*np.cos(2*pi*...+phi)
S2 =....*np.cos(2*pi*...)   #remplacer les points
S=S1+S2
plt.plot(t,S1,label='S1')
plt.plot(t,S2,label='S2')
plt.plot(t,S,label='S')
plt.xlim(0,8)
plt.ylim(-3,3)
plt.show()

# data[].attributes.attachment_link.title
dismutationdu thiosulfate en fct de temp

# data[].attributes.attachment_link.readable_text
import numpy as np
import numpy.polynomial.polynomial as nppol# pour le polyn��me
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker # pour le format des ��tiquettes en x (remplacer le point d��cimal par la virgule)

# Param��tres acido-basiques
pKa= 4.8
Ke=1e-14# produit ionique de l'eau
Cb = 0.10
Ca = 0.10
Vb = 10.0
Vamax=20
#------------------------------------------------------------

#r��glage perso de la grille secondaire du graphe :
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
minor_xticks = np.arange(0, 101, 1)#espaces de la grille
minor_yticks = np.arange(0, 101, 0.2)#espaces de la grille
ax.set_xticks(minor_xticks, minor=True)
ax.set_yticks(minor_yticks, minor=True)
ax.grid(which='minor', alpha=0.2)

def concentration(Va):#Calcule [H3O+]
    Ka=10**(-pKa)
    Kb=Ke/Ka
    a=Ca*Va/(Vb+Va)+Kb# a, b et c les coefficients du polyn��me
    b=Kb*(Ca*Va-Cb*Vb)/(Vb+Va)-Ke
    c=Kb*Ke
    vm = nppol.polyroots([-c,b,a,1])#chercher les racines du polyn��me
    positive=filter(lambda x: x>0,filter(np.isreal,vm))
    C=next(positive)
    return C

def titrage(Vmin,Vmax):# calcul du pH
    volume = np.linspace(Vmin, Vmax, 256,endpoint=True)
    ph=14+np.log10(np.vectorize(concentration)(volume))
    return volume,ph

#---------------------------remplacer  les points d��cimaux par des virgules :
def func(x, pos):  # formatter function takes tick label and tick position
    s = str(x)
    ind = s.index('.')
    return s[:ind] + ',' + s[ind+1:]   # change dot to comma
x_format = ticker.FuncFormatter(func)  # make formatter
#----------------------------------------------------------------------------------------------------------

def graphique_ph(Vmin,Vmax):
    volume,ph=titrage(Vmin,Vmax)
    plt.plot(volume, ph)

plt.title("Titrage pH-m��trique d'une base faible")
plt.xlabel(r"Volume $V_a$ d'acide vers�� (mL)")
plt.ylabel("pH")
plt.grid()
plt.axis([0, Vamax, 0, 14])#limites des axes
plt.yticks(np.arange(0, 14, 1))# ajuster l'espace entre valeurs axe y
plt.xticks(np.arange(0, Vamax, 2.0))# ajuster l'espace entre valeurs axe x
#    ax.xaxis.set_major_formatter(x_format)  # appliquer le format de virgule d��cimale

#for pKa in [10, 9, 8]:# Si on veut montrer l'effet du pKa sur l'allure du graphe
#indenter la ligne suivante, si ligne pr��c��dente.
graphique_ph(0,Vamax)

fig.savefig('CourbeTitrageBaseFaible.png', transparent=False, dpi=150)# Cr��ation image PNG (adapter la r��solution au r��sultat souhait��)

plt.show()

# data[].attributes.attachment_link.readable_text
import matplotlib.pyplot as plt
import numpy as np


def calcul_quantites_avant_et_a_equivalence(i):
    V.append(i)
    n_OH.append()
    n_Cl.append()
    n_Na.append()
    n_MgOH2.append(  )
    n_Mg.append()

def calcul_quantites_apres_equivalence(i) :
     V.append(i)
     n_OH.append()
     n_Cl.append()
     n_Na.append()
     n_MgOH2.append(   )
     n_Mg.append( )

VE =    #saisie du volume équivalent en mL
Veau = 90 #saisie du volume d’eau ajouté en mL
n_OH, n_Cl, n_Na, n_MgOH2,n_Mg, V = [], [], [], [], [] , []# initialisation de 6 listes
for i in np.arange(0,20,0.5) :
    if i <= VE :
        #appelle une fonction qui calcule les quantités avant et à l’équivalence
        calcul_quantites_avant_et_a_equivalence(i)
    else :
        #appelle une fonction qui calcule les quantités après l’équivalence
        calcul_quantites_apres_equivalence(i)
# Expression de la conductivité
Conduct = 10*(20*np.array(n_OH)+5.0*np.array(n_Na)+7.63*np.array(n_Cl) + 10.6*np.array(n_Mg))/(Veau*1E-3+1E-3*np.array(V)+0.010)
# affichage des courbes
plt.subplot(121) # subplot permet d’afﬁcher deux graphes
plt.plot(V, n_OH,'bx-', linewidth=0.5, label="n_Ag")
plt.plot(V, n_Cl, 'rx-', label="n_Cl")
plt.plot(V, n_Na, 'mx-', label="n_NA")
plt.plot(V, n_MgOH2, 'gx-', label="n_MgOH2")
plt.plot(V, n_Mg, 'g+:', label="n_Mg")

plt.legend()
plt.subplot(122)
plt.scatter(V, Conduct, label="Conductivité en $\mathrm{mS\cdot cm^{-1}}$")
#plt.ylim(0,2.8)
plt.grid()
plt.legend()

plt.show()

# data[].attributes.attachment_link.readable_text
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
@author: emilietisserond
"""

import matplotlib.pyplot as plt
import csv
from collections import defaultdict



columns = defaultdict(list) #chaque valeur de chaque colonne est ajoutée à une liste

#définition des variables (listes vides)
Temps=[] ; t=[]
X=[] ; x=[]
Y=[] ; y=[]

#récupération des données de pointage
with open('1') as f:
    reader = csv.reader(f,delimiter=";")
    next(reader)
    for row in reader:
        for (i,v) in enumerate(row):
            columns[i].append(v.replace(',', '.')) #remplacement des , par des .
Temps=columns[0]
X=columns[1]
Y=columns[2]

#suppression du premier élément de chaque liste
Temps.remove(Temps[0])
X.remove(X[0])
Y.remove(Y[0])

#conversion des chaînes de caractères en chaînes de flottants
t = [float(i) for i in Temps]
x = [float(j) for j in X]
y = [float(k) for k in Y]

###########Tracé de la trajectoire######################

plt.plot(x,y,'.',markersize = 5, color = 'red')
plt.xlim(0)
plt.xlabel("x (en m)") #étiquette des abscisses
plt.ylabel("y (en m)") #étiquette des ordonnées
plt.title("Trajectoire du projectile") #titre du graphique
plt.show()
#Calcul de vx, vy et v pour le vecteur vitesse
vx=[]
vy=[]
v=[]
for i in range (1, len(x)-1):
    vx.append((x[i+1]-x[i-1])/(t[i+1]-t[i-1]))
    vy.append((y[i+1]-y[i-1])/(t[i+1]-t[i-1]))
    v.append((vx[-1]**2+vy[-1]**2)**0.5)

#Calcul de ax, ay et a pour le vecteur accélération
ax=[]
ay=[]
a=[]
for i in range (1, len(vx)-1):
    ax.append((vx[i+1]-vx[i-1])/(t[i+1]-t[i-1]))
    ay.append((vy[i+1]-vy[i-1])/(t[i+1]-t[i-1]))
    a.append((ax[-1]**2+ay[-1]**2)**0.5)

###########Tracé des champs de vecteurs#######################

# la fonction plt.quiver() permet de tracer un vecteur

vec_v= plt.quiver(x[1:-1], y[1:-1], vx, vy, color = "green")
vec_a= plt.quiver(x[2:-2], y[2:-2], ax, ay, color = "blue")

plt.show()
plt.savefig("LancerTrajectoire.png") #enregistrement du graphe

# data[].attributes.attachment_link.readable_text
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
@author: emilietisserond
"""

import matplotlib.pyplot as plt
import csv
from collections import defaultdict

columns = defaultdict(list) #chaque valeur de chaque colonne est ajoutée à une liste

#définition des variables (listes vides)
Temps=[] ; t=[]
X=[] ; x=[]
Y=[] ; y=[]

#récupération des données de pointage
with open('2') as f:
    reader = csv.reader(f,delimiter=";")
    next(reader)
    for row in reader:
        for (i,v) in enumerate(row):
            columns[i].append(v.replace(',', '.')) #remplacement des , par des .
Temps=columns[0]
X=columns[1]
Y=columns[2]

#suppression du premier élément de chaque liste
Temps.remove(Temps[0])
X.remove(X[0])
Y.remove(Y[0])

#conversion des chaînes de caractères en chaînes de flottants
t = [float(i) for i in Temps]
x = [float(j) for j in X]
y = [float(k) for k in Y]


#Calcul de vx, vy et v pour le vecteur vitesse
vx=[]
vy=[]
v=[]
for i in range (1, len(x)-1):
    vx.append((x[i+1]-x[i-1])/(t[i+1]-t[i-1]))
    vy.append((y[i+1]-y[i-1])/(t[i+1]-t[i-1]))
    v.append((vx[-1]**2+vy[-1]**2)**0.5)

#Calcul de ax, ay et a pour le vecteur accélération
ax=[]
ay=[]
a=[]
for i in range (1, len(vx)-1):
    ax.append((vx[i+1]-vx[i-1])/(t[i+1]-t[i-1]))
    ay.append((vy[i+1]-vy[i-1])/(t[i+1]-t[i-1]))
    a.append((ax[-1]**2+ay[-1]**2)**0.5)



################Etude énergétique#################

m=0.60 #masse du système en kg
g=9.81 #intensité de la pesanteur

#Calcul des énergies

Ep=[] #énergie potentielle
for i in range(len(vx)) :
    Ep=Ep+[m*g*y[i]]

Ec=[] #énergie cinétique
for i in range(len(vx)) :
     Ec=3

Em=[] #énergie mécanique
for i in range(len(vx))  :
     Em=Em+[Ep[i]+Ec[i]]


################Tracé des énergies################


plt.plot(t[0:-2],Ep,'ro',label='énergie potentielle de pesanteur')
plt.plot(t[0:-2],Ec,'go',label='énergie cinétique')
plt.plot(t[0:-2],Em,'ko',label='énergie mécanique')
plt.xlim(0)
plt.title('Energies du projectile')
plt.xlabel('t (en s)')
plt.ylabel('E (en J)')
plt.legend(loc=0)

plt.show()
plt.savefig(    )

# data[].attributes.attachment_link.readable_text
﻿import matplotlib.pyplot as plt # importe les bibliothèques nécessaires
import numpy as np
import math as m

# Coordonnées de Neptune en unité astronomique
X = [ A COMPLETER, ] # abscisse
Y = [ A COMPLETER, ] # ordonnée
t = [ A COMPLETER, ] # dates de relevé des coordonnées

# Représentation d’une portion de l’orbite de Neptune de 2020 à 2024 dans le plan de l’écliptique
plt.plot(X, Y) # trace la courbe X en fonction de Y
plt.xlabel(' A COMPLETER ') # légende de l’axe des abscisses
plt.ylabel(' A COMPLETER ')
plt.title("Portion d’orbite de Neptune dans le référentiel héliocentrique") # titre du graphique
plt.show() # affiche le graphique

# Calcul des aires parcourues entre 2020 et 2021
L1_a = m.sqrt(X[0]**2 + Y[0]**2) # distance L1_a en ua
L2_a = m.sqrt(X[1]**2 + Y[1]**2)
L3_a = m.sqrt((X[1] - X[0])**2 + (Y[1] - Y[0])**2)
p_a = (L1_a + L2_a + L3_a)/2 # demi-périmètre
Aire_a = m.sqrt(p_a*(p_a - L2_a)*(p_a - L3_a)*(p_a - L1_a)) # aire balayée entre 2020 et 2021
print ("L’aire parcourue par le rayon vecteur entre 2020 et 2021 vaut : ", round(Aire_a, 2), "ua^2") # affiche le résultat

# Calcul des aires parcourues entre 2022 et 2023
L1_b = m.sqrt(X[ A COMPLETER ]**2 + Y[ A COMPLETER ]**2) # distance L1_b en ua
L2_b = m.sqrt(X[ A COMPLETER ]**2 + Y[ A COMPLETER ]**2)
L3_b = m.sqrt( A COMPLETER )
p_b = A COMPLETER # demi-périmètre
Aire_b = m.sqrt(p_b*( A COMPLETER - L2_b)*(p_b - L3_b)*(p_b - A COMPLETER )) # aire balayée entre 2022 et 2023
print ("L’aire parcourue par le rayon vecteur entre 2022 et 2023 vaut : ", round( A COMPLETER , 2), "ua^2") # affiche le résultat

# data[].attributes.attachment_link.readable_text
﻿# Importation des bibliothèques et modules
import matplotlib.pyplot as plt
import numpy as np
from scipy.stats import linregress # importe le module linregress

# Création des tableaux de valeurs
R = np.array([48.227e3, A COMPLETER, ])
# valeurs des rayons (en km) des orbites circulaires des satellites autour de Neptune
T = np.array([ A COMPLETER, ]) # période de révolution (en jour) des satellites de Neptune
R3 = R**3 # cube du rayon de l’orbite du satellite
T2 = A COMPLETER # carré de la période

# Tracé de la courbe expérimentale T2 en fonction de R3
plt.plot(R3, T2, '+') # trace les points expérimentaux pour la courbe T^2 = f(R^3)
plt.xlabel(" A COMPLETER ") # légende de l’axe des abscisses
plt.ylabel(" A COMPLETER ")
plt.grid() # affiche un quadrillage

# Régression linéaire et affichage de la droite de régression
(a, _, _, _, _) = linregress(R3, T2) # modélise la courbe précédente par une droite de coefficient directeur a
print('Le coefficient directeur de la droite est : ', a, "en jour^2/km^3") # affiche la valeur du coefficient directeur a
T2_modelisation = a*R3 # calcule la période connaissant le coefficient directeur a
plt.plot(R3, T2_modelisation, label = 'Droite de régression linéaire') # trace la droite de régression linéaire
plt.legend() # affiche la légende des courbes
plt.show() # affiche le graphique

# data[].attributes.attachment_link.readable_text
import matplotlib.pyplot as plt
import numpy as np

#  Temps et concentration

t = [] # temps en mn
c = [] # compléter avec les valeurs expérimentales en mmol/L

# vitesse de disparition

v = []
for i in range (len(t)-1) :
    v.append(abs ())          # indiquer la formule pour calculer la vitesse volumique de disparition

vmax=max(v)
cmax=max(c)

# Graphique de la vitesse de disparition en fonction de la concentration

del c[6]#  enlève la dernière valeur de la liste car pour i+1 , il n'y a plus de valeur
plt.plot(c,v,'g+:',linewidth=1)
plt.grid()
plt.title("Vitesse volumique de disparition = f(concentration)")

plt.axis([ 0,1.5*cmax,0,1.5*vmax]) # définir les abscisses et ordonnées minimales et maximales
plt.ylabel("     ") # compléter le titre de l'ordonnée                              ")
plt.xlabel("    ") # compléter le titre de l'abscisse                              ")

plt.show()


# data[].attributes.attachment_link.readable_text
import matplotlib.pyplot as plt
import numpy as np

#  Temps et concentration

t = [0,10,20,30,40,50,60] # temps en mn
c = [0.092,0.079,0.067,0.058,0.050,0.044,0.039
] # compléter avec les valeurs expérimentales en mmol/L

# vitesse de disparition

v = []
for i in range (len(t)-1) :
    v.append(abs ((c[i+1]-c[i])/(t[i+1]-t[i])))          # indiquer la formule pour calculer la vitesse volumique de disparition

vmax=max(v)
cmax=max(c)

# Graphique de la vitesse de disparition en fonction de la concentration

del c[6]#  enlève la dernière valeur de la liste car pour i+1 , il n'y a plus de valeur
plt.plot(c,v,'g+:',linewidth=1)
plt.grid()
plt.title("Vitesse volumique de disparition = f(concentration)")

plt.axis([ 0,1.5*cmax,0,1.5*vmax]) # définir les abscisses et ordonnées minimales et maximales
plt.ylabel(" vitesse     ") # compléter le titre de l'ordonnée                              ")
plt.xlabel(" Crestant    ") # compléter le titre de l'abscisse                              ")

plt.show()

