主要内容
- 函数的声明
- 调用自定义函数
- 变量的作用域
- 各类函数参数的应用
- 使用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还允许设置匿名函数，这有助于代码的简洁。
