Résumé détaillé des types de données et opérateurs Python (exemples de code)

Cet article vous apporte un résumé détaillé (exemples de code) des types de données et des opérateurs Python. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

L'article précédent parlait des entrées, des sorties et des variables de Python. Cette section explorera les types de données de Python et les méthodes de calcul entre les données !

1. Types de données Python

La section précédente a clarifié les variables. En fait, les valeurs pointées par les variables ont leurs propres types de données uniques. En Python, on trouve principalement les types de données suivants :

Entier (int)

Dans les ordinateurs, le nombre de chiffres dans les entiers a en fait une plage, et n'est pas infini comme on l'imagine. nombre de chiffres, et le nombre de chiffres dans l'entier peut être différent selon les machines, par exemple :

Système 32 bits : le nombre de chiffres dans l'entier est de 32 bits, et la plage d'adressage est : -2³¹ ~ 2³¹-1, soit -2147483648 ~ 2147483647

Système 64 bits : le nombre de chiffres dans l'entier est de 64 bits, et la plage d'adressage est : -2⁶³ ~ 2⁶³-1, soit -9223372036854775808 ~ 9223372036854775807

Entier long (long)

In Python, l'entier long ne précise pas le nombre de chiffres, c'est-à-dire que l'entier long peut être infiniment grand, mais en raison des limitations de la machine elle-même, il ne peut souvent pas être infiniment grand et ne fonctionnera pas dans un certain délai. gamme.

Type à virgule flottante (float)

Les deux types de données ci-dessus sont des entiers, mais en réalité ils ne sont pas tous des entiers, il y a aussi des décimaux, donc le type à virgule flottante est né. pour parler franchement, la virgule flottante est une décimale et la notation scientifique peut être utilisée. Dans les ordinateurs, les multiples de 10 en notation scientifique sont remplacés par e. Par exemple : 5.21x10⁵ s'écrit 5.21e9, ou 521e7

Complexe

La combinaison des trois types de données ci-dessus est un nombre réel. En fait, les nombres complexes sont souvent utilisés dans les calculs scientifiques. En Python, il existe un type de données complexe. la forme générale est : x+yj , où x et y sont tous deux des nombres réels, par exemple : 5+6j

Valeur booléenne (Vrai, Faux)

Il n'y a que deux valeurs booléennes : true et false, représentés par True et False en Python, assurez-vous de mettre en majuscule la première lettre. Python est sensible à la casse, alors assurez-vous d'y prêter attention.

In [77]: 5==6
Out[77]: False
In [78]: 3>2
Out[78]: True
In [79]: True == True
Out[79]: True
In [80]: True == False
Out[80]: False

Aucune valeur (Aucune)

Il n'y a qu'une seule valeur nulle : Aucune Cette valeur nulle est très intéressante. non autorisé. Il est compris comme 0, car 0 n'est pas une valeur nulle, tout comme la température est de 0 degré Celsius, 0 degré Celsius a une température (￣▽￣)"

Chaîne (str)

Chaîne possible C'est le type de données le plus couramment utilisé dans l'écriture de Python. Tant qu'il est placé entre guillemets, il s'agit d'une chaîne. Python ne fait pas la distinction entre les guillemets simples, les guillemets doubles et les guillemets triples. Ce sont les mêmes :

In [81]: 'Hello,world!'
Out[81]: 'Hello,world!'
In [82]: "Hello,world!"
Out[82]: 'Hello,world!'
In [83]: '''Hello,world'''
Out[83]: 'Hello,world'

Il y aura certainement des débutants qui demanderont, qu'est-ce que tu fais avec tant de choses si tu ne peux pas n'en utiliser qu'une, je le ferai ? en finir avec ça. J'ai juste souri en silence et je n'ai rien dit :

In [84]: 'i'm MinuteSheep'
  File "<ipython-input-84-a2a810ee38cb>", line 1
    &#39;i&#39;m MinuteSheep&#39;
       ^
SyntaxError: invalid syntax

Regardez, pourquoi ? Parce que Python correspondra automatiquement au symbole le plus proche et se fermera. cela, donc la situation ci-dessus se produira. Apportez les modifications suivantes :

In [85]: "i'm MinuteSheep"
Out[85]: "i'm MinuteSheep"

(Mengxin : Votre mauvais vieil homme est très mauvais ╰( ‵□′)╯)

De même, les guillemets triples sont utilisés pour plusieurs lignes ou contenus. Confusion des symboles :

In [87]: '''i'm MinuteSheep,i said:"i'm the best man in the world!"'''
Out[87]: 'i\'m MinuteSheep,i said:"i\'m the best man in the world!"'
In [86]: '''
    ...: i'm MinuteSheep,
    ...: i said:
    ...: "i'm the best man in the world!"
    ...: '''
