Pys60

[Enzo74]

Ciao a tutti

visto che più di un amico qui sul forum si diverte come me a fare qualcosina con python per S60 pensavo che fosse cosa utile aprire un topic più specifico dell'argomento e magari cercare di dare qualche piccolo consiglio a chi deciderà di provare a fare qualcosina come noi...

Più che corsi o guide pratiche (che ce ne sono già tantissime in web) pensavo magari a qualche esempio pratico molto ma molto elementare che aiutasse alla comprensione o alla conoscenza seppur basilare delle sue possibilità e del suo modo di lavorare.

Inizio io con l'elencare gli strumenti necessari per iniziare ma sono sicuro che mi farà compagnia più di qualche amico

Brevi informazioni...

Python fondamentalmente è classificato come linguaggio di scripting,

infatti è possibile attraverso dei semplici script di sistema realizzare vere e proprie

applicazioni.

I suoi punti cardini sono la grande quantità di librerie già disponibili e la sua grande

facilità rispetto ai veri e propri linguaggi di programmazione.

In realtà grazie alla folta schiera di utenti che implementano sempre nuove funzionalità

e librerie è possibile realizzare applicazioni anche molto complesse.

Python ha già di suo una bella raccolta di librerie standard a cui è possibile aggiungerne

sempre di nuove scritte in C o in phyton stesso.

Python è multipiattaforma quindi è possibile far girare i suoi script su Linux, Mac, Windows

e altre piattaforme (tra le quali il nostro amato symbian).

Python è free e non bisogna spendere altro che il tempo cui gli si dedica.

dal sito del progetto

http://sourceforge.net/projects/pys60

scegliere la versione adatta la vostro cell per esempio

PythonForS60_1_3_11_2ndEdFP2.SIS (6630, 6670, 6680, ecc)

oppure

PythonForS60_1_3_11_2ndEdFP3.SIS (N70, N90)

Per utilizzarlo dalla versione 1.3.11 è necessario anche installare la shell

PythonScriptShell_1_3_11_2ndEdFP2.SIS

oppure

PythonScriptShell_1_3_11_2ndEdFP3.SIS

io consiglio anche la bellissima documentazione allegata

PythonForS60_doc_1_3_11.pdf

e l'SDK per avere l'ambiente di sviluppo al completo (anche se io non lo utilizzo al momento)

PythonForS60_1_3_11_SDK_2ndEdFP2.zip

Modificato 10 Novembre 2009 da Il.Socio

[Enzo74]

A questo punto nel menù potremo vedere la simpatica icona del "pitoncino"

una volta entrati possiamo agire in diversi modi

da opzioni

opzioni -->

Run script

Interactive console

Bluetooth console

About python

In linea di massima con Run script possiamo fare eseguire uno script in formato python (tipicamente hanno l'estensione .py e dato che non sono compilati è possibile darci sempre una sbirciatina anche con il blocco note al pari dei listati HTML).

Con l'interactive console invece possiamo scrivere passo passo il codice che viene eseguito di volta in volta

L'aspetto di pys60 (il python per symbian) è pressappoco questo

Come tutti i tutorial che si rispettano si inizia sempre dall'hello word

l'hello word di python è quasi banale

basta scrivere

print "Hello World"

che il sistema restituirà la scritta Hello Word

[Enzo74]

per utilizzare python praticamente è necessario conoscere i suoi moduli e le relative proprietà...

A questo punto una sfogliatina al manuale

PythonForS60_doc_1_3_11.pdf

rende più chiare le cose...

Alcuni moduli ad esempio sono

Appuifw

shutil

e32

os

random

time

camera

sysinfo

audio

location

messaging

inbox

e ogni modulo permette di interagire con qualcosa.

ad esempio il modulo camera la fotocamera del cell, il modulo audio le funzioni realative al suono ecc...

il modulo in linea di massima si deve prima importare con il comando

import...

esempio

import camera importerà questo modulo e a questo punto potremo usare le sue proprietà...

A titolo di esempio pratico il modulo sysinfo controlla le informazioni del sistema e le sue proprietà sono:

battery()

Il valore da 0 a 7 indica lo stato di carica della batteria

display_twips()

Definizione in pixel del display in “twips”

display_pixels()

Definizione in pixel del display in pixel

free_drivespace()

Spazio libero nell'unità che contiene python

imei()

Visualizza codice imei del telefono

max_ramdrive_size()

Ram massima disponibile nel dispositivo

total_ram()

Ram totale

free_ram()

Ram libera

total_rom()

Rom totale

ring_type()

Tipo di suoneria (normale, ascendente, beep, silenzioso)

os_version()

Vesione del sistema operativo

signal()

Il valore da 0 a 7 indica l’intensità del segnale

sw_version()

Versione del software del telefono

per conoscere l'imei del cell quindi bisogna prima importare il modulo

sysinfo e poi richiamare la proprietà imei()

il listato (si fa per dire dato che è cortissimo) è il seguente:

import sysinfo

sysinfo.imei()

per sapere il livello della batteria o per usarlo poi (ad esempio come stringa) in applicazioni più complesse ad esempio

import sysinfo

sysinfo.battery()

o per conoscere le dimensioni del display

import sysinfo

sysinfo.display_pixels()

Modificato 18 Ottobre 2006 da Enzo74

[giangio1986]

Come tutti i tutorial che si rispettano si inizia sempre dall'hello word

l'hello word di python è quasi banale

basta scrivere

print "Hello World"

che il sistema restituirà la scritta Hello Word

a me da errore di sintassi...xkè?

[FAxN70]

Giangio.. come ti dà errore di sintassi!?!?

Impossible..!

Nn sò come spiegartelo ben.. ma prima di dare l'invio devi aspettare che il cursore dopo le ultime virgolette torni a lampeggiare..!

Nn sò se mi sono spiegato..!

Cmq.. piccolo "Hello World" avanzato..:

Due semplici righe che si possono eseguire sempre dal interactive console..

import appuifw

appuifw.note(u"Hello World")

Ps io consiglio di installarvi l'sdk della nokia e il relativo Pythonfor sdk ecc... Risparmiate un sacco di tempo, potete provare i vostri programmi direttamente sul pc.. senza dover tenere il cel sempre attaccato..!!

Modificato 19 Ottobre 2006 da FAxN70

[FAxN70]

Continuo col scrivere qualcosina..

Il linguaggio python è molto semplice e di facile apprendimento anche per il modo in cui vengono compilati gli script.. Ovvero in python l'unica cosa da tener d'occhio sono la punteggiatura e l'indentadura.. nn ci sono parentesi graffe o variabili da dichiarare di difficile comprensione..

Questo è un esempio di Hello world trovato su wikipedia in c++:

"#include <iostream>

int main()

{

std::cout << "Hello World!" << std::endl;

return 0;

}"

Mentre in python il tutto si riduce (come abbiamo già visto..):

" print 'Hello World' "

Molto molto più easy..

Come dicevo sono importanti sia le punteggiature che le indentature..

Altro piccolo esempio..

per creare una funzione si usa questa punteggiatura.:

def(dichiara una funzione) nomefunzione():

... operazioni da eseguire

... operazioni da eseguire

#Esemio:#

def somma(x,y):

... risultato=x+y

... print "La somma di %s e %s dà come risultato: %s"%(x,y,risultato)

#Ok la funzione somma è stata dichiarata,è molto importante seguire l'indentatura, ovvero le operazioni che devono essere eseguite dalla funzione "somma" devono essere scritte "all'interno" altrimenti vi darà un errore di sintassi, la funnzione nn farà altro che eseguire la somma di x e y.. e ritornare la stringa "La somma di ecc..." quando chiamate questa funzione dovrete specificare x e y con 2 numeri Esempio:#

>>> somma(5,9)

#ecco cosa otterrete#

La somma di 5 e 9 dà come risultato: 14

>>>

Modificato 19 Ottobre 2006 da FAxN70

[FAxN70]

Continuo col scrivere qualcosina..

Il linguaggio python è molto semplice e di facile apprendimento anche per il modo in cui vengono compilati gli script.. Ovvero in python l'unica cosa da tener d'occhio sono la punteggiatura e l'indentadura.. nn ci sono parentesi graffe o variabili da dichiarare di difficile comprensione..

Questo è un esempio di Hello world trovato su wikipedia in c++:

"#include <iostream>

int main()

{

std::cout << "Hello World!" << std::endl;

return 0;

}"

Mentre in python il tutto si riduce (come abbiamo già visto..):

" print 'Hello World' "

Molto molto più easy..

Come dicevo sono importanti sia le punteggiature che le indentature..

Altro piccolo esempio..

per creare una funzione si usa questa punteggiatura.:

def(dichiara una funzione) nomefunzione():

... operazioni da eseguire

... operazioni da eseguire

#Esemio:#

def somma(x,y):

... risultato=x+y

... print "La somma di %s e %s dà come risultato: %s"%(x,y,risultato)

#Ok la funzione somma è stata dichiarata,è molto importante seguire l'indentatura, ovvero le operazioni che devono essere eseguite dalla funzione "somma" devono essere scritte "all'interno" altrimenti vi darà un errore di sintassi, la funnzione nn farà altro che eseguire la somma di x e y.. e ritornare la stringa "La somma di ecc..." quando chiamate questa funzione dovrete specificare x e y con 2 numeri Esempio:#

>>> somma(5,9)

#ecco cosa otterrete#

La somma di 5 e 9 dà come risultato: 14

>>>

[Enzo74]

APPUIFW

========

Il modulo appuifw è sicuramente uno dei più utilizzati nella programmazione di

applicazioni symbian poichè offre un interfaccia alle nostre applicazioni.

Al pari degli altri moduli prima di utilizzarlo è importante "importarlo" con

import appuifw

E' ora possibile implementare finestre informative, di richiesta (query),

listbox e quant'altro.

Il modulo appuifw ha diverse funzioni tra cui "note" con cui implementare

finestre informative o ad esempio di errore...

provate con

appuifw.note(u"Questa è una finestra informativa", 'info')

oppure con

appuifw.note(u"Questa è una finestra di errore", 'error')

per vederne l'effetto

La funzione "query" invece permette di ottenere un interfaccia attraverso

la quale richiedere un informazione e poterla gestire successivamente

valore = appuifw.query(u'inserisci testo', 'text' )

in questo modo nella variabile valore abbiamo incamerato quello che l'utente

ha scritto nella casella di testo della query.

Potremmo sfruttare l'informazione con dei cicli decisionali (if..then..else..)

oppure a scopo didattico con un

print valore

In questo caso il tipo di dato raccolto è un testo (text) e quindi il tipo

di formato della query è una casella di testo. però è possibile avere dei

tipi di "raccoglitore" diverso come ad esempio quello della data in formato

01/01/1970 o altri.

Es. per una data

valore = appuifw.query(u'inserisci data', 'date' )

l'elenco completo dei formati è

text, code, number, date, time, query e float

La funzione "multi_query" è simile alla query precedentemente vista ma

differisce per il fatto che è possibile richiedere più di una informazione

contemporaneamente. è quindi possibile raccogliere più dati

Eccone un esempio pratico molto semplice

RICHIEDERE INFORMAZIONI MEDIANTE MULTI_QUERYBOX

import appuifw

data1,data2 = appuifw.multi_query(u"Nome:",u"Cognome:")

print data1

print data2

La funzione "popup_menu" permette di creare dei semplici menù per le nostre

applicazioni.

Praticamente si imposta prima una lista attraverso una variabile (nel nostro

esempio mylist) e attraverso la stessa si implementa il menù...

POPUP MENU

import appuifw

mylist = [u'mela',u'banana',u'arancia',u'pera']

appuifw.popup_menu(mylist, u'mia lista')

La funzione "selection_list" permette di ottenere una lista tra cui scegliere

un solo dato.

Il sistema alla fine della scelta restituisce l'indice della scelta (ovvero un

numero che va da 0 a n oggetti - 1)

