kivy ट्यूटोरियल
शुरुआत किवी से हो रही है

Android Django Git iOS Java Language GNU/Linux matplotlib MySQL opencv Python Language

टिप्पणियों

किवी क्रॉस-प्लेटफॉर्म यूजर इंटरफेस के तेजी से विकास के लिए एक खुला स्रोत पायथन लाइब्रेरी है। किवी एप्लिकेशन को लिनक्स, विंडोज, ओएस एक्स, एंड्रॉइड और आईओएस के लिए एक ही कोडबेस का उपयोग करके विकसित किया जा सकता है।

ग्राफिक्स ओपन विजेट ईएस 2 के बजाय देशी विगेट्स के माध्यम से प्रस्तुत किए जाते हैं, जिससे ऑपरेटिंग सिस्टम में काफी समान उपस्थिति होती है।

Kivy में वैकल्पिक रूप से इंटरफेस विकसित करना kvlang का उपयोग करना शामिल है, एक छोटी सी भाषा जो अजगर जैसी अभिव्यक्तियों और अजगर इंटरॉप का समर्थन करती है। अजगर का उपयोग विशेष रूप से पायथन का उपयोग करने की तुलना में उपयोगकर्ता इंटरफ़ेस के विकास को काफी सरल कर सकता है।

Kivy उपयोग करने के लिए स्वतंत्र है (वर्तमान में MIT लाइसेंस के तहत), और पेशेवर रूप से समर्थित है।

स्थापना और सेटअप

खिड़कियाँ

किवी स्थापित करने के दो विकल्प हैं:

पहले सुनिश्चित करें कि अजगर उपकरण अप-टू-डेट हैं।

python -m pip install --upgrade pip wheel setuptools

फिर मूल निर्भरता स्थापित करें।

python -m pip install docutils pygments pypiwin32 kivy.deps.sdl2 kivy.deps.glew

यद्यपि किवी में पहले से ही ऑडियो और वीडियो के लिए प्रदाता हैं, अधिक उन्नत सामान के लिए GStreamer की आवश्यकता है।

python -m pip install kivy.deps.gstreamer --extra-index-url https://kivy.org/downloads/packages/simple/

इसे सरल बनाने के लिए, निम्न पाठ में <python> का अर्थ है निर्देशिका के लिए पथ python.exe फ़ाइल।

पहिया
व्हील पैकेज संकलित कीवी प्रदान करता है, लेकिन हटाए गए cython स्रोत घटकों के साथ, जिसका अर्थ है कि कोर कोड को इस तरह से उपयोग करके पुन: संकलित नहीं किया जा सकता है। पाइथन कोड, हालांकि, संपादन योग्य है।
कीवी का स्थिर संस्करण पिपी पर उपलब्ध है।
```
python -m pip install kivy
```
आधिकारिक रिपॉजिटरी का नवीनतम संस्करण रात में निर्मित पहिए के माध्यम से उपलब्ध है जो Google ड्राइव पर उपलब्ध है। अपने अजगर संस्करण से मेल खाते डॉक्स में लिंक पर जाएं। एक उचित पहिया डाउनलोड होने के बाद, इस उदाहरण के प्रारूपण से मेल खाने के लिए इसका नाम बदलें और कमांड चलाएं।
```
python -m pip install C:\Kivy-1.9.1.dev-cp27-none-win_amd64.whl
```
स्रोत
पहियों का उपयोग करने की तुलना में स्रोत से कीवी को स्थापित करने के लिए अधिक आवश्यक निर्भरताएं हैं, लेकिन स्थापना अधिक लचीला है।
स्रोत कोड के लिए एक उचित संकलक का उपयोग करने के लिए इन पंक्तियों के साथ <python>\Lib\distutils\distutils.cfg में एक नई फ़ाइल बनाएँ।
```
[build]
compiler = mingw32
```
फिर कंपाइलर की जरूरत होती है। या तो आप पहले से ही स्थापित कुछ का उपयोग करें, या mingwpy डाउनलोड mingwpy । gcc.exe जैसी महत्वपूर्ण फाइलें <python>\Scripts में स्थित होंगी।
```
python -m pip install -i https://pypi.anaconda.org/carlkl/simple mingwpy
```
Kivy को यह बताने के लिए कि वह क्या उपयोग करना चाहिए, यह बताने के लिए पर्यावरण चर सेट करना न भूलें।
```
set USE_SDL2=1
set USE_GSTREAMER=1
```
अब संकलन के लिए आवश्यक अतिरिक्त निर्भरताएं स्थापित करें।
```
python -m pip install cython kivy.deps.glew_dev kivy.deps.sdl2_dev
python -m pip install kivy.deps.gstreamer_dev --extra-index-url https://kivy.org/downloads/packages/simple/
```
सब कुछ ठीक से सेट और किवी स्थापित करने के लिए Paths अनुभाग की जाँच करें। इनमें से कोई एक विकल्प चुनें:
```
python -m pip install C:\master.zip
python -m pip install https://github.com/kivy/kivy/archive/master.zip
```

