Python函数

函数

print() 在控制台输出
input() 获取控制台输入的内容
type() 获取变量的数据类型
len() 获取容器的长度(元素的个数)
range()生成一个序列[0,n)
函数可以实现一个特定的功能
我们学习自己如何定义函数，实现特定的功能
              
函数：将多行代码(可以实现一个特定的功能)放在一块，并给它起一个名字.
              在需要使用多行代码的时候，可以使用名字代替
              
定义函数的好处：减少代码冗余(重复的代码不需要多次书写)，提高编程效率

函数必须 先定义 后 调用

定义和调用

定义

1.函数定义，就是给多行代码起名字的过程
2.函数的定义需要使用 关键字 def，单词 define

def 函数名():
    函数中的代码
    函数中的代码
    
    
#1.处在def缩进中的代码 都属于这个函数
#2.函数名要满足标识符的规则，见名知意
#3.def这行代码的最后需要一个 冒号
#4.函数定义不会执行函数中的代码，想要执行，需要调用

调用

1.函数调用，就是使用多行代码的过程
2.语法 函数名()

定义函数的小技巧

1.先不使用函数，将多行代码写完
2.在多行代码的上方使用def起名字
3.使用tab键，将多行代码进行缩进

函数的文档注释

1, 函数的文档注释,本质就是注释, 只不过作用和书写位置有特定的要求
2, 作用: 是对函数的作用和使用方法进行说明, 比如 有哪些参数, 返回值是什么
3, 书写位置: 在def 的下方,使用 三对双引号来书写
-----
查看
4.1 在函数名上,使用快捷键 Ctrl q 查看
4.2 在函数名上,使用 快捷键 Ctrl B 跳转到函数定义的地方查看
4.3 在函数名上, 按住 Ctrl 键,点击函数名,跳转到函数定义的地方查看

参数

参数：在函数定义的时候，在括号中写入变量，这个变量就称为是函数的参数。形式参数(形参)
在函数调用的时候，可以给定义时候的形参传递具体的数据值，供其使用。实际参数(实参)

即：在函数调用的时候，会将函数的实参值传递给形参

好处：可以让函数更加的通用，函数中的数据值不是固定的，是调用的时候，你传递的

使用场景：判断 函数中 数据值是不是固定不变的，如果是变化的 就可以使用参数传递

注意点：目前书写的函数 如果存在形参，必须传递相同个数的实参

def sum_2_num(a,b): #a,b形参
    c = a + b
    print(c)

sum_2_num(10,20) #10,20 实参10 给a 20给b
sum_2_num(1,2)
sum_2_num(20,39)

函数的嵌套调用

在一个函数中调用另一个函数
1.代码从上到下执行的
2.函数定义不会执行函数中的代码
3.函数调用会进入函数中执行函数中的代码
4.函数中的代码执行结束，会回到调用的地方继续向下执行

#1.定义名为test01的函数，打印当前函数的名称
def test01():
    print(1)
    print('func01')
    print(2)
#2.定义名为test02的函数，打印当前函数的名称 并调用test01函数
def test02():
    print(3)
    print('func2')
    test01()
    print(4)
print(5)
test02()
print(6)#5 3 func2 1 func01 2 4 6

函数的返回值

返回值：函数执行的结果
print() --->None
input() --->键盘输入的内容，类型，字符串
type() --->变量的数据类型
len() --->容器长度

1.在一个函数中，要想返回一个数据（想要有返回值），需要使用return关键字
2.为什么返回值？在函数中可能通过各种代码，得到的数据结果，想要在函数外部使用，就需要使用返回值
3.如果函数有返回值，一般在调用的时候 会使用变量来接收(保存)返回值，以便后续使用
4.return关键字的作用
  - 将一个数据值返回到调用的地方
  - 函数遇到return会结束函数的执行
5.return关键字只能用在函数中
6.如果一个函数 没有写return，可以认为 返回值是None

#设计一个函数用于获取两个数中的较大数，数据来自于函数的参数
def get_max(a,b):
    if a > b:
        return  a
    else:
        return b
    print('我会执行吗，不会执行')# 不会

#调用
num = get_max(10,20)
print(num)

案例

1.定义名为input_username的函数，获取用户输入的用户名
2.定义名为input_password的函数，获取用户输入的密码
3.定义名为login的函数，判断获取的用户名和密码信息
4.要求当获取的用户名为：admin并且密码为123456时，输出"登录成功！",
否则提示“用户名或 密码错误!”

# 1.定义名为input_username的函数，获取用户输入的用户名
def input_username():
    """输入用户名"""
    return  input("请输入用户名:")

# 2.定义名为input_password的函数，获取用户输入的密码
def input_password():
    """输入密码"""
    return input("请输入密码：")
# 3.定义名为login的函数，判断获取的用户名和密码信息
# 4.要求当获取的用户名为：admin并且密码为123456时，输出"登录成功！", 否则提示“用户名或 密码错误!”

def login():
    """登录函数"""
    if input_username()=='admin'and input_password()=='123456':
        print("登录成功")
    else:
        print("用户名或密码错误")

login()

模块和包

模块

1.在python中，每个代码文件 都可以称为是一个模块
2.在模块中 别人书写好的功能（变量，函数，类），我们可以拿来直接用
3.我们自己写的代码文件，想要作为模块让别人使用，你的代码文件名（模块名）满足标识符的规则
4.想要使用  别人模块中写好的功能，需要先导入别人写好的功能
5.as关键字，可以给模块或者功能起别名

模块导入的方法

方式一

import 模块名 #模块名 就是代码文件名，不要.py
# 使用其中的功能
模块名.功能名  #功能可以是变量，函数和类
#多用于 导入系统中的常用的模块和功能

方式二

from 模块名 import 功能名 #导入指定的功能
#使用
功能名()

#方式二 多用于导入自己写书的，或者是第三方的模块
#可以使用快捷键Alt 回车

from random import randint

num=randint(1,10)
print(num)

练习

1.定义一个模块tools.py，在模块中定义一个函数 sum_2_num ，可以对两个数字求和
2.新定义一个代码文件，调用tools.py文件中的sum_2_num函数，对10和20求和

• tools.py

def sum_2_num(a,b):
    """求和函数"""
    return  a+b

• xx.py

# import tools
# print(tools.sum_2_num(10,20))

from tools import sum_2_num
print(sum_2_num(10,20))

__name__变量

1.导入模块的时候，会执行模块中的代码
2.作用：如果在导入模块的时候，模块中的部分代码不想被执行，可以使用__name__来解决
3.__name__变量，是python 解释器内置的变量(变量的值是自动维护的)，每个代码文件中都有这个变量
3.1 在模块中，直接右键运行代码文件，__name__变量的值'__main__'
3.2 如果是被导入运行代码文件，__name__变量的值 是模块名(文件名)

if __name__== '__main__':
    #在这个if的缩进中书写的代码，导入的时候不会被执行

模块的导入顺序

1.在导入模块的时候，会先从代码所在的目录进行导入
2.如果没有找到，会去python系统的目录查找导入
3.如果没有找到，报错
------------
注意点：我们自己定义的代码文件名字 不要和你导入的系统的模块文件名一样

包（package）

包：将多个模块放在一个目录中集中管理，并在这个目录中创建
一个 __init__.py文件（可以什么都不写），就是一个包

包的创建

包的导入

# 方式一
import 包名.模块名
#使用
包名.模块名.工具名

#方式二
from 包名 import 模块名
#使用
模块名.工具名

#方式三
from 包名.模块名 import 工具名
#直接使用工具名
工具名

案例

• login_service.py

  def input_username():
      """输入用户名"""
      return input("请输入用户名:")
  
  def input_password():
      """输入密码"""
      return input("请输入密码:")
  
  def input_code():
      """输入验证码"""
      return input("请输入验证码:")
  
  def login():
         username=input_username()
         password=input_password()
         code=input_code()
         if code=='8888':
            if username=='admin'and password=='123456':
                print('登录成功')
            else:
                print('登录失败')
         else:
             print('验证码错误')
  

• test_login.py

from service import login_service

login_service.login()

变量的进阶

引用

1.定义变量的时候，变量和数据 都会在内存开辟空间
2.变量所对应的内存空间中存储的是 数据所在内存的地址(平时理解为 将数据储存到变量中即可)
3.变量中保存数据的地址，就称为是引用
4.python中所有的数据的传递，传递的都是引用(即地址)
5.赋值运算符(=)，会改变变量的引用，即只有 = 可以修改变量的引用
6.可以使用id（变量）函数，查看变量的引用

可变类型与不可变类型

根据内存中的数据是否允许修改，将数据类型分为可变类型与不可变类型
简单理解：不适用等号，能不能修改数据值
可变类型：可以修改
- 列表（list） list.append()
- 字典(dict)  dict.pop()
- 集合（set）
不可变类型：不允许修改
- 数字类型(int,float,bool)
- 字符串(str)
- 元组(tuple)

my_tuple=(1,2,[10,20])#元组中 储存的1的地址，2 的地址 列表的地址
print(my_tuple,id(my_tuple),id(my_tuple[-1]),id(my_tuple[-1][-1]))
my_tuple[-1][-1]=30 #修改列表中最后一个位置的引用
print(my_tuple,id(my_tuple),id(my_tuple[-1]),id(my_tuple[-1][-1]))

局部变量和全局变量

根据变量定义的位置将变量分为局部变量和全局变量

局部变量

1.在函数内部定义的变量，称为是局部变量
2.特点
- 2.1 局部变量，只能在当前函数内部使用
- 2.2 可以在不同函数内定义名字相同的局部变量
3.生命周期（使用范围）
- 3.1在函数执行（调用）的时候被创建
- 3.2函数执行结束被销毁(删除)
4.形参可以认为是局部变量
5.如果想要在函数外部使用局部变量的值，使用return返回

def func1():
    num =10 #局部变量
    print(num)

def func2():
    num=20
    print(num)

if __name__ == '__main__':
    func1() # 10
    func2() # 20
    func1() # 10

全局变量

1.在函数外部定义的变量
2.特点
  -2.1 全局变量 可以在任意函数内访问（读取）
  -2.2 想要在函数内部修改全局变量的引用，需要使用global 关键字声明（使用global关键字
可以声明为全局变量）
3.生命周期
- 执行代码的时候 创建，执行结束销毁

#定义全局变量
g_num =10
def func1():
    print(g_num)#使用全局变量

def func2():
    g_num=20 #定义局部变量
    print(g_num)

def func3():
    global g_num #声明为全局变量
    g_num=30
    print(g_num)

if __name__ == '__main__':
    print(g_num) # 10
    func1() # 10
    func2() #20
    func1() # 10
    print(g_num) #10
    func3() #30 修改了全局变量，将全局变量的值改为30了

    func1()# 30
    g_num=100
    func1() # 100修改全局变量的值
    func2() #20 局部变量
    func3() #30
    func1() #30

def func1():
    list1.append(10)

def func2():
    list1 = [1,1]#定义局部变量，不影响全局变量
    list1.append(0)

def func3():
    global  list1 # 全局变量
    list1.pop() # 删除最后一个数据

def func5():
    list1.pop()# 用的全局变量，没用改引用

def func4():
    global  list1 #全局变量
    list1=[1]

if __name__ == '__main__':
    list1=[1,2]
    func1()
    print(list1) #[1, 2, 10]
    func2()
    print(list1) #[1, 2, 10]
    func3()
    print(list1) # [1, 2]
    func5()
    print(list1) #[1]
    func4()
    print(list1)  # [1]

函数进阶

函数返回多个数据值

return 关键字两个作用：
1.返回数据值
2.结束函数的运行
函数中如果想要返回多个数据值，一般是组成元组进行返回

def calc(a,b):
    """返回两个数的和及差"""
    return a+b ,a-b

result=calc(10,20)
print(result)

函数传参的方式

是指如何 将实参的值传递给形参

位置传参

在函数调用的时候按照 形参的顺序将实参的值传递给形参

关键字传参

在函数调用的时候，指定将实参传递给哪个形参

混合使用

1.位置参数必须写在关键字参数的前边，关键词参数必须放在位置参数的后边
2.同一个形参只能接收一个实参值(不能既使用位置传参和关键字传参给同一个形参传参)

def calc(a,b):
    """返回两个数的和及差"""
    return a+b ,a-b

result=calc(10,20)
print(result)

缺省参数(默认参数)

• 定义

在函数定义的时候，给形参一个默认的数据值，这个参数就是缺省参数（默认参数）

• 特点

在函数调用的时候，缺省参数可以不用传递实参值
1.如果不传实参值，使用的就是默认值
2.如果传递实参值，使用的就是传递的实参值

• 注意点

缺省参数 必须写在普通参数的后边

• 代码

"""
定义show_info 参数 姓名，年龄，性别
将年龄设置为默认参数18 性别设置为默认保密
"""
def show_info(name,age=18,sex='保密'):
    print(name,age,sex)

#调用

show_info('张三',18,'男')
#李四
show_info('李四')

#王五
show_info('王五',19)
#赵六 男
show_info('赵六',sex='男')

多值参数(可变参数/不定长参数)

1.在函数定义的时候，不确定在调用的时候，实参有多少个，此时可以使用 多值参数
2.在普通的参数前边加上一个*,这个参数就变为了 多值参数
3.这个参数可以接收任意多个位置传参的数据，类型 元组
4.这个形参一般写作 args(arguments), 即*args

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

• 参数顺序

# 普通，缺省，多值
def 函数名(普通，*args,缺省):
	pass

• 代码

def func(*args):
    print(args)

func()# ()
func(1,2,3)#(1, 2, 3)

• 练习

#定义一个函数，my_sum 作用 可以对任意多个数字进行求和计算

#定义一个函数，my_sum 作用 可以对任意多个数字进行求和计算

def my_sum(*args):#args 是元组
    num=0
    for i in args:
        num+=i
    return num

print(my_sum())#0
print(my_sum(1))#1
print(my_sum(1,2))#3
print(my_sum(1,2,3))#6
my_tuple=(1,2,3,4,5)
#需求对 元组中的所有数据使用my_sum进行求和
#想要把列表(元组)中的数据作为位置传参进行传递，只需要在列表（元组）前边加上一个* 进行拆包即可
print(my_sum(*my_tuple))#15

匿名函数

匿名函数：使用lambda 关键字 定义的表达式，称为匿名函数.

• 语法

lambda 参数，参数：一行代码 #只能实现简单的功能，只能写一行代码
#匿名函数 一般不直接使用，作为函数的参数使用的

• 代码

• 练习

#1.定义匿名函数，参数为两个整数数字，求两个数字的乘积
lambda a,b:a*b
#2.定义匿名函数，参数为一个字典，返回 字典中 键为age的值

lambda x:x.get('age')
lambda x:x['age']

• 匿名函数的应用

user_list=[
    {'name':'张三' ,'age':22,'title':'测试工程师'},
    {'name': '李四', 'age': 24, 'title': '开发工程师'},
    {'name': '王五', 'age': 21, 'title': '测试工程师'}

]

#user_list.sort() #只能对数字，字符串排序
# 根据字典的 age键排序
# 想要对列表中的字典排序，需要key形参来执行根据字典中的什么键排序
#key 这个参数需要传递一个函数，使用匿名函数
#列表.sort(key=lambda x:x['键'])
def func(x):
    return x['age']

user_list.sort(key=lambda x:x['age'])
#user_list.sort(key=func)
print(user_list)

案例

#定义一个列表，保存所有学生信息
#stu_list = []
stu_list =[
    {'name':"aa","age":'11'},
    {'name': "bb", "age": '22'},
    {'name': "cc", "age": '33'},
]

def make_student():
    """录入单个学生信息"""
    name=input('请输入姓名:')
    age=input('请输入年龄:')
    #将学生信息存入字典
    stu_dict={"name":name,"age":age}
    # 返回单个学生信息
    return stu_dict

def show_stu_info():
    """展示学生信息"""
    print('________学生列表信息_________')
    j=1 #初始序号
    for stu_dict in stu_list:# stu_dict 字典
        print(f"{j}\t\t{stu_dict.get('name')}\t\t{stu_dict.get('age')}")
        j += 1 #修改序号
        print('---------------------------')

def get_student_counts():
        """获取学生的数量"""
        return len(stu_list)

def search_student():
        """获取学生的信息"""
        name=input("请输入要查询的学生姓名:")
        for stu_dict in stu_list:
            if name==stu_dict.get('name'):
                #找到了这个学生
                print(f"姓名:{name},年龄:{stu_dict.get('age')}")
                #终止
                return #结束函数的执行

        #写在循环的外边
        print(f"对不起,名字叫{name}的学生不存在")

if __name__ == '__main__':
    #录入三个学生信息
    for i in range(3):
        stu=make_student()
        #需要将单个学生添加到列表
        stu_list.append(stu)
    print(stu_list)


    # 展示学生信息
    # show_stu_info()
    # 获取学生数量
    # print('学生总数为:',get_student_counts())
    # search_student()