Python基础-函数与方法

第六章函数与方法

6.1、公共方法

  • +
    • 加法运算适用于所有的基础数据类型（int float bool）
    • 加法运算所有两侧要是同种数据类型
    • 加法运算再容器类型中是拼接的意思，不是相加计算值
# +法运算,都可以用于哪些数据类型之间
# int float  bool 肯定可以用于加法运算,不再赘述
print(1 + 12.3)  # 13.3# str 可以相加么? 可以
str1 = 'hello'
str2 = ' python'
# 字符串相加,可以快速将字符串进行拼接
print(str1 + str2)
# 相加过后,str1 和str2 没有发生变化,可以推断+法运算产生了新的数据,源数据不变化
print(str1, str2, sep='\n')# list 可以相加么? 可以
list1 = [1, 2, 3]
list2 = [4, 5, 6]
# 列表相加可以将列表进行拼接,效果类似于extend
print(list1 + list2)  # [1, 2, 3, 4, 5, 6]
# list相加后,原数据不发生变化,将产生一个新的数据
print(list1)  # [1, 2, 3]
print(list2)  # [4, 5, 6]# tuple 可以相加么?  可以
tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
print(tuple1 + tuple2)  # (1, 2, 3, 4, 5, 6)
# 由于元组内部元素不能修改,索引相加肯定没有对源数据产生影响,而是生成了新的数据# set
# set1 = {1, 2, 3}
# set2 = {4, 5, 6}
# # TypeError: unsupported operand type(s) for +: 'set' and 'set'
# # set之间不能进行加法运算
# print(set1 + set2)# dict
# TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
# dict 类型间不能进行加法运算
# dict1 = {'name': '小明'}
# dict2 = {'age':18}
# print(dict1 + dict2)# 结论: 基础数据类型都可以进行加法运算,容器类型间只有列表,元组,字符串可以进行加法运算# 不同容器类型间可以相加么?
list1 = [1,2,3]
tuple1 = (1,2,3)
set1 = {1,2,3}
dict1 = {'name': 'xiaoming'}# TypeError: can only concatenate list (not "tuple") to list
# print(list1 + tuple1)
# TypeError: can only concatenate list (not "set") to list
# print(list1 + set1)
# TypeError: can only concatenate tuple (not "set") to tuple
print(tuple1 + set1)# 结论,数据类型布偶无法进行加法运算(特指容器类型之间)
  • *
    • 基础数据类型（int float bool）都可以进行乘法运算
    • 容器类型只能和int类型数据进行乘法运算
    • 容器类型进行乘法运算，就是将容器复制指定次数，并进行拼接
# * 效果是设么?
# * 什么容器类型可以使用*# 基础数据类型  int  float  bool都可以使用*法运算
print(12.1 * 2)# 容器类型的乘法运算
# 格式: 容器类型 * int类型数据
# 乘法运算的 效果,就是讲容器类型复制指定次数,并拼接到一起# list 可以使用*法运算么?  可以
list1 = [1, 2, 3]
# 将list1 复制3次并进行拼接
print(list1 * 3)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]
# 使用list 类型乘以float类型可以实现么?
# TypeError: can't multiply sequence by non-int of type 'float'
# 乘法运算不能让容器与非int类型相乘
# print(list1 * 1.3)
# list 能乘以负数么?  可以相乘,但是结果为空列表
print(list1 * -3)  # []
# 可以与0 相乘,结果为空列表
print(list1 * 0)  # []# tuple 可以使用*法运算么? 可以
tuple1 = (1, 2, 3, 4)
print(tuple1 * 2)  # (1, 2, 3, 4, 1, 2, 3, 4)
# tuple 只能与int类型相乘# set可以使用 * 法运算么?  不可以
set1 = {1, 2, 3}
# TypeError: unsupported operand type(s) for *: 'set' and 'int'
# 集合类型数据不能做乘法运算
# print(set1 * 3)# dict 能够使用 * 法运算么?  不可以
dict1 = {'name': 'jack'}
# TypeError: unsupported operand type(s) for *: 'dict' and 'int'
# 字典不能做乘法运算
# print(dict1 * 3)# 乘号左右两侧的数据可以互换位置么?  可以
print(3 * list1)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]
  • in和not in
    • 判断元素是否在数据序列当中
    • 字符串，列表，元组，集合 ，字典都可以使用
# in 判断元素是否存在于容器当中
list1 = [1, 2, 3]
tuple1 = (1, 2, 3)
set1 = {1, 2, 3}print(3 in list1)  # True
print(3 in tuple1)  # True
print(3 in set1)  # True
# 如果要判断是否在set当中,要注意被判断的元素必须可以保存在set当中,如果是列表,字典,集合,则不能判断
# print([1, 2] in list1)  # False  可以判断,引为[1,2] 可以保存在list1当中
# print([1, 2] in set1)  # TypeError: unhashable type: 'list' 不能判断,因为[1,2]不能保存到set1当中# str类型可以使用in么? 可以
str1 = '123'
# TypeError: 'in <string>' requires string as left operand, not int
# 字符串判断时,左侧的元素只能是字符串类型,否则报错
# print(1 in str1)
print('1' in str1)  # True# dict 是否可以使用in???
dict1 = {'name': 123}
# dict使用in判断的是当前元素是否是dict中存在的键
print(123 in dict1)  # False
print('name' in dict1)  # True# 如果使用此方法则不能判断字典  列表 集合
# TypeError: unhashable type: 'list'
# print([1,2] in dict1)# not in  : 所有用法和in相同,只是取反而已# 结论:
# 1.使用in 和not in  被判断的元素在关键字左侧, 数据序列在关键字右侧
# 2.如果想要判断该元素是否在容器内,该元素必须能保存到容器内,比如集合不能保存列表,字典,集合 所以就不能判断其类型的元素是否在集合内
# 3.字典判断的是元素是否在keys内,也就是是否是其中的键
  • 切片
    • 通过切片按照规则获取数据序列中的一部分元素
    • tuple list str 可以使用切片
    • dict set 不可以使用切片
