Python开发【第四篇】：Python基础之函数

佚名 6年前 (2019-04-11) 随笔 1552人围观抢沙发百度已收录

三元运算

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

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

基本数据类型补充

set

SRE实战互联网时代守护先锋，助力企业售后服务体系运筹帷幄！一键直达领取阿里云限量特价优惠。

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 )