www.liaoxuefeng.com/wiki/101695…

数据类型

• 整数 32, 0x20

• 浮点数 0.01，1e-2

• 字符串 'abc', "abc", "I'm OK"

# r防止转义
>>> print(r'\\\t\\')   
\\\t\\

• 布尔值 True,False

• 空值 None

变量

a = 'ABC'，Python解释器干了两件事情：

1. 在内存中创建了一个'ABC'的字符串；
2. 在内存中创建了一个名为a的变量，并把它指向'ABC'。

也可以把一个变量a赋值给另一个变量b，这个操作实际上是把变量b指向变量a所指向的数据。

a = 'ABC'
b = a
a = 'XYZ'
print(b)

ABC

字符串和编码

字符串编码：解决字符串在计算机中的表示问题，用数字指代字符。
Unicode采用两个字节编码一个字符，把所有语言都统一到一套编码里，这样就不会再有乱码问题了。
python提供 encode(format)函数对字符串进行编码，提供decode(format)对字节进行解码。

由于Python源代码也是一个文本文件，所以，当你的源代码中包含中文的时候，在保存源代码时，就需要务必指定保存为UTF-8编码。当Python解释器读取源代码时，为了让它按UTF-8编码读取，我们通常在文件开头写上 # -- coding: utf-8 --。

字符串格式化

>>> 'Hello, %s' % 'world'
'Hello, world'
>>> 'Hi, %s, you have $%d.' % ('Michael', 1000000)
'Hi, Michael, you have $1000000.'

list 和 tuple

list：可变的有序列表
tuple：不可变得有序列表

其中，tuple定义只有一个元素的时候，要加逗号。

# 定义只有一个元素的tuple，不加逗号，定义会出错
>>> t = (1)
>>> t
1

>>> t = (1,)
>>> t
(1,)

条件判断

if <条件判断1>:
    <执行1>
elif <条件判断2>:
    <执行2>
elif <条件判断3>:
    <执行3>
else:
    <执行4>

if语句执行有个特点，它是从上往下判断，如果在某个判断上是True，把该判断对应的语句执行后，就忽略掉剩下的elif和else。

dict 和 set

dict可以用在需要高速查找的很多地方，在Python代码中几乎无处不在，正确使用dict非常重要，需要牢记的第一条就是dict的key必须是不可变对象。

这是因为dict根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法（Hash）。

要保证hash的正确性，作为key的对象就不能变。在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key

函数

函数名其实就是指向一个函数对象的引用，完全可以把函数名赋给一个变量，相当于给这个函数起了一个“别名”：

>>> a = abs # 变量a指向abs函数
>>> a(-1) # 所以也可以通过a调用abs函数
1

默认参数的设置原则：

一是必选参数在前，默认参数在后，否则Python的解释器会报错（思考一下为什么默认参数不能放在必选参数前面）；（如果放在前面，无法判断传递的到底是给必选参数还是默认参数）。如 def my(b=2, a);调用my(3)????。

二是如何设置默认参数。

可变参数：函数存入任意多个参数，当作tuple处理

# *numbers 类似于取出list中的值
def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

>>> calc(1, 2)
5
>>> calc()
0

>>> nums = [1, 2, 3]
>>> calc(*nums)
14

关键字参数：函数存入多个kv参数，当作dict处理

def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)

>>> person('Michael', 30)
name: Michael age: 30 other: {}

>>> person('Bob', 35, city='Beijing')
name: Bob age: 35 other: {'city': 'Beijing'}
>>> person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}

>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, **extra)
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

高级特性

切片

切片语法的基本形式为：
alist[start:stop:step]
start：起始位置
stop：终止位置
step：步长

>>> L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']
>>> L[0:3]   # L[0:3]表示，从索引0开始取，直到索引3为止，但不包括索引3。
['Michael', 'Sarah', 'Tracy']
>>> L[:3]   # 如果第一个索引是0，还可以省略
['Michael', 'Sarah', 'Tracy']

>>> L[-2:-1]  # 支持倒数切片
['Bob']

>>> L[:10:2]  # 前10个数，每两个取一个
[0, 2, 4, 6, 8]

>>> L[::5]  # 所有数，每5个取一个
[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]

迭代

当我们使用for循环时，只要作用于一个可迭代对象，for循环就可以正常运行，而我们不太关心该对象究竟是list还是其他数据类型。

>>> from collections.abc import Iterable
>>> isinstance('abc', Iterable) # str是否可迭代
True
>>> isinstance([1,2,3], Iterable) # list是否可迭代
True
>>> isinstance(123, Iterable) # 整数是否可迭代
False

Python内置的enumerate函数可以把一个list变成索引-元素对

>>> from collections.abc import Iterable
>>> isinstance('abc', Iterable) # str是否可迭代
True
>>> isinstance([1,2,3], Iterable) # list是否可迭代
True
>>> isinstance(123, Iterable) # 整数是否可迭代
False

列表生成式

>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

>>> [x for x in range(1, 11) if x % 2 == 0]   # 这是因为跟在for后面的if是一个筛选条件
[2, 4, 6, 8, 10]

生成器

通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。

所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。

>>> g = (x * x for x in range(10))
>>> for n in g:
...     print(n)
... 
0
1
4
9
16
25
36
49
64
81

# 斐波拉契数列生成器 
def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        # 如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator
        # yield中断返回，当调用next(生成器)就执行一次返回
        yield b 
        a, b = b, a + b
        n = n + 1
    return 'done'
    
>>> for n in fib(6):
...     print(n)
...
1
1
2
3
5
8

迭代器

可以直接作用于for循环的对象统称为可迭代对象：Iterable。
可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。

你可能会问，为什么list、dict、str等数据类型不是Iterator？

这是因为Python的Iterator对象表示的是一个数据流，Iterator对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据，所以Iterator的计算是惰性的，只有在需要返回下一个数据时它才会计算。

Iterator甚至可以表示一个无限大的数据流，例如全体自然数。而使用list是永远不可能存储全体自然数的。

函数式编程

高阶函数

函数名就是变量，它指向一个可以执行某段代码的函数！

# 函数名就是执行函数的变量，可以作为一个函数的参数
def add(x, y, f):
    return f(x) + f(y)

print(add(-5, 6, abs))

高阶函数，就是让函数的参数能够接收别的函数。

常见的高阶函数有：map()、reduce()、filter()、sorted()

>>> list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
['1', '2', '3', '4', '5', '6', '7', '8', '9']

# reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
>>> from functools import reduce
>>> def add(x, y):
...     return x + y
...
>>> reduce(add, [1, 3, 5, 7, 9])
25


# 和map()类似，filter()也接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。
def is_odd(n):
    return n % 2 == 1

list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
# 结果: [1, 5, 9, 15]

# key指定的函数将作用于list的每一个元素上，并根据key函数返回的结果进行排序。
# key制定的函数就类似map的功能
>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)
['Zoo', 'Credit', 'bob', 'about']

返回函数

匿名函数

# lambda x: x * x实际上就是f(x) = x^2
>>> list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
[1, 4, 9, 16, 25, 36, 49, 64, 81]


>>> f = lambda x: x * x
>>> f
<function <lambda> at 0x101c6ef28>
>>> f(5)
25

装饰器

# 日志装饰器
def log(func):
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper
    
@log
def now():
    print('2015-3-25')
    
>>> now()
call now():
2015-3-25


# 如果decorator本身需要传入参数，那就需要编写一个返回decorator的高阶函数，写出来会更复杂。比如，要自定义log的文本：
def log(text):
    def decorator(func):
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator
    
@log('execute')
def now():
    print('2015-3-25')
    
>>> now()
execute now():
2015-3-25


import functools
# Python内置的functools.wraps 
def log(text):
    def decorator(func):
        # 把原始函数的__name__等属性复制到wrapper()函数中
        @functools.wraps(func) 
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator

模块

在Python中，一个.py文件就称之为一个模块（Module）。

举个例子，一个abc.py的文件就是一个名字叫abc的模块，一个xyz.py的文件就是一个名字叫xyz的模块。

现在，假设我们的abc和xyz这两个模块名字与其他模块冲突了，于是我们可以通过包来组织模块，避免冲突。

mycompany ├─ init.py ├─ abc.py └─ xyz.py 引入了包以后，只要顶层的包名不与别人冲突，那所有模块都不会与别人冲突。现在，abc.py模块的名字就变成了mycompany.abc，类似的，xyz.py的模块名变成了mycompany.xyz。