Music-dl: Listen to what you want

python库:Music-dl 是一个基于Python3的命令行工具,可以从多个网站搜索和下载音乐,方便寻找音乐,解决不知道哪个网站有版权的问题。工具的本意是聚合搜索,API 是从公开的网络中获得,不是破解版,也听不了付费歌曲。

功能

  • 部分歌曲支持无损音乐
  • 优先搜索高品质音乐(无损 -> 320K -> 128K)
  • 支持 HTTP 和 SOCKS 代理
  • 支持多线程搜索
  • 支持搜索结果去重和排序
  • 支持搜索关键字高亮
  • 支持下载歌词和封面(部分)

注意:仅支持Python3,建议使用 Python3.5 以上版本

安装

使用pip安装(推荐,注意前面有一个py):

$ pip3 install pymusic-dl

手动安装(最新):

$ git clone https://github.com/0xHJK/music-dl.git
$ cd music-dl
$ python3 setup.py install

不安装直接运行:

$ git clone https://github.com/0xHJK/music-dl.git
$ cd music-dl
$ pip3 install -r requirements.txt
$ ./music-dl

# 或 python3 music-dl

在以下环境测试通过:

系统名称系统版本Python版本
macOS10.143.7.0
macOS10.133.7.0
WindowsWindows 7 x643.7.2
WindowsWindows 10 x643.7.2
Ubuntu16.04 x643.5.2

使用方式

v3.0预览版命令有较大的改变,建议先查看帮助

$ music-dl --help
Usage: music-dl [OPTIONS]

  Search and download music from netease, qq, kugou, baidu and xiami.
  Example: music-dl -k "周杰伦"

