函数（一）

一、函数是什么？

函数一词来源于数学，但编程中的「函数」概念，与数学中的函数是有很大不同的，编程中的函数在英文中也有很多不同的叫法。在BASIC中叫做subroutine(子过程或子程序)，在Pascal中叫做procedure(过程)和function，在C中只有function，在Java里面叫做method。

定义: 函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可。

二、使用函数的作业：

1、让代码更简洁，简化代码       1、提高代码的复用性,   3、代码可扩展

函数的定义：

函数：用def关键字 有函数名（函数名不能重复）、函数体，函数不调用不能被执行

函数的参数：

函数在调用的时候，可以传入参数，形参和实参

形参：形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。

实参：实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。函数调用结束返回主调用函数后则不能再使用该形参变量。

总结：形参就是函数接收的参数，而实参就是你实际传入的参数。#函数的参数

def calc(a,b):#形参，形式参数，a,b就是形参,#位置参数，必填参数

    res=a*b
    print('%s*%s=%s'%(a,b,res))
calc(7,8)#实参，实际参数，7,8就是实际的参数

#结果：7*8=56

函数的四种形参类型：

位置参数：

位置参数，按照参数的位置来进行传参，比如说上面的calc函数，a和b就是位置参数，位置参数是必传的，

有几个位置参数在调用的时候就要传几个，否则就会报错了，那如果有多个位置参数的话，记不住哪个位置传哪个了怎么办，可以使用位置参数的名字来指定调用

比如说上面的那个calc函数也可以使用calc(a=1,b=2)这样来调用，这种调用方式叫做关键字传参

默认参数：

默认参数就是在定义形参的时候，给函数默认赋一个值，这样就算你在调用的时候没传入这个参数，它也是有值的，因此默认参数不是必填的，如果给默认参数传值的话，它就会使用你传入的值。如果使用默认值参数的话，必须放在位置参数后面定义。

def op_file(file_name,connent=None):#默认值参数,它是非必填参数
    f=open(file_name,'a+',encoding='utf')
    f.seek(0)
    if connent:
        f.write(connent)
        f.flush()
    else:
        print(f.read())
    f.close()
op_file('word', 'hwt')
op_file('word')#即使没有输入connent参数也没有进行报错，因其为默认函数

不固定参数：

def syz(*args):
    print(args)
syz()
syz('niuhy',123,'hello')
syz('34','fd')
#1、非必填参数
#2、它没有限制参数个数
#他是把传过来的参数放到元组里面

()
('niuhy', 123, 'hello')
('34', 'fd')

#如果加多一个必填参数
def syz(a,*args):
    print(args)
syz()#报错
syz(21)#()
syz('niuhy',123,'hello')#(123, 'hello')
syz('34','fd')#('fd',)

关键字参数：

def syz2(**kwargs):
    print(kwargs)
syz2()#{}
syz2(name='hwt',age=20)#{'age': 20, 'name': 'hwt'}
syz2(name='hwt2',ages=20,addr='广州',home='梅州')
#{'home': '梅州', 'addr': '广州', 'ages': 20, 'name': 'hwt2'}
syz2('hwt')#报错
#1、非必填参数
#2、它没有限制参数个数
#他是把传过来的参数放到字典里面

函数返回值：

每个函数都有返回值，如果没有在函数里面指定返回值的话，在python里面函数执行完之后，默认会返回一个None，函数也可以有多个返回值，如果有多个返回值的话，会把返回值都放到一个元组中，返回的是一个元组。

为什么要有返回值呢，是因为在这个函数操作完之后，它的结果在后面的程序里面需要用到。

函数中的返回值使用return，函数在遇到return就立即结束。

1、设置return返回函数处理结果

def op_file(file_name,connent=None):#默认值参数,它是非必填参数
    f=open(file_name,'a+',encoding='utf')
    f.seek(0)
    if connent:
        f.write(connent)
        f.flush()
    else:
        all_user=f.read()
        return all_user#把函数处理的结果返回回来
        #print(f.read())
    f.close()
res=op_file('word')
print(res)

2、函数遇到return就立即结束

#函数遇到return就立即结束，如下循环到3就结束不在循环4-5
def haha():
 for i in range(5):
     print(i)
     if i==3:
        return
haha()
结果：
0
1
2
3

3、函数如果没有return，默认返回None

import string
def check(password):
    #长度6-11位，必须包含字母与数字
    if len(password)>5 and len(password)<12:
        if set(password)&set(string.ascii_letters) and set(password)&set(string.digits):
            print('密码合法')
        else:
            print('密码不合法')
    else:
        print('密码不合法')
res=check('abc123')#函数里面如果没有return，默认返回None
print(res)
结果：
密码合法
None

局部变量：在函数里面定义的变量即为局部变量，只在函数里面有效，在函数外面使用无效报错

def op_file(file_name,connent=None):#默认值参数,它是非必填参数
    f=open(file_name,'a+',encoding='utf')
    f.seek(0)
    if connent:
        f.write(connent)
        f.flush()
    else:
        all_user=f.read()#all_user函数里面定义的变量都是局部变量
        return all_user#把函数处理的结果返回回来
        #print(f.read())
    f.close()
res=op_file('word')
print(res)
print(all_user)#在函数外面使用all_user会报错，只能在函数中使用

 全局变量：公共的变量，都可以用的变量

1、不安全，因为所有人都可以改
2、全局变量它会一直占着内存

money=500  #一个不变的值
def test(consume):#500
    return  money-consume#0

def test1(money):
    return test(money)+money#0+500
money=test1(money)
print(money)#500
#500

(1)
name='hwt'
#全局变量
def sayName():
    name='hwt2'
    print('name1',name)#函数中有name1:hwt2
sayName()#打印出函数里局部变量的name
print('name2',name)#打印出全局变量name:hwt

#hwt2
#hwt

(2)
ame='hwt'
#全局变量
def sayName():
    #name='hwt2'#注销局部变量
    print('name1',name)#函数中没有name1
sayName()#打印出函数里全局变量的name
print('name2',name)#打印出全局变量name:hwt

#hwt
#hwt
（3）
#如果要改全局变量的话，那你要先声明一下，你要修改的是全局变量
name='hwt'
#全局变量
def sayName():
    global  name#声明修改全局变量
    name='hwt2'
    print('name1',name)#hwt2

sayName() print('name2',name)#hwt

（4）
def sayName():
    global  name
    name = 'hwt2'
def sayName2():
    global  name
    name = 'hwt3'
sayName()
sayName2()
print('name2',name)

如果没有定义全局变量会报错：

#没有定义全局变量，报错
def test():
    global  a
    a=5
def test1():
    c=a+5
    return c
res =test1()
print(res)
#报错，a没有定义

 小练习：

#需求
#小数点个数 .count
#2、按照小数点进行分割
#正小数：小数点左边是整数，右边也是整数 .isdigits()
#负小数：小数点左边是以负号开头，但是只有一个负号，右边也是整数
#import string
def is_float(num):
    num=str(num)
    if num.count('.')==1:
        nums=num.split('.')
        left=nums[0]#小数点左边
        right=nums[1]#小数点右边
        if left.isdigit() and right.isdigit():
            return True
        elif left.startswith('-') and left.count('-')==1:#判断是否是合法的负数
            if left.split('-')[1].isdigit() and right.isdigit():#判断合法的负小数
                return True#
    return False

print(is_float(1.98)) #True
print(is_float(-2.98))#True
print(is_float(-1))#False
print(is_float(129))#False
print(is_float('s.87'))#False
print(is_float('s.3s6'))#False
print(is_float('.3s6'))#False
print(is_float('-.3s6'))#False
print(is_float('--.3s6'))#False
print(is_float('-2-.3s6'))#False
print(is_float('-2.-3s6'))#False

两种方式转换json

1、先读取文件内容，然后将json串变成Python数据类型

import  json
#json 是一个字符串
f=open('product.json',encoding='utf-8')
res=f.read()
product_dict=json.loads(res)#把json串变成Python数据类型
print(product_dict)
print('
')
print(product_dict.get('product_info'))

结果：
{'iphone': {'price': 98.5, 'color': 'red', 'num': 1}, 'wather': {'price': 1, 'num': 100, 'color': 'white'}}
{'price': 98.5, 'color': 'red', 'num': 1}

2、#传一个文件对象，它帮你读文件

import  json
#json 是一个字符串
f=open('product.json',encoding='utf-8')
product_dict=json.load(f)#传一个文件对象，它帮你读文件
print(product_dict)

#结果：
{'wather': {'num': 100, 'price': 1, 'color': 'white'}, 'iphone': {'num': 1, 'price': 98.5, 'color': 'red'}}

将字典转换成json

(1)

#将字典转变成json串
d={
    "iphone":{
        "color":"红",
        "num":1,
        "price":98.5
    },
    "wather":{
        "num":100,
        "price":1,
        "color":"white"
    }
}
fw=open('user_info.json','w',encoding='utf-8')
dict_json=json.dumps(d,ensure_ascii=False,indent=4)#将字典转换成json
fw.write(dict_json)

(2)

#将字典转变成json串
d={
    "iphone":{
        "color":"红",
        "num":1,
        "price":98.5
    },
    "wather":{
        "num":100,
        "price":1,
        "color":"white"
    }
}

fw=open('user_info.json','w',encoding='utf-8')
json.dump(d,fw,ensure_ascii=False,indent=4)#操作文件将字典转换成json

 练习：

import json
def op_data(filename,dict=None):
    if dict:
        with open(filename,'w',encoding='utf-8') as fw:
            json.dump(dict,fw,ensure_ascii=False,indent=4)
    else:
        with open(filename,encoding='utf-8') as fr:
            json.load(dict,fr)
filename='user_info.json'
all_user=op_data(filename)
print(all_user)
for i in range(3):
    choice=input('请输入你的选择：1、注册 2、删除')
    if choice==1:
        username=input('username:')
        pwd=input('pwd')
        if username not in all_user:
            all_user[username]=pwd
            #all_user.setdefault(username,pwd)
            op_data(filename,all_user)
        elif choice==2:
            username = input('username:')
            all_user.pop(username)
            op_data(filename, all_user)
            print('success')

递归函数：

def test1():
    num = int(input('please enter a number：'))
    if num%2==0:#判断输入的数字是不是偶数
       return True #如果是偶数的话，程序就退出了，返回true
    print('不是偶数请重新输入！')
    return test1()#如果不是偶数的话继续调用自己，输入值
print(test1())#调用test

结果：
please enter a number：5
不是偶数请重新输入！
please enter a number：6
True

少用递归，递归最有递归999，递归的效率不高
#到了999次后报错
i=0
def test():
    global  i
    i+=1
    print(i)
    test()

 内置函数：

内置函数
python自带的一些函数，直接拿过来能用的
id() #看内存地址
type() #看数据类型
print() #打印
input() #输入
list() #转list
set()# 转集合
str()#转字符串
dict()#转字典
int()#转int
float()#转float类型
len()#取长度
max()#取最大值
min()#取最小值
dir() #打印传入对象的可调用方法,如果忘了某个变量类型有啥方法调用，可用改方法查看，例如查看字符
sorted()#排序
round(11.00011,2)#保留几位小数
map() #下周
filter() #下周
zip() #下周