python函数

fo安方

已于 2022-09-04 15:02:45 修改

阅读量1.1k

点赞数 1

分类专栏： python 文章标签： python 开发语言

于 2022-03-17 06:58:29 首次发布

本文链接：https://blog.csdn.net/stqer/article/details/123541005

版权

python 专栏收录该内容

12 篇文章 3 订阅

订阅专栏

文章目录

函数（多行代码整合）
是什么
怎么做

函数（多行代码整合）

前言：

为什么：函数作用：把具有独立功能的代码块组织为一个小模块，在需要的时候调用。能够实现一个具体的功能，是多行代码的整合。
是什么：函数的定义def、参数、返回值return/None、传参、局部&全局global变量、分类1-递归函数、分类2-匿名函数、传参也是引用。
做什么：嵌套调用、

是什么

一、函数的定义和调用

1.1.函数的定义

函数定义：定义函数的格式如下:

 def 函数名():    
 
 代码

格式说明如下：

（1）def是英文define的缩写

（2）函数名称应该能够表达函数封装代码的功能，方便后续的调用（函数中的代码不会执行，在函数调用时，才会执行）

（3）函数名称的命名应该符合标识符的命名规则
。可以由字母、下划线和数字组成
。不能以数字开头
。不能与关键字重名

作用：能够实现一个具体的功能，是多行代码的整合
好处：重复的代码不需要多次书写，减少代码冗余

1.2.函数调用

调用函数很简单的，通过函数名()即可完成对函数的调用

二、函数的参数

2.1. 定义

形参：定义函数时，小括号中的参数，是用来接收参数用的，在函数内部作为变量使用
形参类型：普通形参、缺省形参、不定长元组形参、不定长字典形参
实参：调用函数时，小括号中的参数，是用来把数据传递到函数内部用的

关联：形参的个数需要和实参的个数对应，相同，不能多，也不能少

2.2. 分类

普通形参：

def fun(a,b=1)  #先普通再缺省
    pass

缺省形参：在函数定义的时候，给形参一个默认值，这个形参就是缺省参数，注意点：缺省参数要写在普通参数的后边
特点：在函数调用的时候，如果给缺省参数传递实参值，使用的是传递的实参值，如果没有传递，使用默认值

# print()
# 缺省参数,形参.在函数定义的时候,给形参一个默认值,这个形参就是缺省参数,
# 注意点: 缺省参数要写在普通参数的后边
# 特点: 在函数调用的时候,如果给缺省参数传递实参值,使用的是传递的实参值,如果没有传递,使用默认值


def func(a, b, c=10):  # 形参c 称为缺省形参
    print(f"a: {a}")
    print(f"b: {b}")
    print(f"c: {c}")


func(1, 2)  # 没有给c 传递实参,使用默认值10
func(1, 2, 3)  # 给c传递实参值,使用传递的数据3
执行结果如下：
a: 1
b: 2
c: 10
a: 1
b: 2
c: 3

def user_info(name, age, gender='男'):
    print(f'您的姓名是{name}, 年龄是{age}, 性别是{gender}')


user_info('TOM', 18)  # 没有为缺省参数传值，表示使用默认值
user_info('TOM', 18, gender='女')  # 为缺省参数传值，使用这个值，即修改了默认值
执行结果如下：
您的姓名是TOM, 年龄是18, 性别是男
您的姓名是TOM, 年龄是18, 性别是女

不定长元组形参：

在形参前边加一个*，该形参变为不定长元组形参，可以接收所有的位置实参，类型是元组

# print(1)
# print(1, 2)
# print(1, 2, 3)
# print(1, 2, 3, 4)
# print(1, 2, 3, 4, 5)


def func(args, kwargs):  # 两个普通的形参
    print(args)
    print(kwargs)


func(1, 2)
func(args=2, kwargs=1)

print('*' * 30)
print('*' * 30)


# 在形参前边加上一个*, 该形参变为不定长元组形参,可以接收所有的位置实参, 类型是元组
# 在形参前边加上两个**, 该形参变为不定长字典形参, 可以接收所有的关键字实参,类型是字典
def func(*args, **kwargs):
    print(args)
    print(kwargs)
func(1, 2, 3, 3, 4, 5)
func(a=1, b=2, c=3, d=4)
func(1, 2, 3, a=4, b=5, d=6)

执行结果如下：
1
2
2
1
******************************
******************************
(1, 2, 3, 3, 4, 5)
{}
()
{'a': 1, 'b': 2, 'c': 3, 'd': 4}
(1, 2, 3)
{'a': 4, 'b': 5, 'd': 6}

Process finished with exit code 0

不定长字典形参：

在形参前边加两个**，该形参变为不定长字典形参，可以接收所有的关键字实参，类型是字典

# 普通形参  缺省形参  不定长元组形参   不定长字典形参
def func(a, b=1):  # 先普通再 缺省
    pass


def func1(a, b=1, *args):  # 语法上不会报错,但是缺省参数不能使用默认值
    print('a', a)
    print('b', b)
    print(args)


def func2(a, *args, b=1):  # 普通形参  不定长元组形参  缺省形参
    print('a', a)
    print('b', b)
    print(args)


def func3(a, *args, b=1, **kwargs):  # 普通形参  不定长元组形参  缺省形参 不定长字典形参
    pass


# func1(1, 2, 3, 4)
# func2(1, 2, 3, 4)
func2(1, 2, 3, 4, b=10)

执行结果如下：
a 1
b 10
(2, 3, 4)

2.3. 作用

增加函数的通用性，针对相同的数据处理逻辑，能够适应更多的数据

在函数内部，把参数当做变量使用，进行需要的数据处理（形参）
函数调用时，按照函数定义的参数顺序，把希望在函数内部处理的数据，通过参数传递（实参）

三、传参

定义

●位置传参：按照形参的位置顺序将实参的值传递给形参
●关键字传参：指定实参给到哪个形参，注意点：关键字必须是函数的形参名

位置传参

参数之位置传参

# 需求：函数3个参数name，age，gender
def user_info(name, age, gender):
    print(f'您的姓名是{name}, 年龄是{age}, 性别是{gender}')


# user_info('TOM', 20, '男')
# user_info('TOM', 20)  # 个数定义和传入不一致会报错
user_info(20, 'TOM', '男')  # 顺序也和定义必须是一致的，否则导致数据无意义
执行结果如下：
您的姓名是20, 年龄是TOM, 性别是男

不定长参数之位置参数

# 接收所有位置参数，返回一个元组
def user_info(*args):
    print(args)


user_info('TOM')
user_info('TOM', 20)
user_info('TOM', 20, 'man')
user_info()

执行结果如下：
('TOM',)
('TOM', 20)
('TOM', 20, 'man')
()

关键字传参

参数之关键字传参

def user_info(name, age, gender):
    print(f'您的姓名是{name}, 年龄是{age}, 性别是{gender}')


# 调用函数传参
user_info('ROSE', age=20, gender='女')
user_info('小明', gender='男', age=18)  # 关键字参数之间不分先后顺序
# 位置参数必须写在关键字参数的前面
# user_info(age=20, gender='男', 'TOM')

执行结果如下：
您的姓名是ROSE, 年龄是20, 性别是女
您的姓名是小明, 年龄是18, 性别是男

不定长参数之关键字传参

# 接收所有位置参数，返回一个元组
def user_info(*args):
    print(args)


user_info('TOM')
user_info('TOM', 20)
user_info('TOM', 20, 'man')
user_info()

执行结果如下：
('TOM',)
('TOM', 20)
('TOM', 20, 'man')
()

特点

●混合使用：先写位置传参再写关键字传参
●错误写法：关键字实参要在位置实参的后边

四、函数的返回值-return

定义

返回值是函数完成工作后，最后给调用者的一个结果，在函数中使用return关键字可以返回结果;
在函数中定义的局部变量，或者通过计算得出的局部变量，想要在函数外部访问和使用，此时就可以使用 return 关键字，将这个返回值返回

