多测师_讲解python__004 函数

# 函数：一个工具，随调随用

# 　　降级代码冗余
#
# 　　增加代码的复用性，提高开发效率，为了不成为cv战士
#
# 　　提高程序扩展性
#
# 函数有两个阶段：定义阶段，调用阶段。
#
# 定义时：只检查函数体内代码语法，不执行函数体内代码。



# python 中的函数
# 如何定义一个函数(自定义函数)
# def 来定义一个函数
# def 函数名称+英文的小括号()+英文的冒号结尾:
#     一个tab键就是4个小空格
#     叫函数体
# 如何实现对函数的调用，来引用函数体中的代码
# ：函数调用函数体通过函数自己调用自己本身，函数调用函数自己(名称)

# 自定义一个函数：
# def fun(): #定义一个函数名称叫：fun  函数名称可以自定义
#     pass #函数体
#
# fun() #函数来调用函数自己本身来得到函数体中的结果


# 3、#函数参数：
#参数分形参、实参
#形参：函数定义时括号内的参数
#实参：函数调用时括号内的参数
#形参相当于变量，实参相当于变量的值。
#定义时:
#def func(a, b, c):
#pass
#a, b, c为形参
#调用时：
#func(1, 2, 3)
#1, 2, 3 为实参
#形参：
#只在被调用时，才分配内存单元。调用结束，立刻释放所分配的内存。
#形参只在函数内部有效。

# 实参：
# 可以是：常量、变量、表达式、函数。
# 进行函数调用时，实参必须是确定的值。

# 位置参数：
# 　　位置形参：函数定义时，从左往右写的参数，比如上面的 a, b , c
# 　　位置实参：函数调用时，从左往右写的参数,  比如上面的 1，2，3
# 　　位置形参定义多少个，调用时位置实参必须写上多少个，多一个少一个都不行。
# 关键参数：
# 　　正常情况下，给函数传参数，要按顺序。如果不想按顺序，就用关键参数。
# 　　指定参数名的参数，就叫做关键参数。
# 　　函数调用时：func(a=1, b=2),  这种指定了参数名的参数，就是关键参数。
# 　　调用函数时，关键参数可以和位置参数一起用，但是关键参数必须在位置参数的后面。不然会报错。
# 默认参数：
# 　　函数定义时，默认参数必须在位置形参的后面。
# 　　函数调用时，指定参数名的参数，叫关键参数。
# 　　而在函数定义时，给参数名指定值的时候，这个参数叫做默认参数。
# 　　关键参数，和默认参数两个参数写法一样，区别在于：
# 　　　　关键参数是在函数调用时，指定实参的参数名，也可以说指定值的参数名。
# 　　　　默认参数是在函数定义时，指定参数名的值。
# 　　写法：
# 　　　　def (a, b=100):
# 　　　　　　pass
#
#
#
# 函数中无参数： def func()
#  函数体 func()
# #调用函数
# #如：
# #print('nihao')
# #def fun1(): #定义一个函数名称叫：fun1
# #     print('hello!!!') #函数体中输出一个值
# # fun1() #函数调用函数自己 hello!!!
#
# #函数中有单个参数
# # def func(name):
# #     print ("欢迎"+name+"来到多测师")
# # func("大家")
# # # #调用函数
#
#
# #、函数中有多个参数
# # def func(action,name):
# #     print (action+name+"来到多测师")
# # func("欢迎","大家") #调用函数
#
#
# #函数定义时带上默认参数（缺省参数）
# def func(action,name,where="多测师"):
#     print(action+name+"来到"+where)
# func("欢迎","大家")
# # #调用函数未给默认参数传新值，则函数使用默认值
# func("欢迎","大家","宝安多测师")
# # #调试函数给默认参数传新值，则函数使用新值
# 注意：当多种参数同时出现在函数中，默认参数要放在最后的位置


