DAY-04课堂笔记

函数

print() 在控制台输出
input() 获取控制台输⼊的内容
type() 获取变量的数据类型
len() 获取容器的⻓度 (元素的个数)
range() ⽣成⼀个序列[0, n)
#函数可以实现⼀个特定的功能

我们学习⾃⼰如何定义函数, 实现特定的功能 ???

函数: 将多⾏代码(可以实现⼀个特定的功能)放在⼀块,并给它起 ⼀个名字. 在需要使⽤多⾏代码的时候, 可以使⽤名字代替.

定义函数的好处: 减少代码冗余(重复的代码不需要多次书写),提 ⾼编程效率

函数必须 先定义 后 调⽤

定义和调用

定义：

def 函数名():
    函数封装的代码
    ……

1. def 是英文 define 的缩写
2. 处在 def 缩进中的代码 都属于这个函数
3. 函数名最好能够表达函数内部封装的代码的功能, 方便后续的获取调用[见名知意]
4. 函数名命名遵循标识符命名规则: 字母, 数字, 下划线, 不能以数字开头, 不用使用系统关键字
5. def 这⾏代码的最后需要⼀个 冒号
6. 函数定义  不会执⾏函数中的代码,想要执⾏,需要调⽤

调用:

1. 只定义函数, 不调用函数, 函数永远不会被执行
2. 不能将 函数调用 放在 函数定义 的上方，否则将会出现错误

函数名()

演练：

#需求：
#1. 编写一个打招呼 say_hello 的函数，封装三行打招呼的代码
#2. 在函数下方调用打招呼的代码
def say_hello():
    print("hello")
    print("hello")
    print("hello")
    
say_hello()

函数的文档注释

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

函数参数的使用

参数: 在函数定义的时候,在括号中写⼊变量,这个变量就称为是函数的参数. 
形式参数(形参)在函数调⽤的时候,可以给定义时候的形参传递具体的数据值,供其使⽤. 
实际参数(实参)即: 在函数调⽤的时候,会将函数的实参值传递给形参.
好处: 可以让函数更加的通⽤, 函数中的数据值不是固定的,是调⽤的时候,你传递的.
使⽤场景: 判断 函数中 数据值是不是固定不变的, 如果是变化的,就可以使⽤参数传递
注意点: ⽬前书写的函数, 如果存在形参,必须传递相同个数的实参.

def sun_2_num(a, b): # a, b 形参
 c = a + b
 print(c)
sun_2_num(10, 20) # 10, 20 实参 10 给 a, 20 给 b
sun_2_num(1, 2)
sun_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 1 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    #函数代码遇到return，函数结束
    print('我会执⾏吗, 不会执⾏')    #不会执行



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

案例 -函数嵌套调用

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

def input_username():
    username = input("请输入用户名：")
    return (username)


def input_password():
    password = input("请输入密码：")
    return (password)


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


login()

模块和包

模块

1, 在Python 中, 每个代码⽂件 都可以称为是⼀个模块
2, 在模块中 别⼈书写好的功能(变量, 函数, 类),我们可以拿来直接使⽤
3, 我们⾃⼰写的代码⽂件, 想要作为模块让别⼈使⽤, 你的代码⽂件名(模块名) 满⾜标识符的规则
4, 想要使⽤ 别⼈模块中写好的功能,需要先导⼊别⼈写好的功能
5, as 关键字 , 可以给模块或者功能起别名  #from tools import sum2_num as su2  在下面就可以用su2代替

模块导⼊的⽅法

⽅式⼀

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

import random


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

⽅式⼆

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 求和

#tolls.py
def sum2_num(a,b):
    """求a+b的和"""
    return (a+b)

#新定义⼀个代码⽂件
from tools import sum2_num

print(sum2_num(10,20))

__ name__ 属性

