前提条件

• 安装Scala,找到Other ways to install Scala，选择Download the Scala binaries for windows，因为我是Windows 10环境，安装scala-2.12.8.msi
• 安装有Anaconda
• 安装有Atom,Atom中安装了Hydrogen插件

步骤

安装scala kernel

在电脑硬盘根目录创建文件夹almond,比如我的是G:\almond，进入文件夹。

按住shift单击鼠标右键，选择在此处打开Powershell窗口。

在命令行中依次执行如下命令

1
2
3
4
5
6
7
8
9

set SCALA_VERSION=2.12.8
set ALMOND_VERSION=0.4.0
　　　
bitsadmin /transfer downloadCoursierCli https://git.io/coursier-cli "%cd%\coursier"
bitsadmin /transfer downloadCoursierBat https://git.io/coursier-bat "%cd%\coursier.bat"
　　　
.\coursier bootstrap -r jitpack -i user -I user:sh.almond:scala-kernel-api_%SCALA_VERSION%:%ALMOND_VERSION% sh.almond:scala-kernel_%SCALA_VERSION%:%ALMOND_VERSION% -o almond
　　　
.\almond --install

上述命令会在文件夹中下载这样几个文件：

1
2
3
4

almond
almond.bat
coursier
coursier.bat

最后提示scala-kernel成功就可以。

打开Anaconda Prompt,输入jupyter kernelspec list，看到已经出现scala内核了。

1
2
3
4
5

(base) C:\Users\Administrator>jupyter kernelspec list
Available kernels:
  scala       C:\Users\Administrator\AppData\Roaming\jupyter\kernels\scala
  python3     E:\ProgramData\Anaconda3\share\jupyter\kernels\python3
  anaconda    C:\ProgramData\jupyter\kernels\anaconda

安装language-scala

Atom中，进入设置界面，在安装插件界面中搜索scala，选择安装language-scala.

运行代码

创建scala为扩展名的文件，在每一行代码上按shift+回车键执行代码，可以看到代码后面有运行结果了。

如果打开Jupyter Notebook,可以看到新建中出现Scala选项。

在Notebook中就可以像写Python一样进行交互运行代码了。

如果使用nteract,也是可以执行的，类Jupyter notebook编辑器桌面版nteract

参考

https://almond.sh/docs/quick-start-install

本例用到的组件：生成随机数，增加常量，计算器，过滤记录，分组，记录关联，Excel输出。

实现功能

随机生成100个随机数，随机数取值于[0，100）之间，计算小于等于50的随机数个数和大于50的随机数个数。并把这两个统计数字放在数据库表的一行的两列中，即输出的结果有一行，一行包括两列，每列是一个统计值。

步骤

我使用的PDI版本为7.1.

新建转换

打开PDI中的Spoon.bat进入转换设计器。文件->新建->转换新建空白的抓换任务。Ctrl+s先保存名为test.ktr的文件。

生成随机数

步骤->输入中拖入生成随机数组件，双击组件，添加一行，名称为rand_num，类型为随机数字。

在组件上右键，选择改变开始复制的数量，因为生成100个随机数，所以输入100，但是没看到确定之类的按钮(坑爹)，直接回车就可以了。之后在组件左上角出现x100的标志。

增加常量

步骤->转换中拖入增加常量组件，双击组件，增加两个常量。multi值设置为100，因为生成的随机数是0-1范围的，后面会将随机数x100得到一个0-100的随机整数。standard设置为50，我们将随机数分开计数是以50为分界点。

鼠标放在随机数组件上，按住Shift键，按下鼠标左键拉出一根连线到增加常量组件上。

计算器

步骤->转换中拖入计算器组件，双击组件，增加一个新字段，计算方式为A * B，分别用生成的随机数乘上multi值。

分组记录

步骤->流程中拖入过滤记录组件，步骤->统计中拖入两个分组组件，过滤记录连接到分组上，连接的时候回弹出Result is true和Result is false选项。

双击过滤记录组件，添加条件。

双击设置第一个分组，计算大于等于50的个数。

双击设置第二个分组，计算小于50的个数。

结果输出

步骤->连接中拖入记录关联(笛卡尔输出)组件，因为我们直接将分组结果放在一行输出，直接笛卡尔连接即可。

步骤->输出中拖入Excel输出组件，记录关联组件指向Excel输出。双击Excel输出组件，文件名中设置为${output_dir}/result,其中，${output_dir}是个变量，稍后设置。result是输出文件名。

字段页中可以获取要输出的字段，也可以不设置，默认输出所有字段。

Spoon设计器中编辑->设置环境变量，会出现我们在Excel中用到的变量，值设置为../mywork,因为默认的输出目录是Spoon.bat所在目录，我们在上层目录中新建一个mywork文件夹。

再拖入一个Excel输出组件，从计算器组件指向该组件，添加连线时会弹出选项，选择复制。这步的目的是将计算器计算出的结果保存一个。

双击该组件，文件名中设置为${output_dir}/data.

运行

至此，所有步骤已完成。

点击上部按钮中第一个运行这个转换，弹出执行转换对话框，直接点击启动，可以看到下部面板中的运行日志，运行完成后查看结果Excel中已经输出相应结果。

时间相关概念

epoch

假设我们要将时间表示成毫秒数，比方说1000000毫秒，那有一个问题必须解决，这个1000000毫秒的起点是什么时间，也就是我们的时间基准点是什么时间？好比我说你身高1.8米，那这个身高是指相对于你站立的地面说的。这个时间基准点就是epoch，在Unix系统中，这个基准点就是1970年1月1日0点整那个时间点。

GMT, UTC

上面我们说epoch表示1970年的起始点，那这个1970年又是相对于哪个基准时间呢？一般来说，就是相对于格林尼治时间，也叫做GMT(Greenwich Mean Time)时间，还叫做UTC(Coordinated Universal Time)，为啥一个时间基准有两个名字？历史上，先有的GMT,后有的UTC.UTC是我们现在用的时间标准，GMT是老的时间计量标准。UTC是根据原子钟来计算时间，而GMT是根据地球的自转和公转来计算时间。所以，可以认为UTC是真正的基准时间，GMT相对UTC的偏差为0。在实际中，我们的计算机中有一个硬件模块RCT，里面会实时记录UTC 时间，该模块有单独的电池供电，即使关机也不影响。有了epoch这个时间基准，又有了UTC这个基准的基准，我们就可以精确地表示一个时间了。

DST, tzoneDST, tzone

尽管我们已经可以精确地表示一个时间，很多情况下，我们还是要根据地区实际情况对时间进行一个调整，最常见的就是时区，tzone，相信大家都比较熟悉。此时，当我们说5点5分这个时间时，还需加上是哪个时区的5点5分才能精确说明一个时间。另外一个对时间做出调整的就是DST.DST 全称是Daylight Saving Time，是说，为了充分利用日光，减少用电，人为地对时间做出一个调整，这取决于不同国家和地区的政策法规。比如说，假设你冬天7点天亮起床，但夏天6点天亮，那么在夏天到来时人为将时间加1个小时，这样就可以让你还是觉得7点起床，但实际上是提前一个小时了。

time模块

获取时间

time()方法获取当前时间距离epoch的秒数，用的是UTC时间，这个函数没有参数。

1
2
3

import time
t = time.time()
#结果：1553614051.5006864

时间转换

将上面的秒数转换为年月日时分秒的形式，可以用time. gmtime()，time.localtime()方法。两个函数返回的都是struct_time类的实例。

1
2
3
4
5

time.gmtime()
#结果：time.struct_time(tm_year=2019, tm_mon=3, tm_mday=26, tm_hour=15, tm_min=35, tm_sec=9, tm_wday=1, tm_yday=85, tm_isdst=0)
#
time.localtime()
#结果：time.struct_time(tm_year=2019, tm_mon=3, tm_mday=26, tm_hour=23, tm_min=37, tm_sec=15, tm_wday=1, tm_yday=85, tm_isdst=0)

如果要将上述元组形式的时间转换成秒数，可以用time.mktime()方法。

1
2
3

now_struct = time.localtime()
time.mktime(now_struct)
#结果：1553615106.0

将时间的元组转换为字符串形式，可以用time.strftime(),将特定格式的时间转成时间元组格式用time.strptime()方法。

1
2
3
4
5
6

time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) 
time.strftime("%Y-%m-%d %H:%M:%S") #等效，默认是当前时间
#结果：'2019-03-26 23:52:32'
#
time.strptime('2019-03-26 11:56:21','%Y-%m-%d %H:%M:%S')
#结果：time.struct_time(tm_year=2019, tm_mon=3, tm_mday=26, tm_hour=11, tm_min=56, tm_sec=21, tm_wday=1, tm_yday=85, tm_isdst=-1)

time.asctime()、time.ctime()方法则会将时间转换为标准24字符的字符串，前者参数是时间元组，后者参数是秒数。

1
2
3
4
5
6

now_struct = time.localtime()
time.asctime(now_struct)
#结果：'Wed Mar 27 00:03:07 2019'
#
time.ctime(time.time())
#结果：'Wed Mar 27 00:03:07 2019'

下图可以比较清楚的描述时间秒数、时间元组、字符串之间的转换关系。

datetime模块

time模块解决了时间的获取和表示，datetime模块则进一步解决了快速获取并操作时间中的年月日时分秒信息的能力。
简单说，该模块核心的类就三个，date类表示年月日，time类表示时分秒毫秒，这里不要和time模块搞混淆了。请记住一点，date中是没有时区信息的。

对象创建

常用datetime.today()、datetime.now()方法创建当前时区的对象。datetime.fromtimestamp()方法接收秒数参数。如果要获得utc的datetime对象，使用datetime. utcfromtimestamp()、datetime. utcnow()方法。

1
2
3
4
5
6
7
8
9
10

import datetime
#
datetime.datetime.fromtimestamp(time.time())
#
datetime.datetime.today()
datetime.datetime.now()
#结果：datetime.datetime(2019, 3, 27, 0, 9, 18, 312810)

datetime.datetime. utcnow()
#结果：datetime.datetime(2019, 3, 26, 16, 12, 22, 71628)

以特定格式字符串创建，使用datetime.strptime()方法。给定时间元组也可以创建datetime对象。

1
2
3
4
5

datetime.datetime.strptime('2015-6-1 18:19:59','%Y-%m-%d %H:%M:%S')
#结果：datetime.datetime(2015, 6, 1, 18, 19, 59)
#
datetime.datetime(2015, 4, 19, 12, 20)
#结果：datetime.datetime(2015, 4, 19, 12, 20)

格式转换

datetime对象转换为时间戳。

1
2
3

dt = datetime.datetime.now()
dt.timestamp()
#结果：1553617278.690061

datetime对象转换为字符串。

1
2
3

dt = datetime.datetime.now()
datetime.datetime.strftime(dt,'%Y-%m-%d %H:%M:%S')
#结果：'2019-03-27 00:24:01'

datetime对象转换为time时间元组。

1
2
3

dt = datetime.datetime.now()
time.localtime(dt.timestamp())
#结果：time.struct_time(tm_year=2019, tm_mon=3, tm_mday=27, tm_hour=0, tm_min=28, tm_sec=51, tm_wday=2, tm_yday=86, tm_isdst=0)

日期计算

基于某日期，向前或向后计算某段时间后的日期。

1
2
3
4
5

dt = datetime.datetime.now() #当前日期
dt = datetime.datetime.now()
dt - datetime.timedelta(days=1) #当前日期向前减一天
dt + datetime.timedelta(days=1) #当前日期向后加一天
dt + datetime.timedelta(days=11,hours=3,minutes=20) #当前日期向后推11天3小时20分

计算两个日期的时间差

1
2
3
4
5

start = datetime.datetime.strptime('2015-6-1 18:19:59','%Y-%m-%d %H:%M:%S')
end = datetime.datetime.now()
dlt = end-start
dlt.days #相差天数
dlt.seconds #相差秒数

以下函数实现计算自从某一时间到当前时间经过了多少年，多少天，多少秒。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

def cal_time_past(start_time = '2016-08-12 05:10:45'):
    now_str = time.strftime("%Y-%m-%d %H:%M:%S") #当前时间字符串
    now_obj = datetime.datetime.now() #当前时间datetime对象
    years_end = now_str[:4]+start_time[4:] #开始时间年份替换为当年
    if now_str >= years_end:
        ynum = int(years_end[:4])-int(start_time[0:4]) #过了几个整年
    else:
        ynum = int(years_end[:4])-int(start_time[0:4])-1 #最后不满一年
        years_end = str(int(years_end[:4])-1)+years_end[4:]
    years_end_obj = datetime.datetime.strptime(years_end,'%Y-%m-%d %H:%M:%S')
    delta = now_obj-years_end_obj
    dnum = delta.days #去掉整年后过去的天数 
    hnum = int(delta.seconds/3600) #过去的小时数
    mnum = int((delta.seconds-3600*hnum)/60) #过去的分钟数
    snum = delta.seconds-3600*hnum-60*mnum #过去的描述
    print("%d年%d天%d小时%d分%d秒" % (ynum,dnum,hnum,mnum,snum))
#
cal_time_past('1990-04-18 04:18:00')
#结果：28年342天20小时38分21秒

参考

• https://www.jianshu.com/p/a035a564b248

创建字典方法

{} 方式

1
2

dict1 = {} #创建空字典
dict2 = {'a':11,'b':12} #创建含有值得字典

dict()函数 方式

1
2
3
4
5
6
7
8

dict3 = dict() #创建空字典
dict4 = dict(a='11',b='ddd',c='ssss') #创建含有值的字典，注意键值如果加引号会报错
#dict5 = dict('a'='11',b='ddd',c='ssss') # SyntaxError: keyword can't be an expression

keys = ['a','b','c','d','e']
values = [1,2,3,4]
dict6 = dict(zip(keys,values)) #键或值的列表元素个数不必相同，以少的为准
# {'a': 1, 'b': 2, 'c': 3, 'd': 4}

字典排序

1
2

import operator
test = {'a':1,'c':2,'b':7,'f':5}

根据键排序

sorted() 方式

1
2

print(sorted(test.items())) #升序
print(sorted(test.items(),reverse=True)) #降序

sorted + operator 方式

1
2

print(sorted(test.items(),key=operator.itemgetter(0))) #升序
print(sorted(test.items(),key=operator.itemgetter(0),reverse=True)) #降序

sorted + lambda 方式

1
2

print(sorted(test.items(),key=lambda x : x[0])) #升序
print(sorted(test.items(),key=lambda x : x[0],reverse=True)) #降序

根据值排序

sorted + operator 方式

1
2

print(sorted(test.items(),key=operator.itemgetter(1))) #升序
print(sorted(test.items(),key=operator.itemgetter(1),reverse=True)) #降序

sorted + lambda 方式

1
2

print(sorted(test.items(),key=lambda x : x[1])) #升序
print(sorted(test.items(),key=lambda x : x[1],reverse=True)) #降序

** 注意，如果值的数据类型不一样，以上根据值排序会报错，例如一下字典，值有int和str类型,lambda中要进行类型转换 **

1
2
3

test2 = {'a':1,'c':2,'b':7,'f':'5'}
print(sorted(test2.items(),key=lambda x : str(x[1]))) #升序
#输出 [('a', 1), ('c', 2), ('f', '5'), ('b', 7)]

字典合并

update方法

1
2
3
4

dictA = {'a':3,'b':7,'c':'2'}
dictB = {'d':12,'f':'44'}
dictA.update(dictB)
print(dictA) #输出 {'a': 3, 'b': 7, 'c': '2', 'd': 12, 'f': '44'}

**方法

** 高版本python中可用 **

1
2

dictC = {**dictA,**dictB}
print(dictC) #输出 {'a': 3, 'b': 7, 'c': '2', 'd': 12, 'f': '44'}

• 作者：oscicen
• 使用技术：HTML / CSS / JavaScript
• 依赖库：-
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 响应式：否
• 源码链接：https://codepen.io/oscicen/pen/zyJeJw

• 作者：Guilmain Dorian
• 使用技术：HTML (Pug) / CSS (Less) / JavaScript
• 依赖库：-
• 浏览器兼容：Chrome, Edge, Firefox (partial), Opera, Safari
• 响应式：否
• 源码链接：https://codepen.io/Craaftx/pen/yQGpwa

• 作者：Adrian Payne
• 使用技术：HTML / CSS (SCSS) / JavaScript (Babel)
• 依赖库：-
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 响应式：是
• 源码链接：https://codepen.io/dazulu/pen/VVZrQv

