23. Práctica de análisis de datos SQL (10 preguntas simples de SQL)

Tema 1: Disposición de la lista de competición

Hay una tabla easy_competition_list de los nombres de los equipos que participan en la competencia, y los datos en la tabla easy_competition_list son los siguientes:

mysql> select * from easy_competition_list;
-- team_name 参数队名
+------------+
| team_name  |
+------------+
| 谁与争锋队 |
| 必胜队     |
| 乘风破浪队 |
| 群英汇队   |
| 梦之队     |
+------------+
5 rows in set (0.00 sec)

[Pregunta 1] Cada equipo participante llevará a cabo una competencia por equipos con otros equipos participantes, y se requiere generar todas las combinaciones de situaciones de juego de los dos equipos participantes (equipo A y equipo B respectivamente), y organizarlas en orden ascendente de acuerdo con los nombres del equipo. El contenido de salida incluye: Equipo A, Equipo B y los resultados de muestra son los siguientes:

+------------+------------+
| 队伍A      | 队伍B      |
+------------+------------+
| 乘风破浪队 | 必胜队     |
| 乘风破浪队 | 梦之队     |
| 乘风破浪队 | 群英汇队   |
| 乘风破浪队 | 谁与争锋队 |
| 必胜队     | 梦之队     |
| 必胜队     | 群英汇队   |
| 必胜队     | 谁与争锋队 |
| 梦之队     | 群英汇队   |
| 梦之队     | 谁与争锋队 |
| 群英汇队   | 谁与争锋队 |
+------------+------------+
10 rows in set (0.00 sec)

[Explicación del Tema 1] Utilice la autounión de la tabla para asegurarse de que el equipo no coincida consigo mismo conectando los nombres de los equipos en forma de <, y organícelos en orden ascendente de acuerdo con los nombres de los equipos. esta pregunta es la siguiente:

mysql> SELECT a.team_name AS 队伍A,b.team_name AS 队伍B FROM easy_competition_list
    -> a INNER JOIN easy_competition_list b ON a.team_name < b.team_name ORDER BY 队伍A,队伍B;

Tema 2: Clasificación de los mejores juegos

Ahora hay una tabla de clasificación de descargas de juegos easy_game_ranking, los datos de la tabla easy_game_ranking son los siguientes:

mysql> SELECT * FROM easy_game_ranking;
-- ① game: 游戏名称 VARCHAR ② category: 游戏类别 VARCHAR ③ downloads: 游戏下载量 INT
+------+----------+-----------+
| game | category | downloads |
+------+----------+-----------+
| A    | puzzle   |     13628 |
| B    | shooting |      2830 |
| C    | shooting |      1920 |
| D    | action   |     23800 |
| E    | puzzle   |       842 |
| F    | shooting |     48201 |
| G    | action   |      4532 |
| H    | puzzle   |      1028 |
| I    | action   |     48910 |
| J    | shooting |       342 |
| K    | puzzle   |     32456 |
| L    | action   |      2801 |
| M    | puzzle   |      1248 |
| N    | action   |      8756 |
+------+----------+-----------+
14 rows in set (0.00 sec)

[Pregunta 2] Consulte los dos mejores juegos de cada categoría por volumen de descarga. El contenido de salida incluye: categoría (categoría de juego), juego (nombre del juego) y la muestra de resultado se muestra en la siguiente figura:

[Análisis de la pregunta 2] Se puede realizar un problema de clasificación de grupo típico usando la función de ventana, usando DENSE_RANK () Función Generar los resultados de clasificación de cada juego en cada categoría de juego, y finalmente filtrar los datos que necesitamos a través de los resultados de clasificación. El código de referencia es el siguiente:

-- ① 使用窗口函数+分组聚合
mysql> SELECT category, GROUP_CONCAT(game) as game
    -> FROM (SELECT *, DENSE_RANK() OVER (PARTITION BY category ORDER BY downloads DESC) AS 'downloads_rank'
    ->       FROM easy_game_ranking)
    ->          AS a
    -> WHERE a.downloads_rank < 3
    -> GROUP BY category;

-- ② 使用分组聚合+文本字符串处理函数
-- 通过分组统计，在每组内按照游戏下载量降序排列并使用GROUP_CONCAT()函数进行连接，然后使用
-- SUBSTRING_INDEX()函数提取出前两个游戏名称即可得到结果
mysql> SELECT category, SUBSTRING_INDEX(GROUP_CONCAT(game ORDER BY downloads DESC), ',', 2) AS game
    -> FROM easy_game_ranking
    -> GROUP BY category;

