.. -*- rst -*-

=======
Strings
=======


Un tipus de dades compost
-------------------------

- Anomenarem *string* a tot objecte de tipus (o classe)
  :py:class:`str`.

- Un *string* està compost de caràcters.

- Un **tipus de dades compost** està compost d'objectes de tipus més
  simples.

- L'**operador claudàtor** [] selecciona un únic caràcter d'un
  *string*.

- L'expressió entre claudàtors s'anomena **índex**.

- Indexats a partir de zero.

    >>> adr = "joan@exemple.com"
    >>> type(adr)
    <class 'str'>
    >>> adr[0]
    'j'
    >>> adr[4]
    '@'
   

Longitud
--------

- La funció ``len`` retorna el nombre de caràcters d'un *string*.

- Els darrer element d'un *string* ocupa l'índex longitud menys u.

- Els **índexos negatius** comencen a comptar des del final del
  *string*.

    >>> adr = "joan@exemple.com"
    >>> la = len(adr)
    >>> la
    16
    >>> adr[la - 1]
    'm'
    >>> adr[-1]
    'm'

- String buit o nul.

  >>> s = ''
  >>> type(s)
  <class 'str'>
  >>> s
  ''
  >>> len(s)
  0


Llesques d’string
-----------------

- L'operador llesca ``string[n:m]`` obté el *substring* que comença en
  el caràcter d'index ``n`` inclòs i acaba en el d'índex ``m`` exclòs.

- ``n`` es pot ometre: comença en el primer caràcter

- ``m`` es pot ometre: va fins al darrer caràcter

- Si s'ometen tots dos: tot l'*string*.

- Llesques esteses: ``string[n:m:p]`` obté el *substring* que comença
  en el caràcter d'index ``n`` inclòs i acaba en el d'índex ``m``
  exclòs amb pas ``p``.

    >>> adr = "joan@exemple.com"

    >>> nom = adr[0:4]
    >>> nom
    'joan'
    >>> domini = adr[5:16]
    >>> domini
    'exemple.com'

    >>> nom = adr[:4]
    >>> nom
    'joan'
    >>> domini = adr[5:]
    >>> domini
    'exemple.com'

    >>> pd = adr[5:12]
    >>> pd
    'exemple'


Comparació d’strings
--------------------

- Operadors: ``==``, ``!=``, ``<``, ``>``, ``<=``, ``>=``.

- `Ordre lexicogràfic <http://en.wikipedia.org/wiki/Lexicographic_order>`_.

    >>> x, y = 'hipopòtam', 'hipotàlem'

    >>> x == y
    False
    >>> x != y
    True
    >>> x < y
    True
    >>> x > y
    False

    >>> 'a' == 'A'
    False
    >>> 'a' < 'A'
    False
    >>> 'a' != 'à'
    True
    >>> 'a' > 'à'
    False

    >>> '8' < '10'
    False
    >>> '08' < '10'
    True
   

L’operador in
-------------

- ``a in b``: pertany ``a`` a l'*string* ``b``?

- ``a not in b``: ``a`` no pertany a l'*string* ``b``?

    >>> adr = "joan@exemple.com"

    >>> '@' in adr
    True
    >>> ' ' not in adr
    True
    >>> not (' ' in adr)
    True

    >>> adr_val = '@' in adr and '.' in adr and ' ' not in adr
    >>> adr_val
    True


Concatenació d'strings
----------------------

- Operador ``+``.

    >>> nom = "joan"
    >>> domini = "exemple.com"
    >>> adr = nom + '@' + domini
    >>> adr
    'joan@exemple.com'


Els strings són immutables
--------------------------

- Un *string* no canvia mai.


Mètodes d'strings
-----------------

- Vegeu l'apartat :ref:`String Methods <python:string-methods>` de :ref:`The Python Standard Library <python:library-index>`.

- A la pràctica, un mètode es comporta com una funció, però amb una
  sintaxi de crida diferent:

    >>> 'maryland'.capitalize()
    'Maryland'
    >>> "what's all this, then, amen?".title()
    "What'S All This, Then, Amen?"
    >>> 'How to Center Text Using Python'.center(70)
    '                   How to Center Text Using Python                    '
    >>> 'angola'.upper()
    'ANGOLA'

- Els mètodes d’*string* formen part dels objectes *string*, i
  s’**invoquen** (es criden) aplicant l’**operador punt (.)** després
  de l’objecte seguit pel nom del mètode.


Comptar
.......

- :py:meth:`~str.count`

    >>> adr = "joan@exemple.com"
    >>> adr_val = adr.count('@') == 1 and '.' in adr and ' ' not in adr
    >>> adr_val
    True
      
  
Cercar i substituir
...................

- :py:meth:`~str.find`
- :py:meth:`~str.index`

    >>> adr = "joan@exemple.com"

    >>> iarroba = adr.find('@')
    >>> iarroba
    4
    >>> ipunt = adr.find('.')
    >>> ipunt
    12

    >>> nom = adr[:iarroba]
    >>> nom
    'joan'

    >>> domini = adr[iarroba+1:]
    >>> domini
    'exemple.com'

    >>> pd = adr[iarroba+1:ipunt]
    >>> pd
    'exemple'
  

- :py:meth:`~str.replace`

    >>> nom = "Joan del Riu"
    >>> domini = "exemple.com"

    >>> adr = nom.replace(' ', '_') + '@' + domini
    >>> adr
    'Joan_del_Riu@exemple.com'
  

- :py:meth:`~str.strip`.

>>> nom_b = " \t Joan del Riu\n"
>>> nom_b
' \t Joan del Riu\n'
>>> print(nom_b)
 	 Joan del Riu

>>> domini_b = " \n  exemple.com "
>>> domini_b
' \n  exemple.com '
>>> print(domini_b)
 
  exemple.com 

>>> nom = nom_b.strip()
>>> nom
'Joan del Riu'

>>> domini = domini_b.strip()
>>> domini
'exemple.com'

>>> adr = nom.replace(' ', '_') + '@' + domini
>>> adr
'Joan_del_Riu@exemple.com'


Classificació de caràcters
..........................

- :py:meth:`~str.isalnum`
- :py:meth:`~str.isalpha`
- :py:meth:`~str.isdecimal`
- :py:meth:`~str.isdigit`
- :py:meth:`~str.islower`
- :py:meth:`~str.isnumeric`
- :py:meth:`~str.isprintable`

    >>> ' '.isprintable()
    True
    >>> '\t'.isprintable()
    False
    >>> '\n'.isprintable()
    False

  

- :py:meth:`~str.isspace`

    >>> ' \t\n'.isspace()
    True
  
- :py:meth:`~str.isupper`


Majúscules i minúscules
.......................

- :py:meth:`~str.upper`

    >>> 'abC 3'.upper()
    'ABC 3'

- :py:meth:`~str.lower`

    >>> 'abC 3'.lower()
    'abc 3'
  
- :py:meth:`~str.capitalize`

    >>> 'alguna paraula més?'.capitalize()
    'Alguna paraula més?'
  

Formatat de strings
...................

- Mètode :py:meth:`~str.format`.

>>> hora = 8
>>> minuts = 30
>>> 
>>> '{}:{}'.format(hora, minuts)
'8:30'
  
- Operador ``%`` (:ref:`desaconsellat <python:old-string-formatting>`).


..
   Recorreguts i el bucle for
   --------------------------
   
   - Recorregut d'un *string*: escriure els caràcters un per un.
   
   - Sentència ``for``::
   
       for varible in string:
           cos
   
   - ``variable`` es refereix successivament a cada un dels caràcters de
     l'*string* en ordre creixent d'índex.
   
   L’operador in
   -------------
   
   - ``a in b``: pertany ``a`` a l'*string* ``b``?
   
   - Exemple: esborrar les vocals d'un *string*:
   
     .. sourcecode:: python
   
       def remove_vowels(s):
           vowels = "aeiouAEIOU"
           s_without_vowels = ""
           for letter in s:
               if letter not in vowels:
                   s_without_vowels += letter
           return s_without_vowels
   
   
   Una funció find
   ---------------
   
   - Esquema de cerca:
   
     .. sourcecode:: python
   
       def find(strng, ch):
           index = 0
           while index < len(strng):
               if strng[index] == ch:
                   return index
               index += 1
           return -1
   
   
   Bucles i comptatge
   ------------------
   
   - Patró comptador:
   
     .. sourcecode:: python
   
       fruit = "banana"
       count = 0
       for char in fruit:
           if char == 'a':
               count += 1
       print(count)
   
   
   Paràmetres opcionals
   --------------------
   
   - Generalitzar ``find`` amb un paràmetre addicional.
   
   - Paràmetres opcionals i valors per omissió.