from collections import defaultdict

# 构造图
# 顶点由'1', '2', '3', ... '40'构成
def build_gragh():
    graph = dict()
    with open('network.txt') as f:
        lines = f.read().splitlines()
        for vh, line in enumerate(lines, start=1):
            g = dict()
            for vs, v in enumerate(line.split(','), start=1):
                try:
                    g[str(vs)] = int(v)
                except ValueError:
                    g[str(vs)] = None
            graph[str(vh)] = g

    return graph

# test gragh
# 由字典表示，两个顶点权重值可以表示为：如A和B的权重为graph['A']['B']
"""
graph = {
    'A': {'B': 16, 'C': 12, 'D': 21},
    'B': {'A': 16, 'D': 17, 'E': 20},
    'C': {'A': 12, 'D': 28, 'F': 31},
    'D': {'A': 21, 'B': 17, 'C': 28, 'E': 18, 'F': 19, 'G': 23},
    'E': {'B': 20, 'D': 18, 'G': 11},
    'F': {'C': 31, 'D': 19, 'G': 27},
    'G': {'D': 23, 'E': 11, 'F': 27}
}
"""

# 求权重和
def sum_weight(graph, duplicate=True):
    sum_ = 0
    for v in graph:
        for vs in graph[v]:
            if graph[v][vs] != None:
                sum_ += graph[v][vs]

    # 如果计算两遍，则除以2
    if duplicate:
        return sum_ // 2
    else:
        return sum_

graph = build_gragh()

# prim算法求最小生成树
def prim_tree(graph):
    # 所有顶点
    vertes = list(graph.keys())
    # 选中顶点
    selected = set()
    # 将第一个顶点加入
    selected.add(vertes[0])
    # 移除已选顶点
    vertes.pop(0)

    new_graph = defaultdict(dict)
    # 只要还有未选中顶点，则循环
    while vertes:
        # 假设最小权重为1000
        tmp = 1000
        for u in selected:
            for v in vertes:
                try:
                    if graph[u][v] != None and graph[u][v] < tmp:
                        tmp = graph[u][v]
                        choose_u = u
                        choose_v = v

                except KeyError:
                    pass

        selected.add(choose_v)
        vertes.remove(choose_v)
        new_graph[choose_u][choose_v] = tmp

    return new_graph

print("before: ")
sum1 = sum_weight(graph, duplicate=True)
print(sum1)
print("after:")
# 最小生成树中各条边权重只算一次，所以这里duplicate为False
sum2 = sum_weight(prim_tree(graph), duplicate=False)
print(sum2)

print("saving: {}".format(sum1 - sum2))

import math

class Point(tuple):
		#第一个参数是类型
    def __new__(cls, x, y):
        return tuple.__new__(cls, (x, y))

    def distance(self, other):
        return math.sqrt((self[0]-other[0]) ** 2 + (self[1]-other[1]) ** 2)

    def __repr__(self):
        return "Point({0}, {1})".format(self[0], self[1])

p = Point(1, 1)
p2 = Point(0, 0)
p3 = Point(3, 4)
print(p.distance(p2))
print(p2.distance(p3))
print(repr(p))

def main():
    with open('triangles.txt') as f:
        lines = f.read().splitlines()

    counts = 0
    for line in lines:
        points = line.split(',')
        points = [int(point) for point in points]
        A = points[:2]
        B = points[2:4]
        C = points[4:]
        P = (0, 0)
        if area(A, B, C) == area(P, B, C) + area(P, A, C) + area(P, A, B):
            counts += 1
    print(counts)

# 求面积，根据上面的公式
def area(A, B, C):
    return abs((A[0]-C[0]) * (B[1]-A[1]) - (A[0]-B[0]) * (C[1]-A[1]))

if __name__ == '__main__':
    main()

import functools
# 原函数：
def func1(a, b, c):
	return do_something_with_a_b_c

# 柯里化：
func2 = functools.partial(func1, 1, 2) # 固定参数a,b
# 使用：func2(c)