Un mémorandum pour vous-même, facile à oublier.
#Grammaire la plus rapide de Python
#référence
#Tout le monde est Python 3e édition
# [python]Grand Thanksgiving de fin d'année! Présentation de 50 conseils Python pour l'évasion des débutants
# http://kwatch.houkagoteatime.net/blog/2013/12/07/python-tips/
#Spécification d'encodage
# -*- coding: utf-8 -*-
#Saut de code =;(point-virgule)
#Importation de module
import moduleName
from moduleName import functionName
from math import * # import all functions
from math import e
from math import e as newName
from math import (e, pi) #Mettre entre parenthèses si plusieurs importations
##Le nom du module peut être omis à l'aide de l'instruction from
import math
math.sin(60)
from math import sin
sin(60)
##Créer un fichier de module
## (Le fichier de script peut être utilisé comme module tel quel)
# 1. moduleName.Ecrire une fonction en py
# 2. import moduleName
#Je veux couper une ligne au milieu d'une ligne: barre oblique inverse à la fin de la ligne(\)
import urllib, poplib, sys, calendar, \
datetime, re
#littéral
b = 0b1000 #Nombre binaire
c = 0x1ff #Hexadécimal
#Type booléen
True
False
# Null
None
#Les symboles sont sensibles à la casse
python = 100
Python = 200
print(python, Python) #=> 100 200
#Sortie vers sortie standard(Avec saut de ligne)
print("abc")
print("abc", "def") #Connectez-vous avec un espace demi-largeur
print("abc", file=sys.stderr) #Sortie d'erreur standard
#Concaténer sans interruption
for i in range(10):
print("abc", end = ' ') #=> abc abc abc abc abc abc abc abc abc abc
#Obtenir à partir d'une entrée standard
s = raw_input()
#s = input() # == eval(raw_input())
#Quatre règles
x += 1
x -= 1
x *= 1
x /= 1
x = 2 ** 10 #Puissance
x = 3 / 2 #Valeur de retour = virgule flottante
x = 3 // 2 #Valeur renvoyée = entier
x = 5 % 3 #Surplus
x++ #Cette façon d'écrire ne peut pas être utilisée
x-- #Cette façon d'écrire ne peut pas être utilisée
#Chaîne littérale
s = "abc'def"
s = 'abc"def'
s = r'\d+\s\n' #chaîne brute(Traitez comme vous le voyez)
#Manipulation des cordes
"abcdef"[0]
"abcdef"[0] = "x" # =>Erreur
"abcdef"[-1]
"abcdef".title()
"abcdef".lower()
"abcdef".upper()
"abcdef".endswith('f')
"abcdef".startswith('a')
"abcdef".strip()
"abcdef".count('c')
"abcdef" + "ghijkl"
"abcdef" * 3
"abcdef".replace("abc","replaced")
"abcdef".find('x') #=> -1
"abcdef".index('x') #=> ValueError
#Justifié à gauche, justifié à droite, justifié au centre
"abcdef".ljust(10," ")
"abcdef".rjust(10," ")
"abcdef".center(10," ")
"abc def".split(" ")
" ".join(["abc","def"])
len("abcdef")
ord("a")
chr(52)
if "a" in "abcdef":
do_something()
#Format de chaîne
"{0} {1} {0}".format("Mika", "Mike")
"{name0} {name1} {name0}".format(name0="Mika", name1="Mike")
"{:.2%}".format(6260 / 12776) #Notation en%
#Échange de valeur(Générer des tuples sans parenthèses)
b, a = a, b
#Ici document
lines = '''
de cette façon
Plusieurs lignes
Peut être décrit
Si vous ne souhaitez pas insérer de sauts de ligne\
Citation arrière à la fin(\)Avec
'''
#Si vous souhaitez conserver le retrait()utilisation(Pas de virgule)
lines = ("aaaaaa"
"bbbbb"
"ccccc")
#Opérateur conditionnel(Opérateur binaire)
return "odd" if odd(x) else "even"
s = "odd" if odd(x) else "even"
#Conversion de type
int("123")
hex(1023)
bin(15)
oct(7)
float("1.3")
str(123)
tuple([1,2,3])
list((1,2,3))
#Conversion de base
int("0x100", 16)
int("0b1111", 2)
int("0o1777", 8)
#Opération de bit
x | y # or
x & y # and
x ^ y # xor
x << y # left shift
x >> y # right shift
#une fonction
def functionname(x):
"""
Commentaire de fonction
"""
do_something()
return result
def moveTo(x,y=0): #Valeur par défaut de l'argument
do_something()
moveTo(x=1, y=20) #Spécification de mot-clé d'argument
#Branche conditionnelle
if s == "abc": # =ne pas==
statementA()
elif s == "def":
statementB()
else:
statementC()
if min <= value <= max: #Vous pouvez écrire des opérateurs de comparaison consécutivement
do_something()
#Valeurs de retour multiples(Affectation de déballage)
def foo():
minValue = 1
maxValue = 9
return minValue, maxValue
minValue, maxValue = foo()
(minValue, #valeur minimum
maxValue, #Valeur maximum
) = foo()
#Arguments variables
def foo(a, b, *vals):
print(a, b, vals)
foo(1, 2, 3, 4) # => 1, 2, (3, 4)
#Argument de mot-clé variable
def foo(a, b, **args):
print(a, b, args)
foo(1, 2, c=3, d=4) # => 1, 2, {'c': 3, 'd': 4}
#Opérateur conditionnel:== != > < <= >= not in
#Opérateur logique: et ou xor
#l'instruction switch n'est pas en python
#Répéter (nombre de fois spécifié)
for i in range(6): # i = 0 to 5
do_something()
for i in range(1, 10, 2): #début,Fin,Étape I= 1,3,5,7,9
do_something()
#Contrôle de boucle
continue
break
#Déclaration While
while condition:
do_something()
#Il n'y a pas de faire ~ en python
for loopCounter, item in enumerate(seq): #Avec compteur de boucles
print(loopCounter, item)
for no, name in zip([1, 2, 3, 4], ['name1', 'name2', 'name3', 'name4']): #Combinez deux séquences
print(no, name)
#Gestion des exceptions
try:
if condition:
raise Exception() #Lever intentionnellement une exception
except Exception as e:
#La gestion des erreurs
msg = "{1}(err={2})".format(e.errno, e.strerror)
sys.stderr.write(msg)
else:
#Traitement lorsqu'une exception ne se produit pas
finally:
#Post-traitement (toujours exécuté)
try:
...
except Exception as e:
print e, 'error occurred'
#avec déclaration:Rendre l'exécution des blocs efficace
#Si le processus échoue, n'exécutez pas le bloc
with open(fn) as f: #S'il échoue ici, le traitement à l'intérieur du bloc ne sera pas exécuté.
for line in f :
print(line)
##Gérer les exceptions dans le module de traceback
import traceback
try:
do_something()
except:
traceback.print_exc() #Afficher l'exception
message = traceback.format_exc() #Obtenir comme une chaîne
#liste
a = [1, 2, 3, 4, 5]
a[0]
a[-1] #S'il s'agit d'un nombre négatif, de la fin
a[5] # => Error
#Slice: donne le dernier index +1 de l'élément que vous souhaitez récupérer
a[1:3] #=> a[1] ～ a[3 - 1]Se lever pour=> [2, 3]
a[2:] #=> [3, 4, 5]
a[:3] #=> [1, 2, 3]
a[2:100] #=> [3, 4, 5]
a * 2 #=> [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
a + [6,7] #=> [1, 2, 3, 4, 5, 6, 7]
a[1] = "x" #=> [1, "x", 3, 4, 5, 6, 7]
del a[1] #=> [1, 3, 4, 5, 6, 7]
a.index(1)
if 1 in a:
do_something()
max(a)
min(a)
a.sort() #Attention car il sera réécrit
a.sort(key=compareFuncName)
a.reverse() #Attention car il sera réécrit
a.append(6) # add()n'est pas
a.extend([6, 7, 8])
a.remove(1)
a.pop(0)
#Tableau multidimensionnel
matrix = [[1, 2, 3],
[4, 5, 6],
[7, 8, 9]]
matrix[0][2]
#Taple
# (Liste non réinscriptible/Efficacité de la mémoire/Peut être utilisé comme clé de dictionnaire)
t = (1, 2, 3, 4, 5)
#D'autres sont identiques à la liste
#Exemple d'utilisation
ipmap = {(192.168.0.1):"host1.name.com",
(192.168.0.2):"host2.name.com",}
#dictionnaire
dict = { "key1":"Tokyo", "key2":"Préfecture d'Osaka" }
dict["key1"]
# .get():Renvoie la valeur spécifiée sans erreur même s'il n'y a pas de clé
for word in lines.split():
wordcount[word] = wordcount.get(word, 0) + 1
dict["key1"] = "Hokkaido"
del dict["key1"]
dict.keys()
dict.values()
dict.items() # key,Renvoie une liste de tuples de valeur
if "key1" in dict:
do_something()
#Synthétique
dict1.update(dict2) #Écraser la même clé
#ensemble
s = {1, 2, 3, 4}
s2 = {5, 6}
s.remove(7) # KeyError
s.discard(7) # no error
s.add(7)
s |= {7}
if s == s2:
do_something()
if 1 in s:
do_something()
s.union(s2) # s |ensemble de somme s2
s.intersection(s2) # s &ensemble commun s2
s.difference(s2) # s -jeu de différence s2
s.symmetric_difference(s2) # s ^Jeu de différences symétriques s2
# map(Convertir chaque élément de la séquence)
map1 = map(str, range(5))
#Jugement nul
if x is (not) None:
do_something()
#Lecture de fichiers
f = open("foo.txt", "r", encoding="utf-8")
s = f.read()
line = f.readline() #1 ligne
lines = f.readlines() #Toutes les lignes
f.close()
#Écriture de fichier
f = open("foo.txt", "w", encoding="utf-8")
f.write(s)
f.writelines(seq) #Notez qu'aucun saut de ligne n'est ajouté
f.close()
#Notation inclusive (complétion)
sq = [x ** 2 for x in range(5)]
sq #=> [0, 1, 4, 9, 16]
val = 10
[x for x in range(1,val) if val % x == 0] #=> [1, 2, 5]
filter2 = [x for x in ['cat','dog', 'bird'] if 'cat' in x]
filter2 #=> ['cat']
tz = {"GMT" : "+000", "BST" : "+100",
"EET" : "+200", "JST" : "+900"}
revtz = {value : name for name, value in tz.items()}
revtz #=> {'+200': 'EET', '+100': 'BST', '+000': 'GMT', '+900': 'JST'}
names = ['BOB', 'Burton', 'dave', 'bob']
unames = {x.title() for x in names}
unames #=> {'Bob', 'Dave', 'Burton'}
#Commande de ne rien faire
pass
#Test de l'unité
from Hoge import * #Cible de test
import unittest
class HogeClassTestCase(unittest.TestCase):
def setUp(self):
pass
def tearDown(self):
pass
def testFooMethod(self):
self.assertEqual(1, Hoge().foo())
if __name__ == "__main__":
unittest.main()
#Mesure du temps de la pièce de code
import timeit
timeit.timeit('"-".join(str(n) for n in range(100))', number=10000)
#Obtenir la ligne de commande
for arg in sys.argv[1:] # argv[0]=Le nom du script lui-même
print(arg)
#Analyse des options de ligne de commande
from arse import OptionParser
VERSION = '1.01'
def main():
version = '%prog version ' + VERSION
usage = "usage: %prog [options] directories..."
description = 'Delete empty directories.'
parser = OptionParser(version=version, usage=usage,
description=description)
parser.add_option("-f", "--file", dest="filename",
help="read data from FILENAME")
parser.add_option("-v", "--verbose",
action="store_true", dest="verbose")
parser.add_option("-q", "--quiet",
action="store_false", dest="verbose")
(options, args) = parser.parse_args()
if len(args) != 1:
parser.error("incorrect number of arguments")
if options.verbose:
print "reading %s..." % options.filename
if __name__ == "__main__":
main()
#Itérateur (itérateur externe)
# (Tous les objets intégrés peuvent être convertis en itérateurs)
# (Il est difficile de définir une classe pour la définir)
i = iter([1, 2, 3]) #Convertir en objet itérateur
next(i) #Extraire l'élément suivant(Exception StopIteration si l'élément a disparu)
for line in open("test.txt"): #Traitez chaque ligne du fichier
print(line, end=" ")
#Générateur (générateur interne)
# (Définir des fonctionnalités de type itérateur à l'aide de fonctions)
#Utiliser la déclaration de rendement
def get_primes(x=2):
while True:
for i in range(2, x):
if x % i == 0:
break
else:
yield x
x += 1
i = get_primes()
for c in range(10):
print(next(i))
#Génération par formule de générateur
gen = (ord(s) for s in 'Python')
next(gen)
for code in (ord(s) for s in 'Python'):
print(code)
#Test de l'unité
#TODO:Écrivez plus tard
#Style Lambda
lambda x: x * 10
#Bloquer à exécuter uniquement lorsqu'il est exécuté dans main
# (Non importé d'autres scripts)
if __name__ == '__main__':
do_something()
#Définition et instanciation de classe
class Person(SuperClassName): #Le nom de la classe est en majuscule
def __init__(self, name, age): #Initialisation(1er argument nécessaire)
self.name, self.age = name, age
self.address = None
bob = Person('Bob', 15)
print bob.name
bob.address = 'USA'
##Héritage de classe (héritage multiple possible)
class Person(SuperClassName):
def __init__(self, width):
super().__init__() #L'appel à la classe parent est super()
self.width = width
#Restrictions sur l'ajout d'attributs (variables d'instance)
class Klass:
__slot__ = ['width', 'height'] #Les attributs non écrits ici ne peuvent pas être ajoutés
def __init__(self):
self.width = 0
self.height = 0
i = Klass()
i.width = 1
i.c = 0 # AttributeError
#Masquage (encapsulation) des méthodes et des attributs Ajouter _ au début du nom
self._size #Inaccessible de l'extérieur de la classe
self.__size #Inaccessible de l'extérieur de la classe
## Setter / Getter(Méthode dédiée pour modifier ou référencer des données)
##Propriété(Setter /Fonction pour définir facilement Getter)
##Empêcher la réécriture de l'extérieur de la classe comme des attributs
class Prop(object):
def __init__(self):
#Le nom utilisé en interne est différent du nom de propriété x(Prévention des boucles infinies)
self.__x = 0
def getx(self): # Getter
return self.__x
def setx(self, x): # Setter
self.__x = x
#Obtention de la propriété x,Définir le poseur
x = property(getx, setx)
i = Prop()
i.x = 0
##Tour de l'aura de l'opérateur(redéfinition)
__add__(self, other) # + (self + other)
__sub__(self, other) # -
__mul__(self, other) # *
__truediv__(self, other) # /
__floordiv__(self, other) # //
__iadd__(self, other) # +=
__isub__(self, other) # -=
__imul__(self, other) # *=
__itruediv__(self, other) # /=
__ifloordiv__(self, other) # //=
__or__(self, other) # | (or)
__and__(self, other) # & (and)
##Comparaison de l'aura de l'opérateur
## equal, not equal, lesser than, greater than, ...
__eq__(self, other) # ==
__ne__(self, other) # !=
__lt__(self, other) # < (self < other)
__gt__(self, other) # >
__le__(self, other) # <=
__ge__(self, other) # >=
##Remplacement de la conversion de type
__int__(self) # int()
__bytes__(self)
__float__(self)
__str__(self)
__repr__(self) #Conversion en représentation sous forme de chaîne de caractères imprimable
__format__(self, form_spec) # format()Redéfinir le format dans
##Méthode spéciale utilisée dans le type de conteneur
__len__(self) # len()
__getitem__(self, key) # obj[key]
__setitem__(self, key, value) # obj[key] = value
__delitem__(self, key) # del obj[key]
__iter__(self) # iter() :Renvoie un objet itérateur
# (À l'intérieur__next_()Besoin de définir une méthode appelée)
__getattr__(self, attributeName) #N'existe pas dans l'objet
#Appelé lorsqu'un attribut est référencé
#Si vous voulez que l'attribut soit inexistant
# raise AttributeError
__getattrubute__(self, attributeName) #Appelé sans condition__getattr__
__setattr__(self, attributeName, value) #Appelé lors de l'attribution
__call__(self[, args...]) #Le nom de l'objet est suivi de parenthèses
#Appelé lorsqu'il est appelé en tant que fonction
__del__(self) #Destructeur
__hash__(self) # hash()Renvoie la valeur de hachage sous forme d'entier
##Détermination du type d'objet
isinstance(var, type) #Jugement de type(ype= str, int, float, ...)
##Obtenir des attributs (y compris des méthodes)
s = "abcde"
s.find("cd")
getattr(s, "find")("cd") # find()Appelez la méthode
#Bibliothèque standard
##Obtenir des données du serveur Web
from urllib import request
src = request.urlopen('http://www.python.org/').read()
from urllib import request, parse
url = 'http://www.python.org/somefile.zip'
filename = parse.urlparse(url)[2].split('/')[-1]
request.urlretrieve(url, filename)
##Dictionnaire ordonné
from collections import OrderedDict
od = OrderedDict()
##Dictionnaire avec prix par défaut
from collections import defaultdict
animals = [('Chat', 'Main Kuhn'),
('Chat', 'Abyssin'),
('chien', 'Carlin'),
('chien', 'Husky sibérien'),
('chien', 'bouledogue') ]
dd = defaultdict(list) #Un dictionnaire avec une liste vide comme valeur initiale
for k, v in animals :
dd[k].append(v)
dd # => defaultdict(<class 'list'>, {'Chat': ['Main Kuhn', 'Abyssin'], 'chien': ['Carlin', 'Husky sibérien', 'bouledogue']})
##Aide à l'ajout d'éléments à une liste triée
import bisect
##Gérer la date et l'heure
import datetime
datetime.date.today() #aujourd'hui
datetime.datetime.now() #Date et heure actuelles
datetime.datetime(2014, 3, 2, 16, 32, 00)
datetime.time(16, 32, 00)
datetime.date(2014, 3, 2)
d = datetime.date(2014, 3, 2)
d.year #2014
d.month # 3
d.day # 2
d.weekday() # 6:Jour quotidien
d.strftime('%Y/%m/%d %H:%M:%S') # '2014/03/02 00:00:00'
d = datetime.strptime('2014/03/02 00:00:00', '%Y/%m/%d %H:%M:%S')
###Différence de date et d'heure(La comparaison et la multiplication / division sont également possibles)
delta = datetime.timedelta(days=5)
d1 = datetime.date(2014, 2, 6)
d2 = d1 + delta
print(d2) # 2014-02-11
d2 = datetime.date(2014, 3, 2)
d1 = datetime.date(2014, 2, 6)
d2 = datetime.date(2014, 3, 2)
delta = d2 - d1
print(delta) # 24 days, 0:00:00
##Obtenir des informations sur le calendrier
import calendar
###Jour et nombre de jours dans l'année et le mois spécifiés
(days, first_weekday) = calendar.monthrange(2014, 2)
print(days, first_weekday) #5 28
calendar.month(2014, 2) #Calendrier de sortie
##Expressions régulières
import re
re.findall(r'[abcde]', 'abcdefg') # ['a', 'b', 'c', 'd', 'e']
re.split(r',', 'ab,cde,fg') # ['ab', 'cde', 'fg']
re.sub(r'a', 'b', 'abcde') # 'bbcde'
match = re.search(r'a', 'abcdea')
print(match)
match = re.match(r'a', 'abcdea')
print(match)
for match in re.finditer(r'[a-z]+', 'This is a pen.'):
print(match.group(0), end =' ') # his is a pen
s = 'abcd,efgh,ijkl'
r = re.compile(r'[abcde]', re.IGNORECASE | re.MULTILINE | re.DOTALL)
r.findall(s)
##Obtenir et utiliser les paramètres système
import sys
sys.argv[0] #Le script en cours d'exécution lui-même
sys.argv[1:] #Paramètres de ligne de commande
sys.exit(0)
sys.getdefaultencoding()
##Acquérir et exploiter des informations dépendant du système d'exploitation telles que les systèmes de fichiers et les processus
import os
os.getenv(key, default=None)
os.chdir(path)
os.getcwd()
os.remove(path)
os.rename(src, dest)
os.mkdir(path, mode)
os.mkdirs(path, mode) #Créez un chemin en chemin
os.rmdir(path)
os.removedirs(path) #Supprimer au milieu
os.path.exists(path)
os.path.getsize(path)
os.path.isfile(path)
os.path.isdir(path)
os.path.join(path, path2, ...)
dirname, filename = os.path.split(path)
path = r'c:\users\default\desktop.ini'
os.path.dirname(path) #Nom du répertoire
os.path.basename(path) #nom de fichier
path_without_ext, ext = os.path.splitext(path) #extension
##Module mathématique
import math
math.pi
mati.sqrt(2)
mati.sin(60)
mati.cos(60)
mati.tan(60)
##nombre aléatoire
import random
random.seed(value) #Graine aléatoire
x = random.random() # 0 <= x <= 1
y = random.randint(1, 10) #Entier de 1 à 10
###Traversez la hiérarchie
for dirpath, dirnames, filenames in os.walk(path, topdown=True, oneerror=None):
do_something()
###processus/Exécution d'une commande externe
exit_status = os.system(command) #Exécutez le processus et attendez qu'il se termine(Renvoie le code de fin)
os.startfile(path) #Commande de démarrage de Windows
import commands
stdout_text = commands.getoutput(command) #Exécutez le processus et attendez qu'il se termine(Renvoie la sortie standard)
Installation d'IPython
>pip install ipython
Lancez IPython
>ipython
Lancez IPython Notebook
>ipython notebook --inline
Recommended Posts