2020. szeptember 20., vasárnap

Adatbázis modellező eszközök

 

Élet a Power Designeren kívül:

 

Milyen szempontok vezérelnek általában egy adatbázis modellező eszköz kiválasztásnál:

·         Csoport munka támogatása, közös repository, bussiness glossary kezelés, SVN funkciók,

·         Fejlesztési folyamatba illesztés szintje, lehetőségek,

·         Belső funkcionális scriptelési lehetőség,

·         Közös repository és integrálás támogató funkciók

·         Modell kiolvasás (reverse engineer) támogatás

·         Név és domain konvenció támogatása

·         Modell konverziók támogatása CDM-> LDM -> FDM és vissza

·         Interfészek, be és kimeneti forrás adat file fromátumok (XLS, TXT, CSV, …)

·         Dokumentációs formátumok (PDF, DOK, RTF, HTML, XML, JPG, ....)

·         Adatbázis oldali generációk / DDL támogatás / adatbázis és modell merge és frissítési funkciók

·         Adatbázishoz illeszkedő kliens alkalmazás forráskód modul, skeleton generálás (VB, C#, Delphi, Java, ...)

·         ...

 Vannak olyan próba verziók, amelyek idő vagy objektum szám korlátozás mellet megengedik a telepítést és a funkciók kipróbálását.

 


Fizetős eszközök:

·         erwin Data Modeler    //  https://erwin.com/products/erwin-data-modeler/

·         ER Studio                  // https://www.idera.com/er-studio-enterprise-data-modeling-and-architecture-tools

·         Sparx Systems Enterprise Architect //   https://sparxsystems.com/

·         Toad Datamodeler     // https://www.toadworld.com/products/toad-data-modeler

·         IBM infosphere          // https://www.ibm.com/in-en/marketplace/infosphere-data-architect

·         DbWrench                 //  http://www.dbwrench.com/

·         DbVisualizer          //  https://www.dbvis.com/

·         ...

 

Nem fizetős eszközök:

·         Archi  - Open Source ArchiMate Modelling  //  https://www.archimatetool.com/

·         Oracle SQL Developer Data Modeler          // https://www.oracle.com/in/database/technologies/appdev/datamodeler.html 

·         ...

 A nemfizetős eszközök esetén gondosan körbe kell járni, hogy magán és céges használatra is alkalmazgató, és nincs-e csak adatbázis típusra korlátozva az ingyenesség. 


 

Egyéb eszközök az adatbázis modellezéshez

Megemlítésre méltónak tartom még az olyan eszközöket, melyek

·          Melyek vizuális adatbázis modell megjelenítésre alkalmasak : MS Visio, YedGrap, …

·          UML szerkesztők, amelyek modellező funkciókkal is rendelkeznek,

·          WEB Online modellező eszközök,

·          Adatbázis modellezésre is alkalmas fejlesztői program plugin létezik (pl. eclipse  esetén több mint tíz )

·         ...













Előnyök modellező eszköz használat esetén



Jobb és komplexebb kontroll:

– Kockázatelemzés gyorsabb és pontosabb

– Gyorsabb a rendszerek megértése és dokumentálása (jelőlési szabványok szerinti)

– Hatékony és pontosabb projektmenedzsment (költség-, idő- és erőforrás becslés)

–  Költség- és időtakarékosság a redundancia elkerülésével és az átláthatóbb rendszerek kialakításával








Agilitás - gyors és pontosabb reakció a változásokra:

- Egységes Bussiness Glossary kezelés felelősség, változás kezelés

– Központi meta-adat menedzsment (Repository)

– Hatáselemzéssel a változáskezelés egyszerűbb, pontosabb

– Újrahasznosítás (kódok, adatok, üzleti folyamatok)






Projektdokumentáció kívánt szintű előállítása


• Testre szabható riportok


– Kívánt részletességi szint
– Vállalati templét alkalmazása, beilleszthetőség



• Egységes riport készíthető több modellről (multimodel és submodel report) melynek a formátuma lehet


– Nyomtatható (RTF)
– Intranet (HTML)



• Lista riportok előállítása


– Adott modell csak bizonyos típusú objektumairól készül vagy az összesről
– ResultSet képezhető
– Export: XML, Excel, RTF, HTM stb.


















2020. szeptember 16., szerda

Jupyter notebook trükkök

 

Hogyan jelezhetjük a felületen hogy elkészült a program futása?

## Java scrip felugró ablak:

%%javascript
alert("Kész vagyok!")  

 

 

Hogyan küldjünk magunknak üzenetet ha elkészült a program futása?

mport smtplib 
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
msg = MIMEMultipart('alternative') 
msg['Subject'] = "Elkészül a futás, nézd meg az eredményt!"
msg['From'] = "
no.reply.admin@mierdekel.hu"
msg['To'] = "
admin@mierdekel.hu"
# Message body 
html = "<html><b>DONE</b></html>"
# beágyazott üzenet
part2 = MIMEText(html, 'html')
msg.attach(part2)
# Send the message via local SMTP server.
s = smtplib.SMTP('
amail.servers.mierdekel.hu')
# sendmail function takes 3 arguments: sender's address, recipient's address and message to send - here it is sent as one string
s.sendmail("
no.reply.admin@mierdekel.hu", "user2@mierdekel.hu", msg.as_string())
s.quit()

 

 

Hogyan lehet felhasználni a külső parancsok eredményét?

Az eredmény változóba irányítható. A változó típusa automatikusan String Lists (IPython.utils.text.SList) lesz.

result = !hadoop fs -ls /data/sada/dcda/s3/domani_kbc.avro

 

 

Hogyan íratható automatikusan ki a végrehajtási idő minden program végrehajtás után?

%load_ext autotime 

### Installálás ha szükséges:

%install_ext /data/site/jupyter_extensions/autotime.py  %load_ext autotime

 

 

Az egyes függvények leírását hogyan lehet gyorsan elérni?

A parancs végére tegyünk kérdőjelet a CODE cellában és futtassuk le shift+enter gyos billentyűkombinációval.

 

Hogyan és mire használjunk mágikus parancsokat?

# Egysoros hatókör : %

# Egész céllára vonatkozó hatókör : %%

%%prun : profile your cell code (number of calls & timing info)
%%timeit : execution time of the cell
%debug : enter this in a cell after you had an error, it allow you to debug (messages, variable content at error, ...)
%load : load a .py script or other file into the cell
%macro : create macro's
további infó : (
http://ipython.readthedocs.io/en/stable/interactive/magics.html) ...

 

Hogyan változtathatjuk meg a jupyter lapok stilusát?

A felhasználói stiluslap helye: /home/userxx/.jupyter/custom/custom.css. 

 

 

Több kimenet megjelenítése egyszerre hogyan történhet?

Helyezze a következőket a notebook első soraiba (nem sükséges külön print parancs működéshez):

from IPython.core.interactiveshell import InteractiveShell

InteractiveShell.ast_node_interactivity = "all"

 

 

Hogyan növelhető meg a kimeneti terület szélessége 100%-osra?

from IPython.core.display import display, HTML

display(HTML("<style>.container { width:100% !important; }</style>")) 

 

 

Hogyan lehet összecsukni a code (program) cellát?

from IPython.display import HTML
HTML('''<script>
code_show=true; 
function code_toggle() {
 if (code_show){
 $('div.input').hide();
 } else {
 $('div.input').show();
 }
 code_show = !code_show
$( document ).ready(code_toggle);
</script>
Ha eltüntetni akarod, akkor : <a href="javascript:code_toggle()">Erre klikkelj</a>.''')

 

 

az összes kimeneti cella elrejtéséhez futtassa ezt a kódot egy cellában

 

from IPython.display import HTML

HTML('''<script> $('div.output_wrapper').hide(); </script>''')

 

 

az összes kimeneti cella megjelenítéséhez futtassa ezt a kódot egy cellában

from IPython.display import HTML

HTML('''<script> $('div.output_wrapper').show(); </script>''')

 

 

 

Hogyan lehet csak a nagy kimeneti cellákat törölni (hogy megakadályozzuk a böngésző lelassulását)?

%%html <button onclick="$('div.output_subarea.output_text.output_stream.output_stdout').each(function( index, element ) {

     if( element.innerHTML ) {

         if (element.innerHTML.length > 1000) {

             element.innerHTML='Output Cleared';

         }

     }

 });">Clear output larger than 1000 characters</button>

 

 

Hogyan kell a felesleges logolást letiltani?

import logging 

logger =logging.getLogger('kl_lib')

logger.setLevel(logging.CRITICAL)

 

 

Hagyan kell python modulokat elérhetővé tenni?

Extra könyvtárrakat be kell jegyezni a környezeti utvonal változóba,

import sys
sys.path.append("/data/site/python[2|3]libs/lib/python") 

 

 

 

Hogyan tudunk tömörített fileket olvasni, írni?

 

Írás

#  pandas dataframe : pdf

pdf.to_csv('mypath/myfile.csv.tar.gz', compression='gzip')

 

Olvasás

pdf = pd.read_csv('mypath/myfile.csv.tar.gz', compression='gzip')

 

 

Dátum különbségek napjainak számolása hogyan gyorsítható?

Alap :

 (date1-date2).dt.days

 

Gyors:

 (date1-date2).dt.values.astype('timedelta64[D]')

 

 

 Hogyan lehet konvertálni egy sorozat  int-től dátumra?

Ha az oszlop (sorozat) a következő formátumú: 20200916, és azt szeretné, hogy date_time (2020-09-16) legyen

df['SERIES_NAME'] = pd.to_datetime(df['SERIES_NAME'], format = '%Y%m%d') 

 

 

 

Dátum idő csoportosításokat hoyga érdemes elvégezni?

times = pd.DatetimeIndex(df.SERIES_NAME)

grouped = df.groupby([times.month, times.year)    # Note you can then add additional df columns to the groupby

grouped.count()

 

Hogyan lehet hatékonyan ledobni bizonyos karaktereket egy karakterláncból (pl. A karakterlánc tisztításához)?

text = 'This is a test, dropping 123 numbers and other special characters like #} from a string.'

text_cleaned = text.translate({ord(i):None for i in ' ,.;:-[](){}"\'!@#$:0123456789?!'})

print(text_cleaned)

 

 

Hogyan teszteljek?

Használjuk az assert lehetőséget az elvár eredménnyel összehasonlításra.

assert resolveUser('123456')=='123456'

assert resolveUser('')==''

assert resolveUser('A')=='A'

assert resolveUser('None')==''




2020. szeptember 3., csütörtök

Tanfolyamok kipróbálása 2020

Ingyenes programok COVID19 jegyében.


Hát én leporoltam a tudásom és egy kis angol nyelv gyakorlása is meg volt.
Persze google fordító segített. :)

Többféle online oktatás is létezik, tanfolyam díjas és havidíjas.

Havi előfizetési díjért az online oktatási weboldalak is vannak,  és sokféle kurzust kínálnak, amelyek közül választhatunk a saját ütemű tanulásra. 

Számos lehetőséget találhatunk a Python tanulására. Ráadásul az előfizetési opciók jellemzően ingyenes vagy kedvezményes próbaidőszakot kínálnak.

A DataCamp is egy olyan online oktatási portál, amely tele van új és rendszeresen frissített kurzusokkal, amelyek többnyire az R ,Python és SQL nyelvekre vonatkozó adat-tudományra összpontosítanak. 

A webhely minden tanfolyama interaktív gyakorlatokat, videókat és vetélkedőket tartalmaz a tanuláshoz.

A weboldal különböző készség- és karrierlehetőségeket kínál az érdeklődők. Én a programozásra, az adatok elemzésére vagy az adat-tudományra helyeztem a hangsúlyt. 

Jó hogy tematikusan kialakított és egymásra épülő témákon haladunk végig az oktatás során.


Az ismeret elsajátítási lépések:
- ismeret átadás (videó + prezentációs anyag)
- begyakorló feladatok melyek csak sikeres teljesítés esetén engednek tovább 
- folyamatos pontozás történik siker +100 hiba (hibánként) -30



Most volt egy 8 napos ingyen időszak ebben próbáltam ki a használatot.
A próba időszakra (annak végére) a felső első sorban figyelmeztet:





Így néz ki egy tanfolyam teljesítés:




Így néz ki a leírással együtt egy teljesítés:



Ilyen az interaktív oktatási lap:


Mindig elő lehet venni a prezentációs anyagot.



A modul választás így néz ki:

 Ilyen a pontszám kiírás:




Ilyen a pontozás:


Lehetőség van az anyagok újra átnézésére és külön gyakorlásokra:



Tesztelhetjük a tudás szintünket:




És meg is nézhetjük, hogy tudásunk milyen szinten áll:




Arra azonban rájöttem, öregszem. Amire azt írják, hogy 4 órás tanfolyami feladatsor, az csak kb. 8 óra alatt tudtam teljesíteni.

Itt alapvetően az angol fordítgatás és az egyes feladat megértése jelentet gondot nekem.

Érdemes a shell konzol ablakon a feladat megoldását kipróbálni, mivel ez nem okoz pont lefonást, de az elgépelési hibák azonnal kijönnek (de ez is idő természetesen).




Eredmények:

 

Python

























Node Js





Adatbázis tervezés:
































Sololearn tanfolyamokLink

DataCamp tanfolyamok   Link

MS tanfolyamok: Link






Itt a témákon végigmentem, de mivel a minősítő vizsga fizetős, azt kihagytam (csak a jelvények vannak meg).


Online IT kurzusok még:

https://www.pythonsuli.com/
http://molnardenes.com/blog/category/python.html
https://infopy.eet.bme.hu/
https://learnpythonthehardway.org/
https://www.codecademy.com/
https://www.udemy.com/the-python-mega-course/
https://docs.python-guide.org/
https://docs.pytest.org/en/latest/
https://www.learnpython.org/
https://www.datacamp.com/
https://www.sololearn.com/
https://www.edx.org/course/subject/computer-science
https://www.edx.org/learn/python
https://www.edx.org/course/introduction-to-computer-science-and-programming-using-python-2
https://www.edx.org/course/cs50s-web-programming-with-python-and-javascript
https://www.coursera.org/courses?query=python https://www.udemy.com/python-for-smarties-in-59-minutes/

Kaggle olyan oldal, ahova adatelemzős feladatokat töltenek fel. Itt is lehet gyakorolni.


2020. augusztus 23., vasárnap

Fraktál létrehozása python segítségével

 Egyszerű alakzatokból bonyolult alapzatok létrehozása.


WIKI link


---Python minta:

import numpy as np

from PIL import Image

import matplotlib.pyplot as plt


PIXEL_SCALE = 200

WIDTH = 3

HEIGHT = 3

XSTART = -2

YSTART = -1.5


image_width = int(PIXEL_SCALE*WIDTH)

image_height = int(PIXEL_SCALE*HEIGHT)


def create_color(v):

    values = [0, 64, 128, 196]

    b = values[v % 4] 

    g = values[(v//4) % 4] 

    r = values[(v//16) % 4]

    return (r, g, b)



def calc(c1, c2):

    x = y = 0

    for i in range(1000):

        x, y = x*x - y*y + c1, 2*x*y + c2

        if x*x + y*y > 4:

            return i+1

    return 0


array = np.zeros((image_height,

                  image_width,

                  3),

                 dtype=np.uint8)


for i in range(image_width):

    c1 = XSTART + i/PIXEL_SCALE

    for j in range(image_height):

        c2 = YSTART + j/PIXEL_SCALE

        v = calc(c1, c2)

        array[j, i,] = create_color(v)


img = Image.fromarray(array)

# img.save('mandelbrot-colour.png')

plt.imshow(img, cmap='hot')

plt.axis("off")

plt.show()







---Python minta:

import math

from random import randint

from collections import namedtuple

# const - upper limit for randint

s = 20

class Point(namedtuple('Point', 'x y')):

    def __str__(self):

        return'{} {}'.format(self.x, self.y)


    def __add__(self, other):

        assert isinstance(other, Point)

        return Point(self.x + other.x, self.y + other.y)


    def __mul__(self, other):

        return Point(self.x * other, self.y * other)


    def __rmul__(self, other):

        return self.__mul__(other)



class Branch(namedtuple('Branch', 'p1 p2 color size')):


    def __str__(self):

        """Path SVG object with points, color and stroke of branch."""

        return ('<path d="M {p1} L {p2}" '

                'stroke="rgb(100,{c},0)" stroke-width="{w}"/>\n'.

                format(p1=self.p1, p2=self.p2, w=self.size, c=self.color))


    def __repr__(self):

        return self.__str__()



class Tree(object):


    def __init__(self, length, angle, depth, point, size, color, outlist):

        """Main point of start generation."""

        self.branches = outlist

        self.draw_branches(length, angle, depth, point, size, color)


    def draw_branches(self, length, angle, depth, p1, size, color):

        """ Recursively generate three Branch objects per iteration."""

        if depth <= 0:

            return


        p2 = p1 + length * Point(

            math.cos(math.radians(angle)),

            math.sin(math.radians(angle))

        )


        # set some new characteristics for the next level

        branch_length = 2.0 / 3.0 * length

        branch_size = 2.0 / 3.0 * size + 1

        color += 6


        # Calculate new angle and recurse

        self.branches.append(Branch(p1, p2, color, branch_size))

        nangle = angle + randint(-10, s)

        self.draw_branches(branch_length, nangle, depth - 1,

                           p2, branch_size, color)


        # Calculate new angle and recurse

        b = Point(p1.x, p2.y)

        self.branches.append(Branch(p1, b, color, branch_size))

        nangle = angle + randint(-1, 0) * randint(1, s)

        self.draw_branches(branch_length, nangle, depth - 1,

                           b, branch_size, color)


        # Calculate new angle and recurse

        c = Point(-p2.x + 2 * p1.x, p2.y)

        self.branches.append(Branch(p1, c, color, branch_size))

        nangle = angle + randint(0, 1) * randint(1, s)

        self.draw_branches(branch_length, nangle, depth - 1,

                           c, branch_size, color)


    def write_svg(self, output='kl_py_fractral_20.svg'):

        with open(output, 'w') as outfile:

            outfile.write('<svg xmlns="http://www.w3.org/2000/svg" '

                          'viewBox="0 0 800 800" version="1.1">\n')

            outfile.writelines(map(str, self.branches))

            outfile.write('</svg>\n')



resultlist = [Branch(Point(400, 800), Point(400, 600), color=60, size=35)]

t = Tree(length=200, angle=-20, depth=9, point=Point(400, 600), size=35, color=60, outlist=resultlist)

t.write_svg()








Néhány látványos minta:





















Minta link

Adatbázis modellező eszközök

  Élet a Power Designeren kívül:   Milyen szempontok vezérelnek általában egy adatbázis modellező eszköz kiválasztásnál: ·           Csoport...