python面试总结

一.python的优缺点
1.优点
[1]语言简洁优美
[2]跨平台。mac，Linux，window通用
[3]胶水语言。能够把其他语言制作的各种模块（尤其是C/C++）很轻松地结合在一起
可以这么理解，python本身不是一种运算快的语言，但善于利用，整合其他语言且能在各个平台使用得溜，最重要的是开发效率还很高
2.缺点
[1]运行速度慢
python是解释型语言，运行时需要一行行转换成CPU能理解的机器码，很费时
[2]代码不能加密
[3]python的多线程不能利用多核CPU。一个python解释器进程内有一条主线程，以及多条用户程序的执行线程。即使在多核CPU平台上，由于GIL的存在，所以禁止多线程的并行执行。

二.python下的GIL
1.GIL 是python的全局解释器锁，同一进程中假如有多个线程运行，一个线程在运行python程序的时候会霸占python解释器（加了一把锁即GIL），使该进程内的其他线程无法运行，等该线程运行完后其他线程才能运行。如果线程运行过程中遇到耗时操作，则解释器锁解开，使其他线程运行。所以在多线程中，线程的运行仍是有先后顺序的，并不是同时进行。
2.多进程中因为每个进程都能被系统分配资源，相当于每个进程有了一个python解释器，所以多进程可以实现多个进程的同时运行，缺点是进程系统资源开销大

三.常见的面试题
1.删除字典的键 del dict[key]
2.字典的合并 dict1.update(dict2)
3.列表去重，先转化为集合，再转化为列表
4.函数里面的args和kwargs是什么意思
args表示可以传一个可变数量的参数列表
**kwargs表示可以传一个不定长度的键值对
5.python生成随机整数，随机小数，0-1之间的随机数方法
[1]随机整数 random.randint(a,b)
[2]随机小数 random.randn(5) 生成5个随机小数
[6]0-1之间的随机数 random.random()
6.Linux常用的命令
ls pwd cd touch rm mkdir tree cp mv cat more grep echo > >>
[1]echo hello python > 1.txt 表示输出，会覆盖原有文件的内容
[2]echo hello python >> 1.txt 表示追加，会将内容加到原有内容后面
7.可变数据类型和不可变数据类型
[1]可变数据类型
允许变量的值发生变化，对于相同的值的不同对象，在内存中则会存在不同的对象
[2]不可变数据类型
不允许变量的值发生变化，如果改变了变量的值，相当于是新建了一个对象，而对于相同的值的对象，在内存中则只有一个对象
8.对字符串先去重再排序
转化成集合set去重，再转化为列表s，使用s.sort(reverse=False) 得到排序的列表，适用’’.join(s)得到去重排序后的字符串
9.根据值对字典进行排序
dict = {‘candy’:21,‘mandy’:27,‘ciddy’:17,‘kitty’:24,‘tom’:32}
res = sorted(dict.items(),key=lambda d:d[1],reverse=False)
print(res)
10.统计字符串中每个字符出现的次数直接使用collection里面的Counter(变量名)
11.将二维列表转化为一维列表
a = [[1,2],[3,4]]
from tkinter import _flatten
print(list(_flatten(a)))
12.python高级函数
[1]map(fun,list)对list每个元素都调用fun函数，返回一个新列表
[2]filter(fun,list) 对list每个元素都调用fun函数，返回满足条件的元素列表
[3]zip(iter1,iter2,…)接收一系列可迭代对象作为参数，将对应的元素打包成一个个元组，若长度不等则取最短的，使用星号解压缩
[4]enumerate(s)：返回一个包含索引及索引处所在项目的配对
13.常用的正则表达式
[1]re.compile的作用：将正则表达式编译成一个对象，加快速度并重复使用
[2]正则匹配中文pattern = re.compile(r’[\u4e00-\u9fa5]+’)
14.装饰器，生成器，迭代器
[1]装饰器本质上是一个Python函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外功能，对原函数进行包装，返回另一个函数。装饰器的返回值也是一个函数对象。它经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等场景
[2]在装饰器里面定义的装饰器函数的参数最好为args和kwargs，这样对于任意的目标函数都可以
[3]需要使用functools.wraps在装饰器中的函数上把传进来的这个函数进行一个包裹,这样就不会丢失原来的函数的__name__等属性
[4]迭代器是一个可以记住遍历位置的对象。有iter()创建一个迭代器和next()访问元素的两个方法
[5]生成器。一边循环一边计算。生成器一次只能产生一个值，这样消耗的内存数量将大大减小
generator_ex = (xx for x in range(10))
使用next(generator_ex)或 for i in generator_ex:来访问元素
[6]generator的函数，将一般函数return的位置换成yield关键字。在每次调用next()的时候执行，遇到yield语句返回，再次被next（）调用时候从上次的返回yield语句处继续执行

15.异常代码
[1]捕获异常 执行try里面的程序，遇到异常时在except里面找相应的异常，没有发生异常的情况执行else
def mye( level ):
if level < 1:
raise Exception,“Invalid level!”
# 触发异常后，后面的代码就不会再执行
try:
mye(0) # 触发异常
except Exception,err:
print 1,err
else:
print 2
[2]触发异常 raise

16.提高python运行效率的方法
[1]关键代码使用外部功能包 Cpython Pypy等等可以在代码中直接使用C代码，充分利用C代码的高效率
[2]在排序时使用键和内置的sort()方法
somelist = [(1,5,8),(6,2,4),(9,7,5)]
somelist.sort(key=operator.itemgetter(0))
[3]针对循环的优化
尽量避免在循环中访问变量的属性
使用列表生成式
尽量使用生成器
[4]尽量使用新版本的Python
[5]尝试多种不同的编码方式
[6]交叉编译
如Python语言编写应用，再以C++这样的语言运行你的应用

17简述同源策略
[1]URL由协议、域名、端口和路径组成，如果两个URL的协议、域名和端口相同，则表示他们同源。相反，只要协议，域名，端口有任何一个的不同，就被当作是跨域。
[2]浏览器采用同源策略，禁止页面加载或执行与自身来源不同的域的任何脚本
[3]

四.常见的正则表达式查询表
1.元字符(匹配字符串用)
2.定位字符

3.重复字符

五.python的科学计算模块
1.time模块
time.localtime([secs]) 接收时间辍（1970纪元后经过的浮点秒数）并返回当地时间下的时间元组t
time.mktime(tupletime) 接受时间元组并返回时间辍
time.strftime(fmt[,tupletime]) 接收以时间元组，并返回指定格式可读字符串表示的当地时间，格式由fmt决定。
print(time.strftime(’%Y-%m-%d %H:%M:%S’,time_tu1))
time.strptime(str,fmt=fmt_str) 根据fmt的格式把一个时间字符串解析为时间元组

2.numpy模块
[1]广播机制
如果两个数组的后缘维度(即：从末尾开始算起的维度)的轴长相符或其中一方的长度为1，则认为它们是广播兼容的，广播会在缺失和(或)长度为1的轴上进行.
[2]创建ndarray对象
#ndarray多维数组对象的创建，主要有以下函数
#1.array函数，接收一个普通的python序列(列表，元组，字符串)，并将其转换为ndarray
l1 = [1,2,3,4]
arr1 = np.array(l1)
#2.zeros函数，创建指定长度或者形状的全零数组
arr1 = np.zeros((2,3))
#3.ones函数，创建指定长度或者形状的全1数组
arr1 = np.ones((2,3))
#4.arange()函数创建，通过指定开始值，终值，步长来创建一个一维数组，最终创建的数组不包含终值
arr1 = np.arange(10,20,2)
#5.linspace()函数通过指定开始值，终值，元素个数来创建一个一维数组，数组的数据元素符合等差数列，可以通过endpoint关键字来判断是否包含终值，默认包含
arr2 = np.linspace(0,10,5)
#6.logspace和linspace类似，不过创建的是等比数列
arr3 = np.logspace(0,2,5)
#6.使用随机数填充数组，numpy.random里面的random()函数来创建0-1之间的随机元素，元素数量由参数决定
#指定数组的形状大小
arr4 = np.random.random((2,3,4))
#7.返回一个具有正态分布的样本,指定形状
arr5 = np.random.randn(3,3)
#8.返回0-1的随机值 后面的指的是元素的数量，一维数组
arr = np.random.rand(9)
#9.返回随机整数
arr6 = np.random.randint(1,9,size=(2,3))

[3]------------ndarray的对象属性------------
#ndim数组轴(维度)的个数，轴的个数被称为秩
#shape数组的维度，例如一个2排3列的矩阵，它的shape属性将是(2,3),这个元组的长度就是秩，
#size数组元素的总个数，即shape的元素的乘积
#dtype数组元素的类型
#itemsize数组元素的字节大小
arr6 = np.random.randint(1,9,size=(2,3))
print(arr6.ndim)
print(arr6.shape)
print(arr6.size)
print(arr6.dtype)

#4.-----------数组中元素的类型-------------
#创建时可以通过dtype来指定元素类型，要修改的话可以用atype方法得到一个新的数组
arr6 = np.random.randint(1,9,size=(2,3))
arr = arr6.astype(float)
print(arr6.dtype,arr.dtype)

#5.-----------ndarray修改形状--------
#1.直接修改shape值，修改前后乘积不变即可
#2.直接用reshape()函数创建一个改变尺寸的新数组，原数组的shape保持不变，但是原数组和新数组共享一个内存空间，也就是修改任何一个数组中的值都会对另一个有影响，两个数组的元素个数需要一致
#3.当指定某个轴为-1时，将根据元素个数自动计算改轴的长度
a = np.arange(0,20,2)
b = a.reshape(2,5)
c = a.reshape(-1,2)
b[0][1] = 100
a.shape = (2,-1) #修改原数组的shape

6.Numpy的基本操作
1.数组与标量，数组之间的运算,元素级运算，直接和对应的元素做相应的运算即可
arr1 = np.arange(1,10,2)
print(arr1+2)
print(arr1*2)
print(arr1**2)

2.数组的矩阵积 前一个矩阵的行乘第二个矩阵的列然后相加
arr1 = np.random.randint(1,10,size=(2,3))
arr2 = np.random.randint(2,12,size=(3,4))
arr3 = arr1.dot(arr2)
arr4 = np.dot(arr1,arr2)

3.数组的索引和切片
arr = np.random.randint(1,10,size=(2,3,4))
print(arr[1,2,2])
print(arr[1][2][2])

#数组的切片
#在各维度上使用切片，如果某维度都保留，则直接使用冒号，不指定起始值和终止值
arr = np.random.randint(1,12,size=(2,3,4))
print(arr[1][0][1:3])
print(arr[1][0])
print(arr[1,:,1:3])
#通过切片获取的新数组只是原数组的一个视图，因此对新数组的修改也会影响原数组
#花式索引 利用整数数组进行索引的方式
arr1 = np.arange(32).reshape(8,4)
#获取0,3,5行数据
print(arr1[[0,3,5]])
#获取某几个点的数据(0,0) (3,3) (5,2)
print(arr1[[0,3,5],[0,3,2]])
#获取0,3,5行，0,3,2列的数据
print(arr1[np.ix_([0,3,5],[0,3,2])])

#利用布尔类型的数组进行索引，最终返回的结果是对应索引数组中数据为True位置的值
a = np.random.random((4,4))
b = a < 0.5
c = a[b]

#4.数组的转置与轴对换 通过调用transpose函数或者T属性进行数组的转置操作
arr = np.arange(40).reshape(5,-1)
arr1 = arr.transpose()
arr2 = arr.T

#原本0,1,2对应的是4,3,2,因此现在变成1，2，0则对应的是3,2,4
arr = np.random.randint(1,10,(4,3,2))
arr1 = arr.transpose(1,2,0)

#5.数组的拉伸与合并
#拉伸 np.tile(A,rep) 沿着A的维度重复rep次
arr = np.array([[3,9],[4,6]])
#一个数字表示横向拉伸
arr1 = np.tile(arr,2)
arr2 = np.tile(arr,(3,1)) #纵向拉伸3倍，横向拉伸1倍(即不变)

#数组的合并
#stack(array,axis=0) 沿着新的轴加入一系列数组
arr = [
[1,2,3],
[4,5,6]
]
a = np.array(arr)
b = np.array(arr)
c = np.array(arr)
d = np.array(arr)
e = np.array([1,2,3])
f = np.array([4,5,6])
#默认axis=0,所以在最外面加一层
print(np.stack((e,)))
print(np.stack((e,f)))
print(np.stack((f,),axis=1))
print(np.stack((a,b),axis=0))
print(np.stack((a,b),axis=1))
print(np.stack((a,b),axis=2))
print(np.stack((a,b,c),axis=1))
#vstack(): 纵向合并，增加行
print(np.vstack((a,b)))
#hstack():横向合并，增加列
print(np.hstack((a,b)))

6.通用函数：快速的元素级数组成函数
#一元函数
arr = np.array([-5.3,4.2,-6.2,3.5,2,1])
#最大取整
print(np.ceil(arr))
#最小取整
print(np.floor(arr))

#7.聚合函数 对一组数进行操作返回一个单一值作为结果的函数，也可以针对某个具体的轴进行操作
#常见的聚合有平均值，最大值，最小值，总体标准偏差等等
arr = np.random.randint(1,9,(2,3))
print(np.mean(arr))
print(np.max(arr))
print(np.min(arr))
print(np.mean((arr-arr.mean())**2))
print(np.sqrt(np.mean((arr-arr.mean())**2)))
print(np.std(arr))

#二维数组的情况下，axis=0表示对同列的数据进行聚合，axis=1表示对同行的数据进行聚合
#形成一维数组
arr = np.random.randint(1,10,(3,4))
print(np.mean(arr,0))
print(np.min(arr,1))
print(np.std(arr,1))
print(np.sum(arr,0))

#8.np.where函数 是x if condition else y的矢量化版本
arr1 = np.array([1,3,4,7,8])
arr2 = np.array([2,4,3,6,9])
condition1 = arr1 < arr2 #条件成立就取arr1里面的值，不成立就取arr2里面的值
result = np.where(condition1,arr1,arr2)

9.np.unique函数 将数组中的元素进行去重操作返回一个没有重复元素的数组
arr1 = np.random.randint(1,10,(4,5))
arr2 = np.unique(arr1)

3.pandas模块
#pandas两种数据结构
#[1]Series 类似于一维数组 是由一组数据以及与之相关的数据标签(索引，可以重复)组成
#通过一维数组创建，没有指定索引值的话，会默认索引值从0-n-1,后面根据情况可修改
arr = np.array([2,4,6,8,10])
s1 = Series(arr)
#元素类型
print(s1.dtype)
#元素索引
print(s1.index)
#元素值
print(s1.values)

s2 = Series([80,90,99],[‘语文’,‘英语’,‘数学’])
#通过字典的方式创建
dict1 = {‘语文’:90,‘英语’:90,‘数学’:98}
s3 = Series(dict1)

#常见的Serise属性 Series对象本身及其索引都有一个name属性，默认为空，可以根据需要赋值
scores = Series({‘tom’:90,‘jack’:87,‘candy’:92})
scores.name = ‘语文’
scores.index.name = ‘考试成绩’
#1.axes 返回行轴标签列表
#2.head()返回前n行
#3.tail()返回最后n行
#4.Series值的获取 1.方括号+索引 2.方括号+下标值，下标值为负的话表示从右往左取数
#5.Series获取多个值的方式类似于Numpy里面ndarray的切片 [下标(索引)：下标(索引)]
#6.numpy里面的数组运算在Series里面都可使用，在操作Series的时候实际是当成Numpy里面的ndarray来操作
#7.Series自动对齐 多个Series进行运算时，运算会自动对齐相同索引值的数据，如果某个series没有索引值，则最终结果赋值为NaN
s1 = Series([1,2,3,4],[‘p1’,‘p2’,‘p3’,‘p4’])
s2 = Series([5,6,7],[‘p2’,‘p3’,‘p4’])
print(s1+s2)
#NaN在pandas中用于表示一个缺失值或者一个为NA的值
#pandas里面的isnull和notnull两个函数可以用于在Serise里面检测缺失值，这两个函数返回的是一个布尔类型的series
scores = Series({‘tom’:89,‘jack’:90,‘tandy’:91})
index1 = [‘tom’,‘joe’,‘jack’,‘tandy’]
scores = Series(scores,index1)
print(scores)
print(scores.isnull())
print(scores.notnull())
print(scores[scores.isnull()])
print(scores[scores.notnull()])

