Python on GoodCoder's Blog

【Python】72行实现代码行数统计，简单实用！

Tue, 15 Mar 2022 15:24:00 +0800

前言

最近突然想知道自己总共写了多少行代码，于是做了这样一个小工具……

准备工作

先考虑一下希望得到的效果：

Language（语言）	Lines（代码行数）	Size（代码文件总大小）	Files（代码文件总数）
A	12345	300 KB	193
B	2345	165 KB	98

如上，程序输出一个表格，将代码行数作为关键字排序。
代码框架：

# -*- encoding: utf-8 -*-
import ...

# 代码行数计数类
class CodeLinesCounter(object):
    SIZES = [('B', 1), ('KB', 1024), ('MB', 1024**2), ('GB', 1024**3), ('TB', 1024**4)]
    
    def __init__(self, languages):
        self._languages = languages # 语言（dict,{文件后缀名：语言}）
        self._codelines = {suffix: (0, 0, 0) for suffix in languages} # 统计结果，{后缀名：(行数，大小，文件数)}
        self._successful = self._error = 0 # 记录成功、失败文件个数
    
    # @param directory: 要扫描的目录
    # @param log: 是否打印日志
    def scan(self, directory, log=False):
        if log: print('Scanning', directory)
        pass
    
    def report(self): # 输出结果
        pass

counter = CodeLinesCounter(languages={'py': 'Python', 'c': 'C', 'cpp': 'C++', 'java': 'Java', 'js': 'JavaScript', 'html': 'HTML', 'css': 'CSS', 'txt': 'Plain text'}) # 创建CodeLinesCounter实例
counter.scan('E:/') # 扫描E盘（注意不能用'E:'）
counter.report() # 输出结果

完成，下面正式进入==主要部分==

统计

文件扫描

首先，我们需要获取根目录下的文件列表。这可以用os.walk实现：
os.walk(rootdir)返回一个游走器（可迭代），包含根目录下每个子目录的文件及目录列表。我们来看一个例子：
有一文件夹Folder如下：

Folder
|   file1
|   Folder1
|       file2
|       file3
|   Folder2
    |   file4
    |   Folder3

运行如下代码：

import os

for root, dirs, files in os.walk('Folder'):
    print(root, dirs, files)

则输出如下：

Folder					['Folder1', 'Folder2']	['file1']
Folder\Folder1			[]						['file2', 'file3']
Folder\Folder2			['Folder3']				['file4']
Folder\Folder2\Folder3	[]						[]

其中第一项是当前的根目录，第二项为目录下的目录列表，第三项则为当前的文件列表。
因此，我们可以编写如下代码：

# -*- encoding: utf-8 -*-
from os.path import join, getsize, abspath
from os import walk

class CodeLinesCounter(object):
    SIZES = [('B', 1), ('KB', 1024), ('MB', 1024**2), ('GB', 1024**3), ('TB', 1024**4)]
    
    def __init__(self, languages):
        self._languages = languages
        self._results = {suffix: (0, 0, 0) for suffix in languages}
        self._successful = self._error = 0
    
    def scan(self, directory, log=False):
        if log: print('Scanning', directory)
        try:
            for root, _, files in walk(abspath(directory)):
                for filename in files:
                    suffix = filename[filename.rfind('.') + 1:]
                    filename = join(root, filename)
                    if suffix in self._results:
                        lines, size, numFiles = self._results[suffix]
                        lines += 1 # 暂不统计，先按一行计算
                        numFiles += 1
                        size += getsize(filename) # getsize返回文件大小（字节）
                        self._results[suffix] = (lines, size, numFiles)
                    if log: print(filename)
        except KeyboardInterrupt:
            print('\nUser stopped operation')
        else:
            if log: print('Scan finished')
    
    def report(self):
        print('Language\tLines\tSize\tFiles')
        for suffix, (lines, size, files) in sorted(self._results.items(), key=lambda x: x[1], reverse=True):
            print(self._languages[suffix], lines, self.__format_size(size), files, sep='\t')

    # 单位转换
    def __format_size(self, bytes):
        for suffix, size in self.SIZES:
            if bytes < size * 1024:
                return '%.2f %s' % (bytes / size, suffix)
        return '%.2f %s' % (bytes / self.SIZES[-1][1], 2, self.SIZES[-1][0])

