python入门学习笔记——详细基础知识篇（第八章：python函数）

认识函数；函数的定义及运行特点

1）快速查看内置函数功能与应用：

打开python命令行：>>>help(想查看函数名称)

2）函数特性：

• 功能性
• 隐藏细节
• 避免编写重复代码

3）函数的基本结构：

def funcname(parameler_list) :
代码块

注：
参数列表（parameler_list）可以没有，funcname是指函数名;
返回值： return value /None

4）实例：

实现两个数字的相加
打印输入的参数

def add(x,y):
    result = x + y
    return result

def print_code(code):
    print(code)

-----------
输入：
add(1,2)
print_code('python')

输出：
3
python
-----------
输入：
a = add(1,2)
b = print_code('python')
print(a,b)

输出：
python     
3 None

因为print_code内部没有返回值，会把函数结果设置为None
注：第二个函数虽然没有返回值，但有一个print语句，所以运行完后会输出‘python’

如何让函数返回多个结果

1）如果函数内部 ：

• 不使用 return ————— 则会默认返回空值：None

• return 空 ——————— 连None也不会返回

2）当函数内部代码碰到 Return 之后，Return 后面的语句是不会执行的

3）在python中可以返回任意类型的值，可以直接返回多个值，直接用逗号隔开即可：return a,b,c…

4）变量取名要有意义，可以让代码可读性更好

序列解包与链式赋值

1. 引入：

a = 1
b = 2
c = 3

d = 1,2,3
print(type(d))————————输出 <class'tuple'> —————— 说明 d 是 序列

2. 序列解包的定义：
   ① a , b, c = [1,2,3]
   ②
   d = 1, 2, 3
   a, b, c = d

① ② 均是序列解包

注：序列里面有几个元素就要几个元素来接收

3. 小扩展：
   a = b = c =1
   print(a,b,c)
   也会输出：1 1 1（简化了代码，不用写三条语句）

必须参数与关键字参数

1）引入：

def add(x,y):
    result = x + y
    return result

a = add(1,2) ———————— 按顺序传入x,y的值，此时x，y是必须参数
b = add(y=3,x=2) —————— 不按顺序传入，此时x, y是关键字参数

x , y 也叫 形参
传入的值也叫 实参

2） 关键字参数 在函数调用时明确告诉python：所赋的实参到底是给哪个形参来赋值的，所以不用管传入的顺序。

3）小结：

这两种参数在定义上是相同的，只不过在调用上不一样，关键字参数可以任意调换 传入顺序。

注：定义多少个形参就要传递多少个实参

默认参数

（1）引入：

函数的定义：

def print_student_files(name,gender='男',age=10,college='实验小学'):
    print("我叫"+name)
    print("我今年"+str(age)+'岁')
    print("我是"+gender+"生")
    print("我在"+college+"上学")

调用：

print_student_files("小张","男",10,"实验小学")
print("~~~~~~~~~~~~~~~~")
print_student_files("小张")

输出结果：
    我叫小张
    我今年10岁
    我是男生
    我在实验小学上学
    ~~~~~~~~~~~~~~~~
    我叫小张
    我今年10岁
    我是男生
    我在实验小学上学


调用:
print_student_files("小洁","女",12)

输出结果：
    我叫小洁
    我今年12岁
    我是女生
    我在实验小学上学

有些参数是固定的值，可以用默认参数简化函数的调用。

（2）语法总结：
① 在定义时，如果想让函数有默认值，直接在形参后接等号赋值即可。
② 如果某形参未设置默认值，在调用时一定要传实参。如果想改变一个形参的默认值的话，直接正常传值，即可覆盖默认值。

（3）需要注意的点：

调用：
print_student_files("小洁",12,"女")

输出结果：
    我叫小洁
    我今年女岁
    ——————————————————————————因为没按顺序传入


调用：
print_student_files('小李',age='7',college='光明小学',gender='男')

输出结果：
     我叫小李
     我今年7岁
     我是男生
     我在光明小学上学
     ———————————————————————————————关键字参数传入时可以不考虑顺序

print_student_files('小李',gender='女',7,college='光明小学')

