Dvel

Dvel 查看完整档案

填写现居城市  |  填写毕业院校  |  填写所在公司/组织填写个人主网站
编辑
_ | |__ _ _ __ _ | '_ \| | | |/ _` | | |_) | |_| | (_| | |_.__/ \__,_|\__, | |___/ 个人简介什么都没有

个人动态

Dvel 提出了问题 · 2月28日

解决SSH 中的 ProxyCommand 中的常用参数都是什么意思?

比如 ~/.ssh/config 中的配置:

Host *
    ProxyCommand nc -X 5 -x 127.0.0.1:1234 %h %p

我看还有人使用 -v 等等,搜了很多没找到具体解释。

比如 -v-x%h%p 这些参数都代表了什么意思呢?

关注 2 回答 1

Dvel 提出了问题 · 2020-11-26

解决现在大中小公司的生产环境一般都在用 Java 哪个版本?

只是想了解一下,有大概知道的吗?

关注 5 回答 5

Dvel 赞了回答 · 2020-10-13

解决Mac上MySQL报错:ERROR 2002 (HY000): Can't connect to local MySQL server through socket '/tmp/mysql.sock'

mysql.server start

关注 26 回答 14

Dvel 赞了回答 · 2020-08-18

解决redis如何删除大key?

大key指的是元素数目较多的集合吧?
delete直接删除会阻塞主线程;目前新版本可以通过unlink删除,此时redis通过异步线程删除。
另外,也要小心大key过期删除,配置lazyfree-lazy-expire后,同样基于异步线程实现删除操作。

关注 1 回答 1

Dvel 赞了回答 · 2020-03-10

解决用Python如何换行输出前10位

pprint

这是 Python 标准库模块,全称 pretty printer,可以让各种数据结构更美观地输出。
pprint.pprint(object, stream=None, indent=1, width=80, depth=None, *, compact=False)

  • stream:输出流,默认是 sys.stdout ,也就是屏幕输出。
  • indent:缩进空格数。
  • width:每行最大宽度,默认为80个字符,超过宽度会换行,但如果单个对象超过不会被换行,比如一段长字符串。
  • depth:限制数据的层级,设置后可以限制过多的嵌套。
  • compact:3.4版本新加入的参数,若设为 True ,则输出会在接近 width 限制才进行换行。
>>> d = {(1,'aaaaa') : 0.123456898765445676,(2,'aaaaa') : 0.123456898765445676,(3,'aaaaa') : 0.123456898765445676,(4,'aaaaa') : 0.123456898765445676,(5,'aaaaa') : 0.123456898765445676,(6,'aaaaa') : 0.123456898765445676}
>>> print(d)
{(3, 'aaaaa'): 0.12345689876544567, (1, 'aaaaa'): 0.12345689876544567, (5, 'aaaaa'): 0.12345689876544567, (6, 'aaaaa'): 0.12345689876544567, (4, 'aaaaa'): 0.12345689876544567, (2, 'aaaaa'): 0.12345689876544567}
>>> import pprint
>>> pprint.pprint(d)
{(1, 'aaaaa'): 0.12345689876544567,
 (2, 'aaaaa'): 0.12345689876544567,
 (3, 'aaaaa'): 0.12345689876544567,
 (4, 'aaaaa'): 0.12345689876544567,
 (5, 'aaaaa'): 0.12345689876544567,
 (6, 'aaaaa'): 0.12345689876544567}
>>> 

另外补充一点,字典是无序的。

关注 2 回答 4

Dvel 提出了问题 · 2019-12-18

Let's Encrypt 的 HTTPS 证书,在阿里云OSS用,如何获取公钥私钥?

对这个证书不太了解。

我自己的博客是通过 coding pages 一键申请的。
但是阿里云 OSS 要我上传公钥和私钥才能开启HTTPS访问。
image.png

我有点懵了,搜了一些博客还是没有搞懂怎么找到证书的公钥和私钥。。。

关注 1 回答 0

Dvel 关注了标签 · 2019-11-07

golang

Go语言是谷歌2009发布的第二款开源编程语言。Go语言专门针对多处理器系统应用程序的编程进行了优化,使用Go编译的程序可以媲美C或C++代码的速度,而且更加安全、支持并行进程。
Go语言是谷歌推出的一种全新的编程语言,可以在不损失应用程序性能的情况下降低代码的复杂性。谷歌首席软件工程师罗布派克(Rob Pike)说:我们之所以开发Go,是因为过去10多年间软件开发的难度令人沮丧。Go是谷歌2009发布的第二款编程语言。

七牛云存储CEO许式伟出版《Go语言编程
go语言翻译项目 http://code.google.com/p/gola...
《go编程导读》 http://code.google.com/p/ac-m...
golang的官方文档 http://golang.org/doc/docs.html
golang windows上安装 http://code.google.com/p/gomi...

关注 26301

Dvel 赞了文章 · 2019-01-01

Python 的异步 IO:Asyncio 简介

所谓「异步 IO」,就是你发起一个 IO 操作,却不用等它结束,你可以继续做其他事情,当它结束时,你会得到通知。

Asyncio 是并发(concurrency)的一种方式。对 Python 来说,并发还可以通过线程(threading)和多进程(multiprocessing)来实现。

Asyncio 并不能带来真正的并行(parallelism)。当然,因为 GIL(全局解释器锁)的存在,Python 的多线程也不能带来真正的并行。

可交给 asyncio 执行的任务,称为协程(coroutine)。一个协程可以放弃执行,把机会让给其它协程(即 yield fromawait)。`

定义协程

协程的定义,需要使用 async def 语句。

async def do_some_work(x): pass

do_some_work 便是一个协程。
准确来说,do_some_work 是一个协程函数,可以通过 asyncio.iscoroutinefunction 来验证:

print(asyncio.iscoroutinefunction(do_some_work))  # True

这个协程什么都没做,我们让它睡眠几秒,以模拟实际的工作量 :

async def do_some_work(x):
    print("Waiting " + str(x))
    await asyncio.sleep(x)

在解释 await 之前,有必要说明一下协程可以做哪些事。协程可以:

* 等待一个 future 结束
* 等待另一个协程(产生一个结果,或引发一个异常)
* 产生一个结果给正在等它的协程
* 引发一个异常给正在等它的协程

asyncio.sleep 也是一个协程,所以 await asyncio.sleep(x) 就是等待另一个协程。可参见 asyncio.sleep 的文档:

sleep(delay, result=None, *, loop=None)
Coroutine that completes after a given time (in seconds).

运行协程

调用协程函数,协程并不会开始运行,只是返回一个协程对象,可以通过 asyncio.iscoroutine 来验证:

print(asyncio.iscoroutine(do_some_work(3)))  # True

此处还会引发一条警告:

async1.py:16: RuntimeWarning: coroutine 'do_some_work' was never awaited
  print(asyncio.iscoroutine(do_some_work(3)))

要让这个协程对象运行的话,有两种方式:

* 在另一个已经运行的协程中用 `await` 等待它
* 通过 `ensure_future` 函数计划它的执行

简单来说,只有 loop 运行了,协程才可能运行。
下面先拿到当前线程缺省的 loop ,然后把协程对象交给 loop.run_until_complete,协程对象随后会在 loop 里得到运行。

loop = asyncio.get_event_loop()
loop.run_until_complete(do_some_work(3))

run_until_complete 是一个阻塞(blocking)调用,直到协程运行结束,它才返回。这一点从函数名不难看出。
run_until_complete 的参数是一个 future,但是我们这里传给它的却是协程对象,之所以能这样,是因为它在内部做了检查,通过 ensure_future 函数把协程对象包装(wrap)成了 future。所以,我们可以写得更明显一些:

loop.run_until_complete(asyncio.ensure_future(do_some_work(3)))

完整代码:

import asyncio

async def do_some_work(x):
    print("Waiting " + str(x))
    await asyncio.sleep(x)

loop = asyncio.get_event_loop()
loop.run_until_complete(do_some_work(3))

运行结果:

Waiting 3
<三秒钟后程序结束>

回调

假如协程是一个 IO 的读操作,等它读完数据后,我们希望得到通知,以便下一步数据的处理。这一需求可以通过往 future 添加回调来实现。

def done_callback(futu):
    print('Done')

futu = asyncio.ensure_future(do_some_work(3))
futu.add_done_callback(done_callback)

loop.run_until_complete(futu)

多个协程

实际项目中,往往有多个协程,同时在一个 loop 里运行。为了把多个协程交给 loop,需要借助 asyncio.gather 函数。

loop.run_until_complete(asyncio.gather(do_some_work(1), do_some_work(3)))

或者先把协程存在列表里:

coros = [do_some_work(1), do_some_work(3)]
loop.run_until_complete(asyncio.gather(*coros))

运行结果:

Waiting 3
Waiting 1
<等待三秒钟>
Done

这两个协程是并发运行的,所以等待的时间不是 1 + 3 = 4 秒,而是以耗时较长的那个协程为准。

参考函数 gather 的文档:

gather(*coros_or_futures, loop=None, return_exceptions=False)
Return a future aggregating results from the given coroutines or futures.

发现也可以传 futures 给它:

futus = [asyncio.ensure_future(do_some_work(1)),
             asyncio.ensure_future(do_some_work(3))]

loop.run_until_complete(asyncio.gather(*futus))

gather 起聚合的作用,把多个 futures 包装成单个 future,因为 loop.run_until_complete 只接受单个 future。

run_until_complete 和 run_forever

我们一直通过 run_until_complete 来运行 loop ,等到 future 完成,run_until_complete 也就返回了。

async def do_some_work(x):
    print('Waiting ' + str(x))
    await asyncio.sleep(x)
    print('Done')

loop = asyncio.get_event_loop()

coro = do_some_work(3)
loop.run_until_complete(coro)

输出:

Waiting 3
<等待三秒钟>
Done
<程序退出>

现在改用 run_forever

async def do_some_work(x):
    print('Waiting ' + str(x))
    await asyncio.sleep(x)
    print('Done')

loop = asyncio.get_event_loop()

coro = do_some_work(3)
asyncio.ensure_future(coro)

loop.run_forever()

输出:

Waiting 3
<等待三秒钟>
Done
<程序没有退出>

三秒钟过后,future 结束,但是程序并不会退出。run_forever 会一直运行,直到 stop 被调用,但是你不能像下面这样调 stop

loop.run_forever()
loop.stop()

run_forever 不返回,stop 永远也不会被调用。所以,只能在协程中调 stop

async def do_some_work(loop, x):
    print('Waiting ' + str(x))
    await asyncio.sleep(x)
    print('Done')
    loop.stop()

这样并非没有问题,假如有多个协程在 loop 里运行:

asyncio.ensure_future(do_some_work(loop, 1))
asyncio.ensure_future(do_some_work(loop, 3))

loop.run_forever()

第二个协程没结束,loop 就停止了——被先结束的那个协程给停掉的。
要解决这个问题,可以用 gather 把多个协程合并成一个 future,并添加回调,然后在回调里再去停止 loop。

async def do_some_work(loop, x):
    print('Waiting ' + str(x))
    await asyncio.sleep(x)
    print('Done')

def done_callback(loop, futu):
    loop.stop()

loop = asyncio.get_event_loop()

futus = asyncio.gather(do_some_work(loop, 1), do_some_work(loop, 3))
futus.add_done_callback(functools.partial(done_callback, loop))

loop.run_forever()

其实这基本上就是 run_until_complete 的实现了,run_until_complete 在内部也是调用 run_forever

Close Loop?

以上示例都没有调用 loop.close,好像也没有什么问题。所以到底要不要调 loop.close 呢?
简单来说,loop 只要不关闭,就还可以再运行。:

loop.run_until_complete(do_some_work(loop, 1))
loop.run_until_complete(do_some_work(loop, 3))
loop.close()

但是如果关闭了,就不能再运行了:

loop.run_until_complete(do_some_work(loop, 1))
loop.close()
loop.run_until_complete(do_some_work(loop, 3))  # 此处异常

建议调用 loop.close,以彻底清理 loop 对象防止误用。

gather vs. wait

asyncio.gatherasyncio.wait 功能相似。

coros = [do_some_work(loop, 1), do_some_work(loop, 3)]
loop.run_until_complete(asyncio.wait(coros))

具体差别可请参见 StackOverflow 的讨论:Asyncio.gather vs asyncio.wait

Timer

C++ Boost.Asio 提供了 IO 对象 timer,但是 Python 并没有原生支持 timer,不过可以用 asyncio.sleep 模拟。

async def timer(x, cb):
    futu = asyncio.ensure_future(asyncio.sleep(x))
    futu.add_done_callback(cb)
    await futu

t = timer(3, lambda futu: print('Done'))
loop.run_until_complete(t)
查看原文

赞 53 收藏 50 评论 0

Dvel 赞了回答 · 2018-12-30

解决homebrew 安装mysql后,如何配置mysql

这个是我最新并且一直推崇的方法:
1、安装:sunyichaodeMacBook-Pro:~ sunyichao$ brew install mysql
2、开启mysql:mysql.server start
2、使用mysql的配置脚本:/usr/local/opt/mysql/bin/mysql_secure_installation //mysql 提供的配置向导
启动这个脚本后,即可根据如下命令提示进行初始化设置

sunyichaodeMacBook-Pro:~ sunyichao$ /usr/local/opt/mysql/bin/mysql_secure_installation   //mysql 提供的配置向导
Securing the MySQL server deployment.
Connecting to MySQL using a blank password.
VALIDATE PASSWORD PLUGIN can be used to test passwordsand improve security. It     checks the strength of password and allows the users to set only those passwords which are secure enough. Would you like to setup VALIDATE PASSWORD plugin?

Press y|Y for Yes, any other key for No: k //是否采用mysql密码安全检测插件(这里作为演示选择否,密码检查插件要求密码复杂程度高,大小写字母+数字+字符等)
Please set the password for root here. // 首次使用自带配置脚本,设置root密码

New password:

Re-enter new password:

By default, a MySQL installation has an anonymous user, allowing anyone to log into MySQL without having to have a user account created for This is intended only for testing, and to make the installation go a bit smoother. You should remove them before moving into a production environment.    
Remove anonymous users? [Y/n] Y //是否删除匿名用户
 ... Success!

Normally, root should only be allowed to connect from 'localhost'.This
ensures that someone cannot guess at the root password from the network.

Disallow root login remotely? [Y/n] Y //是否禁止远程登录
 ... Success!

By default, MySQL comes with a database named 'test' that anyone can
access.This is also intended only for testing, and should be removed
before moving into a production environment.

Remove test database and access to it? [Y/n] Y //删除测试数据库,并登录
 Dropping test database...
 ... Success!
 Removing privileges on test database...
 ... Success!

Reloading the privilege tables will ensure that all changes made so far
will take effect immediately.

Reload privilege tables now? [Y/n] Y//重新载入权限表
 ... Success!

All done!  If you've completed all of the above steps, your MySQL
installation should now be secure.

Thanks for using MySQL!

Cleaning up...
sunyichaodeMacBook-Pro:~ sunyichao$

关注 14 回答 6

Dvel 赞了文章 · 2018-07-25

史上最全的 Python 3 类型转换指南

int

支持转换为 int 类型的,仅有 floatstrbytes,其他类型均不支持。

float -> int

会去掉小数点及后面的数值,仅保留整数部分。

int(-12.94)     # -12

str -> int

如果字符串中有数字(0-9)和正负号(+/-)以外的字符,就会报错。

int('1209')     # 1209
int('-12')      # -12
int('+1008')    # 1008

bytes -> int

如果 bytes 中有数字(0-9)和正负号(+/-)以外的字符,就会报错。

int(b'1209')     # 1209
int(b'-12')      # -12
int(b'+1008')    # 1008

float

支持转换为 float 类型的,仅有 intstrbytes,其他类型均不支持。

int -> float

int 转换为 float 时,会自动给添加一位小数。

float(-1209)     # -1209.0

str -> float

如果字符串含有正负号(+/-)、数字(0-9)和小数点(.)以外的字符,则不支持转换。

float('-1209')          # -1209.0
float('-0120.29023')    # -120.29023

bytes -> float

如果 bytes 中含有正负号(+/-)、数字(0-9)和小数点(.)以外的字符,则不支持转换。

float(b'-1209')         # -1209.0
float(b'-0120.29023')   # -120.29023

complex

仅支持 intfloatstr 转换成 complex 类型。

int -> complex

int 转换 complex 时,会自动添加虚数部分并以0j表示。

complex(12)         # (12+0j)

float -> complex

float 转换 complex 时,会自动添加虚数部分并以0j表示。

complex(-12.09)     # (-12.09+0j)

str -> complex

str 转换 complex 时,如果能转换成 int 或 float,则会转换后再转为 complex。如果字符串完全符合 complex 表达式规则,也可以转换为 complex 类型值。

complex('-12.09')       # (-12.09+0j)
complex('-12.0')        # (-12+0j),去除了小数部分
complex('-12')          # (-12+0j)
complex('-12+9j')       # (-12+9j)
complex('(-12+9j)')     # (-12+9j)
complex('-12.0-2.0j')   # (-12-2j),去除了小数部分
complex('-12.0-2.09j')  # (-12-2.09j)
complex(b'12')          # 报错,不支持 bytes 转换为 complex
complex('12 + 9j')      # 报错,加号两侧不可有空格

str

str() 函数可以将任意对象转换为字符串。

int -> str

int 转换 str 会直接完全转换。

str(12)     # 12

float -> str

float 转换 str 会去除末位为 0 的小数部分。

str(-12.90)     # -12.9

complex -> str

complex 转换 str,会先将值转化为标准的 complex 表达式,然后再转换为字符串。

str(complex(12 + 9j))   # (12+9j)
str(complex(12, 9))     # (12+9j)

bytes -> str

bytes 和 str 的转换比较特殊点,在 Python 3.x 中,字符串和字节不再混淆,而是完全不同的数据类型。

转换为可执行的表达式字符串:

str(b'hello world')        # b'hello world'

str() 函数指定 encoding 参数,或者使用 bytes.decode() 方法,可以作实际数据的转换:

b'hello world'.decode()                             # hello world
str(b'hello world', encoding='utf-8')               # hello world
str(b'\xe4\xb8\xad\xe5\x9b\xbd', encoding='utf-8')  # 中国

list -> str

会先将值格式化为标准的 list 表达式,然后再转换为字符串。

str([])                      # []
str([1, 2, 3])              # [1, 2, 3]
''.join(['a', 'b', 'c'])    # abc

tuple -> str

会先将值格式化为标准的 tuple 表达式,然后再转换为字符串。

str(())                     # ()
str((1, 2, 3))              # (1, 2, 3)
''.join(('a', 'b', 'c'))    # abc

dict -> str

会先将值格式化为标准的 dict 表达式,然后再转换为字符串。

str({'name': 'hello', 'age': 18})       # {'name': 'hello', 'age': 18}
str({})                                 # {}
''.join({'name': 'hello', 'age': 18})   # nameage

set -> str

会先将值格式化为标准的 set 表达式,然后再转换为字符串。

str(set({}))                # set()
str({1, 2, 3})              # {1, 2, 3}
''.join({'a', 'b', 'c'})    # abc

其他类型

转换内置对象:

str(int)                # <class 'int'>,转换内置类
str(hex)                # <built-in function hex>,转换内置函数

转换类实例:

class Hello:
    pass


obj = Hello()

print(str(obj))

# <__main__.Hello object at 0x1071c6630>

转换函数:

def hello():
    pass


print(str(hello))

# <function hello at 0x104d5a048>

bytes

仅支持 str 转换为 bytes 类型。

'中国'.encode()                   # b'\xe4\xb8\xad\xe5\x9b\xbd'

bytes('中国', encoding='utf-8')   # b'\xe4\xb8\xad\xe5\x9b\xbd'

list

支持转换为 list 的类型,只能是序列,比如:str、tuple、dict、set等。

str -> list

list('123abc')      # ['1', '2', '3', 'a', 'b', 'c']

bytes -> list

bytes 转换列表,会取每个字节的 ASCII 十进制值并组合成列表

list(b'hello')      # [104, 101, 108, 108, 111]

tuple -> list

tuple 转换为 list 比较简单。

list((1, 2, 3))     # [1, 2, 3]

dict -> list

字典转换列表,会取键名作为列表的值。

list({'name': 'hello', 'age': 18})  # ['name', 'age']

set -> list

集合转换列表,会先去重为标准的集合数值,然后再转换。

list({1, 2, 3, 3, 2, 1})    # [1, 2, 3]

tuple

与列表一样,支持转换为 tuple 的类型,只能是序列。

str -> tuple

tuple('中国人')    # ('中', '国', '人')

bytes -> tuple

bytes 转换元组,会取每个字节的 ASCII 十进制值并组合成列表。

tuple(b'hello')     # (104, 101, 108, 108, 111)

list -> tuple

tuple([1, 2, 3])    # (1, 2, 3)

dict -> tuple

tuple({'name': 'hello', 'age': 18})     # ('name', 'age')

set -> tuple

tuple({1, 2, 3, 3, 2, 1})       # (1, 2, 3)

dict

str -> dict

  • 使用 json 模块

    使用 json 模块转换 JSON 字符串为字典时,需要求完全符合 JSON 规范,尤其注意键和值只能由单引号包裹,否则会报错。
    import json
    
    user_info = '{"name": "john", "gender": "male", "age": 28}'
    print(json.loads(user_info))
    
    # {'name': 'john', 'gender': 'male', 'age': 28}
  • 使用 eval 函数

    因为 eval 函数能执行任何符合语法的表达式字符串,所以存在严重的安全问题,不建议。
    user_info = "{'name': 'john', 'gender': 'male', 'age': 28}"
    print(eval(user_info))
    
    # {'name': 'john', 'gender': 'male', 'age': 28}
  • 使用 ast.literal_eval 方法

    使用 ast.literal_eval 进行转换既不存在使用 json 进行转换的问题,也不存在使用 eval 进行转换的 安全性问题,因此推荐使用 ast.literal_eval。
    import ast
    
    user_info = "{'name': 'john', 'gender': 'male', 'age': 28}"
    user_dict = ast.literal_eval(user_info)
    print(user_dict)
    
    # {'name': 'john', 'gender': 'male', 'age': 28}

list -> dict

通过 zip 将 2 个列表映射为字典:

list1 = [1, 2, 3, 4]
list2 = [1, 2, 3]
print(dict(zip(list1, list2)))

# {1: 1, 2: 2, 3: 3}

将嵌套的列表转换为字典:

li = [
    [1, 111],
    [2, 222],
    [3, 333],
]

print(dict(li))

# {1: 111, 2: 222, 3: 333}

tuple -> dict

通过 zip 将 2 个元组映射为字典:

tp1 = (1, 2, 3)
tp2 = (1, 2, 3, 4)

print(dict(zip(tp1, tp2)))

# {1: 1, 2: 2, 3: 3}

将嵌套的元组转换为字典:

tp = (
    (1, 111),
    (2, 222),
    (3, 333),
)

print(dict(tp))

# {1: 111, 2: 222, 3: 333}

set -> dict

通过 zip 将 2 个集合映射为字典:

set1 = {1, 2, 3}
set2 = {'a', 'b', 'c'}

print(dict(zip(set1, set2)))

# {1: 'c', 2: 'a', 3: 'b'}

set

str -> set

先将字符切割成元组,然后再去重转换为集合。

print(set('hello'))     # {'l', 'o', 'e', 'h'}

bytes -> set

会取每个字节的 ASCII 十进制值并组合成元组,再去重。

set(b'hello')           # {104, 108, 101, 111}

list -> set

先对列表去重,再转换。

set([1, 2, 3, 2, 1])    # {1, 2, 3}

tuple -> set

先对列表去重,再转换。

set((1, 2, 3, 2, 1))    # {1, 2, 3}

dict -> set

会取字典的键名组合成集合。

set({'name': 'hello', 'age': 18})

# {'age', 'name'}

参考资料


原文地址: https://shockerli.net/post/py...

更多文章请访问我的个人博客: https://shockerli.net

查看原文

赞 18 收藏 13 评论 0

认证与成就

  • 获得 11 次点赞
  • 获得 44 枚徽章 获得 2 枚金徽章, 获得 15 枚银徽章, 获得 27 枚铜徽章

擅长技能
编辑

(゚∀゚ )
暂时没有

开源项目 & 著作
编辑

(゚∀゚ )
暂时没有

注册于 2014-06-05
个人主页被 740 人浏览