首页 > 代码库 > python 学习笔记day02-python循环、文件、函数、模块

python 学习笔记day02-python循环、文件、函数、模块

循环语句

    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 = http://www.mamicode.com/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()



            文件对象的访问模式:

文件模式
操作

r

以读方式打开(文件不存在则报错))
w
以写方式打开(文件存在则清空,不存在则创建)
a
以追加模式打开(必要时创建新文件)
r+
以读写模式打开(参见r)
w+
以读写模式打开(参见w)
a+
以读写模式打开(参见a)

 文件输入

        read方法

            read()方法用来直接读取字节到字符串中,最多读取给定数目个字节

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

                  >>> data = http://www.mamicode.com/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 = http://www.mamicode.com/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 = http://www.mamicode.com/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 = http://www.mamicode.com/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 = http://www.mamicode.com/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()


本文出自 “linux服务器” 博客,请务必保留此出处http://sailq21.blog.51cto.com/6111337/1858298

python 学习笔记day02-python循环、文件、函数、模块