彩世界平台-彩世界时时app-彩世界开奖app苹果下载

热门关键词: 彩世界平台,彩世界时时app,彩世界开奖app苹果下载

您的位置:彩世界平台 > 彩世界平台 > python系列4,python系列

python系列4,python系列

发布时间:2019-09-01 20:03编辑:彩世界平台浏览(150)

    python系列4,python系列

    python系列3,python系列

    目录

    • 递归算法解析
    • 冒泡排序解析
    • 装饰器解析

    目录

    • 自定义函数
    • 内置函数
    • 文件的操作
    • 练习题

    一. 递归

    一. 自定义函数

      1. 递归的定义   

        递归(Recursion),又成为递回,在数学与计算机科学中,是指在函数的定义中使用函数自身的方法。递归一词还较长用于描述以自相似方法重复事物的过程。

    斐波那契数列是典型的递归案例:
    F0 = 0(初始值)
    F1 = 1(初始值)
    对所有大于1的整数n: F(n) = F(n - 1) + F(n - 2)(递归定义)
    尽管有许多数学函数均可以递归表示,但在实际应用中,递归的开销过大,因此在不是必要的情况下最好不要用到递归。
    

      1. 函数的创建

    函数的创建
    1.def关键字
    2.函数名+()
    3.冒号
    4.缩进
    5. return返回值,可以不写,默认的返回值为None
    例:
    def hanshuming():
        print(123)
        print(456)
        return True
    hanshuming()
    

      2. 递归的原理

      2. 函数的参数

      (1)参数的定义

      参数是使用通用变量来建立函数和变量之间关系的一个变量。我们都知道函数是用来被调用的,当我们需要给这个函数传送值的时候,参数用来接收调用者传递过来的数据,并保存下来作为一个变量以便后期使用。

      (2)参数的分类

        <1>.实参: 指的是用户在调用函数的时候传递给函数的值。

        <2>.形参: 指的是在函数名后面括号中写入的参数,用来接收用户的实际参数的。

          例:  

    # a 指的是形参,用来接收用户的实参
    # lsjeg 是实参,用来传递给形参
    def test(a):
        print(a)
    test('lsjeg')
    

        

        <3>.指定参数: 指的是传递的参数。

        <4>.默认参数: 指的是函数名后面括号内跟的参数,当没有实参传入的时候,默认是这个值。

          例:由结果可知,当传递的有实参的时候,将用实参,这就是指定参数,当没有实参传入的时候,就用默认值“中国”,这就是默认参数。

    def test(a='中国'):
        print(a)
    test(123)
    test()
    结果:
    123
    中国
    

     

        <5>.动态参数: 指的是加*号的参数。为什么会有动态参数呢?其实就是python把所有的实参循环的放在一个元组里面而已。

        <6>.普通参数: 指的是没有加*的函数,他可以接受任意的实参。

          例:一个星号的动态参数

    # a是普通参数
    # *args是动态参数,把接收的所有参数都保存在一个元组中
    # 动态参数必须放在普通参数后面
    # 要注意的是Python他会自动的把第一个形参传递a,然后后面的都会传递给动态参数。
    def test(a,*args):
        print(args)
    test(123,'sl','s2','s3')
    

     

          例:两个星号的动态参数(主要为了存储字典) 

          注意他的结果,【11,22,33】前面有*,所以会把里面的元素依次的放入元组中,

    # a是普通参数
    # *args是动态参数,把接收的所有参数都保存在一个元组中
    # **kwargs也是动态参数,把接收的所有参数保存在一个字典中,注意,实参必须是键值对
    # 一个*的必须在后面,两个*的必须在一个*的后面
    def test(a,*args,**kwargs):
        print(args)
        print(kwargs)
    test(123,*[11,22,33],sle=23)
    结果:
    (11, 22, 33)
    {'sle': 23}
    

        (1). 例题:

    def recursion(defth, a1, a2):
        if defth == 5:
            return a1
        a3 = a1 + a2
        defth = defth + 1
        print(a1)
        a1 = recursion(defth, a2, a3)
        return a1
    ret = recursion(1, 0, 1)
    print(ret)
    

     

     

      以下这幅图为整个函数的执行过程,红色的代表一层一层的往里面嵌套,绿色的代表函数的返回值一层一层的外面返还。其实递归就是这个原理,通过一个函数的执行流在再次进入此函数,当通过一个条件返回一个值之后,一层一层的按照刚刚的执行流再次返回回去,最后得到返回值,但是递归的时候要注意两点:

      1. 他的条件,必须要使他的递归在某个条件内可以返回一个值,否则就会一直递归,直到电脑资源耗尽(Python默认有递归的次数限制)

      2. 返回值,在里面的递归函数一般要给予他一定的返回值,否则在最后一次返还递归的时候会得不到想要的值。

     

      图片 1

      3. 变量

      <1>.全局变量:简单来说就是没有在函数中定义的变量。一般用大写表示

      <2>.局部变量: 相反,就是在函数中定义的变量。一般小写

        例1:

    # 默认函数里面是没有办法修改全局变量的
    TEST = 123
    def test(a):
        TEST = 456
    test(1)
    print(TEST)
    结果:
    123
    

        例2:修改全局变量

    TEST = 123
    def test(a):
        global TEST
        TEST = 456
    test(1)
    print(TEST)
    结果:
    456
    

     

    二. 冒泡排序

      4. lambda表达式

      什么是lambda表达式呢,其实就是对自定义函数的一个简化,当然,他也是只能用于简单的函数创建。  

      例:

    # 定义了两个函数,两个函数的功能是一样的
    # 一般方式定义test
    # lambda表达式定义的lambda_test
    
    def test(a1, a2):
        return a1+a2
    
    lambda_test = lambda a1,a2: a1+a2
    
    print(test(1,2))
    print(lambda_test(1,2))
    

     

      1. 冒泡排序原理

        冒泡排序就是一种简单的排序算法。他重复的走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。

    冒泡排序算法的运作如下:
      1. 比较相邻的元素。如果第一个比第二个大,就交换他们两个。
      2. 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。这步做完后,最后的元素会是最大的数。
      3. 针对所有的元素重复以上的步骤,除了最后一个。
      4. 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较
    

      5. 三元表达式

      三元表达式是什么东西呢,其实就是对if...else循环的一个简化,但是只能用于简单的if...else的简化,在很多的语言中都有。

      例:if前面的为条件成立后执行的语句,else后面的为条件不成立时执行的语句

    # 普通的判断语句
    a = 1
    if a < 6:
        name = 'huwentao'
    else:
        name = 'zhouyan'
    print(name)
    
    # 这个是三元表达式,
    name = 'zhouyan' if a < 6 else 'huwentao'
    print(name)
    
    输出结果:
    huwentao
    zhouyan
    

     

        交换数据的原理 

        借助一个外围的变量先保存原来的值,然后再去通过指向地址的转换来进行交换数据。注意:当temp指向了a, 然后a再指向b的时候,temp本身的指向是没有发生改变的,就如下图,a指向了b,但是temp依然指向的是a的地址,所以他还是66

    a = 66
    b = 88
    temp = a 
    a = b 
    b = temp 
    

      图片 2

    二. 内置函数简介

    1. str(), int(), bool(), list(), dict(), set(), tuple(), bytes(), type(), isinstance()
        这个是一系列的关于数据类型的函数,因为对于数据类型创建一般有两种方式,
        例: <1>: i = 10 <2>: i = int(10)   这两种方式是一样的,其本质都是调用int函数的_init_函数去创建的对象,其他的类型也一样
        type(): type() 可以显示出类型
            例:
                i = 10
                print(type(i))
                结果:<class 'int'>
        isinstance(要判断的数据, 数据类型): 用来判断是不是某个类型
            例:
                i = 10 
                print(isinstance(i, int))
                结果: True 因为i就是int类型。所以返回True
    
    2. bin(), int(), hex(), oct()
        这是一系列关于进制转换的函数,
        bin(): 十进制转二进制
            例:print(bin(10)) ----->0b1010
        hex(): 十进制转十六进制
            例:print(hex(10)) ----->0xa
        oct(): 十进制转八进制
            例:print(oct(10)) ----->0o12
        int(): 其他进制转十进制
            例: 
                print(int('10101', 2))  #二进制---》十进制
                print(int('ab', 16))    #二进制---》十进制
                print(int('10', 8))     #二进制---》十进制
            结果:
                21  
                171
                8
    3. repr(), ascii()
       这两个函数差不多是一样的,就是调用内置函数里面的_repr__()
    
    4. all(), any()
        all(): 里面的变量全部为真,返回值为真
            例:
                print(all(['hu','zhou','xiaozhou']))
                print(all(['hu','zhou','xiaozhou','']))
            结果:
                True
                False   
        any(): 里面的变量只要有一个为真,就返回为真
            例:
                print(any([]))
                print(any(['hu','zhou','xiaozhou']))
                print(any(['hu','zhou','xiaozhou','']))
            结果:
                False
                True
                True 
    
    5. dir(), help()
        用来获得当前模块或者函数的属性列表
        dir()  获取简单的属性列表
            print(dir(list))
        help()  获取详细的属性列表  
            help(list)
    
    6. enumrate() ,len()
        会给一个序列在生成一列索引,由以下例子可以看出,自动增加缩进然后以一个元组的形式保存在i变量中
        例:
            list = ['hu','zhou','xiaozhou']
            for i in enumerate(list, 1):
                print(i)
        结果:
            (1, 'hu')
            (2, 'zhou')
            (3, 'xiaozhou')
        len(): 得到长度
    
    7. max(), min(), sum(), sorted(), round(), reversed(), abs(), pow(), range(), divmod(), zip()
        这个是一系列关于数据操作的函数
        由名字可以看出,取最大值,最下值,求和,排序,四舍五入,翻转,取绝对值,求幂运算,生成一个可迭代对象
        round():
            例:
                print(round(11.1))
                print(round(11.5))
                print(round(11.6))
            结果:
                11
                12
                12
        reversed():
            例:
                list = [99,32,1,232,44]
                print(sorted(list))
        range():生成一个可迭代对象
            例:
                a = range(10)
                print(a)
                for i in a:
                    print(i, end = ' ')  
            结果:
                range(0, 10)
                0 1 2 3 4 5 6 7 8 9 
        divmod(): 把除数和余数同时输出来
            例:
            print(divmod(10, 3)) -----》 (3, 1)
        zip(): 结合两个列表
            list = [11,22,33,44]
            hu = ['hu','zhou','xiaohu','xiaozhou']
            a = zip(list, hu)
            for i in a:
                print(i)
    
    8. callable() 
        判断里面的数据是否可执行,一般函数和类是可执行的
        例:
            def test():
                return 10
            print(callable(1))
            print(callable('weg'))
            print(callable(test))
        结果:
            False
            False
            True
    9. chr(), ofd() 
        chr(): 数字转ascii
        ord(): asscii转数字
        例:
            print(chr(69))
            print(ord('E'))
    10. compile(),exec(),eval() 
        complie():用来编译生成对象
        exec(): 用来执行编译生成的对象
        例:
            str = '''
            for i in range(4):
                print(i)
            '''
            c = compile(str,'','exec')
            exec(c)
        eval():只能对简单的代码进行操作,不能进行代码的执行
        例:
           print(eval('1+2')) 
    
    11. local() globals(), hash()
        local():当前执行函数的所有局部变量
        globals:当前执行函数的所有全局变量
        hash(): 对里面的数据进行hash运算
    12. exit()
        exit(): 退出程序 
    13. open(), import
        open是打开文件
        import导入模块
    
    14. filter(), map()
        filter(函数,过滤的对象): 每一个过滤的对象都相应的执行函数,当返回为真的时候,就返回回去,并且返回的是一个对象
        例:
            def hanshu(aa):
            if aa > 22:
                return True
            else:
                return False
            a = filter(hanshu, [11,22,33,44])
            print(a)
            for i in a:
                print(i)
        结果:
            <filter object at 0x000000A1636B4470>
            33
            44
        map(函数,对象):每一个过滤的对象都响应的代入函数中执行,返回的是他的返回值,而且返回的是一个对象
        例:
            def hanshu(aa):
            if aa > 22:
                return True
            else:
                return False
            a = map(hanshu, [11,22,33,44])
            print(a)
            for i in a:
                print(i)
        结果:
            <map object at 0x0000005B2B504470>
            False
            False
            True
            True
    

     

        冒泡排序的原理

      图片 3

     

    三. 文件的操作

     2. 冒泡排序事例

     1 # -*- coding:utf-8 -*-
     2 # zhou
     3 # 2017/6/17
     4 list = [0, 88, 99, 33, 22, 11, 1]
     5 for j in range(1, len(list)):
     6     for i in range(len(list) - j):
     7         # 如果第一个数据大, 则交换数据, 否则, 不做改变
     8         if list[i] > list[i + 1]:
     9             temp = list[i]
    10             list[i] = list[i + 1]
    11             list[i + 1] = temp
    12 print(list)
    

      1. 文件的操作

      文件的基本操作有打开,和关闭,读写等。

    # 一般在打开一个文件的时候会创建一个对象传递给一个变量f
    # parameter1:文件名,如果是相对路径,必须在一个目录下面
    # parameter2:模式, 大致分为两种r,w
    # parameter3:编码方式
    f = open('parameter1','parameter2','parameter3')
    f.close()
    

    三. 装饰器

      2. 文件的模式

      1. 装饰器定义

         装饰器是什么呢?简单来说就是在不改变源函数代码的基础上,对代码的一种微妙的扩展,以使得其功能进一步增强的函数。装饰器就是一个函数,一个加载在其他函数之上的函数,

        以下我们先来了解几个概念:

      (1)普通的读写

        <1>.  r: 只能读,传入的文件参数必须要存在,否则会报错

    # test在当前目录下一定要存在
    # flie.write不能用,只能读
    file = open('test','r')
    data = file.read()
    # file.write('lwjege')
    file.close()   
    

        <2>.  w: 只能写,不能读,传入的文件如果存在,就清空里面的内容,如果不存在,就创建

    # 当传入的参数是w的时候,执行完此代码再去查看test文件的时候,会发现里面的内容为“大中国”,无论之前的内容是什么,都是这个内容,因为写操作不是追加的,而是先清空之前的内容然后在写入。
    file = open('test','w')
    file.write('大中国')
    file.close()
    

        <3>.  x: 只能写,不能读,传入的文件不能存在,存在就报错

    #  这里的参数test2在此目录下面不能存在,如果存在就会报错,而且不能读数据
    file = open('test2','x')
    # file.read()
    file.write('大中国')
    file.close()
    

     

        <4>.  a: 只能写,不能读,传入的文件存在,就追加写入,如果不存在,就创建

    # 当传入的参数是a的时候,不能读数据,只能进行写数据,而且他是追加写入,不像w,会把之前的数据都清空
    file = open('test','w')
    file.write('大中国')
    file.close()
    

    本文由彩世界平台发布于彩世界平台,转载请注明出处:python系列4,python系列

    关键词: