YAN's Blog
0%

Posted on In Symbols count in article: 930 Reading time ≈ 1 mins.

numpy.linalg.norm

linalg.norm(x,ord=None,axis=None,keepdims=False)

其中x可以传入array，也可以是matrix。

ord参数针对x是array还是matrix是不一样的计算：

ord norm for matrices norm for vectors
None Frobenius norm 2-norm
‘fro’ Frobenius norm –
‘nuc’ nuclear norm –
inf max(sum(abs(x), axis=1)) max(abs(x))
-inf min(sum(abs(x), axis=1)) min(abs(x))
0 – sum(x != 0)
1 max(sum(abs(x), axis=0)) as below
-1 min(sum(abs(x), axis=0)) as below
2 2-norm (largest sing. value) L2范数
-2 smallest singular value as below
other – sum(abs(x)ord)(1./ord)

如果传入axis这个参数，axis=0表示每一列为向量，以每一列的向量为基础计算。然后就转化为了向量运算。

其中keepdims如果是True，那么规范化的轴将作为尺寸1留在结果中，使用此选项，结果将针对原始 x 正确广播。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
a = np.arange(9) - 4
b = a.reshape((3,3))

a
Out[7]: array([-4, -3, -2, -1,  0,  1,  2,  3,  4])
b
Out[8]: 
array([[-4, -3, -2],
       [-1,  0,  1],
       [ 2,  3,  4]])

LA.norm(b,axis=1)
Out[9]: array([5.38516481, 1.41421356, 5.38516481])
LA.norm(b,axis=1,keepdims=True)
Out[10]: 
array([[5.38516481],
       [1.41421356],
       [5.38516481]])

从以上结果看出：如果keepdims等于True，那么输出的矩阵将会是3乘以1的矩阵，输入矩阵是3乘以3。如果用Input/ norm(input)是不会报错的。

Posted on Edited on In Symbols count in article: 2.2k Reading time ≈ 2 mins.

select

1
2
3
4
5
6
7
8
9
SELECT * FROM table_name; # 选取所有内容

SELECT DISTINCT column_name,column_name
FROM table_name; # 一个列可能包含不同的值，该句可以列出不同的值

SELECT column_name,column_name
FROM table_name
WHERE column_name operator value; # OPERATOR部分可以是: =,>,<,between,in,like
# WHERE后可以跟逻辑符号 and,or,not

mysql语句对大小写不敏感，select == SELECT

1
2
3
4
5
6
7
select * from emp where not sal > 1500;

Select * from emp where comm is null;

Select * from emp where sal in (5000,3000,1500);

SELECT * FROM Websites WHERE alexa > 15 AND (country='CN' OR country='USA'); # AND和OR可以结合使用

Like模糊查询

1
Select * from emp where ename like 'M%';

查询 EMP 表中 Ename 列中有 M 的值，M 为要查询内容中的模糊信息。

  • % 表示多个字值，**_** 下划线表示一个字符；
  • M% : 为能配符，正则表达式，表示的意思为模糊查询信息为 M 开头的。
  • %M% : 表示查询包含M的所有内容。
  • %M_ : 表示查询以M在倒数第二位的所有内容。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
SELECT column_name,column_name
FROM table_name
ORDER BY column_name,column_name ASC|DESC; # 默认是升序

INSERT INTO table_name (column1,column2,column3,...)
VALUES (value1,value2,value3,...); # 这种方式可以向table_name表格中插入一行，可以只向某一列插入，其他自动

UPDATE table_name
SET column1=value1,column2=value2,...
WHERE some_column=some_value; # 用于更新某条记录 
# 比如：
UPDATE Websites 
SET alexa='5000', country='USA' 
WHERE name='菜鸟教程';

DELETE FROM table_name
WHERE some_column=some_value; # 删除某一行记录

高级用法

join

img 
1
2
3
4
5
# QL INNER JOIN（简单的 JOIN）。 SQL INNER JOIN 从多个表中返回满足 JOIN 条件的所有行。
SELECT Websites.id, Websites.name, access_log.count, access_log.date
FROM Websites
INNER JOIN access_log
ON Websites.id=access_log.site_id;
  • INNER JOIN：如果表中有至少一个匹配，则返回行
  • LEFT JOIN：即使右表中没有匹配，也从左表返回所有的行
  • RIGHT JOIN：即使左表中没有匹配，也从右表返回所有的行
  • FULL JOIN：只要其中一个表中存在匹配，则返回行

union

UNION 操作符用于合并两个或多个 SELECT 语句的结果集。