命令

def sum_2_num(num1, num2):
    """对两个数字的求和"""

    result = num1 + num2

    # 可以使用返回值，告诉调用函数一方计算的结果
    return result
    # 注意：return 就表示返回，下方的代码不会被执行到！
    # num = 1000

可以使用变量，来接收函数执行的返回结果
sum_result = sum_2_num(10, 20)

print("计算结果：%d" % sum_result)

计算结果：30

特点

return表示返回，后续的代码都不会被执行

作用

将return后边的数据值进行返回；
程序代码遇到return，会终止(结束)执行；
在函数中定义的局部变量，或者通过计算得出的局部变量，想要在函数外部访问和使用，此时就可以使用return关键字，将这个返回值返回。

None

None

（1）return 关键字后边可以不写数据值，默认返回 None
```
def func(): 

xxx 

return # 返回 None，终止函数的运行的
```
（2）函数可以不写 return，返回值默认是 None
```
def func(): 

xxx 

pass
```

五、函数的局部变量

定义

是在函数内部定义的变量

作用

●作用：在函数内部使用，临时保存函数内部需要使用的数据；
●作用范围：局部变量是在函数内部定义的变量，只能在函数内部使用（当前函数的内容）；
●生存周期：函数执行结束后，函数内部的局部变量，会被系统回收；
●特点：不同的函数，可以定义相同的名字的局部变量，但是彼此之间不会产生影响；

概念

●生命周期：
。所谓生命周期就是变量从被创建到被系统回收的过程
。局部变量在函数执行时才会被创建
。函数执行结束后局部变量被系统回收
。局部变量在生命周期内，可以用来存储函数内部临时使用到的数据

# 定义一个函数，声明一个变量：函数体内部访问、函数体外面访问
def testA():
    a = 100
    print(a)  # 函数体内部访问，能访问到a变量


testA()
# print(a)  # 报错： a变量是函数内部的变量，函数外部无法访问 -- a是一个局部变量
执行结果如下：
100

六、函数的全局变量

定义

是在函数外部定义的变量(没有定义在某一个函数内)，所有函数内部都可以使用这个变量（如果想要修改全局变量的值，需要使用global关键字声明）

访问全局变量

# 声明全局变量：函数体内外都能访问
a = 100

print(a)


def testA():
    print(a)


def testB():
    print(a)


testA()
testB()
执行结果如下：
100
100
100

作用

特点

函数不能直接修改全局变量的引用
全局变量是在函数外部定义的变量(没有定义在某一个函数内)，所有函数内部都可以使用这个变量
在其他的开发语言中，大多不推荐使用全局变量——可变范围太大，导致程序不好维护!
为了保证所有的函数都能够正确使用到全局变量，应该将全局变量定义在其他函数的上方

注意

全局变量命名的建议：
●为了避免局部变量和全局变量出现混淆，在定义全局变量时，有些公司会有一些开发要求, 例如：全局变量名前应该增加g_或者gl_的前缀。
提示：具体的要求格式,各公司要求可能会有些差异。

七、函数的引用（函数传参传递是引用）

定义

定义：变量中记录数据的地址，就叫做引用。

变量和数据是分开存储的
数据保存在内存中的一个位置
变量中保存着数据在内存中的地址

引用分类：python中数据值的传递、函数传参传递

查看方式：使用id()函数可以查看变量中保存数据所在的内存地址，可以将id 值认为是内存地址的别名

在Python中函数的参数传递以及返回值都是靠引用传递的

# 将数据10存储到变量a中, 本质是将数据10所在内存的引用地址保存到变量a中
a = 10
# 将变量a中保存的引用地址给给到b
b = a
print(a, b)  # 使用print函数打印变量a和b引用中存储的值
print(id(a), id(b))
a = 20
print(a, b)
print(id(a), id(b))

执行结果如下：
10 10
140718781487040 140718781487040
20 10
140718781487360 140718781487040

my_list = [1, 2, 3]  # 将列表的引用地址保存到变量my_list 中
my_list1 = my_list  # 将my_list 变量中存储的引用地址给到 my_list1
print(my_list, id(my_list))
print(my_list1, id(my_list1))

my_list.append(4)  # 向列表中添加数据4, 将数据4的引用保存到列表中
print(my_list, id(my_list))
print(my_list1, id(my_list1))

my_list[2] = 5
print(my_list, id(my_list))
print(my_list1, id(my_list1))

执行结果如下：
[1, 2, 3] 2184769236096
[1, 2, 3] 2184769236096
[1, 2, 3, 4] 2184769236096
[1, 2, 3, 4] 2184769236096
[1, 2, 5, 4] 2184769236096
[1, 2, 5, 4] 2184769236096

函数传参传递是引用

# 函数传参传递的也是引用
my_list = [1, 2, 3]  # 全局变量


def func1(a):
    a.append(4)


def func2():
    # 为啥不加global, 因为没有修改 my_list 中存的引用值
    my_list.append(5)


def func3():
    global my_list
    my_list = [1, 2, 3]   # 修改全局变量的值


def func4(a):
    # += 对于列表来说,类似列表的extend方法,不会改变变量的引用地址
    a += a  # a = a + a, 修改了a变量a的引用
    # print(a)


func1(my_list)    # [1, 2, 3, 4]
func2()  # [1, 2, 3, 4, 5]
func3()  # [1, 2, 3]
print(my_list)

b = 10  # 不可变类型
func4(b)
print(b)  #

func4(my_list)
print(my_list)  # [1, 2, 3, 1, 2, 3]

执行结果如下：
[1, 2, 3]
10
[1, 2, 3, 1, 2, 3]

bb = aa

print(bb)

print(id(aa))
print(id(bb))

aa.append(30)
print(aa)
print(bb)  # 列表是可变类型

print(id(aa))
print(id(bb))

执行结果如下：
[10, 20]
2357098503488
2357098503488
[10, 20, 30]
[10, 20, 30]
2357098503488
2357098503488

# 可变和不可变

# 1. 不可变：int： 1.1 声明变量保存整型数据，把这个数据赋值到另一个变量； id()检测两个变量的id值(内存的十进制值)
# a = 1
# b = a
#
# print(b)
#
# # 发现a和b的id值相同的
# print(id(a))
# print(id(b))
#
# # 修改a的数据测试id值
# a = 2
#
# print(b)
#
# # 因为修改了a的数据，内存要开辟另外一份内存取存储2，id检测a和b的地址不同
# print(id(a))
# print(id(b))


# 2. 可变类型：列表
aa = [10, 20]
bb = aa

print(bb)

print(id(aa))
print(id(bb))

aa.append(30)
print(aa)
print(bb)  # 列表是可变类型

print(id(aa))
print(id(bb))
执行结果如下：
[10, 20]
1864940444992
1864940444992
[10, 20, 30]
[10, 20, 30]
1864940444992
1864940444992

引用当做实参

# 需求：引用是否可以当做实参
"""
1. 定义函数： 有形参
    1.1 访问打印形参看是否有数据
    1.2 访问形参的id
    1.3 改变形参的数据，查看这个形参并打印id，看id值是否相同
2. 调用函数 -- 把可变和不可变两种类型依次当做实参传入
"""


def test1(a):
    print(a)
    print(id(a))

    a += a
    print(a)
    print(id(a))


b = 100
test1(b)


c = [11, 22]
test1(c)
执行结果如下：
100
140729861399296
200
140729861402496
[11, 22]
2210520993728
[11, 22, 11, 22]
2210520993728

八、函数的分类1—匿名函数

定义

使用 lambda 关键字定义的函数就是匿名函数

lambda 参数列表：表达式

# 需求：函数 返回值100


# 1. 函数
# def fn1():
#     return 100
#
#
# result = fn1()
# print(result)

# 2. lambda  匿名函数
# lambda 参数列表: 表达式
fn2 = lambda: 100
print(fn2)  # lambda内存地址

# 100返回值 调用函数
print(fn2())
执行结果如下：
<function <lambda> at 0x0000026DF32F78B0>
100

参数形式

无参无返回值

def func1():
   print('hello')

(lambda: print('hello lambda'))()
func1()
f1 = lambda: print('hello lambda')
f1()

无参有返回值

def func2():
   return 1 + 2


f2 = lambda: 1 + 2
print(f2())

有参无返回值

def func3(name):
   print(name)


f3 = lambda name: print(name)
f3('hwllo')

有参有返回值

def func4(*args):
   return args

f4 = lambda *args: args
print(f4(1, 2, 3, 4, 5))

lambda的参数形式
# 1. 无参数
# fn1 = lambda: 100
# print(fn1())


# 2. 一个参数
# fn2 = lambda a: a
# print(fn2('hello world'))


# 3. 默认参数/缺省参数
# fn3 = lambda a, b, c=100: a + b + c
# print(fn3(10, 20))
# print(fn3(10, 20, 200))


# 4. 可变参数：*args
# fn4 = lambda *args: args
# print(fn4(10, 20))
# print(fn4(10, 20, 30, 40))
# print(fn4(10))


# 5. 可变参数：**kwargs
fn5 = lambda **kwargs: kwargs
print(fn5(name='Python'))
print(fn5(name='Python', age=30))

执行结果如下：
{'name': 'Python'}
{'name': 'Python', 'age': 30}

应用

匿名函数的应用场景1——作为函数的参数使用

def my_calc(a, b, func):
    """
    进行四则运算
    :param a: 第一个数据
    :param b: 第二个数据
    :param func: 函数,要进行的运算
    :return: 运算的结果
    """
    print('其他的函数代码...')
    num = func(a, b)
    print(num)


def add(a, b):
    return a + b


# 调用
my_calc(10, 20, add)
my_calc(10, 20, lambda a, b: a - b)
my_calc(10, 20, lambda a, b: a * b)
my_calc(10, 20, lambda a, b: a / b)

执行结果如下：
其他的函数代码...
30
其他的函数代码...
-10
其他的函数代码...
200
其他的函数代码...
0.5

# 需求：计算任意两个数字的累加和
# 1. 函数
def add(a, b):
    return a + b

result = add(1, 2)
print(result)

# 2. lambda
fn1 = lambda a, b: a + b
print(fn1(2, 3))

执行结果如下：
3
5

应用场景2——带判断

# lambda 两个数字比大小，谁大返回谁
fn1 = lambda a, b: a if a > b else b
print(fn1(1000, 500))

执行结果如下：
1000

九、函数的分类2—递归函数

定义

函数自己嵌套调用自己
递归特点：函数内部自己调用自己；必须有出口

# 回顾函数返回值：写法 和 返回的位置: 函数调用的位置
def return_num():
    return 100


result = return_num()
print(result)

执行结果如下：
100

应用

# 需求：3以内数字累加和 3 + 2 + 1 = 6
# 6 = 3 + 2以内数字累加和
# 2以内数字累加和 = 2 + 1以内数字累加和
# 1以内数字累加和 = 1  # 出口


# 递归特点：函数内部自己调用自己；必须有出口


def sum_numbers(num):
    # 2. 出口
    if num == 1:
        return 1
    # 1. 当前数字 + 当前数字-1的累加和
    return num + sum_numbers(num-1)


result = sum_numbers(3)
print(result)

# 如果没有出口，报错：超出最大递归深度

执行结果如下：
6

def get_age(num):
    """
    求第 num 个人的年龄,每相邻的两个人的年龄差两岁, 已知第一个人的年龄是 18岁
    :param num:
    :return:
    """
    if num == 1:
        return 18
    # 求第 num个人的年龄,只需要num-1 这个人的年龄 + 2
    age = get_age(num-1) + 2
    return age


