Chapitre 2 Types de données Python

Section 1 Types de nombres et de chaînes

123 est-il identique à "123" ?

() [] {}

L'ordinateur est utilisé pour aider les gens, les classifications du monde réel sont également cartographiées dans la programmation pour faciliter l'analyse abstraite.

Numéro

Chaîne

Liste

Tuple

Dictionnaire

Nous examinons quelques types de données simples à travers les types de données, et python identifiera automatiquement le type de données

>>> ; num1=123
>>> type(123)

>>> 🎜>>>> num='hello'


>>> type (num)

La plage représentée par un entier int en python est -2,147,483,648 à 2,147,483,647

Par exemple : 0,100,,100

Un exemple de plage de Int est présenté ci-dessus.

>>> num3=123L Ici, nous attribuons la valeur en type entier long

>>> type(num3)

Par exemple : 0.0, 12.0,, 18.8, 3e 7, etc.

Exemple :

>>> num=0.0

> ;> ;> type(num)

>>> =12.0

>>> type(num)

Python fournit une prise en charge intégrée des nombres complexes, ce que la plupart des autres logiciels n'ont pas :


Exemples au pluriel : 3.14j, 8.32e-36j


Exemple :

>>> >>> ; type(num)

>>> num

3.14j

>>> imprimer num

3.14j

>>>


Nous distinguons ici les deux types de variables différents suivants

>>> 🎜>> >> stra="123"
>>> imprimer un

123

>>> > a stra Nous constatons ici que ces deux types différents de variables ne peuvent pas être exploités
Traceback (dernier appel le plus récent) :

Fichier "", ligne 1, dans

TypeError : type(s) d'opérande non pris en charge pour : 'int' et 'str'
>>>

>>> type(a)

>>>

String String


Un ensemble défini à l'aide de guillemets pouvant contenir des chiffres, des lettres et des symboles (symboles système non spéciaux).


>>> str1='bonjour le monde'


>>> >> say='allons-y' Il y a une erreur dans cette définition, car lorsque nous la définissons ici, elle contient également un guillemet simple
Fichier "", ligne 1
say='allons-y'
^
SyntaxError : syntaxe invalide

>>> say="allons-y" Nous pouvons remplacer les guillemets simples externes par des guillemets doubles

> ;>> say="allons-y"" S'il y a des guillemets doubles à l'intérieur de nos guillemets doubles, nous devons utiliser des caractères d'échappement

Fichier "", ligne 1

say="allons-y "" c'est parti

Regardons l'utilisation de quelques caractères d'échappement

>>> >>> print mail
tom: bonjour, je suis jack
>>> mail='tom:n bonjour, je suis jack' Pour les caractères ci-dessus, si nous voulons utiliser la sortie de nouvelle ligne
>>> mail
'tom:n bonjour, je suis jack'

>>> imprimer le mail

tom:
bonjour

je suis Jack

Ci-dessous, nous utilisons des guillemets triples pour obtenir l'effet de saut de ligne :

>>> mail="""tom :
. .. je suis Jack
... au revoir
... """
>>> imprimer le mail
tom :
je suis Jack
au revoir

>>> mail Ici, nous pouvons voir que lorsque nous utilisons des guillemets triples, il enregistrera notre entrée
'tom:nti am jackn goodbyen'

De plus, nous sommes Vous pouvez également utiliser des guillemets triples pour commenter une certaine ligne du code, ou vous pouvez l'utiliser pour créer des données de document

Obtenir la valeur via l'index

>>> a='abcde'

>>> a[0] Nous utilisons l'index pour obtenir une certaine valeur dans la chaîne

'a'
>>> a[ 1]
'b'
>>> a[0] a[1] Si nous voulons en prendre plus d'un, nous pouvons utiliser le numéro au milieu pour connecter

'ab'

Utilisez des tranches pour obtenir des valeurs

>>> 🎜>
'abcde'

Jetons un coup d'oeil au fonctionnement ici, a[position de départ : position de fin 1 : étape]

>>> [1:4] Ici, nous prenons bcd, utilisons [start position: end position 1] pour obtenir la valeur

'bcd'

>>> 4] Cela signifie couper du début à d

'abcd'

>>> Couper la valeur suivante à partir de la quatrième position

'e'

