# 1. Variabile in Python - limbaj de programare dinamic¶

Intr-un cod sursa, variabilele reprezinta containere utilizate pentru stocarea temporara a valorilor informatiilor (datelor) cu care lucreaza programul. Totodata, variabilele furnizeaza programatorului o solutie facila pentru accesarea informatiilor cu care lucreaza programul.
Din punctul de vedere al tipului de date al variabilelor, Python reprezinta un limbaj de programare dinamic (data type dynamic programming language).

Aceasta caracteristica a limbajului Python se manifesta prin faptul ca tipul de date al unei variabile nu se declara explicit, ci este stabilit in timpul executiei programului, la momenul in care variabila se creeaza. In limbajul Python, o variabila este creata in momentul in care este initializata cu o valoare. Acest lucru difera fata de cazul limbajelor statice de programare, cum ar fi limbajele Java, C, C++, etc, la care tipul variabilelor se declara explicit, fiind stabilit ulterior in timpul compilarii codului sursa.

Declarearea si initializarea unei variabile in limbajul Java:

    int x;
    x = 10;

Crearea unei variabile in limbajul Python:

    x = 10

Datorita faptului ca este un limbaj dinamic de programare, in Python variabilele au urmatoarele caracteristici:

- in Python, toate variabilele sunt obiecte; obiectele apartin unei clase (sunt de tipul clasei)
- o variabila este creata in timpul executiei codului sursa, in linia de cod in care acesteia i se atribuie o valoare

      x = 10   # aici se creeaza variabila x

- tipul de date al unei variabile nu se declara explicit, ci este stabilit la tipul valorii care i se atribuie

      x = 10   # variabila x este de tipul int (integer) deoarece valoarea atribuita (10) este de tipul int

- o variabila este creata atunci cand se executa o instructiune de atribuire => chiar daca se pastreaza aceeasi denumire pentru identificarea variabilei, in codul de mai jos sunt create 3 variabile diferite (3 obiecte diferite)

      x = 10        # se creeaza o variabila cu denumirea x, de tipul int (integer)
      x = 20        # se creeaza o noua variabila cu aceeasi denumire x, tot de tipul int (integer)
      x = '30'      # se creeaza o noua variabila cu aceeasi denumire x, de tipul str (string)

## ID - ul (identificatorul) unei variabile¶

La crearea sa, o variabila primeste automat un identificator (id) prin care acesta poate fi identificata in blocul de memorie in care exista. Acest identificator este reprezentat de un numar intreg unic, similar adresei unei locatii de memorie, care se mentine constant pe durata de existenta a variabilei respective. Limbajul Python pune la dispozitia programatorului functia predefinita (built-in function) `id()`, care poate fi utilizata pentru returnarea identificatorului variabilei (obiectului).

- Sintaxa:

      id(obiect)   # returneaza id-ul obiectului (variabilei) furnizat ca argument functiei

In [1]:

    id?

    Help on built-in function id in module builtins:

    id(obj, /)
        Return the identity of an object.

        This is guaranteed to be unique among simultaneously existing objects.
        (CPython uses the object's memory address.)

In [2]:

    # Exemplul 1: returnarea IDului unei variabile (ID-ul obiectului)

    #crearea variabilei (obiectului)
    x = 10

    # apelarea functiei care returneaza id-ul variabilei (obiectului)
    id(x)

Out[2]:

    140723292644016

In [3]:

    # Exemplul 2: 2 variabile diferite, acelasi nume

    # x = obiect de tip int
    x = 10
    id1 = id(x)

    # x = obiect de tip str
    x = '10'
    id2 = id(x)

    # afisarea id-urilor celor 2 obiecte
    print(id1)
    print(id2)

    140723292644016
    3189638943472

## Tipul de date a unei variabile¶

Limbajul Python pune la dispozitia programatorului functia predefinita (built-in function) `type()`, care poate fi utilizata pentru identificarea clasei variabilei (obiectului).

- Sintaxa:

      type(obiect)   # returneaza tipul variabilei (clasa obiectului) furnizata ca argument functiei type

In [4]:

    # Exemplul 3: returnarea tipului unei variabile (returnarea clasei obiectului)

    # x = obiect de tip int
    x = 10

    type(x)

Out[4]:

    int

### Conventii utilizate in denumirea variabilelor¶

In oricare cod sursa, se recomanda ca denumirea variabilei sa descrie rolul sau in executia programului. In limbajul de programare Python, este necesar ca denumirea variabilelor sa respecte urmatoarele reguli:

- primul caracter din numele unei variabile trebuie sa fie o litera, sau caracterul underscore `_`
- nu se permite ca primul caracter din numele unei variabile sa fie o cifra
- numele unei variabile poate contine numai caractere alfa-numerice: A-z, 0-9, si _
- numele utilizat pentru denumirea unei variabile este "case-sensitive":age, Age si AGE reprezinta 3 variabile diferite

In Python, pentru denumirea variabilelor se recomanda respectarea urmatoarelor reguli:

- utilizarea caracterelor litera mica: exemplu = age
- daca denumirea unei variabile implica utilizarea mai multor cuvinte, se recomanda ca acestea sa fie separate de caracterul underscore: exemplu = my_age

In cazul in care in codul sursa se utilizeaza variabile care nu-si modifica valoarea pe durata executiei codului (acest tip de variabile sunt considerate constante; in Python nu exista integrate comenzi specifice pentru declararea constantelor) , se recomanda ca pentru denumirea acestora sa fie utilizate doar litere mari: exemplu = MAX_VALUE

# 2. Tipuri de date definite in limbajul Python¶

In programare, tipul de date reprezinta un concept important, care stabileste urmatoarele:

- tipul valorii pe care o poate avea o variabila,
- tipurile de operatii care pot fi efectuate cu variabila respectiva, fara a fi lansate erori.

In limbajul de programare Python exista predefinite urmatoarele tipuri de date (built-in data types):

- numeric:`int, float, complex`
- boolean:`bool`
- text:`str`
- containere (structuri de date):
  - de tip secventa: `list, tuple, range`
  - de tip set: `set, frozenset`
  - de tip map: `dict`
- binar: `bytes, bytearray, memoryview`

# 3. Intructiunea de atribuire (assignment statement)¶

Intructiunea de atribuire permite furnizarea unei valori, unei variabile.

**In limbajul Python, o variabila este creata la executia instructiunii de atribuire; tipul variabilei este definit de catre tipul valorii atribuite**.

Instructiunea de atribuire utilizeaza operatorul de atribuire `=` si poate fi simpla, sau multipla:

### Instructiunea de atribuire simpla:¶

- Sintaxa:

      variabila = valoare

- Exemplu:

    x = 10       variabila este initializata cu o valoare de tip numeric

    x = 'ten'    variabila este intializata cu o valoare de tip string

### Instructiunea de atribuire multipla: o valoare unica pentru variabile diferite¶

- Sintaxa:

      variabila_1 = variabila_2 = ... = variabila_N = valoare_unica

In [5]:

    # Exemplul 4: utilizarea instructiunii de atribuire multipla; 2 variabile primesc aceeasi valoare unica:

    x = y = 10

    # afisare valori x, respectiv y
    print(x)
    print(y)

    10
    10

### Instructiunea de atribuire multipla: valori diferite pentru variabile diferite:¶

- Sintaxa:

      variabila_1, ..., variabila_N = valoare_1, ..., valoare_N

In [6]:

    # Exemplul 5:  utilizarea instructiunii de atribuire multipla; 2 variabile primesc 2 valori diferite

    x, y = 10, 20

    # afisare valori x, respectiv y
    print(x)
    print(y)

    10
    20

### Instructiunea de atribuire multipla: interschimbarea valorilor intre 2 variabile:¶

- Sintaxa:

      variabila_1, variabila_2 = variabila_2, variabila_1

In [7]:

    # Exemplul 5: utilizarea instructiunii de atribuire multipla - 2 variabile isi "paseaza" reciproc valorile
    x, y = 10, 20

    # afisare valori x, respectiv y
    print(x,y)

    # interschimbarea valorilor celor 2 variabile
    # x primeste valoarea initiala a lui y = 20
    # y primeste valoarea initiala a lui x = 10
    x, y = y, x

    # afisare valori x, respectiv y
    print(x,y)

    10 20
    20 10

# 4. Tipuri de date numerice in Python¶

In limbajul Python sunt definite urmatoarele tipuri de date numerice:

- tipul intreg/ numere intregi (integers): `int`
- tipul real/ numere reale (floating point numbers):`float`
- tipul complex/ numere complexe (complex numbers):`complex`

### Tipul de date intreg `int`¶

In limbajul Python, datele de tip intreg sunt identificate prin cuvantul cheie `int`.Tipul de date intreg include valoarea 0, toate numerele intregi pozitive si toate numerele intregi negative. Numerele intregi negative sunt reprezentate cu prefixul "-". Intervalul de valori pe care datele de tip intreg sunt definite depinde de resursele furnizate de catre calculatorul pe care ruleaza codul sursa. Varianta cea mai comuna de implementare utilizeaza intervalul de valori -2,147,483,648 ($-2^{31}$) to +2,147,483,647 ($2^{31}-1$) pentru definirea numerelor intregi. In limbajul Python, tipul `int` reprezinta o clasa, care defineste tipul de date numerice de tip intreg, iar variabilele programului, carora le sunt atribuite acest tip de date reprezinta obiecte de tip int. Clasa `int` furnizeaza un set de functii, denumite metode care pot fi aplicate variabilelor de tip intreg. Metodele furnizate de catre clasa `int` pot fi listate prin aplicarea functiei tab-completion denumirii clasei, urmata de operatorul punct.

Observatie: limbajul Python permite utilizarea caracterului underscore in specificarea valorilor numerice; se recomanda utilizarea caracterului underscore atunci cand este utila gruparea cifrelor valorii.

- Exemplu:

      x = 1_000_000

In [8]:

    # Exemplul 6: listarea metodelor puse la dispozitie de catre clasa int:
    int.

    Help on class int in module builtins:

    class int(object)
     |  int([x]) -> integer
     |  int(x, base=10) -> integer
     |
     |  Convert a number or string to an integer, or return 0 if no arguments
     |  are given.  If x is a number, return x.__int__().  For floating point
     |  numbers, this truncates towards zero.
     |
     |  If x is not a number or if base is given, then x must be a string,
     |  bytes, or bytearray instance representing an integer literal in the
     |  given base.  The literal can be preceded by '+' or '-' and be surrounded
     |  by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.
     |  Base 0 means to interpret the base from the string as an integer literal.
     |  >>> int('0b100', base=0)
     |  4
     |
     |  Methods defined here:
     |
     |  __abs__(self, /)
     |      abs(self)
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __and__(self, value, /)
     |      Return self&value.
     |
     |  __bool__(self, /)
     |      self != 0
     |
     |  __ceil__(...)
     |      Ceiling of an Integral returns itself.
     |
     |  __divmod__(self, value, /)
     |      Return divmod(self, value).
     |
     |  __eq__(self, value, /)
     |      Return self==value.
     |
     |  __float__(self, /)
     |      float(self)
     |
     |  __floor__(...)
     |      Flooring an Integral returns itself.
     |
     |  __floordiv__(self, value, /)
     |      Return self//value.
     |
     |  __format__(self, format_spec, /)
     |      Default object formatter.
     |
     |  __ge__(self, value, /)
     |      Return self>=value.
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __getnewargs__(self, /)
     |
     |  __gt__(self, value, /)
     |      Return self>value.
     |
     |  __hash__(self, /)
     |      Return hash(self).
     |
     |  __index__(self, /)
     |      Return self converted to an integer, if self is suitable for use as an index into a list.
     |
     |  __int__(self, /)
     |      int(self)
     |
     |  __invert__(self, /)
     |      ~self
     |
     |  __le__(self, value, /)
     |      Return self<=value.
     |
     |  __lshift__(self, value, /)
     |      Return self<<value.
     |
     |  __lt__(self, value, /)
     |      Return self<value.
     |
     |  __mod__(self, value, /)
     |      Return self%value.
     |
     |  __mul__(self, value, /)
     |      Return self*value.
     |
     |  __ne__(self, value, /)
     |      Return self!=value.
     |
     |  __neg__(self, /)
     |      -self
     |
     |  __or__(self, value, /)
     |      Return self|value.
     |
     |  __pos__(self, /)
     |      +self
     |
     |  __pow__(self, value, mod=None, /)
     |      Return pow(self, value, mod).
     |
     |  __radd__(self, value, /)
     |      Return value+self.
     |
     |  __rand__(self, value, /)
     |      Return value&self.
     |
     |  __rdivmod__(self, value, /)
     |      Return divmod(value, self).
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __rfloordiv__(self, value, /)
     |      Return value//self.
     |
     |  __rlshift__(self, value, /)
     |      Return value<<self.
     |
     |  __rmod__(self, value, /)
     |      Return value%self.
     |
     |  __rmul__(self, value, /)
     |      Return value*self.
     |
     |  __ror__(self, value, /)
     |      Return value|self.
     |
     |  __round__(...)
     |      Rounding an Integral returns itself.
     |      Rounding with an ndigits argument also returns an integer.
     |
     |  __rpow__(self, value, mod=None, /)
     |      Return pow(value, self, mod).
     |
     |  __rrshift__(self, value, /)
     |      Return value>>self.
     |
     |  __rshift__(self, value, /)
     |      Return self>>value.
     |
     |  __rsub__(self, value, /)
     |      Return value-self.
     |
     |  __rtruediv__(self, value, /)
     |      Return value/self.
     |
     |  __rxor__(self, value, /)
     |      Return value^self.
     |
     |  __sizeof__(self, /)
     |      Returns size in memory, in bytes.
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  __sub__(self, value, /)
     |      Return self-value.
     |
     |  __truediv__(self, value, /)
     |      Return self/value.
     |
     |  __trunc__(...)
     |      Truncating an Integral returns itself.
     |
     |  __xor__(self, value, /)
     |      Return self^value.
     |
     |  bit_length(self, /)
     |      Number of bits necessary to represent self in binary.
     |
     |      >>> bin(37)
     |      '0b100101'
     |      >>> (37).bit_length()
     |      6
     |
     |  conjugate(...)
     |      Returns self, the complex conjugate of any int.
     |
     |  to_bytes(self, /, length, byteorder, *, signed=False)
     |      Return an array of bytes representing an integer.
     |
     |      length
     |        Length of bytes object to use.  An OverflowError is raised if the
     |        integer is not representable with the given number of bytes.
     |      byteorder
     |        The byte order used to represent the integer.  If byteorder is 'big',
     |        the most significant byte is at the beginning of the byte array.  If
     |        byteorder is 'little', the most significant byte is at the end of the
     |        byte array.  To request the native byte order of the host system, use
     |        `sys.byteorder' as the byte order value.
     |      signed
     |        Determines whether two's complement is used to represent the integer.
     |        If signed is False and a negative integer is given, an OverflowError
     |        is raised.
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  from_bytes(bytes, byteorder, *, signed=False) from builtins.type
     |      Return the integer represented by the given array of bytes.
     |
     |      bytes
     |        Holds the array of bytes to convert.  The argument must either
     |        support the buffer protocol or be an iterable object producing bytes.
     |        Bytes and bytearray are examples of built-in objects that support the
     |        buffer protocol.
     |      byteorder
     |        The byte order used to represent the integer.  If byteorder is 'big',
     |        the most significant byte is at the beginning of the byte array.  If
     |        byteorder is 'little', the most significant byte is at the end of the
     |        byte array.  To request the native byte order of the host system, use
     |        `sys.byteorder' as the byte order value.
     |      signed
     |        Indicates whether two's complement is used to represent the integer.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs) from builtins.type
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  denominator
     |      the denominator of a rational number in lowest terms
     |
     |  imag
     |      the imaginary part of a complex number
     |
     |  numerator
     |      the numerator of a rational number in lowest terms
     |
     |  real
     |      the real part of a complex number

### Tipul de date real `float`¶

In limbajul Python, datele de tip real sunt identificate prin cuvantul cheie `float`. Pentru reprezentarea valorilor numerelor reale, limbajul Python utilizeaza reprezentarea in virgula mobila. Varianta cea mai comuna de implementare utilizeaza intervalul de valori $-10^{308}$ to $10^{308}$ pentru reprezentarea numerelor reale, cu 16 biti pentru reprezentarea valorii fractionare.

In limbajul Python, un numar real poate fi reprezentat fie in format zecimal (cu virgula) fie in format stiintific (cu exponent).

In limbajul Python, `float` reprezinta o clasa care defineste tipul de date numerice de tip real, iar variabilele programului, carora le sunt atribuite acest tip de date reprezinta obiecte de tip real. Clasa `float` furnizeaza un set de functii, denumite metode care pot fi aplicate variabilelor de tip real. Metodele furnizate de catre clasa `float` pot fi listate prin aplicarea functiei tab-completion denumirii clasei, urmata de operatorul punct.

In [9]:

    # Exemplul 7: listarea metodelor puse la dispozitie de catre clasa float:
    float.

    Help on class float in module builtins:

    class float(object)
     |  float(x=0, /)
     |
     |  Convert a string or number to a floating point number, if possible.
     |
     |  Methods defined here:
     |
     |  __abs__(self, /)
     |      abs(self)
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __bool__(self, /)
     |      self != 0
     |
     |  __divmod__(self, value, /)
     |      Return divmod(self, value).
     |
     |  __eq__(self, value, /)
     |      Return self==value.
     |
     |  __float__(self, /)
     |      float(self)
     |
     |  __floordiv__(self, value, /)
     |      Return self//value.
     |
     |  __format__(self, format_spec, /)
     |      Formats the float according to format_spec.
     |
     |  __ge__(self, value, /)
     |      Return self>=value.
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __getnewargs__(self, /)
     |
     |  __gt__(self, value, /)
     |      Return self>value.
     |
     |  __hash__(self, /)
     |      Return hash(self).
     |
     |  __int__(self, /)
     |      int(self)
     |
     |  __le__(self, value, /)
     |      Return self<=value.
     |
     |  __lt__(self, value, /)
     |      Return self<value.
     |
     |  __mod__(self, value, /)
     |      Return self%value.
     |
     |  __mul__(self, value, /)
     |      Return self*value.
     |
     |  __ne__(self, value, /)
     |      Return self!=value.
     |
     |  __neg__(self, /)
     |      -self
     |
     |  __pos__(self, /)
     |      +self
     |
     |  __pow__(self, value, mod=None, /)
     |      Return pow(self, value, mod).
     |
     |  __radd__(self, value, /)
     |      Return value+self.
     |
     |  __rdivmod__(self, value, /)
     |      Return divmod(value, self).
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __rfloordiv__(self, value, /)
     |      Return value//self.
     |
     |  __rmod__(self, value, /)
     |      Return value%self.
     |
     |  __rmul__(self, value, /)
     |      Return value*self.
     |
     |  __round__(self, ndigits=None, /)
     |      Return the Integral closest to x, rounding half toward even.
     |
     |      When an argument is passed, work like built-in round(x, ndigits).
     |
     |  __rpow__(self, value, mod=None, /)
     |      Return pow(value, self, mod).
     |
     |  __rsub__(self, value, /)
     |      Return value-self.
     |
     |  __rtruediv__(self, value, /)
     |      Return value/self.
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  __sub__(self, value, /)
     |      Return self-value.
     |
     |  __truediv__(self, value, /)
     |      Return self/value.
     |
     |  __trunc__(self, /)
     |      Return the Integral closest to x between 0 and x.
     |
     |  as_integer_ratio(self, /)
     |      Return integer ratio.
     |
     |      Return a pair of integers, whose ratio is exactly equal to the original float
     |      and with a positive denominator.
     |
     |      Raise OverflowError on infinities and a ValueError on NaNs.
     |
     |      >>> (10.0).as_integer_ratio()
     |      (10, 1)
     |      >>> (0.0).as_integer_ratio()
     |      (0, 1)
     |      >>> (-.25).as_integer_ratio()
     |      (-1, 4)
     |
     |  conjugate(self, /)
     |      Return self, the complex conjugate of any float.
     |
     |  hex(self, /)
     |      Return a hexadecimal representation of a floating-point number.
     |
     |      >>> (-0.1).hex()
     |      '-0x1.999999999999ap-4'
     |      >>> 3.14159.hex()
     |      '0x1.921f9f01b866ep+1'
     |
     |  is_integer(self, /)
     |      Return True if the float is an integer.
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __getformat__(typestr, /) from builtins.type
     |      You probably don't want to use this function.
     |
     |        typestr
     |          Must be 'double' or 'float'.
     |
     |      It exists mainly to be used in Python's test suite.
     |
     |      This function returns whichever of 'unknown', 'IEEE, big-endian' or 'IEEE,
     |      little-endian' best describes the format of floating point numbers used by the
     |      C type named by typestr.
     |
     |  __set_format__(typestr, fmt, /) from builtins.type
     |      You probably don't want to use this function.
     |
     |        typestr
     |          Must be 'double' or 'float'.
     |        fmt
     |          Must be one of 'unknown', 'IEEE, big-endian' or 'IEEE, little-endian',
     |          and in addition can only be one of the latter two if it appears to
     |          match the underlying C reality.
     |
     |      It exists mainly to be used in Python's test suite.
     |
     |      Override the automatic determination of C-level floating point type.
     |      This affects how floats are converted to and from binary strings.
     |
     |  fromhex(string, /) from builtins.type
     |      Create a floating-point number from a hexadecimal string.
     |
     |      >>> float.fromhex('0x1.ffffp10')
     |      2047.984375
     |      >>> float.fromhex('-0x1p-1074')
     |      -5e-324
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs) from builtins.type
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  imag
     |      the imaginary part of a complex number
     |
     |  real
     |      the real part of a complex number

