-Ms-Filter VS Filter What's the Difference

Python difference between filter() and map()

They both work a little bit differently but you've got the right idea.

Map takes all objects in a list and allows you to apply a function to it
Filter takes all objects in a list and runs that through a function to create a new list with all objects that return True in that function.

Here's an example

def square(num):
    return num * num

nums = [1, 2, 3, 4, 5]
mapped = map(square, nums)

print(*nums)
print(*mapped)

The output of this is

1 2 3 4 5
1 4 9 16 25

Here's an example of filter

def is_even(num):
    return num % 2 == 0

nums = [2, 4, 6, 7, 8]
filtered = filter(is_even, nums)

print(*nums)
print(*filtered)

The output of this would be

2 4 6 7 8
2 4 6 8

dax difference between filter vs filter values

The FILTER function is a table function, meaning it will return a table. In the case of your second example, it is likely that you will get a scalar value (a single value) because you are filtering a table (of one column of unique values) by a single value. In the first FILTER instance, however, you will be returning an entire table of the first argument, which has only been filtered by the conditional in the second argument. For reference, I have used the sample data built within the Power BI Desktop version to show you the key differences.

From your first FILTER example

FILTER( financials, financials[Country] = "Germany" )

Output

From your second FILTER example:

FILTER( VALUES( financials[Country] ), financials[Country] = "Germany" )
-- The extra parantheses around the second argument are not necessary...

Output

Therefore, the main functional difference is in the output. What are you wanting to return? An entire table or a specific value(s) of a column(s)?

In 'edit interactions', what is the difference between filter and highlight?

Filters remove all but the data you want to focus on. Highlighting isn't filtering. It doesn't remove data, but instead highlights a subset of the visible data; the data that isn't highlighted remains visible but dimmed.

check out this link to understand better

https://medium.com/@smitagudale712/filter-vs-highlight-and-spotlight-in-power-bi-ddc9e611984c

what's the difference between filter and comprehention with if?

If you print the results of the following example, you will know which one is faster (Comments are results I got).

timeit.Timer('''[x for x in range(100) if x % 2 == 0]'''         ).timeit(number=100000)
timeit.Timer('''list(filter(lambda x: x % 2 == 0, range(100)))''').timeit(number=100000)

# 0.3664856200000486
# 0.6642515319999802

So in your case, list comprehension would be faster. But let's see the following example.

timeit.Timer('''[x for x in range(100) if x % 2 == 0]'''   ).timeit(number=100000)
timeit.Timer('''(x for x in range(100) if x % 2 == 0)'''   ).timeit(number=100000)
timeit.Timer('''filter(lambda x: x % 2 == 0, range(100))''').timeit(number=100000)

# 0.5541256509999357
# 0.024836917000016
# 0.017953075000036733

The results show that casting an iterable to list takes much time and filter is faster than generator expression. So if your result does not really have to be a list, returning an iterable in a timely manner would be better.

As stated in here,

Note that filter(function, iterable) is equivalent to the generator expression (item for item in iterable if function(item)) if function is not None and (item for item in iterable if item) if function is None.

But list comprehension can do much more than simply filtering. If filter is given to the interpreter, it will knows it is a filter function. However, if a list comprehension is given to the interpreter, the interpreter does not know what it really is. After taking some time interpreting the list comprehension to something like a function, it would be a filter or filterfalse function in the end. Or, something else completely different.

filter with not condition can do what filterfalse does. But filterfalse is still there. Why? not operator does not need to be applied.

There is no magic. Human-friendly 1-for-many grammars are based on encapsulation. For them to be machine-executable binaries, they need to be decapsulated back and it takes time.

Go with a specific solution if it is enough than taking a more general solutions. Not only in coding, general solutions are usually for convenience, not for best results.

What is the difference between filter(_:).first and first(where:)?

You are correct in observing that filter(_:) returns all elements that satisfy a predicate and that first(where:) returns the first element that satisfy a predicate.

So, that leaves us with the more interesting question of what the difference is between elements.filter(predicate).first and
elements.first(where: predicate).

As you've already noticed they both end up with the same result. The difference is in their "evaluation strategy". Calling:

elements.filter(predicate).first

will "eagerly" check the predicate against all elements to filter the full list of elements, and then pick the first element from the filterer list. By comparison, calling:

elements.first(where: predicate)

will "lazily" check the predicate against the elements until it finds one that satisfies the predicate, and then return that element.

As a third alternative, you can explicitly use "a view onto [the list] that provides lazy implementations of normally eager operations, such as map and filter":

elements.lazy.filter(predicate).first

This changes the evaluation strategy to be "lazy". In fact, it's so lazy that just calling elements.lazy.filter(predicate) won't check the predicate against any elements. Only when the first element is "eagerly" evaluated on this lazy view will it evaluate enough elements to return one result.

---

Separately from any technical differences between these alternatives, I'd say that you should use the one that most clearly describes your intentions. If you're looking for the first element that matches a criteria/predicate then first(where:) communicates that intent best.

Difference between filter and reduce?

filter is narrow as it only works on the per row level and returns another ( filtered ) rdd.
Reduce actually returns a single value that is computed going over the entire rdd. For this value to be returned an actual computation must occur which is why reduce is an action.

In general rdd.functions that have to return an actual value or write some output are actions while rdd.functions that return another rdd are transformations.

Only when an action is needed, the rdd transformations leading to it will take place ( Spark's laziness property )

What is the different between filter and filter-map?

The whole point is that if you know filter and map well, then you can explain filter-map like that. If you do not know what filter and map does it will not help you understand it. When you need to learn something new you often need to use prior experience. Eg. I can explain multiplication by saying 3 * 4 is the same as 3 + 3 + 3 + 3, but it doesn't help if you don't know what + is.

What is the difference between filter and filter-map

(filter odd? '(1 2 3 4 5))     ; ==> (1 3 5)
(filter-map odd? '(1 2 3 4 5)) ; ==> (#t #t #t))

The first collects the original values from the list when the predicate became truthy. In this case (odd? 1) is true and thus 1 is an element in the result.

filter-map doesn't filter on odd? it works as if you passed odd? to map. There you get a new list with the results.

(map odd? '(1 2 3 4 5))                   ; ==> (#t #f #t #f #t #f)

Then it removes the false values so that you only have true values left:

(filter identity (map odd? '(1 2 3 4 5))) ; ==> (#t #t #t)

Now. It's important to understand that in Scheme every value except #f is true.
(lambda (x) x) is the identity function and is the same as identity in #lang racket. It returns its own argument.

(filter identity '(1 #f 2 #f 3)) ; ==> (1 2 3)

count works the same way as filter-map except it only returns how many element you would have got. Thus:

(count odd? '(1 2 3 4 5)) ; ==> 3

Now it mentions that it is the same as:

(length (filter identity (map odd? '(1 2 3 4 5)))

Execpt for the fact that the the code using map, filter, and length like that creates 2 lists. Thus while count does the same it does it without using map and filter. Now it seems this is a primitive, but you could do it like this:

(define (count fn lst)
  (let loop ((lst lst) (cnt 0))
    (cond ((null? lst) cnt)
          ((fn (car lst)) (loop (cdr lst) (add1 cnt)))
          (else (loop (cdr lst) cnt))))

---

Related Topics