python基础教程1

python作为一种编程语言，诞生于1990年左右，算是一门比较年轻的语言（也算是90后吧），它是面向对象的，但不同于JAVA\C#那么严格要求一切皆对象，更接近于C++，是面向过程和面向对象的结合；它是解释型语言，但是也可以编译成 .pyc 跨平台的字节码文件（由类似于JAVA 的 .class 文件，由python虚拟机来执行），.pyc 文件有几个好处，一是可以简单的隐藏源码，二是提高载入速度，三是跨平台。

编译：python -m py_compile test.py 会生成 test.pyc 文件

python -O -m py_compile test.py 会生成 test.pyo 文件，就是 .pyc 的简单优化。

批量编译一个文件夹中所有的 .py 文件，可以使用 python -m compileall dirname

在 windows 下执行 .py/.pyc 文件时，默认会有闪现一个dos窗口，如果不要这个窗口，可以将 .py/.pyc 的文件后缀改成 .pyw 即可。

其实这种改动，并没有本质上的区别，真正的区别在于 .py/.pyc 文件默认调用 python.exe 来执行，而 .pyw 文件默认调用 pythonw.exe 执行，仅此而已。（w 表示窗口）

python 也有动态链接库，如 linux 下的 .so 或 windows 下的 .dll。

可以通过 python -m pdb test.py 来调试python程序，方法基本与gdb相同。

http://www.cnblogs.com/mindsbook/archive/2009/07/19/pdb.html

python 的用武之地

由于本人并非python开发者，所知有限，欢迎补充。

1、服务器维护脚本，比 shell 脚本可强大得多。

2、服务端程序

3、胶水程序，如游戏开发中的任务脚本等

4、WEB开发，如 django \web.py 等

5、手游开发，如 cocos-2dx 就有 python 版。

6、桌面应用开发，如 wxpython等等。

7、云，如 openstack

优点：

1、代码风格优雅（见仁见智了）

2、一次编写，随处运行（这句话不是JAVA的特权）

3、即写即运行

4、由于胶水特性，性能要求高的地方可以使用c/c++来编写。

5、简单易学，所以接下来，不必紧张，请愉快的学习它吧

6、开源

7、庞大的标准库

缺点：

1、tab 与 空格带来的噩梦

2、性能，不过可以通过胶水特性弥补

3、python2 与 3之间的抉择

python脚本的第一行一般是特定的，使用 #! 开始，其后紧跟着机器python解释器的路径。在一些LINUX系统上，为了避免硬编码 python 解释器的路径，也可以这样写： #!/usr/bin/env python

通过 import 可以导入一个模块，如果那个模块可执行，则执行此模块，但是，多次 import 同个模块，只会执行一次，因为导入是一个开销很大的工作，所以第一次导入时将其编译成字节码，并且运行代码。如果希望可以再次运行模块，可以使用

import imp
import hello
imp.reload(hello)

python2.6~2.7中，reload 是内置函数，不需要导入，即这样也是可以的：

import hello
reload(hello)

reload函数的返回值是一个python模块对象。

此外，还有一种方法，借助于 exec 函数：

exec(open('hello.py').read())

但这种方法不会导入模块，而是类似于宏替换，把文件中代码粘贴进来一样，如果变量有重名，会造成覆盖。

关于 from ... import ...

from 后跟模块名，即可当模块的文件名或文件夹名（文件夹中包括 __init__.py 文件），而 import 后跟模块中的属性名或方法名等。通过 dir(模块名) 可以返回模块中所有的可用的变量名列表

IDE

交互式解释器:windows\linux

源码执行：windows\linux

与 perl\php\lua\ruby 的对比

最近的语言使用排行榜。

python是蟒蛇的意思，如华蟒的由来。

不必紧张，请保持愉快，python是一门简单且功能强大的语言。

弱类型，但是大小写敏感。

int   long  float  str  bool

字符串是不可变的

注释

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

chmod +x test.py

分号的用武之地：

python可以不使用分号，唯一必须要使用分号的场所为将多行语句写在同一行的时候，如：

i=3;j=4

但推荐一行只写一个语句。将多行写成一行是不被推荐的，但有时却需要把一行写成多行，则需要使用行连接符号 \，如：

print \
i

另外，列表、元组可以不需要行连接符号，即可拆成多行书写，如：

mytuple=(3,
4,5,)

转义符 \

同一层次的语句必须要有相同的缩进。