In questo esempio

APPUIFW - SELECTION_LIST - UNA LISTA

import appuifw

lista = [u'mela',u'banana',u'arancia',u'pera']

appuifw.selection_list(lista)

banana ha indice 1 mentre pera ha indice 3 poichè mela ha indice 0

Sarà così possibile programmare gli eventi legati alla scelta

Con la funzione multi_selection_list invece è possibile scere più valori della

lista che coesistono contemporaneamente.

Mettiamo il caso che all'utente può piacere sia la mela che la pera

APPUIFW - MULTI_SELECTION_LIST - UNA LISTA MULTISELEZIONE

import appuifw

lista = [u'mela',u'banana',u'arancia',u'pera']

appuifw.multi_selection_list(lista, style='checkmark')

[Enzo74]

Esempi pratici dell'utilizzo di appuifw

(molto ma molto brevi)

-------------------------

UNA FINESTRA DI ERRORE

import Appuifw

Appuifw.note(u'Nessuna connessione', 'error')

-------------------------

DEFINIRE IL TITOLO DELL'APPLICAZIONE

import Appuifw

Appuifw.app.title = u'MiaApp'

-------------------------

UNA FINESTRA INFORMATIVA CON TITOLO

import Appuifw

Appuifw.app.title = u"Ciao"

