Python函数相关笔记

函数：

将重复的代码，封装到函数，增强代码的模块化和提高代码的重复利用率。

格式：

def 函数名（[参数]):
    函数体（重复的代码）

注意：必须使用关键字def 2：函数体注意缩进 3:函数体（）绑定

定义函数：随机数的产生

import random


def generate_random():

    for in in range(10):
    
        ran = random.randint()
            
        print(ran)
print(generate_random)

执行：function generate_random at 0x000001390F096280 #函数地址 如果带括号则直接执行函数整体

调用：函数 找到函数并执行函数体的内容

generate_random()
16
18
5
15
12
6
10
20
3
10

函数：带参数的

    定义：
        def 函数名(参数):
            函数体
        调用
            pass        

传参求随机数

import random


def generate_random(number): #形参 
    for i in range(number):
        ran = random.randint(1,20)
        print(ran)

generate_random(5) #实参 赋值

关键字：isinstance

判断是什么类型
print (isistance(2,int) #判断2是不是整型 返回值False , True
True 

可变和不可变：

可变:地址不变里面内容改变 list dict set
不可变：只要内容改变，必须改变地址 int str float tuple frozenset

可变函数与不可变函数传参：

   def add(name,*args):
    sum = 0
    if len(args) > 0:
        for i in args:
            sum += i
        print('%s累加和是：sum:%s' % (name,sum))
    else:
        print("没有元素可计算，sum:" , sum)

add('狒狒',5,8,6,9)


运行结果:
    狒狒累加和是：sum:28

可变参数必须要放在后面

可变参数+关键字参数

关键字参数： key=value

    def add(a,b=10):
        result = a+ b
        print(result)
    
    add(5)
    

定义字典

students = {'001':('蔡徐坤',21),'002':('王源',19),'003':('王俊凯',20),'004':('易烊千玺',19)}

def print_boy(persons):
    if isinstance(persons,dict):
        values = persons.values()
        print(values)
        for name,age in values:
            print('{}的年龄是:{}'.format(name,age))

print_boy(students)
*****************************
F:\code\venv\Scripts\python.exe F:/code/Study/day_20201228.py
dict_values([('蔡徐坤', 21), ('王源', 19), ('王俊凯', 20), ('易烊千玺', 19)])
蔡徐坤的年龄是:21
王源的年龄是:19
王俊凯的年龄是:20
易烊千玺的年龄是:19

成对给值调用

def func(**kwargs): # key word argument
    print (a,b,c)
#调用
func(a=1 , b=2 ,c =3) #关键字参数

{'a': 1, 'b': 2, 'c': 3} #字典形式保存

def aa(a,b,*c,**d):
    print(a,b,c,d)

aa(1,2)
**********************
1 2 () {}

带*参数可有可无 *元组 **字典

可变参数习题

def func(a,*args):
print(a,args)

func(2,3,4,5) 
print('******************************')
func(2,[1,2,3,4])      
print('******************************')
func(2,3,[1,2,3,4,5]) 
print('******************************')
func(5,6,(4,5,6),9)

2 (3, 4, 5)
******************************
2 ([1, 2, 3, 4],)
******************************
2 (3, [1, 2, 3, 4, 5])
******************************
5 (6, (4, 5, 6), 9)

变量作用域：

a = 5  # 这是一个全局变量

def hello():
    a = 1  # a在这里是局部变量.
    print("函数内是局部变量 : ", a)
    return a

hello()
print("函数外是全局变量 : ", a)

运行结果
函数内是局部变量 : 1
函数外是全局变量 : 5

global

如果想要在函数内部用模块定义的变量的话，就需要用到global关键字

a = 5

def hello():
    global a
    # 声明告诉执行引擎用的是全局变量a
    a = 1
    print('In test func: a = %d' % a)

hello()
print('Global a = %d' % a)

运行结果：
In test func: a = 1
Global a = 1
可以看到函数里成功修改了全局变量a

局部变量 和全局变量

局部变量：

函数内部声明的变量，局部变量

def func():
    s= 'abc' #局部变量

全局变量：

声明在函数外层是全局的，所有函数都可以访问

name = '月月' #全局变量
def func():
    pass

循环嵌套

name = '月月'
def func():
    s = 'abc'
    s += 'x'
    print(s,name)

def func1():
    global name
    print(name)
    name += "会弹吉他"
    print('func1修改后的name是:',name)

func()

func1()

func()

#输出结果:
abcx 月月

月月
func1修改后的name是: 月月会弹吉他

abcx 月月会弹吉他

全局变量如果是在不可变的函数中进行修改需要添加global关键字
如果全局变量是可怜的在函数中修改时候就不需要添加关键字

内部函数：

特点：可以访问外部的变量
内部函数可以修改外部函数的可变类型的变量
nonlocal关键字可以修改不可变类型的变量

def func():
    n=5 #局部变量
    list = [5,3,6,15,12] 
    def inner_func():
        nonlocal n
        for index, i in enumerate(list):
            list[index] = i+n
            list.sort()
        n +=100
    inner_func()
    print(list,n)
func()

缺省参数

 end = ''  #缺省参数
 sep= "  "

递归函数

什么是递归函数

通过前面的学习知道一个函数可以调用其他函数。
如果一个函数在内部不调用其它的函数，而是自己本身的话，这个函数就是递归函数。

递归函数的作用

举个例子，我们来计算阶乘 n! = 1 * 2 * 3 * … * n

解决办法1:使用循环来完成

def cal(num):
    result,i = 1,1
    while i <= num:
        result *= i
        i+= 1
    return result

print(cal(3))

看阶乘的规律

1! = 1
2! = 2 × 1 = 2 × 1!
3! = 3 × 2 × 1 = 3 × 2!
4! = 4 × 3 × 2 × 1 = 4 × 3!
...
n! = n × (n-1)!

解决办法2:使用递归来实现

def factorial(num):
    result = 1
    if num == 1:
        return 1
    result = num * factorial(num -1)
    return result
print(cal(3))

原理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lABD7H68-1611304292725)(A0E4505279B6419FB2030A6E32066326)]

匿名函数

用lambda关键词能创建小型匿名函数。这种函数得名于省略了用def声明函数的标准步骤。

lambda函数的语法只包含一个语句，如下：

lambda 参数列表: 运算表达式

如下实例：

sum = lambda arg1, arg2: arg1 + arg2
# 调用sum函数
print("Value of total : %d" % sum( 10, 20 ))
print("Value of total : %d" % sum( 20, 20 ))

以上实例输出结果：

Value of total :  30
Value of total :  40

Lambda函数能接收任何数量的参数但只能返回一个表达式的值

匿名函数可以执行任意表达式(甚至print函数)，但是一般认为表达式应该有一个计算结果供返回使用。

python在编写一些执行脚本的时候可以使用lambda，这样可以接受定义函数的过程，比如写一个简单的脚本管理服务器。

应用场合

函数作为参数传递

>>> def fun(a, b, opt):
...     print("a = " % a)
...     print("b = " % b)
...     print("result =" % opt(a, b))
...
>>> add = lambda x,y:x+y
>>> fun(1, 2, add)  # 把 add 作为实参传递
a = 1
b = 2
result = 3