Tema 3: Análisis de cobertura de la aplicación Community Fresh

Existe una tabla de aplicaciones frescas de la comunidad easy_fresh_food instalada por los usuarios, y los datos en la tabla easy_fresh_food son los siguientes:

mysql> SELECT * FROM easy_fresh_food;
-- user_id(用户ID): VARCHAR app(用户安装的社区生鲜App列表): VARCHAR
+---------+-------+
| user_id | app   |
+---------+-------+
| u001    | A,B   |
| u002    | C,D,A |
| u003    | E     |
| u004    | A     |
| u005    | F,D   |
| u006    | E,G   |
| u007    | C,B   |
| u008    | H,J   |
| u009    | J     |
| u010    | A,K,E |
+---------+-------+
10 rows in set (0.00 sec)

[Pregunta 3] Consultar el número de usuarios que han instalado Ala App. El resultado incluye: num (el número de usuarios), y la muestra de resultados se muestra en la siguiente figura:

[Análisis del Tema 3] Idea ①: Coincidencia aproximada, cuente siempre que haya una A, puede usar la palabra clave like o la función integrada FIND_IN_SET o INSTR de mysql. Idea ②: Dividir según ,, dividir un dato en varias filas de datos y luego contarlos en grupos. El código de referencia es el siguiente:

-- 第①种写法: 模糊匹配使用LIKE或者是REGEXP关键字
mysql> SELECT COUNT(*) AS num FROM easy_fresh_food WHERE app LIKE '%A%';
mysql> SELECT COUNT(*) AS num FROM easy_fresh_food WHERE app REGEXP 'A';
-- 第②种写法: 模糊匹配使用mysql内置函数 FIND_IN_SET或者是INSTR
mysql> SELECT SUM(IF(FIND_IN_SET('A', app), 1, 0)) AS num
    -> FROM easy_fresh_food;

mysql> SELECT SUM(CASE WHEN INSTR(app, 'A') > 0 THEN 1 ELSE 0 END) AS num
    -> FROM easy_fresh_food;

-- 第③种写法: 先将一行数据拆分为多行 然后分组计算
-- 如果 mysql.help_topic 没有权限，可以自己创建一张临时表，用来与要查询的表连接查询
-- 创建临时表，并给临时表添加数据: 注意:
-- 1.临时表必须有一列从 0 或者 1 开始的自增数据
-- 2.临时表表名随意，字段可以只有一个
-- 3.临时表示的数据量必须比 (LENGTH(easy_fresh_food.app)-LENGTH(REPLACE(easy_fresh_food.app, ',', '')) + 1) 的值大
mysql> SELECT *
    -> FROM (SELECT
    -> SUBSTRING_INDEX(SUBSTRING_INDEX(easy_fresh_food.app, ',', b.help_topic_id + 1), ',', - 1) AS app_name,
    -> COUNT(user_id)                                                                            AS num
    ->       FROM easy_fresh_food
    ->                INNER JOIN mysql.help_topic b ON b.help_topic_id < (LENGTH(easy_fresh_food.app) -
    ->                                                                    LENGTH(REPLACE(easy_fresh_food.app, ',', '')) + 1)
    ->       WHERE `app` <> ''
    ->       GROUP BY app_name) a
    -> WHERE a.app_name = 'A';
+----------+-----+
| app_name | num |
+----------+-----+
| A        |   4 |
+----------+-----+
1 row in set (0.00 sec)

Tema 4: Análisis del Comportamiento de Compra de Grupos Comunitarios

Hay una tabla de pedidos de usuarios de compras grupales de la comunidad easy_group_buy, que registra la situación en la que los usuarios inician sesión en la página de compras grupales y generan pedidos a través de diferentes canales en diferentes fechas. Los datos en la tabla easy_group_buy se muestran en la siguiente tabla:

mysql> SELECT * FROM easy_group_buy;
-- user_id(用户id):VARCHAR login_source(登录渠道):VARCHAR login_date(登录日期):DATE order_count(产生订单数量):INT
+---------+--------------+------------+-------------+
| user_id | login_source | login_date | order_count |
+---------+--------------+------------+-------------+
| a001    | applet       | 2021-03-20 |           1 |
| a002    | application  | 2021-03-20 |           0 |
| a003    | web          | 2021-03-21 |           0 |
| a002    | application  | 2021-03-21 |           2 |
| a001    | applet       | 2021-03-21 |           4 |
| a003    | application  | 2021-03-22 |           1 |
| a001    | applet       | 2021-03-22 |           1 |
| a004    | application  | 2021-03-23 |           1 |
+---------+--------------+------------+-------------+
8 rows in set (0.00 sec)

