Python初学者入门

 最近在接触python，感觉python之所以开发效率高，可能有三个因素：

1、语言表达能力强悍。

2、支持很多高级的语言特性。

3、第三方开源库非常的丰富。

两本不错的书：

《Python参考手册》：对Python各个标准模块，特性介绍的比较详细。

《Python核心编程》：介绍的比较深入，关键是，对Python很多高级特性都有介绍。

一个开源代码：openstack，关于云计算的，用Python写的，可以重点学习一下。

套接字编程：

1、  函数的功能基本和c类似，唯一不同的地方在于当发生错误时，它不是通过返回值来告知的，而是通过触发异常，所以udp中的bind,>3、  获取网卡的IP：   

s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

return>

内建函数：

string.capitalize()

 把字符串的第一个字符大写

string.center(width)

 返回一个原字符串居中,并使用空格填充至长度 width 的新串

string.count(str,>

 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指返回指定范围内 str 出现的次数

string.decode(encoding='UTF-8',>

   以 encoding 指定的编码格式解码 string，如果出错默认报ValueError 的异常，除非 errors 指定的是'ignore'或'replace'

string.encode(encoding='UTF-8',>

  以 encoding 指定的编码格式编码 string，如果出错默认报ValueError的异常， 除非errors指定的是'ignore'或者'repl

string.endswith(obj,>

检查字符串是否以 obj 结束，如果 beg 或者 end 指定则检定的范围内是否以 obj 结束， 如果是， 返回True,否则返回Fa

string.expandtabs(tabsize=8)

把字符串 string 中的 tab 符号转为空格， 默认格数 tabsize 是 8.

string.find(str,>

   检测 str 是否包含在 string 中，如果 beg 和 end 指定范则检查是否包含在指定范围内，如果是返回开始的索引值，返回-1

string.index(str,>

    跟find()方法一样， 只不过如果str不在string中会报一个异

string.isalnum()

a, b, c  R如果string至少有一个字符并且所有字符都是字母或数字回 True,否则返回 False

string.isalpha()

a, b, c  如果string至少有一个字符并且所有字符都是字母则返回T否则返回 False

string.isdecimal()

b, c, d 如果 string 只包含十进制数字则返回 True 否则返回 False.

string.isdigit()

b, c 如果 string 只包含数字则返回 True 否则返回 False.

string.islower()

b, c 如果 string 中包含至少一个区分大小写的字符，并且所有这些(大小写的)字符都是小写，则返回 True，否则返回 False

string.isnumeric()

b, c, d 如果 string 中只包含数字字符，则返回 True，否则返回 False

string.isspace()

b, c 如果 string 中只包含空格，则返回 True，否则返回 False.

string.istitle()

b, c 如果 string 是标题化的(见 title())则返回 True，否则返回 False

string.isupper()

b, c 如果 string 中包含至少一个区分大小写的字符， 并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False

string.join(seq)

 Merges (concatenates)以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串

string.ljust(width)

返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串

string.lower()

 转换 string 中所有大写字符为小写.   

string.lstrip()

  截掉 string 左边的空格

string.partition(str)

e 有点像>

string.replace(str1,>

把 string 中的 str1 替换成 str2,如果 num 指定，        则替换不超过 num 次.

string.rfind(str,>

类似于 find()函数，不过是从右边开始查找.

string.rindex( str,>

    类似于 index()， 不过是从右边开始.

string.rjust(width)

返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串

string.rpartition(str)

e  类似于 partition()函数,不过是从右边开始查找.

string.rstrip()

  删除 string 字符串末尾的空格.

string.split(str="",>

  以 str 为分隔符切片 string，如果 num有指定值，则仅分隔 num 个子字符串

string.splitlines(num=string.count('\n'))

b, c按照行分隔， 返回一个包含各行作为元素的列表， 如果 num 指定则仅切片 num 个行.

string.startswith(obj,>

b, e检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查.

string.strip([obj])

  在 string 上执行 lstrip()和 rstrip()

string.swapcase()

  翻转 string 中的大小写

string.title()

b, c   返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())

string.translate(str,>

  根据str给出的表(包含256个字符)转换string的字符,要过滤掉的字符放到 del 参数中

string.upper()

 转换 string 中的小写字母为大写

string.zfill(width)

  返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0

函数的使用：

1、  函数的作用域：函数中定义一个变量，如果和全局变量重名，则全局变量名称就会被覆盖，也就是，这里对这个变量的更改，不会更改全局变量。但是，如果直接使用的话，是会使用全局变量的。同时，如果想要修改全局变量，需要制定是全局变量：global a

2、  xrange用法和range一样，不过更为高效，因为他不会在内存中创建列表。所以，它只能用于循环。

3、  如果函数没有return语句，则他的返回值为None。

4、  关于函数的入参判断：如果如此为空，可能会发生异常。当异常发生后，可能会出现一种情况，一个事情做到了一半，就没有在进行下去，可能会造成内存泄露。这个问题如何解决？按照C的方式，每个入参都做判断是可以解决的，但是这样太麻烦了。而且看很多开源代码页没有这样来做。是不是有更好的方法？换一种思路，在调用之前确保不为空。在看看开源的代码是怎么做的。特别是openstack。

闭包的使用：

1、  将组成函数的语句和语句的执行环境打包在一起形成的对象，成为闭包。

2、  2.7之前的闭包不支持关键字nonlocal。3.0之后才支持。所以2.7前的闭包不可以使用nonlocal。

3、  这样他就不可以对执行环境中的变量进行更改。 

字典的使用：

1、  字典的删除：直接使用del dict[k]可能会引发异常；首先判断k是否存在则效率有些低；使用异常使程序结构看起来不好。一个好的方法是pop(k, default v)。这个删除一个k项，并且返回。如果不存在返回默认的v。如果不加默认值，则会引发异常。

2、  直接使用字典下标获取字典的值可能会引发一场。使用get方法则不会，如果不存在会返回none。另外，还可以设置不存在的默认值。

3、  通过字典格式化字符串：print “value is %(key)s” % kvdict

4、  item方法返回一个列表，列表中的元素是一个元组，第一个是key，第二个是value。比较好用的方法。

5、  iteritem:返回的是一个迭代器。如果想要迭代这个字典，iteritem会比item更高效一点。

6、  iterkeys则返回的是key的迭代器。keys返回的是key的list。

7、  values返回值的列表，itervalues返回的是vlaue的迭代器

8、  popitem会随机弹出（同时删除）一个项，则对于想要处理所有的元素，并且删除所有的元素是有帮助的。但是，如果没用元素的话，会抛出异常。

9、  viewitems，viewkeys，viewvalues：这三个函数返回的是一个view对象。这个类似于视图。分别表示（key, value）pair的列表，key的列表，value的列表。一个优点是，如果字典发生变化，view会同步发生变化。在迭代过程中，字典不允许改变，否则会报异常。

10、  

 

列表的使用：

1、  列表的删除：不可以在遍历的过程中删除链表，这样会得到不可预知的后果。可以使用列表的过滤，来获得新的列表。

2、  列表的过滤：

        def filterFun(node):#这个函数做了两个事情哎。

            node.cycleCount = node.cycleCount -1

            return node.cycleCount < 0

        timeoutList =>kvlist = map(lambda x,y:x+y, [1,2,3], [4,5,6])

如果函数为None，则相当于函数zip：

zip([1,2,3],[4,5,6])

[(1,4),(2,5),(3,6)]

4、  生成器表达式：l = [node>

5、  print(reduce(lambda x,y: x*y, [2 for x in xrange(38)]))

上面的这个语句是计算2的38次方的值。它用到的是二元函数reduce。它第一次调用是将第一个和第二个元素做入参，后面用他们的结果做x，新的元素做y，最后返回值。

另外，在获取一个38个2的列表也可以使用：[2] * 38。这可能更可读一点。

6、  enumerate:对列表处理，返回的是列表的索引以及节点。

        for index, node in enumerate(timerList):

            if timerId == node.timerId and timerEvent ==node.timerEvent:

               >

5、 >

3、   

OO的使用：

1、  如果不想让成员变量或者方法被外部使用（也就是private特性），可以以__双下划线开通。

2、  Python也可以实现抽象基类，也就是接口：

 

 

3、  __str__属性可以将对象转换为字符串，也就是调用print(object)是会打印的字符串。

4、  __call__(魔法方法)可以将对象作为函数来调用。给它一个入参就可以。:

    def __call__(self, protoVer):

        return api.protoModules[protoVer].TimeTicks(

            (time.time()-self.birthday)*100

            )

5、  对象实例是否可以删除？

6、  Python参考手册要好好看一下。

7、  python的static方法使用的是装饰器语法：@staticmethod.

模块的使用：

1、  如果不想将模块的某些函数和变量被别的模块使用，可以以单下划线开头。这样import *是没有的，但是使用importmode，然后mode._fun仍然可以调用。在class中是以双下划线开头的。

2、   

日志的使用：

1、  日志的标准模块logging基本可以满足我的工作。

2、  设置log的初始化工作：

logging.basicConfig(

    filename = "test.log",

    format = "[%(asctime)s-%(levelname)s] %(message)s[%(filename)s,%(lineno)d]",

    level = logging.INFO,

   >"%F %T")

3、  除此之外，一个比较强大的功能就是过滤功能：可以针对级别，文件，行号等等很多的东西进行过滤。

4、   

自省的使用：

1、  type()可以查看对象的类型。这就是自省。也就是可以看看自己是什么类型。这个功能在动态语言中非常有用。

2、  getattr函数：这是个非常有用的函数，它可以根据字符串，从模块，类，对象实例中获取属性和方法的应用并且调用。这个功能非常类似于c语言的函数指针，以及c++中的成员函数的指针。

1）从模块中获取函数和成员

import testfun

tf = getattr(testfun, 'test')

tstr = getattr(testfun, 'str')

2）从类中获取属性和方法

class test():

    tst = 2

        def __init__(self):

        self.abc = 1

      def method(self):

        print('in test.method', self)

      def __test(self):

        print('in test')

tm = getattr(test, 'method’)#获取类方法method函数指针。因为没有实例，所以调用必须用下面的方法：

t =test()

tm(t)#申请一个实例，并且作为第一个参数传进去。

tm =>'abc’)#这是错误的。无法获取。

ttst = getattr(test, 'tst’)#这是可以的。。

3）从对象实例中获取属性和方法

t =test()

tm = getattr(t, 'method')

 tm()#可以这样调用，而不用传入t实例。

tabc =>

4、  自省也叫放射。

5、  exec(‘code’)：可以执行代码

配置文件读取的使用：

1、  使用模块ConfigParser。实例如下：

conf = ConfigParser()

conf.read("snmp_agent.ini")

print(conf.get("main", "log_level"))

print(conf.getint("main", "ne_agent_port"))

print(conf.get("main", "ne_agent_qip"))

异常的使用：

1、  尽量少用。它会使程序难以理解，而且还会发生不可预知的情况，比如异常的发生使程序的状态变为一个未知状态。

2、  可以寻找替代方案。

3、  程序非常重要，不可以停止，可以在主循环包装在异常处理中运行。

4、  打印出异常的信息，供后面的定位：log.error(traceback.format_exc())

类型系统

1、  类型也是对象。比如：inttype =>

2、  另外，是否可以把字符串转化为关键字，或者对象？比如，一个变量，abc,是否可以通过’abc’来引用？

文件的使用

1、  打开使用函数open，模式和linux>

for>

s.decode(fromcodec).encode(tocodec)

也可以直接使用：s.encode(tocodec)。这个时候，相当于默认调用了decode，并且使用的是默认的编码方式。

其他：

1、  脚本语言的进程名称显示为：python ，如果一个服务器上有多个进程，那么将不易发现那个进程是哪个程序。可以使用第三方开源的库来解决这个问题：setproctitle.

from setproctitle import setproctitle,getproctitle

print('当前的进程名：%s' % getproctitle())

setproctitle('proctitle')

print('设置后的的进程名：%s' % getproctitle())