创建函数

使用def声明，函数的返回值其实是一种tuple（元组）类型

# 创建函数
def myFun():
    return 'This my create myFun'
print myFun()

def addNumber(a,b):
    if not isinstance(a,(int,float)) or not isinstance(b,(int,float)): # 对参数类型进行检查isinstance(),可以用来接口封装上
        raise TypeError('参数类型不对')
    return a+b, a - b
print addNumber(1,9)

• 函数的默认参数的注意

  对于默认参数的选择，我们一般采用的是不可变对象，是为了避免发生不必要的问题产生

def immutable(s = []): # 比如默认参数是一个可变的空列表
    s.append('end')
    print s
immutable() # 第一次调用的时候，默认参数s里增加了一个'end'元素
immutable([1,2]) # 当有参数时是不会有问题的
immutable() # 由于python会记住默认参数的指针地址，当再一次调用默认参数后，现在s值->['end', 'end']
'''
运行结果
['end']
[1, 2, 'end']
['end', 'end']
'''
# 所以对于默认参数，我们一般会指向不变的对象，字符串,常量,None，这样就不会出现问题了
def immutable2(s = None):
    if s == None:
        s = []
    s.append('success')
    print s
immutable2()
immutable2()
'''
运行结果
['success']
['success']
'''

• 可变参数

  可变参数就是参数个数不确定，可以是任意个参数，内部自动将传入的参数组装成元组

# 可变参数
def total(*numbers): # 有点类似匹配规则，*表示可以任意同种类型个数参数
    num = 0
    print numbers
    for x in numbers: # 其实这里的number就是一个元组
        num = num + x
    return num
n = total(1,2,3)
l = [4,5,6]
s = total(*l) # 对于列表或者元组，我们只需要前面传*就好
print n,s
'''
运行结果
(1, 2, 3)
(4, 5, 6)
6 15
'''

• 关键字参数

  关键字参数其实就是一个可变字典，参数值具备键值，可以拓展函数的功能

# 关键字参数，对于一些接口的拓展有很大的作用
def fun(**userInfo):
    print userInfo # 可以看出关键字其实就是一个dict(key不能相同)，所以关键字参数传进来都会有一个类似于键值的东西
fun(name = 'Pocket',age = 23,sex = '男',love = 'Baby')
d = {'name' : 'Baby', 'age' : 22}
fun(**d)
'''
运行结果
{'age': 23, 'love': 'Baby', 'name': 'Pocket', 'sex': '\xe7\x94\xb7'}
{'age': 22, 'name': 'Baby'}
'''

• 组合参数

  固定参数、默认参数、可变参数、关键字参数相互组合而成

# 组合参数
def combination(name, age, sex = 'man', *agrs, **kw):
    print name,age,sex,agrs,kw
# 下面两种调用结果是等效的，原因是可变参数发挥了其特性，补充了默认参数
combination('Pocket', 23, *('woman',3,4))
combination('Pocket', 23, 'woman', *(3,4))
# 传参数顺序必须是：（固定参数，默认参数，可变参数，关键字参数），当可变参数用list或者元组包装后关键字参数与可变参数()可以互换位置传递，可以被自动检测出的
combination('Baby', 22, 'woman', love = 'Pocket', *(1,3), test = 'test')
combination('qwer', 21, 'man',1,3,5,n = 'qwer')
'''
运行结果
Pocket 23 woman (3, 4) {}
Pocket 23 woman (3, 4) {}
Baby 22 woman (1, 3) {'test': 'test', 'love': 'Pocket'}
qwer 21 man (1, 3, 5) {'n': 'qwer'}
'''

切片

很多时候我们需要对list、tuple、字符串进行一些截取性的操作，这时候python为我们提供了切片的工具

# 切片
l = range(20)
print l[0:3] # 从索引0开始-索引3结束(不包括索引3)
print l[:4] # 如果是从索引0开始，可以省略
print l[3:10]
print l[-3:-1] 
print l[:10:4] #从索引0-10（不包括索引10），每4个元素取值
copy = l[:] # 什么都不写直接:,相当于复制一个list
print copy

t = ('q','w','e','r') # 切片在元组同样适用
print t[1:3]

s = "Pocket" # 切片在字符串中同样适用
print s[1:4]
'''
运行结果
[0, 1, 2]
[0, 1, 2, 3]
[3, 4, 5, 6, 7, 8, 9]
[17, 18]
[0, 4, 8]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
('w', 'e')
ock
'''

迭代

就是对可遍历对象的一种遍历方式，在python中叫做迭代

# 迭代（遍历）
# list、tuple
l = [1,2,3,4,5]
for x in l: # list 的迭代
    print x
for i, value in enumerate(l): # list 下标方式迭代方式
    print i, value

# dict
d = {'name':'Pocket', 'age' : 23, 'sex' : 'man'}
for key in d: # dict 的key 的迭代方式
    print key
for value in d.iteritems(): # dict 的value 的迭代方式
    print value
for key, value in d.iteritems(): # dict 的 key-value 的迭代方式
    print key, value

# string
s = 'Pocket'
for x in s: # 字符串迭代
    print x

# 判断对象是否属于可迭代对象
from collections import Iterable
print isinstance(123,Iterable)
'''
运行结果
1
2
3
4
5
0 1
1 2
2 3
3 4
4 5
age
name
sex
('age', 23)
('name', 'Pocket')
('sex', 'man')
age 23
name Pocket
sex man
P
o
c
k
e
t
False
'''

列表生成式

快速根据自己需求生成一个list，很方便的一种写法

# 列表生成式
l1 = [x + x for x in [1,2,3]] # 直接生成一个每个元素自身相加之和的list
print l1
l2 = [x for x in range(10) if x % 2 == 0] # 生成式中还可以增加if判断，过滤非偶数
print l2
l3 = [p + b for p in 'Pocket' for b in 'Baby'] # 也可以多层循环（一般两层比较常见）
print l3

import os # 导入os模块
l4 = [d for d in os.listdir('.')] # 生成一个当前目录下的所有文件名的list
print l4
'''
运行结果
[2, 4, 6]
[0, 2, 4, 6, 8]
['PB', 'Pa', 'Pb', 'Py', 'oB', 'oa', 'ob', 'oy', 'cB', 'ca', 'cb', 'cy', 'kB', 'ka', 'kb', 'ky', 'eB', 'ea', 'eb', 'ey', 'tB', 'ta', 'tb', 'ty']
['day1.py', 'day2.py', 'day3.py', 'day4.py']
'''

生成器（generator）

为生成式节省一些不必要的内存空间

# 生成器
l = (x + x for x in range(4)) # 生成器与生成式很像，一个是(),一个是[]表示
print l
print l.next() # 生成器取值可以用next来取，只是很麻烦，每次都只能取一个，一般我们用迭代做for循环
print l.next()
for value in l: # 生成器也是一种可迭代对象，注意这里由于上面执行了两次next，所以这里for循环并不是从最开始的地方执行（理解：就当做生成器会记住每次执行的索引）
    print value

# 含有生成器的函数
def generator(n):
    while n != 0:
        if n % 2 == 0:
            yield n # 如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator
        n = n - 1
g = generator(10)
for x in g:
    print x
# print g.next() # 当生成器没有更多的元素时，会抛出StopIteration的错误。
'''
运行结果
<generator object <genexpr> at 0x10fbe3b40>
0
2
4
6
10
8
6
4
2
'''