Kivy编程：打造移动应用的实用指南

5星 · 超过95%的资源需积分: 10 199 浏览量更新于2024-07-20 1 收藏 7.93MB PDF 举报

"Creating Apps in Kivy" 是一本由 Dusty Phillips 所著的关于使用 Kivy 开发应用程序的指南。Kivy 是一个开源框架，特别适用于 Python 语言，旨在让开发者能够轻松地在多种平台上构建跨平台的用户界面（UI）应用，包括 Android、iOS 和桌面系统。这本书的目标读者是那些对 Python 编程有一定基础，想要学习如何利用 Kivy 进行应用程序开发的人员。在这本手册中，作者详细介绍了 Kivy 的核心概念、架构和工作原理，涵盖了从安装和配置环境到创建第一个可交互窗口的基本步骤。读者可以了解到如何使用 Kivy 的 kv（Kivy Language）来设计用户界面，这是一种类似于 HTML 的声明式编程方式，能够方便地定义控件布局和交互逻辑。章节可能包括但不限于： 1. 入门篇：介绍 Kivy 的安装过程，以及其与其他 Python UI 框架的区别，强调其轻量级和跨平台特性。 2. 基础组件：讲解 Kivy 核心组件如 Label、Button、Widget 的使用，以及如何构建简单的界面元素。 3. 事件处理与响应：涉及事件驱动编程在 Kivy 中的应用，如触摸事件、键盘输入等。 4. 动画与过渡：探讨如何使用 Kivy 动画库实现平滑的视觉效果，提升用户体验。 5. 网络与数据获取：介绍如何与服务器通信，以及处理 JSON 或 XML 数据。 6. 多媒体支持：指导如何集成音频、视频和图像资源到应用程序中。 7. 实战项目：通过实际案例，如创建一个简单的游戏或工具应用，深入理解和实践 Kivy 的使用。 8. 进阶主题：涉及更高级的主题，如多线程、性能优化和调试技巧。 9. 最佳实践与社区资源：分享 Kivy 开发的最佳实践，以及介绍 Kivy 社区的文档、论坛和开源项目。版权信息显示，此书版权属于 Dusty Phillips，并且是 2014 年首次发行，O'Reilly Media 出版。该书不仅提供了纸质版，还提供了在线版本供读者选择。此外，还列出了相关的联系信息，以便读者获取更多关于图书发布和版权使用的信息。 "Creating Apps in Kivy" 是一本实用的教程，旨在帮助读者掌握如何利用 Python 与 Kivy 构建现代、跨平台的移动和桌面应用程序，无论你是初学者还是有一定经验的开发者，都能从中受益匪浅。

Regardless of who you are, if you’re interested in creating a working application in Kivy,

you’re in the right place! I’ll be showing you how to develop a weather application step

by step. You’ll start with setting up a Kivy development environment and end up with

an application running on your Android device or iPhone.

Dependencies: The Hard Part

It’s an unfortunate truth in the programming world that the fun part has to come after

a lot of work. Getting Kivy up and running is not a terribly complicated process, but I

wouldn’t call it enjoyable. “I got a programming library installed after half an hour of

effort” just doesn’t have the same ring as, “I made a program window pop up after 20

seconds!” So, to boost your excitement, let me tell you that 20 seconds after you get all

these dependencies set up, you’ll have written and run a small Kivy application. Ready?

Let’s go!

Python 2 Versus Python 3

There are currently two active versions of Python: Python 2 and Python 3. The syntax

and standard library have changed between the two versions, and both are quite popular.

You may be wondering which one you should use.

As of version 1.8, which is used for the examples in this book, Kivy supports both Python

2 and Python 3 interpreters. From a developer’s point of view, I recommend using

Python 3, as it is a simpler syntax, has a cleaner standard library, and will be more useful

knowledge going into the future.

However, from an ease-of-use perspective, you are more likely to find that Python 2 is

already installed on your computer and ready to go. Further, the tools used to deploy to

both Android and iOS currently run only on Python 2.

I wrote the examples in this book to run in Python 3. However, most of them can be run

unmodified on Python 2, and I have noted any differences in sidebars.

Regardless of which version of Python you choose, make sure you’re using Kivy version

1.8 or later.

Frankly, writing about dependency setup is frustrating for me as well. I don’t know what

operating system you’re using. I don’t know what libraries you already have installed or

how they conflict with each other. I can’t predict the myriad ways that things might go

wrong for you.

