KLucenの启示录

没有工具用代码也能P图#

1. 安装pillow三方库。

   PIL（Python Imaging Library）是Python平台事实上的图像处理标准库了。PIL功能非常强大，而API却非常简单易用。但是PIL仅支持到Python 2.7，而且很多年都没有人维护了，于是一群志愿者在PIL的基础上创建了兼容的版本，名字叫Pillow，除了支持Python 3.x还加入了很多有用且有趣的新特性。

   1
   pip install pillow

   或

   1
   pip3 install pillow

2. 加载图片。

   1
   from PIL import Image
   2
   
   3
   chiling = Image.open('chiling.jpg')
   4
   chiling.show()

3. 使用滤镜。

   1
   from PIL import ImageFilter
   2
   
   3
   chiling.filter(ImageFilter.EMBOSS).show()
   4
   chiling.filter(ImageFilter.CONTOUR).show()

4. 图像剪裁和粘贴。

   1
   rect = 220, 690, 265, 740
   2
   watch = chiling.crop(rect)
   3
   watch.show()
   4
   blured_watch = watch.filter(ImageFilter.GaussianBlur(4))
   5
   chiling.paste(blured_watch, (220, 690))
   6
   chiling.show()

5. 生成镜像。

   1
   chiling2 = chiling.transpose(Image.FLIP_LEFT_RIGHT)
   2
   chiling2.show()

6. 生成缩略图。

   1
   width, height = chiling.size
   2
   width, height = int(width * 0.4), int(height * 0.4)
   3
   chiling.thumbnail((width, height))

7. 合成图片。

   1
   frame = Image.open('frame.jpg')
   2
   frame.show()
   3
   frame.paste(chiling, (210, 150))
   4
   frame.paste(chiling2, (522, 150))
   5
   frame.show()

上面的知识在Python-100-Days项目的第15天中也有对应的内容。

向微信好友群发祝福视频#

1. 安装itchat三方库。

   itchat是一个开源的微信个人号接口，使用Python调用微信从未如此简单。

   1
   pip install itchat

   或

   1
   pip3 install itchat

2. 登录微信。

   1
   import itchat
   2
   
   3
   itchat.auto_login()

   说明：用自己的微信扫描屏幕上出现的二维码就完成了登录操作，登录之后才能获取自己的好友信息以及发送消息给自己的好友。

3. 查找自己的朋友。

   1
   friends_list = itchat.get_friends(update=True)
   2
   print(len(friends_list))
   3
   luohao = friends_list[0]
   4
   props = ['NickName', 'Signature', 'Sex']
   5
   for prop in props:
   6
       print(luohao[prop])

   说明：friends_list相当于是一个列表，列表中的第一个元素是自己。

4. 随机选出5个朋友，获得他们的用户名、昵称、签名。

   1
   lucky_friends = random.sample(friends_list[1:], 5)
   2
   props = ['NickName', 'Signature', 'City']
   3
   for friend in lucky_friends:
   4
       for prop in props:
   5
           print(friend[prop] or '没有此项信息')
   6
       print('-' * 80)

5. 给朋友发送文字消息。

   1
   itchat.send_msg('急需一个红包来拯救堕落的灵魂！！！', toUserName='@8e06606db03f0e28d0ff884083f727e6')

6. 群发视频给幸运的朋友们。

   1
   lucky_friends = random.sample(friends_list[1:], 5)
   2
   for friend in lucky_friends:
   3
       username = friend['UserName']
   4
       itchat.send_video('/Users/Hao/Desktop/my_test_video.mp4', toUserName=username)

利用itchat还能做很多事情，比如有好友给自己发了消息又撤回了，如果想查看这些被撤回的消息，itchat就可以做到（注册一个接收消息的钩子函数，请参考CSDN上的一篇文章）；再比如，有时候我们想知道某个好友有没有把我们删除或者拉入黑名单，也可以利用itchat封装的群聊功能，非好友和黑名单用户不会被拉入群聊，通过创建群聊函数的返回值就可以判定你和指定的人之间的关系。

不用客户端查看热点新闻#

1. 安装requests库。（点击常看官方文档）

   

   1
   pip install requests

   或

   1
   pip3 install requests

2. 爬取新闻数据或者通过API接口获取新闻数据。

   1
   import requests
   2
   
   3
   resp = requests.get('http://api.tianapi.com/allnews/?key=请使用自己申请的Key&col=7&num=50')

   说明：上面使用了天行数据提供的数据接口，需要的话可以自行去天行数据的网站注册开通，调用接口的时候要填写注册成功后系统分配给你的key。

3. 使用反序列化将JSON字符串解析为字典并获取新闻列表。

   1
   import json
   2
   
   3
   newslist = json.loads(resp.text)['newslist']

4. 对新闻列表进行循环遍历，找到感兴趣的新闻，例如：华为。

   1
   for news in newslist:
   2
       title = news['title']
   3
       url = news['url']
   4
       if '华为' in title:
   5
           print(title)
   6
           print(url)

5. 调用短信网关发送短信到手机上，告知关注的新闻标题并给出链接。

   1
   import re
   2
   
   3
   pattern = re.compile(r'https*:\/\/[^\/]*\/(?P<url>.*)')
   4
   matcher = pattern.match(url)
   5
   
   6
   if matcher:
   7
       url = matcher.group('url')
   8
       resp = requests.post(
   9
           url='http://sms-api.luosimao.com/v1/send.json',
   10
           auth=('api', 'key-请使用你自己申请的Key'),
   11
           data={
   12
               'mobile': '13548041193',
   13
               'message': f'发现一条您可能感兴趣的新闻 - {title}，详情点击https://news.china.com/{url} 查看。【Python小课】'
   14
           },
   15
           timeout=10,
   16
           verify=False
   17
       )

   说明：上面的代码使用了螺丝帽提供的短信网关服务，利用短信网关发送短信是需要支付费用的，但是一般的平台都会提供若干条免费的测试短信。发送短信必须遵守平台的规则，违规的短信是无法发送的。上面发短信时使用的短信模板（“发现一条您可能感兴趣的新闻 - ###，详情点击https://news.china.com/### 查看。”）和短信签名（“【Python小课】”）需要登录螺丝帽管理平台进行配置，如果不清楚如何配置，可以联系平台的客服人员进行咨询。

算法概述#

1. 什么是算法？

   解决问题的正确方法和具体的实施步骤。

   例子1：如何在两栋相距50m的大楼的两个房间牵一条线（两个房间都有窗）？

   • 养一只鸟（如鸽子），将线送过去
   • 用很长的杆子将线递过去
   • 用无人机（遥控飞行器）将线送过去

   如何评价这些方法的好坏？少花钱，不费事！

   例子2：大教室里坐了几百名学生一起听课，如何快速的统计学生人数？

   例子3：向列表容器中逆向插入100000个元素。

   • 方法1：

     1
     nums = []
     2
     for i in range(100000):
     3
         nums.append(i)
     4
     nums.reverse()

   • 方法2：

     1
     nums = []
     2
     for i in range(100000):
     3
         nums.insert(0, i)

   例子3：生成Fibonacci数列（前100个Fibonacci数）。

   • 方法1 - 递推：

     1
     a, b = 0, 1
     2
     for num in range(1, 101):
     3
         a, b = b, a + b
     4
         print(f'{num}: {a}')

   • 方法2 - 递归：

     1
     def fib(num):
     2
         if num in (1, 2):
     3
             return 1
     4
         return fib(num - 1) + fib(num - 2)
     5
     
     6
     
     7
     for num in range(1, 101):
     8
         print(f'{num}: {fib(num)}')

   • 方法3 - 改进的递归：

     1
     def fib(num, temp={}):
     2
         if num in (1, 2):
     3
             return 1
     4
         elif num not in temp:
     5
             temp[num] = fib(num - 1) + fib(num - 2)
     6
         return temp[num]

   • 方法4 - 改进的递归：

     1
     from functools import lru_cache
     2
     
     3
     
     4
     @lru_cache()
     5
     def fib(num):
     6
         if num in (1, 2):
     7
             return 1
     8
         return fib(num - 1) + fib(num - 2)

