2024-12-02

202412

¶curl 证书报错

curl 提示这个错

curl: (60) SSL certificate problem: self signed certificate in certificate chain
More details here: https://curl.haxx.se/docs/sslcerts.html

curl failed to verify the legitimacy of the server and therefore could not
establish a secure connection to it. To learn more about this situation and
how to fix it, please visit the web page mentioned above.

这个错误表示 curl 在建立 HTTPS 连接时，无法验证服务器提供的 SSL/TLS 证书。错误的主要原因是服务器的证书链中有一个自签名证书，无法通过 curl 默认的信任存储（CA 根证书）验证。

以下是解决方法的几种方式：

¶1. 检查服务器的证书链

确保服务器提供的证书是由受信任的 CA 签发的，而不是自签名证书。
你可以使用以下命令检查服务器证书链：
1
openssl s_client -connect <server>:443 -showcerts
其中 <server> 替换为目标服务器的域名。如果发现证书链中有问题（比如缺少中间证书），需要联系服务器管理员修复。

¶2. 忽略 SSL 证书验证

如果你明确知道连接的服务器是安全的，可以临时忽略证书验证：

1	curl -k https://<url>

但这种方法不推荐用于生产环境，因为它会跳过安全检查。

¶3. 指定自定义 CA 文件

如果你有服务器的证书或受信任的 CA 文件，可以通过 --cacert 参数指定：

1	curl --cacert /path/to/ca.pem https://<url>

¶4. 添加自签名证书到系统信任存储

下载服务器的自签名证书（或从管理员获取）。
将证书添加到系统的 CA 信任存储：
- Linux:
  1. 将证书放入 /usr/local/share/ca-certificates/ 目录。
  2. 执行以下命令更新 CA 存储：
    1
    sudo update-ca-certificates
- macOS:
  1. 使用 Keychain Access 工具将证书导入，并设置为信任。
- Windows:
  1. 使用 管理工具 > 证书 添加到“受信任的根证书颁发机构”。

¶5. 更新 `curl` 和系统根证书

确保 curl 和操作系统的 CA 存储是最新的：
- Linux:
  1
  2
  sudo apt update && sudo apt upgrade
  sudo apt install --reinstall ca-certificates
- macOS:
  使用 brew 更新 curl：
  1
  2
  brew update
  brew upgrade curl
- Windows:
  重新安装 curl 或更新操作系统。

¶6. 环境变量

如果证书链中有问题，可以使用以下环境变量忽略验证（临时措施）：

1 2	export CURL_SSL_BACKEND=openssl export SSL_CERT_FILE=/path/to/ca.pem

¶ES 集群中节点内存不一致的问题

三个节点的ES集群，其中两台机器128G内存，有一台只有32G内存，在索引数据的时候内存小的这台机器经常被oom killer杀掉，如何解决这个问题？

在 Elasticsearch 集群中，如果节点之间的硬件配置差异较大（例如内存），会导致负载分配不均的问题。特别是索引数据时，资源不足的节点容易因内存溢出（OOM）被系统杀掉。以下是解决这一问题的具体方法：

¶1. 优化 JVM 内存分配

确保为每个节点的 JVM 堆内存合理配置，避免过高或过低的设置：

JVM 堆内存大小建议为 物理内存的 50%，但不超过 30GB：
- 128G 内存的节点：设置为 -Xms64g -Xmx64g
- 32G 内存的节点：设置为 -Xms16g -Xmx16g

修改 Elasticsearch 配置文件：

1	vim /etc/elasticsearch/jvm.options

调整如下：

1 2	-Xms16g -Xmx16g

重启 Elasticsearch：

1	sudo systemctl restart elasticsearch

¶2. 调整索引和负载分配策略

¶（1）限制分片分配到内存较小的节点

你可以通过设置节点的标签，限制索引分片分配到资源有限的节点：

在内存小的节点（32G）上，添加标签：
1
vim /etc/elasticsearch/elasticsearch.yml
增加以下配置：
1
node.attr.low_memory: true

为索引指定分片分配规则，避免分片分配到标记为 low_memory 的节点：

curl -XPUT "http://<ES_HOST>:9200/my_index/_settings" -H 'Content-Type: application/json' -d'
{
  "settings": {
    "index.routing.allocation.exclude.low_memory": "true"
  }
}'

¶（2）调整分片大小

如果分片过大，索引过程中的内存消耗会显著增加。将每个分片的大小限制在 20-40GB：

计算合理的分片数量：

1	分片数 = 索引总大小 / 每个分片大小

在创建索引时指定分片数：

curl -XPUT "http://<ES_HOST>:9200/my_index" -H 'Content-Type: application/json' -d'
{
  "settings": {
    "number_of_shards": 5,
    "number_of_replicas": 1
  }
}'

¶3. 使用协调节点

如果内存小的节点经常被杀死，考虑让它作为一个协调节点，仅负责处理请求的路由，而不存储数据或参与索引操作。

修改小内存节点的配置文件：

1	vim /etc/elasticsearch/elasticsearch.yml

配置为协调节点：

1
2
3

node.master: false
node.data: false
node.ingest: false

重启节点后，它将作为一个轻量级的协调节点。

¶4. 增加虚拟内存

在资源有限的节点上，启用和增加虚拟内存（swap），避免 OOM：

检查当前 swap 配置：
1
free -h

如果没有启用 swap，创建一个 swap 文件：

sudo fallocate -l 8G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile

持久化配置：

1	echo '/swapfile none swap sw 0 0' \| sudo tee -a /etc/fstab

¶5. 优化查询和索引操作

¶（1）批量索引

确保客户端程序使用 Bulk API 进行批量写入，并限制单次请求的大小（如 5MB 或 500 文档）。

¶（2）调整刷新间隔

增加刷新间隔以减少频繁的磁盘 I/O：

curl -XPUT "http://<ES_HOST>:9200/my_index/_settings" -H 'Content-Type: application/json' -d'
{
  "settings": {
    "index.refresh_interval": "30s"
  }
}'

¶6. 监控和调整

使用 Kibana 或 Metricbeat 监控节点的内存、CPU 和 I/O 使用情况。
动态调整堆内存、分片分配和刷新策略。

¶7. 增加硬件资源

如果内存小的节点仍然无法满足需求，考虑增加其内存或替换为硬件配置一致的节点。

¶让被 OOM killer 杀掉的服务自动重启

要让 Elasticsearch 服务在被 OOM killer 杀掉后自动重启，可以通过调整 systemd 的服务配置来实现。以下是具体步骤：

¶1. 修改 systemd 服务配置

编辑 Elasticsearch 的 systemd 单元文件或添加覆盖配置：

¶步骤 1: 创建覆盖文件

运行以下命令创建或修改覆盖文件：

1	sudo EDITOR=vim systemctl edit elasticsearch.service

¶步骤 2: 添加自动重启配置

在打开的编辑器中，添加以下内容：

1
2
3

[Service]
Restart=always
RestartSec=5

Restart=always: 表示无论因何种原因停止，服务都会重启。
RestartSec=5: 设置重启前的等待时间为 5 秒（可以根据需求调整）。

¶步骤 3: 保存并退出

保存文件并退出编辑器。

¶2. 重新加载 systemd 配置

运行以下命令以使更改生效：

1 2	sudo systemctl daemon-reload sudo systemctl restart elasticsearch.service

¶3. 验证配置

检查是否启用了自动重启机制：

1	systemctl show elasticsearch.service \| grep Restart

应看到输出类似：

1 2	Restart=always RestartUSec=5s

¶4. 查看日志

测试时可以通过 journalctl 检查日志确认服务是否成功重启：

1	journalctl -u elasticsearch.service -f

完成上述步骤后，当 Elasticsearch 被 OOM killer 杀掉时，服务会在指定的时间后自动重启。

¶ES 进程被 OOM 杀掉

最终做了这几个操作先：

swap 从 512M 增加到了 8G：fallocate -l 8G /swapfile
java 堆外内存限制在 8G：-XX:MaxDirectMemorySize=8g
设置 systemd 的 ES 服务挂掉自动拉起：Restart=always RestartSec=5

没做的操作：

手工设置 -Xms -Xmx：这个 ES 默认的自动配置应该就可以
设置节点的标签，限制索引分片分配到资源有限的节点：这样这个节点就废了，不存储数据了
调整分片大小: 目前 10 个分片属于合理范围，分片太多碎片会太多，分片太少，单个分片太大也吃内存
使用协调节点 node.master: false node.data: false：这个节点就太鸡肋了
使用 Bulk API 进行批量写入，并限制单次请求的大小：目前已经时 bulk 写入了，单词请求适中
增加硬件配置：物理机，增加不了内存
优化刷新时间 “refresh_interval”: “30s”：这个之前已经设置了
限制搜索线程池 thread_pool.write.size: 2：感觉和 OOM 关系不大，没改
文件描述符限制 ulimit -n 65536：应该不是这个原因
增加 mmap 支持 sysctl -w vm.max_map_count=262144: 应该没关系
减少写入操作时的主分片分布到内存较小的节点 “index.routing.allocation.require._name”: “big_memory_node”：后续再使用
尝试调大 min_free_kbytes 和 watermark_scale_factor 让缓存尽快回收。：暂未调整，怕影响全局。

其它:

像es这种，不光要占内存，写文件还要占用文件系统缓存（cache）。cache占了太大，回收不及时，触发了min水位线，就导致oom了。
如果确实当时是cache占用过大，就不能通过调整jvm参数解决，需要调整内存（cache）回收策略，或者手工回收cache。
机器当时有没有记录sar信息，可以看看当时的cache有多少。如果是centos，默认就开启了，可以看看故障时间点前后的cache使用量。
尝试调大 min_free_kbytes 和 watermark_scale_factor，让缓存尽快回收。或者写个crontab，定期echo 3 > /proc/sys/vm/drop_caches
可以调 watermark_scale_factor，拉大min和low的“间隔”，触发了 low 就开始异步回收了。
看下 dmesg 里面有更详细日志有当时系统内存大小，被 kill 的 java 进程的得分
如果不是一直OOM，可以通过_nodes/stats/jvm这个API看看jvm使用情况, 尤其是内存飙升的时候, 这个版本的熔断功能应该是相对完善了，OMM也可能是一些操作引起的，比如比较重量级的查询，合理设置一下。

¶PHP 7/8 新特性

¶PHP 7.0 (2015)

标量类型声明：支持在函数参数和返回值中使用 int、float、string 和 bool。
返回类型声明：函数可以显式声明返回值类型。
匿名类：支持使用 new class 创建匿名类。
太空船操作符 (<=>)：简化比较逻辑。
Null 合并操作符 (??)：用于处理空值的默认值。
性能提升：Zend 引擎 3 实现，带来显著性能优化和更低的内存使用。
抽象语法树（AST）：引入新的底层实现，为未来扩展和工具奠定基础。
致命错误转为异常：改进了错误处理，使致命错误以异常形式抛出。

¶PHP 7.1 (2016)

可空类型：通过前置 ? 支持参数或返回值可以为 null（如：?int）。
类常量可见性：支持 public、protected 和 private 修饰类常量。
多异常捕获：通过 catch (Exception1 | Exception2 $e) 捕获多个异常类型。
Void 返回类型：允许声明函数无返回值 (void)。
异步生成器：通过 yield 和 Generator 提供更强的协程支持。
短数组解构：支持列表解构（[$a, $b] = [1, 2]）。

¶PHP 7.2 (2017)

参数类型的对象扩展：支持用 object 作为类型提示。
加密扩展更新：引入 Argon2 算法，用于更安全的密码哈希。
抽象方法覆盖：子类覆盖抽象方法时参数类型声明必须匹配。
多字节字符串增强：mbstring 增强对 UTF-8 处理能力。

¶PHP 7.3 (2018)

灵活的 Heredoc 和 Nowdoc 语法：改进多行字符串的书写方式。
数组解构改进：list() 可以用于数组的键值对。
is_countable() 函数：用于判断变量是否可计数。
JSON 扩展增强：JSON_THROW_ON_ERROR 常量提供异常抛出方式处理错误。
引用赋值列表支持：支持 list($a, &$b) = ...。

¶PHP 7.4 (2019)

箭头函数 (fn)：简化单行匿名函数（fn($x) => $x * 2）。
类型属性：属性声明可直接带类型（如：public int $age;）。
弱引用：新增 WeakReference 类，支持更灵活的对象引用。
Null 合并赋值操作符 (??=)：简化赋值逻辑。
预加载（Preloading）：支持在服务器启动时预加载代码，提升性能。
反射增强：更强的反射能力，例如对类属性类型的支持。
废弃动态属性：动态添加属性警告，增强代码规范性。

¶PHP 8.0

命名参数：调用函数时可以通过参数名指定值，顺序可变。
联合类型：使用 | 表示多个类型（e.g., int|float）。
属性（Attributes）：引入原生注解功能。
匹配表达式（Match Expression）：简洁替代 switch。
Nullsafe 操作符：安全地访问可能为 null 的对象属性或方法（?->）。
JIT 编译器：显著提升运行性能。
字符串中的数值比较更严格：解决宽松类型比较的问题。

¶PHP 8.1

只读属性（Readonly Properties）：属性声明为只读后不可修改。
枚举类型（Enums）：支持定义枚举类。
Fibers：为协程提供更底层的 API。
交集类型（Intersection Types）：用 & 表示的多个接口类型要求。
新初始化对象语法：支持 new 连续赋值（new ClassName()->property = value）。
array_is_list() 函数：判断数组是否为列表。

¶PHP 8.2

只读类（Readonly Classes）：声明类中所有属性为只读。
动态属性弃用：不再允许类动态添加属性，除非显式声明 #[\AllowDynamicProperties]。
独立类型（Standalone Types）：支持 null 和 true 等独立类型。
敏感参数红acted：支持通过 #[SensitiveParameter] 防止参数在错误中暴露。
数组解包支持字符串键：改进解包功能。

¶PHP 8.3

json_validate() 函数：验证 JSON 字符串的有效性。
更灵活的 declare()：支持块级作用域。
新随机扩展 API：更安全和现代的随机数生成。
负数索引支持 str_ends_with：改进字符串操作函数。

问题：如何过滤掉一个 csv 中第 3, 4, 5 列都是 0 的行

尝试 1: 用 csvgrep -c 6 -m 0 --invert-match 过滤，失败，因为只能一次只能过滤一个列，多个管道后是 and 的逻辑，不是 or 的逻辑
尝试 2: 用 csvsql --query "SELECT * FROM stdin WHERE NOT (c3 = 0 AND c4 = 0 AND c5 = 0)" 过滤，失败，csvsql 会把整个 csv 灌到 sqlite 里，过程特别慢，csv 太大内存也撑不住。
尝试 3: 因为 3,4,5 列正好是最后三列，而且都是数字列，用 grep -Ev ',0,0,0$' 过滤，失败，-E 不认行尾标志 $，怀疑行尾有换行，用 grep -Ev ',0,0,0\n$'，grep -Ev ',0,0,0\r$' 都不行，任何行都没过滤掉
尝试 4：使用 grep -Pv ',0,0,0\n$' 失败，使用 grep -Pv ',0,0,0\r$' 终于正常了，感觉每行有个 \r 没有去掉，但 grep -P 会很慢
尝试 5：先删掉 \r 再用 grep -E 既能满足需求，速度也很快：tr -d '\r' | grep -Ev ',0,0,0$'

分析：

可以用 od 命令查看 csv 的行结束符：head -n1 | od -xc，或者用 cat -A 查看不可见字符
grep -E 和 grep -P 都使用 $ 表示行尾, 但如果行尾有 \r，grep -E 会失败。
grep -E 不支持标准转义序列（例如 \n, \r 等），要使用八进制或十六进制表示:
- echo -e "line1\r\nline2" | grep -E $'line1[\x0D]'
- echo -e "line1\r\nline2" | grep -E $'line1\15'
- 引号前面的 $ 是 Bash 的特殊符号，表示 ANSI C 风格字符串，和 grep 无关。
- 包含 -r 的文本在终端里可能无法查看，需要过滤掉才能正常显示: echo -e "line1\r\nline2" | grep -E $'line1\15' | tr -d '\r'
grep -P 可以用 \r?$ 来兼容 CRLF 和 LF。

关于游戏出海CPC研究
https://www.luolink.com/article/11a298ea-4c9a-8037-a45a-e58b822b8285

免费 API
https://publicapis.io/

AI 搜索
https://www.perplexity.ai/search/i-have-a-blog-about-mysql-back-lIgz9FzIQC6pcreJccwDNg

问题：如何查看 MySQL 中最近一分钟执行了多少 CRUD 操作，平均耗时有多少？

背景：有时候看到 MySQL 的 CPU 占用特别高，使用 show process list 只能看到耗时较久的查询，
但看不到那些执行很快，但次数很多的查询，如果开 general_log 的话，对数据库性能影响又很大，
所以有时候我们需要查看最近一段时间，比如 1 分钟，或 10 分钟内，select, insert, update 的
请求量大概有多少，以便初步定位引起 CPU 高的原因。

分析：

events_statements_summary_global_by_event_name 表中有服务器启动依赖每个 event 执行的次数和花费的时间
可以创建一个临时表，记录 events 表的快照
然后 sleep 1 分钟，
再把最新的 events 表的数据减去快照里的值，即可计算出这段时间每种操作的条数和平均执行时间。

代码如下：

DROP TEMPORARY TABLE IF EXISTS temp_queries;
CREATE TEMPORARY TABLE temp_queries AS
SELECT NOW() AS Sample_Time, EVENT_NAME,SUM_TIMER_WAIT AS Total_Time, COUNT_STAR AS Total_Queries
FROM performance_schema.events_statements_summary_global_by_event_name
WHERE EVENT_NAME like 'statement/sql%';

SELECT SLEEP(10);

with start as(
    SELECT * FROM temp_queries
),end as (
    SELECT NOW() AS Sample_Time, EVENT_NAME,SUM_TIMER_WAIT AS Total_Time, COUNT_STAR AS Total_Queries
    FROM performance_schema.events_statements_summary_global_by_event_name
    WHERE EVENT_NAME like 'statement/sql%'
), diff as(
    select start.EVENT_NAME, TIMESTAMPDIFF(SECOND, start.Sample_Time,end.Sample_Time) AS Seconds,
    (end.Total_Queries-start.Total_Queries) Querys,
    (end.Total_Time-start.Total_Time) Total_Time_Diff
    from end join start on end.EVENT_NAME = start.EVENT_NAME
)
select Seconds, EVENT_NAME,Querys,Total_Time_Diff/1000000000000/Querys as AvgTime
from diff where Querys> 0 order by Querys desc;

查看具体的统计

select * from performance_schema.setup_consumers where name like 'events_statements%';
update performance_schema.setup_consumers set enabled = 'YES' where name ='events_statements_history_long';
UPDATE performance_schema.setup_instruments SET ENABLED = 'NO', TIMED = 'NO' WHERE NAME in ('statement/com/Quit', 'statement/sql/change_db','statement/sql/set_option','statement/com/Close stmt','statement/com/Prepare','statement/com/Execute');

select EVENT_NAME,count(*) from performance_schema.events_statements_history_long group by EVENT_NAME order by count(*) desc limit 10;
select * from performance_schema.events_statements_history_long where EVENT_NAME like 'statement/sql/%' limit 10\G
select CURRENT_SCHEMA,count(*) from performance_schema.events_statements_history_long group by CURRENT_SCHEMA;

select DIGEST_TEXT, count(*) count, ROUND(AVG(TIMER_WAIT/1000000000000),2) avg_time 
from performance_schema.events_statements_history_long 
where DIGEST_TEXT is not null 
group by DIGEST_TEXT order by count(*) desc 
limit 10\G


UPDATE performance_schema.setup_instruments SET ENABLED = 'YES', TIMED = 'YES';
update performance_schema.setup_consumers set enabled = 'NO' where name ='events_statements_history_long';

general log

SHOW VARIABLES LIKE 'general_log_file';
SET GLOBAL general_log = 'ON';
SET GLOBAL general_log = 'OFF';

¶links

cloudflare D1 database quick start
https://developers.cloudflare.com/d1/get-started/

使用 eBPF 诊断服务网格网络性能
https://skywalking.apache.org/zh/diagnose-service-mesh-network-performance-with-ebpf/

什么是波动率锥？如何用波动率锥设计期权策略？
https://zhuanlan.zhihu.com/p/74766025

使用隐含波动率和历史波动率设计这样一个交易策略：

当 HV 大于波动率锥 70%分位数时，卖出跨式期权组合；
当HV < 70%分位时，则比较 HV 与 IV 的大小关系，若 IV < HV，则买入跨式期权组合；
若IV−HV > ε,则卖出跨式期权组合。根据 IV 与 HV 的关系， ε 取 max(IV 与 HV 差的均值，0)。

期权卖方盈利终极指南-第五章深入了解波动率
https://mp.weixin.qq.com/s?__biz=MzkyMzA5MzgwNQ==&mid=2247483778&idx=1&sn=a567c72ac3cdf1ef67b89ea178124500&chksm=c1eb1fc0f69c96d6d608e366669c1bfaffe245827b9a24560315952fd6a7f7030d7b010dfbf9&cur_album_id=2782448054980640768&scene=189#wechat_redirect

期权卖方盈利终极指南-第六章专家级的日历价差教程
https://mp.weixin.qq.com/s/ZuwCyvSQ2LKc-w2wPSSrtw

¶《MySQL 101》教程提纲

¶第1章：简介

MySQL是什么
- 数据库的定义和用途
- MySQL的特点与优势
- MySQL的常见应用场景
MySQL架构概览
- MySQL的客户端-服务器模型
- 存储引擎的概念（InnoDB vs MyISAM）

¶第2章：安装与设置

安装MySQL
- Windows平台安装
- macOS平台安装
- Linux平台安装（APT/YUM/Docker）
基本配置
- 配置文件（my.cnf/my.ini）详解
- 数据目录和日志文件
启动与关闭服务
- 使用命令行管理MySQL服务
- 常见启动参数
连接到MySQL
- 使用命令行客户端
- GUI工具（如MySQL Workbench）简介

¶第3章：基础操作

数据库与表
- 创建数据库和表
- 删除数据库和表
- 查看已有数据库和表
基本数据操作
- 插入数据（INSERT语句）
- 查询数据（SELECT语句）
- 更新数据（UPDATE语句）
- 删除数据（DELETE语句）
数据类型
- 数值类型
- 字符串类型
- 日期和时间类型

¶第4章：高级查询

查询条件
- WHERE子句
- 比较运算符与逻辑运算符
排序与分页
- 使用ORDER BY排序
- LIMIT实现分页
聚合与分组
- COUNT, SUM, AVG等聚合函数
- GROUP BY与HAVING的用法
多表查询
- JOIN语法（INNER JOIN, LEFT JOIN, RIGHT JOIN）
- 子查询的使用

¶第5章：索引与性能优化

索引基础
- 索引的种类（主键索引、唯一索引、普通索引）
- 创建与删除索引
- 索引的作用与限制
查询优化
- 使用EXPLAIN分析查询
- 优化SQL语句的技巧
数据库设计优化
- 规范化与反规范化
- 合理设计表结构

¶第6章：事务与锁

事务基础
- 什么是事务
- 事务的ACID特性
- 使用BEGIN, COMMIT, ROLLBACK控制事务
锁机制
- 行锁与表锁
- 死锁的定义与处理

¶第7章：存储引擎

存储引擎概览
- InnoDB与MyISAM的对比
- 如何选择合适的存储引擎
深入InnoDB
- 支持事务与外键
- 表空间与文件结构

¶第8章：用户与权限管理

用户管理
- 创建与删除用户
- 修改用户密码
权限控制
- 权限的种类
- 授权与撤销权限
- 使用SHOW GRANTS查看权限

¶第9章：备份与恢复

备份方法
- 逻辑备份（mysqldump）
- 物理备份（使用Xtrabackup等工具）
数据恢复
- 恢复单个表或整个数据库
- 处理备份与恢复中的常见问题

¶第10章：高可用与集群

主从复制
- 复制的原理与配置
- 常见问题及解决方案
高可用架构
- MySQL Cluster简介
- 使用组复制（Group Replication）
- ProxySQL与负载均衡

¶附录

常见问题与解决方法
实用工具推荐
- 数据库管理工具（如phpMyAdmin、DBeaver）
- 性能监控工具
参考文献与学习资源
- 官方文档
- 推荐的书籍与在线教程

https://developers.cloudflare.com/reference-architecture/diagrams/serverless/fullstack-application/

¶使用 redis 布隆过滤器对 csv 去重并插入 mysql

使用 Python 的 csv 模块读取 CSV 文件，使用 pymysql 访问 MySQL 数据库。
使用 Redis 的 RedisBloom 模块实现布隆过滤器去重。
布隆过滤器提示不存在的，直接插入 mysql 。
布隆过滤器提示存在，要去 mysql 里确认，确实不存在的也要插入到 mysql。
每缓存 1000 行要插入的数据，批量一次插入到 mysql，提高插入效率，降低内存消耗。

import csv
import redis
import pymysql

# 连接到Redis
r = redis.Redis(host='localhost', port=6379, db=0)

# 连接到MySQL
connection = pymysql.connect(host='localhost',
                             user='your_username',
                             password='your_password',
                             database='your_database',
                             cursorclass=pymysql.cursors.DictCursor)

# 创建布隆过滤器
bloom_filter_name = 'bloom_filter'
error_rate = 0.01  # 假阳性率
initial_capacity = 10000000  # 初始容量
r.execute_command('BF.RESERVE', bloom_filter_name, error_rate, initial_capacity)

# 读取CSV文件并去重
csv_file_path = 'your_file.csv'
batch_size = 1000  # 批量插入的大小
unique_rows = []  # 存储去重后的数据

with open(csv_file_path, 'r', newline='', encoding='utf-8') as csvfile:
    reader = csv.reader(csvfile)
    headers = next(reader)  # 读取表头
    column_to_check_index = headers.index('Column1')  # 需要去重的列名在表头中的索引

    for row in reader:
        item = row[column_to_check_index]
        if r.execute_command('BF.EXISTS', bloom_filter_name, item) == 0:
            # 如果布隆过滤器提示元素不存在，直接添加到布隆过滤器和unique_rows中
            r.execute_command('BF.ADD', bloom_filter_name, item)
            unique_rows.append(row)
        else:
            # 如果布隆过滤器提示元素可能存在，需要在MySQL中确认
            with connection.cursor() as cursor:
                # 构建查询SQL语句，这里需要根据实际表结构调整
                sql = "SELECT * FROM your_table WHERE Column1 = %s"
                cursor.execute(sql, (item,))
                result = cursor.fetchone()
                if not result:
                    # 如果MySQL中不存在该项，则添加到布隆过滤器和unique_rows中
                    r.execute_command('BF.ADD', bloom_filter_name, item)
                    unique_rows.append(row)

        # 当unique_rows累计到1000行时，批量插入MySQL
        if len(unique_rows) >= batch_size:
            self.insert_into_mysql(connection, unique_rows)
            unique_rows = []  # 清空列表以便下一批数据

# 插入剩余的数据
if unique_rows:
    self.insert_into_mysql(connection, unique_rows)

# 定义批量插入MySQL的函数
def insert_into_mysql(connection, data):
    try:
        with connection.cursor() as cursor:
            # 构建插入SQL语句，这里需要根据实际表结构调整
            sql = "INSERT INTO your_table (Column1, Column2, ...) VALUES (%s, %s, ...)"
            # 请根据实际情况替换列名和值
            cursor.executemany(sql, [tuple(row) for row in data])
            connection.commit()
    except pymysql.Error as e:
        print(f"Error inserting data into MySQL: {e}")
        connection.rollback()

# 关闭数据库连接
connection.close()

统计每分钟执行 url 2xx 和 5xx 的应答数

tail -n1000000 /var/log/nginx/access.log | awk '
NF>=25&&$12~/api\/user/ {
    split($1, t, ":");
    currentMinute = t[1] ":" t[2];

    if (prevMinute != "" && currentMinute != prevMinute) {
        print prevMinute, count2xx[prevMinute], count5xx[prevMinute];
        delete count2xx[prevMinute];
        delete count5xx[prevMinute];
    }

    if (!(currentMinute in count2xx)) {
        count2xx[currentMinute] = 0;
        count5xx[currentMinute] = 0;
    }
    if ($2 ~ /^2[0-9][0-9]$/) count2xx[currentMinute]++;
    if ($2 ~ /^5[0-9][0-9]$/) count5xx[currentMinute]++;

    prevMinute = currentMinute;
}
END {
    if (prevMinute != "") {
        print prevMinute, count2xx[prevMinute], count5xx[prevMinute];
    }
}'

csv 过滤某列不为空的行

csvgrep -c 2 -r '.+' data.csv

过滤某列不符合某个规则的行，两种方式

csvgrep -c 5 -r '^(?!.+)' data.csv 
csvgrep -c 5 -i -r '.+' data.csv

过滤第 5 列为空，但第 3 列不为空的行，只打印第 1，3 列。

csvgrep -c 5 -i -r '.+' data.csv  | csvgrep -c 3 -r '.+'| csvcut -c 1,3 | csvlook

¶mysql 高可用方案对比

在 MySQL 的高可用 (HA) 方案中，普通主从 (Master-Slave)、MHA (MySQL High Availability)、MM (双主模式 Master-Master)、MGR (MySQL Group Replication) 都是常见的架构设计，各自有不同的优缺点。以下是详细的综合对比：

¶1. 普通主从 (Master-Slave)

架构特点

主库负责读写，备库仅用于读请求（需要读写分离）。
数据通过 Binlog 复制到从库。

优点

配置简单，实施成本低。
备库可用于读分担，提升查询性能。
容错性好，主库故障后可以手动切换到从库。

缺点

主从切换需要人工干预或额外工具，切换过程有停机时间。
数据延迟：从库可能有同步延迟。
不支持自动故障恢复。

适用场景

适合对高可用要求不太高的小型项目。
读多写少的场景，通过多从库扩展读性能。

¶2. MHA (MySQL High Availability)

架构特点

在普通主从架构的基础上，MHA 提供自动主从切换和故障恢复。
包括 MHA Manager 和 MHA Node 两部分。
切换时能最大程度保证数据一致性，快速提升新主库。

优点

自动化主从切换，减少人工干预。
数据一致性强，主库故障后从库能快速接管。
与现有的主从架构兼容性高，部署较简单。

缺点

写性能仍然受限于单主架构。
切换过程中仍可能丢失少量事务。
依赖第三方组件，官方不再维护更新。

适用场景

需要高可用的中小型系统，要求尽可能减少停机时间。
不需要太复杂的高可用架构的场景。

¶3. MGR (MySQL Group Replication)

架构特点

MySQL 官方推出的多主复制技术，支持多主或单主模式。
节点间基于 Paxos 协议或 Raft 协议实现强一致性。
自动故障检测和恢复，支持高并发。

优点

数据一致性强，内置的自动化切换和故障恢复。
无需额外组件，原生支持，安全性高。
多主模式下支持多点写入。
自动处理网络分区问题，支持事务级复制。

缺点

配置复杂，对网络和硬件要求较高。
写性能受限于强一致性协议。
多主模式存在冲突处理问题，适合特定场景。

适用场景

要求强一致性和高可用的分布式系统。
对于需要横向扩展写能力的场景，单主模式推荐。

¶4. MM (双主模式 Master-Master)

架构特点

两个主库同时支持写入，通过双向复制同步数据。
双主通常配置成一个主库读写，另一个主库仅做备份。

优点

支持双主写，切换速度快。
两个主库均可承载业务流量，提升容灾能力。

缺点

数据一致性风险：双向复制可能引发冲突或循环更新。
配置和运维复杂，对业务有一定限制。
不支持高并发写入，事务冲突较难处理。

适用场景

需要快速切换主库，数据写入量不高的场景。
双活中心场景，但一般结合业务限制写入区域以减少冲突。

¶综合对比表

方案	优点	缺点	适用场景
普通主从	配置简单、读写分离、成本低	手动切换，存在延迟，无法自动恢复	适合小型项目、读多写少场景
MHA	自动切换、快速恢复、一致性好	依赖第三方组件，维护更新少	中小型高可用需求系统
MGR	原生支持，强一致性，自动恢复	配置复杂，写性能受限	分布式系统，高并发写入场景
MM	快速切换，双主冗余	数据冲突风险，运维复杂	双活容灾中心，小写入业务场景

¶总结建议

普通主从适合预算有限或对高可用要求不高的项目。
MHA是普通主从的升级，适合追求高可用但预算有限的场景。
MGR是官方推荐的现代 HA 方案，适合对数据一致性要求高的场景。
MM适合少量写入，快速主备切换场景，但需要谨慎设计业务逻辑。

那些上千页的计算机书，用什么姿势看？
https://zhuanlan.zhihu.com/p/371097638

¶es 设置副本分片

如何给elasticsearch的某个索引设置number_of_replicas为1

PUT /<index_name>/_settings
{
  "index": {
    "number_of_replicas": 1
  }
}

在分片调整期间集群是否为yellow状态，如何查看分片调整的进度

curl -X GET "http://<elasticsearch_host>:9200/_cat/recovery?v"
curl -X GET "http://<elasticsearch_host>:9200/_cat/shards?v"
curl -X GET "http://<elasticsearch_host>:9200/_cat/shards?v"

` curl -X GET “http://<elasticsearch_host>:9200/_cluster/allocation/explain” -H ‘Content-Type: application/json’ -d’
{
“index”: “my_index”,
“shard”: 0,
“primary”: false
}
’
curl -X GET “http://<elasticsearch_host>:9200/_cluster/health?pretty”

_cat/recovery 如何对显示的行和列进行过滤呀

curl -X GET "http://<elasticsearch_host>:9200/_cat/recovery?v&h=index,shard,stage,bytes_recovered,percent"
curl -X GET "https://<ip>/_cat/recovery?v&h=index,shard,stage,bytes_recovered,bytes_percent,source_host,target_host" | awk '$3=="index"||$3=="stage"'

You want to benchmark Elasticsearch? Then Rally is for you. It can help you with the following tasks:

Setup and teardown of an Elasticsearch cluster for benchmarking
Management of benchmark data and specifications even across Elasticsearch versions
Running benchmarks and recording results
Finding performance problems by attaching so-called telemetry devices
Comparing performance results

https://esrally.readthedocs.io/en/stable/index.html

¶ES 部分查询

我的一个ES索引，有3个node，这个索引有10个主分片，0个副本分片，当一个node挂掉后，如何仍然提供服务，只是搜索结果里少了挂掉node上的数据。

在 Elasticsearch 中，当一个节点挂掉时，如果索引的主分片分布在该节点上，且没有副本分片，默认情况下集群无法继续服务，因为 Elasticsearch 设计为提供一致性保障，不会返回部分数据。然而，如果明确需要支持部分数据查询，可以通过调整一些配置来实现，即允许部分分片返回结果。

以下是具体步骤和方法：

¶步骤 1: 启用 `partial` 查询结果

Elasticsearch 默认要求所有查询涉及的分片都必须可用。要允许返回部分分片的结果，可以在查询时设置 allow_partial_search_results 参数为 true。

¶具体操作：

在查询时添加 allow_partial_search_results 参数，例如：

GET /your_index/_search
{
  "allow_partial_search_results": true,
  "query": {
    "match_all": {}
  }
}

这样，即使某些分片不可用，Elasticsearch 仍会返回其他可用分片的结果。

¶全局设置（可选）：

如果需要所有查询默认支持部分结果，可以修改集群的全局设置：

PUT /_cluster/settings
{
  "persistent": {
    "search.allow_partial_results": true
  }
}

¶步骤 2: 检查分片分布

当一个节点挂掉时，部分主分片可能会丢失。为了最大程度减少丢失的数据，可以均衡分片分布。

¶查看分片分布：

使用 _cat/shards 查看分片在哪些节点上：

1	curl -X GET "http://<elasticsearch_host>:9200/_cat/shards?v"

输出示例：

index    shard prirep state       docs   store ip         node
my_index 0     p      STARTED     10000  50mb  192.168.1.1 node-1
my_index 1     p      STARTED     20000  100mb 192.168.1.2 node-2
my_index 2     p      STARTED     15000  75mb  192.168.1.3 node-3
...

确保主分片分布在不同节点上，以降低单点故障的影响。

¶步骤 3: 调整查询逻辑

在应用层处理查询结果时，确保对缺失的数据提供容错逻辑。

识别缺失的分片
- 使用 _cat/shards 或 _cluster/health 检查哪些分片未分配。
提示用户部分数据丢失
- 在搜索结果中提示用户当前的查询结果可能不完整。

¶局限性和注意事项

数据一致性
- 如果允许部分搜索结果，用户可能会误以为结果是完整的，因此需要在应用层提供明确的提示。
数据丢失
- 挂掉的节点上的数据在没有副本分片时无法恢复。如果节点无法重启，数据会永久丢失。
提高容错能力
- 为了避免这种情况，建议至少设置 number_of_replicas: 1，即使一个节点挂掉，副本分片也可以保证数据的完整性。

¶总结

要在 number_of_replicas=0 的情况下实现节点挂掉后仍然部分服务：

启用 allow_partial_search_results（全局或查询级别）。
确保分片尽量均匀分布在多个节点上。
在应用层处理查询结果的容错逻辑，并提示用户数据可能不完整。

设计一套高性能、高可扩展、高可用、高可伸缩的微服务架构，用于处理用户登录请求，需要从多个层面综合考虑，包括服务分层、基础设施、中间件选择、非功能需求等。

¶1. 总体架构设计

采用基于微服务的架构，将系统分解为若干独立的服务，登录请求由专门的认证与授权服务处理。其他基础服务（如数据库、缓存、消息队列等）和中间件提供支撑。

¶服务划分

用户服务
- 处理用户信息的管理（如注册、查询、更新）。
认证服务
- 专注于用户登录逻辑，包括身份验证（例如，用户名/密码验证，OAuth、OTP等）。
- 支持多种认证方式。
授权服务
- 生成和验证 JWT 或其他访问令牌，处理用户的访问权限。
审计和监控服务
- 记录登录行为和安全事件，用于审计和安全分析。
网关服务
- 作为 API 的入口，统一路由和转发请求。
配置管理服务
- 统一管理微服务配置，支持动态调整。
日志服务
- 收集和分析服务日志，便于排查问题。
负载均衡服务
- 提供高效的负载均衡，分发请求到多个实例。

¶2. 技术选型

¶基础设施

容器化：使用 Docker 容器化服务，提供一致的部署环境。
容器编排：使用 Kubernetes（K8s）管理容器化服务，支持高可用和动态伸缩。

¶中间件

API 网关：
- 工具：Kong, NGINX, Spring Cloud Gateway。
- 功能：路由、负载均衡、限流、认证校验、跨域支持。
负载均衡：
- 工具：K8s Ingress, HAProxy, Envoy。
- 功能：分发请求到不同节点。
缓存：
- 工具：Redis。
- 功能：存储用户会话数据、验证码状态等，减少数据库访问压力。
数据库：
- 工具：PostgreSQL（事务性强），或 MySQL。
- 数据分片：使用读写分离（主从架构）提高性能。
消息队列：
- 工具：RabbitMQ, Kafka。
- 功能：解耦服务，用于异步任务处理（如登录日志记录、安全报警）。
分布式配置管理：
- 工具：Consul, Apache Zookeeper, Spring Cloud Config。
- 功能：动态管理微服务配置。
身份认证和加密：
- 工具：Keycloak 或自定义身份认证服务。
- 加密：使用 HMAC-SHA256 或 bcrypt 保护用户密码。

¶安全

数据传输加密：通过 HTTPS 确保数据传输安全。
用户密码加密：使用强散列算法（如 bcrypt）存储用户密码。
多因子认证（MFA）：支持 OTP、短信验证码等。
防止暴力攻击：
- 基于 IP 的限流（如每分钟最多尝试登录 5 次）。
- CAPTCHA 验证。

¶3. 详细设计

¶登录请求处理流程

用户请求登录：
- 用户通过前端页面提交用户名和密码。
- 请求通过 API 网关转发到认证服务。
认证服务验证身份：
- 校验请求参数完整性。
- 查询用户信息（从数据库或缓存）。
- 验证密码是否正确（bcrypt 或 PBKDF2 散列）。
- 检查用户状态（如是否被锁定、是否需要验证码验证）。
生成令牌：
- 认证通过后，生成 JWT 令牌（包含用户 ID、角色、过期时间等）。
- 将登录状态写入 Redis 或数据库以便后续校验。
返回响应：
- 将令牌返回给前端，前端将其存储（如存储在 Cookie 或 Local Storage 中）。
日志与监控：
- 审计服务记录登录请求和结果。
- 异常请求通过消息队列发送至安全服务进行分析。

¶高可用和高性能实现

¶水平伸缩

服务容器化后，通过 Kubernetes 动态扩容服务实例。
通过 HPA（Horizontal Pod Autoscaler）根据负载自动调整实例数量。

¶高可用

数据库主从架构：主库写操作，从库读操作，提升读写性能。
使用 Redis 集群：确保缓存系统的高可用性。
消息队列镜像模式：RabbitMQ 的镜像队列模式保证消息的高可用性。

¶高性能

请求限流：
- 通过 API 网关限流（如每秒最大请求数）。
缓存查询：
- 用户登录状态和常用信息缓存到 Redis，减少数据库查询。
异步处理：
- 审计、日志和安全报警等非关键任务通过消息队列异步处理。

¶4. 非功能需求

性能
- 高并发支持：每秒支持上万次请求（通过水平扩展实现）。
- 延迟低于 100ms：优化数据库访问、缓存查询等关键路径。
可用性
- 服务可用性：99.99%（通过负载均衡、冗余和健康检查实现）。
- 无单点故障：使用多副本和高可用架构设计。
安全性
- 数据传输全加密（HTTPS）。
- 多层防护：防止 SQL 注入、跨站脚本攻击（XSS）、跨站请求伪造（CSRF）。
- 合规性：符合 GDPR 等隐私法规。
可伸缩性
- 支持按需扩展：高峰期动态扩容，低峰期自动缩容。
- 配置动态更新：通过配置管理服务无缝调整服务参数。

¶总结

这套微服务架构通过模块化的设计和云原生技术，能够满足高性能、高可扩展、高可用、高可伸缩的要求。关键在于服务划分清晰、基础中间件可靠，并辅以完善的安全和监控机制，确保系统在高并发场景下的稳定运行。

¶spark join 两个大文件

如何用spark找出两个csv文件种第2列相同的行，假设两个文件都很大，而且未排序

在 Spark 中处理两个未排序的大型 CSV 文件，并找出它们第 2 列相同的行，可以通过以下步骤实现：

¶步骤 1：加载 CSV 文件

Spark 提供了内置的 CSV 读取功能，可以使用 spark.read.csv 加载 CSV 文件。

from pyspark.sql import SparkSession

# 初始化 SparkSession
spark = SparkSession.builder \
    .appName("Find Matching Rows in CSV") \
    .getOrCreate()

# 加载 CSV 文件
file1 = spark.read.csv("file1.csv", header=True, inferSchema=True)
file2 = spark.read.csv("file2.csv", header=True, inferSchema=True)

header=True 表示 CSV 文件包含表头。
inferSchema=True 自动推断数据类型。

¶步骤 2：选择第 2 列

我们可以使用 DataFrame 的 select 方法选择文件中的第 2 列，并将其重命名为一个通用的列名。

1
2
3

# 选择第 2 列并重命名
file1_col2 = file1.select(file1.columns[1].alias("col2_file1"))
file2_col2 = file2.select(file2.columns[1].alias("col2_file2"))

¶步骤 3：寻找交集

使用 Spark 的 join 操作，以第 2 列为连接键进行内连接（inner join）。假设两个文件中第 2 列的值类型一致。

1 2	# 执行内连接，寻找交集 matching_rows = file1.join(file2, file1.columns[1] == file2.columns[1], "inner")

file1.columns[1] 和 file2.columns[1] 分别表示第 2 列。
"inner" 表示内连接，只保留匹配的行。

¶步骤 4：输出结果

你可以将结果输出到文件或者在控制台中显示。

# 显示结果
matching_rows.show()

# 保存到文件
matching_rows.write.csv("output.csv", header=True)

¶优化建议

分布式计算：
- Spark 会自动将任务分布在集群中运行。确保两个文件被分区存储（例如存储在 HDFS 或 S3 中），以提高并行计算性能。
广播变量（适合一个文件较小的情况）：
如果其中一个文件较小（可以放入内存），可以将较小的文件广播到每个节点，使用 broadcast 优化连接操作。
1
2
3
4
from pyspark.sql.functions import broadcast

# 广播较小的文件
matching_rows = file1.join(broadcast(file2), file1.columns[1] == file2.columns[1], "inner")
分区优化：
- 在读取 CSV 时设置合适的分区数。
- 使用 repartition 或 coalesce 调整分区数以优化性能。
1
file1 = file1.repartition(100) # 将文件重新分区
列裁剪：
- 只读取和处理需要的列，以减少内存消耗。
- 使用 select 筛选所需的列。
数据类型优化：
- 确保第 2 列的类型一致，例如都为 StringType 或 IntegerType。

¶完整代码示例

from pyspark.sql import SparkSession
from pyspark.sql.functions import broadcast

# 初始化 SparkSession
spark = SparkSession.builder \
    .appName("Find Matching Rows in CSV") \
    .getOrCreate()

# 加载 CSV 文件
file1 = spark.read.csv("file1.csv", header=True, inferSchema=True)
file2 = spark.read.csv("file2.csv", header=True, inferSchema=True)

# 执行内连接
matching_rows = file1.join(file2, file1.columns[1] == file2.columns[1], "inner")

# 显示结果
matching_rows.show()

# 保存结果到文件
matching_rows.write.csv("output.csv", header=True)

# 停止 SparkSession
spark.stop()

¶总结

Spark 提供了强大的并行计算能力，可以高效处理两个大型 CSV 文件。
使用 join 操作找出第 2 列相同的行，并注意对数据类型和分区的优化。
如果文件分布在分布式存储中（如 HDFS 或 S3），可以进一步利用数据局部性提升性能。

¶join之前先对两个文件排序是否会增加join的速度

在分布式计算中，是否对两个文件排序能加速 join 操作，取决于数据的特点和具体实现。以下是详细分析：

¶1. 排序是否有助于加速 `join`

排序本身并不总是必要，但在某些情况下，可以提高性能：

无排序情况下的 join：
- Spark 默认会为 join 自动进行 shuffle，将参与 join 的列进行分区（基于键的哈希值）。
- Shuffle 是一个昂贵的操作，涉及网络传输、磁盘 I/O 等。
预排序情况下的 join：
- 如果数据已按 join 键排序，Spark 可以在某些特定情况下避免部分 shuffle 操作（例如通过 Sort-Merge Join 优化）。
- 这种优化通常适用于 已分区且排序 的数据。

结论：
如果输入文件本身未分区，也未排序，对文件排序可能不会直接提升 join 性能，反而增加预处理的时间。如果文件分区已按 join 键对齐，排序后可以避免重复 shuffle，从而加速 join。

¶2. Spark `join` 的实现类型

Spark 支持多种 join 策略，是否排序影响它选择的策略：

Shuffle Hash Join（默认）：
- 没有预排序或分区信息时，Spark 会对两侧数据进行 shuffle，并构建哈希表。
- 无需排序，但 shuffle 成本高。
Broadcast Hash Join：
- 当一侧数据较小时，Spark 会将小表广播到每个节点，避免 shuffle。
- 无需排序，直接使用内存中的哈希表。
Sort-Merge Join（适用于已排序数据）：
- 如果两侧数据均已按 join 键排序并分区，则可以直接进行归并，避免 shuffle。
- 排序后的数据可以触发此优化，但排序的成本需综合考虑。
Cartesian Join（笛卡尔积，极少使用）：
- 对所有组合进行匹配，效率低下。
- 排序不会影响此类型。

¶3. 什么时候排序有意义？

排序可能有意义的情况：

数据量特别大，且可以多次复用：
如果文件被频繁用于按相同键的 join 操作，对数据进行排序和分区可以减少后续 join 的 shuffle 成本。
数据来源支持排序和分区：
如果数据来自分布式存储（如 HDFS），并支持按 join 键提前分区和排序，能避免 Spark 在运行时的 shuffle 操作。
大规模关联操作：
如果两个文件非常大，且系统内存有限，提前排序和分区可以使 join 更高效。

¶4. 排序与分区结合的优化

对数据进行排序和分区时，应综合以下操作：

分区优化：

使用 repartition() 按 join 键分区：

1 2	file1 = file1.repartition("key_column") file2 = file2.repartition("key_column")

排序优化：

使用 sortWithinPartitions() 对每个分区内数据排序：

1 2	file1 = file1.sortWithinPartitions("key_column") file2 = file2.sortWithinPartitions("key_column")

确保数据分区对齐：
- 如果两个文件的数据分区数量不一致，会引发额外的 shuffle。
- 使用 coalesce() 或 repartition() 对齐分区数。

¶5. 总结与建议

排序前的权衡：
排序会增加预处理的计算时间。如果 join 是一次性任务，不建议先排序，因为 Spark 会自动选择高效的 join 策略（如 Broadcast Join 或 Shuffle Join）。
排序后的收益：
如果文件被频繁使用，提前按 join 键分区和排序能显著减少后续 shuffle 成本，提高多次 join 的性能。
推荐实践：
- 小表广播优化：如果其中一个文件较小（如小于几百 MB），优先选择 Broadcast Join。
- 分区对齐：对于大表，确保分区按 join 键一致。
- 数据复用：在需要多次 join 时，排序分区后缓存（persist 或 checkpoint）可降低总成本。

¶示例代码（分区和排序结合）

from pyspark.sql import SparkSession

# 初始化 SparkSession
spark = SparkSession.builder.appName("Optimized Join").getOrCreate()

# 加载 CSV 文件
file1 = spark.read.csv("file1.csv", header=True, inferSchema=True)
file2 = spark.read.csv("file2.csv", header=True, inferSchema=True)

# 分区并排序
file1 = file1.repartition("key_column").sortWithinPartitions("key_column")
file2 = file2.repartition("key_column").sortWithinPartitions("key_column")

# 执行 Sort-Merge Join
result = file1.join(file2, file1["key_column"] == file2["key_column"], "inner")

# 显示结果
result.show()

# 停止 SparkSession
spark.stop()

¶解释这行命令 ./bin/spark-submit --master local[4] SimpleApp.py

以下是对这行命令的详细解释：

1	./bin/spark-submit --master local[4] SimpleApp.py

¶1. 命令部分解析

¶(1) `./bin/spark-submit`

这是 Spark 提供的脚本，用于提交 Spark 应用程序以运行。
它负责启动 Spark 集群环境（或本地环境），配置应用程序，加载依赖项，并运行指定的代码。

¶(2) `--master local[4]`

--master 指定 Spark 应用程序运行的部署模式，也就是 Spark 集群的主控节点地址。
- local[4] 表示在本地运行应用程序，并使用 4 个线程。
  - 本地模式是 Spark 的一种运行模式，适合开发、调试或小规模实验。
  - [4] 指定本地模式中使用的线程数量，通常对应于 CPU 核心数。
  - 例如，如果机器有 4 个 CPU 核心，local[4] 可以充分利用 CPU 资源。
- 其他常见的选项：
  - local: 单线程运行（适合简单调试）。
  - local[*]: 使用机器上所有的 CPU 核心。
  - yarn: 提交到 YARN 集群运行。
  - spark://<master-url>: 提交到指定的 Spark 集群。
  - k8s://<k8s-master-url>: 提交到 Kubernetes 集群。

¶(3) `SimpleApp.py`

这是用户编写的 Spark 应用程序脚本，使用 Python 编写。
文件名 SimpleApp.py 只是一个示例，表示包含 Spark 程序逻辑的 Python 文件。

¶2. 综合含义

这行命令的完整含义是：

使用 spark-submit 提交名为 SimpleApp.py 的 Spark 应用程序脚本。
应用程序将在本地运行，并使用 4 个线程。
适合在开发环境中运行 Spark 程序，充分利用本地机器的资源。

¶3. 应用场景

¶本地模式优点

无需搭建 Spark 集群。
快速调试和开发。
可以在单机上处理小规模数据。

¶局限性

仅能使用本地机器资源，不适合处理大规模数据。
无法测试分布式功能（如数据分区跨节点处理、集群级别的故障恢复等）。

¶4. 扩展

如何指定更多参数：

例如，设置应用名称和配置文件：

1	./bin/spark-submit --master local[4] --name "MyApp" --conf spark.executor.memory=2g SimpleApp.py

将应用提交到集群：

提交到 Spark 独立集群：

1	./bin/spark-submit --master spark://master-host:7077 SimpleApp.py

提交到 YARN 集群：

1	./bin/spark-submit --master yarn --deploy-mode cluster SimpleApp.py

提交到 Kubernetes：

1	./bin/spark-submit --master k8s://https://<k8s-master-url> --deploy-mode cluster SimpleApp.py

查看 java 进程

ps -ef | grep java | cut -c 1-100
lsof -p 3217885 2>/dev/null | awk '$4=="cwd"'

¶union和orderBy是否会占用太多内存，需要人工设置分区个数吗

在 PySpark 中，操作如 union 和 orderBy 确实会消耗较多内存和计算资源，尤其是在处理大数据集时。以下是对它们的性能和内存消耗的分析，以及是否需要设置分区数量的建议。

¶1. `union` 的内存使用分析

¶如何工作：

union 会将两个或多个 DataFrame 合并成一个。合并时不进行去重，只是简单地拼接数据。
默认情况下，union 操作不会重新分区，因此分区数量与输入的第一个 DataFrame 保持一致。

¶性能与内存消耗：

对于大数据集，union 操作会占用内存和磁盘 I/O。
如果多个 DataFrame 的分区数差异较大，可能导致任务负载不均衡。

¶优化建议：

设置合适的分区数量：
- 在合并前，确保所有 DataFrame 的分区数接近一致。
- 如果数据量很大，可以通过 repartition(n) 显式调整分区数量。例如：
  1
  2
  3
  df1 = df1.repartition(100) # 调整分区数为 100
  df2 = df2.repartition(100)
  merged_df = df1.union(df2)
减少重复分区调整：
- 如果后续操作如 orderBy 会自动重新分区，可以避免在 union 前重复调整分区。

¶2. `orderBy` 的内存使用分析

¶如何工作：

orderBy 是一个宽依赖操作，需要将数据根据排序键进行全局排序。
这通常需要对整个数据集进行 Shuffle，即将数据重新分区并排序。

¶性能与内存消耗：

orderBy 是一个高成本操作，因为它需要：
- 重新分区所有数据。
- 将数据按照排序键进行全局排序。
对大数据集，这种操作可能导致内存不足或性能瓶颈，尤其是在分区数不足的情况下。

¶优化建议：

调整分区数量：
- orderBy 会触发 Shuffle 操作，增加分区可以减少单个分区的数据量，降低内存压力。
- 例如：
  1
  sorted_df = merged_df.repartition(200).orderBy("domain")
使用 sortWithinPartitions：
- 如果不需要全局排序，可以使用 sortWithinPartitions 在每个分区内排序，避免全局 Shuffle。
  1
  sorted_df = merged_df.sortWithinPartitions("domain")
减少数据规模：
- 如果只是采样部分数据，可以使用 limit() 或 sample() 方法减少排序数据量。

¶3. 是否需要手动设置分区数

分区数的默认行为：
- 默认分区数为 spark.sql.shuffle.partitions，通常是 200。如果数据量很大或资源有限，可以手动调整。
如何判断是否需要调整：
1. 监控任务的分区情况：
  - 使用 Spark Web UI 查看分区大小和任务分布。如果某些分区数据量过大，可能需要增加分区。
2. 查看运行内存和执行时间：
  - 如果任务因为内存不足或 Shuffle 时间过长失败，可能需要增加分区。
调整分区数的推荐值：
- 分区数通常与数据大小、集群资源和任务类型有关。一般经验：
  - 每个分区处理 128MB 至 256MB 的数据。
  - 分区数量 = 数据大小 / 每分区数据量。

¶group by

df.groupBy(“domain”) 会利用上文件已经按domian排序这个事实吗

在 PySpark 中，groupBy 操作默认情况下并不会直接利用文件已经按 domain 排序的事实。这是因为：

groupBy 的机制：
- groupBy 是一个宽依赖操作，它需要所有相同键（如 domain）的数据集中到相同的分区中进行分组。这通常会触发 Shuffle 操作，将数据重新分布到各个分区。
已排序文件的优势未被使用：
- 即使文件已经按 domain 排序，PySpark 不会在默认情况下将排序信息传递给 groupBy，因此仍然会触发 Shuffle。
- PySpark 无法推断输入文件的排序信息，除非我们明确告知。

¶如何利用已排序文件的事实？

如果输入文件已经按 domain 排序，可以通过以下方法优化分组操作：

¶1. 使用 `sortWithinPartitions`

在数据读取后，通过 sortWithinPartitions 保持每个分区内的排序，然后按键分组。因为每个分区内的键是有序的，分组的开销会较小。

# 保持分区内的排序
sorted_df = df.sortWithinPartitions("domain")

# 按 domain 分组统计
domain_counts = sorted_df.groupBy("domain").agg(count("domain").alias("count"))

优点：

保留分区内排序信息，减少分组过程中的局部 Shuffle。

¶2. 使用 `RDD` 并通过文件排序优化

如果完全控制输入文件的排序和分区，可以使用 RDD 的 combineByKey，避免全局 Shuffle。以下是使用 RDD 的示例：

# 将 DataFrame 转换为 RDD
rdd = df.rdd.map(lambda row: (row["domain"], 1))

# 按 domain 聚合，利用已排序的特点
domain_counts_rdd = (
    rdd.combineByKey(
        lambda value: value,           # 创建初始值
        lambda acc, value: acc + value, # 聚合值
        lambda acc1, acc2: acc1 + acc2  # 合并分区
    )
)

# 转回 DataFrame
domain_counts = domain_counts_rdd.toDF(["domain", "count"])

优点：

如果输入文件按 domain 排序且分区正确，可以完全避免 Shuffle。

¶3. 确保文件按分区排序

如果可以控制数据的写入方式，建议在文件生成时：

按 domain 分区并排序。
使用 repartitionByRange 写入文件，例如：

1
2
3

# 写入排序后的文件，按 domain 分区
sorted_df = df.repartitionByRange(10, "domain").sortWithinPartitions("domain")
sorted_df.write.csv("sorted_output.csv", header=True)

读取时直接利用分区结构，可以显著减少 Shuffle。

¶优化建议总结

小数据集：
默认的 groupBy 是简洁的选择，不需要额外优化。
大数据集（已按键排序）：
- 使用 sortWithinPartitions 或 RDD 操作减少 Shuffle。
- 确保数据按键分区并保持排序。
大数据集（未按键排序）：
- 使用 repartitionByRange 提前对数据分区。
- 使用合适的分区数（repartition 或 coalesce）。

¶详细解释combineByKey的第二种方法

combineByKey 是 RDD 的一种高效聚合方法，适用于分布式数据处理场景，特别是当你需要按照键对数据进行聚合时。

以下是对 combineByKey 的第二种方法的详细解释，以及它如何工作。

¶`combineByKey` 的机制

combineByKey 需要三个函数来完成分区内和分区间的聚合操作：

创建初始值（createCombiner）：
- 当某个键第一次出现时，如何初始化其值。
- 比如，对于 (key, value)，你可以将 value 包装为一个更复杂的数据结构（如计数器、列表等）。
分区内合并（mergeValue）：
- 当相同分区中的某个键再次出现时，如何将新值与当前累积值合并。
分区间合并（mergeCombiners）：
- 当不同分区中累积的结果需要合并时，如何将它们合并。

¶应用场景

假设我们有以下数据集，统计每个 domain 的出现次数：

1	[("gmail.com", 1), ("yahoo.com", 1), ("gmail.com", 1), ("outlook.com", 1)]

¶代码实现

from pyspark import SparkContext

sc = SparkContext("local", "combineByKey Example")

# 示例数据
rdd = sc.parallelize([
    ("gmail.com", 1), 
    ("yahoo.com", 1), 
    ("gmail.com", 1), 
    ("outlook.com", 1),
    ("gmail.com", 1)
])

# 使用 combineByKey 聚合
result = rdd.combineByKey(
    lambda value: value,                    # createCombiner
    lambda acc, value: acc + value,         # mergeValue
    lambda acc1, acc2: acc1 + acc2          # mergeCombiners
)

# 将结果收集并打印
print(result.collect())

¶三个函数的详细解释

¶1. `createCombiner`

描述：当某个键第一次被遇到时，createCombiner 会生成该键的初始值。
示例：将值初始化为自身，比如将 ("gmail.com", 1) 的 1 保持为初始值。

代码中对应：

1	lambda value: value

如果键是 "gmail.com" 且值是 1，那么 combineByKey 内部会为 "gmail.com" 创建一个累积器，初始值为 1。

¶2. `mergeValue`

描述：定义如何将相同分区内的新值与当前累积值合并。
示例：累加新值到已有值，比如 1 + 1。

代码中对应：

1	lambda acc, value: acc + value

如果当前分区的键 "gmail.com" 已有累积值 2，并遇到新值 1，那么累积器会更新为 3。

¶3. `mergeCombiners`

描述：定义如何将不同分区中累积的结果合并。
示例：累加来自不同分区的累积值，比如 3 + 2。

代码中对应：

1	lambda acc1, acc2: acc1 + acc2

如果两个分区的键 "gmail.com" 的累积值分别是 3 和 2，那么合并后结果是 5。

¶如何工作（流程解释）

初始阶段：
- 对于每个分区内的键值对，第一次遇到某个键时，调用 createCombiner 初始化该键的累积值。
- 例如：
  1
  ("gmail.com", 1) -> 初始值为 1
分区内聚合：
- 每个分区独立处理自己的数据，对于相同的键，使用 mergeValue 累加。
- 示例（分区1的数据）：
  1
  ("gmail.com", 1), ("gmail.com", 1) -> 初始值 1 -> 累加值为 2
分区间聚合：
- 各分区处理完后，Spark 使用 mergeCombiners 将不同分区的结果合并。
- 示例：
  - 分区1：("gmail.com", 2)
  - 分区2：("gmail.com", 1)
  - 合并结果：("gmail.com", 3)

¶输出示例

对于以下输入数据：

1	[("gmail.com", 1), ("yahoo.com", 1), ("gmail.com", 1), ("outlook.com", 1), ("gmail.com", 1)]

代码会输出：

1	[('yahoo.com', 1), ('gmail.com', 3), ('outlook.com', 1)]

¶性能优势

combineByKey 的核心优势在于：

分区内高效聚合：
- 通过 mergeValue 在分区内提前聚合，减少数据量。
分区间高效合并：
- 在分区间只需传输聚合结果，而不是所有数据。

这使得 combineByKey 非常适合键值对数据的大规模聚合。

¶改进和扩展

优化内存使用：
如果键值对的结果较大，可以在 createCombiner 和 mergeValue 中使用高效数据结构（如计数器或集合）。

统计复杂信息：
可以使用 combineByKey 计算平均值、最大值等。例如：

rdd.combineByKey(
    lambda value: (value, 1),                # 初始值 (总和, 个数)
    lambda acc, value: (acc[0] + value, acc[1] + 1),  # 分区内累加
    lambda acc1, acc2: (acc1[0] + acc2[0], acc1[1] + acc2[1])  # 分区间合并
).mapValues(lambda x: x[0] / x[1])  # 计算平均值

这种方式可以灵活地计算更复杂的统计信息。

¶总结

combineByKey 是一种分布式键值对聚合操作，通过三步（创建初始值、分区内合并、分区间合并）高效处理大规模数据。
当数据已经按键排序时，可以进一步优化性能，减少 Shuffle 操作。
它非常适合复杂聚合任务，如计算计数、平均值等。

一个csv有两列，一个性别列，一个年龄列，用spark写一段代码按性别分组，然后统计每个分组中每个年龄段的人数，年龄段每10岁划分为一个段。

计算年龄段的代码使用udf，原始数据已经按照性别排序，有可能性别有数据倾斜，数据大约10亿，服务器内存较少，给出完整的代码。

考虑到你的数据量非常大（约10亿条数据），而且服务器内存较少，以下是使用 Spark 进行高效处理的完整代码，结合了以下优化策略：

使用 UDF 来计算年龄段。
避免全局 Shuffle，尽量减少 Spark 操作的开销。
根据性别分区（避免性别数据倾斜），减少不必要的 shuffle 操作。
使用合适的内存管理和分区策略，保证 Spark 程序的性能。

¶优化思路

UDF计算：通过定义自定义 UDF 来计算每个数据的年龄段。
按性别分区：使用 repartitionByRange 或者 partitionBy 按性别分区，可以减少后续的 Shuffle 操作，防止性别列的数据倾斜。
缓存中间数据：如果需要多次计算，可以缓存中间结果，避免重复计算。
调整分区数：如果数据量非常大，可以调整 spark.sql.shuffle.partitions 配置来减少 shuffle 的开销。

¶完整代码

from pyspark.sql import SparkSession
from pyspark.sql.functions import udf, col, concat, lit, floor
from pyspark.sql.types import StringType
from pyspark.sql import functions as F

# 初始化 SparkSession
spark = SparkSession.builder \
    .appName("AgeGroupByGenderWithUDF") \
    .config("spark.sql.shuffle.partitions", "200") \  # 根据实际情况调整
    .config("spark.executor.memory", "4g") \         # 根据内存情况调整
    .config("spark.executor.cores", "4") \           # 根据可用的 CPU 核心数调整
    .getOrCreate()

# 示例数据路径（假设是 CSV 文件，实际情况中应该读取你的大数据源）
# 数据示例：每行包括性别和年龄
input_file = "path_to_your_data.csv"

# 读取数据，假设 CSV 有两列: gender 和 age
df = spark.read.option("header", "true").csv(input_file).select("gender", "age")

# 将年龄列转为整型
df = df.withColumn("age", df["age"].cast("int"))

# 定义 UDF 来计算年龄段
def age_group_logic(age):
    if age is None:
        return None
    # 计算年龄段，例如: 20-29, 30-39
    start_age = (age // 10) * 10
    end_age = start_age + 9
    return f"{start_age}-{end_age}"

# 注册 UDF
age_group_udf = udf(age_group_logic, StringType())

# 添加年龄段列
df_with_age_group = df.withColumn("age_group", age_group_udf(col("age")))

# 按性别分区（避免数据倾斜），通过 repartitionByRange 按性别排序
df_partitioned = df_with_age_group.repartitionByRange(200, "gender")

# 缓存中间结果，避免重复计算
df_partitioned.cache()

# 按性别和年龄段分组并统计人数
result = df_partitioned.groupBy("gender", "age_group").agg(F.count("*").alias("count"))

# 排序以方便查看
result = result.orderBy("gender", "age_group")

# 显示结果
result.show(truncate=False)

# 保存结果（可以根据需求选择保存格式）
# result.write.csv("output_path", header=True)

¶代码解释：

SparkSession：通过 SparkSession.builder 设置了适当的配置，主要配置了：
- spark.sql.shuffle.partitions: 调整 shuffle 操作的分区数。此参数需要根据实际数据量和集群大小进行调整。默认值通常为200，可以适当调整。
- spark.executor.memory: 根据服务器内存大小调整。如果内存不足，可以适当减少。
- spark.executor.cores: 设置每个 executor 的 CPU 核心数，防止过多的并行任务导致资源不足。
读取数据：从 CSV 文件中读取数据，并选择性地保留 gender 和 age 列。如果你的数据存储格式不同，可以调整读取方法。
年龄段计算：定义了一个 age_group_logic 函数，并通过 udf 注册它。UDF 将每个年龄值转换为对应的年龄段，例如 20-29、30-39。
数据分区：通过 repartitionByRange(200, "gender") 按 gender 列进行数据分区，尽量减少后续分组操作时的数据倾斜。
缓存数据：df_partitioned.cache() 缓存了中间结果，如果后续需要多次使用 df_partitioned，避免重复计算。
分组和统计：使用 groupBy("gender", "age_group").agg(F.count("*").alias("count")) 按性别和年龄段进行分组统计人数。
排序输出：通过 orderBy("gender", "age_group") 排序，方便查看输出结果。

¶性能考虑：

避免全局 Shuffle：我们尽量减少了不必要的 groupBy 操作，通过 repartitionByRange 来避免数据倾斜和不必要的 Shuffle。
分区数量调整：spark.sql.shuffle.partitions 的调整能够有效控制 Spark 执行期间的 Shuffle 操作数量，避免大规模数据处理时过多的 Shuffle 操作带来性能瓶颈。
内存与计算资源配置：根据实际内存和 CPU 核心数来合理配置 spark.executor.memory 和 spark.executor.cores，避免过多的并行计算导致资源过度消耗。
缓存中间结果：cache() 用来缓存已经处理过的数据，减少后续计算时的开销。

¶结果展示：

运行这段代码时，result.show(truncate=False) 会展示按性别和年龄段分组统计的结果。例如：

+------+---------+-----+
|gender|age_group|count|
+------+---------+-----+
|Female|10-19    |200000|
|Female|20-29    |350000|
|Female|30-39    |500000|
|Male  |10-19    |150000|
|Male  |20-29    |400000|
|Male  |30-39    |700000|
+------+---------+-----+

根据实际需求，可以选择将结果保存到文件中，使用 result.write.csv("output_path", header=True) 将结果输出到 CSV 文件，或者选择其他格式（如 Parquet）进行存储。

¶总结：

此代码通过 UDF 计算年龄段，并采用按性别分区、减少 Shuffle、缓存等手段来优化性能。根据数据量和集群资源的不同，可以进一步调整分区数、内存和 CPU 核心数等配置，确保 Spark 程序高效运行。

¶为什么df_with_age_group.repartitionByRange(200, “gender”)可以避免数据倾斜

在 Spark 中，数据倾斜（Data Skew）通常发生在 groupBy、join 或 repartition 等操作中，特别是当某些分区的数据量明显大于其他分区时，可能会导致任务执行不均衡，从而拖慢整体处理速度。

repartitionByRange 通过范围划分的方式对数据进行分区，而不是随机划分。这样，分区的方式更加均匀，可以有效避免数据倾斜。让我们详细解释一下：

¶1. `repartitionByRange` 的工作原理

repartitionByRange 根据给定的列（比如 gender 列）对数据进行排序和重新分区。它通过对数据进行排序（按指定列或多个列排序）来确保相同值的记录被分配到同一个分区中。

你提供的参数是：200（目标分区数）和 "gender"（需要按这个列来重新分区）。
这个操作会尝试通过排序的方式来将数据分配到不同的分区中，保证每个分区内的数据量尽可能均匀。

例如，如果 gender 列只有两个值 "Male" 和 "Female"，repartitionByRange(200, "gender") 会尝试将 "Male" 和 "Female" 的数据均匀地分配到 200 个分区中。这有助于避免某个分区的“热点”，从而避免倾斜。

¶2. 为什么避免数据倾斜？

数据倾斜通常发生在某些值（例如某些 gender 或某些键）上出现大量的数据，导致分配到某些分区的任务非常繁重，而其他分区的任务较少。这样会导致计算资源的不均衡，进而影响作业性能。

repartitionByRange 对数据进行范围划分时，会确保相同范围的值集中在相同的分区中，从而减小了某个分区被单一大值（比如某个很大的 "Male" 或 "Female" 数量）占据的可能性。假设数据在 gender 上不平衡（例如 "Male" 比 "Female" 多得多），repartitionByRange 会确保在每个分区内 Male 和 Female 数据量分布较为均衡。

¶3. 避免 `groupBy` 或 `join` 操作中的倾斜

groupBy：如果我们直接使用 groupBy("gender")，那么当某个性别的数量极大时，会导致某个分区上的数据过于集中，形成“热点”，从而影响性能。
join：在进行 join 操作时，若两边某些键的数量极其不均衡，也可能造成某些分区的数据量很大，导致数据倾斜。通过 repartitionByRange 可以使得数据的分布更加均匀。

¶4. 示例：`repartitionByRange` 可以帮助避免倾斜

假设你有如下的 gender 列数据，且数据分布非常不均衡：

80% 的数据是 Male
20% 的数据是 Female

如果你直接进行 groupBy("gender")，那么会把大部分数据集中到一个分区中，导致 Spark 在该分区上工作量过大，其他分区的任务则相对较小，这样会产生数据倾斜，导致性能下降。

然而，如果你使用 repartitionByRange(200, "gender")：

这个操作会根据 gender 列的值将数据范围划分并均匀分配到 200 个分区中。
即使 Male 和 Female 数据量不均，repartitionByRange 会尽量平衡两个值的分配，并使每个分区的数据量相对接近，从而避免某些分区的数据过多，而其他分区的数据较少。

¶5. 与 `repartition` 的区别

repartition 是 基于随机化的重新分区操作，它可能导致某些值过于集中到某些分区，特别是在数据分布不均的情况下，这可能会导致数据倾斜。
repartitionByRange 是 基于排序的重新分区，它通过对数据进行排序并按值范围划分分区，从而保证数据在分区之间更加均匀分布。

¶总结

repartitionByRange(200, "gender") 可以帮助避免数据倾斜，主要是通过按范围对数据进行划分，使得相同值的记录尽量分配到相同的分区，从而减少数据量不均匀的情况，进而提高任务的执行效率和资源利用率。

¶原始数据中gender是否排序对repartitionByRange(200, “gender”)的性能有影响吗？

在 Spark 中，repartitionByRange 通过对数据进行排序来决定如何重新分区。当使用 repartitionByRange(200, "gender") 时，Spark 会尝试将 gender 列的不同值按范围进行排序并均匀分配到 200 个分区中。

¶1. `repartitionByRange` 依赖排序，但原始数据是否已排序不会影响最终结果

排序的本质：repartitionByRange 会对数据进行排序，然后基于排序的结果重新分区，因此即使原始数据中 gender 列没有排序，Spark 也会对数据进行排序。原始数据是否已经排序对最终的性能不会产生直接影响，因为 Spark 会在进行数据重新分区时对数据进行完整的排序。
排序的影响：如果原始数据已经按 gender 列排序，Spark 可能会在内部做一些优化，例如避免进行全量的排序步骤，从而在某些情况下节省了部分计算资源。但即使数据没有排序，Spark 也能通过 repartitionByRange 完成排序和重新分区操作。

¶2. 为什么原始数据排序可能对性能有间接影响

尽管 repartitionByRange 会强制执行排序操作，但在某些情况下，原始数据的排序状态可能影响执行效率。具体来说，以下是几个可能的影响：

数据预排序可能减少不必要的 Shuffle：如果原始数据已经按照 gender 排序，Spark 在执行 repartitionByRange 时可能会有更少的需要移动的数据，因为已经按照一定顺序进行分配。这可能减少内部 shuffle 的开销，因为 Spark 在执行 repartitionByRange 时会根据 gender 的值划分区间，若数据已经按 gender 排序，则可以减少重新排序的计算量。
更低的计算开销：当数据已经按某列（如 gender）排序时，Spark 在进行 repartitionByRange 操作时，可能会减少一部分工作量（例如，减少对整个数据集的排序操作）。这对于较小的分区数和数据量可能是有益的，但对于大规模数据，效果可能不那么明显。

¶3. 影响的主要因素：数据的规模与分布

数据量：对于较小的 DataFrame，数据已经排序对 repartitionByRange 的性能提升可能不明显。对于较大的数据集，原始数据是否排序可能会有较大的影响，因为排序操作会带来额外的计算开销。
数据分布：如果 gender 列的分布非常不均匀（例如，一些 gender 值占比非常大，其他值非常小），即使数据已经排序，repartitionByRange 可能仍然需要进行大量的 shuffle 操作来保证分区的均匀性。

¶4. 总结

性能差异：原始数据是否已排序对 repartitionByRange 的性能有一定影响，但影响主要取决于数据的规模和分布。对于非常大的数据集，数据是否排序可能会对计算和 Shuffle 的效率产生影响。
排序操作：即使原始数据没有排序，repartitionByRange 也会对数据进行排序，因此排序本身的开销始终存在。原始数据的排序状态可能只是优化了排序过程的效率，而不会改变最终的结果。

¶最佳实践：

对于大数据量的情况，推荐始终使用 repartitionByRange 来避免数据倾斜，哪怕原始数据没有排序。
对于小规模数据，如果数据已经按关键列排序，可以考虑直接使用 repartitionByRange，可能会节省一些计算开销。

¶在线收缩表

gh-ost 是一个非常好的选择，特别是对于需要在生产环境中对大表进行修改、重建或优化时。它是一个由 GitHub 开发的 在线模式表结构更改工具，能够在不锁定表的情况下执行表重建、数据迁移等操作，因此可以用于你的场景——优化表以回收空间，且不影响在线业务。

¶使用 `gh-ost` 执行在线优化

gh-ost 通常用于表结构的变更，但也可以用来优化和重建大表，并能够确保操作过程中的最小锁定和最大在线可用性。

¶安装 gh-ost

下载预编译二进制文件:
你可以从 GitHub releases 页面下载适合你操作系统的版本：GitHub Releases

¶使用 `gh-ost` 来在线优化表

创建临时表并执行数据迁移
gh-ost 会创建一个临时表，并且逐步将原表的数据迁移到新表中，整个过程不会锁定原表。

执行 gh-ost 命令：
假设你要优化的表是 xxx，并且你希望通过 gh-ost 来重建表，并且回收空间。你可以通过以下步骤来实现：

gh-ost \
  --user="root" \
  --password="yourpassword" \
  --host="localhost" \
  --database="your_database" \
  --table="xxx" \
  --alter="ENGINE=InnoDB" \
  --approve-renames \
  --chunk-size=1000 \
  --max-load=Threads_running=25 \
  --critical-load=Threads_running=50 \
  --initially-drop-ghost-table \
  --execute

解释参数：

--user、--password、--host 和 --database：用于连接 MySQL 数据库。
--table：指定要优化的表名。
--alter="ENGINE=InnoDB"：用 ALTER 操作改变表的引擎或做其它修改（你可以不做任何结构改变，只是进行表重建来回收空间）。
--approve-renames：确认使用临时表重命名操作。
--chunk-size=1000：迁移数据时，按块大小处理数据，避免一次性迁移过多数据造成性能压力。
--max-load：指定迁移过程中 MySQL 最大允许的负载（比如最大线程数）。
--critical-load：当系统负载超过此限制时，gh-ost 会暂停迁移，以避免影响性能。
--initially-drop-ghost-table：开始时就丢弃临时表，以减少空间占用。
--execute：表示实际执行操作。如果你先想模拟执行过程，可以先去掉 --execute，这将执行干运行并显示预期的操作步骤。

¶gh-ost 的工作方式

gh-ost 在执行过程中会：
- 创建一个临时的 “ghost” 表。
- 使用 MySQL 的 INSERT INTO ... SELECT 或者其他方法将原表的数据逐步迁移到 “ghost” 表。
- 逐渐迁移数据时，只会在数据块大小（--chunk-size）的粒度上短暂加锁，因此对系统影响较小。
- 当迁移完成后，会进行原表和临时表的切换（将新表重命名为原表的名字）。
- 这样，你就能在不中断应用的情况下重建和优化大表。

¶适用场景

不影响业务：gh-ost 能够避免锁定整个表，确保表的数据可以在业务运行时继续读取和写入。
回收空间：通过改变表的存储引擎、重建表等方式，可以回收空间、减少碎片。
高性能：gh-ost 通过分块方式逐步进行数据迁移，并且支持动态调整迁移速度，避免对数据库性能造成过大影响。

¶计算隐含波动率

如果已经获取到期权的行权价，到期时间，价格，底层地产的价格，无风险利率，能否计算出它的隐含波动率，期权价格应该用最新的成交价，还是对手盘的报价？

是的，您可以使用这些信息计算期权的隐含波动率。隐含波动率（IV）是通过反向求解Black-Scholes公式得到的，具体步骤如下：

¶1. 选择期权价格

期权价格可以使用以下两种数据来源：

最新成交价：反映了市场上最近的交易价格，可能包含最新的市场信息。
对手盘报价：包括买价（Bid）和卖价（Ask），代表市场上可交易的价格范围。

建议：如果要精确反映市场情况，可以用买卖盘中点价（即((Bid + Ask) / 2)）。如果市场活跃且最新成交价可信，也可以直接使用成交价。

¶2. 计算隐含波动率的步骤

隐含波动率需要通过迭代法反向求解，具体流程如下：

已知参数代入Black-Scholes公式：
- 行权价 ((K))。
- 到期时间 ((T))。
- 当前底层资产价格 ((S_0))。
- 无风险利率 ((r))。
- 市场上期权价格 ((C_{market}) 或 (P_{market}))。
设定初始隐含波动率值：
- 通常从一个较低的值（例如 0.1 或 10%）开始。
用Black-Scholes公式计算理论期权价格：
- 使用假定的隐含波动率，计算理论期权价格 ((C_{BS}) 或 (P_{BS}))。
比较理论价格与市场价格：
- 如果理论价格与市场价格的差距在容许范围内（例如(\epsilon = 10^{-6})），则认为找到隐含波动率。
- 如果差距较大，调整隐含波动率（例如使用二分法或牛顿-拉夫森法）并重复计算。

¶3. Black-Scholes公式回顾

看涨期权价格：
[
C = S_0 \cdot N(d_1) - K \cdot e^{-rT} \cdot N(d_2)
]
看跌期权价格：
[
P = K \cdot e^{-rT} \cdot N(-d_2) - S_0 \cdot N(-d_1)
]
(d_1) 和 (d_2) 的定义：
[
d_1 = \frac{\ln(S_0 / K) + (r + \sigma^2 / 2)T}{\sigma \sqrt{T}}, \quad d_2 = d_1 - \sigma \sqrt{T}
]
其中，(\sigma) 是隐含波动率。

¶4. 常用求解方法

二分法：
在给定区间内（例如 ([0, 1])），逐步缩小隐含波动率范围。
牛顿-拉夫森法：
使用Black-Scholes公式对(\sigma)的导数进行迭代更新，收敛更快。

总结：您可以根据市场需求选择成交价或中点价作为输入，利用迭代法通过Black-Scholes公式反算隐含波动率。这是一种标准的金融工程方法，用于评估市场对未来波动的预期。

二分法真是无处不在，但我比较纳闷的是，为什么这里可以用二分法呢，曲线是单调平滑的才可以用二分吧，否则二分应该有可能跳过最优解。

您说得非常对，二分法在数值求解中之所以有效，关键在于问题满足特定的单调性或连续性条件。在隐含波动率的求解中，二分法可以使用的原因如下：

¶1. Black-Scholes公式中的单调性

在给定其他参数（如标的价格 (S)、行权价 (K)、到期时间 (T)、无风险利率 (r)）不变的情况下，期权价格对隐含波动率 (\sigma) 是单调递增的：

随着波动率的增加，期权价格总是增加。这是因为更高的波动率意味着标的资产价格的不确定性更高，从而增加了期权的价值。

这种单调性保证了期权价格曲线（相对于波动率）没有局部极值，只有一个唯一的解。这为二分法提供了理论基础。

¶2. 平滑性

Black-Scholes公式是连续且可微的。期权价格关于隐含波动率的导数（称为 Vega）始终为正，且在实用范围内（低波动率到高波动率）变化平滑。

¶Vega 的公式

Vega 是期权价格对隐含波动率的敏感性，公式为：
[
\text{Vega} = S_0 \cdot \sqrt{T} \cdot N’(d_1)
]
其中 (N’(d_1)) 是标准正态分布的概率密度函数。

Vega 总是非负的，并且其值在波动率较低时较大，波动率较高时逐渐减小。这种平滑性意味着隐含波动率与期权价格之间的关系是良好行为的（单调且无振荡），因此适合用二分法。

¶3. 为何不会跳过最优解

二分法的基本思想是每次选择解区间的中点，利用单调性将搜索区间缩小一半。在隐含波动率的求解中，由于以下性质，解区间总是收敛到唯一解：

单调性：期权价格随隐含波动率单调增加。
连续性：期权价格对隐含波动率的映射是连续的。
边界条件：波动率为0时，期权价格接近其内在价值；波动率趋于无穷时，期权价格趋于无穷。

因此，二分法从一个足够大的初始区间（如 ([0, 5])）开始，可以保证找到市场价格的隐含波动率。

¶4. 如果曲线不是单调的会怎样？

如果曲线不是单调的（例如存在局部极值点），二分法可能会失效：

二分法可能跳过最优解。
可能无法收敛到正确的结果。

但在隐含波动率的求解中，这种情况不会发生，因为单调性和连续性已经从理论上保证了解的唯一性。

¶总结

二分法适用于隐含波动率的求解，是因为：

Black-Scholes公式中期权价格对隐含波动率是单调递增的。
这种关系是平滑且连续的。
二分法的迭代过程可以保证找到唯一解。

这也是为什么二分法在数值求解中广泛应用的核心原因之一！

有没有python的库直接计算出隐含波动率，给出示例代码

Python中有多个库可以直接计算隐含波动率，常用的包括 py_vollib 和 mibian。以下是使用这些库的示例代码。

¶方法 1: 使用 `py_vollib`

py_vollib 是一个功能强大的金融计算库，支持隐含波动率的计算。

¶安装

1	pip install py_vollib

¶示例代码

import py_vollib.black_scholes.implied_volatility as iv

# 参数
option_price = 10.0  # 市场期权价格
S = 100.0           # 当前标的资产价格
K = 105.0           # 行权价
T = 0.5             # 到期时间（以年计）
r = 0.05            # 无风险利率
flag = 'c'          # 看涨期权：'c'，看跌期权：'p'

# 计算隐含波动率
implied_vol = iv.implied_volatility(option_price, S, K, T, r, flag)
print(f"隐含波动率: {implied_vol:.2%}")

¶方法 2: 使用 `mibian`

mibian 是另一个简单的工具库，适合快速计算隐含波动率。

¶安装

1	pip install mibian

¶示例代码

import mibian

# 参数
S = 100          # 当前标的资产价格
K = 105          # 行权价
r = 5            # 无风险利率（百分比形式）
T = 30           # 到期时间（以天计）
option_price = 10  # 市场期权价格

# 使用 BSM 模型计算隐含波动率
bsm = mibian.BS([S, K, r, T], callPrice=option_price)
print(f"隐含波动率: {bsm.impliedVolatility:.2f}%")

¶方法 3: 自行实现迭代法（例如二分法）

如果需要完全控制计算过程，可以实现自定义的隐含波动率计算。

¶示例代码

from scipy.stats import norm
import numpy as np

# Black-Scholes定价公式
def black_scholes(S, K, T, r, sigma, option_type='call'):
    d1 = (np.log(S / K) + (r + 0.5 * sigma ** 2) * T) / (sigma * np.sqrt(T))
    d2 = d1 - sigma * np.sqrt(T)
    if option_type == 'call':
        return S * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
    elif option_type == 'put':
        return K * np.exp(-r * T) * norm.cdf(-d2) - S * norm.cdf(-d1)

# 隐含波动率的计算
def implied_volatility(option_price, S, K, T, r, option_type='call', tol=1e-6, max_iter=100):
    low, high = 1e-6, 5.0  # 波动率范围
    for _ in range(max_iter):
        mid = (low + high) / 2
        price = black_scholes(S, K, T, r, mid, option_type)
        if abs(price - option_price) < tol:
            return mid
        elif price < option_price:
            low = mid
        else:
            high = mid
    return mid

# 参数
S = 100  # 标的资产价格
K = 105  # 行权价
T = 0.5  # 到期时间
r = 0.05 # 无风险利率
option_price = 10  # 市场期权价格

# 计算隐含波动率
iv = implied_volatility(option_price, S, K, T, r, option_type='call')
print(f"隐含波动率: {iv:.2%}")

¶比较

库	特点	推荐场景
`py_vollib`	专业金融工具库，支持多个选项和精度高	复杂期权定价与分析
`mibian`	简单易用，适合基础场景	快速验证隐含波动率
自行实现	完全可控，可自定义精度和算法	学术研究或高级控制需求

2024-11-26

english-textbook

以下是一本全新英语自学教材的设计方案，参考《新概念英语》第二册的结构与目标。教材名为**《Practical English Adventures》**（《实用英语历险记》），内容分为四大部分，每部分20个小故事，共80个小故事。每个部分的标题和目标逐步递进，以趣味故事为主线，配合实用词汇、语法和文化背景。

¶第一部分：Daily Encounters（日常邂逅）

目标：学习日常生活中的基本对话和实用词汇；掌握简单句子结构及基础时态（现在时、过去时）。

The Morning Rush（清晨的匆忙）
A Friendly Neighbor（友好的邻居）
Lost Keys（丢失的钥匙）
The Perfect Breakfast（完美的早餐）
A Rainy Day（雨天记）
Shopping for Groceries（购买杂货）
A Call from Mom（来自妈妈的电话）
A Busy Café（繁忙的咖啡馆）
The Broken Bicycle（坏了的自行车）
Watching the Stars（看星星）
A Trip to the Park（去公园的旅程）
The Stray Cat（流浪猫）
Fixing a Flat Tire（修理轮胎）
A New Recipe（新的菜谱）
A Forgotten Appointment（被遗忘的约会）
At the Post Office（在邮局）
The Birthday Surprise（生日惊喜）
Waiting for the Bus（等公交）
A Late Night Snack（深夜的零食）
The Alarm That Didn’t Ring（没有响的闹钟）

¶第二部分：Unexpected Adventures（意外冒险）

目标：拓展日常场景外的表达；掌握过去进行时、将来时及基础从句；提高故事叙述能力。

The Missing Wallet（遗失的钱包）
A Trip to the Zoo（去动物园）
The Haunted House（鬼屋探秘）
Lost in the City（迷失在城市中）
The Helpful Stranger（热心的陌生人）
Trouble on the Train（火车上的麻烦）
A Mysterious Package（神秘的包裹）
Stuck in an Elevator（被困电梯）
The Uninvited Guest（不速之客）
The Lucky Coin（幸运硬币）
A Day at the Beach（海滩的一天）
The Stolen Umbrella（被偷的雨伞）
Running Out of Fuel（油耗尽了）
The Forgotten Password（遗忘的密码）
A Fire Drill（火灾演习）
Meeting a Celebrity（偶遇明星）
A Stormy Night（暴风雨之夜）
A Misunderstood Message（误解的信息）
The Elevator Ride（电梯之旅）
The Unexpected Gift（意外的礼物）

¶第三部分：Cultural Crossroads（文化交汇）

目标：深入学习英语国家文化背景，增强描述能力；掌握定语从句、状语从句和条件句。

A Festival to Remember（难忘的节日）
Learning to Dance（学跳舞）
The History Lesson（历史课）
A Trip to the Museum（博物馆之旅）
Tea Time Traditions（茶时间的传统）
The Old Castle（古老的城堡）
Cooking Together（一起做饭）
A New Hobby（新的爱好）
The Book Club（读书俱乐部）
Learning a Language（学习一门语言）
A Summer Fair（夏季集市）
The Christmas Market（圣诞集市）
An English Garden（英国花园）
A Soccer Match（足球比赛）
A Winter Holiday（冬季假期）
Exploring the Countryside（探索乡村）
A Tale from the Past（过去的故事）
A Family Reunion（家庭聚会）
Learning to Drive（学开车）
A Day in the Library（图书馆的一天）

¶第四部分：Life Lessons（人生启示）

目标：培养高级表达能力；学习虚拟语气、习语及复杂句式；提升整体语言流利度。

The Wise Old Man（智慧的老人）
A Lesson in Patience（耐心的课程）
The Hardest Decision（最难的决定）
A New Perspective（全新的视角）
The Road Not Taken（未选择的路）
A Kind Gesture（善意的举动）
When Plans Change（计划的变化）
A Chance Encounter（偶然的相遇）
The Power of Words（语言的力量）
A Secret Revealed（揭开的秘密）
Finding Balance（找到平衡）
A Dream Come True（梦想成真）
Learning from Failure（从失败中学习）
An Unexpected Mentor（意外的导师）
The Joy of Giving（给予的快乐）
When Opportunity Knocks（机会来临时）
A Promise Kept（守住的承诺）
The Value of Friendship（友谊的价值）
The Long Journey（漫长的旅程）
A Life Well Lived（精彩的人生）

¶教材设计特色

场景化：每篇小故事对应一个场景或主题，贴近生活实际。
语言点清晰：每篇课文配合一个主要语法点，逐步引入复杂结构。
文化融合：在趣味故事中融入英语国家的文化知识。
实践性强：课后配有句型替换练习和对话模拟，促进语言输出。

如果有兴趣，可以深入设计每一篇课文的内容及配套练习！

参考新概念第二册的教学目的，设计思路，短文风格，针对人群，给出短文 The Morning Rush（清晨的匆忙）的正文。

以下是短文 “The Morning Rush”（清晨的匆忙） 的正文内容，基于《新概念英语》第二册的教学目标、设计思路和适合人群，内容简单有趣，注重实用表达和基础语法。短文专为具有一定基础的英语学习者设计，帮助他们巩固词汇和句式。

¶The Morning Rush

Every morning, Sarah wakes up late. She always sets her alarm for 7:00, but she never gets out of bed until 7:30. This morning was no different.

At 7:45, Sarah realized she only had fifteen minutes to get ready. She quickly brushed her teeth, washed her face, and put on her clothes. There was no time for breakfast, so she grabbed an apple and rushed out the door.

When Sarah reached the bus stop, she saw her bus driving away. “Oh no!” she said, “Not again!” Sarah decided to run to the next stop. Luckily, she caught the bus just in time.

On the bus, Sarah checked her bag. “Where is my phone?” she thought. Then she remembered: it was still on her desk at home.

When Sarah finally arrived at work, her boss was waiting for her. “Sarah,” he said, “you’re late again!” Sarah smiled nervously and said, “Good morning! At least I’m here!”

¶语言目标

词汇：
- alarm (闹钟)
- grab (抓住/拿走)
- bus stop (公交车站)
- luckily (幸运地)
- desk (书桌)
语法：
- 现在时：描述日常习惯和事实。
  e.g. “Sarah wakes up late.”
- 过去时：讲述早晨发生的事情。
  e.g. “She realized she only had fifteen minutes to get ready.”
实用句型：
- “There was no time for…” 用于表达来不及做某事。
- “Not again!” 表达对重复发生的事情感到烦恼。
- “At least…” 用于表达积极的一面。

¶设计思路

针对人群：
面向英语初中级学习者（A2-B1水平），适合学生、上班族等需要日常实用英语的人群。
故事情节：
选取日常生活中常见的早晨场景（赶时间、忘东西、错过公交车），增强代入感和趣味性。
教学目的：
- 通过简洁的句子结构和高频词汇，帮助学习者建立语言自信。
- 强化一般现在时和一般过去时的使用场景。
延伸练习：
- 翻译练习：
  - 她抓起一个苹果，冲出了门。
  - 幸运的是，她及时赶上了公交车。
- 句型替换：
  - Rewrite: “She grabbed an apple and rushed out the door.” → “She took a sandwich and ran out the door.”
- 口语对话：
  - 你和朋友聊聊自己的“清晨故事”。

这篇短文短小精悍、内容有趣，能够吸引学习者的兴趣，同时帮助他们巩固基础知识并进行语言输出！

你是一个英语教材设计专家。
首先介绍新概念第二册的教学目的，设计思路，短文风格。
然后参考新概念第二册写一篇短文。
内容要求：以趣味性为主线，同时结合实用词汇与基础语法，帮助初中级英语学习者提升语言表达能力。
最后针对新的短文给出相关词汇，语法，实用句型，教学目的，延伸练习等。
短文题目：A Trip to the Zoo（去动物园）

2024-11-21

从零搞定 MySQL 备份

在今天的数字化世界里，数据库崩溃可能带来的损失远远超出我们的想象。所以，备份不再只是一个技术任务，它已经变成了每一个数据管理者和企业领导者必须思考和解决的生死存亡的关键。

今天我们尝试讨论如下问题：

如何快速的备份 MySQL 的所有数据？
如何定时自动化的备份数据？
如何做好远程数据备份？
如何在备份失败时发出告警？
如何建立一套高效可靠的备份策略？
如何做备份可用性检测和恢复演练？

¶1. 如何快速的备份 MySQL 的所有数据？

MySQL 的备份工具有很多，mysqldump, mysqlpump, mysql shell, mydumper/myloader, xtrabackup等，我们从最简单的 mysqldump 开始，它足够简单可靠，而且随 MySQL 一起发行，不需要额外安装。

最普遍的需求是备份整个实例的所有数据库，包含每个数据库的所有表，存储过程，函数，视图等。

1	mysqldump -h 127.0.0.1 -u root -ppassword --all-databases --routines --triggers --single-transaction --master-data=2 > ./`date +%Y%m%d%H%M%S`.sql

这条命令是使用 mysqldump 工具进行 MySQL 数据库备份的命令。让我们逐部分分析它的功能：

mysqldump：
- mysqldump 是 MySQL 提供的一个备份工具，用于导出 MySQL 数据库或数据库中的数据。
-h 127.0.0.1：
- 这个选项指定 MySQL 服务器的主机地址。127.0.0.1 是本地回环地址，表示连接到本地 MySQL 实例。也可以使用 localhost 或服务器的 IP 地址。
-u root：
- 指定登录 MySQL 的用户名为 root。-u 后面跟的是用户名。
-ppassword：
- -p 后面跟的是密码，表示连接 MySQL 时使用的密码。在这个例子中，密码是 password。注意：-p 和密码之间不能有空格。
--all-databases：
- 这个选项指定备份所有的数据库，而不仅仅是某一个数据库。如果省略此选项，则默认只备份指定的数据库。
--routines：
- 该选项用于备份数据库中的存储过程和存储函数（routines）。如果你有使用存储过程或函数，这个选项很重要，否则它们不会被包含在备份中。
--triggers：
- 这个选项用于备份触发器（triggers）。触发器是数据库中的一些自动执行的操作，可以在插入、更新或删除时触发。
--single-transaction：
- 这个选项在备份时确保事务一致性，适用于支持事务的数据库引擎（如 InnoDB）。它确保在备份过程中，数据库中的数据不会被修改，从而保证了备份的一致性。这是通过在开始备份时使用 START TRANSACTION 来完成的，适用于使用事务的存储引擎。
--master-data=2：
- 这个选项用于备份时记录主从复制的相关信息，特别是在设置 MySQL 主从复制时。--master-data=2 会在备份文件中加入一个注释，记录主服务器的二进制日志位置及文件名，通常用于恢复时设置复制。
- =2 的含义是将复制信息以注释的形式写入备份文件，而不是执行语句。
> ./'date +%Y%m%d%H%M%S'.sql：
- > 是输出重定向符号，将命令的输出结果保存到一个文件中。
- ./date +'%Y%m%d%H%M%S'.sql 是备份文件的名称，使用了 date 命令来生成一个基于当前时间的文件名。具体来说，date +%Y%m%d%H%M%S 会生成类似 20241121094500 格式的日期时间戳。这个时间戳确保每次备份时文件名不同，以避免覆盖现有的备份文件。

我们能想到一些更深入的个性化需求：

如何只备份某个数据库？
如何只备份某个表？
如何只备份数据，不备份表结构？
如何把不同的表备份到各自独立的文件？
如何压缩备份文件？
如何加密备份文件？
如何多线程备份数据以提高备份速度？
如何显示备份的进度及预估备份时长？
如何避免在 Shell 命令行中输入密码以提高安全性？

这些高级需求我们以后再讨论，对于新手来说，上面一行代码足以满足 90% 的需求。

¶2. 如何定时自动化的备份数据？

首先想到的是使用 linux 自带的 crontab 机制，这要求我们把备份命令写到一个 shell 文件中，假设我们创建的文件名叫 mysql_backup.sh，它看起来像这样：

#!/bin/bash
set -euo pipefail

FILE=./`date +%Y%m%d%H%M%S`.sql
mysqldump -h 127.0.0.1 -u root -ppassword --all-databases --single-transaction --master-data=2 > \$FILE

前两行是 Bash 脚本的惯用写法，用于确保脚本的可靠性和执行的一致性，以下是每一行的解释：

#!/bin/bash 告诉系统用 /bin/bash 解释器来执行脚本。
set -euo pipefail
- -e：避免错误被忽略，防止脚本在意外情况下继续运行。
- -u：防止因拼写错误或遗漏变量赋值导致脚本出现难以调试的问题。
- -o pipefail：提高错误检测的可靠性，确保管道中的任意一部分命令失败时，整个管道返回失败状态。

后面两行是我们上一步的备份命令。

输入 crontab -e，会用默认编辑器打开 crontab 规则文件，假设上面的 mysql_backup.sh 文件在 Home 目录 ~/ 下，我们在编辑器里输入如下内容：

1	0 0 * * * cd ~/ && ./mysql_backup.sh >>./mysql_backup.log 2>&1 &

该命令表示每天的午夜 00:00（凌晨零点）运行一次备份脚本，以下是每个字段解析，可以根据自己的需要进行修改。

字段位置	值	取值范围	说明
分钟 (Minute)	`0`	`0-59`	表示任务将在第 0 分钟执行。
小时 (Hour)	`0`	`0-23`	表示任务将在第 0 小时执行（午夜）。
日 (Day of Month)	`*`	`1-31`	表示不限制日期（每天都运行）。
月 (Month)	`*`	`1-12` (或 `JAN-DEC`)	表示不限制月份（每月都运行）。
星期 (Day of Week)	`*`	`0-7` (或 `SUN-SAT`)	表示不限制星期（每天都运行）。

编辑完成后要保存退出，如果使用 vi 编辑器，输入 :wq，如果使用 nano 编辑器，先按 ctrl+o 保存，然后按 ctrl+x 退出。

如果你认为上面的操作有些复杂，那么我们可以一步到位，复制如下代码在终端里执行即可，如有特殊需求，在复制前做好修改。

cat <<EOF > ./mysql_backup.sh
#!/bin/bash
set -euo pipefail

FILE=./`date +%Y%m%d%H%M%S`.sql
mysqldump -h 127.0.0.1 -u root -ppassword --all-databases --single-transaction --master-data=2 > \$FILE
rsync -avzP \$FILE ubuntu@bak-server:/data/backup/
EOF

crontab -l > crontab_backup_$(date +'%Y%m%d_%H%M%S').txt 2>/dev/null
new_rule="0 0 * * * cd $PWD && ./mysql_backup.sh >>./mysql_backup.log 2>&1 &"
(crontab -l 2>/dev/null; echo "$new_rule") | crontab -

后面三行的目的是 备份当前的 crontab 规则 并 向 crontab 添加新规则，以下是逐行的详细解释。

第一行：将当前的 crontab 内容保存到一个带时间戳的文件中，作为备份。

crontab -l: 列出当前用户的所有定时任务。
>: 将输出重定向到文件。
crontab_backup_$(date +'%Y%m%d_%H%M%S').txt:
- $(date +'%Y%m%d_%H%M%S'): 获取当前时间，格式为 YYYYMMDD_HHMMSS（如 20241121_150300）。
- 文件名形如 crontab_backup_20241121_150300.txt，用来保存当前 crontab 的内容。
2>/dev/null: 将标准错误（错误信息）重定向到 /dev/null，避免在没有 crontab 任务时输出错误信息。

第二行：定义一个任务，每天午夜备份 MySQL 数据，并将日志记录到当前目录下的 mysql_backup.log。

new_rule: 定义了一个变量，内容是新的 crontab 任务。
0 0 * * *: 每天的午夜（00:00）执行该任务。
cd $PWD: 切换到当前工作目录（由环境变量 $PWD 确定）。
./mysql_backup.sh: 执行 mysql_backup.sh 脚本。
>> ./mysql_backup.log: 将脚本的标准输出追加到日志文件 mysql_backup.log。
2>&1: 将脚本的标准错误 重定向 到标准输出（即一并写入 mysql_backup.log）。
&: 在后台运行该命令（不阻塞 crontab 进程）。

第三行：将当前 crontab 内容和新规则合并后，重新加载到 crontab 中，最终实现追加新任务的效果。

( ... ): 子进程运行括号内的命令。
crontab -l 2>/dev/null: 获取当前的 crontab 内容。如果没有任务，忽略错误信息（通过 2>/dev/null）。
echo "$new_rule": 将新规则输出到标准输出。
;: 将两个命令（crontab -l 和 echo）的输出合并。
|: 将合并后的输出通过管道传递给下一个命令。
crontab -: 用新的标准输入内容覆盖当前用户的 crontab。

我们可能会想到一些问题：

如何解决备份过多引起磁盘剩余空间不足的问题？
如何做增量备份和差异备份以减少磁盘占用？

这些问题以后我们会详细讨论。

¶3. 如何做好远程数据备份？

目前为止我们已经可以定期的把数据库备份到本地磁盘了，但如果服务器磁盘损坏或者机房出现火灾时，这些备份也会随之失效，为了提高备份的可用性，我们需要对数据做远程异地备份。

我们可以买一台拥有大容量低性能的磁盘的服务器用来专门保存备份数据，它们通常不会太贵。第一步我们要配置好数据库服务器到备份服务器的 SSH 免密登录，以下是操作步骤。

首先确保 MySQL 服务器上已经生成了密钥对，如果没有，使用以下命令生成 SSH 密钥对：

1	ssh-keygen -t rsa -b 4096 -C "your_email@example.com"

-t rsa：指定密钥类型为 RSA。
-b 4096：指定密钥长度为 4096 位（更安全）。
-C "your_email@example.com"：为密钥添加一个注释，通常是你的邮箱。

过程：

系统会提示你输入密钥的存储路径：
- 如果不需要自定义路径，直接按 Enter，密钥将存储在默认位置：~/.ssh/id_rsa（私钥）和 ~/.ssh/id_rsa.pub（公钥）。
系统可能询问是否设置密钥密码：
- 如果需要更高的安全性，可以设置密码；
- 如果希望完全免密登录，直接按 Enter 跳过密码。

然后要将生成的公钥文件 (~/.ssh/id_rsa.pub) 复制到远程服务器上。

方法 1：使用 ssh-copy-id（推荐），运行以下命令，将公钥自动添加到远程服务器：

1	ssh-copy-id user@remote_server

user：远程服务器的用户名。
remote_server：远程服务器的 IP 地址或域名。
系统会提示输入远程服务器的密码，验证后自动将公钥添加到远程服务器的 ~/.ssh/authorized_keys 文件中。

方法 2：如果 ssh-copy-id 不可用，可以手动复制公钥到远程服务器：

查看本地公钥内容：
1
cat ~/.ssh/id_rsa.pub
登录到远程服务器：
1
ssh user@remote_server

在远程服务器上，将公钥添加到 ~/.ssh/authorized_keys 文件中：

mkdir -p ~/.ssh
echo "your_public_key_content" >> ~/.ssh/authorized_keys
chmod 600 ~/.ssh/authorized_keys
chmod 700 ~/.ssh

最后在本地尝试登录远程服务器：

1	ssh user@remote_server

如果配置正确，应该直接登录远程服务器，无需输入密码。
如果仍提示输入密码，检查以下几点：
- 本地私钥是否正确存放在 ~/.ssh/id_rsa。
- 远程服务器的 ~/.ssh/authorized_keys 是否包含公钥，权限是否正确。

免密登录配置好后，我们需要在 mysql_backup.sh 中加入 rsync 命令，把本地备份同步到远程服务器，如下：

cat <<EOF > ./mysql_backup.sh
#!/bin/bash
set -euo pipefail

FILE=./`date +%Y%m%d%H%M%S`.sql
mysqldump -h 127.0.0.1 -u root -ppassword --all-databases --single-transaction --master-data=2 > \$FILE
rsync -avzP \$FILE ubuntu@bak-server:/data/backup/
EOF

crontab -l > crontab_backup_$(date +'%Y%m%d_%H%M%S').txt 2>/dev/null
new_rule="0 0 * * * cd $PWD && ./mysql_backup.sh >>./mysql_backup.log 2>&1 &"
(crontab -l 2>/dev/null; echo "$new_rule") | crontab -

新增的命令使用 rsync 工具将本地的文件或目录 $FILE 同步到远程服务器 bak-server 上的路径 /data/backup/。以下是对该命令的详细解释，可根据需要自行修改。

-a (archive mode)
归档模式，表示递归同步目录，同时保留文件的权限、时间戳、符号链接等元数据。
-v (verbose)
显示详细的同步过程。
-z (compress)
在传输时对数据进行压缩，提高传输效率（特别是在网络带宽有限时）。
-P (progress + partial)
- --progress：显示每个文件的传输进度。
- --partial：如果传输中断，可以保留未完成的部分文件，方便下次继续传输。
ubuntu@bak-server:/data/backup/
- ubuntu：表示远程服务器上的用户名。
- bak-server：远程服务器的主机名或 IP 地址。
- /data/backup/：远程服务器上的目标目录，文件或目录会被同步到这里。

有时候我们会想把数据库备份在 AWS S3 上，因为它便宜且可靠，我们会在以后讨论这个话题。

¶未完待续…

¶I have a blog about mysql backup, and I need you to write a post titled ‘What everyone should know about mysql data backups’ Provide the content in Markdown code block, and include the reference URL at the end of the blog post

What Everyone Should Know About MySQL Data Backups

MySQL data backups are crucial for maintaining the integrity and availability of your database. Understanding the different types of backups, best practices, and recovery strategies can significantly enhance your data protection efforts. This post will cover essential aspects of MySQL backups that everyone should know.

¶Types of MySQL Backups

There are two primary types of MySQL backups: physical and logical.

Physical Backups: These involve copying the actual database files. Tools such as Percona XtraBackup and MySQL Enterprise Backup can be used for this purpose. Physical backups are generally faster to restore because they involve fewer steps.
Logical Backups: This method uses tools like mysqldump to create a textual representation of the database. Logical backups are more flexible but can take longer to restore, especially for large databases.

Additionally, it’s advisable to keep copies of binary log files, which allow you to recover data up to the last transaction point.

¶Best Practices for MySQL Backups

Regular Backup Schedule: Establish a backup frequency that aligns with your recovery point objective (RPO). For critical systems, daily or even hourly backups may be necessary, while less critical data might only require weekly backups[1][4].
Offsite Storage: Store backup copies in a different location, such as cloud storage or an external server. This protects your data against local failures[1][4].
Data Consistency: Ensure data consistency during backups by using transactions and locking mechanisms. This prevents changes during the backup process, ensuring that the backup reflects a stable state of the database[1][4].
Automation: Automate your backup processes using cron jobs or Windows Task Scheduler. This reduces the risk of human error and ensures that backups occur regularly without manual intervention[4][5].
Encryption and Security: Secure your backups by encrypting sensitive data and managing access controls effectively. Regularly review your backup security policies to comply with legal and regulatory requirements[4][7].

¶Recovery Strategies

Having a solid recovery strategy is as important as the backup itself. Here are some key points:

Test Your Backups: Regularly test your backup restoration process to ensure that you can recover quickly in case of data loss.
Point-in-Time Recovery: Utilize binary logs for point-in-time recovery, allowing you to restore your database to a specific moment before a failure occurred[6][8].
Documentation: Maintain clear documentation of your backup and recovery procedures. This will help streamline the recovery process during emergencies.

¶Conclusion

Understanding MySQL backups is vital for any organization relying on this database system. By implementing best practices and having a robust recovery plan in place, you can safeguard your data against unexpected failures and ensure business continuity.

For more detailed information on MySQL backup strategies, you can refer to Percona’s Best Practices Guide.

每个人都应该知道的 MySQL 数据备份

MySQL 数据备份对于维护数据库的完整性和可用性至关重要。了解不同类型的备份、最佳实践和恢复策略可以显著增强您的数据保护工作。本文将涵盖每个人都应该知道的 MySQL 备份的基本方面。

¶MySQL 备份的类型

MySQL 备份主要有两种类型：物理备份和逻辑备份。

物理备份：这涉及复制实际的数据库文件。可以使用 Percona XtraBackup 和 MySQL Enterprise Backup 等工具来执行此操作。物理备份通常恢复速度更快，因为它们涉及的步骤较少。
逻辑备份：这种方法使用 mysqldump 工具创建数据库的文本表示。逻辑备份更灵活，但对于大型数据库，恢复时间可能更长。

此外，建议保留二进制日志文件的副本，这样可以让您恢复到最后一个事务点。

¶MySQL 备份的最佳实践

定期备份计划：建立与您的恢复点目标（RPO）一致的备份频率。对于关键系统，可能需要每天甚至每小时备份，而对不太关键的数据，可能只需每周备份一次[1][4]。
异地存储：将备份副本存储在不同的位置，例如云存储或外部服务器。这可以保护您的数据免受本地故障的影响[1][4]。
数据一致性：通过使用事务和锁机制确保在备份期间的数据一致性。这可以防止在备份过程中发生更改，从而确保备份反映数据库的稳定状态[1][4]。
自动化：使用 cron 作业或 Windows 任务调度程序自动化您的备份过程。这可以减少人为错误的风险，并确保定期进行备份，而无需人工干预[4][5]。
加密和安全性：通过加密敏感数据和有效管理访问控制来保护您的备份。定期审查您的备份安全策略，以符合法律和监管要求[4][7]。

¶恢复策略

拥有一个稳健的恢复策略与备份本身同样重要。以下是一些关键点：

测试您的备份：定期测试您的备份恢复过程，以确保在数据丢失时能够快速恢复。
时间点恢复：利用二进制日志进行时间点恢复，允许您将数据库恢复到故障发生前的特定时刻[6][8]。
文档记录：保持清晰的备份和恢复程序文档。这将有助于在紧急情况下简化恢复过程。

¶结论

了解 MySQL 备份对于任何依赖该数据库系统的组织至关重要。通过实施最佳实践并制定稳健的恢复计划，您可以保护您的数据免受意外故障，并确保业务连续性。

有关 MySQL 备份策略的更多详细信息，请参考 Percona 的最佳实践指南。

2024-11-11

independent-developer

indie startup tips:

解决你自己的问题，对于自己的问题，你是最伟大的专家。
需求要足够小众，大公司不愿意去做。
从参与者不多的细分市场开始，不要第一天就开始做大事。
问题永远应该是第一位的，而不是技术和解决方案。
早期不要追求完美，第一版要快速上线。

links

Make：独立创造者手册

2024-10-30

202410

部分内容由 AI 生成

¶做一个大型fastapi项目的目录规划

在构建一个大型的 FastAPI 项目时，清晰的目录结构能帮助项目更加可维护、易于扩展，并且利于团队协作。以下是一个典型的目录规划：

my_fastapi_project/
├── app/
│   ├── __init__.py
│   ├── main.py               # FastAPI 的入口文件，创建 app 实例并启动服务
│   ├── core/                 # 核心配置模块
│   │   ├── __init__.py
│   │   ├── config.py         # 配置项（如数据库URL、环境变量等）
│   │   ├── security.py       # 安全相关设置（如加密、鉴权逻辑）
│   │   ├── logging.py        # 日志配置
│   ├── api/                  # API 路由模块
│   │   ├── __init__.py
│   │   ├── v1/               # API 版本 1
│   │   │   ├── __init__.py
│   │   │   ├── endpoints/    # 各个 API 端点
│   │   │   │   ├── __init__.py
│   │   │   │   ├── users.py  # 用户相关接口
│   │   │   │   ├── items.py  # 其他模块接口
│   │   │   └── dependencies/ # 依赖项（如权限验证）
│   ├── models/               # 数据库模型
│   │   ├── __init__.py
│   │   ├── user.py           # 用户模型
│   │   ├── item.py           # 其他模型
│   ├── schemas/              # Pydantic 模式（用于数据验证）
│   │   ├── __init__.py
│   │   ├── user.py           # 用户相关数据模式
│   │   ├── item.py           # 其他模块的数据模式
│   ├── crud/                 # 数据库 CRUD 操作
│   │   ├── __init__.py
│   │   ├── user.py           # 用户相关的 CRUD 操作
│   │   ├── item.py           # 其他模块的 CRUD 操作
│   ├── db/                   # 数据库相关
│   │   ├── __init__.py
│   │   ├── base.py           # 数据库基础设置
│   │   ├── session.py        # 数据库会话管理
│   │   └── init_db.py        # 数据库初始化脚本
│   ├── services/             # 独立业务逻辑模块
│   │   ├── __init__.py
│   │   ├── user_service.py   # 用户相关业务逻辑
│   │   ├── email_service.py  # 邮件相关逻辑
│   ├── tests/                # 测试用例
│   │   ├── __init__.py
│   │   ├── test_main.py      # 主入口测试
│   │   ├── test_user.py      # 用户模块测试
│   │   ├── test_item.py      # 其他模块测试
├── alembic/                  # 数据库迁移目录
│   ├── versions/             # 迁移脚本版本
│   └── alembic.ini           # alembic 配置文件
├── scripts/                  # 辅助脚本
│   ├── create_superuser.py   # 创建超级用户脚本
│   ├── init_data.py          # 初始化数据脚本
├── .env                      # 环境变量配置文件
├── Dockerfile                # Docker 镜像配置
├── docker-compose.yml        # Docker Compose 配置
├── requirements.txt          # Python 依赖包列表
├── README.md                 # 项目说明文件
└── .gitignore                # Git 忽略文件

¶目录结构说明

app/main.py: 项目入口文件，创建 FastAPI 实例并定义启动流程。
app/core/: 存放核心配置、日志、安全配置等。
app/api/: 各个 API 版本的具体实现，可以通过 v1 等目录区分不同的版本，便于后续扩展。
app/models/: 定义数据库模型。
app/schemas/: 存放 Pydantic 数据验证模型，用于请求和响应数据的结构验证。
app/crud/: 提供数据库 CRUD 操作，封装直接操作数据库的逻辑。
app/db/: 数据库的初始化和会话管理。
app/services/: 存放业务逻辑，与 API 和数据库层解耦。
app/tests/: 包含所有测试用例，可以细分为各个模块的单元测试和集成测试。
alembic/: 数据库迁移工具 Alembic 的配置及版本文件。
scripts/: 包含辅助管理脚本，如创建超级用户或初始化数据的脚本。
Dockerfile & docker-compose.yml: Docker 配置，便于容器化部署。
.env: 存储环境变量，保证敏感信息不直接写入代码。
requirements.txt: 列出项目依赖的第三方包，便于环境一致性。

¶实现思路

解耦：各层之间使用依赖注入，服务与接口层解耦，使业务逻辑更易于测试和复用。
安全性：将 .env 与 app/core/config.py 结合使用，通过环境变量管理敏感信息。
模块化：将每个功能模块（如用户、项目等）封装为 CRUD、schema、model、service 等子模块，便于快速定位和调试。

¶更好的 grep

grep 一个目录下的所有文件，但忽略.git目录和二进制文件

要在一个目录下递归地搜索文本，同时忽略 .git 目录和二进制文件，可以使用以下 grep 命令：

1	grep -rI --exclude-dir='.git' 'search_term' /path/to/directory

¶参数说明

-r: 递归搜索，遍历子目录中的所有文件。
-I: 忽略二进制文件。grep 会自动跳过二进制文件，减少干扰。
–exclude-dir=‘.git’: 忽略 .git 目录中的内容。你可以添加多个 --exclude-dir 参数来排除多个目录。

¶示例

假设你想在 /home/user/project 目录中查找包含 TODO 的文件，但忽略 .git 目录和二进制文件：

1	grep -rI --exclude-dir='.git' 'TODO' /home/user/project

这个命令会递归地在 /home/user/project 目录下的所有文件中查找包含 TODO 的文本，跳过 .git 目录和所有二进制文件。

¶统计每行的逗号

在 Shell 中可以使用 awk 或 grep 来统计每一行中逗号的个数。以下是几种实现方法：

¶方法 1：使用 `awk`

1	awk -F"," '{print NR, ":", NF-1}' filename

-F","：指定逗号作为字段分隔符。
NF-1：NF 表示字段的数量，NF-1 就是逗号的个数。
NR：表示当前行号。

输出示例：

1
2
3

1 : 3
2 : 5
...

¶方法 2：使用 `grep` 和 `sed`

1	grep -o "," filename \| wc -l

这个命令适合统计文件中所有行的逗号总数，若需要按行统计，则可结合 while 循环：

1
2
3

while IFS= read -r line; do
    echo "$line" | grep -o "," | wc -l
done < filename

¶方法 3：使用 `sed`

1	sed 's/[^,]//g' filename \| awk '{print length}'

这将每一行中非逗号的内容替换为空，然后用 awk 统计字符长度。

tailwind 资源
https://tailadmin.com/

23 Tailwind Dashboards
https://freefrontend.com/tailwind-dashboards/

A free repository for community components using Tailwind CSS
https://www.creative-tim.com/twcomponents

14 Best Free Bootstrap Admin Templates 2024
https://athemes.com/collections/free-bootstrap-admin-templates/

当指定view为flex布局后，给子元素定义width是不起效果的。原因：定义为flex布局元素的子元素，自动获得了flex-shrink的属性，这个属性是什么意思呢？就是告诉子元素当父元素宽度不够用时，自己调整自己所占的宽度比，这个flex-shrink设置为1时，表示所有子元素大家同时缩小来适应总宽度。当flex-shrink设置为0时，表示大家都不缩小适应。所以，倘若给父元素设置了flex布局后，若要其子元素的width有效果，必须给子元素设置flex-shrink为0。

原文链接：https://blog.csdn.net/weixin_51725685/article/details/129310089

Twemproxy 在实际线的使用中，还是存在不少问题的。首先，它是单进程/单线程模型，一个 event_base 要处理所有的事件，这些事件包括 client 请求的读入，转发请求给后端 server，从 server 接受响应，以及将响应发送给 client。单个 Twemproxy 实例，压测最大可以到 8w 左右的 QPS，出于线上稳定性考虑，QPS 最多支撑到 3~4w。而 Memcached 的线上 QPS，一般可以达到 10~20w，一个 Mc 实例前面要挂 3~5 个 Twemproxy 实例。实例数太多，就会引发诸如管理复杂、成本过高等一系列问题。
————————————————
原文链接：https://blog.csdn.net/zhougubei/article/details/139147401

Redis 中有哪些概率性数据结构
https://blog.axiaoxin.com/post/redis-bloom-filter-intro/

概率性数据结构（Probabilistic data structures）是一类用于处理大规模数据集的高效工具，它们通过近似统计结果，如计数、频率和排名等，来替代精确值。虽然这些近似结果并不精确，但它们在许多常见场景中已足够使用，且计算效率更高。此外，这类数据结构还具有其他优势，例如能够模糊化时间、位置等敏感数据。

Redis 常见的概率性数据结构：

HyperLogLog：一种用于估算集合基数的概率性数据结构，非常适合用于估算大规模集合的基数，而不需要存储所有元素。
Bloom Filter：一种用于检查集合中是否存在某个元素的概率性数据结构，非常适合在大规模数据集中进行快速查询和过滤操作。
Cuckoo Filter：一种支持删除操作的概率性数据结构，能够在一定程度上降低误判率，适用于需要更高准确度和支持元素删除的场景。
t-digest：一种用于估算数据流中百分位数的概率性数据结构，特别适合处理大规模数据流。
Top-K：一种用于找出数据流中最频繁出现项的概率性数据结构，适用于需要实时分析数据流中的热门项的场景。
Count-min sketch：一种用于估算数据流中元素频率的概率性数据结构，适用于大规模数据流的频率分析。

选择指南

如果需要快速判断元素是否存在于集合中，并且不需要删除操作，Bloom Filter 是一个极佳的选择。
如果需要检查元素存在性且支持删除操作，Cuckoo Filter 更为适合。
对于估算集合基数，HyperLogLog 是最佳工具。
如果需要实时估算数据流中的百分位数，t-digest 是最佳选择。
若要找出数据流中的最常见元素，Top-K 是最合适的选择。
当需要快速估算数据流中元素的频率时，Count-min Sketch 是理想工具。

从零开始学B端设计
https://www.uxbaike.com/post/5267/5278

https://v2ex.com/t/1088434

UI 门槛低，Dribbble 上找现成的设计文件 1:1 抄一抄技术上就没啥问题了，基本的页面组件在 ui8 下个 uikit 看看源文件就行了，两个周就能超过一般所谓的 UI 设计。
移动端的话可以看看 https://m3.material.io/ google 的设计标准

前端工程师如何兼顾设计工作
https://speakerdeck.com/imdonkey01/qian-duan-gong-cheng-shi-ru-he-jian-gu-she-ji-gong-zuo?slide=65

LaTex 简历
https://ppresume.com/pricing

SaaS 产品集成 Stripe 支付的一些坑
https://v2ex.com/t/1073328#reply19

是这样的呢，resume builder 这个市场不算大，但是也不算小，市面上有很多竞品，开源的实现有一个非常优秀的： https://rxresu.me/ 。不过市面上大多数的 resume builder 底层排版引擎是基于 HTML/CSS 实现的，而 HTML/CSS 的精细排版能力比 LaTeX 还是要差一些。PPResume 的核心卖点就是顶级的排版，以及高质量的 PDF 输出，要实现这点，除了了解 LaTeX ，还要了解排版领域的特定知识，比如我写的排版指南： https://docs.ppresume.com/guide/font ，还有很久之前写的一些关于排版工具的一些对比： https://www.douban.com/note/575242910/ 。

Ask HN: Those making $500/month on side projects in 2024 – Show and tell
https://news.ycombinator.com/item?id=39110194

期权策略大全之：日历价差策略
https://baijiahao.baidu.com/s?id=1814653594827597810&wfr=spider&for=pc

欧洲各个人种之间是什么关系？
https://www.163.com/dy/article/FQ8EHURF0543LLR4.html#

mysqldump 导出表和视图的顺序测试

mysql> create database mytest1;
Query OK, 1 row affected (0.00 sec)

mysql> use mytest1;
Database changed
mysql> create table t1(id int);
Query OK, 0 rows affected (0.13 sec)

mysql> create table v1 as select * from t1;
Query OK, 0 rows affected (0.03 sec)
Records: 0  Duplicates: 0  Warnings: 0

$ mysqldump -udebian-sys-maint mytest1 -p | grep -Ev '\*|--|^$'
Enter password:
DROP TABLE IF EXISTS `t1`;
CREATE TABLE `t1` (
  `id` int DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
LOCK TABLES `t1` WRITE;
UNLOCK TABLES;
DROP TABLE IF EXISTS `v1`;
CREATE TABLE `v1` (
  `id` int DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
LOCK TABLES `v1` WRITE;
UNLOCK TABLES;

新概念英语
http://www.newconceptenglish.com/index.php

linux 数据恢复

sudo fsck /dev/nvme0n1p1
sudo dd if=/dev/sdXn of=/mnt/recovery/backup.img bs=4M
sudo tune2fs -l /dev/nvme0n1p1


sudo ddrescue /dev/nvme0n1p1 /data/temp/dd_image.img /data/temp/dd_logfile.log
sudo losetup --find --show /data/temp/dd_image.img
sudo extundelete /dev/loop12 --restore-file /home/ubuntu/haohu/config.ini
sudo e2fsck -f /dev/loop12
sudo losetup -d /dev/loop12


sudo photorec dd_image.img
$ find . -name '*.ini' | xargs grep smtp
./recup_dir.4/f15986480.ini:[smtp]
$ cat ./recup_dir.4/f15986480.ini
[smtp]
user=onlytiancai@gmail.com

mysqlimport 导入数据时遇到一些问题，如何解决？

如果 csv 是 gz 压缩格式，没法直接导，解压的话太占磁盘空间。
csv 的文件名必须得和表名一致，导入前必须得给文件改名。
导入过程中看不到进度。
如果 csv 中有的列我不想导入，没法过滤。

解决办法：

可以用 zcat 流式解压 gz 通过管道把数据传递给 mysql 命令，中间不需要占用磁盘。
mysqldump 会根据文件名自动推导表名，所以可以直接用 mysql -e 执行 LOAD DATA LOCAL INFILE。
可以用 pv file.gz | gunzip 代替 zcat 来查看进度。
管道中可以加入 csvcut 来过滤掉不需要的列。

整个命令看起来如下，执行之前确保服务器执行了 set global local_infile = 1;

pv /data/mydata.csv.gz | gunzip | csvcut -c 1,2,3 |mysql --local-infile -h192.168.1.1 -uuser -p -D mydb -e "
LOAD DATA LOCAL INFILE '/dev/stdin'
INTO TABLE mytable 
FIELDS TERMINATED BY ','
OPTIONALLY ENCLOSED BY '\"'
LINES TERMINATED BY '\n';"

split

split --additional-suffix=.csv -d --numeric-suffixes=0 --suffix-length=3 -l 200000 mydata.csv mydata_

远程写入文件

mysqlbackup --defaults-file=~/my_backup.cnf --backup-image=- --backup-dir=/tmp backup-to-image | \

ssh @ ‘cat > ~/backups/my_backup.img’

¶hot backup vs online backup

你提到的 hot backup 和 online backup 的确在某些场景下可以被看作是同一个概念，尤其是它们都允许在数据库运行的同时进行备份，且不会中断数据库的读写操作。然而，它们之间可能有些微的差异或特性，这可能解释为什么某些数据库供应商将它作为一个付费功能。

¶1. Hot Backup 和 Online Backup 是否一样？

在大多数数据库上下文中，hot backup 和 online backup 常常可以互换使用，但它们的细节实现可能有区别：

Hot Backup 强调的是备份过程中捕获“所有变化”。换句话说，不仅能够备份已有数据，还能捕获备份期间的增量（如新插入或更新的数据）。
Online Backup 更广泛地表示备份期间数据库仍可在线运行（处理请求）。

某些数据库供应商可能会细分这两个概念，但总体来说，二者大部分场景下是同一回事。

¶2. 为什么需要特殊工具或机制？

在逻辑上，--single-transaction 确实可以用于执行一次一致性的在线备份（比如 MySQL 中使用 mysqldump 加上 --single-transaction），但以下几点解释了为什么复杂数据库（比如 Oracle、PostgreSQL 的企业版）会将 hot backup 功能作为付费特性：

¶a. 事务一致性和并发控制的复杂性

对于支持多事务的数据库，确保备份过程中数据的一致性需要更多的机制。--single-transaction 的实现依赖于快照隔离（snapshot isolation），但这仅适合某些简单的应用场景。
如果数据库的变更复杂（如长事务、触发器或存储过程），实现完全一致性备份就需要数据库引擎额外的处理能力。

¶b. 物理备份 vs 逻辑备份

--single-transaction 通常用于逻辑备份（例如通过 SQL 导出数据）。
热备份工具通常用于 物理备份（直接复制存储文件块），这种方式备份速度更快，尤其适合大数据量的情况。
要实现物理备份的一致性，数据库可能需要跟踪快照点、冻结部分写操作，甚至临时调整存储布局。

¶c. 增量备份与日志捕获

付费热备功能通常附带对 增量备份 和 日志捕获 的支持。
增量备份允许只备份从上次备份后发生变更的数据，大幅提高备份效率。而捕获日志（如 MySQL 的 binlog 或 PostgreSQL 的 WAL）则需要数据库在备份期间实时同步这些数据。

¶d. 性能优化

商业数据库供应商通常会优化热备工具，使其在高并发场景下对性能的影响最小。
自行实现的工具如 --single-transaction，可能在备份时引发大量锁竞争或性能抖动。

¶e. 跨节点或分布式数据库支持

企业版数据库可能需要支持分布式架构的在线备份。这种情况下，维护全局一致性比单节点的 --single-transaction 复杂得多。

¶3. 为什么要收费？

商业化数据库将 hot backup 定为付费特性，可能是因为以下原因：

研发和维护成本：热备份功能的开发涉及到底层存储引擎和事务管理的深度优化。
企业级支持：热备份通常是企业环境才真正需要的功能，针对这些用户收费符合市场逻辑。
差异化策略：通过将此功能划归到企业版，数据库厂商可以区分免费用户和付费用户，推动订阅收入。

¶4. 是否有开源替代方案？

如果你觉得热备功能收费不合理，可以考虑开源数据库中的替代方案：

MySQL/MariaDB：mysqldump + --single-transaction 适用于小规模场景；对于更复杂的需求，可以使用开源工具 Percona XtraBackup。
PostgreSQL：pg_basebackup 提供简单可靠的热备方案。
MongoDB：社区版支持在线备份，但对于快照一致性，可能需要借助底层文件系统工具（如 LVM）。

总结来说，--single-transaction 在某些场景确实可以胜任在线备份，但它是一个比较基础的实现。而付费的热备工具则更注重性能、灵活性和适应复杂环境。

¶如何对一个正在运行的python进行进行内存诊断，这个进程的内存一直在增长

对一个正在运行的 Python 进程进行内存诊断，可以分几个步骤进行：

¶1. 使用外部工具检查进程内存占用

首先确认该进程的内存使用增长情况和趋势：

Linux 系统：
- 使用 top 或 htop 查看内存增长。
- 使用 ps 定位内存占用高的进程：
  1
  ps aux | grep python
- 使用 pmap 查看进程的内存映射：
  1
  pmap <PID>
Windows 系统：
- 在任务管理器中监控 Python 进程的内存使用。
- 使用 Windows Performance Monitor 或者 Sysinternals 的工具（如 Process Explorer）。

¶2. 捕获 Python 堆内存信息

使用 Python 专门的工具捕获堆内存信息，分析内存泄漏或者过度增长的原因。

¶方法 1：`tracemalloc`

tracemalloc 是 Python 内置的一个模块，可以跟踪内存分配情况，找出内存占用大的对象和增长点。

步骤：

在代码中插入以下代码段：

import tracemalloc

tracemalloc.start()

# 在某些关键点打印内存使用信息
snapshot = tracemalloc.take_snapshot()
top_stats = snapshot.statistics('lineno')

print("[ Top 10 memory-consuming lines ]")
for stat in top_stats[:10]:
    print(stat)

也可以定期运行 tracemalloc 来对比两次快照的内存分配：

snapshot1 = tracemalloc.take_snapshot()
# 等待一定时间或操作后
snapshot2 = tracemalloc.take_snapshot()
stats = snapshot2.compare_to(snapshot1, 'lineno')
for stat in stats[:10]:
    print(stat)

¶方法 2：`objgraph`

objgraph 是一个第三方工具，可以分析 Python 对象的引用关系，找到那些不必要增长的对象。

安装：

1	pip install objgraph

用法：

import objgraph

# 打印当前 Python 中引用最多的对象类型
objgraph.show_most_common_types(limit=10)

# 跟踪某种类型对象的增长
objgraph.show_growth()

# 可视化某个对象的引用关系（需要 graphviz 支持）
objgraph.show_backrefs(some_object, filename='backrefs.png')

¶方法 3：`memory_profiler`

memory_profiler 是一个简单易用的工具，可以实时监控函数级别的内存变化。

安装：

1	pip install memory_profiler

用法：
在代码中使用装饰器 @profile，标记需要检查内存占用的函数：

@profile
def my_function():
    x = [i for i in range(100000)]
    y = [i ** 2 for i in x]
    return y

然后使用命令行运行：

1	python -m memory_profiler my_script.py

¶3. 使用分析器工具

有时需要更多的分析工具：

py-spy: 一个性能分析工具，可以附加到正在运行的 Python 进程，支持查看线程堆栈和内存情况。
1
py-spy top --pid <PID>

heapy（Guppy 模块的一部分）:

1	pip install guppy3

然后使用 heapy 检查内存：

1
2
3

from guppy import hpy
h = hpy()
print(h.heap())  # 查看堆的当前使用情况

¶4. 排查内存泄漏的代码

如果发现内存泄漏，通常问题可能是：

未释放的全局变量或缓存。
循环引用导致的垃圾回收失败（可以用 gc.collect() 强制清理）。
第三方库的 Bug。

使用工具确定问题点后，逐步优化代码。

¶5. 监控长时间运行的服务

对于长时间运行的服务，比如 Flask/Django 服务，可以结合日志和分析工具定期记录内存使用情况，例如通过 psutil 定时检查。

代码示例：

import psutil
import os

process = psutil.Process(os.getpid())
print(f"Memory usage: {process.memory_info().rss / 1024 ** 2:.2f} MB")

成语游戏 https://fourwordgame.com/

landing page
https://github.com/Blazity/next-saas-starter

¶我要做3个node的ES集群，如何做高可用，负载均衡，故障转移

在 Elasticsearch 集群中，高可用、负载均衡和故障转移是通过合理的节点配置和架构设计实现的。以下是具体实现步骤和建议：

¶1. 三节点集群的基本架构

¶节点角色分配

在一个 3 节点的集群中，每个节点应至少包括以下角色：
- Master 节点（负责集群管理和元数据分发）
- Data 节点（存储和处理数据）
- Ingest 节点（预处理数据，非必须，但推荐）

为高可用性，推荐每个节点都同时承担 master 和 data 角色。

¶配置文件（`elasticsearch.yml`）示例

在每个节点的配置文件中：

¶公共配置（所有节点共享）

cluster.name: es-cluster      # 集群名称
node.name: ${HOSTNAME}        # 节点名称（推荐使用主机名）
network.host: 0.0.0.0         # 绑定所有接口
discovery.seed_hosts: ["node1-ip", "node2-ip", "node3-ip"]  # 集群中的所有节点 IP
cluster.initial_master_nodes: ["node1", "node2", "node3"]   # 初始主节点，集群首次启动用

¶节点专属配置

为每个节点设置唯一名称和角色（在每个节点上修改以下配置）：

¶Node 1 (`elasticsearch.yml`)

1	node.roles: ["master", "data"] # 同时作为主节点和数据节点

¶Node 2 (`elasticsearch.yml`)

1	node.roles: ["master", "data"]

¶Node 3 (`elasticsearch.yml`)

1	node.roles: ["master", "data"]

¶2. 高可用配置

¶配置主节点故障转移

在 Elasticsearch 中，至少需要过半数的主节点候选者（master）存活才能维持集群正常运行。因此：

3 个主节点的集群允许 1 个节点故障。
如果主节点候选者不足过半（例如只有 1 个节点存活），集群将无法选主，进入只读模式。

¶配置建议

确保每个节点的硬件配置相同，分布在不同的物理主机或数据中心。
使用至少 3 个节点作为主节点候选者。

¶分片和副本的配置

分片（Shard）和副本（Replica）是 Elasticsearch 数据冗余和高可用的核心。

¶配置建议

主分片：每个索引应合理划分分片数量，通常是数据量的 1.5 倍。
副本：每个主分片至少 1 个副本。对于 3 个节点集群，推荐如下：
1
2
3
4
主分片 (P) 和副本 (R) 分布示意：
Node 1: P1 R2
Node 2: P2 R3
Node 3: P3 R1
这样即使任意一个节点失败，数据仍然可用。

设置副本数量的 API 命令：

PUT /_settings
{
  "number_of_replicas": 1
}

¶3. 负载均衡

¶Elasticsearch 自带负载均衡

Elasticsearch 客户端支持自动负载均衡。当客户端向一个节点发送请求时，该节点会将请求路由到正确的分片。

客户端连接时可配置多个节点：

from elasticsearch import Elasticsearch

es = Elasticsearch(
    hosts=[
        {"host": "node1-ip", "port": 9200},
        {"host": "node2-ip", "port": 9200},
        {"host": "node3-ip", "port": 9200},
    ]
)

¶外部负载均衡器

使用外部工具（如 NGINX、HAProxy 或 AWS ELB）实现 HTTP 请求的负载均衡。

¶使用 NGINX 作为负载均衡器

upstream elasticsearch {
    server node1-ip:9200;
    server node2-ip:9200;
    server node3-ip:9200;
}

server {
    listen 80;

    location / {
        proxy_pass http://elasticsearch;
        proxy_set_header Host $host;
    }
}

¶4. 故障转移

¶自动故障转移

Elasticsearch 自带故障转移功能。当一个节点不可用时：

副本分片会在剩余的节点上发挥作用。
当节点恢复后，数据会自动重同步。

¶监控和告警

建议使用以下工具监控节点健康和负载，以便快速响应节点故障：

Kibana：内置的监控 UI，可以直观查看集群状态。
Elastic Stack（ELK）：使用 Beats 采集集群日志和指标。
Prometheus + Grafana：监控集群运行状态，设置告警规则。

¶5. 集群健康检查

¶健康检查命令

检查集群健康状态：

1	curl -X GET "http://localhost:9200/_cluster/health?pretty"

健康状态：

green：集群运行正常，所有主分片和副本分片都可用。
yellow：部分副本分片不可用，但主分片正常。
red：至少一个主分片不可用。

¶6. 总结

高可用性：使用 3 个主节点（最少 3 个，保证过半选主）。
负载均衡：配置客户端连接多个节点，或使用 NGINX/HAProxy 实现负载均衡。
故障转移：启用副本分片，确保数据节点失效时仍能访问。

如果有进一步问题，欢迎继续讨论！

2024-10-26

LSTM预测股价

部分内容由 AI 生成

¶可行性

根据历史K线图使用HMM或LSTM预测未来一周的股价可行吗？

根据历史K线图使用HMM（隐马尔可夫模型）或LSTM（长短期记忆网络）来预测未来一周的股价在理论上可行，但在实际应用中面临一些挑战。以下是可行性分析及每种方法的优缺点：

¶1. 隐马尔可夫模型 (HMM)

HMM是一种基于概率的模型，适合用于捕捉数据中的隐含状态转移。它假设价格波动的模式可以由一些隐藏的状态（如上升、下降、震荡）控制。

可行性分析：

优点：
- HMM适合用于建模序列数据，并且可以捕捉不同市场状态（比如牛市、熊市）的转换。
- 它在处理小样本数据时比LSTM更有效，因为它不需要大量的数据和长序列的训练。
- 可以分析某些特定K线形态（如持续上涨或连续下跌）是否会出现在特定的隐状态中，从而捕捉趋势。
缺点：
- HMM的假设过于简单，它假定状态之间是独立的，无法捕捉更复杂的时间依赖结构。
- HMM对市场突发事件等非线性因素的应对较弱，可能导致预测误差大。
- 股价的变化是高度非线性的，而HMM更适合线性和简单的状态转移，不一定能很好地适应复杂的金融数据。

可行性结论：
使用HMM预测短期趋势或方向性波动具有一定可行性，但对于具体的价格预测效果有限。

¶2. 长短期记忆网络 (LSTM)

LSTM是一种专门用于处理序列数据的神经网络，能捕捉长时间的依赖关系，在处理金融时间序列数据（如股价）时有较好的表现。

可行性分析：

优点：
- LSTM能够记住长序列中的关键模式，适合用来捕捉股价的长期和短期依赖关系。
- LSTM不需要对数据进行特征工程，可以直接使用原始的K线图数据（如开盘价、收盘价、最高价、最低价等）进行训练。
- 在引入技术指标、成交量、市场情绪等辅助特征后，LSTM可以有效地整合这些信息，提高预测精度。
缺点：
- 需要大量的数据和长时间的训练才能得到有效模型，而如果训练数据不足，模型的泛化能力较差。
- LSTM容易过拟合，需要谨慎调整超参数并引入正则化方法来避免过拟合。
- 金融市场中存在很多随机性和不可预测的事件，LSTM虽然能捕捉数据中的模式，但在应对随机性较强的短期价格波动时效果有限。

可行性结论：
使用LSTM预测短期股价走势具有一定可行性，特别是在数据量较大、并且加入了多种特征信息的情况下。LSTM可以作为股价方向性预测的辅助工具，但并不能完全准确预测股价的具体数值。

¶实际操作建议

若使用HMM或LSTM来预测股价，可以结合以下方法来提升预测效果：

数据预处理和特征工程：除了K线图中的价格数据，可以引入成交量、技术指标（如RSI、MACD等）作为辅助特征。
分层建模：HMM可以用于识别市场状态（上升、下降、震荡），然后在每个状态下使用LSTM进行进一步的短期股价预测。这样可以有效地结合两种模型的优点。
模型评估与验证：可以使用交叉验证来评估模型的预测效果，特别是对LSTM模型，防止过拟合。
设置合理的预测期望：由于市场存在大量随机性，即使是最先进的模型也无法做到100%的预测准确率，因此应将模型预测结果作为辅助决策的参考，结合风险控制策略来管理投资组合。

¶加入多因子信息

LSTM除了量价外可以加入其它因子的数据吗，比如基本面因子，技术面因子，市场情绪因子等来增加预测准确性

是的，LSTM除了量价数据外，还可以加入基本面因子、技术面因子和市场情绪因子等其他数据源，以提高预测准确性。这些因子能够提供股价趋势更多维的背景信息，让LSTM模型可以捕捉到更多元的市场动因和复杂的时间依赖性关系。下面分别介绍这些因子如何整合到LSTM模型中。

¶1. 基本面因子

基本面因子反映了公司的财务健康状况、盈利能力和运营效率等。常见的基本面因子包括市盈率（PE）、市净率（PB）、每股收益（EPS）、净利润增长率、资产负债率等。

数据处理：基本面数据通常是按季度或年度发布的，而量价数据是日频数据。可以对基本面因子进行插值或保持前值（forward-fill），使其与日频数据对齐。
因子选择：可以通过相关性分析或特征筛选，选择对股价波动有显著影响的关键基本面因子。
加入方式：将这些因子作为LSTM模型的附加特征，将每一个因子与每日量价数据组合成一个时间序列输入模型。

¶2. 技术面因子

技术面因子通常基于历史价格和成交量衍生而来，用于捕捉市场的技术形态、动能和趋势。常用的技术面因子包括移动平均线（MA）、相对强弱指数（RSI）、移动平均趋同背离指标（MACD）、布林带等。

因子计算：技术指标可以在量价数据的基础上进行预先计算。根据需要选取不同的周期（如5日、20日、60日等）计算多种技术指标。
因子标准化：技术指标的数值跨度较大，标准化或归一化处理后可以提高模型的收敛速度和稳定性。
加入方式：将技术指标添加为附加的时间序列输入特征。与量价数据同时输入LSTM模型，以捕捉趋势和动能。

¶3. 市场情绪因子

市场情绪因子反映投资者的心理和市场的预期，通常来自新闻、社交媒体、投资者情绪指数等非结构化数据。常见的市场情绪因子包括VIX指数（市场恐慌指数）、社交媒体情绪得分、新闻情感分析等。

情绪数据获取与处理：
- VIX指数：可以直接获取该指数的每日数据。
- 新闻或社交媒体情绪：可以使用NLP方法对金融新闻或社交媒体内容进行情感分析，将正向、负向情绪得分量化为情绪因子。
因子频率：情绪因子可以是每日更新，也可以根据新闻事件的频率来更新。
加入方式：将情绪得分作为每日新增的特征列输入LSTM模型，帮助捕捉市场心理对价格的短期影响。

¶4. 宏观经济因子

宏观经济因子反映整体经济环境，可能间接影响股价波动。常用的宏观因子包括利率、通货膨胀率、GDP增长率、失业率等。

数据预处理：这些数据通常是月度或季度数据，需要插值或前值填充。
加入方式：将宏观经济因子作为长周期特征输入，可以帮助模型识别股价在不同经济周期下的趋势特征。

¶综合考虑：多因子LSTM模型设计

在设计包含多因子的LSTM模型时，需要合理组合和处理不同因子的时间频率。一个典型的多因子LSTM模型流程如下：

数据准备和对齐：将不同时间频率的因子数据对齐，必要时使用插值或前值填充。
特征工程和选择：进行特征选择或降维处理，剔除冗余或影响不显著的因子，确保模型输入维度合理。
标准化和归一化：对所有输入因子进行标准化或归一化，避免不同数值范围导致模型收敛问题。
LSTM模型结构设计：
- 输入层：多因子序列输入层，包含量价数据、技术面、基本面、情绪面和宏观经济因子。
- LSTM层：可以堆叠多层LSTM层，增强模型对长短期依赖的捕捉能力。
- 全连接层：LSTM层的输出通过全连接层，生成最终预测结果。
训练与验证：将数据分为训练集、验证集和测试集，优化模型超参数（如学习率、层数、单元数等），并使用交叉验证等方法评估模型效果。

¶示例代码框架

以下是一个包含多因子的LSTM模型的代码框架，假设量价数据、基本面因子、技术面因子和市场情绪因子已处理为DataFrame格式并对齐。

import numpy as np
import pandas as pd
from sklearn.preprocessing import StandardScaler
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Dropout
from tensorflow.keras.optimizers import Adam

# 1. 数据准备
# 将数据加载并合并为一个DataFrame（假设已对齐日期）
data = pd.read_csv('multi_factor_data.csv', index_col='Date')
X = data.drop(columns=['target_price']).values
y = data['target_price'].values

# 2. 数据标准化
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# 3. 构造时间序列样本
sequence_length = 60  # 60天的时间序列窗口
X_seq, y_seq = [], []
for i in range(len(X_scaled) - sequence_length):
    X_seq.append(X_scaled[i: i + sequence_length])
    y_seq.append(y[i + sequence_length])

X_seq, y_seq = np.array(X_seq), np.array(y_seq)

# 4. 构建LSTM模型
model = Sequential([
    LSTM(50, return_sequences=True, input_shape=(X_seq.shape[1], X_seq.shape[2])),
    Dropout(0.2),
    LSTM(50, return_sequences=False),
    Dropout(0.2),
    Dense(25),
    Dense(1)
])

# 编译模型
model.compile(optimizer=Adam(learning_rate=0.001), loss='mean_squared_error')

# 5. 训练模型
history = model.fit(X_seq, y_seq, epochs=50, batch_size=32, validation_split=0.2)

# 6. 预测未来价格
predicted_prices = model.predict(X_seq[-1].reshape(1, X_seq.shape[1], X_seq.shape[2]))
print("未来价格预测值：", predicted_prices)

¶注意事项

数据量要求：LSTM对数据量要求较高，建议使用较长时间段的历史数据以获得稳定的模型效果。
过拟合风险：引入多种因子会增加模型复杂性，需要通过正则化（如Dropout）和调参来避免过拟合。
实际验证：在测试集上进行实际验证，使用MSE、MAE等指标评估预测效果，优化模型参数。

通过引入多因子数据，LSTM模型在股价预测中的表现可以显著提升，但其效果还取决于因子选择和模型调优的质量。

2024-10-26

波动率预测

部分内容由 AI 生成

¶预测未来一周的股价和波动率哪个更可行？

未来一周的股价预测和波动率预测相比，波动率预测通常更可行，原因如下：

波动率相对稳定且具有一定的规律：波动率在短期内往往受到已知的事件驱动，比如财报发布、经济数据公布、重要会议（如美联储会议）等。这些事件往往对市场波动产生显著影响，使波动率在事件前后具有相对规律性，而价格本身的走向（上涨或下跌）则更难预测。
波动率模型更成熟：金融市场中有许多基于统计的波动率模型，比如GARCH（广义自回归条件异方差）模型和EGARCH模型，这些模型通常能够捕捉波动率的自相关性和异方差性特征，而股价本身则因为价格波动的方向性更加随机，难以用单一模型描述。
波动率对市场情绪的反应更加直接：波动率可以被视为市场情绪的反映，它通常会在市场恐慌情绪增加或不确定性加剧时上升，而当市场情绪趋于平稳时下降。因此，短期内影响市场情绪的因素在预测波动率时作用较大，而股价的方向则容易受到更多不确定因素的影响。
股价受多种不确定因素影响：股价在短期内的变化既包括基本面（如财务数据、经济指标）影响，也受到技术面（技术指标、交易量）和市场情绪的波动。尤其是外部不确定事件（如突发的国际事件、政策变动）会对股价产生随机性冲击，使得短期内股价预测的准确性大大降低。

¶实际操作中的应用

如果投资者想要根据波动率进行操作，可以关注VIX指数（代表市场波动预期的指标）或个股的隐含波动率，并利用期权或其他衍生品进行波动性交易。
股价预测方面，虽然一周的股价变动难以精准预测，但可以根据技术指标（如移动平均、布林带等）和市场情绪指标来设定区间预测，配合风险控制策略来减少损失。

因此，若选择预测未来一周的市场动态，基于波动率的预测更可靠，也更适用于设计防御性或对冲型策略。

¶具体如何预测下周的波动率走势

预测下周的波动率走势通常基于历史数据的统计模型、市场事件和情绪分析，以下是具体的步骤和方法：

¶1. 数据准备

收集历史数据：获取标的资产的价格数据（如日收盘价、最高价、最低价）以及市场波动率数据（如VIX指数、隐含波动率）。频率可以按日、每小时或更高频率，取决于模型的需求。
计算历史波动率：使用数据计算历史波动率，通常有多种方法，如日收益率的标准差、移动窗口下的年化波动率等。

¶2. 选择并构建模型

¶2.1. GARCH模型系列

GARCH（广义自回归条件异方差）模型用于捕捉波动率的波动性和自相关性，是金融市场常用的波动率预测模型之一。常见的GARCH模型包括：

GARCH(1,1)：假设波动率依赖于前一日的波动率和残差平方，可以捕捉波动率的聚集效应。
EGARCH（指数GARCH）：相比标准GARCH模型，EGARCH允许波动率为非对称性，也就是说，当市场出现极端负面变化时，波动率上升更快。
GJR-GARCH：进一步增加了对市场下跌或上涨时波动率不同反应的处理。

步骤：

将历史波动率数据或价格收益率序列输入模型，以拟合参数。
使用模型输出未来一周每日波动率的预测值。
根据模型的拟合效果，分析未来一周波动率是否会呈现上升或下降趋势。

¶2.2. 隐含波动率模型

隐含波动率反映了市场对未来波动的预期。可以使用期权市场的隐含波动率（如VIX或个股的隐含波动率）来预测未来波动率。

期权数据分析：提取期权价格，计算不同到期时间和行权价格的隐含波动率，并根据不同期限的隐含波动率结构（IV Term Structure）推测短期波动率的变化。
分析隐含波动率曲面（Volatility Surface）：观察隐含波动率的高低变化，通常波动率曲面形状的变化预示着市场波动的预期。

¶2.3. 基于事件的波动率预测

分析下周的市场事件：例如财报、经济数据发布、重要政策会议等事件会直接影响波动率。可以通过事件日历对波动率做出判断，比如美联储决议日，市场通常预期波动率上升。
历史相似事件的波动率模式：对过去类似事件的市场反应进行分析。比如，若观察到每次非农就业数据发布日波动率显著上升，则本次非农数据发布日也可能出现类似情况。

¶3. 市场情绪与技术指标分析

波动率指数（如VIX）：通常情况下，VIX较高表明市场对未来波动的预期上升；较低则代表市场相对乐观。
技术指标：
- ATR（平均真实波幅）：利用ATR指标衡量当前市场波动范围，结合趋势判断未来波动趋势。
- 布林带：当价格靠近布林带上轨时，可能会出现回调，而接近下轨时，波动率可能增加。

¶4. 整合预测结果

多模型综合分析：可以将GARCH模型输出的波动率预测和隐含波动率预测结合，判断它们的预测结果是否一致，增强预测可靠性。
事件风险修正：如果下周有重要的市场事件，将其对波动率的潜在影响加入预测，调整最终波动率预测值。

¶5. 风险管理和模型验证

验证模型有效性：基于历史数据回测模型，评估其预测精度和可靠性。
设定风险控制：在制定交易策略时，基于预测的波动率区间设置止损、止盈和对冲措施，以应对模型失误或突发市场变化。

¶示例：预测的简单案例

假设上周VIX指数上升，且下周美联储有重要会议，历史数据显示美联储会议后波动率通常会有所上升。可以利用GARCH模型预测波动率上升的具体程度，同时结合隐含波动率观察市场的预期，并得出下周波动率可能上升的结论。

¶用python写一个预测SPX下周波动率的代码

要用Python预测S&P 500（SPX）的下周波动率，我们可以使用历史波动率数据和GARCH模型。以下是一个示例代码，通过获取SPX的历史数据，使用arch包来构建和训练GARCH模型，并预测下周的波动率。

首先确保安装所需的Python库：

1	pip install yfinance arch

¶步骤：

获取历史数据：使用yfinance获取SPX的日收盘价数据。
计算收益率：将收盘价转换为对数收益率。
构建和训练GARCH模型：利用arch库的GARCH模型进行拟合。
预测下周的波动率：生成未来5天的波动率预测。

¶代码

import yfinance as yf
import numpy as np
import pandas as pd
from arch import arch_model
import matplotlib.pyplot as plt

# 1. 获取历史数据
# 使用yfinance下载S&P 500的历史数据
data = yf.download('^GSPC', start='2018-01-01', end='2023-10-01')
data = data['Adj Close']

# 2. 计算对数收益率
returns = np.log(data / data.shift(1)).dropna()

# 3. 构建GARCH模型
# 使用对数收益率的序列来拟合GARCH模型
model = arch_model(returns, vol='Garch', p=1, q=1)
model_fit = model.fit(disp='off')
print(model_fit.summary())

# 4. 预测未来5天的波动率（假设是未来一周的波动率）
forecast_horizon = 5
volatility_forecast = model_fit.forecast(horizon=forecast_horizon)

# 提取预测的波动率均值（年化）
predicted_volatility = volatility_forecast.variance.values[-1, :]
predicted_volatility_annualized = np.sqrt(predicted_volatility * 252)

# 5. 输出下周的波动率预测
print("未来5天（1周）每日预测波动率（年化）：")
for i, vol in enumerate(predicted_volatility_annualized):
    print(f"第{i+1}天：{vol:.2%}")

# 6. 可视化
plt.figure(figsize=(10, 5))
plt.plot(data.index, returns, label='Daily Returns', color='blue')
plt.plot(data.index[-forecast_horizon:], np.sqrt(predicted_volatility) * np.sqrt(252), label='Predicted Volatility', color='red')
plt.title('S&P 500 Returns and Predicted Volatility (Annualized)')
plt.legend()
plt.show()

¶代码说明

数据获取：yfinance提供了SPX（标普500）的历史数据。我们使用Adj Close来计算日收益率。
GARCH模型：GARCH(1,1)模型通常用于捕捉金融时间序列的条件波动性。该模型适合短期预测，因为它能够捕捉波动性聚集的特征。
波动率预测：model_fit.forecast提供了未来5天的波动率预测。我们把每日预测的波动率年化，方便解读。
可视化：将收益率和预测波动率绘制在图中，便于观察预测的波动率走势。

¶结果

代码输出未来一周的每日波动率预测（年化形式），以及波动率变化趋势的图表。

2024-08-05

202408

xargs 多个命令

cd /data/temp && find . -type f -mmin +1 | xargs -I {} sh -c 'rsync -avP {} bak-data-server:/home/bakdata/ && rm -f {}'

https://www.youtube.com/watch?v=JgKbe5tcgZ0

新特性解读 | MySQL 8.0 增强逻辑备份恢复工具介绍
https://zhuanlan.zhihu.com/p/267294729

MySQL Shell UTIL 对象附带的备份工具：

随 MySQL 8.0.21 最新版本捆绑发布，自带多线程备份以及多线程恢复功能，可以直接替代 mysqldump/mysqlpump。
dump_instance/dumpInstance 用来多线程备份 MySQL 整个单机实例
dump_schemas/dumpSchemas 用来多线程备份 MySQL 单个数据库
load_dump/loadDump 用来多线程恢复之前两个工具导出的数据集文件

MySQL Shell 使用指南
https://www.jianshu.com/p/954a011c36f7

安装 mysql-shell，不要用 snap 安装

snap list
sudo snap remove mysql-shell
wget https://dev.mysql.com/get/mysql-apt-config_0.8.32-1_all.deb
sudo dpkg -i mysql-apt-config_0.8.32-1_all.deb
sudo apt-get update
sudo apt-get install mysql-shell

MySQL 核心模块揭秘 | 28 期 | 什么时候释放锁？
https://mp.weixin.qq.com/s/egrrGrjpgX5tMw_xtWY9fw

select、update、delete 语句执行过程中，不管 where 条件是否命中索引，也不管是等值查询还是范围查询，只要扫描过的记录，都会加行锁。
和 update、delete 不一样，select 只在需要加锁时，才会按照上面的逻辑加锁。
可重复读（REPEATABLE-READ）、可串行化（SERIALIZABLE）两种隔离级别，
- 只要加了锁，不管是表锁还是行锁，都要等到事务提交或者回滚即将完成时才释放（手动加的表锁除外）。
读未提交（READ-UNCOMMITTED）、读已提交（READ-COMMITTED）两种隔离级别，
- 如果发现记录不匹配 where 条件，会及时释放行锁。

PG 查看表大小
SELECT pg_size_pretty(pg_total_relation_size(‘public.xxx’)),
pg_size_pretty(pg_relation_size(‘public.xxx’)),
pg_size_pretty(pg_indexes_size(‘public.xxx’));

+----------------+----------------+----------------+
| pg_size_pretty | pg_size_pretty | pg_size_pretty |
+----------------+----------------+----------------+
| 2827 GB        | 1188 GB        | 133 GB         |
+----------------+----------------+----------------+

去掉重音

>>> import unidecode
>>> unidecode.unidecode('Ольга Павлова')
"Ol'ga Pavlova"
>>> unidecode.unidecode('Эмиль Проказов')
"Emil' Prokazov"

一文掌握逻辑门器件选型要点，国产替代哪家强？
https://zhuanlan.zhihu.com/p/658295483

74系列逻辑门系列的特点

（1）74：早期产品，目前仍在使用，逐渐被淘汰；
（2）74H：74的改进型，属于高速TTL产品，其与非门传输时间达到10ns左右，但是电路静态功耗较大，逐渐被淘汰；
（3）74S：TTL的高速型肖特基系列，采用抗饱和肖特基二极管，速度较高但是品种较少，非主流；
（4）74LS：LS是低功耗肖特基，速度比HC系列的略快，属于TTL类的主要产品系列，工作于5V电压，品种和参加非常多，性价比高，在中小规模电路中应用普遍，LS输入开路为高电平，LS 输入端没有上拉或下拉要求，输出端体现下拉强上拉弱。
（5）74HC：HC是高速CMOS标准逻辑电路系列，具有与74LS-系列同等工作度和CMOS固有的低功耗和宽电源电压范围（2V~6V），HC的输入电阻很高，开路状态下电平不定，因此输入端要求有上下拉电阻来确定空置时的电平，电阻取值范围1K~10KΩ；
（6）74HCT：输入输出与LS系列兼容，但是功耗低；
（7）74AS：是74S的后继产品，速度进一步提升到1.5ns，因此也成为“先进超高速肖特基”系列；
（8）74ALS：“先进的低功耗肖特基”系列，属于74LS系列的后继产品，工作频率可达50MHz，典型速度4ns，典型功耗1mW，但是价格较高；
（9）其他：74F采用高速肖特基电路，74AC是带缓冲功能的逻辑门。

https://www.bilibili.com/video/BV12e411L7QB/?spm_id_from=333.788&vd_source=fefee58242775b49fd927c748741105d

并发导入 8000 个文件到数据库的调度策略，多进程调度方案：
1、起多个进程，每个进程处理一个文件列表，命令行参数传入 start_file_id 和 end_file_id
2、处理某个文件时用 {file_id}.progress 保存该文件处理进度
3、进程读取每读取 100 行 bulk insert 一次，成功后将行号写入进度文件
4、如果进程停止后重启，根据当前处理文件的 file_id 读取进度，continue 掉已处理的行
5、处理完一个文件后，将 {file_id}.progress 重命名为 {file_id}.done
6、进程处理某个文件时，如果存在对应 {file_id}.done 文件则跳过该文件
7、全程无锁无共享，可随时重启，随时从头跑，不重不漏

查看进度

for f in  progress/*.progress;do echo $f,`cat $f`; done;
ls -l progress/*.done | wc -l

加索引报错, tmp 所在磁盘满

mysql> alter table x add index ix_id(id);
ERROR 1030 (HY000): Got error 100 - 'InnoDB error' from storage engine

基于MySQL和Otter实现生产环境安全的数据同步及查询
https://baijiahao.baidu.com/s?id=1789028486868642783&wfr=spider&for=pc

3、异地机房同步（是Otter最大的亮点之一，可以解决国际化问题把数据从国内同步到国外提供用户使用，在国内场景可以做到数据多机房容灾)
4、双向同步（双向同步是在数据同步中最难搞的一种场景，Otter可以很好的应对这种场景，Otter有避免回环算法和数据一致性算法两种特性，保证双A机房模式下，数据保证最终一致性）
- 1）避免回环算法 (通用的解决方案，支持大部分关系型数据库)
- 2）数据一致性算法 (保证双A机房模式下，数据保证最终一致性，亮点)

ADHD Test

how often do you have trouble wrapping up the final details of a project, once the challenging parts have been done?
how often do you have difficulty getting things in order when you have to do a task that requires organization?
how often do you have problems remembering appointments or obligations?
when you have a task that requires a lot of thought, how often do you avoid or delay getting started?
how often do you fidget or squirm with your hands or feet when you have to sit down for a long time?
how often do you feel overly active and compelled to do things, like you were drven by a motor?
how often do you make careless mistakes when you have to work on a boring or difficult project?
how often do you have diffiulty keeping your attention when you are doing boring or repetitive work?
how often do you have diffiulty keeping your attention when you are doing boring or repetitive work?
how often do you have difficulty concentrating on what people say to you, event when they are speaking to you directly?
how often do you misplace or have difficulty fiding things at home or at work?
how often are you distracted by activity or noise around you?
how often dou you leave your seat in meetings or other situations in which you are expected to remain seated?
how often do you feel restless or fidgety?
how often do you have difficulty unwinding and relaxing when you have time to yourself?
how often do you find yourself talking too much when you are in social situations?
when you’re in a conversation, how often do you find yourself finishing the sentences of the people you are talking to,before they can finish tehm themselves?
how often do you have difficulty waiting your turn in situations when turn taking is required?
how often do you interrupt others when they are busy?

Deep Tech, Explained
From AI to quantum computing and bioengineering, deep tech is being used to solve tomorrow’s problems today.
https://builtin.com/artificial-intelligence/deep-tech

Deep tech, or deep technology, describes the work of companies developing innovations that surpass technological benchmarks and push the boundaries of current technology.

While deep tech companies are often involved in fields like artificial intelligence, biotechnology and quantum computing, the category also includes companies operating in agriculture, aerospace, green energy, mobility and more. Some have become household names, like Moderna, Tesla and Impossible Foods.

【Rethinking IT】如何结合 Unifi 和 MikroTik 设备打造家庭网络
https://sspai.com/post/81572

https://github.com/rcoh/angle-grinder
Angle-grinder allows you to parse, aggregate, sum, average, min/max, percentile, and sort your data. You can see it, live-updating, in your terminal. Angle grinder is designed for when, for whatever reason, you don’t have your data in graphite/honeycomb/kibana/sumologic/splunk/etc. but still want to be able to do sophisticated analytics.

数据库 name 列去重

# 把需要去重的列排序后导出导磁盘
mysql> select name INTO OUTFILE '/data/mysqltmp/name.csv' from t order by name;

# 用 uniq -c 命令过滤出出现过一次的 name，因为已经排序，所以不需要 sort 命令
$ pv name.csv | uniq -c| awk '$1==2{print $2,$1}' > duplicate_name.txt
29.1GiB 0:01:40 [ 297MiB/s] [==============================================================================================>] 100%

The first 20 hours – how to learn anything | Josh Kaufman | TEDxCSU
https://www.youtube.com/watch?v=5MgBikgcWnY

agrind

 tail -f /var/log/nginx/access.log | agrind '* | parse "* * * * * * \"*,*\" * * \"* * *\"" as time,status,request_time,_,_,_,ip,_,_,_,method,url,http_version|count,p90(request_time) by url'

    PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
 609028 ubuntu    20   0 5102012   1.8g   4620 S 100.0  11.6  28:43.72 agrind

Data compression in Mysql
https://medium.com/datadenys/data-compression-in-mysql-6a0668af8f08

Is Black Myth Wukong Worth Buying
https://www.youtube.com/watch?v=yFF8FWBKSzI

使用Zstandard(zstd)压缩优化备份脚本，实现低负载备份网站数据
https://www.yunloc.com/2438.html

滴滴落地ZSTD压缩算法的实践分享
https://t.it168.com/article_6816820.html

ZSTD（Zstandard）底层基于FSE编码实现，具有出色的压缩和解压速度。ZSTD算法的实现经过了高度优化，通过SIMD等指令集能够充分利用硬件并行性，同时编码过程大量依赖位移运算来完成状态的切换，以此提高处理速度。ZSTD采用字典压缩算法，通过引用字典中的匹配项，能够大大减少重复数据的存储空间，提高压缩比。与此同时，ZSTD采用多级压缩策略，在不同的压缩级别中应用不同的压缩算法，能够在不同的应用场景中灵活地平衡速度和压缩比。

https://python-zstandard.readthedocs.io/en/latest/concepts.html

Counting & Timing
https://code.flickr.net/2008/10/27/counting-timing/

https://docs.vivgrid.com/quick-start

一文学会 OpenAI 的函数调用功能 Function Calling
https://zhuanlan.zhihu.com/p/641239259

https://cookbook.openai.com/examples/how_to_call_functions_with_chat_models

一个人，13年，70个创业项目，独立开发的超级传奇
https://mp.weixin.qq.com/s/T1MGR6yTh_3Z9nU3U9G-Yw

https://cookbook.openai.com/examples/structured_outputs_intro

question = "how can I solve 8x + 7 = -23"

{
   "steps": [
      {
         "explanation": "First, we need to isolate the term with x on one side of the equation, so we subtract 7 from both sides.",
         "output": "8x + 7 - 7 = -23 - 7"
      },
      {
         "explanation": "Simplify both sides. The 7 and -7 on the left-hand side cancel each other out, leaving 8x, and -23 - 7 simplifies to -30.",
         "output": "8x = -30"
      },
      {
         "explanation": "To solve for x, divide both sides of the equation by 8, which is the coefficient of x.",
         "output": "8x/8 = -30/8"
      },
      {
         "explanation": "Simplify -30/8 by reducing the fraction. Divide both numerator and denominator by their greatest common divisor, which is 2.",
         "output": "x = -15/4 or x = -3.75"
      }
   ],
   "final_answer": "x = -3.75"
}

古龙：最放浪的人，最贞洁的小说
https://m.thepaper.cn/baijiahao_9272512

https://github.com/rany2/edge-tts

Programmable Music
http://overtone.github.io/
音乐制作小 Tips：善用 DAW 软件和 MIDI 信号
https://www.sohu.com/a/682533469_121124710

https://b23.tv/MxZntYv

举世流行的作谱应用
https://musescore.org/zh-hans

MuseScore is an open source and free music notation software.
https://github.com/musescore/MuseScore

https://learn.microsoft.com/en-us/azure/ai-services/speech-service/rest-text-to-speech?tabs=streaming
ogg-16khz-16bit-mono-opus
ogg-24khz-16bit-mono-opus
ogg-48khz-16bit-mono-opus

音频编解码器 - Opus
https://www.jianshu.com/p/be8d40b61171
支持的特性包括：

比特率从 6kb/s 到 510 kb/s
采样率从 8kHz（窄带）到 48kHz（全频段）
帧大小从 2.5ms 到 60ms
支持恒定比特率（CBR）和可变比特率（VBR）
从窄带到全频带的音频带宽
支持语音和音乐
支持单声道和立体声
支持多达255个通道（多流帧）
动态可调比特率，音频带宽和帧大小
良好的稳健性和隐蔽性
浮点和定点实现

从 Flask 切到 FastAPI 后，起飞了！
https://blog.csdn.net/m0_59596937/article/details/136383593

Nuxt.js是一个非常强大的框架，但是并不是所有类型的网页都必须使用SSR技术。由于使用SSR需要服务端渲染每一个请求，对服务器资源要求高，尤其是高并发访问的情况，会大量占用服务端CPU资源。我们需要根据业务需求来决定使用什么技术栈去开发页面。

1.SSR
如果项目首屏是动态数据的，对首屏速度要求高且很在乎在搜索引擎的排名，可以考虑使用SSR。

2.SSG
如果项目首屏数据与用户不是强关联的、内容相对稳定的且需要SEO的可以考虑使用预渲染 SSG（Static Site Generation），Nuxt也可以做SSG，避免服务端的渲染压力。

3.CSR
如果网站只是内部产品不需要SEO，或者项目较小不太在意首屏性能的，或者项目是富交互和动态内容的应用，那么还是直接用Vue是最明智的选择。可以通过优化项目体积及其他优化方法如：骨架屏或者添加loading图等方式来优化用户体验。

原文链接：https://blog.csdn.net/m0_55119483/article/details/131491881

binlog 过期天数

mysql> show variables like '%expire%';
+--------------------------------+---------+
| Variable_name                  | Value   |
+--------------------------------+---------+
| binlog_expire_logs_auto_purge  | ON      |
| binlog_expire_logs_seconds     | 2592000 |
| disconnect_on_expired_password | ON      |
| expire_logs_days               | 0       |
+--------------------------------+---------+
4 rows in set (0.01 sec)

mysql> select 2592000/60/60/24;
+------------------+
| 2592000/60/60/24 |
+------------------+
|  30.000000000000 |
+------------------+
1 row in set (0.00 sec)

set global binlog_expire_logs_seconds=4*24*60*60;
show binary logs;
purge binary logs to 'mysql80-bin.000164';
purge binary logs before '2021-22-20 22:00:00';

将Vue项目迁移到Nuxt
https://zhuanlan.zhihu.com/p/664801054

既然加法是基于群论的，为什么小学不先学群论？ - ReversedT的回答 - 知乎
https://www.zhihu.com/question/639591755/answer/3366904561

https://cn.vuejs.org/guide/reusability/composables#what-is-a-composable

说说响应式和函数式
https://blog.csdn.net/jjclove/article/details/124388096

dump mysql to parquet then query by duckdb

# install duckdb and csv2parquet
wget https://github.com/duckdb/duckdb/releases/download/v1.1.0/duckdb_cli-linux-amd64.zip && unzip duckdb*.zip
cargo install csv2parquet
# dump data from mysql to parquet
mysql -h mysql-server -u readonly -p db -Bne 'select * from t limit 1000000;' | pv -p --timer --rate --bytes |csv2parquet -d '       ' /dev/stdin test.parquet
# query pqrquet by duckdb
duckdb -s 'select count(*) from "test.parquet"'

curl <FILE_URL> | csv2parquet /dev/stdin /dev/stdout | aws s3 cp - <S3_DESTINATION>
csv2parquet --header false test.csv  test.parquet

[Python] Incrementally using ParquetWriter keeps data in memory (eventually running out of RAM for large datasets)
https://github.com/apache/arrow/issues/26073

This post is for you. It’s for everybody who plans to write some kind of HTTP service in Go. You may also find this useful if you’re learning Go, as lots of the examples follow good practices. Experienced gophers might also pick up some nice patterns.
https://grafana.com/blog/2024/02/09/how-i-write-http-services-in-go-after-13-years/

Instructors’ Guide to Raft
https://thesquareplanet.com/blog/instructors-guide-to-raft/

Students’ Guide to Raft
https://thesquareplanet.com/blog/students-guide-to-raft/

MySQL 输出到文件

pager cat >/tmp/test.txt 
nopager

埃隆·马斯克认为每个孩子都应该了解的50种认知偏见
https://36kr.com/p/1745363984445063

https://github.com/slimtoolkit/slim
Don’t change anything in your container image and minify it by up to 30x (and for compiled languages even more) making it secure too! (free and open source)

Python环境管理大比拼：pip、Conda、Pyenv、Rye、Virtualenv、PDM、Poetry等工具
https://new.qq.com/rain/a/20240303A055WM00

uv-速度飞快的pip替代
https://zhuanlan.zhihu.com/p/689976933

在Linux系统中，恢复已删除的.log文件的难度取决于多个因素，包括文件系统类型、文件删除后是否被覆盖等。以下是一些可能的恢复方法：

使用extundelete：
如果你使用的是ext3或ext4文件系统，可以尝试使用extundelete工具。
- 首先，卸载该分区（如果可以的话），然后运行：
  1
  extundelete /dev/sdX --restore-file /path/to/your/file.log
- 这将尝试恢复该文件并将其保存到当前目录。
使用photorec：
photorec是一个更通用的恢复工具，可以尝试恢复各种类型的文件。
- 安装testdisk，它包含了photorec：
  1
  sudo apt install testdisk
- 然后运行photorec并按照提示选择分区和文件类型进行恢复。
检查备份：
如果你有定期备份，可以从备份中恢复该文件。
查看日志轮转：
如果系统使用了日志轮转（如logrotate），可能会在某个位置保存旧的日志文件。可以检查/var/log目录下是否有相关的备份文件。

请注意，文件删除后，新的数据写入可能会覆盖原有的数据，降低恢复的成功率。因此，尽快采取恢复措施会更有效。

VScode CPU 占用过高 | search.follow false & exclude nodemodules
https://www.cnblogs.com/dhjy123/p/11906142.html

python bloom filter
from pybloom_live import BloomFilter

# 创建布隆过滤器，设置最大元素数量和误判率
bloom = BloomFilter(capacity=1000, error_rate=0.1)

# 添加元素
bloom.add("apple")
bloom.add("banana")

# 检查元素
print("apple" in bloom)   # 输出: True
print("banana" in bloom)  # 输出: True
print("cherry" in bloom)  # 输出: False（可能为假阳性）

按行号分隔

split --additional-suffix=.csv -d --numeric-suffixes=0 --suffix-length=3 -l 200000 abc.csv abc_

sed 打印第 n-m 行并显示原始行号
sed -n ‘4388879,4388883{=;p}’ a.txt

_csv.Error: line contains NUL 错误

sed -i 's/\x0//g' scileads-phone-numbers-with-source.all.filtered.csv

binlog 提取某个表的操作

mysqlbinlog --database=your_database --tables=your_database.your_table /path/to/binlog.000001 > /path/to/output.sql

sqlmodel: Python 数据库管理ORM 的终极形态？
https://www.cnblogs.com/Detector/p/17458890.html

2024-07-24

en2024

In a world where the internet has become an integral part of our daily lives, there’s a remarkable opportunity to immerse ourselves in foreign languages without ever leaving the comfort of our screens.

we can seamlessly integrate language learning into our web browsing activities. In this article, we’ll explore the top Chrome extensions that can help you learn a new language while you surf the web.

Improve your skills on your own, effectively and enjoyably, by watching films and series in the language you study.

Language Reactor is a powerful toolbox for learning languages. It helps you to discover, understand, and learn from native materials. Studying will become more effective, interesting, and enjoyable! (formerly called ‘Language Learning with Netflix’)

我不是建议大家都去做投资，但从赚钱的可持续性角度来分析，我们应当把「出卖时间」思维方式，转变为「积累资产」的思维方式。

所以，工作的主线，除了存钱，重要的任务还有：

培养通用的能力：心理韧性、沟通表达、情绪管理、商务关系等基础能力；

还要积极发展“工作以外”赚钱的方式，给自己扩大选项，跳出自己狭小的认知锚点，知道这个世界上有谁，在通过什么方式赚钱，赚到了怎样的钱。

如果还有余力，探索一件事自己喜欢且擅长的事情，并持续赚到钱。比如，如果你擅长做内容，是不是可以在业余时间拍一些视频，靠视频赚钱。

I am not suggesting that we all go into investing,
but analyzing from the perspective of sustainability of earning money,
we should change the ‘selling time’ mindset to an ‘accumulating assets’ mindset.

Therefore, the main line of work, in addition to saving money, the important task is also:

Develop generic skills:

mental toughness,
communication,
emotion management,
business relations,
and other basic skills;

It is also important to actively develop ways to make money “outside of work”,
to expand your options,
to look beyond your narrow cognitive anchors,
and to know who in the world is making money, how,
and what kind of money they are making.

If there’s still room,
discover one thing you love and are good at and earn money consistently.
For example, if you’re good at making content,
isn’t it possible to make some videos in your spare time
and rely on them to make money?

Here are some unfamiliar words.
I can’t express this in English without a translation tool.

I’ve found that for new English words,
remembering how it’s pronounced and trying to pronounce it
will make it easier to remember than just remembering its spelling.

Soon I will have multiple databases to periodically backup.
Is there any tool that you can recommend which I can selfhost
and will have a nice UI for scheduling DB backups?
I can of course create scripts for backups,
but it would be great to have a nice tool with a panel that lists all the backups.

LinkedIn, the social platform used by professionals to connect with others in their field,
hunt for jobs, and develop skills,
is taking the wraps off its latest effort to build artificial intelligence tools for users.

Hiring Assistant is a new product designed to take on a wide array of recruitment tasks,
from ingesting scrappy notes and thoughts to turn into longer job descriptions to sourcing candidates and engaging with them.

While the getting started pages provide an introductory tour of the project and what it offers, this document focuses on why we do the things we do in Bootstrap.

It explains our philosophy to building on the web so that others can learn from us, contribute with us, and help us improve.

Modifier classes should only be used when there are multiple properties or values to be changed across multiple variants.

Modifiers are not always necessary, so be sure you’re actually saving lines of code and preventing unnecessary overrides when creating them.

Good examples of modifiers are our theme color classes and size variants.

The same goes for more complex components.

While we could write our own form validation plugin to add classes to a parent element based on an input’s state,
thereby allowing us to style the text say red,

we prefer using the :valid/:invalid pseudo-elements every browser provides us.

Utility classes—formerly helpers in Bootstrap 3—are a powerful ally in combating CSS bloat and poor page performance.

A utility class is typically a single, immutable property-value pairing expressed as a class (e.g., .d-block represents display: block;).

Their primary appeal is speed of use while writing HTML and limiting the amount of custom CSS you have to write.

While not always possible, we strive to avoid being overly dogmatic in our HTML requirements for components.

Thus, we focus on single classes in our CSS selectors and try to avoid immediate children selectors (>).

This gives you more flexibility in your implementation and helps keep our CSS simpler and less specific.

Bootstrap 5 is increasingly making use of custom properties as local variables for various components.

This way we reduce our compiled CSS, ensure styles aren’t inherited in places like nested tables, and allow some basic restyling and extending of Bootstrap components after Sass compilation.

https://readmake.com/

Idea

Get an idea from problems in your own life.
If you don’t have problems that are original enough, become a more original person.
Don’t build products that are solutions in search of a problem.

Build

Build your idea with the tools you already know.
Don’t spend a year learning some language you’ll never use.
Don’t outsource building to other people, that’s a competitive disadvantage.
Build only the core functionality,The rest comes later.

Launch

Launch early and multiple times.
Launch to
- famous startups websites (like Product Hunt, Hacker News, The Next Web),
- mainstream websites (like Reddit)
- and mainstream press (like Forbes).
Find where your specific audience hangs out on the internet and launch there.
Launch in a friendly way, that means “here’s something I made that might be useful for you”,
- instead of acting like you’re some big giant new startup coming to change the world.

Grow

A great product that people really need which is better than the rest will pull people in.
You don’t need ads for that.
Don’t hire people if there’s no revenue yet.
Don’t hire many people if there’s revenue either.
Stay lean and fast.
Do things yourself.

Monetize

Monetize by asking users for money.
Don’t sell their data.
Don’t put ads everywhere.
Don’t dilute your product.
Be honest that you need money to build the product they love and they’ll be fine paying for it.

Ethics

be ethical, and don’t cut corners on ethics.
You’ll be rewarded by not doing dodgy stuff like
- spamming,
- manipulating your users into doing stuff,
- growth hacking your search rankings
- or faking your social media,
- or abusing your power to compete unfairly if you’re successful.
If you make a good product, you don’t need any of this.
If you make mistakes, own up to them and say sorry.
Be nice as a person and especially as a company.

$65k/month website running on one index.php file (twitter.com/levelsio)
https://news.ycombinator.com/item?id=24548391

just because something can be done doesn’t mean it should be done
Simplicity is the ultimate sophistication

Software engineers are now experiencing what mechanical engineers experienced in the 1970s and 1980s when FEA and CAD applications began to automate much of the calculation and drafting work that previously defined the profession.

Writing code by hand will be an educational exercise and something that is done in the earliest stages of prototyping and for fine tuning nearly finished designs much like how manual drafting and hand calculations are used in mechanical engineering today.

Obviously, mechanical engineering is still a profession but calculator and draftsman aren’t. People who are exclusively programming will go the way of the draftsman.

https://www.percona.com/blog/mysql-backup-and-recovery-best-practices/

The app aims to address perceived limitations in existing note-taking applications by implementing the core principles outlined in the creator’s book.

Audiala is a mobile application that generates audio guides for historical and touristic locations worldwide.
Conceived during a solo trip to Florence in 2023,
the project aims to transform travel experiences by providing location-based audio storytelling.
The platform currently generates over $500/month through in-app purchases
and focuses on creating immersive, context-aware narratives about landmarks and destinations

The application leverages a Retrieval-Augmented Generation (RAG) pipeline, primarily utilizing content from Wikipedia and other relevant websites. The creator acknowledges that identifying relevant places is the most challenging aspect of the pipeline, currently addressing this through manual user requests. Approximately 99% of the content is AI-generated, with manual corrections applied when necessary.

The project appears to rely on advertising as its primary revenue stream. The creator acknowledges potential user resistance to ads but views them as the most sustainable monetization approach. Interestingly, some users reported challenges detecting advertisements, with discussions around ad-blocking effectiveness highlighting the nuanced approach to generating revenue.

2024-06-14

202406

Python One Billion Row Challenge — From 10 Minutes to 4 Seconds
https://archive.is/a644q

Processing One Billion Rows in PHP!
https://dev.to/realflowcontrol/processing-one-billion-rows-in-php-3eg0

mysql 中如下 json 字段

{
   "status": "OK",
   "results": [
      {
         "types": [
            "locality",
            "political"
         ],
         "place_id": "ChIJpdtYF6azhkcRmu5nCgU7BtM",
         "formatted_address": "20874 Busnago, Province of Monza and Brianza, Italy",
         "address_components": [
            {
               "types": [
                  "locality",
                  "political"
               ],
               "long_name": "Busnago",
               "short_name": "Busnago"
            },
            {
               "types": [
                  "administrative_area_level_3",
                  "political"
               ],
               "long_name": "Busnago",
               "short_name": "Busnago"
            },
            {
               "types": [
                  "administrative_area_level_2",
                  "political"
               ],
               "long_name": "Province of Monza and Brianza",
               "short_name": "MB"
            },
            {
               "types": [
                  "administrative_area_level_1",
                  "political"
               ],
               "long_name": "Lombardy",
               "short_name": "Lombardy"
            },
            {
               "types": [
                  "country",
                  "political"
               ],
               "long_name": "Italy",
               "short_name": "IT"
            },
            {
               "types": [
                  "postal_code"
               ],
               "long_name": "20874",
               "short_name": "20874"
            }
         ]
      }
   ]
}

要取 types 里包含 administrative_area_level_3 的上级节点的 long_name 值

select 
    country_code,
    location,response->>'$.results[0].formatted_address' formatted_address,
    json_unquote(
        json_extract(
            response,
            concat(
                '$.results[0]',
                REGEXP_REPLACE(
                    JSON_SEARCH(
                        response->>'$.results[0]',
                        'one', 
                        'administrative_area_level_1'
                    ),
                    '"|\\$|\\.types\\[[0-9]]',''
                ),
                '.long_name')
        )
    ) administrative_area_level_1 
from t limit 10;

先用 JSON_SEARCH 得到 administrative_area_level_1 的路径，类似 $.address_components[3].types[0]
用 REGEXP_REPLACE 替换掉前面的 $ 和最后的 .types[0]
用 concat 拼接所需的 json path，类似 $.results[0].address_components[2].long_name
用 json_extract 取出所需要的值
用 json_unquote 去掉结果两侧的引号

乱码替换

>>> re.sub(r'x(\w\d)x(\w\d)',lambda x: bytes.fromhex(x.group(1)+x.group(2)).decode('utf-8'),'Logrosxc3xa1n')
'Logrosán'
>>> re.sub(r'x(\w\d)x(\w\d)',lambda x: bytes.fromhex(x.group(1)+x.group(2)).decode('utf-8'),'Trxc3xa9mentines')
'Trémentines'
>>> re.sub(r'x(\w\d)x(\w\d)',lambda x: bytes.fromhex(x.group(1)+x.group(2)).decode('utf-8'),'Trxc3xa9lazxc3xa9')
'Trélazé'
>>> re.sub(r'x(\w\d)x(\w\d)',lambda x: bytes.fromhex(x.group(1)+x.group(2)).decode('utf-8'),'Jxc3xa4msxc3xa4nkoski')
'Jämsänkoski'
>>> re.sub(r'x(\w\d)x(\w\d)',lambda x: bytes.fromhex(x.group(1)+x.group(2)).decode('utf-8'),'Sxc3xb8llerxc3xb8d')
'Søllerød'
>>> re.sub(r'x([0-9a-fA-F]{1,2})x([0-9a-fA-F]{1,2})',lambda x: bytes.fromhex(x.group(1)+x.group(2)).decode('utf-8'),'Sxc3xb8llerxc3xb8d')

‘Søllerød’

手搓一个最小的 Agent 系统 — Tiny Agent
https://zhuanlan.zhihu.com/p/699732624

MetaGPT: 本质类似于公司的组织架构，横向同一层级的工作模式，可能是COT、TOT、GOT，纵向深度有不同的层级，如role、action、action node等
React: 就像是个不是特别聪明的孩子，要把想法写出来，然后去综合所有想法和观察，接着再做出相应的动作。
Reflexion: 一种“语言”强化的新范式，它将策略参数化为代理的记忆编码，并配对参数选择LLM。
Toolformer: 一种学习以新颖方式使用工具的模型，它通过自监督的方式学习如何使用不同的工具，如搜索引擎、计算器和翻译系统。
Swiftsage: 用一个小模型直接输出决策，当小模型不行时改用大模型通过复杂planning输出决策。
Creator: 通过工具创造实现了大模型抽象与具象思维能力的解耦，面对有难度的问题能够保持更好的鲁棒性。

OpenAI 不可用？使用开源模型一键替换 OpenAI API
https://mp.weixin.qq.com/s?__biz=MzI2MjkxNjA2Mg==&mid=2247487114&idx=1&sn=0c443a88bafa49daec18f8a16d0c6284

docker run --rm -p 8080:8080 --name api-server secondstate/llama-3-8b-nomic-1.5:latest

curl -X POST http://localhost:8080/v1/chat/completions \
    -H 'accept:application/json' \
    -H 'Content-Type: application/json' \
    -d '{"messages":[{"role":"system", "content": "You are a helpful assistant."}, {"role":"user", "content": "What is the capital of France?"}], "model": "Meta-Llama-3-8B-Instruct-Q5_K_M.gguf"}'

curl -X POST http://localhost:8080/v1/embeddings \
    -H 'accept:application/json' \
    -H 'Content-Type: application/json' \
    -d '{"model": "nomic-embed-text-v1.5.f16", "input":["LlamaEdge is the easiest & fastest way to run customized and fine-tuned LLMs locally or on the edge."]}'

https://www.secondstate.io/articles/wasm-runtime-agi/

长时间以来，来自开源生态的朋友们一致支持着Qwen的发展，包括

微调（Axolotl、Llama-Factory、Firefly、Swift、XTuner）、
量化（AutoGPTQ、AutoAWQ、Neural Compressor）、
部署（vLLM、SGL、SkyPilot、TensorRT-LLM、OpenVino、TGI）、
本地运行（MLX、Llama.cpp、Ollama、LM Studio）、
Agent及RAG（检索增强生成）框架（LlamaIndex, CrewAI, OpenDevin）、
评测（LMSys, OpenCompass, Open LLM Leaderboard）、
模型二次开发（Dolphin, Openbuddy）。

https://zhuanlan.zhihu.com/p/703883561

https://llamaedge.com/

Q: Why can’t I use Python to run the LLM inference?
A: You can certainly use Python to run LLMs and even start an API server using Python. But keep mind that PyTorch has over 5GB of complex dependencies. These dependencies often conflict with Python toolchains such as LangChain. It is often a nightmare to set up Python dependencies across dev and deployment machines, especially with GPUs and containers.

In contrast, the entire LlamaEdge runtime is less than 30MB. It is has no external dependencies. Just install LlamaEdge and copy over your compiled application file!

Q: Why can’t I just use native (C/C++ compiled) inference engines?
A: The biggest issue with native compiled apps is that they are not portable. You must rebuild and retest for each computer you deploy the application. It is a very tedious and error prone progress. LlamaEdge programs are written in Rust (soon JS) and compiled to Wasm. The Wasm app runs as fast as native apps, and is entirely portable.

wasm 使用案例
https://wasmedge.org/docs/zh/start/usage/use-cases/

阿里千问
https://qwen.readthedocs.io/en/latest/framework/LlamaIndex.html

本地安装，测试，部署很方便，支持多种方式，满足不同需求
量化，fine tune(有监督训练), embedding(RAG)都支持本地实现
function call，Agent, LangChain相关功能需要使用阿里的dashscope服务

跨设备运行小小阿里云通义千问大模型 Qwen1.5-0.5B-Chat
https://zhuanlan.zhihu.com/p/684034037

mac如何安装git-lfs，以及modelscope的使用示例
https://zhuanlan.zhihu.com/p/692680970

ModelScope+transformers调用llama模型
https://zhuanlan.zhihu.com/p/698481268

https://zhuanlan.zhihu.com/p/681690385

https://wasmedge.org/docs/develop/rust/wasinn/llm_inference/

-m, --model-alias <ALIAS>
      Model alias [default: default]
-c, --ctx-size <CTX_SIZE>
      Size of the prompt context [default: 4096]
-n, --n-predict <N_PRDICT>
      Number of tokens to predict [default: 1024]
-g, --n-gpu-layers <N_GPU_LAYERS>
      Number of layers to run on the GPU [default: 100]
-b, --batch-size <BATCH_SIZE>
      Batch size for prompt processing [default: 4096]

苹果AppleMacOs系统Sonoma本地部署无内容审查(NSFW)大语言量化模型Causallm
https://zhuanlan.zhihu.com/p/686099177
https://hf-mirror.com/tastypear/CausalLM-7B-DPO-alpha-GGUF

LLaMA-Factory QuickStart
https://zhuanlan.zhihu.com/p/695287607

使用 Python库DEAP的多目标优化示例
https://blog.csdn.net/gongdiwudu/article/details/138033230

Pygmo multi-objective optimization with constraints
https://stackoverflow.com/questions/77411477/pygmo-multi-objective-optimization-with-constraints

命令行听歌

for %%i in (D:\mp3\*.mp3) do D:\haohu\soft\ffmpeg\bin\ffplay "%%i" -autoexit

基于STM32+VS1053B的MP3设计
https://zhuanlan.zhihu.com/p/690699207

这里我们使用的是stm32F103VET6，内部Flash有512K，100pin的外部引脚，属于大容量芯片，足够我们diy。对于本设计，stm32这一块用到的知识点有：SDIO驱动SD卡，SPI驱动VS1053B芯片，IIC驱动OLED；对于程序，用的是stm32标准库

功能范围：

CPU 专注于通用计算任务。
SoC 集成了多个功能模块，满足复杂的计算和通信需求。
MCU 专注于特定的嵌入式应用，如控制系统、传感器等。

应用领域：

CPU 广泛用于个人电脑、服务器等通用计算设备。
SoC 常见于智能手机、平板电脑等便携设备。
MCU 主要应用于嵌入式系统，如家电、汽车电子等。

集成程度：

CPU 通常作为计算机系统的核心，但需要其他芯片的支持。
SoC 在一个芯片上集成了多个功能模块。
MCU 是一种完整的嵌入式系统，集成了所有必要的组件。

https://blog.csdn.net/github_35631540/article/details/139122039

ESP8266
- 应用场景：主要用于 WiFi 联网项目，如智能家居设备、IoT 传感器和无线控制。
- 优势：低成本、内置 Wi-Fi 功能、低功耗模式，易于接入互联网。
- 代表产品：NodeMCU 开发板、ESP-01模块。
51单片机
- 应用场景：广泛应用于教育和基础电子学习、简单的控制系统如家电控制、工业仪器等。
- 优势：成本极低、指令简单、资源占用小，适合初学者和低成本项目。
- 代表产品：Intel 的 MCS-51 系列。
ESP32
- 应用场景：IoT设备，智能家居，低功耗传感器网络，音频应用等。
- 优势：比 ESP8266 更强大的 CPU，支持蓝牙和 Wi-Fi，更多的 I/O 端口，更佳的安全性能。
- 代表产品：ESP32 开发板。
Arduino
- 应用场景：广泛用于教育、原型开发、艺术作品、简单的机器人。
- 优势：易于学习的编程环境，丰富的社区和库支持，适合快速原型开发。
- 代表产品：Arduino Uno, Arduino Mega。
STM32系列
- 应用场景：汽车应用、工业控制、医疗设备、高性能嵌入式应用。
- 优势：基于 ARM Cortex-M 核心，性能强大，低功耗，丰富的外设，支持多种开发环境。
- 代表产品：STM32F103 系列、STM32F4 系列。
Raspberry Pi
- 应用场景：作为学习计算机编程的工具、家庭媒体中心、高级DIY项目如自制服务器或游戏机。
- 优势：具备完整的计算机功能，支持多种操作系统，拥有丰富的I/O接口和社区支持。
- 代表产品：Raspberry Pi 4 Model B。

[嵌入式系统-72]：ARM芯片选型基础
https://blog.csdn.net/HiWangWenBing/article/details/138421375

经典 ARM 处理器 ARMx
- ARM7 系列：这是 ARM 处理器家族中较早的一代产品，采用 32 位 RISC 架构。
  - 广泛应用于嵌入式系统、移动设备等领域。
- ARM9系列处理器是在ARM7基础上发展而来的，性能有明显提升。
  - 无线设备、仪器仪表、安全系统、机顶盒、高端打印机、数字照相机
- ARM11 系列处理器是 ARM9 的升级
嵌入式 Cortex-Mx系列：微控制器
- 低成本、低功耗、高性能
- 物联网（IoT）、工业自动化、智能家居和汽车电子等
- 智能灯光控制、智能门锁、智能家电等设备中，实现远程控制和自动化管理。
嵌入式 Cortex-R 系列：实时处理器
- 实时处理器，专为需要高可靠性、高可用性、容错功能、可维护性和实时响应的嵌入式系统而设计。
- 广泛应用于车载控制系统中，如发动机控制、车身控制、底盘控制等。在工业控制领域。
高性能应用 Corex-A 系列：应用处理器
- 高性能应用处理器，专为需要强大计算能力和高性能指令集的应用而设计
- 广泛应用于智能手机、平板电脑、笔记本电脑等移动设备以及网络设备、存储设备等领域。

《龙之家族》血龙狂舞战争，黑党与绿党各有哪些势力？
https://zhuanlan.zhihu.com/p/569141727

ck 中按字符串列平均分成 10份

select count(*) from tbl
where CRC32(name)>= 0*((pow(2, 32) - 1) / 10)
and  CRC32(name) < 1*((pow(2, 32) - 1) / 10);
┌──count()─┐
│ 65588724 │ -- 65.59 million
└──────────┘
select count(*) from tbl
where CRC32(name)>= 1*((pow(2, 32) - 1) / 10)
and  CRC32(name) < 2*((pow(2, 32) - 1) / 10);
┌──count()─┐
│ 65424285 │ -- 65.42 million
└──────────┘

函数平移和伸缩变换的知识汇总
https://mp.weixin.qq.com/s?__biz=MzU0Mjg4ODc2OQ==&mid=2247488669&idx=1&sn=d7eafbfe91f41ed555e81e92ed9643d8

LLM101n: Let’s build a Storyteller
https://github.com/karpathy/LLM101n

thought through though

【tcp】关于tcp状态的Recv-Q 和 Send-Q
https://www.jianshu.com/p/4676ea4d03e1

TCP 半连接队列和全连接队列满了会发生什么？又该如何应对？
https://www.cnblogs.com/xiaolincoding/p/12995358.html

几种防御 SYN 攻击的方法：

增大半连接队列；
- 增大 tcp_max_syn_backlog 和 somaxconn
- 增大 backlog
开启 tcp_syncookies 功能
减少 SYN+ACK 重传次数

开启 syncookies 功能就可以在不使用 SYN 半连接队列的情况下成功建立连接，在前面我们源码分析也可以看到这点，当开启了 syncookies 功能就不会丢弃连接。

syncookies 是这么做的：服务器根据当前状态计算出一个值，放在己方发出的 SYN+ACK 报文中发出，当客户端返回 ACK 报文时，取出该值验证，如果合法，就认为连接建立成功

https://www.languagereactor.com/ 这个学英语插件不错，可以每一句反复听，会自动断句。

所谓「不可能三角」，是指一款No Code工具无法同时兼顾「灵活」、「易用」与「效率」。

比如，如果工具：

支持各种场景（灵活），同时能显著提高网页产出效率，那他的配置一定很复杂（需要应对各种场景，不易用）
支持各种场景（灵活），同时很好用，那他的开发效率就不会高（无法无脑生成页面，需要修改产物代码）
配置简单（易用），同时开发效率高，那他的应用场景就窄（不灵活）
framer选择了第三条道路，即牺牲灵活性，保持易用与效率。

具体来说，framer的应用场景局限在生成落地页、产品介绍页、官网这样的静态页。
https://framer.com/

C++11新特性
https://blog.csdn.net/qq_56044032/article/details/125230984

perl 菜鸟教程
https://www.runoob.com/perl/perl-tutorial.html
Perl 基本语法
https://www.cnblogs.com/cosiray/archive/2012/03/18/2404371.html
Modern Perl, 4e
http://modernperlbooks.com/books/modern_perl_2016/index.html

Google on Monday said the search company is reversing its plan to phase out the use of third-party cookies in its Chrome browser in favor of a new strategy that will allow people to “make an informed choice that applies across their web browsing.”

https://en.wikipedia.org/wiki/Denavit–Hartenberg_parameters

坐标系与矩阵(5): Denavit-Hartenberg算法
https://cloud.tencent.com/developer/article/1849681

在动力学中，比如人的胳膊就有好几个关节，且不同的关节有不同的旋转轴，如果是路飞的话，关节之间的长度还是不固定的。这里，每一个关节都存在一个自身坐标系，其中旋转可以是绕三个轴，平移则是沿着三个轴，每个坐标系存在6个自由度。问题就有点复杂了，每个人对每个关节可能会定义不同的坐标系方向，这会直接决定求解该问题的难度。DH算法则提供了一个一般性理论，且每一个关节只需要4个自由度。

https://cloud.tencent.com/developer/article/1969850
栅格化的对象是网格，网格表面可以通过三角形无限细分，而三角形是最简单的平面。接下来就是栅格化核心内容：如何绘制一个三角形。

栅格化的流水线主要有两个阶段：顶点（vertex）和片元（fragment），前者将三维空间下三角形的每一个点投射到二维平面上，后者则将投影后的三角形填充颜色，最终完成一个三角形的渲染。当多个三角形存在遮盖问题时，则通过深度检测（Z-buffer机制）来判断几何对象间的远近。

Whitted-Style Ray Tracing算法（1979）采用射线模拟相机到光源间的光路传输，并考虑了射线和光源之间的遮盖，射线和物体间的反射，以及和半透明物体间的折射等光学现象。该算法模拟了光线传播中的基本物理规律，比如Fresnel， Beer law，折射率以及传输过程中的衰减等，非常健壮的实现了阴影、折射、反射效果。

通过栅格化和光线追踪的发展来看，人们对真实感的定义随着时间而变化，最初希望有基本的阴影、折射、反射效果，随着技术和硬件能力的提升，人们的标准也不断的提高，正应了那句歌词，得不到的永远在骚动。这也反映了Moore‘s Law和Blinn’s Law之间的相互制约：当计算能力不断提升时，人们也会提高渲染真实感的标准，从而保证渲染时间不变。

在概念上，无论栅格化还是光线追踪，真实感的标准主有三点：照片级别（photo realistic）和物理正确（physically based rendering）以及性能（high performance），只是两者给出了不同的优先级。光线追踪优先前两点，往往需要极大的计算量，因此在离线渲染领域成为主角。而Rasterization技术主要应用于实时渲染领域，为了性能而有条件地牺牲前两点。

https://github.com/rqlite/rqlite

rqlite is a relational database which combines SQLite’s simplicity with the power of a robust, fault-tolerant, distributed system.

You can use rqlite to store your important data reliably, ensuring it’s always available. If you’re interested in understanding how distributed systems actually work, it’s a good example to study. A lot of thought has gone into its design, separating storage, consensus, and API clearly.

The fastest, most reliable, Redis-based distributed queue for Node.
Carefully written for rock solid stability and atomicity.
https://github.com/taskforcesh/bullmq

du -sh 排除挂载点，清理 /tmp

# 创建目录排除文件，排除掉非系统盘挂载点，NFS 挂载点 和 /proc
mount |awk '$1~/^\/dev/&&$3!="/" || $5~/nfs/ {print $3}' >> ~/.du_exclude
echo /proc >> ~/.du_exclude

# 查看文件大小分布
ncdu -X ~/.du_exclude /
du -sh -X ~/.du_exclude /*

# 清理 10 天未改动的临时文件
find /tmp -ctime +10 | xargs rm -rf

¶curl 证书报错

¶1. 检查服务器的证书链

¶2. 忽略 SSL 证书验证

¶3. 指定自定义 CA 文件

¶4. 添加自签名证书到系统信任存储

¶5. 更新 curl 和系统根证书

¶6. 环境变量

¶ES 集群中节点内存不一致的问题

¶1. 优化 JVM 内存分配

¶2. 调整索引和负载分配策略

¶（1）限制分片分配到内存较小的节点

¶（2）调整分片大小

¶3. 使用协调节点

¶4. 增加虚拟内存

¶5. 优化查询和索引操作

¶（1）批量索引

¶（2）调整刷新间隔

¶6. 监控和调整

¶7. 增加硬件资源

¶让被 OOM killer 杀掉的服务自动重启

¶1. 修改 systemd 服务配置

¶步骤 1: 创建覆盖文件

¶步骤 2: 添加自动重启配置

¶步骤 3: 保存并退出

¶2. 重新加载 systemd 配置

¶3. 验证配置

¶4. 查看日志

¶ES 进程被 OOM 杀掉

¶PHP 7/8 新特性

¶PHP 7.0 (2015)

¶PHP 7.1 (2016)

¶PHP 7.2 (2017)

¶PHP 7.3 (2018)

¶PHP 7.4 (2019)

¶PHP 8.0

¶PHP 8.1

¶PHP 8.2

¶PHP 8.3

¶links

¶《MySQL 101》教程提纲

¶第1章：简介

¶第2章：安装与设置

¶第3章：基础操作

¶第4章：高级查询

¶第5章：索引与性能优化

¶第6章：事务与锁

¶第7章：存储引擎

¶第8章：用户与权限管理

¶第9章：备份与恢复

¶第10章：高可用与集群

¶附录

¶使用 redis 布隆过滤器对 csv 去重并插入 mysql

¶mysql 高可用方案对比

¶1. 普通主从 (Master-Slave)

¶2. MHA (MySQL High Availability)

¶3. MGR (MySQL Group Replication)

¶4. MM (双主模式 Master-Master)

¶综合对比表

¶总结建议

¶es 设置副本分片

¶ES 部分查询

¶步骤 1: 启用 partial 查询结果

¶具体操作：

¶全局设置（可选）：

¶步骤 2: 检查分片分布

¶查看分片分布：

¶步骤 3: 调整查询逻辑

¶局限性和注意事项

¶总结

¶1. 总体架构设计

¶服务划分

¶2. 技术选型

¶基础设施

¶中间件

¶安全

¶3. 详细设计

¶登录请求处理流程

¶高可用和高性能实现

¶水平伸缩

¶高可用

¶5. 更新 `curl` 和系统根证书

¶步骤 1: 启用 `partial` 查询结果

¶1. 排序是否有助于加速 `join`

¶2. Spark `join` 的实现类型

¶(1) `./bin/spark-submit`

¶(2) `--master local[4]`

¶(3) `SimpleApp.py`

¶1. `union` 的内存使用分析

¶2. `orderBy` 的内存使用分析

¶1. 使用 `sortWithinPartitions`

¶2. 使用 `RDD` 并通过文件排序优化

¶`combineByKey` 的机制

¶1. `createCombiner`

¶2. `mergeValue`

¶3. `mergeCombiners`

¶1. `repartitionByRange` 的工作原理