Python 4 (函数,装饰器)

1.函数
1)定义函数
如果不主动调用函数，函数是不会执行的

 def say_hello():
     print 'hello1'
     print 'hello2'
     print 'hello3'

2)函数的调用

 say_hello()
 def sum_2_sum():
     """对两个数字的求和"""
     num1 = 20
     num2 = 20
     result = num1 + num2
     print '%d + %d = %d' %(num1,num2,result)

 sum_2_sum()

3)函数参数的使用
在函数名后面的小括号内填写 参数
多个参数之间使用 , 分隔

定义函数时的变量，叫形参 形参可以任意起名字

def sum_2_sum(num1,num2):
    """

    :param num1:
    :param num2:
    :return:

    """
    result = num1 + num2
    print '%d + %d = %d' %(num1,num2,result)

在调用函数的时候
在调用函数时传递得参数称为实参(真实的数据信息)

sum_2_sum(5,20)

4).函数变量的作用域
局部变量：在函数内部定义的普通变量，只在函数内部作用，函数执行结束变量会自动删除
全局变量：全局生效

a = 1

print 'outside:',id(a)
def fun():
    global a # 声明a为全局变量
    a = 5
    print 'inside:',id(a)
fun()
print a
print id(a)

5)函数形参之四大参数
参数:形参 实参
形参：位置参数 默认参数 可变参数 关键字参数

位置参数：形参和实参个数必须保持一致

 def getInfo(name,age):
     print name,age
 getInfo(age=12,name='westos')

默认参数:形参和实参的个数可以不一致

def mypow(x,y=2):
## 求x的y次方，y的值默认为2
#  :param y:
#  :return:

     print x**y
 mypow(4)
# # 默认形参可以改变
 mypow(4,3)

可变参数

 def mysum(*agrs):

#     *args:是可变参数
#      args：是元组类型数据
#      args:名字可变(因为是形参 名字可变)
#     :param agrs:
#     :return:

     print agrs
     sum = 0
     for item in agrs:
         sum += item
     print sum

# # 对list tuple set 解包时，只需要在变量前加 *
 nums = [1,2,3,4,66,78]
 nums1 =(1,2,3,4,5)
 nums2 = {1,2,3}
# # *nums:解包
 mysum(*nums2)
 mysum(1,2,3,4,5)

关键字参数

扫描二维码关注公众号，回复： 3339065 查看本文章

def getStuInfo(name,age,**kwargs):
#   **kwargs：是一个字典；可以传递任意多的key-value对
#   :param name:
#   :param age:
#   :param kwargs:
#       :return:

    print name,age
    print kwargs
getStuInfo('westos',18,hobbies=['code','running'],gender ='female')

5)函数的返回值
返回值：函数运算的结果，还需要进一步操作时，给一个返回值
return用来返回函数执行结果的,如果没有返回值，默认为None
python可以间接返回多个值(返回了一个元组)
一旦遇到return,函数执行结束，后面的代码不会执行

def mypow(x, y=2):
    return x ** y, x + y
    print 'hello'
    # pass

# 对元组进行解包
a,b = mypow(3)
print a,b

2.函数列表生成式
1)

  li = [ ]
  for item in s.split():
      li.append(int(item))
  k,a,b = li
 k, a, b = [int(item) for item in s.split()]
  print k,a,b

2).生成一个列表，列表元素分别为[1**2,2**2,3**2,4**2…n**2]

 li = [ ]
 for i in range(1, 8):
     li.append(i ** 2)
 print li
 print [i ** 2 for i in range(1, 8)]
# """
# [experssion for i in 序列 if...]
# """

 print [i ** 2 for i in range(1, 8) if i % 2 == 0]

import math

1.找出1~10之间的所有偶数，并且返回一个列表(包含以这个偶数为半径的圆的面积)

li = [ ]
for r in range(2, 11, 2):  # [2,4,6,8,10]
    square = math.pi * r * r
    li.append(square)
print li

print [math.pi * r * r for r in range(2, 11, 2)]

2.找出1～10之间的所有奇数，并且返回一个列表(所有的奇数转换为字符串)

print [str(r) for r in range(1,11,2)]

3.找出1～num之间的所有质数

def isPrime(num):
    for i in range(2,num):
        if num % i == 0:
            return False
    else:
        return True

print [i for i in range(2,101) if isPrime(i)]

3.字典生成式
1.假设有20个学生，学分在60～100之间，筛选出成绩在90分以上的学生

import random

stuInfo = {}
for i in range(20):
     name = 'westos' + str(i)
     score = random.randint(60,100)
          stuInfo[name] = score
# #     stuInfo['westos'+str(i)] = random.randint(60,100)
 hightscore = {}
 for name,score in stuInfo.items():
     if score > 90:
         hightscore[name] = score
 print hightscore

stuInfo = {'westos'+ str(i):random.randint(60,100) for i in range(20)}
print {name:score for name,score in stuInfo.items() if score >90}

2.将字典中的key值和value值调换

d = {'a':'apple','b':'bob','c':'cat'}
print {v:k for k,v in d.items()}
print {k:k.upper()for k,v in d.items()}

3.大小写合并，key值最终全部为小写

d1 = {'A':10,'b':3,'a':5,'B':8,'d':1}
print {k.lower():d1.get(k.upper(),0)+d1.get(k.lower(),0)for k,v in d1.items()}

map函数
map():python内置函数，接收两个参数，一个是函数，一个是序列
map依次将序列传递给函数，并把结果作为新的列表返回

print map(lambda x:x*x,[1,2,3,4,5])

装饰器
在不改变原函数的基础上，给函数增加功能
把一个函数当作参数，返回一个替代版的函数
本质上：返回函数的函数

 def func1():
     print 'have a nice day!'
 def func2():
     print 'good luck!'

 def outer(func):
     def inner():
         print '*********'
         func()
         print '&&&&&&&&&&&&'
     return inner

 func1 = outer(func1)
 func1()

1）语法糖

def say(age):
    print 'man is %d years old' % age

def outer(func):
    def inner(age):
        if age < 0:
            age = 0
        func(age)
    return inner

# "化妆过的函数"
say = outer(say)
# 其实是调用的新的函数
say(-10)

def outer(fun):
    def iner():
        print '中秋快乐！'
        fun()
        print 'hello world!'
    return iner
@outer
def login():
    print '欢迎加入！'
@outer  
def logout():
    print '欢迎下次光临！'
login()  ##调用已经被装饰的函数
logout()

2）带有参数的装饰器
计算函数执行时间

import time


def out(fun):
    def iner(*args, **kwargs):
        star_time = time.time()
        fun(*args, **kwargs)
        end_time = time.time()
        print '运行时间为：%s' % (end_time - star_time)

    return iner


@out
def set(x, y=2):
    time.sleep(1)
    return x ** y
set(5,3)

若要保留被装饰函数的函数名称及文档信息

import time
import functools

def out(fun):
    @functools.wraps(fun)
……
……
print ??.__name__
print ??.__doc__

**导入字母的包

import string
li=[string.ascii_letters for i in range(100) ]

3）带有多个装饰器的函数
**需求: 用户登陆验证的装饰器is_login
1). 如果用户登陆成功, 则执行被装饰的函数
2). 如果用户登陆不成功, 则执行登陆函数

**需求: 判断登陆用户是否未管理员is_admin(此处管理员只有一个为：admin用户)
1).如果用户为管理员, 则执行被装饰的函数
2).如果用户不是管理员, 则报错;

import functools

login_users = ['admin', 'root']

def is_admin(fun):
    @functools.wraps(fun)
    def wrapper(*args,**kwargs):
        if kwargs.get('name') == 'admin':
            res = fun(*args,**kwargs)
            return res
        else:
            return 'Error：您没有权限访问该网站'
    return wrapper


def is_login(fun):
    @functools.wraps(fun)
    def wrapper(*args, **kwargs):
        # 判断要写博客的这个用户是否登陆成功
        if kwargs.get('name') in login_users:
            res = fun(*args, **kwargs)
            return res
        else:
            res = login()
            return res
    return wrapper


@is_login
@is_admin
def writeBlog(name):
    return '编写博客'


def login():
    return '登陆。。。'

print(writeBlog(name='root'))