range() ist die integrierte Funktion von Python. Sie gibt eine Reihe nacheinander hinzugefügter Ganzzahlen zurück und kann ein Listenobjekt generieren.
Die meisten davon erscheinen häufig in for-Schleifen und können als Indizes in for-Schleifen verwendet werden.
Schnelle Fragenübung: für..Bereichsübung
1: Verwenden Sie die for-Schleife und den Bereich, um alle geraden Zahlen zwischen 0 und 100 zu finden, und hängen Sie sie an eine Liste an.
list1 = []
for i in range(0,100,2):
list1.append(i)
print(list1)2: Verwenden Sie die for-Schleife und den Bereich, um die Zahlen zwischen 0 und 50 zu finden, die durch 3 teilbar sind, und hängen Sie sie an eine Liste an.
list2 = []
for j in range(0,50):
if j%3 ==0:
list2.append(j)
print(list2)3: Verwenden Sie die for-Schleife und den Bereich, um die durch 3 teilbare Zahl innerhalb von 0 bis 50 zu finden, und fügen Sie sie an der 0. Indexposition der Liste ein. Das Endergebnis lautet wie folgt: [48,45,42. ..]
list3 = []
for k in range(0,50):
if k%3 == 0:
list3.insert(0,k)
print(list3)4: Suchen Sie die Elemente in der Liste li, entfernen Sie die Leerzeichen vor und nach jedem Element, suchen Sie die Elemente, die mit „a“ beginnen, fügen Sie sie einer neuen Liste hinzu und drucken Sie schließlich die neue Liste in einer Schleife aus .
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)range(start, stop [,step])
Parametereinführung:
start bezieht sich auf den Startwert der Zählung, der weggelassen werden kann, und der Standardwert ist 0;
stop bezieht sich auf den Endwert von Zählen, aber ohne Stopp;
Schritt ist die Schrittgröße, die standardmäßig 1 ist und nicht 0 sein kann.
(Besonderer Hinweis: Wenn es drei Parameter gibt, wird der letzte Parameter als Schrittgröße ausgedrückt.)
ps1: Nur ein Parameter: Stellt alle Ganzzahlen von 0 bis zu diesem Parameter dar, mit Ausnahme des Parameters selbst
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: Wenn die
range-Funktion zwei Parameter hat, stellt der erste Parameter die linke Grenze und der zweite Parameter die rechte Grenze dar, einschließlich der linken, aber nicht der rechten.
ran_new = range(1, 8) list_one = list(ran_new) # 将range范围内的数据都存入list print(list_one) #运行结果 [1, 2, 3, 4, 5, 6, 7]
ps3: Wenn
range 3 Parameter enthält, stellt der erste die linke Grenze dar, der zweite die rechte Grenze und der dritte den Schritt, der die Differenz zwischen den beiden ganzen Zahlen darstellt, einschließlich Left nicht rechts einschließen.
# 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)
Das laufende Ergebnis ist:
[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]
Beispiel:
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='')Laufendes Ergebnis:
Beispiel 1: Start Der Wert ist 1, der Endwert ist 10123456789 Beispiel 2: Der Endwert ist 100123456789 Beispiel 3: Der Endwert ist 10, die Schrittgröße ist 213579
(1) Fehlerberichterstattung: TypeError: Das „Listenobjekt“ ist nicht aufrufbar.
bezieht sich auf den Fehlertyp: Das Objekt „Liste“ kann nicht aufgerufen werden
Ursache:
Da die Variablenliste und die Funktionsliste denselben Namen haben, wenn die Funktion die Listenfunktion verwendet, Es wurde festgestellt, dass die Liste eine Definition ist. Nun, Listen können nicht aufgerufen werden, daher wird ein Typfehler ausgegeben. Wenn wir in Zukunft Variablen definieren, sollten wir daher wie in jeder Sprache die Duplizierung von Funktionsnamen, Methodennamen und Schlüsselwörtern vermeiden.
(2) Was passiert, wenn die Bereichsfunktion einen Fehler meldet:
TypeError: ‘float‘ Objekt kann nicht als Ganzzahl interpretiert werden?
Der Grund dafür ist, dass Range nur Ganzzahlen generieren kann, keine Float-Typen, um das Problem zu lösen:
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))
② Der empfangene Parameter muss eine Ganzzahl sein, die eine negative Zahl sein kann, aber keine Gleitkommazahl oder ein anderer Typ sein kann.
'''判断指定的整数 在序列中是否存在 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序列里
③ Es handelt sich um einen unveränderlichen Sequenztyp Führen Sie Operationen wie das Beurteilen von Elementen, das Finden von Elementen, das Schneiden usw. aus, können Sie jedoch keine Elemente ändern.
④ Es ist ein iterierbares Objekt, aber kein Iterator.
# （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__')True5. Das Bereichsobjekt ist eine unveränderliche Sequenz
（Es gibt drei grundlegende Sequenztypen: Listen, Tupel und Bereichsobjekte.）
Der Bereichstyp ist die gleiche grundlegende Sequenz wie Listen und Tupel!
Was ist der Unterschied zwischen der Bereichssequenz und anderen Sequenztypen?Normale Sequenzen unterstützen 12 Operationen und Bereichssequenzen unterstützen nur 10 davon. Additives Spleißen und Multiplikationswiederholung werden nicht unterstützt.
>>> 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'
Es handelt sich auch um unveränderliche Sequenzen. Warum unterstützen Strings und Tupel die beiden oben genannten Operationen, Bereichssequenzen jedoch nicht? Obwohl unveränderliche Sequenzen nicht direkt geändert werden können, können wir sie für den Betrieb in neue Sequenzen kopieren. Warum unterstützt das Bereichsobjekt dies nicht einmal?
Erklärung aus der offiziellen Dokumentation:...aufgrund der Tatsache, dass Bereichsobjekte nur Sequenzen darstellen können, die einem strengen Muster folgen, und Wiederholungen und Verkettungen normalerweise gegen dieses Muster verstoßen.
Der Grund ist dieser Bereich Objekte können nur Sequenzen darstellen, die einem strengen Muster folgen, und Wiederholungen und Verkettungen verstoßen normalerweise gegen dieses Muster. Eine Sequenz, die einem strengen Muster folgt, das durch Wiederholung und Zusammenfügung normalerweise unterbrochen wird ...
问题的关键就在于 range 序列的 pattern！仔细想想，其实它表示的就是一个等差数列，拼接两个等差数列，或者重复拼接一个等差数列，这就是为啥 range 类型不支持这两个操作的原因了。因此可以得出结论，任何修改行为都会破坏等差数列的结构，因此最好不要进行任何修改。
【range类型的优点】
不管range对象表示的整数序列有多长，所有range对象占用的内存空间都是相同的，因为仅仅需要存储start、stop和step。只有当用到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)
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)（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对象是什么，而在于我们如何使用它
Das obige ist der detaillierte Inhalt vonSo verwenden Sie die Range-Funktion von Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
