psutil是一个跨平台库模块，能够获取系统运行的进程和系统的CPU，内存，磁盘，网络等信息，它实现了同等命令行工具提供的功能，如ps,top,lsof,netstat,ifconfig,who,df,kill,free,nice等。

psutil环境准备

安装psutil模块

可以使用pip来安装psutil：

pip install psutil

导入psutil模块

import psutil

完成环境的准备后，就可以使用psutil来获取系统的CPU，内存，硬盘等信息了。

psutil的使用

获取CPU信息

封装了一个简单的获取cpu信息的函数：

def get_cpu_info():
    cpu_count = psutil.cpu_count(logical=False)  #1代表单核CPU，2代表双核CPU  
    xc_count = psutil.cpu_count()                #线程数，如双核四线程
    cpu_percent = round((psutil.cpu_percent(1)), 2)  # cpu使用率
    cpu_info = (cpu_count,xc_count,cpu_percent)
    return cpu_info

获取内存信息

封装了一个简单的获取内存信息的函数：

def get_memory_info():
    memory = psutil.virtual_memory()
    total_nc = round(( float(memory.total) / 1024 / 1024 / 1024), 2)  # 总内存
    used_nc = round(( float(memory.used) / 1024 / 1024 / 1024), 2)  # 已用内存
    free_nc = round(( float(memory.free) / 1024 / 1024 / 1024), 2)  # 空闲内存
    percent_nc = round((float(memory.used) / float(memory.total) * 100), 2)  # 内存使用率
 
    men_info= （total_nc,used_nc,free_nc,percent_nc）
    return men_info

获取硬盘信息

def get_disk_info():
    list = psutil.disk_partitions() #磁盘列表
    ilen = len(list) #磁盘分区个数
    i=0
    retlist1=[]
    retlist2=[]
    while i< ilen:
        diskinfo = psutil.disk_usage(list[i].device)
        total_disk = round((float(diskinfo.total)/1024/1024/1024),2) #总大小
        used_disk = round((float(diskinfo.used) / 1024 / 1024 / 1024), 2) #已用大小
        free_disk = round((float(diskinfo.free) / 1024 / 1024 / 1024), 2) #剩余大小
        percent_disk = diskinfo.percent
 
        retlist1=[i,list[i].device,total_disk,used_disk,free_disk,percent_disk]  #序号，磁盘名称，
        disk_info_list.append(retlist1)  
        i=i+1
 
    return disk_info_list

Python转换字节为字符串可以使用decode函数，但decode函数在Python 2和Python3有所不同。

Python 2.7

help查看decode的函数说明

>>> help(b''.decode)
Help on built-in function decode:

decode(...)
  S.decode([encoding[,errors]]) -> object

  Decodes S using the codec registered for encoding. encoding defaults
  to the default encoding. errors may be given to set a different error
  handling scheme. Default is 'strict' meaning that encoding errors raise
  a UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
  as well as any other name registered with codecs.register_error that is
  able to handle UnicodeDecodeErrors.

Python 2.7的decode函数如果缺失encoding，使用的是系统默认的编码。

获取系统的默认编码

>>> import sys
>>> sys.getdefaultencoding()
'ascii'

这里的系统默认编码为ascii，如果是非‘ascii’使用decode函数不指定编码会抛出异常

>>> s=u'你好'
>>> b=s.encode('utf8')
>>> print b.decode()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
UnicodeDecodeError: 'ascii' codec can't decode byte 0xe4 in position 0: ordinal
not in range(128)
>>>
>>> print b.decode('utf8')
你好

字符串s使用utf8编码得到字节b，使用decode直接对字节b解码时，报ascii解码不了字节。使用decode指定解码为utf8后，解码正确。

所以，在Python 2使用decode对字节解码时，建议指定编码。

Python 3.x

使用help查看decode的帮助说明

>>> help(b''.decode)
Help on built-in function decode:

decode(encoding='utf-8', errors='strict') method of builtins.bytes instance
  Decode the bytes using the codec registered for encoding.

  encoding
   The encoding with which to decode the bytes.
  errors
   The error handling scheme to use for the handling of decoding errors.
   The default is 'strict' meaning that decoding errors raise a
   UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
   as well as any other name registered with codecs.register_error that
   can handle UnicodeDecodeErrors.

可以看出Python3中decode函数的默认编码指定为了utf-8。所以

b'hello'.decode()

等同于

b'hello'.decode('utf-8')

>>> s='你好'
>>> b=s.encode('utf8')
>>> b.decode()
'你好'

在这个例子里，你会看到对字符串s的赋值，‘你好’是没有u作为前缀。这是因为系统的默认编码为utf8

查看系统编码

>>> import sys
>>> sys.getdefaultencoding()
'utf-8'

在python 3，系统的默认编码为utf-8

Python处理用户输入需要考虑几个问题：

1. 用户输入的数据是否合法
2. 用户输入非法数据是否会抛出异常
3. 用户输入非法数据后，给出友好提示并等待继续输入

在Python里比较简单的做法是使用一直循环，如果用户输入错误数据，执行continue继续等待用户输入，如果用户输入正确数据，执行break跳出循环。

用户输入可能会抛出异常

这里需要使用try-catch来捕获用户输入非法数据导致的异常。

python 3.x

while True:
    try:
        age = int(input("请输入您的年龄: "))
    except ValueError:
        print("您输入的不是年龄")
        #继续等待输入
        continue
    else:
        #输入正确的数据（年龄），跳出循环
        break
if age >= 18: 
    print("已满18岁")
else:
    print("未满18岁")

添加校验规则

如果需要对数据进行校验，可以添加自定义的校验规则，如只允许用户输入A，B，C和D，不区分大小写

while True:
    data = input("输入A到D之间的字母:")
    if data.lower() not in ('a', 'b', 'c', 'd'):
        print("输入错误字母")
    else:
        break

组合使用异常处理与自定义校验

有些情况既需要处理异常，也需要添加自定义的校验规则，如用户输入年龄要求为数字，并且不能为负数

while True:
    try:
        age = int(input("请输入您的年龄: "))
    except ValueError:
        print("您输入的不是年龄")
        continue

    if age < 0:
        print("年龄不能为负数")
        continue
    else:
        #输入正确的年龄，退出循环
        break
if age >= 18: 
    print("已满18岁")
else:
    print("未满18岁")

抽取处理用户输入的功能为函数

除了处理数字外，我们可能需要处理不同类型的用户输入，抽取出一个比较公用的处理用户输入的方法

def sanitised_input(prompt, type_=None, min_=None, max_=None, range_=None):
    if min_ is not None and max_ is not None and max_ < min_:
        raise ValueError("min_必须小于或等于max_.")
    while True:
        ui = input(prompt)
        if type_ is not None:
            try:
                ui = type_(ui)
            except ValueError:
                print("输入类型必须是{0}。".format(type_.__name__))
                continue
        if max_ is not None and ui > max_:
            print("输入的值必须小于或等于0}。".format(max_))
        elif min_ is not None and ui < min_:
            print("输入的值必须大于或等于{0}。".format(min_))
        elif range_ is not None and ui not in range_:
            if isinstance(range_, range):
                template = "输入的值必须在{0.start}与{0.stop}之间。"
                print(template.format(range_))
            else:
                template = "输入的值必须为{0}。"
                if len(range_) == 1:
                    print(template.format(*range_))
                else:
                    print(template.format(" 或 ".join((", ".join(map(str,
                                                                     range_[:-1])),
                                                       str(range_[-1])))))
        else:
            return ui

使用示例：

age = sanitised_input("E请输入您的年龄 ", int, 1, 101)
answer = sanitised_input("请输入您的答案", str.lower, range_=('a', 'b', 'c', 'd'))

参考：Asking the user for input until they give a valid response

Python是一门非BS编程语言。可读性和设计简单性是其广受欢迎的两个主要原因。
 

正如Python的禅宗所说：
 

美丽胜于丑陋。 
显式胜于隐式。

这就是为什么值得记住一些常见的Python技巧来帮助改善代码设计的原因。这些将为你节省每次需要到Stack Overflow找解决方案的时间。
 

在日常编码练习中，以下技巧将非常有用。
 

1.反转字符串

以下代码段使用Python切片操作来反转字符串。
 

# Reversing a string using slicing
my_string = "ABCDE"
reversed_string = my_string[::-1]
print(reversed_string)
# Output
# EDCBA

如果想了解更多，可以看这篇文章

2、使用标题格式（首字母大写）

以下代码段可用于将字符串转换为标题大小写。这是使用字符串类的title（）方法完成的。

my_string = "my name is chaitanya baweja"
# using the title() function of string class
new_string = my_string.title()
print(new_string)
# Output
# My Name Is Chaitanya Baweja

3、在字符串中查找唯一元素

以下代码段可用于查找字符串中的所有唯一元素。我们使用set的特性，即集合中的所有元素都是唯一的

my_string = "aavvccccddddeee"
# converting the string to a set
temp_set = set(my_string)
# stitching set into a string using join
new_string = ''.join(temp_set)
print(new_string)

4、多次打印字符串或列表

你可以对字符串或列表使用乘号（*）。这好像我们可以将它们任意倍增一样。

n = 3 # number of repetitions
my_string = "abcd"
my_list = [1,2,3]
print(my_string*n)
# abcdabcdabcd
print(my_list*n)
# [1,2,3,1,2,3,1,2,3]

一个有趣的用例是定义一个具有特定值的列表-假设为值0

n = 4
my_list = [0]*n # n denotes the length of the required list
# [0, 0, 0, 0]

5、列表理解

列表理解为我们提供了一种基于其他列表创建列表的优雅方法。

以下代码段通过将旧列表的每个元素乘以2来创建新列表。

# Multiplying each element in a list by 2
original_list = [1,2,3,4]
new_list = [2*x for x in original_list]
print(new_list)
# [2,4,6,8]

更多信息可以查看这篇文章。

6、在两个变量之间交换值

Python做交互两个变量的值是很简单的，不需要使用到另外一个变量。

a = 1
b = 2
a, b = b, a
print(a) # 2
print(b) # 1

7、将字符串拆分为子字符串列表

我们可以使用字符串类中的.split()方法将字符串拆分为子字符串列表。另外我们可以给split()指定分隔符。

string_1 = "My name is Chaitanya Baweja"
string_2 = "sample/ string 2"
# default separator ' '
print(string_1.split())
# ['My', 'name', 'is', 'Chaitanya', 'Baweja']
# defining separator as '/'
print(string_2.split('/'))
# ['sample', ' string 2']

8.合并字符串列表为单个字符串中

join()方法将作为参数传递的字符串列表合并为单个字符串。在我们的用例里，我们使用逗号分隔符将它们分开。
 

list_of_strings = ['My', 'name', 'is', 'Chaitanya', 'Baweja']
# Using join with the comma separator
print(','.join(list_of_strings))
# Output
# My,name,is,Chaitanya,Baweja

9、检查字符串是否是回文

my_string = "abcba"
if my_string == my_string[::-1]:
    print("palindrome")
else:
    print("not palindrome")
# Output
# palindrome

10、统计列表中元素的出现频率

这样做有多种方法，但是我最喜欢的是使用Python Counter类。

Python counter会跟踪容器中每个元素的频率。 Counter()返回一个字典，其中元素作为键，而频率作为值。

我们还使用most_common()函数来获取列表中的出现频率最高的元素。

# finding frequency of each element in a list
from collections import Counter
my_list = ['a','a','b','b','b','c','d','d','d','d','d']
count = Counter(my_list) # defining a counter object
print(count) # Of all elements
# Counter({'d': 5, 'b': 3, 'a': 2, 'c': 1})
print(count['b']) # of individual element
# 3
print(count.most_common(1)) # most frequent element
# [('d', 5)]

