[python学习笔记]Day3

函数

如：

def is_leapyear(year):
    if (year%4 == 0 and year%100 != 0) or (year%400 == 0):
        return True
    else:
        return False

a = is_leapyear(2016)
print(a)

根据上述例子：

1. is_leapyear是函数名，python中指向对应的内存地址；如执行时可以，"f = is_leapyear;f(2016)"，f也会指向is_leapyear的对应内存地址
2. “year”是形式参数，而执行时“2016”是实际参数
3. return在函数中作终止，如果不设置return值，默认返回"None"。

默认参数

def show(a1,a2=234):    #a2未赋值默认为234
    print(a1,a2)

show(111)
show(111,999)

根据上述例子，a2为默认参数，当调用函数时a2未获得传值，则a2将获得默认值，即a2=234。

指定参数

def show(a1,a2):
    print(a1,a2)

show(a2=111,a1=999)     #不再考虑参数引用顺序

函数的多个参数值一般默认从左到右依次传入，而指定参数则可以任意顺序指定参数。

动态参数（可变长参数）

　　1.*args，自动转换为元组

def show(*args):
    print(args,type(args))

show(1,22,33)

　*args代表一个任意长度的元组，可以接受连续一串参数。

　　2.**kwargs,自动转换为字典

def show(**kwargs):
    print(kwargs,type(kwargs))

show(k1=3,k2=22,k3='fake')

**kwargs代表一个字典，参数的形式是“key=value”，接收连续任意多个参数。

注：

def show(*args,**kwargs):
    print(args, type(args))
    print(kwargs, type(kwargs))

show(11,22,33,44,55,k1='fake',k2=999)  #*args必须放在**kwargs前面，如(x,*args,**kwargs)

l = [1,2,3]
d = {'k2': 999, 'k1': 'fake'}

show(l,d)   #默认把l,d认作*args所指向的元组中的两个元素，故只打印元组，而字典为空
show(*l,**d)    #正确引用方式

应用举例，常应用于format()函数字符串格式化中：

s1 = '{0} is very {1}'  #index要吗都有，要吗都没有
s2 = '{name} is very {condition}'
l = ['Li','poor']
d = {'name':'Liu','condition':'rich'}

ret1 = s1.format(*l)
ret2 = s2.format(**d)

print(ret1,ret2)

匿名函数lambda()

如：

f = lambda a: a**2
result = f(2)
print(result)

lambda()函数通常只是通过简单的运算返回一个需要的值，等价于：

def f(a):
    return a**2

print(f(2))

应用举例：

students = [['Li',100],['Mi',60],['Fa',90]]
students.sort( key = lambda x: x[1],reverse = True)
print(students)

在利用BeautifulSoup中有这样一个小技巧，可以利用lambda函数和map()函数：

# spider 2
def get_item_info_from(url,data=None):
    wb_data = requests.get(url,headers=headers)
    soup = BeautifulSoup(wb_data.text, 'lxml')
    data = {
        'area':list(map(lambda x:x.text,soup.select('ul.det-infor > li:nth-of-type(3) > a'))),
    }
    #soup.select('ul.det-infor > li:nth-of-type(3) > a')返回的是一个列表，里面存放着如：“四川”“-”“雅安”的text信息
    print(data)

　　

递归函数

递归函数就是在自定义函数内部调用其自己，含初始条件和递归两块，如：

 # 计算 n!
 def f(n):
     if n == 1:           #初始条件，结束递归
         return 1
     return n * f(n-1)   #递归

注：

# 进入多少层就得退出多少层
# 可以利用断点观察
def f(n):
    print(n)
    if n/2 > 1:
        ret = f(n/2)
        print('ret:',ret)

    #   当不满足递归条件，即递归完成之后
    print('N:',n)
    #   开始从这儿返回到上一层
    #   注意每一层 N: n  的变化
    return n

f(10)

递归函数实现某些功能相对于用循环结构实现，效率要低很多，但是递归函数常见的应用有很多：

　　1.汉诺塔

counter = 0
def hannuot(n,a,b,c):
    '''hannuot(n,a,b,c)表示
        把A盘上的n个盘子移动到C上
        其中可以用到B'''
    global counter
    if n == 1:
        print 'move disk',n,'from',a,'to',c
    else:
        hannuot(n-1,a,c,b)
        print 'move disk',n,'from',a,'to',c
        hannuot(n-1,b,a,c)
    counter += 1

n=int(raw_input('input a number,plz:'))
hannuot(n,'left','mid','right')
print counter

hannuot

　　2.斐波那契数列（兔子数列）

　　3.随机停车问题

'''车身长为1，停车场长为5'''

import random
s = 0
def parking(low,high):
    if high - low < 1:
        return 0
    else:

        x=random.uniform(low,high-1)

        return parking(low,x) + 1 + parking(x+1,high)
for i in range(1000):
    s =s + parking(0,5)

print s/1000.0

random parking

Python内置函数

python有大量的内置函数，如下图所示：

下面介绍几种常用的内置函数:

　　1.all()函数，括号内的参数为列表，如果当所有元素都为真时返回True，否则返回False

#   all()函数，括号内参数为列表，当列表中的所有元素都为真时返回True,否则返回False
a = all([])
b = all([[]])
c = all([11,22,33])
print(a,b,c)

　　2.any()函数，类似于all()函数，当列表中有一个元素为真时则返回True，否则返回False

　　3.ascii()函数，返回一个可打印的对象字符串方式表示。当遇到非ASCII码时，就会输出\x，\u或\U等字符来表示，与repr()函数等效

ascii(2)
>>> '2'
ascii('c')
>>> "'c'"
ascii('程')
>>> "'\\u7a0b'"

　　4.bytearray()函数，转换成字节数组；bytes()转换成字节

bytearray('python',encoding='utf8')
>>> bytearray(b'python')
bytes('python',encoding='utf8')
>>> b'python'
bytes(2)
>>> b'\x00\x00'

　　5.callable()函数，判断是否可被调用执行

 def f():
     return 1
 x = callable(f)
 l = 23
 y = callable(l)     #即f()可被调用，而l()不行
 print(x,y)

　　6.chr()函数，通过括号内的序号得到对应的ASCII码值，ord()通过括号内ASCII码得到对应的序号值

 >>> ord('A')
 65
 >>> chr(65)
 'A'

　　7.filter()函数，对于序列中的元素进行筛选，最终获取符合条件的序列；map()函数，遍历序列，对序列中每个元素进行操作，最终获取新的序列

代码示例：

 lst = [11,22,33,44]
 new_lst1 = list(map(lambda x: x*100,lst))
 new_lst2 = list(filter(lambda x: x>22,lst))
 print(new_lst1,new_lst2)

　　8.round()函数，四舍五入

 a = round(9.9)
 b = round(9.3)
 print(a,'\n',b)