资讯专栏INFORMATION COLUMN

上云采购季！| 2核2G4M爆款云服务器低至59元/年，更有多台、长期优惠，快来选购！

立即前往
首页/文章专栏/8. Q语言学习之路—表

8. Q语言学习之路—表

syoya / 1858人阅读

摘要：其中代表了列的类型，表示了是否存在任何外键。事实上，语言会自动地识别满足表形式的列字典，在没有任何请求询问下，将其转换为表形式。结果显示的结果永远是一个表。被用来合并两个具有相同列的键表。属性表明对所有出现的值，相同的值都是互相邻近的。

0. 概述

表(Tables)和列表、字典一样，都是q语言中的第一类对象(First-class entity)

Q表是*列导向的*

Q表是从字典构建的

1.表的定义

1. 表作为列字典

</>复制代码 
  1. q)dc:`name`iq!(`Dent`Beeblebrox`Prefect;98 42 126)
  2. q)dc[`iq;]
  3. 98 42 126
  4. q)dc[;2]
  5. name| `Prefect
  6. iq | 126
  7. q)dc[`iq; 2]
  8. 126

我们通过flip指令来得到一个表

</>复制代码 
  1. q)t:flip `name`iq!(`Dent`Beeblebrox`Prefect;98 42 126)
  2. q)t[;`iq]
  3. 98 42 126
  4. q)t[2;]
  5. name| `Prefect
  6. iq  | 126
  7. q)t[2;`iq]
  8. 126

所有表的类型都是98h。

类似于python的pandas包，可以通过t[`column]或者t.column来获取一个列。但请注意，点操作符在函数内不起作用。

</>复制代码 
  1. q)t[`name`iq]
  2. Dent Beeblebrox Prefect
  3. 98   42         126

2. 表的显示

</>复制代码 
  1. q)dc
  2. name| Dent Beeblebrox Prefect
  3. iq  | 98   42         126
  4. q)t
  5. name       iq 
  6. --------------
  7. Dent       98 
  8. Beeblebrox 42 
  9. Prefect    126

3. 表定义语法
定义语法为([] c1:L1;...;cn:Ln)
其中ci是列名，Li是对应的列值。其中的冒号不是必须的。

</>复制代码 
  1. q)t:([] name:`Dent`Beeblebrox`Prefect; iq:98 42 126)
  2. q)t~flip `name`iq!(`Dent`Beeblebrox`Prefect;98 42 126)
  3. 1b

表定义中也可以直接使用变量，这样对应的列名就是变量名了

</>复制代码 
  1. q)c1:`Dent`Beeblebrox`Prefect
  2. q)c2:98 42 126
  3. q)([] c1; c2)
  4. c1         c2
  5. --------------
  6. Dent       98
  7. Beeblebrox 42
  8. Prefect    126

atom元素会自动拓展到列长度

</>复制代码 
  1. q)([] c1:`a`b`c; c2:42; c3:98.6)
  2. c1 c2 c3  
  3. ----------
  4. a  42 98.6
  5. b  42 98.6
  6. c  42 98.6

4. 表的元数据
可以通过cols指令来获取表的列；可以通过meta来获取表的元数据，结果是一个键表(keyed-table)。

</>复制代码 
  1. q)meta t
  2. c   | t f a
  3. ----| -----
  4. name| s    
  5. iq  | j

其中t代表了列的类型，f表示了是否存在任何外键。

指令tables返回当前命名空间下的表名, a效果相同：

</>复制代码 
  1. q)t2:([] c1:1 2 3; c2:(1 2; enlist 3; 4 5 6))
  2. q)t:([] name:`Dent`Beeblebrox`Prefect; iq:98 42 126)
  3. q)tables `.
  4. `t`t2

5. 记录
表在逻辑上是一个字典记录(record)的列表，count返回记录的个数。

</>复制代码 
  1. q)count t
  2. 3

为了获取表中的不带列名的行，可以使用value函数

</>复制代码 
  1. q)value t[1]
  2. `Beeblebrox
  3. 42

6. 转置的列字典 vs 记录的列表
逻辑上，表既可以是转置的列字典(Flipped column dictionary)，也可以是记录的列表(list of records)，但是物理上它被储存为列字典。事实上，Q语言会自动地识别满足表形式的列字典，在没有任何请求询问下，将其转换为表形式。
例如下两例：

</>复制代码 
  1. q)type (`name`iq!(`Dent;98); `nome`iq!(`Beeblebrox;42))
  2. 0h
</>复制代码 
  1. q)type (`name`iq!(`Dent;98); `name`iq!(`Beeblebrox;42))
  2. 98h

表被储存为列形式的一个坏处是，当想要删除掉表中的一行时，花销非常大。

</>复制代码 
  1. The best way to deal with this in large tables is not to do it.

与其删除一行，不如用一个表示flag的column来表示该行有没有被删除。

2. 空表和模式

创建一般空表的方式：

</>复制代码 
  1. q)([] name:(); iq:())

推荐的做法是给每列指定类型

</>复制代码 
  1. q)([] name:`symbol$(); iq:`int$())

一种等价的创建带类型的表的方法：

</>复制代码 
  1. q)([] name:0#`; iq:0#0)
  2. q)([] name:0#`; iq:0#0)~ ([] name:`symbol$(); iq:`int$())
  3. 1b

3. 基本的select和update操作
下面以这个表的操作为例

</>复制代码 
  1. q)t:([] name:`Dent`Beeblebrox`Prefect; iq:98 42 126)

1. select的语法
基本语法为：

</>复制代码 
  1. select cols from table

取全部列直接省略掉cols即可，不用加*。

2. 结果显示
select的结果永远是一个表。

</>复制代码 
  1. q)select from t
  2. name       iq 
  3. --------------
  4. Dent       98 
  5. Beeblebrox 42 
  6. Prefect    126

3. 选择列

</>复制代码 
  1. q)select name from t
  2. name
  3. ----------
  4. Dent
  5. Beeblebrox
  6. Prefect
  7. q)select c1:name, c2:iq from t

4. 基本的update
update的语法与select的语法基本相同，其使用冒号右边的值来取代该列。

</>复制代码 
  1. q)update iq:iq%100 from t
  2. name       iq
  3. ---------------
  4. Dent       0.98
  5. Beeblebrox 0.42
  6. Prefect    1.26
4. 主键和键表

在SQL中，可以声明一个或多个列作为主键，主键的值是unique的，使得通过主键的值来提取行成为可能。

1. 键表
定义：A keyed table is a dictionary mapping a table of key records to a table of value records.

一个键表并不是一个表——它是一个字典，所以类型是99h。

2. 简单的例子
值的表(table of value)：

</>复制代码 
  1. q)v:flip `name`iq!(`Dent`Beeblebrox`Prefect;98 42 126)

键的表(table of key)：

</>复制代码 
  1. q)k:flip (enlist `eid)!enlist 1001 1002 1003

创建键表：

</>复制代码 
  1. q)kt:k!v
  2. q)kt
  3. eid | name       iq 
  4. ----| --------------
  5. 1001| Dent       98 
  6. 1002| Beeblebrox 42 
  7. 1003| Prefect    126

3. 键表的定义语法
下面是通过字典形式对键表定义的常规语法：

</>复制代码 
  1. q)kt:(flip (enlist `eid)!enlist 1001 1002 1003)! flip `name`iq!(`Dent`Beeblebrox`Prefect;98 42 126)
  2. q)kt
  3. eid | name       iq
  4. ----| --------------
  5. 1001| Dent       98
  6. 1002| Beeblebrox 42
  7. 1003| Prefect    126

直接使用表定义语法将更为简单：

</>复制代码 
  1. q)kt:([eid:1001 1002 1003] name:`Dent`BeebleBrox`Prefect; iq:98 42 126)

带类型的空键表的定义形式如下：

