Python 基础知识

Python其他知识目录

1。功能介绍

函数是有组织的、可重用的代码段，用于实现单个或相关的函数。
功能可以提高应用程序的模块化程度和代码复用率。你已经知道Python提供了许多内置函数，例如print()
。但您也可以创建自己的函数，称为用户定义函数。

def函数名（参数列表）：
函数体d
函数名称（参数）

函数名称（参数）

2。使用函数的优点和缺点：

公司有成百上千条生产线。可读性、可重用性、功能性、面向过程编程
优点：
缺点：
面向过程、可重复的代码可以做成函数，用参数来代替变化量，实现重复的功能性操纵。
当事物需要做此操作时，可以通过调用该函数来实现该功能。 #自己理解吧
#发送邮件：在设置中启用pop3和smtp服务器，发送邮件到smtp服务器
比如发送邮件是很多对象都会用到的一个动作。将其编写为函数并调用该函数。避免代码冗余。
每当你编写一个函数时，只是为了重用某个函数，所以把它写成一个函数，一次一个函数。或者是为了阅读方便，增加代码的可读性
函数式编程是做什么的？避免重复的代码。代码拆分，增强可移植性和可读性

本质：在别处取N行代码，并给它起个名字。以后可以通过名字找到这段代码并执行。
场景：代码被重复执行。
如果代码量超过一屏，可以选择通过函数拆分代码。

3。函数定义：

您可以定义一个具有您想要的功能的函数，以下是简单的规则：
函数代码块以 def 关键字开头，后跟函数标识符名称和括号 ()。
任何传入的参数和自变量都必须放在括号之间，括号之间的空格可以用来定义参数。
函数的第一行可以选择使用文档字符串 - 用于存储函数描述。
函数内容以冒号开头，并缩进。
return [表达式] 结束函数并可选择向调用者返回一个值。不带表达式返回相当于返回 None
。
语法：
Python 使用 def 关键字定义函数。一般格式如下：

def函数名（参数列表）：
函数体

默认情况下，参数值和参数名称按照函数声明中定义的顺序进行匹配。

函数执行：
def 小马():
print("魔鬼征服风暴")
小马()
---------- 结果：
恶魔降临风暴

4。函数调用

定义函数：为函数命名，指定函数中包含的参数以及代码块结构。

这个函数的基本结构完成后，你可以通过另一个函数调用来执行它，也可以直接在Python命令提示符下执行
。
函数没有被调用，内部代码也没有被执行。调用后，无论是否使用变量来接收返回值，函数都会被执行。

def xiaoma():
print("魔鬼征服风暴")
小马()
---------- 结果：
魔鬼战胜风暴
def 小马():
print("魔鬼征服风暴")
a=小马()
---------- 结果：
恶魔战胜风暴

def xiaoma():
 print("恶魔征服风暴")

def mcw():　　　　　　　　#函数调用函数 
 print("我是：") 小马()
mcw()
--------------结果：
我是：
魔法征服风暴

5。功能参数

5.1。函数参数传递简介

不同的对象可以执行相同的操作并定义功能。如果每个对象之间存在一些差异，则在存在差异的地方使用函数参数
。
用参数定义函数时
函数式编程。通过传递参数，返回不同的值，返回不同的参数。同一个功能不同的地方，使用参数传递
形式参数（formalparameters）：形式参数就是形式参数，可以理解为数学上的X，它们没有实际值，只有别人赋值的值。
的意思。相当于变量。
实际参数（实际参数）：实际参数是实际意义上的参数。它是一个实际参数，可以是字符串或数字。

函数。
函数可以固定，也可以传递变量。编写函数不一定需要参数。如果有任何变化，请使用参数。如果没有变化，那就死了。
根据实际情况而定。

def eat(arg1,arg2):
 print("%s喜欢吃%s"%(arg1,arg2))
eat("小马过河","米饭")
吃(“小明”,“面条”)
----------结果：

5.1 未传递函数参数
情况1：
使用函数仅计算列表中元素的总和：
def list_sum():
li = [1, 2, 3]
总和=0
对于 i 在 li：
总和+=i
打印（总和）
列表总和()
-----------结果
6
5.2 传递参数的函数：
案例2：
使用函数计算指定列表中元素的总和：
def list_sum(li):总和=0
对于 i 在 li：
总和+=i
打印（总和）
信息=[1,2,3]
列表总和（信息）
-------------- 结果：
6
错误报告1：
错误：函数没有形参，带参数调用函数时报错：
def list_sum():
总和=0
对于 i 在 li：
总和+=i
打印（总和）
信息=[1,2,3]
list_sum(info) #调用时可以直接作为参数，也可以使用变量作为实参。
------------------- 结果：
列表总和（信息）
类型错误：list_sum() 采用 0 位置参数，但给出了 1
5.3 向多个函数传递参数：
def xiaoma(arg1,arg2):
打印（arg1+arg2）
小马(2,3)
----------- 结果：
5
错误问题2：传递的参数太少。
def xiaoma(arg1,arg2):
打印（arg1+arg2）
小马(2)
----------- 结果：
小马(2)
TypeError: xiaoma() 缺少 1 所需的位置参数：'arg2'
错误问题3：传递的参数过多
def xiaoma(arg1,arg2):
打印（arg1+arg2）
小马(2,3,4)
------------ 结果：
小马(2,3,4)类型错误：xiaoma() 接受 2 位置参数，但给出了 3

严格按照顺序传递参数，位置一一对应。

5.2 基本参数知识

• 任意数量
• 任何类型

def func(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8):
打印（arg1，arg2，arg3，arg4，arg5，arg6，arg7，arg8）
搞笑奥玛","1"],(1,2),{ “姓名”： "小马"},{3,4})
------ 结果：
1假无mcw ['小马','1' ] (1, 2) {' 名字'：'小马'} {3、4}

5.3。位置参数传递（调用函数并传入参数）【执行】

位置参数传递：根据位置意义对应传递参数

def func(a1, a2):
打印（a1，a2）
func(1, 3)
------------ 结果：
13

5.4 关键字参数传递【执行】

关键字参数传递：指定形参接收实参

def func(a1, a2, a3):
打印（a1，a2，a3）
func(1,2,a3=9)func(1,a2=2,a3=9)
func(a1=1,a2=2,a3=9)
-------------------------------- 结果：
1 2 9
1 2 9
129
def 函数（a1，a2，a3）：
打印（a1，a2，a3）
func(a1=1,2,3) # 错误
-------------- 结果：
语法错误：位置参数跟随关键字参数
遵循关键字定位参数参数 

5.5 默认参数 【定义】

使用场景：定义函数的默认参数，方便

指定形参等于什么参数。如果没有接收到实际参数，则函数使用默认参数

func(11,22)
func(11,22,10)
func(11,22,10,100)
func(11,22,10,a4=100)
func(11,22,a3=10,a4=100)
func(11,a2=22,a3=10,a4=100)
func(a1=11,a2=22,a3=10,a4=100)
------------------- 结果：
11 22 9 10
11 22 10 10
11 22 10 100
11 22 10 10011 22 10 100
11 22 10 100
11 22 10 100

5.6个通用参数（分散）

*args：将多个实参传递给形参*args，让函数以元组的形式接收外部参数

*kwargs：将多个键值对或字典传递给*kwargs，在函数内以字典的形式存在

• *args

  • 可以接受任意数量的位置参数并将参数转换为元组。

  • *args 只能接收n个参数。当传入多个实参时，会放在args元组中。如果传入元组参数，则该元组将充当 args 的单个元素。如果*()，实参元组前面有*，则实参元组中的每个元素都放在形参组成的元组中，即形参

  • 由

    组成的元组包含实际参数中的每个元素。参数只能按位置传递，不能按关键字传递。 #如果参数可以通过关键字传递，那么设置后，后面就无法接收参数了

  • ，所以关键字传递是不可能的

  • 使用场景：当不确定需要传递多少个参数时，使用通用参数。

    • 调用功能 无 *

      def func(*args):
      print(args)  #*args 只能接收n个参数。当传入多个实参时，会放在args元组中。 
      func(1,2,3,4)
      ------------------- 结果：
      (1、2、3、4)

      def func(*args):
       print(args)  #如果传入一个元组参数，则该元组作为args的单个元素。 
      func((1,2),(3,4))

    • 调用函数为*

      def func(*args):
      打印（参数）
      func（ *（1，2，3，4））＃if *（），在实际参数元组的前面 *，然后是实际的每个元素参数元组 元素放在由形式参数组成的元组中，即形式参数
      func(*[1,2,3,4])
      ------------------------------------ 结果：
      （1、2、3、4）
      (1、2、3、4)
      
      

      ？ )
      ---------结果：

      (1, 2, 3, 4)
      1 2 3 4

  • 只能使用position来传递参数

    def func(*args):
    打印（参数）
    函数(1)
    func(1,2) # args=(1,2)
    func((11,22,33,44,55)) # args=((11,22, 33,44,55), ）
    func(*(11,22,33,44,55)) # args=(11) ,22,33,44,55)------------------------------------ 结果：
    (1,)
    (1, 2)
    ((11, 22, 33, 44, 55),)
    (11, 22, 33, 44, 55)

• **kwargs

  • 可以接受任意数量的关键字参数并将参数转换为字典。

    • 通话功能 无 **

      def func(**kwargs):
      打印（夸格斯）
      func(k1=1,k2="mcw")
      ------------------------ 结果：
      {'k1'：1，'k2'：'mcw'}

    • 调用函数有**

      def func(**kwargs):
      打印（夸格斯）
      func(**{'k1':'v2','k2':'v2'}) # kwargs={'k1':' v2','k2':' v2'}
      ------------------------------------------------ 结果：{'k1'：'v2' 、'k2'： 'v2'}

  • 只能使用关键字来传递参数

  • 综合运用：无敌+无敌=>真无敌

    def func(*args,**kwargs):
    打印（参数，kwargs）
    func(1,2,3,4,5,k1=2,k5=9,k19= 999)
    func(*[1,2,3],k1=2,k5=9,k19=999)
    func(*[1,2,3],**{'k1' :1,' k2':3})
    func(111,222,*[1,2,3],k11='亚历克斯',**{' k1':1,'k2' :3})
    ------------------------ 结果：
    （1、2、3、4、5）{'k1 '：2，' k5 '：9、'k19'： 999}
    (1, 2, 3) {'k1':  、'k5' : 9, 'k19': 999}(1, 2, 3) {'k1':  、'k2' ：3}
    （111、222、1、2、3）{'k11'：'alex' 、'k1'：1、'k2'：3}

5.7，混合参数传输

def func(a1,*args)
func(1,2,3) 将 1 传递给 a1，然后是 args

def func(a1,*args,a2) 混搭
func(1,2,3,a2=4)

def func(a1,*args,a2=10) 混搭 a2 只能通过关键字传递，同上。
func(1,2,3,a2=4)

def func(a1=2,*args,a2) #混搭错误方式
func(1,2,3,a2=4)

def func(**kwargs) #向函数传递多个键值对，实际参数为key=value #通用，传递n个关键字参数。并转换参数
是一本字典
func(k1=1,k2="s")

def func(**kwargs): #kwargs={k1=1,k2="s"} #将字典传入函数**字典
 print(kwargs)
func(**{ " k1":1,"k2":"s"})
-------------结果: 
{'k1': 1, 'k2': 's' } 

def func(**kwargs) #kwargs={k1:{"m":"c"},k2:"s"} #将键值对和字典一起传入函数中，
func ( k1={"m":"c"},k2="s")

5.8。参数传递使用场景总结：

　　1。我想要一个简单的基本参数传递，使用position来传递参数；
　　2。我想把参数传递给我想要接收的人，用关键字来传递参数。
　　3。我没有传参数，希望形参有默认值，所以就用了默认参数；
　　4。我想传递多个参数，我用*号来接收它们；
　　5。我想向它们传递多个键值对或字典，用两个 ** 接收。

功能：增加代码的复用性和可读性。
比如下楼取快递，就是一个功能。告诉他从**取快递，他就会从**取快递

6。函数返回值return

1）print和return的区别是print只在控制台打印，而return则使用return后的部分作为
是返回值作为函数的输出，可以由变量接管并继续使用返回值做其他事情。
2）函数需要先定义，后调用。函数体中return语句的结果就是返回值。如果函数没有 reutrn 语句
，其实它有一个隐式的return语句，返回值为None，类型也是'NoneType'。
3）返回函数：结束函数调用，返回值
4）终止函数的方法：满足一定条件返回False

返回成功或失败的结果。如果不需要打印，用户只需要某个结果，那么就让函数返回一个值，让用户
根据返回值进行相应操作。 return 实现函数返回值。
调用函数并使用变量来接收函数的返回值。

6.1 使用变量接收返回值：

def xiaoma():
a=1
返回a
mcw=小马()
打印（MCW）
------------结果
1

6.2 用户根据函数返回值进行其他操作。 （根据返回值进行通信）

#等小明吃完，还1给我。小明吃完饭后，小马过河陪他玩

def 小明(arg):
a=0if arg=="吃完后":
a=1
返回a
状态=小明("吃完后")
如果状态==1：
print("小马过河和小明玩耍")
---------------- 结果：
小马过河和小明玩耍

6.3 返回多个值的方法：

如果程序需要有多个返回值，既可以将多个值包装到一个列表中返回，也可以直接返回多个值。如果Python
函数直接返回多个值，Python会自动将多个返回值封装成元组。多个值用逗号分隔。

1）python函数使用return语句返回“返回值”，可以赋值给其他变量作其他用途

2）所有函数都有返回值。如果没有return语句，会隐式调用return None作为返回值

3）一个函数可以有多个return语句，但只能执行一个。如果不执行reutrn语句，也会隐式调用return None作为返回值

4）如果需要，可以显式调用return None显式返回一个None（空值对象）作为返回值，可以简写为return

5）如果函数执行了return语句，函数会立即返回，结束调用，return之后的其他语句不会被执行

def list_sum(li):
总和=0
e_str=""
对于 i 在 li：
e_str+=str(i)
总和+=i
返回 sum,e_str
li=[1,2,3]mcw=list_sum(li) # 获取list_sum函数返回的多个值。多个返回值封装成元组
v1,v2=list_sum(li) #另外，还可以使用Python提供的序列拆包函数，直接使用多个变量来接收函数返回的多个值。
打印（MCW）
打印（v1，v2）
--------------- 结果：
(6, '123')
6123

6.4return 终止循环

def mcw(): #没有返回时，返回值默认为None，循环正常结束。
对于 i 在范围内（1，4）：
打印（一）
m=mcw()
打印(米)
-------------- 结果：
1
2
3
没有任何
def mcw(): #有return时，返回指定值并终止函数继续向后执行。
对于 i 在范围内（1，4）：
如果 i==3：
返回 " 终止功能 "
打印（一）
m=mcw()
打印(米)
-------------- 结果：
1
2
终止功能

6.5。直接打印返回值

def mcw():
回归》魔鬼变了》
打印(mcw())

6.6 for .. else .. 语句（意外终止）

#表示如果for语句段的内容正常循环，则执行else段中的语句。如果 for 在循环过程中被破坏或者 return 语句意外终止循环，则 else 段中的语句将不会被执行。

6.7。 return 可以返回任何类型。

#如果需要函数返回字典、列表等，可以在调用函数时使用。

retrue 一种数据类型。

6.8。 if判断使用返回值的三种方式：

def func(a1,a2):
如果 a1>a2：
返回a1
其他：
返回a2
def 函数(a1,a2):
返回 a1 如果 a1>a2 否则 a2
def 函数(a1,a2):
b=a1 如果 a1>a2 否则 a2
返回b

6.9 可以使用返回值True和默认返回值None来判断函数返回

def func(arg1):
if arg1==1：
返回真实打印(func(0))
----------- 结果：
无

6.10 其他返回值，非函数返回值汇总

li=[1,2]
print(li.append(3)) #如果没有返回值是None吗？
--------------- 结果：
没有任何
li=[1,2]
m=li.append(3)
打印(米)
----------- 结果：
没有任何
a="mcw"
a="*".join(a)
打印（一）
---------------- 结果：
m*c*w

总结：列表上的所有方法基本都返回None，字符串上的所有方法基本都返回新值

7。功能范围

7.1 全球范围

• py文件：全局范围

• 功能：局部作用域

• 变量必须先创建后才能使用。
• 函数也可以看成是变量，指向一堆代码
• 范围内的数据属于您，其他人无法访问。局部作用域可以继承全局作用域
• 对于函数调用全局变量，可以在函数调用之前使用环境变量，但不能在函数调用之后使用
。

• print(func) 返回地址
  print(func()) 返回调用值

• a = 1
  定义 s1():
  x1 = 666
  打印（x1）
  打印（一）
  打印(b)
  b = 2
  打印（一）
  s1()
  = 88888
  定义 s2():
  打印（a，b）
  s1()
  s2()------------------------ 结果：
  1
  666
  1
  2
  888882
  666
  88888
  2

• 总结：

  • 一个函数和一个作用域，（很多其他语言只有一个代码块和一个作用域）

  • 在范围内查找数据的规则是先在自己的范围内查找。如果你自己没有，就到父集范围去查找。父集不会一直寻找上层父集。直到全局作用域，如果没有，就会报错。

  • 父集不能使用子集的变量。子集可以继续在外层父集中寻找变量
  • 1。找到该层中未找到的变量。 2. 进入上层作用域，找到调用该函数之前最后一次赋值的变量。 3、如果到达全局环境变量后找不到全局环境变量，就会报错。如果未达到环境变量，请继续步骤2。
    

  • globla 发现全球。找到之后，就可以重新给全局变量赋值了。
    nonloacl 找到了优越者。找到后，可以重新赋值上级变量。

  • 每一级瞄准镜都有自己独立的内部空间。子项可以继承父项，但不能重新分配父项。您需要使用全局和非本地。 #思考（不确定题）：有全局的和非局部的找到parent所在的空间，重新打开空间进行赋值。不然你开辟的空间是你自己的吗？

  • 

    def func():
    x = 9
    打印（x）
    乐趣（）
    print(x) #函数内部可以使用内部变量，但函数外部不能使用内部变量
    -------------- 结果：
    9回溯（最近一次调用最后一次）：
    文件"D:/aPython_小马过河完整目录/代码练习/www.sychzs.cn",第269, 中
    打印（x）
    NameError: 名称 'x' is 未定义

范围内查找数据的规则：首先查找自己范围内的数据。如果你自己没有数据，进入“父”->“父”->直到全世界。如果没有数据就会报错。注意：父作用域中的值到底是什么？

x = 10
def 函数():
x = 9
打印（x）
乐趣（）
--------------- 结果：
9

 8、lambda函数（匿名函数）

8.1、lambda函数简介

python 使用 lambda 来创建匿名函数。

所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

• lambda 只是一个表达式，函数体比 def 简单很多。
• lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
• lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
• 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

8.2、lambda 函数语法

lambda 函数的语法只包含一个语句，如下：

lambda [arg1 [,arg2,.....argn]]:expression

8.3、

lambda 为了解决简单函数的情况。运算相当于简单函数编写方式。这样函数就相当于一个变量
一行表示，所以不定义变量，使用上一层作用域的变量
变量名=lambda 参数（有无*/**）：操作或者函数返回值（返回值可为表达式，为三元运算；表达式有返回的就
作为返回值，否则返回None）

表达式1：
没有参数，只返回指定值
有一个参数，返回表达式
有*和**的参数，举例比如返回*和**长度和
lambda 表达式结合三元运算，返回值部分使用三元运算。
多个lambda放入列表。调用lambda.

9、函数中高级使用  高阶函数

9.1、函数可以作为变量来使用

1）
def func():
print("mcw")
v1 = func  #将函数名赋予一个变量，再给变量加上小括号便能代替原函数名执行这个函数。函数名指
向函数体的内存位置
func()  #
v1()
-------------结果：
mcw
mcw
由上面那个函数打印可知，函数名赋予给变量后，他们都是指向一个内存地址，函数()代表函数返回值
，默认为None。
print(type(func),type(func()),func,func())
print(type(v1),type(v1()),v1,v1())
------------结果：
123
123
<class 'function'> <class 'NoneType'> 0x00A28D20> None
123
123
<class 'function'> <class 'NoneType'> 0x00A28D20> None
2）函数名可以放入列表等数据类型，调用函数时加上小括号
def func():
print(123)
func_list = [func, func, func]
func_list[0]()
-----------结果：
123
def func():
print(123)
func_list = [func, func, func]
for item in func_list:        循环函数列表并打印函数返回值
v = item()
print(v)
----------------结果：
123
None
123
None
123
None
3）函数名作为字典的值来用，（不建议当做键来用，没啥意义）。
def func():
print(123)
def bar():
print(666)
info = {'k1': func, 'k2': bar}
info['k1']()
info['k2']()
------------------结果：
123
666
4）容易弄错的案例：
def func():
return 123
func_list1 = [func,func,func]
func_list2 = [func(),func(),func()]
print(func_list1)
print(func_list2)
info = {
'k1':func,
'k2':func(),
}
print(info)
------------------结果：
[0x00648D20>, 0x00648D20>, <function func at
0x00648D20>]        #func函数名是指向函数的地址
[123, 123, 123]     # func()是函数返回值。这里指定返回值为123
{'k1': 0x00648D20>, 'k2': 123}

５）综上可知：
def func():
print("mcw")
v1 = func

函数名实质上就是函数的内存地址。

当我们定义a=1的时候，系统会开辟一块内存空间来保存1，然后用a变量名保存1所在的内存地址引用，变量名就好像C语言中的指针，大家可以把引用理解成地址，a里面存的是1这个数值所在的地址，a存了1的引用。当我们在代码中定义了一个函数，系统会分配一块内存空间，用于保存函数体的内部变量和函数名，这个v1只是一个变量名，保存了函数内存中的地址，我们可以v1=func,v2=func.这样的操作就相当于把func中引用的地址，赋值给v1,v2　，这样v1和v2都指向了func函数所在的引用，我们可以v1()和v2()来
调用func函数，调用实际上是一个函数，而v1,v2,func三个变量存了同一个函数的地址。

9.2、函数可以当作参数进行传递

1）
def func(arg):
print(arg)
def show():
return 999
func(show)
----------结果：
0x00598D20>  #将show函数作为参数传到func函数，结果为print(show)，show这个
函数名指向内存地址
2）
def func(arg):
v1 = arg()
print(v1)
def show():
print(666)
func(show)
---------------结果：
666
None
#函数执行分析：将函数名show作为func的参数，执行函数后，arg()会让show函数执行并打印666，然后
将show函数执行的默认返回结果赋予变量v1，打印出v1的值。
3）
def func(arg):
v1 = arg()
print(v1)
def show():
print(666)
result = func(show)
print(result)
---------------结果：
666
None
None
#函数执行分析：将函数名show传参给func函数，然后show会在func内执行，打印666，并将默认返回值
赋予变量v1并打印。func函数执行返回默认值None并将值赋予变量result，然后打印result
4）函数传参功能的使用案例。
（指定用户输入选项，并将每个选项的功能写成函数，然后将函数做成字典，根据用户输入执行不同的函数，实现不同的功能）
def func():
print('花费查询')
def bar():
print('语音沟通')
info = {
'f1': func,
'f2': bar,
}
choice = input('请选择要选择功能：')
function_name = info.get(choice)
if function_name:
function_name()
else:
print('输入错误')
---------------结果：
请选择要选择功能：f1
花费查询

9.3、函数可以做返回值来使用

1）没有
def func():
print(123)
def bar():
return func
v = bar()
v()
-----------结果：
123
#函数执行分析：函数bar执行后返回另一个函数名func，将函数名赋值给变量v,v()执行函数就等于func()执行func函数，即打印出123（原因：赋值后，v和func指向同一个函数）
2)返回另一个函数名并赋值给变量
name = 'mcw'
def func():
print(name)
def bar():
return func
v = bar()
v()
--------------结果：
mcw
#函数执行分析：执行bar函数的返回值(func函数名)赋给变量v。执行v也是执行func函数，打印变量name，func当前作用域没有变量name，于是去上级作用域中找到并打印出来。
3）返回子函数名并赋值给变量
def bar():
def inner():
print(123)
return inner
v = bar()
v()
----------结果：
123
#函数执行分析：执行bar函数返回inner，并将子函数名赋值给变量v，执行函数v就是执行函数inner，
并打印出123.
4）返回值为子函数结合作用域
name = 'xiaoma'
def bar():
name = 'mcw'
def inner():
print(name)
return inner
v = bar()
v()
------------------结果：
mcw
#函数执行分析：执行函数bar，将返回值inner函数名赋值给变量v,调用v即执行inner函数（二者执行同一个函数）。inner当前作用域没有变量name，那么先从上一级作用域中去找。
name = 'mcw'
def bar(name):
def inner():
print(name)
return inner
v1 = bar('yh') # { name=yh, inner }  # 闭包，为函数创建一块区域（内部变量供自己使用），为他
以后执行提供数据。
v2 = bar('syn') # { name=syn, inner }
v1()
v2()
-----------------结果：
yh
syn
#函数执行分析：[1]执行bar函数并传入参数yh后，系统会创建一个独立的内存空间给函数bar，然后将返回值inner子函数名赋值变量v1。如果bar函数内的资源没有人占用那么就会销毁，而这里由于函数的资源还有变量v1在使用所以没有销毁。[2]再次执行函数bar,并传入参数syn，分析与第一步相同。[3]两次调用同一个函数，但是两次开辟的内存空间都是独立的，传入的参数也是不同的，并且在各自的内存空间中。当执行v1的时候，就是执行inner子函数，变量还是找v1所在的函数空间，即打印yh。当执行v2的时候，就是执行inner子函数，变量还是找v2所在的函数空间，即打印syn。
5）解释闭包现象
def bar(name):
def inner():
print(name)
return inner()  #没有闭包，函数已经执行完毕
v1 = bar('yh')
#
空间不释放，还被引用，空间还存在东西，没有传参也是闭包，函数执行终止了，内存还没有释放，。
怎样不是闭包，返回子函数返回值，子函数已经执行完毕没人使用它的资源

9.4函数闭包问题

函数名指向函数代码，每次执行此函数，新开辟一份空间，（将代码复制过来）。所以多次执行此函数
互不影响，它们有各自的空间。如果返回的值正在被调用，函数的这个空间不销毁，调用之后才销毁
看函数是由谁创建的，谁那里有函数的入口

name = 'mcw'
def bar(name):
def inner():
print(name)
return inner
v1 = bar('yh') # { name=yh, inner }  # 闭包，为函数创建一块区域（内部变量供自己使用），为他
以后执行提供数据。
v2 = bar('syn') # { name=syn, inner }
v1()
v2()
----------------结果：
yh
syn
#函数执行分析：[1]执行bar函数并传入参数yh后，系统会创建一个独立的内存空间给函数bar，然后将返回值inner子函数名赋值变量v1。如果bar函数内的资源没有人占用那么就会销毁，而这里由于函数的资源还有变量v1在使用所以没有销毁。[2]再次执行函数bar,并传入参数syn，分析与第一步相同。[3]两次调用同一个函数，但是两次开辟的内存空间都是独立的，传入的参数也是不同的，并且在各自的内存空间中。当执行v1的时候，就是执行inner子函数，变量还是找v1所在的函数空间，即打印yh。当执行v2的时候，就是执行inner子函数，变量还是找v2所在的函数空间，即打印syn。

10、Python内置函数的了解

Python 解释器内置了很多函数和类型，您可以在任何时候使用它们。以下按字母表顺序列出它们。

•  自定义函数

• 内置函数

  • 其他

  len open  range  id  type  

  • 输入输出

  print  input

  • 强制转换

  dict() list()  tuple()   int()  str()  bool()  set()  

  •  数学相关

  • abs，绝对值

    print(abs(1),abs(-1),abs(0))
    -------结果：
    1 1 0

  • float，转换成浮点型（小数）

    print(float(3),float(0),float(2.5))
    ----------结果：
    3.0 0.0 2.5

  • max，找到最大值

    mcw=[2,1,4,3]
    print(max(mcw),min(mcw),sum(mcw))
    -----------结果：
    4 1 10

  • min，找最小值

    mcw=[2,1,4,3]
    print(max(mcw),min(mcw),sum(mcw))
    -----------结果：
    4 1 10

  • sum，求和

    mcw=[2,1,4,3]
    print(max(mcw),min(mcw),sum(mcw))
    -----------结果：
    4 1 10

    • divmod，两数相除的商和余数

      a,b = divmod(1001,5)
      print(a,b)

      # 练习题  请通过分页对数据进行展示
      """
      要求：
          每页显示10条数据
          让用户输入要查看的页面：页码
      """

      USER_LIST = []  #此处生成列表元素[{'name': '魔降风云变-1', 'email': 'support@www.sychzs.cn'},{'name': '魔降风云变-2', 'email': 'support@www.sychzs.cn'}。。。。。]

      for i in range(1,836):
          temp = {'name':'魔降风云变-%s' %i,'email':'support@www.sychzs.cn' %i }
          USER_LIST.append(temp)
      def paging(num,data_list):
          """
          实现分页功能
          :param num: 传入分页后每页显示的内容
          :param data_list: 传入列表，将每个列表元素分页展示出来
          """
          total_count = len(data_list)  # 数据总条数
          per_page_count= num # 每页显示10条
          max_page_num,a = divmod(total_count,per_page_count)  # 总页码数
          if a>0:
              max_page_num += 1
          while True:
              try:
                  page = int(input('要查看第几页：'))
              except Exception as e:
                  print("输入有误！")
              if page < 1 or page> max_page_num:
                  print('页码不合法，必须是 1 ~ %s' %max_page_num )
              else:
                  start = (page-1) * per_page_count
                  end = page * per_page_count
                  data = data_list[start:end]
                  for item in data:
                      print(item)
      paging(4,USER_LIST)

      ------------------------------结果：

      要查看第几页：4
      {'name': '魔降风云变-13', 'email': 'support@www.sychzs.cn'}
      {'name': '魔降风云变-14', 'email': 'support@www.sychzs.cn'}
      {'name': '魔降风云变-15', 'email': 'support@www.sychzs.cn'}
      {'name': '魔降风云变-16', 'email': 'support@www.sychzs.cn'}
      要查看第几页：10000
      页码不合法，必须是 1 ~ 209
      要查看第几页：
      输入有误！
      页码不合法，必须是 1 ~ 209
      要查看第几页：10
      {'name': '魔降风云变-37', 'email': 'support@www.sychzs.cn'}
      {'name': '魔降风云变-38', 'email': 'support@www.sychzs.cn'}
      {'name': '魔降风云变-39', 'email': 'support@www.sychzs.cn'}
      {'name': '魔降风云变-40', 'email': 'support@www.sychzs.cn'}

       

      #总结：

  • 进制转换相关

    • bin，将十进制转化成二进制

      print(bin(4),bin(256))     #将十进制转换为二进制
      ----------结果：
      0b100 0b100000000

    • oct，将十进制转换成八进制

      print(oct(3),oct(8),oct(18))    #十进制转换为8进制
      ------------结果：
      0o3 0o10 0o22

    • int，将其他进制转化成十进制

      a="0b1001"
      b="0o5"
      c="0xA"
      print(int(a,base=2),int(b,base=8),int(c,base=16))
      --------------结果：
      9 5 10
      a=0b1001
      b=0o5
      c=0xA
      print(int(a,base=2),int(b,base=8),int(c,base=16))
      -----------------结果：
      print(int(a,base=2),int(b,base=8),int(c,base=16))
      TypeError: int() can't convert non-string with explicit base
      

      a=0b1001
      print(type(a))
      b=0o5
      c=0xA
      print(int(a),int(b),int(c),type(a))
      ----------------结果：
      
      9 5 10 

      综上:
      类似数字类型转换为十进制：int(0o**),int(0x**),int(0b**) #不用加base参数
      字符串类型转换为十进制s             #要加base参数

    • hex，将十进制转换成十六进制

      print(hex(9),hex(10),hex(16),hex(20))  #将十进制转换为16进制
      -----------------------结果：
      0x9 0xa 0x10 0x14

    • 一道进制转换的题

      # 1字节等于8位
      # IP: 192.168.12.79  ->  001010010 . 001010010 . 001010010 . 001010010
      
      # 1. 请将 ip = "192.168.12.79" 中的每个十进制数转换成二进制并通过,连接起来生成一个新的字符串。
      

      ip="192.68.12.79"
      li=ip.split(".")
      li2=[]
      for i in li:
      # li2.append(str(bin(int(i))))
      li2.append(bin(int(i)))
      print(",".join(li2))
      -----------------结果：
      0b11000000,0b1000100,0b1100,0b1001111

      # 2.请将ip=192.168.12.79中的四个十进制数转换成二进制，将四个二进制数拼接成一个二进制数并转换为 十进制。（注意：12转换为二进制位数不满8位）
      #     0010100100001010010001010010001010010 -> 十进制的值。
      

      ip="192.168.12.79"
      li=ip.split(".")
      li2=[]
      for i in li:
      m=str(bin(int(i))).lstrip("0b")
      m="0"*(8-len(m))+m
      li2.append(m)
      mcw="".join(li2)
      print(int(mcw,base=2))
      ----------------结果：
      3232238671

bow使用：

1）函数有两个必需参数x,y和一个可选参数z，结果返回x的y次幂乘(相当于x**y)，如果可选参数z有传入值，则返回幂乘之后再对z取模(相当于pow(x,y)%z)。
v1=pow(2,3)
v2=2**3
v3=pow(2,3,5)
v4=pow(2,3)%5
print([v1,v2,v3,v4])
----------------结果：
[8, 8, 3, 3]
2、所有的参数必须是数值类型
print(pow("3","2"))
----------结果：
print(pow("3","2"))
TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'
3、如果x,y有一个是浮点数，则结果将转换成浮点数。
print(pow(3.0,2))
--------------结果：
9.0
4、如果x,y都是整数，则结果也是整数，除非y是负数；如果y是负数，则结果返回的是浮点数，浮点数不能取模，所有可选参数z不能传入值。
>>> pow(10,2)
100
>>> pow(2,4)
16
>>> pow(2,-4)
0.0625
>>> pow(2,-4,3)
Traceback (most recent call last):
File "", line 1, in
pow(2,-4,3)
ValueError: pow() 2nd argument cannot be negative when 3rd argument specified
　5. 如果可选参数z传入了值，x,y必须为整数，且y不能为负数。
>>> pow(2,3,5)
3
>>> pow(10,0.1,3)
Traceback (most recent call last):
File "", line 1, in
pow(10,0.1,3)
TypeError: pow() 3rd argument not allowed unless all arguments are integers
>>> pow(10,-2,3)
Traceback (most recent call last):
File "", line 1, in
pow(10,-2,3)
ValueError: pow() 2nd argument cannot be negative when 3rd argument specified
>>>

-- 编码解码相关：

1)chr，将十进制数字转换成 unicode 编码中的对应字符串。

print(chr(9798),chr(10087),chr(9787))
------------------结果：
♆ ❧ ☻

print(chr(9679),chr(9711),chr(9734),chr(9733))
-----------结果：
● ◯ ☆ ★

print([chr(i) for i in range(65,91)]) print([chr(i) for i in range(97,123)]) print(chr(65),chr(65+32),chr(90),chr(90+32)) -------------------结果： ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'] ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'] A a Z z

2)ord，根据字符在unicode编码中找到其对应的十进制。

print(ord("A"),ord("a"),ord("☻"))
---------------结果：
65 97 9787

一些可能会用到的特殊符号（Unicode）

 3)map，循环每个元素（第二个参数），然后让每个元素执行函数（第一个参数），将每个函数执行的结果保存到新的列表中，并返回。

v1 = [11,22,33,44]
result = map(lambda x:x+100,v1)
print(list(result)) # 特殊
-------------结果：
[111, 122, 133, 144]

4)

v1 = [11,22,33,'asd',44,'xf']
def func(x):
if type(x) == int:
return True
return False
result = filter(func,v1) # [11,]
print(list(result))
-------------结果：
[11, 22, 33, 44]
v1 = [11,22,33,'asd',44,'xf']
result = filter(lambda x: True if type(x) == int else False ,v1)
print(list(result))
result = filter(lambda x: type(x) == int ,v1)
print(list(result))
---------------结果：
[11, 22, 33, 44]
[11, 22, 33, 44]

5)reduce

import functools
v1 = ['小','马','过','河']
def func(x,y):
return x+y
result = functools.reduce(func,v1)
print(result)
result = functools.reduce(lambda x,y:x+y,v1)
print(result)
----------------结果：
小马过河
小马过河
from functools import reduce
result = reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])
print(result)
---------------结果：
15
原理图：在这个例子里，其实计算过程是这样的：((((1+2)+3)+4)+5)  ，累加的过程。还可以实现阶乘
来自：https://www.sychzs.cn/caimouse/article/details/78129956

 6)dir（）

dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。

import sys,os
print(dir(os))
----------------结果：
['DirEntry', 'F_OK', 'MutableMapping', 'O_APPEND', 'O_BINARY', 'O_CREAT', 'O_EXCL', 'O_NOINHERIT', 'O_RANDOM', 'O_RDONLY', 'O_RDWR', 'O_SEQUENTIAL', 'O_SHORT_LIVED', 'O_TEMPORARY', 'O_TEXT', 'O_TRUNC', 'O_WRONLY', 'P_DETACH', 'P_NOWAIT', 'P_NOWAITO', 'P_OVERLAY', 'P_WAIT', 'PathLike', 'R_OK', 'SEEK_CUR', 'SEEK_END', 'SEEK_SET', 'TMP_MAX', 'W_OK', 'X_OK', '_Environ', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_execvpe', '_exists', '_exit', '_fspath', '_get_exports_list', '_putenv', '_unsetenv', '_wrap_close', 'abc', 'abort', 'access', 'altsep', 'chdir', 'chmod', 'close', 'closerange', 'cpu_count', 'curdir', 'defpath', 'device_encoding', 'devnull', 'dup', 'dup2', 'environ', 'errno', 'error', 'execl', 'execle', 'execlp', 'execlpe', 'execv', 'execve', 'execvp', 'execvpe', 'extsep', 'fdopen', 'fsdecode', 'fsencode', 'fspath', 'fstat', 'fsync', 'ftruncate', 'get_exec_path', 'get_handle_inheritable', 'get_inheritable', 'get_terminal_size', 'getcwd', 'getcwdb', 'getenv', 'getlogin', 'getpid', 'getppid', 'isatty', 'kill', 'linesep', 'link', 'listdir', 'lseek', 'lstat', 'makedirs', 'mkdir', 'name', 'open', 'pardir', 'path', 'pathsep', 'pipe', 'popen', 'putenv', 'read', 'readlink', 'remove', 'removedirs', 'rename', 'renames', 'replace', 'rmdir', 'scandir', 'sep', 'set_handle_inheritable', 'set_inheritable', 'spawnl', 'spawnle', 'spawnv', 'spawnve', 'st', 'startfile', 'stat', 'stat_float_times', 'stat_result', 'statvfs_result', 'strerror', 'supports_bytes_environ', 'supports_dir_fd', 'supports_effective_ids', 'supports_fd', 'supports_follow_symlinks', 'symlink', 'sys', 'system', 'terminal_size', 'times', 'times_result', 'truncate', 'umask', 'uname_result', 'unlink', 'urandom', 'utime', 'waitpid', 'walk', 'write']

参考：https://www.sychzs.cn/zh-cn/3/library/functions.html

11、上述总结

没传参的函数，有传参的函数，没返回值的函数，有返回值的函数。既有传参又有返回值的函数。需要
什么样的根据具体需求。
#自我总结

打印菱形

for i in range(1,4):
a=" "*(5-i) +"*"*i +"*"*(i-1)
print(a)
for i in range(2,4):
b=" "*(i+1)+"*"*(3-i)+"*"*(4-i)
print(b)

参考链接：
http://www.sychzs.cn/python3/python3-function.html
https://www.sychzs.cn/i-honey/p/7679897.html
http://www.sychzs.cn/view/2248.html

参考续集

http://www.sychzs.cn/view/2247.html