My way to Python - Day03

列表和字典的赋值

 dict1 = {}
 dict1['k1'] = 'v1'

 list1 = []
 list1.append('v1')

---

集合系列

1，计数器

 Python 2.7.6 (default, Mar 22 2014, 22:59:56)
 [GCC 4.8.2] on linux2
 Type "help", "copyright", "credits" or "license" for more information.
 >>> import collections
 >>> c1 = collections.Counter()
 >>> str1 = 'fujafksabfaskfjaslfl jshjfkk fhsfj hfajsjfsk fj'
 >>> c1 = collections.Counter(str1)
 >>> c1  # 对于字符串操作的结果是：为每个出现的字符计数
 Counter({'f': 11, 'j': 8, 's': 7, 'a': 5, 'k': 5, ' ': 4, 'h': 3, 'l': 2, 'b': 1, 'u': 1})
 >>> list1 = [11,22,22,33,33,33,44,44,44,44]
 >>> c1 = collections.Counter(list1)
 >>> c1  # 对于列表操作的结果是：为每个出现的元素计数
 Counter({44: 4, 33: 3, 22: 2, 11: 1})
 >>> 

---

2，有序字典 orderedDict

     有序字典在使用上跟普通字典是一样的，只是在内部实现的数据结构上有所区别。

     有序字典在内部实现了一个列表，用来存储字典的key；由于列表是有序的，所以字典也就变为有序了。

     因此有序字典可以通过key的下标进行取值。

     orderedDict也可以做嵌套。

---

3，默认字典 defaultdict

     为字典里的value设置默认的类型

# 1，普通字典的方式

 dic ={}
 dic = {'k1':[]}      # → 这两行等同于下例中的一行(#←)
 dic['k1'].append(1)  # → 这两行等同于下例中的一行(#←)

---

# 2，默认字典的方式

 from collections import defaultdict
 dic = collections.defaultdict(list)   # ←
 dic['k1'].append(1)

---

默认字典操作样例：

 >>> from collections import defaultdict  # 使用默认字典，需要先导入defaultdict
 >>> dic = {}
 >>> dic = collections.defaultdict(list)  # 创建一个默认字典对象，把字典的value的默认类型置为列表
 >>> dic['k1'].append(1) # 向字典中添加一个key k1<list类型>，并向k1中append一个元素1
 >>> dic
 defaultdict(<type 'list'>, {'k1': [1]})
 >>>
 >>> dic1 = {'k1':1}
 >>> dic1
 {'k1': 1}
 >>>
 >>> dic1 = collections.defaultdict(list)
 >>> dic1
 defaultdict(<type 'list'>, {})
 >>>
 >>> dic1.append(22)  # 直接对dict1做append操作会报错，因为字典不能通过append进行赋值
 Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
 AttributeError: 'collections.defaultdict' object has no attribute 'append'
 >>> dic1['k2'].append(22)  # 可以对默认字典中的列表元素做append操作
 >>> dic1
 defaultdict(<type 'list'>, {'k2': [22]})
 >>> 

---

可命名的元组

使用步骤：

     1，创建类

     2，使用类创建对象

     3，使用对象

---

 >>> Mytuple = collections.namedtuple('Mytuple',['x','y'])
 >>>
 >>> n = Mytuple(x=1,y=2)
 >>> n.x
 1
 >>> n.y
 2
 >>>

---

