[Aperçu de diffusion en direct] Les grands modèles remplaceront-ils les programmeurs ? "

Introduction

Revoir le contenu d’apprentissage de la veille

Jour 2 de l'apprentissage du langage Python_Première introduction à Python Hier, cet article a présenté l'histoire, les caractéristiques, les domaines d'application de Python et compilé et exécuté le premier programme Python.

Comprendre l'importance des variables et des types de données

Les variables et les types de données constituent la base du traitement des données dans les langages de programmation. Les variables nous permettent de stocker des données et de les utiliser en cas de besoin, tandis que les types de données définissent les propriétés de la variable et le type de données qu'elle peut stocker.
Une utilisation raisonnable et correcte des types de données peut éviter les erreurs dans les programmes, améliorer l'efficacité des programmes et rendre le code plus lisible et plus facile à maintenir.

2. Concept et utilisation des variables

Définition des variables : que sont les variables et pourquoi sont-elles nécessaires ?

qu'est-ce qu'une variable

En programmation, une variable est un identifiant utilisé pour stocker une valeur de données. Il peut être considéré comme une unité de stockage en mémoire, qui stocke des données accessibles et modifiables à tout moment. Les variables nous permettent de donner un nom aux données afin que nous puissions référencer les données plusieurs fois dans le programme sans avoir à les écrire à plusieurs reprises.

Pourquoi les variables sont nécessaires

Réutilisation des données : les variables nous permettent de stocker une valeur de données et de l'utiliser plusieurs fois dans différentes parties du programme. Cela évite d'écrire les mêmes données à plusieurs reprises et rend le code plus concis et plus facile à gérer.
Lisibilité du code : En donnant des noms de variables significatifs à vos données, vous pouvez augmenter la lisibilité de votre code. Les autres développeurs (ou futurs vous) peuvent plus facilement comprendre ce que fait le code.
Facile à modifier : si vous devez utiliser la même valeur de données dans le programme, l'utilisation de variables peut être facilement modifiée. Modifiez simplement la valeur d'une variable et toutes les références à cette variable seront automatiquement mises à jour.
Flexibilité et évolutivité : les variables offrent une manière flexible de travailler avec les données. Vous pouvez modifier la valeur d'une variable à tout moment, ou transmettre une référence à une variable aux fonctions et modules, ce qui rend le code plus flexible et extensible.
Gestion de la mémoire : les variables aident les programmeurs à gérer efficacement la mémoire. Les programmes peuvent libérer de la mémoire pour les variables lorsque les données ne sont plus nécessaires, ou allouer et réaffecter dynamiquement de la mémoire selon les besoins.
Implémentation de fonctions : Les variables sont la base de la réalisation de fonctions complexes. Par exemple, les variables sont essentielles lors de l'exécution de calculs mathématiques, du contrôle du déroulement du programme, du traitement des entrées de l'utilisateur, etc.

Règles de dénomination des variables : une combinaison de lettres, de chiffres et de traits de soulignement, et le premier caractère ne peut pas être un chiffre, etc.

En Python, la dénomination des variables doit suivre certaines règles :

Sensibilité à la casse : Python est sensible à la casse, ce qui signifie que variable et Variable sont deux variables différentes.
Ne peut commencer que par des lettres (az, AZ) ou un trait de soulignement (_) : les noms de variables ne peuvent pas commencer par des chiffres. Par exemple, 123abc est un nom de variable non valide, mais _123abc est valide.
Peut contenir des lettres, des chiffres (0-9) et des traits de soulignement (_) : les noms de variables ne peuvent pas contenir d'espaces ou de caractères spéciaux, tels que %, $, #, etc. Par exemple, ma_variable et variable2 sont tous deux des noms de variable valides.
Il ne peut pas s'agir d'un mot-clé Python : le nom de la variable ne peut pas être un mot réservé Python, comme if, while, class, etc. Ces mots-clés (voir le plan 6 pour plus de détails) ont des significations linguistiques spécifiques et ne peuvent pas être utilisés comme noms de variables ordinaires.
Aucune limite de longueur : En théorie, il n'y a pas de limite sur la longueur des noms de variables Python, mais pour la lisibilité et la facilité d'utilisation du code, il est recommandé d'utiliser des noms de variables concis et clairs.
Soyez aussi descriptif que possible : Un bon nom de variable doit décrire clairement ce qu'elle représente. Par exemple, total_score est plus facile à comprendre que le simple ts.
Évitez les majuscules et les traits de soulignement : Bien que techniquement autorisés, les majuscules et les traits de soulignement sont généralement réservés aux noms de classes. Par exemple, MyClass est un nom de classe, mais my_variable est un meilleur choix pour un nom de variable.

