python入门（4）—— 函数的使用

1.函数定义和调用

1.1定义函数

定义函数的格式如下：

def 函数名():
    代码

demo：

# 注意python中习惯于使用下划线 _ 作为方法名的不同单词间的间隔
def print_my_python():
    i = 0;
    while i < 10:
        print(f"第{i}遍输出我的Python")
        i += 1
print("开始打印测试。。。")
print_my_python()
print("测试结束。。。")

# 无参数的方法定义
def sum1():
    print(f"{3+5}")
sum1()

# 带参数的方法定义
def sum2(a, b):
    return a + b
print(sum2(1, 1))

1.2 函数的文档注释使用

"""
函数的注释:
        对函数进行解释说明的文字.
函数的文档注释:
    在函数定义的那一行的下面添加的多行注释.

文档注释的作用:
    对函数进行解释说明,提高了函数的可读性.
"""
def hello_python():
    '''
    函数的注释：
    打印十次python
    :return: 空值
    '''
    i = 1
    while i <= 10:
        print(f"hello python {i}")
        i += 1
hello_python()
print()

1.3 关于函数返回值的一些细节

retur语句不写返回值，表示直接结束当前的操作，同一个文件中的函数不能够重名，重名了后边的方法会覆盖前边的方法。

"""
函数的5个细节(重点):
    1.保存函数的返回值
    2.直接打印函数的返回值
    3.函数的返回值作为参数传递给另一个函数
    4.函数中写多个return语句
    5.同一个文件中函数不能重名
"""

def func1(x):
    print(x)

# 1.保存函数的返回值
def sum1(a,b):
    return a+b
res = sum1(2,3)
print(res) # 5

# 2.直接打印函数的返回值
print(sum1(2,3)) # 5

# 3.函数的返回值作为参数传递给另一个函数
func1(sum1(2,3)) # 5

# 4.函数中写多个return语句
# 只执行最上面的return语句.在执行函数时,只要执行了return语句,函数的执行到此结束,不再向下执行了.
print("========多个return==========")
def sum2(a,b,c):
    return a
    return b
    return c + b
print(sum2(2,3,4)) # 2

# return语句后面可以不写返回值,这样表示函数执行到return语句到此结束,函数没有返回值.
def func2():
    print("测试return方法")
    return
    print("测试返回后的return")
func2() # 测试return方法

def func4():
    print("this is first")
def func4(a, b):
    return a+b
'''
    必须要注意，在python中同一个类中没有java的重写的这回事，后边的函数会直接覆盖前边的
    # 5.同一个文件中函数不能重名
    # 会使用后面定义的函数覆盖前面同名的函数
'''
# func4()
print(func4(1,2)) # 3

1.4 关于全局变量（global）

# 定义全局变量
a = 10
def func1():
    # 如果在函数外面没有定义变量a,这里就是在定义全局变量a
    global a # 注意需要使用global关键字声明后的a才是全局的变量，否则就不是
    a = 100
    # 打印全局变量
    print(a) # 100

def func2():
    # 打印全局变量
    print(a) # 100

func1() #100
func2() #100，可以注意到全局变量的改变

1.5 函数同时返回多个值（多个值可以包装成一个元组，返回一个元组对象）

"""
函数同时返回多个值
"""
def func1(a, b):
    res_sum = a + b
    res_avg = res_sum / 2
    res_multiply = a * b
    # 在返回之前,python解释器会自动对return后面的数据进行组包成一个元组.
    return res_sum,res_avg,res_multiply # return (s, avg, multip)

result = func1(10,20)
print(result)
print(type(result))

def func2(a, b):
    res_sum = a + b
    res_avg = res_sum / 2
    res_multiply = a * b
    return res_sum
print("测试单个值的会不会也包装成元组类型，结果不是。。。")
result2 = func2(10,20)
print(result2)
print(type(result2))

def func3(a, b):
    res_sum = a + b
    res_avg = res_sum / 2
    res_multiply = a * b
    return res_sum,res_sum #返回两个相同的变量也是可以的
result3 = func3(10,20)
print(result3)
print(type(result3))

1.6 练习Demo（正确定义一个函数、实现多个参数返回值）

def test_num(str):
    upper_count = 0
    lower_count = 0
    dig_count = 0
    other_count = 0
    for e in str:
        if e.isupper():
            upper_count += 1
        elif e.islower():
            lower_count += 1
        elif e.isdigit():
            dig_count += 1
        else:
            other_count += 1
    return upper_count, lower_count, dig_count, other_count

while True:
    str = input("请录入一个字符串：")
    if str.__eq__("no"):
        break
    res = test_num(str)
    print(res)

1.7 默认参数 func(a, b, c=20)

"""
默认参数:
    在定义函数时,给形参指定了默认的值,这个参数叫默认参数(缺省参数).
特点:
    在调用函数时,可以给它传值也可以不给它传值.
    如果传了,在执行函数时就会使用传递过去的值,如果没传就是用默认的值.
"""
def default_fun_test(a, b, c=20):
    print(a + b + c)

default_fun_test(10,20,30)
default_fun_test(10,20)

1.8 关键字参数 func(c=1,b=2)

"""
关键字参数:
    在调用函数时,根据形参的名称传递的实参叫做关键字参数.
特点:
     是根据形参的名称给形参传值的.

关键字参数只能写在实参列表的最后.
"""
def test_keyword_num(a, b, c):
    print(a + b + c)

test_keyword_num(a=10, b=20, c=30) # 60
test_keyword_num(10,20,c=30) # 60
test_keyword_num(b=20,a=10,c=30) # 60
test_keyword_num(10,20,30) # 60

'''
指定了关键字参数之后可以交换位置，指定形参对应的的值，灵活好多
'''

1.9 可变参数（一个*）

def func1():
    print("空参方法")
def func2(a):
    print(a)
def func3(a,b):
    print(a)
    print(b)
def func4(a,b,c):
    print(a)
    print(b)
    print(c)
# 像上边的的这种参数可变的方法，多次定义，浪费资源
"""
可变参数:
    在形参前面加了 一个 *,这个参数就叫可变参数(不定长参数).
    表示0个或者任意多个形参.
特点:
    1. 前面 有一个 *
    2. 表示0个或者任意多个形参

好处:
    1.可以扩展函数的功能,更加通用.

"""
def func5(* a):
    print(* a)
    print(a)
    print(type(a))
    print("======================")
    for e in a:
        print(e,end=" ")
    print()
func5()
'''
()
<class 'tuple'>
======================

'''
print("========第一个===========")
func5(1)
'''
1
(1,)
<class 'tuple'>
======================
1 
'''
print("==========第二个==============")
func5(1,2)
'''
1 2
(1, 2)
<class 'tuple'>
======================
1 2 
'''

1.10关键字参数的可变参数（两个*）

"""
关键字参数的 可变参数:
    在参数前面加 ** ,这个参数叫做 关键字参数的 可变参数.
"""
def print_arguments(a, ** kwargs):
    print(kwargs)
    print(type(kwargs))

# 如果以关键参数的形式 传递实参,而且 执行的形参名称又不存在.
# python解释器会自动把 关键参数打包成一个 字典, 然后把字典传递给带**的可变参数.
'''
特别注意：这里和前边的可变参数的区别在于这个**，打包的是一个字典，前边的*打包的是一个元组
'''
print_arguments(1,b=10,c=20)
'''
{'b': 10, 'c': 20}
<class 'dict'>
'''
print_arguments(a=1,b=10,c=20)
'''
{'b': 10, 'c': 20}
<class 'dict'>
'''

1.11 参数的混合使用

def test_mix_func(a,*args,b=20,c=30,**kwargs):
    print(a)
    print(args)
    print(b)
    print(c)
    print(kwargs)

test_mix_func(10,20,30,40,50,b=2,c=3,mm=110,nn=120)

1.12 在实参前面加*

def func1(* a, ** b):
    print(a) # ((10, 20), {'m': 10, 'n': 20})
    print(b) # {}

def func2(*args,**kwargs):
    print(args) #(10, 20)
    print(kwargs) #{'m': 10, 'n': 20}
    # 调用func1函数
    # func1(args, kwargs)
    # args是一个元组, kwargs是一个字典
    # * 元组: 对元组解包,解成 元素1 元素2
    # ** 字典: 对字典解包,解成 m=30, n=40形式的
    func1(args,kwargs) # ((10, 20), {'m': 10, 'n': 20})
'''
(10, 20)
{'m': 10, 'n': 20}
((10, 20), {'m': 10, 'n': 20})
{}
'''

func2(10,20,m=10,n=20)

1.13 自动组包、拆包

# 拆包操作
a,b=(10,20)
print(a)
print(b)

print("======================")

#
a,b = [10,20]
print(a)
print(b)

print("========================")

# 组包操作
tuple1 = 10,20
print(tuple1)

cc = 10,20
print(cc)

1.14 利用自动解包交换两个变量的值

a = 10
b = 20

# 交换两个值的常用方法1：使用一个临时变量
temp = a
a = b
b = temp
print(a) # 20
print(b) # 10

print("======================")

# 交换两个值的常用方法1：借助两个变量的和
c = a + b
a = c - a
b = c - a
print(a) # 10
print(b) # 20

