Python之Pandas库学习（三）：数据处理

最新推荐文章于 2024-07-28 15:46:11 发布
最新推荐文章于 2024-07-28 15:46:11 发布
阅读量110 收藏
点赞数
文章标签： python 数据结构与算法
原文链接：http://www.cnblogs.com/fightfordream/p/7072966.html
版权

1. 合并

可以将其理解为SQL中的JOIN操作，使用一个或多个键把多行数据结合在一起。

1.1. 简单合并

参数on表示合并依据的列,参数how表示用什么方式操作(默认是内连接)。

>>> frame1 = pd.DataFrame( {'id':['ball', 'pencil', 'pen', 'mug', 'ashtray'], 'color':['white', 'red', 'red', 'black', 'green'], 'brand':['OMG', 'ABC', 'ABC', 'POD', 'POD']} )
>>> frame1
  brand  color       id
0   OMG  white     ball
1   ABC    red   pencil
2   ABC    red      pen
3   POD  black      mug
4   POD  green  ashtray
>>> frame2 = pd.DataFrame( {'id':['pencil', 'pencil', 'ball', 'pen'], 'brand':['OMG', 'POD', 'ABC', 'POD']} )
>>> frame2
  brand      id
0   OMG  pencil
1   POD  pencil
2   ABC    ball
3   POD     pen
>>> frame2.columns = ['brand', 'nid']

可以指定左边用哪一列合并,右边用哪一列合并
>>> pd.merge(frame1, frame2, left_on='id', right_on='nid')
  brand_x  color      id brand_y     nid
0     OMG  white    ball     ABC    ball
1     ABC    red  pencil     OMG  pencil
2     ABC    red  pencil     POD  pencil
3     ABC    red     pen     POD     pen

根据多个列进行,并且以外连接方式合并
>>> frame2.columns = ['brand', 'id']
>>> pd.merge(frame1, frame2, on=['id', 'brand'], how='outer')
  brand  color       id
0   OMG  white     ball
1   ABC    red   pencil
2   ABC    red      pen
3   POD  black      mug
4   POD  green  ashtray
5   OMG    NaN   pencil
6   POD    NaN   pencil
7   ABC    NaN     ball
8   POD    NaN      pen

1.2. 根据索引合并

将left_index和right_index设为True
>>> pd.merge(frame1, frame2, right_index=True, left_index=True)
  brand_x  color    id_x brand_y    id_y
0     OMG  white    ball     OMG  pencil
1     ABC    red  pencil     POD  pencil
2     ABC    red     pen     ABC    ball
3     POD  black     mug     POD     pen

使用DataFrame()对象的join()函数进行合并,注意不能有重复的列名
>>> frame2.columns=['brand2', 'id2']
>>> frame1.join(frame2)
  brand  color       id brand2     id2
0   OMG  white     ball    OMG  pencil
1   ABC    red   pencil    POD  pencil
2   ABC    red      pen    ABC    ball
3   POD  black      mug    POD     pen
4   POD  green  ashtray    NaN     NaN

2. 拼接

2.1. NumPy的concatenate()函数

>>> array1 = np.arange(9).reshape((3,3))
>>> array2 = np.arange(9).reshape((3,3))+3
>>> array1
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])
>>> array2
array([[ 3,  4,  5],
       [ 6,  7,  8],
       [ 9, 10, 11]])
>>> np.concatenate([array1,array2])
array([[ 0,  1,  2],
       [ 3,  4,  5],
       [ 6,  7,  8],
       [ 3,  4,  5],
       [ 6,  7,  8],
       [ 9, 10, 11]])
>>> np.concatenate([array1,array2], axis = 1)
array([[ 0,  1,  2,  3,  4,  5],
       [ 3,  4,  5,  6,  7,  8],
       [ 6,  7,  8,  9, 10, 11]])

2.2. Pandas的concat()函数

