Serie básica de Python- (3) introducción detallada de cadenas

Objetivos:
 Reconocer cadenas de caracteres
 Subíndice
 Cortar
 Métodos de operación comunes

1 Comprensión de las cadenas Las
cadenas son el tipo de datos más utilizado en Python. Generalmente usamos comillas para crear cadenas. Crear una cadena es fácil, simplemente asígnele una variable.
P.ej:

a = 'hello world'
b = "abcdefg"
print(type(a))
print(type(b))

1.1 Características de la cadena

# 一对引号字符串
name1 = 'Tom'
name2 = 'Rose'

# 三引号字符串
name3 = '''Tom'''
name4 = """Rose"""
a = '''i am Tom,
        nice to meet you !'''
print(a)
b = """i am Rose,
        nice to meet you!"""
print(b)
# 三引号形式的字符串支持换行
# 如果创建一个字符串I'm Tom?
c = "I'm Tom"
d = 'I\'m Tom'  # 这里的单引号注意一下！
print(c)
print(d)

1.2 Entrada y salida de cadenas

# 字符串的输出
print('hello world')
name = 'Tom'
print('我的名字是%s' % name)
print(f'我的名字是{name}')

# 字符串的输入
# 在Python中，使用input()接收用户输入
password = input('请输入您的密码：')
print(f'您输入的密码是{password}')
print(type(password))

2 subíndice

El subíndice también se llama índice, que es el número. Por ejemplo, el número de asiento del tren, la función del número de asiento: encuentre rápidamente el asiento correspondiente según el número.
Del mismo modo: la función de los subíndices es encontrar rápidamente los datos correspondientes a través de subíndices.

str1 = 'abc'
print(str1)
"""
1.数据在程序运行过程中存储在内存
2.如何得到数据a字符，b字符等？即如何使用字符串中的某个特定的数据？
3.这些字符数据从0开始顺序分配一个编号---使用这个编号精确找到某个字符数据
下标或索引或索引值
str1[下标]
"""
print(str1[0])
print(str1[1])
print(str1[2])

"""
输出结果：
abc
a
b
c
"""

3 rodajas

Cortar se refiere a la operación de interceptar una parte del objeto de operación. Las cadenas, listas y tuplas admiten operaciones de corte.
3.1
Secuencia de sintaxis de corte [subíndice de posición inicial: subíndice de posición final: longitud del paso]
Nota:
1. Los subíndices inicial y final se dejan cerrados y abiertos a la derecha, es decir, no incluyen los datos correspondientes a la posición final, y se aceptan tanto números positivos como negativos.
2. La longitud del paso es el intervalo de selección, se aceptan números enteros positivos y negativos, la longitud del paso predeterminada es 1.
Ejemplo 1:

name = "abcdefg"
print(name[2:5:1])  # cde
print(name[2:5])   # cde
print(name[:5])  # abcde
print(name[1:])   # bcdefg

Ejemplo 2:

# 序列名[开始下标位置：结束下标位置：步长]
str1 = '012345678'
print(str1[2:5:1])   # 234
print(str1[2:5:2])   # 24
print(str1[2:5])    # 234
print(str1[:5])     # 01234---如果不写开始，默认从0开始
print(str1[2:])     # 2345678---如果不写结束，默认选取到最后
print(str1[:])      # 012345678---如果不写开始和结束，表示选取全部

# 负数测试
print(str1[::-1])   # 876543210---步长为负数，表示倒叙选取
print(str1[-4:-1])  # 567---下标-1表示最后一个数据，一次向前类推

# 终极测试 str1 = '012345678'
print(str1[-4:-1:1])    # 567

print(str1[-4:-1:-1])
# 不能选取出数据：从-4开始到-1结束，选取方向从左到右，而步长-1表示从右向左选取
# ***如果选取方向（下标开始到结束的方向）和步长的方向冲突，则无法选取数据

4 métodos de operación comunes

4.1 Búsqueda El
llamado método de búsqueda de cadenas consiste en encontrar la posición o el número de apariciones de la subcadena en la cadena.
 find (): comprueba si una determinada subcadena está contenida en la cadena, si lo está, devuelve el índice de la posición inicial de la subcadena; de lo contrario, devuelve -1.

# 语法：字符串序列.find(子串，开始下标，结束位置下标)
# 注意：开始，结束位置下标可以省略，表示在整个字符串序列中查找
mystr = "hello world and itcast and itheima and Python"
print(mystr.find('and'))   # 12
print(mystr.find('and', 15, 30))  # 23
print(mystr.find('ands'))  # -1

 index (): comprueba si una determinada subcadena está contenida en esta cadena y devuelve el índice al principio de la subcadena; de lo contrario, informa una excepción.

# 语法：字符串序列.index(子串，开始位置下标，结束下标位置)
# 注意：开始，结束位置下标可以省略，表示在整个字符串序列中查找
mystr = "hello world and itcast and itheima and Python"
print(mystr.index('and'))  # 12
print(mystr.index('and', 15, 30))  # 23
print(mystr.index('ands'))  # 报错

 rfind () - la misma función que find (), pero la dirección de búsqueda comienza desde la derecha
 rindex () - funciona igual que index (), pero la dirección de búsqueda comienza desde la derecha
 count () - devuelve una determinada subcadena Número de ocurrencias en la cadena

# 语法：字符串序列.count(子串，开始位置下标，结束下标位置)
# 注意：开始，结束位置下标可以省略，表示在整个字符串序列中查找

ejemplo:

mystr = "hello world and itcast and itheima and Python"
# 1,rfind()
print(mystr.rfind('and'))  # 35
print(mystr.rfind('ands'))  #-1
# 2,rindex()
print(mystr.rindex('and'))  #35
# print(mystr.rindex('ands'))  # 报错
# 3,count()
print(mystr.count('and', 15, 30))  # 1
print(mystr.count('and'))  # 3
print(mystr.count('ands'))  # 0

4.2 Modificación La
denominada modificación de una cadena de caracteres se refiere a la modificación de los datos de la cadena de caracteres en forma de función.
4.2.1 Modificaciones comunes
 reemplazar () ---- reemplazar

mystr = "hello world and itcast and itheima and Python"
print(mystr.replace('and', 'he'))
# 结果hello world he itcast he itheima he Python
print(mystr.replace('and', 'he', 10))
# 结果hello world he itcast he itheima he Python
print(mystr)
# 结果hello world and itcast and itheima and Python
语法：字符串序列.replace(旧子串，新子串，替换次数)
注意：替换次数如果超出子串出现次数，则替换次数为该子串出现的次数

Nota: Los datos se pueden dividir en tipo variable y tipo inmutable según se pueda modificar directamente. Cuando se modifican los datos del tipo string, no se puede modificar el string original, pertenece al tipo que no puede modificar directamente los datos, es decir, el tipo inmutable.

 split () ---- Divide la cadena según el carácter especificado.
Nota: Si el carácter dividido es una subcadena de la cadena original, la subcadena se perderá después de la división.

mystr = "hello world and itcast and itheima and Python"
print(mystr.split('and'))
# 结果：['hello world ', ' itcast ', ' itheima ', ' Python']
print(mystr.split('and', 2))
# 结果：['hello world ', ' itcast ', ' itheima and Python']
print(mystr.split(' '))
# 结果：['hello', 'world', 'and', 'itcast', 'and', 'itheima', 'and', 'Python']
print(mystr.split(' ', 2))
# 结果：['hello', 'world', 'and itcast and itheima and Python']

 join (): combina cadenas con un carácter o subcadena, es decir, combina varias cadenas en una nueva cadena.

# join语法---字符或子串.join(多字符组成的序列)
mylist = ['aa', 'bb', 'cc']
new_str = '...'.join(mylist)
print(new_str)
# 结果：aa...bb...cc

4.2.2 Necesidad de conocer las modificaciones

 capitalize () ---- convierte el primer carácter de la cadena a mayúsculas
Nota: Después de convertir la función capitalize (), solo el primer carácter de la cadena está en mayúsculas y todos los demás caracteres en minúsculas.
 título () ---- convierte la primera letra de cada palabra de la cadena a mayúsculas.
 minúscula () ---- cambiar mayúsculas en una cadena a minúsculas
 mayúsculas () ---- cambiar minúsculas en una cadena a mayúsculas
Ejemplo:

mystr = "hello world and itcast and itheima and Python"
# 1，解释：将第一个字符转换成大写
#  结果：Hello world and itcast and itheima and python
print(mystr.capitalize())

# 2，解释：将每个单词首字母转成大写
#  结果：Hello World And Itcast And Itheima And Python
print(mystr.title())

# 3，解释：将字符串中的大写转换为小写
#  结果：hello world and itcast and itheima and python
print(mystr.lower())

# 4，解释：将字符串中的小写转大写
#  结果：HELLO WORLD AND ITCAST AND ITHEIMA AND PYTHON
print(mystr.upper())

 Eliminar la función en blanco
strip () ---- eliminar los caracteres en blanco en ambos lados de la cadena
lstrip () ---- eliminar el carácter en blanco izquierdo de la cadena
rstrip () ---- eliminar el carácter en blanco en el lado derecho de la cadena
Ejemplo:

 Alinear Función
Ijust () ---- devuelve una nueva cadena con la cadena original justificada a la izquierda y rellenada con la longitud correspondiente con los caracteres especificados (espacios predeterminados).

# 语法：字符串序列.ljust(长度，填充个字符)

rjust () ---- devuelve una nueva cadena con la cadena original justificada a la derecha y rellenada con la longitud correspondiente con los caracteres especificados (espacios predeterminados) .La sintaxis es la misma que ljust ().
center () ---- devuelve una nueva cadena con la cadena original alineada en el centro y rellenada con la longitud correspondiente con los caracteres especificados (espacios predeterminados) .La sintaxis es la misma que ljust ().
ejemplo:

4.3 Juicio El
llamado juicio es juzgar verdadero o falso, y el resultado devuelto son datos booleanos: Verdadero o Falso
 startswith () - verifique si la cadena comienza con la subcadena especificada, en caso afirmativo, devuelva Verdadero, de lo contrario devuelva Falso. Si establece los subíndices de posición inicial y final, marque dentro del rango especificado.
Sintaxis:
secuencia de cadena. Satrtswith (subcadena, índice de posición inicial, índice de posición final)
ejemplo:

mystr = "hello world and itcast and itheima and Python"
# 1，startswith():判断字符串是否以某个子串开头
print(mystr.startswith('hello'))
print(mystr.startswith('hel'))
print(mystr.startswith('hels'))

# 2,endswith():判断字符串是否以某个子串结尾
print(mystr.endswith('Python'))
print(mystr.endswith('Pythons'))

 isalpha (): si la cadena tiene al menos un carácter y todos los caracteres son letras, devuelve Verdadero y viceversa.

mystr1 = 'hello'
mystr2 = 'hello12345'
print(mystr1.isalpha())
print(mystr2.isalpha())

 isdigit (): si la cadena contiene solo dígitos, devuelve Verdadero y viceversa.
 isalnum (): devuelve verdadero si la cadena tiene al menos un carácter y todos los caracteres son letras o números, y viceversa.

mystr1 = 'aaa12345'
mystr2 = '12345'
print(mystr1.isdigit())
print(mystr2.isdigit())

print(mystr1.isalnum())
print(mystr2.isalnum())

 isspace () ---- Si la cadena contiene solo espacios en blanco, devuelve True y viceversa.

mystr3 = '1 2 3 4 5'
mystr4 = '     '
print(mystr3.isspace())
print(mystr4.isspace())

Hay tantas presentaciones sobre cuerdas, ¡y se recomienda a los amigos a quienes les guste que las coleccionen!