# -*- coding:utf-8 -*-

#yys

#python 3.7.2

# 1.定义函数、调用函数

# 函数：组织好的、可重复使用的、用户实现单一或者关联功能的代码段。

# 函数能够提高应用的模块性和代码的重复利用率。

# Python提供了很多内置的函数，比如len等等，

# 另外也可以根据自己的业务需求进行用户自定义函数的创建。

# 1.1 函数的定义规则

# 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。

# 任何传入参数和自变量必须放在圆括号中间。

# 函数的第一行语句可以选择性地使用文档字符串---用于存放函数说明。

# 函数内容以冒号起始，并且缩进。

# 语法如下：

# def 函数名([参数列表]): #参数列表可选项

# 函数体

def f1():

print("good night")

def f2(x1,x2):

x3=x1+x2

print("函数体内部")

return x3

f1()#调用函数

# good night

x=f2(1,2)

print(x)

#函数体内部

#3

# 1.2 调用函数

# Python内置了很多函数，内置函数可以直接调用。

# 调用一个函数需要知道函数的名称和函数的参数。

# 语法：

# 函数名([参数列表])

# 函数名其实就是指向一个函数对象的引用，完全可以把函数名赋值给一个变量，相当于给这个函数起了一个别名

list1=[2,3,4,5,6]

a=len #变量a指向len函数

print(a(list1))

# 5

# 2.函数参数

# 2.1 形参和实参的概念

#def定义的函数中参数是形参(形式参数)，函数调用传入的是实参(实际参数)

#定义函数

def fun0(Name):#Name为形参

print("hello"+Name)

#调用函数

fun0('yys')#yys为实参

# helloyys

# 2.2 针对形参、实参进一步分类有 ：

# 函数参数分类

# 2.2.0必备参数

# 函数定义中允许拥有多个形参，因此函数在调用的时候，也可能包含多个实参。

#这些必须要传入函数的参数即必备参数；(不传入就会报错)

# 向函数传递参数的方式有很多，通过实参和形参的顺序对应，这就是位置实参。

# 只有位置一致，才能被正确匹配。位置实参是最简单也最常用的关联方式。( (arg1, arg2), 注意数量和顺序)

def fun1(a): #必备参数

print('必须传参数') #'调用：fun1(a)必须传参数

# 2.2.1 默认参数

# 函数定义的时候，设置的参数是形参。那么也可以给每个形参指定一个默认值。

# 当调用函数时，如果没有传入实参，就使用形参的默认值。

# 如果调用的时候传入了实参，那么程序将使用传入的实参，有默认值的放右边。

#即参数可传可不传，即可指定；当不传入参数是，该参数为之前指定的参数；

def fun2(a=3): #参数可传可不传，可指定

print(a,'默认参数')

fun2()

# 2.2.2关键字参数(关键字实参)

# 关键字实参是传递给函数的名称 = 值对。

# 直接在实参中将名称和值关联起来，因此向函数传递实参时不会混淆。

# 函数调用使用关键字参数来确定传入的值。

# 使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为Python解释器能够用参数名匹配参数值.

def fun3(pet1,pet2):

print(pet1,pet2)

fun3(pet1="猫猫",pet2="狗狗")

# 猫猫 狗狗

# 2.2.3 不定长参数

# 你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数。

#第一种不定常参数函数

def fun4(*arg): #结果都包装成元祖; (传0个或者0个以上的参数)

print(arg)

fun4(1,2,3,4) # (1, 2, 3, 4)

# 第二种不定常参数函数

def fun5(**kwarg): #参数可传可不传， 结果包装成字典; (传0个或者0个以上的参数)

print(kwarg,'可传可不传')

fun5()#{} 可传可不传

fun5(a="字典1") #注意实参的第一个为变量，形式为变量=value的形式

# {'a': '字典1'} 可传可不传

fun5(a="字典1",b="字典2")# #注意实参的第一个为变量，形式为变量=value的形式

# {'a': '字典1', 'b': '字典2'} 可传可不传

