设置环境变量
Linux：
$ PATH=$PATH:/usr/local/python3/bin/python3 # 设置环境变量
$ python3 --version
Python 3.4.0
Windows:
set path=%path%;C:\python341、在Linux下使用下面的代码可以直接./xxx.py执行脚本，在Windows下不可以：#!/usr/bin/python3
2、执行脚本：$ python3 hello.py
3、字符编码，需要写在文件的开头，比如支持中文编码：
# -*- coding: UTF-8 -*- 或者 #coding=utf-8，
#coding=utf-8
import json
student = {}
student['Name'] = '张三'
student['Age'] = 18
student[12] = True
print json.dumps(student, ensure_ascii=False, encoding='utf-8')
注意：#coding=utf-8 的 = 号两边不要空格，且utf-8必须为小写。
4、关键字：>>> import keyword，>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
5、代码注释：#!/usr/bin/python3，也可以使用''' XXX'''和"""XXX"""，即连续的3个单引号或双引号
#单引号注释
#!/usr/bin/python3
'''
这是多行注释，用三个单引号
这是多行注释，用三个单引号
这是多行注释，用三个单引号
'''
print("Hello, World!")
#双引号注释
#!/usr/bin/python3
"""
这是多行注释，用三个单引号
这是多行注释，用三个单引号
这是多行注释，用三个单引号
"""
print("Hello, World!") 6、代码块：python最具特色的就是使用缩进来表示代码块，不需要使用大括号({})。缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数，缩进不一致，会导致运行错误。
7、多行语句：使用反斜杠(\)来实现多行语句，在 [], {}, 或 () 中的多行语句，不需要使用反斜杠(\)：
total = item_one + \
item_two + \
item_three
在 [], {}, 或 () 中的多行语句，不需要使用反斜杠(\)，例如：
total = ['item_one', 'item_two', 'item_three',
'item_four', 'item_five']注意！多行的内容都属于同一块，因此缩进一定要一致。
8、数据类型：python中数有四种类型：整数、长整数、浮点数和复数。
整数， 如 1
长整数 是比较大的整数
浮点数 如 1.23、3E-2
复数 如 1 + 2j、 1.1 + 2.2j
9、字符串：python中单引号和双引号使用完全相同。使用三引号('''或""")可以指定一个多行字符串。
转义符 '\'自然字符串， 通过在字符串前加r或R。 如 r"this is a line with \n" 则\n会显示，并不是换行。
python允许处理unicode字符串，加前缀u或U， 如 u"this is an unicode string"。
字符串是不可变的。按字面意义级联字符串，如"this " "is " "string"会被自动转换为this is string。
word = '字符串'
sentence = "这是一个句子。"
paragraph = """这是一个段落，
可以由多行组成"""
10、代码组：
if expression :
suite
elif expression :
suite
else :
suite11、换行输出：print("xxx")，
不换行输出：print( x, end=" " )或
print( y, end="END" )
print(a, b, c, d, e, sep='+')，输出abcde并使用+号连接。
12、导入模块：
将整个模块(somemodule)导入，格式为： import somemodule
从某个模块中导入某个函数,格式为： from somemodule import somefunction
从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc
将某个模块中的全部函数导入，格式为： from somemodule import *13、help() 函数：调用 python 的 help() 函数可以打印输出一个函数的文档字符串，按下 : q 两个按键即退出说明文档
14、多个变量同时赋值：a, b, c = 1, 2, "runoob"
15、Python3 中有六个标准的数据类型：
Number（数字）
String（字符串）
List（列表）
Tuple（元组）
Sets（集合）
Dictionary（字典）
16、Python3 支持 int、float、bool、complex。内置的 type() 函数可以用来查询变量所指的对象类型：
type()来判断数据的类型：
>>> a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
可以用 isinstance 来判断：
>>>a = 111
>>> isinstance(a, int)
True
>>>
isinstance 和 type 的区别在于：
class A:
pass
class B(A):
pass
isinstance(A(), A) # returns True
type(A()) == A # returns True
isinstance(B(), A) # returns True
type(B()) == A # returns False
区别就是:
type()不会认为子类是一种父类类型。
isinstance()会认为子类是一种父类类型。17、字符串：Python中的字符串用单引号(')或双引号(")括起来，同时使用反斜杠(\)转义特殊字符：
str = 'Runoob'
print (str) # 输出字符串
print (str[0:-1]) # 输出第一个到倒数第二个的所有字符
print (str[0]) # 输出字符串第一个字符
print (str[2:5]) # 输出从第三个开始到第五个的字符
print (str[2:]) # 输出从第三个开始的后的所有字符
print (str * 2) # 输出字符串两次
print (str + "TEST") # 连接字符串字符串的这种输出方式同样适用于列表等其他集合数据类型。与 C 字符串不同的是，Python 字符串不能被改变。向一个索引位置赋值，比如word[0] = 'm'会导致错误。
18、列表：列表支持使用不同的数据类型组成同一个列表：
#!/usr/bin/python3
list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']
print (list) # 输出完整列表
print (list[0]) # 输出列表第一个元素
print (list[1:3]) # 从第二个开始输出到第三个元素
print (list[2:]) # 输出从第三个元素开始的所有元素
print (tinylist * 2) # 输出两次列表
print (list + tinylist) # 连接列表与Python字符串不一样的是，列表中的元素是可以改变的：
19、元组：元组与列表类似，不同之处在于元组的元素不能修改：
#!/usr/bin/python3
tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2 )
tinytuple = (123, 'runoob')
print (tuple) # 输出完整元组
print (tuple[0]) # 输出元组的第一个元素
print (tuple[1:3]) # 输出从第二个元素开始到第三个元素
print (tuple[2:]) # 输出从第三个元素开始的所有元素
print (tinytuple * 2) # 输出两次元组
print (tuple + tinytuple) # 连接元组20、集合：是一个无序不重复元素的序列：
#!/usr/bin/python3
student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
print(student) # 输出集合，重复的元素被自动去掉
# 成员测试
if('Rose' in student) :
print('Rose 在集合中')
else :
print('Rose 不在集合中')
# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')
print(a)
print(a - b) # a和b的差集
print(a | b) # a和b的并集
print(a & b) # a和b的交集
print(a ^ b) # a和b中不同时存在的元素注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
21、字典：是通过key-value来存取数据：
#!/usr/bin/python3
dict = {}
dict['one'] = "1 - 菜鸟教程"
dict[2] = "2 - 菜鸟工具"
tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}
print (dict['one']) # 输出键为 'one' 的值
print (dict[2]) # 输出键为 2 的值
print (tinydict) # 输出完整的字典
print (tinydict.keys()) # 输出所有键
print (tinydict.values()) # 输出所有值
输出结果：
1 - 菜鸟教程
2 - 菜鸟工具
{'name': 'runoob', 'site': 'www.runoob.com', 'code': 1}
dict_keys(['name', 'site', 'code'])
dict_values(['runoob', 'www.runoob.com', 1])注意：
1、字典是一种映射类型，它的元素是键值对。
2、字典的关键字必须为不可变类型，且不能重复。
3、创建空字典使用 { }。
4、不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
5、键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行
字典是支持无限极嵌套的，如下面代码：
citys={
'北京':{
'朝阳':['国贸','CBD','天阶','我爱我家','链接地产'],
'海淀':['圆明园','苏州街','中关村','北京大学'],
'昌平':['沙河','南口','小汤山',],
'怀柔':['桃花','梅花','大山'],
'密云':['密云A','密云B','密云C']
},
'河北':{
'石家庄':['石家庄A','石家庄B','石家庄C','石家庄D','石家庄E'],
'张家口':['张家口A','张家口B','张家口C'],
'承德':['承德A','承德B','承德C','承德D']
}
}可以使用如下方法进行列出:
for i in citys['北京']:
print(i)
将列出如下结果：
朝阳 海淀 昌平 怀柔 密云
for i in citys['北京']['海淀']:
print(i)
输出如下结果：
圆明园 苏州街 中关村 北京大学
22、数据类型转换：
int(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)将一个整数转换为一个字符
ord(x)将一个字符转换为它的整数值
hex(x)将一个整数转换为一个十六进制字符串
oct(x)将一个整数转换为一个八进制字符串23、python 使用 lambda 来创建匿名函数。
所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。
- lambda 只是一个表达式，函数体比 def 简单很多。
- lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
- lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
- 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
#!/usr/bin/python3
# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2;
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))
24、Python作用域：
Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这这些语句内定义的变量，外部也可以访问，如下代码：
>>> def test(): ... msg_inner = 'I am from Runoob' >>> if True: ... msg = 'I am from Runoob' ... >>> msg 'I am from Runoob' >>>
在if中定义的变量msg可以在外部继续访问，而定义在函数test()内的msg_inner变量只能在函数内访问。
25、遍历字典和列表
#字典遍历
knights = {'gallahad': 'the pure', 'robin': 'the brave'}
#遍历keys
for a in knights.keys():
print(a)
#遍历values
for a in knights.values():
print(a)
#同时遍历keys和values
for k, v in knights.items():
print(k, v, sep=':')
#列表遍历
mylst = ['tic', 'tac', 'toe']
for a in mylst :
print(a)
#遍历列表和索引
for i, v in enumerate(mylst):
print(i, v, sep=':')
#反向遍历列表
for v in reversed(mylst):
print(v)
#遍历排序后的列表
for v in sorted(mylst):
print(v)
26、文件读写
cities = {
'北京':{
'海淀区',
'朝阳区'
},
'广州':{
'番禺区',
'海珠区'
}
}
# 打开一个文件
f = open("temp.txt", "w")
s = str(cities)
#写入数据到文件
f.write(s)
# 关闭打开的文件
f.close()
#打开读取文件
f2 = open("temp.txt", "r")
#读取全部行
print(f2.readlines())
#关闭读取文件
f2.close()27、对象序列化和反序列化
#对象序列化
import pickle
# 使用pickle模块将数据对象保存到文件
data1 = {'a': [1, 2.0, 3, 4+6j],
'b': ('string', u'Unicode string'),
'c': None}
selfref_list = [1, 2, 3]
output = open('data.pkl', 'wb')
# Pickle dictionary using protocol 0.
pickle.dump(data1, output)
# Pickle the list using the highest protocol available.
pickle.dump(selfref_list, output, -1)
output.close()
#对象反序列化，使用pprint和print好像一样？
import pprint, pickle
#使用pickle模块从文件中重构python对象
pkl_file = open('data.pkl', 'rb')
data1 = pickle.load(pkl_file)
pprint.pprint(data1)
print(data1)
data2 = pickle.load(pkl_file)
pprint.pprint(data2)
print(data2)
pkl_file.close()28、异常处理try..exception..finally
import sys
#自定义异常处理类
class MyError(Exception):
def __init__(self, value):
self.value = value
def __str__(self):
return repr(self.value)
#产生异常的除法函数
def DivNum(x, y):
if y == 0:
raise NameError('除数不能为零') #除数为零抛出异常
elif y < 0:
raise MyError("除数不能小于零")
else:
return x / y;
try:
f = DivNum(10, -1)
print(f)
except NameError as err:
print("OS error: {0}".format(err))
except ValueError:
print("Could not convert data to an integer.")
except: #或者使用else:
print("Unexpected error:", sys.exc_info()[0], sys.exc_info()[1])
finally: #最后都会执行的代码
print("到此一游！")
#除了可以使用finally进行异常清理
#还可以使用with语句进行预处理清理
with open("myfile.txt") as f:
for line in f:
print(line, end="")
29、类的定义和使用
#类定义
class people:
#定义基本属性
name = ''
age = 0
#定义私有属性,私有属性在类外部无法直接进行访问，使用两根下划线
__weight = 0
#定义构造方法
def __init__(self,n,a,w):
self.name = n
self.age = a
self.__weight = w
def speak(self):
print("%s 说: 我 %d 岁。" %(self.name,self.age))
#单继承示例
class student(people):
grade = ''
def __init__(self,n,a,w,g):
#调用父类的构函
people.__init__(self,n,a,w)
self.grade = g
#覆写父类的方法
def speak(self):
print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
#另一个类，多重继承之前的准备
class speaker():
topic = ''
name = ''
def __init__(self,n,t):
self.name = n
self.topic = t
def speak(self):
print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))
#多重继承
class sample(speaker,student):
a =''
def __init__(self,n,a,w,g,t):
student.__init__(self,n,a,w,g)
speaker.__init__(self,n,t)
def __add(self): #类的私有方法和私有变量一样使用两根下划线命名
print("add")
test = sample("Tim",25,80,4,"Python")
test.speak() #方法名同，默认调用的是在括号中排前地父类的方法
#test.__add() #类的私有方法不能在类的外部调用30、类的专有方法和运算符重载，参考：http://www.jb51.net/article/59691.htm
__init__ : 构造函数，在生成对象时调用
__del__ : 析构函数，释放对象时使用
__repr__ : 打印，转换
__str__：打印类自身
__setitem__ : 按照索引赋值
__getitem__: 按照索引获取值
__len__: 获得长度
__cmp__: 比较运算
__call__: 函数调用
__add__: 加运算
__sub__: 减运算
__mul__: 乘运算
__div__: 除运算
__mod__: 求余运算
__pow__: 乘方
#重载操作符相当于重写上面的专有方法
class Vector:
def __init__(self, a, b):
self.a = a
self.b = b
def __str__(self):
return 'Vector (%d, %d)' % (self.a, self.b)
def __add__(self,other):
return Vector(self.a + other.a, self.b + other.b)
v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)
126
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
