目录

函数

函数的参数与传递方式

异常处理

函数

函数是将代码封装起来，实现代码复用的目的

函数的命名规则——同变量命名规则： 不能中文、数字不能开头、不能使用空格、不能使用关键字

#最简单的定义函数
user_list=[]
def fun(): #定义一个函数，声明
    name = input('name:')
    user_list.append(name)
    print(user_list)
fun() #调用函数 必须要先声明再调用

#定义main函数，主函数是程序的入口，相当于c语言的char main()
#在main上面，要定义函数与类
list1=['wadsad', 'qweqwe']
def show(list_name):
    for i in list_name:
        print(f'{list_name.index(i) + 1}.{i}')
if __name__ == '__main__': #主函数
    show(list1)
#1.wadsad
#2.qweqwe

#函数的帮助文档
#可以通过ctrl+点击打开python的源代码，后面的备注就是函数的说明文档
help(print) #也可以通过help()来查看帮助文档
#可以给自己定义的函数添加备注，说明作用
def show(list_name):
    """
    :param list_name:
    :return:
    """
    for i in list_name:
        print(f'{list_name.index(i) + 1}.{i}')
#通过__doc__也可以对帮助文档进行查看
print(show.__doc__)
#    :param list_name:
#    :return:

#变量的作用域
#变量分为全局变量和局部变量
#全局变量可以在所有区域中被访问，局部变量只能在函数中或嵌套的函数内被访问
#局部变量
def fun():
    i = 1
    print(i)
#全局变量
if __name__ == '__main__':
    i = 2
    fun()
#2 局部变量在函数内优先级比全局变量高

#return 函数的返回值
#return是什么，函数就是什么
#return会立即执行，后面的语句不会执行
#可以一次return多个值
def fun():
    v1 = 1
    v2 = 2
    v3 = 3
    return v1,v2,v3 #返回多个值
if __name__ == '__main__': 
    var1,*var2 = fun() #解包
    print(var2)  #如果没有return，则会自动return一个空值None

函数的参数与传递方式

函数传递不可变类型的对象如char，int等参数时，会把实参复制一份之后给形参传参，对于实参本身没有影响

函数传递可变类型的对象如列表、字典等，对对象引用后操作，映射到对象本身，产生影响

#形参与实参
def fun(var):  #形参（举例）
    print(f'{var}')
if __name__ == '__main__':
    var1 = input('press:')
    fun(var1)  #真实传入的是实参

#顺序的参数————按照顺序一一对应的传递参数，最基础的传参形式
#形参和实参位置要一一对应、且数量要一致
def fun(var1,var2):
    v1 = var1 * 2
    v2 = var2 + 10
    return v1,v2 
if __name__ == '__main__':
    fun(123,456) #按照顺序把123传入var1，把456传入var2

#关键字参数————参数名=值的方式传递参数
def fun(var1,var2,var3):
    print(var1,var2,var3)
if __name__ == '__main__':
    fun(var2=456,var1=123,var3=789) #直接将var1作为关键字在函数里进行赋值，来传参
		fun(123,456,var3=789) #混合使用，需要把关键字参数的部分放到后面，不推荐使用

#默认值参数————给形参指定一个默认值
def fun(var3,var2,var1=3): #默认值参数需要放在形参列表的最后
    print(var1,var2,var3)
if __name__ == '__main__':
		fun(1, 2, 4)
#4 2 1
    fun(1, 3)
#3 3 1

#参数收集————当参数个数不确定时，统一把参数收集起来，封装为元组
#每个函数只能有一个这种参数
#参数收集类函数尽量放到最后，后面的参数必须用关键字参数
def fun(v1,v2,*args,v3): #使用*，参考封包解包，一般使用args
    print(args)
if __name__ == '__main__':
    fun(123,12345,'qwe',True,v3=123)
#('qwe', True)

#关键字参数收集——不确定个数的关键字参数，统一收集，封装成字典
#每个函数只能有一个这种参数
#必须放到最后
def fun(v1,**kwargs):
    print(kwargs)
if __name__ == '__main__':
    fun(True,name='ws',age=24,passwd='ws111')
#{'name': 'ws', 'age': 24, 'passwd': 'ws111'}

#逆向参数收集——将序列对象作为实参传递，序列被拆分并赋值给形参
#实参为列表或元组时，数量要相同
def fun(var1,*var2): #
    print(var1,var2)
if __name__ == '__main__':
    list1 = ['ws','xhy',111,222]
    fun(*list1)
#ws ('xhy', 111, 222)

#实参为字典时，key必须与形参名相同
def fun(var1,var2,**var3):
		print(var1,var2,var3)
if __name__ == '__main__':
		dict1 = {'var1':'ws111','var2':True,'v1':'v1','v2':'v2'}
		fun(**dict1)
#ws111 True {'v1': 'v1', 'v2': 'v2'}

#函数传递可变类型的对象时产生的影响
def fun(add):
    add.append('1')
    return add
if __name__ == '__main__':
    list1=[]
    list2=fun(list1)
    print(list1)
    print(list2)
#['1']
#['1']
#通过引用，可以让局部改变全局的对象

#lambda表达式————匿名函数，结构简单
#主体只能放一个语句、自动返回return主体语句的结果
#支持各种参数与传参形式
#主要用以简化代码，可以将函数赋值到变量
fun = lambda v1,v2 : v1 * v2
print(fun(11,45))
#495
fun = lambda v1,v2=20 : v1 * v2
print(fun(10))
#200

异常处理

常见的异常导致的错误包括：

用户操作相关：类型错误、无效输入、误操作
网络问题：丢包、对方主机无应答
操作系统与硬件问题：重启，断电等

编程中要尽可能面对各种异常情况，编写全面完整的异常处理逻辑

异常信息包括： 文件位置、行数位置、具体语句、错误类型、异常描述

#异常处理结构————try、except关键字，捕获与处理异常
while True: #添加一个循环
    try:    #捕获异常
        num = input('>>') #input输入必定为字符串类型
        if '.' in num:    #如果内容包含一个.则使用float进行转换
            num = float(num)
        else:     #如果内容为数字，则通过int进行转换
            num = int(num)
****            #如果内容两个都不是，则可以用except进行
        print(num + 10)
        break
    except Exception as e: #如果出现异常，则进行处理。并且把故障信息Exception赋值到e中
        print('please press number')
print(e)    #查看之前发生的异常

#异常类型————所有异常类都是从BaseException类派生出，不同的异常类记录不同的异常信息
#BaseException类下有分支常见异常类型Exception类
help(StopIteration)
#通过异常类型，可以设置多分支的异常处理类型
#except分支结构，会首先寻找有没有子类错误，没有子类再寻找父类，例如必然优先执行IOError的
try:
    num = input('>>') 
    print(num + 10)
except Exception as e:
    pass
except SystemExit as e:
    pass
except StopIteration as e:
    pass
except IOError as e:
    pass

#finally分支——无论是否有异常，都会执行finally
#进行资源回收，一些进程会占用资源，比如打开的文件、建立的套接字连接、数据库的连接等
#无论是否异常，都需要做资源的回收
try:
    pass
except Exception as e:
    pass
finally: #必定执行
    pass

#arise主动引发异常，可以指定异常信息与异常类型
#主要用于和try、except结合使用，主动引发异常，输出异常的语句
raise Exception
#Traceback (most recent call last):
#   File "C:\\Users\\13209\\PycharmProjects\\first\\Study\\异常处理.py", line 23, in <module>
#     raise Exception
# Exception
raise StopIteration
# Traceback (most recent call last):
#   File "C:\\Users\\13209\\PycharmProjects\\first\\Study\\异常处理.py", line 23, in <module>
#     raise StopIteration
# StopIteration

#练习：
#让用户输入4位的纯数字，如果不是数字则报异常
#验证是否是4位，如果不是也报错，如果是就输出成功

#我写的
def fun():
    while True:
        try:
            n1 = input('Enter student number:')
            n1 = int(n1)
            if len(str(n1)) == 4:
                print('成功')
                break
            else:
                print('请输入四位数字')
        except ValueError as e:
            print('请输入数字')

if __name__ == '__main__':
    fun()

#GPT写的，确实还是GPT写的更加完善，可以理解为什么程序员喜欢用GPT了
def fun():
    while True:
        try:
            n1 = input('Enter student number:')
						#判断是否为纯数字，这个函数用以判断字符串
						#如果纯数字则返回True，反之则返回False
            if not n1.isdigit():
                raise ValueError('输入纯数字')
            # 检查输入是否为4位数
            if len(n1) != 4:
                raise ValueError("输入的数字不是4位数")
            else:
                print('成功')
                break
        except ValueError as e:
            print(e)
if __name__ == '__main__':
    fun()