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

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化资料的朋友，可以戳这里获取

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 能否放到a,b之前或之间

SyntaxError: non-default argument follows default argument

有默认值的参数只能放到没有默认值的参数之后,不能前置

def func1(c=10,a, b ):

print(a)

print(b)

print©

# 赋值时可以不给c传参因为其有默认值

func1(1, 2)

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

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

顺序赋值多个参数,位置参数优先接收,然后缺省参数接收数据,多余的参数被args以元组形式打包接收

思考:为什么要设置缺省参数呢? 一般情况下,缺省参数是不进行赋值的,因为绝大多数情况下都会赋默认值,极少情况下会使用关键字参数赋值

如果放到*args之前,是不是每次给*args赋值,都要给缺省参数赋值,所以不是很方便

综上考虑,我们决定将缺省参数放到*args之后

def func2(a, b, c=10, *args):

print(a)

print(b)

print©

print(args)

传值逻辑如下:1.先给位置参数赋值 2.多余的未接收数据,被args打包为一个元组进行接收 3.缺省参数一般情况下不赋值,如果需要赋值,使用关键字参数赋值

在官方文档或者系统模块中,都是这种顺序书写的

def func2(a, b, *args, c=10):

print(a)

print(b)

print©

print(args)

func2(1, 2, 3, 4, 5)

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

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

def func2(a, b, *args, c=10, **kwargs):

print(a)

print(b)

print©

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)

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

mg-n0HnOuEg-1715650879686)]
[外链图片转存中…(img-c4mHhaYF-1715650879686)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！