സൈത്തൺ

പൈത്തൺ പ്രോഗ്രാമിങ് ഭാഷയുടെ സൂപ്പർസെറ്റാണ് സൈത്തൺ (Cython), പൈത്തണിൽ ആണ് കൂടുതലും എഴുതിയിട്ടുള്ളത്, ഇത് സിയ്ക്ക് തുല്യമായ പ്രകടനത്തിന് വേണ്ടി രൂപകൽപ്പന ചെയ്തിട്ടുള്ളതാണ്.

Cython

വികസിപ്പിച്ചത്	Robert Bradshaw, Stefan Behnel, et al.
ആദ്യപതിപ്പ്	28 ജൂലൈ 2007 (2007-07-28)
റെപോസിറ്ററി	github.com/cython/cython
ഭാഷ	Python, C
തരം	Programming language
അനുമതിപത്രം	Apache License
വെബ്‌സൈറ്റ്	cython.org

സിപൈത്തൺ എക്സ്റ്റെൻഷൻ മൊഡ്യൂളുകൾ സൃഷ്ടിക്കുന്ന ഒരു കംപൈൽ ഭാഷയാണ് സൈത്തൺ. ഈ വിപുലീകരണ മൊഡ്യൂളുകൾ പിന്നീട് ലോഡ് ചെയ്യാനാകും. ഇംപോർട്ട് നിർദ്ദേശം വഴി പൈത്തൺ കോഡ് ഉപയോഗിക്കുകയും ചെയ്യുന്നു.

പൈത്തണിൽ സൈത്തൺ തയ്യാറാക്കി, വിൻഡോസ്, മാക് ഒഎസ്, ലിനക്സ് എന്നിവയിൽ സിപൈത്തൺ 3.6 കൂടി 2.6, 2.7, 3.3 എന്നിവ ഉപയോഗിച്ച് പൊരുത്തപ്പെടുന്ന സോഴ്സ് ഫയലുകൾ ഉണ്ടാക്കുന്നു.

രൂപരേഖ

ഒരു പൈത്തൺ ഘടകം നിർമ്മിച്ചുകൊണ്ട് സൈത്തൺ പ്രവർത്തിക്കുന്നു. എന്നിരുന്നാലും, മോഡുൾ കോഡ്,സ്റ്റാൻഡേർഡ് പൈത്തണിൽ നിന്നും വ്യത്യസ്തമാണ്. യഥാർത്ഥത്തിൽ പൈത്തണിലാണ് എഴുതുന്നത്, സിയിലേക്ക് വിവർത്തനം ചെയ്തിട്ടുണ്ട്. തത്ഫലമായുണ്ടാകുന്ന കോഡ് വേഗതയേറിയതാണ്, സിപൈത്തൺ ഇൻറർപ്രെട്ടറിൽ പല കോളുകളും ചെയ്യുന്നു. യഥാർത്ഥ പ്രവർത്തനം നടത്താൻ പൈത്തൺ അടിസ്ഥാന ലൈബ്രറികൾ ഉപയോഗപ്പെടുത്തുന്നു. ഈ ക്രമീകരണം തെരഞ്ഞെടുത്തതുകൊണ്ട്, സൈത്തണിൻറെ വികസന സമയം ലാഭിക്കാൻ കാരണമായി, എന്നാൽ ഘടകങ്ങൾക്ക് (Modules) പല കാര്യങ്ങൾക്കും പൈത്തൺ ഇൻറർപ്രെട്ടർ, സ്റ്റാൻഡേർഡ് ലൈബ്രറി എന്നിവയെ ആശ്രയിക്കേണ്ടി വരാറുണ്ട്.

കോഡ് മിക്കതും സി അടിസ്ഥാനമാക്കിയുള്ളതാണെങ്കിലും, പൈത്തൺ ഇൻറർപ്രെട്ടറിൽ എഴുതപ്പെട്ട ഒരു സ്റ്റബ് ലോഡർ സാധാരണയായി ആവശ്യമാണ്(സിയിൽ പൂർണ്ണമായും എഴുതുന്ന ലോഡർ സൃഷ്ടിക്കാൻ ലക്ഷ്യം നിർത്തുകയില്ലെങ്കിൽ, സിപൈത്തണിൻറെ രേഖകളില്ലാത്ത ഇൻറേണലുമായി പ്രവർത്തിക്കുവാൻ ഇടയുണ്ട്). എങ്കിലും, പൈത്തൺ ഇൻറർപ്രെട്ടർ സാന്നിദ്ധ്യമുള്ളതിനാൽ ഇതൊരു വലിയ പ്രശ്നമല്ല.

