Décrit la méthode d'écriture de base de Python. La version est 3.4.3.
Les commentaires commencent par "#".
#Ceci est un commentaire
Il existe des entiers, des nombres à virgule flottante et des nombres complexes.
#Quatre règles
2 + 3 # 5
2 - 3 # -1
2 * 3 # 6
#La division entière sera un nombre à virgule flottante
2 / 3 # 0.6666666666666666
# //La partie entière après division peut être extraite par calcul
3 // 2 # 1
# **C'est une puissance
2 ** 10 #1024 2 à la 10e puissance
#Nombre complexe
(1+1j) + (2+2j) # (3+3j)L'unité imaginaire est j, 1 de 1j ne peut pas être omis
c = 1 + 2j
c.real #1.0 Partie réelle
c.imag #2.0 partie imaginaire
sequence
Une structure de données dans laquelle les éléments sont classés par ordre numérique. Chaque élément est accessible avec un index entier à partir de 0.
La structure de données suivante est la séquence.
Prenons List comme exemple pour expliquer la séquence.
l = [1,2,3]
l[0] #1 élément 0 index commence par 0
l[2] #3 élément 2
l[-1] #L'indice 3 élément 3 peut être négatif
len(l) #Nombre de 3 éléments
max(l) #3 valeur maximale
min(l) #1 valeur minimale
l.count(1) #1 Nombre d'apparitions
1 in l #Si l'élément True est inclus
3 in l # False
1 not in l #L'élément faux n'est pas inclus ou est inversé
#Renvoie une liste avec une plage
l[:] # [1,2,3]Renvoie tous les éléments sous forme de liste
l[1:2] # [2] a:a à b au format b-Renvoie les éléments jusqu'à 1 dans la liste
l[0:] # [1,2,3] a:Renvoie une liste d'éléments de a à la fin au format
l[:2] # [1,2] :b depuis le début au format b-Renvoie les éléments jusqu'à 1 dans la liste
Une séquence dont l'élément est un caractère. Vous ne pouvez pas modifier l'élément.
s = "string" #La chaîne de caractères est"Sortir
s = 'string' # 'Mais d'accord
#Vous pouvez accéder aux caractères avec l'index entier
s[0] # 's'
#L'élément ne peut pas être modifié
s[0] = "S" #Erreur
#Chaîne multiligne" or 'Je vais assembler 3 pièces
'''
Plusieurs lignes
Chaîne
'''
#Connecter des chaînes
"a" + "b" # 'ab'
#Répétez la chaîne
"a" * 2 # 'aa'
#Diviser la chaîne
"1,2".split(",") # ['1', '2']Liste des retours
#Combiner des chaînes
",".join(["1","2"]) # '1,2'
#Convertit une chaîne en nombre
int("0x10", 16) #16 Le deuxième argument est la base
int("10") #10 Si le deuxième argument est omis, la base est traitée comme 10.
int("10", 2) # 2
float("1.2") # 1.2
#Convertir des nombres en chaînes
"dec:{0},hex:{0:X},bin:{0:b}".format(16) # 'dec:16,hex:10,bin:10000'
"{0:.2f}".format(3.1415) # '3.14'
list Une séquence qui peut avoir des données arbitraires comme élément. Vous pouvez changer l'élément.
l = [1,2,3] # ,Séparation,"[]"Sortir
l[0] #1 élément 0 index commence par 0
l[2] #3 élément 2
l[-1] #L'indice 3 élément 3 peut être négatif
#Ajouter un élément à la fin
ll = l + [4] # ll = [1,2,3,4]Ajouter un élément(+)
l.append(4) # l = [1,2,3,4]Ajouter un élément(append)
#Extraire l'élément de la fin
l = [1,2,3]
l.pop #3 Résultat l= [1,2]
#Renvoie l'itération de l'élément
l = [2]
l * 2 # [2,2]
#Vous pouvez utiliser la notation d'inclusion pour initialiser la liste
# []Écrivez l'instruction for dans
l = [x for x in range(10)] # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
#Liste multidimensionnelle
#2D:queue
m = [[row for row in range(2)] for col in range(3)] # [[0, 1], [0, 1], [0, 1]]
#3D
m = [[[row for row in range(2)] for col in range(3)] for mat in range(4)]
tuple Une séquence qui peut avoir des données arbitraires comme élément. ** Vous ne pouvez pas modifier l'élément. C'est la différence avec List. ** **
t = (1,2,3) # ,Séparation,"()"Sortir
t[0] = 10 #Erreur, l'élément ne peut pas être modifié
range Une séquence qui peut utiliser une valeur numérique comme élément. Vous ne pouvez pas modifier l'élément. Utilisé en combinaison avec l'instruction for.
# range(x)À 0~x-Représente 1
# 0~9 s'affiche
for i in range(10):
print(i)
# range(x, y)Avec x~y-Représente 1
# 1~9 s'affiche
for i in range(1, 10):
print(i)
# range(x, y, step)Avec x,x+step, x+2*step, ... (y-Jusqu'à 1)Représente.
# 1,3,5,7,Représente 9.
for i in range(1, 10, 2):
print(i)
if
Les conditions de comparaison peuvent être spécifiées au format ʻaaa <x <bbb. Vous pouvez utiliser les opérations ʻin et ʻis`.
# if .. elif .. else
x = 1
if x == 1:
print("x == 1")
elif x == 2:
print("x == 2")
else:
print("else")
# result : x == 1
# < x <Calcul
x = 5
if 1 < x < 6:
print("True")
else:
print("False")
# result : True
#en arithmétique
if 0 in [1, 2, 3]:
print("True")
else:
print("False")
# result : False
#pas en arithmétique
if 0 not in [1, 2, 3]:
print("True")
else:
print("False")
# result : True
#est l'opération, détermine s'il s'agit du même objet
if [1] is [1]:
print("True")
else:
print("False")
# result : False
l = [1,2,3]
ll = l
if l is ll:
print("True")
else:
print("False")
# result : True
for break / continue est le même que les autres langues. le reste est caractéristique. else est exécuté lorsque l'instruction for est exécutée jusqu'à la fin. Lorsqu'il s'arrête à la pause, else n'est pas exécuté.
# range
for i in range(10):
print(i)
# result : 0~10
# list
for i in [1, 2, 3]:
print(i)
# result : 1~3
# else/break
#Vous pouvez en attacher autre.
#Sinon est exécuté lorsque for est exécuté jusqu'à la fin.
#Il ne sera pas exécuté lorsqu'il se cassera.
for i in [1, 2, 3]:
print(i)
if i == 2:
break
else:
print("else")
# result : 1~2,sinon n'est pas affiché
while Comme pour, vous pouvez en ajouter.
i = 0
while i < 10:
print(i)
if i == 1:
break
i = i + 1
else:
print("else")
# result : 0~1
Vous pouvez appeler une fonction en spécifiant un nom d'argument tel que f (x = 10, y = 20).
Il est plus facile à lire et vous pouvez modifier l'ordre des arguments.
#Définir une fonction qui renvoie la valeur totale
def sum(l):
val = 0
for i in l:
val = val + i
return val
print(sum([1, 2, 3]))
# result : 6
#Vous pouvez spécifier l'argument par défaut
def add(x=10, y=20):
return x + y
print(add())
# result : 30
#Vous pouvez l'appeler en spécifiant le nom de l'argument et vous pouvez modifier l'ordre des arguments.
def sub(x, y):
return x - y
print(sub(y=20, x=10))
# result : -10
Un fichier contenant des classes et des fonctions est appelé un module. L'extension est .py. Le nom du module est le nom du fichier à l'exclusion de .py. Il est pratique d'organiser les fonctions fréquemment utilisées dans un module afin qu'elles puissent être réutilisées.
#Importez le module avec import.
import numpy as np #Définir l'alias avec comme
a = np.array([1,2,3]) #Faire référence à un membre du module avec l'alias np
#Lors du référencement d'un membre de module lors de l'importation simple
#Nom du module(ou alias)Modifié avec(e.g. np.array)besoin de le faire.
#Vous pouvez omettre la modification en utilisant de.
from numpy import array
a = array([1,2,3]) #OK sans np
# *Il est également possible de tout spécifier avec
from numpy import *
La définition d'une classe crée un objet de classe correspondant. Le nom du constructeur est «init». Se prend comme argument. self est un mot clé pour référencer votre propre objet.
Les objets de classe incluent
Les variables et méthodes ont une portée publique et privée. Préfixez le nom avec «__» pour le rendre privé. Les objets privés ne sont pas accessibles depuis l'extérieur de la classe.
#Définir une classe
class Test:
#Variable de classe
i = "pub class var" #Publique
__i = "prv class var" #privé
#Méthode d'instance
def method(self):
print("pub inst method")
def __method(self):
print("prv inst method")
#Méthode de classe
@classmethod
def cls_meth(cls):
print("cls_meth")
#Méthode statique
@staticmethod
def stat_meth():
print("stat_meth")
#constructeur
def __init__(self):
#Variable d'instance
self.j = "pub inst var" #Publique
self.__j = "prv inst var" #privé
print("__init__")
#Publique
print(Test.i) #Classe de variable classe.format de nom
print(self.i) #Variable de classe obj.format de nom
print(self.j) #Variable d'instance obj.format de nom
self.method() #Méthode
#privé
print(self.__i) #Classe de variable classe.format de nom
print(self.__j) #Variable d'instance obj.format de nom
self.__method() #Méthode
#Créer une instance
t1 = Test()
t2 = Test()
#Parcourir les variables
print(Test.i) #1 classe variable classe.format de nom
print(t1.i) #1 variable de classe obj.format de nom
print(t1.j) #2 Variable d'instance obj.format de nom
#Des variables de classe et des variables d'instance avec le même nom peuvent être définies
#C'est une source de confusion, alors ne l'utilisez pas comme ça.
t1.i = 10
print(t1.i) # 10 obj.La priorité est donnée pour obtenir le nom. La variable de classe i ne peut pas être référencée à partir de t1
print(Test.i) # 3
print(t2.i) # 3
#Ajout de variable dynamique
t1.x = 10 #Vous pouvez ajouter des variables d'instance de manière dynamique.
print(t1.x) # 10
del t1.x #Effacer
Test.x = 20 #Vous pouvez ajouter des variables de classe de manière dynamique.
print(Test.x) # 20
del Test.x #Effacer
#Appelez la méthode
t1.method()
#t1.__method() #Erreur
#Appel de méthode de classe
Test.cls_meth()
#Appel de méthode statique
Test.stat_meth()
En écrivant class Child (Parent) dans la définition de classe
Vous pouvez définir une classe Child qui hérite de Parent.
Les membres privés de la classe parent ne sont pas accessibles à partir de la classe enfant. Vous pouvez remplacer les méthodes de la classe parent de la classe enfant. Pour définir les variables d'instance de la classe parent, dans le constructeur de la classe enfant Vous devez appeler le constructeur de la classe parent.
#Définir la classe parent
class Parent:
i = "pub class var"
__i = "prv class var"
def __init__(self):
self.j = "pub inst var"
self.__j = "prv inst var"
def meth(self):
print("pub inst meth")
print(self.i)
print(self.__i)
self.__meth()
def meth2(self):
print("pub inst meth2")
print(self.j)
print(self.__j)
def meth3(self):
print("pub inst meth3")
def __meth(self):
print("prv inst meth")
#Définir une classe enfant
class Child(Parent):
def __init__(self):
#Appelez le constructeur de la classe parent
#Sans cela, la variable d'instance de la classe parente ne sera pas définie
#Meth2 de la classe enfant entraînera une erreur
Parent.__init__(self)
#passer outre
def meth3(self):
print("child pub inst meth3")
def meth4(self):
self.__meth()
#Créer une instance
p = Parent()
p.meth()
p.meth2()
p.meth3()
c = Child()
c.meth()
c.meth2()
c.meth3() #La classe enfant meth3 est appelée
#c.meth4()
#Entraînera une erreur
#La classe enfant ne peut pas accéder aux méthodes privées de la classe parent
try:
int("xxx") #Une exception se produit car il ne s'agit pas d'une valeur numérique
except OSError:
print("OSError")
except ValueError:
print("ValueError")
# resutl : ValueError
#S'il n'y a pas d'exceptions, else sera exécuté
try:
int("10")
except OSError:
print("OSError")
except ValueError:
print("ValueError")
else:
print("NoError")
# resutl : NoError
#S'exécute enfin avec ou sans exceptions
try:
int("xxx")
except OSError:
print("OSError")
except ValueError:
print("ValueError")
finally:
print("Finally")
# resutl : ValueError Finally
#Vous pouvez utiliser avec pour fermer correctement même si une exception se produit
with open("tmp.txt", "a") as f:
f.write("test\n")
#Vous pouvez utiliser l'instruction for pour gérer toutes les lignes
with open("tmp.txt", "r") as f:
for ln in f:
print(ln)
Les arguments de ligne de commande vont dans sys.argv. sys.argv [0] est le nom du script. sys.argv [1] est le premier argument.
test.py
import sys
print(sys.argv)
>python test.py param1 param2
['test.py', 'param1', 'param2']
import re
ln = "<tag>1234</tag>"
#Définissez une expression régulière.()Vous pouvez grouper avec.
r = re.compile("<tag>(.+)</tag>")
#Chercher.
m = r.search(ln)
#S'il n'y a pas de correspondance, m sera Aucun
print(m.group(0)) #Toute la chaîne correspondante"<tag>1234</tag>"
print(m.group(1)) # ()La chaîne de caractères regroupée par est renvoyée."1234"
Recommended Posts