Python快速入门教程1：Python 基础教程

第1部分：Python 基础教程

1、Hello/编码
    Python2.x中默认的编码格式是 ASCII 格式，在没修改编码格式时无法正确打印汉字，所以在读取中文时会报错。
    解决方法为只要在文件开头加入 # -*- coding: UTF-8 -*- 或者 #coding=utf-8 就行了。
    Python3.X 源码文件默认使用utf-8编码，所以可以正常解析中文，无需指定 UTF-8 编码    
    [root@hadron python]# vi hello.py

    #!/usr/bin/python
    #coding=utf-8
    #输出语句
    print("你好，世界");
    #输入语句
    name=raw_input("Enter your name:")
    print "hello,"+name+"!"

    [root@hadron python]# python hello.py
    你好，世界
    Enter your name:程裕强
    hello,程裕强!
    脚本说明：
    "#"后面是注释
    "/"做转义字符用
    #!/usr/bin/python是说程序用的环境的路径,/usr/bin/python是linux用的路径
    有了该声明，脚本添加可执行权限之后可以直接运行，不用每次都python
    [root@hadron python]# chmod +x hello.py
    [root@hadron python]# hello.py
    bash: hello.py: 未找到命令...
    [root@hadron python]# ./hello.py
    你好，世界

2、标示与注释
    python中的标识符是区分大小写
    以下划线开头的标识符是有特殊意义的。以单下划线开头（_foo）的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用"from xxx import *"而导入；

    以双下划线开头的（__foo）代表类的私有成员；以双下划线开头和结尾的（__foo__）代表python里特殊方法专用的标识，如__init__（）代表类的构造函数。

    Python的代码块不使用大括号（{}）来控制类，函数以及其他逻辑判断。python最具特色的就是用缩进来写模块。

    缩进的空白数量是可变的，但是所有代码块语句必须包含相同的缩进空白数量，这个必须严格执行。
    建议你在每个缩进层次使用 单个制表符 或 两个空格 或 四个空格 , 切记不能混用
    Python语句中一般以新行作为为语句的结束符，但是我们可以使用斜杠（ \）将一行的语句分为多行显示。函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。空行与代码缩进不同，空行并不是Python语法的一部分。书写时不插入空行，Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。
    Python可以在同一行中使用多条语句，语句之间使用分号(;)分割
    您可以通过使用del语句删除单个或多个对象的引用

   

    python中单行注释采用 # 开头。

    Python 接收单引号( ' )、双引号( " )、三引号( ''' 或 """ ) 来表示字符串，引号的开始与结束必须的相同类型的。其中三引号可以由多行组成，编写多行文本的快捷语法，常用语文档字符串，在文件的特定地点，被当做注释。

    [root@hadron python]# vi print.py     

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
    word="""这是一个段落
                包含了多行"""
    print(word);
    '''
        这是多行注释，使用单引号。
        这是多行注释，使用单引号。
    '''
    """
        这是多行注释，使用双引号。
        这是多行注释，使用双引号。
    """
    #打印多个表达式，表达式中间会插入一个空格
    print "Age:",20
    #在上一句结尾处加上逗号，下一句会在同一行打印，
    print "Hello,",
    print "World!"

    [root@hadron python]# chmod +x print.py
    [root@hadron python]# ./print.py
    这是一个段落
            包含了多行
    Age: 20
    Hello, World!

3、变量
    [root@hadron python]# vi var.py

    
    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
    age=20          #整型
    sum=3.14        #浮点型
    name="hadron"   #字符串
    print age
    print sum
    print name
    print age**sum  #age的sum次幂
    print 9//2      #正数商4
    print 9//2.0    #4.0

    [root@hadron python]# chmod +x var.py
    [root@hadron python]# ./var.py
    20
    3.14
    hadron
    12168.4198643
    4
    4.0

4、分支语句
    [root@hadron python]# vi if.py 

   #!/usr/bin/python
    # -*- coding: UTF-8 -*-
    a = 21
    b = 10
    c = 0
    #比较运算
    if(a>0):
        print 'a:正数'
    else:
        print 'a:非正数'
    if(b+c>a):
        print "b+c大于a"
    else:
        print "b+c不大于a"
    #逻辑运算
    if(a and b):
        print "与:如果a为False，返回False，否则它返回b的计算值"
        print a and b
    if(a or b):
        print("或:如果a非0，返回a值，否则它返回b的计算值")
        print(a or b)
    print not c

    [root@hadron python]# chmod +x if.py
    [root@hadron python]# ./if.py
    a:正数
    b+c不大于a
    与:如果a为False，返回False，否则它返回b的计算值
    10
    或:如果a非0，返回a值，否则它返回b的计算值
    21
    True

    elif语句：
    [root@hadron python]# vi elif.py

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
    num = 5
    if num == 3:            # 判断num的值
        print 'boss'        
    elif num == 2:
        print 'user'
    elif num == 1:
        print 'worker'
    elif num < 0:           # 值小于零时输出
        print 'error'
    else:
        print 'roadman'     # 条件均不成立时输出

    [root@hadron python]# chmod +x elif.py
    [root@hadron python]# ./elif.py
    roadman

5、in与is
    [root@hadron python]# vi in_is.py  

  #!/usr/bin/python
    # -*- coding: UTF-8 -*-
    a = 10
    b = 20
    list = [1, 2, 3, 4, 5 ];
    if (a in list ):
       print "变量 a 在给定的列表中 list 中"
    else:
       print "变量 a 不在给定的列表中 list 中"
    if ( b not in list ):
       print "变量 b 不在给定的列表中 list 中"
    else:
       print "变量 b 在给定的列表中 list 中"
    a = "20"
    b = '20'
    #is是判断两个标识符是不是引用自一个对象
    if ( a is b ):
       print "a 和 b 引用相同对象"
    else:
       print "a 和 b 引用不同对象"
    print id(a)
    print id(b)

    [root@hadron python]# chmod +x in_is.py
    [root@hadron python]# ./in_is.py
    变量 a 不在给定的列表中 list 中
    变量 b 不在给定的列表中 list 中
    a 和 b 引用相同对象
    140232573171232
    140232573171232

6、循环语句
    else 中的语句会在循环正常执行完（即 for 不是通过 break 跳出而中断的）的情况下执行
    [root@hadron python]# vi for.py

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
    # while循环
    i = 1
    sum =0
    while i < 100:
        i += 1
        if i%2 > 0:     # 非双数时跳过
        continue
        sum+=i
    print sum

    #for循环
    for num in range(10,20):  # 迭代 10 到 20 之间的数字
       for i in range(2,num): # 根据因子迭代
          if num%i == 0:      # 确定第一个因子
             j=num/i          # 计算第二个因子
             print '%d 等于 %d * %d' % (num,i,j)
             break            # 跳出当前循环
       else:                  # 循环的 else 部分
          print num, '是一个质数'

    [root@hadron python]# chmod +x for.py
    [root@hadron python]# ./for.py
    2550
    10 等于 2 * 5
    11 是一个质数
    12 等于 2 * 6
    13 是一个质数
    14 等于 2 * 7
    15 等于 3 * 5
    16 等于 2 * 8
    17 是一个质数
    18 等于 2 * 9
    19 是一个质数
    说明：
    语句print num, '是一个质数'
        相当于一行输出两个字符串

7、字符串
    注意文件名不能命名为string
    [root@hadron python]# vi str.py

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
    a = "Hello"
    b = "Python"
    print "a + b 输出结果：", a + b
    print "a * 2 输出结果：", a * 2
    print "a[1] 输出结果：", a[1]
    print "a[1:4] 输出结果：", a[1:4]
    if( "H" in a) :
        print "H 在变量 a 中"
    else :
        print "H 不在变量 a 中"
    print "My name is %s and weight is %d kg!" % ('Hadron', 21)
    print "Python".lower()
    print "Python".find("on")

    [root@hadron python]# chmod +x str.py
    [root@hadron python]# ./str.py
    a + b 输出结果： HelloPython
    a * 2 输出结果： HelloHello
    a[1] 输出结果： e
    a[1:4] 输出结果： ell
    H 在变量 a 中
    My name is Hadron and weight is 21 kg!
    python
    4

8、列表(List)
    列表是常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。
    列表中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。
    列表的数据项不需要具有相同的类型。
    与字符串的索引一样，列表索引从0开始。列表可以进行截取、组合等。
    [root@hadron python]# vi mylist.py

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
    list=["C","C++","Java","Python",3.1415,110]
    print list[0]
    print list[1:3]   #[m,n]从第m+1个元素到第n个元素
    print list[2:]
    list[0]="C语言"       #更新
    del list[1]       #删除
    list.append("C#") #追加
    print list
    print str(list).decode('string_escape')
    print len(list)   #列表长

    [root@hadron python]# chmod +x mylist.py  
    [root@hadron python]# ./mylist.py
    C
    ['C++', 'Java']
    ['Java', 'Python', 3.1415, 110]
    ['C\xe8\xaf\xad\xe8\xa8\x80', 'Java', 'Python', 3.1415, 110, 'C#']
    ['C语言', 'Java', 'Python', 3.1415, 110, 'C#']
    6

9、字典
    列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
    [root@hadron python]# vi dict.py

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
    dict = {}
    dict[1]='hello';
    dict['one']="only one"
    mydict = {'name': 'john','code':6734, 'dept': 'sales'}
    print dict[1]
    print dict['one']
    print mydict
    print mydict.keys()
    print mydict.values()

    [root@hadron python]# chmod +x dict.py
    [root@hadron python]# ./dict.py
    hello
    only one
    {'dept': 'sales', 'code': 6734, 'name': 'john'}
    ['dept', 'code', 'name']
    ['sales', 6734, 'john']

10、元组
    Python的元组与列表类似，不同之处在于元组的元素不能修改。
    元组使用小括号，列表使用方括号。元组与字符串类似，下标索引从0开始，可以进行截取，组合等。
    [root@hadron python]# vi mytuple.py

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
    tuple=('hi',1,"e",2.7,'ok',"china")
    print tuple
    print tuple[0]
    print tuple[-2]  #反向到数第二个
    print tuple[1:3] #从第2到第3个元素
    print tuple[2:]
    #元组不能更新，可以通过组合生成新元组
    print (1,2,3)+(4,5,6)
    for x in (1,2,3):print x

    [root@hadron python]# chmod +x mytuple.py
    [root@hadron python]# ./mytuple.py
    ('hi', 1, 'e', 2.7, 'ok', 'china')
    hi
    ok
    (1, 'e')
    ('e', 2.7, 'ok', 'china')
    (1, 2, 3, 4, 5, 6)
    1
    2
    3

11、时间
    [root@hadron python]# vi time.py
    [root@hadron python]# chmod +x time.py

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
    import time
    import calendar
    # 格式化成2016-03-20 11:45:39形式
    print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
    cal = calendar.month(2016, 1)
    print "以下输出2016年1月份的日历:"
    print cal;

    [root@hadron python]# ./time.py
    Traceback (most recent call last):
      File "./time.py", line 3, in <module>
        import time
      File "/root/python/time.py", line 6, in <module>
        print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
    AttributeError: 'module' object has no attribute 'strftime'
     import的module是time，而我给这个python文件命名的也是time，估计是冲突了
    [root@hadron python]# mv time.py mytime.py
    [root@hadron python]# rm -rf time.pyc
    [root@hadron python]# ./mytime.py
    2017-01-22 15:28:12
    以下输出2016年1月份的日历:
        January 2016
    Mo Tu We Th Fr Sa Su
                      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

12、函数
    函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
    函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
    函数内容以冒号起始，并且缩进
    return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
    所有参数（自变量）在Python里都是按引用传递。如果你在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了。
    允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
    [root@hadron python]# vi fun.py

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
    #可写函数说明
    def f1(name, age ):
       "打印任何传入的字符串"
       print "Name: ", name;
       print "Age ", age;
       age=0;
       name="";
       return;
    def f2(name="无名氏",age=18):
       "缺省参数的值如果没有传入，则被认为是默认值"
       print "Name: ", name;
       print "Age ", age;
       return;
    #加了星号*的变量名会存放所有未命名的变量参数
    def f3(arg1,*vartuple):
       "打印任何传入的参数"
       print arg1
       for var in vartuple:
          print var
       return;
    age=20
    name="hadron"
    #调用f1函数
    f1(age, name);
    f2();
    f3(10);
    f3(11,13,17);

    [root@hadron python]# ./fun.py
    Name:  20
    Age  hadron
    Name:  无名氏
    Age  18
    10
    11
    13
    17

13、lambda
    lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
    lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
    虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
    lambda的一般形式是关键字lambda后面跟一个或多个参数，紧跟一个冒号，以后是一个表达式。lambda是一个表达式而不是一个语句。它能够出现在Python语法不允许def出现的地方。作为表达式，lambda返回一个值（即一个新的函数）。
    lambda存在意义就是对简单函数的简洁表示
    lambda用来编写简单的函数，而def用来处理更强大的任务
    [root@hadron python]# vi lambda.py

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
    #lambda的一般形式是关键字lambda后面跟一个或多个参数，紧跟一个冒号，以后是一个表达式
    sum = lambda arg1, arg2: arg1 + arg2;
    print sum(10, 20)
    #map函数
    L = [1,2,3,4]
    def inc(x):
        return x+10
    print map(inc,L)
    print map((lambda x: x+10),L)
    #filter函数
    li = [11, 22, 33]
    new_list = filter(lambda arg: arg > 22, li)
    #reduce函数
    for i in new_list:
        print i
    result = reduce(lambda arg1, arg2: arg1 + arg2, li)
    print result

    [root@hadron python]# ./lambda.py
    30
    [11, 12, 13, 14]
    [11, 12, 13, 14]
    33
    66

14、模块
    模块就是一个保存了Python代码的文件。模块能定义函数，类和变量。模块里也能包含可执行的代码。
    想使用Python源文件，只需在另一个源文件里执行import语句,当解释器遇到import语句，如果模块在当前的搜索路径就会被导入。
    Python的from语句让你从模块中导入一个指定的部分到当前命名空间中。
    模块搜索路径存储在system模块的sys.path变量中。变量里包含当前目录，PYTHONPATH和由安装过程决定的默认目录
    [root@hadron python]# vi import.py

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
    # 导入模块
    import math
    # 调用模块中的函数：模块.函数
    print math.sqrt(2)
    #变量引用函数
    foo=math.sqrt
    print foo(2)

    [root@hadron python]# ./import.py
    1.41421356237
    1.41421356237

    from .. import ..
    通过“from 模块 import 函数”形式引入，可以直接使用函数，而不需要使用前缀模块名    
    [root@hadron python]# vi from_import.py  

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
    from math import sqrt
    print sqrt(2)

    [root@hadron python]# ./from_import.py
    1.41421356237

15、文件I/O
    先用Python内置的open()函数打开一个文件，创建一个file对象，调用相关方法进行读写
    r:以只读方式打开文件。文件的指针将会放在文件的开头。    
    w:打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
    +：表示读写都是允许的
    a：以追加的方式打开只写文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾，原内容会被保留。
    b：打开的文件为二进制文件，而非纯文字文件
    write(string)方法可将任何字符串写入一个打开的文件。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。
    write()方法不会在字符串的结尾添加换行符('\n')：
    read([count])方法从一个打开的文件中读取一个字符串
    该方法从文件的开头开始读入，如果没有传入count，它会尝试尽可能多地读取更多的内容，很可能是直到文件的末尾。

    [root@hadron python]# vi file1.py

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
    # 打开一个文件
    f = open("test.txt", "wb+")
    print "文件名: ", f.name
    print "是否已关闭 : ", f.closed
    print "访问模式 : ", f.mode
    print "末尾是否强制加空格 : ", f.softspace
    #写入文件
    f.write("Hello,world!\n");
    f.write("你好，世界！\n")
    f.write("程裕强\n");
    # 关闭打开的文件
    f.close()

    [root@hadron python]# ./file1.py
    文件名:  test.txt
    是否已关闭 :  False
    访问模式 :  wrb+
    末尾是否强制加空格 :  0

    [root@hadron python]# vi file2.py

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
    # 打开一个文件
    f = open("test.txt", "r")
    #读取4个字符
    str = f.read(4);
    print "读取的字符串是 : ", str
    #读取1行
    print "读取1行：",f.readline()
    #读取所有行
    for  line in  f.readlines():
         print  line,
    # 关闭打开的文件
    f.close()

    [root@hadron python]# ./file2.py
    读取的字符串是 :  Hell
    读取1行： o,world!

    你好，世界！
    程裕强
    
    [root@hadron python]# vi file3.py

 #!/usr/bin/python
    # -*- coding: UTF-8 -*-
    # with语句打开文件并赋值到变量f,文件在语句结束后会自动关闭
    with open("test.txt", "r") as f:
        while True:
                       # 查找当前位置
                print "当前文件位置 : ", f.tell()
                          #输出1行
                line=f.readline()
                print line,
                if not line:break
        # 把指针再次重新定位到文件开头
        f.seek(0, 0);
        print "重新读取:\n", f.read();

    [root@hadron python]# chmod +x file3.py
    [root@hadron python]# ./file3.py
    当前文件位置 :  0
    Hello,world!
    当前文件位置 :  13
    你好，世界！
    当前文件位置 :  32
    程裕强
    当前文件位置 :  42
     重新读取: Hello,world!
    你好，世界！
    程裕强

16、目录
    os模块有许多方法能帮你创建，删除和更改目录。
    [root@hadron python]# vi dir.py  

 #!/usr/bin/python
    # -*- coding: UTF-8 -*-
    import os
    # 创建目录test
    os.mkdir("test")
    # 将当前目录改为"/root/python/test"
    os.chdir("/root/python/test")
    # 给出当前的目录
    print os.getcwd()

    [root@hadron python]# chmod +x dir.py
    [root@hadron python]# ./dir.py
    /root/python/test

17、异常处理
    try:
    <语句>        #运行别的代码
    except <名字>：
    <语句>        #如果在try部份引发了'name'异常
    except <名字>，<数据>:
    <语句>        #如果引发了'name'异常，获得附加的数据
    else:
    <语句>        #如果没有异常发生

    [root@hadron python]# vi try.py

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
    try:
        f = open("test", "w")
        f.write("这是一个测试文件，用于测试异常!!")
    except IOError:
        print "Error: 没有找到文件或读取文件失败"
    else:
        print "内容写入文件成功"
        f.close()

    [root@hadron python]# python try.py
    Error: 没有找到文件或读取文件失败

    修改：f = open("test.txt", "w")
    [root@hadron python]# python try.py
    内容写入文件成功
    [root@hadron python]# cat test.txt
    这是一个测试文件，用于测试异常!![root@hadron python]#

    以使用raise语句自己触发异常
    [root@hadron python]# vi try2.py

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
    def f(level ):
        if level < 1:
        #触发异常后，后面的代码就不会再执行
        raise Exception("Invalid level!", level)
    try:
        f(0)
    except "Invalid level!":
        print 1
    else:
        print 2

    [root@hadron python]# python try2.py
    Traceback (most recent call last):
      File "try2.py", line 8, in <module>
        f(0)              
      File "try2.py", line 6, in f
        raise Exception("Invalid level!", level)
    Exception: ('Invalid level!', 0)