当前位置： 移动技术网 > IT编程>脚本编程>Python > python day10 函数（第二篇）

python day10 函数（第二篇）

2019年04月26日  | 移动技术网IT编程  | 我要评论

龙喉氏族军需官,本月上映电影,幻神全文阅读

2019.4.10 s21 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)

您可能感兴趣的文章:

如对本文有疑问，请在下面进行留言讨论，广大热心网友会与你互动！！ 点击进行留言回复

相关文章:

验证码：
最近更新的文章
大家感兴趣的文章
移动技术网