简明Python教程笔记

1. Python 程序执行

       第一种方法：直接在Python命令窗口中新建窗口，编写程序，使用Run Modules来运行程序。

        第二种方法：使用文本编写Python程序，在命令行中运行。例如>Python HelloWorld.py

       在第一篇文章中有关于如何执行的详细介绍，详细内容参考第一篇文章

 

2. 注意事项：

       在Python程序中，一定注意大小写是严格区分的，Print 和 print不同。

       确保每一行的开始字符前没有空格或制表符，这个是一个语法错误，程序无法执行。

       注释是以"#"开始的语句，任何在"#"右面的文字都是注释
       注意在Linux下的首行"#!/usr/bin/python"，这句的意思是告诉shell使用什么编译器或解释器来运行文件。  

3. Python中有四种类型的数：整数、长整数、浮点数和复数。
   
       字符串，在Python中有三种，单引号'',双引号""，三引号''' '''。
 
       单引号和双引号基本相同，但是单引号可以用于双引号中，且可以正常打印。

       三引号语句时可以存在换行的，而前两者不可以。

       注释：Python中没有char类型的数据。

       注：默认地，Python希望每一行上都只是用一个语句，这样是代码更加易读。

4. Python的运算符需要注意几个地方：

       in, not in 成员运算符    is，is not 统一性测试

       ~x  按位翻转             ** 指数(幂次方)

       //  取整除，返回商的整数部分 4// 3.0得到 1.0
   
       x[index:index]  寻址段   (expression,...) 绑定或元组显示
 
       [expression,...] 列表显示 {key:datum, ...} 字典显示

       'expression, ...' 字符串转换

5. if表达式
  
       if  exp1 > exp2:

       elif exp1 > exp3:

       else:

       三个地方需要注意：else if 缩写为 elif   if，elif, else 三个结尾处要有':',其后表明是语句块。

       注：在Python中使用缩进来表示语句块。

6. While语句

       While exp1:

       else:

              exp2

       注：在Python的While语句中可以有else语句，用于while结束时执行(或者while条件不满足时执行，可以实现类似do while 的一些功能)。但是如果在while循环体内遇到了break语句，else语句将不被执行。

7. for循环

       for循环的基本形式：
       for i in range(a, b):
              statement;
       else:
       statement;

   
       1. range函数：生成一个序列的数字

              第一个参数是开始数，第二个参数为终止数字，第三个参数是步长，每一次增长的数字

       2. for 后有冒号":"，else后也有":"，else在for循环执行完后执行else语句。但是如果for语句体内遇到了break语句，那么else将不被执行。

       3. in后的序列，可以是任何对象，包括字符串，自定义对象等等。

       4. 内置函数 len(str); 返回字符串的长度

8. 函数

       1. 通过def关键字定义，def关键字后跟一个函数的名称，然后跟一对圆括号，括号内是一些变量名字，一冒号":"结尾,接下来是一块语句，是函数体。

       def sayHello():
              statement;

       调用函数：sayHello();

       2. 为函数加入形参：与其他变量类似，形参也不需要声明类型，直接放置想要命名的参数即可。

       3. 局部变量同其他的语言的局部变量是一样的，函数体内的局部变量不会对外部变量产生影响。
       参数的传递也是值传递，不是地址传递。

       4. 要想在函数体内修改外部变量，则需要使用全局变量，使用global语句完成全局变量声明。
       def func():
              global x;
   
              print 'x is', x;
              x = 2;
              print 'Changed local x to', x;
   
       x = 50;
       func();
       print 'Value of x is', x;
   
       输出结果：

       x is 50
       Changed global x to 2
       Value of x is 2

       由此可见，对于要进行修改的变量，必须在函数体内将变量声明为global的，才可以实现。
       例如：global x, y, z;

       5. 参数默认值，对于参数的默认值和其他的相同，默认参数应该在参数列表的最后

       6. 关键参数的概念：

       对于参数，默认按照普通参数对待，对其传参则是按照位置进行对应。

       可以使用关键参数，为参数列表的参数指定值(使用参数的名字，而非利用位置对应)。
       def func(a, b=5, c=10):
              print 'a is', a, 'and b is', b, 'and c is', c

       func(3, 7)
       func(25, c=24)
       func(c=50, a=100)
   
       好处：不需要担心参数的顺序对应，使用简单。假设参数都有默认值，仅仅需要给自己感兴趣的参数赋值即可。

       7. return语句
  
       从函数返回或跳出，也可以从函数中返回一个值

       没有返回值的语句等价于 return None;
  
       pass 在python中代表一个空语句块。

       8. DocStrings 文档字符串，被简称为docstrings。

       在函数的第一个逻辑行的字符串就是这个函数的文档字符串。

       docstring书写的习惯：一个多行字符串，首行以大写字母开始，句号结尾。第二行是空行，从第三行开始是详细描述。

       强烈建议：在函数中使用文档字符串时要遵循这个惯例

       可以使用 __doc__(注意是双下划线)调用函数的文档字符串属性。

  
9. 模块

       1. 模块就是一个包含了你所定义的函数和变量，为了在其他程序中重用模块，模块的文件名必须以.py为扩展名。

       首先要学习如何使用标准库模块。

       #!/usr/bin/python
       #Filename: using_sys.py

       import sys;   #引入sys模块

       print 'The command line arguments are:';

       for i in sys.argv:  #参数列表，打印参数列表的内容
              print i

       print '\n\nThe PYTHONPATH is', sys.path,'\n';

       注：系统在sys.path所列的目录中寻找sys.py模块，如果找到就执行。
     
       命令行参数： sys.argv[0] 是程序名称即using_sys.py ，从sys.argv[1]开始才是命令行的参数

       可以观察到sys.path的第一个字符串是空的(在Windows下是当前目录字符串)，表示的是当前目录，那么模块可以放到当前目录下，也即程序所在的目录，python解释器是可以找到的。

       2. 模块 __name__

       每一个模块都有一个名称，在模块中可以通过语句来找出模块的名称。

       使用它处理这样一种情况：模块被第一次输入的时候，这个模块的主块将被运行，如果只想程序本身使用的时候运行主块，而在它被别的模块输入的时候不运行主块，可以通过模块的__name__属性完成。

       #/usr/bin/python
       #Filename : using_name.py

       if __name__ == '__main__':
              print 'This program is being run by itself';
       else:
              print 'I am being imported from another module';
   
       执行过程：
       $ python using_name.py
       This program is being run by itself

       $ python
       >>> import using_name
       I am being imported from another module
       >>>
       显然，如果模块名称是 '__main__'，则说明该模块是独立运行，否则不是独立运行，是被其他模块引入。

       3. 创建自己的模块

       其实每个python程序都是一个模块。一个模块与普通的python没有特别之处。只是不需要在其中调用自己的函数，进行处理而已

       自己创建的模块的位置应该放在输入它的程序同一个目录，后者在sys.path所列出的目录，只有这样python才可以找到它。

       注：注意不要将模块中声明的变量放到了函数中，一定要注意缩进。

       模块代码：
       #!/usr/bin/python
       #Filename: mymodule.py

       def sayHi():
              print 'Hi, this is mymodule speaking.';

       version = '0.1';
       #End of mymodule.py

       调用程序代码：
       #!/usr/bin/python
       #Filename: mymodule_demo.py

       import mymodule;

       mymodule.sayHi();

       print 'Version', mymodule.version;

       4. dir()函数

       dir()函数列出模块定义的标识符，标识符有函数，类和变量。如果要列出指定模块的标识符，则需要以该模块作为参数。否则列举的是当前模块中定义的名称列表。

       >>> import sys
       >>> dir(sys)
       ['__displayhook__', '__doc__', '__excepthook__', '__name__', '__package__', '__stderr__', '__stdin__',    '__stdout__', '_clear_type_cache', '_current_frames', '_getframe', '_mercurial', 'api_version', 'argv',    'builtin_module_names', 'byteorder', 'call_tracing', 'callstats', 'copyright', 'displayhook', 'dllhandle',    'dont_write_bytecode', 'exc_clear', 'exc_info', 'exc_traceback', 'exc_type', 'exc_value', 'excepthook',    'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'getcheckinterval',    'getdefaultencoding', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof',    'gettrace', 'getwindowsversion', 'hexversion', 'long_info', 'maxint', 'maxsize', 'maxunicode', 'meta_path',    'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix', 'py3kwarning', 'setcheckinterval',    'setprofile', 'setrecursionlimit', 'settrace', 'stderr', 'stdin', 'stdout', 'subversion', 'version',    'version_info', 'warnoptions', 'winver']
       >>> print sys.winver
       2.7
       >>> dir()
       ['__builtins__', '__doc__', '__name__', '__package__', 'sys']
       >>> a=3
       >>> dir()
       ['__builtins__', '__doc__', '__name__', '__package__', 'a', 'sys']
       >>> del a
       >>> dir()
       ['__builtins__', '__doc__', '__name__', '__package__', 'sys']
       >>>

       其中的dir()如上所述，del a 从模块中将a变量删除掉

10. 数据结构
  
       字面理解，数据结构——可以处理一些数据的结构，或者说是用来存储一组相关的数据。

       在Python中有三种内建的数据结构—— 列表、元组和字典。

       1. 列表
  
       列表其实类似于数组，项目之间用逗号分隔。

       列表项目包括在方括号中，一旦创建了列表，可以添加、删除或是搜索列表中的项目，因此说列表是可变的数据类型

       列表使用的一个例子：
  
       #!/usr/bin/python
       #Filename: using_list.py
       #this is my shopping list
   
       # 返回list长度
       shoplist = ['apple', 'mango', 'carrot', 'banana'];
       print 'I have', len(shoplist), 'item to purchase.';
   
       # 遍历列表元素
       print 'These item are:', #Notice the comma at end of the line
       for item in shoplist:
              print item,;
   
       # 追加元素
       print '\nI also have to by rice.';
       shoplist.append('rice');
       print 'My shopping list is now', shoplist;

       # 排序元素
       print 'I will sort my list now';
       shoplist.sort();
       print 'Sorted shopping list is', shoplist;

       # 删除元素
       print 'The first item I will buy is', shoplist[0];
       olditem = shoplist[0];
       del shoplist[0];   
       print 'I bought the', olditem;
       print 'My shopping list is now', shoplist;

       注：1. 可以在列表中添加任何类型的数据，包括数和对象，甚至列表  

       2. 在print 语句最后加一个','，可以消除print语句的自动换行功能，难看而有效

       3. sort方法对列表内容进行排序，注意不是返回一个有序列表，而是修改了原始列表

       4. 删除一个元素 del shoplist[0];

       list的其他一些功能函数：
   
       1. append(...)  L.append(object) -- 在列表末尾增加一个对象
   
       2. count(...)   L.count(value)  -- 返回值为整数，返回值在列表中出现次数

       3. extend(...)  L.extend(iterable) -- 从iterable中添加元素来扩展列表

       4. index(...)   L.index(value, [start, [stop]]) 返回值为整数，第一个value的索引值
       如果值不存在，则返回ValueError值
    
       5. insert(...)  L.insert(index, object) 在index之前插入元素
 
       6. pop(...)     L.pop([index]) -- 返回值为item，移除并返回索引值处的item
       如果索引值超出范围，或者列表为空，则返回错误IndexError
 
       7. remove(...)  L.remove(value) -- 移除value在列表中的第一次出现。
       如果值不出现在列表中，则返回错误ValueError

       8. reverse(...)  L.reverse() -- 按照位置进行翻转*IN PLACE*

       9. sort(...)     L.sort(cmp=None, key=None, reverse=False) -- 稳定的排序，按照位置 *IN PLACE*;
       cmp(x, y) -> -1, 0, 1  需要传入的对比函数，如果不使用默认的按字母顺序排序，则需要重写cmp函数，并传参

       10. __len__(...)  x.__len__() <==> len(x) 

       11. __getitem__(...)     x.__getitem__(y) <==> x[y]
 
       12. __getslice__(...)    x.__getslice__(i, j) <==> x[i:j]

       13. __delitem__(...)     x.__delitem__(y) <==> del x[y]
 
       14. __delslice__(...)    x.__delslice__(i, j) <==> del x[i:j]

11. 元组

       与列表类似，只不过与字符串类似，其值是不可变的，不可以修改元组。通过圆括号中用逗号分割项目定义。

       元组的初始化 tuple = ('item1', 'item2', ,'item3');

       其中第三个元素是空值。

       与列表相同的是，将一个元组加入到另外一个元组，就相当于在这个元组的位置处是一个二维数组

 

       使用元组实现格式化输出：

       在输出元素时，可以实现元素的格式化输出，类似于C语言的格式化输出。

       在print最后，例如print 'My string is %s, my age is %d, ...' %(item1, item2,...);

       对于单一的元素，可以这样实现：print 'My element is %s' %item

       例子：
       #!/usr/bin/python
       #Filename:print_tuple.py
    
       age = 22;
       name = 'Swaroop';
    
       print '%s is %d years old' %(name, age);
       print 'Why is %s playing with that python?' %name;

   
