目录
最重要的工具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 安装

Pip一些命令的简介

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)

Dict 与 set

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)
12

for 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）发明的一个术语，指计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员使用。通常来说使用语法糖能够增加程序的可读性，从而减少程序代码出错的机会。