help(Mytuple)

  Help on class Mytuple in module __main__:

  class Mytuple(__builtin__.tuple)
   |  Mytuple(x, y)
   |
   |  Method resolution order:
   |      Mytuple
   |      __builtin__.tuple
   |      __builtin__.object
   |
   |  Methods defined here:
   |
   |  __getnewargs__(self)
   |      Return self as a plain tuple.  Used by copy and pickle.
   |
   |  __getstate__(self)
   |      Exclude the OrderedDict from pickling
   |
   |  __repr__(self)
   |      Return a nicely formatted representation string
   |
   |  _asdict(self)
   |      Return a new OrderedDict which maps field names to their values
   |
   |  _replace(_self, **kwds)
   |      Return a new Mytuple object replacing specified fields with new values
   |
   |  ----------------------------------------------------------------------
   |  Class methods defined here:
   |
   |  _make(cls, iterable, new=<built-in method __new__ of type object>, len=<built-in function len>) from __builtin__.type
   |      Make a new Mytuple object from a sequence or iterable
   |
   |  ----------------------------------------------------------------------
   |  Static methods defined here:
   |
   |  __new__(_cls, x, y)
   |      Create new instance of Mytuple(x, y)
   |
   |  ----------------------------------------------------------------------
   |  Data descriptors defined here:
   |
   |  __dict__
   |      Return a new OrderedDict which maps field names to their values
   |
   |  x
   |      Alias for field number 0
   |
   |  y
   |      Alias for field number 1
   |
   |  ----------------------------------------------------------------------
   |  Data and other attributes defined here:
   |
   |  _fields = ('x', 'y')
   |
   |  ----------------------------------------------------------------------
   |  Methods inherited from __builtin__.tuple:
   |
   |  __add__(...)
   |      x.__add__(y) <==> x+y
   |
   |  __contains__(...)
   |      x.__contains__(y) <==> y in x
   |
   |  __eq__(...)
   |      x.__eq__(y) <==> x==y
   |
   |  __ge__(...)
   |      x.__ge__(y) <==> x>=y
   |
   |  __getattribute__(...)
   |      x.__getattribute__('name') <==> x.name
   |
   |  __getitem__(...)
   |      x.__getitem__(y) <==> x[y]
   |
   |  __getslice__(...)
   |      x.__getslice__(i, j) <==> x[i:j]
   |
   |      Use of negative indices is not supported.
   |
   |  __gt__(...)
   |      x.__gt__(y) <==> x>y
   |
   |  __hash__(...)
   |      x.__hash__() <==> hash(x)
   |
   |  __iter__(...)
   |      x.__iter__() <==> iter(x)
   |
   |  __le__(...)
   |      x.__le__(y) <==> x<=y
   |
   |  __len__(...)
   |      x.__len__() <==> len(x)
   |
   |  __lt__(...)
   |      x.__lt__(y) <==> x<y
   |
   |  __mul__(...)
   |      x.__mul__(n) <==> x*n
   |
   |  __ne__(...)
   |      x.__ne__(y) <==> x!=y
   |
   |  __rmul__(...)
   |      x.__rmul__(n) <==> n*x
   |
   |  __sizeof__(...)
   |      T.__sizeof__() -- size of T in memory, in bytes
   |
   |  count(...)
   |      T.count(value) -> integer -- return number of occurrences of value
   |
   |  index(...)
   |      T.index(value, [start, [stop]]) -> integer -- return first index of value.
   |      Raises ValueError if the value is not present.
  (END)

---

双向队列：deque

     双向队列可以在队列的两端进行读取和插入

     是线程安全的

---

 >>> import collections
 >>> q = collections.deque()
 >>> q.append(1)
 >>> q.append(2)
 >>> q.append(3)
 >>> q.append(4)
 >>>
 >>> q
 deque([1, 2, 3, 4])
 >>> q.pop()
 4
 >>> q
 deque([1, 2, 3])
 >>> q.popleft()    # 此处要注意，是popleft而非leftpop
 1
 >>> q
 deque([2, 3])
 >>>
 >>> q.appendleft(5)
 >>> q
 deque([5, 2, 3])
 >>>

---

单向队列（不是collections系列的模块，属于Queue系列）：

也是一个线程安全的数据结构

 >>> import Queue
 >>>
 >>> q = Queue.Queue(10)
 >>>
 >>> q.put(1)
 >>> q.put(2)
 >>> q.put(3)
 >>> q
 <Queue.Queue instance at 0x7f3975f505a8>
 # 此处返回的是这个对象实例的内存地址
 # 之所以没有返回队列中所有的元素是因为
 # 在Queue的类的定义中没有实现__str__的方法。
 >>> q.get()
 1
 >>> q.get()
 2
 >>> q.get()
 3
 >>> q.get() # 此时队列里已经没有元素了，再get则会hang住。

 ^C^C

