Résumé des méthodes et techniques courantes en Python

Cet article présente principalement quelques méthodes et techniques Python courantes dans la collection. Cet article explique trois méthodes d'inversion de chaîne , quatre méthodes de parcours d'un dictionnaire, trois méthodes de parcours d'une liste et un dictionnaire. Méthodes de tri et autres conseils et méthodes Python courants, les amis dans le besoin peuvent se référer à

1. Trois méthodes d'inversion de chaînes
1.1 . C++ et définissez une chaîne vide à implémenter en définissant une chaîne vide, puis parcourez les chaînes dans les paramètres de l'arrière vers l'avant et utilisez l'ajout de chaînes pour les fusionner dans de nouvelles chaînes

def reverse(text) :
    str = ''
    index = len(text) - 1
    while index >= 0 :
        str += text[index]
        index -= 1
    return str

1.2. Utilisation de la méthode de découpage Il s'agit d'une fonctionnalité de Python qui peut prendre des valeurs négatives. Il s'agit de la méthode de découpage définie sur -1, obtenant ainsi l'inverse. tri.

def reverse_1(text) :
    return text[::-1]

1.3. Utiliser une liste

def reverse_2(text) :
    temp = list(text)
    temp.reverse()
    return ''.join(temp)

2. Utilisez réduireUtilisez
fonction anonyme et réduisez()

def reverse_3(text) :
    return reduce(lambda x, y : y + x, text)
print reverse_3("Hello")

3. Quatre méthodes de dictionnaire

dict={"a":"apple","b":"banana","o":"orange"} 
 
print "##########dict######################" 
for i in dict: 
        print "dict[%s]=" % i,dict[i] 
 
print "###########items#####################" 
for (k,v) in  dict.items(): 
        print "dict[%s]=" % k,v 
 
print "###########iteritems#################" 
for k,v in dict.iteritems(): 
        print "dict[%s]=" % k,v 
 
print "###########iterkeys,itervalues#######" 
for k,v in zip(dict.iterkeys(),dict.itervalues()): 
        print "dict[%s]=" % k,v

4. Trois méthodes de parcours de liste

for key in lst :
    print key
    
for i in range(len(lst)) :
    print lst[i]
for index, key in enumerate(lst) :
    print key    //index是list的索引

5 . méthode de tri Le dictionnaire est trié par ordre de valeur de grand à petit (la valeur par défaut est triée de petit à petit).

dic = {'a':31, 'bc':5, 'c':3, 'asd':4, 'aa':74, 'd':0}
dict= sorted(dic.iteritems(), key=lambda d:d[1], reverse = True)
print dict
//输出的结果：
[('aa', 74), ('a', 31), ('bc', 5), ('asd', 4), ('c', 3), ('d', 0)]

imprimons dic.iteritems() pour obtenir une liste de [(clé, valeur)].
Utilisez ensuite la méthode sorted, en passant le paramètre key, pour spécifier que le tri est basé sur la valeur, c'est-à-dire la valeur du premier élément d[1. reverse = True signifie qu'il doit être inversé. La valeur par défaut est de petit à grand. S'il est inversé, ce sera de grand à petit.
Trier le dictionnaire par clé :

dic = {'a':31, 'bc':5, 'c':3, 'asd':4, 'aa':74, 'd':0}
dict= sorted(dic.iteritems(), key=lambda d:d[0]) # d[0]表示字典的键
print dict
#sorted中第三个可选参数为reverse, True表示从大到小排序
#默认reverse = False

6. Sous-classe et classe parent Sous-classe
Constructeur appelle le constructeur d'initialisation de la classe parent

class A(object) :
    def init(self) :
        print  "testA
class B(A) :
    def init(self) :
        A.init(self)

La sous-classe appelle la fonction du même nom de la classe parent

super().fuleifunction()

7. Une méthode de passage de paramètres plus flexible< 🎜. >

func2(a=1, b=2, c=3) #默认参数
func3(*args)         #接受任意数量的参数, 以tuple的方式传入
func4(**kargs)       #把参数以键值对字典的形式传入

et attribués aux paramètres formels. Au sein de la fonction, lorsque vous devez traiter des paramètres, il vous suffit d'opérer sur les paramètres formels de ce type de tuple (ici, args). Par conséquent, la fonction n'a pas besoin de spécifier le nombre de paramètres lors de sa définition et peut gérer n'importe quel nombre de paramètres.

def calcSum(*args):
    sum = 0
    for i in args:
        sum += i
        print sum
#调用：
calcSum(1,2,3)
calcSum(123,456)
calcSum()
#输出：
6
579
0
#################################
def printAll(**kargs):
    for k in kargs:
    print k, ':', kargs[k]
printAll(a=1, b=2, c=3)
printAll(x=4, y=5)
#输出：
a : 1
c : 3
b : 2
y : 5
x : 4

1. Les paramètres formels avec des valeurs par défaut (arg=) doivent être après le paramètre formel (arg=) sans valeur par défaut

. 3. Les paramètres du dictionnaire (**kargs) doivent venir après les paramètres du tuple (*args)

Lorsque la fonction est appelée, le processus de transmission des paramètres est :

Attribuer les paramètres réels sans spécification. paramètres dans l'ordre Donnez les paramètres formels

3 Regroupez les paramètres réels supplémentaires sans paramètres spécifiés dans un tuple et transmettez-le à. le paramètre de tuple ( *args)
4. Emballez les paramètres réels supplémentaires avec les noms de paramètres spécifiés dans un dict et transmettez-le au paramètre de dictionnaire (**kargs)

8. 🎜>

Format grammatical de l'expression lambda : Liste des paramètres lambda : expression #Il n'y a pas de parenthèses autour de la liste des paramètres, il n'y a pas de mot-clé return avant la valeur de retour , et il n'y a pas de nom de fonction

Analyse
 : Après l'appel de fn(2), cela équivaut à a = lambda y : 2 + y, et puis quand a(3) est appelé.

def fn(x):
    return lambda y: x + y
#调用
a = fn(2)
print a(3)
#输出
5

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!