—————————— 会报错：因为不能把默认参数和必须参数混着调用。和定义时是一样的，要把必须参数放在一起，把默认参数放在一起。

可变参数

1）引入：

# 如何定义一个拥有可变参数的函数

def demo(*param):
    print(param)
    print(type(param))

demo(1,2,3,4,5,6)
demo((1,2,3,4,5,6))

输出：
(1, 2, 3, 4, 5, 6)
<class 'tuple'>
((1, 2, 3, 4, 5, 6),)
<class 'tuple'>

——————————————python能够 自动 把可变参数的列表所对应的实参 组装成一个tuple。所以传入元组时要减掉外层的括号

# 不使用可变参数
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)  # 不能直接传入变量a，会变成一个二维元组，要加上星号

—————————— *a的作用：把元组a里面的每个元素评估出来 传到可变参数的函数中去

可变参数可以和其他参数一起用，但必须参数 要放在前面

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

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

输出：
a
1
(2, 3)
————————————————————没有办法跳过默认参数

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

demo('a', 1,2,3,'param')  
输出：
a
2
(1, 2, 3, 'param')

demo('a', 1,2,3,param2='param')
输出：
a
param
(1, 2, 3)

经验建议：
没有必要把函数参数类型设计的很复杂（例如上述例子含有必须参数、可变参数、默认参数3种，很容易出错），类型越简单越好。

关键字可变参数

（1）可变参数的应用实例：

#求平方和

def squsum(*param):   
    sum =0
    for i in param:
        sum +=i*i
    print(sum)

squsum(1,2)
squsum(*(1,2))

输出：
5
5

（2）关键字可变参数的引入：

# 假设某函数参数列表为每个城市的温度：
funcname('36c','27c','31c')
假设这样传入，并不知道是哪个城市的温度。
 —————————— 引入关键字可变参数

需要设计一个函数，函数的形参列表可以支持 任意个数的关键字参数。

def city_temp(**param):      #两个*
    print(param)
    print(type(param))
    pass
city_temp(bj='32c',xm='23c',sh='31c')

输出：
{'bj': '32c', 'xm': '23c', 'sh': '31c'}
<class 'dict'>    # 字典

（1）
def city_temp(**param):
    for c in param:
        print(c)
city_temp(bj='32c',xm='23c',sh='31c')

输出没打印值：
bj
xm
sh

（2）
def city_temp(**param):
    for key,value in param:
        print(key,':',value)
city_temp(bj='32c',xm='23c',sh='31c')

输出不是我们想要的：
b : j
x : m
s : h

（3）正确遍历字典的方法，需要调用param的一个方法：items()

传入键值对：

def city_temp(**param):
    for key,value in param.items():
        print(key,':',value)

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

输出：
bj : 32c
sh : 31c

注：关键字可变参数可以什么都不传。输出结果是一个空的字典：{}

变量作用域

（1）引入：

c=50        

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

add(1,2)
print(c)

输出：
3
50

每一个变量都有一个作用域 —————— 变量作用域

（2）

c=10         #全局变量：函数外部定义的变量
def demo():
    c=50     #局部变量：函数里面所定义的变量

print(c)
输出：10

（3）

在python中： 是可以直接引用 for 循环、while循环内部的变量的 —————— 因为在python中没有 块级作用域 的概念

作用域链

（1）思考题：

c = 1

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

运行结果：3
如果把 C=3 注释掉，打印出来的是2
如果把 C=3 和 C=2 都注释掉，则打印出来的是1

（2）由上面的例子可以看出：在Python中，作用域是具有链式的特性的 ———— 作用域链

global关键字

（1）全局变量并不是仅局限于一个模块，不做特别限制的话，在整个应用程序里面都是可以引用的

（2）在Python中，怎样把函数内部的局部变量变成一个全局变量？———— global关键字

以下是C1模块中的代码

def demo():
    global c
    c=2
demo()   #得先调用函数
print(c)

输出：2

可以在其他模块里面引用这个 global定义的全局变量 c 吗？
答：可以

import c1
print(c1.c)   #这里是直接引用另一个模块中定义的全局变量c，不用调用函数！

输出：
2       #导入C1模块，会打印出C1模块的运行结果
2       

划算还是不划算

实训项目