# # 给当前函数赋予参数:形式参数
# def fun(name,age):
# #         # name和age表示为形式参数
#    print(name,age) #引用当前函数中的形参
#     # pass
# fun('张三',18)
# name='张三'
# age=18
# print(name,age)
# #如当前函数中有赋予形式参数，在函数调用处需要给与对应形参
# # 赋予对应的实参
# # 当前函数有多少个形参则需要赋予对等对应形参的实参
# # 赋予实参后如在当前函数体中没有引用形参，那么赋予的实参也不会实现输出
#
# def fun1(name='张三'): #定义一个函数，形参赋予实参
#     # print(name)
#     pass
# fun1() #张三 函数调用函数自己本身
# # 在函数中直接给与形参赋予实参，在函数调用函数本身的时候不需要赋予实参
#
# def fun2(name='张三',age='18岁了'):
#         print(name,age) #张三 18;
#         print(name+age) #37
#         print(name+age) #张三18岁了
# #     # 两两相加是需要注意类型：必须相同的类型才可以
# fun2()
#
# def fun(name): #定义一个函数
#    print(name) #打印参数
# fun('zhangsan') #函数调用函数本身且赋予对应形参对应的值
# # 不能超过对应函数中定义的形参个数也不能少于，否则会出现报错

# def fun1():
#     print('name')
#
# if __name__ == '__main__':
#     fun1()   #显示结果name

# 在函数中可变长元组和可变长字典的引用
# 可变长的元组：*
# 可变长字典：**
# def fun(name): #定义一个函数赋予一个形参
#     print(name)
# fun(1) #调用函数赋予对应的一个形参对应的实参
# #结果是1
#
# def fun1(*name): #定义一个函数形参类型通过*号改变为可变长元组
#     print(name)
#     print(type(name)) #<class 'tuple'>元组的类型
# fun1(1,2) #函数调用时可以赋予对应形参多个实参
# 结果为：(1, 2)

#案例2
def func(*name):
    for i in name:
        print (i)
func("duoceshi","dcs","xiaowang")

# '''可变长定义：定义一个可变长元组后，函数调用处
# 可以给当前可变长形参赋予N个实参
# 如没有定义是可变长元组：在函数调用处只能给对应形参对应个数的具体
# 实参'''

# def fun2(**name): #可变长字典
#     print(name)
# fun2()
# '''可变长类型定义后：在函数调用处可以不用赋予实参
# 如不是可变长则需要赋予实参'''

# def fun(**name):
#     print(name) #{}
#     print(type(name)) #<class 'dict'>
# fun()

# def fun1(**name): #定义一个函数 形参定义为可变长字典类型
#     print(name) #打印字典
# if __name__ == '__main__':
#     fun1(name='zhangsan',age=18) #{'name': 'zhangsan', 'age': 18}
# # def fun2(**name): #定义一个函数
#     for i in name.items():
#         print(i) #打印参数
# di_ct={'name':'张三','age':18} #在函数体中定义一个字典
# # # 函数调用函数本身来引用函数体中的定义字典
# fun2(**di_ct) #{'name': '张三', 'age': 18}


# 如果当前函数中同时出现可变长元组和可变长字典：
# 元组一定是放在字典的前面
# def fun(a,**name,c):
#     '''
#     如当前函数中定义的是可变长字典：那么在字典后后面不能在
#     定义普通的形参变量，也不能在后面定义可变长的元组
#     当前函数中定义的是一个可变长元组：那么在元组的后是可以
#     在定义一个普通形参变量，也可以在后面定义一个可变长字典
#     '''
#     print(name)

# def fun1(*name,**dic):
#    print(name,dic)
#
# d ={'name':"xioawang",'age':19}
# if __name__ == '__main__':
#    fun1('zhangsan','lisi',name='wangwu',age=18)
# # # 打印结果：('zhangsan', 'lisi') {'name': 'wangwu', 'age': 18}
# fun1('中国',**d)    # 实参‘中国’，可变长字典**d
# # 打印结果('中国',) {'name': 'xioawang', 'age': 19}
#注意：当可变长元组和可变长字典同时出现时，默认将可变长字典放后面


# 函数中全局和局部变量引用：
# num =200 #定义一个变量num 赋予一个值200 当前变量为全局的变量
# def fun(): #定义一个函数
#     num=100 #在函数中定义一个变量num=100
#     '''当前函数体中的这个num:局部变量
#     '''
#     print(num) #打印的结果为：函数内部变量的num=100
# fun() #函数调用函数自己本身得到结果为：100
#
# num1 =300
# def fun():
#     print(num1) #300
#
# fun()
# #print(num1)
# '''
# 全局：全局变量会被所有引用
# 局部：如当前函数中有局部变量，函数会优先引用自己的变量
# 如函数中没有定义局部变量则会直接引用全局变量


# num =200 #定义一个变量
# def fun():#定义一个函数
#     num=100 #在函数中定义一个变量
#     a=num/2 #定义一个变量 ：通过num /2
#     print(int(a)) #打印变量
# fun()#函数调用   #打印结果：50
# num=200
# def fun():
#     '''
#     可以将函数中的变量通过关键字声明成为一个全局
#     在函数中如通过global将某个局部变量声明成为了一个全局后
#     那么当前别声明的全局优先级要不直接在函数外声明的全局要高
#     '''
#     global num #将num变量声明成为一个全局
#     num=100
#     print(num)
# fun() #结果为：100   #声明全局变量优先级高于函数外的全局变量
#
# def fun1():#定义一个函数
#     print(num)
# fun1() #结果为：100   引用全局


# 函数中的返回的作用：
# def fun(): #定义的一个函数
#     num =100
#     a=num/2
#     #print(a) #50.0
#     return a
#     # return 下面的代码是不会被运行的
# fun()
# #'''函数的传递'''
# def fun1():
#     c=fun() #函数传递，把fun函数中的50拿过来赋值给c那么当前c=50
#     # print(c) #50.0
#     c*=2
#     print(c) #100.0
# fun1()


'''
题目：
   要求1、通过函数来实现
       2、引用函数传递方法
        3、引用返回值
   有一个登录系统：账号admin  密码123456 验证码abc123
   账号、密码、验证码都正确的时候：显示登录成功
   最后显示查询的余额为：888888888
   账号错误返回账号错误
   密码错误返回密码错误
   验证码错误返回验证码错误'''
#方法一：
# def fun():
#     a ='查询的余额为：￥8888888888.00'
#     return a
# fun()
# def fun1():
#     user_name=input('输入账号：')
#     if user_name =='admin':
#         user_pwd=input('输入密码:')
#         if user_pwd =='123456':
#             user_yzm=input('输入验证码:')
#             if user_yzm =='abc123':
#                 print('登录成功',fun())
#             else:
#                 print('验证码错误！！')
#         else:
#             print('密码错误！！')
#     else:
#         print('账号错误！！')
# fun1()

# def fun1():
#     user_name=input('输入账号：')
#     if user_name =='admin':
#         user_pwd=input('输入密码:')
#         if user_pwd =='123456':
#             user_yzm=input('输入验证码:')
#             if user_yzm =='abc123':
#                 print('登录成功')
#                 return True
#             else:
#                 print('验证码错误！！')
#                 return False
#         else:
#             print('密码错误！！')
#     else:
#         print('账号错误！！')
# def fun():
#     a=fun1()
#     if a ==True:
#         print('查询的余额为：￥8888888888.00')
#     else:
#         pass
# fun()

