注：
来自 https://learnxinyminutes.com/docs/python3/ 和 http://learnxinyminutes.com/docs/python/

Python是Guido Van Rossum在90年代发明的。它是目前最热闹的编程语言之一。

原始数据类型与操作

数值型

# 数值型
3 # => 3

# 数学计算
1 + 1 # => 2
8 - 1 # => 7
10 * 2 # => 20
35 / 5 # => 7

# 整型(int)的除法只会获得整型结果，余数自动舍弃 Python 2.7
5 / 2 # => 2
# Python会自动返回浮点数
5 / 2 # => 2.5

# 浮点型(float)的计算可以有小数
2.0 # 这是一个浮点型
11.0 / 4.0 # => 2.75

# 如果只需要整数部分，使用"//"做除法，又叫地板除(foored division)
5 // 3 # => 1
5.0 // 3.0 # => 1.0 浮点型效果也一样
-5 // 3 # => -2
-5.0 // 3.0 # => -2.0

# 取余操作
7 % 3 # => 1

# 幂操作
2 ** 4 # => 16

# 使用括号改变优先级
(1+3) * 2 # => 8

布尔型

# 注： "and" 和 "or" 都是大小写敏感的
True and False # => False
False or True # => True

# 注：int型也可以使用布尔操作
0 and 2 # => 0
-5 or 0 # => -5
0 == False # => True
2 == True # => False
1 == True # => True

# 非操作
not True # => False
not False # => True

# 判断相等
1 == 1 # => True
2 == 1 # => False

# 判断不相等
1 != 1 # => False
2 != 1 # => True

# 其它比较操作
1 < 10 # => True
1 > 10 # => False
2 <= 2 # => True
2 >= 2 # => True

# 比较操作可以串联
1 < 2 < 3 # => True
1 < 3 < 2 # => False

# is 与 == 比较
# is 是判断两个变量是否引用了同一个类
# == 是判断两个变量是否有同样的值
a = [1, 2, 3, 4]  # 将 a 指向一个新的数组 [1, 2, 3, 4]
b = a             # 将 b 指向 a 所指向的对象
b is a            # => True, a 和 b 引用了同一个对象
b == a            # => True, a 和 b 的对象值也相同
b = [1, 2, 3, 4]  # 将 b 指向一个新的数组 [1, 2, 3, 4]
b is a            # => False, a 和 b 不是引用了同一个对象
b == a            # => True, a 和 b 的对象值相同

字符串

# 字符串使用 单引号 或者 双引号 表示
"这是一个字符串"
'这也是一个字符串'

# 字符串可以使用"+"连接
"Hello " + "world!" # "Hello world!"
# 不使用"+"也可以让字符串连接
"Hello " "world!" # "Hello world!"

# 字符串乘法
"Hello" * 3 # => "HelloHelloHello"

# 字符串可以当作字符数组操作
"This is a string"[0] # => "T"

# 使用 % 对字符串进行格式化
# 从Python 3.1 开始已经不推荐使用了，但了解一下如何使用还是有必要的
x = 'apple'
y = 'lemon'
z = "The items in the basket are %s and %s " % (x,y)

# 新的格式化字符串的方式是使用format方法
"{} is a {}".format("This", "placeholder")
"{0} can be {1}".format("strings", "formatted")
# 如果不想用下标方式，可以使用关键字的方式
"{name} wants to eat {food}".format(name="Bob", food="lasagna")

其它

# None 是一个对象
None # => None

# 如果想要将一个对象与None进行比较，使用 is 而不要使用 == 符号
"etc" is None # => False
None is None # => True

# is 操作用来判断对象的类型。在对象操作时非常有用

# 任何一个对象都可以放在一个布尔上下文中进行判断
# 下面的情况会被当作False
#   - None
#   - 值为0的任何数值类型，(例如，0，0L，0.0，0j)
#   - 空列表，(例如，''，()，[])
#   - 空的容器，(例如，{}，set())
#   - 符合条件的用户自定义对象实例，参看:https://docs.python.org/2/reference/datamodel.html#object.__nonzero__
#
# 其它情况下的值会被当作True，可以使用bool()函数来判断
bool(0)   # => False
bool("")  # => False
bool([])  # => False
bool({})  # => False

变量与集合

输入输出

# Python有一个打印语句
print "I'm Python. Nice to meet you!" # => I'm Python. Nice to meet you!

# 获取控制台输入的简单方法
input_string_var = raw_input("Enter some data: ") # 返回字符串类型的数据
input_var = input("Enter some data: ") # 返回数值型的数据
# Warning: Caution is recommended for input() method usage
# 注意：在Python3中，input()已经不再使用，raw_input()重命名为input()

# 不需要先声明变量再使用
some_var = 5    # 通常使用小写字母与下划线命名变量
some_var  # => 5

# 访问一个未定义的变量会抛出一个异常
# 在“控制流”里会介绍更多异常处理
some_other_var  # 这里会抛出一个NameError

# if 可以用来写成类似C语言的 '?:' 条件表达式
"yahoo!" if 3 > 2 else 2  # => "yahoo!"

列表（List）

# List用来存储列表
li = []
# 可以有初始数据
other_li = [4, 5, 6]

# 添加元素到列表的尾
li.append(1) # [1]
li.append(2) # [1,2]
li.append(4) # [1,2,4]
li.append(3) # [1,2,4,3]
# 使用pop方法移除列表末尾的元素
li.pop()        # => 3 列表现在为 [1, 2, 4]
# 把3再放回去
li.append(3)    # li 现在为 [1, 2, 4, 3]

# 像数组一样访问一个list
li[0]  # => 1
# 通过下标重新定义一个元素的值
li[0] = 42
li[0]  # => 42
li[0] = 1  # 注意：设置回原始值
# 查看最后一个元素
li[-1]  # => 3

# 查找超过数据长度的值会抛出异常： IndexError
li[4]  # 抛出 IndexError

# 可以使用切片句法访问列表
# 这里类型数学上的开/闭区间
li[1:3]  # => [2, 4]
li[2:]  # => [4, 3]
li[:3]  # => [1, 2, 4]
li[::2]   # =>[1, 4]
li[::-1]   # => [3, 4, 2, 1]
# 使用高级切片句法
# li[start:end:step]

# 使用切片进行深层拷贝
li2 = li[:]  # => li2 = [1, 2, 4, 3] 但 (li2 is li) 返回 false


# 使用“del”直接从列表中删除元素
del li[2] #liisnow[1,2,3]

# 可以直接添加一个列表
li+other_li #=>[1,2,3,4,5,6]
# 注: 变量li 和 other_li 值并没有变化

# 使用extend()方法，把列表串起来
li.extend(other_li)   # Now li is [1, 2, 3, 4, 5, 6]

# 删除第一个值与参数相同的元素
li.remove(2)  # li is now [1, 3, 4, 5, 6]
li.remove(2)  # 抛出异常 ValueError 列表中没有2

# 在指定下标插入元素
li.insert(1, 2)  # li is now [1, 2, 3, 4, 5, 6] again

# 获得第一个匹配的元素的下标
li.index(2)  # => 1
li.index(7)  # 抛出异常 ValueError 列表中没有7

# 使用“in”来检查列表中是否包含元素
1 in li #=>True
# 使用“len()”来检查列表的长度
len(li)   # => 6

元组（Tuple）

# 元组(Tuple)与列表类似但不可修改
tup = (1, 2, 3)
tup[0]   # => 1
tup[0] = 3  # 抛出异常 TypeError

# 注意：如果一个元组里只有一个元素，则需要在元素之后加一个逗号；如果元组里没有元素，反而不用加逗号
type((1))   # => <class 'int'>
type((1,))  # => <class 'tuple'>
type(())    # => <class 'tuple'>

# 以下对列表的操作，也可以用在元组上
len(tup) # => 3
tup+(4,5,6) #=>(1,2,3,4,5,6)
tup[:2] #=>(1,2)
2intup #=>True

# 可以把元组的值分解到多个变量上
a,b,c= (1, 2, 3) #a is now 1,b  is now 2 and c is now 3
d,e,f= 4,5,6 # 也可以不带括号
# 如果不带括号，元组会默认带上
g = 4, 5, 6 #=>(4,5,6)
# 非常容易实现交换两个变量的值
e, d = d, e # d is now 5 and e is now 4

字典（Dictionaries）

# 字典用来存储（键-值）映射关系
empty_dict = {}
# 这里有个带初始值的字典
filled_dict = {"one": 1, "two": 2, "three": 3}

# 注意：字典 key 必须是不可以修改类型，以确保键值可以被哈希后进行快速检索
# 不可修改的类型包括：int, float, string, tuple
invalid_dict = {[1,2,3]: "123"}  # => Raises a TypeError: unhashable type: 'list'
valid_dict = {(1,2,3):[1,2,3]}   # Values can be of any type, however.

# 使用[]查找一个元素
filled_dict["one"]   # => 1
# 使用"keys()"获得所有的“键”
filled_dict.keys()   # => ["three", "two", "one"]
# 注：字典的key是无序的，结果可以不匹配
# 使用"values()"获得所有的“值”
filled_dict.values()   # => [3, 2, 1]
# 注：同样，这是无序的
# 查询字条中是否存在某个”键“用 "in"
"one" in filled_dict   # => True
1 in filled_dict   # => False
# 查找一个不存在的key会抛出异常 KeyError
filled_dict["four"]   # KeyError
# 使用 "get()" 会避免抛出异常 KeyError
filled_dict.get("one") # => 1
filled_dict.get("four") # => None
# get方法支持默认参数，当key不存在时返回该默认参数
filled_dict.get("one", 4) #=>1
filled_dict.get("four", 4)   # => 4
# 注 filled_dict.get("four") 仍然返回 None
# (get不会把值插入字典中)
# 向字典中插入值的方式与list相同
filled_dict["four"] = 4  # now, filled_dict["four"] => 4
# "setdefault()" 只有首次插入时才会生效
filled_dict.setdefault("five", 5)  # filled_dict["five"] is set to 5
filled_dict.setdefault("five", 6)  # filled_dict["five"] is still 5

# 使用 del 从字典中删除一个键
del filled_dict["one"]  # Removes the key "one" from filled dict

# 从 Python 3.5 开始，可以使用**操作
{'a': 1, **{'b': 2}}  # => {'a': 1, 'b': 2}
{'a': 1, **{'a': 2}}  # => {'a': 2}

集合（Set）

# Set与list类似，但不存储重复的元素
empty_set = set()
some_set = set([1, 2, 2, 3, 4])   # some_set is now set([1, 2, 3, 4])

# 与字典类型一样，Set 里的元素也必须是不可修改的
invalid_set = {[1], 1}  # => Raises a TypeError: unhashable type: 'list'
valid_set = {(1,), 1}

# Set也是无序的，尽管有时看上去像有序的
another_set = set([4, 3, 2, 2, 1])  # another_set is now set([1, 2, 3, 4])
# 从Python 2.7开妈, {}可以用来声明一个Set
filled_set={1,2,2,3,4} #=>{1,2,3,4}
# Can set new variables to a set
filled_set = some_set
# 向Set中添加元素
filled_set.add(5)   # filled_set is now {1, 2, 3, 4, 5}
# 用 & 求 Set的交集
other_set = {3, 4, 5, 6}
filled_set & other_set # =>{3,4,5}
# 用 | 求 Set的合集
filled_set | other_set # =>{1,2,3,4,5,6}
# Do set difference with - 
{1,2,3,4}-{2,3,5} # => {1,4}
# Do set symmetric difference with ^ 
{1,2,3,4}^{2,3,5} #=>{1,4,5}
# 检查右边是否是左边的子集
{1, 2} >= {1, 2, 3} # => False
# 检查左边是否是右边的子集
{1, 2} <= {1, 2, 3} # => True
# 检查元素是否在集合中
2 in filled_set   # => True
10 in filled_set   # => False

控制流

分支结构

# 先定义一个变量
some_var = 5
# 这里用到了if语句 缩进是Python里的重要属性
# 打印 "some_var is smaller than 10"
if some_var > 10:
    print "some_var is totally bigger than 10."
elif some_var < 10:    # This elif clause is optional.
    print "some_var is smaller than 10."
else:           # This is optional too.
    print "some_var is indeed 10."

循环结构

# For 循环用来遍历一个列表
for animal in ["dog", "cat", "mouse"]:
    # 使用{0}格式 插入字符串
    print "{0} is a mammal".format(animal)

# "range(number)" 返回一个包含数字的列表
for i in range(4):
print i

# "range(lower, upper)" 返回一个从lower数值到upper数值的列表
for i in range(4, 8):
print i

# "range(lower, upper, step)" 返回一个从lower数值到upper步长为step数值的列表
# step 的默认值为1
for i in range(4, 8, 2):
    print(i)

# While 循环会一致执行下去，直到条件不满足
x=0
while x < 4:
print x
x+=1 #x=x+1的简写

异常处理

# 使用 try/except 代码块来处理异常
# 自 Python 2.6 以上版本支持:
try:
    # 使用 "raise" 来抛出一个异常
    raise IndexError("This is an index error")
except IndexError as e:
    pass    # Pass 表示无操作. 通常这里需要解决异常.
except (TypeError, NameError):
    pass    # 如果需要多个异常可以同时捕获
else:   # 可选项. 必须在所有的except之后
    print "All good!"   # 当try语句块中没有抛出异常才会执行
finally: #  所有情况都会执行
    print "We can clean up resources here"

# with 语句用来替代 try/finally 简化代码
with open("myfile.txt") as f:
    for line in f:
        print line

迭代器

# Python offers a fundamental abstraction called the Iterable.
# An iterable is an object that can be treated as a sequence.
# The object returned the range function, is an iterable.

filled_dict = {"one": 1, "two": 2, "three": 3}
our_iterable = filled_dict.keys()
print(our_iterable)  # => dict_keys(['one', 'two', 'three']). This is an object that implements our Iterable interface.

# We can loop over it.
for i in our_iterable:
    print(i)  # Prints one, two, three

# However we cannot address elements by index.
our_iterable[1]  # Raises a TypeError

# An iterable is an object that knows how to create an iterator.
our_iterator = iter(our_iterable)

# Our iterator is an object that can remember the state as we traverse through it.
# We get the next object with "next()".
next(our_iterator)  # => "one"

# It maintains state as we iterate.
next(our_iterator)  # => "two"
next(our_iterator)  # => "three"

# After the iterator has returned all of its data, it gives you a StopIterator Exception
next(our_iterator)  # Raises StopIteration

# You can grab all the elements of an iterator by calling list() on it.
list(filled_dict.keys())  # => Returns ["one", "two", "three"]

函数

# 使用 "def" 来创建一个新的函数
def add(x, y):
    print "x is {0} and y is {1}".format(x, y)
    return x + y    # 用 return 语句返回值
# 调用函数
add(5,6) #=>prints out "x is 5 and y is 6" 返回值为11
# 使用关键字参数调用函数
add(y=6, x=5)   # 关键字参数可以不在乎参数的顺序
# 函数的参数个数可以不定，使用*号会将参数当作元组
def varargs(*args):
    return args
varargs(1, 2, 3)   # => (1, 2, 3)

# 也可以使用**号将参数当作字典类型
def keyword_args(**kwargs):
    return kwargs
  # 调用一下试试看
keyword_args(big="foot", loch="ness") # => {"big": "foot", "loch": "ness"}

# 两种类型的参数可以同时使用
def all_the_args(*args, **kwargs):
    print args
    print kwargs
"""
all_the_args(1, 2, a=3, b=4) prints:
    (1, 2)
    {"a": 3, "b": 4}
"""

# When calling functions, you can do the opposite of args/kwargs!
# Use * to expand positional args and use ** to expand keyword args.
args = (1, 2, 3, 4)
kwargs = {"a": 3, "b": 4}
all_the_args(*args)   # 相当于 foo(1, 2, 3, 4)
all_the_args(**kwargs)   # 相当于 foo(a=3, b=4)
all_the_args(*args, **kwargs)   # 相当于 foo(1, 2, 3, 4, a=3, b=4)
# you can pass args and kwargs along to other functions that take args/kwargs
# by expanding them with * and ** respectively
def pass_all_the_args(*args, **kwargs):
    all_the_args(*args, **kwargs)
    print varargs(*args)
    print keyword_args(**kwargs)

# Returning multiple values (with tuple assignments)
def swap(x, y):
    return y, x  # Return multiple values as a tuple without the parenthesis.
                 # (Note: parenthesis have been excluded but can be included)

x = 1
y = 2
x, y = swap(x, y)     # => x = 2, y = 1
# (x, y) = swap(x,y)  # Again parenthesis have been excluded but can be included.

函数的作用域

x=5
def set_x(num):
    # 局部变量x与全局变量x不相同
    x = num # => 43
    print x # => 43
def set_global_x(num):
    global x
    print x # => 5
    x = num # 全局变量被设置成为6
    print x # => 6
set_x(43)
set_global_x(6)

# 函数也可以是对象
def create_adder(x):
    def adder(y):
        return x + y
return adder
add_10 = create_adder(10)
add_10(3)   # => 13
# 匿名函数
(lambda x: x > 2)(3)   # => True
(lambda x, y: x ** 2 + y ** 2)(2, 1) # => 5
# 高阶函数
map(add_10, [1, 2, 3])   # => [11, 12, 13]
map(max, [1, 2, 3], [4, 2, 1])   # => [4, 2, 3]
filter(lambda x: x > 5, [3, 4, 5, 6, 7])   # => [6, 7]
# We can use list comprehensions for nice maps and filters
[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13]
[x for x in[3,4,5,6,7] if x>5] #=>[6,7]

类

