PYTHON函数笔记

最新推荐文章于 2023-10-24 15:24:37 发布

转载最新推荐文章于 2023-10-24 15:24:37 发布 · 76 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/bruce-blogs/p/11142921.html

PYTHON函数笔记

新建

模板

小书匠

欢迎使用 小书匠(xiaoshujiang)编辑器，您可以通过设置里的修改模板来改变新建文章的内容。

一、函数

定义：函数是指将一组语句的集合通过一个名字（函数名）封装起来，要想执行这个函数，只需调用其函数名即可

特性：
减少重复代码
使程序变得可扩展
使程序变得易维护

1.函数参数

def calc(x,y):   #xy 为形参
      res = x**y
      return res 

c = calc(a,b)   #ab 为实参
print(c)

举栗：

def stu_register(name,age,country,course):
      print('----学生信息----')
      print('姓名',name)
      print('age',age)
      print('国籍',country)
      print('课程',course)

stu_register('小黄',22,'CN','student')
stu_register('小吴',23,'CN','student')
stu_register('小叶',23,'CN','student')

2.关键参数

def stu_register(name,age,country,course):
      print('----学生信息----')
      print('姓名',name)
      print('age',age)
      print('国籍',country)
      print('课程',course)

stu_register('小叶',age=23,country='CN',course='student') #正确调用方法

3.非固定参数
若你的函数再定义时不确定用户想传入多少个参数，就可以使用非固定参数

def stu_register(name,age,*args): #args会把传入参数变成一个元组形式
      print(name,age,args)
stu_register('huang',22)
#输出 huang 22 () args为() 没有值所以为空

stu_register('huang',22,'CN','python')
#输出 huang 22 ('CN','python')

非固定关键字参数

def stu_register(name,age,*args,**kwargs): #kwargs会把多传入的参数变成一个dict形式
print(name,age,args,kwargs)

 stu_register('huang',22)
 #输出 huang 22 () {}
 
  stu_register('huang',22,'CN','python',sex='male',province='fujian')
  #输出 huang 22 ('CN','python') {'province':'fujian','sex':'male’}

4.函数返回值

def stu_register(name,age,country='CN',course='PY'):
          print('----学生信息----')
          print('姓名',name)
          print('age',age)
          print('国籍',country)
          print('课程',course)
          if age > 22:
                return Flase
          else:
                return True
registriation_status = stu_register('小黄',22,course='PY全栈',country=‘JP'
if registriation_status:
    print('注册成功')
else:
    print('太老了')

注意：
函数再执行过程中遇到return就停止执行并返回结果
如果未再函数中指定return，那这个函数的返回值为none

5.嵌套函数

def func1():
      print('alex')
      def func2():
            print('eric')
      func2()
func1()

输出alex eric

6.匿名函数

def calc(x,y):
      if x < y :
            return x*y
      else:
            return x/y
    
func = lambda x,y : x*y if x<y else x/y #声明一个匿名函数
print(calc(16,8))  
print(func(16,8))

输出结果都为2，匿名函数最复杂只能支持三元运算

7.高阶函数
函数的参数能接受变量，那么一个函数就可以接收另一个函数作为参数，称为高阶函数
满足以下条件
1）接受一个或多个函数作为输入
2）return返回另一个函数

def func(x,y) :
      return x+y
def calc(x) :
      return x
f = calc(func)
print(f(5,9))  #输出14，把func传进了函数

8.递归
再函数内部，可以调用其他函数。如果函数再内部调用自身本身，就是递归函数

def recursion(n) :
      print(n)
      recursion(n+1)
recursion(1)  #结果输出1-999

栗子：传入一个10，让它每次除2，不要小数,到0就停下来

def calc(n) :
      v = int(n/2)
      print(v)
      if v == 0 :
           return ‘结束'
      calc(v)
 calc(10)   #输出5210

递归的特性总结：
1）必须有一个明确的结束条件
2）每进入更深一层递归时，问题规模相比上次减少
3）递归效率不高，递归层次过多会导致栈溢出

尾递归：

def cal(n):
      print(n)
      return cal(n+1)  #尾递归
cal(1)   #输出1-999 报错

四、函数进阶

1.名称空间
又名name space,救是存放名字的地方。若变量x=1，1存放于内存中，是存放名字x与1绑定。

名称空间有三种：
1）locals：函数内的名称空间，包括局部变量和形参

globals：全局变量，函数定义所在模块
builtins：内置模块的名字空间

不同变量的作用域不同就是由这个变量所在的命名空间决定的，查看作用域用locals globals

2.闭包

def func() :
      n = 10
      def func2():
            print('func2:' ,n )
      return func2
 
 f = func()
 print(f)
 f()

再函数里套用一层子函数，子函数被返回内存地址，再外层引用子函数，子函数又外层函数的变量

3.装饰器
栗子1：

def login(func):
print(func) #func==1    

def aaa(x,y):   #aaa=2
    print(x-y)
    print(x*y)
    func(x,y)
return aaa    #2

@login  #add=login(add)  #定义一个变量add接收login（add）执行后的结果
def add(x,y):             #add=1
    print(x+y)

add(3,1)
print(add)

栗子2：

user_status = False
def login(func):
    def inner (*args,**kwargs):
        _username = 'alex'
        _password = '123'
        global user_status
        if user_status == False:
            username = input('user:')
            password = input('password')
            if username == _username and password == _password:
                print('welcome login...')
                user_status = True
            else:
                print('wrong username or wrong password')
        else:
            print('用户已登陆，验证通过')
        if user_status:
            func(*args,**kwargs)
    return inner

def home():
    print('首页')
def america():
    print('欧美')
@login
def japan():
    print('日韩')
@login
def C(style):
    print('国产',style)

C('abc')

4.列表生成式

a = [i+1 for i in range(10)]
print(a)

这样就是一个列表生成式
可以加入三元运算得到自己想要的结果

a = [i if i<5 else i*i for i in range(10)]
print(a)  #输出[0, 1, 2, 3, 4, 25, 36, 49, 64, 81]

5.生成器generator
要创建一个generator,只需要把列表生成式[]改成()
特性：
1.只能一直往前生成
2.有序生成
3.备料多少生成多少，超过报错

6.斐波那契数列
除第一个和第二个数外，任意一个数都是它的前两个数相加，用函数执行如下

def fib(max):
      n,a,b = 0,0,1
      while n < max:
          print(b)
          a,b = b, a+b
          n = n+1
      return 'done'
fib(10)

变成生成器：

def fib(max):
      n,a,b = 0,0,1
      while n < max:
          yield b   #把函数的执行过程冻结在这一步，并且把b的值返回给外面的next
          a,b = b, a+b
          n = n+1
      return 'done'
f = fib(10)
print(next(f))  #生成器开始走

7.生成器send

def range(n):
      count = 0
      while count < n:
          print('count',count)
          count += 1
          sign = yield count
          print('--sign',sign)
      return 22
f = range(3)
print(next(f))
f.send('stop')  #输出count0,1,---sign stop

1.next可以唤醒并继续执行
2.send可以唤醒并继续执行且发送一个信息到生成器内部

8.迭代器
1.凡是可作用于for循环的对象都是Iterable可迭代（循环）类型
2.凡是可作用于next()函数的对象都是Iterable类型，它们表示一个惰性计算的序列
3.集合数据类型（list,dict,str...)是可迭代但不是迭代器，不过可以通过iter()函数变成迭代器、

转载于:https://www.cnblogs.com/bruce-blogs/p/11142921.html