2. 如何评价算法的好坏？

   渐近时间复杂度和渐近空间复杂度。

3. 大O符号的意义？

   表示一个函数相对于输入规模的增长速度，也可以称之为函数的数量级。

   大O符号	说明	例子
   $O(c)$	常量时间复杂度	布隆过滤器 / 哈希存储
   $O(log_2n)$	对数时间复杂度	二分查找（折半查找）
   $O(n)$	线性时间复杂度	顺序查找 / 桶排序
   $O(n*log_2n)$	对数线性时间复杂度	高级排序算法（归并排序、快速排序）
   $O(n^2)$	平方时间复杂度	简单排序算法（选择排序、插入排序、冒泡排序）
   $O(n^3)$	立方时间复杂度	Floyd算法 / 矩阵乘法运算
   $O(2^n)$	几何级数时间复杂度	汉诺塔
   $O(n!)$	阶乘时间复杂度	旅行经销商问题

穷举法#

在计算机科学中，穷举法或者暴力搜索法是一个非常非常直观的解决问题的方法，这种方法通过一项一项的列举解决方案所有可能的候选项以及检查每个候选项是否符合问题的描述，最终得到问题的解。

虽然暴力搜索很容易实现，并且如果解决方案存在它就一定能够找到，但是它的代价是和候选方案的数量成比例的，由于这一点，在很多实际问题中，消耗的代价会随着问题规模的增加而快速地增长。因此，当问题规模有限或当存在可用于将候选解决方案的集合减少到可管理大小时，就可以使用暴力搜索。另外，当实现方法的简单度比速度更重要的时候，也可以考虑使用这种方法。

经典例子#

1. 百钱百鸡问题：公鸡5元一只，母鸡3元一只，小鸡1元三只，用100元买一百只鸡，问公鸡、母鸡、小鸡各有多少只？

   1
   for x in range(21):
   2
       for y in range(34):
   3
           z = 100 - x - y
   4
           if z % 3 == 0 and 5 * x + 3 * y + z // 3 == 100:
   5
               print(x, y, z)

2. 五人分鱼问题：ABCDE五人在某天夜里合伙捕鱼，最后疲惫不堪各自睡觉。第二天A第一个醒来，他将鱼分为5份，扔掉多余的1条，拿走了属于自己的一份；B第二个醒来，也将鱼分为5份，扔掉多余的1条，拿走属于自己的一份；然后C、D、E依次醒来，也按同样的方式分鱼，问他们至少捕了多少条鱼？

   1
   fish = 6
   2
   while True:
   3
       total = fish
   4
       enough = True
   5
       for _ in range(5):
   6
           if (total - 1) % 5 == 0:
   7
               total = (total - 1) // 5 * 4
   8
           else:
   9
               enough = False
   10
               break
   11
       if enough:
   12
           print(fish)
   13
           break
   14
       fish += 5

3. 暴力破解口令：

   1
   import re
   2
   
   3
   import PyPDF2
   4
   
   5
   with open('Python_Tricks_encrypted.pdf', 'rb') as pdf_file_stream:
   6
       reader = PyPDF2.PdfFileReader(pdf_file_stream)
   7
       with open('dictionary.txt', 'r') as txt_file_stream:
   8
           file_iter = iter(lambda: txt_file_stream.readline(), '')
   9
           for word in file_iter:
   10
               word = re.sub(r'\s', '', word)
   11
               if reader.decrypt(word):
   12
                   print(word)
   13
                   break

现实中的递归#

从前有座山，山里有座庙，庙里有个老和尚，正在给小和尚讲故事呢！故事是什么呢？从前有座山，山里有座庙，庙里有个老和尚，正在给小和尚讲故事呢！故事是什么呢？从前有座山，山里有座庙，庙里有个老和尚，正在给小和尚讲故事呢！故事是什么呢？……