12. 字典

       字典类似于通过联系人名字查找地址和联系人详细情况的地址薄，即键(名字) 和值(详细情况)联系在一起。键必须是唯一的。

       字典的键必须是不变的对象，而值可以是变化的对象

       键值对在字典中以这样的方式标记：d={key1:value, key2:value2}.键/值对用冒号分割，而各个对用逗号分割。在字典中的键值对之间是没有顺序的，其实就是hash。

       例子如下：
       #!/usr/bin/python
       #Filename: using_dict.py
       #'ab' is short for 'a'ddress 'b'ook
    
       ab = {'Swaroop':'swaroopch@byteofpython.info',
              'Larry':'larry@wall.org',
              'Matsumoto':'matz@ruby-lang.org',
              'Spammer':'spammer@hotmail.com'};
    
       print "Swaroop's address is %s" %ab['Swaroop'];
    
    
       # 添加一个键值对key/value
       ab['Guido'] = 'guido@python.org';
       print "The dicionary is", ab;
    
       # 删除一个键值对key/value
       del ab['Spammer'];
       print "The dicionary is", ab;
    
       print '\nThere are %d contackts in the address-book\n' %len(ab);
    
       # 遍历字典
       for name, address in ab.items():
              print 'Contact %s at %s' %(name, address);
    
       if 'Guido' in ab:
              print "\nGuido's address is %s" %ab['Guido'];

       help(dict)中其他的方法：
       1. clear(...)   D.clear() -- 删除D中所有的元素.

       2. copy(...)    D.copy() -- 复制D a shallow copy of D

       3. get(...)     D.get(k[,d]) -- 如果k在D中，则返回D[k]，否则返回d. d默认是None

       4. has_key(...) D.has_key(k) -- 如果D有键k则返回True

       5. items(...)   D.items() -- 以2元组的形式返回D的键值对(key, value)

       6. iteritems(...)   D.iteritems() --指向(key, value)的一个迭代器

       7. iterkeys(...)    D.iterkeys() -- 指向D的键的迭代器

       8. itervalues(...)  D.itervalues() -- 指向D的值的迭代器

       9. keys(...)        D.keys() -- 返回D的键的列表

       如果没有找到键，如果给定了d值，则返回d，否则生成KeyError

       11. popitem(...)    D.popitem() -- (k, v), 移除和返回键值对(key, value)，
        如果D是空的则发挥ErrorKey错误

       12. setdefault(...) D.setdefault(k[,d]) -- 如果k不在D中，则设置D[k]=d

       13. update(...)
        D.update(E, **F) -- None. 从dict/iterable E 和 F更新D
        如果E有a.keys()方法, does:     for k in E: D[k] = E[k]
        如果E没有 .keys()方法, does:     for (k, v) in E: D[k] = v
        如果不是上述两种for k in F: D[k] = F[k]
  
13. 序列

       列表，元组和字符串其实都是序列，最主要的就是下标索引和切片操作(就是取列表的一部分数据)

       索引操作取特定项目，切片获取一列数据

       例子：
       #!/usr/bin/python
       #Filename: seq.py
    
       shoplist = ['apple', 'mango', 'carrot', 'banana'];
    
       #indexing or 'subscription' operation
       print 'Item 0 is', shoplist[0];
       print 'Item 1 is', shoplist[1];
       print 'Item 2 is', shoplist[2];
       print 'Item 3 is', shoplist[3];
       print 'Item -1 is', shoplist[-1];
       print 'Item -2 is', shoplist[-2];
    
       #Slicing on a list
       print 'Item 1 to 3 is', shoplist[1:3];
       print 'Item 2 to end is', shoplist[2:];
       print 'Item 1 to -1 is', shoplist[1:-1];
       print 'Item start to end is', shoplist[:];
    
       #Slicing on a string
       name = 'swaroop';
       print 'characters 1 to 3 is', name[1:3];
       print 'characters 2 to end is', name[2:];
       print 'characters 1 to -1 is', name[1:-1];
       print 'characters start to end is', name[:];

       结果：
       Item 0 is apple
       Item 1 is mango    
       Item 2 is carrot
       Item 3 is banana
       Item -1 is banana  # 负数下标的-1在结尾处
       Item -2 is carrot
       Item 1 to 3 is ['mango', 'carrot']   # 截取的1-3，并不包含3
       Item 2 to end is ['carrot', 'banana']
       Item 1 to -1 is ['mango', 'carrot']
       Item start to end is ['apple', 'mango', 'carrot', 'banana']
       characters 1 to 3 is wa
       characters 2 to end is aroop
       characters 1 to -1 is waroo
       characters start to end is swaroop
        
       注：1. Python从0开始计数，与C语言相同。
      
       2. 索引可以是负数，位置从序列结尾处开始计算，shoplist[-1]标识最后一个元素

14.参考(reference)

       创建一个对象，并将它赋给一个变量，这个变量仅仅参考哪个对象，并不标识这个对象本身。也就是变量名称指向你计算机中存储那个对象的内存，这被称为名称到对象的绑定。

       参考和对象的区别如下例子所示：
       #!/usr/bin/python
       #Filename: reference.py
    
       print 'Simple Assignment';
    
       shoplist = ['apple', 'mongo', 'carrot', 'banana'];
    
       mylist = shoplist; #mylist是同一个对象的另外一个名字
    
       del shoplist[0];
       print 'shoplist is', shoplist;
       print 'mylist is', mylist;    
       # shoplist和mylist打印了相同的列表，表明他们指向同一个对象

       print 'Copy by making a full slice';
       del mylist[0]; # 删除第一个元素
        
       print 'shoplist is', shoplist;
       print 'mylist is', mylist;
       # 两个列表有不同的内容。

       注：赋值语句并不赋值列表内容，只是作参考。而要拷贝，则需要使用slice功能。

       此处使用的其实都是str类对象

 

       By Andy

       转载请注明出处，谢谢！