1.程序输入和输出 raw_input()内建函数
1 2 3 4 5 >>> user = raw_input('Enter your name:') Enter your name:root >>> print 'Your name is:',user Your name is: root
print语句
1 2 3 4 5 6 >>> myString = 'Hello World!' >>> print myString Hello World! >>> myString 'Hello World!'
1 2 3 4 5 >>> print type(u"你") #都能输出汉字，但是输出的类型不一样 <type 'unicode'> >>> print type("你") <type 'str'>
注意：在仅用变量名的时候，输出的字符串是用单引号括起来的
2.操作符 <1>两种除法——单斜杠/用于传统的除法，双斜杠//用作浮点除法（对结果进行四舍五入）
<2>乘方操作符——双星号 **
<3>标准比较操作符——< <= > >= == != <>
<4>逻辑操作符——and or not
3.变量和赋值 Python是动态类型语言，不需要预先声明变量的类型
Python不支持C语言中的自增1和自减1操作符
4.数字 <1>有符号整型 长整型 布尔值
<2>浮点值
<3>复数
5.字符串 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 >>> myString = "Hello" >>> myString[0] 'H' >>> myString[2:4] 'll' >>> myString[1:] 'ello' >>> myString[:4] 'Hell' >>> myString[-1] 'o' >>> myString * 2 'HelloHello' >>> myString + myString 'HelloHello'
1 2 3 4 5 6 7 8 >>> myString = '''python ... is cool''' >>> myString 'python\nis cool' >>> print myString python is cool
6.条件语句 1 2 3 4 5 6 >>> if x>1: ... x -= 1 ... print '#%d' % (x) ... #2
条件表达式
1 2 3 4 5 >>> x = 3 >>> x = 1 if x<3 else 2 >>> x 2
else语句
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 #coding:utf-8 #!/usr/bin/env python 'maxFact.py -- 寻找一个数的最大约数' def showMaxFactor(num): count = num/2 while count > 1: if num % count == 0: print '%d 的最大约数是 %d' % (num,count) break count -= 1 else: print num,'没有最大公约数' for eachNum in range(10,21): showMaxFactor(eachNum)
7.循环语句 while循环
1 2 3 4 5 6 7 8 9 10 >>> x = 0 >>> while x<3: ... print x ... x += 1 ... 0 1 2 >>>
for循环和range()内建函数
1 2 3 4 5 6 7 8 >>> for x in ['A','B','C','D']: ... print x ... A B C D
1 2 3 4 5 >>> for x in ['A','B','C','D']: ... print x, ... A B C D
使用range()内建函数
1 2 3 4 5 6 >>> for x in range(3): #循环从0到2 ... print x, ... 0 1 2 >>>
1 2 3 4 5 6 7 >>> myString = 'ABCD' #循环字符串中的每一个字母 >>> for x in myString: ... print x, ... A B C D >>>
使用len()内建函数
1 2 3 4 5 6 7 8 9 10 >>> myString 'ABCD' >>> for i in range(len(myString)): ... print myString[i],i ... A 0 B 1 C 2 D 3
for语句用于序列类型
<1>通过序列项迭代
1 2 3 4 5 6 7 8 9 >>> List = ['a','b','c','d'] >>> for eachList in List: ... print eachList ... a b c d
<2>通过序列索引迭代
1 2 3 4 5 6 7 8 >>> for eachList in range(len(List)): ... print List[eachList] ... a b c d
<3>使用项和索引迭代
1 2 3 4 5 6 7 8 >>> for i,eachList in enumerate(List): ... print "%d %s" % (i,eachList) ... 0 a 1 b 2 c 3 d
列表解析
1 2 3 4 5 6 7 8 9 >>> square = [x ** 2 for x in range(4)] >>> for i in square: ... print i ... 0 1 4 9
1 2 3 4 5 6 7 >>> square = [x ** 2 for x in range(4) if not x % 2] #如果整除2 >>> for i in square: ... print i ... 0 4
8.迭代器（RandSeq和AnyIter） 1.RandSeq 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 #coding:utf-8 #!/usr/bin/env python 'randSeq.py -- 迭代' #从random模块里仅仅导入choice方法 from random import choice class RandSeq(object): def __init__(self,seq): self.data = seq; def __iter__(self): return self; def next(self): return choice(self.data) if __name__ == '__main__': for eachItem in RandSeq(('rock','paper','scisc')): print eachItem
9.文件和内建函数open()、file() 1 2 3 4 5 6 7 8 9 10 >>> filename = raw_input('Enter file name:') Enter file name:/home/common/software/hexo/source/_posts/book_2016.md >>> fobj = open(filename,'r') >>> for eachLine in fobj: ... print eachLine, ... >>> fobj.close()
文件写入 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 #coding:utf-8 #!/usr/bin/env python 'makeTextPyhton.py -- create text file' import os ls = os.linesep #输入文件名 fname = raw_input('Enter file name:') # 判断输入的文件名是否存在 while True: if os.path.exists(fname): print "错误：'%s' 已经存在" % fname else: break #按行输入文件的内容，以.为结束每一行，以单个.结束整个输入 all = [] print "\n请以.结束每一行内容\n" #循环 while True: entry = raw_input("输入每一行： ") if entry == ".": break else: all.append(entry) #把所有的内容写入到文件中 fobj = open(fname,'w') fobj.writelines(["%s%s" % (x,ls) for x in all]) fobj.close() print "完成！"
文件读取和显示 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 #coding:utf-8 #!/usr/bin/env python 'readTextPyhton.py -- read and display text file' #输入文件名 fname = raw_input('Enter file name:') print #尝试打开和显示文件 try: fobj = open(fname,'r') except IOError,e: print "*** file open error:",e else: #显示内容 for eachLine in fobj: print eachLine, fobj.close()
10.函数 1 2 3 4 5 6 >>> def addMe2Me(x): ... return (x+x) ... >>> addMe2Me(2.5) 5.0
标准类型内建函数 ** <1>type() —— 返回对象的类型
** <2>cmp() —— 比较两个对象，返回两个对象的ASCII码的差
** <3>str()、repr() —— 以字符串的方式获取对象的内容，str()适合于输出，repr()适合于使用eval()重新得到该对象，此外``不推荐使用
** <4>type()、isinstance() —— 确认一个对象的类型
序列类型函数 ** <1>len() —— **返回字符串的字符数
** <2>max()和min() —— **返回字符串中最大或者最小的字符（按照ASCII码值排列）
** <3>enumerate() —— **用于for循环
1 2 3 4 5 6 7 8 9 10 11 >>> s = 'ABCDEF' >>> for i,t in enumerate(s): ... print i,t ... 0 A 1 B 2 C 3 D 4 E 5 F
** <4>zip() —— **返回一个列表
1 2 3 4 >>> s,t = 'ABC','DEF' >>> zip(s,t) [('A', 'D'), ('B', 'E'), ('C', 'F')]
字符串类型函数 ** <1>raw_input() ——** 用于输入
1 2 3 4 5 >>> userinput = raw_input("Enter user name:") Enter user name:XiaoMing >>> userinput 'XiaoMing'
<2>chr() —— 输入是0-255的整数，输出的是一个对应的字符
unichr() —— 输入是整数，返回的是一个对应的Unicode字符
** ord() ——** 输入是一个字符，返回是对应的ASCII码或者Unicode数值
<3>其他 —— 《Pyhton核心编程》P122
11.类 1 2 3 4 5 6 7 8 9 10 11 12 13 >>> class myClass(object): ... def _init_(self,nm='123'): ... self.name = nm ... print 'Constructor' ... def showname(self): ... print 'My name is',self.name ... >>> newClass = myClass() >>> newClass._init_() Constructor >>> newClass.showname() My name is 123
12.模块 1 2 3 4 5 6 7 >>> import sys >>> sys.stdout.write('Hello Word!\n') Hello Word! >>> sys.platform 'linux2' >>> sys.version '2.7.6 (default, Jun 22 2015, 18:00:18) \n[GCC 4.8.2]'
13.基本规则和特殊字符 <1># —— 注释
<2>\n —— 行分隔符
<3>\ —— 继续上一行
<4>; —— 将两个语句连接到一行中
<5>: —— 将代码块的头和体分开
14.Python对象
标准类型 其他内建类型
数字——Integer整型；Boolean布尔型；Long integer 长整型；Floating point number 浮点型；Complex number复数型 类型——type(1)——><type,’int’> 得到特定对象的类型信息
字符串——String Null对象（None）——不支持任何运算，也没有任何内建方法
列表——List [] 文件
元组——Tuple () 集合/固定集合
字典——Dictionary 函数/方法
模块
类
列表 1.创建列表类型数据并给其赋值
1 2 3 4 5 6 >>> aList = [123,'abc',4.56,['inner','list'],7-9j] >>> aList [123, 'abc', 4.56, ['inner', 'list'], (7-9j)] >>> list('ABC') ['A', 'B', 'C']
2.访问列表中的值
1 2 3 4 5 6 7 8 9 >>> aList[0] 123 >>> aList[1:4] ['abc', 4.56, ['inner', 'list']] >>> aList[:3] [123, 'abc', 4.56] >>> aList[3][1] 'list'
3.如何更新列表
1 2 3 4 5 6 7 >>> aList[2]='ABC' >>> aList [123, 'abc', 'ABC', ['inner', 'list'], (7-9j)] >>> aList.append("Hello Word") >>> aList [123, 'abc', 'ABC', ['inner', 'list'], (7-9j), 'Hello Word']
4.删除列表中的元素或者列表本身
1 2 3 4 5 6 7 >>> del aList[1] >>> aList [123, 'ABC', ['inner', 'list'], (7-9j), 'Hello Word'] >>> aList.remove(123) >>> aList ['ABC', ['inner', 'list'], (7-9j), 'Hello Word']<br />>>> del aList
5.标准类型操作符
列表比较操作的时候，是两个列表的元素分别比较，直到有一方的元素胜出
6.序列类型操作符
** <1>切片（[]和[:]）**
1 2 3 4 5 6 7 >>> aList [123, 'abc', 'ABC', ['inner', 'list'], (7-9j), 'Hello Word'] >>> aList[-2:-1] [(7-9j)] >>> aList[2:-1] ['ABC', ['inner', 'list'], (7-9j)]
<2>成员关系操作（in,not in）
输出的是True或者False
** <3>连接操作符（+）**
1 2 3 4 5 6 >>> aList=[1,2,3,4] >>> bList=['A','B','C','D'] >>> cList = aList+bList >>> cList [1, 2, 3, 4, 'A', 'B', 'C', 'D']
<4>重复操作符（*）
1 2 3 >>> aList * 2 [1, 2, 3, 4, 1, 2, 3, 4]
7.标准类型函数cmp()
比较的规则P140
8.序列类型函数
** <1>len()——**对列表和元组返回的是列表或者元组的元素个数
** <2>max()和min()——**比较大小
** <3>sorted()和reversed()——**
1 2 3 4 5 6 7 8 9 10 11 12 13 >>> bList ['A', 'B', 'C', 'D'] >>> for t in reversed(bList): ... print t ... D C B A >>> bList=['D','C','B','A'] >>> sorted(bList) ['A', 'B', 'C', 'D']
<4>enumerate()和zip()——
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 ['A', 'B', 'C', 'D'] >>> for i,t in enumerate(bList): ... print i,t ... 0 A 1 B 2 C 3 D >>> aList [1, 2, 3, 4] >>> bList ['A', 'B', 'C', 'D'] >>> for i,j in zip(aList,bList): ... print ('%s %s' % (i,j)).title() ... 1 A 2 B 3 C 4 D
<5>sum()
1 2 3 4 5 >>> aList [1, 2, 3, 4] >>> sum(aList) 10
** <6>list()和tuple()——**用于列表和元组之间的转换
9.列表类型的内建函数——P142
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 >>> dir(aList) ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort'] >>> aList [1, 2, 3, 4] >>> aList.append('A') >>> aList [1, 2, 3, 4, 'A'] >>> aList.count('A') 1 >>> aList.insert(1,1.5) >>> aList [1, 1.5, 2, 3, 4, 'A'] >>> 'A' in aList True >>> aList.index(1.5) 1 >>> aList.sort() >>> aList [1, 1.5, 2, 3, 4, 'A'] >>> aList.reverse() #没有返回值的函数会直接改变对象的值 >>> aList ['A', 4, 3, 2, 1.5, 1] >>> bList.extend(aList) >>> bList ['A', 'B', 'C', 'D', 'A', 4, 3, 2, 1.5, 1]
10.append和extend
元组 1.创建一个元组并给它赋值
1 2 3 4 5 6 >>> aTuple = (123,'abc',4.56,['inner','tuple'],7-9j) >>> aTuple (123, 'abc', 4.56, ['inner', 'tuple'], (7-9j)) >>> tuple('ABC') ('A', 'B', 'C')
2.访问元组中的值
1 2 3 4 5 6 7 8 9 >>> aTuple[0] 123 >>> aTuple[1:4] ('abc', 4.56, ['inner', 'tuple']) >>> aTuple[:3] (123, 'abc', 4.56) >>> aTuple[3][1] 'tuple'
3.更新元组
元组和字符串一样，是不可变类型，不能更新或者改变元组的元素
4.移除一个元组以及元组本身
删除一个单独的元组元素是不可能的，可以用del语句删除一个元组
5.元组操作符和内建函数
标准类型操作符、序列类型操作符和内建函数和列表的相似
6.元组的特殊特性
3个标准的不可变类型 ——数字、字符串和元组字符串
** 元组类型包含的可变对象是可以改变的，比如元组中包含一个列表**
集合 有两种不同的类型——可变集合 （set）和不可变集合 （frozenset）
可变集合 不是可哈希的，不能用作字典的键，也不能用做其他集合中的元素
不可变集合 是有哈希值的，能被用做字典的键或者是作为集合中的一个成员
1.创建集合类型和给集合赋值
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 >>> s = set('cheeseshop') >>> s set(['c', 'e', 'h', 'o', 'p', 's']) >>> t = frozenset('bookshop') >>> t frozenset(['b', 'h', 'k', 'o', 'p', 's']) >>> type(s) <type 'set'> >>> type(t) <type 'frozenset'> >>> len(s) 6 >>> len(t) 6 >>> s == t False
2.访问集合中的值
1 2 3 4 5 6 7 8 9 10 11 12 13 14 >>> 'k' in s False >>> 'k' in t True >>> for i in s: ... print i ... c e h o p s
3.更新集合
1 2 3 4 5 6 7 8 9 10 11 12 13 >>> s.add('z') >>> s set(['c', 'e', 'h', 'o', 'p', 's', 'z']) >>> s.update('abc') >>> s set(['a', 'c', 'b', 'e', 'h', 'o', 'p', 's', 'z']) >>> s.remove('z') >>> s set(['a', 'c', 'b', 'e', 'h', 'o', 'p', 's']) >>> s -= set('abc') >>> s set(['e', 'h', 'o', 'p', 's'])
不可变集合不能修改
4.删除集合中的成员和集合
5.集合类型操作符
<1>标准类型操作符
1.成员关系 (in,not in)
2.集合等价/不等价 (==,!=)
3.子集/超集 (<,<=,>,>=)
<2>集合类型操作符
1.联合(|)
1 2 3 >>> s|t set(['b', 'e', 'h', 'k', 'o', 'p', 's'])
** 2.交集(&)**
1 2 3 >>> s&t set(['h', 's', 'o', 'p'])
3.差补/相对补集(-)
** 4.对称差分(^)，即(XOR)异或，只能是属于集合s或者集合t的成员，不能同时属于两个集合**
1 2 3 >>> s^t set(['b', 'e', 'k'])
** 5.混合集合类型操作**
类型不相同的时候，产生的结果类型和左操作数的类型相同
<3>集合类型操作符(仅适用于可变集合)
1.update()方法或者|=
1 2 3 4 >>> s|=t >>> s set(['b', 'e', 'h', 'k', 'o', 'p', 's'])
** 2.intersection_update()方法或者&=，保留两个集合重复的成员**
1 2 3 4 5 6 7 8 >>> s set(['a', 'c', 'b', 'd']) >>> t set(['e', 'd', 'f']) >>> s&=t >>> s set(['d'])
3.difference_update()方法或者-=
** 4.symmetric_difference_update()方法或者^=，差分操作**
6.内建函数
<1>标准类型函数——len()
<2>集合类型工厂函数——set()和frozenset()
7.集合类型内建方法——P184
字典 1.创建字典和给字典赋值 ，可以使用工厂方法dict()来创建字典，也可以使用 fromkeys()来创建一个 元素具有相同值 的字典
1 2 3 4 5 6 7 8 9 10 11 12 13 >>> dict = {'name':'XiaoMing','age':20} >>> dict {'age': 20, 'name': 'XiaoMing'} >>> dict2 = dict((['x',1],['y',2])) >>> dict2 {'y': 2, 'x': 1} >>> dict2 = {}.fromkeys(('x','y'),1) >>> dict2 {'y': 1, 'x': 1
2.访问字典中的值
1 2 3 4 5 6 7 8 9 >>> dict = {'name':'XiaoMing','age':20} >>> dict {'age': 20, 'name': 'XiaoMing'} >>> for key in dict.keys(): ... print 'key=%s,value=%s' % (key,dict[key]) ... key=age,value=20 key=name,value=XiaoMing
1 2 3 4 5 6 >>> for key in dict: ... print 'key=%s,value=%s' % (key,dict[key]) ... key=age,value=20 key=name,value=XiaoMing
1 2 3 >>> dict['name'] 'XiaoMing'
1 2 3 >>> 'name' in dict True
3.更新字典
1 2 3 4 >>> dict['name'] = '123' >>> dict['name'] '123'
1 2 3 4 >>> del dict['name'] >>> dict {'age': 20}
1 2 3 4 5 >>> dict {'age': 20} >>> dict.pop('age') 20
4.映射类型相关的函数
<1>dict()——创建字典
<2>len()——返回键值对的数目
<3>hash()——可以判断某个对象是否可以做一个字典的值
5.映射类型内建方法
<1>keys()——返回一个列表，包含字典中所有的键
<2>values()——返回一个列表，包含字典中所有的值
<3>items()——返回一个包含所有（键，值）元组的列表
注意：返回的元素是没有顺序的，可以通过sorted()方法进行排序
<4>update()——将一个字典的内容添加到另外一个字典中
<5>clear()——删除字典中的所有条目
<6>copy()——返回一个字典的副本
<7>get()——根据键查询值，键不存在的话返回None
<8>setdefault()——检查字典中是否含有某个键，如果存在就返回这个值；不存在就赋值并返回这个值
15.操作符 比较类型操作符 <1>对象值的比较 < > <= >= == !=
<2>对象身份比较 is is not 比较是否指向同一个对象 注意：Python中整型对象和字符串对象是不可变对象
格式化操作符（%） 字符串模板——字符串Template对象
1 2 3 4 5 >>> from string import Template >>> s = Template("This is ${name} ${num}") >>> print s.substitute(name="Python",num=3) This is Python 3
16.其他 1.Non-ASCII character错误 源代码文件第一行添加
2.Python终端自动补全 在～目录下添加一个文件，名字为.pythonstartup.py
1 2 3 4 5 6 7 8 9 10 11 12 13 #!/usr/bin/python # -*- coding: UTF-8 -*- import readline, rlcompleter; readline.parse_and_bind("tab: complete"); # 启用Tab补全 def igtk(): globals()['gtk'] = __import__('gtk'); globals()['thread'] = __import__('thread'); gtk.gdk.threads_init(); thread.start_new_thread(gtk.main, ()); pass;
然后在.bashrc中添加
1 2 export PYTHONSTARTUP=~/.pythonstartup.py
3.解析json json.dumps : dict转成str，将字典转换为字符串
json.loads：str转成dict，将字符串转换为字典
参考：json.dumps和 json.loads 区别，如此简单
