python for循环 的步长知是否可以是变量 python for循环设置步长

一、For循环（未完待补充）

（1）. for循环和range函数
for循环除了创建方式以外，其余的都和while一样，包括 else，break，continue都可以在for循环中使用**

range() 可以生成一个自然数序列
r = range(5) # 生成一个这样的序列
r = range(0, 10, 2)
该函数需要三个参数：
1.起始位置
2.结束位置
3.步长（可以省略，默认为1）（步长不能为0，为0会抛异常，可以为负数，会倒序输出）

通过range（）可以创建一个执行指定次数的for循环：
例如：

for i in range(5)
print(i，end = ‘ ’)

运行截图：

for i in range(10, 20, 2):
    print(i, end=' ')

运行截图：

for i in range(18, 8, -3):
    print(i, end=' ')

运行截图：

a = ['a', 'b', 2, 3]
for i in range(len(a)):
    print(a[i], end=' ')

运行截图：

二、列表(list)

**

列表

（list）
列表是Python中的一个对象
对象（object）:就是内存中专门用来存储数据的一块区域
列表中可以保存多个有序**的数据
列表的使用：
1.列表的创建
2.操作列表中的数据
创建列表 ，通过[]来创建列表

列表存储的数据，我们称为元素
一个列表中可以存储多个元素，也可以在创建列表时，来指定列表中的元素
列表可以为空，列表中添加多个元素时，多个元素之间用 , 隔开
列表可以保存任意类型的对象
my_list = [10,‘Hello’, True, None, [1, 2, 3], print ]

#列表中的对象都会按照插入的顺序存储到列表中
#第一个的对象保存到第一个位置，第二个保存到第二个位置
#我们可以通过索引（index）来获取表中的元素
#索引是元素在列表中的位置，列表中的每一个元素都有一个索引
#索引是从 0 开始的整数，列表第一个位置的索引为0，第二个位置索引为1 以此类推
语法
my_list[0]
如果是使用的索引超过了最大的范围，会抛出异常
len()函数
#获取列表的长度，列表中的元素的个数
#len()函数，通过该函数可以获取列表的长度
获取到的长度的值，是列表的最大的索引 + 1

代码举例：

a = []
b = [1, 2]
print(type(a), a)
print(type(b), b)

运行截图：

a = [1, 'a', 'b', 'c']
x = len(a)
print('长度', x)
print(a[0], a[1], a[2])

运行截图：

a = [1, 'a', 'b', 'c']
i = 0
while i < len(a):
    print('第', i + 1, '个值是：', a[i])
    i += 1

运行截图：

步长

语法：列表[起始:结束:步长]
步长表示，每次获取元素的间隔，默认值为1
步长可以是负数，但不能为0
如果是负数，则从列表的后部向前面取元素

+ 和 *

" + "可以将两个列表拼接为一个列表
" * "可以将列表重复指定的次数

a = [1, 2]
b = [3, 4, 5]
c = a + b
print(c )
d = a * 3
print(d)
x = a[1] + b[2]
print(x)

代码的拼接，重复打印，两个列表里的数值运算

运行截图：

切片

#切片指从现有的列表中，获取一个子列表
#创建一个列表，一般创建列表时，变量的名字会使用复数（多个数据）

#列表的索引可以是负数
#如果索引是负数，则从后向前获取元素， -1 表示倒数第一个，-2表示倒数第二个，以此类推

#通过切片来获取指定的元素
#语法：列表[起始 : 结束 ]
#通过切片获取元素时，会包括起始位置的元素，不包括结束位置的元素
#做切片时 ， 总会返回一个新的列表，不会影响原来的列表
#起始位置和结束位置的索引都可以省略不写
如果省略结束位置，会截取到最后，开始同理
如果开始位置和结束位置全部省略，则相当于创建了一个列表的副本

a = ['a', 'b', 'c', 1, 2, 3, 4, 5, 6, 7]
b = a[2:5]  # 根据索引
print(b)
c = a[2:8:2]
print(c)
d = a[2:]
print(d)
e = a[:3]  # 不包含索引为3的数据
print(e)

运行截图：

a = ['a', 'b', 'c', 1, 2, 3, 4, 5, 6, 7]
b = a[-1]
print(b)

a = ['a', 'b', 'c', 1, 2, 3, 4, 5, 6, 7]
for i in range(-1, -len(a) - 1, -1):
    print(a[i])

运行截图：

a, *b = [1, 2, 3]
print(a, b)

加上*号，会将列表中第二个开始到结束的数据以列表的形式给b

*a, b = [1, 2, 3]
print(a, b)

运行截图：

列表的方法

通过方法修改列表

append()方法

stus = ['孙悟空', '猪八戒', '沙僧']
stus.append('唐僧')	#在列表最后加上“唐僧”
print(stus)

运行截图;

a = [1, 2, 3, 4, 5]
a.append(9)
print(a)

运行截图：

a = [1, 2, 3]
b = a
a.append(4)		# a和b所指的地址一样，改变a，b也变
print(a)
print(b)

运行截图：

insert（）方法

向列表的指定位置插入一个元素
#参数
#1.要插入的位置
#2.要插入的元素

stus = ['孙悟空', '猪八戒', '沙僧']
stus.insert(2, '唐僧')		# 2 为下标索引位置
print(stus)

运行截图：

extend()方法

#使用新的序列来扩展当前序列（extend改变了原来的列表，+ 号没有改变原来的列表）
#需要一个序列作为参数，它会将该序列的元素添加到当前列表中

a = [1, 2, 3, 4, 5]
b = [3, 4]
a.extend(b)
c = [5, 6]
print(a)

运行截图：

pop()方法

pop()根据索引删除并返回被删除的元素的值
括号里为空默认删除最后一个

a = [1, 2, 3, 4, 5]
b = a.pop()
print(b)
b = a.pop(2)
print(a, b)

运行截图：

remove()方法

#删除**指定值（不根据索引）**的元素
stus.remove(‘猪八戒’) 如果有重复元素，只会删除第一个，没有返回值

a = [1, 2, 3, 4, 5]
a.remove(3)
print(a)

运行截图：

del方法根据索引来删除元素

c = [1, 2, 3, 4]

for i in range(len©):

del c[0]

print( c )

运行截图：

a = [1, 2, 3, 4, 5]
del a[2]
print(a)

运行截图：

reverse()方法

#用来反转列表

a = [1, 2, 3, 4, 5]
a.reverse()
print(a)

运行截图：

sort()方法

对列表中的数据进行排序（默认从小到大排序）

a = [3, 2, 1, 5, 7, 3, 8]
a.sort()
print(a)

运行截图：

逆序排序（利用reverse函数）

a = [3, 2, 1, 5, 7, 3, 8]
a.sort(reverse=True)
print(a)

运行截图：

sorted()方法

a = [3, 2, 1, 5, 7, 3, 8]
b = sorted(a)		 # 对a不改变，排序赋给b
print(b)

运行截图：

sort()方法和sorted()方法的区别
sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

count()函数
count() 方法用于统计字符串里某个字符出现的次数。
可选参数为在字符串搜索的开始与结束位置。
count()方法语法：
str.count(sub, start= 0,end=len(string))
sub – 搜索的子字符串
start – 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
end – 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。

a = [3, 2, 1, 5, 7, 3, 8]
b = a.count(3)
print("3的个数：", b)

运行截图：

index()方法
Python index() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，该方法与 python find()方法一样，只不过如果str不在 string中会报一个异常。
语法:
str.index(str, beg=0, end=len(string))
str – 指定检索的字符串
beg – 开始索引，默认为0。
end – 结束索引，默认为字符串的长度。

a = [3, 2, 1, 5, 7, 3, 8]
x = a.index(2)  # 返回第一次出现2的索引
print(x)

运行截图：

is 和 is not

is 和is not 比较的是对象的id是否相等

a = [1, 2, 3]
b = [1, 2, 3]
print(a == b)
print(a is b)
print(id(a))
print(id(b))

列表里的元素相同，但是内存地址不一致，所以a和b所指的内存地址不一样

运行截图：

copy()方法

copy()浅拷贝：只拷贝列表最外
deepcopy()深拷贝：由列表最内层向外拷贝，拷贝所有元素

import copy
a = [1, 2, 3, [4, 5], 6]
b = a
c = copy.copy(a)
d = copy.deepcopy(a)
a.append(7)
a[3].append(99)
print(a, id(a))
print(b, id(b))
print(c, id(c))
print(d, id(d))

运行结果：

原理图：

三、元组(tuple)

元组(tuple)

元组是一个不可变的序列
它的操作方式基本上和列表是一致的
所以在操作元组时，把元组当成不可变的列表就可以

一般当我们希望数据不改变时，就使用元组

创建元组

使用（）来创建元组

my_tuple = (1, 2, 3, 4, 5) #创建了一个5个元素的元组

#元组是不可变对象， 不能尝试为了元组中的元素重新赋值

#my_tuple[3] = 10 NameError: name ‘my_tuple’ is not defined

print(my_tuple[3])

#当元组不是空元组时，括号可以省略
#如果元组不是空元组，它里面至少要有一个逗号

a = (1,)
b = (1)
c = 1, 2
print(type(a))
print(type(b))
print(type(c))

运行截图

a = (1, 2, 3, 4)
b = (1, 2)
i = 0
while i < len(a):
    print(a[i], end=' ')
    i += 1

切片一样可以用

a = (1, 2, 3, 4)
print(a[2::1])  # 运行结果：(3, 4)

运行截图

元组不可修改，但是元组中的列表可以修改

a = (1, 2, 3, [4, 5])
a[3].append(9)
print(a)

运行截图：

a = ('a', 'b', 'c', 'e')
for x in enumerate(a):  # 加上索引值
    print(x)

运行截图：