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
>>> type(num3)
Par exemple : 0.0, 12.0,, 18.8, 3e 7, etc.
Exemple :
> ;> ;> type(num)
>>> 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 :
>>> num
>>> imprimer num
3.14j
>>>
Nous distinguons ici les deux types de variables différents suivants
>>> 🎜>> >> stra="123"
>>> imprimer un
>>> > 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) :
TypeError : type(s) d'opérande non pris en charge pour : 'int' et 'str'
>>>
>>>
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
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'
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
>>> :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'
'123123123123123'
'################################# ###'
>>> str2'adbs'
>>> la chaîne str2 Renvoie False, renvoie True
False
True
Vous pouvez également utiliser not in pour juger qu'il n'est pas à l'intérieur
>>> 'c' pas dans str2
>>> ;>> max( str2)
's'>>> min(str2)
'a'
cmp (str1, str2) est utilisé Comparaison de deux chaînes
>>> ; cmp(str1, str2)
-1
>>> ,str2)
1
>>> str2='12345' A ce moment, les deux valeurs sont égales et 0 est renvoyé lors de la comparaison
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.
>>> '
>>> 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[:4 ]
'zou '
>>> t[0]
'milo'
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
>>> )
('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
>>> âge
30
> 3) En python, les deux méthodes peuvent définir des tuples, mais nous essayons d'utiliser la deuxième méthode
>>> type(listmilo)
>>> t=('milo',30,'male')
>>> >> listmilo[0]
>>> listmilo[0:2] Récupérer la valeur de la liste
['milo', 30]
('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
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
['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
Aide sur le descripteur de méthode :
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. .
Créer un dictionnaire :
- {}
- Utiliser la méthode d'usine dict()
Exemple : fdict=dict(['x',1],['y',2])
>>> dic={0:0,1:1,2:2} Nous définissons ici un dictionnaire {key:value,key:value,key:value}
>>> ; dic [0]
>>> dic[1]
1
'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]
>>> 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, dansKeyError: 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
>>> dernier appel récent) :
Fichier "", ligne 1, dans
>>> age': 25, 'name': 'milo'}
>>> dic1['tel']='123454565' Ici on voit qu'en utilisant un dictionnaire, on peut ajouter une valeur sans erreur
{'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
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
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}
>>> ()
>>> dic1.values()
[123, 111, 456, 444]
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
