本地函數計算方法

1. excel引用函數

EXCEL查找與引用函數
1.ADDRESS
用途：以文字形式返回對工作簿中某一單元格的引用。
語法：ADDRESS(row_num，column_num，abs_num，a1，sheet_text)
參數：Row_num是單元格引用中使用的行號;Column_num是單元格引用中使用的列標;Abs_num指明返回的引用類型(1或省略為絕對引用，2絕對行號、相對列標，3相對行號、絕對列標，4是相對引用);A1是一個邏輯值，它用來指明是以A1或R1C1返回引用樣式。如果A1為TRUE或省略，函數ADDRESS返回A1樣式的引用;如果A1為FALSE，函數ADDRESS返回R1C1樣式的引用。Sheet_text為一文本，指明作為外部引用的工作表的名稱，如果省略sheet_text，則不使用任何工作表的名稱。 實例：公式「=ADDRESS(1，4，4，1)」返回D1。
2.AREAS
用途：返回引用中包含的區域個數。 語法：AREAS(reference)。
參數：Reference是對某一單元格或單元格區域的引用，也可以引用多個區域。
注意:如果需要將幾個引用指定為一個參數，則必須用括弧括起來，以免Excel將逗號作為參數間的分隔符。 實例：公式「=AREAS(a2:b4)」返回1，=AREAS((A1:A3，A4:A6，B4:B7，A16:A18))返回4。
3.CHOOSE
用途：可以根據給定的索引值，從多達29個待選參數中選出相應的值或操作。 語法：CHOOSE(index_num，value1，value2，...)。
參數：Index_num是用來指明待選參數序號的值，它必須是1到29之間的數字、或者是包含數字1到29的公式或單元格引用;value1，value2，...為1到29個數值參數，可以是數字、單元格，已定義的名稱、公式、函數或文本。
實例：公式「=CHOOSE(2，"電腦"，"愛好者")返回「愛好者」。公式「=SUM(A1:CHOOSE(3，A10，A20，A30))」與公式「=SUM(A1:A30)」等價(因為CHOOSE(3，A10，A20，A30)返回A30)。
4.COLUMN
用途：返回給定引用的列標。 語法：COLUMN(reference)。
參數：Reference為需要得到其列標的單元格或單元格區域。如果省略reference，則假定函數COLUMN是對所在單元格的引用。如果 reference為一個單元格區域，並且函數COLUMN作為水平數組輸入，則COLUMN函數將reference中的列標以水平數組的形式返回。 實例：公式「=COLUMN(A3)」返回1，=COLUMN(B3:C5)返回2。
5.COLUMNS
用途：返回數組或引用的列數。 語法：COLUMNS(array)。
參數：Array為需要得到其列數的數組、數組公式或對單元格區域的引用。 實例：公式「=COLUMNS(B1:C4)」返回2，=COLUMNS({5，4;4，5})返回2。
6.HLOOKUP
用途：在表格或數值數組的首行查找指定的數值，並由此返回表格或數組當前列中指定行處的數值。 語法：HLOOKUP(lookup_value，table_array，row_index_num，range_lookup)
參數：Lookup_value是需要在數據表第一行中查找的數值，它可以是數值、引用或文字串;Table_array是需要在其中查找數據的數據表，可以使用對區域或區域名稱的引用，Table_array的第一行的數值可以是文本、數字或邏輯值。Row_index_num為table_array 中待返回的匹配值的行序號。Range_lookup為一邏輯值，指明函數HLOOKUP查找時是精確匹配，還是近似匹配。
實例：如果A1:B3區域存放的數據為34、23、68、69、92、36，則公式「=HLOOKUP(34，A1:B3，1，FALSE)返回34;=HLOOKUP(3，{1，2，3;"a"，"b"，"c";"d"，"e"，"f"}，2，TRUE)返回「c」。
7.HYPERLINK
用途：創建一個快捷方式，用以打開存儲在網路伺服器、Intranet(Internet)或本地硬碟的其它文件。 語法：HYPERLINK(link_location，friendly_name)
參數：Link_location是文件的路徑和文件名，它還可以指向文檔中的某個更為具體的位置，如Execl工作表或工作簿中特定的單元格或命名區域，或是指向Word文檔中的書簽。路徑可以是存儲在硬碟驅動器上的文件，或是Internet或Intranet上的URL路徑;Friendly_name為單元格中顯示的鏈接文字或數字，它用藍色顯示並帶有下劃線。如果省略了Friendly_name，單元格就將 link_location顯示為鏈接。
實例：HYPERLINK("http://soft.yesky.com/"，" 驅動之家")會在工作表中顯示文本「驅動之家」，單擊它即可連接到「http://soft.yesky.com/」。公式 「=HYPERLINK("D:\README.TXT"，"說明文件")」在工作表中建立一個的藍色「說明文件」鏈接，單擊它可以打開D盤上的 README.TXT文件。
8.INDEX
用途：返回表格或區域中的數值或對數值的引用。函數INDEX()有兩種形式:數組和引用。數組形式通常返回數值或數值數組;引用形式通常返回引用。
語法：INDEX(array，row_num，column_num)返回數組中指定的單元格或單元格數組的數值。INDEX(reference，row_num，column_num，area_num)返回引用中指定單元格或單元格區域的引用。 參數：Array為單元格區域或數組常數;Row_num為數組中某行的行序號，函數從該行返回數值。如果省略row_num，則必須有 column_num;Column_num是數組中某列的列序號，函數從該列返回數值。如果
省略column_num，則必須有row_num。 Reference是對一個或多個單元格區域的引用，如果為引用輸入一個不連續的選定區域，必須用括弧括起來。Area_num是選擇引用中的一個區域，並返回該區域中row_num和column_num的交叉區域。選中或輸入的第一個區域序號為1，第二個為2，以此類推。如果省略area_num，則 INDEX函數使用區域1。
實例：如果A1=68、A2=96、A3=90，則公式「=INDEX(A1:A3，1，1)」返回68，=INDEX(A1:A3，1，1，1)返回68。
9.INDIRECT
用途：返回由文字串指定的引用。此函數立即對引用進行計算，並顯示其內容。當需要更改公式中單元格的引用，而不更改公式本身，即可使用INDIRECT函數。 語法：INDIRECT(ref_text，a1)。
參數：Ref_text是對單元格的引用，此單元格可以包含A1樣式的引用、R1C1樣式的引用、定義為引用的名稱或對文字串單元格的引用;A1為一邏輯值，指明包含在單元格ref_text中的引用的類型。如果a1為TRUE或省略，ref_text被解釋為A1-樣式的引用。如果a1為 FALSE，ref_text被解釋為R1C1-樣式的引用。
實例：如果單元格A1存放有文本B1，而B1單元格中存放了數值68.75，則公式「=INDIRECT($A$1)」返回68.75。
10.LOOKUP
用途：返迴向量(單行區域或單列區域)或數組中的數值。該函數有兩種語法形式:向量和數組，其向量形式是在單行區域或單列區域(向量)中查找數值，然後返回第二個單行區域或單列區域中相同位置的數值;其數組形式在數組的第一行或第一列查找指定的數值，然後返回數組的最後一行或最後一列中相同位置的數值。 語法1(向量形式):LOOKUP(lookup_value，lookup_vector，result_vector) 語法2(數組形式):LOOKUP(lookup_value，array)。
參數1(向量形式):Lookup_value為函數LOOKUP在第一個向量中所要查找的數值。Lookup_value可以為數字、文本、邏輯值或包含數值的名稱或引用。Lookup_vector為只包含一行或一列的區域。Lookup_vector的數值可以為文本、數字或邏輯值。
參數2(數組形式):Lookup_value為函數LOOKUP在數組中所要查找的數值。Lookup_value可以為數字、文本、邏輯值或包含數值的名稱或引用。如果函數LOOKUP找不到lookup_value，則使用數組中小於或等於lookup_value的最大數值。Array為包含文本、數字或邏輯值的單元格區域，它的值用於與lookup_value進行比較。
注意:Lookup_vector的數值必須按升序排列，否則LOOKUP函數不能返回正確的結果，參數中的文本不區分大小寫。
實例：如果A1=68、A2=76、A3=85、A4=90，則公式「=LOOKUP(76，A1:A4)」返回2，=LOOKUP("bump"，{"a"，1;"b"，2;"c"，3})返回2。

