Python学习第六篇：Python基础之函数（一）

res=x if x >y else y 三元函数 --- 成立的放左边，不成立的放右边

函数

没有函数会有什么问题？

1.无组织无结构，代码冗余
2.可读性差
3.无法统一管理且维护成本高

1.什么是函数？

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

函数能提高应用的模块性，和代码的重复利用率，可扩展性强。

 

2.函数的分类

在python中函数分两类：内置函数，自定义函数

1）内置函数

python本身自己定义的函数，可直接调用

sum
max
min

a=len('hello')
print(a)

b=max([1,2,3])
print(b)

2）自定义函数

自己根据需求，按照函数定义方法去自定函数

 

3.函数的定义

1)为什么要定义函数？

先定义后使用，如果没有定义而直接使用，就相当于引用了一个不存在的变量名

函数的使用包含两个阶段：定义阶段和使用阶段

 定义函数阶段只检测语法，不执行代码 --  所以先定义后定义都没事。只要后在定义后的执行就可以

 

2)函数定义的语法

def functionname( parameters ):
   "函数_文档字符串"
   function_suite
   return [expression]

 

 

例如：

def printme( str ):
   print str
   return

 

3）定义函数的三种形式

#一：无参数函数：如果函数的功能仅仅只是执行一些操作而已，就定义成无参函数，无参函数通常没有返回值
def print_star():
    print('#'*6)

#二：定义有参函数:函数的功能的执行依赖于外部传入的参数，有参函数通常都有返回值
# def my_max(x,y):
#     res=x if x >y else y
#     return res


------->三元表达式:
x=10
y=2
# if x > y:
#     print(x)
# else:
#     print(y)
#

res=x if x > y else y
print(res)

#三：空函数
在一开始思考代码架构时，可以先把扩展功能写下来，后期完善


# def auth():
#     """认证功能"""
#     pass

def insert():
    """插入功能"""
    pass
def select():
    """查询功能"""
    pass
def delete():
    """删除功能"""
    pass
def update():
    """更新功能"""
    pass

 

 

4）函数的调用

 定义阶段只检测函数体的语法，并不会执行

def foo():
    print('from foo')

def bar(name):
    print('bar===>',name)

#按照有参和无参可以将函数调用。分两种：

  1.定义时无参，调用时也无需传入参数
  2.定义时有参，调用时也必须有参数

foo() #定义时无参，调用时也无需传入参数
bar('egon') #定义时有参，调用时也必须有参数


#按照函数的调用形式和出现的位置，分三种：

  1.调用函数的语句形式
  2.调用函数的表达式形式
  3.把函数调用当另外一个函数的参

foo() #1.调用函数的语句形式

def my_max(x,y):
    res=x if x >y else y
    return res

# res=my_max(1,2) #2.调用函数的表达式形式
# print(res)


res=my_max(my_max(10,20),30) #3.把函数调用当中另外一个函数的参数
print(res)

 

python中变量的赋值只是一种绑定操作，变量没储值功能：

x=2 -->内存中只是存了2这个值，然后把x指到（绑定）这个值上了

 

5）函数的参数

函数的参数分两种：形参(变量名)，实参（值）

#定义阶段 def foo(x,y): #x=1,y=2     定义阶段不会占用内存空间，调用阶段会，执行完了就释放内存空间
             print(x)     
             print(y)

#调用阶段 foo(1,2)

详细的区分函数的参数分为五种：
  位置参数，关键字参数，默认参数，可变长参数（*args和**kwargs）,命名关键字参数：

• 位置参数

def foo(x,y,z):#位置形参:必须被传值的参数
    print(x,y,z)

foo(1,2,3) #位置实参数：与形参一一对应

输出：

1 2 3

 

只要是 *后面的实参就是位置实参，如：

 

• 关键字参数

def foo(x,y,z):
    print(x,y,z)

foo(z=3,x=1,y=2)

#关键字参数需要注意的问题：
# 1：关键字实参必须在位置实参后面
# 2: 不能重复对一个形参数传值

# foo(1,z=3,y=2) #正确
# foo(x=1,2,z=3) #错误  位置参数跟在关键字参数后面了，错

# foo(1,x=1,y=2,z=3)  #错误 重复传值了

 只要是 **后面实参就是关键字实参：

 

• 默认参数

# def register(name,age,sex='male'): #形参：默认参数
#     print(name,age,sex)
#
# register('asb',age=40)
# register('a1sb',39)
# register('a2sb',30)
# register('a3sb',29)
#
# register('钢蛋',20,'female')
# register('钢蛋',sex='female',age=19)

#默认参数需要注意的问题：
#一：默认参数必须跟在非默认参数后
# def register(sex='male',name,age): #在定义阶段就会报错
#     print(name,age,sex)

#（了解）二：默认参数在定义阶段就已经赋值了，而且只在定义阶段赋值一次 ---> 重复定义也只取第一次
# a=100000000
# def foo(x,y=a):
#     print(x,y)
# a=0
# foo(1)

#三：默认参数的值通常定义成不可变类型

 

• 可变长参数

*args    *会把溢出的位置定义的实参都接收，以元组的形式赋值给args   --- 注意使用时是位置实参，只是args是元组了。

def foo(x,y,*args): #*args --- 拆开：*会把溢出的按位置定义的实参都接收，以元组的形式赋值给args
    print(x,y)
    print(args)

foo(1,2,3,4,5)

输出：
1，2
(3,4,5)

例如：

# def add(*args):
#     res=0
#     for i in args:
#         res+=i
#     return res
# print(add(1,2,3,4))
# print(add(1,2))

输出：

10
3

 

 

**kwargs     **会把溢出的关键字定义的实参都接收，以字典的形式赋值给kwargs       一一对应，注意在使用时是关键字实参，只是kwargs是字典了。

# def foo(x, y, **kwargs):  # **会把溢出的按关键字定义的实参都接收，以字典的形式赋值给kwargs
#     print(x, y)
#     print(kwargs)
# foo(1,2,a=1,name='egon',age=18)

例如：

def foo(name,age,**kwargs):
    print(name,age)
    if 'sex' in kwargs:
        print(kwargs['sex'])
    if 'height' in kwargs:
        print(kwargs['height'])

foo('egon',18,sex='male',height='185')
foo('egon',18,sex='male')

输出：

egon 18
male
185
egon 18
male

 

综合：

 

------  >  *args,**kwargs

这样就可以接受任意形式，任意长度的实参。

 

• 命名关键字参数

def foo(name,age,*,sex='male',height):
    print(name,age)
    print(sex)
    print(height)
foo('egon',17,height='185')

*后定义的参数为命名关键字参数，这类参数，必须被传值，而且必须以关键字实参的形式去传值 --> A="s"

例如

def foo(x,y,z):
    print('from foo',x,y,z)
def wrapper(*args,**kwargs):
    print(args) #args=(1,2,3)
    print(kwargs) #kwargs={'a':1,'b':2}
    foo(*args,**kwargs) #foo(*(1,2,3),**{'a':1,'b':2}) #foo(1,2,3,b=2,a=1)
# wrapper(1,2,3,a=1,b=2)
wrapper(1,z=2,y=3)

 输出

(1,)
{'z': 2, 'y': 3}
from foo 1 3 2

 

6）函数的返回值

return语句[表达式]退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。

 例如

def foo():
    print('from foo')
    return None
res=foo()
print(res)

输出

from foo
None

 

返回的方式： 

1.返回none：

以三种情况返回值都为None：

2.返回一个值：

输出：

from foo
1

3.返回好几个值：

 

return 值1,值2，值3,... 返回结果:(值1,值2，值3,...)

def foo():
    print('from foo')
    x=1
    return 1,[2,3],(4,5),{}
res=foo()
print(res) #打印结果：(1,[2,3],(4,5),{})
a,b,c,d=foo()
print(d)

输出：

from foo
(1, [2, 3], (4, 5), {})
from foo
{}

 

7) 补充：

变量取值

--- 只取其中某些值：