一、自定义函数
python中的函数与C中的函数作用相同，都是一段代码的封装，需要了解的是python中的语法和python中特有的操作。这里简单记录下python中函数的特性。
形参的分类有：
1.必选参数 2.默认参数 3.可选参数 4.关键字可选参数
1.1 函数的定义、形参、实参、传参、调用举例
与C语言大致相同，但需要注意的是python中万物皆对象，在函数调用时，实参传递就是对象的引用。举例如下：
a=1
def fun1(x):
print('x的地址是{}'.format(id(x)))
x=2
print('x修改后的地址是{}'.format(id(x)))
print('x的值是',end=" ")
print(x)
pass
print('a的地址是{}'.format(id(a)))
fun1(a)
print('调用函数后a的地址是{}'.format(id(a)))
print('a的值是', end=" ")
print(a)
#a的地址是2107354343728
#x的地址是2107354343728
#x修改后的地址是2107354343760
#x的值是 2
#调用函数后a的地址是2107354343728
#a的值是 11.2 全局变量与局部变量
全局变量和局部变量 的特性和C语言一样（作用域等），不同的是，python中在函数内部要修改全局变量要是用关键字 global。
num=10
def fun():
# num=50
print('这里是不能修改全局变量的值的')
global num
num+=1
pass
fun()
print('全局变量被修改:',end="")
print(num)
#这里是不能修改全局变量的值的
#全局变量被修改:11
#必选参数测试：21.3 参数类型分类
1.31 必选参数
所谓“必选参数”，即调用时 形参 与 实参 必须匹配，这与C相同。
def sum(a,b):
c=a+b
print('必选参数测试：%d'%(c))
print('--------end of sum---------------')
pass
sum(1,1)
#必选参数测试：2
#--------end of sum---------------1.32 默认参数（缺省）
函数声明时，可以给形参一个默认值，当调用时如果未赋值，就会使用函数定义时给的默认值 。
def sum1(a=30,b=30):
print('默认参数测试：%d'%(a+b))
print('--------end of sum1---------------')
pass
sum1() #默认参数测试：60 30+30
sum1(10) #默认参数测试：40 10+30
sum1(0,20) #默认参数测试：20 0+201.33 可选参数
当参数的个数不确定时使用 *args 表示可变长的参数，传入的参数是一个元组。
def getvalue(*args):
print('传入的参数是：',end=" ")
print(args)
print('传入的参数的类型是：', end=" ")
print(type(args))
value=0
for i in args:
value+=i
pass
print('函数getvalue的返回值是',end=" ")
return value
print(getvalue(1,2,3,5,6,4,6,8,2,8,2,5,6,5,77))
print('--------end of getvalue---------------')
#传入的参数是： (1, 2, 3, 5, 6, 4, 6, 8, 2, 8, 2, 5, 6, 5, 77)
#传入的参数的类型是： <class 'tuple'>
#函数getvalue的返回值是 1401.34 关键字可选参数
参数0~N个 用**kwargs表示关键字可选参数，传入的参数是一个字典类型
def keyfun(**kwargs):
print('传入的参数是：', end=" ")
print(kwargs)
print('传入的参数的类型是：', end=" ")
print(type(kwargs))
print('--------end of keyfun---------------')
pass
a={'name':'ZXL','age':'zzz','school':'ccit','职业':'程序员','第址':'常州'}
keyfun(**a) #传参时必须用两个*
#传入的参数是： {'name': 'ZXL', 'age': 'zzz', 'school': 'ccit', '职业': '程序员', '第址': '常州'}
#传入的参数的类型是： <class 'dict'>
#--------end of keyfun---------------1.35 可选参数、关键字可选参数组合使用
可选参数必须放到关键字可选参数之前，否则会编译出错。
def TestMup(*args,**kwargs):
print(args)
print(kwargs)
print('--------end of TestMup---------------')
pass
TestMup(1,2,3,4,name='ZXL')
#(1, 2, 3, 4)
#{'name': 'ZXL'}
#--------end of TestMup---------------1.4 匿名函数
1.匿名函数 即 没有名字的函数
2.匿名函数格式： lambda 参数1,参数2,参数3 ：表达式
3.匿名函数冒号后面的表达式只能有一个
4.匿名函数自带return ，结果就是表达式的结果
5.只能是一个表达式，不适用于复杂逻辑可以自定义一些常用的表达式 类似C中的 #define
举例1
#匿名函数定义
m=lambda x,y,z:x+y+z
#匿名函数使用
print(m(1,2,3))
print('-----------------------------------')举例2
#可以自定义一些常用的表达式 类似C中的 #define
functest=lambda x,y:x if x>y else y #比较两个参数的大小,输出较大值
print(functest(1,2))
print('--------------等价方式---------------------')
a=functest=(lambda x,y:x if x>y else y)(1,2)
print(a)
#2
#--------------等价方式---------------------
#21.5 递归函数
递归函数即函数内部调用自己本身；与C相同，递归函数必须有结束条件，代码简洁，但易导致栈溢出，内存泄露
举例：求5的阶乘
def fun(n):
if n==1:
return 1
pass
else:
return n*fun(n-1)
pass
print("5的阶乘{}".format(fun(5)))
#5的阶乘120举例：树形结构遍历 ，遍历电脑路径《D:\3、单片机开发工具》文件件下的所有文件
import os #引入文件操作模块
def FindFile(file_path):
listRs=os.listdir(file_path)#得到该路径下的所有文件夹
for i in listRs:
file_path=os.path.join(file_path,i)#获取完整的文件路径
if os.path.isdir(file_path):#判断是否是文件件
FindFile(file_path) #是文件夹则继续查找
else:
print(i)
pass
return 0
FindFile('D:\\3、单片机开发工具') #\\ 表示 \ 是转义字符二、内置函数
内置函数按照功能分类可分为下列几种：
数学运算： abs()、round()、pow()、divmod()、max()、min()、sum()、eval()
类型转换： int()、float()、str()、ord()、chr()、bool()、bin()、hex()、oct()、list()、tupe()、dict()、bytes()
序列操作： all()、any()、sorted()、reverse()、range()、zip()、
数学运算： add()、clear()、difference()、intersection()、union()、pop()、discard()、update()
2.1 算数运算类函数
2.1.1 常用算数运算举例
#取绝对字号 abs
print(abs(-5)) #输出5
#求近似值（四舍五入）round
print(round(3.14)) #输出3
print(round(3.55)) #输出4
print(round(3.66,1)) #输出3.7 四舍五入保留1位小数
#求指数 pow
print(pow(3,3)) #输出27 3的3次方
print(3**3) #输出27 3的3次方
#求商 和 余数 divmod
print(divmod(27,3)) #输出(9, 0) 一个商和余数的元组
#求最大/小值 max/min
print(max([23,55,68,841,2525,2225,6511,8982,23])) #输出8982 参数可以使列表、元组、集合
print(max(23,55,68,841,2525,2225,6511,8982,23)) #输出8982 参数可以使列表、元组、集合
print(max((23,55,68,841,2525,2225,6511,8982,23))) #输出8982 参数可以使列表、元组、集合
print(min([23,55,68,841,2525,2225,6511,8982,23])) #输出23 参数可以使列表、元组、集合
print(min(23,55,68,841,2525,2225,6511,8982,23)) #输出23 参数可以使列表、元组、集合
print(min((23,55,68,841,2525,2225,6511,8982,23))) #输出23 参数可以使列表、元组、集合
#求和 sum
print(sum([23,55,68,841,2525,2225,6511,8982,23])) #输出21253 参数可以使列表、元组、集合
print(sum((23,55,68,841,2525,2225,6511,8982,23))) #输出21253 参数可以使列表、元组、集合
print(sum(range(100))) #输出1225 参数可以使列表、元组、集合2.1.2 动态执行表达式 eval（）
函数用来执行一个字符串表达式，并返回表达式的值。
#动态执行表达式 eval
a,b,c=1,2,3
print(eval('a*b+c+30')) #输出35
print(eval('x*y+z+30',{'x':1,'y':2,'z':3})) #输出352.2 类型转换类函数
2.2.1 进制转换函数
bin(a)：输入参数转换为二进制
hex(a)：输入参数转换为十六进制
oct(a)：输入参数转换为八进制#进制转换举例
print('10进制5转16进制',end=" ")
print(hex(5)) #输出0x52.2.2 强制类型转换函数
int(a)：输入参数转换为int型
float(a) ：输入参数转换为flaot型
str(a) ：输入参数转换为字符串
list(a)：输入参数转换为列表类型
tuple(a)：输入参数转换为元组类型
dict(a)：输入参数转换为字典类型
bool(a)：输入参数转换为布尔类型
#类型转换举例 元组 列表 相互转换
tup=(5,4,3,2,1)
li=list(tup)
li.append('转换成功')
print(li) #输出[5, 4, 3, 2, 1, '转换成功']
tup=tuple(li)
print(tup) #输出(5, 4, 3, 2, 1, '转换成功')
2.3 序列操作函数
2.3.1 序列判断
all（）：元素除了是 0、空、None、False 外都算 True。 注意：空元组、列表返回true ， 类似与操作（and），一个为flase 全为flase
any（）：如果有一个为 True，则返回 True，类似或操作（or），有一个为True 全为True
#序列操作函数
# all() 元素除了是 0、空、None、False 外都算 True。 注意：空元组、列表返回true and
li=[1,2,3,4,5,6,'0',0]
print(all(li)) #输出False
# any() 如果有一个为 True，则返回 True or
print(any(li)) #输出True2.3.2 序列排序操作
sort（）： 只适用于列表
li=[1,2,3,5,8,96,7,563,55,5,6]
li.sort() #sort只适合列表
print(li) #默认是进行升序排序 输出：[1, 2, 3, 5, 5, 6, 7, 8, 55, 96, 563]sorted()： 适用范围更广 ，且不对源对象进行修改，而是将修改后的内容作为返回值返回
# sorted()
li=[1,2,3,5,8,96,7,563,55,5,6]
tup=(1,2,3,5,8,96,7,563,55,5,6)
print(sorted(li)) #输出[1, 2, 3, 5, 5, 6, 7, 8, 55, 96, 563]
print(sorted(tup)) #输出(1, 2, 3, 5, 8, 96, 7, 563, 55, 5, 6)
print(tup) #sorted() 不会修改原对象，而是将排序结果作为返回值返回
print(sorted(tup,reverse=True)) #sorted默认是升序排序，reverse=True可改为降序排序 ，对元组进行排序后返回的数据类型是列表
#输出[563, 96, 55, 8, 7, 6, 5, 5, 3, 2, 1]reversed() 反向排序
# reversed() 反向排序 # range()函数可创建一个整数列表
ls=list(range(10,20)) #生成10~19的整数做完列表元素放入列表s中
print('reversed反向排序输出结果',end=" ")
print(list(reversed(ls))) #输出reversed反向排序输出结果 [19, 18, 17, 16, 15, 14, 13, 12, 11, 10]2.3.3 数据压缩 zip()
zip函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
举例
a=['1','2','3']
b=['a','b','c']
c=['哈哈','嘿嘿','呵呵','嘻嘻']
print(list(zip(a,b))) #输出 [('1', 'a'), ('2', 'b'), ('3', 'c')]
print(list(zip(a,c))) #输出 [('1', '哈哈'), ('2', '嘿嘿'), ('3', '呵呵')]实例操作，输入编号、书名、书架号 书架自动压缩对应
def printBookInfo(): #定义函数
books=[] #存储所有的图书信息
ID=input('输入编号，移空格分隔') #数据输入并接收
BookName=input('输入书名，已空格分隔') #数据输入并接收
BookPos = input('输入货架，已空格分隔') #数据输入并接收
# split 通过指定分隔符对字符串进行切片，如果第二个参数 num 有指定值，则分割为 num + 1 个子字符串。
IDList=ID.split(' ')
BookNameList=BookName.split(' ')
BookPosList=BookPos.split(' ')
#zip打包
BookInfo=list(zip(IDList,BookNameList,BookPosList))
for i in BookInfo:
#遍历图书信息
dicinfo={'编号':i[0],'书名':i[1],'货架':i[2]}
books.append(dicinfo)
pass
for j in books:
print(j) #输出压缩后的信息
pass
printBookInfo() #调用函数
# 输入编号，移空格分隔11 22 33
# 输入书名，已空格分隔python c语言 c++语言
# 输入货架，已空格分隔AA BB CC
# {'编号': '11', '书名': 'python', '货架': 'AA'}
# {'编号': '22', '书名': 'c语言', '货架': 'BB'}
# {'编号': '33', '书名': 'c++语言', '货架': 'CC'}2.3.4 序列对象遍历 enumerate（）
将一个可遍历的对象（列表、元组、字符串、字典）组合成一个索引序列，同时可列出数据和数据下标 一般用于for循环
listobj=['a','b','c']
for i,j in enumerate(listobj):
print(i,j)
# 0 a
# 1 b
# 2 c
for i,j in enumerate(listobj,5): #可指定其实位置
print(i,j)
# 5 a
# 6 b
# 7 c2.4 集合操作函数
set 集合 类似一个字典，但是只有key 没有value，集合不支持索引和切片，是一个无需的且不重复的容器。
2.4.1 创建集合
#创建集合
set1={'1','2','3'} #创建的是集合
dic1={1:3} #创建的是字典
print(type(set1)) #输出 ：<class 'set'>
print(type(dic1)) #输出 ：<class 'dict'>2.4.2 向集合添加数据add（）
#集合添加
set1={'1','2','3'} #创建的是集合
set1.add('python')
print(set1) #输出的结果是无序的 输出：{'1', '2', 'python', '3'}2.4.3 清空集合 clear（）
#集合清空
set1.clear()
print(set1) # 输出：set()2.4.4 取两个集合的交集 intersection（）
#取两个集合的交集 intersection
setA={33,34,35}
setB={35,36,37}
print(setA.intersection(setB) ) # 取A集合、B集合中 共有的内容
print(setA&setB) #等价于intersection 函数
#输出
# {35}
# {35}2.4.5 取两个集合的差集 difference（）
#取两个集合的差集 difference
setA={33,34,35}
setB={35,36,37}
print(setA.difference(setB) ) # 取A集合中有，B集合中没有的数据
print(setA-setB) #等价于difference 函数
#输出
# {33, 34}
# {33, 34}2.4.6 取两个集合的并集 union（）
setA={33,34,35}
setB={35,36,37}
print(setA.union(setB) ) # 取A集合、B集合中 全部的内容
print(setA|setB) 2.4.7从集合中拿出顶部数据并同时删除 pop（）
#从集合中拿出顶部数据并同时删除 pop
setA={33,34,35}
print('setA移除前',end=" ")
print(setA)
print('setA移除元素',end=" ")
print(setA.pop())
print('setA移除后',end=" ")
print(setA)
# setA移除前 {33, 34, 35}
# setA移除元素 33
# setA移除后 {34, 35}2.4.8 从集合中移除指定元素 discard（）
#从集合中移除指定元素 discard
setA={33,34,35}
print('setA移除前',end=" ")
print(setA)
print('setA移除元素34')
setA.discard(34)
print('setA移除后',end=" ")
print(setA)
# setA移除前 {33, 34, 35}
# setA移除元素34
# setA移除后 {33, 35}2.4.9 更新集合update（）
#更新集合 类似 并集
setA={33,34,35}
setB={35,36,37}
setA.update(setB)
print(setA)即合并两个集合，类似取并集