1. 路径操作#

比起os模块的path方法，python3标准库的pathlib模块的Path处理起路径更加的容易。

l例如：获取当前文件路径。 os版：

1
print(os.path.dirname(__file__))
2
print(os.getcwd())

pathlib版：

1
print(pathlib.Path.cwd())

看着好像没啥区别，然后看下面这个。

获取上两级文件目录#

os版：

1
print(os.path.dirname(os.path.dirname(os.getcwd())))

pathlib版:

1
print(pathlib.Path.cwd().parent.parent)

拼接路径#

os版:

1
print(os.path.join(os.path.dirname(os.path.dirname(os.getcwd())),"yamls","a.yaml"))

pathlib版:

1
parts=["yamls","a.yaml"]
2
print(pathlib.Path.cwd().parent.parent.joinpath(*parts))

运行时拼接路径#

os版:

1
os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), 'yamls',f'{site_name}.yaml')

pathlib版:

1
parts=["yamls","a.yaml"]
2
print(pathlib.Path(__file__).resolve().parent.parent.joinpath(*parts))

另外pathlib生成的是个对象，在open文件操作中可以直接运行的但是如果当作字符串操作会出现错误，此时需要对其进行转换，使用os.fspath()即可，不过一般很少有操作路径字符串的习惯。综合起来，还是pathlib拼接路径方便。

2. 保存标准格式的yaml文件#

编程免不了要写配置文件，怎么写配置也是一门学问。 YAML 是专门用来写配置文件的语言，非常简洁和强大，远比 JSON 格式方便。 YAML在python语言中有PyYAML安装包。前提安装第三方库

1
pip install pyyaml
2
pip install ruamel.yaml

关于yaml的读取知识网上一堆了我就不说了，这里主要说写入。

1
from ruamel import yaml
2
data={"age":23,"sex":"男","name":"牛皮"}
3
with open(conf_file, "w", encoding='utf-8') as fs:
4
    yaml.dump(data, fs, Dumper=yaml.RoundTripDumper, allow_unicode=True)

yaml写文件和json一样也是使用dump。

3. 同时迭代两个列表#

以前的时候我是这么解决的

1
a = ["a", "b", "c", "d"]
2
b = [1, 2, 3]  # 空的补充None
3
for index, a_item in enumerate(a):
4
    b_item = None
5
    if len(b) - 1 <= index:
6
        pass
7
    else:
8
        b_item = b[index]
9
    print({a_item:b_item})

现在通过itertools标准库的zip升级版zip_longest解决，可以通过fillvalue参数补充缺失值。当然如果比较的元素个数相同可以直接用zip。

1
from itertools import zip_longest
2

3
a = ["a", "b", "c", "d","e"]
4
b = [1, 2, 3]  # 空的补充None
5
for a_item, b_item in zip_longest(a,b,fillvalue=0):
6
    print({a_item:b_item})

4. 三元表达式还能这么用？#

一般的我们这样写

1
a="hello" if 2>1 else "bye"
2
print(a)

我们知道python中false实际式0，true是1，所以对于上面的式子我们就可以这么写了。

1
a=["hello","bye"][2<1]
2
print(a)

因为2<1是false也就是0，所以输出了第一个元素hello。

5.简单的类使用namedtuple代替#

先来一个简单的例子

1
import collections
2
# Person=collections.namedtuple('Person','name age')
3
# 如果使用python中的关键字会出现错误,此时使用rename字段。
4
# 按照元素在元组中的下标赋值。class就是_2,def是_3
5
Person = collections.namedtuple('Person', ['name', 'age', 'class', 'def', 'name', 'name'], rename=True)
6
p = Person(name='lisa', age='12', _2="class2", _3="def", _4="name2", _5="name3")
7
print(p)
8
# 如果出现相同的字段第二次出现的时候也是用其下标，参考上面的例子。
9
# _fields查看字段名,可以发现内置模块和重复的字段标记为_加下标的形式
10
print(p._fields)
11
# 使用_asdict将namedtuple转为OrderedDict。
12
od = p._asdict()
13
print(od)
14
# 然后可以转为字典
15
print(dict(od))
16
# _replace()方法构建一个新实例，因为namedtuple是不可变类型所以这个方法可以返回一个新的对象。
17
new_p = p._replace(name="samJ")
18
print(new_p)
19
print(new_p is p)  # 可以看到不是同一个对象。

一个实用的例子pyppeteer的例子感受下

1
import asyncio
2
import pyppeteer
3
from collections import namedtuple
4

5
Response = namedtuple("rs", "title url html cookies headers history status")
6

7

8
async def get_html(url, timeout=30):
9
    # 默认30s
10
    browser = await pyppeteer.launch(headless=True, args=['--no-sandbox'])
11
    page = await  browser.newPage()
12
    res = await page.goto(url, options={'timeout': int(timeout * 1000)})
13
    data = await page.content()
14
    title = await page.title()
15
    resp_cookies = await page.cookies()
16
    resp_headers = res.headers
17
    resp_history = None
18
    resp_status = res.status
19
    response = Response(title=title, url=url,
20
                        html=data,
21
                        cookies=resp_cookies,
22
                        headers=resp_headers,
23
                        history=resp_history,
24
                        status=resp_status)
25
    return response
26

27

28
if __name__ == '__main__':
29
    url_list = ["http://www.10086.cn/index/tj/index_220_220.html", "http://www.10010.com/net5/011/",
30
                "http://python.jobbole.com/87541/"]
31
    task = (get_html(url) for url in url_list)
32

33
    loop = asyncio.get_event_loop()
34
    results = loop.run_until_complete(asyncio.gather(*task))
35
    for res in results:
36
        print(res.title)

6 使用枚举让数字变得更易懂。#

1
import enum
2

3

4
# 枚举
5
@enum.unique
6
class Sex(enum.Enum):
7
    man = 12
8
    woman = 13
9

10
    # 因为加了唯一值的装饰器所以下面添加属性会报错
11
    # boy=12
12

13

14
print(Sex.man.name)
15
print(Sex.woman.value)
16

17
# 遍历
18
for item in Sex:
19
    print(item.name)
20
    print(item.value)
21
print("-" * 40)
22
# 其他使用方式
23
words = enum.Enum(
24
    value='item',
25
    names=('a b c d e f'),
26
)
27
# 输出元素c，必须是上面names里含有的值
28
print(words.c)
29
print(words.f)
30
# 因为names不含有w所以报错
31
try:
32
    print(words.w)
33
except AttributeError as e:
34
    print(e.args)
35
print("-" * 40)
36
for word in words:
37
    print(word.name, word.value)  # 默认赋值为、从1开始自增。
38
print("-" * 40)
39
# 如果自定义元素的值啧改为一下元组的形式
40
words2 = enum.Enum(
41
    value='item2',
42
    names=[('a', 23), ('b', 56), ("c", 12), ("d", 333)]
43
)
44
for word2 in words2:
45
    print(word2.name, word2.value)

7 链式合并字典chainmap的使用#

1
from collections import ChainMap
2

3
# ChainMap
4

5
d1 = {'a': 1, 'b': 2}
6
d2 = {'a2': 3, 'b2': 4}
7
d3 = {'a3': 5, 'b3': 6}
8
d4 = {'a4': 7, 'b4': 8}
9
c = ChainMap(d1, d2, d3, d4)  # 多个字典合并为一个
10
for k, v in c.items():
11
    print(k, v)
12
print(c.maps)  # 要搜索的索引列表
13

14
c.maps = list(reversed(c.maps))  # 逆转映射列表
15
print(c)
16

17
# 因为c和d1-d4对应的索引位置实际是一个所以，修改c的时候会影响到d1到d4其中饿的一个值，同理修改
18
# d1-d4的时候也会影响到c。
19
# 所以使用new_child创建一个新的映射。再修改就影响不到底层的数据了。
20
c2 = c.new_child()
21
c2["a4"] = 100
22
print(c)
23
print(c2)
24
# 输出发现c的值没有发生变化，只要c2变化。
25
d5 = {"a5": 34, "b5": 78}
26
c2 = c2.new_child(d5)  # 可以在原来的映射基础上添加新的映射
27
print(c2)