</>复制代码 
  1. q)ktempty:([eid:`int$()] `symbol$name:(); iq:`int$())
  2. q)ktempty
  3. eid| name iq
  4. ---| -------
  5. q)ktempty:([eid:0#0] name:0#`;iq:0#0)

4. 获取键表的记录
因为键表本质上是一个字典映射，所以可以通过键值对记录进行查找。注意键和值都对应的是字典。

</>复制代码 
  1. q)kt[(enlist `eid)!enlist 1002]
  2. name| `Beeblebrox
  3. iq  | 42

上例可以简化为：

</>复制代码 
  1. q)kt[1002]
  2. name| `Beeblebrox
  3. iq  | 42

我们可以获取某个列的值

</>复制代码 
  1. q)kt[1002][`iq]
  2. 42
  3. q)kt[1002;`iq]
  4. 42

5. 取多行的记录 

</>复制代码 
  1. q)kt[1001]
  2. name| `Dent
  3. iq  | 98
  4. q)kt 1001
  5. name| `Dent
  6. iq  | 98

为了取多行的数据，通过如下的方式去取是错误的

</>复制代码 
  1. q)kt[1001 1002]
  2. "length

正确的方式是：

</>复制代码 
  1. q)kt[(enlist 1001;enlist 1002)]
  2. name       iq
  3. -------------
  4. Dent       98
  5. Beeblebrox 42
  6. q)kt[flip enlist 1001 1002]

也可以通过构建一个匿名的表来取值

</>复制代码 
  1. q)kt ([] eid:1001 1002)
  2. name       iq
  3. -------------
  4. Dent       98
  5. Beeblebrox 42

回想第5.2.2节指出的，可以通过命令#来提取一个子字典，对于键表同理：

</>复制代码 
  1. q)([] eid:1001 1002)#kt
  2. eid | name       iq
  3. ----| -------------
  4. 1001| Dent       98
  5. 1002| Beeblebrox 42

6. 反向查找
由于键表是一个字典，所以我们通过值来反响查找键。

</>复制代码 
  1. q)kts:([eid:1001 1002 1003] name:`Dent`Beeblebrox`Prefect)
  2. q)kts
  3. eid | name
  4. ----| ----------
  5. 1001| Dent
  6. 1002| Beeblebrox
  7. 1003| Prefect

反向查找：

</>复制代码 
  1. q)kts?([] name:`Prefect`Dent)
  2. eid
  3. ----
  4. 1003
  5. 1001

7. 键表的成分
可以通过key和value来提取键表成分

</>复制代码 
  1. q)key kt
  2. eid
  3. ----
  4. 1001
  5. 1002
  6. 1003
  7. q)value kt
  8. name       iq
  9. --------------
  10. Dent       98
  11. Beeblebrox 42
  12. Prefect    126

函数keys和cols返回键表的键名和列名。

8. 表和键表
通过xkey来设置一列为键

</>复制代码 
  1. q)t:([] eid:1001 1002 1003; name:`Dent`Beeblebrox`Prefect; iq:98 42 126)
  2. q)`eid xkey t
  3. eid | name       iq 
  4. ----| --------------
  5. 1001| Dent       98 
  6. 1002| Beeblebrox 42 
  7. 1003| Prefect    126

在xkey左运算元设置为空列表时转换为常规表

</>复制代码 
  1. q)kt:([eid:1001 1002 1003] name:`Dent`Beeblebrox`Prefect; iq:98 42 126)
  2. q)() xkey kt
  3. eid  name       iq 
  4. -------------------
  5. 1001 Dent       98 
  6. 1002 Beeblebrox 42 
  7. 1003 Prefect    126

也可以使用!的又一重载用法：左运算元为一个非负的数字，代表左侧将包含在键中的列数；右运算元为表或者键表。0代表没有键。

</>复制代码 
  1. q)1!t
  2. q)0!kt
  3. eid  name       iq 
  4. -------------------
  5. 1001 Dent       98 
  6. 1002 Beeblebrox 42 
  7. 1003 Prefect    126
  8. q)2!0!kt
  9. eid  name      | iq
  10. ---------------| ---
  11. 1001 Dent      | 98
  12. 1002 Beeblebrox| 42
  13. 1003 Prefect   | 126

上述返回的结果都是在表的拷贝上进行的，如果要对表进行in-place的操作，则需要使用call-by-name

</>复制代码 
  1. q)`eid xkey `t
  2. `t
  3. q)() xkey `kt
  4. `kt
  5. q)kt
  6. eid  name       iq 
  7. -------------------
  8. 1001 Dent       98 
  9. 1002 Beeblebrox 42 
  10. 1003 Prefect    126

