Code tips(持续更新中。。。)

• pandas篇

1、
通常做数据分析时候会用pandas将数据转化成dataframe数据框的格式，
如

但是如果遇到只有一行数据的情况

就会报错：ValueError: If using all scalar values, you must pass an index
有如下两种处理方式：

2、常用list=[]、dict1=dict{}创建一个空列表和空字典表，再用数据框的时候，也可以用pd.DataFrame()直接创建一个空数据框，当然也可以指定一些列名，out_var = pd.DataFrame(columns=var_name) # 创建一个空的dataframe

3、在用append的时候，out_var.append(pd_lt)简单以为这样就连接上是错误滴。一定要out_var = out_var.append(pd_lt)。另外如果要在for循环外面引用内部append之后的变量。必须在外边定义全局变量！！
global out_lst
out_lst=pd.DataFrame()

4、#改变数据类型
df = pd.DataFrame([{‘col1’:‘a’, ‘col2’:‘1’}, {‘col1’:‘b’, ‘col2’:‘2’}])
df.dtypes

df[‘col2’] = df[‘col2’].astype(‘int’)
df[‘col2’] = df[‘col2’].astype(‘float64’)

5、如何找到NaN、缺失值或者某些元素的索引名称以及位置
np.where(np.isnan(df))[0]
是否包含缺失值：np.isnan(df).any()
6、缺失值nan
可以用np.isnan(dt)或者math.isnan(dt)或者pd.isna(dt) 或者pd.isnull(dt)，其中pd.isna()==pd.isnull(),既能识别math.nan也能识别np.nan，是最好的。最好不要用x is np.nan

df_feature[df_feature.label.notna()]
df_feature[df_feature.label.isna()]

7、read_csv(nrows=n)
大数据的情况下先尝试读取几行

8、分类取前几行

list1 = [1, 3, 1,0,7,4,0]
list2 = [3, 3, 2,5,4,4,2]
list3 = [1,2,3,4,5,6,7]
df1 = pd.DataFrame({'col1':list1,'col2':list2,'col3':list3})
df1

col1	col2	col3
0	1	3	1
1	3	3	2
2	1	2	3
3	0	5	4
4	7	4	5
5	4	4	6
6	0	2	7

df2 = df1.sort_values(['col2', 'col3'], ascending=[True, False])
df2.groupby(['col2']).head(1)

col1	col2	col3
6	0	2	7
1	3	3	2
5	4	4	6
3	0	5	4

9、data.idxmax(axis=1) 取每一行的最大值的所属列名

10、pd.pivot
主要是用来拉平reshape数据

res1 = data1_3.groupby(['app_mon','tag1'])['target'].mean().reset_index()
res1
app_mon	tag1	target
0	202107	test	0.196036
1	202107	train	0.191451
2	202108	test	0.201913
3	202108	train	0.203173
4	202108	valid	0.203681

result = res1.pivot(index='tag1', columns='app_mon', values='target')
result.columns.name = None
result
	202107	202108
tag1		
test	0.196036	0.201913
train	0.191451	0.203173
valid	NaN	0.203681

11、
groupby.agg

.agg([('badrate','mean'),('总数','count')]).reset_index()

12、pd.read_excel
pd.read_excel(filename, header=None, names=[‘col1’, ‘col2’,‘col3’])
用于读取excel中没有列名，并且自定义列名

• numpy篇

1、np.take
a = [4, 3, 5, 7, 6, 8]
indices = [0, 1, 4]
np.take(a, indices)
　　array([4, 3, 6])
　　　　　　　　　　　 　　
2、np.corrcoef(a) 计算行之间的相关系数，np.corrcoef(a, rowvar=0)计算列之间的相关系数

3、np.absolute(a) 、np.abs(a) 求a的绝对值矩阵

4、argsort、argmax、argmin、argpartition
　　argsort是对指定的array排序之后的索引，argmax返回最大值的索引，argmin返回最小值的索引，argpartition找出 N 个最大数值的索引

