Python基本语法笔记2

Keywords:

assert	Assert (ensure) that something is true.	assert False, "Error!"
except	If an exception happens, do this.	except ValueError, e: print e
exec	Run a string as Python.	exec 'print "hello"'
global	Declare that you want a global variable.	global X
is	Like == to test equality.	1 is 1 == True
raise	Raise an exception when things go wrong.	raise ValueError("No")
with	With an expression as a variable do.	with X as Y: pass
yield	Pause here and return to caller.	def X(): yield Y; X().next()
pass	This block is empty.	def empty(): pass

Data Types

True、False、None、string、number、float、list、dict

List操作：

ten_things = "Apples Oranges Crows Telephone Light Sugar"
print "Wait there are not 10 things in that list. Let's fix that."
stuff = ten_things.split(' ')
more_stuff = ["Day", "Night", "Song", "Frisbee", "Corn", "Banana", "Girl", "Boy"]
while len(stuff) != 10:
    next_one = more_stuff.pop()
    print "Adding: ", next_one
    stuff.append(next_one)
    print "There are %d items now." % len(stuff)
print "There we go: ", stuff
print "Let's do some things with stuff."
print stuff[1]
print stuff[-1] # whoa! fancy
print stuff.pop()
print ' '.join(stuff) # what? cool!
print '#'.join(stuff[3:5]) # super stellar!      

Dict的使用：

>>> stuff = {'name': 'Zed', 'age': 39, 'height': 6 * 12 + 2}
>>> print stuff['name']
Zed
>>> stuff[1] = "Wow"
>>> stuff[2] = "Neato"
>>> print stuff[1]
Wow
>>> print stuff[2]
Neato
>>> stuff
{'city': 'San Francisco', 2: 'Neato', 'name': 'Zed', 1: 'Wow', 'age': 39, 'height': 74}
>>> del stuff['city']
>>> del stuff[1]
>>> del stuff[2]

states = {
    'Oregon': 'OR',
    'Florida': 'FL',
    'California': 'CA',
    'New York': 'NY',
    'Michigan': 'MI'
}
# print every state abbreviation
print '-' * 10
for state, abbrev in states.items():
    print "%s is abbreviated %s" % (state, abbrev)      

模块：

# 导入模块
import support
# 现在可以调用模块里包含的函数了
support.print_func("Zara")      

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

• 当前目录
• 如果不在当前目录，Python则搜索在shell变量PYTHONPATH下的每个目录
• 如果都找不到，Python会察看默认路径

变量是拥有匹配对象的名字（标识符）。命名空间是一个包含了变量名称们（键）和它们各自相应的对象们（值）的字典。

一个Python表达式可以访问局部命名空间和全局命名空间里的变量。如果一个局部变量和一个全局变量重名，则局部变量会覆盖全局变量。

每个函数都有自己的命名空间。类的方法的作用域规则和通常函数的一样。

Python会智能地猜测一个变量是局部的还是全局的，它假设任何在函数内赋值的变量都是局部的。

因此，如果要给全局变量在一个函数里赋值，必须使用global语句。

dir()函数一个排好序的字符串列表，内容是一个模块里定义过的名字。

根据调用地方的不同，globals()和locals()函数可被用来返回全局和局部命名空间里的名字。

因此，如果你想重新执行模块里顶层部分的代码，可以用reload()函数。

导入包：

我们有另外两个保存了不同函数的文件：

Phone/Isdn.py 含有函数Isdn()

Phone/G3.py 含有函数G3()

现在，在Phone目录下创建file __init__.py：

Phone/__init__.py

当你导入Phone时，为了能够使用所有函数，你需要在__init__.py里使用显式的导入语句，如下：

from Pots import Pots

from Isdn import Isdn

from G3 import G3

当你把这些代码添加到__init__.py之后，导入Phone包的时候这些类就全都是可用的了。

类的使用：

#coding=utf-8
class Employee:
   '所有员工的基类'
   empCount = 0
   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
   
   def displayCount(self):
     print "Total Employee %d" % Employee.empCount
   def displayEmployee(self):
      print "Name : ", self.name,  ", Salary: ", self.salary
"创建 Employee 类的第一个对象"
emp1 = Employee("Zara", 2000)
"创建 Employee 类的第二个对象"
emp2 = Employee("Manni", 5000)      

__dict__ : 类的属性（包含一个字典，由类的数据属性组成）

__doc__ :类的文档字符串

__name__: 类名

__module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod）

__bases__ : 类的所有父类构成元素（包含了以个由所有父类组成的元组）

当对象被创建时， 就创建了一个引用计数， 当这个对象不再需要时， 也就是说， 这个对象的引用计数变为0 时， 它被垃圾回收。但是回收不是"立即"的， 由解释器在适当的时机，将垃圾对象占用的内存空间回收。

析构函数 __del__ ，__del__在对象消逝的时候被调用，当对象不再被使用时，__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, "destroyed"      

类的继承：

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 '调用子类方法 child method'      

issubclass() - 布尔函数判断一个类是另一个类的子类或者子孙类，语法：issubclass(sub,sup)

isinstance(obj, Class) 布尔函数如果obj是Class类的实例对象或者是一个Class子类的实例对象则返回true。

运算符重载：

def __add__(self,other):
    return Vector(self.a + other.a, self.b + other.b)
class JustCounter:
__secretCount = 0  # 私有变量
publicCount = 0    # 公开变量      

__init__ ( self [,args...] )

构造函数

简单的调用方法: obj = className(args)

__del__( self )

析构方法, 删除一个对象

简单的调用方法 : dell obj

__repr__( self )

转化为供解释器读取的形式

简单的调用方法 : repr(obj)

__str__( self )

用于将值转化为适于人阅读的形式

简单的调用方法 : str(obj)

__cmp__ ( self, x )

对象比较

简单的调用方法 : cmp(obj, x)

str()一般是将数值转成字符串。 

repr()是将一个对象转成字符串显示，注意只是显示用，有些对象转成字符串没有直接的意思。如list,dict使用str()是无效的，但使用repr可以，这是为了看它们都有哪些值，为了显示之用。 

正则表达式：

import re
line = "Cats are smarter than dogs"
matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I)
if matchObj:
   print "matchObj.group() : ", matchObj.group()
   print "matchObj.group(1) : ", matchObj.group(1)
   print "matchObj.group(2) : ", matchObj.group(2)
else:
   print "No match!!"      

输出：

matchObj.group() :  Cats are smarter than dogs

matchObj.group(1) :  Cats

matchObj.group(2) :  smarter

re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。

正则表达式替换：

phone = "2004-959-559 # This is Phone Number"
# Delete Python-style comments
num = re.sub(r'#.*$', "", phone)
print "Phone Num : ", num
# Remove anything other than digits
num = re.sub(r'\D', "", phone)    
print "Phone Num : ", num      

re.I使匹配对大小写不敏感

re.L做本地化识别（locale-aware）匹配

re.M多行匹配，影响 ^ 和 $

re.S使 . 匹配包括换行在内的所有字符

re.U根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.

re.X该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。

[...]用来表示一组字符,单独列出：[amk] 匹配 'a'，'m'或'k'

[^...]不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。