请注意，UNION 内部的每个 SELECT 语句必须拥有相同数量的列。列也必须拥有相似的数据类型。同时，每个 SELECT 语句中的列的顺序必须相同。

1
2
3
SELECT column_name(s) FROM table1
UNION
SELECT column_name(s) FROM table2;

注释：默认地，UNION 操作符选取不同的值。如果允许重复的值，请使用 UNION ALL。

SQL UNION ALL 语法

1
2
3
SELECT column_name(s) FROM table1
UNION ALL
SELECT *column_name(s) FROM table2;

注释：UNION 结果集中的列名总是等于 UNION 中第一个 SELECT 语句中的列名。

前者只会列出选出的值中不同的一些数据条，后者是所有的都返回。

Count

COUNT() 函数返回匹配指定条件的行数。

SQL COUNT(column_name) 语法

COUNT(column_name) 函数返回指定列的值的数目（NULL 不计入）：

1
SELECT COUNT(column_name) FROM table_name;

SQL COUNT(*) 语法

COUNT(*) 函数返回表中的记录数：

1
SELECT COUNT(*) FROM table_name;

SQL COUNT(DISTINCT column_name) 语法

COUNT(DISTINCT column_name) 函数返回指定列的不同值的数目：

1
SELECT COUNT(DISTINCT column_name) FROM table_name;

注释：COUNT(DISTINCT) 适用于 ORACLE 和 Microsoft SQL Server，但是无法用于 Microsoft Access。

Posted on Edited on In Symbols count in article: 2.1k Reading time ≈ 2 mins.

join()

Examples

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
>>> df = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3', 'K4', 'K5'],
...                    'A': ['A0', 'A1', 'A2', 'A3', 'A4', 'A5']})
>>> df
  key   A
0  K0  A0
1  K1  A1
2  K2  A2
3  K3  A3
4  K4  A4
5  K5  A5
>>> other = pd.DataFrame({'key': ['K0', 'K1', 'K2'],
...                       'B': ['B0', 'B1', 'B2']})
>>> other
  key   B
0  K0  B0
1  K1  B1
2  K2  B2

Join DataFrames using their indexes.

1
2
3
4
5
6
7
8
>>> df.join(other, lsuffix='_caller', rsuffix='_other')
  key_caller   A key_other    B
0         K0  A0        K0   B0
1         K1  A1        K1   B1
2         K2  A2        K2   B2
3         K3  A3       NaN  NaN
4         K4  A4       NaN  NaN
5         K5  A5       NaN  NaN

如果不想以现有index为基础去Join，比如上面的例子想用key这个index去Join，可以：

1
2
3
4
5
6
7
8
>> df.join(other.set_index('key'), on='key')
  key   A    B
0  K0  A0   B0
1  K1  A1   B1
2  K2  A2   B2
3  K3  A3  NaN
4  K4  A4  NaN
5  K5  A5  NaN

merge()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
df1 = pd.DataFrame({'lkey': ['foo', 'bar', 'baz', 'foo'],
                    'value': [1, 2, 3, 5]})
df2 = pd.DataFrame({'rkey': ['foo', 'bar', 'baz', 'foo'],
                    'value': [5, 6, 7, 8]})
df1
    lkey value
0   foo      1
1   bar      2
2   baz      3
3   foo      5
df2
    rkey value
0   foo      5
1   bar      6
2   baz      7
3   foo      8


选择多列

有时候需要选择DataFrame中的多个列组成一个新的DataFrame，这时候要用

1
df[['column1','column2']] # 注意这里是双层中括号！

drop 满足条件的行

1
2
3
df_clear = df.drop(df[df['x']<0.01].index)
# 也可以使用多个条件
df_clear = df.drop(df[(df['x']<0.01) | (df['x']>10)].index) #删除x小于0.01或大于10的行

dropna 丢掉某一列中有空的行

1
df.dropna(subset=['column_name'])

apply，applymap，map

apply

官方解释是 apply a function along an axis of the dataframe.

apply内函数的是Series，也就是在Series上做函数操作。index可以是dataframe的index，也可以是dataframe的columns(axis=1)。axis=0时，apply the function to each column，也就是每一列为一个整体去实施函数。axis=1时，每一行作为一个整体去实施函数。

1
2
df.apply(np.sum, axis=0)
df.apply(np.sum, axis=1)

applymap

官方解释是 apply a function to a dataframe elementwise.和apply不一样的是对dataframe中每一个元素分别作函数。

applymap允许实施一个函数，这个函数接受和返回的都是一个标量。

1
df.applymap(lambda x: len(str(x)))

map

map调用的对象只能是Series，而上面两个方法的调用对象是Dataframe。