counter = CodeLinesCounter(languages={'py': 'Python', 'c': 'C', 'cpp': 'C++', 'java': 'Java', 'js': 'JavaScript', 'html': 'HTML', 'css': 'CSS', 'txt': 'Plain text'})
counter.scan('E:/')
counter.report()

运行结果应类似于下面这样（手动整理了一下）：

Language        Lines   Size    		Files
C++     		667     671.51 KB       667
Python  		317     981.01 KB       317
HTML    		38      466.52 KB       38
Plain text    34      90.69 KB        34
JavaScript    19      1.43 MB			19
CSS     		9       341.04 KB       9
C       		2       20.45 KB        2
Java    		1       676.00 B        1

好，下面来到行数统计部分（表格输出后面会介绍）。

行数统计

众所周知，空行不应该算在代码行数中。因此，统计时需忽略空行。先写上如下代码（替换掉刚才的23行）：

with open(filename, 'r', encoding='utf-8') as f: # utf-8编码打开文件
    for line in f:
        if line and not line.isspace(): # 去掉空行
            lines += 1

但是，正当我们兴致勃勃地运行时——

Traceback (most recent call last):
  ...
  File "...\lib\codecs.py", line 322, in decode
    (result, consumed) = self._buffer_decode(data, self.errors, final)
UnicodeDecodeError: 'utf-8' codec can't decode byte 0xb5 in position 355: invalid start byte

程序报错UnicodeDecodeError，分析后发现原因是部分文件使用了GBK编码，而utf-8编码无法正确打开，因此造成错误。
我们再次改进程序，使其尝试两种编码：

try:
    ln = 0
    with open(filename, 'r', encoding='utf-8') as f:
        for line in f:
            if line and not line.isspace():
                ln += 1
except UnicodeDecodeError: # 尝试使用GBK编码打开
    try:
        ln = 0
        with open(filename, 'r', encoding='gbk') as f:
            for line in f:
                if line and not line.isspace():
                    ln += 1
    except:
        print(filename, '[Error: unknown encoding]')
        self._error += 1
    else:
        lines += ln
except Exception as e:
    print(filename, '[Unknown error: %s]' % e)
    self._error += 1
    continue
lines += ln
if log: print(f'{filename} [{ln}]')
self._successful += 1

这次，我们得到了正确的结果：

Language        Lines   Size    		Files
C++     		35595   671.51 KB       667
JavaScript    24485   1.43 MB 		19
Python  		24130   982.16 KB       317
CSS     		8203    341.04 KB       9
HTML    		6138    466.52 KB       38
Plain text    741     90.69 KB        34
C       		557     20.45 KB        2
Java    		29      676.00 B        1

现在仅剩最后一步了——制表。

制表

python输出表格可以使用PrettyTable库。具体用法如下：

# -*- encoding: utf-8 -*-
from os.path import join, getsize, abspath
from os import walk
from prettytable import PrettyTable