• 作者：Alex O’Neal
• 使用技术：HTML / CSS
• 依赖库：-
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 响应式：是
• 源码链接：https://codepen.io/alexoneal/pen/OBqaoe

• 作者：Sil van Diepen
• 使用技术：HTML (Pug) / CSS (SCSS)
• 依赖库：-
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 响应式：是
• 源码链接：https://codepen.io/silvandiepen/full/NOboze

• 作者：Yago Estévez
• 使用技术：HTML (Pug) / CSS
• 依赖库：-
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 响应式：是
• 源码链接：https://codepen.io/yagoestevez/full/EdgRMX

• 作者：jakob-e
• 使用技术：HTML / CSS (SCSS) / JavaScript
• 依赖库：
• 浏览器兼容：Chrome, Firefox, Opera, Safari
• 响应式：是
• 源码链接：https://codepen.io/jakob-e/pen/ELqeRM

• 作者：Casey Callis
• 使用技术：HTML / CSS / JavaScript
• 依赖库：jquery.js, parallax.js
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 响应式：是
• 源码链接：https://codepen.io/caseycallis/full/pwEWxo

• 作者：Ravi Dhiman
• 使用技术：HTML (Pug) / CSS (SCSS)
• 依赖库：-
• 浏览器兼容：Chrome, Firefox, Opera, Safari
• 响应式：是
• 源码链接：https://codepen.io/ravid7000/pen/LREEzv

有这样一个软件似乎可以：nteract，这个软件我理解为桌面版的Jupyter notebook，下面是nteract的官网.

软件安装

官网上可以下载安装文件，支持跨平台，有windows,linux,mac版本，免费的。软件安装好后，启动进入，界面比较简洁。

可以看到，系统中.ipynb格式的文件打开方式变成了nteract，直接双击文件就能打开进行编辑，保存，跟在Jupyter notebook一样。

执行代码

软件安装前确保本机有Python执行环境，推荐安装Anaconda，nteract需要连接Jupyter内核才能执行代码，如果已安装有Anaconda，打开nteract后可以看到左下角连接的Jupyter内核名称。

如果需要切换python虚拟环境，就需要安装多个python内核，如何安装参考Atom编辑器中使用Hydrogen切换Python虚拟环境，安装好后在nteract中切换方法如下

和在Jupyter notebook一样，执行单元格的代码可用Shift+Enter等快捷键，或者单元格靠右侧有个执行程序的小按钮。

敲代码时可以看到是支持代码自动提示与补全的。

终止代码执行

如果不小心写了死循环或者想临时终止代码的运行，可以在Runtime菜单下进行操作。

Markdown和Code切换

单元格右侧下拉菜单中可以切换单元格内容是Markdown文本还是代码，如果是MD文本，双击单元格即可显示原始内容。其他单元格操作及相关快捷键看下Edit或者Cell菜单就明白了。

暗色主题

软件可以切换亮色与暗色主题。

小问题

如果是直接启动软件，第一次保存文件按Ctrl+s保存会报错，得用另存为。

总结

相比于Jupyter notebook，nteract显得简洁很多，平时开发作为替代也是可以的。单元格操作上，nteract没有Jupyter notebook那么丰富。Jupyter notebook可以额外安装插件进行功能扩展，虽然nteract也可以安装插件，官网上有介绍，但功能似乎没那么强大。

extend方法

该方法可以扩展数组，会改变原始数组。

1
2
3
4
5
6
7
8

a = [1,2,3,4,7,5,6]
b = ['a','b']
c = ['h',12,'c']
a.extend(b)
a.extend(c)
print(a)

#结果：[1, 2, 3, 4, 7, 5, 6, 'a', 'b', 'h', 12, 'c']

直接相加

用+将各数组连接起来。

1
2
3
4
5
6
7
8

a = [1,2,3,4,7,5,6]
b = ['a','b']
c = ['h',12,'c']

d = a + b +c
print(d)

#结果：[1, 2, 3, 4, 7, 5, 6, 'a', 'b', 'h', 12, 'c']

flatten方法

flatten()方法是numpy中array数组的方法，使用时要导入包和类型转换。

1
2
3
4
5
6
7
8
9
10

from numpy import array

a = [1,2,3]
b = ['a','b','c']
c = ['h',12,'k']
e = [a,b,c]
e = array(e)
print(e.flatten())

#结果：['1' '2' '3' 'a' 'b' 'c' 'h' '12' 'k']

值得注意的是该方法不适用各数组中元素个数不同的情况。

1
2
3
4
5
6
7
8

a = [1,2,3,4]  #元素个数不同
b = ['a','b','c']
c = ['h',12,'k']
e = [a,b,c]
e = array(e)
print(e.flatten())

#结果：[list([1, 2, 3, 4]) list(['a', 'b', 'c']) list(['h', 12, 'k'])]

列表表达式

使用前得把多个数组放在一个数组中，应用在一个二维数组上。

1
2
3
4
5
6
7
8

a = [1,2,3,4] 
b = ['a','b','c']
c = ['h',12,'k']
e = [a,b,c]
e = [y for x in e for y in x]
print(e)

结果：[1, 2, 3, 4, 'a', 'b', 'c', 'h', 12, 'k']

解决方式是设置Python Executable Paths

进入Atom设置Packages,找到该插件，进入Settings

在Python Executable Paths中设置python的执行路径，因为本机是安装的Anaconda，环境变量中没有python执行路径。

重启Atom后就可以了。

环境

配置前先确认电脑上安装了Anaconda,代码编辑器Atom,Atom中安装了Hydrogen插件.

开始菜单中打开Anaconda Prompt命令行窗口。

查看当前可用的kernel

jupyter kernelspec list

1
2
3
4

(base) C:\Windows\system32>jupyter kernelspec list
Available kernels:
  python3    C:\Users\cxuan\AppData\Roaming\jupyter\kernels\python3
  venv       C:\ProgramData\jupyter\kernels\venv

默认只有第一个，第二个是后加的，在Atom中运行Python启动kernel默认只有第一个。

创建python虚拟环境

python -m venv E:\PythonProject\test\pyvenv

创建后文件夹下出现这些文件目录

安装python内核

激活新的虚拟环境

E:\PythonProject\test\pyvenv\Scripts\activate

安装python kernel (ipykernel)到虚拟环境里

python -m pip install ipykernel

安装python kernel到可用的kernel列表中,--name是自定义名称参数。

python -m ipykernel install --name pyvenv

重启Atom编辑器，启动python内核时多出了一个选项，就是刚刚我们配置的虚拟环境内核。

删除python内核

删除python keernel

remove后指定要删除的kernel名称

jupyter kernelspec remove pyvenv

参考

https://nteract.io/kernels

• 作者：John Mantas
• 使用技术：HTML / CSS (SCSS)
• 是否自适应：否
• 依赖库：-
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/john-mantas/full/bxmrBq

• 作者：George Gedox
• 使用技术：HTML / CSS (SCSS)
• 是否自适应：否
• 依赖库：font-awesome.css
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/GeorgeGedox/pen/yEwoqP

• 作者：Julie Park
• 使用技术：HTML / CSS (SCSS)
• 是否自适应：否
• 依赖库：-
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/juliepark/pen/aKbYVp

• 作者：Fatih Takey
• 使用技术：HTML / CSS
• 是否自适应：否
• 依赖库：font-awesome.css
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/fatihtakey/pen/eyyWVr

• 作者：Omar Dsoky
• 使用技术：HTML / CSS
• 是否自适应：否
• 依赖库：font-awesome.css
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/linux/pen/LjWrPZ

• 作者：SliceCrowd
• 使用技术：HTML / CSS
• 是否自适应：否
• 依赖库：bootstrap.css, swiper.css
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/slicecrowd/pen/GWJEZB

• 作者：Tobi Balogun
• 使用技术：HTML / CSS
• 是否自适应：否
• 依赖库：ionicons.css, animate.css
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/cupofmint/pen/wgyrRX

• 作者：CodeFrog
• 使用技术：HTML / CSS
• 是否自适应：否
• 依赖库：font-awesome.css
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/CodeFrogShow/pen/rWjYrP

• 作者：Oscar
• 使用技术：HTML / CSS (SCSS) / JavaScript
• 是否自适应：否
• 依赖库：jquery.js
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/olhilton/pen/dXaqxE

• 作者：Alexandra K
• 使用技术：HTML / CSS
• 是否自适应：否
• 依赖库：-
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/ff0004-red/pen/WxJEJZ

• 作者：Jacob Sauerhoefer
• 使用技术：HTML / CSS (SCSS)
• 是否自适应：否
• 依赖库：-
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/jacobsauerhoefer/pen/mVZwLB

• 作者：Nicholas Gratton
• 使用技术：HTML / CSS
• 依赖库：-
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/ngratton/pen/MZKJvr

• 作者：Jhey
• 使用技术：HTML (Pug) / CSS (Stylus)
• 依赖库：-
• 浏览器兼容：Chrome, Firefox, Opera, Safari
• 源码链接：https://codepen.io/jh3y/full/WyNdMG

• 作者：Danny
• 使用技术：HTML (Haml) / CSS (SCSS)
• 依赖库：-
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/edanny/full/JXwgdK

• 作者：Jaron White
• 使用技术：HTML / CSS
• 依赖库：-
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/jaronwhite/full/zrmozE

• 作者：Adib Behjat
• 使用技术：HTML / CSS
• 依赖库：-
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/abehjat/full/oXMENv

• 作者：Jér?me Beau
• 使用技术：HTML / CSS (SCSS)
• 依赖库：-
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/Javarome/pen/ogEoJM

• 作者：Lucas Bebber
• 使用技术：HTML / CSS (SCSS)
• 依赖库：-
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/lbebber/full/xrwja

直接上代码

这里以Postgresql数据库为例，Mysql数据库差不多，其他的自行改造。

先封装一个查询类，查询返回的结果是一个字典，head是表列名,data是表数据，再用DataFrame构造数据结构。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

import psycopg2
import pandas as pd

class db_pg:
    def __init__(self, host, db, user, pwd, port):
        self.host = host
        self.db = db
        self.user = user
        self.pwd = pwd
        self.port = port
        self._conn = self._connect()
        self._cursor = self._conn.cursor()


    def _connect(self):
        return psycopg2.connect(
            database=self.db,
            user=self.user,
            password=self.pwd,
            host=self.host,
            port=self.port)


    def select(self, sqlCode):
        self.common(sqlCode)
        col_names = []
        result = {}
        column_count = len(self._cursor.description)
        for i in range(column_count):
            desc = self._cursor.description[i]
            col_names.append(desc[0])
        data = self._cursor.fetchall()
        result['head'] = col_names
        result['data'] = data
        return result


    def close(self):
        self._cursor.close()
        self._conn.close()


    def common(self, sqlCode):
        try:
            self._cursor.execute(sqlCode)
        except Exception as e:
            print(e)
            self._conn.rollback()
            self._cursor.execute(sqlCode)
        self._conn.commit()


    def __del__(self):
        self.close()


