nlp——python学习记录(6)

今天还是继续学习了函数，还有引用相关，以及对一个案例进行了实例。

笔记如下：

# 函数续
def func(a,b,c):
    print(f'a:{a}')
    print(f'b:{b}')
    print(f'c:{c}')


# 函数传参的两种形式
# 位置传参,按照形参的位置顺序将实参的值传递给形参
func(1,2,3)
# 关键字传参,指定实参给到哪个形参，注意：关键字必须是函数的形参名
func(a=10,b=20,c=30)
func(c=10,a=20,b=5)
# 混合使用，先写位置传参，再写关键字传参
func(10,b=20,c=30)
# func(a=20,20,30)  报错！！！
# func(10,a=10,b=20)  报错！不能多有个形参值

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


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
# def fun1(a=1,b,c):  # 错误写法，缺省参数要在最后面
#    pass

# 不定长参数 *args


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


func(1,2)
print('*'*30)

# 在形参前面加上一个*，该形参变为不定长元组参数，可以接受所有位置的实参，类型是元组
# 加上**号，该形参变为不定长字典形参，可以接受所有关键字实参，类型是字典


def func(*args,**kwargs):
    print(args)
    print(kwargs)


func(1,2,3,5,8,5,6)  # 元组(1, 2, 3, 5, 8, 5, 6)
func(a=1,b=2,c=3)  # 字典{'a': 1, 'b': 2, 'c': 3}
func(1,2,3,a=5,c=9)  # 混合(1, 2, 3)  {'a': 5, 'c': 9}

# 应用：求和


def my_sum(*args,**kwargs):
    num = 0
    for i in args:
        num += i
    for j in kwargs.values():
        num += j
    print(f'求和的结果为：{num}')


my_sum(1,2,3,a=1,b=2)

# 函数形参的完整格式
# 普通形参  缺省形参  不定长元组形参  不定长字典形参


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

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


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

print(1,2,sep='*')  # sep默认用空格隔开，否则使用sep中的值隔开

# 组包，将多个数据值给到一个变量，类型是元组
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)

a,b = [10,20]  # 列表
print(a,b)
my_dict = {'name':'tct','age':18}
a,b = my_dict
print(a,b)  # 返回的是key值

# 拆包应用：交换两个变量的值
a = 10
b = 20
# 1.使用临时变量
c = a
a = b
b = c
print(a,b)
# 2. +/-
a = a + b  # a:30
b = a - b  # b:10
a = a - b  # a:20
print(a,b)
# 3.组包和拆包!!!
a,b = b,a
print(a,b)

# 引用
# 可以使用id（）查看变量的引用，
# 可以将id值认为是内存地址的别名
# python中数据值的传递传递的是引用
# 赋值运算符可以改变变量的引用
a = 10
# 将变量a中保存的引用地址给到b
b = a
print(a,b)  # 打印a，b中引用中存储的值
print(id(a),id(b))
a = 20
print(a,b)  # b的值不会改变
print(id(a),id(b))

# 都会一起随之改变，改变是在原列表中进行改变
my_list = [1,2,3]  # 列表
my_list1 = my_list
print(my_list,id(my_list))
print(my_list1,id(my_list1))

my_list.append(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))

# 类型的可变与不可变，在不改变变量引用的前提下， 能否改变变量中引用中的数据
# 如果能够改变则是可变类型，不能改变就是不可变类型
# int float bool str list tuple dict
# 不可变类型：int（需要重新开辟一块空间），float,bool,str,tuple(元组中的数据不能改变)
# 可变类型：list,dict
a = 10
b = 10
print(id(a),id(b))  # python中的内存优化，对于不可变类型进行的
# 2334561299024 2334561299024
print('*'*30)

my_list = [1,2,3]
my_list1 = [1,2,3]
print(id(my_list),id(my_list1))  # 是不同的 1458877514176 1458877952640
print('*'*30)

my_tuple = (1,2,[1,2])
print(my_tuple)
my_tuple[2][1] = 5  # 不算是修改元组数据，改变的是元组中的列表数据
print(my_tuple)

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


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


def func1():
    # 不加globa，因为没有修改my_list中存的引用值
    my_list.append(5)


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


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


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

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

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

学生管理系统案例：

# 函数应用；学生管理系统
# 增删改查操作
# 存储学生信息：姓名，年龄，班级......（使用字典存储key-value）
# 存储所有学生的信息：列表[{}，{}，{}.......]
# 给用户的功能菜单，业务框架
# 1.搭建业务框架
# 2.实现功能
# 2.1 添加学生信息，通过input函数获取学生的信息，姓名，年龄，性别
# 将学生信息转换为字典进行保存
# 将学生字典添加到列表中
# 代码优化，假设名字不能重复，在添加学生的时候进行判断，如果存在则不添加
# 3.删除/修改/查询学生信息
# 都是用 name 对学生进行判断
# 3.1 使用input获取要删除/修改/查询的学生姓名
# 3.2 判断学生信息是否存在
# 3.3 学生存在进行操作，不存在则直接结束


# 定义学生列表
stu_list = []


def show_menu():  # 功能菜单函数
    print('1.添加学生')
    print('2.删除学生')
    print('3.修改学生信息')
    print('4.查询单个学生信息')
    print('5.查询所有学生信息')
    print('6.退出系统')


def insert_stu():  # 添加学生函数
    # 输入对应的数值
    name = input('请输入学生名字：')
    # 判断姓名是否重复，判断字典中的value值是否存在，遍历，（假定名字唯一）
    for stu in stu_list:
        if stu['name'] == name:
            print('---------学生信息存在--------')
            return  # 结束函数的执行

    age = input('请输入年龄：')
    gender = input('请输入性别：')
    stu_dict = {'name':name,'age':int(age),'gender':gender}  # 将数值放入字典中
    stu_list.append(stu_dict)  # 将字典添加到列表中
    print('-------学生信息添加成功---------')


def remove_stu():  # 删除学生
    name = input('请输入要操作的学生的名字：')
    for stu in stu_list:  # 循环遍历列表，若存在于列表中，就将其删除掉，使用remove()函数
        if stu['name'] == name:
            stu_list.remove(stu)
            break
    else:
        print('-------该学生信息不存在-------')


def modify_stu():  # 修改学生信息
    name = input('请输入要操作的学生的名字：')
    for stu in stu_list:  # 遍历列表
        if stu['name'] == name:
            stu['age'] = int(input('请输入新的年龄：'))  # 进行修改
            break
    else:
        print('-------该学生信息不存在，无法修改-------')


def search_stu():  # 查找学生
    name = input('请输入要操作的学生的名字：')
    for stu in stu_list:  # 遍历
        if stu['name'] == name:
            print(f'姓名:{stu["name"]}，年龄:{stu["age"]},性别:{stu["gender"]}')  # 找到的话就将其信息输出
            break  # 记得break掉循环
    else:
        print('-------该学生信息不存在-------')


def show_all_info():  # 展示所有信息
    if len(stu_list) > 0:  # 只有当列表长度不为0时才输出相应信息
        for stu in stu_list:
            print(f'姓名:{stu["name"]}，年龄:{stu["age"]},性别:{stu["gender"]}')
            # print(stu)
    else:
        print('目前没有学生信息')


def main():  # 将整个定义成一个函数
    while True:  # 多次进行
        show_menu()
        opt = input('请输入要选择对的操作编号：')
        if opt == '1':
            insert_stu()
        elif opt == '2':
            remove_stu()
        elif opt == '3':
            modify_stu()
        elif opt == '4':
            search_stu()
        elif opt == '5':
            show_all_info()
        elif opt == '6':
            print('6.退出系统')
            break
        else:
            print('输入错误，请重新输入')
            continue

        input('.......回车键继续操作......')


main()  # 直接调用

测试题：

# 1.要求实现一段代码：
# 声明一个函数num，并且在调用函数的时候，不管输入多少个非关键字参数，函数都可以运行，且在函数内部还要把每个参数输出到屏幕上。
def num(*args):
    for i in args:
        print(i)
num(1,2,3,4,5,6)

# 2.如下所示这是一个字典，{"name":"电脑","price":7000}
# 请定义这样一个函数num，讲上述字典中的键值对传入到函数num中，要求用不定长参数来接收，并在函数中打印键值对输出
# 输出格式为：
# key: name value: 电脑
# key: price value: 700
def num(**kwargs):
    for key,value in kwargs.items():
        print('key:',key,'value:',value)
num(name='电脑',price=7000)

# 3.对于一个函数num，
# 当调用nun(1,2,a=3,b=4)和调用num(3,4,5,6,a=1)以及num(a=1,b=2)的时候都可以正常运行，
# 并且可以对元组以及字典类型进行遍历输出，对字典类型进行输出字典的键值对(形式为：key：a，value：1)，
# 请写出这个函数并完成调用。
def num(*args,**kwargs):
    for i in args:
        print(i)
    for key,value in kwargs.items():
        print('key:',key,'value:',value)
num(1,2,a=3,b=4)

昨日课程的测试题：

# 字典测试题
# 1.定义一个空字典my_dict
my_dict = {}
my_dict1 = dict()
print(my_dict)
print(my_dict1)
# 2. 定义一个字典
my_dict2 ={'name':'txt','age':18,'pi':3.14}
print(my_dict2)
# 3.打印类型
print(type(my_dict))
print(type(my_dict2))
# 4. 输出18这个数据
print(my_dict2['age'])
# 5. 求出元素个数
print(len(my_dict2))
# 6. key访问和get访问
print(my_dict2['name'])
print(my_dict2.get('name',5))
# 7.修改age的值为55
my_dict2['age'] = 55
print(my_dict2)
# 8. 添加一个元素
my_dict2['gender'] = '男'
print(my_dict2)
# 9.删除pi的键值对
my_dict2.pop('pi')
print(my_dict2)
# 10.清空给字典数据
my_dict2.clear()
print(my_dict2)
# 11.删除字典变量
del my_dict2
# 12.现在还能使用该变量吗？   不能！！！
# print(my_dict2) 会报错


# 2. 循环打印字典中的键，值，键值对
dict1 = {'name':'soobin','age':18}
for i in dict1.keys():
    print(i)
for j in dict1.values():
    print(j)
for key,value in dict1.items():
    print(key,':',value)

# 3.综合训练
product = [
    {'name':'电脑','price':7000},
    {'name':'鼠标','price':125},
    {'name':'键盘','price':250},
    {'name':'耳机','price':300},
]
# 小明有8000元能否买下所有的商品，返回能或者不能
money = 8000
my_sum = 0
for i in product:
    my_sum += i['price']
if money > my_sum:
    print('能')
else:
    print('不能')

# 函数测试题
# 1.定义一个run函数
# 2.想实现1000遍
def run():
    print('我在跑步呀')
    print('管住嘴')
for i in range(0,1000):
    run()

# 3.addnum带有返回值 7，13
def addnum(a,b):
   return a + b
result = addnum(7,13)
print(result)