学习Pandas（二）

2022年12月31日下午8:42 • Python • 阅读 35

复习Series结构

Series，由一组数据值和一组标签组成，其中标签与数据值具有对应关系。

一、Series结构创建

pd.Series(data=None, index=None, dtype=None, name=None, copy=False)

data:输入的数据，可以是列表、常量、ndarray数组等。如果是字典，则保持参数顺序。
index:索引值，必须是可散列的（不可变数据类型（str,bytes和数据类型）），并且与数据具有相同的长度，允许使用非唯一索引值。如果未提供，将默认为RangeIndex(0,1,2,…,n)
dtype:输出系列的数据类型，如果未指定，将从数据中推断
copy:表示对data进行拷贝，默认为False,仅影响Series和ndarray数组。

data参数：
例如：

a_list = [3,10,3,4,5]
s1 = pd.Series(a_list)
np_rand = np.arange(1,6)
s2 = pd.Series(np_rand)
a_dic = {'a':1, 'b':2, 'c':3}
s3 = pd.Series(data=a_dic)
print("s1: \n",s1, sep='')
print("="*50)
print("s2:\n",s2, sep='')
print("="*50)
print("s3:\n",s3, sep='')

输出：

s1:
0     3
1    10
2     3
3     4
4     5
dtype: int64
==================================================
s2:
0    1
1    2
2    3
3    4
4    5
dtype: int32
==================================================
s3:
a    1
b    2
c    3
dtype: int64

可以通过index和values属性取得对应的标签和值： s1.index；s1.values
标签存在数值型的数据，不能使用标签的下标获取值;
标签非数值型，可以用标签取数据，也可以用下标取数据.
获取不存在的索引值对应数据，会报错，但是可以赋值，相当于新增数据

index参数:
必须是可散列的（不可变数据类型（str,bytes和数值类型）），与数据具有相同的长度。如果未提供，将默认为RangeIndex(0,1,2,…,n)
1.使用”显示索引”的方法定义索引标签： data = np.array(['a','b','c','d']) s = pd.Series(data,index=[100,101,102,103])
2.当传递的索引值未匹配对应的字典键时，使用NaN（非数字）填充 d = {'a':1, 'b':2, 'c':3} ser = pd.Series(data=d, index=['x','b','z']) #x,z对应的数值以NaN填充

name参数：
以给一个Series对象命名，也可以给一个Series数组中的索引列起一个名字
如：
data1 = pd.Series(a_dic)\n data1.name = "dic_Data"\n data1.index.name = "index_name"

copy参数:
对data进行拷贝，默认为False,仅影响Series和ndarry数组
源数据非Series和ndarray类型时,改变Series数据，源数据不改变。

二、Series的索引/切片

索引：
位置索引和标签索引完全相同，将使用标签索引。没有负的标记索引。

[En]

The location index and the label index are exactly the same, and the label index will be used. There is no negative tag index.

切片：
Series使用标签切片时，其末端是包含的。 s1 = pd.Series([6,7,8,9,10],index = ['a','b','c','d','e']) s1["b":"d"]
Series使用位置切片时，其末端不包含（与python切片一样）。 s = pd.Series([1,2,3,4,5],index=['a','b','c','d','e']) print(s[1:4])

三、Series数据结构基本技巧

1.查看前几条和后几条数据
s.head()#默认查看前5条数据
s.head(1)#默认查看前1条数据
s.tail()# 默认查看后5条数据
2.重新索引 reindex
新索引在上一个索引中不存在，生成新对象时，对应的值，设置为NaN：

s = pd.Series(np.random.rand(5),index=list("abcde"))
s1 = s.reindex(list("cde12"))

设置填充值： s2 = s.reindex(list("cde12"), fill_value=0)
3.对齐运算

如果没对齐得位置则补NaN

s1 = pd.Series(np.random.rand(3),index=["kelly","Anne","T-C"])
s2 = pd.Series(np.random.rand(3), index=["Anne", "Kelly", "Lily"])
s1+s2

4.删除和添加
删除：返回删除后的值，原值不改变，默认Inplace=False s1 = s.drop("a")
想要改变原值： s.drop("a",inplace=True)
添加：直接新增数据即可

新内容：DataFrame数据类型

DataFrame是一个表格型的数据结构， 既有行标签（index),又有列标签（columns),也被称为异构数据表，异构指的是表格中每列的数据类型可以不同，比如：

对于每列数据：

每一列标签对应的数据类型不同。

DataFrame的每一列都可以看成一个Series结构，只不过DataFrame为每列数据值增加了一个列标签，因此DataFrame是在Series基础上演变而来的。

