python~变量 & 函数2

1. 变量

1.1 变量的引用

定义变量时，变量和数据都会在内存开辟空间，变量引用数据，变量中保存数据的地址就是引用
python中所有数据的传递，传递的都是引用，即地址，只有 = 可以修改变量的引用，可以使用id(变量),查看变量的引用

a = 1
b = a
print(f"a:{a},{id(a)}") # a:1,140724563624872
print(f"b:{b},{id(b)}") # b:1,140724563624872
a = 2  #将数据2的地址保存到a中，只改变了a的引用，b的引用没有改变
print(f"a:{a},{id(a)}") # a:2,140724563624904
print(f"b:{b},{id(b)}") # b:1,140724563624872

list = [1,2,3]
list1 = list
print(f"list:{list},{id(list)}") # list:[1, 2, 3],2107156114944
print(f"list1:{list1},{id(list1)}") # list1:[1, 2, 3],2107156114944
list[1] = 100  #此时list与list1都引用了同一个列表，修改列表中的元素，a和b都会受影响
print(f"list:{list},{id(list)}") # list:[1, 100, 3],2107156114944
print(f"list1:{list1},{id(list1)}") # list1:[1, 100, 3],2107156114944

1.2 可变类型与不可变类型

根据内存中的数据是否允许修改,将数据类型分为可变类型与不可变类型
简单理解: 不使用等号,能不能修改数据值
可变类型: 可以修改

• 列表(list)-------list.append()
• 字典(dict ) ----dict.pop()
• 集合(set)
  不可变类型: 不允许修改
• 数字类型(int , float , bool)
• 字符串(str)
• 元组(tuple)

1.3局部变量与全局变量

全局变量：在函数外部定义的变量，在函数内外都可以使用
局部变量：在函数内部定义的变量，只能在函数内部使用
想要在函数内部修改全局变量的引用,需要使用 global 关键字声明(使用 global 关键字可以声明为全局变量)
如果在函数内部出现和全局变量名字相同的局部变量,在函数内部使用的是局部变量

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)
    func1()
    func2()
    func1()
    print(g_num)
    func3()
    func1()
    g_num = 100
    func1()
    func2()
    func3()
    func1()

运行结果：10 10 20 10 10 30 30 100 20 30 30

2.函数进阶

2.1 函数返回多个数据值

函数返回多个数据值，一般是组成元组进行返回

#函数如何返回多个值
def calc(a,b):
    return a+b,a-b,a*b,a/b

result = calc(10,5)
print(result) # (15, 5, 50, 2.0)

2.2 函数传参的方式

位置传参，关键字传参，混合传参

def func1(name,age):
    print(name,age)

#位置传参：按照函数定义的参数顺序，依次传递参数
func1('张三',18)

#关键字传参：按照参数名传递参数，不要求顺序
func1(age=18,name='张三')

#混合传参：位置传参和关键字传参混合使用
func1('张三',age=18)

2.3 缺省参数（默认参数）

在函数定义时，为参数指定一个默认值，这个参数就是缺省参数
调用函数时如果不传递该参数，就使用默认值
缺省参数必须写在 普通参数的后边

def func1(name,age=18,sex='保密'):
    print(name,age,sex)

#普通调用
func1('张三',18,'男')

#缺省参数调用
func1('张三')
func1('李四',20)
func1('王五',sex='男')

2.4多值参数

多值参数在不确定调用的时候实参有多少个时使用
在普通参数前加一个*，可以接收多个位置传参的数据，类型是元组
这个形参一般写作 args(arguments), 即 *args

def func(*args):
    print(args)

func()
func(10,20,30)

小练习：
定义一个函数，可以对任意多个数字进行求和

def my_sum(*args):
    sum = 0
    for i in args:
        sum += i
    print(sum)

my_sum(10,20,30,40,50)

my_tuple = (1,2,3,4,5)
#想要把列表或元组中的元素，作为位置参数传递给函数，只需要在列表或元组前加一个*，进行拆包
my_sum(*my_tuple)

2.5 匿名函数

使用 lambda关键字，只能实现简单的功能，写一行代码，一般不直接调用，作为函数的参数使用

语法：lambda 参数, 参数: 一行代码

匿名函数的应用：对列表中的字典进行排序

func = lambda a,b: a + b
print(func(1,2))

print('----排序----')

#匿名函数的应用：对列表中的字典进行排序
user_list = [
    {'name':'张三', 'age':20, 'title':'测试工程师'},
    {'name':'李四', 'age':24, 'title':'测试开发工程师'},
    {'name':'王五', 'age':19, 'title':'测试工程师'},
]
#如果直接用user_list.sort()会报错，只能对数字或者字符串进行排序
#根据字典中的age键排序：

#用匿名函数：
user_list.sort(key = lambda x:x['age'])
print(user_list)

#用普通函数：
def func(x):
    return x['age']
user_list.sort(key = func)
print(user_list)

3.小案例

1. 录入学生信息
2. 展示学生信息列表
3. 计算学生总数
4. 查询学生信息

stu_list = []

def make_student():
    """输入学生信息"""
    name = input('请输入姓名：')
    age = int(input('请输入年龄：'))
    stu_dict={'name':name,'age':age}
    return stu_dict

def show_info():
    """显示学生信息"""
    print('-----学生列表信息-----')
    for student in stu_list:
        count = 1
        print(f'{count}'+'\t\t'+student['name']+'\t\t'+str(student['age']))
        count += 1
    print('--------------------')

def stu_count():
    count = len(stu_list)
    print(f'当前列表中有{count}人')

def search_student():
    names = input('请输入要查询的姓名：')
    for stu2 in stu_list:
        if names == stu2['name']:
            print(f'姓名：{stu2['name']}, 年龄：{stu2['age']}')
            return
    print('查无此人')

if __name__ == '__main__':
    for i in range(3):
        stu = make_student()
        stu_list.append(stu)

    show_info()
    stu_count()
    search_student()