>>> ser1
1    0.105168
2    0.344241
3    0.798570
4    0.648794
dtype: float64
>>> ser2
5    0.161205
6    0.427794
7    0.813935
8    0.742369
dtype: float64
>>> pd.concat([ser1, ser2])
1    0.105168
2    0.344241
3    0.798570
4    0.648794
5    0.161205
6    0.427794
7    0.813935
8    0.742369
dtype: float64
>>> pd.concat([ser1, ser2], axis = 1)
          0         1
1  0.105168       NaN
2  0.344241       NaN
3  0.798570       NaN
4  0.648794       NaN
5       NaN  0.161205
6       NaN  0.427794
7       NaN  0.813935
8       NaN  0.742369
由上面可以看出concat()默认选项是外连接.

指定为内连接
>>> ser3 = pd.Series(np.random.rand(4), index = [1,2,3,4])
>>> ser3
1    0.599582
2    0.123096
3    0.870401
4    0.635363
dtype: float64
>>> pd.concat([ser1, ser3], axis = 1, join = 'inner')
          0         1
1  0.105168  0.599582
2  0.344241  0.123096
3  0.798570  0.870401
4  0.648794  0.635363

可以用keys参数可以创建等级索引,对列进行合并的话,keys会变成列名
>>> pd.concat([ser1, ser2], keys=['fir','sec'])
fir  1    0.105168
     2    0.344241
     3    0.798570
     4    0.648794
sec  5    0.161205
     6    0.427794
     7    0.813935
     8    0.742369
dtype: float64
>>> pd.concat([ser1, ser2], axis=1, keys=['fir','sec'])
        fir       sec
1  0.105168       NaN
2  0.344241       NaN
3  0.798570       NaN
4  0.648794       NaN
5       NaN  0.161205
6       NaN  0.427794
7       NaN  0.813935
8       NaN  0.742369

3. 组合

使用combine_first()函数。

>>> ser1 = pd.Series(np.random.rand(5), index = [1,2,3,4,5])
>>> ser2 = pd.Series(np.random.rand(5), index = [1,3,5,7,9])
>>> ser1
1    0.426299
2    0.732439
3    0.951809
4    0.955885
5    0.183026
dtype: float64
>>> ser2
1    0.981828
3    0.162136
5    0.364654
7    0.607903
9    0.345988
dtype: float64
>>> ser1.combine_first(ser2)
1    0.426299
2    0.732439
3    0.951809
4    0.955885
5    0.183026
7    0.607903
9    0.345988
dtype: float64
>>> ser2.combine_first(ser1)
1    0.981828
2    0.732439
3    0.162136
4    0.955885
5    0.364654
7    0.607903
9    0.345988
dtype: float64

部分合并使用切片
>>> ser1[:4].combine_first(ser2[:4])
1    0.426299
2    0.732439
3    0.951809
4    0.955885
5    0.364654
7    0.607903
dtype: float64

4. 轴向旋转

4.1. 按等级索引旋转

stack()：把列转换成行。

unstack()：把行转换成列。

>>> frame1 = pd.DataFrame(np.arange(9).reshape(3,3), index=['white', 'black', 'red'], columns=['ball', 'pen', 'pencil'])
>>> frame1
       ball  pen  pencil
white     0    1       2
black     3    4       5
red       6    7       8

>>> ser = frame1.stack()
>>> ser
white  ball      0
       pen       1
       pencil    2
black  ball      3
       pen       4
       pencil    5
red    ball      6
       pen       7
       pencil    8
dtype: int32

>>> ser = frame1.unstack()
>>> ser
ball    white    0
        black    3
        red      6
pen     white    1
        black    4
        red      7
pencil  white    2
        black    5
        red      8
dtype: int32

>>> ser.unstack(0)
       ball  pen  pencil
white     0    1       2
black     3    4       5
red       6    7       8
>>> ser.unstack(1)
        white  black  red
ball        0      3    6
pen         1      4    7
pencil      2      5    8
参数表示对第几层进行操作

4.2. 从"长"向"宽"旋转

有时候一类数据集各列都有数据项，每一列后面的数据和前面有重复，这类数据常为列表形式，将其称为长格式或栈格式。还有一种宽格式，可读性强，存储数据效率更高。因此有时候需要转换。

>>> longframe = pd.DataFrame( {'color':['white', 'white', 'white', 'red', 'red', 'red', 'black', 'black', 'black'], 'item':['ball','pen','mug','ball','pen','mug','ball','pen','mug'],'value':np.random.rand(9)} )
>>> longframe
   color  item     value
0  white  ball  0.657363
1  white   pen  0.209334
2  white   mug  0.878001
3    red  ball  0.674560
4    red   pen  0.278861
5    red   mug  0.393061
6  black  ball  0.956869
7  black   pen  0.217121
8  black   mug  0.611301

>>> wideframe = longframe.pivot('color', 'item')
>>> wideframe
          value                    
item       ball       mug       pen
color                              
black  0.956869  0.611301  0.217121
red    0.674560  0.393061  0.278861
white  0.657363  0.878001  0.209334

>>> longframe = pd.DataFrame( {'color':['white', 'white', 'white', 'red', 'red', 'red', 'black', 'black', 'black'], 'item':['ball','pen','mug','ball','pen','mug','ball','pen','mug'],'value':np.random.rand(9), 'game':np.arange(9)} )
>>> wideframe = longframe.pivot('color', 'item')
>>> wideframe
      game             value                    
item  ball mug pen      ball       mug       pen
color                                           
black    6   8   7  0.122732  0.820089  0.505179
red      3   5   4  0.314163  0.964050  0.670957
white    0   2   1  0.219532  0.665007  0.833881

使用pivot()函数指定两个键，第一个参数的列变成索引名，第二个参数的列变成列名。这样数据的可读性就很高了。

5. 数据转换

5.1. 删除重复元素

使用duplicated()可以获取哪些是重复的，使用drop_duplicates()能够删除重复元素。

>>> frame = pd.DataFrame({'color':['white', 'white', 'red', 'red', 'white'], 'value':[1,2,3,3,2]})
>>> frame
   color  value
0  white      1
1  white      2
2    red      3
3    red      3
4  white      2
>>> frame.duplicated()
0    False
1    False
2    False
3     True
4     True
dtype: bool
>>> frame[frame.duplicated()]
   color  value
3    red      3
4  white      2
>>> frame.drop_duplicates()
   color  value
0  white      1
1  white      2
2    red      3

5.2. 映射

5.2.1. 替换元素replace()

使用replace()可以替换元素。可以传入一个字典，键为旧元素，值为新元素。

>>> frame
   color  value
0  white      1
1  white      2
2    red      3
3    red      3
4  white      2
>>> mp = {'white': 'black', 'red': 'yellow'}
>>> frame.replace(mp)
    color  value
0   black      1
1   black      2
2  yellow      3
3  yellow      3
4   black      2
>>> frame.replace('white', 'black')
   color  value
0  black      1
1  black      2
2    red      3
3    red      3
4  black      2

5.2.2. 添加元素map()

使用map()可以从另外一个数据结构获取元素并将其添加到目标数据结构的列中。

>>> frame
   color  value
0  white      1
1  white      2
2    red      3
3    red      3
4  white      2
>>> dic = {'white':'pure', 'red':'ignite'}

>>> frame['live'] = frame['color'].map(dic)
>>> frame
   color  value    live
0  white      1    pure
1  white      2    pure
2    red      3  ignite
3    red      3  ignite
4  white      2    pure

5.2.3. 重命名轴索引rename()

使用rename()转换轴标签。

>>> frame
   color  value    live
0  white      1    pure
1  white      2    pure
2    red      3  ignite
3    red      3  ignite
4  white      2    pure
>>> newindex = {0:'zero', 3:'three'}
>>> newcolumns = {'color':'col', 'value':'val'}
>>> frame.rename(index = newindex, columns = newcolumns)
         col  val    live
zero   white    1    pure
1      white    2    pure
2        red    3  ignite
three    red    3  ignite
4      white    2    pure

# 如果要将原来的frame替换掉，设置inplace参数为True
>>> frame.rename(index = newindex, columns = newcolumns, inplace = True)
>>> frame
         col  val    live
zero   white    1    pure
1      white    2    pure
2        red    3  ignite
three    red    3  ignite
4      white    2    pure

6. 离散化和面元划分

6.1. cut()

cut()函数可以将一个数组中的数据切分成几个部分。

将数据分为几个部分，就称为几个面元。

cut(数据数组,面元数组)

>>> array = [3, 60, 43, 100, 52, 36, 37, 0, 80, 1000] # 数组
>>> bins = [0, 25, 50, 75, 100] # 切割成什么
>>> cat = pd.cut(array, bins)
>>> cat # cat是一个Categorical(类别型)类型
[(0, 25], (50, 75], (25, 50], (75, 100], (50, 75], (25, 50], (25, 50], NaN, (75, 100], NaN]
Categories (4, interval[int64]): [(0, 25] < (25, 50] < (50, 75] < (75, 100]]
>>> cat.codes # 数组原来的元素数据第几个面元
array([ 0,  2,  1,  3,  2,  1,  1, -1,  3, -1], dtype=int8)
>>> pd.value_counts(cat) # 每个面元有多少个元素
(25, 50]     3
(75, 100]    2
(50, 75]     2
(0, 25]      1
dtype: int64

还可以不指定面元的界限，直接传入一个整数参数，cut()会按照指定的数字，将元素划分为相应的几部分。

>>> pd.cut(array, 5)
[(-1.0, 200.0], (-1.0, 200.0], (-1.0, 200.0], (-1.0, 200.0], (-1.0, 200.0], (-1.0, 200.0], (-1.0, 200.0], (-1.0, 200.0], (-1.0, 200.0], (800.0, 1000.0]]
Categories (5, interval[float64]): [(-1.0, 200.0] < (200.0, 400.0] < (400.0, 600.0] < (600.0, 800.0] < (800.0, 1000.0]]

6.2. qcut()

cut()函数划分得到的面元，每个面元的数量不同。而qcut()可以保证每个面元的数量相同，且每个面元的区间大小不等。

>>> pd.qcut(array, 5)
[(-0.001, 29.4], (55.2, 84.0], (40.6, 55.2], (84.0, 1000.0], (40.6, 55.2], (29.4, 40.6], (29.4, 40.6], (-0.001, 29.4], (55.2, 84.0], (84.0, 1000.0]]
Categories (5, interval[float64]): [(-0.001, 29.4] < (29.4, 40.6] < (40.6, 55.2] < (55.2, 84.0] < (84.0, 1000.0]]
>>> cat = pd.qcut(array, 5)
>>> pd.value_counts(cat)
(84.0, 1000.0]    2
(55.2, 84.0]      2
(40.6, 55.2]      2
(29.4, 40.6]      2
(-0.001, 29.4]    2
dtype: int64

6.3. 异常值检测和过滤

使用any()函数可以对每一列应用筛选条件。

>>> frame = pd.DataFrame(np.random.randn(10, 3))
>>> frame
          0         1         2
0 -0.466623 -0.180515 -1.632522
1  0.928587  1.478555 -1.170217
2  1.366825 -0.266165  0.307137
3  1.811664  0.155917 -1.847898
4 -0.451448  1.668134 -0.584497
5 -0.819943 -0.028708  1.119363
6  0.039233 -0.316006 -1.232731
7 -2.721860  0.369594  0.482038
8 -0.320213 -0.456954  1.305954
9 -0.159289 -1.138182  0.452671

>>> frame.describe()
               0          1          2
count  10.000000  10.000000  10.000000
mean   -0.079307   0.128567  -0.280070
std     1.272859   0.861058   1.155481
min    -2.721860  -1.138182  -1.847898
25%    -0.462829  -0.303546  -1.217102
50%    -0.239751  -0.104611  -0.138680
75%     0.706248   0.316174   0.474696
max     1.811664   1.668134   1.305954

>>> (np.abs(frame) > frame.std())
       0      1      2
0  False  False   True
1  False   True   True
2   True  False  False
3   True  False   True
4  False   True  False
5  False  False  False
6  False  False   True
7   True  False  False
8  False  False   True
9  False   True  False

>>> (np.abs(frame) > frame.std()).any(0) # 参数0和参数1分别是axis参数的值
0    True
1    True
2    True

>>> (np.abs(frame) > frame.std()).any(1)
0     True
1     True
2     True
3     True
4     True
5    False
6     True
7     True
8     True
9     True
dtype: bool
    
>>> frame[(np.abs(frame) > frame.std()).any(1)] # 第五行被筛选掉了
          0         1         2
0 -0.466623 -0.180515 -1.632522
1  0.928587  1.478555 -1.170217
2  1.366825 -0.266165  0.307137
3  1.811664  0.155917 -1.847898
4 -0.451448  1.668134 -0.584497
6  0.039233 -0.316006 -1.232731
7 -2.721860  0.369594  0.482038
8 -0.320213 -0.456954  1.305954
9 -0.159289 -1.138182  0.452671

7. 排序

使用permutation()函数可以创建一个随机顺序的数组。

使用take()函数可以采用新的索引次序。

>>> frame = pd.DataFrame(np.arange(25).reshape(5,5))
>>> frame
    0   1   2   3   4
0   0   1   2   3   4
1   5   6   7   8   9
2  10  11  12  13  14
3  15  16  17  18  19
4  20  21  22  23  24
>>> order = np.random.permutation(5)
>>> order
array([2, 4, 1, 0, 3])
>>> frame.take(order)
    0   1   2   3   4
2  10  11  12  13  14
4  20  21  22  23  24
1   5   6   7   8   9
0   0   1   2   3   4
3  15  16  17  18  19

# 对部分操作
>>> frame.take([3, 4, 1])
    0   1   2   3   4
3  15  16  17  18  19
4  20  21  22  23  24
1   5   6   7   8   9

随机取样

>>> len(frame) # frame的行数
5
>>> sample = np.random.randint(0, len(frame), size = 2) # 分别是取值下限，取值上限，和取值的个数
>>> sample
array([1, 1])
>>> frame.take(sample)
   0  1  2  3  4
1  5  6  7  8  9
1  5  6  7  8  9

8. 字符串处理

  • join()

    '拼接字符'.join(string数组)

>>> strings = ['a', 'b', 'd', 'e', 'F']
>>> strings
['a', 'b', 'd', 'e', 'F']
>>> ';'.join(strings)
'a;b;d;e;F'

  • split() 和 strip()

    string.split('切割字符')

    string.strip() 去掉多余的空白字符(包括换行)

>>> string = '233 ,     546'
>>> string
'233 , \t546'
>>> string.split(',')
['233 ', ' \t546']

>>> for s in string.split(','):
...   print(s.strip())
... 
233
546

  • find(s) 和 count(s) 和 replace(s1, s2)

    分别是找到子串的下标，子串出现了多少次，将s1替换为s2.

  • 正则表达式

    click here

9. 数据聚合

GroupBy 内部机制：SPLIT-APPLY-COMBINE(分组-用函数处理-合并结果)。

group[list1].groupby(list2)

list1表示要处理的数据的列名,list2表示根据哪些键(列名)处理。

>>> frame = pd.DataFrame( {'color': ['red', 'white', 'red', 'green', 'white'], 'object': ['pen', 'pencil', 'mug', 'ruler', 'pen'], 'price': [2, 3, 4, 1, 100]} )
>>> frame
   color  object  price
0    red     pen      2
1  white  pencil      3
2    red     mug      4
3  green   ruler      1
4  white     pen    100
>>> group = frame['price'].groupby(frame['color']) # 得到一个GroupBy对象
>>> group.groups
{'red': Int64Index([0, 2], dtype='int64'), 'green': Int64Index([3], dtype='int64'), 'white': Int64Index([1, 4], dtype='int64')}
>>> group.mean()
color
green     1.0
red       3.0
white    51.5
Name: price, dtype: float64
>>> group.sum()
color
green      1
red        6
white    103
Name: price, dtype: int64

  • agg()函数

    还可以对组使用自定义函数，只需要使用agg(函数名)就行了。

>>> group = frame.groupby(frame['color'])
>>> def fun(series):
...   return series.max() - series.min()
... 
>>> group['price'].agg(fun)
color
green     0
red       2
white    97
Name: price, dtype: int64
  • transfrom()函数
>>> frame = pd.DataFrame( {'color':['white', 'red', 'green', 'white', 'green'], 'val1':[5,6,7,8,9], 'val2':[15,16,17,18,19]} )
>>> frame
   color  val1  val2
0  white     5    15
1    red     6    16
2  green     7    17
3  white     8    18
4  green     9    19
>>> frame.groupby('color').transform(np.sum) # 函数必须是一个聚合函数
   val1  val2
0    13    33
1     6    16
2    16    36
3    13    33
4    16    36

  • apply()函数

    将键值分类再处理。

>>> frame['status'] = ['up', 'down', 'up', 'down', 'down']
>>> frame
   color  val1  val2 status
0  white     5    15     up
1    red     6    16   down
2  green     7    17     up
3  white     8    18   down
4  green     9    19   down
>>> frame.groupby(['color', 'status']).apply(lambda x: x.max())
              color  val1  val2 status
color status                          
green down    green     9    19   down
      up      green     7    17     up
red   down      red     6    16   down
white down    white     8    18   down
      up      white     5    15     up

​

转载于:https://www.cnblogs.com/fightfordream/p/7072966.html

weixin_30915951
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
python数据分析之pandas（10）离散化和元面划分
hang on it more longer
02-18 246
为对连续数据进行分区，pandas提供了一些函数： 1. 区间划分 >>> import pandas as pd >>> results = [1,3,4,8,2,5] >>> bins = [1,3,9] >>> cat = pd.cut(results, bins) 注意：这里的bins最小值要小于results中的值...
pandas Series DataFrame 综合学习（2）
yangxiaodong88的博客
06-15 207
函数应用映射 numpy 的ufuncs(元素级数组方法) 也可以用来操作pandas对象 frame = DataFrame(np.arange(12.).reshape((4, 3)), columns=list('bde'), index=['one', 'two', 'three', 'four'] ) pr...
pandas数据操作总结
qq_51283283的博客
03-27 155
pandas数据结构 Series：索引在左，值在右 DataFrame Series： 属性： values（值）：obj.values index（索引）：obj.index name：obj4.name = 'population' ​ obj4.index.name = 'state' 创建Series： obj = pd.Series([4, 7, -5, 3]) obj2 = pd.Series([4, 7, -5, 3], ..
【python】numpy库ndarray多维数组的的运算：np.abs(x)、np.sqrt(x)、np.modf(x)等
brucewong0516的博客
01-28 7万+
numpy库提供非常便捷的数组运算，方便数据的处理。 1、数组与标量之间可直接进行运算 In [45]: a Out[45]: array([[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]]) In [46]: a/5 Out[46]: array([[ 0. , 0.2, 0.4, 0.6],
Series与DataFrame 函数应用和映射
Mikowoo007的博客
07-21 416
函数应用和映射 from pandas import Series,DataFrame import pandas as pd import numpy as np frame = DataFrame(np.random.randn(4,3), columns=list('bde'),index=['Utah','Ohio','Texas','Oregon'])...
Python之 Pandas数据处理
01-24
在Python的世界里，Pandas库是进行数据处理和分析的核心工具，尤其适合初学者和专业人士。Pandas提供了高效且易用的数据结构，如DataFrame和Series，使得数据操作变得简单直观。 1. **Pandas库的安装与数据读写** ...
Python 数据处理库 pandas 入门教程基本操作
09-20
pandas是一个Python语言的软件包，在我们使用Python语言进行机器学习编程的时候，这是一个非常常用的基础编程库。本文是对Python 数据处理库 pandas 入门教程,非常不错，感兴趣的朋友一起看看吧
使用Python(pandas库)处理csv数据
12-22
首先，我们需要导入必要的库，包括os用于文件操作，pandas用于数据处理，以及numpy用于数值计算。在代码中，我们看到`import os`, `import pandas as pd`, 和 `import numpy as np`这三行代码分别导入了这三个库。 ...
python数据分析：Pandas库教程
07-14
Pandas是一个强大的Python数据分析库，由Wes McKinney在2008年创建。它提供了高性能、易用的数据结构和数据分析工具，特别适合于处理表格数据。Pandas中最主要的数据结构是Series和DataFrame，它们使得数据处理和...
Python-Pandas：Pandas数据处理笔记本
02-18
**Python-Pandas：Pandas数据处理笔记本** 在Python的数据科学领域，Pandas库是一个不可或缺的工具，它提供了高效的数据操作接口，使得数据清洗、转换、分析变得简单易行。本项目集成了两个实际应用示例，分别是...
python/pandas/numpy数据分析（十）-函数, rank,重复索引
python|大数据爱好者Alvin
12-28 1万+
DataFrame的apply方法，将函数应用到行或者列形成的一维数组上.frame=pd.DataFrame(np.random.randn(4,3),columns=list('bde'),index=['Utha','Ohio','Texas','Oregon']) frame . b d e Utha -0.683356 -0.577942 -0.022012
Numpy数据类型对象（dtype）
呆码
01-30 2万+
常用方法 #记住引入numpy时要是用别名np，则所有的numpy字样都要替换 #查询数值类型 &gt;&gt;&gt;type(float) dtype('float64') # 查询字符代码 &gt;&gt;&gt; dtype('f') dtype('float32') &gt;&gt;&gt; dtype('d') dtype('float64') # 查询双字符代码 &gt;&gt...
Python之Numpy库常用函数大全（含注释）
人工智能技术学习与分享
05-02 5万+
前言：最近学习Python，才发现原来python里的各种库才是大头！ 于是乎找了学习资料对Numpy库常用的函数进行总结，并带了注释。在这里分享给大家，对于库的学习，还是用到时候再查，没必要死记硬背。 PS：本博文摘抄自中国慕课大学上的课程《Python数据分析与展示》，推荐刚入门的同学去学习，这是非常好的入门视频。 Numpy是科学计算库,是一个强大的N维数组对象ndarray，是广播功能函数
numpy.random.randn()与rand()的区别
热门推荐
木子木泗的博客
05-13 13万+
numpy中有一些常用的用来产生随机数的函数，randn()和rand()就属于这其中。 numpy.random.randn(d0, d1, …, dn)是从标准正态分布中返回一个或多个样本值。 numpy.random.rand(d0, d1, …, dn)的随机样本位于[0, 1)中。 代码：import numpy as np arr1 = np.random.randn(2,4) p
快醒醒，别睡了!...讲《数据分析pandas库》了—/—＜4＞
qq_64603703的博客
07-27 673
详细解说数据分析pandas库中的常用方法
全网最详细Gradio教程系列5——Gradio Client: python
shao918516的博客
07-26 780
程序部署完成后，如何将Gradio App作为API访问使用呢，这就用到Gradio Client。本章讲解Gradio Client的三种使用方式：python、javascript和curl，受字数限制，所以分三篇博客发布。 使用Gradio Python Client非常易于将Gradio应用程序作为API使用，本节讲述gradio_client安装、如何连接Gradio应用程序、查看可用API及其使用方式、job及session等用法。 通过Gradio Python Cli
全面解析 SnowNLP：中文文本处理、情感分析
有勇气的牛排博客
07-24 487
SnowNLP 是一个专门用于处理中文文本的 Python库。分词情感分析关键词提取文本分类拼音转换繁体转简体词相似度计算等测试环境：Python3.10.9尚未测出该功能text = "有勇气的牛排写的文章通俗易懂，爱了爱了"文本分类使用的是 SnowNLP 的情感分析模型。
Chapter 18 Python异常
最新发布
2302_80253507的博客
07-28 769
在Python中，异常是一种特定的对象，能够在程序运行过程中被抛出和处理。有效地管理异常不仅可以增强程序的稳定性，还可以提高用户体验，使程序能够优雅地处理错误情况。本章详细讲解了异常的基本概念以及如何捕获和处理异常。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值