1. La définition et l'utilisation des variables
Les variables se composent de trois parties: nom de variable, expression d'opération, valeur
name='楚留香'
print(name,id(name))
print(name,type(name))
print(name)
En fait, la valeur de l'identifiant est stockée dans le nom. Cette valeur de l'identifiant est stockée à la fois dans le nom et dans "Chu Liuxiang", qui sont identiques. Lors de l'impression (nom), l'identifiant correspondant à la valeur du nom sera trouvé «Chu Liuxiang», puis affichez, dans des circonstances normales, seuls l'identifiant, le type et la valeur sont stockés dans la mémoire des variables que vous avez nommée. Le nom de la variable équivaut à un pointeur. Si plusieurs affectations sont effectuées, la valeur de l'ID correspondant au pointeur change et pointe vers la valeur de l'ID correspondant à différentes valeurs
name='楚留香'
name='张三'
print(name,id(name))
print(name,type(name))
print(name)
Deux, type de données
1. Entier : int
2. Type à virgule flottante : float
Après avoir ajouté des variables à virgule flottante, il peut y avoir des valeurs inexactes. Vous pouvez envisager d'introduire le module décimal. Decimal est en fait un type de données. Il s'agit d'un type de données décimal. En fait, il s'agit d'une conversion de type forcée du type flaot. Si il n'est pas permis d'ajouter des nombres à virgule flottante, il n'y aura aucune erreur lors de l'ajout de nombres à virgule flottante.
Pour le module décimal, vous pouvez utiliser son propre attribut getcontext (). Prec pour modifier sa précision. En supposant que la précision est 1, elle équivaut à un seul nombre, et ainsi de suite, sa précision par défaut est de 28 chiffres.
La différence entre ce nombre et le type de nombre à virgule flottante est qu'il est plus précis. Par conséquent, lorsque vous avez besoin d'exprimer le nombre de manière très précise, vous devez utiliser un nombre décimal. Le nombre à virgule flottante peut facilement représenter une large plage de nombres, mais il n'est pas très précis, et ils sont approximatifs, donc utilisez généralement des décimales pour représenter la valeur exacte
import decimal
decimal.getcontext().prec=28
n1=1.1
print(n1,type(n1))
n2=2.2
print(n1+n2)
#print(Decimal('n1')+Decimal('n2')) 这样是不行的，因为他是数据类型，你不可以吧变量名放进去让他类型转换，你只可以放变量的值进去进行类型转换
print(decimal.Decimal('1.1')+decimal.Decimal('2.2'))
print(decimal.getcontext().prec)
m1=decimal.Decimal('1.1')
m2=decimal.Decimal('2.2')
print(m1+m2)
3. Type booléen: il
n'y a que deux valeurs: true et false.
Contrairement à d'autres langages, il peut être directement calculé comme un entier. True vaut 1 par défaut, False vaut 0, car python est strictement sensible à la casse, donc vrai. doit être en majuscule et le faux F doit également être en majuscule
m1=True
m2=False
print(m1,type(m1))
print(m2,type(m2))
print(m1+1) #结果是2
print(m2-1) #结果是-1
4. type de données str
La définition de chaîne peut utiliser des guillemets simples, des guillemets doubles ou des guillemets triples. La différence entre les guillemets triples et les autres guillemets est que la valeur de sa chaîne peut être saisie ou affichée sur deux lignes
str1='人生苦短，我用python'
str2="人生苦短，我用python"
str3='''人生苦短，我用python'''
str4="""人生苦短，我用python"""
str5='''人生苦短，
我用python'''
str6=""""人生苦短，
我用python
"""
print(str1)
print(str2)
print(str3)
print(str4)
print(str5)
print(str6)
5. La conversion de type Str est
généralement utilisée dans le cas des éditeurs de liens, car l'éditeur de liens exige que les types de données avant et après la connexion soient cohérents, de sorte que la conversion de type est utilisée.
name='张三'
age=20
#print('我的名字是：'+name+'，我的年龄是多大：'+age) #因为连接符前后数据类型不一样，所以报错
print('我的名字是'+name+'，我的年龄是：'+str(age))
6. Conversion de type int
Généralement, seule la valeur du type chaîne peut être convertie en entier et la décimale doit être ignorée lors de la conversion avec un nombre à virgule flottante. Lors de la conversion d'un type booléen, la conversion peut être effectuée normalement.
s1='98'
s2='98.8'
s3='tom'
f1=98.8
b1=True
b2=False
print(s1,s2,s3,f1,b1,b2)
print(int(s1))
#print(int(s2)) 不是整型，不能转换
print(int(s3)) 不是整型，不能转换
print(int(f1)) #转完之后直接取整
print(int(b1))
print(int(b2))
7. Conversion de type de nombre à virgule flottante: float ()
peut tout convertir sauf la partie de la chaîne qui ne peut pas être convertie. De plus, lorsque la valeur convertie est un entier, il remplira automatiquement des zéros, quel que soit le type de l'entier est de
s1='1980'
s2='198.59'
s3='hello'
i1=95
b1=True
b2=False
print(float(s1)) #他转换为1980.0，因为是整数，所以带0
print(float(s2)) #转换为198.59
#print(float(s3)) #无法转换，因为是文字
print(float(i1)) #他转换为95.0，因为是整数，所以带0
print(float(b1)) #他转换为1.0，因为是整数，所以带0
print(float(b2)) #他转换为0.0，因为是整数，所以带0
8. Mode commentaire
Il existe trois modes de commentaire:
# 1. Le premier est très courant # pour commenter
2. Le second est de commenter avec des guillemets triples, car la chaîne représentée par des guillemets triples peut être enveloppée, vous pouvez donc exprimer des commentaires, par exemple
''''嘿嘿嘿，
我是一个
注释哦
'''
3. Le troisième type consiste à spécifier la méthode d'ouverture du fichier python dans la première ligne du fichier pyth. Par exemple, la première ligne du fichier python indique le format qu'il a ouvert
#coding:utf-8
print('hello world')