Luckily, Kivy has great installers for most operating systems. You can use these to get

up and running quickly. Quick installers have their downsides, though. A major one is

that you, as the developer, don’t know exactly what they are doing. This can cause head‐

2 | Chapter 1: Introducing Kivy

aches later when things break and you don’t know what’s going on. However, Kivy takes

good care of its users, so it will probably be quite a long time before you have to work

out the details.

While I use and recommend the Linux operating system (all the code in this book was

first written and tested on Linux), I don’t provide Linux installation instructions. In‐

stalling dependencies in Linux tends to be much more straightforward than on other

operating systems. However, the instructions for doing so vary completely depending

on which Linux distribution you are using, and as a Linux user, you probably know

better than I how to go about getting them for your distribution of choice (unless you

use Arch Linux, for which I’ve written a ton of documentation). Kivy has terrific in‐

structions for most popular Linux distributions on its downloads page.

Installing on Mac OS

You can download an all-inclusive .dmg file that includes a compiled version of Kivy,

all the libraries it depends on, a shell command to run it from a terminal window (this

is necessary to see debugging output), and all the examples that Kivy supplies in case

you get stuck.

To install it, simply download the latest (version 1.8 or higher) .dmg file from Kivy’s

download page. Double-click the file in your downloads folder or stack to open it. Then

drag and drop the Kivy.app file into the Applications folder shortcut inside the volume.

Before you close the .dmg volume, also double-click the Make Symlinks file. This will

allow you to run Kivy as a script on the terminal. This script is kind of a wrapper for

the Python executable. After you’ve run Make Symlinks, you can open a terminal and

type kivy. You’ll be presented with a standard Python prompt as if you had run the

python command directly.

In Mac OS Mavericks (10.9), Apple introduced a new antideveloper

feature to prevent running “unlicensed” programs. It will pop up a

warning that you can’t run the script downloaded from the Internet

and doesn’t provide an obvious way for you to get in on the debate.

There is a hidden workaround, though (I guess Apple just wants you

to prove you know what you are doing). In Finder, open the folder

containing the script. Then Control-click the icon and click Open in

the shortcut menu. This will override the security settings and allow

the script to run.

This prompt is your system Python with some paths modified to ensure that all the

libraries it requires are installed. If you’re an experienced Python coder, you’re likely

wondering why you wouldn’t just use a virtualenv. Virtual environments are great when

your dependencies are Python libraries that you can install from pypi or Git reposito‐

Dependencies: The Hard Part | 3

ries. However, many of Kivy’s dependencies are C libraries that have complicated in‐

terdependencies. These have been bundled into Kivy.app as a bunch of dynamic libraries

that are loaded when you run the kivy script.

Note that Kivy.app uses the default Python that comes with Mac OS. That means you’ll

be using Python 2 instead of Python 3. You will have to adapt a couple of the examples

in this book to make them work, but I’ve highlighted those so you won’t have any trouble.

For the most part, you will be using Kivy from the terminal in this book. Your file will

be named main.py. I may tell you to run python main.py, but if you’re using the Mac

OS Kivy.app, you’ll want to run kivy main.py instead.

Installing on Windows

Windows can be pretty quirky for software development. It doesn’t have a terrific

command-line interface, and there can be bizarre conflicts between software libraries

or software and the heterogeneous collection of hardware that Windows supports.

That said, the Kivy developers have done a great job of bundling the dependencies into

a single ZIP file. The archive contains the minimum dependencies you need to run Kivy.

This portable package should integrate well with the operating system and isolate you

from conflicting libraries on the same system.

Download the Kivy for Windows ZIP file from Kivy’s download page. Extract (right-

click the file and click “Extract all”) the ZIP file to a known directory on your system; I

recommend the folder C:\utils\kivy.

Now you can open a Windows command prompt. Type the command cd C:\utils

\kivy and then just kivy. This will activate the Kivy environment, which includes the

libraries you need. It also bundles a Python executable (you can choose between Python

2 and Python 3 from the downloads page). You will have to perform this activation step

each time you open a new terminal.

Note that you can also install msysgit to get a programmer-friendly command-line

interface (the same command shell used by default on Linux and Mac OS). If you are

using this package, you’ll need to run source kivyenv.sh instead of the kivy script. I

recommend using this installer, as you will also have access to the Git version control

system to manage your source code, and it will install some of the dependencies you’ll

need in Chapter 9.

4 | Chapter 1: Introducing Kivy

Writing Code: The Easy Part

Now create a directory somewhere to host your project and open a new file called

main.py in your preferred text editor.

Program Editors

I’m assuming you’ve done some basic Python development before diving into Kivy. That

probably means you’ve explored the world of Python editors already. All Python pro‐

grams are simple text that is organized into the structure expected by the Python inter‐

preter. There are numerous tools for editing Python programs, and even more opinions

on which one is best.

If you already have such an opinion, then stick with it, by all means. However, if you’re

feeling confused by the array of program editing choices, I can recommend Sublime

Text. It is very easy for novices, with no more of a learning curve than the basic Microsoft

Notepad. However, it is also an advanced editor that professionals, including myself,

use for their daily programming. The best part is that if Sublime doesn’t do something

that you need it to do, you can easily extend it using plug-ins written in Python!

The starting Python module for all Kivy applications should be named main.py, as the

build tools you’ll use later to automate deployment to mobile devices will look for that

file. Now add a couple of lines of code to this new file, as shown in Example 1-1.

Example 1-1. The most basic Kivy app

from kivy.app import App

App().run()

That is it: the most basic Kivy code you could possibly write. It imports an App class,

instantiates it, and then calls the run method. Run this code by activating your Kivy

environment in a terminal and typing python main.py (or kivy main.py on Mac OS).

It will pop up a blank window with a black background. Close it.

The Kivy App object does an impressive amount of work on your behalf. That is the

beauty of object-oriented programming. This object does something, and all you have

to do is tell it to do its job by invoking the run method. It takes care of all sorts of stuff:

interacting with the screen hardware; talking to input devices such as multitouch dis‐

plays, keyboards, and accelerometers; scheduling tasks; and more. We’ll get into some

of that later, but for now, just know that if you don’t have an App object, you don’t get a

window.

Writing Code: The Easy Part | 5

If you aren’t familiar with the basics of object-oriented programming, you might want

to review the relevant section of the Python Tutorial. If you’d like in-depth coverage of

the topic, see my book Python 3 Object Oriented Programming (Packt, 2010).

In Kivy, your use of object-oriented principles is largely to extend Kivy’s built-in objects

through inheritance. This is a fairly easy paradigm to understand, so you don’t need to

be well versed in classes to get there.

If a blank window with a black background is exactly the kind of application you were

looking to write, then you’re done! Congratulations. Perhaps you can skip to the chapter

on deploying so you can get that black background onto your mobile device (or just use

the power button; black goes with anything).

Personally, I’d like something a little more interesting. So let’s try again. Edit the file to

look like Example 1-2.

Example 1-2. A slightly less basic Kivy app

from kivy.app import App

class WeatherApp(App):

pass

if __name__ == '__main__':

WeatherApp().run()

This version uses inheritance to create a new subclass of App called WeatherApp. This is

the application you’ll be developing in this book. You didn’t actually add anything to

the new class, so it behaves exactly the same as the previous version. However, you’ll be

extending it a lot in subsequent chapters. It also wraps the call to App.run in an if

statement to make sure that this file can be imported from inside other files later in the

book. More importantly, you can now use the KV language to add some real user in‐

terface elements to that black window.

Introducing the KV Language

The KV language, often referred to as kvlang, is a simple markup syntax that I think of

as “what HTML would look like if HTML looked like Python.” It’s a very clean syntax

and makes Kivy interface design much more enjoyable than any other toolkit I’ve

worked with, including the Web.,

You’ll be creating a new file to store the KV language in. Call it weather.kv and save it

in the same directory as main.py. Your .kv file should always have the same name as

your app class, but with the word App stripped from the end, and converted to lowercase.

Thus, WeatherApp will always look for its layout information in a file called weather.kv.

6 | Chapter 1: Introducing Kivy

www.allitebooks.com

剩余138页未读，继续阅读

ustcck

粉丝: 46

Kivy编程：打造移动应用的实用指南

使用Kivy进行高效移动应用开发的英文教程

使用Kivy框架开发跨平台应用程序

"解析streamer.c.pdf文件，实现流媒体数据传输

Creating Apps in Kivy 无水印pdf

Creating Apps in Kivy (PDF+Code)

[Creating.Apps.in.Kivy]2014.4.Dusty.Phillips.文字版.pdf

Creating Apps in Kivy

Creating Apps in Kivy mobi

Creating Apps in Kivy epub

No_Description_creating_apps_in_kivy.zip

最新资源