Python, Dwie Sztuczki i Algorytm

Dawno nic nie pisałem, tak to już jest, czasem człowiek jest busy, albo lazy:). Do rzeczy, dwa małe, praktyczne, triki (jakby ktoś nie znał). Pierwszy, otwieranie pliku przy pomocy iteratora(załóżmy, że mamy otwarty plik, na przykład z logami, jako f):

def good_lines(f):
    for line in f:
        line = line.strip("\n ")
        if line.startswith('#'):
            continue
        if not line:
            continue
        yield line

Utworzony iterator, omija linie komentarzy, puste linie, obcina spacje i znaki końca linii, teraz można już robić coś z interesującymi nas partiami pliku:

for line in good_lines(f):
    do_stuff(line)

Argumentem do funkcji good_lines(f) niekoniecznie musi być plik, może to być lista, zbiór, generalnie każda struktura wspierająca iterację.

Dalej,
W Pythonie nie ma łatwej możliwości przerwania podwójnej pętli, trzeba tworzyć dodatkowe zmienne kontrolne, warunki, co raczej zaciemnia kod, utrudnia testowanie, itd... Np.:

for y in range(height):
    for x in range(width):
        if sth_found(x, y):
            break # nie przerwie obu pętli

Ale gdy tylko się da możemy zrobić tak:

def 2d_range(width, height):
    for y in range(height):
        for x in range(width):
            yield x, y
 
for col, row in 2d_range(width, height):
    if sth_found(col, row):
        break # Cool, works!:)

Na koniec Fibonacci, jak można znaleźć w necie jest kilka sposobów liczenia tej funkcji, od najgorszego:

• naiwny rekurencyjny, O(n) i pamięć również O(n), więc po chwili rozsadza nam stos;
• dynamic programming, dalej O(n), ale w stałej pamięci, więc można jako tako używać;
• matrix exponentiation, lepiej O(logn), stała pamięć, bardzo szybki;
• double fibonacci identities, ulepszenie poprzedniego, złożność ta sama, ale mniej operacji stałych.

Wszystko to, dobrze opisane, np., tutaj. Właśnie ten przedostatni algorytm poniżej, w zasadzie jest to zapisanie identyczności z tytułu, trzeba tylko pamiętać o exponentiation by squaring, które można też, jak widać, stosować dla macierzy. Może się okazać, że ten tip jest nawet praktyczny (interview), przed kliknięciem zachęcam do samodzielnego zakodowania, link tutaj:
https://nbviewer.jupyter.org/[...]trix_Exponetiation_Fibo.ipynb

#Python #python #algorithms #theory

Kolejny dzień, kolejny wpis o #python #grski

Dziś oczywista oczywistość, o wadach i zaletach Pythona przeczytać też można na steemit

Tym razem krótko o tym, co może pojawić się w Pythonie 3.8 - operator przypisania w wyrażeniach.
#python #grski

Nowy python 3.7 - https://docs.python.org/3.7/whatsnew/3.7.html
A po polsku można poczytać też trochę i u mnie na blogu albo na steemit jak ktoś korzysta

Tak swoją drogą to poleciał tez updejt bloga - zmieniony wygląd, migracja na gitlab pages i wymuszanie https
#python

Python 3: Poznaj f-strings

O nowym, łatwiejszym sposobie interpolacji stringów – f-strings pisze Mike Driscoll 👌

#python #blog #technicalblog #programowanie

Jako, że trwa promocja na Helionie 2+1 na wybrane książki, to tu zestawiłam wartościowe książki do Pythona:
https://www.flynerd.pl/2018/0[...]-ksiazki-godne-polecenia.html
#python #książka

Dzisiaj świętujemy Dzień Informatyka !👩‍💻👨‍💻
Z tej okazji ⬇️obniżamy⬇️dla Was całą kategorię PROGRAMOWANIE o 30% 😉

https://videopoint.pl/go-promocja_programowanie

#programowanie #java #python #SQL #unity #Ruby #rubyonrails #promocje #naukaprogramowania

Różniczkowanie Symboliczne

Ha, ha, dawno już nie było teorii, wszyscy stęsknieni:P; to do roboty: Symbolic differentiation!
Temat jest bliski moim zainteresowaniom, tzn. AI; więc, studiując słynne PAIG plus (obowiązkowo!) SICP natkąłem się na jak w temacie.
Jako że ciężko mi było nadążyć z oryginalnym kodem w Lispie:

(defun deriv-poly (p x)
"Return the derivative, dp/dx, of the polynomial p."
" If P is a number or a polynomial with main-var > x,
" then p is free of x, and the derivative is zero;
" otherwise do real work.
" But first, make sure X is a simple variable,
" of the form #(X 0 1).
(assert (and (typep x 'polynomial) (= (degree x) 1)
(eql (coef x 0) 0) (eql (coef x 1) 1)))
(cond
« numberp p) 0)
«var> (main-var p) (main-var x)) 0)
(var= (main-var p) (main-var x))
d(a + bx + cx2 + dx3)/dx = b + 2cx + 3dx A 2
;; So. shift the sequence p over by 1. then
;; put x back in. and multiply by the exponents
(let «r (subseq pI)))
(setf (main-var r) (main-var x))
(loop for i from 1 to (degree r) do
(setf (coef r i) (poly*poly (+ i 1) (coef r i))))
(normalize-poly r)))
(t ;; Otherwise some coefficient may contain x. Ex:
d(z + 3x + 3zx2 + z2x3)/dz
;; = 1 + 0 + 3x2 + 2zx A 3
;; So copy p. and differentiate the coefficients.
(let «r (copy-poly p)))
(loop for i from 0 to (degree p) do
(setf (coef r i) (deriv-poly (coef r i) x)))
(normalize-poly r)))))