Options:
  --version             Show the version and exit.
  -k, --keyword TEXT    搜索关键字,歌名和歌手同时输入可以提高匹配(如 空帆船 朴树)
  -u, --url TEXT        通过指定的歌曲URL下载音乐
  -p, --playlist TEXT   通过指定的歌单URL下载音乐
  -s, --source TEXT     Supported music source: qq netease kugou baidu
  -n, --number INTEGER  Number of search results
  -o, --outdir TEXT     Output directory
  -x, --proxy TEXT      Proxy (e.g. http://127.0.0.1:1087)
  -v, --verbose         Verbose mode
  --lyrics              同时下载歌词
  --cover               同时下载封面
  --nomerge             不对搜索结果列表排序和去重
  --help                Show this message and exit.
  • 默认搜索qq netease kugou baidu ,每个数量限制为5,保存目录为当前目录。
  • 指定序号时可以使用1-5 7 10的形式。
  • 默认对搜索结果排序和去重,排序顺序按照歌手和歌名排序,当两者都相同时保留最大的文件。
  • 无损音乐歌曲数量较少,如果没有无损会显示320K或128K。
  • 支持http代理和socks代理,格式形如-x http://127.0.0.1:1087-x socks5://127.0.0.1:1086

一键网易云签到+听歌300首

tools.wgudu.com

collections模块

https://pixabay.com/

collections模块实现一些特定的数据类型,可以替代Python中常用的内置数据类型如dict, list, set, tuple,简单说就是对基本数据类型做了更上一层的处理。

https://github.com/python/cpython/blob/3.10/Lib/collections/init.py

https://docs.python.org/zh-cn/3/library/collections.html?highlight=deque#collections.namedtuple

init.py:

'''This module implements specialized container datatypes providing
alternatives to Python's general purpose built-in containers, dict,
list, set, and tuple.

* namedtuple   factory function for creating tuple subclasses with named fields
* deque        list-like container with fast appends and pops on either end
* ChainMap     dict-like class for creating a single view of multiple mappings
* Counter      dict subclass for counting hashable objects
* OrderedDict  dict subclass that remembers the order entries were added
* defaultdict  dict subclass that calls a factory function to supply missing values
* UserDict     wrapper around dictionary objects for easier dict subclassing
* UserList     wrapper around list objects for easier list subclassing
* UserString   wrapper around string objects for easier string subclassing

'''

__all__ = ['deque', 'defaultdict', 'namedtuple', 'UserDict', 'UserList',
            'UserString', 'Counter', 'OrderedDict', 'ChainMap']

一、deque

用途:双端队列,头部和尾部都能以O(1)时间复杂度插入和删除元素。类似于列表的容器

所谓双端队列,就是两端都能操作,与Python内置的list区别在于:头部插入与删除的时间复杂度为O(1),来个栗子感受一下:

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __author__ = 'liao gao xiang'

"""
保留最后n个元素
"""
from collections import deque


def search(file, pattern, history=5):
    previous_lines = deque(maxlen=history)
    for l in file:
        if pattern in l:
            yield l, previous_lines  # 使用yield表达式的生成器函数,将搜索过程的代码和搜索结果的代码解耦
        previous_lines.append(l)


with open(b'file.txt', mode='r', encoding='utf-8') as f:
    for line, prevlines in search(f, 'Python', 5):
        for pline in prevlines:
            print(pline, end='')
        print(line, end='')

d = deque()
d.append(1)
d.append("2")
print(len(d))
print(d[0], d[1])
d.extendleft([0])
print(d)
d.extend([6, 7, 8])
print(d)

d2 = deque('12345')
print(len(d2))
d2.popleft()
print(d2)
d2.pop()
print(d2)

# 在队列两端插入或删除元素时间复杂度都是 O(1) ,区别于列表,在列表的开头插入或删除元素的时间复杂度为 O(N)
d3 = deque(maxlen=2)
d3.append(1)
d3.append(2)
print(d3)
d3.append(3)
print(d3)

输出结果如下

人生苦短
我用Python
2
1 2
deque([0, 1, '2'])
deque([0, 1, '2', 6, 7, 8])
5
deque(['2', '3', '4', '5'])
deque(['2', '3', '4'])
deque([1, 2], maxlen=2)
deque([2, 3], maxlen=2)

因此,如果你遇到经常操作列表头的场景,使用deque最好。deque类的所有方法,自行操作一遍就知道了。

class deque(object):
    """
    deque([iterable[, maxlen]]) --> deque object

    A list-like sequence optimized for data accesses near its endpoints.
    """
    def append(self, *args, **kwargs): # real signature unknown
        """ Add an element to the right side of the deque. """
        pass

    def appendleft(self, *args, **kwargs): # real signature unknown
        """ Add an element to the left side of the deque. """
        pass

    def clear(self, *args, **kwargs): # real signature unknown
        """ Remove all elements from the deque. """
        pass

    def copy(self, *args, **kwargs): # real signature unknown
        """ Return a shallow copy of a deque. """
        pass

    def count(self, value): # real signature unknown; restored from __doc__
        """ D.count(value) -> integer -- return number of occurrences of value """
        return 0

    def extend(self, *args, **kwargs): # real signature unknown
        """ Extend the right side of the deque with elements from the iterable """
        pass

    def extendleft(self, *args, **kwargs): # real signature unknown
        """ Extend the left side of the deque with elements from the iterable """
        pass

    def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
        """
        D.index(value, [start, [stop]]) -> integer -- return first index of value.
        Raises ValueError if the value is not present.
        """
        return 0

    def insert(self, index, p_object): # real signature unknown; restored from __doc__
        """ D.insert(index, object) -- insert object before index """
        pass

    def pop(self, *args, **kwargs): # real signature unknown
        """ Remove and return the rightmost element. """
        pass

    def popleft(self, *args, **kwargs): # real signature unknown
        """ Remove and return the leftmost element. """
        pass

    def remove(self, value): # real signature unknown; restored from __doc__
        """ D.remove(value) -- remove first occurrence of value. """
        pass

    def reverse(self): # real signature unknown; restored from __doc__
        """ D.reverse() -- reverse *IN PLACE* """
        pass

    def rotate(self, *args, **kwargs): # real signature unknown
        """ Rotate the deque n steps to the right (default n=1).  If n is negative, rotates left. """
        pass

这里提示一下,有些函数对队列进行操作,但返回值是None,比如reverse()反转队列,rotate(1)将队列中元素向右移1位,尾部的元素移到头部。

二、defaultdict

用途:带有默认值的字典。父类为Python内置的dict

字典带默认值有啥好处?举个栗子,一般来讲,创建一个多值映射字典是很简单的。但是,如果你选择自己实现的话, 那么对于值的初始化可能会有点麻烦,你可能会像下面这样来实现:

d = {}
for key, value in pairs:
    if key not in d:
        d[key] = []
    d[key].append(value)

如果使用 defaultdict 的话代码就更加简洁了:

d = defaultdict(list)
for key, value in pairs:
    d[key].append(value)

defaultdict 的一个特征是它会自动初始化每个 key 刚开始对应的值,所以你只需要 关注添加元素操作了。比如:

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __author__ = 'liao gao xiang'

# 字典中的键映射多个值
from collections import defaultdict

d = defaultdict(list)
print(d)
d['a'].append([1, 2, 3])
d['b'].append(2)
d['c'].append(3)

print(d)

d = defaultdict(set)
print(d)
d['a'].add(1)
d['a'].add(2)
d['b'].add(4)

print(d)

输出结果如下:

defaultdict(<class 'list'>, {})
defaultdict(<class 'list'>, {'a': [[1, 2, 3]], 'b': [2], 'c': [3]})
defaultdict(<class 'set'>, {})
defaultdict(<class 'set'>, {'a': {1, 2}, 'b': {4}})

三、namedtuple()

用途:创建命名字段的元组。工厂函数

namedtuple主要用来产生可以使用名称来访问元素的数据对象,通常用来增强代码的可读性, 在访问一些tuple类型的数据时尤其好用。

比如我们用户拥有一个这样的数据结构,每一个对象是拥有三个元素的tuple。使用namedtuple方法就可以方便的通过tuple来生成可读性更高也更好用的数据结构。

from collections import namedtuple

websites = [
    ('Sohu', 'http://www.sohu.com/', u'张朝阳'),
    ('Sina', 'http://www.sina.com.cn/', u'王志东'),
    ('163', 'http://www.163.com/', u'丁磊')
]

Website = namedtuple('Website', ['name', 'url', 'founder'])

for website in websites:
    website = Website._make(website)
    print website


# 输出结果:
Website(name='Sohu', url='http://www.sohu.com/', founder=u'\u5f20\u671d\u9633')
Website(name='Sina', url='http://www.sina.com.cn/', founder=u'\u738b\u5fd7\u4e1c')
Website(name='163', url='http://www.163.com/', founder=u'\u4e01\u78ca')

注意,namedtuple是函数,不是类。

四、Counter

用途:统计可哈希的对象。父类为Python内置的dict

寻找序列中出现次数最多的元素。假设你有一个单词列表并且想找出哪个单词出现频率最高:

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __author__ = 'liao gao xiang'

from collections import Counter

words = [
    'look', 'into', 'my', 'eyes', 'look', 'into', 'my', 'eyes',
    'the', 'eyes', 'the', 'eyes', 'the', 'eyes', 'not', 'around', 'the',
    'eyes', "don't", 'look', 'around', 'the', 'eyes', 'look', 'into',
    'my', 'eyes', "you're", 'under'
]

word_counts = Counter(words)

# 出现频率最高的三个单词
top_three = word_counts.most_common(3)
print(top_three)
# Outputs [('eyes', 8), ('the', 5), ('look', 4)]
print(word_counts['eyes'])

morewords = ['why', 'are', 'you', 'not', 'looking', 'in', 'my', 'eyes']

# 如果你想手动增加计数,可以简单的用加法:
for word in morewords:
    print(word)
    word_counts[word] += 1
print(word_counts['eyes'])

结果如下:

[('eyes', 8), ('the', 5), ('look', 4)]
8
why
are
you
not
looking
in
my
eyes
9

因为Counter继承自dict,所有dict有的方法它都有(defaultdict和OrderedDict也是的),Counter自己实现或重写了6个方法:

  • most_common(self, n=None),
  • elements(self)
  • fromkeys(cls, iterable, v=None)
  • update(*args, **kwds)
  • subtract(*args, **kwds)
  • copy(self)

五、OrderedDict

用途:排序的字段。父类为Python内置的dict

OrderedDict在迭代操作的时候会保持元素被插入时的顺序,OrderedDict内部维护着一个根据键插入顺序排序的双向链表。每次当一个新的元素插入进来的时候,它会被放到链表的尾部。对于一个已经存在的键的重复赋值不会改变键的顺序。

需要注意的是,一个OrderedDict的大小是一个普通字典的两倍,因为它内部维护着另外一个链表。 所以如果你要构建一个需要大量OrderedDict 实例的数据结构的时候(比如读取100,000行CSV数据到一个 OrderedDict 列表中去),那么你就得仔细权衡一下是否使用 OrderedDict带来的好处要大过额外内存消耗的影响。

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __author__ = 'liao gao xiang'

from collections import OrderedDict

d = OrderedDict()
d['foo'] = 1
d['bar'] = 2
d['spam'] = 3
d['grok'] = 4
# d['bar'] = 22 #对于一个已经存在的键,重复赋值不会改变键的顺序
for key in d:
    print(key, d[key])

print(d)

import json

print(json.dumps(d))

结果如下:

foo 1
bar 2
spam 3
grok 4
OrderedDict([('foo', 1), ('bar', 2), ('spam', 3), ('grok', 4)])
{"foo": 1, "bar": 2, "spam": 3, "grok": 4}

OrderDict实现或重写了如下方法。都是干嘛的?这个留给大家当课后作业了^_^

  • clear(self)
  • popitem(self, last=True)
  • move_to_end(self, key, last=True)
  • keys(self)
  • items(self)
  • values(self)
  • pop(self, key, default=__marker)
  • setdefault(self, key, default=None)
  • copy(self)
  • fromkeys(cls, iterable, value=None)

六、ChainMap

用途:创建多个可迭代对象的集合。类字典类型

很简单,如下:

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __author__ = 'liao gao xiang'

from collections import ChainMap
from itertools import chain

# 不同集合上元素的迭代
a = [1, 2, 3, 4]
b = ('x', 'y', 'z')
c = {1, 'a'}

# 方法一,使用chain
for i in chain(a, b, c):
    print(i)
print('--------------')
# 方法二,使用chainmap
for j in ChainMap(a, b, c):
    print(j)

# 这两种均为节省内存,效率更高的迭代方式

一个 ChainMap 接受多个字典并将它们在逻辑上变为一个字典。然后,这些字典并不是真的合并在一起了,ChainMap 类只是在内部创建了一个容纳这些字典的列表并重新定义了一些常见的字典操作来遍历这个列表。大部分字典操作都是可以正常使用的,比如:

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __author__ = 'liao gao xiang'

# 合并多个字典和映射
a = {'x': 1, 'z': 3}
b = {'y': 2, 'z': 4}
# 现在假设你必须在两个字典中执行查找操作
# (比如先从 a 中找,如果找不到再在 b 中找)。
# 一个非常简单的解决方案就是使用collections模块中的ChainMap类
from collections import ChainMap

c = ChainMap(a, b)

print(c)
a['x'] = 11  # 使用ChainMap时,原字典做了更新,这种更新会合并到新的字典中去

print(c)  # 按顺序合并两个字典
print(c['x'])
print(c['y'])
print(c['z'])

# 对于字典的更新或删除操作影响的总是列中的第一个字典。
c['z'] = 10
c['w'] = 40
del c['x']
print(a)
# del c['y']将出现报错

# ChainMap对于编程语言中的作用范围变量(比如globals,locals等)
# 是非常有用的。事实上,有一些方法可以使它变得简单:
values = ChainMap()  # 默认会创建一个空字典
print('\t', values)
values['x'] = 1
values = values.new_child()  # 添加一个空字典
values['x'] = 2
values = values.new_child()
values['x'] = 30
# values = values.new_child()
print(values, values['x'])  # values['x']输出最后一次添加的值
values = values.parents  # 删除上一次添加的字典
print(values['x'])
values = values.parents
print(values)

a = {'x': 1, 'y': 2}
b = {'y': 2, 'z': 3}
merge = dict(b)
merge.update(a)
print(merge['x'], merge['y'], merge['z'])
a['x'] = 11
print(merge['x'])

输出结果如下:

ChainMap({'x': 1, 'z': 3}, {'y': 2, 'z': 4})
ChainMap({'x': 11, 'z': 3}, {'y': 2, 'z': 4})
11
2
3
{'z': 10, 'w': 40}
     ChainMap({})
ChainMap({'x': 30}, {'x': 2}, {'x': 1}) 30
2
ChainMap({'x': 1})
1 2 3
1

作为ChainMap的替代,你可能会考虑使用 update() 方法将两个字典合并。这样也能行得通,但是它需要你创建一个完全不同的字典对象(或者是破坏现有字典结构)。同时,如果原字典做了更新,这种改变不会反应到新的合并字典中去。

ChainMap实现或重写了如下方法:

  • get(self, key, default=None)
  • fromkeys(cls, iterable, *args)
  • copy(self)
  • new_child(self, m=None)
  • parents(self)
  • popitem(self)
  • pop(self, key, *args)
  • clear(self)

七、UserDict、UserList、UserString

这三个类是分别对 dict、list、str 三种数据类型的包装,其主要是为方便用户实现自己的数据类型。在 Python2 之前,这三个类分别位于 UserDict、UserList、UserString 三个模块中,需要用类似于 from UserDict import UserDict 的方式导入。在 Python3 之后则被挪到了 collections 模块中。这三个类都是基类,如果用户要扩展这三种类型,只需继承这三个类即可。

Python 3 新特性:类型注解

摘自:https://www.cnblogs.com/xzkzzz/p/11378842.html

https://pixabay.com/

在 Python 中定义函数非常简单,像这样:

def say(name):
    return f'Hello {name}!'

但是,有时候也会看到这样的代码:

def say_hi(name: str) -> str:
    return f'Hello {name}!'

函数定义似乎变得复杂些了:多出来这些 str 、 -> 都是什么意思?有什么作用?

本文将由浅入深,好好聊聊 Python 3.5 之后的类型注解。理解它将非常有益于优化你的代码。

变量注解

Python 是动态语言,其显著特点是在声明变量时,你不需要显式声明它的类型。

比如这个:

age = 20
print('The age is: ', age + 1)
# Output:
# The age is:  21

你看,虽然代码里没有明确指定 age 的类型,但是程序运行时隐式推断出它是 int 类型,因此可以顺利执行 age + 1 的动作。

除此之外,已经确定类型的变量,可以随时更改其类型,比如:

age = 20
print(type(age))
# Output: <class 'int'>

age = '20'
print(type(age))
# Output: <class 'str'>

Python 这种动态特性的好处是它非常的自由,大部分时候你不用纠结类型声明、类型转化等麻烦事,可以用很少的代码完成各种骚操作。但是缺点也在这里:如果你代码某些变量的类型有错,编辑器、IDE等工具无法在早期替你纠错,只能在程序运行阶段才能够暴露问题。

比如下面这个例子:

age = 20

# ...
# 这里进行了一大串的其他指令
# 然后你忘记了 age 应该是 int
# 错误地将其赋值为字符串

age = '20'

print('The age is: ', age + 1)
# Output: TypeError: can only concatenate str (not "int") to str

在项目代码逐渐膨胀之后,上面这种看似弱智的情况可能会经常发生。

因此,Python 3.5 之后引入了类型注解,其作用就是让你可以明确的声明变量的类型,使代码不再那么的自由(放飞自我)。

类型注解还在快速发展中,因此尽量用较新的 Python 版本去尝试它。

比如上面的代码,就可以用类型注解改写了:

age: int = 20

看似多此一举,但是编辑器可以凭借此,找出你那些错误的骚操作。

比如笔者用的 VS Code,安装好类型注解插件 Pylance 后,如果写出下面的代码:

age: int = 20
age = '20'

那么编辑器会用醒目的方式告诉你:孙子,你这里的类型写错了!(见下图)

Pylance 默认关闭了类型检查,你得在设置中手动打开。其他的编辑器/IDE(比如 Pycharm)也都提供了类似的类型检查,放心用吧。

很简单,但却带来了巨大的好处

  • 编辑器可以替你揪出代码中关于类型的错误,避免了程序运行过程中各种奇奇怪怪的 Bug 。
  • 在你编写代码时,编辑器可以提示你对象的类型,免得你或者团队成员忘记了。(程序员通常记性不好)。

注意,类型注解仅仅是提供给编辑器进行类型检查的机会,也就是起提示的作用,对 Python 程序的运行不会产生任何影响。也就是说,Python 跟以前一样自由,即使你进行了错误的类型赋值,只要不直接引发错误,程序依旧可以运行。

最后,Python 中几种基本的变量类型都得到了支持:

a: int = 3
b: float = 3.14
c: str = 'abc'
d: bool = False

很简单吧。让我们继续。

函数注解

文章开头提到的那个例子,就是简单的函数类型注解:

def say_hi(name: str) -> str:
    return f'Hello {name}!'

你可以很清楚的知道,这个函数应该接收一个字符串参数 name ,并且返回值应该也是字符串。

带默认值的函数像这样书写:

def add(first: int = 10, second: float = 5.5) -> float:
    return first + second

如果函数没有返回值,那么下面两种写法都可以:

def foo():
    pass

def bar() -> None:
    pass

自定义的对象也没问题,像下面这样:

class Person:
    def __init__(self, name: str):
        self.name = name


def hello(p: Person) -> str:
    return f'Hello, {p.name}'

如果要避免循环导入或者注解早于对象定义的情况,可以用字符串代替类型:

def hello(p: 'Person') -> str:
    return f'Hello, {p.name}'


class Person:
    def __init__(self, name: str):
        self.name = name

效果是相同的。

相比变量类型注解,函数里的类型注解更加有用,并且可能是你最频繁用到注解的地方了。

容器类型

列表、字典、元组等包含元素的复合类型,用简单的 list,dict,tuple 不能够明确说明内部元素的具体类型。

因此要用到 typing 模块提供的复合注解功能:

from typing import List, Dict, Tuple

# 参数1: 元素为 int 的列表
# 参数2: 键为字符串,值为 int 的字典
# 返回值: 包含两个元素的元组
def mix(scores: List[int], ages: Dict[str, int]) -> Tuple[int, int]:
    return (0, 0)

如果你用的是 Python 3.9+ 版本,甚至连 typing 模块都不需要了,内置的容器类型就支持了复合注解:

def mix(scores: list[int], ages: dict[str, int]) -> tuple[int, int]:
    return (0, 0)

在某些情况下,不需要严格区分参数到底是列表还是元组(这种情况还蛮多的)。这时候就可以将它们的特征抽象为更泛化的类型(泛型),比如 Sequence(序列)。

下面是例子:

# Python 3.8 之前的版本
from typing import Sequence as Seq1

def foo(seq: Seq1[str]):
    for item in seq:
        print(item)


# Python 3.9+ 也可以这么写
from collections.abc import Sequence as Seq2

def bar(seq: Seq2[str]):
    for item in seq:
        print(item)

例子中函数的参数不对容器的类型做具体要求,只要它是个序列(比如列表和元组)就可以。

类型别名

有时候对象的类型可能会非常复杂,或者你希望给类型赋予一个有意义的名称,那么你可以这样定义类型的别名:

from typing import Tuple

# 类型别名
Vector2D = Tuple[int, int]

def foo(vector: Vector2D):
    print(vector)

foo(vector=(1, 2))
# Output: (1, 2)

Vector2D 这个名称清晰的表达了这个对象是一个二维的向量。

与类型别名有点类似的,是用 NewType 创建自定义类型:

from typing import NewType
from typing import Tuple

# 创建新类型
Vector3D = NewType('Vector3D', Tuple[int, int, int])

def bar(vector: Vector3D):
    print(vector)

乍一眼看起来与前面的类型别名功能差不多,但不同的是 NewType 创建了原始类型的“子类”:

# 类型检查成功
# 类型别名和原始类型是等价的
foo(vector=(1, 2))

# 类型检查失败
# NewType创建的是原始类型的“子类”
bar(vector=(1, 2, 3))

# 类型检查成功
# 传入参数必须是 Vector3D 的“实例”
v_3d = Vector3D((4, 5, 6))
bar(vector=v_3d)

具体用哪种,得根据情况而定。

更多类型

NoReturn

如果函数没有返回值,那么可以这样写:

from typing import NoReturn

def hello() -> NoReturn:
    raise RuntimeError('oh no')

注意下面这样写是错误的:

def hello() -> NoReturn:
    pass

因为 Python 的函数运行结束时隐式返回 None ,这和真正的无返回值是有区别的。

Optional

猜猜下面的类型注解错在哪里:

def foo(a: int = 0) -> str:
    if a == 1:
        return 'Yeah'

答案:函数既有可能返回 None ,也有可能返回 str 。单凭返回值注解为 str 是不能准确表达此情况的。

这种“可能有也可能没有”的状态被称为可选值,在某些项目中非常常见。比如 web 应用中某个函数接受账号和密码作为参数,如果匹配则返回用户对象,若不匹配则返回 None 。

因此,有专门的可选值类型注解可以处理这种情况:

from typing import Optional

def foo(a: int = 0) -> Optional[str]:
    if a == 1:
        return 'Yeah'

Union

比 Optional 涵盖面更广的是 Union 。

如果函数的返回值是多种类型中的一种时,可以这样写:

from typing import Union

def foo() -> Union[str, int, float]:
    # ....
    # some code here

上面这个函数可以返回字符串、整型、浮点型中的任意一种类型。

可以发现 Optional 实际上是 Union 的特例:Optional[X] 和 Union[X, None] 是等价的。

Callable

我们知道, Python 中的函数和类的区别并不明显。只要实现了对应的接口,类实例也可以是可调用的

如果不关心对象的具体类型,只要求是可调用的,那么可以这样写:

from typing import Callable

class Foo:
    def __call__(self):
        print('I am foo')

def bar():
    print('I am bar')


def hello(a: Callable):
    a()

# 类型检查通过
hello(Foo())
# 同样通过
hello(bar)

Literal

即字面量。它在定义简单的枚举值时非常好用,比如:

from typing import Literal

MODE = Literal['r', 'rb', 'w', 'wb']
def open_helper(file: str, mode: MODE) -> str:
    ...

open_helper('/some/path', 'r')  # 成功
open_helper('/other/path', 'typo')  # 失败

Protocol

协议。我们通常说一个对象遵守了某个”协议“,意思是这个对象实现了”协议“中规定的属性或者方法。

比如下面这个例子:

from typing import Protocol

class Proto(Protocol):
    def foo(self):
        print('I am proto')

class A:
    def foo(self):
        print('I am A')

class B:
    def bar(self):
        print('I am B')

def yeah(a: Proto):
    pass

# 通过,A 实现了协议中的 foo() 方法
yeah(A())
# 不通过,B 未实现 foo()
yeah(B())

Any

如果你实在不知道某个类型注解应该怎么写时,这里还有个最后的逃生通道:

from typing import Any

def foo() -> Any:
    pass

任何类型都与 Any 兼容。当然如果你把所有的类型都注解为 Any 将毫无意义,因此 Any 应当尽量少使用。

泛型

要理解泛型,首先得知道没有它时所遇到的麻烦。

假设有一个函数,要求它既能够处理字符串,又能够处理数字。那么你可能很自然地想到了 Union 。

于是写出第一版代码:

from typing import Union, List

U = Union[str, int]

def foo(a: U, b: U) -> List[U]:
    return [a, b]

这样写有个很大的弊端,就是参数的类型可以混着用(比如 a: int 且 b:str ),即便你并不想具有这样的特性。看下面这个就明白了:

# 类型检查通过
# 因为 Union[str, int] 可以是其中任意一种类型
# 即便你并不想将 str 和 int 混用
foo('Joe', 19)

# 通过
foo(19, 21)

# 通过
foo('Joe', 'David')

泛型就可以解决此问题。来看第二版代码:

from typing import TypeVar, List

# 定义泛型 T
# T 必须是 str 或 int 其中一种
T = TypeVar('T', str, int)

def bar(a: T, b: T) -> List[T]:
    return [a, b]

# 类型检查不通过
# 函数的参数必须为同一个类型"T"
bar('Joe', 19)

# 通过
bar(19, 21)

# 通过
bar('Joe', 'David')

可以看出,泛型类似于某种模板(或者占位符),它可以很精确地将对象限定在你真正需要的类型。

让我们再看看下面这个对泛型的应用:

from typing import Dict, TypeVar

# 定义泛型 K 和 V
# K 和 V 的具体类型没有限制
K = TypeVar("K")
V = TypeVar("V")

def get_item(key: K, container: Dict[K, V]) -> V:
    return container[key]


dict_1 = {"age": 10}
dict_2 = {99: "dusai"}

print(get_item("age", dict_1))
# 例1
# 类型检查通过,输出: 10

print(get_item(99, dict_2))
# 例2
# 类型检查通过,输出: dusai

print(get_item("name", dict_2))
# 例3
# 类型检查失败
# 因为"name"是字符串,而dict_2的键为整型
  • 代码中定义了两个泛型 K 和 V,对它两的类型没有做任何限制,也就是说可以是任意类型。
  • 函数 get_item() 接受两个参数。这个函数不关心参数 container 字典的键是什么类型,或者字典的值是什么类型;但它的参数 container 必须是字典,参数 key 必须与字典的键为同类型,并且返回值和字典的值必须为同类型。仅仅通过查看函数的类型注解,就可以获得所有这些信息。

重点来看下例3的类型检查为什么会失败

  • dict_2 定义时,其键被定义为整型。
  • get_item("name", dict_2) 调用时,"name" 为字符串,而 dict_2 的键为整型,类型不一致。而类型注解中清楚表明它两应该为同一个类型 K ,产生冲突。
  • 编辑器察觉到冲突,友好地提示你,这里可能出错了。

泛型很巧妙地对类型进行了参数化,同时又保留了函数处理不同类型时的灵活性。

再回过头来看看类型注解的作用:

def get_item(key: K, container: Dict[K, V]) -> V:
    # ...

def get_item(key, container):
    # ...

上面两个函数功能完全相同,但是没有类型注解的那个,显然需要花更多的时间阅读函数内部的代码,去确认函数到底干了什么。并且它也无法利用编辑器的类型检查,在早期帮助排除一些低级错误。

总结

最后再总结下,Python 社区为什么花了很大力气,去实现了类型注解这个仅仅起”提示作用“的功能:

  • 让代码模块的功能更清晰。
  • 让编辑器可以帮助你尽早发现问题。

python 通过分享的链接下载抖音视频

"""下载抖音无水印的视频"""
import re
import requests

useragent = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.164 Safari/537.36'
headers = {'User-Agent': useragent}


def dy_url_op(data):
    '''从data中找到url,返回str'''
    url=''
    url=re.findall(r'(https?://[^\s]+)',data)
    return url[0]

def get_real_url(url,headers):
    session = requests.Session()
    req = session.get(url , timeout = 5 , headers = headers)
    vid = req.url.split("/")[4].split("?")[0]
    videoInfo = session.get("https://www.iesdouyin.com/web/api/v2/aweme/iteminfo/?item_ids=" + vid,
        timeout = 5 , headers = headers)
    playAddr = re.findall(r'https://aweme.snssdk.com/aweme[\S]*?"',videoInfo.text)[0][:-1]
    parsedAddr = playAddr.replace("/playwm/","/play/")
    return vid, parsedAddr, session

def downlowd_video(video_url):
    '''下载视频'''
    video_data=requests.get(video_url,headers=headers)
    with open('video.mp4','wb') as f:
        f.write(video_data.content)

print("请输入如下格式:\n8.94 mdN:/ 孙红雷的瓜保熟么?%扫黑风暴开播   https://v.douyin.com/eEPNXH4/ 復制佌鏈接,打开Dou音搜索,直接观看视频!")
data = input("请输入抖音视频链接:")
vid, parsedAddr, session = get_real_url(dy_url_op(data),headers)
downlowd_video(parsedAddr)
print("下载完成!")

爬虫过程中URL的变化:

  • 第1个URL(抖音分享的URL):https://v.douyin.com/JuGgK3M/
  • 第2个URL:https://www.iesdouyin.com/share/video/6893421572934159629/……
  • 第3个URL:https://www.iesdouyin.com/web/api/v2/aweme/iteminfo/?item_ids=6893421572934159629
  • 第4个URL(视频URL):
    https://aweme.snssdk.com/aweme/v1/playwm/?video_id=v0300f350000bul5ktfae8n8kibjf990&ratio=720p&line=0

python 正则表达式和re模块

正则表达式

. 点号,在默认模式下,匹配除换行以外的任意字符。如果 DOTALL 标志被指定, 则匹配包括换行符在内的所有字符。

^    乘方运算符或脱字节符,在默认模式下匹配字符串的起始位置,在MULTILINE模式下也匹配换行符之后的位置。
$    匹配字符串的末尾或者字符串末尾换行符之前的位置,在MULTILINE模式下还匹配换行符之前的位置。
*    匹配前面重复出现的正则表达式零次或多次,尽可能多的匹配(greedy 贪婪型)。
+    匹配前面RE 1次或多次(贪婪型,尽可能多的匹配)。
?    匹配前面的RE 0次或1次。
*?,+?,??    '*'、'+'和'?'限定符是贪婪的;它们匹配尽可能多的文本。在限定符之后加上'?'将使得匹配以非贪婪的或最小的方式进行。
{m}        表示精确匹配前面的正则表达式的m个拷贝,较少的匹配将导致整个表达式不能匹配。
{m,n}    匹配前导正则表达式的m到n个重复,尝试匹配尽可能多的重复(greedy 贪婪型)。
{m,}    匹配前导正则表达式的至少m次,尝试匹配尽可能多的重复(greedy 贪婪型)。
{,n}    匹配前导正则表达式的至多n次,尝试匹配尽可能多的重复(greedy 贪婪型)。
{m,n}?    匹配前导正则表达式的m到n个重复,尝试匹配尽可能少的重复(Non-greedy 非贪婪型)。
\        对特殊符号进行转义
[]        用来表示一个字符集合。
        字符可以一个一个的列出来,如[abcd],则可以匹配'a','b','c','d'。
        通过给出两个字符并用'-'分隔,可以给出一段范围的字符,如[a-z]匹配小写字母,[A-Z]匹配大写字母,[0-9]匹配0-9的数字。
        在集合内部,特殊字符将失去它们特殊的含义,如[(+*)]将匹配'(','+','*',')'。
        在集合中接受字符类别\s,\S,\w等。
        可以使用[^RE]作为字符集的补集,^必须为集合第一个字符,如[^a-z]可以匹配除小写字母外所有的字符。
|        a|b 匹配a或b,(Non-greedy 非贪婪型),匹配上正则a后,就不会再去尝试匹配正则b。
(...)    被圆括号括起来的表达式将作为分组,分组表达式作为一个整体,后面可以接数量词,表达式中|仅在该组中有效。
        如(a-z|A-Z){2,3}表示匹配字母2至3次。
(?aiLmsux)    给整个正则表达式设置相应的标记:re.A(ASCII码模式),re.I(忽略大小写),re.L(依赖区域设置);
            re.M(多行模式),re.S(点号匹配所有字符),re.U(依赖Unicode),re.X(详细模式)
(?:...)    # 当你要将一部分规则作为一个整体对它进行某些操作,可以使用(?:RE)将正则表达式RE包裹起来。
(?P<name>...)    # 将RE字符串包裹进来作为一个命名组。
(?P=name)        # 使用命名组进行匹配。匹配前面定义的命名组匹配到的字符串。
(?#...)            # 添加备注,忽略指定的字符。
(?='...')        # 如果指定的字符在匹配到的字符后面,才算匹配成功。s='Isaac Asimov'   m=re.findall("Isaac (?=Asimov)",s)
(?!...)            # 如果指定的字符不在匹配到的字符后面,才算匹配成功。s='Isaac Asimov'   m=re.findall("Isaac (?!Asimov)",s)
(?<=...)         # 如果指定的字符在匹配到的字符前面,才算匹配成功。s='Isaac Asimov'   m=re.findall("(?<=Isaac )Asimov",s)
(?<!...)        # 如果指定的字符不在匹配到的字符前面,才算匹配成功。s='Isaac Asimov'   m=re.findall("(?<!Isaac )Asimov",s)
(?(id/name)yes|no)        #选择性匹配 (?(id/name)yes-pattern|no-pattern) 的作用是:
                            对于给出的id或者name,先尝试去匹配 yes-pattern部分的内容;
                            如果id或name条件不满足,则去匹配no-pattern部分的内容;no-pattern部分可以省略;
                            此处的name或id,是针对(当前位置的)条件性匹配之前的,某个已经通过group去分组的内容
                            如果是有命名的分组,即named group,则对应的该分组就有对应的name,即此处所指的就是对应的name;
                            如果是无命名的分组,即unnamed group,则对应的该分组也有对应的分组的编号,称为group的number,
                            也叫做id,对应的就是这里的id。
    *** 预定义字符集
\\        匹配反斜杠
\A        匹配字符串开头,同^
\Z        匹配字符串结尾,同$
\number    匹配相同编号的组的内容
\b        匹配空字符串,仅在词的开头和结尾
\B        匹配空字符串,不在词的开头和结尾,与\b相反
\d        匹配数字,等同于[0-9]
\D        匹配非数字,等同于\d的补集,即[^\d]
\s        匹配whitespace字符串,同等于[ \t\n\r\f\v]
\S        匹配非whitespace字符串,\s的补集,[^\s]
\w        匹配字母,数字,下划线,等同于[a-zA-Z0-9_]
\W        \w的补集

使用re模块的步骤

我们有必要对re模块中所包含的类及其工作流程进行一下简单的、整体性的说明,这讲有利于我们对下面内容的理解。

使用re模块进行正则匹配操作的步骤:

  • 编写表示正则表达式规则的Python字符串str;
  • 通过re.compile()函数编译该Python字符串获得一个正则表达式对象(Pattern Object)p;
  • 通过正则表达式对象的p.match()或p.fullmatch()函数获取匹配结果–匹配对象(Match Object)m;
  • 通过判断匹配对象m是否为空可知是否匹配成功,也可以通过匹配对象m提供的方法获取匹配内容。

使用re模块进行内容查找、替换和字符串分隔操作的步骤:

  • 编写表示正则表达式规则的Python字符串str;
  • 通过re.compile()函数编译该Python字符串获得一个正则表达式对象(Pattern Object)p;
  • 通过正则表达式对象的p.search()或p.findall()或p.finditer()或p.sub()或p.subn()或p.split()函数完内容查找、替换和字符串分隔操作并获取相应的操作结果;

总结:

  • 根据上面的描述可知,将一个表示正则表达式的Python字符串编译成一个正则表达式对象是使用正则表达式完成相应功能的首要步骤.
  • re模块中用于完成正则表达式编译功能的函数为re.compile()。

re.compile(patternflags=0)将正则表达式的样式编译为一个 正则表达式对象 (正则对象),可以用于匹配,通过这个对象的方法 match()search() 以及其他如下描述。

 

prog = re.compile(pattern)
result = prog.match(string)

等价于

result = re.match(pattern, string)
re.search(patternstringflags=0)

扫描整个 字符串 找到匹配样式的第一个位置,并返回一个相应的 匹配对象。如果没有匹配,就返回一个 None ; 注意这和找到一个零长度匹配是不同的。

re.match(patternstringflags=0)

如果 string 开始的0或者多个字符匹配到了正则表达式样式,就返回一个相应的 匹配对象 。 如果没有匹配,就返回 None ;注意它跟零长度匹配是不同的。

注意即便是 MULTILINE 多行模式, re.match() 也只匹配字符串的开始位置,而不匹配每行开始。

如果你想定位 string 的任何位置,使用 search() 来替代(也可参考 search() vs. match() )

re.fullmatch(patternstringflags=0)

如果整个 string 匹配到正则表达式样式,就返回一个相应的 匹配对象 。 否则就返回一个 None ;注意这跟零长度匹配是不同的。

3.4 新版功能.

re.split(patternstringmaxsplit=0flags=0)

用 pattern 分开 string 。 如果在 pattern 中捕获到括号,那么所有的组里的文字也会包含在列表里。如果 maxsplit 非零, 最多进行 maxsplit 次分隔, 剩下的字符全部返回到列表的最后一个元素。

re.findall(patternstringflags=0)

Return all non-overlapping matches of pattern in string, as a list of strings or tuples. The string is scanned left-to-right, and matches are returned in the order found. Empty matches are included in the result.

The result depends on the number of capturing groups in the pattern. If there are no groups, return a list of strings matching the whole pattern. If there is exactly one group, return a list of strings matching that group. If multiple groups are present, return a list of tuples of strings matching the groups. Non-capturing groups do not affect the form of the result.

 

字符串分割

使用re.split(pattern, string, maxsplit=0, flags=0)进行字符分割:

字符串替换

使用re.sub(pattern, repl, string, count=0, flags=0)对字符串进行替换:

字符转义

使用re.escape将所有字符转义: