Monat: Februar 2020

A bzw. B:

•  in SQL eine Menge an Werten, die aus der Abfrage über eine Spalte einer Tabelle entstehen
• in pandas ein pandas.Series-Objekt (eindimensionales ndarray mit Achsen-Namen), das ggf. aus der Abfrage eines pandas.DataFrame (zweidimensionale, größenveränderliche, möglicherweise verschieden typisierte Tabellendaten) resultiert
• für Python pandas gilt: „left“ = 1st Dataframe; „right“ = 2nd Dataframe

SQL:
SELECT * FROM A LEFT JOIN B ON A.Key = B.Key
Python pandas:
A.join(B, on=[‘A.Key‘], rsuffix=‘_B‘)

SQL:
SELECT * FROM A LEFT JOIN B ON A.Key = B.Key WHERE B.Key IS NULL
Python pandas:
A[~A[‘A.Key‘].isin(B[‘B.Key‘])

SQL:
SELECT * FROM A INNER JOIN B ON A.Key = B.Key
Python pandas:
A.join(B, on=[‘A.Key‘], how=‘inner‘)

SQL:
SELECT * FROM A FULL OUTER JOIN B ON A.Key = B.Key WHERE A.Key IS NULL OR B.Key IS NULL
Python pandas:
pd.concat([A, B].loc[lambda df: ~df.index.duplicated()]

SQL:
SELECT * FROM A FULL OUTER JOIN B ON A.Key = B.Key
Python pandas:
pd.merge(A, B, how=‘outer‘, on=[‘A.Key‘,‘B.Key‘], validate=“one_to_one“, indicator=True)

Weitere Varianten und komplexere Vereinigungen in der pandas-Dokumentation.

Download SQL-pandas-Cheatsheet

Ein passender Titel für den Vortrag auf der NG-CONF 2018 von Ward Bell & Sander Ellis zum Thema „Angular APIs with RxJS“:

.pipe your Observables!

Angular APIs using RxJS: HttpClient, AsyncPipe, Forms, Router:

• .get() with .subscribe() in your service, .pipe() the Observable and map() it there to the object you want to consume in your components, then use the service in your components
• .post() with .subscribe(), including error-handling
• or get the data with using async in your template and error handling (catchError()) in the component
• with Angular reactive forms APIs valueChanges-Observable, .pipe() with tap() for error message, and three functions to reduce http-requests: debounceTime(), disctinctUntilChanged() and switchMap() for discarding an inflight-search, .pipe()‚d again to sandbox the errors inside the switchMap() so that examining the Observable does not complete, e.g. for auto-completion (use reactive style instead of Angular template-driven forms)
• error isolation (explicit example) for sandboxing errors in an isolation level with the help of another .pipe() to map() and catchError() inside the .pipe() to switchMap(). RxJS rule: if an error occurs, the upstream is dead.
• ActivatedRoute used with Observable paramMap.pipe(), Router events and url address path change while navigating on the same component with changing routerParams, map() and then switchMap(), again to cancel previous queries. Including watching the routing for debugging (altenrnative .subscribe()-style!)
• Recommended way if subscribing to an Observable: .unsubscribe() from the source, a Subject, with Observable.onDestroy.next() in life cycle event hook ngOnDestroy() with the aid of Observable.pipe() to takeUntil() emitting the Subject in the Observable.pipe() to complete the Observable which prevents memory leaks. .unsubscribe() when in doubt with takeUntil(notifier) pattern. It never hurts to .unsubscribe()!
•  .subscribe() takes: 1.) the happy (or: the next channel), 2.) the sad (or: the error channel) and 3.) alert things when the Observable completes (which means the Observable terminates and let go of any subscribers)
• async autosubscribes when the Component is destroyed, but emits no „completed“: savely use AsyncPipe in the components template!
• combine multistreams: bring multiple streams from Observers and Subjects together with combineLatest() .pipe()‘d to map() for mapping them into an immutable array of immutable objects
• role your own Observables which have .next(), .error() and .complete(), from properties („rolling http of local storage“) in the component
• create a new result array when any source emits an Observable array with .pipe()‚ing the Observable to scan(), which accumulates all incoming Observables into an array starting empty with startWith( [] ). combineLatest() takes the latest value of every Observable it gets
• sort values in an additional map()
• (not in movie) filter() the .pipe()‚d Observable to filter out unwanted values

Observable Decision Graph:
https://xgrommx.github.io/rx-book/content/which_operator_do_i_use

Source fork (Angular 7 / Node 10 commit):
https://github.com/Mesqualito/rxjs-in-ng-angular_berlin

Wirklich fein.

DIE WELT HÄNGT AN EINEM KOMMA.

Und nicht vergessen: „Truth value of a Series is ambiguous.“
„The or and and python statements require truth-values. For pandas these are considered ambiguous so you should use „bitwise“ | (or) or & (and) operations:
These are overloaded for these kind of datastructures to yield the element-wise or (or and).“

