用return的方式取得proc下的进程号

#!/usr/bin/env python

import os

PidFile = os.listdir('/proc')

def isPid(pid):

    if pid.isdigit():

        return True

    return  False

for i in PidFile:

    if isPid(i):

        print i,

　　注意：在函数中我们一般不会对结果进行打印，而是使用return把结果返回给调用它的地方。

if 1 > 3:

    print 'lt'

else:

    print 'gt'

print 'lt' if 1>3 else 'gt'

匿名函数

# 常规版本：

def fun(x,y)

    return x*y

# lambda版本：

r = lambda x,y:x*y

print(r(1,2))

lambda 参数列表：[表达式]

# 搭配reduce的应用

# reduce(fun,list)

# reduce依次把list中的数字赋值给fun进行计算

# 注意fun必须是连个数字间的运算，list必须是整型数字

# 例：求1到100的累加

reduce (lambda x,y:x + y,xrange(1,101)

# 应用：

ret = (lambda x,y:x+y)(2,3)

print(ret)
 

abs()  # 计算绝对值,abs(-10),接收number，返回一个number

max() # 求序列的的最大值（可迭代的），同时也可以比较一些数字

min() # 求序列的最小值（可迭代的），同时也可以比较一些数字

len() # 求序列的长度，（字典也可以，求index的个数）

divmod(x,y)    # 求x,y的商和余数，存放在元组中

pow(x,y,z) # 求x的y次方，如果有第三个参数，那么把前面的结果和第三个参数求余

round(number) # 用来四折五入，后面可以跟精度（先把number编程浮点数，然后看保留几位）把12.45转换成float，那么就不是12.45了，而可能是12.4999999了

callable() # 判断一个对象是否是可调用的，比如函数，类都是可以调用的，但是变量无法调用

type（） # 查看对象的类型

isinstance（对象，类型） # 判断一个对象是否是给定类型。类型可以是多个，只要是其中1个即可(类型1，类型2)

cmp（x,y） # 比较两个对象的大小，x大于y返回1，x等于y返回-1，x小于y返回-1，字符串也可以比较，是按单个字符的大小开始比对。

str() # 可以把任何数据转换成字符串（字典，元组，也会直接输出）

hex(10) # 把10进制转换为8进制

eval() # 把字符串当做一个有效的表达式来求值

# eval('1+2') 返回3

# eval("[1,2,3]") 返回[1,2,3]

oct() # 把10进制转换为8进制

chr(i) # i的范围是0~255，求i对应的acsii码值

ord(i） # i的范围是ascii的值，求对应的值

filter（函数或空，序列） # 用来过滤，把序列的每一个元素，交给函数来处理。如果为None，则什么也不做，直接输出（序列），如果有函数，那么只有函数的返回值为True才打印序列中的元素

例子：

def even(n):

    if n % 2 == 0:

        return True

    filter(even,xrange(10))

    [0, 2, 4, 6, 8]

高级写法：

    filter(lambda x: x%2 ==0,xrange(10)

zip(seq1，seq2,seqN...) # 把seq1和seq2组合成1个大的列表，每个序列取1个组成元组，存放在整合后的列表中，如果序列的长度不同，那么就以最小的序列的长度为基准。

map(func,seq1,seq2) # 返回也是一个列表，func可以是一个函数也可以是个None，如果为None，那么返回的列表长度以当前最长列表为基准，依旧是依次去每个列表中去取，只不过没有的，用none补充

例子：

l1 = [1, 2, 3]

l2 = ['a', 'b', 'c', 'd']

l3 = ['I', 'II', 'III', 'IV', 'V', 'VI']

map(None,l1,l2,l3)

[(1, 'a', 'I'),

(2, 'b', 'II'),

(3, 'c', 'III'),

(None, 'd', 'IV'),

(None, None, 'V'),

(None, None, 'VI')]

# 如果函数位上是一个函数，那么如果只有1列表，那么就需要这个函数定义1个参数，然后每次把列表中的1个元素交给函数进行处理，并打印，或者保存在迭代器中去

# 如果需要处理两个序列，那么函数就必须定义2个参数，去接受这两个序列的元素。

# 高级应用：

map(lambda x,y:x+y,l1,l4)

reduce(func,seq) # 只能定义1个序列，然后传递给func进行处理。（lambda函数求累加）

def func():

    print('from func')

f = func     #把函数地址当作变量一样进行传递

f() 

def func():

    print('from func')

def wapper(func):

    print('from wapper',func)

wapper(func)  #把函数的地址作为变量传递给另一个函数

def func():

    print('from func')

def wapper(func):

    return func

f = wapper(func)     #把函数的内存地址传递，并返回，用f接收那么f就等于func的内存地址，那么加上括号就可以运行

f()

def func():

    print('from func')

func_dict = {'func':func}    #直接作为字典的值存储，那么调用函数就可以用  func_dict['func']() 直接进行调用了

def max2(a,b):   #判断两个变量的最大值

    return a if  a > b else b

def max4(a,b,c,d):  #判断四个变量的最大值

    res1 = max2(a,b)  #函数的嵌套调用

    res2 = max2(res1,c)

    res3 = max(res2,d)

    print(res3)

max4(10,100,21,99)

def func1():

    print('from func1')

    def func2():

        print('from func2')

        def func3():

            print('from func3')

        func3()  # 只有在func2中才能调用内部定义的函数func3

    func2()

func1()

# 语法格式：  [ exp for val in collection if condition ]

[ i for i in range(1,11) if i % 2 == 0 ]

# 列表生成式打印 1-10 中的偶数

 def func():

     a = []

     for i in range(1,11):

         if i % 2 == 0 :

             a.append(i)

     return a 

 print(func())

普通的方法获取1-10中的偶数

# 修改列表生成式，创建生成器

a = ( i for i in range(1,11) if i % 2 == 0 )

# 使用yield关键字创建 生成器

def func():

    for i in range(1,11):

        if i % 2 == 0 :

            yield i

import time

def timer(func):

    def wapper():

        start_time = time.time()

        res = func()

        end_time = time.time()

        return res,(end_time - start_time)

    return wapper

@timer       # 在被装饰函数上添加 Python 特有的语法棒棒糖表示，装饰后面的函数

def index():

    time.sleep(3)

    return 'hello index'

print(index())

import time

import functools   # 需要引入代码包

def timer(func):

    @functools.wraps(func)   # 继承函数的__name__等属性

    def wapper():

        start_time = time.time()

        res = func()

        end_time = time.time()

        return res,( end_time - start_time )

    return wapper

@timer

def index():

    time.sleep(3)

    return 'hello index'

print(index.__name__)