Appuifw.note(u"Questo è un testo di prova!", 'info')

-------------------------

APPUIFW.APP.SCREEN - IMPOSTARE LA GRANDEZZA DELL'APPLICAZIONE SULLO SCHERMO

import appuifw

appuifw.app.screen='large'

'le altre possibilità sono normal, large e full

-------------------------

LA LISTA DEI FONTS

import Appuifw

devicefonts = Appuifw.available_fonts()

print devicefonts

-------------------------

APPUIFW - SELECTION_LIST - UNA LISTA

import appuifw

lista = [u'mela',u'banana',u'arancia',u'pera']

appuifw.selection_list(lista)

-------------------------

APPUIFW - MULTI_SELECTION_LIST - UNA LISTA MULTISELEZIONE

import appuifw

lista = [u'mela',u'banana',u'arancia',u'pera']

appuifw.multi_selection_list(lista, style='checkmark')

-------------------------

APPUIFW.QUERY - RICHIEDERE UNA DATA

import appuifw

valore = appuifw.query(u'inserisci data', 'date' )

print valore

-------------------------

RICHIEDERE INFORMAZIONI MEDIANTE MULTI_QUERYBOX

import Appuifw

data1,data2 = Appuifw.multi_query(u"Nome:",u"Cognome:")

print data1

print data2

-------------------------

CANCELLARE LA VIDEATA E RICHIEDERE DEI DATI MEDIANTE QUERY BOX

import Appuifw

Appuifw.app.body = None

valore = Appuifw.query(u'inserisci testo', 'text' )

valore = Appuifw.query(u'inserisci codice', 'code' )

-------------------------

POPUP MENU

import Appuifw

mylist = [u'mela',u'banana',u'arancia',u'pera']

Appuifw.popup_menu(mylist, u'mia lista')

-------------------------

Elenco di alcune proprietà e metodi del

modulo appuifw

note

Espone un dato (msgbox)

query

Raccoglie un dato mediante casell1 di testo

multi_query

Raccoglie più dati contemporaneamente mediante caselle di testo

selection_list

Raccoglie un dato mediante lista a scelta unica

multi_selection_list

Raccoglie un dato mediante lista a scelta multipla

popup_menu

Costruisce dei semplici menù

appuifw.app.title

Definisce il titolo dell’applicazione

appuifw.app.body

Definisce il “corpo” dell’applicazione

appuifw.available_fonts()

Lista dei fonts disponibili

appuifw.app.screen

Imposta la videata come normal, large o full

appuifw.app.focus

imposta l’applicazione che deve avere il focus (0 = focus perso 1 = focus impostato)

[Enzo74]

Alcuni esempi ELEMENTARI sul modulo Audio

Visto che un pò di amici si stanno cimentando in applicazioni audio

ho provato tre semplicissime applicazioni facilmente realizzabili e

riproducibili direttamente sul telefonino.

Si importa prima il modulo audio con

import audio

poi sia per suonare un file che per registrare bisogna definire il

percorso del file "input" o "output"

e di conseguenza comandare la funzione

play()

o

record()

a seconda se si sta registrando o suonando un file.

la funzione

close()

è utile per "scaricare" dalla memoria il file che

abbiamo impostato come input o come output.

Esiste anche la funzione

stop()

che però non scarica il file ma lo ferma solo nella sua

riproduzione o registrazione in quella determinata posizione.

A questo proposito la guida in pdf ufficiale è davvero ben fatta

Ecco i miei piccoli esempi

SUONARE UN FILE MP3

import audio

s = audio.Sound.open("e:\\moneta_che_cade.mp3")

s.play()

-------------------------

REGISTRARE UN FILE WAV

import audio

s = audio.Sound.open("e:\\prova.wav")

s.record()

print "registrazione in corso..."

-------------------------

FERMARE E SALVARE UN FILE CHE SI STA REGISTRANDO

'nell'esempio precedente

s.close()

-------------------------

consiglio in fase di prova mentre si sta registrando di fermare

la registrazione scrivendo proprio s.close() e poi magari riaprire

il file per sentirlo con lo stesso comando open...

L'interfaccia grafica è a gusto del programmatore

PS. visto che ieri c'era il quesito di quanto lungo poteva essere un

mp3 in riproduzione se fate qualche prova su qualche file particolarmente

lungo mi fate sapere se è tutto ok?

PS2. non ho avuto modo di provare a registrare un file direttamente in

mp3 se qualcuno prova mi fa sapere se funziona?

[Enzo74]

oggi qualche esempio pratico su come usare funzionalità sms e telefono rigorosamente molto piccoli...

-------------------------

SMS_SEND - SPEDIRE UN SMS

import messaging

messaging.sms_send("123456789", "testo del messaggio")

-------------------------

SMS_SEND - SPEDIRE PIU' SMS

import messaging

messaging.sms_send("123456789", "testo del 1 messaggio")

messaging.sms_send("987654321", "testo del 2 messaggio")

-------------------------

TELEPHONE.DIAL - EFFETTUARE UNA TELEFONATA

import telephone

telephone.dial(u'+123456789')

-------------------------

INBOX.SMS_MESSAGES - CONOSCERE GLI ID DEI VARI SMS IN CASELLA RICEVUTI

import inbox

i=inbox.Inbox()

i.sms_messages()

'restituisce ad esempio [1053221, 1053013, 1052439]

-------------------------

INBOX.CONTENT - CONOSCERE IL TESTO DI UN SMS DAL SUO ID

import inbox

i=inbox.Inbox()

i.content(id dell'sms es 1053221)

-------------------------

INBOX.ADDRESS - CONOSCERE IL MITTENTE DI UN SMS DAL SUO ID

import inbox

i=inbox.Inbox()

i.address(id dell'sms es 1053221)

-------------------------

INBOX.DELETE - CANCELLARE UN SMS DAL SUO ID

import inbox

i=inbox.Inbox()

i.delete(id dell'sms es 1053221)

-------------------------

[Enzo74]

Spesso estrarre o gestire dei caratteri da una stringa inglobata o meno in una variabile può essere necessario. a questo si ispira l'esempio di oggi

ESTRARRE N CARATTERI DA UNA STRINGA

la cifra prima dei due punti (es [3:]) indica quante lettere cancellare dall'inizio della parola

la cifra dopo dei due punti (es [:3]) fa il contrario ovvero indica quante lettere visualizzare dall'inizio della parola (il resto le elimina)

s = "prova"

print s[3:]

-->resituisce "va"

s = "prova"

print s[:3]

-->resituisce "pro"

s = "prova"

print s[:]

-->resituisce "prova"

s = "prova"

print s[2:4]

-->resituisce "ov"

s = "prova"

print s[2:-2]

-->resituisce "o"

praticamente qui si parte dal cancellarne 2 dall'inizio e quindi rimane "ova" ma poi se ne levano 2 dalla fine e quindi rimane "o"

mentre

s = "prova"

print s[2:-1]

-->resituisce "ov"

qui si parte dal cancellarne 2 dall'inizio e quindi rimane "ova" ma poi se ne leva solo 1 dalla fine e quindi rimane "ov"

in effetti python è un pò complicato in questo tipo di sintassi perchè con visual basic sarebbe di gran lunga più semplice e più razionale estrapolare dati dando il punto di inizio e il numero di caratteri da destra o da sinistra

probabilmente quando non è scritto nulla è da intendersi zero

buon python

Modificato 8 Novembre 2006 da Il.Socio

[frizz]

posto a titolo di esempio il codice del programma che ho realizzato con l'aiuto di Enzo74 e Matteo6630

Fa partire chiamate verso un numero di telefono a intervalli di tempo prestabiliti. Tutte vengono chiuse dopo tot secondi. Viene visualizzato l'orario nel quale la chiamata è stata fatta completo di indice dell'ordine della stessa.

from time import ctime #importo il mudulo che mi consente piu in là di acquisire l'orario dall'orologio di sistema

import telephone #importo il modulo che consente l'utilizzo della funzione dial e hang_up

def a():

telephone.dial(u'123456789') #la funzione a() fa partire la chiamata al numero in questione

def b():

telephone.hang_up() #b() invece interrompe la chiamata corrente

import e32

timer= e32.Ao_timer() #creo l'istanza della classe Ao_timer()

timer.after(10) #questa operazione mi consente di 'addormentare' il programma per tot secondi

a() #parte la chiamata dopo 10 secondi di sonno

timer.after(10) #zzzzzzz.....(intanto il cell sta chiamando)

b() #finiti i tot secondi si risveglia e la prima istruzione che trova è questa che fa arrestare la chiamata

print '-1- ', ctime() #il suo bel lavoro l'ha fatto, ma ora visualizza indice e orario corrente xke è uno preciso

print "" #va a capo, cosi poi posso rivedere il tutto in modo ordinato

timer.after(20) #ora l'intervallo tra uno squillo e l'altro è di 20 sec

a()

timer.after(14) #stavolta lo squillo lo faccio un po piu lungo

b()

print '-2- ', ctime()

print ""

timer.after(100)

a()

timer.after(10)

b()

print '-3- ', ctime()

print ""

e cosi via!

Modificato 28 Ottobre 2006 da frizz

[Enzo74]

I tips di oggi riguardano la lettura o la scrittura di un file

sui nostri dispositivi

-------------------------

SCRIVERE UN FILE - WRE

import sys

miofile = open('e:/prova.txt','w')

miofile.wre('questo è il testo')

miofile.close()

-------------------------

LEGGERE UN FILE - READLINES

import sys

miofile = open('e:/prova.txt','r')

miofile.readlines()

-------------------------

magari offrirà nuove funzionalità a qualche programma

[dokkis]

Funzioni di random:

import random

# Random di numeri float da 0 a 1

random.random()

# Random di numeri float da 1 a 10

random.uniform(1,10)

# Random di lettere dalla a alla z

random.choice('abdcefghilmnopqrstuvz')

# Random di numeri interi da 1 a 10 (inclusi)

random.randint(1,10)

# Ordina in modo casuale gli elementi dell'array 'arr'

arr = [1,2,3,4,5,6,7,8,9,10]

random.shuffle(arr)

# Sceglie 4 elementi dell'array 'arr' e li ordina in modo casuale:

arr = [1,2,3,4,5,6,7,8,9,10]

random.sample(arr,4)

EDIT: tanto per cambiare ho fatto un errore stupido, avevo chiamato il sorgente random.py come il nome della classe importata e non trovava i corrispettivi metodi -.-'

Modificato 28 Ottobre 2006 da dokkis

[Enzo74]

Come esempio funzionante di random ho questo:

-------------------------

RANDOM

import random

random.choice(['mela', 'pera', 'banana'])

restituisce ad esempio'mela'

-------------------------

[Enzo74]

altri tips rigorosamente facili da digerire per chi inizia

-------------------------

CONOSCERE LA DIRECTORY CORRENTE

import os

os.getcwd()

-------------------------

OS.LISTDIR - ELENCO DELLE CARTELLE

import appuifw

import e32

import os

imagedir=u'c:\\nokia\images'

files=map(unicode,os.listdir(imagedir))

print files[index]

'con index che va da 0 al numero-1 delle sottocartelle

-------------------------

LISTDIR - ELENCO DELLE CARTELLE IN UNA SELECTION_LIST

import appuifw

import e32

import os

imagedir=u'c:\\nokia'

files=map(unicode,os.listdir(imagedir))

index=appuifw.selection_list(files)

print files[index]

-------------------------

COPIARE UN FILE

import shutil

shutil.copyfile('e:/prova.txt','e:/prova2.txt')

-------------------------

E32.START_EXE - APRIRE IL BROWSER E PASSARGLI L'URL

import e32

apprun = 'z:\\system\\programs\\apprun.exe'

browser = 'z:\\System\\Apps\\Browser\\Browser.app'

url = 'http://www.google.com'

e32.start_exe(apprun, browser + ' "%s"' %url , 1)

-------------------------

[dokkis]

Modulo keycapture.. qui sotto posto un esempio di uso:

NB: c'è un BUG nelle lib del python... il bug dovrebbe consistere nel fatto che su C:\system\libs (se lo si è installati su C:\) c'è una libreria che si chiama _keycaputure.pyd mentre dovrebbe chiamarsi _keycapture.pyd (basta rinominarla togliendo la 'u' di troppo) e poi dovrebbe funzionare.. io l'ho provata e va..

--- Come usare il modulo KeyCapture ---

#funzione cb_capture di callback:

def cb_capture(key):

...if key==keycapture.EKeyLeftArrow:

....... print("left")

...elif key==keycapture.EKeyRightArrow:

....... print("right")

#dichiariamo l'istanza del modulo:

capturer=keycapture.KeyCapturer(cb_capture) #settiamo a cb_capture la funzione che si scatena ogni qual volta si preme un tasto filtrato

#settiamo qui i tasti che vogliamo controllare...

#keycapture.all_keys setta il controllo di TUTTI i tasti... usarlo attentamente dato che praticamente poi si controlla tutti i

#tasti dal programma, quindi bisogna riprogrammare eventuale tasto Exit e tasto menu... io consiglio di catturare solo i

#tasti che si vuole davvero controllare...

#per vedere i codici dei tasti rimando al pdf PythonForS60_doc_1_3_11.pdf al capitolo 5.2

capturer.keys=(keycapture.EKeyRightArrow,keycapture.EKeyLeftArrow) #cattura freccia dx e freccia sx

#avvia il keycapture

capturer.start()

Modificato 8 Novembre 2006 da Il.Socio

[dokkis]

"uso del canvas e come importare un immagine"

from appuifw import *

from graphics import *

import e32

def Draw(rect):

...#colore sfondo oltre l'immagine se questa non ricopre tutto lo schermo, serve cmq

...#a cancellare tutti gli oggetti precedentemente disegnati in modo da non sovrapporli

...canv.clear(0x000000) #nero

...img = Image.open("C:\\img.jpg") #dovrebbe leggere solo i formati jpg/jpeg e png

...canv.blit(img,target=(0,0)) #target=(x,y) 0,0=in alto a sx dello schermo

lock=e32.Ao_lock()

#assegno l'oggetto canv al body del mio form

#ogni qual volta è necessario ridisegnare l'img verrà chiamata la funzione Draw

#ad es quando si esce dal menu e si rientra nel prg, nel momento di rientro nel

#programma la classe Canvas richiama la callback di redraw

appuifw.app.body=canv=Canvas(redraw_callback=Draw)

appuifw.app.screen='full' #a schermo intero, oppure large (si vedono i 2 tasti di menu sotto, esci ecc..) altrimenti normal

#appena apro il programma disegno la mia immagine

Draw(())

lock.wait()

Modificato 8 Novembre 2006 da Il.Socio

[Enzo74]

tips molto basilari per chi comincia

-------------------------

CICLO WHILE - ESEGUIRE UN OPERAZIONE FINO AD UNA DETERMINATA CONDIZIONE

a = 0

while a < 10:

.....a = a + 1

.....print a

-------------------------

LIST - SEMPLICE PARAMETRAZIONE DI UNA LISTA

list = ['zero','uno','due']

list[1]

restituisce "uno"

-------------------------

LEN - SAPERE QUANTI ELEMENTI SONO PRESENTI NELLA LISTA

list = ['zero','uno','due']

len(list)

restituisce "3"

-------------------------

[Enzo74]

DIR - COME CONOSCERE TUTTE LE FUNZIONI SUPPORTATE DA UN MODULO

sintassi:

import <module_name>

dir(module_name)

es.

import e32

dir(e32)

restituisce

['Ao_lock', '__doc__', '__name__', '_as_level', '_mem_info', '_stdo', '_uidcrc_a

pp', 'ao_callgate', 'ao_sleep', 'ao_yield', 'drive_list', 'file_copy', 'is_ui_th

read', 'start_exe', 'start_server']

[Enzo74]

visto che in alcuni esempi riguardanti canvas ci sono i colorcode posto qualche codice di qualche colore nel caso a qualcuno servisse. sono solo alcuni perchè in realtà sono molti di più

white, 0xffffff

snow, 0xfffafa

silver, 0xc0c0c0

gray, 0x808080

black, 0x000000

azure, 0xf0ffff

lightblue, 0xadd8ed

skyblue, 0x87ceeb

cyan, 0x00ffff

aqua, 0x00ff80

deepskyblue, 0x00bfff

aquamarine, 0x7fffd4

turquoise, 0x40e0d0

teal, 0x008080

blue, 0x0000ff

navy, 0x000080

lime, 0x00ff00

green, 0x008000

olive, 0x808000

ivory, 0xfffff0

beige, 0xf5f5dc

yellow, 0xffff00

gold, 0xffd700

wheat, 0xf5deb3

orange, 0xffa500

oldlace, 0xfdf5e6

linen, 0xfaf0e6

salmon, 0xfa8072

coral, 0xff7f50

tomato, 0xff6347

orangered, 0xff4500

red, 0xff0000

crimson, 0xdc143c

maroon, 0x800000

thistle, 0xd8bfd8

pink, 0xffc0cb

fuchsia, 0xff00ee

magenta, 0xff00ff

plum, 0xdda0dd

violet, 0xee82ee

purple, 0x9370db

tan, 0xd2b48c

sandybrown, 0xf4a460

peru, 0xcd853f

goldenrod, 0xdaa520

chocolate, 0xd2691e

rosybrown, 0xbc8f8f

sienna, 0xa0522d

brown, 0xa52a2a

[Enzo74]

Oggi posto degli esempi che possono tornare utili nel caso

ad esempio si vogliono trattare delle strighe per criptarle

a livelli molto soft ad artigianali.

Ritengo che gli esempi abbiano comunque valore didattico

-------------------------

ORD - TRASFORMARE IL CARATTERE NEL SUO RISPETTIVO NUMERO

char = 't'

print chr(ord(char)+1)

-> restituisce u

char = 't'

print chr(ord(char)+0)

-> restituisce t

-------------------------

MATH.POW - CALCOLARE LA POTENZA DI UN NUMERO

import math

math.pow(2,4)

-> restituisce 16.0 (2 elevato alla 4)

oppure senza scomodare il modulo math

2**4

-> restituisce 16

-------------------------

RANDOM.RANDOM - STAMPA UN NUMERO CASUALE

import random

random.random()

restituisce ad esempio 0,388366897509018

-------------------------

[Enzo74]

altre utili mini routine...

-------------------------

PRINT - ARROTONDARE UN NUMERO CON PRINT

numero = 12.3456789

print '%.3f' % numero

->restituisce 12,345

numero = 12.3456789

print '%.5f' % numero

->restituisce 12,34567

il parametro prima della f indica il numero di decimali

a cui arrotondare

-------------------------

REPLACE - SOSTITUIRE CARATTERI IN UNA STRINGA

variabile = 'giorno'

print variabile.replace('o','i')

->restituisce giirni perchè sostituisce ogni o con una i

esiste anche l'argomento opzionale maxsplit che

specifica il numero massimo di sostituzioni da fare

variabile = 'giorno'

print variabile.replace('o','i',1)

->restituisce giirno perchè sostituisce solo una o con una i

è possibile anche concatenare più replace

variabile = 'giorno'

print variabile.replace('o','i',1).replace('n','v')

->restituisce giirvi perchè sostituisce una o con una i e le n con le v

-------------------------

[Enzo74]

pensando di fare cosa utile ho riunito un bel pò di tips diciamo di estrema semplicità per favorire il valore didittico per chi inizia in un piccolo file pdf magari da tenere anche sul cell

fatemi sapere se c'è qualcosa da correggere e ogni commento

PYS60_Esempi_07_11_06.pdf