pandas 的学习和使用（二）

最新推荐文章于 2021-01-12 07:31:42 发布
最新推荐文章于 2021-01-12 07:31:42 发布
阅读量242 收藏
点赞数
分类专栏： pandas python 文章标签： pandas
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangxiaodong88/article/details/79353682
版权

排序 排名

from pandas import Series, DataFrame

print("series 排序")
x = Series(range(4), index=['b', 'a', 'c', 'd'])
print(x)
# series 排序
# b    0
# a    1
# c    2
# d    3
# dtype: int64
print(x.sort_index())
# a    1
# b    0
# c    2
# d    3
# dtype: int64
print(x.sort_values()) # 按值排序
# b    0
# a    1
# c    2
# d    3
# dtype: int64


print("dataframe 按索引排序")
frame = DataFrame(numpy.arange(8).reshape((2, 4)),
                  columns=list('ABCD'),
                  index=['b', 'a']
                  )

print(frame)
# dataframe 按索引排序
#    A  B  C  D
# b  0  1  2  3
# a  4  5  6  7
print(frame.sort_index()) # 根据行索引来排序
#    A  B  C  D
# a  4  5  6  7
# b  0  1  2  3
print(frame.sort_index(axis=1)) # 根据列索引来排序
#    A  B  C  D
# b  0  1  2  3
# a  4  5  6  7
print(frame.sort_index(axis=1, ascending=False)) # 按行索引降序排列
#    D  C  B  A
# b  3  2  1  0
# a  7  6  5  4
print("按列的值排序")
print(frame.sort_values(by='B' )) # 按列的值排序
# 按列的值排序
#    A  B  C  D
# b  0  1  2  3
# a  4  5  6  7
print(frame.sort_values(by='B', ascending=False)) # 按列的值降序排列
#    A  B  C  D
# a  4  5  6  7
# b  0  1  2  3
frame = DataFrame({'b': [4, 7, -3, 2], 'a': [0, 1, 0, 1]})
print(frame)
#    a  b
# 0  0  4
# 1  1  7
# 2  0 -3
# 3  1  2
print(frame.sort_values(by='b'))# 按照b 列的值进行排序
#    a  b
# 2  0 -3
# 3  1  2
# 0  0  4
# 1  1  7
print(frame.sort_values(by=['a', 'b'])) # 先a 后b 进行列的值的排序
#    a  b
# 2  0 -3
# 0  0  4
# 3  1  2
# 1  1  7

排名： 根据值的大小 / 出现次数来进行排名，得到一组排名值： rank函数

这里写图片描述

obj = Series([4, 2, 0, 4], index=['a', 'b', 'c', 'd'])
print('rank排名：默认按照值的升序， 排名从1 开始')
# 以值从小到大来赋值排名c:0(1) b:2(2) a:4(3) d:4(4)
print(obj.rank())
#a    3.5
#b    2.0
#c    1.0
#d    3.5
#dtype: float64

#注释：
    rank 表示在这个数在原来的Series中排第几名，有相同的数，取其排名平均（默认）作为值。
    这里4 有相同的数 ，一个4排第3名一个4排第4名， 那么这两个的4 的排名都是取平均值 （4+3）/2 =3.5 排名都是3.5

直接rank() 函数是要求平均值的

print(obj.rank(method='first')) # 按照出现顺序排名不求平均值
#a    3.0
#b    2.0
#c    1.0
#d    4.0
#dtype: float64

print(obj.rank(ascending=False, method='max'))# 逆序，并取排名值最大值
#a    2.0
#b    3.0
#c    4.0
#d    2.0
#dtype: float64

分析： 首先 进行排序 ，排序后的结果 # a:4(1) d:4(2) b:2(3) c:0(4)， 然后按照排名最大的值取， 比如 a,d 值都是4 取排名最大的 ，4 排名最大的是2 所以a, d 都是2   b 和c 的排名是3, 4

frame = DataFrame({
    'b': [4.3, 7, -3, 2],
    'a': [0, 1, 0, 1],
    'c': [-2, 5, 8, -2.5]
})
print(frame)
   a    b    c
0  0  4.3 -2.0
1  1  7.0  5.0
2  0 -3.0  8.0
3  1  2.0 -2.5
print(frame.rank()) # 默认按照列排名
     a    b    c
