一、函数的特殊用法

1.变量可以指向函数

代码演示：

#abs------>absolute#abs（）是一个系统的内置函数【built-in function】
print(abs(-10))   #10
print(abs)   #<built-in function abs>#结论一：abs(-10)是函数的调用，而abs是函数本身
x = abs(-20)
print(x)   #20f = abs
print(f)   #<built-in function abs>#结论二;函数本身也可以直接赋值给一个变量，也就是说：变量可以指向一个函数   num = 10
#如果一个变量指向了一个函数，则可以通过这个变量去调用这个函数
print(f(-30))#结论三：f = abs, 则表示f已经指向了abs所表示的函数，调用abs和调用f实现的效果是一样的def test():return  "fjskghs"print(test())
fun = test
print(fun())

2.函数名是一个变量

代码演示：

#函数的特殊用法之函数名是一个变量#结论一：函数名其实就是指向函数的变量#abs（）：可以将abs看做一个变量，指向了一个可以计算绝对值的函数#abs更改指向【变量的重新赋值】num = 10
num = "hello"#让abs指向一个整型
print(abs)
abs = 10
print(abs)#print(abs(-100))

3.函数作为参数

代码演示：

#函数的特殊用法之函数作为参数#变量可以指向函数，函数名是一个变量，而函数的形参本身就是一个变量，可以接收实参，那么一个函数就可以接收另一个函数作为参数
#高阶函数【一个函数就可以接收另一个函数作为参数】#一个简单的高阶函数【需求：求两个数的绝对值的和】
#参数：x和y就是需要参与运算的数据，fun是一个函数
"""
def add(x,y):return abs(x) + abs(y)"""
def add(x,y,fun):return fun(x) + fun(y)    #abs(x) + abs(y)#将函数名abs作为参数使用
result = add(-5,6,abs)    #x = -5  y = 6   fun = abs  fun()
print(result)#自定义函数
def show():print("abc")def func(f):print("hello")f()func(show)

二、偏函数【了解】

默认参数：可以降低函数调用的难度

偏函数：对函数参数做一些控制的函数

注意：偏函数不需要自定义，直接使用【系统函数】

代码演示：

import  functools# 偏函数的使用#int(x)   可以将字符串或者浮点型转换为整型
#默认：将其中的字符串按照十进制输出
print(int("123"))#int（）还提供了一个额外的参数：base
#print(int("abc123"))
#base；指明前面数据的进制，int()执行完成之后，最终还是以十进制输出
print(int("123",base = 10))   #123
print(int("123",base = 8))    #83print(int("110",base = 2))
print(int("11010",base = 2))
print(int("110001",base = 2))#转换大量的二进制，每次传入base = 2麻烦，可以将这个功能提取出来
def customInt(x,base=2):return int(x,base)
print(customInt("110"))  #6
print(customInt("11010"))  #26#上面通过默认参数模仿了偏函数的使用，但是系统提供了功能：functools.partial可以创建一个偏函数【前提；需要导入import  functools】
#参数：需要创建偏函数的原函数名  需要设定的参数
int2 = functools.partial(int,base=2)
print(int2("110"))   #6
print(int2("11010"))  #26print(int2("110",base=10))   #110#总结：偏函数
#主要针对的是系统函数，如果系统默认的操作满足不了需求，则可以在这个系统函数的基础上生成一个新的函数【偏函数】，两个函数可以实现不同的需求

三、闭包【掌握】

如果在一个函数的内部定义另外一个函数，外部的函数叫做外函数，内部的函数叫做内函数

如果在一个外部函数中定义一个内部函数，并且外部函数的返回值是内部函数，就构成了一个闭包，则这个内部函数就被称为闭包【closure】

代码演示：

"""
如果在一个函数的内部定义另外一个函数，外部的函数叫做外函数，内部的函数叫做内函数如果在一个外部函数中定义一个内部函数，并且外部函数的返回值是内部函数，就构成了一个闭包，
则这个内部函数就被称为闭包【closure】
"""#1.最简单的闭包
#外函数
def func(str):#内函数【闭包】def innerFunc():print("hello")return innerFunc#f中存储了外函数func的返回值，而func的返回值是innerFunc,j就相当于f = innerFunc
f = func("abc")   #f = innerFunc
#f（）就相当于innerFunc()
f()#2.
#a和b被称为外函数中的临时变量【自由变量】
def outer(a):b = 10def inner():#在内函数中可以直接使用外函数中临时变量print(a + b)return  innerf1 = outer(5)
f1()#3.
def outer1(num1):def inner1(num2):#在内函数中可以直接使用外函数中临时变量print(num1,num2)return  inner1f2 = outer1(10)
f2(20)#应用场景：装饰器

四、变量的作用域

1.出现的原因

变量的作用域：变量可以被使用【被访问】的范围

程序中的变量并不是在任意的语句中都可以被访问，访问权限取决于这个变量被定义在哪个位置

2.作用范围划分

局部作用域：L【Local】

函数作用域：E【Enclosing】 将变量定义在闭包外的函数中

全局作用域：G【Global】

內建作用域：B【Built-in】

代码演示：

#1.不同作用域变量的定义
num4 = int(2.9)    #B;內建作用域
num3 =  3    #G；全局作用域
def outer():num1 = 1    #E:函数作用域def inner():num2 = 2   #L:局部作用域#注意：当所有的变量不同名的时候，在闭包中，可以任意访问四种不同作用域对应的变量print(num4,num3,num2,num1)return  innerf = outer()
f()

3.变量的查找规则

查找的顺序：L------>E------>G------>B【极端情况：当所有的变量同名的情况下】【面试题】

代码演示：

#变量的查找规则#注意：全局作用域和内置作用域，当重名的时候，谁出现在后面，则先匹配到谁
x = 0
x1 = int(3.3)def outer1():j = 1def inner1():i = 2#【就近原则】print(x)return  inner1f1 = outer1()
f1()

#函数
def show(a):num1 = 10print(num1,a)
show(20)
#print(num1,a)
#结论一：在函数中定义的变量【形参，在函数体中定义的变量】，作用域仅限于函数内部
# 【变量的生命周随着函数的出现而出现，函数执行完毕则变量随着被销毁】#if语句
if True:msg = "hello"print(msg)
print(msg)#for循环
for i in range(0,5):print(i)
print(i)#结论二;Python中只有模块【module】、类【class】和函数【def,lambda】才会引入新的作用域
#其他的代码块：if语句，while语句，for语句，try-except语句都不会引入新的作用域

4.全局变量和局部变量【掌握】

全局变量：将变量定义在函数的外面

局部变量：将变量定义在函数的内部

注意：局部变量只能在其被声明的当前函数中使用，而全局变量可以在整个程序中使用

代码演示：

#全局变量
total = 0def show():print(total)
show()if True:total = 20print(total)total = 10
print(total)def add(arg1,arg2):#arg1,arg2，total1都属于局部变量total1 = arg1 + arg2print(total1)add(10,20)
#print(total1)

作业讲解：

#1.计算1~某个数范围内奇数的和并返回
def fun1(num):sum = 0for i in range(1,num + 1):if i % 2 == 1:sum += 1return sumprint(fun1(100))#2.判断某个数是否是质数，返回结果
def fun2(num):is_prime = Truefor x in range(2,num):if num % x == 0:is_prime = Falsebreakif is_prime and num != 1:return "质数"else:return "不是质数"fun2(10)

5.global和nonlocal关键字的使用【掌握】

使用场景：当内部作用域【局部作用域，函数作用域】想要修改全局变量的作用域的时候

1.global

代码演示：

#global#全局变量
num = 1
def fun1():#此时要使用全局变量中的num，需要给编译器做一个声明，声明此处使用num就是使用的全局变量中的numglobal numprint(num)print(id(num))   #1355785312#局部变量num = 123print(num)print(id(num))   #1355789216fun1()#练习
a = 10
def test():global  aa = a + 1print(a)test()

2.nonlocal

代码演示：

#前提：nonlocal关键字是定义在闭包中
x = 0def outer():x = 1def inner():#使用nonlocal关键字进行声明，相当于将局部作用域范围扩大了nonlocal xx = 2print("inner:",x)#return  innerinner()print("outer:",x)   #2outer()
print("global:",x)
"""
原本：
inner: 2
outer: 1
global: 0
""""""
修改：
inner: 2
outer: 2
global: 0
"""

五、列表生成式和生成器【掌握】

1.列表生成式

list comprehension

系统内置的用于创建list的方式

range(start,end,step)缺点:生成的列表一般情况下都是等差数列

代码演示：

#列表生成式list1 = list(range(1,11))
print(list1)   #[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]#需求：[1, 4, 9, 16, 25]
list2 = []
for x in range(1,11):list2.append(x ** 2)
print(list2)  #[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]#1
#使用列表生成式完成上面的需求
#列表生成式的格式：[生成的元素 for-in循环]
list3 = [x ** 2 for x in range(1,11)]
print(list3)   #[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]#2.
#[4,16,36,64,100]
list4 = [x ** 2 for x in range(1,11) if x % 2 == 0]
print(list4)#3.嵌套for循环，第一个循环就相当于外层循环，第二个循环就相当于内层循环
list5 = [m + n for m in "ABC" for n in "XYZ"]
print(list5)#["AX","AY","AZ"....]"""
for m in "ABC"：for n in "XYZ"：print(m + n)"""#4
#for k,v in dict.items)():
d = {"x":"1","y":"2","z":"3"}
for k,v in d.items():print(k,v)list6 = [k + "=" + v for k,v in d.items()]
print(list6)   #['x=1', 'y=2', 'z=3']#练习：使用列表生成式生成一个新的列表，将一个已知列表中的所有的字符变为小写
l1 = ["Hello","GOOD","ABC","kkH"]
#l2 = ["hello","good","abc","kkh"]newList1 = []
for element in l1:str = element.lower()newList1.append(str)
print(newList1)newList2 = [s.lower() for s in l1]
print(newList2)

2.生成器

generator

next()

代码演示：

#生成器#方式一：（），将列表生成式中的[]改成()
#列表生成式的类型是list，生成器的类型是generator【当做一种新的数据类型】
r1 = (x ** 2 for x in range(1,6))
print(r1)   #(1,4,9,16,25)
print(type(r1))"""
for i in r1:print(i)
"""#生成器区别于列表生成式：可以使用next遍历，每调用一次则获取一个元素
#next()
print(next(r1))
print(next(r1))
print(next(r1))
print(next(r1))
print(next(r1))
#注意：当生成器中的元素全部获取完成之后，接着调用next函数的，则会出现StopIteration
#print(next(r1))   #StopIteration异常#方式二：yield---->让步
#(x for x in range(1,6))----->1,2,3,4,5
def test(n):for i in range(1, n + 1):#执行到yield的时候，则函数会停止，将yiled后面的变量返回yield i ** 2#yield后面的代码的执行时机：当调用next函数的时候print(i)t = test(5)
print(t)  #<generator object test at 0x0000019CC432A1A8>
print(next(t))
print(next(t))
print(next(t))
print(next(t))
print(next(t))

六、迭代器【掌握】

1.可迭代对象

可迭代对象【实体】：可以直接作用于for循环的实体【Iterable】

可以直接作用于for循环的数据类型：

​ a.list,tuple,dict,set,string

​ b.generator【() 和yield】

isinstance:判断一个实体是否是可迭代的对象

代码演示：

#一、可迭代对象#1.导入
from  collections  import  Iterable#2.使用isinstance(数据，Iterable)
print(isinstance([],Iterable))
print(isinstance((),Iterable))
print(isinstance({},Iterable))
print(isinstance((x for x in range(10)),Iterable))
print(isinstance("hello",Iterable))print(isinstance(10,Iterable))   #False
print(isinstance(True,Iterable))  #Falseprint("****88")

2.迭代器

不但可以作用于for循环，还可以被next函数遍历【不断调用并返回一个元素，直到最后一个元素被遍历完成，则出现StopIteration】

目前为止，只有生成器才是迭代器【Iterator】

结论：迭代器肯定是可迭代对象，但是，可迭代对象不一定是迭代器

isinstance:判断一个实体是否是迭代器

代码演示：

#二、迭代器
from  collections  import  Iteratorprint(isinstance([],Iterator))
print(isinstance((),Iterator))
print(isinstance({},Iterator))
print(isinstance("hello",Iterator))
print(isinstance((x for x in range(10)),Iterator))   #Trueprint("****88")

3.可迭代对象和迭代器之间的转换

可以将可迭代对象转换为迭代器：iter()

代码演示：

#三、虽然list、tuple、dict、set、string都不是迭代器
#iter():将list、tuple、dict、set、string的  Iterable转换为Iterator
print(isinstance(iter([]),Iterator))
print(isinstance(iter(()),Iterator))
print(isinstance(iter({}),Iterator))
print(isinstance(iter("hello"),Iterator))

总结：

​ a.凡是可以作用于for循环的对象都是Iterable类型

​ b.凡是可以作用于next函数的对象都是Iterator类型

​ c.list/tuple/dict/set/string都不是Iterator，可以通过iter()获得一个Iterator对象

【面试题】

区分可迭代对象和迭代器