xml地图|网站地图|网站标签 [设为首页] [加入收藏]
应用开发之WinForm开发,Python算法基础
分类:编程

函数的作用

函数可以让编程逻辑结构化以及模块化

无论是C、C++,Java还是Python,函数是必不可少的知识点,也是很重要的知识点,函数是完成一个功能的代码块,使用函数可以使逻辑结构变得更加清晰以及程序模块化设计

先来看看Python函数相关知识

 1 def test(x):
 2     """我是用来描述这个函数的"""
 3     x += 1
 4     return x
 5 
 6 # def : 定义函数的关键字
 7 # test: 函数名
 8 # (): 里面定义形参
 9 # """ """: 用来描述这个函数的功能以及所传函数,返回值,
10 # x+= 1: 函数执行的代码块
11 # return :定义返回值

函数的的运行:函数名()  只有加上这个括号才是运行这个函数

一、简介

本章简言

函数运行的结束

  当函数执行遇到return,后面所有的代码都是无效的,都不会执行

def test():
    print('我会打印')
    return
    print('我不会被打印')
test()
"""
我会打印
"""

函数参数:

  1. 形参:只在函数内部有效
  2. 实参:
  3. 位置参数和关键字参数
  4. 默认参数
  5. 参数组

    author = "Tang"

    # 形参:x y z def test(x,y,z):

    print(x)
    print(y)
    print(z)
    

    test(1,2,3) # 实参:1,2,3

    # 位置参数 一一对应 def test(x,y,z):

    print(x)
    print(y)
    print(z)
    

    test(1,2,3) # # test(1,2) # 缺一不可 报错 # test(1,2,3,4) # 多一不可 报错

    # 关键字参数 def test(x,y,z):

    print(x) # 2
    print(y) # 1
    print(z) # 3
    

    test(y=1,x=2,z=3)

    # 位置参数 & 关键字参数 混搭 # 位置参数一定要在关键字的左边 def test(x,y,z):

    print(x) # 2
    print(y) # 1
    print(z) # 3
    

    # test(1,3,y=2) # 报错 位置参数必须一一对应 test(1,y=3,z=2) # test(1,3,z=2,y=3) # 报错,传入参数比形参多 没有覆盖一说

    # x,z 为默认参数 def test(x,y=1,z=3):

    print(x,y,z)
    

    test(10) # 10 1 3默认参数不传 使用默认的 test(10,20,30) # 10 20 30 如果传了就覆盖

# 不定参数
# 参数组: * 列表 元组, **字典 键值对
# 第一种
def test(x,*args):
    print(x) # 1
    print(args) # (2, 3, 4, 5)
    print(*args) # 2 3 4 5 注意:这里没有换行
test(1,2,3,4,5)

# 第二种 *()
def test(x,*args):
    print(x) # 1
    print(args) # ((2, 3, 4, 5, 6)
    print(*args) # 2 3 4 5 6 注意:这里没有换行
test(1,2,3,*(4,5,6))

# 第三种 ()
def test(x,*args):
    print(x) # 1
    print(args) # ((2, 3, (4, 5, 6))
    print(*args) # 2 3 (4, 5, 6) 注意:这里没有换行
test(1,2,3,(4,5,6))

# 第四种 []
def test(x,*args):
    print(x) # 1
    print(args) # (2, 3, [4, 5, 6])
    print(*args) # 2 3 [4, 5, 6] 注意:这里没有换行
test(1,2,3,[4,5,6])

# 第五种 *[]
def test(x,*args):
    print(x) # 1
    print(args) # ((2, 3, 4, 5, 6)
    print(*args) # 2 3 4 5 6 注意:这里没有换行
test(1,2,3,*[4,5,6])

# **kwargs 字典 键值对
# 第一种
def test(x,**kwargs):
    print(x) # 1
    print(kwargs) # {'y': 2, 'z': 3}
    # print(**kwargs) # 报错
test(1,y=2,z=3)

# 第二种
def test(x,**kwargs):
    print(x) # 1
    print(kwargs) # {'y': 2, 'z': 3}
    # print(**kwargs) # 报错
# test(1,{"y":2,"z":3}) # 报错
test(1,**{"y":2,"z":3})

定义和特征

  定义:算法(Algorithm)是指解题方案的准确而完整的描述,是一系列解决问题的清晰指令,算法代表着用系统的方法描述解决问题的策略机制。也就是说,能够对一定规范的输入,在有限时间内获得所要求的输出。如果一个算法有缺陷,或不适合于某个问题,执行这个算法将不会解决这个问题。不同的算法可能用不同的时间、空间或效率来完成同样的任务。一个算法的优劣可以用空间复杂度与时间复杂度来衡量。

  一个算法应该具有以下五个重要的特征:

  • 有穷性:算法的有穷性是指算法必须能在执行有限个步骤之后终止;
  • 确切性:算法的每一步骤必须有确切的定义;
  • 输入项:一个算法有0个或多个输入,以刻画运算对象的初始情况,所谓0个输入是指算法本身定出了初始条件;
  • 输出项:一个算法有一个或多个输出,以反映对输入数据加工后的结果,没有输出的算法是毫无意义的;
  • 可行性:算法中执行的任何计算步骤都是可以被分解为基本的可执行的操作步,即每个计算步都可以在有限时间内完成(也称之为有效性)。

