Notes depuis 3 mois depuis que j'ai commencé Python

Une note de bonnes techniques à connaître comme pierre d'achoppement du débutant

Opérateur triangulaire

Formule: (variable) = (valeur lorsque la condition est vraie) if (condition) else (valeur lorsque la condition est fausse)

score = 100
result = "good" if score > 80 else "bad"
print(result) # good

else

Il semble que le moment où le traitement de la boucle est terminé peut être pris

`while`


i = 0
while i < 3:
    print(i)
    i += 1
else:
    print("while, end")

`for`


for i in range(3):
    print(i)
else:
    print("for, end")

pass

ne fais rien. À utiliser lorsque vous souhaitez décider approximativement uniquement du cadre extérieur

def say_hello():
    pass
print(say_hello()) # None

Référence Comment utiliser l'instruction de passe Python

format

Plus intelligent si vous pouvez l'utiliser lorsque plusieurs lancers tels que str (1) continuent

text = 'name -> {0:>10s}\nscore -> {1:<10.2f}'.format('sato',30.2)
# name ->Largeur d'affichage:10, s:string, >:Justifié à droite
# score ->Largeur d'affichage:10,2 chiffres après la virgule décimale, f:float, >:Justifié à gauche
print(text)
# name ->       sato
# score -> 30.20

↓ Ceci est également pratique

`Remplissez avec des zéros en spécifiant le nombre de chiffres`


print('{:05}'.format(255)) # 00255
print('{:08}'.format(255)) # 00000255

portée

Gestion des variables globales au sein d'une fonction

`Erreur si vous ne déclarez pas global lors de l'affectation`


x = 5 
def add():
    global x #Ne peut être réécrit sans déclaration
    x += 1
add() 
print(x)

`Vous n'avez pas besoin d'une déclaration globale si vous voulez simplement vous y référer ...`


#Il est plus facile de comprendre si vous déclarez global simplement en vous y référant
x = 5 
def print_x():
    print(x)
print_x()

Cependant, pour éviter les effets secondaires, il est préférable de ne pas accéder autant que possible aux variables globales à partir de la fonction.

`Bonne forme à passer en argument`


x = 5 
def add(x):
    x += 1
    return x
x = add(x) 
print(x)

liste

`Liste des pièges`


x = ["a", "b", "c"]
y = x.append("d")
print(x) # ['a', 'b', 'c', 'd']Les variables sont remplacées
print(y) #Aucun Le retour est Aucun

`Pour les cordes`


x = "abcdef"
y = x.upper()
print(x) #variable abcdef telle quelle
print(y) #ABCDEF renvoie une chaîne

Type d'objet	Variables après l'exécution de la méthode	Ce que la méthode renvoie
Chaîne	Variable comme il est	Chaîne
liste	Les variables sont remplacées	None

Notation d'inclusion de liste

Se limiter à ceux qui correspondent aux conditions | si

Image qui peut traiter la carte et filtrer en même temps Si l'instruction if vaut True, la liste sera créée.

`Extraire les noms contenant e et les réduire`


users = ["Yo", "Ken", "Nao", "Shin", "Lee"]
users = [u.lower() for u in users if u.find("e") != -1]
print(users) # ['ken', 'lee']

Boucle plusieurs listes en même temps | zip

`Démontez "Aiueo ..." et restaurez-le`


str_ = list('Aiue Okakikuke Kosashi Suseso')
a = str_[::2] #La deuxième chose qui est sortie du début à la fin=Le numéro d'index est pair (y compris 0)
b = str_[1::2] #Le second de 1 à la fin=Le numéro d'index est impair
print(a) # ['Ah', 'U', 'Oh', 'Ki', 'Ke', 'Sa', 'Su', 'Alors']
print(b) # ['je', 'e', 'Ou', 'Ku', 'Cette', 'Shi', 'Ensemble']
#Chaîne de délimitation.join(séquence)
moto = "".join([ _a + _b for _a,_b in zip(a,b) ])
print(moto) #Aiue Okakikuke Kosashi

https://docs.python.jp/3/library/functions.html#zip

Ensemble / Dictionnaire

set => Pas de doublons, pas de commande, recherche par hachage

dictionary => Valeur ajoutée à l'utilisation du hachage dans l'ensemble

s = {1,2,3,4,5}
print(type(s)) # <class 'set'>

d = {} #Notez que s'il est vide, ce sera un dictionnaire.
print(type(d)) # <class 'dict'>

Arithmétique mathématique de l'ensemble

colors1 = {"white","black","red","green"}
colors2 = {"white","black","yellow"}
#Définir la différence
print(colors1 - colors2) # {'green', 'red'}
#S'il est inclus dans l'ensemble
print("blue" in colors2) # False
#Somme collective
colors3 = colors1 | colors2
print(colors3) # {'white', 'green', 'red', 'black', 'yellow'}
#partie commune
colors4 = colors1 & colors2
print(colors4) # {'black', 'white'}

Argument de longueur variable et argument de mot-clé

Taple et type de dictionnaire

La description	Type de réception
*	Taple
**	Sorte de dictionnaire