[2]DataFrame 一个表格型的数据结构 数据帧
#通过二维数组创建
arr = np.array([
[‘tom’,90],
[‘yany’,80],
[‘john’,100]
])
df1 = DataFrame(arr,index=[‘one’,‘two’,‘three’],columns=[‘姓名’,‘成绩’])
print(df1.columns)
print(df1.index)
print(df1.values)
#通过字典创建 字典的key为列索引
dict1 = {
‘语文’:[83,90,87],
‘数学’:[93,98,89],
‘英语’:[90,98,99]
}
df2 = DataFrame(dict1)
#重置索引
df2.index = [‘a’,‘b’,‘c’]
#可以直接通过列索引获取指定列的数据 df[column_name]
#df.ix[index_name] loc iloc获取指定行的数据
df3 = DataFrame(np.random.randint(1,10,(3,3)),index=list(‘abc’),columns=list(‘ABC’))
#获取指定列
print(df3[‘A’])
print(df3[[‘A’,‘B’]])
#列修改
df3[‘A’] = [1,2,3]
print(df3)
#列添加
df3[‘D’] = [4,6,8]
print(df3)
#列删除
#df3.pop(‘D’)
del df3[‘D’]
#行选择
print(df3.loc[‘a’])
print(df3.loc[‘a’:‘b’])
#选择某行某列
print(df3.loc[‘a’,‘A’])
print(df3.loc[‘a’:‘b’,‘A’])
print(df3.loc[‘a’:‘b’,‘A’:‘B’])
print(df3.loc[:,‘A’:‘B’])
#如果行索引是数字的话，可以用iloc来获取
print(df3.iloc[0:2,0:2])
#行增加
df3.ix[‘d’] = [3,5,7]
df3.loc[‘e’] = [4,6,8]
#行删除
df4 = df3.drop(‘e’)

#pandas基本功能
#1.数据文件读取/文本文件读取与文本存储 常用read_xxx读取文件中的数据，常用的有read_csv可以读取文本类型的数据
#并形成dataframe
df5 = pd.read_csv(‘Book1.csv’)
df5.to_csv(‘Book2.csv’)
#处理缺失值的方法 一般删除所在的列或者行，或者填充默认值
#[1]df.dropna()删除只要包含NAN的行
#[2]df.dropna(axis=1)删除只要包含NAN的列
#[3]df.dropna(how=‘all’,axis=1)删除所有元素是NAN的行或列
#填充
df6.fillna(0)
df6.fillna(method=‘bfill’) #向后填充
df6.fillna(method=‘ffill’) #向前填充
df6.loc[0:2,1:3] = np.nan
print(df6.fillna({1:2,2:90})) #对某几列填充什么值
print(df6.replace({np.nan:‘haha’}))
#常用的数学统计方法
#count 计算非na值的数量
#describe 针对series或dataframe各列计算总统计值
#min/max 最小值，最大值 idxmin/idxmax取得最小值或最大值的索引位置
#quantile 计算样本的分位数(0-1)
#medain 值的中位数
#var 方差，std标准差
#cumsum样本值的累计和
#cummin,cummax样本的累计最小值，累计最大值
#cumprod 样本值的累计积
#pct_change 百分数变化
print(df2.describe())
#相关系数与协方差 反应两个样本之间的相关关系以及关系程度
#协方差为正，则同向变化，越大则同向程度越高，为负则反向运动，越小则反向程度越高
df_01 = DataFrame({
‘GDP’:[900,1000,1100,1200],
‘foreign_trade’:[300,400,500,500],
‘year’:[‘2012’,‘2013’,‘2014’,‘2015’]
})
print(df_01.cov())
print(df_01[‘GDP’].cov(df_01[‘foreign_trade’]))
#相关系数，反应两个变量单位变化的相似程度
print(df_01.corr())
print(df_01[‘GDP’].corr(df_01[‘foreign_trade’]))
#数据去重，值计数，成员资格
se1 = Series([‘a’,‘c’,‘b’,‘a’,‘c’,‘b’])
print(se1.unique())
print(se1.value_counts())
print(se1.isin([‘a’,‘c’]))
print(~se1.isin([‘a’,‘c’]))

#5.层次索引 指的是在同一方向拥有多个(两个或两个以上)索引级别
se2 = Series([100,200,300,400,180],
index=[
[‘2016’,‘2016’,‘2017’,‘2017’,‘2017’],
[‘香蕉’,‘苹果’,‘梨子’,‘香蕉’,‘苹果’]

])
print(se2[‘2016’])
print(se2[:,‘苹果’])
#交换分层索引
se02 = se2.swaplevel().sort_index()
#unstack和stack 不堆叠(表格结构) 堆叠(花括号)
se03 = se02.unstack(level=1) #level等于几，第几列就成为列索引
print(se03.stack(level=0))
#stack对普通的dataframe而言，直接列索引转换到内层的行索引，形成一个series
#对于层次化索引的dataframe而言，可以指定的列索引转化到行上，默认是将最内层的列索引转化到最内层的行索引上
#dataframe的分层索引
df_02 = DataFrame({
‘year’:[2011,2011,2011,2012,2012,2013],
‘fruit’:[‘apple’,‘banana’,‘pear’,‘apple’,‘pear’,‘banana’],
‘production’:[2345,1234,467,2424,2434,5463],
‘profits’:[233.44,100.3,355.23,566.45,200.34,400]
})
#设置分层索引
df_03 = df_02.set_index([‘year’,‘fruit’])
#交换分层索引
df_03.swaplevel().sort_index()
print(df_03.loc[2011,‘apple’])
print(df_03.loc[:,‘profits’])
print(df_03.unstack())
df_04 = df_03.unstack()
print(df_04.loc[:,‘production’][‘apple’])
print(df_04.stack(level=0))
#6.排序 sort_index()对行或列索引进行排序
ser1 = Series(np.arange(0,4),index=list(‘bcda’))
ser1.sort_index() #默认索引升序排列
dataf1 = DataFrame(np.random.randint(1,9,(4,4)),index=list(‘BDAC’),columns=list(‘bcda’))
print(dataf1.sort_index()) #默认是对行索引升序排列
print(dataf1.sort_index(axis=1)) #对列升序排列
#series按值进行排列 sort_values 任何缺失值都会放到末尾
print(ser1.sort_values())
print(dataf1.sort_values(by=[‘d’,‘b’])) #按某列进行排序
dataf2 = DataFrame(np.random.randint(1,9,(5,5)),index=list(‘cdbae’),columns=list(‘DSTWA’))
print(dataf2.sort_values(axis=1,by=‘d’))

#rank排名
ser = Series([3,4,1,3,3],index=list(‘abcde’))
print(ser)
print(ser.rank())
print(ser.rank(method=‘min’)) #3是排名2-4，取小的就是2
print(ser.rank(method=‘max’))
print(ser.rank(method=‘first’)) #按默认额顺序
#dataframe rank()默认按列排名，rank(axis=1)按照行排名

#7.时间序列 处理函数date_range 会产生一个时间序列数据的索引
#创建时间序列
date1 = pd.date_range(start=‘20170101’,end=‘20170110’)
#创建10个时间序列
date2 = pd.date_range(start=‘20170101’,periods=10)
#创建一个步长为3天的时间序列
date3 = pd.date_range(start=‘20170101’,periods=10,freq=‘3D’)
#创建一个时间序列，以秒为步长
date4 = pd.date_range(start=‘2017-01-01 08:10:50’,periods=20,freq=‘s’)

#8.数据合并
#merge 根据一个或多个键将不同的DataFrame中的行连接起来
#concat 可以沿着一个轴将多个对象堆叠到一起
df1 = DataFrame({
‘data1’:[1,2,3,4],
‘key1’:[‘a’,‘b’,‘c’,‘d’]
})
df2 = DataFrame({
‘data2’:[9,8,7,6],
‘key1’:[‘a’,‘b’,‘e’,‘f’]
})
df02 = DataFrame({
‘data2’:[9,8,7,6],
‘key2’:[‘a’,‘b’,‘e’,‘f’]
})

df3 = pd.merge(df1,df2)
#how，表示取并集，还是交集，on表示连接的关键字
df4 = pd.merge(df1,df2,how=‘outer’,on=‘key1’)
#不存在共同的列名时，需要指定left_on,right_on how=left表示左边的全取，右边的只取和左边相交的部分
df03 = pd.merge(df1,df02,left_on=‘key1’,right_on=‘key2’,how=‘left’)
#行索引作为连接键
df04 = pd.merge(df1,df2,left_index=True,right_index=True)
df5 = pd.concat([df1,df2],axis=1) #往列上合并 横向合并
df6 = pd.concat([df1,df2],axis=0,join=‘outer’) #往行上加 默认为0，纵向合并

#9.分组聚合 groupby
df1 = DataFrame({
‘data1’:[1,2,3,4,5],
‘data2’: [10, 12, 3, 14, 5],
‘key1’:[‘a’,‘b’,‘c’,‘d’,‘d’],
‘sex’:[‘w’,‘w’,‘m’,‘m’,‘w’]
})
#按照某一列进行分组
print(df1.groupby(‘sex’)) #生成的是一个groupby迭代对象，每次迭代结果是一个元组
for i in df1.groupby(‘sex’):
print(i)
#分完组之后一般会进行聚合
datas = df1.groupby(‘sex’)
print(datas.sum())
print(datas.mean())
print(datas.min())
print(datas.max())
#随机下标
m = [1,2,1,2,1]
print(df1.groupby(m).max())
print(df1)
#通过某一列分组，分别获取一列或两列数据
print(df1.groupby(‘sex’)[‘data1’,‘data2’].sum())
#通过某两列进行分组
print(df1.groupby([‘sex’,‘key1’]).max())
datas1 = df1.groupby([‘key1’,‘sex’])[‘data1’,‘data2’].sum().unstack()
print(datas1)
print(datas1[‘data1’])
print(datas1.loc[:,‘data1’][‘m’])

#pandas聚合之apply 对分组进行现有的运算和自定义运算
df = DataFrame(np.random.randint(1,9,(4,4)),columns=list(‘abcd’))
print(df)
#对所有数据进行操作
def func(x):
return x+10
print(df.apply(func)) #将数据一列列加进来进行计算，然后返回
print(df[‘a’].apply(func))
print(df.apply(lambda x:x.max(),axis=1)) #axis=0表示每一列(默认)，axis=1表示每一行
#自定义操作
data = DataFrame(np.random.randint(1,10,(4,4)),columns=list(‘abcd’))
def func2(x,arg_txt):
return str(x)+arg_txt
print(df[‘a’].apply(func2,args=(‘haha’,)))

#10.数据透视 pivot_table 通过一个或多个键对数据进行聚合，并根据行列上的分组键将数据分配到各个矩形区域
df1 = DataFrame({
‘data1’:np.random.randint(1,9,5),
‘data2’:np.random.randint(1,9,5),
‘key1’:list(‘aabba’),
‘key2’:[‘one’,‘one’,‘two’,‘one’,‘two’]
})
#通过key1分组，查看data1,data2的平均值,最大值
df01 = df1.pivot_table(values=[‘data1’,‘data2’],index=[‘key1’],columns=[‘key2’],aggfunc=[np.mean,np.max])
print(df01)

df1 = DataFrame({
‘address’:[‘上海’,‘北京’,‘上海’,‘北京’,‘北京’,‘上海’,‘北京’,‘上海’,‘北京’,‘上海’],
‘age’:[19,19,18,20,20,18,19,20,18,19],
‘money’:[8000,8500,7000,9000,10000,9500,7500,8800,9300,12000],
‘name’:[‘joe’,‘susan’,‘anne’,‘black’,‘molica’,‘rona’,‘tom’,‘lili’,‘candy’,‘mandy’],
‘sex’:[‘m’,‘w’,‘w’,‘m’,‘m’,‘w’,‘m’,‘w’,‘w’,‘m’]
})
#根据地区进行分组，查看平均工资和年龄
df2 = df1.groupby(‘address’)[‘age’,‘money’].mean()
print(df2)
#根据年龄进行分组，查看平均工资
df3 = df1.groupby(‘age’)[‘money’].mean()
print(df3)
#根据性别进行分组，查看平均工资
df4 = df1.groupby(‘sex’)[‘money’].mean()
print(df4)
#先根据地区，然后再根据性别进行分组，查看各地区不同性别的平均值
df5 = df1.groupby([‘address’,‘sex’])[‘money’].mean()
print(df5)