不要混用制表符和空格来缩进。

SyntaxError: invalid syntax

int/int == int，如 3/2 的结果是1，同 c/c++，如果要得到浮点结果，则两数字至少要有一个是浮点数，如 3.0/2 或 3/2.0 即可。也可以 from __future__ import division ，或以 python -Qnew 的方式启动python交互解释器。

关于 import 与 include

str 与 repr(``)

input 与 raw_input

原始字符串 r

------------------------------------------------

序列和映射：

列表类似于其它语言中动态可变的数组，如 c++的vector，java的 arraylist ，索引也是从0开始，但不同的是，python的列表索引还可以从反向开始，最后一个元素为-1，倒数第二个为-2……

六种序列：列表、元组、字符串、Unicode字符串、buffer对象和 xrange对象。

元组用作配置文件的情况非常常见。

通用序列操作：

分片操作，如果熟知 go 语言，会有助于理解。

字符串是不可变的，更类似于 tuple。

格式化字符串，%s,%d,%f,%%

模板字符串

print 'ab','cd'    会输出 ab cd，中间会自带空格，如果不需要空格  print 'ab','\bcd' 即可，或 print 'ab'+'cd'

i = int()   --> i = 0

b = bool()   --> b = False

强制类型转换

str\unicode\basestring

print isinstance('a',basestring)　　仅适用于 str 和 unicode

下面不仅适用于str和unicode,且适用于 UserString ,不过比较慢

def isStringLike(obj):
    try:obj+''
    except:return False
    else: return True

print isStringLike(3)

闭包：

http://blog.csdn.net/marty_fu/article/details/7679297

dict的 copy 与 deepcopy

print 语句默认会在输出信息后加上换行符，如果不需要换行，则可以在行尾加上一个逗号，如：

print 'hello,',
print 'world'

序列解包：

x,y,z = 1,2,3

x,y = y,x

values = 1,2,3

x,y,z = values

FALSE:

False/None/0/''/()/[]/{}

比较运算符可以连在一起使用，如 0<age<100

is / is not

and / or 代替 &&/|| ，短路逻辑。没有 & / | 的非短路版本。

assert

没有类C语言的for循环语句，只有 for ... in 循环，类似于其它语言的 foreach

zip 并行迭代。

编号迭代。

翻转 reversed、排序迭代 sorted。

循环：while,for,列表推导式

其它语言用一个分号表示空语句，python使用 pass

exec/eval

命名空间：http://www.cnblogs.com/windlaughing/archive/2013/05/26/3100362.html

return 返回None，一般用来表示函数结束

默认参数传递是值传递，参数如果是列表，在函数内部操作列表索引，就可达到引用传递的效果，（但如果想整个给列表赋新值，也是不可以的。貌似传进来的参数，不能直接做为左值，否则就是新的变量）如：

def fun(lt):
    lt[0]=3

mylt = [1,2,3,4]
fun(mylt)
print mylt

所以如果想改变参数，可以把值放在列表中。

关键字参数和默认值

可变参数 */**，前者用元组，表示可变的位置参数，jj后者用字典，表示可变的关键字参数

globals()["i"]  来引用全局变量 i

kkk

一些有意思的函数：

map/filter/reduce/sum/apply

关于 Unicode / utf-8 / ascii 编码：

http://blog.renren.com/share/68464/3096404244

http://wenku.baidu.com/link?url=2EE55MZiNreqM_fdh44k7o8fKweZ1GhPzotnL3nPRXytXJsXJhzkAOY91zUxAJZiVtj3Rrao6E7d-xnIz_owai7sx24L7KgJK1X52P-Rw1_

http://blog.163.com/longsu2010@yeah/blog/static/173612348201173115733728/

import types

dir(types) 可以查看所有类型

import exceptions

dir(exceptions)  可以查看所有异常

dir(dict)　可以查看所有字典方法与属性

help(dict)  可以查看所有字典方法 （详细）

help(dict.pop)　　可以查看指定方法或属性

x,y,z = 1,2,3

这种赋值称为多元赋值，左边当作元组，右边也当作元组。等同于 (x,y,z) = (1,2,3)

面向对象：

class A(object):
    count = 0

    def __init__(self,name):
        self.name = name
        self.__class__.count += 1
        print '__init__'
        print 'count:',self.__class__.count

    def __del__(self):
        print '__del__'
        self.__class__.count -= 1

    def msg(self):
        print self.name

    @staticmethod
    def get_count1():
        print 'staticmethod:',A.count

    @classmethod
    def get_count2(cls):
        print 'classmethod:',cls.count

class B(A):
    def __init__(self,name,age):
        super(self.__class__,self).__init__(name)
        self.age = age

    def msg(self):
        print self.name,self.age

a1 = A('a1')
a1.msg()
del a1
a2 = A('a2')
a2.msg()
print '----------------'
b1 = B('b1',18)
b1.msg()
A.get_count2()
A.get_count2()

@classmethod 的第一个参数是 cls，因此可以访问类变量，或是用作类工厂，而 @staticmethod 除了自身代码是位于类里面之外，对类的情况一无所知；@staticmethod 只适用于不想定义全局函数的情况。两者能做的事几乎一样，区别是更明晰的暴露使用意图，为了有更好的编程风格。

新式类和旧式类

python的新式类是2.2版本引进来的，我们可以将之前的类叫做经典类或者旧类。

为什么要在2.2中引进new style class呢？官方给的解释是：

为了统一类(class)和类型(type)。

在2.2之前，比如2.1版本中，类和类型是不同的，如a是ClassA的一个实例，那么a.__class__返回 ‘ class    __main__.ClassA‘ ，type(a)返回总是<type 'instance'>。而引入新类后，比如ClassB是个新类，b是ClassB的实例，b.__class__和type(b)都是返回‘class '__main__.ClassB' ，这样就统一了。

引入新类后，还有其他的好处，比如更多的内置属性将会引入，描述符的引入，属性可以来计算等等。

为了向前兼容，默认情况下用户定义的类为经典类，新类需要继承自所有类的基类 object 或者继承自object的新类。

值得注意的地方是，虽然使用的是最新的python（2.7），但是一些特性不会在旧式类起作用。
所以，为了确保自己使用的是新式类，有以下方法：

1. 把这个赋值语句放在类模块代码的最前面 __metaclass__ = type（前面有提过）。
2. 自己的类都从内建类object直接或者间接地继承。

如果不需要兼容旧式类，旧版本的类，那么就保持都是新式类。
当然，在Python3里面，不存在这些问题了，因为所有的类都是object类的子类（隐式）。

类实现迭代器如下：

#coding:utf-8
class Odd(object):
    val,i = 1,1
    def __init__(self,num,count=0):
        self.num = num
        self.count = count
    def next(self):
        if self.__class__.val > self.num:
            raise StopIteration #只能使用这句才能退出循环
        if self.count != 0 and self.__class__.i > self.count:
            raise StopIteration
        ret = self.__class__.val
        self.__class__.val += 2
        self.__class__.i += 1
        return ret

    def __iter__(self):
        return self

#print list(Odd(100,3))
#for item in Odd(100,3):print item
while True:
    try:
        print Odd(100,3).next()
    except StopIteration:
        break        

关于生成器，也是一种特殊的迭代器

#coding:utf-8
def odd(num,count=0):
    val,i = 1,1
    while val <= num:
        yield val
        val += 2
        i += 1
        #生成器退出的三种情况：
        #1、执行到函数末尾，如此处的 val>num 时
        #2、执行到 return 语句
        #3、抛出 StopIteration 异常
        if count != 0:
            if i>count:
                return
                #raise StopIteration

for i in odd(100):
    print(i)
print list(odd(100,3))
fun = odd(100,4)
while True:
    try:
        print fun.next()
    except StopIteration:
        break

将一段字符串中指定字符替换成指定字符：

s1 = ''
s2 = ''
s = ''

print ''.join(dict(zip(list(s1),list(s2))).get(c,c) for c in s)

import string
print string.translate(s,string.maketrans(s1,s2))

import re
print re.sub('.',lambda m: dict(zip(list(s1),list(s2))).get(m.group(),m.group()),s)

第三种方法，目前暂不熟练。

try...except...else...finally

else子句是当没有捕捉到异常时执行的语句，表示正常运行。

finally是不管有没有捕捉到异常都必然执行的语句

如果 except 后面没有跟上指定异常（或异常元组），则默认为全捕捉，这是很危险的，因为它也会捕捉语法或书写方面的异常，如 AttributeError 、 IndentationError 和SyntaxError。

不同于C/C++，python的赋值语句不能做为表达式，即没有返回值。

python3.2教程：

http://docspy3zh.readthedocs.org/en/latest/tutorial/index.html