#Gardez l'ordre des arguments de longueur variable et des arguments de mot-clé
def print_args_kwargs(*args, **kwargs):
    print(args) # (1, 2, 3)
    print(kwargs) # {'age': 25, 'name': 'sato'}
print_args_kwargs(1,2,3, age=25, name='sato')

Dictionnaire des arguments de mots clés

`Passez l'argument en tant que dictionnaire`


def say_hello(name, age):
    print(name, age) # sato 25
user = {'name':'sato', 'age':25}
say_hello(**user) # **Sorte de dictionnaire

Référence Introduction à Python (Extra 1): * arg et ** kwarg

classe

self

Fait référence à une instance créée à partir d'une classe. Le premier argument d'une méthode d'instance de classe ou d'un constructeur. C'est facile à oublier. La variable associée à self est appelée "variable d'instance" et la méthode est appelée "méthode d'instance".

Variables de classe (constantes) et méthodes

Les variables associées à la classe sont appelées "variables de classe" et les méthodes sont appelées "méthodes de classe".

class Player:
    #Variable de classe
    count = 0
    #Constante de classe (supérieure)
    GUILD = "KoB"
    def __init__(self):
        Player.count += 1
    #Méthode de classe
    @classmethod 
    def show_count(cls):
        #Parce que je ne me suis pas reçu
        #Les variables / méthodes d'instance ne peuvent pas être utilisées
        print("{} instances".format(cls.count))
        
    #Méthode statique
    #Quelque chose comme une méthode de classe sans premier argument
    #Peut être appelé sans instanciation
    @staticmethod
    def show_guild():
        print(Player.GUILD)

player01 = Player()
player02 = Player()
player03 = Player()

#Peut être appelé sans instanciation
print(Player.count) # 3
Player.show_count() # 3 instances

#S'il n'y a pas de variable d'instance portant le même nom, vous pouvez également appeler la variable de classe à partir de l'instance.
print(player01.count) # 3

Player.show_guild() # KoB

Gestion des données avec des constantes de classe

↓ Il est pratique de gérer des données comme celle-ci

`Gérer les couleurs avec des constantes`


class Color:
    MAIN = '#f00'
    SUB = '#00f'
    FONT = '#fff'
print(Color.MAIN) # #f00

Variables / méthodes privées

Deux traits de soulignement "__" le rendent inaccessible de l'extérieur Un trait de soulignement "_" n'est que la forme

class Player:
    def __init__(self):
        self.name = 'sato'
    def __method(self):
        print(self.name)

player01 = Player()
player01.__method() # error

Les méthodes et les variables privées ne sont que des "dénominations", donc si vous voulez les appeler de force, vous pouvez le faire, mais ne le faites pas.

Setter Setter

Utilisé par exemple des variables qui doivent être manipulées en externe

getter

`officiel`


class ClassName:
    @property
    def getterName(self):
        return value

class Clock:
    def __init__(self, hour):
        self._hour = hour

    @property
    def hour(self):
        return self._hour

clock = Clock(10)
print(clock.hour) #Vous pouvez accéder à la méthode comme une variable
clock.hour = 12 #La valeur ne peut pas être modifiée AttributeError: can't set attribute

setter

`officiel`


class ClassName:
    @getterName.setter
    def getterName(self, value):

class Clock:
    def __init__(self, hour):
        self._hour = hour

    @property
    def hour(self):
        return self._hour
    
    @hour.setter
    def hour(self, value):
        self._hour = value

clock = Clock(10)
clock.hour # 10
clock.hour = 6 #Maintenant accessible
clock.hour # 6

Style Lambda

argument lambda: expression Renvoie la fonction en tant qu'objet Il est judicieux de l'utiliser lorsque vous pouvez le faire avec une fonction anonyme au lieu de créer une fonction à chaque fois en passant une fonction

lambda_test = lambda x, y : print('lambda_test : {}, {}'.format(x, y)) # function <lambda>
lambda_test('hello', 'lambda') # lambda_test : hello, lambda

map

map(function, iterable) Adapter la fonction du premier argument à la liste (taple) du second argument et renvoyer le résultat

map_obj = map(lambda x : x * 2, range(10))
print(list(map_obj)) # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

filter

filter(function, iterable) Appliquez la fonction du premier argument à la liste (taple) du deuxième argument et collectez l'élément True.

filter_obj = filter(lambda x : x % 2 == 0, range(10))
print(list(filter_obj)) # [0, 2, 4, 6, 8]

Décorateur

Ajouter un traitement arbitraire avant et après la fonction

import time

def time_log(func):
    def wrapper(*args,**kwargs):
        
        import datetime
        start = datetime.datetime.today()
        print("--- start", func.__name__)
        
        #Exécution de la fonction
        func(*args, **kwargs)
        
        end = datetime.datetime.today()
        delta = end - start
        print("--- end", func.__name__, delta, "sec")
    
    return wrapper #Renvoie un objet fonction

#Ajouter un traitement en décrivant le nom du décorateur
@time_log 
def test1():
    print("sleep 1sec")
    time.sleep(1)
    
@time_log
def test2():
    print("sleep 2sec")
    time.sleep(2)
    
test1()
test2()

Référence http://dotinstall.com/lessons/basic_python_v3 http://www.yoheim.net/