python函数基础，嵌套函数作用域，匿名函数，高阶函数，内置函数

函数的定义：　

# 1,函数的定义(函数的目的是完成某一个特定的功能)
# def 函数名（形参）：
#     '文件描述，就是说明函数的原因，可以不用'
#     函数体
#     'return(返回结果)’

 

　　

带参数和不带参数：

#################具体事例（带参数）######################
# def test(x):# x ：形参
#     '''
#     文件描述，就是说明函数的原因，可以不用
#     :param x:x代表必须传入int
#     :return:返回一个值
#     '''
#     x+=1
#     return x
# print(test)#test是内存地址
# y=test(1)#运行函数把返回值给Y，1：实参
# print(y)
#################具体事例（不带参数）######################
# def test():
#     '''
#     文件描述，就是说明函数的原因，可以不用
#     :param x:x代表必须传入int
#     :return:返回一个值
#     '''
#     x=1
#     x+=1
#     return x
# print(test)#test是内存地址
# y=test()#运行函数把返回值给Y，
# print(y)

 

　　

函数的作用举例：

#################函数的作用举例######################
# 就是去除重复的代码，把他做成一个功能的函数，需要时调用就可以了。
# 好处：减少代码量，保持一致性，易维护性，可扩展
# 例：
# while 1:
#     if 'cup'>'90%':
#         #发送邮件
#         '连接邮箱服务器'
#         '发送邮件'
#         '关闭链接'
#     elif '硬盘' > '90%':
#         # 发送邮件
#         '连接邮箱服务器'
#         '发送邮件'
#         '关闭链接'
#     elif '内存' > '90%':
#         # 发送邮件
#         '连接邮箱服务器'
#         '发送邮件'
#         '关闭链接'
# # ######################可以简化##########################
# def '发送邮件'(内容):
#     '''
#
#     :return:
#     '''
#     '连接邮箱服务器'
#     '发送邮件'
#     '关闭链接'
# while 1:
#     if 'cup'>'90%':
#         '发送邮件'(‘CPU报警’)
#     elif '硬盘' > '90%':
#         '发送邮件'(‘硬盘报警’)
#     elif '内存' > '90%':
#         '发送邮件'(‘内存报警’)

 

　　

函数的返回值形式

##############函数返回值的几种形式##########
# def test1():
#     '''
#
#     :return:
#     '''
#     print('test1')
#     return {11,22}#返回一个元素结果本身
# def test2():
#     '''
#
#     :return:
#     '''
#     print('test2')#没返回值就是none
# def test3():
#     '''
#
#     :return:
#     '''
#     print('test3')
#     return 1,"qyl",[11,22,33],{1:'123'}#返回多个个元素结果是元组
# print(test1())
# print(test2())
# print(test3())

形参和实参：

##########形参和实参##########
#x,y叫形参，只用在被调用的时候，才分配内存，等调用结束后，释放内存，说以在内部使用
# def calc(x,y):
#     '''
#
#     :param x:
#     :param y:
#     :return: 算平方
#     '''
#     print(x)
#     print(y)
#     res=x**y
#     return res
# 2,3叫实参，可以是常量，变量，表达式，函数
# 1实参和形参必须一一对应这个叫位置参数
# calc(2,3)
# 2，关键字这个叫关键字参数
# calc(y=3,x=2)
# 3，参数组,位置参数必须在前面
# calc(1,y=2)
# 4，默认参数
#默认参数就是先给一个默认值实参可以不写就是默认值，写了就是实参的值
# def hendle(x,type=None):
#     print(x)
#     print(type)
# hendle(1)#不写就是默认值
# hendle(1,2)#写了就是实参值
# 6参数组为了后续维护扩展用
# **表示字典，*表示列表
def test(x,*args,**kwargs):#*args把位置参数后面的当一个元组元素给args=('qyl', 3, 4, 5)
    print(x)
    print(args)
    print(kwargs)
# test(1,'qyl',3,4,5)#args把位置参数后面的当一个元组元素给args=('qyl', 3, 4, 5)
# test(1)#不传就是一个空元组
# test(1,*[1,2,3])#加*就是把列表里面的元素组成一个元组传值
# test(1,[1,2,3])#不加就是把列表整个当元素组成一个元组传值
# test(1,{1:'qyl','qjq':'name'},"sadsad",y=1,z=123)#这个是一种方式传值
test(1,*[11,22,33],**{'1':'2'})#这个是第二种方式

局部变量和全局变量：

print('(3)局部变量和全局变量')
# 1全局变量：就是没有什么缩进定义的变量，就是在程序，任何地方都能调用
# name='qyl'#就是全局变量
#2局部变量：在之程序里面定义的变量的叫局部变量,出了外部变量就清空了
# def change_name():
#     name='qjq'#在里面的叫局部变量,出了外部变量就清空了
#     print('change',name)
# change_name()
# print('change',name)
#3局部变量：在之程序里面定义的变量的叫局部变量,出了外部变量就清空了
# def change_name():
#     global name #global定义全局变量，就是局部变量改成全局变量，里面的变量赋值外面的也跟着改变
#     name='qjq'#在里面的叫局部变量,出了外部变量就清空了
#     print('change',name)
# change_name()
# print('change',name)
# #4事例
# name = '老一'
# def change_name1():
#     name ='老二'
#     print(name)
#     def change_name2():
#         nonlocal name #这里指的是上一层的变量
#         name='老三'
#         print(name)
#         def change_name3():
#             name ='老四'
#             print(name)
#         print(name)
#         change_name3()
#     change_name2()
#     print(name)
# change_name1()
# 1老二，2，老三 3，老三 4 老四 5老二

前向引用“函数即变量”

######################4，前向引用之‘函数即变量‘###############
print('(4)前向引用之‘函数即变量‘')
# 就是必须先声明好函数体（相当于变量就是内存开辟的一个内存空间）否者报错才能去调用FOO(是一个内存地址),foo()就是调用里面的变量（就是函数体）
# 报错：没开辟bar函数体
# def foo():
#     print('from foo')
#     bar()#没开辟bar函数体
# foo()
# 报错bar函数体在调用后面
# def foo():
#     print('from foo')
#     bar()#没开辟bar函数体
# foo()
# def bar():
#     print('from bar')

嵌套函数和作用域

print('(5)嵌套函数和作用域')
# 就是函数里面还有函数
# def test1():
#     print('form test1')
#     def test2():
#         print('form test1')
#         '.....'
#         test2()
# test1()
# 作用域
# def test():
#     print('from test')
#     def test1():
#         print('from test1')
#     return test1
# test()()#test()返回的就是test1在加（）就是执行test1
########、# #############6， 递归    ############## ‘###############
# 就是函数体里面调用自己,会进入死循环
# def test():
#     print('from test')
#     test()
# test()
# 所以必须要有一个明确的结束条件和while 1加braek一样
# def test(n):
#     if int(n) <= 0:
#         return n
#     print(n)
#     return test(n/2)
# print(test(10))#结果是返回的最后一个结果

匿名函数

print('(6)匿名函数')
# 匿名函数
# res=lambda x,y,z:(x+1,y+1,z+1)#x是形参 x+1:就是函数体必须是一个
# print(res(10,11,12))
# # 相当于：
# def test(x,y,z):
#     return x+1,y+1,z+1
# print(test(10,11,12))

函数式编程

print("2,函数式编程#")
# 编程有3种方式：1，面向过程，2函数式编程，3面向对象
# # 面向过程：就是一步一步来 y=x*2+4
# def test(x):
#     x=x*2
#     x=x+4
#     return x
# print(test(10))
# #函数值编程，先考虑思路x*2+4,可读性比较差（不用变量保存状态）不修改变量
# def test(x):
#     return x*2+4
# print(test(10))

高阶函数

print('(1)高阶函数（就是只要满足下面2个条件之一就是高阶函数）')
# # 把函数当作参数传给另外一个函数
# def foo(n):
#     print(n)
# def bar(name):
#     print("my name is %s"%name)
# foo(bar('qyl'))
#函数体return 返回函数
# def foo():
#     print('from foo')
#     return bar()#返回的是bar的返回值
# def bar():
#     print('from bar')
# print(foo())
# 尾调用:返回的函数是最后一部调用，叫尾调用
# def bar(n):
#     print('bar',n)
#     return foo(n)
# def foo(x):
#     print('foo',x)
#     return bar(x)+1#不是最后一步，所以不是尾调用
# foo(10)
# # 可以改成尾递归
# def bar(n):
#     print('bar',n)
#     return foo(n)
# def foo(x):
#     print('foo',x)
#     x+1
#     return bar(x)
# foo(10)

函数式编程的重点

1,map

print("1,map")
##########################1,map############################
# 作用：处理序列中的每个元素，得到的结果是一个列表，该列表元素的个数及位置和庲的一样
# 例子：li=[1.2.5.6.8]做自加，自减，平方。。。。。
# li=[1,2,5,6,8]
# # 先想功能
# fucn_add=lambda x:x+1
# # def fucn_add(x):
# #     return x+1
# fucn_deduce=lambda x:x-1
# # def fucn_deduce(x):
# #     return x-1
# fucn_square=lambda x:x**2
# # def fucn_square(x):
# #     return x**2
# # 在做主程序
# def map_test(fucn,para):
#     res=[]
#     for item in para:
#         res.append(fucn(item))
#     return res
# print(map_test(fucn_add,li))
# print(map_test(fucn_deduce,li))
# print(map_test(fucn_square,li))
# 最终版本(就是自己做了一个map)
# li=[1,2,5,6,8]
# def map_test(fucn,para):
#     res=[]
#     for item in para:
#         res.append(fucn(item))
#     return res
# print(map_test(lambda x:x+1,li))
# print(map_test(lambda x:x-1,li))
# print(map_test(lambda x:x**2,li))

# 1,map内置函数
# li=[1,2,5,6,8]
# def fucn_add(x):
#     return x+1
# print(list(map(lambda x:x+1,li)))#处理方法 ，可迭代对象（处理计算的）
# print(list(map(fucn_add,li)))

2，filter

print('2，filter')
######################2，filter#############################
# 作用：遍历序列号的每个元素，判断每个元素得到布尔值，如果和条件相同为ture这留下来得到的结果是列表
# iden_li=["dr_qyl",'dr_xp','xr_qjq',"xr_xiaog"]
# # 想功能
# lambda x:x.startswith("dr")
# def fucn_sieve(x):
#     p1=[]
#     for p in x:
#         if  not p.startswith("dr"):
#                 p1.append(p)
#     return p1
# # 做主程序
# def main(fucn,array):
#      return fucn(array)
# print(main(fucn_sieve,iden_li))
# print(list(filter(lambda x:not x.startswith("dr"),iden_li)))#处理字符的把列表里面的元素和前面比较

3reduce函数

print("3,reduce函数")
################################3,reduce函数（响铃2个元素的处理）###############################################
# 作用：处理一个序列，然后把序列进行合并操作
# from functools import reduce#从functools中导入reduce模块
# mun=[1,2,3,4,5,6,100]
# # 功能
# lambda x,y:x+y
# def fucn_add(x,y):
#     return x+y
# def main(fucn,array):
#     n1=0
#     for n in array:
#         n1=fucn_add(n1,n)
#     return n1
# print(main(fucn_add,mun))
# print(reduce(lambda x,y:x+y,mun))#每个元素一个一个运算

别的内置函数

print('别的内置函数')
########################################4，别的内置函数##############
# print(abs(-1))#取绝对值
# print(pow(2,3))#算平方2**3
# print(pow(2,3,2))#2**3%2
# print(sum([1,2,3,4]))#1+2+3+4
# print(all([1,2,4,'12312',0]))#把每个元素做布尔元算（0，空字符，none,）如果有一个为假，结果是false
# print(any([1,2,4,'12312',0]))#把每个元素做布尔元算（0，空字符，none,）如果有一个为假，结果是Ture
# print(bin(10))#把数字变成2进制
# print(oct(12))#把数字变成8进制
# print(hex(12))#把数字变成16进制
# print(bool(10))#判断是不是布尔值0，空字符，none,，如果有一个为假，结果是false
# print(bool(10))#判断是不是布尔值0，空字符，none,，如果有一个为假，结果是false
# print(bytes('你好',encoding='utf-8'))#\xe4\xbd\xa0\xe5\xa5\xbd'换成字节就是6个字节就是编码
# print(b'\xe4\xbd\xa0\xe5\xa5\xbd'.decode('utf-8'))#\xe4\xbd\xa0\xe5\xa5\xbd'换成转换成看的懂的字就是解码
# print(chr(97))#ascll吗表
# print(ord("a"))#变成ascll吗
# print(dir(int))#看里面有哪些方法
# print(divmod(10,3))#做网页的分页功能的
# print(eval('{"name":123}'))#提取字符串里面的内容

# print(hash('sadadascas134'))#可hash的是不可变数据类型，不可hash的是可变数据类型,可以做密码用 也可以检验现在文件的可靠性
# print(help(list))#查看功能的帮助
# a="qyl"
# print(globals())#显示全局变量
# def test():
#     a='qyl'
#     print(locals())  # 显示当前的变量
#     print(vars())# ()里面没有内容显示当前的变量
# test()
# print(vars(int))#()有内容就是以字典的形式显示功能
# print(list(zip((1,2,3),('qyl','xu','qjq'))))#像拉链一样，一一对应放在元组里
# dic={'name':'qyl','age':19,'xb':'男'}
# print(list(zip(dic.keys(),dic.values())))
# print(max([1,3,10]))#取最大值
# age={'age1':43,'age2':16,'age3':36}
# print(list(max(zip(age.values(),age.keys()))))
# peplo=[
#     {'name':'qyl','age':43},
#     {'name':'qjq','age':16},
#     {'name':'xp','age':36}
# ]
# print(max(peplo,key=lambda x:x['age']))#max 把peplo的每个元素给x运算，在取最大值，显示出这组元素
# print(min([1,3,10]))#取最小值
# print(list(reversed([1,2,3,4])))#反转
# print(round(3.5))#四舍五入
# l='hello'
# print(l[slice(3,5)])#相当于l[3:5]

#########################面向 对象############################
# print(classmethod',''getattr','delattr','hasattr'，'super'‘setattr’,issubclass(),iter(),next(),object(),open(),property(),'repr()'" \33[31m面向对象再说\33[0m")
# print(isinstance(1,int))#第一个元素是不是第二个的实例，就是是不是第二个的类