No.10函数(二)

时间：2020-03-19 09:15:40 收藏：0 阅读：54

No.10

今日概要

参数
作用域
函数嵌套

内容回顾和补充

1.面试题相关

py2和py3的区别
线上操作系统：centos
每种数据类型，列举你知道的方法。
3 or 9 and 8
字符串的反转
is 和 == 的区别
v1 = (1) / v2 = 1
深浅拷贝
文件操作，大文件如何读取内容【50G的日志文件】
```
v = open(...)
for line in v:
    print(line)
v.close()
```

2.回顾

2.1知识点

函数基本结构

def func(name,age,email):
    #函数体(保持缩进一致)
    a = 123
    print(a)
    return 8  #一旦遇到return后面代码就不执行
    b = 456
    print(b)

m = func(1,2,3)   
#定义函数时设置了参数，调用时一定要写参数，设置了几个就写几个。

参数

def func(n1,n2):
    print(n1,n2)

func(1,2)
func([1,2],{a:1,b:2})
#严格按照顺序传参数：位置方式传参。
#实际参数可以是任意类型。

返回值

函数没有返回值时，默认返回None。

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

def fun():
    return '完成'  #函数每次执行到此就返回，下面代码永远不执行。
    for i in range(10):
        print(i)
fun()

def fun():
    for i in range(10):
        print(i)
        return '完成'  
fun()              #调用时只会打印0

return可以返回任意类型。

def fun():
    return (1,2,3)
v = fun()
print(v)

#特殊：返回元组
def fun():
    return 5,8,'alex'
v = fun()
print(v)

2.2练习题

技术分享图片

def func(x):
    v = x[1::2]
    return list(v)

v1 = func([1,2,3])
v2 = func((1,2,3))
#其它类型可以通过list(type)强制转换成列表
dic = {'k1':1,'k2':2}
lst = list(dic)
print(lst)
['k1','k2']
#字典转列表，默认是循环key

def sum(data):
    v = True if len(data) > 5 else False
    return v
msg = input('>>>')
print(sum(msg))

def sum(a,b):
    return a if a - b > 0 else b
msg = sum(11,2)
print(msg)

def func(name,gender,age,edu):
    # template = '%s*%s*%s*%s'%(name,gender,age,edu,) 
    # return template
    lst = [name,gender,age,edu]
    return '*'.join(lst)
       
a = input('>>>')
b = input('>>>')
c = input('>>>')
d = input('>>>')
result = func(a,b,c,d)
print(result)

def fun(max):
    lst = []
    while True:
        if len(lst) == 0:
            lst.append(1)
        if len(lst) == 1:
            lst.append(1)
        else:
            n = lst[-1] + lst[-2]
            if n > max:
                break
            lst.append(n)
    return lst

fun(300)

#写函数验证用户名是否在文件中，如果存在返回True，不存在返回False。
#函数有一个参数，用于接收用户输入的用户名。
'''文件格式
1|alex|123123
2|eric|rewrew
3|wupeiqi|ppp
'''
方式一
def fun(name):
    with open('文件操作练习.txt', mode = 'r',encoding = 'utf-8') as obj:
        content = obj.read()
        flag = False
        row_list = content.split('\n')
        for row in row_list
            v = row.split('|')
            if v[1] == name:
                flag = True
    return flag
方式二
def fun(name):
    with open('文件操作练习.txt', mode = 'r',encoding = 'utf-8') as obj:
        content = obj.read()
        row_list = content.split('\n')
        for row in row_list
            v = row.split('|')
            if v[1] == name:
                return True
v = func('alex')
if v:
    print('存在')
else:
    print('不存在')

内容详细

1.参数

基本的参数知识

任意个数
任意类型

def func(a,b,c,d):
    print(a,b,c,d)

func(1,'alex',True)

位置传参（调用函数并传入参数）

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

func(1,2)
#定义了几个参数，调用时就传入几个参数，每个实际参数和形式参数一一对应。

关键字传参

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

func(a1=6,a2=66)
func(a2=66,a1=6)
#调用函数时写上定义函数所设置的参数名字，就可以任意换位了。

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

func(1,6,a3=9)
func(1,a2=6,a3=9)
#位置传参和关键词传参可以混合使用。
func(a1=1,6,9)
#混合使用时，需要保证位置参数在前，关键字参数在后，不然会报错。
func(1,a1=6,a3=9)
#会先处理位置参数再处理关键字参数，这样会因参数多值而报错。

默认参数（定义）

def func(a1,a2=9)
 print(a1,a2)

func(1)
#func函数可以接受两个参数，再调用函数进行传值时可以只传一个参数，另个参数使用默认值。
def func(a1,a2,a3=6,a4=9):
    print(a1,a2,a3,a4)

func(1,2)
func(1,2,3)
func(1,2,3,4)
func(1,2,3,a4=4)
func(1,2,a=3,4)  #报错，关键字传参一定要放在位置传参后面。

万能参数（打散）

*args
- 可以接受任意个位置参数，并将参数转换成元组。
  - 调用函数有*（打散容器类数据）
  - 调用函数无*
- 只能用位置传参

情况1
def func(*a):  # 一般写成*args，潜规则
    print(a)

func(1)        # 结果是元组(1,)
func(1,2,[3,4],567,'alex')
func((1,2,3))  # ((1, 2, 3),)
func(*(1,2,3)) # (1, 2, 3)

情况2
def func(a1,*args):
    print(a1,args)

func(1,2,3)    
func(a1=1,2,3) # 报错，关键字永远在位置参数后。

情况3：基本遇不到
def func(a1=3,*args,a2=6):
    print(a1,args,a2)

func(1,2,3)    # a1的默认值永远会被覆盖，a2不用关键字传参永远默认值。
func(a1=1,2,3,a2=4) # 报错，关键字永远在位置参数后。
func(1,2,3,a2=4)

**kwargs
- 可以接受任意个关键字参数，并将参数转换成字典。
  - 调用函数有**（只能是字典）
  - 调用函数无**
- 只能用关键字传参

def func(**kwargs):
    print(kwargs)

func(a=1,b='alex')  # 只能用关键字传参
#结果{'a': 1, 'b': 'alex'}

def func(**v):
    print(v)

func(**{'a':11,'b':'eric'}) 
#结果{'a': 11, 'b': 'eric'}

综合应用：无敌 + 无敌

def func(*args,**kwargs)
 print(args,kwargs)

func(1,2,3)
func(1,2,3,k1=4,k2=5,k3=6)
func(*[1,2,3],**{'k1':4,'k2':5})
func(11,22,*[1,2,3],k0='a',**{'k1':4,'k2':5})
#(1, 2, 3) {}
#(1, 2, 3) {'k1': 4, 'k2': 5, 'k3': 6}
#(1, 2, 3) {'k1': 4, 'k2': 5}
#(11, 22, 1, 2, 3) {'k0': 'a', 'k1': 4, 'k2': 5}

参数相关的重点：

定义函数

def func1(a1,a2):
    pass

def func2(a1,a2=None):
    pass

def func3(*args,**kwargs):
    pass

调用函数
- 位置参数 > 关键字参数

2.作用域

Python中：

py文件：全局作用域

函数：局部作用域

a = 1
def s1():
    x1 = 666
    print(x1)
    print(a)
    print(b)
    #def s3():
      #pass
#s1()如果在此位置会报错，因为代码执行此时还未定义b。
b = 2
print(a)
s1()
a = 888
def s2(): 
    print(a,b)
    s1()  #s2()内部可以调用已经出现在全局的s1()，但是无法调用嵌套在s1()中的函数s3()。
s2()

总结：

一个函数是一个作用域（其它语言并非一样）

def func():
    x = 9
    print(x)
func()
print(x)  #会报错

作用域查找数据规则：优先在自己的作用域找数据，自己没有就去上一级作用域寻找数据一直到全局，全局若没有就会报错。
```
x = 10
def fun():
    x = 8 #如果此行没有，结果会是10。    
    print(x)

func()    #结果是8。
```

注意父级作用域中的值是否发生变化。

#示例
x = 10
def func():
    x = 9
    print(x)
    def func2():
        x = 8
        print(x)
func()

#示例
x = 10
def func():
    x = 9
    print(x)
    def func2():
        x = 8
        print(x)
    func2()
func()

#示例
x = 10
def func():
    x = 9
    print(x)
    def func2():
        x = 8
        print(x)
    print(x)
    func2()
func()

#示例
x = 10
def func():
    x = 9
    print(x)
    def func2():
        x = 8
        print(x)
    func2()
    print(x)
func()

#示例
x = 10
def func():
    x = 9
    print(x)
    def func2():
        print(x)
    func2()
    print(x)
func()

#示例
x = 10
def func():
    x = 9
    print(x)
    def func2():
        print(x)
    x = 10
    func2()
    x = 11
    print(x)
func()

#示例
x = 10
def func():
    x = 9
    print(x)
    def func2():
        print(x)

    func2()
    x = 10
    func2()
    x = 11
    print(x)
func()

子作用域中只能找到父级作用域中的变量的对应值，默认无法重新为父级作用域中的变量重新赋值。

name = 'oldboy'
def func():
    name = 'alex'
    print(name)
func()       #alex
print(name)  #oldboy

lst = [1,2,3]
def func():
    lst.append(888) 
    print(lst)
func()       #[1,2,3,888]并没有重新赋值，而是对可变类型数据修改。

golbal关键字，强制改变全局作用域中的变量值。

#如果非要对全局变量重新赋值，采用golbal关键字
data = '加油'
def func():
    global data
    data = '中国'
func()
print(data)

data = '加油'
def func():
    data = '中国'
    def func2():
        global data
        data = ['四川']
    func2()
    print(data)
func()
print(data)

nonlocal关键字，强制改变父级作用域中的变量值。

data = '加油'
def func():
    data = '中国'
    def func2():
        nonlocal data
        data = ['四川']
    func2()
    print(data)
func()
print(data)

总结

参数
- 调用函数
  - 传参：位置参数 > 关键字参数
- 定义函数
  - def func(a)
  - def func(a,b=None)
    - 对于默认值，不可变类型随变设置。
    - 对于可变类型，→ 坑
  - def func(*args,**kwargs)
- 作用域
  - 函数为作用域
  - 寻找数据顺序：自己 > 父级 > 全局【可变类型可改】
  - 重新赋值
    - global
    - nonlocal

原文：https://www.cnblogs.com/elliottwave/p/12521805.html