Objet intégré Python

Aperçu

Notes d'étude pour First Python 3rd Edition

ordre du jour

• Objet intégré --Valeur numérique --Chaîne de caractères --Liste --Dictionnaire --Taple
• Fichier --Autres types --Résumé

Objet intégré

Avantages de l'utilisation d'objets intégrés

--Facile à créer des programmes

• Vous pouvez également créer vos propres objets en fonction des objets intégrés
• Les objets intégrés fonctionnent souvent mieux que les objets personnalisés
• Les objets intégrés de Python sont écrits en C et sont pré-optimisés pour des performances élevées.
• Les objets intégrés sont standard --Les caractéristiques et les fonctions ne changent pas

Type d'objet intégré

Valeur numérique

Arithmétique mathématique

Utilisez le symbole «+» pour l'addition, le «*» pour la multiplication et le symbole «**» pour la puissance.

#Addition d'entiers
>>> 123 + 222
345

#Multiplication des nombres à virgule flottante
>>> 1.5 * 4
6.0

#2 à la 100e puissance
#Python se convertit automatiquement en «entiers longs» lorsqu'il a besoin d'être plus précis.
>>> 2 ** 100
1267650600228229401496703205376L

Les différences suivantes sont entre les deux fonctions intégrées repr et str

#repr: afficher le résultat du calcul tel quel(Sortie avec une précision maximale)
>>> 3.1415 * 2
6.2830000000000004

#str: conversion au format et affichage faciles à lire(Afficher sous une forme facile à voir pour les humains)
>>> print 3.1415 * 2
6.283

module mathématique

• Le module mathématique fournit des outils sous forme de fonctions qui peuvent être utilisées pour des traitements avancés liés aux valeurs numériques.

>>> import math
>>> math.pi
3.1415926535897931
>>> math.sqrt(85)
9.2195444572928871

module aléatoire

• Le module aléatoire a une fonction de génération de nombres aléatoires ou une fonction de sélection aléatoire.

>>> import random
>>> random.random()
0.59268735266273953
>>> random.choice([1, 2, 3, 4])
1

Chaîne

séquence

--Une chaîne est un type d'objet appelé séquence

• Une séquence est un arrangement d'objets dans un certain ordre. --Dans une séquence, l'ordre des objets élément ne change pas toujours

Manipuler des séquences

• L'index est un nombre qui indique le nombre d'éléments à partir de l'extrémité gauche.
• L'index du premier élément est "0" et le second est "1".
• En utilisant un nombre négatif, vous pouvez spécifier les éléments dans l'ordre inverse à partir de l'extrémité droite. --En plus de spécifier des nombres, vous pouvez également écrire des expressions entre crochets. —— Prend en charge le tranchage, qui a une plus large gamme d'applications
• Le découpage est le processus consistant à découper une partie spécifique d'une chaîne de caractères et à examiner le contenu. --Peut être concaténé en utilisant le symbole +
• Vous pouvez itérer en utilisant le symbole «*»

>>> S = 'Spam'

#Vérifiez la longueur
>>> len(S)
4

#Si l'index "0" est spécifié, le premier élément peut être extrait.
>>> S[0]
'S'

#Extraire le deuxième élément de la gauche
>>> S[1]
'p'

#Élément le plus à droite de S
>>> S[-1]
'm'

#Le deuxième élément de l'extrémité droite de S
>>> S[-2]
'a'

#Le dernier élément de S
>>> S[-1]
'm'

#Même sens, mais plus difficile
>>> S[len(S)-1]
'm'

#Extraire 1 et 2 éléments (3 n'est pas inclus) par tranchage
>>> S[1:3]
'pa'

#Extraire tous les éléments après l'index 1 (1):len(S)Pareil que)
>>> S[1:]
'pam'

#Il n'y a pas de changement dans S lui-même après le traitement ci-dessus
>>> S
'Spam'

#Extraire tous les éléments sauf la fin
>>> S[0:3]
'Spa'

# S[0:3]Pareil que
>>> S[:3]
'Spa'

#C'est aussi la même chose (0:-Vous pouvez écrire 1 mais c'est plus facile)
>>> S[:-1]
'Spa'

#Extraire tous les éléments de S (0:len(S)Pareil que)
>>> S[:]
'Spam'

#Mise en relation
>>> S + 'xyz'
'Spamxyz'

