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并不是在项目中全局