class CodeLinesCounter(object):
    SIZES = [('B', 1), ('KB', 1024), ('MB', 1024**2), ('GB', 1024**3), ('TB', 1024**4)]
    
    def __init__(self, languages):
        self._languages = languages
        self._results = {suffix: (0, 0, 0) for suffix in languages}
        self._successful = self._error = 0
    
    def scan(self, directory, log=False):
        if log: print('Scanning', directory)
        try:
            for root, _, files in walk(abspath(directory)):
                for filename in files:
                    suffix = filename[filename.rfind('.') + 1:]
                    filename = join(root, filename)
                    if suffix in self._results:
                        lines, size, numFiles = self._results[suffix]
                        numFiles += 1
                        size += getsize(filename)
                        try:
                            ln = 0
                            with open(filename, 'r', encoding='utf-8') as f:
                                for line in f:
                                    if line and not line.isspace():
                                        ln += 1
                        except UnicodeDecodeError: # Try 'gbk' encoding
                            try:
                                ln = 0
                                with open(filename, 'r', encoding='gbk') as f:
                                    for line in f:
                                        if line and not line.isspace():
                                            ln += 1
                            except:
                                print(filename, '[Error: unknown encoding]')
                                self._error += 1
                            else:
                                lines += ln
                        except Exception as e:
                            print(filename, '[Unknown error: %s]' % e)
                            self._error += 1
                            continue
                        lines += ln
                        if log: print(f'{filename} [{ln}]')
                        self._successful += 1
                        self._results[suffix] = (lines, size, numFiles)
                    elif log:
                        print(filename, '[None]')
        except KeyboardInterrupt:
            print('\nUser stopped operation')
        else:
            if log: print('Scan finished')
    
    def report(self):
        table = PrettyTable(['Language', 'Lines', 'Size', 'Files'], title=f'Scan result (OK {self._successful}, Error {self._error})') # 创建PrettyTable实例，添加标题
        for suffix, (lines, size, files) in sorted(self._results.items(), key=lambda x: x[1], reverse=True):
            table.add_row([self._languages[suffix], lines, self.__format_size(size), files]) # 添加行
        print(table) # 输出
    
    def __format_size(self, bytes):
        for suffix, size in self.SIZES:
            if bytes < size * 1024:
                return '%.2f %s' % (bytes / size, suffix)
        return '%.2f %s' % (bytes / self.SIZES[-1][1], 2, self.SIZES[-1][0])

counter = CodeLinesCounter(languages={'py': 'Python', 'c': 'C', 'cpp': 'C++', 'java': 'Java', 'js': 'JavaScript', 'html': 'HTML', 'css': 'CSS', 'txt': 'Plain text'})
counter.scan('E:/')
counter.report()

运行结果：

+----------------------------------------+
|     Scan result (OK 1087, Error 0)     |
+------------+-------+-----------+-------+
|  Language  | Lines |    Size   | Files |
+------------+-------+-----------+-------+
|    C++     | 35595 | 671.51 KB |  667  |
| JavaScript | 24485 |  1.43 MB  |   19  |
|   Python   | 24130 | 982.16 KB |  317  |
|    CSS     |  8203 | 341.04 KB |   9   |
|    HTML    |  6138 | 466.52 KB |   38  |
| Plain text |  741  |  90.69 KB |   34  |
|     C      |  557  |  20.45 KB |   2   |
|    Java    |   29  |  676.00 B |   1   |
+------------+-------+-----------+-------+

总结

最终代码（无注释）：

# -*- encoding: utf-8 -*-
from os.path import join, getsize, abspath
from os import walk
from prettytable import PrettyTable

class CodeLinesCounter(object):
    SIZES = [('B', 1), ('KB', 1024), ('MB', 1024**2), ('GB', 1024**3), ('TB', 1024**4)]
    
    def __init__(self, languages):
        self._languages = languages
        self._results = {suffix: (0, 0, 0) for suffix in languages}
        self._successful = self._error = 0
    
    def scan(self, directory, log=False):
        if log: print('Scanning', directory)
        try:
            for root, _, files in walk(abspath(directory)):
                for filename in files:
                    suffix = filename[filename.rfind('.') + 1:]
                    filename = join(root, filename)
                    if suffix in self._results:
                        lines, size, numFiles = self._results[suffix]
                        numFiles += 1
                        size += getsize(filename)
                        try:
                            ln = 0
                            with open(filename, 'r', encoding='utf-8') as f:
                                for line in f:
                                    if line and not line.isspace():
                                        ln += 1
                        except UnicodeDecodeError: # Try 'gbk' encoding
                            try:
                                ln = 0
                                with open(filename, 'r', encoding='gbk') as f:
                                    for line in f:
                                        if line and not line.isspace():
                                            ln += 1
                            except:
                                print(filename, '[Error: unknown encoding]')
                                self._error += 1
                            else:
                                lines += ln
                        except Exception as e:
                            print(filename, '[Unknown error: %s]' % e)
                            self._error += 1
                            continue
                        lines += ln
                        if log: print(f'{filename} [{ln}]')
                        self._successful += 1
                        self._results[suffix] = (lines, size, numFiles)
                    elif log:
                        print(filename, '[None]')
        except KeyboardInterrupt:
            print('\nUser stopped operation')
        else:
            if log: print('Scan finished')
    
    def report(self):
        table = PrettyTable(['Language', 'Lines', 'Size', 'Files'], title=f'Scan result (OK {self._successful}, Error {self._error})')
        for suffix, (lines, size, files) in sorted(self._results.items(), key=lambda x: x[1], reverse=True):
            table.add_row([self._languages[suffix], lines, self.__format_size(size), files])
        print(table)
    
    def __format_size(self, bytes):
        for suffix, size in self.SIZES:
            if bytes < size * 1024:
                return '%.2f %s' % (bytes / size, suffix)
        return '%.2f %s' % (bytes / self.SIZES[-1][1], 2, self.SIZES[-1][0])

counter = CodeLinesCounter(languages={'py': 'Python', 'c': 'C', 'cpp': 'C++', 'java': 'Java', 'js': 'JavaScript', 'html': 'HTML', 'css': 'CSS', 'txt': 'Plain text'})
counter.scan('E:/')
counter.report()

后期改进：

增加正则表达式忽略文件
matplotlib绘图
PyQt5GUI
……（欢迎提出宝贵的意见！）

Anaconda Spyder点击无响应解决

Sun, 12 Jul 2020 16:03:00 +0800

问题分析

可能是升级或卸载了spyder依赖的包，导致spyder无法正常运行。
我升级了PyQt5，spyder要求PyQt5<5.13，而安装的最新版本为5.15，导致spyder启动时出现问题。

解决方法

打开Anaconda Prompt，执行：

`1`	`pip install spyder`

解释：
pip会自动根据要安装的包（spyder也是一个包）安装依赖的包，如spyder要求PyQt5<5.13，安装PyQt5 5.15后pip会自动识别，并安装PyQt5 5.12.3（低于5.13的最高版本）。

20210926 EDIT：
如出现“拒绝访问”一类的错误，加上--user选项即可。

pip速度太慢解决（使用清华镜像）

Sun, 12 Jul 2020 14:56:00 +0800

python的包管理工具pip速度太慢，经常下载时报错，可以使用清华镜像代替默认下载源。以下两种方法任何电脑都可以使用，演示电脑为Windows 10 版本1909。

临时方法

使用pip下载时，临时使用镜像（命令行）：

`1`	`pip install <包名称> -i https://pypi.tuna.tsinghua.edu.cn/simple`

永久方法

打开命令行，执行：

`1`	`pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple`

1.1MB/s 2.2MB/s 6.8MB/s

P. S. 网上搜了$N$篇文章都说自己创建pip.ini文件…

【python爬虫】从腾讯API爬取美国疫情数据+制表

Wed, 03 Jun 2020 13:35:00 +0800

最近（文章撰写时间为2020/6/1 18:40）疫情在中国情况好转，却在美国暴虐。
本篇文章将爬取腾讯提供的美国疫情数据并制表。

爬取数据

调用API接口

接口：https://api.inews.qq.com/newsqa/v1/automation/modules/list?modules=FAutoCountryMerge
观察得到的数据：

{
    ...,
    "data": {
        "FAutoCountryMerge": {
            ...,
            "美国": {
                "showDash":false,
                "list": [
                    {"date":"01.28","confirm_add":0,"confirm":5,"heal":0,"dead":0},
                    ...,
                    {"date":"05.29","confirm_add":25069,"confirm":1768461,"heal":510713,"dead":103330},
                    {"date":"05.30","confirm_add":23290,"confirm":1793530,"heal":519569,"dead":104542},
                    {"date":"05.31","confirm_add":20350,"confirm":1816820,"heal":535238,"dead":105557},
                    {"date":"06.01","confirm_add":20350,"confirm":1837170,"heal":599867,"dead":106195}
                ]
            },
            ...
        }
    }
}

