Python 语法

  • python 一切都是对象，变量也是

基础语法

一、常用语法

1、HELLO WORLD

  2. * 创建文件
  3. touch test.py
  4. print "hello world";
  7. 1.指定路径执行
  8.   /usr/bin/python test.py
  11. 2.文件首行写执行环境,像 shell 的 #!/bin/bash
  12.   #!/usr/bin/python
  13.   ./test.py

2、数据类型

  2. 1、字符串
  3.   1) str='this is string';
  5.   2) 多行字符串
  6.     str='''this is string
  7.     this is pythod string
  8.     this is string'''
  9.   print str;
  11. 2、布尔类型
  12.   bool=False;
  14. 3、整数
  15.   int=20;
  17. 4、浮点数
  18.   float=2.3;
  20. 5、数字
  21.   包括整数、浮点数
  23. 6、列表 list
  24.   list=['physics', 'chemistry', 1997, 2000];
  26. 7、元组 tuple
  27.   tup1 = ('physics', 'chemistry', 1997, 2000);
  29. 8、字典
  30.   dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'};
  32. 9、日期
  33.   import time, datetime;
  34.   http://www.cnblogs.com/linjiqin/p/3608541.html
  36.   time.sleep()

3、变量赋值

  2. 1. 统一赋值
  3.   x , y , z = 1 , 2 , 3
  5. 2. 元祖赋值
  6.   x = 1,2,3
  7.   print x
  8.     (1, 2, 3)
  10. 3. 链式赋值
  11.   x = y = 1
  13. 4. 查看变量类型
  14.   x.__class__
  16. 5. 定义全局变量
  17.   global a;

4、逻辑判断

  2. 1.bool() 函数验证参数布尔值
  3.   print bool(1)
  5. 2.if elif else
  6.   name = raw_input("what's you name");
  7.   if name.endswith("jason"):
  8.     print "hello" + name;
  9.   elif name.endswith("ray"):
  10.     print "hello" + name
  11.   else:
  12.     print "who are youj"
  14. 3.表达式
  15.   x == y
  16.   x != y
  17.   x is y        x 和 y 是同一个对象
  18.   x is not y    x 和 y 不是同一个对象
  19.   x in y        x 是 y 容器 (如，序列) 的成员
  20.   x not in y    x 不是 y 容器 (如，序列) 的成员
  22. 4. and 和 or
  23.   1) if ("a" == "a") and ("aaa" == "aaa1"):
  24.       false
  26.   2) if ("a" == "a") or ("aaa" == "aaa1"):
  27.       true
  29. 4. None
  30.   if xxx is None:
  31.     pass
  33. 5. in
  34.   if xxx in (aaaa,bbb,ccc)
  35.     pass
  37. 6. 三元表达式
  38.   status = True
  39.   status and 'Y' or 'N'

5、循环

  2. * ps
  3.   continue 跳过当前循环
  4.   break    退出循环
  6. 1. while
  7.   status = True;
  8.   i = 0;
  10.   while status == True :
  11.     print i
  12.     i += 1;
  13.     if i > 100 :
  14.         status = False
  16. 2. for
  17.   1) 普通循环
  18.     codes = ['a','b','c','d','e','f','g','h','i','j']
  19.     for now_code in codes:
  20.       print now_code
  22.   2) 字典遍历
  23.     map_data = {'a': 1 , 'b' : 2 , 'c' : 3}
  24.     for key in map_data:
  25.       print key , "-" , map_data[key]
  27.   3) 深度遍历
  28.     for i,obj in  [('host', '10.10.2.91'), ('user', 'hadoop')]:
  29.       print i,obj
  31.     host 10.10.2.91
  32.     user hadoop
  34.   4) 循环次数，0 到 10
  35.     import math
  36.     for i in range(0,10):
  37.       print i
  39.     在需要的时候生成 list  
  40.     for i in xrange(0,10):
  41.       print i
  43.   5) 字典遍历
  44.     person={'name':'lizhong','age':'26','city':'BeiJing','blog':'www.jb51.net'}
  46.     for key,value in person.items():
  47.       print 'key=',key,'，value=',value
  49.     key= blog ，value= www.jb51.net
  50.     key= city ，value= BeiJing
  51.     key= age ，value= 26
  52.     key= name ，value= lizhong

6、自省

  2. 1. pass 当前行跳过,相当远行占位符
  5. 2. del 删除变量名,但不删除内存数据
  6.   x = 1
  7.   del x
  9. 3. exec() 执行字符语句
  10.   1) 一般执行
  11.     exec "print 'hello world'"
  13.   2) 命名空间执行
  14.     nameSpace = {} #定义一个字段
  15.     exec "a = 1" in nameSpace; #把执行的数据放入字段中
  16.     print nameSpace['a'] #即可全局获取
  18. 4. eval() 用于求值
  19.   print eval("1 + 2")
  22. 5. help() 帮助
  23.     help(str)
  25. 6. type() 查看数据类型
  26.     type("Hello")
  28. 7. isinstance() 验证一个对象，是否是另外一个对象的类型
  29.     isinstance('hellow',str)
  31. 8. dir() 查看对象所有的函数
  32.     dir(str)

二、字符串

  2. 1. print "Let's go" + ",Jason"
  5. 2. repr() 和 ``(不建议使用 ``) 是把结果字符串转换为合法的 Python 表达式
  6.   1) print repr("Hello,world!");
  7.     'Hello,world!'
  9.   2) print repr(10000L);
  10.     10000L
  12.   3) x = "test";
  13.     print repr(x);
  14.       'test'
  17. 3. str() 把值转换成字符串
  18.   1) print str("Hello World");
  19.       Hello World
  21.   2) print str(10000L);
  22.       10000
  25. 4. print r 原始字符输出
  26.   1) print r'C:\Program'
  27.       C:\Program
  30. 5. 字符串连接
  31.   1) 关键字 %
  32.     str = "%s %s"%('a','b');
  34.     字典替换
  35.     str = '''%(a)s %(b)s %(c)s'''% {'a':'a1', 'b':'b1', 'c':'c1'}
  38.     %c    转换成字符(ASCII 码值,或者长度为一的字符串)
  39.     %r    优先用 repr()函数进行字符串转换
  40.     %s    优先用 str()函数进行字符串转换
  41.     %d / %i    转成有符号十进制数
  42.     %ub    转成无符号十进制数
  43.     %ob    转成无符号八进制数
  44.     %xb/%Xb    (Unsigned)转成无符号十六进制数(x/X 代表转换后的十六进制字符的大小写)
  45.     %e/%E    转成科学计数法(e/E 控制输出 e/E)
  46.     %f/%F    转成浮点数(小数部分自然截断)
  47.     %g/%G    %e 和%f/%E 和%F 的简写
  48.     %%    输出%
  50.   2) join
  51.     var_list = ['tom', 'david', 'john']
  52.     #按照 , 号组合
  53.     str = ','.join(var_list)
  55.   3) 元祖
  56.     xx = 'Jim', 'Green'
  57.     str = ','.join(xx)
  59.   4) 字符串连接
  60.     str = "Let's go" + ",Jason"
  63. 6. split 分割字符串
  64.     s = u'1*2*3*4'
  65.     s.split('*')
  67.     [u'1', u'2', u'3', u'4']
  70. 7. join 字符串
  71.   s = u'alexzhou'
  72.   u'*'.join(s)
  74.   u'a*l*e*x*z*h*o*u'
  77. 8. replace 替换字符串
  78.    s = u'111111'
  79.    s.replace('1','2')
  81.    u'222222'
  84. 9. 正则表达式
  86.   *) 参数说明
  87.     pattern: 匹配的正则表达式
  88.     string: 要匹配的字符串
  89.     flags: 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。
  90.       re.I    使匹配对大小写不敏感
  91.       re.L    做本地化识别（locale-aware）匹配
  92.       re.M    多行匹配，影响 ^ 和 $
  93.       re.S    使 . 匹配包括换行在内的所有字符
  94.       re.U    根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.
  95.       re.X    该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。
  97.   1) re.match(pattern, string, flags=0), 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none
  98.     import re
  100.     pattern = r'(.*) are (.*?) .*'
  101.     line = "Cats are smarter than dogs"
  102.     matchObj = re.match(pattern, line, re.M|re.I)
  104.     if matchObj:
  105.      print "matchObj.group() : ", matchObj.group()
  106.      print "matchObj.group(1) : ", matchObj.group(1)
  107.      print "matchObj.group(2) : ", matchObj.group(2)
  108.     else:
  109.        print "No match!!"
  112.   2) re.search(pattern, string, flags=0), 扫描整个字符串并返回第一个成功的匹配
  113.     import re
  115.     pattern = r'(.*) are (.*?) .*'
  116.     line = "Cats are smarter than dogs";
  117.     searchObj = re.search(pattern, line, re.M|re.I)
  119.     if searchObj:
  120.      print "searchObj.group() : ", searchObj.group()
  121.      print "searchObj.group(1) : ", searchObj.group(1)
  122.      print "searchObj.group(2) : ", searchObj.group(2)
  123.     else:
  124.      print "Nothing found!!"
  127.   3) re.sub(pattern, repl, string, count=0, flags=0), 替换
  129.     参数解释:
  130.       pattern : 正则中的模式字符串。
  131.       repl : 替换的字符串，也可为一个函数。
  132.       string : 要被查找替换的原始字符串。
  133.       count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。
  135.     import re
  137.     phone = "2004-959-559 # 这是一个国外电话号码"
  139.     # 删除字符串中的 Python注释
  140.     num = re.sub(r'#.*$', "", phone)
  141.     print "电话号码是: ", num
  143.     # 删除非数字(-)的字符串
  144.     num = re.sub(r'\D', "", phone)
  145.     print "电话号码是 : ", num
  148.   4) Pattern, 是一个编译好的正则表达式，通过Pattern提供的一系列方法可以对文本进行匹配查找
  150.     value = "jason"
  151.     line = "jason so cool"
  153.     # 获取正则对象
  154.     pattern = re.compile(value)
  155.     # 检索
  156.     match = pattern.search(line)
  158.     print match.group(0)

