Chinaunix

标题: Python的入门简介 [打印本页]

---

作者: missjiang    时间: 2007-09-25 12:28
标题: Python的入门简介
前段时间老板要做一个项目，采用的开发语言是Python，之前本人只学习过C++和Java两种传统的编程语言，对于Python语言的了解仅限于听说过而已，在参与这个项目过程中，真真实实感受到了Python语言的简单易用和它的快速开发的效率。
    我想可能部分网友和我有着相似的学习背景(只学习过传统的C++/Java编程语言，而对Perl/Python/Ruby没有了解)，经历这个项目后，我认为像Python这样的语言确实有学习的必要，因此把我的Python学习笔记贴出来，不过前面部分写的过于基础了。

目录
1、第一个Python脚本: hello world
2、Python语言与传统的C++/Java语言显著不同的地方
3、Python语言的控制结构
4、变量声明和定义  
5、函数  
6、列表、字典、元组  
7、字符串处理
8、面向对象编程：封装、继承、虚拟函数、接口、多继承、模板
9、面向对象编程：异常处理

[ 本帖最后由 missjiang 于 2007-9-25 12:37 编辑 ]

---

作者: missjiang    时间: 2007-09-25 12:29
1、第一个Python脚本: hello world

1. 
   
2. #!/usr/bin/python
   
3. print 'hello world'
   

复制代码

与C语言的不同地方在于：

• 不需要使用 ; 结尾
• 不需要使用 () 把参数包起来
• 可以使用单引号

这些做法可以使得程序看上去较为清爽，当然如果你不习惯的话，Python编译器也可以接受以下的风格

1. 
   
2. #!/usr/bin/python
   
3. print("hello world");
   

复制代码

---

作者: missjiang    时间: 2007-09-25 12:29
2、Python语言与传统的C++/Java语言显著不同的地方

• 变量在使用之前无须声明
  
  1. 
     
  2. a = 1
     
  3. b = "hello world"
     

  复制代码
  
  
• 使用 # 而不是//和/* ... */注释代码
  
  1. 
     
  2. c = a + b # this is comment
     

  复制代码
  
  
• 表达式语句不需要使用 ; 结尾
  
  1. 
     
  2. a = a + 1
     
  3. b = b + 1
     

  复制代码
  
  
• 函数调用时不需要使用 () 把参数包起来，if/while 中的也不需要使用()把条件表达式包起来
  
  1. 
     
  2. print "hello world"
     
  3. if a == b:
     
  4.         print 'a == b'
     
  5. else:
     
  6.         print 'a != b'
     

  复制代码
  
  
• 引号有单引号、双引号、三引号三种形式，后面详述
• 使用“缩进”而不是{}标志代码块，下面我们将详细讨论这样作的优缺点.
  

先看一个例子：

1. 
   
2. a = 1
   
3. b = 2
   
4. c = 3
   
5. d = 3
   
6. if a == b:
   
7.         if c == d:
   
8.                 print 'a == b && c == d'
   
9. else:
   
10.         print 'a != b'
    
11. # 程序运行结果：a != b
    

复制代码

注意：

• 缩进相同的语句处于同一个语法块中
• 在if/else语句末尾有一个冒号，代表语法块的开始
• python中提供了pass语句，该条语句表示一个空操作
  
  1. 
     
  2. a = 1
     
  3. b = 2
     
  4. if a == b:
     
  5.         pass
     
  6. else:
     
  7.         print 'a != b'        
     
  8. # 程序运行结果：a != b
     

  复制代码
  
  

Python语言这种做法的优点在于：

• 省去{}或者begin/end，使得程序结构更为清晰(也许有人会有不同的观点)：
• 强制所有的Python程序都有着相同的风格，不会像在C语言中出现风格迥异的情况：
  
  1. 
     
  2. /* K&R的风格 */
     
  3. if (a > b) {
     
  4.    printf("a > b")
     
  5. }
     
  6. 
     
  7. /* 很多人喜欢的风格 */
     
  8. if (a > b)
     
  9. {
     
  10.    printf("a > b")
      
  11. }
      
  12. 
      
  13. /* EMACS编辑器的风格 */
      
  14. if (a > b)
      
  15.   {
      
  16.    printf("a > b")
      
  17.   }
      

  复制代码
  
  
• 避免了如下情况由于忘记{}而造成的错误
  
  1. 
     
  2. #include <stdio.h>
     
  3. 
     
  4. int main()
     
  5. {
     
  6.         int a, b, c, d;
     
  7.         a = 1;
     
  8.         b = 2;
     
  9.         c = 3;
     
  10.         d = 3;
      
  11.         if (a == b)
      
  12.                 if (c == d)
      
  13.                         puts("a == b && c == d");
      
  14.         else
      
  15.                 puts("a != b");
      
  16.         return 0;
      
  17. }
      

  复制代码
  
  从缩进来看，编写这段代码的程序员的本意是希望当a、b不相等时输出"a != b"，但是程序运行时没有任何输出，和程序员期待的结果是不一样的。
  

Python语言这种做法的缺点在于：

• python的代码一旦缩进乱了，无法重新格式化
• 粘贴代码的时候，缩进会被破坏，不方便
  

这些缺点倒是可以接受，关键在于用户是否认同Python缩进的优点。

---

作者: missjiang    时间: 2007-09-25 12:30
3、Python语言的控制结构

• if 语句
  
  1. 
     
  2. a = 1
     
  3. b = 2
     
  4. if a < b:
     
  5.         print 'a < b'
     
  6. elif a == b:
     
  7.         print 'a == b'
     
  8. else:
     
  9.         print 'a > b'
     

  复制代码
  
  注意：Python中提供了elif语句，是else if的缩写。
  
• switch 语句
  python没有提供switch 语句，另外python也不提供++、--运算符。
  
• while 语句
  
  1. 
     
  2. sum = 0
     
  3. i = 1
     
  4. while i < 101:
     
  5.         sum += i
     
  6.         i += 1
     
  7. else:
     
  8.         print("LOOP IS OVER, i = %d" % i)  # 格式化字符串输出的细节在后面详述
     
  9. print("sum = %d" % sum)
     

  复制代码
  
  程序运行结果：
  LOOP IS OVER, i = 101
  sum = 5050
  
• while循环中的else语句
  while循环中有一个可选的else语句，当循环没有被break中断而结束时，执行else后面的语句块，如果把程序改为：
  
  1. 
     
  2. sum = 0
     
  3. i = 1
     
  4. while i < 101:
     
  5.         sum += i
     
  6.         i += 1
     
  7.         break
     
  8. else:
     
  9.         print("LOOP IS OVER, i = %d" % i)
     
  10. print("sum = %d" % sum)
      

  复制代码
  
  程序运行结果变为：
  sum = 1
  
• for 语句
  python中不提供C语言风格的for循环，如下代码段是不被接受的：
  
  1. 
     
  2. for (i = 1; i < 101; i += 1):
     
  3.         sum += i
     

  复制代码
  
  
  要计算从1累加到100的和，通常使用如下方法：
  
  1. 
     
  2. sum = 0
     
  3. for i in range(1, 101):
     
  4.         sum += i
     
  5. else:
     
  6.         print "LOOP IS OVER, i = %d" % i
     
  7. print "sum is %d" % sum
     

  复制代码
  
  运行结果：
  LOOP IS OVER, i = 100
  sum = 5050
  这里需要注意的是：
  
  • range(start, end, step)接受了三个参数：以步长为step(缺省为1)，产生从start(包含)开始到end(不包含)结束的一个序列。在这个例子中，start = 1, end = 101, step = 1(缺省值)，产生了从1到100总计100个数。
  • 使用i变量遍历range产生的序列，循环执行100次，i的值依次为1、2、... 100。
  • for循环也有可选的else语句，功能和while循环中的else语句相同。
    
  
  
• for 语句，指定range的step
  
  1. 
     
  2. for i in range(10, 0, -1):
     
  3.         print i
     
  4. 程序输出结果：
     
  5. 10
     
  6. 9
     
  7. 8
     
  8. 7
     
  9. 6
     
  10. 5
      
  11. 4
      
  12. 3
      
  13. 2
      
  14. 1
      

  复制代码
  
  在这个例子中，start = 10,  end = 0,  step = -1，程序的功能类似于如下C代码：
  
  1. 
     
  2. start = 10
     
  3. end = 0
     
  4. step = -1
     
  5. for (i = start; i > end; i += step)
     
  6.         print(i)
     

  复制代码
  
  

---

作者: missjiang    时间: 2007-09-25 12:31
4、变量声明和定义

• 变量在使用之前无须声明
  
  1. 
     
  2. var = 1
     
  3. print var
     

  复制代码
  
  
• 变量在使用之前必须定义
  
  1. 
     
  2. print var
     
  3. # 运行时刻出错，NameError: name 'var' is not defined
     

  复制代码
  
  