上一章笔者介绍了关于WinForm环境。这一章笔者将继续讲WinForm。只不过更加的面向开发了。事实就是在学习工具箱里面的控件。对于WinForm开发来讲,企业对他的要求并没有那么高。但是如果是游戏相关的话,不好意思!笔者觉得你可能选错语言了。C++可能更合适你。有一点希望读者们明白。下列讲到的内容是笔者在开发用的。只能辅助你学习,却不能成为教材。上一章讲到WinForm开发就是JAVA的Awt和Swing编程。笔者在做Awt和Swing已经过去四年多了。如果记得没有错的话,在设计窗体的时候笔者常常会用到关于FlowLayout类,BorderLayout类,JPanel类等布局类。所以先让我们看一下关于WinForm的布局吧。

函数里面可以调用函数

__author__ = "Tang"

def test1():
    print('我是test1')
def test2():
    print('我是test2')
    test1()
test2()

"""
我是test2
我是test1
"""

设计要求

算法设计的要求: 

  • 确定性: 指的是算法至少应该有输入,输出和加工处理无歧义性,能正确反映问题的需求,能够得到问题的正确答案。确定性大体分为四个层次:

    1.算法程序无语法错误;

    2.算法程序对于合法的输入产生满足要求的输出;

    3.对于非法输入能够产生满足规格的说明;

    4.算法程序对于故意刁难的测试输入都有满足要求的输出结果。 

  • 可读性: 程序便于阅读,理解交流。 
  • 健壮性: 当输入数据不合法时,算法也能作出相关处理,而不是产生异常,崩溃或者莫名其妙的结果。 
  • 时间效率高和存储量低。
WinForm布局

全局变量与局部变量

  1. 全局变量一般都是大写 ,在整个程序中都可以被访问
  2. 局部变量,定义在代码块中,for循环,函数等

    author = "Tang"

    name = "我是全局变量" # def test():

    name = "我是局部变量"
    print(name) # 我是局部变量
    

    test() print(name) # 我是全局变量

以上例子可以看到,当局部变量和全局变量都为同一个变量名的时候,在代码块里面,首先先找代码块中的变量也就是局部变量,当代码块中找不到该变量,就找全局变量

name = "我是全局变量" #
def test():
    print(name) # 我是全局变量
test()
print(name) # 我是全局变量

在代码块中修改全局变量需要用到关键字 global

name = "我是全局变量" #
def test():
    global name
    name = "我是全局变量,我被修改啦"
    print(name) # 我是全局变量,我被修改啦
test()
print(name) # 我是全局变量,我被修改啦

请注意看我哦!

name = "我是全局变量" 
def test():
    global name
    print(name) # 我是全局变量
    name = "我是全局变量,我被修改啦"
    print(name) # 我是全局变量,我被修改啦
test()
print(name) # 我是全局变量,我被修改啦

总结:当找不到代码块中的变量,就会到上一级中找该变量。当看到global 关键字,就要想到要重修赋值全局变量。如果没有global关键字,只能读取全局变量,无法重新赋值全局变量的值。

算法效率的度量方法

  事后统计方法:主要是通过设计好的测试程序和数据,利用计算机计时器对不同算法编制的程序的运行时间进行比较,从而确定算法效率的高低,但这种方法有很大缺陷,一般不予采纳。

  事前分析估算方法:在计算机程序编制前,依据统计方法对算法进行估算。

  一个用高级语言编写的程序在计算机上运行时所消耗的时间取决于以下因素:

  1. 算法采用的策略,方法;(算法好坏的根本)
  2. 编译产生的代码质量;(由软件来支持)
  3. 问题的输入规模;(由数据决定)
  4. 机器执行指令的速度。(看硬件的性能)

 

说到布局,笔者只能先从属性窗体切入了。记得大部分的控件都是从Control类这里继承过来的。而Control类中有俩个属性跟布局有一定有关系。一个是Anchor属性,一个是Dock属性。

下面请注意

当全局变量为可变数据类型的时候,可在代码块中对全局变量进行修改(增,删,改),但是不能对全局变量进行重新赋值,赋值的只是局部变量,除非用global 关键字进行声明为全局变量,此时才是赋值给全局变量

# 第六种 列表添加
NAME = ["tang","lao"]
def test():
    NAME.append('er')
    print(NAME) # ['tang', 'lao', 'er']
test()
print(NAME) # ['tang', 'lao', 'er']

# 第七种 列表删除
NAME = ["tang","lao",'er']
def test():
    NAME.remove('er')
    print(NAME) # ['tang', 'lao']
test()
print(NAME) # ['tang', 'lao']