print(get_age(4))

执行结果如下：
24

怎么做

函数的嵌套调用

定义

一个函数里面又调用了另外一个函数

命令


def test1():

    print("*" * 50)


def test2():

    print("-" * 50)

    # 函数的嵌套调用
    test1()

    print("+" * 50)

test2()

C:\Users\18826\AppData\Local\Programs\Python\Python38\python.exe "D:/python/资料-python入门教程完整版（懂中文就能学会）/02 Python 基础资料/代码/04_函数/hm_07_函数的嵌套调用.py"
--------------------------------------------------
**************************************************
++++++++++++++++++++++++++++++++++++++++++++++++++

Process finished with exit code 0

# 两个函数 testA 和 testB  -- 在A里面嵌套调用B
# B函数
def testB():
    print('B函数开始-----')
    print('这是B函数')
    print('B函数结束-----')

# A函数
def testA():
    print('A函数开始-----')
    # 嵌套调用B
    testB()
    print('A函数结束-----')


testA()
执行结果如下：
A函数开始-----
B函数开始-----
这是B函数
B函数结束-----
A函数结束-----

应用

打印横线图形

# 1. 打印一条横线


def print_line():
    print('-' * 20)


# print_line()


# 2. 函数嵌套调用 实现多条横线
def print_lines(num):
    i = 0
    while i < num:
        print_line()
        i += 1


print_lines(5)

执行结果如下：
--------------------
--------------------
--------------------
--------------------
--------------------

函数计算

# 1. 任意三个数之和
def sum_num(a, b, c):
    return a + b + c


result = sum_num(1, 2, 3)
# print(result)


# 2. 任意三个数求平均值
def average_num(a, b, c):
    # 先求和 再除以3
    sumResult = sum_num(a, b, c)
    return sumResult / 3


averageResult = average_num(1, 2, 3)
print(averageResult)
执行结果如下：
2.0

拆包

# 组包, 将多个数据值,组成元组,给到一个变量.
a = 1, 2, 3
print(a)  # (1, 2, 3)


def func():
    return 1, 2  # 组包


# 拆包: 将容器的数据分别给到多个变量, 需要注意: 数据的个数和变量的个数要保持一致
b, c, d = a   # 拆包
# print(b, c, d)

e, f = func()
print(e, f)

my_list = [10, 20]
a, b = my_list
print(a, b)
my_dict = {'name': 'isaac', 'age': 18}
a, b = my_dict   # key值
print(a, b)

执行结果如下：
C:\Users\18826\AppData\Local\Programs\Python\Python38\python.exe "D:/python/资料-python零基础入门/day05 函数/04-代码/08-拆包.py"
(1, 2, 3)
1 2
10 20
name age

Process finished with exit code 0

# 1. 拆包元组数据
# def return_num():
#     return 100, 200
#
#
# # result = return_num()
# # print(result)
# num1, num2 = return_num()
# print(num1)
# print(num2)


# 2. 字典数据拆包: 变量存储的数据是key值
# 先准备字典，然后拆包
dict1 = {'name': 'TOM', 'age': 20}
# dict1中有两个键值对，拆包的时候用两个变量接收数据
a, b = dict1
print(a)
print(b)

# v值
print(dict1[a])
print(dict1[b])

执行结果如下：
name
age
TOM
20

a = 10
b = 20

# 方法一:
# c = a
# a = b
# b = c
# print(a, b)

# 方法二: +/-   */÷
# a = a + b  # a 30
# b = a - b  # 10
# a = a - b  # 20
# print(a, b)

# 方法三, python中的使用 组包和拆包
a, b = b, a
print(a, b)
执行结果如下：
20 10

变换变量的值

# a = 10
# b = 20

# 1. 方法一
"""
1.1 定义中间的第三变量，为了临时存储a或b的数据
1.2 把a的数据存储到c，做保存
1.3 把b的数据赋值到a， a = 20
1.4 把c的数据赋值到b， b = 10
"""
# c = 0
# c = a
# a = b
# b = c
#
# print(a)
# print(b)
执行结果如下：
1
2
2
1

高阶函数

# abs(): 绝对值
# print(abs(-10))

# round()： 四舍五入
print(round(1.2))
print(round(1.9))
执行结果如下：
1
2

# 需求：任意两个数字，先进行数字处理(绝对值或四舍五入)再求和计算


# 1. 写法一
# def add_num(a, b):
#     # 绝对值
#     return abs(a) + abs(b)
#
#
# result = add_num(-1.1, 1.9)
# print(result)

# 2. 写法二：高阶函数:f是第三个参数，用来接收将来传入的函数
def sum_num(a, b, f):
    return f(a) + f(b)


result1 = sum_num(-1, 5, abs)
print(result1)


result2 = sum_num(1.1, 1.3, round)
print(result2)

内置高阶函数–map

# 1. 准备列表数据
list1 = [1, 2, 3, 4, 5]


# 2. 准备2次方计算的函数
def func(x):
    return x ** 2


# 3. 调用map
result = map(func, list1)

# 4. 验收成果
print(result)
print(list(result))
执行结果如下：
<map object at 0x000002A079FE7F40>
[1, 4, 9, 16, 25]

内置高阶函数–reduce

list1 = [1, 2, 3, 4, 5]

# 1. 导入模块
import functools


# 2. 定义功能函数
def func(a, b):
    return a + b


# 3. 调用reduce，作用：功能函数计算的结果和序列的下一个数据做累计计算
result = functools.reduce(func, list1)
print(result)
执行结果如下：
15

内置高阶函数–filter

list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]


# 1. 定义功能函数：过滤序列中的偶数
def func(x):
    return x % 2 == 0


# 2. 调用filter
result = filter(func, list1)
print(result)

print(list(result))

执行结果如下：
<filter object at 0x000001C66FA67970>
[2, 4, 6, 8, 10]

读取函数

readlines

f = open('test.txt', 'r')

con = f.readlines()
print(con)

f.close()
执行结果如下：
['aaaaa\n', 'bbbbb\n', 'ccccc\n', 'ddddd\n', 'eeeee']

readline

f = open('test.txt', 'r')

con = f.readline()
print(con)

con = f.readline()
print(con)

con = f.readline()
print(con)

f.close()
执行结果如下：
aaaaa

bbbbb

ccccc

read

f = open('test.txt', 'r')

# 文件内容如果换行，底层有\n，会有字节占位，导致read书写参数读取出来的眼睛看到的个数和参数值不匹配
# read不写参数表示读取所有；
# print(f.read())
print(f.read(10))

f.close()
执行结果如下：
aaaaa
bbbb

seek

"""
语法： 文件对象.seek(偏移量, 起始位置)  0开头1当前2结尾
目标：
    1. r 改变文件指针位置：改变读取数据开始位置或把文件指针放结尾(无法读取数据)
    2. a 改变文件指针位置，做到可以读取出来数据
"""
# f = open('test.txt', 'r+')
f = open('test.txt', 'a+')

# 1. 改变读取数据开始位置
# f.seek(2, 0)
# 1. 把文件指针放结尾(无法读取数据)
# f.seek(0, 2)

# 2. a 改变文件指针位置，做到可以读取出来数据
# f.seek(0, 0)
f.seek(0)

con = f.read()
print(con)

f.close()
执行结果如下：
aaaaa
bbbbb
ccccc
ddddd
eeeee

题目

题目1 [加强训练]

题干

有如下代码：

num = 10
def anum():
    num = 20
    
print(num)

请问这段代码最终输出的值是多少？

训练目标

分清全局变量与局部变量

训练提示

全局变量与局部变量有什么区别

参考方案

对于在函数内部的变量，如果改变没有global声明的变量，那么相当于是重新定义了一个与全局变量同名的局部变量

题目2 [加强训练]

题干

有如下代码：

def abnum(big, small, middle):
    .....#此处省略一千行代码

现在要调用abnum函数，但是怕在调用的时候将参数的位置传错，如何避免这个情况？写一段代码示范下

训练目标

关键字参数的使用

训练提示

题中已经给了现有的函数以及形参，但是要怎么才能保证实参能够一对一传入，不发生错误呢？

参考方案

明确要用关键字参数，来指定参数位置

操作步骤

在调用函数的时候，直接标明参数的值

参考答案

abnum(big=5, small=1, middle=1)

题目3 [加强训练]

题干

在填写个人资料时，如果选了女性，那么性别是女；如果不选性别，那就是默认是男，那么这个功能用函数怎么实现？

要求如下：定义一个函数gender，并在函数中将“所选性别为*”，并可以成功调用运行。

训练目标

练习缺省参数的使用，事实上缺省参数也是很常使用的

训练提示

在定义函数的时候，如何声明形参是缺省参数？
缺省参数的意义是什么呢？

参考方案

在声明函数时直接声明缺省参数。
缺省参数意味着，如果不传参数的话，那就按照默认的值来进行使用，并且程序不会报错。

操作步骤

参考答案

def gender(g="男")：
	print("您的性别是:"+g)
gender()
# 经过上述例子以及代码，是不是说明我们的缺省参数是可以缺少可以省去的？

题目4 [加强训练]

题干

要求实现一段代码：

声明一个函数num，并且在调用函数的时候，不管输入多少个非关键字参数，函数都可以运行，且在函数内部还要把每个参数输出到屏幕上。

训练目标

不定长元组类型参数的使用
元组的遍历

训练提示

不定长参数有什么作用？

参考方案

在不确定参数的个数的时候，用不定长参数做形参，可以接受多个可以接受的参数。

操作步骤

定义一个函数num，形参为*args，然后在函数内部进行对元组遍历输出即可

参考答案

def num(*args):
    for i in args:
        print(i)

题目5 [综合训练]

题干

如下所示这是一个字典，{“name”:“电脑”,“price”:7000}

请定义这样一个函数num，讲上述字典中的键值对传入到函数num中，要求用不定长参数来接收，并在函数中打印键值对输出

输出格式为：

key: name value: 电脑
key: price value: 700

训练目标

不定长参数字典类型的使用
遍历字典

训练提示

字典类型的不定长参数的关键字什么？
调用函数时应如何传参？
如何对字典完成遍历并输出？

参考方案

1.不定长参数关键字没有固定的关键字，但是一般用 **kwargs多一些

2.传入关键字参数

3.可以对字典的键，值，以及键值对进行遍历

操作步骤

不定长参数关键字没有固定的关键字，但是一般用 **kwargs多一些
遍历选择用dict.items()
调用时传入关键字参数，将键值对传入即可

参考答案

def num(**kwargs):
    for key,value in kwargs.items():
        print("key:",key,"value:",value)
num(name="电脑", price=700)

题目6 [综合训练]

题干

对于一个函数num，当调用nun(1,2,a=3,b=4)和调用num(3,4,5,6,a=1)以及num(a=1,b=2)的时候都可以正常运行，并且可以对元组以及字典类型进行遍历输出，对字典类型进行输出字典的键值对(形式为：key：a，value：1)，

请写出这个函数并完成调用。

训练目标

元组类型不定长参数与字典类型不定长参数的混合使用

训练提示

当有元组以及字典两个不定长参数的时候，顺序要怎么放？如何传参？参数顺序有没有什么顺序？

参考方案

可以采用*args与**kwargs两个形参
定义一个函数num，调用时将关键字参数放在最后面，其他参数放在前面在函

操作步骤

定义函数num时，参数顺序应该是*args，**kwargs
在函数内部分别执行遍历操作即可

参考答案

def num(*args, **kwargs):
    for i in args:
        print(i)
    for key,value in kwargs.items():
        print("key:",key,"value:",value)
num(1,2,3,a=1, b=2)
# num(a=1, b=2)  此种情况也可