Python学习笔记——基本语法

1.程序输入和输出

raw_input()内建函数

>>> user = raw_input('Enter your name:')
Enter your name:root
>>> print 'Your name is:',user
Your name is: root

print语句

>>> myString = 'Hello World!'
>>> print myString
Hello World!
>>> myString
'Hello World!'

>>> 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.字符串

>>> myString = "Hello"
>>> myString[0]
'H'
>>> myString[2:4]
'll'
>>> myString[1:]
'ello'
>>> myString[:4]
'Hell'
>>> myString[-1]
'o'
>>> myString * 2
'HelloHello'
>>> myString + myString
'HelloHello'

 

>>> myString = '''python
... is cool'''
>>> myString
'python\nis cool'
>>> print myString
python
is cool

6.条件语句

>>> if x>1:
...     x -= 1
...     print '#%d' % (x)
... 
#2

条件表达式

>>> x = 3
>>> x = 1 if x<3 else 2
>>> x
2

 

else语句

#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循环

>>> x = 0
>>> while x<3:
...     print x
...     x += 1
... 
0
1
2
>>> 

 for循环和range()内建函数

>>> for x in ['A','B','C','D']:
...     print x
... 
A
B
C
D

 

>>> for x in ['A','B','C','D']:
...     print x,
... 
A B C D

使用range()内建函数

>>> for x in range(3):　　#循环从0到2
...     print x,
... 
0 1 2
>>> 

 

>>> myString = 'ABCD'　　#循环字符串中的每一个字母
>>> for x in myString:
...     print x,
... 
A B C D
>>> 

使用len()内建函数

>>> myString
'ABCD'
>>> for i in range(len(myString)):
...     print myString[i],i
... 
A 0
B 1
C 2
D 3

for语句用于序列类型

<1>通过序列项迭代

>>> List = ['a','b','c','d']
>>> for eachList in List:
...     print eachList
... 
a
b
c
d

<2>通过序列索引迭代

>>> for eachList in range(len(List)):
...     print List[eachList]
... 
a
b
c
d

<3>使用项和索引迭代

>>> for i,eachList in enumerate(List):
...     print "%d %s" % (i,eachList)
... 
0 a
1 b
2 c
3 d

 

 列表解析

>>> square = [x ** 2 for x in range(4)]
>>> for i in square:
...     print i
... 
0
1
4
9

 

>>> 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

#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()

>>> 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()

文件写入

#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 "完成！"

文件读取和显示

#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.函数

>>> 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循环

>>> 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() —— 返回一个列表

>>> s,t = 'ABC','DEF'
>>> zip(s,t)
[('A', 'D'), ('B', 'E'), ('C', 'F')]

字符串类型函数

　　<1>raw_input() —— 用于输入

>>> 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.类

>>> 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.模块

>>> 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.创建列表类型数据并给其赋值

>>> aList = [123,'abc',4.56,['inner','list'],7-9j]
>>> aList
[123, 'abc', 4.56, ['inner', 'list'], (7-9j)]
>>> list('ABC')
['A', 'B', 'C']

2.访问列表中的值

>>> aList[0]
123
>>> aList[1:4]
['abc', 4.56, ['inner', 'list']]
>>> aList[:3]
[123, 'abc', 4.56]
>>> aList[3][1]
'list'

 3.如何更新列表

>>> 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.删除列表中的元素或者列表本身

>>> del aList[1]
>>> aList
[123, 'ABC', ['inner', 'list'], (7-9j), 'Hello Word']
>>> aList.remove(123)
>>> aList
['ABC', ['inner', 'list'], (7-9j), 'Hello Word']
>>> del aList

5.标准类型操作符

列表比较操作的时候，是两个列表的元素分别比较，直到有一方的元素胜出

6.序列类型操作符

　　<1>切片（[]和[:]）

>>> 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>连接操作符（+）

>>> aList=[1,2,3,4]
>>> bList=['A','B','C','D']
>>> cList = aList+bList
>>> cList
[1, 2, 3, 4, 'A', 'B', 'C', 'D']

 　　<4>重复操作符（*）

>>> aList * 2
[1, 2, 3, 4, 1, 2, 3, 4]

7.标准类型函数cmp()

　　比较的规则P140

8.序列类型函数

　　<1>len()——对列表和元组返回的是列表或者元组的元素个数

 　  <2>max()和min()——比较大小

　　<3>sorted()和reversed()——　

>>> 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()——

['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()

>>> aList
[1, 2, 3, 4]
>>> sum(aList)
10

 　　<6>list()和tuple()——用于列表和元组之间的转换

9.列表类型的内建函数——P142

>>> 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.创建一个元组并给它赋值

>>> aTuple = (123,'abc',4.56,['inner','tuple'],7-9j)
>>> aTuple
(123, 'abc', 4.56, ['inner', 'tuple'], (7-9j))
>>> tuple('ABC')
('A', 'B', 'C')

 2.访问元组中的值

>>> 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.创建集合类型和给集合赋值

>>> 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.访问集合中的值

>>> 'k' in s
False
>>> 'k' in t
True
>>> for i in s:
...     print i
... 
c
e
h
o
p
s

3.更新集合

>>> 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.删除集合中的成员和集合

>>> del t

5.集合类型操作符

　　<1>标准类型操作符

　　　　1.成员关系(in,not in)

　　　　2.集合等价/不等价(==,!=)

　　　　3.子集/超集(<,<=,>,>=)

　　<2>集合类型操作符

　　　　1.联合(|)

>>> s|t
set(['b', 'e', 'h', 'k', 'o', 'p', 's'])

　　　　2.交集(&)

>>> s&t
set(['h', 's', 'o', 'p'])

　　　　3.差补/相对补集(-)

>>> s-t
set(['e'])

　　　  4.对称差分(^)，即(XOR)异或，只能是属于集合s或者集合t的成员，不能同时属于两个集合

>>> s^t
set(['b', 'e', 'k'])

　　　  5.混合集合类型操作

 　　　　　　类型不相同的时候，产生的结果类型和左操作数的类型相同

　　<3>集合类型操作符(仅适用于可变集合)

　　　　1.update()方法或者|=

>>> s|=t
>>> s
set(['b', 'e', 'h', 'k', 'o', 'p', 's'])

　　  　2.intersection_update()方法或者&=，保留两个集合重复的成员

>>> 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()来创建一个元素具有相同值的字典

>>> 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.访问字典中的值

>>> 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

>>> for key in dict:
...     print 'key=%s,value=%s' % (key,dict[key])
... 
key=age,value=20
key=name,value=XiaoMing

 

>>> dict['name']
'XiaoMing'

>>> 'name' in dict
True

 3.更新字典

>>> dict['name'] = '123'
>>> dict['name']
'123'

>>> del dict['name']
>>> dict
{'age': 20}

 

>>> 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对象

>>> 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错误

源代码文件第一行添加

#coding:utf-8

2.Python终端自动补全

在～目录下添加一个文件，名字为.pythonstartup.py

#!/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中添加

export PYTHONSTARTUP=~/.pythonstartup.py

3.解析json

json.dumps : dict转成str，将字典转换为字符串

json.loads：str转成dict，将字符串转换为字典

参考：json.dumps和 json.loads 区别，如此简单