x = np.array([12, 10, 12, 0, 6, 8, 9, 1, 16, 4, 6, 0])
index_val = np.argpartition(x, -4)[-4:]

5、np.ravel()

6、np.allclose(a, b,0.1) 判断a,b两个数组在公差范围内是否相等

array1 = np.array([0.12,0.17,0.24,0.29])
array2 = np.array([0.13,0.19,0.26,0.31])# with a tolerance of 0.1, it should return False:
np.allclose(array1,array2,0.1)
False# with a tolerance of 0.2, it should return True:
np.allclose(array1,array2,0.2)
True

7、np.random产生随机数
其中np.random.randn(10), 生成10个0,1正态分布随机数
np.random.randint(0, 5, 10)生成10个在0,5之间的随机数

np.random.uniform(0,0.1,size=(10,20)) 产生10*20 的0~0.1的均匀分布数

8、np.ones_like(arry, dtype=bool)和np.ones(shapes=(array.shape[0],array.shape[1]), dtype=bool)；类比的还有np.zeros_like和zp.zeros

9、np.where
Where() 用于从一个数组中返回满足特定条件的元素。比如，它会返回满足特定条件的数值的索引位置。Where() 与 SQL 中使用的 where condition 类似，如以下示例所示：

y = np.array([1,5,6,8,1,7,3,6,9])# Where y is greater than 5, returns index position
np.where(y>5)
array([2, 3, 5, 7, 8], dtype=int64),)# First will replace the values that match the condition, 
# second will replace the values that does not
np.where(y>5, "Hit", "Miss")
array(['Miss', 'Miss', 'Hit', 'Hit', 'Miss', 'Hit', 'Miss', 'Hit', 'Hit'],dtype='<U4')

10、
Percentile() 用于计算特定轴方向上数组元素的第 n 个百分位数。

a = np.array([1,5,6,8,1,7,3,6,9])
np.percentile(a, 50, axis =0)

11、np.histogram
Compute the histogram of a dataset.

numpy.histogram(a, bins=10, range=None, normed=None, weights=None, density=None)

特别的，在这里bins可以是自己设置的分箱数，也可以根据算法确定的numpy.histogram_bin_edges
返回值有两个：hist:各个分组的总数；bin_edges：the bin edges (length(hist)+1).

12、np.digitize
Return the indices of the bins to which each value in input array belongs.

numpy.digitize(x, bins, right=False)

13、np.bincount

numpy.bincount(x, weights=None, minlength=0)

特别注意里面weight的使用

以上三个函数用法：

bin_count, bin_edges = np.histogram(proba, bins=bins)
n_bins = len(bin_count)
bin_edges[0] -= 1e-8

bin_id = np.digitize(proba, bin_edges, right=True) - 1

bin_ysum = np.bincount(bin_id, weights=y, minlength=n_bins)
bin_probasum = np.bincount(bin_id, weights=proba, minlength=n_bins)

• python

1、深拷贝与浅拷贝
先看浅拷贝和直接赋值传递的区别

l1 = [1, 2, 3]
l2 = l1
l3 = l1[:]
l4 = list(l1) # 通过构造函数的方式，等同切片操作[:]

l1.append(10)
print(l1, l2, l3, l4)
[1, 2, 3, 10] [1, 2, 3, 10] [1, 2, 3] [1, 2, 3]

直接赋值的做法就相当于l2和l1同时指向了[1, 2, 3]这个对象，因为列表是可变的，所以l2会随着l1变化；

a = 1
b = a
a += 1
print(a, b)
2 1

因为整型是不可变的，所以，a = a + 1，并不是让 a 的值增加 1，而是表示重新创建了一个新的值为 2 的对象，并让 a 指向它。但是 b 仍然不变，仍然指向 1 这个对象。