### Tipul de date complex (complex)¶

In limbajul Pyhton, numerele complexe sunt reprezentate prin utilizarea caracterului "j" pentru specificarea partii imaginare a acestuia.

In limbajul Python, `complex` reprezinta o clasa care defineste tipul de date numerice de tip complex, iar variabilele programului, carora le sunt atribuite acest tip de date reprezinta obiecte de tip complex. Clasa `complex` furnizeaza un set de functii, denumite metode care pot fi aplicate variabilelor de tip complex. Metodele furnizate de catre clasa `complex` pot fi listate prin aplicarea functiei tab-completion denumirii clasei, urmata de operatorul punct.

In [10]:

    # Exemplul 8: listarea metodelor puse la dispozitie de catre clasa complex:
    complex.

    Help on class complex in module builtins:

    class complex(object)
     |  complex(real=0, imag=0)
     |
     |  Create a complex number from a real part and an optional imaginary part.
     |
     |  This is equivalent to (real + imag*1j) where imag defaults to 0.
     |
     |  Methods defined here:
     |
     |  __abs__(self, /)
     |      abs(self)
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __bool__(self, /)
     |      self != 0
     |
     |  __divmod__(self, value, /)
     |      Return divmod(self, value).
     |
     |  __eq__(self, value, /)
     |      Return self==value.
     |
     |  __float__(self, /)
     |      float(self)
     |
     |  __floordiv__(self, value, /)
     |      Return self//value.
     |
     |  __format__(...)
     |      complex.__format__() -> str
     |
     |      Convert to a string according to format_spec.
     |
     |  __ge__(self, value, /)
     |      Return self>=value.
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __getnewargs__(...)
     |
     |  __gt__(self, value, /)
     |      Return self>value.
     |
     |  __hash__(self, /)
     |      Return hash(self).
     |
     |  __int__(self, /)
     |      int(self)
     |
     |  __le__(self, value, /)
     |      Return self<=value.
     |
     |  __lt__(self, value, /)
     |      Return self<value.
     |
     |  __mod__(self, value, /)
     |      Return self%value.
     |
     |  __mul__(self, value, /)
     |      Return self*value.
     |
     |  __ne__(self, value, /)
     |      Return self!=value.
     |
     |  __neg__(self, /)
     |      -self
     |
     |  __pos__(self, /)
     |      +self
     |
     |  __pow__(self, value, mod=None, /)
     |      Return pow(self, value, mod).
     |
     |  __radd__(self, value, /)
     |      Return value+self.
     |
     |  __rdivmod__(self, value, /)
     |      Return divmod(value, self).
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __rfloordiv__(self, value, /)
     |      Return value//self.
     |
     |  __rmod__(self, value, /)
     |      Return value%self.
     |
     |  __rmul__(self, value, /)
     |      Return value*self.
     |
     |  __rpow__(self, value, mod=None, /)
     |      Return pow(value, self, mod).
     |
     |  __rsub__(self, value, /)
     |      Return value-self.
     |
     |  __rtruediv__(self, value, /)
     |      Return value/self.
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  __sub__(self, value, /)
     |      Return self-value.
     |
     |  __truediv__(self, value, /)
     |      Return self/value.
     |
     |  conjugate(...)
     |      complex.conjugate() -> complex
     |
     |      Return the complex conjugate of its argument. (3-4j).conjugate() == 3+4j.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs) from builtins.type
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  imag
     |      the imaginary part of a complex number
     |
     |  real
     |      the real part of a complex number

# 5. Tipuri de date booleene `bool` in Python¶

In limbajul Python, datele de tip boolean `bool` au doar 2 valori si anume:

- `True` - adevarat
- `False` - fals

Intern, limbajul Python utilizeaza pentru reprezentarea celor 2 valori booleene valorile intregi 1 pentru reprezentarea valorii `True`, respectiv 0, pentru reprezentarea valorii `False`.

# 6. Tipuri de date text `str` in Python¶

In limbajul Python, datele de tip text (string) sunt identificate prin cuvantul cheie `str`. Acest tip de date, referit si prin denumirea "sir de caractere", reprezinta o colectie (sau secventa) de caractere inclusa intre:

- caractere simple apostrof ', sau caractere simple ghilimele ", pentru siruri de caractere pe 1 singura linie de cod - single line string

Sintaxa - varianta 1:

    'text'

Sintaxa - varianta 2:

    "text"

- caractere triple apostrof ', sau caractere triple ghilimele ", pentru siruri de caractere pe mai multe linii de cod - multi-line string/paraghraph

Sintaxa - varianta 1:

    '''
    text
    '''

Sintaxa - varianta 2:

    """
    text
    """

In [11]:

    # Exemplul 9: string pe 1 linie de cod - V1: denumirea trupei este inclusa intre caractere ""
    '"Dream Theater" is an American progressive metal band formed in 1985 in Boston.'

Out[11]:

    '"Dream Theater" is an American progressive metal band formed in 1985 in Boston.'

In [12]:

    # Exemplul 10: string pe 1 linie de cod - V2: textul utilizat necesita utilizarea caracterului '
    "It's up to you to decide what are the best progressive metal bands."

Out[12]:

    "It's up to you to decide what are the best progressive metal bands."

In [13]:

    # Exemplul 11: string pe 1 linie de cod - V3: Dream Theater - "I Walk Beside You" lyrics
    '''
    I walk beside you
    Wherever you are
    Whatever it takes
    No matter how far
    '''

Out[13]:

    '\nI walk beside you\nWherever you are\nWhatever it takes\nNo matter how far\n'

In [14]:

    # Exemplul 12: string pe 1 linie de cod - V4: Metallica - "Master of puppets" lyrics
    """
    Master of puppets I'm pulling your strings
    Twisting your mind and smashing your dreams
    Blinded by me, you can't see a thing
    Just call my name, 'cause I'll hear you scream
    """

Out[14]:

    "\nMaster of puppets I'm pulling your strings\nTwisting your mind and smashing your dreams\nBlinded by me, you can't see a thing\nJust call my name, 'cause I'll hear you scream\n"

### Escape sequences¶

Uneori, pentru declararea unei valori de tip string, este necesara utilizarea secventelor escape (escape sequences). Secventele escape sunt identificate prin prefixul . Exemple de secvente escape utilizate des sunt:

- `\n` = newline
- `\t` = tab
- `\'` = apostrof
- `\"` = ghilimele

In [15]:

    # Exemplul 13: utilizarea secventelor escape in declararea unei variabile string:
    'Dream Theater\'s greatest album is Octavarium.'

Out[15]:

    "Dream Theater's greatest album is Octavarium."

In limbajul Python, `str` reprezinta o clasa care defineste tipul de date numerice de tip text (sir de caractere), iar variabilele programului, carora le sunt atribuite acest tip de date reprezinta obiecte de tip string. Clasa `str` furnizeaza un set de functii, denumite metode care pot fi aplicate variabilelor de tip `str`. Metodele furnizate de catre clasa `str` pot fi listate prin aplicarea functiei tab-completion denumirii clasei, urmata de operatorul punct.

In [16]:

    # Exemplul 14: listarea metodelor puse la dispozitie de catre clasa string:
    str.

    Help on class str in module builtins:

    class str(object)
     |  str(object='') -> str
     |  str(bytes_or_buffer[, encoding[, errors]]) -> str
     |
     |  Create a new string object from the given object. If encoding or
     |  errors is specified, then the object must expose a data buffer
     |  that will be decoded using the given encoding and error handler.
     |  Otherwise, returns the result of object.__str__() (if defined)
     |  or repr(object).
     |  encoding defaults to sys.getdefaultencoding().
     |  errors defaults to 'strict'.
     |
     |  Methods defined here:
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __contains__(self, key, /)
     |      Return key in self.
     |
     |  __eq__(self, value, /)
     |      Return self==value.
     |
     |  __format__(self, format_spec, /)
     |      Return a formatted version of the string as described by format_spec.
     |
     |  __ge__(self, value, /)
     |      Return self>=value.
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __getitem__(self, key, /)
     |      Return self[key].
     |
     |  __getnewargs__(...)
     |
     |  __gt__(self, value, /)
     |      Return self>value.
     |
     |  __hash__(self, /)
     |      Return hash(self).
     |
     |  __iter__(self, /)
     |      Implement iter(self).
     |
     |  __le__(self, value, /)
     |      Return self<=value.
     |
     |  __len__(self, /)
     |      Return len(self).
     |
     |  __lt__(self, value, /)
     |      Return self<value.
     |
     |  __mod__(self, value, /)
     |      Return self%value.
     |
     |  __mul__(self, value, /)
     |      Return self*value.
     |
     |  __ne__(self, value, /)
     |      Return self!=value.
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __rmod__(self, value, /)
     |      Return value%self.
     |
     |  __rmul__(self, value, /)
     |      Return value*self.
     |
     |  __sizeof__(self, /)
     |      Return the size of the string in memory, in bytes.
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  capitalize(self, /)
     |      Return a capitalized version of the string.
     |
     |      More specifically, make the first character have upper case and the rest lower
     |      case.
     |
     |  casefold(self, /)
     |      Return a version of the string suitable for caseless comparisons.
     |
     |  center(self, width, fillchar=' ', /)
     |      Return a centered string of length width.
     |
     |      Padding is done using the specified fill character (default is a space).
     |
     |  count(...)
     |      S.count(sub[, start[, end]]) -> int
     |
     |      Return the number of non-overlapping occurrences of substring sub in
     |      string S[start:end].  Optional arguments start and end are
     |      interpreted as in slice notation.
     |
     |  encode(self, /, encoding='utf-8', errors='strict')
     |      Encode the string using the codec registered for encoding.
     |
     |      encoding
     |        The encoding in which to encode the string.
     |      errors
     |        The error handling scheme to use for encoding errors.
     |        The default is 'strict' meaning that encoding errors raise a
     |        UnicodeEncodeError.  Other possible values are 'ignore', 'replace' and
     |        'xmlcharrefreplace' as well as any other name registered with
     |        codecs.register_error that can handle UnicodeEncodeErrors.
     |
     |  endswith(...)
     |      S.endswith(suffix[, start[, end]]) -> bool
     |
     |      Return True if S ends with the specified suffix, False otherwise.
     |      With optional start, test S beginning at that position.
     |      With optional end, stop comparing S at that position.
     |      suffix can also be a tuple of strings to try.
     |
     |  expandtabs(self, /, tabsize=8)
     |      Return a copy where all tab characters are expanded using spaces.
     |
     |      If tabsize is not given, a tab size of 8 characters is assumed.
     |
     |  find(...)
     |      S.find(sub[, start[, end]]) -> int
     |
     |      Return the lowest index in S where substring sub is found,
     |      such that sub is contained within S[start:end].  Optional
     |      arguments start and end are interpreted as in slice notation.
     |
     |      Return -1 on failure.
     |
     |  format(...)
     |      S.format(*args, **kwargs) -> str
     |
     |      Return a formatted version of S, using substitutions from args and kwargs.
     |      The substitutions are identified by braces ('{' and '}').
     |
     |  format_map(...)
     |      S.format_map(mapping) -> str
     |
     |      Return a formatted version of S, using substitutions from mapping.
     |      The substitutions are identified by braces ('{' and '}').
     |
     |  index(...)
     |      S.index(sub[, start[, end]]) -> int
     |
     |      Return the lowest index in S where substring sub is found,
     |      such that sub is contained within S[start:end].  Optional
     |      arguments start and end are interpreted as in slice notation.
     |
     |      Raises ValueError when the substring is not found.
     |
     |  isalnum(self, /)
     |      Return True if the string is an alpha-numeric string, False otherwise.
     |
     |      A string is alpha-numeric if all characters in the string are alpha-numeric and
     |      there is at least one character in the string.
     |
     |  isalpha(self, /)
     |      Return True if the string is an alphabetic string, False otherwise.
     |
     |      A string is alphabetic if all characters in the string are alphabetic and there
     |      is at least one character in the string.
     |
     |  isascii(self, /)
     |      Return True if all characters in the string are ASCII, False otherwise.
     |
     |      ASCII characters have code points in the range U+0000-U+007F.
     |      Empty string is ASCII too.
     |
     |  isdecimal(self, /)
     |      Return True if the string is a decimal string, False otherwise.
     |
     |      A string is a decimal string if all characters in the string are decimal and
     |      there is at least one character in the string.
     |
     |  isdigit(self, /)
     |      Return True if the string is a digit string, False otherwise.
     |
     |      A string is a digit string if all characters in the string are digits and there
     |      is at least one character in the string.
     |
     |  isidentifier(self, /)
     |      Return True if the string is a valid Python identifier, False otherwise.
     |
     |      Use keyword.iskeyword() to test for reserved identifiers such as "def" and
     |      "class".
     |
     |  islower(self, /)
     |      Return True if the string is a lowercase string, False otherwise.
     |
     |      A string is lowercase if all cased characters in the string are lowercase and
     |      there is at least one cased character in the string.
     |
     |  isnumeric(self, /)
     |      Return True if the string is a numeric string, False otherwise.
     |
     |      A string is numeric if all characters in the string are numeric and there is at
     |      least one character in the string.
     |
     |  isprintable(self, /)
     |      Return True if the string is printable, False otherwise.
     |
     |      A string is printable if all of its characters are considered printable in
     |      repr() or if it is empty.
     |
     |  isspace(self, /)
     |      Return True if the string is a whitespace string, False otherwise.
     |
     |      A string is whitespace if all characters in the string are whitespace and there
     |      is at least one character in the string.
     |
     |  istitle(self, /)
     |      Return True if the string is a title-cased string, False otherwise.
     |
     |      In a title-cased string, upper- and title-case characters may only
     |      follow uncased characters and lowercase characters only cased ones.
     |
     |  isupper(self, /)
     |      Return True if the string is an uppercase string, False otherwise.
     |
     |      A string is uppercase if all cased characters in the string are uppercase and
     |      there is at least one cased character in the string.
     |
     |  join(self, iterable, /)
     |      Concatenate any number of strings.
     |
     |      The string whose method is called is inserted in between each given string.
     |      The result is returned as a new string.
     |
     |      Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'
     |
     |  ljust(self, width, fillchar=' ', /)
     |      Return a left-justified string of length width.
     |
     |      Padding is done using the specified fill character (default is a space).
     |
     |  lower(self, /)
     |      Return a copy of the string converted to lowercase.
     |
     |  lstrip(self, chars=None, /)
     |      Return a copy of the string with leading whitespace removed.
     |
     |      If chars is given and not None, remove characters in chars instead.
     |
     |  partition(self, sep, /)
     |      Partition the string into three parts using the given separator.
     |
     |      This will search for the separator in the string.  If the separator is found,
     |      returns a 3-tuple containing the part before the separator, the separator
     |      itself, and the part after it.
     |
     |      If the separator is not found, returns a 3-tuple containing the original string
     |      and two empty strings.
     |
     |  replace(self, old, new, count=-1, /)
     |      Return a copy with all occurrences of substring old replaced by new.
     |
     |        count
     |          Maximum number of occurrences to replace.
     |          -1 (the default value) means replace all occurrences.
     |
     |      If the optional argument count is given, only the first count occurrences are
     |      replaced.
     |
     |  rfind(...)
     |      S.rfind(sub[, start[, end]]) -> int
     |
     |      Return the highest index in S where substring sub is found,
     |      such that sub is contained within S[start:end].  Optional
     |      arguments start and end are interpreted as in slice notation.
     |
     |      Return -1 on failure.
     |
     |  rindex(...)
     |      S.rindex(sub[, start[, end]]) -> int
     |
     |      Return the highest index in S where substring sub is found,
     |      such that sub is contained within S[start:end].  Optional
     |      arguments start and end are interpreted as in slice notation.
     |
     |      Raises ValueError when the substring is not found.
     |
     |  rjust(self, width, fillchar=' ', /)
     |      Return a right-justified string of length width.
     |
     |      Padding is done using the specified fill character (default is a space).
     |
     |  rpartition(self, sep, /)
     |      Partition the string into three parts using the given separator.
     |
     |      This will search for the separator in the string, starting at the end. If
     |      the separator is found, returns a 3-tuple containing the part before the
     |      separator, the separator itself, and the part after it.
     |
     |      If the separator is not found, returns a 3-tuple containing two empty strings
     |      and the original string.
     |
     |  rsplit(self, /, sep=None, maxsplit=-1)
     |      Return a list of the words in the string, using sep as the delimiter string.
     |
     |        sep
     |          The delimiter according which to split the string.
     |          None (the default value) means split according to any whitespace,
     |          and discard empty strings from the result.
     |        maxsplit
     |          Maximum number of splits to do.
     |          -1 (the default value) means no limit.
     |
     |      Splits are done starting at the end of the string and working to the front.
     |
     |  rstrip(self, chars=None, /)
     |      Return a copy of the string with trailing whitespace removed.
     |
     |      If chars is given and not None, remove characters in chars instead.
     |
     |  split(self, /, sep=None, maxsplit=-1)
     |      Return a list of the words in the string, using sep as the delimiter string.
     |
     |      sep
     |        The delimiter according which to split the string.
     |        None (the default value) means split according to any whitespace,
     |        and discard empty strings from the result.
     |      maxsplit
     |        Maximum number of splits to do.
     |        -1 (the default value) means no limit.
     |
     |  splitlines(self, /, keepends=False)
     |      Return a list of the lines in the string, breaking at line boundaries.
     |
     |      Line breaks are not included in the resulting list unless keepends is given and
     |      true.
     |
     |  startswith(...)
     |      S.startswith(prefix[, start[, end]]) -> bool
     |
     |      Return True if S starts with the specified prefix, False otherwise.
     |      With optional start, test S beginning at that position.
     |      With optional end, stop comparing S at that position.
     |      prefix can also be a tuple of strings to try.
     |
     |  strip(self, chars=None, /)
     |      Return a copy of the string with leading and trailing whitespace removed.
     |
     |      If chars is given and not None, remove characters in chars instead.
     |
     |  swapcase(self, /)
     |      Convert uppercase characters to lowercase and lowercase characters to uppercase.
     |
     |  title(self, /)
     |      Return a version of the string where each word is titlecased.
     |
     |      More specifically, words start with uppercased characters and all remaining
     |      cased characters have lower case.
     |
     |  translate(self, table, /)
     |      Replace each character in the string using the given translation table.
     |
     |        table
     |          Translation table, which must be a mapping of Unicode ordinals to
     |          Unicode ordinals, strings, or None.
     |
     |      The table must implement lookup/indexing via __getitem__, for instance a
     |      dictionary or list.  If this operation raises LookupError, the character is
     |      left untouched.  Characters mapped to None are deleted.
     |
     |  upper(self, /)
     |      Return a copy of the string converted to uppercase.
     |
     |  zfill(self, width, /)
     |      Pad a numeric string with zeros on the left, to fill a field of the given width.
     |
     |      The string is never truncated.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs) from builtins.type
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  maketrans(x, y=None, z=None, /)
     |      Return a translation table usable for str.translate().
     |
     |      If there is only one argument, it must be a dictionary mapping Unicode
     |      ordinals (integers) or characters to Unicode ordinals, strings or None.
     |      Character keys will be then converted to ordinals.
     |      If there are two arguments, they must be strings of equal length, and
     |      in the resulting dictionary, each character in x will be mapped to the
     |      character at the same position in y. If there is a third argument, it
     |      must be a string, whose characters will be mapped to None in the result.

### Setul de caractere predefinit in limbajul Python¶

In limbajul Python, fiecarui caracter al unui obiect de tip `str` ii corespunde un cod numeric, numit cod UNICODE. Limbajul Python furnizeaza la dispozitia programatorului 2 functii predefinite, care pot fi utilizate pentru conversia caracterului utilizat in codul sau UNICODE si invers si anume functiile `ord()` si `chr()`:

- Sintaxa:

    ord('caracter')  # returneaza valoarea codului UNICODE, care corespunde caracterului furnizat functiei ca argument
                     # argumentul furnizat trebuie sa fie un obiect de tip `str`

- Sintaxa:

    chr(intreg)     # returneaza caracterul care corespunde codul UNICODE, furnizat functiei ca argument
                     # argumentul furnizat trebuie sa fie un obiect de tip `int`

In [18]:

    # Exemplul 15: returnarea unui cod unicode al unui caracter
    help(ord)

    Help on built-in function ord in module builtins:

    ord(c, /)
        Return the Unicode code point for a one-character string.

In [19]:

    ord('a')

Out[19]:

    97

In [20]:

    # Exemplul 16: returnarea unui caracter al unui cod unicode
    help(chr)

    Help on built-in function chr in module builtins:

    chr(i, /)
        Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff.

In [21]:

    chr(97)

Out[21]:

    'a'

### F - string-uri¶

F-string-urile (f = format), ofera o solutie pentru formatarea sirului de caractere prin inserarea unor variabile in continutului sirului de caractere respectiv.

- Sintaxa:

    f".... {variabila_1}..."

sau

    f'.... {variabila_1}...'

In [22]:

    # Exemplul 17: utilizarea f-string-urilor

    direction = 'right'
    speed = 60

    # crearea unei variabile de tip string cu ajutorul f-string-ului
    command = f'Turn {direction} at {speed} km/h'

    # afisare rezultat
    print(command)

    Turn right at 60 km/h

# 8. Conversia tipului datelor¶

Limbajul Python pune la dispozitia programatorului solutii pentru conversia tipului datelor, dintr-un tip predefinit in altul. Aceste solutii se bazeaza pe constructorul clasei spre care se doreste a se realiza conversia (conceptul de constructor al unei clase se va detalia in cadrul sesiunii in care se vor introduce conceptele specifice Programarii Orientate pe Obiecte). In programare, tehnica de conversia a unui obiect spre alt tip este referita sub termenul de casting.

- Sintaxa:

      int(obiect)      # realizeaza conversia obiectului spre tipul de date intreg (int)
      float(obiect)    # realizeaza conversia obiectului spre tipul de date real (float)
      complex(obiect)  # realizeaza conversia obiectului spre tipul de date complex (complex)
      str(obiect)      # realizeaza conversia obiectului spre tipul de date string (str)

In [23]:

    # Exemplul 18: conversia unui obiect spre tipul intreg

    x = 10.5

    # conversie
    y = int(x)

    # afisare rezultate
    print(x)
    print(y)

    10.5
    10

In [24]:

    # Exemplul 19: conversia unui obiect spre tipul real

    x = 5

    # conversie
    y = float(x)

    # afisare rezultate
    print(x)
    print(y)

    5
    5.0

In [25]:

    # Exemplul 20: conversia unui obiect spre tipul complex

    re = 10
    im = 20
    # conversie
    x = complex(re, im)

    # afisare rezultate
    print(x)

    (10+20j)

In [26]:

    # Exemplul 21: conversia unui obiect spre tipul string

    x = 100

    # conversie
    y = str(x)

    # afisare rezultate
    print(type(x), x)
    print(type(y), y)

    <class 'int'> 100
    <class 'str'> 100

# 9. Structuri de date predefinitie in limbajul Python¶

Limbajul Python frunzeaza o serie de structuri de date predefinite, care se mai numesc si containere, organizate sub forma unor colectii de elemente care pot fi de acelasi tip, sau de diferite tipuri. Limbajul Python furnizeaza urmatoarele tipuri de containere:

- liste (`list`), reprezinta colectii de date ordonate, al caror continut se poate modifica; listele permit in componenta lor elemente duplicate;
- tuple (`tuple`), reprezinta colectii de date ordonate, al caror continut nu se poate modifica; tuplele permit in componenta lor elemente duplicate;
- set (`set`), reprezinta colectii de date neordonate, al caror continut nu se poate modifica; set-urile nu permit in componenta lor elemente duplicate (elementele sunt unice);
- frozenset (`frozenset`), reprezinta colectii de date neordonate, al caror continut nu se poate modifica; set-urile nu permit in componenta lor elemente duplicate (elementele sunt unice);
- dictionare (`dict`), reprezinta colectii de date neordonate, al caror continut se poate modifica; dictionarele nu permit in componenta lor elemente duplicate.

Prin element ordonat se intelege un element care se poate identifica intr-o colectie de date printr-un index.

Deoarece toate aceste containere reprezinta clase, acestea furnizeaza progamatorului diferite metode, care pot fi aplicate variabilelor (obiectelor) de tipul respectiv. Metodele furnizate de catre fiecare clasa pot fi listate prin aplicarea functiei tab-completion denumirii clasei, urmata de operatorul punct.

In [27]:

    # Exemplul 22: afisarea listei cu metodele furnizate de clasa "list":
    help(list)

    Help on class list in module builtins:

    class list(object)
     |  list(iterable=(), /)
     |
     |  Built-in mutable sequence.
     |
     |  If no argument is given, the constructor creates a new empty list.
     |  The argument must be an iterable if specified.
     |
     |  Methods defined here:
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __contains__(self, key, /)
     |      Return key in self.
     |
     |  __delitem__(self, key, /)
     |      Delete self[key].
     |
     |  __eq__(self, value, /)
     |      Return self==value.
     |
     |  __ge__(self, value, /)
     |      Return self>=value.
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __getitem__(...)
     |      x.__getitem__(y) <==> x[y]
     |
     |  __gt__(self, value, /)
     |      Return self>value.
     |
     |  __iadd__(self, value, /)
     |      Implement self+=value.
     |
     |  __imul__(self, value, /)
     |      Implement self*=value.
     |
     |  __init__(self, /, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __iter__(self, /)
     |      Implement iter(self).
     |
     |  __le__(self, value, /)
     |      Return self<=value.
     |
     |  __len__(self, /)
     |      Return len(self).
     |
     |  __lt__(self, value, /)
     |      Return self<value.
     |
     |  __mul__(self, value, /)
     |      Return self*value.
     |
     |  __ne__(self, value, /)
     |      Return self!=value.
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __reversed__(self, /)
     |      Return a reverse iterator over the list.
     |
     |  __rmul__(self, value, /)
     |      Return value*self.
     |
     |  __setitem__(self, key, value, /)
     |      Set self[key] to value.
     |
     |  __sizeof__(self, /)
     |      Return the size of the list in memory, in bytes.
     |
     |  append(self, object, /)
     |      Append object to the end of the list.
     |
     |  clear(self, /)
     |      Remove all items from list.
     |
     |  copy(self, /)
     |      Return a shallow copy of the list.
     |
     |  count(self, value, /)
     |      Return number of occurrences of value.
     |
     |  extend(self, iterable, /)
     |      Extend list by appending elements from the iterable.
     |
     |  index(self, value, start=0, stop=9223372036854775807, /)
     |      Return first index of value.
     |
     |      Raises ValueError if the value is not present.
     |
     |  insert(self, index, object, /)
     |      Insert object before index.
     |
     |  pop(self, index=-1, /)
     |      Remove and return item at index (default last).
     |
     |      Raises IndexError if list is empty or index is out of range.
     |
     |  remove(self, value, /)
     |      Remove first occurrence of value.
     |
     |      Raises ValueError if the value is not present.
     |
     |  reverse(self, /)
     |      Reverse *IN PLACE*.
     |
     |  sort(self, /, *, key=None, reverse=False)
     |      Stable sort *IN PLACE*.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs) from builtins.type
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __hash__ = None

In [28]:

    # Exemplul 23: afisarea listei cu metodele furnizate de clasa "tuple":
    help(tuple)

    Help on class tuple in module builtins:

    class tuple(object)
     |  tuple(iterable=(), /)
     |
     |  Built-in immutable sequence.
     |
     |  If no argument is given, the constructor returns an empty tuple.
     |  If iterable is specified the tuple is initialized from iterable's items.
     |
     |  If the argument is a tuple, the return value is the same object.
     |
     |  Methods defined here:
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __contains__(self, key, /)
     |      Return key in self.
     |
     |  __eq__(self, value, /)
     |      Return self==value.
     |
     |  __ge__(self, value, /)
     |      Return self>=value.
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __getitem__(self, key, /)
     |      Return self[key].
     |
     |  __getnewargs__(self, /)
     |
     |  __gt__(self, value, /)
     |      Return self>value.
     |
     |  __hash__(self, /)
     |      Return hash(self).
     |
     |  __iter__(self, /)
     |      Implement iter(self).
     |
     |  __le__(self, value, /)
     |      Return self<=value.
     |
     |  __len__(self, /)
     |      Return len(self).
     |
     |  __lt__(self, value, /)
     |      Return self<value.
     |
     |  __mul__(self, value, /)
     |      Return self*value.
     |
     |  __ne__(self, value, /)
     |      Return self!=value.
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __rmul__(self, value, /)
     |      Return value*self.
     |
     |  count(self, value, /)
     |      Return number of occurrences of value.
     |
     |  index(self, value, start=0, stop=9223372036854775807, /)
     |      Return first index of value.
     |
     |      Raises ValueError if the value is not present.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs) from builtins.type
     |      Create and return a new object.  See help(type) for accurate signature.

In [29]:

    # Exemplul 24: afisarea listei cu metodele furnizate de clasa "set":
    help(set)

    Help on class set in module builtins:

    class set(object)
     |  set() -> new empty set object
     |  set(iterable) -> new set object
     |
     |  Build an unordered collection of unique elements.
     |
     |  Methods defined here:
     |
     |  __and__(self, value, /)
     |      Return self&value.
     |
     |  __contains__(...)
     |      x.__contains__(y) <==> y in x.
     |
     |  __eq__(self, value, /)
     |      Return self==value.
     |
     |  __ge__(self, value, /)
     |      Return self>=value.
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __gt__(self, value, /)
     |      Return self>value.
     |
     |  __iand__(self, value, /)
     |      Return self&=value.
     |
     |  __init__(self, /, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __ior__(self, value, /)
     |      Return self|=value.
     |
     |  __isub__(self, value, /)
     |      Return self-=value.
     |
     |  __iter__(self, /)
     |      Implement iter(self).
     |
     |  __ixor__(self, value, /)
     |      Return self^=value.
     |
     |  __le__(self, value, /)
     |      Return self<=value.
     |
     |  __len__(self, /)
     |      Return len(self).
     |
     |  __lt__(self, value, /)
     |      Return self<value.
     |
     |  __ne__(self, value, /)
     |      Return self!=value.
     |
     |  __or__(self, value, /)
     |      Return self|value.
     |
     |  __rand__(self, value, /)
     |      Return value&self.
     |
     |  __reduce__(...)
     |      Return state information for pickling.
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __ror__(self, value, /)
     |      Return value|self.
     |
     |  __rsub__(self, value, /)
     |      Return value-self.
     |
     |  __rxor__(self, value, /)
     |      Return value^self.
     |
     |  __sizeof__(...)
     |      S.__sizeof__() -> size of S in memory, in bytes
     |
     |  __sub__(self, value, /)
     |      Return self-value.
     |
     |  __xor__(self, value, /)
     |      Return self^value.
     |
     |  add(...)
     |      Add an element to a set.
     |
     |      This has no effect if the element is already present.
     |
     |  clear(...)
     |      Remove all elements from this set.
     |
     |  copy(...)
     |      Return a shallow copy of a set.
     |
     |  difference(...)
     |      Return the difference of two or more sets as a new set.
     |
     |      (i.e. all elements that are in this set but not the others.)
     |
     |  difference_update(...)
     |      Remove all elements of another set from this set.
     |
     |  discard(...)
     |      Remove an element from a set if it is a member.
     |
     |      If the element is not a member, do nothing.
     |
     |  intersection(...)
     |      Return the intersection of two sets as a new set.
     |
     |      (i.e. all elements that are in both sets.)
     |
     |  intersection_update(...)
     |      Update a set with the intersection of itself and another.
     |
     |  isdisjoint(...)
     |      Return True if two sets have a null intersection.
     |
     |  issubset(...)
     |      Report whether another set contains this set.
     |
     |  issuperset(...)
     |      Report whether this set contains another set.
     |
     |  pop(...)
     |      Remove and return an arbitrary set element.
     |      Raises KeyError if the set is empty.
     |
     |  remove(...)
     |      Remove an element from a set; it must be a member.
     |
     |      If the element is not a member, raise a KeyError.
     |
     |  symmetric_difference(...)
     |      Return the symmetric difference of two sets as a new set.
     |
     |      (i.e. all elements that are in exactly one of the sets.)
     |
     |  symmetric_difference_update(...)
     |      Update a set with the symmetric difference of itself and another.
     |
     |  union(...)
     |      Return the union of sets as a new set.
     |
     |      (i.e. all elements that are in either set.)
     |
     |  update(...)
     |      Update a set with the union of itself and others.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs) from builtins.type
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __hash__ = None

In [30]:

    # Exemplul 25: afisarea listei cu metodele furnizate de clasa "set":
    help(set)

    Help on class set in module builtins:

    class set(object)
     |  set() -> new empty set object
     |  set(iterable) -> new set object
     |
     |  Build an unordered collection of unique elements.
     |
     |  Methods defined here:
     |
     |  __and__(self, value, /)
     |      Return self&value.
     |
     |  __contains__(...)
     |      x.__contains__(y) <==> y in x.
     |
     |  __eq__(self, value, /)
     |      Return self==value.
     |
     |  __ge__(self, value, /)
     |      Return self>=value.
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __gt__(self, value, /)
     |      Return self>value.
     |
     |  __iand__(self, value, /)
     |      Return self&=value.
     |
     |  __init__(self, /, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __ior__(self, value, /)
     |      Return self|=value.
     |
     |  __isub__(self, value, /)
     |      Return self-=value.
     |
     |  __iter__(self, /)
     |      Implement iter(self).
     |
     |  __ixor__(self, value, /)
     |      Return self^=value.
     |
     |  __le__(self, value, /)
     |      Return self<=value.
     |
     |  __len__(self, /)
     |      Return len(self).
     |
     |  __lt__(self, value, /)
     |      Return self<value.
     |
     |  __ne__(self, value, /)
     |      Return self!=value.
     |
     |  __or__(self, value, /)
     |      Return self|value.
     |
     |  __rand__(self, value, /)
     |      Return value&self.
     |
     |  __reduce__(...)
     |      Return state information for pickling.
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __ror__(self, value, /)
     |      Return value|self.
     |
     |  __rsub__(self, value, /)
     |      Return value-self.
     |
     |  __rxor__(self, value, /)
     |      Return value^self.
     |
     |  __sizeof__(...)
     |      S.__sizeof__() -> size of S in memory, in bytes
     |
     |  __sub__(self, value, /)
     |      Return self-value.
     |
     |  __xor__(self, value, /)
     |      Return self^value.
     |
     |  add(...)
     |      Add an element to a set.
     |
     |      This has no effect if the element is already present.
     |
     |  clear(...)
     |      Remove all elements from this set.
     |
     |  copy(...)
     |      Return a shallow copy of a set.
     |
     |  difference(...)
     |      Return the difference of two or more sets as a new set.
     |
     |      (i.e. all elements that are in this set but not the others.)
     |
     |  difference_update(...)
     |      Remove all elements of another set from this set.
     |
     |  discard(...)
     |      Remove an element from a set if it is a member.
     |
     |      If the element is not a member, do nothing.
     |
     |  intersection(...)
     |      Return the intersection of two sets as a new set.
     |
     |      (i.e. all elements that are in both sets.)
     |
     |  intersection_update(...)
     |      Update a set with the intersection of itself and another.
     |
     |  isdisjoint(...)
     |      Return True if two sets have a null intersection.
     |
     |  issubset(...)
     |      Report whether another set contains this set.
     |
     |  issuperset(...)
     |      Report whether this set contains another set.
     |
     |  pop(...)
     |      Remove and return an arbitrary set element.
     |      Raises KeyError if the set is empty.
     |
     |  remove(...)
     |      Remove an element from a set; it must be a member.
     |
     |      If the element is not a member, raise a KeyError.
     |
     |  symmetric_difference(...)
     |      Return the symmetric difference of two sets as a new set.
     |
     |      (i.e. all elements that are in exactly one of the sets.)
     |
     |  symmetric_difference_update(...)
     |      Update a set with the symmetric difference of itself and another.
     |
     |  union(...)
     |      Return the union of sets as a new set.
     |
     |      (i.e. all elements that are in either set.)
     |
     |  update(...)
     |      Update a set with the union of itself and others.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs) from builtins.type
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __hash__ = None

In [31]:

    # Exemplul 26: afisarea listei cu metodele furnizate de clasa "dictionary":
    help(dict)

    Help on class dict in module builtins:

    class dict(object)
     |  dict() -> new empty dictionary
     |  dict(mapping) -> new dictionary initialized from a mapping object's
     |      (key, value) pairs
     |  dict(iterable) -> new dictionary initialized as if via:
     |      d = {}
     |      for k, v in iterable:
     |          d[k] = v
     |  dict(**kwargs) -> new dictionary initialized with the name=value pairs
     |      in the keyword argument list.  For example:  dict(one=1, two=2)
     |
     |  Methods defined here:
     |
     |  __contains__(self, key, /)
     |      True if the dictionary has the specified key, else False.
     |
     |  __delitem__(self, key, /)
     |      Delete self[key].
     |
     |  __eq__(self, value, /)
     |      Return self==value.
     |
     |  __ge__(self, value, /)
     |      Return self>=value.
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __getitem__(...)
     |      x.__getitem__(y) <==> x[y]
     |
     |  __gt__(self, value, /)
     |      Return self>value.
     |
     |  __init__(self, /, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __iter__(self, /)
     |      Implement iter(self).
     |
     |  __le__(self, value, /)
     |      Return self<=value.
     |
     |  __len__(self, /)
     |      Return len(self).
     |
     |  __lt__(self, value, /)
     |      Return self<value.
     |
     |  __ne__(self, value, /)
     |      Return self!=value.
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __setitem__(self, key, value, /)
     |      Set self[key] to value.
     |
     |  __sizeof__(...)
     |      D.__sizeof__() -> size of D in memory, in bytes
     |
     |  clear(...)
     |      D.clear() -> None.  Remove all items from D.
     |
     |  copy(...)
     |      D.copy() -> a shallow copy of D
     |
     |  get(self, key, default=None, /)
     |      Return the value for key if key is in the dictionary, else default.
     |
     |  items(...)
     |      D.items() -> a set-like object providing a view on D's items
     |
     |  keys(...)
     |      D.keys() -> a set-like object providing a view on D's keys
     |
     |  pop(...)
     |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
     |      If key is not found, d is returned if given, otherwise KeyError is raised
     |
     |  popitem(...)
     |      D.popitem() -> (k, v), remove and return some (key, value) pair as a
     |      2-tuple; but raise KeyError if D is empty.
     |
     |  setdefault(self, key, default=None, /)
     |      Insert key with a value of default if key is not in the dictionary.
     |
     |      Return the value for key if key is in the dictionary, else default.
     |
     |  update(...)
     |      D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
     |      If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
     |      If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
     |      In either case, this is followed by: for k in F:  D[k] = F[k]
     |
     |  values(...)
     |      D.values() -> an object providing a view on D's values
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  fromkeys(iterable, value=None, /) from builtins.type
     |      Create a new dictionary with keys from iterable and values set to value.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs) from builtins.type
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __hash__ = None