Ich habe mehr mit Python gespielt und etwas mehr gelernt, daher werde ich es als Fortsetzung von Last time schreiben.
Es spielt keine Rolle, aber der Python-Benutzer heißt Pythonista. Ziel Pythonista! !!
Gewöhnlich
items = ["A", "B", "C", "D", "E"]
item = items[1] #Holen Sie sich das Element von Index 1
print(item) # B
Kürzlich gelernt
items = ["A", "B", "C", "D", "E"]
item = items[-1] #Holen Sie sich das letzte Element
# item = items[len(items) - 1] #Du musst das nicht tun
print(item) # E
Wenn Sie -2 angeben, können Sie das zweite "D" von hinten erhalten.
Ich habe [letztes Mal] geschrieben (http://qiita.com/ota-meshi/items/3f14dae4447af7cd04b2), aber es sieht so aus.
items = ["A", "B", "C", "D", "E"]
items2 = items[1:3] #Listengenerierung, die den Index 1 bis 2 extrahiert
print(items2) # ['B', 'C']
items3 = items[1:] #Listengenerierung, die die gesamte Rückseite aus Index 1 extrahiert
print(items3) # ['B', 'C', 'D', 'E']
items4 = items[:3] #Listengenerierung, die alles vor Index 3 extrahiert
print(items4) # ['A', 'B', 'C']
Darüber hinaus kann es auf diskrete Weise aufgenommen werden.
items = ["A", "B", "C", "D", "E", "F", "G"]
items6 = items[::2] #Listengenerierung durch Überspringen einer
print(items6) # ['A', 'C', 'E', 'G']
items7 = items[::-1] #Umgekehrte Listengenerierung
print(items7) # ['G', 'F', 'E', 'D', 'C', 'B', 'A']
items8 = items[-1:3:-1] #Wenn Sie den Indexbereich in umgekehrter Reihenfolge angeben, beginnen Sie hinten. (Wenn Sie es umkehren, können Sie das Element nicht entfernen.)
print(items8) # ['G', 'F', 'E']
Natürlich können Sie [::] verwenden, um verschiedene Schleifen des Arrays zu erstellen.
items = ["A", "B", "C", "D", "E", "F", "G"]
for item in items[1:]:
print(item) # B,C,D,E,F,Drucken Sie G der Reihe nach
print("---")
for item in items[::-1]:
print(item) # G,F,E,D,C,B,Drucken Sie A in der richtigen Reihenfolge
print("---")
for item in items[::3]:
print(item) # A,D,Drucken Sie G der Reihe nach
Es gab einen Weg.
items = ["A", "B", "C", "D", "E"]
for i, value in enumerate(items):
print(str(i) + ":"+ value)
Ergebnis
0:A
1:B
2:C
3:D
4:E
(Vielleicht anders als die for-Anweisung) http://docs.python.jp/3.5/tutorial/datastructures.html#list-comprehensions
Wenn Sie den Inhalt eines Arrays bearbeiten möchten, um ein anderes Array zu erstellen
items = ["a", "B", "c", "D", "e"]
#Erstellen Sie eine großgeschriebene Liste
items2 = []
for item in items:
items2.append(item.upper())
print(items2) # ['A', 'B', 'C', 'D', 'E']
Wo es geschrieben zu sein scheint, kann die Verarbeitung der Schleife, die items2 erstellt, wie folgt geschrieben werden.
items2 = [item.upper() for item in items]
Wenn Sie eine Karte verwenden, können Sie übrigens wie folgt schreiben.
items2 = list(map(str.upper, items))
des Weiteren,
items = ["a", "B", "c", "D", "e"]
#Erstellen Sie eine Liste mit nur Großbuchstaben
items2 = []
for item in items:
if item.upper() == item:
items2.append(item)
print(items2) # ['B', 'D']
Wo es geschrieben zu sein scheint, kann die Verarbeitung der Schleife, die items2 erstellt, wie folgt geschrieben werden.
items2 = [item for item in items if item.upper() == item]
Python-Array-Bindung, die persönlich sehr beeindruckend ist Es wurde nur mit dem Operator "+" erstellt.
item1 = ["A", "B", "C"]
item2 = ["D", "E"]
item3 = item1 + item2
print(item3) # ['A', 'B', 'C', 'D', 'E']
(Im Gegensatz zu "Erweitern" wird eine andere Liste erstellt.)
Wie zu erwarten ist, ist natürlich auch eine zusätzliche Substitution möglich
item1 = ["A", "B", "C"]
item2 = ["D", "E"]
item1 += item2
# item1.extend(item2)Und das Ergebnis ist das gleiche
print(item1) # ['A', 'B', 'C', 'D', 'E']
Und ich persönlich verstehe das überhaupt nicht.
item1 = ["A", "B", "C"]
item2 = ["D", "E"]
item1[:0] = item2
print(item1) # ['D', 'E', 'A', 'B', 'C']
Wenn Sie wie oben schreiben, können Sie es mit Ihrem Kopf kombinieren.
Ich bin nicht daran gewöhnt, deshalb kann ich es vorerst nicht verstehen
item1 = item2 + item1
Ich denke ich werde schreiben.
join (Letztes Mal Vielleicht hätte es geschrieben werden sollen)
s = ":".join(["A", "B", "C", "D", "E"])
print(s) # "A:B:C:D:E"
Dies ist auch eine Methode, von der ich sehr beeindruckt bin.
Es wurde nur mit dem Operator * erstellt. (Ich habe eine Schleife geschrieben, bis ich das wusste)
s = "Ah" * 5
print(s) #Ahhhh
Schreiben Sie so. Die Art und Weise, einen Lambda-Ausdruck zu schreiben, unterscheidet sich derzeit nicht wesentlich von Java.
func = lambda x: x.upper()
print(func("a")) # A
in Bestimmen Sie (oder), ob es in der Sequenz enthalten ist. (Das Verhalten ist anders mit Diktat) Eine praktische, die nicht mit oder verbunden sein muss.
http://docs.python.jp/3.5/reference/expressions.html#membership-test-operations Es scheint, dass der Name Attributionsprüfungsberechnung ist. Wie SQL IN? Eine persönliche Erinnerung, die ich mit Temple Mark Language hätte machen können.
if 2 in [1, 2, 3]: # True
print("Da sind 2")
if 4 not in [1, 2, 3]: # True
print("4 ist nicht")
yield
http://docs.python.jp/3.5/reference/expressions.html#yieldexpr http://docs.python.jp/3.5/reference/simple_stmts.html#the-yield-statement
Ich kann nicht erklären, wie hoch der Ertrag ist. Beziehen Sie sich daher auf Folgendes https://ja.wikipedia.org/wiki/ジェネレータ_(プログラミング)
Ich habe verstanden, wie man Iterator einfach in Java erstellt.
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(): #Kann mit einer for-Anweisung gedreht werden
print(i) #Ausgabe 1, 2 und 3 der Reihe nach
Als nächstes kommt der interessante Teil der Ausbeute
def yield_sample2():
print("Weiter ist 1")
yield 1
print("Weiter ist 2")
yield 2
print("Weiter ist 3")
yield 3
print("Es gibt kein nächstes")
for i in yield_sample2():
print(i) #Ausgänge 1, 2 und 3 der Reihe nach, aber ...
Das Ergebnis ist
Weiter ist 1
1
Weiter ist 2
2
Weiter ist 3
3
Es gibt kein nächstes
Wenn Sie den nach Yield erstellten Generator auflisten möchten,
def yield_sample():
for i in [1, 2, 3]:
yield i
l = list(yield_sample())
print(l) # [1, 2, 3]
Google ist möglicherweise schneller. Ich hatte den Eindruck, dass es mehrere Möglichkeiten gibt, dies zu tun. Ich weiß nicht, welche Methode die beste ist. Ich werde nicht alle Dateioperationen schreiben, aber ich werde nur die schreiben, die ich verwendet habe.
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 Catch Block in Java
def error_throw():
"" + 1
try:
error_throw()
print("Komm nicht her")
except: #Komm her mit allen Fehlern
print("Error")
try:
error_throw()
print("Komm nicht her")
except Exception as e: #Fehlerobjekt abrufen
print(type(e))
print(e)
Ergebnis
<class 'TypeError'>
Can't convert 'int' object to str implicitly
Gilt auch für den Ausnahmetyp
try:
error_throw()
print("Komm nicht her")
except ValueError:
print("ValueError tritt nicht auf, daher kommt es nicht hierher")
except TypeError:
print("Ich bin hier, weil ich einen TypeError bekomme")
trace Stacktrace netter Kerl in Java
import traceback
try:
error_throw()
except :
print(traceback.format_exc())
Kann nicht. Es tut mir Leid. Mit einem Java-ähnlichen Bild ist dies nicht möglich.
def new_counter():
count = 0
def func():
count += 1
return count
return func
c = new_counter()
print(c())
print(c())
print(c())
Error
UnboundLocalError: local variable 'count' referenced before assignment
Sie können so etwas tun, indem Sie wie folgt schreiben. .. .. (Wie 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())
Von Eclipse "Neu" -> "Pydev-Modul" -> Name und "Fertig" -> Wenn Sie "Modul: Unittest" auswählen und sehen, was Sie mit "OK" tun können, können Sie verstehen, wie man es schreibt.
Sie kann durch Auswahl von "Ausführen" -> "Python Unit Test" ausgeführt werden.
import unittest
class Test(unittest.TestCase):
def testName(self):
self.assertEqual(1, 2, "Stichprobe")
if __name__ == "__main__":
#import sys;sys.argv = ['', 'Test.testName']
unittest.main()
Ergebnis
F
======================================================================
FAIL: testName (__main__.Test)
----------------------------------------------------------------------
Traceback (most recent call last):
File "C:\hogehoge\testsample.py", line 13, in testName
self.assertEqual(1, 2, "Stichprobe")
AssertionError: 1 != 2 :Stichprobe
----------------------------------------------------------------------
Ran 1 test in 0.016s
FAILED (failures=1)
Ich bezog mich auf Folgendes. http://hirokazumiyaji.hatenablog.com/entry/2015/07/16/134238
Das folgende Beispiel ist ein Beispiel zum Registrieren des Tests für die Dateien im Verzeichnis.
import unittest
import os
class Test(unittest.TestCase):
#Leere Testklasse
pass
def setup_testsuite():
"""
Registrieren Sie den Test, indem Sie die Dateien im Verzeichnis auflisten
"""
root = os.getcwd()
test_files_dir = os.path.join(root, "files") #Richten Sie die Dateien im Dateiordner neben dieser py-Datei aus
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":#Durch Erweiterung eingrenzen
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):
"""
Tatsächlicher Zustand des Tests
"""
print("test start: " + file_name)
#Da self Test ist, wird assertEqual wie folgt aufgerufen
# self.assertEqual(first, second, msg)
return test_func
test_name = "test_{}".format(file_name)
setattr(Test, test_name, create_test_func(file_name, path)) #Anmeldung
#Führen Sie eine Testregistrierung durch
setup_testsuite()
if __name__ == "__main__":
# import sys;sys.argv = ['', 'Test.testName']
unittest.main()
Recommended Posts