पथ

किवी को कुछ निर्भरताओं से बायनेरिज़ तक पहुंच की आवश्यकता है। इसका मतलब है कि सही फ़ोल्डर्स को पर्यावरण के PATH चर पर होना चाहिए।

set PATH=<python>\Tools;<python>\Scripts;<python>\share\sdl2\bin;%PATH%

इस तरह से पायथन IDLE IDE को पथ के साथ शामिल किया जा सकता है <python>\Lib\idlelib; । फिर idle को कंसोल में लिखें और कीवी का उपयोग करने के लिए IDLE तैयार हो जाएगा।

इसे सरल कीजिए

पर्यावरण चर की दोहरावदार सेटिंग से बचने के लिए या तो इस तरह से प्रत्येक आवश्यक पथ निर्धारित करें या इन पंक्तियों के साथ एक बैच ( .bat ) फ़ाइल बनाएं <python> :

set PATH=%~dp0;%~dp0Tools;%~dp0Scripts;%~dp0share\sdl2\bin;%~dp0Lib\idlelib;%PATH%
cmd.exe

cmd.exe या बैच फ़ाइल चलाने के बाद Kivy प्रोजेक्ट चलाने के लिए और python <filename>.py उपयोग करें

उबंटू पर स्थापना

किवी उदाहरण खुले टर्मिनल के साथ ubuntu पर किवी स्थापित करने के लिए और निम्नलिखित आदेश चलाएँ

सबसे पहले ppa जोड़ें

 sudo add-apt-repository ppa:kivy-team/kivy

स्थापित करने के लिए

 sudo apt-get install python-kivy

किवी उदाहरणों को स्थापित करने के लिए

 sudo apt-get install python-kivy-example

स्पर्श करें, पकड़ो और स्थानांतरित करो

निम्नलिखित उदाहरण 2 बिंदुओं और बीच में 1 पंक्ति के साथ एक कैनवास बनाता है। आप बिंदु और रेखा को चारों ओर ले जाने में सक्षम होंगे।

from kivy.app import App
from kivy.graphics import Ellipse, Line
from kivy.uix.boxlayout import BoxLayout


