TheOne的个人博客

发表于 更新于 分类于

什么是可迭代对象

可迭代对象:在Python中，可迭代对象是指可以被迭代的对象，即可以使用 for 循环遍历其元素的对象。

1
2
3
4
5
6
7
8
from collections.abc import Iterable

nums = [1, 2, 3]

for num in nums:
    print(num)

print(isinstance(nums, Iterable))  # True

在上述代码中我们创建了一个列表，这个列表中的元素可以被我们的for循环所遍历，那么nums就是一个可迭代对象。最下边我们通过一个python内置方法instance来检查nums是否是Iterable类的实例，打印了True说明nums是Iterable类的一个实例，要是Iterable的子类一定是一个可迭代对象。

instance内置方法

isinstance是python的内置函数，判断一个类的实例是否是指定类的实例,支持继承关系

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class A:
    pass


class B(A):
    pass


a = A()
b = B()

print(isinstance(a, A))  # True
print(isinstance(b, A))  # True
print(isinstance(a, B))  # False

什么是迭代器对象

迭代器是一种对象，它实现了迭代器协议，即包含 iter() 和 next() 方法。迭代器对象用于在迭代过程中逐个访问元素，每次调用 next() 方法都会返回序列中的下一个元素，直到序列中没有元素可返回，此时会引发 StopIteration 异常。
iter函数是python中的一个内置函数，传递一个可迭代对象将这个对象转为一个迭代器对象

1
2
3
4
5
6
7
8
9
10
11
12
nums = [1, 2, 3]
print(next(nums))  # 这里会报错，因为只有迭代器对象才拥有next方法
"""
在python中iter()和__iter__的作用是一样的，因为__iter__是比较底层的方法，所以推荐使用iter()
下面这段代码将nums从一个可迭代对象转为一个迭代器对象
"""
obj = iter(nums)  # 此时obj对象将拥有next方法

print(next(nums))  # 1
print(next(nums))  # 2
print(next(nums))  # 3
print(next(nums))  # 如果元素取完则引发报错:StopIteration

通过instance方法来判断对象是否为迭代器对象

1
2
3
4
5
from collections.abc import Iterator

nums = [1, 2, 3]
print(isinstance(nums, Iterator))  # False,列表对象不是迭代器对象
print(isinstance(iter(nums), Iterator))  # True

自定义类实例化返回迭代器对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class ListNode:
    def __init__(self):
        self.person_list = list()

    # 如果一个类内部定义了__iter__方法，那么创建出来的实例一定是一个可迭代对象
    def __iter__(self):
        pass

    def __next__(self):
        pass


list_node = ListNode()
print(isinstance(list_node, Iterable))  # True
print(isinstance(list_node, Iterator))  # True

在上面这段代码中我们自定义了一个类，该类拥有__iter__和__next__方法，那么该类的实例对象就是一个迭代器对象，如果将该类的__next__方法注释，那么该类的实例对象就是一个可迭代对象。可迭代对象不一定是迭代器对象，迭代器对象一定是一个可迭代对象。

__iter__和__next__具体的使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class ListNode:
    def __init__(self):
        self.index = 0
        self.stu_list = list()

    def __iter__(self):
        return self

    def __next__(self):
        if self.index < len(self.stu_list):
            item = self.stu_list[self.index]
            self.index += 1
            return item
        else:
            print('元素被取完了')
            raise StopIteration

    def add(self, name):
        self.stu_list.append(name)


list_node = ListNode()
list_node.add('安娜')
list_node.add('双双')

for stu in list_node:
    print(stu)

在上面这段代码中我们定义了一个ListNode类，该类中声明了__iter__和__next__方法，先实例化了ListNode类对象，随后通过add方法添加了两个学员，那么我们使用for循环直接去遍历ListNode类的实例对象是可以正常将类中列表的内容打印出来，因为for循环实质上是先将调用iter方法将需要遍历的对象转为迭代器对象，然后迭代器对象去执行next方法，从而将元素遍历出来，next方法的作用就是定义如何在一个迭代器对象中获取元素。

