<jupyter_start><jupyter_text>DadesLes dades que utilitzen els programes es guarden dins la memòria principal i les identificam mitjançant elque anomenem com a **variables**. Com el nom indica, una variable pot canviar de contingut al llarg de l'execució d'unprograma.Tenen tres característiques que les defineixen completament: el seu nom, el seu tipus i el seu valor. NomÉs una combinació de caràcters, dígits i el signe de subratllat que permeten identificar una variable demanera única. Tot nom ha de començar per un caràcter.* **Exemples de noms vàlids**: x, y, pi, var2, var_2, preu_de_cost* **Exemples de noms invàlids**: 14_de_maig , 35a , +set, capitol 14És molt recomanable que les variables comencin amb minúscula. Hem de pensar que hi ha una sèrie de noms que `Python` utilitza com a part del llenguatge i per tant no són vàlidscom a nom de variable, ja que ens poden donar resultats inesperats. A continuació els podeu veure:Paraules clau en PythonFalsedefifraiseNonedelimportreturnTrueelifintryandelseiswhileasexceptlambdawithassertfinallynonlocalyieldbreakfornotclassfromorcontinueglobalpass   TipusEl tipus defineix la natura dels valors que pot tenir una variable. També limita les operacions que es poden fer ambelles.Els tipus de dades elementals són: caràcter, enter, real i booleà:**Caràcter** permet representar informació referent a caràcters simples i a seqüències de caràcters, es representenentre comes, ja siguin simples ' o dobles ". Al món de la programació coneixem una seqüència de caràcters amb el nom de_String_ (_str_). `Python` considera els caràcters com strings de longitud 1.- Exemples de caràcters: 'a', 'b', '\n'.- Exemples de _String_: '3', "llonguet", "Josep".**Enter** (*int*) permet representar valors numèrics tant positius com negatius.- Exemples d'enters: -33, 14, 28 o 8545445.**Real** (*float*): aquest tipus designa un nombre de coma flotant. Aquests valors s'especifiquen amb un puntdecimal. Opcionalment, es pot afegir el caràcter e o E seguit d’un enter positiu o negatiu per especificar la notaciócientífica.- Exemples de nombres reals: -1.2, 3.1416, -0.26989, 4. , 3e7 (3000000.0), 1.6e-4 (0.00016).**Complex**: valors numèrics en format complex. S'especifiquen com +j.- Exemples de nombres complexos: 2+3j, 33+0j.**Booleà**: valors lògics. Poden tenir únicament dos valors: veritat (*True*) o fals (*False*).El valor màxim i mínim que podem guardar en una variable de tipus enter o real no estan definits, com passa en altresllenguatges, depenen de la màquina on executam el codi.  Declaracions de variablesDurant el transcurs del programa, el programador ha d'especificar cada una de les variables que necessitarà.L'especificació d'aquestes variables s'anomena una declaració. Normalment, aquestes declaracions es fan a l'inici del programa. Com a mínim, s'ha de definir el nom i s’ha d’assignar un valor inicial. Si no es vol (o no es pot) assignar un valor, a `Python` tenim el valor nul: **None**.A continuació teniu la primera mostra de codi, declaram una variable de cada un dels diferents tipus de dades que hemdescrit en la secció anterior:<jupyter_code>caracter = 'a'
estring = "<NAME>"
enter =  123
decimal = 1.23
complexe = 1+23j
logic = False


#Aquest codi ara no es rellevant per a nosaltres.
print(type(caracter))
print(type(estring))
print(type(enter))
print(type(decimal))
print(type(complexe))
print(type(logic))<jupyter_output><class 'str'>
<class 'str'>
<class 'int'>
<class 'float'>
<class 'complex'>
<class 'bool'><jupyter_text>Operadors i operandsA `Python`, els **operadors** són símbols especials que indiquen que cal fer algun tipus de computació. Els valorsamb els quals actua un operador s'anomenen **operands**.Ho entendrem amb un petit exemple:```x = 10.0y = 5resultat = x + y```En aquest cas, l'operador **+** ens permet sumar els operands `x` i `y` junts i guardar el resultat en la variabledel mateix nom. Hem de destacar que en aquest codi hem necessitat definir tres variables diferents.Un operand pot ser una variable o un literal. Definim els **literals** en un programa com la idea d’expressar unvalor que no canvia en el codi font, aquests son d'un dels diferents tipus de dades que hem descritanteriorment.A continuació tenim un altre fragment de codi en el qual usam altres operadors i literals de tipus enter:```a = 10b = 20x = 45r = (a + b - 5) + (x + 10 + 20)``` Una seqüència d'operands i operadors, com a + b - 5, s'anomena **expressió**. `Python` admet molts operadorsdiferents per combinar operands de diferents tipus, això ens permetrà crear expressions diferents persolventar els diferents problemes que sen's presentin.  Operadors aritmèticsLa taula següent llista els operadors aritmètics compatibles amb Python:OperadorExempleDefinicióResultat+&nbsp;(unari)+aUnari Positiua Realment no fa res. Existeix per complementar la negació unària.+&nbsp;(binari)a + bSumaSuma a i b-&nbsp;(unari)-aNegació unària El mateix valor que a però amb el signe oposat-&nbsp;(binari)a - bRestaResultat de restar b  a l'operand a * a * bMultiplicacióProducte de  a i b/a / bDivisióQuocient de a dividit per b. El resultat sempré és del tipus float float.%a % bMòdulReste de a dividit per  b//a // bDivisió sencera Quocient de dividir a entre b, arrodonit al següent número sencer més petit **a ** bExponenta elevat a  bAquí teniu alguns exemples del seu ús:<jupyter_code>divisio_decimal = 3 / 2
print(divisio_decimal)
divisio_sencera = 3 // 2
divisio_sencera<jupyter_output><empty_output><jupyter_text>Operadors de comparacióEls operadors de comparació s’utilitzen normalment en contextos _booleans_ com els que ens serveixen per controlar elflux del programa, com veurem més endavant. El resultat d'usar un operador de comparació sempre és del tipus _booleà_.OperadorExempleDefinicióResultat==a == bIgualTrue si el valor de  a és igual al valor de bFalse en cas contrari!=a != bDiferentTrue si el valor de a és diferent a bFalse en cas contrari&lt;a &lt; bMenorTrue si el valor de a és menor a b False en cas contrari&lt;=a &lt;= bMenor o igual a True si el valor de aés menor o igual a bFalse en cas contrari&gt;a &gt; bMajorTrue si el valor de a és major a bFalse en cas contrari&gt;=a &gt;= bMajor o igual aTrue si el valor de a iés major o igual a bFalse en cas contrari```{admonition} CuriositatEl valor emmagatzemat internament per a una variable en coma flotant pot no ser el que un pensaria que seria. Peraquest motiu, és poc pràctic comparar variables del tipus coma flotant amb l'operador d'igualtat exacta  `==`.```Aquí teniu alguns exemples del seu ús:<jupyter_code>x = 5.3
y = 5.5
comparacio_1 = x < y
comparacio_1
lletra_a = 'a'
lletra_b = 'b'

comparacio_2 = lletra_a != lletra_b
comparacio_2
lletra_a = 'a'
lletra_b = 'b'

comparacio_3 = lletra_a > lletra_b
comparacio_3<jupyter_output><empty_output><jupyter_text>Operadors lògicsEls operadors lògics _not_, *or* i _and_ modifiquen i uneixen expressions avaluades en un context booleà i enspermeten crear condicions més complexes.**Expressions lògiques que inclouen operands booleans**Com heu vist, algunes expressions de `Python` són, en realitat, de tipus booleà. És a dir, són iguals a un delsvalors `Python` `True` or `False`.Per exemple: A continuació teniu la taula d'operadors:OperadorExempleSignificatnotnot xTrue si x és FalseFalse si x és Trueorx or yTrue si x ò y és  TrueFalse en cas contrariandx and yTrue si x i  y són TrueFalse en cas contrari Per veure el seu ús, però sobretot el resultat de l'aplicació d'aquests operadors en variables del tipus booleà, acontinuació teniu un conjunt d'exemples de la seva aplicació:<jupyter_code>vertader = True
fals = False
operador_not = not vertader
operador_not
operador_or = vertader or fals
operador_or

operador_or = fals or fals
operador_or
operador_and = vertader and fals
operador_and
operador_and = vertader and vertader
operador_and<jupyter_output><empty_output><jupyter_text>Operadors d'assignació augmentadaAbans hem vist que un signe igual (=) s'utilitza per assignar un valor a una variable.És, per descomptat, perfectament viable que el valor de la dreta de l'assignació sigui una expressió que continguialtres variables. Si feim l'operació sobre una mateixa variable podem fer el següent:`x = y`  és el mateix que fer  ` x = x  y`Es a dir:```x = 4y = 5x += y```És el mateix que fer:```x = x + y```  Comentaris en el codiEn el món de la programació, un comentari és una explicació o anotació llegible pel programador en el codi font d’unprograma d’ordinador. S'escriuen amb el propòsit de facilitar la comprensió del codi font per a futures lectures delmateix programador o per altres programadors, són ignorats pels intèrprets.Moltes vegades també usarem els comentaris per prevenir l'execució d'una part del codi quan volem avaluar elfuncionament del nostre propi codi.A ```Python``` els comentaris s'expressen amb el símbol ``````.  A continuació en veurem dos exemples del seu ús:``` Això és un comentari que m'ajuda a explicar el bloc de codix = y +3  Aquí també puc posar un comentari per descriure l'expressió```Es recomanable comentar el codi que realitzam, en particular aquelles parts més rellevants o que presentencerta dificultat.<jupyter_code># COMENTARI
variable = 45
resultat = variable + 33
print(resultat)<jupyter_output>78<jupyter_text>Entrada / Sortida d'informacióUn programa necesita poder rebre i mostrar informació de l'/ al usuari. EntradaPer poder proporcionar informació al programa, podem usar la funció `input`, sempre ens tornarà l'string corresponent ala informació que l'usuari ens proporciona.```entrada = input()entrada``` Si volem llegir un sencer o un float haurem de realitzar una transformació explícita (*casting*)```enter = int(input("Escriu un enter: "))enterprint(type(enter))print(enter)``````decimal = float(input("Escriu un decimal: "))decimalprint(type(decimal))``` Si volem llegir un únic caràcter, ho podem fer de la següent manera:```import syscar = sys.stdin.read(1)print(car)```  SortidaPer poder mostar informació per pantalla, farem servir la funció `print`. Aquesta funció pot mostrar qualsevol text(*string*) separat entre comes.A continuació teniu diversos exemples:<jupyter_code>print("Hola mon!")


print("Aixo es un text" + " el qual concatenam amb un altre text")

a = 'a' + " " + 'b'

print("També ho podem fer així " + a)

num = 3

print("Text concatenat amb un nombre " + str(num))

print('Si vull posar cometes dobles en el text (") puc delimitar el string amb cometes simples')
print("En Biel es un 'bon' professor")<jupyter_output>Hola mon!
Aixo es un text el qual concatenam amb un altre text
També ho podem fer així a b
Text concatenat amb un nombre 3
Si vull posar cometes dobles en el text (") puc delimitar el string amb cometes simples
En Biel es un 'bon' professor
{'fraction_non_alphanumeric': 0.0724907063197026, 'fraction_numerical': 0.010408921933085501, 'mean_word_length': 5.311436950146628, 'pattern_counts': {'":': 0, '<': 30, '<?xml version=': 0, '>': 30, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '6', 'dir': 'jupyter-structured-clean-dedup', 'id': '161218', 'license': 'MIT', 'n_tokens_mistral': 3783, 'n_tokens_neox': 3746, 'n_words': 1478, 'path': 'programacioi/chapters/Tema2/Tema2.ipynb', 'repo_name': 'bmalcover/material_programacio', 'size': '10762'}