python 学习笔记day02-pyt

循环语句

    while 循环

        while 循环语法结构

            当需要语句不断的重复执行时，可以使用 while 循环

                while expression:

                    while_sutie

            语句 while_suite 会被连续不断的循环执行，直到表达式的值变成 0 或 False

        #!/usr/bin/env python
        # -- coding: utf-8 --
        sum100 = 0
        counter = 1
        while counter <=100:
            sum100 +=counter
            counter +=1
        print "result is: %d " % sum100

        break 语句

            break 语句可以结束当前循环然后跳转到下条语句

            写程序时，应尽量避免重复的代码，在这种情况下可以使用 while-break 结构

         name = raw_input('username: ')
         while name != 'tom':
             name = raw_input("username: ")

            可以替换为

        while Ture:
            name = raw_input("username: ")
            if name == 'tom'
                break
        
        #!/usr/bin/env Python
        # --coding: utf-8 --

        while True:
            yn = raw_input("Continue(Y/N)? ")
            # break 作用：当 yn 在 yY 中则跳出 while 循环，即不再执行 print
            if yn in 'yY':
                break
            print 'working....'

        continue 语句

            当遇到continue语句时，程序会终止当前循环，并忽略剩余的语句，然后回到循环的顶端

            如果仍然满足循环条件，循环提内语句继续执行，否则退出循环 

        #!/usr/bin/env python
        # --coding: utf-8 --

        sum100 = 0
        counter = 1
        while counter <= 100:
            counter += 1
            if counter % 2:
                continue
            sum100 += counter
        print "result is: %d " % sum100

        else 语句

            python 中的 while 语句也支持else子句

            else子句只在循环完成后执行

            break语句也会跳过else块

        #!/usr/bin/env python
        # --coding: utf-8 --

        sum10 = 0
        i = 1
        while i <=10:
            sum10 +=1
        else:
            print sum10
插曲：

>>> import WEBbrowser
>>> help(webbrowser)

>>> webbrowser.open_new_tab("Http://www.baidu.com")   #可以打开一个新的网页 
True
>>> webbrowser.open_new_tab("http://192.168.2.100")   # 同上。 
True

>>> import os
>>> os.system('ls /home/qihang/')

刷博客的循环（初级模式）
#!/usr/bin/env python
# --coding: utf-8 --

import webbrowser
import time
import os
url = "http://192.168.1.107"
counter = 0

while counter < 11:
    webbrowser.open_new_tab(url)
    time.sleep(0.5) #睡0.5秒
    counter +=1
    if not counter % 10:
       os.system('killall firefox')

    for 循环

        for 循环语法结构

            python中的for接受可迭代对象（例如序列或迭代器）作为其参数，每次迭代其中一个元素

                for iten_var in iterable:

                      suite_expression

                 >>> for ch in 'abcd':
                ...     print ch
                ...
                a
                b
                c
                d
                >>> for ch in ["hello","wold"]:
                ...     print ch
                ...
                hello
                wold

            与while循环一样，支持break/continue/else 语句

            一般情况下，循环次数未知采用 while 循环，循环次数已知，采用 for 循环

        range 函数

            for循环常与range函数一起使用

            range函数提供循环条件

            range函数的完整语法为：

                range(start,end,step=1)

                    >>> range(5)
                    [0, 1, 2, 3, 4]
                    >>> range(1,5)
                    [1, 2, 3, 4]
                    >>> range(1,5,2)
                    [1, 3]

                    >>> range(10,0,-1)

                    >>> for i in range(3):
                    ...   print "hello world!"
                    ...
                    hello world!
                    hello world!
                    hello world!
                    >>> alist = ['bob','alict','tom','jerry']
                    >>> for i in range(len(alist)):
                    ...   print "%s: %s" %(i,alist[i])
                    ...
                    0: bob
                    1: alict
                    2: tom
                    3: jerry

        xrange 函数

            xrange()类似range(),不过当你有一个很大的范围列表时，xrange()可以更为适合，因为它不会在内存里创建列表的完整拷贝。

            它只被用在for循环中，在for循环外使用它没有意义

            它的性能远高出range()，因为它不生成整个列表

                >>> for x in xrange(3):
                ...   print x
                ...
                0
                1
                2