发表于 更新于 分类于

什么是存储过程

存储过程（Stored Procedure）是一种在数据库中存储复杂程序，以便外部程序调用的一种数据库对象。
存储过程是为了完成特定功能的SQL语句集，经编译创建并保存在数据库中，用户可通过指定存储过程的名字并给定参数(需要时)来调用执行。
存储过程思想上很简单，就是数据库 SQL 语言层面的代码封装与重用。

存储过程的优点

  • 提高性能： 存储过程在数据库服务器上预先编译和存储，可以减少每次执行的解析和编译时间，从而提高执行速度。
  • 减少网络流量： 客户端只需发送存储过程的调用请求，而不是发送大量的SQL语句，从而减少了网络流量和延迟。
  • 增强安全性： 可以限制用户直接访问数据库表，只允许他们通过存储过程进行数据操作，从而提高了数据的安全性和完整性。
  • 提高可维护性： 存储过程可以实现业务逻辑的封装，使得逻辑在数据库层面统一管理，易于维护和更新。
  • 提高代码复用： 存储过程可以被多个应用程序调用，实现了代码的复用，避免了重复编写相同的逻辑。

存储过程的缺点

  • 难以调试： 存储过程的调试相对复杂，特别是当存储过程逻辑较为复杂时，调试可能会变得非常困难。
  • 数据库厂商依赖性： 存储过程的语法和特性在不同的数据库管理系统中可能有所不同，导致代码的移植性受到影响。
  • 增加数据库复杂性： 过度使用存储过程可能会增加数据库的复杂性，使得数据库结构难以理解和维护。
  • 限制了平台独立性： 使用存储过程可能限制了应用程序的平台独立性，因为存储过程通常是特定数据库管理系统的特性。
  • 可能导致性能问题： 如果存储过程编写不当，可能会导致性能问题，例如过度的循环、大量的参数传递等都可能影响存储过程的性能表现。

存储过程的创建和调用

存储过程通过procedure关键字来进行定义，存储过程的开始和结束符号由BEGIN…END来标识

1
2
3
4
create procedure 存储过程名(参数)
    BEGIN
        ...
    END

声明语句结束符

1
2
3
DELIMITER $$
或
DELIMITER //

调用存储过程时通过call关键字来进行调用

1
call 存储过程名(参数)

变量赋值

1
SET @p_in=1

变量定义

1
DECLARE l_int int unsigned default 4000000;

存储过程使用实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
-- 创建matches表
CREATE TABLE matches (
    MATCHNO INT,
    TEAMNO INT,
    PLAYERNO INT,
    WON INT,
    LOST INT
);
-- 表中插入数据
INSERT INTO matches ( MATCHNO, TEAMNO, PLAYERNO, WON, LOST )
VALUES
	( 1, 1, 6, 3, 1 ),
	( 7, 1, 57, 3, 0 ),
	( 8, 1, 8, 0, 3 ),
	( 9, 2, 27, 3, 2 ),
	( 11, 2, 112, 2, 3 );
	
-- 定义存储过程，删除指定球员参加的所有比赛
delimiter $$  -- 声明语句结束符，可以自定义
create procedure delete_matches(in p_playerno INTEGER)
BEGIN
	delete from matches where playerno = p_playerno;
END$$
delimiter ;

call delete_matches(57);  -- 执行存储过程,删除playerno为57的所有记录

存储过程的参数

1、in输入参数

1
2
3
4
5
6
7
8
9
10
11
12
delimiter $$
create procedure in_param(in p_in int)
BEGIN
	select p_in;
	set p_in=2;
	select p_in;
END$$
delimiter ;

set @p_in=1;
call in_param(@p_in); -- 这里会先打印1后打印2，p_in 在存储过程中被修改，但并不影响 @p_in   的值，因为前者为局部变量、后者为全局变量。
select @p_in;  --这里会输出1

2、out输出参数

1
2
3
4
5
6
7
8
9
10
11
12
13
delimiter //
create procedure out_param(out p_out int)
BEGIN
	select p_out;
	set p_out=2;
	select p_out;
END
//
delimiter ;

set @p_out=1;
call out_param(@p_out);  -- 这里会先输出null，再输出2，因为out是向调用者输出参数，不接收输入的参数，所以存储过程里第一次select p_out的时候会打印null
select @p_out;  -- 这里会输出2，因为我们调用了存储过程out_param并将参数@p_out传入，经过存储过程内部的处理将@p_out参数进行了修改并进行输出

3、inout输入输出参数

1
2
3
4
5
6
7
8
9
10
11
12
13
delimiter //
create procedure out_param(inout p_inout int)
BEGIN
	select p_inout;
	set p_inout=2;
	select p_inout;
END
//
delimiter ;

set @p_inout=1;
call inout_param(@p_inout);  -- 这里会先输出1再输出2，因为变量的类型为inout，所以既支持外部传入参数同时也会将参数输出出去
select @p_inout;  -- 这里仍然会打印2

注意:
1.即使存储过程中没有参数也必须在括号后面写上小括号
2.确保参数的名字不等于列的名字，否则在过程体中，参数名被当做列名来处理

MySQL存储过程的查询、修改与删除

1
2
3
4
5
6
7
8
9
10
11
12
13
14
select name from mysql.proc where db='数据库名';
或者
select routine_name from information_schema.routines where routine_schema='数据库名';
或者
show procedure status where db='数据库名';

如果我们想知道，某个存储过程的详细，那我们又该怎么做呢？是不是也可以像操作表一样用describe 表名进行查看呢？
SHOW CREATE PROCEDURE 数据库.存储过程名;

修改存储过程
ALTER PROCEDURE

删除存储过程
DROP PROCEDURE

MySQL存储过程的变量作用域及控制语句

1、变量的作用域

内部的变量在其作用域范围内享有更高的优先权，当执行到 end。变量时，内部变量消失，此时已经在其作用域外，变量不再可见了，应为在存储过程外再也不能找到这个声明的变量，但是你可以通过 out 参数或者将其值指派给会话变量来保存其值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
DELIMITER //
	CREATE PROCEDURE proc3() 
		begin
			declare x1 varchar(5) default 'outer';
			begin
				declare x1 varchar(5) default 'inner';
				select x1;
			end;
			select x1;
		end;
//
DELIMITER ;

CALL proc3()  -- 先输出inner，再输出outer

2、控制语句

2.1 if-then-else 语句
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
DELIMITER //
	CREATE PROCEDURE proc2(IN parameter int) 
		begin
			declare var int;
			set var=parameter+1;
			if var=0 then
				insert into MATCHES values(17,9,9,9,9);
			end if; 
			if parameter=0 then
				update MATCHES set LOST=LOST+1;
			else
				update MATCHES set LOST=LOST+2;
			end if;
		end;
//
DELIMITER ;
2.2 case语句
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
DELIMITER //
	CREATE PROCEDURE proc3 (in parameter int)  
		begin
			declare var int;
			set var=parameter+1;
			case var
				when 0 then
					insert into matches values(17,9,9,9,9);
				when 1 then
					insert into matches values(18,9,9,9,9);
				else
					insert into matches values(19,9,9,9,9);
			end case; 
		end;
//
DELIMITER ;
2.3 循环语句

2.3.1 while ···· end while

1
2
3
4
5
6
7
8
9
10
11
12
DELIMITER //
	CREATE PROCEDURE proc4 (in parameter int)  
		begin
			declare var int;
			set var=0;
			while var<6 do
				insert into matches values(var,9,9,9,9);
				set var=var+1;
			end while; 
		end;
//
DELIMITER ;

2.3.2 repeat···· end repeat
它在执行操作后检查结果，而 while 则是执行前进行检查。

1
2
3
4
5
6
7
8
9
10
11
12
13
DELIMITER //
	CREATE PROCEDURE proc5()
		begin
			declare v int;
			set v=0;
			repeat
				insert into matches values(v,8,8,8,8);
				set v=v+1;
			until v>=5
			end repeat;
		end;
