07：循环嵌套、函数的介绍、定义、参数以及参数拆包

最新推荐文章于 2022-03-29 22:27:34 发布

TaQuanGe

最新推荐文章于 2022-03-29 22:27:34 发布

阅读量256

点赞数

分类专栏： python学习

本文链接：https://blog.csdn.net/weixin_44769776/article/details/107915315

版权

python学习专栏收录该内容

13 篇文章 0 订阅

订阅专栏

以下内容仅做自己学习使用，知识点内容来自柠檬班，转载请标记来源

@Author:木又
@File:demo1_循环嵌套.py
@Time:2020/7/14 20:22
@Name:Ta Quan Ge

python 之禅：扁平胜于嵌套
print参数：end= 换行

while循环嵌套

# while True:
#     num = int(input("请输入数字："))
#     n = 0
#     while n <= num:
#         print(n)
#         n += 1

*
**
***
****
*****
******


# 1.打印*号
# for i in range(1, 7):
#     print(f"{i}行")
#     for j in range(i):
#         print("* ", end="")    # print参数：end=  换行
#
#     print("")

2.打印乘法口诀表

for i in range(1, 10):
    for j in range(1, i + 1):
        print(f"{j}*{i}={j * i:<4}", end="")
    print()

=================================================================
@Author:木又
@File:demo2_函数的介绍.py
@Time:2020/7/14 20:52
@Name:Ta Quan Ge

函数：可以对重复使用的功能进行封装，提高代码的重复性，提高工作效率，降低代码的耦合性

def fun(n):
    for i in range(1, n + 1):
        for j in range(i):
            print("* ", end="")  # print参数：end=  换行
        print("")


fun(2)

=================================================================
@Author:木又
@File:demo3_函数的定义.py
@Time:2020/7/14 20:53
@Name:Ta Quan Ge

函数的定义：关键字def
def 函数名字():
函数的功能代码

定义好的函数不会直接运行，需要调用时才会执行

函数名命名规范：
1.只能由数字、字母、下划线组成
2.不能使用数字开头
3.不能使用python中的关键字（内置函数、第三方库的名字）

函数命名风格：
推荐使用下划线命名法

已经学过的内置函数
print()：输出
input(): 输入
id():获取数据的内存地址
type() 获取数据的类型

def fun(n):
    for i in range(1, n + 1):
        for j in range(i):
            print("* ", end="")  # print参数：end=  换行
        print("")

fun(9)     #调用函数，执行代码

=================================================================
@Author:木又
@File:demo4_函数的参数.py
@Time:2020/7/14 21:26
@Name:Ta Quan Ge

函数的参数：
定义函数的时候，可以在后面括号中定义参数

函数参数类型：
形参：定义的参数称为形参
三种定义形式：
1.必须参数（必备参数）:定义了就一定要传，不能多传也不能少传

2.默认参数（缺省参数）：定义的时候可以设置默认值，调用的时候可以传，
也可以不传，不传的时候就使用默认值

3.不定长参数（动态\可变参数）: 可以接受0个或者多个参数
*args：只能接收位置传参，以元组的形式保存
**kwargs：只能接收关键字传参，以字典的形式保存

实参：调用实际传递的为实参
两种定义形式：
1.位置传参（位置参数）：按照参数定义的位置进行传递
2.关键字参数（关键字参数）：通过参数名字，指定传递

注意点：如果使用两种形式混合传递参数：先写位置参数，再写关键字参数，不然会报错

形参:
1.必须参数（必备参数）:定义了就一定要传，不能多传也不能少传

def sum(a, b):
    print("a:", a)
    print("b:", b)
    print(a + b)


sum(1, 2)
sum(1, )    # TypeError: sum() missing 1 required positional argument: 'b'
sum(2, 1, 3)  # TypeError: sum() takes 2 positional arguments but 3 were given

2.默认参数（缺省参数）：定义的时候可以设置默认值，调用的时候可以传，
也可以不传，不传的时候使用默认值

def sum(a, b=2):
    print("a:", a)
    print("b:", b)
    print(a + b)

sum(1)  #  不传的时候使用默认值

sum(1,4)

3.不定长参数（动态\可变参数）: 可以接受0个或者多个参数

# *args：只能接收位置传参，以元组的形式保存

def sum(*args):
    print("arge:", args)


sum()  # 可不传
sum(1)  # 可传一个
sum(1, 4)  # 可传多个


sum(a=1)   # 只能接收位置传参,TypeError: sum() got an unexpected keyword argument 'a'

# **kwargs： 只能接收关键字传参，以字典的形式保存
def sum(**kwargs):
    print("kwargs", kwargs)


sum()  # 可不传
sum(a=1)  # 可传一个
sum(a=1, b=4)  # 可传多个

# 同时传 *args、 **kwargs
def sum(*args, **kwargs):
    print("args", args)
    print("kwargs", kwargs)


sum(1, 2, 3, a=1, b=4)  # 可传多个,注意位置参数在前，关键字参数在后，否则报错

实参:
1.位置传参（位置参数）：按照参数定义的位置进行传递

def sum(a, b):
    print("a:", a)
    print("b:", b)
    print(a + b)


sum(1, 2)
sum(2, 1)

2.关键字参数（关键字参数）：通过参数名字，指定传递

def sum(a, b):
    print("a:", a)
    print("b:", b)
    print(a + b)


sum(a=1, b=2)
sum(b=1, a=2)

3.注意点：如果使用两种形式混合传递参数：先写位置参数，再写关键字参数，不然会报错

def sum(a, b):
    print("a:", a)
    print("b:", b)
    print(a + b)


sum(a=1, 2)    #SyntaxError: positional argument follows keyword argument
sum(1, b=2)  # 先写位置参数，再写关键字参数

案例一：定义一个可以自定义打印三角形大小的函数

def fun(n):
    for i in range(1, n + 1):
        for j in range(i):
            print("* ", end="")  # print参数：end=  换行
        print("")

fun(9)

必须参数（必备参数）

def sum(a, b):
    print("a:", a)
    print("b:", b)
    print(a + b)


sum(1, 2)

================================================================
@Author:木又
@File:demo5_函数的参数拆包.py
@Time:2020/7/14 21:55
@Name:Ta Quan Ge

* : *加在形参前面（定义函数参数的时候使用），接收不定长位置参数，转换为元组
    *加在实参前面（调用函数参数的时候使用），可以将元组（列表）拆包成多个位置参数
    
** ： **加在形参前面（定义函数参数的时候使用），接收不定长的关键字参数，转换为字典 
      **加在实参前面（调用函数参数的时候使用），可以将字典拆包成多个关键字参数

*args、 ** kwargs 是可以更改的，关键点在于前面的（星 ※）

def sum(*a, **b):
    print("args", a)
    print("kwargs", b)

sum(1, 2, 3, a=1, b=4)

*加在实参前面（调用函数参数的时候使用），可以将元组（列表）拆包成多个位置参数

def sum(a, b, c, d):
    print(a, b, c, d)

tu = (1, 2, 34, 5)
li = [1, 2, 3, 4]
sum(*tu)
sum(*li)


def sum(a, b, c, d):
    print(a, b, c, d)


dic = {"a": 1, "b": 2, "c": 3, "d": 4}
li = [1, 2, 3, 4]
sum(**dic)


# sum(**li)   # 两个星不可以拆列表

=================================================================
@Author:木又
@File:work_07day.py
@Time:2020/7/14 22:49
@Name:Ta Quan Ge

一、必做题：

1：简单题
1、函数的形参有哪几种定义形式？

1.必须参数（必备参数）:定义了就一定要传，不能多传也不能少传

2.默认参数（缺省参数）：定义的时候可以设置默认值，调用的时候可以传，
也可以不传，不传的时候就使用默认值

2、函数的实参有哪几种形式？
两种定义形式：
1.位置传参（位置参数）：按照参数定义的位置进行传递
2.关键字参数（关键字参数）：通过参数名字，指定传递

2、利用上课讲的for循环嵌套的知识点，封装一个可以打印任意比列三角形的函数
(注意点：和上课的有区别，这个是倒三角)

# * * * * * *
# * * * * *
# * * * *
# * * *
# * *
# *
def fun(a, b):
    for i in range(-a, b):
        # print(i)
        for j in range(-i):
            print("* ", end="")
        print()


fun(3, 3)    # 此方法有漏洞

# 其他做法
# 法1.
def fun(n):
    res = list(range(1, n + 1))
    res.reverse()  # 使列表反序
    # print(res)
    for i in res:
        for j in range(i):
            print("* ", end="")
        print()


fun(4)


# 法2.
def fun(n):
    for i in range(n, 0, -1):
        for j in range(i):
            print("* ", end="")
        print()


fun(4)

3、定义一个可以完成任意个数字相加的函数（支持关键字传参和位置传参），并返回相加结果。
要求:调用函数传入1个数字，返回值为这个数字。
如：func(1) ----> 返回 1
调用函数传入2个数字，返回值为2个数相加的结果。
如：func(11,22) ----> 返回33
调用函数传入3个数字，返回值为3个数相加的结果。
如：func(11,22,33,) ----> 返回66
调用函数传入n个数字，返回值为n个数相加的结果。
如：func(1,2,3,4,5) ----> 返回 15
（提示：可以使用不定长参数来接收参数，对参数进行遍历再相加）

def fun(*args, **kwargs):
    tu = args
    tu1 = kwargs
    sum = 0
    for i in tu:
        sum += i
    for i in tu1.values():
        sum += i
    print(sum)


fun(1)
fun(1, 2, a=3)

简化

def fun(*args, **kwargs):
    sum = 0
    for i in args:
        sum += i
    for i in kwargs.values():    #使用位置传参时，不定长参数会以字典的形式保存，故遍历的时候要获取values
        sum += i
    print(sum)



fun(1)
fun(1, 2, a=3)

再简化

def fun(*args,**kwargs):
    print(sum(args) + sum(kwargs.values()))
fun(1)
fun(1, 2, a=3)

TaQuanGe

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
07：循环嵌套、函数的介绍、定义、参数以及参数拆包

以下内容仅做自己学习使用，知识点内容来自柠檬班，转载请标记来源@Author:木又@File:demo1_循环嵌套.py@Time:2020/7/14 20:22@Name:Ta Quan Gepython 之禅：扁平胜于嵌套print参数：end= 换行while循环嵌套# while True:# num = int(input("请输入数字："))# n = 0# while n <= num:# print(n)#
复制链接

扫一扫