1, 导⼊模块的时候, 会执⾏模块中的代码
2, 作⽤: 如果在导⼊模块的时候, 模块中的部分代码不想被执⾏, 可以使⽤ __name__ 来解决
3, __name__ 变量,是 Python 解释器内置的变量(变量的值是⾃动维护的), 每个代码⽂件中,都有这个变量
 当被其他模块导入后运行时, __name__ 属性值为 模块名
 当在模块内运行时, __name__ 属性值为 __main__

快捷键：main 

# tolls.py
def sum2_num(a, b):
    """求a+b的和"""
    return (a + b)


print(f"myname is {__name__}")      # 在模块和包.py执行时myname is tools
if __name__ == '__main__':
    # 在这个 if 的缩进中书写的代码,导⼊的时候不会被执⾏
    print(f"myname id {__name__}")   #myname is __main__
    print(sum2_num(100, 200))        #300

#模块和包.py
from tools import sum2_num

print(sum2_num(10,20))

快捷键:main

模块的导⼊顺序

1, 在导⼊模块的时候, 会先从代码所在的⽬录进⾏导⼊
2, 如果没有找到,会去 Python 系统的⽬录查找导⼊
3, 如果没有找到, 报错
----------------------------------------------------
注意点: 我们⾃⼰定义的代码⽂件名字 不要和你导⼊的系统的模
块⽂件名⼀样

包

包: 将多个模块放在⼀个⽬录中集中管理, 
    并在这个⽬录中创建⼀个 __init__.py ⽂件(可以什么都不写), 就是⼀个包

包的创建

工程根目录上鼠标右键 -> New -> Python Package

包的导⼊

# ⽅式⼀
import 包名.模块名
# 使⽤
包名.模块名.⼯具名


# ⽅式⼆
from 包名 import 模块名
# 使⽤
模块名.⼯具名


# ⽅式三, 使⽤快捷键导包
from 包名.模块名 import ⼯具名
# 直接使⽤⼯具名
⼯具名

包操作案例

案例一：需求

1. 新建一个 hm_message 的 包
2. 在目录下，新建两个文件 send_message 和 receive_message
3. 在 send_message 文件中定义一个 send 函数
4. 在 receive_message 文件中定义一个 receive 函数
5. 在外部定义一个 test_message 文件，编写测试代码调用发消息和收消息的函数

代码实现：

#send_message.py
def send():
    print("发送消息")

#receive_message.py
def receive():
    print("接收消息")

#test_message.py
from hm_message.send_message import send
from hm_message.receive_message import receive as  re

send()
re()

案例二 需求

1. 模拟开发人员实现登录功能，定义一个函数能够接收用户输入的用户名、密码、验证码，根据不同的测试数据返回不同的验证结果
2. 已知正确的登录信息（用户名：admin、密码：123456、验证码：8888）
3. 要求1：创建login_service.py模块开发登录功能代码，并存放到service包中
4. 要求2：创建test_login.py模块开发测试代码，并存放到script包中
5. 要求3：至少测试3种测试场景

答案一(自己写的)

#test_login.py
def login():
    name = input("请输入用户名：")
    pwd = input("请输入密码：")
    code = input("请输入验证码：")
    return [name, pwd, code]

#login_service.py
from script.test_login import login

test = login()
name, pwd, code = test

if code == "8888":
    if name == "admin" and pwd == "123456":
        print("登录成功！")
    else:
        print("用户名账号错误")
else:
    print("验证码错误")

答案二（老师的）

#test_login.py
from service.login_service import login

login("admin","123456","8888")
login("root","123456","8888")
login("admin","123456","1234")
login("admin","112233","8888")

#login_service.py
def login(username,password,code)
    if code == "8888":
        if username == "admin" and password == "123456":
            print("登录成功！")
        else:
            print("用户名账号错误")
    else:
        print("验证码错误")

DAY-05课堂笔记

变量进阶

变量的进阶
- 引用 -- 变量 = 数据值 本质(了解)
- 可变类型与不可变类型(记住)
- 局部变量和全局变量(理解掌握特点)