//
DELIMITER ;

2.3.3 loop ·····endloop
loop 循环不需要初始条件，这点和 while 循环相似，同时和 repeat 循环一样不需要结束条件, leave 语句的意义是离开循环。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
DELIMITER //
	CREATE PROCEDURE proc6()
		begin
			declare v int;
			set v=0;
			LOOP_LABLE:loop
				insert into matches values(v,7,7,7,7);
				set v=v+1;
				if v >=5 then
					leave LOOP_LABLE;
				end if;
			end loop;
		end;
//
DELIMITER ;

2.3.4 ITERATE迭代
ITERATE 通过引用复合语句的标号,来从新开始复合语句:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
DELIMITER //
	CREATE PROCEDURE proc10()
		begin
			declare v int;
			set v=0;
			LOOP_LABLE:loop
				if v=3 then
					set v=v+2;
					ITERATE LOOP_LABLE;
				end if;
				insert into matches values(v,5,5,5,5);
				set v=v+1;
				if v>=5 then
					leave LOOP_LABLE; 
				end if;
			end loop;
		end;
//
DELIMITER ;

通过数据存储过程批量创建用户

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
delimiter $$

create procedure insertUser(in insertCount int, in startUsername int)
begin
	declare i int default 0; -- 初始化循环计数器
	declare usernameno int default startUsername; -- 初始化用户名计数器
	while i < insertCount do  -- 循环插入数据直到达到指定的insertCount
		insert into user(username, email, phone, sex, password, create_time) values(
		concat('user_', usernameno),
		concat('user', usernameno, '@gmail.com'),
		concat('15', lpad(FLOOR(100000000 + RAND() * 900000000), 8, '0')),
		if(mod(usernameno, 2) = 0, 1, 0),
		'123456',
		now()
		);
		insert into user_role(user_id, role_id) values(last_insert_id(), 2); -- 使用last_insert_id()获取刚刚插入的user_id
		set i = i + 1;
		set usernameno = usernameno + 1;
	end while;
end$$

delimiter ;

call insertUser(2, 3);

发表于 更新于 分类于

Docker-compose简介

Docker-compose 是用于定义和运行多容器的 Docker 应用程序的工具。通过 Compose，可以使用 YAML 文件来配置应用程序的服务。

Linux下安装Docker-compose

https://github.com/docker/compose/releases

1
curl "https://github.com/docker/compose/releases/download/1.25.4/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

更改权限：chmod +x /usr/local/bin/docker-compose
查看版本：docker-compose version

Docker-compose常用命令

  • 查看配置：docker-compose config
  • 后台启动：docker-compose up -d
  • 停止并删除容器、网络、卷、镜像： docker-compose down
  • 构建镜像：docker-compose build
  • 下载镜像：docker-compose pull
  • 展示当前docker-compose编排过的运行的所有容器：docker-compose ps
  • 进程：docker-compose top
  • 查看配置：docker-compose config
  • 启动：docker-compose start
  • 停止：docker-compose stop

Docker-compose.yml示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
version: "3"

service:
	# 下面的配置等价于
	# docker run -d -p 6001:6001 -v /app/microService:/data --network atguigu_net --name ms_01 docker_image:1.6
	microService:
  	image: docker_image:1.6
  	container_name: ms_01
  	ports:
    	- "6001:6001"
    volumes:
      - /app/microService:/data
    networks:
      - atguigu_net
    depends_on:
      - redis
      - mysql
      
  redis:
    image: redis:6
    ports:
    	- "6379:6379"
    volumes:
      - /app/redis/redis.conf:/etc/redis/redis.conf
    networks:
      - atguigu_net
    command: redis-server /etc/redis/redis.conf
  
  mysql:
    image: mysql:5.7
    environment:
      MYSQL_ROOT_PASSWORD: '123456'
      MYSQL_ALLOW_EMPTY_PASSWORD: 'no'
      MYSQL_DATABASE: 'db123'
      MYSQL_USER: 'william'
      MYSQL_PASSWORD: '123456'
    ports:
    	- "3306:3306"
    volumes:
      - /app/mysql/mysql.conf:/etc/mysql/mysql.conf
    networks:
      - atguigu_net
    command: --default-authentication-plugin=mysql_native_password # 解决外部无法访问