# 继承 object 创建一个子类
class Human(object):
    # 一个类属性，所有该类的实例都可以访问
    species = "H. sapiens"
    # 基础实例化方法，在创建一个实例时调用
    # 注意在名称前后加双下划线表示对象或者属性是 Python 的特殊用法，但用户可以自己控制
    # 最好不要在自己的方法前这样使用
    def __init__(self, name):
        # 将参数赋值给实例属性
        self.name = name
        # 初始化属性
        self.age = 0
    # 一个实例方法。所有实例方法的第一个属性都是self
    def say(self, msg):
        return "{0}: {1}".format(self.name, msg)

    # A class method is shared among all instances
    # They are called with the calling class as the first argument
    @classmethod
    def get_species(cls):
        return cls.species 

    # A static method is called without a class or instance reference
    @staticmethod
    def grunt():
        return "*grunt*"

    # A property is just like a getter.
    # It turns the method age() into an read-only attribute
    # of the same name.
    @property
    def age(self):
        return self._age

    # This allows the property to be set
    @age.setter
    def age(self, age):
        self._age = age

    # This allows the property to be deleted
    @age.deleter
    def age(self):
        del self._age

# 创建一个实例
i = Human(name="Ian")
print i.say("hi") # prints out "Ian: hi"

j = Human("Joel")
print j.say("hello")  # prints out "Joel: hello"

# 调用类方法
i.get_species()   # => "H. sapiens"

# 访问共有变量
Human.species = "H. neanderthalensis"
i.get_species()   # => "H. neanderthalensis"
j.get_species()   # => "H. neanderthalensis"

# 调用静态方法
Human.grunt()   # => "*grunt*"

# Update the property
i.age = 42

# Get the property
i.age # => 42

# Delete the property
del i.age
i.age  # => raises an AttributeError

模块

# 可以直接引用其它模块
import math
print math.sqrt(16)  # => 4
# 也可以引用模块中的函数
from math import ceil, floor
print ceil(3.7)  # => 4.0
print floor(3.7)   # => 3.0

# 你可以引用一个模块中的所有函数
# 警告：这是不推荐的
from math import *
# 可以给模块起个简短的别名
import math as m
math.sqrt(16) == m.sqrt(16)   # => True
# you can also test that the functions are equivalent
from math import sqrt
math.sqrt == m.sqrt == sqrt  # => True
# Python modules are just ordinary python files. You
# can write your own, and import them. The name of the
# module is the same as the name of the file.
# You can find out which functions and attributes
# defines a module.
import math
dir(math)

高级

# Generators help you make lazy code
def double_numbers(iterable):
    for i in iterable:
        yield i + i
# A generator creates values on the fly.
# Instead of generating and returning all values at once it creates one in each
# iteration.  This means values bigger than 15 wont be processed in
# double_numbers.
# Note xrange is a generator that does the same thing range does.
# Creating a list 1-900000000 would take lot of time and space to be made.
# xrange creates an xrange generator object instead of creating the entire list
# like range does.
# We use a trailing underscore in variable names when we want to use a name that
# would normally collide with a python keyword
xrange_ = xrange(1, 900000000)
# will double all numbers until a result >=30 found
for i in double_numbers(xrange_):
    print i
    if i >= 30:
break 
# Decorators
# in this example beg wraps say
# Beg will call say. If say_please is True then it will change the returned
# message
from functools import wraps

def beg(target_function):
    @wraps(target_function)
    def wrapper(*args, **kwargs):
        msg, say_please = target_function(*args, **kwargs)
        if say_please:
            return "{} {}".format(msg, "Please! I am poor :(")
        return msg
    return wrapper
@beg
def say(say_please=False):
    msg = "Can you buy me a beer?"
    return msg, say_please
print say()  # Can you buy me a beer?
print say(say_please=True)  # Can you buy me a beer? Please! I am poor :(

Free Online

Automate the Boring Stuff with Python (https://automatetheboringstuff.com)

Learn Python The Hard Way (http://learnpythonthehardway.org/book/)

Dive Into Python (http://www.diveintopython.net/)

Ideas for Python Projects(http://pythonpracticeprojects.com/)

The Official Docs (http://docs.python.org/2/)

Hitchhiker’s Guide to Python (http://docs.python-guide.org/en/latest/)

Python Module of the Week (http://pymotw.com/2/)

Python Course(http://www.python-course.eu/index.php)

First Steps With Python(https://realpython.com/learn/python-first-steps/)

A Crash Course in Python for Scientists (http://nbviewer.ipython.org/5920182)

First Steps With Python (https://realpython.com/learn/python-first-steps/)

Fullstack Python (https://www.fullstackpython.com/)

30Python Language Features and Tricks You May Not Know About(http://sahandsaba.com/thirty-python-language-features-and-tricks-you-may-not-know.html)

Official Style Guide for Python(https://www.python.org/dev/peps/pep-0008/)

Python 3 Computer Science Circles(http://cscircles.cemc.uwaterloo.ca/)