0  1.5  3.0  2.0
1  3.5  4.0  3.0
2  1.5  1.0  4.0
3  3.5  2.0  1.0
print(frame.rank(axis=1)) # 按照行进行排名，默认升序
 a    b    c
0  2.0  3.0  1.0
1  1.0  3.0  2.0
2  2.0  1.0  3.0
3  2.0  3.0  1.0

# 注意：
  都是先排序（默认升序）， 然后进行排名

索引重复情况

print(" 重复索引: 进行两次索引")
obj = Series([0, 1,2,3,4], index=['a', 'a', 'b', 'b', 'c'])
print(obj.index.is_unique)
#重复索引: 进行两次索引
#False

df = DataFrame(numpy.arange(12).reshape((4, 3)), index=['a', 'a', 'b', 'b'])
print(df)
#   0   1   2
#a  0   1   2
#a  3   4   5
#b  6   7   8
#b  9  10  11
print(df.ix['b'].ix[0]) # 两次行索引
#0    6
#1    7
#2    8

print(df.ix['b'].ix[1]) # 两次行索引
#0     9
#1    10
#2    11
#Name: b, dtype: int32

# 汇总和计算描述统计

常用方法选项：
这里写图片描述

常用汇总统计函数 I：
这里写图片描述

常用汇总统计函数 II：
这里写图片描述


print("求和")
df = DataFrame([[1, numpy.nan], [7,4], [numpy.nan, numpy.nan], [0, 1]],
               index=['a', 'b', 'c', 'd'],
               columns=['one', 'two']
               )
 print(df)
 #   one  two
#a  1.0  NaN
#b  7.0  4.0
#c  NaN  NaN
#d  0.0  1.0
print(df.sum()) # 按列求和
#one    8.0
#two    5.0
#dtype: float64
# 注意：排除缺失值， skipna 默认值为true


print(df.sum(skipna=False))
# one   NaN
# two   NaN
# dtype: float64
print(df.sum(axis=1)) #按行求和
# a     1.0
# b    11.0
# c     0.0
# d     1.0
# dtype: float64

print(df.sum(axis=1, skipna=False)) #按行求和

# a     NaN
# b    11.0
# c     NaN
# d     1.0
# dtype: float64

print("求平均数")
print(df.mean()) # 按列求平均数
#one    2.666667
#two    2.500000
#dtype: float64

print(df.mean(axis=1)) # 按行求平均值， 排除缺失值， 为true
#a    1.0
#b    5.5
#c    NaN
#d    0.5
#dtype: float64
print(df.mean(axis=1, skipna=False)) # 按行求平均值，不排除缺失值
#a    NaN
#b    5.5
#c    NaN
#d    0.5
#dtype: float64



print(" 计算每一列最大值的索引")
print(df.idxmax())
# one    b
# two    b
# dtype: object

print("计算每一列的累加和")
print(df.cumsum())
#    one  two
# a  1.0  NaN
# b  8.0  4.0
# c  NaN  NaN
# d  8.0  5.0

print("对DataFrame 每列计算汇总统计")
print(df.describe())
#             one      two
# count  3.000000  2.00000
# mean   2.666667  2.50000
# std    3.785939  2.12132
# min    0.000000  1.00000
# 25%    0.500000  1.75000
# 50%    1.000000  2.50000
# 75%    4.000000  3.25000
# max    7.000000  4.00000

print("series 汇总")
obj = Series([2, 4, 8, 4], index=['a', 'a', 'b', 'c'])
print(obj)
# a    2
# a    4
# b    8
# c    4
# dtype: int64

print(obj.describe())
# count    4.000000
# mean     4.500000
# std      2.516611
# min      2.000000
# 25%      3.500000
# 50%      4.000000
# 75%      5.000000
# max      8.000000
# dtype: float64

去重和成员出现计数

主要方法：
这里写图片描述

print("去重")
obj = Series(['c', 'a', 'd', 'b', 'b', 'c'])
print(obj.unique())
# ['c' 'a' 'd' 'b']
print(obj.value_counts())
# b    2
# c    2
# d    1
# a    1
# dtype: int64
print("判断元素存在")
mask = obj.isin(['b', 'c'])
print(mask)
# 0     True
# 1    False
# 2    False
# 3     True
# 4     True
# 5     True
# dtype: bool
print("只打印包含的元素b 和c")
print(obj[mask])
# 0    c
# 3    b
# 4    b
# 5    c
# dtype: object