• 定义变量时，可以获知变量的类型，需要记住列表、字典、元组使用不同的括号[]、{}、()
  
  1. 
     
  2. # 整数
     
  3. integer = 123         
     
  4. 
     
  5. # 字符串
     
  6. string = "hello"         
     
  7. 
     
  8. # 列表
     
  9. list = [1, 2, 3]
     
  10. 
      
  11. # 字典
      
  12. dict = {1:2, 2:4, 3:6}   
      
  13. 
      
  14. # 元组
      
  15. tuple = (1, 2, 3)        
      

  复制代码
  
  
• 在函数中缺省访问的是局部变量，当使用global声明后，访问的才是全局变量
  
  1. 
     
  2. def func():
     
  3.         g = 2  ＃ 局部变量
     
  4. 
     
  5. g = 1
     
  6. func()
     
  7. print(g)
     

  复制代码
  
  func中修改了局部变量g，没有影响全局变量g，输出结果为1
  
  
  1. 
     
  2. def func():
     
  3.         global g
     
  4.         g = 2  ＃ 全局变量
     
  5. 
     
  6. g = 1
     
  7. func()
     
  8. print(g)
     

  复制代码
  
  func中修改了全局变量g，输出结果为2
  

---

作者: missjiang    时间: 2007-09-25 12:31
5、函数

• 使用def定义函数
  
  1. 
     
  2. def add(a, b):
     
  3.        return a + b
     
  4. 
     
  5. print(add(1, 2))
     

  复制代码
  
  运行结果为3
  
• 函数可以递归调用
  
  1. 
     
  2. def fact(n):
     
  3.         if n == 0:
     
  4.                 return 1
     
  5.         else:
     
  6.                 return n * fact(n - 1)
     
  7. print(fact(3))
     

  复制代码
  
  运行结果为6
  
• 缺省参数
  
  1. 
     
  2. def func(a = 'a', b = 'b', c = 'c', d = 'd', e = 'e', f = 'f'):
     
  3.         print a + b + c + d + e + f
     
  4. # 情况1：所有参数使用缺省值
     
  5. # 输出结果：abcdef
     
  6. func()
     
  7. 
     
  8. # 情况2：前面的参数使用指定值，后面的参数使用缺省值
     
  9. # 输出结果：ABCdef
     
  10. func('A', 'B', 'C')
      
  11. 
      
  12. # 情况3：任意指定哪些参数接受缺省值，哪些参数使用指定值
      
  13. # 输出结果：aBcDeF
      
  14. func(b = 'B', d = 'D', f = 'F')
      

  复制代码
  
  
• 把所有的参数存放在数组中
  
  1. 
     
  2. add函数把接受的参数相加，并把和打印出来，注意args前面有一个*
     
  3. def add(*args):
     
  4.         sum = 0
     
  5.         for i in args:  # 遍历数组
     
  6.                 sum += i
     
  7.         print sum
     
  8. 
     
  9. # 情况1：所有参数使用缺省值
     
  10. # 输出结果：abcdef
      
  11. func()
      
  12. 
      
  13. # 情况2：前面的参数使用指定值，后面的参数使用缺省值
      
  14. # 输出结果：ABCdef
      
  15. func('A', 'B', 'C')
      
  16. 
      
  17. # 情况3：任意指定哪些参数接受缺省值，哪些参数使用指定值
      
  18. # 输出结果：aBcDeF
      
  19. func(b = 'B', d = 'D', f = 'F')
      

  复制代码
  
  
• 使用lambda生成一个新的函数
  
  1. 
     
  2. def generate_multiplier(factor):
     
  3.         return lambda x: x * factor
     
  4. 
     
  5. # 生成一个功能为乘以2的函数mul2，输出结果为200，mul2的定义相当于：
     
  6. # def mul2(x):
     
  7. #         return x * 2
     
  8. mul2 = generate_multiplier(2)
     
  9. print(mul2(100))
     
  10. 
      
  11. # 生成一个功能为乘以4的函数mul4，输出结果为400，mul4的定义相当于：
      
  12. # def mul4(x):
      
  13. #         return x * 4
      
  14. mul4 = generate_multiplier(4)
      
  15. print(mul4(100))
      
  16. 
      
  17. # 生成一个功能为乘以8的函数mul8，输出结果为800，mul8的定义相当于：
      
  18. # def mul8(x):
      
  19. #         return x * 8
      
  20. mul8 = generate_multiplier(8)
      
  21. print(mul8(100))
      

  复制代码
  
  

---

作者: missjiang    时间: 2007-09-25 12:32
6、列表、字典、元组
待续...

---

作者: missjiang    时间: 2007-09-25 12:32
7、字符串处理
待续...

---

作者: missjiang    时间: 2007-09-25 12:33
8、面向对象编程：封装、继承、虚拟函数、接口、多继承、模板
Python是一种典型的动态类型语言，由于他的动态性：

• 天生支持虚拟函数、接口、模板等特征，无须引入特定的关键字
• 在多继承中不存在“菱形继承”引发的问题

下面我们通过举例的方式学习面向对象语言中的各种特性

1、封装

1. 
   
2. class Person:
   
3.         def __init__(self, name):
   
4.                 self.name = name
   
5.         def getName(self):
   
6.                 return self.name
   
7. 
   
8. person = Person('person')
   
9. print 'name = %s' % person.getName()
   
10. 
    
11. 程序输出：
    
12. name = person
    

复制代码

与C++不同的地方：

• 类的成员函数的第一个参数是指向这个对象的self引用
• 在成员函数里，必须通过self引用访问其他的成员变量或者成员函数
  
  1. 
     
  2. class Person:
     
  3.         def __init__(self, name):
     
  4.                 self.name = name
     
  5.                 getName()
     
  6.         def getName(self):
     
  7.                 return self.name
     
  8. 
     
  9. person = Person('person')
     
  10. print 'name = %s' % person.getName()
      
  11. 
      
  12. 运行时刻出错，NameError: global name 'getName' is not defined
      

  复制代码
  
  
• 构造函数的名称为__init__
  

2、继承

1. 
   
2. class Chinese(Person):
   
3.         def __init__(self, name, company):
   
4.                 Person.__init__(self, name)
   
5.                 self.company = company
   
6.         def love(self):
   
7.                 print '%s is Chinese, he love working' % self.name
   
8.         def work(self):
   
9.                 print '%s is working in %s' % (self.name, self.company)
   
10. 
    
11. class Japanese(Person):
    
12.         def __init__(self, name, interesting):
    
13.                 Person.__init__(self, name)
    
14.                 self.interesting = interesting
    
15.         def love(self):
    
16.                 print '%s is Japanese, he love playing' % self.name
    
17.         def play(self):
    
18.                 print '%s is playing %s' % (self.name, self.interesting)
    
19. 
    
20. zhangSan = Chinese('Zhang San', 'HuaWei')
    
21. zhangSan.love()
    
22. zhangSan.work()
    
23. 
    
24. sanJing = Japanese('San Jing', 'Basketball')
    
25. sanJing.love()
    
26. sanJing.play()
    
27. 
    
28. 程序输出：
    
29. Zhang San is Chinese, he love working
    
30. Zhang San is working in HuaWei
    
31. San Jing is Japanese, he love playing
    
32. San Jing is playing Basketball
    

复制代码

3、虚拟函数

1. 
   
2. zhangSan = Chinese('Zhang San', 'Hua Wei')
   
3. sanJing = Japanese('San Jing', 'Basketball')
   
4. 
   
5. persons = [zhangSan, sanJing]
   
6. for person in persons:
   
7.         person.love()
   
8. 
   
9. 程序输出：
   
10. Zhang San is Chinese, he love working
    
11. San Jing is Japanese, he love playing
    

复制代码

这个例子建立了继承于Person的Chinese和Japanese类，Chinese中定义了love和work两个成员函数，Japanese中定义了love和play两个成员函数，注意：

• Python中没有virtual关键字，默认成员函数都是虚函数，这一点与java类似。
• 在Chinese和Japanese的父类Person中无须声明两者共同的接口(love函数)，这一点与java不同

4、接口

1. 
   
2. class Cat:
   
3.         def __init__(self, name, food):
   
4.                 self.name = name
   
5.                 self.food = food
   
6.         def love(self):
   
7.                 print '%s is Cat, he love eating %s' % (self.name, self.food)
   
8. 
   
9. def callLove(object):
   
10.         object.love()
    
11. 
    
12. zhangSan = Chinese('Zhang San', 'HuaWei')
    
13. sanJing = Japanese('San Jing', 'Basketball')
    
14. mimi = Cat('MIMI', 'fish')
    
15. objects = [zhangSan, sanJing, mimi]
    
16. for object in objects:
    
17.         callLove(object)
    
18. 
    
19. 程序输出：
    
20. Zhang San is Chinese, he love working
    
21. San Jing is Japanese, he love playing
    
22. MIMI is Cat, he love eating fish
    

复制代码

注意：

• Chinese和Japanese有共同的祖先Person，而Cat和Chinese、Japanese完全不相关
• 三者都有共同的接口：love函数
• callLove函数的参数是无类型的，实现以上功能，无须像Java一样要引入interface的概念

5、多继承

1. 
   
2. class Mix(Chinese, Japanese):
   
3.         def __init__(self, cname, jname, company, interesting):
   
4.                 Chinese.__init__(self, cname, company)
   
5.                 Japanese.__init__(self, jname, interesting)
   
6. 
   
7. mix = Mix('Zhang San', 'San Jing', 'HuaWei', 'Basketball')
   
8. mix.love()
   
9. mix.work()
   
10. mix.play()
    
11. 
    
12. 程序输出：
    
13. San Jing is Chinese, he love working
    
14. San Jing is working in HuaWei
    
15. San Jing is playing Basketball
    

复制代码

• 这是一个所谓的菱形继承，但是Mix类中只有一份name的拷贝
• Mix的构造函数中，先调用Chinese的构造函数，把name初始化为Zhang San；随后调用Japanese的构造函数，把name有改为San Jing，因此后面打印出来的名字都是San Jing
• work是Chinese特有的方法，调用正常
• play是Japanese特有的方法，调用正常
• love是Chinese和Japanese共有的方法，这里调用的是Chinese的love方法
  

6、模板
Python是动态类型的语言，天生支持模板，看两个例子：

函数模板

1. 
   
2. def min(a, b):
   
3.         if (a < b):
   
4.                 return a
   
5.         else:
   
6.                 return b
   
7. 
   
8. print(min(1, 2))
   
9. print(min(1.5, 2.5))
   

复制代码

类模板

1. 
   
2. objects = [Person('person'), Cat('mimi')]
   

复制代码

Python中内置的高级数据类型有：列表、字典、元组，它们可以存储任意类型的元素，实现容器时无须像C++的stl需要template的支持，这一点与Java类似。

[ 本帖最后由 missjiang 于 2007-9-25 19:34 编辑 ]

---

作者: missjiang    时间: 2007-09-25 12:34
9、面向对象编程：异常处理

捕获除以零的异常

1. 
   
2. try:
   
3.         a = 1
   
4.         b = 0
   
5.         c = a / b
   
6.         print 'Never reach this line'
   
7. except ZeroDivisionError:
   
8.         print 'Attempt divide by zero'
   

复制代码

定义自己的异常

1. 
   
2. class MyException(Exception):
   
3.         def __init__(self, divisor, dividend):
   
4.                 self.divisor = divisor
   
5.                 self.dividend = dividend
   
6. 
   
7. def divide(divisor, dividend):
   
8.         if divisor == 2 * dividend:
   
9.                 raise MyException(divisor, dividend)
   
10.         print '%d / %d = %d' % (divisor, dividend, divisor / dividend)
    
11. 
    
12. try:
    
13.         divide(9, 3)
    
14.         divide(16, 4)
    
15.         divide(4, 2)
    
16. except MyException, x:
    
17.         print 'MyException is raised while execute divide(%d, %d)' % (x.divisor, x.dividend)
    

复制代码

finally子句

1. 
   
2. def openFile():
   
3.         try:
   
4.                 print 'Open File'
   
5.                 file = open('/etc/passwd')
   
6.                 c = 1 / 0
   
7.         finally:
   
8.                 print 'Close File'
   
9.                 file.close()
   
10.         print 'Never reach this line'
    
11. 
    
12. try:
    
13.         openFile()
    
14. except:
    
15.         print 'Error occured while open file'
    

复制代码

---

作者: jcodeer    时间: 2007-09-25 17:28
不错～～～～～
学习

---

作者: szhaitao    时间: 2007-09-30 11:12
不错。。。。。。。看《简明 Python 教程》
Swaroop, C. H. 著
沈洁元  译
www.byteofpython.info

居然一直没找到怎么注释代码。。。。。。还是这样的笔记型的好，想读者所想，记读者易混淆

对于缩进代替结束关键字，感觉非常不爽
如果说为了强制代码规范，那为什么变量可以不定义就使用，而且可以随时改变其类型！这样只会更混乱。
——比较喜欢c++的随时随地{ }一个代码块里定义局部变量，对于pascal的函数头部统一声明变量也觉得太极端了

---

欢迎光临 Chinaunix (http://bbs.chinaunix.net/)

Powered by Discuz! X3.2