1. 函数的定义
函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段
函数能提高应用的模块性,和代码的重复利用率。Python提供了许多内建函数,比如print()。但是也可以自己创建函数,这被叫做用户自定义函数
定义一个由自己想要功能的函数,以下是简单的规则
函数代码块以 def 关键词开头,后接函数标识符名称和圆括号 ()。
任何传入参数和自变量必须放在圆括号中间,圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始,并且缩进。
return [表达式] 结束函数,选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
def 函数名(参数列表):
函数体
#函数的定义与使用
#定义一个没有参数,没有返回值(返回值为空)的函数
def hello1():
print("hello world!")
#定义一个有参数,没有返回值(返回值为空)的函数
def hello2(name):
print(f"hello {name}!")
#定义一个没有参数,有返回值的函数
w=3
h=4
def area1():
return w*h
#定义一个有参数,有返回值的函数
def area2(w,h):
return w*h
#调用函数
hello1()
hello2("zhangsan")
print(area1())
print(area2(7,8))
2. 函数的调用
定义一个函数:给了函数一个名称,指定了函数里包含的参数,和代码块结构
这个函数的基本结构完成以后,可以通过另一个函数调用执行,也可以直接从 Python 命令提示符执行
3. 参数传递
String,tuple和number是不可更改的对象,如果作为函数的参数,在函数内部进行的修改不会影响到函数外;而list,dict,set等则是可以修改的对象,如果作为函数的参数,在参数内部进行的修改会影响到函数外。
可更改(mutable)与不可更改(immutable)对象
在 python 中,strings, tuples, 和 numbers 是不可更改的对象,而 list,dict 等则是可以修改的对象。
不可变类型:变量赋值 a=5 后再赋值 a=10,这里实际是新生成一个 int 值对象 10,再让 a 指向它,而 5 被丢弃,不是改变a的
值,相当于新生成了a。
可变类型:变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改,本身la没有动,只是其内部的一
部分值被修改了。
python 函数的参数传递:
不可变类型:类似 c++ 的值传递,如 整数、字符串、元组。如fun(a),传递的只是a的值,没有影响a对象本身。比如在 fun(a)
内部修改 a 的值,只是修改另一个复制的对象,不会影响 a 本身。
可变类型:类似 c++ 的引用传递,如 列表,字典。如 fun(la),则是将 la 真正的传过去,修改后fun外部的la也会受影响
python 中一切都是对象,严格意义我们不能说值传递还是引用传递,我们应该说传不可变对象和传可变对象。
#参数的可变与不可变
#数字,字符串,元组是不可变类型,当参数时传递的是值,不会被函数改动
a=3
b="4"
c=(1,2)
def change1(a,b,c):
a=4
b="5"
c=(1,2,3)
print("函数内:",a,b,c)
change1(a,b,c)
print("函数外:",a,b,c)
#列表,字典,集合是可变类型,当参数时传递的是指针,会被函数改动
a=[1,2]
def change2(a):
a.append(4)
print("函数内:",a)
change2(a)
print("函数外:",a)
4. 必需参数
必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样
必需参数使用的时候传入的参数应该与定义时一致,如果使用关键字形式传递可以忽略顺序
5. 可变参数/不定长参数
可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数,和上述 2 种参数不同,声明时不会命名
在参数名前面加一个星号*,这时候传入的全部参数会被当成一个元组统一处理
如果在函数调用时没有指定参数,它就是一个空元组。我们也可以不向函数传递未命名的变量
#固定参数和可变长度参数
#固定参数
def f1(a,b,c):
return a+b-c
print(f1(1,2,3))
print(f1(3,2,1))
#print(f1(1,2)) 这句运行会出错TypeError: f1() missing 1 required positional argument: 'c'
#设置默认值 一般默认值会写在最后
def f2(a,b,c=0):
return a+b-c
print(f2(1,2,3))
print(f2(3,2))
#不定长参数
#对任意多个整数求和
def mysum1(*n):
print(n)
return sum(n)
print(mysum1())
print(mysum1(1))
print(mysum1(1,2))
print(mysum1(1,2,3))
#固定参数加可变参数
def mysum2(a,*n):
print(a,n)
return a*sum(n)
print(mysum2(1))
print(mysum2(2,3,4))
print(mysum2(1,2,3,4))
6. 关键词参数
关键字参数和函数调用关系紧密,函数调用使用关键字参数来确定传入的参数值
使用关键字参数允许函数调用时参数的顺序与声明时不一致,因为 Python 解释器能够用参数名匹配参数值
关键字参数一般用**,可以输入任意多个值,但是一定要用=,会被当成字典解读
限定关键字
#关键字参数
def printme1(name,**kw):
"打印任何传入的字符串"
print(name,kw)
return
printme1("Tom",course="安全课程",age=99)
#关键字有限定范围
def printme2(name,*,course,age):
print("名字:",name)
print("课程:",course)
print("年龄:",age)
printme2("tom",course="python",age=18)
#printme2("tom",course="python",a=18) 这行会报错TypeError: printme2()
# got an unexpected keyword argument 'a'
#printme2("tom",course="python") 这行会报错TypeError: printme2() missing 1
# required keyword-only argument: 'age'
7. 匿名函数
通常就一行,使用lambda,必须传参数
所谓匿名,意即不再使用 def 语句这样标准的形式定义一个函数。
lambda 只是一个表达式,函数体比 def 简单很多。
lambda的主体是一个表达式,而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda 函数拥有自己的命名空间,且不能访问自己参数列表之外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行,却不等同于C或C++的内联函数,后者的目的是调用小函数时不占用栈内存从而增加运行效率。
#匿名函数 使用lambda定义,通常只有一行
f1=lambda i:i*i
print(f1(3))
#相当于
def f1(i):
return i*i
print(f1(3))
#匿名函数必须传参数
f2=lambda i,j:i+j
print(f2(2,3))
print(f2("2","3"))
print(f2([1,2],[3,4]))
8. 高阶函数
可以把函数当参数使用的函数
#高阶函数,以函数为参数的函数
#过滤函数filter
a=[1,2,3,4,5,6,7]
b=list(filter(lambda i:i%2==0,a)) #过滤出a中的全部偶数
print(b)
s1=["Alice","Tom","Smith","Tony"]
s2=list(filter(lambda i:i.startswith("T"),s1)) #过滤出s1中T开头的
print(s2)
#映射函数map map(f,[a,b,c])相当于[f(a),f(b),f(c)]
c=list(map(lambda i:i*i,a))
print(c)
print([i*i for i in a])
#递归函数 reduce(f,[a,b,c])相当于f(f(a,b),c)
from functools import reduce
d=reduce(lambda i,j:10*i+j,a)
print(d)
#排序函数sorted
db=[('1701',88,77),('1702',85,79),('1703',90,70)]
print(sorted(db)) #默认第一项排队
print(sorted(db,key=lambda i:i[1])) #指定第二项排队
print(sorted(db,key=lambda i:i[2])) #指定第三项排队
print(sorted(db,key=lambda i:i[1]+i[2]))#指定总分排队
9. 常见的内置函数
Any只要一个为真就为真,字符串有东西就是真,all一个为假就为假
Round四舍五入,divmod除数和余数运算结果结合起来,返回一个包含商和余数的元组
10. 练习一:BASE64编码
#bases64编码
mmb="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
#输入要编码的语句
s1=input("请输入要编码的语句:")
#把输入的语句变成数字字符
bs=s1.encode()
#print(bs)
#把数字形式的语句进行3个一组分段
length=len(bs)
dlen=length//3
if length%3>0:
dlen+=1
dlist=[]
for i in range(dlen):
dlist.append(bs[i*3:i*3+3])
#print(dlist)
#对每一个分段进行变换
def three2four(data):
#12345678 12345678 12345678
#123456 781234 567812 345678
n1=data[0]>>2
n2=(data[0]%4)*16+(data[1]>>4)
n3=(data[1]%16)*4+(data[2]>>6)
n4=data[2]%64
return mmb[n1]+mmb[n2]+mmb[n3]+mmb[n4]
def two2four(data):
#12345678 12345678
#123456 781234 567800 000000(=)
n1=data[0]>>2
n2=(data[0]%4)*16+(data[1]>>4)
n3=(data[1]%16)*4
return mmb[n1]+mmb[n2]+mmb[n3]+"="
def one2four(data):
#12345678
#123456 780000 000000(=) 000000(=)
n1=data[0]>>2
n2=(data[0]%4)*16
return mmb[n1]+mmb[n2]+"=="
result=""
for pd in dlist:
if len(pd)==3:
r=three2four(pd)
elif len(pd)==2:
r=two2four(pd)
else:
r=one2four(pd)
result+=r
#把变换的结果合并输出
print("编码的结果是:"+result)