Liste des fonctions avancées en python

Cet article présente principalement en détail les fonctions avancées de list en python. Les amis intéressés peuvent s'y référer

utiliser une liste comme une pile : #Like Utiliser une liste comme une pile.

stack = [3, 4, 5] 
stack.append(6) 
stack.append(7) 
stack 
[3, 4, 5, 6, 7] 
stack.pop() #删除最后一个对象 
7 
stack 
[3, 4, 5, 6] 
stack.pop() 
6 
stack.pop() 
5 
stack 
[3, 4]

utiliser une liste comme file d'attente : #Utiliser une liste comme une file d'attente

> from collections import deque #这里需要使用模块deque 
> queue = deque(["Eric", "John", "Michael"])
> queue.append("Terry")      # Terry arrives
> queue.append("Graham")     # Graham arrives
> queue.popleft()         # The first to arrive now leaves
'Eric'
> queue.popleft()         # The second to arrive now leaves
'John'
> queue              # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])

trois fonctions intégrées : Trois fonctions intégrées importantes

filter(), map() et réduire()
1), filtre(fonction, séquence) : :
Filtrer les données dans le. lister la séquence selon les règles de la fonction function

> def f(x): return x % 3 == 0 or x % 5 == 0
... #f函数为定义整数对象x,x性质为是3或5的倍数
> filter(f, range(2, 25)) #筛选
[3, 5, 6, 9, 10, 12, 15, 18, 20, 21, 24]

2), map(function, séquence) :
La fonction map est implémentée selon pour fonctionner Les règles de la fonction font la même chose pour les séquences de listes
Ici la séquence ne se limite pas aux listes, les tuples peuvent également être utilisés.

> def cube(x): return x*x*x #这里是立方计算 还可以使用 x**3的方法
...
> map(cube, range(1, 11)) #对列表的每个对象进行立方计算
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]

Remarque : La liste des paramètres ici n'est pas fixe. Elle dépend principalement du nombre de paramètres de la fonction personnalisée qui peut être transformée. into : def func(x,y) map(func, séquence1, séquence2) Exemple :

 seq = range(8)  #定义一个列表
> def add(x, y): return x+y #自定义函数，有两个形参
...
> map(add, seq, seq) #使用map函数，后两个参数为函数add对应的操作数，如果列表长度不一致会出现错误
[0, 2, 4, 6, 8, 10, 12, 14]

3), réduire(fonction, séquence) :
La fonction de la fonction de réduction est d'opérer les données dans la séquence selon la fonction, par exemple effectuer une opération de fonction sur le premier nombre et le deuxième nombre de la liste, et d'effectuer une opération de fonction sur le résultat et les données suivantes dans la liste, et la boucle continue...
Exemples :

def add(x,y): return x+y
...
reduce(add, range(1, 11))
55

Compréhensions de listes :
Ici, nous présenterons plusieurs applications des listes :
squares = [x**2 for x in range(10)]
#Générer une liste, qui est le résultat du calcul au carré de la liste générée par la plage de liste (10).
[(x, y) pour x dans [1,2,3] pour y dans [3,1,4] si x != y]
#[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)] Voici une liste générée , chaque élément de la liste est un tuple, chaque tuple est composé de x et y, x est fourni par la liste [1,2,3], y vient de [3,1,4], et satisfait la règle x = ! y.

Compréhensions de listes imbriquées :
C'est difficile à traduire ici, alors donnons un exemple :

matrix = [          #此处定义一个矩阵
...   [1, 2, 3, 4],
...   [5, 6, 7, 8],
...   [9, 10, 11, 12],
... ]
[[row[i] for row in matrix] for i in range(4)]
#[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

Deux niveaux d'imbrication ici sont gênants. Expliquons brièvement : pour la matrice matrice, for row in matrice est utilisé pour extraire chaque ligne de la matrice. row[i] est utilisé pour extraire le i-ème (indice). dans chaque ligne list et générer une list , puis i vient de for i in range(4), générant ainsi une liste de listes.

L'instruction del :
Supprimez les données spécifiées dans la liste, par exemple :

> a = [-1, 1, 66.25, 333, 333, 1234.5]
>del a[0] #删除下标为0的元素
>a
[1, 66.25, 333, 333, 1234.5]
>del a[2:4] #从列表中删除下标为2，3的元素
>a
[1, 66.25, 1234.5]
>del a[:] #全部删除 效果同 del a
>a
[]

Ensembles : Ensembles

> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> fruit = set(basket)        # create a set without duplicates
>>> fruit
set(['orange', 'pear', 'apple', 'banana'])
>>> 'orange' in fruit         # fast membership testing
True
>>> 'crabgrass' in fruit
False

>>> # Demonstrate set operations on unique letters from two words
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                 # unique letters in a
set(['a', 'r', 'b', 'c', 'd'])
>>> a - b               # letters in a but not in b
set(['r', 'd', 'b'])
>>> a | b               # letters in either a or b
set(['a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'])
>>> a & b               # letters in both a and b
set(['a', 'c'])
>>> a ^ b               # letters in a or b but not both
set(['r', 'd', 'b', 'm', 'z', 'l'])

Dictionnaires : Dictionnaires

>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127 #相当于向字典中添加数据
>>> tel
{'sape': 4139, 'guido': 4127, 'jack': 4098}
>>> tel['jack'] #取数据
4098
>>> del tel['sape'] #删除数据
>>> tel['irv'] = 4127   #修改数据
>>> tel
{'guido': 4127, 'irv': 4127, 'jack': 4098}
>>> tel.keys()    #取字典的所有key值
['guido', 'irv', 'jack']
>>> 'guido' in tel #判断元素的key是否在字典中
True
>>> tel.get('irv') #取数据
4127

Vous pouvez également utiliser des règles pour générer un dictionnaire :

>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}

enumerate() : Parcourir les éléments et les indices La fonction
enumerate est utilisée pour parcourir les éléments de la séquence et leurs indices :

>>> for i, v in enumerate(['tic', 'tac', 'toe']):
...   print i, v
...
0 tic
1 tac
2 toe

zip() :
zip() est une fonction intégrée de Python. Elle accepte une série d'objets itérables comme paramètres, regroupe les éléments correspondants dans les objets dans des tuples, puis renvoie une liste composée de ceux-ci. tuples. Si les longueurs des paramètres transmis ne sont pas égales, la longueur de la liste renvoyée sera la même que celle de l'objet ayant la longueur la plus courte parmi les paramètres. À l'aide de l'opérateur *, vous pouvez décompresser (décompresser) la liste.

>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
...   print 'What is your {0}? It is {1}.'.format(q, a)
...
What is your name? It is lancelot.
What is your quest? It is the holy grail.
What is your favorite color? It is blue.

Un exemple simple concernant le zip :

>>> a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)
[(1, 4), (2, 5), (3, 6)]
>>> zip(a,c)
[(1, 4), (2, 5), (3, 6)]
>>> zip(*zipped)
[(1, 2, 3), (4, 5, 6)]

reversed() : inversé

>>> for i in reversed(xrange(1,10,2)):
...   print i
...

sorted() : trié

> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
> for f in sorted(set(basket)):       #这里使用了set函数
...   print f
...
apple
banana
orange
pear

L'ensemble de Python est similaire à d'autres langages. Il s'agit d'une fonction de base incluant le test des relations et l'élimination des éléments en double.

Pour modifier une séquence que vous itérez. à l'intérieur de la boucle (par exemple pour dupliquer certains éléments), il est recommandé de faire d'abord une copie. Effectuer une boucle sur une séquence ne crée pas implicitement une copie. La notation slice rend cela particulièrement pratique :

<.>

>>> words = ['cat', 'window', 'defenestrate']
>>> for w in words[:]: # Loop over a slice copy of the entire list.
...   if len(w) > 6:
...     words.insert(0, w)
...
>>> words
['defenestrate', 'cat', 'window', 'defenestrate']

Ce qui précède représente l'intégralité du contenu de cet article, j'espère qu'il sera utile à l'étude de chacun.

Pour plus d'articles liés aux fonctions de liste avancées en Python, veuillez faire attention au site Web PHP chinois !