Notes de débutant Python

Je suis un Javaler, alors j'ai commencé à jouer avec Python, alors prenez note. Vraiment juste une note.

Environnement de développement

Vous pouvez créer un environnement de développement avec Eclipse. Il y a Pléiades Tout-en-un pour Python, alors laissez tomber.

Création de projet

Vous pouvez le créer en faisant un clic droit sur Package Explorer → "Nouveau" → "Projet" → "Projet Pydev".

Opération Eclipse

paquet

Il semble que Python ait également le concept de package. Vous pouvez le créer en faisant un clic droit sur Package Explorer → "Nouveau" → "Pydev Package".

fichier py

Les fichiers source Python sont des fichiers avec l'extension py Vous pouvez le créer en faisant un clic droit sur Package Explorer → "Nouveau" → "Pydev Module". Vous pouvez sélectionner un modèle de classe ou principal (exécution).

Courir

Faites un clic droit sur le fichier py avec la méthode principale (?) → "Exécuter" → "Exécuter Python"

Syntaxe Python

Principale

La chose semblable à publoc void main (String ... args) en java est décrite comme suit

if __name__ == '__main__':
    print("I am a beginner")

«Je suis un débutant» apparaît sur la console

Préparé en sélectionnant le modèle "principal" lors de la création d'un module Pydev depuis Eclipse

Retrait

Python définit des blocs avec indentation.

if __name__ == '__main__':
    print("1")
    if True:
        print("2") #Dans si
        print("3") #Dans si
    else:
        print("4") #Dans d'autre
        print("5") #Dans d'autre
    print("6") #Sortez du bloc

Est sortie comme 1, 2, 3, 6

variable

La substitution est la même que la déclaration de variable.

i = 1
s = "Chaîne"
b = True

Expression conditionnelle

Opérateur logique

Utilisez ʻand, ʻor, not

Jugement spécial

Si aucun

Si un objet est utilisé dans une expression conditionnelle, il sera traité comme "faux" lorsqu'il vaut Aucun.

o = None
if not o:
    print("o est Aucun")

Aucun n'est nul en Python (comme)

Si la chaîne est vide

Si une chaîne de caractères est utilisée dans une expression conditionnelle, elle sera traitée comme "fausse" lorsqu'elle est vide.

s = ""
if not s:
    print("s est vide")

Que ce soit 0

Lorsqu'une valeur numérique est utilisée dans une expression conditionnelle, elle est traitée comme "fausse" lorsqu'elle est égale à 0.

i = 0
if not i:
    print("je vaut 0")

Si le tableau est vide

Si un tableau (etc.) est utilisé dans une expression conditionnelle, il sera traité comme "faux" lorsqu'il est vide.

a = []
if not a:
    print("a est vide")

si boucle

if J'ai déjà écrit une partie de l'instruction if, mais écrivez-la comme suit

si condition 1:
    print("La condition 1 est vraie")
condition elif 2:
    print("La condition 1 est fausse")
    print("La condition 2 est vraie")
else:
    print("La condition 1 est fausse")
    print("La condition 2 est fausse")

ʻElse if est écrit comme ʻelse if.

for L'instruction for est décrite comme suit.

for i in range(10):
    print(i) #0 à 9 sont émis dans l'ordre

for i in range(3, 7):
    print(i) #3 à 6 sont émis dans l'ordre

for i in range(1, 12, 2):
    print(i) # 1,3,5,7,9,11 est sorti dans l'ordre

for s in ["A", "B", "C"]:
    print(s) #A, B et C sont émis dans l'ordre

Une instruction Python for est comme une extension Java for statement. Il semble que pour les instructions par index, les conditions d'échappement, les incréments, etc. se font bien en utilisant range.

while L'instruction while fonctionne si vous l'écrivez dans la même atmosphère qu'avant. C'est tellement normal que je n'écrirai pas d'exemple. Pour une raison quelconque, il existe une syntaxe appelée while ... else, mais je ne sais pas comment l'utiliser. .. ..

switch-case Il semble que cela n'existe pas.

Opérateur triangulaire

Il est expliqué comme "expression conditionnelle" et "opérateur conditionnel" au lieu du nom de l'opérateur ternaire.

http://docs.python.jp/3.5/reference/expressions.html#conditional-expressions

for i in range(10):
    a = "odd number" if i % 2 else "even number" #Celle appelée "expression conditionnelle"
    print(str(i) + " is an " + a)

Tableau / Itérateur

list Créer une instance avec javascript glue

items1 = []
items2 = ["A", "B"]

Ajouter ou retirer

items = ["A", "B"]
items.append("C") #Liste Java#add
items.extend(["D", "E", "F"]) #Liste Java#addAll
del items[4] #Liste Java#remove(int)
items.remove("F") #Liste Java#remove(Object)

size = len(items) #Liste Java#size
print("size:" + str(size)) # 4
index2 = items[2] #Liste Java#get
print("index2:" + index2) # C

idx = items.index(index2) #Liste Java#indexOf
print("idx:" + str(idx)) # 2

for item in items:
    print(item) # A,B,C,Sortie D dans l'ordre

items2 = items[:] #Créer une instance de liste copiée
print(items2) # ['A', 'B', 'C', 'D'](Contientlesmêmesélémentsqueleséléments)
print(items is items2) #False (une autre instance)

items.insert(0, "INS") #Liste Java#add(int, Object)
print(items) # ['INS', 'A', 'B', 'C', 'D']

Qu'est-ce que «[:]»?

items3 = items[1:3] #Génération de liste qui extrait les index 1 à 2
print(items3) # ['B', 'C']

items4 = items[1:] #Génération de liste qui extrait tout le dos de l'index 1
print(items4) # ['B', 'C', 'D']

items5 = items[:3] #Génération de liste qui extrait tout avant l'index 3
print(items5) # ['A', 'B', 'C']

Itérateur

Il existe un concept appelé iterable "iterable". Similaire à la classe Iterable de Java. "Iterable" peut être tourné avec l'instruction [for] de Python (http://docs.python.jp/3/reference/compound_stmts.html#for). La liste est également "itérable", et la chaîne Python (str) est également "itérable". Il semble que vous puissiez créer le vôtre, mais cette fois, il est omis.

ensemble de tuple ・ dict ・

Il y a aussi.

t = ("A") # tuple
print(type(t))

d = {"A" : 1} # dict
print(type(d))

s = {"A"} # set
print(type(s))

Je n'ai pas enquêté sur les détails. Référence ci-dessous http://www.tohoho-web.com/python/list.html

Chaîne

De base

Il peut être exprimé entre guillemets simples ou doubles.

s1 = "I am a beginner"
s2 = 'I am a beginner'

Je ne sais pas lequel est le plus courant, mais le sentiment que je recherche est celui des guillemets?

Il existe également une technique de trois citations.

s = """Python et
Oh python
Python et"""

print(s)

résultat

Python et
Oh python
Python et

Concaténation de chaînes

Utilisez «+». Il n'y a pas de distribution implicite, utilisez donc ce qui suit.

Cast en chaîne

Utilisez str.

i = 10

print("Valeur numérique en chaîne de caractères" + str(i))
print("Concaténer des chaînes et des nombres" + i) #Erreur

Stringification de la classe autodidacte

Si vous créez une méthode appelée «str», elle sera appelée lorsqu'elle sera convertie en chaîne. L'atmosphère du rôle de la méthode toString en Java, où «str» est (ne peut pas être appelé directement).

Méthode

Écrivez def pour définir.

#Méthode définie par def
def method1():
    print("foo")

#Les arguments sont écrits entre parenthèses
def method2(arg1, arg2):
    print(arg1)
    print(arg2)

#La valeur de retour est retournée par return
def method3():
    return "bar"

argument

Comment faire passer divers arguments

Si vous n'êtes pas particulier à ce sujet, vous pouvez le passer normalement, mais il y a aussi une étrange façon de passer (pas en Java).

def method2(arg1, arg2):
    print("---")
    print(arg1)
    print(arg2)

if __name__ == '__main__':
    method2("A", "B") #Habituel
    method2(arg1="A", arg2="B") #Vous pouvez également le transmettre comme ceci (argument de mot-clé)
    method2(arg2="B", arg1="A") #Dans ce cas, il semble que l'ordre puisse être aléatoire

    method2(*["A", "B"]) #Passer dans un tableau
    method2(**{"arg2":"B", "arg1":"A"}) #Passer par dict

Les résultats sont tous les mêmes

Argument par défaut

Quelque chose comme C ++.

#La valeur par défaut peut être définie pour l'argument Lors de l'appel, s'il y a un argument, arg2"DefaultArg"Entrer
def method4(arg1, arg2 = "DefaultArg"):
    print("---")
    print(arg1)
    print(arg2)

if __name__ == '__main__':
    method4("A", "B")
    method4("A") #Utiliser la valeur par défaut pour le deuxième argument

résultat

---
A
B
---
A
DefaultArg

En supposant que le dict passe, il semble que le premier argument puisse également être l'argument par défaut, mais cela semble impossible

def method5(arg1 = "DefaultArg", arg2):
   print(arg1)
   print(arg2)

Erreur de syntaxe

Argument de longueur variable

Il existe une méthode d'acceptation avec le type tuple et une méthode d'acceptation avec le type dict

Pour le type tuple

# *Est un argument de longueur variable que le type tuple accepte
def method_variadic_tuple(arg1, *others): #other est un argument de longueur variable de type tuple
    print("---" )
    print("Premier argument:" + arg1)
    print("Argument de longueur variable:" + str(others))
    print("Longueur variable Longueur d'argument:" + str(len(others)))

if __name__ == '__main__':
    method_variadic_tuple("A")
    method_variadic_tuple("A", "B")
    method_variadic_tuple("A", "B", "C")
    method_variadic_tuple("A", *("B", "C")) #Il est également possible de le passer directement avec tuple
    method_variadic_tuple("A", *["B", "C"]) #la liste est également OK
    method_variadic_tuple(*("A", "B", "C")) #Tous les tuples peuvent être remis

résultat

---
Premier argument:A
Argument de longueur variable:()
Longueur variable Longueur d'argument:0
---
Premier argument:A
Argument de longueur variable:('B',)
Longueur variable Longueur d'argument:1
---
Premier argument:A
Argument de longueur variable:('B', 'C')
Longueur variable Longueur d'argument:2
---
Premier argument:A
Argument de longueur variable:('B', 'C')
Longueur variable Longueur d'argument:2
---
Premier argument:A
Argument de longueur variable:('B', 'C')
Longueur variable Longueur d'argument:2
---
Premier argument:A
Argument de longueur variable:('B', 'C')
Longueur variable Longueur d'argument:2

Pour le type dict

# **Est un argument de longueur variable accepté comme type de dict
def method_variadic_dict(arg1, **others):  #other est un argument de longueur variable de type dict
    print("---" )
    print("Premier argument:" + arg1)
    print("Argument de longueur variable:" + str(others))
    print("Longueur variable Longueur d'argument:" + str(len(others)))

if __name__ == '__main__':
    method_variadic_dict("A")
    method_variadic_dict("A", d1="B") #argument de longueur variable dict passé comme ceci
    method_variadic_dict("A", d1="B", d2="C")
    method_variadic_dict(arg1="A", d1="B", d2="C") #Si vous utilisez le type dict, également le premier argument=La notation utilisée est plus propre
    method_variadic_dict(d1="B", arg1="A", d2="C") #Dans ce cas, le premier argument est OK même au milieu
    method_variadic_dict("A", **{"d1":"B", "d2":"C"}) #Il est également possible de passer directement avec dict
    method_variadic_dict(**{"arg1":"A" , "d1":"B", "d2":"C"}) #Le premier argument peut également être dict.
    # method_variadic_dict(*["A", {"d1":"B", "d2":"C"}]) #Est-il vraiment impossible de passer un tableau?

résultat

---
Premier argument:A
Argument de longueur variable:{}
Longueur variable Longueur d'argument:0
---
Premier argument:A
Argument de longueur variable:{'d1': 'B'}
Longueur variable Longueur d'argument:1
---
Premier argument:A
Argument de longueur variable:{'d1': 'B', 'd2': 'C'}
Longueur variable Longueur d'argument:2
---
Premier argument:A
Argument de longueur variable:{'d1': 'B', 'd2': 'C'}
Longueur variable Longueur d'argument:2
---
Premier argument:A
Argument de longueur variable:{'d1': 'B', 'd2': 'C'}
Longueur variable Longueur d'argument:2
---
Premier argument:A
Argument de longueur variable:{'d1': 'B', 'd2': 'C'}
Longueur variable Longueur d'argument:2
---
Premier argument:A
Argument de longueur variable:{'d1': 'B', 'd2': 'C'}
Longueur variable Longueur d'argument:2

classe

Définition

Déclarez nom de classe de classe (source d'héritage).

Si vous utilisez le modèle Eclipse, il s'écrira comme suit.

class MyClass(object):
    '''
    classdocs
    '''


    def __init__(self, params):
        '''
        Constructor
        '''

__init__ Comme vous pouvez déjà le voir dans le commentaire (docstring), le constructeur est défini en écrivant __init__. L'argument «self» est votre propre instance, et écrivez les paramètres que vous voulez accepter dans le constructeur après.

Génération d'instance

if __name__ == '__main__':
    obj = MyClass("param") #argument"param"Générez MyClass avec et attribuez-le à obj

Variables / méthodes de champ d'instance

Si la variable de champ provient de l'intérieur de l'instance, vous pouvez créer une variable en lui assignant self.field name. De l'extérieur, attribuez-les normalement avec variable qui stocke le nom de l'instance.field.

La méthode est indentée en fonction de la classe et définie avec def. Le premier argument (similaire à «init») est «self». Lorsque vous appelez de l'extérieur, donnez un argument sans «self» et appelez.

class MyClass(object):
    def __init__(self, param):
        self.field1 = "field1" # self.Si vous l'assignez à un nom de champ, il devient une variable de champ.
        print("init param:" + param)

    def foo(self, param): #Méthode d'instance
        self.field2 = "field2" #Les variables de champ peuvent être créées à tout moment
        print("foo param:" + param)

if __name__ == '__main__':
    obj = MyClass("A")
    print(obj.field1)
    obj.foo("B")
    print(obj.field2)
    obj.field3 = "field3" #Vous pouvez créer des variables de champ de l'extérieur
    print(obj.field3)

résultat

init param:A
field1
foo param:B
field2
field3

portée

Exprimez en nommant.

référence: http://docs.python.jp/3.5/reference/lexical_analysis.html#reserved-classes-of-identifiers http://docs.python.jp/3.5/tutorial/classes.html#tut-private

Si vous ajoutez deux traits de soulignement au début, ce sera privé. (Strictement parlant, il existe un moyen d'y accéder, il ne peut donc pas être appelé privé.) Cependant, les noms avec deux traits de soulignement derrière eux, tels que __hoge__, sont pour les systèmes Python, alors ne leur en donnez pas un nouveau.

De plus, par habitude, un trait de soulignement semble être non public.

class MyClass(object):

    def foo(self): # public
        print("foo" )

    def _foo(self): #Non public comme habitude
        print("_foo" )

    def __foo(self): # private
        print("__foo" )

    def call_private_foo(self): # __Méthode pour appeler foo
        self.__foo() #Les méthodes privées peuvent être appelées

if __name__ == '__main__':
    obj = MyClass()
    obj.foo()
    obj._foo()
    # obj.__foo() #Ne peut pas être appelé
    obj.call_private_foo()
    obj._MyClass__foo() #À proprement parler, il existe un moyen d'y accéder. "_Il a été remplacé par "nom de classe + nom de méthode". Cependant, il n'apparaît pas dans le stockage d'Eclipse

résultat

foo
_foo
__foo
__foo

Héritage

Si vous modifiez la partie écrite comme (objet) dans la classe dont vous voulez hériter, vous pouvez en hériter pour le moment.

Il semble que l'héritage multiple soit possible, mais je n'ai pas l'impression de pouvoir le maîtriser en tant que débutant, je vais donc l'omettre cette fois.

Appeler une méthode de la classe parent

Le constructeur de la classe parent n'est pas appelé simplement en l'héritant. Appelez-le en écrivant super (propre classe, self). Nom de la méthode () comme indiqué ci-dessous.

class AbsMyClass(object):
    def __init__(self):
        print("AbsMyClass__init__A été appelé")


class MyClass(AbsMyClass):
    def __init__(self):
        super(MyClass, self).__init__() #Source d'héritage__init__Appel
        print("MyClass__init__A été appelé")

if __name__ == '__main__':
    obj = MyClass()

résultat

AbsMyClass__init__A été appelé
MyClass__init__A été appelé

Vous pouvez éviter d'appeler la classe parente __init__, le timing est arbitraire, vous pouvez l'appeler autant de fois que vous le souhaitez et il n'y a pas de liberté. Je suis nouveau sur Python, donc j'oublie souvent d'écrire et j'y suis accro.

importer

Eclipse complète et écrit. La syntaxe est omise.

J'ai écrit Python Beginner's Memo (Part 2).