db_conn = {
        'host': "******",
        'db'  : "******",
        'user': "******",
        'pwd' :"******",
        'port': "******"
    }
pg_conn = db_pg(host=db_conn['host'],db=db_conn['db'],user=db_conn['user'],pwd=db_conn['pwd'],port=db_conn['port'])
rs            = pg_conn.select("select * from test")
rs_df       = pd.DataFrame(list(rs.get('data')),columns=rs.get('head'))

运行示例

问题是这样的

例如我有以上的两个图，节点b的前置节点是a,节点c的前置节点是b和d，以此类推。给出一个节点，需要找出以此节点为前置节点的所有链条节点。比如给出a，那出来的结果就是a,b,c,d,e,给出f,那出来的结果就是f,g,h,i,j,k。

数据准备

创建表以及插入数据，多个前置节点用,隔开，注意，使用的是PostgreSQL数据库。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

-- ----------------------------
-- Table structure for mytest
-- ----------------------------
DROP TABLE IF EXISTS "public"."mytest";
CREATE TABLE "public"."mytest" (
"node" varchar(256) COLLATE "default",
"pre_nodes" varchar(10240) COLLATE "default"
);

-- ----------------------------
-- Records of mytest
-- ----------------------------
INSERT INTO "public"."mytest" VALUES ('a', null);
INSERT INTO "public"."mytest" VALUES ('b', 'a');
INSERT INTO "public"."mytest" VALUES ('c', 'b,d');
INSERT INTO "public"."mytest" VALUES ('d', 'b');
INSERT INTO "public"."mytest" VALUES ('e', 'c');
INSERT INTO "public"."mytest" VALUES ('f', null);
INSERT INTO "public"."mytest" VALUES ('g', 'f');
INSERT INTO "public"."mytest" VALUES ('h', 'g');
INSERT INTO "public"."mytest" VALUES ('i', 'g');
INSERT INTO "public"."mytest" VALUES ('j', 'g');
INSERT INTO "public"."mytest" VALUES ('k', 'h,i,j');

SQL创建

方法有多种，用函数或者存储过程也可以，这里使用WITH递归，相关信息可以百度:postgresql 递归。第一个select语句中要给出起始节点。

1
2
3
4
5
6

WITH RECURSIVE graph_depds AS (
  SELECT node,pre_nodes FROM mytest a WHERE node = 'f'
  UNION ALL
  SELECT a.node,a.pre_nodes FROM mytest a, graph_depds b WHERE strpos(a.pre_nodes, b.node) > 0
)
SELECT DISTINCT node,pre_nodes FROM graph_depds ORDER BY node;

如果想向前查找呢

上面的查找相当于找出一个节点所有影响到的节点，其实就是向下递归，如果给出一个节点，想从这个节点往前追溯有关的节点呢？例如给出c节点，结果是a,b,c,d,其实就是向上递归，可以像下面这样写。

1
2
3
4
5
6

WITH RECURSIVE graph_depds AS (
  SELECT node,pre_nodes FROM mytest a WHERE node = 'i'
  UNION ALL
  SELECT a.node,a.pre_nodes FROM mytest a, graph_depds b WHERE strpos(b.pre_nodes,a.node) > 0
)
SELECT DISTINCT node,pre_nodes FROM graph_depds ORDER BY node;

其他数据库

如果像Sql Server等支持WITH语法的数据，以上写法可以移植，稍作修改就好。但是mysql等数据库中的实现方式不一样，百度mysql 递归相关的内容都能找到方法。

启动Falsk服务后信息如下，

1
2
3
4
5
6
7
8
9

* Serving Flask app "app" (lazy loading)
* Environment: production
  WARNING: Do not use the development server in a production environment.
  Use a production WSGI server instead.
* Debug mode: on
* Restarting with stat
* Debugger is active!
* Debugger PIN: 228-080-042
* Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

除本机外是不能访问的，需要在run参数中设置,端口自定，主机为0.0.0.0

1

app.run(host='0.0.0.0', port=5000)

再次启动后就可以了。

1
2
3
4
5
6
7
8
9

* Serving Flask app "app" (lazy loading)
* Environment: production
  WARNING: Do not use the development server in a production environment.
  Use a production WSGI server instead.
* Debug mode: on
* Restarting with stat
* Debugger is active!
* Debugger PIN: 228-080-042
* Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)

atom-aligner是干什么的呢，就是用来对齐的，比如我们写这样一段变量赋值的程序：

1
2
3
4

var_a =1 #我是变量1
b = [1,2,3,4]#我是变量2
cccc=(1,2,3)#注释
ddddddd='rrrrrrrr'#又一个注释

虽然也没问题，但是如果能按=对齐就更强迫症一些。安装插件后，选中要对齐的行，按快捷键:
Mac: ctrl-cmd-/ Linux/Windows: ctrl-alt-/
就会变为这样

1
2
3
4

var_a   = 1         #我是变量1
b       = [1,2,3,4] #我是变量2
cccc    = (1,2,3)   #注释
ddddddd = 'rrrrrrrr'#又一个注释

需要注意是，只安装一个atom-aligner插件是不够的，得配合不同语言的另一些插件，比如我写python代码，得另外装一个aligner-python插件才可以。

如果是JSON格式的对象，也是可以按冒号:对齐的

1
2
3
4

obj = {'aaa': 11,
    'bbb': 'terdff',
  'ccc': 123111,
    'array': [1,2,3,4]}

要注意的是，如果连同=,{}一起选中，按快捷键对齐是不起作用的，得写成这样：

1
2
3
4
5
6

obj = {
  'aaa': 11,
    'bbb': 'terdff',
  'ccc': 123111,
    'array': [1,2,3,4]
}

