python学习第五天 —– 函数

1. 内置函数

　　例如： print， round

2.自定义函数：

　　通过def来定义
def funcname(parameter_list):
    pass
　　⑴.参数parameter_list可以没有
　　⑵.在函数体重可以通过return返回value，如果没有返回value，则认为返回None
 
　　对于无线递归函数，可以设置最大递归数量：
import sys
sys.setrecursionlimit(100000)
　　sys.setrecursionlimit，系统默认为992
 
　　函数是可以返回多个结果的：
def damage(skill1, skill2):
    damage1 = skill1 * 3
    damage2 = skill2 * 2 + 10
    return damage1, damage2
    
damages = damage(3, 6)    
print(type(damages))
//<class 'tuple'>
　　
　　我们可以通过【】和序号获取元组中的某个值。
　　我们可以通过两个变量去接收这两个返回结果：
def damage(skill1, skill2):
    damage1 = skill1 * 3
    damage2 = skill2 * 2 + 10
    return damage1, damage2
    
skill1_damage, skill2_damage = damage(3, 6)    
print(skill1_damage, skill2_damage) //9 22

3.序列解包与链式赋值：

变量的逗号赋值，可以直接将赋值号后的元素们转换为元组：
d = 1,2,3  
print(d)
# (1, 2, 3)
# <class 'tuple'>
那么，反过来，就是序列解包：

d = 1,2,3
a, b, c = d
此时可以得到以下代码：
a, b, c = 1,2,3
print(a, b, c)
# 1 2 3
解包数量应该与序列长度相等，如下就会报错：
a, b = [1, 2, 3]
#Traceback (most recent call last):
#  File ".\c4.py", line 12, in <module>
#    a, b = [1, 2, 3]
#ValueError: too many values to unpack (expected 2)
修改长度：
#a, b = [1, 2]
#print(a, b) 
##  1 2

a, b = [1]
Traceback (most recent call last):
  File ".\c4.py", line 12, in <module>
    a, b = [1]
ValueError: not enough values to unpack (expected 2, got 1)
链式赋值：
 
a = b = c = 1
print(a, b, c)
#1 1 1

4.必须参数与关键字参数：

　　必须参数：

　　函数参数列表里定义的参数必须要传递的，如果不传递，是会报错的。
　　如下列代码：
def add(x, y):
    result = x + y
    return result
　　调用add函数时必须传两个参数，否则，会报错。
add(1)
# Traceback (most recent call last):
#  File ".\c1.py", line 12, in <module>
    add(1)
# TypeError: add() missing 1 required positional argument: 'y'
　　其中，x，y被称为形参，调用时传入的数据被称为实参。

　　关键字参数：

　　可以指明我传入参数是谁，此时就不需要按照顺序去传入参数。

def add(x, y):
    print(x, y)

c = add(y = 3, x = 2)
# 2 3

　默认参数：

　　在形参中赋予默认值。
def print_student_files(name, gender='男', age=22, college="华北水利水电大学"):
    print('我叫' + name)
    print('我今年' + str(age) + '岁了')
    print('我是' + gender + '生')
    print('我在' + college + '上学')

print_student_files('鸡小萌', '男', 18, '人民路小学')
print('_______________________________________________')
print_student_files('五六七')
print('_______________________________________________')
print_student_files('果果', age = 17)
结果是：
我叫鸡小萌
我今年18岁了
我是男生
我在人民路小学上学
_______________________________________________
我叫五六七
我今年22岁了
我是男生
_______________________________________________
我叫果果
我今年17岁了
我是男生
我在华北水利水电大学上学
　　注意：
　　　　如果要设置默认参数，则所有的必须参数都要放在前边，所有的默认参数都放在后边。同时必须参数和默认参数也不能混着给。
print_student_files('果果', gender = '女', 17, college='牛津中学')

File "c6.py", line 13
    print_student_files('果果', gender = '女', 17, college='牛津中学')
                                                  ^
SyntaxError: positional argument follows keyword argument

　　可变参数：

　　　　*号可以将参数组成元组，且如果有必须参数的话，必须参数必须放在前边。
def demo(*param):
    print(param)
    print(type(param))

demo(1,2,3,4,5,6)
#结果：
#(1, 2, 3, 4, 5, 6)
#<class 'tuple'>
　　而且，*号可以将实参进行平铺，即元组转换为一个个元素：
def demo(*param):
    print(param)
    print(type(param))

a = (1, 2, 3, 4, 5, 6)
demo(*a)
对于实参：

def demo(param1, *param, param2 = 2):
    print(param1)
    print(param2)
    print(param)

demo('a', 1,2,3, param2 = '3')

#a
#3
#(1, 2, 3)

 关键字可变参数：

 　　用两个*号去将关键字参数转为字典。
def city_temp(**param):
    print(param)
    print(type(param))
    pass

city_temp(bj = '32', xm = '23', sh = '31')

#{'bj': '32', 'xm': '23', 'sh': '31'}
#<class 'dict'>
　　遍历字典：
　　　　以下是错误遍历：
def city_temp(**param):
    for key, value in param:
        print(key, ':', value)

city_temp(bj = '32', xm = '23', sh = '31')

#b : j
#x : m
#s : h
　　正确遍历字典：
def city_temp(**param):
    for key, value in param.items():
        print(key, ':', value)

city_temp(bj = '32', xm = '23', sh = '31')

#bj : 32
#xm : 23
#sh : 31
　　对于字典的反向输入：
def city_temp(**param):
    for key, value in param.items():
        print(key, ':', value)

a = {'bj': '32c', 'sh':'31c'}
city_temp(**a)

#PS F:\pythonlearn\Demo\eight> python .\c8.py
# bj : 32c
#sh : 31c

　5.变量作用域：

  　　　　此处可以看到与javascript中的作用域有很大的不同。先来看代码：

c = 50  

def add(x, y):
    c = x + y
    print(c)

add(1, 2)
print(c) 
#3
#50
　　七月给的解释：函数内的c和函数外的c不是一个变量，相当于重新命名了一个变量a，然后打印a，与外边的c没有一点关系。

 

　　然鹅，函数内部可以调用函数外部的变量，那么问题来了：
c = 10

def demo():
    print(c)

demo() #10
　　for循环内定义的数据可以在for循环以外使用么？
def demo():
    c = 50

    for i in range(0, 9):
        a = 'a'
        c += 1
    print(c)
    print(a)

demo()

#59
#a
　　也就是说，在python中for循环等循环体内并不构成作用域。即，python中并没有块儿级作用域。
 

6.作用域链：

　　个人理解是：一个变量的值等于他所在的作用域中离得最近最小的作用域。即，所在作用域没有改变量，则向上级作用域查找，直到找到为止。
 
c = 1

def func1():
    c = 2
    def func2():
        c = 3
        print(c)
    func2()

func1()

//依次将 c = 3， c = 2这两行代码注释，得到打印的结果分别是3， 2， 1

 

7.global关键字：

　　　　可以通过global关键字将局部变量变为全局变量（变量会不会污染呢，我觉得不应该过多使用，或者说尽量不用）
def demo():
    global c
    c = 2

demo()

print(c) 
#2
个人测试，c10.py中写入上边代码，c11.py文件中导入
import c10
print(c10.c) //2
此时是可以打印出C的结果，然鹅，修改c11文件，
import c10
print(c) //c是未定义，因此，这个c并不是在项目中全局
Tags:

VirMach 便宜 VPS

QNews

QNews