python day10 函数（第二篇）

一、内容回顾

• 1.面试题相关：

  • 1.py2和py3的区别

  • 2.运算符的计算 ：3 or 9 and 8

  • 3.字符串的反转

  • 4.is和==的区别

  • 5.v1 = (1) v2 = 1 v3 = (1,)有什么区别

    v1 、v2都是数字，v3是元组

  • 6.线上操作系统：centos

  • 7.每种数据类型，列举你了解的方法

  • 8.深浅拷贝

  • 9.文件操作，大文件如何读取内容（如50G的日志文件）

    v=open(……)

    for line in v:

    ​ print(line)

    v.close()

  • 10.一行写出：9*9乘法表

  • git流程

• 2.函数

  方法（数据类型的）类似于函数，但不是函数 。

  严格按照顺序传参数：位置方式传参

  实际参数可以是任意类型

  return没有返回值时，默认返回None

  return的作用：1.返回值 2.终止函数的执行

  函数内部执行过程中，遇到return就终止

  return可以返回任意类型

  特殊情况：return 1,2,'alex' 表示返回的是元组，与return(1,2,'alex')相同

二、今日内容

1. 参数

1.1基本参数知识

• 参数可以是任意个数

• 可以是任意类型

  def func(a1,a2,a3,a4):
  	print(a1,a2,a3,a4)
  
  func(2,'name',[1,2,3],False)
  
  

1.2 位置传参(调用函数并传入参数)（执行）

调用/执行函数的时候严格按照位置的顺序传入参数

def func(a1,a2,a3):
	print(a1,a2,a3)

func(66,'alex',3)

1.3 关键字传参（执行）

关键字传参就是将形参放入到实参中去使用

def func(a1,a2):
	print(a1,a2)

func(a1=22,a2=8)

关键字传参与位置传参是可以混合使用的：位置传入的参数要放在前面，关键字传参要放在后面，最后等于总参数个数

def func(a1,a2,a3):
	print(a1,a2,a3)

func(1,2,a3=3)
func(1,a2=2,a3=3)
func(a1=1,a2=2,a3=3)
func(a1=1,2,3)  # 是错误的

def func() : 自定义函数 open() 这两个为python的内置函数

​ pass len()

1.4 默认参数

def func(a1,a2,a3=9,a4=10):   # 默认参数a3=9,a4=10
    print(a1,a2,a3,a4)

func(11,22)       # 不给a3,a4传值，则a3,a4等于默认参数
func(11,22,10)
func(11,22,10,100)
func(11,22,10,a4=100)
func(11,22,a3=10,a4=100)
func(11,a2=22,a3=10,a4=100)
func(a1=11,a2=22,a3=10,a4=100)

1.5 万能参数（用于打散）

• *args

  可以接受任意个数的位置参数，并将参数转换成元组。

  • 调用函数无*

  def func(*args):
  	print(*args)
  
  func(1,2)   ==> (1,2)
  func(1,2,[12,3,4])   ==> (1,2,[12,3,4])
  func((11,22,33))   ==> ((11,22,33))  # 参数是一个元组，打印出来的效果是元组套元组。
  

  调用函数有*

  def func(*args):
  	print(*args)
  
  func(*(11,22,33))   ==>(11,22,33)    # *是用来打散元组的，将元组中的每个元素作为参数。
  func(*[11,22,33])   ==>(11,22,33)    # *可以用来打散列表/元组 /字典/集合，只是循环内部元素
  

  只能用位置传参

  def func(*args):
      print(args)
  
  func(1)
  func(1,2)   # args=(1, 2)
  func((11,22,33,44,55))    # args=((11,22,33,44,55),)
  func(*(11,22,33,44,55))   # args=(11,22,33,44,55)
  

• **kwargs

  可以接受任意个数的关键字参数，并见参数转换成字典

  调用函数无*

  def func(**kwargs):
  	print(***kwargs)
  
  func(k=1)    **kwargs = {'k':1}
  func(k1=1,k2=3)   **kwargs = {'k1':1,'k2':3}
  

  调用函数有*

  def func(**kwargs):
  	print(**kwargs)
  
  func(**{'k1':1,'k2':4,'k3':9})   **kwargs = {'k1':1,'k2':4,'k3':9}
  

  只能用关键字传参

• *args/**kwargs综合使用：无敌 + 无敌 => 真无敌

  def func(*args,**kwargs):
      print(args,kwargs)
  
  func(1,2,3,4,5,k1=2,k5=9,k19=999)     *arg = (1,2,3,4,5) **kwargs = {'k1':2,'k5':9,'k19':999}
  func(*[1,2,3],k1=2,k5=9,k19=999)      *arg = (1,2,3) **kwargs = {'k1':2,'k5':9,'k19':999}
  func(*[1,2,3],**{'k1':1,'k2':3})      *arg = (1,2,3) **kwargs = {'k1':1,'k2':3}
  func(111,222,*[1,2,3],k11='alex',**{'k1':1,'k2':3})
  *arg = (111,222,1,2,3)   **kwargs = {'k11':'alex','k1':1,'k2':3}
  

1.6 参数相关的重点

• 定义函数

  def func(a1,a2):
  	pass
  
  def func(a1,a2=None):  # 对于默认值，不可变类型随便写，如果是可变类型（有坑）。
  	pass
  
  def func(*args,**kwargs):
  	pass
  

• 调用函数

  位置参数在前，关键字参数在后。

2. 作用域

在python文件中：

• py文件：全局作用域

• 函数：局部作用域

  a = 1
  def s1():
      x1 = 666
      print(x1)
      print(a)
      print(b)
  
  b = 2
  print(a)
  s1()
  a = 88888
  def s2():
      print(a,b)
      s1()
  
  s2()
  

• 每个作用域中的数据只有作用域自己可以调用，如果作用域中调用的数据没有，可以调用全局作用域的

  全局作用域只能调用全局的

  在全局作用域中的函数可以互相调用（调用已经存在的），但不可以直接调用作用域中的作用域

总结：

• 1.一个函数就是一个作用域

• 2.作用域中查找数据规则：优先在自己的作用域找数据，自己没有就去“父级”-->“父级”-->直到全局，全局没有就报错。 （作用域的嵌套）

  注意：父级作用域中的值到底是多少？

  x = 10
  def func():
      x = 9
      print(x)
  
  func()
  

  课上练习题

  x = 10
  def func():
      x = 9
      print(x)
      def x1():
          x = 999
          print(x)
  
  func()
  
  x = 10
  def func():
      x = 9
      print(x)
      def x1():
          x = 999
          print(x)
      x1()
  
  func()
  
  x = 10
  def func():
      x = 9
      print(x)
      def x1():
          x = 999
          print(x)
      print(x)
      x1()
  
  func()
  
  x = 10
  def func():
      x = 8
      print(x)
      def x1():
          x = 999
          print(x)
      x1()
      print(x)
  
  func()
  
  x = 10
  def func():
      x = 8
      print(x)
      def x1():
          print(x)
      x1()
      print(x)
  
  func()
  
  x = 10
  def func():
      x = 8
      print(x)
      def x1():
          print(x)
      x = 9
      x1()
      x = 10
      print(x)
  
  func()
  
  x = 10
  def func():
      x = 8
      print(x)
      def x1():
          print(x)
      x1()
      x = 9
      x1()
      x = 10
      print(x)
  
  func()
  

• 3.子作用域中只能只能找到父级中的值，默认无法重新为父级的变量进行赋值。

  • 不能进行赋值，只能对可变类型进行内部修改

    # #####################
    name = 'oldboy'
    def func():
        name = 'alex' # 在自己作用域再创建一个这样的值。
        print(name)
    func()
    print(name)
    
    # #####################
    name = [1,2,43]
    def func():
        name.append(999)
        print(name)
    func()
    print(name)
    

  • 如果非要对全局的变量进行赋值需要加global(强制赋值)

    #示例一
    name = "老男孩“
    def func():
    	global name
    	name = 'alex'
    func()
    print name
    
    # 示例二
    name = ["老男孩",'alex']
    def func():
        global name
        name = '我'
    func()
    print(name)
    
    # 示例三
    name = "老男孩"
    def func():
        name = 'alex'
        def inner():
            global name
            name = 999
        inner()
        print(name)
    func()
    print(name)
    
    

  • 对父级的变量赋值用nonlocal，先找到父级的变量再进行赋值 (强制赋值)

    name = "老男孩"
    def func():
        name = 'alex'
        def inner():
            nonlocal name # 找到上一级的name
            name = 999
        inner()
        print(name)
    func()
    print(name)
    

• 补充：全局变量必须全部要大写

USER_LIST = [11,22,3]

def func():
    name = 'asdf'
    USER_LIST.append(12)
    USER_LIST.append(name)

func()
print(USER_LIST)