注意：print x 后面 加“，”，可以不用换行。
斐波那契数列

    1、斐波那契数列就是某一个数，总是前两个数之和，比如0，1，1，2，3，5，8

    2、使用for循环和range()函数编写一个程序，加算有10个数的斐波那契数列

    3、改进程序，要求用户输入一个数字，可以生成用户需要长度的斐波那契数列

        #!/usr/bin/env python
        # --coding: utf-8 --
        num = int(raw_input("number")
        fib = [0,1]
        for i in range(num - 2):
            fib.append(fib[-1] + fib[-2])
        print fib
        一个小练习，使用python来ping 一个网段的主机存活
        #!/usr/bin/env python

        import os

        for i in range(1,255):
            ip = "192.168.1.%s" % i
            result = os.system("ping -c2 %s > /dev/null" % ip)
            if result:
                print "%s: down" %ip
            else:
                print "%s:up" %ip

        列表解析

            它是一个非常有用、简单、而且灵活的工具，可以用来动态地创建列表

            语法：

                [expr for iter_var in iterable]

                >>> ['hello' for i in range(2)]
                     ['hello', 'hello']

                >>> [i for i in range(1,10)]
                    [1, 2, 3, 4, 5, 6, 7, 8, 9]
                    >>> [i ** 2 for i in range(1,10)]
                    [1, 4, 9, 16, 25, 36, 49, 64, 81]

            这个语句的核心是for循环，它迭代iterable对象的所有条目

            expr 应用与序列的每个成员，最后的结果是该表达式产生的列表

文件对象

    文件打开方法

        open及file 内建函数

            作为打开文件之门的“钥匙”，内建函数open()以及file()提供了初始化输入/输出(I/O)操作的通用接口

            成功打开文件后会返回一个文件对象，否则引发一个错误

            open()方法和file()方法可以完全相互替换

            基本语法：

                file_object = open(file_name,access_mode='r',buffering=-1)

            >>> f = open('/etc/hosts')
                >>> f
                <open file '/etc/hosts', mode 'r' at 0xb744e0d0>
                >>> f.read()
                '127.0.0.1\tlocalhost\n127.0.1.1\tqihang-Lenovo-G460\n\n# The following lines are desirable for IPv6 capable hosts\n::1     ip6-localhost ip6-loopback\nfe00::0 ip6-localnet\nff00::0 ip6-mcastprefix\nff02::1 ip6-allnodes\nff02::2 ip6-allrouters\n'

                >>> f.close()
                >>> f = open('/etc/hosts')
                >>> data = f.read()
                >>> print data,
                127.0.0.1    localhost
                127.0.1.1    qihang-Lenovo-G460

                # The following lines are desirable for IPv6 capable hosts
                ::1     ip6-localhost ip6-loopback
                fe00::0 ip6-localnet
                ff00::0 ip6-mcastprefix
                ff02::1 ip6-allnodes
                ff02::2 ip6-allrouters
                >>> f.close()

            文件对象的访问模式：

 文件输入

        read方法

            read（）方法用来直接读取字节到字符串中，最多读取给定数目个字节

            如果没有给定size参数（默认值为-1）或者size值为负，文件将被读取直至末尾

                  >>> data = fobj.read()

                        >>> print data

        readline 方法

            >>> f = open('/etc/hosts')
                >>> f.readline()
                '127.0.0.1\tlocalhost\n'
                >>> f.readline()
                '127.0.1.1\tqihang-Lenovo-G460\n'

                >>> f.close()

        readlines 方法

            >>> f = open('/etc/hosts')
               >>> f.readlines()
               ['127.0.0.1\tlocalhost\n', '127.0.1.1\tqihang-Lenovo-G460\n', '\n', '# The following lines are desirable for IPv6 capable hosts\n', '::1     ip6-localhost ip6-loopback\n', 'fe00::0 ip6-localnet\n', 'ff00::0 ip6-mcastprefix\n', 'ff02::1 ip6-allnodes\n', 'ff02::2 ip6-allrouters\n']

                >>> f.close()

        文件迭代

            如果需要逐行处理文件，可以结合 for 循环迭代文件

            迭代文件的方法与处理其他序列类型的数据类似

            >>> fobj = open("star.py")

            >>> for eachLine in fobj:

            ...    print eachLine,

            >>> f = open("/etc/hosts")
                >>> for line in f:
                ...   print line,
                ...
                127.0.0.1    localhost
                127.0.1.1    qihang-Lenovo-G460

                # The following lines are desirable for IPv6 capable hosts
                ::1     ip6-localhost ip6-loopback
                fe00::0 ip6-localnet
                ff00::0 ip6-mcastprefix
                ff02::1 ip6-allnodes
                ff02::2 ip6-allrouters
                >>> f.close()

    文件输出

        write 方法

            write()内建方法功能与read()和readline()相反。它把含有文本数据或二进制数据块的字符串写入到文件中去

            写入文件时，不会自动添加行结束标志，需要程序员首手工输入

            >>> fobj.write("Hello World!\n"）

>>> f = open('hi.txt','w')
>>> f.read()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IOError: File not open for reading
>>> f.write(30)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: expected a character buffer object
>>> f.write('hello world!')    # f.write('hello world!\n')  加上\n 换行
>>> f.flush()
>>> exit()

>>> f  =open('hi.txt','a')
>>> f.write('new line.\n')
>>> f.close()
>>> exit()

        writelines 方法()列表方式）

                >>> f.writelines(['2rd lines\n','3rd lines\n'])

                >>> f.flush()

                >>> f.close()  

练习：模拟cp操作

    1、创建～/bin/cp.py文件

    2、将/bin/ls "拷贝"到/root目录下

    3、要求读取/bin/ls 后，每次读取4096字节，依次写入到新文件

    4、不要修改原始文件 

#!/usr/bin/env python
# coding: utf-8 --

sfname = '/bin/ls'
dfname = '/root/ls'

src_fobj = open(sfname)
dst_fobj = open(dfname,'w')

while True:
    data = src_fobj.read(4096)
    if not data:
        break
    dst_fobj.write(data)
src_fobj.close()
dst_fobj.close()

比对md5值，检查文件是否完全相同，检查结果为相同。

小插曲：read文件的时候会直接占用内存个

$ free -m
             total       used       free     shared    buffers     cached
Mem:          1941       1713        227         30         56        283
-/+ buffers/cache:       1372        568
Swap:         1972        513       1459

# dd if=/dev/zero of=ttt.img bs=1M count=100

>>> f = open('ttt.img')
>>> data = f.read()

$ free -m
             total       used       free     shared    buffers     cached
Mem:          1941       1812        128         30         56        281
-/+ buffers/cache:       1474        466
Swap:         1972        513       1459
>>> f.close()
>>> del data

$ free -m
             total       used       free     shared    buffers     cached
Mem:          1941       1722        218         30         56        281
-/+ buffers/cache:       1384        556
Swap:         1972        513       1459

函数

    函数基本操作

        函数基本概念

            函数是对程序逻辑进行结构化或过程化的一种编程方法

            将整块代码巧妙地隔离成易于管理的小块

            把重复代码放到函数中而不是进行大量的拷贝，这样既能节省空间，也有助于保持一致性

            通常函数都是用于实现某一种功能

        创建函数

            函数是用def语句来创建的，语法如下：

                def function_name(arguments):

                    "function_documentation_string"

                    function_body_stuite

                #!/usr/bin/env python
                # --coding: utf-8 --
                #define function
                def pstar():
                    print '*' * 20
                    print "#" * 20
                # use function
                pstar()
                prstar()

            标题行由def关键字，函数的名字，以及参数的集合（如果有的话）组成

            def子句的剩余部分包括了一个虽然可选但是强烈推荐的文档字符串，和必须的函数体

        调用函数

            同大多数语言相同，python用一对圆括号调用函数

            如果没有加圆括号，只是对函数的引用

                >>> def foo():

                ...  print "hello"

                ...

                >>> foo()

                hello

                >>> foo

                <function foo at 0x7ff2328967d0>     # 函数在内存中的地址。

        函数的返回值

            多数情况下，函数并不直接输出数据，而是向调用者返回值

            函数的返回值使用return关键字

            没有return的话，函数默认使用None   

                >>> def foo():

                ...    res = 3 + 4

                >>> i = foo()

                >>> print i

                None

    函数参数

        定义参数

            形式参数

                - 函数定义时，紧跟在函数名后（圆括号内）的参数被称为形式参数，简称形参，由于它不是实际存在变量，所以又称虚拟变量

                #!/usr/bin/env python

                def pstar(num):

                       return '*' * num

                n = int(raw_input("number: "))

                print pstar(n)

             实际参数

                - 在主调函数中调用一个函数时，函数名后面括弧中的参数（可以是一个表达式）称为“实际参数”，简称实参

        传递参数

            调用函数时 ，实参的个数需要与形参个数一致

            实参将依次传递给形参

                >>> def foo(x,y):
                ...    print 'x=%d,y=%d' %(x,y)
                ...
                >>> foo()
                Traceback (most recent call last):
                  File "<stdin>", line 1, in <module>
                TypeError: foo() takes exactly 2 arguments (0 given)
                >>> foo(3)
                Traceback (most recent call last):
                  File "<stdin>", line 1, in <module>
                TypeError: foo() takes exactly 2 arguments (1 given)
                >>> foo(3,4)
                x=3,y=4 

        位置参数

            与shell脚本类似，程序名以及参数都以位置参数的方式传递给python  程序

            使用sys模块的argv列表接收

            $ vim args.py
#!/usr/bin/env python
import sys
print sys.argv

            $ python args.py hello world
            ['args.py', 'hello', 'world']

#!/usr/bin/env python
# coding: utf-8 --
import sys

def cp(sfname,dfname):

    src_fobj = open(sfname)
    dst_fobj = open(dfname,'w')

    while True:
        data = src_fobj.read(4096)
        if not data:
            break
        dst_fobj.write(data)
    src_fobj.close()
    dst_fobj.close()

cp(sys.argv[1],sys.argv[2])

          默认参数

            默认参数就是声明了默认值的参数

            因为给参数赋予了默认值，所以在函数调用时，不向该参数传入值也是允许的

                    >>> def pstar(num = 30):
                    ...   print "*" * num
                    ...
                    >>> pstar()
                    ******************************
                    >>> pstar(40)
                    ****************************************
将cp 编程函数形式：

#!/usr/bin/env python
# coding: utf-8 --

def cp(sfname,dfname):

    src_fobj = open(sfname)
    dst_fobj = open(dfname,'w')

    while True:
        data = src_fobj.read(4096)
        if not data:
            break
        dst_fobj.write(data)
    src_fobj.close()
    dst_fobj.close()
cp('/bin/ls','/home/list')
cp('/bin/touch','/home/mytouch')

模块

    定义模块

        模块基本概念

            模块是从逻辑上组织python代码的形式

            当代码量变得相当大的时候，最好把代码分成一些有组织的代码段，前提是保证它们的彼此交互

            这些代码片段相互间有一定的联系，可能是一个包含数据成员和方法的类，也可能是一组相关但彼此独立的操作函数

        创建模块

            模块物理层面上组织模块的方法十文件，每一个以.py作为极为的python文件都是一个模块

            模块名称切记不要与系统中已存在的模块重名

            模块文件名字去掉后面的扩展名（.py）即为模块名

    使用模块

        导入模块（import）

            使用import导入模块

            模块被导入后，程序会自动生成pyc的字节码文件以提升性能

            模块属性通过“模块名.属性”的方法调用

            如果仅需要模块中的某些属性，也可以单独导入

                >>> import tab
                     >>> import sys
                     >>> import os,string
                    >>> string.digits
                    '0123456789'
                    >>> from random import randint    #导入模块中的某个方法
                    >>> randint(1,10)
                    3
                    >>> import random as rdm   #导入random 模块并加别名 rdm

        模块加载（load）

            一个模块只被加载一次，无论它被导入多少次

            只加载一次可以阻止多重导入时代码被多次执行

            如果两个文件相互导入，阻止了无限的相互加载

            模块加载时，顶层代码会自动执行，所以只将函数放入模块的顶层是良好的编程习惯

        模块导入的特性

            模块具有一个__name__特殊属性

            当模块文件直接执行时，__name__的值为‘__main__'

            当模块被另一个文件导入时，__name__的值就是该模块的名字

$ cat foo.py
#!/usr/bin/env python
print __name__

$ cat bar.py
#!/usr/bin/env python
import foo
$ python foo.py
__main__
$ python bar.py
foo

  __name__ 是python 的内部变量，在foo 中 打印 __name__ ,单独执行时，输出的名字是__main__,被其他程序导入后，显示foo。

一个模块文件自己独立执行的时候，__name__,打印的是__main__,如果是被其他文件导入了。则__name__打印的就是模块名

应用：

#vim star.py

#!/usr/bin/env python

def pstar(num=20):

    return '*' * num

if __name__ == '__main__':

    print pstar()

    print pstart(40)

上述代码，单独执行（python star.py） ，则会执行 print pstar() print pstar(),如果import star，则不会执行print pstar() print pstar()

练习：生成8位随机密码

1、编写一个能生成8位随机密码的程序

2、使用random的choice函数随机取出字符

3、用于密码的字符通过string模块获得

4、改进程序，用户可以自己决定生成多少位的密码

多线程 ping

mtping.py

#!/usr/bin/env python

import os

import threading
def ping(ip):
    result = os.system("ping -c2 %s > /dev/null" % ip )
    if not result:
        print "%s:up" % ip
    else:
        print "%s:down" % ip

if __name__ == '__main__':
    for i in range(1,255):
        ipaddress = "192.168.2.%s" % i
        t = threading.Thread(target=ping,args=[ipaddr])
        t.start()