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中没有列名,并且自定义列名
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)
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, 即字符串的翻转(常用);
- 交换前后字母的位置;
- 递归的方式, 每次输出一个字符;
- 双端队列, 使用extendleft()函数;
- 使用for循环, 从左至右输出;
- .借用列表,使用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}"
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 ;