2024年最新Python大数据之Python基础【七】参数_不定长参数看平方和

于 2024-09-19 01:08:47 发布
阅读量355 收藏 6
点赞数 3
文章标签： python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_87226988/article/details/142347274
版权 
# 不定长参数主要就是在定义函数时,不确定参数的个数时即可进行不定长参数的书写

'''
位置不定长参数的定义格式:
def 参数名(\*args):
 函数体
'''


# def func(\*args):
# print(\*args) # 相当于书写内容为 print(1,2,3)
#
#
# func(1, 2, 3)
# print(1, 2, 3)

# args变量到底内部是什么样子的?
# def func(\*args):
# return args

# 数据传入函数内部时,将传入的多个数据进行打包,转换为一个元组,被args接收.并且在函数体内部可以使用该元组参与运算
# print(func(1, 2, 3)) # (1, 2, 3)


# 案例:
# 输入不确定数量的多个值,判断其中的最大值

def max1(\*args):
    max_num = args[0]  # 如果max\_num = 0 这个时候我们所有值都没负的时候会判断出错
    for i in args:
        if i > max_num:
            max_num = i
    return max_num


print(max1(1, 4, 5, 3, 6, 12, 3))

# 如果输入的数值全部为负呢?
print(max1(-1, -2, -5))
  • 关键字不定长参数（**kwargs）：将多余的关键字 参数，打包为一个字典，保存在kwargs当中
# 关键字不定长参数,可以接收多个未定义参数的关键字赋值

'''
关键字不定长参数的格式:
def 函数名(\*\*kwargs):
 函数体
'''


# TypeError: 'a' is an invalid keyword argument for print()
# def func(\*\*kwargs):
# print(\*\*kwargs) # 相当于给print输入了多个关键字参数 print(a=1, b=2, c=3)
#
#
# func(a=1, b=2, c=3)

# 使用\*\*kwargs可以将关键字参数进行传递
# def func(\*\*kwargs):
# print(1, 2, \*\*kwargs) # 相当于print(1, 2, sep='&', end='a')
#
#
# func(sep='&', end='a')

# kwargs 内部到底是什么存储结构呢?
def func(\*\*kwargs):
    # kwargs 在从传参之后,会将实参位置的所有未定义参数的关键字参数转换为字典的键值对,保存在kwargs当中
    print(kwargs)  # {'a': 1, 'b': 2, 'c': 3}


func(a=1, b=2, c=3)


# 案例:
# 使用创建一个函数可以保存学员的全部信息,并将其储存到字典当中

def student\_info(\*\*kwargs):
    print(f'学员信息为:{kwargs}')


student_info(name='xiaoming', age=18, gender='男')

2、函数定义和调用时各类参数的排布顺序

  • 形参： 位置参数》》位置不定长参数》》缺省参数》》关键字不定长参数
  • 实参：顺序赋值》》关键字参数赋值
  • 在开发中除非有特殊需求，一般参数种类不超过三种，参数个数不超过5个，如果种类或数量太多，会造成我们开发中沟通成本加大
# 在定义函数时:位置参数,缺省参数,位置不定长参数,关键字不定长参数 到底在定义时怎么排列呢?
# 调用函数时:顺序赋值, 关键字赋值 调用时的传参顺序是什么样的呢?


# 定义函数时:形参

# 位置参数和缺省参数的位置关系:
# def func1(a, b, c=10):
# print(a)
# print(b)
# print(c)
# 缺省参数c 能否放到a,b之前或之间
# SyntaxError: non-default argument follows default argument
# 有默认值的参数只能放到没有默认值的参数之后,不能前置
# def func1(c=10,a, b ):
# print(a)
# print(b)
# print(c)
#
# # 赋值时可以不给c传参因为其有默认值
# func1(1, 2)

# 结论: 在定义函数时,位置参数在缺省参数之前

# 位置参数,缺省参数,位置不定长参数之间的位置关系
# 顺序赋值多个参数,位置参数优先接收,然后缺省参数接收数据,多余的参数被args以元组形式打包接收
# 思考:为什么要设置缺省参数呢? 一般情况下,缺省参数是不进行赋值的,因为绝大多数情况下都会赋默认值,极少情况下会使用关键字参数赋值
# 如果放到\*args之前,是不是每次给\*args赋值,都要给缺省参数赋值,所以不是很方便
# 综上考虑,我们决定将缺省参数放到\*args之后

# def func2(a, b, c=10, \*args):
# print(a)
# print(b)
# print(c)
# print(args)
# 传值逻辑如下:1.先给位置参数赋值 2.多余的未接收数据,被args打包为一个元组进行接收 3.缺省参数一般情况下不赋值,如果需要赋值,使用关键字参数赋值
# 在官方文档或者系统模块中,都是这种顺序书写的
# def func2(a, b, \*args, c=10):
# print(a)
# print(b)
# print(c)
# print(args)
#
#
# func2(1, 2, 3, 4, 5)


# 结论:在定义函数时,先写位置参数,再写位置不定长参数,最后写缺省参数


# 位置参数,缺省参数,位置不定长参数,关键字不定长参数之间的位置关系

# def func2(a, b, \*args, c=10, \*\*kwargs):
# print(a)
# print(b)
# print(c)
# print(args)
# print(kwargs)
#
#
# func2(1, 23, 4, 5, 3, 2, c=1, name='xiaoming', age=18)

# 思考:\*\*kwargs可不可以往前放
# \*\*kwargs只能放到最后,否则会报错

# 结论:形参排布顺序为:位置参数>>位置不定长参数>>缺省参数>>关键字不定长参数


# 调用函数时:实参

def sum1(a, b):
    print(a + b)

# SyntaxError: positional argument follows keyword argument
# 顺序赋值,不能在关键字赋值之后
# sum1(a=1, 2)

# 结论,调用参数时,先使用顺序赋值,后使用关键字赋值

3、组包和拆包

  • 组包：将多个数据，组合为一个容器类型，进行使用或变量保存
  • 拆包：将一个容器类型，进行拆分，其中的每一个元组赋值给其他的变量
# 组包:就是讲多个值进行组合,打包为一个容器类型的过程
# 拆包:就是讲一个容器类型,拆分成多个数据,分别赋值给多个变量的过程

# 组包
def func1():
    return 1, 2, 3, 4


# func1返回了多个数据,Python自动将其打包为一个元组,这个过程就是组包
print(func1())  # (1, 2, 3, 4)
# 将多个数据打包整合为一个容器,赋值给变量,这个就是组包过程
a = 1, 2, 3, 4
print(a)

# 拆包(解包)
# 将等号右侧的列表,拆分为四个数据元素,分别赋值给a,b,c,d这个过程就是拆包
a, b, c, d = [1, 2, 3, 4]
print(a, b, c, d)

# 之前我们在循环汇总用过拆包过程
list1 = [1, 2, 3, 4]
for index, value in enumerate(list1):
    print(index, value)

dict1 = {'name': 'xiaoming', 'age': 18}
for key, value in dict1.items():
    print(key, value)

# 同时应用组包和拆包的案例

a = 1
b = 2
# 需求:将a, b进行互换值
# 这个互换过程,是先讲a,b的值提取出来,组包为一个元组,然后进行拆包,将元组内的两个数据分别赋值给,a,b变量
a, b = b, a
print(a, b)

# 注意:字典可以拆包么?可以
dict1 = {'a': 1, 'b': 2, 'c': 3}
# 对字典进行拆包,得到的是字典的键
char1, char2, char3 = dict1
print(char1, char2, char3)

# 集合可以拆包么? 可以
# 对于集合进行拆包,没有任何问题,但是一般不会这样做,因为赋值顺序无法指定
set1 = {'Tom', 'Bob', 'Rose'}
a, b, c = set1
print(a, b, c)

4、引用

  • 数据的三个维度：值， 数据类型，唯一标识
    • 值： 数据计算时使用的值
    • 数据类型：数据的存储类型
    • 唯一标识：id ，也就是数据的内存地址的标识
  • 如果我们想要判断id 或者说唯一标识是否相等，我们使用is进行判断
# 在Python中所有的数据分为三个维度: 值(判断==), 数据类型(int...float...), 唯一标识(id)

# 值相等的数据,唯一标识和数据类型不一定相等
bool1 = False
int1 = 0
# 0 和False的值相等
print(bool1 == int1)  # True
# 数据类型不等
print(type(bool1) == type(int1))  # False
# 唯一标识不等
# id 判断数据是否是同一内存空间中的数据(同一内存空间中的数据必相等)
print(id(bool1) == id(int1))  # False

# 值和数据类型相等的,唯一标识不一定相等
list1 = [1, 2, 3]
list2 = [1, 2, 3]
# list1 和list2 值相等
print(list1 == list2)  # True
# list1和list2 数据类型相等
print(type(list1) == type(list2))  # True
# list1 和list2 的唯一标识不等,也就是说,其所在的内存空间不一致
print(id(list1) == id(list2))  # False

# 唯一标识相等的, 值和数据类型必然相等
# 在同一内存空间中只能储存同一个值
str1 = 'abc'
str2 = 'abc'
# str1 和str2 的唯一标识相等
print(id(str1) == id(str2))  # True
# 数据类型相等
print(type(str1) == type(str2))  # True
# 数据值相等
print(str1 == str2)  # True

# 怎样判断id 唯一标识是否相等呢? is关键字
# 使用is可以判断是否为同一个内存空间中的数据
print(list1 is list2)  # False
print(str1 is str2)  # True

5、可变类型和不可变类型

  • 可变类型：内存空间中的数据可以被修改的数据类型
    • list set dict
  • 不可变数据类型：内存空间中的数据不可以被修改的数据类型
    • int float bool str tuple
# 传参或者变量的传递是进行了值的传递 还是进行了引用地址的传递呢?

list1 = [1, 2, 3, 4]
list2 = [1, 2, 3, 4]
# id的值,我们称呼他为引用地址,list1 和list2 的引用地址不相同
print(id(list1))  # 140652966394496
print(id(list2))  # 140652968507776

# 如果我向list1 中添加以数字,次数list2 中的值为多少? [1,2,3,4]
list1.append(5)
print(list1)
print(list2)
# 在list1中添加了数据,那list1的引用地址会发生变化么? 不会变化
# list1,在使用append方法时,是将内存空间中的值进行了变化,没有修改内存地址,所以id值不变
print(id(list1))  # 140652966394496

# 如果我们使用list1 = list2,list1的引用地址发生变化了么? 变化
list1 = list2
# 在对list1赋值时,list2 将list1中的内存地址赋值给了list1,此时,list1和list2指向同一块内存空间
print(id(list1))  # 140652968507776

# 如果在list1中删除下标为1的元素,list2 会发生变化么? 会变化
# list1 和list2 指向同一块内存空间,所以内存空间中的数据发生了改变,list1 和list2 均发生了变化
list1.pop(1)
print(list1)  # [1, 3, 4]
print(list2)  # [1, 3, 4]

# list 内存空间中的数据可以发生改变,这种数据类型我们称之为可变数据类型

# 练习:
list1 = [1, 2, 3, 4]
list2 = [1, 2, 3, 4]
list1 = [1, 2, 3, 4, 5]
list2 = list1
list1.pop(2)
list1 + list2
# list1 和list2 分别是多少
print(list1)
print(list2)

# 练习:
str1 = '12345'
str2 = '12345'
str1 = str2
str1 = '123'
str2 + str1
print(str1)
print(str2)

str1 = '123'
str2 = '123'
print(id(str1))  # 140509725727984
print(id(str2))  # 140509725727984

# 我么可以修改str内部的元素么? 不可以
# TypeError: 'str' object does not support item assignment
# str1[0] = '2'
# 既然内部元素不可修改,系统定义其值相同时,数据引用地址也相同

# 我么称这种内存空间中的数据无法被修改的值为不可变数据类型


# 结论:
# 可变数据类型: 列表,集合,字典
# 不可变数据类型: 字符串,元组,整型,浮点型,布尔型

# 结论:在数据的传递过程中,是引用传递,不是值的传递

6、引用当做参数传递

  • 在函数传参过程中，变量会以引用的形式进行传参，也就是说我们的变量或参数传递是引用传递，不是值传递
    • 如果参数是可变数据类型，那么在函数内修改其引用地址指向空间内的数据，外部数据同时发生变化
    • 如果参数是不可变数据类型，其实也是引用传递，只不过引用地址指向的数据空间中的数据无法被修改
2401_87226988
关注
Python函数的不定长参数：*args
weixin_40458518的博客
10-04 315
目录例1：*args例2：args名称改为其它名称例3：*args 中的 args 接收的参数是一个元组数据类型例4：一般位置参数和*args同时使用例4：同时使用*args和**kwargs参数 例1：*args def addition(*args): result = 0 for arg in args: result += arg return result if __name__ == "__main__": sum = addition(2,
python 不定长参数_python不定长参数 *argc,**kargcs(24)
weixin_29079671的博客
02-01 921
文章首发微信公众号，微信搜索：猿说python在 python函数的声明和调用 中我们简单的了解了函数的相关使用，然而在函数传递参数的时候，我们埋下了一个坑，关于不定长参数的传递我们还没有讲，今天这篇文章主要就是讲解这个问题。一.函数不定长参数语法函数的不定长参数包含*args和**kwargs，完整实例如下：def function_print(*args,**kwargs): # 传递不定长参...
Python函数的不定长参数
cmw2008free的专栏
07-24 1241
Python函数的不定长参数 程序开发者经常会遇到，函数参数的个数不确定问题，即函数的变长参数问题。 Python语言为开发者提供了方便的变长参数处理方式，在申明参数数时在之前加上*即可。 例如： def displayinfo(var1, *varlist):     print(var1)     for var in varlist:         print var
Python的不定参数
02-11 9164
以一个＊开始的参数，代表一个任意长的元组：>>> def mul(*arg):...     print arg... >>> mul(1,2,3,4,5,6,7,'hello','panfei')(1, 2, 3, 4, 5, 6, 7, 'hello', 'panfei') ＃一个元组>>>＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊一个以＊＊开始的参数，代表一个字典：>>> def mul2(**arg):...     print arg... >>> mul2(a=11,b=
python不定长参数
wenjin
07-17 154
python不定长参数 def func(*args,**kwargs): print(args) print(kwargs) func(11,22,33,44,55,task=66,done=77) *+变量名 传位置参数、可变参数 内部封装成tuple来使用 **+变量名 传关键字参数 内部内部封装成dict来使用 ...
中信建投_0308_大数据人工智能研究之七：零基础python代码策略模型实战.pdf
07-28
中信建投_0308_大数据人工智能研究之七：零基础python代码策略模型实战.pdf
小北使用Python和pyecharts对我校通信学院2024大数据专业就业情况进行中国地图可视化
09-02
小北使用Python和pyecharts对我校通信学院2024大数据专业就业情况进行中国地图可视化
java大数据和python大数据的全面对比，哪个更主流？
hutubiancheng的博客
04-16 4233
大数据是目前互联网流行的技术语言，处理大数据的编程语言比较有优势的也很多，比如java、python、go、R语言、Hadoop等等，按道理来说每种编程语言都可以处理大数据，只是处理的规模不一样而且，但是现在比较受欢迎的数据处理编程语言是java与python。 　　java大数据与python大数据 说到java编程，java工程师一直都是同行的高薪岗位，而python是从最初的2016人工智能开始爆发，从而在短短两年之内能赶超java。随着python的发展，最大赢家无疑是python。未来大数据是
python程序设计基础答案第七章_Python语言程序设计基础（第2版） 课后题 第七章...
weixin_40007515的博客
02-21 6200
参考原版答案import keyword#7.1stopwords = '\t\n\r: ()'functionwords = '.('word = []output = ''lastAvailable = ['from', 'import']last = Falsedef readFile(path):file = open(path,'r',encoding = 'utf-8')string ...
NumPy Cookbook.pdf（Python大数据基础）
07-09
NumPy（Numerical Python）是一个运行在Python之上的开源数学库，它提供了强大的N维数组对象、广播功能、以及用于整合C/C++和Fortran代码的工具。NumPy的核心是其多维数组对象——ndarray。利用这个数组对象，我们...
python大数据
06-25
python开发大数据，区块链学习，让你跟上时代的步伐，
Python 大数据
08-19
大数据技术应用与创新
Python中，不定长参数
最新发布
w_2486的博客
09-05 309
在Python中，不定长参数，*args和**kwargs
python中的不定长参数
ainvzhong0238的博客
09-25 384
#不定长参数def test(*args,**kargs):# print(a)# print(b) print(args) print(kargs) --------------------------------- #定义函数用作划分 def printInfo(): print('-'*30) --------------------------------- #...
Python函数中不定长参数
Philo的博客
01-07 1681
Python
python函数中的不定长参数
Sesen的木屋
03-24 648
python自定义函数中有两中不定长参数，第一种是*name，第二种是**name。加了星号* 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。加了两个星号** 的参数会以字典的形式导入。 第一种形式的不定长参数，在传入额外的参数时可以不用指明参数名，直接传入参数值即可，第二种因为返回的是字典，所以传入时需要指定参数名。 两个简单例子： *name 形式： >...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值