3.

PROGRAMAREA AVANSATA CU PYTHON

Instalarea limbajului de programare

Am ales versiunea 2.7 ca sa ruleze codul

aleg open interactive windows din dreapta

Aplicatiile

Cu tasta enter se executa programul

Operatii cu numere
Python interactive window. Type $help for a list of commands.

>>> 2 + 2

>>> (50 - 5*6) / 4

>>> 17 // 3

>>> 17 % 3

>>> 5 ** 2

25

>>> width = 20

>>> height = 5 * 9

>>> width * height

900

>>>

Stergerea ecranului
Siruri de caractere
>>> 'spam eggs'

'spam eggs'

>>> '"Yes," they said.'

'"Yes," they said.'

>>> '"Yes," they said.'

'"Yes," they said.'

>>> '"Isn\'t," they said.'

'"Isn\'t," they said.'

>>> '"Isn\'t," they said.'

'"Isn\'t," they said.'

>>> print('"Isn\'t," they said.')

"Isn't," they said.

>>> s = 'First line.\nSecond line.'

>>> s

'First line.\nSecond line.'

>>> print(s)

First line.

Second line.

>>> print('C:\some\name')

C:\some

ame
>>> print(r'C:\some\name')

C:\some\name

>>> # 3 times 'un', followed by 'ium'

...

>>> 3 * 'un' + 'ium'

'unununium'

>>> 'Py' 'thon'

'Python'

>>> prefix = 'Py'

>>> prefix + 'thon'

'Python'

>>> word = 'Python'

>>> word[0]

'P'

>>> word[-6]

'P'

>>> word[0:2]

'Py'

>>> word[:2] + word[2:]

'Python'

>>> word[:4] + word[4:]

'Python'

>>> word[-2:]

'on'

>>> word[4:42]

'on'

>>> 'J' + word[1:]

'Jython'

>>> word[:2] + 'py'

'Pypy'

>>> s = 'supercalifragilisticexpialidocious'

>>> len(s)

34
>>> squares = [1, 4, 9, 16, 25]

>>> squares[0]

>>> squares[-3:]

[9, 16, 25]

>>> squares[:]

[1, 4, 9, 16, 25]

>>> squares + [36, 49, 64, 81, 100]

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

>>> cubes = [1, 8, 27, 65, 125]

>>> 4 ** 3

64

>>> cubes[3] = 64

>>> cubes

[1, 8, 27, 64, 125]

>>> cubes.append(216)

>>> cubes.append(7 ** 3)

>>> cubes

[1, 8, 27, 64, 125, 216, 343]

>>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']

>>> letters

['a', 'b', 'c', 'd', 'e', 'f', 'g']

>>> letters[2:5] = ['C', 'D', 'E']

>>> letters

['a', 'b', 'C', 'D', 'E', 'f', 'g']

>>> letters[2:5] = []

>>> letters

['a', 'b', 'f', 'g']

>>> letters[:] = []

>>> letters

[]

>>> letters = ['a', 'b', 'c', 'd']

>>> len(letters)

>>> a = ['a', 'b', 'c']

>>> n = [1, 2, 3]

>>> x = [a, n]

>>> x

[['a', 'b', 'c'], [1, 2, 3]]

>>> x[0]

['a', 'b', 'c']

>>> x[0][1]

'b'

>>> i = 256*256

>>> print('The value of i is', i)

('The value of i is', 65536)

Setare pentru executare programe in python
C:\Python27

Envirnment variance
Aplicatii minimale

Aleg sa execut cu Pyton 2.7

Apasam de 2 ori enter pentru executarea sectiunii de program

>>> if x == 24:

... # un comentariu

... print "Salutari de pe www.invata-programare.ro."

...

Executia este mai jos

Salutari de pe www.invata-programare.ro.

>>>

Stergem ecranul
>>> sirdecaractere = 'Salut Invata-Programare'

>>> print sirdecaractere # scrie tot sirul de caractere pe ecran

Salut Invata-Programare

>>> print sirdecaractere [0] # scrie primul caracter din sir

>>> print sirdecaractere [2:5] # scrie pe ecran cracterele dintre pozitiile 3 si 5

lut

>>> print sirdecaractere [2:] # scrie pe cran toate caracterele incepand cu al 3-

lea

lut Invata-Programare

>>> print sirdecaractere * 2 # scrie sirul de caractere de 2 ori

Salut Invata-ProgramareSalut Invata-Programare

>>> print sirdecaractere + "TEST" # concateneaza sirurile de caractere

Salut Invata-ProgramareTEST

>>>

Liste

>>> lista = [ 'abcd', 123, 3.14, 'mihai', 2.81 ]

>>> listamica = [123, 'invata-programare']

>>> print lista # afiseaza toata lista pe ecran

['abcd', 123, 3.14, 'mihai', 2.81]

>>> print lista[0] # afiseaza primul element pe ecran

abcd
>>> print lista[1:3] # afiseaza elementele de la 2 pana la 3

[123, 3.14]

>>> print lista[2:] # afiseaza toate elementele incepand cu al 3-lea

[3.14, 'mihai', 2.81]

>>> print listamica * 2 # afiseaza lista de 2 ori

[123, 'invata-programare', 123, 'invata-programare']

>>> print lista + listamica # afiseaza listele concatenate

['abcd', 123, 3.14, 'mihai', 2.81, 123, 'invata-programare']

>>>

Dictionare

>>> dictionar = {}

>>> dictionar['unu'] = "Primul dictionar"

>>> dictionar[2] = "Urmatorul dictionar"

>>> dictionarmic = {'nume': 'mihai','varsta':23, 'site': 'www.cmconline.xyz'}

>>> print dictionar['unu'] # afiseaza valoarea acestui dictionar

Primul dictionar

>>> print dictionar[2] # afiseaza valoarea acestui dictionar

Urmatorul dictionar

>>> print dictionarmic # afiseaza tot dictionarul

{'nume': 'mihai', 'site': 'www.cmconline.xyz', 'varsta': 23}

>>> print dictionarmic.keys() # afiseaza cheile acestui dictionar

['nume', 'site', 'varsta']

>>> print dictionarmic.values() # afiseaza valoarile acestui dictionar

['mihai', 'www.cmconline.xyz', 23]

>>>

Siruri de caractere

>>> variabila1 = 'Salut'

>>> print "Noul sir de caractere: ", variabila1 + ' www.invata-programare.ro'

Noul sir de caractere: Salut www.invata-programare.ro

>>>

>>> variabila1 = 'Salut'

>>> print "Noul sir de caractere: ", variabila1 + ' www.invata-programare.ro'

 Noul sir de caractere: Salut www.invata-programare.ro

>>> string_mare = """this is a long string that is made up of

... several lines and non-printable characters such as

... TAB ( \t ) and they will show up that way when displayed.

... NEWLINEs within the string, whether explicitly given like

... this within the brackets [ \n ], or just a NEWLINE within

... the variable assignment will also show up.

... """

...

>>> print string_mare

this is a long string that is made up of

several lines and non-printable characters such as

TAB ( ) and they will show up that way when displayed.

NEWLINEs within the string, whether explicitly given like

this within the brackets [

], or just a NEWLINE within

the variable assignment will also show up.

>>>

Structura decizionala

>>> var = 23

>>> if ( var == 23 ) : print "Salut!"

...

...

Salut!

>>> print "Pa!"

Pa!

>>>
Resetare in caz de eroare sau ciclu infinit

Adaugare si stergere dintr-o lista

>>> agenda = {'Andrew Parson':8806336,

... 'Emily Everett':6784346, 'Peter Power':7658344,

... 'Lewis Lame':1122345}

...

>>> print agenda['Lewis Lame']

1122345
>>> agenda['Gingerbread Man'] = 1234567

>>> del agenda['Andrew Parson']

>>>

>>> lunile_anului = ('Ianuarie','Februarie','Martie','Aprilie','Mai','Iunie',\

... 'Iulie','August','Septembrie','Octombrie','Noiembrie',' Decembrie')

...

>>> pisici = ['Tom', 'Snappy', 'Kitty', 'Jessie', 'Chester']

>>> print pisici[2]

Kitty

>>> pisici.append('Catherine')

>>> del pisici[1]

>>>

Instructiunea ciclica FOR

>>> newList = [45, 'mananca', 90210, "Buna dimineata", -67]

>>> # creeaza bucla:

... # Parcurge newList si pune fiecare element

... # in variabila value si afiseaz-o

... for value in newList:

... print value

...

45

mananca

90210

Buna dimineata

-67

>>>
PROGRAMARE AVANSATA
Instalare Visual studio 15

tbe_ms_visual_studio_enterprise_x64_x86_with_update1
Se va activa
rularea unui program

Etapa 1

Configurarea visual studio v15

sa fiu conectat la internet
skip

Am ales versiunea 2.7 ca sa ruleze codul

update
click dreapta
SAU
IN VISUAL STUDIO 2013 AVEM

aleg open interactive windows din dreapta

Aplicatiile

Cu tasta enter se executa programul

APLICATII

Operatii cu numere
Python interactive window. Type $help for a list of commands.

>>> 2 + 2

>>> (50 - 5*6) / 4

>>> 17 // 3

>>> 17 % 3

>>> 5 ** 2

25

>>> width = 20

>>> height = 5 * 9

>>> width * height

900

>>>

Stergerea ecranului
Siruri de caractere
>>> 'spam eggs'

'spam eggs'

>>> '"Yes," they said.'

'"Yes," they said.'

>>> '"Yes," they said.'

'"Yes," they said.'

>>> '"Isn\'t," they said.'

'"Isn\'t," they said.'

>>> '"Isn\'t," they said.'

'"Isn\'t," they said.'

>>> print('"Isn\'t," they said.')

"Isn't," they said.

>>> s = 'First line.\nSecond line.'

>>> s

'First line.\nSecond line.'

>>> print(s)

First line.

Second line.

>>> print('C:\some\name')

C:\some

ame
>>> print(r'C:\some\name')

C:\some\name

>>> # 3 times 'un', followed by 'ium'

...

>>> 3 * 'un' + 'ium'

'unununium'

>>> 'Py' 'thon'

'Python'

>>> prefix = 'Py'

>>> prefix + 'thon'

'Python'

>>> word = 'Python'

>>> word[0]

'P'

>>> word[-6]

'P'

>>> word[0:2]

'Py'

>>> word[:2] + word[2:]

'Python'

>>> word[:4] + word[4:]

'Python'

>>> word[-2:]

'on'

>>> word[4:42]

'on'

>>> 'J' + word[1:]

'Jython'

>>> word[:2] + 'py'

'Pypy'

>>> s = 'supercalifragilisticexpialidocious'

>>> len(s)

34
>>> squares = [1, 4, 9, 16, 25]

>>> squares[0]

>>> squares[-3:]

[9, 16, 25]

>>> squares[:]

[1, 4, 9, 16, 25]

>>> squares + [36, 49, 64, 81, 100]

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

>>> cubes = [1, 8, 27, 65, 125]

>>> 4 ** 3

64

>>> cubes[3] = 64

>>> cubes

[1, 8, 27, 64, 125]

>>> cubes.append(216)

>>> cubes.append(7 ** 3)

>>> cubes

[1, 8, 27, 64, 125, 216, 343]

>>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']

>>> letters

['a', 'b', 'c', 'd', 'e', 'f', 'g']

>>> letters[2:5] = ['C', 'D', 'E']

>>> letters

['a', 'b', 'C', 'D', 'E', 'f', 'g']

>>> letters[2:5] = []

>>> letters

['a', 'b', 'f', 'g']

>>> letters[:] = []

>>> letters

[]

>>> letters = ['a', 'b', 'c', 'd']

>>> len(letters)

>>> a = ['a', 'b', 'c']

>>> n = [1, 2, 3]

>>> x = [a, n]

>>> x

[['a', 'b', 'c'], [1, 2, 3]]

>>> x[0]

['a', 'b', 'c']

>>> x[0][1]

'b'

>>> i = 256*256

>>> print('The value of i is', i)

('The value of i is', 65536)

Setare pentru executare programe in python
C:\Python27

Envirnment variance
Aplicatii minimale

Aleg sa execut cu Pyton 2.7

Apasam de 2 ori enter pentru executarea sectiunii de program

>>> if x == 24:

... # un comentariu

... print "Salutari de pe www.invata-programare.ro."

...

Executia este mai jos

Salutari de pe www.invata-programare.ro.

>>>

Stergem ecranul
>>> sirdecaractere = 'Salut Invata-Programare'

>>> print sirdecaractere # scrie tot sirul de caractere pe ecran

Salut Invata-Programare

>>> print sirdecaractere [0] # scrie primul caracter din sir

>>> print sirdecaractere [2:5] # scrie pe ecran cracterele dintre pozitiile 3 si 5

lut

>>> print sirdecaractere [2:] # scrie pe cran toate caracterele incepand cu al 3-

lea

lut Invata-Programare

>>> print sirdecaractere * 2 # scrie sirul de caractere de 2 ori

Salut Invata-ProgramareSalut Invata-Programare

>>> print sirdecaractere + "TEST" # concateneaza sirurile de caractere

Salut Invata-ProgramareTEST

>>>

Liste

>>> lista = [ 'abcd', 123, 3.14, 'mihai', 2.81 ]

>>> listamica = [123, 'invata-programare']

>>> print lista # afiseaza toata lista pe ecran

['abcd', 123, 3.14, 'mihai', 2.81]

>>> print lista[0] # afiseaza primul element pe ecran

abcd

>>> print lista[1:3] # afiseaza elementele de la 2 pana la 3

[123, 3.14]

>>> print lista[2:] # afiseaza toate elementele incepand cu al 3-lea

[3.14, 'mihai', 2.81]

>>> print listamica * 2 # afiseaza lista de 2 ori

[123, 'invata-programare', 123, 'invata-programare']

>>> print lista + listamica # afiseaza listele concatenate

['abcd', 123, 3.14, 'mihai', 2.81, 123, 'invata-programare']

>>>

Dictionare

>>> dictionar = {}

>>> dictionar['unu'] = "Primul dictionar"

>>> dictionar[2] = "Urmatorul dictionar"

>>> dictionarmic = {'nume': 'mihai','varsta':23, 'site': 'www.cmconline.xyz'}

>>> print dictionar['unu'] # afiseaza valoarea acestui dictionar

Primul dictionar

>>> print dictionar[2] # afiseaza valoarea acestui dictionar

Urmatorul dictionar

>>> print dictionarmic # afiseaza tot dictionarul

{'nume': 'mihai', 'site': 'www.cmconline.xyz', 'varsta': 23}

>>> print dictionarmic.keys() # afiseaza cheile acestui dictionar

['nume', 'site', 'varsta']

>>> print dictionarmic.values() # afiseaza valoarile acestui dictionar

['mihai', 'www.cmconline.xyz', 23]

>>>

Siruri de caractere

>>> variabila1 = 'Salut'

>>> print "Noul sir de caractere: ", variabila1 + ' www.invata-programare.ro'

Noul sir de caractere: Salut www.invata-programare.ro

>>>

>>> variabila1 = 'Salut'

>>> print "Noul sir de caractere: ", variabila1 + ' www.invata-programare.ro'

Noul sir de caractere: Salut www.invata-programare.ro

>>> string_mare = """this is a long string that is made up of

... several lines and non-printable characters such as

... TAB ( \t ) and they will show up that way when displayed.

... NEWLINEs within the string, whether explicitly given like

... this within the brackets [ \n ], or just a NEWLINE within

... the variable assignment will also show up.

... """

...

>>> print string_mare

this is a long string that is made up of

several lines and non-printable characters such as

TAB ( ) and they will show up that way when displayed.

NEWLINEs within the string, whether explicitly given like

this within the brackets [

], or just a NEWLINE within

the variable assignment will also show up.

>>>

print("Word counter")

sentence = input("Please enter a sentence to count the number of words. Press ENTER to
end the sentence:")

print("In this sentence, the number of words is:")

print(len(sentence.split(' ')))

REZULTA

Word counter

Please enter a sentence to count the number of words. Press ENTER to end the sentence:

In this sentence, the number of words is:

Structura decizionala
>>> var = 23

>>> if ( var == 23 ) : print "Salut!"

...

...

Salut!

>>> print "Pa!"

Pa!

>>>

def add(x, y):

return x + y

def subtract(x, y):

return x - y

def multiply(x, y):

return x * y

def divide(x, y):

return x / y

print("Python Calculator:")

print("1. Add")

print("2. Subtract")

print("3. Multiply")

print("4. Divide")

choice = input("What are we calculating today? (1, 2, 3, or 4):")

num1 = int(input("Enter first number: "))

num2 = int(input("Enter second number: "))

if choice == '1':

print(num1,"+",num2,"=", add(num1,num2))

elif choice == '2':

print(num1,"-",num2,"=", subtract(num1,num2))
elif choice == '3':

print(num1,"*",num2,"=", multiply(num1,num2))

elif choice == '4':

print(num1,"/",num2,"=", divide(num1,num2))

else:

print("Invalid input")

REZULTA

Python Calculator:

1. Add

2. Subtract

3. Multiply

4. Divide

What are we calculating today? (1, 2, 3, or 4):1

Enter first number: 1

Enter second number: 2

1 + 2 = 3

Resetare in caz de eroare sau ciclu infinit

Adaugare si stergere dintr-o lista

>>> agenda = {'Andrew Parson':8806336,

... 'Emily Everett':6784346, 'Peter Power':7658344,

... 'Lewis Lame':1122345}

...

>>> print agenda['Lewis Lame']

1122345

>>> agenda['Gingerbread Man'] = 1234567

>>> del agenda['Andrew Parson']

>>>

>>> lunile_anului = ('Ianuarie','Februarie','Martie','Aprilie','Mai','Iunie',\

... 'Iulie','August','Septembrie','Octombrie','Noiembrie',' Decembrie')

...

>>> pisici = ['Tom', 'Snappy', 'Kitty', 'Jessie', 'Chester']

>>> print pisici[2]

Kitty

>>> pisici.append('Catherine')

>>> del pisici[1]

>>>
Instructiunea ciclica FOR

>>> newList = [45, 'mananca', 90210, "Buna dimineata", -67]

>>> # creeaza bucla:

... # Parcurge newList si pune fiecare element

... # in variabila value si afiseaz-o

... for value in newList:

... print value

...

45

mananca

90210

Buna dimineata

-67

>>>

def main():

# define a list of days in English and French

days = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]

daysFr = ["Dim", "Lun", "Mar", "Mer", "Jeu", "Ven", "Sam"]

# use iter to create an iterator over a collection

i = iter(days)

print(next(i)) # Sun

print(next(i)) # Mon

print(next(i)) # Tue

# iterate using a function and a sentinel

with open("testfile.txt", "r") as fp:

for line in iter(fp.readline, ''):

print(line)
 # use regular interation over the days

for m in range(len(days)):

print(m+1, days[m])

# using enumerate reduces code and provides a counter

for i, m in enumerate(days, start=1):

print(i, m)

# use zip to combine sequences

for m in zip(days, daysFr):

print(m)

for i, m in enumerate(zip(days, daysFr), start=1):

print(i, m[0], "=", m[1], "in French")

if __name__ == "__main__":

main()

REZULTA

Sun

Mon

Tue

This is line 1

This is line 2

This is line 3

This is line 4

This is line 5

This is line 6
(1, 'Sun')

(2, 'Mon')

(3, 'Tue')

(4, 'Wed')

(5, 'Thu')

(6, 'Fri')

(7, 'Sat')

(1, 'Sun')

(2, 'Mon')

(3, 'Tue')

(4, 'Wed')

(5, 'Thu')

(6, 'Fri')

(7, 'Sat')

('Sun', 'Dim')

('Mon', 'Lun')

('Tue', 'Mar')

('Wed', 'Mer')

('Thu', 'Jeu')

('Fri', 'Ven')

('Sat', 'Sam')

(1, 'Sun', '=', 'Dim', 'in French')

(2, 'Mon', '=', 'Lun', 'in French')

(3, 'Tue', '=', 'Mar', 'in French')

(4, 'Wed', '=', 'Mer', 'in French')

(5, 'Thu', '=', 'Jeu', 'in French')

(6, 'Fri', '=', 'Ven', 'in French')

(7, 'Sat', '=', 'Sam', 'in French')

def main():

# use any() and all() to test sequences for boolean values

list1 = [1, 2, 3, 0, 5, 6]
 # any will return true if any of the sequence values are true

print(any(list1))

# all will return true only if all values are true

print(all(list1))

# min and max will return minimum and maximum values in a sequence

print("min: ", min(list1))

print("max: ", max(list1))

# Use sum() to sum up all of the values in a sequence

print("sum: ", sum(list1))

if __name__ == "__main__":

main()

REZULTA

True

False

min: 0

max: 6

sum: 17

n1 = 0

n2 = 1

count = 0

while count < 20:

print(n1)

n3 = n1 + n2

n1 = n2

n2 = n3

count += 1
REZULTA

13

21

34

55

89

144

233

377

610

987

1597

2584

4181
Rularea programelor ca module se face astfel

Click dreapta pe programul editat si salvat cu extensia .py

Deplasez paginile ca sa vad rezultatul rularii

Exersam sirul lui Fibonacci

n1 = 0

n2 = 1

count = 0

while count < 20:

print(n1)
 n3 = n1 + n2

n1 = n2

n2 = n3

count += 1

C:\kit python\nou\python-course-downloads\python_course\functions\lessons

def get_name():

"""Get and return a name"""

name = input('What is your name? ')

return name
Determinarea daca un numar este impar

def is_odd(number):

"""Determine if a number is odd."""

if number % 2 == 0:

return False

else:

return True

print(is_odd(7))

============

sau

============

def odd_or_even(number):

"""Determine if a number is odd or even."""

if number % 2 == 0:

return 'Even'
 else:

return 'Odd'

odd_or_even_string = odd_or_even(7)

print(odd_or_even_string)

Initiazarea se face si direct la apelul unei proceduri

def say_hi(first, last='Doe'):

print('Hi {} {}!'.format(first, last))

say_hi('Jane')

say_hi('John', 'Coltrane')

def say_hi(first, last):

print('Hi {} {}!'.format(first, last))

say_hi(first = 'Jane', last = 'Doe')

say_hi(last = 'Doe', first = 'John')

def say_hi(first, last):

print('Hi {} {}!'.format(first, last))

say_hi('Jane', 'Doe')
def say_hi(name = 'there'):

print('Hi {}!'.format(name))

say_hi()

say_hi('Jason')

def say_hi(name):

print('Hi {}!'.format(name))

say_hi('Jason')

say_hi('everybody')
def say_hi():

print('Hi!')

say_hi()
Apelul unei proceduri

def display_facts(facts):

"""Displays facts"""

for fact in facts:

print('{}: {}'.format(fact, facts[fact]))

print()

