Comment utiliser la fonction range de Python

1. Qu'est-ce que la fonction range() ? La fonction

range() est la fonction intégrée de python. Elle renvoie une série d'entiers ajoutés consécutivement et peut générer un objet liste.

La plupart d'entre eux apparaissent souvent dans les boucles for et peuvent être utilisés comme index dans les boucles for.

Pratique des questions rapides : pour la pratique de la plage

1 : Utilisez la boucle for et la plage pour trouver tous les nombres pairs compris entre 0 et 100 et ajoutez-les à une liste.

list1 = []
for i in range(0,100,2):
    list1.append(i)
print(list1)

2 : utilisez la boucle for et la plage pour trouver les nombres compris entre 0 et 50 qui peuvent être divisés par 3 et ajoutez-les à une liste.

list2 = []
for j in range(0,50):
    if j%3 ==0:
        list2.append(j)
print(list2)

3 : utilisez la boucle for et la plage pour trouver le nombre divisible par 3 entre 0 et 50 et insérez-le dans la 0ème position d'index de la liste. Le résultat final est le suivant : [48,45,42. ..]

list3 = []
for k in range(0,50):
    if k%3 == 0:
        list3.insert(0,k)
print(list3)

4 : Retrouver les éléments dans la liste li, supprimer les espaces avant et après chaque élément, retrouver les éléments commençant par "a", les ajouter à une nouvelle liste, et enfin imprimer la nouvelle liste en boucle .

li = ["alexC", "AbC ", "egon", " riTiAn", "WuSir", "  aqc"]'''
li = ["alexC", "AbC ", "egon", " riTiAn", "WuSir", "  aqc"]
li1 = []
for m in li:
    b = m.strip().startswith('a')
    if b == True :
        li1.append(m.strip())
for n in li1:
    print(n)

2. Format de syntaxe

range(start, stop [,step])

Introduction aux paramètres :

• start fait référence à la valeur de départ du comptage, qui peut être omise, et la valeur par défaut est 0 

• stop fait référence à la valeur finale de ; en comptant, mais en excluant l'arrêt ;

• step est la taille du pas, qui est par défaut de 1 et ne peut pas être 0.

(Remarque : s'il y a trois paramètres, alors le dernier paramètre est exprimé en taille de pas.)

ps1 : Un seul paramètre : représente tous les entiers de 0 à ce paramètre, à l'exclusion du paramètre lui-même

ran = range(6)
# 定义一个list，将range范围内的数都存入list
arry_list = list(ran)
print(ran)
print(arry_list)

#运行结果如下
range(0, 6)
[0, 1, 2, 3, 4, 5]

ps2 : Lorsque la fonction

range a deux paramètres, le premier paramètre représente la limite gauche et le deuxième paramètre représente la limite droite, y compris la gauche mais pas la droite.

ran_new = range(1, 8)
list_one = list(ran_new)  # 将range范围内的数据都存入list
print(list_one)

#运行结果
[1, 2, 3, 4, 5, 6, 7]

ps3 : Lorsque

range contient 3 paramètres, le premier représente la limite gauche, le deuxième représente la bordure droite et le troisième représente le pas, qui est la différence entre les deux entiers, dont la gauche n'inclut pas inclure le droit.

# range含有3个参数时,第一个表示左边界，第二个表示右边界，第三个表示步长step，即两个整数之间相差的数，含左不含右
ran_two = range(1, 16,2)
list_two = list(ran_two)
# list_two=
print(ran_new)
print(ran_two)
print(list_two)

Le résultat en cours d'exécution est :

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
range(1, 16 )
range(1, 16, 2)
[1, 3, 5, 7, 9, 11, 13, 15]

Exemple :

print("实例一：起始值为1，结束值为10")
for i in range(1,10):
    print(i,end='')
    print("\n实例二：结束值为10")
    for i in range(10):    print(i,end='') 
    print("\n实例三：结束值为10，步长为2")
for i in range(1,10,2):
    print(i,end='')

Résultat d'exécution :

Exemple 1 : Démarrer La valeur est 1, la valeur finale est 10123456789. Exemple 2 : La valeur finale est 100123456789. Exemple 3 : La valeur finale est 10, la taille du pas est 213579

3. Problème de rapport d'erreur

(1) Rapport d'erreur : TypeError : L'objet "list" n'est pas appelable.

fait référence au type d'erreur : L'objet "list" ne peut pas être appelé

Cause :

Puisque la liste de variables et la liste de fonctions ont le même nom, lorsque la fonction utilise la fonction liste, on constate que list est une définition. Eh bien, les listes ne peuvent pas être appelées, donc une erreur de type est générée. Par conséquent, lorsque nous définirons des variables à l’avenir, nous devrions éviter la duplication des noms de fonctions, des noms de méthodes et des mots-clés, et cela est vrai pour n’importe quel langage.

(2) Que se passe-t-il si la fonction range signale une erreur :

TypeError : ‘float‘

La raison est que range ne peut générer que des entiers, pas des types flottants. Utilisez la fonction arange de numpy pour résoudre le problème :

import numpy as np
for i in np.arange(0.1,0.5,0.05):
  print(i) # 0.1,0.15,0.2,...,0.4,0.45, 不包含0.5！
# 或者 l = list(np.arange(0.1,0.5,0.05))

4. Ce à quoi vous devez faire attention dans la fonction range()

① Cela représente une gauche. -intervalle fermé et ouvert à droite ;

② Le paramètre qu'il reçoit doit être un entier, qui peut être un nombre négatif, mais ne peut pas être un nombre à virgule flottante ou d'autres types

'''判断指定的整数 在序列中是否存在 in ，not in'''
print(10 in r) #False ,10不在当前的r这个整数序列中
print(9 in r)  #true ,9在当前的这个r序列里
print(9 not in r)  #false ,9不在当前的这个r序列里

③ C'est un type de séquence immuable qui peut ; être utilisé pour juger des éléments, trouver des éléments, découper et d'autres opérations, mais ne peut pas modifier des éléments ;

④ C'est un objet itérable, mais pas un itérateur.

# （1）左闭右开
>>> for i in range(3, 6):>>>  
print(i,end=" ")3 4 5
# （2）参数类型
>>> for i in range(-8, -2, 2):>>>   
print(i,end=" ")-8 -6 -4>>> range(2.2)----------------------------TypeError  Traceback (most recent call last)...TypeError: 
    'float' object cannot be interpreted as an integer
 # （3）序列操作
 >>> b = range(1,10)>>> b[0]1>>> b[:-3]range(1, 7)>>> b[0] = 2TypeError  Traceback (most recent call last)...TypeError: 
     'range' object does not support item assignment
 # （4）不是迭代器
 >>> hasattr(range(3),'__iter__')True>>> 
 hasattr(range(3),'__next__')False>>> hasattr(iter(range(3)),'__next__')True

5. L'objet range est une séquence immuable

La division officielle est la suivante - il existe trois types de séquence de base : liste, tuple et objet range.

（Il existe trois types de séquences de base : les listes, les tuples et les objets plage.）

Le type plage est la même séquence de base que les listes et les tuples ! Quelle est la différence entre la séquence de plage et les autres types de séquence ?

Les séquences normales prennent en charge 12 opérations, et les séquences de plage n'en prennent en charge que 10. L'épissage additif et la répétition de multiplication ne sont pas pris en charge.

>>> range(2) + range(3)-----------------------------------------TypeError  Traceback (most recent call last)...TypeError: unsupported operand type(s) 
for +: 'range' and 'range' >>> range(2)*2-----------------------------------------TypeError  Traceback (most recent call last)...TypeError: unsupported operand type(s) 
for *: 'range' and 'int'

Alors la question est : C'est aussi une séquence immuable Pourquoi les chaînes et les tuples prennent-ils en charge les deux opérations ci-dessus, mais pas les séquences de plage ?

Bien que les séquences immuables ne puissent pas être modifiées directement, nous pouvons les copier dans de nouvelles séquences pour les utiliser. Pourquoi l'objet range ne prend-il même pas cela en charge ?

Explication du document officiel :

...en raison du fait que les objets de plage ne peuvent représenter que des séquences qui suivent un modèle strict et que la répétition et la concaténation violeront généralement ce modèle.

La raison est que la plage les objets ne peuvent représenter que des séquences qui suivent un modèle strict et la répétition et la concaténation violeront généralement ce modèle. Une séquence qui suit un modèle strict, que la répétition et l'épissage brisent généralement...

.

问题的关键就在于 range 序列的 pattern！仔细想想，其实它表示的就是一个等差数列，拼接两个等差数列，或者重复拼接一个等差数列，这就是为啥 range 类型不支持这两个操作的原因了。因此可以得出结论，任何修改行为都会破坏等差数列的结构，因此最好不要进行任何修改。

【range类型的优点】

不管range对象表示的整数序列有多长，所有range对象占用的内存空间都是相同的，因为仅仅需要存储start、stop和step。只有当用到range对象时，才会去计算序列中的相关元素。

6、range函数实现逆序遍历

range函数实现逆序遍历两种实现方式

1）先创建一个列表，然后对列表中的元素进行逆序

例如：a=range(4)

a=range(4)    # [0, 1, 2, 3]new =[]for i in reversed(a):  
new.append(i)print(new)    # [3, 2, 1, 0]

2）直接使用range()函数完成逆序遍历

//第三个参数表示的是100所有进行的操作，每次加上-1，直到0for i in range(100,0,-1):
print(i)

7、与列表list的使用

list1 = ["看不", "见你", "的", "笑", "我怎么", "睡", "得", "着"]
for i in range(len(list1)):
print(i, list1[i])

运行结果：

【range与list的区别】

range（）是依次取顺序的数值，常与for循环一起用，如for范围内的每个（0, 5）：for循环执行5次，每个取值是0〜4。而list（）是把字符串转换为列表，如a = ’01234’ , b = list（a）, a打印出来会是一个列表：[‘0’,‘1’,‘2’,‘3’,‘4’]，如a = [0, 1, 2, 3, 4],输出的结果就会是[0, 1, 2, 3, 4]

#对比range与list
for i in range(0, 5):
    print(i)
a = [0, 1, 2, 3, 4]
print(a)

8、关于range函数小结

• （1）range对象的使用和理解都不难，但是在python的使用中非常常用！

• （2）range对象既不是函数也不是迭代器，可以叫它“懒序列”；

• （3）参数解释：start为范围开始，stop为范围结束，step为步长；

• （4）range对象经常和for循环配合使用；

• （5）可以对range对象进行索引；

关于range()函数还有一点需要注意的地方：range() 方法生成的只是可迭代对象，并不是迭代器！（Python2 中 range() 生成的是列表，本文基于Python3，生成的是可迭代对象）可以获得迭代器的内置方法很多，例如 zip() 、enumerate()、map()、filter() 和 reversed() 等等，但是像 range() 这样仅仅得到的是可迭代对象的方法就少有了。

在 for-循环 遍历时，可迭代对象与迭代器的性能是一样的，即它们都是惰性求值的，在空间复杂度与时间复杂度上并无差异。两者的差别概括是：相同的是都可惰性迭代，不同的是可迭代对象不支持自遍历（即next()方法），而迭代器本身不支持切片（即__getitem__() 方法）。虽然有这些差别，但很难得出结论说它们哪个更优。

那为什么给 5 种内置方法都设计了迭代器，偏偏给 range() 方法设计的就是可迭代对象呢？把它们都统一起来，不是更好么？事实上，Pyhton 为了规范性就干过不少这种事，例如，Python2 中有 range() 和 xrange() 两种方法，而 Python3 就干掉了其中一种。为什么不更规范点，令 range() 生成的是迭代器呢？

这个问题看到有大佬说的比较好的观点，这里引用一下：

zip() 等方法都需要接收确定的可迭代对象的参数，是对它们的一种再加工的过程，因此也希望马上产出确定的结果来，所以 Python 开发者就设计了这个结果是迭代器。

这样还有一个好处，即当作为参数的可迭代对象发生变化的时候，作为结果的迭代器因为是消耗型的，不会被错误地使用。

而 range() 方法就不同了，它接收的参数不是可迭代对象，本身是一种初次加工的过程，所以设计它为可迭代对象，既可以直接使用，也可以用于其它再加工用途。

例如，zip() 等方法就完全可以接收 range 类型的参数。

>>> for i in zip(range(1,6,2), range(2,7,2)):>>>
print(i, end="")(1, 2)(3, 4)(5, 6)

也就是说，range() 方法作为一种初级生产者，它生产的原料本身就有很大用途，早早把它变为迭代器的话，无疑是一种画蛇添足的行为。重点不在于range对象是什么，而在于我们如何使用它

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!