day10-函数以及作用域

最新推荐文章于 2024-07-24 23:49:50 发布
最新推荐文章于 2024-07-24 23:49:50 发布
阅读量68 收藏
点赞数
文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46137199/article/details/116666475
版权

day10

总结

1. 函数

  • 位置参数和关键字参数(根据实参的提供的不同将实参分为位置参数和关键字参数)

    """
1) 位置参数：调用函数的时候让实参和形参在位置上一一对应
2) 关键字参数：调用函数的时候以’形参名=值‘的形式确定形参对应的实参。
3) 位置关键字和关键字参数混用： 位置参数必须在关键字参数前面，必须保证每个参数都会有一次赋值
"""


def func1(x, y, z):
    print(f'x:{x},y:{y},z:{z}')


# 位置参数
func1(10, 20, 30)  # x:10,y:20,z:30

# 关键字参数
func1(x=10, z=20, y=30)  # x:10,y:30,z:20
func1(20, z=100, y=200)  # x:20,y:200,z:100


# func1(x=100, 20, z=400)     # SyntaxError: positional argument follows keyword argument

  • 参数默认值 - 定义函数的时候可以直接在形参后面用=给形参赋默认值

    # 有默认值的参数在调用的时候可以不用传参
# 如果有的参数有默认值有的没有，有默认值的参数必须放在没有默认值的后面
# def func3(x=100, y):        # SyntaxError: non-default argument follows default argument
#     print(f'x:{x}, y:{y}')


def func2(x, y, z=100, i=200, j=400):
    print(f"x:{x}, y:{y}, z:{z}, j:{j}, i:{i}")


func2(10, 40)  # x:10, y:40, z:100, j:400, i:200
func2(10, 30, i=1000)  # x:10, y:30, z:100, j:400, i:1000
print(10, 20, end='\n', sep=',')  # 10,20

  • 参数类型说明 - 仅对参数类型进行说明，不做约束

    # 无默认值参数的类型说明   -   形参:  类型名-例如：int
# 有默认值的参数，默认值的类型就是参数对应的类型
def func4(x: str, y=1) -> None:
    pass
    print(f'str:{x}, y:{y}')


func4([1, 2, 3], 2)  # str:[1, 2, 3], y:2

  • 不定长参数

    """
1) 带*的不定长参数：在某个形参前加*,那么这个形参就是一个不定长形参,它可以接收任意多个实参
                  带*的本质就是一个元组，对应的实参是元组中的元素
    注意：带*的不定长参数对应的实参必须用位置参数传参,
    带*号前传入参数只能用位置参数，带*号后传入传入参数只能用关键字参数，所以默认不带默认值的形参放在带*号的形参前，有默认的形参写在带*号的形参之后

2) 带**的不定长参数：在某个形参前加**，那么这个形参就是一个不定长参数，它可以接受任意多个数的参数
    带**的参数本质就是一个字典，对应的关键字参数就是字典中的键值对
    注意：**的不定长参数对应的参数必须用关键字传参
"""
# 定长参数在*的不定长参数前，定长和不定长都适用于位置参数传参


def func5(y=10, *x, z):
    pass
    print(f'y:{y}, x:{x}, z:{z}, type(x):{type(x)}')


# func5(x=(100, 30))      # TypeError: func5() got an unexpected keyword argument 'x'
# func5()
func5(19, 38, 25, 100, 2343, z=10)      # y:19, x:(38, 25, 100, 2343), z:10, type(x):<class 'tuple'>
# func5(19, 38, 25, 100, 2343, z=10, y=120)   # TypeError: func5() got multiple values for argument 'y'
# func5(19, 38, 25, 100, 2343, 10)        # TypeError: func5() missing 1 required keyword-only argument: 'z'


def func6(z, *x):
    print(f'z:{z}, x:{x}')


def func7(x, y, z=10):
    print(f"x:{x}, y:{y}, z:{z}")


print('===================================================')


# 3) **的使用
def func9(**x):
    pass
    print(f"x:{x}")


func9(x=10, a=10, b=12)     # x:{'x': 10, 'a': 10, 'b': 12}


# 4) 定长参数在**的不定长前，定长既可以用位置参数也可以用关键字参数
def func10(x, **y,):
    pass
    print(f"x:{x}, y:{y}")


func10(x=2, a=10)       # x:2, y:{'a': 10}
func10(2, a=10)         # x:2, y:{'a': 10}


# 5) 定长参数不能放在**的不定长参数后面
# def func11(**y, *y):        # SyntaxError: invalid syntax
#     pass


# 6) 带*的不定长参数和带**的不定长参数可以一起使用，带*的必须放在带**的前面
def func11(*args, **kwargs):
    pass
    print(args, kwargs)


func11()    # () {}
func11(1, 2, 3)     # (1, 2, 3) {}
func11(a=10)        # () {'a': 10}

  • 返回值(返回值的作用就是将函数内部的数据传递到函数外部)

    # 在函数体中用return关键字来返回返回值（一个函数只有一个返回值)
# 什么时候需要返回值；如果函数的功能产生了新的数据，将新的数据返回


def sum2(num1=0, num2=0):
    return num2 + num1

  • 字母确定函数返回值 - 怎么将函数内部的数据传递到外部

  • 怎么获取函数返回值

    # 获取函数调用表达式的值就是获取函数返回值
# 函数调用表达值   -   调用函数的语句
# 函数调用表达式的值就是函数返回值，函数返回值能做的事，函数表达式都可以做
result = sum2(10, 30)  # 40
print(result)
print(sum2(10, 20))  # 30
a = result + 10
a = sum2(10, 30) + 10


def func1():
    return [10, 20]


print([10, 20][-1])  # 20
print(func1()[-1])  # 20
list1 = func1()
list1.append('hello')
list1.insert(0, 'hhhh')
list1.extend([10, 20, 30])
del list1[0]
list1.remove('hello')
list1.pop(3)
list1[0] = 100
print(list1)  # [100, 20, 10, 30]


def func2():
    return 10, 20


for x in func2():
    print(x)
print(len(func2()))
print(max(func2()))

  • 函数调用过程

    """
第一步：回到函数定义的位置
第二步：传参（用实参给形参赋值，这个时候要保证每个参数都有值）
第三步：执行函数体
第四步：执行完函数体，确认返回值
    （看执行函数体的时候有没有遇到returnj, 如果遇到return，return后面的值是什么，函数的返回值就是什么，并且在遇到
    return的时候函数直接结束。如果没有遇到return,函数返回值就是None)
第五步：回到函数调用的位置（这个时候函数调用表达式的值才是函数的返回值）
"""


def func3():
    print('---------')
    return
    return 100
    print('==========')
    print('+++++++')


print(func3())


def func4():
    return 10, 20


print(func4())


# 练习：写一个函数通过指定方式来计算多个数的结果
# operation('+', 10, 20, 30)    -> 求： 10+20+30
# operation('*', 3, 4, 5, 6)    -> 求：3*4*5*6

def my_operation(operator: str, *nums) -> (int, None):
    if nums:
        if operator == '+':
            sum1 = 0
            for num in nums:
                sum1 += num
            return sum1
            # return sum(nums)

        elif operator == '*':
            res = 1
            for num in nums:
                res *= num
            return res

        elif operator == '-':
            res = nums[0]
            for num in nums[1:]:
                res -= num
            return res

        elif operator == '/':
            dividend = nums[0]
            for divisor in nums[1:]:
                dividend /= divisor
            return dividend


res = my_operation('/', 1, 3, 4, 5)
print(res)      # 0.016666666666666666
res = my_operation('-', 10, 32, 43, 1)
print(res)      # -66
res = my_operation('+', 1, 2, 3, 4, 5)
print(res)      # 15
res = my_operation('*', 13, 43, 23, 5, 2)
print(res)      # 128570


def odevity(num: int):
    if num % 2:
        return '奇数'
    return '偶数'

2. 作用域

  • 变量的作用域 - 已经定义过的变量能使用范围

  • 全局变量

    """
没用定义在函数里或类里面的变量就是全局变量;
全局变量的作用域：从定义开始到程序结束的任何位置都可以使用
"""
# a, b, x都是全局变量
a = 10
for x in range(10):     # 全部变量
    b = x
print(a, b, x)  # 10 9 9


def func1():
    print(a, b, x)


func1()     # 10 9 9

  • 局部变量

"""
定义在函数里的变量就是局部变量（形参也是局部变量）
局部变量的作用域：从定义开始到函数结束
"""


# c, d都是局部变量
def func2(c=3):
    d = 100


func2()

  • 函数调用过程就是压栈的过程

    """
调用函数的时候，系统会自动在栈区间为这个函数创建一个临时栈区间，用来保持在函数中产生的数据（局部变量）。
当函数调用结束，这个临时栈区间会自动释放（释放之前会将返回值传递到临时栈区间的外部）。
"""

  • global - 在函数内部

    """
在函数中修改一个全局变量的值或者在函数定义一个全局变量

语法：
gloabl 变量
使用变量
"""