Plus pomoc z SICP (Scheme):

(define (deriv exp var)
(cond ((number? exp) 0)
((variable? exp) (if (same-variable? exp var) 1 0))
((sum? exp) (make-sum (deriv (addend exp) var)
(deriv (augend exp) var)))
((product? exp)
(make-sum
(make-product (multiplier exp)
(deriv (multiplicand exp) var))
(make-product (deriv (multiplier exp) var)
(multiplicand exp))))
(else
(error "unknown expression type: DERIV" exp))))

(Nawiasem pisząc, formatka 4programmers ssie (nie formatuje Lispu)), to wysmażyłem swój w Pythonie (kompilowalny pseudokod :-D). Idea jest prosta: Na najniższym poziomie - pochodna liczby jest zerem, pochodna zmiennej jest jedynką, jeśli to ta sama zmienna, zerem jeśli inna (jak stała). Problemem jest, jak to odwzorować w notacji infiksowej (jak Python i inne języki głównonurtowe). Okazuje się, że można wykorzystać algorytm parsowania formuły do (binarnego na razie!!) drzewa składniowego.
Idea: Pochodna sumy jest sumą pochodnych, a pochodna iloczynu, jest sumą iloczynu pierwszego członu razy pochodna drugiego plus pochodna pierwszego razy drugi; doskonale wpisuje się to w drzewo składniowe:

def evaluate(tree):
    opers = {'+': sym_add, '-': op.sub, '*': sym_mul, '/': op.truediv}
 
    leftT = tree.getLeftChild()
    rightT = tree.getRightChild()
 
    if leftT and rightT:
        fn = opers[tree.getRootVal()]
        return fn(evaluate(leftT), evaluate(rightT))
    else:
        return tree.getRootVal()
 
def evaluate_parse_tree(tree, var):
    opers = {'+': sym_add, '-': op.sub, '*': sym_mul, '/': op.truediv}
 
    leftT = tree.getLeftChild()
    rightT = tree.getRightChild()
 
    if leftT and rightT:
        fn = opers[tree.getRootVal()]
        # changes start:
        if fn is sym_mul:
            fn = sym_add
            return fn(sym_mul(evaluate(leftT), evaluate_parse_tree(rightT, var)), sym_mul(evaluate_parse_tree(leftT, var),
                    evaluate(rightT)))
        else:
            return fn(evaluate_parse_tree(leftT, var), evaluate_parse_tree(rightT, var))
    else:
        return derrive(tree.getRootVal(), var)
 
def derrive(exp, var):
    if is_number(exp): return 0
    elif is_variable(exp):
        return 1 if same_variable(exp, var) else 0

Dwie funkcje evaluate_parse_tree i evaluate działają zgodnie z powyższym schematem; chociaż widać tu dużo braków: Trzeba upraszczać końcowe wyrażenia (albo poprawić sym-add i sym_mul). Lecz pomysł działa. Kod (już nie GitHubie, bo go nie ma:-D), z funkcjami sym_add i tak dalej (w razie nieścisłości zapraszam do dyskusji) tutaj: https://bitbucket.org/lion137[...];fileviewer=file-view-default
Działa?

 form = "((1 + (2 * x)) * (1 + x))"
   p_tree = BinaryTree('')
   p_tree = build_parse_tree(form)
   print(evaluate_parse_tree(p_tree, "x"))# -> 1(1 + 2x) + (0 + 2 + 0x)*(1 + x)
   form = "(x + 1)"
   p_tree = BinaryTree('')
   p_tree = build_parse_tree(form)
   print(evaluate_parse_tree(p_tree, "x")) # -> 1

Jak widać tak (chociaż): Wyrażenie musi być poprawnie znawiasowane i forma wyniku przedstawia sporo do życzenia.
Ale droga jest właściwa! :-D)
#theory #Python

#theory #Python

11 blogów logów poświęconych Pythonowi, które warto odwiedzać.

Co jeszcze powinno znaleźć się w zestawieniu? 🤔

#blog #python #technicalblog

Nowości ze świata Pythona.
Dataclasses:
https://hackernoon.com/a-brie[...]3-7-data-classes-22ee5e046517
Python3 jest szybszy od 2.7 (wbrew niektórym opiniom, również na tym forum):
https://speed.python.org/changes/
Jest oficjalna data, odejścia od Legacy Pythona:
https://pythonclock.org/
W związku z tym dobry pomysł na biznes na przyszły rok, konsulting przy przechodzeniu z 2.7 na 3!:), Kurs, na przykład, tutaj:
https://www.pluralsight.com/courses/python-2-to-python-3
#python #Python #links