9. 复合的主键 

</>复制代码 
  1. q)ktc:([lname:`Dent`Beeblebrox`Prefect; fname:`Arthur`Zaphod`Ford]; iq:98 42 126)
  2. q)ktc
  3. lname      fname | iq 
  4. -----------------| ---
  5. Dent       Arthur| 98 
  6. Beeblebrox Zaphod| 42 
  7. Prefect    Ford  | 126

复合主键的查找可以通过一个复合的键：

</>复制代码 
  1. q)ktc[`lname`fname!`Beeblebrox`Zaphod]
  2. iq| 42

对于一个简单的键，我们可以简化查找：

</>复制代码 
  1. q)ktc[`Dent`Arthur]
  2. iq| 98

空的多键值表的创建：

</>复制代码 
  1. q)ktc:([lname:`symbol$();fname:`symbol$()] iq:`int$())
  2. q)ktc:([lname:0#`;fname:0#`] iq:0#0)

10. 提取复合键
可以通过复合键的列表来提取对应的记录

</>复制代码 
  1. q)ktc (`Dent`Arthur;`Prefect`Ford)
  2. iq
  3. ---
  4. 98
  5. 126

当然也可以通过匿名表来提取

</>复制代码 
  1. q)ktc ([] lname:`Dent`Prefect; fname:`Arthur`Ford)

当然也可以用#来提取子字典

</>复制代码 
  1. q)K:([] lname:`Dent`Prefect; fname:`Arthur`Ford)
  2. q)K#ktc
  3. lname   fname | iq 
  4. --------------| ---
  5. Dent    Arthur| 98 
  6. Prefect Ford  | 126

11. 提取列数据
在这一小节中我们使用如下两个例子：

</>复制代码 
  1. q)kts:([k:101 102 103] v1:`a`b`c; v2:1.1 2.2 3.3)
  2. q)kts
  3. _
  4. q)ktc:([k1:`a`b`c;k2:`x`y`z] v1:`a`b`c; v2:1.1 2.2 3.3)
  5. q)ktc
  6. _

提取特定列的做法：

</>复制代码 
  1. q)kts[([] k:101 103)][`v1]
  2. `a`c
  3. q)ktc[([] k1:`a`c;k2:`x`z)][`v1`v2]

也可以使用index at depth的做法

</>复制代码 
  1. q)kts[([] k:101 103); `v1]
  2. _
  3. q)ktc[([] k1:`a`c;k2:`x`z); `v1`v2]
  4. _
5. 外键和虚拟列

外键是指表中的一列，该列的数据都在另一个表中的主键中。
1. 外键的定义
定义：A foreign key is one or more table columns whose values are defined as an enumeration over the key column(s) of a keyed table.

2， 外键的例子
以下表为例

</>复制代码 
  1. q)kt:([eid:1001 1002 1003] name:`Dent`Beeblebrox`Prefect; iq:98 42 126)

以eid列为外键的表定义如下，这里用到了枚举，强制保证了该列出现的值都在另一个表的键值中

</>复制代码 
  1. q)tdetails:([] eid:`kt$1003 1001 1002 1001 1002 1001; sc:126 36 92 39 98 42)

在meta命令中，可以看到外键出现在f列中：

</>复制代码 
  1. q)meta tdetails
  2. c  | t f  a
  3. ---| ------
  4. eid| j kt  
  5. sc | j

内置函数fkeys返回一个表示外键的字典

