python入门（一） --函数

python入门（一） --函数

函数.抽象概念

如何在字典中找到100对应的所有key值

varibal ={
    'a':100,
    'b':100,
    'c':200
}
varibal['a']
100
varibal.items()

dict_items([('a', 100), ('b', 100), ('c', 200)])
#遍历字典
[key for key ,value in varibal.items() if value ==100]
['a', 'b']

def get_keys(dict_varibel,value):
    return [k for k ,v in dict_varibel.items() if v == value]
get_keys(varibal,200)

['c']

get_keys(varibal,200)
get_keys(varibal,200)
[‘c’]
** 函数是组织好的，可重复使用的，能够完成特定功能的代码段，它是代码块的抽象**

函数由函数名 ，形参和返回值组成。

参数分为位置参数和关键字参数，如果用位置参数，很容易混乱函数放置的位置，如果给参数赋值，就可以不必按照原来的参数顺序放置
​

get_keys(dict_varibel={'a':20}, value = 20)
['a']
get_keys( value = 20,dict_varibel={'a':20})
['a']

函数通过参数获取我们传递的值，函数中改变了参数，那么我们传递的值会改变吗
def test(varibal):
varibal = 100
return varibal
var =1
test(var)
var =1
test(var)
100
var
** 当var有值时，不改变var的值，当var为空时，会改变var的值**
1
var=[]
test(var)
100
赋值

**不建议对可变类型在函数内进行修改，建议用函数返回值进行重新赋值

return temp
def test(varibal):
temp = varibal.copy()
temp.append(100)
return temp
var
var = []
var = test(var)
var
[100]

参数的收集

def test(name,age,*arge, **kwarge):        #输入的参数可以为任意的类型或者关键字
     print(name,age,*arge,**kwarge)         #输出为输入
     
test('wang',12)
wang 12

dict_varibals = {
    'weight':120,
    'height':175
}
test('wong',12,dict_varibals)

wong 12 {'weight': 120, 'height': 175}

装饰器 被用来区分新手和老手

a=10
b=[12,12]
def test():
    print('test')
c=test
c
<function __main__.test()>

可以把函数赋值给一个变量

c.__name__
'test'

函数可以返回函数

def test(func):
    return func
def func():
    print('func run')
​
f =test(func)
f.__name__
'func'

**
函数可以当做函数的返回值进行返回

f()

func run

#需求：返回一个从0到1的浮点值

import random
random.random()

0.49500584968514516

def test(): 
    return random.random()
test()
0.2502416440658627

round(random.random(),3)
0.235

#函数返回的浮点数保留三位有效数字

def test(): 
    return round(random.random(),3)
   
test()

0.678

利用python另一个语法糖，装饰器的方法

#返回一个从0到1的浮点值
def test(): 
    return random.random()
    
def decorator(func):
    def wrapper(*arge,**kwarge):
        return func()
    return wrapper
 
f = decorator(test)
f
<function __main__.decorator.<locals>.wrapper(*arge, **kwarge)>
f()
0.65202651090431

如果有很多地方都想改变，每个去修改就很不方便，装饰器，可以只修改装饰器内的内容，其他被装饰器装饰的，都会跟着改变
利用python另一个语法糖，装饰器的方法

#返回一个从0到1的浮点值
@decorator    #装饰器加@后，相当于f = decorator(test)这行代码，两者完全等价，如果没有这行代码，test name为test
def test(): 
    return random.random()
    
def decorator(func):
    def wrapper(*arge,**kwarge):
        ##do somthing
        return func()
    return wrapper
   
#f = decorator(test)
f()    #f的调用，实际是调用的test.f = decorator(test)
0.552135547899615
test.__name__
'wrapper'

#利用python另一个语法糖，装饰器的方法

#返回一个从0到1的浮点值
def decorator(func):
    def wrapper(*arge,**kwarge):
        #do somthing
        return round(func(*arge,**kwarge),3) #做了改变，这样修改3即可控制几位有效数字
        #do somthing
    return wrapper

@decorator#装饰器加@后，相当于f = decorator(test)这行代码，两者完全等价，如果没有这行代码，test name为test
def test(): 
    return random.random()
@decorator
def test_two():
    return random.random()*10
    
test()
0.902

test_two()
1.68