日期: 2021 年 3 月 27 日

KMS服务器关于Vol Windows/Office命令

可用的KMS服务器地址:

zh.us.to 有效

kms.03k.org 有效

kms.chinancce.com 有效

kms.shuax.com 有效

kms.dwhd.org 有效

kms.luody.info 有效

kms.digiboy.ir 有效

kms.lotro.cc 有效

www.zgbs.cc 有效

cy2617.jios.org 有效

 

假如你的服务器IP是1.1.1.1

Windows用下面两条命令:(需要cmd在管理员权限下执行)

slmgr -skms 1.1.1.1

slmgr -ato
查看Windows状态用下面命令(KMS连接周期,剩余时间等):

slmgr.vbs /dlv
Office用下面这条命令:(需要cmd在管理员权限下执行)

cscript “E:\Microsoft Office\Office16\OSPP.VBS” /sethst:1.1.1.1
查看Office状态用下面这条命令:(需要cmd在管理员权限下执行)

cscript “E:\Microsoft Office\Office16\OSPP.VBS” /dstatus
其中E:\Microsoft Office\Office16   是Office2016中OSPP.VBS 所在的目录,Office16代表Office2016;Office15达标Office2013;Office14代表Office2010;

tidb分布式数据库是mysql_常见问题-分布式数据库 TiDB-帮助文档-京东智联云

常见问题

1. 分布式数据库 TiDB 是基于 MySQL 开发的吗?

不是,但是分布式数据库 TiDB 支持 MySQL 语法和协议。

2. 用起来简单吗?

是的,分布式数据库 TiDB 用起来很简单。启动整套服务后,就可以将 分布式数据库 TiDB 当做一个普通的 MySQL Server 来用,您可以将 分布式数据库 TiDB 用在任何以 MySQL 作为后台存储服务的应用中,基本上不需要修改应用代码,并且兼容大部分 MySQL 管理工具。

3. 适用的场景?

原业务的 MySQL 的业务遇到单机容量或者性能瓶颈时,可以考虑使用 分布式数据库 TiDB 无缝替换 MySQL。

4. 如何将运行在 MySQL 上的应用迁移到 分布式数据库 TiDB 上?

分布式数据库 TiDB 大多数 MySQL 语法,一般不需要修改代码,可以用工具 Checker 检查 MySQL 中的 Schema 是否兼容。

5. TiDB 具备高可用的特性吗?

TiDB 具备高可用特性,TiDB、TiKV、PD 这三个组件都能容忍部分实例失效,不影响整个集群的可用性。

6. TiDB 数据是强一致的吗?

TiDB 使用 Raft 在多个副本之间做数据同步,从而保证数据的强一致,单个副本失效时,不影响数据的可靠性。

7. TiDB 用户名长度限制?

在 TiDB 中用户名*长为 32 字符。

8. 一个事务中的语句数量*大是多少?

一个事务中的语句数量,默认限制*大为 5000 条。

9. 如何通过扩展 分布式数据库 TiDB 提高性能?

随着业务不断增长时,数据库可能会面临三方面瓶颈: – *是存储资源不够,也就是磁盘空间不够; – 第二是计算资源不够用,如 CPU 占用较高; – 第三是吞吐跟不上;

这时可以对数据库集群做水平扩展。 – 如果是存储资源不够,可以通过添加 TiKV Server 节点来解决。新节点启动后,PD 会自动将其他节点的部分数据迁移过去,无需人工介入。 – 如果是计算资源不够,可以查看 TiDB 节点 和 TiKV 节点的 CPU 消耗情况,再考虑添加 TiDB 节点或者是 TiKV 节点来解决。 – 如果是吞吐跟不上,一般可以考虑同时增加 TiDB 节点 和 TiKV 节点。
————————————————
版权声明:本文为CSDN博主「冰浠」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
原文链接:https://blog.csdn.net/weixin_30980025/article/details/114471493

Python基础之:函数

Python基础之:函数

文章目录
简介
内置函数
自定义函数
参数的默认值
关键字参数
特殊参数
参数解包
Lambda
函数标注
简介
函数是结构化编程的基础,也是代码复用的基石。Python中通过def来自定义函数。本文将会深入探索Python中函数的秘密。

内置函数
除了用户的自定义函数之外,Python内置了一些非常有用的函数:

内置函数
abs() delattr() hash() memoryview() set()
all() dict() help() min() setattr()
any() dir() hex() next() slice()
ascii() divmod() id() object() sorted()
bin() enumerate() input() oct() staticmethod()
bool() eval() int() open() str()
breakpoint() exec() isinstance() ord() sum()
bytearray() filter() issubclass() pow() super()
bytes() float() iter() print() tuple()
callable() format() len() property() type()
chr() frozenset() list() range() vars()
classmethod() getattr() locals() repr() zip()
compile() globals() map() reversed() __import__()
complex() hasattr() max() round()
自定义函数
Python中使用def来定义函数,并使用return来返回特定的值。

看一个简单的函数的例子:

def my_function(x, y, z):
if z > 1:
return z * (x + y)
else:
return z / (x + y)

把我们之前讲的斐波拉赫数列的例子重新用函数来定义,可以这样写:

def fib(n):
a, b = 0, 1
while a < n:
print(a, end=’ ‘)
a, b = b, a+b
print()

# 调用函数
fib(1000)

函数的内容需要使用空格或者tab来进行缩进。

参数的默认值
在Python中,我们可以给参数设置默认值,这样如果在函数调用的过程中没有传递参数的时候,就会使用默认值作为参数。

在我们之前定义的函数my_function中,我们可以给z设置一个默认值:

def my_function(x, y, z=10):
if z > 1:
return z * (x + y)
else:
return z / (x + y)

这样我们在调用my_function可以只用传递两个参数,*后的z可以使用默认的参数值。

注意,默认值只会执行一次,如果你传入的参数是可变对象(列表,字典和类实例)的话,我们需要注意这个问题:

def f(a, L=[]):
L.append(a)
return L

print(f(1))
print(f(2))
print(f(3))

# 输出
[1]
[1, 2]
[1, 2, 3]

如果不想在后面的调用中共享默认值,那么可以把默认值的赋值放到函数体内部:

def f(a, L=None):
if L is None:
L = []
L.append(a)
return L

关键字参数
我们可以使用key=value的方式对函数进行调用。

还是前面的函数:

def my_function(x, y, z=10):
if z > 1:
return z * (x + y)
else:
return z / (x + y)

我们可以这样调用:

my_function(1,y=3,z=5)
my_function(1,y=3)

但是不能这样用:

my_function(y=3,1)

关键字的参数必须要放在非关键词参数的后面。也不能对参数进行多次赋值:

>>> def function(a):
… pass

>>> function(0, a=0)
Traceback (most recent call last):
File “<stdin>”, line 1, in <module>
TypeError: function() got multiple values for keyword argument ‘a’

通过上面的讨论我们可以看出,Python函数中的参数有两种,一种是带默认值的参数,一种是不带默认值的参数。

注意,不带默认值的参数一定要在带默认值的参数之前 。

看一个错误的例子:

In [69]: def fa(a=100,b,c=200):
…: pass
File “<ipython-input-69-d5678b64f352>”, line 1
def fa(a=100,b,c=200):
^
SyntaxError: non-default argument follows default argument

而向函数传递参数也有两种方式,一种是不带关键字的传递,一种是带关键字的传递。

注意,非关键词参数的传递一定要在关键词参数传递之前。

举个错误的例子:

In [70]: def fa(a,b=100,c=200):
…: pass
…:

In [71]: fa(a=100,30)
File “<ipython-input-71-5a229b8e420e>”, line 1
fa(a=100,30)
^
SyntaxError: positional argument follows keyword argument

那么问题来了,如果有多个关键词参数和多个非关键词参数,有没有简便的方法来定义这样的函数呢?

有的,那就是 *arguments 和 **keywords

*arguments用来接收所有多余的非关键词参数。而**keywords用来接收所有额外的关键词参数。

注意,*arguments一定要出现在 **keywords 的前面。

举个例子:

def cheeseshop(kind, *arguments, **keywords):
print(“– Do you have any”, kind, “?”)
print(“– I’m sorry, we’re all out of”, kind)
for arg in arguments:
print(arg)
print(“-” * 40)
for kw in keywords:
print(kw, “:”, keywords[kw])

我们可以这样调用:

cheeseshop(“Limburger”, “It’s very runny, sir.”,
“It’s really very, VERY runny, sir.”,
shopkeeper=”Michael Palin”,
client=”John Cleese”,
sketch=”Cheese Shop Sketch”)

将会得到下面的结果:

— Do you have any Limburger ?
— I’m sorry, we’re all out of Limburger
It’s very runny, sir.
It’s really very, VERY runny, sir.
—————————————-
shopkeeper : Michael Palin
client : John Cleese
sketch : Cheese Shop Sketch

特殊参数
函数可以按位置传参,可以按照关键词传参,也可以混合传参。

在某些情况下,我们可能需要限制传参的类型,比如只接收按位置传递,只接收按关键词传递,或者只接受混合传递。

看下特殊参数的定义:

def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):
———– ———- ———-
| | |
| 按位置或者关键词 |
| – 只允许按关键词传递
— 只允许按位置传递

注意,参数之间是以 / 和 * 来进行区分的。

我们举个例子:

>>> def standard_arg(arg):
… print(arg)

>>> def pos_only_arg(arg, /):
… print(arg)

>>> def kwd_only_arg(*, arg):
… print(arg)

>>> def combined_example(pos_only, /, standard, *, kwd_only):
… print(pos_only, standard, kwd_only)

上面定义了4种传参方式的函数。

*个函数就是标准形式,可以按位置传递,也可以按关键词传递。

第二个函数只允许按照位置传递。

第三个函数只允许按照关键词来传递。

第四个函数是混合模式。

参数解包
有时候我们需要将列表或者字典的值转换为函数的参数。那么就需要用到参数解包的功能。

* 操作符 可以用来解包列表和元组。

>>> list(range(3, 6)) # normal call with separate arguments
[3, 4, 5]
>>> args = [3, 6]
>>> list(range(*args)) # call with arguments unpacked from a list
[3, 4, 5]

** 操作符 可以用来解包字典。

>>> def parrot(voltage, state=’a stiff’, action=’voom’):
… print(“– This parrot wouldn’t”, action, end=’ ‘)
… print(“if you put”, voltage, “volts through it.”, end=’ ‘)
… print(“E’s”, state, “!”)

>>> d = {“voltage”: “four million”, “state”: “bleedin’ demised”, “action”: “VOOM”}
>>> parrot(**d)

Lambda
熟悉java的朋友可能知道,在JDK8中,Java引入了Lambda表达式。同样的Python中也有Lambda。

你可以将Lambda看做是匿名函数。可以在任何需要函数的地方使用Lambda表达式。

看一个Lambda的例子:

>>> def make_incrementor(n):
… return lambda x: x + n

>>> f = make_incrementor(42)
>>> f(0)
42
>>> f(1)

还可以将lambda的返回值作为参数:

>>> pairs = [(1, ‘one’), (2, ‘two’), (3, ‘three’), (4, ‘four’)]
>>> pairs.sort(key=lambda pair: pair[1])
>>> pairs
[(4, ‘four’), (1, ‘one’), (3, ‘three’), (2, ‘two’)]

函数标注
之前我们讨论的是简单的自定义函数形式,我们并不知道函数的参数类型和返回值类型,其实函数可以写得更加详细一些,这就要用到函数标注了。

所谓函数标注就是用户自定义函数中的类型的可选元数据信息。

函数标注是以字典的形式存放在 __annotations__ 属性中的。我们在参数的名称后面加上冒号,后面跟一个表达式,那么这个表达式会被求值为标注的值。对于返回值来说,返回值标注的定义是加上一个组合符号 ->,后面跟一个表达式,该标注位于形参列表和表示 def 语句结束的冒号之间。

举个例子:

>>> def f(ham: str, eggs: str = ‘eggs’) -> str:
… print(“Annotations:”, f.__annotations__)
… print(“Arguments:”, ham, eggs)
… return ham + ‘ and ‘ + eggs

>>> f(‘spam’)
Annotations: {‘ham’: <class ‘str’>, ‘return’: <class ‘str’>, ‘eggs’: <class ‘str’>}
Arguments: spam eggs
‘spam and eggs’

其实使用函数标注写出来的程序更加清晰,可读性更高。

阿里云ECS 云服务器和轻量应用服务器 区别

什么是阿里云轻量应用服务器?

轻量应用服务器是面向入门级云计算及简单应用用户,提供基于单台云服务器的域名管理、应用部署、安全和运维管理的一站式综合服务。用户可以选择精品应用镜像(比如wordpress),并可在控制台实现全方位的服务器、域名、防火墙、安全防控、监控等管理和操作。轻量应用服务器 (Simple Application Server),是可快速搭建且易于管理的轻量级云服务器。

如下介绍:

%title插图%num

注:学生身份购买,会便宜一些。

阿里云轻量应用服务器的优点是什么?
1.易用易上手。

产品针对单机用户的购买和使用做了操作和使用优化,提供精品镜像、资源套餐、多产品关联(VPC、安全产品、域名管理等)。简单三步就可以轻松开始使用轻量应用服务器

a.选择镜像,并购买(创建)服务器;

b.配置应用:通过查看控制台已经安装好的应用信息,并通过登录服务器查看初始化应用的密码,登录应用后台配置应用;

c.将域名解析到服务器IP。

2.性价比高。

在集合多个必用或常用产品、提供更多基础功能,优化使用体验的同时,并未增加额外费用,且提供了更加优惠的价格,旨在提供更多用户低门槛上云实践机会。

阿里云轻量应用服务器与阿里云ecs云服务器有什么区别?
跟ECS相比,采用同ECS共享版相同的CPU,均采用Intel(R) Xeon(R) CPU E5-2682 v4@ 2.50GHz CPU,但轻量应用服务器将系统盘升级为SSD,虽然容量小了一半,但使用SSD,性能应该是有不错的提升。相同CPU,内存不知道是否相同型号的情况下,单来比较磁盘读写性能,可见速度的提升明显。

介绍
所以就有了轻量应用服务器(轻量应用服务器),基于 ECS 发展出的轻量服务器,完美解决了上述的三个痛点:

轻量应用服务器 是 IaaS 产品但是提供定制化应用镜像且有可视化控制台可以操作,不怕新手不会用。轻量应用服务器 在提供
提供定制化应用镜像的同时,用户依旧可以拥有 root 权限,对系统进行个性化操作
精简了一些 ECS 的功能,比如说安骑士。把安全组的操作也做了适当减法更适合用户操作
不过别看多了轻量两个字性能就会不如 ECS,在 CPU 和 磁盘性能上均没有缩水,后面会有测评。

优点
控制台
轻量应用服务器

那么从控制台的对比上,ECS 是把所有的内容都告诉用户你的地域、操作系统、标签等等,但是新手看了难免一头雾水。而 轻量应用服务器 则做了减法,让控制台变得更加的直观简介,只告诉你重要的信息。

站在新手视角肯定是 轻量应用服务器 更简洁更舒服,站在我的角度么,我配置好服务器基本上很少会来看一下 ECS 的控制台,但一回来肯定是需要一些信息的,那么 ECS 能告诉我越多肯定越好。

应用镜像

