主要内容

• 函数的声明
• 调用自定义函数
• 变量的作用域
• 各类函数参数的应用
• 使用lambda匿名函数
• python的其他内置函数

def hello():                              #函数的声明与调用
    print('hello little sister')
hello()    

hello little sister

def Sum(T):
    for i in T:
        i+=1
    return i
print('列表[1,2,3,4]的和为：%d'%Sum([1,2,3,4]))       #传递元组参数给函数
print('元组(1,2,3,4)的和为：%d'%Sum([1,2,3,4]))

列表[1,2,3,4]的和为：5
元组(1,2,3,4)的和为：5

#print('列表[1.1,2,3,4]的和为：%d'%Sum([1.1,2,3,4])    #因为整数与浮点数不能相加因此error
#print('元组(1,2.2,3,4)的和为：%d'%Sum([1,2.1,3,4]))

#位置参数传递
def hello(hi='你好',name='python'):    #带默认参数的函数
     print('%s,%s' % (hi,name))         

hello('hello small sister','i am small brother')  #带参数调用函数
hello()                                           #不带参数调用

hello small sister,i am small brother
你好,python

def student(name='',age=0):
    print('姓名:%s,年龄:%s' %(name,age))

student('李寻欢',20)          #按位置传递参数
student(age=19,name='李寻欢') #按参数名传递参数可以不按顺序

姓名:李寻欢,年龄:20
姓名:李寻欢,年龄:19

#可变数量参数传递
def changnum(*tp1):
    print(type(tp1))           #输出tp1类型为元组类型，即把输入的参数作为一个元组
    print(tp1)
changnum(1,2,3,4)     

<class 'tuple'>
(1, 2, 3, 4)

#三种类型的参数
def change(*tp1,a,b=0):                          #b与#tp1必须赋值
    print('tp1:%s,a:%s,b:%s'%(tp1,a,b))           
change(1,2,3,4,a=100)           #如果*tp1多值赋值在前面，其他参数必须参数名赋值  

tp1:(1, 2, 3, 4),a:100,b:0

#change(1,2,3,4)                #此处出错

#字典参数**name
#字典参数必须放在参数之后
def tuplefunction(a,b=0,**dct): 
    print(type(dct))                #dct参数类型
    print('a:',a)
    print('b:',b)         
    print('dct:',dct)
tuplefunction(1,2,x=3,y=4,z=5)    

<class 'dict'>
a: 1
b: 2
dct: {'x': 3, 'y': 4, 'z': 5}

def cube(name,**nature):                   #求立方体体积
    a = {'x':1,'y':1,'z':1,'color':'white'}
    a.update(nature)                       #update更新dict数据有则覆盖无则追加
    print(name,'立方体的属性')
    print('体积:',a['x']*a['y']*a['z'])  
    print('立方体颜色:',a['color'])
cube('first')
cube('second',y=2,color='blue')             #提供部分参数
cube('third',x=2,y=2,color='purple')

first 立方体的属性
体积: 1
立方体颜色: white
second 立方体的属性
体积: 2
立方体颜色: blue
third 立方体的属性
体积: 4
立方体颜色: purple

#拆解数据类型提取数据
def mysum(a,b):
    return a+b
print('拆解元组调用')
print(mysum(*(3,4)))  #拆解tuple
print(mysum(**{'a':1,'b':2})) #拆解dict键名需与参数一致

拆解元组调用
7
3

#参数传递的可变与不可变
#数值型与元组都属于不可变类型
def chan(b,c):
    b=0             #函数中改变b的值
    c[0]=2
    c.append(6)     #函数中改变b list的值
    print('b:',b)
    print('c:',c)
b = 3                     
c = [1,4,3]        
print('调用前b:',b)     
print('调用前c:',c)
chan(b,c)
print('调用后b:',b)  #显然b的值不可变
print('调用后c:',c)  #列表的值改变

调用前b: 3
调用前c: [1, 4, 3]
b: 0
c: [2, 4, 3, 6]
调用后b: 3
调用后c: [2, 4, 3, 6]

def fun(list=[]):
    list.append('abc')
    print(list)
fun()
fun()
fun()      #显然调用三次改变三次

['abc']
['abc', 'abc']
['abc', 'abc', 'abc']

#变量的作用域
def func():
    a = 3
    print('函数内部局部作用域a:',a)
a = 10
print('函数外部全局作用域a：',a)
func()                      #因为作用域不同所以尽管变量名相同值也互不影响
print('调用函数后a:',a)

函数外部全局作用域a： 10
函数内部局部作用域a: 3
调用函数后a: 10

#global关键字使用全局变量
def functi():
    global c       #定义全局变量
    c = 10
    print('函数内c:',c)
c = 20
print('全局作用域c:',c)
functi()
print('调用函数后:',c)

全局作用域c: 20
函数内c: 10
调用函数后: 10

b=4               #定义全局变量
def println1():
    print(b)
println1()    

4

b = 4
def println():
    print(b)    #此时发生错误，因为在函数中定义了局部变量
    b = 5       #因此b被判定为局部变量而局部变量不能在未
                #引用前访问，而输出函数访问了b
println()    

---------------------------------------------------------------------------

UnboundLocalError                         Traceback (most recent call last)

<ipython-input-19-6a1a6431a3cf> in <module>()
      4     b = 5       #因此b被判定为局部变量而局部变量不能在未
      5                 #引用前访问，而输出函数访问了b
----> 6 println()


<ipython-input-19-6a1a6431a3cf> in println()
      1 b = 4
      2 def println():
----> 3     print(b)    #此时发生错误，因为在函数中定义了局部变量
      4     b = 5       #因此b被判定为局部变量而局部变量不能在未
      5                 #引用前访问，而输出函数访问了b


UnboundLocalError: local variable 'b' referenced before assignment

#使用匿名函数(lambda)
'''
   lambda的特点：
   简单可节省代码
   不重复使用
   可使代码清晰
'''
import math
s = lambda x1,y1,x2,y2:math.sqrt((x1-x2)**2+(y1-y2)**2) #定义一个求两点距离的匿名函数
s(1,1,0,0)

1.4142135623730951

#python常用内置函数
help(abs)     #查看对象信息
a = bin(20)
print(a)    #将十进制变成二进制
a = hex(20)       #将十进制变为十六进制
print(a)
a = oct(20)       #将十进制变位八进制
print(a)
callable(abs) #测试是否为可调用函数
a = 3
callable(a)
chr(97)     #将ascii码转为字符
ord('a')    #将字符转成ascii
alist = [0,1,2,3,4]
list(filter(lambda x:x % 2,alist)) #过滤掉偶数
list(map(lambda x:x*2,alist))      #对元素进行逐个变换

Help on built-in function abs in module builtins:

abs(x, /)
    Return the absolute value of the argument.

0b10100
0x14
0o24





[0, 2, 4, 6, 8]

---

总结：

python中的函数与其他高级语言相比主要的差别在与参数的的传递上面，python允许设置默认参数，允许传递可变长度的参数比如列表的传递与字典的传递。在这一点上比其他高级语言有更加强的安全性和灵活性。python还允许设置匿名函数，这有助于代码的简洁。