[Título 4-1] Consulta el nombre del canal en el que cada usuario inicia sesión por primera vez. El resultado incluye: user_id (ID de usuario), login_source (canal de inicio de sesión) y el ejemplo de resultado se muestra en la siguiente figura:

[Pregunta 4-1 Análisis] Idea ①: Use la función MIN() para encontrar la hora de inicio de sesión más temprana de cada usuario, y configure INNER JOIN en la tabla original y la hora de inicio de sesión más temprana de cada usuario para obtener la ID de usuario y el canal de inicio de sesión del usuario. Idea ②: función de ventana, el código de referencia es el siguiente:

-- 第①种写法
mysql> SELECT a1.user_id, a1.login_source
    -> FROM easy_group_buy a1
    ->          INNER JOIN (SELECT user_id, MIN(login_date) AS first_login_date FROM easy_group_buy GROUP BY user_id) a2
    ->                     ON a1.login_date = a2.first_login_date AND a1.user_id = a2.user_id;

-- 第②种写法
mysql> SELECT user_id, login_source
    -> FROM (SELECT user_id, login_source, DENSE_RANK() OVER (PARTITION BY user_id ORDER BY login_date ASC ) AS login_date_rank
    ->       FROM easy_group_buy) temp_table
    -> WHERE temp_table.login_date_rank = 1;

[Título 4-2] Consulta la fecha de inicio de sesión del usuario y la cantidad acumulada del pedido. El resultado incluye: user_id (ID de usuario), login_date (fecha de inicio de sesión), total_order_count (cantidad de pedido acumulada), la muestra de resultados se muestra en la siguiente figura: [Pregunta 4-2

Análisis] Use la función SUM() para agrupar por usuario ID y ordene según la fecha de inicio de sesión, puede obtener la fecha de inicio de sesión del usuario y la cantidad acumulada del pedido, lo que implica puntos de conocimiento: función de ventana, el código de referencia es el siguiente:

mysql> SELECT user_id,
    ->        login_date,
    ->        SUM(order_count) OVER (PARTITION BY user_id ORDER BY login_date)
    ->            AS total_order_count
    -> FROM easy_group_buy;

Tema 5: Contar las ocurrencias de caracteres

Hay una tabla de texto original easy_original_text, y los datos de la tabla easy_original_text se muestran en la siguiente tabla:

mysql> SELECT * FROM easy_original_text;
-- text_id（文本ID）: VARCHAR text_content（文本内容）: VARCHAR
+---------+--------------+
| text_id | text_content |
+---------+--------------+
| t001    | !**@%&       |
| t002    | *            |
| t003    | @@!***&*     |
| t004    | %&*$@        |
| t005    | *******      |
| t006    | 123456       |
+---------+--------------+
6 rows in set (0.00 sec)

【题目5】Cuente el número de ocurrencias de símbolos en cada texto . El resultado incluye: text_id (ID de texto), num (la cantidad de veces que aparece el símbolo *), y la muestra de resultados se muestra en la siguiente figura: [Análisis de la

Pregunta 5] Use la función REEMPLAZAR() para reemplazar el texto en el texto con una cadena vacía (cadena vacía La longitud del texto es 0), la diferencia entre la longitud del texto antes y después del reemplazo es el número de ocurrencias de * en el texto, involucrando puntos de conocimiento: funciones de procesamiento de cadenas, el código de referencia es el siguiente:

mysql> SELECT text_id, LENGTH(text_content) - LENGTH(REPLACE(text_content, '*', '')) AS num
    -> FROM easy_original_text table1;

Tema 6: Encuentra el producto con mayores ventas en cada categoría

Hay una tabla de ventas de productos easy_product_sale, que registra la información de productos de diferentes categorías de ventas de productos.Los datos en la tabla easy_product_sale se muestran en la siguiente tabla:

mysql> SELECT * FROM easy_product_sale;
-- product_id: 商品ID VARCHAR product_category: 商品类别 VARCHAR sale: 商品销量 INT
+------------+------------------+-------+
| product_id | product_category | sale  |
+------------+------------------+-------+
| p001       | c001             | 14600 |
| p002       | c001             | 23300 |
| p003       | c001             |  8000 |
| p004       | c002             | 40800 |
| p005       | c002             |  5300 |
| p006       | c003             | 12900 |
+------------+------------------+-------+
6 rows in set (0.00 sec)

[Pregunta 6] Consultar la información del producto con mayor volumen de ventas de las diferentes categorías de productos. El resultado incluye: product_category (categoría de producto), product_id (ID de producto), sale (ventas de producto) y la muestra de resultados se muestra en la siguiente figura: [Análisis de la Pregunta 6] Use la función DENSE_RANK()

para generar una nueva columna , es decir, diferentes categorías de productos Clasificación de ventas (sale_rank), y luego use esta parte como el interior de la subconsulta, filtre los registros con sale_rank=1 a través de WHERE fuera de la subconsulta, y luego obtenga la información del producto con las ventas más altas de diferentes categorías de productos El código de referencia es el siguiente:

mysql> SELECT temp_table.product_category, temp_table.product_id, temp_table.sale
    -> FROM (SELECT *, DENSE_RANK() OVER (PARTITION BY product_category ORDER BY sale DESC ) AS sale_rank
    ->       FROM easy_product_sale) temp_table
    -> WHERE temp_table.sale_rank = 1;

Tema 7: Encuentra el segundo empleado mejor pagado en cada departamento

Hay una tabla de información de empleados de la empresa easy_employee, y los datos en la tabla easy_employee se muestran en la siguiente tabla:

mysql> SELECT * FROM easy_employee;
-- employee_id（员工ID）: VARCHAR employee_name（员工姓名）: VARCHAR employee_salary（员工薪资）: INT 
-- department（员工所属部门ID）: VARCHAR
+-------------+---------------+-----------------+------------+
| employee_id | employee_name | employee_salary | department |
+-------------+---------------+-----------------+------------+
| a001        | Bob           |            7000 | b1         |
| a002        | Jack          |            9000 | b1         |
| a003        | Alice         |            8000 | b2         |
| a004        | Ben           |            5000 | b2         |
| a005        | Candy         |            4000 | b2         |
| a006        | Allen         |            5000 | b2         |
| a007        | Linda         |           10000 | b3         |
+-------------+---------------+-----------------+------------+
7 rows in set (0.00 sec)

También existe una tabla de información de departamentos easy_department, los datos de la tabla easy_department se muestran en la siguiente tabla:

mysql> SELECT * FROM easy_department;
-- department_id（部门ID）: VARCHAR department_name（部门名称）: VARCHAR
+---------------+-----------------+
| department_id | department_name |
+---------------+-----------------+
| b1            | Sales           |
| b2            | IT              |
| b3            | Product         |
+---------------+-----------------+
3 rows in set (0.00 sec)

[Título 7] Consultar la información del empleado con el segundo salario más alto en cada departamento. La salida incluye: employee_id (ID del empleado), employee_name (nombre del empleado), employee_salary (salario del empleado), department_name (nombre del departamento del empleado), la muestra de resultados se muestra en la siguiente figura: [Análisis del problema 7] Uso de la función de ventana, de acuerdo con el

ID del departamento El grupo se clasifica en orden descendente de salario de empleado en el grupo y se registra como employee_salary_rank, y employee_salary_rank=2 se usa como la segunda condición de salario más alta para realizar el filtrado DONDE, y luego la tabla procesada se conecta con la tabla de información del departamento para asociar el nombre del departamento, seleccione la columna deseada para obtener el resultado, el código de referencia es el siguiente:

mysql> SELECT a2.employee_id, a2.employee_name, a2.employee_salary, easy_department.department_name
    -> FROM (SELECT *
    ->       FROM (SELECT *, RANK() OVER (PARTITION BY department ORDER BY employee_salary DESC ) AS employee_salary_rank
    ->             FROM easy_employee) AS a1
    ->       WHERE a1.employee_salary_rank = 2) AS a2
    ->          INNER JOIN easy_department ON a2.department = easy_department.department_id;

Tema 8: Análisis de la situación de inicio de sesión del jugador del juego

Hay una tabla de inicio de sesión de jugador de juego easy_game_login, y los datos en la tabla easy_game_login se muestran en la siguiente tabla:

mysql> SELECT * FROM easy_game_login;
-- user_id（玩家ID）: VARCHAR login_time（登录时间）: VARCHAR
+---------+---------------------+
| user_id | login_time          |
+---------+---------------------+
| u001    | 2021-03-01 06:01:12 |
| u001    | 2021-03-01 07:14:20 |
| u002    | 2021-03-01 07:20:22 |
| u003    | 2021-03-01 08:22:45 |
| u001    | 2021-03-01 11:10:23 |
| u004    | 2021-03-01 12:00:10 |
| u002    | 2021-03-01 18:03:52 |
| u005    | 2021-03-01 20:10:29 |
| u003    | 2021-03-01 21:11:50 |
+---------+---------------------+
9 rows in set (0.00 sec)

[Título 8-1] Consulta los jugadores que han iniciado sesión en el juego varias veces en un día y la cantidad de veces que lo han hecho. El resultado incluye: user_id (ID del jugador), login_date (fecha de inicio de sesión), num (horas de inicio de sesión) y la muestra de resultados se muestra en la siguiente figura: [

Pregunta 8-1 Análisis] Para convertir la hora en formato de cadena, use IZQUIERDA ( ) intercepta la parte de la fecha y usa HAVING para filtrar a los jugadores que han iniciado sesión varias veces en un día a través de la agregación de grupos. El código de referencia es el siguiente:

mysql> SELECT a.user_id, a.login_date, COUNT(a.login_date) AS 'num'
    -> FROM (SELECT user_id, LEFT(login_time, 10) AS 'login_date' FROM easy_game_login)
    ->          AS a
    -> GROUP BY a.user_id, a.login_date
    -> HAVING COUNT(a.login_date) > 1;

[Pregunta 8-2] Para los jugadores que inician sesión en el juego varias veces al día, solo se busca el último registro del día. El resultado incluye: user_id (ID del jugador), login_time (hora de inicio de sesión) y el ejemplo de resultado se muestra en la siguiente figura:

[Análisis de la pregunta 8-2] Basado en los jugadores que iniciaron sesión varias veces en un día encontrado en el anterior pregunta, use La función RANK() selecciona el último registro según el grupo de usuarios y ordenado por tiempo. El código de referencia es el siguiente:

mysql> SELECT user_id, login_time
    -> FROM (SELECT e1.user_id,
    ->              e1.login_time,
    ->              RANK() OVER (PARTITION BY e1.user_id,LEFT(login_time, 10) ORDER BY login_time DESC ) AS login_time_rank
    ->       FROM easy_game_login e1
    ->                INNER JOIN (
    ->           SELECT a.user_id, a.login_date
    ->           FROM (SELECT user_id, LEFT(login_time, 10) AS 'login_date' FROM easy_game_login)
    ->                    AS a
    ->           GROUP BY a.user_id, a.login_date
    ->           HAVING COUNT(a.login_date) > 1) e2 ON e1.user_id = e2.user_id AND left(e1.login_time, 10) = e2.login_date) b
    -> WHERE b.login_time_rank = 1;

Tema 9: Importe del primer pedido del usuario

Hay una tabla de información de pedidos de compras del usuario easy_user_order en el sitio web de comercio electrónico, que registra las compras del usuario y otra información relacionada. Los datos en la tabla easy_user_order se muestran en la siguiente tabla:

mysql> SELECT * FROM easy_user_order;
-- user_id（用户ID）：VARCHAR payment（订单金额）：INT paytime（下单时间）：DATETIME
+---------+---------+---------------------+
| user_id | payment | paytime             |
+---------+---------+---------------------+
| a001    |     500 | 2021-02-01 13:25:00 |
| a001    |     800 | 2021-02-03 09:10:00 |
| b001    |     150 | 2021-02-03 15:18:00 |
| a002    |      90 | 2021-02-05 08:10:00 |
| a001    |    1050 | 2021-02-06 10:34:00 |
| b001    |     400 | 2021-02-07 18:19:00 |
+---------+---------+---------------------+
6 rows in set (0.00 sec)

[Pregunta 9] El primer pedido del usuario en el sitio web de comercio electrónico (el pedido con el tiempo de pedido más temprano) puede reflejar la capacidad de consumo del usuario, y se requiere contar la información del primer pedido de cada usuario. El contenido de salida incluye: user_id (ID de usuario), pago (monto del pedido) y la muestra del resultado se muestra en la siguiente figura: [

Análisis de la Pregunta 9] Use la función DENSE_RANK() para agrupar por ID de usuario y ordenarlos de forma ascendente ordenar de forma predeterminada por tiempo de pedido para obtener la clasificación de tiempo de pedido respectiva de cada usuario, consultar fuera de la subconsulta y filtrar la información de pedido de cada usuario clasificado 1 (es decir, la información de primer pedido) involucra puntos de conocimiento: subconsulta, función de ventana. El código de referencia es el siguiente:

mysql> SELECT user_id, payment
    -> FROM (SELECT user_id, payment, DENSE_RANK() OVER (PARTITION BY user_id ORDER BY paytime ASC) AS 'paytime_rank'
    ->       FROM easy_user_order)
    ->          AS a
    -> WHERE a.paytime_rank = 1;

Tema 10: Productos que participan en actividades promocionales

Ahora hay un programa de promoción de productos easy_product_promotion, y los datos en la tabla easy_product_promotion son los siguientes:

mysql> SELECT * FROM easy_product_promotion;
-- commodity_id（商品ID）：VARCHAR start_date（商品优惠活动起始日期）：DATE end_date（商品优惠活动结束日期）：DATE
+--------------+------------+------------+
| commodity_id | start_date | end_date   |
+--------------+------------+------------+
| a001         | 2021-01-01 | 2021-01-06 |
| a002         | 2021-01-01 | 2021-01-10 |
| a003         | 2021-01-02 | 2021-01-07 |
| a004         | 2021-01-05 | 2021-01-07 |
| b001         | 2021-01-05 | 2021-01-10 |
| b002         | 2021-01-04 | 2021-01-06 |
| c001         | 2021-01-06 | 2021-01-08 |
| c002         | 2021-01-02 | 2021-01-04 |
| c003         | 2021-01-08 | 2021-01-15 |
+--------------+------------+------------+
9 rows in set (0.00 sec)

[Pregunta 10] Consultar sobre los productos participantes en las actividades promocionales del 7 de enero de 2021 al 9 de enero de 2021. El resultado incluye: muestra de resultado de commodities_id (ID de producto) como se muestra en la siguiente figura:

[Análisis 10] Esta pregunta es adecuada para usar el método gráfico para enumerar primero todos los arreglos de tiempo posibles y luego escribir el código SQL. Supongamos que el 7 de enero de 2021 es la hora a, el 9 de enero de 2021 es la hora b, la hora de inicio de cada actividad promocional es s y la hora de finalización es e, entonces todas las secuencias posibles son "sabe", "saeb", "asbe" y "aseb". Puntos de conocimiento involucrados: juicio de tiempo complejo. El código SQL para esta pregunta es el siguiente:

mysql> SELECT commodity_id FROM easy_product_promotion
    -> WHERE (start_date <= '2021-01-09' AND start_date >= '2021-01-07')
    -> OR (end_date <= '2021-01-09' AND end_date >='2021-01-07')
    -> OR (start_date >= '2021-01-07' AND end_date <= '2021-01-09')
    -> OR (start_date <= '2021-01-07' AND end_date >= '2021-01-09');

Hasta ahora, el estudio de hoy ha terminado. El autor declara aquí que el autor escribe el artículo solo para aprender y comunicar, y para que más lectores que estudien la base de datos eviten algunos desvíos, ahorren tiempo y no la utilicen para otros fines. Si hay alguna infracción, contacto El blogger puede ser eliminado. Gracias por leer esta publicación de blog, espero que este artículo pueda convertirse en un líder en su viaje de programación. ¡Feliz lectura!

---

    Un buen libro no se cansa de leer cien veces, y el niño se conoce a sí mismo cuando está familiarizado con la clase. Y si quiero ser el chico más hermoso de la audiencia, debo persistir en adquirir más conocimiento a través del aprendizaje, cambiar mi destino con el conocimiento, ser testigo de mi crecimiento con los blogs y demostrar que estoy trabajando duro con las acciones.
    Si mi blog es útil para usted, si le gusta el contenido de mi blog, 点赞¡ 评论haga收藏 clic en tres enlaces! ¡Escuché que aquellos a quienes les gusta no tendrán mala suerte y estarán llenos de energía todos los días! Si realmente quieres prostituirte gratis, entonces te deseo felicidad todos los días, bienvenido a visitar mi blog a menudo.
 Codificar no es fácil, el apoyo de todos es mi motivación para perseverar. ¡No 关注me olvides después de que te guste!