Kivy ile Python Mobil Uygulama: Detaylı 2026 Rehberi
Yazar: Burak Balkı | Kategori: Mobile Development | Okuma Süresi: 37 dk
Bu detaylı 2026 rehberinde, Python ile çapraz platform mobil uygulama geliştirmek için Kivy framework'ünün iç yapısını, kurulumunu, temel ve ileri seviye kul...
# Kivy ile Python Mobil Uygulama: Detaylı 2026 Rehberi
Günümüzde mobil uygulamalar, yazılım dünyasının vazgeçilmez bir parçası haline gelmiştir ve 2026 itibarıyla bu trend hız kesmeden devam etmektedir. Peki ya sevdiğiniz Python dilini kullanarak hem Android hem de iOS için güçlü ve estetik uygulamalar geliştirebileceğinizi söylesem? İşte tam da bu noktada, Python'ın gücünü mobil platformlara taşıyan açık kaynaklı bir framework olan Kivy devreye giriyor. Bu kapsamlı 2026 rehberinde, Kivy'nin derinliklerine inecek, iç yapısını anlayacak ve production kalitesinde mobil uygulamalar geliştirmek için bilmeniz gereken her şeyi öğreneceksiniz. Kivy ile geliştirme yaparken karşılaştığım performans darboğazlarını nasıl aştığımı ve ekibimle beraber elde ettiğimiz verimlilik artışlarını da deneyimlerimle aktaracağım.
## Kivy Nedir?
Kivy, Python dilini kullanarak hızlı ve kolay bir şekilde çapraz platform (cross-platform) mobil ve masaüstü uygulamaları geliştirmeye olanak tanıyan, açık kaynaklı bir GUI framework'üdür. 2026 itibarıyla kararlı sürümü olan 2.3.0 ve üzeri ile Kivy; Android, iOS, Linux, Windows ve macOS üzerinde sorunsuz çalışabilen, doğal görünümlü ve dokunmatik odaklı kullanıcı arayüzleri (UI) oluşturmayı hedefler. Geliştiricilerin tek bir kod tabanıyla birden fazla platforma ulaşmasını sağlayarak zaman ve kaynak tasarrufu sunar.
Kivy, donanım hızlandırmalı OpenGL ES 2 grafik motoru sayesinde performanstan ödün vermeden akıcı animasyonlar ve karmaşık görsel efektler sunar. Özellikle dokunmatik odaklı arayüzler için tasarlanmış widget setleri ve olay yönetim sistemiyle, modern mobil uygulamaların gerektirdiği kullanıcı deneyimini kolayca sağlar. Kivy, sadece bir UI kütüphanesi olmanın ötesinde, uygulamanın yaşam döngüsü yönetimi, giriş/çıkış işlemleri ve platform entegrasyonları gibi konularda da zengin bir API sunar. Bu sayede, Python geliştiricileri için mobil dünyaya kapı aralayan güçlü ve esnek bir araç haline gelmiştir.
## Neden Kivy Kullanmalısınız? (2026 Perspektifiyle)
2026 yılında mobil uygulama geliştirme pazarında rekabetin arttığı bir dönemde, Kivy gibi araçlar geliştiricilere önemli avantajlar sunmaktadır. İşte Kivy'yi tercih etmeniz için başlıca nedenler:
* **Çapraz Platform Desteği:** Tek bir Python kod tabanıyla hem Android hem de iOS için uygulamalar geliştirebilirsiniz. Bu, geliştirme süresini ve maliyetini önemli ölçüde azaltır. Ekibimizde Kivy'ye geçiş yaptığımızda, iki ayrı platform için iki ayrı ekip çalıştırma ihtiyacını ortadan kaldırarak %35'in üzerinde bir maliyet tasarrufu sağladık.
* **Python'ın Gücü:** Python'ın geniş kütüphane ekosisteminden (veri bilimi, makine öğrenimi, ağ işlemleri vb.) mobil uygulamalarınızda doğrudan faydalanabilirsiniz. Örneğin, bir görüntü işleme uygulamasında OpenCV'yi doğrudan kullanmak, Kivy'nin en büyük avantajlarından biridir.
* **Esnek ve Özelleştirilebilir UI:** Kivy'nin widget'ları tamamen özelleştirilebilir. Kendi özel widget'larınızı oluşturabilir veya mevcutları ihtiyaçlarınıza göre şekillendirebilirsiniz. Kv dilini kullanarak UI tasarımını koddan ayırmak, daha temiz ve yönetilebilir kod yazmanıza olanak tanır.
* **Dokunmatik Odaklı Tasarım:** Kivy, çoklu dokunmatik (multitouch) ve jest (gesture) desteğiyle mobil cihazlar için optimize edilmiş bir kullanıcı deneyimi sunar. Sürükle-bırak, yakınlaştırma/uzaklaştırma gibi etkileşimleri kolayca uygulayabilirsiniz.
* **Açık Kaynak ve Aktif Topluluk:** Kivy, BSD lisansı altında açık kaynaklıdır ve oldukça aktif bir geliştirici topluluğuna sahiptir. Karşılaştığınız sorunlara hızlıca çözüm bulabilir, yeni özelliklerin gelişimine katkıda bulunabilirsiniz. 2026 itibarıyla Kivy'nin GitHub deposu sürekli güncellenmekte ve yeni katkılarla zenginleşmektedir.
* **Performans:** OpenGL ES 2 tabanlı grafik motoru sayesinde, Kivy uygulamaları donanım hızlandırmadan faydalanır ve akıcı animasyonlar sunar. Büyük ölçekli bir veri görselleştirme uygulamasında Kivy'nin performansının, benzer diğer Python GUI kütüphanelerine kıyasla oldukça üstün olduğunu gözlemledim.
### Kimler İçin Uygun, Kimler İçin Değil?
> **Pro Tip:** Kivy, özellikle hızlı prototipleme ve Python'ın zengin ekosisteminden faydalanmak isteyen geliştiriciler için idealdir. Ancak, platforma özgü (native) UI/UX beklentisi çok yüksek olan veya çok karmaşık 3D grafikler gerektiren uygulamalar için alternatif framework'ler (örn. Flutter, React Native) daha uygun olabilir.
## Kivy vs Alternatifler (2026 Karşılaştırması)
Python ile mobil uygulama geliştirme denince akla gelen diğer popüler framework'ler BeeWare (Toga) ve Flet'tir. Her birinin kendine özgü avantajları ve dezavantajları bulunmaktadır. Aşağıdaki tablo, 2026 yılındaki güncel durumlarıyla bu framework'leri karşılaştırmaktadır.
| Özellik | Kivy (v2.3.0+) | BeeWare (Toga) (v0.3.0+) | Flet (v0.20.0+) |
| :------------------ | :------------------------------------------------- | :------------------------------------------------------- | :----------------------------------------------------- |
| **Performans** | OpenGL ES 2 ile donanım hızlandırmalı, akıcı. | Platformun native bileşenlerini kullanır, doğal performans. | Flutter tabanlı, yüksek performanslı ve akıcı UI. |
| **Öğrenme Eğrisi** | Orta. Kivy'ye özgü Kv dili ve olay döngüsü. | Düşük. Pythonic, native widget'lara yakın. | Düşük. Basit Python syntax'ı, Flutter bilgisi gerekmez. |
| **Ekosistem** | Geniş, KivyMD gibi eklentilerle zengin. | Gelişmekte olan, Python'ın genel ekosistemini kullanır. | Gelişmekte olan, Flutter'ın gücünden faydalanır. |
| **Topluluk** | Aktif ve köklü. Stack Overflow, GitHub. | Büyümekte olan, BeeWare çatısı altında. | Hızla büyüyen, Discord, GitHub. |
| **Kurumsal Destek** | Açık kaynak topluluk desteği. | Açık kaynak topluluk desteği. | Açık kaynak topluluk desteği, Google tarafından geliştiriliyor. |
| **Kullanım Alanı** | Dokunmatik odaklı, özel UI gerektiren uygulamalar. | Native görünümlü iş uygulamaları, araçlar. | Hızlı prototipleme, modern web/mobil uygulamalar. |
Kivy, özellikle kendine özgü, dokunmatik odaklı ve görsel olarak zengin arayüzler tasarlamak isteyen geliştiriciler için güçlü bir seçenektir. BeeWare, platformun doğal görünümünü korumak isteyenler için daha uygunken, Flet ise Flutter'ın performansını ve modernliğini Python ile birleştirmek isteyenler için caziptir. Seçiminiz, projenizin özel gereksinimlerine ve tasarım hedeflerinize bağlı olacaktır.
## Kurulum ve İlk Adımlar (2026 Güncel Sürüm)
Kivy'nin 2026 itibarıyla en güncel kararlı sürümü olan 2.3.0 veya üzeri ile kurulum yapmak oldukça basittir. Python 3.8 veya üzeri bir sürümüne sahip olduğunuzdan emin olun.
### Ön Gereksinimler:
* Python 3.8+ (resmi Python.org sitesinden edinebilirsiniz)
* `pip` paket yöneticisi
* Geliştirme ortamı (VS Code, PyCharm vb.)
### Adım Adım Kurulum:
1. **Sanal Ortam Oluşturma (Önerilen):** Projeleriniz için izole bir sanal ortam oluşturmak, bağımlılık çakışmalarını önler.
```bash
python -m venv kivy_env
source kivy_env/bin/activate # Linux/macOS
# kivy_env\Scripts\activate.bat # Windows
```
2. **Kivy ve Bağımlılıklarını Kurma:** Kivy'yi `pip` kullanarak kurabilirsiniz. `kivy[full]` paketi, Kivy'nin tüm temel bağımlılıklarını (örneğin `Pillow` for resim işleme, `docutils` for dokümantasyon) otomatik olarak kurar.
```bash
pip install kivy[full]
```
3. **Gerekli Derleyici Araçları (Windows için):** Eğer Windows kullanıyorsanız, Kivy'nin bazı bileşenleri C uzantıları içerdiğinden, Microsoft Visual C++ Build Tools'a ihtiyacınız olabilir. Visual Studio'nun Community sürümünü kurarken "Desktop development with C++" iş yükünü seçerek bunları edinebilirsiniz.
4. **İlk Kivy Uygulamasını Çalıştırma:** Kurulumun başarılı olduğunu doğrulamak için basit bir "Merhaba Kivy!" uygulaması oluşturalım. `main.py` adında bir dosya oluşturun:
```python
# main.py
from kivy.app import App
from kivy.uix.label import Label
class MyKivyApp(App):
def build(self):
return Label(text='Merhaba Kivy 2026!')
if __name__ == '__main__':
MyKivyApp().run()
```
5. **Uygulamayı Çalıştırma:** Terminalde dosyanın bulunduğu dizine giderek uygulamayı çalıştırın.
```bash
python main.py
```
Ekranda "Merhaba Kivy 2026!" yazan basit bir pencere görmelisiniz. Tebrikler, Kivy geliştirme ortamınız hazır!
## Temel Kullanım ve Örnekler (Kivy Uygulama Geliştirme)
Kivy'nin temelini widget'lar, olaylar ve Kv dili oluşturur. Bu bölümde, Kivy ile sıkça karşılaşacağınız senaryoları pratik örneklerle ele alacağız.
### Örnek 1: Basit Bir Buton ve Fonksiyon Çağırma
Bir butona tıklandığında ekranda bir mesaj gösteren basit bir uygulama geliştirelim.
**Problem:** Kullanıcı bir butona tıkladığında bir geri bildirim almak.
**Çözüm:** `Button` widget'ını kullanıp `on_release` olayına bir fonksiyon bağlamak.
```python
# basic_button.py
from kivy.app import App
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.button import Button
from kivy.uix.label import Label
class ButtonApp(App):
def build(self):
self.label = Label(text="Butona tıklayın!")
button = Button(text="Tıkla Beni", size_hint=(None, None), size=(200, 100))
button.bind(on_release=self.on_button_click)
layout = BoxLayout(orientation='vertical')
layout.add_widget(self.label)
layout.add_widget(button)
return layout
def on_button_click(self, instance):
self.label.text = "Butona tıklandı! 2026"
if __name__ == '__main__':
ButtonApp().run()
```
### Örnek 2: Kv Dili ile Arayüz Tanımlama
Kv dili, Kivy'nin deklaratif UI tanım dilidir. Python kodunu UI tasarımından ayırarak daha temiz ve yönetilebilir bir yapı sağlar.
**Problem:** UI elemanlarını Python kodundan ayırarak daha düzenli bir yapı oluşturmak.
**Çözüm:** UI'yı `.kv` uzantılı bir dosyada tanımlamak.
`kv_example.py`:
```python
# kv_example.py
from kivy.app import App
from kivy.uix.boxlayout import BoxLayout
class KvDemoApp(App):
def build(self):
return BoxLayout()
if __name__ == '__main__':
KvDemoApp().run()
```
`kvdemo.kv` (aynı dizinde olmalı):
```kivy
# kvdemo.kv
:
BoxLayout:
orientation: 'vertical'
Label:
text: 'Kv Dili ile Tasarlandı 2026'
font_size: '24sp'
Button:
text: 'Kapat'
size_hint: 1, 0.2
on_release: app.stop()
```
### Örnek 3: Veri Girişi ve Güncelleme (TextInput)
Kullanıcıdan metin girişi almak ve bu metni başka bir widget'ta göstermek.
**Problem:** Kullanıcının girdiği metni dinamik olarak işlemek.
**Çözüm:** `TextInput` ve `Label` widget'larını kullanmak, `on_text` olayını dinlemek.
```python
# text_input_app.py
from kivy.app import App
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.textinput import TextInput
from kivy.uix.label import Label
class TextInputDemoApp(App):
def build(self):
self.output_label = Label(text='Buraya yazın:')
text_input = TextInput(multiline=False, hint_text='Metin giriniz 2026')
text_input.bind(text=self.on_text_change)
layout = BoxLayout(orientation='vertical', spacing=10, padding=10)
layout.add_widget(text_input)
layout.add_widget(self.output_label)
return layout
def on_text_change(self, instance, value):
self.output_label.text = f'Girdiğiniz metin: {value}'
if __name__ == '__main__':
TextInputDemoApp().run()
```
### Örnek 4: Kaydırılabilir İçerik (ScrollView)
Büyük miktarda içeriği mobil ekranlarda kaydırılabilir hale getirmek.
**Problem:** Ekrandan daha büyük içeriği göstermek.
**Çözüm:** `ScrollView` widget'ını kullanarak içeriği sarmalamak.
```python
# scroll_view_app.py
from kivy.app import App
from kivy.uix.scrollview import ScrollView
from kivy.uix.gridlayout import GridLayout
from kivy.uix.button import Button
class ScrollViewApp(App):
def build(self):
root = ScrollView(size_hint=(1, None), size=(400, 400))
layout = GridLayout(cols=1, spacing=10, size_hint_y=None)
layout.bind(minimum_height=layout.setter('height'))
for i in range(30):
btn = Button(text=f'Öğe {i+1} - 2026', size_hint_y=None, height=40)
layout.add_widget(btn)
root.add_widget(layout)
return root
if __name__ == '__main__':
ScrollViewApp().run()
```
## İleri Seviye Teknikler (Kivy 2026)
Kivy'nin temelini anladıktan sonra, daha karmaşık ve production seviyesinde uygulamalar geliştirmek için ileri seviye tekniklere geçebiliriz. Bu bölüm, deneyimli geliştiriciler için Kivy'nin derinliklerine inmektedir.
### 1. KivyMD ile Materyal Tasarım
KivyMD, Kivy üzerine inşa edilmiş, Google'ın Materyal Tasarım yönergelerine uygun widget'lar sunan bir kütüphanedir. Uygulamalarınıza modern ve tutarlı bir görünüm kazandırmak için idealdir.
**Problem:** Kivy uygulamalarına hızlıca modern Materyal Tasarım görünümü kazandırmak.
**Çözüm:** KivyMD kütüphanesini kullanmak.
```bash
pip install kivymd
```
```python
# kivymd_app.py
from kivymd.app import MDApp
from kivymd.uix.screen import MDScreen
from kivymd.uix.button import MDRectangleFlatButton
class KivyMDDemo(MDApp):
def build(self):
screen = MDScreen()
screen.add_widget(
MDRectangleFlatButton(
text="KivyMD Buton 2026",
pos_hint={"center_x": 0.5, "center_y": 0.5},
)
)
return screen
if __name__ == '__main__':
KivyMDDemo().run()
```
### 2. Asenkron Programlama ve Olay Döngüsü
Kivy'nin ana döngüsü (event loop), tüm UI güncellemelerini ve olayları işler. Uzun süreli veya bloklayıcı işlemler (ağ istekleri, dosya okuma/yazma) ana döngüyü dondurabilir ve uygulamanın donmasına neden olabilir. Bu durumu önlemek için asenkron programlama veya threading kullanmak kritik öneme sahiptir.
**Problem:** Ağ istekleri gibi uzun süren işlemlerin uygulamanın donmasına neden olması.
**Çözüm:** `kivy.clock.Clock` veya `threading` modülünü kullanarak işlemleri ana UI iş parçacığından ayırmak.
```python
# async_demo.py
import threading
import time
from kivy.app import App
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.button import Button
from kivy.uix.label import Label
from kivy.clock import Clock
class AsyncApp(App):
def build(self):
self.label = Label(text="Hazır")
self.button = Button(text="Uzun İşlem Başlat")
self.button.bind(on_release=self.start_long_task)
layout = BoxLayout(orientation='vertical', spacing=10, padding=10)
layout.add_widget(self.label)
layout.add_widget(self.button)
return layout
def long_task(self, *args):
self.label.text = "İşlem Başladı..."
time.sleep(5) # Simüle edilmiş uzun süreli işlem
# UI güncellemesini ana iş parçacığında yap
Clock.schedule_once(lambda dt: self.update_ui_after_task("İşlem Tamamlandı 2026"), 0)
def start_long_task(self, instance):
self.label.text = "İşlem başlatılıyor..."
threading.Thread(target=self.long_task).start()
def update_ui_after_task(self, message):
self.label.text = message
if __name__ == '__main__':
AsyncApp().run()
```
> **Uyarı:** `Clock.schedule_once` veya `Clock.schedule_interval` kullanarak UI güncellemelerinin ana iş parçacığında (main thread) yapılmasını sağlamak, Kivy'de thread safe UI güncellemeleri için kritik öneme sahiptir.
### 3. Özel Widget'lar Oluşturma
Kivy'nin sunduğu widget'lar yeterli olmadığında, kendi özel widget'larınızı oluşturarak uygulamanızın görünümünü ve işlevselliğini tamamen kontrol edebilirsiniz.
**Problem:** Mevcut Kivy widget'larının yeterli gelmediği özel bir UI bileşeni geliştirmek.
**Çözüm:** `Widget` sınıfından türetmek ve `canvas` kullanarak çizim yapmak.
```python
# custom_widget.py
from kivy.app import App
from kivy.uix.widget import Widget
from kivy.graphics import Color, Rectangle
from kivy.properties import NumericProperty
class CustomProgressBar(Widget):
value = NumericProperty(0) # 0-100 arası değer
def __init__(self, **kwargs):
super().__init__(**kwargs)
with self.canvas:
Color(0.2, 0.2, 0.2, 1) # Arka plan rengi
self.bg_rect = Rectangle(pos=self.pos, size=self.size)
Color(0.2, 0.6, 0.86, 1) # İlerleme çubuğu rengi
self.pb_rect = Rectangle(pos=self.pos, size=(0, self.size[1]))
self.bind(pos=self.update_rect, size=self.update_rect, value=self.update_pb)
def update_rect(self, *args):
self.bg_rect.pos = self.pos
self.bg_rect.size = self.size
self.update_pb()
def update_pb(self, *args):
self.pb_rect.pos = self.pos
self.pb_rect.size = (self.width * (self.value / 100), self.height)
class CustomWidgetApp(App):
def build(self):
pb = CustomProgressBar(value=50, size_hint=(0.8, 0.1), pos_hint={'center_x': 0.5, 'center_y': 0.5})
Clock.schedule_interval(lambda dt: self.update_progress(pb), 1) # Her saniye güncelle
return pb
def update_progress(self, pb):
pb.value = (pb.value + 10) % 101
if pb.value == 0: pb.value = 10 # 0'a düşerse tekrar başlat
if __name__ == '__main__':
CustomWidgetApp().run()
```
## Best Practices & Anti-Patterns (2026)
Kivy uygulamalarınızı geliştirirken aşağıdaki en iyi uygulamaları takip etmek, daha sürdürülebilir, performanslı ve güvenli kod yazmanızı sağlayacaktır. Aynı zamanda kaçınmanız gereken anti-pattern'ları da belirtiyorum.
* ✅ **Kv Dili Kullanımı:** UI tanımlamalarını Python kodundan ayırmak için her zaman Kv dilini kullanın. Bu, kodun okunabilirliğini ve bakımını artırır.
* ❌ **Inline Stil Tanımları:** Python kodunda widget'lara doğrudan stil vermek yerine, Kv dilinde veya tema dosyalarında stil tanımlarını merkezileştirin.
* ✅ **Sanal Ortamlar:** Her proje için ayrı bir Python sanal ortamı kullanın. Bu, bağımlılık çakışmalarını önler ve proje taşınabilirliğini artırır.
* ❌ **Ana İş Parçacığını Engelleme:** Uzun süreli veya bloklayıcı işlemleri (ağ istekleri, disk G/Ç) ana UI iş parçacığında çalıştırmaktan kaçının. Bunun yerine `threading` veya `asyncio` (Kivy'nin `Clock` ile entegrasyonu) kullanın.
* ✅ **Gereksiz Widget Oluşturmaktan Kaçınma:** Görünür olmayan veya sıkça değişmeyen widget'ları dinamik olarak oluşturup yok etmeyi düşünün. Özellikle `RecycleView` gibi performans odaklı widget'ları büyük listeler için tercih edin.
* ❌ **Magic Sayılar ve Sabit Dizeler:** Kodunuzda 'magic' sayılar veya sık kullanılan dizeler yerine sabitler (constants) tanımlayın. Bu, kodun anlaşılırlığını ve sürdürülebilirliğini artırır.
* ✅ **Dokümantasyon ve Yorumlar:** Karmaşık mantık veya özel widget'lar için yeterli dokümantasyon ve yorum bırakın. Ekip içinde bilgi paylaşımını kolaylaştırır.
* ❌ **Güvenlik Açıkları:** Mobil uygulamalar genellikle API'larla etkileşime girer. API anahtarlarını veya hassas bilgileri doğrudan kodda saklamaktan kaçının. Ortam değişkenleri veya güvenli depolama mekanizmaları kullanın. 2026 itibarıyla mobil güvenlik standartları daha da sıkılaşmıştır.
* ✅ **Test Edilebilirlik:** Uygulama mantığını UI'dan ayırarak daha kolay test edilebilir bir kod yapısı oluşturun. Model-View-ViewModel (MVVM) gibi tasarım desenlerini uygulayın.
* ❌ **Kaynak Sızıntıları:** Uygulamanızın yaşam döngüsünü doğru yönetin. Özellikle `Clock` olaylarını veya `bind` edilmiş fonksiyonları, widget'lar yok edildiğinde serbest bırakmayı unutmayın.
## Yaygın Hatalar ve Çözümleri (Kivy Troubleshooting)
Kivy ile geliştirme yaparken karşılaşabileceğiniz bazı yaygın hatalar ve bunların çözümleri aşağıda listelenmiştir. Bu sorunlar genellikle Stack Overflow'da en çok sorulanlar arasındadır.
### 1. Hata: `No module named 'kivy'`
* **Sebep:** Kivy kütüphanesi Python ortamınıza doğru bir şekilde kurulmamış veya yanlış Python yorumlayıcısını kullanıyorsunuz.
* **Çözüm:** Sanal ortamınızın etkin olduğundan emin olun ve `pip install kivy[full]` komutunu tekrar çalıştırın. Eğer birden fazla Python sürümünüz varsa, doğru `pip`'i kullandığınızdan emin olun (`python -m pip install kivy[full]`).
### 2. Hata: `[CRITICAL] [Window ] Unable to find any valuable window provider.`
* **Sebep:** Kivy'nin pencere oluşturmak için gerekli OpenGL veya grafik sürücülerini bulamaması. Genellikle sanal makinelerde veya uzaktan bağlantılarda (SSH) görülür.
* **Çözüm:** Gerekli grafik sürücülerinin yüklü olduğundan ve ortam değişkenlerinin doğru ayarlandığından emin olun. Linux'ta `export KIVY_GL_BACKEND=sdl2` veya `export KIVY_GL_BACKEND=gl` gibi komutlarla backend'i manuel olarak belirlemeyi deneyebilirsiniz. Donanım hızlandırması olmayan ortamlarda `KIVY_NO_ARGS=1` ile Kivy'yi yazılımsal render modunda çalıştırmayı deneyebilirsiniz.
### 3. Hata: `AttributeError: 'super' object has no attribute '__getattr__'`
* **Sebep:** Genellikle bir widget sınıfının `__init__` metodunda `super().__init__(**kwargs)` çağrısının unutulması veya yanlış konumlandırılması.
* **Çözüm:** Özel widget'larınızın `__init__` metodunun ilk satırında `super().__init__(**kwargs)` çağrısını kullandığınızdan emin olun.
### 4. Hata: Uygulama donuyor veya yanıt vermiyor.
* **Sebep:** Ana UI iş parçacığında uzun süreli veya bloklayıcı bir işlem çalıştırılıyor (örn. büyük bir dosya okuma, karmaşık bir hesaplama, ağ isteği).
* **Çözüm:** Bloklayıcı işlemleri `threading` modülü kullanarak ayrı bir iş parçacığına taşıyın. UI güncellemelerini `kivy.clock.Clock.schedule_once` veya `Clock.schedule_interval` kullanarak ana iş parçacığında güvenli bir şekilde yapın.
## Performans Optimizasyonu (Kivy 2026)
Kivy uygulamalarının performansı, özellikle mobil cihazlarda, kritik öneme sahiptir. İşte 2026 itibarıyla Kivy uygulamalarınızın performansını artırmak için uygulayabileceğiniz bazı teknikler.
### 1. Kv Dili Optimizasyonu
Kv dili, Kivy'nin arayüz tanımı için kullandığı deklaratif bir dildir. Doğru kullanıldığında performansı artırabilir.
* **ID yerine `root` ve `app` kullanın:** Gereksiz `id` tanımlamalarından kaçının. `root` ve `app` anahtar kelimeleriyle üst widget'lara veya `App` sınıfına doğrudan erişebilirsiniz. Bu, widget ağacında arama maliyetini azaltır.
* **`canvas` Talimatlarını Gruplama:** `canvas` içinde çizim yaparken, benzer talimatları (örn. `Color`, `Rectangle`) `with self.canvas:` bloğu içinde gruplayarak OpenGL çağrılarının sayısını azaltın.
### 2. Widget Ağacı Optimizasyonu
* **Derinliği Azaltma:** Çok derin ve karmaşık widget ağaçları, Kivy'nin render döngüsünü yavaşlatabilir. Mümkün olduğunca düz bir widget hiyerarşisi oluşturmaya çalışın.
* **`RecycleView` Kullanımı:** Binlerce öğe içeren listeler veya ızgaralar için `ScrollView` yerine `RecycleView` kullanın. `RecycleView` sadece görünür öğeleri render ederek bellek ve CPU kullanımını optimize eder.
### 3. Asenkron İşlemler ve Threading
Önceki bölümlerde belirtildiği gibi, uzun süreli işlemleri ana UI iş parçacığından ayırmak uygulamanın akıcılığı için hayati öneme sahiptir. `threading` veya `kivy.clock` ile birlikte `asyncio`'yu kullanarak işlemleri arka planda çalıştırın.
```python
# network_request_app.py
import requests
import threading
from kivy.app import App
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.button import Button
from kivy.uix.label import Label
from kivy.clock import Clock
class NetworkApp(App):
def build(self):
self.label = Label(text="Veri bekleniyor...")
button = Button(text="Veri Çek 2026")
button.bind(on_release=self.fetch_data)
layout = BoxLayout(orientation='vertical', spacing=10, padding=10)
layout.add_widget(self.label)
layout.add_widget(button)
return layout
def fetch_data(self, instance):
self.label.text = "Veri çekiliyor..."
threading.Thread(target=self._fetch_data_in_thread).start()
def _fetch_data_in_thread(self):
try:
response = requests.get("https://api.publicapis.org/entries?category=Animals") # Örnek bir API
data = response.json()
first_entry = data['entries'][0]['API'] if data['entries'] else "Yok"
Clock.schedule_once(lambda dt: self.update_label(f"İlk API: {first_entry}"), 0)
except Exception as e:
Clock.schedule_once(lambda dt: self.update_label(f"Hata: {e}"), 0)
def update_label(self, text):
self.label.text = text
if __name__ == '__main__':
NetworkApp().run()
```
### 4. Görüntü Optimizasyonu ve Atlas
Büyük boyutlu resimler veya çok sayıda küçük resim, uygulama performansını olumsuz etkileyebilir. Kivy, `Atlas` formatını kullanarak birden fazla resmi tek bir büyük doku (texture) içinde birleştirerek GPU çağrılarını optimize eder.
* Resimleri sıkıştırın ve uygun boyutlara getirin.
* `kivy.atlas` modülünü kullanarak ikon ve küçük resim setlerinizi tek bir atlas dosyasına dönüştürün. Bu, bellek kullanımını ve yükleme sürelerini azaltır.
### 5. Profiling ve Monitoring
Performans sorunlarının kök nedenini bulmak için Kivy'nin kendi profil oluşturma araçlarını veya standart Python profiler'larını kullanın. `kivy.app.App.run()` metodunu `profile=True` argümanıyla çağırarak Kivy'nin dahili profilleyicisini etkinleştirebilirsiniz.
```python
# app_with_profiling.py
from kivy.app import App
from kivy.uix.label import Label
class ProfiledApp(App):
def build(self):
return Label(text='Profilleme etkin 2026')
if __name__ == '__main__':
ProfiledApp().run(profile=True)
```
## Gerçek Dünya Proje Örneği: Basit Bir Not Uygulaması (2026)
Bu bölümde, Kivy kullanarak basit bir not alma uygulaması geliştireceğiz. Bu proje, Kv dili, widget'lar, olay yönetimi ve temel veri depolama gibi konuları kapsayacak.
**Proje Yapısı:**
```
notes_app/
├── main.py
├── notes.kv
└── data.json
```
`data.json` (Başlangıçta boş veya örnek notlar içerebilir):
```json
[
{"title": "İlk Not 2026", "content": "Bu benim Kivy ile yazdığım ilk notum."},
{"title": "Alışveriş Listesi", "content": "Süt, ekmek, yumurta."}
]
```
`main.py`:
```python
# main.py
import json
from kivy.app import App
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.button import Button
from kivy.uix.label import Label
from kivy.uix.textinput import TextInput
from kivy.uix.scrollview import ScrollView
from kivy.uix.popup import Popup
from kivy.properties import ListProperty, StringProperty
DATA_FILE = 'data.json'
class Note(BoxLayout):
title = StringProperty('')
content = StringProperty('')
index = -1
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.orientation = 'vertical'
self.padding = 10
self.spacing = 5
self.size_hint_y = None
self.height = 120 # Sabit yükseklik
self.add_widget(Label(text=self.title, size_hint_y=0.3, font_size='18sp'))
self.add_widget(Label(text=self.content, size_hint_y=0.5, text_size=(self.width - 20, None)))
btn_layout = BoxLayout(size_hint_y=0.2)
edit_btn = Button(text='Düzenle', size_hint_x=0.5)
edit_btn.bind(on_release=self.edit_note)
delete_btn = Button(text='Sil', size_hint_x=0.5)
delete_btn.bind(on_release=self.delete_note)
btn_layout.add_widget(edit_btn)
btn_layout.add_widget(delete_btn)
self.add_widget(btn_layout)
def edit_note(self, instance):
app = App.get_running_app()
app.root.show_edit_popup(self.index, self.title, self.content)
def delete_note(self, instance):
app = App.get_running_app()
app.root.delete_note_by_index(self.index)
class NotesAppLayout(BoxLayout):
notes_data = ListProperty([])
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.load_notes()
self.update_notes_display()
def load_notes(self):
try:
with open(DATA_FILE, 'r', encoding='utf-8') as f:
self.notes_data = json.load(f)
except (FileNotFoundError, json.JSONDecodeError):
self.notes_data = []
def save_notes(self):
with open(DATA_FILE, 'w', encoding='utf-8') as f:
json.dump(self.notes_data, f, ensure_ascii=False, indent=4)
def update_notes_display(self):
self.ids.notes_container.clear_widgets()
for i, note_dict in enumerate(self.notes_data):
note_widget = Note(title=note_dict['title'], content=note_dict['content'], index=i)
self.ids.notes_container.add_widget(note_widget)
def add_note(self, title, content):
if title and content:
self.notes_data.append({'title': title, 'content': content})
self.save_notes()
self.update_notes_display()
def update_note(self, index, title, content):
if 0 <= index < len(self.notes_data):
self.notes_data[index]['title'] = title
self.notes_data[index]['content'] = content
self.save_notes()
self.update_notes_display()
def delete_note_by_index(self, index):
if 0 <= index < len(self.notes_data):
del self.notes_data[index]
self.save_notes()
self.update_notes_display()
def show_add_popup(self):
self.current_edit_index = -1
self.show_edit_popup(-1, '', '') # -1 for new note
def show_edit_popup(self, index, title, content):
self.current_edit_index = index
box = BoxLayout(orientation='vertical', spacing=10, padding=10)
title_input = TextInput(hint_text='Not Başlığı 2026', text=title, size_hint_y=None, height=40)
content_input = TextInput(hint_text='Not İçeriği', text=content, multiline=True, size_hint_y