</>复制代码 
  1. q)fkeys tdetails
  2. eid| kt

3. 清除外键

当想清楚一个外键时，对枚举的列使用value函数

</>复制代码 
  1. q)meta update value eid from tdetails
  2. c  | t f a
  3. ---| -----
  4. eid| j    
  5. sc | j

4. 外键和关系
设tf是一个带有键表kt外键f的表，为了获取kt中的某一列c，可以直接在select语句中直接使用点操作符f.c即可。

</>复制代码 
  1. q)select eid.name, sc from tdetails
  2. name       sc 
  3. --------------
  4. Prefect    126
  5. Dent       36 
  6. Beeblebrox 92 
  7. Dent       39 
  8. Beeblebrox 98 
  9. Dent       42
6. 使用表和键表

在这一节中，我们使用如下例子

</>复制代码 
  1. q)t:([] name:`Dent`Beeblebrox`Prefect; iq:98 42 126)
  2. q)kt:([eid:1001 1002 1003] name:`Dent`Beeblebrox`Prefect; iq:98 42 126)

1. Append记录
使用,:，带列名时可以不同考虑顺序

</>复制代码 
  1. q)t,:`name`iq!(`W; 26)
  2. q)t,:`iq`name!(200; `Albert)
  3. q)t
  4. name       iq
  5. --------------
  6. Dent       98
  7. Beeblebrox 42
  8. Prefect    126
  9. Albert     200

不带列名时必须考虑顺序

</>复制代码 
  1. q)t,:(`H; 142)
  2. _
  3. q)t,:(97;`J)
  4. "type
  5. q)t
  6. _

2. First和Last记录
使用函数first和last

</>复制代码 
  1. q)first t
  2. name| `Dent
  3. iq  | 98
  4. q)last t
  5. name| `Albert
  6. iq  | 200

使用#获取前后几行记录

</>复制代码 
  1. q)2#t
  2. q)-3#kt

3. Find
find操作符?返回记录的索引

</>复制代码 
  1. q)t?`name`iq!(`Dent;98)
  2. 0

上式可简化为

</>复制代码 
  1. q)t?(`Dent;98)
  2. 0

也可以查多列

</>复制代码 
  1. q)t?((`Dent;98);(`Prefect;126))
  2. 0 2

由于键表是一个字典，所以使用?相当于执行了反向查找，返回对应的键值

</>复制代码 
  1. q)kt?`name`iq!(`Dent;98)
  2. eid| 1001
  3. q)kt?(`Dent;98)
  4. eid| 1001

单个列的查找必须生成列值，或者使用匿名表的结构

</>复制代码 
  1. q)t1:([] eid:1001 1002 1003)
  2. q)t1?enlist each 1001 1002
  3. 0 1
  4. q)t1?([] eid:1001 1002)
  5. 0 1

4. Union with,
使用join操作符,追加记录到一个表中，但是不会执行类型检查。

</>复制代码 
  1. q)t,`name`iq!(`Slaartibartfast; `123)
  2. name            iq  
  3. --------------------
  4. Dent            98  
  5. Beeblebrox      42  
  6. Prefect         126 
  7. Slaartibartfast `123

只有表有完全一样的meta结果时，两个表才能合并成一个表。

</>复制代码 
  1. q)t,([] name:1#`W; iq:1#26)
  2. q)t,t

当键表使用,合并两个meta结果相同的键表时，右边的键表将upsert(update and insert)左边的键表，不同的键将append，相同的键将update。

</>复制代码 
  1. q)kt,([eid:1003 1004] name:`Prefect`W; iq:150 26)
  2. eid | name       iq 
  3. ----| --------------
  4. 1001| Dent       98 
  5. 1002| Beeblebrox 42 
  6. 1003| Prefect    150
  7. 1004| W          26

5. Coalesce ^
Coalesce^被用来合并两个具有相同列的键表。^的效果与,的相同，除了这种情况：两个键表相同键合并时，右边的键表若为null，则左边的保留下来。

