kivy Samouczek
Pierwsze kroki z kivy
Szukaj…
Uwagi
Kivy to biblioteka Python typu open source do szybkiego opracowywania wieloplatformowych interfejsów użytkownika. Aplikacje Kivy można tworzyć dla systemów Linux, Windows, OS X, Android i iOS przy użyciu tej samej bazy kodów.
Grafika jest renderowana za pomocą OpenGL ES 2, a nie przez natywne widżety, co prowadzi do dość jednolitego wyglądu w różnych systemach operacyjnych.
Opracowywanie interfejsów w Kivy opcjonalnie wymaga użycia kvlang, małego języka, który obsługuje wyrażenia podobne do python i interop python. Korzystanie z kvlang może drastycznie uprościć tworzenie interfejsu użytkownika w porównaniu do używania wyłącznie Pythona.
Kivy jest darmowy (obecnie na licencji MIT) i profesjonalnie wspierany.
Instalacja i konfiguracja
Windows
Istnieją dwie opcje instalacji Kivy:
Najpierw upewnij się, że narzędzia Python są aktualne.
python -m pip install --upgrade pip wheel setuptools
Następnie zainstaluj podstawowe zależności.
python -m pip install docutils pygments pypiwin32 kivy.deps.sdl2 kivy.deps.glew
Chociaż Kivy ma już dostawców audio i wideo, GStreamer jest wymagany do bardziej zaawansowanych rzeczy.
python -m pip install kivy.deps.gstreamer --extra-index-url https://kivy.org/downloads/packages/simple/
Aby uprościć, <python>
w poniższym tekście oznacza ścieżkę do katalogu z plikiem python.exe
.
Koło
Pakiet koła zapewnia skompilowany Kivy, ale z usuniętymi komponentami źródłowymi
cython
, co oznacza, że kodu rdzenia nie można ponownie skompilować w ten sposób. Kod Pythona jest jednak edytowalny.Stabilna wersja Kivy jest dostępna na pypi.
python -m pip install kivy
Najnowsza wersja z oficjalnego repozytorium jest dostępna za pośrednictwem nocnych kół dostępnych na dysku Google. Odwiedź link w dokumentach pasujący do twojej wersji Pythona. Po pobraniu odpowiedniego koła zmień jego nazwę, aby pasowało do formatowania tego przykładu, i uruchom polecenie.
python -m pip install C:\Kivy-1.9.1.dev-cp27-none-win_amd64.whl
Źródło
Potrzebne są bardziej wymagane zależności, aby zainstalować Kivy ze źródła niż przy użyciu kół, ale instalacja jest bardziej elastyczna.
Utwórz nowy plik w
<python>\Lib\distutils\distutils.cfg
pomocą tych linii, aby upewnić się, że dla kodu źródłowego zostanie użyty odpowiedni kompilator.[build] compiler = mingw32
Następnie potrzebny jest kompilator. Albo użyj już zainstalowanego, albo pobierz
mingwpy
. Ważne pliki, takie jakgcc.exe
będą znajdować się w<python>\Scripts
.python -m pip install -i https://pypi.anaconda.org/carlkl/simple mingwpy
Nie zapomnij ustawić zmiennych środowiskowych, aby Kivy wiedział, jakich dostawców powinien użyć.
set USE_SDL2=1 set USE_GSTREAMER=1
Teraz zainstaluj dodatkowe zależności wymagane do kompilacji.
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/
Sprawdź sekcję
Paths
aby upewnić się, że wszystko jest ustawione poprawnie i zainstaluj Kivy. Wybierz jedną z następujących opcji:python -m pip install C:\master.zip python -m pip install https://github.com/kivy/kivy/archive/master.zip
Ścieżki
Kivy potrzebuje dostępu do plików binarnych z niektórych zależności. Oznacza to, że właściwe foldery muszą znajdować się w zmiennej PATH
środowiska.
set PATH=<python>\Tools;<python>\Scripts;<python>\share\sdl2\bin;%PATH%
W ten sposób Python IDLE IDE może zostać dołączony do ścieżki za pomocą <python>\Lib\idlelib;
. Następnie wpisz idle
w konsoli, a IDLE będzie gotowy do użycia Kivy.
Uprość to
Aby uniknąć powtarzalnego ustawiania zmiennych środowiskowych, ustaw w ten sposób każdą niezbędną ścieżkę lub utwórz plik wsadowy ( .bat
) z tymi wierszami umieszczonymi w <python>
:
set PATH=%~dp0;%~dp0Tools;%~dp0Scripts;%~dp0share\sdl2\bin;%~dp0Lib\idlelib;%PATH%
cmd.exe
Aby uruchomić projekt Kivy po instalacji, uruchom cmd.exe
lub plik wsadowy i użyj python <filename>.py
instalacja na Ubuntu
Aby zainstalować kivy na ubuntu z przykładem kivy, otwórz terminal i uruchom następujące polecenie
Najpierw dodaj ppa
sudo add-apt-repository ppa:kivy-team/kivy
Do instalacji Kivy
sudo apt-get install python-kivy
Aby zainstalować przykłady Kivy
sudo apt-get install python-kivy-example
Dotknij, chwyć i rusz się
Poniższy przykład tworzy płótno z 2 punktami i 1 linią pomiędzy nimi. Będziesz mógł przesuwać punkt i linię.
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()
Witaj świecie w kivy.
Poniższy kod ilustruje, jak zrobić aplikację „hello world” w kivy. Aby uruchomić tę aplikację w systemie iOS i Android, zapisz ją jako main.py i użyj 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()
Prosty przykład wyskakującego okienka w Kivy.
Poniższy kod ilustruje sposób wykonywania prostych okien podręcznych za pomocą 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()
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()
Różne sposoby uruchamiania prostej aplikacji i interakcji z widżetami
Większość kivy aplikacji zaczyna się od tej struktury:
from kivy.app import App
class TutorialApp(App):
def build(self):
return
TutorialApp().run()
Można stąd przejść na kilka sposobów:
Wszystkie poniższe kody (z wyjątkiem przykładów 1 i 3) mają ten sam widget i podobne funkcje, ale pokazują inny sposób tworzenia aplikacji.
Przykład 1: zwracanie pojedynczego widgetu (prosta aplikacja Hello World)
from kivy.app import App
from kivy.uix.button import Button
class TutorialApp(App):
def build(self):
return Button(text="Hello World!")
TutorialApp().run()
Przykład 2: zwrócenie kilku widżetów + przycisk drukuje tekst etykiety
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()
Przykład 3: użycie klasy (pojedynczy widget) + przycisk drukuje „Mój przycisk”
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()
Przykład 4: jest taki sam jak np. 2, ale pokazuje, jak korzystać z klasy
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()
Z językiem .kv
Przykład 5: to samo, ale pokazujący, jak używać języka kv w Pythonie
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()
** Przykład 6: to samo z częścią kv
w pliku Tutorial.kv
**
W .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()
W 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)
** Przykład 7: link do określonego pliku kv + def w pythonie odbierającym label.text **
W .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()
W myapp.kv: orientacja: „pionowa” Etykieta: id: mylabel tekst: „Moja aplikacja” Przycisk: tekst: „Kliknij mnie!” on_press: root.printMe (mylabel.text)
Przykład 8: przycisk drukuje tekst etykiety (z def w Pythonie przy użyciu ids
(„ID”))
Zauważ, że:
-
self_xx
z przykładu 7 jest zastąpione przezself
W .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()
W myapp.kv:
<MyLayout>
orientation:"vertical"
Label:
id:mylabel
text:"My App"
Button:
text: "Click me!"
on_press: root.printMe()
Przykład 9: przycisk drukuje tekst etykiety (z def w Pythonie przy użyciu StringProperty)
W .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()
W Tutorial.kv:
<MyLayout>
orientation:"vertical"
Label:
id:mylabel
text:root.stringProperty_mylabel
Button:
text: "Click me!"
on_press: root.printMe()
Przykład 10: przycisk drukuje tekst etykiety (z def w Pythonie przy użyciu ObjectProperty)
W .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()
W Tutorial.kv:
<MyLayout>
orientation:"vertical"
objectProperty_mylabel:mylabel
Label:
id:mylabel
text:"My App"
Button:
text: "Click me!"
on_press: root.printMe()