# 切片:通过切片方法可以按照一定规则截取容器的一部分数据# str切片
str1 = 'abcde'
# 格式:[起始位置:终止位置:步长]
# 不会修改原有字符串,而是产生了一个新的字符串
print(str1[2:])  # cde# list可以切片么?
list1 = [1, 2, 3, 4]
# list切片方式方法和str完全相同
# list切片后不会在原有数据上进行修改,而是产生了一个新的列表
print(list1[1:3:1])  # [2, 3]
print(list1)# tuple 可以切片么?
tuple1 = (1, 2, 3, 4)
# tuple1切片方式方法和str完全相同
# 切片后不会在原有数据上进行修改,而是产生了一个新的列表
print(tuple1[1:3:1])  # (2, 3)
print(tuple1)# dict可以切片么?  肯定不行,因为不能使用索引获取数据
# set 可以切片么?  肯定不行,因为不能使用索引获取数据# 结论:
# 1.list str tuple 可以使用切片,格式是:[起始位置:终止位置:步长],三者使用方式完全一致
# 2.所有的切片都不会在原有的数据上进行修改,而是产生一个新的数据序列
# 3.集合和字典无法切片,因为不能使用索引获取数据元素

6.2、公共函数

  • len ：获取容器内元素个数
  • del：删除容器内元素
  • max ：获取容器内数据的最大值
  • min ： 获取容器内元素的最小值
  • enumerate ： 获取容器内元素时可以携带序号
  • range：根据一定规则获取整数序列
# len  获取容器类型的元素个数,  或者说获取容器的长度
str1 = '123'
list1 = [1, 2, 3]
tuple1 = (1, 2, 3)
set1 = {1, 2, 3}
dict1 = {'name': 123, 'age': 18}
# 使用len可以获取list  str  tuple set中的元素个数
print(len(str1))
print(len(list1))
print(len(tuple1))
print(len(set1))
# 使用len可以获取dict中的键值对的个数
print(len(dict1))# len() 可以写成  容器.__len__()
print(list1.__len__())# del
# 删除容器内指定的元素
# list
# del list1[0]
# print(list1)# tuple
# del tuple1[0]
# TypeError: 'tuple' object doesn't support item deletion
# 元组内元素不能被删除
# print(tuple1)# set
# for i in set1:
#     del i# dict
# del dict1['name']
# del 在dict中删除的是键值对
print(dict1)# str
# TypeError: 'str' object doesn't support item deletion
# str 不能够使用del 删除内部元素
# 注意 :str内部的元素也是不可修改的,类似于元组
# del str1[0]
# print(str1)# 结论:
# 1.列表,字典可以使用del删除内部元素,但是,列表中是删除元素,字典中是删除键值对
# 2.使用del 没法循环遍历删除set中的元素,因为引用机制问题
# 3.str  tuple内部的元素都不可更改所以不能使用del删除元素# max  min
# list tuple set str可以使用max  min获取容器内的最大最小值
print(max(list1))
print(max(tuple1))
print(max(set1))
print(max(str1))
# dict是使用max和min获取键的最大最小值
print(max(dict1))# enumerate  枚举函数:获取容器内数据时添加序号(默认序号从0开始可以作为索引使用)list2 = [1, 2, 3, 4, 5, 6, 7, 8]for i in list2:print(i)# 可不可以同时获取元素的值和元素的索引?  可以 使用enumerate# for i in enumerate(list2):
#     # 直接打印,获取的是以(索引,值)组成的元组
#     print(i)# list
for index, value in enumerate(list2):print(index, value, sep=' : ')# tuple
for index, value in enumerate(tuple1):print(index, value, sep=' : ')# set
for index, value in enumerate(set1):print(index, value, sep=' : ')# str
for index, value in enumerate(str1):print(index, value, sep=' : ')# dict  
for index, value in enumerate(dict1):print(index, value, sep=' : ')# 结论:所有的容器和课迭代类型都可以使用enumerate,并且产生序号,这个序号并不是索引值,而是在生成序号时默认从0开始,碰巧可以在list,str,tuple中当做索引使用

6.3、推导式

  • 列表推导式
    • 格式：[要插入的值 for 临时变量 in 数据序列 if 条件]
  • 集合推导式
    • 格式：{要插入的值 for 临时变量 in 数据序列 if 条件}
  • 字典推导式
    • 格式：{要插入的键：要插入的值 for 临时变量 in 数据序列 if 条件 }
  • 没有元组推导式和字符串推导式，因为其内部元素无法被修改