>>>a[2:]

'cde'

>>> a[::1] Par étape Pour obtenir la valeur, c'est plus clair lorsque la taille du pas est de 2 en dessous de

'abcde'

>>> :2]


'ace'

>>> a[-4:-1] prend la valeur via un indice négatif Ici, nous commençons de l'arrière vers l'avant. , et -1 représente l'avant-dernière valeur

'bcd'

>>> puis affichez la valeur précédente

'abcd'

Nous pouvons voir son ordre de valeur des deux manières suivantes

>>> [-2:-4:-1] Il est de tous Le nombre est d'abord inversé, puis la valeur est coupée de la deuxième position à la troisième position de 'dc'

>>> -4:-2:1] Il veut dire commencer par la dernière position. Commencez à prendre les valeurs des quatre positions et coupez à l'avant-dernière position

'bc'

>>> a[-2:-5:-1 ] À l'intérieur de la section valeur

'dcb'

de la section

A. Les groupes et les chaînes sont tous deux des séquences

b Les deux principales caractéristiques des séquences sont l'opérateur d'index et l'opérateur de découpage.

– L'opérateur d'index nous permet de récupérer un élément spécifique d'une séquence.

- L'opérateur slice nous permet d'obtenir une tranche de la séquence, c'est-à-dire une partie de la séquence.

c. L'indice peut également être un nombre négatif, et la position est calculée à partir de la fin de la séquence.

- Par conséquent, shoplist[-1] représente le dernier élément de la séquence et shoplist[-2] récupère l'avant-dernier élément de la séquence

d. L'opérateur est le nom de la séquence suivi d'un crochet contenant une paire facultative de nombres séparés par deux points.

- Notez que ceci est très similaire à l'opérateur d'indexation que vous utilisez. N'oubliez pas que les chiffres sont facultatifs, mais que les deux-points sont obligatoires.

- Le premier chiffre de l'opérateur tranche (avant les deux points) indique la position de départ, et le deuxième chiffre (après les deux points) indique où se termine la tranche. Si vous ne spécifiez pas le premier nombre, Python démarre au début de la séquence. Si le deuxième nombre n'est pas précisé, Python s'arrêtera à la fin de la séquence.

——Remarque : la séquence renvoyée commence à partir de la position de départ et se termine juste avant la position de fin. Autrement dit, la position de départ est incluse dans la tranche de séquence, tandis que la position de fin est exclue de la tranche.

a.shoplist[1:3] renvoie une tranche de séquence commençant à la position 1, incluant la position 2, mais s'arrêtant à la position 3, renvoyant donc une tranche contenant deux éléments. shoplist[:] renvoie une copie de la séquence entière. Vous pouvez effectuer un découpage avec des nombres négatifs. Les nombres négatifs sont utilisés à partir de la fin de la séquence. Par exemple, shoplist[:-1] renvoie une tranche de séquence contenant tous les éléments sauf le dernier élément.

Opérations de base des séquences

1.len() : Trouver la longueur de la séquence

2. : Connecter 2 séquences

3.* : Répéter les éléments de la séquence

4.in : Déterminer si l'élément est en séquence

5.max() : Renvoie la valeur maximale

6.min() : Renvoie la valeur minimale

7.cmp(tupel,tuple2) Comparez 2 Les valeurs de séquence sont-elles les mêmes ?

Faisons-le :

>>> > len(a )
5
>>> str1='123'
>>> 🎜>

'123adbs'

>>> str1*5 De cette façon, str1 sera répété cinq fois

'123123123123123'

> ;>> "#"*40

'################################# ###'

>>> str2

'adbs'


>>> la chaîne str2 Renvoie False, renvoie True

False

>>> 'a' dans str2

True

Vous pouvez également utiliser not in pour juger qu'il n'est pas à l'intérieur

>>> 'c' pas dans str2

Vrai

>>> ;>> max( str2)

's'

>>> min(str2)


'a'


cmp (str1, str2) est utilisé Comparaison de deux chaînes

>>> str1='12345'

>>> ; cmp(str1, str2)

-1

>>> ,str2)
1
>>> str2='12345' A ce moment, les deux valeurs ​​​​sont égales et 0 est renvoyé lors de la comparaison

>>> (str1,str2)

Section 3 Tuple()


Les tuples sont très similaires aux listes, sauf que les tuples sont immuables comme les chaînes, c'est-à-dire que vous ne peut pas modifier le tuple.

— Les tuples sont définis par des éléments séparés par des virgules entre parenthèses.

- Les tuples sont généralement utilisés lorsqu'une instruction ou une fonction définie par l'utilisateur peut prendre en toute sécurité un ensemble de valeurs, c'est-à-dire que la valeur du tuple utilisé ne changera pas.

>>> str2='12345'

>>> '
>>> id(str2)

139702043552576

Maintenant, nous commençons l'opération de tuple

D'abord, nous peut regarder les noms qui sont découpés. Il y aura des espaces affichés lorsque la longueur est différente, il nous est donc plus difficile d'en extraire des éléments

>>> "
>>> userinfo[:4]
'milo'

>>> userinfo1="zou 25 famale"

>>> userinfo1[:4 ]
'zou '

>>> t=("milo",30,"male") Si nous utilisons ici la définition du tuple, il sera beaucoup plus pratique d'obtenir la valeur

>>> t[0]
'milo'

>>> t[1]

30

>>> 🎜>

'mâle'

Créer un tuple
- Un tuple vide se compose d'une paire de parenthèses vides
a Par exemple, myempty = ()
- Contient un seul élément Tuple. du groupe
a.singleton = (2,)
——Tuple général
a.zoo = ('wolf','elephant','pingouin')

b .new_zoo = ('monkey','dolphin',zoo)

>>> t=() Définir un tuple vide
>> > t1=(2,) Définissez un tuple avec un seul élément. Faites particulièrement attention ici, la virgule ne peut pas manquer
>>> ; type(t1)

Opération Tuple

- tuple et chaîne Le type est également un type séquence et peut être opéré via l'indexation et le découpage

- Les valeurs de tuple sont également immuables

>>> )

>>> t

('milo', 30 ans, 'mâle')
>>> ; t[1]=31 Ici, nous avons trouvé une erreur lors du changement de l'âge de la vue
Traceback (dernier appel le plus récent) :
Fichier "", ligne 1, dans
TypeError : objet 'tuple' ne prend pas en charge l'attribution d'éléments
>>> t


('milo', 30, 'male') >
>>> =t
>>> nom

'milo'

>>> âge
30

>>> >

>>> a,b,c=1,2,3

> 3) En python, les deux méthodes peuvent définir des tuples, mais nous essayons d'utiliser la deuxième méthode

Section 4 Sequence-Tuple

Liste[]

1) La liste est une structure de données qui traite un ensemble d'éléments ordonnés, c'est-à-dire que vous pouvez stocker une séquence d'éléments dans une liste.

2) Une liste est un type de données variable

3) La composition d'une liste : utilisez [] pour représenter une liste, qui contient plusieurs nombres séparés par virgules ou chaîne.

——List1=['Simon','David','Clotho','Zhang San']

——List2=[1,2,3 ,4,5]

——List3=["str1","str2","str3","str4","str5"]

> >> listmilo=[] Définition de la liste vide

>>> type(listmilo)

>>> Définition de la liste générale

>>> t=('milo',30,'male')
>>> >> listmilo[0]

'milo'

>>> listmilo[0:2] Récupérer la valeur de la liste
['milo', 30]

>> ; >t[0:2]

('milo', 30)


Les différences sont en dessous

>>> ; =('abc')
>>> l3=['abc']
>>> type(l3) Ici on voit qu'il s'agit d'une liste

>>> type(t3)

Opération de liste

——Valeur

a .Découpage et indexation


b.list[]

——Ajouter

a.list.append()

——Supprimer

a.del(list[])

b.list.remove(list[])

— —Modifier

a.list[]=x

——Rechercher

a.var dans la liste

>>> listmilo[0] On constate ici que la liste peut changer la valeur de l'élément stocké
'milo'
>>>
>>> listmilo[0]
'zou'

Nous présentons ici comment ajouter un élément à la liste

> > > listmilo
['milo', 30, 'male']
>>> listmilo.append("123444555")
>>> 🎜>
['milo', 30, 'male', '123444555'] À ce moment-là, nous avons constaté qu'un quatrième élément a été ajouté à la liste listmilo

