J'ai joué plus avec Python et j'ai appris un peu plus, donc je vais l'écrire comme une suite de Dernière fois.
Cela n'a pas d'importance, mais Python s'appelle Pythonista. Visez Pythonista! !!
Habituel
items = ["A", "B", "C", "D", "E"]
item = items[1] #Récupère l'élément de l'index 1
print(item) # B
Récemment appris
items = ["A", "B", "C", "D", "E"]
item = items[-1] #Obtenez le dernier élément
# item = items[len(items) - 1] #Tu n'as pas à faire ça
print(item) # E
Si vous spécifiez -2, vous pouvez obtenir le deuxième "D" à l'arrière.
J'ai écrit Dernière fois, mais cela ressemble à ceci.
items = ["A", "B", "C", "D", "E"]
items2 = items[1:3] #Génération de liste qui extrait les index 1 à 2
print(items2) # ['B', 'C']
items3 = items[1:] #Génération de liste qui extrait tout le dos de l'index 1
print(items3) # ['B', 'C', 'D', 'E']
items4 = items[:3] #Génération de liste qui extrait tout avant l'index 3
print(items4) # ['A', 'B', 'C']
De plus, il peut être pris de manière discrète.
items = ["A", "B", "C", "D", "E", "F", "G"]
items6 = items[::2] #Génération de liste extraite en en sautant une
print(items6) # ['A', 'C', 'E', 'G']
items7 = items[::-1] #Génération de liste inversée
print(items7) # ['G', 'F', 'E', 'D', 'C', 'B', 'A']
items8 = items[-1:3:-1] #Si vous spécifiez la plage d'index dans l'ordre inverse, commencez par l'arrière. (Si vous l'inversez, vous ne pouvez pas supprimer l'élément)
print(items8) # ['G', 'F', 'E']
Bien sûr, vous pouvez utiliser [::] pour créer diverses boucles du tableau.
items = ["A", "B", "C", "D", "E", "F", "G"]
for item in items[1:]:
print(item) # B,C,D,E,F,Imprimer G dans l'ordre
print("---")
for item in items[::-1]:
print(item) # G,F,E,D,C,B,Imprimer A dans l'ordre
print("---")
for item in items[::3]:
print(item) # A,D,Imprimer G dans l'ordre
Il y avait un moyen.
items = ["A", "B", "C", "D", "E"]
for i, value in enumerate(items):
print(str(i) + ":"+ value)
résultat
0:A
1:B
2:C
3:D
4:E
(Peut-être différent de l'instruction for) http://docs.python.jp/3.5/tutorial/datastructures.html#list-comprehensions
Lorsque vous souhaitez manipuler le contenu d'un tableau pour créer un autre tableau
items = ["a", "B", "c", "D", "e"]
#Faire une liste en majuscules
items2 = []
for item in items:
items2.append(item.upper())
print(items2) # ['A', 'B', 'C', 'D', 'E']
Là où il semble être écrit, le traitement de la boucle qui crée les items2 peut être écrit comme suit.
items2 = [item.upper() for item in items]
Au fait, si vous utilisez map, vous pouvez écrire comme suit.
items2 = list(map(str.upper, items))
plus loin,
items = ["a", "B", "c", "D", "e"]
#Faites une liste avec uniquement des lettres majuscules
items2 = []
for item in items:
if item.upper() == item:
items2.append(item)
print(items2) # ['B', 'D']
Là où il semble être écrit, le traitement de la boucle qui crée les items2 peut être écrit comme suit.
items2 = [item for item in items if item.upper() == item]
Liaison de tableau Python qui est assez impressionnante personnellement Il a été réalisé uniquement avec l'opérateur «+».
item1 = ["A", "B", "C"]
item2 = ["D", "E"]
item3 = item1 + item2
print(item3) # ['A', 'B', 'C', 'D', 'E']
(Contrairement à extend, une autre liste est créée)
Comme vous pouvez vous y attendre, bien sûr, une substitution supplémentaire est également possible
item1 = ["A", "B", "C"]
item2 = ["D", "E"]
item1 += item2
# item1.extend(item2)Et le résultat est le même
print(item1) # ['A', 'B', 'C', 'D', 'E']
Et personnellement, je ne comprends pas du tout.
item1 = ["A", "B", "C"]
item2 = ["D", "E"]
item1[:0] = item2
print(item1) # ['D', 'E', 'A', 'B', 'C']
Si vous écrivez comme ci-dessus, vous pouvez le combiner avec votre tête.
Je n'y suis pas habitué, donc je ne peux pas le comprendre pour le moment
item1 = item2 + item1
Je pense que je vais écrire.
join (Dernière fois Peut-être que cela aurait dû être écrit)
s = ":".join(["A", "B", "C", "D", "E"])
print(s) # "A:B:C:D:E"
C'est aussi une méthode qui m'impressionne. Il a été réalisé uniquement avec l'opérateur «*». (J'ai écrit une boucle jusqu'à ce que je sache cela)
s = "Ah" * 5
print(s) #Ahhhh
Écrivez comme ça. La façon d'écrire une expression lambda n'est pas très différente de Java actuellement.
func = lambda x: x.upper()
print(func("a")) # A
in Déterminez (ou) s'il est inclus dans la séquence. (Le comportement est différent avec dict) Un outil pratique qui n'a pas besoin d'être connecté avec ou.
http://docs.python.jp/3.5/reference/expressions.html#membership-test-operations Il semble que le nom soit le calcul de l'inspection d'attribution. Comme SQL IN? Un souvenir personnel que j'aurais pu faire avec Temple Mark Language.
if 2 in [1, 2, 3]: # True
print("Il ya deux")
if 4 not in [1, 2, 3]: # True
print("4 n'est pas")
yield
http://docs.python.jp/3.5/reference/expressions.html#yieldexpr http://docs.python.jp/3.5/reference/simple_stmts.html#the-yield-statement
Je ne peux pas expliquer quel est le rendement, alors reportez-vous à ce qui suit https://ja.wikipedia.org/wiki/ジェネレータ_(プログラミング)
J'ai compris comment créer facilement Iterator en Java.
def yield_sample():
for i in [1, 2, 3]:
yield i
gen = yield_sample()
print(next(gen)) # 1
print(next(gen)) # 2
print(next(gen)) # 3
print(next(gen)) # StopIteration
for i in yield_sample(): #Peut être tourné avec une instruction for
print(i) #Sortie 1, 2 et 3 dans l'ordre
Vient ensuite la partie intéressante du rendement
def yield_sample2():
print("Le suivant est 1")
yield 1
print("Le suivant est 2")
yield 2
print("Le suivant est 3")
yield 3
print("Il n'y a pas de suivant")
for i in yield_sample2():
print(i) #Sorties 1, 2 et 3 dans l'ordre, mais ...
Le résultat est
Le suivant est 1
1
Le suivant est 2
2
Le suivant est 3
3
Il n'y a pas de suivant
Si vous souhaitez lister le générateur créé par yield,
def yield_sample():
for i in [1, 2, 3]:
yield i
l = list(yield_sample())
print(l) # [1, 2, 3]
Cela peut être plus rapide sur Google. J'ai eu l'impression qu'il y avait plusieurs façons de le faire. Je ne sais pas quelle méthode est la meilleure. Je n'écrirai pas toutes les opérations sur les fichiers, mais je n'écrirai que celles que j'ai utilisées.
f = codecs.open(path, "r", "utf-8")
ret = f.read()
f.close()
f = codecs.open(path,"w", "utf-8")
f.write(value)
f.close()
if os.path.exists(path):
os.makedirs(dirPath)
os.path.dirname(path)
for root, _, files in os.walk(dirPath):
for fileName in files:
path = os.path.join(root, fileName)
yield path
except Bloc de capture en Java
def error_throw():
"" + 1
try:
error_throw()
print("Ne viens pas ici")
except: #Viens ici avec toutes les erreurs
print("Erreur")
try:
error_throw()
print("Ne viens pas ici")
except Exception as e: #Obtenir un objet d'erreur
print(type(e))
print(e)
résultat
<class 'TypeError'>
Can't convert 'int' object to str implicitly
S'applique également au type d'exception
try:
error_throw()
print("Ne viens pas ici")
except ValueError:
print("ValueError ne se produit pas, donc il ne vient pas ici")
except TypeError:
print("Je suis ici parce que j'ai une TypeError")
trace Stacktrace gentil mec en Java
import traceback
try:
error_throw()
except :
print(traceback.format_exc())
Ne peux pas. Je suis désolé. Vous ne pouvez pas le faire avec une image similaire à Java.
def new_counter():
count = 0
def func():
count += 1
return count
return func
c = new_counter()
print(c())
print(c())
print(c())
Erreur
UnboundLocalError: local variable 'count' referenced before assignment
Vous pouvez faire quelque chose comme ça en écrivant comme suit. .. .. (Comme Java)
def new_counter():
count = [0]
def func():
count[0] += 1
return count[0]
return func
c = new_counter()
print(c())
print(c())
print(c())
Depuis Eclipse "Nouveau" -> "Module Pydev" -> Nom et "Terminé" -> Si vous sélectionnez "Module: Unittest" et voyez ce que vous pouvez faire avec "OK", vous pouvez comprendre comment l'écrire.
Il peut être exécuté en sélectionnant "Exécuter" -> "Test unitaire Python".
import unittest
class Test(unittest.TestCase):
def testName(self):
self.assertEqual(1, 2, "échantillon")
if __name__ == "__main__":
#import sys;sys.argv = ['', 'Test.testName']
unittest.main()
résultat
F
======================================================================
FAIL: testName (__main__.Test)
----------------------------------------------------------------------
Traceback (most recent call last):
File "C:\hogehoge\testsample.py", line 13, in testName
self.assertEqual(1, 2, "échantillon")
AssertionError: 1 != 2 :échantillon
----------------------------------------------------------------------
Ran 1 test in 0.016s
FAILED (failures=1)
J'ai évoqué ce qui suit. http://hirokazumiyaji.hatenablog.com/entry/2015/07/16/134238
L'exemple ci-dessous est un exemple pour enregistrer le test pour les fichiers dans le répertoire.
import unittest
import os
class Test(unittest.TestCase):
#Classe de test vide
pass
def setup_testsuite():
"""
Enregistrez le test en listant les fichiers dans le répertoire
"""
root = os.getcwd()
test_files_dir = os.path.join(root, "files") #Ciblez les fichiers dans le dossier files à côté de ce fichier py
def listup():
for root, _, files in os.walk(test_files_dir):
for file_name in files:
if os.path.splitext(file_name)[1].lower() == ".txt":#Affiner par extension
yield file_name, os.path.join(root, file_name)
for file_name, path in listup():
def create_test_func(file_name, path):
def test_func(self):
"""
État réel du test
"""
print("test start: " + file_name)
#Puisque self est Test, assertEqual est appelé comme suit
# self.assertEqual(first, second, msg)
return test_func
test_name = "test_{}".format(file_name)
setattr(Test, test_name, create_test_func(file_name, path)) #enregistrement
#Effectuer l'enregistrement du test
setup_testsuite()
if __name__ == "__main__":
# import sys;sys.argv = ['', 'Test.testName']
unittest.main()
Recommended Posts