11、检查两个字符串是否为字谜

Counter类的一个有趣应用是查找字谜。

字谜是通过重新排列不同单词或短语的字母而形成的单词或短语。

如果两个字符串的Counter对象相等，那么它们就是字谜。

from collections import Counter
str_1, str_2, str_3 = "acbde", "abced", "abcda"
cnt_1, cnt_2, cnt_3  = Counter(str_1), Counter(str_2), Counter(str_3)
if cnt_1 == cnt_2:
    print('1 and 2 anagram')
if cnt_1 == cnt_3:
    print('1 and 3 anagram')

12、使用try-except-else代码块

使用try/except块可以轻松完成Python中的错误处理。在代码块中添加else语句可能会很有用，它会在try块中没有引发异常的情况下运行。
 

如果想在不管是否发生异常，都要执行的内容，需要使用finally。

a, b = 1,0
try:
    print(a/b)
    # exception raised when b is 0
except ZeroDivisionError:
    print("division by zero")
else:
    print("no exceptions raised")
finally:
    print("Run this always")

13、使用enumerate来获取键值对的索引和值

以下脚本使用枚举遍历列表中的值及其索引。

my_list = ['a', 'b', 'c', 'd', 'e']
for index, value in enumerate(my_list):
    print('{0}: {1}'.format(index, value))
# 0: a
# 1: b
# 2: c
# 3: d
# 4: e

14、检查对象的内存使用情况

以下脚本可用于检查对象的内存使用情况。

import sys
num = 21
print(sys.getsizeof(num))
# In Python 2, 24
# In Python 3, 28

15、合并两个字典

在Python 2中，我们使用了update()方法来合并两个字典。 Python 3.5使这一过程变得更加简单。

在下面给出的脚本中，两个字典被合并。在相交的情况下(即出现相同的键时)，使用第二个字典中的值。

dict_1 = {'apple': 9, 'banana': 6}
dict_2 = {'banana': 4, 'orange': 8}
combined_dict = {**dict_1, **dict_2}
print(combined_dict)
# Output
# {'apple': 9, 'banana': 4, 'orange': 8}

16、统计执行一段代码的耗时

以下代码片段使用时间库来计算执行一段代码的耗时。

import time
start_time = time.time()
# Code to check follows
a, b = 1,2
c = a+ b
# Code to check ends
end_time = time.time()
time_taken_in_micro = (end_time- start_time)*(10**6)
print(" Time taken in micro_seconds: {0} ms").format(time_taken_in_micro)

17、展开嵌套的列表

有时，您不确定列表的嵌套深度，只希望将所有元素放在一个平面列表中。

from iteration_utilities import deepflatten
# if you only have one depth nested_list, use this
def flatten(l):
  return [item for sublist in l for item in sublist]
l = [[1,2,3],[3]]
print(flatten(l))
# [1, 2, 3, 3]
# if you don't know how deep the list is nested
l = [[1,2,3],[4,[5],[6,7]],[8,[9,[10]]]]
print(list(deepflatten(l, depth=3)))
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

如果有正确格式化的数组，则Numpy Flatten是执行此操作的更好方法。
 

18、从列表中采样

以下代码段使用随机库从给定列表中生成了n个随机样本。

出于加密安全考虑，推荐使用使用secrets库来生成的随机样本。以下代码段仅适用于Python 3：

import secrets                              # imports secure module.
secure_random = secrets.SystemRandom()      # creates a secure random object.
my_list = ['a','b','c','d','e']
num_samples = 2
samples = secure_random.sample(my_list, num_samples)
print(samples)
# [ 'e', 'd'] this will have any 2 random values

19、数​​字化

以下代码段会将整数转换为数字列表。
 

num = 123456
# using map
list_of_digits = list(map(int, str(num)))
print(list_of_digits)
# [1, 2, 3, 4, 5, 6]
# using list comprehension
list_of_digits = [int(x) for x in str(num)]
print(list_of_digits)
# [1, 2, 3, 4, 5, 6]

20、检查唯一性

以下函数将检查列表中的所有元素是否唯一。

def unique(l):
    if len(l)==len(set(l)):
        print("All elements are unique")
    else:
        print("List has duplicates")
unique([1,2,3,4])
# All elements are unique
unique([1,1,2,3])
# List has duplicates

原文：20 Python Snippets You Should Learn Today

使用的是PyCharm2018.3.4

代码的自动补全

在PyCharm中找到Power Save Mode选项，将前面的对勾去掉。

• 在左上角File的展开栏的倒数第二行

• 在PyCharm的最右下角有个👷的样子（在🔒旁边），单击点开就可看到Power Save Mode选项

  • 在这个Current inspection profile中可以设置Highlighting Level即检查代码严格程度。（过多的不致命波浪线就是这个造成的）

  但是實際上在補全代碼的時候，我這樣設置以後并不會提示導入"包"。我也不知道爲什麽~

设置默认PyCharm解析器：

操作如下：

Python–>Preferences–>Project Interpreter–>Python Interpreter 点击“+”号选择系统安装的Python。

设置编辑器“颜色与字体”主题

File -> Settings -> Editor -> Colors & Fonts -> Scheme name -> 选择“Darcula”

修改字体大小

 File -> Settings -> Editor -> Colors & Fonts -> Font -> Size -> 设置为“14”

“代码自动完成”时间延时设置

File -> Settings -> Editor -> Code Completion
 -> Auto code completion in (ms):0
 -> Autopopup in (ms):500

PyCharm3.0默认快捷键(翻译的)

PyCharm Default Keymap

1、编辑（Editing）

Ctrl + Space 基本的代码完成（类、方法、属性）
Ctrl + Alt + Space 快速导入任意类
Ctrl + Shift + Enter 语句完成
Ctrl + P 参数信息（在方法中调用参数）

Ctrl + Q 快速查看文档

F1 外部文档

Shift + F1 外部文档，进入web文档主页

Ctrl + Shift + Z --> Redo 重做