import pandas as pd
data = DataFrame({
    'Qu1': [1, 3, 4, 3, 4],
    'Qu2': [2, 3, 1, 2, 3],
    'Qu3': [1, 15, 2, 4, 4]
})
print(data)
#   Qu1  Qu2  Qu3
#0    1    2    1
#1    3    3   15
#2    4    1    2
#3    3    2    4
#4    4    3    4
print("计算每列数字出现的次数， 缺失值为0")
print(data.apply(pd.value_counts).fillna(0))
#    Qu1  Qu2  Qu3
#1   1.0  1.0  1.0
#2   0.0  2.0  1.0
#3   2.0  2.0  0.0
#4   2.0  0.0  2.0
#15  0.0  0.0  1.0
print("计算每行中各个数字出现的次数， 缺失值为0")
print(data.apply(pd.value_counts, axis=1).fillna(0))
#   1    2    3    4    15
#0  2.0  1.0  0.0  0.0  0.0
#1  0.0  0.0  2.0  0.0  1.0
#2  1.0  1.0  0.0  1.0  0.0
#3  0.0  1.0  1.0  1.0  0.0
#4  0.0  0.0  1.0  2.0  0.0
# 注意： 按列的话前面 的索引就是这些值， 后面是这些值出现的次数， 比如 这里的15  一下子就看出规律了

处理缺失数据

• NaN（Not a Number）表示浮点数和非浮点数组中的缺失数据，None也被当作NA处理。

处理缺失数据函数：

这里写图片描述

• dropna 函数：DatFrame默认丢弃任何含有缺失值的行。how参数控制行为，axis参数选择轴，thresh参数控制NaN数量的要求。

• fillna函数： inplace参数决定返回新对象还是就地修改

print("作为Null 处理的值")
string_data = Series(['a', 'b', numpy.nan, 'd'])
print(string_data)
# 作为Null 处理的值
# 0      a
# 1      b
# 2    NaN
# 3      d
print(string_data.isnull()) # 判断值是不是为空
# 0    False
# 1    False
# 2     True
# 3    False
# dtype: bool
string_data[0] = None
print(string_data)
# 0    None
# 1       b
# 2     NaN
# 3       d
# dtype: object
print(string_data.isnull())

from numpy import nan as NA
print("丢弃缺失数据NaN")
# 0     True
# 1    False
# 2     True
# 3    False
# dtype: bool
data = Series([1, NA, 3.5, NA, 7])
print(data.dropna())
# 丢弃缺失数据NaN
# 0    1.0
# 2    3.5
# 4    7.0
# dtype: float64



print(" 对丢弃的NaN 的处理")
data = DataFrame([[1., 6.5, 3.], [1., NA, NA], [NA, NA, NA], [NA, 6.5, 3.]])
print(data)
#      0    1    2
# 0  1.0  6.5  3.0
# 1  1.0  NaN  NaN
# 2  NaN  NaN  NaN
# 3  NaN  6.5  3.0
print("默认只要某行有NA 就全部删除")
print(data.dropna())
#      0    1    2
# 0  1.0  6.5  3.0
print("某行 全部为NA才全部删除")
print(data.dropna(how='all'))
#      0    1    2
# 0  1.0  6.5  3.0
# 1  1.0  NaN  NaN
# 3  NaN  6.5  3.0
data[0] = NA
print(data)
#     0    1    2
# 0 NaN  6.5  3.0
# 1 NaN  NaN  NaN
# 2 NaN  NaN  NaN
# 3 NaN  6.5  3.0
print(data.dropna(axis=1, how='all')) # 某列全部为NA 就全部删除
#      1    2
# 0  6.5  3.0
# 1  NaN  NaN
# 2  NaN  NaN
# 3  6.5  3.0



