i，大家好。
我們在日常工作中，會用Excel來進行數據分析，尤其是數值處理。今天我們來分享一下Excel中都有哪些最常用的數值處理函數。這里面包括了常用的四舍五入、向上向下取整、奇偶判斷、絕對值；中值、眾數、隨機數、組合數等。另外，這些函數看似簡單，但是也有些需要主要的地方。同時，有些函數會有意想不到的用法。可以說，本文將總結數值類處理函數的常用用法，掌握它們將使得我們更為全面地理解Excel的函數，提升工作效率。
1.round函數
round英文本意是圓的，整數的，因此在Excel中用于對數據進行指定位數的四舍五入。
語法：=round(數值,四舍五入的位數)
=ROUND(number,num_digits)
說明：四舍五入位數為0時，進行取整四舍五入；位數為正時，表示在小數點右邊保留小數多少位進行四舍五入；位數為負時，表示在小數點左邊進行四舍五入（例如整十整百等四舍五入操作）
注意點：當四舍五入位數為負時的特殊作用，這種用法可以對一些預測的數據進行取整十整百等的處理。
2.int函數
Int是integer的縮寫，表示整數的意思，因此int會對數值進行向下的取整處理，即取值的結果不大于原來的數值
語法：=int(數值),=int()
說明：
注意點：向下取整，尤其是負數是的結果需要理解一下。
3.rounddown函數
Round+down，向下指定位數舍入。
語法：=rounddown(數值，舍入后的數值位數)
說明：
注意點：注意當舍入位數為0時，與int函數返回結果的區別，尤其是值為負值時。
4.roundup函數
Round+up，向上指定位數舍入。
語法：=roundup(數值,舍入后的數值位數)
說明：roundup與rounddown相對應，一個是向下，一個向上。
注意點：roundup和rounddown函數與是否負數無關，都是按照正數的方式進行指定位數舍入。
5.ceiling函數
Ceiling是天花板，函數意思是按基數進行指定倍數的向上舍入。
語法：=CEILING(數值, 基數)，=CEILING(number,significance)
說明：函數的處理機制是用數值除以基數得到一個倍數，然后將倍數向上取整，取整后再乘以基數得到最終結果。
=ceiling(8,3)，返回結果9。首先8/3=2.666..，倍數取整后得到3，向上取整倍數3乘以基數3得到結果9。
注意點：和int類似，注意負數時的函數執行情況。如果除出來的倍數是負數，向上取整就是向0的方向取整。-2.3取整后就是-2。
6.floor函數
floor是地板的意思，函數意思是按基數進行指定倍數的向下舍入。
語法：=floor(數值, 基數)，=floor(number,significance)
說明：函數的處理機制是用數值除以基數得到一個倍數，然后將倍數向下取整，取整后再乘以基數得到最終結果。
=floor(8,3)，返回結果6。首先8/3=2.666..，倍數取整后得到2，向上取整倍數2乘以基數3得到結果6。
注意點：和int類似，注意負數時的函數執行情況。如果除出來的倍數是負數，向下取整就是逆向0的方向取整。-2.66取整后就是-3。
Floor和Ceiling函數，在新的Excel版本中提供了另外兩個函數：floor.math和ceiling.math的兩個升級函數，兩個函數都新增了一個mode參數，用于控制當數值為負數時，控制舍入的方向，朝0或反向0的方向進行舍入。
7.abs函數
Abs函數就是對數值進行絕對值取值
語法：=abs(數值)
說明：
8.rand函數
rand，random的縮寫，隨機的意思，函數會參數一個0-1的隨機數。
語法：=rand()，無參數
9.randbetween函數
Rand+between，隨機產生一個范圍內的整數
語法：=randbetween(最小整數，最大整數)
說明：
=randbetween(1,100)，返回1到100的隨機整數
注意點：
那么產生1-100的隨機數怎么辦?=randbetween(1,100)+rand()
10.trunc函數
Trunc函數用于將數字的小數部分截去，返回整數。或者我們也可以指定保留幾位小數，超出部分會被截去。
這個函數類似于rounddown函數
語法：=trunc(數值,[保留位數])，當取整時，可以不寫保留位數。
注意點：這個函數只是截取函數，本身不做任何方向的舍入。
11.isodd 和 iseven函數
Is+odd，表示是否是基數，同理is+even表是否是偶數。
語法：=isood(數值)，=iseven(數值)。由于是判斷函數，兩個函數都返回True 或者False。
注意點：可以外層用if，內部判斷條件用這兩個函數來進行判斷，并顯示奇數或者偶數。這兩個函數也有其它的替代的處理方式，比如用mod進行求余處理。
12. mod函數
Mod函數用于求余數。
語法：=mod(被除數，除數)，返回兩者的余數。
注意點：
Mod本身是用于求余數，但是我們用一個遞增的整數去除以一個固定的數，就會得到一組循環的遞增的余數。
例如，我們用mod(row(),3)就會循環得到0,1,2的余數。假定我們需要每隔2行進行單元格底色填充，我們就可以用條件格式進行設置。當條件格式的公式mod(row(),3)=2時，則填充底色。可以嘗試一下，這是一種非常有趣的用法。
13. MEDAIN函數
中位數函數，用于求一組數中的中位數
語法：=medain(數值1, [數值2], ...)
說明：
假設A1:A6單元格的值分別是1,2,3,4,5,6
那么=median(A1:A6)，返回值為3.5。因為當數據系列是偶數個時，中位數會取順序排列的中間兩個數據的均值，即本例中的(3+4)/2=3.5
注意點：
Median函數可以有其它一些擴展用法。
例如：
假設我們有一組考試成績的數值，要求是低于60分的按60分計，高于100分的按100分計，60-100分的維持原狀。
一般做法肯定是用if進行嵌套處理。假設A2是存放的分值數據，則判斷公式：=if(A2<60,60,if(A2>100,100,A2))。這里用到了2層判斷。
但是這里我們也可以用medain函數進行處理，即公式：=median(A2,60,100)
邏輯上我們來理清一下：
靈活使用這些數值函數，將會大大提高我們的數值數據處理效率。
以上，是今日分享的內容。
我是華哥。每日精進，不負光陰韶華。
贈人玫瑰，手留余香。歡迎評論、點贊、關注，轉發。
在當下 AI 迅猛發展的時期，Python 憑借其簡潔易讀的語法以及強大的表現力，深受程序員與科學家的青睞。本文旨在展示 Python 僅用 10 行代碼便能完成復雜數學運算的強大能力，涵蓋向量加法、點積、矩陣乘法、矩陣轉置以及線性系統求解器等諸多方面。
回想最初使用 Python 時，NumPy 或 SymPy 尚未出現。那時，研究常借助 MatLab，快速原型設計依賴 Delphi……甚至還會在 Prolog 中進行符號計算。那時的 Python 類似優化版的 Perl，但并非研究人員的首選。
不過，用它編寫程序頗具趣味，我因而選擇以 Python 來實現論文中的部分實驗，其中涉及一些線性代數的內容。起初，我采用類似 Pascal 風格的嵌套循環程序，感覺較為枯燥，然而隨著對 Python 研究的深入，有趣的一面逐漸展現。
某一時刻，我察覺到這門語言絕非僅能編寫嵌套循環，于是開始更深入地探索，而非局限于論文所需——這或許是我所做的最佳“錯誤”決定。
Python 以其友好的學習曲線著稱，但這也可能帶來問題。您可以用 Python 編寫類似 Pascal、C++ 或 Lisp 的程序，但只有以 Python 特有的方式編寫，方能充分發揮其優勢。
好在，即便僅掌握 Python 的基礎知識，可能會錯失精彩部分，但用戶體驗依然良好。
為闡釋這一點，我選取了線性代數領域。按理說，Python 有眾多出色的庫可處理線性代數，因此無需重新實現文中提及的內容。而我選擇線性代數，旨在證明 Python 中以少量代碼表達豐富含義的語法是完全可行的（免責聲明：為保證可讀性，部分代碼示例未嚴格限制在一行內，示例中的所有縮進純粹是為了提升閱讀體驗）。
def scaled(A, x):
B=list()
for i in range(len(A)):
B.append( A[i] * x )
return B
這種寫法雖無過錯，也有其優點，例如總能找到一行設置斷點，但確實顯得有些“冗長”。在 Python 中，您可以簡潔地寫成：
def scaled(A, x): return [ai*x for ai in A]
然后其運行效果如下：
List comprehension
[1.0, 4.0, 3.0]
* 2.0
[,...
Step 1
[1.0, 4.0, 3.0]
* 2.0
[2.0,...
Step 2
[1.0, 4.0, 3.0]
* 2.0
[2.0, 8.0,...
Step 3
[1.0, 4.0, 3.0]
* 2.0
[2.0, 8.0, 6.0]
不過，列表解析并非 Python 所獨有，Haskell 和 Clojure 也具備類似功能，甚至 C# 的 LINQ 也為范圍提供了特殊語法。鮮為人知的是，Python 還支持字典解析和元組解析。
>>> [2*v for v in [1.0, 2.0, 3.0]]
[2.0, 4.0, 6.0]
>>> {k:2*v for k, v in {0:1.0, 1:4.0, 2:3.0}.items()}
{0: 2.0, 1: 8.0, 2: 6.0}
>>> tuple(2*v for v in (1.0, 4.0, 3.0))
(2.0, 8.0, 6.0)
>>> A=[1, 2, 3]
>>> B=('a', 'b', 'c')
>>> C={1:'a', 2:'b', 3:'c'}
>>> D=xrange(123)
>>> zip(A, B, C, D)
[(1, 'a', 1, 0), (2, 'b', 2, 1), (3, 'c', 3, 2)]
同樣，您可以用一行代碼實現向量加法。
def sum_of(A, B): return [ai+bi for (ai, bi) in zip(A, B)]
對于兩組列表，這能夠如同拉鏈一般將數據壓縮在一起。
List zipping
A=[1.0, 4.0, 3.0]
B=[7.0, 3.0, 1.0]
zip(A, B)=[...
Step 1
A=[1.0, 4.0, 3.0]
B=[7.0, 3.0, 1.0]
zip(A, B)=[(1.0, 7.0),...
Step 2
A=[1.0, 4.0, 3.0]
B=[7.0, 3.0, 1.0]
zip(A, B)=[(1.0, 7.0), (4.0, 3.0),...
Step 3
A=[1.0, 4.0, 3.0]
B=[7.0, 3.0, 1.0]
zip(A, B)=[(1.0, 7.0), (4.0, 3.0), (3.0, 1.0)]
def dot_of(A, B): return sum([ai*bi for (ai, bi) in zip(A, B)])
然而，有時簡單的求和并不足夠。例如在處理浮點數時，可能會遭遇一些惱人的小誤差。為了更加便利，Python 提供了另一個求和函數，能夠對部分求和進行操作，從而獲取更精確的輸出。
>>> [0.1]*10
[0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1]
>>> sum([0.1]*10)
0.9999999999999999
>>> import math
>>> math.fsum([0.1]*10)
1.0
def identity(n):
return [[1.0 if i==j else 0.0
for j in range(n)]
for i in range(n)]
這實際上是一個包含條件表達式的嵌套列表解析，結果如下：
Conditional expression: 0==0
j=0
[[1.0,... i=0
Conditional expression: 1!=0
j=1
[[1.0, 0.0,... i=0
Conditional expression: 2!=0
j=2
[[1.0, 0.0, 0.0],... i=0
Conditional expression: 0!=1
j=0
[[1.0, 0.0, 0.0],
[0.0,... i=1
Conditional expression: 1==1
j=1
[[1.0, 0.0, 0.0],
[0.0, 1.0,... i=1
Conditional expression: 2!=1
j=2
[[1.0, 0.0, 0.0],
[0.0, 1.0, 0.0],... i=1
Conditional expression: 0!=2
j=0
[[1.0, 0.0, 0.0],
[0.0, 1.0, 0.0],
[0.0,... i=2
Conditional expression: 1!=2
j=1
[[1.0, 0.0, 0.0],
[0.0, 1.0, 0.0],
[0.0, 0.0,... i=2
Conditional expression: 2==2
j=2
[[1.0, 0.0, 0.0],
[0.0, 1.0, 0.0],
[0.0, 0.0, 1.0]] i=2
條件表達式在簡潔性和表達力方面表現出色，但由于它們是表達式，所以不易添加副作用。但并非完全不可能，只是需要一些技巧。在 Python 中，元組計算會從左到右依次計算每個元組元素，所以當您需要在表達式中添加更多內容時，只需使用元組即可。
def identity(n):
return [[1.0 if i==j else (0.0,
sys.stdout.write("i!=j\n")
)[0]
for j in range(n)]
for i in range(n)]
您也不能在表達式中使用 print，因為它們不應具有副作用，但可以使用 sys.stdout.write。
def identity(n):
return [[1.0 if i==j else (0.0,
sys.stdout.write("i!=j\n")
)[0]
for j in range(n)]
for i in range(n)]
同樣的技巧也適用于 lambda 表達式，您可以通過元組讓您的 lambda 表達式盡可能復雜。不過建議若非必要，請勿如此操作。
我猜測肯定會有人反駁說，“您的例子根本無需條件表達式！”的確如此。在 Python 中，您可以顯式地將布爾類型變量轉換為浮點數變量。
def identity(n):
return [[float(i==j) for j in range(n)] for i in range(n)]
這只是風格問題。就個人而言，我更傾向于將事實和數字分開，不這樣做也完全可行。
不過，我們還需解決兩個問題。一個較為簡單：我們期望矩陣是一個列表，而非元組，所以需要通過一個簡單的列表解析來解決。另一個問題則需使用特殊的 Python 語法，它能讓我們將列表轉變為函數參數的元組，此語法便是在矩陣前添加一個星號。
def transposed(A): return [list(aj) for aj in zip(*A)]
領取方式：私信回復666，免費領取資料軟件~