三、数组

  • 列表 (可以修改)
    • 索引
    • 分片
    • 步长
    • 序列运算
    • 成员资格 (是否存在)
    • 函数
    • 操作
  • 元祖 (不能修改)
  • 字典

1、序列

  2. 1.定义序列
  3.   1) 普通定义
  4.     edward = ['Edward Gumby',42];
  5.     john = ['John Smith',50];
  6.     databases = [edward,john];
  8.     print databases
  9.       [['Edward Gumby', 42], ['John Smith', 50]]
  11. 2.索引
  12.   1) 字符串序列 (字符串就是由字符组成的序列)
  13.     greeting = 'Hello'
  14.     #从第 0 个索引获取
  15.     print greeting[0]
  16.       H
  17.     #从最后一个索引获取
  18.     print greeting[-1]
  21. 3.分片 (边界操作)
  22.   code = ['a','b','c','d','e','f','g','h','i','j']
  24.   1) 取索引 3 ~ 6 范围数据
  25.     print code[3:6]
  26.       ['d', 'e', 'f']
  28.   2) 取索引 3 ~ 最后所有的数据
  29.     print code[3:]
  30.       ['d', 'e', 'f', 'g', 'h', 'i', 'j']
  32.   3) 取最后索引 -3 ~ 为止，最后的所有数据
  33.     print code[-3:]
  34.       ['h','i','j']
  36.   4) 取索引 0 - 4 边界的数据
  37.     print code[:4]
  38.       ['a', 'b', 'c', 'd']
  40.   4) 取索引 0 - max()-1 位置的数据
  41.     print code[:-1]
  42.       ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
  45. 4.步长 (每次数据指针跳过动的位置，默认 1)
  46.   code = ['a','b','c','d','e','f','g','h','i','j']
  48.   1) 默认是步长 1
  49.     print code[0:10:1]
  50.       ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
  52.   2) 设置步长 3
  53.     print code[0:10:3]
  54.       ['a', 'd', 'g', 'j']
  57. 5. 序列运算
  58.   other = ['st','nd','rd'] + 2 * ['th'] \
  59.         + ['st','nd','rd'] + 3 * ['zd']
  60.   print other
  61.     ['st', 'nd', 'rd', 'th', 'th', 'st', 'nd', 'rd', 'zd', 'zd', 'zd']
  64. 6.成员资格
  65.   1) 是否在序列中
  66.     code = ['a','b','c','d','e','f','g','h','i','j']
  68.     print 'a' in code
  69.       True
  70.     print 'z' in code
  71.       False
  73.   2) 组合验证
  74.     box = [
  75.       ['a',123],
  76.       ['b',456]
  77.     ]
  79.     print ['a',123] in box
  80.       True
  81.     print ['a',8989] in box
  82.       False
  84. 7.函数
  86.   len() max() min()
  87.   1) len()
  88.     numbers = [1,2,3,4,5,6,7,8,9,10]
  89.     print len(numbers)
  90.       10
  92.   2) max()
  93.     numbers = [1,2,3,4,5,6,7,8,9,10]
  94.     print max(numbers)
  95.       10
  97.   3) min()
  98.     numbers = [1,2,3,4,5,6,7,8,9,10]
  99.     print min(numbers)
  100.       1
  102.     print min(1,3,6,8)  
  103.       1
  106.   list() join()
  107.   1) list() 字符串转数字
  108.     arr_hello = list("Hello") ;
  109.     print arr_hello
  110.       ['H', 'e', 'l', 'l', 'o']
  112.   2) join() 数组转字符串
  113.     str_hello = ''.join(arr_hello)
  114.     print str_hello
  115.       Hello
  119.   append() count() extend() index() insert() pop() remove() reverse() sort()
  121.   1) append() 追加对象
  122.     code = ['a','b','c','d']
  123.     code.append('e')
  125.   2) count() 统计元素在数组出现的次数
  126.     code = ['a','b','c','d',[2,3]]
  127.     code.count('a')
  128.     code.count([2,3])
  130.   3) extend() 在数组尾部追加 1 个或者 n 个值
  131.     code = ['a','b','c','d']
  132.     code.extend('a')
  133.     code.extend([2,3])
  135.   4) index() 找出值所在索引位置
  136.     code = ['a','b','c','d']
  137.     code.index('b')
  139.   5) insert() 指定位置插入数据
  140.     code = ['a','b','c','d']
  141.     code.insert(3, 'zzzzz')
  143.   6) pop() 从尾部移除数组值
  144.     code = ['a','b','c','d']
  145.     code.pop(2)
  146.     print code
  147.       ['a', 'b', 'd']
  149.   7) remove() 移除匹配的值
  150.     code = ['a','b','c','d']
  151.     code.remove('b')
  153.   8) reverse() 倒序排序
  154.     numbers = [1,3,2,5,4]
  155.     numbers.reverse();
  156.     print numbers
  157.       [4, 5, 2, 3, 1]
  159.   9) sort() 正序排序
  160.     numbers = [1,3,2,5,4]
  161.     numbers.sort();
  162.     print numbers
  163.       [1, 2, 3, 4, 5]
  166. 8.操作
  168.   1) 修改元素
  169.     code = ['a','b','c','d']
  170.     code[0] = 'aaa';
  171.     print code
  172.       ['aaa', 'b', 'c', 'd']
  174.   2) 删除元素
  175.     code = ['a','b','c','d']
  176.     del code[2]
  177.     print code
  178.       ['a', 'b', 'd']
  180.   3) 分片赋值
  181.     code = ['a','b','c','d']
  182.     code[1:] = list('Hello')
  183.     print code
  184.       ['a', 'H', 'e', 'l', 'l', 'o']
  186.   4) 替换为空
  187.     code = ['a','b','c','d']
  188.     code[2:4] = []
  189.     print code
  190.       ['a', 'b']

