Una breve muestra de Python 2

1. Declaraciones de control lógico

1. si declaración de juicio

demostración1

1 Defina la variable de puntuación para registrar la puntuación de la prueba
2. Si la puntuación es >=90 puntos, mostrará excelente
3 >=80 y <90, mostrará buena 4
>=70 y <80, media
5 >=60 & <70, pobre
6, otro reprobado

score = float(input('录入考试分数'))
if score >= 90:
    print("优")
elif score >= 80:
    print('良')
elif score >= 70:
    print('中')
elif score >= 60:
    print('差')
else:
    print('不及格')

demostración2

El proceso de retirar dinero del cajero automático: Contraseña: 123456. Si el saldo de la cuenta es 1000, se le
pedirá que ingrese la contraseña.
Si la contraseña es correcta, se le pedirá que ingrese el monto del retiro
. Determine la relación entre el monto del retiro y el saldo.

pwd = int(input("输入密码"))
if pwd == 123456:
    cash = float(input("本次取款金额"))
    if cash <= 1000:
        print('取款成功')
    else:
        print('余额不足')
else:
    print('密码不正确')

control lógico demo3 + número aleatorio

Ingrese los gestos de golpear Piedra (1)/Tijeras (2)/Papel (3) desde la consola. La
computadora golpea aleatoriamente; primero asuma que la computadora solo puede golpear piedras para completar la función de código general. Compare los pasos
ganadores y perdedores de los gestos de golpe del jugador (Piedra (1) Tijeras) (2) Tela (3)) La computadora golpea aleatoriamente para determinar el resultado.

import random

rand_num = random.randint(1, 3)
huaquan = int(input('写入划拳手势'))
if (rand_num == 1 and huaquan == 2) or (rand_num == 2 and huaquan == 3) or (rand_num == 3 and huaquan == 1):
    print(f'很遗憾你输了,电脑出{
      
      rand_num},你出{
      
      huaquan}')
elif rand_num == huaquan:
    print(f'平局,电脑出{
      
      rand_num},你出{
      
      huaquan}')
else:
    print(f'恭喜你赢了,电脑出{
      
      rand_num},你出{
      
      huaquan}')

demostración4

Condiciones para ingresar si el año es bisiesto: si es divisible por 4 pero no por 100, o si es divisible por 400, se puede determinar como año bisiesto.

inputYear = int(input("请输入年份"))
if (inputYear % 4 == 0 and inputYear % 100 != 0) or inputYear % 400 == 0:
    print(f'当前输入年份 {
      
      inputYear}为闰年')
else:
    print(f'当前输入年份 {
      
      inputYear}不是闰年')

otro

Aquí hay otros ejercicios que pueden hacer los bebés que quieran solidificar sus conceptos básicos:

1 Defina una variable entera para registrar la edad y determine si es mayor de 18 años (> =), si es mayor de 18 años, puede ingresar al cibercafé para divertirse.

2 Obtenga la información de nombre de usuario ingresada por el usuario.
Si la información de nombre de usuario es admin, envíela a la consola.

3 Defina dos variables enteras python_score y c_score, use la entrada para obtener la puntuación y escriba código para determinar la puntuación.
Siempre que haya una puntuación> 60 puntos, la salida será calificada.

4 Obtenga el nombre de usuario ingresado por el usuario. Cuando se determine que el nombre de usuario es admin, aparecerá en la consola: Bienvenido administrador para iniciar sesión.
Cuando el nombre de usuario sea prueba, aparecerá en la consola: Bienvenido inicio de sesión de prueba. Si se trata de otra información, aparecerá en la consola: ¡No se encontró ninguna gente!

Después de la ejecución, después de ingresar la edad desde la consola, el contenido correspondiente se generará de acuerdo con las condiciones de juicio.

2. declaración de bucle while

demostración1

Mi padre hizo enojar a mi madre y le dijo "Cariño, me equivoqué" 100 veces

i = 0
while i < 100:
    i += 1
    print(f'老婆我错了{
      
      i}')
print('终止循环')

demo2 acumula: 0+1+2+3+… +100 resultado

i = int(0)
sum = int(0)
while i < 100:
    i += 1
    sum += i
print(sum)

demo3 completa los golpes varias veces

Reglas: Ingrese el gesto de golpear piedra (1)/tijeras (2)/papel (3) desde la consola. La
computadora golpea aleatoriamente; primero asuma que la computadora solo puede golpear piedras para completar la función de código general.
Compare las ganancias y las pérdidas.
pasos
del gesto de golpe del jugador (piedra (1)) Tijeras (2) Papel (3))
La computadora golpea aleatoriamente
para determinar el resultado.

import random

