I. Aperçu
Les variables en Python n'ont pas besoin d'être déclarées. Chaque variable doit se voir attribuer une valeur avant d'être utilisée, et la variable n'est créée qu'après qu'une valeur lui est attribuée.
En Python, une variable n'est qu'une variable ; elle n'a pas de type. Le « type » auquel nous faisons référence est le type de l'objet en mémoire vers lequel la variable pointe.
Le signe égal (=) est utilisé pour attribuer des valeurs aux variables.
Le côté gauche de l'opérateur signe égal (=) est un nom de variable, et le côté droit de l'opérateur signe égal (=) est la valeur stockée dans la variable.
Par exemple :
#!/usr/bin/python3 counter = 100 # 整型变量 miles = 1000.0 # 浮点型变量 name = "example" # 字符串 a = b = c = 1 # 同时为多个变量赋值 a,b,c=1,2,'hello' # 为多个对象指定多个变量
II. Types de données standard
Python3 possède six types de données standard :
Number（数字） String（字符串） List（列表） Tuple（元组） Sets（集合） Dictionary（字典）
2.1 Nombre
Python3 prend en charge int, float, bool et complex (nombres complexes).
Il n'existe qu'un seul type entier, int, représenté comme un entier long. Il n'y a pas de Long comme dans Python2.
La fonction intégrée type() peut être utilisée pour interroger le type de l'objet référencé par une variable.
>>> a,b,c,d=5,6.7,true,2+3j Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name 'true' is not defined >>> a,b,c,d=5,6.7,True,2+3j >>> print(type(a),type(b),type(c),type(d)) <class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
Remarque :
- 1. Python peut affecter des valeurs à plusieurs variables en même temps, par exemple, a, b = 1, 2.
- 2. Une variable peut pointer vers des objets de types différents par affectation.
- 3. La division numérique (/) renvoie toujours un nombre à virgule flottante (print(2/4) affiche 0.5) ; pour obtenir un entier, utilisez l'opérateur //.
- 4. Dans les calculs mixtes, Python convertit les entiers en nombres à virgule flottante. 5. Booléen : True et False, 1 et 0.
- 6. L'instruction del peut supprimer des objets définis, par exemple, del a,b.
2.2 Chaîne de caractères
Les chaînes de caractères en Python sont entourées de guillemets simples (') ou de guillemets doubles ("), et les barres obliques inverses servent à échapper les caractères spéciaux.
La syntaxe de découpage des chaînes est la suivante :
variable[start_index:end_index]
L'index commence à 0, et -1 est la position de départ depuis la fin.
Le signe plus (+) est l'opérateur de concaténation de chaînes, et l'astérisque (*) signifie répéter la chaîne actuelle ; le nombre qui le suit est le nombre de répétitions.
Exemple :
#!/usr/bin/python3
# -*- coding:UTF-8 -*-
str='hello,world!'
print(str) # 输出字符串
print(str[0:-1]) # 输出第一个到倒数第二个的所有字符
print(str[0]) # 输出字符串第一个字符
print(str[2:5]) # 输出从第三个开始到第五个的字符
print(str[2:]) # 输出从第三个开始的后的所有字符
print(str * 2) # 输出字符串两次
print(str + '你好') # 连接字符串
print('------------------------------')
print('hello\nworld') # 使用反斜杠(\)+n转义特殊字符
print(r'hello\nworld') # 在字符串前面添加一个 r，表示原始字符串，不会发生转义
Résultat de l'exécution :
hello,world! hello,world h llo llo,world! hello,world!hello,world! hello,world!你好 ------------------------------ hello world hello\nworld
Remarque :
- 1. Les barres obliques inverses peuvent être utilisées pour échapper des caractères. Utiliser r peut empêcher les barres obliques inverses d'être échappées.
- 2. Les chaînes de caractères peuvent être concaténées avec l'opérateur + et répétées avec l'opérateur *.
- 3. Les chaînes de caractères en Python ont deux méthodes d'indexation : en partant de 0 de gauche à droite, et en partant de -1 de droite à gauche.
- 4. Les chaînes de caractères en Python ne peuvent pas être modifiées.
- 5. Python n'a pas de type caractère séparé ; un caractère est une chaîne de longueur 1.
2.3 Liste
La liste est le type de données le plus fréquemment utilisé en Python.
Les listes peuvent implémenter la plupart des structures de données de type collection.
Les types des éléments d'une liste peuvent être différents. Elles prennent en charge les nombres, les chaînes de caractères, et peuvent même contenir des listes (ce qu'on appelle l'imbrication).
Une liste s'écrit entre crochets [] avec les éléments séparés par des virgules.
Comme les chaînes de caractères, les listes peuvent être indexées et découpées. Après le découpage d'une liste, elle renvoie une nouvelle liste contenant les éléments requis.
La syntaxe pour le découpage de liste est la suivante :
variable[start_index:end_index]
L'index commence à 0, et -1 est la position de départ depuis la fin.
Le signe plus (+) est l'opérateur de concaténation de listes, et l'astérisque (*) est l'opération de répétition.
Exemple :
#!/usr/bin/python3 # -*- coding:UTF-8 -*- list=['hello',357,6.6,'world'] ttlist=[123,'new'] print(list) # 输出完整列表 print(list[0]) # 输出列表第一个元素 print(list[1:3]) # 输出从第2个开始到第3个元素 print(list[2:]) # 输出从第三个开始的后的所有元素 print(ttlist * 2) # 输出两次列表 print(str + ttlist) # 连接列表
Résultat de l'exécution :
['hello', 357, 6.6, 'world'] hello [357, 6.6] [6.6, 'world'] [123, 'new', 123, 'new'] ['hello', 357, 6.6, 'world', 123, 'new']
Contrairement aux chaînes Python, les éléments d'une liste peuvent être modifiés :
>>> new=[1,2,3,4,5,'hi'] >>> new [1, 2, 3, 4, 5, 'hi'] >>> new[1]='hehe' #改变列表new中的第2个元素为hehe >>> new [1, 'hehe', 3, 4, 5, 'hi'] >>> new[2:4]=[8,10] #改变列表new中的第3/4个元素为8,9 >>> new [1, 'hehe', 8, 10, 5, 'hi' >>> new[2:4]=[] #删除列表new中的第3、4个元素 >>> new [1, 'hehe', 5, 'hi'] >>> new[2:3]=[]
Remarque :
- 1. Les listes s'écrivent entre crochets, avec les éléments séparés par des virgules.
- 2. Comme les chaînes de caractères, les listes peuvent être indexées et découpées.
- 3. Les listes peuvent être concaténées à l'aide de l'opérateur +.
- 4. Les éléments d'une liste peuvent être modifiés.
2.4 Tuple
Les tuples sont similaires aux listes, sauf que les éléments d'un tuple ne peuvent pas être modifiés.
Les tuples s'écrivent entre parenthèses () et les éléments sont séparés par des virgules.
Les types des éléments dans un tuple peuvent aussi être différents.
Les tuples sont similaires aux chaînes de caractères en ce qu'ils peuvent être indexés, l'index commençant à 0 et -1 étant la position depuis la fin. Ils peuvent aussi être découpés.
En fait, une chaîne peut être vue comme un type particulier de tuple.
La construction d'un tuple contenant 0 ou 1 élément est particulière, il y a donc quelques règles de syntaxe supplémentaires :
tup1 = () # 空元组 tup2 = (20,) # 一个元素，需要在元素后添加逗号
chaîne, liste et tuple sont tous des séquences.
Remarque :
- 1. Comme les chaînes de caractères, les éléments d'un tuple ne peuvent pas être modifiés.
- 2. Les tuples peuvent aussi être indexés et découpés de la même manière.
- 3. Faites attention aux règles de syntaxe particulières pour construire des tuples avec 0 ou 1 élément.
- 4. Les tuples peuvent aussi être concaténés à l'aide de l'opérateur +.
2.5 Ensembles
Un ensemble est une séquence non ordonnée d'éléments uniques.
Ses fonctions de base sont le test d'appartenance et la suppression des éléments en double.
Vous pouvez utiliser des accolades { } ou la fonction set() pour créer un ensemble. Remarque : pour créer un ensemble vide, vous devez utiliser set() au lieu de { }, car { } est utilisé pour créer un dictionnaire vide.
Exemple :
#!/usr/bin/python3
student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
print(student) # 输出集合，重复的元素被自动去掉
# 成员测试
if ('Rose' in student):
print('Rose 在集合中')
else:
print('Rose 不在集合中')
# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')
print(a)
print(b)
print(a - b) # a和b的差集
print(b - a) # b和a的差集
print(a | b) # a和b的并集
print(a & b) # a和b的交集
print(a ^ b) # a和b中不同时存在的元素
Résultat de sortie :
{'Jim', 'Mary', 'Rose', 'Tom', 'Jack'}
Rose 在集合中
{'d', 'c', 'r', 'a', 'b'}
{'l', 'c', 'm', 'a', 'z'}
{'d', 'b', 'r'}
{'l', 'm', 'z'}
{'l', 'd', 'c', 'r', 'm', 'a', 'b', 'z'}
{'c', 'a'}
{'l', 'd', 'r', 'm', 'b', 'z'}
2.6 Dictionnaire
Le dictionnaire est un autre type de données intégré très utile en Python.
Les listes sont des collections ordonnées d'objets, tandis que les dictionnaires sont des collections non ordonnées d'objets.
La différence entre les deux est que les éléments d'un dictionnaire sont accessibles par clé, et non par décalage.
Un dictionnaire est un type de mappage. Les dictionnaires sont identifiés par "{ }" et sont une collection non ordonnée de paires clé: valeur.
Les clés doivent utiliser des types immuables.
Dans un même dictionnaire, les clés doivent être uniques.
Exemple :
#!/usr/bin/python3
dict = {}
dict['one'] = "1 - hello,world"
dict[2] = "2 - 嘿嘿"
tinydict = {'name': 'lucy', 'code': 100, 'class': '5年级6班'}
print(dict['one']) # 输出键为 'one' 的值
print(dict[2]) # 输出键为 2 的值
print(tinydict) # 输出完整的字典
print(tinydict.keys()) # 输出所有键
print(tinydict.values()) # 输出所有值
Résultat de sortie :
1 - hello,world
2 - 嘿嘿
{'name': 'lucy', 'code': 100, 'class': '5年级6班'}
dict_keys(['name', 'code', 'class'])
dict_values(['lucy', 100, '5年级6班'])
Fonctions intégrées :
get : renvoie la valeur correspondante en fonction de la clé ; si aucune valeur n'est trouvée, renvoie None sans lever d'erreur.
>>> dic = {'k1':'v1','k2':'v2'}
>>> v = dic.get('k1')
>>> print(v)
v1
clear : vide le dictionnaire.
>>> dic = {'k1':'v1','k2':'v2'}
>>> v = dic.clear()
>>> print(dic)
{}
>>> print(v)
None
copy : copie (copie superficielle).
>>> dic = {'k1':'v1','k2':'v2'}
>>> v = dic.copy()
>>> print(v)
{'k1':'v1','k2':'v2'}
pop : supprime et récupère la valeur correspondante.
>>> dic = {'k1':'v1','k2':'v2'}
>>> v = dic.pop('k1')
>>> print(dic)
{'k2':'v2'}
>>> print(v)
v1
popitem : supprime aléatoirement une paire clé-valeur et récupère la clé et la valeur supprimées.
>>> dic = {'k1':'v1','k2':'v2'}
>>> v = dic.popitem()
>>> print(dic)
{'k1':'v1'}
>>> print(v)
{'k2':'v2'}
setdefault : ajoute ; si la clé existe, ne fait rien.
>>> dic = {'k1':'v1','k2':'v2'}
>>> dic.setdefault('k3','v3')
>>> print(dic)
{'k1':'v1','k2':'v2','k3':'v3'}
update : ajoute ou modifie par lots.
dic = {'k1':'v1','k2':'v2'}
dic.update({'k3':'v3','k4':'v4'})
print(dic)
{'k1':'v1','k2':'v2','k3':'v3','k4':'v4'}
Remarque :
- 1. Un dictionnaire est un type de mappage, et ses éléments sont des paires clé-valeur.
- 2. Les clés d'un dictionnaire doivent être de types immuables et ne peuvent pas être dupliquées.
- 3. Utilisez { } pour créer un dictionnaire vide.
III. Conversion de types de données
Pour la conversion de type de données, vous utilisez simplement le type de données comme nom de fonction.
Les fonctions intégrées suivantes peuvent effectuer des conversions entre types de données. Ces fonctions renvoient un nouvel objet représentant la valeur convertie.
| Fonction | Description | |
|---|---|---|
| int(x [,base]) | Convertit x en un entier. | |
| float(x) | Convertit x en un nombre à virgule flottante. | |
| complex(real [,imag]) | Crée un nombre complexe. | |
| str(x) | Convertit l'objet x en une chaîne de caractères. | |
| repr(x) | Convertit l'objet x en une chaîne d'expression. | |
| eval(str) | Utilisé pour évaluer une expression Python valide dans une chaîne et renvoyer un objet. | |
| tuple(s) | Convertit la séquence s en un tuple. | |
| list(s) | Convertir la séquence s en une liste. | |
| set(s) | Convertir en un ensemble mutable. | |
| dict(d) | Créer un dictionnaire. d doit être une séquence de tuples (clé, valeur). | |
| frozenset(s) | Convertir en un ensemble immuable. | |
| chr(x) | Convertir un entier en caractère. | |
| unichr(x) | Convertir un entier en caractère Unicode. | |
| ord(x) | Convertir un caractère en sa valeur entière. | |
| hex(x) | Convertir un entier en une chaîne hexadécimale. | |
| oct(x) | Convertir un entier en une chaîne octale. | |
Adresse de l'article original : https://segmentfault.com/a/1190000009722187