python:while循环、for循环

循环

1、在一般情况下,语句是按顺序执行的:在一个函数的第一条语句,首先执行,然后是第二条,第三条...等等
    ⑴可能有一种情况,当你需要执行代码块几次或多数,循环语句可以让我们执行语句声明或组多次

2、循环三大条件
    ⑴定义循环的起始值
    ⑵循环结束的条件
    ⑶起始值递增或递减

3、在python编程中,python提供了for循环while循环

 

Python中的循环

Python编程语言提供了以下类型的循环

循环类型描述
while循环当指定的条件为True时:重复执行while语句块下的语句或组。它在执行循环体之前测试条件
for循环执行一系列语句多次或循环遍历某一可迭代对象
嵌套循环可以在while循环或for循环内嵌套任意类型的循环

 

Python中的循环控制语句

1、循环控制语句改变其正常的顺序执行。当执行离开了循环范围,在该范围内创建的所有自动对象被销毁

2、Python支持以下控制语句

控制语句描述
break语句 终止循环语句并立刻转移执行循环后面的语句:跳出整个循环
continue语句结束本次循环,进行下次循环
pass语句pass是空语句,为了保持程序结构的完整性。它不做任何事情,相当于占位语句

 

 

while循环

1、Python编程语言中的while循环语句只要给定条件为真,则会重复执行while代码块下的语句

2、基本语法为:

while 判断条件:
        执行语句......

注:
1、while循环用于循环执行程序,以处理需要重复处理的任务:当while关键字后的判断条件为真时,执行while代码块

2、while语句和if语句都有判断的作用
    ⑴while循环用于多次判断同一个条件,条件满足时重复执行语句块
    ⑵if语句只能判断一个条件一次,无循环作用    

3、执行语句可以是单个语句或语句块。判断条件可以是任何表达式(参考if的判断表达式)
    ⑴所有非空(null)、非零的值都为真(True):执行while代码块
    ⑵当判断条件为假(False)时:循环结束

4、while循环的执行流程图如下,该流程图的意思为:
    ⑴首先对while条件进行判定,当条件为ture时,执行while语句块。执行完while语句块后再次对条件进行判定,若为仍为true,则继续执行while语句块,直到条件为false时结束循环

例1:

count = 0
while count < 5:
   print ('The count is:', count)
   count = count + 1

print ("Good bye!") #while循环结束后,继续执行下面其他语句块

"""
The count is: 0
The count is: 1
The count is: 2
The count is: 3
The count is: 4
Good bye!
"""

 

无限循环

1、在while循环中:如果条件永远不会变为False,那么一个循环就会变成无限循环(死循环)

2、进入了一个无限循环时,需要使用CTRL+C才能退出程序

3、所以在使用while循环时一定需要注意循环的判断条件:保证一定会有跳出循环的条件

例2:

count = 1
while count ==True:
   print ('The count is:', count)

print ("Good bye!") #上面为一个死循环,因此永远都不会跳出循环来执行这条语句

 

while循环中使用else语句

Python支持循环语句相关的else语句。
    ⑴如果else语句在一个for循环中使用,当循环已经完成(用尽时)迭代列表执行else语句
    ⑵如果else语句用在while循环中,当条件变为false,则执行else语句

例3:

number = 1
while number < 5:
    print(number)
    number += 1
else:    #else与while为同一缩进
    print("number的值为5")

"""
2
3
4
number的值为5
"""

 

while循环中使用if语句

同样在while循环和for循环中也可以使用if...else语句:在循环中对某些条件进行判断,用来执行不同的语句块

例4:

import random

number = random.randint(0,10)
print("正确结果为:",number)

guess = int(input("请输入你认为正确的数字:"))
while guess != number:
    if guess > number:
        print("稍微大了一点,需要再小一点")
        guess = int(input("您猜错了,请输入你认为正确的数字:"))
    elif guess < number:
        print("稍微小了一点,需要再大一点")
        guess = int(input("您猜错了,请输入你认为正确的数字:"))
    else:
        pass

print("正确")

"""
正确结果为: 10
请输入你认为正确的数字:2
稍微小了一点,需要再大一点
您猜错了,请输入你认为正确的数字:11
稍微大了一点,需要再小一点
您猜错了,请输入你认为正确的数字:10
正确

例4_1:

list = [12,37,5,42,8,3]
list_1 = []
list_2 = []
while len(list) > 0:
    number = list.pop()
    if number % 2 == 0:
        list_1.append(number)
    else:
        list_2.append(number)
print(list_1)
print(list_2)

"""
[8, 42, 12]
[3, 5, 37]
"""

注:
1、感觉在while中直接中else的场景应该会比较少,可能有些特殊场景下回用到这种写法。在循环中使用if...else语句应该会比较多

2、在上面的第二个例子中先是通过while、if 条件的判断,分别得到list_1、list_2,在最后一次判断中while为False,则不执行循环执行输出(空列表表示False)

 

 

for循环

1、在python中,for关键字叫做for循环,for循环可以遍历任何一个可迭代对象
    ⑴可迭代对象:可以使用for...in...语句进行循环的对象,比如字符串、列表、元组、字典以及迭代器、生成器都是可迭代对象
    ⑵迭代:就是从某个容器对象中逐个地读取元素,直到容器中没有更多元素为止
    ⑶序列:一个列表、字符串等
    ⑷非序列:字典、TXT文件等

2、Python中,for循环用于遍历一个可迭代对象中的所有元素
    ⑴循环内的语句段会针对可迭代对象中的每一个元素项目都执行一次。暂且可以将迭代对象想象成一个对象集合,我们可以一个个遍历里面的元素
    ⑵即:将可迭代对象中的元素依次一个一个的拿出来执行一遍for循环下的语句,直到执行完最后一个元素后,整个循环结束

3、for循环的基本语法格式如下:

    for iterating_var in sequence:
        statements(s)
    
    """    
    sequence是需要迭代的任意序列
    iterating_var是序列中需要遍历的元素(即序列中元素的变量名)
    statements(s)是待执行的语句块
    """

例5:使用while遍历序列中的元素

list = [12, 37, 5, 42, 8, 3]
n = 0
while n < len(list):
    print("当前字母是 %s" % list[n])
    n += 1

"""
当前字母是 12
当前字母是 37
当前字母是 5
当前字母是 42
当前字母是 8
当前字母是 3
"""

例5_1:使用for循环遍历

list = [12, 37, 5, 42, 8, 3]
for i in list:
    print("当前字母是 %s" % i)

"""
当前字母是 12
当前字母是 37
当前字母是 5
当前字母是 42
当前字母是 8
当前字母是 3
"""

注:
1、如果一个序列中包含一个表达式列表时,它需要首先计算,然后再进行遍历

2、可以看到,在循环遍历一个可迭代对象时,使用for循环比使用while循环简便得多
    ⑴Python中的for循环更适合用于遍历一个可迭代对象,比如遍历一个序列等
    ⑵Python中的while循环更适合针对某一条件进行循环

例6:遍历字典

tups = {"小明":"001","小红":"002"}
for name in tups:
    print("字典的键名为:" ,name)

"""
字典的键名为: 小明
字典的键名为: 小红
"""

例6_1:遍历字典(序列解包)

tups = {"小明":"001","小红":"002"}
for name,number in tups.items():  #使用序列解包
    print("%s : %s" % (name,number))

print("----------")

tups1 = {"小明":"001","小红":"002"}
for name in tups1:         #先遍历出字典的键,然后根据"字典[键名]"来索引出键对应的值
    print("%s : %s" % (name,tups1[name]))

"""
小红 : 002
小明 : 001
----------
小红 : 002
小明 : 001
"""

注:
1、单纯的对字典进行循环迭代时,只能对键进行迭代,若同时想得到键对应的值时只能通过字典索引的方式得到

2、第二个例子中先是通过items()函数得到由键值对组成元组,在对返回的元组利用序列解包的方式同时对键值对进行迭代

 

同时迭代两个序列(并行迭代)

例7:

name = ["小红","小张","小强"]
number = ["001","002","003"]
for student_ID in range(len(name)):
    print("学生的名字:%s,学号为: %s" % (name[student_ID],number[student_ID]))

"""
学生的名字:小红,学号为: 001
学生的名字:小张,学号为: 002
学生的名字:小强,学号为: 003
"""

例7_1:

name = ["小红","小张","小强"]
number = ["001","002","003"]
for student_name,student_ID in zip(name,number):
    print(student_name,"的学号是",student_ID)

"""
小红 的学号是 001
小张 的学号是 002
小强 的学号是 003
"""

注:
1、例例7_1中先通过函数zip()将两个序列打包成一个元组列表,再通过序列解包和迭代的方法得到对应学生的学号和名字

2、zip()函数可以作用于任意数量的序列,并且可以应付不等长的序列,当短序列用完时,就会停止

 

for循环与range()函数

1、内置函数range()是迭代数字序列的函数。它产生算术数列迭代器。生成一个从0开始到n-1的整数的序列。要获得序列的列表对象,它可以强制转换为list()
    ⑴range()函数的返回值为一个序列(Python2中返回的是一个列表)且生成的序列包含star参数但不会包含stop参数(包左不包右)

2、语法:

for number in range():
    print(number)

"""
range(star,stop,step) : 用于生成一个指定序列
参数star:表示生成的序列的开始数字,无此参数时,表示序列从0开始
参数stop:表示生成序列的结束数字
参数step:表示生成序列的递增数(该参数不能是浮点数),无此参数时,表示默认递增数为1
"""

例8:

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

print("--------------")

list = [1,2,3]
for n in range(len(list)):
    print(n)

"""
0
1
2
--------------
0
1
2
"""

 

for循环中使用else语句

在for循环中正常使用if...else语句:将if...else语句整个嵌套在for循环中来达到判断的作用,进而进行不同的处理

例9:

list = [1,2,3,4,5,6]
for i in list:
    if i > 3:
        print("当前数字大于3:",i)
    elif i == 3:
        print("当前数字等于3:",i)
    else:
        print("当前数字小于3:",i)
        
"""
当前数字小于3: 1
当前数字小于3: 2
当前数字等于3: 3
当前数字大于3: 4
当前数字大于3: 5
当前数字大于3: 6
"""

例9_1:for循环中也可以直接使用else语句

list = [1,2,3,4,5,6]
for n in list:
    print(n)
else:    #该else未在for循环中
    print("直接使用else:",n)#在编辑器中这个n警告提示,但不会报错,因为n是for内的变量,但是现在是在for循环外使用

"""
1
2
3
4
5
6
直接使用else: 6
"""

注:从上面这个例子可以看出
1、感觉把else语句放在for循环外这种写法是为了强调for循环遍历出来的最后一个元素(可以把这个元素单独拿来做其他事)

2、像这种写法感觉用得不是很多(else语句放在for循环外),可能会在特殊的场景中会用到这种写法。还是正常的使用if...else语句多好的(把if...else都放在for循环内)

3、如果在for和else之间(循环体)存在if,也不会影响for和else的关系。因为for的级别比if高,else又是一个攀附权贵的家伙,根本不在乎是否有if,以及是否执行了满足if条件的语句。else的眼里只有for,只要for顺利执行完毕,else就会屁颠儿屁颠儿地跑一遍

4、如何拆散for和else这对冤家呢?只有当for循环被break语句中断之后,才会跳过else语句

例9_2:

list = [1,2,3,4,5,6]
for x in list:
    if x > 3:
        print("当前数字大于3:",x)
else:
    print("使用if...else语句:",x)#在编辑器中这个x警告提示,但不会报错
    
"""
当前数字大于3: 4
当前数字大于3: 5
当前数字大于3: 6
使用if...else语句: 6
"""

例9_3:拆散for和else

for y in list:
    if y > 3:
        print("当前数字大于3:",y)
        break
    else:
        print("当前数字小于等于3:",y)
else:
    print("使用break语句:",y)#在编辑器中这个y警告提示,但不会报错
print('结束了')

"""
当前数字小于等于3: 1
当前数字小于等于3: 2
当前数字小于等于3: 3
当前数字大于3: 4
结束了
"""

注:
1、上面这个例子中还有一点需要注意:就是上面break语句的使用
    ⑴正常的break语句的作用是跳出整个循环:跳出整个循环,不会执行break语句下面的语句(与break属于同一个循环语句块的语句)。但还会执行break语句下面其他语句块的代码
    ⑵但是在上面例子中else语句实际上算是其他语句块了,但使用break后还是没有执行else语句,这种算是这种写法的特例吧(正常的应该是像后面的print语句一样照常执行,print语句就属于break下面的其他语句了)

2、总的来说:把else语句放在for循环外这种写法不常用,知道有这种写法就好了。我只是个弟弟,还是按照正常的来用


例9_4:在for条件语句为false或结束后没有被break中断时,执行else语句

list = ["xiaozhang","xiaohong"]
for name in list:
    if name == "xiao":
        print("名称: ",name)
        break
    print("当前名称: ",name)
else:  #与for语句为同一缩进
    print("没有循环数据了")
print("循环结束")

"""
当前名称:  xiaozhang
当前名称:  xiaohong
没有循环数据了
循环结束
"""

例9_5:

list = ["xiaozhang","xiaohong","xiao"]
for name in list:
    if name == "xiao":
        print("名称: ",name)
        break
    print("当前名称: ",name)
else:  #与for语句为同一缩进
    print("没有循环数据了")
print("循环结束")

"""
当前名称:  xiaozhang
当前名称:  xiaohong
名称:  xiao
循环结束
"""

 

 

break

1、break:终止当前循环并跳出整个循环

2、break语句用在while和for循环中

3、break语句用于跳出当前循环,并且不会再执行break下面的代码:只是不会执行该循环下的语句,会继续执行下面不属于循环的代码

4、break语句通过if语句来对条件进行判定,当if语句为True时,执行break语句

5、在使用while循环时,如果判断条件一直为True,那么一定需要在代码中写入break:避免称为死循环

例10:

str = ("hello")
for letter in str:
    if letter == "l": #判断是否满足某一条件,满足条件时跳出循环,不会执行break语句下面的语句(同以循环内的)
        break
    print(letter)

"""
h
e
"""

例10_2:

number = 10
while number > 2:
    if number == 6:
        break   #跳出整个循环,不会再执行下面的代码
    print(number)  #该条语句在循环内,跳出循环后,就不会再执行了
    number -= 1

print("跳出循环,继续执行循环外的代码")#该条语句不在循环内,因此跳出循环后,也会继续执行下面循环外的代码

"""
10
9
8
7
跳出循环,继续执行循环外的代码
"""

例10_3:

import random

number = random.randint(0,10)
print("正确结果为:",number)

guess = int(input("请输入你认为正确的数字:"))
while True:
    if guess == number:
        print("正确")
        break
    elif guess > number:
        print("稍微大了一点,需要再小一点")
        guess = int(input("您猜错了,请输入你认为正确的数字:"))
    else :
        print("稍微小了一点,需要再大一点")
        guess = int(input("您猜错了,请输入你认为正确的数字:"))

"""
正确结果为: 10
请输入你认为正确的数字:22
稍微大了一点,需要再小一点
您猜错了,请输入你认为正确的数字:3
稍微小了一点,需要再大一点
您猜错了,请输入你认为正确的数字:10
正确
"""

 

 

continue

1、continue:终止当前的循环,继续下一循环

2、continue语句用来告诉python跳过当前循环的剩余语句,然后继续进行下一轮循环

3、continue语句用在while和for循环中

4、continue语句通过if语句来对条件进行判定,当if语句为True时,执行continue语句

5、continue语句的作用为终止当前循环(不会执行continue下面的代码),并开始下一轮循环(重新开始)

例11:

number = 1
while number < 10:
    if number == 5:
        number += 1
        continue
    if number == 7:
        break
    print(number)
    number += 1

"""
1
2
3
4
6
"""

例11_2:

str = ("hello")
for letter in str:
    if letter == "l":
        continue
    print(letter)

"""
h
e
o
注:由输出结果来看,相比与break,使用continue语句只是跳过了某次循环 ,不会跳出整个循环
"""

 

 

备注

1、while循环和for循环两者的相同点在于都能循环做一件重复的事情。不同的是for循环是在序列穷尽时停止;while循环是在条件不成立时停止。

2、for 循环提供了python中最强大的循环结构(for循环是一种迭代循环机制,而while循环是条件循环迭代即重复相同的逻辑操作,每次操作都是基于上一次的结果,而进行的)

3、Python for循环可以遍历任何序列的项目,如一个列表或者一个字符串。

4、for循环可以用来遍历某一对象(遍历:通俗点说,就是把这个循环中的第一个元素到最后一个元素依次访问一次

5、一般来说for循环的执行过程为:迭代出一个元素后,继续执行for所属代码块,后面的代码块执行完后,在进行下一个迭代

例12:

list = [1,2,3,4]
list_1 = []
for num in list:
    list_1.append(num)
    print(list_1) 

"""
这段代码表示:遍历出一个元素后执行append()和prine(),然后继续遍历下一个元素...
[1]
[1, 2]
[1, 2, 3]
[1, 2, 3, 4]
"""

例13:

list = [1,2,3,4]
list_1 = []
for num in list:
    list_1.append(num)
print(list_1)  #print()的位置不同:执行完全部for后,再输出


"""
这段代码表示:遍历出一个元素后,执行append(),然后继续遍历下一个元素...直到遍历出最后一个元素
并执行append()后,循环结束,继续执行循环后的代码print()。因此此时打印的结果就是最后一次遍历并执行完append()后的结果

[1, 2, 3, 4]
"""

 

 

拓展

1、Python提供的另外一个循环结构就是for循环语句,Python提供的for循环语句和Java、C++等编程语言提供的for语句不同,Python中的for循环更像是shell或是脚本语言中的foreach循环。它可以遍历如列表、元组、字符串等序列成员(列表、元组、字符串也称为序列),也可以用在列表解析和生成器表达式中

2、for循环常用于遍历字符串、列表、元组、字典、集合等序列类型,逐个获取序列中的各个元素(用于遍历可迭代对象)

3、可迭代就是指任意可以使用 for 循环遍历的东西,可迭代意味着可以遍历,任何可以遍历的东西都是可迭代的。序列是一种常见的可迭代类型,如列表、元组、字符串等

4、Python 中的大部分东西都是可以迭代的,但是可以迭代并不意味着它是序列。如集合、字典、文件和生成器都是可迭代的,但是它们都不是序列

5、迭代器就是可以驱动可迭代对象的东西。你可以从任何可迭代对象中获得迭代器,你也可以使用迭代器来手动对它的迭代进行遍历

6、Python中,for循环用于遍历一个迭代对象的所有元素。循环内的语句段会针对迭代对象的每一个元素项目都执行一次。暂且可以将迭代对象想象成一个对象集合,我们可以一个个遍历(访问)里面的元素(将序列中的每个元素都拿出来执行一次)

7、while语句执行的具体流程为:首先判断条件表达式的值,其值为真(True)时,则执行代码块中的语句,当执行完毕后,再回过头来重新判断条件表达式的值是否为真,若仍为真,则继续重新执行代码块...如此循环,直到条件表达式的值为假(False),才终止循环

例14:有时使用for循环或while循环,会达到同样的目标

num = 0
while num < 5:
    print("hello")
    num += 1

for i in range(5):
    print("word")

"""
hello
hello
hello
hello
hello
word
word
word
word
word
"""

注:上面例子中分别使用了for循环和while循环打印一个字符串5次,但是个人感觉这种循环还是使用while来写好点

1、for循环用于遍历一个迭代对象的所有元素,即依次一个一个的访问可迭代对象中的元素:如果使用了for循环,但是又没有用到可迭代对象中的元素,所以感觉有点别扭且有点违背for循环的意义(自己理解的)

2、while循环用于判断一个条件是否成立,成立的话执行while循环语句,不成立就跳出循环:这个例子中使用while循环就很合适了

 

 

return语句与for循环、while循环一起使用

在实际场景中有很多时候我们需要遍历一些序列,然后将序列中满足条件的一些元素作为返回值返回。此时就会在for循环、while循环中使用return了

例15:

list = [1,2,3,4,5]

def func(data):
    for i in data:
        return i #return语句在for语句下面(属于for循环代码块)

print("return语句在for语句下面:",func(list))

#return语句在for语句下面: 1

注:从上面例子可看出
1、我们实际的需要的是返回所有遍历后的元素,但是实际上值返回了序列中的第一个元素(只遍历了一次)

2、之所以会出现这种情况是因为:当遍历出第一个元素后,执行"return i"语句,return语句的作用是结束函数调用(结束for循环:这里就跟break语句差不多了)。因此这里就只会执行一次遍历

例15_1:

#经过上面的例子,那换一种写法:将return语句放来跟for循环同一层级
list = [1,2,3,4,5]
def func1(data):
    for n in data:
        pass
    return n  #这种写编辑器不会报错但是有提示:return语句与for语句属于同一缩进


print("return语句与for语句属于同一缩进:",func1(list))

#return语句与for语句属于同一缩进: 5

注:从上面例子可看出
1、实际的数据还是与我们的预期不一样,并且在编辑器中会提示这种写法不合规矩

2、之所以会出现这种情况是因为:for循环与return是同一层级(属于相同的代码块:在执行逻辑上它们是并列关系)

3、因此上面例子实际流程是:执行完for循环后在执行return语句,for循环最后一次遍历出来的元素是5,当把元素5遍历出来后,执行for循环下面的语句(这里是pass),然后在从上到下执行与for循环同一层级的代码(这里的return语句),此时n=5,因此就只会返回5了
 

例15_2:解决办法

list = [1,2,3,4,5]

def func(data):
    dataList = []
    for i in data:
        dataList.append(i)
    return dataList

print(func(list))

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

注:
1、可以在for循环前面定义一个空列表,用来装for循环遍历出来的元素,等for循环执行完成后,再将整个列表返回

2、上面例子的执行流程就是:for循环遍历出来一个元素后,执行"dataList.append(i)",在进行下一次遍历....直到for循环完成后,执行与for循环同一层级的代码"return dataList"(将整个列表一次性返回)
    ⑴注:用来装遍历出来的元素的容器,必须定义在for循环之前,如果在循环内则会被初始化(进行下一次循环时别初始化)

3、Python for循环可以遍历任何序列的项目,如一个列表或者一个字符串
    ⑴for循环可以用来遍历某一对象(遍历:通俗点说,就是把这个循环中的第一个元素到最后一个元素依次访问一次)
    ⑵一般来说for循环的执行过程为:迭代出一个元素后,继续执行for所属代码块,后面的代码块(属于for循环代码块的代码)执行完后,在进行下一个迭代。直到所有元素遍历完成后,再执行下面与for循环同一层级的代码

4、虽然说这里输入和输出的列表都是一样的,感觉没什么实际意义。当然我这里只是举一个例子,实际中的场景应该也差不多,只是说属于for循环的代码块会比这复杂多(这里的dataList.append(i))

5、以后遇到了循环(for、while)与return一起使用时,就一定要想到使用一个容器来装遍历(处理)后的数据,不管符合条件的数据有几个,都要有容器

例15_3:

data = [{'CODE': '1005', 'VALUE': '测试1'}, {'CODE': '10051', 'VALUE': '测试2'}, {'CODE': None, 'VALUE': '测试3'}]


def func(data):
    # 因为会有多个字典,因此定义一个列表来装所有的字典
    data_list = []
    for each_data in data:
        data_dict = {}
        for key, value in each_data.items():
            # 将字典的键变为小写后添加到新字典中去
            data_dict[key.lower()] = value
        # 将新生成的字典添加到列表中去
        data_list.append(data_dict)
    # 最后统一返回大列表
    return data_list


res = func(data)
print(res)
print(data)

"""
[{'value': '测试1', 'code': '1005'}, {'value': '测试2', 'code': '10051'}, {'value': '测试3', 'code': None}]
[{'VALUE': '测试1', 'CODE': '1005'}, {'VALUE': '测试2', 'CODE': '10051'}, {'VALUE': '测试3', 'CODE': None}]
"""
"""
外循环:
    遍历出data中的第一个字典:dict1
        内循环:
            遍历出第一个字典中的第一组键值对:key1、value1
                内循环将第一个字典的第一组键值对中的key变为小写,并加入到新字典中
            遍历出第一个字典中的第二组键值对:key2、value2
                内循环将第一个字典的第一组键值对中的key变为小写,并加入到新字典中
            ...
            内循环结束
        将新字典加入到列表中
外循环:
    遍历出data中的第二个字典:dict2
        内循环:
            遍历出第二个字典中的第一组键值对:key1、value1
                内循环将第二个字典的第一组键值对中的key变为小写,并加入到新字典中
            遍历出第二个字典中的第二组键值对:key2、value2
                内循环将第二个字典的第一组键值对中的key变为小写,并加入到新字典中
            ...
            内循环结束
        将新字典加入到列表中
...
外循环结束
继续执行与外循环同层级的代码:这里是返回列表  
"""

 

 

return语句与for循环、if语句一起使用

需求

遍历传入的列表(嵌套了字典的列表)
    ⑴如果列表中的某个字典的"C"键值符合要求(这里是dict["C"] == "6"),则返回对应字典(前提:只有单个字典符合条件)
    ⑵如果列表中的所有字典的"C"键值都不符合要求(这里是dict["C"] == "6"),则返回False

例16:

dict = [{"A":"1","B":"2","C":"3"},{"A":"4","B":"5","C":"6"}]

def func(data):
    for eachDict in data:
        print("---",eachDict)
        if eachDict["C"] == "6":
            return eachDict
        else:
            return False

result = func(dict)
print(result)

"""
输出结果:
--- {'A': '1', 'B': '2', 'C': '3'}
False
"""

注:

1、可以看到这里实际的输出结果跟我们预期的结果是不一样的:列表中的第二个字典是满足要求的,但是返回的是False(走的else)

2、这个是因为:遍历出第一个字典时,此时这个字典时不满足要求的(不满足 if dict["C"] == "6"),因此它走的是else,并执行了"return False",执行return后for循环结束,不再继续遍历。因此根本就不会走到第二个字典那里了

3、因此正确代码流程是:遍历完整个列表中的所有字典后,都没有满足要求的字典,这个时候才return False

例16_1:

dict = [{"A":"1","B":"2","C":"3"},{"A":"4","B":"5","C":"6"}]

def func1(data):
    for eachDict in data:
        print("---",eachDict)
        if eachDict["C"] == "6":
            return eachDict
    else:
        return False

result1 = func1(dict)
print(result1)

"""
--- {'A': '1', 'B': '2', 'C': '3'}
--- {'A': '4', 'B': '5', 'C': '6'}
{'A': '4', 'B': '5', 'C': '6'}
"""

注:
1、所以啊,在for循环或者while循环中使用return一定要注意return的使用位置以及分清楚具体的数据、场景是什么样的啊,想清楚所需要的代码流程是什么

2、当然这种写法的话就必须满足:列表里面只有一个字典满足条件(dict["C"] == "6"),如果有多个字典满足条件那么就又有问题了

例17:

dict = [{"A":"1","B":"2","C":"3"},{"A":"4","B":"5","C":"6"},{"A":"7","B":"8","C":"6"}]

def func(data):
    for eachDict in data:
        print("---",eachDict)
        if eachDict["C"] == "6":
            return eachDict
    else:
        return False

result = func(dict)
print(result)

"""
--- {'B': '2', 'C': '3', 'A': '1'}
--- {'B': '5', 'C': '6', 'A': '4'}
{'B': '5', 'C': '6', 'A': '4'}
字典中有两个符合条件,但只返回了一个
"""


例17_1:

"""
需求:
遍历传入的列表(嵌套了字典的列表)
    ⑴如果列表中的某些字典的"C"键值符合要求(这里是dict["C"] == "6"),则将其加到一个列表中并返回这个列表
    ⑵如果列表中的所有字典的"C"键值都不符合要求(这里是dict["C"] == "6"),则返回False

"""
dict = [{"A":"1","B":"2","C":"3"},{"A":"4","B":"5","C":"6"},{"A":"7","B":"8","C":"6"}]

resultList = []
def func(data):
    for eachDict in data:
        print("---",eachDict)
        if eachDict["C"] == "6":
            resultList.append(eachDict)
    #else:    #这个时候else就不能在这里写else了,这样写的话return resultList就没意义了(因为不管怎么都会执行else)
        #return False
    return resultList

result = func(dict)
print(result)
"""
--- {'C': '3', 'B': '2', 'A': '1'}
--- {'C': '6', 'B': '5', 'A': '4'}
--- {'C': '6', 'B': '8', 'A': '7'}
[{'C': '6', 'B': '5', 'A': '4'}, {'C': '6', 'B': '8', 'A': '7'}]
"""

注:
1、如果要实现这个需求的话,肯定就不能按照上面这里例子这样来写了,因为这些写的话是不能同时满足需求1和需求2的,因此只能换一个思路来实现

2、思路:因为要把满足条件的字典添加到列表中,如果for循环全部完成之后,对列表进行判断,如果列表还是空列表的话,说明所有字典都不满足条件,这个时候就可以返回False了

例17_2:

"""
需求:
遍历传入的列表(嵌套了字典的列表)
    ⑴如果列表中的某个字典的"C"键值符合要求(这里是dict["C"] == "6"),则将其加到一个列表中并返回这个列表
    ⑵如果列表中的所有字典的"C"键值都不符合要求(这里是dict["C"] == "6"),则返回False

"""
dict = [{"A":"1","B":"2","C":"3"},{"A":"4","B":"5","C":"6"},{"A":"7","B":"8","C":"6"}]


def func(data):
    resultList = []
    for eachDict in data:
        print("---",eachDict)
        if "C" in eachDict and eachDict["C"] == "6": #判断"C"键在字典中并且"C"键值为6
            resultList.append(eachDict)
    if resultList:
        return resultList
    else:
        return False
result = func(dict)
print(result)

"""
--- {'C': '3', 'B': '2', 'A': '1'}
--- {'C': '6', 'B': '5', 'A': '4'}
--- {'C': '6', 'B': '8', 'A': '7'}
[{'C': '6', 'B': '5', 'A': '4'}, {'C': '6', 'B': '8', 'A': '7'}]
"""

例11_3:

dict = [{"A":"1","B":"2","C":"3"},{"A":"4","B":"5","C":"1"},{"A":"7","B":"8","C":"1"}]


def func(data):
    resultList = []
    for eachDict in data:
        print("---",eachDict)
        if "C" in eachDict and eachDict["C"] == "6": #判断"C"键在字典中并且"C"键值为6
            resultList.append(eachDict)
    if resultList:
        return resultList
    else:
        return False
result = func(dict)
print(result)

"""
--- {'B': '2', 'A': '1', 'C': '3'}
--- {'B': '5', 'A': '4', 'C': '1'}
--- {'B': '8', 'A': '7', 'C': '1'}
False
"""

注:
1、Python中的for循环提供了python中最强大的循环结构(for循环是一种迭代循环机制,而while循环是条件循环,迭代即重复相同的逻辑操作,每次操作都是基于上一次的结果,而进行的)

2、Python for循环可以遍历任何序列的项目,如一个列表或者一个字符串
    ⑴for循环可以用来遍历某一对象(遍历:通俗点说,就是把这个循环中的第一个元素到最后一个元素依次访问一次)
    ⑵一般来说for循环的执行过程为:迭代出一个元素后,继续执行for循环所属代码块,后面的代码块(属于for循环代码块的代码)执行完后,在进行下一个迭代。所有元素遍历完成后,再执行与for循环同一层级的代码
    ⑶比如这个例子中的for循环与if...else处于相同缩进的,是并列关系的(同一代码块),因此会执行完for循环后再执行if...else

3、当return语句用在for循环、while循环中时,一定要注意return的使用位置啊!!!

例12:

infos= [{'code': '1005', 'value': '测试1'}, {'code': '10051', 'value': '测试2'},{ 'code': None,'value': '测试3'}]

def Parse(data):
    DataCodeList = []
    for info in data:
        if info["code"] == None:
            print("===数据中无code属性,直接返回value值===:",info["value"])
            DataCode = info["value"]
            #DelyCodeList.append(DelyCode)
        else:
            if info["code"] == '1005':
                print("===数据中code属性且其值为1005,返回指定值:Success")
                DataCode = "Success"
                #DelyCodeList.append(DelyCode)
            else:
                print("===数据中code属性且其值不为1005,返回指定值:Fail")
                DataCode = "Fail"
                #DelyCodeList.append(DelyCode)
        #这里主要是想说明下:DelyCodeList.append(DelyCode)放在这里(if...else...语句结束后)跟放在每个判断条件里面是一样的
        #不管输入的info满足那个条件,在判断完后继续往下执行,都会执行这步(都在for循环内)。当然如果上面判断结果有不需要加入到列表中的,就不能写在这里了
        DataCodeList.append(DataCode)
    #for循环结束后,根据前面输出的DelyCodeList中元素个数来确定是否需要拼接列表里面的元素
    if len(DataCodeList) > 1:
        DelyCode = {"info":",".join(DataCodeList)}
        return DelyCode
    else:
        DelyCode = {"info":DataCodeList[0]}
        return DelyCode

DelyCode = Parse(infos)
print(DelyCode)

"""
===数据中code属性且其值为1005,返回指定值:Success
===数据中code属性且其值不为1005,返回指定值:Fail
===数据中无code属性,直接返回value值===: 测试3
{'info': 'Success,Fail,测试3'}
"""

例12_1:

data = [{"A":"1","B":"2","C":"hello"},{"A":"4","B":"5","C":"world"}]

def func(data):
    new_list = []
    for each_dict in data:
        if isinstance(each_dict,dict):
            new_dict = {}
            for key,value in each_dict.items():
                if key == "C":
                    new_dict[key] = value.upper()
                else:
                    new_dict[key] = value
            new_list.append(new_dict)
        else:
            raise TypeError("传入数据类型错误")
    # 必须在这里return
    return new_list

print(func(data))

#[{'C': 'HELLO', 'A': '1', 'B': '2'}, {'C': 'WORLD', 'A': '4', 'B': '5'}]

例12_2:

import datetime


def DealSelectData(selectDatas):
    # 定义一个大列表来装所有子数据列表:是一个嵌套了列表的列表
    selectDataLists = []
    for selectData in selectDatas:
        # 定义一个小列表来装该条数据
        selectDataList = []
        for eachData in selectData:
            # 如果字段值为整形、浮点型、字符串:那么不需要整理,直接加入到该条数据列表中
            if isinstance(eachData, int) == True or isinstance(eachData, str) == True or isinstance(eachData,float) == True:
                pass
                # selectDataList.append(eachData)
            # 如果字段值为datetime类型:那么就将其转为字符串型的时间值
            elif isinstance(eachData, datetime.datetime):
                eachData = eachData.strftime('%Y-%m-%d %H:%M:%S')
                # selectDataList.append(eachData)
            # 如果字段值为None:那么就添加null,毕竟数据库中空值表示为null
            elif eachData is None:
                eachData = "null"
                # selectDataList.append("null")
            else:
                print("该类型的值未整理:请添加相应代码")
            # 这里想说明下append()语句放在这里与放在每个判断条件中是一样的:都是内循环语句块内(前提条件是每个判断后都会有添加到列表的操作)
            # 将处理后的元素加到小列表中
            selectDataList.append(eachData)
        # 将小列表添加到大列表中
        selectDataLists.append(selectDataList)
    print("整理后的查询数据为:", selectDataLists)
    return selectDataLists


data = [(1, '张三', 'China', datetime.datetime(2020, 9, 10, 20, 34, 23),
         datetime.datetime(2020, 7, 20, 20, 34, 25, 269000), 1, 4, 2, 2424),
        (
        2, '李四', 'China', datetime.datetime(2022, 7, 5, 20, 34, 58), datetime.datetime(2020, 7, 19, 12, 35, 1), 2, 2, 3,
        7747),
        (3, '王五', 'China', datetime.datetime(2020, 7, 20, 21, 18, 16), datetime.datetime(2020, 7, 20, 21, 18, 16), 2, 3,
         4, 4242)]

DealSelectData(data)
"""
整理后的查询数据为: [[1, '张三', 'China', '2020-09-10 20:34:23', '2020-07-20 20:34:25', 1, 4, 2, 2424], 
[2, '李四', 'China', '2022-07-05 20:34:58', '2020-07-19 12:35:01', 2, 2, 3, 7747], 
[3, '王五', 'China', '2020-07-20 21:18:16', '2020-07-20 21:18:16', 2, 3, 4, 4242]]
"""

注:
经for循环遍历出来一个元素后,使用该元素将该for循环下所属全部语句都执行完后才会继续遍历出下一个元素,下一个元素遍历出来后继续将该for循环下所属全部代码执行一次
    ⑴selectDataList.append(eachData):这条语句是属于内循环且是内循环的最后一条语句。因此,每个遍历出来的元素经过if语句判断后,都会执行这条语句,这条语句执行完成后才会遍历下一个元素
    ⑵selectDataLists.append(selectDataList):这条语句与内循环一样,都是属于外循环的(与内循环同一缩进)。在内循环执行完成后,继续执行这条语句。这条语句执行完成后才会遍历下一个元素
    ⑶外循环执行一次,内循环要全部执行完成:外循环遍历出来一个元素,这个元素经内循环继续遍历。需要内循环将这个元素全部遍历完成后,才会开始下一个外循环
    ⑷不管是什么循环,在循环执行完成后,代码继续往下执行:(除了特殊逻辑,代码都是由上往下执行的:注意缩进)

 

python嵌套字典中, 通过key值获取所有的对应的value值

1、有时候面对一些需要处理的数据, 会是一种字典中嵌套字典的数据, 然后里面可能有多个key相同的value都是需要获取的, 比如json中的部分值

2、key对应的value的类型有很多, 比如有可能是str的‘abc’, 也有可能是int的123, 也有可能是dict的{‘1’: 123}还有可能是list的[1, 2, 3]

3、大概思路是迭代当前dict的所有元素, 对元素挨个依次比较key与所需要的key, 如果相同就保存在输出的list中。然后如果遇到value是属于又一个dict, 则进行一个回归, 再次对这个子dict进行相同操作. 最后循环结束后输出list

例13:

data = {
    "2": {
        "a": [
            11111,
            22222
        ]
    },
    "3": ["2",2,3],
    "b": 1,
    "a": "ok1"
}
def get_json_value_by_key(in_json, target_key, results=None):
    """
    results这个列表不能定义在函数内:不然每次回调时,会重置
    因此只能定义为默认参数,但是默认参数为可变对象时,前面的调用结果会影响后面的结果,因此采用这种写法
    """
    if results == None:
        results = []
    if isinstance(in_json, dict):  # 如果输入数据的格式为dict
        for key in in_json.keys():  # 循环获取key
            # 如果当前key与目标key相同就将当前key的value添加到输出列表
            if key == target_key:
                results.append(in_json[key])
            # 不管当前key与目标key是否相同:都要继续回调(继续获取里面的值)
                get_json_value_by_key(in_json[key], target_key, results=results)  # 回归当前key对于的value
            else:
                get_json_value_by_key(in_json[key], target_key, results=results)

    elif isinstance(in_json, list):  # 如果输入数据格式为list
        for data1 in in_json:  # 循环当前列表
            get_json_value_by_key(data1, target_key, results=results)  # 回归列表的当前的元素

    return results
a = get_json_value_by_key(data, '2')
print(a)
b = get_json_value_by_key(data, '3')
print(b)
c = get_json_value_by_key(data, 'a')
print(c)
d = get_json_value_by_key(data, 'b')
print(d)

"""
[{'a': [11111, 22222]}]
[['2', 2, 3]]
['ok1', [11111, 22222]]
[1]
"""

 

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 创作都市 设计师:CSDN官方博客 返回首页