对齐后是这样的

1
2
3
4
5
6

obj = {
 'aaa':      11,
    'bbb':   'terdff',
  'ccc':     123111,
    'array': [1,2,3,4]
    }

所以:左边是不会对齐的，我们在编辑器写代码的时候一般都会左对齐了，像这样

1
2
3
4
5
6

obj = {
    'aaa':   11,
    'bbb':   'terdff',
    'ccc':   123111,
    'array': [1,2,3,4]
    }

有个问题是，官方的说明里说是可以冒号对齐的，对齐成这样

1
2
3
4
5
6

obj = {
    'aaa'  : 11,
    'bbb'  : 'terdff',
    'ccc'  : 123111,
    'array': [1,2,3,4]
    }

插件设置中没有找到相关设置，官方说明看了半天也没找到怎么设置，最后无奈改了插件的源码。

进入插件设置

找到插件包配置，修改默认为left

重启编辑器就可以了。

• 作者：Chalda Pnuzig
• 使用技术：HTML (Pug) / CSS (SCSS)
• 依赖库：-
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/chalda/pen/wRJYmz

• 作者：Jamie Coulter
• 使用技术：HTML / CSS (SCSS)
• 依赖库：-
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/jcoulterdesign/pen/yGgxOY

• 作者：Ivan Grozdic
• 使用技术：HTML / CSS / JavaScript
• 依赖库：bootstrap.css, jquery.js, popper.js, bootstrap.js
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/ig_design/pen/NeRxzj

• 作者：Jon Kantner
• 使用技术：HTML (Pug) / CSS (SCSS)
• 依赖库：-
• 浏览器兼容：Chrome, Firefox, Opera, Safari
• 源码链接：https://codepen.io/jkantner/pen/gKRKKb

• 作者：Yusuke Nakaya
• 使用技术：HTML (Pug) / CSS (SCSS)
• 依赖库：-
• 浏览器兼容：Chrome, Firefox, Opera, Safari
• 源码链接：https://codepen.io/YusukeNakaya/pen/vJKwZw

• 作者：Satrio Yamanda
• 使用技术：HTML / CSS
• 依赖库：-
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/yamanda/pen/RpNMaY

• 作者：Tahina
• 使用技术：HTML / CSS
• 依赖库：-
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/tahina/pen/WRXNwQ

• 作者：Zed Dash
• 使用技术：HTML / CSS (SCSS)
• 依赖库：-
• 浏览器兼容：Chrome, Firefox, Opera, Safari
• 源码链接：https://codepen.io/z-/pen/JXVpgp

• 作者：Deepak K Vijayan
• 使用技术：HTML (Haml) / CSS (SCSS)
• 依赖库：-
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/BrianBravo/pen/JaFfz

403 Forbidden
Access to this resource on the server is denied!
Powered By LiteSpeed Web Server
LiteSpeed Technologies is not responsible for administration and contents of this web site!

403状态码

403错误是网站访问过程中，常见的错误提示。资源不可用，服务器理解客户的请求，但拒绝处理它。通常由于服务器上文件或目录的权限设置导致，比如IIS或者apache设置了访问权限不当。

下面看一些有意思的403页面设计，撇开实不实用，能看见几回等等等，，，专注于设计。

• 作者：Mansoour
• 使用技术：HTML / CSS
• 依赖库：-
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/Mansoour/pen/LgGGvm

• 作者：lsgrrd
• 使用技术：HTML / CSS (SCSS)
• 依赖库：-
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/lsgrrd/pen/BObbYY

• 作者：ycw
• 使用技术：HTML (Pug) / CSS (Less)
• 依赖库：-
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/ycw/pen/BObmJr

• 作者：Aimie | Blissful Lemon
• 使用技术：HTML / CSS
• 依赖库：-
• 浏览器兼容：Chrome, Firefox, Opera, Safari
• 源码链接：https://codepen.io/ablissfullemon/pen/zJepap

• 作者：Sean B
• 使用技术：HTML / CSS (SCSS) / JavaScript
• 依赖库：-
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/Chesswithsean/pen/ZMwagQ

• 作者：Blessing Oni
• 使用技术：HTML / CSS (SCSS)
• 依赖库：-
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/blecaf/pen/EervOE

• 作者：Arturo Wibawa
• 使用技术：HTML / CSS (SCSS)
• 依赖库：-
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/artcoholic/pen/ZMVNMw

• 作者：Leena Lavanya
• 使用技术：HTML / CSS / JavaScript
• 依赖库：-
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/leenalavanya/pen/RYqvgK

• 作者：Cassidy Williams
• 使用技术：HTML (Haml) / CSS (Less)
• 依赖库：-
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/cassidoo/pen/rZQQrj

• 作者：creme
• 使用技术：HTML / CSS (SCSS) / JavaScript
• 依赖库：jquery.js, tweenmax.js
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/creme/pen/VGVpbJ

• 作者：Mariana
• 使用技术：HTML / CSS / JavaScript
• 依赖库：-
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/marianab/pen/EedpEb

• 作者：A van Hagen
• 使用技术：HTML / CSS (SCSS)
• 依赖库：-
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/anjanas_dh/pen/ZMqKwb

• 作者：Nuuou
• 使用技术：HTML / CSS (SCSS) / JavaScript (Babel)
• 依赖库：bootstrap-reboot.css, tweenmax.js
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/Nuuou/pen/GXYmJv

• 作者：Andrew Hani
• 使用技术：HTML / CSS / JavaScript
• 依赖库：jquery.js
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/androhani/pen/deOpMZ

