python个人总结5.0

创建函数基本格式

def 函数名():
    printf()
    . . . .

调用函数

函数名(可传入参数)

def myfirstfunction (name):
        print(name + '最帅')     #以上是定义函数

        
myfirstfunction ('龙哥')         #这里是调用函数并传入参数
龙哥最帅

传入多个参数时可用，隔开

def add (num1,num2):
        result = num1+num2
        print(result)               #定义一个两数相加函数

        
add (1,2)                           #调用函数并传入参数
3

return()返回函数返回值

def add (num1,num2 ):
        return( num1 + num2 )


add (1,2)
3

有返回值的叫函数

无返回值的叫过程

python只有函数没有过程，例：

def Hello ():
    print ('hello word!')

    
temp = Hello()                  #将函数中的东西传入到temp中
hello word!
temp                            #无反应Hello()中没有任何东西
print (temp)                    #打印temp中是否有东西
None                            #我的天呐，真他妈没有
type(temp)                      #查看temp的类型
<class 'nonetype'>              #OMG，还真没有类型

若有返回值则返回返回值，若没有则返回None，None并不是什么都没有，而是也是一种返回值，所以说python只有函数没有过程

python也可返回多个返回值，例：

def back():
    return 1,'龙哥',2

back()
(1, '龙哥', 2)                  #默认返回元组
#元组在原则上不一定非要用（）     用‘，’隔开也可以看成元组

函数文档

调用默认属性双下划线+doc+双下划线

def myfirstfunction (name):
    '函数定义过程中的name是形参'
    #因为它只是一个形式，表示占据一个参数位置
    print('传递进来的' + name + '叫做实参，因为他是具体的参数值')

    
myfirstfunction ('霸霸')
传递进来的霸霸叫做实参，因为他是具体的参数值
myfirstfunction.__doc__
'函数定义过程中的name是形参'

关键字

def SaySome( name , words):
    print( name + '->' + words)

    
SaySome('龙哥','喜欢大波妹？！')
龙哥->喜欢大波妹？！
SaySome('喜欢大波妹？！','龙哥')
喜欢大波妹？！->龙哥

加入关键字

SaySome( name = '龙哥' , words = '喜欢大波妹？！')
龙哥->喜欢大波妹？！
SaySome(words = '喜欢大波妹？！', name = '龙哥' )
龙哥->喜欢大波妹？！

默认参数

def SaySome( name = '龙哥', words = '喜欢大波妹'):  #当不给定参数时执行默认值
    print( name + '->' + words)

    
SaySome('苍井空')
苍井空->喜欢大波妹
SaySome('苍井空','我脱光衣服躺在镜头前，是为了生存，而你衣冠楚楚的站在镜头前，却只为了私欲和欺骗！')
苍井空->我脱光衣服躺在镜头前，是为了生存，而你衣冠楚楚的站在镜头前，却只为了私欲和欺骗！

收集参数（*）（不知道要传入多少个参数）

def Text(*params):
    print('参数的长度是：',len(params));
    print('第二个参数是：',params[1]);

    
Text(1,'龙哥',3.14,5,6,7,8)
参数的长度是： 7
第二个参数是： 龙哥

函数里面的为局部变量，外面的为全局变量通过一个实例来区分局部变量和全局变量，

def discounts(price,rate):
    final_price = price*rate
    return final_price
old_price = float(input('请输入原价：'))
rate = float(input('请输入折扣率：'))
new_price = discounts(old_price,rate)
print('打折后价格是：',new_price)
    
print('这里试图打印局部变量final_price的值：',final_price)     #若加上这条则会报错，因为final_price是局部变量

可以在函数内访问全局变量但不可以在函数内修改全局变量

也不可在函数外访问局部变量，例：

def discounts(price,rate):
    final_price = price*rate
    old_price = 50                                  #这里试图修改全局变量
    print('修改后old_price的值是1：',old_price)       #第一次打印修改后的全局变量
    return final_price
old_price = float(input('请输入原价：'))
rate = float(input('请输入折扣率：'))
new_price = discounts(old_price,rate)
print('修改后old_price的值是2：',old_price)           #第二次打印修改后的全局变量
print('打折后价格是：',new_price)


请输入原价：10
请输入折扣率：0.1
修改后old_price的值是1： 50
修改后old_price的值是2： 10.0
打折后价格是： 1.0

当在函数中修改全局变量时，会在函数中创建一个与全局变量相同名字的局部变量

在函数内部试图修改全局变量时python会使用屏蔽(shadowing)保护全局变量

count = 5
def Myfun():
    count = 10
    print(count)
Myfun()                  #这里打印的是局部变量
print(count)             #这里打印的是全局变量
 

10
5

global关键字

在函数中修改全局变量，例：

count = 5
def Myfun():
    global count
    count = 10
    print(count)
Myfun()
print(count)


10
10                   #全局变量修改成功

闭包：如果在一个内部函数里对外部作用域（但不是在全局作用域）的变量进行引用那么内部函数被认为是闭包

>>> def FunX(x):
       def FunY(y):
        return x*y
    return FunY

>>> i = FunX(8)
>>> i
<function FunX.<locals>.FunY at 0x000002356EAD7510>
>>> type(i)
<class 'function'>    #这里i的类型为程序
>>> FunX(8)(5)
40

在内部函数中只能对外部的局部变量进行访问不能进行修改

>>> def fun1():
    x=5
    def fun2():
        x*=x
        return x
    return fun2

>>> n= fun1(2)
Traceback (most recent call last):              #当执行内部函数时外部函数被屏蔽了起来，因此找不到x的值所以报错
  File "<pyshell#8>", line 1, in <module>
    n= fun1(2)
TypeError: fun1() takes 0 positional arguments but 1 was given

解决方法

1、将局部变量改为列表

>>> def fun1():
    x=[5]
    def fun2():
        x[0]*=x[0]
        return x
    return fun2
>>> n= fun1()
>>> n()
[25]
>>> fun1()()
[25]

2、nonlocal关键字

>>> def fun3():
    x=5
    def fun4():
        nonlocal x   #这里强制声明x不是局部变量
        x*=x
        return x
    return fun4()

>>> fun3()
25

相关推荐