1. 数据类型：

Numbers（数字）：包括int（有符号整型）、long（长整型[也可以代表8进制和16进制]）、float（浮点型）、complex（复数）
布尔类型：包括True和False
String（字符串）
List（列表）
Tuple（元组）
Dictionary（字典）
可变数据类型：列表，字典
不可变数据类型：数字、字符串、元组

2. 切片

字符串、列表、元组都支持切片操作
切片操作语法[起始:结束:步长]
切片区间左闭右开

3. 字符串操作

find 检查str是否包含在mystr中，如果是返回索引，否则返回-1
mystr.find(str, start=0, end=len(mystr))

index 跟find一样，只不过如果str不在mystr会报异常
mystr.index(str, start=0, end=len(mystr))

rfind 返回字符串最后一次出现的位置，如果没有匹配项则返回 -1
mystr.rfind(str, beg=0 end=len(string))

rindex 跟rfind一样，只不过如果str不在mystr会报异常
mystr.rindex(str, start=0, end=len(mystr))

count 返回str在start和end之间，在mystr里面出现的次数
mystr.count(str, start, end=len(mystr))

replace 把mystr中的str1替换成str2，如果count指定，则替换不超过count次
mystr.replace(str1, str2, mystr.count(str1))

split 以str为分隔符切片mystr, 如果maxsplit有指定值，则仅分割maxsplit个子字符串
mystr.split(str=" ", 2)

capitalize 把字符串的第一个字符大写
mystr.capitalize()

title 把字符串的每个单词首字母大写
mystr.title()

startswith 检查字符串是否以obj开头，是则返回True，否则返回False
mystr.startwith('obj')

endswith 检查字符串是否以obj结尾，是则返回True，否则返回False
mystr.endswith('obj')

lower 转换mystr中所有大写字符为小写
mystr.lower()

upper 转换mystr中所有小写字符为大写
mystr.upper()

ljust 返回一个原字符串左对齐，并使用空格填充至长度width的新字符串
mystr.ljust(width)

rjust 返回一个原字符串右对齐，并使用空格填充至长度width的新字符串
mystr.rjust(width)

center 返回一个原字符串居中，并使用空格填充至长度width的新字符串
mystr.center(width)

lstrip 删除mystr左边的空白字符
mystr.lstrip()

rstrip 删除mystr右边的空白字符
mystr.rstrip()

strip 删除mystr字符串两端的空白字符
mystr.strip()

partition 把mystr以str分割成三部分，str前，str，str后
mystr.partition(str)

splitlines 按照行分隔，返回一个包含各行作为元素的列表
mystr.splitlines()

isalpha 如果mystr所有字符都是字母，则返回True，否则返回False
mystr.isalpha()

isdigit 如果mystr只包含数字则返回True，否则返回False
mystr.isdigit()

isalnum 如果mystr所有字符都是字母或数字则返回True，否则返回False
mystr.isalnum()

isspace 如果mystr中只包含空格则返回True，否则返回False
mystr.isspace()

join 将序列中的元素以指定的字符（str）连接生成一个新的字符串
str.join(sequence)

5. 列表

添加元素（append, extend, insert）
append 向列表添加元素
A.append(str)
A.insert(index, object)

修改元素
通过下标直接修改
A[1] = str

查找元素
in(存在) 如果存在为True，否则为False
not in(不存在) 如果不存在为True，否则为False
index 查询元素并返回下标，如不存在，抛出异常 A.index('a', start, end)
count 统计元素个数 A.count('a')

删除元素 （del, pop, remove）
del 根据下标删除 del A[2]
pop 删除并返回最后一个元素
remove 根据元素值删除

排序（sort, reverse）
sort 默认从小到大排序 参数reverse=True 可以改为倒序，从大到小 A.sort()
reverse 将列表倒序 A.reverse()

排序（sorted）
sorted(iterable，key=None,reverse=False) # cmp参数在Python3中废除

