This simple example creates peewee model from exisiting  database table by pwiz module

user@home > python -m pwiz -e mysql -u USER_NAME -H HOST_NAME_OR_IP -p 3306 DB_NAME -t TABLE_NAME

We are creating a worker.py file wihch is our threaded part:

# worker.py
from PyQt5.QtCore import QThread, QObject, pyqtSignal, pyqtSlot
import time


class Worker(QObject):
    finished = pyqtSignal()
    intReady = pyqtSignal(int)


    @pyqtSlot()
    def procCounter(self): # A slot takes no params
        for i in range(1, 100):
            time.sleep(1)
            self.intReady.emit(i)

        self.finished.emit()

And the main window part which is our main thread running in main.py file

# main.py
from PyQt5.QtCore import QThread
from PyQt5.QtWidgets import QApplication, QLabel, QWidget, QGridLayout
import sys
import worker


class Form(QWidget):


    def __init__(self):
        super().__init__()
        self.label = QLabel("0")
 
        # 1 - create Worker and Thread inside the Form
        self.obj = worker.Worker()  # no parent!
        self.thread = QThread()  # no parent!

        # 2 - Connect Worker`s Signals to Form method slots to post data.
        self.obj.intReady.connect(self.onIntReady)

        # 3 - Move the Worker object to the Thread object
        self.obj.moveToThread(self.thread)

        # 4 - Connect Worker Signals to the Thread slots
        self.obj.finished.connect(self.thread.quit)

        # 5 - Connect Thread started signal to Worker operational slot method
        self.thread.started.connect(self.obj.procCounter)

        # * - Thread finished signal will close the app if you want!
        # self.thread.finished.connect(app.exit)

        # 6 - Start the thread
        self.thread.start()

        # 7 - Start the form
        self.initUI()


    def initUI(self):
        grid = QGridLayout()
        self.setLayout(grid)
        grid.addWidget(self.label, 0, 0)

        self.move(300, 150)
        self.setWindowTitle('thread test')
        self.show()


    def onIntReady(self, i):
        self.label.setText("{}".format(i))
        # print(i)


app = QApplication(sys.argv)

form = Form()

sys.exit(app.exec_())

The only connection between worker and main is via emit and pyqtSignal. This is the critical part (çokomelli)

Reference: https://stackoverflow.com/a/33453124

1. Gradianto
2. Idea Mind Map
3. .ignore
4. BashSupport
5. ExtraIcons
6. Flake8Support
7. MakefileSupport
8. Mypy
9. Pylint
10. Python Security
11. Requirements
12. Sourcery

Basit Dekoratör Kullanımı

def my_decorator(func):
    def wrapper(var1: int, var2: int):
        print("Foksiyon cagirimindan once burasi calisir")
        retval=func(var1, var2)
        print("Foksiyon cagirimindan sonra burasi calisir")
        print("Carpim={}".format(var1 * var2))
        return retval

    return wrapper


@my_decorator
def topla(var1: int, var2: int)->int:
    print("Fonksiyon cagirildi")
    return var1 + var2


if __name__ == '__main__':
    print(topla(3,5))

Çıktısı:

Foksiyon cagirimindan once burasi calisir
Fonksiyon cagirildi
Foksiyon cagirimindan sonra burasi calisir
Carpim=15
8

Fonksiyon Argümanlarıyla Dekoratör Kullanımı

def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("Foksiyon cagirimindan once burasi calisir")
        retval=func(*args, **kwargs)
        print("Foksiyon cagirimindan sonra burasi calisir")
        print("Carpim={}".format(args[0] * args[1]))
        return retval

    return wrapper


@my_decorator
def topla(var1: int, var2: int)->int:
    print("Fonksiyon cagirildi")
    return var1 + var2


if __name__ == '__main__':
    print(topla(3,5))

Çıktısı:

Foksiyon cagirimindan once burasi calisir
Fonksiyon cagirildi
Foksiyon cagirimindan sonra burasi calisir
Carpim=15
8

Tanım

pip en basit haliyle python için bir modül yöneticisidir. pypi üzerindeki paketlerin sisteme eklenmesi, kaldırılması vb. işlemleri yerine getirir. Kullanıcı dökümanına https://pip.pypa.io/en/stable/ adresinden ulaşabilirsiniz. 

Kurulum

Paket Yöneticisi İle

# python2
#archlinux
pacman -S python2-pip 
#ubuntu
apt install python-pip
#opensuse 
zypper in python-pip

# python3
#archlinux 
pacman -S python-pip
#ubuntu
apt install python3-pip
#opensuse
zypper in python3-pip

El İle

get-pip.py dosyasını indirdikten sonra konsoldan

python get-pip.py

yazarak kurulumu gerçekleştirebilirsiniz.

Kullanım

Lafı çok uzatmadan basitçe kullanımına geçelim. Detaylı bilgiler ve burada gösterilmeyen kullanım parametreleri için pip dökümantasyonundan faydalanabilirsiniz.

Arama

Paket deposunda arama yapar.

pip search [options] <paket_adı>

pip search django

Kurulu Paketleri Listeleme

Sistemde kurulu paketleri listeler

pip list [options]

pip list
pip list --format columns
pip list --outdated # Güncellenebilir paketleri listeler

Paket Kurma Ve Güncelleme

Paket deposundan veya herhangi bir versyon kontrol sistemi üzerindeki(git, svn vs.) projenin elle paket ismi verilerek veya requirements.txt dosyası okutularak kurulumunu gerçekleştirir.

pip install [options] <paket_adı>

pip install django #django paketini kurar
pip install -U django #django paketini yoksa kurar varsa günceller
# Ayrıca
# requirements text dosyasının içinde tanımlanmış olan paketlerin kurulumu:
pip install -r requirements.txt
#Version kontrol deposundan örnek kurulum:
pip install -e git://git.ozeldepo.org/ozelproje#egg=ozelproje

Not: requirements dosyası formatı yazının sonunda anlatılmıştır.

Kurulu Paketi Kaldırma

pip uninstall [options] <paket_adı>
pip uninstall [options] -r <requirements_dosya_yolu>

pip uninstall simplejson
pip uninstall -r requirements.txt #requirements.txt'de tanımlı modülleri kaldırır

Snapshot Alma

requirements.txt dosyası oluşturmak için sistemin veya virtual environment'ın snapshotını alır.
pip freeze [options]

pip freeze

Requirements Dosya Formatı

#
####### örnek-requirements.txt #######
#
###### Var olmayanlar kurulur var olanlar ellenmez ######
nose
nose-cov
beautifulsoup4
#
###### Kurulum sırasında sürüm kontrol kuralları ######
# Bkz. https://www.python.org/dev/peps/pep-0440/#version-specifiers
docopt == 0.6.1 # Version 0.6.1 kurulur
keyring >= 4.1.1 # 4.1.1 versiyonundan daha büyük bir sürüm kurulur(eğer var olan sürüm daha küçükse update edilir)
coverage != 3.5 # version 3.5 hariç herhangi bir cversiyon kurulur(eğer örneğin en son sürün olan versiyon 3.5 kurulu ise bir alt sürüme çekilir)
Mopidy-Dirble ~= 1.1 # Benzer sürüm.  >= 1.1, == 1.* ile aynıdır
#
###### başka bir requirements dosyasını referans alır ######
-r diger-requirements.txt
#
#
###### Bellirli bir dosyanın kurulum yapar ######
./downloads/numpy-1.9.2-cp34-none-win32.whl #yereldeki dosya
http://wxpython.org/Phoenix/snapshot-builds/wxPython_Phoenix-3.0.3.dev1820+49a8884-cp34-none-win_amd64.whl #uzak sunucudaki dosya
#
# Yukarıda tanımlanan kuralların belirli bir sırası yoktur

# İstediğiniz sırada kullanabilirsiniz

http://stackoverflow.com/questions/1623039/python-debugging-tips

Yazılım bir sanattır. Motosiklet kullanmak da öyle. İkiside incelik ister. Altında bastırdıkları amortisörleri, susturucusuz egzosları ve kaskı kafası yerine koluna takanlardan bahsetmediğim gibi diploma almayı yeterlilik sayan, incelik nezaket ve yaratıcılıktan yoksun, yazılım geliştirmeyi esnaflıkla eşdeğer bir kazanç kapısı gören meslektaşlarımdan da bahsetmiyorum. Etrafındaki insanlara kod yazıyorum hek yapıyorum diye "hava atan"  yeniyetmeler de bu yazının ilgi alanına girmiyor. Bohemian Rhapsody'nin içindeki pattern'i ve yaratıcılığı görebilen insanlardan bahsediyorum.