Da braucht es Ruhe. Schöne Ruhe. Hacking music Ruhe.

Observable bedeutet zu deutsch: „Beobachtbares“

Die Funktion: mit switchMap kann zum Observable geschalten werden, welches sich zuletzt geändert hat („switch to a new observable“).

Der switchMap-Operator aus der RxJS-Bibliothek bildet jedes Element auf ein Observable ab. Er ordnet alle empfangenen Observables auf einer Ebene ein. Der switchMap-Operator projiziert jeden Wert aus der Quelle in ein Observable und führt dieses in einem Ziel-Observable zusammen, welches vom switchMap-Operator schließlich ausgegeben wird. Im Ziel-Observable finden sich immer nur die Werte, die vom zuletzt von der Quelle abgegebenen Observable empfangen wurden.

Die Syntax des switchMap-Operators

switchMap<T, R, O extends ObservableInput>(project: (value: T, index: number) => O, resultSelector?: (outerValue: T, innerValue: ObservedValueOf, outerIndex: number, innerIndex: number) => R): OperatorFunction<T, ObservedValueOf | R>

Der Parameter project in der Syntax ist eine Funktion, die ein Observable zurück gibt, sobald sie auf ein Element angewandt wird, das von einem Quell-Observable ausgegeben wurde.
Der Parameter resultSelector ist optionell und der Standardwert dieses Parameters ist nicht definiert. Der Rückgabewert, „OperatorFunction<T, ObservedValueOf | R>“, ist ein Observable, welches das Ergebnis liefert, das aus der Anwendung der projection-Funktion (und dem optionalen, veralteten [„deprecated“] resultSelector) auf jedes Element, welches aus dem Quell-Observable übergeben wird, resultiert, wobei nur die Werte des zuletzt proijezierten, inneren Observables verwendet werden.

Den switchMap-Operator in Angular anwenden

Der switchMap-Operator liefert ein Observable zurück, das Elemente ausgibt, auf welche eine Funktion, die dem Operator als Parameter mitgeliefert wird, angewandt wird. Dabei wird die Funktion auf jedes Element, das vom Quell-Observable kommt, angewandt. Diese Funktion gibt bei jeder Anwendung intern im switchMap-Operator ein inneres Observable zurück. Jedes Mal wenn eines dieser inneren Observable in Betracht gezogen wird, beginnt das von der switchMap zurückgelieferte Observable, die Elemente dieses inneren Observables  auszugeben.

Wenn ein neues, inneres Observable verarbeitet wird, beendet switchMap die Ausgabe der Elemente des vorher ausgelieferten, inneren Observable und beginnt, die Elemente des neuen, inneren Observable zurück zu liefern. Dieser switchMap-Prozess setzt sich kontinuierlich für jedes folgende, innere Observable fort.

switchMap-Einsatz beim Angular Routing

Der switchMap-Operator kann mit Angulars Activated Route verwendet werden.

Als erstes müssen Router, ActivatedRoute und ParamMap Wertmarken [„token“] aus dem router-Paket importiert werden. Anschließend muss der switchMap-Operator importiert werden, der dazu verwendet wird, die beobachtbaren [„observable“] route-Parameter abzuarbeiten. Wie gewöhnlich schreiben wir einen constructor, der Angular anfragt, services einzuspeisen, welche die Komponente benötigt, und diese mithilfe privater Variablen zu referenzieren.

In der ngOnInit-Methode verwenden wir den ActivatedRoute service, um die Parameter für das route-Objekt abzurufen, den employee ID aus den Parametern heraus zu ziehen und den employee zu extrahieren, den wir anzeigen wollen. Die Abarbeitung der paramMap ist etwas knifflig. Wenn die map sich ändert, bekommen [„get()“] wir die ID Parameter von den geänderten Parametern. Man könnte denken, jetzt wäre die Gelegenheit die RxJS map zu verwenden, der EmployeeService Operator liefert jedoch ein Observable zurück. Deswegen ebnen wir stattdessen das Observable mit dem switchMap-Operator ein. Zusätzlich verwirft der switchMap-Operator vorhergehende, „fliegende“ Anfragen. Wenn der Benutzer mit einer neuen ID zur gleichen Route zurück kehrt während der EmployeeService noch eine alte ID verarbeitet, verwirft switchMap die alte Anfrage und liefert den employee für die neue ID zurück.

Teilweise Übersetzung des Artikels von Yallaling Goudar. Code-Beispiele und weitere Ausführungen dort.

Ebenso ein nützlicher Link: switchMap auf Learn RxJS.

Zwei Links, die für seltener gebrauchte git-Schritte nützlich sind:

heise: Die vielfältigen Fähigkeiten von Git

Mit Kraftausdrücken: Oh Shit, Git!?!