python函数

1.定义：

所谓函数，就是把具有独立功能的代码块组织为一个小模块，在需要的时候调用
   函数的调用包括两个步骤:
      1.定义函数一一封装独立的功能
	  ⒉.调用函数一一享受封装的成果
函数的作用，在开发程序时，使用函数可以提高编写的效率以及代码的重用

2.定义函数

  def函数名()∶
      函数封装的代码
      def say_hello():       #函数定义
		print("hello1")
		print("hello2")
      print(name)
      say_hello()      #函数的调用

3.函数的参数

 def sum_2nums(a,b):  #形参
   num1=a
   num2=b
   result=num1+num2

   print(f'函数输出的结果是{result}')

 sum_2nums(1,2)     #实参  调用函数时 传入形参的值
 
 1.在函数内部，把参数当做变量使用，进行需要的数据处理
 ⒉.函数调用时，按照函数定义的参数顺序、把希望在函数内部处理的数据通过参数传递

4.嵌套调用

 定义一个函数的时候，一个函数里面又调用了另外一个函致，这就是函数嵌套调用
     def test1():
         print("woshi")
         print("*"*10)
     
     def test2():
         print("/"*10)
         print("woshini")
     
         test1()   #再调用test1
         print("."*10)
	 test2()   #先调用test2
	输出：//
          woshini
          woshi
          **********
          ..........

	#定义一个print_line 函数能打印50个*组成的一条分割线
	# #打印任意个*
	def print_line(char,count,lines):
	  for i in range(lines) :
	        print(char * count)
	print_line(" I",100,3)

5.局部变量全局变量

局部变量 是在 函数内部 定义的变量，只能在函数内部使用

        函数执行结束后，函数内部的局部变量，会被系统回收
		def demo1():
		    num = 100    
		    print("demo1 ==>%d" % num)
		def demo2():
			num = 20
			print("demo2 ==>%d" % num)
		demo1()
		demo2()
		输出：demo1 ==>100
              demo2 ==>20

全局变量 是在 函数定义外部 的变量，所有函数都能使用这个变量

	    number = 10
		def demo1():
			print("demo1 ==>%d" % number)
		def demo2():
			print("demo2 ==>%d" % number)
		demo1()
		demo2()
		输出:demo1 ==>10
             demo2 ==>10
			 函数不能直接修改 全局变量的引用
			 全局变量 是在 函数定义外部 的变量，所有函数都能使用这个变量
			 在函数内部，可以 通过全局变量的引用获取对应的数据
             但是，不允许直接修改全局变量的引用—可以使用赋值语句修改全局变量的值

在函数内部修改全局变量的值

        如果在函数中需要修改全局变量，需要使用 global 进行声明
		number = 10
		def demo1():   
		        # 希望修改全局变量的值，使用 global 声明一下变量即可
				global number
			    number = 99    
				print("demo1 ==>%d" % number)
		def demo2():
		        print("demo2 ==>%d" % number)
		demo1()
		demo2()

6.返回值

    返回值 是函数 完成工作 后， 最后 给调用者的 一个结果
	在函数中使用return关键字可以返回结果
    调用函数一方， 可以 使用变量 来 接收 函数的返回结果
	def measure():
	    print("开始测量.....")
	    temp1 = 37.3
	    
	    print("测量结束！！")
	    return temp1 # ==》返回温度的值
		
	result1 = measure()  
	print(result1)

7.可变不可变参数

    如果传递的参数是 可变类型，在函数内部，使用 方法 修改了数据的内容，同样会影响到 可变类型 外部的数据
       def mutable(num_list):
         # num_list = [1, 2, 3]
         num_list.extend([1, 2, 3])
       gl_list = [6, 7, 8]
       mutable(gl_list)
       print(gl_list)
	   输出：[6, 7, 8, 1, 2, 3]

8.递归函数

     函数调用自身的 编程技巧 称为  递归
	 求：定义一个函数 sum_numbers
         能够接收一个 num 的整形参数
         计算 1+2+…+n的结果
	 def sum_numbers(num):
		# 1.出口，计算1到num的累加，可以把计算倒过来，从num累加到1，那么出口就是1
		if num == 1:
				return 1    
		# 2.数字的累加： num + (num-1) +...+ 1
		# 假设sum_numbers 能够完成 num-1 的累加
		temp = sum_numbers(num-1)
		# 函数内部的核心算法就是 两个数字的相加
		return num + temp
	 print(sum_numbers(3))
	 输出：6

9.内部函数

     在函数内部 定义 另一个函数，也就是函数的嵌套
     在外部函数的作用域内，外部函数可以随意调用内部函数
     由于内部函数的整个定义过程都在外部函数中，所以出了外部函数就无法再被调用了
        def outside():
		   print('外部函数被调用')
		   def inside():
			    print('内部函数被调用')
		   inside()
         输出：>>>outside() 
              外部函数被调用 
              内部函数被调用
              >>>inside() NameError: name 'inside' is not defined

10.闭包

    如果在一个内部函数里引用了外部函数的变量，此时这个内部函数就被称为闭包
     #格式：
          def 外部函数():
               ...   
			   def 内部函数()
					 ...   
			   return 内部函数名  # 没有括号
			  
			  def func(a, b):
				 c = 10
				 def inner_func():
						 s = a + b + c
						 print("相加之后的结果是：", s)
				 return inner_func
			   # 调用 func
			   ifunc = func(6, 9)  # ifunc 就是 inner_func
			   # 调用返回的内部函数
			   ifunc()