Python案例：try、assert、def的用法

try预执行

assert断言

def定义函数

'''try异常捕捉，try会先对下面的代码进行存档，如果代码可以正常执行，则删除存档，继续往下运行，如果下面的代码报错，则加载回存档，不再
执行try下面的代码，转而执行except下面的代码。'''
# try:
#     a = int(input('请输入数字：'))
#     print(a)
# except TypeError:
#     print('类型错误')
# except ValueError:
#     print('值错误')
# except Exception as r:
#     print('未知类型错误：{}'.format(r))
# else:  # else跟随try一起使用的时候，只有当try下面的代码运行成功才会跟着执行，否则不执行
#     print('如果你看到了我，证明try下面的代码运行成功')
# finally:
#     print('无论try是否成功，最后都会执行的部分')
#
# print('我是来证明try之后，代码可以正常走到这里')

'''练习18'''
# 1.
# try:
#     a = float(input('你输入一个内容：'))
#     print('你输入的是数字')
# except:
#     print('你输入的是字符串')

# 2.
# try:
#     a = int(input('请输入6位数字'))
#     if 99999< a <= 999999:
#         print('你输入的数字长度符合要求')
#     elif a >999999:
#         print('你输入的数字长度太长')
#     else:
#         print('你输入的数字长度太短')
# except:
#     print('你输入的数字有误')

# 3.
# try:
#     a = float(input('请输入一个内容：'))
#     b = int(a)
#     if a == b:
#         print('你输入的是一个整数')
#     else:
#         print('你输入的是一个小数')
# except:
#     print('你输入的是一个字符串')

'''assert断言，就是对结果进行预期断定，如果断言成功，则代码继续执行，如果断言失败，则代码报错，所以断言一般和try一起使用'''
# a = input('请输入一个内容：')

# try:
# assert len(a) >= 1,'失败原因：未输入任何内容'
# print('用例通过')
# except:
#     print('用例失败')

'''定义函数,通过def来定义，起函数名要遵循命名规则，函数名后面有括号，括号里面是参数列表，可以不止一个参数，下面是函数体，也就是该函数需要执行的代码
，最后可以有return来设定函数的返回内容，也可以不写，如果写return，要注意写在函数体的最后，因为return是一个结束标志，函数体里面的代码在执行的过程
中，遇到return就会终止并返回结果，所以return后面的代码就不再执行了。'''


def kunkun():
    a = 3
    b = 4
    c = a + b
    return c


'''调用和引用，调用是指调用函数体本身，需要在函数名后面加(),括号里面如果需要填写参数的，就填写参数；引用是指只用函数的名字，不执行函数本身'''

a = kunkun()
print(a)


def kun1(a, b):
    c = a + b
    return c


a = kun1(2, 9)
print(a)


# b = kun1()
# print(b)

def kun2(a=0, b=0):
    c = a + b
    return c

a = kun2(5, 7)
print(a)

a = kun2(15)
print(a)

a = kun2(b=345)
print(a)

'''def就是用来声明函数，在写def的过程，就称之为声明过程，括号里面的参数，叫做形参，就是形式上的参数，本身是不会被使用的，目的是让函数在形式上看起来是
一个整体
在调用函数的过程中，传入函数体里面的参数叫做实参，就是实际上的参数，也是函数在执行过程中真正会用到的参数。
那么由实参代入形参的过程称之为传参，就是传递参数的意思，这个过程看不见
实例化：就是调用一个函数，生成一个函数对象
局部变量就是只在函数体内有效的变量，超过函数体则不生效
全局变量是指在整个文件中都有效的变量，在该文件运行周期内，可以随意使用'''
def kun3():
    acv = '我是局部变量'
    return acv

str1 = kun3()  # 实例化，其实就是调用函数
print(str1)
# print(acv)

sxc = '我是全局变量'
print(sxc)

def kun4():
    acv = '我是局部变量'
    tyu = acv + sxc
    return tyu

a = kun4()
print(a)

# 没有return的情况下，不需要变量来承载返回结果，因为返回来的结果是None
def kun5():
    a = 5
    b = 5
    c = a + b
    print(c)

a = kun5()
print(a)

# 将局部变量声明为全局变量

def kun6():
    # 先声明全局，再赋值，不能同时进行
    global aer
    aer = '我虽然在函数体里面，但是我是全局变量'
    print(aer)

kun6()

print(aer)

# 带默认值的形参必须在没有默认值的形参后面，否则定义函数错误，这个是语法规定的
def kun7(a,b=0):
    print(a,b)

# 不定长参数
'''*args和**kwargs来指代不定长参数，区别：
1.名字不一样
2.前面的*不一样多
3.两种参数的类型不一样，*args类型是元祖，**kwargs类型是字典
4.传参方式不一样，*args只能用位置参数进行传参，**kwargs必须用=赋值，也就是指定参数进行传参'''
def kun8(name,age,*args):
    print('你的名字是{}，你的年龄是{}，你的其他信息是{}，{}，{}'.format(name,age,*args))

kun8('xiaoming',17,'身高170cm','体重140斤','性别男')


def kun9(name,age,**kwargs):
    print('你的名字是{0}，你的年龄是{1}，你的其他信息是{2}'.format(name,age,kwargs))

kun9('小明',18,height='170cm',weight='140斤',sex='男')

# 定义函数的时候最好带上注释
def kun10(name,age,sex,height,weight):
    '''
    该函数是用来打印个人信息，方便征婚
    :param name: 承载姓名
    :param age: 年龄
    :param sex: 性别
    :param height: 身高，单位是厘米
    :param weight: 体重，单位是斤
    :return: 返回”函数执行完毕“
    '''
    print('姓名：{}'.format(name))
    print('年龄：{}'.format(age))
    print('性别：{}'.format(sex))
    print('身高：{}'.format(height))
    print('体重：{}'.format(weight))
    return '函数执行完毕'


a= kun10('xiaoming',19,'男',190,180)
print(a)

# 分开调用函数和嵌套调用函数
def ubi(name,age,sex):
    print('姓名：{}'.format(name))
    print('年龄：{}'.format(age))
    print('性别：{}'.format(sex))
    return name,age,sex

def uoi(a,b,c):
    d,e,f, = ubi(a,b,c)
    print(f,d,e)

def ui():
    uoi('kunkun',19,'男')

ui()

def demo1():
    print('我是第一个函数体')
    def demo2():
        print('我是第二个函数体')
    demo2()

demo1()

def func1():
    print('我是第一个函数')

def func2(x):
    print('我是第二个函数')
    x()
def func3():
    print('我是第三个函数')

func2(func3)    #func3是一个函数的名字，但是这个名字后面没有()，只是单纯使用这个名字而已，这就叫做引用