同Series一样，DataFrame自带行标签索引，默认为隐式索引，即从0开始递增，行标签与DataFrame中的数据项一一对应，上述表格行标签从0到3，共4条数据，也可以通过”显示索引”的方式设置行标签。

; 一、创建DataFrame对象

pandas.DataFrame(data=None, index=None, columns=None,dtype=None,copy=None)

data:输入的数据，可以是ndarray,series,list,dict,标量以及一个DataFrame
index:行标签，如果没有传递index值，则默认行标签是RangeIndex（0，1，2，3...n),n代表data元素个数
columns:列标签，如果没有传递columns值，则默认标签是RangeIndex（0，1，2...n)
dtype:要强制的数据类型，只允许使用一种数据类型，如果没有，自行推断。
copy:从输入复制数据。对于dict数据，copy=True,重新复制一份。对于dataFrame或ndarray输入，copy=False.

1.使用普通列表创建:

data = [1,2,3,4]
df = pd.DataFrame(data)
print(df)

输出：

2.使用嵌套列表创建


data = [["xiaowang",20],["Lily",30],["Anne",40]]

df = pd.DataFrame(data)
print(df)

输出：

         0   1
0  xiaowang  20
1      Lily  30
2      Anne  40

分配列标签：

data = [["xiaowang",20],["Lily",30],["Anne",40]]

df = pd.DataFrame(data,columns=['Name','Age'])
print(df)

输出：

     Name  Age
0  xiaowang   20
1      Lily   30
2      Anne   40

3.指定数值元素的数据类型为float

注意：dtype只能设置一个，设置多个列的数据类型，需要使用其他方式

data = [['xiaoming',20,"男",5000],['lily',30,"男",8000],["Anne",40,"女",10000]]

df = pd.DataFrame(data,columns=['Name','Age',"gender","salary"],dtype=int)

print(df)
print(df['salary'].dtype)
print(df['gender'].dtype)

输出：

       Name  Age gender  salary
0  xiaoming   20      男    5000
1      lily   30      男    8000
2      Anne   40      女   10000
int32
object

4.列表嵌套字典创建DataFrame对象

列表嵌套字典可以作为输入数据传递给DataFrame构造函数， 默认情况下，字典的键被用作列名。

data = [{'a':1, "b":2},{"a":5,"b":10,"c":20}]

df = pd.DataFrame(data, index=["first","second"])
print(df)

输出：

        a   b     c
first   1   2   NaN
second  5  10  20.0

注意：如果其中某个元素值缺失，也就是字典的key无法找到对应的value,将使用NaN代替。

如果使用列表嵌套字典创建一个DataFrame对象，可以设置结果需要的那些列。

data = [{'a':1, "b":2},{"a":5,"b":10,"c":20}]
df1 = pd.DataFrame(data,index=["first","second"], columns=['a','b'])

df2 = pd.DataFrame(data,index = ['first','second'], columns=['a','b1'])
print("=========df1========")
print(df1)
print("=========df2========")
print(df2)

输出：

=========df1========
        a   b
first   1   2
second  5  10
=========df2========
        a  b1
first   1 NaN
second  5 NaN

5.字典嵌套列表创建

data字典中，键对应的值元素长度必须相同（也就是列表长度相同）。如果传递了索引，那么索引的长度应该等于数组的长度；如果没有传递索引，那么默认情况下，索引是RangeIndex（0，1，2…n),其中n代表数组长度。

data = {"Name":['关羽','刘备','张飞','曹操'],'Age':[28,34,29,42]}

df = pd.DataFrame(data)
print(df)

print(df.index)

print(df.columns)

输出：

  Name  Age
0   关羽   28
1   刘备   34
2   张飞   29
3   曹操   42
RangeIndex(start=0, stop=4, step=1)
Index(['Name', 'Age'], dtype='object')

添加自定义的行标签：

data = {"Name":['关羽','刘备','张飞','曹操'],'Age':[28,34,29,42]}
index = ["rank1", "rank2", "rank3", "rank4"]
df = pd.DataFrame(data, index=index)
print(df)

print(df.index)

print(df.columns)

输出：

      Name  Age
rank1   关羽   28
rank2   刘备   34
rank3   张飞   29
rank4   曹操   42
Index(['rank1', 'rank2', 'rank3', 'rank4'], dtype='object')
Index(['Name', 'Age'], dtype='object')

6.Series创建DataFrame对象

输出结果的行索引是所有index的合集

d = {'one':pd.Series([1,2,3],index=['a','b','c']),
    'two':pd.Series([1,2,3,4],index=['a','b','c','d'])}
df = pd.DataFrame(d)
print(df)
type(np.NaN)

输出：

  one  two
a  1.0    1
b  2.0    2
c  3.0    3
d  NaN    4
float

注意： 对于one列而言，行索引d没有对应的值，为NaN .

实例：建一个DataFrame结构的对象：

data = {
    "Name":pd.Series(['xiaoming','Lily','Anne']),
    "Age":pd.Series([20,30,40],dtype=float),
    "gender":pd.Series(["男","男","女"]),
    "salary":pd.Series([5000,8000,10000],dtype=float)

}
df = pd.DataFrame(data)
df

输出：

二、列操作DataFrame

DataFrame可以使用列标签来完成数据的选取、添加和删除操作。

1.选取数据列

data = {"Name":['关羽','刘备','张飞','曹操'],'Age':[28,34,29,42]}
index = ["rank1", "rank2", "rank3", "rank4"]
df = pd.DataFrame(data, index=index)
print(df)
print("*"*20)
print(df['Name'])
print("*"*20)
print(df['Age'])

输出：

     Name  Age
rank1   关羽   28
rank2   刘备   34
rank3   张飞   29
rank4   曹操   42
********************
rank1    关羽
rank2    刘备
rank3    张飞
rank4    曹操
Name: Name, dtype: object
********************
rank1    28
rank2    34
rank3    29
rank4    42
Name: Age, dtype: int64

df选取多列：

print("=======df[['Name','Age']]:df选取多列=======")
print(df[['Name','Age']])

print("*"*20)
print(df['Name':'Age'])

输出：

=======df[['Name','Age']]:df选取多列=======
      Name  Age
rank1   关羽   28
rank2   刘备   34
rank3   张飞   29
rank4   曹操   42
********************
Empty DataFrame
Columns: [Name, Age]
Index: []

没有办法直接通过标签位置去获取列： df[1]# 报错

2.列添加

使用columns列索引可以实现添加新的数据列，示例：

d = {'one':pd.Series([1,2,3],index=['a','b','c']),
    'two':pd.Series([1,2,3,4],index=['a','b','c','d'])}
df = pd.DataFrame(d)

print("=======通过Series添加一个新的列======：")
df['three'] = pd.Series([10,20,30],index=['a','b','c'])
print(df)

print("=======将已经存在的数据列相加运算，从而创建一个新的列======：")
df['four'] = df['one']+df['three']
print(df)

输出：

=======通过Series添加一个新的列======：
   one  two  three
a  1.0    1   10.0
b  2.0    2   20.0
c  3.0    3   30.0
d  NaN    4    NaN
=======将已经存在的数据列相加运算，从而创建一个新的列======：
   one  two  three  four
a  1.0    1   10.0  11.0
b  2.0    2   20.0  22.0
c  3.0    3   30.0  33.0
d  NaN    4    NaN   NaN

insert（）方法添加

df.insert(loc, column, value, allow_duplicates=False)

loc:整型，插入索引，必须验证0loclen(列）
column:插入列的标签，类型可以是（字符串/数字/散列对象)
value:数值，Series或者数组
allow_duplicates:允许重复，可以有相同的列标签数据，默认为false

info = [['王杰', 18],['李杰', 19],['刘杰',17]]
df = pd.DataFrame(info,columns=['name','age'])
print(df)

df.insert(2,column='score',value=[91,90,75])
print("=====df.insert插入数据=====")
print(df)

输出：

  name  age
0   王杰   18
1   李杰   19
2   刘杰   17
=====df.insert插入数据=====
  name  age  score
0   王杰   18     91
1   李杰   19     90
2   刘杰   17     75

您可以添加重复的列标签数据：

[En]

You can add duplicate column label data:

df.insert(1,column='score',value=[80,70,90],allow_duplicates=True)
print(df['score'])

输出：

   score  score
0     80     91
1     70     90
2     90     75
  name  score  age  score
0   王杰     80   18     91
1   李杰     70   19     90
2   刘杰     90   17     75

df.insert(1,column='score',value=[80,70,90])

2.删除数据列：

通过del()和pop()都能够删除DataFrame中的数据列，pop有返回值

import pandas as pd
d = {'one':pd.Series([1,2,3],index=['a','b','c']),
    'two':pd.Series([1,2,3,4],index=['a','b','c','d']),
    'three':pd.Series([10,20,30],index=['a','b','c'])}
df = pd.DataFrame(d)
print(df)

del df['one']
print("=========del df['one']==========")
print(df)

res_pop = df.pop('two')
print(df)
res_pop

输出：

   one  two  three
a  1.0    1   10.0
b  2.0    2   20.0
c  3.0    3   30.0
d  NaN    4    NaN
=========del df['one']==========
   two  three