2、元祖

  2. 1.普通定义  “,” 逗号很重要(这是标识 元祖的)
  4.   code = ('a','b','c','d',)
  5.   print code[0]
  8. 2.函数
  9.   tuple()  
  11.   1) tuple() 与 list() 基本一致,序列转换成元祖
  12.     code = ['a','b','c','d']
  13.     print tuple(code)
  14.       ('a', 'b', 'c', 'd')

3、字典

  2. 1.定义 字典
  4.   map_arr = {}
  5.   map_arr['a'] = 123;
  6.   map_arr['b'] = 456;
  7.   print map_arr
  9. 2.查找元素
  10.   print map_arr[a]
  12. 3.函数
  13.   1) 长度
  14.     print len(map_arr)
  16.   2) 转换成序列、元祖
  17.     print map_arr.items()
  18.       [('a', 123), ('b', 456)]
  20.   3) map_arr.has_key('a') 验证 key 是否存在
  22.   4) map_arr.get('a') 获取值
  24.   5) map_arr.update({'a':456}) 修改值
  26.   6) map_arr.setdefault({'a':456})
  27.     若key存在，则覆盖之前的值，若key不存在，则给字典添加key-value对
  29. 4. 2 个列表转换为字典
  30.   dict(zip(['a','b','c'],[1,2,3]))

四、函数和类

1、函数

  2. 1.定义函数
  3.   1) 普通参数
  4.     def fn_test(a,b='a'):
  5.       print a
  6.       print b
  8.       return a;
  10.     fn_test(1,2)
  12.   2) 加 *(元祖) 的参数
  13.     def test_fn(*args):
  14.       print args
  15.       print args[0]
  17.     #把参数转换为元祖
  18.     test_fn(1,2,3,4,6)
  20.   3) 加 **(字典) 的参数
  21.     def test_fn(**args):
  22.       print args
  23.       print args['a']
  25.     #把参数转换为字典
  26.     test_fn(a='aaa',b='bbb')

2、类

  2. 1. 简单定义
  3.   class Test:
  5.       def __init__(self,name,age):
  6.           self.name = name;
  7.           self.age = age;
  9.       def echo(self):
  10.           return self.name + self.age;
  13.   test = Test("a","b");
  16.   print test.echo()
  18. 2. 继承
  19.   class Apple(Test):
  20.     def __init__(self,name,age):
  21.         #调用父类方法
  22.          Test.__init__(self, name,age)
  24.     #重写父类方法
  25.     def echo(self):
  26.       return self.name + self.age
  29. 3.静态类的方法
  31.   class Apple:
  33.     @staticmethod
  34.       def method():
  35.         pass
  37.   访问：Apple.method()

五、模块

1、导入模块

  2. #自定义包路径
  3. global BASE_PATH;
  4. BASE_PATH = os.getcwd();
  5. core_path = BASE_PATH + "/core";
  6. #sys.path.append(core_path);  
  8. 1.import model_name
  10. 2.import model_name as model_as_name
  11.   model_as_name.function_1()
  13. 3.from model_name import function_1 as fun_as,function_2
  14.        (文件名)           (类名)  
  15.   fun_as()
  16.   function_2()

2、动态加载模块

  1. package = 'test.test_run'
  2. module = 'TestRun'
  3. importClass = __import__(package, fromlist=[module])
  4. className = getattr(importClass, module)
  6. serviceObject = className()

六、异常

  2. 1. try except 捕获异常
  3.   1) 执行try下的语句，如果引发异常，则执行过程会跳到第一个except语句
  4.   2) 如果第一个except中定义的异常与引发的异常匹配，则执行该except中的语句
  5.   3) 如果引发的异常不匹配第一个except，则会搜索第二个except，允许编写的except数量没有限制
  6.   4) 如果所有的except都不匹配，则异常会传递到下一个调用本代码的最高层try代码中
  7.   5) 如果没有发生异常，则执行else块代码
  9. try:
  10.   status = True
  11. except Exception,ex:
  12.   print Exception,":",ex
  13.   status = False
  14. else:
  15.   xx
  17. 2。try finally
  18.   1) try 中无论有没有发生异常都要执行代码 finally 下的代码
  19.   2) 如果发生异常，在该异常传递到下一级try时，执行finally中的代码
  20.   3) 如果没有发生异常，则也执行finally中的代码
  21. try:
  22.    block
  23. finally:
  24.    block