由如上代码所示，对于一个国家，获取其疫情数据只需要使用：

`1`	`json['data']['FAutoCountryMerge']['<国名>']['list']`

对于美国的数据，使用：

`1`	`json['data']['FAutoCountryMerge']['美国']['list']`

代码

上面都是干货，下面才是真正的code：

from requests import get

url = 'https://api.inews.qq.com/newsqa/v1/automation/modules/list?modules=FAutoCountryMerge'
data = get(url).json()['data']['FAutoCountryMerge']['美国']['list']

处理数据

在python中，其结果是一个list对象：

[
    {"date":"01.28","confirm_add":0,"confirm":5,"heal":0,"dead":0},
    ...,
    {"date":"05.29","confirm_add":25069,"confirm":1768461,"heal":510713,"dead":103330},
    {"date":"05.30","confirm_add":23290,"confirm":1793530,"heal":519569,"dead":104542},
    {"date":"05.31","confirm_add":20350,"confirm":1816820,"heal":535238,"dead":105557},
    {"date":"06.01","confirm_add":20350,"confirm":1837170,"heal":599867,"dead":106195}
]

该对象中存放美国每天的疫情数据，
date：从1月28日至今的日期；
confirm_add：该日新增确诊；
confirm：该日累计确诊；
heal：该日累计治愈；
dead：该日累计死亡。

筛选数据

数据的筛选很重要。

confirm_add（该日新增确诊）明显没有用，去掉
应该增加一个now_confirm（该日现存确诊），这样能清楚地看到美国治疗中人数。
该值可以通过confirm - heal - head得到。

date：从1月28日至今的日期
~~confirm_add：该日新增确诊~~
confirm：该日累计确诊
heal：该日累计治愈
dead：该日累计死亡
now_confirm: 该日现存确诊

代码

由于最前面人数太少，数据会影响到最终绘图质量。
所以，我从第35个开始保存数据，当然如果您想使用所有数据，将data[35:]改为data即可。

dates = []
confirms = []
now_confirms = []
heals = []
deads = []

for day_data in data[35:]:
    dates.append(day_data['date'])
    confirms.append(day_data['confirm'])
    heals.append(day_data['heal'])
    deads.append(day_data['dead'])
    now_confirms.append(confirms[-1] - heals[-1] - deads[-1])

绘图

参考文章：https://www.cnblogs.com/lone5wolf/p/10870200.html
由于我在绘图方面还是个小白，所以直接贴出代码，敬请谅解。。。

import matplotlib.pyplot as plt
from matplotlib.font_manager import FontProperties

# 绘制文本
plt.figure(figsize=(11.4, 7.7))

confirm_line, = plt.plot(dates, confirms, color='#8B0000')
now_confirm_line, = plt.plot(dates, now_confirms, color='red', linestyle=':')
heal_line, = plt.plot(dates, heals, color='green', linestyle='--')
dead_line, = plt.plot(dates, deads, color='black', linestyle='-.')

# 绘制图形
my_font = FontProperties(fname=r'fonts\msyh.ttc')
plt.legend(handles=[confirm_line, now_confirm_line, heal_line, dead_line], labels=['累计确诊', '现存确诊', '治愈', '死亡'], prop=my_font)
plt.xlabel('日期', fontproperties=my_font)
plt.ylabel('人数', fontproperties=my_font)
plt.title('美国2019-nCov疫情情况', fontproperties=my_font)
plt.gca().xaxis.set_major_locator(plt.MultipleLocator(7))

# 保存并显示统计图
plt.savefig('AmericaNCovData.png')
plt.show()

结果图片

完整代码

# -*- coding: utf-8 -*-
from requests import get
import matplotlib.pyplot as plt
from matplotlib.font_manager import FontProperties

url = 'https://api.inews.qq.com/newsqa/v1/automation/modules/list?modules=FAutoCountryMerge'
data = get(url).json()['data']['FAutoCountryMerge']['美国']['list']

dates = []
confirms = []
now_confirms = []
heals = []
deads = []

