prefacio
Cuando realizamos la automatización de la interfaz, generalmente usamos expresiones regulares para extraer datos relevantes cuando tratamos con los datos relevantes de los que depende la interfaz.
Expresión regular, también conocida como expresión regular, expresión regular, expresión regular, expresión regular, expresión regular (Expresión regular, a menudo abreviada como expresión regular, expresión regular o RE en el código). Es una secuencia de caracteres especial que le ayuda a comprobar fácilmente si una cadena coincide con un patrón determinado. En muchos editores de texto, las expresiones regulares se utilizan a menudo para recuperar y reemplazar texto que coincide con un patrón determinado. Python ha agregado el módulo re desde la versión 1.5, que proporciona patrones de expresión regular al estilo Perl.
1. Sintaxis de expresiones regulares
1.1 representa un solo carácter
Carácter único: significa un solo carácter, por ejemplo, \d se usa para hacer coincidir números y \D se usa para hacer coincidir no números.
Además de la siguiente sintaxis, también puede hacer coincidir caracteres específicos específicos, que pueden ser uno o más.
El ejemplo es el siguiente, aquí hay una descripción de findall (reglas de coincidencia, la cadena que debe coincidir). Este método consiste en encontrar todos los datos coincidentes y devolverlos en forma de lista, que se explicará más adelante en el módulo re . :
import re
# .：匹配任意1个字符
re1 = r'.'
res1 = re.findall(re1, '\nj8?0\nbth\nihb')
print(res1) # 运行结果：['j', '8', '?', '0', 'b', 't', 'h', 'i', 'h', 'b']
# []：匹配列举中的其中一个
re2 = r"[abc]"
res2 = re.findall(re2, '1iugfiSHOIFUOFGIDHFGFD2345a6a78b99cc')
print(res2) # 运行结果：['a', 'a', 'b', 'c', 'c']
# \d:匹配一个数字
re3 = r"\d"
res3 = re.findall(re3, "dfghjkl32212dfghjk")
print(res3) # 运行结果：['3', '2', '2', '1', '2']
# \D:匹配一个非数字
re4 = r"\D"
res4 = re.findall(re4, "d212dk？\n$%3;]a")
print(res4) # 运行结果：['d', 'd', 'k', '？', '\n', '$', '%', ';', ']', 'a']
# \s：匹配一个空白键或tab键（tab键实际就是两个空白键）
re5 = r"\s"
res5 = re.findall(re5,"a s d a 9999")
print(res5) # 运行结果：[' ', ' ', ' ', ' ', ' ']
# \S: 匹配非空白键
re6 = r"\S"
res6 = re.findall(re6, "a s d a 9999")
print(res6) # 运行结果：['a', 's', 'd', 'a', '9', '9', '9', '9']
# \w：匹配一个单词字符(数字、字母、下划线)
re7 = r"\w"
res7 = re.findall(re7, "ce12sd@#a as_#$")
print(res7) # 运行结果：['c', 'e', '1', '2', 's', 'd', 'a', 'a', 's', '_']
# \W：匹配一个非单词字符(不是数字、字母、下划线)
re8 = r"\W"
res8 = re.findall(re8, "ce12sd@#a as_#$")
print(res8) # 运行结果：['@', '#', ' ', '#', '$']
# 匹配指定字符
re9 = r"python"
res9 = re.findall(re9, "cepy1thon12spython123@@python")
print(res9) # 运行结果：['python', 'python']1.2 Indica la cantidad
Si desea hacer coincidir un determinado personaje varias veces, puede agregar el número después del carácter para indicar, las reglas específicas son las siguientes:
Los ejemplos son los siguientes:
import re
# *：表示前一个字符出现0次以上(包括0次)
re21 = r"\d*" # 这里匹配的规则，前一个字符是数字
res21 = re.findall(re21, "343aa1112df345g1h6699") # 如匹配到a时，属于符合0次，但因为没有值所以会为空
print(res21) # 运行结果：['343', '', '', '1112', '', '', '345', '', '1', '', '6699', '']
# ? : 表示0次或者一次
re22 = r"\d?"
res22 = re.findall(re22, "3@43*a111")
print(res22) # 运行结果：['3', '', '4', '3', '', '', '1', '1', '1', '']
# {m}:表示匹配一个字符m次
re23 = r"1[3456789]\d{9}" # 手机号：第1位为1，第2位匹配列举的其中1个数字，第3位开始是数字，且匹配9次
res23 = re.findall(re23,"sas13566778899fgh256912345678jkghj12788990000aaa113588889999")
print(res23) # 运行结果：['13566778899', '13588889999']
# {m,}:表示匹配一个字符至少m次
re24 = r"\d{7,}"
res24 = re.findall(re24, "sas12356fgh1234567jkghj12788990000aaa113588889999")
print(res24) # 运行结果：['1234567', '12788990000', '113588889999']
# {m,n}：表示匹配一个字符出现m次到n次
re25 = r"\d{3,5}"
res25 = re.findall(re25, "aaaaa123456ghj333yyy77iii88jj909768876")
print(res25) # 运行结果：['12345', '333', '90976', '8876']1.2.1 Agrupación de partidos
Los casos son los siguientes:
import re
# 同时定义多个规则，只要满足其中一个
re31 = r"13566778899|13534563456|14788990000"
res31 = re.findall(re31, "sas13566778899fgh13534563456jkghj14788990000")
print(res31) # 运行结果：['13566778899', '13534563456', '14788990000']
# ()：匹配分组:在匹配规则的数据中提取括号里的数据
re32 = r"aa(\d{3})bb" # 如何数据符合规则，结果只会取括号中的数据，即\d{3}
res32 = re.findall(re32, "ggghjkaa123bbhhaa672bbjhjjaa@45bb")
print(res32) # 运行结果：['123', '672']1.3 Representando límites
Los ejemplos son los siguientes:
import re
# ^:匹配字符串的开头
re41 = r"^python" # 字符串开头为python
res41 = re.findall(re41, "python999python") # 只会匹配这个字符串的开头
res411 = re.findall(re41, "1python999python") # 因为开头是1,第1位就不符合了
print(res41) # 运行结果：['python']
print(res411) # 运行结果：[]
# $:匹配字符串的结尾
re42=r"python$" # 字符串以python结尾
res42 = re.findall(re42, "python999python")
print(res42) # 运行结果：['python']
# \b:匹配单词的边界，单词即:字母、数字、下划线
re43 = r"\bpython" # 即匹配python，且python的前一位是不是单词
res43 = re.findall(re43, "1python 999 python") # 这里第1个python的前1位是单词，因此第1个是不符合的
print(res43) # 运行结果：['python']
# \B:匹配非单词的边界
re44 = r"\Bpython" # 即匹配python，且python的前一位是单词
res44 = re.findall(re44, "1python999python")
print(res44) # 运行结果：['python', 'python']2. Modo codicioso
Los cuantificadores en Python son codiciosos por defecto. Siempre intentan hacer coincidir tantos caracteres como sea posible, mientras que el modo no codicioso intenta hacer coincidir la menor cantidad de caracteres posible. Agregar un signo de interrogación (?) a la expresión que indica la cantidad puede desactivar modelo de avaricia.
El siguiente ejemplo coincide con más de 2 números. Si cumple con las condiciones, coincidirá hasta que no coincida. Por ejemplo, 34656fya, 34656 coincide con más de 2 números, entonces coincidirá hasta 6. Si se activa el modo codicioso apagado, luego se detendrá cuando encuentre 2 números y finalmente podrá coincidir con 34 y 65.
import re
# 默认的贪婪模式下
test = 'aa123aaaa34656fyaa12a123d'
res = re.findall(r'\d{2,}', test)
print(res) # 运行结果：['123', '34656', '12', '123']
# 关闭贪婪模式
res2 = re.findall(r'\d{2,}?', test)
print(res2) # 运行结果：['12', '34', '65', '12', '12']Tres, re módulo
Cuando se usan expresiones regulares en Python, el módulo re se usará para las operaciones. Los métodos proporcionados generalmente requieren que se pasen dos parámetros:
- Parámetro 1: la regla de coincidencia
- Parámetro 2: la cadena que debe coincidir
3.1 re.findall()
Busque todas las cadenas que cumplan con la especificación y devuélvalas como una lista.
import re
test = 'aa123aaaa34656fyaa12a123d'
res = re.findall(r'\d{2,}', test)
print(res) # 运行结果：['123', '34656', '12', '123']3.2re.búsqueda()
Encuentre la primera cadena que cumpla con la especificación y devuelva un objeto coincidente, y los datos coincidentes se pueden extraer directamente a través del grupo ().
import re
s = "123abc123aaa123bbb888ccc"
res2 = re.search(r'123', s)
print(res2) # 运行结果：<re.Match object; span=(0, 3), match='123'>
# 通过group将匹配到的数据提取出来，返回类型为str
print(res2.group()) # 运行结果：123En el objeto coincidente devuelto, el intervalo es el rango de subíndice de los datos coincidentes y la coincidencia es el valor coincidente.
Descripción del parámetro grupo():
- No se pasan parámetros: se obtiene todo el contenido coincidente
- Valor entrante: se puede especificar mediante parámetros para obtener el contenido del primer grupo (obtener el primer grupo, pasar el parámetro 1, obtener el segundo grupo, pasar el parámetro 2, etc.).
import re
s = "123abc123aaa123bbb888ccc"
re4 = r"aaa(\d{3})bbb(\d{3})ccc" # 这里分组就是前面说到的匹配语法：()
res4 = re.search(re4, s)
print(res4)
# group不传参数：获取的是匹配到的所有内容
# group通过参数指定，获取第几个分组中的内容（获取第1个分组，传入参数1，获取第2个分组，传入参数2，依次类推..
print(res4.group())
print(res4.group(1))
print(res4.group(2))3.3 re.match()
Haga coincidir desde la posición inicial de la cadena y devuelva el objeto coincidente si la coincidencia es exitosa. Si la posición inicial no cumple con las reglas de coincidencia, no continuará coincidiendo y devolverá Ninguno directamente. Tanto re.match() como re.search() coinciden solo con uno, la diferencia es que el primero solo coincide con el comienzo de la cadena, mientras que el segundo coincide con toda la cadena, pero solo obtiene los primeros datos coincidentes.
import re
s = "a123abc123aaa1234bbb888ccc"
# match：只匹配字符串的开头，开头不符合就返回None
res1 = re.match(r"a123", s)
res2 = re.match(r"a1234", s)
print(res1) # 运行结果：<re.Match object; span=(0, 4), match='a123'>
print(res2) # 运行结果：None3.4re.sub()
Recuperar y reemplazar: se usa para reemplazar coincidencias en una cadena
Descripción del parámetro re.sub():
- Parámetro 1: la cadena a reemplazar
- Parámetro 2: cadena de destino
- Parámetro 3: la cadena a reemplazar
- Parámetro 4: puede especificar el número máximo de reemplazos, lo cual no es necesario (de forma predeterminada, se reemplazan todas las cadenas que cumplen con la especificación)
import re
s = "a123abc123aaa123bbb888ccc"
# <font color="#FF0000">参数1：</font>待替换的字符串
# <font color="#FF0000">参数2：</font>目标字符串
# <font color="#FF0000">参数3：</font>要进行替换操作的字符串
# <font color="#FF0000">参数4：</font>可以指定最多替换的次数，非必填（默认替换所有符合规范的字符串）
res5 = re.sub(r'123', "666", s, 4)
print(res5) # 运行结果：a666abc666aaa666bbb888ccc4. Parametrización de casos de uso
En la prueba de automatización de la interfaz, nuestros datos de prueba se almacenan en Excel. Si algunos parámetros se escriben hasta el final, es posible que no estén disponibles en una escena o entorno diferente. Al cambiar de entorno, primero debemos probar el nuevo entorno. Los datos está listo y puede admitir la ejecución de nuestros scripts o modificar los datos de Excel para probar datos adecuados para el nuevo entorno, y el costo de mantenimiento es relativamente alto. Por lo tanto, necesitamos parametrizar nuestros datos de prueba de script automatizados tanto como sea posible para reducir los costos de mantenimiento.
Primero veamos la parametrización de la versión simple. Tomando el inicio de sesión como ejemplo, el número de cuenta, la contraseña y otra información utilizada para iniciar sesión se pueden extraer y colocar en el archivo de configuración. Al modificar datos o cambiar el entorno, puede ser directamente modificado en el archivo de configuración.
Pero si hay varios datos diferentes que deben parametrizarse, ¿debería cada parámetro agregar un juicio para reemplazar los datos? Este código es largo y difícil de mantener. En este momento, se puede utilizar el módulo re. Veamos un ejemplo directamente:
import re
from common.myconfig import conf
class TestData:
"""用于临时保存一些要替换的数据"""
pass
def replace_data(data):
r = r"#(.+?)#" # 注意这个分组()内的内容
# 判断是否有需要替换的数据
while re.search(r, data):
res = re.search(r, data) # 匹配出第一个要替换的数据
item = res.group() # 提取要替换的数据内容
key = res.group(1) # 获取要替换内容中的数据项
try:
# 根据替换内容中的数据项去配置文件中找到对应的内容，进行替换
data = data.replace(item, conf.get_str("test_data", key))
except:
# 如果在配置文件中找不到就在临时保存的数据中找，然后替换
data = data.replace(item, getattr(TestData, key))
return dataTenga en cuenta que aquí se utiliza la expresión regular: desactive el modo codicioso, porque los datos de prueba pueden necesitar parametrizar 2 o más datos. Si el modo codicioso no está desactivado, solo puede coincidir y coincidir con un dato, por ejemplo:
import re
data = '{"mobile_phone":"#phone#","pwd":"#pwd#","user":#user#}'
r1 = "#(.+)#"
res1 = re.findall(r1, data)
print(res1) # 运行结果：['phone#","pwd":"#pwd#","user":#user'] 注意这里单引号只有一个数据
print(len(res1)) # 运行结果：1
r2 = "#(.+?)#"
res2 = re.findall(r2, data)
print(res2) # 运行结果：['phone', 'pwd', 'user']
print(len(res2)) # 运行结果：3Además, se menciona una clase para guardar datos temporalmente, que se utiliza principalmente para guardar los datos devueltos por la interfaz, porque algunos datos de prueba cambian dinámicamente y pueden depender de una determinada interfaz, y los casos de prueba posteriores necesitan estos datos, entonces Cuando la interfaz regresa, podemos guardarlo en esta clase como un atributo de clase y luego extraer este atributo de clase y reemplazarlo en los datos de prueba cuando necesitemos un caso de prueba que use estos datos. Consejo: establezca el atributo setattr (objeto, nombre de atributo, valor de atributo), obtenga el valor de atributo getattr (objeto, nombre de atributo).
Finalmente me gustaría agradecer a todos los que han leído atentamente mi artículo, la reciprocidad siempre es necesaria, aunque no es algo muy valioso, puedes quitártelo si lo necesitas:
Subprograma de entrevista de prueba de software
¡El banco de preguntas de pruebas de software superado por millones de personas! ! ! ¡Quién es quién lo sabe! ! ! El miniprograma de cuestionarios más completo de toda la red, puedes usar tu teléfono móvil para hacer los cuestionarios, en el metro o en el autobús, ¡enróllalo!
Se cubren las siguientes secciones de preguntas de la entrevista:
1. Teoría básica de pruebas de software, 2. web, aplicaciones, pruebas de función de interfaz, 3. red, 4. base de datos, 5. linux
6. web, aplicación, automatización de interfaz, 7. pruebas de rendimiento, 8. conceptos básicos de programación, 9. preguntas de la entrevista de horas, 10. preguntas de prueba abiertas, 11. pruebas de seguridad, 12. conceptos básicos de informática
Estos materiales deberían ser el almacén de preparación más completo y completo para los amigos [de pruebas de software]. Este almacén también ha acompañado a decenas de miles de ingenieros de pruebas en el viaje más difícil. ¡Espero que pueda ayudarlo a usted también!