Develop Reference

Creating an OR logic function with a list composed of bool functions Python

I want to write a function that checks if the True boolena statement is within all_vals if there is a True value then the code will yes if not the code will output no, essentially creating an or statement. The code below does not work how would I be able to modify it so that it will get the Expected output below?
def vals(all_vals):
for x in all_vals:
if True in all_vals:
print('yes')
else:
print('no')
a = [True, True, True]
b = [True, False, True, True, False]
c = [False, False]
d = [True, False]
vals([a,b,c,d])
Expected Output:
yes
yes
no
yes

Instead of: if True in all_vals: you need if True in x: like this:
def vals(all_vals):
for x in all_vals:
if True in x:
print('yes')
else:
print('no')
a = [True, True, True]
b = [True, False, True, True, False]
c = [False, False]
d = [True, False]
vals([a,b,c,d])
Also you can shorten your code durastically by instead using:
vals = lambda all_vals: print("\n".join(['yes' if True in i else 'no' for i in all_vals]))
a = [True, True, True]
b = [True, False, True, True, False]
c = [False, False]
d = [True, False]
vals([a,b,c,d])
Output:
yes
yes
no
yes

def vals(all_vals):
for x in all_vals:
if True in x: # <--- Your typo here
print("yes")
else:
print("no")
a = [True, True, True]
b = [True, False, True, True, False]
c = [False, False]
d = [True, False]
vals([a, b, c, d])

How to get index of numpy multidimensional array in reverse order?

For example I have this np.array:
[[True, True, False, False]
[True, False, True, False]
[False, True, False, True]
[False, False, True, True]]
I want to get the the first index that is True in each row but counting from the back of the row. So expected output is a (4,) array corresponding to each row:
[1, # First index that is True is at index 1
2, # First index that is True is at index 2
3, # First index that is True is at index 3
3] # First index that is True is at index 3

a = np.array(
[[True, True, False, False],
[True, False, True, False],
[False, True, False, True],
[False, False, True, True]]
)
idx = a.shape[1] - 1 - np.argmax(a[:,::-1], axis=1)
np.argmax() will find the index of the highest value (for each row with axis=1). Since True is equivalent to 1 and False to 0, it'll record the index of the first True value. Simply reverse the rows so you find the "last" one and then substract this from the row length to account for the fact that you're counting backwards.

you can use python to reversea row and find an element: row.reverse() and row.find(True). in numpy you can use numpy.flip(row) to reverse a row and numpy.where(row == True) to find an element in a row.
import numpy as np
x = np.array([[True, True, False, False],
[True, False, True, False],
[False, True, False, True],
[False, False, True, True]])
result = []
for row in x:
row = np.flip(row)
index = np.where(row == True)
result.append(index[0][0])
print(result)

Choose random elements from specific elements of an array

I have a 1D (numpy) array with boolean values. for example:
x = [True, True, False, False, False, True, False, True, True, True, False, True, True, False]
The array contains 8 True values. I would like to keep, for example, exactly 3 (must be less than 8 in this case) as True values randomly from the 8 that exist. In other words I would like to randomly set 5 of those 8 True values as False.
A possible result can be:
x = [True, True, False, False, False, False, False, False, False, False, False, False, True, False]
How to implement it?

One approach would be -
# Get the indices of True values
idx = np.flatnonzero(x)
# Get unique indices of length 3 less than the number of indices and
# set those in x as False
x[np.random.choice(idx, len(idx)-3, replace=0)] = 0
Sample run -
# Input array
In [79]: x
Out[79]:
array([ True, True, False, False, False, True, False, True, True,
True, False, True, True, False], dtype=bool)
# Get indices
In [80]: idx = np.flatnonzero(x)
# Set 3 minus number of True indices as False
In [81]: x[np.random.choice(idx, len(idx)-3, replace=0)] = 0
# Verify output to have exactly three True values
In [82]: x
Out[82]:
array([ True, False, False, False, False, False, False, True, False,
False, False, True, False, False], dtype=bool)

Build an array with the number of desired True and False, then just shuffle it
import random
def buildRandomArray(size, numberOfTrues):
res = [False]*(size-numberOfTrues) + [True]*numberOfTrues
random.shuffle(res)
return res
Live example

Python boolean operations on lists - inconsistent results

Suppose I have two lists:
>>> y
[False, False, True, False, True, False, False, True, False, True, False, False]
>>> z
[False, True, True, True, True, True, False, False, False, False, False, True]
Then I do the following:
>>> y or z
[False, False, True, False, True, False, False, True, False, True, False, False]
>>> z or y
[False, True, True, True, True, True, False, False, False, False, False, True]
Shouldn't the correct answer be as shown below?
[False, True, True, True, True, True, False, True, False, True, False, True]
I also get incorrect answers with and:
>>> y and z
[False, True, True, True, True, True, False, False, False, False, False, True]
>>> z and y
[False, False, True, False, True, False, False, True, False, True, False, False]
I tested 1s and 0s with odd results:
>>> y=[0,0,0,0,0]
>>> z=[1,1,1,1,1]
>>> y or z
[0, 0, 0, 0, 0]
>>> z or y
[1, 1, 1, 1, 1]
>>> y and z
[1, 1, 1, 1, 1]
>>> z and y
[0, 0, 0, 0, 0]
What am I doing incorrectly?

y or z doesn't behave how you think it does, on the individual elements. Instead, it evaluates the 'truthiness' of the first argument (y). Since y is a non-empty list, it evaluates to true. The overall statement then evaluates to y.
Similarly, z or y first looks to see if z is truthy (which it is, because it's a non empty list). Thus the statement evaluates to z without ever looking at y or the elements within it.
Here are some clearer examples:
>>> [1,2,3,4] or [5,6,7,8]
[1, 2, 3, 4]
>>> ['this','is','a','list'] or ['and','here','is','another']
['this', 'is', 'a', 'list']
An empty list evaluates as 'false-y', so in this care, the right hand list is the value of the statement:
>>> [] or ['and','here','is','another']
['and', 'here', 'is', 'another']
Swapping the order of the lists shows that the first one to evaluate as true will be the result:
>>> ['and','here','is','another'] or ['this','is','a','list']
['and', 'here', 'is', 'another']
To achieve what you want, you could do a list comprehension like
[
y_item or z_item
for y_item, z_item
in zip(y, z)
]

The correct approach for or operation:
[a or b for a, b in zip(y, z)]
The correct approach for and operation:
[a and b for a, b in zip(y, z)]
None, False, 0, '', (), [], {} and few more (mentioned here -> Truth Value Testing) are considered False.
here's some example:
[] is False, [False] is True since its not empty, check using
bool([False])
>>> [] and [False]
[]
>>> bool([] and [False])
False
[] is False, [False] is True, hence Here True
>>> [] or [False]
[False]
>>> bool([] or [False])
True

Generate Truth Table but leave some variables undefined in python

input:
vv = [True, False, None, True, None]
Is there a way to generate truth table by replacing undefined one boolean at a time
So the ouptut would be
[True, False, True, True, None]
[True, False, False, True, None]
[True, False, None, True, False]
[True, False, None, True, True]

Assuming that Undefined can be None, for example, you could do as follows:
l = [True, False, None, True, None]
# first get indices of None/Undefined elements in the input list
indexes = [i for i,v in enumerate(l) if v is None]
# for each index, generate new list using True and False
# as substitutes.
for idx in indexes:
for sub in [True, False]:
new_l = l[:]
new_l[idx] = sub
print(new_l)
This gives:
[True, False, True, True, None]
[True, False, False, True, None]
[True, False, None, True, True]
[True, False, None, True, False]