# 1、有如下url地址, 要求实现截取出"?"号后面的参数, 并将参数以"key value"的键值形式保存起来, 并最终通过#get(key)的方式取出对应的value值。
#url地址如下：
#http://ip:port/extername/get_account_trade_record.json?page_size=20&page_index=1&user_id=203317&trade_type=0"
# url="http://ip:port/extername/get_account_trade_record.json?page_size=20&page_index=1&user_id=203317&trade_type=0"
# def fun():
#     dic={} #定义一个空字典
#     a =url.split('?') #通过字符串中的分割函数将?进行分割返回一个列表
#     # print(a,end='')#打印结果
# # ['http://ip:port/extername/get_account_trade_record.json',
# #  'page_size=20&page_index=1&user_id=203317&trade_type=0']
#     del a[0]
#     # print(a,end='')
# # ['page_size=20&page_index=1&user_id=203317&trade_type=0']
#     for i in a: #for循环遍历当前列表返回类型为字符串
#         c =i.split('&') #调用字符串函数来对&进行分割又返回一个列表
#         # print(c,end='')
# # ['page_size=20', 'page_index=1', 'user_id=203317', 'trade_type=0']
#         for j in c: #继续对当前列表进行遍历返回一个字符串
#             d =j.split('=') #把当前字符串中的=号进行分割返回一个列表
#             # print(d,end='')
# # ['page_size', '20']['page_index', '1']['user_id', '203317']['trade_type', '0']
#             dic.setdefault(d[0],d[1]) #通过 空字典调用字典中的方法来同索引设置对应的键值对
#     # print(dic)
# # {'page_size': '20', 'page_index': '1', 'user_id': '203317', 'trade_type': '0'}
#     return dic #通过return把字典返回给当前函数本身
# fun()
# all =fun() #创建一个对象（函数传递）
# print(all.get('page_index')) #1

# 2、用递归方法求出N的阶乘  /4的阶乘的结果
# 函数自己调用自己内部来实现结果的输出
# '''
# 0！ =1
# 1！ =1
# 2!  =2*1！
# 3！ =3*2！*1！
# # 4！ =4*3!*2!*1!
# # 5!  =5*4!*3!*2!*1!
# # 4!=4*3*2*1 =24'''
# #
# def fun(i): #2 3
#     if i ==0 or i==1:
#         return 1
#     else:
#         return i*fun(i-1)
#                # 2*    2-1 2*1
#                # 3*    3-1=2 3*2*1
# print(fun(4))
#
#python中的格式化输出：format()
# 和%号格式化输出一样，是%号的另外一种格式
#1、不设置指定位置，按默认顺序
# a ='{}'.format('hello','nihao','dajiaoha')
# print(a)    #打印结果 hello
# a ='{}{}'.format('hello','nihao','dajiaoha')
#print(a) # 打印结果hello      nihao
# a ='{} {} {} {}'.format('hello','nihao','dajiaoha')
#print(a) #{}可以小于等于具体的值，但是不能大于否者抛异常
#打印结果：IndexError: tuple index out of range  元组索引超出范围

#案例：
# v = input('>>>')
# name = "我叫{name},年龄{age}"
# val = name.format(name=v,age=18)
# print(val)  #打印结果  >>>
#案例1：
# name = "我叫{0},年龄{1}-{0}-{0}"
# val = name.format('海娇',45)
# print(val)

#2、设置指定索引位置输出
#案例1
# a ='{1} {0}'.format('hello','nihao','dajiaoha')
# print(a)    #打印结果：nihao hello
#案例2：
# name = "我叫{0},年龄{1}-{0}-{0}"
# val = name.format('海娇',45)
# print(val)

#3、设置参数输出
# d ="姓名：{name} 年纪：{age}".format(name='张三',age=18)
# print(d) #姓名：张三 年纪：18


#3对列表进行格式化
#案例1
# a=['多测师','www.duoceshi.com']
# #大括号里面的0代表的是列表、中括号里面的0和1是列表元素对应的索引位
# b="网站名:{0[0]}, 地址 {0[1]}".format(a)
#print(b)  #打印结果：网站名:多测师, 地址 www.duoceshi.com
#案例2
# l =[1,2,3,4] #0
# l1=[5,6,7,8] #1
# l2=[9,10,11,12] #2
# a ='{2[1]} {2[2]}'.format(l,l1,l2)
# print(a)
#
# #4、对字典进行格式化 "*"表示可变长元组
# name = "我叫{0},年龄{1}-{0}-{0}"
# val = name.format(*('海角',45))
# print(val)

#5、对字典进行格式化 "**"表示可变长字典
#案例1
#  name = "我叫{name},年龄{age}"
# dic = {'name':'海角','age':18}
# val = name.format(**dic)
# print(val)

#案例2
# a={"name":"多测师","url":"www.duoceshi.com"}
# b="网站名:{name}, 地址:{url}".format(**dic)
# print(b)


# zip函数
#zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。

# 将两个列表进行拼接返回一个个的元组
# l =[1,2,3,4]
# ll=[5,6,7]
# lll=[8,9,10]
# a =zip(lll,ll)
#b =zip(l,ll)
# print(a)       #打印结果<zip object at 0x00000000027819C8>（对象）
# print(list(a))  #打印结果 [(8, 5), (9, 6), (10, 7)] # list() 转换为列表
#print(list(b))  #  打印结果[(1, 5), (2, 6), (3, 7)]#元素个数与最短的列表一致
# '''zip函数在Python3中直接打印返回的是object
# 在Python2中可以直接打印出结果'''
# for i in a:
#     print (list(i))
# '''
# 取值的要求：必须两两为真才取，一真一假不取
# '''
# s,c =zip(*zip(l,ll))   # 与 zip 相反，zip(*) 可理解为解压，返回二维矩阵式
# print (list(s))   #打印结果
# print (list(c))   #打印结果


#案例
# a=['name','url']
# b=['duoceshi','www.duoceshi.cn']
# #c=zip(a,b) #通过zip方法转换成元组放入列表当中
# #print(list(c))  #打印结果：[('name', 'duoceshi'), ('url', 'www.duoceshi.cn')]
# d = dict(zip(a,b)) #利用字典的方法转换成字典
# print(d)
# #案例2：
# #通过zip方法将两个列表合成字典
# key_list = ['name','age','gender']
# val_list = ['Allen',30,'Male']
# lst_dict = dict(zip(key_list,val_list))
# print(lst_dict)


# open()函数
#open() 函数用于打开一个文件，创建一个 file 对象
#Python open() 函数用于打开一个文件，并返回文件对象，
# 在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。
#注意：使用 open() 函数一定要保证关闭文件对象，即调用 close() 函数。
#open() 函数常用形式是接收两个参数：文件名(file)和模式(mode)。
#open(file, mode='r')
# 打开文件的模式有：
##文件句柄 = open('文件路径', '模式')

# r，只读模式（默认）。
# w，只写模式。【不可读；不存在则创建；存在则删除内容；】
# a，追加模式。【可读；   不存在则创建；存在则只追加内容；】
# "+" 表示可以同时读写某个文件
#
# r+，可读写文件。【可读；可写；可追加】
# w+，写读
# a+，同a
#完整的语法格式为：
#open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
# file: 必需，文件路径（相对或者绝对路径）。
# mode: 可选，文件打开模式
# buffering: 设置缓冲
# encoding: 一般使用utf8
# errors: 报错级别
# newline: 区分换行符
# closefd: 传入的file参数类型
# opener:

#语法:open(file, mode),模式有r(只读),w(写入覆盖),a(写入追加)

#报错：编解码器无法解码位置2-3的字节:truncated \UXXXXXXXX转义
#SyntaxError: (unicode error) 'unicodeescape' codec can't decode bytes in position 2-3: truncated \UXXXXXXXX escape
#解决方案：
# 1、在路径前面加r，即保持字符原始值的意思。
#2、替换为双反斜杠
#3、替换为正斜杠
# 在编译器工具中创建一个文件
a = open(r'C:\Users\Administrator\PycharmProjects\untitled\python\aaaa ','r',encoding='utf-8')
#print(a.read())#读取当前文件中的所有内容
# # text  copy:当前文件或者目录名称
# # copy path:当前文件或者目录的绝对路径：如：C:\Users\Administrator\PycharmProjects\untitled\python\aaaa
#print(a.read()) #读取当前文件中的所有内容
l =a.readline() #读取文件中的第一行
#print(l)
o =a.readlines() #读取文件中的所有返回一个列表
# print(o)

# 第二种：引用本地的文件
#t =open(r'D:\bao\aa.txt','r')
# print(t.read()) #读取所有  #显示文件123456
# print(t.readline())#只读取第一行
# print(t.readlines())#读取所有返回一个列表
# a =t.readlines()
# print(a)
# for i in a:
#     print(i,end='')

