Chapitre 4 : Organisation des programmes en Python

Enterprise 2023-08-11 23:37:54 views: null

Chapitre 4 : Organisation des programmes en Python

1. Structure organisationnelle du programme

En 1996, des informaticiens ont prouvé le fait que tout algorithme, simple ou complexe, peut avoir une structure de séquence , une structure de sélection , et une structure de boucle , les trois structures de base combinées.

1-4-1 Structure organisationnelle du programme

2. Structure séquentielle

  • qu'est-ce que la structure de séquence
    • Le programme exécute le code séquentiellement de haut en bas, sans jugement ni saut au milieu, jusqu'à la fin du programme
  • Organigramme de structure de séquence

1-4-2 Structure de la séquence

  • démo de code

    • écriture de code
    """把大象当冰箱一共需要几步"""
print('---------程序开始------------')
print('1.把冰箱打开')
print('2.把大象放进去')
print('3.关闭冰箱门')
print('---------程序结束------------')
    • Analyse des résultats
    ---------程序开始------------
1.把冰箱打开
2.把大象放进去
3.关闭冰箱门
---------程序结束------------

3. La valeur booléenne de l'objet

Tout en Python est un objet et tous les objets ont une valeur booléenne

  • Obtenir la valeur booléenne de l'objet

    • Utilisez la fonction intégrée bool()

  • La valeur booléenne des objets suivants est False et la valeur booléenne des autres objets est True

    • FAUX
    • valeur 0
    • Aucun
    • chaîne vide
    • liste vide
    • tuple vide
    • dictionnaire vide
    • collection vide

  • démo de code

    • écriture de code
    # 测试对象的bool
print("以下对象的布尔值为False")
print(bool(False))  # False
print(bool(0))  # False
print(bool(0.0))  # False
print(bool(None))  # False
print(bool(""))  # False   空字符串
print(bool([]))  # False   空列表
print(bool(list()))  # False   空列表
print(bool(()))  # False   空元组
print(bool(tuple()))  # False  空元组
print(bool({
      
      }))  # False   空字典
print(bool(dict()))  # False   空字典
print(bool(set()))  # False 空集合
print("其他对象的布尔值为True")

4. Structure de la succursale (choisir la structure)

  • qu'est-ce que la structure de sélection
    • Le programme exécute sélectivement certains codes en fonction des conditions de jugement, et indique clairement à l'ordinateur quoi faire dans quelles conditions

4.1 Branche unique si structure

  • Signification chinoise
    • si donc…
      • apportez un parapluie s'il pleut
  • Structures grammaticales
if 条件表达式:
	条件执行体
  • organigramme

1-4-3 Organigramme de la structure à branche unique

  • Démonstration de code : opération de retrait

    • écriture de code
    """取款操作"""
money = 1000  # 余额
s = int(input("请输入取款金额:"))  # 取款金额
# 进行判断，余额是否充足
if money >= s:
    money = money - s
    print("取款成功，余额为：", money)

4.2 Structure à double branche if...else

  • Signification chinoise
    • Si...pas satisfait...alors...
      • S'il pleut, apportez un parapluie, s'il ne pleut pas, n'apportez pas de parapluie
  • Structures grammaticales
if 条件表达式:
	条件执行体1
else
	条件执行体2
  • organigramme

1-4-4 Organigramme de la structure à double branche

  • Démonstration de code : opération de retrait

    • écriture de code
    "从键盘录入一个数，编写程序需让计算机判断是奇数还是偶数"
num = int(input("请输入一个整数："))

# 条件判断
if num % 2 == 0:
    print(num, "为偶数")
else:
    print(num, "为奇数")

4.3 Structure multi-branches if...elif...else

  • Structures grammaticales
if 条件表达式1：
	条件执行体1
elif 条件表达式2：
	条件执行体2
	....
elif 条件表示式N:
	条件执行体N
[else:]
	条件执行体N+1
  • organigramme

1-4-5 Organigramme de la structure multi-agences

  • démo de code
"""从键盘录入一个整数升级，并判断
90-100  A
80-89   B
70-79   C
60-69   D
0-59    E
小于0或者大于100的数位非法数据（不是成绩的有效范围）"""
score = int(input("请输入一个成绩:"))
if 90 <= score <= 100:
    print("A")
elif 80 <= score <= 89:
    print("B")
elif 70 <= score <= 79:
    print("C")
elif 60 <= score <= 69:
    print("D")
elif 0 <= score <= 59:
    print("E")
else:
    print("非法数据")

4.4 Imbrication des instructions if

  • Structures grammaticales
if 条件表达式1:
	if 内层条件表达式:
		内层条件执行体1
	else 内层条件执行体2：
else:
	条件执行体
  • organigramme

1-4-6 Emboîté si organigramme de structure

  • démo de code
answer = input("您是会员吗？Y或N")
money = float(input("请输入你的购物金额："))
if answer == "Y":
    print("会员")
    if money >= 200:
        print("付款金额为：",money*0.8)
    elif money>=100:
        print("付款金额为：", money * 0.9)
    else:
        print("不打折，付款余额为：、")
else:
    print("非会员")

4.5 Expressions conditionnelles

  • Essence : Raccourci pour si… sinon…
  • Structures grammaticales
x	if	判断条件	else	y
  • Algorithme
    • Si la valeur booléenne de la condition de jugement est True , la valeur de retour de l'expression conditionnelle est x , sinon la valeur de retour de l'expression conditionnelle est False
  • démo de code
"""从键盘录入两个整数，并判断大小"""
num_a = int(input("请输入第一个整数："))
num_b = int(input("请输入第二个整数："))
# 比较大小
"""if num_a >= num_b:
    print(num_a, "大于等于", num_b)
else:
    print(num_a, "小于", num_b)"""

print("使用条件表达式进入比较")
print(str(num_a) + "大于等于" + str(num_b) if num_a >= num_b else str(num_a) + "小于" + str(num_b))

4.6 déclaration de réussite

  • qu'est-ce que la déclaration de passe

    • La déclaration ne fait rien, c'est juste un espace réservé où une déclaration est requise syntaxiquement

  • quand utiliser

    • Lors de la construction de la structure grammaticale d'abord, avant de penser à la façon d'écrire le code

  • Quelles déclarations peuvent être utilisées avec

    • Le corps d'exécution conditionnelle de l'instruction if
    • Le corps de la boucle de l'instruction for-in
    • Corps de la fonction lors de la définition d'une fonction

  • démo de code

answer = input("您是会员吗？：y/n")
if answer == "y":
    pass
else:
    pass
# 代码不会报错

5. Structure du cycle

5.1 Utilisation de la fonction range()

  • est utilisé pour générer une séquence d' entiers

  • Trois façons de créer un objet range()

    Le paramètre est laissé fermé et ouvert à droite

    • range(stop) : Crée une séquence d'entiers entre [0,stop] avec un pas de 1
    • range(start,stop) : crée une séquence d'entiers entre [start,stop] avec un pas de 1
    • range(start,stop,step) : crée une séquence d'entiers entre [start,stop,stop] avec une taille de pas de pas

  • La valeur de retour de la fonction range est un objet itérateur

  • Avantages du type gamme :

    • Quelle que soit la longueur de la séquence d'entiers représentée par l'objet range, l'espace mémoire occupé par tous les objets range est le même
      car seuls start, stop et step doivent être stockés , et ce n'est que lorsque l'objet range est utilisé que les éléments pertinents dans la suite soit calculée

  • in et not in détermine si ** existe (n'existe pas) ** l'entier spécifié dans la séquence d'entiers

  • démo de code

# range创建的三种方式
"""第一种创建方式，只有一个参数"""
r = range(10)  # 默认从零开始，步长默认为1
print(r)
print(list(r))
"""第二种方式，给了两个参数"""
r2 = range(1, 10)
print(list(r2))

"""第三种方式，给了三个参数"""
r3 = range(1, 10, 2)
print(list(r3))

"""in 与 not in
判断指定的整数在不在序列中"""
print(10 in r3)
print(10 not in r3)

5.2 boucle while

  • Structures grammaticales
while	条件表达式:
	条件执行体（循环体）
  • organigramme

1-4-7 organigramme de la boucle while

  • La différence entre le if de la structure de sélection et le while de la structure de boucle
    • si est de juger une fois , et la condition est vraie pour exécuter une fois
    • while est de juger N+1 fois , et la condition est True pour exécuter N fois
  • Le flux d'exécution de la boucle while (méthode de boucle en quatre étapes)
    les variables initialisées et les variables de jugement conditionnel et les variables modifiées sont les mêmes
    • Initialiser les variables
    • jugement conditionnel
    • Corps d'exécution conditionnelle (corps de boucle)
    • changer de variable
  • démo de code
"""计算0到4的累加和"""
# 初始化变量
a = 0
sum = 0
# 条件判断
while a <= 4:
    # 条件执行体
    sum += a
    # 改变变量
    a += 1
print("和为：", sum)
  • Problème d'entraînement : Calculer la somme de nombres pairs entre 1 et 100
"""代码1"""
# 初始化变量
a = 1
sum = 0
# 条件判断
while a <= 100:
    # 条件执行体
    if not bool(a % 2) :
        sum += a
    # 改变变量
    a += 1
print("1到100之间的偶数和为：", sum)

"""代码2"""
# 初始化变量
a = 1
sum = 0
# 条件判断
while a <= 100:
    # 条件执行体
    if a % 2 == 0:
        sum += a
    # 改变变量
    a += 1
print("1到100之间的偶数和为：", sum)

5.3 boucle for-in

  • concept de boucle for-on
    • dans l'expression prend des valeurs séquentiellement à partir de (chaîne, séquence), également appelée traversée
    • L'objet traversé par for-in doit être un objet itérable
  • Structures grammaticales
for 自定义的变量 in 可迭代对象:
	循环体
  • organigramme

Organigramme de la boucle for-in 1-4-8

  • Il n'est pas nécessaire d'accéder aux variables personnalisées dans le corps de la boucle et les variables personnalisées peuvent être remplacées par des traits de soulignement
  • démo de code
for item in "Python":
    print(item)

for i in range(0, 10):
    print(i)

# 如果在循环体中不需要使用到自定义变量，可将自定义变量写为_
for _ in range(5):
    print("人生苦短，我用Python")  # Python循环5次

"""使用for in 计算1到100之间的偶数和"""
sum = 0
for item in range(1, 101):
    if item % 2 == 0:
        sum += item
print("1到100的偶数和为：", sum)
  • Exercice : Sortir le nombre de jonquilles entre 1 et 999
"""输出100到999之间的水仙花数
水仙花数，举例
153=3*3*3+5*5*5+1*1*1"""
for item in range(100, 1000):
    ge = item % 10
    shi = item // 10 % 10
    bai = item // 100
    if item == ge ** 3 + bai ** 3 + shi ** 3:
        print(item)

5.4 instructions break, continue et else

5.4.1 instruction de rupture

  • Utilisé pour terminer la structure de boucle , généralement utilisé avec la structure de branche si,
  • démo de code
"""从键盘录入密码，最多录入三次，如果正确就结束循环"""
for item in range(1, 4):
    pwd = input("请输入密码：")
    if pwd == "8888":
        break
    else:
        print("密码不正确")

5.4.2 continuer l'instruction

  • Utilisé pour terminer la boucle en cours et entrer dans la boucle suivante, généralement utilisé avec if dans la structure de branche
  • démo de code
"""输出1到50之前所有的倍数"""
for item in range(1, 51):
    if item % 5 != 0:
        continue
    print(item)

5.4.3 instruction else

for item in range(3):
    pwd = input("请输入密码：")
    if pwd == "9999":
        print("密码正确")
    else:
        print("密码不正确")
else:
    print("对不起，三次机会已经用完")

5.5 Boucles imbriquées

  • boucle imbriquée
    • Une autre structure de boucle complète est imbriquée dans la structure de boucle, où la boucle interne est exécutée en tant que corps de boucle de la boucle externe
  • démo de code
"""输出一个三行四列的矩形"""
for i in range(1,4):
    for j in range(1,5):
        print("*",end="\t")
    print()
    
"""输出一个9行的直角三角形"""
for i in range(1,10):
    for j in range(1,i):
        print("*",end="\t")
    print()
  • pause et continuer en double boucle
for i in range(1, 5):
    for j in range(1, 11):
        if j % 2 == 0:
            continue
        print(j,end="\t")
    print()

Je suppose que tu aimes

Origine blog.csdn.net/polaris3012/article/details/130490194
conseillé
Classement
du quotidien
Plus
2024-10-02(0)
2024-10-01(0)
2024-09-30(0)
2024-09-29(0)
2024-09-28(3)
2024-09-27(0)
2024-09-26(0)
2024-09-25(0)
2024-09-24(0)
2024-09-23(0)

Code World

© 2018 codetd.com