facts = {

'Jason': 'Can fly an airplane.',

'Jeff': 'Is afraid of clowns.',

'David': 'Plays the piano.'

display_facts(facts)

facts['Jeff'] = 'Is afraid of heights.'

facts['Jill'] = 'Can hula dance.'

display_facts(facts)

VARIALILE GLOBALE SI LOCALE IN CADRUL PROCEDURILOR

def demo_print_greeting():

print("TIK SI ADY!!")

def demo_local_variable():

a_variable = 7

a_variable ="TYK 007"

print(a_variable)

name = "NU CUNOSC"

def demo_global_variable():

global name

name = "TIK"
 print(name + "aDy")

def main():

#demo_print_greeting()

#demo_local_variable()

demo_global_variable(); print(name)

if __name__ =="__main__":

main()
import math

# This is a single-line comment

This is an

example of a

multi-line comment

def demo_print_greeting():

print("Rise & Shine!!")

def demo_local_variable():

a_variable = 7

a_variable ="The name is 007"

print(a_variable)

name = "Unknown"

def demo_global_variable():

global name

name = "Paul"

print(name + "y")

def demo_arithmetic():

print("\nDemo Arithmetic\n")

print("7 + 2 =", 7+2)

print("7 - 2 =", 7-2)

print("7 * 2 =", 7*2)

print("7 / 2 =", 7/2)

print("7 % 2 =", 7%2)

print("7 ** 2 =", 7**2) #Power

print("7 // 2 =", 7//2) #Floor

 print("math.floor(7/2) =", math.floor(7/2))

print("math.ceil(7/2) =", math.ceil(7/2))

def demo_order_of_operations():

print("\nDemo Order of Operations\n")

print("5+7-3*2 =", 5+7-3*2)

print("5+(7-3)*2 =", 5+(7-3)*2)

def main():

#demo_print_greeting()

#demo_local_variable()

#demo_global_variable(); print(name)

demo_arithmetic()

demo_order_of_operations()

if __name__ =="__main__":

main()
import math

# This is a single-line comment

This is an

example of a

multi-line comment
def demo_print_greeting():

print("Rise & Shine!!")

def demo_local_variable():

a_variable = 7

a_variable ="The name is 007"

print(a_variable)

name = "Unknown"

def demo_global_variable():

global name

name = "Paul"

print(name + "y")

def demo_arithmetic():

print("\nDemo Arithmetic\n")

print("7 + 2 =", 7+2)

print("7 - 2 =", 7-2)

print("7 * 2 =", 7*2)

print("7 / 2 =", 7/2)

print("7 % 2 =", 7%2)

print("7 ** 2 =", 7**2) #Power

print("7 // 2 =", 7//2) #Floor

print("math.floor(7/2) =", math.floor(7/2))

print("math.ceil(7/2) =", math.ceil(7/2))

def demo_order_of_operations():

print("\nDemo Order of Operations\n")

print("5+7-3*2 =", 5+7-3*2)

print("5+(7-3)*2 =", 5+(7-3)*2)

def demo_function_params(first,last):

print("The name is " + first + " " + last)

def demo_function_return(first, last):

full_name = first + " " + last

return "The full name is " + full_name

def demo_function_default(first = "Someone", last = "UnknownLast"):

full_name = first + " " + last

return "The full name is " + full_name

def demo_function_calls():

demo_function_params("James", "Bond") # executes function

print(demo_function_return("James", "Bond")) # prints returned value

print(demo_function_default(last="Bond")) # uses default value for 'first'

print(demo_function_return) # print object

def main():

#demo_print_greeting()

#demo_local_variable()

#demo_global_variable(); print(name)

#demo_arithmetic()

#demo_order_of_operations()

demo_function_calls()

if __name__ =="__main__":

main()
Ciclicitatea cu conditie de filtrare dintr-un vector de tip enumerare

contacts = {

'Jason': {

'phone': '555-0123',

'email': '[email protected]'
 },

'Carl': {

'phone': '555-0987',

'email': '[email protected]'

for contact in contacts:

print("{}'s contact info:".format(contact))

print(contacts[contact]['phone'])

print(contacts[contact]['email'])

Enumerarea unor date referitoare la o entitate

contacts = {'Jason': '555-0123', 'Carl': '555-0987'}

for person, phone_number in contacts.items():

print('The number for {0} is {1}.'.format(person, phone_number))

Afisarea datelor unei structuri

contacts = {

'Jason': '555-0123',

'Carl': '555-0987'

for contact in contacts:

print('The number for {0} is {1}.'.format(contact, contacts[contact]))

Aparteneta unui element la o multime

contacts = {

'Jason': ['555-0123', '555-0000'],

'Carl': '555-0987'

print ('555-0987' in contacts.values())

Instructiunea conditionala de filtrare

contacts = {

'Jason': ['555-0123', '555-0000'],

'Carl': '555-0987'

if 'Jason' in contacts.keys():

print("Jason's phone number is:")

print(contacts['Jason'][0])

if 'Tony' in contacts.keys():

print("Tony's phone number is:")

 print(contacts['Tony'][0])

Filtrare conditionala simpla

contacts = {

'Jason': ['555-0123', '555-0000'],

'Carl': '555-0987'

for number in contacts['Jason']:

print('Phone: {}'.format(number))
contacts = {

'Jason': ['555-0123', '555-0000'],

'Carl': '555-0987'

print('Jason:')

print(contacts['Jason'])

print('Carl:')

print(contacts['Carl'])
contacts = {'Jason': '555-0123', 'Carl': '555-0987'}

del contacts['Jason']

print(contacts)

contacts = {'Jason': '555-0123', 'Carl': '555-0987'}

contacts['Tony'] = '555-0570'

print(contacts)

print(len(contacts))

contacts = {'Jason': '555-0123', 'Carl': '555-0987'}

contacts['Jason'] = '555-0000'

jasons_phone = contacts['Jason']

print('Dial {} to call Jason.'.format(jasons_phone))

contacts = {'Jason': '555-0123', 'Carl': '555-0987'}

jasons_phone = contacts['Jason']

carls_phone = contacts['Carl']

print('Dial {} to call Jason.'.format(jasons_phone))

print('Dial {} to call Carl.'.format(carls_phone))

Instructiunea IF

age = 31

if age >= 35:

print('1.')

elif age >= 30:

print('2')

else:

print('3')

print('4!')
age = 31

if age >= 35:

print('1')

else:

print('2')

print('3!')
age = 31

if age >= 35:

print('You are old enough to be the President.')

print('Have a nice day!')

if 37 < 40:
 print('Thirty-seven is less than forty.')

Instructiunea conditionala compusa

a_boolean = True

the_other_boolean = False

print(a_boolean)

print(the_other_boolean)
Rularea alegand visual studio
open active window
copiez in ferastra mica

apas enter si rulez

# Use special methods to compare objects to each other

class Employee():

def __init__(self, fname, lname, level, yrsService):

 self.fname = fname

self.lname = lname

self.level = level

self.seniority = yrsService

# implement comparison functions by emp level

def __ge__(self, other):

if self.level == other.level:

return self.seniority >= other.seniority

return self.level >= other.level

def __gt__(self, other):

if self.level == other.level:

return self.seniority > other.seniority

return self.level > other.level

def __lt__(self, other):

if self.level == other.level:

return self.seniority < other.seniority

return self.level < other.level

def __le__(self, other):

if self.level == other.level:

return self.seniority <= other.seniority

return self.level <= other.level

def __eq__(self, other):

return self.level == other.level

def main():

# define some employees

dept = []

dept.append(Employee("Tim", "Sims", 5, 9))

dept.append(Employee("John", "Doe", 4, 12))

 dept.append(Employee("Jane", "Smith", 6, 6))

dept.append(Employee("Rebecca", "Robinson", 5, 13))

dept.append(Employee("Tyler", "Durden", 5, 12))

# Who's more senior?

print(bool(dept[0] > dept[2]))

print(bool(dept[4] < dept[3]))

# sort the items

emps = sorted(dept)

for emp in emps:

print(emp.lname)

if __name__ == "__main__":

main()

Apoi rularea programelor se face astfel

# customize string representations of objects

class myColor():

def __init__(self):

self.red = 50

self.green = 75

self.blue = 100
 # use getattr to dynamically return a value

def __getattr__(self, attr):

if attr == "rgbcolor":

return (self.red, self.green, self.blue)

elif attr == "hexcolor":

return "#{0:02x}{1:02x}{2:02x}".format(self.red, self.green, self.blue)

else:

raise AttributeError

# use setattr to dynamically return a value

def __setattr__(self, attr, val):

if attr == "rgbcolor":

self.red = val[0]

self.green = val[1]

self.blue = val[2]

else:

super().__setattr__(attr, val)

# use dir to list the available properties

def __dir__(self):

return ("rgbolor", "hexcolor")

def main():

# create an instance of myColor

cls1 = myColor()

# print the value of a computed attribute

print(cls1.rgbcolor)

print(cls1.hexcolor)
 # set the value of a computed attribute

cls1.rgbcolor = (125, 200, 86)

print(cls1.rgbcolor)

print(cls1.hexcolor)

# access a regular attribute

print(cls1.red)

# list the available attributes

print(dir(cls1))

if __name__ == "__main__":

main()

REZULTATUL
# define enumerations using the Enum base class

from enum import Enum, unique, auto

@unique

class Fruit(Enum):

APPLE = 1
 BANANA = 2

ORANGE = 3

TOMATO = 4

PEAR = auto()

def main():

# enums have human-readable values and types

print(Fruit.APPLE)

print(type(Fruit.APPLE))

print(repr(Fruit.APPLE))

# enums have name and value properties

print(Fruit.APPLE.name, Fruit.APPLE.value)

# print the auto-generated value

print(Fruit.PEAR.value)

# enums are hashable - can be used as keys

myFruits = {}

myFruits[Fruit.BANANA] = "Come Mr. Tally-man"

print(myFruits[Fruit.BANANA])

if __name__ == "__main__":

main()

REZULTATUL
# give objects number-like behavior

class Point():

def __init__(self, x, y):

self.x = x

self.y = y
 def __repr__(self):

return "<Point x:{0},y:{1}>".format(self.x, self.y)

# implement addition

def __add__(self, other):

return Point(self.x + other.x, self.y + other.y)

# implement subtraction

def __sub__(self, other):

return Point(self.x - other.x, self.y - other.y)

# implement in-place addition

def __iadd__(self, other):

self.x += other.x

self.y += other.y

return self

def main():

# Declare some points

p1 = Point(10, 20)

p2 = Point(30, 30)

print(p1, p2)

# Add two points

p3 = p1 + p2

print(p3)

# subtract two points

p4 = p2 - p1

print(p4)
 # Perform in-place addition

p1 += p2

print(p1)

if __name__ == "__main__":

main()

REZULTATUL ESTE
# give objects number-like behavior

class Point():

def __init__(self, x, y):

self.x = x

self.y = y
 def __repr__(self):

return "<Point x:{0},y:{1}>".format(self.x, self.y)

# TODO: implement addition

def __add__(self, other):

pass

# TODO: implement subtraction

def __sub__(self, other):

pass

# TODO: implement in-place addition

def __iadd__(self, other):

pass

def main():

# Declare some points

p1 = Point(10, 20)

p2 = Point(30, 30)

print(p1, p2)

# TODO: Add two points

# TODO: subtract two points

# TODO: Perform in-place addition

if __name__ == "__main__":

main()
REZULATATUL

<Point x:10,y:20> <Point x:30,y:30>

# customize string representations of objects

class Person():

def __init__(self):

self.fname = "Joe"

self.lname = "Marini"

self.age = 25

# use __repr__ to create a string useful for debugging

def __repr__(self):

return "<Person Class - fname:{0}, lname:{1}, age{2}>".format(self.fname, self.lname, self.age)

# use str for a more human-readable string

def __str__(self):

return "Person ({0} {1} is {2})".format(self.fname, self.lname, self.age)

# use bytes to convert the informal string to a bytes object

def __bytes__(self):

val = "Person:{0}:{1}:{2}".format(self.fname, self.lname, self.age)

return bytes(val.encode('utf-8'))

def main():

# create a new Person object

cls1 = Person()
 # use different Python functions to convert it to a string

print(repr(cls1))

print(str(cls1))

print("Formatted: {0}".format(cls1))

print(bytes(cls1))

if __name__ == "__main__":

main()

REZULTATUL ESTE

<Person Class - fname:Joe, lname:Marini, age25>

Person (Joe Marini is 25)

Formatted: Person (Joe Marini is 25)

b'Person:Joe:Marini:25'

from collections import defaultdict

def main():

# define a list of items that we want to count

fruits = ['apple', 'pear', 'orange', 'banana',

'apple', 'grape', 'banana', 'banana']

# use a dictionary to count each element

fruitCounter = defaultdict(int)
 # Count the elements in the list

for fruit in fruits:

fruitCounter[fruit] += 1

# print the result

for (k, v) in fruitCounter.items():

print(k + ": " + str(v))

if __name__ == "__main__":

main()

REZULTATUL

apple: 2

pear: 1

orange: 1

banana: 3

grape: 1

import collections

import string

def main():

# initialize a deque with lowercase letters

d = collections.deque(string.ascii_lowercase)

# deques support the len() function

print("Item count: " + str(len(d)))

 # deques can be iterated over

for elem in d:

print(elem.upper(), end=",")

# manipulate items from either end

d.pop()

d.popleft()

d.append(2)

d.appendleft(1)

print(d)

# rotate the deque

print(d)

d.rotate(1)

print(d)

if __name__ == "__main__":

main()

REZULTAT

Item count: 26

A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,deque([1, 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 2])

deque([1, 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 2])

deque([2, 1, 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y'])

FUNCTII
def myFunction(arg1, arg2=None):

print(arg1, arg2)

def main():

print(myFunction.__doc__)

if __name__ == "__main__":

main()

REZULTA

None

def myFunction(arg1, arg2, *, suppressExceptions=False):

print(arg1, arg2, suppressExceptions)

def main():

# try to call the function without the keyword

# myFunction(1, 2, True)

myFunction(1, 2, suppressExceptions=True)

if __name__ == "__main__":

main()

REZULTA

1 2 True
def CelsisusToFahrenheit(temp):

return (temp * 9/5) + 32

def FahrenheitToCelsisus(temp):

return (temp-32) * 5/9

def main():

ctemps = [0, 12, 34, 100]

ftemps = [32, 65, 100, 212]

# Use regular functions to convert temps

print(list(map(FahrenheitToCelsisus, ftemps)))

print(list(map(CelsisusToFahrenheit, ctemps)))

# Use lambdas to accomplish the same thing

print(list(map(lambda t: (t-32) * 5/9, ftemps)))

print(list(map(lambda t: (t * 9/5) + 32, ctemps)))

if __name__ == "__main__":

main()

REZULTA

[0.0, 18.333333333333332, 37.77777777777778, 100.0]

[32.0, 53.6, 93.2, 212.0]

[0.0, 18.333333333333332, 37.77777777777778, 100.0]

[32.0, 53.6, 93.2, 212.0]

liste

def demo_if():

testGrade = 95

# Ex: if

if testGrade>85:

print("You did good!")

else:

print("You did not work hard!")

# Ex: elif

if testGrade > 94:

print("You did awesome!")

elif testGrade > 85:

print("You did good!")

else:

print("You did not work hard!")

# Ex: multiple operators

if ((testGrade >= 90) and (testGrade <= 95)):

print("You almost reached excellence!")

def demo_lists():

#Create, print entire list & just first friend

print('Create, print entire list & just first friend')

print('---------------------------------------------')
 friend_list = ['Sky', 'Marcel', 'Robin',

'Khaleel', 'Connie']

print('All Friends =', friend_list)

print('First Friend =', friend_list[0])

#Change value

friend_list[0] = "Taylor"

print('First Friend with name change =', friend_list[0])

#Print partial list

print('Partial list of friends =' + str(friend_list[2:5]))

#List within lists

family_list = ['Mom', 'Dad', 'Cousin']

people_list = [friend_list,family_list]

print('\nWrite out people_list:')

print('-----------------------')

print(people_list)

print('\nWrite 3rd element from 2nd list:')

print('-----------------------------------')

print('Third person in 2nd list is:' + (people_list[1][2]))

def main():

#demo_if()

demo_lists()

if __name__ =="__main__":

main()
def demo_if():

testGrade = 95

# Ex: if

if testGrade>85:
 print("You did good!")

else:

print("You did not work hard!")

# Ex: elif

if testGrade > 94:

print("You did awesome!")

elif testGrade > 85:

print("You did good!")

else:

print("You did not work hard!")

# Ex: multiple operators

if ((testGrade >= 90) and (testGrade <= 95)):

print("You almost reached excellence!")

def demo_lists():

#Create, print entire list & just first friend

print('Create, print entire list & just first friend')

print('---------------------------------------------')

friend_list = ['Sky', 'Marcel', 'Robin',

'Khaleel', 'Connie']

print('All Friends =', friend_list)

print('First Friend =', friend_list[0])

#Change value

friend_list[0] = "Taylor"

print('First Friend with name change =', friend_list[0])

#Print partial list

print('Partial list of friends =' + str(friend_list[2:5]))

 #List within lists

family_list = ['Mom', 'Dad', 'Cousin']

people_list = [friend_list,family_list]

print('\nWrite out people_list:')

print('-----------------------')

print(people_list)

print('\nWrite 3rd element from 2nd list:')

print('-----------------------------------')

print('Third person in 2nd list is:' + (people_list[1][2]))

def demo_for_loops():

#Print from 0 to 4

print("\n*Print from 0 to 4")

for i in range(0,5):

print(i, ' ', end="")

#Print list using 'for'

print("\n*Print list using 'for'")

friend_list = ['Sky', 'Marcel', 'Robin','Khaleel', 'Connie']

for list in friend_list:

print(list)

#List within list aka 2-dimensional array

print("\n*Printing nested loop")

array_of_people = [["Robin", "Khaleel", "Connie"],["Mom","Dad","Sister"]]

for x in range(0,2):

for y in range(0,3):

print(array_of_people[x][y])

#Continue, Break
 my_items = ['answer', 'amazon', 'banana', 'badger', 'clementine',

'camel']

print("\n*Ex: 'continue' from list: " + str(my_items))

for item in my_items:

if item.startswith('b'):

continue

print(item)

print("\n*Ex: 'break' from list: " + str(my_items))

for item in my_items:

if item.startswith('b'):

break

print(item)

def main():

#demo_if()

#demo_lists()

demo_for_loops()

if __name__ =="__main__":

main()
def demo_if():

testGrade = 95

# Ex: if

if testGrade>85:

print("You did good!")

 else:

print("You did not work hard!")

# Ex: elif

if testGrade > 94:

print("You did awesome!")

elif testGrade > 85:

print("You did good!")

else:

print("You did not work hard!")

# Ex: multiple operators

if ((testGrade >= 90) and (testGrade <= 95)):

print("You almost reached excellence!")

def demo_lists():

#Create, print entire list & just first friend

print('Create, print entire list & just first friend')

print('---------------------------------------------')

friend_list = ['Sky', 'Marcel', 'Robin',

'Khaleel', 'Connie']

print('All Friends =', friend_list)

print('First Friend =', friend_list[0])

#Change value

friend_list[0] = "Taylor"

print('First Friend with name change =', friend_list[0])

#Print partial list

print('Partial list of friends =' + str(friend_list[2:5]))

 #List within lists

family_list = ['Mom', 'Dad', 'Cousin']

people_list = [friend_list,family_list]

print('\nWrite out people_list:')

print('-----------------------')

print(people_list)

print('\nWrite 3rd element from 2nd list:')

print('-----------------------------------')

print('Third person in 2nd list is:' + (people_list[1][2]))

def demo_for_loops():

#Print from 0 to 4

print("\n*Print from 0 to 4")

for i in range(0,5):

print(i, ' ', end="")

#Print list using 'for'

print("\n*Print list using 'for'")

friend_list = ['Sky', 'Marcel', 'Robin','Khaleel', 'Connie']

for list in friend_list:

print(list)

#List within list aka 2-dimensional array

print("\n*Printing nested loop")

array_of_people = [["Robin", "Khaleel", "Connie"],["Mom","Dad","Sister"]]

for x in range(0,2):

for y in range(0,3):

print(array_of_people[x][y])

#Continue, Break

my_items = ['answer', 'amazon', 'banana', 'badger', 'clementine',

 'camel']

print("\n*Ex: 'continue' from list: " + str(my_items))

for item in my_items:

if item.startswith('b'):

continue

print(item)

print("\n*Ex: 'break' from list: " + str(my_items))

for item in my_items:

if item.startswith('b'):

break

print(item)

def demo_while_loops():

print("\n*While loop demo")

x=0

while (x < 5):

print("Today, I've got time, son!")

x=x+1

def main():

#demo_if()

#demo_lists()

#demo_for_loops()

demo_while_loops()

if __name__ =="__main__":

main()
def demo_if():

testGrade = 95

# Ex: if

if testGrade>85:

print("You did good!")

else:
 print("You did not work hard!")

# Ex: elif

if testGrade > 94:

print("You did awesome!")

elif testGrade > 85:

print("You did good!")

else:

print("You did not work hard!")

# Ex: multiple operators

if ((testGrade >= 90) and (testGrade <= 95)):

print("You almost reached excellence!")

def demo_lists():

#Create, print entire list & just first friend

print('Create, print entire list & just first friend')

print('---------------------------------------------')

friend_list = ['Sky', 'Marcel', 'Robin',

'Khaleel', 'Connie']

print('All Friends =', friend_list)

print('First Friend =', friend_list[0])

#Change value

friend_list[0] = "Taylor"

print('First Friend with name change =', friend_list[0])

#Print partial list

print('Partial list of friends =' + str(friend_list[2:5]))

#List within lists

 family_list = ['Mom', 'Dad', 'Cousin']

people_list = [friend_list,family_list]

print('\nWrite out people_list:')

print('-----------------------')

print(people_list)

print('\nWrite 3rd element from 2nd list:')

print('-----------------------------------')

print('Third person in 2nd list is:' + (people_list[1][2]))

def demo_for_loops():

#Print from 0 to 4

print("\n*Print from 0 to 4")

for i in range(0,5):

print(i, ' ', end="")

#Print list using 'for'

print("\n*Print list using 'for'")

friend_list = ['Sky', 'Marcel', 'Robin','Khaleel', 'Connie']

for list in friend_list:

print(list)

#List within list aka 2-dimensional array

print("\n*Printing nested loop")

array_of_people = [["Robin", "Khaleel", "Connie"],["Mom","Dad","Sister"]]

for x in range(0,2):

for y in range(0,3):

print(array_of_people[x][y])

#Continue, Break

my_items = ['answer', 'amazon', 'banana', 'badger', 'clementine',

'camel']
 print("\n*Ex: 'continue' from list: " + str(my_items))

for item in my_items:

if item.startswith('b'):

continue

print(item)

print("\n*Ex: 'break' from list: " + str(my_items))

for item in my_items:

if item.startswith('b'):

break

print(item)

def demo_while_loops():

print("\n*While loop demo")

x=0

while (x < 5):

print("Today, I've got time, son!")

x=x+1

def demo_dictonary():

favorite_movie = {'Reynald' : 'Titanic',

'Marcel' : 'Enter the Dragon',

'Khaleel' : 'The Notebook',

'Connie' : 'Superman'}

print("No shame, Reynald's fav movie is " + favorite_movie['Reynald'])

print(favorite_movie) #print entire dictionary

del favorite_movie['Connie'] #delete value

favorite_movie['Khaleel'] = "Star Wars" #replace value

 print("\nReprinting dictionary after modifications")

print(favorite_movie) #reprint entire dictionary

def main():

#demo_if()

#demo_lists()

#demo_for_loops()

#demo_while_loops()

demo_dictonary()

if __name__ =="__main__":

main()
import random

import sys

import os

# Chapter 4

def demoIf():

#Traditional if/else

age = 35
 if age !=35:

print("A value was given ")

name = "Reynald"

if not name:

print("The 'if' condition evaluated to true")

else:

print("The 'if' condition evaluated to false")

#Ternary operator

isAgeGreaterThan25 = True if age > 24 else False

print("isAgeGreaterThan25=" + str(isAgeGreaterThan25))

def demoLists():

#Create, print entire list & just first friend

friend_list = ['Sky', 'Marcel', 'Robin',

'Khaleel', 'Connie']

print('All Friends =', friend_list)

print('First Friend =', friend_list[0])

#Change value

friend_list[0] = "Taylor"

print('First Friend with name change =', friend_list[0])

#Print partial list

print('Partial list of friends =' + str(friend_list[2:5]))

#list within lists

family_list = ['Mom', 'Dad', 'Cousin']

people_list = [friend_list,family_list]

print(people_list)
 print('Third person in 2nd list is: ' + str((people_list[1][2])))

def demoForLoops():

#Print from 0 to 4

print("\n*Print from 0 to 4")

for i in range(0,5):

print(i, ' ', end="")

#Print list using 'for'

print("\n*Print list using 'for'")

friend_list = ['Sky', 'Marcel', 'Robin','Khaleel', 'Connie']

for list in friend_list:

print(list)

#List within list aka 2-dimensional array

print("\n*Printing nested loop")

arrayOfPeople = [["Robin", "Khaleel", "Connie"],["Mom","Dad","Sister"]]

for x in range(0,2):

for y in range(0,3):

print(arrayOfPeople[x][y])

def demoWhileLoops():

print("\n*While loop demo")

x=0

while x < 5:

print("Today, I've got time, son.")

x=x+1

def demoDictionary():

favorite_movie = {'Reynald' : 'Titanic',

'Marcel' : 'Enter the Dragon',

'Khaleel' : 'The Notebook',

 'Connie' : 'Superman'}

print("No shame, Reynald's fav movie is " + favorite_movie['Reynald'])

print(favorite_movie) #print entire dictionary

del favorite_movie['Connie'] #delete value

favorite_movie['Khaleel'] = "Star Wars" #replace value

print("\nReprinting dictionary after modifications")

print(favorite_movie) #reprint entire dictionary

def main():

#demoIf()

#demoLists()

#demoForLoops()

#demoWhileLoops()

demoDictionary()

if __name__== "__main__":

main()
APLICATII DIVERSE

MULTIMI

Created on Mar 31, 2018

# ------------ Sets ------------

number_set = {1, 2, 3, 4} # sets use curly braces for creation

letter_set = {'a', 'b', 'c', 'd'}

mixed_set = {1, 'a', 2, (1, 2, 3)} # types must be "hashable", i.e. immutable

empty_set = set() # have to use the set() function, cannot use = {}

print(number_set)

print(letter_set)

print(mixed_set)

print(empty_set) # returns: set(). {} would be a dict, not a set

print(type(number_set)) # <class 'set'>

number_set_unique = {1, 2, 3, 4, 2, 3, 4} # sets only store unique values

print(number_set_unique) # {1, 2, 3, 4}, ignores dupes

number_set.add(5) # add an item to the set

print(number_set)

number_set.add(4) # try to add existing item to the set

number_set.add(5) # try to add existing item to the set

print(number_set) # no duplicates, nothing got added

number_set.remove(1) # remove an item from the set

print(number_set)
try: # if the item is not in the set

number_set.remove(98) # KeyError: 98

except Exception as e:

print('** caught Exception:', e)

# use the 'in' keyword

print(98 in number_set) # False

print(5 in number_set) # True

Created on Mar 31, 2018
# ------------ Lists ------------

number_list = [1, 2, 3, 4] # lists use square brackets for creation

letter_list = ['a', 'b', 'c', 'd']

mixed_list = [1, 'a', 2, [1, 2, 3, 4]] # can also nest lists within lists

print(number_list)

print(letter_list)

print(mixed_list)

print(type(number_list)) # <class 'list'>

original_value = number_list[0] # save value at index 0

number_list[0] = 9 # lists are mutable, can change items once assigned

print(number_list)

number_list[0] = original_value # reassign original value

print(number_list)

number_list.append(5) # add item to list via append

print(number_list)

number_list += [6] # add item to list via operator

print(number_list)

new_number_list = number_list[:] # copy entire list via slicing

print(new_number_list)

print(id(number_list)) # different ids

print(id(new_number_list))

print()
other_number_list = number_list # create second reference to same list object

print(id(number_list)) # same ids

print(id(other_number_list)) # pointing to the same object

number_list.append(99) # append to first list

print(other_number_list) # second list also shows the new value

print(number_list[:]) # slice operator - entire list

print(number_list[1:3]) # start at element 1, end at 3 (exclusive)

print(number_list[3:]) # start at element 3 until the end (inclusive)

Created on Mar 31, 2018
# ------------ Tuples ------------

number_tuple = (1, 2, 3, 4) # tuples use parentheses for creation

letter_tuple = ('a', 'b', 'c', 'd')

mixed_tuple = (1, 'a', 2, 'b', [88, 99]) # can mix different types

print(number_tuple)

print(letter_tuple)

print(mixed_tuple)

print(type(number_tuple)) # <class 'tuple'>

try:

number_tuple[0] = 9 # tuples are immutable, can't change items once assigned

except Exception as e:

print('** caught Exception:', e) # TypeError: 'tuple' object does not support item assignment

try: # try to add item to tuples by creating a new tuple

new_number_tuple = number_tuple + (5) # TypeError: can only concatenate tuple (not "int") to
tuple

except Exception as e:

print('** caught Exception:', e)

new_number_tuple = number_tuple + (5,) # have to add a comma to make it a tuple

print(new_number_tuple)

number_tuple = number_tuple + (5,) # if we reassign to original tuple value,

print(number_tuple) # it appears as if we are updating it

print(id(number_tuple)) # but they are two different objects

number_tuple = number_tuple + (6,)

print(id(number_tuple)) # the variable name is now pointing to a new object

print(number_tuple[:]) # slice operator - entire tuple

print(number_tuple[1:3]) # start at element 1, end at 3 (exclusive)

print(number_tuple[3:]) # start at element 3 until the end (inclusive)

APAS ATCH
SE POATE SI DIRECT

SAU CLICK DREAPTA

GRAFICA

import turtle

t = turtle.Pen()
import turtle

t = turtle.Pen()

t.forward(50)

import turtle

t = turtle.Pen()

t.forward(50)
t.left(90)

import turtle

t = turtle.Pen()

t.forward(50)

t.left(90)

t.forward(50)

t.left(90)

t.forward(50)

t.left(90)

t.forward(50)

t.left(90)
import turtle

t = turtle.Pen()

t.forward(50)

t.left(90)

t.forward(50)

t.left(90)

t.forward(50)

t.left(90)

t.forward(50)

t.left(90)

t.clear()
import turtle

t = turtle.Pen()

t.forward(50)

t.left(90)

t.forward(50)

t.left(90)

t.forward(50)

t.left(90)

t.forward(50)

t.left(90)

t.clear()

t.reset()

t.backward(100)

t.right(90)

t.up()

t.down()
import time

print(time.localtime())

import time

print(time.localtime())

t = time.localtime()

print(time.asctime(t))

import time
print(time.localtime())

t = time.localtime()

print(time.asctime(t))

print(time.asctime(time.localtime()))

GRAFICA

import turtle

t = turtle.Pen()

t.left(90)

t.forward(50)

t.left(90)

t.forward(50)

t.left(90)

import turtle

t = turtle.Pen()

t.color(1,0,0)

t.begin_fill()

t.forward(100)

t.left(90)
t.forward(20)

t.left(90)

t.forward(20)

t.right(90)

t.forward(20)

t.left(90)

t.forward(60)

t.left(90)

t.forward(20)

t.right(90)

t.forward(20)

t.left(90)

t.forward(20)

t.end_fill()

t.color(0,0,0)

t.up()

t.forward(10)

t.down()

t.begin_fill()

t.circle(10)

t.end_fill()

t.setheading(0)

t.up()

t.forward(90)

t.right(90)

t.forward(10)

t.setheading(0)

t.begin_fill()

t.down()

t.circle(10)

t.end_fill()
import turtle

t = turtle.Pen()

t.color(1,1,0)

t.begin_fill()

t.circle(50)

t.end_fill()
import turtle

t = turtle.Pen()

t.forward(50)

t.left(90)

t.forward(50)

t.left(90)

t.forward(50)

t.left(90)

t.forward(5)
programare pe obiecte

CLASE

# Step 1 - Create abstract base class

class employee():

def determine_weekly_salary(self, weeklyHours, wage):

raise NotImplementedError("This abstract method must be implmented by subclass")

# Step 2 - Inherit from base & define calculation for permanent employee

class permanent(employee):

def determine_weekly_salary(self, weeklyHours, wage):

salary = 40 * wage

print("\nThis ANGRY EMPLOYEE worked " + str(weeklyHours) +

 " hrs. Paid for 40 hrs (no overtime) at $ " + str(wage) +

"/hr = $"+ str(salary) + " \n")

# Step 3 - Inherit from base & define calculation for contractor

class contractor(employee):

def determine_weekly_salary(self, weeklyHours, wage):

salary = weeklyHours * wage

print("\nThis HAPPY CONTRACTOR worked " + str(weeklyHours) +

" hrs. Paid for "+ str(weeklyHours) +" hrs (w/ overtime) at $ " +

str(wage) + "/hr = $"+ str(salary) + " \n")

# Step 4 - Create permanent / contractor objects & list

def get_employees():

some_permanent_employee = permanent()

some_contractor = contractor()

everyone = [some_permanent_employee,some_contractor]

return everyone

# Step 5 - Polymorphically calculate salaries

def main():

hours = 50; wage = 70

employees = get_employees()

for e in employees:

e.determine_weekly_salary(hours, wage)

if __name__== "__main__":

main()
class employee:

__name = "" # an attribute

# Constructor

def __init__(self, name):

self.__name = name

# Getter & Setter

 @property

def employee_name(self):

return self.__name.upper()

@employee_name.setter

def employee_name(self, value):

self.__name = value + " (Name changed. Someone quit!)"

# Write employee name

def getIntro(self):

return "Name of employee is {}.".format(self.employee_name)

def demo_class():

#Create employee object

e = employee('James')

e.employee_name="rey"

print(e.getIntro())

def main():

demo_class()

if __name__ =="__main__":

main()
PROGRAM PRINCIPAL

# Chapter Sample

#TODO

def main():

print("Rise & Shine!!!")

if __name__== "__main__":
 main()

import random

import sys

import os

# Chapter 5 - Creating & working w/ Classes

# Create the class

class Employee:

__name = "" # an attribute

 # Constructor

def __init__(self, name):

self.__name = name #When values are passed in, define them.

# Getter & Setter

def set_name(self, name):

self.__name = name

def get_name(self):

return self.__name.upper()

# Write employee name

def getIntro(self):

return "Name of employee is {}. ".format(self.get_name())

def main():

#Create employee object

anEmployee = Employee('james')

# Execute code

print(anEmployee.getIntro())

if __name__== "__main__":

main()
ESTE ECHIVALENTUL Python

Created on Apr 20, 2018

import random

from pprint import pprint

suits = ['Clubs', 'Spades', 'Hearts', 'Diamonds']

deck = [ (suit, rank) for suit in suits for rank in range(1, 14) ] # list comprehension

pprint(deck)

random.shuffle(deck)

pprint(deck)

card = deck.pop()

print('card drawn from top of deck is: ', card)

random_card = deck.pop(random.randint(0, len(deck) -1))

print('random card drawn is: ', random_card)

executia este

[('Clubs', 1),

('Clubs', 2),

('Clubs', 3),

('Clubs', 4),

('Clubs', 5),
('Clubs', 6),

('Clubs', 7),

('Clubs', 8),

('Clubs', 9),

('Clubs', 10),

('Clubs', 11),

('Clubs', 12),

('Clubs', 13),

('Spades', 1),

('Spades', 2),

('Spades', 3),

('Spades', 4),

('Spades', 5),

('Spades', 6),

('Spades', 7),

('Spades', 8),

('Spades', 9),

('Spades', 10),

('Spades', 11),

('Spades', 12),

('Spades', 13),

('Hearts', 1),

('Hearts', 2),

('Hearts', 3),

('Hearts', 4),

('Hearts', 5),

('Hearts', 6),

('Hearts', 7),

('Hearts', 8),

('Hearts', 9),

('Hearts', 10),
('Hearts', 11),

('Hearts', 12),

('Hearts', 13),

('Diamonds', 1),

('Diamonds', 2),

('Diamonds', 3),

('Diamonds', 4),

('Diamonds', 5),

('Diamonds', 6),

('Diamonds', 7),

('Diamonds', 8),

('Diamonds', 9),

('Diamonds', 10),

('Diamonds', 11),

('Diamonds', 12),

('Diamonds', 13)]

[('Hearts', 12),

('Diamonds', 5),

('Spades', 6),

('Hearts', 9),

('Spades', 9),

('Hearts', 5),

('Spades', 5),

('Hearts', 1),

('Hearts', 13),

('Diamonds', 6),

('Hearts', 10),

('Diamonds', 9),

('Clubs', 1),

('Spades', 3),

('Diamonds', 10),
('Clubs', 11),

('Diamonds', 4),

('Hearts', 3),

('Spades', 7),

('Clubs', 3),

('Clubs', 5),

('Spades', 12),

('Hearts', 2),

('Diamonds', 12),

('Hearts', 7),

('Spades', 4),

('Diamonds', 11),

('Spades', 10),

('Diamonds', 7),

('Hearts', 6),

('Diamonds', 1),

('Spades', 8),

('Clubs', 2),

('Clubs', 10),

('Diamonds', 8),

('Spades', 13),

('Clubs', 8),

('Diamonds', 3),

('Hearts', 11),

('Hearts', 4),

('Clubs', 12),

('Clubs', 4),

('Clubs', 6),

('Diamonds', 2),

('Hearts', 8),

('Clubs', 9),
('Spades', 1),

('Clubs', 13),

('Spades', 2),

('Diamonds', 13),

('Clubs', 7),

('Spades', 11)]

card drawn from top of deck is: ('Spades', 11)

random card drawn is: ('Diamonds', 10)

Created on May 2, 2018

# single inheritance

class Building():

def __init__(self, type_of, name):

self.type_of_building = type_of

self.name_of_building = name

def build(self):

print('building a {}...'.format(self.type_of_building))

def visit(self):

print('Welcome to {}'.format(self.name_of_building))

def info(self):
 return self.build(), self.visit()

class Cathedral(Building):

pass

class Cafe(Building):

pass

notre_dame = Cathedral('Cathedral', 'Notre-Dame de Paris')

notre_dame.info()

print()

Cafe('Cafe', 'The Java House').info()

Created on May 2, 2018
# Inheritance: 'is-a'

# Composition: 'has-a'

class Engine():

def __init__(self, engine_type='[unknown]'):

self.engine_type = engine_type

class Vehicle():

def __init__(self, seats=1):

self.number_of_seats = seats

class Airplane(Vehicle): # Airplane is-a Vehicle

def __init__(self, model, engine, seats=1):

super().__init__(seats)

self.airplane_model = model

self.airplane_engine = Engine(engine) # Airplane has an Engine

def airplane_info(self):

print('{} with \n{} type of engine and \n{} passenger seats\n'.\

format(self.airplane_model,

self.airplane_engine.engine_type,

self.number_of_seats))

boing = Airplane(model='Boing 787 Dreamliner',

engine='Rolls-Royce Trent 1000',

 seats=300)

airbus = Airplane(model='Airbus A350',

engine='Rolls-Royce Trent XWB',

seats=299)

for plane in (boing, airbus):

plane.airplane_info()
programare vizuala cu obiecte

realizarea unei ferestre

Created on May 7, 2018

import tkinter

tkinter.Tk().mainloop()

Created on May 7, 2018

import tkinter as tk # alias tkinter as "tk"

from tkinter import ttk # ttk == "themed tk"

gui = tk.Tk() # create Tk() instance and assign to variable

ttk.Label(gui, text="Hello Label").\

grid(row=0, column=0) # create a themed tk label

ttk.Button(gui, text="Click Me!").\

grid(row=0, column=1) # gui is the parent for the widgets

tk.Entry(gui).\

grid(row=0, column=2) # using grid layout manager

gui.mainloop() # start the main event loop to display our gui

Created on May 7, 2018

import tkinter as tk

from tkinter import ttk

gui = tk.Tk()

ttk.Label(gui, text="Hello Label").\

 grid(row=0, column=0)

ttk.Button(gui, text="Click Me!").\

grid(row=0, column=1)

tk.Entry(gui, textvariable=tk.StringVar(value=" <default entry>")).\

grid(row=0, column=2)

gui.mainloop()

o ferestra cu titlu

Created on May 7, 2018

import tkinter as tk

from tkinter import ttk

gui = tk.Tk()

gui.title("Our GUI Title")

ttk.Label(gui, text="Hello Label").\

grid(row=0, column=0)

ttk.Button(gui, text="Click Me!").\

grid(row=0, column=1)

tk.Entry(gui, textvariable=tk.StringVar(value=" <default entry>")).\

grid(row=0, column=2)

for child in gui.winfo_children(): # loop through gui children

child.grid_configure(padx=10, pady=10) # add x, y padding to each

gui.mainloop()

Created on May 7, 2018

import tkinter as tk

from tkinter import ttk

gui = tk.Tk()

gui.title("Our GUI Title")

frame = ttk.LabelFrame(gui, text="A frame surrounding widgets") # gui is parent of frame

frame.pack(padx=10, pady=5)

ttk.Label(frame, text="Hello Label").\

grid(row=0, column=0) # frame is parent

ttk.Button(frame, text="Click Me!").\

grid(row=0, column=1)

tk.Entry(frame, textvariable=tk.StringVar(value=" <default entry>")).\

grid(row=0, column=2)

for child in frame.winfo_children():

child.grid_configure(padx=10, pady=10)

gui.mainloop()

eticheta active
Created on May 7, 2018

import tkinter as tk

from tkinter import ttk

gui = tk.Tk()

gui.title("Our GUI Title")

frame = ttk.LabelFrame(gui, text="A frame surrounding widgets")

frame.pack(padx=10, pady=5)

ttk.Label(frame, text="Hello Label").\

grid(row=0, column=0)

def button_callback():

entry.config(textvariable=tk.StringVar(value=' Button was clicked!'))

ttk.Button(frame, text="Click Me!", command=button_callback).\

 grid(row=0, column=1)

entry = tk.Entry(frame, textvariable=tk.StringVar(value=" <default entry>"))

entry.grid(row=0, column=2)

for child in frame.winfo_children():

child.grid_configure(padx=10, pady=10)

gui.mainloop()

Created on May 7, 2018

import tkinter as tk

from tkinter import ttk

gui = tk.Tk()

gui.title("Our GUI Title")

frame = ttk.LabelFrame(gui, text="A frame surrounding widgets")

frame.pack(padx=10, pady=5)

entry_list = []

def button_callback(idx):

entry_list[idx].config(textvariable=tk.StringVar(value=' Button {} was clicked!'.\

format(idx)))

for idx in range(4):

ttk.Label(frame, text="Hello Label " + str(idx)).\

grid(row=idx, column=0)

ttk.Button(frame, text="Click Me " + str(idx), command= lambda cur_idx=idx:

button_callback(cur_idx)).\

grid(row=idx, column=1)

entry_var = "entry" + str(idx)

entry_var = tk.Entry(frame, textvariable=tk.StringVar(value=" <default entry> " + str(idx)))

entry_var.grid(row=idx, column=2)

entry_list.append(entry_var)

for child in frame.winfo_children():

child.grid_configure(padx=8, pady=3)

gui.mainloop()
Created on May 7, 2018

import tkinter as tk

from tkinter import ttk

gui = tk.Tk()

gui.title("Our GUI Title")

frame = ttk.LabelFrame(gui, text="A frame surrounding widgets")

frame.pack(padx=10, pady=5)

entry_list = []

label_list = []

def button_callback(idx):

entry_list[idx].config(textvariable=tk.StringVar(value=' Button {} was clicked!'.\

format(idx)))

label_list[idx].config(foreground='red')
for idx in range(4):

lbl_var = "label" + str(idx)

lbl_var = ttk.Label(frame, text="Hello Label " + str(idx))

lbl_var.grid(row=idx, column=0)

label_list.append(lbl_var)

ttk.Button(frame, text="Click Me " + str(idx), command= lambda cur_idx=idx:

button_callback(cur_idx)).\

grid(row=idx, column=1)

entry_var = "entry" + str(idx)

entry_var = tk.Entry(frame, textvariable=tk.StringVar(value=" <default entry> " + str(idx)))

entry_var.grid(row=idx, column=2)

entry_list.append(entry_var)

for child in frame.winfo_children():

child.grid_configure(padx=8, pady=3)

gui.mainloop()
Created on May 7, 2018

import tkinter as tk

from tkinter import ttk

gui = tk.Tk()

gui.title("Our GUI Title")

frame = ttk.LabelFrame(gui, text="A frame surrounding widgets")

frame.pack(padx=10, pady=5)

entry_list = []

label_list = []

def button_callback(idx):

entry_list[idx].config(textvariable=tk.StringVar(value=' Button {} was clicked!'.\

format(idx)))

label_list[idx].config(foreground='red')

text.insert(tk.END, entry_list[idx].get() + '\n')

for idx in range(4):

lbl_var = "label" + str(idx)

lbl_var = ttk.Label(frame, text="Hello Label " + str(idx))

lbl_var.grid(row=idx, column=0)

label_list.append(lbl_var)

ttk.Button(frame, text="Click Me " + str(idx), command= lambda cur_idx=idx:

button_callback(cur_idx)).\

grid(row=idx, column=1)

entry_var = "entry" + str(idx)

entry_var = tk.Entry(frame, textvariable=tk.StringVar(value=" <default entry> " + str(idx)))

entry_var.grid(row=idx, column=2)

entry_list.append(entry_var)

for child in frame.winfo_children():

child.grid_configure(padx=8, pady=3)
frame_2 = ttk.LabelFrame(gui, text="Another frame")

frame_2.pack(padx=10, pady=5)

text = tk.Text(frame_2, height=15, width=40)

text.pack()

# text.grid(row=0, column=0) # use pack or grid layout mgr

gui.mainloop()

Created on May 8, 2018

import tkinter as tk

from tkinter import ttk

gui = tk.Tk()

gui.title("Our GUI Title")

frame = ttk.LabelFrame(gui, text="A frame surrounding widgets")

frame.pack(padx=10, pady=5)

entry_list = []

label_list = []

def button_callback(idx):

entry_list[idx].config(textvariable=tk.StringVar(value=' Button {} was clicked!'.\

format(idx)))

label_list[idx].config(foreground='green')

text1.insert(tk.END, entry_list[idx].get() + '\n')

if idx == 0:

progress_bar.start()

text2.insert(tk.END, ' starting Progressbar...\n')

label_list[idx].config(text='Running...')

elif idx ==1:

progress_bar.stop()

text2.insert(tk.END, ' stopping Progressbar...\n')

label_list[idx].config(text='Stopped...')
button_names = [

'Start Progress',

'Stop Progress',

'Button 2',

'Button 3']

for idx in range(4):

lbl_var = "label" + str(idx)

lbl_var = ttk.Label(frame, text="Hello Label " + str(idx))

lbl_var.grid(row=idx, column=0)

label_list.append(lbl_var)

ttk.Button(frame, text=button_names[idx], command= lambda cur_idx=idx:

button_callback(cur_idx)).\

grid(row=idx, column=1)

entry_var = "entry" + str(idx)

entry_var = tk.Entry(frame, textvariable=tk.StringVar(value=" <default entry> " + str(idx)))

entry_var.grid(row=idx, column=2)

entry_list.append(entry_var)

for child in frame.winfo_children():

child.grid_configure(padx=8, pady=3)

frame_2 = ttk.LabelFrame(gui, text="Another frame")

frame_2.pack(padx=10, pady=5)

paned = tk.PanedWindow(frame_2, sashwidth=4, relief='solid',

orient='vertical')
paned.pack()

text1 = tk.Text(paned, height=8, width=40)

paned.add(text1)

text2 = tk.Text(paned, height=8, width=40)

paned.add(text2)

gui.update()

gui_width = gui.winfo_width()

progress_bar = ttk.Progressbar(gui, length=gui_width, mode='determinate')

progress_bar.pack()

gui.mainloop()
Created on May 8, 2018

import tkinter as tk

from tkinter import ttk

gui = tk.Tk()

gui.title("Our GUI Title")

frame = ttk.LabelFrame(gui, text="A frame surrounding widgets")

frame.pack(padx=10, pady=5)

entry_list = []

label_list = []

def button_callback(idx):

label_list[idx].config(foreground='green')

text1.insert(tk.END, entry_list[idx].get() + '\n')

if idx == 0:

progress_bar.start()

text2.insert(tk.END, ' starting Progressbar...\n')

label_list[idx].config(text='Running...')

elif idx ==1:

progress_bar.stop()

text2.insert(tk.END, ' stopping Progressbar...\n')

label_list[idx].config(text='Stopped...')

button_names = [

'Start Progress',

'Stop Progress',

'Button 2',

'Button 3']

for idx in range(4):

lbl_var = "label" + str(idx)

lbl_var = ttk.Label(frame, text="Hello Label " + str(idx))

lbl_var.grid(row=idx, column=0)

label_list.append(lbl_var)
 ttk.Button(frame, text=button_names[idx], command= lambda cur_idx=idx:
button_callback(cur_idx)).\

grid(row=idx, column=1)

entry_var = "entry" + str(idx)

entry_var = tk.Entry(frame, textvariable=tk.StringVar(value=" <default entry> " + str(idx)))

entry_var.grid(row=idx, column=2)

entry_list.append(entry_var)

for child in frame.winfo_children():

child.grid_configure(padx=8, pady=3)

frame_2 = ttk.LabelFrame(gui, text="Another frame")

frame_2.pack(padx=10, pady=5)

paned = tk.PanedWindow(frame_2, sashwidth=4, relief='solid',

orient='vertical')

paned.pack()

text1 = tk.Text(paned, height=8, width=40)

paned.add(text1)

text2 = tk.Text(paned, height=8, width=40)

paned.add(text2)

gui.update()

gui_width = gui.winfo_width()

progress_bar = ttk.Progressbar(gui, length=gui_width, mode='determinate')

progress_bar.pack()
gui.mainloop()

Created on May 8, 2018

import tkinter as tk

from tkinter import ttk

gui = tk.Tk()

gui.title("GUI")

tabs_frame = ttk.Frame(gui)

tabs_frame.grid(row=0, column=0, sticky='W')

display_area = ttk.Labelframe(gui, text=' Tab Display Area ')

display_area.grid(row=1, column=0, sticky='WE')

note1 = ttk.Notebook(tabs_frame)

note1.grid(row=0, column=0)
note2 = ttk.Notebook(tabs_frame)

note2.grid(row=1, column=0)

# create and add tabs to Notebooks

for tab_no in range(5):

tab1 = ttk.Frame(note1) # Create a tab for notebook 1

tab2 = ttk.Frame(note2) # Create a tab for notebook 2

note1.add(tab1, text=' Tab {} '.format(tab_no + 1)) # Add tab notebook 1

note2.add(tab2, text=' Tab {} '.format(tab_no + 1)) # Add tab notebook 2

gui.mainloop()

Created on May 8, 2018

import tkinter as tk

from tkinter import ttk

from tkinter.messagebox import showinfo

# Callbacks

#------------------------------------------

def clear_display_area():

for widget in display_area.grid_slaves():

if int(widget.grid_info()["row"]) == 0:

widget.grid_forget()

def display_button(active_notebook, tab_no):

btn = ttk.Button(display_area, text=active_notebook +' - Tab '+ tab_no,

command= lambda: showinfo("Tab Display", "Tab: " + tab_no))

btn.grid(column=0, row=0, padx=8, pady=8)

def notebook_callback(event):

clear_display_area()

current_notebook = str(event.widget)

tab_no = str(event.widget.index("current") + 1)

if current_notebook.endswith('notebook'):

active_notebook = 'Notebook 1'

elif current_notebook.endswith('notebook2'):

active_notebook = 'Notebook 2'

else:

active_notebook = ''

display_button(active_notebook, tab_no)

# GUI Creation
#------------------------------------------

gui = tk.Tk()

gui.title("GUI")

tabs_frame = ttk.Frame(gui)

tabs_frame.grid(row=0, column=0, sticky='W')

display_area = ttk.Labelframe(gui, text=' Tab Display Area ')

display_area.grid(row=1, column=0, sticky='WE', padx=5, pady=5)

display_area_label = tk.Label(display_area, text="", height=2)

display_area_label.grid(column=0, row=0)

note1 = ttk.Notebook(tabs_frame)

note1.grid(row=0, column=0)

note2 = ttk.Notebook(tabs_frame)

note2.grid(row=1, column=0)

# create and add tabs to Notebooks

for tab_no in range(5):

tab1 = ttk.Frame(note1) # Create a tab for notebook 1

tab2 = ttk.Frame(note2) # Create a tab for notebook 2

note1.add(tab1, text=' Tab {} '.format(tab_no + 1)) # Add tab notebook 1

note2.add(tab2, text=' Tab {} '.format(tab_no + 1)) # Add tab notebook 2

# bind click-events to Notebooks

note1.bind("<ButtonRelease-1>", notebook_callback)

note2.bind("<ButtonRelease-1>", notebook_callback)
# display_button('Notebook 1', '1') # mimic tab click event

gui.mainloop()

Created on May 8, 2018

import tkinter as tk

from tkinter import ttk

from tkinter.messagebox import showinfo

# Callback & functions

#------------------------------------------

def clear_display_area():

for widget in display_area.grid_slaves():

if int(widget.grid_info()["row"]) == 0:

widget.grid_forget()
def display_button(active_notebook, tab_no):

btn = ttk.Button(display_area, text=active_notebook +' - Tab '+ tab_no,

command= lambda: showinfo("Tab Display", "Tab: " + tab_no))

btn.grid(column=0, row=0, padx=8, pady=8)

def notebook_callback(event):

clear_display_area()

current_notebook = str(event.widget)

tab_no = str(event.widget.index("current") + 1)

if current_notebook.endswith('notebook'):

active_notebook = 'Notebook 1'

elif current_notebook.endswith('notebook2'):

active_notebook = 'Notebook 2'

else:

active_notebook = ''

display_button(active_notebook, tab_no)

# GUI Creation

#------------------------------------------

gui = tk.Tk()

gui.title("GUI")

tabs_frame = ttk.Frame(gui)

tabs_frame.grid(row=0, column=0, sticky='W')

display_area = ttk.Labelframe(gui, text=' Tab Display Area ')

display_area.grid(row=1, column=0, sticky='WE', padx=5, pady=5)

display_area_label = tk.Label(display_area, text="", height=2)

display_area_label.grid(column=0, row=0)

note1 = ttk.Notebook(tabs_frame)

note1.grid(row=0, column=0)

note2 = ttk.Notebook(tabs_frame)

note2.grid(row=1, column=0)

# create and add tabs to Notebooks

for tab_no in range(5):

tab1 = ttk.Frame(note1) # Create a tab for notebook 1

tab2 = ttk.Frame(note2) # Create a tab for notebook 2

note1.add(tab1, text=' Tab {} '.format(tab_no + 1)) # Add tab notebook 1

note2.add(tab2, text=' Tab {} '.format(tab_no + 1)) # Add tab notebook 2

# bind click-events to Notebooks

note1.bind("<ButtonRelease-1>", notebook_callback)

note2.bind("<ButtonRelease-1>", notebook_callback)

display_button('Notebook 1', '1') # mimic tab click event

gui.mainloop()
Created on May 8, 2018

import tkinter as tk

from tkinter import ttk

from tkinter.messagebox import showinfo

# Callback & functions

#------------------------------------------

def new_text_callback(event):

x, y = event.widget.winfo_pointerxy()

btn = event.widget.winfo_containing(x, y)

try: btn.configure(text=event.widget.cget("text"))

except: pass

def drag_btn_text(btn):

btn.bind("<ButtonRelease-1>", new_text_callback)

def clear_display_area():
 for widget in display_area.grid_slaves():

if int(widget.grid_info()["row"]) == 0:

widget.grid_forget()

def display_button(active_notebook, tab_no):

btn = ttk.Button(display_area, text=active_notebook +' - Tab '+ tab_no,

command= lambda: showinfo("Tab Display", "Tab: " + tab_no))

btn.grid(row=0, column=0, padx=8, pady=8)

drag_btn_text(btn)

def notebook_callback(event):

clear_display_area()

current_notebook = str(event.widget)

tab_no = str(event.widget.index("current") + 1)

if current_notebook.endswith('notebook'):

active_notebook = 'Notebook 1'

elif current_notebook.endswith('notebook2'):

active_notebook = 'Notebook 2'

else:

active_notebook = ''

display_button(active_notebook, tab_no)

# GUI Creation

#------------------------------------------

gui = tk.Tk()
gui.title("GUI")

tabs_frame = ttk.Frame(gui)

tabs_frame.grid(row=0, column=0, sticky='W')

display_area = ttk.Labelframe(gui, text=' Tab Display Area ')

display_area.grid(row=1, column=0, sticky='WE', padx=5, pady=5)

display_area_label = tk.Label(display_area, text="", height=2)

display_area_label.grid(column=0, row=0)

note1 = ttk.Notebook(tabs_frame)

note1.grid(row=0, column=0)

note2 = ttk.Notebook(tabs_frame)

note2.grid(row=1, column=0)

# create and add tabs to Notebooks

for tab_no in range(5):

tab1 = ttk.Frame(note1) # Create a tab for notebook 1

tab2 = ttk.Frame(note2) # Create a tab for notebook 2

note1.add(tab1, text=' Tab {} '.format(tab_no + 1)) # Add tab notebook 1

note2.add(tab2, text=' Tab {} '.format(tab_no + 1)) # Add tab notebook 2

# bind click-events to Notebooks

note1.bind("<ButtonRelease-1>", notebook_callback)

note2.bind("<ButtonRelease-1>", notebook_callback)

display_button('Notebook 1', '1') # mimic tab click event

btn0 = ttk.Button(display_area, text='Second Row')

btn0.grid(row=1, column=0, sticky='WE', padx=8, pady=2)

btn1 = ttk.Button(display_area, text='Drag here')

btn1.grid(row=1, column=1, sticky='WE', padx=8, pady=2)

drag_btn_text(btn0)

drag_btn_text(btn1)

gui.mainloop()

import tkinter as tk
gui = tk.Tk()

gui.title("GUI")

gui.resizable(False, False)

gui.update()

print(gui.winfo_width())

print(gui.winfo_height())

gui.mainloop()
import tkinter as tk

gui = tk.Tk()

gui.title("GUI")
gui.resizable(False, False)

label = tk.Label(gui, text='Hi there...', padx=100, pady=10)

label.pack()

gui.update()

print(gui.winfo_width())

print(gui.winfo_height())

gui.mainloop()
import tkinter as tk

gui = tk.Tk()

gui.title("GUI")
gui.resizable(False, False)

gui.geometry("200x200")

label = tk.Label(gui, text='Hi there...')

label.pack()

gui.update()

print(gui.winfo_width())

print(gui.winfo_height())

gui.mainloop()

import tkinter as tk

from tkinter import ttk

gui = tk.Tk()

gui.title("GUI")

gui.resizable(False, False)
gui.configure(background='Blue')

ttk.Button(gui, text='Hi there...').grid()

ttk.Button(gui, text='Hi there...').grid(column=1)

ttk.Button(gui, text='Hi there...').grid(column=2)

gui.mainloop()

import tkinter as tk

from tkinter import ttk

gui = tk.Tk()

gui.title("GUI")

gui.resizable(False, False)

gui.configure(background='blue')
tk.Button(gui, text='Hi there...', bg='orange', relief='flat', width=9).grid()

tk.Button(gui, text='Hi there...', bg='orange', relief='flat', width=9).grid(column=1)

tk.Button(gui, text='Hi there...', bg='orange', relief='flat', width=9).grid(column=2)

gui.mainloop()

import tkinter as tk

from tkinter import ttk

gui = tk.Tk()

gui.title("GUI")

gui.resizable(False, False)

gui.configure(background='blue')

style = ttk.Style()

style.configure('TButton', font=('', 12))

ttk.Button(gui, text='Hi there...').grid()

ttk.Button(gui, text='Hi there...').grid()

ttk.Button(gui, text='Hi there...').grid()

ttk.Label(gui, text='Hi there...', width=20, anchor='center').grid(row=0, column=1)

ttk.Label(gui, text='Hi there...', width=20, anchor='center').grid(row=1, column=1)

ttk.Label(gui, text='Hi there...', width=20, anchor='center').grid(row=2, column=1)

gui.mainloop()

import tkinter as tk

from tkinter import ttk

gui = tk.Tk()

gui.title("GUI")

gui.resizable(False, False)

gui.configure(background='blue')

style = ttk.Style()

style.configure('TButton', font=('', 12))

style.configure('TLabel', font=('', 12))

ttk.Button(gui, text='Hi there...').grid()

ttk.Button(gui, text='Hi there...').grid()

ttk.Button(gui, text='Hi there...').grid()

ttk.Label(gui, text='Hi there...', width=20, anchor='center').grid(row=0, column=1)

ttk.Label(gui, text='Hi there...', width=20, anchor='center').grid(row=1, column=1)

ttk.Label(gui, text='Hi there...', width=20, anchor='center').grid(row=2, column=1)

gui.mainloop()

APELURI DE FUNCTII

def example_function(x):

return x + 1

example_variable = 10

print(example_variable)

processed_variable = example_function(example_variable)

print(processed_variable) # this should be 11

def complicated_func(x, y):

def squared(z):

return z * z

x_squared = squared(x)

return x_squared + y * 3

x=5

y=3

print(complicated_func(x, y)) # 34

# List comprehensions

xs = [0, 1, 2, 3, 4, 5]

# target x_squared_s = [0, 1, 4, 9, 16, 25]

result = []

for x in xs:

result.append(x * x)

print(result)

result_alternative = [(x * x) for x in xs]

print(result_alternative)
# Write a small program to ask for a name and an age.

# When both values have been entered, check if the person

# is the right age to go on an 18-30 holiday (they must be

# over 18 and under 31).

# If they are, welcome them to the holiday, otherwise print

# a (polite) message refusing them entry.

name = input("Please enter your name: ")

age = int(input("How old are you, {0}? ".format(name)))

# if 18 <= age < 31:

if age >=18 and age <31:

print("Welcome to club 18-30 holidays, {0}".format(name))

else:

print("I'm sorry, our holidays are only for seriously cool people")
============= surse de la

mk:@MSITStore:C:\Users\tica1234ticabogd\Desktop\CARTI%20PYTHON\Python%20Book%2
0Collection%20Pack%20PDF%20-
%20P2P\Python\Data%20Structures%20and%20Algorithms%20with%20Object-
Oriented%20Design%20Patterns%20in%20Python%20(2003).chm::/opus7/programs/index.html

suma ca si functie trebuie programul principal de apelare

def sum(n):

result = 0

i=1

while i <= n:

result += i

i += 1

return result

def Horner(a, n, x):

result = a[n]

i=n-1

while i >= 0:

result = result * x + a[i]

i -= 1

return result
def factorial(n):

if n == 0:

return 1

else:

return n * factorial(n - 1)

def findMaximum(a, n):

result = a[0]

i=1

while i < n:

if a[i] > result:

result = a[i]

i += 1

return result

def gamma():

result = 0.
 i = 1

while i <= 500000:

result += 1.0/i - math.log((i + 1.0)/i)

i += 1

return result

def geometricSeriesSum(x, n):

sum = 0
i = 0
while i <= n:
prod = 1
j = 0
while j < i:
prod *= x
j += 1
sum += prod
i += 1
return sum

def geometricSeriesSum(x, n):

sum = 0

i = 0

while i <= n:

sum = sum * x + 1

i += 1

return sum

def power(x, n):

if n == 0:

return 1

elif n % 2 == 0: # n is even

return power(x * x, n / 2)

else: # n is odd

return x * power(x * x, n / 2)
def geometricSeriesSum(x, n):

return (power(x, n + 1) - 1) / (x - 1)

def Horner(a, n, x):

result = a[n]
i = n - 1
while i >= 0:
result = result * x + a[i]
i -= 1
return result

def prefixSums(a, n):

j = n - 1

while j >= 0:

sum = 0

i = 0

while i <= j:

sum += a[i]

i += 1

a[j] = sum

j -= 1

iterativ

def Fibonacci(n):

previous = -1

result = 1

i = 0

while i <= n:

sum = result + previous

previous = result

result = sum

i += 1

return result
recursiv

def Fibonacci(n):

if n == 0 or n == 1:

return n

else:

return Fibonacci(n - 1) + Fibonacci(n - 2)

def bucketSort(a, n, buckets, m):

for j in range(m):

buckets[j] = 0

for i in range(n):

buckets[a[i]] += 1

i = 0

for j in range(m):

for k in range(buckets[j]):

a[i] = j

i += 1

crearea claselor in proiect

ALGORITMI DE SORTARE FOLOSIND CLASE

class Sorter(Object):

def __init__(self):

super(Sorter, self).__init__()

self._array = None

self._n = 0
 def _sort(self):

pass

_sort = abstractmethod(_sort)

def sort(self, array):

assert isinstance(array, Array)

self._array = array

self._n = len(array)

if self._n > 0:

self._sort()

self._array = None

def swap(self, i, j):

tmp = self._array[i]

self._array[i] = self._array[j]

self._array[j] = tmp

class StraightInsertionSorter(Sorter):

def __init__(self):

super(StraightInsertionSorter, self).__init__()

def _sort(self):

for i in xrange(1, self._n):

j = i

while j > 0 and self._array[j - 1] > self._array[j]:

self.swap(j, j - 1)

j -= 1

class BinaryInsertionSorter(Sorter):

def __init__(self):

super(BinaryInsertionSorter, self).__init__()

def _sort(self):

for i in xrange(1, self._n):

tmp = self._array[i]
 left = 0

right = i

while left < right:

middle = (left + right) / 2

if tmp >= self._array[middle]:

left = middle + 1

else:

right = middle

j = i

while j > left:

self.swap(j - 1, j)

j -= 1

class BubbleSorter(Sorter):

def __init__(self):

super(BubbleSorter, self).__init__()

def _sort(self):

i = self._n

while i > 1:

for j in xrange(i - 1):

if self._array[j] > self._array[j + 1]:

self.swap(j, j + 1)

i -= 1

class QuickSorter(Sorter):

def __init__(self):

super(QuickSorter, self).__init__()

def selectPivot(self):

pass

selectPivot = abstractmethod(selectPivot)

class QuickSorter(Sorter):

CUTOFF = 2 # minimum cut-off

 def quicksort(self, left, right):

if right - left + 1 > self.CUTOFF:

p = self.selectPivot(left, right)

self.swap(p, right)

pivot = self._array[right]

i = left

j = right - 1

while True:

while i < j and self._array[i] < pivot:

i += 1

while i < j and self._array[j] > pivot:

j -= 1

if i >= j:

break

self.swap(i, j)

i += 1

j -= 1

if self._array[i] > pivot:

self.swap(i, right)

if left < i:

self.quicksort(left, i - 1)

if right > i:

self.quicksort(i + 1, right)

class QuickSorter(Sorter):

def _sort(self):

self.quicksort(0, self._n - 1)

sorter = StraightInsertionSorter()

sorter.sort(self._array)

class MedianOfThreeQuickSorter(QuickSorter):

def __init__(self):

super(MedianOfThreeQuickSorter, self).__init__()
 def selectPivot(self, left, right):

middle = (left + right) / 2

if self._array[left] > self._array[middle]:

self.swap(left, middle)

if self._array[left] > self._array[right]:

self.swap(left, right)

if self._array[middle] > self._array[right]:

self.swap(middle, right)

return middle

class StraightSelectionSorter(Sorter):

def __init__(self):

super(StraightSelectionSorter, self).__init__()

def _sort(self):

i = self._n

while i > 1:

max = 0

for j in xrange(i):

if self._array[j] > self._array[max]:

max = j

self.swap(i - 1, max)

i -= 1

class HeapSorter(Sorter):

def __init__(self):

super(HeapSorter, self).__init__()

def percolateDown(self, i, length):

while 2 * i <= length:

j = 2 * i

if j < length and self._array[j + 1] \

> self._array[j]:
 j = j + 1

if self._array[i] \

>= self._array[j]:

break

self.swap(i, j)

i = j

class HeapSorter(Sorter):

def buildHeap(self):

i = self._n / 2

while i > 0:

self.percolateDown(i, self._n)

i -= 1

class HeapSorter(Sorter):

def _sort(self):

base = self._array.baseIndex

self._array.baseIndex = 1

self.buildHeap()

i = self._n

while i >= 2:

self.swap(i, 1)

self.percolateDown(1, i - 1)

i -= 1

self._array.baseIndex = base

class TwoWayMergeSorter(Sorter):

def __init__(self):

super(TwoWayMergeSorter, self).__init__()

self._tempArray = None

class TwoWayMergeSorter(Sorter):

def merge(self, left, middle, right):

i = left
 j = left

k = middle + 1

while j <= middle and k <= right:

if self._array[j] < self._array[k]:

self._tempArray[i] = self._array[j]

i += 1

j += 1

else:

self._tempArray[i] = self._array[k]

i += 1

k += 1

while j <= middle:

self._tempArray[i] = self._array[j]

i += 1

j += 1

for i in xrange(left, k):

self._array[i] = self._tempArray[i]

class TwoWayMergeSorter(Sorter):

def _sort(self):

self._tempArray = Array(self._n)

self.mergesort(0, self._n - 1)

self._tempArray = None

def mergesort(self, left, right):

if left < right:

middle = (left + right) / 2

self.mergesort(left, middle)

self.mergesort(middle + 1, right)

self.merge(left, middle, right)

class BucketSorter(Sorter):

def __init__(self, m):

 super(BucketSorter, self).__init__()

self._m = m

self._count = Array(self._m)

class BucketSorter(Sorter):

def _sort(self):

for i in xrange(self._m):

self._count[i] = 0

for j in xrange(self._n):

self._count[self._array[j]] += 1

j = 0

for i in xrange(self._m):

while self._count[i] > 0:

self._array[j] = i

j += 1

self._count[i] -= 1

class RadixSorter(Sorter):

r = 8

R = 1 << r

p = (32 + r - 1) / r

def __init__(self):

self._count = Array(self.R)

self._tempArray = None

class RadixSorter(Sorter):

def _sort(self):

self._tempArray = Array(self._n)

for i in xrange(self.p):

for j in xrange(self.R):

self._count[j] = 0

for k in xrange(self._n):
 self._count[(self._array[k] \

>> (self.r*i)) & (self.R-1)] += 1

self._tempArray[k] = self._array[k]

pos = 0

for j in xrange(self.R):

tmp = pos

pos += self._count[j]

self._count[j] = tmp

for k in xrange(self._n):

j = (self._tempArray[k] \

>> (self.r*i)) & (self.R-1)

self._array[self._count[j]] = self._tempArray[k]

self._count[j] += 1

Instalez optiunile
Grafuri
class Vertex(Object):

def __init__(self):

super(Vertex, self).__init__()

def getNumber(self): pass

getNumber = abstractmethod(getNumber)

number = property(

fget = lambda self: self.getNumber())

def getWeight(self): pass

getWeight = abstractmethod(getWeight)

weight = property(

fget = lambda self: self.getWeight())

def getIncidentEdges(self): pass

getIncidentEdges = abstractmethod(getIncidentEdges)

incidentEdges = property(

fget = lambda self: self.getIncidentEdges())

 def getEmanatingEdges(self): pass

getEmanatingEdges = abstractmethod(getEmanatingEdges)

emanatingEdges = property(

fget = lambda self: self.getEmanatingEdges())

def getPredecessors(self): pass

getPredecessors = abstractmethod(getPredecessors)

predecessors = property(

fget = lambda self: self.getPredecessors())

def getSuccessors(self): pass

getSuccessors = abstractmethod(getSuccessors)

successors = property(

fget = lambda self: self.getSuccessors())

class Edge(Object):

def __init__(self):

super(Edge, self).__init__()

def getV0(self): pass

getV0 = abstractmethod(getV0)

v0 = property(

fget = lambda self: self.getV0())

def getV1(self): pass

getV1 = abstractmethod(getV1)

v1 = property(

fget = lambda self: self.getV1())

def getWeight(self): pass

 getWeight = abstractmethod(getWeight)

weight = property(

fget = lambda self: self.getWeight())

def getIsDirected(self): pass

getIsDirected = abstractmethod(getIsDirected)

isDirected = property(

fget = lambda self: self.getIsDirected())

def mateOf(self, vertex): pass

mateOf = abstractmethod(mateOf)

class Graph(Container):

def __init__(self, size):

super(Graph, self).__init__()

self._numberOfVertices = 0

self._numberOfEdges = 0

self._vertex = Array(size)

self._isDirected = False

class Vertex(Vertex):

def __init__(self, graph, number, weight):

super(Graph.Vertex, self).__init__()

self._graph = graph

self._number = number

self._weight = weight
 class Edge(Edge):

def __init__(self, graph, v0, v1, weight):

super(Graph.Edge, self).__init__()

self._graph = graph

self._v0 = v0

self._v1 = v1

self._weight = weight

class Graph(Container):

def getNumberOfEdges(self): pass

getNumberOfEdges = abstractmethod(getNumberOfEdges)

numberOfEdges = property(

fget = lambda self: self.getNumberOfEdges())

def getNumberOfVertices(self): pass

getNumberOfVertices = abstractmethod(getNumberOfVertices)

numberOfVertices = property(

fget = lambda self: self.getNumberOfVertices())

def getIsDirected(self): pass

getIsDirected = abstractmethod(getIsDirected)

isDirected = property(

fget = lambda self: self.getIsDirected())

def getIsConnected(self): pass

getIsConnected = abstractmethod(getIsConnected)

isConnected = property(

fget = lambda self: self.getIsConnected())

 def getIsCyclic(self): pass

getIsCyclic = abstractmethod(getIsCyclic)

isCyclic = property(

fget = lambda self: self.getIsCyclic())

def getVertices(self): pass

getVertices = abstractmethod(getVertices)

vertices = property(

fget = lambda self: self.getVertices())

def getEdges(self): pass

getEdges = abstractmethod(getEdges)

edges = property(

fget = lambda self: self.getEdges())

class Graph(Container):

def addVertex(self, *args): pass

addVertex = abstractmethod(addVertex)

def getVertex(self, v): pass

getVertex = abstractmethod(getVertex)

def addEdge(self, *args): pass

addEdge = abstractmethod(addEdge)

def getEdge(self, v, w): pass

getEdge = abstractmethod(getEdge)

def isEdge(self, v, w): pass

 isEdge = abstractmethod(isEdge)

def depthFirstTraversal(self, visitor, start): pass

depthFirstTraversal = abstractmethod(depthFirstTraversal)

def breadthFirstTraversal(self, visitor, start): pass

breadthFirstTraversal = abstractmethod(breadthFirstTraversal)

def getIncidentEdges(self, v): pass

getIncidentEdges = abstractmethod(getIncidentEdges)

def getEmanatingEdges(self, v): pass

getEmanatingEdges = abstractmethod(getEmanatingEdges)

def __len__(self):

return self.numberOfVertices

def __getitem__(self, v):

return self.getVertex(v)

class Digraph(Graph):

def __init__(self, size):

super(Digraph, self).__init__(size)

self._isDirected = True

def getIsStronglyConnected(self): pass

getIsStronglyConnected = abstractmethod(

getIsStronglyConnected)

isStronglyConnected = property(

fget = lambda self: self.getIsStronglyConnected())

 def topologicalOrderTraversal(self): pass

topologicalOrderTraversal = abstractmethod(

topologicalOrderTraversal)

class GraphAsMatrix(Graph):

def __init__(self, size):

super(GraphAsMatrix, self).__init__(size)

self._matrix = DenseMatrix(size, size)

class GraphAsLists(Graph):

def __init__(self, size):

super(GraphAsLists, self).__init__(size)

self._adjacencyList = Array(size)

for i in xrange(size):

self._adjacencyList[i] = LinkedList()

class Graph(Container):

def depthFirstTraversal(self, visitor, start):

assert isinstance(visitor, PrePostVisitor)

visited = Array(self._numberOfVertices)

for v in xrange(self._numberOfVertices):

visited[v] = False

self._depthFirstTraversal(visitor, self[start], visited)

def _depthFirstTraversal(self, visitor, v, visited):

if visitor.isDone:
 return

visitor.preVisit(v)

visited[v.number] = True

for to in v.successors:

if not visited[to.number]:

self._depthFirstTraversal(visitor, to, visited)

visitor.postVisit(v)

class Graph(Container):

def breadthFirstTraversal(self, visitor, start):

assert isinstance(visitor, Visitor)

enqueued = Array(self._numberOfVertices)

for v in xrange(self._numberOfVertices):

enqueued[v] = False

queue = QueueAsLinkedList()

queue.enqueue(self[start])

enqueued[start] = True

while not queue.isEmpty and not visitor.isDone:

v = queue.dequeue()

visitor.visit(v)

for to in v.successors:

if not enqueued[to.number]:

queue.enqueue(to)

enqueued[to.number] = True

class Digraph(Graph):

def topologicalOrderTraversal(self, visitor):

inDegree = Array(self.numberOfVertices)

for v in xrange(self.numberOfVertices):

inDegree[v] = 0
 for e in self.edges:

inDegree[e.v1.number] += 1

queue = QueueAsLinkedList()

for v in xrange(self.numberOfVertices):

if inDegree[v] == 0:

queue.enqueue(self[v])

while not queue.isEmpty and not visitor.isDone:

v = queue.dequeue()

visitor.visit(v)

for to in v.successors:

inDegree[to.number] -= 1

if inDegree[to.number] == 0:

queue.enqueue(to)

class Graph(Container):

class CountingVisitor(Visitor):

def __init__(self):

super(Graph.CountingVisitor, self).__init__()

self._count = 0

def visit(self, obj):

self._count += 1

def getCount(self):

return self._count

count = property(

fget = lambda self: self.getCount())

 def getIsConnected(self):

visitor = self.CountingVisitor()

self.depthFirstTraversal(PreOrder(visitor), 0)

return visitor.count == self.numberOfVertices

class Digraph(Graph):

def getIsStronglyConnected(self):

for v in xrange(self.numberOfVertices):

visitor = self.CountingVisitor()

self.depthFirstTraversal(PreOrder(visitor), v)

if visitor.count != self.numberOfVertices:

return False

return True

class Digraph(Graph):

def getIsCyclic(self):

visitor = self.CountingVisitor()

self.topologicalOrderTraversal(visitor)

return visitor.count != self.numberOfVertices

class Algorithms(object):

class Entry(object):

def __init__(self):

self.known = False

self.distance = sys.maxint

self.predecessor = sys.maxint

class Algorithms(object):
def DijkstrasAlgorithm(g, s):

n = g.numberOfVertices

table = Array(n)

for v in xrange(n):

table[v] = Algorithms.Entry()

table[s].distance = 0

queue = BinaryHeap(g.numberOfEdges)

queue.enqueue(Association(0, g[s]))

while not queue.isEmpty:

assoc = queue.dequeueMin()

v0 = assoc.value

if not table[v0.number].known:

table[v0.number].known = True

for e in v0.emanatingEdges:

v1 = e.mateOf(v0)

d = table[v0.number].distance + e.weight

if table[v1.number].distance > d:

table[v1.number].distance = d

table[v1.number].predecessor = v0.number

queue.enqueue(Association(d, v1))

result = DigraphAsLists(n)

for v in xrange(n):

result.addVertex(v, table[v].distance)

for v in xrange(n):

if v != s:

result.addEdge(v, table[v].predecessor)

return result

DijkstrasAlgorithm = staticmethod(DijkstrasAlgorithm)
class Algorithms(object):

def FloydsAlgorithm(g):

n = g.numberOfVertices

distance = DenseMatrix(n, n)

for v in xrange(n):

for w in xrange(n):

distance[v, w] = sys.maxint

for e in g.edges:

distance[e.v0.number, e.v1.number] = e.weight

for i in xrange(n):

for v in xrange(n):

for w in xrange(n):

if distance[v, i] != sys.maxint and \

distance[i, w] != sys.maxint:

d = distance[v, i] + distance[i, w]

if distance[v, w] > d:

distance[v, w] = d

result = DigraphAsMatrix(n)

for v in xrange(n):

result.addVertex(v)

for v in xrange(n):

for w in xrange(n):

if distance[v, w] != sys.maxint:

result.addEdge(v, w, distance[v, w])

return result

FloydsAlgorithm = staticmethod(FloydsAlgorithm)

class Algorithms(object):

def PrimsAlgorithm(g, s):

 n = g.numberOfVertices

table = Array(n)

for v in xrange(n):

table[v] = Algorithms.Entry()

table[s].distance = 0

queue = BinaryHeap(g.numberOfEdges)

queue.enqueue(Association(0, g[s]))

while not queue.isEmpty:

assoc = queue.dequeueMin()

v0 = assoc.value

if not table[v0.number].known:

table[v0.number].known = True

for e in v0.emanatingEdges:

v1 = e.mateOf(v0)

d = e.weight

if not table[v1.number].known and \

table[v1.number].distance > d:

table[v1.number].distance = d

table[v1.number].predecessor = v0.number

queue.enqueue(Association(d, v1))

result = GraphAsLists(n)

for v in xrange(n):

result.addVertex(v)

for v in xrange(n):

if v != s:

result.addEdge(v, table[v].predecessor)

return result

PrimsAlgorithm = staticmethod(PrimsAlgorithm)

class Algorithms(object):
 def KruskalsAlgorithm(g):

n = g.numberOfVertices

result = GraphAsLists(n)

for v in xrange(n):

result.addVertex(v)

queue = BinaryHeap(g.numberOfEdges)

for e in g.edges:

weight = e.weight

queue.enqueue(Association(weight, e))

partition = PartitionAsForest(n)

while not queue.isEmpty and partition.count > 1:

assoc = queue.dequeueMin()

e = assoc.value

n0 = e.v0.number

n1 = e.v1.number

s = partition.find(n0)

t = partition.find(n1)

if s != t:

partition.join(s, t)

result.addEdge(n0, n1)

return result

KruskalsAlgorithm = staticmethod(KruskalsAlgorithm)

class Algorithms(object):

class EarliestTimeVisitor(Visitor):

def __init__(self, earliestTime):

super(Algorithms.EarliestTimeVisitor,self).__init__()

self._earliestTime = earliestTime
 def visit(self, w):

t = self._earliestTime[0]

for e in w.incidentEdges:

t = max(t,

self._earliestTime[e.v0.number] + e.weight)

self._earliestTime[w.number] = t

class Algorithms(object):

def criticalPathAnalysis(g):

n = g.numberOfVertices

earliestTime = Array(n)

earliestTime[0] = 0

g.topologicalOrderTraversal(

Algorithms.EarliestTimeVisitor(earliestTime))

latestTime = Array(n)

latestTime[n - 1] = earliestTime[n - 1]

g.depthFirstTraversal(PostOrder(

Algorithms.LatestTimeVisitor(latestTime)), 0)

slackGraph = DigraphAsLists(n)

for v in xrange(n):

slackGraph.addVertex(v)

for e in g.edges:

slack = latestTime[e.v1.number] - \

earliestTime[e.v0.number] - e.weight

slackGraph.addEdge(

e.v0.number, e.v1.number, e.weight)

return Algorithms.DijkstrasAlgorithm(slackGraph, 0)
 criticalPathAnalysis = staticmethod(criticalPathAnalysis)

Grafica

from turtle import *

color('red', 'yellow')
begin_fill()

while True:

forward(200)

left(170)

if abs(pos()) < 1:

break

end_fill()

done()

Programarea bazelor de date

https://www.filehorse.com/download-python-32/20735/
https://www.filehorse.com/download-python-32/6427/
La toate aleg optiunea de mai jos
https://sourceforge.net/projects/mysql-python/files/
import MySQLdb

import MySQLdb as mysql

help(MySQLdb._mysql)

In visual studio rulam astfel

Caut pe internetutilitarele care le import ca sa ruleze aplicatiile
Crearea claselor si functiilor specifice

class Car:

'Common base class for all cars'

carCount = 0

def __init__(self, name, year):

self.name = name

self.year = year

Car.carCount += 1

def displayCount(self):

print ("Total Car %d" % Car.carCount)

def displayCar(self):

print ("Name : ", self.name, ", Year: ", self.year)

#This would create first object of Car class"

car1 = Car("Honda", 2000)

#This would create second object of Car class"

car2 = Car("BMW", 2017)

car1.displayCar()

car2.displayCar()

print ("Total Car %d" % Car.carCount)

class MyClass(object):

def __init__(self, number):

self.number = number
my_objects = []

for i in range(100):

my_objects.append(MyClass(i))

# later

for obj in my_objects:

print (obj.number)

class Car:

print("Car created")
class car(object):

def __init__(self):

self.__mileage = 16

def getMileage(self):

print(self.__mileage)

def setMileage(self,mileage):
 self.__mileage = mileage

volvo = car()

volvo.getMileage()

volvo.setMileage(20)

volvo.getMileage()

class car:

"this is my first car"

a=10
 def func(self):

print ("Nice Ride!")

class Man:

def sayHi(self,name=None):

if name is not None:

print("Hi " + name)

else:
 print("Hi!")

obj = Man()

obj.sayHi()

obj.sayHi("James")

APELUL UNEI CLASE CA SI OBIECT SE NUMESTE INSTANTA

class Car:

# Class variables

vehicle_type = "suv"

model = "S90"

# Constructor method with instance variables brand and cost

def __init__(self, brand, cost):

self.brand = brand

self.cost = cost

# Method with instance variable followers

def fan_follow(self, follow):

print("This user has " + str(follow) + " follow")

def main():

# First object, set up instance variables of constructor method

car = Car("Volvo", 7)

# Print out instance variable brand

print(car.brand)

# Print out class variable cost

print(car.cost)
 # Second object

suv = Car("Audi", 15)

# Print out instance variable brand

print(suv.brand)

print(suv.cost)

# Use set_followers method and pass followers instance variable

suv.fan_follow(77)

# Print out class variable vehicle_type

print(suv.vehicle_type)

if __name__ == "__main__":

main()
Car1_price = 5000

print (Car1_price)

Car2_price = Car1_price

if (id(Car1_price) == id(Car2_price)):

print("Car1 and Car2 have same object value & Memory ID = ", hex(id(Car1_price)))

Car1_price = Car1_price + 10

if (id(Car1_price) != id(Car2_price)):
 print("Car1 and Car2 have different object value & Memory ID = ", hex(id(Car1_price)),"&",
hex(id(Car2_price)))

Car3_price = 5000

if (id(Car2_price)==id(Car3_price)):

print("Car2 and Car3 have same memory value & Memory ID = ", hex(id(Car3_price)))

else:

print("Car2 and Car3 have different object value & Memory ID = ", hex(id(Car3_price)))

Car1_price = None

print("Value is None")

print("Garbage Collector emptied the memory")

class Car:

def start(self):

print("Car started")

def reverse(self):

print("Car taking reverse")

def speed(self):

print("top speed = 200")

def main():

volvo=Car()

volvo.start()

volvo.reverse()

volvo.speed()

if __name__ == "__main__":

main()
x=10

print(type(x))

y=x

if (id(x)==id(y)):

print(" x and y are using same refernce object")

x=x+1

if (id(x)!=id(y)):

print(" x and y are using different refernce object")

z=10

if (id(x)!=id(y)):

print(" y and z are using same refernce object")

else:

print(" y and z are using diffenent refernce object")

NOTIUNEA DE CONSTRUCTOR AL UNEI CLASE

class Car:

#construct - paramterized constuctor

def __init__(self,name):

print("This is parameterized constructor")

self.name=name

def model(self):

print("my first car",self.name)

volvo=Car("Volvo S90")

volvo.model()

class Car:

def __init__(self):

self.color = None

self.type = None

def fill(self, fuel):

self.type = fuel

def empty(self):

self.type = None

redCar = Car()

redCar.color = "red"

redCar.type = "gas"

redCar.empty()

redCar.fill("petrol")

STERGEREA DIN MEMORIE A UNUI CONSTRUCTOR SE NUMESTE DESTRUCTOR

class Car:

def __init__(self):

print("Car created")

def __del__(self):

print("Destructor is called, Car is deleted")

volvo=Car()

del volvo
class Parents:

def gen(self):

x=1

print(x)

class Father(Parents):

pass

class Mother(Parents):
 pass

class Child(Father,Mother):

pass

childobj=Child()

childobj.gen()

class Triangle():

def __init__(self,base,height):
 self.base = base

self.height = height

def getArea(self):

print(self.base*self.height/2,"is area of triangle")

class Square(Triangle):

def __init__(self,side):

self.side = side

Triangle.__init__(self,side,side)

def getArea(self):

print(self.side*self.side,"is area of square")

t = Triangle(2,6)

s = Square(4)

t.getArea()

s.getArea()
import sys

anyList = ['X', 0, 10]

for entry in anyList:

try:

print("Entry is ",entry)

R = 1/int(entry)

break
 except:

print("OOPs!", sys.exc_info()[0], "Occured.")

print("Next Entry.")

print()

print("Reciprocal of", entry, "is", R)

try:

n1, n2 = eval(input("Input 2 Numbers, Separated by comma: "))

 ans = n1/n2

print("Answer :", ans)

except ZeroDivisionError:

print("Division by Zero is Error!")

except SyntaxError:

print("Comma is missing. Enter Numbers separated by comma. Eg: 5,6 ")

except:

print("Wrong Input")

else:

print("No Exception")

finally:

print("This will execute no matter what")

class Error(Exception):

"""Base Class of other exceptions"""

pass

class ValueTooSmallError(Error):

"""Raised when the input value is too small"""

pass

class ValueTooLargeError(Error):
 """Raised when the input value is too large"""

pass

#out main program

#user guesses a number until he/she is right

#you need to guess this number

number = 10

while True:

try:

i_num = int(input("Enter a number :"))

if i_num < number:

raise ValueTooSmallError

elif i_num > number:

raise ValueTooLargeError

break

except ValueTooSmallError:

print("This value is too small, try again!!")

print()

except ValueTooLargeError:

print("This value is too large, try again!!")

print()

print("Congratulation! You guessed it correctly.")

import math

class Circle:

def __init__(self, radius):

self.__radius = radius

def setRadius(self, radius):

self.__radius = radius
 def getRadius(self):

return self.__radius

def area(self):

return math.pi * self.__radius ** 2

def __add__(self, another_circle):

return Circle(self.__radius + another_circle.__radius)

def __sub__(self, another_circle):

return Circle(self.__radius - another_circle.__radius)

c1 = Circle(8)

print(c1.getRadius())

c2 = Circle(10)

print(c2.getRadius())

c3 = c1 + c2

print(c3.getRadius())

c3 = c2 - c1

print(c3.getRadius())
class car:

__topspeed = 0

__name=""

def __init__(self):

self.__topspeed=250

self.name="SAM"
 def drive(self):

print("Drive Top Speed=" +str(self.__topspeed))

def setTopSpeed(self,speed):

self.__topspeed=speed

volvo=car()

volvo.drive()

volvo.setTopSpeed(380)

volvo.drive()
def fact(x):

if x==1:

return 1

else:

return (x * fact (x-1))

numb= 5
print("factorial of", numb, "is", fact(numb))

APLICATII ELEMENTARE GIMNAZIU

length = 5

breadth = 2

area = length * breadth

print ('Area is', area)

print ('Perimeter is', 2 * (length + breadth))

import math

a = 4.0
x = 3.0

y = (x + a/x) / 2

print (y)

import math

a = 4.0

x = 3.0

y = (x + a/x) / 2

print (y)

X=5

eval('math.sqrt(3)')

Recursivitate

Neverificate
1)
def countdown(n):
if n <= 0:
print 'Blastoff!'
else:
print n
countdown(n-1)
countdown(3)

2)
def print_n(s, n):
if n <= 0:
return
print s
print_n(s, n-1)

def distance(x1, y1, x2, y2):

dx = x2 - x1
dy = y2 - y1
dsquared = dx**2 + dy**2
result = math.sqrt(dsquared)
return result

radius = distance(xc, yc, xp, yp)

result = area(radius)
def circle_area(xc, yc, xp, yp):
radius = distance(xc, yc, xp, yp)
result = area(radius)
return result
def circle_area(xc, yc, xp, yp):
return area(distance(xc, yc, xp, yp))

def is_divisible(x, y):

if x % y == 0:
return True
else:
return False
is_divisible(6, 4)

def factorial(n):
if n == 0:
return 1
else:
recurse = factorial(n-1)
result = n * recurse
return result

def factorial (n):

if not isinstance(n, int):
print 'Factorial is only defined for integers.'
return None
elif n < 0:
print 'Factorial is only defined for positive integers.'
return None
elif n == 0:
return 1
else:
return n * factorial(n-1)

factorial(15)

def fibonacci (n):

if n == 0:
return 0
elif n == 1:
return 1
else:
return fibonacci(n-1) + fibonacci(n-2)

def b(z):
prod = a(z, z)
print z, prod
return prod
def a(x, y):
x=x+1
return x * y
def c(x, y, z):
sum = x + y + z
pow = b(sum)**2
return pow
x=1
y=x+1
print c(x, y+3, x+y)

def first(word):
return word[0]
def last(word):
return word[-1]
def middle(word):
return word[1:-1]
2. CONSTRUCTIA SI PROGRAMAREA ROBOTILOR CU
PYTHON
Placa de baza

Suportul pentru baterii

Conectorul de baterii

Adaptor cu iesire usb

Conectarea motorului

Alimentarea pe fata cealalata a placii

Conectarea controller cu B negru si A rosu

Conectarea bateriei la motor

Cablul usb ttl

Conectarea pe placa de baza

Comanda seriala

Prjvire de sus pentru a vede configurarea jamperilor

Conectare motoare baterie si caramida
Acestea ar fi componentele hard

Programarea se face cu python

Se fac initializarile si conectarea la portul serial

Ca si in programarea ev3 se stabilesc

Ceea ce este pe caramida

Adaugarea senzorilor de distanta , sonori
De distanta

Alimentarea si transmiterea semnalului prin placa

Programul afferent

Rulez
Senzorul unghiular de distanta

Cablul de conexiune
Conectarea la pinul 8 si 9

Programul afferent

Rularea
Modalitate de calcul
Programul care face CALCULUL
Ocolirea unui obstacol

Solutia
Programul
Procesarea imaginii cu camera

Desctopul de configurare
Controlul ei
Programul

Vizualizarea camerei
Gasirea culorilor

cv.Smooth(img,img,cv.CV_BLUR,3)
 hue_img = cv.CreateImage(cv.GetSize(img), 8, 3)
cv.CvtColor(img,hue_img, cv.CV_BGR2HSV)

#Remove all the pixels that don't match

threshold_img = cv.CreateImage(cv.GetSize(hue_img), 8, 1)
cv.InRangeS(hue_img, (10,120, 60), (20, 255, 255),
threshold_img)

Implementarea efectiva

storage = cv.CreateMemStorage(0)
contour = cv.FindContours(threshold_img, storage, cv.CV_
RETR_CCOMP, cv.CV_CHAIN_APPROX_SIMPLE)

points = []
while contour:

rect = cv.BoundingRect(list(contour))
contour = contour.h_next()
size = (rect[2] * rect[3])
if size > 100:
pt1 = (rect[0], rect[1])
pt2 = (rect[0] + rect[2], rect[1] + rect[3])
#Add a rectangle to the initial image
cv.Rectangle(img, pt1, pt2, (38, 160, 60))

Asa este procesata ca in fereastra stanga

Miscarea robotului in functie de cee ace detecteaza camera
import cv

capture = cv.CaptureFromCAM(0)

cv.NamedWindow("Target", 1)

frame = cv.QueryFrame(capture)

frame_size = cv.GetSize(frame)

color_image = cv.CreateImage(cv.GetSize(frame), 8, 3)

grey_image = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_8U, 1)

moving_average = cv.CreateImage(cv.GetSize(frame), cv.IPL_ DEPTH_32F, 3)

first = True

while True
color_image = cv.QueryFrame(capture)

cv.Smooth(color_image, color_image, cv.CV_GAUSSIAN, 3, 0)

if first

difference = cv.CloneImage(color_image)

temp = cv.CloneImage(color_image)

cv.ConvertScale(color_image, moving_average, 1.0, 0.0)

first = False

else

cv.RunningAvg(color_image, moving_average, 0.020, None)

cv.ConvertScale(moving_average, temp, 1.0, 0.0)

cv.AbsDiff(color_image, temp, difference)

cv.CvtColor(difference, grey_image, cv.CV_RGB2GRAY)

cv.Threshold(grey_image, grey_image, 70, 255, cv.CV_THRESH_ BINARY)

cv.Dilate(grey_image, grey_image, None, 18)

cv.Erode(grey_image, grey_image, None, 10)

storage = cv.CreateMemStorage(0)

contour = cv.FindContours(grey_image, storage, cv.CV_RETR_ CCOMP,

cv.CV_CHAIN_APPROX_SIMPLE);

points = []

while contour

bound_rect = cv.BoundingRect(list(contour))

contour = contour.h_next()

pt1 = (bound_rect[0], bound_rect[1])

pt2 = (bound_rect[0] + bound_rect[2], bound_rect[1] + bound_ rect[3])

points.append(pt1)

points.append(pt2)

cv.Rectangle(color_image, pt1, pt2, cv.CV_RGB(255,0,0), 1)

if len(points)

center_point = reduce(lambda a, b: ((a[0] + b[0]) / 2, (a[1] + b[1]) / 2),

points)
cv.Circle(color_image, center_point, 40, cv.CV_RGB(255, 255, 255), 1)

cv.Circle(color_image, center_point, 30, cv.CV_RGB(255, 100, 0), 1)

cv.Circle(color_image, center_point, 20, cv.CV_RGB(255, 255, 255), 1)

cv.Circle(color_image, center_point, 10, cv.CV_RGB(255, 100, 0), 1)

cv.ShowImage("Target", color_image)

c = cv.WaitKey(7) % 0x100

if c == 27

break

Miscarea robotului in functie de forma circulara prin care percepe obiectul

Programul
Constructia robotului

Servomotoarele se misca pe grade si in timp

Accesoriu
Dispozitivul

Sistemul de prindere
Priderea accesoriilor
Controlerul pentru servomotor

Pe verso

Alimentarea
Comunicarea cu laptopul

Portul serial setat

Asa va arata
Conectarea la controller

Programul pentru controlul miscarii

import serial

def setAngle(ser, channel, angle)

ser = serial.Serial("/dev/ttyACM0", 9600)

for i in range(0, 15)

setAngle(ser, i, 90)
Mai sus este comunicarea cu portul serial
Comandarea prin voce a robotului
else if (strcmp(word, "FORWARD") == 0)

system("/home/ubuntu/maestro_linux/robot.py")

Constructia unui robot care sa zboare

Controlerul
Alimentarea lui
Conectarea in pinii p8 si p9
Programarea servomotor

Comenzile
Conectarea
Comunicarea cu portul serial
import serial

Ser = serial.Serial('/dev/ttyUSB0', 9600, timeout = 1000):

x = 'n'

while x != 'q'

x = ser.read(1)

print x

Programul pentru servomotor

import serial

serInput = serial.Serial('/dev/ttyUSB0', 9600, timeout = 1000)

servo = int(ser.read(1)) and angle = int(ser.read(3))

Folosirea GPS pentru navigare

Conectarea GPS la placa de baza

Antenna
Programul de comunicare cu gps
import Adafruit_BBIO.UART as UART

import serial

UART.setup("UART2")

ser = serial.Serial(port = "/dev/ttyO1", baudrate=9600)

x = ser.read(1200)

print x

ser.close()

UART.clearup()
$GPRMC,020740.000,A,4349.1426,N,11146.1064,W,1.82,214.11,021013,,,A*7B
Programul

import serial
UART.setup("UART2")

ser = serial.Serial(port = "/dev/ttyO1", baudrate=9600)

x = ser.read(1200)

pos1 = x.find("$GPRMC")

pos2 = x.find("\n", pos1)

pos2 = x.find("\n", pos1)

loc = x[pos1:pos2]

data = loc.split(',')

if data[2] == 'V'

else

calculul distantei
Masurarea vitezei cu sensor analog

Senzorul
Pinii

Calibrarea
Conectarea la caramida
Programul

Rularea

Programarea servomotorului
Executia

Directia
Modificarea operatiilor unui vehicul

Din PVC

Prinderea la capat
Acumulatorul
Controlul cu placa de baza
Conectareaq cablurilor

Programul
import Adafruit_BBIO.PWM as PWM

motor1 = "P8_13"

duty_stop = 9

duty_forward = 12 # 12 max

duty_back = 6

PWM.start(motor1, duty_stop, 60.0)

print "Ready"

key = '0'

while key != 'q'

key = raw_input(">")

print key

if key == '1'

PWM.set_duty_cycle(motor1, duty_forward)

elif key == '2'

PWM.set_duty_cycle(motor1, duty_back)
elif key == '3'

PWM.set_duty_cycle(motor1, duty_stop)

elif key == '4'

PWM.stop(motor1)

PWM.cleanup()
Conectarea la retea si placa de baza
Routerul

Testul
 iface usb0 inet static
address 192.168.7.2
netmask 255.255.255.0
network 192.168.7.0
gateway 192.168.7.1

Sa accesat camera mai sus

Elicopterul sau drone

Principiul mathematic
Controlul inaltimii
Conectarea la caramida si placa de baza
Practice

Ecranul caramizii
Incarc pe ea motorul

Alagem drone
Dispunerea motoarelor

Testam senzorul de inaltime

Calibrarea
Programul

Verificam receptia
Controlul interfetei
Controlul prin wireless si cu o consola de jocuri

Programul
Codul de pe server
Controlul pe baza de integrale si derivate
ANEXA TEORETICA

Cum să programezi în Python

Cuprins ANEXA

Cuprins ........................................................................................................................................................... 2
De ce să te apuci de programare? ......................................................................................................... 4
Cu ce limbaj ar trebui să încep? .........................................................................................................................5
De ce Python? ..........................................................................................................................................................8
Capitolul I Instalarea Python 3. Noțiuni fundamentale .............................................................. 10
Instalarea Python3 în Windows ..................................................................................................................... 10
1.1. Primul program ............................................................................................................................................................ 12
1.2. Noțiuni fundamentale ............................................................................................................................................... 14
1.3. Variabile .......................................................................................................................................................................... 18
1.4. Puțină matematică ...................................................................................................................................................... 26
1.5. “Spargerea” declarațiilor lungi în linii multiple ............................................................................................. 28
1.6. Specificarea unui item separator.......................................................................................................................... 28
1.7. Concatenarea ‐ afișarea mai multor itemi cu operatorul + ....................................................................... 29
1.8. Formatarea numerelor (Important!!!) ............................................................................................................... 29
1.9. Formatarea întregilor ................................................................................................................................................ 33
1.10. Formatarea șirurilor ............................................................................................................................................... 33
Capitolul II FUNCȚII .............................................................................................................................. 35
2.1. Definirea și invocarea unei funcții ....................................................................................................................... 35
2.2. Invocarea unei funcții ................................................................................................................................................ 36
2.3. Indentarea (Important!!!) ........................................................................................................................................ 37
2.4. Variabile locale ............................................................................................................................................................. 37
2.5. Constante și variabile globale ................................................................................................................................ 40
2.6. Funcția lambda ............................................................................................................................................................. 41
Capitolul III STRUCTURI DE DECIZIE ................................................................................................ 43
3.1. Declarația if ................................................................................................................................................................. 43
3.2. Operatori de comparatie .......................................................................................................................................... 44
3.3. Declarația if‐else .......................................................................................................................................................... 44
3.4. Operatori logici............................................................................................................................................................. 46
3.5. Variabile booleene ...................................................................................................................................................... 47
3.6.Bucle................................................................................................................................................................................... 47
3.7. Bucla while – o buclă controlată ........................................................................................................................... 47
3.8. Bucla infinită ................................................................................................................................................................. 49
3.9. Bucla for .......................................................................................................................................................................... 49
3.10. Acumulatori ................................................................................................................................................................ 52
3.11. Operatori de atribuire augmentată................................................................................................................... 53
3.12. Bucle de validare a intrărilor ............................................................................................................................... 53
3.13. Bucle imbricate .......................................................................................................................................................... 55
Capitolul IV Module ................................................................................................................................ 56
4.1.Biblioteci de funcții standard și declarația import ........................................................................................ 56
4.2. Generarea numerelor aleatoare ............................................................................................................................ 56
4.3. Funcțiile randrange, random și uniform ........................................................................................................... 58
4.4. Scrierea propriei funcții care returnează o valoare ..................................................................................... 59
4.5. Modularea cu funcții .................................................................................................................................................. 60
4.6. Modulul matematic ..................................................................................................................................................... 61
Capitolul V Fișiere și excepții ........................................................................................................ 64
5.1.Tipuri de fișiere ............................................................................................................................................................. 64
5.2. Metode de acces a fișierelor ................................................................................................................................... 65
5.3. Deschiderea unui fișier în Python ........................................................................................................................ 65

2
 5.4. Scrierea datelor într‐un fișier ................................................................................................................................ 66
5.5. Citirea datelor dintr‐un fișier ................................................................................................................................. 68
5.6. Adăugarea datelor într‐un fișier existent ......................................................................................................... 70
5.7. Scrierea și citirea datelor numerice .................................................................................................................... 70
5.8. Copierea unui fisier .................................................................................................................................................... 71
5.9. Fișiere binare ................................................................................................................................................................ 72
5.10. Excepții.......................................................................................................................................................................... 73
Capitolul VI Liste, tupluri, dicționare și seturi. Serializarea obiectelor (pickling) ......... 76
6.1. Liste ................................................................................................................................................................................... 76
6.2. Metode și funcții preconstruite pentru liste .................................................................................................... 84
Metoda append ..................................................................................................................................................................... 84
6.3. Tupluri ............................................................................................................................................................................. 89
6.4. Dicționare ....................................................................................................................................................................... 90
6.5. Metode ale dicționarelor .......................................................................................................................................... 95
6.6. Seturi................................................................................................................................................................................. 98
6.7. Serializarea obiectelor (pickling) ...................................................................................................................... 100
Capitolul VII Clase și obiecte. Programarea orientată pe obiect ........................................... 103
7.1. Definiții ......................................................................................................................................................................... 103
7.2. Clase ............................................................................................................................................................................... 106
7.3. Crearea claselor în Python ................................................................................................................................... 108
7.4. Adăugarea atributelor ............................................................................................................................................ 109
7.5. Să punem clasa la treabă........................................................................................................................................ 110
7.6. Argumentul self ......................................................................................................................................................... 111
7.7. Definirea unei clase – o altă abordare ............................................................................................................. 112
7.8. Moștenirea (Inheritance) în Python................................................................................................................. 117
Cap. VIII Crearea si manipularea formularelor web................................................................ 123
8.1. Drepturi de acces la fișiere ................................................................................................................................... 131
Milioane de posibilități........................................................................................................................ 133
Bibliografie .............................................................................................................................................. 134

3
De ce să te apuci de programare?

Pentru că:

1. îți ține mintea trează

2. e fun

3. e o activitate care îți aduce prestigiu

4. poți caștiga bani (mulți!)

Până la 45 de ani nu mă interesa mai deloc IT‑ul. Mi se părea un univers inaccesibil.

Foloseam calculatorul ca orice user de rând: scriam texte pe care abia dacă reușeam să le

“tehnoredactez”, citeam sau trimiteam email‑uri și uneori lecturam ziare sau publicații

online. După aceea s‑a produs declicul. Păcat că am descoperit acest minunat domeniu

cam târziu, când creierul nu mai funcționează ca odinioară.

Toată viața am crezut că programarea înseamnă inainte de toate să fii tobă de matematică.

E o exagerare. După ce am studiat limbaje de programare vreme de trei ani, am ajuns la

concluzia că nu trebuie să știi mai mult de operațiile matematice fundamentale la care se

adaugă și cunoașterea ordinii lor. Astea se învață din câte îmi amintesc prin clasa a șasea

sau a șaptea, atunci când deslușești tainele algebrei 1.

Cel mai important lucru în asimilarea unui limbaj de programare este în opinia mea

sintaxa, adică regulile după care sunt puse semnele, numerele sau declarațiile dintr‑un

program. Din necunoașterea lor în profunzime vin și cele mai multe erori în scrierea unui

program. Când am început să deslușesc tainele PHP uitam mai mereu să închei linia de

program cu punct și virgulă așa cum e regula. Asta genera permanent erori pe care apoi, cu

cât programul devine mai lăbărțat, le dibuiești greu, cam ca pe acul din carul cu fân.

Ce îți este necesar ca să scrii un program (pe lîngă ceva cunoștințe de mate și

stăpânirea sintaxei)? Dăruire, atenție și…scrierea de programe. Fiecare carte care afirma ca

te învață un limbaj de programare are în general la sfârșitul capitolelor o secțiune de

exerciții și probleme. E partea cea mai importantă (și captivantă)! Citiți bine teoria, scrieți

1
Asta desigur e valabil pentru un anumit nivel (mai lipsit de pretenții…) în programare.

4
programele date în carte în propriul editor de text (nu descărcați codul aferent cărții de pe

site‑ul editurilor pentru ca vă va fi lene sa‑l rescrieți), analizați‑le și apoi procedați la

rezolvarea exercițiilor. Numai așa înveți!

Cu ce limbaj ar trebui să încep?

Aici e ca în proverbul acela cu câte bordeie, atâtea obiceie. Am stat odată ore întregi

pe forumuri pentru a afla un răspuns cât de cât adecvat la această intrebare. Oricum ar fi, e

bine să începi să studiezi un limbaj ușor. Dar există unul ușor, atât de ușor încât să fie

asimilat într‑o perioadă cât mai scurtă? Din experiența personală, nu. Totuși, un limbaj de

programare foarte ușor de implementat pe calculator și nu prea greu de învățat este

Python. Despre el am ales să scriu în această carte.

Există limbaje de programare complexe și altele mai puțin complexe. Există limbaje cu

ajutorul cărora se pot construi doar aplicații web și altele care pot aduce la viață idei

mărețe care ușurează viața de zi cu zi a celor care le folosesc. Acestea din urmă sunt cel mai

greu de învățat dar odată asimilate îți garantează satisfacții majore. Limbaje de scriptare

precum PHP sau Javascript sunt bune (doar) pentru a face site‑uri, bloguri, aplicații pentru

Internet în general. Când însă vorbim spre exemplu de programe de contabilitate, de

proiectare în inginerie sau arhitectură, de aplicații IT în medicină sau științe atunci intervin

adevăratele limbaje de programare: C, C++, Java, Python, Lisp, Pascal 2 etc.

Sfatul meu este să începeți, daca imi este permis, să studiați ‑ dintre limbajele grele ‑

pe cele mai ușoare! În niciun caz însă nu e indicat să vă apucați de învățarea C++. E

adevărat, el este regele balului (alaturi de Java…), e extrem de utilizat dar foarte dificil de

asimilat. Și C‑ul este asemenea lui ținând cont că îi este precursor. Java pe de altă parte,

seamănă mult (ca sintaxă cel puțin, cu toate că ceva mai…ușurică) cu C++ dar pe deasupra

are un mediu de dezvoltare greu de configurat pentru un incepator.

În tot cazul, nu vă apucați să deprindeți un limbaj de programare din sursă închisă

precum cele furnizate de Windows sau Apple. E drept C# sau Objective C se folosesc

(acum!) pe scară largă la construirea de aplicații pentru dispozitivele mobile aflate în mare

2
Vezi site-ul Tiobe.com (http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html)

5
vogă. Dar țineți minte că voga e modă și de obicei ea trece – mai încet sau mai repede, dar

tot trece. Sfatul meu e să învățați limbaje de programare portabile pe orice sistem de

operare și mai ales din sursă deschisă. Unele dintre ele n‑au moarte. C spre exemplu se

îndreaptă spre 50 de ani3 și nu dă semne că va pieri în curând. C++ are și el peste trei

decenii4 și la fel, e “în plină putere”, chiar dacă a mai scăzut în preferințele

programatorilor.

Atunci când căutați materiale tipărite sau online, tutoriale, cărți, exemple etc pentru

învățat, evitați titluri de genul : “Învață Java în 24 de ore!” Sunt minciuni ordinare! Java,

Python, C++ (chiar și Basic) nu se învață nici într‑o luna, nici măcar într‑un an, daramite

într‑o zi! Opinia mea – pe care o împărtășesc cu sinceritate, e că un limbaj de programare se

asimileaza în ani de zile. Și nici atunci, după o perioadă lungă de timp, nu cred că poți să

pretinzi că ești “geek”…După unele voci de mare încredere5, perioada optimă de timp

necesară deprinderii unui limbaj de programare este de zece ani!

Alegeți‑vă un limbaj de programare pe care‑l puteți iniția imediat și fără bătăi de

cap la compilare. Cel mai indicat e desigur Python. Îl descarci într‑o clipa de pe Internet, îi

configurezi variabilele de mediu (în Windows) și dai drumul la lucru. Alta e treaba cu Java,

C++ sau C. Ele necesită mai multă muncă și pentru un începător (care nu prea are pe cine

să întrebe în afară de Google6…) nu e chiar ușor.

Marele noroc (astăzi!) în deslușirea unui limbaj de programare este că pe Internet se găsesc

o mulțime de tutoriale și forumuri, locuri unde întotdeauna afli răspunsuri la întrebări

pentru că alții s‑au lovit inaintea voastră de aceleași probleme, desigur dacă ști să întrebi.

Uitasem un lucru esențial: limba engleză. Din observațiile pe care le tot fac de vreo

câțiva ani, am observat că există câteva nații care excelează în IT. Printre ele, la loc de

cinste, indienii, chinezii și nordicii. Am găsit și explicații. La indieni e vorba despre

numărul uriaș al populației. Vă imaginați că din peste un milliard de oameni ai de unde

3 1972
4 1980
5
http://norvig.com/romanian21-days.html
6 Din păcate, literatura IT în România e sublimă dar (aproape) lipsește cu desăvârșire. Se mai găsesc rătăcite

prin librarii vestigii din anii ’90 sau începutul ori mijlocul anilor 2000, total depășite astăzi.

6
alege câteva sute sau mii de căpățâni luminate. Aceștia au avut poate norocul educației și

pe cale de consecință, a ieșirii din foame. Într‑o țară în care speranța de viață e de 40 de ani,

a fi instruit e o șansă uriașă! Programarea i‑a scos pur și simplu din sărăcie, i‑a adus adesea

în America și i‑a angajat la companii de vârf precum Windows, Oracle, IBM, Apple.

Căutați informații despre diverse companii de top și nu se poate să nu găsiți în poziții de

frunte indieni sau chinezi. Numărul foarte mare și sărăcia pe măsură este explicația

succesului (multora dintre ei) în IT.

Ceilalți sunt nordicii. Câteva exemple edificatoare: cel care a proiectat Linux‑ul este

finlandez cu rădăcini suedeze; cel care a făcut inițial PHP‑ul este danez, cel care a făcut C++

este danez, cel care a proiectat Python‑ul este olandez. Și exemplele pot continua. Ei,

contrar indienilor ori chinezilor, provin din țări foarte dezvoltate economic dar paradoxal,

cu populație deficitară. Și atunci de unde formidabilul succes în IT? Am găsit și aici o

explicație: condițiile meteo. Când ai jumătate sau mai bine din an temperaturi negative,

când plouă sau ninge neîntrerupt zile intregi ești nevoit să stai în casă, eventual în fața

computerului. Cu el îți omori timpul, cu el comunici cu alții și tot el te poate aduce pe

culmile gloriei.

Și totuși, cei care au inventat calculatorul, limbajele ințiale de programare și tot ce

ține de IT au fost americanii, adică un popor care vorbește limba engleză, limbă în care

logic, au scris și limbajele de programare, apropiate ca vocabular acesteia. De aici rezultă

importanța fundamentală a limbii engleze în învățarea limbajelor de programare. Totuși,

nu vreau să vă sperii. Nu trebuie să stăpâniți engleza la nivel oxbridge, însă un bagaj minim

de cuvinte este absolut necesar să‑l posedați. Mai trebuie să știți – fie doar pentru cultura

generală – că la baza industriei IT de astăzi au stau odinioară proiecte militare americane

(realizate în colaborare cu mediul academic), care datează încă hăt, din timpul celui De‑al

Doilea Război Mondial. Apoi a venit mediul de afaceri ce a avut nevoie de aplicații care să

ușureze munca, să mărească productivitatea și implicit profitul. Ca o concluzie, IT‑ul are

origini militare, academice și financiare. Doar cei care puteau susține financiar cercetarea în

domeniile de vârf puteau obține rezultate, nu? Timpul a dovedit că au reușit dar mai ales,

aplicațiile – bazate 100% pe limbaje de programare si care odată, de mult, erau accesibile

7
doar unei mâini de oameni, au devenit astăzi un lucru banal și cât se poate de comun.

Pentru asta trebuie doar să jonglați puțin cu un telefon mobil inteligent care este “înțesat”

cu ele.

De ce Python?
Pentru că în primul rând este un limbaj curat ca sintaxă și foarte ușor de

implementat pe orice calculator. Legenda spune că Guido van Rosssum – creatorul Python,

a pus bazele limbajului într‑un week‑end de Crăciun când se plictisea și nu prea avea cu ce

să‑și omoare timpul. Cert este că olandezul, care a lucrat mulți ani după aceea la Google7, a

reușit să ofere lumii un limbaj cu o sintaxă simplă și suplă, cu reguli clare și de netrecut și

care se folosește astăzi pe scară largă în mediul academic american (tocmai pentru

învățarea limbajelor de programare), în afaceri dar și în proiectarea unor aplicații de mare

succes. Youtube spre exemplu este scris în Python. Și Google folosește ca liant Python.

Asemenea lui Yahoo!. Renumitul ziar Washington Post folosește în varianta lui online

limbajul Python. Căutați pe Internet și veți găsi alte numeroase domenii în care Python are

un cuvânt important de spus.

Un alt motiv pentru care este indicat să începeți cu Python este dat de numărul de

entuziaști aflat într‑o creștere constantă și care se ocupă de Python. Internetul este plin de

informații despre el, de tutoriale, de cărți și forumuri. Este știut că într‑un fel, Python nu

poate să facă ceea ce face C++ spre exemplu. Totuși, curba de învățare a celor două limbaje

este radical diferită. Cred sincer că un programator Python valoros se poate forma în circa

doi – trei ani, bine‑nțeles dacă stă cu brânca pe carte. Nu același lucru se poate afirma

despre C++…

Altfel decât PHP – un alt limbaj relativ ușor de asimilat, cu Python se pot realiza proiecte

web dar / sau mai ales, aplicații desktop de sine stătătoare.

Un alt motiv pentru care este bine să învățați Python e numărul relativ redus (pe

plan mondial, în România ce să mai vorbim…) de programatori în acest limbaj. Știu, veți

spune că site‑urile de joburi sunt pline de oferte de muncă pentru programatori Java, C,

7 Van Rossum a plecat între timp la Dropbox, după șapte ani petrecuți în ograda Google.

8
C++, C# , PHP sau Objective C și mai puțin Python. Așa este, numai că numărul

programatorilor Java sau PHP este covârșitor în vreme ce al celor care se ocupă de Python

– cu toata creșterea lui ‑ nu. De aici vine și confuzia care se creează cu privire la găsirea

unui job legat de Python. Dați un banal search pe Google cu cuvintele cheie “python

jobs(s)” și veți avea afișate istantaneu în fața ochilor un noian de rezultate care mai de care

mai interesante. Sunt oferte peste oferte, ce‑i drept, majoritatea de peste Ocean. Asta nu

înseamnă că nu aveți șanse. Nu trebuie neapărat să lucrați full time la sediul din Chicago

sau din Silicon Valey al unei firme, ci în intimitatea propriului cămin. Restul îl face

Internetul, Skype, Messenger și/sau PayPal. Internetul a anulat distanțele, a făcut ca

proiectele și ideile să circule nestingherite cu viteze uluitoare iar banii să intre (sau să

iasă…) din conturi la fel.

Ultimul motiv și poate cel mai important este prestigiul. Stăpânirea Python (sau a

oricărui alt limbaj de programare) face diferența în ochii cunoscătorilor, a prietenilor sau

rudelor dar mai ales în ochii voștri. A ști să programezi îți ține mintea activă, te face să fii

mândru de tine, să te simți tânăr și cine știe, cu multă muncă și ceva șansă, îți poate aduce

și venituri substanțiale.

Succes!

9
Capitolul I Instalarea Python 3. Noțiuni fundamentale

În această carte vom lucra cu Python 3 (sau variantele lui ulterioare). În prezent

există variantele Python 2 (și cele din clasa lui: 2.6 și 2.7 care sunt cele mai răspândite) și

Python 3 (de asemenea cu variantele lui). Din păcate, Python 3 nu a devenit încă

standardul dar, cel mai important, urmeaza sa devina! Tot din nefericire, majoritatea

framework‑urile necesare aplicațiilor web sunt scrise în Python2. Ele nu sunt compatibile

cu Python 3, așa că dacă veți încerca să le instalați pe un computer care rulează Python 3

nu veți reuși. O excepție notabilă8 este din cele observate de mine, Pyramid. Oricum, până

la a proiecta aplicații web scrise în Python e cale lungă de bătut pe care o începem cu..

Instalarea Python3 în Windows

Ca să programezi în Python trebuie mai întâi să‑l instalezi pe computer. Îți alegi ultima

distribuție de pe site‑ul www.python.org. În Windows lucrurile sunt puțin mai complicate

dar nu deznădăjduiți. Descarci de pe link‑ul de mai sus (www.python.org) executabilul

(.exe) ultimei variante pe care‑l rulezi (Run). Pachetul este instalat automat pe partiția “C”

(vă sfătuiesc să nu o schimbați). Dacă însă vei deschide o fereastră în linia de comandă și

vei scrie python, limbajul nu va funcționa (încă) pentru că nu ai schimbat calea de rulare în

variabila de mediu și calculatorul nu știe unde să‑l găsească.

Iată care sunt pașii ca să faci asta:

1. Start -> Computer
2. Properties
3. Advanced Settings
4. Environment Variables
5. Path (Edit)
6. Aici adaugi la sfârșitul liniei următoarele: ; C:\Python329 (nu uita de semnul

punct și virgulă (;) scris înaintea datelor!)

8 Între timp și Django – cel mai folosit și cunoscut web framework Python, a migrat complet spre Python3 ori
Mezzanine
9 python32 e varianta mea. La voi ar putea fi python33 sau python34 (varianta din momentul scrierii cărții)

10
 7. Ok
8. Restartezi computerul

Dupa repornire, deschizi o nouă fereastră Command Prompt (DOS) și scrii python. Abia

acuma vei avea posibilitatea să “jonglezi” cu limbajul de programare Python în modul

interactiv.

Ca să rulezi un program Python în modul script (vom vedea imediat ce înseamnă asta) în

Windows 7 sunt necesari următorii pași:

1. Scrii programul în Notepad (sau orice alt editor, mai puțin MS Word..)

2. Îl salvezi (pe Desktop) cu extensia .py din meniul derulant al Notepad

3. Pornești Command Prompt‑ul tastând cheile Windows+R și scriind în căsuță cmd,

după care apeși Enter

4. Odată fereastra Command Promt deschisă, schimbi aici directorul pe desktop cu

comanda: cd Desktop (adică acolo unde ai salvat fișierul Python, să‑i zicem

test.py)

5. Scrii la prompter: python test.py

Dacă totul este în regulă și programul nu are erori de sintaxă, el va fi rulat fără probleme.

În MacOS X

Spre deosebire de Windows, în Mac OS X Python este deja (pre)instalat. Tot ceea ce trebuie

să faci este să deschizi Terminal‑ul (din Applications ‑> Utilities ‑> Terminal) și să scrii la

prompt: python. Imediat îți va apărea promterul python care este >>> și unde poți începe

să…”programezi” (asta în modul interactiv). Daca vei scrie însă programe într‑un editor de

text gen Smultron (până recent era gratis dar acuma obeserv că dezvoltatorul i‑a pus prețul

de 5$ pe Apple Store), atunci vei urma pașii de la rularea în Windows. În linii mari sunt

aceiași. Scrii programul în editorul preferat, îl salvezi pe desktop cu extensia .py, deschizi

Terminalul, schimbi directorul (cd desktop) și rulezi programul (python test.py).

11
De obicei OS X “Snow Leopard”, “Lion”, „Mountain Lion” și “Maverick” au deja

preinstalate versiunile 2.6. sau 2.7. (ori mai vechi) ale Python. Dacă însă ai descărcat o

variantă 3.0 sau peste (de exemplu 3.2. , 3.3. sau 3.4.), ea va fi instalată în Applications. Nu

este nicio problemă, căci ca s‑o rulezi trebuie doar ca în Terminal să scrii în linia de

comanda python3 și programul va începe să funcționeze. Totuși, dacă vrei ca ultima

versiune Python (din clasa 3) să‑ți pornească automat atunci când scrii doar python în

Terminal (care îți va deschide invariabil varianta mai veche, cea preinstalată) trebuie să faci

unele modificări.

Acestea sunt următoarele10:

1. În Terminal scrii: open ~/.bash_profile . Această comandă îți va deschide în

editorul predefinit (TextEdit) fișierul pomenit.

2. Adaugi aici, în poziția cea mai de sus, următoarele:

3. alias python=”python3″

4. Salvezi

5. Redeschizi Terminalul și scriind python vei observa că versiunea Python3

este cea care rulează.

1.1. Primul program

În Python există două moduri de a vizualiza programele:

- în interpretorul Python
- în modul script

Să vedem mai întâi, pentru a vă convinge că Python este un limbaj grozav, care este
diferența între scrierea celui mai simplu program în Java și unul în Python. În Java:

// my first program in Java

10În versiunea Mac OS Maverick, acest truc nu funcționează, astfel că în linia de comandă scrieți python3 și
dați enter. Dacă nu adaugați numărul 3 dupa comanda python, computerul afișează în Terminal shell‑ul
versiunii 2.7. care este preinstalată. Daca lucrati in Ubuntu Linux, in versiunea 14 Python 3 este deja
preinstalat. Scrieti in Terminal (shortcut „Ctr+Alt+T„) python3 si este deschis shell‑ul Python.

12
public class HelloWorld {

public static void main(String[] args) {

System.out.println("Hello, World");
}

și acuma în Python:

>>> print(‘Hello World!’)

Fig.1.1. Hello World! în Python shell

Deci ceea ce în Java se afișează cu ajutorul a șase linii, în Python se face cu una singură!
Pentru scrierea primului (și următoarelor) programe în Python trebuie să deschideți

interpretorul Python astfel:

Windows -> All Programs -> Python32 -> Python (Command Line) [Enter]

Același lucru se face și fără invocarea interpretorului, direct din Command Prompt /

fereastra DOS (Windows) sau Terminal (Mac OS, Linux). În fapt, sfatul meu este să lucrați

doar cu acest instrument.11

Există de asemenea și mediumuri profesionale de dezvoltare a programelor Python, cum

ar fi Eclipse, Netbeans sau Pycharm (exclusiv pentru Python). Cu toate că primele două

sunt dedicate programării în Java, ele admit instalarea de add‑on‑uri suplimentare pentru

crearea si testarea programelor scrise in Python. Totuși, nu vă sfătuiesc să utilizați aceste

mediumuri complexe (cel puțin nu la început de drum) care sunt îndeajuns de intimidante

pentru un începător. În plus, nici configurarea lor inițială nu e prea lesne de realizat.

Să revenim însă la lucruri ușoare. Astfel, o dată ce ai scris o declarație aici (în Windows

Command Prompt sau MacOS/Linux Terminal), automat – după apăsarea tastei “Enter”,

11Totul este însă ca în Enviromnent Variables (Windows) calea de rulare către executabilul Python să fie
configurată corect (vezi p.11‑12 instalarea Python).

13
intrepretorul Python o (și) afișează pe ecran:

Fig.1.2. Interpretorul Python în MacOS Terminal

1.2. Noțiuni fundamentale

Declarațiile (statements) sunt liniile (conținutul) unui program. Toate declarațiile dintr‑un

program scrise în modul script și salvate pe hard‑ul calculatorului cu extensia .py se

cheama cod sursă sau pur și simplu cod.

Modul script

Spre deosebire de interpretorul Python, modul script salvează declarațiile din program pe

calculator. Acestea sunt de fapt, în opinia mea, adevăratele programe.

Să afișăm de exemplu cu ajutorul programului următor, câteva informații despre un

personaj fictiv. Mai întâi scriem în editorul de text preferat (Notepad în Windows de

exemplu sau Smultron în Mac OS) următoarele linii de cod:

print(‘Vasile Popescu’)
print(‘Adresa: Str.N.Iorga, Nr.46, Bucuresti12’)
print(‘Telefon: 0722 200406’)

Fig.1.3. Programul scris în Notepad

Salvăm programul sub numele popescu.py (eu l‑am salvat pe desktop) și apoi îl rulăm din

linia de comandă cu comanda python popescu.py, nu înainte însă de a muta calea de

rulare a programului pe desktop cu comanda cd desktop13. Altfel, interpretorul Python

nu găsește fisierul (în cazul meu popescu.py) și va genera o eroare cât se poate de enervantă.

12 Puteți la fel de bine să scrieți București (cu diacritice). Nu va rezulta nicio eroare pentru că Python foloseste
pentru decodificare standardul UTF‑8 și nu ASCII.
13 Comanda cd desktop nu este case sensitive (nu ține cont dacă scrieți desktop sau Desktop) în Windows și

MacOS dar e case sensitive în Linux. Astfel, dacă lucrați pe un computer cu sistemul de operare Ubuntu
instalat (nu știu la celelalte distribuții Linux), comanda este neapărat cd Desktop, cu majusculă.

14
Poate vă întrebați de ce insist pe aceste aspecte care aparent nu par importante.

Dimpotrivă, ele sunt foarte importante, mai ales la început, când știi doar să deschizi

calculatorul dar esti plin de dorința de a învăța programare! Atunci când m‑am apucat să

deprind tainele programării, mă loveam mereu – și îmi venea să arunc computerul pe

fereastră – de aceste amănunte care apar exact la început de drum!

Fig.1.4. Rularea programului popescu.py în linia de comandă

Intrări, procesare, ieșiri, funcția print

Intrările (Input‑ul) care se fac de obicei de la tastatură, sunt datele pe care computerul le

primește de la utilizator. Urmează etapa procesării lor. Rezultatul operației de procesare se

numește ieșire (Output) și este afișat pe ecran.

Afișarea ieșirii cu funcția print

O funcție este un cod prescris care realizează o operație. Python are numeroase funcții

preconstruite. Totuși, dintre toate, fundamentală rămâne funcția print, adică exact aceea

care afișează ieșirea pe ecran.

Când un program execută o funcție, spunem că el cheamă (invocă) funcția. Când invocăm

funcția print, scriem cuvântul print urmat de un set de paranteze ( ). Înăuntrul

parantezelor scriem argumentul14 care reprezintă datele pe care le dorim afișate pe ecran.

Spre exemplu, la invocarea funcției print în declarația print(‘Hello World’),

argumentul este Hello World. Observăm că ghilimelele nu sunt afișate la ieșirea

programului. Ele doar arată începutul și sfârșitul textului pe care vrem să‑l afișăm.

14Parametrul este definit de numele care apare în definiția funcției, în vreme ce argumentul reprezintă
variabila trecută unei funcții atunci când este invocată. Parametrul definește tipul de argument(e) pe care o
funcție îl poate accepta.

15
Prin urmare, putem afirma că print este cea mai importantă funcție. Recapitulând, cu

ajutorul ei afișăm ieșirea unui program în Python. Încercați în shell‑ul Python următoarea

linie de cod:

>>> print(‘Hello world!’)

Hello world!
>>>

Șiruri și șiruri literale

Ex: ‘Vasile Popescu’

’46, N.Iorga’
‘Bucuresti, 0722200406’
Acestea sunt șiruri de date care se mai cheamă șiruri de date literale. Ele sunt incluse între

ghilimele. Se pot folosi ghilimele simple (‘ ‘), duble (“ ”) sau chiar triple (‘’’ ‘’’).

Să luăm de exemplu următoarea linie de cod care folosește ghilimele simple și duble:
print(“Vino’ncoa!”)
Ea va scoate la ieșire șirul literal:
Vino’ncoa!
Ce s‑ar întâmpla dacă în expresia (șirul) de mai sus am pune doar ghilimele simple (la fel

de bine duble sau triple)? Am primi din partea interpretorului (shell‑ul) Python o eroare de

sintaxă ca mai jos:

Fig.1.5. Eroare de sintaxă la punerea ghilimelor

Câteva cuvinte în plus trebuiesc adăugate despre ghilimelele triple (pe care nu le veți găsi

în Java, C++, C ori PHP) dar care au o semnificație aparte în Python. Mulți folosesc

ghilimelele triple pe post de comentarii, ceea ce este eronat. În Python comentariile sunt

(doar liniile de cod marcate) cu semnul diez (#) la început (citiți paragraful următor).

De exemplu #acesta este un comentariu.

16
Ghilimelele triple sunt tratate ca șiruri regulate15 cu excepția cazului în care este vorba de

mai multe linii. Totuși, ele nu sunt ignorate de interpretorul Python așa cum se întâmplă cu

comentariile care încep cu semnul diez (#). Ele sunt așezate imediat după definiția unei

funcții sau clase, ori în vârful codului unui modul, caz în care se numesc docstrings.

Docstring‑urile pot include în interiorul lor ghilimele simple, duble sau de ambele feluri

ca‑n exemplul de mai jos:

Fig.1.6. Utilizare ghilimele triple

Să vedem acuma ce se întâmplă daca scriem doar ghilimele_triple (fără funcția print) și

dăm enter:

Fig.1.7. Un șir „ciudat” de caractere apare la finalul procesării programului

Răspunsul este ușor nefiresc pentru că el ne arată codificarea intimă în Python folosind

caracterul „escape” (\).

Comentariile

Sunt folosite într‑un program ca să arăți ce ai vrut să faci acolo. Dacă peste câtva timp vei

redeschide programul, comentariile îți vor reaminti de ceea ce ai vrut să faci cu linia de cod

respectivă din program. Ele sunt ignorate de interpretorul Python dar nu trebuiesc

ignorate de tine!

În Python, comentariile încep cu semnul diez #.

Șirurile regulate sunt șirurile care nu sunt atribuite unei variabile.

15

17
Ex: #Acest program afiseaza
#numele unei persoane
print(‘Mircea Prodan’)

1.3. Variabile
Programarea înseamnă înainte de toate a jongla cu abstracțiuni. A lucra cu astfel de entități

ce nu sunt palpabile – cel puțin nu în faza lor de dezvoltare, este în opinia mea cel mai

dificil lucru pentru că în general, marea noastră majoritate avem o putere destul de limitată

de a imagina obiecte pipăibile dar care au drept fundament idei „incolore”, „inodore” și

mai cu seamă fără o formă anume. Din acest motiv ni se pare grea matematica...

Variabilele sunt printre cele mai importante elemente din programare și nu mă feresc să

afirm că dacă ele și manipularea lor este bine înțeleasă, ați făcut un mare pas înainte în

dobândirea unui limbaj de programare.

Totuși, spre deosebire de lumea programării orientată pe obiect (OOP), înțelegerea

variabilelor este mulțumitor de ușoară. Tot ceea ce trebuie să faceți este să vă gândiți la o

variabilă ca la o cutie în care depozitați ceva.

Permiteți‑mi s‑o luăm altfel. Să presupunem că ați terminat recent facultatea, ați redactat

licența – care v‑a fost aprobată de profesorul îndrumător și apoi, așa cum cere

regulamentul, trebuie s‑o puneți (s‑o depozitați) pe un CD ce urmează să stea la arhiva

universității multe decenii de atunci încolo, dar și să predați un exemplar tipărit. Lucrarea

dumneavoastră de licență – nu importă domeniul – este pe calculatorul personal sub forma

unui fișier Microsoft Word16 și deci ea este abstracta. Puteți s‑o țineți în mâna? Nu, eventual

puteți s‑o arătați cu degetul pe monitorul computerului! În momentul în care o printați și

legați, ea își pierde această calitate și devine un obiect în sine, cât se poate de palpabil, cu

care eventual vă puteți lăuda la familie și prieteni. Mergeți apoi la facultate și depuneți un

exemplar printat. Ea este înregistrată și depozitată într‑o încăpere a facultății. Hopa! Iată că

dintr‑o dată avem variabila care este încăperea și valoarea ei care este lucrarea de licență. Pe

Ar putea la fel de bine să fie o aplicatie de redactare din sursă deschisă în genul OpenOffice ori LibreOffice,
16

numai că universitățile românești acceptă doar fișiere Microsoft Word.

18
măsură ce alți și alți (potențiali) absolvenți își depun lucrările, numărul (valoarea) lor crește

dar încăperea (variabila17) rămâne aceeași.

Mutându‑ne oarecum în lumea computerelor, aveți acuma nevoie și de CD‑ul care să

conțină lucrarea în format digital. Prin urmare “ardeți” un CD nou nouț, depozitând pe/în

el lucrarea în format digital. Aici variabila este CD‑ul căruia i‑am atribuit valoarea lucrare

de licență. Exemplul meu poate nu este cel mai fericit pentru că un CD obișnuit se poate

inscripționa doar o singură data, ceea ce ar însemna că o dată atribuită o valoare variabilei,

aceasta nu se mai poate modifica. În programare acest fapt nu este adevărat (din acest

motiv se numește variabilă). Totuși, există CD‑uri care se pot inscripționa de mai multe

ori, radiind informațiile (valorile) de la un moment dat și înlocuindu‑le cu altele. Numele

variabilei (în cazul nostru CD) rămâne același, doar valoarea pe care i‑o atribuim (licența) se

schimbă.

O variabilă este un nume (cuvânt) care reprezintă o valoare stocată în memoria

calculatorului. Numele (variabila) se scrie întotdeauna în partea stângă:

age = 49 #Corect! Vârsta mea la data scrierii #primei
variante a lucrării
și nu
49 = age #Gresit!!
age = 52 #Corect!Vârsta mea la data scrierii #variantei
actuale
și nu
52 = age #Gresit!!
Semnul = nu înseamna egal ca în matematică ci reprezintă atribuirea.

În exemplul de mai sus :

(lui) age = (i‑am atribuit valoarea) 49 respectiv 52.

Când treci o variabilă ca argument al funcției print nu mai ai nevoie de ghilimele.

Ex:

17 De fapt numele ei...

19
 print( ) argument

funcția print
>>>latime = 10 (Enter)
>>>print(‘latime’)
latime
>>> print(latime) (Enter)
10
>>>
Exemplu de program care demonstrează o variabilă:

(variabila.py)
#Acest program demonstreaza o variabila
camera = 123
print(‘Stau in camera: ’)
print(camera)
Ieșirea (output‑ul) acestui program este:
Stau in camera:
123
Sa vedem in linia de comanda (Terminal) cum putem face economie de spațiu și efort prin

renunțarea la ultima declarație print:

Fig.1.8. Variabila șir

Ce s‑ar fi întâmplat dacă în prima varianta a exemplului anterior, în ultima declarație

print am fi cuprins între ghilimele parametrul camera ca mai jos? Păi în loc să ne afișeze

valoarea parametrului care este 123, ne‑ar fi printat cuvântul (șirul literal) camera:

20
 Fig. 1.9. Importanța ghilimelelor18 la afișarea rezultatelor

Ați sesizat diferența?

Exemplu de program cu două variabile:

(variabila2.py)
#Creeaza doua variabile numite viteza si distanta
viteza = 160
distanta = 300
#Afiseaza valoarea referita de variabile
print (‘Viteza este: ’)
print (viteza)
print (‘Distanta parcursa este: ’)
print (distanta)19

Este indicat ca numele variabilei să înceapă cu literă mică. Variabilele sunt sensibile la

litere mici sau mari (case sensitive) așa că de exemplu python nu este totuna cu Python..

Numele variabilelor nu au voie să conțină cuvintele cheie din Python20. Variabilele nu

trebuie să conțină spații dar au voie să conțină (și să înceapă) cu semnul underscore ( _ ).

De asemenea, variabilele nu trebuie să înceapă cu un număr sau să conțină caractere

speciale precum $#%^&* ș.a.m.d.

Cu funcția print se pot afișa mai mulți itemi. Ex. (refacerea exemplului variabila.py):

#Acest program demonstreaza o variabila

18 Se pot folosi ghilimele simple sau duble, rezultatul este același.

19 Încercați acest exemplu pe calculatorul dumneavoastră, dar să cuprindă două declarații print și nu patru.
20 [ʹFalseʹ, ʹNoneʹ, ʹTrueʹ, ʹandʹ, ʹasʹ, ʹassertʹ, ʹbreakʹ, ʹclassʹ, ʹcontinueʹ, ʹdefʹ, ʹdelʹ, ʹelifʹ, ʹelseʹ, ʹexceptʹ, ʹfinallyʹ,

ʹforʹ, ʹfromʹ, ʹglobalʹ, ʹifʹ, ʹimportʹ, ʹinʹ, ʹisʹ, ʹlambdaʹ, ʹnonlocalʹ, ʹnotʹ, ʹorʹ, ʹpassʹ, ʹraiseʹ, ʹreturnʹ, ʹtryʹ, ʹwhileʹ,
ʹwithʹ, ʹyieldʹ]

21
camera = 123
print(‘Stau in camera numarul ’, camera)

Ieșirea este: Stau in camera 123

Dacă priviți cu atenție, veți observa ca propoziției îi lipsește ceva esențial (ca să

îndeplinească normele gramaticale de definire a propoziției) și anume punctul de la sfârșit.

Haideți să vedem cum îl afișăm. (Încercați să figurați răspunsul fără să citiți paragraful de

mai jos).

Dacă îl punem imediat după ultimul parametru al funcției print (camera) va rezulta o

eroare de sintaxă. Pentru a nu primi o eroare, punctul trebuie la rândul lui cuprins între

ghilimele ca în exemplul de mai jos:

Fig1.10. Afișarea corectă a unei declarații

Să mai observăm (în linia 4) că dacă nu adăugăm un item separator21 (ca‑n finalul liniei 5),

punctul este așezat ușor anormal, la o distanță destul de mare de locul în care ar trebui să

fie. În output‑ul din linia 6 această mică inadvertență (corectă totuși din punct de vedere al

programării, nu însă și estetic) este eliminată.

Stocarea șirurilor cu tipul de date str

#Creeaza o variabila care refera doua siruri
prenume = ‘Vasile’
nume = ‘Popescu’
#Afiseaza valorile referite de variabile
print(prenume, nume)
La ieșire vom avea: Vasile Popescu

21 Am luat‑o puțin înainte, dar veți vedea foarte curând ce reprezintă un item separator.

22
La fel de bine putem să inversăm numele dacă ultima declarație ar arăta astfel:
print(nume, prenume)
iar la ieșire ar rezulta Popescu Vasile.

Tipuri de date. Reatribuirea variabilelor diferitelor tipuri

În Python există câteva tipuri principale de date:

1. int ‑ întregi

2. float ‑ în virgulă mobilă22

3. string (str) ‑ șiruri

4. boolean – True, False

Ca să aflăm cu ce fel de date lucrăm utilizăm funcția type() ca în exemplele de mai jos:

Fig.1.11. Folosirea funcției type() pentru aflarea tipurilor de date

Ce se întâmplă însă dacă unui intreg îi adăugăm zero la sfârșit? Pentru noi el rămâne un

întreg, nu însă și pentru calculator. Astfel, el devine un număr în virgulă mobilă (float):

Fig.1.12. Transformarea int în float

În Python, o variabilă poate să refere orice tip de date: întreg, șir, în virgulă mobilă (float),

boolean. După ce o variabilă a fost atribuită unui anumit tip, ea poate fi reatribuită altui tip

de date.

22 Acestea nu sunt totuna cu numerele zecimale

23
Ex:

>>> x = 99 [enter] #aici avem o variabila int (întreg)

>>> print(x) [enter]

99
dar și :

>>> x = ‘Sa mergem la masa’ (enter) #aici avem o variabilă #str (șir)

>>> print(x) [enter]

Sa mergem la masa
>>>
sau float:
x = 0.15
print(x) [enter]
0.15
Putem de fapt să renunțăm la 0 și să lăsăm doar punctul urmat de valorile semnificative:

Fig.1.13. Am renunțat la 0 în declararea variabilei subunitare

Se observă că rezultatul este afișat însă normal – cu 0 înainte.

Obținerea inputului de la user

In programare, obtinerea informatiilor de la user este extrem de importanta. Altfel ca în

Java de exemplu, în Python acest lucru se face foarte ușor cu ajutorul funcției input().

Prompterul care clipește în fereastra DOS sau în Terminal este de fapt un șir care invită

userul să introducă date de la tastatură.

Ex.:

name = input (‘Care este numele tau? ’)

aici este un spațiu!!

variabilă tastatură datele șir

24
Spațiul dintre semnul întrebării din șirul ‘Care este numele tău? ’ și ultima ghilimea este

necesar pentru ca după răspuns, întrebarea și răspunsul să nu fie lipite (de ex: Care este

numele tău?Vasile Popescu în loc de Care este numele tau? Vasile Popescu).

Exemplu de program cu două șiruri la introducerea de la tastatură:

#Ia prenumele userului
prenume = input(‘Introdu prenumele: ’)
#Ia numele de familie
nume = input(‘Introdu numele de familie: ’)
#Afiseaza numele userului
print (‘Salut’, prenume, nume)23

Citirea numerelor cu funcția input

Funcția input returnează întotdeauna input‑ul (intrarea) userului ca pe un șir, chiar dacă

userul introduce date numerice.

De exemplu, dacă in fereastra interactivă tastezi numărul 65 și apeși Enter, valoarea

returnată de funcția input este șirul ‘65’. Aceasta poate fi o problemă dacă vrei să folosești

operații matematice.

Așadar:

Operațiile matematice pot fi făcute doar cu valori numerice și NU cu șiruri.

Exemplul următor folosește funcția input ca să citească un șir (str), un numar întreg (int) și

unul în virgulă mobilă (float).

(input.py)
#Ia numele, varsta si venitul financiar al userului
nume = input(‘Care e numele tau? ’)
varsta = int(input(‘Cati ani ai? ’))
venit = float(input(‘Care e venitul tau? ’))
#Afiseaza datele
print(‘Iata datele pe care le-ai introdus: ’)
print(‘Nume’, nume)

23Reproduceți toate aceste exemple încet și atent pe computerul dumneavostră. Nu le copiați ca să vedeți
cum și dacă funcționează!! Programarea înseamnă două lucruri esențiale: pasiune și răbdare...

25
print(‘Varsta’, varsta)
print(‘Venit’, venit)
Concluzia este următoarea: atunci când introduci nume sau alte date literale scrii simplu

input (‘……..’). Când însă introduci numere (întregi sau în virgulă mobilă) e musai să

arăți de ce tip sunt (int sau float)24.

int și float funcționează doar dacă itemul ce urmează să fie introdus conține o valoarea

numerică. Altfel, va apărea o eroare numită excepție.

1.4. Puțină matematică

Python are numeroși operatori cu care se pot face calcule matematice. Operatorii sunt

aceiași ca în matematica: + / * - dar și:

// împărțirea cu întreg (rezultatul e totdeauna un întreg, de ex. 10//3 = 3)

% rest – împarte un număr la altul și atribuie variabilei restul

** ridicarea la putere a unui număr

(și celalalte simboluri matematice).

Ex.

Fig.1.14. Împărțirea cu întreg, restul și ridicarea la putere

Să notăm că la ridicarea la putere, primul numar (în exemplul de mai sus 10) este cel

multiplicat la puterea dată de cel de‑al doilea număr (3 în cazul nostru).

Ex. salariu.py
#Atribuie o valoare variabilei salariu
salariu = 2500.0

24Cei care au programat în Java sau C știu că acolo e obligatoriu să declari tipul variabilei. De fapt, același
lucru se petrece și în Python, dar doar în cazul datelor cu valoare numerică.

26
#Atribuie o valoarea bonusului
bonus = 1200.0
#Calculeaza venitul total si
#atribuie valoarea variabilei plata
plata = salariu + bonus
#Afiseaza plata
print(‘Plata ta este: ’, plata)

Calcularea unui procent

Algoritmul este următorul:

- ia prețul original al unui item

- calculează 20% din prețul original; acesta este discountul

- scade discountul din prețul original; acesta e prețul de vânzare

- afișează prețul

Și acuma să vedem programul (pret_vanzare.py):

#Acest program ia pretul original si
#calculeaza un discount de 20%.
#Ia pretul original
pret_original = float(input(‘Introdu pretul original: ’))
#Calculeaza valoarea discountului
discount = pret_original * 0.2
#Calculeaza pretul de vanzare
pret_vanzare = pret_original – discount
#Afiseaza pretul de vanzare
print(‘Pretul de vanzare este: ’, pret_vanzare)

Precedența operatorilor matematici

1. Ridicarea la putere se execută prima (**)

2. Înmulțirea, împartirea și restul (* / // %) al doilea

3. Adunarea și scăderea ultimele

27
Ridicarea la putere a unei valori se scrie așa:

Ex: suprafata_patrat = lungimea**2

în care **2 este ridicarea la puterea a doua

sau

volum_cub = lungimea**3 (ridicarea la puterea a treia)

Operatorul rest (remainder) %

Ex. rest = 17 % 3

Variabilei rest îi atribuim valoarea 2 pentru ca 17/3 = 5 rest 2.

1.5. “Spargerea” declarațiilor lungi în linii multiple

Python permite să spargi o declarație în linii multiple folosind backslah‑ul ( \ ).

Ex:
print(‘Am vandut’, bucati_vandute, ‘pentru un total de’, vanzare_totala)

devine
print (‘Am vandut’, bucati_vandute, \
‘pentru un total de’, vanzare_totala)
Atunci când se sparge o declarație considerată prea lungă, indentarea (vom vedea puțin

mai târziu ce înseamnă acest lucru) este obligatorie.

1.6. Specificarea unui item separator

Când argumentele sunt trecute funcției print, ele sunt automat separate de un spațiu care

este afișat pe ecran.

Ex

>>> print(‘Unu’, ‘Doi’, ‘Trei’) [enter]

Unu Doi Trei
>>>
Dacă le vrei împreunate, treci argumentul sep=’’ funcției print la sfarsitul declaratiei:

>>> print(‘Unu’, ‘Doi’, ‘Trei’, sep=’ ’) #[enter]

UnuDoiTrei

28
>>>

Fig.1.15. Inserarea itemului separator

Caracterul escape

Caracterul escape este unul special care e ilustrat de un backslash (\) ce apare înăuntrul

unui șir literal.

Ex.
print(‘Unu\nDoi\nTrei’)
afișează:
Unu
Doi
Trei
ceea ce înseamnă că \n reprezintă o linie nouă (n vine de la new line)25.

1.7. Concatenarea ‑ afișarea mai multor itemi cu operatorul +

Când operatorul + se folosește la adunarea șirurilor se cheamă concatenare (legare).

Ex.
print (‘Acesta este26 ’ + ‘un sir.’)
care afișează:
Acesta este un sir.

1.8. Formatarea numerelor (Important!!!)

Când un număr în virgulă mobilă e afișat pe ecran, el poate avea și 12 zecimale.

Ex:
#Acest program demonstreaza cum un numar

25Încercați pe calculatorul personal să înlocuiți \n cu \t și vedeți ce rezultă. (Indiciu: litera t vine de la tab)
26Nu uitați că între ultimul cuvânt din primul enunț și ultima ghilimea care încadrează același enunț este un
spațiu. Daca nu e marcat corespunzator, ultimul cuvânt din primul enunț și primul din cel de‑al doilea vor fi
afișate lipite.

29
#in virgula mobila este afisat fara formatare
suma_datorata = 5000.0
plata_lunara = suma_datorata / 12.0
print (‘Plata lunara este ’, plata_lunara)
iar ieșirea programului este:
Plata lunara este 416.666666667

Fig.1.16. Valoare neformatată

Cum facem totuși ca rezultatul să nu mai apară ca o inșiruire grosiera de numere? Simplu:

invocăm funcția format. Când invoci funcția format, îi treci două argumente:

- o valoare numerică

- un specificator de format

Specificatorul de format (format specifier) este un șir care conține caractere speciale ce arată

cum valorile numerice trebuiesc formatate.

Ex: format (12345.6789, ‘.2f’)

Primul argument, care este un număr în virgulă mobilă (12345.6789), este numărul pe care

vrem să‑l formatăm.

Al doilea argument este un șir – ‘.2f’ – și reprezintă specificatorul de format.

Iată ce înseamnă el luat “pe bucăți” :

.2 specifică precizia; el arată că vrem să rotunjim numărul la două zecimale.

f vine de la float și specifică faptul că numărul pe care‑l formatăm este în virgulă mobilă

(pentru formatarea întregilor, cum vom vedea, nu se folosește litera f ci d).

În aceste condiții, funcția format returnează un șir care conține numărul formatat:

>>> print(format(12345.6789, ‘.2f’)) #[Enter]

12345.68

30
Să notăm că numărul este rotunjit la două zecimale, in sus27.

Acuma, să luăm același exemplu, dar rotunjit la o singură zecimală:

>>> print(format(12345.6789, ‘.1f’)) [Enter]

12345.7
Sa luăm un alt exemplu în fereastra interactivă:

Fig.1.17. Valoare formatată cu specificatorul de format

Formatarea în mod științific

Se utilizează literele e sau E în loc de f.

Ex:
>>> print(format(12345.6789, ‘e’))
1.2345678e +04
>>> print(format(12345.6789, ‘.2e’))
1.23e + 04
>>>

Inserarea separatorului virgulă

>>> print(format(123456789.456, ‘,.2f’)
123,456,789.46
separatorul virgulă28

Programul următor demonstrează cum separatorul virgulă și o precizie de două zecimale

pot fi folosite la formatarea unui număr mare:

(plata_anuala.py)

27 Pentru că a doua valoare din șirul de numere de după punct ‑ în speță 7 (.6789) este mai aproape de 10
decât de 0, computerul rotunjește valoarea în sus, ea devenind .68. Dacă ar fi fost în schimb .64..., .63..., .62...,
.61... atunci era rotunjită în jos, ea devenind 0.60.
28 Între separatorul virgulă și punctul situat înaintea lui (.2f) nu exista spațiu. Dacă este introdus din greșeală

va rezulta o eroare (“Invalid format specifier”).

31
#Acest program demonstreaza formatarea
#numerelor mari
plata_lunara = 5000.0
plata_anuala = plata_lunara * 12
print(‘Plata ta anuala este $’,\
format(plata_anuala, ‘,.2f’), \
sep=’’)
Ieșirea programului este:
Plata ta anuala este $60,000.00
Sa vedem cum funcționează programul în Terminal:

Fig.1.18. Rularea programul plata_anuala.py în shell‑ul Python

Să notăm că în ultima linie a codului am trecut sep=’ ’ ca argument al funcției print.

Acesta specifică faptul că nu trebuie afișat niciun spațiu între itemii care urmează să fie

afișați. Dacă nu facem acest lucru, va apărea un spațiu între $ și sumă.

Specificarea unei lățimi minime de spațiu

Următorul exemplu afișează un număr în câmpul care este de lațime 12:

>>> print(‘Numarul este’, format(12345.6789, ’12,.2f’))
Numarul este 12,345.68
>>>

Fig.1.19. Specificare lățimii de spațiu

Formatarea unui număr în virgulă mobilă ca procent

Aici în loc să folosim litera f folosim simbolul procentului ( %) ca să formatăm un număr ca

32
procent:
>>> print(format(0.5, %))
50.000%
Și încă un exemplu care are 0 ca precizie:
>>> print(format(0.5, ‘.0%’))
50%

1.9. Formatarea întregilor

Diferențele la formatarea întregilor față de numerele reale (în virgulă mobilă) sunt:

- folosești d în loc de f

- NU poți specifica precizia

Ex:
>>> print(format(123456, ‘d’))
123456
Acuma, același exemplu dar cu separatorul virgulă:
>>> print(format(123456, ‘,d’))
123,456

1.10. Formatarea șirurilor

Formatarea sirurilor e puțin mai complicată și se face cu ajutorul acoladelor ca în exemplul

următor:

Fig.1.20. Exemplu de formatare a șirurilor

Șirurile și alte obiecte au o sintaxă specială pentru funcții numită metodă, asociată unui tip

particular de obiect. Obiectele de tipul șir (str) au o metodă numita format. Sintaxa pentru

această metodă conține obiectul urmat de punct urmat de numele metodei și următorii

parametri dintre paranteze:

33
obiect.nume_metoda(parametri)
În exemplul de mai sus obiectul este șirul ‘Salut {}’ iar metoda este format.

Parametrul este nume.

După cum se observă la ieșire, acoladele sunt înlocuite de valoarea preluată din lista

parametrilor metodei format. Deoarece acoladele au un înțeles special în formatarea

șirurilor, este nevoie de o regulă specială dacă vrem ca ele să fie incluse în formatarea

finală a șirurilor. Regula este dublarea acoladelor: ‘{{‘ și ‘}}’

De exemplu29:

Fig. 1.21. Formatarea șirurilor

29 Vom vedea mai târziu ce reprezintă un set in Python.

34
Capitolul II FUNCȚII
O funcție reprezintă un grup de declarații care există într‑un program pentru a

realiza o anumită sarcină. Am vazut in primul capitol comportamentul functiei prestabilite

print.

Majoritatea programelor realizează sarcini care sunt îndeajuns de mari ca să poată fi

divizate în câteva subsarcini. Din acest motiv programatorii “sparg” programele în bucăți

mai mici cunoscute sub numele de funcții.

Astfel, în loc să scriem largi secvențe de declarații, scriem câteva funcții mai mici, fiecare

realizând o parte specifică din sarcină.

Aceste mici funcții pot fi executate în ordinea dorită pentru ca în final să realizeze soluția

la întreaga problemă.

2.1. Definirea și invocarea unei funcții

Definirea unei functii se face cu ajutorul cuvantului def (define). Codul unei funcții este

(și) definiția unei funcții. Ca să execuți o funcție, scrii pur si simplu declarația care o

invocă (numele funcției) urmată de paranteze ().

Numele funcțiilor

Numele unei funcții e bine să fie apropiat de ceea ce ea face. În Python, când denumim o

funcție urmăm aceleași reguli ca la botezarea variabilelor adică:

- nu poți folosi cuvintele cheie din Python

- nu pot exista spații între cuvintele care alcătuiesc numele funcției

- primul caracter trebuie să fie o literă de la a la z, de la A la Z sau underscore

(_)

- literele mici sunt tratate diferit de cele mari (case sensitive).

Pentru că funcțiile realizează acțiuni, e indicat să folosim verbe atunci când le alegem

numele.

De exemplu, o funcție care calculează venitul poate fi denumită pur și simplu

calculeaza_venitul. Unii programatori folosesc pentru notarea funcțiilor metoda

numită “cocoașă de camilă” (camelCase). Dacă am folosi‑o în exemplul nostru, atunci ea ar

35
arăta așa: calculeazaVenitul.

Formatul general este:

def nume_functie() :
declaratie
declaratie
………
Ex:
def mesaj():
print(‘Sunt Gigel,’)
print(‘si incerc sa invat Python!’)
Codul de mai sus definește o funcție numită mesaj. Functia mesaj conține un bloc cu două

declarații.

2.2. Invocarea unei funcții

Definiția unei funcții specifică ce face funcția dar nu o execută. Ca să execuți o funcție

trebuie să o invoci (să o chemi).

Iată cum invocăm funcția mesaj din exemplul anterior:

mesaj()
Când funcția e chemată, interpretorul sare la acea funcție și execută declarațiile din blocul

ei. Apoi, când blocul s‑a terminat, interpretorul sare înapoi la partea de program care a

chemat funcția și programul rezumă execuția în acel punct. Când se întâmplă asta,

spunem că funcția returnează.

Ex:

(functie_demo.py)
#Acest program defineste o functie 1
#Prima data definim o functie numita mesaj 2
def mesaj(): 3
print(‘Sunt Mircea,’) 4
print(‘si incerc sa invat Python.’) 5
#Apoi invocam functia mesaj 6
mesaj() 7
Cum funcționează? Interpretorul ignoră comentariile. Apoi citește declarația def în linia 3.

36
Aceasta creează o funcție numită mesaj în memorie. Ea conține declarațiile din liniile 4 și

5. Apoi interpretorul citește comentariul din linia 6 care este ignorat. La sfârșit citește linia

7 care invocă funcția mesaj. Aceasta face ca funcția să fie executată și să fie afișată ieșirea.

Fig. 2.1. Ilustrarea unei funcții în Python shell

2.3. Indentarea (Important!!!)

Într‑un bloc indentarea se face cu același număr de linii. De obicei se folosește tab‑ul

sau patru spații. Dacă în același program folosim o dată patru spații , altădată tabul sau

trei, cinci ori “n” spații, programul va da eroare de indentare:

Fig.2.2. Eroare de indentare

Indentarea în Python este obligatorie și se face pentru ca blocurile de cod din program să

fie perfect stabilite, ceea ce duce la lizibilitatea mai bună a programului. Indentarea ține de

fapt locul acoladelor din celelalte limbaje de programare din familia limbajului C. Ea ne

arata unde începe și se termină un bloc de declarații. Totodată ține loc si de semnul punct

și virgula cu care se sfârșesc obligatoriu declarațiile din limbajele de programare din

familia C.

2.4. Variabile locale

O variabilă locală este creată în interiorul unei funcții și nu poate fi accesată din afara ei.

Funcții diferite pot avea variabile locale cu același nume pentru că ele nu se pot vedea una

pe cealălaltă. De fiecare dată când atribui o valoare unei variabile în interiorul unei funcții,

37
creezi o variabilă locală.

Să luam un exemplu de program (pasari.py)30 care are două funcții și care fiecare conține o

variabilă cu același nume:

#Acest program demonstreaza doua functii
#care au variabile locale cu acelasi nume.
def main():
#Cheama functia dolj
dolj()
#Cheama functia gorj
gorj()
#Defineste functia dolj. Ea creeaza
#o variabila locala numita pasari
def dolj():
pasari = 5000
print(‘Doljul are’, pasari, ‘de pasari’)
#Defineste functia gorj. Ea creeaza
#o variabila locala numita pasari
def gorj():
pasari = 8000
print(‘Gorjul are’, pasari, ‘de pasari’)
#Cheama functia principala
main()

Trecerea argumentelor la funcții

Un argument este o porțiune de date care este trecută într‑o funcție atunci când funcția este

invocată.

Un parametru este o variabilă care primește un argument ce este trecut într‑o funcție.

Exemplu:

30Scrieți exemplele în editorul de text caracter cu caracter și nu le copiați (copy/paste) de pe formatul PDF în
care se găsește cartea pentru că există mari șanse să primiți o eroare de tipul: “SyntaxError: invalid character
in identifier”. Aceasta se întâmplă pentru că formatele PDF, Word, ODT etc au caracteristici intime diferite,
care cel mai adesea, nu se potrivesc interpretorului Python ce pur și simplu nu distinge ceea ce scrie în
declarații.

38
def dublul(numar):
rezultat = numar*2
print(rezultat)
Funcția se cheama dublul. Ea acceptă un număr (numar) ca parametru și afișează

valoarea dublată a acelui număr. Sa vedem cum functioneaza in interpretorul Python:

Fig.2.3. Exemplul anterior complet

Exemplu de program (show_double.py):

#Acest program demonstreaza cum un
#argument este trecut unei functii
def main():
valoare=5
arata_dublul(valoare)
#Functia arata_dublul accepta un argument
#si afiseaza valoarea lui dubla
def arata_dublul(numar):
rezultat = numar*2
print(rezultat)
#Cheama functia principala
main()

Fig. 2.4. Trecerea unui argument la funcție

39
Trecerea într‑o funcție a mai multor argumente

Există situații când trebuie să treci două sau mai multe argument unei funcții.
def main():
print(‘Suma lui 12 cu 45 este’)
arata_suma(12, 45)
def arata_suma(num1, num2):
rezultat = num1 + num2
print(rezultat)
#Cheama functia principala
main()
Să vedem exemplul în interpretor:

Fig.2.5. Exemplul de mai sus în Python shell

Schimbarea parametrilor
def main():
valoare = 99
print(‘Valoarea este’, valoare)
def schimba_valoarea(arg):
print(‘Voi schimba valoarea.’)
arg = 0
print(‘Acuma valoarea este’, arg)
#Cheama functia principala
main()

2.5. Constante și variabile globale

O variabilă globală este accesibilă tuturor funcțiilor dintr‑un program. Ea se creează în

afara oricărei funcții.

40
Ex:
#Creeaza o variabila globala
numar = 0
def main():
global numar
numar = int(input(‘Introdu un numar ’))
arata_numar()
def arata_numar():
print(‘Numarul introdus este: ’, numar)
main()
Este totuși indicat să nu folosiți variabile globale. În schimb puteți să utilizați constante globale.

O constantă globală referă o valoare care NU POATE FI SCHIMBATĂ.

Prin convenție, constantele globale se scriu cu majuscule și sunt așezate la începutul

programului, înaintea oricăror alte declarații, ca în exemplul următor:

Fig.2.6. Ilustrarea unei constate globale

2.6. Funcția lambda

Python permite crearea unei funcții anonime folosind cuvântul cheie lambda. O funcție

anonimă poate să conțină doar o singură expresie care neapărat trebuie să returneze o

valoare. Altfel ca la crearea unei funcții comune care folosește def, o funcție creată cu

lambda returnează un obiect funcție. Acesta poate fi atribuit unei variabile care poate fi

folosită în orice moment ca să execute expresia conținută. Să vedem cum arată în Terminal

o funcție normală, aceeași funcție creată cu ajutorul cuvântului cheie lambda și o funcție

lambda căruia nu‑i atribuim nicio variabilă (da, permite și acest lucru!).

41
Fig.2.7. Funcția lambda

42
Capitolul III STRUCTURI DE DECIZIE

Una dintre cele mai importante, interesante și frumoase părți ale programării este oferită

de structurile de decizie. Toți cei care au făcut programare în școală sau facultate – chiar

dacă nu au fost deloc interesați de domeniu, le‑a ajuns la ureche fie și total pasager cuvinte

precum if, while, else, continue. Dacă ați terminat un liceu cu profil real, nu se

poate să nu vă fi lovit de ele. Oricum ar fi, chiar dacă până acuma nu știați de existența lor,

a venit momentul să ne ocupăm de ele.

3.1. Declarația if
De cele mai multe ori într‑un program ajungi la o răspântie, mai corect spus, în fața unei

alegeri. Să ne imaginăm că mergem pe o șosea cu autoturismul personal și la un moment

dat ajungem la o bifurcație. Să zicem de exemplu că ne deplasăm de la Craiova către

București și am ajuns la Găneasa, Olt. Aici drumul se bifurcă: drumul spre dreapta duce la

București via Pitești, drumul la stânga duce către Râmnicu Vâlcea, via Drăgășani.

Să vedem cum arată drumul direct spre București „transpus” în Python cu ajutorul

condiției if (daca):
if (daca) laDreapta: #o iau la dreapta
print(’Ajung la Bucuresti prin Pitesti’)
Dar poate că vrem să mergem la Râmnicu Vâlcea. Programul nostru ar arăta astfel în

această variantă:
if(daca) laStanga: #o iau la stanga
print(’Ajung la Ramnicu Valcea prin Dragasani’)

Forma generală:

if conditie:

declaratie

declaratie

etc

43
Ex:
vanzari = float(input(’Introdu vanzarile tale: ’))
if vanzari > 5000:
print(’Ai un bonus de 500 de lei’)

3.2. Operatori de comparatie

Nu putem sa mergem mai departe inainte de a vedea care sunt operatorii de comparatie in

Python. Ei sunt prezentati mai jos:

Operator Semnificație
< Mai mic ca
> Mai mare ca
<= Mai mic sau egal cu
>= Mai mare sau egal cu
== Egal cu
!= Diferit de (nu este egal cu)
Tabel 3.1. Operatori de comparație în Python

3.3. Declarația if‑else

O declarație if‑else execută un bloc de declarații dacă (if) condiția e adevarată sau alt bloc

(else) dacă condiția e falsă.

Forma generală:

if conditie:

declaratie

declaratie

etc

else:

declaratie

declaratie

44
 etc

Ex:

Fig.3.1. Ilustrarea clauzei if‑else

Reguli de indentare a clauzei if‑else

- fiti sigur că if și else sunt aliniate

- fiti sigur că declarațiile care urmează dupa if și else sunt indentate la rândul lor.

Compararea șirurilor

Python permite să compari șiruri cu ajutorul declarației if‑else. Acest lucru îți dă voie să

creezi structuri de decizie care testează valoarea unui șir.

Ex (testare_nume.py):
nume1 = ‘Marcel’
nume2 = ‘Marius’
if nume1 == nume2:
print(‘Numele sunt la fel’)
else:
print(‘Numele sunt diferite’)

Structuri de decizie imbricate31 și declarația if‑elif‑else

Ca să testeze mai mult de o condiție, o structură de decizie poate fi imbricată înăuntrul

altei structuri de decizie.

Ex (imprumut.py):
MIN_SALARIU = 2000
MIN_ANI = 3
salariu = eval32(input(’Introdu salariul tau: ’))
ani_la_serviciu = eval(input(’Introdu ani de serviciu:’))

31Imbricat = îmbucat(e), suprapus(e) ca șindrilele de pe casa (cf.dexonline.ro)

32Atunci când introducem date numerice putem utiliza eval fără sa ne mai gândim dacă e vorba de o valoare în
virgulă mobilă sau de un întreg. eval ține loc de float sau input.

45
if salariu > = MIN_SALARIU:
if ani_la_serviciu >= MIN_ANI:
print(‘Te califici pentru imprumut’)
else:
print(‘Nu te califici’)
else:
print(‘Trebuie sa ai minim..’, MIN_ANI)

Fig.3.2. Declarația if‑elif‑else

Pentru a ușura și a face economie de efort și de spațiu se poate utiliza declarația (clauza) if‑

elif‑else. Mai sus este un exemplu de program ce include declarația if‑elif‑else; În

momentul în care userul introduce diverse valori cuprinse între 500 și 1000, programul va

afișa bonificația corespunzătoare. Dacă însă introduce o valoare mai mică de 500,

programul afișeaza șirul „Ești concediat!”.

3.4. Operatori logici

Sunt: and, or, not.

Exemplu and:
if temperatura < 20 and minute > 12:
print(‘Temperatura e periculoasa’)
Exemplu or:
if temperatura < 20 or temperatura > 100:
print(‘Temperatura este extrema’)
Exemplu not:
if not(temperatura > 100):

46
 print(‘Aceasta e aproape temperatura maxima’)

3.5. Variabile booleene

O variabilă booleană poate referi două valori: TRUE sau FALSE. Ele arată dacă o condiție

există. Variabilele booleene sunt folosite ca indicatori. Un indicator este o variabilă care

semnalizeaza când o condiție există în program.

Ex:
if cota_vanzari >=5000.0:
cota_vanzari_ok = True
else:
cota_vanzari_not_ok = False

3.6.Bucle
Buclele sunt acele părți dintr‑un program care sunt folosite ca să execute o declarație atâta

timp cât o expresie este adevărată.

3.7. Bucla while – o buclă controlată

O condiție controlată face ca o declarație sau un bloc de declarații să se repete atâta timp

cât o condiție e adevărată. Python folosește declarația (bucla) while ca să scrie o astfel de

condiție.

Formatul general al buclei while este:

while conditie:

declaratie

declaratie

etc

Ex:
while valoare == ‘y’:
Exemplu:

47
 Fig. 3.3. Bucla while

Bucla while nu se execută niciodată dacă condiția de început e falsă.

Să mai luăm un exemplu de buclă while. Vom scrie un program care transformă gradele

Fahrenheit în Celsius.

Formula de transformare este:

C = 5/9 * (F‑32)

(temp.py)

Fig.3.4. Bucla while

Este nevoie ca la începutul programului să setăm temp = 0 pentru că altfel primim o

eroare. Programul pornește, iar bucla while caută să vadă dacă variabila temp nu cumva

este egala cu -100. Dacă temp nu a fost setată inițial cu 0, se creează o problemă pentru că

temp nu există și bucla while nu știe ce să facă! În locul valorii 0 putem pune oricare altă

cifră dar nu ‑100. Dacă facem asta, bucla while devine falsă dintr‑un început și nu rulează

niciodată.

O buclă while e asemănătoare condiționalei if cu diferența că cea din urmă funcționează

48
doar o singură dată iar while până când condiția ei este atinsă (în cazul nostru temp = -

100).

Să șlefuim puțin exemplul de mai sus, astfel încât atunci când utilizatorul introduce

valoarea ‑100, computerul să‑i spună „La revedere!”:

temp = 0
while temp != -100:
temp=eval(input(’Introdu temp. in F(-100 ca sa iesi):’ ))
if temp != -100:
print(’Temp in C este: ’, format(5/9*(temp-32), ’,.2f’))
else:
print(’La revedere!’)

3.8. Bucla infinită

Să spunem că avem următorul exemplu de buclă while:
numar = 0
while numar < 10:
print(numar)
În acest program valoarea variabilei numar nu se schimbă niciodată și deci declarația

numar < 10 este întotdeauna adevărată. Python va afișa la infinit numărul 0. Ca să oprim

bucla infinită trebuie pur și simplu să întrerupem brutal shell‑ul Python. Există însă o

posibilitate de a întrerupe o buclă infinită atunci când scriem programul. Pentru aceasta

folosim declarația break:

x = 0
numar = 1
while x < 10 and numar > 0:
numar = int(input(’Introdu un numar: ’))
break

3.9. Bucla for

Bucla for iterează de un număr specific de ori.

Format general:

for variable in [value1, value2, etc] :

declaratie

49
 declaratie

etc

Ex:
#Acest program demonstreaza o bucla for
#care utilizeaza o lista de numere
def main():
print(‘Voi afisa numerele de la 1 la 5’)
for num in [1, 2, 3, 4, 5]:
print(num)
#Cheama functia principala
main()

Fig.3..5. Bucla for

Folosirea funcției range cu bucla for

Funcția range creează un tip de obiect numit iterabil. Un iterabil este similar unei liste (vom

vorbi ceva mai târziu despre liste):

for num in range(5):
print (num)

Fig.3.6. Bucla for…in range

Ex:
#Acest program demonstreaza cum functia range
#poate fi folosita cu bucla for

50
def main():
#Afiseaza un mesaj de 5 ori
for x in range(5):
print(‘Ce faci Caine?!’)
#Cheama functia principala
main()

Fig.3.7. Exemplu de mai sus în interpretor

Funcția for …in range produce o secvență de numere care crește cu valoarea 1 fiecare

număr succesiv din listă până când este atinsă valoarea 5 inclusiv. Să vedem ce se întâmplă

cu următoarea declarație:
for numar in range(1, 10, 2):
print(numar)
Primul argument este 1 iar ultimul argument este 10. Dar ce reprezintă numărul 2 ? Acesta

este folosit ca valoarea de pas (step valor sau pas). Astfel, fiecare număr succesiv din

secvență în loc să crească cu 1, va crește cu valoarea pasului, în cazul nostru 2. Deci 2 va fi

adăugat fiecărui număr succesiv din secvență:

Fig.3.8. Demonstrarea valorii de pas

Să vedem ce se întamplă dacă o luăm de la sfârșit spre început iar valoarea pasului devine

negativă:

51
 Fig.3.9. Inversarea secvenței

3.10. Acumulatori
Un total de funcționare (running total) este o sumă de numere care acumulează fiecare

iterare (trecere, execuție) a unei bucle. Variabila folosită ca să înmagazineze totalul se

cheamă acumulator.

Multe programe cer să calculezi totalul unei serii de numere. De exemplu, se presupune că

scrii un program care calculează totalul vânzărilor pentru o săptămână. Programul citește

vânzările din fiecare zi și calculează totalul acelor numere.

Acest tip de programe folosește de obicei două elemente:

1. o buclă care citește fiecare număr al seriei

2. o variabilă care acumulează totalul numerelor citite

Să luăm un program care demonstrează un acumulator:

#Acest program calculeaza suma unei serii
#de numere introduse de user
#Ia constanta pentru numarul maxim
MAX = 5 (Reține! Constanta se pune la început)
Def main():
#Initializeaza variabila acumulator
total = 0.0 (acumulatorul se ințializează întotdeauna cu 0.0)
#Explica ceea ce faci
print(‘Acest program calculeaza suma’)
print(MAX, ‘numerelor introduse.’)
#Ia numerele si acumuleaza-le
for counter in range(MAX):
number = int(input(‘Introdu un numar: ’))

52
 total = total+number
#Afiseaza totalul numerelor
print(‘Totalul este’, total)
#Cheama functia principala
main()

3.11. Operatori de atribuire augmentată

Aceștia ajută la prescurtarea și deci simplificarea codului.

Exemple:

x= x + 1 se mai poate scrie x+=1

sau:

y= y - 2 se mai poate scrie y-=2

sau:

z= z * 5 se mai poate scrie z*=5

sau

total = total + number devine total += number

3.12. Bucle de validare a intrărilor

Validarea intrărilor (input‑ului) este procesul de verificare a datelor care sunt introduse

într‑un program ca să fii sigur că sunt corecte înainte de a fi folosite în calcule. Dacă un

user introduce date greșite, programul va scoate răspunsuri eronate (sau erori logice care

sunt cel mai greu de depanat…). Calculatorul – oricât de deștept l‑am crede (și nu este…) –

procesează datele pe care omul i le furnizează. El nu știe să facă diferența între datele bune

și cele proaste.

De exemplu, următorul program va afișa un rezultat eronat pentru că datele introduse sunt

ilogice (salariat.py):
#Acest program afiseaza salariul unui angajat
def main():
#Ia numarul orelor lucrate intr-o saptamana
ore = int(input(‘Introdu numarul orelor lucrate intr-o saptamana:
’))
#Ia salariul orar

53
 sal_orar=float(input(‘Introdu salariul orar: ’))
#Calculeaza salariul
salariu = ore * sal_orar
#Afiseaza salariul
print(‘Salariul este: lei ’, format(salariu, ‘,.2f’))
#Cheama functia main
main()

Fig. 3.10. Date aberante și răspunsuri pe măsură!

Ce s‑ar intâmpla dacă la orele lucrate pe săptămână, un angajat ar introduce în loc de 40 de

ore (adică opt ore pe zi înmulțite cu 5 zile pe săptămână) 400 de ore? Rezultatul ar fi

aberant, în primul rând pentru că o săptămână – fie ea de lucru sau nu – nu poate să aibă

400 de ore!

Cum corectăm o asemenea năzbâtie? Simplu! Adăugăm o buclă while:

#Acest program afiseaza salariul unui angajat
def main():
#Ia numarul orelor lucrate intr-o saptamana
ore = int(input(‘Introdu nr orelor lucrate intr-o saptamana: ’))
#Asigura-te ca userul nu introduce o valoare absurda
while ore > 40:
print(‘Eroare! Nu poti lucra mai mult de 40 de ore!’)
ore=int(input(‘Introdu orele corecte: ’))
#Ia salariul orar
sal_orar=float(input(‘Introdu salariul orar: ’))
#Calculeaza salariul
salariu = ore * sal_orar
#Afiseaza salariul
print(‘Salariul este: ’, format(salariu, ‘,.2f’))
#Cheama functia main
main()

54
3.13. Bucle imbricate
O buclă aflată înăuntrul altei bucle se cheamă imbricată.

Ceasul este cel mai bun exemplu de bucle imbricate. Secundele, minutele și orele se rotesc

pe un ecran de ceas. O oră se rotește complet în 12 “ore” ale ecranului. Unui minut îi

trebuiesc 60 de rotiri. Pentru a demonstra “funcționarea” ceasului folosim o buclă for:

for secunde in range(60):
print (secunde)
sau
for minute in range(60):
for secunde in range(60):
print(minute, ‘:’, secunde)

Buclele complete ale ceasului arată așa:

for ore in range(24):

for minute in range(60):
for secunde in range(60):
print(ore, ‘:’, minute, ‘:’, secunde)

Bucla cea mai din interior iterează de 60 de ori pentru fiecare iterație a buclei din mijloc.

Bucla din mijloc itereaza de 60 de ori la fiecare iterație a buclei din exterior. Când bucla din

exterior iterează de 24 de ori, bucla din mijloc iterează de 1440 de ori iar cea din interior de

86.400 de ori.

55
Capitolul IV Module

O funcție care returnează valori este o funcție care trimite înapoi o valoare părții din

program care a chemat‑o. Python oferă o bibliotecă (pre) scrisă de funcții care face asta.

Această bibliotecă conține o funcție care generează numere aleatoare (întâmplătoare).

4.1.Biblioteci de funcții standard și declarația import

Am folosit deja câteva funcții standard pre‑scrise în biblioteci: print, input, range,
type.
Câteva dintre funcțiile Python sunt construite în interpretorul lui. Dacă vrei să le folosești,

pur și simplu le invoci. Așa este cazul cu input, print, range. Multe alte funcții sunt însă

stocate în biblioteci numite module. Aceste module ‑ care sunt copiate în computer în

momentul instalării Python, ajută la organizarea bibliotecilor standard.

Când invoci o funcție stocată într‑un modul, trebuie să scrii o declarație de import în

partea cea mai de sus a programului. Spre exemplu, să luăm modulul numit math. El

conține funcții matematice care lucreză cu numere reale (în virgulă mobilă). Dacă vrei să

folosești modulul math trebuie să scrii în vârful programului o declarație ca aceasta:

import math
Această declarație face ca interpretorul să încarce conținutul modulului math în memorie și

să‑l facă disponibil.

4.2. Generarea numerelor aleatoare

Python oferă câteva biblioteci de funcții care lucrează cu numere aleatoare (întâmplătoare).

Acestea sunt stocate într‑un modul numit random. Ca să generăm numere aleatoare vom

importa modulul random prin declarația:

import random
Prima funcție aleatoare generată se numeste randint. De fapt există forme mai explicite

de a importa modulele și funcțiile din el:

from random import randint

56
from random import *
Pentru că funcția randint se găsește în modulul random, avem nevoie să folosim notația cu

punct ca să ne referim la ea.

Iată mai jos cum se scrie o astfel de declarație:

modul

random.randint funcție

În partea stângă a punctului este numele modulului (random) iar după el numele funcției

(randint).

Deci, reține că:

1. Punctul leagă modulul de funcție.

2. random este modulul.

3. randint este funcția.

Ex:
number = random.randint(1, 100)
Argumentul (1, 100) spune funcției randint să afișeze un numar întreg aleator situat între 1

și 100.

Exemplu de program:
#Acest program afiseaza un numar aleator
#situat in marja 1 pana la 100
import random
def main():
#Ia un numar aleator
numar = random.randint(1, 100)
#Afiseaza numarul
print(‘Numarul este’, numar)
#Cheama functia principala
main()

Fig.4 .1. Numere aleatoare

57
Acuma să luăm un alt exemplu în care iterăm cu o buclă for de 5 ori:
#Acest program afiseaza 5 numere aleatoare
#situate intre 1 si 100
import random
def main():
for count in range(5):
#Ia un numar aleator
numar = random.randint(1, 100)
#Afiseaza numarul
print(numar)
#Cheama main
main()

Sa simplificăm programul anterior astfel:

import random
def main():
for count in range(5):
print(random.randint(1, 100))
main()

Fig.4.2. Ilustrarea exemplului de mai sus

4.3. Funcțiile randrange, random și uniform

Funcția randrange ia același argument ca funcția range. Diferența este că randrange nu

returnează o listă de valori. În loc de asta, ea returnează o valoare aleatoare dintr‑o

secvență de valori.

De exemplu, următoarea declarație atribuie un număr aleator situat între 0 și 9 variabilei

numar:
numar = random.randrange(10)
Argumentul – în cazul nostru 10 – specifică limita unei secvențe de valori. Funcția va

returna un număr aleator selectat din secvența de la 0 în sus dar nu include limita

58
sfârșitului, adică numărul 10.

Următoarea declarație specifică și valoarea de început dar și de sfârșit a secvenței:

numar = random.randrange(5, 10)
Când această declarație e executată, un număr întâmplător cuprins între 5 și 9 va fi atribuit

variabilei număr.

Următorul exemplu specifică o valoare de start, una de sfârșit și o altă valoare:

numar = random.randrange (0, 101, 10)
Funcția uniform returnează un număr aleator în virgulă mobilă, dar îți permite să specifici

media valorilor pe care le‑ai selectat:

numar = random.uniform (1.0, 10.0)
Declarația de mai sus face ca funcția uniform să returneze o valoarea aleatoare în virgulă

mobilă situată în gama 1.0 până la 10.0 și s‑o atribuie variabilei numar.

4.4. Scrierea propriei funcții care returnează o valoare

O funcție care returnează o valoare conține o declarație return care înapoiază o valoare

părții de program care a invocat‑o.

Scrierea unei funcții care returnează o valoare se face la fel ca scrierea unei funcții simple

cu o excepție: o funcție care returnează o valoare trebuie să aibă o declarație return.

Forma generală a funcției este:

def function_name():
declaratie
declaratie
etc
return expression
Ex:
def sum(num1, num2):
result = num1 + num2
return result
Și acuma un exemplu practic (total_bani.py):
#Acest program foloseste valoarea returnata a unei functii
def main():
#Ia valoarea banilor unui cetatean

59
 bani_primul=float(input(‘Introdu valoarea banilor: ’))
#Ia valoarea banilor celui de-al doilea cetatean
bani_al_doilea=float(input(‘Introdu valoarea banilor: ’))
#Afla valoarea totala
total=sum(bani_primul, bani_al_doilea)
#Afiseaza totalul
print(‘Impreuna cei doi au: ’ total)
#Functia sum accepta doua argumente numerice si
#returneaza suma celor doua argumente
def sum(num1, num2):
rezultat=num1 + num2
return rezultat
#Cheama main
main()

4.5. Modularea cu funcții

(exemplu de aplicație)

Andrei are o afacere numită “Fă‑ți propria muzică” prin intermediul căreia vinde

instrumente muzicale. Andrei își plătește angajații cu comision. Comisionul este în funcție

de vânzări astfel:

- mai puțin de 10000 lei ‑ 10%

- 10000 – 14999 – 12%

- 15.000 – 17.999 – 14%

- 18.000 – 21.999 – 16%

- 22.000 și mai mult – 18%

Pentru că agenții de vânzări sunt plătiți lunar, Andrei permite fiecăruia dintre ei să ia în

avans câte 2000 de lei. Când comisionul este calculat, suma pe care fiecare angajat a luat‑o

în avans este scăzută din comision. Dacă comisionul este mai mic decât suma luată în

avans, ei trebuie să‑i ramburseze lui Andrei diferența. Ca să calculeze plata lunară a

fiecărui angajat, Andrei folosește următoarea formulă:

plata = vanzari * comision – avans

Andrei te roagă să‑i scrii o aplicație care să facă toate calculele pentru el.

60
Algoritmul aplicației este următorul:

1. Ia vânzările lunare ale fiecărui agent de vânzări

2. Ia suma de bani luată în avans de fiecare dintre ei

3. Folosește valoarea vânzărilor lunare ca să afli comisionul

4. Calculează plata fiecărui angajat folosind formula de mai sus. Dacă valoarea e

negativă, angajatul trebuie să restituie banii.

Programul (comision.py):
#Acest program calculeaza salariul
#unei persoane de vanzari
def main():
#Ia suma vanzarilor
vanzari = ia_vanzarile()
#Ia valoarea luata in avans
avans = ia_avansul()
#Determina comisionul
comision = determina_comision(vanzari)
#Calculeaza plata
plata = vanzari*comision – avans
#Afiseaza valoarea platii
print (‘Plata este lei’, format(plata, ‘.2f’))
#Afla daca plata e negativa
if plata < 0:
print(‘Plata trebuie rambursata’)
else:
print(‘Plata nu trebuie rambursata’)
#Cheama functia principala
main()

4.6. Modulul matematic

Modulul math conține numeroase funcții care pot fi folosite în calcule matematice

Ex:
rezultat = math.sqrt(16)
Funcția sqrt acceptă argumentul 16 și îi returnează rădăcina pătrată (care e 4).

Mai întâi trebuie să importam modulul math pentru a scrie un program care îl folosește.

61
Ex de program (radacina.py):
#Acest program demonstreaza functia sqrt
import math
def main():
#Ia un numar
numar = float(input(‘Introdu un numar: ’))
#Ia radacina patrata a numarului
radacina_patrata = math.sqrt(numar)
#Afiseaza radacina patrata a numarului
print(‘Radacina patrata este’, radacina_patrata)
#Cheama functia principala
main()

Următorul program folosește funcția hypot ca să calculeze ipotenuza unui triunghi

dreptunghic:
#Acest program calculeaza lungimea ipotenuzei
#unui triunghi dreptunghic
import math
def main():
#Ia lungimea a doua laturi ale triunghiului
a=float(input(‘Introdu lungimea laturii A: ’))
b=float(input(‘Introdu lungimea laturii B: ’))
#Calculeaza lungimea ipotenuzei
c = math.hypot(a, b)
#Afiseaza lungimea ipotenuzei
print(‘Lungimea ipotenuzei este: ’, c)
#Cheama functia main
main()

Valorarea math.pi

Suprafața cercului este constanta pi înmulțită cu raza cercului la pătrat, după cum bine

știm din clasa a VII‑a, de la studiul geometriei plane:

suprafata = math.pi*radius**2
Ce se întâmplă? Suprafața cercului este S=pi**r (unde r este raza cercului) la pătrat. Dar

cum pi este o constantă universală care aparține modulului matematic, trebuie să scriem

math.pi.

62
Un modul este doar un fișier care conține cod Python. Programele mari sunt (mai) ușor de

reparat și întreținut atunci când sunt împărțite în module dar mai ales pot fi refolosite33

intr‑un alt program. Un modul poartă întotdeauna extensia .py.

Modulul calendar

Sa luam de exmplu modulul implicit Python calendar. El se importa ca oricare alt modul,

asa cum am aratat mai devreme, cu declaratia import:

import calendar
Ca să afișăm de exemplu cum arăta anul Revoluției 1989 trebuie să ne referim la funcția

inclusă în modulul calendar, prcal (printează calendar) folosind notația cu punct:

calendar.prcal()
Programul următor afișeaza anul amintit:
import calendar
an = int(input(’Introdu anul dorit: ’))
prcal(an)
Să vedem cum funcționează în Python shell:

Fig.4.3. Modulul calendar

33 Reuse în lib.engleză

63
Capitolul V Fișiere și excepții

Când un program are nevoie să salveze date pentru a le folosi mai târziu, el le scrie

într‑un fișier. Datele pot fi extrase și citite din fișier în orice moment.

Programele pe care le scrii sunt refolosite pentru că datele lui sunt stocate în

memoria RAM (Random Acces Memory). Datele sunt salvate într‑un fișier care este stocat

pe disc. Odată ce datele sunt salvate în fișier, ele rămân și după ce fișierul este închis.

Datele pot fi retrimise și refolosite de utilizator oricând dorește.

Exemple:

- procesoare word

- editoare de imagine

- tabele de date

- jocuri de calculator

- browsere web (prin cookie)

Când o bucățică de date este scrisă într‑un fișier, ea e copiată dintr‑o variabilă din RAM în

fișierul de pe disc.

Procesul de retrimitere a datelor dintr‑un fișier este cunoscut ca citirea din fișiere.

Procesul acesta este invers scrierii în fișiere: când o porțiune de date este citită din fișierul

de pe HDD, este copiată în RAM și referită de o variabilă.

Procesul implică trei pași:

1. Deschiderea fișierului – creează o conexiune între fișier și program. Deschiderea

unui fișier din input permite programului să citească date din el.

2. Procesarea fișierului – datele sunt scrise în fișier (fișier output) sau citite (fișier

input)

3. Închiderea fișierului – când programul termină cu fișierul, el trebuie închis.

4.

5.1.Tipuri de fișiere
Sunt două tipuri de fișiere: text și binare.

64
Un fișier text conține date care au fost codificate în text folosind scheme ca ASCII sau

Unicode. Chiar dacă fișierele conțin numere, ele sunt stocate ca o serie de caractere. Drept

rezultat, fișierul poate fi deschis și văzut într‑un editor de text precum Notepad sau Word.

Un fișier binar conține date care sunt convertite în text. Ca urmare, nu le poți citi cu un

editor de text.

5.2. Metode de acces a fișierelor

Majoritatea limbajelor de programare oferă două căi de acces la datele stocate în fișiere:

a) acces secvențial

b) acces direct

Când lucrezi cu accesul secvențial, accesezi date de la început spre sfârșit. Deci dacă vrei să

citești date situate spre sfârșitul fișierului ești nevoit să parcurgi tot fișierul – nu poți sări la

ceea ce te interesează. Este ca la casetofon: nu poți pune direct cântecul dorit.

Când însă folosești accesul direct (random access file), poți sări direct la orice date din

fișier. Este ca la CD sau ca la pick‑up: poți pune direct orice cântec vrei.

Noi vom lucra cu accesul secvențial.

Numele fișierului și obiectele fișier (Filenames and File Objects)

Fișierele sunt identificate printr‑un nume. Asta se întâmplă când le salvăm. De exemplu:

cat.jpg ; nota.txt ; scrisoare.doc etc.

În măsura în care un program lucrează cu un fișier de pe computer, programul trebuie să

creeze un fișier obiect în memorie ca să‑l poată accesa. Un fișier obiect (file object) este un

obiect asociat cu un fișier specific și oferă o cale programului de a lucra cu acel fișier.

În program, o variabilă referă obiectul fișier. Acea variabilă se îngrijește de toate operațiile

făcute în fișier.

5.3. Deschiderea unui fișier în Python

Ca să deschidem un fișier folosim funcția open. Funcția open creează un fișier obiect pe

care îl asociază cu fișierul dorit de pe discul computerului:

Formatul general al funcției open este:

65
 file_variable = open(filename, mode)
unde:

- file_variable este numele variabilei care referă obiectul fișier

- filename este un șir care arată numele fișierului

- mode este un șir care specifică modul (scris, citit, etc) în care fișierul va fi deschis.

Exemple de moduri (mode) în Python:

‘r’ = deschide un fișier doar pentru citit (read); fișierul de acest tip nu poate fi scris

‘w’ = deschide un fișier pentru scris (write). El poate fi interpretat cam așa: dacă fișierul

există, șterge‑i conținutul; dacă nu există, creează‑l.

‘a’ = deschide un fișier pentru a fi scris. Toate datele fișierului vor fi anexate până la sfârșit.

Dacă nu există (fișierul) creează‑l.

De exemplu, să presupunem că fișierul client.txt conține datele unui client și vrem să‑l

deschidem pentru a‑l citi. Iată un exemplu de cum invocăm funcția open:
fisier_client = open(‘client.txt’, ‘r’)
După ce declarația este executată, fișierul client.txt este deschis și variabila fisier_client va

referi un fișier obiect pe care‑l putem folosi ca să citim date din fișier.

Acuma, vrem să creăm un fișier numit vanzari.txt și să scriem în el. Iată cum facem:
fisier_vanzari = open(‘vanzari.txt’, ‘w’)

5.4. Scrierea datelor într‑un fișier

Este timpul să introducem un alt tip de funcții care se cheamă metode.

O metodă este o funcție care aparține unui obiect și care face unele operații folosind acel

obiect. Odată ce ai deschis un fișier, folosești metoda fișierului obiect ca să poți face

operații pe fișier.

De exemplu, obiectul fișier are o metodă numită ‘write’ care poate fi folosit ca să scrii date

într‑un fișier.

Iată formatul general și cum să invoci metoda write:

file_variable.write(string)
În această declarație, file_variable este o variabilă care referă un fișier obiect și string este un

șir care va fi scris în fișier. Fișierul trebuie să fie deschis pentru scris (‘w’ sau ‘a’) altfel va

66
apărea o eroare.

Să spunem că customer_file referă un fișier obiect și fișierul va fi deschis pentru scris cu

modul ‘w’. Iată cum vom scrie de exemplu șirul ‘Traian Basescu’ într‑un fișier:
customer_file.write(‘Traian Basescu’)
Următorul fragment de cod arată un alt exemplu:
nume = ‘Traian Basescu’
customer_file.write(‘nume’)
Odată ce am terminat cu un fișier, el trebuie închis cu cuvântul close. Ex.:
customer_file.close()
Exemplu complet de program (presedinti.py)
#Acest program scrie trei linii de date
#intr-un fisier
def main():
#Deschide un fisier numit presedinti.txt
outfile = open(‘presedinti.txt’, ‘w’) 5
#Scrie numele presedintilor Romaniei 6
#in fisier
outfile.write(‘Ion Iliescu\n’) 8
outfile.write(‘Emil Constantinescu\n’) 9
outfile.write(‘Traian Basescu\n’) 10
#Inchide fisierul
outfile.close() 12
#Cheama functia principala
main()

Rezultatul programului este redat mai jos:

Fig.5.1 presedinti.txt

(Nota: Numerele din partea dreaptă reprezintă rândurile programului). Cum lucrează însa acest

program? Linia 5 deschide fișierul tenori.txt folosind modul ‘w’. Acesta face ca fișierul să

fie creat și bun pentru scris în el. De asemenea, aceeași declarație creează un obiect în

67
memorie pe care il atribuie variabilei outfile. Declarațiile din liniile 8, 9 și 10 scriu pur și

simplu șirurile din fisier. Linia 12 închide fișierul. După ce programul este rulat, numele

celor trei personaje este scris în fișierul tenori.txt. Să mai observăm că fiecare șir se termină

cu \n adică numele următorului tenor este așezat pe o linie nouă.

5.5. Citirea datelor dintr‑un fișier

Dacă un fișier este deschis pentru citire (folosind modul ‘r’), putem folosi metoda obiect

read ca să‑i citim întregul conținut. Când este invocată metoda read, ea returnează

conținutul fișierului ca pe un șir. Să vedem în exemplul următor cum folosim metoda read

ca să citim conținutul textului tenori.txt pe care l‑am creat anterior:

(citire_fisier.py)

#Acest program citeste si afiseaza continutul

#fisierului presedinti.txt

def main():

#deschidem fisierul numit presedinti.txt

infile = open(‘presedinti.txt’, ‘r’) 5

#Ii citim continutul

file_contents = infile.read() 7

#Inchidem continutul

infile.close()

#Afisam datele citite

print(file_content)

#Invocam functia principala

main()

Declarația din linia 5 deschide fișierul pentru citit folosind modul ‘r’. De asemenea creează

un fișier obiect pe care îl atribuie variabilei infile. Linia 7 invocă metoda infile.read ca

68
să îi citească conținutul. Conținutul este citit în memorie ca un șir și atribuit variabilei

file_contents. Putem de asemenea folosi metoda readline ca să citim doar o linie dintr‑un

fișier. Metoda returnează o linie ca pe un șir.

Concatenarea unei linii noi la un șir

În cele mai multe cazuri, datele care sunt scrise într‑un fișier nu sunt șiruri literare dar sunt

referite în memorie de variabile. Este cazul în care un program invită userul să introducă

date și apoi să le scrie într‑un fișier. Când un program scrie date introduse de user, este de

obicei necesar să le legăm (concatenăm) cu un caracter \n. Acest lucru ne va asigura că

fiecare dată este scrisă într‑o linie nouă în fișier. Programul următor ne arată cum se face

acest lucru (barbati.py).

#Acest program ia trei nume de la user

#Si le scrie intr-un fisier
def main():
print('Introdu numele a trei barbati.')
nume1 = input('Barbatul #1 ')
nume2 = input('Barbatul #2 ')
nume3 = input('Barbatul #3 ')
#deschide un fisier numit barbati.txt
fisier = open('barbati.txt', 'w')
#Scrie numele in fisier
fisier.write(nume1 + '\n')
fisier.write(nume2 + '\n')
fisier.write(nume3 + '\n')
#inchide fisierul
fisier.close()
print('Numele au fost scrise in barbati.txt')
main()
Sa verificam exitenta fisierului si functionalitatea lui:

Fig.5.2. Deschidere fisier

Ca sa rulam programul barbati.py trebuie neaparat sa fim in acest director. Tot aici va fi

creat si salvat fisierul barbati.txt.

69
5.6. Adăugarea datelor într‑un fișier existent
Când folosim metoda ‘w’ ca să deschidem un fișier dar fișierul cu nume specificat există

deja pe disc, fișierul existent va fi șters și unul gol dar cu același nume va fi creat.

Uneori dorim să păstrăm fișierul vechi și să‑i adăugăm date noi. Acestea se adaugă la

sfârșitul celor existente. În Python folosim modul ‘a’ ca să deschidem un fișier căruia vrem

să‑i adăugăm date. Asta înseamnă că:

- dacă fișierul există deja, el nu va fi șters. Dacă nu există, va fi creat.

- când datele sunt scrise în fișier, ele vor fi adăugate la sfârșitul datelor existente.

De exemplu, să spunem că fișierul barbati.txt conține deja următoarele nume scrise fiecare

pe o linie separată:
Costel
Mirel
Florel
Codul de mai jos deschide fișierul și adaugă următoarele date la conținutul existent:
myfile=open(‘barbati.txt’, ‘a’)
myfile.write(‘Gigel\n’)
myfile.write(‘Fanel\n’)
myfile.write(‘Stanel\n’)
myfile.close()

După aceasta vom avea numele anterior scrise (Costel, Mirel, Florel) la care se adaugă cele

de mai sus. Fișierul va arăta în final așa:

Costel
Mirel
Florel
Gigel
Fanel
Stanel

5.7. Scrierea și citirea datelor numerice

Șirurile pot fi scrise direct cu metoda write, în schimb numerele trebuiesc convertite în

șiruri înainte de a fi scrise.

70
Python are o funcție preconstruită numită str care convertește o valoare într‑un șir. Să

spunem de pildă că variabilei num îi este atribuită valoarea 99. Expresia str(num) va

returna șirul ‘99’.

Ex: scrie_numere2.py
#Programul demonstreaza cum numerele
#trebuiesc convertite in siruri inainte de a fi
#scrise in fisiere text
def main():
#Deschide un fisier pentru scris
outfile=open(‘numere.txt’, ‘w’)
#Ia trei numere de la user
num1=int(input(‘Introdu un numar: ’))
num2=int(input(‘Introdu alt numar: ’))
num3=int(input(‘Mai baga unul: ’))
#Scrie cele trei numere in fisier
outfile.write(str(num1) + ‘\n’)
outfile.write(str(num2) + ‘\n’)
outfile.write(str(num3) + ‘\n’)
#Inchide fisierul
outfile.close()
print(‘Date scrise in numere.txt’)
#Cheama functia principala
main()

La ieșire, programul va afișa cele trei numere introduse de utilizator și mesajul “Date scrise

in numere.txt”.

Expresia str(num1) + ‘\n’ convertește valoarea referită de variabila num1 într‑un șir

și o concatenează cu ‘\n’ șirului. Când userul introduce să zicem valoare 50, expresia va

produce șirul ‘50\n’. Drept rezultat, șirul ‘50\n’ este scris în fișier.

5.8. Copierea unui fisier

Sa presupunem ca dorim sa facem o copie a fisierului barbati.txt care se va chema

copybarbati.txt. Pentru aceasta scriem urmatorul program (copybarbati.py):

71
 Fig. 5.3. Copierea fisierului barbati.txt

Sa vedem si functionarea lui in Terminal:

Fig. 5.4. Functionare in Terminal

5.9. Fișiere binare

Următorul exemplu creează un fișier binar. Pentru aceasta folosim modul ’wb’ (binar.py):
str = 'Salutare si voiosie!'
fisier = open('fisier_binar.bin', 'wb')
fisier.write(str.encode('utf-8'))
fisier.close()
fisier = open('fisier_binar.bin', 'rb')
fisiercontinut = fisier.read()
fisier.close()
print('Continutul fisierului este:')
print(fisiercontinut.decode('utf-8'))

Programul binar.py creează un fișier numit fisier_binar.bin în modul write și

stochează în el șirul ”Salutare si voiosie!”. Șirul este codificat în sistemul UTF‑8 înainte de

fi scris în fișier. Fișierul este apoi închis. Ca sa confirmăm că șirul este stocat corect în fișier,

îl deschidem cu modul read.

Să vedem cum funcționează:

72
 Fig. 5.5. Crearea unui fișier binar

5.10. Excepții
O excepție este o eroare care apare atunci când un program rulează și care are drept

consecință oprirea lui brutală. Pentru mânuirea excepțiilor se folosește blocul de declarații

try/except .

Programul de mai jos (imparte.py) oferă un exemplu.

#Programul imparte un numar la altul
def main():
#Ia doua numere
num1=int(input(‘ia un numar: ’))
num2=int(input(‘ia al doilea numar: ’))
#Imparte-le unul la celalalt si afiseaza rezultatul
result=num1 / num2
print(num1, ‘impartit la’, num2, ‘este’, result)
#Cheama main
main()

Fig.5.6. Eroare impartire la zero

El împarte două numere. Atunci când userul vrea să împartă un număr la zero, apare o

excepție sau o eroare numită traceback. Ea dă informații cu privire la numărul liniei (liniilor)

care cauzează excepția. Când se întâmplă să avem de a face cu o excepție, spunem că

programul “a ridicat o excepție”. Ele pot fi prevenite scriind codul cu atenție.

Să rescriem codul de mai sus (impartire2.py) astfel încât excepția să nu mai apară:
#Programul imparte un numar al altul
def main():
#Ia doua numere

73
 num1=int(input(‘ia un numar: ’))
num2=int(input(‘ia al doilea numar: ’))
#Daca num2 nu este 0, imparte num1 la num2
#si afiseaza rezultatul
if num2 != 0:
result = num1 / num2
print(num1, ‘impartit la’, num2, ‘este’, result)
else:
print(‘Impartirea la zero este imposibila.’)
#Cheama main
main()

Fig.5.7. Împarțirea la zero cu eroarea corectată

După cum poate v‑ați dat seama, excepțiile trebuiesc pur și simplu ghicite atunci când

programatorul scrie programul. El trebuie să‑și puna mereu întrebarea Ce s‑ar întâmpla

dacă? (În cazul de mai sus, Ce s‑ar întampla dacă userul introduce valoarea celui de‑al doilea

număr ca fiind zero?).

Tabelul de mai jos arata exceptiile care pot aparea atunci cand un program este evaluat de

interpretor:
Exceptie Descriere

AssertionError Apare atunci cand declaratia esueaza

AttributeError Atributul nu este gasit in obiect

EOFError Cand se incearca citirea dincolo de sfarsitul unui

fisier

FloatingPointError Apare cand operatia cu un numar in virgula mobila

esueaza

IOError Cand o operatie I/O esueaza

74
IndexError Cand se foloseste un index aflat in afara gamei

(range)

KeyError Cand o cheie nu este gasita

OSError Cand invocarea unui sistem de operare esueaza

OverflowError Cand o valoarea este prea mare ca sa poata fi

reprezentata

TypeError Cand un argument de un tip nepotrivit este furnizat

ValueError Cand valoarea unui argument nu este potrivita

ZeroDivisionError Cand un numar se imparte la zero ori cand al doilea

argument intr‑o operatie modulo este zero

Tabel 5.1.

75
Capitolul VI Liste, tupluri, dicționare și seturi. Serializarea
obiectelor (pickling)

6.1. Liste
O listă este un obiect care conține itemi multipli. Este similară matricei din alte

limbaje de programare. Listele sunt mutabile ceea ce înseamnă că conținutul lor poate fi

schimbat pe timpul execuției programului. Listele sunt structuri dinamice de date adică

itemii lor pot fi adăugați sau șterși. Pentru aceasta se poate folosi indexarea, felierea (slicing)

dar și alte metode de lucru cu liste.

Fiecare item dintr‑o listă se cheamă element al listei.

Iată cum arată o declarație de creare a unei liste de întregi (ex):

numere_impare=[1, 3, 5, 7, 9]
Elementele listei sunt incluse între paranteze drepte și sunt despărțite între ele prin

virgulă.

Să luam un exemplu de listă cu șiruri:

nume= [‘Mircea’, ‘Dana’, ‘Marcel’, ‘Stanel’]
O listă poate să conțină tipuri diferite de valori:
lista = [‘Stanel’, 51, 4.157]
Lista “lista” conține un șir (Stanel), un întreg (51) și o valoare în virgulă mobilă (4.157).

Pentru afișarea conținutului listei folosim funcția print( ) ca mai jos:

print (lista)
ceea ce va da la ieșire:

Fig.6.1. Listă de itemi cu valori diferite

Python are de asemenea o funcție preconstruită care convertește anumite tipuri de obiecte

76
în liste. Așa cum am vazut într‑un capitol anterior, funcția range returnează un iterabil ce

este un obiect care ține o serie de valori ce iterează peste ea.

Mai jos este un exemplu de folosire a funcției range:

numere = [5, 10, 15, 20]
numere = list(range(5))
Când executăm declarația se întâmplă următoarele:

- funcția range este invocată cu 5 drept argument; funcția returnează un iterabil care

conține valorile 0, 1, 2, 3, 4.

- iterabilul este trecut ca argument funcției list( ); funcția list( ) returnează lista

[0, 1, 2, 3, 4].

- lista [0, 1, 2, 3, 4] este atribuită variabilei numere.

Operatorul de repetiție

Operatorul de repetiție face copii multiple unei liste și le pune laolaltă. Forma generală

este:
lista * n
Un exemplu în care este multiplicată o listă de întregi dar și una cu valoare șir:

Fig. 6.2. Multiplicarea listelor

Iterarea peste o listă cu bucla for

numere = [45, 67, 90, 3.45]
for n in numere:
print(n)
Ceea ce la ieșire va da:

45

67

90

77
3.45

Indexarea

O metodă de accesare a elementelor individuale dintr‑o listă este cu ajutorul unui index.

Fiecare element al listei are un index specific care‑l poziționează în listă. Numărarea

elementelor dintr‑o listă începe de la zero (0) , așa că primul element are indexul 0, al

doilea are indexul 1, al treilea are indexul 2 s.a.m.d.

Să spunem că avem lista următoare:

lista = [12, 56, 6.345, ‘Stanel’]

0 1 2 3
Ca să accesăm elementul listei care are valoarea Stanel, utilizăm declarația:

print(lista[3]) .

Sau elementul cu indexul 1 al listei (care este 56).

Fig. 6.3. Acces index listă

Dacă folosim indecși negativi, vom identifica poziția elementelor relative la sfârșitul listei.

Așa se face că indexul ‑1 identifică ultimul element al listei, ‑2 pe penultimul și tot așa.

Indexul 0 este același cu indexul ‑4. Ce se întâmplă însă dacă vrem să aflăm elementul care

numărat de la coada listei, are indexul ‑5 ?

Va apărea o eroare “Traceback” pentru că lista nu contine cinci indecsi:

Fig.6.4. Afișarea elementelor cu ajutorul indecsilor negativi

78
Funcția len

Cu ajutorul funcției len putem afla lungimea unei liste.

Să luăm următorul cod:

lista = [1, 2, 3, 4, 5]
lungime = len(lista)

Fig.6.5. Funcția len( )

Funcția len poate fi folosită ca să prevină o excepție IndexError atunci când iterăm peste o

listă cu o buclă:
lista = [1, 2, 3, 4, 5]
index = 0
while index < len(lista):
print(lista[index])
index +=1

Listele sunt mutabile

Așa cum scriam la începutul capitolului, listele în Python sunt mutabile ceea ce înseamnă

că elementele ei pot fi schimbate.

Să vedem un exemplu:
lista = [1, 2, 3,4, 5] 1
print(lista) 2
lista[0] = 50 3
print(lista) 4
Cum funcționează:

Pe rândul 1 creăm lista “lista” iar apoi o afișăm pe rândul 2. Pe rândul 3, elementului 0 din

listă – care este 1 – îi reatribuim valoarea 50. Cu linia 4 afișăm noua componență modificată

79
a listei:

Fig.6.6. Listele pot fi modificate

Ce se întâmplă dacă nu folosim un index valid, ci unul care depășește numărul elementelor

listei? Va apărea o excepție:

Fig.6.7. Excepție de ieșire din marjă

Lista de mai sus are cinci elemente dar care au indecșii de la 0 la 4. Cum nu există index‑ul

7, încercarea de modificare va eșua apărând o eroare Traceback.

Să luam un exemplu cu bucla while:

Fig. 6.8. Program listă vânzări

Și acuma ieșirea programului de mai sus:

80
 Fig.6.9. Ieșirea programului anterior

Concatenarea (legarea) listelor

Pentru concatenarea listelor în Python se folosește semnul + .

Cel mai bun mod de a înțelege cum funcționează este un exemplu:

lista1 = [8,9,10,11]
lista2 = [12,13,14,15]
lista3 = lista1 + lista 2
care va afișa la ieșire:

Fig.6.10. Concatenarea listelor

La fel de bine putem folosi și concatenarea listelor cu valoare șir:

fete = [‘Dana’, ‘Roxana’, ‘Ileana’, ‘Maria’]
baieti = [‘Costel’, ‘Gigel’, ‘Ion’, ‘Popica’]
nume = fete + baieti
care va avea output‑ul:

Fig.6.11. Concatenare șiruri

81
dar și tipuri diferite de valori (întregi, float, șir):

Fig. 6.12. Tipuri diferite combinate într‑o listă

Să reținem că putem combina doar liste cu liste. Dacă încercăm să combinăm o listă cu o

altă entitate va apărea o excepție.

Felierea (slicing) listelor

Uneori ai nevoie să selectezi unele elemente dintr‑o secvență dar nu pe toate. Atunci

folosești felierea (slice). Ca să iei o porțiune dintr‑o listă trebuie să scrii o declaratie de

forma:
lista[start : end]
unde start este indexul primului element din porțiune și end este indexul ultimului element

din porțiune.

Să presupunem că avem următoarea listă:

zile_saptamana = [‘Luni’, ‘Marti’, ‘Miercuri’, ‘Joi’, ‘Vineri’,
‘Sambata’, ‘Duminica’]
Următoarea expresie folosește o porționare care preia elementele din lista de mai sus care

au indexul 2 până la 5 (dar neincluzându‑l pe cel din urmă):

zile_mijloc = zile_saptamana[2:5]
Când este executată declarația va rezulta:
[‘Marti’, ‘Miercuri’, ‘Joi’]
sau un exemplu numeric:

Fig.6.13 Slicing

82
Dacă lăsăm gol locul unuia dintre indecși, Python va folosi automat 0 ca index de început.

Fig. 6.14. Lipsa unui index

sau invers:

Fig. 6.15. Lipsa celuilalt index

Ce se întâmplă dacă lași goale spațiile indecșilor? Python va face o copie a întregii liste:

Fig. 6.16. Lipsa ambilor indecși

Expresiile partajate pot avea și un pas (step value) ca în exemplul de mai jos:

Fig.6.17. Feliere cu pas

Pasul partajarii este 2 ceea ce face ca porțiunea afișată să cuprindă fiecare al doilea număr

din listă.

Găsirea itemilor dintr‑o listă cu operatorul in

Forma generală este:

item in lista
Să luăm un exemplu (in_lista.py)

83
#demonstrarea operatorului in
def main():
#creeaza o lista a numerelor produselor
prod_num = ['V476', 'F890', 'Q143', 'R688']
#Ia numarul unui produs pe care-l cauti
cauta = input('Introdu numarul produsului: ')
#afla daca numarul se gaseste in lista
if cauta in prod_num:
print(cauta, 'a fost gasit in lista.')
else:
print(cauta, 'nu a fost gasit in lista.')
#cheama functia principala
main()

6.2. Metode și funcții preconstruite pentru liste

Metoda append
Metoda append este folosită pentru adăugarea unui nou item listei. Itemul este trecut

drept argument și este adăugat la sfârșitul listei.

Ex. program (append.py)

#acest program demonstreaza metoda append
#de adaugare a unui nou item intr-o lista
def main():
#cream o lista goala
nume_lista = [ ]
#cream o variabila de control a buclei
again = 'y'
#adaugam cateva nume listei
while again == 'y':
#luam un nume de la utilizator
nume = input('Introdu un nume: ')
#adauga numele introdus in lista
nume_list.append(nume)
#mai adauga inca un nume
print('Mai adaugi un nume? ')
again = input('y = yes, anything else = no ')

84
 print()
#afiseaza numele introduse
print('Iata numele pe care le-ai introdus.')
for nume in nume_lista:
print(nume)
#cheama functia principala
main()

Metoda index

Uneori dorim să știm unde se află un item dintr‑o listă. Pentru aceasta folosim metoda

index. Trecem un argument metodei index și ea returnează index‑ul primului element din

listă care conține acel item. Dacă itemul nu este găsit, programul va ridica o excepție

ValueError.

Ex. mancare.py
#programul demonstreaza cum luam un index al unui item
#dintr-o lista si apoi il inlocuim cu un alt item
def main():
#cream o lista
mancare = ['Pizza', 'Hamburg', 'Cipsuri']
#afisam lista
print(mancare)
#luam itemul pe care il vrem inlocuit
item = input('Ce item vrei sa schimbi? ')
try:
#ia indexul itemului din lista
item_index = mancare.index(item)
#ia valoarea de inlocuire
noul_item = input('Introdu noua valoare: ')
#inlocuieste vechiul item cu noul item
mancare[item_index] = noul_item
#afiseaza lista
print('Aici este noua lista.')
print(mancare)
except ValueVallor:
print('Itemul nu a fost gasit in lista.')

85
#cheama main
main()

Sa vedem cum functioneaza in Terminal:

Fig. 6.18. Functionarea in Terminal

Metoda insert

Această metodă permite să adaugi un item într‑o listă pe o poziție specifică. Ca să faci asta

trebuie să treci două argumente metodei insert: un index care specifică locul unde itemul

ar trebui să fie inserat și itemul pe care dorești să‑l inserezi.

Ex.(insert_list.py)
def main():
#creeaza o lista cu cativa itemi
nume = ['Mircea', 'Dana', 'Auras']
#afiseaza lista
print('Lista inainte de inserare: ')
print(nume)
#insereaza un nume nou ca element 0 al listei
nume.insert(0, 'Gigel')
#afiseaza din nou lista
print('Noua lista arata asa: ')
print(nume)
#cheama functia main
main()

Metoda sort

Metoda sort rearanjează elementele unei liste așa încât ele să apară în ordine ascendentă.

Ex:
lista = [1,2 ,8,9,4,6,0]
print('Ordinea originala este:', lista)
lista.sort()
print('Lista sortata:', lista )

86
Metoda remove

Fig. 6.19. Metoda remove

Metoda reverse

După cum îi spune numele, metoda reverse inversează ordinea itemilor din listă.

Ex:
lista = [1,2,3,4,5]
lista.reverse()
print(lista)

Fig. 6.20. Metoda reverse

Declaratia del

Cu această declarație ștergem un element din listă:

Fig. 6.21. Declarația del

Funcțiile min și max

Ex:

87
 Fig. 6.22. Funcția min

La fel se întâmplă și cu max, înlocuind min cu max.

Totalul valorilor dintr‑o listă

Pentru acest calcul trebuie să folosim o buclă for dar si un acumulator inițiat cu valoarea

zero. Iată un exemplu:

#Acest program calculează totalul valorilor dintr-o listă
def main():
#Cream lista
numere = [2,3,6,8,10]
#cream o variabila pe care o folosim drept acumulator
total = 0
#Calculam totalul elementelor listei
for value in numere:
total += value
#Afisam totalul elementelor listei
print(‘Totalul elementelor este’, total)
#Invocam functia main
main()

Iar output‑ul este: “Totalul elementelor este 30”.

Media valorilor dintr‑o listă

După ce calculăm totalul (ca mai sus) unei liste, ca să aflăm media valorilor din listă trebuie

să împărțim totalul la lungimea listei. Ex. (media.py)

#Acest program calculează media valorilor dintr-o listă
def main():
#creem lista
scoruri = [2.5, 8.3, 6.5, 4.0, 5.2]
#creem o variabila ca s-o folosim ca acumlator
total = 0.0

88
 #Calculam totalul valorilor din lista
for value in scoruri:
total +=value
#Calculam media elementelor
media = total / len(scoruri)
#Afisam totalul elementelor listei
print(‘Media elementelor este’, media)
#Invocam functia main
main()

Ieșirea programului este: “Media elementelor este 5.3”.

6.3. Tupluri
Un tuplu este o secvență imutabilă, ceea ce înseamnă că conținutul ei nu se poate schimba.

Un tuplu seamană foarte mult cu o listă cu diferența că o dată creat, elementele lui nu se

pot schimba. Elementele unui tuplu se închid între o pereche de paranteze, ca mai jos:

Fig. 6.23. Elementele unui tuplu

Prima declarație creează un tuplu numit “tuplu” care conține elementele 1,2,3,4,5. A

doua declarație afișează elementele tuplului.

Să vedem acuma cum o bucla for iterează peste elementele unui tuplu:

Fig. 6.24. Bucla for în tupluri

De fapt, tuplurile suportă aceleași operații ca listele cu excepția celor care schimbă

conținutul. Tuplurile suportă următoarele operații:

89
- Subscrierea indecsilor

- Metode ca index

- Functii preconstruite: len, min și max

- Operații de feliere (slicing)

- Operatorul in

- Operatorii + si *

Tuplurile nu suportă metode ca append, remove, insert, reverse sau sort.

Când vrei să creezi un tuplu cu un singur element, acel element trebuie urmat neapărat de

virgulă:

Fig. 6.25. Tuplu cu un singur element

Motivul pentru care tuplurile există este acela că tuplurile sunt mai rapide ca listele.

Aceasta înseamnă că tuplurile sunt o bună alegere atunci când se procesează date foarte

multe care nu urmează a fi modificate. Un alt motiv este acela că tuplurile sunt sigure.

Pentru că nu li se pot modifica elementele, nimeni nu poate să le manipuleze accidental.

Există două functii care pot converti tuplurile în liste și invers. Acestea sunt: list( ) și

tuple( ) :

Fig. 6.26. Conversia tuplu‑lista

6.4. Dicționare
Un dicționar e un obiect care stochează o colecție de date. Fiecare element dintr‑un

dicționar are două părți: o cheie și o valoare. Folosim cheia ca să localizăm valoarea.

90
 Într‑un dicționar clasic – ca de exemplu DEX, cheia este cuvântul pe care‑l căutăm în

dicționar ca să aflăm ce semnificație are. Spre exemplu, să luăm cuvântul “enoriaș” .

Conform DEX el înseamnă (are valoarea) “persoană credincioasă care ține de o parohie”.

Deci cheia este enoriaș iar valoarea este persoană credincioasă care ține de o parohie.

sau:
enoriaș = persoană credincioasă care ține de o parohie
Un alt exemplu este cartea de telefon în care cheia este numele persoanei pe al cărui număr

de telefon dorim să‑l aflam iar numărul de telefon este valoarea.

Perechea cheie‑valoare mai este referită și de expresia cartografiere.

Să creăm un dicționar:
carte_telefon = {’Mircea’: ’07225666’, ’Gigel’ : ’076666111’, ’Minel’:
’0744234567’}

Observăm că la crearea dicționarului carte_telefon folosim o pereche de acolade în

interiorul cărora introducem cheia – care este numele persoanei – și numărul de telefon care

este valoarea. Elementele dicționarului sunt fiecare cuprinse între ghilimele iar perechile

sunt despărțite de virgule. Mai observăm că fiecare pereche își referă elementele prin

semnul două puncte (:).

Primul element al dicționarului este ‘Mircea’ : ‘072256666’;

Al doilea element este: ‘Gigel’ : ‘0766666111’;

Al treilea element este: ‘Minel’ : ‘0744234567’.

În acest exemplu cheile și valorile sunt șiruri. Totuși, elementele unui dicționar pot fi de

orice tip numai că – spre deosebire de liste, cheile sunt imutabile. Cheile pot fi șiruri, întregi,

în virgulă mobila sau tupluri. Cheile nu pot fi însa liste (am învățat deja că listele au

elemente mutabile).

Extragerea unei valori din dicționar

Trebuie să reținem amănuntul că elementele dintr‑un dicționar nu sunt stocate într‑

o ordine anume. Aceasta înseamnă că dicționarele nu sunt secvențe ordonate de date

precum listele, tuplurile sau șirurile. Prin urmare nu putem folosi indexuri numerice ca să

extragem valori. În loc de asta putem folosi cheile valorilor, nu însă înainte de a pune

91
înaintea lor numele dicționarului (în cazul de față “carte_telefon”):

Fig. 6.27. Extragerea unei valori dintr‑un dictionar

În momentul în care solicităm o cheie care nu există în cartea de telefon, va apărea o eroare

Traceback (KeyError):

Fig. 6.28. KeyError

Folosirea operatorilor “in” și “not in” pentru testarea unei valori dintr‑un dicționar

Ca să prevenim eroarea de mai sus putem folosi operatorul in dintr‑o declaratie if ca să

vedem dacă o cheie există în dicționar:

Fig. 6.29. Prevenirea apariției KeyError

Declarația if determină dacă cheia “Costel” este în dicționarul carte_telefon. Dacă este,

îi va afișa valoarea (numărul de telefon).

Putem de asemenea să folosim operatorul not in ca să determinăm dacă o cheie există

într‑un dicționar:

Fig. 6.30. Folosirea operatorului not in

Să reținem că șirurile care se compară cu ajutorul lui in și not in sunt case sensitive.

92
Adăugarea unor elemente dicționarului

Dicționarele sunt obiecte mutabile. Putem să le adăugam noi perechi de elemente cu o

declarație de următoarea formă:

nume_dictionar[cheie] = valoare

Fig. 6.31. Adăugarea de elemente dicționarului

După cum se observă, în cartea noastră de telefon l‑am adaugat pe “Dorel”.

Trebuie să mai reținem că într‑un dicționar nu putem avea valori duplicat. Când atribuim

o valoarea unei chei existente, aceasta îi va lua locul celei vechi.

Ștergerea elementelor dintr‑un dicționar

Forma generala este:

del nume_dictionar[cheie]
Ex:

Fig. 6.32. Ștergerea elementelor dintr‑un dicționar

Dacă privim atent exemplul de mai sus observăm că atunci când cheia pe care dorim s‑o

excludem nu există în dicționar apare o eroare numită “KeyError”. In cazul de mai sus e

vorba de cheia Cornelia care nu există în dicționar.

Aflarea numărului elementelor dintr‑un dicționar

Pentru aceasta folosim funcția len:

93
 Fig. 6.33. Folosirea funcției len()

Amestecarea tipurilor de date într‑un dicționar

Cheile unui dicționar sunt imutabile însa ele pot fi de orice tip: liste, întregi, numere în

virgula mobilă, tupluri.

Exemplele următoare ilustrează toate acestea:

Fig. 6.34. Date de tipuri diferite intr‑un dicționar

sau:

Fig. 6.35. Ibidem

Dicționar gol

Un dicționar gol se creează printr‑o simplă declarație de forma generală:

>>>dictionar = { }
sau în cazul nostru
>>>carte_telefon = { }
După aceea putem să‑i adăugăm elemente:
>>>carte_telefon[‘Ion’] = ‘0245345789’
>>>carte_telefon[‘Costel’] = ‘0743123098’
>>>carte_telefon[‘Florina’] = ‘0250445566’
Pentru crearea unui dicționar gol se mai poate folosi și funcția preconstruită dict( ).

Ex:

94
carte_telefon = dict( )

Folosirea buclei for pentru iterarea peste elementele unui dicționar

Fig.6.36. Folosirea buclei for pentru afișarea elementelor dicționarului

6.5. Metode ale dicționarelor

Obiectele unui dicționar au câteva metode cu care se pot manipula datele:

clear – curăță conținutul unui dictionar

get – ia valoarea asociată unei chei specifice. Dacă cheia nu este găsită, metoda nu ridică o

excepție. În loc de asta, returnează valoarea implicită.

items ‑ returnează toate cheile dintr‑un dicționar și valorile lor asociate ca pe o secvență

de tupluri

keys – returnează toate cheile ca pe o secvență de tupluri

pop – returnează valorile asociate cu o cheie specifică și le șterge (perechile cheie/valoare)

din dicționar. Dacă cheia nu e găsită returnează valoarea implicită.

popitem – returnează o pereche întâmplătoare de cheie/valorare ca pe un tuplu și o șterge

din dicționar

values – returnează toate valorile din dicționar ca pe o secvență de tupluri.

Să le luăm pe rând.

Metoda clear

Metoda clear șterge toate elementele unui dicționar, lăsându‑l gol.

Formatul general al acestei metode este:

dictionary.clear( )
Ex:

95
 Fig. 6.37. Metoda clear

Metoda get

Forma generală este:

dictionar.get(cheie, default)
în care dictionar e numele dicționarului, cheie este cheia pe care o căutăm în dicționar iar

default este valoarea implicită pe care o returnează declarația în cazul în care cheia nu e

găsită (în cazul de mai jos ‘Valoarea n‑a fost gasita’).

Ex.:

Fig. 6.38. Metoda get

Metoda items

Această metodă returnează toate cheile dicționarului și valorile asociate lor. Ea returnează

valorile într‑un tip special de secvență numit “vedere”. Fiecare element din dicționar este

un tuplu și fiecare tuplu conține o cheie cu valoarea ei asociată.

Ex:

Fig. 6.39. Metoda items

Metoda keys

Această metodă retunează toate cheile dicționarului.

Ex:

96
 Fig. 6.40. Metoda keys

Metoda pop

Metoda pop returnează valorile asociate cu o cheie specifică și șterge acele valori. În cazul

în care nu găsește perechea solicitată cheie/valoare, afișează valoarea default.

Ex.:

Fig. 6.41. Metoda pop

Metoda popitem

Metoda popitem returnează o pereche întâmplătoare de chei/valori și șterge acea pereche

din dicționar.

Ex.:

Fig. 6.42. Metoda popitem

Metoda values

Această metodă returnează toate valorile dicționarului (fără cheiele lor) ca pe un dicționar.

Ex.:

Fig. 6.43. Metoda values

97
6.6. Seturi
Un set este un obiect care stochează o colecție de date. Un set are câteva caracteristici:

- Toate elementele setului sunt unice, adică doua elemente nu pot avea aceeași valoare

- Seturile sunt structuri neordonate, ceea ce înseamnă că elementele lui pot sta în orice

ordine

- Elementele setului pot fi de diferite tipuri.

Pentru a crea un set, invocăm functia preconstruita set:

setul_meu = set()
Aici aveam de‑a face cu un set gol de elemente. Ca să‑i adăugăm elemente, i le trecem

drept argumente ale functiei set():

setul_meu = set([‘a’, ’b’, ’c’])
sau
setul_meu = set(‘abc’)

Fig. 6.44. Crearea unui set in Python shell

Dacă scriem însă

setul_meu = set(‘a’, ‘b’, ‘c’)
vom primi o eroare:

Fig. 6.45. Eroare

Aflarea numărului elementelor unui set se face prin intermediul funcției len:
setul_meu = set([1,2,3,4,5])
len(setul_meu)

Fig.6.46. Aflarea numărului elementelor unui set

98
Pentru adăugarea de elemente setului se utilizează metoda add (legată cu punct, desigur):

Fig. 6.47. Metoda add

Se poate folosi și metoda update:

Fig. 6.48. Metoda update

Tipurile de date introduse pot fi diferite ca mai jos:

Fig. 6.49. Date diferite

Pentru ștergerea elementelor unui set se pot folosi metodele remove sau discard. Itemul

pe care‑l vrem șters din set îl trecem drept argument al uneia dintre aceste metode. Spre

exemplu, mai jos renunțăm la elementul 2 al setului:

Fig. 6.50. Metoda remove (am renuntat la numarul 2)

Sau discard:

Fig. 6.51. Metoda discard (am renunțat la litera a)

Ca sa iterăm peste elementele unui set putem să folosim bucla for:

99
 Fig. 6.52. Bucla for utilizată în seturi

Uniunea a doua seturi contine elementele celor doua seturi si se realizeaza cu metoda

union:

Fig. 6.53. Uniunea a două seturi

6.7. Serializarea obiectelor (pickling)

Serializarea unui obiect este procesul de convertire a obiectului într‑un număr de

biți care pot fi salvați într‑un fișier ce poate fi accesat oricând după aceea. În Python,

serializarea obiectelor se numește pickling34.

Librăria standard a limbajului Python pune la dispoziție un modul numit pickle care

este întrebuințat la serializarea obiectelor.

După ce este importat modului pickle, facem următorii pași

- Deschidem un fișier pentru scrierea binară

- Invocăm metoda dump a modulul pickle cu care scriem în fișierul dat

- Închidem fisierul

Acuma, asa cum am vazut in capitolul anterior, ca să scriem în modul binar un fișier

trebuie să folosim modul “wb” (write binary) atunci când invocam funcția open:
outputfile = open(‘datele_mele.dat’, ‘wb’)
Odată ce am deschis fișierul pentru scrierea binară, invocăm funcția dump a modulului

pickle:

34 to pickle = a mura, a băițui, a decapa, a afuma

100
pickle.dump(obiect, fișier)
unde obiect este o variabilă care referă obiectul pe care vrem să‑l serializăm și fișier

este o variabilă care face referință la obiectul fișier. După ce funcția este executată, obiectul

referit de obiectul fișier este serializat și scris în fișier. Trebuie spus că se poate folosi

modulul pickle pentru orice fel de obiecte: liste, tupluri, dicționare, seturi, șiruri, întregi și

numere în virgulă mobilă.

Într‑un fișier putem salva oricâte obiecte serializate dorim. Când am terminat invocăm

metoda close pentru închiderea fișierului.

Să luăm exemplul următor dintr‑o sesiune interactivă:

Fig. 6.54. Modulul Pickle si serializarea unui obiect

Ce se întâmplă mai sus?

Prima dată importăm modulul pickle. Apoi, creăm dicționarul carte_telefon cu

numele drept chei și numerele de telefon ca valori. Mai departe, deschidem fișierul

carte_telefon.dat pentru scriere binară. Următoarea linie de program invocă funcția

dump a modulului pickle care serializează dicționarul carte_telefon și îl scrie în fișierul

carte_telefon.dat. Ultima linie închide fișierul carte_telefon.dat.

Poate că la un moment dat avem nevoie să “desfacem” (unpickle) acel obiect. Pentru aceasta

trebuie să facem următorii pași:

- Deschidem fișierul pentru citire binară

- Invocăm funcția load din modulul pickle ca să recuperăm un obiect din fișier

- După aceasta închidem fisierul

Ca să citim fișierul utilizăm modul ‘rb’:

Fig. 6.55. Citirea binară a fișierului

101
Ce se întâmplă? În prima linie importăm modulul pickle. În linia a doua deschidem

fișierul carte_telefon.dat pentru citire binară. Apoi invocăm funcția load din

modulul pickle ca să desfacem (unpickle) un obiect din fișierul carte_telefon.dat.

Rezultatul îl atribuim variabilei ct (de la carte de telefon, voi puteți să‑i spuneți cum vreți).

Apoi afișăm cu comanda ct conținutul cărții de telefon. Ultima linie de cod închide fișierul

carte_telefon.dat.

102
Capitolul VII Clase și obiecte. Programarea orientată pe obiect

După cum îi spune și numele, programarea orientată pe obiect este centrată pe

obiect. Obiectele sunt create din date abstracte încapsulate și care funcționează împreună.

Într‑un program procedural, itemii de date sunt trecuți de la o procedură la alta. Separarea

datelor și codului care operează datele poate rezolva problemele, dar astfel un program

devine din ce în ce mai mare și mai complex.

Să presupunem că faci parte dintr‑o echipă de programatori care scrie un program întins

de baze de date. Programul este inițial proiectat astfel încât numele, adresa și numărul de

telefon sunt referite de trei variabile. Sarcina ta este să proiectezi câteva funcții care acceptă

cele trei variabile ca argument și să realizezi operații cu ele. Software‑ul funcționează cu

succes o perioadă, dar echipa ta este rugată la un moment dat să updateze soft‑ul

adăugându‑i câteva noi componente. În timpul procesului de revizuire, programatorul șef

îți spune că numele, adresa și numărul de telefon nu mai sunt stocate în variabilele știute.

În loc de asta, ele urmează să fie stocate în liste. Asta înseamnă că trebuie să modifici toate

funcțiile pe care le‑ai scris, astfel încât să funcționeze cu liste în locul celor trei variabile.

Făcând această modificare majoră, nu numai că vei avea enorm de muncă, ci deschizi

oportunitatea ideală pentru apariția erorilor.

În timp ce programarea procedurală este centrată pe crearea de proceduri (funcții),

programarea orientată pe obiect (OOP) este centrată pe crearea de obiecte.

7.1. Definiții
Un obiect este o entitate software care conține date și proceduri. Datele conținute

într‑un obiect sunt cunoscute drept atributele datelor obiectului. Atributele datelor obiect

sunt variabile simple care referă date.

Procedurile prin care un obiect performează sunt cunoscute ca metode. Metoda unui obiect

este funcția care realizează operații prin intermediul datelor obiectului.

Conceptual, obiectul este o unitate autoconținută care constă în atributele datelor și

metodele ce le operează. OOP realizează separarea codului și datelor cu ajutorul

103
incapsulării și ascunderii datelor.

Încapsularea se referă la combinarea datelor și codului într‑un singur obiect. Ascunderea

datelor se referă la abilitatea unui obiect de a ascunde atributele datelor de codul aflat în

afara obiectului. Doar metodele obiectului pot accesa direct și pot face schimbări asupra

atributelor datelor obiectului.

De obicei, un obiect ascunde datele dar permite codului exterior să‑i acceseze metodele.

Cum vom vedea mai târziu, metodele obiectului oferă declarații din afara obiectului cu

acces indirect asupra atributelor datelor.

Date
‐‐//‐ ‐‐//‐‐ ‐‐//‐‐ ‐‐//‐‐ ‐‐//‐‐

OBIECT

METODE Cod din afara

obiectului

Fig. 7.1. Modelarea obiectelor

Când atributele datelor obiectului sunt ascunse codului extern și accesul atributelor datelor

este restricționat de metodele obiectului, atributele sunt protejate de întreruperi sau

defecțiuni accidentale. În plus, codul din afara obiectului nu trebuie să știe nimic despre

structura și formatul intern al datelor obiectului. Codul are nevoie să interacționeze doar

cu metodele obiectului. Acesta este motivul pentru care datele din obiect rămân

neschimbate.

Un exemplu din viața de zi cu zi de obiect este ceasul cu alarmă pe care însă să incercam sa

ni‑l imaginăm ca pe un obiect software. El are următoarele atribute:

104
- secunda_curenta (o valoare cuprinsă între 0 și 59)

- minut_curent ( o valoare cuprinsa intre 0 si 59)

- ora_curenta (o valoare cuprinsă între 0 și 12)

- timp_alarma (o oră și un minut valide)

- setare_alarma (True sau False)

După cum se poate vedea, atributele datelor sunt valori care definesc starea atunci când

alarma ceasului e fixată. Tu, utilizatorul obiectului ceas cu alarmă nu poți manipula direct

aceste date pentru că ele sunt private. Ca să schimbi valoarea datelor atribut trebuie să

folosești una din metodele obiectului.

Iată mai jos câteva din metodele obiectului ceas cu alarmă:

- setare_timp

- setare_timp_alarma

- setare_alarma_on

- setare_alarma_off

Fiecare metodă manipuleză unul sau mai multe atribute ale datelor. De exemplu,

“setare_timp” îți permite să fixezi timpul alarmei ceasului. Activezi metoda prin apăsarea

butonului din capul ceasului. Folosind alt buton (cheia) poți activa metoda

“setare_timp_alarma”. În plus, un alt buton îți permite să execuți metodele

“setare_alarma_on” și “setare_alarma_off”.

Trebuie să ții minte că aceste metode sunt activate de tine din afara ceasului cu alarmă.

Metodele care pot fi accesate de entități din afara obiectului sunt cunoscute ca metode

publice.

Ceasul cu alarmă are de asemenea metode private care sunt părți private ale obiectului și

care funcționează intern. Entitățile exterioare (ca tine, de exemplu), nu au acces direct la

metodele interne ale ceasului cu alarmă. Obiectul este proiectat să execute aceste metode

automat și să ascundă detaliile de tine.

Metodele private ale obiectului ceas cu alarmă sunt:

- incrementare_secunda_curenta

- incrementare_minut_curent

105
- incrementare_ora_curenta

- sunet_alarma

Metoda “incrementare_secunda_curenta” este executată în fiecare secundă. Aceasta

schimbă valoarea atributului datei “secunda_curenta”. Daca atributul datei

secunda_curenta este setat la 59 când metoda este executată, metoda este programată să

reseteze valoarea “secunda_curenta” la 0 și face ca valoarea lui

“incrementare_minut_curent” să crească, adică această metodă este executată.

Metoda “incrementare_minunt_curent” adaugă 1 la atributul “minunt_curent”, mai putin

când e setat la 59. În acest caz el resetează “minut_curent” la 0 și duce la execuția metodei

“incrementare_ora_curenta”. Metoda “incrementare_minut_curent” compară noul timp cu

“setare_alarma”. Dacă cele doua coincid și alarma este pornită, metoda “sunet_alarma”

este executată.

7.2. Clase
O clasă este un cod care specifică atributele datelor și metodele pentru un tip

particular de obiect.

Înainte ca un obiect să fie creat, el trebuie să fie proiectat de un programator.

Programatorul determină atributele și metodele necesare și apoi crează o clasă. Să ne

gândim la o clasa ca la un șablon după care obiectele sunt creeate. Șablonul servește același

scop ca acela folosit la proiectarea unei case. Șablonul în sine nu este o casă dar el descrie în

detaliu o casă. Când folosim un șablon ca să construim o casă putem spune că construim o

instanță a casei descrise de șablon. Dacă vrem, putem să construim oricâte case (identice)

dorim după șablon. Fiecare casă este o instanță separată a casei descrise de șablon.

Programatorii au mai imaginat și o altă asemănare pentru a descrie mai bine diferențele

dintre clase și obiect. Spre exemplu o formă de prajitură și prăjitura în sine. Sau, daca mă

gândesc la gogoșile pe care le făcea bunica mea cu paharul, atunci gura paharului descria o

gogoașă dar nu era o gogoașă la rândul ei. Forma de prajitură este deci folosită să faci

prăjituri. Să ne gândim la o clasă ca la un șablon, o formă de prăjituri sau gura unui pahar

iar la obiectele create cu ele ca la prăjituri, gogoși sau case.

106
Un alt exemplu foarte nimerit de clasă este formularul de la ghișeul primăriei prin care

soliciți ceva. Formularul este proiectat o singură dată iar apoi este multiplicat în mii de

exemplare. Solicitantul (cetățeanul) vine la primărie cu o problemă și i se înmânează sau își

ia singur un formular pe care îl completează. Fiecare cetățean are datele lui personale pe

care le introduce. O dată formularul completat avem deja de a face cu o instanță a clasei

formular.

Deci o clasă descrie caracteristicile unui obiect. Când un program rulează el poate folosi o

clasă ca să creeze în memorie oricâte obiecte dorește. Fiecare obiect care este creat de o clasă se

cheamă instanța clasei.

De exemplu, Andrei se ocupă cu scrierea de programe de calculator. El proiectează un

program care să catalogheze diversele tipuri de automobile. Ca parte a programului,

Andrei creează o clasă numită Vehicul care are caracteristicile comune oricăror vehicule

(tip, producător, preț etc).

Clasa Vehicul specifică obiectele ce pot fi create din ea. Apoi, Andrei scrie declarațiile de

program care creează un obiect numit automobil care este o instanță a clasei Vehicul.

Obiectul automobil este o enitate care ocupă un loc în memoria computerului și stochează

date despre automobil. El are atributele și metodele specific clasei Vehicul. Apoi Andrei

scrie o declarație care creează un obiect numit bicicleta. Obiectul bicicleta este de asemenea

o instanță a clasei Vehicul. El are propriul loc în memorie și stochează date despre bicicleta.

Altfel, obiectele automobil și bicicleta sunt două entități separate în memoria

computerului, ambele create din clasa Vehicul. Asta înseamnă că fiecare dintre cele doua

obiecte are atributele și metodele descrise de clasa Vehicul.

Clasa
Vehicul

Obiectul Obiectul
automobil bicicleta

107
7.3. Crearea claselor în Python
Nu trebuie să scriem prea mult cod ca să ne dăm seama că Python este un limbaj foarte

curat. Când vrem să facem ceva, facem pur și simplu, fără a urma prea mulți pași.

Omniprezentul “hello world” în Python, este după cum știm, afișat cu o singură linie de

cod.

În mod similar, cea mai simplă clasă în Python 3 arată cam așa:
class PrimaMeaClasa:
pass
Acesta este primul nostru program obiect orientat! Definiția clasei începe cu cuvântul

cheie class. El este urmat de un nume (la alegerea noastră) care identifică clasa (numele

clasei) și apoi de semnul două puncte. Numele clasei trebuie să urmeze regulile standard

de denumire a variabilelor. De asemenea este recomandat ca numele să fie scris în stilul

cocoasă de cămilă (CamelCase): să înceapă cu o literă mare iar apoi fiecare cuvânt

subsecvent la fel (ex: PrimaMeaClasa).

Linia de definiție a clasei este urmată de conținutul indentat al clasei. Ca și alți constructori

din Python, indentarea este folosită ca să delimiteze clasele în locul acoladelor din alte

limbaje de programare bazate pe “C”.

Pentru că prima noastră clasă nu face practic nimic, folosim cuvântul cheie pass ca să

arătăm că nu urmează nicio acțiune (ca la poker). Ne putem gândi că nu sunt prea multe

de făcut cu o clasă de bază, dar ea permite să instanțiezi obiecte după acea clasă. Putem să

încărcăm clasa în interpretorul Python 3 ca să ne jucăm cu ea interactiv. Ca să facem asta,

salvam definiția clasei de mai devreme într‑un fișier numit first_class.py și apoi rulăm

comanda:
python –i first_class.py.35
Argumentul –i îi spune lui Python să ruleze codul și apoi “să‑l arunce” interpretorului

interactiv. Următoarea sesiune în interpretor demonstrează interacțiunea de bază cu o

clasă:
>>> a = PrimaMeaClasa()

35 Cu această ocazie învățăm și cum să trecem din modul script în modul interactiv din linia de comandă

108
>>> b = PrimaMeaClasa()
>>> print(a)
< __main__.MyFirstClass object at 0xb7b7faec>
>>> print(b)
< __main__.MyFirstClass object at 0xb7b7fbac>
>>>
Explicații

Codul de mai sus instanțiază două obiecte ale clasei MyFirstClass, obiecte numite a și b.

Crearea instanței unei clase înseamnă de fapt scrierea numelui clasei urmată de o pereche

de paranteze. Ea arată aproape la fel ca invocarea unei funcții normale, numai că Python

știe că invocă o clasă și nu o funcție, deci înțelege că sarcina lui e să creeze un obiect nou.

Când sunt afișate, cele două obiecte ne spun despre ce clasă e vorba și care e adresa de

memorie unde ele sălășluiesc. Adresele de memorie nu sunt prea mult folosite în Python,

dar în exemplul anterior ele demonstrează că sunt implicate două obiecte distincte.

7.4. Adăugarea atributelor

În programarea OOP există două denumiri frecvent întâlnite: metode și atribute.

Atributele sunt de fapt variabilele din programarea procedurală iar metodele sunt funcțiile.

În exemplul nostru avem deci o clasă de bază dar total inutilă. Ea nu conține nicio dată și

mai ales, nu face nimic. Ce se întâmplă daca oferim un atribut unui obiect dat?

Putem să setăm un atribut arbitrar unui obiect instanțiat folosind notația cu punct (dot

notation):
class Punct:
pass
p1 = Punct()
p2 = Punct()

p1.x = 5
p1.y = 4

p2.x = 3
p2.y = 6

print(p1.x, p1.y)
print(p2.x, p2.y)

109
Dacă rulăm acest cod, cele două declarații de afișare de la sfârșit, ne dau noile valori ale

atributelor celor doua obiecte:

5 4
3 6
Ce face totuși acest cod? El creează o clasă goală numită Punct care nu are date și nici

comportamente. Apoi, el creează două instanțe ale clasei și atribuie fiecăreia coordonatele x

și y care identifică un punct bidimensional. Tot ceea ce avem de făcut este să atribuim o

valoare atributului obiectului folosind sintaxa generală:

<obiect>.<atribut> = <valoare>
Aceasta este uneori denumită notația cu punct (dot notation). Valoarea poate fi orice: o

primitivă Python, a data preconstruită etc. Poate fi chiar o funcție sau un alt obiect.

7.5. Să punem clasa la treabă

Programarea Orientata pe Obiect (OOP) este despre interacțiunea obiectelor între ele.

Suntem interesați așadar să invocăm acțiuni care fac ca lucrul acesta să se întâmple. Este

timpul deci să adăugăm comportamente claselor noastre.

Să concepem modelul unor acțiuni ale clasei Punct. Putem începe cu o metodă numită

reset care mută punctul la origine (originea este punctul unde valoarea lui x și y este

egală cu zero, v‑amintiți probabil de la algebră de ordonata si abscisa). Aceasta este o bună

introducere pentru că ea necesită orice parametru:

(punct.py)
class Punct:
def reset(self):
self.x = 0
self.y = 0
p = Punct()
p.reset()
print(p.x, p.y)

Declarația print afișează cele două zerouri ale atributelor (0 0) ca în sesiunea interactivă

de mai jos:

110
 Fig.7.2. Ieșire program punct.py

O metodă în Python este identică cu definirea unei funcții. Ea începe cu cuvântul cheie def

urmat de un spațiu și de numele metodei. Aceasta e urmată de o pereche de paranteze care

conțin parametrul self (vorbim imediat despre el) și se termină cu două puncte.

Următoarea linie este indentată și conține declarațiile din interiorul metodei. Aceste

declarații pot fi cod Python arbitrar care operează asupra obiectelor însăși precum și orice

parametru trecut metodei.

7.6. Argumentul self

Singura diferență dintre metode și funcțiile normale este aceea că fiecare metodă necesită

un argument. Acest argument este convențional numit self.

Argumentul self dintr‑o metodă este o simpla referință la un obiect a cărui metoda a fost

invocată. Prin el putem accesa atribute și metode ale acelui obiect. Aceasta este exact ceea

ce facem înăuntrul metodei reset atunci când setăm atributele x și y obiectului self.

Să notăm că atunci când invocăm metoda p.reset(), nu trebuie să trecem argumentul

self în ea. Python are automat grijă să facă acest lucru. El știe când invocăm o metodă a

obiectului p, deci el trece automat acel obiect metodei.

Oricum, o metodă chiar este cu adevărat doar o funcție care se întâmplă să fie într‑o clasă.

În loc să invocăm metoda pe un obiect, putem invoca funcția clasei, trecând explicit

obiectul ca argumentul self:

p = Punct()
Punct.reset(p)
print(p.x, p.y)
Ieșirea este aceeași ca la exemplul anterior, pentru că se desfașoară același proces.

111
Sa adăugăm o nouă metodă care permite să muți un punct într‑o poziție arbitrară , nu doar

la origine. Putem să includem un alt obiect Punct ca input și apoi să returnăm distanța

dintre ele:
import math
class Punct:
def move(self, x, y):
self.x = x
self.y = y
def reset(self):
self.move(0, 0)
def calculeaza_distanta(self, alt_punct):
return math.sqrt(
(self.x – alt_punct.x)**2 +
(self.y – alt_punct.y)**2)
#cum folosim programul:
punct1 = Punct()
punct2 = Punct()

punct1.reset()
punct2.move(5, 0)
print(punct2.calculeaza_distanta(punct1))
assert (punct2.calculeaza_distanta(punct1) = =
punct1.calculeaza_distanta(punct2))
punct1.move(3, 4)
print(punct1.calculeaza_distanta(punct2))
print(punct1.calculeaza_distanta(punct1))

7.7. Definirea unei clase – o altă abordare

Ca să creezi o clasă trebuie să scrii definiția ei. Definiția clasei este un set de declarații care

stipuleaza metodele și atributele datelor obiectului.

Să luam un exemplu simplu. Să presupunem că scriem un program care simulează

întoarcerea unei monede. Avem nevoie să repetăm întoarcerea monedei ca să determinăm

de fiecare dată dacă e “cap” sau “pajură”.

Folosind OOP vom scrie o clasă numita Moneda care descrie comportamentul aruncării

unei monede.

112
Iată mai jos programul moneda.py:
import random 1
#Clasa Moneda simuleaza o moneda
#care poate fi intoarsa
class Moneda: 4
#Metoda __init__ initializeaza atributele
# partii de sus a monedei (in_sus) cu ‘Cap’ 6
def __init__(self):
self.in_sus = ‘Cap’ 8
#Metoda intoarce genereaza un numar aleator
# in gama 0 si 1. Daca numarul este 0 atunci
# in_sus (partea de sus) este setata pe ‘Cap’
# altfel, in_sus este setata pe ‘Pajura’ 12
def intoarce(self): 13
if random.randint(0, 1) = = 0: 14
self.in_sus = ‘Cap’ 15
else: 16
self.in_sus = ‘Pajura’ 17
#Metoda ia_in_sus returneaza o valoare
#referita de in_sus 19
def ia_in_sus(self): 20
return self.in_sus
def main():
#cream un obiect (o instanta) din clasa Moneda
moneda_mea = Moneda()
#afisam partea monedei care este in sus
print(‘Aceasta parte este in sus: ’, moneda_mea.ia_in_sus())
#intoarcem moneda
print(‘Intorc moneda’)
moneda_mea.intoarce()
#afisam fata monedei aflata in sus
print(‘Aceasta e in sus:’, moneda_mea.ia_in_sus())
main()

Ce se întâmplă? În linia 1 importăm modulul random, căci nu‑i așa, “dăm cu banul”, adică

urmează o valoarea întâmplătoare. El este necesar pentru că folosim funcția randint

inclusă în modulul random ca să generăm un număr aleator.

113
Linia 4 reprezintă începutul definiției clasei. Ea începe cu cuvântul cheie class urmat de

numele clasei (care este Moneda), urmat la rândul lui de două puncte (:). Aceleași reguli

care se aplică la numele unei variabile, sunt valabile și aici. Să notăm totuși că numele

clasei începe cu majusculă: Moneda. Nu este obligatoriu, dar este o convenție general

utilizată de programatori. Ea ajută să facem distincția între numele claselor și numele

variabilelor atunci când citim codul.

Clasa Moneda conține trei metode:

metoda __init__ care apare în liniile 6 și 7

metoda intoarce care ocupă liniile 12‑16

metoda ia_in_sus din liniile 19 și 20

Să privim mai atent începutul fiecărei metode și să observăm că fiecare dintre ele are un

parametru numit self:

Linia 6 def __init__ (self):

Linia 12 def __intoarce__ (self):

Linia 20 def ia_in_sus(self):

Parametrul self este obligatoriu în fiecare metodă a unei clase. Când o metodă este

executată ea trebuie să aibă o cale ca să știe asupra cărui atribut al datelor obiectului

trebuie să opereze. Aici este momentul în care parametrul self intră în rol. Când o

metodă este invocată, Python face ca parametrul self să refere un obiect specific asupra

căruia se presupune că metoda operează.

Să privim mai atent fiecare dintre metode. Prima metodă numită __init__ este definită în

liniile 6 și 7:
def __init__ (self):
self.in_sus = ‘Cap’
Majoritatea claselor în Python au o metodă specială numită __init__ care este executată

automat atunci când o instanță a clasei este creată în memorie. Metoda __init__ este mai

cunoscută sub numele de metoda de ințializare pentru că inițializează atributele datelor

obiectului. Numele metodei începe cu două liniuțe joase urmate de cuvântul init și apoi de

încă două liniuțe joase.

114
Imediat după ce un obiect este creat în memorie, metoda __init__ este executată și

parametrul self este automat atribuit obiectului ce tocmai a fost creat.

Avem apoi declarația din linia 14 care este executată:

self.in_sus = ‘Cap’
Această declarație atribuie șirul ‘Cap’ atributului in_sus care aparține obiectului ce

tocmai a fost creat. Drept rezultat al metodei __init__ fiecare obiect pe care‑l creăm din

clasa Moneda va avea un atribut in_sus care e setat pe ‘Cap’.

Nota: Metoda __init__ este de obicei prima metoda înăuntrul definiției clasei.

Metoda intoarce apare în liniile 12 – 16:

def intoarce(self):
if random.randint(0, 1) = = 0:
self.in_sus = ‘Cap’
else:
self.in_sus = ‘Pajura’
Și această metodă necesită variabila parametru self. Când metoda intoarce este invocată,

self referă automat obiectul asupra căruia metoda operează. Metoda intoarce

simulează întoarcerea unei monede. Când metoda este invocată, declarația if cheamă

funcția random.randint ca să dea un întreg situat între 0 și 1. Dacă numărul este 0 atunci

declarația următoare atribuie ‘Cap’ lui self.in_sus. Altfel, declarația atribuie

‘Pajura’ lui self.in_sus.

Metoda ia_in_sus apare în liniile 19 și 20:

def ia_in_sus(self):
return self.in_sus
Încă o dată, metoda necesită parametrul self. Această metodă returnează valoarea lui

self.in_sus. Chemăm această metodă ori de câte ori vrem să știm care față a monedei

este în sus.

În imaginea următoare avem ieșirea programului moneda.py rulat în Command Prompt:

115
 Fig. 7.3. Ieșire program moneda.py

Să vedem în continuare și cum funcționează o clasă. Astfel, vom scrie clasa Asigurari

care ține câteva informații despre firme de asigurări (asigurari.py):

#Clasa Asigurari tine informatii despre
#firme de asigurari
class Asigurari:

#Metoda __init__ initializeaza atributele

def __init__(self, firma, pret):
self.__firma = firma
self.__pret = pret

#Metoda set_firma accepta un argument

#pentru firma de asigurari
def set_firma(self, firma):
self.__firma = firma

#Metoda set_pret accepta un argument

#pentru pretul asigurarii
def set_pret(self, pret):
self.__pret = pret

#Metoda ia_firma returneaza numele firmei

#de asigurari
def ia_firma(self):
return self.__firma

#Metoda ia_pret returneaza

#pretul politei de asigurare
def ia_pret(self):
return self.__pret

Si acuma programul care o testeaza (polita.py):

import asigurari

def main():
firma = input('Introdu firma de asigurari')
pret = float(input('Introdu pretul asigurarii'))

#Creeaza o instanta a clasei Asigurari

asigurare = asigurari.Asigurari(firma, pret)

#Afiseaza datele introduse

116
 print('Iata datele pe care le-ai introdus: ')
print('Firma de asigurari: ', asigurare.ia_firma())
print('Pretul asigurarii este: ron',\
format(asigurare.ia_pret(), ',.2f'), sep='' )

main()

În final, să testăm funcționarea în linia de comandă a programului polita.py:

Fig. 7.4. Ieșirea programului polita.py

Foarte important! Clasa Asigurari (asigurari.py) se importă fără terminația (extensia)

.py. Clasa (asigurari.py) se salvează întotdeauna în același director/folder (în cazul meu pe

Desktop) în care salvăm și programul care o folosește (polita.py). Altfel, programul nu va

funcționa.

7.8. Moștenirea (Inheritance) în Python

Moștenirea reprezintă o tehnică de copiere a datelor și funcțiilor unei clase existente într‑o

altă clasă. În loc să pornim de la zero, o clasă existentă poate fi moștenită de o alta căreia îi

adăugăm date noi. Clasa moștenită se cheamă clasă de bază sau superclasă iar clasa

moștenitoare se cheamă clasă derivată sau subclasă. Trebuie menționat că clasa care

moștenește preia toate proprietățile clasei de bază.

Există trei tipuri de moștenire. Acestea sunt:

1. moștenirea simplă

2. moștenirea pe mai multe niveluri

3. moștenirea multiplă

Noi vom vorbi în continuare despre moștenirea simplă.

Toate clasele din limbajul Python sunt derivate dintr‑o clasă specială (părinte) numită

Object. Chiar dacă nu este explicitatat scrisă, ea oricum este implicită. Să zicem de exemplu

că vrem să creăm o clasă Animal pe care o derivăm din clasa Object (animal.py):

117
class Animal(Object):
Să luăm în continuare un exemplu.
#Aici avem superclasa
class Animal(object36):
vorbesteStr = ’Salut de la Animal!’
pass
#Aici avem clasa derivata
class Caine(Animal):
pass
latra = Caine.vorbesteStr
print(latra)
La ieșire vom avea „Salut de la Animal!”.

Fig. 7.5. Ieșire program animal.py

Clasa Caine moștenește atributele clasei Animal și afișează șirul pe care clasa Animal l‑a

avut ca atribut. Dacă însă vrem să suprascriem valoarea unui atribut din clasa derivată

Caine, facem astfel (caine.py):

class Animal(object):
vorbesteStr = ’Salut de la Animal!’
pass
class Caine(Animal):
vorbesteStr = ’Salut de la caine!’
pass
latra = Caine.vorbesteStr
print(latra)
care va avea ieșirea „Salut de la caine” așa cum se poate vedea în figura de mai jos:

36 Putem să adăugăm sau nu object, functionarea programului nu va fi afectata.

118
 Fig. 7.6. Ieșirea programului caine.py

Putem de asemenea să executăm o metodă din clasa părinte (superclasă) înauntrul unei

subclase așa cum se poate vedea în următorul program rulat în interpretorul Python:

Fig. 7.7. Metoda inauntrul subclasei

Să mai luăm un exemplu ‑ de această dată din geometrie. Să spunem că dorim să aflăm

suprafața unui dreptunghi și a unui triunghi care sunt la origine poligoane.

Poligon

Dreptunghi Triunghi

Prin urmare trebuie să creăm superclasa Poligon și apoi subclasele Dreptunghi și

Triunghi care să o moștenească.

Prima dată creăm superclasa Poligon (poligon.py):

class Poligon:
lungime = 0
latime = 0
def set_valori(self, lungime, latime):

119
 Poligon.lungime = lungime
Poligon.latime = latime
Apoi subclasa Dreptungi care moștenește caracteristicile superclasei Poligon

(Dreptunghi.py):

from poligon import*

class Dreptunghi(Poligon):
def suprafata(self):
return self.lungime * self.latime

În continuare creăm clasa Triunghi (Triunghi.py):

from poligon import*
class Triunghi(Poligon):
def suprafata(self):
return(self.lungime * self.latime) / 2
În final, scriem programul necesar calculării celor două suprafețe (mostenire.py):
from Dreptunghi import*
from Triunghi import*

#cream o instanta pentru fiecare subclasa

drept = Dreptunghi()
tri = Triunghi()
#invocam metoda mostenita de la superclasa, trecandu-i
#argumentele care sunt atribuite variabilelor clasei
drept.set_valori(35, 25)
tri.set_valori(16, 20)
#afisam rezultatele manipuland variabilele
#clasei mostenite din clasa de baza
print('Aria dreptunghiului este: ', drept.suprafata())
print('Aria triunghiului este: ', tri.suprafata())

La ieșire vom avea:

120
 Fig. 7.8. Output program mostenire.py

Nu știu dacă acest capitol a fost indeajuns de explicit, prin urmare m‑am gîndit să dau un

exemplu de aplicație foarte interesantă scrisă în Python, care are o excelentă parte grafică

(realizată ce‑i drept cu ajutorul xml si javascript) dar care evidențiază în opinia mea

noțiunea de moștenire în Python. Este vorba despre OpenERP, o aplicație modulară din

sursă deschisă, de management al unei afaceri ce implică extrem de multe posibilități și

utilizată din ce în ce mai mult de companiile interesate.

OpenERP se poate descărca de pe site‑ul www.openerp.com și instala în mediile Windows

(ușor) și Linux (Debian‑Ubuntu, ceva mai greu dar nu foarte). Eu am încercat s‑o instalez și

pe Macintosh, însă după “lupte seculare” care au durat vreo două zile, m‑am dat bătut…

OpenERP vine cu o serie de module standard preinstalate dar neactivate. Printr‑un singur

click însă ele se pot activa și apoi utiliza. Ceea ce însă este interesant e faptul că modulele

se pot ajusta, se pot customiza, după dorința clientului. Poate că de exemplu unul dintre

beneficiarii OpenERP vrea ca modulul “CRM” să conțină mai multe (sau mai puține)

informații despre clienții lui din baza de date. Poate că ei vor ca partenerii de afaceri să nu

aibă adresa sau numarul de telefon fix care să apară în rapoartele (chitanțe, facuri, etc) pe

care programul le tipărește. Sunt o mulțime de posibilități sosite standard odată cu

instalarea programului, dar care se pot ajusta pe gustul utilizatorului aplicației. Pentru a

customiza însă aplicația veți fi nevoiți să pătrundeți în miezul (core‑ul) ei și aceasta

reprezintă deja un nivel de programare complex sau foarte complex.

Moștenirea obiectelor înseamnă în esență mai puțină muncă pentru că veți prelua ceea ce

alții au creat înainte și veți adapta – prin mici sau mai mari modificări, la nevoile

dumneavoastră. Daca aveti curiozitatea, puteti instala OpenERP (mai nou cunoscut ca

Odoo) si apoi sa‑i deschideti fisierele diverselor module intr‑un editor de text. Veti putea

analiza cum functioneaza mostenirea in Python intr‑un program cladit pe o arhitectura

121
excelenta.

122
Cap. VIII Crearea si manipularea formularelor web

Daca ați avut răbdarea să parcurgeți această carte până aici, sunt sigur că v‑ați

întrebat la ce folosește totuși cunoașterea unui limbaj de programare. Ați vazut doar

programe scrise într‑un editor de text, rulate în interpretorul Python din Command

Prompt (Windows) ori Terminal (MacOS sau Linux). Până acuma nu ați întâlnit un ecran

prietenos cu o interfață grafică deosebită care să aibă în spate noianul de linii de cod scrise

in Python. Și în general, în afară de nerds, nimeni nu utilizează calculatorul din linia de

comandă.. Totuși Python deține capacitatea creării de interfețe grafice interesante

(Graphical User Interface sau GUI). M‑am gandit totuși să nu abordez (încă) acest subiect

complex.

Python este însă un puternic limbaj de programare utilizat (și) pentru crearea aplicațiilor

web. La fel ca formularele scrise în limbajul PHP, cele realizate în Python sunt găzduite pe

un webserver, loc din care sunt servite utilizatorului interesat. Există însă o deosebire

fundamentală între PHP și Python: în vreme ce scripturile PHP sălășluiesc numai și numai

pe server pentru ca să poată fi procesate, scripturile Python pot să stea pe calculator atunci

când avem de‑a face cu o aplicație „desktop” de sine stătătoare și/sau pe web server atunci

când e vorba de o aplicație pentru Internet. Cu PHP nu se pot face aplicații desktop37.

Simplist explicat, procesul cerere – procesare server ‑ răspuns se desfășoară conform

desenului de mai jos:

Browser
utilizator Cerere Web
Server Inter‐
(raspuns pretor
HTML) Python

37Există totuși și posibilitatea rulării scripturilor PHP din Terminal cu comanda php –a, desigur dacă PHP este
instalat pe calculatorul dumneavoastră.

123
Serverul web trebuie mai întâi configurat ca să recunoască scripturile (fișierele) Python

care au – așa cum am învățat, extensia .py. Interpretorul Python procesează scriptul înainte

de a‑l trimite ca un răspuns HTML serverului, care la rândul lui îl returnează browser‑ului

utilizatorului. Un script Python cerut de browser poate să genereze un răspuns complet

HTML descriind tipul conținutului în prima linie a fișierului astfel:

Content-type:text/html\r\n\r\n
Ce facem totuși cu scriptul (pe care încă nu l‑am creat, linia de cod de mai sus arată doar

declarația inițială din fișier), pentru că, altfel ca fișierele Python pe care le‑am dezvoltat

până acuma și care rulau din linia de comandă a calculatorului, avem nevoie de un web

server ?

Există aici două posibilități de luat în calcul:

a. Să instalăm serverul arhicunoscut și arhifolosit38 pe plan mondial Apache pe

propriul computer și apoi să‑l configurăm astfel încât să „știe” să proceseze scripturi

Python.

Aceasta este o operație destul de dificilă, care necesită timp, aflată nu la îndemâna

începătorilor. Totuși, în Anexe găsiți modul de configurare a fișierului httpd.conf (care

este „creierul și inima” serverului Apache) pentru a prelucra fișiere Ruby, CGI, Perl și

Python.

b. Cea mai la îndemână metodă este să scriem propriul server în Python, operație ce

necesită câteva linii de cod.

Vom apela la această a doua metodă pentru că este mult mai puțin complicată. Trebuie

reținut că fișierele vor fi afișate în regim local (localhost) în browser‑ul calculatorului

dumneavoastră. Dacă aveți propriul website și vreți să exersați în „lumea reală„ puteți

întreba administratorul de sistem al serviciului de găzduire (hosting) dacă există

posibilitatea (în general, ea nu este setată implicit) de a vă configura serverul pentru

scripturi Python. Oricum, dacă atunci când ați închiriat spațiu pe server în ofertă nu era

trecută și opțiunea „scripturi CGI”, sigur nu aveți această posibilitate. Ca o paranteză

vreau să mai adaug că găzduirea de scripturi sofisticate precum CGI, Perl, Python sau

38 Peste 60% din website‑uri utilizează serverul Apache

124
Ruby costă enorm – cel puțin la anumite firme și mai ales pentru buzunarele noastre.

Serviciul meu de hosting – de care de altfel nu mă pot plânge, îmi oferea pentru scripturi

Python un server „dedicat” la prețul „minim” de 29 euro/lună! Normal că am zis pass ca‑

ntr‑o clasă Python! Există șansa să găsiți și oferte ce includ „scripturi CGI” la prețuri de bun

simț, dar dacă spre exemplu, vă bate gândul să vă portați / alcătuiți un website în

framework‑ul Django (scris în Python) ori în Mezzanine, veți primi răspunsul că nu e

posibil sau eventual, vă vor pretinde o căruță de bani.

Din acest motiv exemplele pe care le voi arăta în continuare sunt pur și simplu oferite în

scop didactic, pentru a vedea cum poate fi utilizat Python în aplicații de Internet.

Dar vorba multă sărăcia programatorului, așa că să dăm drumul la treabă și să scriem

codul serverului Python necesar aplicațiilor noastre, nu înainte de a crea pe desktopul

computerului un folder numit „webdir” iar înăuntrul acestuia încă unul numit cgi‑bin.

Scriptul webserver.py arată astfel:

Fig. 8 1. Fișierul webserver.py

Urmăriți cu atenție liniile 1, 4 și 6. Ele sunt cele mai importante din întreg fișierul Python.

Cu toate că prima linie este caracteristică computerelor UNIX (eu rulez serverul pe un

computer Macintosh bazat pe UNIX) trebuie musai s‑o adăugați în fișier chiar dacă rulați

serverul pe Windows. Linia ar putea să difere, astfel încât să nu conțină „local” ci pur și

simplu
#!/usr/bin/python3
Mai departe, scrieți cu atenție maximă linia 4, ea fiind cea mai importantă din întreg

scriptul:
from http.server import HTTPServer, CGIHTTPRequestHandler

125
Apoi este linia 6 care arată locul exact unde se află fișierele Python ce urmează să fie servite

în browser. Desigur că la dumneavoastră difera, mai cu seamă dacă lucrați în Windows.

Important este să scrieți cu exactitate unde se găsește folderul „webdir”:

webdir = '/Users/mirceaprodan/Desktop/webdir'
Linia 7 setează portul serverului. În mod normal, serverul web Apache „ascultă” la portul

80 și în cazul meu, acest lucru e valabil pentru că aici îl am și eu configurat pentru scripturi

PHP . Atunci când scriu localhost:8039 (sau 127.0.0.1:80) îmi apare pagina principală a

serverului (It works!) sau eventual (depinde cum e configurat) indexul serverului.

Așa cum vedeți în script, am setat serverul Python la valoarea 8080. Dacă aveți ceva

împotriva numărului opt, puteți să‑i dați oricare altă valoare în linia 7, dar neaparat mai

mare ca 1024:
port = 8080
La sfârșit, după ce ați scris cu atenție toate liniile de cod exact așa cum sunt date în

imaginea de mai sus, salvați scriptul webserver.py în directorul (folderul) webdir.

Nu știu dacă sunteți cât de cât familiarizați cu limbajul de marcare HTML, dar scriptul pe

care îl vom rula inițial în browser este pur și simplu un document HTML (căruia mai târziu

îi adăugăm funcția Python print() pentru a‑l putea extrage de pe server). Să vedem mai

întâi cum arată documentul HTML:

<!DOCTYPE HTML>
<html lang="en">'
<head>
<meta charset="UTF-8">
<title>Raspuns Python</title>
</head>
<body>
<h1>Salutari de la Python online!</h1>
</body>
</html>
Salavați‑l ca salutari.html pe desktop și apoi dați dublu click pe el ca să‑l rulați în

39 80 e implicit și de regulă nu se mai scrie

126
browser. Acesta este cum spuneam, doar un banal fișier HTML pe care îl putem rula direct

de pe desktop, fără a fi necesar ca să fie încărcat în server, așa cum puteți vedea privind

URL‑ul evidențiat în browser:

Fig. 8.2. salutari.html rulat în browser

Ca să avem un script Python adevărat trebuie doar să‑i facem câteva retușuri, să‑l încărcăm

în server și apoi să‑l afișăm în browser‑ul web. Pentru asta trebuie mai întâi să adăugăm

neapărat linia de cod care arată unde este interpretorul Python, inclusiv pentru fișierele pe

care le rulați sub Windows:

#!/usr/local/bin/python3.3
Apoi dați un Enter ca să aveți o linie goală (linia 2) și după aceea scrieți linia de cod despre

care am amintit la începutul acestui capitol:

print('Content-type:text/html\r\n\r\n')
În final, fiecare linie de program din fișierul salutari.html treceți‑o drept argument al

funcție print() din Python.

În consecință, prima noastră pagină web scrisă în Python (raspuns.py) va arăta așa:

Fig.8.3. Scriptul raspuns.py

Salvați fișierul raspuns.py în subfolderul cgi‑bin aflat în folderul webdir situat pe desktop.

Acuma urmează lucrul cel mai interesant, anume vizualizarea primei dumneavoastră

pagini web scrisă în Python. Pentru aceasta mai întâi trebui să pornim serverul despre care

127
am scris că lucrează la portul 8080.

Schimbăm directorul în folderul webdir cu comanda (aceeași pentru Mac, Windows sau

Linux) dată în Command Prompt sau Terminal :

cd Desktop/webdir
Următoarea comandă este:
python3 webserver.py
care pornește serverul la portul 8080 după cum se poate vedea în imaginea următoare:

Fig.8.4. Pornire server

Deschidem browser‑ul (daca nu este deja în această poziție) și scriem în bara URL:
http://localhost:8080
Dacă ați făcut corect toți pașii necesari, pagina web care apare va arăta indexul serverului

ce include fișierele aflate în el. În cazul meu sunt mai multe, după cum se poate vedea mai

jos:

Fig.8.5. Directorul indexului fișierelor serverului

Cum scriam, fișierul care ne interesează si anume raspuns.py se află în folderul cgi‑bin. Ca

128
să‑l afișăm scriem în browser – în niciun caz nu dăm click în index pe subfolderul cgi‑bin

pentru ca va apărea o eroare de autorizare 403, următoarea adresă:

http://localhost:8080/raspuns.py :

Fig.8.6. Scriptul web raspuns.py trimis din server

Se observă ‑ privind URL‑ul paginii, că de această dată fișierul este trimis din webserver și

cu toate că pagina pare identică cu cea afișată de fișierul răspuns.html, de fapt nu este

nici pe departe același lucru.

Următorul fișier pe care vi‑l propun este mai complex și l‑am preluat din cartea lui Mark

Lutz, Learning Python. Este vorba despre un program foarte simpatic care afișează o pagină

web ce conține codul salutului începătorilor în programare „Hello World!” afișat pentru

cele mai cunoscute limbaje de programare. Fișierul Python este următorul (limbaje.py):
#!/usr/local/bin/python3.3

"""
show hello world syntax for input language name;
any languages name can arrive at this script since explicit
"""

debugme = False
inputkey = 'language'

hellos = {
'Python': r" print('Hello World') ",
'Python2': r" print 'Hello Wordl' ",
'Perl': r' print "Hello World\n" ',
'Tcl': r' puts "Hello World" ',
'Scheme': r' (display "Hello World") (newline) ',
'SmallTalk': r" 'Hello World' print. ",
'Java': r' System.out.println("Hello World"); ',
'C': r' printf("Hello World\n"); ',
'C++': r' cout << "Hello World" << endl; ',
'Fortran': r" print *, 'Hello World' ",
'Pascal': r" Writeln('Hello World';) "

129
}

class dummy:
def __init__(self, str): self.value = str

import cgi, sys

if debugme:
form = {inputkey: dummy(sys.argv[1])}
else:
form = cgi.FieldStorage()

print('Contet-type: text/html\n')
print('<title>Languages</title>')
print('<h1>Sytnax</h1><hr>')

def showHello(form):
choice = form[inputkey].value
print('<h3>%s</h3><p><pre>' %choice)
try:
print(cgi.escape(hellos[choice]))
except KeyError:
print("Sorry-- I don'y know that language")
print('</pre></p><br>')

if not inputkey in form or form[inputkey].value == 'All':

for lang in hellos.keys():
mock = {inputkey: dummy(lang)}
showHello(mock)
else:
showHello(mock)
print('</hr>')

Ieșirea lui este următoarea (partea superioară a paginii):

Fig.8.7. Ieșire program limbaje.py

130
8.1. Drepturi de acces la fișiere
Rămâne totuși de lămurit un lucru esențial în programarea Python pentru web, de care cu

siguranță vă veți lovi și anume dreptul de acces la fișiere. Spre deosebire de scripturile

PHP, fișierele Python sunt mult mai dificil de manipulat din server. Ce vreau să spun cu

aceasta este că atunci când veți încerca să le afișați în browser, cu siguranță veți întâlni

adesea refuzul serverului de a vă permite accesul la fișier sau, în cel mai bun caz, în loc să

vă afișeze pagina web revendicată, vă va fi oferit fișierul în sine pe care să‑l vizualizați sau

descărcați ca în figura de mai jos (pentru MacOS dar e valabil și pentru Windows) unde eu

am solicitat pagina web link.py:

Fig.8.8. Setare incorectă a privilegiilor de acces

Pentru a evita o astfel de situație trebuie să configurați dreptul de acces la fișier astfel încât

doar dumneavoastră ca administrator să fiți proprietarul lui și să aveți dreptul să scrieți în

el și să‑l citiți. Ceilalți, trebuie să aibă doar dreptul de a‑l citi. Nu vă garantez ca această

configurare funcționează fără probleme pentru că nu este așa. După ce am încercat de

nenumărate ori diverse scripturi Python pentru web cu combinații diferite de privilegii, am

131
ajuns la concluzia că există o mare doză de impredictibilitate în a funcționa sau nu. Poate vi

se pare o abordare neprofesională a problemei, dar după ce vă veți lovi de vreo 50 de ori de

refuzul de a deschide pagina web cerută știind că ați scris/reprodus perfect un fișier, s‑ar

putea să îmi dați dreptate. Știu, în sistemele UNIX / Linux drepturile de acces la fișiere sunt

mult mai restrictive, acesta fiind unul dintre motivele pentru care în general, utilizatorii

comuni ai calculatoarelor evită folosirea lor. Nu știu cum este în Windows, nu am încercat,

dar după știința mea, setarea privilegiilor asupra unui fișier nu este atât de spectaculoasă

ca în Unix.

132
Milioane de posibilități...
Cum bine spunea unul dintre Părinții Fondatori ai Statelor Unite, cea mai bună

metodă ca să înveți un lucru este să scrii o carte despre el. Pot spune că și eu am procedat

la fel în cazul de față. Puteți afirma că nu e prea bine ca un individ care abia deslușește

tainele unui limbaj de programare să se apuce să și scrie despre el. Munca mea la acest mic

manual mi‑a dovedit că nu este așa, pentru că mereu ești nevoit să cauți și să aduni

informații de prin tot felul de cărți în limba engleza descărcate de pe Internet.

Din cărți se nasc alte cărți și această maximă e valabila și în privința paginilor de față.

Mi‑au fost de un real ajutor astfel, volumele scrise de Tony Gaddis (din care m‑am inspirat

foarte mult) și Paul Barry & David Griffiths. Nu‑i pot lăsa deoparte pe Dusty Phillips, pe

Al Sweigart, ori pe Fabien Pinkaert, creatorul OpenERP.

Motivul pentru care m‑am aplecat asupra acestui subiect este plăcerea de a scrie și

rula programe in Python. Motivul cu adevărat important este că în limba română nu există

până acuma – după știința mea ‑ o carte cât de neînsemnată despre acest din ce în ce mai

important limbaj modern de programare. Nu am pretenția ca paginile mele să umple acest

gol. Sunt convins că în România există destui oameni extrem de talentați în mânuirea

liniilor de cod Python – cu siguranță autodidacți ‑ care ar putea s‑o facă mult mai bine și cu

mai mult talent ca mine. Sunt însă sigur că paginile pe care le‑ați avut în față au reușit cât

de cât să vă dumirească asupra unui minunat dar puțin cunoscut pe aceste meleaguri

limbaj de programare.

Daca v‑am trezit curiozitatea, vă stau la dispoziție pe Internet o droaie de cărți,

forumuri de discuții sau tutoriale dintre cele mai simple ori mai complexe. Dați doar un

search pe motorul de cautare preferat și în față vi se vor deschide milioane de posibilități...

133
Bibliografie
4. Barry, Paul, Griffiths, David, Head First Programming, O’Reilly

Media, Sebastopol, CA, 2009

5. Barry, Paul, Head First Python, O’Reilly Media, Sebastopol, CA,

2011

6. Gaddis, Tony, Starting out with Python (second edition), Pearson

Education, Boston,2012

7. Harrington, Andrew, Hands‑On Python. A tutorial introduction

for beginners (Python 3.1. version), creativecommons.org

8. Phillips, David, Python3 Object Oriented Programming, Packt

Publishing, London, 2010

9. Pinckaers Fabien, Van Vossel, Els, Streamline your Menufacturing

Processes with OpenERP, Open Object Press, 2012

10. Swaroop, CH, A byte of Python (second edition)

11. Sweigart, Al, Invent Your Own Computer Games With Python

(second edition), Creative Commons Licence

134