应用镜像像 WordPress、phpwind 其实都是基于 LAMP 镜像运行的,而 轻量应用服务器 提供的 LAMP 细节好评就是:php 是通过 php-fpm 方式运行的,而不是 mod_php,而且 MySQL 也是 5.7 版本的不是说万年 5.1 或者 5.5,能支持更多的 PHP 程序。在创建虚拟主机绑定域名商相较于一键包配合图形化控制台的确更加好用。

功能

轻量应用服务器 在功能上肯定是更讨喜的,安装应用镜像基本上能做到开箱即用,三大金刚 Apache Httpd、PHP、MySQL 都会默认安装好,而且添加域名、设置 HTTPS 等操作都是一键式的,*大得降低了 HTTPS 入门门槛,而且 HTTPS 的配置跑分是 A 哟,为了照顾新手不会使用 HSTS 所以没开,不然跑到 A+ 肯定是妥妥的。

ECS 能就只有空白的系统镜像,任何环境都是需要用户自行安装的,这在一定程度上增加了用户使用的学习成本。而 ECS 更多体现的就是专业性了,虽然复杂但是十分强大的安全组、弹性IP、均衡负载等等。

基础运维

比如说 ECS 控制台操作起来也更加的方便,点击一下就能远程连接了,操作的过程中也支持命令的右键复制和粘贴,也大大降低了用户使用终端控制的学习成本,不然还要下个 Putty 或者 Xshell 啥的也是麻烦。 然后默认只支持 密钥 登录 Linux,这个也是好评,不用密码当然更安全。

同样不考虑使用 Putty 或者 Xshell 等 OpenSSH 连接工具的话,ECS控制台的远程终端控制实在是难用,不过借助 DMS 产品倒是能扩展使用的灵活性。

防火墙

轻量的防火墙设置同 ECS 的安全组相比很简单直观更适合新手的使用,没有一些非常复杂的设置,新手看到 udp、tcp 真的是头都大了额,如果新手看教程的话,一般只会说 “记得一定要开启443端口才能使用HTTPS” 这样的话,但是一看到 ECS 又是 TCP 又是 UDP,而且端口还要写成 443/443 的形式,直接就是一个头两个大了。

缺点
无法满足企业特性
轻量应用服务器有轻量两个字,意味着其无法持续进行高负载运行(即 CPU 长时间高负载占用),如果我们要利用 轻量应用服务器 来进行持续的渲染、转码、机器学习等持续高负载操作那么就不可以了,也不支持 Nvme 这样的超高性能的 SSD,这对于读写敏感的操作就不好了。

三大金刚的版本问题
Apache Httpd、PHP、MySQL 是会持续更新的,而且它们也均有爆发过大规模严重漏洞的历史,不过目前还没有看到应用镜像中的三大金刚如何升级版本号的姿势。

像 WordPress 这样的程序完全可以适应高版本的 PHP,使用 PHP7.0 或者 7.1 可以拥有更高的性能还可以降低负载,但是默认只有 php5.6 可以选,既然使用 php-fpm 方式驱动其实完全可以提供多版本 PHP 的选择。

总结
可以说 轻量应用服务器 是专门针对云计算入门新手或者只有轻量计算需求的用户,其对标的产品只会是 ECS 的共享型,当一到要使用 ECS 的企业型来发展性能、功能了,轻量应用服务器 的优势其实也就没有了。

如果你只是轻度使用云计算产品例如搭建一个博客、官网,如果你需要一个更快启动的轻量服务器,如果你需要一个纯粹的虚拟专用机,如果你并没有阿里云内网的需求,那么 轻量应用服务器 *对是你*好的选择。

评测
我们对比的是华东1地域的安装了 CentOS 7.3 系统的 1核心1G内存的 ECS 和 轻量应用服务器 产品。看了评测就可以跟深入的了解,ECS 和 轻量应用服务器 的不同只在于概念而不在于性能。

CPU 性能
根据下面的对比可以发现,轻量应用服务器 的性能和 ECS 并没有差距,大家都是新一代的 Xeon CPU,同样的虚拟化技术。只不过 轻量应用服务器 不可以持续高负载占用。

轻量应用服务器:

System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 34281977.0 2937.6
Double-Precision Whetstone 55.0 2962.7 538.7
Execl Throughput 43.0 4860.0 1130.2
File Copy 1024 bufsize 2000 maxblocks 3960.0 1054197.7 2662.1
File Copy 256 bufsize 500 maxblocks 1655.0 283098.8 1710.6
File Copy 4096 bufsize 8000 maxblocks 5800.0 3165160.0 5457.2
Pipe Throughput 12440.0 1734490.3 1394.3
Pipe-based Context Switching 4000.0 375732.0 939.3
Process Creation 126.0 18345.1 1456.0
Shell Scripts (1 concurrent) 42.4 6747.0 1591.3
Shell Scripts (8 concurrent) 6.0 921.5 1535.8
System Call Overhead 15000.0 2939229.7 1959.5
========
System Benchmarks Index Score 1649.5

ECS:

System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 34582858.9 2963.4
Double-Precision Whetstone 55.0 2984.8 542.7
Execl Throughput 43.0 5118.8 1190.4
File Copy 1024 bufsize 2000 maxblocks 3960.0 1073823.9 2711.7
File Copy 256 bufsize 500 maxblocks 1655.0 284701.5 1720.3
File Copy 4096 bufsize 8000 maxblocks 5800.0 3213933.6 5541.3
Pipe Throughput 12440.0 1722785.7 1384.9
Pipe-based Context Switching 4000.0 377999.7 945.0
Process Creation 126.0 18704.4 1484.5
Shell Scripts (1 concurrent) 42.4 6852.6 1616.2
Shell Scripts (8 concurrent) 6.0 937.2 1562.0
System Call Overhead 15000.0 2979190.8 1986.1
========
System Benchmarks Index Score 1673.4

磁盘性能
由下面的磁盘跑分也可以看见,轻量应用服务器 的 20G SSD 系统盘 和 ECS 的 20G SSD 云盘的性能都是一致的,都是 1800 的iops,也都是 90M 左右的读写没有差距。

轻量应用服务器:

/dev/vda:
Timing cached reads: 21070 MB in 2.00 seconds = 10549.25 MB/sec
Timing buffered disk reads: 270 MB in 3.01 seconds = 89.76 MB/sec

[root@izbp1auqkyqtj4iozs7athz dev]# fio –bs=4k –ioengine=libaio –iodepth=1 –direct=1 –rw=read –time_based –runtime=600 –refill_buffers –norandommap –randrepeat=0 –group_reporting –name=fio-read –size=10G –filename=/dev/vda
fio-read: (g=0): rw=read, bs=4K-4K/4K-4K/4K-4K, ioengine=libaio, iodepth=1
fio-2.2.8
Starting 1 process
Jobs: 1 (f=1): [R(1)] [100.0% done] [7200KB/0KB/0KB /s] [1800/0/0 iops] [eta 00m:00s]
fio-read: (groupid=0, jobs=1): err= 0: pid=24361: Sun Sep 10 15:04:27 2017
read : io=4206.7MB, bw=7179.3KB/s, iops=1794, runt=600004msec
slat (usec): min=3, max=165, avg= 6.78, stdev= 2.02
clat (usec): min=2, max=84748, avg=548.56, stdev=2727.93
lat (usec): min=131, max=84755, avg=555.59, stdev=2727.93
clat percentiles (usec):
| 1.00th=[ 141], 5.00th=[ 241], 10.00th=[ 302], 20.00th=[ 306],
| 30.00th=[ 314], 40.00th=[ 322], 50.00th=[ 334], 60.00th=[ 350],
| 70.00th=[ 362], 80.00th=[ 382], 90.00th=[ 442], 95.00th=[ 502],
| 99.00th=[ 1012], 99.50th=[23936], 99.90th=[40704], 99.95th=[42752],
| 99.99th=[68096]
bw (KB /s): min= 4624, max= 7784, per=100.00%, avg=7182.85, stdev=181.15
lat (usec) : 4=0.01%, 250=6.25%, 500=88.69%, 750=3.79%, 1000=0.27%
lat (msec) : 2=0.36%, 4=0.06%, 10=0.03%, 20=0.04%, 50=0.48%
lat (msec) : 100=0.04%
cpu : usr=0.50%, sys=1.81%, ctx=1076903, majf=1, minf=33
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1076894/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=1

Run status group 0 (all jobs):
READ: io=4206.7MB, aggrb=7179KB/s, minb=7179KB/s, maxb=7179KB/s, mint=600004msec, maxt=600004msec

Disk stats (read/write):
vda: ios=1078167/690, merge=0/399, ticks=598805/4230, in_queue=602927, util=98.01%

ECS:

/dev/vdb:
Timing cached reads: 19778 MB in 2.00 seconds = 9901.01 MB/sec
Timing buffered disk reads: 270 MB in 3.02 seconds = 89.54 MB/sec

[root@iZbp1258gr0v9v184jdqqkZ dev]# fio –bs=4k –ioengine=libaio –iodepth=1 –direct=1 –rw=read –time_based –runtime=600 –refill_buffers –norandommap –randrepeat=0 –group_reporting –name=fio-read –size=10G –filename=/dev/vdb
fio-read: (g=0): rw=read, bs=4K-4K/4K-4K/4K-4K, ioengine=libaio, iodepth=1
fio-2.2.8
Starting 1 process
Jobs: 1 (f=1): [R(1)] [100.0% done] [6940KB/0KB/0KB /s] [1735/0/0 iops] [eta 00m:00s]
fio-read: (groupid=0, jobs=1): err= 0: pid=9552: Sun Sep 10 15:23:44 2017
read : io=4218.9MB, bw=7200.2KB/s, iops=1800, runt=600001msec
slat (usec): min=3, max=344, avg= 6.97, stdev= 2.32
clat (usec): min=1, max=85711, avg=546.79, stdev=4741.30
lat (usec): min=145, max=85717, avg=553.99, stdev=4741.28
clat percentiles (usec):
| 1.00th=[ 147], 5.00th=[ 149], 10.00th=[ 151], 20.00th=[ 153],
| 30.00th=[ 155], 40.00th=[ 159], 50.00th=[ 167], 60.00th=[ 199],
| 70.00th=[ 229], 80.00th=[ 241], 90.00th=[ 249], 95.00th=[ 270],
| 99.00th=[ 374], 99.50th=[56576], 99.90th=[67072], 99.95th=[67072],
| 99.99th=[67072]
bw (KB /s): min= 6380, max= 7624, per=100.00%, avg=7202.00, stdev=111.69
lat (usec) : 2=0.01%, 50=0.01%, 250=90.56%, 500=8.76%, 750=0.06%
lat (usec) : 1000=0.02%
lat (msec) : 2=0.02%, 4=0.01%, 10=0.01%, 20=0.01%, 50=0.01%
lat (msec) : 100=0.55%
cpu : usr=0.50%, sys=1.98%, ctx=1080029, majf=0, minf=34
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=1080027/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=1

Run status group 0 (all jobs):
READ: io=4218.9MB, aggrb=7200KB/s, minb=7200KB/s, maxb=7200KB/s, mint=600001msec, maxt=600001msec

Disk stats (read/write):
vdb: ios=1079640/0, merge=0/0, ticks=589523/0, in_queue=589382, util=98.27%

 

 

javascript中的Strict模式

javascript中的Strict模式

 

看动画学算法
以动画的方式,图文并茂讲解常用的算法和数据结构,包括各种排序算法、hash、栈、队列、链表、树、散列表、堆、图等,*对物有所值!
flydean程序那些事
¥39.90
订阅博主
文章目录
简介
使用Strict mode
strict mode的新特性
强制抛出异常
简化变量的使用
简化arguments
让javascript变得更加安全
保留关键字和function的位置
总结
简介
我们都知道javascript是一个弱类型语言,在ES5之前,javascript的程序编写具有很强的随意性,我可以称之为懒散模式(sloppy mode)。比如可以使用未定义的变量,可以给对象中的任意属性赋值并不会抛出异常等等。

在ES5中,引入了strict模式,我们可以称之为严格模式。相应的sloppy mode就可以被称为非严格模式。

严格模式并不是非严格模式的一个子集,相反的严格模式在语义上和非严格模式都发生了一定的变化,所以我们在使用过程中,一定要经过严格的测试。以保证在严格模式下程序的执行和非严格模式下的执行效果一致。

使用Strict mode
strict mode会改变javascript的一些表现,我们将会在下一节中进行详细的讲解。

这里先来看一下,怎么使用strict mode。

Strict mode主要用在一个完整的脚本或者function中,并不适用于block {}。 如果在block中使用strict mode是不会生效的。

除此之外,eval中的代码,Function代码,event handler属性和传递给WindowTimers.setTimeout()的string都可以看做是一个完整的脚本。我们可以在其中使用Strict mode。

如果是在script脚本中使用strict模式,可以直接在脚本的*上面加上”use strict”:

// 整个脚本的strict模式
‘use strict’;
var v = “Hi! I’m a strict mode script!”;
同样的我们也可以在function中使用strict模式:

function strict() {
// 函数的strict模式
‘use strict’;
function nested() { return ‘And so am I!’; }
return “Hi! I’m a strict mode function! ” + nested();
}
function notStrict() { return “I’m not strict.”; }

如果使用的是ES6中引入的modules,那么modules中默认就已经是strict模式了,我们不需要再额外的使用”use strict”:

function myModule() {
// 默认就是strict模式
}
export default myModule;
strict mode的新特性
strict mode在语法和运行时的表现上面和非严格模式都发生了一定的变化,接下来,我们一一来看。

强制抛出异常
在js中,有很多情况下本来可能是错误的操作,但是因为语言特性的原因,并没有抛出异常,从而导致*终运行结果并不是所期待的。

如果使用strict模式,则会直接抛出异常。

比如在strict模式中,不允许使用未定义的全局变量:

‘use strict’;

globalVar = 10; //ReferenceError: globalVar is not defined
这样实际上可以避免手误导致变量名字写错而导致的问题。

我再看一些其他的例子:

‘use strict’;

// 赋值给不可写的全局变量,
var undefined = 5; // throws a TypeError
var Infinity = 5; // throws a TypeError

// 赋值给不可写的属性
var obj1 = {};
Object.defineProperty(obj1, ‘x’, { value: 42, writable: false });
obj1.x = 9; // throws a TypeError

// 赋值给一个get方法
var obj2 = { get x() { return 17; } };
obj2.x = 5; // throws a TypeError

// 赋值给一个禁止扩展的对象
var fixed = {};
Object.preventExtensions(fixed);
fixed.newProp = ‘ohai’; // throws a TypeError

Strict模式可以限制删除不可删除的属性,比如构造函数的prototype:

‘use strict’;
delete Object.prototype; // throws a TypeError

禁止对象和函数参数中的重复属性:

‘use strict’;
var o = { p: 1, p: 2 }; // Duplicate declaration

function sum(a, a, c) { // Duplicate declaration
‘use strict’;
return a + a + c;
}
禁止设置基础类型的属性:

(function() {
‘use strict’;

false.true = ”; // TypeError
(14).sailing = ‘home’; // TypeError
‘with’.you = ‘far away’; // TypeError

})();

简化变量的使用
使用Strict模式可以简化变量的使用,让程序代码可读性更强。

首先,strict模式禁止使用with。

with很强大,我们可以通过将对象传递给with,从而影响变量查找的scope chain。也就是说当我们在with block中需要使用到某个属性的时候,除了在现有的scope chain中查找之外,还会在with传递的对象中查找。

with (expression)
statement

使用with通常是为了简化我们的代码,比如:

var a, x, y;
var r = 10;

with (Math) {
a = PI * r * r;
x = r * cos(PI);
y = r * sin(PI / 2);
}

上面的例子中,PI是Math对象中的变量,但是我们可以在with block中直接使用。有点像java中的import的感觉。

下面的例子将会展示with在使用中的问题:

function f(x, o) {
with (o) {
console.log(x);
}
}
们在with block中输出x变量,从代码可以看出f函数传入了一个x变量。但是如果with使用的对象中如果也存在x属性的话,就会出现意想不到的问题。

所以,在strict模式中,with是禁止使用的。

其次是对eval的改动。

传统模式中,eval中定义的变量,将会自动被加入到包含eval的scope中。我们看个例子:

var x = 17;
var evalX = eval(“var x = 42; x;”);
console.log(x);

因为eval中引入了新的变量x,这个x的值将会覆盖*开始定义的x=17. *后我们得到结果是42.

如果加入use strict,eval中的变量将不会被加入到现有的Scope范围中,我们将会得到结果17.

var x = 17;
var evalX = eval(“‘use strict’; var x = 42; x;”);
console.log(x);
这样做的好处是为了避免eval对现有程序逻辑的影响。

在strict模式下面,还不允许delete name:

‘use strict’;

var x;
delete x; // !!! syntax error

eval(‘var y; delete y;’); // !!! syntax error~~

简化arguments
在js中,arguments代表的是参数数组,首先在Strict模式下,arguments是不能作为变量名被赋值的:

‘use strict’;
arguments++;
var obj = { set p(arguments) { } };
try { } catch (arguments) { }
function arguments() { }
var f = new Function(‘arguments’, “‘use strict’; return 17;”);

上面执行都会报错。

另外,在普通模式下,arguments是和命名参数相绑定的,并且arguments[0]和arg同步变化,都表示的是*个参数。

但是如果在strict模式下,arguments表示的是真正传入的参数。

我们举个例子:

function f(a) {
a = 42;
return [a, arguments[0]];
}
var pair = f(17);
console.log(pair[0]); // 42
console.log(pair[1]); // 42

上面的例子中,arguments[0]是和命名参数a绑定的,不管f传入的是什么值,arguments[0]的值*后都是42.

如果换成strict模式:

function f(a) {
‘use strict’;
a = 42;
return [a, arguments[0]];
}
var pair = f(17);
console.log(pair[0]); // 42
console.log(pair[1]); // 17

这个模式下arguments[0]接收的是实际传入的参数,我们得到结果17.

在Strict模式下,arguments.callee是被禁用的。通常来说arguments.callee指向的是当前执行的函数,这会阻止虚拟机对内联的优化,所以在Strict模式下是禁止的。

让javascript变得更加安全
在普通模式下,如果我们在一个函数f()中调用this,那么this指向的是全局对象。在strict模式下,这个this的值是undefined。

如果我们是通过call或者apply来调用的话,如果传入的是primitive value(基础类型),在普通模式下this会自动指向其box类(基础类型对应的Object类型,比如Boolean,Number等等)。如果传入的是undefined和null,那么this指向的是global Object。

而在strict模式下,this指向的是传入的值,并不会做转换或变形。

下面的值都是true:

‘use strict’;
function fun() { return this; }
console.assert(fun() === undefined);
console.assert(fun.call(2) === 2);
console.assert(fun.apply(null) === null);
console.assert(fun.call(undefined) === undefined);
console.assert(fun.bind(true)() === true);

为什么会安全呢?这就意味着,在strict模式下,不能通过this来指向window对象,从而保证程序的安全性。

另外,在普通模式下,我们可以通过fun.caller或者fun.arguments来获取到函数的调用者和参数,这有可能会访问到一些private属性或者不安全的变量,从而造成安全问题。

在strict模式下,fun.caller或者fun.arguments是禁止的。

function restricted() {
‘use strict’;
restricted.caller; // throws a TypeError
restricted.arguments; // throws a TypeError
}
function privilegedInvoker() {
return restricted();
}
privilegedInvoker();

保留关键字和function的位置
为了保证JS标准的后续发展,在strict模式中,不允许使用关键字作为变量名,这些关键字包括implements, interface, let, package, private, protected, public, static 和 yield等。

function package(protected) { // !!!
‘use strict’;
var implements; // !!!

interface: // !!!
while (true) {
break interface; // !!!
}

function private() { } // !!!
}
function fun(static) { ‘use strict’; } // !!!

而对于function来说,在普通模式下,function是可以在任何位置的,在strict模式下,function的定义只能在脚本的顶层或者function内部定义:

‘use strict’;
if (true) {
function f() { } // !!! syntax error
f();
}

for (var i = 0; i < 5; i++) {
function f2() { } // !!! syntax error
f2();
}

function baz() { // kosher
function eit() { } // also kosher
}

总结
Strict模式为JS的后续发展和现有编程模式的规范都起到了非常重要的作用。但是如果我们在浏览器端使用的话,还是需要注意浏览器的兼容性,并做好严格的测试。

浅谈分布式数据库

一 分布式数据库出现的场景:

1.单表数据量爆炸,>1000w,>1亿,>10亿,各种数据操作(CRUD)效率很低 。 关系型数据库在大于一定数据量的情况下检索性能会急剧下降。在面对互联网海量数据情况时,所有数据都存于一张表,显然会轻易超过数据库表可承受的数据量阀值。这个单表可承受的数据量阀值,需根据数据库和并发量的差异,通过实际测试获得。

2.单机数据库的瓶颈问题,处理不了高强度io。现代企业程序的瓶颈问题是数据库的瓶颈问题,所以数据库只做存储用,不再使用触发器,事物;

3.为了方便扩展,动态增加数据库节点,保证扩展性好

4.不同业务对应不同业务数据库,即使某个数据库挂了,不影响其他数据库对应的服务使用,服务高可用。

5.数据备份,数据*重要。

 

二 一些基本概念

单库:单机数据库 所有表存在一个库里,

分片(sharding),分片解决扩展性问题,属于水平拆分,引入分片,就引入了数据路由和分区键的概念。分表解决的是数据量过大的问题,分库解决的是数据库性能瓶颈的问题。

分组(group),分组解决可用性问题,分组通常通过主从复制(replication)的方式实现

互联网公司数据库实际软件架构是(大数据量下):又分片,又分组

单纯的分表虽然可以解决数据量过大导致检索变慢的问题,但无法解决过多并发请求访问同一个库,导致数据库响应变慢的问题。所以通常水平拆分都至少要采用分库的方式,用于一并解决大数据量和高并发的问题。这也是部分开源的分片数据库中间件只支持分库的原因。

​ 但分表也有不可替代的适用场景。*常见的分表需求是事务问题。同在一个库则不需考虑分布式事务,善于使用同库不同表可有效避免分布式事务带来的麻烦。目前强一致性的分布式事务由于性能问题,导致使用起来并不一定比不分库分表快,分局也无需要,大所述只需要保证事物的*终一致性。分表的另一个存在的理由是,过多的数据库实例不利于运维管理。

 

如何实现分库分表(后面去研究一致性raft算法)

​ 1) dao层,首先通过分区键算出库名表名(如shardKey%shardNum 算出来表index如y,然后y/(shardNum/sourceNum)=x,y是表下标,x是库下标)。
​ 2) 把source从spring容器中拿出来,把表名当参数传进去,拼成分片后的sql。
​ 3) 思路大概是(select … from order where … -> 先拿到db_x的source 然后 select … from order_y where …)

%title插图%num

Cobar介绍

Cobar是阿里巴巴(B2B)部门开发的一种关系型数据的分布式处理系统,它可以在分布式的环境下看上去像传统数据库一样为您提供海量数据服务。那么具体说说我们为什么要用它,或说cobar–能干什么?以下是我们业务运行中会存在的一些问题:
1.随着业务的进行数据库的数据量和访问量的剧增,需要对数据进行水平拆分来降低单库的压力,而且需要高效且相对透明的来屏蔽掉水平拆分的细节。
2.为提高访问的可用性,数据源需要备份。
3.数据源可用性的检测和failover。
4.前台的高并发造成后台数据库连接数过多,降低了性能,怎么解决。
针对以上问题就有了cobar施展自己的空间了,cobar中间件以proxy的形式位于前台应用和实际数据库之间,对前台的开放的接口是mysql通信协议。将前台SQL语句变更并按照数据分布规则转发到合适的后台数据分库,再合并返回结果,模拟单库下的数据库行为。

 

 

网上找到的关于cobar的一些不完美的地方:

Cobar不支持将一张表,例如test表拆分成test_1, test_2, test_3…..放在同一个库中,必须将拆分后的表分别放入不同的库来实现分布式。
1) 不支持跨库情况下的join、分页、排序、子查询操作。
2) SET语句执行会被忽略,事务和字符集设置除外。
3) 分库情况下,insert语句必须包含拆分字段列名。
4) 分库情况下,update语句不能更新拆分字段的值。
5) 不支持SAVEPOINT操作。
6) 暂时只支持MySQL数据节点。
7) 使用JDBC时,不支持rewriteBatchedStatements=true参数设置(默认为false)。
8) 使用JDBC时,不支持useServerPrepStmts=true参数设置(默认为false)。
9) 使用JDBC时,BLOB, BINARY, VARBINARY字段不能使用setBlob()或setBinaryStream()方法设置参数。

 

快速检测服务器漏洞

Shodan是互联网上*可怕的搜索引擎

CNNMoney的一篇文章写道,虽然目前人们都认为谷歌是*强劲的搜索引擎,但Shodan才是互联网上*可怕的搜索引擎。

与谷歌不同的是,Shodan不是在网上搜索网址,而是直接进入互联网的背后通道。Shodan可以说是一款“黑暗”谷歌,一刻不停的在寻找着所有和互联网关联的服务器、摄像头、打印机、路由器等等。每个月Shodan都会在大约5亿个服务器上日夜不停地搜集信息。

本文以百度www.baidu.com为例检测百度服务器的漏洞。

地址:https://www.shodan.io/

搜索形式建议采用ip地址这种形式

首先需要获取到百度的ip地址

cmd->ping www.baidu.com
%title插图%num

发现我本机访问的百度服务器IP地址为:61.135.169.125

下来我们将在https://www.shodan.io/搜索这个地址

%title插图%num

下面我们看看搜索结果

%title插图%num

搜索另一个网站,也可以使用域名,比如我们搜索淘宝www.taobao.com

可以发现淘宝在地球上面是有2000多台服务器的

%title插图%num

我来搜索一下自己的网站www.jqqhappy.club

ip地址为:39.105.165.135

%title插图%num

Python中的模块

Python基础之:Python中的模块

 

看动画学算法
以动画的方式,图文并茂讲解常用的算法和数据结构,包括各种排序算法、hash、栈、队列、链表、树、散列表、堆、图等,*对物有所值!
flydean程序那些事
¥39.90
订阅博主
文章目录
简介
模块基础
执行模块
模块搜索路径
dir

包的相对路径
简介
Python的解释环境是很好用,但是如果我们需要编写一个大型的程序的时候,解释环境就完全不够用了。这个时候我们需要将python程序保存在一个文件里。通常这个文件是以.py结尾的。

对于大型的应用程序来说,一个文件可能是不够的,这个时候我们需要在文件中引用其他的文件,这样文件就叫做模块。

模块是一个包含Python定义和语句的文件。文件名就是模块名后跟文件后缀 .py 。在模块内部,模块名可以通过全局变量 __name__ 获得。

模块基础
还是之前的斐波拉赫数列的例子,我们在fibo.py文件中存放了函数的实现:

def fib(n): # write Fibonacci series up to n
a, b = 0, 1
while a < n:
print(a, end=’ ‘)
a, b = b, a+b
print()

编写完毕之后,我们可以在Python的解释环境中导入它:

>>> import fibo
1
然后直接使用即可:

>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987

常用的函数,我们可以将其赋值给一个变量:

>>> fib = fibo.fib
>>> fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987

或者,我们在导入的时候,直接给这个模块起个名字:

>>> import fibo as fib
>>> fib.fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

或者导入模块中的函数:

>>> from fibo import fib as fibonacci
>>> fibonacci(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

每个模块都有它自己的私有符号表,该表用作模块中定义的所有函数的全局符号表。因此,模块的作者可以在模块内使用全局变量,而不必担心与用户的全局变量发生意外冲突。

执行模块
前面我们提到了可以使用import来导入一个模块,并且 __name__ 中保存的是模块的名字。

和java中的main方法一样,如果我们想要在模块中进行一些测试工作,有没有类似java中main方法的写法呢?

先看一个例子:

if __name__ == “__main__”:
import sys
fib(int(sys.argv[1]))

在模块中,我们需要进行一个判断 __name__ 是不是被赋值为 “__main__”。

我们这样来执行这个模块:

python fibo.py <arguments>

以脚本执行的情况下,模块的 __name__ 属性会被赋值为 __main__ , 这也是例子中为什么要这样写的原因。

看下执行效果:

$ python fibo.py 50
0 1 1 2 3 5 8 13 21 34

如果是以模块导入的话,那么将不会被执行:

>>> import fibo
>>>

模块搜索路径
使用import导入模块的时候,解释器首先会去找该名字的内置模块,如果没找到的话,解释器会从 sys.path变量给出的目录列表里寻找。

sys.path的初始目录包括:

当前目录
PYTHONPATH 指定的目录
安装的默认值
dir
要想查看模块中定义的内容,可以使用dir函数。

>>> a = [1, 2, 3, 4, 5]
>>> import fibo
>>> fib = fibo.fib
>>> dir()
[‘__builtins__’, ‘__name__’, ‘a’, ‘fib’, ‘fibo’, ‘sys’]

上面的例子列出了当前模块中定义的内容,包括变量,模块,函数等。

注意, dir() 不会列出内置函数和变量的名称。如果你想要这些,它们的定义是在标准模块 builtins 中。

我们可以给dir加上参数,来获取特定模块的内容:

>>> import builtins
>>> dir(builtins)
[‘ArithmeticError’, ‘AssertionError’, ‘AttributeError’, ‘BaseException’,
‘BlockingIOError’, ‘BrokenPipeError’, ‘BufferError’, ‘BytesWarning’,
‘ChildProcessError’, ‘ConnectionAbortedError’, ‘ConnectionError’,
‘ConnectionRefusedError’, ‘ConnectionResetError’, ‘DeprecationWarning’,
‘EOFError’, ‘Ellipsis’, ‘EnvironmentError’, ‘Exception’, ‘False’,
‘FileExistsError’, ‘FileNotFoundError’, ‘FloatingPointError’,
‘FutureWarning’, ‘GeneratorExit’, ‘IOError’, ‘ImportError’,
‘ImportWarning’, ‘IndentationError’, ‘IndexError’, ‘InterruptedError’,
‘IsADirectoryError’, ‘KeyError’, ‘KeyboardInterrupt’, ‘LookupError’,
‘MemoryError’, ‘NameError’, ‘None’, ‘NotADirectoryError’, ‘NotImplemented’,
‘NotImplementedError’, ‘OSError’, ‘OverflowError’,
‘PendingDeprecationWarning’, ‘PermissionError’, ‘ProcessLookupError’,
‘ReferenceError’, ‘ResourceWarning’, ‘RuntimeError’, ‘RuntimeWarning’,
‘StopIteration’, ‘SyntaxError’, ‘SyntaxWarning’, ‘SystemError’,
‘SystemExit’, ‘TabError’, ‘TimeoutError’, ‘True’, ‘TypeError’,
‘UnboundLocalError’, ‘UnicodeDecodeError’, ‘UnicodeEncodeError’,
‘UnicodeError’, ‘UnicodeTranslateError’, ‘UnicodeWarning’, ‘UserWarning’,
‘ValueError’, ‘Warning’, ‘ZeroDivisionError’, ‘_’, ‘__build_class__’,
‘__debug__’, ‘__doc__’, ‘__import__’, ‘__name__’, ‘__package__’, ‘abs’,
‘all’, ‘any’, ‘ascii’, ‘bin’, ‘bool’, ‘bytearray’, ‘bytes’, ‘callable’,
‘chr’, ‘classmethod’, ‘compile’, ‘complex’, ‘copyright’, ‘credits’,
‘delattr’, ‘dict’, ‘dir’, ‘divmod’, ‘enumerate’, ‘eval’, ‘exec’, ‘exit’,
‘filter’, ‘float’, ‘format’, ‘frozenset’, ‘getattr’, ‘globals’, ‘hasattr’,
‘hash’, ‘help’, ‘hex’, ‘id’, ‘input’, ‘int’, ‘isinstance’, ‘issubclass’,
‘iter’, ‘len’, ‘license’, ‘list’, ‘locals’, ‘map’, ‘max’, ‘memoryview’,
‘min’, ‘next’, ‘object’, ‘oct’, ‘open’, ‘ord’, ‘pow’, ‘print’, ‘property’,
‘quit’, ‘range’, ‘repr’, ‘reversed’, ’round’, ‘set’, ‘setattr’, ‘slice’,
‘sorted’, ‘staticmethod’, ‘str’, ‘sum’, ‘super’, ‘tuple’, ‘type’, ‘vars’,
‘zip’]


java中有package的概念,用来隔离程序代码。同样的在Python中也有包。

我们看一个Python中包的例子:

sound/ Top-level package
__init__.py Initialize the sound package
formats/ Subpackage for file format conversions
__init__.py
wavread.py
wavwrite.py
aiffread.py
aiffwrite.py
auread.py
auwrite.py

effects/ Subpackage for sound effects
__init__.py
echo.py
surround.py
reverse.py

filters/ Subpackage for filters
__init__.py
equalizer.py
vocoder.py
karaoke.py

上面我们定义了4个包,分别是sound,sound.formats, sound.effects, sound.filters。

注意,如果是包的话,里面一定要包含 __init__.py 文件。

__init__.py 可以是一个空文件,也可以执行包的初始化代码或设置 __all__ 变量。

当导入的时候, python就会在 sys.path 路径中搜索该包。

包的导入有很多种方式,我们可以导入单个模块:

import sound.effects.echo

但是这样导入之后,使用的时候必须加载全名:

sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)

如果不想加载全名,可以这样导入:

from sound.effects import echo

那么就可以这样使用了:

echo.echofilter(input, output, delay=0.7, atten=4)

还以直接导入模块中的方法:

from sound.effects.echo import echofilter

然后这样使用:

echofilter(input, output, delay=0.7, atten=4)

如果一个包里面的子包比较多,我们可能会希望使用 * 来一次性导入:

from sound.effects import *

那么如何去控制到底会导入effects的哪一个子包呢?

我们可以在 __init__.py 中定义一个名叫 __all__ 的列表,在这个列表中列出将要导出的子包名,如下所示:

__all__ = [“echo”, “surround”, “reverse”]

这样from sound.effects import * 将导入 sound 包的三个命名子模块。

如果没有定义 __all__,from sound.effects import * 语句 不会 从包 sound.effects 中导入所有子模块到当前命名空间;它只会导入包 sound.effects。

包的相对路径
Import 可以指定相对路径,我们使用 . 来表示当前包, 使用 … 来表示父包。

如下所示:

from . import echo
from .. import formats
from ..filters import equalizer

idea如何连接linux服务器进行操作

idea如何连接linux服务器进行操作

1.找到下方图片的位置

%title插图%num

2.然后输入主机用户名密码之类的信息需要密钥上传一下密钥之类的

%title插图%num

3.然后我们就可以进行愉快的操作了

%title插图%num

怎么保存服务器会话信息以及设置多个服务器会话信息

%title插图%num %title插图%num

OK

中国数据库告别卡脖子:阿里再刷新全球纪录,代码100%自研

中国自研OceanBase数据库,又刷新了世界纪录。

时隔七月,再次在TPC-C公开证明实力。

但这一次,不只是新晋霸主地位的巩固,也不止于打破业界尘封9年世界纪录后的新里程碑……

更是技术性能benchmark、底层基础自主研发,以及全球标准话语权的关键事件。

很多年后回溯起来,这还可能是两个时代的分水岭。

数据库操作系统芯片,科技产业和数字化经济中三大当之无愧的底座技术,之前无一项主动权掌握在中国手中。

现在,阿里巴巴、支付宝,十年之功、20万亿行代码之力——在数据库领域,打破全球纪录的7个月后,再次创造了新的标准线。

究竟是怎样的成就?

去年十一,我们就报道过,阿里自主研发的金融级分布式关系数据库OceanBase,在国际事务处理性能委员会(TPC)的TPC-C基准测试中登上榜首。

这一成绩还打破了由美国公司甲骨文(Oracle)保持了9年之久的世界记录,成为首个登顶该榜单的中国数据库产品。

中国工程院院士、计算机专家李国杰都盛赞说:“这是中国基础软件取得的重大突破。”

如今,7个月后,纪录再度被刷新。

%title插图%num

OceanBase不仅打破了去年自己保持的世界纪录,性能分数首次突破7.07亿,相比去年大幅提升近11倍。

而且这一次还是扩展能力的展现,在分布式架构下使用超过1500个节点的数据库集群,*终实现了整体性能的大幅提升——这在传统的集中式数据库是无法想象的。

更重要的是,在产业领域,分布式数据库解决了传统数据库几十年的难题,标志着数据库行业迎来了新一轮技术变革。

%title插图%num

%title插图%num

TPC-C,被誉为“数据库领域的世界杯”。

是全球主流计算机硬件厂商、数据库厂商公认的性能评价标准,其对数据库系统的软硬件协同能力要求*高。

也是全球目前*具公信力的联机交易处理(OLTP)数据库的功能与性能结合的测试标准,金融、电信、政府等关键领域的客户,一般参照 TPC-C 结果来衡量各个数据库厂商的事务处理能力。

更直接来说,TPC-C的测试就是数据库产品真实实力的*佳公开证明。

具体到测试本身,主要涵盖两大方向,分别是基本属性压力性能

在模拟真实交易环境并考察数据库基本性能的需求下,要求连续运行至少2小时,通过每分钟创建新订单数量来评价数据库的性能和性价比,规定测试任务需要在指定时间内完成,95%事务在1s内完成。

所以一款商业数据库想要向业界证明自身实力,TPC-C测试,*对是一项硬指标。

然而,TPC-C排行榜长期被甲骨文、IBM和微软等传统数据库和硬件厂商占据……

中国自研品牌的身影,从未出现过。

直到2019年9月,阿里一鸣惊人,打破甲骨文长达9年的霸榜垄断。

%title插图%num

然而当是时,虽然成绩超*名甲骨文纪录两倍有余,但外界依然有不少质疑的声音,且认为“蹭”了硬件红利。

于是这一次,时隔7个月再战——硬件基本无变化,要的就是技术架构和软件实力的证明。

所以也有外界评价说:「再无敌手,独孤求败」。

但参与此次“证明”的阿里工程师表示:这个评价听起来太狂了。

不过也认同,在数据库领域,技术架构的优越和*,确实短时间内是很难超越的。

阿里凭什么?

这一次,OceanBase在测试压力性能时被要求连续运行至少八小时,1500多个数据库节点以及5000多万个仓库与对应数量的客户端参与其中,过程中上下抖动情况不超过1%。

以*苛刻的方式,无压力通过了该测试,而且短时间内,别人再以同样标准通过测试,几无可能。

OceanBase总经理杨冰,阿里连续两次刷榜的带头人。

%title插图%num

他分享了OceanBase取胜的核心原因:

分布式整体系统可用性的技术创新。

即不用担心高额的软硬件投入来保障扩展性能所造成的杯水车薪,又可搞定节点故障无法使用主备镜像技术等问题。

以此为出发点,OceanBase大胆采用了Paxos分布式一致性协议,作为整个分布式数据库中*核心的技术之一。

OceanBase创始人阳振坤坦言,无论是主备库数据不一致还是分布式事务的技术缺陷,根本原因都在于关系型数据库自身软件高可用性的缺失,仅仅通过堆砌硬件红利来解决问题显然是治标不治本的做法;而OceanBase则是从数据库内部入手将问题解决。

当然,经过首次冲击TPC-C测试成功再到二次震撼TPC-C并满载而归,期间OceanBase技术团队也做了很多重要的优化升级工作。

例如提供兼容Oracle的租户模式并支持兼容PL/SQL的存储过程;实践分布式并行查询的新执行引擎帮助更好支持TPC-H这类场景测试,更快走向混合负载等。

关于兼容Oracle的工作难点,杨冰强调OceanBase团队的目标是打算用两年时间做到业务的平滑迁移,不需要修改一行代码,也不需要业务做任何调整,但过程中由于Oracle本身功能较多,先去突破哪些具体的内容确实是一种挑战。

%title插图%num

另外甲骨文一直以来都是一家技术能力强大的企业,对自身专利权限十分看重,未来在兼容工作进行过程中技术团队认为务必要基于自研数据库的属性对类似功能的加持保持慎重。

更重要的是,分析甲骨文单机数据库强大的技术功能后,OceanBase团队发现其混合负载是其重要的技术杀手锏,“未来在OceanBase分布式技术架构中实现此项功能的确算是一种不小的技术挑战。”

此外,对于OceanBase来说,公开挑战里的成功,只是日常实力的证明方式之一。

与诸多中国技术公司一样,业务场景才是*好的练兵场,而且中国业务场景下的挑战,可能比基准测试还要复杂多变得多。

或许你多少有了解,支付宝投身OceanBase获得成功,除了强大的专业技术人才投入之外,更重要的是阿里经济体与支付宝业务为代表的的互联网规模、金融级场景的复杂度,以及每年双十一大促时期的大型历练机会……

%title插图%num

这些都为其提供了天然的练兵场,因为只有经过丰富的业务场景考验才能证明数据库系统的通用性,“用出来”才是硬道理。

举个例子,在高效解决银行业务从传统Oracle迁移到OceanBase的有关问题时,由于实操经验丰富,团队早已面向开发者、运维人员等不同技术层面人群提供了完成与大数据链路同步以及异构数据库、同构数据库同步与迁移的诸多工具,例如OCP、OMS等。

现如今随着OceanBase在金融场景的商用化程度越发深入,创始人阳振坤表示,未来团队更想该产品代表下一代分布式数据库的技术趋势前沿与发展方向,在除金融行业以外的多个领域。

例如交通、铁路与航天等也都陆续出现OceanBase的身影,夯实金融场景技术创新之余大力推进商用化进程,逐渐成长位至关重要的通用性技术。

包括如今面貌一新的国民应用,目前背后底座就是OceanBase。

所以可以想见,随着TPC-C的再次实力证明,会有更多公司、业务、场景和领域,用上全球*且中国自研的OceanBase数据库。

在波诡云谲的大环境中,不必再担心任何形式的断供。

%title插图%num

十年磨一剑

但即便如此,OceanBase一路走来,也并非轻而易举。

现在看到的是全球瞩目,之前却有十年的风雨兼程。

OceanBase创始人阳振坤回忆,当时完全是凭借技术灵感,认定传统集中式数据库,总会有尽头。

“我虽然不是做数据库的,但长期的分布式经验让我觉得像Oracle那种单机数据库总会有个尽头。毕竟业务数据量没几个月就要翻一翻,分布式*对是个机会。”

于是当年6月25日,OceanBase正式立项。

又一年,OceanBase 0.1版本正式发布,在淘宝收藏夹上线,成功帮助淘宝收藏夹业务的数据库服务器数量大幅度减少。

2013年,支付宝开始启动“去 IOE”,即去掉了Oracle数据库、IBM小型机和EMC存储。

2014年支付宝交易库上线,OceanBase产品真正带到金融核心业务。

2017年*个外部用户南京银行也正式上线OceanBase。

%title插图%num

再到去年9月,一战成名,打破垄断。

但更重要的是今年3月,OceanBase宣布正式通过阿里云向全球开放,实现更广泛的高可用、高性能、低成本服务。

而筚路蓝缕的研发之路中,一度因为困难重重、中途因为找不到愿意使用的业务,OceanBase团队还曾经濒临解散。

如今春风化雨,一切尽付笑谈中。

更重要的是,曾经因为数据库技术垄断,甲骨文创始人拉里·埃里森,让中国合作方在零下二十多度的凛冽环境中苦等2小时的傲慢往事,或许再也不会有了。

现在,我们不仅有了国产自研OceanBase数据库可供选择,而且OceanBase,也是*好的选择。

接下来,就看操作系统和芯片的了。

 

友情链接: SITEMAP | 旋风加速器官网 | 旋风软件中心 | textarea | 黑洞加速器 | jiaohess | 老王加速器 | 烧饼哥加速器 | 小蓝鸟 | tiktok加速器 | 旋风加速度器 | 旋风加速 | quickq加速器 | 飞驰加速器 | 飞鸟加速器 | 狗急加速器 | hammer加速器 | trafficace | 原子加速器 | 葫芦加速器 | 麦旋风 | 油管加速器 | anycastly | INS加速器 | INS加速器免费版 | 免费vqn加速外网 | 旋风加速器 | 快橙加速器 | 啊哈加速器 | 迷雾通 | 优途加速器 | 海外播 | 坚果加速器 | 海外vqn加速 | 蘑菇加速器 | 毛豆加速器 | 接码平台 | 接码S | 西柚加速器 | 快柠檬加速器 | 黑洞加速 | falemon | 快橙加速器 | anycast加速器 | ibaidu | moneytreeblog | 坚果加速器 | 派币加速器 | 飞鸟加速器 | 毛豆APP | PIKPAK | 安卓vqn免费 | 一元机场加速器 | 一元机场 | 老王加速器 | 黑洞加速器 | 白石山 | 小牛加速器 | 黑洞加速 | 迷雾通官网 | 迷雾通 | 迷雾通加速器 | 十大免费加速神器 | 猎豹加速器 | 蚂蚁加速器 | 坚果加速器 | 黑洞加速 | 银河加速器 | 猎豹加速器 | 海鸥加速器 | 芒果加速器 | 小牛加速器 | 极光加速器 | 黑洞加速 | movabletype中文网 | 猎豹加速器官网 | 烧饼哥加速器官网 | 旋风加速器度器 | 哔咔漫画 | PicACG | 雷霆加速