Ctrl + 悬浮/单击鼠标左键 简介/进入代码定义
Ctrl + F1 显示错误描述或警告信息
Alt + Insert 自动生成代码
Ctrl + O 重新方法
Ctrl + Alt + T 选中
Ctrl + / 行注释/取消行注释
Ctrl + Shift + / 块注释
Ctrl + W 选中增加的代码块
Ctrl + Shift + W 回到之前状态
Ctrl + Shift + ]/[ 选定代码块结束、开始
Alt + Enter 快速修正
Ctrl + Alt + L 代码格式化
Ctrl + Alt + O 优化导入
Ctrl + Alt + I 自动缩进
Tab / Shift + Tab 缩进、不缩进当前行
Ctrl+X/Shift+Delete 剪切当前行或选定的代码块到剪贴板
Ctrl+C/Ctrl+Insert 复制当前行或选定的代码块到剪贴板
Ctrl+V/Shift+Insert 从剪贴板粘贴
Ctrl + Shift + V 从最近的缓冲区粘贴
Ctrl + D 复制选定的区域或行
Ctrl + Y 删除选定的行
Ctrl + Shift + J 添加智能线
Ctrl + Enter 智能线切割
Shift + Enter 另起一行
Ctrl + Shift + U 在选定的区域或代码块间切换
Ctrl + Delete 删除到字符结束
Ctrl + Backspace 删除到字符开始
Ctrl + Numpad+/- 展开/折叠代码块（当前位置的：函数，注释等）
Ctrl + shift + Numpad+/- 展开/折叠所有代码块
Ctrl + F4 关闭运行的选项卡
2、查找/替换(Search/Replace)
F3 下一个
Shift + F3 前一个
Ctrl + R 替换
Ctrl + Shift + F 或者连续2次敲击shift 全局查找{可以在整个项目中查找某个字符串什么的，如查找某个函数名字符串看之前是怎么使用这个函数的}
Ctrl + Shift + R 全局替换
3、运行(Running)
Alt + Shift + F10 运行模式配置
Alt + Shift + F9 调试模式配置
Shift + F10 运行
Shift + F9 调试
Ctrl + Shift + F10 运行编辑器配置
Ctrl + Alt + R 运行manage.py任务
4、调试(Debugging)
F8 跳过
F7 进入
Shift + F8 退出
Alt + F9 运行游标
Alt + F8 验证表达式
Ctrl + Alt + F8 快速验证表达式
F9 恢复程序
Ctrl + F8 断点开关
Ctrl + Shift + F8 查看断点
5、导航(Navigation)
Ctrl + N 跳转到类
Ctrl + Shift + N 跳转到符号

Alt + Right/Left 跳转到下一个、前一个编辑的选项卡（代码文件）

Alt + Up/Down跳转到上一个、下一个方法

F12 回到先前的工具窗口
Esc 从工具窗口回到编辑窗口
Shift + Esc 隐藏运行的、最近运行的窗口
Ctrl + Shift + F4 关闭主动运行的选项卡
Ctrl + G 查看当前行号、字符号
Ctrl + E 当前文件弹出，打开最近使用的文件列表
Ctrl+Alt+Left/Right 后退、前进

Ctrl+Shift+Backspace 导航到最近编辑区域 {差不多就是返回上次编辑的位置}

Alt + F1 查找当前文件或标识
Ctrl+B / Ctrl+Click 跳转到声明
Ctrl + Alt + B 跳转到实现
Ctrl + Shift + I查看快速定义
Ctrl + Shift + B跳转到类型声明

Ctrl + U跳转到父方法、父类

Ctrl + ]/[跳转到代码块结束、开始

Ctrl + F12弹出文件结构
Ctrl + H类型层次结构
Ctrl + Shift + H方法层次结构
Ctrl + Alt + H调用层次结构
F2 / Shift + F2下一条、前一条高亮的错误
F4 / Ctrl + Enter编辑资源、查看资源
Alt + Home显示导航条F11书签开关
Ctrl + Shift + F11书签助记开关
Ctrl + #[0-9]跳转到标识的书签
Shift + F11显示书签
6、搜索相关(Usage Search)
Alt + F7/Ctrl + F7文件中查询用法
Ctrl + Shift + F7文件中用法高亮显示
Ctrl + Alt + F7显示用法
7、重构(Refactoring)
F5复制F6剪切
Alt + Delete安全删除
Shift + F6重命名
Ctrl + F6更改签名
Ctrl + Alt + N内联
Ctrl + Alt + M提取方法
Ctrl + Alt + V提取属性
Ctrl + Alt + F提取字段
Ctrl + Alt + C提取常量
Ctrl + Alt + P提取参数
8、控制VCS/Local History
Ctrl + K提交项目
Ctrl + T更新项目
Alt + Shift + C查看最近的变化
Alt + BackQuote(’)VCS快速弹出
9、模版(Live Templates)
Ctrl + Alt + J当前行使用模版
Ctrl +Ｊ插入模版
10、基本(General)
Alt + #[0-9]打开相应的工具窗口
Ctrl + Alt + Y同步
Ctrl + Shift + F12最大化编辑开关
Alt + Shift + F添加到最喜欢
Alt + Shift + I根据配置检查当前文件
Ctrl + BackQuote(’)快速切换当前计划
Ctrl + Alt + S　打开设置页
Ctrl + Shift + A查找编辑器里所有的动作

Ctrl + Tab在窗口间进行切换

Pycharm中注释

①在程序行前面加“#”

②将需要注释的代码用’’’----’’’ 包起来，此方法类似C的注释方法

③方法一的快捷方式：将需要注释的代码选住然后利用“Ctrl+/”进行注释

http://www.jetbrains.com/help/pycharm/settings-code-completion.html

元组

original = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]

转换后

result = (['a', 'b', 'c', 'd'], [1, 2, 3, 4])

使用zip(*list)来实现

