敏感词检测

https://github.com/houbb/sensitive-word.git

汉字转拼音

https://github.com/houbb/pinyin

中文分词

https://github.com/houbb/segment

简繁转换

https://github.com/houbb/opencc4j

汉字相似性

https://github.com/houbb/nlp-hanzi-similar

单词拼写检查

https://github.com/houbb/word-checker

标记-清除

将存活的对象进行标记，然后清理掉未被标记的对象。

不足:

• 标记和清除过程效率都不高；
• 会产生大量不连续的内存碎片，导致无法给大对象分配内存。

标记-整理

让所有存活的对象都向一端移动，然后直接清理掉端边界以外的内存。

复制

将内存划分为大小相等的两块，每次只使用其中一块，当这一块内存用完了就将还存活的对象复制到另一块上面，然后再把使用过的内存空间进行一次清理。

主要不足是只使用了内存的一半。

分代收集策略

JDK1.8采用分代收集策略

$ java -XX:+PrintCommandLineFlags -version...UseParallelGC = Parallel Scavenge + Parallel Old

分代收集是根据对象的存活时间把内存分为新生代和老年代，根据个代对象的存活特点，每个代采用不同的垃圾回收算法。新生代采用标记—复制算法，老年代采用标记—整理算法。

import java.util.UUID;/** * @author 小怪兽 * @version 1.0 * @since 2022-11-15 */public class Jmap {    private byte[] buffer = new byte[500*1024];    private String h = UUID.randomUUID().toString();    public static void main(String[] args) throws Exception {        int n = 100000;        for (int i = 0; i < n; i++) {            Jmap jmap = new Jmap();            Thread.sleep(10);        }    }}

可以使用如下脚本监控jvm的内存使用情况

pid=`jps | grep Jmap | awk '{print $1}'`echo PID: $pidwatch -n 2 -d "jmap -heap $pid"

Every 2.0s: jmap -heap 25834                                                                                                         Tue Nov 15 23:31:43 2022Attaching to process ID 25834, please wait...Debugger attached successfully.Server compiler detected.JVM version is 25.202-b08using thread-local object allocation.Parallel GC with 13 thread(s)Heap Configuration:   MinHeapFreeRatio         = 0   MaxHeapFreeRatio         = 100   MaxHeapSize              = 16846422016 (16066.0MB)   NewSize                  = 351272960 (335.0MB)   MaxNewSize               = 5615124480 (5355.0MB)   OldSize                  = 703594496 (671.0MB)   NewRatio                 = 2   SurvivorRatio            = 8   MetaspaceSize            = 21807104 (20.796875MB)   CompressedClassSpaceSize = 1073741824 (1024.0MB)   MaxMetaspaceSize         = 17592186044415 MB   G1HeapRegionSize         = 0 (0.0MB)Heap Usage:PS Young GenerationEden Space:   capacity = 264241152 (252.0MB)   used     = 95229184 (90.817626953125MB)     free     = 169011968 (161.182373046875MB)     36.038740854414684% usedFrom Space:   capacity = 43515904 (41.5MB)   used     = 0 (0.0MB)   free     = 43515904 (41.5MB)   0.0% usedTo Space:   capacity = 43515904 (41.5MB)   used     = 0 (0.0MB)   free     = 43515904 (41.5MB)   0.0% usedPS Old Generation   capacity = 703594496 (671.0MB)   used     = 0 (0.0MB)   free     = 703594496 (671.0MB)   0.0% used1070 interned Strings occupying 78624 bytes.

Heap Usage:PS Young GenerationEden Space:   capacity = 264241152 (252.0MB)   used     = 206210320 (196.65748596191406MB)   free     = 58030832 (55.34251403808594MB)   78.03868490552145% usedFrom Space:   capacity = 43515904 (41.5MB)   used     = 0 (0.0MB)   free     = 43515904 (41.5MB)   0.0% usedTo Space:   capacity = 43515904 (41.5MB)   used     = 0 (0.0MB)   free     = 43515904 (41.5MB)   0.0% usedPS Old Generation   capacity = 703594496 (671.0MB)   used     = 0 (0.0MB)   free     = 703594496 (671.0MB)   0.0% used1070 interned Strings occupying 78624 bytes.

Heap Usage:PS Young GenerationEden Space:   capacity = 264241152 (252.0MB)   used     = 264241152 (252.0MB)                free     = 0 (0.0MB)                        100.0% used            From Space:   capacity = 43515904 (41.5MB)   used     = 0 (0.0MB)   free     = 43515904 (41.5MB)   0.0% usedTo Space:   capacity = 43515904 (41.5MB)   used     = 0 (0.0MB)   free     = 43515904 (41.5MB)   0.0% usedPS Old Generation   capacity = 703594496 (671.0MB)   used     = 0 (0.0MB)   free     = 703594496 (671.0MB)   0.0% used1073 interned Strings occupying 78792 bytes.

Heap Usage:PS Young GenerationEden Space:   capacity = 264241152 (252.0MB)   used     = 10466912 (9.982025146484375MB)   free     = 253774240 (242.01797485351562MB)   3.961121089874752% usedFrom Space:   capacity = 43515904 (41.5MB)   used     = 524320 (0.500030517578125MB)   free     = 42991584 (40.999969482421875MB)   1.204892813441265% usedTo Space:   capacity = 43515904 (41.5MB)   used     = 0 (0.0MB)   free     = 43515904 (41.5MB)   0.0% usedPS Old Generation   capacity = 703594496 (671.0MB)   used     = 8192 (0.0078125MB)   free     = 703586304 (670.9921875MB)   0.0011643070044709389% used1058 interned Strings occupying 77752 bytes.

Heap Usage:PS Young GenerationEden Space:   capacity = 264241152 (252.0MB)   used     = 15956744 (15.217536926269531MB)   free     = 248284408 (236.78246307373047MB)   6.038705129472036% used From Space:   capacity = 43515904 (41.5MB)   used     = 425984 (0.40625MB)   free     = 43089920 (41.09375MB)   0.9789156626506024% usedTo Space:   capacity = 43515904 (41.5MB)   used     = 0 (0.0MB)   free     = 43515904 (41.5MB)   0.0% usedPS Old Generation   capacity = 703594496 (671.0MB)   used     = 8192 (0.0078125MB)   free     = 703586304 (670.9921875MB)   0.0011643070044709389% used1058 interned Strings occupying 77752 bytes.

Heap Usage:PS Young GenerationEden Space:   capacity = 257949696 (246.0MB)   used     = 20690464 (19.731964111328125MB)   free     = 237259232 (226.26803588867188MB)   8.021123622491107% usedFrom Space:   capacity = 524288 (0.5MB)   used     = 442384 (0.4218902587890625MB)   free     = 81904 (0.0781097412109375MB)   84.3780517578125% usedTo Space:   capacity = 1048576 (1.0MB)   used     = 0 (0.0MB)   free     = 1048576 (1.0MB)   0.0% usedPS Old Generation   capacity = 703594496 (671.0MB)   used     = 16384 (0.015625MB)   free     = 703578112 (670.984375MB)   0.0023286140089418777% used1058 interned Strings occupying 77752 bytes.

Heap Usage:PS Young GenerationEden Space:   capacity = 257949696 (246.0MB)   used     = 58366424 (55.662559509277344MB)   free     = 199583272 (190.33744049072266MB)   22.62705671108835% usedFrom Space:   capacity = 43515904 (41.5MB)   used     = 442384 (0.4218902587890625MB)   free     = 43073520 (41.07810974121094MB)   1.0166030332266567% usedTo Space:   capacity = 524288 (0.5MB)      used     = 0 (0.0MB)   free     = 524288 (0.5MB)      0.0% usedPS Old Generation   capacity = 703594496 (671.0MB)   used     = 24576 (0.0234375MB)   free     = 703569920 (670.9765625MB)   0.003492921013412817% used 

可以看出，创建新对象是总是在Eden区操作，随着不断new对象，Eden区内存使用不断上升，当Eden区空间使用达100%时会执行复制算法将对象复制到From区, 虽然From区的容量远小于Eden区但仍然使Eden的内存使用降到了0%，这是因为当Eden区满了之后会触发YoungGC（Minor GC）清理掉垃圾对象。

当再次触发YoungGC（Minor GC）并且From区满了之后会将存活对象复制到To区，就这样循环往复一定次数（默认15次）之后，存活的数据会复制到老年代（Old Generation）

当老年代的内存不足时会触发Old GC(Major GC)

从概念上讲Old GC(Major GC)指的是针对老年代的GC，Full GC指的是对整个堆空间的GC,不过也有说法是Major GC其实等价于Full GC，因为Major GC其实就是老年代空间不足，新生代的对象没法转移到老年代所以需要先对老年代GC，然后再对新生代GC，可以说Major GC的目的就是为了Minor GC，这其实就是Full GC了。

这里老年代空间不足指的探讨，不足指的是老年代空间使用100%还是超过了一定阈值？这个笔者尚没有看到相关定论，后续可以再深究。

参考资料

• https://blog.csdn.net/weixin_40739833/article/details/80717638
• https://blog.csdn.net/yanghenan19870513/article/details/115669223
• https://pdai.tech/md/java/jvm/java-jvm-gc.html#full-gc-的触发条件
• https://cloud.tencent.com/developer/article/1830320
• https://blog.csdn.net/mccand1234/article/details/52078645

class Solution {    /**     * 因为题目说链表节点值是不重复的，所以可以用HashSet存储数组中元素，便于查询     * flag 变量表示当前元素是否属于某个集合，true: 当前元素属于某个集合（组件）， false: 不属于某个集合（组件）     * @param head     * @param nums     * @return     */    public int numComponents(ListNode head, int[] nums) {        Set<Integer> set = new HashSet<>();        for (int num : nums) {            set.add(num);        }        boolean flag = false;        int ans = 0;        while (head != null) {            if (!set.contains(head.val)) {                flag = false;            }            if (set.contains(head.val) && !flag) {                ans++;                flag = true;            }            head = head.next;        }        return ans;    }}

深度优先搜索

版本1