data = DataFrame(numpy.arange(21).reshape((7, 3)))
print(data)
#     0   1   2
# 0   0   1   2
# 1   3   4   5
# 2   6   7   8
# 3   9  10  11
# 4  12  13  14
# 5  15  16  17
# 6  18  19  20
data.ix[:4, 1] = NA # 根据行名， 行号， 列进行选择， 包括行4   0-4 行 列号是1 的 这些数据
data.ix[:2, 2] = NA
print(" 改变后的data ")
print(data)
#     0     1     2
# 0   0   NaN   NaN
# 1   3   NaN   NaN
# 2   6   NaN   NaN
# 3   9   NaN  11.0
# 4  12   NaN  14.0
# 5  15  16.0  17.0
# 6  18  19.0  20.0
print("每行至少有2个NA 元素则删除")
print(data.dropna(thresh=2))
#     0     1     2
# 3   9   NaN  11.0
# 4  12   NaN  14.0
# 5  15  16.0  17.0
# 6  18  19.0  20.0
print("填充0")
df= DataFrame(numpy.arange(9).reshape((3,3)))
print(df)
#    0  1  2
# 0  0  1  2
# 1  3  4  5
# 2  6  7  8
df.ix[:1, 1] = NA
df.ix[:2, 2] = NA
print(df)
#    0    1   2
# 0  0  NaN NaN
# 1  3  NaN NaN
# 2  6  7.0 NaN
print(df.fillna(0)) # 默认inplace 为False
#    0    1    2
# 0  0  0.0  0.0
# 1  3  0.0  0.0
# 2  6  7.0  0.0
print(df) # 这样打印后还是没有修改
#    0    1   2
# 0  0  NaN NaN
# 1  3  NaN NaN
# 2  6  7.0 NaN
print("就地修改")
df.fillna(0, inplace=True)
print(df)
#    0    1    2
# 0  0  0.0  0.0
# 1  3  0.0  0.0
# 2  6  7.0  0.0


df = DataFrame(numpy.arange(9).reshape((3,3)))
df.ix[:1, 1] = NA
df.ix[:2, 2] = NA
print(df)
#    0    1   2
# 0  0  NaN NaN
# 1  3  NaN NaN
# 2  6  7.0 NaN
print("不同行列填充不同的值")
print(df.fillna({1:0.5, 2:-1})) # 第一列填充0.5 第二列填充 -1
#    0    1    2
# 0  0  0.5 -1.0
# 1  3  0.5 -1.0
# 2  6  7.0 -1.0
print(df.fillna(method='bfill')) # 向前填充
#    0    1   2
# 0  0  7.0 NaN
# 1  3  7.0 NaN
# 2  6  7.0 NaN
print(df.fillna(method='bfill', limit=1)) # 向前填充， 只可向前填充一步
#    0    1   2
# 0  0  NaN NaN
# 1  3  7.0 NaN
# 2  6  7.0 NaN

print("用统计数据填充")
data = Series([1, NA, 2, NA, 3])
print(data.fillna(data.mean())) # 使用平均数进行填充
# 0    1.0
# 1    2.0
# 2    2.0
# 3    2.0
# 4    3.0
# dtype: float64

多层次化索引

对Series和DataFrame进行多层次的索引MultiIndex，通过stack与unstack进行Series和DataFrame的变换。

import numpy
from pandas import Series, DataFrame, MultiIndex

print("series 的多层索引")
data = Series(numpy.arange(8), index=[['a', 'a', 'b', 'b',  'c', 'c', 'd','d'],
                       [1, 2, 1, 2, 1, 2, 1,2]])

print(data)
# series 的多层索引
# a  1    0
#    2    1
# b  1    2
#    2    3
# c  1    4
#    2    5
# d  1    6
#    2    7
# dtype: int32
print(data.index)
# MultiIndex(levels=[['a', 'b', 'c', 'd'], [1, 2]],
#            labels=[[0, 0, 1, 1, 2, 2, 3, 3], [0, 1, 0, 1, 0, 1, 0, 1]])
print(data.b)
# 1    2
# 2    3
# dtype: int32
print(data.d)
# 1    6
# 2    7
# dtype: int32
print("闭区间")
print(data['b':'c'])
# 闭区间
# b  1    2
#    2    3
# c  1    4
#    2    5
# dtype: int32

print("数组索引不区分标签")
print(data[:2])
# 数组索引不区分标签
# a  1    0
#    2    1
# dtype: int32

print("将serise转化为DataFrame")
print(data.unstack())
# 将serise转化为DataFrame
#    1  2
# a  0  1
# b  2  3
# c  4  5
# d  6  7

print("将dataframe 转化为series")

print(data.unstack().stack())
# 将dataframe 转化为series
# a  1    0
#    2    1
# b  1    2
#    2    3
# c  1    4
#    2    5
# d  1    6
#    2    7
# dtype: int32


print("dataframe 多层次索引")
frame = DataFrame(numpy.arange(12).reshape((4, 3)),
                  index=[['a', 'a', 'b', 'b'], [1, 2, 1, 2]],
                  columns=[['A', 'A', 'B'], ['A1', 'A2', 'B1']]
                  )

print(frame) # 两层行索引两层列索引
#      A       B
#     A1  A2  B1
# a 1  0   1   2
#   2  3   4   5
# b 1  6   7   8
#   2  9  10  11
print(frame.index)
#MultiIndex(levels=[['a', 'b'], [1, 2]],
 #          labels=[[0, 0, 1, 1], [0, 1, 0, 1]])

#MultiIndex(levels=[['A', 'B'], ['A1', 'A2', 'B1']],
 #          labels=[[0, 0, 1], [0, 1, 2]])

frame.index.names = ['key1', 'key2']
frame.columns.names = ['state', 'more']
print(frame)
# state      A       B
# more      A1  A2  B1
# key1 key2           
# a    1     0   1   2
#      2     3   4   5
# b    1     6   7   8
#      2     9  10  11
print(frame.ix['a', 1]['B'])
#more
#B1    2
#Name: (a, 1), dtype: int32

print(frame.ix['a', 1]['A']['A1'])
# 0
print("直接使用 MultiIndex 创建层次索引结构index")
print(MultiIndex.from_arrays([['A', 'A', 'B'], ['Gree', 'Red', 'Green']],
                             names=['state', 'color']
                             ))
#直接使用 MultiIndex 创建层次索引结构index
#MultiIndex(levels=[['A', 'B'], ['Gree', 'Green', 'Red']],
#           labels=[[0, 0, 1], [0, 2, 1]],
#           names=['state', 'color'])

将索引层进行交换：swaplevel函数。对某个索引层进行排序：sortlevel函数

print("索引层交换")
frame = DataFrame(numpy.arange(12).reshape((4, 3)),
                  index = [['a', 'a', 'b', 'b'], [1, 2, 1, 2]],
                  columns = [['A', 'A', 'B'], ['A1', 'A2', 'B1']])
frame.index.names = ['key1', 'key2']
print(frame)
#            A       B
#           A1  A2  B1
# key1 key2           
# a    1     0   1   2
#      2     3   4   5
# b    1     6   7   8
#      2     9  10  11

frame_swapped = frame.swaplevel('key1', 'key2')
print("交换索引层")
print(frame_swapped)

#            A       B
#           A1  A2  B1
# key2 key1           
# 1    a     0   1   2
# 2    a     3   4   5
# 1    b     6   7   8
# 2    b     9  10  11

print(frame_swapped.swaplevel(0, 1)) # 交换回来
           A       B
          A1  A2  B1
key1 key2           
a    1     0   1   2
     2     3   4   5
b    1     6   7   8
     2     9  10  11



print("对某个索引层进行排序")
print(frame.sort_index(level="key2"))

#            A       B
#           A1  A2  B1
# key1 key2           
# a    1     0   1   2
# b    1     6   7   8
# a    2     3   4   5
# b    2     9  10  11

根据某个索引层进行统计计算

print("根据索引层进行统计")
print(frame.sum(level='key2'))
       A       B
      A1  A2  B1
key2            
1      6   8  10
2     12  14  16

将某列转化为层次的行索引，列名为索引名，列的值为索引值：set_index函数；恢复重置行索引且恢复列：reset_index函数

print("将列索引转换行层次索引")
frame = DataFrame({'a': range(7),
                   'b': range(7, 0, -1),
                    'c':['one', 'one', 'one', 'two', 'two', 'two', 'two'],
                   'd':[0, 1, 2, 0, 1, 2, 3]
                   })

print(frame)
#    a  b    c  d
# 0  0  7  one  0
# 1  1  6  one  1
# 2  2  5  one  2
# 3  3  4  two  0
# 4  4  3  two  1
# 5  5  2  two  2
# 6  6  1  two  3
print(frame.set_index(['c', 'd'])) # 把c d 列索引变成行索引

#        a  b
# c   d      
# one 0  0  7
#     1  1  6
#     2  2  5
# two 0  3  4
#     1  4  3
#     2  5  2
#     3  6  1
print(frame.set_index(['c', 'd'], drop= False)) # 列依然保留
#        a  b    c  d
# c   d              
# one 0  0  7  one  0
#     1  1  6  one  1
#     2  2  5  one  2
# two 0  3  4  two  0
#     1  4  3  two  1
#     2  5  2  two  2
#     3  6  1  two  3

print("恢复列")
frame2 = frame.set_index(['c', 'd'])
print(frame2.reset_index())
#      c  d  a  b
# 0  one  0  0  7
# 1  one  1  1  6
# 2  one  2  2  5
# 3  two  0  3  4
# 4  two  1  4  3
# 5  two  2  5  2
# 6  two  3  6  1
yangxiaodong88
关注
专栏目录
pandas 多进程处理数据框
周迪新的博客
05-17 2533
我假设看到这里的朋友都已经掌握了 apply。 df['new'] = df['old'].apply( 核心函数: def parallelize_dataframe(df, func, **kwargs): CPUs = multiprocessing.cpu_count() num_partitions = CPUs # number of partitions to split dataframe num_cores = CPUs # number of cores o
python pandas 多线程(携程)写入excel
python
04-27 4016
不知道如何优化,写入excel文件依然很慢. # -*- coding: utf-8 -*-# # python 3.6.7 # Description: # Author: zzq # Date: 2020/4/27 import math import threadpool import asyncio import pandas as pd def ...
python pandas excel 多线程_Python数据分析：pandas玩转Excel （一）
weixin_32837047的博客
01-12 1113
1 pandas简介1.Pandas是什么？Pandas是一个强大的分析结构化数据的工具集；它的使用基础是Numpy(提供高性能的矩阵运算)；用于数据挖掘和数据分析，同时也提供数据清洗功能。2.DataFrameDataFrame是Pandas中的一个表格型的数据结构，包含有一组有序的列，每列可以是不同的值类型(数值、字符串、布尔型等)，DataFrame即有行索引也有列索引，可以被看做是由Ser...
pandas apply多线程实现代码
09-16
主要介绍了pandas apply多线程实现代码，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Pandas 获取列名
热门推荐
TH_NUM的博客
05-13 9万+
获取DataFrame的列名是一个比较简单的操作，又以下几个方法： 1.[column for column in df] 2.df.columns.values 返回 array 3.list(df) 4.df.columns 返回Index，可以通过 tolist(), 或者 list（array） 转换为list import pandas as pd from numpy.r...
python学习教程之Numpy和Pandas的使用
09-21
Python中的Numpy和Pandas是两个非常重要的数据分析和科学计算库。Numpy是Python的基础库，专注于高效处理大型多维数组和矩阵。...无论是新手还是经验丰富的开发者，掌握Numpy和Pandas的使用都是至关重要的。
【pandas学习笔记(一)】pandas基本使用
12-21
【pandas学习笔记(一)】pandas基本使用 pandas是Python中广泛使用的数据分析库，它基于NumPy构建，提供了高效的数据结构，如Series（一维数组）和DataFrame（二维表格型数据结构）。pandas的主要功能是进行数据清洗...
数据分析和机器学习库Pandas的使用.ipynb
最新发布
03-24
Pandas 库是一个免费、开源的第三方 Python 库，是 Python 数据分析和机器学习的工具之一。Pandas 提供了两种数据结构，分别是 Series（一维数组结构）与 DataFrame（二维数组结构），极大地增强的了 Pandas 的数据...
pandas库学习报告.docx
04-11
### pandas库学习报告 #### 一、pandas简介 pandas 是一个强大的 Python 库，专为数据分析设计。它建立在 NumPy 基础之上，提供了一系列高级数据结构和数据分析工具，使得处理数据变得更加简单高效。pandas 的核心...
python pandas读取csv后，获取列标签
keep forward, go, go, go
04-09 1万+
在Python中，经常会去读csv文件，如下import pandas as pdimport numpy as npdf = pd.read_csv("path.csv")data = np.array(df.loc[:,:])通过这种方式得到的data，不包含第一行，一般来说，第一行即使列标签。那么如何获取第一行的内容呢。如下column_headers = list(df.columns.v...
pandas取列号_pandas操作,按序号取列,按条件筛选,df格式转换等
weixin_39682897的博客
12-19 2646
这几天遇到比较多的dataframe操作,频繁使用,在此整理记录下,方便查找.1.num为列的数字序号,name=df.columns[num],返回的是column的字符串名字,df[name]=df[df.columns[num]]=df['xxx']2.关于panda中dataframe的与&运算,详情见我的博客,链接:https://www.cnblogs.com/Rvin/p/9...
关于线程中的pandas计算速度问题tqdm
NLP与推荐算法
06-15 551
问题来源：Youtube2016数据处理 下面简化后复现 RuntimeError: cannot join thread before it is started 上面错误暂时不管。避免了。 从500多的bit/s的速度到下面的结果，现在速度还在降低 最后的速度可能会到40多，我想知道这是为啥子 最后用时估计会在一个小时 不用线程发现速度也是很慢，那么就是程序写的不行了。毕竟才10来万的数据 我看看怎么改。 这个问题先记着：点击日志中用户信息及最近点击item构成的多行数.
pandas取列号_pandas生成dataframe，获取行和列，得到series
weixin_39967938的博客
12-19 1297
lib不用就忘：一、创建dataframeC:\Windows\system32>pythonPython 3.5.4 (v3.5.4:3f56838, Aug 8 2017, 02:17:05) [MSC v.1900 64 bit (AMD64)] on win32Type "help", "copyright", "credits" or "license" for more inf...
pandas apply 函数 多进程实现
大学之道，在明明德
05-08 1万+
@creat_data: 2017-05-08 @author: huangyongye 前言: 在进行数据处理的时候，我们经常会用到 pandas 。但是 pandas 本身好像并没有提供多进程的机制。本文将介绍如何来自己实现 pandas (apply 函数)的多进程执行。其中，我们主要借助 joblib 库，这个库为python 提供了一个非常简洁方便的多进程方法。所以，本文将按照下面的
py批量存入mysql，pandas一些操作，循环内加线程
小木的博客
09-02 469
写在前面的话： 总结一下近期实习学到的内容，还有在做项目中遇到的问题及其解决方式。都是为了学习巩固，有什么不对的地方还希望各位大佬指正出来，不胜感激。 1. 批量存入数据库 与 excute() 方法对应的是 excutemany() """ :param sql: sql语句，values 部分正常写，insert 最好加上ignore，这样会跳过错误的数据 :param data: tuple; data 必须是元组，而且其内存的数据顺序与values部分对应，这样存的时候才能对应到相应字段 """ #
用 Python 做数据处理必看：12 个使效率倍增的 Pandas 技巧（上下）
sherri_du的博客
04-06 1万+
http://datartisan.com/article/detail/81.html 导语 Python正迅速成为数据科学家偏爱的语言，这合情合理。它拥有作为一种编程语言广阔的生态环境以及众多优秀的科学计算库。如果你刚开始学习Python，可以先了解一下Python的学习路线。 在众多的科学计算库中，我认为Pandas对数据科学运算最有用。Pandas，加上Scikit-lear
还在抱怨pandas运行速度慢？这几个方法会颠覆你的看法
weixin_34383618的博客
02-12 1233
作者：xiaoyu 微信公众号：Python数据科学 知乎：python数据分析师 前言 当大家谈到数据分析时，提及最多的语言就是Python和SQL。Python之所以适合数据分析，是因为它有很多第三方强大的库来协助，pandas就是其中之一。pandas的文档中是这样描述的： “快速，灵活，富有表现力的数据结构，旨在使”关系“或”标记“数据的使用既简单又直观。” 我们知道pandas的...
python数据分析_Python数据分析—数据排序
weixin_39711867的博客
12-07 745
在对海量数据进行分析的过程中，可能需要对数据进行排序操作。本节教大家如何在python中对数据框进行一些排序操作。本文目录总结sort_values函数的用法按年龄对行进行升序排列按年龄对行进行降序排列按年龄升序身高降序排列数据框对列进行排序注意：本文沿用数据分析第一课【Python数据分析—数据建立】里的数据框date_frame：1 总结sort_values函数的用法pyth...
Python数据分析：深入讲解Numpy和Pandas的使用
Pandas的核心数据结构包括Series（一维带标签的数据结构）和DataFrame（二维表格型数据结构）。这两个数据结构都具有索引，使得数据操作更加灵活。Pandas不仅继承了Numpy的数组运算特性，还增加了许多特有的功能，如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值