【Python】Python学习笔记8

 代码笔记：

'''
函数进阶
    作用域：指变量生效的范围，分为两种（全局变量和局部变量）。
        全局变量：函数外部定义的变量，它在整个文件中都是有效的。
        局部变量：函数内部定义的变量，它从函数内部被定义开始到函数结束位置有效。
    在函数中修改全局变量，可以使用global关键字：将变量声明为全局变量。
        格式：global 变量名1,变量名2,...
    在嵌套函数中，如果内层函数要修改外层函数的变量，可以使用nonlocal关键字：将内层（本层）函数变量声明为外层（上一层）函数变量。
'''
school = '北京大学'     # 全局变量，整个文件中都有效。
def fun1():
    student = '小明'     # 局部变量，当函数调用结束后就被销毁。
    print(f'我的名字是：{student}，我就读于{school}!')
def fun2():
    student = 'Alice'   # 局部变量，当函数调用结束后就被销毁。
    dic1 = {
        school: 'Peking university',
        student: '爱丽丝'
    }
    print(f'我的名字是：{dic1[student]}，我就读于{school}!', end='\t')
    print(f'My name is {student},I`m studying in {dic1[school]}!')
fun1()      # 我的名字是：小明，我就读于北京大学!
fun2()      # 我的名字是：爱丽丝，我就读于北京大学!	My name is Alice,I`m studying in Peking university!
# print(student)  # 报错NameError: name 'student' is not defined（student没有被定义）
def fun3():
    global school           # 将局部变量school声明为全局变量
    school = '清华大学'
    student = '小红'
    print(f'我的名字是：{student}，我就读于{school}!')
fun3()          # 我的名字是：小红，我就读于清华大学!
print(school)   # 清华大学
def fun4():
    teacher = '张三'
    print(f'我是{teacher}老师，我在{school}任教。')
fun4()          # 我是张三老师，我在清华大学任教。
def role():
    role = '老师'         # 外层函数变量role
    print(f'第一种身份是：{role}',end='\\')
    def change_role():
        nonlocal role    # 将内层函数变量声明为外层函数变量
        role = '程序员'
        print(f'第二种身份是：{role}',end='\\')    # 输出内层函数变量
        def change_role1():
            role = '项目经理'       # 第三层函数变量
            print(f'第三种身份是：{role}',end='\\')
        change_role1()
    change_role()
    print(f'现在的身份是：{role}')     # 输出外层函数变量
role()      # 第一种身份是：老师\第二种身份是：程序员\第三种身份是：项目经理\现在的身份是：程序员
'''
匿名函数（lambda函数）：
    定义格式：函数名 = lambda 形参 : 返回值（表达式）
    调用格式：结果 = 函数名(实参)
    lambda函数不需要写return，因为表达式本身就是返回值。
    优点：简化简单函数的代码量。
'''
def add(a,b):       # 普通加法函数
    return a+b
print(add(3,4))            # 7
lambda_add = lambda a,b: a+b    # lambda加法函数
print(lambda_add(5,6))     # 11
'''
lambda函数的参数形式：无参数、一个参数、默认参数、可变参数、关键字参数。
    注意：默认参数必须写在非默认参数之后。
'''
lam1 = lambda  : '这是无参数的匿名函数！'
print(lam1())   # 这是无参数的匿名函数！
lam2 = lambda name : (name,'这是带一个参数的匿名函数！')
print(lam2('张三'))   # ('张三', '这是一个参数的匿名函数！')
lam3 = lambda name,age = 18: (name, age, '这是带默认参数的匿名函数！')
print(lam3('王五'),lam3('李四',20))    # ('王五', 18, '这是带默认参数的匿名函数！') ('李四', 20, '这是带默认参数的匿名函数！')
lam4 = lambda *args: args
print(lam4(4,[2,3,5],'这是带可变参数的匿名函数！'))      # (4, [2, 3, 5], '这是带可变参数的匿名函数！')
lam5 = lambda **kwargs: kwargs
print(lam5(name='赵六', age=24, str='这是带关键字参数的匿名函数！'))    # {'name': '赵六', 'age': 24, 'str': '这是带关键字参数的匿名函数！'}
'''
lambda结合if判断：
    利用三目运算：为真结果 if 判断表达式（条件） else 为假结果
'''
identify = lambda age: '注册成功！' if age>=18 else '您还未成年！'
age = 20
print(f'你的年龄是：{age},', identify(age))    # 你的年龄是：20, 注册成功！
'''
内置函数：
    查看所有内置函数：
    import builtins
    print(dir(builtins))
'''
# import builtins
# # print(dir(builtins))        # 大写字母开头一般是内置常量名，小写字母开头一般是内置函数名。
'''
常用内置函数：
    abs():返回绝对值。
    sum(可迭代对象):求和。
        注意：字符串（str）和字典（dict）不可以使用sum()函数。列表（list）、元组（tuple）、集合（set）可以使用sum()函数。
    min():求最小值。
    max():求最大值。
'''
print(abs(-400))    # 400
print(sum((123, 567)))   # 690，元组
print(sum([1, 2, 3, 567]))     # 573，列表
print(sum({2, 3, 4, 5}))       # 14，集合
print(min(2, 3, 4, 1, 0))       # 0
print(max(2, 3, 4, 1, 0))       # 4
print(min(-8, 5, key=abs))      # 5 比较绝对值小的数
print(max(-8, 5, key=abs))      # -8 比较绝对值大的数
'''
zip(可迭代对象):将可迭代对象中的数据打包成元组的形式。
    取出元素的方式：
        （1）通过for循环去除元素
        （2）强制转换成列表打印输出（注意：此时zip()中都必须是可迭代对象。）
'''
for i in zip([1, 'hello',2 ],[2,3,4]):
    print(i)    # (1, 2) ('hello', 3) (2, 4) 输出一一对应