networks:
	atguigu_net:

发表于 更新于 分类于

Docker常用命令

1.docker pull 镜像名称:镜像标签 拉取镜像
2.docker run 运行镜像

  • –rm 容器停止之后立即删除容器
  • -i 表示运行容器
  • -it 运行之后进入到交互模式
  • –name xxx 给容器进行命名
  • -e 配置环境变量
  • -d 后台运行
  • -p 33060:3306 将本地的33060端口映射到容器内部的3306端口
  • -v 本地路径:容器内部的路径 将本地的目录映射到容器内部
  • –privileged=true 解决挂载目录没有权限的问题
  • –network 网络组名称 容器之间进行相互通信
  • –privileged 使用该参数，container内的root拥有真正的root权限。
    否则，container内的root只是外部的一个普通用户权限。

3.docker ps 查看正在运行的容器
4.docker ps -a 查看所有的容器
5.docker logs 容器名称/容器id 查看启动日志
6.docker exec -it 容器名称/容器id bash 进入容器的内部
7.docker inspect 容器名称/容器id 分析容器的具体信息
8.docker run -d bash -c ‘要执行的命令1 && 要执行的命令2’ 运行镜像后要执行的命令（注意：启动dockerfile构建的镜像时在后面加上bash -c ‘要执行的命令1 && 要执行的命令2’，会忽略掉dockerfile中CMD的内容）
9.docker cp 本地的文件目录 镜像名称:镜像目录 ——将本地的文件拷贝到容器内
10.docker inspect 容器名称——查看容器的ip地址
11.docker load -i 镜像压缩文件——将压缩文件加载为docker镜像

镜像管理

1、docker images 查看所有镜像
2、docker search 镜像名 搜索镜像
3、docker pull 镜像名:版本号 拉取镜像
4、docker history 镜像名 查看镜像创建历史
5、docker rmi 镜像名:标签 删除镜像
6、docker tag busybox:latest busybox:test 更改镜像名

Docker镜像构建

一、Dockerfile参数详解

  • FROM –依赖于哪些镜像
  • WORKDIR –指定工作的上下文
  • COPY –把一些文件或目录添加到镜像中
  • RUN –要运行的相关命令
  • CMD –最后要运行的指令
  • ENV key value –设置环境变量
  • ADD –将本地的文件复制到镜像内部（如果是一个压缩文件，将会在复制后自动解压）
  • COPY –与ADD相似（但是如果复制的是压缩文件，不会自动解压）

二、docker build参数详解

  • -t：为构建的镜像设置标签
  • –build-arg：传递构建参数到Dockerfile中
  • -f：指定要使用的Dockerfile的名称，如果文件名默认叫做dockerfile可以不用写
  • –network：指定构建时使用的网络配置
  • –no-cache：忽略缓存，强制重新构建镜像
  • –pull：在构建之前尝试拉取最新的基础镜像
  • –target：指定构建过程中的目标阶段

docker build官方文档:https://docs.docker.com/engine/reference/builder/

docker网络组的使用

当你在Docker中使用网络组时，可以通过以下简单的例子来理解其作用。假设你有两个容器，一个运行Web应用程序，另一个运行数据库服务。

首先，创建一个网络组：

1
docker network create mynetwork

接下来，运行一个容器并将其连接到这个网络：

1
docker run --name webapp --network mynetwork -d -p 8080:80 your-webapp-image

这会运行一个名为 “webapp” 的容器，将其连接到 “mynetwork” 网络，并将容器的端口 80 映射到主机的端口 8080。

然后，运行另一个容器，比如一个运行数据库的容器，并将其连接到相同的网络：

1
docker run --name database --network mynetwork -d -e MYSQL_ROOT_PASSWORD=password your-db-image

