Python笔记9

综合代码案例

my_dict = {'登录':[{'desc':'正确的用户名密码','username':'admin','password':'123456','expect':'登录成功'},
                 {'desc':'错误的用户名','username':'root','password':'123456','expect':'登录失败'},
                 {'desc':'错误的密码','username':'admin','password':'123123','expect':'登录失败'},
                 {'desc':'错误的用户名和密码','username':'aaaa','password':'123123','expect':'登录失败'}],
           '注册':[{'desc':'注册1','username':'abcd','password':'123456'},
                 {'desc':'注册1','username':'xyz','password':'123456'}]}

# 自定义以下程序，实现如下要求：
# 能够获取测试人员输入的信息（登录/测试）
# 获取每组测试数据的用户名，密码和预期结果，组成以下的数据格式进行打印
# [(),(),()]或者[[],[],[]]
opt = input('请输入获取的数据（登录/注册）')
info_list = []
if opt =='登录':
    print('获取登录注册')
    for d in my_dict.get('登录'):
        # 需要将数据组成元组类型（定义元组）
        my_tuple = (d.get('username'),d.get('password'),d.get('expect'))
        # 需要将元组添加到列表中  append()
        info_list.append(my_tuple)
elif opt == '注册':
    print('获取注册数据')
    for d in my_dict.get('注册'):
        my_tuple = (d.get('username'),d.get('password'))
        info_list.append(my_tuple)
else:
    print('输入错误')
print(info_list)

列表去重

方式一：
思路：遍历原列表中的数据判断在新列表中是否存在，如果存在，不管，如果不存在放入新的列表中
遍历：for 循环实现
判断是否存在：可以 使用 in
存入数据：append()

方法二：
在python中还有一种数据类型（容器），称为是集合（set）
特点：集合中不能有重复的数据（如果有重复的数据会自动去重）
可以使用集合的特点对列表去重
1、使用set()类型转换，将列表转换为 集合类型
2、在使用list()类型转换将集合转换为列表

缺点：不能保证数据在原列表中出现的顺序（一般来说，也不考虑）

my_list = [1,2,3,3,2,1,2,3,1]
print(list(set(my_list))) # [1, 2, 3]

new_list = list(set(my_list))
print(new_list) # [1, 2, 3]


my_list = [1,2,3,3,2,1,2,3,1]
new_list = []
 for i in my_list:
     # 判断新列表中是否存在i
     if i in new_list:
         # 存在
         pass  # continue
     else:
         new_list.append(i)
print(new_list)  # [1, 2, 3]


my_list = [1,2,3,3,2,1,2,3,1]
new_list = []
for i in my_list:
    if i not in new_list:
        new_list.append(i)
print(new_list)  # [1, 2, 3]

函数基础

函数的参数

# 定义一个函数，my_sum,对两个数字进行求和计算  只能对10和20求和
def my_sum():
    num1=10
    num2=20
    num3=num1+num2
    print(num3)
my_sum()

函数的参数：在函数定义的时候，使用变量代替具体的数据值（进行占位），在函数调用的时候，传递具体的数据值
好处：让函数更加通用，能够解决以类问题

# num1和num2 是函数定义时候的参数，直到占位的作用，没有具体的数据值，称为形式参数，简称形参
def my_sum( num1 , num2):
    # 在什么时候定义参数，函数中使用的数据会会变化的时候，就可以定义为参数
    num3=num1+num2
    print(num3)       
# 在函数调用的时候，括号中的数据会传递给形参，是具体的数据值，称为实际参数，简称 实参
# 目前书写的函数，在定义的时候如果有形参，那么在调用的时候，必须传递实参值，个数要对应，否则会报错
my_sum(10,20) 
my_sum(1,1)

函数的返回值

函数的返回值，可以理解为函数整体执行的结果是什么
print() —> None
input() —>键盘输入的内容
tpye() —>类型
len() —>数据的长度（元素的个数）
在函数中想要将一个数据作为返回值返回，需要使用return 关键字（只能在函数中使用）
作用：
1、将数据值作为返回值返回
2、函数代码执行遇到return，会结束函数的执行

def my_sum(a,b):
    num = a+b
    # print(num) 代码中没有返回值，只有print，这个结果只能在函数中用一次，不能后续使用
    # 想要将这个求和结果在后续的代码中使用，需要使用return将求和的结果进行返回
    return num # 将这个结果返回到调用的地方
    # return 之后的代码是否执行
    print('return之后是否执行   执行/不执行')  # 不执行


# 1、函数中没有print，只有retyrn，想要查看结果，需要在调用的时候使用print
print(my_sum(1, 2))

# 2、想要将函数中返回的结果， 在后续代码中使用，即需要将这个数据保存下来，需要使用变量来接收（保存）函数的返回值（执行结果）
# 变量= 函数()
result = my_sum(10,20)
print('使用：1，直接打印:',result)
print('使用：2，对数字加10:',result+10)

• 返回值的说明

def 函数名(): # 返回值  None
	pass  # 代码中没有return
def 函数名():
	return # return 后边没有数据，返回值None
def 函数名():
	return XX # 返回值是XX

变量的引用

1、在定义变量的时候 变量= 数据值 ，python 解释器会在内存中开辟两块空间
2、变量和数据都有自己的空间
3、将数据保存到变量的内存中，本质是将数据的地址保存到变量对应的内存中
4、变量中存储数据地址的行为 就是引用（变量引用了数据的地址，简单的说就是变量中存储数据），存储的地址称为 引用地址
5、可以使用id()来获取变量中的引用地址（即数据的地址），如果两个变量的id()获取的引用地址一样，代表着两个变量引用了同一个数据，是同一个数据
6、只有赋值运算符 = ，可以改变变量的引用（等号左边数据的引用）
7、pyhon中数据的传递，都是传递的引用

a =1 # 将数据 1 的地址存到 a 对应的内存中
print(id(a)) # 140734898375096

b=a # 将变量 a 中的引用 保存到变量 b
print(id(b)) # 140734898375096

a =10 # 将数据 10 的地址保存到 a 对应的地址，即 a 的引用变了
print(id(a)) # 140734891035352
print(id(b)) # 140734898375096

可变类型和不可变类型

数据类型： int float bool str list tuple dict set
可变不可变是指：数据所在的内存是否允许修改，允许修改就是可变类型，不允许修改就是不可变类型（不适用 = ，变量引用的数据中的内容是否会变化，会变化是可变的，不会变化是不可变的）
可变类型：列表 list，字典dict，集合set
列表.append()
字典.pop(键)
不可变类型： int float bool str tuple

my_list = [1,2,3]
my_list1 = [1,2,3]

print('my_list:',id(my_list),id(my_list[1])) # 2345820688768 140735077681624
print('my_list1:',id(my_list1)) # 2345820690688

my_list[1] = 10 # 这里修改的是列表中下标为1的位置的引用
print(id(my_list),id(my_list[1]))  # 2345820688768 列表的引用没有发生变化 140735077681880
print(my_list) # [1, 10, 3]

# 元组中存储的是 1 的地址，2的地址，和列表的地址
my_tuple= (1,2,[3,4])
print(my_tuple,id(my_tuple[-1])) # (1, 2, [3, 4]) 2177234334016
# 元组中的数据不能改变，是值 这个三个地址不能改变
my_tuple[-1][0] =10 # 修改的是列表中下标为 0 的位置的引用地址，列表的地址没变，元组中的内容没有变化
print(my_tuple,id(my_tuple[-1])) # (1, 2, [10, 4]) 2177234334016

例题

交换两个变量的值

# 方法一：
# 常规方法 引入第三个变量
a=10
b=20
c = a
a = b
b = c
print(a,b)   # 20 10

# 方法二：
# 不使用第三个变量，使用数学中的方法
a=10
b=20
a = a + b  # a 的值为30
b = a - b  # b 的值为30-20=10
a = a - b  # a 的值为30-10=20
print(a,b) # 20 10

# 方法三：
# python特有
a=10
b=20
a,b = b,a
print(a,b) # 20 10

组包和拆包

组包（pack）:将多个数据值使用逗号连接，组成元组
拆包（unpark）:将容器中的数据值使用多个变量分别保存的过程，注意：变量的个数和容器中数据的个数要保持一致
赋值运算符，都是先执行等号右边的代码，执行的结果，保存到等号左边的变量中

a=10
b=20
# 组包
c = b , a #
print(type(c),c) # <class 'tuple'> (20, 10)
# 拆包
a,b =c
print(a,b) # 20 10

x , y ,z =[1,2, 3]
print(x,y,z) # 1 2 3

局部变量和全局变量

局部变量

局部变量：在函数内部（函数的缩进中）定义的变量，称为是局部变量
特点：
1、局部变量只能在当前函数内部使用，不能在其他函数和函数外部使用
2、在不同函数中，可以定义名字相同的局部变量，两者之间没有影响
3、生存周期（生命周期，作用范围）用在哪里
在函数被调用的时候，局部变量被创建，函数调用结束，局部变量的值被销毁（删除），不能使用
所以函数中的局部变量的值，如果想要在函数外部使用，需要使用return关键字，将这个值进行返回

def fun1():
    num =10 # num在函数里定义的，是局部变量
    print(f"fun1函数中{num}")

def fun2():
    num = 100 # 可以在不同函数中定义名字相同的局部变量，没用影响
    print(f"fun2函数中{num}")

# print(num) #会报错
fun1()   # fun1函数中10
fun2()  # fun2函数中100
fun1()  # fun1函数中10

全局变量

定义位置：在函数外部定义的变量，称为是全局变量
特点：
1、可以在任何函数中读取（获取）全局变量的值
2、如何在函数中存在和全局变量名字相同的局部变量，在函数中使用的是局部变量的值（就近）
3、在函数内部想要修改全局变量的引用（数据值），需要添加global关键字，对变量进行声明为全局变量
4、生命周期
代码执行的时候被创建，代码执行结束，被销毁（删除）

g_num =10 # 全局变量
def fun1():
    print(f"fun1函数中{g_num}") # 在函数中可以读取全局变量的值

def fun2():
    g_num= 20 # 定义局部变量，不会影响全局变量
    print(f"fun2函数中{g_num}")

def fun3():
    global  g_num # 这个函数中使用的g_num，都是全局变量  写在函数的第一行
    g_num =30  # 这里修改了全局变量
    print(f"fun3函数中{g_num}")

fun1() # fun1函数中10
fun2() # fun2函数中20
fun1() # fun1函数中10
fun3() # fun3函数中30
fun1() # fun1函数中30
#print(g_num)  # 10 没有调用，所以还是原始数据

函数进阶

返回值-函数返回多个数据值

函数中想要返回有个数据值，使用return 关键字
将 多个数据值组成容器进行返回，一般是元组（组包）

def calc(a,b):
    num = a+b
    num1 = a-b
    return num,num1

# 写法一：
result = calc(10,5)
print(result,result[0],result[1]) # (15, 5) 15 5

# 写法二，直接拆包：
x,y=calc(20,10)
print(x,y) # 30 10

函数参数

• 位置传参
  在函数调用的时候，按照形参的顺序，将实参值传递给形参
• 关键字传参
  在函数调用的时候，指定数据值给到那个形参
• 混合使用
  1、关键字传参必须写在位置传参的后面
  2、不要给一个形参传递多个数据值

def func(a,b,c):
    print(f'a:{a},b:{b},c:{c}')


# 位置传参
func(1,2,3) # a:1,b:2,c:3

# 关键字传参
func(a=2,b=3,c=1) # a:2,b:3,c:1

# 混合使用   其中关键字传参只能放在末尾
func(1,3,c=6) # a:1,b:3,c:6

缺省参数

缺省参数，默认参数
列表.pop() # 不写参数，删除最后一个
列表。sort(reverse=True)

1、定义方式
在函数定义的时候，给形参一个默认的数据值，这个形参就变为缺省参数，注意，缺省参数的书写要放在普通参数的后边
2、特点（好处）
缺省参数，在函数调用的时候，可以传递实参值，也可以不传递实参值
如果传参，使用的就是传递的实参值，如果不传参，使用的就是默认值

def show_info(name,sex='保密'):
    print(name,sex)
show_info('张')  # 张 保密   不传参
show_info('张','男') # 张 男   传参

多值参数（可变参数/不定长参数）

print(1)
print(1,2)
print(1,2,3)
print(1,2,3,4)

不确定参数的具体个数时，可以使用 不定长参数

• 不定长位置参数（不定长元组参数）
  1、书写，在普通参数的前边，加上一个 * ，这个参数就变为不定长位置参数
  2、特点，这个形参可以接受任意多个 位置传参的数据
  3、数据类型，形参的类型是 元组
  4、元组，不定长位置参数，要写在普通的参数的后面
  5、一般写法，不定长位置参数的名字为 args，即(*agrgs) # arguments
• 不定长关键字参数（不定长字典参数）
  1、书写，在普通参数的前边，加上两个*，这个参数就是变为不定长关键字参数
  2、特点，这个形参可以接收任意多个关键字传参的数据
  3、数据类型，形参的类型是字典
  4、注意，不定长关键字参数，要写在所有参数的最后边
  5、一般写法，不定长关键字参数的名字为kwargs，即（**kwargs）,keyword arguments
• 完整的参数顺序

  def 函数名(普通函数, *args,缺省参数,**kwargs):
  	pass
  # 一般在使用的时候，使用1-2种，按照这个这个顺序书写即可
  

  def func(*args,**kwargs):
      print(type(args),args)
      print(type(kwargs),kwargs)
      print('-'*30)
  
  
  func()
  # <class 'tuple'> ()
  # <class 'dict'> {}
  
  # 位置传参，数据都给args
  func(1,2,3)
  # <class 'tuple'> (1, 2, 3)
  # <class 'dict'> {}
  
  # 关键字传参，数据都给kwargs
  func(a=1,b=2,c=3)
  # <class 'tuple'> ()
  # <class 'dict'> {'a': 1, 'b': 2, 'c': 3}
  
  func(1,2,3,a=4,b=5,c=6)
  # <class 'tuple'> (1, 2, 3)
  # <class 'dict'> {'a': 4, 'b': 5, 'c': 6}
  

print函数

# print()
# sep=' ' 多个位置参数之间的间隔
# end ='\n'  每一个print 函数结束，都会打印的内容 结束符
print(1,end=' ')
print(2,end=' ')
print(3)
print(1,2,3,4,5,6,sep=' ')
print(1,2,3,4,5,6,sep='_')
# 1 2 3
# 1 2 3 4 5 6
# 1_2_3_4_5_6