(标记位置1)linux dns配置文件是“/etc/resolv.conf”，该配置文件用于配置DNS客户，它包含了主机的域名搜索顺序和DNS/服务器的地址，每一行包括一个关键字和一个或多个空格隔开的参数。
/etc/resolv.conf （不配置就不能域名解析）
可以配置路由器网关或者dns服务器：
nameserver 192.168.0.1
nameserver 114.114.114.114
du -sh 递归看当前目录占用空间大小。
du -sh * 递归看当前目录下各个目录或文件的大小。
df -h 看磁盘总空间，及已用空间。
和我遇到的情况一样， /var/crash应该是系统崩溃记录下来的日志。
操作系统硬件或者软件故障导致操作系统崩溃的日志记录，crash目录里面的大文件也是服务器崩溃的时候产生的主要是提供给系统管理员分析系统崩溃原因用的。
linux /var/crash目录暴增
https://www.modb.pro/db/224470
长见识了，可以这么写。pandas筛选长度
import pandas as pd
def invalid_tweets(tweets: pd.DataFrame) -> pd.DataFrame:
is_valid = tweets[‘content’].str.len() > 15
df = tweets[is_valid]
return df[[‘tweet_id’]]
Zookeeper配置文件端口相关：
#the port at which the clients will connect
clientPort是与客户端连接的端口
clientPort=2181
server.A=B:C:D
尾部新增如上配置。A为一个节点编号，如0或1或2。B为节点ip地址。C为Leader选举端口。D为数据同步端口。
https://www.kancloud.cn/zhangpn/zookeeper/1654670
kafka启动
kafka-server-start.sh $KAFKA_HOME/conf/server.properties &
Zookeeper命令
zkServer.sh start # 启动
zkServer.sh status # 查看状态
zkServer.sh stop # 停止
zkServer.sh restart # 重启
Kafka并不难学！入门、进阶、商业实战 邓杰编著（第二章）
kafka和ZooKeeper安装：
https://www.kancloud.cn/zhangpn/zookeeper/1654670
https://www.kancloud.cn/zhangpn/kafka/1658561
kafka安装：
https://kafka.apache.org/downloads
https://archive.apache.org/dist/kafka/
ZooKeeper安装：
https://zookeeper.apache.org/releases.html#download
https://archive.apache.org/dist/zookeeper/
zookeeper和kafka集群的版本适配
kafka zookeeper
kafka_2.13-2.7.0 zookeeper-3.5.8
kafka_2.13-2.6.x zookeeper-3.5.8
kafka_2.12-2.5.0 zookeeper-3.5.8
kafka_2.12-2.4.0 zookeeper-3.5.6
kafka_2.12-2.3.1 zookeeper-3.4.14
kafka_2.12-2.3.0 zookeeper-3.4.14
kafka_2.12-1.1.1 zookeeper-3.4.10
kafka_2.12-1.1.0 zookeeper-3.4.10
kafka_2.12-1.0.2 zookeeper-3.4.10
kafka_2.12-0.11.0.0 zookeeper-3.4.10
kafka_2.12-0.10.2.2 zookeeper-3.4.9
kafka_2.12-0.10.0.0 zookeeper-3.4.6
kafka_2.12-0.9.0.0 zookeeper-3.4.6
https://zhuanlan.zhihu.com/p/360095145?utm_id=0
zabbix图形化配置mysql报错：发现Database host写 localhost报错，写127.0.0.1就正常：
Please create database manually, and set the configuration parameters for connection to this database. Press “Next step” button when done.
Details Cannot connect to the database.
No such file or directory
启动服务，并开机自启： systemctl enable --now 加服务
HAVING的用法，因为count(*)不能筛选
SELECT DISTINCT version FROM
(SELECT version,COUNT(*) CT FROM test_table GROUP BY version HAVING CT > 20000) T
ORDER BY version DESC LIMIT 2
zcat 查看压缩包里面的内容
zcat /usr/share/doc/zabbix-server-mysql*/create.sql.gz | mysql -utest -p test
搭建kafka
https://baijiahao.baidu.com/s?id=1761361346909650797&wfr=spider&for=pc
https://blog.csdn.net/abments/article/details/128993066
https://mikechen.cc/24924.html
https://dgrt.cn/a/2261784.html?action=onClick
https://mikechen.cc/24926.html
搭建kafka：https://mikechen.cc/24924.html
确实好用，df.query
num_list = [2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 20, 30]
df = df.query(“time_horizon in @num_list”)
crontab -l crontab -e
每6小时一次定时，覆盖式写入：
0 */6 * * * echo y | cp /home/test.config /data/test.config
不覆盖写入：
cp -n /home/test.config /data/test.config
想了一下，其实是因为用了内网穿透的原因。
mysql 报错 虽然回显是内网ip，但是我们是外网ip连的，不能因为看见是内网ip就断定是运行的内网代码; Access denied for userxxxx@内网IP’ (using password: YES)
查看端口号：
ss -an
netstat -an
lsof -i -P -n
可以使用以下命令来查看 k8s 占用的端口号:kubectl get svc
telnet 192.168.0.100 80 看端口是否开启
Trying 192.168.0.100…
Connected to 192.168.0.100.
Escape character is ‘^]’.
^]
按ctl + ]号进入telnet界面，说明连接成功
https://jingyan.baidu.com/article/63f236285a48180209ab3d4a.html
ifdown 网卡名 ifup 网卡名 好了。虽然
systemctl status network看见网络还是失败，但是网络可以用了。
不知道是不是什么冲突之类的。
https://blog.csdn.net/wuds_158/article/details/131409495
mysql
查看设置最大连接数，与已用最大连接数
show variables like ‘max_connections’;
show global status like ‘Max_used_connections’;
https://blog.csdn.net/LelemamaAnne/article/details/113585805
mysq查看死锁进程
select * from information_schema.innodb_trx
kill 240727
kill的是trx_mysql_thread_id
https://blog.csdn.net/David_jiahuan/article/details/91558816
https://blog.51cto.com/u_12390904/6254246
相关排查语句
show full processlist ## 当前连接的线程
select * from information_schema.innodb_trx ## 当前运行的所有事务
select * from information_schema.innodb_locks ## 当前出现的锁
select * from information_schema.innodb_lock_waits ## 锁等待的对应关系
©著作权归作者所有：来自51CTO博客作者flysnownet的原创作品，请联系作者获取转载授权，否则将追究法律责任
解决mysql死锁错误 SQLSTATE[HY000]: General error: 1205 Lock wait timeout exceeded； try restart
https://blog.51cto.com/u_12390904/6254246
使用管道给cp传值：
find . -name “*.jar” | xargs -i cp {} /dir
cp后面的{}会被替换成xargs的输入
也可以使用
find . -name “*.jar” | xargs -I {} cp -r {} .
建议使用-I{}来代替 (大写i,不是小写L)
————————————————
版权声明：本文为CSDN博主「yayaqwl」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/u011517841/article/details/82347228
linux 获取倒数第二行数据
tail -n 2 mysql-bin.index | head -n 1
如何手动清理binlog
1.使用MySQL命令行
在MySQL命令行中，使用PURGE BINARY LOGS语句可以删除所有指定日期前创建的过期binlog日志文件。
例如，为了删除超过7天的binlog日志文件，可以运行以下命令：
PURGE BINARY LOGS BEFORE DATE_SUB(NOW(), INTERVAL 7 DAY);
1
2.按照binlog名称删除
#将mysql-bin.000011之前的日志清理掉
mysql> purge binary logs to ‘mysql-bin.000011’;
Query OK, 0 rows affected (0.01 sec)
1
2
3
3.按照时间删除
#删除2023-03-21 18:08:00之前的binlog日志
mysql> purge binary logs before ‘2023-03-21 18:08:00’;
Query OK, 0 rows affected, 1 warning (0.02 sec)
————————————————
版权声明：本文为CSDN博主「Clang的技术博客」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/u012899618/article/details/129790336
[mysqld]
#设置日志保留天数
expire_logs_days=7
#设置日志文件最大大小
max_binlog_size=100M
用代码实现mysql同步删，mysql的binlog格式一般设置为row，这种格式解析精准。
mysqlbinlog可以指定数据库
mysqlbinlog --database my_test_database --base64-output=decode-rows --verbose mysql-bin.001364 | grep -i -A 10 delete
正则表达式：匹配忽略大小写，加 re.I
s = ‘That’
pat = r’t’
results = re.findall(pat,s,re.I)
正则表达式
获取数字串：re.findall(“mysql-bin.(\d+)”, res)
cp -n 不要覆盖已存在的文件。（不需要交互式输出）
python的subprocess模块来执行linux命令，并获取结果。
python之subprocess模块 : import subprocess
subprocess.getstatusoutput(cmd) 执行cmd命令，返回一个元组(命令执行状态, 命令执行结果输出)，其功能类似于commands.getstatusoutput()
https://blog.csdn.net/qq_43331089/article/details/124421661
git clone分支 重命名（git链接后面加 自己的命名，可以重命名来区分不同分支）
git clone --depth=1 -b my_branch_2 http://project1.git project1_my_branch_2
https://baijiahao.baidu.com/s?id=1757643389424134685&wfr=spider&for=pc
mysq查看死锁进程
select * from information_schema.innodb_trx
kill 240727
https://blog.csdn.net/David_jiahuan/article/details/91558816
https://blog.51cto.com/u_12390904/6254246
pycharm 打开文件数量设置默认10个 File --> Settings -->Editor -->General --> Editor Tabs --> Tab limit
sql语句里有单引号或者双引号之类的字符，如果不是必须的可以replace去掉：
str(e).replace(‘"’, ’ ')
sql_update = “”“update 1_test_table set is_ok= “{}” “””.format(
e)
python保存输出到文件：
import sys
f = open(‘test_log.txt’, ‘w’)
sys.stdout = f
print(‘输出输出’)
f.close()
优先级为：内置模块 > 自定义包 > 自定义模块 > 三方安装包
https://blog.csdn.net/UZDW_/article/details/131745636
git回退版本：
场景一：如果想将代码恢复到之前某个提交的版本，且那个版本之后提交的版本都不要了，就可以使用 git rest
原理： git reset的作用是修改HEAD的位置，即将HEAD指向的位置改变为之前存在的某个版本
操作：
查看版本号：git log，也可以上代码托管网页上查看history，找到需要回滚的目标版本号
使用“git reset --hard 目标版本号”命令将版本回退
使用“git push -f”提交更改，此时如果用“git push”会报错，因为我们本地库HEAD指向的版本比远程库的要旧，用“git push -f”强制推上去。
————————————————
版权声明：本文为CSDN博主「泡泡大怪兽」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_45032067/article/details/124621305
scrapy设置延时，单位秒
DOWNLOAD_DELAY=2
(pymysql.err.0perationalEmror)(206,"mySQL erver has gone away (ComectionResetEror(10854,“远程主机强迫关闭7一个现有的连接。”, None, 10054,Wone))’ 应该是单次入库太多，我修改了一下max_allowed_packet 就好了。
查看： show global variables like ‘max_allowed_packet’;
设置：set global max_allowed_packet =33554432;
影响范围：
设置太大，会使用更多内存，很容易导致丢包，无法捕捉异常大事物包SQL
设置太小，可能会导致程序报错，备份失败，也会导致频繁的收发网络报，影响系统性能
修改：一般32M足够
[Mysql] >set global max_allowed_packet =33554432;
修改配置文件：
[mysqld]
max_allowed_packet=32M
https://cloud.tencent.com/developer/article/1103836
MySQL 对大小写是否敏感，由 lower_case_table_names 参数来控制，修改此参数需要重启数据库才能生效。
lower_case_table_names = 0：表名区分大小写，且按照用户指定存储。
lower_case_table_names = 1：表不区分大小写，使用小写存储。
lower_case_table_names = 2：表不区分大小写，按照用户指定存储
又遇到一个问题：https://blog.51cto.com/u_15072920/4373675
python中，No module named ‘main.models’; ‘main’ is not a package解决方法：
将相对路径改为绝对路径：
from .bird_base import BirdBase------改为-----> from python_learning.bird_base import BirdBase
mysqldump安装：yum install mysql
对应退出的容器，用 docker start 启动。
docker run 是使用镜像创建新容器。
先编辑一下docker容器里的文件，发现容器没有编辑器：
可以通过 docker cp 解决：
方法：通过copy进行编辑
查看运行的容器：docker ps -a
选择需要编辑容器进行登陆 sudo docker exec -it 容器名 /bin/bash ，通过ls或 whereis 文件名或文件夹 进行查看需要编辑的文件的位置或者文件夹位置在哪
退出该容器内部 exit;
通过 docker cp 容器名:/etc/确认copy的文件或文件夹 /home/拷贝到的外部文件夹 把文件拷贝出来
通过 cd 拷贝到的文件夹位置，可以使用 xftp工具直接对文件夹进行编辑，或通过命令 vi vim 进行编辑
编辑完后，再通过 docker cp /home/拷贝到的外部文件夹 容器名:/etc/确认copy的文件或文件夹 拷贝回去
最后重启一下编辑过文件的容器，然后进行测试有没有生效
一个字段不小心尾部多了个空格，可以用下列sql快速去除空格：
UPDATE 表名 SET 字段名 = REPLACE(字段名, ’ ', ‘’)
https://www.yzktw.com.cn/post/650656.html
pip install 或者 pip2 install 三方库失败，一般是因为包不兼容，要指定就可以了。
https://blog.csdn.net/crazytire/article/details/125964956
WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED!
警告：远程主机标识已更改！
这个报错主要是因为远程主机的ssh公钥发生了变化，两边不一致导致的
删除本地对应ip的在known_hosts相关信息
ssh登陆报错“IT IS POSSIBLE THAT SOMEONE IS DOING SOMETHING NASTY!“问题原因及解决方法
https://huaweicloud.csdn.net/635641f3d3efff3090b5c7c7.html
在python3中,sys.maxint改为sys.maxsize.
‘dict‘ object has no attribute ‘has_key‘
已于 2022-05-08 10:35:30 修改
3378
收藏 2
分类专栏： Python 文章标签： py2 py3
版权
这个问题是py2和py3兼容性的问题
在py2中，判断key是否属于dict的写法可以是：
d={‘name’:‘abc’,‘location’:‘BeiJing’}
if d.has_key(‘location’):
print(d[‘location’])
在py3中，判断key是否属于字典的写法可以是：
d={‘name’:‘abc’,‘location’:‘BeiJing’}
if ‘location’ in d:
print(d[‘location’])
————————————————
版权声明：本文为CSDN博主「upDiff」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/dlhlSC/article/details/90299500
scrapy：
https://blog.csdn.net/qq_44907926/article/details/119531324
scrapy官方文档：
https://scrapy-chs.readthedocs.io/zh_CN/1.0/intro/overview.html
scrapy 里面的item转化为dataframe：
df = pd.DataFrame(dict(item2), index=[0])
字典转化为dataframe：
df = pd.DataFrame(mydict, index=[0])
必须先把item转为字典，再转为dataframe。
如果是单条数据，必须加 index=[0]， 多条则不用。
想起以前遇到的一个关于 pd.read_excel 的问题:
import pandas as pd
from urllib.request import urlopen
url = “http://xxxxxxxxxx”
#python3要加read,py2不用（这里也是个点）
df = pd.read_excel(urlopen(url).read(),converters={‘字段1’;:str,‘字段2’:str})
如果运行报错就#Install xlrd >= 1.0.0 for Excel support Use pip or conda to
安装版本pip install xlrd==1.1.0就可以了。
原来这个报错和SQLAlchemy版本有关系
这个版本是sqlalchemy版本的是1.4.3的版本， 2.0的版本是不适用的
AttributeError: ‘Engine‘ object has no attribute ‘execute‘
https://blog.csdn.net/Deng872347348/article/details/129898331
pycharm菜单栏消失了，双击shift搜索 'menu’或者’菜单’即可显示菜单栏。
https://www.ycpai.cn/python/icrD9HxH.html
这个方法不错，拿jsonpCallback里面的json：
filter = re.findall("(jsonpCallback.*?\().+",response)[0]
filter=re.findall("jQuery.*?\((.*?)\);", content)[0]
content=response.text.replace('\n','').replace('\r','')
content = response.text.replace('\n', '').replace('\r', '').replace(' ', '')
filter=re.findall("jQuery.*?\((.*?)\);", content)
正则匹配网页要去掉\n和\r，不然可能会匹配不上。
.* 是贪婪模式，倾向于获取最长的满足条件的字符串；
.* ?是非贪婪模式，倾向于获取最短的能满足条件的字符串。
如果json内部也有小括号的时候，括号内部用.* 贪婪匹配 ：
filter=re.findall("jQuery.*?\((.*)\);", content)
filter=re.findall("jQuery.*?\((.*?)\);", content)
linux设置开机自启动：
在/etc/rc.local文件中添加自启动命令
测试了一下，还可以，蛮好用的
docker-compose 用pip安装：
pip install docker-compose
https://www.itbulu.com/python-setuppy-egginfo.html
mysql查询一小时内数据：
SELECT * FROM table_name WHERE date_column > DATE_SUB(NOW(), INTERVAL 1 HOUR);
看了几篇文章，发现这个最好用（就是jenkins任务一直卡着，×不掉的用命令行清理）
1、Manage Jenkins->Script Console（系统管理-工具和动作-脚本命令行）
Jenkins.instance.getItemByFullName(“清洗任务1”).getBuildByNumber(9711).delete();
清洗任务1是job名字，9711是Build号
————————————————
版权声明：本文为CSDN博主「萌翻天」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_40308101/article/details/125806891
要停止所有 Docker 容器，您可以运行以下命令：
docker stop$(docker ps -a -q)
1
2
这个命令会停止所有正在运行的容器，并且会忽略已经停止的容器。如果您想要删除这些容器，可以使用以下命令：
docker rm$(docker ps -a -q)
docker一条命令启动、关闭、停止、删除 所有容器
1.docker中 启动所有的容器命令
docker start $(docker ps -a | awk ‘{ print $1}’ | tail -n +2)
2.docker中 停止所有的容器命令
docker stop $(docker ps -a | awk ‘{ print $1}’ | tail -n +2)
3. docker中 删除所有的容器命令
docker rm $(docker ps -a | awk ‘{ print $1}’ | tail -n +2)
4. docker中 删除所有的镜像
docker rmi $(docker images | awk ‘{print $3}’ |tail -n +2)
5. 更新容器为开机自启
docker update --restart=always mysql #设置MySQL为开机自启
6.根据容器的状态，删除Exited状态的所有容器
sudo docker rm $(sudo docker ps -qf status=exited)
docker 出现root也无法停止、删除的问题
解决：
执行命令：
aa-remove-unknown
https://blog.csdn.net/lau_jw/article/details/126598759
原来lanproxy服务端的端口对应等配置信息在这个地方： /root/.lanproxy
又get到一个新知识zfill：
zfill的功能
为字符串定义长度，如不满足，缺少的部分用0填补
zfill的用法
用法：newstr = string.zfill(width)
参数：width新字符串希望的宽度
In [14]: name = ‘insane’
In [15]: new_name = name.zfill(10)
In [16]: print(new_name)
0000insane
————————————————
版权声明：本文为CSDN博主「Insane_Loafer」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/m0_48978908/article/details/119189964
获取汉字首字母拼音
from pypinyin import pinyin as py, Style as py_style
person_name_py = “”.join([x[0] for x in py(‘李小白’, style=py_style.FIRST_LETTER)]).upper()
为什么requests.get(url)得到的response不能使用简洁用法 response.xpath（需要先用etree.HTML()方法过渡），而scrapy中parse方法内却能直接使用response.xpath？
requests和scrapy的response是两个类，requests的没有封装xpath方法
https://zhuanlan.zhihu.com/p/40332579
查看目录总大小
du -sh ./root
du 参数 目录
-h：单位以用户友好方式展示
-c: 统计目录文件大小
-a：显示目录下所有的文件
–time：显示目录文件修改的最后时间
–exclude：排除某个目录
-s：直接显示目录的使用大小
-BK：以KB为单位显示目录大小
-BM：以MB为单位显示目录大小
-BG：以GB为单位显示目录大小
https://baijiahao.baidu.com/s?id=1741054542770174942&wfr=spider&for=pc
docker exec -it my_ginx /bin/bash
failed to create runc console socket: mkdir /tmp/pty179331520: no space left on device: unknown
应该是磁盘空间不够了
清理docker日志，参考这篇文章
https://blog.csdn.net/WLPJLP/article/details/121371788
#!/bin/bash
echo "开始清理docker日志"
#容器的路径 默认的就是下面的，如果是自定义的docker的路径就改自己定的路径
CONTAINER_DIR=/var/lib/docker/containers
获取所有的容器日志文件
CONTAINER_LOGS=$(find $CONTAINER_DIR -name "*-json.log")
#清理每个容器的日志
for LOG in $CONTAINER_LOGS; do
LOG_FILE=${LOG##*/}
echo "容器的ID：${LOG_FILE/-json.log/} 清理的日志文件：$LOG_FILE"
cat /dev/null >"$LOG"
# 也可以使用-> echo "" >"$LOG"
done
清洗无用镜像：
docker image prune -f
是一个用于删除Docker镜像的命令。其中，-f 参数表示强制删除，即不进行任何提示或确认。
使用该命令可以删除所有未被任何容器使用的镜像，以及所有已停止的镜像。
请注意，在执行此操作之前，请确保您已经备份了重要的数据，因为删除的镜像将无法恢复。
————————————————
版权声明：本文为CSDN博主「shareloke」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/WLPJLP/article/details/121371788
https://console.cloud.tencent.com/cns
改域名对应ip。每个子域名都可以对应不同IP
好用，真方便！
https://www.runoob.com/docker/docker-compose.html
docker-compose.yml 配置文件：
使用 Compose 命令构建和运行您的应用
在测试目录中，执行以下命令来启动应用程序：
docker-compose up
如果你想在后台执行该服务可以加上 -d 参数：
docker-compose up -d
zip 命令为压缩命令，压缩后不覆盖源文件，可以压缩目录，一般后缀名为.zip用于压缩文件，其语法格式如下：
zip [选项] 文件名.zip /xxx/路径xxx/文件
1
常用参数选项如下：
-v ：可视化操作，显示压缩的执行过程，默认就是可视化
-q ： 静默操作，不显示指令执行过程
-r ：表示递归打包包含子目录的全部内容
-d ：从压缩文件内删除指定的文件
-n ：n为一个数字，压缩级别是从 1~9 的数字，-1 代表压缩速度更快，-9 代表压缩效果更好
-e ：加密压缩文件
-u :追加文件到zip压缩包中
1
2
3
4
5
6
7
演示示例：
zip -vr etc.zip /etc/ #压缩/etc/目录，压缩文件名为etc.zip
zip -d myfile.zip smart.txt #删除压缩文件中的指定文件
zip -e passwd.zip /etc/passwd #加密压缩，需要输入密码
zip -u passwd.zip mypasww.txt #追加mypasww.txt文件到压缩包中
————————————————
版权声明：本文为CSDN博主「MssGuo」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/MssGuo/article/details/117324818
调整服务器内核参数
① Linux 提供了 tcp_max_tw_buckets 参数，当 TIME_WAIT 的连接数量超过该参数时，新关闭的连接就不再经历 TIME_WAIT 而直接关闭：
[root@kvm-10-115-88-47 ~]# cat /proc/sys/net/ipv4/tcp_max_tw_buckets
1.sort_values（）方法
sort_values(by, axis=0, ascending=True, inplace=False, kind=‘quicksort’, na_position=‘last’)
①axis 如果axis=0，那么by=“列名”； 如果axis=1，那么by=“行名”；
②ascending: True则升序，可以是[True,False]，即第一字段升序，第二个降序
③inplace: 是否用排序后的数据框替换现有的数据框 ，True,或者False
④kind: 排序方法
⑤na_position : {‘first’, ‘last’}, default ‘last’，默认缺失值排在最后面
————————————————
版权声明：本文为CSDN博主「Clyde_刘」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_51098806/article/details/115264798
Jenkins 时间输出：如何设置打印时间为钟表时间，而不是脚本运行时间
输出界面左边配置：
Timestamps
View as plain text
System clock time
Use browser timezone
Elapsed time
None
mysql对NULL的判断： = 和 != 运算符是不起作用的，必须使用 IS NULL 和 IS NOT NULL
mysql limit用法：
LIMIT 初始位置，记录数
其中，“初始位置”表示从哪条记录开始显示；“记录数”表示显示记录的条数。第一条记录的位置是 0，第二条记录的位置是 1。后面的记录依次类推。
注意：LIMIT 后的两个参数必须都是正整数。
比如：
select * from test limit 2,5
就是从test表里，第三条记录开始取，一共取5条记录
mysql配置文件的server-id是4字节整数，范围从0-4294967295。不能重复，可以设置为ip的末端号。
XtraBackup 环境安装
https://blog.csdn.net/A___LEi/article/details/127661509
[root@centos7 ~]# yum -y install https://repo.percona.com/yum/percona-release-latest.noarch.rpm
[root@centos7 ~]# yum -y install percona-xtrabackup-24
[root@centos7 ~]# yum -y install qpress ##innobackupex支持压缩导出，这里安装压缩工具
[root@centos7 ~]# innobackupex -version ###如果出现如下提示表示安装成功，我这里2.4.15
xtrabackup: recognized server arguments: --server-id=11 --datadir=/data/mysql_data --tmpdir=/tmp --log_bin=bin.log --innodb_page_size=8192 --innodb_buffer_pool_size=2G --innodb_io_capacity=4000 --innodb_flush_method=O_DIRECT --innodb_undo_tablespaces=3 --innodb_log_file_size=128M --innodb_log_buffer_size=16777216
innobackupex version 2.4.15 Linux (x86_64) (revision id: 544842a)
使用物理备份恢复数据库
https://cloud.tencent.com/document/product/236/33363
下载并安装 XtraBackup 工具。
MySQL 5.6、5.7 请选择 Percona XtraBackup 2.4.6 及以上的版本，下载地址，安装介绍请参见 Percona XtraBackup 2.4 指引。
MySQL 8.0 请选择 Percona XtraBackup 8.0.22-15 及以上版本，下载地址，安装介绍请参见 Percona XtraBackup 8.0 指引。
pycharm配置add configuration
注意点：
1.打开当前项目，而不是把多个项目在一个窗口打开（注意项目路径）。
2.添加解释器环境的时候，注意选择Script path,而不是Module name。
wget 可以断点续传，真是太好了，某云下载mysql备份文件url链接只生效12小时。下载一半失败了。发现可以续上，省时间了。
只需要使用-c参数，就支持断点续传了。
wget命令格式：wget -c ‘<备份文件下载地址>’ -O <自定义文件名>.xb
发现一件事，xpath的时候，都是从1开始计数的，不是从0计数。
比如说td[1]、td[2]…
linux解压zip文件到特定目录：
unzip -d /temp test.zip
https://blog.csdn.net/weixin_44021888/article/details/126384301
把一个项目里特定几个模块使用setup打包成tar.gz，文件。然后比如说在另一个项目pip install xxx.tar.gz，就可以像安装python三方库一样，使用这个xxx项目的模块。
如何把这个 xxx.tar.gz，在该项目的容器里使用呢。
先把这个文件上传到git项目里。
在该项目的Dockerfile里写入：
ENV TZ=Asia/Shanghai
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
RUN mkdir -p /usr/src/app
ENV PYTHONPATH=/usr/src/app
WORKDIR /usr/src/app
COPY . /usr/src/app
RUN pip install /usr/src/app/xxx.tar.gz
RUN pip install -r /usr/src/app/requirements.txt
就可以在打包镜像的时候，安装自己的包和python三方库了。
代码没找到指定库，原来没指定就用0号库：“Redis的默认库是0号库。用户在Redis中进行操作时,如果没有指定具体的数据库,那么默认会操作0号库
场景：应该是当for循环正常结束，则才运行else里的语句。反之，当for循环没有正常运行则，不执行else的语句。
长见识了，python 里居然有 for…else语法。
for 临时变量 in 序列:
重复执行的代码
…
else:
循环正常结束后要执行的代码
Break是终止循环，一旦遇到break就代表循环是非正常结束的，因为break是终止循环这个时候else之后的的代码是不执行的。Continue指的是退出当前一次循环继而继续下一次循环，这样continue循环是正常结束的，else之后的的代码是正常执行的。
参考文章https://blog.csdn.net/weixin_48728769/article/details/123796020
一交换机下接了两个无线路由器，现在交换机的网段是192.168.0.x。
路由器1的网段是192.168.1.x，路由器2的网段是192.168.2.x。
则路由器1与路由器2下的设备，可以访问交换机下的设备（即192.168.0.x网段）。
而交换机下的设备，不能访问路由器1和路由器2下的设备。
列如路由器2下的一windows主机192.168.2.66 可以直接通过ssh连接到交换机下的一Linux服务器192.168.0.77。
该windows主机可以ping通该Linux服务器（即在192.168.2.66机器可以ping通192.168.0.77）
但是在该Linux服务器不能ping通该windows主机（即在192.168.0.77机器不能ping通192.168.2.66）
实际工作中，经常遇到一些需要很长时间才能完成的任务，例如压缩一个40G的目录，或者复制很大的文件。这些操作耗时很长，操作人员一般需要一直等待，直到它执行完毕。否则，可能会因为电脑锁屏、服务器ssh链接断开而导致任务执行失败。
在linux系统里有一个命令，screen，可以很好地解决这个问题。可以通过screen，将执行的命令放到screen后台任务里，screen任务作为一个进程在服务器后台执行。设置好screen任务后，可以退出服务器去做其他事情，等时间差不多了，再来查看放在screen的任务。
一般情况下，只要没有人去kill你的screen任务进程，服务器也没有关机或重启操作，screen任务都会平稳运行。
screen的使用实现了长耗时任务的无人值守，解放了操作者的双手，节省了时间，是IT民工必备的技能之一。
下边简单说下screen的用法
————————————————
版权声明：本文为CSDN博主「CwSunlit」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_43557605/article/details/120265864
https://blog.csdn.net/weixin_43557605/article/details/120265864
docker ps -a
看到某个容器没起来，状态 Exited (0) 2 hoours ago
这个时候，一般重启容器就可以了
docker restart 容器id或容器名称
1.dataframe筛选：
df = df[df[‘person_id’]==‘testid1234’]
2.筛选后定位：
gender=df[‘gender’].iloc[0]
因为筛选后，index不是0了，所以要加个iloc[0]来定位。
df[‘gender’][0] 定位不到。
1.axis
lambda和dropna默认都是axis=0，lambda的axis=0是列操作，dropna的axis=0是行操作。
df.apply(lambda x: test_func(x),axis=1)
df=df.dropna()
mysql DATE_FORMAT: 格式化日期
DATE_FORMAT(NOW(),‘%b %d %Y %h:%i %p’)
DATE_FORMAT(NOW(),‘%m-%d-%Y’)
DATE_FORMAT(NOW(),‘%d %b %y’)
DATE_FORMAT(NOW(),‘%d %b %Y %T:%f’)
dataframe筛选案例：
df_w_cal= df_w[df_w[‘statistic_date’]>=dt.datetime.strptime(min_statistic_date,“%Y-%m-%d”).date()]
make 编译
make install 安装
make install PREFIX=/usr/local/share/reids 安装到特定目录
make distclean 清除上次编译（为了下一次干净编译）
make install PREFIX=/usr/local/share/redis
之前使用安装包安装gcc 4.4.7，然后make编译redis 2.8.9的时候报错，猜想是不是gcc版本太低了。(其中cc链接自gcc)
cc: error trying to exec ‘cc1’: execvp: 没有那个文件或目录
手动编译指定版本gcc：
Linux 安装指定版本GCC方法：
https://blog.csdn.net/qq_33438733/article/details/79983141
https://blog.csdn.net/liboyang71/article/details/77152577
直接去/etc/yum.repos.d/CenOS-Base.repo配置yum’源，然后yum install gcc。再编译redis就可以了。
yum安装gcc是4.8.5。
(结论：要么就是gcc版本，要么就是4.4.7那个安装方式没安全。)
rpm -e 包名
rpm卸载软件
mkdir -p /usr/redis/redis-2.8.17/
-p参数，父目录不存在的时候，一并创建父目录
Python报错：
ValueError: unsupported format character ‘?’ (0x5927) at index 134
原因：一般是因为sql语句文本里有百分号%，导致不能识别是输出内容还是特殊符号。
方案：在文本百分号%后面再加个百分号%，就可以了。
向下取整 int() 函数
四舍五入round() 函数
向上取整math.ceil()
分别取整数部分和小数部分math.modf()
这个写法有意思
source_ids = ‘,’.join([“'”+x+“'” for x in df_source_id[‘source_id’].tolist()])
用内网是真的快！！！！
导出mysql文件：
nohup mysqldump --skip-lock-tables -h 192.168.1.2 -P 1314 -utest_user -p’test_password’ test_database test_biao_name >test.sql &
导入sql文件：
inux下mysql导入sql文件方法1
进入linux命令命令行下
mysql -uroot -p 回车 输入密码
source fileName.sql
注意fileName.sql要有路径名，例如：source /home/user/data/fileName.sql
我服了，我发现mysqldump命令加密码的时候，生成的sql文件不能用。。可能和首行的无效输出信息有关系。
交互式命令可以。。。。。
sed -i ‘1,nd’ 文件名 删除文件 1到n行
headers_scrapy = {
‘Content-Type’: ‘application/json’,
‘Authorization’: ‘Basic xxxxxxxxxx’,
“Accept-Language”: “zh-CN,zh;q=0.9”
}
jenkins请求头里Authorization的值是 账号:密码 然后进行base64加密后的结果，可以用来进行当jenkins爬虫的请求头
我傻了，一定不能设置DNS为8.8.8.8，这个是谷歌的DNS服务器，速度太慢了，之前只觉得好记忆，没想到这个是外网的，速度这么慢。。。。
kubectl describe pod pod_name -n namespace 看报错信息
k8s任务一直处于Pending状态，是因为yaml文件里要求资源太高，可以适当降低yaml文件里的资源要求。（request的资源就被该任务锁住了，其他任务不能用）
Warning FailedScheduling default-scheduler 0/5 nodes are available: 1 node(s) had taint {node.kubernetes.io/unreachable: }, that the pod didn’t tolerate, 1 node(s) were unschedulable, 2 Insufficient cpu, 2 Insufficient memory.
Warning FailedScheduling default-scheduler 0/5 nodes are available: 1 node(s) had taint {node.kubernetes.io/unreachable: }, that the pod didn’t tolerate, 1 node(s) were unschedulable, 2 Insufficient cpu, 2 Insufficient memory.
Warning FailedScheduling default-scheduler 0/5 nodes are available: 1 node(s) had taint {node.kubernetes.io/unreachable: }, that the pod didn’t tolerate, 1 node(s) were unschedulable, 2 Insufficient memory, 3 Insufficient cpu.
可能因为网络等原因clone不下来，可以循环50次自动克隆：
for i in {1…50}; do git clone --depth=1 http://xxxxxx.git; done
10天前日期：
dt.datetime.today() - dt.timedelta(10)
安装cv2:
pip install opencv-python
代码里导入cv2:
import cv2
从数据库里找每条基金的最小成立日期：select fund_id, min(statistic_date) statistic_date from fund_nv_data_standard group by fund_id
去除重复数据——drop_duplicates
去除指定单列或多列中的完全重复的项通过drop_duplicates()函数实现，需要利用Pandas包。
其中：
1、subset=[] 表示整个dataframe基于[]内选定列进行数据重复内容识别，可以添加多列数据进行识别。
（1）添加一列列名时表示对选中的单列数据进行重复数据识别，
（2）添加多列时则表示识别多列数据同时重复的情况；
2、keep=‘’ 表示对选中的重复数据操作策略，可选择的参数为’first’、'last’和’False’三种。
（1）'first’表示在识别的重复项中保留按照索引顺序的第一个内容，其余删除，
（2）'last’表示在识别的重复项中保留按照索引顺序的最后一个内容，其余删除，
（3）'False’表示删除所有重复项；
3、inplace= 表示对处理好的dataframe存储策略，可选择参数为False和True
（1）False表示不对原始数据进行去重工作，例如示例代码中data1内容不改变，将处理结果赋予data参数中，
（2）True表示去重工作直接在原始数据中进行操作，例如示例代码中data1中去重操作会直接在data1中进行，data不会被赋值。
data = data1.drop_duplicates(subset=[‘列名1’,‘列名2’], keep=‘first’, inplace= False)
————————————————
版权声明：本文为CSDN博主「羊羊麾下的发电站」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/gisaavg/article/details/124516669
confined.
Dataframe 的 set_index 方法可以将一列设置为索引，这样可以更方便地选择和操作数据。例如：
复制
import pandas as pd
df = pd.DataFrame({‘A’: [1, 2, 3], ‘B’: [4, 5, 6]}, index=[‘a’, ‘b’, ‘c’])
df = df.set_index(‘A’)
print(df)
sort_values() 函数说明
pandas库的 sort_values() 函数可以对 Dataframe 的数据集按照某个字段中的数据进行排序。该函数可以指定列数据或行数据进行排序，可以是单个，也可以是多个。
https://blog.csdn.net/BlueWhale52/article/details/119187311?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522167832983716800184120140%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=167832983716800184120140&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2alltop_click~default-1-119187311-null-null.142v73insert_down3,201v4add_ask,239v2insert_chatgpt&utm_term=dataframe%20sort_values&spm=1018.2226.3001.4187
nginx 报错：nginx: [warn] the “ssl” directive is deprecated, use the “listen … ssl” directive instead
nginx升级版本之后，原来配置的所有ssl的站点全都报警告
解决办法：
在nginx的配置文件中，
将原来的ssl on注释掉或者删除
将原来的listen 443;修改成listen 443 ssl;
注意，两点都需要，如果只是将ssl on注释掉，不修改listen，测试语法的时候，是没有告警，重启nginx也没有问题，但是访问网站的时候会显示网站不是安全链接，即ssl配置没有生效。
————————————————
版权声明：本文为CSDN博主「unreachableO」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_44972135/article/details/106621593
https://blog.csdn.net/qq_36908872/article/details/127284896
https://www.jianshu.com/p/ccf365361738
给阿里云服务器(Centos6.8 64位)配置https，安装证书的时候，报错了：
nginx: [emerg] unknown directive “ssl” in /usr/local/nginx/conf/con.d/xxx.conf:8
大概意思是找不到或者，没有安装OpenSSL，但是我whereis openssl，是能找到的，那应该就是没有配置openssl，
然后就重新配置一下：
进入Nginx安装目录：cd /usr/local/src/nginx-1.10.3
./configure --with-http_ssl_module
make
cp /usr/local/nginx/sbin/nginx /usr/local/nginx/sbin/nginx.bak，然后输入Y
覆盖旧的：cp objs/nginx /usr/local/nginx/sbin/nginx
测试一下是否成功：/usr/local/nginx/sbin/nginx -t ，如图代表成功
重启Nginx（cd /usr/local/nginx/sbin，./nginx -s reload）
————————————————
版权声明：本文为CSDN博主「闹灬爷」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/Maple_abao/article/details/82383004
https:// 走ip显示不安全，走域名显示安全。
查看端口使用
netstat -lntp
docker查看容器完整command的命令:
打印全称
就是在显示容器列表的命令后面加上–no-trunc，大概是不省略的意思
比如
docker ps -a --no-trunc
https://blog.csdn.net/drnrrwfs/article/details/124173679
防踩坑
防踩坑：出现Docker挂载主机目录访问出现cannot open directory.: Permission denied…
解决办法：在挂载目录后多加一个–privileged=true参数即可。
出现上面问题的原因是：通常情况下Linux系统会把不安全的项禁止掉，目录挂载的操作默认情况下被看作是不安全的行为。即在SELinux里面挂载目录被禁止掉了，如果要开启，我们通常需要使用–privileged=true命令，来扩大容器的权限解决挂载目录没有权限的问题。其实上面这个过程可以理解为：将容器内部的root拥有本地主机的root权限，不然容器内部的root只是外部的一个普通用户。
————————————————
版权声明：本文为CSDN博主「嵌入式技术」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_37926734/article/details/123278466
（解决方案：见116）
SELinux is preventing /bin/touch from write access on the 目录 /home/jenkins_home.
***** 插件 catchall (100. 置信度) 建议 ********************************************
如果你相信 touch应该允许_BASE_PATH write 访问 jenkins_home directory默认情况下。
Then 应该将这个情况作为 bug 报告。
可以生成本地策略模块以允许此访问。
Do
暂时允许此访问权限执行：
ausearch -c ‘touch’ --raw | audit2allow -M my-touch
semodule -i my-touch.pp
报错：Got permission denied while trying to connect to the Docker daemon socket at unix:///var/run/docker.sock: Get http://%2Fvar%2Frun%2Fdocker.sock/v1.26/containers/json: dial unix /var/run/docker.sock: connect: permission denied。
可能原因一：使用了非root用户启用或连接docker
>>> Docker进程使用Unix Socket而不是TCP端口，而默认情况下，Unix socket属于root用户，因此需要root权限才能访问。
复制代码
sudo groupadd docker #添加docker用户组
sudo gpasswd -a $XXX docker #检测当前用户是否已经在docker用户组中，其中XXX为用户名。
sudo gpasswd -a $USER docker #将当前用户添加至docker用户组
newgrp docker #更新docker用户组
https://www.cnblogs.com/leozhanggg/p/11730189.html
解决方案：
防踩坑：出现Docker挂载主机目录访问出现cannot open directory.: Permission denied…
解决办法：在挂载目录后多加一个–privileged=true参数即可。
出现上面问题的原因是：通常情况下Linux系统会把不安全的项禁止掉，目录挂载的操作默认情况下被看作是不安全的行为。即在SELinux里面挂载目录被禁止掉了，如果要开启，我们通常需要使用–privileged=true命令，来扩大容器的权限解决挂载目录没有权限的问题。其实上面这个过程可以理解为：将容器内部的root拥有本地主机的root权限，不然容器内部的root只是外部的一个普通用户。
————————————————
版权声明：本文为CSDN博主「嵌入式技术」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_37926734/article/details/123278466
Docker docker + selenium + jenkins 并行跑自动化测试
https://testerhome.com/topics/16605
scrapy中关于Splash的使用:
https://blog.csdn.net/Lijuhao_blog/article/details/89070929
为什么要学习Splash？
我们经常使用scrapy框架编写爬虫代码，站在巨人的肩膀上感觉很好，但是一旦遇到网站用JavaScript动态渲染，scrapy就显得有些力不从心了，我们了解的selenium可以完成动态加载，返回浏览器渲染后的页面，今天我们不讲selenium，Scrapy-Splash（是一个Scrapy中支持JavaScript渲染的工具）同样可以完成这件事，下面我们来说说Splash如何与Scrapy进行对接。
————————————————
版权声明：本文为CSDN博主「ljhyigehaoren」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/Lijuhao_blog/article/details/89070929
chpasswd命令：真好用
runoob@runoob:~$ cat Dockerfile
FROM centos:6.7
MAINTAINER Fisher “[email protected]”
RUN /bin/echo ‘root:123456’ |chpasswd
RUN useradd runoob
RUN /bin/echo ‘runoob:123456’ |chpasswd
RUN /bin/echo -e "LANG=“en_US.UTF-8"” >/etc/default/local
EXPOSE 22
EXPOSE 80
CMD /usr/sbin/sshd -D
https://www.runoob.com/docker/docker-image-usage.html
docker 文档：
https://www.runoob.com/docker/docker-tutorial.html
excel表格前面的0如何显示：
1.打开excel表格
首先打开excel表格，在需要的单元格上方单击右键，选择“设置单元格格式”。
2.选择“文本”
在设置单元格格式对话框中，数字分类选择“文本”选项，确定即可在数字前方输入0。
3.完成
或者直接在01前方输入多一个”英文’号“，回车即可成功显示前方的0。
https://jingyan.baidu.com/article/5d6edee2ec6dc4d8eadeeca6.html
linux系统解决boot空间不足
ubuntu：
1、查看当前使用内核版本号
uname -a（完整版）
uname -r（精简版）
2、查看已安装的内核版本号
dpkg --get-selections | grep linux
3、删除内核
apt-get purge …
centos：
1、查看当前使用内核版本号
uname -a（完整版）
uname -r（精简版）
2、查看已安装的内核版本号
rpm -qa | grep kernel
3、删除内核
yum remove …
https://www.likecs.com/show-305926883.html
原文链接：https://www.cnblogs.com/anzerong2012/p/6354436.html
我认为以后装系统，要把/boot分区搞大点，200M实在不够，不然要一直删老内核。。。。。。
centos中如何安装中文输入法？
使用命令 管理员权限运行yum install ibus-libpinyin安装，若提示软件已经是最新版本就不用安装，一般来说，系统都会默认安装了ibus-libpinyin。然后是添加系统设置中添加中文输入法：设置---->Region & Language界面下，点击“+”添加输入法，选中“汉语（中国）” ，回弹出下一个界面然后选择 “汉语（Intelligent Pinyin）”，然后便可以在桌面上方的工具栏中进行输入法切换，也可以使用shift切换。
————————————————
版权声明：本文为CSDN博主「qq_41210639」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_41210639/article/details/115263611
不用安装，直接改设置真方便。
Centos7安装无线网卡驱动(No Wi-Fi Adapter Found):
进入QCA9377 目录下，看看有什么版本：
cd /lib/firmware/ath10k/QCA9377/hw1.0/
firmware-5.bin 和 firmware-6.bin 两个版本的固件文件，
若是，则删掉firmware-6.bin，保留firmware-5.bin。
然后重启电脑，wifi设备就又可以正常工作了。
https://www.cnblogs.com/wutou/p/16777165.html
真详细的centos安装教程，但是为什么我的网络设置显示找不到wifi adapter。。。。不知道是不是和驱动有关系。（解决方案：见126）
物理服务器安装CentOS 7操作系统
https://blog.csdn.net/qq_33427869/article/details/126668794
装centos前不能分区，不然显示空间不够，要先删除分区，删除分区可以通过救援模式删。
磁盘分区后提示：sda必须有一个gpt磁盘标签的解决办法。
https://mnews.68idc.cn/jiabenmake/qita/20150108163219.html
选择"Troubleshoot"选项。
选择"Rescue a Centos system"，进入到救援系统。
模式下选择"Continue"，继续进入系统。
此时，就可以来到CD/DVD提供的文件系统下。而原本的磁盘系统则存放再/mnt/sysimage目录下。等待系统修复完成，就可以通过chroot切换到磁盘系统文件系统下了。
怎么删除原本的分区，因为原本分区跑系统的时候就运行了，现在可以插个u盘救援模式，就可以不管物理机的系统了，相对于一个移动系统直接操作物理机磁盘。
通过蓝牙可以共享网络，长见识了
1.安装centos系统。
如果过程中出现：
Entering emergency mode exit the shell to continue. Type “journalctl” to view system logs.
解决方法：
这时在提示符下输入以下两行命令
cd dev
ls
在出现的几列字符中找到sdb和sdb#，其中#代表某个数字，sdb#表示系统为你正在使用的U盘分配的盘符。（记下这个数字）
输入reboot重启系统，再选择USB启动，
在出现的安装菜单中按tab(如果tab没反应，按e，有提示的，按e键），会在下面出现一列字符。
initrd=initrd.img inst.stage2=hdABEL=CentOS\x207\x20x86_64 quiet
把上面的改为下面的
注意，这个4就是刚刚记的数，如果是其他的数就改为其他的
initrd=initrd.img inst.stage2=hd:/dev/sdb4 quiet
按enter(回车)或者ctrl-x进入启动界面。
————————————————
版权声明：本文为CSDN博主「hell_haita」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/hell_haita/article/details/102564387
安装liunx出现Entering emergency mode
https://blog.csdn.net/hell_haita/article/details/102564387
ultraiso官网：
https://cn.ultraiso.net/xiazai.html
制作u盘启动盘:UltralSO 软碟通制作U盘启动盘（图解详细 完美避坑
https://blog.csdn.net/qq_43901693/article/details/95535051?ops_request_misc=&request_id=&biz_id=102&utm_term=%E5%88%B6%E4%BD%9Cu%E7%9B%98%E5%90%AF%E5%8A%A8%E7%9B%98&utm_medium=distribute.pc_search_result.none-task-blog-2allsobaiduweb~default-1-95535051.142v73insert_down4,201v4add_ask,239v2insert_chatgpt&spm=1018.2226.3001.4187
information_schema!!! 获取表、列信息
import sys
sys.path.appen(r’C:\Users\DELL\Desktop\IndexCalculation’)
python脚本文件加入这两行（路径为具体项目路径），就可以在cmd里跑项目里的脚本了，如果不加这两行，那么有时候导入项目里的包时，会报错，。所以一定要在代码里标识项目路径，然后再在cmd里运行脚本
import sys
sys.path.append(‘…/projectname’)
这样更方便，自动识别项目路径
python包 Sklearn安装：
pip install scikit-learn
https://blog.csdn.net/Xingchen0101/article/details/126332660?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522167720747116800186574045%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=167720747116800186574045&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2alltop_positive~default-3-126332660-null-null.142v73insert_down3,201v4add_ask,239v2insert_chatgpt&utm_term=sklearn&spm=1018.2226.3001.4187
#获取所有记录 fetchall–获取所有记录 fetchmany–获取多条记录，需传参 fetchone–获取一条记录
sql_date = “”“select MIN(statistic_date) from fund_month_risk “””
res=engine_2g_base_du().execute(sql_date)
a=res.fetchone()
all=res.fetchall()
https://blog.csdn.net/weixin_43977279/article/details/124083828?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522167720295216800225544102%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=167720295216800225544102&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2alltop_positive~default-2-124083828-null-null.142v73insert_down3,201v4add_ask,239v2insert_chatgpt&utm_term=python%20mysql&spm=1018.2226.3001.4187
argv: argumentsvalue 参数值
Python 中也可以使用 sys 的 sys.argv 来获取命令行参数：
sys.argv 是命令行参数列表。
len(sys.argv) 是命令行参数个数。
注：sys.argv[0] 表示脚本名。
#!/usr/bin/python
import sys
print ‘参数个数为:’, len(sys.argv), ‘个参数。’
print ‘参数列表:’, str(sys.argv)
执行以上代码，输出结果为：
$ python test.py arg1 arg2 arg3
参数个数为: 4 个参数。
参数列表: [‘test.py’, ‘arg1’, ‘arg2’, ‘arg3’]
https://www.runoob.com/python/python-command-line-arguments.html
这种写法有意思：
df_bd = pd.DataFrame([infos[‘seriesData0’], infos[‘seriesData1’], infos[‘xAxisData’]],index=[‘return_10k’, ‘d7_return_a’, ‘statistic_date’]).T
pycharm 创建venv虚拟环境
https://www.likecs.com/show-306062469.html
venv环境真好用，apply 应用一下才生效，不要把本机环境搞乱了！！！！
在pycharm的file-setting中选中project，然后点击project interpreter的右侧点击添加按钮。
（2）输入基于哪个python版本创建虚拟环境，环境的路径选择项目路径下，点击ok就可以创建新的虚拟环境。
在项目路径下就有会生成一个venv路径 D:\Project\python\handson-ml-master\venv
项目的依赖库package保存在路径D:\Project\python\handson-ml-master\venv\Lib\site-packages下，是这个项目工程的依赖库。
（2）点击manager resposities，设置新的镜像
（3）设置下载库的网址镜像为豆瓣镜像，原有的镜像太慢会出错
pip install -r requirements.txt 终端输命令时，要先确定现在是虚拟环境，不然有可能影响到本机实际环境。
(venv) F:\test\project_test> (venv)来判断是虚拟环境
pip install -i http://pypi.douban.com/simple/ numpy 单条命令国内源
阿里源更好些
pip install -i http://pypi.douban.com/simple/ -r requirements.txt
pip install pandas==0.24.2 -i http://pypi.douban.com/simple/ --trusted-host pypi.douban.com
要添加信任才能用
https://mirrors.aliyun.com/pypi/simple/ 阿里源
TensorFlow错误：TypeError: init() got an unexpected keyword argument ‘serialized_options’
问题其实很简单，TensorFlow和protobuf的版本不匹配，
我的TensorFlow和protobuf版本：
tensorflow 1.13.0rc1
protobuf 3.1.0
1.
2.
3.
tensorflow 1.13.0rc1需要的是protobuf 3.6.1，所以不匹配，
具体的解决步骤：
pip3 uninstall protobuf
pip3 uninstall tensorflow
pip3 install tensorflow
1.
2.
3.
4.
5.
新的问题
paddlepaddle,百度自主研发,真正源于产业实践,易学易用,安全高效分布式深度学习框架。
paddlepaddle 1.2.1 has requirement protobuf==3.1
很头疼，两个深度学习框架需要的protobuf版本不一样。
所以，自己决定吧。
（支持国产）
©著作权归作者所有：来自51CTO博客作者wx5e46005fc4d21的原创作品，请联系作者获取转载授权，否则将追究法律责任
TensorFlow错误：TypeError: init() got an unexpected keyword argument ‘serialized_options’
https://blog.51cto.com/u_14691718/5141408
https://blog.51cto.com/u_14691718/5141408
tensorflow2.0.0
protobuf3.6.1
keras==2.3.1
这一对好像可以
tensorflow 1.5 --------------- protobuf 3.4
tensorflow 1.12 --------------- protobuf 3.6
tensorflow 1.10 --------------- protobuf 3.6
tensorflow 1.0.0 --------------- protobuf 3.1
tensorflow 0.12 --------------- protobuf 3.1
tensorflow 0.11 --------------- protobuf 3.0.2
我的联想设备
f12进入boot manager menu。
f2进入bios
小技巧：联想所有的笔记本基本都有boot manager的功能，即可以直接按F12键打开引导管理器，直接选择启动设备，而不需要进入BIOS来设置引导 ，在安装系统的时候这样可以节省时间。
还有就是跑大量指标时，redis与mysql配合使用，来达到既保留了断点功能，而且还可以多台电脑同时读取redis数据，不用像读mysql那样需要分段跑指标，避免了要一直为了平分数量而改sql。reids读一条，弹一条，比mysql快
pd.date_range获取月末日期真的很方便
date_range时间序列–时间切片
pd.date_range(start=‘20220101’, periods=10, freq=‘M’)
#输出
DatetimeIndex([‘2022-01-31’, ‘2022-02-28’, ‘2022-03-31’, ‘2022-04-30’,
‘2022-05-31’, ‘2022-06-30’, ‘2022-07-31’, ‘2022-08-31’,
‘2022-09-30’, ‘2022-10-31’],
dtype=‘datetime64[ns]’, freq=‘M’
————————————————
版权声明：本文为CSDN博主「Python当打之年」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_42152811/article/details/124040862
https://blog.csdn.net/weixin_42152811/article/details/124040862?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522167694531516800211539571%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=167694531516800211539571&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2alltop_click~default-1-124040862-null-null.142v73insert_down2,201v4add_ask,239v2insert_chatgpt&utm_term=date_range&spm=1018.2226.3001.4187
netstat -tunlp | grep 端口号是查看所查询的端口号情况
https://blog.csdn.net/m0_67392182/article/details/124290054?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522167662950716782429740730%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=167662950716782429740730&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2alltop_positive~default-2-124290054-null-null.142v73wechat,201v4add_ask,239v2insert_chatgpt&utm_term=linux%E6%9F%A5%E7%9C%8B%E7%AB%AF%E5%8F%A3&spm=1018.2226.3001.4187
disk_unit=$(lsblk |egrep '^(v|s)d[a-z]' |awk '{print $4}' |sed -n '1p' |sed 's/\(.*\)\(.\)$/\2/')
disk_space=$(lsblk |egrep '^(v|s)d[a-z]' |awk '{print $4}'|sed 's/[a-Z]//'|awk '{disk[$1]++} END {for(i in disk){print i}}' |awk '{sum +=$1};END{print sum}')
echo "磁盘总空间为${disk_space}${disk_unit}"
linux计算磁盘总空间
https://blog.51cto.com/u_4820306/5424712
lsblk |egrep '^(v|s)d[a-z]' |awk '{print $4}'|sed 's/[a-Z]//'|awk '{disk[$1]++} END {for(i in disk){print i}}' |awk '{sum +=$1};END{print sum}'
split()函数介绍:
https://blog.csdn.net/weixin_46655865/article/details/115657910?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522167635794916800182134365%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=167635794916800182134365&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2alltop_positive~default-1-115657910-null-null.142v73control,201v4add_ask,239v1control&utm_term=split%E5%87%BD%E6%95%B0&spm=1018.2226.3001.4187
问题：<twisted.python.failure.Failure OpenSSL.SSL.Error: [(‘SSL routines’, ‘’, ‘unsafe legacy renegotiation disabled’)]>
-
没有添加请求头
只需要添加请求头即可 -
版本问题
需要查看自己两个库的版本pyOpenSSLcryptography
这两个库的版本必须完美卡在一个版本区间
比如 PyOpenSSL如果在21.0.0 以上 即失败
cryptography，如果安装最新也会失败
执行一下命令
pip install cryptography==3.4.8
pip install pyOpenSSL==21.0.0
————————————————
版权声明：本文为CSDN博主「始識」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/Zuko_chen/article/details/128125506
pip install cryptography==3.4.8
pip install pyOpenSSL==21.0.0
step over 不进入函数，直接下一步
strftime与strptime
https://blog.csdn.net/Han_torch/article/details/121251202?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522167600034516800188592352%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=167600034516800188592352&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2allfirst_rank_ecpm_v1~rank_v31_ecpm-7-121251202-null-null.142v73pc_search_v2,201v4add_ask,239v1insert_chatgpt&utm_term=python%E6%97%B6%E9%97%B4%E6%A0%BC%E5%BC%8F%E8%BD%AC%E6%8D%A2&spm=1018.2226.3001.4187
loc匹配时，index不一定是0，这时候用iloc[0,0]刚好可以匹配上。
bond_list=[[c.split(“,”)[0],self.df_mapping[self.df_mapping[‘bond_name’]==c.split(“,”)[0]].iloc[0,0]], [c.split(“,”)[1],self.df_mapping[self.df_mapping[‘bond_name’]==c.split(“,”)[1]].iloc[0,0]]]
http://t.csdn.cn/dIOHK
http://t.csdn.cn/Xzwbw
原来nan是float类型：
当判断是否为空时，有时候为nan，但是
if not my_value好像不能找出nan值，而且试过 if my_value==np.nan好像也无效。试过以下方式有效，可以记录一下：
1.numpy判断
import numpy as np
nan = float(‘nan’)
print(np.isnan(nan))
2.pandas判断
import pandas as pd
nan = float(‘nan’)
print(pd.isna(nan))
3.math判断
import math
nan = float(‘nan’)
print(math.isnan(nan))
————————————————
版权声明：本文为CSDN博主「羸弱的穷酸书生」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/zy1620454507/article/details/126950041
Python爬虫：Scrapy的get请求和post请求
原文链接：https://blog.csdn.net/mouday/article/details/83859158
(发现请求时：https能出结果，用http出不了结果，第一次发现还有这种情况)
data = {
“pageNo”: 1,
“pageSize”: 100000,
“nvTp”: “01”
}
requests.post(“url”,data=data,headers=headers)
平时一般data都是要加双引号，但是这个加双引号不行，不能加双引号。
不知道这个是不是就是json格式与表单格式的区别
总结
请求方式 使用方法 headers参数 参数 服务器端接收到参数
get Request - ?name=tom args
post FormRequest 有默认值 formdata={“name”: “Tom”} form
post Request - body=json.dumps({“name”: “Tom”}) data，json
post Request “Content-Type”: “application/x-www-form-urlencoded” body=json.dumps({“name”: “Tom”}) form
post Request “Content-Type”: “application/json”, body=json.dumps({“name”: “Tom”}) data， json
————————————————
版权声明：本文为CSDN博主「彭世瑜」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/mouday/article/details/83859158
scipy.optimize.minimize求解有无约束的最小化问题
http://t.csdn.cn/AKRPh
MySQL mysql的sql查询语句中使用is null、is not null
chromedriver国内源网站：
https://registry.npmmirror.com/binary.html?path=chromedriver/
selenium定位加遍历html的div：
#定位出同个路径下所有的 span 信息
data_1 = driver.find_elements(By.XPATH,“//*[@class=‘mu-afte fl’]/ul/li/a/span”)
#定位出同个路径下所有的 num 信息
data_2 = driver.find_elements(By.XPATH,“//*[@class=‘mu-num’]”)
#定位出同个路径下所有的 unit 信息
data_3 = driver.find_elements(By.XPATH,“//*[@class=‘mu-unit’]”)
#进行遍历，并打印出文本信息
for i in range(len(data_1)):
print(data_1[i].text,data_2[i].text,data_3[i].text)
1、由于几个元素所在的位置都是在相同的结构下，所以可以通过定位到一组元素，再通过遍历进行获取
2、遍历的次数是获取的列表数据的长度
3、遍历后需要用 text来获取到文本信息
https://blog.csdn.net/OrangeTreeTest/article/details/124274980?ops_request_misc=&request_id=&biz_id=102&utm_term=selenium%20%E6%80%8E%E6%A0%B7%E8%BF%AD%E4%BB%A3div&utm_medium=distribute.pc_search_result.none-task-blog-2allsobaiduweb~default-2-124274980.142v70control,201v4add_ask&spm=1018.2226.3001.4187
selenium获取cookie后，如何传递给requests?
https://coding.imooc.com/learn/questiondetail/33720.html
利用selenium携带cookies实现免登录：
https://blog.csdn.net/weixin_43821172/article/details/105199481
cookie = browser.get_cookies()
browser.quit()
cookie_dict = {}
for i in cookie:
cookie_dict[i[“name”]] = i[“value”]
print(cookie_dict)
selenium之options模块：
https://blog.csdn.net/zzrs_xssh/article/details/106006939?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522167342981416800192284911%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=167342981416800192284911&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2allsobaiduend~default-2-106006939-null-null.142v70control,201v4add_ask&utm_term=21-selenium%E4%B9%8Boptions%E6%A8%A1%E5%9D%97&spm=1018.2226.3001.4187
判断是不是日期格式，进而方便下一步区分处理：
def is_valid_date(strdate):
‘’‘判断是否是一个有效的日期字符串’‘’
try:
time.strptime(strdate, “%Y-%m-%d”)
return True
except:
return False
sql性能优化：
SELECT statistic_date from my_table where fund_id=‘000072’ and bianhao_id=‘ece0ef5138aa677f5e4b2a883580e203’
耗时：0.2秒
SELECT statistic_date from my_table where bianhao_id=‘ece0ef5138aa677f5e4b2a883580e203’
耗时：42秒
增加了筛选条件，耗时反而大大减少
164.（低版本的pandas==0.24.2时，读取xlsx方法）
使用BytesIO对象，声明流为bytes类型：read_excel报错：
must explicitly set engine if not passing in buffer or path for io。
res = requests.get(url)
BytesIO = pd.io.common.BytesIO
df = pd.read_excel(BytesIO(result.content))
或者
from pandas.io.common import BytesIO
df = pd.read_excel(BytesIO(result.content))
https://blog.csdn.net/MacwinWin/article/details/107611256
https://blog.csdn.net/weixin_40647516/article/details/123783668
datafrme 条件筛选之query： 好用！！！！
可以使用外部的变量
#查询温度在这两个温度之间的数据
high_temperature = 15
low_temperature = 13
1
2
3
df.query(“yWendu<=@high_temperature & yWendu>=@low_temperature”).head()
————————————————
版权声明：本文为CSDN博主「北山啦」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_45176548/article/details/112755795
merge根据某列合并其他列：
pd.merge(left, right, how=‘left’, on=[‘key1’, ‘key2’])
left 左表，合并对象，DataFrame或Series
right 右表，合并对象，DataFrame或Series
how 合并方式，可以是left(左合并), right(右合并), outer(外合并), inner(内合并)
on 基准列 的列名
left_on 左表基准列列名
right_on 右表基准列列名
left_index 左列是否以index为基准，默认False，否
right_index 右列是否以index为基准，默认False，否
————————————————
版权声明：本文为CSDN博主「侯小啾」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_48964486/article/details/123387448
df_ty=df_ty.drop([‘type’,‘stype’],axis=1)
删除多列
删除某列： df=df.drop(‘org_full_name’,axis=1)
axis=1删某列，axis，删除行
dataframe列的重命名
df.rename(columns = {“old_name”: “new_name”}
pandas中如何提取DataFrame的某些列:
http://t.csdn.cn/LeKBa
列：df=df[[‘course2’,‘fruit’]]
df_ty=df_ty.dropna(subset=[‘dimension’, ‘type_code’, ‘type_name’, ‘stype_code’, ‘stype_name’])
某列为空则删除行
缺失值填充：http://t.csdn.cn/5zssD
#使用列1填补列2的缺失值
df[2].fillna(df[0])
fillna默认会返回新对象，但也可以对现有对象进行就地修改：
df.fillna(0, inplace = True)
Python 忽略warning的输出方法:
python -W ignore
这样就可以避免warnings的输出了，但是切记，不要盲目设置取消输出。
Set-Cookie 一天一个小技巧。
http://t.csdn.cn/aOZtD
session = requests.session()应该也可以吧，如果是会话类型
pycharm 替换 快捷键： CTRL + R
r:replace f:find
上月初与本月初日期获取：
last_month=(dt.date.today().replace(day=1)+ dt.timedelta(days=-1)).replace(day=1)
now_month=dt.date.today().replace(day=1)
python 获取本周一日期
import datetime as dt
monday_time = dt.datetime.strftime((dt.date.today()-dt.timedelta(dt.date.today().weekday())), ‘%Y-%m-%d’)
kubectl命令
https://blog.csdn.net/William0318/article/details/117021718
报错：docker: Error response from daemon: endpoint with name xxx already exists in network bridge
第一步，删除容器
docker rm -f xxx（比docker kill xxx更有强制性，如果kill不行就rm -f）
第二步，删除网桥
docker network disconnect --force bridge xxx
（原来不仅要杀容器，还要删除网桥啊！）
https://blog.csdn.net/DaChengXiaoShi/article/details/115173482#:~:text=%E7%AC%AC%E4%BA%8C%E6%AD%A5%EF%BC%8C%E5%88%A0%E9%99%A4,force%20bridge%20xxx
正则表达式
\d+ 表示可以出现1次或是n次数字
. .? 表示可以“.”可以出现一次，也可以不出现
\d* 表示可以出现0次或是n次数字
requests请求报错问题
HTTPSConnectionPool(host=‘fund.chinaamc.com’, port=443): Max retries exceeded with url: /product/fundLishijingzhi.do?fundcode=000041 (Caused by SSLError(SSLError(“bad handshake: Error([(‘SSL routines’, ‘’, ‘wrong signature type’)],)”,),))
https://qa.1r1g.com/sf/ask/4314236881/
import requests
import ssl
from urllib3 import poolmanager
url = 'https://live.euronext.com/fr/product/equities/FR0000120271-XPAR'
class TLSAdapter(requests.adapters.HTTPAdapter):
def init_poolmanager(self, connections, maxsize, block=False):
"""Create and initialize the urllib3 PoolManager."""
ctx = ssl.create_default_context()
ctx.set_ciphers('DEFAULT@SECLEVEL=1')
self.poolmanager = poolmanager.PoolManager(
num_pools=connections,
maxsize=maxsize,
block=block,
ssl_version=ssl.PROTOCOL_TLS,
ssl_context=ctx)
session = requests.session()
session.mount('https://', TLSAdapter())
res = session.get(url)
print(res)
https://github.com/psf/requests/issues/4775
logstash配置之自动重载配置文件
./bin/logstash -f configfile.conf --config.reload.automatic
https://blog.csdn.net/qq_32292967/article/details/78622647
Logstash 参考指南（关闭Logstash）
https://segmentfault.com/a/1190000016592079?utm_source=tag-newest
canny算子
拼图验证码，找缺口坐标(单图版)
https://blog.csdn.net/qq_41871957/article/details/113920564
Docker 容器常见故障排查及处理
https://blog.csdn.net/qq_41958579/article/details/107927140
k8s
警告失败调度80（x8超过9m53s）默认调度程序0/4个节点可用：1个cpu不足，1个节点有污点｛node-role.kubernetes.io/master:｝，pod无法容忍，2个节点有pod无法忍受的污点。
(标记位置2)
mysql的in语法，可以直接format一个tuple进去。
myids=[‘id1’,‘id2’,‘id3’,‘id4’,‘id5’]
tuple_ids = tuple(myids)
sql = “”“SELECT * from test_table where test_id in {} “””.format(tuple_ids)
requests报错：OpenSSL.SSL.Error: [(‘SSL routines’, ‘tls_process_server_certificate’, ‘certificate verify failed’)]
方案：requests.get(url, verify=False)
参考：
这个错误通常是由于 SSL 证书验证失败引起的。SSL 证书验证是一种安全机制，用于确保与服务器建立的连接是可信的。当 SSL 证书验证失败时，可能有以下几个原因：
证书过期或无效：服务器的 SSL 证书可能已过期或被撤销，或者证书链中的某个证书无效。
证书链不完整：服务器的 SSL 证书链中可能缺少必要的中间证书或根证书。
证书主机名不匹配：服务器的 SSL 证书上的主机名与请求的主机名不匹配。
解决此问题的方法通常是更新 SSL 证书或配置，或者禁用证书验证（不推荐）。
如果你在使用 Python 的请求库（例如 requests）时遇到了这个错误，可以尝试以下解决方法：
更新根证书：更新操作系统或 Python 环境中的根证书库，以确保包含最新的根证书。
禁用证书验证：虽然不推荐，但你可以在请求中禁用 SSL 证书验证。在使用 requests 库时，可以通过设置 verify 参数为 False 来实现，例如：requests.get(url, verify=False)。请注意，这会降低连接的安全性，因此请仅在开发或测试环境中使用。
指定证书路径：如果你有服务器的 SSL 证书文件，可以通过在请求中指定证书路径来解决此问题。在使用 requests 库时，可以通过设置 cert 参数为证书文件路径来实现，例如：requests.get(url, cert=‘path/to/certificate.pem’)。
请注意，在生产环境中，确保 SSL 证书验证的正确性非常重要，因此建议仔细检查证书配置和更新证书，以确保安全性。
df = df[df[‘name’].str.len() > 2]
获取df里name长度大于2的数据
假设linux里一个目录叫： xxxx(我的xxxx目录)
那么命令行使用这个目录的时候，要对小括号进行转义。
cd xxxx(我的xxxx目录)
python取上一个周五和周六的日期
import datetime as dt
today = dt.date.today()
current_weekday = today.weekday()
#计算上一个周五的日期
days_to_friday = (current_weekday - 4) % 7
last_friday = today - dt.timedelta(days=days_to_friday)
#计算上一个周六的日期
days_to_saturday = (current_weekday - 5) % 7
last_saturday = today - dt.timedelta(days=days_to_saturday)
print(“上一个周五的日期：”, last_friday)
print(“上一个周六的日期：”, last_saturday)
在tplink路由器里给服务器设置静态IP：
登录网关页面 - 基本设置 - LAN设置 - 客户端列表 - 点击添加到静态IP - 然后剩余租期就变为永久 - 在静态地址分配界面可以看到静态IP
在 Vim 中，可以使用列操作模式来对文本进行高效的编辑。以下是一些常用的列操作命令：
ctrl + v 进入可视块模式，然后使用方向键选择要操作的列。
d 删除选中的列。
c 复制选中的列。
p 将复制的列粘贴到光标下方。
> 将选中的列向右缩进一次。
< 将选中的列向左缩进一次。
= 将选中的列设置为等号后的数值。
:s/foo/bar/g 将选中的列替换为指定的字符串。
这些命令可以在普通模式下输入，也可以在列操作模式下输入。在列操作模式下，命令会作用于选中的列而不是整行。
re.search在Python中取括号里的内容，可以使用正则表达式。
python
复制代码
import re
text = “这是一个例子(需要提取的内容)”
pattern = r’((.*?))’
result = re.search(pattern, text)
if result:
content = result.group(1)
print(content)
else:
print(“未找到匹配内容”)
.* 是贪婪模式，倾向于获取最长的满足条件的字符串；
.* ?是非贪婪模式，倾向于获取最短的能满足条件的字符串。
rsync -avP -e “ssh -i 密钥路径” /xxx/nginx_logs/ 用户名@目标机ip:/xxx/nginx_logs/
这是一个使用rsync命令进行远程同步的示例。它将本地的nginx_logs/目录同步到远程主机的nginx_logs/目录。
-a：表示归档模式，即保留文件属性（如修改时间、权限等）。
-v：表示详细输出，显示同步过程中的详细信息。
-P：表示使用进度条显示同步进度。
-e “ssh -i 密钥路径”：表示使用SSH协议进行连接，并指定私钥文件。
执行该命令后，rsync会将本地的nginx_logs/目录同步到远程主机的nginx_logs/目录。
Rsync是一款开源的、多功能的数据同步备份工具，适用于Unix、Linux、Windows等多种操作系统。它的名字中的"r"代表remote，意为"远程同步"，因此rsync常被用来进行本地计算机与远程计算机之间，或者两个本地目录之间的文件同步，但不支持两台远程计算机之间的同步。
rsync的一大特性是会检查发送方和接收方已有的文件，仅传输有变动的部分，默认规则是文件大小或修改时间有变动。这使得rsync在同步大量文件时，相比其他文件传输工具（如FTP或scp），效率更高。此外，rsync还支持断点续传。
除了文件同步，rsync还可以当作文件复制工具，替代cp和mv命令。它可以在本地主机的不同分区或目录之间全量及增量的复制数据，也可以实现删除文件和目录的功能。
在大多数Linux发行版中，rsync默认是没有安装的，因此需要手动安装。如果需要同步文件夹，需要加上-r选项，即recursive（递归的、循环的）。
isinstance(对象，类名)
判断一个对着是否是一个类的实例。
a=‘test’
res=isinstance(a，str)
a是str类的实例。
调用对象的属性的时候，先找对象的属性，如果找不到，再去找类的同名属性。
对象由id，type和value组成。
类也是一个对象。
类是一个用来创建对象的对象。
类是type类型的对象，定义类实际上就是定义了一个type类型的对象。
装饰器：
def begin_end(old):
def new_func(*args，**kwargs):
print(‘开始’)
result=old(*args，**kwargs)
print(‘结束’)
return result
return new_func
f=begin_end(add)
在定义类或函数时，以下场景会用到*args和**kwargs，前者叫位置参数，后者叫关键字参数\n\n不确定传入参数的数量或形式\n不关心传入参数的数量或形式（此时该类或函数多作为一个中间件的角色，接收参数后只是做了一些预处理，最后将这些参数传递给其他类或函数做进一步处理，如装饰器）
@装饰器，来使用指定装饰器，来装饰当前的函数，可以给一个函数加多个装饰器。
@外层装饰器
@内层装饰器
def func():
pass
先用内层的进行装饰，再用外层装饰器。
@begin_end
def say_hello():
print(‘大家好’)
say_hello()
这时候运行该函数，就不是本来的函数了，是注解后的函数，是被装饰器修改后的函数。
es启动：
elasticsearch/bin/elasticsearch -d
logstash启动：
nohup ./logstash -f …/config/datamonitor.conf --config.reload.automatic --config.reload.interval 60s &
kibana启动：
nohup kibana/bin/kibana &
edge浏览器开启夜间模式
初步设置
打开edge浏览器，点击右上角的三个点，点击->设置
点击，选择左侧外观栏
在系统默认改为深色
此时系统界面进入夜间模式，初步设置夜间模式完成
进阶设置
在初步设置完成后浏览网页依旧正常颜色没有进入夜间模式
此时，可以在浏览器地址栏输入edge://flags/
在搜索栏输入Force Dark Mode for Web Contents
选择enable,点击选择重启浏览器，除图片以外的所有部分进入夜间模式
————————————————
版权声明：本文为CSDN博主「零琴 辉月」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/m0_46230650/article/details/120280448
linux生成随机数：‘test_docker_task_’$RANDOM，这样在docker容器名称就不会重复了。
mysql 如果不存在就入库，存在就更新:
可以使用MySQL的INSERT INTO … ON DUPLICATE KEY UPDATE语句来实现如果记录不存在就插入，存在就更新的操作。
假设有一个名为mytable的表，包含以下字段：id, name, age。其中，id是主键。现在需要向该表中插入一条记录，如果id已经存在，则更新对应的记录。
可以使用如下SQL语句实现：
sql
复制代码
INSERT INTO mytable (id, name, age) VALUES (1, ‘Tom’, 20)
ON DUPLICATE KEY UPDATE name=‘Tom’, age=20;
上述语句中，首先尝试插入一条新记录，如果id为1的记录已经存在，则执行ON DUPLICATE KEY UPDATE后面的语句，将对应记录的name和age字段更新为指定的值。
需要注意的是，为了使用ON DUPLICATE KEY UPDATE语句，必须在表中定义一个唯一索引或主键约束，以确保能够检测到重复的记录。
grant option
拥有grant option，就可以将自己拥有的权限授予其他用户（仅限于自己已经拥有的权限）
mysql> grant Grant option on pyt.* to p1@localhost
mysql> grant select on pyt.* to p2@localhost
————————————————
版权声明：本文为CSDN博主「anzhen0429」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/anzhen0429/article/details/78296814
字符串转为datetime类型，再转为date类型。
import datetime as dt
my_datetime = dt.datetime.strptime(‘2023-10-11’, ‘%Y-%m-%d’)
my_date = my_datetime.date()
RedisCluster连多个redis
from rediscluster import RedisCluster
startup_nodes = [
{“host”: “ip1”, “port”: 端口1},
{“host”: “ip2”, “port”: 端口2},
{“host”: “ip3”, “port”: 端口3},
]
r = RedisCluster(startup_nodes=startup_nodes, password=‘xxxx’)
将使用修改后的文件创建一个新的Docker镜像。可以使用docker commit命令将临时容器转换为镜像。
docker commit temp_container new_image
https://blog.51cto.com/u_16175512/7028200
Python文档字符串：help(func)可以查看文档字符串来得知函数作用。
def func():
‘’’
函数作用，注释说明。
‘’’
pass
闭包条件：
函数嵌套。
将内部函数作为返回值返回。
内部函数需要使用到外部函数的变量。
闭包场景：一些变量需要安全，藏起来的。
闭包：
def func():
a=1
def func2():
print(a)
return func2
r=func()
func2函数给r，r能访问到func函数内的变量。
sort()是一个方法，sorted()是一个函数。
sorted可以对任意序列进行排序，sort()只对列表排序。
sorted()不影响原来的对象，而是返回一个新对象。
其他两者类似。
sort()对列表元素排序：
l=[‘a’,‘c’,‘b’,]
l.sort()
print(l)
sort函数可以传入一个参数key，key接受一个函数，根据这个函数为规则来排序。
l.sort(key=len)
l.sort(key=int)
l.sort(key=str)
map函数，对对象元素做指定操作，然后添加到新对象返回。
l=[1,2,3]
r=map(lambda i :i+1, l)
list®
匿名函数:(lambda a,b :a+b)(10,20)
filter过滤，把满足函数的内容返回。
filter(自定义函数,可迭代的结构)
高阶函数:把函数当参数传进去，实际上是将指定代码传进函数，这样有高度可定制化，传入自己的功能。
命名空间就是个字典，放着变量名和变量值。
通过globals()可以在任意位置获取全局命名空间。(比如函数内部获取外部命名空间)
在代码里使用 locals()获取一个字典，看到当前命名空间的变量名及变量值。
如果希望在函数内使用全局变量，需要使用global声明。(是在要使用的内部区域声明)
a=10
def func():
global a
a=20
func2嵌套在func里，它可以访问到func的变量。(使用变量时，优先在当前作用域寻找，如果有就使用，如果没有可以去上一级作用域寻找。)
def func():
a=1
def func2():
print(a)
func2()
定义函数传入类型和返回类型。
def func(a:int,b:bool,c:str)->int:
return 100
id(变量名)，可以看变量地址，来判断对象是否改变。
先a=[1,2,3,4]，然后a[1]=10，这样赋值，指向对象不变，是改变了对象的值。
先a=[1,2,3,4]，然后a=[1,2,3]，这样是改变了指向的对象。
b=a，第一种情况b值也跟着改变，第二种情况b值不变。
解包：
def func(a,b,c):
pass
t=(1,2,3)
func(*t)
解包2：
def func(a,b,c):
pass
t={‘a’=1,‘b’=2,‘c’=3}
func(**t)
函数调用，形参加个*会传入一个元组。加两个**会传入一个字典。
def func(*a)：
pass
func(1,2,3,4,5)
def func2(**a)：
pass
func2(a=1,b=2,c=3)
如果函数传的是列表，那么指向的是同一个对象，函数里改变改形参列表，会改变实参列表。
改对象和改变量概念、可变对象概念。
一般为变量赋值时，才是修改变量，其余都是修改对象。
若a,*b,c=(1,2,3,4,5)，则a=1，c=5，b=[2,3,4]
方法是如果对象调用，函数是传入参数。
a.len() 和 len(a)
__init()__构造方法也叫魔法方法，特殊方法。不要去手动调用构造方法，构造方法会主动被调用。
构造方法里对属性赋值，创建对象时，必须对构造方法里的属性赋值，不然会报错，这样在创造对象时就赋值了属性值。可以避免忘记对必须的属性赋值。
方法通过类的实例来访问。
如果是函数调用，则传几个参数，就会有几个实参。
但是方法调用，默认传递一个参数，所以方法里至少定义一个形参。
方法里第一个参数，一般命名为self，self就是调用该方法的对象本身。命名不一定是self，叫a也行，但是一般都命名为self。
方法就是定义在类里的函数。
=和!=比较的是对象的值。is和is not比较的是对象的id。
PrettyZoo 是一个基于 Apache Curator 和 JavaFX 实现的 Zookeeper 图形化管理客户端。
【Zookeeper可视化神器 prettyzoo - CSDN App】http://t.csdnimg.cn/Ma0iF
https://blog.csdn.net/a6470831/article/details/124076203
Windows系统的hosts文件位置是C:\Windows\System32\drivers\etc\hosts。
CentOS7升级安装最新版Firefox步骤
tar -xjvf Firefox-latest-x86_64.tar.bz2
rm -rf /usr/lib64/firefox
mv firefox /usr/lib64
cd /usr/bin
rm firefox（删除原有的旧版本的firefox启动的软链接方式）
cd /
ln -s /usr/lib64/firefox/firefox /usr/bin/firefox（创建一个新的软链接来指向新版本的firefox）
https://zhuanlan.zhihu.com/p/649765624
Centos系统中使用Firefix播放视频
sudo yum install epel-release
sudo yum install https://download1.rpmfusion.org/free/el/rpmfusion-free-release-7.noarch.rpm
sudo yum -y install vlc
https://blog.csdn.net/m0_58173092/article/details/129940495
连接zookeeper：
zkCli.sh -server 127.0.0.1:2181
看zookeeper集群里的节点：
ls /brokers/ids
看节点记录的kafka配置信息：
getData /brokers/ids/节点id
好像是get /brokers/ids/节点id
在 Docker 容器中使用 hosts 文件，可以通过以下步骤进行配置：
在宿主机上创建 hosts 文件，添加需要映射的域名和 IP 地址。例如：
复制代码
127.0.0.1 localhost
192.168.1.10 example.com
运行 Docker 容器时，使用 --add-host 参数将 hosts 文件添加到容器内的 /etc/hosts 文件中。例如：
复制代码
docker run -it --add-host=example.com:192.168.1.10 myimage /bin/bash
这将把 example.com 映射到 192.168.1.10 IP 地址。在容器内部，可以使用 ping example.com 命令来测试域名解析是否正确。
可以使用多个 --add-host 参数来添加多个域名和 IP 地址映射。例如：
复制代码
docker run -it --add-host=example1.com:192.168.1.10 --add-host=example2.com:192.168.1.11 myimage /bin/bash
如果需要在多个容器之间共享 hosts 文件，可以将主机上的 hosts 文件挂载到容器内的 /mnt 目录下。例如：
复制代码
docker run -it -v /path/to/hosts:/mnt myimage /bin/bash
这将把主机上的 /path/to/hosts 文件挂载到容器内的 /mnt 目录下，容器内可以像普通主机一样使用 hosts 文件。
docker-compose stop 停止容器
docker-compose up -d 后台运行容器
lanproxy服务端配置占用的端口即使该条记录被删除后仍然会一直占用，重启lanproxy服务端释放被删除记录却仍占用的端口
docekr容器修改端口对应:
使用 docker ps -a 命令找到要修改容器的 CONTAINER ID。
运行以下命令，进入该容器目录：docker inspect 【CONTAINER ID】| grep Id。
停止容器：docker stop [容器id]。
停止主机docker服务：systemctl stop docker。
进入2得到的文件夹内，修改hostconfig.json 和 config.v2.json。
docker container update --publish-add 8888:8080 容器名称或容器ID
方式一：使用docker命令修改端口映射
查看运行中的docker容器
docker ps
使用以下命令修改端口映射，将容器内部的端口8080映射到宿主机的端口8888
docker container update --publish-add 8888:8080 容器名称或容器ID
其中–publish-add表示新增一个端口映射，8888是宿主机的端口，8080是容器内部的端口。
查看端口映射是否已生效
docker container inspect 容器名称或容器ID
在返回结果中找到"Ports"部分，可以看到端口映射已生效。
示例：修改nginx容器内部的端口80映射到宿主机的端口8080
docker container update --publish-add 8080:80 nginx
方式二：使用docker-compose修改端口映射
在docker-compose.yml文件所在的目录中，运行以下命令使修改生效
docker-compose up --force-recreate --build -d
其中–force-recreate表示强制重新创建容器，–build表示在创建容器前先构建镜像。
示例：修改docker-compose.yml中web服务的端口映射，将容器内部的端口80映射到宿主机的端口8888。
services: web: ports: - “8888:80”
https://blog.51cto.com/u_16175495/7108971
MySQL中最快的复制表的方法？
https://geek-docs.com/mysql/mysql-ask-answer/322_mysql_fastest_way_to_copy_a_table_in_mysql.html
使用命令行实用程序“mysqldump”来将表复制到不同的数据库或服务器。这是一种快速、可靠的方法，尤其适用于同时复制大量数据。
因此，以下是常规的复制表命令：
mysqldump -u username -p -h host_name database_name table_name | mysql -u username -p -h host_name new_database_name
Mysql
以上命令可以指定源表“table_name”所属的“database_name”、目标数据库的名称以及目标MySQL服务器的主机名和用户名。
要使用`mysqldump`导出`statistic_date`大于'2021-09-19'的数据，您可以使用`--where`参数指定条件。请按照以下步骤进行操作：
1. 打开命令行终端。
2. 使用以下命令格式运行`mysqldump`：
mysqldump -u [用户名] -p [数据库名] [表名] --where=“statistic_date > ‘2021-09-19’” > [输出文件名].sql
- 将`[用户名]`替换为您的MySQL用户名。
- 将`[数据库名]`替换为要导出数据的数据库名称。
- 将`[表名]`替换为要导出数据的表名称。
- 将`[输出文件名]`替换为导出数据的输出文件名，可以是任何您想要的名称。
请确保在命令中使用正确的引号和日期格式。
3. 运行命令后，系统将提示您输入MySQL密码。输入密码并按回车键。
4. `mysqldump`将导出满足条件的数据，并将其保存到指定的输出文件中。
通过这个命令，您将获得一个包含满足条件的数据的SQL导出文件。您可以使用该文件来还原数据或在其他MySQL数据库中导入数据。
要清空MySQL数据库中的表，您可以使用以下方法之一：
方法一：使用TRUNCATE TABLE语句
TRUNCATE TABLE table_name;
将上面的table_name替换为您要清空的表的实际名称。执行此语句后，将删除表中的所有数据，但保留表结构和定义。
方法二：使用DELETE语句
DELETE FROM table_name;
将上面的table_name替换为您要清空的表的实际名称。执行此语句后，将删除表中的所有数据，但保留表结构和定义。
请注意，使用TRUNCATE TABLE语句比使用DELETE语句更高效，因为TRUNCATE TABLE语句直接删除表中的所有行，而不会记录每个删除操作。但是，TRUNCATE TABLE语句无法撤消，而DELETE语句可以使用ROLLBACK命令进行撤消。
在执行任何删除操作之前，请务必备份重要的数据，以防止意外删除。
如果您只是想删除表中的数据，而不是删除整个表，请使用DELETE FROM table_name;语句。这将删除表中的所有行，但保留表结构。
请注意，执行删除操作需要具有足够的权限。如果您遇到权限问题，请联系数据库管理员或具有适当权限的用户。
如果你想要在 DataFrame 中的某一列为空时，用另一列的值进行填补，你可以使用 Pandas 的 fillna() 方法来实现。下面是一个示例代码：
import pandas as pd
# 假设你的 DataFrame 名为 df，有两列 "column1" 和 "column2"
# 使用 "column2" 的值填补 "column1" 中的空值
df['column1'].fillna(df['column2'], inplace=True)
上述代码中，fillna() 方法用于填补 DataFrame 中指定列的空值。我们将 “column1” 列的空值用 “column2” 列的值进行填补。通过将 df['column2'] 作为 fillna() 方法的参数，我们指定了用于填补空值的替代值。
请注意，我们使用了 inplace=True 参数，以便在原始 DataFrame 上直接进行修改。如果不指定 inplace=True，fillna() 方法将返回一个填补了空值的新 DataFrame，而不会修改原始 DataFrame。
这样，当 “column1” 列为空时，它将被 “column2” 列的对应值填补。如果 “column2” 列也为空，则 “column1” 列仍将保持为空。
df截取某个值之后的数据
id = df.loc[df[‘fund_id’] == ‘JR328103’].index[0]
df=df[id:]
要获取 MySQL 表的物理文件大小，你可以使用以下方法：
- 使用命令行工具：可以使用 MySQL 的命令行工具（如 mysql 或 mysqladmin）来执行以下命令：
SELECT table_schema AS 'Database', table_name AS 'Table', CONCAT(ROUND((DATA_LENGTH + INDEX_LENGTH) / (1024 * 1024), 2), ' MB') AS 'Size' FROM information_schema.TABLES WHERE table_schema = 'your_database_name' AND table_name = 'your_table_name';
将 “your_database_name” 替换为你的数据库名称，“your_table_name” 替换为你的表名。执行该命令后，将返回表的物理文件大小。
- 使用信息模式（Information Schema）查询：可以直接查询 “information_schema.TABLES” 表来获取表的物理文件大小。执行以下查询语句：
SELECT table_schema AS 'Database', table_name AS 'Table', CONCAT(ROUND((DATA_LENGTH + INDEX_LENGTH) / (1024 * 1024), 2), ' MB') AS 'Size' FROM information_schema.TABLES WHERE table_schema = 'your_database_name' AND table_name = 'your_table_name';
同样，将 “your_database_name” 替换为你的数据库名称，“your_table_name” 替换为你的表名。执行该查询后，将返回表的物理文件大小。
无论使用哪种方法，都需要替换相应的数据库名称和表名。这些方法将返回以 MB 为单位的表的物理文件大小。
在 MySQL 中，常见的系统库包括：
information_schema: 包含关于数据库系统的元数据信息，如数据库、表、列、索引、权限等的详细信息。
mysql: 存储了关于 MySQL 服务器的配置和权限信息，包括用户、权限、角色、日志等。
performance_schema: 用于性能监控和性能分析，提供了与数据库服务器性能相关的数据和统计信息。
sys: 提供了一些便捷的视图和函数，用于分析和监控数据库的性能和状态。
这些系统库都是默认安装的，用于存储和管理数据库系统的元数据、配置信息以及性能相关的数据。它们在 MySQL 中起着重要的作用，帮助用户了解和管理数据库系统的各个方面。
需要注意的是，对于系统库的访问和操作通常需要具有相应的权限。确保你具有足够的权限来查询
kafka穿透：
https://www.ngui.cc/el/1990221.html?action=onClick
nohup ./kafka-server-start.sh ../config/server.properties & 和 ./kafka-server-start.sh ../config/server.properties & 的区别在于是否使用了 nohup 命令。
nohup命令：nohup是一个用于在后台运行命令的工具。当你使用nohup命令运行 Kafka 服务器时，它会将命令的输出重定向到一个名为nohup.out的文件中，并且即使你关闭终端或退出当前会话，Kafka 服务器仍然会继续在后台运行。
例如，nohup ./kafka-server-start.sh ../config/server.properties & 将启动 Kafka 服务器，并将输出保存到 nohup.out 文件中，即使你关闭终端，Kafka 服务器也会继续在后台运行。
- 不使用
nohup命令：如果你直接使用./kafka-server-start.sh ../config/server.properties &命令启动 Kafka 服务器，那么它将在后台运行，但是命令的输出将直接打印到终端。如果你关闭终端或退出当前会话，Kafka 服务器也会随之终止。
例如，./kafka-server-start.sh ../config/server.properties & 将启动 Kafka 服务器，并将输出直接打印到终端。如果你关闭终端，Kafka 服务器也会停止运行。
因此，使用 nohup 命令可以确保 Kafka 服务器在后台运行，并将输出保存到文件中，即使你关闭终端或退出当前会话。这对于长时间运行的进程（如 Kafka broker）非常有用，因为它们可以在后台持续运行，而不会受到终端关闭的影响。
看topic列表：
kafka-topics.sh --zookeeper localhost:2181 --list
看topic具体信息
kafka-topics.sh --zookeeper localhost:2181 --describe --topic my_topic_name
增加topic的分区数量（只能加不能减，一般1，2，4，8，是2的幂，消费者数量要小于等于分区数量）
kafka-topics.sh --alter --zookeeper localhost:2181 --topic my_topic_name–partitions new_topic_number
看状态 kafka-daemons.sh status
Kafka Eagle 是一个用于监控和管理 Apache Kafka 集群的开源工具。在 Kafka Eagle 2.0.5 版本中，有两个操作：Drop（删除）和Truncating（截断），它们在功能和效果上有所区别。
Drop（删除）：Drop 操作用于删除 Kafka 主题中的消息。当执行 Drop 操作时，Kafka Eagle 会删除指定主题中的所有消息数据，包括所有分区中的消息。这是一个非常慎重的操作，因为删除消息后将无法恢复。Drop 操作通常用于清除测试数据或不再需要的数据。
Truncating（截断）：Truncating 操作用于截断 Kafka 主题中的消息。与删除操作不同，截断操作只会删除指定主题中的部分消息数据，而不是全部。具体来说，截断操作会将主题中的消息截断到指定的偏移量（offset）之前，包括指定偏移量的消息。截断操作可以用于清除过期的消息或重新处理一部分数据。
需要注意的是，无论是 Drop 还是 Truncating 操作，都会对 Kafka 主题中的消息进行永久性的更改或删除。因此，在执行这些操作之前，务必谨慎考虑，并确保对数据的影响有清晰的理解。建议在生产环境中慎重使用这些操作，并备份重要的数据以防止意外情况发生。
根据您提供的输出，/etc/alternatives/java 符号链接的目标路径是 /usr/lib/jvm/java-1.8.0-openjdk-1.8.0.262.b10-1.el7.x86_64/jre/bin/java。
因此，您可以将 JAVA_HOME 设置为该路径的上级目录，即 /usr/lib/jvm/java-1.8.0-openjdk-1.8.0.262.b10-1.el7.x86_64。
您可以在终端中执行以下命令来设置 JAVA_HOME 环境变量：
export JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.262.b10-1.el7.x86_64
如果您希望在每次登录时都自动设置 JAVA_HOME，可以将上述命令添加到您的 shell 配置文件（如 .bashrc、.bash_profile 或 .profile）中。
设置好 JAVA_HOME 后，您可以通过运行以下命令来验证它是否正确设置：
echo $JAVA_HOME
输出应该显示为 /usr/lib/jvm/java-1.8.0-openjdk-1.8.0.262.b10-1.el7.x86_64，这表示 JAVA_HOME 已经成功设置为您指定的 Java 安装目录。
应该用这个才对export JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.262.b10-1.el7.x86_64/jre
好像也不是，算了，压缩包配一个吧
JAVA_HOME 是一个环境变量，用于指定 Java 安装目录的路径。在 Linux 系统中，Java 可能安装在不同的位置，而 JAVA_HOME 变量可以帮助系统找到正确的 Java 安装路径。
通常情况下，JAVA_HOME 的默认值是 /usr/lib/jvm/java，但实际路径可能因操作系统和 Java 版本而有所不同。要确定 JAVA_HOME 的准确路径，可以执行以下命令：
echo $JAVA_HOME
这将显示当前系统中配置的 JAVA_HOME 路径。
在 /etc/alternatives/ 目录中，通常会有一个名为 java 的符号链接，它指向实际的 Java 安装路径。您可以使用以下命令找到 java 符号链接的目标路径：
ls -l /etc/alternatives/java
输出将显示符号链接的目标路径，类似于 /usr/lib/jvm/java-11-openjdk-amd64/bin/java。在这个例子中，/usr/lib/jvm/java-11-openjdk-amd64 就是实际的 Java 安装目录。
请注意，JAVA_HOME 的设置可能因不同的用户和系统而有所不同。确保在您的环境中正确设置 JAVA_HOME 变量，以便应用程序和工具可以找到并使用正确的 Java 安装。
Kafka eagle的介绍及安装（基于linux环境）
https://blog.csdn.net/jack__love/article/details/127297887
kafka消费与生产(命令行)
创建主体
/usr/local/kafka_2.11-2.4.0/bin/kafka-topics.sh --zookeeper localhost:2181 --create --topic gosuncn --partitions 2 --replication-factor 1
列出所有主题
/usr/local/kafka_2.11-2.4.0/bin/kafka-topics.sh --zookeeper localhost:2181 --list
查看主题详情
/usr/local/kafka_2.11-2.4.0/bin/kafka-topics.sh --zookeeper localhost:2181 --describe --topic gosuncn
启动消费端接收主题
/usr/local/kafka_2.11-2.4.0/bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic gosuncn
启动生产端发送主题
/usr/local/kafka_2.11-2.4.0/bin/kafka-console-producer.sh --broker-list localhost:9092 --topic gosuncn
https://www.kancloud.cn/zhangpn/kafka/1656669
记录kafka上线N天后自动崩溃的bug分析和优化策略
https://zhuanlan.zhihu.com/p/459766419?utm_id=0
zabbix-java-gateway配置连接jmx
yum install zabbix-java-gateway
vim /etc/zabbix/zabbix_server.conf
JavaGateway=192.168.0.xxx
JavaGatewayPort=10052
StartJavaPollers=5
systemctl start zabbix-java-gateway
systemctl restart zabbix-java-gateway
zabbix上：
jmx端口：192.168.0.xxx 与 9999
jconsole连接jmx
kafka配置jmx kafka-server-start.sh 添加
export JMX_PORT=9999
export KAFKA_JMX_OPTS=“-Dcom.sun.management.jmxremote -Dcom.sun.management.jmxremote.authenticate=false -Dcom.sun.management.jmxremote.ssl=false -Djava.rmi.server.hostname=kafka的ip地址”
还是把这个关了，感觉zabbix监控效果不明显。
read_csv 是 Pandas 库中用于读取 CSV 文件的函数。它可以将 CSV 文件中的数据读取为一个 Pandas DataFrame 对象，方便进行数据处理和分析。
以下是 read_csv 函数的基本语法：
import pandas as pd
df = pd.read_csv(filepath_or_buffer, sep=',', header='infer', names=None, index_col=None)
参数说明：
filepath_or_buffer：CSV 文件的路径或 URL，可以是本地文件路径或网络地址。sep：字段分隔符，默认为逗号（‘,’）。可以根据实际情况指定其他分隔符，如制表符（‘\t’）。header：指定作为列名的行号，默认为 ‘infer’，表示自动推断。可以指定行号或行号列表作为列名。names：自定义列名列表。如果指定了header=None，则使用names参数作为列名。index_col：指定作为索引的列号或列名。默认为None，表示不使用任何列作为索引。
示例用法：
import pandas as pd
# 读取本地 CSV 文件
df = pd.read_csv('data.csv')
# 读取网络上的 CSV 文件
df = pd.read_csv('https://example.com/data.csv')
# 指定分隔符和列名
df = pd.read_csv('data.csv', sep=';', header=0, names=['col1', 'col2', 'col3'])
# 指定索引列
df = pd.read_csv('data.csv', index_col='id')
通过使用 read_csv 函数，你可以轻松地将 CSV 文件中的数据加载到 Pandas DataFrame 中，以便进行后续的数据处理和分析操作。
筛选出 DataFrame 中某一列不在给定列表中的数据，可以使用 Pandas 的条件筛选功能和 ~ 运算符。
data = {‘A’: [1, 2, 3, 4, 5],
‘B’: [‘apple’, ‘banana’, ‘orange’, ‘apple’, ‘orange’]}
df = pd.DataFrame(data)
给定的列表
given_list = [‘apple’, ‘banana’]
筛选出不在给定列表中的数据
filtered_df = df[~df[‘B’].isin(given_list)]
打印筛选结果
print(filtered_df)
在线测网络https://www.speedtest.cn/
发现：交换机连网络的线要连到uplink那个端口，连其他端口网络慢。
交换机的Uplink端口是指连接到上层设备（如路由器、核心交换机）的端口。Uplink端口通常具有更高的带宽和更高的速度，用于连接不同交换机之间的链路，以扩展网络规模或提供网络冗余。Uplink端口可以是光纤端口、千兆以太网端口或其他高速连接端口。通过使用Uplink端口，可以将多个交换机级联在一起，形成更大的网络架构。
长见识了，可以这么写。pandas筛选长度
import pandas as pd
def invalid_tweets(tweets: pd.DataFrame) -> pd.DataFrame:
is_valid = tweets[‘content’].str.len() > 15
df = tweets[is_valid]
return df[[‘tweet_id’]]
同理， df[‘name’] = df[‘name’].str.replace(’ ', ‘’) 将name列进行去除空格处理
Jenkins发现docker卡死，日志不更新，但是容器可能还在正常工作，只不过日志断了。这种情况下，可能脚本会完整跑一遍。这时候确定服务器里容器已经没在运行了，要手动Jenkins上x掉任务就可以了。
x不掉，一般要Jenkins上命令行关掉任务（一般是因为Jenkins连不上执行脚本的服务器）。
canal+kafka
https://github.com/alibaba/canal/releases
tar -zcvf压缩
要压缩一个目录，你可以使用以下命令：
tar -zcvf archive.tar.gz directory/
其中，archive.tar.gz 是你希望创建的压缩文件的名称，directory/ 是要压缩的目录的路径。这个命令会将目录及其子目录和文件都压缩到一个 .tar.gz 文件中。
self.engine.url.database == ‘test_db’
kafka序列化：
value_serializer=lambda m: pickle.dumps(m)
pycharm打开项目报错Cannot load settings from file
亲测可以：
直接去项目根目录下把 .idea 文件夹删了，再重新打开项目就好了，简单粗暴有效可靠
https://blog.csdn.net/weixin_45427313/article/details/129376147
使用for循环和enumerate()函数遍历列表（同时输出索引值和元素内容）
使用for循环和enumerate()函数可以实现同时输出索引值和元素内容，其语法格式如下：
for index,变量元素 in enumerate(列表)
#输出index和变量元素
python：计算四分位距IQR
import numpy as np
def cal_iqr(arr): # 计算四分位距
qr1 = np.quantile(arr, 0.25, method=‘averaged_inverted_cdf’) # 下四分位数
qr3 = np.quantile(arr, 0.75, method=‘averaged_inverted_cdf’) # 上四分位数
iqr = qr3 - qr1 # 计算四分位距
return iqr
method共有13种方法，选择合适需求的方法。
1.‘inverted_cdf’
2.‘averaged_inverted_cdf’
3.‘closest_observation’
4.‘interpolated_inverted_cdf’
5.‘hazen’
6.‘weibull’
7.‘linear’(默认)
8.‘median_unbiased’
9.‘normal_unbiased’
10.‘lower’
11.‘higher’
12.‘nearest’
13.‘midpoint’
计算下四分位数：
将数据升序排序，用数据个数n除以4，如得到整数a，取第a个和第a+1个数据的均值作为下四分位数，若得到小数，向上取整得到整数b，第b个数即是下四分位数。
计算上四分位数：
将数据升序排序，用数据个数的三倍，即3n除以4，如得到整数c，取第c个和第c+1个数据的均值作为下四分位数，若得到小数，向上取整得到整数d，第d个数即是下四分位数。
————————————————
版权声明：本文为CSDN博主「小卖部的老板娘」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_41543800/article/details/127548569
abs() 求绝对值
在Python中，可以使用abs()函数来计算一个数的绝对值。该函数接受一个数作为参数，并返回该数的绝对值。例如，要计算-5的绝对值，可以这样写：
abs(-5)
该表达式的结果将是5。同样地，如果要计算一个正数的绝对值，结果将是该数本身。
python列表去除元素
使用列表的 remove() 方法：如果你知道要删除的元素的值，你可以使用 remove() 方法来删除该元素。例如：
my_list = [1, 2, 3, 4, 5]
my_list.remove(3)
print(my_list) # 输出: [1, 2, 4, 5]
使用 del 关键字：如果你知道要删除元素的索引位置，你可以使用 del 关键字来删除该元素。例如：
my_list = [1, 2, 3, 4, 5]
del my_list[2]
print(my_list) # 输出: [1, 2, 4, 5]
使用列表的 pop() 方法：pop() 方法不仅可以返回列表中指定索引位置的元素，还会将其从列表中删除。例如：
my_list = [1, 2, 3, 4, 5]
popped_element = my_list.pop(2)
print(my_list) # 输出: [1,2, 4, 5]
print(popped_element) # 输出: 3
np.mean(a) 求平均数
import numpy as np
a = [5, 6, 16, 9]
np.mean(a)
9.0
计算样本标准差
标准差 σ = sqrt(((x1-x)^2 +(x2-x)^2 +……(xn-x)^2)/（n-1))
import numpy as np
计算样本标准差，（计算时除以 N - 1）
np.std(list, ddof = 1 )
https://blog.csdn.net/robert_chen1988/article/details/102712946
在 Python 中，你可以使用内置的 round() 函数来进行四舍五入。round() 函数的语法如下：
round(number, ndigits)
其中，number 是需要进行四舍五入的数字，ndigits 是保留的小数位数（默认为 0）。当 ndigits 为正数时，表示保留的小数位数；当 ndigits 为负数时，表示将数字四舍五入到指定的十位、百位等。
以下是一些示例：
x = 3.14159
rounded = round(x) # 默认为整数四舍五入
print(rounded) # 输出: 3
y = 3.14159
rounded_2_digits = round(y, 2) # 保留两位小数四舍五入
print(rounded_2_digits) # 输出: 3.14
z = 12345
rounded_to_thousands = round(z, -3) # 四舍五入到千位
print(rounded_to_thousands) # 输出: 12000
拿BASE TABLE就可以了
SELECT DISTINCT TABLE_TYPE from information_schema.TABLES
SYSTEM VIEW
BASE TABLE
VIEW
Python求两个list的差集、交集与并集的方法
定义
差集： A，B是两个集合，所有属于A且不属于B的元素构成的集合， 就是差集。
交集： A，B是两个集合，既属于A又属于B的元素构成的集合， 就是交集。
并集： A，B是两个集合，把他们所有的元素合并在一起组成的集合，就是并集。
求两个list差集
如有下面两个列表：
1
2
listA = [1,2,3,4]
listB = [2,3,4]
想要的结果是[1]
有3种方法：
- 循环遍历法
1
2
3
4
5
ret = []
for i in listA:
if i not in listB:
ret.append(i)
print(ret)
- 运算符法
1
2
ret = list(set(listA) ^ set(listB))
print(ret)
- difference函数法
1
2
list(set(listA).difference(set(listB)))
print(ret)
很明显第二种、第三种方法更加优雅。
求两个list的并集
代码如下:
1
2
ret = list(set(listA).union(set(listB)))
print(ret)
求两个list的交集
1
2
ret = list(set(listA).intersection(set(listB)))
print(ret)
————————————————
版权声明：本文为CSDN博主「量慧实工作室LHStudio」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/LLC25802580/article/details/123095147
监控网卡故障，重启网卡：https://www.cnblogs.com/luckyall/p/8094366.html
vi check_network.sh
#!/bin/bash
date=“date '+%Y-%m-%d %H:%M:%S'”
ip=“173.208.x.x”
nic=“eth0”
lost_rate=ping -c 8 -w 8 $ip | grep 'packet loss' \ | awk -F'packet loss' '{ print $1 }' \ | awk '{ print $NF }' | sed 's/%//g'
if [ $lost_rate -eq 0 ]
then
echo “network_ok $date $ip $nic” >>/root/network_ok.log
elif [ $lost_rate -le 100 ]
then
#echo “network_error $date $ip $nic” //输出到窗口，因为不需要所以屏蔽了
#else
echo “network_error $date $ip $nic” >>/root/network_error.log
service network restart
fi
chmod +x check_network.sh
然后在计划任务里添加
*/3 * * * * /bin/sh /opt/check_network.sh
如果消费者启动不了或者无法消费指定topic，尝试设置所使用用户的组权限（当前使用用户admin为超级用户，不需要配置权限）
https://www.cnblogs.com/iamsach/p/9234624.html
kafka分区:
分区是用来并发的
consumer的数量不会大于分区数量
如果你希望有8个消费者同时消费
那分区最起码得设置为8
一般就是1 4 8
反正是2的幂
kafka服务端设置用户和密码登录
https://blog.csdn.net/guaotianxia/article/details/121094383
配置 Zabbix Server 监控 Kafka 集群
https://docsv4.qingcloud.com/user_guide/middware/kafka/best-practices/zabbix/
charles 抓包工具：
https://blog.csdn.net/weixin_49353386/article/details/125879541
https://www.zzzmode.com/mytools/charles/
(标记位置3)
一个df,里面有个字段叫my_time,记录的是时间点, 我想计算时间差,相邻超过两小时要特别计算. 比如说 该字段数据为 1点,2点,3点,10点 ,11点,12点.,13点 那么结果就是(3-1)+(13-10)=2+3=5小时. 因为3点和10点超过了2小时,所以要分段计算.用python怎么实现这个功能
要实现这个功能，你可以使用 Python 和 pandas 库。下面是一个步骤：
- 首先，你需要确保
pandas和numpy库已经安装。如果还没有安装，可以使用 pip 安装：
pip install pandas numpy
- 使用以下 Python 代码来实现你的需求：
import pandas as pd
import numpy as np
# 假设你有一个DataFrame，其中my_time列包含了你的时间数据
# 创建一个示例DataFrame
df = pd.DataFrame({
'my_time': ['1:00', '2:00', '3:00', '10:00', '11:00', '12:00', '13:00']
})
# 将my_time列转换为datetime类型
df['my_time'] = pd.to_datetime(df['my_time'], format='%H:%M')
# 计算时间差
df['time_diff'] = df['my_time'].diff().dt.total_seconds() / 3600
# 将超过2小时的时间差标记为NaN
df['time_diff'] = df['time_diff'].apply(lambda x: x if x <= 2 else np.nan)
# 计算总的时间差，跳过NaN值
total_time = df['time_diff'].sum(skipna=True)
print(f"总时间差: {total_time}小时")
这个代码首先将 my_time 列转换为 pandas 的 datetime 类型。然后，计算每两个连续时间点之间的时间差，并将超过2小时的时间差标记为 NaN。最后，计算所有非 NaN 值的总和，这就是你要的总时间差。
破解CSS加密之爬取大众点评
https://blog.csdn.net/qq_16146103/article/details/109210701
FontCreator安装
https://www.high-logic.com/font-editor/fontcreator/download-confirmation
Linux中inode使用率满了解决办法( inode节点满处理方法)
ls /var/spool/postfix/maildrop | wc -l
为什么 /var/spool/postfix/ 下面会生成那么多的文件数量？
答：这是因为crontab定时任务所导致的，定时任务执行后发送告知联系人，但是发送失败就会在postfix下生成，所有就产生了这么多的垃圾文件。
先通过 rm 直接删除，结果报错参数列表太长：
[root@node2 maildrop]# rm -rf *
-bash: /bin/rm: Argument list too ong
最后，使用类似于 ls | xargs -n 500 rm -rf 的方式进行删除
ls | xargs -n 500 rm -rf
https://zhuanlan.zhihu.com/p/473796938
ls /var/spool/postfix/maildrop | xargs -n 500 rm 即可
要查看 Linux 文件系统中的 inode 数量，你可以使用 df 和 df -i 命令。
- 使用
df -i命令:
执行以下命令可以查看每个挂载的文件系统的 inode 使用情况：
df -i
输出将列出每个文件系统的以下信息：
Filesystem: 文件系统的设备名称或挂载点。Inodes: 使用的 inode 数量。IUsed: 已使用的 inode 数量。IFree: 可用的 inode 数量。IUse%: inode 使用率。
- 查看单个目录或文件的 inode 信息:
如果你想查看特定目录或文件的 inode 信息，可以使用 ls -i 命令：
ls -i /path/to/directory_or_file
这将显示指定目录或文件的 inode 号码以及它们的名称。
- 其他工具:
- 你还可以使用像
stat这样的工具来获取特定文件或目录的 inode 信息：
stat /path/to/directory_or_file
- 或者使用
df命令查看整个文件系统的 inode 总数和使用情况：
df -i /path/to/mount_point
请确保将 /path/to/mount_point 替换为你要检查的文件系统的挂载点路径。
通过上述方法，你可以查看 Linux 文件系统中 inode 的数量和使用情况。
要查看 MySQL 中的严格模式是否已开启，可以执行以下步骤：
1. 登录到 MySQL 服务器
使用 MySQL 客户端或命令行工具登录到 MySQL 服务器：
mysql -u your_username -p
然后输入密码以登录。
2. 查看当前的 sql_mode 设置
一旦你登录到 MySQL 服务器，执行以下 SQL 命令以查看当前的 sql_mode 设置：
SHOW VARIABLES LIKE 'sql_mode';
这将显示当前的 sql_mode 设置。如果严格模式已启用，你可能会在结果中看到包含 STRICT_TRANS_TABLES 或 STRICT_ALL_TABLES 的值。
3. 解析 sql_mode 设置
MySQL 的 sql_mode 可能包含多个标志，它们由逗号分隔。以下是一些常见的 sql_mode 值及其意义：
STRICT_TRANS_TABLES：在插入或更新操作中进行严格的类型检查。STRICT_ALL_TABLES：进行更严格的类型检查，同时禁用非安全操作。NO_ZERO_IN_DATE：禁止日期中的 ‘0000-00-00’。NO_ZERO_DATE：禁止 ‘0000-00-00’ 作为有效日期。ERROR_FOR_DIVISION_BY_ZERO：在除以零时产生错误。
如果你看到这些标志中的任何一个，那么相关的严格模式选项已经开启。
通过上述步骤，你应该能够查看并确定 MySQL 中的严格模式是否已开启。
在 MySQL 8.0 中，你可以通过修改配置或运行 SQL 语句来关闭严格模式。关闭严格模式后，MySQL 在执行某些数据验证时将更为宽松。以下是如何关闭严格模式的方法：
1. 临时关闭严格模式（仅当前会话）
如果你只想在当前会话中关闭严格模式，可以使用以下 SQL 语句：
SET GLOBAL sql_mode=(SELECT REPLACE(@@sql_mode,'STRICT_ALL_TABLES',''))
或者，你可以在 MySQL 命令行工具中执行以下命令：
SET sql_mode=(SELECT REPLACE(@@sql_mode,'STRICT_ALL_TABLES',''))
2. 永久关闭严格模式
要永久关闭 MySQL 8.0 中的严格模式，你需要修改 MySQL 配置文件（例如 my.cnf 或 my.ini，取决于你的操作系统）。
-
找到 MySQL 配置文件。对于 Linux 系统，通常位于
/etc/mysql/my.cnf或/etc/my.cnf，而对于 Windows，通常位于 MySQL 安装目录的根目录。 -
在配置文件中找到
[mysqld]部分，并添加或修改sql_mode行如下：
[mysqld]
sql_mode=NO_ENGINE_SUBSTITUTION
上述配置会将 sql_mode 设置为 NO_ENGINE_SUBSTITUTION，这是一个没有严格模式的常见设置。但是，如果你想完全自定义 sql_mode，确保删除或替换与严格模式相关的选项。
-
保存并关闭文件。
-
重新启动 MySQL 服务，使更改生效。
根据你的实际需求，选择适当的方法来关闭 MySQL 8.0 中的严格模式。如果你选择修改配置文件，请确保备份原始配置文件，以防出现问题
js加壳网站：
https://obfuscator.io/
当配置全局用户名和邮箱时，Git会将这些信息存储在C:\Users\用户名.gitconfig文件中。此外，如果你设置了全局的用户名和密码，这些信息也会被保存在这个文件里。
标识项目路径：
import sys
sys.path.append(‘…\项目名’)
报错:(UnicodeDecodeError: ‘gbk‘ codec can‘t decode byte 0xad in position 20: illegal ）
import subprocess
from functools import partial
subprocess.Popen = partial(subprocess.Popen, encoding=“utf-8”)
修改编码方式,window默认编码是gbk,Mac和Linux 默认是uft-8
#在前面三行后import需要的库 execjs
import execjs
requests模块不支持http2.0协议, 在访问使用http2.0协议的网站时, 就需要用到httpx。
pip install httpx[http2] # 后面要加[http2]否则不能支持https2.0.、
参数http2设置为True
这里Client对象的作用类似于requests的Session对象
with httpx.Client(http2=True) as client:
resp = client.get(url)
print(resp.text)
————————————————
版权声明：本文为CSDN博主「顽皮的橙子」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/demonscg/article/details/123035665
jenkins有时候运行docker任务容易卡住，让docker后台运行，不在Jenkins打印日志，Jenkins就不会卡住了。
docker run -d --rm --name=‘test’
打印日志格式：
docker run -t --rm --name=‘test’
Charles 抓包工具：
https://blog.csdn.net/weixin_49353386/article/details/125879541
new Date()['valueOf']() 是 JavaScript 中获取当前时间戳的一种方式。它使用了 Date 对象的 valueOf 方法。
在这个表达式中：
new Date()创建一个表示当前时间的Date对象。['valueOf']使用数组访问符号访问Date对象的valueOf方法。()调用valueOf方法，返回一个表示当前时间的时间戳（从1970年1月1日 UTC的毫秒数）。
因此，new Date()['valueOf']() 的结果是当前时间的时间戳。这个表达式通常可以简写为 new Date().valueOf() 或者更简单的 Date.now()。
在 Windows 的命令行环境（CMD），你可以使用 findstr 命令来实现类似于 Unix/Linux 中的 grep 功能，用于在文件中搜索字符串或者在命令输出中过滤匹配的行。
在Scrapy中，你可以在爬虫关闭时使用信号（Signals）来执行一段代码，例如更新数据库状态。以下是一个简单的例子：
from scrapy import signals
from scrapy.signalmanager import dispatcher
from scrapy.crawler import CrawlerProcess
import your_database_module # 替换成你的数据库模块
class MySpider(scrapy.Spider):
name = 'my_spider'
# 爬虫逻辑...
def update_database_status():
# 在爬虫关闭时执行的代码，例如更新数据库状态
print("Updating database status...")
your_database_module.update_status() # 替换成实际的数据库更新代码
# 在 spider_closed 信号触发时调用 update_database_status 函数
dispatcher.connect(update_database_status, signal=signals.spider_closed)
# 创建 CrawlerProcess 对象并添加爬虫
process = CrawlerProcess()
process.crawl(MySpider)
# 启动爬虫
process.start()
在这个例子中，update_database_status 函数是在爬虫关闭时要执行的代码，其中 your_database_module.update_status() 是实际更新数据库状态的代码，你需要根据自己的数据库模块和逻辑进行替换。
确保导入了你的数据库模块，并在 update_database_status 函数中调用适当的函数来更新数据库状态。这个函数将在爬虫关闭时由 spider_closed 信号触发。
在MySQL中，使用NOT IN操作符时，会过滤掉字段为NULL的行。这是因为在SQL中，任意值与NULL进行比较的结果都是FALSE。因此，如果NOT IN后面的选项中存在NULL，查询结果会过滤掉这些值为NULL的行
innerHTML 是 JavaScript 中用于操作 DOM 元素内容的属性。它提供了一种简便的方式来获取或设置元素的 HTML 内容。
获取元素的 HTML 内容：
var element = document.getElementById('example');
var htmlContent = element.innerHTML;
console.log(htmlContent);
上面的例子中，element.innerHTML 会返回元素的 HTML 内容。这包括了元素的标签、属性以及它包含的文本或其他元素。
设置元素的 HTML 内容：
var element = document.getElementById('example');
element.innerHTML = '<p>New HTML content</p>';
通过将新的 HTML 字符串赋值给 element.innerHTML，你可以替换元素的当前内容。
需要注意的是，使用 innerHTML 会解析并重新渲染整个 HTML 结构，这可能导致重新绑定事件处理程序、重新计算样式等，因此在大量操作时需要小心使用，以避免不必要的性能开销。
此外，如果从用户输入或其他不受信任的来源获得的数据被直接插入到 innerHTML 中，可能存在安全风险，因为这可能导致跨站脚本攻击（XSS）。在这种情况下，最好使用其他更安全的方式，比如使用 textContent 或使用 DOM 操作创建和附加元素。
浏览器控制台里是window，nodejs里是global。
源代码-替代页面内容功能
call是一个一个传，apply是传数组。
call 方法：
call 方法是函数对象的一个方法，它允许你以指定的 this 值和一个参数列表来调用函数。
function myFunction(arg1, arg2, arg3) {
// 函数体
}
myFunction.call(context, arg1, arg2, arg3);
context是函数执行时的上下文（即this的值）。- 后续的参数是按顺序传递给函数的实际参数。
apply 方法：
apply 方法也是函数对象的一个方法，它允许你以指定的 this 值和一个数组（或类数组对象）作为参数列表来调用函数。
function myFunction(arg1, arg2, arg3) {
// 函数体
}
var argsArray = [arg1, arg2, arg3];
myFunction.apply(context, argsArray);
context是函数执行时的上下文（即this的值）。argsArray是一个包含实际参数的数组或类数组对象。
- 参数传递方式：
call方法是将参数按顺序传递给函数。apply方法是将参数作为一个数组传递给函数。
- 语法：
call的语法是function.call(context, arg1, arg2, ...)。apply的语法是function.apply(context, argsArray)。
通常情况下，你可以根据函数的参数形式来选择使用 call 或 apply。如果参数已经以数组或类数组的形式存在，那么使用 apply 更方便。如果参数是已知的一组值，而不是数组，那么使用 call 更合适。
从 ES6（ECMAScript 2015）开始，使用扩展运算符（...）也提供了一种更现代的方式来传递参数，因此在一些场景下，你可能会使用 function(...args) 代替 apply。
arguments 对象是一个类数组对象，它代表传递给函数的所有参数。这个对象并没有 indexOf 方法，因此在你的代码中调用 arguments.indexOf() 会导致错误。
如果你想在 arguments 对象上使用 indexOf 方法，你需要将它转换为一个真正的数组。你可以使用 Array.from 或者 Array.prototype.slice.call 来实现这一点。下面是一个修复的例子：
function a() {
var argsArray = Array.from(arguments); // 或者 Array.prototype.slice.call(arguments);
console.log(argsArray.indexOf('debugger'));
}
a('debugger'); // 现在不会报错
在这个例子中，Array.from(arguments) 将 arguments 对象转换为一个真正的数组，然后你就可以在这个数组上使用 indexOf 方法了。
Charles
https://blog.csdn.net/weixin_49353386/article/details/125879541
https://www.zzzmode.com/mytools/charles/
new Date().getTime() js获取时间戳
arguments 对象是一个类数组对象，它代表传递给函数的所有参数。这个对象并没有 indexOf 方法，因此在你的代码中调用 arguments.indexOf() 会导致错误。
如果你想在 arguments 对象上使用 indexOf 方法，你需要将它转换为一个真正的数组。你可以使用 Array.from 或者 Array.prototype.slice.call 来实现这一点。下面是一个修复的例子：
function a() {
var argsArray = Array.from(arguments); // 或者 Array.prototype.slice.call(arguments);
console.log(argsArray.indexOf('debugger'));
}
a('debugger'); // 现在不会报错
在这个例子中，Array.from(arguments) 将 arguments 对象转换为一个真正的数组，然后你就可以在这个数组上使用 indexOf 方法了。
btoa(‘xxx’)生成base64编码。
原型链 Array.prototype == [1,2].__proto__
document.body.contentEditable = true
这个是刚刚开启全局编辑的指令。
a=[1,2,3]
a.at(-1)
就可以定位到3了。
Array.prototype.at
省略上文
Person.xxx=xxx
Person.prototype.yyy=yyy
var p1=new Person()
Person.xxx可以调用到xxx。
但是p1.xxx调用不到，因为xxx是Person的属性，xxx没有挂在Person的原型链上。
p1.yyy可以调用到yyy，因为在原型链上。
Person.yyy调用不到yyy了，因为prototype是显示原型，只有在new它的时候才会绑定到实例化引用里。Person取原型是这样取的 Person.__proto__，Person.__proto__.__proto__等。
test.hasOwnProperty('name')等于Object.prototype.hasOwnProperty.call(test,['name'])
.hasOwnProperty(属性名)，看属性在否在本身。在原型时，返回false。
console.dir() 是一个 JavaScript 函数，用于在控制台输出一个对象的所有可枚举属性。
[1,2].__proto__.__proto__==Array.prototype.__proto__
Array.prototype.__proto__ == Object.prototype
[1,2].__proto__.__proto__== Object.prototype
[1,2].__proto__.__proto__==Array.prototype.__proto__
[1,2].__proto__.__proto__
Array.prototype.__proto__
Boolean([])是true，![]是false：
在JavaScript中，空数组 `[]` 在布尔上下文中被视为真值（truthy）。这是因为在 JavaScript 中，所有对象（包括数组）在布尔上下文中都被认为是真值，即它们被视为“真”。
布尔上下文通常是指条件语句、逻辑运算符、三元运算符等需要布尔值的地方。当在这些上下文中使用对象时，对象会被隐式地转换为布尔值。
对于数组，即使是空数组 `[]`，它仍然被视为一个存在的对象，因此在布尔上下文中被解释为真值。这是 JavaScript 中的一个设计选择，而不是严格逻辑上的“空数组应该是假值”的规则。
严格来说，JavaScript 中的假值包括 `false`、`0`、`null`、`undefined`、`NaN` 和空字符串 `""`，而除此之外的所有值都被视为真值，包括空数组 `[]`。
[]==![]的结果是true：
[]==false
''==false
true
如果你想配置使用阿里云的镜像源，可以按照以下步骤进行：
1. **找到pip配置文件：** 打开命令提示符（Command Prompt）或 PowerShell，并输入以下命令找到pip的配置文件位置：
```bash
pip config list
查找输出中的 “global” 部分，找到 “config file” 的路径。
-
编辑pip配置文件： 使用文本编辑器（如Notepad++、VSCode等）打开上一步中找到的pip配置文件。
-
添加阿里云源配置： 在配置文件中添加如下内容：
[global]
index-url = https://mirrors.aliyun.co如果你想配置使用阿里云的镜像源，可以按照以下步骤进行：
安装新系统以后，删掉老系统的efi分区，防止开机进入老系统的启动界面。
list disk
进入所选磁盘（EFI分区所在的硬盘号）
sel disk 0 （EFI分区所在的硬盘号）
磁盘的分区列表
list partition
进入所选分区
sel partition 1 （EFI分区号）
设置临时ID
SET ID= ebd0a0a2-b9e5-4433-87c0-68b6b72699c7 # 将EFI分区设置为数据分区以便删除
然后磁盘管理就可以删老的efi了。
————————————————
版权声明：本文为CSDN博主「讓丄帝愛伱」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/ximaiyao1984/article/details/127713176
https://blog.csdn.net/ximaiyao1984/article/details/127713176
panda中文文档：
https://www.pypandas.cn/
pivot 是 pandas 中的一个函数，用于将数据框从长格式（long format）转换为宽格式（wide format）。这个操作通常称为"pivoting"，因此这个函数被称为 pivot。
在长格式中，可能有一个“变量”列用于表示原来的列名，一个“值”列用于表示对应的数值。而在宽格式中，每一列代表一种变量，每一行代表一个观察。
下面是一个简单的示例：
python
Copy code
import pandas as pd
创建一个长格式的数据框
long_df = pd.DataFrame({
‘Name’: [‘John’, ‘John’, ‘Alice’, ‘Alice’],
‘Subject’: [‘Math’, ‘English’, ‘Math’, ‘English’],
‘Score’: [90, 85, 95, 88]
})
print(“长格式数据框：”)
print(long_df)
使用pivot函数将长格式转换为宽格式
wide_df = long_df.pivot(index=‘Name’, columns=‘Subject’, values=‘Score’)
print(“\n宽格式数据框：”)
print(wide_df)
在这个示例中，pivot 函数将原来的长格式数据框转换为了宽格式，其中 “Subject” 列的值成为了新的列名，“Score” 列的值成为了对应的数值。
请注意，pivot 函数的参数 index 指定了在转换过程中用作行索引的列，columns 指定了新的列名取自于哪一列，values 指定了新的数值列的数据来自于哪一列。
pivot
英
/ˈpɪvət/
美
/ˈpɪvət/
n.
支点;中心;枢轴;核心;中心点;最重要的人(或事物)
v.
(使)在枢轴上旋转(或转动)
melt 是 pandas 中的一个函数，用于将数据框从宽格式（wide format）转换为长格式（long format）。这个操作通常称为"melting"，因此这个函数被称为 melt。
在宽格式中，每一列代表一种变量，每一行代表一个观察。而在长格式中，可能会有一个“变量”列用于表示原来的列名，一个“值”列用于表示对应的数值。这对于某些数据分析和可视化任务非常有用。
下面是一个简单的示例：
python
Copy code
import pandas as pd
创建一个宽格式的数据框
wide_df = pd.DataFrame({
‘Name’: [‘John’, ‘Alice’],
‘Math’: [90, 95],
‘English’: [85, 88],
‘History’: [92, 89]
})
print(“宽格式数据框：”)
print(wide_df)
使用melt函数将宽格式转换为长格式
long_df = pd.melt(wide_df, id_vars=[‘Name’], var_name=‘Subject’, value_name=‘Score’)
print(“\n长格式数据框：”)
print(long_df)
在这个示例中，melt 函数将原来的宽格式数据框转换为了长格式，其中 “Subject” 列包含原来的科目列名，“Score” 列包含原来的数值。
请注意，参数 id_vars 指定了在转换过程中保持不变的列，var_name 指定了新的“变量”列的列名，value_name 指定了新的“值”列的列名。
confined.
melt
英
/melt/
美
/melt/
v.
（使）溶化，（使）融化;（使）溶解;(使)（心等）软化，（使）变得温柔;（使）融合;（使）消散，（使）逐渐消失;（使）逐渐变化;〈口〉（人）感到极热
n.
融化，溶化;溶解;溶化的金属，熔化物;（金属）一次（或一定时间）的融化量;〈美〉含奶酪的食品（如三明治、汉堡包等）;（溶炉的）一次装料
docker system prune -a 和 docker image prune -f 都是 Docker 提供的用于清理不再使用的资源的命令，但在功能上有一些差异。
docker system prune -a：
- 这是一个更全面的清理命令，可以清理不再使用的容器、镜像、网络和挂载卷等资源。
-a标志表示清理所有不再使用的资源，包括未被引用的镜像。- 这个命令会提示用户确认，以防止意外删除。
docker system prune -a
docker image prune -f：
- 这个命令专门用于清理不再使用的镜像。
-f标志表示强制执行，无需用户确认。使用这个标志会直接删除所有不再使用的镜像。
docker image prune -f
总的来说，docker system prune -a 是一个更综合的清理工具，可以一次性清理多种类型的不再使用的资源，而 docker image prune -f 则专注于清理不再使用的镜像。根据实际需求，可以选择使用其中一个或两者结合使用。
format字符串填充：
“xxxxxx，{}，{}”.fromat(name,date)
“xxxxxx，{name}，{name}，{date}”.fromat(name=name,date=date)
二维df里，axis=1是列，axis=0是行。(记忆方法，因为1是竖着所以是列。)
axis参数理解
axis=0或者 index：
如果是单行操作，就是某一行。
如果是聚合操作，就是指的跨行cross rows。
axis=1或者columns：
如果是单列操作，指的就是某一列。
如果是聚合操作，指的就是跨列cross columns。
按哪个axis，就是这个axis要动起来(类似for遍历)，其他axis保持不动。
apply() axis=1，，一次传一行进去。
mean() 求平均值，聚合操作，axis=1，是求每行平均值。
drop()是单行操作，axis=1，就是删一列。
sum()是聚合操作，axis=1，就是各行相加。
第一个str是series的属性attribute，第二个str是Python的属性attribute。
series没slice，但是Python的str有。
df[“test”].str.replace(“-”.“”).str.slice(0,6)
slice就是切片语法。
缺失值使用前面的有效值填充，用ffill：forward fill
df[“姓名”]=df[“姓名”].fillna(method=“ffill”)
看去重信息
df[“test”].unique()
df.describe()看平均值，等汇总信息
value_counts()看不同值出现的次数。
df[“wendu_type”].value_counts()
df.loc可以用函数进行查询
df.info()看df信息
对列分组时因为series里没test2这个列名，所以groupby的对象是df[“test2”]
df.groupby(by=[“test2”]).count()[“test”]
df[“test”].groupby(by=df[“test2”]).count()
pd.isnull(xx)
pd.notnull(xx)
df.fillna(xx) 给NaN值填充数据。
df[“age”].mean() 求平均值时，不计算为NaN的，比如说五个数据，有一个为NaN，那么求平均值，只除以4就行了。
df多条件筛选: 用 &和 |，不能用 and 、 or。
df[(df[“num”]>0 ) & (df[“num”]<=100 )]
冒号在loc里面是闭合的，即会选择到冒号后面的数据。
df.loc[“a”:“c”,[“w”,“z”]]
df方括号写数字表示取行，方括号写字符串，表示取列。
如果kafka是按update_time触发同步应用库。那么采集库清洗到基础库的时候要删掉entry_time 和 update_tim。才能触发同步。
要给 DataFrame 中满足条件的行赋值，可以使用 loc 方法:
#df 给org_name为 ‘测试org_name’ 的foundation_date赋值为 ‘2023-11-24’
df.loc[df[‘org_name’] == ‘测试org_name’, ‘foundation_date’] = ‘2023-11-24’
调试时用 if debug: 一些场景下更方便调试
在 Python 中，通常使用 debug 变量来判断是否在调试模式（debug mode）。该变量是一个内置的布尔变量，当 Python 解释器运行时，如果传递了 -O（大写字母 O）选项，debug 将被设置为 False，表示非调试模式；如果没有传递 -O 选项，debug 将被设置为 True，表示调试模式。
你可以使用 debug 变量来编写条件语句，根据是否处于调试模式执行不同的代码。以下是一个简单的示例：
python
Copy code
if debug:
print(“在调试模式下运行的代码”)
else:
print(“在非调试模式下运行的代码”)
使用 astype 方法将 DataFrame 的某一行数据转换为字符串，然后使用字符串拼接的方式：
df = pd.DataFrame(data)
选择第一行数据
row_data = df.iloc[0]
使用 astype 将行数据转换为字符串
row_str = row_data.astype(str)
使用字符串拼接得到一个字符串表示
row_as_string = ', '.join(row_str)
通过df的某几行构建新的df，并指定columns为某行值：
data = {
‘序号’: [1, 2, 3, 4, 5],
‘Name’: [‘Alice’, ‘Bob’, ‘Charlie’, ‘David’, ‘Eva’],
‘Age’: [25, 30, 22, 35, 28],
}
df = pd.DataFrame(data)
选择第 2 行到第 4 行（索引 1 到索引 3）构建新的 DataFrame
selected_rows = df.iloc[1:4]
选择行名为 1 到 3 的行构建新的 DataFrame
selected_rows = df.loc[1:3]
columns_row = df.iloc[0]
设置新 DataFrame 的列名
new_df = selected_rows.set_axis(columns_row, axis=1)
将某行设置为列名：
df.columns=df.iloc[0]
如果你的 Excel 文件中没有标题行，你可以在使用 read_excel 函数时通过设置 header 参数来指定不使用标题行。将 header 参数设置为 None 表示没有标题行。
df = pd.read_excel(‘your_excel_file.xlsx’, header=None)
isin 方法来判断某个值是否在 DataFrame 中：
value_to_check = 3
if df.isin([value_to_check]).any().any():
print(f’{value_to_check} 存在于 DataFrame 中’)
else:
print(f’{value_to_check} 不存在于 DataFrame 中’)
isin([value_to_check]) 返回一个布尔值的 DataFrame，表示每个元素是否等于 value_to_check。any().any() 部分用于检查整个 DataFrame 是否存在至少一个 True 值，即是否存在某个元素等于 value_to_check。
1. df检索，检索出第一列里所有为 '序号'的数据：
result = df.loc[df.iloc[:, 0] == '序号']
2. df检索，检索出第一行里为 '序号'的数据：（这将返回一个包含第一行中值为 '序号' 的所有列的 Series。）
result = df.loc[0, df.loc[0] == '序号']
3. df检索，检索出第一行里为 '序号'的数据：（整行作为 DataFrame 返回）
result_df = df.loc[:, df.loc[0] == '序号']
collections.OrderedDict 是 Python 标准库中的一个数据类型，它是一个有序字典（Ordered Dictionary）。它与普通字典（dict）相似，但具有保持插入顺序的特性。
在普通字典中，元素的顺序是不确定的，而在 OrderedDict 中，元素的顺序与它们被插入字典的顺序相同。这意味着当遍历 OrderedDict 时，元素的顺序是可以预测的。
from collections import OrderedDict
创建一个有序字典
ordered_dict = OrderedDict()
添加元素
ordered_dict[‘one’] = 1
ordered_dict[‘two’] = 2
ordered_dict[‘three’] = 3
或：
创建一个有序字典
ordered_dict = OrderedDict([(‘one’, 1), (‘two’, 2), (‘three’, 3)])
删除键为 ‘two’ 的元素
removed_value = ordered_dict.pop(‘two’)
如果尝试删除一个不存在的键，pop() 方法会引发 KeyError。你可以使用 pop() 方法的第二个参数指定默认值，以避免引发异常：
removed_value = ordered_dict.pop(‘nonexistent_key’, None)
这样如果键不存在，pop() 将返回 None 而不是引发异常。
需要注意的是，从 Python 3.7 开始，普通的字典（dict）也开始保持插入顺序，因此在新版本的 Python 中，OrderedDict 的使用可能相对较少。在早期版本的 Python 中，如果需要确保字典的顺序，OrderedDict 是一个常用的选择。
当你在遍历 OrderedDict 的同时尝试修改它时，会引发 RuntimeError: OrderedDict mutated during iteration 错误。这是因为在遍历过程中不能修改字典的大小，因为这可能导致迭代器失效。
如果你需要在遍历过程中删除元素，可以通过创建一个副本来避免这个问题。
df = pd.read_excel(“xxx.xlsx”, header=[1], sheet_name=None)
df = pd.read_excel(BytesIO(requests.get(xls_url).content), header=[1, 2], sheet_name=None)
read_excel如果有多个sheet，那么df就是一个<class ‘collections.OrderedDict’>类型。
当 DataFrame 的列不一致时，使用 pd.concat 可能会导致列的不匹配。在这种情况下，你可以使用 ignore_index 参数，该参数默认为 False，如果设置为 True，则会忽略列索引，生成一个新的默认整数索引。
以下是一个示例：
python
Copy code
import pandas as pd
创建两个示例 DataFrame
df1 = pd.DataFrame({‘A’: [1, 2], ‘B’: [3, 4]})
df2 = pd.DataFrame({‘A’: [5, 6], ‘C’: [7, 8]})
使用 pd.concat 进行合并，忽略列索引
result = pd.concat([df1, df2], ignore_index=True)
print(result)
在这个例子中，df1 和 df2 的列不一致，df1 有 ‘B’ 列，而 df2 有 ‘C’ 列。通过设置 ignore_index=True，创建了一个新的默认整数索引，合并后的 DataFrame 如下：
r
Copy code
A B C
0 1 3.0 NaN
1 2 4.0 NaN
2 5 NaN 7.0
3 6 NaN 8.0
请注意，NaN 表示缺失的值。这样的合并会保留所有的列，并在缺失的地方用 NaN 填充。
正则表达式| 是或者的意思，匹配任意一个
re.findall(‘（(.?)）| ((.?))’, xx基金评级结果(2019-12-31)‘)
re.findall(’（(.?)）| ((.?))‘, xx基金评级结果（2019-12-31）’)
xls = pd.ExcelFile(‘./test.xlsx’)
xls.sheet_names获取所有sheet的列表
20231121发现一个问题：read_excel和wps打开不一致。
后来发现原来是一个在前面的sheet被隐藏了，read_excel读的被隐藏的。取消隐藏即可。
去除字段里非数值类型的字符：
df[‘fund_id’] = df[‘fund_id’].apply(lambda x: ‘’.join(char for char in x if char.isdigit()))
创造df，并在创建时声明某一列为字符串类型
import pandas as pd
创建一个示例 DataFrame，并在创建时声明某一列为字符串类型
data = {‘column_with_zeros’: [‘00012’, ‘00123’, ‘00234’]}
df = pd.DataFrame(data, dtype={‘column_with_zeros’: str})
print(df)
curl发get请求
【 curl --user 用户名:密码 -XGET IP地址:端口 】
一般都是自动提交事务，所以一般execute后不需要commit：
show GLOBAL VARIABLES like ‘%AUTOCOMMIT%’
SET AUTOCOMMIT=0 禁止自动提交
SET AUTOCOMMIT=1 开启自动提交
在 MySQL 命令行的默认设置下，事务都是自动提交的，即执行 SQL 语句后就会马上执行 COMMIT 操作。因此要显式地开启一个事务务须使用命令 BEGIN 或 START TRANSACTION，或者执行命令 SET AUTOCOMMIT=0，用来禁止使用当前会话的自动提交。
————————————————
版权声明：本文为CSDN博主「sevieryang」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_42442369/article/details/106645545
https://blog.csdn.net/qq_42442369/article/details/106645545
mysql8.0认证【MySQL】Authentication plugin 'caching_sha2_password' reported error
使用MySQL8.0.30创建主从，启动从库的时候报错：
1
2
Last_IO_Errno:2061
Last_IO_Error:error connecting to mater 'repl@xxxxx:3308' - retry-time:60 retries:1 massage:Authentication plugin 'caching_sha2_password' reported error:Authentication require secure connection.
原因是在MySQL8之前，身份验证插件默认是mysql_native_password；而从8.0开始，换成了caching_sha2_password。
1.可以在mysql server的配置文件中，继续使用旧的验证插件。在配置文件中即可。
1
2
[mysqld]
default_authentication_plugin=mysql_native_password
2.也可以在用户级别进行修改，修改用户使用的验证插件即可：
1
2
3
# 相当于重新设置密码
alter user '[username]'@'[host]' identified with mysql_native_password by '[password]';
3.也可以使用GET_MASTER_PUBLIC_KEY=1，请求公钥：
1
mysql> change master to master_host='xxxx', master_port=3308, master_user='repl', master_password='pwd',master_auto_position = 1,get_master_public_key=1;
r730有时候前面小显示屏报黄色警告，也可能是加了硬件的原因，比如说硬盘、u盘。好像是因为：
在经过了各种摸索不可以之后，突然有一种想法，日志！！！
服务器都有日志存储的功能，是不是因为服务器存储了硬件的信息，让服务器按照原来的日志来读取硬件，导致新增加的硬件无法被识别，导致错误呢？
遂钻机房，开机。经过5小时漫长摸索，将DELL服务器BIOS环节每个功能都进去翻看了一遍。原来各种问题的造成，是由于DELL 服务器在iDRAC环境中保存的有一份硬件资源图。这张图会记录硬件资源的详细信息。
如果硬件更新后，但是iDRAC没有更新，那么BIOS默认会读取旧的硬件资源图。鉴于此，思考若清除之后，会不会自动重新生成硬件资源图呢（新增后的硬件信息）
思考良久，决定一试。
1.按 F10 进去DELL lifcycle conronller （生命周期管理控制器）
开机有显示lifcycle conronller 只是没有 F10 .
1.2 按F2–>iDRAC Settings -->Lifecycle Controller -->Enabled -->Back -->Finish -->Yes to save the settings and exit the utility，然后就正常了。
2.重启，按 F10 进入 lifcycle conronller
选择固件更新>启动硬件回滚，提示会回到出厂化配置的。
这种出厂化配置是直接将iDRAC恢复到出厂化的哦…
初始化过程：配置语言>ip地址，就可以了。此时在 硬件配置里是可以看到当前服务器所有的硬件信息了。保存不保存都不所谓，万一以后随时增删硬件呢？
直接敲回车！
3.重置完成。保存退出
————————————————
版权声明：本文为CSDN博主「weixin_38627000」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_38627000/article/details/112609133
https://blog.csdn.net/weixin_38627000/article/details/112609133
docker部署elasticsearch es6.8.22设置密码。如果data希望用主机的目录，那么要把data目录从容器里cp出来，然后再挂载到容器，应该是密码保证在data的缘故。
mount -l 看挂载磁盘信息(好像比fdisk -l好用,fdisk好像只能看本地磁盘,不能看云磁盘)
通过这个方法获取pod位置，就可以指定开始同步的文件和pod位置。来达到从某一个时间点同步的效果:
SHOW BINLOG EVENTS IN ‘mysql-bin.000001’;
在 MySQL 中，如果您知道一个二进制日志文件（master_log_file）的名称，但不知道其起始位置（master_log_pos），您可以通过执行 SHOW BINLOG EVENTS 命令来获取该文件的事件列表，包括每个事件的起始位置。
以下是使用 SHOW BINLOG EVENTS 的示例：
SHOW BINLOG EVENTS IN 'mysql-bin.000001';
请将 'mysql-bin.000001' 替换为您要查询的二进制日志文件的实际名称。
执行上述命令后，将返回该二进制日志文件中所有事件的详细信息，包括每个事件的起始位置（End_log_pos）。
示例输出：
| Log_name | Pos | Event_type | Server_id | End_log_pos | Info |
| mysql-bin.000001 | 107 | Format_desc | 1 | 126 | Server ver: 8.0.23-debug-log, Binlog ver: 4 |
| mysql-bin.000001 | 126 | Previous_gtids | 1 | 171 |
在上述输出中，`End_log_pos` 列显示了每个事件的结束位置。您可以查看最后一个事件的 `End_log_pos`，并将其作为下一个二进制日志文件的起始位置。请注意，这是该二进制日志文件中所有事件的最后一个位置，而不仅仅是一个事件的位置。
314.
res[res['sub_fund_id'].notna() & res['sub_fund_id']!=None ]
1.中括号里面只能用&不能用and。
2.notna()` 已经检查了 NaN 和 `None` 值
您的筛选条件看起来是正确的，但请注意在 pandas 中，`!= None` 的部分可以省略，因为 `notna()` 已经检查了 NaN 和 `None` 值。以下是正确的方式：
```python
res[res['sub_fund_id'].notna()]
这将返回一个 DataFrame，其中 ‘sub_fund_id’ 列不包含 NaN 值。如果您的目标是删除包含 None 的行，上述代码足以实现。如果您有任何进一步的问题或需要额外的帮助，请随时告诉我。
lambda表达式，一定要返回，要return，如果不返回这条数据就没了
Dell CentOS 环境下安装远程管理命令racadm
https://codeleading.com/article/67192190336/
cd /data/packages/
wget https://downloads.dell.com/FOLDER05223994M/1/OM-MgmtStat-Dell-Web-LX-9.2.0-3142_A00.tar.gz
tar zxvf OM-MgmtStat-Dell-Web-LX-9.2.0-3142_A00.tar.gz
cd /data/packages/linux/rac
运行安装程序
sh install_racadm.sh
创建软连接
ln -s /opt/dell/srvadmin/sbin/racadm /usr/sbin/racadm
安装后在/opt/dell/srvadmin/sbin/racadm位置
mysql自增id，表被后，id怎么从头加起，编辑ddl里面AUTO_INCREMENT的数值即可。
原始字符串是"123"，然后使用 zfill(6) 方法，将字符串填充到6位，不足的地方用0填充。
请注意，在这个过程中，如果原始字符串的长度超过6位，zfill 方法不会删除多余的字符，它只会在不足的地方填充0。
如果您有一个整数而不是字符串，并且希望将其转换为6位的字符串，您可以使用 str 函数将整数转换为字符串，然后再使用 zfill 方法。
original_number = 123
padded_number_string = str(original_number).zfill(6)
print(padded_number_string)
使用 dtype 参数，将每个列的数据类型都设置为字符串
1. df = pd.read_excel('your_excel_file.xlsx', dtype=str)
2. df['column_to_convert'] = df['column_to_convert'].astype(str)
3. df = pd.read_excel('your_excel_file.xlsx', dtype={'column_name': str})
在Python中，当我们尝试重命名一个不存在的列时，通常会引发一个错误。为了避免这种情况，我们可以使用pandas库中的rename函数，并设置errors='ignore’参数。这样，当遇到不存在的列时，程序将不会报错，而是忽略这些操作。
df.rename(columns={‘C’: ‘D’}, errors=‘ignore’, inplace=True)
嗯，rename好像没有errors参数，这个是drop的：
df.drop(columns=[‘C’, ‘D’], errors=‘ignore’, inplace=True)
读取excel，如果列名同时在多行，该怎么处理：
import pandas as pd
df = pd.read_excel(‘header-merged.xlsx’, header=[0,1])
cols = df.columns.map(lambda x: ‘’.join(‘’ if ‘Unnamed’ in i else i for i in x))
df.columns = cols
https://www.gairuo.com/m/pandas-read-header-excel-merged
表单 和 json传参区别：
在使用 requests 库发送 HTTP 请求时，json 和 data 是两个常用的参数，用于传递不同类型的数据。
json参数：
当你使用 json 参数时，你可以传递一个 Python 对象（通常是字典），requests 会自动将其转换为 JSON 格式，并设置请求的 Content-Type 为 application/json。这在发送 POST 请求时很有用，特别是当你需要向服务器传递 JSON 格式的数据时。
import requests
url = 'https://example.com/api/endpoint'
data = {'key': 'value'}
response = requests.post(url, json=data)
这会将 data 转换为 JSON，并设置请求的 Content-Type 为 application/json。
data参数：
data 参数用于发送表单数据，通常使用在 POST 请求中。data 参数应该是一个字典，其中包含要发送的表单字段和值。requests 会将这些数据编码为表单形式，并设置请求的 Content-Type 为 application/x-www-form-urlencoded。
import requests
url = 'https://example.com/api/endpoint'
data = {'key': 'value'}
response = requests.post(url, data=data)
这会将 data 字典编码为表单形式，并将其作为请求的正文发送。
总体来说，json 主要用于发送 JSON 格式的数据，而 data 用于发送表单数据。选择使用哪个参数取决于服务器端期望接收的数据类型。如果你要发送 JSON 数据，通常会使用 json 参数。如果你需要模拟表单提交，可以使用 data 参数。
Python爬虫：Scrapy的get请求和post请求
https://blog.csdn.net/mouday/article/details/83859158
BeautifulSoup 用法：
from bs4 import BeautifulSoup as bs
soup = bs(response.text,'lxml')
body = soup.find('body')
thead_list = body.findAll('thead')
for thead in thead_list:
th_list = thead.findAll('th')
if len(th_list)==3 and th_list[0].text=='产品代码' and th_list[1].text=='产品名称' and th_list[2].text=='产品类型':
tr_list = thead.find_next_sibling('tbody').findAll('tr')
for tr in tr_list:
td_list = tr.findAll('td')
if len(td_list) == 3:
fund_dict = {}
fund_dict['type'] = td_list[2].text.strip()
fund_dict['fund_name'] = td_list[1].text.strip()
df = pd.DataFrame(data=fund_dict,index=[0])
print(df.tail(1))
to_sql('d_fund_sell', engine_crawl_private(), df)
调试时，调试时单步调试的按钮找不到了
debuge界面。点到debug的文件名处，右键选择：show toolbar
scrapy.FormRequest的form_data 好像必须都是字符串，不能是数字。
网页上是传的数字，但是代码里传数字报错，必须传字符串。
form_data = {“productName”: “”, “currentPage”: str(1), “recordNumber”: str(10), “languageFlg”: “0”}
Linux检索多个文件的内容，查到特定值，并返回文件名：
使用grep命令可以搜索包含特定文本的文件，并返回匹配的行及文件名。下面是一个示例：
grep -r “特定值” /path/to/search/directory
这将在指定目录（/path/to/search/directory）及其子目录中查找包含"特定值"的文件，并显示匹配的行以及文件名。
在Linux中，-r或–recursive是一种用于递归操作的选项。它通常与一些命令一起使用，以表示在操作时应递归处理目录及其子目录的内容。
具体来说，对于grep命令，-r或–recursive选项用于告诉grep在搜索文本时递归地查找指定目录及其子目录中的文件。这意味着它将搜索目录中的所有文件，包括子目录中的文件，以查找匹配的文本。
修改打开文件限制：很重要！
ulimit -n 查看当前用户打开文件限制。
lsof -u 用户名 | wc -l 看当前用户已打开文件（可以超过限制，但是影响性能。）
vim /etc/security/limits.conf 修改用户打开文件数量限制:
用户名 soft nofile 65536
用户名 hard nofile 131072
低版本的pandas==0.24.2时，读取xlsx方法）
使用BytesIO对象，声明流为bytes类型：read_excel报错：
must explicitly set engine if not passing in buffer or path for io。
res = requests.get(url)
BytesIO = pd.io.common.BytesIO
df = pd.read_excel(BytesIO(result.content))
或者
from pandas.io.common import BytesIO
df = pd.read_excel(BytesIO(result.content))
https://blog.csdn.net/MacwinWin/article/details/107611256
https://blog.csdn.net/weixin_40647516/article/details/123783668
————————————————
版权声明：本文为CSDN博主「confined.」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_44821149/article/details/132413676
wine执行exe报错：exe格式无效。因为默认安装的wine是64位只能执行64位wine程序。需要安装32wine才能执行32位exe程序。
CentOS 7 安装 64 位 Wine\n1.1 安装 EPEL 软件源\nWine 3 最新稳定版包含在 EPEL 软件源中，安装 Wine 3 首先需要安装 EPEL 软件源：\nsudo yum install epel-release\n1.2 CentOS 7 安装 64 位 Wine 3.0\n安装 EPEL 软件源后，直接使用如下命令安装 64 位 Wine 3 最新稳定版：\nsudo yum -y install wine\nCentOS 7 安装 32 位 Wine\n32 位 Wine 依赖于 EPEL 软件源中 64 位 Wine，所以首先按如上安装 EPEL 软件源。\n2.1 安装 CentOS/RHEL 7 32 位 Wine 软件源：
sudo yum -y install https://harbottle.gitlab.io/wine32/7/i386/wine32-release.rpm
2.2 CentOS 7 安装 32 位 Wine
sudo yum -y install wine.i686
https://harbottle.gitlab.io/wine32/7/i386/wine-core-4.0.4-1.el7.i686.rpm
https://blog.csdn.net/yannantian198656/article/details/86523719
原文链接：https://blog.csdn.net/yannantian198656/article/details/86523719
用epel国内源：
wget -O epel.repo http://mirrors.aliyun.com/repo/epel-7.repo
然后就可以：
yum install zstd
西部数据移动硬盘设置密码教程
https://blog.csdn.net/weixin_43407833/article/details/130473271
“SS” 在电脑接口上通常指的是"SuperSpeed"，它是一种USB规范，用于指示USB设备或接口支持高速数据传输。SuperSpeed USB是USB 3.0和USB 3.1的前缀，它提供了比以前的USB规范更快的数据传输速度，允许更快的文件传输和设备连接速度。这些接口通常有一个蓝色的标志或字母"S"来表示它们支持SuperSpeed USB。
总之，“SS” 在电脑接口上表示高速传输，通常用于USB接口，以表明它们支持更快的数据传输。
硬链接（Hard Link）：
硬链接是在文件系统内部将多个文件名链接到相同的存储数据块上的不同位置的机制。
所有硬链接与原始文件（被链接的文件）共享相同的 inode 和数据块。
删除其中一个硬链接并不会影响其他硬链接，因为它们都指向相同的数据块。
硬链接只能链接到文件，而不能链接到目录。
硬链接不能跨越不同的文件系统。
软链接（Symbolic Link）：
软链接是一个指向另一个文件或目录的文件，类似于 Windows 中的快捷方式。
软链接包含了原始文件的路径信息，而不是像硬链接那样直接引用inode和数据块。
删除原始文件或目录后，软链接将变为无效，即使它仍然存在，它指向的目标也不存在了。
软链接可以链接到文件或目录，也可以跨越不同的文件系统。
符号链接（Symlink）：
符号链接是软链接的另一个术语，通常用于Linux和Unix系统中，它是一种指向另一个文件或目录的链接。
符号链接类似于软链接，它们包含了原始文件的路径信息，而不是像硬链接那样直接引用inode和数据块。
符号链接通常用于创建快捷方式或创建相对路径的引用。
总之，硬链接和软链接都是用于创建文件之间的链接，但它们的实现和用途有所不同。硬链接是文件系统级别的链接，它们共享相同的 inode 和数据块，因此对任何一个硬链接的修改都会影响其他硬链接。软链接（符号链接）是一个独立的文件，它包含指向原始文件或目录的路径信息，因此删除原始文件后，软链接将变为无效。软链接通常用于创建符号引用或路径的快捷方式。
在Linux文件系统中，软链接和硬链接的标志都可以在ls -l等命令的输出中看到，但它们的标志是不同的。软链接的标志通常是 “l”，而硬链接没有特定的标志，因为硬链接在ls命令的输出中不显示特殊标志。
软链接（Symbolic Link）的标志是 “l”： 软链接的ls -l输出会显示 “l” 标志，表示这是一个符号链接。例如：
sql
Copy code
lrwxr-xr-x 1 user user 12 Oct 21 11:45 symlinkfile -> originalfile
硬链接（Hard Link）不具有特定的标志： 硬链接不会在ls的输出中显示特殊标志，因为它们与原始文件在文件系统层面上没有显著区别。硬链接与原始文件共享相同的 inode 号，因此它们的文件属性（如权限、时间戳等）几乎完全相同。硬链接只是多个文件名引用同一份数据。
请注意，硬链接是文件系统级别的链接，因此它们与原始文件在文件系统内部被视为相同的文件。软链接是一个独立的文件，包含指向原始文件或目录的路径信息。因此，软链接具有 “l” 标志以表示它们是特殊的符号链接。
当Xshell或其他SSH终端工具的会话被强行中断，通常会导致当前会话的历史命令未被记录在持久化文件中。这是因为历史命令通常在用户的shell会话正常结束时才会被保存到历史文件中。
SSH会话的历史命令通常保存在用户的主目录下的.bash_history文件中（对于Bash shell）。这个文件会在用户退出登录或关闭终端会话时自动保存。如果会话突然被中断，例如由于网络故障或Xshell崩溃，未保存的历史命令通常不会被记录。
要确保历史命令得到持久化，您可以定期使用history命令将历史命令手动写入历史文件，或者在每个命令之后使用history -w命令将命令写入历史文件。这样可以更频繁地保存历史命令，以防止意外中断导致数据丢失。
函数需要传多个参数时候，多线程用法：
zip把参数列表按顺序压缩，然后构造一个my_func参数，传入位置参数即可。my_func函数与多线程函数不能写在一个函数里，不然会报错，Can’t pickle local object ‘main..my_func’。这个错误是因为在使用multiprocessing模块时，无法对局部函数进行pickle序列化。要解决这个问题，可以将局部函数转换为全局函数或者使用functools.partial将部分参数固定。
from multiprocessing import Pool
def parse_one_report(‘uploadInfoId’, ‘reportDesp’, ‘fundCode’):
xxx
def my_func(x):
return parse_one_report(*x)
def main():
args_list = list(zip(df_list[‘uploadInfoId’], df_list[‘reportDesp’], df_list[‘fundCode’]))
pool = Pool(processes=4)
pool.map(my_func, args_list)
pool.close()
pool.join()
pandas自定义排序：
按年份降序排序，然后相同年份，按季度降序。
df_sorted = df_list.assign(
reportDesp=pd.Categorical(df_list[‘reportDesp’], categories=[‘第四季度报告’, ‘第三季度报告’, ‘第二季度报告’, ‘第一季度报告’], ordered=True))
.sort_values(by=[‘reportYear’, ‘reportDesp’], ascending=[False, True])
.reset_index(drop=True)
在 Linux 中，可以使用 zip 命令来压缩文件夹并设置密码。首先确保已经安装了 zip 工具，然后按照以下步骤操作：
- 打开终端。
- 使用
cd命令进入到要压缩的文件夹所在的目录。 - 输入以下命令，将文件夹压缩为
.zip格式的文件（例如，将名为example_folder的文件夹压缩为example_folder.zip），并设置密码（例如，设置密码为mypassword）：
zip -r example_folder.zip example_folder -P mypassword
其中：
-r表示递归压缩；-P表示设置密码。
当函数需要多个参数时，可以使用functools.partial函数来创建一个带有部分参数的新函数，然后将这个新函数传递给pool.map进行多线程处理。
以下是使用functools.partial和线程池执行多线程任务的示例代码：
from multiprocessing.dummy import Pool as ThreadPool
from functools import partial
# 定义一个需要多个参数的函数
def my_function(arg1, arg2, arg3):
# 执行函数的操作
print(f"arg1: {arg1}, arg2: {arg2}, arg3: {arg3}")
# 创建一个偏函数，固定其中的部分参数
partial_function = partial(my_function, arg2="default_value")
# 定义要传递给函数的参数列表
ids = [1, 2, 3, 4, 5]
# 创建线程池
pool = ThreadPool(8)
# 使用偏函数和参数列表进行多线程处理
pool.map(lambda x: partial_function(x, arg3="other_value"), ids)
# 关闭线程池
pool.close()
# 等待所有线程任务完成
pool.join()
在上述示例中，my_function是一个需要三个参数的函数。我们使用functools.partial创建了一个新的函数partial_function，将arg2参数固定为"default_value"。然后，我们使用pool.map函数将partial_function作为要执行的函数，并传递参数列表ids。在lambda函数中，我们提供了缺少的参数x和arg3，并调用partial_function来执行实际的函数操作。
这样，您就可以在多线程环境下执行带有多个参数的函数。请根据您的实际需求修改函数和参数，并根据需要调整线程池的大小。
多次循环，直到成功：
while attempt < max_attempts:
try:
# 尝试执行的代码
result = 1 / 0 # 这里会引发一个异常
break # 如果成功，跳出循环
except Exception as e:
print(f"尝试失败，原因：{e}")
attempt += 1
else:
print("达到最大尝试次数，仍然失败")
vim 复制一行：yy
复制多行： v 上下移动选择多行 y
粘贴： p
Python requests使用代理报错：
方法一：
模块 urllib3 的版本，报错的是 1.26.3，没报错的是 1.25.11
在原报错环境中使用下面命令重装低版本 urllib3：
pip install urllib3==1.25.11
方法二：代理服务器只支持http，所以都写http：
proxies={
‘http’: ‘http://127.0.0.1:7890’,
‘https’: ‘http://127.0.0.1:7890’
}
Python 遭遇 ProxyError 问题记录
https://zhuanlan.zhihu.com/p/350015032
【科V学P上N网后使用爬虫以及使用pip，报错requests.exceptions.SSLError - CSDN App】
https://blog.csdn.net/m0_69082030/article/details/131525671
Linux环境变量：HTTP_PROXY 和 HTTPS_PROXY
卸载所有wine相关包
sudo yum remove $(sudo yum list installed | grep -i wine | awk ‘{print $1}’)
之前换base源，但是epel没换，所以下载到epel的包还是慢，都要换一下：
更换yum源
wget -O CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-7.repo
更换epel源
wget -O epel.repo http://mirrors.aliyun.com/repo/epel-7.repo
————————————————
版权声明：本文为CSDN博主「xiaobei72aaa」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/xiaobei72aaa/article/details/131218255
注意：alias cman=‘man -M /usr/share/man/zh_CN’
等于号两边不能有空格。
(/etc/bashrc和~/.bashrc)
在CentOS 7上配置中文man，您需要按照以下步骤进行：
首先，查找并安装man中文包。您可以使用以下命令来查找man中文安装包： yum list |grep man.*zh 。如果找不到相关的安装包，您可以尝试使用 yum -y update 命令来更新安装包。找到正确的安装包后，使用以下命令进行安装： yum install man-pages-zh-CN.noarch 。
接下来，您需要编辑配置文件以使中文包生效。具体来说，您需要打开 .bashrc 文件，然后添加以下行： alias cman = ‘man -M /usr/share/man/zh_CN’ 。完成编辑后，保存并关闭文件。
最后，为了让修改的配置生效，您需要运行以下命令： source .bashrc 。之后，您可以使用 cman 命令来查看中文man文档了。
es配置内存：./config/jvm.options 配置，两个要相等，不然会报错
找到 Elasticsearch 的安装目录。这是您解压缩压缩包时所选择的目录。
进入 Elasticsearch 的配置目录。该目录通常位于 Elasticsearch 安装目录的 config 子目录下。
打开 jvm.options 文件。这是 Elasticsearch 的 JVM 配置文件。
定位到以下两行，它们设置了初始堆内存大小和最大堆内存大小：
-Xms2g
-Xmx2g
增加堆内存大小：取消注释并增加堆内存大小的数值。例如，将初始堆内存大小和最大堆内存大小都设置为8GB，修改为：
-Xms8g
-Xmx8g
注意：确保您的系统具有足够的可用内存来支持所配置的堆内存大小。
保存并关闭文件。
重新启动 Elasticsearch，以使新的内存配置生效。
如果您在安装 Elasticsearch 时使用了启动脚本（例如 elasticsearch.bat 或 elasticsearch.sh），可以使用该脚本来启动 Elasticsearch。
如果没有启动脚本，您可以手动进入 Elasticsearch 的安装目录，并执行以下命令来启动 Elasticsearch：
./bin/elasticsearch
这样，您就可以通过增加 Elasticsearch 的 JVM 堆内存大小来解决内存不足的问题。请记住，合理配置堆内存大小对于 Elasticsearch 的性能和稳定性非常重要。确保根据您的系统资源和应用需求进行适当的调整。
top -c 可以看到具体程序运行。
MySQL5.6.30升级到8.0.33
升级路线
1、支持从 MySQL 5.7 升级到 8.0。但是，仅在通用 (GA) 版本之间支持升级。对于 MySQL 8.0，需要从 MySQL 5.7 GA 版本（5.7.9 或更高版本）升级。不支持从 MySQL 5.7 的非 GA 版本升级。
2、建议在升级到下一个版本之前升级到最新版本。例如，在升级到 MySQL 8.0 之前升级到最新的 MySQL 5.7 版本。
3、不推荐：不支持跳过版本的升级(in-place)，例如：不支持直接从 MySQL 5.6 升级到 8.0
————————————————
版权声明：本文为CSDN博主「简单爱你心所爱」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/evil_wdpp/article/details/132423750
https://blog.csdn.net/evil_wdpp/article/details/132423750
在Linux中，可以通过修改`/etc/systemd/logind.conf`文件来实现笔记本合上盖子不休眠的功能。请按照以下步骤操作：
1. 打开终端。
2. 输入以下命令以编辑`logind.conf`文件：
```bash
sudo nano /etc/systemd/logind.conf
- 在文件中找到以下行：
HandleSuspendKey=suspend
- 将该行修改为：
HandleSuspendKey=ignore
-
保存并关闭文件。
-
重启系统以使更改生效：
sudo reboot
现在，当您合上笔记本电脑的盖子时，系统将不会进入休眠状态
348.
pip3配置国内源，其中sudo时候用的是/etc/pip.conf的配置文件。
如果没有安装，就先安装pip3
sudo apt install python3-pip
1
使用pip3时，会发现下载Python第三方库特别慢，因此改为国内镜像以提速
vim ~/.pip/pip.conf
1
这里直接替换为阿里源了
[global]
timeout = 6000
index-url = https://mirrors.aliyun.com/pypi/simple/
trusted-host = mirrors.aliyun.com
来源：
https://codeleading.com/article/17595970180/
349.
问题:
innobackupex备份数据库，因为打开文件太多报错。
InnoDB: Error number 24 means 'Too many open files'
InnoDB: Some operating system error numbers are described at http://dev.mysql.com/doc/refman/5.7/en/operating-system-error-codes.html
InnoDB: File ./test_db/test_table.ibd: 'open' returned OS error 124. Cannot continue operation
InnoDB: Cannot continue operation.
参考链接：
https://zhuanlan.zhihu.com/p/554742192
解决方案：
增加系统允许的最大打开文件数。在Linux系统中，可以通过修改/etc/security/limits.conf文件来实现。例如，将以下内容添加到文件中：
你的系统用户名 soft nofile 65535
你的系统用户名 hard nofile 65535
修改/etc/security/limits.conf文件后，要使更改生效，好像要重启会话。
350.
eval()函数是Python中的一个内置函数，它可以将字符串作为代码进行解析和执行。它的基本语法如下：
eval(expression, globals=None, locals=None)
expression是一个字符串，表示要执行的Python代码。
globals（可选）是一个字典，用于指定全局命名空间。如果未提供，则使用当前全局命名空间。
locals（可选）是一个字典，用于指定局部命名空间。如果未提供，则使用当前局部命名空间。
eval()函数会解析并执行给定的代码字符串，并返回表达式的结果。
以下是一些示例：
# 执行简单的数学运算
result = eval("2 + 3")
print(result) # 输出: 5
# 执行条件判断
x = 5
is_greater = eval("x > 10")
print(is_greater) # 输出: False
# 访问全局变量
globals_dict = {'x': 5, 'y': 10}
result = eval("x + y", globals_dict)
print(result) # 输出: 15
# 访问局部变量
def my_function():
x = 5
result = eval("x + 10", locals())
print(result) # 输出: 15
my_function()
请注意，使用eval()函数要小心，尤其是在处理用户提供的输入时。不正确使用eval()函数可能会导致安全漏洞或意外的行为。确保仅在可信的环境中使用eval()函数，并且仅执行你信任的代码。
351.
linux安装mongodb的详细教程
http://e.betheme.net/article/show-1147362.html?action=onClick
352.
1.mysql安装包下载链接：
https://dev.mysql.com/downloads/mysql/
2.(mysql-8.0.34-linux-glibc2.17-x86_64.tar.gz)
(mysql-8.0.34-linux-glibc2.28-x86_64.tar.gz)
两者有什么区别：
这两个文件名中的"glibc2.17"和"glibc2.28"表示了两个不同的glibc（GNU C Library）版本。
glibc是Linux系统中的重要组件之一，它提供了许多操作系统功能和服务的实现。不同的Linux发行版和版本可能使用不同的glibc版本。
在你提供的两个文件中，"glibc2.17"表示该MySQL版本是构建和编译在glibc 2.17上的，而"glibc2.28"表示该MySQL版本是构建和编译在glibc 2.28上的。
选择正确的glibc版本对于确保MySQL与特定Linux发行版和版本的兼容性非常重要。因此，你应该根据你的操作系统使用的glibc版本来选择相应的MySQL tar.gz包进行安装。
如果你的CentOS 7.6系统使用的是glibc 2.17，那么你应该选择下载并安装"glibc2.17"版本的MySQL tar.gz包。
如果你不确定你的系统使用的是哪个glibc版本，你可以在终端中运行以下命令来查看：
ldd --version
根据输出结果中的glibc版本信息，选择对应的MySQL tar.gz包进行安装。
请注意，确保选择与你的操作系统和glibc版本兼容的MySQL版本是非常重要的，否则可能会导致不稳定或不可预测的行为。
3.
ldd (GNU libc) 2.17
Copyright (C) 2012 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
由 Roland McGrath 和 Ulrich Drepper 编写。
353.
1.Mac、Linux和Windows都能使用的文件系统：
- UDF文件系统：UDF也可以在U盘和硬盘上使用，并且它能默认兼容Windows、MacOS、Linux平台，同时支持单个文件的大小大于4GB。
- NTFS文件系统：这是Windows原生支持的文件系统，对于Linux来说，也有较好的支持。在macOS上，可以通过第三方软件（如Paragon或OSXFuse）来实现对NTFS格式硬盘的读写。
- ext4文件系统：ext4是Linux操作系统的内核文件系统，也是Linux核心组件之一。因为Linux采用虚拟文件系统的方案管理各种文件系统，所以它对多种文件系统都提供支持。
还是需要根据具体需求和设备特性进行选择。例如，由于版权问题，Mac系统默认不支持NTFS文件系统格式，需要通过第三方软件才能实现对其的读写。
2.Mac和Windows都能使用的文件系统主要有以下几种：
- FAT32：这是一种较为普遍的文件系统，被广泛应用于各种设备上。单个文件的大小不能超过4GB，这是它的主要限制。
- exFAT：exFAT原名“扩展文件分配表”，是微软公司专门为U盘等闪存存储设备设计的文件系统。它解决了FAT32等文件系统不支持4GB及更大文件的问题，被广泛应用在各种数码设备上。
- NTFS：这是Windows原生支持的文件系统，Linux的支持情况良好，而在macOS上可以通过第三方软件（如Paragon或OSXFuse）来实现读写NTFS格式的硬盘。
若要在Mac和Windows之间实现文件系统的通用性，还可以考虑使用MS-DOS（FAT）格式，此格式得到了Mac和Windows的共同支持。UDF文件系统也能默认兼容Windows、MacOS、Linux平台，同时支持＞4G单文件。
3.exFAT文件系统旨在解决FAT32等不支持4G及其更大的文件的问题。这种格式被广泛应用于闪存存储设备，特别是对于大于32GB的U盘和SD卡。
exFAT是一种折中方案，介于FAT32与NTFS之间，非常适合闪存的文件系统，但对于磁盘则不太适用。具有单文件大小最大可达16EB的优点。
exFAT文件系统得到了Linux、Mac、Windows的支持。在Mac上，原生就支持读写exFAT格式。而在Windows和Linux上，可能需要通过安装相关的工具或驱动才能实现对exFAT格式的支持。
复制大量的小文件，先批量打包成zip压缩文件再写到移动硬盘，效率要比你直接往里面要写高得多。嫌打包费时间可以用快速压缩，我们追求的不是多高的压缩率，而是把大量的随机读写变成连续读写。
但是exFAT好像稳定性差，对机械硬盘支持不好
354.
```bash
在 CentOS 上制作启动盘可以使用命令行工具 `dd`，以下是在 CentOS 上使用 `dd` 制作启动盘的步骤：
1. 插入空白的 USB 驱动器：将空白的 USB 驱动器插入计算机的 USB 端口。请注意，此过程将擦除 USB 驱动器上的所有数据，因此请确保在继续之前备份重要数据。
2. 确定 USB 驱动器的设备名称：打开终端（Terminal）应用程序，并运行以下命令来确定 USB 驱动器的设备名称：
sudo fdisk -l
在输出中查找您的 USB 驱动器，通常以 `/dev/sdX` 的形式表示，其中 `X` 是字母标识符。请注意，确保选择正确的设备，以免意外擦除您的硬盘数据。
3. 卸载 USB 驱动器（可选）：如果 USB 驱动器已经挂载，请运行以下命令卸载它，以确保 `dd` 命令可以正确写入数据：
sudo umount /dev/sdX
将 `/dev/sdX` 替换为您的 USB 驱动器设备名称。
4. 使用 `dd` 命令制作启动盘：运行以下命令来使用 `dd` 命令制作启动盘：
sudo dd if=/path/to/centos.iso of=/dev/sdX bs=4M status=progress oflag=sync
将 `/path/to/centos.iso` 替换为您下载的 CentOS ISO 镜像文件的路径，并将 `/dev/sdX` 替换为您的 USB 驱动器设备名称。
请注意，这是一个耗时的操作，命令执行完毕前请耐心等待。`bs=4M` 设置每次写入的块大小为 4MB，`status=progress` 显示进度信息，`oflag=sync` 强制 `dd` 命令在数据写入完成后进行同步。
5. 制作完成：当 `dd` 命令执行完毕后，您将获得一个 CentOS 启动盘。您可以使用此启动盘来安装或启动 CentOS 操作系统。
请注意，使用 `dd` 命令时需要小心，确保正确选择设备名称，以免意外擦除或破坏数据。在执行命令之前，请仔细检查命令中的设备名称和路径，并确保已备份重要数据。
import xxx
可以引用同一个模块多次，但是模块的实例只会创建一个。
os.rename(‘旧名字’,‘新名字’) 也可以移动文件，也可以重命名
os.remove()删除文件。
os.rmdir()删除目录。
os.mkdir()创建目录。
os.listdir列出指定目录结构。
os.getcwd()获取当前所在目录。
os.chdir(‘…’)切换当前所在目录。
tell()文件读取的位置，seek()修改读取的位置。
open的x参数，如果不存在创建文件，存在则报错。
open：r读，w写，a追加，+为操作符增加功能。
r+可读可写，w+可读可写，a+可读可写
readlines()一行一行读取内容，一次性读取到的内容放到一个列表里。
readline读一行
print(xxx，end=“”)这样print打印就不会换行了。
read接受一个size参数，指定读取字符数量。默认是-1表示全部读取。如果读到文件最后，返回一个’'字符串。read的参数size的单位是字符，不是字节，比如说6个字符 锄禾日当午加个回车，算6个字符 。每次不是从头读，是接着上一次读
方法一
a=open(filename)
content=a.read()
a.close()
方法二(自动关闭文件)
with open(filename) as a:
content=a.read()
打开中文文件，要指定编码：
open(filename,encoding=‘utf-8’)
raise手动抛出异常。raise Exception(“xxx异常信息”)
当运行出现异常以后，所有异常信息会被保存到一个专门的异常对象里。而异常传播，实际上就是异常对象抛给了调用处。
如果函数中没有异常处理，异常会继续向调用处传播。直到传递到全局作用域，如果依然没有处理，则程序终止，并显示报错信息。
没出错执行else里的，出错误了，不执行else里的。
try:
xxx
except:
xxx
else:
xxx
finally无论是否出现异常，都执行。
os.system()可以执行操作系统的命令。
os.version()获取系统的环境变量。
sys.exit()退出程序函数。
sys.platform表示python运行的平台。
sys.path放着一组路径，是列表格式，保存着模块的搜索路径。
pprint可以对打印的数据做一个简单格式化。
import pprint
pprint.pprint(需要打印的对象)
sys.argv获取运行脚本传入的参数。
sys.modules获取当前程序引入的所有模块。
__pycache__是模块缓存文件。py代码在执行钱，需要转为机器码再执行。
为了提高程序运行性能，Python在编译过一次后，把代码保存到缓存文件中，这样在下次加载包时，就可以不再重新编译，而是直接加载缓存中，编译好的代码。所以有__pycache__文件。
包package里面必须有一个__init__.py代码
if __name__=='__main__'：
pass
这里写代码，import时，不会被执行，因为import的时候，__name__不是不是主模块，即'__main__'。
__name__也是魔法方法。
添加了下划线的变量，只能在模块内部访问，通过import *引入时，不会被引入。函数也是一样，加了下划线不会被引入。
_a=30
def _b():
pass
在程序里没被引用的对象就是垃圾，需要垃圾回收。
a=[123]
a=None
那么[123]就是垃圾，没被引用。
Python里自动的垃圾回收机制，它会自动将没被引用的对象删除。
__del__是一个特殊方法，会在对象被垃圾回收前调用。
对象是否支持>号比较，由__gt__方法决定。
同理，__ge__，__ne__，__ge__等等
魔法方法非常多，主要就是配合多态的。即可以操作不同对象
print(对象)
打印的是__str__方法的返回值。
__repr__这个特殊方法，会在对当前对象使用str(对象)函数的时候调用。
可以用这个验证垃圾回收机制是否触发。
ded __del__(self):
pritf(触发了垃圾回收机制'')
del a删掉的a的变量，而不是对象。一般del不被用。
如果del a但是，a变量的对象还没其他变量引用，那么该对象没被清理。
继承是面向对象三大特性之一。子类可以直接继承
父类当中所有属性和方法。
class Dog(Animal):
pass
静态方法: 使用@staticmethod修饰的方法是静态方法。静态方法不需要指定任何默认的参数。静态方法可以通过类和实例去调用。
a.test()
A.test()
静态方法是一个和当前类无关的方法。静态方法就是一个保存到当前类中的函数。
类方法：
@classmethod
def test(cls):
print(cls)
实例方法第一个参数是self，类方法第一个参数是cls。
类方法可以通过类调用，也可以通过实例调用。
self表示当前对象，cls表现类。
实例方法可以通过实例调用，也可以通过类去调用。
a.test()等价于A.test(a)。
类方法的特点：
在类内部使用@classmethod来修饰方法属于类方法。
封装：确保对象数据安全。
继承：确保对象的可扩展性。
多态：确保程序的灵活性。
多态：比如说字符串或者列表，都可以通过len(xx)获取长度。是因为对象里都有__len__()这个方法，所以都可以用len(xx)获取长度。
多态，一个对象可以用不同的形态去呈现。
多态性，可以让方法运行不同类型的对象。所有对象都可以用，适用性好。
多重继承，class c(a,b)继承a和b两个类。但是一般避免多重继承，因为让代码复杂。同名方法先在第一个父类里找，谁在前面优先用谁。
不会重复找父类
类名.__bases__看当前类的所有父类，返回元组类型
super()可以获取当前类的父类，并且通过super()返回对象调用父类方法时，不需要传递self。
super().__init__(name)
子类中如果有和父类同名的方法，则通过子类实例去调用方法时，会调用子类的方法。
即子类覆盖了父类的方法，也叫方法的重写。
所以的类都是object类的子类。
issubclass(子类，父类)
检查一个类是否是另一个类的子类，如果是返回true
如果创建类时，省略了父类，则默认继承自object。
子类的对象既是子类的实例，也是父类的实例。isinstance(子类对象，子类)
isinstance(子类对象，父类)
都返回true
面向对象三大特征:封装，继承，多态。
例如self.__testname，类里双划线开头的属性，是对象的隐藏属性，隐藏属性只能在类的内部访问，无法通过对象访问。
ocp原则，扩展开放，修改关闭。
@property装饰器，这个是get方法的装饰器。
在方法上添加。使用该装饰器装饰的方法，必须和属性名一样。
@property
def name(self):
print('get方法执行了')
return self.name
这个可以直接调用方法。
print(p.name)
@name.setter
def name(self,name):
print('setter方法执行了')
self._name=name
p.name='喜洋洋'
可以用属性的方式来使用方法。
有setter必须定义getter，否则会报错。反之，不然。
双划线用的比较少，因为它不能真正隐藏属性。一般不希望被外部访问的属性，用一个下划线访问，这时候不是隐藏属性，只是为了告诉阅读者，不希望去改这个属性，而且单划线写法调用起来比双划线容易。
双下划线是一个伪隐藏，只不过是改了个名。其实还可以修改和访问
实际上是python内部，将名字修改为了，_类名__属性名，比如__nane变为_Person__name。
隐藏属性。
Process finished with exit code 0
# 打印序号
if __name__ == '__main__':
for i in range(200,1000):
print('{}.'.format(i))
print('\n\n\n\n\n')