1

#函数
#print()
a = 1.12386
result = round(a, 2)
print(result)


#保留小数后三位
a = 1.12386
print(round(a, 2))  #函数里面嵌套函数


#用循环怎么取小数点后两位？

2

# def funcname(parameter_list):   #参数列表
#     pass

'''
特点：
1 参数列表可以没有
2 return value   #没有return 语句的话，将返回None
'''

#实现两个数字的相加
#打印输入的参数
# import sys
# sys.setrecursionlimit(100)#最大的递归层数


def add(x, y):
    result = x + y
    return result


# def print(code):  #注意定义函数的时候不要用系统的关键字
#     print(code)


# def print_code(code):
#     print(code)

add(1, 2)
# print(add)
# print_code('python')

3

def add(x, y):
    result = x + y
    return result

def print_code(code):
    print(code)
    return 'hehe'

a = add(1, 2)
b = print_code('python')

print(a, b)
#执行结果
#python
#3 None     #函数的调用顺序？    #这一个None也是值得思考的

# python
# 3 hehe



def add(x, y):   
    print(x + y)
    return 'heihei'
    
print(add(8, 2))

#执行结果
# 10
# heihei

#定义一个函数，不管中间写的是什么，最后要有一个 return 关键字，返回一些东西。
# 如果没有return ,Python会自己返回一个None

4让函数返回多个结果

#函数返回多个结果

def damage(skill1, skill2):
    damage1 = skill1 * 3
    damage2 = skill2 * 2 + 10
    return damage1, damage2

damages = damage(3, 6) 

print(damages[0], damages[1])   
#这样的返回结果不好，

skill1_damage, skill2_damage = damage(3, 6)  
#这样的接收比较好。叫序列解包。不要用下标索引的方法
print(skill1_damage, skill2_damage)

#可以认为3和6是初始伤害，damages是最终计算后的伤害值
print(type(damages))

5序列解包和链式赋值

#序列解包和链式赋值
a = 1
b = 2
c = 3
a, b, c = 1, 2, 3

d = 1, 2, 3
print(type(d))

a, b, c = d #这就叫序列解包
print(d)

6参数

#参数

# 1 必须参数
# 2 关键字参数

def add(x, y):  #x, y 是形式参数
    result = x + y
    return result

f = add(5, 6)  #5, 6是实参
print(f)

c = add(y=3, x=2)   #这是关键字参数
#告诉Python实参是给那个形参赋值的
#它的意义是代码的可读性高！！


# 3 默认参数     #简化了代码 
#注意，必须参数要放在前面，不能放在默认参数的后面
def print_student_msg(name, gender='男', age=18):
    return name , gender, age

stu01 = print_student_msg(name='hehe')
stu02 = print_student_msg(name='haha', age=20)
print(stu01)
print(stu02)


#可变参数
def demo(*param):
    print(param)
    print(type(param))

demo(1,2,3,4,5,6)


# 这个相当于
def demo(param):
    print(param)
    print(type(param))

demo((1,2,3,4,5,6))


#注意可能会成为二维的元祖
def demo(*param):
    print(param)
    return (type(param))

# a = (1,2,3,4,5,6)
# demo(a)   #注意可能会成为二维的元祖  #正确的做法是  demo(*a)

f = demo((1,2,3,4,5,6))  #注意可能会成为二维的元祖
print(f)



#可变参数
def demo(param1, *param, param2=6):
    print(param1)
    print(param)
    print(param2)
    return 'hehe'

demo('a', 1,2,3)


# a
# (1, 2, 3)
# 6            


# hehe  为什么没有返回  #这样会将 hehe 返回
# f = demo('a', 1,2,3)
# print(f)


#可变参数的使用场景

def squsum(*param):
    sum = 0
    for i in param:
        sum += i * i
    print(sum)

# squsum(1, 2, 3)

# 这样也可以
# squsum(*[1,2,3])



#关键字可变参数
def city_temp(**param):
    print(param)
    print(type(param))
    pass

city_temp(bj='32c', xm='23c', sh='30c')

#打印的结果
# {'bj': '32c', 'xm': '23c', 'sh': '30c'}
# <class 'dict'>


#用循环来打印   #错误的演示
def city_temp(**param):
    for key, value in param:
        print(key, ':', value)

city_temp(bj='32c', xm='23c', sh='30c')

# 打印的结果
# b : j
# x : m
# s : h


#正确的打开方式
def city_temp(**param):
    for key, value in param.items():  #注意方法后面的括号
        print(key, ':', value)

city_temp(bj='32c', xm='23c', sh='30c')

# 打印的结果
# bj : 32c
# xm : 23c
# sh : 30c

#补充
a = (bj='32c', xm='23c', sh='30c')
city_temp(**a)

7变量的作用域

#变量作用域
c = 50

def add(x, y):
    c = x + y
    print(c)   #这个c和上面的c作用域的范围不一样，

add(1, 3)
print(c)

#打印的结果
# 4
# 50



def demo():
    c = 10

print(c) #这个会报错  #外部无法引用内部的变量




c = 10        #全局变量
def demo():
    c = 50     #局部变量   #可以在函数的内部引用外部的变量
    print(c)



#局部变量只是相对的。 
print('----------------------------------')
def demo():
    c = 50
    for i in range(0, 9):
        a = 'a'
        c += 1
    print(c)
    print(a)   #我们在外部可以引用for循环内部的变量
                #原因是Python中没有块级作用域的概念
demo()


c = 1

def func1():
    c = 2
    def func2():
        c = 3
        print(c)
    func2()

func1()   
#我们一直往下看，发现func2() 函数调用了，c=3 在func2() 的内部，其他的都是在 func2() 外部



#global关键字
def demo():
    global c 
    c = 666

demo()   #执行函数后global才有效
print(c)  

#执行结果
#666
# 全局变量在整个应用程序中都可以使用的