for i in zip([1,2,3],['hello',2]):
    print(i)    # (1, 'hello') (2, 2) 如果元素个数不一致就按长度最短的返回
print(type(i))     #  <class 'tuple'>
print(list(zip([2,3,4],[3,4,5])))   # [(2, 3), (3, 4), (4, 5)]
print(list(zip([2,3,5],[3,5])))     # [(2, 3), (3, 5)]
# # print(list(zip(3,['2',3])))         # 报错TypeError: 'int' object is not iterable（整型不是可迭代对象）
'''
map()函数：可以对可迭代对象中的每一个元素进行映射，然后分别执行。
    参数解释：map(func,iter1)    func：指元素执行的（自定义）函数名；iter1：指可迭代对象。
    注意：只需要写函数名，不需要加上括号()。
    作用：使可迭代对象中的每一个元素都会去执行func（自定义）函数。
    取出元素的方式：
        （1）通过for循环去除元素
        （2）强制转换成列表打印输出
'''
num = [2, 4, 5, 6]      # 定义列表num
def single_price(x):    # x：形参
    return x * 5
print(map(single_price, num))   # <map object at 0x000002352743F190>，此时是一个map类型的对象。
for i in map(single_price, num):    # 利用for循环取出map对象中的元素
    print(i,end=' ')    # 10 20 25 30
print('\r')             # \r 换行符，将内容移到开头位置
print(list(map(single_price, num)))     # [10, 20, 25, 30]，利用强制转换为列表的形式取出map对象中的元素。
single_price1 = lambda a : a * 8        # 利用lambda函数和map()函数搭配简化简单功能的代码量。
print(list(map(single_price1,num)))     # [16, 32, 40, 48]
'''
reduce()函数：函数用于将一个序列的所有元素累计到一个单一的结果中。
    参数解释；reduce(function,sequence)  function:指必须有两个参数的函数名；sequence:必须使可迭代对象。
    作用：先将两个参数放入函数（function）运行，然后将运行结果与第三个（下一个）参数作为新的两个参数放入函数（function）运行。
    注意：
        1.reduce()函数需要导入：  from functools import reduce  从functools工具包中导入reduce函数。
        2.函数只能是两个参数的函数；
        3.reduce()中的函数只需要写函数名，不需要加上括号()。
'''
from functools import reduce        # 从functools工具包中导入reduce函数
num1 = [2, 2, 3]
fun_reduce = lambda x,y: x**y       # 求x的y次幂
print(reduce(fun_reduce,num1))   # 64；运算过程：2**3=8 --> 8**3=64
'''
拆包：指的是将可迭代对象（如列表、元组、或其他序列类型）的元素拆分开来并赋值给多个变量的操作。
    分类：
        1.基本拆包（元组拆包、列表拆包）
        2.星号拆包（*）：当不知道序列的长度时，使用星号（*）操作符来进行部分拆包。
            有两个参数：first 变量接收了列表的第一个元素，而 *rest 变量接收了剩余的所有元素组成的列表。
        3.函数拆包
        4.字典拆包
    注意：
        对于基本拆包要求接收的变量与可迭代对象中的元素个数相等。
    作用：拆包是一种非常灵活和强大的工具，常用于提高代码的可读性和简洁性。
'''
a, b, c, d = (1, 2, 3, 4)   # 基本拆包（元组拆包）
print(a, b, c, d)           # 1 2 3 4；也可单独打印。
a, *x = (1, 2, 3, 4, 5)     # 星号拆包
print(a, x, type(x))     # 1 [2, 3, 4, 5] <class 'list'>    一般在函数调用时使用
def test_fun(a, b, *args):
    print(a, b, args, type(args))
test_fun(1, 2, 3, 4, 5, 6, 7)       # 1 2 (3, 4, 5, 6, 7) <class 'tuple'>

运行结果：

我的名字是：小明，我就读于北京大学!
我的名字是：爱丽丝，我就读于北京大学!	My name is Alice,I`m studying in Peking university!
我的名字是：小红，我就读于清华大学!
清华大学
我是张三老师，我在清华大学任教。
第一种身份是：老师\第二种身份是：程序员\第三种身份是：项目经理\现在的身份是：程序员
7
11
这是无参数的匿名函数！
('张三', '这是带一个参数的匿名函数！')
('王五', 18, '这是带默认参数的匿名函数！') ('李四', 20, '这是带默认参数的匿名函数！')
(4, [2, 3, 5], '这是带可变参数的匿名函数！')
{'name': '赵六', 'age': 24, 'str': '这是带关键字参数的匿名函数！'}
你的年龄是：20, 注册成功！
400
690
573
14
0
4
5
-8
(1, 2)
('hello', 3)
(2, 4)
(1, 'hello')
(2, 2)
<class 'tuple'>
[(2, 3), (3, 4), (4, 5)]
[(2, 3), (3, 5)]
<map object at 0x000002378857C3D0>
10 20 25 30 
[10, 20, 25, 30]
[16, 32, 40, 48]
64
1 2 3 4
1 [2, 3, 4, 5] <class 'list'>
1 2 (3, 4, 5, 6, 7) <class 'tuple'>

Process finished with exit code 0