while True:
    rand_num = random.randint(1, 3)
    huaquan = int(input('写入划拳手势 1：石头，2:剪刀 ，3:布 ，0 ：退出'))
    if huaquan == 0:
        print('欢迎下次来玩')
        break
    elif (rand_num == 1 and huaquan == 2) or (rand_num == 2 and huaquan == 3) or (rand_num == 3 and huaquan == 1):
        print(f'很遗憾你输了,电脑出{
      
      rand_num},你出{
      
      huaquan}')
    elif rand_num == huaquan:
        print(f'平局,电脑出{
      
      rand_num},你出{
      
      huaquan}')
    elif huaquan > 3 or huaquan < 1:
        print(f'输入错误，请重新输入,电脑出{
      
      rand_num},你出{
      
      huaquan}')
        continue
    else:
        print(f'恭喜你赢了,电脑出{
      
      rand_num},你出{
      
      huaquan}')

3. para bucle

demo1 acumula: 0+1+2+3+… +100 resultado

sum = 0
for i in range(101):
    sum += i
print(sum)

La cantidad de bucles demo2 está determinada por la cantidad de datos en el contenedor.

Cada bucle extrae un dato del contenedor y lo guarda en una variable. Después de
recuperar los datos del contenedor, se recorren los resultados (es decir, el bucle finaliza).

for i in 'hello':
    print(f'所以你会一直幸福下去   {
      
      i}')

demo3 for loop puede especificar el número de bucles

for n in range(3):
    print('最近天气很热')

2. Operaciones de tipos de datos comunes

1. Operaciones de cadena

Definición de cadenas comunes

str1 = '嗷呜！'  # 单引号
str2 = "嗷呜！"  # 双引号
str3 = """嗷呜！"""  # 三双引号
str4 = '''嗷呜！'''  # 三单引号

La cadena en sí contiene comillas simples. Al definir, no puede usar comillas simples para definir. Use comillas dobles para definir.
La cadena en sí contiene comillas dobles. Al definir, no puede usar comillas dobles para definir. Use comillas simples o triples para definir .

demostración 1

str1 = '''i'm  tom'''  # 输出：i'm  tom
print(str1)

demo2: El carácter de escape '' " está " después del escape

str2 = 'i\'m  tom'  # 输出：i'm  tom
print(str2)

demo3: La cadena en sí contiene (barras y comillas simples) \ ', soy Tom, \ se escapa a \

str3 = ' i\\\'m  tom '  # 输出 i\'m  tom
print(str3)

demo4: cadena nativa, agregue r"" delante de la cadena, lo que indica que no se escapará el contenido de la cadena.

Generalmente se usa en rutas de Windows y también se puede usar directamente en el texto de la declaración HTML

str4 = r"i\'m  tom"  # 输出：i\'m  tom
print(str4)
str5 = r"i\\\'m  tom"  # 输出：i\\\'m  tom
print(str5)

1.1 Índice y subíndice

El índice (subíndice) es el número de posición de los datos en el contenedor. Para una cadena, es la posición del carácter en toda la cadena.
1 En circunstancias normales, se utilizan índices positivos (de izquierda a derecha), comenzando desde 0
2. Python admite índices negativos (de derecha a izquierda), -1 representa los últimos datos en el contenedor
3. Utilice el índice (subíndice) para obtener los datos en la ubicación especificada en el contenedor
4. El subíndice es un número entero
str6 = 'abcdefg'

• Imprime el primer carácter de la cadena.

print(str6[0])  # 输出：a

• Imprime el último carácter de la cadena.

print(str6[-1])  # 输出：g

• Obtenga la ubicación y los datos con el índice 3.

print(str6[3])  # 输出：d
print(str6[30])  # 输出：数组下标越界 下面是输出内容

Traceback (most recent call last):
  File "/Users/gina/FeiHe/SourceCode/python_base1/python_2.py", line 14, in <module>
    print(str6[30])  # 输出：数组下标越界
IndexError: string index out of range

1.2 Recorrido de cuerdas

Utilice bucles for y while para facilitar las cadenas (es decir, saque cada carácter de la cadena e imprímalo)

str7 = 'bcdefgh'

for i in str7:
    print(i, end='  ')
print('\n', 'for-----------end')
i = 0
a = str7[0]

while i < len(str7):
    a = str7[i]
    i += 1
    print(a, end='  ')
print('\n', 'while-----------end')

print('xx¥@--' * 30)  # 输出 30个xx¥@--

1.3 Rebanar

1 Utilice el subíndice (índice) para obtener un carácter en una posición específica en la cadena
2 Utilice el corte para obtener varios caracteres en un carácter