浅拷贝，是指重新分配一块内存，创建一个新的对象，里面的元素是原对象中子对象的引用。

l1 = [[1, 2], (30, 40)]
l2 = list(l1)
l1.append(100)
l1[0].append(3)
print(l1, l2)
[[1, 2, 3], (30, 40), 100] [[1, 2, 3], (30, 40)]

l1.append(100)，表示对 l1 的列表新增元素 100。这个操作不会对 l2 产生任何影响，因为 l2 和 l1 作为整体是两个不同的对象，并不共享内存地址。操作过后 l2 不变，l1 会发生改变。
再来看，l1[0].append(3)，这里表示对 l1 中的第一个列表新增元素 3。因为 l2 是 l1 的浅拷贝，l2 中的第一个元素和 l1 中的第一个元素，共同指向同一个列表，因此 l2 中的第一个列表也会相对应的新增元素 3。操作后 l1 和 l2 都会改变。

所谓深度拷贝，是指重新分配一块内存，创建一个新的对象，并且将原对象中的元素，以递归的方式，通过创建新的子对象拷贝到新对象中。因此，新对象和原对象没有任何关联。Python 中以 copy.deepcopy() 来实现对象的深度拷贝

2、assert 断言
assert 1>2, ‘incorrect number’

3、对列表的extend、append、+=
a=[1, 2, 3] b=[7, 8, 9]
a.append(b)=[1, 2, 3, [7, 8, 9]]
a.extend(b)=[1, 2, 3, 7, 8, 9]
+=和extend效果一样

4、字符串翻转
找到下面5种方法的比较:

1. 简单的步长为-1, 即字符串的翻转(常用);
2. 交换前后字母的位置;
3. 递归的方式, 每次输出一个字符;
4. 双端队列, 使用extendleft()函数;
5. 使用for循环, 从左至右输出;
6. .借用列表，使用reverse()方法

string = 'abcdef'

def string_reverse1(string):
    return string[::-1]

def string_reverse2(string):
    t = list(string)
    l = len(t)
    for i,j in zip(range(l-1, 0, -1), range(l//2)):
        t[i], t[j] = t[j], t[i]
    return "".join(t)

def string_reverse3(string):
    if len(string) <= 1:
        return string
    return string_reverse3(string[1:]) + string[0]

from collections import deque
def string_reverse4(string):
    d = deque()
    d.extendleft(string)
    return ''.join(d)

def string_reverse5(string):
    #return ''.join(string[len(string) - i] for i in range(1, len(string)+1))
    return ''.join(string[i] for i in range(len(string)-1, -1, -1))
    
def string_reverse6(string):
    return ''.join(list(string).reverse())

5、实现逆序循环 for i in range(len, -1, -1)

6、7//2=3，7%2=1，7/2=3.5

7、if条件语句后面需要跟随bool类型的数据，即True或者False。然而，如果不是bool类型的数据，可以将其转换成bool类型的数据，转换的过程是隐式的。

在Python中，None、空列表[]、空字典{}、空元组()、0等一系列代表空和无的对象会被转换成False。除此之外的其它对象都会被转化成True。

在命令if not 1中，1便会转换为bool类型的True。not是逻辑运算符非，not 1则恒为False。因此if语句if not 1之下的语句，永远不会执行。

8、s.split(’ ')和s.split()有区别，前者可以把所有的空格都当做分隔符，后者只能把一个空格当做空格符

9、连续空格只保留一个

s = "abc  def   ghi       xy"
print(' '.join(filter(lambda x: x, s.split(' ')))
#filter的用法，filter(function, iterable)，其中function是个判断函数，例：
/*
def is_odd(n):
    return n % 2 == 1

newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(newlist) --[1, 3, 5, 7, 9]
*/
#这个判断函数就是x不为空

print(' '.join(s.split()))#这个方法就能达到要求

10、

def foo(a, b, name=None,*args,  **kwargs):
    print(name)
    print(args)
    print(kwargs)
A=(1, 2, 3)
B={"k1":"v1","k2":"v2"}
foo(1,2,C=6,*A,**B) #如果写成foo(1,2,C=6,1, 2, 3,**B)则会报错
1------->name
(2, 3)------->args
{'k2': 'v2', 'C': 6, 'k1': 'v1'}------->kwargs，C=6传入kwargs中

还有：

def foo(a, b, k1, k2):
	print(k1, k2)

B={"k1":"v1","k2":"v2"}
foo(1, 2,**B)
这样操作是传入多个参数

11、装饰器

import time

def timer(func):
    def wrapper(*args,**kwds):
        t0 = time.time()
        func(*args, **kwds)
        t1 = time.time()
        print('耗时%0.3f' % (t1 - t0,))

    return wrapper

@timer
def do_something(delay):
    print('函数do_something开始')
    time.sleep(delay)
    print('函数do_something结束')

do_something(3)

12、
classmethod装饰器的使用

class A(object):

    # 属性默认为类属性（可以给直接被类本身调用）
    num = "类属性"

    # 实例化方法（必须实例化类之后才能被调用）
    def func1(self): # self : 表示实例化类后的地址id
        print("func1")
        print(self)

    # 类方法（不需要实例化类就可以被类本身调用）
    @classmethod
    def func2(cls):  # cls : 表示没用被实例化的类本身
        print("func2")
        print(cls)
        print(cls.num)
        cls().func1()

    # 不传递传递默认self参数的方法（该方法也是可以直接被类调用的，但是这样做不标准）
    def func3():
        print("func3")
        print(A.num) # 属性是可以直接用类本身调用的
    
# A.func1() 这样调用是会报错：因为func1()调用时需要默认传递实例化类后的地址id参数，如果不实例化类是无法调用的
A.func2()
A.func3()

13、
判断集合 x 的所有元素是否都包含在集合 y 中：

x = {"a", "b", "c"}
y = {"f", "e", "d", "c", "b", "a"}
 
z = x.issubset(y) 

14、
凡是在类中定义了这个__getitem__ 方法，那么它的实例对象（假定为p），可以像这样p[key] 取值，当实例对象做p[key] 运算时，会调用类中的方法__getitem__。

class DataBase:
    def __init__(self, data):
        '''初始化方法'''
        self.data = data
        
    def __getitem__(self, idx):
        return self.data[idx]

data = DataBase([3,5])

那么可以data[0] ，结果为 3

15、str.format输出花括号本身

>>> print("{{{0}".format(0))
{0

16、3种输出方式控制小数位数

number = 3.141592653589793
formatted_number = "%.2f" % number  # 保留两位

formatted_number = "{:.2f}".format(number)

formatted_number = f"{number:.2f}"

• sql

1、delete删除重复的email，只保留一个id最小的

DELETE p1 FROM Person p1,
    Person p2
WHERE
    p1.Email = p2.Email AND p1.Id > p2.Id

2、update

UPDATE salary
SET sex = CASE when sex = 'm' then 'f' else 'm' end;

3、group_concat

select sell_date, count(distinct product) as num_sold,
group_concat(distinct product order by product separator ',') products
from Activities
group by sell_date
order by sell_date;

4、mysql行列转换

列转行

SELECT product_id, 'store1' store, store1 price FROM products WHERE store1 IS NOT NULL
UNION
SELECT product_id, 'store2' store, store2 price FROM products WHERE store2 IS NOT NULL
UNION
SELECT product_id, 'store3' store, store3 price FROM products WHERE store3 IS NOT NULL;

行转列

SELECT 
  product_id,
  SUM(IF(store = 'store1', price, NULL)) 'store1',
  SUM(IF(store = 'store2', price, NULL)) 'store2',
  SUM(IF(store = 'store3', price, NULL)) 'store3' 
FROM
  Products1 
GROUP BY product_id ;