Out[86]: '\ni\'m MinuteSheep,\ni said:\n"i\'m the best man in the world!"\n'

est parfaitement résolu. Vous souvenez-vous de ce que signifie n ? Cela signifie un saut de ligne. De même, vous constaterez que je suis devenu. C'est en fait l'affichage de l'évasion. > Il y a encore un nouveau venu. N'avez-vous pas dit dans la section précédente que trois citations sont des commentaires sur plusieurs lignes ? , comment cette section est-elle devenue une chaîne

C'est une bonne question ! mon explication, il y a des images et la vérité :

Directement Le contenu entre guillemets triples est un commentaire Tant que le contenu entre guillemets triples est affecté à une variable, c'est la chaîne

. Il existe de nombreuses méthodes pour les chaînes. Il y aura une section spéciale pour expliquer les méthodes des chaînes en détail plus tard. >Liste

Les débutants ne sont peut-être pas familiers avec les listes. Vous pouvez temporairement les comprendre comme unidimensionnelles. les tableaux. Les listes sont beaucoup utilisées en Python, sauf pour les chaînes. Un type de données qu'il faut maîtriser. Voyons à quoi ressemble la liste :

<. 🎜>Comme vous pouvez le voir, les données entourées d'une paire de crochets sont Les listes peuvent contenir d'autres types de données. Les listes ci-dessus incluent : des chaînes et des entiers. Bien sûr, les listes peuvent contenir des listes, ce que l'on appelle l'imbrication de listes : <🎜. >

In [88]: ['MinuteSheep', 'LiMing', '123', 123]
Out[88]: ['MinuteSheep', 'LiMing', '123', 123]

Il existe de nombreuses méthodes spécifiques concernant les listes. Je ne les présenterai pas une par une ici. Il y aura une section spéciale expliquant les méthodes de liste plus tard. 🎜>

Tuple (tuple)

