Une note personnelle lors de l'écriture de python. Principalement lors de l'étude de la page suivante. http://www.tohoho-web.com/python/index.html
python.py
#!/usr/bin/python3
# -*- coding: utf-8 -*-
#Voir ci-dessous
# http://docs.python.jp/3/library/functions.html
# http://www.tohoho-web.com/python/index.html
# http://docs.python.jp/3.5/
print("En python, il semble qu'une erreur se produira si vous n'écrivez pas le code du caractère au début")
"""
Commentaire sur plusieurs lignes
À l'origine, il s'agit d'une chaîne de caractères littérale, mais il semble qu'elle soit également utilisée comme commentaire
"""
print("\n\n----------")
print("○ importer et imprimer")
import random
num = random.randint(1,10)
print("num est"+str(num))
print("\n\n----------")
print("○ si déclaration")
if num == 1:
print("num est 1")
elif num < 5:
print("num est égal ou inférieur à 5")
else:
print("Autre")
print("\n\n----------")
print("○ instruction while")
n = 0
while n < 3:
print("while "+str(n))
n += 1
else:
print('while END')
print("Si vous écrivez else dans l'instruction while, else sera exécuté si la condition while n'est pas remplie et que le message est quitté.")
print("Il sera exécuté même si les conditions ne sont pas remplies depuis le début.")
print("S'il se casse en raison d'une rupture, etc., il ne sera pas exécuté.")
print("\n\n----------")
print("○ pour la peine")
for n in [1, 2, 3]:
print(n) # => 1, 2, 3
else:
print("END")
for n in (1, 2, 3):
print(n) # => 1, 2, 3
for k,v in {'one': 1, 'two': 2, 'three': 3}.items():
print(str(k)+":"+str(v)) # => one:1, two:2, three:3
for c in "123":
print(c) # => 1, 2, 3
for line in open("data.txt"):
print(line) # =>Affichage ligne par ligne
for n in range(3,6):
print(n) # => 3, 4, 5
for c in 'AIUEO':
print(c) # =>Ah,je,U,e,Oh
print("Vous pouvez également écrire else dans l'instruction for.")
print("Le sens est le même que while.")
for x in range(2, n):
if n % x == 0:
print(n, 'equals', x, '*', n//x)
break
else:
# loop fell through without finding a factor
print(n, 'is a prime number')
print("\n\n----------")
print("○ méthode de type printf")
errmsg = "Chaîne"
errcode = 12
msg = "Vous pouvez faire quelque chose comme printf au stade de la création d'une chaîne[%s](%d)" % (errmsg, errcode)
print(msg)
print("%(name)s is %(age)d years old." % {'age': 28, 'name': "Tanaka"})
print("\n\n----------")
print("○ Liste et pour déclaration")
a = [1, 2, "AAA", 4, (1+3j)*(2+2j)]
print('Le troisième à partir de 0'+str(a[3])) # => 4
print("1er au 2ème(Le n ° 3 n'est pas inclus)Avec des tranches"+str(a[1:3])) # => [2, 'AAA']
print("Vous pouvez omettre le début et la fin. Jusqu'à la seconde"+str(a[:3])) # => [1, 2, 'AAA']
print("Des valeurs négatives peuvent également être utilisées. De l'arrière à la seconde(Cependant, le second lui-même n'est pas inclus)Est"+str(a[:-2])) # => [1, 2, 'AAA']
print("Largeur de pas(Étape)Peut également être changé"+str(a[0:1:2])) # => [1, 'AAA']
print("Des valeurs négatives peuvent être utilisées pour la taille de pas"+str(a[::-1])) # => [(-4+8j), 4, 'AAA', 2, 1]
print("Vous pouvez également modifier la valeur")
print("Changer avant:"+str(a)) # => [1, 2, 'AAA', 4, (-4+8j)]
a[1]=999
print("Après le changement:"+str(a)) # => [1, 999, 'AAA', 4, (-4+8j)]
print("Vous pouvez également ajouter.")
a.append(777)
print("Après le changement:"+str(a)) # => [1, 999, 'AAA', 4, (-4+8j), 777]
for n in a:
print("[pour déclaration]"+str(n)+"C'est vrai")
print("rejoindre la liste" + str([1, 2, 3] + [4, 5, 6])) # => [1, 2, 3, 4, 5, 6]
print("len()Trouvez la longueur avec"+str(len([1, 2, 3]))) # => 3
a = [[1, 2], [3, 4], [5, 6]]
a.append([7,8])
print("Plusieurs listes sont également OK"+str(a)) # => [[1, 2], [3, 4], [5, 6], [7, 8]]
for line in a:
for n in line:
print(str(n)+" ", end="")
print("") # => 1 2
# 3 4
# 5 6
# 7 8
print("a[2][1]Est"+str(a[2][1])) # => 6
print("\n\n----------")
print("○ Taple")
a = (11,22,33,)
print("Il existe une version à valeur fixe de la liste"+str(a))
print("Premier comptage à partir de 0"+str(a[1])) # => 22
#a[1]=12 # =>Erreur
print("\n\n----------")
print("○ Dictionnaire")
d = {'Yamada': 30, 'Suzuki': 40, 'Tanaka': 80}
print("dictionnaire(Tableau associatif)Il y a aussi"+str(d))
print("Yamada"+str(d["Yamada"]))
for key,val in d.items():
print("[pour déclaration]"+key+"Est"+str(val))
print("\n\n----------")
print("○ Fonction")
def doublefunc(x):
return x * 2
print("Multiplier 7 par double func"+str(doublefunc(7))) # => 14
a = [1, 2, 3]
print(str(a)+"Pour doubler func"+str(doublefunc(a))) # => [1, 2, 3, 1, 2, 3]
print("\n\n----------")
print("○map")
print("map renvoie le résultat du traitement de chaque élément individuellement")
print("・ Méthode de fonction")
print(map(doublefunc, a)) # => map object
print(list(map(doublefunc, a))) # => [2, 4, 6]
print("・ Méthode Lamb")
print(map(lambda x: x * 2, a)) # => map object
print(list(map(lambda x: x * 2, a))) # => [2, 4, 6]
print("・ Notation inclusive")
print([x * 2 for x in a]) # => [2, 4, 6]
print("○filter")
print("le filtre traite chaque élément individuellement et ne renvoie que le vrai")
a = [1, 2, 3]
def kisuucheck(x): return x % 2
print("・ Méthode de fonction")
print(filter(kisuucheck, a)) # => filter object
print("Les bizarres"+str(list(filter(kisuucheck, a)))) # => [1, 3]
print("・ La méthode Lamb et la notation d'inclusion sont omises")
print("○reduce")
print("réduire traite les premier et deuxième éléments, traite le résultat et le troisième, et ainsi de suite.")
print("Mais probablement parce qu'il n'est pas beaucoup utilisé, il ne peut être utilisé qu'après importation en python3")
from functools import reduce
a = [1, 2, 3, 4, 5]
def add(x, y): return x + y
print(reduce(add, a)) # => 15 :Méthode de fonction
print(reduce(lambda x, y: x + y, a)) # => 15 :méthode lambda
print("○ Notation d'inclusion")
a = [1, 2, 3]
print([x * 2 for x in a]) # => [2, 4, 6]
print([x * 2 for x in a if x%2==1]) # => [2,6]
print([[x, x * 2] for x in a]) # => [[1, 2], [2, 4], [3, 6]]
print([(x, x * 2) for x in a]) # => [(1, 2), (2, 4), (3, 6)]
a = [[1, 2], [3, 4], [5, 6]]
print([[x[0]*2,x[1]*3] for x in a]) # => [[2, 6], [6, 12], [10, 18]]
print("○ Ensemble")
print("ensemble(set)Est une liste unique")
a = set(['red', 'blue', 'green'])
b = set(['green', 'yellow', 'white'])
print("définir un est"+str(a)) # => set(['red', 'blue', 'green'])
print("l'ensemble b est"+str(b)) # => set(['green', 'yellow', 'white'])
print("a-b est"+str(a-b)) # => set(['red', 'blue'])
print("a|b est"+str(a|b)) # => set(['red', 'blue', 'green', 'yellow', 'white'])
print("a&b est"+str(a&b)) # => set(['green'])
print("a^b est"+str(a^b)) # => set(['red', 'blue', 'yellow', 'white'])
print("'green'dans un est"+str('green' in a)) # => True
a.add('black')
print("Après avoir ajouté du noir à un"+str(a)) # => set(['red', 'blue', 'green', 'black'])
a.add('black')
print("Si vous ajoutez du noir à un"+str(a)) # => set(['red', 'blue', 'green', 'black'])
print("\n\n----------")
print("○ Notez que le nom de la fonction intégrée peut être écrasé après la réservation.")
print("list([1,2])Est"+str(list([1,2]))) # => [1,2]
list_temp = list
list = doublefunc
print("list([1,2])Est"+str(list([1,2]))) # => [1,2,1,2]
list = list_temp
print("list([1,2])Est"+str(list([1,2]))) # => [1,2]
print("\n\n----------")
print("○ Traitement des exceptions")
mystring = 'ABC'
try:
c = mystring[5] #J'obtiens une exception IndexError car je n'ai pas le 5ème caractère
except IOError:
print('IOError') #En cas d'exception IOError, ce bloc sera exécuté
except IndexError:
print('IndexError') #En cas d'exception IndexError, ce bloc sera exécuté
except:
print('Unknown') #Pour les exceptions autres que celles ci-dessus, ce bloc sera exécuté
else:
print('Error not occur') #Si aucune exception n'est levée, ce bloc sera exécuté
finally:
print('Finally') #Ce bloc est toujours exécuté
try:
f = open('sample.txt', 'r')
except:
print('cannot open sample.txt')
else:
lines = f.readlines()
try:
raise SystemError("Sorry, my fault!")
except SystemError as e:
print("SystemError")
print(e)
print("\n\n----------")
print("○with")
print("Si vous traitez avec, l'objet se terminera automatiquement.")
#Comment écrire sans utiliser avec
f = open("data.txt")
print(f.read())
f.close()
#Comment écrire avec avec 1
with open("data.txt") as f:
print(f.read())
#Écrire avec avec 2
f = open("data.txt")
with f:
print(f.read())
print("\n\n----------")
print("○pass")
print("pass ne fait rien, utilisé lors de la création d'une fonction vide, etc.")
def myfunc():
pass
class MyClass:
pass
print("\n\n----------")
print("○del")
print("del supprime l'objet")
x = 5
y = [1, 2, 3]
z = MyClass()
del x, y, z
print("\n\n----------")
print("○ Imprimer dans un fichier avec impression")
f = open("gomi.txt", "a")
print("Hello world!", file=f)
f.close()
print("\n\n----------")
print("○exec")
print("Vous pouvez exécuter une chaîne avec exec")
exec("print('hello')")
print("\n\n----------")
print("○ Fonction")
print("Les arguments de fonction peuvent également être passés par nom")
print("Il détermine également la valeur par défaut de l'argument")
def repeat_msg(msg, repeat=2, a=1):
for i in range(repeat):
print(msg+" a="+str(a))
repeat_msg('Hello') # => Hello a=1, Hello a=1
repeat_msg('Yahho', a=5) # => Yahho a=5, Yahho a=5
print("Vous pouvez également faire des choses comme argv en langage c")
def func(a1, a2, *args, **params):
print(a1) # => A
print(a2) # => B
print(args) # => ('C', 'D')
print(params) # => {'k1': 'K1', 'k2': 'K2'}
func('A', 'B', 'C', 'D', k1='K1', k2='K2')
args = ('C', 'D')
params = {'k1': 'K1', 'k2': 'K2'}
func('A', 'B', args, params) # => A, B, (('C', 'D'), {'k2': 'K2', 'k1': 'K1'}), {}
func('A', 'B', *args, **params) # => A, B, ('C', 'D'), {'k1': 'K1', 'k2': 'K2'}
print("Vous pouvez également renvoyer plusieurs valeurs")
def func():
return 3, "ABC"
n, s = func()
print(n, s) # => 3 ABC
print("\n\n----------")
print("○ Variables globales")
print("Les variables globales ne peuvent normalement pas être référencées ou modifiées dans une fonction")
print("Vous pouvez le changer en le déclarant global")
count = 0 #Variables globales
def func():
global count #Tu ne peux pas changer sans ça
print(count) #Peut être référencé
count += 1
print(count)
func()
print("Toutes les variables globales et locales sont globales()Et les locaux()Vous pouvez l'obtenir à")
def func():
for k in globals().keys():
print("GLOBAL: %s = %s" % (k, globals()[k]))
for k in locals().keys():
print("LOCAL: %s = %s" % (k, locals()[k]))
func()
print("\n\n----------")
print("○ Type Lambda")
print("Les expressions Lambda sont de petites fonctions sans nom.")
print("L'argument est avant les deux-points et la valeur de retour est après.")
myfunc = lambda x, y: x + y
print(myfunc(3, 5)) # => 8
print("\n\n----------")
print("○ Itérateur")
print("Iterator est un objet avec une fonction de répétition qui peut être utilisée dans l'instruction for.")
print("__init__()Écrivez le processus à effectuer une seule fois au début")
print("__iter__()Renvoie l'objet")
print("__next__()Renvoie l'élément suivant avec l'exception StopIteration lorsqu'il atteint la fin")
class Fib:
def __init__(self, max):
self.max = max
self.a = 0
self.b = 1
def __iter__(self):
return self
def __next__(self):
fib = self.a
if fib > self.max:
raise StopIteration
self.a, self.b = self.b, self.a + self.b
return fib
for n in Fib(3):
print(n) # => 0, 1, 1, 2, 3
print("Ce qui précède fait automatiquement ce qui suit")
it = Fib(3).__iter__()
while 1:
try:
n = it.__next__()
print(n) # => 0, 1, 1, 2, 3
except StopIteration:
break
print("\n\n----------")
print("○ Générateur")
print("Il calcule quand l'élément suivant est utilisé, il semble donc que l'efficacité de la mémoire et du traitement sera améliorée par rapport à la création et au passage d'un tableau.")
def funcB(list):
for n in list:
yield n * 2
for n in funcB([1, 2, 3, 4, 5]):
print(n) #=> 2, 4, 6, 8, 10
def readfileB(f):
for line in f:
yield line.rstrip()
f = open("data.txt")
for line in readfileB(f):
if (line == "__END__"):
break
print(line)
f.close()
print("\n\n----------")
print("○ Décorateur")
print("Le traitement peut être ajouté avant et après l'exécution de la fonction")
def mydecolater(func):
import functools
@functools.wraps(func)
def wrapper(*args, **kwargs):
print("Funcname:", func.__name__)
print("Arguments:", args)
print("Keywords:", kwargs)
ret = func(*args, **kwargs)
print("Return:", ret)
return ret
return wrapper
@mydecolater
def func(msg1, msg2, flag=1, mode=2):
"""A sample function"""
print("----", msg1, msg2, "----")
return 1234
n = func("Hello", "Hello2", flag=1)
print(n)
print(repr(func))
print(func.__doc__)
print("\n\n----------")
print("○ Classe")
class MyClass(object):
"""A simple example class""" #Commentaire de Mie Quart
PI=3.14 #Variable de classe
def __init__(self): #constructeur
self.name = "" #nom est une variable d'instance
def getName(self): # getName()Méthode
return self.name
def setName(self, name): # setName()Méthode
self.name = name
a = MyClass() #Créer une instance de la classe
a.setName("Tanaka") # setName()Méthode d'appel
print(a.getName()) # getName()Méthode d'appel
print("Python n'implémente pas de mécanisme de contrôle de portée tel que privé ou protégé, et les variables de classe et les variables d'instance peuvent toutes être référencées de n'importe où.(public)Ce sera.")
print("Les variables de classe et les variables d'instance peuvent être réécrites directement")
MyClass.PI=3.141592
a.name="Tanaka2"
print("Peut être ajouté dynamiquement")
MyClass.myPI=3
a.age=18
print("Si la variable d'instance n'existe pas, "Instance".Notez que "nom de variable" fait référence à une variable de classe.")
print(a.PI) #Puisqu'il n'y a pas de variable d'instance appelée PI, la variable de classe est référencée.
print(""exemple.Une variable d'instance est générée lorsqu'une valeur est affectée à "nom de variable", et la variable d'instance est référencée par la suite.")
a.PI=333 #Une variable d'instance PI peut être créée séparément de la variable de classe PI.
print(a.PI) # =>333 variables d'instance
print(MyClass.PI) # => 3.141592 Variables de classe
print("dir()Si vous utilisez, il sera affiché de différentes manières")
print("MyClass : "+str(dir(MyClass)))
print("MyClass : "+str(dir(a)))
print("\n\n----------")
print("○ Variables de type privé")
class MyClass2(object):
_hidden_param=12
__hidden_param2=34
print("Il existe une règle habituelle selon laquelle les variables d'une classe qui ont un trait de soulignement au début ne doivent pas être accessibles de l'extérieur. Mais vous pouvez y accéder.")
print("2 Si vous le piquez, vous pouvez y accéder normalement dans la classe, mais il sera difficile d'y accéder de l'extérieur. Le nom a légèrement changé, "_nom de la classe__Il devient "nom de variable".")
print("MyClass2._hidden_param="+str(MyClass2._hidden_param))
#print("MyClass2._hidden_param="+str(MyClass2.__hidden_param2)) #← Ceci est une erreur
print("MyClass2._hidden_param="+str(MyClass2._MyClass2__hidden_param2)) #← C'est OK
print("\n\n----------")
print("○ Constructeur, destructeur et chaîne")
class MyClass3(object):
def __init__(self, name):
self.name = name
print("welcome "+str(self.name))
def __str__(self):
return "name is "+self.name
def __del__(self):
print("byebye "+str(self.name))
a = MyClass3("Tanaka")
print(a) # __str__La méthode définie comme est automatiquement appelée.
del(a)
print("\n\n----------")
print("○ Héritage")
class MyClass:
def hello(self):
print("Hello")
class MyClass2(MyClass):
def world(self):
print("World")
a = MyClass2()
a.hello() #=> Hello
a.world() #=> World
print("Remplacement de méthode")
class MyClass:
def hello(self):
print("Hello")
class MyClass2(MyClass):
def hello(self): #Classe des parents bonjour()Méthode de remplacement
print("HELLO")
a = MyClass2()
a.hello() #=> HELLO
print("super")
class MyClass1(object):
def __init__(self):
self.val1 = 123
def pripri(self):
print("print1")
class MyClass2(MyClass1):
def __init__(self):
super(MyClass2, self).__init__()
self.val2 = 456
def pripri(self):
super(MyClass2, self).pripri()
print("print2")
a = MyClass2()
print(a.val1) #=> 123
print(a.val2) #=> 456
a.pripri()
print("Héritage multiple")
class MyClassA:
def funcA(self):
print("MyClassA:funcA")
class MyClassB:
def funcB(self):
print("MyClassB:funcB")
class MyClassC(MyClassA, MyClassB):
def funcC(self):
print("MyClassC:funcC")
a = MyClassC()
a.funcA() #Les méthodes MyClassA aussi
a.funcB() #Vous pouvez également utiliser les méthodes MyClassB
a.funcC()
print("\n\n----------")
print("○ Module")
import mymodule
mymodule.myfunc()
print("Omis pour les packages.")
print("nom de fichier"+str(__file__))
print("__name__Vous pouvez afficher le nom du module avec. Si lancé par script__main__Sera. str(__name__)="+str(__name__))
print("\n\n----------")
print("○pprint")
print("Utilisez pprint pour afficher des informations telles que des tableaux d'une manière facile à lire")
from pprint import pprint
aaa = [0, 1, 2]
ppp = {'taro':{'age': '21', 'name': 'tanaka'}, 'jiro':{'age': '18', 'name': 'tanaka2'},}
pprint(aaa) #=> [0, 1, 2]
pprint(ppp) #=> {'jiro': {'age': '18', 'name': 'tanaka2'},
# 'taro': {'age': '21', 'name': 'tanaka'}}
import os
print("Le chemin actuel est"+os.getcwd())
print("\n\n----------")
print("○ Imprimer pour le débogage")
print("Si vous souhaitez l'afficher uniquement lors du débogage, procédez comme suit(Je ne sais pas si c'est un bon moyen)。")
def null_function(x):
return
myprint=null_function
#myprint=print
myprint("hoge")
print("\n\n----------")
print("○ Changement partiel de la chaîne de caractères")
print("Texte comme le langage C[2]='x'Etc. ne peut pas être utilisé.")
print("parce que str est immuable")
print("Convertissez-le en liste, puis modifiez-le ou utilisez-le avec des tranches.")
print("référence: http://minus9d.hatenablog.com/entry/20130528/1369745960")
text="test string"
#text[2]='S'#C'est NG
temp=list(text)
temp[2]='S'
text="".join(temp)
print(text) #=> "teSt string"
print("\n\n----------")
print("○ Passer des arguments par valeur et par référence")
print("Les arguments de fonction peuvent être passés par valeur ou par référence.")
print("Similaire au langage C, int,float etc. sont passés par valeur, liste,dict etc. sont passés par référence.")
print("Mais str est passé par valeur.")
print("référence: http://amacbee.hatenablog.com/entry/2016/12/07/004510")
def func1(x):
x[1]=999
y=[0,1,2]
print(y) #=> [0, 1, 2]
func1(y)
print(y) #=> [0, 999, 2]
print("\n\n----------")
print("○ Arrêtez le fichier de script au milieu et activez l'entrée")
import code; code.InteractiveConsole(locals=dict(globals(),**locals())).interact()
mymodule.py
#!/usr/bin/python3
# -*- coding: utf-8 -*-
#module
def myfunc():
print("Hello!")
Recommended Posts