Funkcja warunkowa tworzącą listę pod warunkiem true.

Witam

Jaka składnia jest odpowiedzialna za zwrócenie wartości prawda występującego na liście a ,ale pobiera dane z listy b do nowej listy c/

a = ['a', 'b', 'a', 'a', 'b', 'b'] 
b = ['c', 'b', 'c', 'c', 'b', 'b']
c =[]
if 'a' in a:

#jeśli warunek prawda to zwróć elementy z listy b do nowej listy c:

Chciałbym prosić o pomoc jakie funkcje są odpowiedzialne za działania na takich listach z warunkami true czy false z większa ilością danych.
W specyfikacji są tylko proste przykłady dla jednego elementu z zapytaniem czy znajduje się na liście i zwraca true.

Dziękuję za pomoc.

Nie rozumiem o co ci chodzi. O coś takiego?

# a = [False, True, False, True, False, True]
a = ['a', 'b', 'a', 'a', 'b', 'b'] 
b = ['c', 'b', 'c', 'c', 'b', 'b']

ziped = zip(a, b)
filtered = filter(lambda x: x[0], ziped)
mapped = map(lambda x: x[1], filtered)
print(list(mapped))

Tylko że to bez sensu bo każdy element z listy a zawsze zwróci True

Chyba że chcesz porównywać do znaku a:

a = ['a', 'b', 'a', 'a', 'b', 'b'] 
b = ['c', 'b', 'c', 'c', 'b', 'b']

ziped = zip(a, b)
filtered = filter(lambda x: x[0]=='a', ziped)
mapped = map(lambda x: x[1], filtered)
print(list(mapped))

BTW co za straszny język :D
BTW2 zaraz pewnie przyjdzie jakiś mistrz pythona i napisze to w jednej linii. Ja pytona nie umiem więc to tak zostawię :P

@KamilAdam przepraszam a czego nie rozumiesz? Przecież jest lista a i element 'a' wiec jak już chcesz bardziej to zrozumieć to niech będzie wyszukanie elementu 'b'
Jak może ci zwrócić true coś czego może nie być na danej liście?
Myslę ,że to nie straszny język tylko twój brak rozumienia .,a niestety w tym Ci już nie pomogę .
Dzięki za odp .ale co ma znaczyć "ja pythona nie umiem"/?
Co do odpowiedzi to będzie ich tyle ilu jest programistów.

Zrozumiałem to w taki sposób

listA = ['a', 'b', 'a', 'a', 'b', 'b'] 
listB = ['c', 'b', 'c', 'c', 'b', 'b']

# listC = listB if 'a' in listA else []
listC = []

for i, el in enumerate(listA):
    if (el == 'a'):
        listC.append(listB[i]);

print(listC) # ['c', 'c', 'c']

Nie wiem czy dobrze rozumiem cel zadania, ale chyba chodzi o itertools.compress.

from itertools import compress

a = ['a', 'b', 'a', 'a', 'b', 'b'] 
b = ['c', 'b', 'c', 'c', 'b', 'b']
c = list(compress(b, (i == 'a' for i in a)))

print(c)

Jak już wszyscy dają jakieś przykłady to ja preferuję matematycznie na tensorach, jakoś bardziej naturalnie można operować na danych.

import numpy as np
a = np.array(['a', 'b', 'a', 'a', 'b', 'b'])
b = np.array(['c', 'b', 'c', 'c', 'b', 'b'])
c = b[a=='a']

ledi12 w komentarzu napisał(a):

Jeśli OP nie ma pokaźnych list, to zaprzęganie numpy jest troszkę przerostem formy nad treścią :P

Kiedyś kiedy byłem młody i głupi a po ziemi wędrowały dynozaury, próbowałem dopasowywać algorytm do skali problemu.
To pozwalało mi tworzyć kody nawet dwukrotnie szybsze od "szeroko rozumianej" konkurencji.
Ale pewnego dnia dostałem zlecenie na pytanie ile rekordów przewiduje klient w bazie danych dostałem odpowiedź że jak do końca życia zgromadzi 10 tyś rekordów to będzie sukcess całego jego życia!
Po roku klient wraca z prośbą o przyśpieszenie algorytmów, pytam ile rekordów zawiera baza danych, dostaje odpowiedź: - aktualnie ponad 100 tyś, ale do końca roku przewiduje 500 tyś.
Wniosek: - Apetyt przychodzi podczas jedzenia, czyli wytaczamy armatę na muchy co najwyżej stracimy kilka mikrosekund, zaś jak problem nabierze SKALI (właśnie dużymi literami) to tylko zyskujemy nic nie robiąc.

Jeśli OP nie ma pokaźnych list, to zaprzęganie numpy jest troszkę przerostem formy nad treścią :P

Jeśli miały by to być naprawdę duże dane, to, numpy i tak wiele nie pomoże, (tak czy siak, w pamięci, będziemy przepychać w dużo bajtów) i wtedy lepiel operować w pipelinie, na streamach, i dopiero na końcu zwracać wynik, na przykład jakimś, reduce.

Najlepiej to być milionerem i postawić sobie high concurrency cluster w databricksie, nabity ramem i corami jak autobus do lichenia ( ͡° ͜ʖ ͡°)