使用Kivy构建应用：Dusty Phillips的著作

5星 · 超过95%的资源需积分: 0 15 浏览量更新于2024-07-23 收藏 8.21MB PDF 举报

"Creating Apps in Kivy" 是一本由 Dusty Phillips 编写的关于使用 Kivy 框架创建应用程序的书籍。这本书于2014年由 O'Reilly Media 出版，旨在帮助读者理解并掌握如何利用 Kivy 开发跨平台的应用程序。 Kivy 是一个开源的 Python 库，专为创建多触点应用而设计，适用于各种操作系统，包括 Windows、macOS、Linux、Android 和 iOS。它提供了一个强大的用户界面框架，支持快速开发动态和交互式的应用。书中可能涵盖的知识点包括： 1. **Kivy基础知识**：介绍 Kivy 的安装过程、基本架构以及如何设置项目环境，包括安装 Python 和 Kivy 的要求。 2. **Kivy Widget系统**：讲解 Kivy 中的 widget（控件）体系，如 Button、Label、TextInput 等，以及如何使用它们构建用户界面。 3. **事件处理**：解释 Kivy 如何处理用户输入，如触摸事件和键盘事件，并展示如何绑定函数来响应这些事件。 4. **图形与动画**：讨论 Kivy 的图形渲染机制，如使用 Graphical User Interface (GUI) 组件和自定义图形，以及创建动画效果的方法。 5. **布局管理**：介绍 Kivy 的布局系统，如 BoxLayout、GridLayout 和 FloatLayout，如何根据需要组织和调整 widget 布局。 6. **多媒体支持**：讲解如何在 Kivy 应用中集成音频和视频，以及处理图像和其他媒体文件。 7. **应用打包**：说明如何将开发的应用打包成可执行文件或在移动设备上部署，包括 Android 和 iOS 平台的特定要求。 8. **Pygame与Kivy**：可能涉及 Kivy 如何与 Pygame 库集成，为开发者提供更丰富的游戏开发选项。 9. **最佳实践和调试**：提供开发过程中的一些技巧和建议，如何进行有效的代码调试以及优化性能。 10. **实例应用**：书中可能会包含一些实际应用的例子，如创建一个简单的计算器、画板应用或者小游戏，帮助读者通过实践加深对 Kivy 的理解。 11. **社区与资源**：介绍 Kivy 社区，包括论坛、文档和示例代码库，以便读者能获取更多学习和解决问题的资源。通过这本书，读者可以学会使用 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

剩余138页未读，继续阅读

fengu0082

粉丝: 0
资源: 3

使用Kivy构建应用：Dusty Phillips的著作

Creating Apps in Kivy mobi

Creating Apps in Kivy

Creating Apps in Kivy (PDF+Code)

如何利用Python 3的面向对象编程特性，开发一个具有基本功能的PDF处理类？

examples/asr.py --wav data/audio/dusty.wav

git clone https://github.com/dusty-nv/jetson-inference

绘制 total_bill 和 tip 之间的关系折线图并使用 xkcd 颜色值

seaborn曲线颜色

jetson-inference安装

jetson 使用python，导入jetson-inference找不到

最新资源