print(abs(-5))
print(max(1,2))
print(max(1,2,3,4,5))
print(int('123'))
print(int(12.34))
print(float('12.34'))
print(str(1.23))
print(str(100))
print(bool(1))
print(bool(''))
a = abs #變數a指向abs函式,相當於給函式起了個別名
print(a(-1))

#自定義函式
def my_abs(x):
    if not isinstance(x,(int,float)):
        raise TypeError('bad operand type'
 
)
    if x>=0:
        return x
    else:
        return -x

print(my_abs(-10))

#from abstest import my_abs   引入其他.py檔案中定義的函式直接呼叫

#空函式，什麼也不幹
def nop():
    pass    #pass 可以作為佔位符，現在不知道函式的實現，可以通過pass佔位，類似於 ;


#my_abs(1,2)  TypeError 引數錯誤

#my_abs('acb')

import math
#座標 位移 速度 
#返回多個引數,實際上返回的只是一個tuple
 

def move(x,y,step,angle=0):         
    nx = x + step*math.cos(angle)
    ny = y - step*math.sin(angle)
    return nx,ny

x,y = move(100,100,60,math.pi / 6)
print(x,y)
r = move(100,100,60,math.pi / 6)
print(r)

#Python的函式定義非常簡單，但靈活度卻非常大。
#除了正常定義的必選引數外，還可以使用預設引數、
#可變引數和關鍵字引數，使得函式定義出來的介面，
#不但能處理複雜的引數，還可以簡化呼叫者的程式碼
 


#預設引數  預設引數在後（呼叫堆疊）
def my_power(x,n=2):
    s = 1
    while n>0:
        n = n - 1
        s = s * x
    return s

print(my_power(5))
print(my_power(5,3))

#預設引數必須指向不變物件
def add_end(L=[]):
    L.append('END')
    return L


print(add_end([1,2,3])) #[1,2,3,'END']  ok
print(add_end(['a','b',3])) #['a','b',3,'END']  ok

print(add_end()) # ['END'] ok
print(add_end()) #  ['END','END']  error  why
print(add_end()) #  ['END','END','END']  error  why   錯誤原因：預設引數指向了變數


def add_end_M(L=None):
    if L is None:
        L = []
    L.append('END')
    return L

print(add_end_M()) #  ['END']  ok
print(add_end_M()) #  ['END']  ok
print(add_end_M()) #  ['END']  ok

#可變引數   允許傳入0個或任意個引數，這些引數在函式呼叫時自動組裝為一個tuple
def calc(numbers):
    sum = 0
    for n in numbers:
        sum = sum + n*n*n
    return sum

print(calc([1,2,3]))
print(calc((1,2,3,4,5)))

#真正的可變引數
def calc_m(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n*n
    return sum

print(calc_m())
print(calc_m(1))
print(calc_m(1,2))
print(calc_m(1,2,3))
print(calc_m(1,2,3,4))

nums = [1,2,3]
print(calc_m(*nums))  # *num 表示把nums這個list的所有元素作為可變引數傳進去。

#關鍵字引數   允許傳入0個或任意個含引數名的引數，這些關鍵字引數在函式內部自動組裝為一個dict。
def person(name,age,**kw):
    print('name:',name,'age:',age,'other:',kw)

print(person('Michael',30))
aa = person('Bob',30,city='Beijing')
print(aa)

#命名關鍵字引數
def person(name,age,**kw):
    if 'city' in kw:
        pass
    if 'job' in kw:
        pass
    print('name:',name,'age:',age,'other:',kw)

person('Jack',24,city='Begin',addr='CHaoyang',zipcode=123456)
#命名關鍵字引數(需要可變引數，或者*分割)   限制關鍵字引數的名字  命名關鍵字引數必須傳入引數名
def person(name,age,*,city,job):
    print(name,age,city,job)

person('Jack',24,city='Begin',job='Engineer')

#如果函式定義中已經有了一個可變引數，後面跟著的命名關鍵字引數就不再需要一個特殊分隔符*了：
def person(name,age,*args,city,job):
    print(name,age,args,city,job)

person('Jack',24,(1,2,3),city='Begin',job='Engineer')
person('Jack',24,city='Begin',job='Engineer')

#命名關鍵字引數可以有預設值
def person(name,age,*,city='beijing',job):
    print(name,age,city,job)

person('Jack',24,job='Engineer')

#遞迴函式
def fact(n):
    if n==1:
        return 1;
    return n*fact(n-1)

print(fact(100))

#尾遞迴  防止棧溢位  
#尾遞迴呼叫時，如果做了優化，棧不會增長，因此，無論多少次呼叫也不會導致棧溢位。
def fact_iter(num,product):
    if num == 1:
        return product
    return fact_iter(num-1,num*product)

def fact(n):
    return fact_iter(n,1)

print(fact(100))`這裡寫程式碼片`