野比大雄在房间里，用时光电视看着未来的情况。电视画面中，野比大雄在房间里，用时光电视看着未来的情况。电视画面中，野比大雄在房间里，用时光电视看着未来的情况……

阶乘的递归定义：$0! = 1$，$n!=n*(n-1)!$ ，使用被定义对象的自身来为其下定义称为递归定义。

德罗斯特效应是递归的一种视觉形式。图中女性手持的物体中有一幅她本人手持同一物体的小图片，进而小图片中还有更小的一幅她手持同一物体的图片……

递归的应用#

在程序中，一个函数如果直接或者间接的调用了自身，我们就称之为递归函数。

写递归函数有两个要点：

1. 收敛条件 - 什么时候结束递归。
2. 递归公式 - 每一项与前一项（前N项）的关系。

例子1：求阶乘。

1
def fac(num):
2
    if num == 0:
3
        return 1
4
    return num * fac(num - 1)

Python对递归的深度加以了限制（默认1000层函数调用），如果想突破这个限制，可以使用下面的方法。

1
import sys
2

3
sys.setrecursionlimit(10000)

例子2：爬楼梯 - 楼梯有n个台阶，一步可以走1阶、2阶或3阶，走完n个台阶共有多少种不同的走法。

1
def climb(num):
2
    if num == 0:
3
        return 1
4
    elif num < 0:
5
        return 0
6
    return climb(num - 1) + climb(num - 2) + climb(num - 3)

注意：上面的递归函数性能会非常的差，因为时间复杂度是几何级数级的。

优化后的代码。

1
from functools import lru_cache
2

3

4
@lru_cache()
5
def climb(num):
6
    if num == 0:
7
        return 1
8
    elif num < 0:
9
        return 0
10
    return climb(num - 1) + climb(num - 2) + climb(num - 3)

不使用的递归的代码。

1
def climb(num):
2
    a, b, c = 1, 2, 4
3
    for _ in range(num - 1):
4
        a, b, c = b, c, a + b + c
5
    return a

重点：有更好的办法的时候，请不要考虑递归。

回溯法#

回溯法是暴力搜索法中的一种。对于某些计算问题而言，回溯法是一种可以找出所有（或一部分）解的一般性算法，尤其适用于约束满足问题（在解决约束满足问题时，我们逐步构造更多的候选解，并且在确定某一部分候选解不可能补全成正确解之后放弃继续搜索这个部分候选解本身及其可以拓展出的子候选解，转而测试其他的部分候选解）。

经典案例#

例子1：迷宫寻路。

1
"""
2
迷宫寻路
3
"""
4
import random
5
import sys
6

7
WALL = -1
8
ROAD = 0
9

10
ROWS = 10
11
COLS = 10
12

13

14
def find_way(maze, i=0, j=0, step=1):
15
    """走迷宫"""
16
    if 0 <= i < ROWS and 0 <= j < COLS and maze[i][j] == 0:
17
        maze[i][j] = step
18
        if i == ROWS - 1 and j == COLS - 1:
19
            print('=' * 20)
20
            display(maze)
21
            sys.exit(0)
22
        find_way(maze, i + 1, j, step + 1)
23
        find_way(maze, i, j + 1, step + 1)
24
        find_way(maze, i - 1, j, step + 1)
25
        find_way(maze, i, j - 1, step + 1)
26
        maze[i][j] = ROAD
27

28

29
def reset(maze):
30
    """重置迷宫"""
31
    for i in range(ROWS):
32
        for j in range(COLS):
33
            num = random.randint(1, 10)
34
            maze[i][j] = WALL if num > 7 else ROAD
35
    maze[0][0] = maze[ROWS - 1][COLS - 1] = ROAD
36

37

38
def display(maze):
39
    """显示迷宫"""
40
    for row in maze:
41
        for col in row:
42
            if col == -1:
43
                print('■', end=' ')
44
            elif col == 0:
45
                print('□', end=' ')
46
            else:
47
                print(f'{col}'.ljust(2), end='')
