python 学习

python 将代码分块的三种方法: 函数, 类, 模块

将代码分块可以使代码逻辑清晰

 

1. 函数

(1) 定义函数

有确定的实参: 一个形参只能传入一个实参

def func(形参):
    """函数文档"""
    函数表达式
    
func(实参)
func(形参=实参)

可变实参/收集参数  : # 可变长参数以元组的数据类型传入函数

def func(*形参):       # 一定要有 * 号
    """函数文档"""
    函数表达式
    
func(实参)     # 无 * 号

混合参数: 有确定的参数和可变参数:

def func(*形参1,形参2):
    """函数文档"""
    函数表达式
    
func(实参1,形参2=实参2)

def assemble(*surge,militant):
    """可变长的参数以元组的形式输出"""
    print(surge*2)
    print("//"*20)
    print(militant**2)

assemble('yangmi','dami','damimi',militant=13) # 可变长参数以元组的数据类型传入函数

输出结果:

('yangmi', 'dami', 'damimi', 'yangmi', 'dami', 'damimi')

169
 

assemble(1,2,3,4,militant=13)

输出结果:

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

169

2. 函数和过程

函数:  有返回值, return value

过程:  无返回值

python 有函数没有过程: 因为无return 的情况下, 返回NoneType; 函数会自动的返回数据类型

在函数内定义全局变量: global 变量

global可用于修改全局变量

 

3. 内嵌函数和闭包

(1) 内嵌函数: 函数/外部函数 内嵌套 函数/内部函数, 外部函数之外就无法调用内部函数, 也就说只有在外函数内才能调用内部函数

 

""这是没有调用内部函数""
def military():
    print("你好吗")
    def militant():
        print("不好, 我被关在半岛铁盒里")

military()

输出:

你好吗

""在外部函数内调用内部函数""

def military():
    print("你好吗")
    def militant():
        print("不好, 我被关在半岛铁盒里")
    militant()  # 调用内部函数

military()

输出结果:

你好吗
不好, 我被关在半岛铁盒里

def military():
    print("你好吗")
    def militant():
        print("不好, 我被关在半岛铁盒里")

militant()  # 错误的调用内部函数;
military()

4. 闭包: 内部函数对外部函数整个作用域的变量进行调用; 并且返回内部函数给外部函数

1、不带括号时，调用的是这个函数本身 ，是整个函数体，是一个函数对象，不需等该函数执行完成
2、带括号（此时必须传入需要的参数），调用的是函数的return结果，需要等待函数执行完成的结果

3. 内部函数变量强制修改外部函数变量, 用: nonlocal 变量名

def avert(shift):
    """1、不带括号时，调用的是这个函数本身 ，是整个函数体，是一个函数对象，不需等该函数执行完成"""
    print(shift)
    def militant():
        print("shift=%d"%shift**2)
    return militant # 返回函数

a = avert(10) # 将返回的函数赋值给a, 所以a的数据类型是function; 在这里a相当于militant()
print(type(a))  # <class 'function'>
a() # 对函数a传入实参,也就是内部函数的实参, 若没有形参则不需要传入实参

""

a = avert(10)

a()

这两行等于:

avert(10)()

""

输出结果:

10

<class 'function'>
shift=100

def avert(shift):
    """2、带括号（此时必须传入需要的参数），调用的是函数的return结果，需要等待函数执行完成的结果"""
    print(shift)
    def militant():
        print("shift=%d"%shift**2)
    return militant() # 将内部函数的返回值 返回 给外部函数; 

a = avert(10)
print(a)
print(type(a)) # 但由于内部函数没有返回值,所以得出a的数据类型是 'NoneType'

输出结果:

10
shift=100

None
<class 'NoneType'>

00

00

def avert(shift):
    print(shift)
    def militant():
        print("shift=%d"%shift**2)
        return shift**3 # 内部函数有返回值
    return militant() # 将内部函数的返回值返回给外部函数

a = avert(10) # a得到的是内部函数有返回值, 1000
print(a) 
print(type(a)) # 整型

输出结果:

10
shift=100
1000
<class 'int'>

 

3. 内部函数变量强制修改外部函数变量, 用: nonlocal 变量名

def avert():
    shift = 12
    def militant():
        nonlocal shift # 用nonlocal强制修改内部函数变量; 如果没有这一行, 就会报错;
        shift = shift**2 # 修改过后的内部函数的变量
        return shift

    return militant()

a = avert()
print(a)
print(type(a))

输出结果:

144
<class 'int'>

 

4. 匿名函数lambda

表达式:

函数变量名 = lambda 形参: 返回值的表达式

函数变量名(实参)

avert = lambda x,y: x**y
print(avert(2,3))

输出结果: 8

5. 过滤器函数filter

"""
filter(function or None, iterable) --> filter object

Return an iterator yielding those items of iterable for which function(item)
is true. If function is None, return the items that are true.
"""

表达式: filter(用来过滤的函数, 过滤的迭代对象)

以布尔类型来过滤, 即迭代对象的元素传入用来过滤的函数后, 如果得出的结果是True或者非零值, 则保留; 否则过滤掉

过滤函数有两个或者一个对象: 函数(可有可无) 和 可迭代的对象(如列表,元组,series等)

返回的是一个可迭代的对象

def even(x):
    """用于过滤不是偶数的函数"""
    if  x % 2 == 0:
        return 1  
    else:
        return 0
num = range(24) # 可迭代对象
result = filter(even,num) # 将num中的元素依次传入even函数中, 如果even函数的返回值是1, 则保留; 否则过滤掉
print(list(result))

输出结果: 

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22]

 

filter结合经常lambda使用:

# 使用匿名函数
result = list(filter(lambda x :x % 2==0,range(24)  )) # range(24)是可迭代对象,
print(result)


# 分步写
even = lambda x :x % 2==0
num = range(24)
result = list(filter(even,num ))
print(result)

 

输出结果一样:

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22]

 

6. 映射函数map : 将序列的每一个元素作为参数进行运算加工, 全部元素运算完以后, 返回一个新序列

表达式: map(函数,可迭代的序列/对象)

list1 = list(map(lambda x: x*10,range(10)))
print(type(map(lambda x: x*10,range(10))))
print(list1)

输出结果:

<class 'map'>
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]