Python | 序列操作函数 all() 和 any()

序列操作函数 all() 和 any()

说明: 将下面的代码运行以后, 得到的结果, 就是all()函数和any()函数的使用方法说明,很详细哦。

'''
all() 用来判断给定的可迭代参数中所有的"元素"是否都为 Ture,
      具体判断方法: 至少存在一个判断结果为False的元素, 最后结果才是False,否则为True.
      (反证法,逐一判断元素是否为false; 没有元素时,理解为没有判断结果为false的元素,故结果为true)
      参数是'元组或列表',
      若元素是0、空、false, 结果就是返回 False
'''
print('\n1. all()函数的使用-------------------------\n')
print('-----当参数是列表时-----\n-----我们先定义一些特殊的列表-----\n')
li1=[] # 空列表,没有元素,所以元素不含0\空\false,所以结果是true
li2=[0] # 元素为0
li3=[1,2,0] # 元素中含有0项
li4=[''] # 元素为'空'字符串
li5=[1,''] # 元素中含有'空'字符串
li6=[12,False] # 元素中含有False项
L=[li1,li2,li3,li4,li5,li6]
def printL(): # 定义函数
    j=1
    for item in L:
        print('li{}={}'.format(j,item))
        j+=1
        pass
    pass
printL() # 调用函数
# print(all([])) # 没有元素=>没有判断结果是False的元素=>最后的判断结果是True.
print() # 换行
# print('li1={}\nli2={}\nli3={}\nli4={}\nli5={}\nli6={}'.format(li1,li2,li3,li4,li5,li6))
print('-----当参数为列表时, all()函数的使用情况分析如下:-----\n')
print('列表{}, 没有元素, 所以元素中不含"0/空/false", 返回结果为{}'.format(li1,all(li1)))
print('列表{}, 元素为0, 返回结果为{}'.format(li2,all(li2)))
print('列表{}, 元素中含有0项, 返回结果为{}'.format(li3,all(li3)))
print('列表{}, 元素为"空"字符串, 返回结果为{}'.format(li4,all(li4)))
print('列表{}, 元素中含有"空"字符串, 返回结果为{}'.format(li5,all(li5))) 
print('列表{}, 元素中函数False项, 返回结果为{}'.format(li6,all(li6)))
print() #换行
print('-----当参数是元组时-----\n-----我们先定义一些特殊情况的元组-----\n')
tuple1=() # 空列表,没有元素,所以元素不含0\空\false,所以结果是true
tuple2=(0,) # 元素为0
tuple3=(1,2,0) # 元素中含有0项
tuple4=('',) # 元素为'空'字符串
tuple5=(1,'') # 元素中含有'空'字符串
tuple6=(23,False) # 元素中含有False项
y=(tuple1,tuple2,tuple3,tuple4,tuple5,tuple6)
def printTup(): # 定义一个函数, 用来打印元组内的各项元素
    '''
    输出元组的各项元素
    :格式:例如:tuple2=(0,)
    '''
    i=1
    for item in y:
        print('tuple{}={}'.format(i,item))
        i+=1
    pass
printTup()  # 调用函数, 输出元组内的各项元素
print() # 换行
print('-----当参数为元组时,all()函数的使用情况分析如下:------\n')
print('元组{}, 没有元素,所以元素中不含"0/空/false", 返回结果为{}'.format(tuple1,all(tuple1))) 
print('元组{}, 元素为0, 返回结果为{}'.format(tuple2,all(tuple2)))
print('元组{}, 元素中含有0项, 返回结果为{}'.format(tuple3,all(tuple3)))
print('元组{}, 元素为"空"字符串, 返回结果为{}'.format(tuple4,all(tuple4)))
print('元组{}, 元素中含有"空"字符串, 返回结果为{}'.format(tuple5,all(tuple5)))
print('元组{}, 元素中含有False项,返回结果为{}'.format(tuple6,all(tuple6)))
print() # 换行
print() # 换行
'''
any() 如果有任意一个是true,则返回true,
      具体判断方法: 任意一个元素为True, 结果为True, 否则结果为False.
      (反证法,逐一判断元素是否为true; 没有元素时,理解为没有判断结果为true的元素,故结果为false)
      参数是'元组或列表'
      若其元素中存在0、空、false以外的项, 结果都要返回 True
'''
print('2. any()函数的使用-------------------------\n')
print('-----当参数是列表时-----\n-----我们先定义一些特殊情况的列表-----\n')
li1=[]
li2=[0]
li3=['']
li4=[False]
li5=[0,False,'']
li6=[0,False,'',1]
li7=[True,0,'',False]
print('li1={}\nli2={}\nli3={}\nli4={}\nli5={}\nli6={}\nli7={}\n'.format(li1,li2,li3,li4,li5,li6,li7))
print('-----当参数是列表时, any()函数使用情况分析如下:-----\n')
L2=[li1,li2,li3,li4,li5,li6,li7]
def printRes():
    '''
    打印any()函数的使用情况分析
    :判断条件:至少存在一个判断结果为True的元素, 最后的结果才是True, 否则为False
    :打印注释:给出判断结果的原因说明
    '''
    x=1
    for item in L2:
        print('列表li{}={}, 使用any()函数,返回的结果是{}'.format(x,item,any(item)))
        if any(item)==False:
            print('因为没有判断结果是True的元素, 所以返回结果是False\n')
            pass
        else:
            print('因为有判断结果是True的元素, 所以返回的结果是True\n')
        x+=1
        pass
    pass
printRes() # 调用函数
# print(any([])) # 没有元素=>没有判断结果是true的元素=>最后的判断结果是False.
print() #换行
print('-----当参数是元组时-----\n-----我们先定义一些特殊情况的元组-----\n')
tup1=()
tup2=(0,)
tup3=('',)
tup4=(False,)
tup5=(0,'',False)
tup6=(1,0,'',False)
tup7=(0,True,'',False)
print('-----当参数是元组时, any()函数的使用情况分如下:-------\n')
i=[tup1,tup2,tup3,tup4,tup5,tup6,tup7] # 将上面的7个元组, 放进列表i内, 便于后面的操作
def printLi(): # 定义一个函数, 输出i的各项元素, 也就是打印tup1~tup7, 按格式输出
    '''
    输出列表i内的元素
    :格式:例如:tup2=(0,)
    '''
    x=1     # 定义一个函数内部变量, 便于循环时使用
    for item in i:
        print('tup{}={}'.format(x,item)) # 格式化输出, 按照指定的格式进行打印
        x+=1 # 为了使循环打印的结果正确, 必须自增1
printLi() # 调用函数
print() # 换行
Tup=[tup1,tup2,tup3,tup4,tup5,tup6,tup7]
def printAns():
    '''
    打印any()函数的使用情况分析
    :判断条件:至少存在一个判断结果为True的元素, 最后的结果才是True, 否则为False
    :打印注释:给出判断结果的原因说明
    '''
    x=1
    for item in Tup:
        print('元组tup{}={}, 使用any()函数,返回的结果是{}'.format(x,item,any(item)))
        if any(item)==False:
            print('因为没有判断结果是True的元素, 所以返回结果是False\n')
            pass
        else:
            print('因为有判断结果是True的元素, 所以返回的结果是True\n')
        x+=1
        pass
    pass
printAns() # 调用函数
print() # 换行

输出的结果如下:

1. all()函数的使用-------------------------

-----当参数是列表时-----
-----我们先定义一些特殊的列表-----

li1=[]
li2=[0]
li3=[1, 2, 0]
li4=['']
li5=[1, '']
li6=[12, False]

-----当参数为列表时, all()函数的使用情况分析如下:-----

列表[], 没有元素, 所以元素中不含"0/空/false", 返回结果为True
列表[0], 元素为0, 返回结果为False
列表[1, 2, 0], 元素中含有0项, 返回结果为False
列表[''], 元素为"空"字符串, 返回结果为False
列表[1, ''], 元素中含有"空"字符串, 返回结果为False
列表[12, False], 元素中函数False项, 返回结果为False

-----当参数是元组时-----
-----我们先定义一些特殊情况的元组-----

tuple1=()
tuple2=(0,)
tuple3=(1, 2, 0)
tuple4=('',)
tuple5=(1, '')
tuple6=(23, False)

-----当参数为元组时,all()函数的使用情况分析如下:------

元组(), 没有元素,所以元素中不含"0/空/false", 返回结果为True
元组(0,), 元素为0, 返回结果为False
元组(1, 2, 0), 元素中含有0项, 返回结果为False
元组('',), 元素为"空"字符串, 返回结果为False
元组(1, ''), 元素中含有"空"字符串, 返回结果为False
元组(23, False), 元素中含有False项,返回结果为False


2. any()函数的使用-------------------------

-----当参数是列表时-----
-----我们先定义一些特殊情况的列表-----

li1=[]
li2=[0]
li3=['']
li4=[False]
li5=[0, False, '']
li6=[0, False, '', 1]
li7=[True, 0, '', False]

-----当参数是列表时, any()函数使用情况分析如下:-----

列表li1=[], 使用any()函数,返回的结果是False
因为没有判断结果是True的元素, 所以返回结果是False

列表li2=[0], 使用any()函数,返回的结果是False
因为没有判断结果是True的元素, 所以返回结果是False

列表li3=[''], 使用any()函数,返回的结果是False
因为没有判断结果是True的元素, 所以返回结果是False

列表li4=[False], 使用any()函数,返回的结果是False
因为没有判断结果是True的元素, 所以返回结果是False

列表li5=[0, False, ''], 使用any()函数,返回的结果是False
因为没有判断结果是True的元素, 所以返回结果是False

列表li6=[0, False, '', 1], 使用any()函数,返回的结果是True
因为有判断结果是True的元素, 所以返回的结果是True

列表li7=[True, 0, '', False], 使用any()函数,返回的结果是True
因为有判断结果是True的元素, 所以返回的结果是True


-----当参数是元组时-----
-----我们先定义一些特殊情况的元组-----

-----当参数是元组时, any()函数的使用情况分如下:-------

tup1=()
tup2=(0,)
tup3=('',)
tup4=(False,)
tup5=(0, '', False)
tup6=(1, 0, '', False)
tup7=(0, True, '', False)

元组tup1=(), 使用any()函数,返回的结果是False
因为没有判断结果是True的元素, 所以返回结果是False

元组tup2=(0,), 使用any()函数,返回的结果是False
因为没有判断结果是True的元素, 所以返回结果是False

元组tup3=('',), 使用any()函数,返回的结果是False
因为没有判断结果是True的元素, 所以返回结果是False

元组tup4=(False,), 使用any()函数,返回的结果是False
因为没有判断结果是True的元素, 所以返回结果是False

元组tup5=(0, '', False), 使用any()函数,返回的结果是False
因为没有判断结果是True的元素, 所以返回结果是False

元组tup6=(1, 0, '', False), 使用any()函数,返回的结果是True
因为有判断结果是True的元素, 所以返回的结果是True

元组tup7=(0, True, '', False), 使用any()函数,返回的结果是True
因为有判断结果是True的元素, 所以返回的结果是True