zoukankan      html  css  js  c++  java

  • Python基础之函数

    三元运算

    三元运算（三目运算），是对简单的条件语句的缩写。

    1
    2
    3
    4
    5
    # 书写格式
     
    result = 值1 if 条件 else 值2
     
    # 如果条件成立，那么将 “值1” 赋值给result变量，否则，将“值2”赋值给result变量

    基本数据类型补充

    set

    set集合，是一个无序且不重复的元素集合

    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
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    class set(object):
        """
        set() -> new empty set object
        set(iterable) -> new set object
         
        Build an unordered collection of unique elements.
        """
        def add(self, *args, **kwargs): # real signature unknown
            """
            Add an element to a set，添加元素
             
            This has no effect if the element is already present.
            """
            pass
     
        def clear(self, *args, **kwargs): # real signature unknown
            """ Remove all elements from this set. 清除内容"""
            pass
     
        def copy(self, *args, **kwargs): # real signature unknown
            """ Return a shallow copy of a set. 浅拷贝  """
            pass
     
        def difference(self, *args, **kwargs): # real signature unknown
            """
            Return the difference of two or more sets as a new set. A中存在，B中不存在
             
            (i.e. all elements that are in this set but not the others.)
            """
            pass
     
        def difference_update(self, *args, **kwargs): # real signature unknown
            """ Remove all elements of another set from this set.  从当前集合中删除和B中相同的元素"""
            pass
     
        def discard(self, *args, **kwargs): # real signature unknown
            """
            Remove an element from a set if it is a member.
             
            If the element is not a member, do nothing. 移除指定元素，不存在不保错
            """
            pass
     
        def intersection(self, *args, **kwargs): # real signature unknown
            """
            Return the intersection of two sets as a new set. 交集
             
            (i.e. all elements that are in both sets.)
            """
            pass
     
        def intersection_update(self, *args, **kwargs): # real signature unknown
            """ Update a set with the intersection of itself and another.  取交集并更更新到A中 """
            pass
     
        def isdisjoint(self, *args, **kwargs): # real signature unknown
            """ Return True if two sets have a null intersection.  如果没有交集，返回True，否则返回False"""
            pass
     
        def issubset(self, *args, **kwargs): # real signature unknown
            """ Report whether another set contains this set.  是否是子序列"""
            pass
     
        def issuperset(self, *args, **kwargs): # real signature unknown
            """ Report whether this set contains another set. 是否是父序列"""
            pass
     
        def pop(self, *args, **kwargs): # real signature unknown
            """
            Remove and return an arbitrary set element.
            Raises KeyError if the set is empty. 移除元素
            """
            pass
     
        def remove(self, *args, **kwargs): # real signature unknown
            """
            Remove an element from a set; it must be a member.
             
            If the element is not a member, raise a KeyError. 移除指定元素，不存在保错
            """
            pass
     
        def symmetric_difference(self, *args, **kwargs): # real signature unknown
            """
            Return the symmetric difference of two sets as a new set.  对称差集
             
            (i.e. all elements that are in exactly one of the sets.)
            """
            pass
     
        def symmetric_difference_update(self, *args, **kwargs): # real signature unknown
            """ Update a set with the symmetric difference of itself and another. 对称差集，并更新到a中 """
            pass
     
        def union(self, *args, **kwargs): # real signature unknown
            """
            Return the union of sets as a new set.  并集
             
            (i.e. all elements that are in either set.)
            """
            pass
     
        def update(self, *args, **kwargs): # real signature unknown
            """ Update a set with the union of itself and others. 更新 """
            pass

    练习：寻找差异

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    # 数据库中原有
    old_dict = {
        "#1":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 },
        "#2":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 }
        "#3":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 }
    }
       
    # cmdb 新汇报的数据
    new_dict = {
        "#1":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 800 },
        "#3":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 }
        "#4":{ 'hostname':c2, 'cpu_count': 2, 'mem_capicity': 80 }
    }

    需要删除：？
    需要新建：？
    需要更新：？
    注意：无需考虑内部元素是否改变，只要原来存在，新汇报也存在，就是需要更新

    深浅拷贝

    一、数字和字符串

    对于 数字 和 字符串 而言，赋值、浅拷贝和深拷贝无意义，因为其永远指向同一个内存地址。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    import copy
    # ######### 数字、字符串 #########
    n1 = 123
    # n1 = "i am alex age 10"
    print(id(n1))
    # ## 赋值 ##
    n2 = n1
    print(id(n2))
    # ## 浅拷贝 ##
    n2 = copy.copy(n1)
    print(id(n2))
      
    # ## 深拷贝 ##
    n3 = copy.deepcopy(n1)
    print(id(n3))

    二、其他基本数据类型

    对于字典、元祖、列表 而言，进行赋值、浅拷贝和深拷贝时，其内存地址的变化是不同的。

    1、赋值

    赋值，只是创建一个变量，该变量指向原来内存地址，如：

    1
    2
    3
    n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
      
    n2 = n1

    　　

    2、浅拷贝

    浅拷贝，在内存中只额外创建第一层数据

    1
    2
    3
    4
    5
    import copy
      
    n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
      
    n3 = copy.copy(n1)

    3、深拷贝

    深拷贝，在内存中将所有的数据重新创建一份（排除最后一层，即：python内部对字符串和数字的优化）

    1
    2
    3
    4
    5
    import copy
      
    n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
      
    n4 = copy.deepcopy(n1)

    函数

    一、背景

    在学习函数之前，一直遵循：面向过程编程，即：根据业务逻辑从上到下实现功能，其往往用一长段代码来实现指定功能，开发过程中最常见的操作就是粘贴复制，也就是将之前实现的代码块复制到现需功能处，如下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    while True：
        if cpu利用率 > 90%:
            #发送邮件提醒
            连接邮箱服务器
            发送邮件
            关闭连接
        
        if 硬盘使用空间 > 90%:
            #发送邮件提醒
            连接邮箱服务器
            发送邮件
            关闭连接
        
        if 内存占用 > 80%:
            #发送邮件提醒
            连接邮箱服务器
            发送邮件
            关闭连接

    腚眼一看上述代码，if条件语句下的内容可以被提取出来公用，如下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    def 发送邮件(内容)
        #发送邮件提醒
        连接邮箱服务器
        发送邮件
        关闭连接
        
    while True：
        
        if cpu利用率 > 90%:
            发送邮件('CPU报警')
        
        if 硬盘使用空间 > 90%:
            发送邮件('硬盘报警')
        
        if 内存占用 > 80%:

    对于上述的两种实现方式，第二次必然比第一次的重用性和可读性要好，其实这就是函数式编程和面向过程编程的区别：

    • 函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
    • 面向对象：对函数进行分类和封装，让开发“更快更好更强...”

    函数式编程最重要的是增强代码的重用性和可读性

    二、定义和使用

    1
    2
    3
    4
    5
    6
    def 函数名(参数):
           
        ...
        函数体
        ...
        返回值

    函数的定义主要有如下要点：

    • def：表示函数的关键字
    • 函数名：函数的名称，日后根据函数名调用函数
    • 函数体：函数中进行一系列的逻辑计算，如：发送邮件、计算出 [11,22,38,888,2]中的最大数等...
    • 参数：为函数体提供数据
    • 返回值：当函数执行完毕后，可以给调用者返回数据。

    1、返回值

    函数是一个功能块，该功能到底执行成功与否，需要通过返回值来告知调用者。

    以上要点中，比较重要有参数和返回值：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    def 发送短信():
           
        发送短信的代码...
       
        if 发送成功:
            return True
        else:
            return False
       
       
    while True:
           
        # 每次执行发送短信函数，都会将返回值自动赋值给result
        # 之后，可以根据result来写日志，或重发等操作
       
        result = 发送短信()
        if result == False:
            记录日志，短信发送失败...

    2、参数

    为什么要有参数？

    无参数实现
    有参数实现

    函数的有三中不同的参数：

    • 普通参数
    • 默认参数
    • 动态参数
    普通参数
    默认参数
    动态参数
    动态参数
    动态参数

    扩展：发送邮件实例

    发送邮件实例

    内置函数

    　　

    注：查看详细猛击这里

    open函数，该函数用于文件处理

    操作文件时，一般需要经历如下步骤：

    • 打开文件
    • 操作文件

    一、打开文件

    1
    文件句柄 = open('文件路径', '模式')

    打开文件时，需要指定文件路径和以何等方式打开文件，打开后，即可获取该文件句柄，日后通过此文件句柄对该文件操作。

    打开文件的模式有：

    • r ，只读模式【默认】
    • w，只写模式【不可读；不存在则创建；存在则清空内容；】
    • x， 只写模式【不可读；不存在则创建，存在则报错】
    • a， 追加模式【可读；   不存在则创建；存在则只追加内容；】

    "+" 表示可以同时读写某个文件

    • r+， 读写【可读，可写】
    • w+，写读【可读，可写】
    • x+ ，写读【可读，可写】
    • a+， 写读【可读，可写】

     "b"表示以字节的方式操作

    • rb  或 r+b
    • wb 或 w+b
    • xb 或 w+b
    • ab 或 a+b

     注：以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型

    二、操作

    2.x
    3.x

    三、管理上下文

    为了避免打开文件后忘记关闭，可以通过管理上下文，即：

    1
    2
    3
    with open('log','r') as f:
            
        ...

    如此方式，当with代码块执行完毕时，内部会自动关闭并释放文件资源。

    在Python 2.7 及以后，with又支持同时对多个文件的上下文进行管理，即：

    1
    2
    with open('log1') as obj1, open('log2') as obj2:
        pass

    lambda表达式

    学习条件运算时，对于简单的 if else 语句，可以使用三元运算来表示，即：

    1
    2
    3
    4
    5
    6
    7
    8
    # 普通条件语句
    if 1 == 1:
        name = 'wupeiqi'
    else:
        name = 'alex'
        
    # 三元运算
    name = 'wupeiqi' if 1 == 1 else 'alex'

    对于简单的函数，也存在一种简便的表示方式，即：lambda表达式

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    # ###################### 普通函数 ######################
    # 定义函数（普通方式）
    def func(arg):
        return arg + 1
        
    # 执行函数
    result = func(123)
        
    # ###################### lambda ######################
        
    # 定义函数（lambda表达式）
    my_lambda = lambda arg : arg + 1
        
    # 执行函数
    result = my_lambda(123)

    递归

    利用函数编写如下数列：

    斐波那契数列指的是这样一个数列 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946，17711，28657，46368...

    1
    2
    3
    4
    5
    6
    7
    8
    def func(arg1,arg2):
        if arg1 == 0:
            print arg1, arg2
        arg3 = arg1 + arg2
        print arg3
        func(arg2, arg3)
      
    func(0,1)

    练习题

    1、简述普通参数、指定参数、默认参数、动态参数的区别

    2、写函数，计算传入字符串中【数字】、【字母】、【空格] 以及 【其他】的个数

    3、写函数，判断用户传入的对象（字符串、列表、元组）长度是否大于5。

    4、写函数，检查用户传入的对象（字符串、列表、元组）的每一个元素是否含有空内容。

    5、写函数，检查传入列表的长度，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。

    6、写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其作为新列表返回给调用者。

    7、写函数，检查传入字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。

    1
    2
    3
    dic = {"k1": "v1v1", "k2": [11,22,33,44]}
     
    PS:字典中的value只能是字符串或列表

    8、写函数，利用递归获取斐波那契数列中的第 10 个数，并将该值返回给调用者。
  • 相关阅读:
    日区 Apple ID共享
    强大的视频跨平台视频处理软件
    百度网盘无限速
    App Store看片神器,请收好
    bootstrap 中这段代码 使bundles 失败
    C# EF中调用 存储过程并调回参数
    mvc 默认访问 Area 下控制器方法
    怎样用SQL语句查看查询的性能指标
    slice 定义和用法
    C# Regex类用法
  • 原文地址：https://www.cnblogs.com/maozhr/p/5840698.html
Copyright © 2011-2022 走看看