Python与SL4A打造Android实用应用：简化开发与自动化

需积分: 10 192 浏览量更新于2024-07-25 1 收藏 5.01MB PDF 举报

《Pro.Android.Python.with.SL4A》是一本专为Android平台设计的实用指南，作者是Paul Ferrill。本书主要讲解如何利用Python语言和少量JavaScript编写实际应用，尤其在处理那些只需简单操作如开关设备设置的情境中，与Java相比，Python显得更为高效。SL4A（Scripting Layer for Android）项目正是为满足这种特定需求而创建的，它提供了一种更简便的方式来自动化Android设备。书中内容涵盖广泛，包括： 1. **入门介绍**：首先引导读者了解Python在Android开发中的应用，以及为何选择Python而非Java。 2. **开始使用**：从基础入手，教授如何安装和配置所需的环境，以便踏上Python Android开发之旅。 3. **Android SDK导航**：深入解析Android Software Development Kit（SDK），让开发者熟悉其组件和工具。 4. **Eclipse集成开发**：探讨如何在Eclipse这样的集成开发环境中进行Python编程，实现代码的编写和调试。 5. **探索Android API**：讲解Android应用程序接口（API），展示如何利用这些API构建功能丰富的应用。 6. **Python脚本基础**：通过Python的基本语法和概念，让读者掌握编写脚本的基础技能。 7. **Python实用工具**：介绍如何使用Python编写实用工具，提高开发效率。 8. **基于对话框的GUI**：讲解如何利用Python创建简单用户界面，通过对话框交互设计。 9. **HTML驱动的GUI**：扩展到HTML技术，探讨如何结合Python构建更复杂的图形用户界面。 10. **打包与分发**：最后，指导读者如何将应用打包成可安装的APK文件，并发布到Google Play或其他分发渠道。本书不仅提供了理论知识，还鼓励读者动手实践，通过实际项目来深化对Python在Android开发中的理解和应用。无论是初学者还是有一定经验的开发者，都能从中受益匪浅，提升Android应用开发的能力。通过SL4A，你将解锁无限可能，让你的Android设备自动化水平跃升至新高度。

CHAPTER 1 ■ INTRODUCTION

Shell

If you’re a shell script wizard, then you’ll feel right at home with SL4A’s shell interpreter. It’s essentially

the same bash script environment you would see at a typical Linux terminal prompt. You’ll find all the

familiar commands for manipulating files like cp, ls, mkdir, and mv.

Python

Python has a wide usage and heavy following, especially within Google. In fact, its following is so

significant they hired the inventor of the language, Guido van Rossum. Python has been around for quite

a while and has many open source projects written in the language. It also has seen the most interest as

far as SL4A is concerned, so you’ll find more examples and discussions in the forums than for any of the

other languages. For that reason, I will spend a little more time introducing the language, trying to hit

the highlights of things that will be important from an SL4A perspective.

Language Basics

Knowing the Python language is not an absolute requirement for this book, but it will help. The first

thing you need to know about Python is that everything is an object. The second thing is that whitespace

is meaningful in Python. By that, I mean Python uses either tabs or actual spaces (ASCII 32) instead of

curly braces to control code execution (see Figure 1-2). Third, it’s important to remember that Python is

a case-sensitive language.

Figure 1-2. Example of whitespace usage in Python

Python is a great language to use when teaching an “introduction to computer programming”

course. Every installation of standard Python comes with a command-line interpreter where you can

type in a line of code and immediately see the result. To launch the interpreter, simply enter python at a

command prompt (Windows) or terminal window (Linux and Mac OS X). At this point, you should see a

few lines with version information followed by the triple arrow prompt (>>>), letting you know that

you’re inside the Python interpreter as shown here:

CHAPTER 1 ■ INTRODUCTION

C:\Users\paul>python

Python 2.6.6 (r266:84297, Aug 24 2010, 18:13:38) [MSC v.1500 64 bit (AMD64)] on

win32

Type "help", "copyright", "credits" or "license" for more information.

>>>

Python uses a number of naming conventions that you will see if you examine much Python code.

The first is the double underscore, which is used in Python to “mangle” or change names as a way to

define private variables and methods used inside a class. You will see this notation used for “special”

methods such as __init__(self). If a class has the special __init__ method, it will be invoked whenever

a new instantiation of that class occurs.

For example:

>>> class Point:

def __init__(self, x, y):

self.x = x

self.y = y

>>> xy = Point(1,2)

>>> xy.x, xy.y

(1, 2)

As you can see from the example, self is used as a reserved word in Python and refers to the first

argument of a method. It’s actually a Python convention and, in reality, has no special meaning to

Python. However, because it’s a widely accepted convention, you’ll want to stick with it to avoid any

potential issues. Technically, self is a reference to the class or function itself. Methods within a class

may call other methods in the same class by using the method attributes of the self argument.

Python has a short list of built-in constants. The main ones you’ll run into are False, True, and None.

False and True are of type bool and show up primarily in logical tests or to create an infinite loop.

One of the things that frequently confuses new users of the language is the variety of data types. The

following sections give quick overview of the key data types you’ll need to use Python and SL4A.

Dictionary: An Unordered Set of Key/Value Pairs Requiring Unique Keys

A Python dictionary maps directly to a JSON data structure. The syntax for defining a dictionary uses

curly braces to enclose entries and a colon between the key and value. Here’s what a simple dictionary

definition looks like:

students = {'barney' : 1001, 'betty' : 1002, 'fred' : 1003, 'wilma' : 1004}

To reference entries, use the key, as shown here:

students['barney'] = 999

students['betty'] = 1000

You can also use the dict() constructor to build dictionaries. When the key is a simple string, you

can create a new dictionary using arguments passed to dict() such as the following:

students = dict(barney=1001, betty=1002, fred=1003, wilma=1004)

CHAPTER 1 ■ INTRODUCTION

Because everything in Python is an object, you can expect to see methods associated with a

dictionary object. As you might expect, there are methods to return the keys and the values from a

dictionary. Here’s what that would look like for the students dictionary:

>>> students

{'barney': 1001, 'betty': 1002, 'fred': 1003, 'wilma': 1004}

>>> students.keys()

['barney', 'betty', 'fred', 'wilma']

>>> students.values()

[1001, 1002, 1003, 1004]

The square bracket convention denotes a list. Evaluating the students.keys() statement returns a

list of keys from the students dictionary.

List: A Built-In Python Sequence Similar to an Array in Other Languages

In Python, a sequence is defined as “an iterable which supports efficient element access using integer

indices via the __getitem__() special method and defines a len() method that returns the length of the

sequence.” An iterable is defined as “a container object capable of returning its members one at a time.”

Python provides direct language support for iteration because it’s one of the more common operations

in programming. List objects provide a number of methods to make working with them easier. From the

Python documentation:

• list.append(x): Add an item to the end of the list; equivalent to a[len(a):] = [x].

• list.extend(L): Extend the list by appending all the items in the given list;

equivalent to a[len(a):] = L.

• list.insert(I,x): Insert an item at a given position. The first argument is the

index of the element before which to insert, so a.insert(0, x) inserts at the front

of the list, and a.insert(len(a), x) is equivalent to a.append(x).

• list.remove(x): Remove the first item from the list whose value is x. It is an error if

there is no such item.

• list.pop([i]): Remove the item at the given position in the list and return it. If no

index is specified, a.pop() removes and returns the last item in the list. (The

square brackets around the i in the method signature denote that the parameter is

optional, not that you should type square brackets at that position.) You will see

this notation frequently in the Python Library Reference.

• list.index(x): Return the index in the list of the first item whose value is x. It is an

error if there is no such item.

• list.count(x): Return the number of times x appears in the list.

• list.sort: Sort the items of the list, in place.

• list.reverse(x): Reverse the elements of the list, in place.

CHAPTER 1 ■ INTRODUCTION

strip( [chars])

swapcase( )

title( )

translate( table[, deletechars])

upper( )

zfill( width)

With Python 2.6, the built-in str and unicode classes provide a very full-featured formatting and

substitution capability through the str.format() method. There’s also a Formatter class with an even

more extensive set of methods suitable for implementing a templating capability. Python uses the

percent sign with strings for formatting as well. Here’s an example of using the percent sign in a print

statement:

>>> Pi = 3.141593

>>> print "Pi = %10.2f" % Pi

Pi = 3.14

>>> print "Long Pi = %10.6f" % Pi

Long Pi = 3.141593

This is a good place to talk about the use of slices in Python. Any object with multiple items, such as

a string, can be addressed using a notation called a slice. To reference the items from j to k of string s,

use s[j:k]. Adding a third item to the slice notation includes a step so that s[j:k:l] references the

items from j to k, incremented by l. To reference items from the beginning of the list to the nth item, use

s[:n], and from the nth item to the end would use s[n:]. For example:

>>> mylist = [1,2,3,4,5,6,7,8,9]

>>> mylist[:3]

[1, 2, 3]

>>> mylist[3:]

[4, 5, 6, 7, 8, 9]

Note that Python uses zero-based referencing. So, the first or zeroth element of mylist would be

equal to 1. The syntax mylist[:3] says “return all elements of mylist from the beginning up to, but not

including, the fourth element.” Negative indices count from the end of the list.

Tuple: An Immutable List

As with the string type, a tuple is immutable, meaning it can’t be changed once created. Tuples are

defined using the same syntax as a list, except they are enclosed by parentheses instead of square

brackets. Here’s an example of a tuple:

>>> Sentence = ("Today", "is", "the", "first", "day", "of", "the", "rest", "of", "your",

"life.")

>>> Sentence

('Today', 'is', 'the', 'first', 'day', 'of', 'the', 'rest', 'of', 'your', 'life.')

>>> Sentence[0]

'Today'

>>> Sentence[1:3]

('is', 'the')

>>> Sentence[-1]

'life.'

剩余295页未读，继续阅读

u011000529

粉丝: 72
资源: 25

Python与SL4A打造Android实用应用：简化开发与自动化

Apress.Pro.Android.Python.with.SL4A.Jul.2011.rar

ProAndroidPythonWithSl4a.pdf 英文原版

Pro Android Python with SL4A 无水印pdf

filed to load class org.sl4j.impl

如何在Android应用中调用Python脚本实现特定功能？请提供详细步骤和代码示例。

android调用python代码

android运行python脚本

如何在Android中调用python

脚本是基于安卓系统的

external/sl4a/Common/src/com/googlecode/android_scripting/facade/telephony/TelephonyManagerFacade.java 这个是跟谷歌的接口名

最新资源