注意：在get时，如果过队列里面没有数据的时候，线程会hang住。

---

迭代器

     ① 创建一个类

     ② 类中需要实现next方法，用来判断是否有下一条数据。

---

 >>> dir(list)
 ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
 >>>
 >>> help(list.__iter__)

 Help on wrapper_descriptor:

 __iter__(...)
     x.__iter__() <==> iter(x)
 (END)

---

# 打印列表的2种方法：

 # 方法1
 >>> li = [11,22,33,44,55,66]
 >>> for i in li:
 ...     print i
 ...
 11
 22
 33
 44
 55
 66
 >>>
 # 方法2
 >>> li = [11,22,33,44,55,66]
 >>> for i in range(len(li)):
 ...     print li[i]
 ...
 11
 22
 33
 44
 55
 66
 >>>

---

生成器：

例子：

 >>>
 >>> range(10)
 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 >>>
 >>> xrange(10)
 xrange(10)
 >>> 

辅助理解的类比：

数据库的连接池的概念，连接池就可以使用生成器来做。

生成器的思想：先返回对象，不会直接在内存中创建。

 

上例中的range会直接在内存中创建对象，xrange不会立刻创建。

---

冒泡排序算法：

 # 基于range的冒泡排序算法
 li = [13, 22, 6, 99, 11]

 for m in range(len(li)-1):

     for n in range(m+1, len(li)):
         if li[m]> li[n]:
             temp = li[n]
             li[n] = li[m]
             li[m] = temp

 print li

---

函数（代码块）

     按功能划分的代码块

函数的分类：

     内置函数

     自定义函数

     导入函数

---

内置函数

---

help()

dir()

vars() # 当前模块的所有变量

    __file__

    __doc__

               文件顶部用三引号做的注释就是程序的__doc__

    __name__

 

     被执行的脚本文件的__name__的值为__main__

type() # 类型

id() #显示内存地址 

is # 比较内存地址

---

---

在vars里面inportvar01

var01里面的代码会直接执行，因此在后面写代码的时候都要写成函数，不允许有可以被直接执行的代码。

---

cmp(2,3)

divmod(10,3) # 商和余数，用户页面分页

max()

min()

sum()

power(2,11)

---

len()

all() # 接受一个序列，判断，所有值都是真，返回真，否则为假。

        # eg：可以用来判断用户输入值的判定

any() #接受一个序列，判断，所有值都是假，返回假；只要有一个值为真，返回真。

---

all，any的简单样例：

 >>> li = ['stephen','',25]
 >>> all(li)
 False
 >>> any(li)
 True
 >>>
 >>> li = ['stephen','password',25]
 >>> all(li)
 True
 >>> any(li)
 True
 >>>
 >>> li = ['']
 >>> all(li)
 False
 >>> any(li)
 False
 >>>
 >>> 

---

ASCII码数字对照表

     ord # 字符到数字

     chr # 数字到字符

---

进制转换

     hex()

     oct()

     bin()

---

枚举类型：enumbrare

---

 >>> li =  [11,22,33,44,55,66]
 >>> for k,v in enumerate(li):
 ...     print k,v
 ...
 0 11
 1 22
 2 33
 3 44
 4 55
 5 66
 >>>
 >>> for k,v in enumerate(li,1):
 ...     print k,v
 ...
 1 11
 2 22
 3 33
 4 44
 5 55
 6 66
 >>>
 >>> 

---

map等内置函数。。。

---

函数

第一个函数(简易报警程序)：

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 __author__ = 'Stephen'

 def email(arg):
 #print arg

 if __name__ == '__main__':
 cpu = 99
 ram = 50
 disk = 95

 for i in range(1):
     if cpu > 90:
         alert = 'cpu is ERROR'
         email(alert)
     if ram > 90:
         alert = 'memory is ERROR'
         email(alert)
     if disk > 90:
         alert = 'disk is ERROR'
         email(alert)

程序运行结果：

