20200116--python学习第十天

今日内容

　　1.参数

　　2.作用域

　　3.函数嵌套

内容回顾　　

• 　　线上操作系统：centos
• 　　py2和py3的区别？
• 　　每种数据类型，列举你了解的方法。
• 　　3 or 9 and 8
• 　　字符串的反转
• 　　is 和 == 的区别？
• 　　v1 = (1) / v2 = 1
• 　　深浅拷贝
• 　　文件操作，大文件如何读取内容 [ 50G的日志文件

2.1知识点回顾

　　a.函数基本结果　　

def func(name,age,email):
    # 函数体(保持缩进一致)  
    a=123
    print(a)
    return 1111
    b=456
    print(b)
result = func(1,2,3) #输出的结果为：123
注意：函数默认返回值为：None
b.参数

def func(n1,n2):
     print(n1, n2)
func(1, 2)  #输出结果为：1，2
func(1, [11, 22, 3]) #输出的结果为：1，[11, 22, 3]
func({‘k1‘: ‘k‘}, [11, 22, 3])#输出的结果为：{‘k1‘: ‘k‘}, [11, 22, 3]
注意：严格按照顺序参数：位置方式传参
实际参数可以是任意类型；

c.返回值
函数返回值没有默认值，默认返回：None
函数内部执行过程中遇到return,就中止；

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

def func2():
    for i in range(10):
        print(i)
        return "完成"
    print(666)
func2()  #输出结果为：0

d.return可以返回任意类型

def func():
    return (1,2,3)
v = func()
print(v)  #返回的结果为:(1,2,3)

def func():
    return 5,8,"alex"
v = func()
print(v)  #输出的结果为(5,8,"alex")
#注意：return 可以返回任意类型，特殊情况：可以返回元组

2.2参数

　　a.基本参数知识 任意个数/任意类型

　　b.位置传参（调用参数并传入参数）　

　　c.关键字传参（注意位置传参与关键字传参可以混合使用，位置参数>关键字参数，其中位置参数个数+关键字参数个数 = 总参数个数）　

　　d.自定义参数（参数可以赋有默认值）

　　示例如下：　

def func(a1,a2,a3=9,a4=10):
    print(a1,a2,a3,a4)

func(11,22)
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)

  e.万能参数（打散）
　　*args:可以接收任意个的位置参数，并将参数转换为元组。（只能使用位置参数）
　　调用参数无*
　　调用参数有*
　　示例如下：　

def func(*args):
    print(args)

func(1,2,3,4) #输出结果为：(1,2,3,4)
func((1,2,3,4)) #输出的结果为：((1,2,3,4))
func(*(1,2,3,4)) #输出结果为：(1,2,3,4)
func(*[1,2,3,4]) #输出结果为：(1,2,3,4)
 
　　**kwargs：可以接收任意个关键字参数，并将参数转化为字典。（只能接收关键字参数）
　　调用参数无*
　　调用参数有**　

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

func(k1= 1,k2="alex") #输出的结果为：{‘k1‘: 1, ‘k2‘: ‘alex‘}
func(**{‘k1‘: 1, ‘k2‘: ‘alex‘}) #输出的结果为：{‘k1‘: 1, ‘k2‘: ‘alex‘}

　　f.综合应用 无敌（位置参数）+无敌（关键字参数）

　　示例：

def func(*args,**kwargs):
    print(args,kwargs)
func(1,2,3,4,5,k1=2,k5=9,k19=999) #输出结果为：(1,2,3,4,5){‘k1‘:2,‘k2‘:9,‘k19‘：999}
func(*[1,2,3],k1=2,k5=9,k19=999)  #输出结果为：(1,2,3){‘k1‘:2,‘k2‘:9,‘k19‘：999}
func(*[1,2,3],**{‘k1‘:1,‘k2‘:3})  #输出结果为：(1,2,3){‘k1‘:2,‘k2‘:3}
func(111,222,*[1,2,3],k11=‘alex‘,**{‘k1‘:1,‘k2‘:3}) #输出结果为：(111,222,1,2,3){‘k11‘:‘alex‘,‘k1‘:1,‘k2‘：3}

参数相关重点

　　1.定义参数　

def func1(a1,a2):
    pass

def func2(a1,a2=None):
    pass

def func3(*args,**kwargs):
    pass
 　2.调用参数 位置参数>关键字参数

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 #666  #1 #2 #88888  2 # 666 # 88888 # 2

作用域中查找数据规则：优先在自己作用域找数据，自己没有就去父级-->父级-->直到全局，全部没有就报错。在此注意的是父级作用域中的值到底是什么？

def func():
    x = 9
    print(x)
func()  #此处打印9
print(x)  #此处报错，没有全局没有x变量的值

4.练习题 

x=10
def func():
    x=9
    print(x)
    def x1():
        x=999
        print(x)
func()  #打印一个9

x=10
def func():
    x=9
    print(x)
    def x1():
        x = 999
        print(x)
    x1()
func()  #打印一个9 999

x=10
def func():
    x=9
    print(x)
    def x1():
        x = 999
        print(x)
    print(x)
    x1()
func()  #打印一个9 9 999

x = 10
def func():
    x = 8
    print(x)
    def x1():
        x = 999
        print(x)
    x1()
    print(x)
func()  #打印一个8 999  8

x = 10
def func():
    x = 8
    print(x)
    def x1():
        print(x)
    x1()
    print(x)
func()  #打印一个8 8  8

x = 10
def func():
    x = 8
    print(x)
    def x1():
        print(x)
    x = 9
    x1()
    x = 10
    print(x)
func()  #打印一个8 9  10

x = 10
def func():
    x = 8
    print(x)
    def x1():
        print(x)
    x1()
    x = 9
    x1()
    x = 10
    print(x)
func()  #打印一个8 8 9  10

name=‘oldboy‘
def func():
    name = ‘alex‘  # 在自己作用域再创建一个这样的值。  
    print(name)
func()
print(name)
#输出的结果为：alex oldboy

name=[1,2,43]
def func():
    name.append(999)
    print(name)
func()
print(name)
#输出结果为:[1,2,3,43,999]
#[1,2,3,43,999] 

注意：子作用域中只能找到父级中的值，默认无法重新为父级的变量进行赋值；（如果非要强制赋值，可以使用golbal/nonlocal）

关于golbal与nonlocal的示例：

示例一
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)
#输出结果为：alex 9999

#示例三
name="老男孩"
def func():
    name=‘alex‘
    def inner():
        global name
        name=999
    inner()
    print(name)
func()
print(name)
#输出结果为：alex 9999

nonlocal
name="老男孩"
def func():
    name=‘alex‘
    def inner():
        nonlocal name #找到上一级的name
        name=999
    inner()
    print(name)
func()
print(name)
#输出结果为： 999 老男孩

补充

　　以后全局变量必须是大写　　

USER_LIST=[11,22,3]
def func():
    name = ‘asdf‘
    USER_LIST.append(12)
    USER_LIST.append(name)
func()
print(USER_LIST)
#输出结果为：[11, 22, 3, 12, ‘asdf‘]

总结

　　参数：

　　　　调用（执行）参数时，传参：位置参数> 关键字参数

　　　　定义参数：

　　　　def func(a)

　　　　def func(a,b = None) #对于默认值，如果是可变类型，存在坑

　　　　def func(*args,**kwargs)

　　作用域：

　　　　函数为作用域

　　　　作用域：自己 >父级>父级 >全局 【读/修改可变类型】

　　　   重新赋值：global/nonlocal

20200116--python学习第十天

原文：https://www.cnblogs.com/limin1027/p/12202090.html