a    1   10.0
b    2   20.0
c    3   30.0
d    4    NaN
   three
a   10.0
b   20.0
c   30.0
d    NaN
a    1
b    2
c    3
d    4
Name: two, dtype: int64

三、行操作DataFrame：

1.标签选取

行操作 需要借助loc属性来完成，按 标签或布尔数组访问一组行和列

d = {'one':pd.Series([1,2,3],index=['a','b','c']),
    'two':pd.Series([1,2,3,4],index=['a','b','c','d'])}
df = pd.DataFrame(d)
print("===========df原始数据========")
print(df)

print("==========标签为b的数据========")
print(df.loc['b'])

输出：

===========df原始数据========
   one  two
a  1.0    1
b  2.0    2
c  3.0    3
d  NaN    4
==========标签为b的数据========
one    2.0
two    2.0
Name: b, dtype: float64

注意： loc允许接受两个参数分别是行和列


df.loc['b','one']

输出：2.0

行和列还可以使用切片


df.loc['b':'d',"one"]

输出：

b    2.0
c    3.0
d    NaN
Name: one, dtype: float64

还可以：

df.loc[['a','b'],['one','two']]

输出：

2.数值型索引和切片

使用数值型索引需要 使用iloc属性
如果直接使用索引，您将首先找到列标签。如果找不到，则会报告错误。该列没有位置索引

[En]

If you use the index directly, you will first find the column label. If you cannot find it, you will report an error. * the column does not have a location index *

1.可以使用iloc:行基于整数位置的按位置选择索引
2.切片操作多行选取

data = {"Name":['关羽','刘备','张飞','曹操'],'Age':[28,34,29,42]}
index = ["rank1", "rank2", "rank3", "rank4"]
df = pd.DataFrame(data, index=index)

print("=========df.iloc[1:3]:========")
print(df.iloc[1:3])

输出：

=========df.iloc[1:3]:========
      Name  Age
rank2   刘备   34
rank3   张飞   29

使用切片直接提取行：

print("=======df[1:3]=======")
print(df[1:3])

输出：

=======df[1:3]=======
      Name  Age
rank2   刘备   34
rank3   张飞   29

4.添加数据行

使用 append()函数，可以将新的数据行添加到DataFrame中，该函数会在行末尾追加数据行

df.append(other, ignore_index=False, verify_integrity=False, sort=False)

将"other"追加到调用者的末尾，返回一个新对象，"other"行中不在调用者中的列将作为新列添加。
other:DataFrame或Series/dict类对象，或这些对象的列表
ignore_index:默认为False,若为True将不适用Index标签
verity_integrity:默认为False，若为True,则在创建具有重复项的索引时引发ValueError
sort:排序

1.追加字典

data = {
    'Name':['关羽','刘备','张飞','曹操'],
    "Age":[28,34,29,42],
    "Salary":[5000,8000,4500,10000]
}
df = pd.DataFrame(data)
d2 = {"Name":"诸葛亮","Age":30}

df3 = df.append(d2,ignore_index=True)
print(df3)

输出：

 Name  Age   Salary
0   关羽   28   5000.0
1   刘备   34   8000.0
2   张飞   29   4500.0
3   曹操   42  10000.0
4  诸葛亮   30      NaN

2.追加Series

d2 = {"Name":"诸葛亮","Age":30}
s = pd.Series(d2, name="a")
df3 = df.append(s)
print(df3)

输出：

Name  Age   Salary
0   关羽   28   5000.0
1   刘备   34   8000.0
2   张飞   29   4500.0
3   曹操   42  10000.0
a  诸葛亮   30      NaN

3.追加列表
如果list是一维的，则以列的形式追加
如果list是二维的，则以行的形式追加
如果list是三维的，只添加一个值
注意：使用append可能会出现相同的index,想避免的话，可以使用ignore_index=True

a_1 = [[10,"20",30]]
df4 = df.append(a_1)
print(df4)

df5 = df.append(a_1,ignore_index=True)
print(df5)

输出：

      0    1     2   Age Name   Salary
0   NaN  NaN   NaN  28.0   关羽   5000.0
1   NaN  NaN   NaN  34.0   刘备   8000.0
2   NaN  NaN   NaN  29.0   张飞   4500.0
3   NaN  NaN   NaN  42.0   曹操  10000.0
0  10.0   20  30.0   NaN  NaN      NaN
      0    1     2   Age Name   Salary
0   NaN  NaN   NaN  28.0   关羽   5000.0
1   NaN  NaN   NaN  34.0   刘备   8000.0
2   NaN  NaN   NaN  29.0   张飞   4500.0
3   NaN  NaN   NaN  42.0   曹操  10000.0
4  10.0   20  30.0   NaN  NaN      NaN

同列名追加：

data = {
    'Name':['关羽','刘备','张飞','曹操'],
    "Age":[28,34,29,42],
    "Salary":[5000,8000,4500,10000]
}
df = pd.DataFrame(data)
a_1 = [[10,"20",30],[2,5,6]]
df2 = pd.DataFrame(a_1, columns=["Name","Age","Salary"])
df4 = df.append(df2)
print(df4)

输出：

Name Age  Salary
0   关羽  28    5000
1   刘备  34    8000
2   张飞  29    4500
3   曹操  42   10000
0   10  20      30
1    2   5       6

新建DataFrame对象

data = [
    [1,2,3,4],
    [5,6,7,8]
]
df = pd.DataFrame(data)
print(df)

list是一维，以列的形式追加

a_1 = [10,20]
df3 = df.append(a_1)
print(df3)

输出：

    0    1    2    3
0   1  2.0  3.0  4.0
1   5  6.0  7.0  8.0
0  10  NaN  NaN  NaN
1  20  NaN  NaN  NaN

ignore_index=True：

a_1 = [10,20]
df3 = df.append(a_1,ignore_index=True)
print(df3)

输出：

    0    1    2    3
0   1  2.0  3.0  4.0
1   5  6.0  7.0  8.0
2  10  NaN  NaN  NaN
3  20  NaN  NaN  NaN

二维加法刚刚给出了一个例子，下面是三维：

[En]

Two-dimensional addition has just been given an example, the following is three-dimensional:

a_1 = [10,20]
df3 = df.append(a_1)
print(df3)

输出：

a_1 = [10,20]
df3 = df.append(a_1)
print(df3)

5.删除数据行

可以使用行索引标签，从DataFrame中删除某一行数据，如索引标签存在重复，将一起被删除，

df = pd.DataFrame([[1,2],[3,4]], columns = ['a','b'])
df2 = pd.DataFrame([[5,6],[7,8]], columns = ['a','b'])
df = df.append(df2)
print("========源数据df=======")
print(df)
df1 = df.drop(0)
print("========修改后的数据df1=======")
print(df1)
print("========源数据df=======")
print(df)

输出：

========源数据df=======
   a  b
0  1  2
1  3  4
0  5  6
1  7  8
========修改后的数据df1=======
   a  b
1  3  4
1  7  8
========源数据df=======
   a  b
0  1  2
1  3  4
0  5  6
1  7  8

四、DataFrame常用的属性和方法

新建一个DataFrame对象：

data = {
    'Name':['关羽','刘备','张飞','曹操'],
    "Age":[28,34,29,42],
    "Salary":[5000,8000,4500,10000]
}
df = pd.DataFrame(data)
df

1.转置T

返回DataFrame的转置，也就是把行和列交换 df.T
输出：

; 2.axes

返回一个 行标签、列标签组成的列表

print(df.axes)
[df.index,df.columns]

输出：

3.dtypes

返回Series， 每一列的数据类型 df.dtypes
输出：

Name      object
Age        int64
Salary     int64
dtype: object

4.empty

返回一个布尔值，判断输出的数据对象是否为空， 若为true则表示对象为空 df.empty
输出： False
若：

empty_df = pd.DataFrame()
empty_df.empty

输出： True
使用场景：

def my_fun(df):

    if not df.empty:
        print("提供的数据正常")
    else:

        print("提供的数据为空")

my_fun(df)

输出： 提供的数据正常

如果给DataFrame数据类型直接判断真假，报错：

5.columns

返回DataFrame所有列标签 df.columns
输出：

Index(['Name', 'Age', 'Salary'], dtype='object')

可以通过df.columns的个数获取DataFrame列个数： len(df.columns)
输出：3

df.columns.size

输出：3

6.shape

返回一个 元组，获取行数和列数，表示了DataFrame维度 df.shape
输出： (4, 3)

row_num,column_num = df.shape
print(row_num,column_num)

输出：

4 3

7.values

以 ndarray数组的形式返回DataFrame中的数据 df.values
输出：

array([['关羽', 28, 5000],
       ['刘备', 34, 8000],
       ['张飞', 29, 4500],
       ['曹操', 42, 10000]], dtype=object)

8.head()&tail()查看数据

获取前3行数据 df.head(3)
输出：

获取后3行数据 df.tail(3)
输出：
学习Pandas（二）

; 9.修改标签名renanem()

DataFrame.rename(index=None, columns=None, inplace=False)

index:修改后的行标签
columns:修改后的列标签
inplace:默认为False，不改变源数据，返回修改后的数据。True更改源数据
可以修改部分行和列

打印df df

修改变量df的行标签: df.rename(index={1:"row2",2:"row3"})

修改变量df的列标签 df.rename(columns = {"Name":"name","Age":"age"})
输出：

再次打印df,源数据不改变 df

添加inplace参数，修改源数据：

df.rename(index={1:"row2",2:"row3"},columns = {"Name":"name","Age":"age"},inplace=True)
df

输出（源数据已改变）：

10.info()函数

用于打印DataFrame的简要摘要， 显示有关DataFrame的信息，包括索引的数据类型dtype和列的数据类型dtype,非空值的数据和内存使用情况

给df追加一组数据


data = {"name":"诸葛亮","age":30}

df = df.append(data, ignore_index = True)
df

查看信息 df.info()
学习Pandas（二）

11.df.sort_index()

sort_index(axis=0, ascending=True, inplace=False)

功能：默认按行标签对所有行进行排序，或按列标签对所有列进行排序，或按指定列或行对行进行排序

[En]

Function: sort all rows by default according to row labels, or sort all columns by column labels, or sort rows according to a specified column or row

注意：df.sort_index()可以完成和df.sort_values()完全相同的功能，但 python更推荐用只用df.sort_index()对”根据行标签”和”根据列标签”排序，其他排序方式用df.sort_values().

axis:0按照行名排序，1按照列名排序
ascending:默认True升序排列；False降序排列
inplace:默认False，否则排序之后的数据直接替换原来的数据。

新建一个DataFrame对象：

df = pd.DataFrame({'b':[1,2,2,3],'a':[4,3,2,1],'c':[1,3,8,2]},index=[2,0,1,3])
df

默认按”行标签”升序排序，或df.sort_index(axis=0，ascending=True)

df.sort_index()

输出：

按”列标签”排序升序

df.sort_index(axis=1)

输出：

设置inplace = True：

df.sort_index(axis=1,inplace = True)
df

输出：

12.df.sort_values()

DataFrame.sort_values(by,axis=0,ascending=True,inplace=False,kind="quicksort",na_position='last')

功能：可按列数据或按行数据排序

[En]

Function: it can be sorted according to column data or row data

注意： 必须指定by参数，即必须指定哪几行或哪几列； 无法根据index名和columns名排序（由sort_index()执行）

 by:str or list of str:如果axis=0,那么by="列名";如果axis=1,那么by="行名"
 axis:{0 or "index",1 or "columns"},default=0,默认按照列排序，即纵向排序；如果为1，则是横向排序。
 ascending：布尔型，是否用排序后的数据框替换现有的数据框。
 na_position:{'first','last'},default 'last',默认缺失值排在最后面

df = pd.DataFrame({'b':[1,2,2,3],'a':[4,3,2,1],'c':[1,3,8,2]},index=[2,0,1,3])
df

输出：

按b列升序排序：


df.sort_values(by='b')

输出：

先按b列降序，再按a列升序排序：

df.sort_values(by=['b','a'],ascending=[False,True])

输出

按行3升序排列 df.sort_values(by=3,axis=1)
输出：

按行3升序，行0降排列：

df.sort_values(by=[3,0],axis=1,ascending=[True,False])

输出：

五、附：

注意：
一组数据，字典的value只有一个值，创建DataFrame会报错

dict_1 = {"Name":"诸葛亮","Age":30}
df = pd.DataFrame(dict_1)
df

修改方案1：将字典的value修改为列表

dict_1 = {"Name":["诸葛亮"],"Age":[30]}
df = pd.DataFrame(dict_1)
df

输出：

修改方案2：创建df时添加一个index参数为[0]

dict_1 = {"Name":["诸葛亮"],"Age":[30]}
df = pd.DataFrame(dict_1,index=[0])
df

输出：

Original: https://blog.csdn.net/qq_43668591/article/details/125776988
Author: 问世间是否此山最高
Title: 学习Pandas（二）

Title: Python计算泊松分布教程

泊松分布描述在给定时间间隔内发生K次事件的概率。

如果给定随机变量X服从泊松分布，那么X恰等于k次的公式为：

P(X=k) = λk * e-λ / k!

参数解释：

λ: 给定时间内发送事件均值
k: 发送事件的次数
e: 常量，近似为 2.71828

泊松分布需要满足以下条件：

[En]

Poisson distribution needs to meet the following conditions:

发生事件次数可数
给定时间内发送次数的平均值是已知的

[En]

the mean of the number of times sent in a given time is known*
每个结果是独立的
传输概率与时间间隔成正比。
[En]
the transmission probability is proportional to the time interval.*

泊松实验的一个例子是每小时在医院分娩的人数。例如，假设一家医院平均每小时生产10个新生儿。这是一个泊松实验，因为它具有以下四个特性：

[En]

An example of the Poisson experiment is the number of people giving birth per hour in a hospital. For example, suppose a hospital gives birth to an average of 10 births per hour. This is a Poisson experiment because it has the following four properties:

实验的成功次数是可以计算的–我们可以计算出生的人数。

[En]

The number of successes in the experiment can be calculated-we can calculate the number of births.

在给定间隔内发生的平均成功次数是已知的–平均每小时10次递送。

[En]

The average number of successes that occur during a given interval is known-an average of 10 deliveries per hour are known.

每个结果都是独立的–母亲在给定时间内分娩的概率是独立的。

[En]

Each result is independent-a mother’s probability of giving birth within a given hour is independent.

成功的概率与间隔的大小成正比-间隔越长，出生的概率越高。

[En]

The probability of success is proportional to the size of the interval-the longer the interval, the higher the probability of birth.

下面解释Python计算泊松分布的几个示例。

生成泊松分布数据

使用poisson.rvs(mu, size) 函数生成服从泊松分布数据，给定均值和样本大小：

from scipy.stats import poisson

data = poisson.rvs(mu=3, size=10)
print(data)

# array([2, 2, 2, 0, 7, 2, 1, 2, 5, 5])

计算泊松分布概率

使用poisson.pmf(k, mu) 和 poisson.cdf(k, mu)函数计算泊松分布相关的概率.

等于某值得概率

一家店平均每天有三个顾客，有可能有一天会有五个人：

[En]

A store has an average of three customers a day, and there is a chance that there will be five people one day:

from scipy.stats import poisson

poisson.pmf(k=5, mu=3)

# &#x7ED3;&#x679C;&#x4E3A; 0.100819

小于某值的概率

某商店平均每天卖7个足球，那么某天卖出足球数量小于5的概率：

from scipy.stats import poisson

# &#x8BA1;&#x7B97;&#x7D2F;&#x79EF;&#x6982;&#x7387;
poisson.cdf(k=4, mu=7)

# &#x7ED3;&#x679C;&#x4E3A; 0.172992

大于某值的概率

某商店平均每天卖15个罐头，则某天卖出罐头超过20听的概率：

from scipy.stats import poisson

# 1&#x51CF;&#x53BB;&#x7D2F;&#x79EF;&#x6982;&#x7387;
1-poisson.cdf(k=20, mu=15)

# &#x7ED3;&#x679C;&#x4E3A; 0.082971

泊松分布直方图

可以通过matplotlib.pyplot画泊松分布直方图：

from scipy.stats import poisson
import matplotlib.pyplot as plt

# &#x751F;&#x6210;10000&#x6837;&#x672C;&#x5927;&#x5C0F;&#x7684;&#x6CCA;&#x677E;&#x5206;&#x5E03;&#x6570;&#x636E;&#x96C6;
x = poisson.rvs(mu=3, size=10000)

# &#x521B;&#x5EFA;&#x6CCA;&#x677E;&#x5206;&#x5E03;&#x76F4;&#x65B9;&#x56FE;
plt.hist(x, density=True, edgecolor='black')
plt.show()

Original: https://blog.csdn.net/neweastsun/article/details/126417204
Author: 梦想画家
Title: Python计算泊松分布教程

原创文章受到原创版权保护。转载请注明出处：https://www.johngo689.com/298541/

转载文章受原作者版权保护。转载请注明原作者出处！

python

【自取】最近整理的，有需要可以领取学习：

Linux核心资料大放送~

全栈面试题汇总（持续更新&可下载）

一个提高学习100%效率的工具！

【超详细】深度学习面试题目！

LeetCode Python刷题答案下载！

LeetCode Java版刷题答案下载！

LeetCode C++ 版本，抓紧保存！

LeetCode GO语言刷题答案下载！

python + Django + MySQL 系列学习

python + Django + MySQL 系列学习文章目录 python + Django + MySQL 系列学习前言一、环境搭建二、学习步骤 * 1.留言板快速开…

Python 2022年12月26日
0040
python导入pygame模块时出错_Pygame模块导入错误？

我还是新来的，所以我希望没问题，但不管怎样： [En] I’m still new here, so I hope it’s okay, but anywa…

Python 2023年1月21日
0047
Apache Flink 作业图 JobGraph 与执行图 ExecutionGraph

由 Flink 程序直接映射成的数据流图（dataflow graph），也被称为逻辑流图（logical StreamGraph）。到具体执行环节时，Flink 需要进一步将逻辑…

Python 2023年1月20日
0020
Python与机器人技术

http://gashero.iteye.com/blog/2157346 Original: https://www.cnblogs.com/luckgopher/p/50739…

Python 2022年8月14日
0080
22. Pandas怎么处理日期索引的缺失

问题：按日期统计的数据，缺失了某天，导致数据不全该怎么补充日期？公众号：蚂蚁学Python 可以用两种方法实现：1、DataFrame.reindex，调整dataframe的索…

Python 2023年1月7日
0028
PYTHON自动化测试模块之pywinauto

PYTHON自动化测试模块之pywinauto一、pywinauto简介pywinauto是一组python模块，用于自动化Microsoft Windows GUI。在最简单的情…

Python 2022年12月25日
0060
【C++】spdlog光速入门，C++logger最简单最快的库

Very fast, header only, C++ logging library. 一个header-only的C++日志库，十分高效且易用。获取安装方式使用样例 #in…

Python 2023年1月30日
0028
6. Python数据类型之浮点数

6. Python数据类型之浮点数文章目录 6. Python数据类型之浮点数 * 1. Python的数据类型 2. 浮点数的定义 3. 浮点数示例 – 3.1 正…

Python 2023年1月10日
0045
Python Pandas 数据分析工具透视表（pivot table）

数据透视表概念数据透视表是Excel中常用的工具，本片文章的重点不是认识数据透视表，所以找了一片文章，供大家参考。>>>Excel学习笔记-数据透视表透视表操…

Python 2023年1月7日
0039
第三章使用 matplotlib 绘制直方图

参考视频：Python线图点图–15分钟详解matplotlib.pyplot.plot #011_哔哩哔哩_bilibili 一、绘图基础 #导入画图包，以及数据包 …

Python 2023年1月14日
0032
深度学习–matplotlib语法介绍

Matplotlib设置坐标轴日期格式绘制双坐标轴 ax2=ax1.twinx() 创建了一个独立的Y轴，共享了X轴。双坐标轴！类似的还有twiny() 设置坐标轴日期格式需…

Python 2023年1月14日
0023
python数据清洗—实战案例（清洗csv文件）

我也是最近才开始这方面的学习，这篇就当作学习的笔记，记录一下学习的过程目录 * – 所以我们现在要解决的问题就是删除列名中的空格 – 接下来要解决的问题就…

Python 2023年1月7日
0033
Python游戏开发入门课程(pygame)学习笔记（01）

import sys,pygame pygame.init() size=w,h=800,400 speed=[1,1] color=0,0,0 fps=100 fclock=py…

Python 2023年1月20日
0025
flask调用主机文件

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

Python 2023年1月6日
0026
关于 .NET 在不同操作系统中 IO 文件路径拼接方法，升级 .NET 7 后注意到的一个知识点

.NET 现在支持跨平台这件事情已经是众所周知的特点了，虽然平台整体支持跨平台了，但是我们的代码如果真的想要实现跨平台运行其实还是有些小细节要注意的，今天想要记录分享的就是关于文…

Python 2023年1月29日
0017
2022年安徽最新交安安全员考试模拟题及答案

百分百题库提供交安安全员考试试题、交安安全员考试真题、交安安全员证考试题库等，提供在线做题刷题，在线模拟考试，助你考试轻松过关。 15.为防止电焊弧光伤害眼睛，应采…

Python 2023年1月23日
0018

2023年 3月
一	二	三	四	五	六	日
		1	2	3	4	5
6	7	8	9	10	11	12
13	14	15	16	17	18	19
20	21	22	23	24	25	26
27	28	29	30	31

学习Pandas（二）

目录

复习Series结构

一、Series结构创建

二、Series的索引/切片

三、Series数据结构 基本技巧

新内容：DataFrame数据类型

; 一、创建DataFrame对象

1.使用普通列表创建:

2.使用嵌套列表创建

3.指定数值元素的数据类型为float

4.列表嵌套字典创建DataFrame对象

5.字典嵌套列表创建

6.Series创建DataFrame对象

二、列操作DataFrame

1.选取数据列

2.列添加

2.删除数据列：

三、行操作DataFrame：

1.标签选取

2.数值型索引和切片

4.添加数据行

5.删除数据行

四、DataFrame常用的属性和方法

1.转置T

; 2.axes

3.dtypes

4.empty

5.columns

6.shape

7.values

8.head()&tail()查看数据

; 9.修改标签名renanem()

10.info()函数

11.df.sort_index()

12.df.sort_values()

五、附：

相关阅读

Title: Python计算泊松分布教程

生成泊松分布数据

计算泊松分布概率

等于某值得概率

小于某值的概率

大于某值的概率

泊松分布直方图

大家都在看

三、Series数据结构基本技巧