65_Pandas显示设置(小数位数、有效数字、最大行/列数等)

2023-10-21 04:30

本文主要是介绍65_Pandas显示设置(小数位数、有效数字、最大行/列数等),希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

65_Pandas显示设置(小数位数、有效数字、最大行/列数等)

本文介绍了使用 print() 函数显示 pandas.DataFrame、pandas.Series 等时如何更改设置(小数点后位数、有效数字、最大行/列数等)。

有关如何检查、更改和重置设置值的详细信息,请参阅下面的文章。设置更改仅在同一代码(脚本)内有效。它不会被永久重写,并在其他代码中再次成为默认设置。即使在同一代码中,您也可以临时更改 with 块中的设置。

这里说明的只是显示时的设置,原始数据值本身不会改变。如果您想对数字进行四舍五入或将其转换为指定格式的字符串,请参阅下面的文章。

  • 63_Pandas中数字的四舍五入

导入以下库。 NumPy 用于生成 pandas.DataFrame。请注意,根据 pandas 的版本,设置的默认值可能会有所不同。

import pandas as pd
import numpy as npprint(pd.__version__)
# 0.23.0

这里我们将解释与显示相关的主要项目。

  • 小数点右边的位数:display. precision
  • 有效数字:display.float_format
  • 关于四舍五入的注意事项
  • 最大显示行数:display.max_rows
  • 最大显示列数:display.max_columns
  • 默认显示的行数和列数:display.show_dimensions
  • 总体最大显示宽度:display.width
  • 每列最大显示宽度:display.max_colwidth
  • 列名显示的右对齐/左对齐:display.colheader_justify

小数点右边的位数:display. precision

小数点后的位数用display. precision设置。 默认为 6,无论整数部分有多少位,小数点以下的位数都将是指定的数字。尽管被省略并显示,原始数据值也保留了后续数字的信息。

print(pd.options.display.precision)
# 6s_decimal = pd.Series([123.456, 12.3456, 1.23456, 0.123456, 0.0123456, 0.00123456])print(s_decimal)
# 0    123.456000
# 1     12.345600
# 2      1.234560
# 3      0.123456
# 4      0.012346
# 5      0.001235
# dtype: float64print(s_decimal[5])
# 0.00123456

根据display. precision的设置值,格式(显示格式)发生变化并变为指数表示法。

pd.options.display.precision = 4print(s_decimal)
# 0    123.4560
# 1     12.3456
# 2      1.2346
# 3      0.1235
# 4      0.0123
# 5      0.0012
# dtype: float64pd.options.display.precision = 2print(s_decimal)
# 0    1.23e+02
# 1    1.23e+01
# 2    1.23e+00
# 3    1.23e-01
# 4    1.23e-02
# 5    1.23e-03
# dtype: float64

如果要控制格式,请使用 display.float_format,如下所述。

有效数字:display.float_format

用display. precision可以设置的是小数点后的位数,如果想指定包括整数部分在内的有效数字(significantdigits)的个数,则使用display.float_format。默认为“None”。

print(pd.options.display.float_format)
# None

display.float_format 指定一个可调用对象(函数、方法等),该对象将浮点float类型转换为任何格式的字符串。基本上,您可以考虑指定字符串方法format()。

格式规范字符串’.[位数]f’可用于指定小数点后的位数,'.[位数]g’可用于指定总位数(有效数字) )。

pd.options.display.float_format = '{:.2f}'.formatprint(s_decimal)
# 0   123.46
# 1    12.35
# 2     1.23
# 3     0.12
# 4     0.01
# 5     0.00
# dtype: float64pd.options.display.float_format = '{:.4g}'.formatprint(s_decimal)
# 0      123.5
# 1      12.35
# 2      1.235
# 3     0.1235
# 4    0.01235
# 5   0.001235
# dtype: float64

如果要显示相同的位数,请使用“.[位数]e”来使用指数表示法。由于整数部分始终为 1 位,因此有效数字为设定的位数 + 1。

pd.options.display.float_format = '{:.4e}'.formatprint(s_decimal)
# 0   1.2346e+02
# 1   1.2346e+01
# 2   1.2346e+00
# 3   1.2346e-01
# 4   1.2346e-02
# 5   1.2346e-03
# dtype: float64