a = [5, 7, 6, 3, 4, 1, 2]
b = sorted(a) # 保留原列表
print(a)
print(b)

返回

[5, 7, 6, 3, 4, 1, 2]
[1, 2, 3, 4, 5, 6, 7]

通过key排序

L = [('b', 2), ('a', 1), ('c', 3), ('d', 4)]
M = sorted(L, key=lambda x: x[1])
N = sorted(L, key=lambda x: x[1], reverse=True) # 倒序
print(L)
print(M)
print(N)

返回

[('b', 2), ('a', 1), ('c', 3), ('d', 4)]
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
[('d', 4), ('c', 3), ('b', 2), ('a', 1)]

6. 元组

元组与列表类似，不同之处是元组不能修改，使用小括号
通过下标访问元组，修改元组值会报异常

index和count与字符串和列表中的用法相同
index 查询元素并返回下标，如不存在，抛出异常 A.index('a', start, end)
count 统计元素个数 A.count('a')

7. 字典

数字、元组也可以是字典的key，只要不可变数据类型就可以
查询 通过key访问字典
info['name'] 如果不存在会报错
get 如果字典存在key，返回key值，如果不存在，返回None。如果不存在，并且指定了默认值，返回默认值。
name = info.get('name', 'Bill')

删除（del, clear()）
del 删除指定元素 del info['name']
clear 清空字典 info.clear()

常用操作
len() 查询字典键值对个数 len(info)
keys() 返回一个包含字典所有key的列表 info.keys()，Python3返回类型是dict_keys，可用list转为列表使用 res = list(info.keys())
values() 返回一个包含字典所有value的列表 info.values()，Python3返回类型是dict_values，可用list转为列表使用 res = list(info.values())
items() 返回一个包含字典所有键值元组的列表 info.items()，Python3返回类型是dict_items，可用list转为列表使用 res = list(info.items())
kas_key() Python2中如果key存在字典中，返回True，如果不存在，返回False。info.has_key('name')
in(存在) Python3中使用in判断key是否存在，存在返回True，不存在返回False。'name' in info
not in(不存在) Python3中使用not in判断key，不存在返回True，存在返回False。'name' not in info

遍历
字符串遍历 for char in str: 或者 for i, char in enumerate(str)：可以返回下标和值
列表遍历
字典遍历

8. 运算符

• 合并字符串、列表、元组

• 复制字符串、列表、元组
  in 字符串、列表、元组、字典中元素是否存在
  not in 字符串、列表、元组、字典中元素是否不存在

9. 内置函数

cmp(item1, item2) 比较两个值
len(item) 计算容器中元素个数
max(item) 返回容器中最大值
min(item) 返回容器中最小值
del(item) 删除变量
help() 函数用于查看函数或模块用途的详细说明
eval() 函数用来执行一个字符串表达式，将字符串当成有效的表达式，并返回表达式的值eval('2 + 2')返回4

10. 函数

返回值：一个函数执行完成后，把一个结果返回给调用者。使用return返回结果并结束函数
函数的4种类型：
无参数 无返回值 多用于打印信息
无参数 有返回值
有参数 无返回值 用于对变量设置数据，但是不需要结果
有参数 有返回值

局部变量：在函数里定义的变量，只在定义的函数中有效
全局变量：在函数外定义的变量
在函数中修改全局变量会产生异常，如果需要修改，可以声明 global xxx

缺省参数：如果没有传入参数，则使用函数声明中的默认值
带有默认值的参数一定要位于参数列表的最后面

不定长参数：有时可能需要一个函数能处理比当初声明时更多的参数，这些参数叫做不定长参数，声明时不会命名。声明如下：

def test(a,b,*args,**kwargs):
  pass
A=[11,22,33]
B={'aa':100, 'bb':200}
# 解包：列表/元组作为实参传递的时候，如果前面有一个*，表示对齐解包。
# 字典作为实参传递的时候，如果前面有两个个*，表示对齐解包。
test(11,22,*A,**B) 相当于 test(11,22,11,22,33,'aa'=100,'bb'=200)