class CustomLayout(BoxLayout):

    def __init__(self, **kwargs):
        super(CustomLayout, self).__init__(**kwargs)

        self.canvas_edge = {}
        self.canvas_nodes = {}
        self.nodesize = [25, 25]

        self.grabbed = {}

        #declare a canvas
        with self.canvas.after:
            pass

        self.define_nodes()
        self.canvas.add(self.canvas_nodes[0])
        self.canvas.add(self.canvas_nodes[1])
        self.define_edge()
        self.canvas.add(self.canvas_edge)
    

    def define_nodes(self):
        """define all the node canvas elements as a list"""

        self.canvas_nodes[0] = Ellipse(
            size = self.nodesize,
            pos =  [100,100]
            )

        self.canvas_nodes[1] = Ellipse(
            size = self.nodesize,
            pos =  [200,200]
            )

    def define_edge(self):
        """define an edge canvas elements"""


        self.canvas_edge = Line(
            points =  [
                self.canvas_nodes[0].pos[0] + self.nodesize[0] / 2,
                self.canvas_nodes[0].pos[1] + self.nodesize[1] / 2,
                self.canvas_nodes[1].pos[0] + self.nodesize[0] / 2,
                self.canvas_nodes[1].pos[1] + self.nodesize[1] / 2
                ],
            joint = 'round',
            cap = 'round',
            width = 3
            )


    def on_touch_down(self, touch):

        for key, value in self.canvas_nodes.items():
            if (value.pos[0] - self.nodesize[0]) <= touch.pos[0] <= (value.pos[0] + self.nodesize[0]):
                if (value.pos[1] - self.nodesize[1]) <= touch.pos[1] <= (value.pos[1] + self.nodesize[1]):
                    touch.grab(self)
                    self.grabbed = self.canvas_nodes[key]
                    return True

    def on_touch_move(self, touch):

        if touch.grab_current is self:
            self.grabbed.pos = [touch.pos[0] - self.nodesize[0] / 2, touch.pos[1] - self.nodesize[1] / 2]
            self.canvas.clear()
            self.canvas.add(self.canvas_nodes[0])
            self.canvas.add(self.canvas_nodes[1])
            self.define_edge()
            self.canvas.add(self.canvas_edge)
        else:
            # it's a normal touch
            pass

    def on_touch_up(self, touch):
        if touch.grab_current is self:
            # I receive my grabbed touch, I must ungrab it!
            touch.ungrab(self)
        else:
            # it's a normal touch
            pass

class MainApp(App):

    def build(self):
        root = CustomLayout()
        return root

if __name__ == '__main__':
    MainApp().run()

हैलो दुनिया kivy में।

निम्न कोड दिखाता है कि kivy में 'हैलो वर्ल्ड' ऐप कैसे बनाया जाता है। इस ऐप को ios में चलाएं और android इसे main.py के रूप में सहेजें और buildozer का उपयोग करें।

from kivy.app import App
from kivy.uix.label import Label
from kivy.lang import Builder

Builder.load_string('''
<SimpleLabel>:
    text: 'Hello World'
''')


class SimpleLabel(Label):
    pass


class SampleApp(App):
    def build(self):
        return SimpleLabel()

if __name__ == "__main__":
    SampleApp().run()

किवी में सरल पॉपअप उदाहरण।

निम्नलिखित कोड किवी के साथ सरल पॉपअप करने का तरीका बताता है।

from kivy.app import App
from kivy.uix.popup import Popup
from kivy.lang import Builder
from kivy.uix.button import Button

Builder.load_string('''
<SimpleButton>:
    on_press: self.fire_popup()
<SimplePopup>:
    id:pop
    size_hint: .4, .4
    auto_dismiss: False
    title: 'Hello world!!'
    Button:
        text: 'Click here to dismiss'
        on_press: pop.dismiss()
''')


class SimplePopup(Popup):
    pass

class SimpleButton(Button):
    text = "Fire Popup !"
    def fire_popup(self):
        pops=SimplePopup()
        pops.open()

class SampleApp(App):
    def build(self):
        return SimpleButton()

SampleApp().run()

RecycleView

from kivy.app import App
from kivy.lang import Builder
from kivy.uix.button import Button


items = [
    {"color":(1, 1, 1, 1), "font_size": "20sp", "text": "white",     "input_data": ["some","random","data"]},
    {"color":(.5,1, 1, 1), "font_size": "30sp", "text": "lightblue", "input_data": [1,6,3]},
    {"color":(.5,.5,1, 1), "font_size": "40sp", "text": "blue",      "input_data": [64,16,9]},
    {"color":(.5,.5,.5,1), "font_size": "70sp", "text": "gray",      "input_data": [8766,13,6]},
    {"color":(1,.5,.5, 1), "font_size": "60sp", "text": "orange",    "input_data": [9,4,6]},
    {"color":(1, 1,.5, 1), "font_size": "50sp", "text": "yellow",    "input_data": [852,958,123]}
]


class MyButton(Button):

    def print_data(self,data):
        print(data)


KV = '''

<MyButton>:
    on_release:
        root.print_data(self.input_data)

RecycleView:
    data: []
    viewclass: 'MyButton'
    RecycleBoxLayout:
        default_size_hint: 1, None
        orientation: 'vertical'

'''


class Test(App):
    def build(self):
        root = Builder.load_string(KV)
        root.data = [item for item in items]
        return root


Test().run()

एक साधारण ऐप चलाने और विजेट्स के साथ बातचीत करने के लिए अलग-अलग तरीके

अधिकांश कीवी ऐप्स इस संरचना से शुरू होते हैं:

from kivy.app import App

class TutorialApp(App):
    def build(self):
        return 
TutorialApp().run()

यहाँ से जाने के लिए कई रास्ते हैं:

नीचे दिए गए सभी कोड (उदाहरण 1 और 3 को छोड़कर) में एक ही विजेट और समान विशेषताएं हैं, लेकिन ऐप बनाने के लिए अलग-अलग तरीके दिखाते हैं।

उदाहरण 1: एकल विजेट लौटना (सरल हैलो वर्ल्ड ऐप)

from kivy.app import App
from kivy.uix.button import Button
class TutorialApp(App):
    def build(self):
        return Button(text="Hello World!")
TutorialApp().run()

उदाहरण 2: कई विजेट लौटाता है + बटन लेबल के पाठ को प्रिंट करता है

from kivy.app import App
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.label import Label
from kivy.uix.button import Button

class TutorialApp(App):
    def build(self):
        mylayout = BoxLayout(orientation="vertical")
        mylabel = Label(text= "My App")
        mybutton =Button(text="Click me!")  
        mylayout.add_widget(mylabel)
        mybutton.bind(on_press= lambda a:print(mylabel.text))
        mylayout.add_widget(mybutton)
        return mylayout
TutorialApp().run()

उदाहरण 3: एक वर्ग (एकल विजेट) + बटन का उपयोग करके "मेरा बटन" प्रिंट करता है

from kivy.app import App
from kivy.uix.button import Button

class Mybutton(Button):
    text="Click me!"
    on_press =lambda a : print("My Button")    
    
class TutorialApp(App):
    def build(self):
        return Mybutton()
TutorialApp().run()

उदाहरण 4: यह पूर्व की तरह ही है। 2 लेकिन यह दिखाता है कि कक्षा का उपयोग कैसे किया जाए

from kivy.app import App
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.label import Label
from kivy.uix.button import Button

class MyLayout(BoxLayout):
    #You don't need to understand these 2 lines to make it work!
    def __init__(self, **kwargs):
        super(MyLayout, self).__init__(**kwargs)
        
        self.orientation="vertical"
        mylabel = Label(text= "My App")
        self.add_widget(mylabel)
        mybutton =Button(text="Click me!")
        mybutton.bind(on_press= lambda a:print(mylabel.text))
        self.add_widget(mybutton)
        
class TutorialApp(App):
    def build(self):
        return MyLayout()
TutorialApp().run()

.Kv भाषा के साथ

उदाहरण 5: अजगर के भीतर kv भाषा का उपयोग करने के लिए समान लेकिन दिखा रहा है

from kivy.app import App
from kivy.uix.boxlayout import BoxLayout 
# BoxLayout: it's in the python part, so you need to import it

from kivy.lang import Builder
Builder.load_string("""
<MyLayout>
    orientation:"vertical"
    Label: # it's in the kv part, so no need to import it
        id:mylabel
        text:"My App"
    Button:
        text: "Click me!"
        on_press: print(mylabel.text)
""")
class MyLayout(BoxLayout):
    pass
class TutorialApp(App):
    def build(self):
        return MyLayout()
TutorialApp().run()

** उदाहरण 6: एक Tutorial.kv में kv भाग के साथ ही। फ़ाइल में **

इन खस्ता:

from kivy.app import App
from kivy.uix.boxlayout import BoxLayout

class MyLayout(BoxLayout):
    pass
class TutorialApp(App):  
#the kv file name will be Tutorial (name is before the "App")
    def build(self):
        return MyLayout()
TutorialApp().run()

Tutorial.kv में:

<MyLayout> # no need to import stuff in kv!
    orientation:"vertical"
    Label:
        id:mylabel
        text:"My App"
    Button:
        text: "Click me!"
        on_press: print(mylabel.text)

** उदाहरण 7: विशिष्ट kv फ़ाइल के लिए लिंक + लेबल प्राप्त करने वाले अजगर में एक दोष **

इन खस्ता:

from kivy.app import App
from kivy.uix.boxlayout import BoxLayout

class MyLayout(BoxLayout):
    def printMe(self_xx, yy):
        print(yy)
class TutorialApp(App): 
    def build(self):
        self.load_kv('myapp.kv')
        return MyLayout()
TutorialApp().run()

Myapp.kv: ओरिएंटेशन में: "वर्टिकल" लेबल: id: mylabel टेक्स्ट: "माय ऐप" बटन: टेक्स्ट: "" मुझे क्लिक करें! " on_press: root.printMe (mylabel.text)

उदाहरण 8: बटन लेबल के पाठ को प्रिंट करता है ( ids ("आईडी") का उपयोग करके अजगर में दोष के साथ)

नोटिस जो:

self_xx उदाहरण 7 से self द्वारा प्रतिस्थापित किया जाता है

इन खस्ता:

from kivy.app import App
from kivy.uix.boxlayout import BoxLayout

class MyLayout(BoxLayout):
    def printMe(self):
        print(self.ids.mylabel.text)
class TutorialApp(App):
    def build(self):
        self.load_kv('myapp.kv')
        return MyLayout()
TutorialApp().run()

Myapp.kv में:

<MyLayout>
    orientation:"vertical"
    Label:
        id:mylabel
        text:"My App"
    Button:
        text: "Click me!"
        on_press: root.printMe()

उदाहरण 9: बटन लेबल के पाठ को प्रिंट करता है (स्ट्रिंग में एक स्ट्रिंग के साथ अजगर का उपयोग करते हुए StringProperty)

इन खस्ता:

from kivy.app import App
from kivy.uix.boxlayout import BoxLayout
from kivy.properties import StringProperty
class MyLayout(BoxLayout):
    stringProperty_mylabel= StringProperty("My App")
    def printMe(self):
        print(self.stringProperty_mylabel)

class TutorialApp(App):
    def build(self):
        return MyLayout()
TutorialApp().run()

Tutorial.kv में:

<MyLayout>
    orientation:"vertical"
    Label:
        id:mylabel
        text:root.stringProperty_mylabel
    Button:
        text: "Click me!"
        on_press: root.printMe()

उदाहरण 10: बटन लेबल के पाठ को प्रिंट करता है (ऑब्जेक्टप्रॉपर्टी का उपयोग करके अजगर में दोष के साथ)

इन खस्ता:

from kivy.app import App
from kivy.uix.boxlayout import BoxLayout
from kivy.properties import ObjectProperty
class MyLayout(BoxLayout):
    objectProperty_mylabel= ObjectProperty(None)
    def printMe(self):
        print(self.objectProperty_mylabel.text)

class TutorialApp(App):
    def build(self):
        return MyLayout()
TutorialApp().run()

Tutorial.kv में:

<MyLayout>
    orientation:"vertical"
    objectProperty_mylabel:mylabel
    Label:
        id:mylabel
        text:"My App"
    Button:
        text: "Click me!"
        on_press: root.printMe()

Modified text is an extract of the original Stack Overflow Documentation

के तहत लाइसेंस प्राप्त है CC BY-SA 3.0

से संबद्ध नहीं है Stack Overflow