# 第八种 列表修改
NAME = ["tang","lao",'er']
def test():
    NAME[0] = "chen"
    print(NAME) # ['chen', 'lao', 'er']
test()
print(NAME) # ['chen', 'lao', 'er']

# 第九种 字典 修改
NAME = {"name":"tang","age":18}
def test():
    NAME["name"] = "chen"
    print(NAME) # {'name': 'chen', 'age': 18}
test()
print(NAME) # {'name': 'chen', 'age': 18}

# 第九种 字典 添加
NAME = {"name":"tang","age":18}
def test():
    NAME["hobby"] = "girl"
    print(NAME) # {'name': 'tang', 'age': 18, 'hobby': 'girl'}
test()
print(NAME) # {'name': 'tang', 'age': 18, 'hobby': 'girl'}

# 第九种 字典 删除
NAME = {"name":"tang","age":18}
def test():
    del NAME["name"]
    print(NAME) # {'age': 18}
test()
print(NAME) # {'age': 18}

# 没有global 赋值
NAME = {"name":"tang","age":18}
def test():
    NAME = {'a':1,'b':2}
    print(NAME) # {'a': 1, 'b': 2}
test()
print(NAME) # {'name': 'tang', 'age': 18}

# 有global 赋值
NAME = {"name":"tang","age":18}
def test():
    global NAME
    NAME = {'a':1,'b':2}
    print(NAME) # {'a': 1, 'b': 2}
test()
print(NAME) # {'a': 1, 'b': 2}

算法时间复杂度

  定义:在进行算法分析时,语句总的执行次数T(n)是关于问题规模n的函数,进而分析T(n)随n的变化情况并确定T(n)的数量级。算法的时间复杂度,也就是算法的时间量度,记作:T(n}=0(f(n))。它表示随问题规模n的增大,算法执行时间的埔长率和 f(n)的埔长率相同,称作算法的渐近时间复杂度,简称为时间复杂度。其中f( n)是问题规横n的某个函数。

根据定义,求解算法的时间复杂度的具体步骤是:

  ⑴ 找出算法中的基本语句;

  算法中执行次数最多的那条语句就是基本语句,通常是最内层循环的循环体。
  ⑵ 计算基本语句的执行次数的数量级;
  只需计算基本语句执行次数的数量级,这就意味着只要保证基本语句执行次数的函数中的最高次幂正确即可,可以忽略所有低次幂和最高次幂的系数。这样能够简化算法分析,并且使注意力集中在最重要的一点上:增长率。
  ⑶ 用大Ο记号表示算法的时间性能。
  将基本语句执行次数的数量级放入大Ο记号中。

 

如何推导大o阶呢?下面是基本的推导方法:

  1.用常数1取代运行时间中的所有加法常数。
  2.在修改后的运行次数函数中,只保留最髙阶项。
  3.如果最高阶项存在且不是1,则去除与这个项相乘的常数。

简单的说,就是保留求出次数的最高次幂,并且把系数去掉。  如T(n)=n2+n+1 =O(n2)

Anchor属性的作用就是把控件绑定到其容器的边缘并确定控件随其容器一起调整大小。但是是按什么样的比列调整笔者也不是很清楚。MSDN也没有找到相关的说法。只是说明控件随其容器一起调整大小。下面就是Anchor属性的值。

 一个错误的特例

__author__ = "Tang"

# 错误的例子     报错
# NAME = ['tang','lao','er']
# def test():
#     NAME = "chen"
#     global NAME
#     print(NAME)
# test()
# print(NAME)

# 改正
NAME = "tang"
def test():
    global NAME # 我是声明 我要在 NAME 其他操作的前面
    NAME = "chen"
    print(NAME) # chen
test()
print(NAME) # chen

总结:声明要在其他操作的前面,不然会报错。。。。。。

 

为了防止错误,全局变量大写,局部变量小写,可以防止编程出现没必要的错误

一些例子

######复杂度O(1)
print("this is wd")


######复杂度O(n)
for i in range(n):
    print(i)


######复杂度O(n2)
for i in range(n):
    for j in range(n):
        print(j)


######复杂度O(n3)
for i in range(n):
    for j in range(n):
        for k in range(n):
            print('wd')



######复杂度O(log2n)
while n > 1:
    print(n)
    n = n // 2

常见的复杂度按效率排序:O(1)<O(logn)<O(n)<O(nlogn)<O(n2)<O(2nlogn)<O(n2)

 

    public enum AnchorStyles
    {
        // 摘要: 
        //     该控件未锚定到其容器的任何边缘。
        None = 0,
        //
        // 摘要: 
        //     该控件锚定到其容器的上边缘。
        Top = 1,
        //
        // 摘要: 
        //     该控件锚定到其容器的下边缘。
        Bottom = 2,
        //
        // 摘要: 
        //     该控件锚定到其容器的左边缘。
        Left = 4,
        //
        // 摘要: 
        //     该控件锚定到其容器的右边缘。
        Right = 8,
    }

函数嵌套

 1 __author__ = "Tang"
 2 
 3 # 函数嵌套
 4 NAME = "全局"
 5 def yeye():
 6     name = "爷爷级别"
 7     print(name)
 8     def fu():
 9         name =  "父级别"
10         print(name)
11         def zi():
12             name = "子级别"
13             print(name)
14             def sunzi():
15                 name = "孙子级别"
16                 print(name)
17             sunzi()
18         zi()
19     fu()
20 yeye()
21 print(NAME)
22 
23 """
24 爷爷级别
25 父级别
26 子级别
27 孙子级别
28 全局
29 """

再来一个,请仔细看

name = "A"

def test():
    name = "B"
    def test_test():
        global name
        name = "C"
    test_test()
    print(name) # B
print(name) #  A
test()
print(name) # C

空间复杂度 

  空间复杂度(Space Complexity)是对一个算法在运行过程中临时占用存储空间大小的量度。一个算法在计算机存储器上所占用的存储空间,包括存储算法本身所占用的存储空间,算法的输入输出数据所占用的存储空间和算法在运行过程中临时占用的存储空间这三个方面。算法的输入输出数据所占用的存储空间是由要解决的问题决定的,是通过参数表由调用函数传递而来的,它不随本算法的不同而改变。存储算法本身所占用的存储空间与算法书写的长短成正比,要压缩这方面的存储空间,就必须编写出较短的算法。算法在运行过程中临时占用的存储空间随算法的不同而异,有的算法只需要占用少量的临时工作单元,而且不随问题规模的大小而改变,这种算法是节省存储的算法;有的算法需要占用的临时工作单元数与解决问题的规模n有关,它随着n的增大而增大,当n较大时,将占用较多的存储单元。

如当一个算法的空间复杂度为一个常量,即不随被处理数据量n的大小而改变时,可表示为O(1);当一个算法的空间复杂度与以2为底的n的对数成正比时,可表示为0(log2n);当一个算法的空间复杂度与n成线性比例关系时,可表示为0(n).若形参为数组,则只需要为它分配一个存储由实参传送来的一个地址指针的空间,即一个机器字长空间;若形参为引用方式,则也只需要为其分配存储一个地址的空间,用它来存储对应实参变量的地址,以便由系统自动引用实参变量。 

 

如果你设置Right的话,当你把容器往右边拉的话,设置的控件大小也往右边变。还是让笔者举一个例子吧。 

关键字 nonlocal 声明上一级的变量

name = "A"

def test():
    name = "B"
    def test_test():
        nonlocal name # nonlocal,指定上一级变量
        name = "C"
    test_test()
    print(name) # C
print(name) #  A
test()
print(name) # A

nonlocal 只能使用于两级或多级函数嵌套,一级嵌套会导致程序报错,下面请看一个错误的示例

name = "A"
def test():
    nonlocal name # 报错
    name = "C"
    print(name)
print(name)
test()
print(name)

二、python中的常见算法

图片 1

函数声明与调用的顺序

函数即变量,调用函数前需先声明

# 第一种情况
def foo():
    print("foo")
    bar()

def bar():
    print("bar")
foo()

下面看一个错误的例子

# 第二种情况 报错的例子
def foo():
    print("foo")
    bar()

foo()
def bar():
    print("bar")

冒泡排序

效率:O(n2)

原理:

  1. 比较相邻的元素,如果第一个比第二个大,就交换他们两个;

  2. 对每一对相邻元素做同样的工作,从开始第一对到结尾的最后一对。做完以后,最后的元素会是最大的数,这里可以理解为走了一趟;

  3. 针对所有的元素重复以上的步骤,除了最后一个;

  4. 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较,最后数列就是从大到小一次排列;

demo:

def bubble_sort(data):
    """
    冒泡排序
    :param data: 
    :return: 
    """
    for i in range(len(data)-1):  # 趟数
        for j in range(len(data)-i-1):  # 遍历数据,依次交换
            if data[j]>data[j+1]:  # 当较大数在前面
                data[j],data[j+1]=data[j+1],data[j] #交换两个数的位置

if __name__=='__main__':
    import random
    data_list=list(range(30))
    random.shuffle(data_list)
    print("pre:",data_list)
    bubble_sort(data_list)
    print("after:",data_list)
#结果:
#pre: [22, 11, 19, 16, 12, 18, 20, 28, 27, 4, 21, 10, 9, 7, 1, 6, 5, 29, 8, 0, 17, 26, 13, 14, 15, 24, 25, 23, 3, 2]
#after: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]

优化版本:当某一趟走完以后发现并没有进行数据交换,那么此时的数列已经排列好了,没有必要在进行下去。例如:极端情况下,数列本来已经排序好的,我们只需要走一趟即可完成排序。

def bubble_sort(data):
    """
    冒泡排序优化版
    :param data: 
    :return: 
    """
    for i in range(len(data)-1):  # 趟数
        exchange=False   # 交换标志
        for j in range(len(data)-i-1):  # 遍历数据,依次交换
            if data[j]>data[j+1]:  # 当较大数在前面
                data[j],data[j+1]=data[j+1],data[j]  # 交换两个数的位置
                exchange = True  # 改变标志
        if not exchange: # 如果某一趟没有进行交换,代表排序完成
            break
    return i  # 返回次数的趟数

if __name__=='__main__':
    data_list=list(range(30))
    print("pre:",data_list)
    num =bubble_sort(data_list)
    print("after:",data_list,'趟数:',num+1)
#结果:
#pre: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]
#after: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29] 趟数: 1

从图上可以看出笔者设置了四个值——上下左右。现在笔者就拖动一下看看他们的变化吧。

 函数递归

  1.  必须有一个明确的结束条件(if 判断)return结束
  2. 每次进入更深一层递归时,问题规模相比上一次递归都应有所减少

 

 1 __author__ = "Tang"
 2 
 3 def calc(n):
 4     print(n)
 5     if int(n / 2) ==0:
 6         return n
 7     res = calc(int(n/2))
 8     print("****",res)
 9     return res
10 n = calc(10)
11 print(n)
12 """
13 10
14 5
15 2
16 1
17 **** 1
18 **** 1
19 **** 1
20 1
21 """

 

递归代码练习:一个快速排序的例子

 1 # coding:utf-8
 2 def quick_sort(alist, first, last):
 3     """快速排序"""
 4     if first >= last:
 5         return
 6     mid_value = alist[first]
 7     low = first
 8     high = last
 9     while low < high:
10         # high 左移
11         while low < high and alist[high] >= mid_value:
12             high -= 1
13         alist[low] = alist[high]
14 
15         while low < high and alist[low] < mid_value:
16             low += 1
17         alist[high] = alist[low]
18     # 循环退出时,满足条件low==high
19     alist[low] = mid_value
20 
21     # 对low左边的列表执行快速排序
22     quick_sort(alist, first, low-1)
23 
24     # 对low右边的列表排序
25     quick_sort(alist, low+1, last)
26 
27 
28 if __name__ == "__main__":
29     li = [54, 26, 93, 17, 77, 31, 44, 55, 20]
30     print(li)
31     quick_sort(li, 0, len(li)-1)
32     print(li)

斐波那契数列

__author__ = "Tang"

# 斐波那契数列
a = 0
b = 1
while b < 1000:
    print(b,end=" ")
    a,b = b, a+b
# 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987

# 生成前20项
lis =[]
for i in range(20):
    if i ==0 or i ==1:# 第1,2项 都为1
        lis.append(1)
    else:
        lis.append(lis[i-2]+lis[i-1])# 从第3项开始每项值为前两项值之和
print(lis) # [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]

# 递归实现
li = []
def test(a, b):
    if a > 1000 or b > 1000:
        return
    li.append(a)
    li.append(b)
    a = a + b
    b = a + b
    test(a, b)
test(1, 1)
print(li) # [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987]

 函数作用域相关练习

 1 __author__ = "Tang"
 2 
 3 """函数的作用域相关练习"""
 4 
 5 """
 6 寻找变量的顺序:当前函数里面寻找,如果找不到就往上一层函数找,实在找不到就找全局变量
 7 函数的调用:函数名+ () 函数名即变量,只要取得函数地址就可以
 8 """
 9 
10 # 第一种
11 def foo():
12     print("我是foo")
13     def bar():
14         print("我是bar")
15     bar()
16 foo()
17 # bar() # 报错 不可以直接调用 记住:要想执行里面的,就要先执行外面的,想象盒子里面包含盒子,外面的盒子不拿掉,里面的也拿不出来
18 """
19 我是foo
20 我是bar
21 """
22 
23 # 第二种
24 def foo():
25     print("我是foo")
26     def bar():
27         print("我是bar")
28     return bar
29 test = foo()
30 test() # 可以调用 test拿到bar函数的地址
31 """
32 我是foo
33 我是bar
34 """
35 
36 # 第三种
37 def test():
38     print("我是test")
39 print(test()) # 没有没有返回值 默认为None
40 """
41 我是test
42 None
43 """
44 
45 # 第四种
46 def test():
47     print("我是test")
48     return 10
49 print(test())
50 """
51 我是test
52 10
53 """
54 
55 # 第五种
56 name = "tang"
57 def foo():
58     name = "chen"
59     def bar():
60         name = "li"
61         print(name)
62     return bar
63 a = foo()
64 print(a)
65 a()
66 """
67 <function foo.<locals>.bar at 0x02FE0B28>
68 li
69 """
70 
71 # 第六种
72 name = "tang"
73 def foo():
74     name = "chen"
75     def bar():
76         print(name)
77     return bar
78 a = foo()
79 print(a)
80 a()
81 """
82 <function foo.<locals>.bar at 0x00830B70>
83 chen
84 """
85 
86 # 第七种
87 name = "tang"
88 def foo():
89     name = "chen"
90     def bar():
91         print(name)
92     return bar
93 foo()()
94 """
95 chen
96 """

选择排序

效率:O(n2)

原理:

  1. 每一次从待排序的列表中选出一个元素,并将其与其他数依次比较,若列表中的某个数比选中的数小,则交换位置,把所有数比较完毕,则会选出最小的数,将其放在最左边(这一过程称为一趟);
  2. 重复以上步骤,直到全部待排序的数据元素排完;

demo:

def select_sort(data):
    """
    选择排序
    :param data: 待排序的数据列表
    :return: 
    """
    for i in range(len(data)-1):  #趟数
        min_index=i  # 记录i趟开始最小的数的索引,我们从最左边开始
        for j in range(i+1,len(data)): # 每一次趟需要循环的次数
            if data[j] < data[min_index]:  # 当数列中的某一个数比开始的数要小时候,更新最小值索引位置
                min_index=j
        data[i],data[min_index]=data[min_index],data[i]  # 一趟走完,交换最小值的位置,第一趟最小



if __name__=='__main__':
    import random
    data_list=list(range(30))
    random.shuffle(data_list)  # 打乱列表数据
    print("pre:",data_list)
    select_sort(data_list)
    print("after:",data_list)
#结果:
#pre: [20, 11, 22, 0, 18, 21, 14, 19, 7, 23, 27, 29, 24, 4, 17, 15, 5, 10, 26, 13, 25, 1, 8, 16, 3, 9, 2, 28, 12, 6]
#after: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]

 

图片 2   图片 3

匿名函数 lambda

lambda x : x+1 一个简单的匿名函数

__author__ = "Tang"


def test(x):
    return x + 1
res = test(10)
print(res) # 11

#  匿名函数实现上面函数
func = lambda x:x+1
print(func(10)) # 11

下面通过一些简单的例子来加深匿名函数的理解

# 第一个
name = "tang"
def change_name(x):
    return x +"_sb"
res = change_name(name)
print(res) # tang_sb

res = lambda x:name+"_sb"
print(res(name)) # tang_sb
print(res("tang")) # tang_sb

res = lambda x:x+"_sb"
print(res(name)) # tang_sb
print(res("tang")) # tang_sb


# 第二个 传多个参数
func = lambda x,y,z:x+y+z
print(func(1,2,3)) # 6

# 第三个
name1 = "tang"
name2 = "lao"
name3 = "er"
x = lambda name1,name2,name3:"".join([name1,name2,name3])
print(x(name1,name2,name3)) # tanglaoer

 

插入排序

效率:O(n2)

原理:

  1. 以从小到大排序为例,元素0为第一个元素,插入排序是从元素1开始,尽可能插到前面。
  2. 插入时分插入位置和试探位置,元素i的初始插入位置为i,试探位置为i-1,在插入元素i时,依次与i-1,i-2······元素比较,如果被试探位置的元素比插入元素大,那么被试探元素后移一位,元素i插入位置前移1位,直到被试探元素小于插入元素或者插入元素位于第一位。
  3. 重复上述步骤,最后完成排序

demo:

def insert_sort(data):
    """
    插入排序
    :param data: 待排序的数据列表
    :return: 
    """
    for i in range(1, len(data)): # 无序区域数据
        tmp = data[i] # 第i次插入的基准数
        for j in range(i, -1, -1):
            if tmp < data[j - 1]:  # j为当前位置,试探j-1位置
                data[j] = data[j - 1]  #  移动当前位置
            else:  # 位置确定为j
                break
        data[j] = tmp  # 将当前位置数还原

if __name__=='__main__':
    import random
    data_list=list(range(30))
    random.shuffle(data_list)  # 打乱列表数据
    print("pre:",data_list)
    insert_sort(data_list)
    print("after:",data_list)
#结果:
#pre: [7, 17, 10, 16, 23, 24, 13, 11, 2, 5, 15, 29, 27, 18, 4, 19, 1, 9, 3, 21, 0, 14, 12, 25, 22, 28, 20, 6, 26, 8]
#after: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]

按扭是放在一个Panel类的容器里面的。现在笔者拖动了Panel就是发现按扭跟着一起发现变化。

快速排序

效率:平均O(nlogn)

原理:

  1. 从数列中随机挑选出一个数作为基数;
  2. 重新排列数列,使得比基数小的元素在左边,比基数大元素在右边,相等的元素放左边或者右边都可以,最后使得该基数在处于数列中间位置,这个称为分区操作;
  3. 递归上述操作,完成排序,如下如;

      图片 4

demo:

#!/usr/bin/env python3
#_*_ coding:utf-8 _*_
#Author:wd

def quick_sort(data,left,right):
    """
    快速排序
    :param data: 待排序的数据列表
    :param left: 基准数左边元素的索引
    :param right: 基准数右边元素的索引
    :return: 
    """
    if left < right:
        mid = partition(data,left,right)  # 分区操作,mid代表基数所在的索引
        quick_sort(data,left,mid-1)   # 对基准数前面进行排序
        quick_sort(data,mid+1,right)  # 对基准数后面进行排序


def partition(data,left,right):
    tmp=data[left]  # 随机选择的基准数,从最左边开始选
    while left < right:
        while left < right and data[right] >= tmp:  # 右边的数比基准数大
            right-=1  # 保留该数,然后索引指针往左移动
        data[left]=data[right]   # 否则此时右边数比基数小,则将该数放到基准位置
        while left < right and data[left] <= tmp: # 右边的数比基准数小
            left+=1  # 此时保持该数位置不动,索引指针往前移动
        data[right]=data[left]  # 否则此时左边的数比基数大,则将该数放到右边
    data[left] = tmp  # 最后将基准数量放回中间
    return left  # 返回基准数位置

if __name__=='__main__':
    data_list=[1,3,21,6,50,33,34,58,66]
    quick_sort(data_list,0,len(data_list)-1)
    print(data_list)
###结果:[1, 3, 6, 21, 33, 34, 50, 58, 66]

Dock属性这个可以说是跟JAVA的BorderLayout类是一个样子的。把容器分为上、下、左、右、中五大区。所以对应的Dock属性的值也有五种。

堆排序

堆定义:本质是一个完全二叉树,如果根节点的值是所有节点的最小值称为小根堆,如果根节点的值是所有节点的最大值,称为大根堆。

效率:O(nlogn)

原理:

  1. 将待排序数据列表建立成堆结构(建立堆);
  2. 通过上浮(shift_up)或下沉(shift_down)等操作得到堆顶元素为最大元素(已大根堆为例);
  3. 去掉堆顶元素,将最后的一个元素放到堆顶,重新调整堆,再次使得堆顶元素为最大元素(相比第一次为第二大元素);
  4. 重复3操作,直到堆为空,最后完成排序;

      图片 5

demo:

def sift(data, low, high):
    """
    调整堆函数
    :param data: 带排序的数据列表
    :param low: 值较小的节点的位置,可以理解为是根节点
    :param high:值较大的节点的位置 
    :return: 
    """
    i = low
    j = 2 * i  # 父节点i所对应的左孩子
    tmp = data[i]  # 最较小节点的值
    while j <= high:
        if j < high and data[j] < data[j + 1]:  # 如果右孩子比左孩子大则把j指向右节点
            j += 1  # 指向右节点
        if tmp < data[j]:  # 如果此时位置较小的节点值比该节点值小,则将该节点上浮最为新的父节点,并调整该节点双亲
            data[i] = data[j]
            i = j  # 调整该节点的双亲的位置
            j = 2 * i
        else:
            break  # 否则代表本次调整已经完成,并且节点i已经无值
    data[i] = tmp  # 最后将被调整节点的值放到i节点上(空出的位置)


def heap_sort(data):
    """
    堆排序
    :param data: 待排序的数据列表
    :return: 
    """
    n = len(data)
    for i in range(n // 2 - 1, -1, -1):
        sift(data, i, n - 1)
    # 构建堆
    for i in range(n - 1, -1, -1):  # 调整过程,从最后一个元素开始交换
        data[0], data[i] = data[i], data[0]  # 交换
        sift(data, 0, i - 1)  # 开始调整


if __name__ == '__main__':
    import random
    data_list = [1, 3, 21, 6, 50, 33, 34, 58, 66]
    random.shuffle(data_list)  # 打乱列表数据
    print("pre:", data_list)
    heap_sort(data_list)
    print("after:", data_list)
#结果:
#pre: [66, 3, 58, 34, 1, 33, 21, 6, 50]
#after: [1, 3, 6, 21, 33, 34, 50, 58, 66]
 1     public enum DockStyle
 2     {
 3         // 摘要: 
 4         //     该控件未停靠。
 5         None = 0,
 6         //
 7         // 摘要: 
 8         //     该控件的上边缘停靠在其包含控件的顶端。
 9         Top = 1,
10         //
11         // 摘要: 
12         //     该控件的下边缘停靠在其包含控件的底部。
13         Bottom = 2,
14         //
15         // 摘要: 
16         //     该控件的左边缘停靠在其包含控件的左边缘。
17         Left = 3,
18         //
19         // 摘要: 
20         //     该控件的右边缘停靠在其包含控件的右边缘。
21         Right = 4,
22         //
23         // 摘要: 
24         //     控件的各个边缘分别停靠在其包含控件的各个边缘,并且适当调整大小。
25         Fill = 5,
26     }

归并排序

效率:O(nlogn)

空间复杂度:O(n)

原理:

  1. 申请空间,使其大小为两个已经排序序列之和,该空间用来存放合并后的序列;
  2. 设定两个指针,最初位置分别为两个已经排序序列的起始位置;
  3. 比较两个指针所指向的元素,选择相对小的元素放入到合并空间,并移动指针到下一位置;
  4. 重复步骤3直到某一指针达到序列尾;
  5. 将另一序列剩下的所有元素直接复制到合并序列尾。

      图片 6

demo:

def merge(data, low, mid, high):
    """
    合并函数
    :param data: 数据列表
    :param low: 列表开头位置
    :param mid: 分割中间位置
    :param high: 列表最后位置
    :return: 
    """
    i = low  # 第一个指针
    j = mid + 1  # 第二个指针
    tmp = []  # 临时存放的列表
    while i <= mid and j <= high:  # 分割的列表当两边都有数才进行
        if data[i] < data[j]:
            tmp.append(data[i])
            i += 1  # 低的指针往右移动
        else:
            tmp.append(data[j])  # 右边大,存右边的数
            j += 1  # 同时指针右移动

    while i <= mid:  # 左边分割有剩下
        tmp.append(data[i])
        i += 1
    while j <= high:  # 右边有剩下
        tmp.append(data[j])
        j += 1
    data[low:high + 1] = tmp  # 最后将tmp中的数写入到原来的列表中


def merge_sort(data, low, high):
    """
    归并排序
    :param data: 待排序的数据列表
    :param low: 数据列表开始位置
    :param high: 数据列表结束位置
    :return: 
    """
    if low < high:  # 至少有两个元素才进行
        mid = (low + high) // 2  # 分割
        merge_sort(data, low, mid)  # 递归分割上一部分
        merge_sort(data, mid + 1, high)  # 递归分割下一部分
        merge(data, low, mid, high)  # 合并


if __name__ == '__main__':
    import random

    data_list = [1, 3, 21, 6, 50, 33, 34, 58, 66]
    random.shuffle(data_list)  # 打乱列表数据
    print("pre:", data_list)
    merge_sort(data_list, 0, len(data_list) - 1)
    print("after:", data_list)

#结果:
#pre: [21, 3, 33, 58, 34, 66, 1, 6, 50]
#after: [1, 3, 6, 21, 33, 34, 50, 58, 66]

你们可以自己动手试一下。就是设置对应的值。就是可以零距离停靠所设置的区。算了。笔者设置一下TOP吧。看一下样子吧。

希尔排序

效率:与增量有关,O(n1+£)其中<0£<1,如增量为2k-1 复杂度为O(n3/2)

原理:

  1. 先取一个小于n的整数d1作为第一个增量,把文件的全部记录分组。所有距离为d1的倍数的记录放在同一个组中。
  2. 先在各组内进行直接插入排序;
  3. 取第二个增量d2<d1重复上述的分组和排序,直至所取的增量  =1(  <  …<d2<d1),即所有记录放在同一组中进行直接插入排序为止。

    def shell_sort(data):

    """
    希尔排序
    :param data:待排序的数据列表 
    :return: 
    """
    d1 = len(data) // 2  # 设置分割大小为d1,
    while d1 > 0:
        for i in range(d1, len(data)):
            tmp = data[i]  # 当前分割元素位置
            j = i - d1  # 上一个分割元素位置
            while j >= 0 and tmp < data[j]:  # 上一个元素分割位置比当前分割位置要大,则需要调整位置
                data[j + d1] = data[j]  # 后移动当前分割元素位置
                j -= d1  # 往前移d1
            data[j + d1] = tmp
        d1 //= 2  # 继续分割
    
if __name__ == '__main__':
    import random
    data_list = [1, 3, 21, 6, 50, 33, 34, 58, 66]
    random.shuffle(data_list)  # 打乱列表数据
    print("pre:", data_list)
    shell_sort(data_list)
    print("after:", data_list)
#结果:
#pre: [3, 66, 58, 34, 33, 50, 6, 21, 1]
#after: [1, 3, 6, 21, 33, 34, 50, 58, 66]

 

 

 

图片 7

上面俩个属性的功能大概多了解了。接下就来讲一下关于FlowLayoutPanel控件吧。JAVA的FlowLayout有一点类似。意为流动布局。而C#的这个叫流式布局面板。是一个容器。看一下下面的图片吧。

图片 8

我们可以看到,如果不够位置放一个按扭的时候,会自动换行存放。FlowLayoutPanel控件里面有一个叫FlowDirection属性来设置流动的方向。是从左到右,是从上到下。这个吗读者们自行查看。

用户定义控件

在开发过程中,我们会发现官方提供的控件有时候并不能满足我们自己的业务需求。这个时候怎么办呢?其实开发人员完全可以自己组装一个控件。即是用户定义控件。选中项目右击》添加》用户控件。

图片 9

图片 10

填写对应的用户控件的名称之后,点击添加按扭。visual studio就会切换到用户控件的设计窗体界面,同时项目里面会多出一个文件。如下

图片 11

图片 12

本文由澳门新葡亰手机版发布于编程,转载请注明出处:应用开发之WinForm开发,Python算法基础

上一篇:lambda匿名函数,作为脚本语言执行解密 下一篇:没有了
猜你喜欢
热门排行
精彩图文