现在，你有两个容器运行在同一个网络中。它们可以通过容器名称相互通信，而无需关心它们各自的 IP 地址。

例如，在Web应用程序容器中，你可以配置数据库连接为：

1
mysql -h database -u root -p

这里，”database” 是另一个容器的名称，Docker网络组的内置 DNS 服务会将其解析为相应的 IP 地址。
通过这种方式，你可以轻松地创建多个容器，使它们能够在同一个网络中相互通信，而不受主机网络或其他容器的影响。这种隔离和组织方式使得构建和管理复杂的应用程序更为灵活和方便。

发表于 更新于 分类于

Docker简介

Docker 起源于 2013 年。Docker 是一个开源的应用容器引擎，基于 Go 语言开发，Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的系统

Docker优点

  • Docker 可以用来快速交付应用。加快打包时间，加快测试，加快发布，缩短开发及运行代码之间的周期。
  • 复杂环境管理，应用隔离：不同软件运行环境兼容依赖问题，开发环境/测试环境/线上环境保持一致。
  • 轻量级：对于系统内核来说，一个 docker 只是一个进程，一个系统可以运行上千个容器。

Docker与虚拟机的区别

  • 容器与容器之间只是进程的隔离，而虚拟机是完全的资源隔离。
  • 虚拟机的启动可能需要分钟级别，Docker 启动是秒级或者更短。
  • 容器使用宿主操作系统的内核，而虚拟机使用完全独立的内核。

Docker架构

centos下安装Docker

1
2
3
4
5
6
7
# 安装 Docker 依赖
yum install -y yum-utils device-mapper-persistent-data lvm2
# 配置依赖下载源
yum-config-manager --add-repo \
http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
# 安装 docker
yum makecache fast && yum -y install docker-ce

Docker配置阿里镜像源

https://cr.console.aliyun.com/cn-guangzhou/instances/mirrors(阿里云镜像加速地址获取)

1
2
3
4
5
6
7
8
sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["这里替换成自己的加速地址"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

Docker容器介绍

容器是您机器上的沙盒进程，与主机上的所有其他进程隔离。这种隔离利用了内核命名空间和 cgroups，这些特性已经在 Linux 中存在了很长时间。 Docker 致力于使这些功能变得平易近人且易于使用。总而言之，一个容器： 是图像的可运行实例。您可以使用 DockerAPI 或 CLI 创建、启动、停止、移动或删除容器。 可以在本地机器、虚拟机上运行或部署到云端。 是可移植的（可以在任何操作系统上运行）。 与其他容器隔离并运行自己的软件、二进制文件和配置。

图片描述

docker官网

发表于 更新于 分类于

前置说明：假设现在打开一个网页，需要点击页面中的元素跳转到另一个页面，这个时候可能会出现页面没有渲染完成导致点击失败


这里拿企业微信做一个例子，现在我处于协作模块，我需要点击进入应用管理，假设浏览器打开页面后页面没有渲染完成导致我点击应用管理失败，这个时候我们可以通过显示等待的高级用法（使用复杂行为解决点击不生效的问题）。我们可以找到应用管理页面中特定元素来判断是否点击成功，我们可以看见应用管理页面中有一个微信客服的元素，那么我们可以通过selenium显示等待的高级用法进行循环点击。

1
2
3
4
5
def loop_click(driver):
    self.driver.click(By.XPATH, "//span[text()='应用管理']/parent::a")
        return len(self.driver.find_elements(By.XPATH, "/div[text()='微信客服']")) > 0

WebDriverWait(self.driver, 10).until(loop_click)

这里我们我们将点击应用管理的操作写在了loop_click的函数内，并且在函数的return中定义了判断结果，如果应用管理页面的元素一旦出现则loop_click函数就会返回true，证明元素点击成功。当应用管理页面的元素一直没有出现，那么len(self.driver.find_elements(By.XPATH, “/div[text()=’微信客服’]”)) > 0就会一直为false，则在显示等待设定的时间内会一直执行loop_click函数从而达到循环点击的作用。

0%