Basic Python Elements (Python on Symbian)

Original Author:

>>> hours = 42.5
>>> hourly_wage = 12
>>> payment = hours * hourly_wage
>>> payment
510.0

overtime

>>> payment = hours * hourly_wage + overtime * hourly_wage * 1.5
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'overtime' is not defined

b'one'
01100010
01101110
01100101

>>> thelist = ['trees', 'birds', 'flowers']
>>> thelist
['trees', 'birds', 'flowers']
>>> thelist[1] = 'cows'
>>> thelist
['trees', 'cows', 'flowers']

>>> thetuple = ('trees', 'birds', 'flowers')
>>> thetuple
('trees', 'birds', 'flowers')
>>> thetuple[1] = 'cow'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

>>> thedictionary = {"item": "coffee", "onshelf": True, "quantity": 10}
>>> thedictionary["item"]
'coffee'
>>> thedictionary["quantity"] += 1
>>> thedictionary["quantity"]
11

>>> theset = set(['t', 'r', 'e', 'e'])
>>> theset
set(['r', 'e', 't'])
>>> anotherset = set('flower')
>>> theset & anotherset
set(['r', 'e'])
>>> theset | anotherset
set(['e', 'f', 'l', 'o', 'r', 't', 'w'])
>>> theset - anotherset
set(['t'])
>>> 't' in theset
True

>>> listing = [1, 2, 3, 4, "DONE"]
>>> listing + listing
[1, 2, 3, 4, 'DONE', 1, 2, 3, 4, 'DONE']
>>> listing * 3
[1, 2, 3, 4, 'DONE', 1, 2, 3, 4, 'DONE', 1, 2, 3, 4, 'DONE']

>>> drsuess = 'The Cat in the Hat'
>>> animal = drsuess[4:7]         # take out the cat
>>> animal
'Cat'
>>> onmyhead = drsuess[15:]       # get the Hat
>>> onmyhead
'Hat'
>>> lastone = drsuess[-1]         # last character
>>> lastone
't'

>>> drsuess = ["Horton Hears a Who", "Green Eggs and Ham"]
>>> drsuess[1][0:5]
'Green'
>>> drsuess[1][0:5][2]
'e'

drsuess
drsuess[1][0:5]
drsuess
Green

while (x < y) {
   x += 2;
   y = y - 2;
}

while
while

while x < y:
   x += 2
   y = y - 2

while
while
while

while x < y: x += 2; y = y - 2

while

while x<y:
   pass

x + 15 * L[2]

x
x
15
L[2]
L
x + 15 * L[2]
a < b
x + 15 * L[2] < 100 and a < b
a < b < c
f(x,y)
*
+
and
or
not

>>> aList = [10,20,30]
>>> aList.append(40)
>>> print aList
[10, 20, 30, 40]

aList.append(40)
None

>>> aList = [10,20,30]
>>> aNewList = aList.append(40)
>>> print aNewList
None

None
print
stdout
if

if <condition1>:
   <statementset1>
elif <condition2>:
   <statementset2>
else:
   <statementset3>

True
False
False
else

theString = "The Mad Hatter"
length = len(theString)
if length < 10:
   category = "short"
elif length < 20:
   category = "medium"
elif length < 30:
   category = "kind of long"
else:
   category = "long"

theString
True
category
medium
and
or
not

theString = "The Mad Hatter"
length = len(theString)
toolong = length > 40
printable = not toolong and length > 10
if printable:
   print "The string is OK"

theString = "The Mad Hatter"
length = len(theString)
if length:
   print "The string has characters"

True
True
False
None
False
False and x == 2
False
False and anything
False

theString = "The Mad Hatter"
length = len(theString)
value1 = length or theString == "The Mad Hatter"
value2 = theString == "The Mad Hatter" or length
value3 = 0.0 or theString == "Mad Hatter"

value1
length
value2
True
value3
False
if

if x < 10:
   x = 1
else:
   x = -1

x = 1 if x < 10 else -1

x = 1 if x < 10 else -1
while
for
if
goto
goto
goto
goto label
goto
goto
while
while

while <condition>:
   <statementset1>
else:
   <statementset2>

while

while True:
   print "Help! I'm running away..."

while x < y + 2:
   x += 1
   y -= 1

while a**2 < b**2 and c+d == e:
   a = c - d
   b += 1
   c -= 2

break
continue
break
break
continue

a = 20
while a: 
   a -= 1
   if a % 2 == 0: continue
   print a

continue

while a**2 < b**2:
   if c+d != e: break
   a = c - d
   b += 1
   c -= 2

c+d != e
while

while a**2 < b**2 and c+d == e:
...

False

while a**2 < b**2:
   if c+d != e: break
   ...

while
False
while

number = int(raw_input("Enter number: "))
count = 0
while number:
   count += 1
   total = total + number
   number = int(raw_input("Enter number: "))
else:
   print "The average is ", total/count

for
for

for <index> in <objectsequence>:
   <statementset1>
else:
   <statementset2>

for

thesum = 0
for x in [1, 2, 3, 4, 5, 6]:
   thesum += x
print "Average is ",thesum/6

thesum = 0
for x in (1, 2, 3, 4, 5, 6):
   thesum += x
print "Average is ",thesum/6

for
for

thetuple = [(10,3.14), (20, 14.5), (30, 17.9), (55, 2.31)]
thesum = 0
for (left,right) in thetuple:
   print "Reading ", left
   thesum += right
print "Average of lefts is ",thesum/len(thetuple)

Reading  10
Reading  20
Reading  30
Reading  55
Average of lefts is  9.4625

for
for
for

for (int i=0; i < objectlist.length; i++) 
   process(objectlist.get(i));

range()
objectlist.length
range()

for i in range(len(objectlist)):
   process(objectlist[i])

range()
objectlist.length

for x in range(10,100,5):
   ...

x
for
while
for
while
for
while
for
while
break
continue
for
while
for

countries = ["France", "Germany", "United States", "Austria", "Norway"]
iterator = iter(countries)
print iterator.next()

countries
iter(countries)

fd = open("data.txt")
print fd.next()
print fd.next()
print fd.next()

fd.readline()
enumerate()
for
enumerate()

countries = ["France", "Germany", "United States", "Austria", "Norway"]
for (offset, country) in enumerate(countries):
   print country, 'is the', offset, 'item in the list'

enumerate()
iter(countries)

France is the 0 item in the list
Germany is the 1 item in the list
United States is the 2 item in the list
Austria is the 3 item in the list
Norway is the 4 item in the list

for
for

powers = [2**1, 2**2, 2**3, 2**4, 2**5]

powers = [2 ** x for x in range(32)]

range()
next()
enumerate()
def

def <function name>(<parameter list>):
   <statementset>

def listaverage(aList):
   thesum = 0
   for x in aList:
      thesum += x
   print "Average is ",thesum/len(aList)

listaverage([1,2,3,4,5])

Average is  2

aList
def

if x < y:
   def announcement():
      print "x is indeed less than y!"
else:
   def announcement():
      print "Sorry, x is not less than y!"

shout = announcement
shout()

x
y

x is indeed less than y!

def swapper(aItem1, aItem2):
   temp = aItem1
   aItem1 = aItem2
   aItem2 = temp

x = "Number 1"
y = "Number 2"
swapper(x,y)
print "x = ", x, " and y = ", y

x =  Number 1  and y =  Number 2

def swapper2(aItem1, aItem2):
   aItem1[0] = 'Hello'
   aItem2[0] = 'there'

x = ['xitem0', 'xitem1', 'xitem2']
y = ['yitem0', 'yitem1', 'yitem2']
swapper2(x,y)
print "x = ", x, " and y = ", y

x =  ['Hello', 'xitem1', 'xitem2']  and y =  ['there', 'yitem1', 'yitem2']

swapper2()

swapper(aItem2=y, aItem1=x)

def sum(a, b=2, c=10):
   return (a+b+c)

sum(1,2,3)
b
c
sum(1)
sum(1,5)

return <expressions>

listaverage()

def listaverage(aList):
   thesum = 0
   for x in aList:
      thesum += x
   return thesum/len(aList)

listaverage([1,2,3,4,5])

def listaverage2(aList):
   thesum = 0
   for x in aList:
      thesum += x
   return len(aList),thesum/len(aList)

l,a = listaverage2(range(32))
print "l is ", l, " and a is ", a

l is  32  and a is  15

a = 100
def f():
   a = 99
f()
print a

a

a = 100
def f():
   a = 99
f()
print a

a
a
a
f()
a
100
a
a

a = 100
def f():
   print a
f()
print a

a
a
a
a
100
a

a = 100
def f():
   print a
   a = a+100
   print a
f()
print a

a

a = 100
def f():
   global a
   print a
   a = a+100
   print a
f()
print a

global
a
global
a

def min(a,b):
   return a if a>b else b
min(2,3)

min()
max()
min()
mileage
def

lambda <parameterlist>: <expression>

func = lambda a, b, c: (a + b + c) / 3
x = func(1,2,3)

func
def
def

table = {'green': (lambda: x * y),
      'orange': (lambda: x + y),
      'blue': (lambda: x - y + 2),
      'yellow': (lambda: x / y -1)
      }

color

table[color]()

if

class <name>(<superclass>,...):
    <shared data section>
    <method section>

class Account():
   def __init__(self, aStartingAmount):
      self.amount = aStartingAmount

   def deposit(self, aDepositAmount):
      self.amount += aDepositAmount
      return self.amount

   def withdraw(self, aWithdrawlAmount):
      self.amount -= aWithdrawlAmount
      return self.amount

   def balance(self):
      print self.amount

Account
amount
aStartingAmount
__init__()
__init__()
self.amount
amount
self
self
this

bankaccount = Account(1000)
bankaccount.balance()
bankaccount.deposit(250)
bankaccount.withdraw(100)
bankaccount.balance()

bankaccount
Account
amount
bankaccount
1000
1000

1000
1150

CheckingAccount
SavingsAccount
Account
Account
CheckingAccount
Account
SavingsAccount
Account
withdrawl

class CheckingAccount(Account):
   pass

class SavingsAccount(Account):

   def withdraw(self, aWithdrawlAmount):
      if (self.amount-aWithdrawlAmount > 100):
         self.amount -= aWithdrawlAmount
      return self.amount

CheckingAccount
Account
SavingsAccount
Account
withdraw()
Account
CheckingAccount
SavingsAccount
Account

def transfer(aAmount, aAcct1, aAcct2):
   aAcct2.deposit(aAcct1.withdraw(aAmount))

Account
CheckingAccount
SavingsAccount
Account

class Account():
   def __init__(self, aStartingAmount):
      self.amount = aStartingAmount

   def deposit(self, aDepositAmount):
      self.amount += aDepositAmount
      return self.amount

   def withdraw(self, aWithdrawlAmount):
      if (self.amount-aWithdrawlAmount > self.limit):
         self.amount -= aWithdrawlAmount
      return self.amount

   def balance(self):
      print self.amount

withdraw()
self.limit
Account
Account
CheckingAccount
SavingsAccount
self.limit

class CheckingAccount(Account):
   def __init__(self, aStartingAmount):
      self.amount = aStartingAmount
      self.limit = 0

class SavingsAccount(Account):
   def __init__(self, aStartingAmount):
      Account.__init__(self,aStartingAmount)
      self.limit = 100

self.limit
Account
CheckingAccount
__init__()
SavingsAccount
__init__()
__init__()
CheckingAccount
SavingsAccount

class MyNumber:
   def __init__(self, aInitialValue):
      self.value = aInitialValue
   def __add__(self, aValue):
      return MyNumber(self.value + aValue)

MyNumber

x = MyNumber(100)
y = x + 100

y.value
deposit()
withdrawl()
Account
Employee
Student
Employee
Student
class

class MenuItemWithButton(MenuItem, Button):
   ...

MenuItemWithButton
MenuItem
Button
isPressed
setVisible
class
setVisible
MenuItem
goto
try/except

try:
   <statementset1>
except <name1>:
   <statementset2>
except <name2>,<data>
   <statementset3>
except (name3, name4):
   <statementset4>
except:
   <statementset5>
else:
   <statementset6>
finally:
   <statementset7>

try
except
except
except
except
finally

a = 10
b = 0
try:
   c = a/b
except:
   print "Oops...something bad happened"

a = 10
b = 0
try:
   c = a/b
except ZeroDivisionError:
   print "Oops...something bad happened"

except

a = 10
b = 0
try:
   c = a/b
except ZeroDivisionError, message:
   print "Oops...something bad happened"
   print message

Oops...something bad happened
integer division or modulo by zero

else

a = 10
b = 10
try:
   c = a/b
except ZeroDivisionError, message:
   print "Oops...something bad happened"
   print message
else:
   print "Hey!  Something good happened"

else
try
except

Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ZeroDivisionError: integer division or modulo by zero

raise

raise <exceptionname1>
raise <exceptionname2>,<value>

try
Account

BalanceError = 'BalanceError'

class Account():
   def __init__(self, aStartingAmount):
      self.amount = aStartingAmount

   def deposit(self, aDepositAmount):
      self.amount += aDepositAmount
      return self.amount

   def withdraw(self, aWithdrawlAmount):
      if (self.amount-aWithdrawlAmount > self.limit):
         self.amount -= aWithdrawlAmount
      else:
         msg = "Account is overdrawn by "+str(-(self.amount-aWithdrawlAmount))
         raise BalanceError,msg
      return self.amount

def balance(self):
   print self.amount

class CheckingAccount(Account):
   def __init__(self, aStartingAmount):
      self.amount = aStartingAmount
      self.limit = 0

class SavingsAccount(Account):
   def __init__(self, aStartingAmount):
      Account.__init__(self,aStartingAmount)
      self.limit = 100

withdraw()
msg
BalanceError
BalanceError

newacct = CheckingAccount(100)
try:
   newacct.withdraw(200)
except BalanceError,errormsg:
   print errormsg

Account
CheckingAccount
SavingsAccount
BalanceError
SavingsAccount

import Account
myaccount = Account.SavingsAccount(1000)
myaccount.balance()

import
SavingsAccount
from

from Account import SavingsAccount
myacct = SavingsAccount(1000)
myacct.withdraw(2000)

Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "Account.py", line 17, in withdraw
raise BalanceError,msg
BalanceError: Account is overdrawn by 1000

BalanceError
try

from Account import SavingsAccount
try:
   myacct = SavingsAccount(1000)
   myacct.withdraw(2000)
except BalanceError, errormsg:
   print errormsg

Traceback (most recent call last):
   File "accttest.py", line 6, in <module>
      except BalanceError, errormsg:
NameError: name 'BalanceError' is not defined

SavingsAccount
BalanceError
import

from Account import *
try:
   myacct = SavingsAccount(1000)
   myacct.withdraw(2000)
except BalanceError, errormsg:
   print errormsg

import

def sum(a,b,c):
   '''
   This is a contrived example to show
   off docstrings
   '''
   return(a+b+c)

__doc__

>>> print sum.__doc__

   This is a contrived example to show
   off docstrings

sum()
max()

>>> print max.__doc__
max(iterable[, key=func]) -> value
max(a, b, c, ...[, key=func]) -> value

With a single iterable argument, return its largest item.
With two or more arguments, return the largest argument.

help()
dir()
sum()
dir(sum)

>>> dir(sum)
['__call__', '__class__', '__delattr__', '__dict__', '__doc__', '__get__', '__getattribute__', '__hash__', '__init__', '__module__', '__name__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__str__', 'func_closure', 'func_code', 'func_defaults', 'func_dict', 'func_doc', 'func_globals', 'func_name']

help()
help(sum.__init__)

if (x < y and
   y > z and 
   a > y):
   ...

if (x < y and \
   y > z and \
   a > y):
   ...

Object Type	Description	Examples
int	A whole number with fixed precision of unlimited magnitude	19,72,-12
float	A floating point number with a fractional part of system-defined precision	3.14159,-50.309,100.2
complex	A number with real and imaginary parts	7+4.5j
boolean	A truth value	true,false
string	A sequence of Unicode characters	'mobile',"icon's"
byte	A sequence of 8-bit bytes	b'one',b"characters"
list	A sequence of objects, which can be of mixed types	[7,"lowest",False]
tuple	A sequence of objects, which can be of mixed types	(7,"lowest",False)
dictionary	A group of key/value pairs, which can be of mixed types	{"key1":17, "key2":True}
set	An unordered sequence of objects, which can be of mixed types, with no duplicates	{7,"lowest",False}
file	The representation of data kept in storage	myFile = open("README",'r')

Expression	Interpretation
`x + 15 * L[2]`	arithmetic expression
`a < b`	boolean expression
`x + 15 * L[2] < 100 and a < b`	compound boolean expression
`a < b < c`	combination of boolean expressions
`f(x,y)`	function call

Basic Python Elements (Python on Symbian)

From Symbian Developer Community

Contents

Introduction

Variables

Basic Types

Operators

Statements

Expressions and Assignments

Conditional Statements

Loops

While Loops

For Loops

Other Python Iterators

Functions

Writing User-Defined Functions

Parameters to Functions

Returning a Value

Scope Rules

lambda Functions

Classes and Objects

Defining Classes

Inheritance

Operator Overloading

Multiple Inheritance

Exception Handling

Exception Basics

Raising Exceptions

Exceptions and Propagating

Importing Modules

Miscellaneous Python Elements

Conclusion

Comments

Views

Navigation

Toolbox

In other languages

OUR SITES

DEVELOPER PROGRAMS

Source

Website bugs

Documentation

Forums

CONTACT

Follow us