CV
Langages
- C
- PHP
- Java
- Perl
- Ruby
- Javascript
- Flex 3
- Python
- GO
- C#
- TCL
- Bash
Liens
Articles
Contact

Python

Expertise (2/5)

Il y a quelques années j’ai utilisé Python quelques mois dans le cadre d’un projet autour de l’outil ZOP.

Récemment, j’ai utilisé Python pour développer un outil destiné à automatiser la procédure de cassage d’une clé WEP. Le script est disponible sur ce lien : wep-cracker.

Impression
Manipulation de chaîne
Les boucles
Les tests
Les fonctions
Les listes
Les dictionnaires
Manipulation de fichier
Expressions régulières
Les sockets
Les modules

Impression

Manipulation de chaîne

import string

a = ' chaine '
b = string.strip(a)
print "string.strip(\'%s\') = [%s]" % (a,b)

a = string.atoi("15")
print "string.atoi(\"15\") = %d" % (a)

a = "abcdabcdabcdabcdabcdx"
print "number of \"abcd\" in \'%s\' is: %d" % (a, string.count(a,"abcd"))
print "number of \"x\" in \'%s\' is: %d" % (a, string.count(a,"x"))

a = "equivalent to strstr()"
b = string.index (a, "strstr")
print "\"strstr\" starts at index %d in \"%s\"" % (b,a)

a = "equivalent to strstr()"
b = string.replace(a,"strstr", "find in string")
print "replacing \"%s\" by \"find in string\" into \"%s\": \"%s\"" % ("strstr",a,b)

a = "equivalent to strstr()"
print 'lengh of "%s" is %d characters' % (a, len(a))

my_list = [1,2,3,4]
print "converting a list into a string of characters."
print "the list my_list is equal to: " + str(my_list)
print "the list my_list is equal to: " + repr(my_list)
print "the list my_list is equal to: " + `my_list`

Les boucles

Les tests

Les fonctions

###################################################
# Defining a simple function                      #
###################################################

def my_function(n):
        a = n*2
        return a

x = my_function(200)
print "x = my_function(200) = %d - should be 400" % (x)

copy_of_the_function = my_function
print "x = copy_of_the_function(300) = %s - should be 600" % (x)

###################################################
# Default arguments for functions                 #
###################################################

def default_args (a, b=2):
        print "default_args (%d,%d)" % (a,b)
        x = a + b
        print " a = " + `a`
        print " b = " + `b`
        return x

print "x = default_args(3) = %d" % (default_args(3))
print "x = default_args(3, 4) = %d" % (default_args(3, 4))

###################################################
# Keywords when calling a function                #
###################################################

print "x = my_function(n=10) = %d" % (my_function(n=10))
print "x = my_function(b=5, a=2) = %d" % (default_args(b=5, a=2))

###################################################
# Variable number of arguments                    #
###################################################

def variable (toto, *vargs):
        print 'toto is equal to %s' % (toto)
        print 'Extra arguments are:'
        for i in vargs:
                print i

print "calling variable() with \'first arg\', \'a1\', \'a2\', \'a3\' as argument"
variable('first arg', 'a1', 'a2', 'a3')

###################################################
# variable number of keywords                     #
###################################################

def variable (toto, **vargs):
        print 'toto is equal to %s' % (toto)
        print 'Extra arguments are:'
        for i in vargs.keys():
                print i,vargs[i]

print "\n\n"
variable('first arg')

print "\n\n"
variable('first arg', a='first keyword')

print "\n\n"
variable('first arg', a='first keyword', b='second keyword')

Les listes

a = ["string1", "string2", "string3"]
print 'a=["string1", "string2", "string3"]'
print " a[0] " + a[0]
print " a[1] " + a[1]
print " a[2] " + a[2]

print ' add "string4" to the end of the list'
a.append("string4")
print " a[3] " + a[3]

print 'Insering "insert0" at index 0'
a.insert (0, "insert0")
print a

print 'Insering "insert4" at index 4'
a.insert (4, "insert4")
print a

print 'remove the first occurence of "insert0" in the list'
a.remove ("insert0")
print a

print "remove (and return) the last item of the list"
b = a.pop()
print "last item is " + b
print "now list is: "
print a

print "remove (and return) the second item of the list"
b = a.pop(1)
print "last item is " + b
print "now list is: "
print a

print "index of \"string3\" is %d" % (a.index("string3"))

print "number of items \"string3\" in the list: %d" % (a.count("string3"))
print "number of items in the list: %d" % (len(a))

print "sorting the list"
print "before:"
print a
print "after"
a.sort()
print a

print "remove items at index 0 and 1 from the list"
del a[0:2]
print a

Les dictionnaires

Manipulation de fichier

import sys


try:
        fdin = open("test_file", "r")