48
        print()
49

50

51
def main():
52
    """主函数"""
53
    maze = [[0] * COLS for _ in range(ROWS)]
54
    reset(maze)
55
    display(maze)
56
    find_way(maze)
57
    print('没有出路!!!')
58

59

60
if __name__ == '__main__':
61
    main()

**说明：**上面的代码用随机放置围墙的方式来生成迷宫，更好的生成迷宫的方式请参考《简单的使用回溯法生成 Tile Based 迷宫》一文。

例子2：骑士巡逻 - 国际象棋中的骑士（马），按照骑士的移动规则走遍整个棋盘的每一个方格，而且每个方格只能够经过一次。

1
"""
2
骑士巡逻
3
"""
4
import sys
5

6
SIZE = 8
7

8

9
def display(board):
10
    """显示棋盘"""
11
    for row in board:
12
        for col in row:
13
            print(f'{col}'.rjust(2, '0'), end=' ')
14
        print()
15

16

17
def patrol(board, i=0, j=0, step=1):
18
    """巡逻"""
19
    if 0 <= i < SIZE and 0 <= j < SIZE and board[i][j] == 0:
20
        board[i][j] = step
21
        if step == SIZE * SIZE:
22
            display(board)
23
            sys.exit(0)
24
        patrol(board, i + 1, j + 2, step + 1)
25
        patrol(board, i + 2, j + 1, step + 1)
26
        patrol(board, i + 2, j - 1, step + 1)
27
        patrol(board, i + 1, j - 2, step + 1)
28
        patrol(board, i - 1, j - 2, step + 1)
29
        patrol(board, i - 2, j - 1, step + 1)
30
        patrol(board, i - 2, j + 1, step + 1)
31
        patrol(board, i - 1, j + 2, step + 1)
32
        board[i][j] = 0
33

34

35
def main():
36
    """主函数"""
37
    board = [[0] * SIZE for _ in range(SIZE)]
38
    patrol(board)
39

40

41
if __name__ == '__main__':
42
    main()

例子3：八皇后 - 如何能够在8×8的国际象棋棋盘上放置八个皇后，使得任何一个皇后都无法直接吃掉其他的皇后？为了达到此目的，任两个皇后都不能处于同一条横行、纵行或斜线上。

说明：这个问题太经典了，网上有大把的答案，留给大家自己搞定。

为什么要用Python写代码#

1
#include <stdio.h>
2

3
int main() {
4
    printf("hello, world\n");
5
    return 0;
6
}

1
class Example01 {
2

3
    public static void main(String[] args) {
4
        System.out.println("hello, world");
5
    }
6
}

1
print('hello, world')

1
#include <stdio.h>
2

3
int main() {
4
    int total = 0;
5
    for (int i = 1; i <= 100; ++i) {
6
        total += i;
7
    }
8
    printf("%d\n", total);
9
    return 0;
10
}

1
print(sum(range(1, 101)))

1
import java.util.Arrays;
2

3
public class Example03 {
4

5
    public static void main(String[] args) {
6
        boolean[] values = new boolean[10];
7
        Arrays.fill(values, true);
8
        System.out.println(Arrays.toString(values));
9

10
        int[] numbers = new int[10];
11
        for (int i = 0; i < numbers.length; ++i) {
12
            numbers[i] = i + 1;
13
        }
14
        System.out.println(Arrays.toString(numbers));
15
    }
16
}

1
values = [True] * 10
2
print(values)
3
numbers = [x for x in range(1, 11)]
4
print(numbers)

1
import java.util.List;
2
import java.util.ArrayList;
3
import java.util.Collections;
4
import java.util.Scanner;
5
import java.util.concurrent.ThreadLocalRandom;
6

7
class Example03 {
8
    private static final List<Integer> RED_BALLS = new ArrayList<>();
9
    static {
10
        for (int i = 1; i <= 33; ++i) RED_BALLS.add(i);
11
    }
12

13
    public static void display(List<Integer> balls) {
14
        StringBuilder sb = new StringBuilder();
15
        for (int i = 0; i < balls.size(); i++) {
16
            sb.append(String.format("%02d ", balls.get(i)));
17
            if (i == 5) sb.append("| ");
18
        }
19
        System.out.println(sb.toString());
20
    }
21

22
    public static List<Integer> generate() {
23
        List<Integer> pool = new ArrayList<>(RED_BALLS);
24
        Collections.shuffle(pool);
25
        List<Integer> selectedBalls = pool.subList(0, 6);
26
        Collections.sort(selectedBalls);
27
        selectedBalls.add(ThreadLocalRandom.current().nextInt(1, 17));
28
        return selectedBalls;
29
    }
30

31
    public static void main(String[] args) {
32
        try (Scanner sc = new Scanner(System.in)) {
33
            System.out.print("机选几注: ");
34
            if (sc.hasNextInt()) {
35
                int num = sc.nextInt();
36
                for (int i = 0; i < num; ++i) {
37
                    display(generate());
38
                }
39
            }
40
        }
41
    }
42
}

1
import random
2

3
RED_RANGE = range(1, 34)
4
BLU_RANGE = range(1, 17)
5

6

7
def generate():
8
    red_balls = random.sample(RED_RANGE, 6)
9
    red_balls.sort()
10
    blue_ball = random.choice(BLU_RANGE)
11
    return red_balls, blue_ball
12

13

14
def display(sample):
15
    reds, blue = sample
16
    reds_str = ' '.join(f'{ball:02d}' for ball in reds)
17
    print(f'{reds_str} | {blue:02d}')
18

19

20
num = int(input('机选几注: '))
21
for _ in range(num):
22
    display(generate())

1
import com.sun.net.httpserver.HttpExchange;
2
import com.sun.net.httpserver.HttpHandler;
3
import com.sun.net.httpserver.HttpServer;
4

5
import java.io.IOException;
6
import java.io.OutputStream;
7
import java.net.InetSocketAddress;
8

9
class Example05 {
10

11
    public static void main(String[] arg) throws Exception {
12
        HttpServer server = HttpServer.create(new InetSocketAddress(8000), 0);
13
        server.createContext("/", new RequestHandler());
14
        server.start();
15
    }
16

17
    static class RequestHandler implements HttpHandler {
18

19
        @Override
20
        public void handle(HttpExchange exchange) throws IOException {
21
            String response = "<h1>hello, world</h1>";
22
            exchange.sendResponseHeaders(200, 0);
23
            try (OutputStream os = exchange.getResponseBody()) {
24
                os.write(response.getBytes());
25
            }
26
        }
27
    }
28
}

1
from http.server import HTTPServer, SimpleHTTPRequestHandler
2

3

4
class RequestHandler(SimpleHTTPRequestHandler):
5

6
    def do_GET(self):
7
        self.send_response(200)
8
        self.end_headers()
9
        self.wfile.write('<h1>hello, world</h1>'.encode())
10

11

12
server = HTTPServer(('', 8000), RequestHandler)
13
server.serve_forever()

1
python3 -m http.server 8000

1
# 一行代码实现求阶乘函数
2
fac = lambda x: __import__('functools').reduce(int.__mul__, range(1, x + 1), 1)
3

4
# 一行代码实现求最大公约数函数
5
gcd = lambda x, y: y % x and gcd(y % x, x) or x
6

7
# 一行代码实现判断素数的函数
8
is_prime = lambda x: x > 1 and not [f for f in range(2, int(x ** 0.5) + 1) if x % f == 0]
9

10
# 一行代码实现快速排序
11
quick_sort = lambda items: len(items) and quick_sort([x for x in items[1:] if x < items[0]]) + [items[0]] + quick_sort([x for x in items[1:] if x > items[0]]) or items
12

13
# 生成FizzBuzz列表
14
['Fizz'[x % 3 * 4:] + 'Buzz'[x % 5 * 4:] or x for x in range(1, 101)]

1
def fib(num):
2
    if num in (1, 2):
3
        return 1
4
    return fib(num - 1) + fib(num - 2)

1
from functools import lru_cache
2

3

4
@lru_cache()
5
def fib(num):
6
    if num in (1, 2):
7
        return 1
8
    return fib(num - 1) + fib(num - 2)
9

10

11
for n in range(1, 121):
12
    print(f'{n}: {fib(n)}')

1
from functools import wraps
2
from threading import RLock
3

4

5
def singleton(cls):
6
    instances = {}
7
    lock = RLock()
8

9
    @wraps(cls)
10
    def wrapper(*args, **kwargs):
11
        if cls not in instances:
12
            with lock:
13
                if cls not in instances:
14
                    instances[cls] = cls(*args, **kwargs)
15
        return instances[cls]

1
import copy
2

3

4
class PrototypeMeta(type):
5

6
    def __init__(cls, *args, **kwargs):
7
        super().__init__(*args, **kwargs)
8
        cls.clone = lambda self, is_deep=True: \
9
            copy.deepcopy(self) if is_deep else copy.copy(self)

数据采集和数据分析从未如此简单#

网络数据采集是Python最擅长的领域之一。

例子：获取豆瓣电影“Top250”。

1
import random
2
import time
3

4
import requests
5
from bs4 import BeautifulSoup
6

7
for page in range(10):
8
    resp = requests.get(
9
        url=f'https://movie.douban.com/top250?start={25 * page}',
10
        headers={'User-Agent': 'BaiduSpider'}
11
    )
12
    soup = BeautifulSoup(resp.text, "lxml")
13
    for elem in soup.select('a > span.title:nth-child(1)'):
14
        print(elem.text)
15
    time.sleep(random.random() * 5)

利用NumPy、Pandas、Matplotlib可以轻松实现数据分析和可视化。

写出Python代码的正确姿势#

用Python写代码就要写出Pythonic的代码。

1
name = 'jackfrued'
2
fruits = ['apple', 'orange', 'grape']
3
owners = {'name': '骆昊', 'age': 40, 'gender': True}
4
if name != '' and len(fruits) > 0 and len(owners.keys()) > 0:
5
    print('Jackfrued love fruits.')

1
name = 'jackfrued'
2
fruits = ['apple', 'orange', 'grape']
3
owners = {'name': '骆昊', 'age': 40, 'gender': True}
4
if name and fruits and owners:
5
    print('Jackfrued love fruits.')

1
temp = a
2
a = b
3
b = temp

1
a = a ^ b
2
b = a ^ b
3
a = a ^ b

1
a, b = b, a

1
chars = ['j', 'a', 'c', 'k', 'f', 'r', 'u', 'e', 'd']
2
name = ''
3
for char in chars:
4
    name += char

1
chars = ['j', 'a', 'c', 'k', 'f', 'r', 'u', 'e', 'd']
2
name = ''.join(chars)

1
fruits = ['orange', 'grape', 'pitaya', 'blueberry']
2
index = 0
3
for fruit in fruits:
4
    print(index, ':', fruit)
5
    index += 1

1
fruits = ['orange', 'grape', 'pitaya', 'blueberry']
2
for index, fruit in enumerate(fruits):
3
    print(index, ':', fruit)

1
data = [7, 20, 3, 15, 11]
2
result = []
3
for i in data:
4
    if i > 10:
5
        result.append(i * 3)

1
data = [7, 20, 3, 15, 11]
2
result = [num * 3 for num in data if num > 10]

1
data = {'x': '5'}
2
if 'x' in data and isinstance(data['x'], (str, int, float)) \
3
        and data['x'].isdigit():
4
    value = int(data['x'])
5
    print(value)
6
else:
7
    value = None

1
data = {'x': '5'}
2
try:
3
    value = int(data['x'])
4
    print(value)
5
except (KeyError, TypeError, ValueError):
6
    value = None

使用Lint工具检查你的代码规范#

阅读下面的代码，看看你能看出哪些地方是有毛病的或者说不符合Python的编程规范的。

1
from enum import *
2