# 引用本地电脑中的文件，对于中文可以进行转译
# 引用工具中的文件file创建的，对于中文不能进行转译，需要定义
# 一个编码格式encoding='utf-8'


# 文件的路径中出现中文
# 错误案例：url ='C:/Users/Administrator/PycharmProjects/untitled/python/002作业.py '
# a=open(url,'r')
# print(a.read())   #结果： 无效参数OSError: [Errno 22] Invalid argument: 'D:\x08ao\\多测师\x07a.txt'
#
#正确案例：
# url ='C:/Users/Administrator/PycharmProjects/untitled/python/002作业.py '
#a=open(url,'r',encoding='utf-8')
#print(a.read())
# '''python3中引用本地路径：含有中文都能够实现转译
# 如出现乱码情况和文件中出现中文一样加上；encoding=utf-8'''
#案例


# 在open函数中w权限：替换
# url =r'C:\Users\Administrator\PycharmProjects\untitled\python\aaaa'
# a =open(url,'w',encoding='utf-8')
# a.write('多测师大佬！！！！')
# a.writelines('\n 多测师')
# a.close() #覆盖后关闭当前文件释放资源

# #查看语句
# b=open(url,"r",encoding='utf-8')
# print(b.read())

# a追加在open函数中
# url =r'C:\Users\Administrator\PycharmProjects\untitled\python\aaaa'
# a =open(url,'a',encoding='utf-8')
# a.write('\n多测师')
 # \n表示为换行符
# 查看 追加内容
# b=open(url,"r",encoding='utf-8')
# print(b.read())

#open()函数扩展用法
# url =r'C:\Users\Administrator\PycharmProjects\untitled\python\aaaa'
# with open(url,'r',encoding='utf-8')as o:
#     a=o.read()
#     print(a)
#用with语句的好处，就是到达语句末尾时，会自动关闭文件，即便出现异常

# with open("C:\\bao\\bb.txt", 'r')as f:
#     a = f.read()
#     b = f.readline()
#     c = f.readlines()
#     d = f.write()
#     e = f.writelines()
#用with语句的好处，就是到达语句末尾时，会自动关闭文件，即便出现异常

# f = open('C:\Users\Administrator\PycharmProjects\untitled\python\aaaa', 'r', encoding='gbk'errors='ignore',)
# print (f.read())

#
# 字符编码
# 要读取非UTF-8编码的文本文件，需要给open()函数传入encoding参数，例如，读取GBK编码的文件：

#遇到有些编码不规范的文件，你可能会遇到UnicodeDecodeError，因为在文本文件中可能夹杂了一些非法编码的字符。遇到这种情况，open()函数还接收一个errors参数，表示如果遇到编码错误后如何处理。最简单的方式是直接忽略：



#二进制文件
#前面讲的默认都是读取文本文件，并且是UTF-8编码的文本文件。
# 要读取二进制文件，比如图片、视频等等，用'rb'模式打开文件即可：

#总结：以后读写文件尽量使用with open语句，少使用f = open()语句

# '''题目：有这样的一个字符串：
#   helloword ni haoya 将此字符串输出最终的结果为：
#     helloword%$ni%$haoya
# 不能使用替换函数
# 用函数来进行完成 '''
# def fun(): #定义一个函数
#     s='helloword ni haoya' #定义一个字符串
#     c=s.split(' ') #通过split把空格进行分割
#     # print(c) #['helloword', 'ni', 'haoya']
#     print('%$'.join(c)) #然后用join来进行拼接
# fun() #helloword%$ni%$haoya
#
# def fun():
#     s='helloword ni haoya' #定义一个字符串
#     s_tr='' #定义一个空的字符串容器存放结果的
#     for i in range(len(s)): #统计当前字符串中的个数对应的索引
#         # print(i,end='') #01234567891011121314151617
#         if s[i]==' ':
#             s_tr+='%$'
#         else:
#             s_tr+=s[i]
#     print(s_tr) #helloword%$ni%$haoya
# fun()