python高级函数练习（三）

1、闭包需要满足的三个条件是什么？

1. 存在于两个嵌套关系的函数中，并且闭包是内部函数
2. 内部函数引用了外部函数的变量
3. 外部函数会把内部函数的函数名称返回

按照上面三个条件创建一个用于计算平方根的闭包函数。

import math
def outerfunc():  # outerfunc为外函数
    x=int(input("请输入一个数字："))  # x是外函数的非全局变量
    def innerfunc():  # innerfunc是内函数
        return math.sqrt(x)  #内函数使用外函数的非全局变量
    return innerfunc  #外函数最终返回的是内函数的引用
func=outerfunc()
sqrtone=func()
print("内函数计算后的平方根是："+str(sqrtone))

2、现有一函数内容如下：

要求为test函数创建装饰器，装饰器函数有入参，在装饰器中打印出装饰函数，执行结果如下：

def q(w1):
    def inner(num1,num2):
        print("装饰器开始装饰：")
        print("--打印装饰器的入参为：",num1,num2,"我是装饰器的入参啊")
        w1(num1,num2)
        return 'huatec'
    return inner
@q
def test(num1,num2):
    print("被验证函数开始，被修饰函数入参之和为：",num1+num2)
    return 'huatec'
#调用test函数
print(test(1,2))

3、使用filter函数打印出1~100内所有能被3整除的数

import math
def bszc(x):
    return x%3==0
newlist = filter(bszc,range(1,101))
print(list(newlist))

4、输入一个数使用reduce计算这个数的阶乘。

from functools import reduce
def add(x,y):
    return x*y
list = []
i=int(input("计算阶乘，请输入一个数："))
for x in range(1,i+1):
    list.append(x)
    print(list)
reduce(add,list)
print(int(reduce(add,list)))

5、实现乘法重载，将两个列表对应元素相乘。

import numpy as np
class TestChengFa(object):
    def __init__(self,high,old):
        self.high=high
        self.old=old
    def chenfa(self,a,b):
        return a*b
    def chenfa(self,listone,listtwo):
        listthree=np.multiply(np.array(listone),np.array(listtwo))
        print(listthree)
    #创建对象
jack = TestChengFa(2,20)
print("开始调用原方法：")
print(jack.chenfa(4,5))
list1=[1,2,3,4]
list2=[5,6,7,8]
print("开始调用重载的方法")
jack.chenfa(list1,list2)

6、参照课件实例，完成鱼，鸟和水鸟的多继承创建。

#定义鱼类
class Fish(object):
    def __init__(self,name):
        self.name=name
        print("这是鱼的构造方法，它的名字是："+self.name)
    def aoyou(self):
            print("鱼的特点是会遨游")
#定义鸟类
class Bird(object):
    def __init__(self,name):
        self.name=name
        print("这是鸟的构造方法，它的名字是："+self.name)
    def feixiang(self):
        print("鸟的特点是会飞翔")
class WaterBird(Fish,Bird):
    def __init__(self,name):
        self.name=name
        print("这是水鸟的构造方法，它的名字是："+self.name)
#开始创建鸟类，鱼类，水鸟类的对象，比较他们之间的异同来体会多继承
fishone=Fish("小黄鱼")
fishone.aoyou()
birdone=Bird("小鸟")
birdone.feixiang()
waterbirdone=WaterBird("小水鸟")
waterbirdone.feixiang()
waterbirdone.aoyou()

运行结果：

7、现有一Python类如下：
创建一个实例，按照“实例.属性”的方式分别打印出类属性和实例属性，要求打印的类属性为9，实例属性为5，按照“类.属性”的方式，打印出可以打印的所有属性，要求其中打印的类属性值为6，打印部分结果如下图：

class Cat(object):
    # 类属性，位于方法外面，类里面，被类的所有实例对象共有
    number=0
    def __init__(self,age):
         # self.属性的属性都是实例属性
        self.age=age
        print("这是猫的构造方法，年龄是："+self.age+"它的实例属性是age，类属性是number")
# 按要求打印类属性和实例属性
catone=Cat("5")
# 使用实例打印类属性
print("cat的类属性是："+str(catone.number))  # 默认是0
Cat.number=9
print("cat的类属性是："+str(catone.number))
# 体验用另一个对象调用类属性，因为被共用，打印值还是9
cattwo=Cat("5")
print("cat的类属性是："+str(cattwo.number))
# 使用实例打印实例属性
print("cat的实例属性是："+str(catone.age))
# 按照类.属性的方式打印所有属性，其实只能打印类属性
Cat.number=6
print("cat的类属性是："+str(Cat.number))

运行结果：

8、创建一个类，要求内部包含一个用于求和的类方法，一个用于打印求和结果的静态方法，如图所示：

class TestOne(object):
    # 定义求和的类方法
    @classmethod
    def he(cls,a,b):
        return a+b
    # 定义用于打印求和结果的类方法，静态方法和类没有直接关系，起到类似函数的作用
    @staticmethod
    def output(a,b):
        print("求和的结果是："+str(TestOne.he(a,b)))
# 开始调用类方法
TestOne.he(3,4)
# 开始调用静态打印方法
testone=TestOne()
testone.output(3,4)

运行结果：

9、参照“模板”章节课件，完成模块得到制作、发布和安装。

①创建名为suba.subb的包,在包里分别创建 aa.py,bb.py,cc.py,dd.py的模块文件，每个模块都完成一定的功能(即定义一个函数)，创建过程省略，结果如图：


②再创建名为setup的.py文件，与suba.subb在同一目录下，并编辑文件， 指明要包含 aa.py,bb.py,cc.py,dd.py模块文件以及即将发布的模块包的版本，作者和描述信息，如图：

from distutils.core import setup
setup(
    name="AutoCc",
    version="1.0",
    description="AutoCc belongs to 大众",
    author="cgt",
    py_modules=["suba.aa","suba.bb","subb.cc","subb.dd"]
)

③在终端进入pycharm的默认工作台目录，该目录下存放了所有的工程文件。
开始构建模块在终端执行 python setup.py build命令

④构建完成后工作台文件夹出现了build-lib目录,该目录下有suba.subb两个模块包，如图：

⑤构建后的目录结构

⑥生成压缩发布包

⑦打包后的目录结构

⑧模块的安装

⑨解压后的文件结构

⑩解压后的文件结构：

⑪在终端执行命令python setup.py install

⑫查看信息