#------------------------------------
Chaines de caractères (string) : str()

s='bacon'
len(s)                 # longueur vaut 5
print(s + ' and eggs') # concatenation : résultat "bacon and eggs"
print(s[1:4])          # slice : résultat "aco"
print(s[2])            # accès direct : vaut "c"
# Immuable = non modifiable => s[2] = "a" : Erreur
# Liste de caractères
for c in s: # c pour caractère ou char, s pour string
	print(c) # affiche chaque caractère

for i in range(len(s)): # i pour index dans la string s
	print(s[i]) # afffiche chaque caractère

print(a.replace('c', 'll')) # affiche 'ballon'
t="voici du texte qu'on peut spliter"
t2=t.split()  # ['voici', 'du', 'texte', "qu'on", 'peut', 'spliter']
s='-'.join(t2)# "voici-du-texte-qu'on-peut-spliter"
print(t2)
print(s)

#------------------------------------
Axiomatique des string : 

3 méthodes pour tout faire : 
	longeur              : len
	concaténation        : +
	sous-chaine (substr) : slice : [:]

	c''est pratique avec ces méthodes. On peut se débrouiller avec les 3 méthodes pour tout faire ! Avec en plus ord('A') et chr(65) ou upper() et lower() pour les traitements de base des caractères.

Il existe de nombreuses autres méthodes de strig qui facilitent les calculs : 
	split, join, replace,
   find, replace,
   strip, 
   upper, lower, capitalize, title (capitalize chaque mot)
   etc.

#-------------------------------------
# slice positifs : 

a='bonjour'
a[:]          # bonjour
a[0:len(a)]   # bonjour

a[1:]         # onjour
a[2:]         # njour

a[:]          # bonjour
a[0:len(a):1] # bonjour
a[0:len(a):2] # bnor

a[::1]        # bonjour
a[::2]        # bnor

#-------------------------------------
# slice negatifs : 
a[len(a)-1:]   # r
a[-1:]         # r
a[-2:]         # ur

a[:len(a)-1]  # bonjou
a[:-1]        # bonjou
a[:-2]        # bonjo
a[2:-2]       # njo

a[::-1]       # ruojnob
a[::-2]       # ronb

#-------------------------------------
# slice double negatifs : 

# attention, le double négatifs donne des résultats étranges !
# mieux vaut les éviter !

a[:-1:-1]     # ''
a[:-2:-1]     # r

#-------------------------------------
# f-string : string formatée
# ça s'utilise pour formater un affichage de string : 
# https://he-arc.github.io/livre-python/fstrings/index.html
#
# exemple : 
l=[i*5 for i in range(10)]
for i in range(len(l)):
	print(f"{'key':>10s}: {i:2d} {'-':^6} value: {l[i]:2d} {'-':^6} tiers: {l[i]/3:6.2f}")

# il y a 11 morceaux dans la f-string (entre les " "):

#  1: {'key':>10s} le mot 'key' sur 10 caractères, callé à droite
#  2: ": " est affiché tel quel
#  3: {i:2d} la variable i est un entier sur 2 caractères
#  4: " " est affiché tel quel
#  5: {'-':^6} le mot '-' est centré sur 6 caractères.
#  6: " value: " est affiché tel quel.
#  7: # {l[i]:2d} la variable l[i] est un entier sur 2 caractères
#  8: " " est affiché tel quel
#  9: {'-':^6} le mot '-' est centré sur 6 caractères.
# 10: " tiers: " est affiché tel quel
# 11: {i/3:6.2f} le float i/3 est sur 6 caractères dont 2 après la virgule

# présentation formaté du code :
l=[i*5 for i in range(10)]
for i in range(len(l)):
       print(
              f"{'key':>10s}: {i:2d} "
              f"{'-':^6}"
              f"value: {l[i]:2d} "
              f"{'-':^6}"
              f"tiers: {l[i]/3:6.2f}"
       )

''' 
       key:  0   -    value:  0   -    tiers:   0.00
       key:  1   -    value:  5   -    tiers:   1.67
       key:  2   -    value: 10   -    tiers:   3.33
       key:  3   -    value: 15   -    tiers:   5.00
       key:  4   -    value: 20   -    tiers:   6.67
       key:  5   -    value: 25   -    tiers:   8.33
       key:  6   -    value: 30   -    tiers:  10.00
       key:  7   -    value: 35   -    tiers:  11.67
       key:  8   -    value: 40   -    tiers:  13.33
       key:  9   -    value: 45   -    tiers:  15.00
'''