全网最详细的Python基础知识（5）看了就是赚了

for循环（重点掌握）

1. 与之前学的while循环极其类似，但是for循环相对于while循环要简单一些；for循环也叫做迭代循环

for i in 'python':
	print(i)

# 返回结果
p
y
t
h
o
n

这段代码的意思是，将python这个字符串循环，并依次将每一个字符拿出来赋值到 i 这个变量中，最后打印 i

for循环在写完循环语句后，必须有冒号，表示代码未结束；for循环中所循环的不一定是字符串，也可以是已经赋值的变量：

a = 'python'
for i in a:
	print(i)

i不是固定的，可以随便起名字，但是要注意变量命名

2. range函数，表示从某个范围获取值，范围写在小括号中：

for i in range(0,10):
	print(i)

# 返回结果
0
1
2
3
4
5
6
7
8
9

上面的代码所表达的意思是获取循环从0开始10结束的数并且赋值到 i 中，在range中获取的范围是顾头不顾尾，也就是从0开始，0包括，10结束，不包括10

for i in range(10):
	print(i)

也是表示0开始10结束
一般开始数值如果是0，可以直接简写成range(10)

但在我们写代码的时候，往往需要获取0，2，4，6这样的数字，这时候python中的步长就用得上了

for i in range(0,10,2):
	print(i)

0
2
4
6
8

意思是，获取并循环从0开始10结束，步长为2的数值；步长为2，意思是，相隔2个数获取一次，0是第一个数0,1；割了两个数，然后就获取2；2,3；又隔了两个，再获取4，以此类推

注意，如果是获取有步长的数值，不需要有三个参数，开始数，结束数，以及步长，三者缺一不可；还有一种情况，我们需要反向获取，步长为2，就将步长改为-2，并且将开始数和结束数位置互换：

for i in range(10,0,-2):
	print(i)

这时所打印出来的就是10，8，6，4，2

continue和break（重点掌握）

1. continue：意思为跳出某次循环

for i in range(10):
	if i % 2 == 0:
		continue
	print(i)

1
3
5
7
9

获取并循环0开始10结束的值，再进行判断如果获取的值除以2的余数为0的，跳出本次循环，执行下一次循环；第一个获取的是0,0除2等于0，余数也为0，便执行continue跳出此次循环，接着执行下一次，当获取的数值是1时，1除2为0，余数为0.5，不为0，所以不执行continue，执行print打印数值；以此类推；当为3时，3除2为1，余0.5，打印3

2. break：意思为结束循环

a = 0
while a < 20:
	a += 1
	print(a)
	if a == 5:
		print('循环结束')
		break

1
2
3
4
5
循环结束

代码解释：当a为0，a小于20，执行a加1，打印a的值为1，再判断if语句，1不等于5，所以不执行if后面的代码，a为1时，1小于20，执行a加1，此时a变为2，接着打印a的值为2，再进行判断，一直到a等于4时，4小于20，执行加1操作，并且打印a的值为5，再判断5等于5，打印’循环结束’，并且break停止循环

拓展：大家想想如果print和break调换位置，先break后print，结果是怎么样的，给大家看看结果

1
2
3
4
5

这时候没有打印’循环结束’，因为break比较特殊，一旦python中遇到break，break后面所有的代码全都不执行，包括else语句

for i in range(20):
	if i % 2 == 0:
		break
	else:
		print(i)
else:
	print('循环结束')

最后执行的结果什么都没有，说明不管是if后的else，还是循环本身的else都会因为break的出现而打断

补充1：之前一直是for循环比while循环好用，这里告诉大家，while循环其实是一个死循环，需要使用break停止循环，上面的while循环我是控制了结束条件，以至于没有变成死循环，这里给大家看一下while循环跟True连用变成的死循环

while True:
	print('hello')

意思为，默认while为真，让它一直执行打印操作，这段代码执行的结果就是一直打印‘hello’，因为你没有给结束条件，除非使用break终止循环，True代表标志性，告诉循环一直执行，只能用True不能用False，也可以是

a = True
while a:
	print('hello')

打印结果都一样；但是for循环没法让它默认为真一直循环，所以才说for循环要优于while循环

补充2：上面的代码有一个共同点，不知道大家有没有发现，它们都有一个很长的空格，这种空格python中叫做‘缩进’，默认一个缩进是4个空格，缩进是系统来判断执行顺序所用的

for i in range(10):
if i == 5:
continue
else:
print(i)
else:
print('结束')

大家看看如果没有缩进，系统是怎么执行的；第一步循环获取数值没有问题，第二步判断 i 是否等于5，如果等于5，则跳出循环，否则则打印 i ，但是现在没有缩进，系统就不知道这个else到底是if里面的。还是for循环本身的，就会导致代码执行错误，大家写代码的时候一定要注意这一点

补充3：我们有时候写代码的时候，会报错

D:\SoftWareSpace\python\python.exe D:/python_work/知识分享源代码/Python基础1.py
  File "D:/python_work/知识分享源代码/Python基础1.py", line 3
    print('hello')
        ^
IndentationError: expected an indented block

Process finished with exit code 1

类似这种，这种情况，第一检查自己代码是不是单词写错了，第二检查所有符号是不是英文的，第三检查缩进有没有问题；关于这一大段的具体意思，后面的异常处理会详细讲解

列表解析（重点掌握）

1. 列表（list）是python中储存数据的方法之一，实例代码如下：

li = [1,2,3,4]

将数字1-4储存进列表中，用[ ]表示，里面的数值用英文逗号隔开，列表中不仅可以储存数字，还可以储存字符串

2. 使用列表中的数值，虽然我们现在储存的数据，但是突然想用其中的数据2，该怎么办呢？这时候，列表中的索引就体现出来了。列表中的数据每一个都有对应的下标，python中称为索引下标（index），下标从0开始，列表中的第一个数据对应的下标是0，第二个数据对应的下标是1，以此类推
3. 还可以根据切片获取范围元素，切片中的下标是顾头不顾尾，包括开头，不包括末尾

li = [1,2,3,4]
print(li[1])  # li[1]表示获取列表li中下标为1的数据
print(li[0:2]) # 获取下标范围0-2的元素，中间用冒号相隔下标

通过下标获取列表中数据用 列表[下标] 表示

2
[1,2]

此时打印的结果就是2，如果将li[1]改成li[0]，打印的结果就是1

列表中的增删改查

增：

1. append()方法，依次添加，追加，将数据依次添加至末尾
2. insert()方法，指定数据插入，需要明确指明下标
3. extend()方法，依次添加多个数据，也是添加至末尾

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

# 返回值
>>>[1,2,3,4,5]

li = [1,2,3,4]
li.insert(1,5)  # 将下标为1的位置加上数据5，也就是说2的位置现在是5，其他全部往后移一位
print(li)

# 返回值
>>>[1,5,2,3,4]

li = [1,2,3,4]
li.extend([5,6]) # 注意要以列表的形式添加
print(li)

# 返回值
>>>[1,2,3,4,5,6]

删：

1. pop()方法，默认删除最后一位，可以根据下标进行删除，且删除的可以使用变量接收
2. remove()方法，根据元素删除
3. clear()方法，清空整个列表
4. del方法，根据切片删除范围元素

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

# 返回值
>>>[1, 3] 4 2

li = [1,2,3,4]
li.remove(1)  # 这是根据元素不是根据下标，注意！！！
print(li)

# 返回值
>>>[2, 3, 4]

li = [1,2,3,4]
li.clear()
print(li)

# 返回值
>>>[]

li = [1,2,3,4]
del li[0:2]  # 注意，del中间没有点！！！
print(li)

# 返回值
>>>[3,4]

改：

1. 列表名[下标] = ‘修改后的值’，这种事单个修改，通过索引下标修改值
2. 列表名[0:2] = ‘修改后的值’，‘修改后的值’，这种是多个修改，通过切片修改值

li = [1,2,3,4]
li[0] = 2 # 这里不加引号是因为修改的是数字不是字符串，如果修改后的是字符串一定要见引号，像中文、英文都属于字符串
print(li)

# 返回值
>>>[2,2,3,4]

li = [1,2,3,4]
li[0:2] = 7,8
print(li)

# 返回值
>>>[7,8,3,4]

查：

1. 就是获取每个下标对应的值，上面已经讲过了，这里就不重复讲了

li = [1,2,3,4]
print(li[0:2])

# 返回值
>>>[1,2]

列表推导式

列表推导式是简化了储存数据的操作

li = [i for i in range(10) if i%2 == 0]

# 返回值
>>>[0, 2, 4, 6, 8]

代码解析：i 是循环获取数据储存到哪个变量，for i in range(10)是循环语句，if i%2 == 0是条件判断

下面的是列表推导式的全写：

li = []
for i in range(10):
	if i % 2 == 0:
		li.append(i)
print(li)

# 返回值
>>>[0, 2, 4, 6, 8]

列表推导式大家知道就可以了，不需要特别去记，以后看到，能想起这是个啥就可以了

其他操作

深浅复制

1. 列表复制：li_a = li.copy()或者是li_a = li

li = [1,2,3,4]
li_a = li.copy()
print(li,li_a)
li.append(5)
print(li,li_a)

>>>[1, 2, 3, 4] [1, 2, 3, 4]
   [1, 2, 3, 4, 5] [1, 2, 3, 4]

如果是用copy复制的列表，改变其中一个列表的值，另一个列表的值是不会改变的，但是如果直接用‘=’来复制：

li = [1,2,3,4]
li_a = li
print(li,li_a)
li.append(5)
print(li,li_a)

>>>[1, 2, 3, 4] [1, 2, 3, 4]
   [1, 2, 3, 4, 5] [1, 2, 3, 4, 5]

结果会发现，当我们对其中一个列表增加值时，另一个列表的值也随之改变了。

我们用‘=’复制时，其实复制出来的列表与原来的列表内存地址指向是一样的，所以我们修改其中一个列表时，对应的另一个内存地址的列表的值也随之改变。

当我们用copy复制时，复制出来的列表与原来的列表内存地址指向是不一样的，所以修改其中一个列表的值，对另一个列表的值是不影响的

li = [1,2,3,4]
li_a = li
print(id(li))
print(id(li_a))

>>>1602444812872
   1602444812872

li = [1,2,3,4]
li_a = li.copy()
print(id(li))
print(id(li_a))

>>>1350150611528
   1350150611592

复制中又有一个深浅复制问题：

1、深复制：需要导入copy模块，使用里面的deepcopy()方法

import copy

li = [1,2,[3,4,5]]
li_a = copy.deepcopy(li)
print(id(li))
print(id(li_a))

>>>2547267800520
   2547267849288

2、浅复制：id不一样

统计元素：count()方法，统计某个元素的个数

li = [1,1,2,1,3,4,5]
print(li.count(1))

>>>3

排序操作

1. sort()正向永久排序，数字按数字从小到大顺序，字母按字母顺序；永久排序会影响原列表
2. sorted()正向临时排序，不会影响原列表
3. reverse()反向列表，只是将列表反过来排，并不是按顺序;永久的
4. sort(reverse=True)反向排序，数字从大到小，字母前后到前，永久的

li = [5,4,3,2,1]
li.sort()  #sort排序不能将print直接作用在它们整体，必须分开
print(li)

>>>[1,2,3,4,5]

li = [5,4,3,2,1]
print(sorted(li)) #sorted可以加print，且注意sort与sorted的使用方法，一个是列表.sort()，一个是sorted(列表)
print(li)

>>>[1, 2, 3, 4, 5]
   [5, 4, 3, 2, 1]

li = [5,8,1,6,3,4,9]
li.reverse()
print(li)

>>>[9, 4, 3, 6, 1, 8, 5]

li = [5,8,1,6,3,4,9]
li.sort(reverse=True)
print(li)

>>>[9, 8, 6, 5, 4, 3, 1]

使用index()方法通过元素获取索引下标

li = [1,2,3,4,5]
print(li.index(2))  #2是列表元素

>>>1  #2所对应的下标

元组

一旦元组定义了，不能进行添加、修改，只能进行拆包；元组用（ ，，）的形式表示，每个元素之间用逗号分隔；元组的数据类型是tuple

1. 接收元组的元素：a,b = tu

tu = (1,2,3,4)
a,b,c,d = tu
print(a,b,c,d)

>>>1 2 3 4

2. 拆包的语法结构：a, *b = tu
   用a变量去接收第一个元素，*b表示剩下的所有元素用b来接收，并且以列表的形式

tu = (1,2,3,4)
a,b,*c = tu
print(a,b,c)

>>>1 2 [3,4]

上节课作业答案

# 第一题
x = 1  #循环初始值
while x < 10:  #循环结束条件，因为乘法表横竖最大只有9，所以这里是小于10
    y = 1
    while y <= x:  #如果这里是10，最后执行出来的是一个矩形状的，你会发现当y小于等于10，y的值是大于x的，但乘法表是阶梯状的，所以要改成y<=x，这个地方是难点，比较难理解，大家把两种写出来，对比着看
        print('%d*%d=%d' % (y, x, y * x), end='\t')  #这里没啥难度，用了字符串格式化的方法，以及不换行打印，\t是制表符，后面会学，可以让乘法表对齐；注意这里是y乘x，不是x乘y，因为乘法表是1*1,1*2的，而不是1*1,2*1的
        y += 1
    print('\n')  #\n是换行符，后面会跟\t一起学，这里只要知道是用来换行的就可以了
    x += 1

# 第二题
import random
number = random.randint(1,50)  #在1-50之间随机抽取一个数
i = 1
while i<=10:

    a = int(input("请输入一个数字,您共有10次机会: "))
    
    if a < number:
        print("小了一点！\n")
    elif a > number:
        print("大了一点！\n")
    else:
        print("你太棒了，猜对了！")
        break
    i += 1
else:
    print("不好意思，您的机会用完了！")

今日作业

1. 用for循环打印九九乘法表，原理都是一样的
2. 自己定义出一个很重复元素的列表，用我们学过的方法去除重复的元素

今天内容有点多，希望大家可以慢慢理解，如果有问题，可以私信，或者评论区问出来，感谢大家！！！