3
@unique
4
class Suite (Enum):
5
    SPADE, HEART, CLUB, DIAMOND = range(4)
6

7
class Card(object):
8
    def __init__(self,suite,face ):
9
        self.suite = suite
10
        self.face = face
11

12

13
    def __repr__(self):
14
        suites='♠♥♣♦'
15
        faces=['','A','2','3','4','5','6','7','8','9','10','J','Q','K']
16
        return f'{suites[self.suite.value]}{faces[self.face]}'
17

18
import random
19

20
class Poker(object):
21
    def __init__(self):
22
        self.cards =[Card(suite, face) for suite in Suite
23
            for face in range(1, 14)]
24
        self.current=0
25
    def shuffle (self):
26
        self.current=0
27
        random.shuffle(self.cards)
28
    def deal (self):
29
        card = self.cards[self.current]
30
        self.current+=1
31
        return card
32
    def has_next (self):
33
        if self.current<len(self.cards): return True
34
        return False
35

36
p = Poker()
37
p.shuffle()
38
print(p.cards)

1
pip install pylint
2
pylint [options] module_or_package

使用Profile工具剖析你的代码性能#

1
import cProfile
2

3

4
def is_prime(num):
5
    for factor in range(2, int(num ** 0.5) + 1):
6
        if num % factor == 0:
7
            return False
8
    return True
9

10

11
class PrimeIter:
12

13
    def __init__(self, total):
14
        self.counter = 0
15
        self.current = 1
16
        self.total = total
17

18
    def __iter__(self):
19
        return self
20

21
    def __next__(self):
22
        if self.counter < self.total:
23
            self.current += 1
24
            while not is_prime(self.current):
25
                self.current += 1
26
            self.counter += 1
27
            return self.current
28
        raise StopIteration()
29

30

31
cProfile.run('list(PrimeIter(10000))')

1
   114734 function calls in 0.573 seconds
2

3
   Ordered by: standard name
4

5
   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
6
        1    0.006    0.006    0.573    0.573 <string>:1(<module>)
7
        1    0.000    0.000    0.000    0.000 example.py:14(__init__)
8
        1    0.000    0.000    0.000    0.000 example.py:19(__iter__)
9
    10001    0.086    0.000    0.567    0.000 example.py:22(__next__)
10
   104728    0.481    0.000    0.481    0.000 example.py:5(is_prime)
11
        1    0.000    0.000    0.573    0.573 {built-in method builtins.exec}
12
        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}

1
@profile
2
def is_prime(num):
3
    for factor in range(2, int(num ** 0.5) + 1):
4
        if num % factor == 0:
5
            return False
6
    return True
7

8

9
class PrimeIter:
10

11
    def __init__(self, total):
12
        self.counter = 0
13
        self.current = 1
14
        self.total = total
15

16
    def __iter__(self):
17
        return self
18

19
    def __next__(self):
20
        if self.counter < self.total:
21
            self.current += 1
22
            while not is_prime(self.current):
23
                self.current += 1
24
            self.counter += 1
25
            return self.current
26
        raise StopIteration()
27

28

29
list(PrimeIter(1000))

1
pip install line_profiler
2
kernprof -lv example.py
3

4
Wrote profile results to example02.py.lprof
5
Timer unit: 1e-06 s
6

7
Total time: 0.089513 s
8
File: example02.py
9
Function: is_prime at line 1
10

11
 #      Hits         Time  Per Hit   % Time  Line Contents
12
==============================================================
13
 1                                           @profile
14
 2                                           def is_prime(num):
15
 3     86624      43305.0      0.5     48.4      for factor in range(2, int(num ** 0.5) + 1):
16
 4     85624      42814.0      0.5     47.8          if num % factor == 0:
17
 5      6918       3008.0      0.4      3.4              return False
18
 6      1000        386.0      0.4      0.4      return True

1
@profile
2
def eat_memory():
3
    items = []
4
    for _ in range(1000000):
5
        items.append(object())
6
    return items
7

8

9
eat_memory()