print("======================")

# 利用自动拆包
a, b = b, a # a,b -> 20,10 -> a,b = (20,10) -> a=20,b=10
print(a) # 20
print(b) # 10

1.15 小数字和短字符串的对象池

"""
小数字:
    -5-256

短字符串:
    长度不超过20的字符串


在python解释器一启动的时候,就会把小数字和短字符串放到 缓冲区(小数字对象池和短字符串对象池).
"""
a = 10
b = 10

print("========小数字的对象池==========")
# 获得数据的地址: 调用id(数据)
print(id(10)) # 2071815488
print(id(a))  # 2071815488
print(id(b))  # 2071815488

print("========大数字的对象池==========")

c = 100000
d = 100000
print(id(100000)) # 17096000
print(id(c))      # 17096000
print(id(d))      # 17096000

print("=========短字符串的对象池===============")
e = "aa"
f = "aa"
print(id("aa"))  # 20385472
print(id(e))     # 20385472
print(id(f))     # 20385472

print("长字符串的对象池")
h = "hellohellohellohellohellohellohellohellohellohello"
i = "hellohellohellohellohellohellohellohellohellohello"
print(id("hellohellohellohellohellohellohellohellohellohello"))  # 59737056
print(id(h))                                                     # 59737056
print(id(i))                                                     # 59737056

1.16 可变类型与不可变类型

"""
不可变类型:

    如果改变了该类型的数据的值,地址 也发生了变化, 这种类型的数据,是不可变类型的数据.
    常见类型:
        int, float,bool, str, tuple

可变类型:

    如果改变了该类型的数据的值,地址 没有 发生了变化, 这种类型的数据,是可变类型的数据.
    常见类型:
        列表,字典,set集合
"""
print("=========测试数字的可变性============") #属于不可变类型
a = 10
print(id(a)) # 2071815488
a = 20
print(id(a)) # 2071815648

print("=========测试字符串的可变性==============") #属于不可变类型
str1 = "helloWorld"
print(id(str1)) # 12797056
str1 = "newWorld"
print(id(str1)) # 12797136

print("=========测试字典类型的可变性============")  #属于可变类型
list1 = [10,20]
print(id(list1))   # 21841400
list1.append(30)
print(list1)
print(id(list1))   # 21841400

print("=============")

1.17 参数的引用传递

"""
python中只有引用传递没有值传递.
也就是说在调用函数传递实参时,给形参传递的是实参的地址,而不是具体的数据值.
"""
def print_list(list2=[]):
    list2.append(10)
    print(id(list2))
    print(list2)

list1 = [10,20]
print(list1)       # [10, 20]
print(id(list1))   # 12601984
print("=======list2-test========")
print_list(list1)
'''
12601984
[10, 20, 10]
'''

1.18 +=与=+的区别

"""
    a += 1
	a = a + 1

这两种写法对应 不可变类型的 数据,是没有区别的.
"""
print("========测试不可变类型中的数字=========")
a = 10
print(id(a)) # 2071815488
a += 20
print(id(a)) # 2071815808

print("=======测试不可变类型类型中的字符串========")
str1 = "hello"
print(id(str1))   # 13111008
str1 += "python"
print(id(str1))   # 13321664

print("============测试可变类型的list字典==================") # 地址变了
# 只是把第二个列表中的元素放到第一个列表中,第一个列表的地址没有变,没有产生第三个列表
print("========测试list的 =+ ===========")
list1 = [10,20]
print(id(list1))   # 28526072
list1 = list1 + [30,40]
print(list1)
print(id(list1))   # 57130360

print("=============测试list的 += =======================") # 地址不变
# 是把两个列表中的元素都放到第三个列表中,产生了第三个列表,把第三个列表赋值给了list1
list2 = [10,20]
print(id(list2))   # 56511104
list2 += [30,40]
print(list2)
print(id(list2))   # 56511104

1.19 模块的基本使用

首先定义一个模块：

a = 100

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

在另一个类中使用：

"""
模块的基本使用:
    模块: 一个.py文件就是一个模块.可以在这个模块文件中定义全局变量,函数和类.

    可以把这个模块文件导入到另外一个程序文件中,然后在另外一个文件中调用模块文件中定义的
    全局变量,函数和类

导入模块:
    1.使用import关键字 导入模块
        import 模块名
        这里的模块名是指 .py文件的模块,不包含.py.

    2.通过模块名访问模块文件中内容
        模块名.全局变量
        模块名.函数名(实参1,实参2,...)
"""
# 1.使用import关键字 导入模块
import module01

# 2.通过模块名访问模块文件中内容
print(module01.a)  # 100
sum = module01.func1(10, 20)
print(sum) # 30