python_ku

axis==ass  1 行走 进去
axis=0为列操作
axis=1为对行操作
bool 只有两种变化，0,1，用1B存储
df中object类型是字符串类型，只存储指向字符串的指针，来保证同int8一样，每个元素占用存储空间一样，同numpy

numpy中的array不能同list一样可改变长度，list是动态的，array是固定长度的

打开text

with open(path,'r',encoding="utf-8") as f:
	#自动关闭
'r':只读
'r+'：读写
'a'：追加
'w'：覆盖写入
encoding：gbk/ansi

global

a=3
def b():
	global a#声明使用的全局变量，不是函数内变量
	print(a)

try

while True:
	try:
		kk=pa(url,head)#可能会出现异常的代码
	except socket.timeout:#出现异常了怎么操作
		time.sleep(2)
		continue
    except Exception: 
        time.sleep(5)
        continue
	else:#如果代码正常运行，则
		break
	

numpy

#加载数据
np_array=np.loadtxt('aa.csv.gz',dellimiter=',',dtype=np.float32)

np_array=np.array([[1 1 1 1 0],[2 2 2 2 0]])
#[[1 1 1 1], [2 2 2 2]]
np_array[:,:-1]#获取二维矩阵：所有行，除了最后一行的所有列
#[0 0]
np_array[:,-1]#获取一维向量：最后一列。每一行是个标量
#[[0],[0]]
np_array[:,[-1]]#获取二维矩阵，每一行是个向量。


2*np.array([1,2,3])==np.array([2,4,6])
2+np.array([1,2,3])==np.array([3,4,5])
np.array([1,2,3])-2==np.array([-1,0,1])
np.array([[1,2,3],[4,5,6]])-np.array([1,1,1])==array([[0, 1, 2],
       [3, 4, 5]])


array.dtype查看其中元素的类型
#生成一个layer_output形状的array，每个元素的随机取值为0 or 1【[0,2)】
np.random.randint(0,high=2,size=layer_output.shape)
#生成size形状{(2,3)或(2,)}的array，每个元素的随机取值为[0, 1.0)
np.random.random(size=())
np.random.shuffle(array)#直接将array随机打乱，不产生副本
np.arange(5)#array([0, 1, 2, 3, 4])
np_array[indices]#indices可为int，或int的列表/array

array_1==array_2#返回bool型的array，形状同array_1
#两个array是否相同
(array_1==array_2).all() #返回True,或 False
#两个array是否在同样的位置有相同的元素，一个及以上
(array_1==array_2).any()

#array的形状(row_num,col_num ) (5,)
array.shape
#返回给定形状和类型的0填充的array
np.zeros(5)==array([ 0.,  0.,  0.,  0.,  0.])
np.zeros((5,),dypte=np.int)==array([0, 0, 0, 0, 0])
np.zeros(shape,dtype=np.float,order='C')
'''
order：'C' 类似C语言风格，在内存中按行存储
		'F' 类似Fortran风格，在内存中按列存储
'''

#返回于给定array_like形状相同的0填充array
np.zeros_like(array_like,dtyp=None,order='K',subok=True,shape=None)
'''
dtype：数据类型
order:

'''
#查看是否
np.all(array_like,axis=None)
'''
array_like：可转换为array的对象，可为df
axis：为None时检测所有位置，得到一个 bool型 
	  为0按列检测，得到bool型数组
	  为1按行检测，得到bool型数组
'''
#比较两个array是否一样
a=array_1
b=array_2
a==b返回矩阵，每个位置是否相等
(a==b).all()#对两个矩阵的比对结果再做一次与运算,如果两个矩阵完全相等，返回True
(a==b).any()#对两个矩阵的比对结果再做一次或运算,如果两个矩阵有值相等的地方，就返回True

#删除
np.delete(array_like,index/index_arr,axis=None)
'''
axis：为None时，表示展平的array

'''
np.where(cond,x,y)#满足cond，输出x，不满足cond，输出y
'''
cond 是一个bool形状的array_like，可为df
x，y可为单个元素，或者array_like，为array_like时要和cond的形状一样
'''
np.where(array_like)#输出array_like中为真的坐标（真也可理解为非0）

#返回一个se，索引为原索引，值：若一行的值都大于cutoff_high，取该行最大值，若一行的值都小于cutoff_low，则用该行最小值，否则，用该行的中值。
np.where(np.all(df.iloc[:,1:ncol]>cutoff_high,axis=1),df['max'],np.where(np.all(df.iloc[:,1:ncol]<cutoff_low,axis=1),df['min'],df['median']))
'''
xx=np.all(df.iloc[:,1:ncol]>cutoff_high,axis=1): df所选中的区域，按行来看，满足条件的为True，不满足条件的为False，索引为原索引，是个se
np.where(xx,df['max'],2) xx为True的位置，在同样位置去df['max']，为False的位置取2
'''
#直接将字符串list转换为浮点数array
arr2=np.array(data1 dtype='float32')  
arr3=np.asarray(data1 dtype='float32')
'''
np.array()和np.asarray都是讲数据结构转换为np_array的类型
当数据结构为列表时，都是复制出一个
当数据结构为array时，asarray直接在对元数据进行更改，而array复制一个副本
'''