# 推导式:通过一定的规则快速构建数据序列
# 列表推导式
# 获取从0 到9的数据序列
# while
list1 = []
i = 0
while i < 10:list1.append(i)i += 1
print(list1)# for
list2 = []
for i in range(10):list2.append(i)
print(list2)# 推导式
# 格式: [要插入列表的表达式 for 临时变量 in 数据序列]
list3 = [i for i in range(10)]
print(list3)# 使用推导式,创建一个从1-100的偶数的数据序列# for
list4 = []
for i in range(1, 101):if i % 2 == 0:list4.append(i)print(list4)# 推导式
# 格式: [要插入列表的表达式 for 临时变量 in 数据序列 if  条件]
list5 = [i for i in range(1, 101) if i % 2 == 0]
print(list5)# 练习:
# 用推导式进行九九乘法表的生成,将所有的算式放入列表中
list6 = []
for i in range(1, 10):for j in range(1, i + 1):list6.append(f'{j} * {i} = {j * i}')print(list6)# 改写为推导式:
list7 = [f'{j} * {i} = {j * i}' for i in range(1, 10) for j in range(1, i + 1)]
print(list7)# 集合推导式
# 集合推导式和列表推导式完全一致,只不过使用推导式时,外层用{}包裹,并且在序列中会去重
set1 = {i for i in range(10)}
print(set1)# 获取从1-10 的偶数集合
set2 = {i for i in range(1, 11) if i % 2 == 0}
print(set2)# 字典推导式
keys = ['name', 'age', 'gender', 'id']
values = ['xiaoming', 18, '女', '001']# 需求想将key 和value以一对应,形成一个字典
dict1 = {}
for i in range(len(keys)):dict1[keys[i]] = values[i]print(dict1)# 改写推导式
# 格式:{要插入的键:要插入的值  for 临时变量 in 数据序列  if 条件}
dict2 = {keys[i]: values[i] for i in range(len(keys))}
print(dict2)# 所有的推导式都可以使用for循环改写,所以我们进行推导式的时候先不要急于求成,多改写几次就不用再改写了直接可以写出推导式

6.4、函数介绍

  • 函数的定义：

    • def 函数名（参数）：

      ​ 函数体

      ​ return 返回值

  • 函数的调用：函数名（参数）

