kivykivy 시작하기


비고

Kivy는 크로스 플랫폼 사용자 인터페이스의 신속한 개발을위한 오픈 소스 Python 라이브러리입니다. Kivy 응용 프로그램은 동일한 코드베이스를 사용하여 Linux, Windows, OS X, Android 및 iOS 용으로 개발할 수 있습니다.

그래픽은 네이티브 위젯이 아닌 OpenGL ES 2를 통해 렌더링되므로 운영 체제 전반에 걸쳐 모양이 균일합니다.

Kivy의 인터페이스 개발에는 kvlang이라는 작은 언어가 필요합니다 (kvlang은 파이썬과 같은 표현식과 파이썬 interop을 지원합니다). kvlang을 사용하면 Python을 독점적으로 사용하는 것과 비교하여 사용자 인터페이스 개발을 대폭 간소화 할 수 있습니다.

Kivy는 (현재 MIT 라이센스하에) 무료로 사용할 수 있으며 전문적으로 지원합니다.

설치 및 설정

Windows

Kivy를 설치하는 방법에는 두 가지 옵션이 있습니다.

먼저 파이썬 도구가 최신 버전인지 확인하십시오.

python -m pip install --upgrade pip wheel setuptools
 

그런 다음 기본 종속성을 설치하십시오.

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

Kivy는 이미 오디오 및 비디오 제공 업체를 보유하고 있지만 GStreamer는 고급 기능을 필요로합니다.

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

간단히하기 위해 다음 텍스트의 <python>python.exe 파일이있는 디렉토리 경로를 의미합니다.

  1. 바퀴

    휠 패키지는 컴파일 된 Kivy를 제공하지만 제거 된 cython 소스 구성 요소를 포함하고 있습니다. 즉, 코어 코드를이 방법으로 다시 컴파일 할 수 없습니다. 그러나 파이썬 코드는 편집 가능합니다.

    Kivy의 안정 버전은 pypi에서 사용할 수 있습니다.

    python -m pip install kivy
     

    공식 저장소의 최신 버전은 야간에 Google 드라이브에서 사용할 수있는 바퀴를 통해 사용할 수 있습니다. 파이썬 버전과 일치하는 문서 에서 링크를 방문하십시오. 적절한 휠을 다운로드 한 후이 휠의 이름을이 예의 형식과 일치하도록 바꾸고 명령을 실행하십시오.

    python -m pip install C:\Kivy-1.9.1.dev-cp27-none-win_amd64.whl
     
  2. 출처

    휠을 사용하는 것보다 소스에서 Kivy를 설치하는 데 필요한 종속성이 더 많이 필요하지만 설치가보다 유연합니다.

    <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 섹션을 확인하여 모든 것이 올바르게 설정되고 Kivy를 설치하십시오. 다음 옵션 중 하나를 선택하십시오.

    python -m pip install C:\master.zip
    python -m pip install https://github.com/kivy/kivy/archive/master.zip
     

경로

Kivy는 일부 종속성에서 바이너리에 액세스해야합니다. 즉, 올바른 폴더 환경의 PATH 변수에 있어야합니다.

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

이 방법으로 Python IDLE IDE는 <python>\Lib\idlelib; 와 함께 경로에 포함될 수 있습니다 <python>\Lib\idlelib; . 그런 다음 idle 를 콘솔에 쓰면 IDLE이 Kivy를 사용할 준비가됩니다.

그것을 단순화하십시오

환경 변수의 반복적 인 설정을 피하려면 이 방법으로 각 필요한 경로를 설정하거나 <python> 배치 된 배치 ( .bat ) 파일을 만듭니다.

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

설치 후 Kivy 프로젝트를 실행하려면 cmd.exe 또는 배치 파일을 실행하고 python <filename>.py

우분투에 설치

kivy 예제 open terminal로 우분투를 설치하고 다음 명령을 실행하십시오.

먼저 ppa를 추가하십시오.

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

Kivy 설치

 sudo apt-get install python-kivy
 

Kivy 예제 설치

 sudo apt-get install python-kivy-example
 

간단한 앱을 실행하고 위젯과 상호 작용하는 다양한 방법

대부분의 kivy 앱은 다음 구조로 시작합니다.

from kivy.app import App

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

여기에서 갈 방법은 여러 가지가 있습니다.

아래의 모든 코드 (예 1과 3 제외)는 동일한 위젯 및 유사한 기능을 갖지만 앱을 빌드하는 다른 방법을 보여줍니다.

예제 1 : 단일 위젯 (간단한 Hello World App) 반환

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 : 클래스 사용 (하나의 위젯) + 버튼은 "My Button"

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 부분과 동일 **

.py에서 :

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 파일에 대한 링크 + python에서 label.text를받는 def **

.py에서 :

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 : orientation : "vertical"레이블 : id : mylabel 텍스트 : "My App"버튼 : 텍스트 : "Click me!" on_press : root.printMe (mylabel.text)

예제 8 : 버튼은 레이블의 텍스트를 인쇄합니다 ( ids ( "IDs")를 사용하여 파이썬에서 def로).

그것을주의해라:

  • 예제 7의 self_xxself 로 대체되었습니다.

.py에서 :

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를 사용하여 파이썬에서 def로)

.py에서 :

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 : 버튼은 라벨의 텍스트를 인쇄합니다 (ObjectProperty를 사용하여 파이썬에서 def로)

.py에서 :

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()
 

kivy의 안녕 세상.

다음 코드는 kivy에서 'hello world'앱을 만드는 법을 보여줍니다. 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()
 

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()
 

Kivy의 간단한 팝업 예.

다음 코드는 Kivy로 간단한 팝업을 수행하는 방법을 보여줍니다.

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()
 

터치하고 잡아서 이동하십시오.

다음 예제에서는 중간에 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()