python基础学习（二）

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))`这里写代码片`