#重塑array形状
array.reshape(-1)#将矩阵变成向量(1,len)
array.reshape(-1,1)#将矩阵变成矩阵(len,1)
array.reshape((chang,kuan))
#拼接numpy数组
1.
np.append(array_1,value/array_2) #返回一个一维数组，不管array_1，array_2是几维
2.
np.concatenate((array_1,array_2,..),axis=0)
'''
当array_1和array_2为一维，且axis=0时，同list的extend

axis：默认为0，在列上进行扩展，此时拼接的各数组宽度相同
	 为1时，在行上进行扩展，此时拼接的各数组长度相同
	 
np.concatenate((np.array([1,2,3]),np.array([4,5,6])),axis=0)
	array([1, 2, 3, 4, 5, 6])

	
'''

#排序 升序，返回副本 a=np.sort(array_1)
numpy.sort(array,axis=-1,kind='quicksort',order=None)
'''
array：要排序的np.array
axis：None 先变成一维的再排序，0 按列排序（按第一个轴排序），1 按行排序，-1 按最后一个轴排序
kind：
	
    kind	speed	worst case	work space	stable
    ‘quicksort’	1	O(n^2)	0	no
    ‘heapsort’	3	O(n*log(n))	0	no
    ‘mergesort’	2	O(n*log(n))	~n/2	yes
    ‘timsort’	2	O(n*log(n))	~n/2	yes
order：如果数组包含字段，则是要排序的字段
'''
#排序 升序，直接对原数据进行修改 array_1.sort()
numpy.ndarray.sort(axis=-1, kind='quicksort', order=None)


#array_like中的每个元素是用来堆叠的数组/列表，其形状相同，axis指定按照哪个维度记性堆叠
np.stack(array_like,axis)#返回array
np.stack((a,b,c),axis=)
'''
a = np.arange(1, 10).reshape((3, 3))
b = np.arange(11, 20).reshape((3, 3))
c = np.arange(101, 110).reshape((3, 3))

axis=0时，直接将a,b,c堆叠在一起即可
# axis=0可以认为只是将原数组上下堆叠，增加了0维的个数
array([[[  1,   2,   3],
        [  4,   5,   6],
        [  7,   8,   9]],

       [[ 11,  12,  13],
        [ 14,  15,  16],
        [ 17,  18,  19]],

       [[101, 102, 103],
        [104, 105, 106],
        [107, 108, 109]]])


axis=1时，将a,b,c的每个行堆在一起
#axis=1，可以看出第一个3*3的数组是由是a,b,c中每个数组的第一行堆叠而成
array([[[  1,   2,   3],
        [ 11,  12,  13],
        [101, 102, 103]],

       [[  4,   5,   6],
        [ 14,  15,  16],
        [104, 105, 106]],

       [[  7,   8,   9],
        [ 17,  18,  19],
        [107, 108, 109]]])

axis=2时，将a,b,c的每个列堆在一起,可以看到第一个3*3的数组是由a,b,c中的第一列向量组合而成

array([[[  1,  11, 101],
        [  2,  12, 102],
        [  3,  13, 103]],

       [[  4,  14, 104],
        [  5,  15, 105],
        [  6,  16, 106]],

       [[  7,  17, 107],
        [  8,  18, 108],
        [  9,  19, 109]]])

'''


#判断是某特征se中是数字型
np.issubdtype(type(se[0]), np.number) #返回True

#检测numpy——array中是否存在NaN缺失值
np.isnan(array)#返回和array一样形状的数组（bool型）
np.isnan(array).all()#是否全部为缺失值
np.isnan(array).any()#是否存在缺失值

np.isin(array_1,array_2,invert=False)#array_1中的元素是否在array_2中出现过，并返回array_1形状的bool型
'''
invert 翻转：为True时，如果array_1中元素不在array_2中出现，在相应位置返回True
			为False时，如果array_1中元素在array_2中出现，在相应位置返回True
'''

#取一个array_1中除array_2中出现的元素外其他的元素
index = np.isin(array_1,array_2,invert=True)
array_1[index]
#判断一个值是否为NaN缺失值
np.isnan(a)
#其他判断的方式都不行：eg:
>> np.nan == np.nan
False
>> np.nan in 含nan数组
False

#含nan数组 a
np.sum(a)==nan
np.min(a)==nan
np.max(a)==nan

#使用除缺失值外所有值的平均来填充缺失值
a[np.isnan(a)]#选中所有缺失值的位置
np.mean(a[~np.isnan(a)])#除缺失值外所有值的平均
a[np.isnan(a)]=np.mean(a[~np.isnan(a)])