由于可以使用任何格式规范字符串,因此也可以进行左对齐和百分比显示等对齐方式,如下所示。关于如何指定格式等详细信息,请参见上面format()的相关文章。

pd.options.display.float_format = '{: <10.2%}'.formatprint(s_decimal)
# 0   12345.60% 
# 1   1234.56%  
# 2   123.46%   
# 3   12.35%    
# 4   1.23%     
# 5   0.12%     
# dtype: float64

关于四舍五入的注意事项

display. precision 和 display.float_format 对值进行四舍五入,但不是一般四舍五入,而是四舍五入为偶数;例如,0.5 四舍五入为 0。

df_decimal = pd.DataFrame({'s': ['0.4', '0.5', '0.6', '1.4', '1.5', '1.6'],'f': [0.4, 0.5, 0.6, 1.4, 1.5, 1.6]})pd.options.display.float_format = '{:.0f}'.formatprint(df_decimal)
#      s  f
# 0  0.4  0
# 1  0.5  0
# 2  0.6  1
# 3  1.4  1
# 4  1.5  2
# 5  1.6  2

另外,在四舍五入到小数点时,根据该值,可以四舍五入到偶数,也可以四舍五入到奇数。

df_decimal2 = pd.DataFrame({'s': ['0.04', '0.05', '0.06', '0.14', '0.15', '0.16'],'f': [0.04, 0.05, 0.06, 0.14, 0.15, 0.16]})pd.options.display.float_format = '{:.1f}'.formatprint(df_decimal2)
#       s   f
# 0  0.04 0.0
# 1  0.05 0.1
# 2  0.06 0.1
# 3  0.14 0.1
# 4  0.15 0.1
# 5  0.16 0.2

这是由于浮点数的处理造成的。

最大显示行数:display.max_rows

最大显示行数通过display.max_rows 设置。如果行数超过display.max_rows的值,则省略中间部分,显示开头和结尾。 默认值为 60。

print(pd.options.display.max_rows)
# 60df_tall = pd.DataFrame(np.arange(300).reshape((100, 3)))pd.options.display.max_rows = 10print(df_tall)
#       0    1    2
# 0     0    1    2
# 1     3    4    5
# 2     6    7    8
# 3     9   10   11
# 4    12   13   14
# ..  ...  ...  ...
# 95  285  286  287
# 96  288  289  290
# 97  291  292  293
# 98  294  295  296
# 99  297  298  299
# [100 rows x 3 columns]

如果只想显示开头或结尾,请使用 head() 或 tail()。同样在这种情况下,如果行数超过display.max_rows的值,则中间部分被省略。

  • 18_Pandas.DataFrame,取得Series的头和尾(head和tail)
print(df_tall.head(10))
#     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
# 7  21  22  23
# 8  24  25  26
# 9  27  28  29print(df_tall.head(20))
#      0   1   2
# 0    0   1   2
# 1    3   4   5
# 2    6   7   8
# 3    9  10  11
# 4   12  13  14
# ..  ..  ..  ..
# 15  45  46  47
# 16  48  49  50
# 17  51  52  53
# 18  54  55  56
# 19  57  58  59
# [20 rows x 3 columns]

如果将其设置为“None”,则将显示所有行而不省略。

pd.options.display.max_rows = None

最大显示列数:display.max_columns

显示列的最大数量通过display.max_columns 设置。如果列数超过display.max_columns的值,则省略中间部分,显示开头和结尾。 默认为20,如果设置为None,则将显示所有列,不会被省略。

