基础语法 变量 运算符 流程控制 字符串 列表/元组/字典 日期时间 函数 模块/包 异常处理 文件I/O 面向对象

基础语法

					#!/usr/bin/python
					# _*_ coding: UTF-8 _*_
					
					#这是注释
					
					'''
					这是多行注释，使用单引号。
					这是多行注释，使用单引号。
					这是多行注释，使用单引号。
					'''
					
					"""
					这是多行注释，使用双引号。
					这是多行注释，使用双引号。
					这是多行注释，使用双引号。
					"""

变量

Python有五个标准的数据类型：Numbers（数字） String（字符串） List（列表） Tuple（元组） Dictionary（字典）

					#!/usr/bin/python
					# -*- coding: UTF-8 -*-
					 
					counter = 100 # 赋值整型变量
					miles = 1000.0 # 浮点型
					name = "John" # 字符串
					list = [ 'runoob', 786 , 2.23, 'john', 70.2 ] # 列表
					tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 ) # 元组
					tinydict = {'name': 'john','code':6734, 'dept': 'sales'} # 字典 
					a, b, c = 1, 2, "john" #多个变量赋值
数据类型转换
函数描述
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) 将一个整数转换为一个八进制字符串

运算符

运算符描述实例
+ 加 - 两个对象相加 a + b 输出结果 30
- 减 - 得到负数或是一个数减去另一个数 a - b 输出结果 -10
* 乘 - 两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 200
/ 除 - x除以y b / a 输出结果 2
% 取模 - 返回除法的余数 b % a 输出结果 0
** 幂 - 返回x的y次幂 a**b 为10的20次方， 输出结果 100000000000000000000
// 取整除 - 返回商的整数部分 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0
== 等于 - 比较对象是否相等 (a == b) 返回 False。
!= 不等于 - 比较两个对象是否不相等 (a != b) 返回 true.
<> 不等于 - 比较两个对象是否不相等 (a <> b) 返回 true。这个运算符类似 != 。
> 大于 - 返回x是否大于y (a > b) 返回 False。
< 小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。 (a < b) 返回 true。
>= 大于等于 - 返回x是否大于等于y。 (a >= b) 返回 False。
<= 小于等于 - 返回x是否小于等于y。 (a <= b) 返回 true。
= 简单的赋值运算符 c = a + b 将 a + b 的运算结果赋值为 c
+= 加法赋值运算符 c += a 等效于 c = c + a
-= 减法赋值运算符 c -= a 等效于 c = c - a
*= 乘法赋值运算符 c *= a 等效于 c = c * a
/= 除法赋值运算符 c /= a 等效于 c = c / a
%= 取模赋值运算符 c %= a 等效于 c = c % a
**= 幂赋值运算符 c **= a 等效于 c = c ** a
//= 取整除赋值运算符 c //= a 等效于 c = c // a
& 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 (a & b) 输出结果 12 ，二进制解释： 0000 1100
| 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。 (a | b) 输出结果 61 ，二进制解释： 0011 1101
^ 按位异或运算符：当两对应的二进位相异时，结果为1 (a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~ 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1 (~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。
<< 左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。 a << 2 输出结果 240 ，二进制解释： 1111 0000
>> 右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数 a >> 2 输出结果 15 ，二进制解释： 0000 1111
and 布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。 (a and b) 返回 20。
or 布尔"或" - 如果 x 是非 0，它返回 x 的值，否则它返回 y 的计算值。 (a or b) 返回 10。
not 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 not(a and b) 返回 False
in 如果在指定的序列中找到值返回 True，否则返回 False。 x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in 如果在指定的序列中没有找到值返回 True，否则返回 False。 x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。
is is 是判断两个标识符是不是引用自一个对象 x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not is not 是判断两个标识符是不是引用自不同对象 x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

流程控制

					#!/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'     # 条件均不成立时输出
					    
					#while循环
					count = 0
					while count < 5:
					   print count, " is  less than 5"
					   count = count + 1
					   break	#中断循环
					else:
					   pass #空处理，不做任何事
					
					#for循环
					fruits = ['banana', 'apple',  'mango']
					for fruit in fruits:
					   print '当前水果 :', fruit
					   continue #跳过本次循环

字符串

					#!/usr/bin/python
					# -*- coding: UTF-8 -*-
					
					#字符串初始化
					var1 = 'Hello World!'
					var2 = "Python Runoob"
					errHTML = '''
					<HTML><HEAD><TITLE>
					Friends CGI Demo</TITLE></HEAD>
					<BODY><H3>ERROR</H3>
					<B>%s</B><P>
					<FORM><INPUT TYPE=button VALUE=Back
					ONCLICK="window.history.back()"></FORM>
					</BODY></HTML>
					'''

					print "var1 + var2 输出结果：", var1 + var2  #连接字符串
					print "var1 * 2 输出结果：", var1 * 2  #重复字符串
					print "var1[0]: ", var1[0]
					print "var2[1:5]: ", var2[1:5]
					
					if( "H" in a) :
					    print "H 在变量 a 中" 
					else :
						print "H 不在变量 a 中" 
					
					if( "M" not in a) :
					    print "M 不在变量 a 中" 
					else :
						print "M 在变量 a 中"
					
					print "My name is %s and weight is %d kg!" % ('Zara', 21)  #字符串格式化

列表/元组/字典

					#!/usr/bin/python
					# -*- coding: UTF-8 -*-
					
					#列表
					list1 = ['physics', 'chemistry', 1997, 2000];
					list2 = [1, 2, 3, 4, 5, 6, 7 ];
					list[2] = 2001;
					del list1[2]; #删除元素
					print len(list2); #获取长度
					print "list1[0]: ", list1[0];
					print "list2[1:5]: ", list2[1:5];
					
					#元组
					tup1 = ('physics', 'chemistry', 1997, 2000);
					tup2 = (1, 2, 3, 4, 5, 6, 7 );
					print "tup1[0]: ", tup1[0]
					print "tup2[1:5]: ", tup2[1:5]
					tup3 = tup1 + tup2; #元组相加
					print len(tup3); #获取长度
					del tup1; #删除元组
					
					#字典
					dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
					print "dict['Name']: ", dict['Name'];
					dict['Age'] = 8; # update existing entry
					dict['School'] = "DPS School"; # Add new entry
					del dict['Name']; # 删除键是'Name'的条目
					dict.clear();     # 清空词典所有条目
					del dict ;        # 删除词典
					print len(dict);  # 获取长度

日期时间

					#!/usr/bin/python
					# -*- coding: UTF-8 -*-
					
					import time;  # 引入time模块
					import calendar;
					
					ticks = time.time()
					print "当前时间戳为:", ticks
					
					localtime = time.localtime(time.time())
					print "本地时间为 :", localtime
					
					localtime = time.asctime( time.localtime(time.time()) )
					print "本地时间为 :", localtime
					
					# 格式化成2016-03-20 11:45:39形式
					print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) 
					# 格式化成Sat Mar 28 22:24:24 2016形式
					print time.strftime("%a %b %d %H:%M:%S %Y", time.localtime()) 
					# 将格式字符串转换为时间戳
					a = "Sat Mar 28 22:24:24 2016"
					print time.mktime(time.strptime(a,"%a %b %d %H:%M:%S %Y"))
					
					cal = calendar.month(2016, 1)
					print "以下输出2016年1月份的日历:"
					print cal;

函数

					#!/usr/bin/python
					# -*- coding: UTF-8 -*-
					
					#可写函数说明
					def printme( str ):
					   "打印任何传入的字符串"
					   print str;
					   return;
					   
					#调用printme函数
					printme();
					#调用printme函数
					printme( str = "My string");
					
					#缺省参数
					def printinfo( name, age = 35 ):
					   "打印任何传入的字符串"
					   print "Name: ", name;
					   print "Age ", age;
					   return;
					
					#不定长参数   
					def printinfo( arg1, *vartuple ):
					   "打印任何传入的参数"
					   print "输出: "
					   print arg1
					   for var in vartuple:
					      print var
					   return;
					   
					# 匿名函数
					sum = lambda arg1, arg2: arg1 + arg2;

模块/包

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

					#!/usr/bin/python
					# -*- coding: UTF-8 -*-
					
					# 导入模块
					import support
					from fib import fibonacci
					from math import *

包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的 Python 的应用环境。简单来说，包就是文件夹，但该文件夹下必须存在 __init__.py 文件, 该文件的内容可以为空。__int__.py用于标识当前文件夹是一个包。

					#!/usr/bin/python
					# -*- coding: UTF-8 -*-
					#package_runoob/__init__.py
					 
					if __name__ == '__main__':
					    print '作为主程序运行'
					else:
					    print 'package_runoob 初始化'

异常处理

					#!/usr/bin/python
					# -*- coding: UTF-8 -*-
					
					try:
					    fh = open("testfile", "w")
					    try:
					        fh.write("这是一个测试文件，用于测试异常!!")
					        #触发异常
					        raise Exception("Invalid level!", level)
					    finally:
					        print "关闭文件"
					        fh.close()
					except IOError:
					    print "Error: 没有找到文件或读取文件失败"
					else:
					    print "内容写入文件成功"
					    fh.close()

文件I/O

					#!/usr/bin/python
					# -*- coding: UTF-8 -*- 
					
					import os
					
					# 重命名文件test1.txt到test2.txt。
					os.rename( "test1.txt", "test2.txt" )
					
					# 删除一个已经存在的文件test2.txt
					os.remove("test2.txt")
					
					# 创建目录test
					os.mkdir("test")
					
					# 将当前目录改为"/home/newdir"
					os.chdir("/home/newdir")
					
					# 给出当前的目录
					print os.getcwd()
					
					# 删除”/tmp/test”目录
					os.rmdir( "/tmp/test")
					
					print "Python 是一个非常棒的语言，不是吗？";
					
					#raw_input([prompt]) 函数从标准输入读取一个行，并返回一个字符串（去掉结尾的换行符）
					str = raw_input("请输入：");
					print "你输入的内容是: ", str
					
					#input([prompt]) 函数和 raw_input([prompt]) 函数基本类似，但是 input 可以接收一个Python表达式作为输入，并将运算结果返回。
					str = input("请输入：");
					print "你输入的内容是: ", str
					
					# 打开一个文件
					fo = open("foo.txt", "wb")
					print "文件名: ", fo.name
					print "是否已关闭 : ", fo.closed
					print "访问模式 : ", fo.mode
					print "末尾是否强制加空格 : ", fo.softspace
					#写入内容
					fo.write( "Very good!\n");
					#读取内容
					str = fo.read(10);
					print "读取的字符串是 : ", str
					# 关闭打开的文件
					fo.close()

面向对象

					#!/usr/bin/python
					# -*- 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)
					emp1.displayEmployee()
					emp2.displayEmployee()
					print "Total Employee %d" % Employee.empCount
					
					hasattr(emp1, 'age')    # 如果存在 'age' 属性返回 True。
					getattr(emp1, 'age')    # 返回 'age' 属性的值
					setattr(emp1, 'age', 8) # 添加属性 'age' 值为 8
					delattr(empl, 'age')    # 删除属性 'age'
					
					print "Employee.__doc__:", Employee.__doc__
					print "Employee.__name__:", Employee.__name__
					print "Employee.__module__:", Employee.__module__
					print "Employee.__bases__:", Employee.__bases__
					print "Employee.__dict__:", Employee.__dict__			
					
					#!/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 '调用子类方法 child method'
					 
					c = Child()          # 实例化子类
					c.childMethod()      # 调用子类的方法
					c.parentMethod()     # 调用父类方法
					c.setAttr(200)       # 再次调用父类的方法
					c.getAttr()          # 再次调用父类的方法