# -*- coding: utf-8 -*-
#----------------------
print()
print(" calcul pour instruments d'optiques")
print(" ----------------------------------")
print()
#------------------------------------------------------------------- les options
def question() :
    print(" Choisissez le chiffre de l'une des options suivantes")
    print()
    print(" Grossissement.1...............: 1    Ouverture réel (astro et photo)...: 8")
    print(" Focale de l'oculaire..........: 2    Focale de l'objectif..............: 9")
    print(" Focale de l'objectif..........: 3    Diamètre de l'objectif............:10")
    print(" Champ en mètre ou en degrès...: 4    .....................................")
    print(" Luminosité....................: 5    Grossissement du microscope.......:11")
    print(" Grossissement.2...............: 6    Oculaire du microscope............:12")
    print(" ouverture.....................: 7    Objectif du microscope............:13")
    print()
    return
#-------------------------------------------------------------------
'''
[touche = chr(code)] les code ASCII de 0 à 9 = sont de 48 à 57
code = input("blabla") - utiliser "try except" ou bien 
if code < 48 or code > 57 print(Entrée non conforme) re...
'''
#------------------------------------------------------------------- le choix
def choisir() :
    global choix
    
    choix = input("               Entrez le numéro de l'option choisie : ")
    print()
    try :
        choix = int(choix)
    except :
        print("         Vous devez taper uniquement un chiffre, rien d'autre")
        choisir() # tourniquet pour chiffre non conforme
    
    if choix < 0 :
        print("                 Erreur ce chiffre est négatif !")
        choisir()  # tourniquet pour chiffre négatif
        print()
        
    if choix == 0 :
        print("                 Erreur se chiffre est trop petit !")
        choisir()  # tourniquet pour chiffre trop petit
        print()
    
    if choix > 13 :
        print("                 Erreur se chiffre est trop grand !")    
        choisir()  # tourniquet pour chiffre trop grand
        print()
    return
#============================================================================================================== section des commentaires
#------------------------------------------------------------------- pas assez !
def argum() :
    print(" Désolé, mais il n'y a pas assez d'argument pour pouvoir effectuer ce calcul.")
    return
#------------------------------------------------------------------- blabla...!
def blabla() :
    print()
    print(" L' ouverture est de", ouverture, "mm")
    print(" Le grossissement est de", grossissement,"fois")
    print(" La luminosité est de", luminosité)
    print("-------------------------------------")
    if ouverture < 6 :
        print(" Luminosité bonne, résolution faible")
        print(" Bon pour l'observation du ciel profond")
    
    if ouverture > 5 and ouverture < 10 :
        print( " Luminosité moyenne, résolution moyenne")
        print( " Observation du ciel profond et des planètes")
    
    if ouverture > 9 :
        print(" Luminosité faible, résolution bonne")
        print(" Bien pour l'observation des planètes")
    return
#============================================================================================================== section des demandes de l'utilisateur
#------------------------------------------------------------------- entrée objectif oculaire
def ocul() :
    global oculaire
    
    oculaire = input(" Focale de l'oculaire ? ")
    try :
        oculaire = float(oculaire)
    except :
        print(" Vous devez taper uniquement un chiffre, rien d'autre")
        ocul() # tourniquet pour chiffre non conforme
    if oculaire <= 0.0 :
        print(" Erreur ce chiffre doit être ni négatif ni nul !, recommancez !")
        ocul() # tourniquet pour chiffre non conforme
    return
#------------------------------------------------------------------- entrée objectif objectif
def obje() :
    global objectif
    
    objectif = input(" Focale de l'objectif [longueur de l'instrument] ? ")
    print()
    try :
        objectif = float(objectif)
    except :
        print(" Vous devez taper uniquement un chiffre, rien d'autre")
        obje() # tourniquet pour chiffre non conforme
    if objectif <= 0.0 :
        print(" Erreur ce chiffre doit être ni négatif, ni nul !")
        obje() # tourniquet pour chiffre non conforme
    return

#------------------------------------------------------------------- entrée grossissement
def gros() :
    global grossissement
    
    grossissement = input(" Grossissement ? ")
    try :
        grossissement = float(grossissement)
    except :
        print(" Vous devez taper uniquement un chiffre, rien d'autre")
        gros() # tourniquet pour chiffre non conforme
    if grossissement <= 0.0 :
        print(" Erreur ce chiffre doit être ni négatif ni nul, recommancez !")
        gros() # tourniquet pour chiffre non conforme
    return
#------------------------------------------------------------------- entrée ouverture
def ouve() :
    global ouverture
    
    ouverture = input(" Ouverture ? ")
    try :
        ouverture = float(ouverture)
    except :
        print(" Vous devez taper uniquement un chiffre, rien d'autre")
        ouve() # tourniquet pour chiffre non conforme
    if ouverture <= 0.0 :
        print(" Erreur ce chiffre doit être ni négatif ni nul, recommancez !")
        ouve() # tourniquet pour chiffre non conforme
    return
#------------------------------------------------------------------- entrée luminosité
def lumi() :
    global luminosité
    
    luminosité = input(" Luminosité ? ")
    try :
        luminosité = float(luminosité)
    except :
        print(" Vous devez taper uniquement un chiffre, rien d'autre")
        lumi() # tourniquet pour chiffre non conforme
    if luminosité <= 0.0 :
        print(" Erreur ce chiffre doit être ni négatif ni nul, recommancez !")
        lumi() # tourniquet pour chiffre non conforme
    return
#------------------------------------------------------------------- entrée diamètre objectif
def diam() :
    global diamètre
    
    diamètre = input(" Diamètre de l'objectif ? ")
    try :
        diamètre = float(diamètre)
    except :
        print(" Vous devez taper uniquement un chiffre, rien d'autre")
        diam() # tourniquet pour chiffre non conforme
    if diamètre < 0.0 :
        print(" Erreur ce chiffre doit être ni négatif ni nul, recommancez !")
        diam() # tourniquet pour chiffre non conforme
    return
#------------------------------------------------------------------- entrée de l'ouverture réel objectif
def ouRe() :
    global ouvertRéel
    
    ouvertRéel = input(" Ouverture réel de l'objectif ? ")
    try :
        ouvertRéel = float(ouvertRéel)
    except :
        print(" Vous devez taper uniquement un chiffre, rien d'autre")
        ouRe() # tourniquet pour chiffre non conforme
    if ouvertRéel < 0.0 :
        print(" Erreur ce chiffre doit être ni négatif ni nul, recommancez !")
        ouRe() # tourniquet pour chiffre non conforme
    return
#============================================================================================================== section des calculs de 1 à 3
#=================================================================== 1 [grossissement]
def grossis() :
    global objectif
    global oculaire
    global grossissement
    
    print(" Pour calculer le grossissement  j'ai besoin de connaître,")
    print("   La objectif de l'oculaire, et la objectif de l'objectif")
    print()
    ocul()
    obje()    
#------------------------------------------------------------------- 1 calcul et affichage pour grossissement
    if objectif > 0.0 and oculaire > 0.0 :
        grossissement = objectif / oculaire
    
    print()
    print(" Avec un oculaire de", oculaire,"mm")
    print(" Et un objectif de", objectif,"mm")
    print(" Le grossissement est de", grossissement, "fois")
    return
#=================================================================== 2 [oculaire]
def ocular() :
    global objectif
    global oculaire
    global grossissement
    
    print(" Pour calculer objectif de l'oculaire j'ai besoin de connaître,")
    print("      La objectif de l'objectif, et le Grossissement")
    print()
    obje()
    gros()
#------------------------------------------------------------------- 2 calcul et affichage pour la objectif de l'oculair 
    if objectif > 0.0 and grossissement > 0.0 :
        oculaire = objectif / grossissement
    
    print()
    print(" Avec un objectif de", objectif, "mm")
    print(" Et un grossissement de", grossissement, "fois")
    print(" L'oculaire doit être de", oculaire,"mm")
    return
#=================================================================== 3 [objectif]
def object() :
    global objectif
    global oculaire
    global grossissement
    
    print(" Pour calculer la objectif de l'objectif j'ai besoin de connaître,")
    print("   La objectif de l'oculaire, et le Grossissement")
    print()
    ocul()
    gros()
#-------------------------------------------------------------------  3 calcul et affichage pour la objectif de l'objectif
    if oculaire > 0.0 and grossissement > 0.0 :
        objectif = oculaire * grossissement
    
    print()
    print(" Avec un oculaire de", oculaire, "mm")
    print(" Et un grossissement de", grossissement, "fois")
    print(" L'objectif doit être de", oculaire,"mm")
    return
#========================================================================= 4 [entrée avec calcul et affichage pour les champs en mètres ou en degrès]
def chmp() :
    global mètre
    global degé
        
    print(" Entrez un zéro si vous ne connaissez pas la réponse.")
    mètre = input(" Champ en mètre ? ")
    try :
        mètre = float(mètre)
    except :
        print(" Vous devez taper uniquement un chiffre, rien d'autre")
        chmp() # tourniquet pour chiffre non conforme
    if mètre < 0.0 :
        print(" Erreur ce chiffre doit être ni négatif ni nul !")
        chmp() # tourniquet pour chiffre non conforme
        
    if mètre > 0.0 :
        degré = mètre / 17.45
        print("", mètre, "mètre sont égal à", degré, "degré")
        return
#-------------------------------------------------------------------
    degré = input(" Champ en degrés ? ")
    try :
        degré = float(degré)
    except :
        print(" Vous devez taper uniquement un chiffre, rien d'autre")
        chmp() # tourniquet pour chiffre non conforme
    if degré < 0.0 :
        print(" Erreur ce chiffre doit être ni négatif ni nul, recommancez !")
        chmp() # tourniquet pour chiffre non conforme
    
    if degré > 0.0 :
        mètre = degré * 17.45
        print("", degré, "degré sont égal à" , mètre, "mètre")
        return
#-------------------------------------------------------------------
    if mètre == 0 and degés == 0 :
        argum()
    return
#============================================================================================================== section des calculs de 5 à 7 
#=================================================================== 5 Luminosité
def lumin() :
    global ouverture
    global grossissement
    global luminosité
    
    print("  Pour calculer la Luminosité j'ai besoun de connaître")  # luminosité rapport de la objectif / ouverture ou diamètre
    print("  L'ouverture de l'objectif ainsi que le Grossissement")  # objectif = ouverture * luminosité
    print()
    ouve()
    gros()
#-------------------------------------------------------------------
    if ouverture > 0.0 and grossissement > 0.0 :
        luminosité = (ouverture / grossissement) ** 2
    
    print()
    print(" Avec une ouverture de", ouverture, "mm")
    print(" Et un grossissement de", grossissement, "fois")
    print(" Vous devriez avoir une luminosité de", luminosité)
    blabla()
    return
#=================================================================== 6 grossissement
def grossi() :
    global ouverture
    global grossissement
    global luminosité
    
    print("  Pour calculer le grossissement j'ai besoun de connaître")
    print("  L'ouverture de l'objectif ainsi que la luminosité")
    print()
    ouve()
    lumi()
#-------------------------------------------------------------------
    if ouverture > 0.0 and luminosité > 0.0 :
        grossissement = ouverture / (luminosité ** 0.5)
    
    print()
    print(" Avec une ouverture de", ouverture, "mm")
    print(" Et une luminosité de", luminosité, )
    print(" Vous devriez avoir un grossissement, de", grossissement, "fois")
    blabla()
    return
#=================================================================== 7 ouverture (ou diamètre)
def ouvert() :
    global ouverture
    global grossissement
    global luminosité
    
    print("  Pour calculer l'ouverture j'ai besoun de connaître")
    print("     Le Grossissement ainsi que la luminosité")
    print()
    gros()
    lumi()
#-------------------------------------------------------------------
    if ouverture == 0.0 :
        if grossissement >0.0 and luminosité > 0.0 :
            ouverture = grossissement * (luminosité ** 0.5)
    
    print()
    print(" Avec un grossissement, de", grossissement, "fois")
    print(" Et une luminosité de", luminosité, )
    print(" vous devriez avoir une ouverture de", ouverture, "mm")
    blabla()
    return
#============================================================================================================== section des calculs de 8 à 10
# le rapport de la distance focale de l'objectif / ouverture ou diamètre
# dans ce programme "focale = objectif" pour n'avoir qu'une seul variable et un seul sous programme
#=================================================================== 8 Ouverture réel 
def ouvRL() :
    global diamètre
    global objectif
    global ouvertRéel
    
    print("       Pour calculer Ouverture réelle j'ai besoin de connaître")
    print("        La Focale de l'objectif, et le Diamètre de l'objectif")
    print()
    obje()
    diam()
#-------------------------------------------------------------------
    if objectif > 0.0 and diamètre > 0.0 :
        ouvertRéel = objectif / diamètre
    
    print()
    print(" Avec une focale de l'objectif de", objectif, "mm")
    print(" Et un diamètre de l'objectif de", diamètre, "mm")
    print(" Vous devriez avoir une ouverture réelle de", ouvertRéel)
    return
#=================================================================== 9 focale de l'objectif
def Object() :
    global diamètre
    global objectif
    global ouvertRéel
    
    print("       Pour calculer la focale de l'objectif j'ai besoin de connaître")
    print("              Le Diamètre de l'objectif, et l'ouverture réel")
    print()
    diam()
    ouRe()
#-------------------------------------------------------------------
    if diamètre > 0.0 and ouvertRéel > 0.0 :
        objectif = diamètre * ouvertRéel
    
    print()
    print(" Avec un diamètre de l'objectir de", diamètre,"mm")
    print(" Et une ouverture réel de", ouvertRéel)
    print(" Vous devriez avoir une focale de l'objectif de", objectif, "mm")
    return
#=================================================================== 10 diamètre de l'objectif
def diamèt() :
    global diamètre
    global objectif
    global ouvertRéel
    
    print("       Pour calculer le Diamètre de l'objectif, j'ai besoin de connaître")
    print("                La focale de l'objectif et l'ouverture réel")
    print()
    obje()
    ouRe()
#-------------------------------------------------------------------
    if objectif > 0.0 and ouvertRéel > 0.0 :
        diamètre = objectif / ouvertRéel
    
    print()
    print(" Avec une focale de l'objectif de", objectif,"mm")
    print(" Et une ouverture réel de", ouvertRéel)
    print(" Vous devriez avoir un diamètre de l'objectif de", diamètre, "mm")
    return
#==============================================================================================================  section des calculs de 11 à 13
#=================================================================== 11 Grossissement du microscope
def grosmic() :
    global oculaire
    global objectif
    global grossissement
    
    print("      Pour calculer le grossissement du microscope")
    print("     J'ai besoin de savoir quel oculaire est utilisé")
    print("               Et avec quel objectif")
    print()
    ocul()
    obje()
#-------------------------------------------------------------------
    if oculaire > 0.0 and objectif > 0.0 :
        grossissement = oculaire * objectif
    
    print()
    print(" Et un oculaire de", oculaire,"mm")
    print(" Avec un objectif de", objectif,"mm")
    print(" Le grossissement est de", grossissement, "fois")
    return
#=================================================================== 12 oculaire du microscope
def ocumic() :
    global oculaire
    global objectif
    global grossissement
    
    print("      Pour calculer objectif de l'oculaire du microscope")
    print("    J'ai besoin de savoir quel grossissement est utilisé")
    print("               Et avec quel objectif")
    print()
    gros()
    obje()
#-------------------------------------------------------------------
    if grossissement > 0.0 and objectif > 0.0 :
        oculaire = grossissement / objectif
    
    print()
    print(" Avec un grossissement de", grossissement,"fois")
    print(" Et un objectif de", objectif, "mm")
    print(" la objectif de l'oculaire doit être", oculaire, "mm")
    return
#=================================================================== 13 objectif du microscope
def objmic() :
    global oculaire
    global objectif
    global grossissement
    
    print("      Pour calculer objectif de l'objectif du microscope")
    print("    J'ai besoin de savoir quel grossissement est utilisé")
    print("               Et avec quel oculaire")
    print()
    gros()
    ocul()
#-------------------------------------------------------------------
    if oculaire > 0.0 :
        objectif = grossissement / oculaire
    
    print()
    print(" Avec un grossissement de", grossissement,"fois")
    print(" Et un oculaire de",  oculaire, "mm")
    print(" la objectif de l'objectif doit être", objectif, "mm")
    return
#============================================================================================================== Début de la lecture du programme
#------------------------------------------------------------------- déclaration des variables globales
global choix
global oculaire
global objectif
global grossissement
global ouverture
global ouverture
global luminosité
global diamètre
global ouvertRéel
global mètre
global degré

#------------------------------------------------------------------- initialisation des variables
choix = 0
oculaire =0.0
objectif = 0.0
grossissement = 0.0
ouverture = 0.0
luminosité = 0.0
diamètre = 0.0
ouvertRéel = 0.0
mètre = 0.0
degré = 0.0 
#-------------------------------------------------------------------------------------------------------------- [main]
question()
choisir()
if choix == 1 :
    grossis()
if choix == 2 :
    ocular()
if choix == 3 :
    object()
if choix == 4 :
    chmp()
if choix == 5 :
    lumin()
if choix == 6 :
    grossi()
if choix == 7 :
    ouvert()
if choix == 8 :
    ouvRL()
if choix == 9 :
    Object()
if choix == 10 :
    diamèt()
if choix == 11 :
    grosmic()
if choix == 12 :
    ocumic()
if choix == 13 :
    objmic()
#------------------------------------------------------------------- impression
# faite en cours de programme
#------------------------------------------------------------------- Sortie
print()
print(" ----------------------")
bye = (input (" Entrer pour Sortir...!"))