.. -*- rst -*-

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


El tipus :class:`str`
---------------------

- El text es representa en objectes de tipus (o classe)
  :py:class:`str`, `string o cadena
  <https://ca.wikipedia.org/wiki/Cadena_(inform%C3%A0tica)>`__

- Un objecte de tipus :class:`str` conté una :term:`seqüència` de `caràcters
  <https://ca.wikipedia.org/wiki/Car%C3%A0cter_(tipus_de_dada)>`__

- Python no té el tipus caràcter: un :term:`caràcter` és un *string*
  de longitud u


Valors literals
---------------
     
- :term:`Valor literal` de tipus :class:`str`

  >>> 'Hola!'
  'Hola!'
  >>> "Digues com estàs."
  'Digues com estàs.'
  >>> s = """I les teves
  amistats,
     com van?"""
  >>> s
  'I les teves\namistats,\n   com van?'
  >>> print(s)
  I les teves
  amistats,
     com van?

- Una :term:`seqüència d'escapament` permet representar un
  :term:`caràcter de control`, però també alguns caràcters imprimibles

  ====================== =================== ====================
  seqüència d'escapament significat          caràcter de control?
  ====================== =================== ====================
  \n                     salt de línia       Sí
  \t                     tabulador           Si
  \\ \\                  \\                  No
  \\\'                   \'                  No
  \\\"                   \"                  No
  ====================== =================== ====================

  Vegeu :ref:`escape-sequences` a :doc:`python:reference/index`


Accés a un caràcter
-------------------

- L\'*operador claudàtor* (``[]``) permet accedir a un únic caràcter
  d'un *string* mitjançant un índex

- L\':term:`índex` és l'expressió entre claudàtors i sempre comença
  per zero.

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


Concatenació i repetició
------------------------

- Concatenació: operador ``+``

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

- Repetició: operador ``*``   

  >>> a = "Bon dia!"
  >>> b = a*3
  >>> b
  Bon dia!Bon dia!Bon dia!
  >>> c = a + a + a
  >>> c
  Bon dia!Bon dia!Bon dia!
  >>> b == c
  True

- Exemples d'operacions il·legals.

  .. code-block:: python3

     'a' / 'b'
     'a' - 'b'
     'a' ** 3


Longitud
--------

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

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

- Els **índexs negatius** comencen a comptar des del final de
  l\'*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
--------

- 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'índex ``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'
   

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


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

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

- Comparacions en :term:`ordre alfabètic`

    >>> 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


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

- Un *string* no canvia mai.


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

- Vegeu :ref:`String Methods <python:string-methods>` a :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
......

- :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'
  

substituir
..........

- :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
   
   >>> nom = nom_b.strip()
   >>> nom
   'Joan del Riu'
   
   >>> adr = nom.replace(' ', '_') + '@' + domini
   >>> adr
   'Joan_del_Riu@exemple.com'
   
   
   >>> domini_b = " \n  exemple.com "
   >>> domini_b
   ' \n  exemple.com '
   >>> print(domini_b)
   <BLANKLINE> 
     exemple.com 
   
   >>> domini = domini_b.strip()
   >>> domini
   'exemple.com'


Classificar
...........

- :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`

  >>> 'ABC'.isuuper()
  True
  >>> 'AbC'.isupper()
  False


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?'
  

Formatació d\'*strings*
.......................

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

   >>> hora = 8
   >>> minuts = 30
   >>> 
   >>> '{}:{}'.format(hora, minuts)
   '8:30'


Exercicis
---------

- :doc:`fi:temes/strings/Correus_electrònics/index`

  .. +, llesques i find

- :doc:`fi:temes/strings/Censura/index`

  .. in i replace

- :doc:`fi:temes/strings/Paraules_Noves/index`

  .. isupper, islower, +

- :doc:`fi:temes/strings/Format_URL/index`

  .. count, isalpha, find, llesques, isdigit



- :doc:`fi:temes/strings/Traductor/index`

  .. in, +, replace

- :doc:`fi:examens/curs2022-2023/1/L1/G20/codi`

  .. llesques, +, replace

- :doc:`fi:examens/curs2022-2023/1/L1/G30/encripta`

  .. llesques, replace

- :doc:`fi:examens/curs2022-2023/1/L1/G60/aminoacids`

  .. in, replace, +