2. Excel日期函數

首先進行迭代運算的設定
菜單欄→工具→選項→重新計算
勾選啟用迭代，迭代設為1次

A4公式
=IF(COUNTA(B6:C8)=0,"",IF(A4="",YEAR(TODAY())&"年第"&INT((MONTH(TODAY())-1)/3)+1&"季度",A4))

3. 如何對一個tensor內的所有元素作用本地函數

基本使用 使用 TensorFlow, 你必須明白 TensorFlow: 使用圖 (graph) 來表示計算任務. 在被稱之為 會話 (Session) 的上下文 (context) 中執行圖. 使用 tensor 表示數據. 通過 變數 (Variable) 維護狀態. 使用 feed 和 fetch 可以為任意的操作(arb

4. C語言計算時間函數

標准庫的time.h里有時間函數

time_t time (time_t *timer)
計算從1970年1月1日到當前系統時間,並把結果返回給timer變數,
函數本身返回的也是這個結果.time_t這個類型其實就是一個int.

另有：
double difftime ( time_t timer2, time_t timer1 )
把返回time2和time1所儲存的時間的差.

5. excel函數計算很慢怎麼解決

1、打開選項對話框，執行：文件，選擇選項；
2、在常規菜單下，先來取消顯示開始屏幕，取消勾選「此應用程序啟動時顯示開始屏幕」；
3、在保存選項下，設置一下保存的位置為本地，然後設置保存的路徑；
4、在高級選項下，禁用硬體圖形加速，這是解決Excel卡頓現象的關鍵；
5、在載入項選項中，轉到Excel載入項，這些載入項暫時用不到，所以要將其取消勾選，等用到的時候再勾上；
6、轉到com載入項，這些載入項都不要勾，等用著的時候再勾選就可以了。

6. 怎樣計算出本地的經緯度

立一根桿子，不停的畫出它的影子，當影子最短時，影子的方向就是標準的南北方向。然後，當太陽位於正南或正北（看你在北半球還是南半球了）時，測量影子和桿子的長度，用三角函數算出太陽仰角。然後看測量的具體日期，已知春分或秋分時太陽直射赤道、夏至或冬至直射北回歸線回南回歸線，利用這幾個已知條件和測量當天的具體日期進行三角函數插值，得出修正值後和太陽仰角相加可得出當地緯度值。在看太陽過正南北向時的時間，和當地時區的12點整點的時間差進行計算，就可以得出經度值。當初我在大學時就是這么組織天文協會的同學測量的。

7. Python 里為什麼函數可以返回一個函數內部定義的函數

「在Python中，函數本身也是對象」
這一本質。那不妨慢慢來，從最基本的概念開始，討論一下這個問題：
1. Python中一切皆對象
這恐怕是學習Python最有用的一句話。想必你已經知道Python中的list, tuple, dict等內置數據結構，當你執行：
alist = [1, 2, 3]

時，你就創建了一個列表對象，並且用alist這個變數引用它：
當然你也可以自己定義一個類:
class House(object):
def __init__(self, area, city):
self.area = area
self.city = city

def sell(self, price):
[...] #other code
return price

然後創建一個類的對象：
house = House(200, 'Shanghai')

OK，你立馬就在上海有了一套200平米的房子，它有一些屬性(area, city)，和一些方法(__init__, self)：

2. 函數是第一類對象
和list, tuple, dict以及用House創建的對象一樣，當你定義一個函數時，函數也是對象：
def func(a, b):
return a+b

在全局域，函數對象被函數名引用著，它接收兩個參數a和b，計算這兩個參數的和作為返回值。
所謂第一類對象，意思是可以用標識符給對象命名，並且對象可以被當作數據處理，例如賦值、作為參數傳遞給函數，或者作為返回值return 等
因此，你完全可以用其他變數名引用這個函數對象：
add = func

這樣，你就可以像調用func(1, 2)一樣，通過新的引用調用函數了：
print func(1, 2)
print add(1, 2) #the same as func(1, 2)

或者將函數對象作為參數，傳遞給另一個函數：
def caller_func(f):
return f(1, 2)

if __name__ == "__main__":
print caller_func(func)

可以看到，

函數對象func作為參數傳遞給caller_func函數，傳參過程類似於一個賦值操作f=func；

於是func函數對象，被caller_func函數作用域中的局部變數f引用，f實際指向了函數func；cc

當執行return f(1, 2)的時候，相當於執行了return func(1, 2)；

因此輸出結果為3。
3. 函數對象 vs 函數調用
無論是把函數賦值給新的標識符，還是作為參數傳遞給新的函數，針對的都是函數對象本身，而不是函數的調用。
用一個更加簡單，但從外觀上看，更容易產生混淆的例子來說明這個問題。例如定義了下面這個函數：
def func():
return "hello,world"

然後分別執行兩次賦值：
ref1 = func #將函數對象賦值給ref1
ref2 = func() #調用函數，將函數的返回值("hello,world"字元串)賦值給ref2

很多初學者會混淆這兩種賦值，通過Python內建的type函數，可以查看一下這兩次賦值的結果：
In [4]: type(ref1)
Out[4]: function

In [5]: type(ref2)
Out[5]: str

可以看到，ref1引用了函數對象本身，而ref2則引用了函數的返回值。通過內建的callable函數，可以進一步驗證ref1是可調用的，而ref2是不可調用的：
In [9]: callable(ref1)
Out[9]: True

In [10]: callable(ref2)
Out[10]: False

傳參的效果與之類似。
4. 閉包&LEGB法則
所謂閉包，就是將組成函數的語句和這些語句的執行環境打包在一起時，得到的對象
聽上去的確有些復雜，還是用一個栗子來幫助理解一下。假設我們在foo.py模塊中做了如下定義：
#foo.py
filename = "foo.py"

def call_func(f):
return f() #如前面介紹的，f引用一個函數對象，然後調用它

在另一個func.py模塊中，寫下了這樣的代碼：
#func.py
import foo #導入foo.py

filename = "func.py"
def show_filename():
return "filename: %s" % filename

if __name__ == "__main__":
print foo.call_func(show_filename) #注意：實際發生調用的位置，是在foo.call_func函數中

當我們用python func.py命令執行func.py時輸出結果為：
chiyu@chiyu-PC:~$ python func.py
filename:func.py

很顯然show_filename()函數使用的filename變數的值，是在與它相同環境(func.py模塊)中定義的那個。盡管foo.py模塊中也定義了同名的filename變數，而且實際調用show_filename的位置也是在foo.py的call_func內部。
而對於嵌套函數，這一機制則會表現的更加明顯：閉包將會捕捉內層函數執行所需的整個環境：
#enclosed.py
import foo
def wrapper():
filename = "enclosed.py"
def show_filename():
return "filename: %s" % filename
print foo.call_func(show_filename) #輸出：filename: enclosed.py

實際上，每一個函數對象，都有一個指向了該函數定義時所在全局名稱空間的__globals__屬性：
#show_filename inside wrapper
#show_filename.__globals__

{
'__builtins__': <mole '__builtin__' (built-in)>, #內建作用域環境
'__file__': 'enclosed.py',
'wrapper': <function wrapper at 0x7f84768b6578>, #直接外圍環境
'__package__': None,
'__name__': '__main__',
'foo': <mole 'foo' from '/home/chiyu/foo.pyc'>, #全局環境
'__doc__': None
}

當代碼執行到show_filename中的return "filename: %s" % filename語句時，解析器按照下面的順序查找filename變數：

Local - 本地函數(show_filename)內部，通過任何方式賦值的，而且沒有被global關鍵字聲明為全局變數的filename變數；

Enclosing - 直接外圍空間(上層函數wrapper)的本地作用域，查找filename變數(如果有多層嵌套，則由內而外逐層查找，直至最外層的函數)；

Global - 全局空間(模塊enclosed.py)，在模塊頂層賦值的filename變數；

Builtin - 內置模塊(__builtin__)中預定義的變數名中查找filename變數；
在任何一層先找到了符合要求的filename變數，則不再向更外層查找。如果直到Builtin層仍然沒有找到符合要求的變數，則拋出NameError異常。這就是變數名解析的：LEGB法則。
總結：

閉包最重要的使用價值在於：封存函數執行的上下文環境；

閉包在其捕捉的執行環境(def語句塊所在上下文)中，也遵循LEGB規則逐層查找，直至找到符合要求的變數，或者拋出異常。

5. 裝飾器&語法糖(syntax sugar)
那麼閉包和裝飾器又有什麼關系呢？
上文提到閉包的重要特性：封存上下文，這一特性可以巧妙的被用於現有函數的包裝，從而為現有函數更加功能。而這就是裝飾器。
還是舉個例子，代碼如下：
#alist = [1, 2, 3, ..., 100] --> 1+2+3+...+100 = 5050
def lazy_sum():
return rece(lambda x, y: x+y, alist)

我們定義了一個函數lazy_sum，作用是對alist中的所有元素求和後返回。alist假設為1到100的整數列表：
alist = range(1, 101)

但是出於某種原因，我並不想馬上返回計算結果，而是在之後的某個地方，通過顯示的調用輸出結果。於是我用一個wrapper函數對其進行包裝：
def wrapper():
alist = range(1, 101)
def lazy_sum():
return rece(lambda x, y: x+y, alist)
return lazy_sum

lazy_sum = wrapper() #wrapper() 返回的是lazy_sum函數對象

if __name__ == "__main__":
lazy_sum() #5050

這是一個典型的Lazy Evaluation的例子。我們知道，一般情況下，局部變數在函數返回時，就會被垃圾回收器回收，而不能再被使用。但是這里的alist卻沒有，它隨著lazy_sum函數對象的返回被一並返回了(這個說法不準確，實際是包含在了lazy_sum的執行環境中，通過__globals__)，從而延長了生命周期。
當在if語句塊中調用lazy_sum()的時候，解析器會從上下文中(這里是Enclosing層的wrapper函數的局部作用域中)找到alist列表，計算結果，返回5050。
當你需要動態的給已定義的函數增加功能時，比如：參數檢查，類似的原理就變得很有用：
def add(a, b):
return a+b

這是很簡單的一個函數：計算a+b的和返回，但我們知道Python是 動態類型+強類型 的語言，你並不能保證用戶傳入的參數a和b一定是兩個整型，他有可能傳入了一個整型和一個字元串類型的值：
In [2]: add(1, 2)
Out[2]: 3

In [3]: add(1.2, 3.45)
Out[3]: 4.65

In [4]: add(5, 'hello')
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
/home/chiyu/<ipython-input-4-f2f9e8aa5eae> in <mole>()
----> 1 add(5, 'hello')

/home/chiyu/<ipython-input-1-02b3d3d6caec> in add(a, b)
1 def add(a, b):
----> 2 return a+b

TypeError: unsupported operand type(s) for +: 'int' and 'str'

於是，解析器無情的拋出了一個TypeError異常。
動態類型：在運行期間確定變數的類型，python確定一個變數的類型是在你第一次給他賦值的時候；
強類型：有強制的類型定義，你有一個整數，除非顯示的類型轉換，否則絕不能將它當作一個字元串(例如直接嘗試將一個整型和一個字元串做+運算)；
因此，為了更加優雅的使用add函數，我們需要在執行+運算前，對a和b進行參數檢查。這時候裝飾器就顯得非常有用：
import logging

logging.basicConfig(level = logging.INFO)

def add(a, b):
return a + b

def checkParams(fn):
def wrapper(a, b):
if isinstance(a, (int, float)) and isinstance(b, (int, float)): #檢查參數a和b是否都為整型或浮點型
return fn(a, b) #是則調用fn(a, b)返回計算結果

#否則通過logging記錄錯誤信息，並友好退出
logging.warning("variable 'a' and 'b' cannot be added")
return
return wrapper #fn引用add，被封存在閉包的執行環境中返回

if __name__ == "__main__":
#將add函數對象傳入，fn指向add
#等號左側的add，指向checkParams的返回值wrapper
add = checkParams(add)
add(3, 'hello') #經過類型檢查，不會計算結果，而是記錄日誌並退出

注意checkParams函數：

首先看參數fn，當我們調用checkParams(add)的時候，它將成為函數對象add的一個本地(Local)引用；

在checkParams內部，我們定義了一個wrapper函數，添加了參數類型檢查的功能，然後調用了fn(a, b)，根據LEGB法則，解釋器將搜索幾個作用域，並最終在(Enclosing層)checkParams函數的本地作用域中找到fn；

注意最後的return wrapper，這將創建一個閉包，fn變數(add函數對象的一個引用)將會封存在閉包的執行環境中，不會隨著checkParams的返回而被回收；

當調用add = checkParams(add)時，add指向了新的wrapper對象，它添加了參數檢查和記錄日誌的功能，同時又能夠通過封存的fn，繼續調用原始的add進行+運算。
因此調用add(3, 'hello')將不會返回計算結果，而是列印出日誌：
chiyu@chiyu-PC:~$ python func.py
WARNING:root:variable 'a' and 'b' cannot be added

有人覺得add = checkParams(add)這樣的寫法未免太過麻煩，於是python提供了一種更優雅的寫法，被稱為語法糖：
@checkParams
def add(a, b):
return a + b

這只是一種寫法上的優化，解釋器仍然會將它轉化為add = checkParams(add)來執行。
6. 回歸問題
def addspam(fn):
def new(*args):
print "spam,spam,spam"
return fn(*args)
return new

@addspam
def useful(a,b):
print a**2+b**2

首先看第二段代碼：

@addspam裝飾器，相當於執行了useful = addspam(useful)。在這里題主有一個理解誤區：傳遞給addspam的參數，是useful這個函數對象本身，而不是它的一個調用結果；

再回到addspam函數體：

return new 返回一個閉包，fn被封存在閉包的執行環境中，不會隨著addspam函數的返回被回收；

而fn此時是useful的一個引用，當執行return fn(*args)時，實際相當於執行了return useful(*args)；

最後附上一張代碼執行過程中的引用關系圖，希望能幫助你理解：

8. 如何計算當地的中央子午線

計算方法：當地中央子午線決定於當地的直角坐標系統，首先確定您的直角坐標系統是3度帶還是6度帶投影，然後再根據如下公式推算。

6度帶：帶號N=round[(L+3)/6]，即對(L+3)/6的值四捨五入取整數，L為當地經度；則中央子午線經度L0=6 × N-3。

3度帶：帶號N=round(L/3)，即對(L/3)的值四捨五入取整數，L為當地經度；則中央子午線經度L0=3 × N。

拓展資料：

長白時區

以東經135(127.5)度為中央子午線。

一個時區的「標准時」，只是一個大地區的統一時間，大家共同遵守的「人工時間「而已，並不是該時區內每個地點的「本地時間(LMT)」——真正的經度時。要用出生地的經度與出生大地區的標准時來加減，全球任何地點都用這個原則。