range(n) #---> [0, n)
range(start, end, step) #---> [start, end) 步长是 step,默认 1
        
range(1, 5, 2) # [1, 3]
range(1, 101)  # 1-100

引用的概念

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

a = 1                        # 本质: 将数据 1 的地址保存到变量 a 中, 通常理解: 将 1 保存到 a
b = a                        # 本质: 将 变量 a中的引用保存到变量 b中.  通常理解 将 a 的值给 b
print(f"a: {a}, {id(a)}")
print(f"b: {b}, {id(b)}")
a = 2                        # 本质: 将数据 2 的地址保存到变量a中, 只是改变 a的引用,即改变 a的值, 没有改变 b 的引用
print(f"a: {a}, {id(a)}")    # 2
print(f"b: {b}, {id(b)}")    # 1

my_list = [1, 2, 3]
my_list1 = my_list
print(f'my_list :{my_list}, {id(my_list)}')
print(f'my_list1:{my_list1}, {id(my_list1)}')
my_list[1] = 10  # 修改 列表my_list 中下标为 1 位置的引用
print(f'my_list :{my_list}, {id(my_list)}')  # [1, 10, 3]
print(f'my_list1:{my_list1}, {id(my_list1)}')  # [1, 10, 3]

可变类型与不可变类型[记住]

根据内存中的数据是否允许修改,将数据类型分为可变类型与不可变类型
简单理解: 不使用等号,能不能修改数据值
可变类型: 可以修改
- 列表(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 关键字可以声明为全局变
量)
- 2.3 如果在函数内部出现和全局变量名字相同的局部变量,在函数内部使用的是局部变量
3, 生命周期
- 代码执行的时候 创建, 执行结束销毁

函数中变量获取顺序:
1. 首先查找函数内部是否存在指定名称的局部变量, 如果有直接使用
2. 内部如果没有, 则查找函数外部是否存在指定名称的全局变量, 如果有直接使用
3. 如果还没有, 则程序报错

# 定义全局变量
g_num = 10


def func_1():
    print(g_num)  # 使用全局变量


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


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


if __name__ == '__main__':
    print(g_num)  # 10
    func_1()  # 10
    func_2()  # 20
    func_1()  # 10
    print(g_num)  # 10
    func_3()  # 30 修改了全局变量, 将全局变量的值改为30 了

    func_1()  # 30
    g_num = 100
    func_1()  # 100 修改全局变量的值
    func_2()  # 20 局部变量
    func_3()  # 30  修改了全局变量, 将全局变量的值改为30 了
    func_1()  # 30

综合应用：<仔细看-列表>

def func1():
list1.append(10)


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


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


def func_5():
list1.pop() # 用的全局变量,没有改引用


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



if __name__ == '__main__':
    list1 = [1, 2]
    func1()
    print(list1) # ①[1, 2] ②[1, 2, 10](√) ③报错
    func2()
    print(list1) # ① [1, 1, 0] ②[1, 2, 10](√) ③报错
    func3()
    print(list1) # [1, 2]
    # func_5()
    # print(list1) # ②[1, 2] ①[1]对
    func4()
    print(list1) # [1]

函数进阶

函数的进阶
- 函数返回多个数据
- 默认参数,缺省参数(形参)
- 不定长参数,可变参数,多值参数(形参)
- 匿名函数(lambda 关键字)

函数返回多个数据

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

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


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

函数传参的方式

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

位置传参

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

关键字传参

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

混合传参

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

def show_info(name, age):
    print(f"name:{name}, age: {age}")


# 位置传参
show_info('小明', 18)
# 关键字传参
show_info(age=18, name='张三')
# 混合使用
show_info('李四', age=17)  #位置参数必须写在关键字参数的前边
show_info(name='李四', 17)  #错

标签：__,03,函数,num,print,def,name	

From： https://www.cnblogs.com/xcq-bj/p/18308329