GB-BRi5H-8250 准系统

其他配件

• 内存：SEIWHALE 枭鲸笔记本内存条 DDR4 16G
• 硬盘：Samsung 850 EVO M.2 SATA 250G
• 无线网卡：DW1820A (08PKF4)

总体成果

OpenCore配置文件我放到github了 https://github.com/ruanimal/GB-BRi5H-8250-hackintosh

正常工作项目

• CPU，变频
• 显卡，硬件加速
• HDMI输出，MiniDP输出，HDMI音频，双屏
• 蓝牙
• WiFi
• Handoff, Airdrop
• iMessage, iCloud, Photos, Mac App Store
• USB
• 音频接口，mic
• 苹果电源管理
• 睡眠，关机，唤醒

不正常工作项目

• 系统偏好设置-节能（错误识别为有电池）
  
• HDMI睡眠唤醒，有时屏幕黑屏，需要按一下屏幕开关；DP睡眠正常 (添加启动参数igfxonln=1应该可以解决)
• 显示器喇叭开机时不正常，拔插接口后或者开关屏幕电源后正常。(添加启动参数igfxonln=1应该可以解决)

安装教程

安装过程大部分参考dortania，这里采用的是双系统安装方法。

先安装Windows10, 然后在Windows10下配置OpenCore，制作macOS安装镜像。

准备工作

预先下载的工具软件

• 微PE工具箱V2.1：Windows系统安装工具
• Windows10镜像
• Hackintool: 黑苹果多功能工具
• Python: ProperTree等软件的依赖
• DiskGenius: 磁盘分区
• bootice: uefi引导编辑
• ProperTree: 编辑OpenCore配置
• GenSMBIOS：用于生成苹果设备序列号信息
• OpenCorePkg: OpenCore引导文件，注意下载release版本
• gibMacOS: 下载，制作macOS安装镜像
• speccy: 查看电脑硬件信息

其他

• 能正常访问Google的网络
• 另外一台电脑，用于查资料（可选）
• U盘1-2个

前置知识

• 技术术语了解

Windows安装和分区

1. 制作Windows安装U盘
2. 开机安装Delete键进入bios，选择从U盘启动
3. 安装Windows系统，具体安装过程可以参考这个教程，注意安装时不要Windows分区不要占用所有空间，建议50G就好了。
4. 安装完成后，新建一个分区，后续作为macOS的安装分区，建议预留100G以上

macOS安装U盘制作

macOS准备

具体步骤参考这个，gibMacOS已被官方教程废弃
1. 使用gibMacOS的gibMacOS.bat，下载最新macOS
2. 使用gibMacOS的MakeInstall.bat，制作安装U盘

OpenCore文件准备

1. 将下载的OpenCorePkg解压，复制EFI文件夹到U盘
2. 删除EFI文件夹中多余的文件，只保留以下内容
   
3. 添加必要的.efi驱动到U盘EFI/OC/Drivers文件夹，不同的机型需要的有所区别
   • HfsPlus.efi: 用于读写苹果HFS分区

Kexts驱动准备

添加必要的Kexts驱动到U盘EFI/OC/Kexts文件夹，不同的机型需要的有所区别

• VirtualSMC：将电脑伪装成苹果设备
• SMCProcessor.kext: VirtualSMC附带驱动，用于监控cpu状态
• SMCSuperIO：VirtualSMC附带驱动，用于监控风扇状态
• Lilu: 用于加载音频等驱动
• WhateverGreen：显卡驱动
• AppleALC: 声卡驱动
• IntelMausi: 有线网卡驱动

SSDT准备

添加必要的Kexts驱动到U盘EFI/OC/ACPI文件夹，不同的机型需要的有所区别

从opencore的文档可以看出，我们至少需要以下几个SSDT

• SSDT-PLUG：电源管理相关，影响睡眠
• SSDT-EC-USBX：内置控制器，和USB相关，影响睡眠
• SSDT-PMC：NVRAM相关
• SSDT-AWAC：系统时钟（通过查看DSDT，我们并不需要这个）

为了更完美，我们还需要以下SSDT，这些可以等macOS安装完之后，根据情况再考虑是否制作

• SSDT-SBUS-MCHC：SMBus相关
• SSDT-RHUB：USB相关
• SSDT-HPET：IRQ Conflicts相关

具体SSDT的制作过程比较繁琐，详细过程参考文档

OpenCore配置文件准备

1. 复制OpenCorePKG的Docs/Sample.plist到U盘EFI/OC/config.plist
2. 打开ProperTree的ProperTree.bat脚本，打开前面的config.plist，选择OC Clean Snapshot, 根据我们的驱动文件自动修改配置，保存。
   
3. 配置文件各项微调，参考文档，注意DeviceProperties，PlatformInfo配置项，影响比较大。
4. 配置准确性校验 https://opencore.slowgeek.com/

注意：配置文件中kext的顺序是有影响的，建议前两个是lilu和virtualsmc

Bios设置

如果bios没有相关设置项，可以跳过

禁用项

• Fast Boot
• Secure Boot
• VT-d (can be enabled if you set DisableIoMapper to YES)
• CSM
• Thunderbolt(For initial install, as Thunderbolt can cause issues if not setup correctly)
• Intel SGX
• Intel Platform Trust
• CFG Lock

启用项

• VT-x
• Above 4G decoding
• Hyper-Threading
• Execute Disable Bit
• EHCI/XHCI Hand-off
• OS type: Windows 8.1/10 UEFI Mode
• DVMT Pre-Allocated(iGPU Memory): 64MB
• SATA Mode: AHCI

macOS安装

注意：这时我们先不要替换无线网卡为DW1820A，可能会导致系统安装失败或者卡死。

1. 重启电脑，从macOS安装U盘启动
2. 从OpenCore启动菜单选择macOS安装启动项
3. 等待macOS系统加载完成，选择我们预留的分区，格式为APFS, 安装系统
4. 等待多次重启之后，macOS系统初步安装完成

驱动安装及优化

显卡驱动优化

如果只使用免驱的独立显卡，可以跳过这一步
前面配置macOS安装U盘时，其实已经对显卡做了简单驱动，如果一切功能正常，也可以跳过这一步。

显卡驱动不正常会影响双屏显示，睡眠假死，睡眠变重启，HDMI音频输出等

内置显卡的驱动，注意做的是以下几个点

• 选择合适的缓冲帧AAPL,ig-platform-id，必要时仿冒设备iddevice-id
• 定制正确的显示输出接口，将物理接口和PCI设备正确对应
• 显存，HDMI相关补丁

这一步使用hackintool的应用补丁功能可以完成，详细步骤参考这个

注意：hackintool在配置过程中，有时改动会被重置，应用补丁时注意二次确认

声卡驱动

声卡驱动大部分工作由AppleALC自动完成，我们需要的是选择正确的layout-id.
建议先去github的release日志上查看，是否在某次release添加了你主板的layout-id。如果没有相关记录，那就只能尝试wiki中对应声卡型号的所有可能的layout-id

详细步骤参考这个

USB定制

USB定制直接影响睡眠是否正常

使用hackintool完成USB定制，主要过程

1. SSDT-EC-USBX定制（前面已经完成）
2. 加载USBInjectAll.kext驱动，重启，注入所有接口。
3. 分别使用USB2.0，USB3.0，Type-C设备拔插所有USB接口，找到物理接口和PCI设备的映射关系，并删除没有用到的USB接口。
4. 生成USBPorts.kext驱动，加载。

详细步骤参考这个

DW1820A无线网卡

无线网卡驱动和系统序列号影响iMessage, sidecar等Apple服务使用。

1. 找到无线的PCI设备地址
   
2. 在config.plist中DeviceProperties->Add配置项下加入设备信息, 注意替换PCI设备地址

   <key>PciRoot(0x0)/Pci(0x1C,0x5)/Pci(0x0,0x0)</key> <dict> <key>AAPL,slot-name</key> <string>WLAN</string> <key>compatible</key> <string>pci14e4,43a3</string> <key>device_type</key> <string>Airport Extreme</string> <key>model</key> <string>DW1820A (BCM4350) 802.11ac Wireless</string> <key>name</key> <string>Airport</string> <key>pci-aspm-default</key> <integer>0</integer> </dict>

3. 加入Airport驱动AirportBrcmFixup.kext, 加入蓝牙驱动
4. 在config.plist的boot-args项中加入brcmfx-country=#a
5. 关机替换网卡为DW1820A（有的机器可能需要屏蔽针脚）

详细步骤参考这个和这个

电源管理

这一步是为了启动苹果内置电源管理，影响睡眠

详细步骤参考这个

CPU变频

使CPU的变频挡位更多，台式机不是特别必要。

可以使用CPU-S软件来查看变频状态

详细步骤参考这个

睡眠修复

如果上面的SSDT和驱动都做好了，睡眠的问题基本不大了，可能要设置下系统参数，禁止休眠到硬盘。

详细步骤参考这个

启动项，图形化界面

到此黑苹果配置基本完成了，我们可以去除boot-args中的-v等debug启动参数，添加相关声音和图片资源，配置config.plist启动OpenCore图形界面。（在开机中启用声音，个人觉得不太不要）

详细步骤参考这个

将OpenCore迁移到硬盘

上面的OpenCore的各种配置都是在U盘上完成的，当配置完成没啥问题之后，我们就可以把OpenCore的文件迁移到硬盘了。
这样就不需要每次都从U盘启动了，并且开启会默认进入macOS

1. 在pe系统下，使用DiskGenius挂载硬盘ESP分区（右键ESP分区-指派新的驱动器号）
   
2. 复制U盘的EFI文件夹到ESP分区根目录，和原有的文件夹合并
3. 使用bootice，添加硬盘ESP分区的\EFI\BOOT\BOOTx64.efi文件到启动条目，并上移到第一位
   
   

其他注意事项

• 每个SSDT基本都可以用手动修改和自动修改，如果某种方法不生效建议尝试另外一种。
• 如果不是配置完全一样，不要直接使用别人的EFI文件
• FakePCIID相关驱动会改动PCI设备信息，可能导致USB设备地址变化，导致USB定制失效，需要重新定制
• 不同的SMBios机型会影响驱动成功率
• 修改序列号会影响iCloud账户识别

感谢

• https://dortania.github.io
• https://github.com/acidanthera
• https://blog.daliansky.net
• https://blog.skk.moe/post/hackintosh-fix-magenta-screen/

概述

Getting Things Done（GTD），是一种时间管理的方法，确切地说是事项管理的方法，通过GTD可以将所有事项管理起来，提高效率的同事，降低心智损耗，减少个人焦虑

笔记

焦虑是由于缺乏控制力，组织管理，以及缺少准备和行动不足造成的。

目的：

1. 收集所有一切需要处理的事，把它们统一置入一个脱离大脑的逻辑系统中
2. 训练自己在接受任何“输入”的前期就作出分析和计划，以确保在任何时候，都拥有一套可以立即执行的计划

价值观促使我们首先在清单上积累了大量任务

静水对石子的反应：依物体的质量和力度作出相应的反应，既不过激也不会置之不理

阮云：物来顺应

学会对那些承诺的事情加以控制

收集所有那些“经常唤醒你模糊记忆”的事情，然后着手计划如何一一解决掉

在大脑中不留任何事情

自下而上的工作方法

“横向”管理涉及的所有行动

通常你大脑中盘踞问题的数量与其解决效率成反比

横向管理：收集（工作篮） - 加工 - 组织管理 - 检视（至少每周一次） - 执行

确定某一时刻行动的“四标准法”

1. 情景
2. 有多少时间
3. 有多少精力
4. 重要性

总体检视工作的“六极四顾法”

• 五万英尺+：人生
• 四万英尺：3-5年的展望
• 三万英尺：1-2年的目标
• 二万英尺：责任范围
• 一万英尺：当前的项目
• 跑道：目前的行动

git是一个分散式版本控制软件，最初由林纳斯·托瓦兹（Linus Torvalds）創作，於2005年以GPL釋出。最初目的是为更好地管理Linux内核开发而设计。
初始版本由Linus大神在两个星期内写出来，之后基本一统文件版本控制的天下。

名词解释

工作区：就是你在电脑里能看到的目录。
暂存区：英文叫stage, 或index。一般存放在”git目录”下的index文件（.git/index）中，所以我们把暂存区有时也叫作索引（index）。
版本库：工作区有一个隐藏目录.git，这个不算工作区，而是Git的版本库。
branch：分支，相当于不同的平行世界
remote：远程仓库
origin：默认的远程仓库名词
HEAD：一个指向当前版本号的指针

环境配置