സൈത്തണിന് സി / സി++ റുട്ടീനുകൾ വിളിക്കുവാനുള്ള ഒരു ഫോറിൻ ഫങ്ഷൻ ഇൻറർഫെയിസും, സ്റ്റാറ്റിക് തരം സബ്റൂട്ടീൻ പരാമീറ്ററുകളും അതിൻറെ ഫലങ്ങളും, ലോക്കൽ വേരിയബിളുകൾ, ക്ലാസ് ആട്രിബ്യൂട്ടുകൾ എന്നിവ പ്രഖ്യാപിക്കുന്നതിനുള്ള കഴിവുമുണ്ട്.

ഒരു പൈത്തൺ പ്രോഗ്രാമിന് സമാനമായ ആൽഗോരിതം നടപ്പിലാക്കുന്ന ഒരു സൈത്തൺ പ്രോഗ്രാമിന് സിപൈത്തൺ (CPython), സൈത്തൺ എക്സിക്യൂഷൻ മോഡലുകൾ തമ്മിലുള്ള വ്യത്യാസങ്ങൾ കാരണം കോർ മെമ്മറി, പ്രൊസസിംഗ് സൈക്കിൾസ് എന്നിവ പോലുള്ള കുറച്ച് കമ്പ്യൂട്ടിംഗ് വിഭവങ്ങൾ ഉപയോഗപ്പെടുത്താം. സിപൈത്തൺ വിർച്ച്വൽ മെഷീൻ ഒരു അടിസ്ഥാന പൈത്തൺ പ്രോഗ്രാം ലോഡ് ചെയ്ത് എക്സിക്യൂട്ട് ചെയ്യുന്നു. അതിനാൽ റൺടെമും പ്രോഗ്രാമും കമ്പ്യൂട്ടിംഗ് ഉറവിടങ്ങൾ ഉപയോഗിക്കുന്നു. ഒരു സൈത്തൺ പ്രോഗ്രാം സി കോഡിലേക്ക് കംപൈൽ ചെയ്യുന്നു, ഇത് വീണ്ടും മെഷീൻ കോഡിലേക്ക് കംപൈൽ ചെയ്യുന്നു, അതിനാൽ പ്രോഗ്രാം ലോഡ് ചെയ്യുമ്പോൾ വെർച്വൽ മെഷീൻ ചുരുക്കമായി മാത്രമേ ഉപയോഗിക്കുന്നുള്ളു. സൈത്തൺ ഇനി പറയുന്ന കാര്യങ്ങളിൽ വ്യാപ‌ൃതമാക്കുന്നു:

• ഓപ്റ്റിമിക്കൽ ഒപ്റ്റിമൈസേഷനുകൾ
• ടൈപ്പുചെയ്യൽ അനുപേക്ഷണം (ഓപ്ഷണൽ)
• നിയന്ത്രണ സംവിധാനങ്ങളിൽ താഴ്ന്ന ഓവർഹെഡ്
• കുറഞ്ഞ പ്രവർത്തന കോൾ ഓവർഹെഡ്

സൈത്തണിൻറെ പ്രകടനം സി കോഡ് സൃഷ്ടിക്കുന്നതെങ്ങനെയെന്നും ആ കോഡ് കോ കമ്പൈലർ എങ്ങനെ സമാഹരിക്കുമെന്നും ആശ്രയിച്ചിരിക്കുന്നു.

ചരിത്രം

പൈറോക്സ് ഭാഷയുടെ ഒരു ഡെറിവേറ്റീവ് ആണ് സൈത്തൺ, പൈറക്സിനെക്കാൾ കൂടുതൽ സവിശേഷതകളും ഒപ്റ്റിമൈസേഷനുകളും പിന്തുണയ്ക്കുന്നു.

2007 ൽ സേയ്ജ് കമ്പ്യൂട്ടർ ആൾജിബ്ര പാക്കേജിൻറെ ഡെവലപ്പർമാർ, സൈത്തൺ പൈറെക്സിൽ നിന്ന് ഫോർക്ക് ചെയ്തതാണ്. കാരണം പൈറെക്സിൻറെ പരിമിതികൾ അവരെ അസ്വസ്ഥരാക്കി, പൈറെക്സിൻറെ സംരക്ഷകനായ ഗ്രെഗ് എവിങിൻറെ പാച്ചുകൾ അംഗീകാരം നേടാനായില്ല, സേയ്ജിൻറെ ഡെവലപ്പറന്മാർ വിചാരിച്ചതിനെക്കാൾ ചെറിയ സ്കോപ്പ് ആണ് ഉപയോഗത്തിലുണ്ടായിരുന്നത്. അവർ പൈറെക്സ് സെയ്ജ് എക്സ് എന്നാക്കി.(എക്സ്.ആർ. ലൈബ്രറി എൽഎക്സ്എൽഎൽ പരിപാലിക്കുന്ന സ്റ്റീഫൻ ബെൻനൽ), പൈറെക്സിൻറെ ഫോർക്ക് പരിപാലിക്കുകയും, സേജ്എക്സ്(SageX) സേയ്ജ് പ്രോജക്റ്റിനെ പിളർത്തുകയും Cython-lxml ലും സൈത്തണുമായി ലയിപ്പിക്കുകയും ചെയ്തു.

സൈത്തൺ ഫയലുകൾക്ക്.pyx എക്സറ്റെൻഷനുണ്ട്. അതിലെ ഏറ്റവും അടിസ്ഥാന സൈത്തൺ കോഡ് പൈത്തൺ കോഡ് പോലെയാണ്. എന്നിരുന്നാലും, അടിസ്ഥാന പൈത്തൺ ചലനാത്മകമായി ടൈപ്പ് ചെയ്യുമ്പോൾ, സൈത്തണിൽ തരങ്ങൾക്ക് ഓപ്ഷണലായി നൽകാം, ഇത് മെച്ചപ്പെട്ട പ്രകടനത്തിന് അനുവദിക്കുന്നു, സാധ്യമാകുന്ന ഇടങ്ങളിലെ ലൂപ്പുകൾ സി ലൂപ്പുകളായി മാറ്റാൻ അനുവദിക്കുന്നു ഉദാഹരണത്തിന്:

def primes(int kmax):  # The argument will be converted to int or raise a TypeError.
    cdef int n, k, i  # These variables are declared with C types.
    cdef int p[1000]  # Another C type
    result = []  # A Python type
    if kmax > 1000:
        kmax = 1000
    k = 0
    n = 2
    while k < kmax:
        i = 0
        while i < k and n % p[i] != 0:
            i = i + 1
        if i == k:
            p[k] = n
            k = k + 1
            result.append(n)
        n = n + 1
    return result

ഉദാഹരണം

Hello World in Cython

സൈത്തണിൻറെ ഒരു മാതൃകാ ഹലോ വേൾഡ് പ്രോഗ്രാം മിക്ക ഭാഷകളിലും ഉള്ളതിനേക്കാൾ സങ്കീർണ്ണമാണ് കാരണം പൈത്തൺ സി എപിഐയും(C API)setuptools എക്സ്റ്റൻഷൻ ബിൽഡിങ് സൗകര്യവും തമ്മിൽ ഇൻറർഫേസു ചെയ്യുന്നു. ഒരു അടിസ്ഥാന പ്രോജക്റ്റിനായി ചുരുങ്ങിയത് മൂന്ന് ഫയലുകൾ ആവശ്യമാണ്:

• സെറ്റ്അപ്പ്ടൂളുകൾ നിർമ്മിക്കാൻ ഒരു setup.py ഫയൽ എക്സ്റ്റഷൻ മോഡൂൾ സൃഷ്ടിക്കുന്നു.
• എക്സ്റ്റെൻഷൻ മൊഡ്യൂൾ ലോഡ് ചെയ്യുന്നതിനുള്ള ഒരു പ്രധാന പൈത്തൺ പ്രോഗ്രാം
• സൈത്തൺ സോഴ്സ് ഫയൽ (കൾ)

ഇനിപ്പറയുന്ന കോഡ് ലിസ്റ്റിംഗുകൾ നിർമ്മിക്കുകയും, സമാരംഭിക്കുകയും അത് പ്രദർശിപ്പിക്കുകയും ചെയ്യുന്ന പ്രവർത്തനങ്ങൾ കാണിക്കുന്നു:

# hello.pyx - Python Module, this code will be translated to C by Cython.
def say_hello():
    print "Hello World!"

# launch.py - Python stub loader, loads the module that was made by Cython.

# This code is always interpreted, like normal Python.
# It is not compiled to C.

import hello
hello.say_hello()

# setup.py - unnecessary if not redistributing the code, see below
from setuptools import setup
from Cython.Build import cythonize

setup(name = 'Hello world app',
      ext_modules = cythonize("*.pyx"))

ഈ നിർദ്ദേശങ്ങൾ ഈ പ്രോഗ്രാം നിർമ്മിക്കുകയും ആരംഭിക്കുകയും ചെയ്യുന്നു:

$ python setup.py build_ext --inplace
$ python launch.py

ഐപൈത്തൺ / ജുപ്പീറ്റർ(IPython / Jupter) നോട്ട്ബുക്ക് ഉപയോഗിക്കുന്നു

സൈത്തൺ ആരംഭിക്കുന്നതിനുള്ള കൂടുതൽ ലളിതമായ മാർഗ്ഗമാണ് കമാൻഡ് ലൈൻ ഐപൈത്തൺ (അല്ലെങ്കിൽ ബ്രൌസർ പൈത്തൺ കൺസോൾ വഴി ജുപ്പീറ്റർ നോട്ട്ബുക്ക്):

In [1]: %load_ext Cython

In [2]: %%cython
   ...: def f(n):
   ...:     a = 0
   ...:     for i in range(n):
   ...:         a += i
   ...:     return a
   ...: 
   ...: cpdef g(int n):
   ...:     cdef int a = 0, i
   ...:     for i in range(n):
   ...:         a += i
   ...:     return a
   ...: 

In [3]: %timeit f(1000000)
42.7 ms ± 783 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

In [4]: %timeit g(1000000)
74 µs ± 16.6 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

ശുദ്ധമായ പൈത്തൺ പതിപ്പിനേക്കാൾ 585 മടങ്ങ് മെച്ചപ്പെടുത്തുന്നു. ഈ വിഷയത്തെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾ ഔദ്യോഗിക ദ്രുതഗതിയിലുള്ള പേജിൽ കാണാം.

ഉപയോഗങ്ങൾ

പൈത്തണിൻറെ ശാസ്ത്രീയ ഉപയോക്താക്കളുടെ ഇടയിൽ സൈത്തൺ പ്രത്യേകിച്ചും പ്രസിദ്ധമാണ്, പൈത്തൺ ഡെവലപ്പർ ഗൈഡോ വാൻ റോസ്സം പറയുന്ന പ്രകാരം "പൂർണതയുള്ള പ്രേക്ഷകരുണ്ട്". പ്രത്യേക കുറിപ്പുകൾ താഴെ കൊടുക്കുന്നു:

• സ്വതന്ത്ര സോഫ്റ്റ്‌വേർ സേയ്ജ്മാത്ത് (SageMath) കമ്പ്യൂട്ടർ ആൾജിബ്ര സംവിധാനം പ്രകടനത്തിനും മറ്റ് ലൈബ്രറികളുമായുള്ള ഇൻറർഫെയിസിനേയും സൈത്തണെ ആശ്രയിച്ചിരിക്കുന്നു.
• ശാസ്ത്രീയ കമ്പ്യൂട്ടിംഗ് ലൈബ്രറികളുടെ പ്രധാന ഭാഗങ്ങൾ സൈപൈ(SciPy), പാണ്ടാസ്(pandas), സൈകിറ്റ്(scikit)-പഠനങ്ങൾ എന്നിവ സൈത്തണിൽ എഴുതപ്പെടുന്നു.
• ക്വോറ പോലുള്ള ഉയർന്ന ട്രാഫിക്ക് വെബ്സൈറ്റുകൾ സൈത്തൺ ഉപയോഗിക്കുന്നു.

സൈത്തണിൻറെ ഡൊമെയ്ൻ വെറും സംഖ്യാപര കമ്പ്യൂട്ടിംഗിന് മാത്രമായി പരിമിതപ്പെടുത്തിയിട്ടില്ല. ഉദാഹരണത്തിന്, എൽഎക്സ്എംഎൽ(lxml) എക്സ്എംഎൽ ടൂൾകിറ്റ് (xml toolkit) സൈത്തണിൽ മുൻപത്തെ, കൂടാതെ പൈറെക്സിൻറെ മുൻഗാമിയെ പോലെ, സൈത്തൺ പല സി,സി++ ലൈബ്രറികൾക്കായി പൈത്തൺ ബൈൻഡിംഗ്സ് നൽകുന്നതിനായി സിറോഎംക്യൂ(ZeroMQ) സന്ദേശമയക്കൽ ലൈബ്രറി പോലുള്ളവ ഉപയോഗിക്കുന്നു.മൾട്ടി കോർ പ്രോസസ്സർ യന്ത്രങ്ങൾക്ക് സമാന്തര പ്രോഗ്രാമുകൾ വികസിപ്പിക്കുന്നതിനും സൈത്തൺ ഉപയോഗിക്കാം. ഓപ്പൺഎംബിയുടെ( OpenMP) ഈ സവിശേഷത പ്രയോജനപ്പെടുത്തുന്നു.

ഇതും കാണുക

• പൈപൈ
• നുംബ