摘要：函數(shù)名應(yīng)盡量只有小寫字母和下劃線。傳遞參數(shù)位置參數(shù)必選參數(shù)這就是要求實參的順序和形參的順序相同。比如上述函數(shù)如果給形參指定默認(rèn)值，則可以看出這個函數(shù)主要是用來描述狗這種寵物的。在的函數(shù)中，使用語句來返回值。

《Python編程：從入門到實踐》筆記。
本章主要介紹Python中函數(shù)的操作，包括函數(shù)的概念，定義，如何傳參等，最后還有小部分模塊的概念。

函數(shù)是帶名字的代碼塊，該代碼塊是完成特定工作的固定代碼序列。如果程序中多次出現(xiàn)相同或相似的代碼塊，則應(yīng)將這段代碼提取出來，編寫成函數(shù)，然后多次調(diào)用。通過編寫函數(shù)可以避免重復(fù)工作，使程序的編寫、閱讀、測試和修復(fù)更容易。請使用描述性的函數(shù)名來命名函數(shù)，以大致表明函數(shù)的功能，這樣即使沒有注釋也能容易理解。函數(shù)名應(yīng)盡量只有小寫字母和下劃線。以下是兩個最基本的函數(shù)，有參數(shù)與無參函數(shù)：

# 定義無參函數(shù)
def greet_user1():
    """顯示簡單的問候語"""
    print("Hello!")

# 定義有參函數(shù)
def greet_user2(username):
    """顯示簡單的問候語"""
    print("Hello, " + username.title() + "!")

# 調(diào)用函數(shù)
greet_user1()
greet_user2("jesse")

# 結(jié)果：
Hello!
Hello, Jesse!

在調(diào)用函數(shù)前，必須先定義函數(shù)！即函數(shù)的定義部分必須在調(diào)用語句之前。
上述代碼中的三引號字符串叫做文檔字符串，他們既可以被用作代碼注釋，也可用于自動生成有關(guān)程序中函數(shù)的文檔。

實參和形參
這兩個概念經(jīng)常被搞混，函數(shù)定義中的參數(shù)叫做形參，比如上述函數(shù)greet_user2(username)中的username就是形參；傳遞給函數(shù)的參數(shù)叫做實參，比如在調(diào)用greet_user2("jesse")時的"jesse"就是實參。

如果想定義一個什么都不做的函數(shù)，可以使用pass語句

def do_nothing():
    pass

如果為了讓程序能跑起來，但暫時又不寫這個函數(shù)，可以使用pass語句。這里pass用作占位符。

這就是要求實參的順序和形參的順序相同。