print(pd.options.display.max_columns)
# 20df_wide = pd.DataFrame(np.arange(90).reshape((3, 30)))print(df_wide)
#    0   1   2   3   4   5   6   7   8   9  ...  20  21  22  23  24  25  26  27  \
# 0   0   1   2   3   4   5   6   7   8   9 ...  20  21  22  23  24  25  26  27   
# 1  30  31  32  33  34  35  36  37  38  39 ...  50  51  52  53  54  55  56  57   
# 2  60  61  62  63  64  65  66  67  68  69 ...  80  81  82  83  84  85  86  87   
#    28  29  
# 0  28  29  
# 1  58  59  
# 2  88  89  
# [3 rows x 30 columns]pd.options.display.max_columns = 10print(df_wide)
#    0   1   2   3   4  ...  25  26  27  28  29
# 0   0   1   2   3   4 ...  25  26  27  28  29
# 1  30  31  32  33  34 ...  55  56  57  58  59
# 2  60  61  62  63  64 ...  85  86  87  88  89
# [3 rows x 30 columns]pd.options.display.max_columns = Noneprint(df_wide)
#    0   1   2   3   4   5   6   7   8   9   10  11  12  13  14  15  16  17  18  \
# 0   0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18   
# 1  30  31  32  33  34  35  36  37  38  39  40  41  42  43  44  45  46  47  48   
# 2  60  61  62  63  64  65  66  67  68  69  70  71  72  73  74  75  76  77  78   
#    19  20  21  22  23  24  25  26  27  28  29  
# 0  19  20  21  22  23  24  25  26  27  28  29  
# 1  49  50  51  52  53  54  55  56  57  58  59  
# 2  79  80  81  82  83  84  85  86  87  88  89  

整体显示宽度通过display.width设置。见下文。 另外,在终端中运行时,display.max_columns 的默认值为 0,并且根据终端的宽度自动省略。

默认显示的行数和列数:display.show_dimensions

与前面的示例一样,如果省略了行和列,则行数和列数将显示在末尾,例如[3 行 x 30 列]。 可以使用 display.show_dimensions 配置此行为。默认为“truncate”,只有省略时才会显示行数和列数。

print(pd.options.display.show_dimensions)
# truncatepd.options.display.max_columns = 10print(df_wide)
#    0   1   2   3   4  ...  25  26  27  28  29
# 0   0   1   2   3   4 ...  25  26  27  28  29
# 1  30  31  32  33  34 ...  55  56  57  58  59
# 2  60  61  62  63  64 ...  85  86  87  88  89
# [3 rows x 30 columns]df = pd.DataFrame(np.arange(12).reshape((3, 4)))print(df)
#    0  1   2   3
# 0  0  1   2   3
# 1  4  5   6   7
# 2  8  9  10  11

如果设置为True,则无论是否省略都会始终显示,如果设置为False,则始终隐藏。

pd.options.display.show_dimensions = Trueprint(df_wide)
#    0   1   2   3   4  ...  25  26  27  28  29
# 0   0   1   2   3   4 ...  25  26  27  28  29
# 1  30  31  32  33  34 ...  55  56  57  58  59
# 2  60  61  62  63  64 ...  85  86  87  88  89
# [3 rows x 30 columns]print(df)
#    0  1   2   3
# 0  0  1   2   3
# 1  4  5   6   7
# 2  8  9  10  11
# [3 rows x 4 columns]pd.options.display.show_dimensions = Falseprint(df_wide)
#    0   1   2   3   4  ...  25  26  27  28  29
# 0   0   1   2   3   4 ...  25  26  27  28  29
# 1  30  31  32  33  34 ...  55  56  57  58  59
# 2  60  61  62  63  64 ...  85  86  87  88  89print(df)
#    0  1   2   3
# 0  0  1   2   3
# 1  4  5   6   7
# 2  8  9  10  11

总体最大显示宽度:display.width

总体最大显示宽度通过display.width 设置。 默认值为 80。如果超过该值,就会发生换行。换行符处显示反斜杠 \,如下例所示。 即使display.width为None,也不会显示整个图像。

print(pd.options.display.width)
# 80pd.options.display.max_columns = Noneprint(df_wide)
#    0   1   2   3   4   5   6   7   8   9   10  11  12  13  14  15  16  17  18  \
# 0   0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18   
# 1  30  31  32  33  34  35  36  37  38  39  40  41  42  43  44  45  46  47  48   
# 2  60  61  62  63  64  65  66  67  68  69  70  71  72  73  74  75  76  77  78   
#    19  20  21  22  23  24  25  26  27  28  29  
# 0  19  20  21  22  23  24  25  26  27  28  29  
# 1  49  50  51  52  53  54  55  56  57  58  59  
# 2  79  80  81  82  83  84  85  86  87  88  89  pd.options.display.width = 60print(df_wide)
#    0   1   2   3   4   5   6   7   8   9   10  11  12  13  \
# 0   0   1   2   3   4   5   6   7   8   9  10  11  12  13   
# 1  30  31  32  33  34  35  36  37  38  39  40  41  42  43   
# 2  60  61  62  63  64  65  66  67  68  69  70  71  72  73   
#    14  15  16  17  18  19  20  21  22  23  24  25  26  27  \
# 0  14  15  16  17  18  19  20  21  22  23  24  25  26  27   
# 1  44  45  46  47  48  49  50  51  52  53  54  55  56  57   
# 2  74  75  76  77  78  79  80  81  82  83  84  85  86  87   
#    28  29  
# 0  28  29  
# 1  58  59  
# 2  88  89  pd.options.display.width = Noneprint(df_wide)
#    0   1   2   3   4   5   6   7   8   9   10  11  12  13  14  15  16  17  18  \
# 0   0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18   
# 1  30  31  32  33  34  35  36  37  38  39  40  41  42  43  44  45  46  47  48   
# 2  60  61  62  63  64  65  66  67  68  69  70  71  72  73  74  75  76  77  78   
#    19  20  21  22  23  24  25  26  27  28  29  
# 0  19  20  21  22  23  24  25  26  27  28  29  
# 1  49  50  51  52  53  54  55  56  57  58  59  
# 2  79  80  81  82  83  84  85  86  87  88  89  

每列最大显示宽度:display.max_colwidth

每列的最大显示宽度通过display.max_colwidth 设置。 默认值为 50。

print(pd.options.display.max_colwidth)
# 50df_long_col = pd.DataFrame({'col': ['a' * 10, 'a' * 30, 'a' * 60]})print(df_long_col)
#                                                  col
# 0                                         aaaaaaaaaa
# 1                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
# 2  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa...pd.options.display.max_colwidth = 80print(df_long_col)
#                                                             col
# 0                                                    aaaaaaaaaa
# 1                                aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
# 2  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

每一列都被省略以适应 display.max_colwidth 设置。

df_long_col2 = pd.DataFrame({'col1': ['a' * 10, 'a' * 30, 'a' * 60],'col2': ['a' * 10, 'a' * 30, 'a' * 60]})pd.options.display.max_colwidth = 20print(df_long_col2)
#                   col1                 col2
# 0           aaaaaaaaaa           aaaaaaaaaa
# 1  aaaaaaaaaaaaaaaa...  aaaaaaaaaaaaaaaa...
# 2  aaaaaaaaaaaaaaaa...  aaaaaaaaaaaaaaaa...

列名columns不受display.max_colwidth的影响,不能省略。

df_long_col_header = pd.DataFrame({'a' * 60: ['a' * 10, 'a' * 30, 'a' * 60]})pd.options.display.max_colwidth = 40print(df_long_col_header)
#   aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
# 0                               aaaaaaaaaa                    
# 1           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa                    
# 2  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa...                 

列名显示的右对齐/左对齐:display.colheader_justify

列名显示的右对齐或左对齐通过d​​isplay.colheader_justify 设置。 默认为“right”。如果要将其左对齐,请使用“left”。

print(pd.options.display.colheader_justify)
# rightprint(df_long_col)
#                                        col
# 0                               aaaaaaaaaa
# 1           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
# 2  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa...pd.options.display.colheader_justify = 'left'print(df_long_col)
#   col                                     
# 0                               aaaaaaaaaa
# 1           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
# 2  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa...

这篇关于65_Pandas显示设置(小数位数、有效数字、最大行/列数等)的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/251960

相关文章

第10章 中断和动态时钟显示

第10章 中断和动态时钟显示 从本章开始,按照书籍的划分,第10章开始就进入保护模式(Protected Mode)部分了,感觉从这里开始难度突然就增加了。 书中介绍了为什么有中断(Interrupt)的设计,中断的几种方式:外部硬件中断、内部中断和软中断。通过中断做了一个会走的时钟和屏幕上输入字符的程序。 我自己理解中断的一些作用: 为了更好的利用处理器的性能。协同快速和慢速设备一起工作

Android实现任意版本设置默认的锁屏壁纸和桌面壁纸(两张壁纸可不一致)

客户有些需求需要设置默认壁纸和锁屏壁纸  在默认情况下 这两个壁纸是相同的  如果需要默认的锁屏壁纸和桌面壁纸不一样 需要额外修改 Android13实现 替换默认桌面壁纸: 将图片文件替换frameworks/base/core/res/res/drawable-nodpi/default_wallpaper.*  (注意不能是bmp格式) 替换默认锁屏壁纸: 将图片资源放入vendo

安卓链接正常显示,ios#符被转义%23导致链接访问404

原因分析: url中含有特殊字符 中文未编码 都有可能导致URL转换失败,所以需要对url编码处理  如下: guard let allowUrl = webUrl.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed) else {return} 后面发现当url中有#号时,会被误伤转义为%23,导致链接无法访问

C#实战|大乐透选号器[6]:实现实时显示已选择的红蓝球数量

哈喽,你好啊,我是雷工。 关于大乐透选号器在前面已经记录了5篇笔记,这是第6篇; 接下来实现实时显示当前选中红球数量,蓝球数量; 以下为练习笔记。 01 效果演示 当选择和取消选择红球或蓝球时,在对应的位置显示实时已选择的红球、蓝球的数量; 02 标签名称 分别设置Label标签名称为:lblRedCount、lblBlueCount

pandas数据过滤

Pandas 数据过滤方法 Pandas 提供了多种方法来过滤数据,可以根据不同的条件进行筛选。以下是一些常见的 Pandas 数据过滤方法,结合实例进行讲解,希望能帮你快速理解。 1. 基于条件筛选行 可以使用布尔索引来根据条件过滤行。 import pandas as pd# 创建示例数据data = {'Name': ['Alice', 'Bob', 'Charlie', 'Dav

poj 3723 kruscal,反边取最大生成树。

题意: 需要征募女兵N人,男兵M人。 每征募一个人需要花费10000美元,但是如果已经招募的人中有一些关系亲密的人,那么可以少花一些钱。 给出若干的男女之间的1~9999之间的亲密关系度,征募某个人的费用是10000 - (已经征募的人中和自己的亲密度的最大值)。 要求通过适当的招募顺序使得征募所有人的费用最小。 解析: 先设想无向图,在征募某个人a时,如果使用了a和b之间的关系

poj 3258 二分最小值最大

题意: 有一些石头排成一条线,第一个和最后一个不能去掉。 其余的共可以去掉m块,要使去掉后石头间距的最小值最大。 解析: 二分石头,最小值最大。 代码: #include <iostream>#include <cstdio>#include <cstdlib>#include <algorithm>#include <cstring>#include <c

poj 2175 最小费用最大流TLE

题意: 一条街上有n个大楼,坐标为xi,yi,bi个人在里面工作。 然后防空洞的坐标为pj,qj,可以容纳cj个人。 从大楼i中的人到防空洞j去避难所需的时间为 abs(xi - pi) + (yi - qi) + 1。 现在设计了一个避难计划,指定从大楼i到防空洞j避难的人数 eij。 判断如果按照原计划进行,所有人避难所用的时间总和是不是最小的。 若是,输出“OPETIMAL",若

poj 2135 有流量限制的最小费用最大流

题意: 农场里有n块地,其中约翰的家在1号地,二n号地有个很大的仓库。 农场有M条道路(双向),道路i连接着ai号地和bi号地,长度为ci。 约翰希望按照从家里出发,经过若干块地后到达仓库,然后再返回家中的顺序带朋友参观。 如果要求往返不能经过同一条路两次,求参观路线总长度的最小值。 解析: 如果只考虑去或者回的情况,问题只不过是无向图中两点之间的最短路问题。 但是现在要去要回

poj 2594 二分图最大独立集

题意: 求一张图的最大独立集,这题不同的地方在于,间接相邻的点也可以有一条边,所以用floyd来把间接相邻的边也连起来。 代码: #include <iostream>#include <cstdio>#include <cstdlib>#include <algorithm>#include <cstring>#include <cmath>#include <sta