Python Programming/Live print version

Environment Variables

>>> a,b = 0,1
>>> print(b)
1
>>> while b < 100:
...   a,b = b,(a+b)
...   print(b, end=" ")
... 
1 2 3 5 8 13 21 34 55 89 144

dir()
dir(object)
locals()
PATH %PATH%;c:\python26

$ sudo apt-get update  # This will update the software repository
$ sudo apt-get install python   # This one will actually install python

$ pacman -Sy python

$ python
Python 3.0b3 (r30b3:66303, Sep  8 2008, 14:01:02) [MSC v.1500 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

>>>
1+1
2
>>> 5
5
>>> print (5*7)
35
>>> "hello" * 4
'hellohellohellohello'
>>> "hello".__class__
<type 'str'>

if 1:
  print("True")
print("Done")

>>> if 1:
...   print("True")
... print("Done")
  File "<stdin>", line 3
    print("Done")
        ^
SyntaxError: invalid syntax

if 1:
  print("True")

print("Done")

>>> if 1:
...   print("True")
...
True
>>> print("Done")
Done
>>>

python -i hello.py

help()
modules
keywords
topics
help("object")
print("Hello, world!")

Hello, world!

lucky = 7
print (lucky)

changing = 3
print (changing)

changing = 9
print (changing)

different = 12
print (different)
print (changing)

changing = 15
print (changing)

red = 5
blue = 10
print (red, blue)

yellow = red
print (yellow, red, blue)

red = blue
print (yellow, red, blue)

>>> print ('I am a single quoted string')
I am a single quoted string
>>> print ("I am a double quoted string")
I am a double quoted string
>>> print ("""I am a triple quoted string""")
I am a triple quoted string

>>> print ("So I said, \"You don't know me! You'll never understand me!\"")
So I said, "You don't know me! You'll never understand me!"
>>> print ('So I said, "You don\'t know me! You\'ll never understand me!"')
So I said, "You don't know me! You'll never understand me!"
>>> print ("This will result in only three backslashes: \\ \\ \\")
This will result in only three backslashes: \ \ \
>>> print ("""The double quotation mark (") is used to indicate direct quotations.""")
The double quotation mark (") is used to indicate direct quotations.

>>> print("Hello, world!")
Hello, world!

>>> print ("Hello, " + "world!")
Hello, world!

>>> print ("bouncy, " * 10)
bouncy, bouncy, bouncy, bouncy, bouncy, bouncy, bouncy, bouncy, bouncy, bouncy,

>>> print (len("Hello, world!"))
13

question = "What did you have for lunch?"
print (question)

question = "What did you have for lunch?"
print (question)
answer = raw_input()

print ("You had " + answer + "! That sounds delicious!")

print ("Please give me a number: ",)
number = input()

plusTen = number + 10
print ("If we add 10 to your number, we get " + plusTen)

Traceback (most recent call last):
  File "test.py", line 7, in <module>
    print "If we add 10 to your number, we get " + plusTen
TypeError: cannot concatenate 'str' and 'int' objects

print ("Please give me a number:",)
response = input()

number = int(response) 
plusTen = number + 10

print ("If we add 10 to your number, we get " + str(plusTen))

print ("If we add 10 to your number, we get ", plusTen)

print ("If we add 10 to your number, we get %s" % plusTen)

mass_kg = int(raw_input("What is your mass in kilograms?" ))
mass_stone = mass_kg * 2.2 / 14
print("You weigh %d stone." % mass_stone)

mass_stone = mass_kg * 2.2 / 14

from math import sqrt

 >>> print(0.6/0.2)
 3.0
 >>> print(0.6//0.2)
 2.0

What is your mass in kilograms? 65
You weigh 10.2142857143 stone.

>>> print (round(3.14159265, 2))
3.14

print ("You weigh %f stone." % round(mass_stone, 2))

twoSigFigs = round(mass_stone, 2)
numToString = str(twoSigFigs)
print ("You weigh " + numToString + " stone.")

spam = ["bacon", "eggs", 42]

>>> spam
['bacon', 'eggs', 42]
>>> spam[0]
'bacon'
>>> spam[1]
'eggs'
>>> spam[2]
42

>>> spam[-1]
42
>>> spam[-2]
'eggs'
>>> spam[-3]
'bacon'

>>> len(spam)
3

>>> spam = ["bacon", "eggs", 42]
>>> spam
['bacon', 'eggs', 42]
>>> spam[1]
'eggs'
>>> spam[1] = "ketchup"
>>> spam
['bacon', 'ketchup', 42]

>>> spam.append(10)
>>> spam
['bacon', 'eggs', 42, 10]

>>> spam.insert(1, 'and')
>>> spam
['bacon', 'and', 'eggs', 42, 10]

>>> spam
['bacon', 'and', 'eggs', 42, 10]
>>> del spam[1]
>>> spam
['bacon', 'eggs', 42, 10]
>>> spam[0]
'bacon'
>>> spam[1]
'eggs'
>>> spam[2]
42
>>> spam[3]
10

unchanging = "rocks", 0, "the universe"

foo, bar = "rocks", 0, "the universe" # An error: 2 elements on left, 3 on right
foo, bar = "rocks", (0, "the universe")

>>> var = "me", "you", "us", "them"
>>> var = ("me", "you", "us", "them")

>>> print var 
('me', 'you', 'us', 'them')

>>> var = ("me", "you", ("us", "them"))
>>> print(var)
('me', 'you', ('us', 'them')) # A tuple of 3 elements, the last of which is itself a tuple.

>>> definitions = {"guava": "a tropical fruit", "python": "a programming language", "the answer": 42}
>>> definitions
{'python': 'a programming language', 'the answer': 42, 'guava': 'a tropical fruit'}
>>> definitions["the answer"]
42
>>> definitions["guava"]
'a tropical fruit'
>>> len(definitions)    
3

>>> definitions["new key"] = "new value"
>>> definitions
{'python': 'a programming language', 'the answer': 42, 'guava': 'a tropical fruit', 'new key': 'new value'}

>>> mind = set([42, 'a string', (23, 4)])
>>> mind
set([(23, 4), 42, 'a string'])

>>> mind = set([42, 'a string', 40, 41])
>>> mind
set([40, 41, 42, 'a string'])
>>> mind = set([42, 'a string', 40, 0])
>>> mind
set([40, 0, 42, 'a string'])
>>> mind.add('hello')
>>> mind
set([40, 0, 42, 'a string', 'hello'])

>>> mind.add('duplicate value')
>>> mind.add('duplicate value')
>>> mind
set([0, 'a string', 40, 42, 'hello', 'duplicate value'])

>>> frozen=frozenset(['life','universe','everything'])
>>> frozen
frozenset({'universe', 'life', 'everything'})

a = 6
b = 7
c = 42
print (1, a == 6)
print (2, a == 7)
print (3, a == 6 and b == 7)
print (4, a == 7 and b == 7)
print (5, not a == 7 and b == 7)
print (6, a == 7 or b == 7)
print (7, a == 7 or b == 6)
print (8, not (a == 7 and b == 6))
print (9, not a == 7 and b == 6)

1 True
2 False
3 True
4 False
5 True
6 True
7 False
8 True
9 False

print
print
print (1, a == 6)
print (2, a == 7)

print (3, a == 6 and b == 7)
and
print (4, a == 7 and b == 7)
and
and
print (5, not a == 7 and b == 7)
not
not
print (5, a != 7 and b == 7)
print (6, a == 7 or b == 7)
print (7, a == 7 or b == 6)
or
or
or
print (8, not (a == 7 and b == 6))
print (9, not a == 7 and b == 6)
not
a == 7
list = ["Life","The Universe","Everything","Jack","Jill","Life","Jill"]

# Make a copy of the list.
copy = list[:]
# Sort the copy
copy.sort()
prev = copy[0]
del copy[0]

count = 0

# Go through the list searching for a match
while count < len(copy) and copy[count] != prev:
    prev = copy[count]
    count = count + 1

# If a match was not found then count can't be < len
# since the while loop continues while count is < len
# and no match is found
if count < len(copy):
    print ("First Match:",prev)

First Match: Jill

while count < len(copy) and copy[count]
count
copy
and
if
while
and
and
count >= len(copy)
count < len(copy)
and
count < len(copy)
count
copy
count < len(copy) and copy[count] != prev
copy[count] != prev and count < len(copy)
## This programs asks a user for a name and a password.
# It then checks them to make sure that the user is allowed in.
# Note that this is a simple and insecure example,
# real password code should never be implemented this way.

name = raw_input("What is your name? ")
password = raw_input("What is the password? ")
if name == "Josh" and password == "Friday":
    print ("Welcome Josh")
elif name == "Fred" and password == "Rock":
    print ("Welcome Fred")
else:
    print ("I don't know you.")

What is your name? Josh
What is the password? Friday
Welcome Josh

What is your name? Bill
What is the password? Saturday
I don't know you.

n = raw_input("Integer? ")#Pick an integer.
n = int(n)#Defines n as the integer you chose. (Alternatively, you can define n yourself)
if n < 0:
    print ("The absolute value of",n,"is",-n)
else:
    print ("The absolute value of",n,"is",n)

Integer? -34
The absolute value of -34 is 34

Integer? 1
The absolute value of 1 is 1

n = raw_input("Integer? ")
if n < 0:
n
print "The absolute value of",n,"is",-n
print "The absolute value of",n,"is",n
n < 0
if
if
else
<
<=
>
>=
==
!=
if
elif
if
elif
elif
a = 0
while a < 10:
    a = a + 1
    if a > 5:
        print (a,">",5)
    elif a <= 7:
        print (a,"<=",7)
    else:
        print ("Neither test was true")

1 <= 7
2 <= 7
3 <= 7
4 <= 7
5 <= 7
6 > 5
7 > 5
8 > 5
9 > 5
10 > 5

elif a <= 7
if
elif
High_low.py
#Plays the guessing game higher or lower 
# (originally written by Josh Cogliati, improved by Quique)

#This should actually be something that is semi random like the
# last digits of the time or something else, but that will have to
# wait till a later chapter.  (Extra Credit, modify it to be random
# after the Modules chapter)
number = 78
guess = 0

while guess != number : 
    guess = raw_input("Guess an integer: ")
    guess = int(guess)
    if guess > number :
        print ("Too high")

    elif guess < number :
        print ("Too low")
    else:
        print ("Just right" )

Guess an integer:100
Too high
Guess an integer:50
Too low
Guess an integer:75
Too low
Guess an integer:87
Too high
Guess an integer:81
Too high
Guess an integer:78
Just right

even.py
#Asks for a number.
#Prints if it is even or odd

number = raw_input("Tell me a number: ")
number = float(number)
if number % 2 == 0:
    print (number,"is even.")
elif number % 2 == 1:
    print (number,"is odd.")
else:
    print (number,"is very strange.")

Tell me a number: 3
3 is odd.

Tell me a number: 2
2 is even.

Tell me a number: 3.14159
3.14159 is very strange.

average1.py
#keeps asking for numbers until 0 is entered.
#Prints the average value.

count = 0
sum = 0.0
number = 1.0  # set this to something that will not exit
#               the while loop immediately.

print ("Enter 0 to exit the loop")

while number != 0:
    number = raw_input("Enter a number: ")
    number = float(number)
    if number != 0:
       count = count + 1
       sum = sum + number

print "The average was:",sum/count

Enter 0 to exit the loop
Enter a number:3
Enter a number:5
Enter a number:0
The average was: 4.0

Enter 0 to exit the loop
Enter a number:1
Enter a number:4
Enter a number:3
Enter a number:0
The average was: 2.66666666667

average2.py
#keeps asking for numbers until count have been entered.
#Prints the average value.

sum = 0.0

print ("This program will take several numbers, then average them.")
count = raw_input("How many numbers would you like to sum:")
count = int(count)
current_count = 0

while current_count < count:
    current_count = current_count + 1
    print ("Number",current_count)
    number = input("Enter a number: ")
    sum = sum + number

print "The average was:",sum/count

This program will take several numbers, then average them.
How many numbers would you like to sum:2
Number 1
Enter a number:3
Number 2
Enter a number:5
The average was: 4.0

This program will take several numbers, then average them.
How many numbers would you like to sum:3
Number 1
Enter a number:1
Number 2
Enter a number:4
Number 3
Enter a number:3
The average was: 2.66666666667

x = 1

def hello():
  print ("Hello")

def bye():
  print ("Bye")

def hola():
  print ("Hola is Spanish for Hello")

def adios():
  print ("Adios is Spanish for Bye")

# Notice that our switch statement is a regular variable, only that we added the function's name inside
# and there are no quotes
menu = [hello,bye,hola,adios]

# To call our switch statement, we simply make reference to the array with a pair of parentheses
# at the end to call the function
menu[3]()   # calls the adios function since is number 3 in our array.

menu[0]()   # Calls the hello function being our first element in our array.

menu[x]()   # Calls the bye function as is the second element on the array x = 1

if x==0:
    hello()
elif x==1:
    bye()
elif x==2:
    hola()
else:
    adios()

a = 0
while a < 10 :
    a += 1
    print (a)

1
2
3
4
5
6
7
8
9
10

a = 0
while a < 10:
a < 10
while
a = 1
s = 0
print ('Enter Numbers to add to the sum.')
print ('Enter 0 to quit.')
while a != 0:
    print ('Current Sum: ', s)
    a = raw_input('Number? ')
    a = float(a)
    s += a
print ('Total Sum = ',s)

Enter Numbers to add to the sum.
Enter 0 to quit.
Current Sum: 0
Number? 200
Current Sum: 200
Number? -15.25
Current Sum: 184.75
Number? -151.85
Current Sum: 32.9
Number? 10.00
Current Sum: 42.9
Number? 0
Total Sum = 42.9

print 'Total Sum =',s
while
 !=
while a != 0 :
while 1 == 1:
    print ("Help, I'm stuck in a loop.")

Help, I'm stuck in a loop.
#This program calculates the Fibonacci sequence
a = 0
b = 1
count = 0
max_count = 20
while count < max_count:
    count = count + 1
    #we need to keep track of a since we change it
    old_a = a
    old_b = b
    a = old_b
    b = old_a + old_b
    #Notice that the , at the end of a print statement keeps it
    # from switching to a new line
    print (old_a,)
print()

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181

# Waits until a password has been entered.  Use control-C to break out with out
# the password

# Note that this must not be the password so that the 
# while loop runs at least once.
password = "foobar"

#note that != means not equal
while password != "unicorn":
    password = raw_input("Password: ")
print ("Welcome in")

Password:auo
Password:y22
Password:password
Password:open sesame
Password:unicorn
Welcome in

onetoten = range(1,11)
for count in onetoten:
    print (count)

1
2
3
4
5
6
7
8
9
10

range
range
range(start,finish)
start
finish
for count in range(1,11):
    print (count)

range
>>> range(1,10)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(-32, -20)
[-32, -31, -30, -29, -28, -27, -26, -25, -24, -23, -22, -21]
>>> range(5,21)
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
>>> range(21,5)
[]

range()
for
for a in range(10):
    print a,

for a in range(0, 10):
    print a,

0 1 2 3 4 5 6 7 8 9

for
for count in onetoten:
for
for
for variable in list:
list
for
variable
variable
demolist = ['life',42, 'the universe', 6,'and',7,'everything']
for item in demolist:
    print ("The Current item is: %s" % item)

The Current item is: life
The Current item is: 42
The Current item is: the universe
The Current item is: 6
The Current item is: and
The Current item is: 7
The Current item is: everything

print
for
list = [2,4,6,8]
sum = 0
for num in list:
    sum = sum + num
print "The sum is: %d" % sum

The sum is:  20

list = [4, 5, 7, 8, 9, 1,0,7,10]
list.sort()
prev = list[0]
del list[0]
for item in list:
    if prev == item:
        print ("Duplicate of ",prev," Found")
    prev = item

Duplicate of  7  Found

l = [4, 5, 7, 8, 9, 1,0,7,10]
print ("l = [4, 5, 7, 8, 9, 1,0,7,10]","\tl:",l)
l.sort()
print ("l.sort()","\tl:",l)
prev = l[0]
print ("prev = l[0]","\tprev:",prev)
del l[0]
print ("del l[0]","\tl:",l)
for item in l:
    if prev == item:
        print ("Duplicate of ",prev," Found")
    print ("if prev == item:","\tprev:",prev,"\titem:",item)
    prev = item
    print ("prev = item","\t\tprev:",prev,"\titem:",item)

l = [4, 5, 7, 8, 9, 1,0,7,10]   l: [4, 5, 7, 8, 9, 1, 0, 7, 10]
l.sort()        l: [0, 1, 4, 5, 7, 7, 8, 9, 10]
prev = l[0]     prev: 0
del l[0]        l: [1, 4, 5, 7, 7, 8, 9, 10]
if prev == item:        prev: 0         item: 1
prev = item             prev: 1         item: 1
if prev == item:        prev: 1         item: 4
prev = item             prev: 4         item: 4
if prev == item:        prev: 4         item: 5
prev = item             prev: 5         item: 5
if prev == item:        prev: 5         item: 7
prev = item             prev: 7         item: 7
Duplicate of  7  Found
if prev == item:        prev: 7         item: 7
prev = item             prev: 7         item: 7
if prev == item:        prev: 7         item: 8
prev = item             prev: 8         item: 8
if prev == item:        prev: 8         item: 9
prev = item             prev: 9         item: 9
if prev == item:        prev: 9         item: 10
prev = item             prev: 10        item: 10

print
a = 1
b = 1
for c in range(1,10):
    print (a)
    n = a + b
    a = b
    b = n
print ("")

1
1
2
3
5
8
13
21
34

for
while
for
#!/usr/bin/env python
# commentexample.py

# Display the knights that come after Scene 24
print("The Knights Who Say Ni!")
# print("I will never see the light of day!")

x = x + 1 # Increment x

x = x + 1 # Compensate for border

#!/usr/bin/env python
# docstringexample.py

"""Example of using documentation strings."""

class Knight:
    """
    An example class.

    Call spam to get bacon.
    """

    def spam(eggs="bacon"):
        """Prints the argument given."""
        print(eggs)

import time

import time

def main():
    #define the variable 'current_time' as a tuple of time.localtime()
    current_time = time.localtime() 
    print(current_time) # print the tuple
    # if the year is 2009 (first value in the current_time tuple)
    if current_time[0] == 2009: 
        print('The year is 2009') # print the year

if __name__ == '__main__': # if the function is the main function ...
    main() # ...call it

import time as t # import the time module and call it 't'

def main():
    current_time = t.localtime() 
    print(current_time)
    if current_time[0] == 2009: 
        print('The year is 2009')

if __name__ == '__main__': 
    main()

from time import localtime #1

def main():
    current_time = localtime() #2
    print(current_time)
    if current_time[0] == 2009: 
        print 'The year is 2009'

if __name__ == '__main__': 
    main()

from time import localtime as lt 

def main():
    current_time = lt()
    print(current_time)
    if current_time[0] == 2009: 
        print('The year is 2009')

if __name__ == '__main__': 
    main()

inputFileText = open("testit.txt", "r").read()
print inputFileText

inputFileText = open("testit.txt", "r").read(123)
print inputFileText

>>> f=open("/proc/cpuinfo","r")
>>> f.tell()
0L
>>> f.read(10)
'processor\t'
>>> f.read(10)
': 0\nvendor'
>>> f.tell()
20L
>>> f.seek(10)
>>> f.tell()
10L
>>> f.read(10)
': 0\nvendor'
>>> f.close()
>>> f
<closed file '/proc/cpuinfo', mode 'r' at 0xb7d79770>

for line in open("testit.txt", "r").readlines():
    print line

outputFileText = "Here's some text to save in a file"
open("testit.txt", "w").write(outputFileText)

outputFileText = "Here's some text to add to the existing file."
open("testit.txt", "a").write(outputFileText)

import os
os.path.exists('<path string>')

import os
os.path.exists('C:\\windows\\example\\path')

import os
os.path.exists(r'C:\windows\example\path')

>>> import os
>>> os.path.isfile("/")
False
>>> os.path.isfile("/proc/cpuinfo")
True
>>> os.path.isdir("/")
True
>>> os.path.isdir("/proc/cpuinfo")
False
>>> os.path.ismount("/")
True
>>> os.path.islink("/")
False
>>> os.path.islink("/vmlinuz")
True
>>> os.path.realpath("/vmlinuz")
'/boot/vmlinuz-2.6.24-21-generic'

import shutil
shutil.move("originallocation.txt","newlocation.txt")
shutil.copy("original.txt","copy.txt")

import shutil
shutil.copytree("dir1","dir2")
shutil.rmtree("dir1")

import os
os.remove("file.txt")

try
import urllib2
url = 'http://www.goat.com'
try:
    req = urllib2.Request(url)
    response = urllib2.urlopen(req)
    the_page = response.read()
    print the_page
except:
    print "We have a problem."

try:
    age = int(raw_input("Enter your age: "))
    print "You must be {0} years old.".format(age)
except ValueError:
    print "Your age must be numeric."

Enter your age: 5
You must be 5 years old.

ValueError
int()
except
Enter your age: five
Your age must be a number.

try
while
valid = False
while valid == False:
    try:
        age = int(raw_input("Enter your age: "))
        valid = True     # This statement will only execute if the above statement executes without error.
        print "You must be {0} years old.".format(age)
    except ValueError:
        print "Your age must be numeric."

Enter your age: five
Your age must be numeric.
Enter your age: abc10
Your age must be numeric.
Enter your age: 15
You must be 15 years old.

class <<name>>:
    def <<method>> (self [, <<optional arguments>>]):
        <<Function codes>>

class car:
    def brake(self):
        print "Brakes"

    def accelerate(self):
        print "Accelerating"

car1 = car() # car 1 is my instance for the first car
car2 = car()

# And use the object methods like
car1.brake()

car1.color = "Red"

print car1.color

class car:
    ... previous methods ...

    def set_owner(self,Owners_Name): # This will set the owner property
        self._owner = Owners_Name

    def get_owner(self): # This will retrieve the owner property
        return self._owner

class car:
    ... previous methods ...
    owner = property(get_owner, set_owner)

class new_car(car):
   def start_car(self):
      self.on = true

class new_car(car):
    def __init__(self,brand, model, year):
        # Sets all the properties
        self.brand = brand
        self.model = model
        self.year = year

    def start_car(self):
        """ Start the cars engine """
        print "vroem vroem"

if __name__ == "__main__":
    # Creates two instances of new_car, each with unique properties
    car1 = new_car("Ford","F-150",2001)
    car2 = new_car("Toyota","Corolla",2007)

    car1.start_car()
    car2.start_car()

# Ask user for his name and stores
name = raw_input("Please enter your name:")
# Display the name entered by the user.
print name

# Retrieve user age
age = int(raw_input("Please enter your age:"))
print age

class ainput:   # We can't use input as it is a existent function name, so we use AInput for Advance Input
   ''' This class will create a object with a simpler coding interface to retrieve console input'''
   def __init__(self,msg=""):
      ''' This will create a instance of ainput object'''
      self.data = ""   # Initialize a empty data variable
      if not msg == "":
         self.ask(msg)

   def ask(self,msg, req=0):
      ''' This will display the prompt and retrieve the user input.'''
      if req == 0:
         self.data = raw_input(msg)   # Save the user input to a local object variable
      else:
         self.data = raw_input(msg + " (Require)")

      # Verify that the information was entered and its not empty. This will accept a space character. Better Validation needed
      if req == 1 and self.data == "":
         self.ask(msg,req)

   def getString(self):
      ''' Returns the user input as String'''
      return self.data

   def getInteger(self):
      ''' Returns the user input as a Integer'''
      return int(self.data)

   def getNumber(self):
      ''' Returns the user input as a Float number'''
      return float(self.data)

# import is not imported
name = ainput("Please enter your first name:").getString()
age = ainput("Now enter your age:").getInteger()
print name, age

class ainput:   # We can't use input as it is a existent function name, so we use AInput for Advance Input
   ''' This class will create a object with a simpler coding interface to retrieve console input'''
   def __init__(self,msg=""):
      ''' This will create a instance of ainput object'''
      self.data = ""   # Initialize a empty data variable
      if not msg == "":
         self.ask(msg)

   def ask(self,msg, req=0):
      ''' This will display the prompt and retrieve the user input.'''
      if req == 0:
         self.data = raw_input(msg)   # Save the user input to a local object variable
      else:
         self.data = raw_input(msg + " (Require)")

      # Verify that the information was entered and its not empty. This will accept a space character. Better Validation needed
      if req == 1 and self.data == "":
         self.ask(msg,req)

   def getString(self):
      ''' Returns the user input as String'''
      return self.data

   def getInteger(self):
      ''' Returns the user input as a Integer'''
      return int(self.data)

   def getNumber(self):
      ''' Returns the user input as a Float number'''
      return float(self.data)

def main():
	# import is not imported
	name = ainput("Please enter your first name:").getString()
	age = ainput("Now enter your age:").getInteger()
	print name, age

if __name__ == '__main__':
	main()

 import Tkinter

 # Define input retrieve function for application input
 def retrieve_text():
   print app_entry.get()

 if __name__ == "__main__":

   # Create Window Object or Window Form
   app_win = Tkinter.Tk()

   # Create label object
   app_label = Tkinter.Label(app_win,text="Hello World")
   app_label.pack()

   # Create User Input Object
   app_entry = Tkinter.Entry(app_win)
   app_entry.pack()

   # Create Button Object
   app_button = Tkinter.Button(app_win,text="Print Value",command=retrieve_text)
   app_button.pack()

   # Initialize Graphical Loop
   app_win.mainloop()

# Import Tkinter Library
import Tkinter

# Define our Textbox Object
class textbox(Tkinter.Frame):

    # Object Initialize
    def __init__(self,parent, msg):
        # Initialize the Frame properties by explicit calling its Init method
        Tkinter.Frame.__init__(self,parent)

        # Create the Textbox Label on the Left side
        self.g_label = Tkinter.Label(self,text=msg)
        self.g_label.pack(side=Tkinter.LEFT,expand=False)

        # Create the Textbox Entry on the Right side
        self.g_entry = Tkinter.Entry(self)
        self.g_entry.pack(side=Tkinter.LEFT, fill=Tkinter.X, expand=True)

        # Proceed to pack the frame
        self.pack(fill=Tkinter.X, anchor=Tkinter.NW, expand=True)

    def text(self):
        # Textbox text value retrieval
        return self.gui['entry'].get()

name = textbox(win,"Name:")

1  import MySQLdb
2  db = MySQLdb.connect("host machine", "dbuser", "password", "dbname")
3  cursor = db.cursor()
4  query = """SELECT * FROM sampletable"""
5  lines = cursor.execute(query)
6  data = cursor.fetchall()
7  db.close()

MySQLdb
query
lines
sampletable
data
sampletable
row = cursor.fetchone()
  #first 5 lines are the same as above
  while True:
    row = cursor.fetchone()
    if row == None: break
    #do something with this row of data
  db.close()

fetchone()
import MySQLdb;
db = MySQLdb.connect(read_default_file="~/.my.cnf")
...

import urllib
pageText = urllib.urlopen("http://www.spam.org/eggs.html").read()
print pageText

import urllib
params = urllib.urlencode({"plato":1, "socrates":10, "sophokles":4, "arkhimedes":11})

# Using GET method
pageText = urllib.urlopen("http://international-philosophy.com/greece?%s" % params).read()
print pageText

# Using POST method
pageText = urllib.urlopen("http://international-philosophy.com/greece", params).read()
print pageText

import urllib
urllib.urlretrieve("http://upload.wikimedia.org/wikibooks/en/9/91/Python_Programming.pdf", "pythonbook.pdf")

>>> plain_text = "This isn't suitable for putting in a URL"
>>> print urllib.quote(plain_text)
This%20isn%27t%20suitable%20for%20putting%20in%20a%20URL
>>> print urllib.quote_plus(plain_text)
This+isn%27t+suitable+for+putting+in+a+URL

print "Spam" + " eggs" + " and" + " spam"               # DON'T DO THIS
print " ".join(["Spam","eggs","and","spam"])            # Much faster/more
                                                        # common Python idiom
print "%s %s %s %s" % ("Spam", "eggs", "and", "spam")   # Also a pythonic way of
                                                        # doing it - very fast

import cPickle # You may want to import it as P for convenience.

directory = os.listdir(os.getcwd())       # Gets a list of files in the
                                          # directory the program runs from
filesInDir = [item for item in directory] # Normal For Loop rules apply, you
                                          # can add "if condition" to make a
                                          # more narrow search.

[a - b for (a,b) in zip((1,2,3), (1,2,3))]  # will return [0, 0, 0]

list1 = [{'a': 1, 'b': 2}, {'c': 3, 'd': 4}, {'e': 5, 'f': 6}]
list2 = [{'e': 5, 'f': 6}, {'g': 7, 'h': 8}, {'i': 9, 'j': 10}]

common = []
for entry in list1:
    if entry in list2:
        common.append(entry)

set1 = set([tuple(entry.items()) for entry in list1])
set2 = set([tuple(entry.items()) for entry in list2])
common = set1.intersection(set2)
common = [dict(entry) for entry in common]

def flatten(seq, a = list()):
    """flatten(seq, a = list()) -> list

    Return a flat version of the iterator `seq` appended to `a`
    """
    try:                          # Can `seq` be iterated over?
        for item in seq:          # If so then iterate over `seq`
            flatten(item, a)      # and make the same check on each item.
    except TypeError:             # If seq isn't iterable
        a.append(seq)             # append it to the new list.
    return a

print 'Hit Enter to exit'
raw_input()

pythonprogrammer@wikibook:~$ python -tt myscript.py

'bob'.upper

'bob'.upper()

dir()
Python 2.3.4 (#53, Oct 18 2004, 20:35:07) [MSC v.1200 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> dir()
['__builtins__', '__doc__', '__name__']

type()
>>> type(__builtins__)
<type 'module'>

dir()
>>> dir(__builtins__)
['ArithmeticError', ... 'copyright', 'credits', ... 'help', ... 'license', ... 'zip']
>>>

>>> dir()
['__builtins__', '__doc__', '__name__']
>>> name = "Bob"
>>> import math
>>> dir()
['__builtins__', '__doc__', '__name__', 'math', 'name']

>>> math
<module 'math' (built-in)>

>>> dir(math)
['__doc__', '__name__', 'acos', 'asin', 'atan', 'atan2', 'ceil', 'cos', 'cosh', 'degrees', 'e',
'exp', 'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log', 'log10', 'modf', 'pi', 'pow',
'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh']
>>>

__name__
math
>>> print __name__
__main__
>>> print math.__name__
math
>>> print math.__doc__
This module is always available.  It provides access to the
mathematical functions defined by the C standard.
>>> math.pi
3.1415926535897931

'foo' works, and
"moo" works as well,
     but
'bar" does not work, and
"baz' does not work either.
"quux'' is right out.

'''foo''' works, and
"""moo""" works as well,
     but
'"'bar'"' does not work, and
"""baz''' does not work either.
'"'quux"'" is right out.

(10, 'Mary had a little lamb')

10, 'whose fleece was as white as snow'

('this is a stupid tuple',)

['abc', 1,2,3]

{ 'hello': 'world', 'weight': 'African or European?' }

((((((((('bob',),['Mary', 'had', 'a', 'little', 'lamb']), { 'hello' : 'world' } ),),),),),),)

//
>>> x = 5
>>> type(x)
<type 'int'>
>>> x = 187687654564658970978909869576453
>>> type(x)
<type 'long'>
>>> x = 1.34763
>>> type(x)
<type 'float'>
>>> x = 5 + 2j
>>> type(x)
<type 'complex'>

5/2
5/2.
5./2
__future__ import
>>> 5/2
2
>>>5/2.
2.5
>>>5./2
2.5
>>> from __future__ import division
>>> 5/2
2.5
>>> 5//2
2

>>> a = 'hello'; b = 'hello' # Assign 'hello' to a and b.
>>> print a == b             # True
True
>>> print a == 'hello'       #
True
>>> print a == "hello"       # (choice of delimiter is unimportant)
True
>>> print a == 'hello '      # (extra space)
False
>>> print a == 'Hello'       # (wrong case)
False

>>> c = 'a'
>>> c + 'b'
'ab'
>>> c * 5
'aaaaa'

>>> x = 'hello'
>>> y = 'll'
>>> x in y
False
>>> y in x
True

>>> s = "Xanadu"
>>> s[1]
'a'

>>> s[-4]
'n'

>>> s[1:4]
'ana'

>>> print s
>>> s[0] = 'J'
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: object does not support item assignment
>>> s[1:3] = "up"
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: object does not support slice assignment
>>> print s

Xanadu
Xanadu

>>> s[2:]
'nadu'
>>> s[:3]
'Xan'
>>> s[:]
'Xanadu'

>>> print s[-2:]
'du'

Element:     1     2     3     4
Index:    0     1     2     3     4
         -4    -3    -2    -1

>>> '2YK'.istitle()
False
>>> '2Yk'.istitle()
True
>>> '2Y K'.istitle()
True

>>> s = 'Hello, wOrLD'
>>> s
'Hello, wOrLD'
>>> s.title()
'Hello, World'
>>> s.swapcase()
'hELLO, WoRld'
>>> s.upper()
'HELLO, WORLD'
>>> s.lower()
'hello, world'
>>> s.capitalize()
'Hello, world'

>>> s = 'Hello, world'
>>> s.count('l') # print the number of 'l's in 'Hello, World' (3)
3

>>> s = '\t Hello, world\n\t '
>>> print s
         Hello, world

>>> print s.strip()
Hello, world
>>> print s.lstrip()
Hello, world
        # ends here
>>> print s.rstrip()
         Hello, world

import string
s = 'www.wikibooks.org'
print s
print s.strip('w')                 # Removes all w's from outside
print s.strip(string.lowercase)    # Removes all lowercase letters from outside
print s.strip(string.printable)    # Removes all printable characters

www.wikibooks.org
.wikibooks.org
.wikibooks.

>>> s = 'foo'
>>> s
'foo'
>>> s.ljust(7)
'foo    '
>>> s.rjust(7)
'    foo'
>>> s.center(7)
'  foo  '

>>> seq = ['1', '2', '3', '4', '5']
>>> ' '.join(seq)
'1 2 3 4 5'
>>> '+'.join(seq)
'1+2+3+4+5'

>>> seq = [1,2,3,4,5]
>>> ' '.join(map(str, seq))
'1 2 3 4 5'

>>> s = 'Hello, world'
>>> s.find('l')
2
>>> s[s.index('l'):]
'llo, world'
>>> s.rfind('l')
10
>>> s[:s.rindex('l')]
'Hello, wor'
>>> s[s.index('l'):s.rindex('l')]
'llo, wor'

>>> 'Hello, world'.replace('o', 'X')
'HellX, wXrld'

string = 'Hello, world'
newString = string.replace('o', 'X')
print string
print newString

'Hello, world'
'HellX, wXrld'

s = 'abcdefg\tabc\ta'
print s
print len(s)
t = s.expandtabs()
print t
print len(t)

abcdefg abc     a
13
abcdefg abc     a
17

v = s.expandtabs(4)
print v
print len(v)

abcdefg abc a
13

>>> s = 'Hello, world'
>>> s.split()
['Hello,', 'world']
>>> s.split('l')
['He', '', 'o, wor', 'd']

>>> s = """
... One line
... Two lines
... Red lines
... Blue lines
... Green lines
... """
>>> s.split('\n')
['', 'One line', 'Two lines', 'Red lines', 'Blue lines', 'Green lines', '']
>>> s.splitlines()
['', 'One line', 'Two lines', 'Red lines', 'Blue lines', 'Green lines']

[ 1,2,3,"This is a list",'c',Donkey("kong") ]

listOfWords = ["this","is","a","list","of","words"]

>>> listOfWords = ["this","is","a","list","of","words"]
>>> items = [ word[0] for word in listOfWords ]
>>> print items
['t', 'i', 'a', 'l', 'o', 'w']

>>> item = [x+y for x in 'flower' for y in 'pot']
>>> print item
['fp', 'fo', 'ft', 'lp', 'lo', 'lt', 'op', 'oo', 'ot', 'wp', 'wo', 'wt', 'ep', 'eo', 'et', 'rp', 'ro', 'rt']

>>> print x, y
r t

>>> zeros=[0]*5
>>> print zeros
[0, 0, 0, 0, 0]

>>> foos=['foo']*8
>>> print foos
['foo', 'foo', 'foo', 'foo', 'foo', 'foo', 'foo', 'foo']

listoflists=[ [0]*4 ] *5

>>> listoflists=[ [0]*4 ] *5
>>> print listoflists
[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
>>> listoflists[0][2]=1
>>> print listoflists
[[0, 0, 1, 0], [0, 0, 1, 0], [0, 0, 1, 0], [0, 0, 1, 0], [0, 0, 1, 0]]

>>> innerlist=[0]*4
>>> listoflists=[innerlist]*5
>>> print listoflists
[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
>>> innerlist[2]=1
>>> print listoflists
[[0, 0, 1, 0], [0, 0, 1, 0], [0, 0, 1, 0], [0, 0, 1, 0], [0, 0, 1, 0]]

>>> listoflists=[[0]*4 for i in range(5)]
>>> print listoflists
[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
>>> listoflists[0][2]=1
>>> print listoflists
[[0, 0, 1, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]

>>> len([1,2,3])
3
>>> a = [1,2,3,4]
>>> len( a )
4

>>> [1,2] + [3,4]
[1, 2, 3, 4]

>>> a = [1,2,3]
>>> b = [4,5,6]
>>> a.extend(b)
>>> print a
[1, 2, 3, 4, 5, 6]

>>> p=[1,2]
>>> p.append([3,4])
>>> p
[1, 2, [3, 4]]
>>> # or
>>> print p
[1, 2, [3, 4]]

>>> list = [2, 4, "usurp", 9.0,"n"]
>>> list[2]
'usurp'
>>> list[3:]
[9.0, 'n']

>>> list[1] = 17
>>> list
[2, 17, 'usurp', 9.0,'n']

>>> list[1:4] = ["opportunistic", "elk"]
>>> list
[2, 'opportunistic', 'elk', 'n']

>>> list[:0] = [3.14,2.71]
>>> list
[3.14, 2.71, 2, 'opportunistic', 'elk', 'n']

>>> list[:] = ['new', 'list', 'contents']
>>> list
['new', 'list', 'contents']

>>> list[:2] = ('element',('t',),[])
>>> list
['element', ('t',), [], 'contents']

>>> original = [1, 'element', []]
>>> list_copy = original[:]
>>> list_copy
[1, 'element', []]
>>> list_copy.append('new element')
>>> list_copy
[1, 'element', [], 'new element']
>>> original
[1, 'element', []]

>>> list_copy[2].append('something')
>>> original
[1, 'element', ['something']]

>>> [1,2] == [1,2]
True
>>> [1,2] == [3,4]
False

>>> list = [2, 3, 1, 'a', 'b']
>>> list.sort()
>>> list
[1, 2, 3, 'a', 'b']

>>> list = [1, 2, 3]
>>> list.append(4)
>>> list
[1, 2, 3, 4]

>>> list = [1, 2, 3, 4]
>>> a = list.pop(0)
>>> list
[2, 3, 4]
>>> a
1
>>> b = list.pop()
>>>list
[2, 3]
>>> b
4

>>> l = [1, 'a', [6, 3.14]]
>>> t = (1, 'a', [6, 3.14])
>>> t
(1, 'a', [6, 3.1400000000000001])
>>> tuple(l)
(1, 'a', [6, 3.1400000000000001])
>>> t == tuple(l)
True
>>> t == l
False

>>> t = ('A single item tuple',)
>>> t
('A single item tuple',)

>>> t = 'A', 'tuple', 'needs', 'no', 'parens'
>>> t
('A', 'tuple', 'needs', 'no', 'parens')

>>> article, noun, verb, adjective, direct_object = t
>>> noun
'tuple'

>>> a, b = 1, 2
>>> b
2

>>> a = (1, 2)
>>> b = (3, 4)
>>> a + b
(1, 2, 3, 4)
>>> a
(1, 2)
>>> b
(3, 4)
>>> print a.append(3)
Traceback (most recent call last):
File "<stdin>", line 1, in ?
AttributeError: 'tuple' object has no attribute 'append'
>>> a
(1, 2)
>>> a[0] = 0
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: object does not support item assignment
>>> a
(1, 2)

>>> a = [1, 2]
>>> b = [3, 4]
>>> a + b
[1, 2, 3, 4]
>>> a
[1, 2]
>>> b
[3, 4]
>>> a.append(3)
>>> a
[1, 2, 3]
>>> a[0] = 0
>>> a
[0, 2, 3]

>>> len( ( 1, 2, 3) )
3
>>> a = ( 1, 2, 3, 4 )
>>> len( a )
4

>>> l = [4, 5, 6]
>>> tuple(l)
(4, 5, 6)

>>> t = (4, 5, 6)
>>> list(t)
[4, 5, 6]

>>> d = {'a': 1, 'b': 2}
>>> tuple(d.items())
(('a', 1), ('b', 2))

def func(x,y):
    # code to compute a and b
    return (a,b)

(a,b) = func(1,2)

{}
>>> d = {'city':'Paris', 'age':38, (102,1650,1601):'A matrix coordinate'}
>>> seq = [('city','Paris'), ('age', 38), ((102,1650,1601),'A matrix coordinate')]
>>> d
{'city': 'Paris', 'age': 38, (102, 1650, 1601): 'A matrix coordinate'}
>>> dict(seq)
{'city': 'Paris', 'age': 38, (102, 1650, 1601): 'A matrix coordinate'}
>>> d == dict(seq)
True

>>> seq1 = ('a','b','c','d')
>>> seq2 = [1,2,3,4]
>>> d = dict(zip(seq1,seq2))
>>> d
{'a': 1, 'c': 3, 'b': 2, 'd': 4}

>>> d = {'a':1,'b':2, 'cat':'Fluffers'}
>>> d.keys()
['a', 'b', 'cat']
>>> d.values()
[1, 2, 'Fluffers']
>>> d['a']
1
>>> d['cat'] = 'Mr. Whiskers'
>>> d['cat']
'Mr. Whiskers'
>>> d.has_key('cat')
True
>>> d.has_key('dog')
False
>>> 'cat' in d
True

>>> d = {'apples': 1, 'oranges': 3, 'pears': 2}
>>> ud = {'pears': 4, 'grapes': 5, 'lemons': 6}
>>> d.update(ud)
>>> d
{'grapes': 5, 'pears': 4, 'lemons': 6, 'apples': 1, 'oranges': 3}
>>>

del dictionaryName[membername]

>>> set([0, 1, 2, 3])
set([0, 1, 2, 3])
>>> set("obtuse")
set(['b', 'e', 'o', 's', 'u', 't'])

>>> s = set([12, 26, 54])
>>> s.add(32)
>>> s
set([32, 26, 12, 54])

>>> s.update([26, 12, 9, 14])
>>> s
set([32, 9, 12, 14, 54, 26])

>>> s2 = s.copy()
>>> s2
set([32, 9, 12, 14, 54, 26])

>>> 32 in s
True
>>> 6 in s
False
>>> 6 not in s
True

>>> s.issubset(set([32, 8, 9, 12, 14, -4, 54, 26, 19]))
True
>>> s.issuperset(set([9, 12]))
True

>>> s.issuperset([32, 9])
True

>>> set([4, 5, 7]) <= set([4, 5, 7, 9])
True
>>> set([9, 12, 15]) >= set([9, 12])
True

>>> s = set([1,2,3,4,5,6])
>>> s.pop()
1
>>> s
set([2,3,4,5,6])

>>> s.remove(3)
>>> s
set([2,4,5,6])

>>> s.remove(9)
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
KeyError: 9

>>> s.clear()
>>> s
set([])

>>> s = set("blerg")
>>> for n in s:
...     print n,
...
r b e l g

>>> s1 = set([4, 6, 9])
>>> s2 = set([1, 6, 8])
>>> s1.union(s2)
set([1, 4, 6, 8, 9])
>>> s1 | s2
set([1, 4, 6, 8, 9])

>>> s1 = set([4, 6, 9])
>>> s2 = set([1, 6, 8])
>>> s1.intersection(s2)
set([6])
>>> s1 & s2
set([6])
>>> s1.intersection_update(s2)
>>> s1
set([6])

>>> s1 = set([4, 6, 9])
>>> s2 = set([1, 6, 8])
>>> s1.symmetric_difference(s2)
set([8, 1, 4, 9])
>>> s1 ^ s2
set([8, 1, 4, 9])
>>> s1.symmetric_difference_update(s2)
>>> s1
set([8, 1, 4, 9])

>>> s1 = set([4, 6, 9])
>>> s2 = set([1, 6, 8])
>>> s1.difference(s2)
set([9, 4])
>>> s1 - s2
set([9, 4])
>>> s1.difference_update(s2)
>>> s1
set([9, 4])

>>> fs = frozenset([2, 3, 4])
>>> s1 = set([fs, 4, 5, 6])
>>> s1
set([4, frozenset([2, 3, 4]), 6, 5])
>>> fs.intersection(s1)
frozenset([4])
>>> fs.add(6)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'frozenset' object has no attribute 'add'

>>> x = 2
>>> y = 3
>>> z = 5
>>> x * y
6
>>> x + y
5
>>> x * y + z
11
>>> (x + y) * z
25

>>> 3**3
27

>>> x = 5
>>> float(x)
5.0

>>> print 0.6/0.2
3.0
>>> print 0.6//0.2
2.0

>>> 10%7
3

>>> x = 5
>>> -x
-5

>>> x = 2
>>> x # 2
2
>>> x *= 3
>>> x # 2 * 3
6
>>> x += 4
>>> x # 2 * 3 + 4
10
>>> x /= 5
>>> x # (2 * 3 + 4) / 5
2
>>> x **= 2
>>> x # ((2 * 3 + 4) / 5) ** 2
4
>>> x %= 3
>>> x # ((2 * 3 + 4) / 5) ** 2 % 3
1

>>> x = 'repeat this  '
>>> x  # repeat this
repeat this
>>> x *= 3  # fill with x repeated three times
>>> x
repeat this  repeat this  repeat this

if a or b:
    do_this
else:
    do_this

if a and b:
    do_this
else:
    do_this

if not a:
    do_this
else:
    do_this

l = [100,200,300,400]
for i in l:
    print i

100
200
300
400

l = range(100, 401,100)
for i in l:
    print i

for i in range(10, 0, -1):
    print i

10
9
8
7
6
5
4
3
2
1

for i in range(10, 0, -2):
    print i

10
8
6
4
2

l = [(1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]
for x, xsquared in l:
    print x, ':', xsquared

1 : 1
2 : 4
3 : 9
4 : 16
5 : 25

x = 5
while x > 0:
    print x
    x = x - 1

5
4
3
2
1

x = 5
y = x
while y > 0:
    print y
    y = y - 1
else:
    print x

5
4
3
2
1
5

x = 5
while x > 0:
    print x
    break
    x -= 1
    print x

5

l = [5,6,7]
for x in l:
    continue
    print x

l = range(1,100)
for x in l:
    if x == 100:
        print x
        break
    else:
        print x," is not 100"
else:
    print "100 not found in range"

expected_str = "melon"
received_str = "apple"
fruits = ["banana", "grapes", "strawberry", "melon", "orange"]
x = 0

while(received_str != expected_str):
    print "I am waiting for my ",expected_str
    received_str = fruits[x]
    x += 1 # Change this to 3 to make the while statement 
           # evaluate to false, avoiding the break statement, using the else clause.
    if(received_str==fruits[2]): print "I hate",fruits[2],"!";break
else:
    print "Finally got what I wanted! my precious ",expected_str,"!"
print "Going back home now!"

I am waiting for my  melon
I am waiting for my  melon
I am waiting for my  melon
I hate strawberry !
Going back home now!

>>> x = 10
>>> if x > 0:
...    print "Positive"
...
Positive
>>> if x < 0:
...    print "Negative"
...

>>> x = -6
>>> if x > 0:
...    print "Positive"
... elif x == 0:
...    print "Zero"
... else:
...    print "Negative"
...
'Negative'

def functionname(arg1, arg2, ...):
    statement1
    statement2
    ...

>>> def functionname(arg1,arg2):
...     return arg1+arg2
...
>>> t = functionname(24,24) # Result: 48

def functionname():
    statement1
    statement2
    ...

def square(x):
    return x*x

>>> def display_message(message, truncate_after = 4):
...     print message[:truncate_after]
...
>>> display_message("message")
mess
>>> display_message("message", 6)
messag

def function(first,second,*remaining):
    statement1
    statement2
    ...

>>> def print_tail(first,*tail):
...     print tail
...
>>> print_tail(1, 5, 2, "omega")
(5, 2, 'omega')

def make_dictionary(max_length = 10, **entries):
    return dict([(key, entries[key]) for i, key in enumerate(entries.keys()) if i < max_length])

>>> make_dictionary(max_length = 2, key1 = 5, key2 = 7, key3 = 9)
{'key3': 9, 'key2': 7}

foo()
square(3)
bar(5, x)

x = foo()
y = bar(5,x)

def display_message(message, start=0, end=4):
   print message[start:end]

display_message("message", end=3)

display_message(end=5, start=1, "my message")

>>> def outer(outer_argument):
...     def inner(inner_argument):
...         return outer_argument + inner_argument
...     return inner
...
>>> f = outer(5)
>>> f(3)
8
>>> f(4)
9

>>> def add(a, b):
...    return a + b
...
>>> add(4, 3)
7

>>> print (lambda a, b: a + b)(4, 3)
7

>>> sorted([[3, 4], [3, 5], [1, 2], [7, 3]], key=lambda x: x[1])
[[1, 2], [7, 3], [3, 4], [3, 5]]

>>> def attribution(name):
...    return lambda x: x + ' -- ' + name
...
>>> pp = attribution('John')
>>> pp('Dinner is in the fridge')
'Dinner is in the fridge -- John'

>>> class Foo(object):
...     @property
...     def bar(self):
...         return 'baz'
...
>>> F = Foo()
>>> print F.bar
baz

>>> class Foo(object):
...     def bar(self):
...         return 'baz'
...     bar = property(bar)
...
>>> F = Foo()
>>> print F.bar
baz

>>> def decorator(f):
...     def called(*args, **kargs):
...         print 'A function is called somewhere'
...         return f(*args, **kargs)
...     return called
...
>>> class Foo(object):
...     @decorator
...     def bar(self):
...         return 'baz'
...
>>> F = Foo()
>>> print F.bar()
A function is called somewhere
baz

def foo():
    def bar():
        x = 5 # x is now in scope
        return x + y # y is defined in the enclosing scope later
    y = 10
    return bar() # now that y is defined, bar's scope includes y

>>> foo()
15
>>> bar()
Traceback (most recent call last):
  File "<pyshell#26>", line 1, in -toplevel-
    bar()
NameError: name 'bar' is not defined

>>> for x in range(10):
         y.append(x) # append is an attribute of lists

Traceback (most recent call last):
  File "<pyshell#46>", line 2, in -toplevel-
    y.append(x)
NameError: name 'y' is not defined

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

 try:
     print 1/0
 except ZeroDivisionError:
     print "You can't divide by zero, you silly."

You can't divide by zero, you silly.

 def f(x):
     return g(x) + 1

 def g(x):
     if x < 0: raise ValueError, "I can't cope with a negative number here."
     else: return 5

 try:
     print f(-6)
 except ValueError:
     print "That value was invalid."

That value was invalid.

 try:
    the_file = open("the_parrot")
 except IOError, (ErrorNumber, ErrorMessage):
     if ErrorNumber == 2: # file not found
        print "Sorry, 'the_parrot' has apparently joined the choir invisible."
     else:
        print "Congratulation! you have managed to trip a #%d error" % ErrorNumber  # String concatenation is slow, use % formatting whenever possible
        print ErrorMessage

Sorry, 'the_parrot' has apparently joined the choir invisible.

   class CustomException(Exception):
       def __init__(self, value):
           self.parameter = value
       def __str__(self):
           return repr(self.parameter)

try:
    raise CustomException("My Useful Error Message")
except CustomException, (instance):
    print "Caught: " + instance.parameter

try:
    result = None
    try:
       result = x/y
    except ZeroDivisionError:
       print "division by zero!"
    print "result is ", result
finally:
     print "executing finally clause"

try:
     result = x / y
except ZeroDivisionError:
     print "division by zero!"
else:
     print "result is", result
finally:
     print "executing finally clause"

if hasattr(self, 'items'):
    self.items.extend(new_items)
else:
    self.items = list(new_items)

try:
    self.items.extend(new_items)
except AttributeError:
    self.items = list(new_items)

print raw_input('What is your name?')

What is your name? <user input data here>

[1,2,3]

x = input('What are the first 10 perfect squares? ')

map(lambda x: x*x, range(10))

x = None
while not x:
    try:
        x = int(raw_input())
    except ValueError:
        print 'Invalid Number'

f = file('test.txt', 'r')

f = open('test.txt', 'r')
for line in f:
    print line[0]
f.close()

for line in open('test.txt', 'r'):
    print line[0]

c = f.read(1)
while len(c) > 0:
    if len(c.strip()) > 0: print c,
    c = f.read(1)

f.seek(0)

import sys

import sys
for line in sys.stdin:
    print line,

python program.py hello there programmer!

print 'Hello, world'

print 'Hello,', 'World'

Hello, World

print 1,2,0xff,0777,(10+5j),-0.999,map,sys

1 2 255 511 (10+5j) -0.999 <built-in function map> <module 'sys' (built-in)>

for i in range(10):
    print i,

0 1 2 3 4 5 6 7 8 9

for i in range(10):
    print i,
print
for i in range(10,20):
    print i,

0 1 2 3 4 5 6 7 8 9
10 11 12 13 14 15 16 17 18 19

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

print str(1)+str(2)+str(0xff)+str(0777)+str(10+5j)+str(-0.999)+str(map)+str(sys)

12255511(10+5j)-0.999<built-in function map><module 'sys' (built-in)>

import sys
write = sys.stdout.write
write('20')
write('05\n')

2005

print >> f, 'Hello, world'

import math

import math
print math.sqrt(10)

from string import whitespace
from math import *
from math import sin as SIN
from math import cos as COS
from ftplib import FTP as ftp_connection
print sqrt(10)

class Object1:
        def __init__(self):
                self.name = 'object 1'

import mymod
myobject = mymod.Object1()
from mymod import *
myobject = Object1()

from Object1 import *
from Object2 import *
from Object3 import *

__all__ = ["Object1", "Object2", "Object3"]

from . import *

class Object2:
        def __init__(self):
                self.name = 'object 2'
                self.otherObject = Object1()

class ClassName:
    ...
    ...

f = Foo()

>>> class Foo:
...     def setx(self, x):
...         self.x = x
...     def bar(self):
...         print self.x

>>> f.setx(5)
>>> f.bar()

5

>>> Foo.setx(f,5)
>>> Foo.bar(f)

>>> del f.x
>>> f.bar()

Traceback (most recent call last):
  File "<stdin>", line 1, in ?
  File "<stdin>", line 5, in bar
AttributeError: Foo instance has no attribute 'x'

>>> Foo.y = 10
>>> g = Foo()
>>> g.y
10

>>> vars(g)
{}

>>> vars(Foo)
{'y': 10, 'bar': <function bar at 0x4d6a3c>, '__module__': '__main__',
 'setx': <function setx at 0x4d6a04>, '__doc__': None}

>>> g.setx(5)
>>> vars(g)
{'x': 5}

>>> g.y = 9
>>> vars(g)
{'y': 9, 'x': 5}
>>> vars(Foo)
{'y': 10, 'bar': <function bar at 0x4d6a3c>, '__module__': '__main__',
 'setx': <function setx at 0x4d6a04>, '__doc__': None}

>>> g.y
9
>>> Foo.y
10

>>> g.__dict__
{'y': 9, 'x': 5}

>>> g.__dict__['z'] = -4
>>> g.z
-4

>>> class ClassicFoo:
...     def __init__(self):
...         pass

>>> class NewStyleFoo(object):
...     def __init__(self):
...         pass

>>> class SpamWithProperties(object):
...     def __init__(self):
...         self.__egg = "MyEgg"
...     def getEgg(self):
...         return self.__egg
...     def setEgg(self,egg):
...         self.__egg = egg
...     egg = property(getEgg,setEgg)

>>> sp = SpamWithProperties()
>>> sp.egg
'MyEgg'
>>> sp.egg = "Eggs With Spam"
>>> sp.egg
'Eggs With Spam'
>>>

>>> class StaticSpam(object):
...     def StaticNoSpam():
...         print "You can't have have the spam, spam, eggs and spam without any spam... that's disgusting"
...     NoSpam = staticmethod(StaticNoSpam)

>>> StaticSpam.NoSpam()
'You can't have have the spam, spam, eggs and spam without any spam... that's disgusting'

>>> class StaticSpam(object):
...     @staticmethod
...     def StaticNoSpam():
...         print "You can't have have the spam, spam, eggs and spam without any spam... that's disgusting"

class ClassName(superclass1,superclass2,superclass3,...):
    ...

>>> class Foo:
...     def bar(self):
...         print "I'm doing Foo.bar()"
...     x = 10
...
>>> class Bar(Foo):
...     def bar(self):
...         print "I'm doing Bar.bar()"
...         Foo.bar(self)
...     y = 9
...
>>> g = Bar()
>>> Bar.bar(g)
I'm doing Bar.bar()
I'm doing Foo.bar()
>>> g.y
9
>>> g.x
10

>>> vars(g)
{}
>>> vars(Bar)
{'y': 9, '__module__': '__main__', 'bar': <function bar at 0x4d6a04>,
 '__doc__': None}
>>> vars(Foo)
{'x': 10, '__module__': '__main__', 'bar': <function bar at 0x4d6994>,
 '__doc__': None}

class A:
    def __init__(self):
        print 'A.__init__()'
a = A()

A.__init__()

class Foo:
    def __init__ (self, printme):
        print printme
foo = Foo('Hi!')

Hi!

class Foo:
    def __init__ (self, x):
         print x
foo = Foo('Hi!')
class Foo2:
    def setx(self, x):
        print x
f = Foo2()
Foo2.setx(f,'Hi!')

Hi!
Hi!

class Bar:
    def __init__ (self, iamthis):
        self.iamthis = iamthis
    def __str__ (self):
        return self.iamthis
bar = Bar('apple')
print bar

apple

class Bar:
    def __init__ (self, iamthis):
        self.iamthis = iamthis
    def __repr__(self):
        return "Bar('%s')" % self.iamthis
bar = Bar('apple')
bar

Bar('apple')

>>> class Unchangable:
...    def __setattr__(self, name, value):
...        print "Nice try"
...
>>> u = Unchangable()
>>> u.x = 9
Nice try
>>> u.x

Traceback (most recent call last):
  File "<stdin>", line 1, in ?
AttributeError: Unchangable instance has no attribute 'x'

>>> class HiddenMembers:
...     def __getattr__(self, name):
...         return "You don't get to see " + name
...
>>> h = HiddenMembers()
>>> h.anything
"You don't get to see anything"

>>> class Permanent:
...     def __delattr__(self, name):
...         print name, "cannot be deleted"
...
>>> p = Permanent()
>>> p.x = 9
>>> del p.x
x cannot be deleted
>>> p.x
9

>>> class FakeNumber:
...     n = 5
...     def __add__(A,B):
...         return A.n + B.n
...
>>> c = FakeNumber()
>>> d = FakeNumber()
>>> d.n = 7
>>> c + d
12

>>> c.__imul__ = lambda B: B.n - 6
>>> c *= d
>>> c
1

>>> c = FakeNumber()
>>> c += d
>>> c
12

>>> FakeNumber.__neg__ = lambda A : A.n + 6
>>> -d
13

>>> class FakeList:
...     def __getitem__(self,index):
...         return index * 2
...
>>> f = FakeList()
>>> f['a']
'aa'

>>> class FakeList:
...     def __setitem__(self,index,value):
...         self.string = index + " is now " + value
...
>>> f = FakeList()
>>> f['a'] = 'gone'
>>> f.string
'a is now gone'

>>> class FakeList:
...     def __getslice___(self,start,end):
...         return str(start) + " to " + str(end)
...
>>> f = FakeList()
>>> f[1:4]
'1 to 4'

>> f[:]
'0 to 2147483647'

>>> class Documented:
...     """This is a docstring"""
...     def explode(self):
...         """
...         This method is documented, too! The coder is really serious about
...         making this class usable by others who don't know the code as well
...         as he does.
...
...         """
...         print "boom"
>>> d = Documented()
>>> d.__doc__
'This is a docstring'

class Spam:
  def __init__(self):
    self.myeggs = 5

def cook(self):
  print "cooking %s eggs" % self.myeggs

Spam.cook = cook   #add the function to the class Spam
eggs = Spam()      #NOW create a new instance of Spam
eggs.cook()        #and we are ready to cook!

cooking 5 eggs

class Spam:
  def __init__(self):
    self.myeggs = 5

eggs = Spam()

def cook(self):
  print "cooking %s eggs" % self.myeggs

import types
f = types.MethodType(cook, eggs, Spam)
eggs.cook = f

eggs.cook()

cooking 5 eggs

def attach_method(fxn, instance, myclass):
  f = types.MethodType(fxn, instance, myclass)
  exec('instance.' + fxn.__name__ + ' = f')

attach_method(cook, eggs, Spam)

instance.fxn = f
>>> def StringContainer():
...     # define a class
...     class String:
...             content_string = ""
...             def len(self):
...                     return len(self.content_string)
...     # return the class definition
...     return String
...
>>> # create the class definition
... container_class = StringContainer()
>>>
>>> # create an instance of the class
... wrapped_string = container_class()
>>>
>>> # take it for a test drive
... wrapped_string.content_string = 'emu emissary'
>>> wrapped_string.len()
12

>>> def DeAbbreviate(sequence_container):
...     setattr(sequence_container, 'length', sequence_container.len)
...     delattr(sequence_container, 'len')
...
>>> DeAbbreviate(container_class)
>>> wrapped_string.length()
12
>>> wrapped_string.len()
 Traceback (most recent call last):
   File "<stdin>", line 1, in ?
 AttributeError: String instance has no attribute 'len'

>>> del container_class
>>> wrapped_string2 = container_class()
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
NameError: name 'container_class' is not defined
>>> wrapped_string.length()
12

>>> type(object)
<type 'type'>
>>> type(int)
<type 'type'>
>>> type(list)
<type 'type'>

>>> type(type)
<type 'type'>

>>> class MyClass(BaseClass):
...     attribute = 42

>>> MyClass = type("MyClass", (BaseClass,), {'attribute' : 42})

class CustomMetaclass(type):
    def __init__(cls, name, bases, dct):
        print "Creating class %s using CustomMetaclass" % name
        super(CustomMetaclass, cls).__init__(name, bases, dct)

class BaseClass(object):
    __metaclass__ = CustomMetaclass

class Subclass1(BaseClass):
    pass

Creating class BaseClass using CustomMetaclass
Creating class Subclass1 using CustomMetaclass

import re

import re
foo = re.compile(r'foo(.{,5})bar', re.I+re.S)

>>> import re
>>> foo = re.compile(r'foo(.{,5})bar', re.I+re.S)
>>> st1 = 'Foo, Bar, Baz'
>>> st2 = '2. foo is bar'
>>> search1 = foo.search(st1)
>>> search2 = foo.search(st2)
>>> match1 = foo.match(st1)
>>> match2 = foo.match(st2)

>>> search3 = re.search('oo.*ba', st1, re.I)

>>> match3 = foo.match(st2, 3)

>>> str3 = 'foo, Bar Foo. BAR FoO: bar'
>>> foo.findall(str3)
[', ', '. ', ': ']
>>> for match in foo.finditer(str3):
...     match.group(1)
...
', '
'. '
': '

>>> search1.group()
'Foo, Bar'
>>> search1.group(1)
', '

>>> search1.start()
0
>>> search1.end()
8
>>> search1.start(1)
3
>>> search1.end(1)
5

>>> import re
>>> mystring = 'This string has a q in it'
>>> pattern = re.compile(r'(a[n]? )(\w) ')
>>> newstring = pattern.sub(r"\1'\2' ", mystring)
>>> newstring
"This string has a 'q' in it"

>>> subresult = pattern.subn(r"\1'\2' ", mystring)
>>> subresult
("This string has a 'q' in it", 1)

>>> import re
>>> mystring = '1. First part 2. Second part 3. Third part'
>>> re.split(r'\d\.', mystring)
['', ' First part ', ' Second part ', ' Third part']

>>> re.escape(r'This text (and this) must be escaped with a "\" to use in a regexp.')
'This\\ text\\ \\(and\\ this\\)\\ must\\ be\\ escaped\\ with\\ a\\ \\"\\\\\\"\\ to\\ use\\ in\\ a\\ regexp\\.'

import xml.sax.handler as saxhandler
import xml.sax as saxparser

class MyReport:
    def __init__(self):
        self.Y = 1

class MyCH(saxhandler.ContentHandler):
    def __init__(self, report):
        self.X = 1
        self.report = report

    def startDocument(self):
        print 'startDocument'

    def startElement(self, name, attrs):
        print 'Element:', name

report = MyReport()          #for future use
ch = MyCH(report)

xml = """\
<collection>
  <comic title=\"Sandman\" number='62'>
     <writer>Neil Gaiman</writer>
     <penciller pages='1-9,18-24'>Glyn Dillon</penciller>
     <penciller pages="10-17">Charles Vess</penciller>
  </comic>
</collection>
"""

print xml

saxparser.parseString(xml, ch)

from xml.dom import minidom as dom
import urllib2

def fetchPage(url):
    a = urllib2.urlopen(url)
    return ''.join(a.readlines())

def extract(page):
    a = dom.parseString(page)
    item = a.getElementsByTagName('item')
    for i in item:
        if i.hasChildNodes() == True:
            t = i.getElementsByTagName('title')[0].firstChild.wholeText
            l = i.getElementsByTagName('link')[0].firstChild.wholeText
            d = i.getElementsByTagName('description')[0].firstChild.wholeText
            print t, l, d

if __name__=='__main__':
    page = fetchPage("http://rss.slashdot.org/Slashdot/slashdot")
    extract(page)

import smtplib
server = smtplib.SMTP('smtp.gmail.com', 587)

server.ehlo()
server.starttls()
server.ehlo()

server.login("youremailusername", "password")

msg = "\nHello!" # The /n separates the message from the headers (which we ignore for this example)
server.sendmail("you@gmail.com", "target@example.com", msg)

from email.MIMEMultipart import MIMEMultipart
from email.MIMEText import MIMEText

fromaddr = "you@gmail.com"
toaddr = "target@example.com"
msg = MIMEMultipart()
msg['From'] = fromaddr
msg['To'] = toaddr
msg['Subject'] = "Python email"

body = "Python test mail"
msg.attach(MIMEText(body, 'plain'))

import smtplib
server = smtplib.SMTP('smtp.gmail.com', 587)
server.ehlo()
server.starttls()
server.ehlo()
server.login("youremailusername", "password")
text = msg.as_string()
server.sendmail(fromaddr, toaddr, text)

>>> print text
Content-Type: multipart/mixed; boundary="===============1893313573=="
MIME-Version: 1.0
From: you@gmail.com
To: target@example.com
Subject: Python email

--===============1893313573==
Content-Type: text/plain; charset="us-ascii"
MIME-Version: 1.0
Content-Transfer-Encoding: 7bit

Python test mail
--===============1893313573==--

import thread, time

def loop1_10():
    for i in range(1,10):
        time.sleep(1)
        print i

thread.start_new_thread(loop1_10, ())

#!/usr/bin/env python
import threading
import time

class MyThread(threading.Thread):
    def run(self):
        print "%s started!" % self.getName()
        time.sleep(1)
        print "%s finished!" % self.getName()

if __name__ == '__main__':
    for x in range(4):
        mythread = MyThread(name = "Thread-%d" % (x + 1))
        mythread.start()
        time.sleep(.2)

Thread-1 started!
Thread-2 started!
Thread-3 started!
Thread-4 started!
Thread-1 finished!
Thread-2 finished!
Thread-3 finished!
Thread-4 finished!

import socket
s = socket.socket()
s.connect(('localhost', 80))
s.send('GET / HTTP/1.1\nHost:localhost\n\n')
s.recv(40000) # receive 40000 bytes

ntpps       picoseconds portion of time
ntps        seconds portion of time
ntpms       milliseconds portion of time
ntpt        64-bit ntp time, seconds in upper 32-bits, picoseconds in lower 32-bits

import socket

BLOCKING = 1            # 0 = non blocking, 1 = blocking
NONBLOCKING = 0         # 0 = non blocking, 1 = blocking
TIME1970            = 2208988800L      # Thanks to F.Lundh
NTPPORT             = 123
MAXLEN              = 1024
NTPSERVER           = ('time.apple.com')
SKTRDRETRYCOUNT         = 2
SKTRDRETRYDLY           = 0.01

#***************************************************
## opensocket(servername, port, blocking) \n
# opens a socket at ip address "servername"
# \arg servername = ip address to open a socket to
# \arg port = port number to use
# ntp uses dgram sockets instead of stream
def opensocket(ipaddr, port, mode):
    # create the socket
    skt = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

    # open the socket
    try:
        skt.connect((ipaddr, port))
    except socket.error, e:
        print "Failed to connect to server %s %d %d" % (ipaddr, port, mode)
        print "Error %s" % (e.args[0])
        print "Goodbye..."
        sys.exit()

    # set the blocking mode (0=nonblocking, 1=blocking)
    try:
        skt.setblocking(mode)
    except socket.error, e:
        print "Failed to set socket blocking mode for %s %d %d" %(ipaddr, port, mode)
        print "Error %s" % (e.args[0])
        print "Goodbye..."
        sys.exit()

    return(skt)

#***************************************************
##
# we should get 12 long words back in network order \n
# the 10th word is the transmit time (seconds since UT 1900-Jan-01 \n
# I = unsigned long integer \n
# ! = network (big endian) ordering
# \arg \c \b ntpsocket, the socket handle to connect to
# \arg \c \b msg, the message to send to the ntp server
def getntptime(ntpsocket, msg, servername):
    ntpsocket.send(msg)

    rtrycnt = 0
    data = 0
    while (data == 0) & (rtrycnt < SKTRDRETRYCOUNT):
        try:
            data = ntpsocket.recv(MAXLEN)
        except socket.error, e:
            rtrycnt += 1
            print "Error reading non-blocking socket, retries = %s, server = %s" %(rtrycnt, servername)
            time.sleep(SKTRDRETRYDLY)       # don't retry too often

    # check and see if we got valid data back
    if data:
        ntps = unpack('!12I', data)[10]
        ntpps = unpack('!12I', data)[11]
        if ntps == 0:
            print "Error: NTP, invalid response, goodbye..."
            sys.exit()
    else:
        print "Error: NTP, no data returned, goodbye..."
        sys.exit()

    ntpms = ntpps/5000000L                  # 1ms/200ps, we want ms
    ntpt = (ntps << 32) + ntpps
    return (ntpsocket, ntps, ntpps, ntpms, ntpt)

import Tkinter

root = Tkinter.Tk()
root.mainloop()

import Tkinter

class App:
   def __init__(self, master):
      button = Tkinter.Button(master, text="I'm a Button.")
      button.pack()

if __name__ == '__main__':
   root = Tkinter.Tk()
   app = App(root)
   root.mainloop()

from PyQt4.QtCore import *
from PyQt4.QtGui import *

class App(QApplication):
    def __init__(self, argv):
        super(App, self).__init__(argv)
        self.msg = QLabel("Hello, World!")
        self.msg.show()

if __name__ == "__main__":
    import sys
    app = App(sys.argv)
    sys.exit(app.exec_)

import wx

class test(wx.App):
    def __init__(self):
        wx.App.__init__(self, redirect=False)

    def OnInit(self):
        frame = wx.Frame(None, -1,
                         "Test",
                         pos=(50,50), size=(100,40),
                         style=wx.DEFAULT_FRAME_STYLE)
        button = wx.Button(frame, -1, "Hello World!", (20, 20))
        self.frame = frame
        self.frame.Show()
        return True

if __name__ == '__main__':
        app = test()
        app.MainLoop()

import dabo
dabo.ui.loadUI("wx")

class TestForm(dabo.ui.dForm):
	def afterInit(self):
		self.Caption = "Test"
		self.Position = (50, 50)
		self.Size = (100, 40)
		self.btn = dabo.ui.dButton(self, Caption="Hello World",
		      OnHit=self.onButtonClick)
		self.Sizer.append(self.btn, halign="center", border=20)

	def onButtonClick(self, evt):
		dabo.ui.info("Hello World!")

if __name__ == '__main__':
        app = dabo.ui.dApp()
        app.MainFormClass = TestForm
        app.start()

from fltk import *

window = Fl_Window(100, 100, 200, 90)
button = Fl_Button(9,20,180,50)
button.label("Hello World")
window.end()
window.show()
Fl.run()

import pyodbc

DBfile = '/data/MSAccess/Music_Library.mdb'
conn = pyodbc.connect('DRIVER={Microsoft Access Driver (*.mdb)};DBQ='+DBfile, autocommit=True)
cursor = conn.cursor()

SQL = 'SELECT Artist, AlbumName FROM RecordCollection ORDER BY Year'
cursor.execute(SQL)
for row in cursor: # cursors are iterable
    print row.Artist, row.AlbumName

cursor.close()
conn.close()

import psycopg2
conn = psycopg2.connect("dbname=test")
cursor = conn.cursor()
cursor.execute("select * from test");
for i in cursor.next():
    print i
conn.close()

 #!/usr/bin/env python

 import sys
 from PyQt4 import Qt

 # We instantiate a QApplication passing the arguments of the script to it:
 a = Qt.QApplication(sys.argv)

 # Add a basic widget to this application:
 # The first argument is the text we want this QWidget to show, the second
 # one is the parent widget. Since Our "hello" is the only thing we use (the 
 # so-called "MainWidget", it does not have a parent.
 hello = Qt.QLabel("<nowiki><h2>Hello, World</h2></nowiki>")

 # ... and that it should be shown.
 hello.show()

 # Now we can start it.
 a.exec_()

#!/usr/bin/env python

import sys
from PyQt4 import Qt

a = Qt.QApplication(sys.argv)

# Our function to call when the button is clicked
def sayHello():
    print "Hello, World!"

# Instantiate the button
hellobutton = Qt.QPushButton("Say 'Hello world!'",None)

# And connect the action "sayHello" to the event "button has been clicked"
a.connect(hellobutton, Qt.SIGNAL("clicked()"), sayHello)

# The rest is known already...
#a.setMainWidget(hellobutton)
hellobutton.show()
a.exec_()

#!/usr/bin/env python

import sys
from PyQt4 import Qt

class HelloApplication(Qt.QApplication):

    def __init__(self, args):
        """ In the constructor we're doing everything to get our application
            started, which is basically constructing a basic QApplication by 
            its __init__ method, then adding our widgets and finally starting 
            the exec_loop."""
        Qt.QApplication.__init__(self, args)
        self.addWidgets()
        self.exec_()        

    def addWidgets(self):
        """ In this method, we're adding widgets and connecting signals from 
            these widgets to methods of our class, the so-called "slots" 
        """
        self.hellobutton = Qt.QPushButton("Say 'Hello world!'",None)
        self.connect(self.hellobutton, Qt.SIGNAL("clicked()"), self.slotSayHello)
        self.hellobutton.show()

    def slotSayHello(self):
        """ This is an example slot, a method that gets called when a signal is 
            emitted """
        print "Hello, World!"

# Only actually do something if this script is run standalone, so we can test our 
# application, but we're also able to import this program without actually running
# any code.
if __name__ == "__main__":
    app = HelloApplication(sys.argv)

pyuic testapp_ui.ui -o testapp_ui.py

#!/usr/bin/env python

from testapp_ui import TestAppUI
from qt import *
import sys

class HelloApplication(QApplication):

    def __init__(self, args):
        """ In the constructor we're doing everything to get our application
            started, which is basically constructing a basic QApplication by 
            its __init__ method, then adding our widgets and finally starting 
            the exec_loop."""
        QApplication.__init__(self,args)

        # We pass None since it's the top-level widget, we could in fact leave 
        # that one out, but this way it's easier to add more dialogs or widgets.
        self.maindialog = TestApp(None)

        self.setMainWidget(self.maindialog)
        self.maindialog.show()
        self.exec_loop()     

class TestApp(TestAppUI):

    def __init__(self,parent):
        # Run the parent constructor and connect the slots to methods.
        TestAppUI.__init__(self,parent)
        self._connectSlots()

        # The listview is initially empty, so the deletebutton will have no effect,
        # we grey it out.
        self.deletebutton.setEnabled(False)

    def _connectSlots(self):
        # Connect our two methods to SIGNALS the GUI emits.
        self.connect(self.addbutton,SIGNAL("clicked()"),self._slotAddClicked)
        self.connect(self.deletebutton,SIGNAL("clicked()"),self._slotDeleteClicked)

    def _slotAddClicked(self):
        # Read the text from the lineedit,
        text = self.lineedit.text()
        # if the lineedit is not empty,
        if len(text):
            # insert a new listviewitem ...
            lvi = QListViewItem(self.listview)
            # with the text from the lineedit and ...
            lvi.setText(0,text)
            # clear the lineedit.
            self.lineedit.clear()

            # The deletebutton might be disabled, since we're sure that there's now
            # at least one item in it, we enable it.
            self.deletebutton.setEnabled(True)

    def _slotDeleteClicked(self):
        # Remove the currently selected item from the listview.
        self.listview.takeItem(self.listview.currentItem())

        # Check if the list is empty - if yes, disable the deletebutton.
        if self.listview.childCount() == 0:
            self.deletebutton.setEnabled(False)

if __name__ == "__main__":
    app = HelloApplication(sys.argv)

import dbus

sys_bus = dbus.SystemBus()

proxy_for_cell_a2 = sys_bus.get_object('com.mycorp.CalcProgram', '/spreadsheet1/cells/a2')

cell_a2 = dbus.Interface(proxy_for_cell_a2, 'com.mycorp.CalcProgram.SpreadsheetCell')

cell_a2.getContents()

import dbus

sys_bus = dbus.SystemBus()

# get an object called / in org.freedesktop.Avahi to talk to
raw_server = sys_bus.get_object('org.freedesktop.Avahi', '/')

# objects support interfaces. get the org.freedesktop.Avahi.Server interface to our org.freedesktop.Avahi object.
server = dbus.Interface(raw_server, 'org.freedesktop.Avahi.Server')

# The so-called documentation is at /usr/share/avahi/introspection/Server.introspect
print server
print server.GetVersionString()
print server.GetHostName()

import dbus
bus = dbus.SystemBus()
hal_manager_object = bus.get_object('org.freedesktop.Hal', '/org/freedesktop/Hal/Manager')
hal_manager_interface = dbus.Interface(hal_manager_object, 'org.freedesktop.Hal.Manager')
print hal_manager_interface.GetAllDevices()

 def say_hello(name):
     "Greet somebody."
     print "Hello %s!" % name

hellomodule.c
#include <Python.h>

static PyObject* say_hello(PyObject* self, PyObject* args)
{
    const char* name;

    if (!PyArg_ParseTuple(args, "s", &name))
        return NULL;

    printf("Hello %s!\n", name);

    Py_RETURN_NONE;
}

static PyMethodDef HelloMethods[] =
{
     {"say_hello", say_hello, METH_VARARGS, "Greet somebody."},
     {NULL, NULL, 0, NULL}
};

PyMODINIT_FUNC

inithello(void)
{
     (void) Py_InitModule("hello", HelloMethods);
}

setup.py
from distutils.core import setup, Extension

module1 = Extension('hello', sources = ['hellomodule.c'])

setup (name = 'PackageName',
        version = '1.0',
        description = 'This is a demo package',
        ext_modules = [module1])

python setup.py build

hello.so
build/lib.linux-i686-x.y
cmd.exe
gcc
PATH
python setup.py build -c mingw32

hello.pyd
build\lib.win32-x.y
DLL
cmd.exe
gcc -c  hellomodule.c -I/PythonXY/include
gcc -shared hellomodule.o -L/PythonXY/libs -lpythonXY -o hello.dll

cl /LD hellomodule.c /Ic:\Python24\include c:\Python24\libs\python24.lib /link/out:hello.dll

>>> import hello
>>> hello.say_hello("World")
Hello World!

#include <Python.h>

int _fib(int n)
{
    if (n < 2)
        return n;
    else
        return _fib(n-1) + _fib(n-2);
}

static PyObject* fib(PyObject* self, PyObject* args)
{
    const char *command;
    int n;

    if (!PyArg_ParseTuple(args, "i", &n))
        return NULL;

    return Py_BuildValue("i", _fib(n));
}

static PyMethodDef FibMethods[] = {
    {"fib", fib, METH_VARARGS, "Calculate the Fibonacci numbers."},
    {NULL, NULL, 0, NULL}
};

PyMODINIT_FUNC
initfib(void)
{
    (void) Py_InitModule("fib", FibMethods);
}

from distutils.core import setup, Extension

module1 = Extension('fib', sources = ['fibmodule.c'])

setup (name = 'PackageName',
        version = '1.0',
        description = 'This is a demo package',
        ext_modules = [module1])

>>> import fib
>>> fib.fib(10)
55

/*hellomodule.c*/

#include <stdio.h>

void say_hello(const char* name) {
    printf("Hello %s!\n", name);
}

/*hello.i*/

%module hello
extern void say_hello(const char* name);

swig -python hello.i

gcc -fpic -c hellomodule.c hello_wrap.c -I/usr/include/python2.4/

gcc -shared hellomodule.o hello_wrap.o -o _hello.so

>>> import hello
>>> hello.say_hello("World")
Hello World!

#include <iostream>

using namespace std;

void say_hello(const char* name) {
    cout << "Hello " <<  name << "!\n";
}

#include <boost/python/module.hpp>
#include <boost/python/def.hpp>
using namespace boost::python;

BOOST_PYTHON_MODULE(hello)
{
    def("say_hello", say_hello);
}

#!/usr/bin/env python

from distutils.core import setup
from distutils.extension import Extension

setup(name="blah",
    ext_modules=[
        Extension("hello", ["hellomodule.cpp"],
        libraries = ["boost_python"])
    ])

python setup.py build

>>> import hello
>>> hello.say_hello("World")
Hello World!

from ctypes import *
libName = 'libc.so' # If you're on a UNIX-based system
libName = 'msvcrt.dll' # If you're on Windows
libc = CDLL(libName)
libc.printf("Hello, World!\n")

Syntax	Math	Operation Name
`a+b`	$a + b\,$	addition
`a-b`	$a - b\,$	subtraction
`a*b`	$a \times b\,$	multiplication
`a/b`	$a \div b\,$	division (see note below)
`a//b`	$a \div b\,$	floor division (e.g. 5/2=2) - Available in Python 2.2 and later
`a%b`	$a \bmod b\,$	modulo
`-a`	$-a\,$	negation
`abs(a)`	$\|a\|\,$	absolute value
`a**b`	$a^b\,$	exponent
`sqrt(a)`	$\sqrt{a}\,$	square root

operator	function
`<`	less than
`<=`	less than or equal to
`>`	greater than
`>=`	greater than or equal to
`==`	equal
`!=`	not equal

Abbreviation	Full name	Description
`re.I`	`re.IGNORECASE`	Makes the regexp case-insensitive
`re.L`	`re.LOCALE`	Makes the behavior of some special sequences (`\w, \W, \b, \B, \s, \S`) dependant on the current locale
`re.M`	`re.MULTILINE`	Makes the `^` and `$` characters match at the beginning and end of each line, rather than just the beginning and end of the string
`re.S`	`re.DOTALL`	Makes the `.` character match every character including newlines.
`re.U`	`re.UNICODE`	Makes `\w, \W, \b, \B, \d, \D, \s, \S` dependent on Unicode character properties
`re.X`	`re.VERBOSE`	Ignores whitespace except when in a character class or preceded by an non-escaped backslash, and ignores `#` (except when in a character class or preceded by an non-escaped backslash) and everything after it to the end of a line, so it can be used as a comment. This allows for cleaner-looking regexps.

ctypes name	C type	Python type	Notes
None	void	None	the None object
c_bool	C99 _Bool	bool
c_byte	signed char	int
c_char	signed char	str	length of one
c_char_p	char *	str
c_double	double	float
c_float	float	float
c_int	signed int	int
c_long	signed long	long
c_longlong	signed long long	long
c_short	signed short	long
c_ubyte	unsigned char	int
c_uint	unsigned int	int
c_ulong	unsigned long	long
c_ulonglong	unsigned long long	long
c_ushort	unsigned short	int
c_void_p	void *	int
c_wchar	wchar_t	unicode	length of one
c_wchar_p	wchar_t *	unicode

expression	result
true and true	true
true and false	false
false and true	false
false and false	false

expression	result
true or true	true
true or false	true
false or true	true
false or false	false

Name	Example	Description
service well known name	com.mycorp.CalcProgram	Identifies the application
path of an object	/spreadsheet1/cells/a2	Identifies an object published by a service
interface	com.mycorp.CalcProgram.SpreadsheetCell	Identifies what type of object we expect

Python Programming/Live print version

From Wikibooks, the open-content textbooks collection

Contents

[edit] Introduction

[edit] Installing Python in Windows

[edit] Cygwin

[edit] Installing Python on Mac

[edit] Installing Python on Unix environments

[edit] Gentoo GNU/Linux

[edit] Ubuntu GNU/Linux

[edit] Arch GNU/Linux

[edit] Source code installations

[edit] Installing Python PyDEV Plug-in for Eclipse IDE

[edit] Python Mode for Emacs

[edit] Installing new modules

[edit] See Also

[edit] Interactive mode

[edit] Navigating help

[edit] Help parameter

[edit] Learning to program in Python

[edit] Hello, World!

[edit] Windows

[edit] Mac

[edit] Linux

[edit] Result

[edit] Exercises

[edit] Notes

[edit] Variables

[edit] Strings

[edit] Strings and Variables

[edit] Combining Numbers and Strings

[edit] List of Learned Functions

[edit] Exercises

[edit] Mathematical Operators

[edit] Formatting output

[edit] Notes

[edit] Lists

[edit] Tuples

[edit] Dictionaries

[edit] Sets

[edit] Frozenset

[edit] Other data types

[edit] 3rd party data structure

[edit] Notes

[edit] Boolean Expressions

[edit] Examples

[edit] Exercises

[edit] Decisions

[edit] If statement

[edit] If Examples

[edit] If Exercises

[edit] Switch

[edit] While loops

[edit] Examples

[edit] For Loops

[edit] Exercises

[edit] Comments

[edit] Comment Guidelines

[edit] Documentation Strings

[edit] File I/O

[edit] Testing Files

[edit] Common File Operations

[edit] Syntax errors

[edit] Exceptions

[edit] Dealing with exceptions

[edit] Object Oriented Programming

[edit] Constructing a Class

[edit] But how do I use it?

[edit] Properties

[edit] Extending a Class

[edit] Special Class Methods

[edit] Console Windows (Command Line Interface)

[edit] Graphical User Interface(GUI)

[edit] Advance OOP GUI

[edit] MySQL

[edit] External links

[edit] Getting page text as a string

[edit] Downloading files

[edit] Other functions

[edit] Strings