# 代碼：
def describe_pet(animal_type, pet_name):
    """顯示寵物的信息"""
    print("
I have a " + animal_type + ".")
    print("My " + animal_type + ""s name is " + pet_name.title() + ".")

describe_pet("hamster", "harry")
describe_pet("dog", "willie")

# 結(jié)果：
I have a hamster.
My hamster"s name is Harry.

I have a dog.
My dog"s name is Willie.

對于位置參數(shù)，應(yīng)該注意實參的傳遞順序，如果順序不對，結(jié)果會出乎意料：有可能報錯，如果不報錯，函數(shù)所要表達(dá)的意思可能改變。

# 代碼：
describe_pet("willie", "dog")

# 結(jié)果：
I have a willie.           # 尷尬
My willie"s name is Dog.

如果函數(shù)的形參過多，則很難記住每個位置的參數(shù)是用來干什么的，如果用鍵值對的方式傳遞實參，這個問題就能迎刃而解，這就是關(guān)鍵字參數(shù)。在傳遞參數(shù)時，直接將形參與實參關(guān)聯(lián)，這樣就不用在意實參的位置，依然以上述代碼為例，函數(shù)定義不變：

# 代碼：
describe_pet(animal_type="hamster", pet_name="harry")
describe_pet(pet_name="harry", animal_type="hamster")

# 結(jié)果：
I have a hamster.
My hamster"s name is Harry.

I have a hamster.
My hamster"s name is Harry.

請注意，這是一種傳遞參數(shù)的方法！在調(diào)用函數(shù)時使用！

編寫函數(shù)時可以為每個形參指定默認(rèn)值，給形參指定了默認(rèn)值之后，在調(diào)用函數(shù)時可以省略相應(yīng)的實參。使用默認(rèn)值可以簡化函數(shù)調(diào)用，也可清楚地指出函數(shù)的典型用法。比如上述describe_pet()函數(shù)如果給形參animal_type指定默認(rèn)值“dog”，則可以看出這個函數(shù)主要是用來描述狗這種寵物的。

# 代碼：
def describe_pet(pet_name, animal_type="dog"):
    """顯示寵物的信息"""
    print("
I have a " + animal_type + ".")
    print("My " + animal_type + ""s name is " + pet_name.title() + ".")


describe_pet(pet_name="willie")
describe_pet("happy")
describe_pet("lili", "cat")

# 結(jié)果：
I have a dog.
My dog"s name is Willie.

I have a dog.
My dog"s name is Happy.

I have a cat.
My cat"s name is Lili.

在函數(shù)調(diào)用時，如果給形參提供了實參，Python將使用指定的實參；否則將使用形參的默認(rèn)值。
注意：默認(rèn)參數(shù)是在函數(shù)定義時使用！在定義函數(shù)時帶有默認(rèn)值的形參必須在沒有默認(rèn)值的形參后面！

還有一點值得注意：默認(rèn)參數(shù)必須指向不變對象！請看以下代碼：

# 代碼：
def add_end(temp=[]):
    """在傳入的列表最后添加“end”"""
    temp.append("end")
    return temp


print(add_end([1, 2, 3]))
print(add_end(["a", "b", "c"]))
print(add_end())
print(add_end())
print(add_end())

# 結(jié)果：
[1, 2, 3, "end"]
["a", "b", "c", "end"]
["end"]
["end", "end"]
["end", "end", "end"]

當(dāng)給這個函數(shù)傳遞了參數(shù)時，結(jié)果是正確的，而且，在沒有傳遞參數(shù)且第一次調(diào)用時，返回結(jié)果也是正確的，然而，沒有傳遞參數(shù)且第二次、第三次調(diào)用時，結(jié)果則成了問題。這是因為，Python在函數(shù)定義的時候，默認(rèn)參數(shù)的值就被計算了出來，形參只要不指向新的值，它就會一直指向這個默認(rèn)值，但如果這個默認(rèn)值是個可變對象，就會出現(xiàn)上述情況。
要修正上述例子，可以使用None，str之類的不變對象。如下：

def add_end(temp=None):
    """在傳入的列表最后添加“end”"""
    if temp is None:
        temp = []
    temp.append("end")
    return temp

print(add_end())
print(add_end())

# 結(jié)果：
["end"]
["end"]

補充--設(shè)計不變對象的原因：
①對象一旦創(chuàng)建則不可修改，可以減少因修改數(shù)據(jù)而產(chǎn)生的錯誤；
②由于對象不可修改，在多任務(wù)環(huán)境下不需要加鎖，同時讀不會出錯。所以，我們在設(shè)計一個對象時，能設(shè)計成不變對象則設(shè)計成不變對象。

函數(shù)并非總是直接顯示輸出，它可以處理一些數(shù)據(jù)并返回一個或一組值。在Python的函數(shù)中，使用return語句來返回值。以下是一個參數(shù)可選的帶有返回值的函數(shù)例子：

# 代碼：
def get_formatted_name(first_name, last_name, middel_name=""):
    """返回標(biāo)準(zhǔn)格式的姓名"""
    if middel_name:
        full_name = first_name + " " + middel_name + " " + last_name
    else:
        full_name = first_name + " " + last_name

    return full_name.title()


musician = get_formatted_name("jimi", "hendrix")
print(musician)

musician = get_formatted_name("john", "hooker", "lee")
print(musician)

# 結(jié)果：
Jimi Hendrix
John Lee Hooker

Python函數(shù)可以返回任何類型的值，包括列表和字典等復(fù)雜的數(shù)據(jù)結(jié)構(gòu)。

# 代碼：
def build_person(first_name, las_name, age=""):
    """返回一個字典，其中包含一個人的信息"""
    person = {"first": first_name, "last": las_name}
    if age:
        person["age"] = age
    return person


musician = build_person("jimi", "hendrix", age=27)
print(musician)

# 結(jié)果：
{"first": "jimi", "last": "hendrix", "age": 27}

return語句后面用逗號分隔多個值，則可返回多個值：

# 代碼：
def return_mult():
    return 1, 2

a, b = return_mult()
print("a = " + str(a) + "
b = " + str(b))

# 結(jié)果：
a = 1
b = 2

但其實這是個假象，其實函數(shù)返回的是一個元組（Tuple），只是最后對元組進行了解包，然后對a，b進行了平行賦值。

# 代碼：
print(return_mult())

# 結(jié)果：
(1, 2)

如果函數(shù)返回多個值，但有些值并不想要，則這些位置的值可以用下劃線_進行接收：

def return_mult():
    return 1, 2, 3
    
a, _, _ = return_mult()

將列表傳遞給函數(shù)，函數(shù)可以直接訪問其內(nèi)容或?qū)ζ溥M行修改。用函數(shù)處理列表可以提高效率。
以下代碼是一個打印程序，將未打印的設(shè)計在打印后轉(zhuǎn)移到另一個列表中，此代碼中未使用函數(shù)：

# 代碼:
# 未打印列表
unprinted_designs = ["iphone case", "robot pendant", "dodecahedron"]
completed_models = []

# 模擬打印過程，知道沒有未打印的設(shè)計為止，并將已打印的設(shè)計移動到“完成列表”
while unprinted_designs:
    current_design = unprinted_designs.pop()

    # 模擬打印過程
    print("Printing model: " + current_design)
    completed_models.append(current_design)

print("
The following models have been printed:")
for completed_model in completed_models:
    print(completed_model)

# 結(jié)果：
Printing model: dodecahedron
Printing model: robot pendant
Printing model: iphone case

The following models have been printed:
dodecahedron
robot pendant
iphone case

現(xiàn)在用兩個函數(shù)來重組這些代碼：

# 兩個函數(shù)：
def print_models(unprinted_designs, completed_models):
    """模擬打印過程，知道沒有未打印的設(shè)計為止，并將已打印的設(shè)計移動到“完成列表”"""
    while unprinted_designs:
        current_design = unprinted_designs.pop()

        # 模擬打印過程
        print("Printing model: " + current_design)
        completed_models.append(current_design)


def show_completed_models(completed_models):
    print("
The following models have been printed:")
    for completed_model in completed_models:
        print(completed_model)

# 主程序代碼：
unprinted_designs = ["iphone case", "robot pendant", "dodecahedron"]
completed_models = []

print_models(unprinted_designs, completed_models)
show_completed_models(completed_models)

從以上代碼可以看出，使用了函數(shù)后，主程序變?yōu)榱硕潭趟男小?br>相比于沒有使用函數(shù)的代碼，使用了函數(shù)后代碼更易讀也更容易維護。
在編寫函數(shù)時，盡量每個函數(shù)只負(fù)責(zé)一項功能，如果一個函數(shù)負(fù)責(zé)的功能太多，應(yīng)將其分成多個函數(shù)。同時，函數(shù)里面還能調(diào)用另一個函數(shù)；函數(shù)里也能再定義函數(shù)！

禁止函數(shù)修改列表：
有時候需要禁止函數(shù)修改列表，以上述代碼為例，print_models()函數(shù)在執(zhí)行完成后清空了未打印列表unprinted_design，但有時我們并不希望這個列表被清空，而是留作備案。為解決此問題，可以向函數(shù)傳遞副本而不是原件，如下：

# 不用改變函數(shù)定義，在函數(shù)調(diào)用時使用切片操作：
print_models(unprinted_designs[:], completed_models)

如果從C/C++的角度來看（沒有研究過Python底層代碼，這里僅是猜測），實參unprinted_designs是一個指針，當(dāng)他傳遞給函數(shù)時，形參得到了這個變量的一個拷貝，形參也指向了內(nèi)存中的那片區(qū)域，所以能直接修改。而當(dāng)使用切片傳遞拷貝時，Python先在內(nèi)存中復(fù)制一遍實參unprinted_designs指向的數(shù)據(jù)，并給這片數(shù)據(jù)的地址賦給一個臨時的變量，然后再將這個臨時變量傳遞給形參。

有時候你并不知道要向函數(shù)傳遞多少個參數(shù)，比如制作披薩，你不知道顧客要多少種配料，此時使用帶一個星號*的形參，來定義函數(shù)：

# 代碼：
def make_pizza(*toppings):
    """打印顧客點的所有配料"""
    print(toppings)
    
make_pizza()    # 不傳參數(shù)
make_pizza("pepperoni")
make_pizza("mushrooms", "green peppers", "extra cheese")

# 結(jié)果：
()
("pepperoni",)
("mushrooms", "green peppers", "extra cheese")

從結(jié)果可以看出，以可變參數(shù)的方式傳入值時，Python將值封裝成了一個元組，即使是只傳入了一個值。

補充：多個參數(shù)都在一個列表里面，如果一個元素一個元素的傳遞，則代碼會很難看，可以使用如下方式傳遞參數(shù)，任以上述make_pizza()函數(shù)為例：

toppings = ["mushrooms", "green peppers", "extra cheese"]
make_pizza(*toppings)    # 這里是在執(zhí)行函數(shù)，而不是在定義函數(shù)！

在后面的“任意關(guān)鍵字參數(shù)”小節(jié)中，也可用這種方式傳值，只不過得用雙星號**。

注意：如果要讓函數(shù)接收不同類型的參數(shù)，必須將可變參數(shù)放在最后，因為Python先匹配位置參數(shù)和關(guān)鍵字參數(shù)，再將剩余的參數(shù)封裝到最后一個可變參數(shù)中。

# 代碼：
def make_pizza(size, *toppings):
    """概述要制作的披薩"""
    print("
Making a " + str(size) + "-inch pizza with the following toppings:")
    for topping in toppings:
        print("- " + topping)

make_pizza(16, "pepperoni")
make_pizza(12, "mushrooms", "green peppers", "extra cheese")

# 結(jié)果：
Making a 16-inch pizza with the following toppings:
- pepperoni

Making a 12-inch pizza with the following toppings:
- mushrooms
- green peppers
- extra cheese

有時候需要傳入任意數(shù)量的參數(shù)，并且還要知道這些參數(shù)是用來干什么的，此時函數(shù)需要能夠接受任意數(shù)量的關(guān)鍵字參數(shù)，這里使用雙星號**來實現(xiàn)：

# 代碼：
def build_profile(first, last, **user_info):
    print(user_info)

    """創(chuàng)建一個字典，其中包含我們知道的有關(guān)用戶的一切"""
    profile = {}
    profile["first_name"] = first
    profile["last_name"] = last
    for key, value in user_info.items():
        profile[key] = value
    return profile

user_profile = build_profile("albert", "einstein", location="princeton", field="physics")
print(user_profile)

# 結(jié)果：
{"location": "princeton", "field": "physics"}
{"first_name": "albert", "last_name": "einstein", "location": "princeton", "field": physics"}

從上述結(jié)果可以看出，Python將任意關(guān)鍵字參數(shù)封裝成一個字典。這里也要注意，指示任意關(guān)鍵字參數(shù)的形參必須放到最后！

區(qū)分---命名關(guān)鍵字參數(shù)（也叫命名參數(shù)）：
上述代碼可以傳遞任意數(shù)量的關(guān)鍵字參數(shù)，但有時需要限制傳入的關(guān)鍵字參數(shù)，比如上述build_profile()函數(shù)除了傳入first和last這兩個必選參數(shù)之外，還必須且只能傳入age和country這兩個參數(shù)（一個不多，一個不少）時，則需要用到命名關(guān)鍵字參數(shù)，它使用一個星號分隔必選參數(shù)和命名關(guān)鍵字參數(shù)，如下：

# 代碼：
# 星號后面的為命名關(guān)鍵字參數(shù)
def build_profile(first, last, *, age, country="China"):
    """創(chuàng)建一個字典，其中包含我們知道的有關(guān)用戶的一切"""
    profile = {}
    profile["first_name"] = first
    profile["last_name"] = last
    profile["age"] = age
    profile["country"] = country
    return profile


print(build_profile("albert", "einstein", country="USA", age=20))
print(build_profile("albert", "einstein", age=20))
print(build_profile(age=20, country="USA", first="albert", last="einstein"))
# print(build_profile("albert", "einstein"))

# 結(jié)果：
# 如果不看最后一個print()，則代碼的執(zhí)行結(jié)果如下：
{"first_name": "albert", "last_name": "einstein", "age": 20, "country": "USA"}
{"first_name": "albert", "last_name": "einstein", "age": 20, "country": "China"}
{"first_name": "albert", "last_name": "einstein", "age": 20, "country": "USA"}

# 如果將最后一個print()的注釋去掉，則代碼會報錯

從以上結(jié)果可以看出命名關(guān)鍵字參數(shù)必須每個都賦值，可以有默認(rèn)值，有默認(rèn)值的可以不用再賦值；命名關(guān)鍵字之間可以交換順序，如果要和前面的必選參數(shù)也交換順序，則必須使用關(guān)鍵字參數(shù)的方式傳遞實參。

為什么有命名關(guān)鍵字參數(shù)：
（網(wǎng)上搜的答案，個人暫時認(rèn)為這種參數(shù)可以被位置參數(shù)給替換掉）命名參數(shù)配合默認(rèn)參數(shù)使用可以簡化代碼，比如在寫類的構(gòu)造函數(shù)時，有10個參數(shù)，8個有合理的默認(rèn)值，那么可以將這8個定義為命名關(guān)鍵字參數(shù)，前兩個就是必須賦值的位置參數(shù)。這樣，在后面生成對象時，如果要替換默認(rèn)值：
①要么按順序給后面8個參數(shù)替換默認(rèn)值（C++做法）；
②要么用關(guān)鍵字參數(shù)的傳值方式給這8個關(guān)鍵字不一定按順序來賦值（Python做法）；
③要么混合①②的做法，不過容易混淆。（也就是全用必選參數(shù)，前面一部分按順序賦值，后面一部分用關(guān)鍵字參數(shù)賦值）

一點感想：但如果是筆者自己寫代碼，暫時更偏向于全用必選參數(shù)，帶默認(rèn)值，即如下定義形式：

def func(a, b, c="test1", d="test2", e="test3", f="test4", g="test5"):
    pass

而不是如下形式：

def func(a, b, *, c="test1", d="test2", e="test3", f="test4", g="test5"):
    pass

可能筆者才疏學(xué)淺，暫時還沒領(lǐng)會到這種方式的精髓之處。
不過上述是沒有可變參數(shù)的情況，如果是以如下形式定義函數(shù)：

def func(a, b="test", c="test2", *args):
    pass

在以如下形式調(diào)用時則會報錯：

func("test1", c="test3", b="test2", "test4")

# 結(jié)果：
SyntaxError: positional argument follows keyword argument

可以看出，Python在這里將test4解釋為了位置參數(shù)，但筆者是想將其作為可變參數(shù)。所以筆者推測，在以下情況時，使用命名關(guān)鍵字參數(shù)比較好：
必選參數(shù)數(shù)量不少（其中有些參數(shù)的默認(rèn)值不常變動），后面又跟有可變參數(shù)，由于必選參數(shù)很多，不容易記住位置，如果不用命名參數(shù)，按照上述關(guān)鍵字方式調(diào)用函數(shù)則會出錯，所以此時將這些有合理默認(rèn)值的必選參數(shù)變?yōu)槊P(guān)鍵字參數(shù)，則可以使用關(guān)鍵字參數(shù)不按順序傳值。但如果沒有可變參數(shù)時，筆者還是傾向于使用帶默認(rèn)值的必選參數(shù)。

還有一點值得注意：命名關(guān)鍵字參數(shù)可以和可變參數(shù)（*args）混用，此時語法如下：

def func(a, b, *agrs, c, d):
    pass

這里c，d為命名關(guān)鍵字參數(shù)，并且前面也不用加單個星號進行區(qū)分了，但是，如果和可變數(shù)量關(guān)鍵字參數(shù)（**kw）進行混用，命名關(guān)鍵字不能在可變數(shù)量關(guān)鍵字參數(shù)之前，即不存在如下函數(shù)定義形式：

def func(a, b, **kw, c, d):
    pass

如果這樣定義，Pycharm會標(biāo)紅（其他IDE沒用過，不知道提不提示）。

綜上所述：Python中一共有五中參數(shù)類型，即必選參數(shù)（位置參數(shù)），默認(rèn)參數(shù)（帶默認(rèn)值的參數(shù)），可變參數(shù)（args），命名關(guān)鍵字參數(shù)和關(guān)鍵字參數(shù)（數(shù)量可變，*kw），這五種可以同時混用，但是必須遵照如下順序：
（從左到右）必選參數(shù)、默認(rèn)參數(shù)、可變參數(shù)、命名關(guān)鍵字參數(shù)和關(guān)鍵字參數(shù)。以下是這兩個參數(shù)混用的幾個例子：

def func1(a, b, *, c, d, **kw):
    """
    a, b 為必選參數(shù)
    c, d 為命名關(guān)鍵字參數(shù)
    kw 為關(guān)鍵字參數(shù)，可包含多對
    """
    pass


def func2(a, b="test", *args, c, d="test2", **kw):
    """
    :param a: 必選參數(shù)
    :param b: 帶默認(rèn)值的必選參數(shù)
    :param args: 可變參數(shù)
    :param c: 命名關(guān)鍵字參數(shù)
    :param d: 帶默認(rèn)值的命名關(guān)鍵字參數(shù)
    :param kw: 關(guān)鍵字參數(shù)，可包含多對 
    """
    pass

常用的包含任意數(shù)量關(guān)鍵字，且不區(qū)分參數(shù)類型的函數(shù)定義方式如下：

def func(*args, **kw):
    pass

def func(*args, **kwargs):
    pass

在python中，一個.py文件就是一個模塊。使用模塊的最大好處就是提高了代碼的可維護性。其次，代碼不用從零開始編寫，一個模塊編寫完成后，可以在其他地方被調(diào)用。再次，可以避免函數(shù)名和變量名沖突，不同模塊可以有相同的函數(shù)名和變量名。

要讓函數(shù)是可以導(dǎo)入的，得先創(chuàng)建模塊。以上述make_pizza()函數(shù)為例，將其余代碼刪掉，只保留這一個函數(shù)，然后再在當(dāng)前目錄中創(chuàng)建一個making_pizzas.py的文件，執(zhí)行如下代碼以導(dǎo)入整個模塊：

# making_pizzas.py文件：
import pizza

pizza.make_pizza(12, "mushromms", "green peppers", "extra cheese")
pizza.make_pizza(16, "pepperoni")

# 結(jié)果：
Making a 12-inch pizza with the following toppings:
- mushromms
- green peppers
- extra cheese

Making a 16-inch pizza with the following toppings:
- pepperoni

以這種方式導(dǎo)入模塊時，按如下方式調(diào)用函數(shù)：

module_name.function_name()

語法結(jié)構(gòu)為：

# 導(dǎo)入一個函數(shù)
from module_name import function_name

# 導(dǎo)入多個函數(shù)，逗號分隔
from module_name import func1, func2, func3

# 以此方式導(dǎo)入模塊式，直接以函數(shù)名調(diào)用函數(shù)，前面不用加模塊名

仍以上述pizza.py為例：

from pizza import make_pizza

make_pizza(12, "mushromms", "green peppers", "extra cheese")
make_pizza(16, "pepperoni")

別名：
當(dāng)函數(shù)名發(fā)生沖突，或者函數(shù)名、模塊名太長時，可以取一個簡短的名稱，類似“外號”，以上述代碼為例：

# 函數(shù)取別名
from pizza import make_pizza as mp

mp(12, "mushromms", "green peppers", "extra cheese")
mp(16, "pepperoni")

# -------------------- 另一個文件 ------------------------------
# 模塊取別名
import pizza as p
p.make_pizza(12, "mushromms", "green peppers", "extra cheese")
p.make_pizza(16, "pepperoni")

導(dǎo)入模塊中的所有函數(shù)：
例如導(dǎo)入pizza模塊中的所有函數(shù)：

from pizza import *

make_pizza(12, "mushromms", "green peppers", "extra cheese")
make_pizza(16, "pepperoni")

然而，使用并非自己編寫的大型模塊時，最好不要采用這種導(dǎo)入方法，因為如果模塊中有函數(shù)或變量和你自己寫的函數(shù)、變量同名，結(jié)果將有問題。所以，一般的做法是要么只導(dǎo)入你需要的函數(shù)，要么導(dǎo)入整個模塊并用句點表示法。

包：
Python中的包就是一個文件夾，但這個文件夾下面必須包含名為__init__.py的文件（前后都是雙下劃線），包中可以放多個模塊，組織結(jié)構(gòu)與Java包類似。

迎大家關(guān)注我的微信公眾號"代碼港" & 個人網(wǎng)站 www.vpointer.net ~