</>复制代码 
  1. q)([k:`a`b`c] v:10 0N 30)^([k:`a`b`c] v:100 200 0N)
  2. k| v
  3. -| ---
  4. a| 100
  5. b| 200
  6. c| 30
  7. q)([k:`a`b`c`x] v:10 0N 30 40)^([k:`a`b`c`y]; v:100 200 0N 0N)
  8. k| v
  9. -| ---
  10. a| 100
  11. b| 200
  12. c| 30
  13. x| 40
  14. y|

^的执行效率没有,的高，因为右运算元需要检查是否为null。

6. 列 Join
两个具有相同数量记录的表可以使用join-each(,")来合并列。

</>复制代码 
  1. q)([] c1:`a`b`c),"([] c2:100 200 300)
  2. c1 c2 
  3. ------
  4. a  100
  5. b  200
  6. c  300

在键表上的列join：

</>复制代码 
  1. q)([k:1 2 3] v1:10 20 30),"([k:3 4 5] v2:1000 2000 3000)
  2. k| v1 v2  
  3. -| -------
  4. 1| 10     
  5. 2| 20     
  6. 3| 30 1000
  7. 4|    2000
  8. 5|    3000
7. 复杂列数据

1. 简单的例子
在如下表中，lh列中储存了一个嵌套的列表

</>复制代码 
  1. q)tp:([] d:2015.01.01 2015.01.02; lh:(67.9 82.10; 72.8 88.4))
  2. q)tp 0
  3. d | 2015.01.01
  4. lh| 67.9 82.1
  5. q)tp `lh
  6. 67.9 82.1
  7. 72.8 88.4

2. 复合列数据的操作
复合列数据的定义：嵌套列中的元素都是简单列表。

</>复制代码 
  1. q)tm:([] wk:2015.01.01 2015.01.08; rv:(38.92 67.34; 16.99 5.14 128.23 31.69))
  2. q)tm
  3. wk         rv                     
  4. ----------------------------------
  5. 2015.01.01 38.92 67.34            
  6. 2015.01.08 16.99 5.14 128.23 31.69
</>复制代码 
  1. Nested columns mean adverbs. Lots of adverbs.
</>复制代码 
  1. q)select wk, srt:desc each rv, avgr:avg each rv, hi:max each rv from tm
  2. wk         srt                     avgr    hi    
  3. -------------------------------------------------
  4. 2015.01.01 67.34 38.92             53.13   67.34 
  5. 2015.01.08 128.23 31.69 16.99 5.14 45.5125 128.23
</>复制代码 
  1. q)select wk, drp:neg 1_"deltas each desc each rv from tm
  2. wk         drp             
  3. ---------------------------
  4. 2015.01.01 ,28.42          
  5. 2015.01.08 96.54 14.7 11.85

3. 复合外键
复合主键的键表：

</>复制代码 
  1. q)ktc:([lname: `Dent`Beeblebrox`Prefect; fname:`Arthur`Zaphod`Ford]; iq:98 42 126)

有ktc外键的表：

</>复制代码 
  1. q)tdetails:([] name:`ktc$(`Beeblebrox`Zaphod;`Prefect`Ford;`Beeblebrox`Zaphod); sc:36 126 42)

ktc的列就可以作为tdetails的虚拟列了

</>复制代码 
  1. q)select name.lname, name.iq, sc from tdetails
  2. lname      iq  sc 
  3. ------------------
  4. Beeblebrox 42  36 
  5. Prefect    126 126
  6. Beeblebrox 42  42
8. 属性 
</>复制代码 
  1. Attributes are metadata that you attach to lists of special forms. They are also used on a dictionary domain or a table column to speed retrieval for some operations.

属性是描述性的，当你指定表中某一列具有某种属性时，q语言会去检查确认，但并不会帮你完成这个操作。

</>复制代码 
  1. Kx says not to expect significant benefit from an attribute for fewer than a million items.

1. Sorted `s#
当某一列被指定为sorted的时候，线性搜索就会被替换为二分查找，查找速度更快。

当属性被成功应用于列表时，它就变成了列表的一部分，并且q会检查这个列表是否满足这一属性。

</>复制代码 
  1. q)`s#1 2 4 8
  2. `s#1 2 4 8
  3. q)`s#2 1 3 4
  4. "s-fail

排序函数asc会自动在其结果上应用sorted属性，但是til不会

</>复制代码 
  1. q)asc 2 1 8 4
  2. `s#1 2 4 8
  3. q)til 5
  4. 0 1 2 3 4