for day_data in data[35:]:
    dates.append(day_data['date'])
    confirms.append(day_data['confirm'])
    heals.append(day_data['heal'])
    deads.append(day_data['dead'])
    now_confirms.append(confirms[-1] - heals[-1] - deads[-1])

# 绘制文本
plt.figure(figsize=(11.4, 7.7))

confirm_line, = plt.plot(dates, confirms, color='#8B0000')
now_confirm_line, = plt.plot(dates, now_confirms, color='red', linestyle=':')
heal_line, = plt.plot(dates, heals, color='green', linestyle='--')
dead_line, = plt.plot(dates, deads, color='black', linestyle='-.')

# 绘制图形
my_font = FontProperties(fname=r'fonts\msyh.ttc')
plt.legend(handles=[confirm_line, now_confirm_line, heal_line, dead_line], labels=['累计确诊', '现存确诊', '治愈', '死亡'], prop=my_font)
plt.xlabel('日期', fontproperties=my_font)
plt.ylabel('人数', fontproperties=my_font)
plt.title('美国2019-nCov疫情情况', fontproperties=my_font)
plt.gca().xaxis.set_major_locator(plt.MultipleLocator(7))

# 保存并显示统计图
plt.savefig('AmericaNCovData.png')
plt.show()

代码下载：GitHub

Python函数之lambda函数

Tue, 21 Apr 2020 18:32:00 +0800

温馨提示：如果读者没有学过def定义函数，请先看这里

定义形式

`1`	`<函数名> = lambda <参数列表>: <返回值>`

等同于：

1
2

def <函数名>(<参数列表>):
    return <返回值>

也可以定义为匿名函数（没有名字的函数）：

`1`	`lambda <参数列表>: <返回值>`

可以确认lambda函数对象的类型与def定义的一样，都是function：

调用

如果是匿名函数，调用形式为：

`1`	`(lambda <参数列表>: <返回值>)(<参数列表>)`

如果不是，调用形式为：

`1`	`<函数名>(<参数列表>)`

计算$a+b$的函数：

无返回值

lambda函数也可无返回值。
如：

无返回值的lambda函数一般用于做事，如print('Hello World')等。

Python函数之def定义函数

Tue, 21 Apr 2020 13:22:00 +0800

链接

想研究Python函数？看这里
函数怎样取名？看这里
有参数的函数还可以怎么传参？看这里

一、无参数函数

结构

1
2
3

def <函数名>(): # 强制要求
    <函数体> # 可省略
    return <返回值> # 可省略

程序举例

用函数的Hello world程序：

# prints 'Hello World\nDone'
# Author: GoodCoder666
def getHelloWorldString():
    return 'Hello World'
def print_hello_world():
    print(getHelloWorldString())
print_hello_world()
print('Done')
# 输出：
# Hello World
# Done

程序流程

  flowchat
st=>start: 开始，调用print_hello_world()
e=>end: 结束
get_str_call=>operation: print_hello_world()调用getHelloWorldString()
return_str=>operation: getHelloWorldString()返回 'Hello world'
print_hi=>inputoutput: 回到print_hello_world()，输出Hello world
done=>inputoutput: 回到主程序，输出Done

st->get_str_call->return_str->print_hi->done->e

二、有参数函数

补充知识

参数 (parameter)：给函数的值，在函数中相当于变量：

def param_test(a, b):
    a, b = b, a
    print(a, b)
param_test(5, 6) # 输出：6 5

以上程序等同于：

def param_test():
    a, b = 5, 6
    #-----以下部分相同-----#
    a, b = b, a
    print(a, b)
param_test() # 输出：6 5

结构

1
2
3

def <函数名>(<参数列表>): # 强制要求
    <函数体> # 可省略
    return <返回值> # 可省略

其中，参数列表中的参数用,隔开，例如a, b 、c（如果只有一个参数直接写）

程序举例

# prints 'Hi, {name}!'
# Author: GoodCoder666
def get_greet_str(name):
    return 'Hi, ' + name + '!'

def greet(name):
    print(get_greet_str(name))

greet(input("What's your name? "))
print('Done')
# 输入: GoodCoder666
# 输出
# Hi, GoodCoder666!
# Done

程序流程

  flowchat
st=>start: 开始，调用input("What's your name?")
e=>end: 结束
call_greet=>operation: input返回用户名，调用greet(<用户名>)
call_get_greet_str=>operation: greet调用get_greet_str(<用户名>)
print_hi=>inputoutput: 回到get_greet_str，输出get_greet_str的返回值
done=>inputoutput: 回到主程序，输出Done

st->call_greet->call_get_greet_str->print_hi->done->e

函数也是对象

一个函数也是一个对象。

证明

先定义两个函数：

def a(a, b):
    return a + b
def b():
    return a(1, 2)

项目	是否支持/存在	证明
赋值	Y	`c = a`可执行；执行后`c`可被调用
属性	Y	执行`type(a)`，返回`class <'function'>`
类型	Y

【Python】对象（包括类、函数）取名方法

Mon, 20 Apr 2020 22:03:00 +0800

先上干货，通用的：
字母：A-Z a-z
下划线：_
数字：0-9（注意：数字不能在开头）
==理论上可以使用中文变量名，但强烈不建议使用。==

合法名字举例

1
2
3

abcdef	GoodCoder	AD_fhrygfuigfr
A_a_007	__NAME123	_P_T_
_123456	Cc_Dd	_

不合法名字举例

1
2
3

666Code	C++	1+1=2	(5)4
654ty54F	0.123	123456@qq.com
ccf-csp		atcoder&codeforces

取名风格

首字母一般（类除外）小写。
由于对象名称中不能有空格，所以有两种风格：

1
2

helloWorldStr = 'Hello World'
hello_world_str = 'Hello World'

取名为helloWorldStr，将每个单词（除第一个hello）首字母大写；
取名为hello_world_str，将每两个单词之间加一个下划线（_）。

特例：类

举个例子：

1
2
3

class AppleTree:
    def dropApple():
        print('Apple dropped to the ground.')

AppleTree是将每个单词（第一个apple也不例外）首字母大写。

tkinter Text edit_undo()/edit_redo() 没反应解决方法

Tue, 24 Mar 2020 19:37:00 +0800

问题

tkinter.Text调用edit_undo()和edit_redo()没反应。

问题分析

这是因为没有设置Text的undo参数为True，设置后才能“激活”edit_undo()和edit_redo()。
这个错误难发现是因为它没有报错，查了好多资料才发现……
希望以后python官方能改进这点。

解决方法

from tkinter import *

root = Tk()
root.title('Undo/redo test')
text = Text(root, undo=True)
#                 ^^^^^^^^^
#                   重要！
text.insert(END, 'Hello tkinter!')
text.edit_undo()
text.edit_redo()

root.mainloop()

Python函数之*[参数名]和**[参数名]的用处

Tue, 03 Mar 2020 19:19:00 +0800

一、*[参数名]

调用

合法调用

普通调用

*参数名一般写成*args, 如：

1
2

def func(*args):
    print(args)

可以试着调用func：

>>> func(1)
(1,)
>>> func()
()
>>> func(1, 2, 3)
(1, 2, 3)
>>> func(dict(), set(), str(), int())
({}, set(), '', 0)

所以，我们发现，这样的函数可以传任意个参数（包括0），*会把参数打包成一个tuple，如(1,) () (1, 2, 3) ({}, set(), '', 0)。

特殊调用

如果已经有一个tuple对象，想传进去作为args呢？
首先定义一个tuple对象：

1
2
3

>>> tuple_object = (1, 2, 3)
>>> print(tuple_object)
(1, 2, 3)

错误方法

一般想到的都是这样的方法：

1
2

>>> func(tuple_object)
((1, 2, 3),)

((1, 2, 3),)? 不应该是(1, 2, 3)吗？
因为系统把它识别为一个args中的参数，所以args就是“tuple中有tuple”，不对。OH NO!

正确方法

给tuple_object前面打个*，OK：

1
2

>>> func(*tuple_object)
(1, 2, 3)

这就是“解包”。

非法调用

如果调用func(a=1, b=2)呢？请看：

`1`	`>>> func(a=1, b=2)`

得到TypeError:

Traceback (most recent call last):
  File "<*args test file>", line 1, in <module>
    func(a=1, b=2)
TypeError: func() got an unexpected keyword argument 'a'

错误中，keyword argument是什么？

keyword argument是像a=1 b=2 c='Hi'这样的传参形式。
简单地说，keyword argument就是name=value形式的传参。

所以，应该用value形式的传参（英文是positional argument），而不应该使用name=value的传参。

默认参数

*[参数名]的参数不能有默认参数：

如上图，尝试设置默认参数会报SyntaxError，如果真要设置默认参数，应该用一种类似“手动设置默认值”的办法：

# 手动设置*args的参数默认值
DEFAULT_VALUE = (1, 2, 3) # 默认值，可自行改变
def func(*args):
    if args == (): # 如果为空（用户没有传递参数）:
        args = DEFAULT_VALUE # 设为默认值
    print(args)

这样，就有默认值了：

1
2

>>> func() # 无参数调用
(1, 2, 3)

总结

*[参数名]表示应使用value形式传参，参数个数不限，传入后会打包成tuple，供函数体使用。
特殊传参方法：*[tuple object]
这种方法不能设置默认值，只能用“手动设置默认值”。

二、**[参数名]

调用

合法调用

普通调用

**参数名一般写成**kwargs, 如：

1
2

def func(**kwargs): # kwargs = keyword arguments
    print(kwargs)

然后调用func，但是这个跟上一个相反，必须是name=value式传参（这也是为什么它叫kwargs (keyword arguments)）：

>>> func(a=1, b=2, c=3, d=4)
{'a': 1, 'b': 2, 'c': 3, 'd': 4}
>>> func(_tuple_obj=tuple(), _set_obj=set(), _dict_obj=dict())
{'_tuple_obj': (), '_set_obj': set(), '_dict_obj': {}}
>>> func()
{}

这样的函数可以传任意个keyword argument（包括0），这里也与上一个相反，会把参数打包成一个dict，如{'a': 1, 'b': 2, 'c': 3, 'd': 4} {'_tuple_obj': (), '_set_obj': set(), '_dict_obj': {}} {}。

特殊调用

如果已经有一个dict对象，想传进去作为kwargs呢？
首先定义一个这样的对象：

1
2
3

>>> dict_object = {'a': 666, 'b': 888}
>>> print(dict_object)
{'a': 666, 'b': 888}

然后，跟上次相似：

>>> func(dict_object) # 因为不能传positional argument, 这下还报错了（马上会讲到）：
Traceback (most recent call last):
  File "<**kwargs test program>", line 1, in <module>
    func(dict_object)
TypeError: func() takes 0 positional arguments but 1 was given
>>> func(**dict_object) # 正确方法
{'a': 666, 'b': 888}

非法调用

如果传递positional argument呢？请看：

`1`	`>>> func(1, 2)`

得到TypeError:

Traceback (most recent call last):
  File "<**kwargs test program>", line 1, in <module>
    func(1, 2)
TypeError: func() takes 0 positional arguments but 2 were given

所以，这里应该用key=value形式的传参（英文是keyword argument），而不应该使用value的传参方法。

默认参数

与*args的方法类似，应该用手动设置默认值”的方法：

# 手动设置**kwargs的参数默认值
DEFAULT_VALUE = {'a': 1, 'b': 2} # 默认值，可自行改变
def func(**kwargs):
    if kwargs == {}: # 如果为空（用户没有传递参数）:
        kwargs = DEFAULT_VALUE # 设为默认值
    print(kwargs)

这样，就有默认值了：

1
2

>>> func() # 无参数调用
{'a': 1, 'b': 2}

总结

**[参数名]表示应使用key=value形式传参，参数个数不限，传入后会打包成dict。
特殊传参方法：**[dict object]
这种方法不能设置默认值，也只能用“手动设置默认值”。