Affectation de variables : comment déclarer et initialiser des variables

En Python, déclarer et initialiser des variables est très simple et vous n'avez pas besoin de déclarer explicitement le type de données. Python est un langage typé dynamiquement, ce qui signifie que vous attribuez directement des valeurs aux variables et que l'interpréteur Python déduit automatiquement le type de la variable au moment de l'exécution. Voici les étapes de base pour déclarer et initialiser des variables :

Choisissez un nom de variable conforme aux règles de dénomination : les noms de variables peuvent contenir des lettres, des chiffres et des traits de soulignement, mais ils ne peuvent pas commencer par un chiffre ni être un mot-clé Python. Attribuez une valeur à une variable à l'aide de l'opérateur d'affectation (=) : attribuez la valeur des données que vous souhaitez stocker à la variable. Voici quelques exemples de déclaration et d’initialisation de variables :

# 声明一个整型变量
number = 10

# 声明一个浮点型变量
pi = 3.14159

# 声明一个字符串变量
greeting = "Hello, World!"

# 声明一个布尔型变量
is_valid = True

# 声明一个列表变量
fruits = ["apple", "banana", "cherry"]

# 声明一个字典变量
person = {"name": "Alice", "age": 25}

Dans l'exemple ci-dessus, nous avons créé plusieurs types de variables différents, notamment des entiers, des flottants, des chaînes, des booléens, des listes et des dictionnaires. L'interpréteur Python détermine automatiquement le type de données d'une variable en fonction de la valeur qui lui est attribuée.

Vous pouvez également déclarer plusieurs variables dans une seule instruction, comme indiqué ci-dessous :

x, y, z = 1, 2, 3

Ici, nous déclarons trois variables x, y et z en même temps et leur attribuons respectivement les valeurs 1, 2 et 3.

N'oubliez pas que les variables en Python sont comme des étiquettes, vous pouvez leur attribuer de nouvelles valeurs à tout moment, même un type de valeur différent, puisque Python est typé dynamiquement. Par exemple:

x = 100  # x是一个整型
x = "text"  # 现在x是一个字符串

Dans cet exemple, nous attribuons d’abord une valeur entière à x, puis lui attribuons une valeur de chaîne. L'interpréteur Python traitera la variable x selon la dernière affectation.

3. Types de données de base

En Python, les types de données de base peuvent être divisés en plusieurs catégories, notamment les nombres, les séquences, les cartes, les ensembles et les valeurs booléennes. Voici un aperçu de ces types de données de base :

nombre :
- Entier (int) : entier positif, 0, entier négatif, tel que 1, 0, -10.
- Float : Nombres avec des décimales, tels que 3.14, -0.001.
- Nombre complexe (complexe) : un nombre composé d'une partie réelle et d'une partie imaginaire, tel que 1j, 2 + 3j.
séquence :
- String (str) : données texte, telles que "Hello, World!", 'Python'.
- Liste : Une collection ordonnée d'éléments. Les éléments peuvent être de différents types, tels que [1, 2, 3], ["a", "b", "c"].
- Tuple : une collection ordonnée immuable d'éléments, tels que (1, 2, 3), ("a", "b", "c").
Cartographie :
- Dictionary (dict) : Une collection de paires clé-valeur, telles que {"name": "Alice", "age": 25}.
rassembler :
- Ensemble : Un ensemble non ordonné avec des éléments uniques, tels que {1, 2, 3}.{1.1, 2.2, 3.3}
Valeur booléenne :
- Booléen : valeur logique avec seulement deux valeurs possibles : Trueet False.

En Python, vous pouvez utiliser type()des fonctions pour vérifier le type de données d'une variable. Par exemple:

x = 100
print(type(x))  # 输出：<class 'int'>

y = 3.14
print(type(y))  # 输出：<class 'float'>

z = "Hello"
print(type(z))  # 输出：<class 'str'>

Comprendre ces types de données de base est important pour écrire du code Python, car ils déterminent les types de données que vous pouvez stocker dans des variables et les opérations que vous pouvez effectuer sur ces données.

4. Détection et conversion du type de données

Détection du type de données

En Python, vous pouvez utiliser type()des fonctions pour vérifier le type de données d'une variable. Vous pouvez également utiliser isinstance()des fonctions pour vérifier si une variable est d'un type spécifique ou est dérivée d'une classe. De plus, si vous devez convertir une variable d'un type de données à un autre, Python fournit des fonctions intégrées à cet effet.

Fonction type() : renvoie le type de variable.
Fonction isinstance() : vérifie si la variable est une instance d'un certain type.

x = 100
print(type(x))  # 输出：<class 'int'>
print(isinstance(x, int))  # 输出：True
print(isinstance(x, float))  # 输出：False

Conversion de types de données

Python fournit une variété de fonctions intégrées pour convertir des variables d'un type de données à un autre. Ces fonctions portent généralement le nom du type de données cible et peuvent être appelées en tant que fonctions.

int() : Convertit une variable en entier.
float() : Convertit une variable en nombre à virgule flottante.
str() : Convertit une variable en chaîne.
list() : Convertit les variables en listes.
tuple() : Convertit les variables en tuples.
set() : Convertit les variables en ensembles.
dict() : Convertit une variable en dictionnaire.
bool() : Convertit une variable en valeur booléenne.

x = "123"
y = int(x)  # 将字符串转换为整数
print(type(y))  # 输出：<class 'int'>

z = float(x)  # 将字符串转换为浮点数
print(type(z))  # 输出：<class 'float'>

a = [1, 2, 3]
b = tuple(a)  # 将列表转换为元组
print(type(b))  # 输出：<class 'tuple'>

Précautions

Lors de la conversion de type, une erreur peut être générée si les données source ne peuvent pas être directement converties en type cible. Par exemple, essayer de convertir une chaîne non numérique en un entier augmentera ValueError.

x = "abc"
y = int(x)  # 尝试将非数字字符串转换为整数，将引发ValueError

Par conséquent, avant d'effectuer une conversion de type, il est judicieux de vérifier que les données peuvent être converties en toute sécurité vers le type requis.

5. Exercice et pratique

Exercice 1 : Créer des variables de différents types et effectuer des opérations simples

# 创建整数变量
number = 10
number += 5  # 加法操作
print(number)  # 输出：15

# 创建浮点数变量
pi = 3.14159
pi *= 2  # 乘法操作
print(pi)  # 输出：6.28318

# 创建字符串变量
greeting = "Hello, "
name = "World"
full_greeting = greeting + name  # 字符串拼接
print(full_greeting)  # 输出：Hello, World

# 创建布尔变量
is_valid = True
is_valid = not is_valid  # 逻辑非操作
print(is_valid)  # 输出：False

Exercice 2 : Démontrer la conversion entre différents types de données

# 字符串转换为整数
str_number = "123"
int_number = int(str_number)
print(type(int_number))  # 输出：<class 'int'>

# 整数转换为字符串
int_number = 456
str_number = str(int_number)
print(type(str_number))  # 输出：<class 'str'>

# 列表转换为元组
list_of_numbers = [1, 2, 3]
tuple_of_numbers = tuple(list_of_numbers)
print(type(tuple_of_numbers))  # 输出：<class 'tuple'>

# 元组转换为集合
tuple_of_numbers = (4, 5, 6)
set_of_numbers = set(tuple_of_numbers)
print(type(set_of_numbers))  # 输出：<class 'set'>

Exercice 3 : Résoudre des problèmes pratiques simples

Question pratique 1 : Calculer l'aire d'un cercle

# 给定半径
radius = 5.0

# 计算面积
area = 3.14159 * radius ** 2
print("圆的面积是：", area)  # 输出：圆的面积是： 78.53975

Question pratique 2 : Déterminer si un nombre est pair ou impair

