目录
最重要的工具PIP， 以及常用的网站，IDE推荐
基本概念
函数
进阶概念：装饰器，迭代器，列表推导式，匿名函数
面向对象
标准库以及常用的库
最重要的工具PIP， 以及常用的网站，IDE推荐
Python 能干什么
开发一些简单的脚本，自动化完成一些繁复的工作
web （相关的框架 flask， django）
数据分析（相关的库： Numpy）
爬虫
以及偶尔装个逼—> 川普撞脸希拉里(基于 OpenCV 的面部特征交换)
Python3 的安装
如果你正在使用Mac，系统是OS X 10.8~10.10，那么系统自带的Python版本是2.7。要安装最新的Python 3.5，有两个方法：
方法一：从Python官网下载Python 3.5的安装程序（网速慢的同学请移步国内镜像），双击运行并安装；
方法二：如果安装了Homebrew，直接通过命令brew install python3
安装即可。
Homebrew安装及使用
Homebrew 官网
Ruby 安装
pip is already installed if you're using Python 2 >=2.7.9 or Python 3 >=3.4 binaries downloaded from python.org, but you'll need to upgrade pip.
对于国内用户，因为有墙的存在，用pip 安装第三方包的时候，下载速率很慢。我们需要配置pip的config 文件，假如国内的镜像网站。
配置pip 镜像文件
[global]
timeout = 6000
index-url = http://pypi.douban.com/simple/
[install]
use-mirrors = true
mirrors = http://pypi.douban.com/simple/
trusted-host = pypi.douban.com
IDE: PyCharm
Pycharm official website
Pycharm 使用教程
基本概念
数据类型
n = 123
f = 456.789
s1 = 'Hello, world'
s2 = 'Hello, 'Adam''
s3 = r'Hello, "Bart"'
s4 = r'''Hello,
... Lisa!'''
print(s1)
Hello, world
print(s2)
Hello, 'Adam'
print(s3)
Hello, "Bart"
print(s4)
Hello,
Lisa!
print()
len()
b'AbC'.decode()
'AbC'
'ANC'.encode('utf-8')
b'ANC'A = 'Allen'
'Hello %s' % A
'Hello Allen''%2d-%02d' % (3, 1)
' 3-01'
'%.2f' % 3.1415926
'3.14'
List 与 tuple
list 就是 NSMutableArray, tuple就是 NSArray
classmatess_L = ['Michael', 'Bob', 'Tracy']
classmates = ('Michael', 'Bob', 'Tracy')
classmates_L.append('Allen')
print(classmates_L)
['Michael', 'Bob', 'Tracy', 'Allen']
classmates.append('Allen')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'append'
List：
append()
classmates_L.pop()
'Allen'
print(classmates_L)
['Michael', 'Bob', 'Tracy']
classmates_L.pop(2)
'Tracy'
print(classmates_L)
['Michael', 'Bob']len(classmates_L)
2
classmates_L[-1]
'Allen'
classmates_L.insert(1,'Allen')
print(classmates_L)
['Michael', 'Allen', 'Bob']
避免歧义，定义一个元素的tuple，在元素后面要加上,
name= ('Allen',)
print(name)
('Allen',)
print(s3)
Hello, "Bart"
>>> print(s4)
Hello,
Lisa!
>>>
字符串与编码
print()
len()
>>> b'AbC'.decode()
'AbC'
>>> 'ANC'.encode('utf-8')
b'ANC'
>>>
>>> A = 'Allen'
>>> 'Hello %s' % A
'Hello Allen'
>>>
>>> '%2d-%02d' % (3, 1)
' 3-01'
>>> '%.2f' % 3.1415926
'3.14'
List 与 tuple
list 就是 NSMutableArray, tuple就是 NSArray
classmatess_L = ['Michael', 'Bob', 'Tracy']
classmates = ('Michael', 'Bob', 'Tracy')
>>> classmates_L.append('Allen')
>>> print(classmates_L)
['Michael', 'Bob', 'Tracy', 'Allen']
>>> classmates.append('Allen')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'append'
>>>
List：
append()
>>> classmates_L.pop()
'Allen'
>>> print(classmates_L)
['Michael', 'Bob', 'Tracy']
>>> classmates_L.pop(2)
'Tracy'
>>> print(classmates_L)
['Michael', 'Bob']
>>>
>>>len(classmates_L)
2
>>> classmates_L[-1]
'Allen'
>>> classmates_L.insert(1,'Allen')
>>> print(classmates_L)
['Michael', 'Allen', 'Bob']
#避免歧义，定义一个元素的tuple，在元素后面要加上,
>>> name= ('Allen',)
>>> print(name)
('Allen',)
age = 20
if age >= 6:
print('teenager')
elif age >= 18:
print('adult')
else:
print('kid')
sum = 0
for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
sum = sum + x
print(sum)
sum = 0
list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for index in range(0,len(list)):
sum = sum + list[index]
print(sum)
sum = 0
n = 99
while n > 0:
sum = sum + n
n = n - 2
print(sum)
d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
d['Michael']
95
d['Jack'] = 90
d['Jack']
90
d['Jack'] = 88
d['Jack']
88
d.pop('Michael')
95
print(d)
{'Tracy': 85, 'Bob': 75}
set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。
要创建一个set，需要提供一个list作为输入集合：
s = set([1, 2, 3])
s
{1, 2, 3}
s.add(4)
{1,2,3,4}
s1 = set([1, 2, 3])
s2 = set([2, 3, 4])
s1 & s2
{2, 3}
s1 | s2
{1, 2, 3, 4}
函数
def my_abs(x):
if x >= 0:
return x
else:
return -x
my_abs(-4)
4
python中函数的参数
只有位置参数： def func(a): pass
带有默认参数 def func(a, b = 'default'): pass
带有任意位置参数 def func(a, b = 'default', *args):pass
带有任意键值的参数（关键字参数） def func(a, b = 'default',*args, **kwds):pass
==note==
位置参数是最基本的参数，它会跟所传入的参数位置一一对应。
默认参数是为了简化函数调用的方法，我们可以在定义中定义一个默认的值，以此对于某一类的参数，我们只需要传入不同的位置参数.
def enroll(name, gender, age=6, city='Beijing'):
print('name:', name)
print('gender:', gender)
print('age:', age)
print('city:', city)
enroll('Sarah', 'F')
name: Sarah
gender: F
age: 6
city: Beijing
默认参数有几个注意的地方：
有多个默认参数时，调用的时候，既可以按顺序提供默认参数，比如调用enroll('Bob', 'M', 7)
，意思是，除了name
，gender
这两个参数外，最后1个参数应用在参数age
上，city
参数由于没有提供，仍然使用默认值。
也可以不按顺序提供部分默认参数。当不按顺序提供部分默认参数时，需要把参数名写上。比如调用enroll('Adam', 'M', city='Tianjin')
，意思是，city
参数用传进去的值，其他默认参数继续使用默认值。
默认参数一定不能传入可变元素。 因为默认参数在定义时候就已经确定了值，相当于已经给其分配了空间，当我们每一次调用的时候都会给那个空间中存入。
可变参数： 解决的问题是当你不确定要在函数中传入多少个参数时候，你需要用到可变参数。
关键字参数: 相当于 userinfo
命名关键字参数： 相当于固定要传进来的userinfo
命名关键字参数必须传入参数名，这和位置参数不同。如果没有传入参数名，调用将报错
如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数。这种方式定义的函数如下：
def person(name, age, *, city, job):
print(name, age, city, job)
如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了：
def person(name, age, *args, city, job):
print(name, age, args, city, job)
在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。
进阶概念
切片
用来操作迭代对象，比如list，tuple，字符串等。有了切片操作，很多地方循环就不再需要了。Python的切片非常灵活，一行代码就可以实现很多行循环才能完成的操作。
L = list(range(100))
print(L(：10))
print(L(10:20))
print(L(-10:))
print(L(0:10:2))
print(L(::5))
example:
冒泡
ListNumber = [4,2,51,212,34,99,110,122]
for x in ListNumber:
for y in ListNumber[ListNumber.index(x):]:
if x > y:
x, y = y, x
print(ListNumber)
[2, 4, 34, 51, 99, 110, 122, 212]
对于切片，我们需要参考 Python cookbook的建议，可以命名切片， 使得我们的程序中少点切片的硬编码。
0123456789012345678901234567890123456789012345678901234567890'
record = '....................100 .......513.25 ..........'
糟糕的写法
cost = int(record[20:23]) * float(record[31:37])
好的写法
SHARES = slice(20, 23)
PRICE = slice(31, 37)
cost = int(record[SHARES]) * float(record[PRICE])
Note：
我们一旦命令了slice， 在任何地方都可以用到，包括列表的删除，插入等
items = [0, 1, 2, 3, 4, 5, 6]
a = slice(2, 4)
items[2:4]
[2, 3]
items[a]
[2, 3]
items[a] = [10,11]
items
[0, 1, 10, 11, 4, 5, 6]
del items[a]
items
[0, 1, 4, 5, 6]
slice 有三个属性， start，stop， step
slice 有一个方法indices()， 这个方法可以将所切片的范围规定在给定字符串的范围中，避免IndexError
列表生成器
列表生成式即List Comprehensions，是Python内置的非常简单却强大的可以用来创建list的生成式。
L = []
for x in range(1, 11):
... L.append(x * x)
...
L
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
[x * x for x in L if x > 10]
[256, 625, 1296, 2401, 4096, 6561, 10000]
[x * x for x in L]
[1, 16, 81, 256, 625, 1296, 2401, 4096, 6561, 10000]
字典推导
字典推导式实际上跟 列表生成器是类似的， 代码如下，实际上就是把 列表推导中的[]
换成{}
：
dic1 = {x: x * x for x in range(1,11)}
print dic1
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100}
生成器
==方法1==
实际上跟 列表生成器是类似的， 代码如下，实际上就是把 列表推导中的[]
换成（）
， 在使用中用for 跟 next()方法取值。
Q：
为什么要用生成器
A:
通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。
所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。
G=(x+y for x in L for y in range(1,5) if x>y)
next(G)
12for x in G:
... print('Next:', x)
...
Next: 12
Next: 13
Next: 17
.
.
.
==方法2==
生成器的主要目的是构成一个用户自定义的循环对象。
生成器的编写方法和函数定义类似，==只是在return的地方改为yield==。生成器中可以有多个yield。当生成器遇到一个yield时，会暂停运行生成器，返回yield后面的值。当再次调用生成器的时候，会从刚才暂停的地方继续运行，直到下一个yield。生成器自身又构成一个迭代器，每次迭代时使用一个yield返回的值。
def generate(endNum):
for x in range(0,endNum):
yield x*2
L = generate(10)
print(L)
for x in L:
print(x)
<generator object generate at 0x102183830> #这句说明通过generate函数之后是一个generator
0
2
4
6
8
10
12
14
16
18
迭代器
迭代器，廖学峰的教程中写的很详细
我们已经知道，可以直接作用于for
循环的数据类型有以下几种：
一类是集合数据类型，如list
、tuple
、dict
、set
、str
等；
一类是generator
，包括生成器和带yield
的generator function。
这些可以直接作用于for
循环的对象统称为可迭代对象：Iterable
。
可以使用isinstance()
判断一个对象是否是Iterable
对象：
而生成器不但可以作用于for
循环，还可以被next()
函数不断调用并返回下一个值，直到最后抛出StopIteration
错误表示无法继续返回下一个值了。
可以被next()
函数调用并不断返回下一个值的对象称为迭代器：Iterator
。
可以使用isinstance()
判断一个对象是否是Iterator
对象：
高阶函数， Map, filter , sorted等, 匿名函数
高阶函数：
对于python， 函数本身也可以赋值给变量，即：变量可以指向函数。 既然变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为==高阶函数==。
example:
def higherFunc(x, y, f):
return f(x)+f(y)
print(higherFunc(1,-2,abs))
3
Map:
在stackover flow 上 有人这么总结Map
map(f, iterable)
基本上等于：
[f(x) for x in iterable]
example
L = map(TestMap,[88,11,33])
list(L)
[10088, 10011, 10033]
Sorted:
排序 ：廖学峰
此外，sorted()
函数也是一个高阶函数，它还可以接收一个key
函数来实现自定义的排序，例如按绝对值大小排序：
from operator import itemgetter
rows = [
{'fname': 'Brian', 'lname': 'Jones', 'uid': 1003},
{'fname': 'David', 'lname': 'Beazley', 'uid': 1002},
{'fname': 'John', 'lname': 'Cleese', 'uid': 1001},
{'fname': 'Big', 'lname': 'Jones', 'uid': 1004}
]
sorwRows1 = sorted(rows, key= itemgetter('uid')) # itemgetter: operator模块提供的itemgetter函数用于获取对象的哪些维的数据，
print('sorted ROWS :%s' % sorwRows1)
L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
sortL = sorted(L, key = itemgetter(0), reverse = True)
print(sortL)
匿名函数
关键字lambda
表示匿名函数，冒号前面的x
表示函数参数。
匿名函数有个限制，就是只能有一个表达式，不用写return
，返回值就是该表达式的结果。
def build(x, y):
return lambda: x * x + y * y
装饰器（==语法糖：@==）
目前最清晰的入门博客
假设我们要增强now()
函数的功能，比如，在函数调用前后自动打印日志，但又不希望修改now()
函数的定义，这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。
==本质上，decorator就是一个返回函数的高阶函数。==
装饰器其实也就是一个函数，一个用来包装函数的函数，返回一个修改之后的函数对象，将其重新赋值原来的标识符，并永久丧失对原始函数对象的访问
Note：
==语法糖：==
语法糖（Syntactic sugar），也译为糖衣语法，是由英国计算机科学家彼得·约翰·兰达（Peter J. Landin）发明的一个术语，指计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员使用。通常来说使用语法糖能够增加程序的可读性，从而减少程序代码出错的机会。
