1 dir(): 默认打印当前模块的所有属性，如果传一个对象参数则打印当前对象的变量名
2 vars() 默认打印当前模块的所有属性，如果传一个对象参数则打印当前对象的变量名和值
3 reload() 将以前导入过的模块再加载一次,这样就允许在不退出解释器的情况下重新加载已更改的Python模块。
4 id() 标示内存地址
5 cmp(x,y) 根据比较两个对象x和y的结果，返回一个整数。如果x<y,返回值是负的(-1),如果x==y,返回0，如果 x > y,返回一个正数(1).
6 abs(x) 返回一个数的绝对值
7 bool() 布尔值
8 divmod( a, b) 取商和余数
9 max() 取最大值
10 min() 最小值
11 sum() 求和 sum([1,2,4])
12 pow() 幂子方 pow(2,4) 2的四字方
13 len() 求字符串长度.
14 all() 全为真，就为真.
15 any() 只要有一个为真，就为真
16 chr() 参数是0 - 256 的一个整数，返回值是当前整数对应的ascii字符.参数可以是10进制也可以是16进制的形式
17 ord() 参数是一个ascii字符，返回值是对应的十进制整数
18 hex() 返回十六进制
19 oct() 返回八进制
20 bin() 返回二进制
21 zip() zip()函数来可以把列表合并，并创建一个元组对的列表。
22 enumerate 函数用于遍历序列中的元素以及它们的下标.
def 函数名(参数):
...
函数体
...
函数的定义主要有如下要点：
- def：表示函数的关键字
- 函数名：函数的名称，日后根据函数名调用函数
- 函数体：函数中进行一系列的逻辑计算，如：发送邮件、计算出 [11,22,38,888,2]中的最大数等...
- 参数：为函数体提供数据
- 返回值：当函数执行完毕后，可以给调用者返回数据。
以上要点中，比较重要有参数和返回值：
和其他高级语言区别:
1.声明函数名尾部要有冒号.
2.它不需要用花括号将语句块括起来，用TAB键缩进.
函数式编程最重要的是增强代码的重用性和可读性
实例：
def test_a():
print 'hello world'
print 'www.jeapedu.com'
def test_b(varl,var2): #函数定义，形参,提供给使用者一个接口.
print val1,
print val2,
print 'Entry programme'
test_a()
test_b(12,13) #函数调用，实参.
print 'leave programme'
1、返回值
函数是一个功能块，该功能到底执行成功与否，需要通过返回值来告知调用者。
def 发送短信():
发送短信的代码...
if 发送成功:
return True
else:
return False
while True:
# 每次执行发送短信函数，都会将返回值自动赋值给result
# 之后，可以根据result来写日志，或重发等操作
result = 发送短信()
if result == False:
记录日志，短信发送失败...
2、参数
为什么要有参数？看下下面的例子：
如果不定义参数，用函数的话：（每个有相同功能的都写个函数，说好的代码简化呢？）
def CPU报警邮件()
#发送邮件提醒
连接邮箱服务器
发送邮件
关闭连接
def 硬盘报警邮件()
#发送邮件提醒
连接邮箱服务器
发送邮件
关闭连接
def 内存报警邮件()
#发送邮件提醒
连接邮箱服务器
发送邮件
关闭连接
while True：
if cpu利用率 > 90%:
CPU报警邮件（）
if 硬盘使用空间 > 90%:
硬盘报警邮件（）
if 内存占用 > 80%:
内存报警邮件（）
函数有三中不同的参数：
- 普通参数
- 默认参数
- 动态参数
1,接收多个参数
2,内部自动构造元组
3,序列,*,避免内部构造元组1 >>> li = (1,2,3,4,5,66,'alex')
2 >>>
3 >>> def func(*args):
4 ... print args
5 ...
6 >>> func(li)
7 ((1, 2, 3, 4, 5, 66, 'alex'),)
8 >>> func(*li)
9 (1, 2, 3, 4, 5, 66, 'alex')
10 >>> li = [1,2,3,4,5,66,'alex']
11 >>> def func(*args):
12 ... print args
13 ... print args[0] 通过下标获取元素
14 >>> func(li)
15 ([1, 2, 3, 4, 5, 66, 'alex'],)
16 >>> func(*li)
17 (1, 2, 3, 4, 5, 66, 'alex')
18 >>>
如果一个函数定义中的最后一个形参有 ** （双星号）前缀,所有正常形参之外的其他的关键字参数都将被放置在一个字典中传递给函数，比如：
1 def contacs(a,**b):
2 print "a is: %s" %a
3 for i in b:
4 print i + ":" + str(b[i])
5
6 contacs(100, saneri=1234567890,rain=007) #调用
7
8 a is: 100 #执行结果
9 saneri:1234567890
10 rain:7
扩展：发送邮件实例
import smtplib
from email.mime.text import MIMEText
from email.utils import formataddr
def email(message):
msg = MIMEText("邮件报警测试", 'plain', 'utf-8')
msg['From'] = formataddr(["saneri",'saneri@126.com']) #发件人和发件邮箱
msg['To'] = formataddr(["收件人",'838118461@qq.com'])
msg['Subject'] = message #这里我调用了参数
server = smtplib.SMTP("smtp.126.com", 25)
server.login("saneri@126.com", "密码")
server.sendmail('shuaige@126.com', ['451161316@qq.com',], msg.as_string())
server.quit()
if __name__ == u'__main__':
cpu = 100
disk = 500
ram = 50
for i in range(1):
if cpu > 90:
alert = u'CPU出问题了' #这里设置了一个变量
email(alert) #这里调用函数的时候引用了上面的变量，当执行函数的时候形参讲会被替换掉，message='CPU出问题了' 发送邮件！
if disk > 90:
alert = u'硬盘出问题了'
email(alert)
if ram> 80:
alert = u'内存出问题了'
email(alert)
--------------------------------------------------------------------------------------------------
如果执行python test.py 等同于 __name__ == '__mail__'
被执行的脚步，__name_'值 ==__mail__
条件运算时，对于简单的 if else 语句，可以使用三元运算来表示，即：
1 # 普通条件语句
2
3 if 1 == 1:
4
5 name = 'wusiri'
6
7 else:
8
9 name = 'asir'
10
13 # 三元运算
14
15 name = 'wusiri' if 1 == 1 else 'asir'
对于简单的函数，也存在一种简便的表示方式，即：lambda表达式
1 # ###################### 普通函数 ######################
2
3 # 定义函数（普通方式）
4
5 def fun(arg):
6
7 return arg + 1
8
9 # 执行函数
10
11 result = fun(123)
12
13 # ###################### lambda ######################
14
17 # 定义函数（lambda表达式）
18
19 my_lambda = lambda arg : arg + 1
22
23 # 执行函数
24
25 result = my_lambda(123)
#lambda存在意义就是对简单函数的简洁表示:
一、map
遍历序列，对序列中每个元素进行操作，最终获取新的序列。
map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。
>>> def f(x):
... return x * x
...
>>> map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
[1, 4, 9, 16, 25, 36, 49, 64, 81]
#map()传入的第一个参数是f，即函数对象本身。
1 #每个元素增加100
2
3 li = [11, 22, 33]
4
5 new_list = map(lambda a: a + 100, li)
6
7
8 #两个列表对应元素相加
9
10 li = [11, 22, 33]
11 sl = [1, 2, 3]
12 new_list = map(lambda a, b: a + b, li, sl)
k1 = [11,20,23]
k2 = [2,5,8]
def func4(a1,a2):
return a1 + a2
print map(func4,k1,k2)
二、filter
对序列中的元素依次进行筛选，将执行结果为True的元素组成一个序列(List/String/Tuple)（取决于序列的类型）返回：
1 li = [11, 22, 33]
2
3 new_list = filter(lambda arg: arg > 22, li)
4
5 #filter第一个参数为空，将获取原来序列
1 def f(x):
2 return x != 'a'
3
4 filter(f, "abcdef")
5 'bcdef'
三、reduce
对于序列内所有元素进行累计操作:
1 def add(x,y):
2 return x + y
3
4
5 reduce(add, range(1, 11))
6 值：
7 55 （注：1+2+3+4+5+6+7+8+9+10）
8
9 reduce(add, range(1, 11), 20)
10 值为：
11
12 75 （注：1+2+3+4+5+6+7+8+9+10+20）
li = [1,2,3,4,5,6,7,8,9]
print reduce(lambda arg1,arg2:arg1*arg2,li) //对li中的元素进行垒乘计算
362880
li = [1,2,3,4,5,6,7,8,9]
print reduce(lambda arg1,arg2:arg1*arg2,li,100) #100为基数,再100的基础上进行加减乘除.
# reduce的第一个参数，函数必须要有两个参数
# reduce的第二个参数，要循环的序列
# reduce的第三个参数，初始值
1、对比range 和 xrange 的区别:
1 >>> print range(10)
2 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
3 >>> print xrange(10)
4 xrange(10)
如上代码所示，range会在内存中创建所有指定的数字，而xrange不会立即创建，只有在迭代循环时，才去创建每个数组。
1 def funt():
2 yield 1
3 yield 2
4 yield 3
5
6 for i in funt():
7 print i
8 ##################################
9
10 def mrange(arg):
11 seed = 0
12 while True:
13 seed += 1
14 if seed > 10:
15 return
16 else:
17 yield seed
18
19 for i in mrange(10):
20 print i
2、文件操作的 read 和 xreadlinex 的的区别:
read会读取所有内容到内存
xreadlines则只有在循环迭代时才获取
1 基于seek和tell自定义生成器NReadlines:
2
3 def NReadlines():
4 with open('log','r') as f:
5 seek = 0
6 while True:
7 f.seek(seek)
8 data = f.readline()
9 if data:
10 seek = f.tell()
11 yield data
12 else:
13 return
14
15 for item in NReadlines():
16 print item
装饰器是函数，只不过该函数可以具有特殊的含义，装饰器用来装饰函数或类，使用装饰器可以在函数执行前和执行后添加相应操作。
使用装饰函数在函数执行前和执行后分别附加额外功能: 1 #使用装饰函数在函数执行前和执行后分别附加额外功能 2 #装饰函数的参数是被装饰的函数的对象，返回原函数对象
3 下例为替换函数(装饰)：
4
5 def deco(func): #装饰函数
6 print "before myfunc() called"
7 func()
8 print "after myfunc() called."
9 return func
10
11 def myfunc(): #被装饰函数
12 print "myfunc() called."
13
14 #myfunc = deco(myfunc)
#myfunc()
#myfunc()
15 result = deco(myfunc)
16 result()
17 result()
使用语法糖@来装饰函数:
1 使用语法糖@来装饰函数，相当于上例中 “myfunc= deco(myfunc)”
2
3 def deco(func):
4 print("before myfunc() called.")
5 func()
6 print(" after myfunc() called.")
7 return func
8
9 @deco
10 def myfunc():
11 print(" myfunc() called.")
12
13 myfunc()
14 myfunc()
return 语句用来从函数中return(返回)，也就是说跳出函数。同样，我们也可以从函数中选择性地返回一个值。
1 def maximum(x, y):
2 if x > y:
3 return x
4 elif x == y:
5 return '两个数相等'
6 else:
7 return y
8
9 print(maximum(2, 3))
输出：
3
冒泡算法：将需要排序的元素看作是一个个“气泡”，最小的“气泡”最先浮出水面，排在最前面。从小到大依次排列。
实例：
1 需求：请按照从小到大对列表 [13, 22, 6, 99, 11] 进行排序
2
3 思路：相邻两个值进行比较，将较大的值放在右侧，依次比较！
4
5 li = [13, 22, 6, 99, 11]
6
7 for m in range(len(li)-1):
8
9 for n in range(m+1, len(li)):
10
11 if li[m] > li[n]:
12 temp = li[n]
13
14 li[n] = li[m]
15 li[m] = temp
16 print li
实例2：
1 def popo(numbers):
2 for x in xrange(len(numbers)-1, -1, -1):
3 for i in xrange(x):
4 if numbers[i] > numbers[i+1]:
5 numbers[i], numbers[i+1] = numbers[i+1], numbers[i] # 交换数据
6 print numbers
7
8 def main():
9 numbers = [23, 12, 9, 15, 6]
10 popo(numbers)
11
12 if __name__ == '__main__':
13 main()
1 #将a和b的值互换位置,使a =123 ,b =abc:
2 a = "abc"
3 b = 123
4
5 temp = a #定义中间变量temp
6 a= b
7 b = temp
8 print "a = %s" %a ,"\n" "b = %s" %b,
9
10 打印输出：
11
12 a = 123
13 b = abc
递归：
规律：除过第一个和第二个数外，前两个数相加都是第三个数的值！！！
斐波那契数列指的是这样一个数列 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946，17711，28657
1 def func(arg1,arg2):
2 if arg1 == 0: #如果arg1等于0
3 print arg1, arg2 #打印出arg1，arg24 arg3 = arg1 + arg2
5 print arg3
6 func(arg2, arg3) #将func(arg2,arg3)的值给func(arg1,arg2)再执行
7 8 func(0,1)
递归：
1 def func(arg1,arg2):
2 if arg1 == 0:
3 print arg1, arg2
4 arg3 = arg1 + arg2
5 #print arg3
6 if arg3 > 1000:
7
8 return arg3
9 return func(arg2, arg3) #将func(arg2,arg3)的值给func(arg1,arg2)再执行
10
11 #func(0,1)
12 result = func(0,1)
13 print result