>>> ; listmilo.remove ('123444555') Supprimer une valeur de la liste

>>> listmilo

['milo', 30, 'male']


> >> del(listmilo[1]) On peut également utiliser del pour supprimer des valeurs dans la liste via l'index de la liste

>>> , 'male']

Vous devez apprendre à utiliser l'aide pour interroger l'utilisation de certaines syntaxes. Par exemple, nous devons visualiser les opérations de suppression internes de la liste

<.>>>> help(list.remove) 

Aide sur le descripteur de méthode :

remove(...)

L.remove(value ) -- supprime la première occurrence de la valeur
Lève ValueError si la valeur n'est pas présente 🎜>
Démarrage rapide avec les objets et les classes


1) Objets et classes, mieux comprendre les listes. .

2) Objet = Méthode d'attribut

3) La liste est un exemple d'utilisation d'objets et de classes.

- Lorsque vous utilisez la variable i et que vous lui attribuez une valeur, par exemple en attribuant un entier 5, vous pouvez penser que vous avez créé un objet (instance) i de classe (type) int.

——help(int)

4) Les classes ont également des méthodes, qui sont des fonctions définies uniquement pour la classe.

- Seuls les objets de cette classe peuvent utiliser ces fonctions.

- Par exemple :

a.Python fournit la méthode append pour la classe list, qui vous permet d'ajouter un élément à la fin de la liste.

b.mylist.append('an item') ajoute une chaîne à la liste mylist. Notez l'utilisation de la notation par points pour utiliser les méthodes objet.

5) Les classes ont aussi des variables, variables définies uniquement pour les classes.

- Ces variables/noms ne peuvent être utilisés que dans les objets de cette classe.

- Utilisé via des points, tels que mylist.field.

Section 5 Dictionnaire {}

1) Le dictionnaire est le seul type de mappage (table de hachage) en python

2) Les objets du dictionnaire sont mutables, mais les clés du dictionnaire doivent utiliser des objets immuables, et différents types de valeurs clés peuvent être utilisés dans un dictionnaire.

3) key() ou values() renvoie une liste de clés ou une liste de valeurs

4) items() renvoie un tuple contenant des paires clé-valeur.

Créer un dictionnaire :

- {}

- Utiliser la méthode d'usine dict()

Exemple : fdict=dict(['x',1],['y',2])

- Méthode intégrée : fromkeys(), les éléments du le dictionnaire a la même valeur, la valeur par défaut est Aucune

Exemple : ddict={}.fromkeys(('x','y'),-1)

>>> dic={0:0,1:1,2:2} Nous définissons ici un dictionnaire {key:value,key:value,key:value}
>>> ; dic [0]

0

>>> dic[1]
1

>>> 🎜> >>> dic1={'name':'milo','age':25,'gender':'male'} Il sera plus significatif de le définir de cette façon

> >> >> dic1['genre']

'masculin'

>>> dic2={1:'123','name':'milo','x':456}

>>> >
{1 : '123', 'name' : 'milo', 'x' : 456}

Regardons ensuite un autre exemple :

> > ;> a=1 Ici, nous définissons d'abord deux variables

>>> b=2

>>> ':'bbb'} Si a n'est pas défini, une erreur apparaîtra ici

>>> dic3[1]

'aaa'

>>> dic3[2] Ici on voit enfin la différence. En fait, dans le dictionnaire, il n'utilise pas la valeur définie avant b

Traceback (dernier appel le plus récent) :

Fichier "", ligne 1, dans

KeyError: 2
>>> dic3['b']
'bbb'
>>> 'sexe' : 'mâle', 'âge' : 25, 'nom' : 'milo'}
>>> pour k dans dic1 : Ici, nous pouvons voir la commodité d'utiliser un dictionnaire
. ..         imprimer k                                                                                                                                                                  
...
'homme'
25
'milo'





Mise à jour et supprimé :


- Accédez aux mises à jour directement à l'aide des valeurs de clé ; la méthode uodate() intégrée peut copier le contenu de l'intégralité du dictionnaire vers un autre dictionnaire.

- del dict1['a'] supprime l'élément avec la valeur clé a dans le dictionnaire

a. dict1.pop('a') supprime et renvoie les éléments clés de 'a'

b. dict1.clear() supprime tous les éléments du dictionnaire

c. del dict1 supprime tout le dictionnaire

>>> l

[1, 2, 3, 4, 5]

>>> dernier appel récent) :
Fichier "", ligne 1, dans

IndexError : index d'affectation de liste hors plage

>>> age': 25, 'name': 'milo'}
>>> dic1['tel']='123454565' Ici on voit qu'en utilisant un dictionnaire, on peut ajouter une valeur sans erreur

>> ;> dic1

{'genre' : 'masculin', 'âge' : 25, 'tel' : '123454565', 'nom' : 'milo'}


On voit qu'il n'est pas ajouté à la fin, car il n'est pas fixé dans le dictionnaire lui-même. Le désordre du dictionnaire et la valeur du type de hachage peuvent directement faire fonctionner les éléments du dictionnaire via la clé du dictionnaire
<.>
>>> dic1['tel']='888888888'
>>> dic1


{'genre' : 'masculin', ' âge' : 25, 'tel' : '888888888', 'nom' : 'milo'}

>>> age') Touche Pop La valeur correspondant à 'age', il n'y a pas de valeur clé d'âge dans le dictionnaire

25
>>> ', 'tel' : ' 888888888', 'name' : 'milo'}
>>> dic1.clear() Effacer le dictionnaire

>>>

>>> ; del(dic1) Supprimer le dictionnaire directement
>>> dic1

Traceback (dernier appel le plus récent) :

Fichier "", ligne 1, dans
NameError : le nom 'dic1' n'est pas défini

Fonctions intégrées liées au dictionnaire :


- type(), str(),cmp()(cmp Rarement utilisé pour la comparaison de dictionnaires, la comparaison porte sur la taille, la clé et la valeur du dictionnaire dans l'ordre).


Fonction d'usine dict() :


- Par exemple : dict(zip('x','y'),(1,2)) ou dict( x =1,y=2)

- {'y':2,'x':1}

- Utiliser un dictionnaire pour générer un dictionnaire est plus lent que d'utiliser la copie, il est donc recommandé d'utiliser copy() dans ce cas.

1) len(), hash() (utilisé pour déterminer si un objet peut être une clé de dictionnaire, les types sans hachage signalent TypeError) .

2) dict.clear() : Supprime tous les éléments du dictionnaire.

3) dict.fromkeys(seq, val=None) : crée et renvoie un dictionnaire avec les éléments de seq comme clés, et val est la valeur par défaut spécifiée.

4) dict.get(key, default=None) : renvoie la valeur de la clé si la clé n'existe pas, renvoie la valeur spécifiée par défaut.

5) dict.has_key(key) : Déterminez si la clé existe dans le dictionnaire. Il est recommandé d'utiliser in et non in à la place.

6) dict .items() : renvoie une liste de tuples de paires clé-valeur.

7) dict.keys() : Renvoie la liste des clés du dictionnaire.

8) dict.iter*() : iteritems(), iterkeys(), itervalues() renvoient une itération au lieu d'une liste.

9) dict.pop(key[,default]) : Identique à get(), la différence est que si la clé existe, supprimez et renvoyez son dict[key], si ce n'est pas le cas existe, la valeur par défaut n'est pas spécifiée, lancez l'exception KeyError.

10) dict.setdefault(key, default=None) : Identique à set(), si la clé existe, sa valeur est renvoyée Si la clé n'existe pas, dict[key]=default.

11) dict.update(dict2) : Ajoutez les paires clé-valeur de dict2 au dictionnaire dict. S'il y a des écrasements répétés, les entrées qui n'existent pas dans le dictionnaire d'origine sont ajoutées.

12) dict. valeurs() : renvoie une liste de toutes les valeurs du dictionnaire.

>>> dict.get(3) ') Lorsqu'elle n'existe pas dans le dictionnaire, la définition renvoie l'erreur

'erreur'

Nous pouvons pratiquer avec d'autres exemples. Si nous ne comprenons pas, nous pouvons utiliser la fonction d'aide.

>>> dic1={'a':123,'b':456,1:111,4:444}
>>> ()

['a', 1, 'b', 4]

>>> dic1.values()
[123, 111, 456, 444]

Ce qui précède est le contenu des types de données Python du chapitre 2. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !