python基础晋级篇

Python开发【第四篇】：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 个数，并将该值返回给调用者。

 

转载于:https://www.cnblogs.com/zl-py/p/5537633.html