# 函数: 将特定的功能所对应的代码片段进行打包,封存在一个函数内,如果我们想要重复使用该功能,就直接调用函数即可
# 函数的作用: 提高代码复用率,提高开发效率,易于维护'''
函数定义的格式:
def 函数名(参数1, 参数2,参数3....):函数体return 返回值函数调用的格式:
函数名(参数1,参数2,参数3.....)# 函数名:绝大多数函数都有函数名,没有函数名的函数不能被复用
# 参数:为了让函数灵活性更高,更容易被复用,会动态对函数进行传值,传递的值可以在函数体内部进行使用
# 函数体: 特定功能的代码,写在函数内部,调用函数时可全部执行
# 返回值: 写在return之后,将函数内部计算或运行得到的数据传递到函数体外部
'''# 定义的时候可以不传参,如果不传调用的时候也不用传参
def run():print('我跑的老快了,没人追的上我,钱包在我手里')print('我跑的老快了,没人追的上我,手机在我手里')print('我跑的老快了,没人追的上我,女朋友在我手里')# 调用时可以将函数内的代码全部执行一遍
run()
run()
  • 函数的调用顺序：从上到下依次执行，先键函数名保存到函数列表中，调用的时候去类表中查询，如果存在则调用其中的代码，如果不存在则报错
# NameError: name 'sing' is not defined
# 函数需要先定义后调用否则会报错
# sing()
# 定义一个唱歌方法
def sing():print('我再唱青藏高原')
# 定义一个跳舞方法
def dance():print('我再跳广场舞')sing()
dance()# 执行顺序: 先讲所有函数的函数名执行一遍将其储存到缓存中的方法列表中,后续调用函数时去方法列表中查询,如果函数名存在,则调用函数内部的代码,如果函数名不存在将报错

6.5、函数参数

  • 函数的参数可以增加代码的灵活性
    • 在定义时传入的参数是形参，只能在函数体内部使用
    • 在调用的时候传入的参数是实参，可以传入到函数体内部被形参接收
# 定义一个eat方法,通过传入不同的参数,可以输出不同的生物吃不同的食物def eat_cat():print('猫吃鱼')def eat_dog():print('狗吃肉')def eat_person():print('人吃藕')# 上述函数定义方法不太方便,因为如果有更多的生物去吃不同的东西,就要重复书写函数不利于函数的复用# 改进 >> 传参
# 通过传入参数,可以控制函数体内部的执行结果发生变化,让函数更加灵活
def eat(who, food):  # 在定义时传入的参数叫做形参,只能在函数体内部使用print(f'{who}吃{food}')# 在调用的时候传入的参数叫做实参,会传入到函数内部被形参接收
eat('猫', '🐟')
eat('狗', '肉')
eat('人', '藕')# TypeError: eat() missing 1 required positional argument: 'food'
# 进行传值时需要保证传参数量满足要求,否则会报错
# eat('人')

6.6、函数返回值

  • 1.返回值是将函数内计算或运行的结果返回到函数外部调用位置,参与计算或运行
  • 2.函数可以不写返回值或者只写一个return不写返回值内容,都会默认返回一个None
  • 3.return后将会立即跳出函数,如果在retrun后仍有代码,则不会被执行
  • 4.return只能返回一个元素,如果想返回多个元素需要使用容器类型
# 返回值:将函数体内部运行或计算得到的数据传递到函数体外部# def sum(a, b):
#     print(a + b)
#
#
# sum(1, 2)# 思考?如果我们想在函数体外部使用这个结果进行二次运算我应该怎么做?
# NameError: name 'a' is not defined  a, b 是形参,只能在函数体内部使用
# print(a + b)# 如果我们想将数据传递出来可以使用return
def sum1(a, b):return a + bprint(sum1(1, 3))  # 当函数执行完毕,函数调用位置就替换为函数的返回值
# 返回的数据可以参与计算
print(sum1(1, 3) + 12)
# 注意:返回值内容不会自动打印到控制台,将数据返回后如果想要查看数据需要手动打印或者debug调试# 如果没有return 那么就没有返回值么?
list1 = [1, 2]
# 因为此处,append方法,没有返回值,默认返回None
print(list1.append(3))  # Nonedef eat():print('猫吃鱼,狗吃肉,奥特曼吃小怪兽')# 如果没有书写返回值,则返回值为None
print(eat())  # None# 如果只写了return 没有写返回值内容会怎么样?  Nonedef sum1(a, b):print(a + b)returnprint(sum1(1, 2))  # None# return 执行后会跳出函数,return之后的所有代码将不会继续执行
# 在函数中可以有多个return 但是只能执行一个
def function():print('hello python')returnreturn# 同一分支中,在return之后的所有代码不会被执行print('hello bigdata')function()# 返回值只能是一个么?  可以返回多个返回值么?
# 返回值只能是一个元素,如果要返回多个值只能通过容器类型进行打包
def function1():return 1, 2, 3, 4
print(function1())  # (1, 2, 3, 4)# 结论:
'''
1.返回值是将函数内计算或运行的结果返回到函数外部调用位置,参与计算或运行
2.函数可以不写返回值或者只写一个return不写返回值内容,都会默认返回一个None
3.return后将会立即跳出函数,如果在retrun后仍有代码,则不会被执行
4.return只能返回一个元素,如果想返回多个元素需要使用容器类型
'''

6.7、函数的嵌套

  • 在一个函数体内部嵌套了另一个函数的调用
# 函数的嵌套,就是在一个函数的内部嵌套了另一个函数的调用def function2():print('我是func2-----')function1()print('我是func2-----')def function1():print('func1执行开始')print('func1执行结束')# def function2():
#     print('我是func2-----')
#     function1()
#     print('我是func2-----')function2()# 执行顺序,只要函数在调用之前被定义即可,定义函数的顺序不做规定

6.8、局部变量和全局变量

  • 局部变量就是在函数体内部进行定义函数体外部无法调用的变量
  • 全局变量就是在函数体外部，一般在文件顶格处书写，函数体内外都可以使用的变量
  • if 和for结构中的控制语句中定义的变量都是全局变量
# 全局变量就是在函数体外部书写的一般要在文件内顶格书写,在函数体内部外部都可以调用的变量
a = 1
b = 2def sum1():# 函数体内部可以使用print(a + b)sum1()
# 函数体外部也可以使用
print(a)
print(b)# for 循环中,  if 分支中创建的变量是全局变量还是局部变量呢? 全局变量
# for i in range(10):
#     pass
#
# print(i)
#
# if True:
#     c = 1
# print(c)

6.9、gloal

  • global能声明我们当前使用的变量是全局变量
  • LEGB原则
    • L：在函数体内部查找
    • E：在外层函数中查找
    • G：在全局变量中查找
    • B：在内置变量中查找
# global  全局  :作用就是声明我要使用的这个变量是全局变量# 如果要在函数体内修改全局变量,就要使用global
a = 100# 此处,使用a=1相当于再函数体内定义了一个局部变量,并没有修改全局变量的值
# def func1():
#     a = 1
# 如果想要在函数体内修改全局变量就要使用global
# def func1():
#     global a
#     a = 1
#
# func1()
# print(a)# 扩展:  在Python中所有的变量查询遵循legb原则
# 调用变量时的查询顺序
'''
L:local :首先在函数体内部查询
E:edge :在外部函数中查询
g:global:在全局变量中查询
b:built-in:在系统内置变量中查询
'''
def func1():# L:我们再调用变量时,先在函数体内部查找a = 1print(a)
func1()def out_func():# E: 如果当前函数中没有此变量,我们将在外部函数中查找a = 2def in_func():print(a)in_func()out_func()def func2():# 如果函数体内部和外部函数中都没有该变量,则去全局变量中查找print(a)func2()# 当这个函数在函数体内部,外部函数中,全局变量中都不存在时, 则去内置变量中查找
print(__name__) # __main__def func3():# a = a + 10# 首先用a + 10 进行计算,根据legb原则先从函数体内部查找,查找后发现a 在函数体内部定义,但是在调用时未定义则报错# a += 10# print(a)a = 1def func4():# SyntaxError: name 'a' is assigned to before global declaration# 如果要对全局变量进行修改,则先对变量进行global修饰,在修改,否则报错a = 15# global a
func4()
print(a)# 能否在函数体内部创建全局变量  可以 只要用global修饰即可
def func5():global num1num1 = 105func5()
print(num1)

6.10、函数参数进阶

  • 位置参数：直接书写参数名，在传值时顺序传值，调用时既不能多传参，也不能少传参（形参）
  • 关键字参数：使用”参数名 = 值“的形式进行传参（实参）
    • 可以不按顺序赋值
    • 必须在顺序赋值之后完成赋值
  • 缺省参数：在定义函数时，给参数一个默认值，如果调用时，不给其传参，则使用默认值，如果传参，则使用传入的值
# 位置参数:按照位置顺序进行赋值的参数(形参)def func(a, b, c, d):print(a)print(b)print(c)print(d)# TypeError: func() missing 1 required positional argument: 'd'
# 如果有位置参数没有被赋值,则报错
# func(1, 2, 3)# TypeError: func() takes 4 positional arguments but 5 were given
# 如果位置参数传参过多也会报错
# func(1, 2, 3, 4, 5)
# 结论:位置参数在使用时需要保证每个参数都被赋值,且不要重复赋值或赋多个值
# 在为位置参数顺序赋值时,所有的参数按序赋值给每个位置参数
func(1, 2, 3, 4)# 关键字参数 : 关键字参数就是通过"参数名 = 值"的形式进行赋值的参数(实参)def func(a, b, c, d):print(a)print(b)print(c)print(d)# 使用关键字参数,不需要按照顺序赋值,只要参数名称正确即可
func(d=4, a=1, c=3, b=2)# 使用参数=值的形式赋值,就是关键字参数
# func(a=1, b=2, c=3, d=4)
# TypeError: func() got an unexpected keyword argument 'f'
# 使用关键字参数赋值时,要注意所使用的参数是否存在,最好是提示出来在用
# func(f=1, b=2, c=3, d=4)
# 注意:使用关键字参数要防止重复赋值
# TypeError: func() got multiple values for argument 'a'
# func(1,2,3,a=5)
# 一般情况下,关键字参数都是给默认参数(缺省参数)赋值的# 缺省参数:就是在定义时给参数一个默认值,如果参数没有赋值,则使用默认值
def func(a, b, c, d=10):print(a)print(b)print(c)print(d)# 不给缺省参数传值则使用默认值
# func(1, 2, 3)
# 给缺省参数传值则使用传入的值
# func(1, 2, 3, 4)# 一般使用关键字参数给缺省参数赋值
# func(1, 2, 3, d=12)
# 关键字参数赋值,不能在顺序赋值之前
# func(d=12,1, 2, 3)

6.11、不定长参数

  • 位置不定长参数（*args）：多余的位置参数，可以被args接收,并且打包为一个元组，保存在args当中。
# 不定长参数主要就是在定义函数时,不确定参数的个数时即可进行不定长参数的书写'''
位置不定长参数的定义格式:
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 = ireturn max_numprint(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='男')

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

  • 形参： 位置参数》》位置不定长参数》》缺省参数》》关键字不定长参数
  • 实参：顺序赋值》》关键字参数赋值
  • 在开发中除非有特殊需求，一般参数种类不超过三种，参数个数不超过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)# 结论,调用参数时,先使用顺序赋值,后使用关键字赋值

6.13、组包和拆包

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

6.14、引用

  • 数据的三个维度：值， 数据类型，唯一标识
    • 值： 数据计算时使用的值
    • 数据类型：数据的存储类型
    • 唯一标识：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

6.15、可变类型和不可变类型

  • 可变类型：内存空间中的数据可以被修改的数据类型
    • 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.16、引用当做参数传递

  • 在函数传参过程中，变量会以引用的形式进行传参，也就是说我们的变量或参数传递是引用传递，不是值传递
    • 如果参数是可变数据类型，那么在函数内修改其引用地址指向空间内的数据，外部数据同时发生变化
    • 如果参数是不可变数据类型，其实也是引用传递，只不过引用地址指向的数据空间中的数据无法被修改
# 将数字1所在空间的引用地址赋值给了a
# a = 1
# 将a所保存的引用你地址给了b
# b = adef func(num_list):print(id(num_list))  # 140490414045760num_list.append(2)return num_list# 在进行参数传递时,是进行了地址传递,将list1 的引用地址传递给了num_list,num_list 修改内存空间中的数据时,list1,也会发生变化
list1 = [1, 2, 3, 4]# print(id(list1))  # 140490414045760
# print(func(list1))
# print(list1)def func2(num_list):print(id(num_list))  # 140326362233472# 无论什么情况下,使用=赋值运算,就是讲等号右侧数据的引用地址,赋值给等号左侧的变量num_list = [1, 2, 3, 4, 5]print(id(num_list))  # 140466340833664return num_listprint(id(list1))  # 140326362233472
print(func2(list1))  # [1, 2, 3, 4, 5]
print(list1)  # [1, 2, 3, 4]# 不可变数据类型
def func1(char1):print(id(char1))  # 140228523715632# 不可变数据类型,在进行参数传递时,也是引用传递,但是他无法修改原有数据空间内的数据,如果想要修改只能改变引用地址,重新赋值(只有=才有改变引用的功能)char1.replace('a', 'b')return char1str1 = 'abc'
print(id(str1))  # 140228523715632
print(func1(str1))  # abc
print(str1)  # abc

6.17、学生管理系统

# 需求拆分:
'''
1.展示学生管理系统的功能有哪些,引导用户键入序号选择功能
2.获取用户键入的功能
3.分析具体要执行哪一项功能
4.执行功能
'''def print_all_option():"""用户功能界面展示"""print('-' * 20)print('欢迎登录学员管理系统')print('1: 添加学员信息')print('2: 删除学员信息')print('3: 修改学员信息')print('4: 查询学员信息')print('5: 遍历输出所有学员信息')print('6: 退出系统')print('-' * 20)def choose_option(num):"""分析要执行哪一项功能"""if num == '1':# 添加学员函数add_student_info()elif num == '2':# 删除学员函数delete_student_info()elif num == '3':# 修改学员函数modify_student_info()elif num == '4':# 查询学员函数search_student_info()elif num == '5':# 展示所有学员函数show_students_info()elif num == '6':# 退出程序函数exit_program()else:print('无此选项,请重新输入')def add_student_info():"""添加学员信息"""# 1.用户输入学员信息# 1.1当用户输入的id值已经存在时,则不让其继续输入,警告,该id已经存在stu_id = input('请输入要添加学员的id:')# 获取students_list中所有学员的id值(推导式)students_id = [i['id'] for i in students_list]# 1.2 比对id是否存在,存在则不允许运行if stu_id in students_id:print('该id值已经存在,无法添加学员')else:name = input('请输入要添加学员的姓名:')age = input('请输入要添加学员的年龄:')mobile = input('请输入要添加学员的手机号:')# 2.将学员信息添加到students_list当中students_list.append({'id': stu_id, 'name': name, 'age': int(age), 'mobile': mobile})print('学员添加完成')def delete_student_info():"""删除学员信息"""# 1.获取要删除学员的id值stu_id = input('请输入要删除学员的id:')# 2.判断该学员是否存在,如果存在则删除该学员,如果不存在,则提示该学员不存在for stu_info in students_list:# 判断是否是要删除的学员if stu_info['id'] == stu_id:# 删除学员并跳出函数students_list.remove(stu_info)print('该学员已删除')returnelse:# 执行该命令警告用户没有该学员print('该学员不存在,无法删除')def modify_student_info():"""修改学员信息"""# 1.输入要修改的学员的id值stu_id = input('请输入您要修改学员的id:')# 2.如果学员存在就修改学员信息,如果不存在则进行提示,学员不存在for stu_info in students_list:if stu_info['id'] == stu_id:# 学员信息修改name = input('请输入您要修改为的名字:')age = input('请输入您要修改为的年龄')mobile = input('请输入您要修改为的手机号:')stu_info['name'] = namestu_info['age'] = agestu_info['mobile'] = mobileprint('学员信息修改完成')returnelse:print('该学员不存在,修改失败')def search_student_info():"""查询学员信息"""# 1.输入要查询学员的id值stu_id = input('请输入要查询学员的id:')# 2.判断id值是否存在,如果存在则展示,如果不存在,则警告学员不存在for stu_info in students_list:if stu_info['id'] == stu_id:print(f'学员的学号是:{stu_info["id"]}, 学员的姓名是:{stu_info["name"]}, 学员的年龄是:{stu_info["age"]}, 学员的手机号是:{stu_info["mobile"]}')returnelse:print('该学员不存在,查询失败')def show_students_info():"""展示所有学员信息"""for stu_info in students_list:print(f'学员的学号是:{stu_info["id"]}, 学员的姓名是:{stu_info["name"]}, 学员的年龄是:{stu_info["age"]}, 学员的手机号是:{stu_info["mobile"]}')# def exit_program():
#     # import sys
#     # # 退出当前程序,结束进程
#     # sys.exit()
#     exit()def exit_program():"""结束程序"""# 通过控制变量结束死循环global is_stop# 在修改之前需要进行声明 ,修改的变量为全局变量is_stop = True# # 展示功能界面
# print_all_option()
#
# # 引导用户输入功能序号,并获取序号
# option = input('请输入您要执行功能的序号:')
#
# # 根据获取的序号分析要执行哪些功能
# chose_option(option)# 思考:学生管理系统,是不是需要输入6  才能退出 不然就一直询问您要输入的选项
# 这中情况下建议使用 while True 构造死循环students_list = [{'id': '001', 'name': 'xiaoming', 'age': 18, 'mobile': '13833838338'},{'id': '002', 'name': 'xiaohong', 'age': 18, 'mobile': '13900000000'}
]
is_stop = Falsewhile not is_stop:# 展示功能界面print_all_option()# 引导用户输入功能序号,并获取序号option = input('请输入您要执行功能的序号:')# 根据获取的序号分析要执行哪些功能choose_option(option)# 方便展示,显示所有学员信息,开发完成后删除# print(students_list)input()# 死循环的退出方式有哪些?
# break
# return
# exit()
# 控制变量
...

6.18、函数递归

  • 函数内部调用函数本身
  • 函数有明确的递归跳出条件
  • 不超出最大调用深度
# 函数递归的三个必备条件
'''
1/函数体内部,调用函数本身
2/递归够明确的跳出条件
3/不能超出最大调用深度
'''# 需求:
'''
func(1) = 1
func(2) = 1 + 2 = func(1) + 2
func(3) = 1 + 2 + 3 = func(2) + 3
func(4) = 1 + 2 + 3 + 4 = func(3) + 4
.....
func(n) = 1 + 2 + 3 .... + n = func(n-1) + n
'''# RecursionError: maximum recursion depth exceeded
# 这种方式无法跳出递归,所以在使用的时候就会无限递归下去
# def func(n):
#     return func(n-1) + n'''
func(1) = 1
func(2) = func(1) + 2
func(3) = func(2) + 3
func(4) = func(3) + 4
.....
func(n) = func(n-1) + n
'''def func(n):if n == 1:return 1return func(n-1) + nprint(func(999))# Python中默认的最大调用深度,是1000 也就是在Python中函数最多嵌套1000层
# 最大调用深度是为了保证系统性能的,否则无限递归下去,一会内存就满了
# 最大调用深度可以调整,可以调整到非常大的数字只要系统性能跟得上
# RecursionError: maximum recursion depth exceeded in comparison# 注意事项:
# 在编程初期,尽量少使用递归,但是要理解递归的特性,别人写的递归函数也要能看懂

6.19、lambda函数

  • 匿名函数，在函数定义时没有函数名
  • 可以用变量保存，在变量之后添加括号即可调用
# lambda表达式,也叫匿名函数
# 格式: lambda 参数: 返回值# 需求: 根据传入的参数返回最大值  使用lambda函数书写
# 三目运算  :  条件成立时返回的代码 if 条件 else 条件不成立时返回的代码
max_num = lambda a, b: a if a > b else b
# 使用变量可以储存lambda函数
print(max_num(1, 2))
print(max_num(9, 2))print(type(max_num))  # <class 'function'>def func():print('abc')print(type(func))  # <class 'function'>
# 通过对数据类型的查看,我们发现lambda和普通函数本质上是一样的,只不过在使用时构造更为简单# 在使用lambda函数时可以不用变量接收
print((lambda a, b: a if a > b else b)(3, 4))  # 4
# 但是不适用变量接收,lambda函数只能使用一次,使用后集被释放,无法再次使用# lambda缺点: 没有办法书写负责的函数,因为其没有函数体,只有返回值,所以返回值后边只能书写一个表达式,lambda可读性极差# 使用lambda完成递归(了解,一般不建议写复杂的代码)
func1 = lambda n: func1(n - 1) + n if n != 1 else 1
# RecursionError: maximum recursion depth exceeded
# 超出最大调用深度,没有明确的递归跳出条件
print(func1(100))# lambda应用场景
# 可以用于一次性函数使用
# 可以作为函数的参数进行传递# list  sort(key= )
# lsit sort排序方法中的key所需要的参数就是一个函数,我们可以传入lambda表示list1 = [{'a': 1}, {'b': 12}, {'c': 10}]
# 排序规则:根据字典的第一个键所对应的值进行排序list1.sort(key=lambda x:list(x.values())[0])
# 格式: 列表.sort(key = lambda 每次传入的元素: 排序所依据的规则)
print(list1)

第七章文件的操作

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/233187.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

自助借还办证一体机软件需求说明书

自助借还办证一体机软件需求说明书

1. 简介 1.1 项目概括 本项目主要实现读者自助办证、借书、还书、查询、续借的功能&#xff0c;减轻管理员的工作量&#xff0c;提升读者的借阅体验&#xff0c;提高了图书的借阅量与流通率&#xff0c;是图书馆智能化、无人化建设的重要步骤。 1.2 项目背景 ​ 目前各大图…
阅读更多...
WEB渗透—PHP反序列化（四）

WEB渗透—PHP反序列化（四）

Web渗透—PHP反序列化 课程学习分享&#xff08;课程非本人制作&#xff0c;仅提供学习分享&#xff09; 靶场下载地址&#xff1a;GitHub - mcc0624/php_ser_Class: php反序列化靶场课程&#xff0c;基于课程制作的靶场 课程地址&#xff1a;PHP反序列化漏洞学习_哔哩…
阅读更多...
使用 React 实现自定义数据展示日历组件

使用 React 实现自定义数据展示日历组件

目录 背景实现日历组件父组件数据 效果最后 背景 项目中需要实现一个日历组件&#xff0c;并且需要展示月&#xff0c;日所对应的数据&#xff08;因为项目需求问题&#xff0c;就不统计年数据总量&#xff09;。网上找了一堆&#xff0c;基本都不大符合项目需求&#xff0c;且…
阅读更多...
OpenHarmony鸿蒙原生应用开发，ArkTS、ArkUI学习踩坑学习笔记，持续更新中。

OpenHarmony鸿蒙原生应用开发，ArkTS、ArkUI学习踩坑学习笔记，持续更新中。

一、AMD处理器win10系统下&#xff0c;DevEco Studio模拟器启动失败解决办法。 结论&#xff1a;在BIOS里面将Hyper-V打开&#xff0c;DevEco Studio模拟器可以成功启动。 二、ArkTS自定义组件导出、引用实现。 如果在另外的文件中引用组件&#xff0c;需要使用export关键字导…
阅读更多...
3ds max软件中的一些常用功能分享！

3ds max软件中的一些常用功能分享！

3ds max软件有很多小伙伴反馈说&#xff0c;明明有很多3ds max教程资料。却不知道如何入门3dmax。 掌握3dmax基本功能是开始使用3dmax的基础之一&#xff0c;所以&#xff0c;小编带大家盘点一下3dmax常用操作。 3dmax常用功能介绍如下&#xff0c;快快跟着小编一起看起来。 1…
阅读更多...
预测性维护在汽车制造行业中的应用

预测性维护在汽车制造行业中的应用

汽车制造行业是一个高度复杂和精细化的领域&#xff0c;依赖于各种设备来完成生产流程。这些设备包括机械装配线、焊接机器人、喷涂设备、传送带等。然而&#xff0c;这些设备在长时间运行中不可避免地会遇到各种故障&#xff0c;给生产进程带来延误和成本增加。为了应对这一挑…
阅读更多...
可变参数详解

可变参数详解

概述 可变参数用在形参中可以接收多个数据。 可变参数的格式&#xff1a;数据类型...参数名称。 可变参数在方法内部本质上就是一个数组。 可变参数的作用 传输参数非常灵活&#xff0c;方便。可以不传输参数&#xff0c;可以传输1个或者多个&#xff0c;也可以传输一个数…
阅读更多...
61道MyBatis高频题整理(附答案背诵版)

61道MyBatis高频题整理(附答案背诵版)

1、介绍下MyBatis? MyBatis是一个基于Java的持久层框架&#xff0c;它封装了底层的JDBC操作&#xff0c;大大简化了数据库操作的复杂性。MyBatis的主要特点包括&#xff1a; SQL语句与Java代码的分离&#xff1a;MyBatis允许你直接在XML文件中编写SQL语句&#xff0c;这样可以…
阅读更多...
LeetCode Hot100 79.单词搜索

LeetCode Hot100 79.单词搜索

题目&#xff1a; 给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中&#xff0c;返回 true &#xff1b;否则&#xff0c;返回 false 。 单词必须按照字母顺序&#xff0c;通过相邻的单元格内的字母构成&#xff0c;其中“相邻”单元格是那…
阅读更多...
快速幂算法C++

快速幂算法C++

快速幂算法C 一个简单例子快速了解例题代码 一个简单例子快速了解 计算 2的13次方&#xff0c;首先&#xff0c;我们将指数13转换为二进制形式&#xff0c;得到1101。 然后&#xff0c;我们从右到左遍历每一位&#xff1a; 第一位是1&#xff0c;所以我们将结果乘以 2的20次…
阅读更多...
鸿蒙（HarmonyOS）项目方舟框架（ArkUI）之Button按钮组件

鸿蒙（HarmonyOS）项目方舟框架（ArkUI）之Button按钮组件

鸿蒙&#xff08;HarmonyOS&#xff09;项目方舟框架&#xff08;ArkUI&#xff09;之Button按钮组件 一、操作环境 操作系统: Windows 10 专业版 IDE:DevEco Studio 3.1 SDK:HarmonyOS 3.1 二、Button按钮组件 Button 组件也是基础组件之一&#xff0c;和其它基础组件不…
阅读更多...
metric和log

metric和log

Metric&#xff08;指标&#xff09;和 Log&#xff08;日志&#xff09;是两种不同的监控数据类型&#xff0c;它们在监控和故障排查中有不同的用途和特点。 Metric&#xff08;指标&#xff09;: 定义&#xff1a; Metric 是定量的度量&#xff0c;通常是数值或计数&#xf…
阅读更多...
鸿蒙开发之数据持久化存储Preferences

鸿蒙开发之数据持久化存储Preferences

用户首选项&#xff08;Preferences&#xff09;提供的是key-value键值对的方式处理数据。类似于iOS开发中的NSUserDefault&#xff0c;主要针对的是轻量化数据的存储。如&#xff1a;字体大小、用户的信息等。 其中&#xff0c;key为字符串类型&#xff0c;value是string、nu…
阅读更多...
Linux之grep、sed、awk

Linux之grep、sed、awk

目录 1.grep 2.sed 3.awk 1.grep grep 擅长过滤查找&#xff0c;按行进行过滤 例&#xff1a; 当有用户对我们的主机进行爆破攻击时&#xff0c;我们可以使用grep将 ip 查找出来&#xff0c;进行封锁等处理 在 /var/log 目录下的 secure 文件中存放在用户登录连接信息&am…
阅读更多...
信息搜集简要总结

信息搜集简要总结

信息搜集 一.遍历目录&#xff1a; ​ 可以使用dirsearch和御剑等目录扫描软件来进行目录遍历&#xff0c;得到一些信息&#xff0c;注意&#xff0c;有的时候扫不出来&#xff08;我使用dirsearch的时候经常出现扫不出来的时候&#xff0c;因此有的时候可以rce或者传马蚁剑连…
阅读更多...
自定义 springboot 启动器 starter 与自动装配原理

自定义 springboot 启动器 starter 与自动装配原理

Maven 依赖 classpath 类路径管理 Maven 项目中的类路径添加来源分为三类 自定义 springboot starter starter 启动器定义的规则自定义 starter 示例 自动装配 原文链接&#xff0c;点击跳转 — —
阅读更多...
自动化测试成本高效果差，意义在哪？

自动化测试成本高效果差，意义在哪？

自动化测试的成本高效果差&#xff1f;首先这个结论就太过武断了一些。 任何技术都需要放到适合的地方去使用&#xff0c;否则一定是达不到理想的效果的。举例大炮打蚊子&#xff0c;同样是成本高效果差&#xff0c;难道大炮就没有存在的意义了吗&#xff1f; 当然不是&#…
阅读更多...
ATKXCOM串口助手接受中文字符乱码问题

ATKXCOM串口助手接受中文字符乱码问题

中文乱码大多是编码格式问题&#xff0c;如心知天气API返回的数据编码格式为UTF-8格式&#xff0c;同理串口调试助手需要更改为对应的编码格式&#xff0c;正点原子的串口调试助手具有多种编码格式可以更改。 PS:点击左下角设置图标即可设置
阅读更多...
OpenAI发布AGI安全风险框架！董事会可随时叫停GPT-5等模型发布，奥特曼也得乖乖听话

OpenAI发布AGI安全风险框架！董事会可随时叫停GPT-5等模型发布，奥特曼也得乖乖听话

OpenAI 再次强调模型安全性&#xff01;AGI 安全团队 Preparedness 发布模型安全评估与监控框架&#xff01; 这两天关注 AI 圈新闻的小伙伴们可能也有发现&#xff0c;近期的 OpenAI 可谓进行了一系列动作反复强调模型的“安全性”。 前有 OpenAI 安全系统&#xff08;Safety…
阅读更多...
工业镜头常见的类型

工业镜头常见的类型

在机器视觉中&#xff0c;工业镜头作为机器视觉系统的核心部件&#xff0c;常常需要和工业相机搭配使用。工业镜头&#xff0c;属于一种光学系统。光学系统是指由透镜、反射镜、棱镜和光阑等多种光学元件按一定次序组合成的系统。那么工业镜头都有哪些类型&#xff1f; 一、按照…
阅读更多...
最新文章

Copyright @ 2022~2023