>>> list = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> zip(*list)
(['a', 'b', 'c', 'd'], [1, 2, 3, 4])

zip()函数会把所有的输入配对，如第一个元素配对，然后第二个元素配对...，

*list则是把列表拆分为单独的元组作为zip()函数的输入，否则zip()会把整个list作为第一个元素。

pycharm激活码获取（2019）

1、打开网址： lookdiv.com 

2、在输入框输入钥匙：lookdiv.com

3、点击获取激活码按钮，获取激活码

pip3升级到10.0.0后，安装numpy报错：

~$ pip3 install numpy
Traceback (most recent call last):
  File "/usr/bin/pip3", line 9, in <module>
    from pip import main
ImportError: cannot import name 'main'

Python版本为3.6.1。

在github上开了一个issue，里面提到一个方案说原因是在hash缓存了旧的pip3，要使用新安装的需要清理hash，如下：

bash

$ hash -d pip

dash（sh）

$ hash -r pip

基本命令

conda upgrade --all #默认情况下更新所有的包
conda install package_name = version #安装指定的包（可同时安装多个包并附加版本）
conda remove package_name #卸载包
conda list #查看所有的包
conda search package_name #查询某个包的完整名

环境管理

conda create -n env_name list_of_packages #新建安装了指定包的环境

示例：

  conda create -n py3 python=3
  conda create -n py2 python=2

进入环境

avtivate env_name   #Linux Mac
source avtivate env_name  #Windows

离开环境

deactivate           #Linux Mac
source deactivate    #Windows

列出环境

conda env list

删除环境

conda env remove -n env_name

class collections.defaultdict([default_factory[, ...]])

defaultdict继承与内置类dict，但对于不存在的键处理方式不同。

dict处理缺失的键

在Python访问dict不存在的键会抛出KeyError异常。如计数列表里的颜色

colors = ('yellow', 'red', 'yellow', 'blue','black', 'white', 'blue', 'blue')
counts = {}

for k in colors:
    counts[k] += 1

因为所有的键在字典counts里都不存在，在counts[k]+=1处会抛出KeyError异常。

Traceback (most recent call last):
 File "<stdin>", line 2, in <module>
KeyError: 'yellow'

我们可以使用dict的setdefault方法对不存在的键设置默认值以避免此问题。

colors = ('yellow', 'red', 'yellow', 'blue','black', 'white', 'blue', 'blue')
counts = {}

for k in colors:
    counts.setdefault(k, 0)
    counts[k] += 1

defaultdict处理缺失的键

defaultdict接受default_factory作为参数，defaultdict用它来初始化缺失键的默认值。

default_factory的值：

• default_factory可以是类型名，使用指定的类型初始化默认值。
• default_factory也可以是一个无参的lambda回调函数，回调函数的返回值作为缺失键的默认值。

需要注意的是，只有调用defaultdict的内置方法__getitem__()（实际就是使用下标访问字典，如d[k]）才会使用default_factory初始化缺失键的默认值。

上面的示例修改如下：

from collections import defaultdict
colors = ('yellow', 'red', 'yellow', 'blue','black', 'white', 'blue', 'blue')
counts = defaultdict(int)

for k in colors:
    counts[k] += 1

应用示例

分组键值对序列

设置default_factory为list：

>>> s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
>>> d = defaultdict(list)
>>> for k, v in s:
...     d[k].append(v)
...
>>> sorted(d.items())
[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]

计数

设置defaul_facotry为int：

>>> s = 'mississippi'
>>> d = defaultdict(int)
>>> for k in s:
...     d[k] += 1
...
>>> sorted(d.items())
[('i', 4), ('m', 1), ('p', 2), ('s', 4)]

集合

设置default_factory为set：

>>> s = [('red', 1), ('blue', 2), ('red', 3), ('blue', 4), ('red', 1), ('blue', 4)]
>>> d = defaultdict(set)
>>> for k, v in s:
...     d[k].add(v)
...
>>> sorted(d.items())
[('blue', {2, 4}), ('red', {1, 3})]