• 作者：Saleh Riaz Qureshi
• 使用技术：HTML / CSS / JavaScript
• 依赖库：-
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/salehriaz/pen/erJrZM

• 作者：Vincent Van Goggles
• 使用技术：HTML / CSS (SCSS)
• 依赖库：-
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/Gogh/pen/eeReMO

• 作者：Selcuk Cura
• 使用技术：HTML / CSS (SCSS) / JavaScript
• 依赖库：jquery.js, tweenmax.js, splittext.js
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/selcukcura/pen/XeQpEv

• 作者：Robin Selmer
• 使用技术：HTML / CSS (SCSS)
• 依赖库：-
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/robinselmer/pen/vJjbOZ

• 作者：Clement Girault
• 使用技术：HTML / CSS / JavaScript
• 依赖库：jquery.js
• 浏览器兼容：Chrome, Firefox, Opera, Safari
• 源码链接：https://codepen.io/clementGir/pen/PqGyMq

• 作者：john
• 使用技术：HTML / CSS (Less) / JavaScript
• 依赖库：-
• 浏览器兼容：Chrome, Firefox, Opera, Safari
• 源码链接：https://codepen.io/thejohnyagiz/pen/npDyq

• 作者：gavra
• 使用技术：HTML / CSS / JavaScript
• 依赖库：jquery.js
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/gavra/pen/upHzg

• 作者：Ian Gloude
• 使用技术：HTML / CSS (SCSS)
• 依赖库：-
• 浏览器兼容：Chrome, Edge, Firefox, Opera, Safari
• 源码链接：https://codepen.io/igloude/pen/qNNWKr

闭包

闭包指延伸了作用域的函数，其中包含函数定义体中引用、但是不在定义体中定义的非全局变量。函数是不是匿名的没有关系，关键是它能访问定义体之外定义的非全局变量。

举个栗子

1
2
3
4
5
6
7
8
9
10
11
12
13
14

def make_averager():
    series = []
    
    def averager(new_value):
        series.append(new_value)
        total = sum(series)
        return total/len(series)
    
    return averager

avg = make_averager()
avg(10) # 10.0
avg(13) # 11.5
avg(19) # 14.0

上面定义了一个嵌套函数，作用是计算移动平均值。
调用make_averager时，返回一个averager函数对象。每次调用averager时，会把一个新的参数值添加到列表中，然后计算列表的平均值。series是make_averager函数的局部变量，但是调用avg(10)时，make_averager()函数已经返回了，所以它的本地作用域也没有了。

在averager()函数中，series变成了自由变量，就是没在本地作用域中绑定的变量。

所以闭包是一种函数，它会保留定义函数时存在的自由变量的绑定，在调用函数时，虽然定义作用域不可用了但是还可以使用绑定的变量。注意，只有嵌套在其他函数中的函数才可能需要处理不在全局作用域中的外部变量

栗子改进

虽然上面函数可以实现计算移动平均，但是效率不高，因为把所有历史数据都保留在列表中。如果只存储总和以及元素个数，再求平均值更好些。

1
2
3
4
5
6
7
8
9
10

def make_averager():
    count = 0
    total = 0
    
    def averager(new_value):
        count += 1
        total += new_value
        return total / count
    
    return averager

上述函数在调用averager()时是有问题的，原因是count初始定义是数字，是不可变类型。在执行count = count + 1 时，count变成了局部变量，不是自由变量，所以解析器认为count在averager()里没有定义。total变量也是这样的问题。

问题显然出现在变量是否是可变类型上，在用列表计算的时候，采用的series是可变的列表类型。但是对于数字、字符串、元祖等不可变类型，嵌套函数内只能读取，不能更新，如果尝试重新绑定，比如count = count + 1,就会隐式创建局部变量，不会成为自由变量保存在闭包里。

python3下解决方式是引入nonlocal声明。作用就是把变量标记为自由变量。

1
2
3
4
5
6
7
8
9
10
11

def make_averager():
    count = 0
    total = 0
    
    def averager(new_value):
        nonlocal count,total
        count += 1
        total += new_value
        return total / count
    
    return averager

总结

在函数内嵌套的函数如果引用了外层函数定义的变量，外部调用嵌套的函数时，可以认为这时候函数变量的作用域延伸了，存在自由变量。主意自由变量如果是不可变类型，需要使用nonlocal声明。那么闭包有什么用呢？如果要了解Python装饰器，或许会有所帮助。

参考Luciano Ramalho-《Fluent Python》

1
2
3

>[Error] Script lines: 1-1 --------------------------
 Error while compiling statement: FAILED: ParseException line 1:19 
 cannot recognize input near 'agent' ';' '<EOF>' in from source

Aqua Data Studio简介

Aqua Data Studio是一套完整IDE的数据库开发工具，拥有数据库查询、管理、比对和源码控制等功能，可用于创建、编辑和执行SQL的管理工具脚本编写，以及浏览和修改数据库内容，支持大多数常见的数据库，如Oracle，MySQL，MSSQL，Vertica，Hadoop，Impala等，为所有数据库提供了一个统一界面的平台，让使用者或开发者在一个应用程序中能同时处理多个任务。

使用环境

• Aqua Data Studio 18.0.18
• JDK 1.8
• Windows 7

解决

问题解决比较简单，菜单File->Options,在弹出的设置窗口总的搜索里搜索Hive,结果中的Scripts下的Apache Hive里面，勾选;Statement Separator即可。

其实如果不设置这个选项，默认情况下如何在查询窗口执行多条语句而不报错呢？每条语句用GO隔开就可以了，例如：

1
2
3

select * from tb1
go
select * from tb2

DbVisualizer 也是一个不错的工具，可以试用下。