Peki neden yazılım ve motosiklet değil de python ve enduro?

Aslında konunun altında yatan toplumun çizdiği iki düz çizginin arasında gitmektense çizgilerin dışında ilerleyen insanlar. Yaratıcılıklarının farkında olanlar. Python nasıl open source dünyasının bir markası ise kullandığım motosiklet olan Honda-CRF'de enduro dünyasının bir markası. İkisi de ilk başlandığında aksaklıklarla başlar. İkiside bildiğiniz kalıpların dışındadır çünkü. 

İlk enduro makinamla araziden inip piste girdiğimizde rampada takla atıp düştükten sonra 1 ay boyunca sağ tarafıma yatarken kemiğim ağrımıştı. Ama o 1 günlük haz 1 ay boyunca mutlu uyuyabilemmi ve tekrar piste gideceğim günü hayal etmemi sağladı. Son düşüşüm oldu. Ne yapmam gerektiğini artık biliyordum.

Pythonla ilk kod yazdığım zamanlarda loop döngülerindeki zaman kaybı yüzüme tokat gibi çarpmıştı.  Ama loop'un içini map ettikten, bir kaç optimizasyondan  ve pypy ile çalıştırdıktan sonra ARM bir makinada C'ye yakın bir performans elde edince aldığım haz tarif edilemezdi.

Artık biliyordum. Ne hayabusa ne de R1 beni arazide takip edemezlerdi.

Artık biliyordum ne C# ne de senelerce ekmeğini yediğim Java artık beni takip edemezlerdi.

CRF ile artık trafiğin içinde sıkışmış değildim. Önümde yepyeni bir dünya vardı bu sıkış trafikte. Kaldırımlar ve merdivenler :)

Python ile yazılım dünyasının doktrinleri arasında sıkışmış değildim. Her ne kadar python nesne yönelimli bir dil olarak bilinsede esasen alakası yoktur, nesne tabanlı bir dildir ve bu da yazmak istediğiniz tipe göre biçim değiştirmenize olanak sağlar. Bu da yaratıcılığıma kimsenin gem vuramıyacağı anlamına geliyordu :)

Arazide düştükten sonra ben bir ayda kendime gelebilirken , motorumun yamulan gidonunun ve ayak peginin bir klavuz ve mengene yardımıyla 10 dk da düzeltildiğini ve orjinali gibi olduğunu gördüğümde anladım ki herhangi bir sorunda beni yarıyolda bırakmıyacaktı ve düzeltmem dakikalarımı alacaktı.

Django ile sıfırdan ilk blogumu oluşturduğumda(bu oluyor kendileri) eşim köklü bir değişiklik istediğinde bana sadece yarım saat zamana mal olduğunu gördüğümde anladım ki beni yarıyolda bırakmıyacaktı ve düzeltmem dakikalarımı alacaktı.

Arkadaşımın R1'i ile otobanda kalıp, servisin gıkını çıkarmayıp, taşımacıya bir ton para ödeyip kendi parasıyla rezil olmasını izlerken, bir başka arkadaşım dağda kaldığında enduro kullananların bir kurtarma ekibi oluşturduğunu gördüğümde kullandığım motosikletin değerini bir kez daha anladım.

Çalıştığım iş yerleri C# ve benzeri dillerde destek almak için bir ton para ödeyip paralarıyla rezil olurken; sıkıştığımda irc üzerinden insanların yardımcı olmak için bana can attıklarını gördüğümde açık kaynak kod paylaşımcılığının değerini bir kez daha anladım.

Sözün özü Python dünyası da enduro dünyası da paylaşım ve özgürlük üzerine kuruludur. Ama hayatları boyunca ne paylaşmayı ne de gerçek anlamda özgürlüğü tatmamış olanlara anlatması zor oluyor maalesef :)

Results:

Arm - Beagleboard

80x86 64bit (4 core but single thread)

Test Code:

# -*- coding: utf-8 -*-
import time

__author__ = 'ozgur'
__creation_date__ = '4/1/16' '4:11 PM'