Les tuples sont peut-être encore plus inconnus. Les tuples sont en fait des listes immuables. La liste est entourée d'un ensemble de crochets, tandis que le tuple est entouré d'une paire de crochets. . La liste peut être manipulée (comme l'ajout, la suppression et la modification). , vérifiez), mais les tuples ne peuvent pas être modifiés :

In [89]: ['MinuteSheep', ['LiMing', 123]]
Out[89]: ['MinuteSheep', ['LiMing', 123]]

<. 🎜>

字典（dict）

字典是Python的一种非常强大的数据类型，通过键值对的形式将数据保存下来，提高了数据增、删、改、查的速度，通常作为数据存储的格式，也来看看字典长啥样哇：

In [91]: {'name': 'MinuteSheep', 'gender' : 'male', 'age': 99}
Out[91]: {'age': 99, 'gender': 'male', 'name': 'MinuteSheep'}

可以看到，字典是用一对花括号括起来的，并且以 'key' : 'value' 的形式存储，同样，字典里面可以包含其他数据类型，上面的字典包括：字符串、整型。当然，字典也可以嵌套：

In [92]: {'name' : 'MinuteSheep', 'age': {'young' : 15, 'old' : 99}}
Out[92]: {'age': {'old': 99, 'young': 15}, 'name': 'MinuteSheep'}

字典也会有专门的一节去讲解它的方法。

二、Python数据运算

说完了Python的数据类型，就该数据运算了，养兵千日，用在一时嘛

算数运算

加 +

In [93]: 1+2
Out[93]: 3

减 -

In [95]: 1-2O
ut[95]: -1

乘 *

In [96]: 1*2
Out[96]: 2

除 /

In [97]: 5/2Out[97]: 2.5

取模 % （就是取余数）

In [98]: 5%2
Out[98]: 1

取整 //

In [99]: 5//2
Out[99]: 2

幂 **

In [100]: 5**2
Out[100]: 25

赋值运算

简单赋值 =

In [102]: a=5
In [103]: b=6
In [104]: c=a+b
In [105]: c
Out[105]: 11

加法赋值 += （b+=a，相当于b=b+a）

In [106]: a=5
In [107]: b=6
In [108]: b+=a
In [109]: b
Out[109]: 11

减法赋值 -= （b-=a，相当于b=b-a）

In [111]: a=5
In [112]: b=6
In [113]: b-=a
In [114]: b
Out[114]: 1

乘法赋值 *= （b*=a，相当于b=b*a）

In [115]: a=5
In [116]: b=6
In [117]: b*=a
In [118]: b
Out[118]: 30

除法赋值 /= （b/=a，相当于b=b/a）

In [119]: a=5
In [120]: b=6
In [121]: b/=a
In [122]: b
Out[122]: 1.2

取模赋值 %= （b%=a，相当于b=b%a）

In [123]: a=5
In [124]: b=6
In [125]: b%=a
In [126]: b
Out[126]: 1

取整赋值 //= （b//=a，相当于b=b//a）

In [127]: a=5
In [128]: b=6
In [129]: b//=a
In [130]: b
Out[130]: 1

幂赋值 **= （b**=a，相当于b=b**a）

In [131]: a=5
In [132]: b=6
In [133]: b**=a
In [134]: b
Out[134]: 7776

比较运算

测试相等 ==

In [136]: 1==1
Out[136]: True
In [137]: 1==2
Out[137]: False

不等于 !=

In [144]: 1!=1
Out[144]: False
In [145]: 1!=2
Out[145]: True

大于 >

In [146]: 1>1
Out[146]: False
In [147]: 2>1
Out[147]: True

大于等于 >=

In [149]: 1>=1
Out[149]: True
In [150]: 2>=1
Out[150]: True

小于 <

In [151]: 6<6
Out[151]: False
In [152]: 6<7
Out[152]: True

小于等于 <=

In [153]: 6<=6
Out[153]: True
In [154]: 6<=7
Out[154]: True

逻辑运算

布尔'与' and (有假为假，全真为真）

In [156]: True and False
Out[156]: False
In [157]: True and True
Out[157]: True
In [158]: False and False
Out[158]: False

布尔'或' or (有真为真，全假为假）

In [159]: True or True
Out[159]: True
In [160]: True or False
Out[160]: True
In [161]: False and False
Out[161]: False

布尔'非' not （取相反）

In [162]: not True
Out[162]: False
In [163]: not False
Out[163]: True

身份运算

判断两个标识符是否引用自同一个对象 is

In [167]: a=b=3

In [168]: a is b
Out[168]: True

In [169]: a=3

In [170]: b=5

In [171]: a is b
Out[171]: False

判断两个标识符是否引用自不同对象 is not

In [177]: a=3
In [178]: b=5
In [179]: a is not b
Out[179]: True

== 与 is 的区别：

看到这里，很多小伙伴已经晕了，== 和 is 好像一样啊，看起来一样，其实是不一样的，来看下面的这段代码：

In [180]: a = 600
In [181]: b = 600
In [182]: a == b
Out[182]: True
In [183]: a is b
Out[183]: False

其实啊，== 比较的是值，is比较的地址，让我们用 id() 这个函数查看一下变量的地址：

In [184]: id(a)
Out[184]: 2155434581648
In [185]: id(b)
Out[185]: 2155434581904

可以看到，a和b俩个变量的值虽然相同，但地址却不一样，所以使用 == 和 is 的结果自然就不一样。那我们再来看一段代码：

In [187]: a = 10
In [188]: b = 10
In [189]: a == b
Out[189]: True
In [190]: a is b
Out[190]: True
In [191]: id(a)
Out[191]: 1529742064
In [192]: id(b)
Out[192]: 1529742064

萌新是不是莫不着头脑了，用600的时候 is 输出False，用10的时候怎么地址一样了啊，（快回头，有鬼~）其实啊，Python有一个叫做小整数对象池的东西，只要是[-5, 256]之间的整数都会使用同一份地址，这下萌新明白了哇。

位运算

重点说明：位运算针对的是二进制数

按位与 &

In [193]: a = 15   # 15 = 0000 1111
In [194]: b = 30   # 30 = 0001 1110
In [195]: c = a&b  # 14 = 0000 1110
In [196]: c
Out[196]: 14

按位或 |

In [193]: a = 15   # 15 = 0000 1111
In [194]: b = 30   # 30 = 0001 1110
In [197]: c = a|b  # 31 = 0001 1111
In [198]: c
Out[198]: 31

按位异或 ^

In [193]: a = 15   # 15 = 0000 1111
In [194]: b = 30   # 30 = 0001 1110
In [200]: c = a^b  # 17 = 0001 0001
In [201]: c
Out[201]: 17

按位取反 ~

In [210]: a = 60   # 60 = 0011 1100
In [211]: c = ~a  # -61 = 1100 0011
In [212]: c
Out[212]: -61

左移 <<

In [213]: a = 15   # 15 = 0000 1111
In [214]: c = a<<2 # 60 = 0011 1100
In [215]: c
Out[215]: 60#左移后面要加位数

右移 >>

In [213]: a = 15     # 15 = 0000 1111
In [218]: c = a>>2    # 3 = 0000 0011 
In [219]: c
Out[219]: 3#右移后面要加位数

Python运算符优先级（从高到底依次排列）

**                 # 指数 (最高优先级)
~ + -              # 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % //           # 乘，除，取模和取整除
+ -                # 加法减法
>> <<              # 右移，左移运算符
&                  # 位 &#39;AND&#39;
^ |                # 位运算符
<= < > >=          # 比较运算符
<> == !=           # 等于运算符
= %= /= //= -= += *= **=    # 赋值运算符
is is not          # 身份运算符
in not in          # 成员运算符
not and or         # 逻辑运算符

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!