8 在不打乱列表顺序的基础上插入元素#

1
import bisect
2

3
"""
4
bisect 模块，用于维护有序列表。
5
bisect 模块实现了一个算法用于插入元素到有序列表。
6
在一些情况下，这比反复排序列表或构造一个大的列表再排序的效率更高。
7
Bisect 是二分法的意思，这里使用二分法来排序，它会将一个元素插入到一个有序列表的合适位置，
8
这使得不需要每次调用 sort 的方式维护有序列表。
9
"""
10
values = [14, 85, 77, 26, 50, 45, 66, 79, 10, 3, 84, 77, 1]
11
print("New Pos Content")
12
print("--- --- -------")
13
l = []
14
for i in values:
15
    postion = bisect.bisect(l, i)  # 返回插入的位置
16
    bisect.insort(l, i)  # 等于insort_right
17
    print('{:3}{:3}'.format(i, postion), l)
18

19
"""
20
Bisect模块提供的函数有：
21

22
bisect.bisect_left(a,x, lo=0, hi=len(a)) :
23
查找在有序列表 a 中插入 x 的index。lo 和 hi 用于指定列表的区间，默认是使用整个列表。如果 x 已经存在，在其左边插入。返回值为 index。
24

25
bisect.bisect_right(a,x, lo=0, hi=len(a))
26
bisect.bisect(a, x,lo=0, hi=len(a)) ：
27
这2个函数和 bisect_left 类似，但如果 x 已经存在，在其右边插入。
28

29
bisect.insort_left(a,x, lo=0, hi=len(a)) ：
30
在有序列表 a 中插入 x。和 a.insert(bisect.bisect_left(a,x, lo, hi), x) 的效果相同。
31

32
bisect.insort_right(a,x, lo=0, hi=len(a))
33
bisect.insort(a, x,lo=0, hi=len(a)) :
34
和 insort_left 类似，但如果 x 已经存在，在其右边插入。
35

36
Bisect 模块提供的函数可以分两类： bisect* 只用于查找 index， 不进行实际的插入；
37
而 insort* 则用于实际插入。该模块比较典型的应用是计算分数等级：
38
"""

9 关于字典的逻辑运算你了解多少#

1
# 使用&操作符查看字典的相同之处
2
#字典键支持常见的集合操作，并集交集差集。
3
a = {'x': 1, 'y': 2, 'z': 3}
4
b = {'w': 2, 'z': 4, 'x': 3, 'z': 3}
5

6
# 获取相同的键
7
c = a.keys() & b.keys()
8
print(c)
9
# 获取相同的键值对
10
d = a.items() & b.items()
11
print(d)
12
# 创建一个新的字典并删除某些键
13

14
e = {k: a[k] for k in a.keys() - {'z', 'x'}}
15
print(e)

10 给切片起个名字#

1
a="safr3.14"
2
print(a[-4:])
3
#上面可以改为
4
pie = slice(len(a)-4, len(a))
5
print(a[pie])   # 和 a[-4:] 等价，但切片有了名字，可复用、可读

11 获取出现频率高的元素#

1
from collections import Counter
2

3
text = "abcdfegtehto;grgtgjri"  # 可迭代对象
4
lis = ["a", "c", "d", "t", "b"]
5
dic = {"a": 1, "b": 4, "c": 2, "d": 9}  # 字典也可以
6
c = Counter()  # 可以定义空容器然后update
7
c.update(text)
8
c2 = Counter()
9
c2.update(dic)
10

11
c3 = Counter(lis)  # 也可以直接传入对象
12
print(c)
13
print(c2)
14
print(c3)
15

16
# 使用c.most_common(n)获取前n出现频率最高的元素,列表元组类型
17
print(c.most_common(4))