# 给定一个数
num = 7

# 判断偶数或奇数
if num % 2 == 0:
    print(num, "是偶数")
else:
    print(num, "是奇数")  # 输出：7 是奇数

Grâce à ces exercices, vous pourrez mieux comprendre les variables et les types de données en Python, ainsi que comment effectuer des conversions entre différents types. Ce sont la base pour écrire des programmes plus complexes.

6. Mots-clés Python

False, None, True, and, as, assert, async, await, break, class, continue, def, del, elif, else, 
except, finally, for, from, global, if, import, in, is, lambda, nonlocal, not, or, pass, raise, return, try, while, with, yield

Ces mots-clés jouent des rôles spécifiques dans la syntaxe Python, par exemple :

if, elif, else sont utilisés pour le jugement conditionnel. for, while, break et continue sont utilisés pour le contrôle de boucle. def est utilisé pour définir des fonctions. class est utilisé pour définir des classes. essayez, sauf que, finalement, raise est utilisé pour la gestion des exceptions. import, from sont utilisés pour l’importation de modules. return est utilisé pour renvoyer une valeur d’une fonction. le rendement est utilisé pour la production de valeur dans les fonctions génératrices. True, False et None sont des constantes intégrées à Python. Pour afficher la liste de mots-clés de la version actuelle de l'interpréteur Python, vous pouvez utiliser le module de mots-clés :

import keyword
print(keyword.kwlist)

7. Résumé et perspectives

1. Revue et résumé des points de connaissances de ce chapitre

Ce chapitre se concentre principalement sur les connaissances de base de l'apprentissage du langage Python, en particulier sur des sujets tels que les variables, les types de données, les règles de dénomination des variables, les mots-clés Python, la détection et la conversion des types de données, etc. Ce qui suit est un examen et un résumé des points de connaissances de ce chapitre :

variable :
- Les variables sont des identifiants utilisés pour stocker les valeurs des données.
- Les variables nous permettent de donner un nom aux données afin qu'elles puissent être référencées plusieurs fois dans un programme.
type de données :
- Les types de données de base de Python incluent des nombres (entiers, nombres à virgule flottante, nombres complexes), des séquences (chaînes, listes, tuples), des cartes (dictionnaires), des ensembles et des valeurs booléennes.
- Chaque type de données a sa finalité spécifique et ses règles de fonctionnement.
Règles de dénomination des variables :
- Les noms de variables doivent commencer par une lettre (az, AZ) ou un trait de soulignement (_).
- Les noms de variables peuvent contenir des lettres, des chiffres et des traits de soulignement, mais ils ne peuvent pas commencer par un chiffre.
- Les noms de variables ne peuvent pas être des mots-clés Python.
Mots-clés Python :
- Les mots-clés sont des mots réservés ayant une signification particulière dans le langage Python.
- Les mots-clés ne peuvent pas être utilisés comme noms de variables ou autres identifiants.
Détection et conversion du type de données :
- Utilisez type()une fonction pour détecter le type de données d'une variable.
- Utilisez isinstance()des fonctions pour vérifier si une variable est d'un type spécifique ou dérivée d'une classe.
- Python fournit une variété de fonctions intégrées pour convertir des variables d'un type de données à un autre, telles que int(), float(), str(), list(), tuple(), set()et dict().bool()
Exercices et pratique :
- Entraînez-vous en créant différents types de variables et en effectuant des opérations simples.
- Écrivez des extraits de code pour démontrer la conversion entre différents types de données.
- Résolvez quelques problèmes pratiques simples pour consolider votre compréhension des variables et des types de données.

Comprendre ces bases est crucial pour apprendre Python en profondeur. Ils constituent la base de l’écriture d’un code efficace, efficient et maintenable.

2, perspectives

Journée d'apprentissage du langage Python 4_Structure de contrôle : instructions conditionnelles et boucles

Cet article est une réimpression de l'article Heng Xiaopai et les droits d'auteur appartiennent à l'auteur original. Il est recommandé de consulter le texte original. Pour réimprimer cet article, veuillez contacter l'auteur original.

Journée d'apprentissage du langage Python 3_Variables et types de données de base