C:\Python27\python.exe G:/python/day03/def_function.py
cpu is ERROR
disk is ERROR

Process finished with exit code 0

修改为smtp的方式

---

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 __author__ = 'Stephen'

 import smtplib
 from email.mime.text import MIMEText
 from email.utils import formataddr

 def email(arg): # 此处的arg为形式参数，简称形参。不赋值的时候没有实际意义。
     msg = MIMEText('邮件内容', 'plain', 'utf-8')
     msg['From'] = formataddr(["Stephen",'xxx@126.com'])
     msg['To'] = formataddr(["thatsit",'xxx@qq.com'])
     msg['Subject'] = "监控报警邮件"

     server = smtplib.SMTP("smtp.126.com", 25)
     server.login("mail-address@126.com", "PASSWORD")
     server.sendmail('xxx@126.com', ['xxx@qq.com',], msg.as_string())
     server.quit()

 if __name__ == '__main__':
     cpu = 99
     ram = 50
     disk = 95

     for i  in  range(10):
         if cpu > 90:
             alert = 'cpu is ERROR 第%d次' %i
             email(alert) # 此处的alert在赋值之后就是实际参数。
         if ram > 90:
             alert = 'memory is ERROR 第%d次' %i
             email(alert)
         if disk > 90:
             alert = 'disk is ERROR 第%d次' %i
             email(alert)

---

函数小结：

     1，def关键字定义函数

     2，函数名，日后调用函数使用

     3，函数声明，不自动执行；调用后才执行

     4，函数的参数

          ① 普通参数

          ② 默认参数

          ③ 动态参数

 

     5，函数的返回值

          ① 如果一个函数不定义明确的返回值(return)，返回值为None。

          ② 返回值可以赋值给某个变量

---

动态参数详解：     

               # 参数可以有N个，传入指定个数的参数。

               # 默认参数可以有多个，但是需要放到参数列表的最后。

               # def func(*args)

               # 内部自动构造元组

               # 传序列时，可以使用*号防止内部构造元组

 

---

动态参数2：

 def func(**kwargs):
      print kwargs

 func (k1=123,k2='sss')

 dic = {k1:123,k2:234}
 func (**dic)

---

文件操作：

文件操作(分为两个步骤:打开文件,操作文件)
      文件打开方式：(#涉及到python升级的原因，推荐使用open的方式打开文件)
          ① obj = file('文件路径','打开模式')
          ② obj = open('文件路径','打开模式')       

 r,只读
 w,清空原文件写
 a,可读,可写,只能以追加的方式写

 r+,可读可写
 w+ <==> w
 a+ <==> a

---

文件指针操作样例

1 obj = open('log.txt','r') # 打开文件
2 obj.seek(5)       # 指定文件的指针
3 print obj.tell()  # 显示文件指针
4 obj.read()        # 将文件全部加载到内存，此时的文件指针已经到了文件的尾部
5 print obj.tell()  # 显示文件指针

执行结果：

C:\Python27\python.exe G:/python/day03/func.py
5
24

Process finished with exit code 0

---

文件其他操作

 truncate() # 根据当前指针的位置截断数据，截断位置也可以使用参数指定。
            # eg：truncate(5)

 b   # 二进制，在linux没有什么卵用，在跨平台的时候要用。
 rU  # U参数只能跟r结合。写法有rU和r+U两种。
     # 用来处理不同平台的换行符的问题：处理不同平台的换行符的问题：(\n,\r,\r\n)。

 托管资源：手动进行释放，在python中才有，用于同时打开同一个文件。
 非托管资源：

 closed() #关闭文件
 flush()  # 会把应用缓存写到系统缓存中，但是不一定会直接写到磁盘，依赖于系统机制

 open()         #打开文件：
 next()         # 取下一行，不存在会报错。
 write()        # 写文件
 writelines()   # 参数可以是一个列表
 xreadlines()   # 逐行读取文件
 for line in f: # 用来替换for line in f.xreadlines()

with关键字，用来做上下文管理。并且with在python2.7之后支持同时打开多个配置文件。

 obj = open('log','r')
 with open('log','r') as obj: