Python Kivy：打造手机应用的全能指南

5星 · 超过95%的资源需积分: 50 54 浏览量更新于2024-07-18 3 收藏 7.94MB PDF 举报

"《利用Kivy进行Python应用开发》是一本由Dusty Phillips撰写的专业书籍，专为那些想要利用Python语言开发手机应用的开发者设计。Kivy作为一个开源框架，为Python程序员提供了一种简单而强大的方式来构建跨平台的应用程序，尤其适合那些寻求快速原型设计和原型演示的开发者。本书的目的是让读者掌握Kivy的基本原理、核心组件和实践技巧，包括如何创建用户界面、处理用户交互、动画效果以及数据绑定。作者通过实例和详细的步骤指导，帮助读者理解Kivy的 widgets（控件）、 kv语言（用于定义布局和样式）以及其背后的多线程和网络通信能力。在学习过程中，读者将了解到Kivy的优势在于其轻量级、易学易用，并且拥有良好的社区支持。它支持多种操作系统，如Android和iOS，使得开发者可以利用Python的强大功能，快速实现跨平台应用的开发。本书不仅适合有一定Python基础的开发者，也适合对移动应用开发感兴趣但对其他语言有难度的初学者。它旨在通过实用的教程和深入的剖析，帮助读者建立起坚实的Kivy开发基础，从而能够独立开发出功能丰富的应用程序。在版权方面，此书享有Dusty Phillips的版权，O'Reilly Media负责出版，确保了内容的质量和专业性。此外，还提供了在线版本供读者方便查阅，并指出如有任何错误或更新信息，可在O'Reilly的网站上获取。《Creating Appsin Kivy》的发布日期为2014年4月，首版修订历史在同年同月进行。书中包含丰富的实例和详尽的指南，为Python开发者提供了一个完整的Kivy应用开发指南，无论是想入门还是进阶的读者，都能从中获益匪浅。" 通过阅读这本书，读者不仅可以掌握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

剩余138页未读，继续阅读

qq_34425850

粉丝: 0
资源: 7

Python Kivy：打造手机应用的全能指南

kivy中文手册.pdf

kivy 编程手册版本 2.0.0rc2

kivy开发文档.pdf （英文）

kivy开发app教程

pycharm kivy.app

利用kivy开发小游戏

Python开发app

怎么用kivy开发一个记账本

kivy开发安卓应用

python开发手机app教程

最新资源