<jupyter_start><jupyter_text>`str` - Karaktere kateak * `str` motako objektuak * Karaktere sekuentzia **ALDAEZINA**. * Propietateak: Indexagarriak, Iteragarriak, Aldaezinak  IndexagarritasunaKontatu zenbatetan agertzen den letra bat hitz baten barnean.<jupyter_code>def kontatzen(hitza,letra):
    k = 0
    i = 0
    while i < len(hitza) :
        if hitza[i] == letra :
            k += 1
        i += 1
    return k

print(kontatzen('amara','a'))
def kontatzen(hitza,letra):
    k = 0
    for i in range(len(hitza)) :
        if hitza[i] == letra :
            k += 1
    return k

print(kontatzen('amara','a'))<jupyter_output>3<jupyter_text>IteragarritasunaKontatu zenbatetan agertzen den letra bat hitz baten barnean.<jupyter_code>def kontatzen(hitza,letra):
    k = 0
    for x in hitza :
        if x == letra :
            k += 1
    return k

print(kontatzen('amara','am'))

def kontatzen(hitza,letra):
    return hitza.count(letra)

print(kontatzen('amara','am'))<jupyter_output>0
1<jupyter_text>Eragileak: `+` , `*` , `in` , `not in`__Ariketa:__ Zenbaki oso bat era bitarrean adierazi karaktere kate baten bidez.<jupyter_code>def bitarrera(n):
    s = ''
    while n > 0 :
        s = str(n%2) + s
        n //= 2
    return s

print(bitarrera(25))
print(bitarrera(1423462))<jupyter_output>11001
101011011100001100110<jupyter_text>__Ariketa:__ Zenbaki oso bat edozein oinarritan adierazi karaktere kate baten bidez.<jupyter_code>def oinarrira(n,oin=10):
    s = ''
    while n > 0 :
        s = str(n%oin) + s
        n //= oin
    return s

for o in range(2,11) :
    print(15,o,'oinarrian:',oinarrira(15,o))

print(oinarrira(15,16),"\n\n")<jupyter_output>15 2 oinarrian: 1111
15 3 oinarrian: 120
15 4 oinarrian: 33
15 5 oinarrian: 30
15 6 oinarrian: 23
15 7 oinarrian: 21
15 8 oinarrian: 17
15 9 oinarrian: 16
15 10 oinarrian: 15
15<jupyter_text>__Ariketa:__ 10 Oinarritik gora joan nahi badugu, `[0-9]` gainetik digitu berriak behar ditugu. Adibidez, letrak erabili ditzakegu: `A, B, C...`<jupyter_code>def num2str(n):
    n2s = '0123456789ABCDEF'
    if n < 16 :
        return n2s[n]
    raise ValueError('Unsupported value: ' + str(n))

def oinarrira(n,oin):
    s = ''
    while n > 0 :
        s = num2str(n%oin) + s
        n //= oin
    return s

for o in range(2,17) :
    print(15,o,'oinarrian:',oinarrira(15,o))

#print(oinarrira(16,17))<jupyter_output>15 2 oinarrian: 1111
15 3 oinarrian: 120
15 4 oinarrian: 33
15 5 oinarrian: 30
15 6 oinarrian: 23
15 7 oinarrian: 21
15 8 oinarrian: 17
15 9 oinarrian: 16
15 10 oinarrian: 15
15 11 oinarrian: 14
15 12 oinarrian: 13
15 13 oinarrian: 12
15 14 oinarrian: 11
15 15 oinarrian: 10
15 16 oinarrian: F<jupyter_text>__Ariketa:__ Kate bat pantailatik inprimatu, aurretik behar aina hutsune utziz edo haserako karaktereak ezabatuz, idatzitako testuaren luzera 40 izan dadin. Hau da, testua beti eskuinera lerrokatua agertuko da.<jupyter_code>def idatzi_eskuinean(s, zabalera=40):
    n = (zabalera - len(s))
    if n > 0 :
        s = n * ' ' + s
    else :
        s = s[-zabalera:]
    print(s)
    
idatzi_eskuinean('kaixo')
idatzi_eskuinean('ea nola ateratzen den')
idatzi_eskuinean('Orain beste',30)
idatzi_eskuinean('zabalera',25)
idatzi_eskuinean('batekin',25)
idatzi_eskuinean('hau luzeegia denez ezingo da osorik agertu',25)<jupyter_output>kaixo
                   ea nola ateratzen den
                   Orain beste
                 zabalera
                  batekin
z ezingo da osorik agertu<jupyter_text>__Ariketa:__ Idatzi funtzio bat, `True` bueltatzen duena emandako hitzak `a` letrarik ez duenean eta `False` kontrako kasuan.<jupyter_code>def a_rik_ez(hitza):
    for k in hitza :
        if k == 'a' :
            return False
    return True

print(a_rik_ez('ondoloin'))
print(a_rik_ez('kaixo'))<jupyter_output>True
False<jupyter_text>`in` eragilea erabiliz, funtzioa erreztu dezakegu:<jupyter_code>def a_rik_ez(hitza):
    if 'a' in hitza :
        return False
    else :
        return True

print(a_rik_ez('ondoloin'))
print(a_rik_ez('kaixo'))<jupyter_output>True
False<jupyter_text>Ondoko egitura:```pythonif xxx :    return Trueelse :    return False```beste modu hontan adieraz daiteke (ez da berdina, baina bai baliokidea):```pythonreturn xxx```Guztiz baliokidea litzateke:```pythonreturn bool(xxx)```Era berean,```pythonif xxx :    return Falseelse :    return True```idatzi ordez (hau guztiz berdina da):```pythonreturn not xxx``` * `0` (edo `0.0`) ez diren zenbakizko balio guztiak egiak dira.* Hutsik ez dauden sekuentzia guztiak egiak dira.<jupyter_code>for x in [0,1,0.0,1.0,1e-30,"kaixo","",[1,2,3],[],range(10),range(0)] :
    if x :
        print("Egia:",x,bool(x))
    else :
        print("Gezurra:",x,bool(x))<jupyter_output>Gezurra: 0 False
Egia: 1 True
Gezurra: 0.0 False
Egia: 1.0 True
Egia: 1e-30 True
Egia: kaixo True
Gezurra:  False
Egia: [1, 2, 3] True
Gezurra: [] False
Egia: range(0, 10) True
Gezurra: range(0, 0) False<jupyter_text>Ariketara bueltatuz:<jupyter_code>def a_rik_ez(hitza):
    return not ('a' in hitza)

print(a_rik_ez('ondoloin'))
print(a_rik_ez('kaixo'))


def a_rik_ez(hitza):
    return 'a' not in hitza

print(a_rik_ez('ondoloin'))
print(a_rik_ez('kaixo'))<jupyter_output>True
False
True
False<jupyter_text>Formatudun karaktere kateakDemagun bi aldagai ditugula, `a` eta `b`, Ane eta Xabiren adinekin, eta ondoko karaktere katea osatu nahi dugula:`Anek ... urte ditu eta Xabik ...`Karaktere kate baten barnean datuak txertatu naghi ditugunean, aukera ezberdinak ditugu.  _Eskuz_ eratutako formatudun karaktere katea<jupyter_code>a = 23
b = 25
print("Anek " + str(a) + " urte ditu eta Xabik " + str(b))<jupyter_output>Anek 23 urte ditu eta Xabik 25<jupyter_text>Metodo honek desabantaila asko ditu.   * Sortzen den karaktere katearen egitura ez da oso argia.   * Edozein datu txertatzeko `str(...)` erabili behar dugu.   * Kontu handia eduki behar dugu sortu nahi ditugun hutsuneekin.  `%` eragilea: _C-style string formatting_   * `%` eragilearen ezkerraldean karaktere kate bat dagoenean, eskuinaldean txertatuko ditugun balioen tupla bat jar dezakegu.   * Karaktere katearen barnean `%` agertzen den lekuetan, balioak txertatuko dira.   * Balioak txertatzean formatua adieraziko dugu:      * `%d` &rarr; zenbaki osoa      * `%e` `%f` `%g` &rarr; zenbaki erreala (notazio zientifikoa, dezimala eta nahasia)      * `%s` &rarr; karaktere katea      * ...<jupyter_code>a = 23
b = 25
print("Anek %d urte ditu eta Xabik %d" % (a,b))<jupyter_output>Anek 23 urte ditu eta Xabik 25<jupyter_text>Metodo honek abantailak ditu aurrekoarekin konparatuz.   * Sortzen den karaktere katearen egitura nahiko argia da.   * Sintaxia sinpleagoa da (batez ere C lengoaiatik datozenentzat!).  `str.format()` bidezko formatua   * `%` eragilearen hobekuntza bat da   * `s.format(...)` metodoko argumentuak `s` karaktere katean txertatuko dira   * Karaktere katearen barnean `{}` agertzen den lekuetan, balioak txertatuko dira.<jupyter_code>a = 23
b = 25
print("Anek {} urte ditu eta Xabik {}".format(a,b))<jupyter_output>Anek 23 urte ditu eta Xabik 25<jupyter_text>Gauza berdina badirudi ere, `str.format(...)` metodoa `%` eragilea baina askosaz erabilgarriagoa da.    * `{n}`-k Argumentu indizea adierazten du. Posizioz alda daiteke, ala nahi adina aldiz erabili.<jupyter_code>print("Anek {0} urte ditu eta Xabik {1}".format(a,b))
print("Xabik {1} urte ditu eta Anek {0}".format(a,b))
print("Xabik {1} urte ditu, Anek {0} eta Xabik {1}".format(a,b))<jupyter_output>Anek 23 urte ditu eta Xabik 25
Xabik 25 urte ditu eta Anek 23
Xabik 25 urte ditu, Anek 23 eta Xabik 25<jupyter_text>* `*s` espresioak `s` sekuentziarten espantsioa adierazten du eta oso erabilkorra da sekuentzia baten elementuak metodo baten argumentu bilakatzeko.<jupyter_code>z = [234,938,262,232,432,2]
print('lehenengo hiru elementuak {0}, {1} eta {2} dira'.format(*z))<jupyter_output>lehenengo hiru elementuak 234, 938 eta 262 dira<jupyter_text>__OHARRA:__ `*s` espresioak ez du zerikusirik `format` metodoarekin, beste edozein lekutan erabil daiteke.     * `{keyword}`-k _keyword_ argumentu bat adierazten du. Hau da, izenaren bidez adierazitako argumentua.<jupyter_code>print("Anek {ane} urte ditu eta Xabik {xabi}".format(ane=23, xabi=25))<jupyter_output>Anek 23 urte ditu eta Xabik 25<jupyter_text>* `**d` espresioak `d` hiztegiaren espantsioa adierazten du eta oso erabilkorra da hiztegi batetako sarrerak metodo baten _keyword_ argumentu bilakatzeko.<jupyter_code>h = {'ane':23, 'xabi':25}
print("Anek {ane} urte ditu eta Xabik {xabi}".format(**h))<jupyter_output><empty_output><jupyter_text>__OHARRA:__ `**d` espresioak ez du zerikusirik `format` metodoarekin, beste edozein lekutan erabil daiteke.   _f-Strings_ edo _formatted string literals_   * `format` metodoa baina malguagoa da   * `f` letra aurretik daramaten karaktere kate literala: `f'....'`   * `format(...)` metodoak txertatzeko balioak argumentoetatik lortzen dituen moduan, _f-String_ -ak exekuzio ingurunetik lortzen ditu zuzenean<jupyter_code>a = 23
b = 25
print(f"Anek {a} urte ditu eta Xabik {b}")<jupyter_output>Anek 23 urte ditu eta Xabik 25<jupyter_text>* `{..}` barnean dagoen espresioa ebaluatu egiten da<jupyter_code>print(f'3 * 4 = {3*4}')
print(f'3 ** 4 = {3**4}')
print(f'sum(range(1,501)) = {sum(range(1,501))}')
filma='hodeiak pintatzeko makina'
print(f'Pelikularen izenburua "{filma.title()}" zen')<jupyter_output>3 * 4 = 12
3 ** 4 = 81
sum(range(1,501)) = 125250
Pelikularen izenburua "Hodeiak Pintatzeko Makina" zen<jupyter_text>* Lerro anitzetako _f-String_ -ak ere sortu daitezke, `f''' ... '''` erabiliz<jupyter_code>txt = f'''
1x1 = {1*1}
2x2 = {2*2}
3x3 = {3*3}
4x4 = {4*4}
...
'''

print(txt)<jupyter_output>1x1 = 1
2x2 = 4
3x3 = 9
4x4 = 16
...<jupyter_text>*Slice* notazioaObjetu indexagarrietan elementu bat baina gehiago adierazteko aukera* `a[i:j]` : `a`-ko azpi-sekuentzia, `i` indizetik (barne) `j`-ra (kanpo).  * `i` edo `j` negatiboak &rarr; `len(a)-i` , `len(a)-j`  * `i` edo `j` > `len(a)` &rarr; `len(a)`  * `i` ez adierazia edo `None` &rarr; `0`  * `j` ez adierazia edo `None` &rarr; `len(a)`* `a[i:j:k]` : `a`-ko azpi-sekuentzia, `i`-tik (barne) `j`-ra (kanpo), `k` hurratsarekin.* `a[i:j]` eta `a[i:j:k]`-k objektu berriak sortzen dituzte... **ia beti**.Adibideak:```	[hasi:gelditu:hurratsa] (hurrats negatiboa ere)	[hasi:gelditu]	[hasi:]	[:gelditu]	[:]	[hasi::hurratsa]        (hurrats negatiboa ere)	[:gelditu:hurratsa]     (hurrats negatiboa ere)	[::hurratsa]            (hurrats negatiboa ere)```<jupyter_code>a = "abcdefghijklmnñopqrstuvwxyz"
print(a[0:5])
print(a[5:len(a)])
print(a[:5])
print(a[5:])
print(a[:])
print(a==a[:],a is a[:])

a = "abcdefghijklmnñopqrstuvwxyz"
print(a[0:len(a):2])
print(a[::2])
print('froga1:',a[0:len(a):-1])
print('froga2:',a[len(a):0:-1])
print('froga3:',a[len(a):-len(a)-1:-1])
print('froga4:',a[len(a)::-1])
print('froga5:',a[::-1])<jupyter_output>acegikmñprtvxz
acegikmñprtvxz
froga1: 
froga2: zyxwvutsrqpoñnmlkjihgfedcb
froga3: zyxwvutsrqpoñnmlkjihgfedcba
froga4: zyxwvutsrqpoñnmlkjihgfedcba
froga5: zyxwvutsrqpoñnmlkjihgfedcba<jupyter_text>Karaktere kateen metodoak (funtzioak)* Objektu mota bakoitzak berezko metodo sorta bat eduki dezake.* Metodo hauek izendatzeko: `objektua.metodo_izena`* Karaktere kateek, [45 bat metodo](https://docs.python.org/3.5/library/stdtypes.htmlstring-methods) dituzte...Metodo erabilgarri batzuk:   * `s.count(a[,i,j])` , `s.find(a[,i,j])`   * `s.replace(a,b[,maxreps])`   * `s.strip([charset])` , `s.lstrip([charset])` , `s.rstrip([charset])`   * `s.split([sep[,maxsplits]])` , `s.splitlines([keepends])`   * `s.join(t)`   * `s.lower()` , `s.upper()` , `s.capitalize()` , `s.title()`  `string` moduloaKaraktere multzoak dituzten karaktere kateak definitzen dira`import string`   * `string.ascii_letters`  &rarr;  lowercase + uppercase    * `string.ascii_lowercase`  &rarr;  letra xeheak (a-z)    * `string.ascii_uppercase`  &rarr; letra larriak (A-Z)    * `string.digits`  &rarr;  digito hamartarrak	   * `string.hexdigits`  &rarr;  digito hexadezimalak (0-9a-fA-F)    * `string.octdigits`  &rarr;  digito zortzitarrak    * `string.punctuation`  &rarr;  puntuazio seinuak    * `string.printable`  &rarr;  letrak + dig. + puntuaz. + huts.    * `string.whitespace`  &rarr;  hutsuneak bezala hartzen diren karak. __OHARRA:__ Multzo hauek ingelesean oinarrituak daude....<jupyter_code>from string import ascii_lowercase as lowercase
print('n' in lowercase , 'ñ' in lowercase , 'u' in lowercase , 'ú' in lowercase)<jupyter_output>True False True False
{'fraction_non_alphanumeric': 0.1370935527682352, 'fraction_numerical': 0.03722936805943916, 'mean_word_length': 4.669384057971015, 'pattern_counts': {'":': 0, '<': 70, '<?xml version=': 0, '>': 73, 'https://': 1, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 2, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '22', 'dir': 'jupyter-structured-clean-dedup', 'id': '15022', 'license': 'MIT', 'n_tokens_mistral': 5924, 'n_tokens_neox': 5570, 'n_words': 1243, 'path': 'Gardenkiak/Karaktere kateak.ipynb', 'repo_name': 'mpenagar/Programazioaren-Oinarriak', 'size': '12517'}