序列操作函數(shù) all() 和 any()

說明: 將下面的代碼運行以后, 得到的結果, 就是all()函數(shù)和any()函數(shù)的使用方法說明,很詳細哦。

'''
all() 用來判斷給定的可迭代參數(shù)中所有的"元素"是否都為 Ture,
      具體判斷方法: 至少存在一個判斷結果為False的元素, 最后結果才是False,否則為True.
      (反證法,逐一判斷元素是否為false; 沒有元素時,理解為沒有判斷結果為false的元素,故結果為true)
      參數(shù)是'元組或列表',
      若元素是0、空、false, 結果就是返回 False
'''
print('\n1. all()函數(shù)的使用-------------------------\n')
print('-----當參數(shù)是列表時-----\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(): # 定義函數(shù)
    j=1
    for item in L:
        print('li{}={}'.format(j,item))
        j+=1
        pass
    pass
printL() # 調(diào)用函數(shù)
# print(all([])) # 沒有元素=>沒有判斷結果是False的元素=>最后的判斷結果是True.
print() # 換行
# print('li1={}\nli2={}\nli3={}\nli4={}\nli5={}\nli6={}'.format(li1,li2,li3,li4,li5,li6))
print('-----當參數(shù)為列表時, all()函數(shù)的使用情況分析如下:-----\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('列表{}, 元素中函數(shù)False項, 返回結果為{}'.format(li6,all(li6)))
print() #換行
print('-----當參數(shù)是元組時-----\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(): # 定義一個函數(shù), 用來打印元組內(nèi)的各項元素
    '''
    輸出元組的各項元素
    :格式:例如:tuple2=(0,)
    '''
    i=1
    for item in y:
        print('tuple{}={}'.format(i,item))
        i+=1
    pass
printTup()  # 調(diào)用函數(shù), 輸出元組內(nèi)的各項元素
print() # 換行
print('-----當參數(shù)為元組時,all()函數(shù)的使用情況分析如下:------\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)
      參數(shù)是'元組或列表'
      若其元素中存在0、空、false以外的項, 結果都要返回 True
'''
print('2. any()函數(shù)的使用-------------------------\n')
print('-----當參數(shù)是列表時-----\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('-----當參數(shù)是列表時, any()函數(shù)使用情況分析如下:-----\n')
L2=[li1,li2,li3,li4,li5,li6,li7]
def printRes():
    '''
    打印any()函數(shù)的使用情況分析
    :判斷條件:至少存在一個判斷結果為True的元素, 最后的結果才是True, 否則為False
    :打印注釋:給出判斷結果的原因說明
    '''
    x=1
    for item in L2:
        print('列表li{}={}, 使用any()函數(shù),返回的結果是{}'.format(x,item,any(item)))
        if any(item)==False:
            print('因為沒有判斷結果是True的元素, 所以返回結果是False\n')
            pass
        else:
            print('因為有判斷結果是True的元素, 所以返回的結果是True\n')
        x+=1
        pass
    pass
printRes() # 調(diào)用函數(shù)
# print(any([])) # 沒有元素=>沒有判斷結果是true的元素=>最后的判斷結果是False.
print() #換行
print('-----當參數(shù)是元組時-----\n-----我們先定義一些特殊情況的元組-----\n')
tup1=()
tup2=(0,)
tup3=('',)
tup4=(False,)
tup5=(0,'',False)
tup6=(1,0,'',False)
tup7=(0,True,'',False)
print('-----當參數(shù)是元組時, any()函數(shù)的使用情況分如下:-------\n')
i=[tup1,tup2,tup3,tup4,tup5,tup6,tup7] # 將上面的7個元組, 放進列表i內(nèi), 便于后面的操作
def printLi(): # 定義一個函數(shù), 輸出i的各項元素, 也就是打印tup1~tup7, 按格式輸出
    '''
    輸出列表i內(nèi)的元素
    :格式:例如:tup2=(0,)
    '''
    x=1     # 定義一個函數(shù)內(nèi)部變量, 便于循環(huán)時使用
    for item in i:
        print('tup{}={}'.format(x,item)) # 格式化輸出, 按照指定的格式進行打印
        x+=1 # 為了使循環(huán)打印的結果正確, 必須自增1
printLi() # 調(diào)用函數(shù)
print() # 換行
Tup=[tup1,tup2,tup3,tup4,tup5,tup6,tup7]
def printAns():
    '''
    打印any()函數(shù)的使用情況分析
    :判斷條件:至少存在一個判斷結果為True的元素, 最后的結果才是True, 否則為False
    :打印注釋:給出判斷結果的原因說明
    '''
    x=1
    for item in Tup:
        print('元組tup{}={}, 使用any()函數(shù),返回的結果是{}'.format(x,item,any(item)))
        if any(item)==False:
            print('因為沒有判斷結果是True的元素, 所以返回結果是False\n')
            pass
        else:
            print('因為有判斷結果是True的元素, 所以返回的結果是True\n')
        x+=1
        pass
    pass
printAns() # 調(diào)用函數(shù)
print() # 換行

輸出的結果如下:

1. all()函數(shù)的使用-------------------------

-----當參數(shù)是列表時-----
-----我們先定義一些特殊的列表-----

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

-----當參數(shù)為列表時, all()函數(shù)的使用情況分析如下:-----

列表[], 沒有元素, 所以元素中不含"0/空/false", 返回結果為True
列表[0], 元素為0, 返回結果為False
列表[1, 2, 0], 元素中含有0項, 返回結果為False
列表[''], 元素為"空"字符串, 返回結果為False
列表[1, ''], 元素中含有"空"字符串, 返回結果為False
列表[12, False], 元素中函數(shù)False項, 返回結果為False

-----當參數(shù)是元組時-----
-----我們先定義一些特殊情況的元組-----

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

-----當參數(shù)為元組時,all()函數(shù)的使用情況分析如下:------

元組(), 沒有元素,所以元素中不含"0/空/false", 返回結果為True
元組(0,), 元素為0, 返回結果為False
元組(1, 2, 0), 元素中含有0項, 返回結果為False
元組('',), 元素為"空"字符串, 返回結果為False
元組(1, ''), 元素中含有"空"字符串, 返回結果為False
元組(23, False), 元素中含有False項,返回結果為False


2. any()函數(shù)的使用-------------------------

-----當參數(shù)是列表時-----
-----我們先定義一些特殊情況的列表-----

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

-----當參數(shù)是列表時, any()函數(shù)使用情況分析如下:-----

列表li1=[], 使用any()函數(shù),返回的結果是False
因為沒有判斷結果是True的元素, 所以返回結果是False

列表li2=[0], 使用any()函數(shù),返回的結果是False
因為沒有判斷結果是True的元素, 所以返回結果是False

列表li3=[''], 使用any()函數(shù),返回的結果是False
因為沒有判斷結果是True的元素, 所以返回結果是False

列表li4=[False], 使用any()函數(shù),返回的結果是False
因為沒有判斷結果是True的元素, 所以返回結果是False

列表li5=[0, False, ''], 使用any()函數(shù),返回的結果是False
因為沒有判斷結果是True的元素, 所以返回結果是False

列表li6=[0, False, '', 1], 使用any()函數(shù),返回的結果是True
因為有判斷結果是True的元素, 所以返回的結果是True

列表li7=[True, 0, '', False], 使用any()函數(shù),返回的結果是True
因為有判斷結果是True的元素, 所以返回的結果是True


-----當參數(shù)是元組時-----
-----我們先定義一些特殊情況的元組-----

-----當參數(shù)是元組時, any()函數(shù)的使用情況分如下:-------

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

元組tup1=(), 使用any()函數(shù),返回的結果是False
因為沒有判斷結果是True的元素, 所以返回結果是False

元組tup2=(0,), 使用any()函數(shù),返回的結果是False
因為沒有判斷結果是True的元素, 所以返回結果是False

元組tup3=('',), 使用any()函數(shù),返回的結果是False
因為沒有判斷結果是True的元素, 所以返回結果是False

元組tup4=(False,), 使用any()函數(shù),返回的結果是False
因為沒有判斷結果是True的元素, 所以返回結果是False

元組tup5=(0, '', False), 使用any()函數(shù),返回的結果是False
因為沒有判斷結果是True的元素, 所以返回結果是False

元組tup6=(1, 0, '', False), 使用any()函數(shù),返回的結果是True
因為有判斷結果是True的元素, 所以返回的結果是True

元組tup7=(0, True, '', False), 使用any()函數(shù),返回的結果是True
因為有判斷結果是True的元素, 所以返回的結果是True