python learning2

In [1]:
#python函数
#内置函数
#int()
#float()等强制转换函数
#abs()求绝对值
1>3#可以直接比较大小
Out[1]:
False
In [2]:
a=abs#相当于把函数名赋给了一个变量
a(-5)
Out[2]:
5
In [3]:
#定义一个函数
#定义空函数
def nop():
    pass#pass什么都不做

def my_abs(x):
    if x>=0:
        return x
    else:
        return -x
In [4]:
#函数的返回值，其实是单一值，只是返回如果写两个，它会对应赋到对应的值
import math
def move(x,y,step,angle=0):
    nx=x+step*math.cos(angle)
    ny=y-step*math.sin(angle)
    return nx,ny
In [5]:
x,y=move(100,100,60,math.pi/6)
print(x,y)

151.96152422706632 70.0
In [6]:
r=move(100,100,60,math.pi/6)
r
Out[6]:
(151.96152422706632, 70.0)
In [7]:
#函数的默认参数
def power(x):
    return x*x
In [8]:
power(5)
Out[8]:
25
In [9]:
#如果想计算函数的三次方怎么办呢？
def power(x,n):
    s=1
    while n>0:
        n=n-1
        s=s*x
    return s
In [10]:
power(5,2)
Out[10]:
25
In [11]:
power(5,3)
Out[11]:
125
In [13]:
#power(5)会报错，因为此时in(9)中的函数已经替代了之前只有一个参数的函数
#重新定义power
def power(x,n=2):
    s=1
    while n>0:
        n=n-1
        s=s*x
    return s
power(5)
#此时默认n=2
Out[13]:
25
In [ ]:
#那么当函数有多个参数的时候，一般将变化大的参数放在前面，变化小的参数放在后面（可以设置默认值）。
In [14]:
def add_end(L=[]):
    L.append('End')
    return L
add_end([1,2,3])
Out[14]:
[1, 2, 3, 'End']
In [15]:
#但是如果多次调用上面的函数
add_end()
Out[15]:
['End']
In [16]:
add_end()
Out[16]:
['End', 'End']

结果就不对了，因为python中默认参数L的值已经被计算出来了
默认参数必须是不可变的量
所以上面的函数应该改为
In [20]:
def add_end(L=None):
    if L==None:
        L=[]
    L.append('End')
    return L
In [21]:
add_end()
Out[21]:
['End']
In [22]:
add_end()
Out[22]:
['End']

可变参数
比如计算a^2+b^2+c^2....
In [23]:
def calc(numbers):
    sum=0
    for n in numbers:
        sum=sum+n*n
    return sum
In [24]:
calc([1,2,3])
Out[24]:
14
In [25]:
calc((1,2,3))#tuple
Out[25]:
14
In [28]:
#定义可变参数和定义list或tuple参数相比，仅仅在参数前面加了一个*号。
#调用该函数时，可以传入任意个参数，包括0个参数
def clac(*numbers):
    sum=0
    for n in numbers:
        sum=sum+n*n
    return sum
In [29]:
clac(1,2)
Out[29]:
5
In [30]:
clac()
Out[30]:
0
In [31]:
nums=[1,2,3]
clac(nums)#此时就不能直接调用list

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-31-479cce2509ba> in <module>()
      1 nums=[1,2,3]
----> 2 clac(nums)

<ipython-input-28-7f21f5858778> in clac(*numbers)
      4     sum=0
      5     for n in numbers:
----> 6         sum=sum+n*n
      7     return sum

TypeError: can't multiply sequence by non-int of type 'list'
In [32]:
clac(nums[0],nums[1],nums[2])
#这样太繁琐
Out[32]:
14
In [34]:
clac(*nums)
Out[34]:
14

关键字参数**
可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。
In [35]:
def person(name,age,**kw):
    print('name:',name,' age:',age,' other:',kw)
    
In [36]:
person('Michael',30)

name: Michael  age: 30  other: {}
In [37]:
person('Bob',35,city='Beijing')

name: Bob  age: 35  other: {'city': 'Beijing'}
In [38]:
person('Adam',45,gender='M',job='Engineer')

name: Adam  age: 45  other: {'gender': 'M', 'job': 'Engineer'}
In [39]:
#上面的写法，可以换成
kw={'city':'Beijing','job':'Engineer'}
person('Jack',24,**kw)

name: Jack  age: 24  other: {'job': 'Engineer', 'city': 'Beijing'}

参数组合
在Python中定义函数，可以用必选参数、默认参数、可变参数和关键字参数，这4种参数都可以一起使用，或者只用其中某些，但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数和关键字参数。
In [44]:
def func(a,b,c=0,*argc,**kw):
    print('a=',a,' b= ',b,' c=',c,' args=',argc,' kw=',kw)
In [45]:
func(1,2,3,'a','b')

a= 1  b=  2  c= 3  args= ('a', 'b')  kw= {}
In [46]:
func(1,2,3,'a','b',x=99)

a= 1  b=  2  c= 3  args= ('a', 'b')  kw= {'x': 99}

Python的函数具有非常灵活的参数形态，既可以实现简单的调用，又可以传入非常复杂的参数。
默认参数一定要用不可变对象，如果是可变对象，运行会有逻辑错误！
要注意定义可变参数和关键字参数的语法：
*args是可变参数，args接收的是一个tuple；
**kw是关键字参数，kw接收的是一个dict。
以及调用函数时如何传入可变参数和关键字参数的语法：
可变参数既可以直接传入：func(1, 2, 3)，又可以先组装list或tuple，再通过args传入：func((1, 2, 3))；
关键字参数既可以直接传入：func(a=1, b=2)，又可以先组装dict，再通过kw传入：func({'a': 1, 'b': 2})。
使用*args和**kw是Python的习惯写法，当然也可以用其他参数名，但最好使用习惯用法。
In [48]:
args = (1, 2, 3, 4)
kw = {'x': 99}
func(*args, **kw)

a= 1  b=  2  c= 3  args= (4,)  kw= {'x': 99}

递归函数
In [49]:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-

# 利用递归函数计算阶乘
# N! = 1 * 2 * 3 * ... * N
def fact(n):
    if n == 1:
        return 1
    return n * fact(n-1)

print('fact(1) =', fact(1))
print('fact(5) =', fact(5))
print('fact(10) =', fact(10))

# 利用递归函数移动汉诺塔:
def move(n, a, b, c):
    if n == 1:
        print('move', a, '-->', c)
    else:
        move(n-1, a, c, b)
        move(1, a, b, c)
        move(n-1, b, a, c)

move(4, 'A', 'B', 'C')

fact(1) = 1
fact(5) = 120
fact(10) = 3628800
move A --> B
move A --> C
move B --> C
move A --> B
move C --> A
move C --> B
move A --> B
move A --> C
move B --> C
move B --> A
move C --> A
move B --> C
move A --> B
move A --> C
move B --> C
In [ ]:
 
In [ ]:
 
In [ ]:
 
In [ ]:
 
In [ ]:
 
In [ ]: