Python学习

1，特殊规定

• 缩进：没有{}，通过缩进控制模块范围。所有缩进一致即可，一般采用4个空格

• 多行分隔符：斜杠（ \），将一行代码分多行显示。语句中包含 [], {} 或 () 括号就不需要使用多行连接符。

total = item_one           item_two           item_three

• 引号：使用引号( ’ )、双引号( " )、三引号( ‘’’ 或 “”" ) 来表示字符串。其中三引号可以由多行组成，编写多行文本的快捷语法，常用于文档字符串，在文件的特定地点，被当做注释。

paragraph = """这是一个段落。
包含了多个语句"""

• 注释：#号开头或者使用三个单引号(’’’)或三个双引号(""")进行多行注释。

'''
这是多行注释，使用单引号。
这是多行注释，使用单引号。
'''

"""
这是多行注释，使用双引号。
这是多行注释，使用双引号。
"""

2，中文编码

Python2中默认的编码格式是 ASCII 格式，在没修改编码格式时无法正确打印汉字。

#!/usr/bin/python
# -*- coding: UTF-8 -*-

Python3.X 源码文件默认使用utf-8编码，所以可以正常解析中文，无需指定 UTF-8 编码。

3，输入输出

1）输入

raw_input

从标准输入读取一个行，并返回一个字符串（去掉结尾的换行符）：

username = raw_input("请输入账户:")

input

与raw_input类似，但是input 可以接收一个Python表达式作为输入，并将运算结果返回。

#!/usr/bin/python
# -*- coding: UTF-8 -*- 
 
str = input("请输入：")
print "你输入的内容是: ", str

结果：

请输入：[x*5 for x in range(2,10,2)]
你输入的内容是:  [10, 20, 30, 40]

密文输入

    # Author:dancheng
    //导入密码密文文件
    import getpass
    password = getpass.getpass("password:");
    print(password)

2）输出：print

counter = 100 # 赋值整型变量
print ("Hello, Python!")
print counter

3）File 对象方法

file 对象提供了操作文件的一系列方法。

open（打开文件）

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
# 打开一个文件
fo = open("foo.txt", "w")
print "文件名: ", fo.name
print "是否已关闭 : ", fo.closed
print "访问模式 : ", fo.mode
print "末尾是否强制加空格 : ", fo.softspace  #file.softspace 如果用print输出后，必须跟一个空格符，则返回false。否则返回true。

file object = open(file_name [, access_mode][, buffering])

access_mode：打开文件的模式：只读，写入，追加等。这个参数是非强制的，默认文件访问模式为只读®。

模式	描述
t	文本模式 (默认)。
x	写模式，新建一个文件，如果该文件已存在则会报错。
b	二进制模式。
	打开一个文件进行更新(可读可写)。
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。rb是以二进制格式打开一个文件用于只读。=
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。=
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。

buffering：如果buffering的值被设为0，就不会有寄存。如果buffering的值取1，访问文件时会寄存行。如果将buffering的值设为大于1的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。

close()

File 对象的 close（）方法刷新缓冲区里任何还没写入的信息，并关闭该文件，这之后便不能再进行写入。

当一个文件对象的引用被重新指定给另一个文件时，Python 会关闭之前的文件。用 close（）方法关闭文件是一个很好的习惯。

write()

可将任何字符串写入一个打开的文件。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。

write()方法不会在字符串的结尾添加换行符(’\n’)：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
# 打开一个文件
fo = open("foo.txt", "w")
fo.write( "www.runoob.com!\nVery good site!\n")
 
# 关闭打开的文件
fo.close()

read()

read（）方法从一个打开的文件中读取一个字符串。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
# 打开一个文件
fo = open("foo.txt", "r ")
str = fo.read(10)
print "读取的字符串是 : ", str   #输出：www.runoob
# 关闭打开的文件
fo.close()

文件定位

tell()方法告诉你文件内的当前位置, 换句话说，下一次的读写会发生在文件开头这么多字节之后。

seek（offset [,from]）方法改变当前文件的位置。Offset变量表示要移动的字节数。From变量指定开始移动字节的参考位置。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
# 打开一个文件
fo = open("foo.txt", "r ")
str = fo.read(10)
print "读取的字符串是 : ", str
 
# 查找当前位置
position = fo.tell()
print "当前文件位置 : ", position
 
# 把指针再次重新定位到文件开头
position = fo.seek(0, 0)
str = fo.read(10)
print "重新读取字符串 : ", str
# 关闭打开的文件
fo.close()

4）OS 对象方法

提供了处理文件及目录的一系列方法。

rename()

#!/usr/bin/python
# -*- coding: UTF-8 -*-

import os
 
# 重命名文件test1.txt到test2.txt。
os.rename( "test1.txt", "test2.txt" )

remove()

#!/usr/bin/python
# -*- coding: UTF-8 -*-

import os
 
# 删除一个已经存在的文件test2.txt
os.remove("test2.txt")

mkdir()

#!/usr/bin/python
# -*- coding: UTF-8 -*-

import os
 
# 创建目录test
os.mkdir("test")

chdir()：改变当前的目录

#!/usr/bin/python
# -*- coding: UTF-8 -*-

import os
 
# 将当前目录改为"/home/newdir"
os.chdir("/home/newdir")

getcwd()

显示当前的工作目录。

#!/usr/bin/python
# -*- coding: UTF-8 -*-

import os
 
# 给出当前的目录
print os.getcwd()

rmdir()

删除目录，目录名称以参数传递。

#!/usr/bin/python
# -*- coding: UTF-8 -*-

import os
 
# 删除”/tmp/test”目录
os.rmdir( "/tmp/test"  )

os.path.exists

检验文件、路径是否存在。

import os
os.path.exists(test_file) #test_file可以是文件或路径
#True

4，数据类型

Python有五个标准的数据类型：

1）Numbers（数字）

不可改变的数据类型，这意味着改变数字数据类型会分配一个新的对象。
包括4种：int（有符号整型），long（长整型[也可以代表八进制和十六进制]，以L结尾），float（浮点型），complex（复数） 。

long 类型只存在于 Python2.X 版本中，在 2.2 以后的版本中，int 类型数据溢出后会自动转为long类型。在 Python3.X 版本中 long 类型被移除，使用 int 替代。

2）String（字符串）

python的字串列表有2种取值顺序:

从左到右索引默认0开始的
从右到左索引默认-1开始的

str = 'Hello World!'
print str[0]        # 输出字符串中的第一个字符
print str[2:5]      # 输出字符串中第三个至第六个之间的字符串
print str[2:]       # 输出从第三个字符开始的字符串
print str * 2       # 输出字符串两次
print str   "TEST"  # 输出连接的字符串

3）List（列表）

语法和字符串一致。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']
 
print list               # 输出完整列表
print list[0]            # 输出列表的第一个元素
print list[1:3]          # 输出第二个至第三个元素 
print list[2:]           # 输出从第三个开始至列表末尾的所有元素
print tinylist * 2       # 输出列表两次
print list   tinylist    # 打印组合的列表

4）Tuple（元组）

元组用 () 标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
tinytuple = (123, 'john')
 
print tuple               # 输出完整元组
print tuple[0]            # 输出元组的第一个元素
print tuple[1:3]          # 输出第二个至第四个（不包含）的元素 
print tuple[2:]           # 输出从第三个开始至列表末尾的所有元素
print tinytuple * 2       # 输出元组两次
print tuple   tinytuple   # 打印组合的元组

list( tup ) 元组转列表

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
aTuple = (123, 'xyz', 'zara', 'abc');
aList = list(aTuple)
 
print "列表元素 : ", aList

5）Dictionary（字典）

两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典用"{ }"标识。字典由索引(key)和它对应的值value组成。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"
 
tinydict = {'name': 'john','code':6734, 'dept': 'sales'}
 
 
print dict['one']          # 输出键为'one' 的值:  This is one
print dict[2]              # 输出键为 2 的值: This is two
print tinydict             # 输出完整的字典
print tinydict.keys()      # 输出所有键:['dept', 'code', 'name']
print tinydict.values()    # 输出所有值

6）数据类型转换

函数	描述
int(x [,base])	将x转换为一个整数
long(x [,base] )	将x转换为一个长整数
float(x)	将x转换到一个浮点数
complex(real [,imag])	创建一个复数
str(x)	将对象 x 转换为字符串
repr(x)	将对象 x 转换为表达式字符串
eval(str)	用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s)	将序列 s 转换为一个元组
list(s)	将序列 s 转换为一个列表
set(s)	转换为可变集合
dict(d)	创建一个字典。d 必须是一个序列 (key,value)元组。
frozenset(s)	转换为不可变集合
chr(x)	将一个整数转换为一个字符
unichr(x)	将一个整数转换为Unicode字符
ord(x)	将一个字符转换为它的整数值
hex(x)	将一个整数转换为一个十六进制字符串
oct(x)	将一个整数转换为一个八进制字符串

5，运算符

除了通用的运算符，下面为一些python特有的运算。

运算符	描述	实例
**	幂 - 返回x的y次幂	a=10，b=20;a**b 输出结果为10的20次方
//	取整除 - 返回商的整数部分（向下取整）	9//2 输出为4；-9//2 输出为-5

成员运算符：in（not in)

如果在指定的序列中找到值返回 True，否则返回 False。

a = 10
list = [1, 2, 3, 4, 5 ];
 
if ( a in list ):
   print "1 - 变量 a 在给定的列表中 list 中"

身份运算符：is（is not）

is 是判断两个标识符是不是引用自一个对象。
x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False。

6，结构性语句

1）if-else

#!/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'     # 条件均不成立时输出

2）while-else

count = 0
while (count < 9):
   print 'The count is:', count
   count = count   1

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

3）for-else

else用法和while一致。

for letter in 'Python':     # 第一个实例
   print '当前字母 :', letter

4）break，continue，pass

pass是空语句，是为了保持程序结构的完整性，一般用于占位。

7，日期和时间

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
import time;  # 引入time模块
 
ticks = time.time()   #输出：1459994552.51
localtime = time.localtime(time.time())  #输出：time.struct_time(tm_year=2016, tm_mon=4, tm_mday=7, tm_hour=10, tm_min=3, tm_sec=27, tm_wday=3, tm_yday=98, tm_isdst=0)

localtime = time.asctime( time.localtime(time.time()) ) #格式化时间输出：Thu Apr  7 10:05:21 2016
print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) # 格式化成2016-03-20 11:45:39形式

8，函数

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
# 定义函数
def printme( str ):
   "打印任何传入的字符串"
   print str
   return
 
# 调用函数
printme("我要调用用户自定义函数!")

9，模块（Module）

Module是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。

1）使用

support.py 模块：

def print_func( par ):
   print "Hello : ", par
   return

test.py 文件代码：

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

或者：

from fib import print_func
print_func("Runoob")

或者：

from modname import *

2）搜索路径

当你导入一个模块，Python 解析器对模块位置的搜索顺序是：

1、当前目录
2、如果不在当前目录，Python 则搜索在 shell 变量 PYTHONPATH 下的每个目录。
3、如果都找不到，Python会察看默认路径。UNIX下，默认路径一般为/usr/local/lib/python/。

模块搜索路径存储在 system 模块的 sys.path 变量中。

在import模块之前可以手动导入模块路径：

CWD = os.path.dirname(__file__)
sys.path.append(os.path.abspath(os.path.join(CWD, "./common")))

10，异常处理

python提供了两个非常重要的功能来处理python程序在运行中出现的异常和错误：

1）异常处理

异常即是一个事件，该事件会在程序执行过程中发生，影响了程序的正常执行。
一般情况下，在Python无法正常处理程序时就会发生一个异常。
异常是Python对象，表示一个错误。
当Python脚本发生异常时我们需要捕获处理它，否则程序会终止执行。

try/except（捕捉异常）

#!/usr/bin/python
# -*- coding: UTF-8 -*-

try:
    fh = open("testfile", "w")
    fh.write("这是一个测试文件，用于测试异常!!")
except IOError:  # 如果不写IOError，表示捕获所有异常
    print "Error: 没有找到文件或读取文件失败"
else:
    print "内容写入文件成功"
    fh.close()

try-finally

无论是否发生异常都将执行最后的代码。

#!/usr/bin/python
# -*- coding: UTF-8 -*-

try:
    fh = open("testfile", "w")
    fh.write("这是一个测试文件，用于测试异常!!")
finally:
    print "Error: 没有找到文件或读取文件失败"

raise触发异常

def functionName( level ):
    if level < 1:
        raise Exception("Invalid level!", level)
        # 触发异常后，后面的代码就不会再执行

用户自定义异常

自定义异常类如下：

class Networkerror(RuntimeError):
    def __init__(self, arg):
        self.args = arg

使用：

try:
    raise Networkerror("Bad hostname")
except Networkerror,e:
    print e.args

2）断言(Assertions)

11，面向对象-类

1）创建类

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
class Employee:
   '所有员工的基类'
   empCount = 0
 
   def __init__(self, name, salary): # __init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法
      self.name = name
      self.salary = salary
      Employee.empCount  = 1
   
   def displayCount(self):# self 代表类的实例，self 在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。这也是类方法与普通方法的区别。self 代表的是类的实例，代表当前对象的地址，而 self.__class__ 则指向类
     print "Total Employee %d" % Employee.empCount
 
   def displayEmployee(self):
      print "Name : ", self.name,  ", Salary: ", self.salary

类的实例化：

"创建 Employee 类的第一个对象"
emp1 = Employee("Zara", 2000)
emp1.displayEmployee() #访问类方法

print "Employee.__doc__:", Employee.__doc__ #类的文档字符串 输出：所有员工的基类
print "Employee.__name__:", Employee.__name__  #类名 
print "Employee.__module__:", Employee.__module__ # 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod） 
print "Employee.__bases__:", Employee.__bases__ #类的所有父类构成元素（包含了一个由所有父类组成的元组） 
print "Employee.__dict__:", Employee.__dict__  #类的属性（包含一个字典，由类的数据属性组成） 

2）对象销毁(垃圾回收)

Python 的垃圾收集器实际上是一个引用计数器和一个循环垃圾收集器。作为引用计数的补充， 垃圾收集器也会留心被分配的总量很大（及未通过引用计数销毁的那些）的对象。 在这种情况下， 解释器会暂停下来， 试图清理所有未引用的循环。

析构函数 del

在对象销毁的时候被调用，当对象不再被使用时运行。

class Point:
   def __init__( self, x=0, y=0):
      self.x = x
      self.y = y
   def __del__(self):
      class_name = self.__class__.__name__
      print class_name, "销毁"

3）继承

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
class Parent:        # 定义父类
   parentAttr = 100
   def __init__(self):
      print "调用父类构造函数"
 
   def parentMethod(self):
      print '调用父类方法'
 
   def setAttr(self, attr):
      Parent.parentAttr = attr
 
   def getAttr(self):
      print "父类属性 :", Parent.parentAttr
 
class Child(Parent): # 定义子类
   def __init__(self):
      print "调用子类构造方法"
 
   def childMethod(self):
      print '调用子类方法'
 
c = Child()          # 实例化子类
c.childMethod()      # 调用子类的方法
c.parentMethod()     # 调用父类方法
c.setAttr(200)       # 再次调用父类的方法 - 设置属性值
c.getAttr()          # 再次调用父类的方法 - 获取属性值

• 在调用基类的方法时，需要加上基类的类名前缀，且需要带上 self 参数变量。区别在于类中调用普通函数时并不需要带上 self 参数

• Python 总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。

• 同样也支持方法重载，运算符重载

4）类属性与方法

类的私有属性（__private_attrs）

两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

类的私有方法（__private_method）

两个下划线开头，声明该方法为私有方法，不能在类的外部调用。在类的内部调用 self.__private_methods

系统方法（foo）

头尾双下划线方法，定义的是特殊方法，一般是系统定义名字 ，类似 init() 之类的。

protected变量（_foo）:

以单下划线开头，只能允许本身与子类进行访问，不能用于 from module import *

12，db通信

13，网络通信

socket通信

服务器端

#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 文件名：server.py
 
import socket               # 导入 socket 模块
 
s = socket.socket()         # 创建 socket 对象
host = socket.gethostname() # 获取本地主机名
port = 12345                # 设置端口
s.bind((host, port))        # 绑定端口
 
s.listen(5)                 # 等待客户端连接
while True:
    c,addr = s.accept()     # 建立客户端连接
    print '连接地址：', addr
    c.send('欢迎访问菜鸟教程！')
    c.close()                # 关闭连接

客户端

#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 文件名：client.py
 
import socket               # 导入 socket 模块
 
s = socket.socket()         # 创建 socket 对象
host = socket.gethostname() # 获取本地主机名
port = 12345                # 设置端口号
 
s.connect((host, port))
print s.recv(1024)
s.close()

14，多线程

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
import thread
import time
 
# 为线程定义一个函数
def print_time( threadName, delay):
   count = 0
   while count < 5:
      time.sleep(delay)
      count  = 1
      print "%s: %s" % ( threadName, time.ctime(time.time()) )
 
# 创建两个线程
try:
   thread.start_new_thread( print_time, ("Thread-1", 2, ) )
   thread.start_new_thread( print_time, ("Thread-2", 4, ) )
except:
   print "Error: unable to start thread"
 
while 1:
   pass

15，GUI

16，JSON

json.dumps

对象编码成 JSON 字符串。

语法：

json.dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, encoding="utf-8", default=None, sort_keys=False, **kw)

参数说明：

• skipkeys=True：在encoding过程中，dict对象的key只可以是string对象，如果是其他类型，那么在编码过程中就会抛出ValueError的异常。skipkeys可以跳过那些非string对象当作key的处理。

• ensure_ascii：输出真正的中文需要指定ensure_ascii=False

• check_circular

• allow_nan

• cls

• indent=2：参数根据数据格式缩进显示，读起来更加清晰；indent的数值，代表缩进的位数。

• separators=(’,’,’:’)：去掉,:后面的空格，美化输出结果。

• encoding

• default

• sort_keys=True：按照字典排序(a到z)输出。

#!/usr/bin/python
import json

data = [ { 'a' : 1, 'b' : 2, 'c' : 3, 'd' : 4, 'e' : 5 } ]

json = json.dumps(data)
print json

python 原始类型向 json 类型的转化对照表：

Python	JSON
dict	object
list, tuple	array
str, unicode	string
int, long, float	number
True	true
False	false
None	null

json.loads

用于解码 JSON 数据。

#!/usr/bin/python
import json

jsonData = '{"a":1,"b":2,"c":3,"d":4,"e":5}';

text = json.loads(jsonData)
print text