#Original S ne change pas
>>> S
'Spam'

#répétition
>>> S * 8
'SpamSpamSpamSpamSpamSpamSpamSpam'

Immuable

• Même si vous faites quelque chose avec la chaîne de caractères, la chaîne de caractères d'origine ne change pas.

>>> S
'Spam'

#Les objets immuables ne peuvent pas être écrasés
>>> S[0] = 'z'
...Message d'erreur omis...
TypeError: 'str' object does not support item assignment

#Créez une nouvelle chaîne et affectez-la à la variable d'origine
>>> S = 'z' + S[1:]
>>> S
'zpam'

Méthodes spécifiques aux chaînes

#Trouvez la chaîne spécifiée
>>> S.find('pa')
1

>>> S
'Spam'

#Remplacer la chaîne spécifiée
>>> S.replace('pa', 'XYZ')
'SXYZm'

>>> S
'Spam'

>>> line = 'aaa,bbb,ccccc,dd'

#Divisez par délimiteur pour faire une liste
>>> line.split(',')
['aaa', 'bbb', 'ccccc', 'dd']

>>> S = 'spam'

#Conversion de cas
>>> S.upper()
'SPAM'

#Confirmation du contenu (isalpha, isdigit, etc.)
>>> S.isalpha()
True

>>> line = 'aaa,bbb,ccccc,dd\n'

#Supprimez le caractère vide à l'extrémité droite
>>> line = line.rstrip()
>>> line
'aaa,bbb,ccccc,dd'

Variations sur la façon de créer des chaînes

Séquence d'échappement

# \n est la fin de la ligne,\t est un onglet
>>> S = 'A\nB\tC'

#Les deux sont traités comme un seul personnage
>>> len(S)
5

# \n correspond au code ASCII 10
>>> ord('\n')
10

# \0 représente NULL. Pas la fin de la chaîne
>>> S = 'A\0B\0C'
>>> len(S)
5

Cotations simples, doubles et triples

• Si vous le mettez entre guillemets triples, plusieurs lignes seront traitées comme un groupe.
• Pratique lors de l'incorporation de code HTML ou XML dans un programme Python
• Si vous préfixez le premier quota de la chaîne avec "r", la barre oblique inverse de la séquence d'échappement sera interprétée comme un simple caractère, appelé "chaîne brute".
• En ajoutant "u" avant la citation, la chaîne de caractères à l'intérieur peut être interprétée comme une chaîne de caractères Unicode.

>>> msg = """
aaaaaaaaaaaaa
bbb'''bbbbbbbbbb""bbbbbbb'bbbb
cccccccccccccc"""
>>> msg
'\naaaaaaaaaaaaa\nbbb\'\'\'bbbbbbbbbb""bbbbbbb\'bbbb\ncccccccccccccc'

Correspondance de motif

--Utilisez un module appelé re

>>> import re
>>> match = re.match('Hello[ \t]*(.*)world', 'Hello Python world')
>>> match.group(1)
'Python '

>>> match = re.match('/(.*)/(.*)/(.*)', '/usr/home/lumberjack')
>>> match.groups()
('usr', 'home', 'lumberjack')

liste

Caractéristiques de la liste

• Non lié à un type spécifique
• La taille n'est pas fixe

Opération de séquence

--La même opération qu'une chaîne de caractères est possible --Indexation et tranchage sont également possibles

#Une liste à trois éléments. Tous les types sont différents
>>> L = [123, 'spam', 1.23]

#Nombre d'éléments dans la liste
>>> len(L)
3

#Indexage
>>> L[0]
123

#Tranchage (résultant en une nouvelle liste)
>>> L[:-1]
[123, 'spam']

#Une nouvelle liste est créée même lorsqu'elle est concaténée
>>> L + [4, 5, 6]
[123, 'spam', 1.23, 4, 5, 6]

#La liste d'origine n'a pas changé
>>> L
[123, 'spam', 1.23]

Méthodes spécifiques à la liste

--ʻAppend: Ajouter un élément à la fin --pop: Supprimer l'élément au milieu --ʻInsert: insérer l'élément à la position spécifiée --remove: supprime l'élément spécifié --sort: Trier (écraser) les éléments de la liste par ordre croissant -- reverse: inverser (écraser) les éléments

#Ajouter un élément à la fin pour allonger la liste
>>> L.append('NI')
>>> L
[123, 'spam', 1.23, 'NI']

#Raccourcissez la liste en supprimant les éléments au milieu
>>> L.pop(2)
1.23

# “del L[2]"Mais vous pouvez supprimer l'élément
>>> L
[123, 'spam', 'NI']

>>> M = ['bb', 'aa', 'cc']
>>> M.sort()
>>> M
['aa', 'bb', 'cc']

>>> M.reverse()
>>> M
['cc', 'bb', 'aa']

Vérification de l'existence des éléments

Pour faire référence à un élément qui n'existe pas réellement

>>> L
[123, 'spam', 'NI']

>>> L[99]
...Message d'erreur omis...
IndexError: list index out of range

>>> L[99] = 1
...Message d'erreur omis...
IndexError: list assignment index out of range

Nid

Exemple d'application Nest

--Matrice

• Tableau multidimensionnel

#Une matrice 3x3 créée par imbrication de listes
>>> M = [[1, 2, 3], 
         [4, 5, 6],
         [7, 8, 9]]
>>> M
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

#Ligne d'accès 2
>>> M[1]
[4, 5, 6]

#Après avoir accédé à la ligne 2, récupérez le troisième élément de cette ligne
>>> M[1][2]
6

Notation d'inclusion de liste

• La notation d'inclusion de liste a été conçue sur la base de la notation de la théorie des ensembles. --Les opérations sont effectuées une par une de gauche à droite. --Avantage en termes de vitesse de traitement

#Extraire les éléments de la deuxième colonne
>>> col2 = [row[1] for row in M]
>>> col2
[2, 5, 8]

#La matrice d'origine reste inchangée
>>> M
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

#Ajoutez 1 à chaque élément de la colonne 2
>>> [row[1] + 1 for row in M]
[3, 6, 9]

#Supprimer les éléments impairs
>>> [row[1] for row in M if row[1] % 2 == 0]
[2, 8]

#Extraire des éléments diagonaux
>>> diag = [M[i][i] for i in [0, 1, 2]]
>>> diag
[1, 5, 9]

#Répétez les caractères de la chaîne
>>> doubles = [c * 2 for c in 'spam']
>>> doubles
['ss', 'pp', 'aa', 'mm']

dictionnaire

Cartographie

--Dictionary appartient à la catégorie du mappage, pas à la "séquence"

• L'ordre dans lequel les éléments sont disposés n'est pas fixe
• Parmi les principaux objets Python, seuls les dictionnaires appartiennent à la catégorie de mappage. --Objets "variables" réinscriptibles
• Utiliser un dictionnaire pour le processus de recherche est le plus avantageux en termes de vitesse.

Manipuler le mappage

>>> D = {'food': 'Spam', 'quantity': 4, 'color': 'pink'}

#Clé'food'Spécifier
>>> D['food']
'Spam'

# 'quantity'Ajouter 1 à la valeur correspondant à
>>> D['quantity'] += 1
>>> D
{'food': 'Spam', 'color': 'pink', 'quantity': 5}

>>> D = {}

#Attribuer une valeur en spécifiant une clé qui n'existe pas
>>> D['name'] = 'Bob'
>>> D['job'] = 'dev'
>>> D['age'] = 40
>>> D
{'age': 40, 'job': 'dev', 'name': 'Bob'}
>>> print D['name']
Bob

Nid

>>> rec = {'name': {'first': 'Bob', 'last': 'Smith'},
           'job': ['dev', 'mgr'],
           'age': 40.5}

# 'Name'Prend en charge les dictionnaires imbriqués
>>> rec['name']
{'last': 'Smith', 'first': 'Bob'}

#Spécifiez la clé du dictionnaire imbriqué
>>> rec['name']['last']
'Smith'

# 'job'Correspond à une liste imbriquée
>>> rec['job']
['dev', 'mgr']

#Spécifier l'index pour la liste imbriquée
>>> rec['job'][-1]
'mgr'

# 'job'Étendre et écraser la liste correspondant à
>>> rec['job'].append('janitor')
>>> rec
{'age': 40.5,'job': ['dev', 'mgr', 'janitor'], 'name': {'last': 'Smith', 'first':'Bob'}}

Tri de clé: pour la boucle

#Obtenir une liste de clés (sans ordre particulier)
>>> Ks = D.keys()
>>> Ks
['a', 'c', 'b']

#Trier la liste des clés
>>> Ks.sort()
>>> Ks
['a', 'b', 'c']

#Sortez les clés de la liste et leurs valeurs correspondantes dans l'ordre
>>> for key in Ks:
print key, '=>', D[key]
a => 1
b => 2
c => 3

Le processus ci-dessus peut être écrit comme

>>> D
{'a': 1, 'c': 3, 'b': 2}
>>> for key in sorted(D):
print key, '=>', D[key]
a => 1
b => 2
c => 3

Boucle For qui convertit les caractères de la chaîne de caractères en majuscules dans l'ordre et la renvoie

>>> for c in 'spam':
print c.upper()
S
P
A
M

Traitement itératif et optimisation

―― Les deux codes suivants sont équivalents, mais la notation d'inclusion de liste est généralement environ deux fois plus rapide.

• L'accent doit être mis sur la concision et la lisibilité, et la vitesse de traitement doit être considérée par la suite. --Si vous avez besoin de vérifier la vitesse, vous pouvez utiliser des outils tels que le module de temps, le module timeit, le module de profil.

Notation d'inclusion de liste

>>> squares = [x ** 2 for x in [1, 2, 3, 4, 5]]
>>> squares
[1, 4, 9, 16, 25]

pour boucle

>>> squares = []
>>> for x in [1, 2, 3, 4, 5]:
squares.append(x ** 2)
>>> squares
[1, 4, 9, 16, 25]

Clé inexistante: si test

Une erreur se produit si vous essayez d'accéder à une valeur à l'aide d'une clé qui n'existe pas

>>> D
{'a': 1, 'c': 3, 'b': 2}

#Le dictionnaire est développé en spécifiant une nouvelle clé
>>> D['e'] = 99
>>> D
{'a': 1, 'c': 3, 'b': 2, 'e': 99}

#Erreur lors de la tentative d'accès à une valeur avec une clé qui n'existe pas
>>> D['f']
...Message d'erreur omis...
KeyError: 'f'

Assurez-vous que la clé existe à l'avance

--Vérifiez si la clé existe avec la méthode has_key

>>> D.has_key('f')
False
>>> if not D.has_key('f'):
print 'missing'
missing

Taple

Une fois créé, il ne peut pas être modifié

>>> T = (1, 2, 3, 4) #Taple avec 4 éléments
>>> len(T) #longueur
4
>>> T + (5, 6) #Mise en relation
(1, 2, 3, 4, 5, 6)
>>> T[0] #Indexation, découpage, etc.
1
La plus grande différence par rapport à la liste des taples est peut-être qu'une fois créés, ils ne peuvent pas être modifiés.
>>> T[0] = 2 #Taple est invariant
...Message d'erreur omis...
TypeError: 'tuple' object does not support item assignment

Taple

Taple

#Taple avec 4 éléments
>>> T = (1, 2, 3, 4)

#longueur
>>> len(T)
4

#Mise en relation
>>> T + (5, 6)
(1, 2, 3, 4, 5, 6)

#Indexation, découpage, etc.
>>> T[0]
1

#La plus grande différence avec la liste des taples est qu'une fois créés, ils ne peuvent pas être modifiés.
>>> T[0] = 2
...Message d'erreur omis...
TypeError: 'tuple' object does not support item assignment

Pourquoi vous avez besoin de tuples

• Pour assurer la cohérence
• Aspect vitesse

Fichier

opération de base

l'écriture

#Créer un nouveau fichier en mode sortie
>>> f = open('data.txt', 'w')

#Ecrire une chaîne
>>> f.write('Hello\n')

>>> f.write('world\n')

#Fermez le fichier et videz le tampon de sortie sur le disque
>>> f.close()

Lis

# 'r'Est le mode de traitement par défaut
>>> f = open('data.txt')

#Lire le fichier entier
>>> bytes = f.read()
>>> bytes
'Hello\nworld\n'

#print interprète la signification des caractères de contrôle
>>> print bytes
Hello
world

#Le contenu du fichier est toujours traité comme des chaînes
>>> bytes.split()
['Hello', 'world']

Outils liés aux fichiers

Outils pris en charge

--Tuyau

• FIFO --Fichier d'accès par clé
• Persistance d'objet --Fichier descripteur
• Base de données relationnelle / base de données orientée objet

Autres types

Objet agrégé

--Utilisez une fonction intégrée appelée set --Un objet set peut correspondre à "set operation" en mathématiques

>>> X = set('spam')

#Créez deux ensembles basés sur la séquence
>>> Y = set(['h', 'a', 'm'])
>>> X, Y
(set(['a', 'p', 's', 'm']), set(['a', 'h', 'm']))

#Traversée
>>> X & Y
set(['a', 'm'])

#Joindre
>>> X | Y
set(['a', 'p', 's', 'h', 'm'])

#différence
>>> X - Y
set(['p', 's'])

Fractions de précision fixes et types booléens

#Fraction de précision fixe
>>> import decimal
>>> d = decimal.Decimal('3.141')
>>> d + 1
Decimal("4.141")

#Type booléen
>>> 1 > 2, 1 < 2
(False, True)
>>> bool('spam')
True

# None
>>> X = None
>>> print X
None

#Créer une liste de 100 Aucun
>>> L = [None] * 100
>>> L
[None, None, None, None, None, None, None, None, None, None, None, None, None,...Liste de 100 Aucun...]

# Types
>>> type(L)
<type 'list'>

#Le type lui-même est aussi un objet
>>> type(type(L))
<type 'type'>

Vérification de type

• En Python, il est généralement préférable de ne pas faire de vérification de type
• Ce à quoi vous devez faire attention lors de l'écriture d'un programme est l'interface de l'objet.

#Vérification de type
>>> if type(L) == type([]):
print 'yes'
yes

#Vérifiez le nom du type
>>> if type(L) == list:
print 'yes'
yes

#Méthode de confirmation "orientée objet"
>>> if isinstance(L, list):
print 'yes'
yes

Classe créée par l'utilisateur

Définition de la classe de travailleurs

class Worker:
  #Initialisation
  def __init__(self, name, pay):
    #self correspond à un nouvel objet
    self.name = name
    self.pay = pay
  def lastName(self):
    #Séparer la chaîne de caractères avec des espaces
    return self.name.split()[-1]
  def giveRaise(self, percent):
    #Remplacer le salaire
    self.pay *= (1.0 + percent)

#Créer deux instances
>>> bob = Worker('Bob Smith', 50000)

#Les deux ont un nom et paient
>>> sue = Worker('Sue Jones', 60000)

#Appel de méthode. Bob devient soi-même
>>> bob.lastName()
'Smith'

#poursuivre c'est soi-même
>>> sue.lastName()
'Jones'

#Changement de salaire de la poursuite
>>> sue.giveRaise(.10)
>>> sue.pay
66000.0

Résumé

Quels sont certains des objets intégrés de Python?

--Valeur numérique --Entier --Entier long --Flottant --Numéro différentiel

• Fraction de précision fixe --Chaîne de caractères
• Chaîne normale
• Chaîne unicode --Liste --Dictionnaire --Taple
• Fichier --Réunion --Type d'objet
• None --Type de booléen

Avec des objets intégrés

--Un objet préparé en Python et qui peut toujours être utilisé.

• Si vous souhaitez utiliser un objet autre que l'objet intégré, vous devez importer le module et y appeler la fonction.

Qu'est-ce que l'immuabilité?

--La propriété qui a créé un objet ne peut plus être modifiée par la suite.

• Les valeurs numériques, les chaînes de caractères, les taples, etc. peuvent être classés comme des objets immuables --Dans l'expression qui exploite l'objet immuable, l'objet n'est pas modifié (écrasé) en tant que résultat de l'exécution et un nouvel objet est créé.

Qu'est-ce qu'une séquence

--Un ou plusieurs objets disposés dans un certain ordre

• Les séquences sont classées en chaînes, listes, taples, etc.
• Tous les objets appartenant à la séquence prennent en charge des opérations telles que l'indexation, la concaténation et le découpage.
• Les opérations spécifiques au type sont possibles en utilisant les méthodes de chaque type.

Qu'est-ce qu'une cartographie?

--Un ensemble d'objets

• L'ordre dans lequel les éléments sont disposés n'est pas fixe --Chaque élément a une "clé" --Seul le dictionnaire est classé comme un mappage parmi les objets intégrés.

Qu'est-ce que le polymorphisme?

• Même si le code est le même, sa signification change en fonction du type d'objet à traiter.
• En Python, le même code change automatiquement sa fonction en fonction de l'objet cible.
• Un code peut gérer de nombreux types d'objets