fun5(**{'c':1,'d':2,"4":4}) #加两个* 号,可以传递字典作为参数。键必须是字符类型。

# {'c': 1, 'd': 2, '4': 4} 可传可不传

dict1={1:2}

print(dict1)

# {1: 2}

#2.2.4 混合参数1

def fun6(e,f=1): #必备参数必须放在前面，否则报错

print(e+f)

fun6(e=2,f=3)

# 5

fun6(e=6)

# 7

fun6(9,10)

# 19

fun6(12)

# 13

# 2.2.5 混合参数函数2

# 要点，

# 定义的时候：必备参数要在默认参数之前；

# 调用时候关键字参数放最后，

# 确保必须取值的参数取到值

def fun7(*arg,b,m=1):#定义的时候，必备参数放默认参数之前

sum=""

for i in list(arg):

i=str( i )+","

sum+=i

print("打印不定参数:",sum)

print("必备参数b：",b)

print("打印默认参数m：",m)

fun7(1,3,b=2)#传实参的时候，必备参数使用变量=value的方式

# 打印不定参数: 1,3,

# 必备参数b： 2

# 打印默认参数m： 1

# 2.2.6 混合参数函数3,推荐！

#默认用这种顺序传递参数，必备、默认、不定常,这样顺序一般不会报错。

print("&"*10)

def fun8(b,m=1,*arg):

print("必备参数b：", b)

print("打印默认参数m：", m)

sum = ""

for i in list(arg):

i = str(i) + ","

sum += i

print("打印不定参数:", sum)

fun8(7,8,*(9,10,11)) #*号函数结果会解包

# 必备参数b： 7

# 打印默认参数m： 8

# 打印不定参数: 9,10,11,

fun8(17,*(19,110,111))

# 必备参数b： 17

# 打印默认参数m： 19

# 打印不定参数: 110,111,

print("R"*10)

fun8(12,13,(14,15,16)) #没*号函数结果不会解包

# 必备参数b： 12

# 打印默认参数m： 13

# 打印不定参数: (14, 15, 16),

print("Y"*10)

fun8(17,18)

#推荐以下函数的不定长参数写法

print("R"*10)

def fun9(a,b,c,d=100,*e,**f):

print("关键字参数a:",a)

print("关键字参数b:", b)

print("关键字参数c:", c)

print("默认参数d:",d)

print("不定长参数e:", e,"即结果包成元祖")

print("不定长参数f:", f, "即结果包成字典")

fun9(1,2,"星期四","夜晚","0322","0323","0324",name="xiaoming",age=18,sex="man")

# 关键字参数a: 1

# 关键字参数b: 2

# 关键字参数c: 星期四

# 默认参数d: 夜晚

# 不定长参数e: ('0322', '0323', '0324') 即结果包成元祖

# 不定长参数f: {'name': 'xiaoming', 'age': 18, 'sex': 'man'} 即结果包成字典

# 注意：

# 加了星号(*)的变量名会存放所有未命名的变量参数。(除了必备参数、默认参数)

# 加了(**)会存放所有命名的变量参数(除了必备参数、默认参数)

# 3.可变对象与不可变对象的传递

# 在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict,set等则是可以修改的对象。

#不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。

# 不可变类型：如 整数、字符串、元组。如fun(a)，传递的只是a的值，没有影响a对象本身。比如在 fun(a)内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。

# 可变类型：变量赋值 list1=[1,2,3,4] 后再赋值 list1[2]=5 则是将列表list1 的第三个元素值更改，本身list1没有动，只是其内部的一部分值被修改了

# 可变类型：如 列表，字典。如 fun(la)，则是将 la 真正的传过去，修改后fun外部的la也会受影响

# 4.函数返回值

#函数并非总是将结果直接输出，相反，函数的调用者需要函数提供一些通过函数处理过后的一个或者一组数据，只有调用者拥有了这个数据，才能够做一些其他的操作。

# 那么这个时候，就需要函数返回给调用者数据，这个就被称之为返回值，想要在函数中把结果返回给调用者，需要在函数中使用return。

# return语句用于退出函数，选择性的向调用者返回一个表达式或value。

def fun10(a,b):

return a+b

print(fun10(1,2))

# 3

# 直接return的语句返回None。

def fun11():

return

print(fun11())

# None

# 注意：return后语句不再执行。

def fun12(a,b):

if a>b:

return "早上好！"

elif a

return "中午好！"

return "晚上好"

print(fun12(1,2))

# 中午好！

#打印函数在内存中的地址

print(fun12)#

#注意4.2 Return和print区别

#print是将结果输出到控制台，

# return语句结束函数的调用，并将结果返回给调用者，

# 返回的结果不能输出到控制台(也就是不能直接打印出来)需要通过print才能打印出来

#4.3 函数类型

# 无参数，无返回值的函数

# 无参数，有返回值的函数

# 有参数，无返回值的函数

# 有参数，有返回值的函数

# 5. 生成器(generator)

# 5.1 使用了 yield 的函数被称为生成器。

#yield 的作用就是把一个函数变成一个generator(生成器)，

# 带有 yield 的函数不再是一个普通函数，Python 解释器会将其视为一个生成器，

#跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。

#在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回yield的值。并在下一次从当前位置继续运行。

print("G"*50)

def fun13(max):

a=0

b=1

while a

yield #只是yiled的时候返回None,与None一样；

print("打印b:",b)

b+=1

a+=1

print(fun13(3)) #

# 如上述调用fun13函数,不会执行该函数，而是返回一个iterable迭代对象！

# 区别:与return类似，都可以返回值，但不一样的地方，yield可以返回多次值，而return只能返回一次。

for i in fun13(3):

print(i)

# None

# 打印b: 1

# None

# 打印b: 2

# None

# 打印b: 3

print("H"*50)

def fun14(max):

a=3

b=4

while a

yield b

print("打印b:",b)

b+=1

a+=1

print(fun14(6))#

print(type(fun14(6)))#

print(next(fun14(6)))

print(next(fun14(6)))

print(next(fun14(6)))

for i in fun14(6):

print(i)

# 4

# 4

# 4

# 4

# 打印b: 4

# 5

# 打印b: 5

# 6

# 打印b: 6

print("@"*15)

def fun15():

print('start')

a = yield 1

print(a)

print('middle....')

b = yield 2 # 2这个值只是迭代值，调用next时候返回的值

print(b)

print('next')

c = yield 3

print(c)

a = fun15()

print(next(a))

# start

# 1

print(next(a))

# None

# middle....

# 2

print(next(a))

# None

# next

# 3

#注意如果生成器只能迭代3次，那么使用next(a)最多3次；

#5.2 生成器-send(generator)

# a = yield 1 这个表达式,

#先要执行yield 1,然后才是赋值

#yield把1值返回到了调用者那里,因为执行等号右边的yield就是暂停,所以不会对a赋值

# 那这个表达式的下一步操作:赋值,却换句话说a = yield 1 只执行到yield把1值返回到了调用者那里，所以a=None

# 而send()里面的值的作用是把值传进当前的yield.即执行对a的赋值

print("*"*20)

def fun16():

print('start_1')

a = yield 1

print(a)

print('middle_2')

b = yield 2 # 2这个值只是迭代值，调用next时候返回的值

print(b)

print('next_3')

c = yield 3

print(c)

a = fun16()

print(next(a))

# start_1

# 1

print(a.send(20))

# 20

# middle_2

# 2

# 6 迭代器

# 迭代器 迭代是Python最强大的功能之一，是访问集合元素的一种方式。

# 迭代器是一个可以记住遍历的位置的对象。 迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。

# 迭代器有两个基本的方法：iter() 和 next()。

# 字符串，列表或元组,集合对象都可用于创建迭代器：

print("U"*20)

list1=[1,2,3,4]

iter1 = iter(list1) # 创建迭代器对象

print(iter1)#

print(type(iter1))#

print (next(iter1)) # 输出迭代器的下一个元素

#1

print (next(iter1)) # 输出迭代器的下一个元素

#2

print (next(iter1)) # 输出迭代器的下一个元素

# 3

# 7.局部变量和全局变量

# 7.1 变量的作用域

# 一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。

# 变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。

# 两种最基本的变量作用域如下：

# 全局变量，即定义在函数外的拥有全局作用域。

# 局部变量，即定义在函数内部的变量拥有一个局部作用域。

# 全局变量修改

# 对于不可变类型的全局变量来说，要在函数中修改需要global 关键字声明,注意是修改，而不是赋值！

# 对于可变类型的全局变量来说，要在函数中修改可以不使用global声明,注意是修改，而不是赋值！

# 全局变量,全局变量是声明在函数外部的变量，定义在函数外的拥有全局作用域

#定义全局变量

a17=200

list17=[17,"早上好","晚上好"]

def fun17():

a17=50

list17=[17,"早上","中午","晚上"]

print("fun17()打印全局变量：",a17,list17)

fun17()

print(a17,list17)

# fun17()打印全局变量： 50 [17, '早上', '中午', '晚上']

# 200 [17, '早上好', '晚上好']

a18=300

list18=[18,"早上好","晚上好"]

def fun18():

global a18

a18=60

list18[1]=[18,"早上","中午","晚上"]

print("fun18()打印全局变量：",a18,list18)

fun18()

print(a18,list18)

# fun18()打印全局变量： 60 [18, [18, '早上', '中午', '晚上'], '晚上好']

# 60 [18, [18, '早上', '中午', '晚上'], '晚上好']

# 局部变量，就是在函数内部定义的变量；

# 不同的函数，可以定义相同的名字的局部变量，但是各用个的不会产生影响；

def fun19():

a19=100

print("fun19()打印局部变量：",a19)

fun19()

# fun19()打印局部变量： 100

def fun20():

global a20,list20

a20 = 100

list20=[1,2,3]

print("fun20()打印局部变量：",a20,list20)

def fun21():

fun20()

print("fun21()打印局部变量：",a20,list20)

fun21()

# fun20()打印局部变量： 100 [1, 2, 3]

# fun21()打印局部变量： 100 [1, 2, 3]

#8.匿名函数

# 匿名函数：定义函数的过程中，没有给定名称的函数就叫做匿名函数；Python中使用lambda表达式来创建匿名函数。

# lambda 来创建匿名函数规则。

# lambda只是一个表达式，函数体比def简单很多。

# lambda的主体是一个表达式，而不是一个代码块，所以不能写太多的逻辑进去。

# lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。

# lambda定义的函数的返回值就是表达式的返回值，不需要return语句块

# lambda表达式的主要应用场景就是赋值给变量、作为参数传入其它函数

# lambda匿名函数的表达式规则是：

# lambda 参数列表: 表达式

# 由于lambda返回的是函数对象(构建的是一个函数对象)，所以需要定义一个变量去接收

sum1 = lambda arg1, arg2: arg1 + arg2;

print ("相加后的值为 : ", sum1( 20, 30 )) # 相加后的值为 : 50

listfun=lambda list19:[i for i in list19 if i%2==0 ]

print("输出列表中的偶数：",listfun([1,2,3,4,5,6,7]))

# 输出列表中的偶数： [2, 4, 6]

# 对字典排序

list20 = [{"name":"wang","age":10},{"name":"xiaoming","age":20},{"name":"banzhang","age":15}]

list20.sort(key=lambda x:x['age']) #根据age对字典排序

print(list20)

#[{'name': 'wang', 'age': 10}, {'name': 'banzhang', 'age': 10}, {'name': 'xiaoming', 'age': 20}]

# 把lambda当一个变量

def fun22(a,b,func):

result = func(a,b)

return result

num = fun22(11,22,lambda x,y:x+y)

print(num)

# 33

#9. 递归函数

# 递归函数：递归就是子程序(或函数)直接调用自己或通过一系列调用语句间接调用自己;

# 是一种描述问题和解决问题的基本方法。(即，自己调用自己)

def fun23(n):

if n==1:

return 1

return n * fun23(n - 1)

x=fun23(5)

print(x)#120

def fun24(n):

return fun25(n, 1)

def fun25(num, product):

if num == 1:

return product

return fun25(num - 1, num * product)

x2=fun24(5)

print(x2)#120

# 斐波那契数列(Fibonacci sequence)是以如下被以递归的方法定义：

# F(0)=0，F(1)=1, F(n)=F(n-1)+F(n-2)(n>=2，n∈N*)

#效率最高

# 直接输出

def fun25(n):

f1=1

f2=1

if (n==1 or n==2):

return 1

else:

for i in range(3,n+1):

f1,f2=f2,f1+f2

return f2

print(fun25(6))

#效率最低

# 把之前的数据存起来而不是计算

# 递归输出方式一

# 这个斐波那契数还可以使用递归进行输出，就是非常直观的递归计算。

def fun26(n):

if (n==1 or n==2):

return 1

else:

return fun26(n-1)+fun26(n-2)

print(fun25(10))

# 55

#10. 内置函数与高阶函数

# 常用内置函数

# abs() 函数返回数字的绝对值。

num = -32.199

print(abs(num)) #32.199

# sorted(list) 排序，返回排序后的list

print(sorted([1, 3, 5, 0] ,reverse = True)) #[5, 3, 1, 0]

# 备注 li.sort()和sorted()两种方法的区别?

# 1). 列表里面提供了sort方法， 其他数据结构没有.sorted方法可以对任何可迭代对象排序.

# 2).sort方法支持原地排序(变量排序后， 变量本身改变), sorted排序后返回一个新的列表,并不改变原变量的内容.

# sum(list) 求取list元素的和

print(sum([1,2,3,4])) #10

# round(a,b) 获取指定位数的小数。a代表浮点数，b代表要保留的位数

print(round(3.1415926,3))#3.142

# isinstance 类型判断

a=[1,2,3]

print(isinstance (a,(str,int,list) )) #True

print(isinstance (a,(str,int) )) #False

print(isinstance (a,(list) )) #True

# eval() 执行一个表达式，或字符串作为运算

print(eval('1+1')) #2

print(eval("9*10")) #90

# exec() 输出python语句

exec('print("Python")')

# 常用高阶函数

# map(func,seq[,seq[,seq...]]) ->list 接收一个函数及多个集合序列，

# 会根据提供的函数对指定序列做映射，然后返回一个新的map对象。

# map(func, lst)，将传入的函数变量func作用到lst变量的每个元素中，并将结果组成新的列表返回

list21=[x**2 for x in range(5)]

# print(list21)

# [0, 1, 4, 9, 16]

list22=map(float,list21)

print(list22)#

def fun26(x):

return x * x

print( map(fun26, [ 7, 8, 9] ) )#

for i in map(fun26, [7, 8, 9] ):

print(i)

# 49

# 64

# 81

print((map(abs, [-1, 3, -4, -5])))#

print(list(map(abs, [-1, 3, -4, -5])))#[1, 3, 4, 5]

# filter(func,seq) ->list or tuple or string

# 用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的filter对象。

print("*"*20)

def fun27(x):

if x%2==0:

return x

print([i for i in range(1,11) if fun27(i)])

# [2, 4, 6, 8, 10]

#reduce(func,seq[,initvalue])

#对于序列中的所有元素调用func进行数据合并操作，可以给定一个初始值。

from functools import reduce # 导入reduce,

def fun28(x, y):

return x * y

print(reduce(fun28, range(1, 6)))#120

# Python闭包：

# 如果在一个内部函数，对外部作用域(非全局作用域)的变量进行引用，那么内部函数FuncY()就被认为是闭包(closure)。

# 一个闭包就是你调用了一个函数FuncX()，这个函数FuncX()返回了一个函数FuncY()给你 这个返回的函数FuncY()就叫做闭包。

# 你在调用函数FuncX()的时传递的参数x就是自由变量

def FuncX(x):

def FuncY(y):

return x * y

return FuncY