git config --global user.name yourname 设置用户名，如果不加--global则只对当前项目生效
git config --global user.email youremail 设置邮箱
git config --global core.editor vim 设置默认编辑器为vim，可替换为你自己喜欢的
git config --global core.quotepath false 显示中文路径名

开始项目

git init 初始化git仓库
git clone <repository> [<directory>] 复制项目

管理修改

git status 查看当前仓库状态，绿色为未commit的stage内容，红色为未stage、为添加到版本库内容
git show <commit-hash-id|tag_name> 查看某次commit的修改内容
git add filename 保存文件修改到暂存区
git rm filename 删除工作区的文件和git记录
git rm --cached filename 删除暂存区的新文件
git diff 查看工作区和暂存区(stage)的不同
git diff --cached 比较的是暂存区和版本库的差别
git diff HEAD 可以查看工作区和版本库的差别
git diff commit1 commit2 比较不同commit
git diff commit1 commit2 -- filepath 比较不同commit指定文件更改
git commit 提交暂存区内容到当前分支，会新加一个commit
git commit --amend 追加暂存区内容到当前分支的最近一个commit
git rebase -i HEAD~4 合并最近4个commit
git rebase 目标分支名称 把本分支改动放到目标分支之后

分支与Tag

git branch -a 查看所有分支信息
git branch new_branch_name 新建分支
git branch -d branch_name 删除分支
git branch --set-upstream dev origin/dev 指定本地dev分支与远程origin/dev分支的链接
git checkout branch_name 切换到分支头部
git checkout tags/tag_name 切换到某个tag对应的版本
git checkout -b new_branch_name 新建分支，并切换到新分支
git checkout -b dev origin/dev 创建远程origin的dev分支到本地，并切换到新分支
git merge dev 合并dev到当前分支，保留commit信息
git merge --squash dev 合并dev分枝代码到暂存区，不保留commit信息
git tag 查看tag列表
git tag tag_name 打tag
git tag -d tag_name 删除tag
git push --delete origin tagname 删除远程tag

仓库操作

git remote -v 查看远程仓库详细信息
git remote add <name> <url> 添加远程仓库
git remote rename <old> <new> 重命名远程仓库
git remote remove <name> 删除远程仓库
git remote set-url [--push] <name> <newurl> 设置远程仓库链接
git remote prune origin 清除本地无用remote
git pull <远程主机名> <远程分支名>:<本地分支名> 从远程仓库更新
git fetch git@github.com:ruanimal/Mysite.git 从其他仓库获取代码，但不更新到本地分支
git push <远程主机名> <本地分支名>:<远程分支名> 提交到远程仓库
git push origin <本地分支名> 将本地分支推送与之存在“追踪关系”的远程分支(通常两者同名)
git push 如果当前分支只有一个追踪分支，那么主机名都可以省略。
git push -f 强制提交

子模块

git submodule add -b branch {url} [module_name]. 已有仓库，添加子模块
git submodule set-branch --branch master module_name 子模块切换追踪分支到master
git submodule update --remote 更新子模块代码, 分支和代码与.gitmodules中的配置同步
git clone --recursive {url}. clone代码时，拉取子模块代码
git submodule update --init 克隆项目后, 首次拉取子模块代码
git rm {submodule_folder} 删除子模块

怎么吃后悔药

git log 查看commit的历史
git log -p 查看某个文件的修改历史
git log -p -2 查看最近2次的更新内容
git log --graph 命令可以看到分支合并图。
git whatchanged filename 显示文件更改的相关commit
git checkout [commit id] -- file 丢弃工作区文件修改
git restore filename 丢弃工作区文件修改
git reset HEAD filename 可以把暂存区的修改撤销掉（unstage），重新放回工作区
git restore --staged filename 可以把暂存区的修改撤销掉（unstage），重新放回工作区
git reset –mixed 此为默认方式，不带任何参数的git reset，即时这种方式，它回退到某个版本，只保留源码，回退commit和index信息
git reset –soft 回退到某个版本，只回退了commit的信息，不会恢复到index file一级。如果还要提交，直接commit即可
git reset –hard 彻底回退到某个版本，本地的源码也会变为上一个版本的内容，若无版本号则回退到最新的版本。
git reset [commit-id] -- filename 以commit的版本替换stage的文件
git revert [commit-id] 是用一次新的commit来逆向操作之前的commit

其他

git gc 压缩历史信息来节约磁盘和内存空间
git <command> --abort 一般用于中断某次操作
git cherry-pick <commit_id> 捡取某一个commit到当前分支（包含commit变更的内容和注释）
git filter-branch --tree-filter 'rm -f testme.txt' HEAD 从git仓库中永久删除某个文件的历史
git rebase -r <commit_id> --exec 'git commit --amend --no-edit --reset-author' 将HEAD到commit_id为止的commit的提交用户信息重置

• 检查MySQL是否安装 sudo netstat -tap | grep mysql
• 如果没有 sudo apt-get install mysql-server mysql-client
• 设置mysql的root用户的密码

MySQL的python模块

• MySQL-Python

$ wget https://pypi.python.org/packages/source/M/MySQL-python/MySQL-python-1.2.5.zip
$ unzip MySQL-python-1.2.5.zip
$ sudo python setup.py install

• 若提示“EnvironmentError: mysql_config not found”
  $ sudo apt-get install libmysqld-dev

django中的设置

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql', #设置为mysql数据库
        'NAME': 'dmyz',  #mysql数据库名
        'USER': 'root',  #mysql用户名，留空则默认为当前linux用户名
        'PASSWORD': 'root',   #mysql密码(怀疑有安全性问题)
        'HOST': '',  #留空默认为localhost
        'PORT': '',  #留空默认为3306端口
    }
}

另一种方法是使用mysql配置文件，参看

MySQL 数据库操作

• 进入mysql命令行 mysql -uroot -p[密码]
• 新建数据库 create database name
• 使用数据库 use name
• (可选)导入sql备份文件 mysql –uroot –p[密码] -Dtest< .sql

django初始化数据库

• django1.6环境加south

python manage.py syncdb  # 创建表
python manage.py migrate  # 数据迁移可选
python manage.py runserver 

• django1.8+

python manage.py makemigrations appname  # 建立迁移脚本 
python manage.py migrate  # 数据迁移可选
python manage.py runserver 

由于在Python2中字符串有两种类型str和unicode，他们都是basestring的子类。

str类型，即是ascii字符或者经过encode的unicode，一个字符占用1byte。ascii码是美国信息交换标准代码，主要用于显示现代英语和其他西欧语言，用一个字节储存一个字符，所以ascii字符最多只有256(2^8)个。

而unicode包含了256个ascii码之外还包含其他各个国家的文字的编码，所以unicode的一个字符占用2个字节，这样理论上一共最多可以表示2^16（即65536）个字符，远大于256。

utf-8是unicode的一中实现，是unicode的一种编码方式。而且utf-8的编码方式，包含了ascii码的内容，也就是utf-8兼容ascii。

打个比方，unicode是商品，utf-8就是打包好的一个个包裹(encode)，打包是为了传输和储存的方便。而不同的编码之间不能直接互相转换，都需要转成unicode，也就是decode。

所以碰到一个str，你就得明白它是encode过的，你得调用相应的decode方法才不会乱码。

python2解释器的默认编码方式是ascii，如果我们给系统的输入是非ascii编码的字符，系统在尝试解码时就会出现UnicodeDecodeError

>>> s = '2'
>>> u = u'2'
>>> type(s)
<type 'str'>
>>> type(u)
<type 'unicode'>
>>> issubclass(str,basestring)
>>> issubclass(unicode,basestring)
True
>>> '啊'.decode('ascii')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
UnicodeDecodeError: 'ascii' codec can't decode byte 0xe5 in position 0: ordinal not in range(128)
'ascii' codec can't decode byte 0xe5 in position 0: ordinal not in range(128)

几种解决方法

修改系统编码

这种方法较为普遍

import sys
reload(sys)
sys.setdefaultencoding('utf-8')

使用codec模块

常用于文本文件操作

import codecs
with codecs.open('somefile.txt', 'r', 'utf-8') as fp:
    pass

改用Python3

此乃釜底抽薪，一劳永逸的办法。

re是python中的正则表达式处理模块，本文是为了总结re模块的用法。

至于正则表达式的写法可以看正则表达式30分钟入门教程

用法

re.compile

re.complie(pattern, flags=0)
把正则编译为_sre.SRE_Pattern object对象，在多次匹配的时候可提高运行效率。

>>> pattern = re.compile(r'\w(o)')
>>> pattern.match('doooo')
<_sre.SRE_Match object at 0x7f45fc3d9990>
>>> pattern.match('doooo').group(1)
'o'
>>> re.match(r'\w(o)', 'doooo')
<_sre.SRE_Match object at 0x7f45ec0be0a8>
>>> re.match(r'\w(o)', 'doooo').group(1)
'o'

re.search

re.search(pattern, string, flags=0)
寻找整个文本，直到发现一个匹配的位置，返回MatchObject，未找到返回None

re.match

re.match(pattern, string, flags=0)
检查文本的开头是否匹配，返回MatchObject，未找到返回None

re.split

re.split(pattern, string, maxsplit=0, flags=0)
通过正则表达式分割字符，返回list对象。若表达式里使用了组，组匹配到的内容会加到结果中。

>>> re.split(r'g(o)', 'Wo-rds, words, words.')
['Wo-rds, words, words.']
>>> re.split(r'\wo', 'Wo-rds, words, words.')
['', '-rds, ', 'rds, ', 'rds.']
>>> re.split(r'\w(o)', 'Wo-rds, words, words.')
['', 'o', '-rds, ', 'o', 'rds, ', 'o', 'rds.']

re.findall

re.findall(pattern, string, flags=0)
查找所有匹配的对象，返回list。

>>> re.findall(r'g(o)', 'Wo-rds, words, words.')
[]
>>> re.findall(r'w(o)', 'Wo-rds, words, words.')
['o', 'o']
>>> re.findall(r'w(o)(r)', 'Wo-rds, words, words.')
[('o', 'r'), ('o', 'r')]

re.sub