TEST_STRING = '''The hierarchy shown above is relative to a PREFIX directory. PREFIX is computed by starting from the directory where the executable resides, and “walking up” the filesystem until we find a directory containing lib_pypy and lib-python/2.7.
The archives (.tar.bz2 or .zip) containing PyPy releases already contain the correct hierarchy, so to run PyPy it’s enough to unpack the archive, and run the bin/pypy executable.
To install PyPy system wide on unix-like systems, it is recommended to put the whole hierarchy alone (e.g. in /opt/pypy2.1) and put a symlink to the pypy executable into /usr/bin or /usr/local/bin
If the executable fails to find suitable libraries, it will report debug: WARNING: library path not found, using compiled-in sys.path and then attempt to continue normally. If the default path is usable, most code will be fine. However, the sys.prefix will be unset and some existing libraries assume beni bul that this is never the case.'''


class StressSuite():
    def __init__(self):
        pass

    @staticmethod
    def test_array():
        a = []
        for y in range(1000000):
            txt_arr = "deneme".split()
            for item in txt_arr:
                a.append(item)
        del (a)

    @staticmethod
    def test_float():
        a = 0.5612342
        b = 653.324556
        c = a + b
        d = a * b
        e = b / a
        f = a - b

    @staticmethod
    def test_int():
        a = 5612342
        b = 653324556
        c = a + b
        d = a * b
        e = b / a
        f = a - b

    @staticmethod
    def test_string():
        b = TEST_STRING.find("beni bul")

    def runtest(self, label, loop, func_exec):
        print "Testing : ", label
        s_time = time.time()
        for x in range(loop):
            func_exec()
        print "%s exec time : %.3f sn." % (label, (time.time() - s_time))

    def run(self):
        s_time = time.time()
        self.runtest("Array Copy", 100, StressSuite.test_array)
        self.runtest("Float Arithmetic", 100000000, StressSuite.test_float)
        self.runtest("Integer Arithmetic", 100000000, StressSuite.test_int)
        self.runtest("String Search", 10000000, StressSuite.test_string)
        print "Total exec time : %.3f sn." % (time.time() - s_time)


if __name__ == '__main__':
    ss = StressSuite()
    ss.run()

Here's a summary of the ways to call external programs and the advantages and disadvantages of each:

1. os.system("some_command with args") passes the command and arguments to your system's shell. This is nice because you can actually run multiple commands at once in this manner and set up pipes and input/output redirection. For example,
   os.system("some_command < input_file | another_command > output_file")
   However, while this is convenient, you have to manually handle the escaping of shell characters such as spaces, etc. On the other hand, this also lets you run commands which are simply shell commands and not actually external programs.
   see documentation

2. stream = os.popen("some_command with args") will do the same thing as os.systemexcept that it gives you a file-like object that you can use to access standard input/output for that process. There are 3 other variants of popen that all handle the i/o slightly differently. If you pass everything as a string, then your command is passed to the shell; if you pass them as a list then you don't need to worry about escaping anything.
   see documentation

3. The Popen class of the subprocess module. This is intended as a replacement for os.popen but has the downside of being slightly more complicated by virtue of being so comprehensive. For example, you'd say

   print subprocess.Popen("echo Hello World", shell=True, stdout=subprocess.PIPE).stdout.read()

   instead of

   print os.popen("echo Hello World").read()

   but it is nice to have all of the options there in one unified class instead of 4 different popen functions.
   see documentation

4. The call function from the subprocess module. This is basically just like the Popen class and takes all of the same arguments, but it simply waits until the command completes and gives you the return code. For example:

   return_code = subprocess.call("echo Hello World", shell=True)  

   see documentation

5. If you're on Python 3.5 or later, you can use the new subprocess.run function, which is a lot like the above but even more flexible and returns a CompletedProcess object when the command finishes executing.

6. The os module also has all of the fork/exec/spawn functions that you'd have in a C program, but I don't recommend using them directly.

The subprocess module should probably be what you use.

Finally please be aware that for all methods where you pass the final command to be executed by the shell as a string and you are responsible for escaping it there are serious security implications if any part of the string that you pass can not be fully trusted (for example if a user is entering some/any part of the string). If unsure only use these methods with constants. To give you a hint of the implications consider this code

print subprocess.Popen("echo %s " % user_input, stdout=PIPE).stdout.read()

and imagine that the user enters "my mama didnt love me && rm -rf /".

Database :

Storm

https://github.com/Said007/iterable_orm

https://github.com/EliotBerriot/lifter

GUI:

https://pypi.python.org/pypi/htmlPy/