变量

1、变量赋值

• python中的变量赋值不需要类型声明
• 每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。
• 每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建

a = b = c = 1
a, b, c = 1, 2, "jsion"

2、python的数据类型

• Numbers（数字）（int,long,float,complex）
• String（字符串）
• List（列表）
• Tuple（元组）
• Dictionary（字典）

3、数据类型转换

4、变量作用域

• 全局变量
• 局部变量

运算符

• 算数运算符

  + - * / % **(幂) //(向下取整除)

• 比较运算符

  == != > < >= <=

• 赋值运算符

  = += -= *= /= %= **= //=

• 逻辑运算符

  and or not

• 位运算符,按位运算符是把数字看作二进制来进行计算

  & | ^(按位异或) ~(按位取反) <<(高位丢弃，低位补0) >>

• 成员运算符

  in not in

• 身份运算符

  is : 判断两个标识符是不是引用自一个对象(是否为一个内存空间),类似 id(x) == id(y)

  is not

• 运算符优先级

  指数 > 按位 > * / %/ // > 加减 > 位移 > & > ^ | > 比较运算符 > == !== > 赋值运算符 > 身份运算符 > 成员运算符 > 逻辑运算符

条件语句

if 判断语句:            #冒号不可少
    执行语句s
else：
    执行语句s

---

if 判断条件1:
    执行语句1……
elif 判断条件2:
    执行语句2……
elif 判断条件3:
    执行语句3……
else:
    执行语句4……

循环语句（for ,while, until,嵌套循环）

1、for 循环

for iterating_var in sequence:
   statements(s)

for ...else   #for 中的语句和普通的没有区别，else 中的语句会在循环正常执行完(即 for 不是通过 break 跳出而中断的)的情况下执行

2、while 循环

while 判断条件(condition)：
    执行语句(statements)……
else:
    执行语句......

3、until

4、嵌套循环

#for 循环嵌套
for iterating_var in sequence:
   for iterating_var in sequence:
      statements(s)
   statements(s)

#while 循环嵌套
while expression:
   while expression:
      statement(s)
   statement(s)
#for while 相嵌

循环控制语句（break,continue,pass）

1、break

• break语句用来终止循环语句，即循环条件没有False条件或者序列还没被执行完
• 如果嵌套循环，break语句将停止执行最深层的循环，并开始执行下一行代码

2、continue

• Python continue 语句跳出本次循环，而break跳出整个循环。
• continue 语句用来告诉Python跳过当前循环的剩余语句，然后继续进行下一轮循环

3、pass

• pass不做任何事情，一般用做占位语句

数字，字符串，列表，元组，字典，日期和时间

1、数字Number

• int long float complex

• 数据类型是不允许改变的,这就意味着如果改变 Number 数据类型的值，将重新分配内存空间

• 赋值与删除

  #赋值
   var = 1
  # 删除
  del var 
  

2、字符串string

• python的字串列表有2种取值顺序

  • 从左到右索引默认0开始的，最大范围是字符串长度少1

  • 从右到左索引默认-1开始的，最大范围是字符串开头

    # [头下标:尾下标] 获取的子字符串包含头下标的字符，但不包含尾下标的字符
    >>> s = 'abcdef'
    >>> s[1:5]
    'bcde'
    

  • 加号（+）是字符串连接运算符，星号（*）是重复操作

• 定义,使用引号('或")来创建字符串

  var1 = 'hello'
  var2 = "world"
  

• 字符串运算符

  + * [] [:] in not in r/R(原始字符串)pritn(r'\n') 输出\n

  %(格式字符串)：基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。

  符号	描述
  %s	格式化字符串
  %d	格式化整数
  %f	格式化浮点数字，可指定小数点后的精度
  %u	格式化无符号整型

  print "I %s love %s !" % ('weiwei', "baby")
  输出结果: I weiwei love baby !
  

3、列表

• 序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。

• 序列都可以进行的操作包括索引，切片，加，乘，检查成员

• 定义

  list = ['a',2,"b"]
  

• 访问，更新,删除，操作符

  #访问
  list[1] list[1:4] list[:4] list[2:]  list[-1]...
  #更新
  list[1]=NEW_VALUE
  list.append()
  #删除
  del list[1]   del list[:]
  #操作符
   + * in   not in
  

4、元组

• Python的元组与列表类似，不同之处在于元组的元素不能修改。

• 定义，访问,修改，删除,运算符

  #定义
   tup = ('a',1,"bb")
   tup =('a',)#创建一个元素是需要在元素后面添加逗号
  #访问
   tup[0]   tup[-1] tup[:]
  #修改
   元组中的元素值是不允许修改的，但我们可以对元组进行连接组合
  #删除
  del tup
  #运算符
  + * in  not in
  

5、字典

• 字典是另一种可变容器模型，且可存储任意类型对象

• 字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中

• 值可以取任何数据类型，但键必须是不可变的(数字，字符串，元组)，如字符串，数字或元组

• 定于,访问，修改

  #定义
   d = {key1 : value1, key2 : value2 }
  #访问字典里的值
   dict[key]    
  #修改
   - 更新：dict[key] = new_value
   - 添加：dict[new_key] = value
  #删除
   - 删除：del dict
   - 清空：dict.clear()
   - 删除指定key: del dict[key]
  #
  

6、日期和时间

• time模块

  #获取当前时间
  localtime = time.localtime(time.time())
  #格式化日期
  time.strftime(format[, t])
  #格式化成2016-03-20 11:45:39形式
  time.strftime("%Y-%m-%d %H:%M:%S", time.localtim())
  
  

• calendar模块 calendar.month(2016, 1)

函数

• 定义函数

  - 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
  - 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
  - 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
  - 函数内容以冒号起始，并且缩进。
  - return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的- return相当于返回 None
  

• 函数与方法

  函数作用域：从函数调用开始至函数执行完成，返回给调用者后，在执行过程中开辟的空间会自动释放，也就是说函数执行完成后，函数体内部通过赋值等方式修改变量的值不会保留，会随着返回给调用者后，开辟的空间会自动释放。
  方法作用域：通过实例化的对象进行方法的调用，调用后开辟的空间不会释放，也就是说调用方法中对变量的修改值会一直保留
  
  函数：通过“函数名（）”的方式进行调用。
  方法：通过“对象.方法名”的方式进行调用
  

• 参数

  • 必备参数：必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样

  • 关键参数：关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值，使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值

    printme( str = "My string",str2 = 'hehe')
    

  • 默认参数:调用函数时，默认参数的值如果没有传入，则被认为是默认值

    def printinfo( name, age = 35 ):
    

  • 不定长参数

    #基本语法
    def functionname([formal_args,] *var_args_tuple ):
       "函数_文档字符串"
       function_suite
       return [expression]
    
    eg: def printinfo( arg1, *vartuple ):  #参数存为元组
        def printinfo( arg1, **vardict ):  #参数存为字典 
     def f(*a,**b)
     f(a,b,m=1,n=2)
    

• 匿名函数

  lambda只是一个表达式，函数体比def简单很多。
  lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
  lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
  #语法
  lambda [arg1 [,arg2,.....argn]]:expression
  

• return

1、内置函数

https://www.runoob.com/python/python-built-in-functions.html

2、数学常量

math.pi
math.e

3、字符串内建方法（函数）

4、列表内建方法（函数）

5、元组内建方法（函数）

6、字典内建方法（函数）

7、file方法

8、os方法

文件I/O（os,file模块）

• 读取键盘输入

  • raw_input() ：函数从标准输入读取一个行，并返回一个字符串

  • input()：和 raw_input([prompt]) 函数基本类似，但是 input 可以接收一个Python表达式作为输入，并将运算结果返回

• 打开和关闭文件

  • open()：file object = open(file_name [, access_mode][, buffering])
  • close(): fileObject.close()
  • read()：
  • write()：fileObject.write(string)，不会再字符串的结尾添加换行符
  • with open(): with open(file_name [, access_mode][, buffering]) as fileObject: #冒号不能少
  • readlines()

• file对象相关的属性：

  • file.closed 返回true如果文件已被关闭，否则返回false

• file.mode 返回被打开文件的访问模式。

• file.name 返回文件的名称

• 文件定位

  • tell()方法：告诉你文件内的当前位置, 换句话说，下一次的读写会发生在文件开头这么多字节之后

  • seek（offset [,from]）方法改变当前文件的位置。Offset变量表示要移动的字节数。From变量指定开始移动字节的参考位置。如果from被设为0，这意味着将文件的开头作为移动字节的参考位置。如果设为1，则使用当前的位置作为参考位置。如果它被设为2，那么该文件的末尾将作为参考位置

• 重命名和删除文件

  • 重命名：os.rename(current_file_name, new_file_name)
  • 删除：os.remove(file_name)

• python里的目录

  • 创建目录：os.mkdir()
  • 切换目录：os.chdir()
  • 删除目录：os.rmdir()

异常处理

• python 标准异常

• 异常处理try/except:

  try:
  <语句>        #运行别的代码
  except <名字>：
  <语句>        #如果在try部份引发了'name'异常
  except <名字>，<数据>:
  <语句>        #如果引发了'name'异常，获得附加的数据
  else:
  <语句>        #如果没有异常发生
  
  #使用except而不带任何异常类型,捕获所有发生的异常
  try:
      正常的操作
     ......................
  except:
      发生异常，执行这块代码
     ......................
  else:
      如果没有异常执行这块代码
  
  #异常的参数
  try:
      正常的操作
     ......................
  except ExceptionType, Argument:
      你可以在这输出 Argument 的值...
  

• try-filnall语句无论是否发生异常都将执行最后的代码。

  try:
  <语句>
  

finally:
<语句> #退出try时总会执行
raise

- 触发异常

```python
raise [Exception [, args [, traceback]]]:语句中 Exception 是异常的类型（例如，NameError）参数标准异常中任一种，args 是自已提供的异常参数。最后一个参数是可选的（在实践中很少使用），如果存在，是跟踪异常对象。
def functionName( level ):
    if level < 1:
        raise Exception("Invalid level!", level)
        # 触发异常后，后面的代码就不会再执行

• 自定义异常

对象

1、概念

• 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
• 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
• 数据成员：类变量或者实例变量, 用于处理类及其实例对象的相关的数据。
• 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
• 局部变量：定义在方法中的变量，只作用于当前实例的类。
• 实例变量：在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。
• 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
• 实例化：创建一个类的实例，类的具体对象。
• 方法：类中定义的函数。
• 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法

2、类

• 创建类

  class ClassName:
     '类的帮助信息'   #类文档字符串
     class_suite  #类体
  第一种方法__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法。self 代表类的实例，self 在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。
  
  #!/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
  

• 类的实例对象化,访问

  #实例化 
  emp1 = Employee("Zara", 2000)  #2个参数传递给初始化方法__init__()
  #类方法访问
  emp1.displayEmployee()
  

• 内置类的属性

  __dict__ : 类的属性（包含一个字典，由类的数据属性组成）
  __doc__ :类的文档字符串
  __name__: 类名
  __module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod）
  __bases__ : 类的所有父类构成元素（包含了一个由所有父类组成的元组）
  

python正在表达式 与shell正在表达式对比

1、python中的正则表达式

• python中如何使用正则表达式

  * re 模块使 Python 语言拥有全部的正则表达式功能。
  * re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none.
  * re.match(pattern, string, flags=0)flags标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等
  * re.search(pattern, string, flags=0)re.search 扫描整个字符串并返回第一个成功的匹配
  * re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。
  *re.compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用。
  re.compile(pattern[, flags])
  >>> pattern = re.compile(r'\d+')                    # 用于匹配至少一个数字
  >>> m = pattern.match('one12twothree34four')        # 查找头部，没有匹配
  >>> print m
  
  * re.findall(string[, pos[, endpos]])在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。 match 和 search 是匹配一次 findall 匹配所有
  *re.finditer和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回
  re.finditer(pattern, string, flags=0)
  

  检索和替换

  * re.sub(pattern, repl, string, count=0, flags=0)re.sub用于替换字符串中的匹配项
  pattern : 正则中的模式字符串。
  repl : 替换的字符串，也可为一个函数。
  string : 要被查找替换的原始字符串。
  count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。
  * re.split方法按照能够匹配的子串将字符串分割后返回列表，它的使用形式如下：re.split(pattern, string[, maxsplit=0, flags=0])
  maxsplit: 分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数
  

  修饰符

  修饰符	描述
  re.I	使匹配对大小写不敏感
  re.L	做本地化识别（locale-aware）匹配
  re.M	多行匹配，影响 ^ 和 $
  re.S	使 . 匹配包括换行在内的所有字符
  re.X	该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。

• python中正则表达式元字符 不分基本正则表达式和扩展正则表达式

  ^ 匹配字符串的开头

  $ 匹配字符串的末尾。

  . 匹配任意字符，除了换行符

  [] 用来表示一组字符

  [^] 不在[]中的字符

  * 匹配0个或多个的表达式

  + 匹配1个或多个的表达式

  ? 匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式

  {n} 精确匹配 n 个前面表达式

  {m,n}

  a|b

  () 分组

  (?= re) 前向肯定界定符。如果所含正则表达式，以 ... 表示，在当前位置成功匹配时成功，否则失败

  (?! re) 前向否定界定符。与肯定界定符相反

  \w 匹配字母数字及下划线.等价于'[A-Za-z0-9_]'。

  \W 匹配非字母数字及下划线，等价于[^A-Za-z0-9_]

  \s 匹配任意空白字符,等价于 [ \f\n\r\t\v]。

  \S 匹配任意非空字符, [^ \f\n\r\t\v]。

  \d 匹配任意数字，等价于 [0-9]

  \D 匹配任意非数字,等价于 [^0-9]。

  \A 匹配字符串开始

  \Z 匹配字符串结束,如果是存在换行，只匹配到换行前的结束字符串

  \z 匹配字符串结束

  \G 匹配最后匹配完成的位置

  \b 匹配一个单词边界'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。

  \B 匹配非单词边界

  \1...\9 匹配第n个分组的内容

  \10 匹配第n个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。

2、shell中的正则表达式

• 基本正则表达式

  .:匹配任意单个字符
  []:匹配指定范围内的任意单个字符

  [^]:匹配指定范围外的任意打个字符
  *：匹配前面字符任意次数
  .*：任意长度的任意次数
  ?:匹配其前面的字符0次或1次
  \+：匹配其前面的字符至少1次
  \ {m\}:匹配前面字符至少每次,后面跟文件时。 echo "bet" | gawk --re-interval '/be{1}t/{print $0}'

  \{m,n\}:

  位置锚定：
  ^:行首 ^PATTERN

  $：行尾 PATTERN$

  ^PATTERN$: 用于模式匹配整行
  \< 或\b：词首锚定
  \> 或\b: 词尾锚定
  \bPATTERN\b: 匹配整个单词
  分组：
  ():将一个或多个字符绑定在一起，当作一个整体进行处理。分组括号中的模式匹配到的内容会被正则表达式引擎记录于内部的变量中，这些变量命令方式为\1, \2……

• 扩展表达式

  字符匹配：. [] [^]
  次数匹配： * ? + {m} {m,n} 没有转义符号
  锚定：^ $ \b或< \b或>
  分组() \1 ……
  或 a|b

•    [:digit:] [:lower:] [:upper:] [:alpha:] [:alnum:] [:punct:] [:spcae:]
      [[:alpha:]] 匹配任意字母字符，不管是大写还是小写
      [[:alnum:]] 匹配任意字母数字字符0~9、A~Z或a~z
      [[:blank:]] 匹配空格或制表符
      [[:digit:]] 匹配0~9之间的数字
      [[:lower:]] 匹配小写字母字符a~z
      [[:print:]] 匹配任意可打印字符
      [[:punct:]] 匹配标点符号
      [[:space:]] 匹配任意空白字符：空格、制表符、NL、FF、VT和CR
      [[:upper:]] 匹配任意大写字母字符A~Z
  

3、对比

• 元字符基本相同 (. [] [^] * .* ? + {m} {m,n} ^ $ \b () )

• 对于一些特殊匹配不同

  描述	python	shell
  匹配（非）任意字母字符	[a-zA-Z]	[[:alpha:]]（[^[:alpha:]]）
  匹配任意字母数字字符0-9、A-Z或a-z	\w (\W)	[[:alnum:]]

...