re.sub(pattern, repl, string, count=0, flags=0
替换，返回替换后的字符。
repl参数可以为一个函数，该函数接受MatchObject，返回值为替换的字符串。

>>> re.sub(r'w(o)(r)',r'*', 'Wo-rds, words, words.')
'Wo-rds, *ds, *ds.'
>>> def repl(match):
...     return '***%s***|+++%s+++' % (match.group(1), match.group(2))
>>> re.sub(r'w(o)(r)', repl, 'Wo-rds, words, words.')
'Wo-rds, ***o***|+++r+++ds, ***o***|+++r+++ds.'

匹配可选项 flags

flags是正则表达式匹配的一些选项

• re.DEBUG 输出匹配过程中的调试信息
• re.IGNORECASE 忽略大小写
• re.LOCALE 本地化标志
• re.MULTILINE 多行模式，使^和$匹配每行的行首和行尾
• re.DOTALL 使.匹配换行符
• re.UNICODE 使\w等匹配unicode字符
• re.VERBOSE 使正则表达式使用""""""能够跨多行，并且每行使用#添加注释

re.compile对匹配效率的影响

# -*- coding:utf-8 -*-

import re, time

def aa():
    now = time.time()
    string = 'sfsfdsdffffffffffsxcsdsffffffsdsfsffssadfsaasfffffsdssfssssdsdcvfgbdgssdfvdfsss'
    for i in xrange(5000000):
        re.match(r'f(s)', string)
    seconds = time.time() -now
    return seconds

def bb():
    now = time.time()
    string = 'sfsfdsdffffffffffsxcsdsffffffsdsfsffssadfsaasfffffsdssfssssdsdcvfgbdgssdfvdfsss'
    pp = re.compile(r'f(s)')
    for i in xrange(5000000):
        re.match(pp, string)
    seconds = time.time() -now
    return seconds

def cc():
    now = time.time()
    string = 'sfsfdsdffffffffffsxcsdsffffffsdsfsffssadfsaasfffffsdssfssssdsdcvfgbdgssdfvdfsss'
    pp = re.compile(r'f(s)')
    for i in xrange(5000000):
        pp.match(string)
    seconds = time.time() -now
    return seconds

print u'未使用compile: %s' % aa()
print u'通过re.match调用compile后的对象: %s' % bb()
print u'使用compile: %s' % cc()

输出

未使用compile: 5.53200006485
通过re.match调用compile后的对象: 11.4990000725
使用compile: 1.66799998283

• 可以看出，通过compile过的_sre.SRE_Pattern object对象进行match操作，效率大概比re.mathc高几倍。
• 而bb函数通过re.match调用compile后的对象，花费时间是未使用compile的两倍。
  因为re.match(pattern, string)通过调用re._compile(pattern).match(string)来实现的，这样相当于每次匹配都进行了两次compile。

类变量与实例变量区分

>>> class ClassA(object):  # 1
...     num1 = 1  # 类变量
...     def __init__(self):
...         self.num2 = 2  # 实例变量，或者说属性

>>> a1 = ClassA()
>>> a1.num1
1
>>> ClassA.num1
1
>>> a1.num1 is ClassA.num1  # 2
True

>>> a1.num1 = 3
>>> a1.num1 is ClassA.num1  # 3
False

>>> a1.__class__.num1
1
>>> a1.__class__.num1 = 4  # 4
>>> ClassA.num1
4

>>> a2 = ClassA()
>>> a2.num1
4

1. 这里我们定义了ClassA类，它有一个类变量num1，还有一个实例变量num2。
2. a1是ClassA的一个实例，当我们写下a1.num1的时候，实际上是引用类变量num1，因此a1.num1 is ClassA.num1值为True。
3. 运行a1.num1 = 3的时候，其实给a1绑定了一个属性num1，这是动态语言的特性，此时a1.num1 is ClassA.num1值为False。
   因此我不建议通过实例的名称来引用类变量，这样容易引起混淆，你以为改变了ClassA.num1，其实没有。
   这里就扯到了Python的作用域与命名空间，运行a1.num1的时候，先是在a1自己的命名空间内查找num1，没找到就在所属类的命名空间找，还没有就抛出AttributeError: 'ClassA' object has no attribute 'num3'.
   运行a1.num1 = 3之后，a1自己的命名空间内找到了num1，就不继续往上查找了。
4. 如果此时还想通过a1访问和改变类变量num1，可以通过a1.__class__.num1来访问。

以上这些，也适用于staticmethod和classmethod。

如果ClassA还有父类

>>> class FatherI(object):
...     num1 = 11

>>> class FatherII(object):
...     num1 = 111

>>> class ClassA(FatherI, FatherII):
...     num1 = 1
...     def __init__(self):
...         self.num2 = 2

>>> a1 = ClassA()
>>> a1.__class__
<class 'ClassA'>
>>> a1.__class__.__mro__
(<class 'ClassA'>, <class 'FatherI'>, <class 'FatherII'>, <type 'object'>)
>>> a1.__class__.__mro__[0].num1
1
>>> a1.__class__.__mro__[1].num1
11
>>> a1.__class__.__mro__[2].num1
111

>>> super(ClassA, a1).num1
11
>>> super(ClassA.__mro__[0], a1).num1
11
>>> super(FatherI, a1).num1
111
>>> super(ClassA.__mro__[1], a1).num1
111
>>> super(FatherII, a1).num1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'super' object has no attribute 'num1'
'super' object has no attribute 'num1'

• 如果ClassA还有父类，而且可能还有多个，想访问父类的类变量可以通过__mro__或者super。
• __mro__属性显示了一个类的继承树，也就是记录了所有属性和方法的查找顺序，由于此处是新式类，mro为广度优先。
  由于__mro__是一个元祖，所以我们可以用__mro__[1]这种方式来访问继承树树上每个类的属性和方法。
• 使用super也能达到相同的效果，不过稍有不同.super(ClassA, a1).num1这个语句的意思其实是，在__mro__中访问<class 'ClassA'>后一个类，也就是<class 'FatherI'>的num1，所以此处值是11

taskman
├── db.sqlite3
├── manage.py
├── task
│   ├── __init__.py
│   ├── admin.py
│   ├── models.py
│   ├── urls.py
│   └── views.py
└── man
    ├── __init__.py 
    ├── settings.py 
    ├── urls.py 
    └── wsgi.py 

说明

上面的例子是一个Django项目，Python包的导入都是相对于主程序来说的。

这个项目的主程序就是manage.py，跟manage.py同级的文件夹（含有__init__.py）如task,man就称之为包，若同级有文件就称之为顶级模块。

在这个项目里所有Python包的导入，都应该写完整路径, 或者使用相对当前文件的相对路径。

例如在文件taskman/task/views.py中，想要导入taskman/man/setting.py，就得这样。

## 绝对路径 import
from man.setting import some_setting
# or 
from man import setting

再例如, 在文件taskman/task/views.py中，想要导入taskman/task/urls.py，就得这样。

## 绝对路径 import 
from task.urls import some_setting
# 或者
from task import urls

## 相对路径import
from .urls import some_setting
from . import urls

总结

1. 所有导入都是根据主程序的路径，然后从完整路径导入包，或者相应的相对路径导入。
2. 主程序应该位于包的最顶层，否则发生ValueError: Attempted relative import in non-package

由于使用Hyper-V来实现WSL2，使得WSL更像虚拟机，一个能访问本地硬盘的虚拟机。
这带来一些便利，能够把它当做独立服务器来使用，可玩性就增强很多。当然，这也导致WSL上的端口不能从外部访问到，总之有利有弊。

虽然能够配置端口转发，曲线救国突破这个缺陷，但是有些服务的端口是约定俗成的（比如samba），更换端口号（原端口号被windows占用）之后其他设备可能识别不到服务。

经过一番思考后，觉得给WSL2开启桥接模式，直接连接物理网络才是相对最好的方案。

安装WSL2

参考官方文档安装WSL2

在PowerShell中执行以下命令

1. 启用WSL2

   dism.exe /online /enable-feature /featurename:Microsoft-Windows-Subsystem-Linux /all /norestart

2. 启用虚拟机平台

   dism.exe /online /enable-feature /featurename:VirtualMachinePlatform /all /norestart

3. 启用Hyper-V

   dism.exe /online /enable-feature /featurename:Microsoft-Hyper-V /all /norestart

4. 设置WSL2为默认

   wsl --set-default-version 2

然后重启系统, 安装适用于 x64 计算机的 WSL2 Linux 内核更新包

安装Linux发行版

这里选择Debian作为示例

1. 在Microsoft Store中搜索Debian并安装
2. 启动Debian应用，并根据提示初始化系统
3. 在PowerShell执行wsl -l --all -v确认WSL版本为2

   PS C:\Users\ruan> wsl -l --all -v NAME STATE VERSION * Debian Running 2

4. 如果VERSION不为为2，在PowerShell执行wsl --set-version Debian 2进行升级

修改WSL2默认网络为桥接

由于WSL2底层使用的是Hyper-V虚拟机，所以我们可以修改虚拟交换机的类型，来启用桥接网络
打开Hyper-V管理器 -> 操作 -> 虚拟交换机管理器， 修改WSL的连接类型为“外部网络”

修复Debian网络

由于WSL2默认网络模式是NAT，我们把虚拟交换机改为桥接后，默认的ip和路由以及DNS解析将会失效

以下操作在Debian系统内执行

修复ip和路由

1. 清除原网卡ip ip addr flush dev eth0
2. 添加新ip ip addr add 192.168.123.31/24 dev eth0
3. 清除原默认路由 ip route delete default
4. 添加默认路由 ip route add default via 192.168.123.1 dev eth0

这些操作在重启WSL2虚拟机后会失效，如果需要永久修改，请配置静态ip

修复DNS解析

1. 新建/etc/wsl.conf，防止WSL2覆盖DNS配置文件

   [network] generateResolvConf = false

2. 编辑/etc/resolv.conf， 清除原配置，添加以下内容

   nameserver 192.168.123.1

已知缺陷

重启Windows10后桥接失败

重启后桥接可能会失败，而且上不了网，可以取消勾选外网网口的“Hyper-V可扩展的虚拟交换机”选项，然后重新配置桥接

WSL2的MAC地址不固定

由于WSL2的MAC地址每次重启后都会变化，所以桥接后DHCP的ip也是非固定的，参考issue。

目前没有好的解决办法，一些依赖MAC地址的服务，可能会工作不正常。如samba的域名访问。

参考

1. https://docs.microsoft.com/zh-cn/windows/wsl/install-win10#manual-installation-steps
2. https://github.com/microsoft/WSL/issues/4928#issuecomment-646703350
3. https://github.com/microsoft/WSL/issues/4150#issuecomment-747152240

谷歌百度一键搜索， 在百度页面上搜谷歌，在谷歌的页面上搜索百度，无需切换，无需重新输入搜索词。

详细描述：
虽然谷歌比较好用，结果也准确，但搜索中文这方面却也弱了点，百度还是有点用。谷歌百度一键搜索， 在谷歌的页面上搜索百度，在百度页面上搜谷歌，无需切换，无需重新输入搜索词。
目前支持http(s)://www.baidu.com, http(s)://www.google.com.hk, http(s)://www.google.com

创建：2015.11.25
作者：ponder.work
forked from: raywill/BaiGoogleDu

安装方法

下载crx文件：github
拖入到 chrome://extensions/ 页面，即可完成安装。

更新日志

2015年11月28日　　版本: 1.2.1

• 改进百度首页判断逻辑。

2016年12月12日　　版本: 1.2.2

• 适应新版google首页。

截图

提取文本中的电驴、磁力、迅雷、旋风、快车链接。也可作为一个简易的文本编辑器。
功能采用python和正则表达式实现，界面采用wxPython类库，并通过py2exe打包。

使用说明

1. 粘贴文本到程序窗口，或打开txt文件，或者打开网址。
2. 点击相应的按钮实现相应的功能
3. 复制或者保存结果到文件，默认路径问程序当前目录（否则请使用完整路径）
4. 请保证当前路径为英文

下载链接

http://pan.baidu.com/s/1sjP1KBj

更新日志

• 2015.09.13 V2.4
  增加直接提取网址源码功能

• 2015.09.12 V2.3
  修正不能正确提取部分迅雷链接

声明

这个小工具是本人Python的一个习作，水平有限，如有bug可以在这里留言，或者给我发邮件admin@ponder.work。

最近碰巧了解了 scrcpy, 用于远程控制安卓，终于解决了这个问题。

需要的工具

1. 安卓环境：虚拟环境或者物理设备均可，这里使用虚拟环境。以下是可选的虚拟环境

• PVE 的 PCT容器 (Proxmox Container Toolkit)，需要打补丁
• docker，基于Redroid 需要调整内核参数
• WSA (Windows Subsystem for Android)，与 scrcpy 配合有点问题，窗口有黑边。
• VMware、VirtualBox等虚拟化平台，需要解决虚拟显卡。

2. 使用 scrcpy-mobile 远程控制安卓环境, 当然 scrcpy 也支持 Windows、Linux、macOS

PCT 安卓容器

由于已有PVE环境，这里选用PCT，主要步骤

1. 根据 PCT-patches 文档，给 PCT 打好补丁
2. 根据 lineageOS 模板，新建安卓容器，注意去除Unprivileged container的勾选。
3. 修改 lxc.init.cmd 选项，在后面增加以下参数，调整分辨率和iPad一致。

   androidboot.redroid_width=1668 androidboot.redroid_height=2388 androidboot.redroid_fps=60

ps: 安卓容器对宿主机性能似乎有一定要求，J4125 只是勉强够用，流畅度一般。

macOS 中使用 scrcpy

安装 scrcpy ，连接命令

scrcpy --audio-codec=aac \
  --video-codec=h264 \
  --video-bit-rate=16M \
  --max-fps=60 \
  --tcpip=192.168.10.181:5555 \
  --start-app=io.legado.app.release

参数解释

• --audio-codec=aac 同步声音，使用 AAC 编码，默认参数可能导致没有声音
• --video-codec=h264 使用 H.264 视频压缩编码
• --video-bit-rate=16M 16Mbps 码率，高画质
• --max-fps=60 最大帧率 60FPS，画面流畅
• --tcpip=192.168.10.181:5555 Wi-Fi adb 连接设备
• --start-app=io.legado.app.release （可选）连接后直接启动 Legado App，应用列表可使用adb shell pm list packages -3查看

iOS 中使用 scrcpy-mobile

appstore中安装 scrcpy-mobile

由于该应用的用户界面易用性比较差，表单也不支持有些 scrcpy 参数，这里直接使用快捷指令打开应用。
设置打开 scrcpy-mobile 后，开启引导式访问，防止误触。同时可以在 iOS 设置中开启引导式访问的面容id，防止频繁输入密码。

scrcpy-mobile 的 url schema

scrcpy2://192.168.10.181:5555?enable-audio=true&audio-codec=aac&video-bit-rate=16M&video-codec=h264&max-fps=60

最后，这也未尝不算一种 NTR

安卓环境设置（可选）

1. 关闭导航栏：系统 > 手势 > 系统导航 > 手势导航
2. 加快或者关闭系统动画：开发者选项 > 窗口动画缩放、过渡动画缩放、Animator 时长比例 > 关闭或者0.5x

经过本强迫症的探索，终于找到基于 Karabiner-Elements + Automator + Logseq 的完美生词本方案。
最后的效果是，快捷键取词的同时记录单词卡片到Logseq对应的笔记。

词典词库扩充

参考知乎文章安装好《朗道英汉字典5.0》
这是为了有个释义简洁的词典，方便后续生成生词本词条

编写workflow

使用 macOS 自带应用 Automator（自动操作）编写workflow，将当前鼠标所在位置的文本提取并保存制卡。

首先打开 Automator.app 新建一个 Quick Aciont(快速操作)

然后依次拖入“获得词语定义”，“运行Shell脚本”等步骤，并调整如下几个位置的选项。

修改脚本里的代码为如下内容，生词本路径相应替换，并相应位置新建好生词本文件。

# -*- coding:utf-8 -*-

from __future__ import unicode_literals, print_function
import sys, os, io, subprocess

FILE=os.path.expanduser("~/weiyun_sync/!sync/logseq-note/pages/生词本.md")
output = []
text = sys.argv[1].decode('utf8') if sys.version_info.major == 2 else sys.argv[1]

lines = [i.strip() for i in text.splitlines() if i.strip()]
if len(lines) < 2:
    exit(0)

word = lines[0]
if lines[1][0] == '*':
    output.append('- {}\t{}  [[card]]'.format(word, lines[1]))
    lines = lines[2:]
else:
    output.append('- {}\t  [[card]]'.format(word))
    lines = lines[1:]
output.append('\t- {}'.format(lines[0]))
for line in lines[1:]:
    output.append('\t  ' + line)

old_words = set()
with io.open(FILE, 'r', encoding='utf8') as fp:
    for line in fp:
        parts = line.split()
        if line.startswith('-') and len(parts) > 1:
            old_words.add(parts[1])

if word not in old_words:
    with io.open(FILE, 'a', encoding='utf8') as fp:
        fp.write('\n')
        fp.write('\n'.join(output))
        fp.write('\n')
    subprocess.check_call(['osascript', '-e', u'display notification "添加 {}" with title "生词本"'.format(word)])
else:
    subprocess.check_call(['osascript', '-e', u'display notification "跳过 {}" with title "生词本"'.format(word)])

选择路径保存好 workflow，然后在 键盘 - 快捷键 - 服务 中能看到新建的workflow。
为它设置快捷键 command + shift + alt + 1

Karabiner-Elements

Karabiner-Elements 是 macOS 平台的一个重新映射快捷键的软件。
这里我们使用它将“查询单词”和“触发workflow”整合在一起，当然它还支持很多用途，这里就不赘述了。

注意确保Karabiner相关权限，并且设置中下图相关设备是勾选状态

安装好Karabiner-Elements后，打开它的配置文件
路径在 /Users/<用户名>/.config/karabiner/karabiner.json

在 profiles -> complex_modifications -> rules 列表中增加一项配置，内容如下。
然后保存，Karabiner会自动加载新的配置。

这里是将鼠标的侧键（靠前的）映射为查单词的快捷键，实现一键查词。
也可以根据需要更改按键，通过EventViewer可以查看按键代码，配置文件格式可参考官方文档

{
    "description": "Mouse",
    "manipulators": [
        {
            "from": {
                "pointing_button": "button5"
            },
            "to": [
                {
                    "pointing_button": "button1"
                },
                {
                    "pointing_button": "button1"
                },
                {
                    "key_code": "d",
                    "modifiers": [
                        "left_command",
                        "left_control"
                    ]
                },
                {
                    "key_code": "1",
                    "modifiers": [
                        "left_option",
                        "left_shift",
                        "left_command"
                    ]
                }
            ],
            "type": "basic"
        }
    ]
}

效果

可以看到 Logseq 中卡片生成的效果

参考

• https://karabiner-elements.pqrs.org/docs/
• https://zhuanlan.zhihu.com/p/433646737
• https://hectorguo.com/zh/save-words-in-dictionary/
• https://github.com/jjgod/mac-dictionary-kit
• https://lightcss.com/mac-dictionary/

模式扩展

模式扩展（globbing），类似C语言中的宏展开，我们通常使用的通配符*就是其中之一。

Bash 一共提供八种扩展，前4种为文件扩展，只有文件路径确实存在才会扩展。

• ~ 波浪线扩展
• ? 问号扩展
• * 星号扩展
• [] 方括号扩展
• {} 大括号扩展
• $var 变量扩展
• $(date) 命令扩展
• $((1 + 1)) 算术扩展

波浪线扩展

波浪线~会自动扩展成当前用户的主目录。
~user表示扩展成用户user的主目录。如果用户不存在，则波浪号扩展不起作用。

bash-5.1$ echo ~/projects/
/Users/ruan/projects/

bash-5.1$ echo ~root/.ssh
/var/root/.ssh

bash-5.1$ echo ~aaa/.ssh
~aaa/.ssh

问号扩展

?字符代表文件路径里面的任意单个字符，不包括空字符。
只有文件确实存在的前提下，才会发生扩展。

bash-5.1$ touch {a,b}.txt ab.txt

bash-5.1$ ls ?.txt
a.txt  b.txt

bash-5.1$ ls ??.txt
ab.txt

星号扩展

*字符代表文件路径里面的任意数量的任意字符，包括零个字符。

bash-5.1$ ls *.txt
a.txt  ab.txt  b.txt

bash-5.1$ ls /usr/local/Cellar/*/*/bin/z*
/usr/local/Cellar/ffmpeg/4.4_2/bin/zmqsend
/usr/local/Cellar/mysql-client/8.0.26/bin/zlib_decompress
/usr/local/Cellar/netpbm/10.86.24/bin/zeisstopnm
/usr/local/Cellar/perl/5.34.0/bin/zipdetails
/usr/local/Cellar/zstd/1.5.0/bin/zstd

方括号扩展

方括号扩展的形式是[...]，只有文件确实存在的前提下才会扩展。

[^...]和[!...]。它们表示匹配不在方括号里面的字符

方括号扩展有一个简写形式[start-end]，表示匹配一个连续的范围

bash-5.1$ ls [ab].txt
a.txt  b.txt

bash-5.1$ ls [^b]b.txt
ab.txt

bash-5.1$ ls [a-b].txt
a.txt  b.txt

大括号扩展

大括号扩展{...}表示分别扩展成大括号里面的所有值
大括号也可以与其他模式联用，并且总是先于其他模式进行扩展。

bash-5.1$ echo {1,2,3}
1 2 3

bash-5.1$ echo a{1,2,3}b
a1b a2b a3b

bash-5.1$ echo --exclude={a,b,c}
--exclude=a --exclude=b --exclude=c

bash-5.1$ echo foo{1,2{1,2}0,3}bar
foo1bar foo210bar foo220bar foo3bar

bash-5.1$ echo {1..3}
1 2 3

bash-5.1$ echo {1..10..2}
1 3 5 7 9

变量扩展

Bash 将美元符号$开头的词元视为变量，将其扩展成变量值

bash-5.1$ echo $HOME
/Users/ruan

命令扩展

$(...)可以扩展成另一个命令的运行结果，该命令的所有输出都会作为返回值。

bash-5.1$ echo $(date)
日 11 28 16:22:09 CST 2021

bash-5.1$ echo `date`
日 11 28 16:22:24 CST 2021

算术扩展

$((...))可以扩展成整数运算的结果

bash-5.1$ echo $((1+1))
2

引号使用

单引号

单引号用于保留字符的字面含义，在单引号里转义字符和模式扩展都会失效。

bash-5.1$ ls '[ab].txt'
ls: cannot access '[ab].txt': No such file or directory

bash-5.1$ ls '*'
ls: cannot access '*': No such file or directory

双引号

双引号比单引号宽松，三个特殊字符除外：美元符号（$）、反引号（`）和反斜杠（\）。这三个字符，会被 Bash 自动扩展。

也就是说，相比单引号在双引号中变量扩展，命令扩展，算术扩展以及转义字符是有效的。

bash-5.1$ echo "$((1+1))"
2

bash-5.1$ echo "$HOME"
/Users/ruan

bash-5.1$ echo "$(date)"
日 11 28 16:35:27 CST 2021

bash-5.1$ echo -e "1\t2"
1	2

引号嵌套

# 双引号中使用单引号
bash-5.1$ echo '"'
"
bash-5.1$ echo '"${HOME}"'
"${HOME}"
# 单引号中使用双引号
bash-5.1$ echo "'${HOME}'"
'/Users/ruan'
bash-5.1$ echo "'\"${HOME}\"'"
'"/Users/ruan"'

# 引号嵌套中使用模式扩展，将需要扩展的字符放在单引号中；典型的有json变量填充
bash-5.1$ echo '{"user": "'${USER}'"}'
{"user": "ruan"}

here doc

Here 文档（here document）是一种输入多行字符串的方法，格式如下。
它的格式分成开始标记（<< token）和结束标记（token）, 一般用字符串EOF作为token

<< token
text
token

例如

bash-5.1$ cat << EOF
> 11
> 22
> 33
> EOF
11
22
33

here string

Here 文档还有一个变体，叫做 Here 字符串（Here string），使用三个小于号（<<<）表示。
它的作用是将字符串通过标准输入，传递给命令。

bash-5.1$ cat <<< foobar
foobar
bash-5.1$ echo foobar | cat
foobar

变量

bash 是基于标准输入在不同进程间交互数据的，大部分功能都是在操作字符串，所以变量的默认类型也是字符串。

声明变量和读取变量

声明时等号两边不能有空格。
Bash 变量名区分大小写，HOME和home是两个不同的变量。

bash-5.1$ foo=1
bash-5.1$ echo $foo
1

变量查看和删除

# 查看所有变量, 其中包含父进程export的变量
bash-5.1$ set
UID=501
USER=ruan
bar=2
foo=1

bash-5.1$ unset foo
bash-5.1$ set
UID=501
USER=ruan
bar=2

变量输出

用户创建的变量仅可用于当前 Shell，子 Shell 默认读取不到父 Shell 定义的变量。
如果希望子进程能够读到这个变量，需要使用export命令。

bash-5.1$ bash -c set  | grep foo
bash-5.1$ export foo=1
bash-5.1$ bash -c set  | grep foo
foo=1

环境变量

平时所说的环境变量，就是init进程export输出的。子进程对变量的修改不会影响父进程，也就是说变量不是共享的。

# 查看环境变量
bash-5.1$ env
SHELL=/bin/zsh
LSCOLORS=Gxfxcxdxbxegedabagacad
ITERM_PROFILE=Default

下面是一些常见的环境变量。

• BASHPID：Bash 进程的进程 ID。
• BASHOPTS：当前 Shell 的参数，可以用shopt命令修改。
• DISPLAY：图形环境的显示器名字，通常是:0，表示 X Server 的第一个显示器。
• EDITOR：默认的文本编辑器。
• HOME：用户的主目录。
• HOST：当前主机的名称。
• IFS：词与词之间的分隔符，默认为空格。
• LANG：字符集以及语言编码，比如zh_CN.UTF-8。
• PATH：由冒号分开的目录列表，当输入可执行程序名后，会搜索这个目录列表。
• PS1：Shell 提示符。
• PS2： 输入多行命令时，次要的 Shell 提示符。
• PWD：当前工作目录。
• RANDOM：返回一个0到32767之间的随机数。
• SHELL：Shell 的名字。
• SHELLOPTS：启动当前 Shell 的set命令的参数
• TERM：终端类型名，即终端仿真器所用的协议。
• UID：当前用户的 ID 编号。
• USER：当前用户的用户名。

特殊变量

Bash 提供一些特殊变量。这些变量的值由 Shell 提供，用户不能进行赋值。

• $?: 上一个命令的退出码, 0为成功，其他为失败
• $$: 当前进程的pid
• $_: 为上一个命令的最后一个参数
• $!: 为最近一个后台执行的异步命令的进程 ID。
• $0: bash脚本的参数列表，0是脚本文件路径，1到n是第1到第n个参数

变量默认值

• ${varname:-word}: 如果变量varname存在且不为空，则返回它的值，否则返回word
• ${varname:=word}: 如果变量varname存在且不为空，则返回它的值，否则将它设为word，并且返回word。
• ${varname:+word}: 如果变量名存在且不为空，则返回word，否则返回空值。它的目的是测试变量是否存在。
• ${varname:?message}: 如果变量varname存在且不为空，则返回它的值，否则打印出varname: message，并中断脚本的执行。

declare 命令

declare命令的主要参数（OPTION）如下。

• -a：声明数组变量。
• -A：声明关联数组变量。
• -f：输出所有函数定义。
• -F：输出所有函数名。
• -i：声明整数变量。
• -p：查看变量信息。
• -r：声明只读变量。
• -x：该变量输出为环境变量。

数据类型

bash 有字符串，数字，数字，关联数组四种数据类型，默认是字符串，其他类型需要手动声明。

字符串

定义

语法 varname=value

bash-5.1$ s1=abcdefg
bash-5.1$ echo $s1
abcdefg

获取长度（length）

语法 ${#varname}

bash-5.1$ echo ${#s1}
7

子字符串（substr）

语法 ${varname:offset:length}, offset为负数的时候，前面要加空格，防止与默认值语法冲突。

bash-5.1$ s1=abcdefg
bash-5.1$ echo ${s1:1:3}
bcd
bash-5.1$ echo ${s1: -6:2}
bc
bash-5.1$ echo ${s1: -6:3}
bcd

替换 （replace）

字符串头部的模式匹配

• ${variable#pattern}: 删除最短匹配（非贪婪匹配）的部分，返回剩余部分
• ${variable##pattern}: 删除最长匹配（贪婪匹配）的部分，返回剩余部分

匹配模式pattern可以使用*、?、[]等通配符。

$ myPath=/home/cam/book/long.file.name

$ echo ${myPath#/*/}
cam/book/long.file.name

$ echo ${myPath##/*/}
long.file.name

字符串尾部的模式匹配

• ${variable%pattern}: 删除最短匹配（非贪婪匹配）的部分，返回剩余部分
• ${variable%%pattern}: 删除最长匹配（贪婪匹配）的部分，返回剩余部分

$ path=/home/cam/book/long.file.name

$ echo ${path%.*}
/home/cam/book/long.file

$ echo ${path%%.*}
/home/cam/book/long

任意位置的模式匹配

如果匹配pattern则用replace替换匹配的内容

• ${variable/pattern/replace}: 替换第一个匹配
• ${variable//pattern/replace}: 替换所有匹配

$ path=/home/cam/foo/foo.name

$ echo ${path/foo/bar}
/home/cam/bar/foo.name

$ echo ${path//foo/bar}
/home/cam/bar/bar.name

数字

使用 declare -i声明整数变量。

# 声明为整数，可以直接计算，不需要使用$符号
bash-5.1$ declare -i val1=12 val2=5
bash-5.1$ echo $val1
12
bash-5.1$ val1+=val2
bash-5.1$ echo $val1
17

# 一个变量声明为整数以后，依然可以被改写为字符串。Bash 不会报错，但会赋以不确定的值
bash-5.1$ val1=aaa
bash-5.1$ echo $val1
0

数值的进制

Bash 的数值默认都是十进制，但是在算术表达式中，也可以使用其他进制。

• number：没有任何特殊表示法的数字是十进制数（以10为底）。
• 0number：八进制数。
• 0xnumber：十六进制数。
• base#number：base进制的数。

bash-5.1$ declare -i a=0x77
bash-5.1$ echo $a
119

bash-5.1$ declare -i a=0xfe
bash-5.1$ echo $a
254

bash-5.1$ declare -i a=2#111
bash-5.1$ echo $a
7

算术表达式

((...))语法可以进行整数的算术运算。
支持的算术运算符如下。

• +：加法
• -：减法
• *：乘法
• /：除法（整除）
• %：余数
• **：指数
• ++：自增运算（前缀或后缀）
• --：自减运算（前缀或后缀）

如果要读取算术运算的结果，需要在((...))前面加上美元符号$((...))，使其变成算术表达式，返回算术运算的值。

bash-5.1$ echo $((1+1))
2
bash-5.1$ echo $((1-1))
0
bash-5.1$ echo $((1*2))
2
bash-5.1$ echo $((1/2))
0
bash-5.1$ echo $((5%2))
1
bash-5.1$ a=1
bash-5.1$ echo $((a++))
1
bash-5.1$ echo $((a++))
2
bash-5.1$ echo $((++a))
4

数组

创建数组

array=(item1 item2) 语法可初始化数组，括号内可以换行，多行初始化可以用#注释。

# 直接初始化数组
bash-5.1$ a=(1 2 3)
bash-5.1$ echo ${a[@]}
1 2 3

# 多行初始化数组
bash-5.1$ a=(
> 1
> 2
> 3
> #4
> )
bash-5.1$ echo ${a[@]}
1 2 3

# 模式扩展初始化
bash-5.1$ a=({1..3})
bash-5.1$ echo ${a[@]}
1 2 3

# declare -a命令声明一个数组，也是可以的。
bash-5.1$ declare -a b
bash-5.1$ b+=(1)
bash-5.1$ echo ${b[@]}
1

#read -a命令则是将用户的命令行输入，存入一个数组。
bash-5.1$ read -a c
11 22 33
bash-5.1$ echo ${c[@]}
11 22 33

访问数组元素

array[index] 语法可访问数组元素，不带index访问则是访问数组首个元素。

bash-5.1$ a=(1 2 3)
# 查看元素
bash-5.1$ echo ${a[1]}
2
# 元素赋值
bash-5.1$ a[1]+=1
bash-5.1$ echo ${a[1]}
21
bash-5.1$ a[1]=22
bash-5.1$ echo ${a[1]}
22
#
bash-5.1$ a[0]=1111
bash-5.1$ echo ${a}
1111
bash-5.1$ echo ${a[0]}
1111

数组长度

${#array[@]} 和 ${#array[*]} 可访问获得数组长度

bash-5.1$ a=(1 2 3)
bash-5.1$ echo ${#a[*]}
3
bash-5.1$ echo ${#a[@]}
3

获取非空元素下标

${!array[@]} 或 ${!array[*]}, 可以获得非空元素的下标

bash-5.1$ a=(1 2 3)
bash-5.1$ a[6]=6
bash-5.1$ echo ${a[0]}
1
bash-5.1$ echo ${a[@]}
1 2 3 6
bash-5.1$ echo ${a[3]}

bash-5.1$ echo ${a[4]}

bash-5.1$ echo ${!a[@]}
0 1 2 6
# 注意此时数组长度为4，并不是7
bash-5.1$ echo ${#a[@]}
4

数组元素切片

${array[@]:position:length}的语法可以提取数组成员。

bash-5.1$ a=({1..10})
bash-5.1$ echo ${a[@]}
1 2 3 4 5 6 7 8 9 10
bash-5.1$ echo ${a[@]:1:3}
2 3 4

数组追加元素

数组末尾追加元素，可以使用+=赋值运算符。

bash-5.1$ a=({1..10})
bash-5.1$ echo ${a[@]}
1 2 3 4 5 6 7 8 9 10
bash-5.1$ a+=(11 12)
bash-5.1$ echo ${a[@]}
1 2 3 4 5 6 7 8 9 10 11 12

删除元素

删除一个数组成员，使用unset命令。

bash-5.1$ a=(1 2 3)
# 删除单个元素
bash-5.1$ unset a[1]
bash-5.1$ echo ${a[@]}
1 3
# 删除整个数组
bash-5.1$ unset a
bash-5.1$ echo ${a[@]}

关联数组

declare -A可以声明关联数组，关联数组使用字符串而不是整数作为数组索引。

除了初始化外，使用方法和数组基本相同

bash-5.1$ declare -A a
bash-5.1$ a['red']=1
bash-5.1$ a['blue']=2
bash-5.1$ echo ${a[@]}
2 1
bash-5.1$ echo ${a[@]:0:1}
2

控制流

注释

#表示注释，每行从#开始之后的内容代表注释，会被bash忽略.

bash-5.1$ echo 1111 # 222
1111

条件判断

bash 和常规编程语言一样使用if作为分支条件的关键字, fi作为结束的关键字，else和
elif子句是可选的

其中if和elif的condition所判断的内容是命令的状态码是否为0，为0则执行关联的语句。

# 因为bash中分号(;)和换行是等价的，所以有下面两种风格，其他多行语句也是类似的
# 本人偏好风格1
# 风格1
if condition; then
    command
elif condition; then
    command
else
    command
fi

# 风格2
if condition
then
    command
elif condition
then
    command
else
    command
fi

这里的condition可以是多个命令，如command1 && command2，或者command1 || command2，则if判断的是这两个命令的状态码的逻辑计算结果。

condition也是可以是command1; command2， 则则if判断的是最后一个命令的状态码。

这里最常用的condition是test命令, 也就是[[]]和[]. test是bash的内置命令，会执行给定的表达式，结果为真满足则返回状态码0, 否则返回状态码1.

下文循环语言的condition也是相同的，就不赘述了

bash-5.1$ test 1 -eq 1
bash-5.1$ echo $?
0
bash-5.1$ test 1 -eq 2
bash-5.1$ echo $?
1

[[]]和[]的区别是[[]]内部支持&&，||逻辑判断，所以以下三种写法是等价的。

由于[和]是命令， 所以两侧一定要有空格，也是就是[ 1 -eq 1 ]，否则bash会认为命令找不到。

# test
if test 1 -eq 2 || test 1 -eq 1; then
    echo True
fi

# [ ]
if [ 1 -eq 2 ] || [ 1 -eq 1 ]; then
    echo True
fi

# [[ ]]
if [[ 1 -eq 2  || 1 -eq 1 ]]; then
    echo True
fi

逻辑操作符

判断条件支持且（&&）或（||）非（!）

# not  
if [[ ! 'aa' == 'bb' ]]; then
    echo True
fi

# or 
if [[ 1 -eq 2  || 1 -eq 1 ]]; then
    echo True
fi

# and
if [[ 1 -ne 2  && 1 -eq 1 ]]; then
    echo True
fi

判断时引号使用（quote）

使用[和test时，变量引用注意加双引号，否则得不到正确的结果，[[则不需要。

bash-3.2$ echo "$SSH_CLIENT"

bash-3.2$ if [ -n $SSH_CLIENT ]; then echo 1; else echo 0; fi
1
bash-3.2$ if [ -n "$SSH_CLIENT" ]; then echo 1; else echo 0; fi
0
bash-3.2$ if [[ -n $SSH_CLIENT ]]; then echo 1; else echo 0; fi
0

字符串判断

bash默认数据类型为字符串，所以常见的 >, <是用于字符串判断。

注意：字符串判断不支持>=和<=, 得使用逻辑组合来替代

• -z string：字符串串长度为0
• -n string: 字符串长度大于0
• string1 == string2: string1 等于 string2
• string1 = string2: string1 等于 string2
• string1 > string2: 如果按照字典顺序string1排列在string2之后
• string1 < string2: 如果按照字典顺序string1排列在string2之前

数字(整数)判断

下面的表达式用于判断整数。

• [ integer1 -eq integer2 ]：如果integer1等于integer2，则为true。
• [ integer1 -ne integer2 ]：如果integer1不等于integer2，则为true。
• [ integer1 -le integer2 ]：如果integer1小于或等于integer2，则为true。
• [ integer1 -lt integer2 ]：如果integer1小于integer2，则为true。
• [ integer1 -ge integer2 ]：如果integer1大于或等于integer2，则为true。
• [ integer1 -gt integer2 ]：如果integer1大于integer2，则为true。

文件判断

以下表达式用来判断文件状态。仅列举常用判断，详细支持列表参考 https://tldp.org/LDP/abs/html/fto.html

• [ -a file ]：如果 file 存在，则为true。
• [ -d file ]：如果 file 存在并且是一个目录，则为true。
• [ -e file ]：如果 file 存在，则为true, 同-a。
• [ -f file ]：如果 file 存在并且是一个普通文件，则为true。
• [ -h file ]：如果 file 存在并且是符号链接，则为true。
• [ -L file ]：如果 file 存在并且是符号链接，则为true, 同-h。
• [ -p file ]：如果 file 存在并且是一个命名管道，则为true。
• [ -r file ]：如果 file 存在并且可读（当前用户有可读权限），则为true。
• [ -s file ]：如果 file 存在且其长度大于零，则为true。
• [ -w file ]：如果 file 存在并且可写（当前用户拥有可写权限），则为true。
• [ -x file ]：如果 file 存在并且可执行（有效用户有执行／搜索权限），则为true。

switch case

bash也支持，switch case，语法如下。

case EXPRESSION in
  PATTERN_1)
    STATEMENTS
    ;;
  PATTERN_2)
    STATEMENTS
    ;;
  PATTERN_N)
    STATEMENTS
    ;;
  *)
    STATEMENTS
    ;;
esac

例如

a=2
case $a in
1)
    echo 11
    ;;
2)
    echo 22
    ;;
*)
    ;;
esac

循环

while 循环

while循环有一个判断条件，只要符合条件，就不断循环执行指定的语句。
condition与if语句的相同，就不赘述了。

while condition; do
  command
done

unitl 循环

until循环与while循环恰好相反，只要不符合判断条件（判断条件失败），就不断循环执行指定的语句。一旦符合判断条件，就退出循环。

until condition; do
  command
done

for-in 循环

for...in循环用于遍历列表的每一项。

for variable in list; do
  commands
done

常见的几种用法

for i in 1 2 3; do
    echo $i
done

for i in {1..3}; do
    echo $i
done

list=(1 2 3)
for i in ${list[@]}; do
    echo $i
done

for 循环

for循环还支持 C 语言的循环语法。

for (( expression1; expression2; expression3 )); do
  commands
done

上面代码中，expression1用来初始化循环条件，expression2用来决定循环结束的条件，expression3在每次循环迭代的末尾执行，用于更新值。

注意，循环条件放在双重圆括号之中。另外，圆括号之中使用变量，不必加上美元符号$。

例如

for ((i=1; i<=3; i++)); do
    echo $i
done

跳出循环

Bash 提供了两个内部命令break和continue，用来在循环内部跳出循环。

break命令立即终止循环，程序继续执行循环块之后的语句，即不再执行剩下的循环。
continue命令立即终止本轮循环，开始执行下一轮循环。

函数

函数定义

Bash 函数定义的语法有两种，其中fn为定义的函数名称。

# 第一种
fn() {
  # codes
}

# 第二种
function fn() {
  # codes
}

函数参数

函数体内可以使用参数变量，获取函数参数。函数的参数变量，与脚本参数变量是一致的。

• ${N}：函数的第一个到第N个的参数。
• $0：函数所在的脚本名。
• $#：函数的参数总数。
• $@：函数的全部参数，参数之间使用空格分隔。
• $*：函数的全部参数，参数之间使用变量$IFS值的第一个字符分隔，默认为空格，但是可以自定义。

函数调用

funcname arg1 arg ... argN 的语法进行函数调用。主要函数的返回值和输出值（标准输出）的区别，这和主流编程语言不同

add() {
    declare -i res
    res=0
    for i in $@; do
        res+=$i
    done
    echo $res
}

# 结果为10
add 1 2 3 4

函数返回值

return命令用于从函数返回一个值。返回值和命令的状态码一样，可以用$?拿到值。
return也可以不接具体的值，则返回值是return命令的上一条命令的状态码。
如果不加return，则返回值是函数体最后一条命令的状态码。

function func_return_value {
  return 10
}

关键概念

shebang

Shebang（也称为Hashbang）是一个由井号和叹号构成的字符序列#!， 其出现在可执行文本文件的第一行的前两个字符。
在文件中存在Shebang的情况下，类Unix操作系统的程序加载器会分析Shebang后的内容，将这些内容作为解释器指令，并调用该指令.

例如，shell脚本

#!/bin/bash

echo Hello, world!

python 脚本

#!/usr/bin/env python -u

print("Hello, world!")

状态码

每个命令都会返回一个退出状态码（有时候也被称为返回状态）。

成功的命令返回 0，不成功的命令返回非零值，非零值通常都被解释成一个错误码。行为良好的 UNIX 命令、程序和工具都会返回 0 作为退出码来表示成功，虽然偶尔也会有例外。

状态码一般是程序的main函数的返回码，如c,c++。
如果是bash脚本，状态码的值则是 exit 命令的参数值。
当脚本以不带参数的 exit 命令来结束时，脚本的退出状态码就由脚本中最后执行的命令来决定，这与函数的 return 行为是一致的。

特殊变量$?可以查看上个命令的退出状态码

文件描述符

文件描述符在形式上是一个非负整数。指向内核为每一个进程所维护的该进程打开文件的记录表。
当程序打开一个现有文件或者创建一个新文件时，内核向进程返回一个文件描述符。

标准输入输出

每个Unix进程（除了可能的守护进程）应均有三个标准的POSIX文件描述符，对应于三个标准流：

• 0：标准输入
• 1：标准输出
• 2：错误输出

打开新的文件描述符

手动指定描述符

exec 3<> /tmp/foo  #open fd 3.
echo "test" >&3
exec 3>&- #close fd 3.

系统自动分配描述符，bash4.1开始支持(在macos报错，原因不明)

#!/bin/bash

FILENAME=abc.txt

exec {FD}<>"$FILENAME"
echo 11 >&FD
echo 22 >&FD
$FD>&-

描述符重定向

• command > file: 将输出重定向到 file。
• command < file: 将输入重定向到 file。
• command >> file: 将输出以追加的方式重定向到 file。
• n > file: 将文件描述符为 n 的文件重定向到 file。
• n >> file: 将文件描述符为 n 的文件以追加的方式重定向到 file。
• n >& m: 将输出文件 m 和 n 合并。
• n <& m: 将输入文件 m 和 n 合并。

所以命令中常见的ls -al > output.txt 2>&1, 就是将标准输出和错误输出都重定向到一个文件。
等价于ls -al &>output.txt，本人偏好这种写法，比较简洁。

IFS (Input Field Separators)

IFS决定了bash在处理字符串的时候是如何进行单词切分。
IFS的默认值是空格，TAB，换行符，即 \t\n

$ echo "$IFS" | cat -et
 ^I$
$

例如，在for循环的时候，如何区分每个item

for i in `echo -e "foo bar\tfoobar\nfoofoo"`; do
    echo "'$i' is the substring";
done

也可以自定义

OLD_IFS="$IFS"
IFS=":"
string="1:2:3"
for i in $string; do
    echo "'$i' is the substring";
done
IFS=$OLD_IFS

任务管理

linux进程分前台（fg）和后台（bg）。

在命令的末尾添加&可以将命令后台执行，一般配合输出重定向使用。

jobs可以查看当前bash进程的子进程，并通过fg和bg进行前台和后台切换。

%1代表后台的第一个进程，以此类推%N代表第n个.

control + Z可以将当前前台程序暂停，配合bg可以将其转后台。

wait [pid]可以等待子进程结束，如果不带pid参数则等待所有子进程结束。

bash-5.1$ sleep 100
^Z
[1]+  已停止               sleep 100
bash-5.1$ jobs
[1]+  已停止               sleep 100
bash-5.1$ bg %1
[1]+ sleep 100 &
bash-5.1$ sleep 200 &
[2] 63603
bash-5.1$ jobs
[1]-  运行中               sleep 100 &
[2]+  运行中               sleep 200 &
bash-5.1$ wait %1
[1]-  已完成               sleep 100

后台进程并发控制

可以利用jobs对后台进程并发数目进行控制

for i in {1..30}; do
	sleep $((30+i)) &
	if [[ $(jobs | wc -l ) -gt 10 ]]; then
		jobs
		wait
	fi
done
wait

参考

• https://wangdoc.com/bash/
• https://tldp.org/LDP/abs/html/fto.html
• https://zh.wikipedia.org/wiki/Shebang
• https://en.wikipedia.org/wiki/File_descriptor

每一个bit有0、1两种状态，所以 Bitmap 适合应用于判断是否存在、桶排序（不含重复元素），具体来说可以用bitmap记录ip信息，实现布隆过滤器等等。

Bitmap 原理

Bitmap 可以看成是个二维数组，第一维取出的元素是byte，然后用第二维的index去访问该byte对应的位。

由于正常访问内存最小的单位的字节，操作具体的位需要位运算。

位运算

注意：这里的位移操作都是逻辑位移

一个byte有8bit， 设置某个位为1，需要用到按位或 |

第0个bit： byte |= 0b10000000
第1个bit： byte |= 0b01000000
...
第7个bit： byte |= 0b00000001

所以：设置byte的第n个bit(n取0到7)： byte |= (0b10000000 >> n)

判断某个位是否为1，需要用到按位与 &
过程和上面类似, 满足byte & (0b10000000 >> n) == (0b10000000 >> n)，则该位为1

将某个位置为0，需要用到按位与 &

第0个bit： byte &= 0b01111111
第1个bit： byte &= 0b10111111
...
第7个bit： byte &= 0b01111110

所以：第n个bit(n取0到7)： byte &= ((0b10000000 >> n) ^ 0b11111111)
Python中由于没有无符号数，所以算掩码（0b01111111）时不能用按位取反。

Python实现

将使用到的掩码设置为常量，性能会更好，这里的实现主要是为了体现思路，便于理解

BYTE_WIDTH = 8

class BitMap:
    def __init__(self, size, fill=0):
        self._array = bytearray((fill for _ in range(size//BYTE_WIDTH+1)))

    def set(self, index):
        major, minor = divmod(index, BYTE_WIDTH)
        self._array[major] |= (0b10000000 >> minor)

    def get(self, index):
        major, minor = divmod(index, BYTE_WIDTH)
        mask = 0b10000000 >> minor
        return int(self._array[major] & mask == mask)

    def clear(self, index):
        major, minor = divmod(index, BYTE_WIDTH)
        self._array[major] &= ((0b10000000 >> minor) ^ 0b11111111)

    def get_bin(self):
        return ' '.join(('{:0>8}'.format(bin(i)[2:]) for i in self._array))

通用monkey.patch_all() 所有io操作函数, gevent可以以同步的方式编写异步代码. 在不更改代码的同时就可以使系统并发性能得到指数级提升。

这里有一个局限, c扩展中的io操作无法被patch, 会导致整个server阻塞

一个简单的web server

这里使用flask写了web server 用于测试

# filename: flask_app.py
import time
from flask import Flask, request

app = Flask(__name__)

@app.route('/test', methods=['GET', 'POST'])
def test():
    time.sleep(0.2)
    return 'hello'

if __name__ == "__main__":
    app.run()

不使用gevent

安装依赖：pip install flask gunicorn gevent

启动服务器：gunicorn -w 1 --bind 127.0.0.1:5000 flask_app:app

测试性能：siege -c 20 -r 1 'http://127.0.0.1:5000/test'

由于只有一个worker进程，可以看到只有5qps，每个请求sleep 0.2秒，是符合预期的。

使用gevent

启动服务器：gunicorn -w 1 -k gevent --bind 127.0.0.1:5000 flask_app:app

测试性能：siege -c 20 -r 1 'http://127.0.0.1:5000/test'

可以看到，性能有接近20倍的提升

C扩展阻塞io与gevent协作的问题

加入阻塞io的C扩展

这个程序通过sleep 2s 来模拟阻塞的io操作，所以每次调用会阻塞2s

#include <unistd.h>

// sleep.c

int main(){
  sleep(2);
  return 0;
}

然后，自然是把这个C文件编成动态链接库：

Linux下的编译：

gcc -c -fPIC sleep.c
gcc -shared sleep.o -o sleep.so

然后在我们的web server 中调用这个动态库，使用ctypes调用

def socket_block():
    from ctypes import cdll
    lib = cdll.LoadLibrary('./sleep.so')
    lib.main()
    return 0

@app.route('/test', methods=['GET', 'POST'])
def test():
    socket_block()
    return 'hello'

测试后发现，gevent失效了，整个服务基本是串行阻塞状态

解决方案

尝试thread

使用线程, 基本没啥用, 不能解决问题

@app.route('/test', methods=['GET', 'POST'])
def test():
    t = threading.Thread(target=socket_block, args=())
    t.setDaemon(1)
    t.start()
    return 'hello'

使用 siege 进行测试, 看请求耗时, 所有请求基本是串行的, gevent没有效果

➜  ~/projects siege -c 10 -r 1 'http://127.0.0.1:5000/test'  -v
** SIEGE 4.0.4
** Preparing 10 concurrent users for battle.
The server is now under siege...
HTTP/1.1 200    16.02 secs:       9 bytes ==> GET  /test
HTTP/1.1 200    16.02 secs:       9 bytes ==> GET  /test
HTTP/1.1 200    16.02 secs:       9 bytes ==> GET  /test
HTTP/1.1 200    16.02 secs:       9 bytes ==> GET  /test
HTTP/1.1 200    16.02 secs:       9 bytes ==> GET  /test
HTTP/1.1 200    16.03 secs:       9 bytes ==> GET  /test
HTTP/1.1 200    16.02 secs:       9 bytes ==> GET  /test
HTTP/1.1 200    16.02 secs:       9 bytes ==> GET  /test
HTTP/1.1 200    20.03 secs:       9 bytes ==> GET  /test
HTTP/1.1 200    20.04 secs:       9 bytes ==> GET  /test

尝试multiprocess

问题解决

@app.route('/test', methods=['GET', 'POST'])
def test():
    p = multiprocessing.Process(target=socket_block, args=())
    p.start()
    return 'hello'

使用 siege 进行测试, 请求没有被阻塞

➜  ~/projects siege -c 5 -r 1 'http://127.0.0.1:5000/test'  -v
** SIEGE 4.0.4
** Preparing 5 concurrent users for battle.
The server is now under siege...
HTTP/1.1 200     0.01 secs:       5 bytes ==> GET  /test
HTTP/1.1 200     0.02 secs:       5 bytes ==> GET  /test
HTTP/1.1 200     0.03 secs:       5 bytes ==> GET  /test
HTTP/1.1 200     0.03 secs:       5 bytes ==> GET  /test
HTTP/1.1 200     0.04 secs:       5 bytes ==> GET  /test

总结

webserver主体进程使用gevent, 将阻塞的c扩展网络io操作放到另一个进程中执行, 可以改造成一个服务

具体可以用这下面两种实现

• celery
• multiprocess

还有一种对动态库进行patch的方案（greenify），只在linux下有效，就没怎么研究了

话接上回，说是接手了一个82年的拉菲Python项目，这次又发现了一个新坑

项目中用了一个上下文类，用于存储本次请求的一些数据，在开发过程中我想把这个上下文类dump成json，详细分析里面的数据，然而发现上下文类的行为不符合预期

症状

上下文类大概是这样

class Context():
    def __init__(self):
        self._input_json = None
        self._result_dict = dict()

    @property
    def input_json(self):
        print 'get _input_json'
        return self._input_json

    @input_json.setter
    def input_json(self, input_json):
        print 'set _input_json %s ' % input_json
        self._input_json = input_json

    @property
    def result_dict(self):
        print 'get _result_dict'
        return self._result_dict

    @result_dict.setter
    def result_dict(self, result_dict):
        print 'set _result_dict %s ' % result_dict
        self._result_dict = result_dict

    # 我附加的to_dict方法
    def to_dict(self):
        tmp = {}
        for k, v in self.__dict__.items():
            if k.startswith('_'):
                tmp[k] = v
        return tmp

测试之后发现，结果明显不符合预期，两个属性只输出了一个

>>> from test_property import  Context
>>> c = Context()
... c.input_json = {'a': 1}
... c.result_dict['b'] = 2
...
get _result_dict
>>> c.to_dict()
{'_input_json': None, '_result_dict': {'b': 2}}

分析

看测试代码我们可以发现，在访问result_dict属性的时候，property是工作正常的（有对应的print)

但是对应设置input_json的时候, 却没有看到对应的print输出

所以可以断定，此处的property工作不正常。

仔细看代码后，我发现Context是旧式类。可以看到，A, B, C三中类的写法，其中A和B都是旧式类<type 'classobj'>, C是新式类。（旧式类只在Python2中存在）。
我们这里Context的写法和B是一样的。

>>> class A:
...     pass
...
... class B():
...     pass
...
... class C(object):
...     pass
...
>>> type(A)
<type 'classobj'>
>>> type(B)
<type 'classobj'>
>>> type(C)
<type 'type'>

然后自然就怀疑旧式类对property装饰器的支持存在问题。
一通google之后，确定旧式类是不支持property。

确切地说，是对property的支持不完整，具体来说有以下3点。

• 支持property的getter
• 不支持property的setter
• 不支持property的赋值保护

参考

• https://help.semmle.com/wiki/display/PYTHON/Property+in+old-style+class
• https://stackoverflow.com/questions/9962037/pythons-property-decorator-does-not-work-as-expected

golang将程序编译成一个可执行文件，部署起来特别方便。

那么Python是否也有类似解决方案呢？单一可执行文件，免去安装Python环境的麻烦，也避免了直接暴露源码程序。

经过多次搜索之后找到解决方案 exxo

注意：exxo只支持linux64平台

指路

安装

首先下载安装exxo

wget https://bintray.com/artifact/download/mbachry/exxo/exxo-0.0.7.tar.xz  # 下载 

tar xf exxo-0.0.7.tar.xz  # 解压

mv exxo /usr/local/bin   # 移动到可执行文件目录（可选）

创建环境

通过 exxo 创建一个python虚拟环境，用于编译我们的程序

exxo venv /tmp/myenv    # 创建环境
source /tmp/myenv/bin/activate   # 激活环境

编译程序

先写一个简单的程序: aa.py

import os

def main():
    os.system('ls -al')

if __name__ == '__main__':
    main()

再根据这个程序编写setup.py, 这一步是关键，不熟悉的同学可以去学习一下setuptools的语法。

#condig=utf8
from setuptools import setup, find_packages

requirements = [
    # 这里可以写上需要的依赖
    # 'setuptools',
]

setup(
    name='pyaa',   # 编译出的文件的名称
    version='0.0.1',
    packages=find_packages(),
    include_package_data=True,
    install_requires=requirements,
    zip_safe=True,
    py_modules=[
        "aa",
    ],
    entry_points={  # python 生成可执行文件的入口
        'console_scripts': [
            'pyaa = aa:main',
        ]
    }
)

执行exxo build编译，生成文件dist/pyaa

最后，测试该文件，功能正常。

$ ./dist/pyaa
总用量 19348
drwxrwxr-x 4 ruan ruan     4096 3月   1 11:25 .
drwxrwxr-x 6 ruan ruan     4096 2月  29 11:48 ..
-rw-rw-r-- 1 ruan ruan       87 3月   1 11:14 aa.py
drwxrwxr-x 2 ruan ruan     4096 3月   1 11:26 dist
-rw-r--r-- 1 ruan ruan 19784872 8月  29 2016 exxo-0.0.7.tar.xz
drwxrwxr-x 2 ruan ruan     4096 3月   1 11:24 __pycache__
-rw-rw-r-- 1 ruan ruan      505 3月   1 11:25 setup.py

在工作中发现有获取linux具体开关机时间和类型的需求，可以通过分析/var/log/wtmp日志文件得到。
通过last -x -F可以将/var/log/wtmp输出以下格式。

root     pts/1        172.16.3.245     Sun Jun 12 10:14:47 2016 - Tue Jun 14 08:34:31 2016 (1+22:19)
root     pts/0        172.16.3.245     Sun Jun 12 10:14:37 2016 - Tue Jun 14 08:34:25 2016 (1+22:19)
root     ttyS0                         Sun Jun 12 10:14:24 2016 - down                     (5+03:49)
runlevel (to lvl 3)   3.10.0           Sun Jun 12 10:14:17 2016 - Fri Jun 17 14:03:40 2016 (5+03:49)
root     pts/1        172.16.3.145     Sun Jun 12 10:13:57 2016 - Sun Jun 12 10:13:57 2016  (00:00)
reboot   system boot  3.10.0           Sun Jun 12 10:13:18 2016 - Fri Jun 17 14:03:40 2016 (5+03:50)
shutdown system down  3.10.0           Sun Jun 12 10:12:51 2016 - Sun Jun 12 10:13:18 2016  (00:00)
root     pts/1        172.16.3.145     Sun Jun 12 10:12:47 2016 - down                      (00:00)
root     pts/20       172.16.3.211     Sun Jun 12 10:07:58 2016 - down                      (00:04)
root     pts/19       172.16.3.119     Sun Jun 12 10:07:50 2016 - down                      (00:05)

...
root     pts/3        172.16.3.145     Sun Jun 12 09:10:15 2016 - down                      (01:02)
root     pts/2        172.16.3.145     Sun Jun 12 09:10:15 2016 - down                      (01:02)
root     tty1                          Sun Jun 12 09:09:37 2016 - down                      (01:03)
runlevel (to lvl 3)   3.10.0           Sun Jun 12 09:09:22 2016 - Sun Jun 12 10:12:51 2016  (01:03)
root     pts/1        172.16.3.245     Sun Jun 12 09:09:10 2016 - Sun Jun 12 10:12:47 2016  (01:03)
reboot   system boot  3.10.0           Sun Jun 12 09:07:24 2016 - Sun Jun 12 10:12:51 2016  (01:05)
root     pts/14       172.16.3.211     Sun Jun 12 08:57:19 2016 - crash                     (00:10)
root     pts/7        172.16.3.245     Sun Jun 12 08:52:13 2016 - crash                     (00:15)
root     pts/11       172.16.3.245     Sun Jun 12 08:51:38 2016 - crash                     (00:15)
root     pts/10       172.16.3.211     Sun Jun 12 08:46:06 2016 - crash                     (00:21)
root     pts/9        172.16.3.30      Sun Jun 12 08:41:33 2016 - crash                     (00:25)

性空

具体一条记录

每一行为一条会话记录，有以下6个部分。

1. 用户名
   • linux用户名
   • reboot 系统关机或重启
   • shutdown 关机
2. 终端类型
   • tty 本机终端
   • pst 远程登录终端
3. 登录ip
4. 开始时间（可靠）
5. 结束时间（不可靠）
   • 具体时间：结束时间，若不正常关机，此时间就不准确
   • down：系统关机退出
   • crash：系统不正常关机退出
6. 持续时长
   • (5+03:49) 日，小时，分

分析开关机时间思路

1. 首先找到开始为reboot的行，获取此行的“开始时间”得到这一次的开机时间。
2. 如果reboot行的下一行为shutdown，则为正常关机，获取此行的“开始时间”得到关机时间。若持续时间为(00:00)则为重启。
3. 如果reboot行的下一行不为shutdown，则为不正常关机，下面的登录会话的“结束时间”必然伴随着crash。找到最近的一条crash记录，拿到这条记录的“开始时间”和“持续时长”，相加即是关机时间。

在类UNIX系统中，一切被打开的文件、端口被抽象为文件描述符（file descriptor）
从python3.4开始，文件描述符默认是non-inheritable，也就是子进程不会共享文件描述符。

问题

一般为了实现多进程、多线程的webserver，服务端口fd必须设置为继承（set_inheritable），这样才能多进程监听一个端口（配合SO_REUSEPORT）
典型的是使用flask的测试服务器的场景，这里我们写一段代码模拟。

import socket, os
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(('127.0.0.1', 22222))
server.set_inheritable(True)

os.system("python -c 'import time;time.sleep(1000)' ")

我们通过lsof -p {pid}可以看到这两个进程的所有文件描述符
server进程, 可以看到服务端口的fd是4

COMMAND   PID  FD      TYPE             DEVICE  SIZE/OFF       NODE NAME
ptpython 6214 cwd       DIR              253,0      4096  872946898 /
...
ptpython 6214   0u      CHR             136,13       0t0         16 /dev/pts/13
ptpython 6214   1u      CHR             136,13       0t0         16 /dev/pts/13
ptpython 6214   2u      CHR             136,13       0t0         16 /dev/pts/13
ptpython 6214   3r      CHR                1,9       0t0       2057 /dev/urandom
ptpython 6214   4u     sock                0,7       0t0   58345077 protocol: TCP
ptpython 6214   5u  a_inode               0,10         0       8627 [eventpoll]
ptpython 6214   6u     unix 0x0000000000000000       0t0   58368029 socket
ptpython 6214   7u     unix 0x0000000000000000       0t0   58368030 socket

sleep子进程，也拥有fd=4的文件描述符

COMMAND   PID  FD   TYPE DEVICE  SIZE/OFF       NODE NAME
python  18022 cwd    DIR  253,0      4096  872946898 /
...
python  18022   0u   CHR 136,13       0t0         16 /dev/pts/13
python  18022   1u   CHR 136,13       0t0         16 /dev/pts/13
python  18022   2u   CHR 136,13       0t0         16 /dev/pts/13
python  18022   4u  sock    0,7       0t0   58345077 protocol: TCP

如果server进程退出时，sleep进程没有退出，fd=4对应的端口就被占用了，服务也就不能正常启动了。

解决方法

手动清理

import os
import time

os.system(f'lsof -p {os.getpid()}')
os.closerange(3, 100)  # 这里假定打开文件描述符不会超过100
time.sleep(5)
os.system(f'lsof -p {os.getpid()}')
# 后面执行需要的业务代码

使用close_fds

使用subprocess库而不是os来启动子程序， 通过close_fds参数关闭多余的文件描述符

import subprocess
subprocess.call("python -c 'import time;time.sleep(1000)'", shell=True, close_fds=True)

参考

• https://docs.python.org/3/library/os.html#inheritance-of-file-descriptors
• https://docs.python.org/3/library/subprocess.html#subprocess.Popen
• https://stackoverflow.com/questions/2023608/check-what-files-are-open-in-python#answer-25069136

谈到一致性哈希（Consistent hashing），就得先讲一下分布式存储。
比如我们有2000w条数据，一台机器存不下，那么我们可以把分成10份每份200w条存到10台机器上。
这样存储就不成问题，但是查询效率很低，查一条数据要每台机器都查一遍。
如果这些数据能够分类，每一类存到一台机器上，查询前先知道数据的类别，就可以直接定位到某台机器，效率就高了。

原理

那么就得找到一个通用而且均匀的分类方法，可以想到先哈希再取模hash(data) % N

现有这几个数据apple, banana, cherry，durian，希望存储到有3台机器的服务.

# 假设自定义了hash函数，有以下返回
hash("apple") % 3 == 30 % 3 == 0
hash("banada") % 3 == 31 % 3 == 1
hash("cherry") % 3 == 32 % 3 == 2

如果B机器宕机了，需要将取模余数和机器重新映射，这时发现3/4的数据都需要迁移

其实当B机器宕机时，取模的除数可以不改成2，依然是hash(data) % 3，这样余数就不会变，只需要把余数和机器的映射改一下，将原先B机器的映射到A机器上，这样只需要迁移1/4的数据.

但是现在取模的除数和机器数目相等，只能应对机器减少的情况，增加机器就没法处理了。
这时可以用一个比较大的数作为除数（比如3000），把除数在一定范围内的都映射到某台机器，增加机器只需要调整余数和机器的映射就行了。

到这里一致性哈希的基本原理已经介绍完了，但对于新增服务器的情况还存在一些问题。
新增的服务器D只分担了C服务器的负载，服务器 A 和 B 并没有因为 D 服务器的加入而减少负载压力。
针对这个问题，可以把D当做多台机器，均匀地放置，这样所有机器的负载都得到分担，也就是所谓的引入虚拟节点。

实现

下面用Python来实现一致性哈希，这里实现不带虚拟节点的版本。

代码实现和上文分析，有几点细节有些不同

• 简化实现，使用hashlib.sha1作为哈希函数
• 取模的除数设置为2^32 - 1，这是C语言中unsiged int的最大取值。
• 根据我们的除数，余数的取值空间就是[0, 2^32 - 1], 可以看成一个首位相连的环。
• 余数和机器的映射不需要单独维护，只要将机器也哈希和取模，就得到机器在环上的位置。
• 机器分布在环上，将余数的取值范围分割成多个区间，每个区间对应一台机器，每台机器负责上一个机器位置到当前机器位置的数据。
  

import hashlib

MASK = 2 ** 32 - 1

def myhash(string):
    return int(hashlib.sha1(string.encode("utf-8")).hexdigest(), 16)

def get_pos(obj):
    return myhash(obj) % MASK

class Server:
    def __init__(self, addr):
        self.addr = addr
        self.pos = get_pos(self.addr)

    def __hash__(self):
        return myhash(self.addr)

    def __repr__(self):
        return '<Server {}; {:,}>'.format(self.addr, self.pos)

class ConsistentHashing:
    def __init__(self):
        self.servers = []

    def add_server(self, server):
        assert server not in self.servers
        self.servers.append(server)
        self.servers.sort(key=lambda i: i.pos)

    def get_server(self, key):
        assert len(self.servers) > 0
        pos = get_pos(key)
        for i in self.servers:
            if i.pos >= pos:
                return i
        return self.servers[0]

if __name__ == '__main__':
    ch = ConsistentHashing()
    ch.add_server(Server('192.168.1.1:80'))
    ch.add_server(Server('192.168.1.2:80'))
    ch.add_server(Server('192.168.1.3:80'))
    print(ch.servers)
    print('{:,}'.format(get_pos('123')), ch.get_server('123'))
    print('{:,}'.format(get_pos('xxx')), ch.get_server('xxx'))
    print('{:,}'.format(get_pos('1')), ch.get_server('1'))

参考

• https://segmentfault.com/a/1190000021199728
• https://www.jianshu.com/p/528ce5cd7e8f
• https://en.wikipedia.org/wiki/Consistent_hashing

最近有个需求, 在Java环境环境运行xgboost模型, 查询资料后发现PMML可以解决这个问题.

PMML是数据挖掘的一种通用的规范，它用统一的XML格式来描述我们生成的机器学习模型。这样无论你的模型是sklearn,R还是Spark MLlib生成的，我们都可以将其转化为标准的XML格式来存储。当我们需要将这个PMML的模型用于部署的时候，可以使用目标环境的解析PMML模型的库来加载模型，并做预测。

可以看出，要使用PMML，需要两步的工作:

• 第一块是将离线训练得到的模型转化为PMML模型文件
• 第二块是将PMML模型文件载入在线预测环境，进行预测

模型转PMML

sklearn2pmml

常见的方法是用sklearn2pmml, 主要思路是将Booster模式转为Scikit-Learn Wrapper interface的XGBModel, 然后再使用PMMLPipeline保存为PMML模型文件

import xgboost as xgb
from sklearn_pandas import DataFrameMapper
from sklearn2pmml import PMMLPipeline, sklearn2pmml

FILE = 'demo.model'

def convert(file):
    mod = xgb.XGBModel()
    mod.load_model(file)
    pipe = PMMLPipeline([
        ("classifier", mod),
    ])
    # pipe.configure(ntree_limit=999)
    sklearn2pmml(pipe, file + '.pmml', with_repr=True)
    
convert(FILE)

使用这种方法, 可能会出现因为模型包含中文信息导致转换失败

Standard output is empty
Traceback (most recent call last):
  File "<stdin>", line 7, in <module>
  File "/Users/ruan/.pyenv/versions/2.7.16/lib/python2.7/site-packages/sklearn2pmml/__init__.py", line 262, in sklearn2pmml
    print("Standard error:\n{0}".format(_decode(error, java_encoding)))
UnicodeEncodeError: 'ascii' codec can't encode character u'\u6708' in position 1: ordinal not in range(128)
'ascii' codec can't encode character u'\u6708' in position 1: ordinal not in range(128)

jpmml-xgboost

也可以jpmml-xgboost工具, 将xgboost模型直接转换为PMML

注意这里的模型文件, 需要是通过xgboost.Booster.save_model方法保存的.

下载

wget https://github.com/jpmml/jpmml-xgboost/releases/download/1.3.15/jpmml-xgboost-executable-1.3.15.jar

生成fmap特征映射文件

fmap文件的每行的格式是: 特征索引\t特征名称\tq
特征名称可以随意命名, 在调用PMML预测时会用到

例如: fmap.txt

0	fea0	q
1	fea1	q
2	fea2	q
3	fea3	q
4	fea4	q
...

执行

java -jar jpmml-xgboost-executable-1.3.15.jar \
	--model-input demo.model \  # 输入
	--pmml-output demo.model.pmml \  # 输出
	--fmap-input fmap.txt \  # 特征映射文件
	--missing-value -1 \   # 指定模型缺失值

模型预测

python环境比较模型结果

python可以使用pypmml库, 测试我们转换好的PMML, 并和原始模型进行分数比较

from pypmml import Model
import xgboost as xgb
import numpy as np

xgb_mod = xgb.Booster(model_file='demo.model')
pmml_mod = Model.load('demo.model.pmml')

# float分数比较
def eq(a, b):
    return abs(a - b) < 0.00001

# xgboost预测
def predict(mod, data):
    fea = np.asarray(data, dtype=np.float64).reshape([1, -1])
    dtest = xgb.DMatrix(fea, missing=np.float64(-1.0))
    return mod.predict(dtest)[0]

# pmml预测
def pmml_predict(mod, data):
    fea = {"fea{}".format(idx): elem for (idx, elem) in  enumerate(data)}
    return mod.predict(fea)['probability(1)']

data = [1, 2, 3, 4]
a, b = predict(xgb_mod, data), pmml_predict(pmml_mod, data)
assert eq(a, b)

Java环境执行

java环境执行, 需要用到pmml-evaluator和pmml-evaluator-extension库

具体代码参考 https://www.cnblogs.com/pinard/p/9220199.html

参考

1. https://www.cnblogs.com/pinard/p/9220199.html
2. https://blog.csdn.net/yueguanghaidao/article/details/91892549
3. https://github.com/jpmml/jpmml-xgboost
4. https://yao544303.github.io/2018/07/11/sklearn-PMML/

它的优点是空间效率和查询时间都远远超过一般的算法，缺点是有一定的误识别率和删除困难。

布隆过滤器原理

如果想判断一个元素是不是在一个集合里，一般想到的是将集合中所有元素保存起来，然后通过比较确定，比如在Python中通过dict来实现。

使用dict的方案有个局限，就是没办法应用在大规模数据上。

以英语单词为例，我们有三个单词apple，banana，cherry。

如果用dict来存的话是, 查询的准确性是100%，空间占用也是100%

如果我们对准确性要求降低一些，我们可以只记录单词的首字母；
首字母不存在dict中的话，该单词不存在，否则有可能存在。

记录首字母的方法虽然有效，但是由于同首字母的单词很多，只记录首字母准确率太低了。
所以我们可以依次记录前2个字母，只有这两个字母都存在，我们才认为该单词存在。

以此类推，为了提高准确率，我们可以从前2个字母增加到前n个字母。
但是也不能太大，太大的话，dict里的每个字母被重复设置的次数过多，准确率反而会下降。

以上方案还有一个问题，单词中每个字母的分布是很不均匀的，导致准确率对不同的单词也不稳定。
可以不直接记录字母，而是对单词应用哈希函数，并将结果按一个数值（比如26）取模，如hash('apple') % 26，当做一个单词的一个字母来记录。
同时应用多个不同的哈希函数，并记录取模后的值，相当于记录该单词的多个字母。

Python实现

根据上文的分析，可以实现Python版本的布隆过滤器。
用bitmap代替dict，节省空间占用。
使用Python内置的hash函数作为哈希函数。
哈希前对元素增加不同的后缀再调用，替代理论里的多个不同哈希函数。

BIT_SIZE = 5000000
BYTE_WIDTH = 8

class BitMap:
    def __init__(self, size, fill=0):
        self._array = bytearray((fill for _ in range(size//BYTE_WIDTH+1)))

    def set(self, index):
        major, minor = divmod(index, BYTE_WIDTH)
        self._array[major] |= (0b10000000 >> minor)

    def get(self, index):
        major, minor = divmod(index, BYTE_WIDTH)
        mask = 0b10000000 >> minor
        return int(self._array[major] & mask == mask)

class BloomFilter:
    def __init__(self):
        self.bit_array = BitMap(BIT_SIZE)

    def add(self, url):
        point_list = self.get_postions(url)
        for b in point_list:
            self.bit_array.set(b)

    def contains(self, url):
        point_list = self.get_postions(url)
        return all(self.bit_array.get(i) for i in point_list)

    def get_postions(self, url):
        return [hash('{}-{}'.format(url, i)) % BIT_SIZE for i in range(41, 48)]

if __name__ == '__main__':
    bf = BloomFilter()
    bf.add('1')
    print(bf.contains('1'))
    print(bf.contains('2'))

参考

• https://zh.wikipedia.org/wiki/布隆过滤器
• https://www.cnblogs.com/cpselvis/p/6265825.html

本文是用于速查囚徒健身”六艺”的手册

俯卧撑

升级表

第一式 墙壁俯卧撑

第二式 上斜俯卧撑

第三式 膝盖俯卧撑

第四式 半俯卧撑

第五式 标准俯卧撑

第六式 窄距俯卧撑

第七式 偏重俯卧撑

第八式 单臂半俯卧撑

第九式 杠杆俯卧撑

最终式 单臂俯卧撑

深蹲

升级表

第一式 肩倒立深蹲

第二式 折刀深蹲

第三式 支撑深蹲

第四式 半深蹲

第五式 标准深蹲

第六式 窄距深蹲

第七式 偏重深蹲

第八式 单腿半深蹲

第九式 单腿辅助深蹲

最终式 单腿深蹲

引体向上

升级表

第一式 垂直引体

第二式 水平引体向上

第三式 折刀引体向上

第四式 半引体向上

第五式 标准引体向上

第六式 窄距引体向上

第七式 偏重引体向上

第八式 单臂半引体向上

第九式 单臂辅助引体向上

最终式 单臂引体向上

举腿

升级表

第一式 坐姿屈膝

第二式 平卧抬膝

第三式 平卧屈举腿

第四式 平卧蛙举腿

第五式 平卧直举腿

第六式 悬垂屈膝

第七式 悬垂屈举腿

第八式 悬垂蛙举腿

第九式 悬垂半举腿

最终式 悬垂直举腿

桥

升级表