class Solution {    // 上下左右四个方向遍历    int[][] direction = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};    // 记录行，列数    int m, n;    // 标记数组，判断是否已经访问过    boolean[][] visited = null;    public int numIslands(char[][] grid) {        if (grid == null || grid[0].length == 0) {            return 0;        }        int res = 0;        m = grid.length;        n = grid[0].length;        visited = new boolean[m][n];        for (int i = 0; i < m; i++) {            for (int j = 0; j < n; j++) {                if (grid[i][j] == '1' && !visited[i][j]) {                    res++;                    dfs(grid, i, j);                }            }        }        return res;    }    /**     * @param grid     * @param x     * @param y     * @return     */    private boolean dfs(char[][] grid, int x, int y) {        // 如果当前遍历的字符是陆地，则继续访问后续位置        if (grid[x][y] == '1') {            visited[x][y] = true;            // 依次从四个方向分别计算            for (int i = 0; i < 4; i++) {                int newX = x + direction[i][0];                int newy = y + direction[i][1];                if (inArea(newX, newy) && !visited[newX][newy]) {                    if (dfs(grid, newX, newy)) {                        return true;                    }                }            }        }        return false;    }    /**     * 判断当前坐标点是否越界     *     * @param x     * @param y     * @return     */    private boolean inArea(int x, int y) {        return x >= 0 && x < m && y >= 0 && y < n;    }}

版本2

class Solution {    // 上下左右四个方向遍历    int[][] direction = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};    // 记录行，列数    int m, n;    public int numIslands(char[][] grid) {        if (grid == null || grid[0].length == 0) {            return 0;        }        int res = 0;        m = grid.length;        n = grid[0].length;        visited = new boolean[m][n];        for (int i = 0; i < m; i++) {            for (int j = 0; j < n; j++) {                if (grid[i][j] == '1') {                    res++;                    dfs(grid, i, j);                }            }        }        return res;    }    /**     * @param grid     * @param x     * @param y     * @return     */    private boolean dfs(char[][] grid, int x, int y) {        // 如果当前遍历的字符是陆地，则继续访问后续位置        if (grid[x][y] == '1') {            // 一点小改进，直接将当前字符改为0，变相的设置为已访问，节省内存消耗，避免开辟visited内存            //visited[x][y] = true;            grid[x][y] = '0';            // 依次从四个方向分别计算            for (int i = 0; i < 4; i++) {                int newX = x + direction[i][0];                int newy = y + direction[i][1];                if (inArea(newX, newy) && grid[newX][newy] == '1') {                    if (dfs(grid, newX, newy)) {                        return true;                    }                }            }        }        return false;    }    /**     * 判断当前坐标点是否越界     *     * @param x     * @param y     * @return     */    private boolean inArea(int x, int y) {        return x >= 0 && x < m && y >= 0 && y < n;    }}

给你一个 m x n 的矩阵 board ，由若干字符 ‘X’ 和 ‘O’ ，找到所有被 ‘X’ 围绕的区域，并将这些区域里所有的 ‘O’ 用 ‘X’ 填充。

示例 1：

重要的就是这句话，替换的区域一定不与边界相连，所以可以吧与边界相连的区域标记出来，最后没有被标记的O一定就是被X围绕的。

具体过程：

1. 遍历四个边界上的点，分别从每个点出发使用DFS标记(#)与边界点相连的区域
2. 边界遍历完成后，剩下的所有O一定是不与边界相连且被X围绕的
3. 将违背标记的O置为X，将被标记的#还原为O

class Solution {     // 上下左右四个方向遍历    int[][] direction = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};    // 记录行，列数    int m, n;    public void solve(char[][] board) {        if (board == null || board[0].length == 0) {            return;        }        m = board.length;        n = board[0].length;        // 从四个边界的点出发，将所有与边界相连的点标记        for (int i = 0; i <= m-1; i++) {            dfs(board, i, 0);            dfs(board, i, n-1);        }        for (int i = 0; i <= n-1; i++) {            dfs(board, 0, i);            dfs(board, m-1, i);        }        // 上面两个for循环执行后所有与边界相邻的点都会被标记为特殊字符        // 全部遍历一次        // 将所有被标记为#的点重新恢复成O, 仍旧是O的点则一定是被X包围且不与边界相连的，可以置为X        for (int i = 0; i < m; i++) {            for (int j = 0; j < n; j++) {                if (board[i][j] == '#') {                    board[i][j] = 'O';                }else if (board[i][j] == 'O') {                    board[i][j] = 'X';                }            }        }    }    /**     * @param board     * @param x     * @param y     * @return     */    private void dfs(char[][] board, int x, int y) {        // 如果没有越界并且当前字符是'O'则继续递归遍历        if (inArea(x, y) && board[x][y]=='O') {            board[x][y] = '#';            for (int i = 0; i < direction.length; i++) {                int newX = x + direction[i][0];                int newY = y + direction[i][1];                dfs(board, newX, newY);            }        }    }    /**     * 判断当前坐标点是否越界     *     * @param x     * @param y     * @return     */    private boolean inArea(int x, int y) {        return x >= 0 && x < m && y >= 0 && y < n;    }}

使用递归和回溯

AC代码

class Solution {    List<List<Integer>> res = new LinkedList();    Map<String, Integer> memo = new HashMap<>();    public List<List<Integer>> combinationSum(int[] candidates, int target) {        if (candidates.length == 0) {            return res;        }        Arrays.sort(candidates);        f(candidates, target, 0, new LinkedList<>());        return res;    }    void f(int[] candidates, int target, int start, LinkedList<Integer> current) {        // 记忆化搜索，避免重复计算        if (memo.containsKey(generateKey(current))) {            return;        }        if (target == 0) {            res.add(current);            memo.put(generateKey(current), 0);            return;        }        // 因为排序了，所以当当前的target比数组中最小的数还要小时可以认为没有满足的元素了，直接结束当前递归        if (target < candidates[0]) {            return;        }        for (int i = start; i < candidates.length; i++) {            current.addLast(candidates[i]);                        // start == i表示下次计算仍从i位置开始，因为条件要求可以有重复元素            f(candidates, target - candidates[i], i, new LinkedList<>(current));            current.removeLast();        }    }    String generateKey(LinkedList<Integer> current) {        current.sort((a, b) -> a - b);        return current.toString();    }}

典型的递归回溯问题。因为要考虑到要可重复的问题，所以每一次都要重复遍历整个数组，考虑到重复计算问题，需要加上记忆化搜索。

AC代码

class Solution {    List<List<Integer>> res = new LinkedList();    Map<String, Integer> memo = new HashMap<>();    public List<List<Integer>> combinationSum(int[] candidates, int target) {        if (candidates.length == 0) {            return res;        }        Arrays.sort(candidates);        f(candidates, target, 0, new LinkedList<>());        return res;    }    void f(int[] candidates, int target, int start, LinkedList<Integer> current) {        if (target == 0) {            // 记忆化搜索，避免重复计算            if (memo.containsKey(generateKey(current))) {                return;            }            res.add(current);            memo.put(generateKey(current), 0);            return;        }        // 因为排序了，所以当当前的target比数组中最小的数还要小时可以认为没有满足的元素了，直接结束当前递归        if (target < candidates[0]) {            return;        }        for (int i = start; i < candidates.length; i++) {            current.addLast(candidates[i]);            // start == i表示下次计算仍从i位置开始，因为条件要求可以有重复元素            f(candidates, target - candidates[i], i, new LinkedList<>(current));            // 因为i位置的元素已经计算过了，后面再也不会用到了，可以删除            current.removeLast();        }    }    // 计算key的辅助函数    String generateKey(LinkedList<Integer> current) {        current.sort((a, b) -> a - b);        return current.toString();    }}

字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。

示例 1：

输入: s = “abcdefg”, k = 2
输出: “cdefgab”

示例 2：

输入: s = “lrloseumgh”, k = 6
输出: “umghlrlose”

限制：

1 <= k < s.length <= 10000

思路

以k为界，将字符串切分，然后将两部分拼接起来。

代码

class Solution {    public String reverseLeftWords(String s, int n) {        return s.substring(n, s.length()).concat(s.substring(0, n));    }}

原题链接：https://leetcode-cn.com/problems/richest-customer-wealth/

给你一个 m x n 的整数网格 accounts ，其中 accounts[i][j] 是第 i 位客户在第 j 家银行托管的资产数量。返回最富有客户所拥有的 资产总量 。

客户的 资产总量 就是他们在各家银行托管的资产数量之和。最富有客户就是 资产总量 最大的客户。

示例 1：

输入：accounts = [[1,2,3],[3,2,1]]
输出：6
解释：
第 1 位客户的资产总量 = 1 + 2 + 3 = 6
第 2 位客户的资产总量 = 3 + 2 + 1 = 6
两位客户都是最富有的，资产总量都是 6 ，所以返回 6 。

示例 2：

输入：accounts = [[1,5],[7,3],[3,5]]
输出：10
解释：
第 1 位客户的资产总量 = 6
第 2 位客户的资产总量 = 10
第 3 位客户的资产总量 = 8
第 2 位客户是最富有的，资产总量是 10

示例 3：

输入：accounts = [[2,8,7],[7,1,3],[1,9,5]]
输出：17

提示：

m == accounts.length
n == accounts[i].length
1 <= m, n <= 50
1 <= accounts[i][j] <= 100

思路

就是求二维数组每一行的和

代码

class Solution {    public int maximumWealth(int[][] accounts) {        int m = accounts.length;        int n = accounts[0].length;        int[] wealthy = new int[m];        for (int i=0; i<m; i++) {            wealthy[i] = 0;            for (int j=0; j<n; j++) {                wealthy[i] += accounts[i][j];            }            // 方便起见将财富最大值保存在 wealthy[0], 计算完成后直接返回即可            if (wealthy[i] > wealthy[0]) {                wealthy[0] = wealthy[i];            }        }        return welthy[0];    }}

Proplot

安装

pip install proplotconda install -c conda-forge proplot

要使用proplot绘图，必须先调用 figure 或 subplots 。这些是根据同名的 pyplot 命令建模的。跟matplotlib.pyplot 一样，subplots 一次创建一个图形和一个子图网格，而 figure 创建一个空图形，之后可以用子图填充。下面显示了一个只有一个子图的最小示例。

# Simple subplot gridimport numpy as npimport proplot as ppltimport warningswarnings.filterwarnings('ignore')state = np.random.RandomState(51423)data = 2 * (state.rand(100, 5) - 0.5).cumsum(axis=0)fig = pplt.figure()ax = fig.subplot(121)ax.plot(data, lw=2)ax = fig.subplot(122)fig.format(    suptitle='Simple subplot grid', title='Title',    xlabel='x axis', ylabel='y axis')# fig.save('~/example1.png')  # save the figure# fig.savefig('~/example1.png')  # alternative

# Complex gridimport numpy as npimport proplot as ppltstate = np.random.RandomState(51423)data = 2 * (state.rand(100, 5) - 0.5).cumsum(axis=0)array = [  # the "picture" (0 == nothing, 1 == subplot A, 2 == subplot B, etc.)    [1, 1, 2, 2],    [0, 3, 3, 0],]fig = pplt.figure(refwidth=1.8)axs = fig.subplots(array)axs.format(    abc=True, abcloc='ul', suptitle='Complex subplot grid',    xlabel='xlabel', ylabel='ylabel')axs[2].plot(data, lw=2)# fig.save('~/example2.png')  # save the figure# fig.savefig('~/example2.png')  # alternative

# Really complex gridimport numpy as npimport proplot as ppltstate = np.random.RandomState(51423)data = 2 * (state.rand(100, 5) - 0.5).cumsum(axis=0)array = [  # the "picture" (1 == subplot A, 2 == subplot B, etc.)    [1, 1, 2],    [1, 1, 6],    [3, 4, 4],    [3, 5, 5],]fig, axs = pplt.subplots(array, figwidth=5, span=False)axs.format(    suptitle='Really complex subplot grid',    xlabel='xlabel', ylabel='ylabel', abc=True)axs[0].plot(data, lw=2)# fig.save('~/example3.png')  # save the figure# fig.savefig('~/example3.png')  # alternative

# Using a GridSpecimport numpy as npimport proplot as ppltstate = np.random.RandomState(51423)data = 2 * (state.rand(100, 5) - 0.5).cumsum(axis=0)gs = pplt.GridSpec(nrows=2, ncols=2, pad=1)fig = pplt.figure(span=False, refwidth=2)ax = fig.subplot(gs[:, 0])ax.plot(data, lw=2)ax = fig.subplot(gs[0, 1])ax = fig.subplot(gs[1, 1])fig.format(    suptitle='Subplot grid with a GridSpec',    xlabel='xlabel', ylabel='ylabel', abc=True)# fig.save('~/example4.png')  # save the figure# fig.savefig('~/example4.png')  # alternative

​
​

import proplot as ppltimport numpy as npstate = np.random.RandomState(51423)# Selected subplots in a simple gridfig, axs = pplt.subplots(ncols=4, nrows=4, refwidth=1.2, span=True)axs.format(xlabel='xlabel', ylabel='ylabel', suptitle='Simple SubplotGrid')axs.format(grid=False, xlim=(0, 50), ylim=(-4, 4))axs[:, 0].format(facecolor='blush', edgecolor='gray7', linewidth=1)  # eauivalentaxs[:, 0].format(fc='blush', ec='gray7', lw=1)axs[0, :].format(fc='sky blue', ec='gray7', lw=1)axs[0].format(ec='black', fc='gray5', lw=1.4)axs[1:, 1:].format(fc='gray1')for ax in axs[1:, 1:]:    ax.plot((state.rand(50, 5) - 0.5).cumsum(axis=0), cycle='Grays', lw=2)# Selected subplots in a complex gridfig = pplt.figure(refwidth=1, refnum=5, span=False)axs = fig.subplots([[1, 1, 2], [3, 4, 2], [3, 4, 5]], hratios=[2.2, 1, 1])axs.format(xlabel='xlabel', ylabel='ylabel', suptitle='Complex SubplotGrid')axs[0].format(ec='black', fc='gray1', lw=1.4)axs[1, 1:].format(fc='blush')axs[1, :1].format(fc='sky blue')axs[-1, -1].format(fc='gray4', grid=False)axs[0].plot((state.rand(50, 10) - 0.5).cumsum(axis=0), cycle='Grays_r', lw=2)

import proplot as ppltimport numpy as np# Sample dataN = 20state = np.random.RandomState(51423)data = N + (state.rand(N, N) - 0.55).cumsum(axis=0).cumsum(axis=1)# Example plotscycle = pplt.Cycle('greys', left=0.2, N=5)fig, axs = pplt.subplots(ncols=2, nrows=2, figwidth=5, share=False)axs[0].plot(data[:, :5], linewidth=2, linestyle='--', cycle=cycle)axs[1].scatter(data[:, :5], marker='x', cycle=cycle)axs[2].pcolormesh(data, cmap='greys')m = axs[3].contourf(data, cmap='greys')axs.format(    abc='a.', titleloc='l', title='Title',    xlabel='xlabel', ylabel='ylabel', suptitle='Quick plotting demo')fig.colorbar(m, loc='b', label='label')

import proplot as ppltimport numpy as npfig, axs = pplt.subplots(ncols=2, nrows=2, refwidth=2, share=False)state = np.random.RandomState(51423)N = 60x = np.linspace(1, 10, N)y = (state.rand(N, 5) - 0.5).cumsum(axis=0)axs[0].plot(x, y, linewidth=1.5)axs.format(    suptitle='Format command demo',    abc='A.', abcloc='ul',    title='Main', ltitle='Left', rtitle='Right',  # different titles    ultitle='Title 1', urtitle='Title 2', lltitle='Title 3', lrtitle='Title 4',    toplabels=('Column 1', 'Column 2'),    leftlabels=('Row 1', 'Row 2'),    xlabel='xaxis', ylabel='yaxis',    xscale='log',    xlim=(1, 10), xticks=1,    ylim=(-3, 3), yticks=pplt.arange(-3, 3),    yticklabels=('a', 'bb', 'c', 'dd', 'e', 'ff', 'g'),    ytickloc='both', yticklabelloc='both',    xtickdir='inout', xtickminor=False, ygridminor=True,)

​
​

import proplot as ppltimport numpy as np# Update global settings in several different wayspplt.rc.metacolor = 'gray6'pplt.rc.update({'fontname': 'Source Sans Pro', 'fontsize': 11})pplt.rc['figure.facecolor'] = 'gray3'pplt.rc.axesfacecolor = 'gray4'# pplt.rc.save()  # save the current settings to ~/.proplotrc# Apply settings to figure with context()with pplt.rc.context({'suptitle.size': 13}, toplabelcolor='gray6', metawidth=1.5):    fig = pplt.figure(figwidth=6, sharey='limits', span=False)    axs = fig.subplots(ncols=2)# Plot lines with a custom cyclerN, M = 100, 7state = np.random.RandomState(51423)values = np.arange(1, M + 1)cycle = pplt.get_colors('grays', M - 1) + ['red']for i, ax in enumerate(axs):    data = np.cumsum(state.rand(N, M) - 0.5, axis=0)    lines = ax.plot(data, linewidth=3, cycle=cycle)# Apply settings to axes with format()axs.format(    grid=False, xlabel='xlabel', ylabel='ylabel',    toplabels=('Column 1', 'Column 2'),    suptitle='Rc settings demo',    suptitlecolor='gray7',    abc='[A]', abcloc='l',    title='Title', titleloc='r', titlecolor='gray7')# Reset persistent modifications from head of cellpplt.rc.reset()

​

import proplot as ppltimport numpy as np# pplt.rc.style = 'style'  # set the style everywhere# Sample datastate = np.random.RandomState(51423)data = state.rand(10, 5)# Set up figurefig, axs = pplt.subplots(ncols=2, nrows=2, span=False, share=False)axs.format(suptitle='Stylesheets demo')styles = ('ggplot', 'seaborn', '538', 'bmh')# Apply different styles to different axes with format()for ax, style in zip(axs, styles):    ax.format(style=style, xlabel='xlabel', ylabel='ylabel', title=style)    ax.plot(data, linewidth=3)

​
​

SciencePlots

安装

# to install the lastest release (from PyPI)pip install SciencePlots# to install the latest commit (from GitHub)pip install git+https://github.com/garrettj403/SciencePlots# to clone and install from a local copygit clone https://github.com/garrettj403/SciencePlots.gitcd SciencePlotspip install -e .

根据系统不同，需要提前安装latex环境

例子

import numpy as npimport matplotlibimport matplotlib.pyplot as pltmatplotlib.style.reload_library()matplotlib.rcParams['axes.unicode_minus'] = Falsedef model(x, p):    return x ** (2 * p + 1) / (1 + x ** (2 * p))pparam = dict(xlabel='Voltage (mV)', ylabel='Current ($\mu$A)')x = np.linspace(0.75, 1.25, 201)

with plt.style.context(['science']):    fig, ax = plt.subplots()    for p in [10, 15, 20, 30, 50, 100]:        ax.plot(x, model(x, p), label=p)    ax.legend(title='Order')    # ax.autoscale(tight=True)    ax.set(**pparam)    # fig.savefig('figures/fig1.pdf')    fig.savefig('figures/fig1.jpg', dpi=300)

with plt.style.context(['science', 'ieee', 'notebook']):    fig, ax = plt.subplots()    for p in [10, 20, 40, 100]:        ax.plot(x, model(x, p), label=p)    ax.legend(title='Order')    ax.autoscale(tight=True)    ax.set(**pparam)    # Note: $\mu$ doesn't work with Times font (used by ieee style)    ax.set_ylabel(r'$Current (\mu A)$')      # fig.savefig('figures/fig2a.pdf')    fig.savefig('figures/fig2a.jpg', dpi=300)

​
​

with plt.style.context(['science', 'ieee', 'std-colors', 'notebook']):    fig, ax = plt.subplots()    for p in [10, 15, 20, 30, 50, 100]:        ax.plot(x, model(x, p), label=p)    ax.legend(title='Order')    ax.autoscale(tight=True)    ax.set(**pparam)    # Note: $\mu$ doesn't work with Times font (used by ieee style)    ax.set_ylabel(r'$Current (\mu A)$')      # fig.savefig('figures/fig2b.pdf')    fig.savefig('figures/fig2b.jpg', dpi=300)

​

with plt.style.context(['science', 'high-vis', 'notebook']):    fig, ax = plt.subplots()    for p in [10, 15, 20, 30, 50, 100]:        ax.plot(x, model(x, p), label=p)    ax.legend(title='Order')    ax.autoscale(tight=True)    ax.set(**pparam)    # fig.savefig('figures/fig4.pdf')    fig.savefig('figures/fig4.jpg', dpi=300)

​

with plt.style.context(['dark_background', 'science', 'high-vis', 'notebook']):    fig, ax = plt.subplots()    for p in [10, 15, 20, 30, 50, 100]:        ax.plot(x, model(x, p), label=p)    ax.legend(title='Order')    ax.autoscale(tight=True)    ax.set(**pparam)    # fig.savefig('figures/fig5.pdf')    fig.savefig('figures/fig5.jpg', dpi=300)

​
​

with plt.style.context(['science', 'notebook']):    fig, ax = plt.subplots()    for p in [10, 15, 20, 30, 50, 100]:        ax.plot(x, model(x, p), label=p)    ax.legend(title='Order')    ax.autoscale(tight=True)    ax.set(**pparam)    # fig.savefig('figures/fig10.pdf')    fig.savefig('figures/fig10.jpg', dpi=300)

​
​

with plt.style.context(['science', 'bright', 'notebook']):    fig, ax = plt.subplots()    for p in [5, 10, 15, 20, 30, 50, 100]:        ax.plot(x, model(x, p), label=p)    ax.legend(title='Order')    ax.autoscale(tight=True)    ax.set(**pparam)    # fig.savefig('figures/fig6.pdf')    fig.savefig('figures/fig6.jpg', dpi=300)

​
​
​

with plt.style.context(['science', 'muted', 'notebook']):    fig, ax = plt.subplots()    for p in [5, 7, 10, 15, 20, 30, 38, 50, 100, 500]:        ax.plot(x, model(x, p), label=p)    ax.legend(title='Order', fontsize=7)    ax.autoscale(tight=True)    ax.set(**pparam)    # fig.savefig('figures/fig8.pdf')    fig.savefig('figures/fig8.jpg', dpi=300)

with plt.style.context(['science', 'grid', 'notebook']):    fig, ax = plt.subplots()    for p in [10, 15, 20, 30, 50, 100]:        ax.plot(x, model(x, p), label=p)    ax.legend(title='Order')    ax.autoscale(tight=True)    ax.set(**pparam)    # fig.savefig('figures/fig11.pdf')    fig.savefig('figures/fig11.jpg', dpi=300)

​
​

with plt.style.context(['science', 'high-contrast', 'notebook']):    fig, ax = plt.subplots()    for p in [10, 20, 50]:        ax.plot(x, model(x, p), label=p)    ax.legend(title='Order')    ax.autoscale(tight=True)    ax.set(**pparam)    # fig.savefig('figures/fig12.pdf')    fig.savefig('figures/fig12.jpg', dpi=300)

​

with plt.style.context(['science', 'light', 'notebook']):    fig, ax = plt.subplots()    for p in [5, 7, 10, 15, 20, 30, 38, 50, 100]:        ax.plot(x, model(x, p), label=p)    ax.legend(title='Order', fontsize=7)    ax.autoscale(tight=True)    ax.set(**pparam)    # fig.savefig('figures/fig13.pdf')    fig.savefig('figures/fig13.jpg', dpi=300)

​
​

参考资料

• https://proplot.readthedocs.io
• https://github.com/garrettj403/SciencePlots

plotly 是一个交互式可视化库。

1. plotly安装

pip install plotly# 或conda install -c plotly plotly=5.4.0

1.1. 安装jupyter lab支持

pip install "jupyterlab>=3" "ipywidgets>=7.6"# 或conda install "jupyterlab>=3" "ipywidgets>=7.6"jupyter labextension install jupyterlab-plotly@5.4.0 @jupyter-widgets/jupyterlab-manager

1.2. 安装jupyter支持

pip install "notebook>=5.3" "ipywidgets>=7.5"# 或conda install "notebook>=5.3" "ipywidgets>=7.5"

2. Plotly 生态

Plotly 是绘图基础库，它可以深度定制调整绘图，但是 API 复杂学习成本较高。 Plotly_exprress 则是对 Plotly 的高级封装，上手容易，它对 Plotly 的常用绘图函数进行了封装。缺点是没有 plotly 那样自由度高，个人感觉类似 Seaborn 和 Matplotlib 的关系。本文不以express为主。 Dash 用于创建交互式绘图工具，可以方便地用它来探索数据，其绘图基于 Plotly。使用 Dash 需要注册并购买套餐，也就是常说的“在线模式”，一般，我们在 Jupyter 内本地绘图就够用了，这是“离线模式”。

3. 画图案例

在画图之前需要先创建画布go.Figure，可以在构造参数中通过data参数指定相关图形也可以后续通过add_trace方法添加

3.1. 散点图

import numpy as npimport plotly.graph_objects as gox = np.linspace(0, 100, 1000)y = np.sin(x)x1 = np.arange(1, 100)y1 = np.random.random(100)# 创建画布，在构造函数中通过data参数指定图形fig = go.Figure(data=go.Scatter(x=x, y=y, mode="markers", name="sign"))# fig.add_trace(go.Scatter(x=x1, y=y1, name='random'))# 显示图像fig.show()

3.2. 折线图

# 创建画布fig = go.Figure()# 添加图层fig.add_trace(go.Scatter(x=x1, y=y1, name="折线图"))fig.show()

3.3. 添加子图

plotly.subplots.make_subplots() 函数生成一个图形对象图形，该图形对象图形预先配置了可以添加跟踪的子图网格。 add_trace() 函数将在下面详细讨论。

from plotly.subplots import make_subplotsfig = make_subplots(rows=1, cols=2)fig.add_trace(go.Scatter(y=[4, 2, 1], mode="lines"), row=1, col=1)fig.add_trace(go.Bar(y=[2, 1, 3]), row=1, col=2)fig.show()

3.4. 添加跟踪（图层）

可以使用 add_trace() 方法将新跟踪添加到图形对象图形中。此方法接受图形对象跟踪（go.Scatter、go.Bar 等的实例）并将其添加到图形中。这允许您从一个空图形开始，并按顺序向其中添加跟踪。 append_trace() 方法做同样的事情，虽然它不返回数字。

# 创建画布（空图层）fig = go.Figure()fig.add_trace(go.Bar(x=x1, y=y1))fig.show()

import plotly.express as pxdf = px.data.iris()fig = px.scatter(    df,    x="sepal_width",    y="sepal_length",    color="species",    title="Using The add_trace() method With A Plotly Express Figure",)fig.add_trace(    go.Scatter(        x=[2, 4],        y=[4, 8],        mode="lines",        line=go.scatter.Line(color="gray"),        showlegend=False,    ))fig.show()

多次调用add_trace可添加多个图层

fig = go.Figure()fig.add_trace(go.Bar(x=x1, y=y1))fig.add_trace(go.Scatter(x=x, y=y))fig.show()

3.5. 向子图添加Trace（图层）

向子图添加跟踪 如果图形是使用 plotly.subplots.make_subplots() 创建的，则向 add_trace() 提供 row 和 col 参数可用于向特定子图添加跟踪。

from plotly.subplots import make_subplotsfig = make_subplots(rows=1, cols=2)fig.add_trace(go.Scatter(y=[4, 2, 1], mode="lines"), row=1, col=1)fig.add_trace(go.Bar(y=[2, 1, 3]), row=1, col=2)fig.show()

这也适用于 Plotly Express 使用 facet_row 和或 facet_col 参数创建的图形。

import plotly.express as pxdf = px.data.iris()fig = px.scatter(    df,    x="sepal_width",    y="sepal_length",    color="species",    facet_col="species",    title="Adding Traces To Subplots Witin A Plotly Express Figure",)reference_line = go.Scatter(    x=[2, 4],    y=[4, 8],    mode="lines",    line=go.scatter.Line(color="gray"),    showlegend=False,)fig.add_trace(reference_line, row=1, col=1)fig.add_trace(reference_line, row=1, col=2)fig.add_trace(reference_line, row=1, col=3)fig.show()

3.6. 添加图层简便方法

作为 add_trace() 方法的替代方法，图形对象图形具有一系列形式为 add_{trace}（其中 {trace} 是跟踪类型的名称）的方法，用于构建和添加每种跟踪类型的跟踪。 这是前面的子图示例，适用于使用 fig.add_scatter() 添加散点跟踪并使用 fig.add_bar() 添加条形跟踪。

from plotly.subplots import make_subplotsfig = make_subplots(rows=1, cols=2)fig.add_scatter(y=y, mode="lines", row=1, col=1)fig.add_bar(y=y1, row=1, col=2)fig.show()

3.7. 魔术下划线符号

为了更轻松地使用嵌套属性，图形对象构造函数和许多图形对象方法支持魔术下划线表示法。

这允许您通过将多个嵌套属性名称与下划线连接在一起来引用嵌套属性。

例如，在没有魔术下划线符号的图形构造函数中指定图形标题需要将布局参数设置为 dict(title=dict(text="A Chart"))。 同样，设置散点轨迹的线条颜色需要将标记属性设置为 dict(color="crimson")。

import plotly.graph_objects as gofig = go.Figure(    data=[go.Scatter(y=[1, 3, 2], line=dict(color="crimson"))],    layout=dict(        title=dict(text="A Graph Objects Figure Without Magic Underscore Notation")    ),)fig.show()

使用魔术下划线表示法，您可以通过向图形构造函数传递名为 layout_title_text 的关键字参数，并通过向 go.Scatter 构造函数传递名为 line_color 的关键字参数来完成相同的事情。

import plotly.graph_objects as gofig = go.Figure(    data=[go.Scatter(y=[1, 3, 2], line_color="crimson")],    layout_title_text="A Graph Objects Figure With Magic Underscore Notation",)fig.show()

整个图形对象 API 都支持魔术下划线符号，它通常可以显着简化涉及深度嵌套属性的操作。

注意：当您看到传递给图形对象构造函数或方法的带下划线的关键字参数时，几乎总是可以安全地假设它是魔术下划线符号的应用。我们不得不说“几乎总是”而不是“总是”，因为 plotly 模式中有一些属性名称包含下划线：error_x、error_y、error_z、copy_xstyle、copy_ystyle、copy_zstyle、paper_bgcolor 和 plot_bgcolor。这些是在图书馆的早期（2012-2013）添加回来的，然后我们标准化了禁止属性名称中的下划线。

3.8. 更新图形（画布）布局

图形对象图形支持 update_layout() 方法，该方法可用于更新图形布局的多个嵌套属性。 这是使用 update_layout() 更新图形标题的文本和字体大小的示例。

import plotly.graph_objects as gofig = go.Figure(data=go.Bar(x=[1, 2, 3], y=[1, 3, 2]))fig.update_layout(title_text="使用 update_layout() 更新图形", title_font_size=30)fig.show()

请注意，以下 update_layout() 操作是等效的：

fig.update_layout(title_text="update_layout() Syntax Example", title_font_size=30)fig.update_layout(title_text="update_layout() Syntax Example", title_font=dict(size=30))fig.update_layout(title=dict(text="update_layout() Syntax Example"), font=dict(size=30))fig.update_layout(    {"title": {"text": "update_layout() Syntax Example", "font": {"size": 30}}})fig.update_layout(    title=go.layout.Title(        text="update_layout() Syntax Example", font=go.layout.title.Font(size=30)    ))

更新图层（trace）大小

import numpy as npimport plotly.graph_objs as gox = np.linspace(-20, 20)y = np.sin(x)trace1 = go.Scatter(    x=x,  # x-coordinates of trace    y=y,  # y-coordinates of trace    mode="markers +text ",  # scatter mode (more in UG section 1)    opacity=1,    textposition="top center",    marker=dict(size=12, line=dict(width=0.5)),    textfont=dict(        color="black",        size=18,  # can change the size of font here        family="Times New Roman",    ),)data = [trace1]layout = go.Layout(    autosize=False,    width=1000,  # 设置画布宽度    height=800,  # 设置画布高度    xaxis=go.layout.XAxis(        linecolor="black", linewidth=3, mirror=True  # 设置X轴线宽    ),  # 上下X轴是否一样    yaxis=go.layout.YAxis(        linecolor="black", linewidth=6, mirror=False  # 设置Y轴线宽    ),  # 左右Y轴是否一样    margin=go.layout.Margin(l=50, r=50, b=100, t=100, pad=4),)fig = go.Figure(data=data, layout=layout)fig.show()

3.9. 批量更新追踪（图层）

图形对象图形支持 update_traces() 方法，该方法可用于更新图形的一个或多个轨迹的多个嵌套属性。 为了展示一些示例，我们将从一个包含跨越两个子图的条形和散点轨迹的图形开始。

from plotly.subplots import make_subplotsfig = make_subplots(rows=1, cols=2)fig.add_scatter(    y=[4, 2, 3.5],    mode="markers",    marker=dict(size=20, color="LightSeaGreen"),    name="a",    row=1,    col=1,)fig.add_bar(y=[2, 1, 3], marker=dict(color="MediumPurple"), name="b", row=1, col=1)fig.add_scatter(    y=[2, 3.5, 4],    mode="markers",    marker=dict(size=20, color="MediumPurple"),    name="c",    row=1,    col=2,)fig.add_bar(y=[1, 3, 2], marker=dict(color="LightSeaGreen"), name="d", row=1, col=2)fig.show()

请注意，散点图和条形图都有一个marker.color 属性来控制它们的颜色。以下是使用 update_traces() 修改所有轨迹颜色的示例。

from plotly.subplots import make_subplotsfig = make_subplots(rows=1, cols=2)fig.add_scatter(    y=[4, 2, 3.5],    mode="markers",    marker=dict(size=20, color="LightSeaGreen"),    name="a",    row=1,    col=1,)fig.add_bar(y=[2, 1, 3], marker=dict(color="MediumPurple"), name="b", row=1, col=1)fig.add_scatter(    y=[2, 3.5, 4],    mode="markers",    marker=dict(size=20, color="MediumPurple"),    name="c",    row=1,    col=2,)fig.add_bar(y=[1, 3, 2], marker=dict(color="LightSeaGreen"), name="d", row=1, col=2)fig.update_traces(marker=dict(color="RoyalBlue"))fig.show()

update_traces() 方法支持一个选择器参数来控制应该更新哪些跟踪。只有具有与选择器匹配的属性的跟踪才会更新。这是使用选择器仅更新条形轨迹颜色的示例。

from plotly.subplots import make_subplotsfig = make_subplots(rows=1, cols=2)fig.add_scatter(    y=[4, 2, 3.5],    mode="markers",    marker=dict(size=20, color="LightSeaGreen"),    name="a",    row=1,    col=1,)fig.add_bar(y=[2, 1, 3], marker=dict(color="MediumPurple"), name="b", row=1, col=1)fig.add_scatter(    y=[2, 3.5, 4],    mode="markers",    marker=dict(size=20, color="MediumPurple"),    name="c",    row=1,    col=2,)fig.add_bar(y=[1, 3, 2], marker=dict(color="LightSeaGreen"), name="d", row=1, col=2)fig.update_traces(marker=dict(color="RoyalBlue"), selector=dict(type="bar"))fig.show()

可以在选择器中使用魔术下划线符号来匹配嵌套属性。这是一个更新所有正式着色为 "MediumPurple" 的跟踪颜色的示例。

from plotly.subplots import make_subplotsfig = make_subplots(rows=1, cols=2)fig.add_scatter(    y=[4, 2, 3.5],    mode="markers",    marker=dict(size=20, color="LightSeaGreen"),    name="a",    row=1,    col=1,)fig.add_bar(y=[2, 1, 3], marker=dict(color="MediumPurple"), name="b", row=1, col=1)fig.add_scatter(    y=[2, 3.5, 4],    mode="markers",    marker=dict(size=20, color="MediumPurple"),    name="c",    row=1,    col=2,)fig.add_bar(y=[1, 3, 2], marker=dict(color="LightSeaGreen"), name="d", row=1, col=2)fig.update_traces(marker_color="RoyalBlue", selector=dict(marker_color="MediumPurple"))fig.show()

对于带有子图的图形，update_traces() 方法还支持 row 和 col 参数来控制应更新哪些跟踪。只会更新指定子图行和列中的轨迹。这是更新第二个子图列中所有轨迹颜色的示例。

from plotly.subplots import make_subplotsfig = make_subplots(rows=1, cols=2)fig.add_scatter(    y=[4, 2, 3.5],    mode="markers",    marker=dict(size=20, color="LightSeaGreen"),    name="a",    row=1,    col=1,)fig.add_bar(y=[2, 1, 3], marker=dict(color="MediumPurple"), name="b", row=1, col=1)fig.add_scatter(    y=[2, 3.5, 4],    mode="markers",    marker=dict(size=20, color="MediumPurple"),    name="c",    row=1,    col=2,)fig.add_bar(y=[1, 3, 2], marker=dict(color="LightSeaGreen"), name="d", row=1, col=2)fig.update_traces(marker=dict(color="RoyalBlue"), col=2)fig.show()

update_traces() 方法也可用于图形工厂或 Plotly Express 生成的图形。这是将 Plotly Express 生成的回归线更新为虚线的示例。

import pandas as pdimport plotly.express as pxdf = px.data.iris()fig = px.scatter(    df,    x="sepal_width",    y="sepal_length",    color="species",    facet_col="species",    trendline="ols",    title="Using update_traces() With Plotly Express Figures",)fig.update_traces(    line=dict(dash="dot", width=4), selector=dict(type="scatter", mode="lines"))fig.show()

4. 使用更新方法时覆盖现有属性

update_layout() 和 update_traces() 有一个 overwrite 关键字参数，默认为 False，在这种情况下，更新将递归应用于现有的嵌套属性结构。设置为 True 时，现有属性的先前值将被提供的值覆盖。

在下面的示例中，在 update_traces() 中使用 overwrite=True 更新标记时，标记的红色会被覆盖。请注意，使用魔术下划线代替marker_opacity设置不会覆盖marker_color，因为属性将仅在marker.opacity 级别开始被覆盖。

import plotly.graph_objects as gofig = go.Figure(    go.Bar(x=[1, 2, 3], y=[6, 4, 9], marker_color="red"))  # will be overwritten belowfig.update_traces(overwrite=True, marker={"opacity": 0.4})fig.show()

4.1. 有条件地更新跟踪

假设您要对跟踪集合进行的更新取决于某些跟踪属性的当前值。 update_traces() 方法不能处理这种情况，但是 for_each_trace() 方法可以！

作为它的第一个参数，for_each_trace() 方法接受一个函数，该函数一次接受和更新一个跟踪。与 update_traces() 一样，for_each_trace() 也接受选择器、行和列参数来控制应考虑哪些跟踪。

这是使用 for_each_trace() 将“setosa”的唯一标记转换为 Plotly Express 图形中的方形符号的示例。

import pandas as pdimport plotly.express as pxdf = px.data.iris()fig = px.scatter(    df,    x="sepal_width",    y="sepal_length",    color="species",    title="Conditionally Updating Traces In A Plotly Express Figure With for_each_trace()",)fig.for_each_trace(    lambda trace: trace.update(marker_symbol="square")    if trace.name == "setosa"    else (),)fig.show()

4.2. 更新图形轴

图形对象图形支持 update_xaxes() 和 update_yaxes() 方法，这些方法可用于更新图形的一个或多个轴的多个嵌套属性。这是使用 update_xaxes() 禁用 Plotly Express 生成的图中所有子图中的垂直网格线的示例。

import pandas as pdimport plotly.express as pxdf = px.data.iris()fig = px.scatter(    df,    x="sepal_width",    y="sepal_length",    color="species",    facet_col="species",    title="Using update_xaxes() With A Plotly Express Figure",)fig.update_xaxes(showgrid=False)fig.show()

还有类似于上述 for_each_trace() 方法的 for_each_xaxis() 和 for_each_yaxis() 方法。对于非笛卡尔子图类型（例如 polar），还有额外的 update_{type} 和 for_each_{type} 方法（例如 update_polar()、for_each_polar()）。

5. 链式表达

上面描述的所有图形更新操作都是返回对正在修改的图形的引用的方法。这使得可以将多个图形修改操作链接到单个表达式中。

import plotly.express as pxdf = px.data.iris()(    px.scatter(        df,        x="sepal_width",        y="sepal_length",        color="species",        facet_col="species",        trendline="ols",        title="Chaining Multiple Figure Operations With A Plotly Express Figure",    )    .update_layout(title_font_size=24)    .update_xaxes(showgrid=False)    .update_traces(        line=dict(dash="dot", width=4), selector=dict(type="scatter", mode="lines")    )).show()

6. 属性分配

可以使用属性分配语法更新跟踪和布局属性。这是使用属性分配设置图形标题的示例。

6.1. 修改图形样式，颜色

import plotly.graph_objects as gofig = go.Figure(data=go.Bar(x=[1, 2, 3], y=[1, 3, 2]))fig.layout.title.text = "Using Property Assignment Syntax With A Graph Object Figure"fig.show()

这是使用属性分配更新条形轮廓的示例。

import plotly.graph_objects as gofig = go.Figure(data=go.Bar(x=[1, 2, 3], y=[1, 3, 2]))fig.data[0].marker.line.width = 4fig.data[0].marker.line.color = "black"fig.show()

That’s all!

通常我们使用docker 都是在服务器端pull镜像然后根据镜像创建容器。对于自开发的应用，如果想要将其创建为docker镜像一般需要将应用编译打包后编写Dockerfile文件使用docker build命令构建成docker镜像。对于每次的版本升级和功能迭代都需要重复这些步骤，因此最好将这些操作流程化和自动化。

可以对docker进行相关配置，客户端可远程对docker服务进行操作。

If you need to access the Docker daemon remotely, you need to enable the tcp Socket. Beware that the default setup provides un-encrypted and un-authenticated direct access to the Docker daemon - and should be secured either using the built in HTTPS encrypted socket, or by putting a secure web proxy in front of it. You can listen on port 2375 on all network interfaces with -H tcp://0.0.0.0:2375, or on a particular network interface using its IP address: -H tcp://192.168.59.103:2375. It is conventional to use port 2375 for un-encrypted, and port 2376 for encrypted communication with the daemon.

最简单的方式就是将docker向外暴露。

# vim /usr/lib/systemd/system/docker.service...第13行ExecStart=/usr/bin/dockerd -H fd:// \    -H tcp://0.0.0.0:2375 \    --containerd=/run/containerd/containerd.sock...# service docker restart

但是，这样的方式没有任何防护，是非常不安全的，因为docker默认是以root用户启动的，一旦黑客通过docker服务对服务器进行攻击，很容易拿到服务器的root权限从而造成严重的后果。因此最好对docker服务进行加密，只有拿到加密证书的客户端才能对服务端进行操作。

具体步骤

• 创建加密证书
• 配置docker服务使用加密方式
• 客户端连接时指定证书

官方文档：

• https://docs.docker.com/engine/reference/commandline/dockerd/#:~:text=Examples-,Daemon socket option,-🔗
• https://docs.docker.com/engine/security/protect-access/#:~:text=CControlPersist yes-,Use TLS (HTTPS) to protect the Docker daemon socket,-🔗

生成证书

$ HOST=example.com$ openssl genrsa -aes256 -out ca-key.pem 4096Generating RSA private key, 4096 bit long modulus (2 primes)..........++++.........................................................................................................................................................................................++++e is 65537 (0x010001)Enter pass phrase for ca-key.pem:Verifying - Enter pass phrase for ca-key.pem:$ openssl req -new -x509 -days 365 -key ca-key.pem -sha256 -out ca.pemEnter pass phrase for ca-key.pem:You are about to be asked to enter information that will be incorporatedinto your certificate request.What you are about to enter is what is called a Distinguished Name or a DN.There are quite a few fields but you can leave some blankFor some fields there will be a default value,If you enter '.', the field will be left blank.-----Country Name (2 letter code) [AU]:CNState or Province Name (full name) [Some-State]:BeijingLocality Name (eg, city) []:ChaoyangOrganization Name (eg, company) [Internet Widgits Pty Ltd]:ZNHOrganizational Unit Name (eg, section) []:Common Name (e.g. server FQDN or YOUR name) []:Email Address []:alayama@163.com$ openssl genrsa -out server-key.pem 4096Generating RSA private key, 4096 bit long modulus (2 primes)........................................................................................................................................................++++...............................................++++e is 65537 (0x010001)$ openssl req -subj "/CN=$HOST" -sha256 -new -key server-key.pem -out server.csr$ echo subjectAltName = DNS:$HOST,IP:127.0.0.1 >> extfile.cnf$ echo extendedKeyUsage = serverAuth >> extfile.cnf$ openssl x509 -req -days 365 -sha256 -in server.csr -CA ca.pem -CAkey ca-key.pem -CAcreateserial -out server-cert.pem -extfile extfile.cnfSignature oksubject=CN = example.comGetting CA Private KeyEnter pass phrase for ca-key.pem:$ openssl genrsa -out key.pem 4096Generating RSA private key, 4096 bit long modulus (2 primes).........................................................................................................................................................................................++++................++++e is 65537 (0x010001)$ openssl req -subj '/CN=client' -new -key key.pem -out client.csr$ echo extendedKeyUsage = clientAuth > extfile-client.cnf$ openssl x509 -req -days 365 -sha256 -in client.csr -CA ca.pem -CAkey ca-key.pem -CAcreateserial -out cert.pem -extfile extfile-client.cnfSignature oksubject=CN = clientGetting CA Private KeyEnter pass phrase for ca-key.pem:$ rm -v client.csr server.csr extfile.cnf extfile-client.cnfrm: remove regular file ‘client.csr’? yremoved ‘client.csr’rm: remove regular file ‘server.csr’? yremoved ‘server.csr’rm: remove regular file ‘extfile.cnf’? yremoved ‘extfile.cnf’rm: remove regular file ‘extfile-client.cnf’? yremoved ‘extfile-client.cnf’$ chmod -v 0400 ca-key.pem key.pem server-key.pemmode of ‘ca-key.pem’ changed from 0600 (rw-------) to 0400 (r--------)mode of ‘key.pem’ changed from 0600 (rw-------) to 0400 (r--------)mode of ‘server-key.pem’ changed from 0600 (rw-------) to 0400 (r--------)$ chmod -v 0444 ca.pem server-cert.pem cert.pemmode of ‘ca.pem’ changed from 0644 (rw-r--r--) to 0444 (r--r--r--)mode of ‘server-cert.pem’ changed from 0644 (rw-r--r--) to 0444 (r--r--r--)mode of ‘cert.pem’ changed from 0644 (rw-r--r--) to 0444 (r--r--r--)

配置docker使用加密方式

$ vim /usr/lib/systemd/system/docker.service...第左右13行ExecStart=/usr/bin/dockerd -H fd:// \--tlsverify --tlscacert=/data/docker_cert/ca.pem \--tlscert=/data/docker_cert/server-cert.pem \--tlskey=/data/docker_cert/server-key.pem \-H tcp://0.0.0.0:2376 \--containerd=/run/containerd/containerd.sock...$ service docker restart

按照官方说法，docker默认使用2375端口作为非加密方式的访问端口，2376端口作为加密端口，且不支持自定义修改。

对于云服务器，需要放开相关的端口外部才可以访问。

对于公司内网环境，直接使用默认端口就好，但是对于外网环境建议再对2376端口进行转发避免黑客对指定端口进行攻击。

可以在浏览器使用https://$HOST:PORT进行测试，如果提示证书不正确说明配置成功，只有拿到证书的客户端才可以访问远程docker服务。

IDEA连接远程Docker

将ca.pem，cert.pem，key.pem三个证书下载到本地。

在IDEA中打开File->Settings->Docker，填写URL和证书目录，

配置maven docker插件

<plugin><groupId>io.fabric8</groupId>    <artifactId>docker-maven-plugin</artifactId></plugin>

这个插件功能很丰富，可定制化程度更高，具体配置如下：

<plugin>    <groupId>io.fabric8</groupId>    <artifactId>docker-maven-plugin</artifactId>    <version>0.39.1</version>    <configuration>        <certPath>C:\Code\cert</certPath>        <dockerHost>https://xxxxxxxxxx:9092</dockerHost>        <useColor>true</useColor>        <images>            <image>                <alias>${project.name}</alias>                <name>lymboy/${project.name}</name>                <build>                    <from>ccr.ccs.tencentyun.com/lymboy/java8:1.0</from>                    <maintainer>alayama@163.com</maintainer>                    <tags>                        <tag>${project.version}</tag>                    </tags>                    <workdir>/opt/</workdir>                    <ports>                        <port>8080</port>                    </ports>                    <entryPoint>                        <exec>                            <arg>java</arg>                            <arg>-jar</arg>                            <arg>/opt/${project.name}.jar</arg>                        </exec>                    </entryPoint>                    <assembly>                        <mode>dir</mode>                        <targetDir>/opt</targetDir>                        <descriptorRef>artifact</descriptorRef>                    </assembly>                </build>            </image>        </images>    </configuration>    <dependencies>        <dependency>            <groupId>commons-codec</groupId>            <artifactId>commons-codec</artifactId>            <version>1.15</version>        </dependency>    </dependencies></plugin>

添加上述maven插件后，通过maven命令就可以直接将项目构建成docker镜像并推送到远程docker服务。

mvn clean package -Dfile.encoding=UTF-8 docker:build

上述的插件配置等价于如下Dockerfile

FROM ccr.ccs.tencentyun.com/lymboy/java8:1.0MAINTAINER alayama@163.comEXPOSE 8080COPY maven /opt/WORKDIR /opt/ENTRYPOINT ["java","-jar","/opt/example.jar"]

当应用镜像推送到远程docker服务后，可以在IDEA Services直接运行指定的镜像。

这样，将原本为复杂的应用部署过程直接使用鼠标点击几下就可以解决，非常方便。

如果在构建镜像中有用到jdk8，可以使用笔者构建的jdk8基础镜像ccr.ccs.tencentyun.com/lymboy/java8:1.0

好久没写文章了，科研?真难。

箱线图是一种强大的数据可视化工具，用于了解数据的分布。它将数据分成四分位数，并根据从这些四分位数得出的五个数字对其进行汇总：

• 中位数：数据的中间值。标记为 Q2，描绘了第 50 个百分点。

• 第一个四分位数：“最小非异常值”和中位数之间的中间值。标记为 Q1，描绘了第 25 个百分点。

• 第三四分位数：“最大非异常值”和中位数之间的中间值。标记为 Q3，描绘了第 75 个百分点。

• “最大非异常值”：按 (Q3 + 1.5*IQR) 计算。高于此值的所有值都被视为异常值。

• “最小非异常值”：按 (Q1 – 1.5*IQR) 计算。低于此值的所有值都被视为异常值。

它还可以表示数据的对称性、偏度和分布。

箱型图的功能：

• 直观明了地识别数据批中的异常值
• 利用箱线图判断数据批的偏态和尾重
• 比较几批数据的形状

使用Pandas + Seaborn绘制箱型图

• 导入相关库

%matplotlib inlineimport matplotlib.pyplot as pltimport numpy as npimport pandas as pdimport plotly.express as pximport plotly.graph_objects as goimport seaborn as snsimport warningswarnings.filterwarnings("ignore")sns.set(font="SimHei")plt.rcParams["font.sans-serif"] = ["SimHei"]plt.rcParams["axes.unicode_minus"] = False

Pandas绘图

# load the datasetdf = sns.load_dataset('tips')df.head(10)

tips是Seaborn官方的一个数据集，首次会从github远程仓库下载到用户目录，如果出现超时可手动使用下面的镜像加速网址下载官方数据集并放到用户目录下，如/home/sairo/seaborn-data

https://github.com.cnpmjs.org/mwaskom/seaborn-data.git

df.boxplot(by="day", column=["total_bill"])df.boxplot(by="size", column=["tip"], grid=False)

使用Seaborn画箱型图

tips = sns.load_dataset("tips")tips.head()

# Draw a vertical boxplot grouped# by a categorical variable:sns.set_style("whitegrid")sns.boxplot(x="day", y="total_bill", data=tips)

Seaborn绘制水平箱型图

箱线图用于可视化数据分布，这在需要比较数据时非常有用。有时，箱线图也称为箱线图。该框显示了数据集的四分位数，而胡须延伸以显示分布的其余部分。在本文中，我们将使用 python 使用 seaborn 实现水平箱线图。

水平箱线图

Seaborn 使用 boxplot() 方法绘制箱线图。我们可以通过两种方法将箱线图变成水平箱线图，我们需要切换x和y属性并将其传递给boxplot()方法，另一种是使用orient="h"选项传递给boxplot() 方法。

• 方法一：切换x和y属性

# import library & datasetimport seaborn as snsdf = sns.load_dataset("iris")# Just switch x and yplt.Figure(dpi=300)sns.boxplot(y=df["species"], x=df["sepal_length"])

• 方法 2：使用 orient = h

# import library & datasetimport seaborn as snstips = sns.load_dataset("tips")ax = sns.boxplot(data=tips, orient="h", palette="Set2")

Seaborn – 使用调色板为箱线图着色

为您的数据可视化添加正确的颜色集使其更令人印象深刻和可读，seaborn 调色板使您可以轻松地在您的可视化中使用颜色。在本文中，我们将看到如何使用 seaborn 调色板为箱线图着色，还将了解 seaborn 调色板的用途，它也可以应用于其他绘图。

# import librariesimport matplotlib.pyplot as pltimport seaborn as snsds = sns.load_dataset("iris")ax = sns.boxplot(data=tips, orient="h")

Seaborn boxplot() 函数有调色板参数，在这个例子中我们设置了palette=”Set1″，它使用定性调色板来给boxplot中的框上色。所以在 boxplot 方法中添加调色板参数。

# use palette methodax = sns.boxplot(data=ds, orient="h", palette="Set1")

如何在 Python 中使用 Seaborn 在 Boxplot 上显示均值？

本节使用官方提供的泰坦尼克数据集

# importing useful librariesimport matplotlib.pyplot as pltimport seaborn as sns# using titanic dataset from# seaborn librarydf = sns.load_dataset("titanic")# to see first 5 rows of datasetdf.head()

# to plot a boxplot of# age vs survived featureplt.figure(figsize=(10, 8))sns.boxplot(x="survived", y="age", data=df)plt.ylabel("Age", size=14)plt.xlabel("Survived", size=14)plt.title("Titanic Dataset", size=18)

我们观察到中位数显示为四分位线，但未显示平均值。

• 为了显示均值，我们在 boxplot 函数中使用了一个额外的关键字参数。我们将 showmeans 设置为 True。

# boxplot with showmeansplt.figure(figsize=(10, 8))sns.boxplot(x="survived", y="age", data=df, showmeans=True)  # notice the changeplt.ylabel("Age", size=14)plt.xlabel("Survived", size=14)plt.title("Titanic Dataset", size=18)

• 要设置我们自定义的标记和标记颜色，我们将使用meanprops关键字参数，如下面的代码所示。

# customizing using meanpropsplt.figure(figsize=(10, 8))sns.boxplot(    x="survived",    y="age",    data=df,    showmeans=True,    meanprops={"marker": "+", "markeredgecolor": "black", "markersize": "10"},)plt.ylabel("Age", size=14)plt.xlabel("Survived", size=14)plt.title("Titanic Dataset", size=18)

如何在 Seaborn 中手动排序 Boxplot？

# import required modulesimport matplotlib.pyplot as pltimport numpy as npimport pandas as pdimport seaborn as sns# load datasettips = sns.load_dataset("tips")# display top most rowstips.head()# illustrate box plotfx = sns.boxplot(x="day", y="total_bill", data=tips, hue="sex", palette="Set2")

• 使用 seaborn 绘制箱线图。看上图的顺序和根据我们的需要设置顺序后的区别。 Palette 将改变图形的颜色（您也可以尝试 Set1 和 Set3）

# illustrating box plot with orderfx = sns.boxplot(    x="day",    y="total_bill",    data=tips,    order=["Sun", "Sat", "Fri", "Thur"],    hue="sex",    palette="Set2",)

使用 Seaborn 在 Python 中分组箱线图

分组箱线图用于可视化具有多个子组的数据。此外，我们可以使用分组箱线图一次可视化三个变量，其中一个变量是数字变量，另外两个变量是分类变量。 我们将使用 Python 的 Seaborn 库来创建分组箱线图。我们将使用来自 Seaborn 库的tip数据集。

# import seaborn libraryimport seaborn as sns# load the datasetdata = sns.load_dataset("tips")data.head(5)

示例 1：让我们创建一个箱线图来了解“tips”数据集的每一“天”上“total_bill”的分布。但我们也想根据“性别”属性对其进行分组。因此，我们将为这三个属性绘制分组箱线图，其中“sex”和“day”是分类属性，“total_bill”是数值属性。

sns.boxplot(x=data["day"], y=data["total_bill"], hue=data["sex"])

示例 2：下一个示例与上一个示例类似。唯一的区别是作为"smoker"属性的"hue"参数的值。在这里，我们想根据一个人是否吸烟来了解"total_bill"与"day"组的分布。

# create another grouped boxplotsns.boxplot(x=data["day"], y=data["total_bill"], hue=data["smoker"], palette="Set2")

示例 3：在本示例中，我们将介绍如何绘制 2 个以上的分组箱线图。如果"hue"参数的值有 2 个以上的类别，那么我们可以绘制 2 个以上的分组箱线图，如下所示。 在这里，'hue' = data['size'] 有六个类别，因此我们可以使用与上述相同的方法看到 2 个以上的分组箱线图。

sns.boxplot(x=data["day"], y=data["total_bill"], hue=data["size"], palette="husl")

使用 graph_objects 类在 Plotly 中绘制箱线图

Plotly 是一个 Python 库，用于设计图形，尤其是交互式图形。它可以绘制各种图形和图表，如直方图、条形图、箱线图、展开图等等。它主要用于数据分析以及财务分析。

使用graph_objects类的箱线图

import plotly.graph_objects as goimport numpy as np# creating random data through randomint# function of numpy.randomnp.random.seed(42)random_y1= np.random.randint(1,101,100)random_y2= np.random.randint(1,101,100)x = ['A', 'B', 'C', 'D']fig = go.Figure()fig.add_trace(go.Box(y=random_y1))fig.add_trace(go.Box(y=random_y2))fig.show()

水平箱线图

水平箱线图是一种箱线图，其中 x 变量和 y 值在图中水平显示。它可以通过传递箱线图的 x 参数来创建。

import plotly.graph_objects as goimport numpy as np# creating random data through randomint# function of numpy.randomnp.random.seed(42)random_x1= np.random.randint(1,101,100)random_x2= np.random.randint(1,101,100)x = ['A', 'B', 'C', 'D']fig = go.Figure()fig.add_trace(go.Box(x=random_x1))fig.add_trace(go.Box(x=random_x2))fig.show()

寻找均值和标准差

可以使用 boxmean 参数找到由boxplot绘制的数据的平均值和标准偏差。它可以取两个值:

True: 显示均值

sd: 为标准差。

import plotly.graph_objects as goimport numpy as np# creating random data through randomint# function of numpy.randomnp.random.seed(42)random_x1= np.random.randint(1,101,100)random_x2= np.random.randint(1,101,100)x = ['A', 'B', 'C', 'D']fig = go.Figure()fig.add_trace(go.Box(x=random_x1, marker_color = 'indianred', boxmean=True))fig.add_trace(go.Box(x=random_x2, marker_color='royalblue', boxmean='sd'))fig.show()

更改四分位数的算法

选择四分位数的算法也可以在plotly中选择。默认使用线性算法计算。然而，它提供了两种以上的算法来做同样的事情，即包容性和排斥性。可以通过传递 quartilemethod 参数来完成。

import plotly.graph_objects as goimport numpy as np# creating random data through randomint# function of numpy.randomnp.random.seed(42)random_y= np.random.randint(1,101,100)x = ['A', 'B', 'C', 'D']fig = go.Figure()fig.add_trace(go.Box(y=random_y, quartilemethod="linear", name="linear"))fig.add_trace(go.Box(y=random_y, quartilemethod="inclusive", name="inclusive"))fig.add_trace(go.Box(y=random_y, quartilemethod="exclusive", name="exclusive"))fig.show()

显示基础数据

可以使用 boxpoints 参数显示基础数据。这个参数的值可以是三种类型——

all为所有点

outliers 仅异常值

false 不是以上任何一种

import plotly.graph_objects as goimport numpy as np# creating random data through randomint# function of numpy.randomnp.random.seed(42)random_y1= np.random.randint(1,101,100)random_y2= np.random.randint(1,101,100)x = ['A', 'B', 'C', 'D']fig = go.Figure()fig.add_trace(go.Box(y=random_y1, boxpoints="all"))fig.add_trace(go.Box(y=random_y2, boxpoints="outliers"))fig.show()

参考文献

• https://www.geeksforgeeks.org/horizontal-boxplots-with-seaborn-in-python/?ref=lbp

原理剖析

listeners: 学名叫监听器，其实就是告诉外部连接者要通过什么协议访问指定主机名和端口开放的 Kafka 服务。
advertised.listeners：和 listeners 相比多了个 advertised。Advertised 的含义表示宣称的、公布的，就是说这组监听器是 Broker 用于对外发布的。
kafka 节点启动后，会向 zookeeper 注册自己，同时告诉 zookeeper 自身的通信地址，这个地址就是配置文件中的 advertised.listeners，如果没有配置 advertised.listeners，就会使用listeners。同时从 zookeeper 中获取兄弟节点的这个地址，以便与兄弟节点通信。即 kafka 节点是从 zookeeper 获取的其他节点的通信地址。
我们使用客户端以一个 ip 地址首次连接 kafka 节点后，节点返回给客户端的 kafka 集群地址就是从 zookeeper 中获得的这些地址，也就是各个节点配置的 advertised.listeners，包括当前连接的节点。所以可能客户端后续访问当前节点的 ip 地址有可能和首次连接的 ip 地址并不一样。

为什么客户端需要在第一次请求中获取 kafka 各个节点的服务 ip
因为你可以在启动客户端时只配置一个 kafka 节点的地址而不是列出所有节点（这样是不推荐的），但是客户端必须具有访问集群中的每一个节点的能力（收消息、发消息都可能面向所有节点）。
如果不配置advertised.listeners, 你会发现虽然你在启动 kafka 客户端时配置的访问地址是101.89.163.1:9092，但是 kafka 客户端启动时报错：

Connection to node -1[192.168.0.213:9092] could not be established. Broker may not be available.

为什么明明配置的是101.89.163.1:9092启动时连接的是192.168.0.213？这就是因为不配置advertised.listeners 则使用listeners 代替并注册到zookeeper 中，客户端拿到的 kafka 节点 ip 就是listeners配置的内网 ip 192.168.0.213。

参考文献

• https://juejin.cn/post/6893410969611927566
• https://blog.csdn.net/weixin_38251332/article/details/105638535

字符 数值

I             1V             5X             10L             50C             100D             500M             1000

例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。

通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：

I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。 C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。

给你一个整数，将其转为罗马数字。

示例 1:

输入: num = 3
输出: "III"

示例 2:

输入: num = 4
输出: "IV"

示例 3:

输入: num = 9
输出: "IX"

示例 4:

输入: num = 58
输出: "LVIII"
解释: L = 50, V = 5, III = 3.

示例 5:

输入: num = 1994
输出: "MCMXCIV"
解释: M = 1000, CM = 900, XC = 90, IV = 4.

提示：

1 <= num <= 3999

AC代码

class Solution {    public String intToRoman(int num) {        StringBuffer ret = new StringBuffer();        Map<Integer, String> romansNum = new LinkedHashMap<>();        romansNum.put(1000, "M");        romansNum.put(900, "CM");        romansNum.put(500, "D");        romansNum.put(400, "CD");        romansNum.put(100, "C");        romansNum.put(90, "XC");        romansNum.put(50, "L");        romansNum.put(40, "XL");        romansNum.put(10, "X");        romansNum.put(9, "IX");        romansNum.put(5, "V");        romansNum.put(4, "IV");        romansNum.put(1, "I");                if (romansNum.containsKey(num)) {            ret.append(romansNum.get(num));        } else {            for (int n : romansNum.keySet()){                if (num == 0) {                    break;                }                int div = num / n;                int mod = num % n;                if (div != 0) {                    for (int i = 0; i < div; i++) {                        ret.append(romansNum.get(n));                    }                }                if (mod != 0) {                    if (romansNum.containsKey(mod)) {                        ret.append(romansNum.get(mod));                        mod = mod / n;                    }                }                num = mod;            }        }        return ret.toString();    }}

• 将字体文件拷贝到 /usr/share/fonts/ 目录下，可以在此目录下建子目录，系统会扫描/usr/share/fonts/ 目录下的所有字体。

提前安装
使mkfontscale和mkfontdir命令正常运行
yum install mkfontscale
使fc-cache命令正常运行。如果提示 fc-cache: command not found
yum install fontconfig

• 执行以下三条命令

mkfontdir   mkfontscalefc-cache -fv

输出：

/usr/share/fonts: 正在生成缓存，新增缓存内容：0 个字体，40 个目录/usr/share/fonts/cjkuni-uming: 正在生成缓存，新增缓存内容：4 个字体，0 个目录/usr/share/fonts/dejavu: 正在生成缓存，新增缓存内容：21 个字体，0 个目录/usr/share/fonts/gnu-free: 正在生成缓存，新增缓存内容：12 个字体，0 个目录/usr/share/fonts/google-crosextra-caladea: 正在生成缓存，新增缓存内容：4 个字体，0 个目录/usr/share/fonts/google-crosextra-carlito: 正在生成缓存，新增缓存内容：4 个字体，0 个目录/usr/share/fonts/google-noto-emoji: 正在生成缓存，新增缓存内容：1 个字体，0 个目录/usr/share/fonts/jomolhari: 正在生成缓存，新增缓存内容：1 个字体，0 个目录/usr/share/fonts/khmeros: 正在生成缓存，新增缓存内容：3 个字体，0 个目录/usr/share/fonts/liberation: 正在生成缓存，新增缓存内容：12 个字体，0 个目录/usr/share/fonts/lklug: 正在生成缓存，新增缓存内容：1 个字体，0 个目录....../usr/share/fonts/urw-base35: 跳过，探测到循环目录/usr/share/fonts/vlgothic: 跳过，探测到循环目录/usr/share/fonts/wqy-microhei: 跳过，探测到循环目录/usr/share/fonts/wqy-zenhei: 跳过，探测到循环目录/opt/Anaconda3/var/cache/fontconfig: cleaning cache directory/home/sairo/.cache/fontconfig: cleaning cache directory/home/sairo/.fontconfig: not cleaning non-existent cache directoryfc-cache: 缓存生成成功

➜  ~ docker network lsNETWORK ID          NAME                DRIVER              SCOPEc9e0ba5e6caa        bridge              bridge              localc1c6888f498a        host                host                local50a084d0ef9f        none                null                local

• bridge：桥接网络
  默认情况下启动的Docker容器，都是使用 bridge，Docker安装时创建的桥接网络，每次Docker容器重启时，会按照顺序获取对应的IP地址，这个就导致重启下，Docker的IP地址就变了

• none：无指定网络
  使用 --network=none ，docker 容器就不会分配局域网的IP

• host： 主机网络
  使用 --network=host，此时，Docker 容器的网络会附属在主机上，两者是互通的。
  例如，在容器中运行一个Web服务，监听8080端口，则主机的8080端口就会自动映射到容器中。

创建自定义网络：（设置固定IP）

启动Docker容器的时候，使用默认的网络是不支持指派固定IP的，所以需要创建自定义网络

创建自定义网络，并且指定网段：172.18.0.0/16，并取名为mynetwork

➜  ~ docker network create --subnet=172.18.0.0/16 mynetwork

docker中已经有4个网络了

➜  ~ docker network ls                                                                                                           NETWORK ID     NAME        DRIVER    SCOPEc9e0ba5e6caa   bridge      bridge    localc1c6888f498a   host        host      localc6e14fdaf31a   mynetwork   bridge    local50a084d0ef9f   none        null      local

创建容器时给容器指定IP

以mysql为例

➜  ~ docker run -it --name mysql_test -e MYSQL_ROOT_PASSWORD=123456 --net mynetwork --ip 172.18.0.66 -p 3312:3306 -d 2c9028880e58

• --net 指定网络名
• --ip 指定ip

可以看到容器ip正是在创建时指定的ip

➜  ~ mycli -h 172.18.0.66 -uroot -p123456 -P3306                 MySQL mycli 1.24.1Home: http://mycli.netBug tracker: https://github.com/dbcli/mycli/issuesThanks to the contributor - SeamileMySQL root@172.18.0.66:(none)>

➜  ~ mycli -h 192.168.0.179 -uroot -p123456 -P3312MySQL mycli 1.24.1Home: http://mycli.netBug tracker: https://github.com/dbcli/mycli/issuesThanks to the contributor - Abirami PMySQL root@192.168.0.179:(none)> exitGoodbye!

两种方式都可以连接容器内的mysql

• mycli 是第三方的myql客户端工具
• 当使用容器内ip时对应的端口也应该是容器内端口，不是映射后的宿主机端口

修改已存在的容器ip

• 断开容器原本的网络

➜  ~ docker network disconnect mynetwork mysql_test

• 给容器指定新的网络

  简单起见，这里使用刚才的网络，不创建新的

➜  ~ docker network connect mynetwork mysql_test --ip 172.18.0.66

--ip 可选，分配指定ip

• 重启容器

➜  ~ docker restart mysql_test   

可以重新连接了！

• 生成配置文件

jupyter notebook --generate-config --allow-config

• 允许远程访问

c.NotebookApp.ip='*'

• 设置密码

from notebook.auth import passwdpasswd()Enter password:Verify password:'argon2:$argon2id$v=19$m=10240,t=10,p=8$wLvn9j4SchZazAnfllMEcA$XI6jNtzZx8LpOOY9L8oR0A'

c.NotebookApp.password = u'sha:ce...刚才复制的那个密文'

• 关闭自动打开浏览器

c.NotebookApp.open_browser = False

• 指定远程访问端口，默认是8888

c.NotebookApp.port =8888 #可自行指定一个端口, 访问时使用该端口

• 后台挂起jupyter服务

nohup jupyter notebook &

解决anaconda多环境EnvironmentLocationNotFound: Not a conda environment: /home/sairo/.conda/envs/anaconda3

原因
之前版本conda是envs=[],而4.4版本之后envs=[root_env_dir]，然而这个目录通常并不是空的，官方可能在后续的更新中解决这个问题。
解决方法

• 进入/opt/anaconda3/pkgs/nb_conda-2.2.1-py38_1/lib/python3.8/site-packages/nb_conda/(根据版本可能会有不同)
• 打开envmanager.py文件
  查找这一句:(大概第83行)

return {    "environments": [root_env] + [get_info(env)                                  for env in info['envs']]}

改成：

return {    "environments": [root_env] + [get_info(env) for env in info['envs']                                  if env != root_env['dir']]}

一般matplotlib 或seaborn 只能画静态图表，plotly https://plotly.com/python/line-charts/ 可以画可交互式图表。

import plotly.express as pxdf = px.data.gapminder().query("continent=='Oceania'")fig = px.line(df, x="year", y="lifeExp", color='country')fig.show()

滑动图像

https://plotly.com/python/range-slider/

pandas时间格式列转换

from datetime import datetimeimport pandas as pdtran['date'] = tran['date'].astype('datetime64[ns]')# 或者tran['date'] = pd.to_datetime(tran['date']) # date转为时间格式

折线图分段画不同颜色

方法一：
指定c 颜色参数
方法二：
前一段数据置位None

from pandas import read_csvfrom matplotlib import pyplotseries = read_csv('sunspots.csv', header=0, index_col=0)X = series.valuestrain_size = int(len(X) * 0.66)train, test = X[0:train_size], X[train_size:len(X)]print('Observations: %d' % (len(X)))print('Training Observations: %d' % (len(train)))print('Testing Observations: %d' % (len(test)))pyplot.plot(train)pyplot.plot([None for i in train] + [x for x in test])pyplot.show()

pandas 统计不同值出现的次数

y.value_counts()

Tensor.transpose(dim0, dim1) → Tensor

对dim0, dim1维度分别转置然后返回，只能操作两维，且会直接修改底层数据

torch.permute(input, dims) → Tensor

翻转多维数组，返回视图。参数指定原张量的哪一维翻转到新维度上。

矩阵运算

torch.matmul(input, other, *, out=None) → Tensor

矩阵乘法