num = 30
m = 100


def func4():
    num = 40        # 不是在修改全局变量num的值，而是定义一个新的局部变量
    print(f"函数内部num:{num}")     # 函数内部num:40

    global m
    m = 200     # 在函数中修改一个全局变量的值，需要先用global进行说明
    print(f"函数内部m:{m}")     # 函数内部m:200

    global n
    n = 'abc'


func4()
print(f"函数外部num:{num}")     # 函数外部num:30
print(f"函数外部m:{m}")     # 函数外部m:200
print(f"函数外n:{n}")      # 函数外n:abc

作业

  1. 编写一个函数，计算一个整数的各位数的平方和
例如: sum1(12) -> 5（1的平方加上2的平方）    sum1(123) -> 14

def sum1(num: int) -> int:
    """
    计算一个整数的各位数的平方和
    :param num:  需要计算的整数
    :return:  该数的各位数的平方和
    """
    if type(num) != int:
        return None
    res = 0
    if num >= 0:
        for x in str(num):
            res += int(x)**2
    else:
        for x in str(num)[1:]:
            res += int(x) ** 2
    return res


print(sum1(-123))		# 14
  1. 写一个函数，求一个数字列表中绝对值最大的元素
# 例如：nums = [-23, 100, 89, -56, -234, 123], 最大值是：-234

def abs_max_list(list1: list):
    """
    求一个数字列表中绝对值最大的元素
    :param list1:   传入数字列表
    :return:    列表中元素绝对值最大对应的元素
    """
    if type(list1) != list or not list1:
        return None
    # value = list1[0]
    abs_max = abs(list1[0])
    for x in list1[1:]:
        if abs_max < abs(x):
            abs_max = abs(x)
            # value = x
    # return value
    return [x for x in list1 if x in [abs_max, -abs_max]]


print(abs_max_list([-23, 100, 89, -56, -234, 123]))   # -234

  1. 编写函数实现字符串join方法的功能，将指定序列中的元素通过指定字符串合并成一个新的字符串

    def sequence_join(sequence, joinstr: str):
    """
    将指定序列中的元素通过指定字符串合并成一个新的字符串
    :param sequence:    需要拼接的序列
    :param joinstr:     拼接字符串
    :return:    新字符串
    """
    if not sequence:
    	return None
    res = ''
    for x in sequence[:-1]:
        res += str(x) + joinstr
    res += str(sequence[-1])	
    return res


print(sequence_join([-23, 100, 89, -56, -234, 123], '+'))       # -23+100+89+-56+-234+123

  2. 写一个函数实现列表extend的功能，将指定序列中的元素全部添加到指定列表中

    def list_extend(list1: list, sequence):
    """
    将指定序列中的元素全部添加到指定列表中
    :param list1:   指定列表
    :param sequence:    指定序列
    :return:    None
    """
    for x in sequence:
        list1.append(x)


list1 = [-23, 100, 89, -56, -234, 123]
list_extend(list1, (12, 110))
print(list1)

  3. 写一个函数实现简易计算器的功能：输入第一个数字，输入运算符，输入第二个数字，计算结果。

    执行过程1：
计算器：
>10
>+
>20
=30

执行过程1：
计算器：
>10
>x
>20
=200

....

    def calculator():
    """
    简易计算器
    :return:    None
    """
    num1 = float(input('>'))
    if num1 % 1 == 0:
        num1 = int(num1)
    operator = input('>')
    num2 = float(input('>'))
    if num2 % 1 == 0:
        num2 = int(num2)
    if operator == '+':
        print(f'={num1 + num2}')
    elif operator == '-':
        print(f'={num1 - num2}')
    elif operator == 'x' or operator == 'X':
        print(f'={num1 * num2}')
    elif operator == '/':
        print(f'={num1 / num2}')
    elif operator == '%':
        print(f'={num1 % num2}')
    else:
        print('暂时无法进行该运算符的计算，请尽情期待下一个版本！')


calculator()

  4. 已经列表points中保存的是每个点的坐标(坐标是用元组表示的，第一个值是x坐标，第二个值是y坐标)

    points = [
  (10, 20), (0, 100), (20, 30), (-10, 20), (30, -100)
]


def get_max_y_from_points(points: list):
    """
    获取列表中y坐标最大的点
    :param points:  要进行操作的坐标列表
    :return: 列表中y坐标最大的点
    """
    if not points:
        return None
    max_y_point = points[0]
    for x, y in points[1:]:
        if max_y_point[-1] < y:
            max_y_point = (x, y)
    return max_y_point


def get_min_x_from_points(points: list):
    """
    获取列表中x坐标最小的点
    :param points:  要进行操作的坐标列表
    :return:    列表中x坐标最小的点
    """
    if not points:
        return None
    min_x_point = points[0]
    for x, y in points[1:]:
        if min_x_point[0] > x:
            min_x_point = (x, y)
    return min_x_point


def get_max_distance_from_points(points: list):
    """
    获取列表中距离原点最远的点
    :param points:  要进行操作的坐标列表
    :return:    列表中距离原点最远的点
    """
    if not points:
        return None
    max_distance_point = points[0]
    max_distance_square = max_distance_point[0]**2 + max_distance_point[-1]**2
    for point in points:
        if max_distance_square < point[0]**2 + point[-1]**2:
            max_distance_point = point
    return max_distance_point


def points_sort_by_x_distance(points: list):
    """
    将点按照点到x轴的距离大小从大到小排序
    :param points:  要进行操作的坐标列表
    :return:    按照点到x轴的距离大小从大到小排序后的列表
    """
    if not points:
        return None
    new_points = []
    list1 = sorted({abs(x[-1]) for x in points}, reverse=True)
    for value in list1:
        new_points.extend([x for x in points if x[-1] in [value, -value]])
    return new_points

    1）获取列表中y坐标最大的点

    max_y_point = get_max_y_from_points(points)  
max_y_points = [x for x in points if x[-1] == max_y_point[-1]]
print(max_y_points)

    2）获取列表中x坐标最小的点

    min_x_point = get_min_x_from_points(points)
min_x_points = [x for x in points if x[0] == min_x_point[0]]
print(min_x_points)

    3）获取列表中距离原点最远的点

    max_distance_point = get_max_distance_from_points(points)
max_distance_points = [x for x in points if x[0]**2 + x[-1]**2 == max_distance_point[0]**2 + max_distance_point[-1]**2]
print(max_distance_points)

    4）将点按照点到x轴的距离大小从大到小排序

    # 方法一
points = points_sort_by_x_distance(points)
# 方法二
points.sort(reverse=True, key=lambda x: abs(x[-1]))
print(points)
??fengyu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言变量/函数的作用域
小豹Miss鲍的博客
09-20 965
C语言常见问题 问题： 在学习Java语言的时候，会用一节讲java语言的作用域，但是C语言却没有。那么C语言有作用域么，和java语言有什么区别？ 代码1 （我们常这样写） #include <stdio.h> //代码1 int main(int argc, char *argv[]){ int i = 20; for(int i = 0; i &lt...
Python学习笔记之函数的定义和作用域实例详解
09-18
了解如何定义函数和理解变量作用域是编写高效、可维护的Python代码的关键。以下是关于Python函数定义和作用域的详细解释。 **函数的定义** 在Python中，使用`def`关键字来定义函数。例如，下面是如何定义一个简单...
c语言变量按作用域范围分两种,C语言day02-10变量的作用域
weixin_39855634的博客
05-16 1904
变量的作用域本小节知识点:1.【掌握】变量的作用域2.【掌握】局部变量3.【掌握】全局变量4.【掌握】常见错误1.变量的作用域C语言中所有变量都有自己的作用域，申明变量的类型不同，其作用域也不同。C语言中的变量，按照作用域的范围可分两种，即局部变量和全局变量。2.局部变量局部变量也称之为内部变量。局部变量是在函数内作定义说明的。其作用域仅限于函数内(代码块)，离开该函数后再使用这种变量是非法的。-...
day09-python-函数学习-基础
m0_73708511的博客
10-03 1208
def 函数名([ 参数列表 ]) : 函数体python 中使用def关键字来定义函数def fun1() : """ 这是函数的注释用于解释函数是干什么的""" print("第一个函数") fun1()在上面示例中我定义了一个名字为fun1的函数，我们注意到函数名后面带了一对圆括号，圆括号中是用于指出函数的输入参数的，在这里fun1不需要任何输入参数，因此括号是空的【即使没有参数也不能省略圆括号】，最后以冒号结尾。跟着冒号后面所有的缩进代码被称为函数体。
Python 变量作用域与函数
CSDN
08-03 7379
Python 变量作用域一个程序的所有的变量并不是在哪个位置都可以访问的,访问权限决定于这个变量是在哪里赋值的,变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称,两种最基本的变量作用域,第一种是局部变量,第二种是全局变量.定义在函数内部的变量拥有一个局部作用域,定义在函数外的拥有全局作用域,而局部变量只能在其被声明的函数内部访问,全局变量则可以在整个程序范围内访问.变量的作用域...
Day06 - 函数和模块的使用
Laic Zhang的博客
04-27 1110
函数和模块的使用 在讲解本章节的内容之前，我们先来研究一道数学题，请说出下面的方程有多少组正整数解。 x1+x2+x3+x4=8x_1 + x_2 + x_3 + x_4 = 8x1​+x2​+x3​+x4​=8 事实上，上面的问题等同于将8个苹果分成四组每组至少一个苹果有多少种方案。想到这一点问题的答案就呼之欲出了。 CMN=M!N!(M−N)!,(M=7, N=3)C_M^N =\f...
04day-函数,函数进阶（作用域）
DaB210的博客
03-30 696
04day-函数,函数进阶（作用域）
嵌入式学习Day11 C语言 --- 数组作为函数的形参、标识符的作用域与生命周期
ZGZM9的博客
01-28 1041
void printStr(char s[][10],int row) //注意需要传行数，因为操作多个字符串。//如果想在当前文件使用别的文件中的 全局变量 ，//相当于，把别的文件中的变量作用域扩展到当前文件。//表示 此时这个a 不是在当前文件中定义的 ，//指针变量 p 指向 了 int型变量a。//这个是一个自动变量 --- 栈上开辟的变量。
Python笔记：函数的定义和作用域
Wang的专栏
06-18 684
定义函数 默认参数： 可以向函数中添加默认参数，以便为在函数调用中未指定的参数提供默认值 # 如果调用 cylinder_volume 函数时，不提供radius参数，那么radius的值为5 def cylinder_volume(height, radius=5): pi = 3.14159 return height * pi * radius ** 2 向函数中的参数传值...
Python-Level1-day09:变量作用域；函数参数
dpq666dpq666
07-13 461
2022年7月13日15:02:58
python开发基础——day11 函数作用域与名称空间
qq_45727950的博客
07-08 916
函数：更高级的容器，里面存的不是数据，而是代码，一个容器能干嘛，函数也可以干嘛
Practise-day9-10
03-18
2. **函数与作用域**：了解如何定义和调用函数，以及作用域的概念，包括全局作用域、局部作用域、块级作用域以及闭包。 3. **对象与数组**：掌握对象的创建和操作，如属性访问、方法调用，以及数组的遍历、增删改查...
通过5个知识点轻松搞定Python的作用域
12-25
C:/Users/L/PycharmProjects/s14/preview/Day8/作用域/main.py lzl 9 Process finished with exit code 0 代码执行成功，没有问题；在Java/C#中，执行上面的代码会提示name，age没有定义，而在Python中可以执行成功...
Day-10:第 10 天的作业
06-29
我们可以通过`var`、`let`或`const`来声明变量，它们各有其用处，`var`的作用域是函数，而`let`和`const`则是块级作用域。`const`用于声明不可变的常量，一旦赋值，就不能改变。 函数在JavaScript中扮演着重要角色...
day03-js高级.zip
10-01
- **作用域**：区分全局作用域和局部作用域，了解块级作用域以及`let`、`var`和`const`的区别。 - **异步编程**：包括回调函数、Promise、async/await等，以解决JavaScript的非阻塞I/O问题。 - **模块化**：学习如何...
随机数种子的作用
帆的博客
07-23 1032
设置随机数种子（random seed）的目的是为了确保随机数生成器在每次运行时产生相同的随机数序列，从而保证实验结果的一致性。随机数种子通过初始化随机数生成器的内部状态，使得在相同的种子值下，随机数生成器每次调用时生成的序列是相同的。
Java-Lambda
lizhiwei21的博客
07-21 475
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
使用9种方法隐藏和显示元素
lulei5153的博客
07-21 198
【代码】使用9种方法隐藏和显示元素。
提取autocad2024图形中图块的属性的代码-统计选中图块长度属性的总长度
最新发布
VB973490770的专栏
07-24 107
阀门位号：XV-123。
C++11指针与函数实战：调试与日期转换
这两个实验着重于提升学习者对C++指针的理解，包括指针作为参数传递、指针操作和函数作用域。通过实践，学生可以加深对数据结构和函数设计的掌握，同时提高代码的可读性和效率。如果在实验过程中遇到问题，可以参考...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值