python 基础指南

1.基础

应用领域

Web
爬虫
科学计算
机器学习
自动化测试
系统运维

三个内置：type help dir

type(a)
help(time)
dir(linecache)  找到模块的内置方法

python 先将脚本编译成字节码（pyc,pyo）
python 虚拟机解释并运行字节码文件

编码

python 2.x中默认的编码格式是 ASCII 格式
Python3.X 源码文件默认使用utf-8编码，所以可以正常解析中文，无需指定 UTF-8 编码
python 2.x中在文件开头加入 # -*- coding: UTF-8 -*- 或者 #coding=utf-8 就行了
#-*-coding:UTF-8-*-
打印 : print(json.dumps(station_time_info, encoding="UTF-8", ensure_ascii=False))

标识符

在 Python 里，标识符由字母、数字、下划线组成。
在 Python 中，所有标识符可以包括英文、数字以及下划线(_)，但不能以数字开头。
Python 中的标识符是区分大小写的。
以下划线开头的标识符是有特殊意义的。
Python 可以同一行显示多条语句，方法是用分号 ;

多行连接符

使用斜杠将一行的语句分为多行显示;
total = item_one + \
 item_two + \
 item_three
语句中包含 [], {} 或 () 括号就不需要使用多行连接符

Python引号

Python 可以使用引号( ' ' )、双引号( " ")、三引号( ''' '''或 """ """ ) 来表示字符串，引号的开始与结束必须的相同类型的。
其中三引号可以由多行组成，编写多行文本的快捷语法，常用于文档字符串，在文件的特定地点，被当做注释。
word = 'word'
sentence = "这是一个句子。"
paragraph = """这是一个段落。
包含了多个语句"""

Python注释

单行注释采用 # 开头
多行注释使用三个单引号(''' ''')或三个双引号(""" """)

Python空行

    函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。
空行与代码缩进不同，空行并不是Python语法的一部分。书写时不插入空行，Python解释器运行也不会出错。但是空行的作用    在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。
记住：空行也是程序代码的一部分

Print 输出

   print 默认输出是换行的，如果要实现不换行需要在变量末尾加上逗号 ,
   # 不换行输出
    print x,
    print y,

    # 不换行输出
    print x,y

变量

Python 中的变量赋值不需要类型声明。
每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。
每个变量在使用前都必须赋值，变量在赋值以后该变量才会被创建
 counter = 100 # 赋值整型变量
 miles = 1000.0 # 浮点型
 name = "John" # 字符串

    可以为多个对象指定多个变量
a, b, c = 1, 2, "john" #两个整型对象1和2的分配给变量 a 和 b，字符串对象 "john" 分配给变量 c

查看数据对象的引用计数
import sys
sys.getrefcount(“dddd”)

五个标准的数据类型

    Numbers（数字） int（有符号整型） long（长整型[也可以代表八进制和十六进制]） float（浮点型） complex（复数）
    String（字符串）
    List（列表）
    Tuple（元组）
    Dictionary（字典）

判断类型

isinstance(num1,int)  返回boolean类型

转换

str(x ) 将对象 x 转换为字符串
list(s ) 将序列 s 转换为一个列表
chr(x ) 将一个整数转换为一个字符
int(x [,base])  将x转换为一个整数
tuple(s)  将序列 s 转换为一个元组
dict(d)  创建一个字典。d 必须是一个序列 (key,value)元组

数字

-786   0122L   -21.9   9.322e-36j
bin(4)  ->转成二进制0b100
int(0b100) ->十进制整数4
奇偶数  if( a&1>0) 奇数

元组

有序（即支持切边和索引操作）的集合 不可变的
元组是另一个数据类型，类似于List（列表）。
元组用"()"标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表

集合

 无序的
可变的set() 不可变的frozenset()
    add update remove  in not in 交集 并集 差集 & set去重
    a = set(‘abc’)  a实际上是 a  b  c 三个元素组成的集合
    add(‘domain’)   a domain b c  四个元素
    update(”zhu“)  a z domain h b u c 七个元素
    remove(”a“)   z domain h b u c 六个元素  如果没有会抛异常


a = set(‘abc’)
b = set(‘abd’)
交集 a & b
并集 a|b
差集 a-b
去重
c = [1,1,2,3] 
list(set(c)) -> [1,2,3]
print a

字典

列表是有序的对象集合，字典是无序的对象集合 两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取 字典用"{ }"标识。字典由索引(key)和它对应的值value组成。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
          
tinydict = {'name': 'john','code':6734, 'dept': 'sales'}  创建方式一
tinydict2 = dict(name=”你好“,age=’nihoa’)   创建方式二
tinydict['one'] = "This is one"   赋值
tinydict.update({'code':67344444,'c':44})    更新 相同的键覆盖 新的键就添加进去了
tinydict.pop('code')  移除
tinydict.pop('code',’M040002’)  如果没有key code 则返回’M040002’
备注列表的pop方法 参数是序列号  如果没有会抛异常

‘aa’ in tinydict  成员关系
tinydict.has_key(‘aa')  成员关系


del tinydict['Name']; # 删除键是'Name'的元素
del tinydict; # 删除词典
tinydict.clear(); # 清空词典所有条目

print tinydict['one'] # 输出键为'one' 的值
print tinydict # 输出完整的字典
print tinydict.keys() # 输出所有键
print tinydict.values() # 输出所有值

遍历迭代：
a = {'a':'haha','c':'ccc','d':'ddd','h':'hhh'}
for x,y in a.items():
        print x,y
   
   特性；
    1.不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
    2.键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行

运算符

/   除 - x除以y    b / a 输出结果 2
//  取整除 - 返回商的整数部分  9//2 输出结果 4 , 9.0//2.0 输出结果 4.0
%   取模 - 返回除法的余数    b % a 输出结果 0
**  幂 - 返回x的y次幂 a**b 为10的20次方， 输出结果 100000000000000000000

成员运算符 in not in
    a = 10
    b = 20
    list = [1, 2, 3, 4, 5 ];
    
    if ( a in list ):
     print ""
    else:
     print ""

身份运算符 比较两个对象的存储单元
    is  is 是判断两个标识符是不是引用自一个对象   x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
    is not  is not 是判断两个标识符是不是引用自不同对象   x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。
    注： id() 函数用于获取对象内存地址。

is 与 == 区别

is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。

python复合布尔表达式计算采用短路规则
and or

print语句

print(‘1111’)  默认换行
print(‘1111’), 不换行
f = open(‘print.txt’,’w’)
print >> f,”hahahha”  输出到文件中
f.close()

条件语句

and or  从左到右 and和or 优先级相同
is(是否引用同一个数据对象)
== 比较值是否相等
not 反转boolen值 
任何非0和非空（None）值为true，0 或者 None为false
    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' # 条件均不成立时输出

三元

print 4 if True else 3 不建议

循环语句

while

    count = 0
    while count < 5:
     print count, " is less than 5"
     count = count + 1
    else:
     print count, " is not less than 5"

for

    for letter in 'Python': # 第一个实例
             print '当前字母 :', letter
    
    fruits = ['banana', 'apple', 'mango']
	for fruit in fruits: # 第二个实例
	  print '当前水果 :', fruit
   else：
	  print ‘meiyoufruit’

       备注 ：fruit 保留最后一个迭代值
	print fruit 为mango

pass 语句

   pass是空语句，是为了保持程序结构的完整性。pass 不做任何事情，一般用做占位语句。
   for letter in 'Python':
   if letter == 'h':
   pass
   print '当前字母 :', letter   

三引号

    errHTML = '''
    <HTML><HEAD><TITLE>
    Friends CGI Demo</TITLE></HEAD>
    <BODY><H3>ERROR</H3>
    <B>%s</B><P>
    <FORM><INPUT TYPE=button VALUE=Back
    ONCLICK="window.history.back()"></FORM>
    </BODY></HTML>
    '''
    cursor.execute('''
    CREATE TABLE users (
    login VARCHAR(8),
    uid INTEGER,
    prid INTEGER)
    ''')

函数

    # 定义函数
    def printme( str ):
     "打印任何传入的字符串"
     print str;
     return;

filter

语法 ：filter(function, iterable)

 data = [3,6,7,1,-1,-5,90]
 data = filter(lambda x:x>=0,data)

lambda

d = lambda x:x+1
d = lambda x:x+1 if x>0
print d(2)

可更改(mutable)与不可更改(immutable)对象

     在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

不可变类型 与可变类型

   不可变类型：变量赋值 a=5 后再赋 值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
   可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python 函数的参数传递

  不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。

   可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

必备参数

    #可写函数说明
    def printme( str ):
     "打印任何传入的字符串"
     print str;
     return;

 调用printme()函数，你必须传入一个参数，不然会出现语法错误

关键字参数
    #可写函数说明
    def printinfo( name, age ):
     "打印任何传入的字符串"
     print "Name: ", name;
     print "Age ", age;
     return;
    
    #调用printinfo函数
    printinfo( age=50, name="miki" );

缺省参数

    #可写函数说明
    def printinfo( name, age = 35 ):
     "打印任何传入的字符串"
     print "Name: ", name;
     print "Age ", age;
     return;
    
    #调用printinfo函数
    printinfo( name="miki" );

不定长参数

def test(**kr): 
return kr
test(c=1,a=3,b=3)   会返回一个字典

def test(*kr):
return kr
test(1,4,5,6,3)  会返回一个元组

       #!/usr/bin/python
        # -*- coding: UTF-8 -*-
        
        # 可写函数说明
        def printinfo( arg1, *vartuple ):
                 "打印任何传入的参数"
                 print "输出: "
                print arg1

        for var in vartuple:
                print var
                 return;
        
        # 调用printinfo 函数
        printinfo( 10 );
        printinfo( 70, 60, 50 );
        以上实例输出结果：

        输出:
        10
        输出:
        70
        60
        50

匿名函数

# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2;

# 调用sum函数
print "相加后的值为 : ", sum( 10, 20 )

函数的返回值

return a,b,c,d   #返回的是一个元组

断言

assert add(1,2) ==3,error信息
断言失败了 会同时打印error信息
开发环境下 先断言绝对不能发生的错误 然后再处理断言

全局变量和局部变量

#如果要给函数内的全局变量赋值，必须使用 global 语句。
#

globals() 和 locals() 函数

#如果在函数内部调用 locals()，返回的是所有能在该函数里访问的命名。
#如果在函数内部调用 globals()，返回的是所有在该函数里能访问的全局名字。
global aa
aa = 11

def test():
        global  aa
        aa = 22
        return 'dd'
test()
print aa

reload() 函数

#重载 hello 模块
reload(hello)

模块

#模块(Module)，是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句

support.py 模块：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
‘’‘
这是__doc__属性要输出的东西
’‘’
    def print_func( par ):
     print "Hello : ", par
     return

test.py 文件代码：
    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
    
    # 导入模块
    import support
    
    # 现在可以调用模块里包含的函数了
    support.print_func("Runoob")

print support.__doc__

    #要导入模块 fib 的 fibonacci 函数，使用如下语句：
    from fib import fibonacci

    #把一个模块的所有内容全都导入到当前的命名空间也是可行的
    from modname import *

# 导入内置math模块
    import math
    content = dir(math)
    print content;

    输出结果:
        ['__doc__', '__file__', '__name__', 'acos', 'asin', 'atan',
        'atan2', 'ceil', 'cos', 'cosh', 'degrees', 'e', 'exp',
        'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log',
        'log10', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh',
        'sqrt', 'tan', 'tanh']

常用模块

pypi.python.org
docs.python.org/2.7/library/msvcrt.html

urllib urllib2 抓取 网页的内容

d= urllib.urlopen(“http://www.baidu.com”)
content = d.read()

os 模块 处理系统

import os
os.system(“ls -l”)  直接执行linux 命令行

pickle 模块 对象序列化

常用的数据交换格式 json xml
import pickle

logging 日志 模块

bsddb 模块

Python中的包

#包就是文件夹，但该文件夹下必须存在 __init__.py 文件, 该文件的内容可以为空。__int__.py用于标识当前文件夹是一个包。
__init__.py 中 如果定义了__all__=[]  表明该包下那些模块可以被引用

引用的时候不在一个路径下面 使用
import sys
sys.path.append(‘/tmp/m’) 
import m1

xrange

xrange返回的是一个生成器 对生成器进行迭代时，元素是逐个被创建的
 for i in xrange(0, 100):
        print i

正则表达式

[0-9] 或者 \d 全部数字

\w 单词类字符 a-z A-Z 0-9 _
\W 非单词类字符

{2}  {n}  前面的表达式匹配n次
{0,2} {m,n} 前面的表达式匹配m到n次

+ 前面的表达式，出现1到无限次  最少，出现1次
? 前面的表达式，出现0到1次  最多，出现1次
* 前面的表达式，出现0到无限次 出现不出现，都没关系
^a  匹配的字符串开头为a

python 模块re

import re
判断是否都是数字:re.match(r’\d’,’1223ee’) 如果不匹配返回None 否者返回一个对象
判断是否只有一个数字 re.match(r’\d$’,’4’) 返回一个对象
判断是否多个数字 re.match(r’\d+$’,’34444’)    返回一个对象

a = ’a1b2b3n45n6’
re.split(r’\d’,e)  返回一个list 里面全部是字母

集合

a = set('abc')
b = set('abd')
交集 a & b
并集 a|b
差集 a-b
去重
c = [1,1,2,3] 
list(set(c)) -> [1,2,3]