</>复制代码 
  1. q)L:`s#1 2 3 4 5
  2. q)L,:6
  3. q)L
  4. `s#1 2 3 4 5 6
  5. q)L,:0
  6. q)L
  7. 1 2 3 4 5 6 0

对字典应用sorted属性，会在应用到其键值上，其查找算法就会被替代为二分查找。

</>复制代码 
  1. q)d:`s#10 20 30 40 50!`a`b`c`d`e
  2. q)key d
  3. `s#10 20 30 40 50
  4. q)d 10
  5. `a
  6. q)d 12
  7. `a
  8. q)d 15
  9. `a
  10. q)d 20
  11. `b

2. Unique `u# 

</>复制代码 
  1. q)`u#2 1 4 8
  2. `u#2 1 4 8
  3. q)`u#2 1 4 8 2
  4. "u-fail

Unique属性的amend操作：

</>复制代码 
  1. q)L:`u#2 1 4 8
  2. q)L,:3
  3. q)L
  4. `u#2 1 4 8 3
  5. q)L,:2
  6. q)L
  7. 2 1 4 8 3 2

unique属性可以作用于字典的域，表的一列或者键表的键。但是不能作用于一个字典，表或者键表。

3. Parted `p#
Parted属性 `p#表明对所有出现的值，相同的值都是互相邻近的。

</>复制代码 
  1. q)`p#2 2 2 1 1 4 4 4 4 3 3
  2. `p#2 2 2 1 1 4 4 4 4 3 3
  3. q)`p#2 2 2 1 1 4 4 4 4 3 3 2
  4. "u-fail
  5.   [0]  `p#2 2 2 1 1 4 4 4 4 3 3 2

parted属性在任何list的操作上都不会被保留下来，即使折耳根操作保留了这个属性。

</>复制代码 
  1. q)L:`p#1 1 2 3 3
  2. q)L
  3. `p#1 1 2 3 3
  4. q)L,:3
  5. q)L
  6. 1 1 2 3 3 3

4. Grouped `g#
可以作用在任何list上。

</>复制代码 
  1. It causes q to create and maintain an index – essentially a hash table.
</>复制代码 
  1. q)`g#1 2 3 2 3 4 3 4 5 2 3 4 5 4 3 5 6
  2. q)L:`g#100?100
  3. q)L,:1 1 1 1

5. 去除属性 `#
通过指令 `# 可以去除列表上的任何属性：

</>复制代码 
  1. q)L:`s#til 10
  2. q)L
  3. `s#0 1 2 3 4 5 6 7 8 9
  4. q)`#L
  5. 0 1 2 3 4 5 6 7 8 9

Section End.

GPU云服务器 云服务器 机器学习学习之路 机器学习之路 python学习之路 大数据学习之路

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/17985.html

相关文章

  • 2. Q语言学习之路—基本数据类型: Atoms

    摘要：概述所有的数据都是通过最小单位构造。语言中大部分数据类型与传统语言类似，但是多出了和相关的类型，用来加速时间序列运算。适用的运算符仅有数据中共有两种类型数据，更类似于中的和。其表示值为从千禧年计数的纳秒数，之前为负数，之后为正数。 概述 所有的数据都是通过最小单位atom构造。q语言中大部分数据类型与传统语言类似，但是多出了date和time相关的类型，用来加速时间序列运算。下表给出了...

    李涛 评论0 收藏0

发表评论

登陆后可评论

0条评论

syoya

男|高级讲师
我要私信

TA的文章

阅读更多
最新活动
阅读需要支付1元查看
<