except IOError, desc:
        print "Can not open input file for reading: ", desc;
        sys.exit(1)


try:
        fdout = open("out", "w")
except IOError, desc:
        print "Can not open output file for writing: ", desc;
        sys.exit(1)


i = 1

try:
        line = fdin.readline()
except IOError, desc:
        print "Error while reading line ", i, " of input file: ", desc;
        sys.exit(1)

while line != "":
        print "line %d is %s" % (i,line)
        i = i + 1

        try:
                fdout.write("out" + line)
        except IOError, desc:
                print "Error while writing line ", i, " to output file: ", desc;
                sys.exit(1)

        try:
                line = fdin.readline()
        except IOError, desc:
                print "Error while reading line ", i, " of input file: ", desc;
                sys.exit(1)


fdin.close()
fdout.close()

Expressions régulières

import re

################################################################
# Testing for pattern                                          #
################################################################

regular = 'ab.'
buff = 'abc'

expr = re.compile(regular)
p = re.match(expr, buff)

print "Does " + buff + " contain " + regular + " ?"

if p == None:
        print "No"
else:
        print "Yes"

################################################################
# Finding all pattern that matches a given expression          #
################################################################

regular = 'ab.'
buff = 'abbxxxxabcyyyyabdb'

expr = re.compile(regular)
p = re.findall(expr, buff)

print "Find all occurrence of " + regular + " into " + buff

print p

################################################################
# Searching for a match in a given string of characters        #
################################################################

regular = '.ABBA.'
buff = 'wwwwwwwABBAzzzzzzz'

expr = re.compile(regular)
p = re.search(expr, regular)

print "Searching for " + regular + " into string " + buff

if p != None:
        print "Found"
else:
        print "Not found"

################################################################
# Replace pattern                                              #
################################################################

regular = '.ABBA.'
buff = '1ABBA2xxx3ABBA4yyy4ABBA5'
tag = "REPLACED"

replaced = re.sub(expr, tag, buff)

print "Replacing " + regular + " by " + tag + " in " + buff

print replaced

################################################################
# Another example with the use of ()                           #
################################################################

test = "<data name=\"email\">adresse email</data>"
test = test + "<data name=\"multisms\">nombres de sms</data>"
test = test + "<data name=\"expire\">date d'expiration de SMS</data>"
test = test + "<data name=\"free\">SMS gratuits</data>"

print "Searching in: [", test, "]"

######################################
# Look for attributs                 #
######################################

pattern = "\"([^\"<>]*)\""
expr = re.compile(pattern)
attributs = re.findall(expr, test)

print "\nAttributs are:"
print attributs

######################################
# Look for values                    #
######################################

pattern = ">([^<>]+)<"
expr = re.compile(pattern)
values = re.findall(expr, test)

print "\nValues are:"
print values

Les sockets

from socket import *
import sys


SERVER_PORT = 80
SERVER_HOST = 'dev3'
DATA_TO_SEND = "GET / HTTP/1.0\n\n"

###################################################
# Create socket                                   #
###################################################

try:
        sock = socket(AF_INET, SOCK_STREAM)
except error, desc:
        print "Can not create socket : ", desc
        sys.exit(1)

###################################################
# Connect to remote server                        #
###################################################

try:
        sock.connect((SERVER_HOST, SERVER_PORT))
except error, desc:
        print "Can not nonnect to server ", SERVER_HOST, " on port ", SERVER_PORT, " : ", desc
        sys.exit(1)

###################################################
# Send data                                       #
###################################################

try:
        sock.send (DATA_TO_SEND)
except error, desc:
        print "Error while sendinf data to server : ", desc
        sys.exit(1)

###################################################
# Now get the answer                              #
###################################################

try:
        answer = sock.recv(1000)
except error, desc:
        print "Error while reading answer from server : ", desc
        sys.exit(1)

print "\nThe server replied:\n\n", answer, "\n"

###################################################
# Close the connexion                             #
###################################################

sock.close()

Les modules

Just like other languages (such as C, C++, Perl, ...), it is possible to define modules. Modules may be compared to the libraries for C.

import module_name

Python will search for the file "module_name.py". If this file is not in the current directory, or in the standard Python's module path, then the Python interpreter will look in the list of directories specified by the environment variable PYTHONPATH. PYTHONPATH is a list of colon (:) separated directory paths.

Note that all the functions or variables in the module "module_name" can be called by using the notation: "module_name.function_name". If you want to get rid of the module name ("module_name"), then you can use the following notation:

from module_name import function1 function2

This will allow you to call function1 and function2 without the leading "module_name.". But all other functions or variables from the module "module_name" will not be exported (this means that you can't call them, even if you use the leading "module_name.".

If you want to export everything from a module, you can use:

from module_name import *

This will allow you to call any functions or variables from the module module_name without the leading "module_name.".