#用相应列的平均值/中位数/众数/给定值填充缺失值，或用众数/给定值填充想要改变的数字/字符串
from sklearn.imputer import SimpleImputer
im=SimpleImputer(missing_values=np.nan,strategy=’mean',fill_value=None)
'''
missing_values:np.nan缺失值，或想要改变的数字或字符串
strategy：策略
	'mean'：每列的平均值来填充，只能用于数字
	'median'：每列的中位数填充，只能用于数字
	'most_frequent'：每列的众数来填充，可用于数字和字符串
	'constant'：用fill_value的值来填充，可用于数字和字符串
fill_value：当strategy='constant'时才可用，可为数字或字符串
'''
#检测numpy__array中是否为有限值（无限值：np.inf，缺失值：np.nan都返回False）
np.isfinite(array)#返回bool型的array
#返回是否为无穷大的bool型array
np.isinf(array)
#返回是否为正无穷大的bool型array
np.isposinf(array)
#返回是否为负无穷大的bool型array                 
np.isneginf(array)   
                 
#复制
#浅拷贝(切片和‘=’)
a=array[:] or a=array
#深拷贝
array.copy()

                 
#查看某种类型的数据的最值
np.iinfo(np.int8).min#查看int类型的最值
np.finfo(np.float32).max#查看float类型的最值
                 
                

os

import os
#data文件夹下有train文件夹
os.path.join(路径，路径下某个子文件夹名字)
os.path.join('./data','train')=='./data'+'/'+'train'
#获取路径所有文件夹名字列表
os.listdir(路径)
#改变工作目录
os.chdir(路径)
#获取当前工作路径
os.getcwd()
#对于zip文件可之间当做文件夹（文件夹名字为去掉.zip）

#分离路径
file_path = "E:/tt/abc.py"
filepath,fullflname = os.path.split(file_path)
'''
filepath：E:/tt
fullflname：abc.py
'''
fname,ext = os.path.splitext(file_path)
'''
fname：E:/tt/abc
ext：.py
'''

pandas

import pandas as pd
'''
numpy的运算也适用于Series，对于同索引的Series1,Series2
Series1-Series2
Series1/Series2
Series1-array2=Series3没错是可以的

对于df-df2，同列名的相减，若一个特征只有df有，则最终结果的该列值为nan
'''
#对Series取绝对值，返回Series
Series.abs()


#读取a.csv.gz中的a.csv文件
df=pd.read_csv('a.csv.gz',compression='gzip')
#读取文件装换为DataFrame格式,默认有表头，无表头时header=None
df=pd.(read_csv('file_name',header='infer',index_col=False,,usecols=[要读取的列s],engine='c',skiprows=None, nrows=None,seq=',')
'''
seq：默认','，文件中可以有多个分割符  ',|\t| ' |为‘或’的意思
header：默认为'infer'此时以第一行列名
		None时：为没有列名
		0或其他int,为第几行为列名
			0为第一行为列名
skiprows：跳过的文件中的行下标，列名为文件中的下标0行，df中的下标0其实为文件中的下标1
		skiprows=array[从df得到的下标]+1
		skiprows=np.where(~(df['x']==t))[0]+1 #跳过其他类型
			np.where得到元组（array[下标s],）
		为int时，表明跳过前n行(df中的非列名行数)
		
		int==3时，无列名（即使设为header=0)
		skiprows=[1,2,3]/range(1,4)时，有正常的列名（header=0)
			
index_col：作为df的index的列，以列名或列索引的形式给出，默认False,不使用第一列作为index
engine:默认为’c'，c引擎更快，但是python引擎功能更完善，有时读取大文件时，需python引擎

nrows：读取前多少行，不算列名那一行


#当seq为多个分隔符时，读取文件是需传入nrows，否则会出现错误：Error could possibly be due to quotes being ignored when a multi-char delimiter is used.
'''
 # 有表头
df=pd.read_excel('file_name',header=True)
#无表头
df=pd.read_excel('file_name',header=None)
#转换类型
se.astype(dtype)
df.astype(dtype)
'''
dtype：为numpy.dtype ’int8','float32',np.int12,np.float16
'''
#创建DataFrame
df=pd.DataFrame(二维数据)
df=pd.DataFrame({
   '列名1':[第一列数据],'列名2':[第二列数据]})
df=pd.DataFrame(columns=[列名],index=[行名],data=[[],])      
'''
data为二维数据，当DataFrame只有一行时，此时data=[[xx],]
'''
#创建Series
ps=pd.Series(字典)
ps = pd.Series(index=[], data=[], name=None) #其中index为DataFrame的columns

       
#设置display查看的属性
pd.set_option('display.max_colwidth', -1)#将特征的文本字符串全部显示，默认过长时会截断，eg：个人简介，有时会很长
pd.set_option('display.max_rows', 120)#最多显示120行
pd.set_option('display.max_columns', 120)#最多显示120列               
#查看DataFrame的n个样例
df.sample(n=None,frac=None