引用传参：Python中函数参数是引用传递（注意不是值传递）。对于不可变类型，因变量不能修改，所以运算不会影响到变量自身；而对于可变类型来说，函数体中的运算有可能会更改传入的参数变量。

递归函数
一个函数调用了它本身，那么这样的函数就叫递归函数

匿名函数

aaaa = lambda a,b:a+b  #（a,b为入参，a+b为返回值）
print(aaaa(8,9)) 

# 使用lambda函数将字典按照key值从小到大排序
b.sort(key = lambda x:x['id'])

重复声明
多个函数名相同时，后面的覆盖前面的，只调用最后一个函数

11. 文件操作

open(文件名，访问模式)，打开一个存在文件，或者创建一个新文件
f = open('test.txt', 'w')
f.read(n) #读取文件，读取n个字符
f.close() #关闭文件
访问模式：
r 只读方式打开文件，文件指针放在文件的开头
w 打开一个文件只用于写入，如果存在则覆盖，不存在则创建
a 打开一个文件用于追加，如果文件存在，文件指针放在文件结尾。如果不存在则创建
rb 以二进制格式打开一个文件只读，文件指针放在文件开头，这是默认模式
wb 以二进制格式打开一个文件只用于写入，如果存在则覆盖，不存在则创建
ab 以二进制格式打开一个文件用于追加，如果文件存在，文件指针放在文件结尾。如果不存在则创建
r+ 打开一个文件用于读写，文件指针放在文件开头
w+ 打开一个文件用于读写，如果存在则覆盖，不存在则创建

读数据
readline：每次读取一行
readlines：按照行的方式读取文件整个内容，返回一个列表，每一行数据为一个元素。

移动指针：
seek() 方法用于移动文件读取指针到指定位置。
f.seek(offset, from) # offset 偏移量，from 方向：0表示文件开头，1表示当前位置，2表示末尾
f.seek(-3, 2) 表示把位置设置为：离文件末尾，3字节处

文件重命名 os.rename(需要修改的文件名，新文件名)
删除文件 os.remove(需要删除的文件名)
创建文件夹 os.mkdir(文件夹名)
获取当前目录 os.getcwd()
改变默认目录 os.chdir("../")
获取目录列表 os.listdir("./")
删除文件夹 os.rmdir(文件夹名)
判断是否是文件 os.path.isdir(文件路径)

文本文件的编码格式
Python2 默认使用ASCII编码
Python3 默认使用utf-8编码

12. 面向对象

在一个对象中封装多个方法
怎么设计？
在完成某个需求前，先确定职责--要做的事情（方法）
根据职责确定不同的对象，在对象内部封装不同的方法（多个）
最后完成的代码，就是让不同的对象调用不同的方法

类
类是对一群具有相同特征或者行为的事物的一个统称，是抽象的，不能直接使用。特征被称为属性，行为被称为方法。类是负责创建对象的模板。

类名满足大驼峰命名法：Capwords，整个业务流程中出现的名字，通常就是类名。
每一个单词的首字母大写，单词与单词之间没有下划线

dir()内置函数可以查看对象内的所有属性和方法，例如：
__new__ 创建对象时会自动调用
__init__ 对象被初始化时会自动调用
__del__对象被从内存中销毁前会自动调用
__str__ 返回对象的描述信息，print函数输出使用

初始化方法
使用“类名()”创建对象时，会自动执行以下操作：
为对象在内存中分配空间，创建对象
为对象的属性设置初始值，自动调用初始化方法__init__

定义类

class 类名:
    def 方法1(self, 参数列表):
        # 哪一个对象调用的方法，self就是哪一个对象的引用
        pass
    def 方法2(self, 参数列表):
        pass

创建类的对象：对象变量=类名()
在类的外部，通过“变量名.”访问对象的属性和方法
在类封装的方法中，通过self.访问对象的属性和方法
del关键字可以删除一个对象 del object_name
定义属性时，如果不需要值，可以设置为None
创建出来的对象叫做类的实例，创建对象的动作叫做实例化，对象的属性叫做实例属性，对象调用的方法叫做实例方法。

每一个对象都有自己独立的内存空间，保存各自不同的属性
多个对象的方法，在内存中只有一份，在调用方法时，需要把对象的引用传递到方法内部。

面向对象三大特性
封装：面向对象编程是将属性和方法封装在一个抽象的类中，外界使用类来创建对象，让对象调用方法。对象方法的细节都被封装在类的内部。
继承：实现代码的重用，相同的代码不需要重复编写。
多态：不同子类对象调用相同的父类方法，产生不同的执行结果，以继承和重写父类方法为前提，增加代码的灵活度。

身份运算符(is和==的区别)
is 用于判断两个变量引用的对象是否为同一个
== 用于判断引用变量的值是否相等

私有属性和私有方法（只希望在类内部被使用的属性和方法）定义方式：
在属性名或者方法名前面加两个下划线__
Python中没有真正意义的私有，只是在给属性和方法命名时，对名称做了特殊处理，使外界无法访问到。可以在名称前面加上 类名来访问（对象.类名__名称）

继承：（父类，子类 = 基类，派生类）
子类拥有父类以及父类的父类中封装的所有的方法和属性。
子类根据职责封装子类特有的属性和方法

class 类名(父类名):
        pass

方法重写的两种情况：当父类的方法实现不能满足子类的需求时，可以对方法重写（override）
覆盖父类的方法：父类和子类方法实现完全不同，可以在子类重新编写方法，在子类中定义一个和父类同名的方法并且实现。运行时只会调用子类中重写的方法。

对父类方法进行扩展：父类封装的方法是子类方法的一部分，可以在子类中扩展重写父类的方法。在需要的位置使用 super().父类方法 来调用父类方法的执行。代码其他位置针对子类的需求，编写子类特有的代码实现。相当于在重写方法的同时也包含了父类的方法。

关于super()
Python中super是一个特殊的类
super()就是super类创建出来的对象
最常用的场景就是在重写父类方法时，调用在父类中封装的方法实现。

父类的私有属性和方法
不能被子类对象直接访问到，通常用于做一些内部的事情。
可以通过父类的公有方法间接访问到私有属性和私有方法。

多继承：子类可以拥有多个父类，并且具有所有父类的属性和方法

class 子类名(父类名1，父类名2)
        pass

不同父类存在同名的方法时，子类会调用到哪个父类的方法？这种情况要避免使用多继承。
Python中针对类提供了一个内置属性mro可以查看方法搜索顺序。
MRO(method resolution order)，主要用于在多继承时判断方法、属性的调用路径。

新式类与旧式类：
以object为基类的类，Python3中如果没有指定父类，默认使用object作为基类。Python2不会。
定义类时，如果没有父类，建议统一继承自object

class 类名(object):
    pass

类是一个特殊的对象，除了封装实例的属性和方法，类对象还可以拥有自己的属性和方法
类属性：给类对象定义的属性，通常记录与这个类相关的特征(例：创建对象数量统计)，类属性不会去记录具体对象的特征。访问方式(类名.类属性) 和 (对象.类属性（不推荐）)

类属性的获取机制：向上查找
首先在对象内部查找对象属性，如果没有找到就会想向上寻找类属性。
如果使用（对象.类属性=值）赋值语句，只会给对象添加一个属性，而不会影响到类属性的值。

类方法(cls)：针对类对象定义的方法，外部访问方式(类名.方法名)
在类方法内部可以直接访问类属性和调用其他的类方法
语法如下：由哪一个类调用的方法，cls就是哪一个类的引用

@classmethod
def 类方法名(cls):
    pass

在方法内部，可以通过cls.访问类的属性，也可以通过cls.调用其他的类方法

静态方法
既不需要访问实例属性或者调用实例方法，也不需要访问类属性或者调用类方法。
语法如下：

@staticmethod
def 静态方法名():
    pass

调用时不需要创建对象： 类名. 静态方法名()

__new__和__init__
先执行__new__：1.为对象分配空间；2.返回对象引用
再执行__init__：1.对象初始化；2.定义实例属性

13. 捕获异常

简单代码：

try:
  尝试执行的代码
except:
  出现错误的处理

错误类型捕获：

try:
  尝试执行的代码
except 错误类型1:
  针对错误类型1的代码处理
except (错误类型2, 错误类型3):
  针对错误类型2和3的代码处理
except Exception as result:
  print('位置错误 %s', result)
else:
  没有异常才会执行的代码
finally:
  是否有异常都会执行的代码

Python解释器抛出异常时，最后一行错误信息的第一个单词就是错误类型。

异常的传递：
当函数/方法执行出现异常，会讲异常传递给函数/方法的调用一方，如果传递到主程序，仍然没有异常处理，程序才会被终止。可以在主函数中增加异常捕获，保证代码简洁。

抛出raise异常
开发中除了代码出错解释器抛出异常外，还可以根据业务需求主动抛出异常。
Python中提供了一个Exception异常类。如果在业务需求中需要抛出异常，可以创建一个Exception的对象，使用raise关键字抛出异常对象。

ex = Exception("异常信息") # 创建异常对象
raise ex # 主动抛出一行

14. 模块

模块是Python程序架构的一个核心概念，每一个.py结尾的源代码文件都是一个模块。
导入方式

# import应该统一写在代码顶部
import 模块1, 模块2
import 模块1
import 模块2
# 使用as指定模块别名，模块别名使用大驼峰命名法
import 模块1 as 模块别名
# 从一个模块中导入部分工具
from 模块名 import 工具名

导入之后，通过 模块名. 使用模块提供的工具：全局变量、函数、类
注意：如果2个模块，存在同名函数，后导入模块的函数，会覆盖掉先导入的函数

模块的搜索顺序
Python解释器导入模块时，先搜索当前目录，再搜索系统目录。如果当前目录有同名模块，会直接导入。所以给文件起名不要和系统模块重名。
模块内置属性__file__可以查看模块的完整路径。

__name__属性
一个独立的py文件就是一个模块，导入文件时，文件中所有没有任何缩进的代码都会被执行一遍。
开发时，会在模块下方增加测试代码，只在模块内使用，被导入到其他文件时不需要执行。
__name__属性可以做到测试模块的代码，只在测试情况下被运行，而在被导入时不会被执行。
__name__是Python的一个内置属性，记录这一个字符串。
如果是被其他文件导入的，__name__就是模块名
如果是当前执行的程序，__name__就是__main__

# 根据``__name__``判断是否执行下面代码
``if __name__ == "__main__"：``
    main()

15. 包

包是一个包含多个模块的特殊目录，目录下有一个特殊的文件__init__.py
包名的命名方式和变量名一致，小写字母+'_'
使用import包名可以一次性导入包中所有模块
__init__.py中指定对外界提供的模块列表

# 从当前目录导入的模块列表
from . import 模块1
from . import 模块2

发布模块
如果希望自己开发的模块分享给其他人，可以按照以下步骤发布
创建setup.py文件

from distutils.core import setup
setup(
        name="mytest", # 包名
        version="1.0", # 版本
        author="test", # 作者
        author_email="test@test.com", # 作者邮箱
        description="Learn to Pack Python Module", # 描述信息
        url="http://test.com/", # 主页
        py_modules = ["模块1", "模块2"], # 提供的模块)

构建模块

python3 setup.py build

生成发布压缩包

python3 setup.py sdist

安装模块

tar -zxvf 模块名.tar.gz
sudo python3 setup.py install

卸载模块

cd /usr/local/lib/python3.5/dist-packages/
sudo rm -f 模块名

第三方模块通过pip install安装

Python2中如何使用中文

# *-* coding:utf8 *-*
# coding=utf8

常量命名：所有字母大写，单词之间下划线连接