• Cadena(inicio:fin:paso)
• inicio: el subíndice de la posición inicial, desde qué posición comenzar a tomar caracteres
• final: subíndice de posición final, dónde terminar (no se pueden obtener los datos finales) [inicio, fin) es el cierre frontal y la apertura posterior en matemáticas cuando era niño.
• paso: longitud del paso, el intervalo entre dos subíndices de datos adyacentes en la cadena obtenida. Los subíndices
  correspondientes a los datos obtenidos son:
  inicio, inicio+paso, inicio+paso+paso, inicio+paso +paso +paso

str7 = 'abcdefg'

# 1 取出字符串中 abc
print(str7[0:3:1])  # 输出 abc

# 1.1如果步长1，可以不写
print(str7[0:3])  # 输出 abc

# 1.2如果步长为整数（>0），开始位置为0，可以不写 ,截取前几位
print(str7[:3])  # 输出 abc

# 2 取出字符串efg ，下标从0开始
print(str7[4:7])

# 2.1结束位置是字符串的长度（最后一个数据要取到），可以不写
print(str7[4:])  # 输出efg
print(str7[:])  # 输出全部。从0开始取到最后一个字符，步长1 输出abcdefg
print(str7[::2])  # 步长为2，输出全部。从0 开始，取到最后，步长2 输出：aceg
print(str7[1:-1:3])  # 所取下标为（1,4），输出：b ，e
print(str7[:-1:2])  # 所取下标为 （0，2，4） a，c，e 

# 特殊情况，步长为负数，表示从右向左获取数据，一般用法：字符串的反转，倒置
print(str7[::-1])

1.4 Método de búsqueda de cadenas

print('abc'.find('a'))  # 存在返回第一次出现的下标，如果有多个也只会返回第一个，不存在返回-1 ，输出 0

# 现有字符串数据'你好哇咔咔，好困好困'
str = '你好哇咔咔，好困好困'
# 判断 输入咔或困是否存在于数据中
name = input('输入咔或困是否存在于数据中')
# 如果数据存在，则输出数据所在的位置
if name == '咔' or name == '困':
    print(str.find(name))
print(str)

1.5 Método de reemplazo de cadenas

# g 换为G ，如果不做指定，默认全量替换
str = 'g g stu ,d d up'
print(str.replace('g', 'G'))  # 输出：G G stu ,d d up
print(str)  # 输出：g g stu ,d d up
# 第一个g换为G ，指定替换个数，默认从左侧开始替换
print(str.replace('g', 'G', 1))  # 输出：G G stu ,d d up
# 第二个g替换为G
print(str.replace('g', 'G', 2).replace('G', 'g', 1))

1.6 División y concatenación de cadenas

• Dividir

str1 = 'hello python\tand\init and theam'
# 1、默认按空格为间隔符来拆分字符串 str.split() == str.split(' ')
rs = str1.split()  # 输出：['hello', 'python', 'and\\init', 'and', 'theam']
print(rs)
rs = str1.split(' ')  # 输出：['hello', 'python', 'and\\init', 'and', 'theam']
print(rs)
# 2、按照and 进行拆分
rs = str1.split('and')
print(rs)
str1 = 'hello pythontandinit and theam'
rs = str1.split('and')
print(rs)

• Conexión
  string.json (contenedor); Los contenedores generalmente usan listas. Al especificar una cadena, los contenidos de la lista se conectan entre sí para obtener una nueva cadena.

# ps：容器（列表）中的数据必须都是字符串类型
my_list = ['hello python', 'init ', ' theam']
# 用空格把列表内容连成一个字符串
str1 = ' '.join(my_list)
print(str1)
# 用逗号把列表中内容连成一个字符串
str2 = ','.join(my_list)
print(str2)

2. Lista de operaciones

2.1 Lista de definiciones

• Método 1: name_list=[] , name_list=["tom","jack","lily"]utilice [] para definir y utilice comas para separar los datos.

my_list2 = []
print(my_list2)
my_list2 = ['hello', '小强']
print(my_list2, len(my_list2))
输出：
[]
['hello', '小强'] 2

• Método 2: definir mediante creación de instancias de clase:data_list=list()

my_list = list();
print(my_list, type(my_list))
my_list = list('hello');
print(my_list, len(my_list))
输出
[] <class 'list'>
['h', 'e', 'l', 'l', 'o'] 5

2.2 La lista admite subíndices y divisiones

my_list = ['小明', 18, 1.81, True]
print(my_list[0])  # 取出第一个数据
print(my_list[-1])  # 取出最后一个数据
print(my_list[:2])  # 取出前两个数据，切片得到的是一个新的列表
输出：

小明
True
['小明', 18]

2.3 Consulta de lista

2.3.1 Recorrido de lista

for i in my_list:
    print(i, end=' ')

i = 0
while i < len(my_list):
    print(my_list[i], end=' ')
    i += 1

2.3.2 Número de listas

Cuente el número de veces que los datos de destino aparecen en la lista: list.count(datos de destino) devuelve 0 si los datos de destino no existen.

my_list = [1, 3, 2, 3, 1, 'hello']
print(my_list.count('hello'))  # 1
print(my_list.count(1))  # 2
print(my_list.count(5))  # 0

输出：
1
2
0

2.4 Operaciones de adición, eliminación y modificación de listas

2.4.1 Agregar elementos

• demo1:
  List.append(), tiene efecto en la lista original.
  Limitación: solo se puede agregar un dato a la vez

my_list = []
my_list.append('tom')
print(my_list)
my_list.append('jimi')
my_list.append('lily')
print(my_list)
输出：

['tom']
['tom', 'jimi', 'lily']

• Agregar demostración2

import random
# 使用随机数 向列表添加10个 1-20之间的随机数
my_list2 = []
for i in range(10):
    my_list2.append(random.randint(1, 20))
print(f'列表元素：{
      
      my_list2}')

2.4.2 Eliminar elementos:

my_list=['tom', 'jimi', 'lily']
# 删除列表中最后一个数据，返回删除的数据，作用于原列表
rs = my_list.pop()  # 
print(f'{
      
      my_list},删除的数据为{
      
      rs}')
输出：

['tom', 'jimi'],删除的数据为lily

2.4.3 Modificar elementos:

my_list=['tom', 'jimi', 'lily']
my_list[0] = 'jerry'
print(my_list)
# 修改第一个数据为8
my_list[0] = 8
print(my_list)
# 再次统计 数据8出现的次数
print(my_list.count(8))

输出：
['jerry', 'jimi', 'lily']
[8, 'jimi', 'lily']
1

2.5 Inversión de lista

• m1: La lista original no se modificará y se obtendrá una nueva lista [::-1];

my_list = [1, 3, 2]
print(my_list)
my_list = my_list[::-1]  # 切片进行的反转，原列表不会发生改变
print(my_list)
输出：
[1, 3, 2]
[2, 3, 1]

• m2: modifica directamente la lista original: list.reverse()

my_list = [1, 3, 2]
my_list.reverse()  # 切片进行的反转，原列表发生改变
print(my_list)
输出：
[2, 3, 1]

2.6 Clasificación de listas

• La clasificación de listas
  generalmente implica ordenar números en una lista, es decir, ordenar del mismo tipo, los valores de la lista cambiarán, orden ascendente: list.sort (), orden descendente: list.sort (reverso = Verdadero)

my_list2 = [1, 4, 3, 5]
print(my_list2)
my_list2.sort()
print(my_list2)
my_list2.sort(reverse=True)
print(my_list2)
输出：
[1, 4, 3, 5]
[1, 3, 4, 5]
[5, 4, 3, 1]

2.7 Anidamiento de listas

my_list = [['张三', '18', '黑盒测试'], ['丽萨', '28', '接口测试']]
# 打印第一个人的名字和年龄
print(my_list[0][:2])
# 最后一个人的名字
print(my_list[-1][0])

# 打印每个人的名字，年龄和工作：通过for循环来做
for i in my_list:
    print(f'for循环来做：{
      
      i}')
# 打印每个人的名字，年龄和工作 这种方式显然更轻量简洁
print(f'列表嵌套+切片 ：{
      
      my_list[::][::]}')
输出：

['张三', '18']
丽萨
for循环来做：['张三', '18', '黑盒测试']
for循环来做：['丽萨', '28', '接口测试']
列表嵌套+切片 ：[['张三', '18', '黑盒测试'], ['丽萨', '28', '接口测试']]

2.8 Lista de deduplicación

El conjunto de recopilación, expresado en la forma {datos, datos, datos},
primero convierte la lista en un tipo de conjunto y luego convierte el conjunto en un tipo de lista
dentro/no dentro. Se puede juzgar si los datos existen en el contenedor. Para un diccionario, se juzga la clave.) ¿Existe?

my_list = [1, 2, 3,  2, 'a', 'a', 'c']
my_list = list(set(my_list))
print(my_list)
输出【set后为乱序，不能保证原数据顺序】：
[1, 2, 3, 'a', 'c']

if 3 in my_list:
    print('存在')
else:
    print('不存在')
输出：
存在

Datos en el contenedor, determina si los datos existen, si existen, devuelve verdadero, si no existen, devuelve falso
Datos no en el contenedor, determina si los datos no existen, si no existen, devuelve verdadero, si los datos existe, devuelve falso