Python学习笔记：基础

本文根据廖雪峰的博客，学习整理笔记。主要内容有：基本数据类型，容器数据类型，变量及其作用域，判断及循环语法，函数式编程，面向对象，模块等概念。

数据类型

在python中，能够直接处理的数据类型有以下几种：

• 整数
• 浮点数
• 字符串
• 布尔值
• 空值

其他内置的数据类型：

• 列表 list 是一种有序的集合，例如 classmates = ['Michael', 'Bob', 'Tracy']
  • len() 获取个数
  • list[0] 取值
  • apend('tom') 追加元素到末尾
  • insert(1,'tom') 插入指定元素
  • pop(1) 删除指定位置元素，不传参数删除末尾元素
• 元祖 tuple 和list类似，一旦初始化就不能修改，例如 classmates = ('Michael', 'Bob', 'Tracy')
  • 只有一个元素的元祖可以表示为 t = (1,)
  • 没有append()，insert()这样的方法
• 字典 dict 全称dictionary，类似java中map，使用键值对存储，例如 d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
  • 取值 d['Michael']
  • 判断key值是否存在，通过in判断，'Tom' in d， 或者get()，不存在返回None
  • 删除一个key，用pop(key)方法，对应的value以会删除
  • dict的key必须是不可变对象，在python中字符串、整数等都是不可以变的，可以作为key。而list不可变，不能作为key
• set 和list类似，但是没有重复的元素，set的原理和dict一样，set存放的是key，没有value。要创建一个set，需要提供一个list作为输入集合，例如 s = set([1, 2, 3]) ，打印出的结果是 {1，2，3}
  • add(key) 添加元素
  • remove(key) 删除元素

变量

这种变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言。静态语言在定义变量时必须指定变量类型，如果赋值的时候类型不匹配，就会报错。

字符串和编码

现在计算机系统通用的字符编码工作方式：在计算机内存中，统一使用Unicode编码，当需要保存到硬盘或者需要传输的时候，就转换为UTF-8编码。

由于Python的字符串类型是str，在内存中以Unicode表示，一个字符对应若干个字节。如果要在网络上传输，或者保存到磁盘上，就需要把str变为以字节为单位的bytes。

Python对bytes类型的数据用带b前缀的单引号或双引号表示。

函数

判断：

if case1:
    do1
elif case2:
    do2
elif case3:
    do3
else:
    do4

循环：python中循环有两种，一种是for...in循环，依次把list或tuple中每个元素迭代出来；第二种是while循环

names = ['Michael', 'Bob', 'Tracy']
for name in names:
    print(name)

python内置函数range()，可以生成一个整数序列，在通过list()函数可以转换为list。例如 list(range(5))

sum = 0
n = 99
while n > 0:
    sum = sum + n
    n = n - 2
print(sum)

在循环中，break语句可以提前退出循环，continue可以跳过当前这次循环。

计算机程序中，函数就是最基本的一种代码抽象的方式。

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

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

定义函数，使用def语句，依次写出 函数名 括号 括号中的参数 冒号，然后，在缩进快中编写函数体，函数的返回值用return语句返回。如果没有return语句，函数执行完毕后也会返回结果，只是结果为None。retrun None可以简写为return。

def my_abs(x):
    if x >= 0:
        return x
    else:
        return -x

空函数：如果想定义一个什么事也不做的空函数，可以用pass语句：

def nop():
    pass

参数检查：调用函数时，如果参数个数不对，Python解释器会自动检查出来，并抛出TypeError。数据类型检查可以用内置函数isinstance()实现。

返回多个值：可以返回多个值，但这其实只是一种假象，返回值是一个tuple，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值。例如：

import math

def move(x, y, step, angle=0):
    nx = x + step * math.cos(angle)
    ny = y - step * math.sin(angle)
    return nx, ny

函数的参数：

默认参数，默认参数必须指向不变对象

def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

可变参数，在参数前面加了一个*号，参数numbers接收到的是一个tuple，调用该函数时，可以传入任意个参数

def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

关键字参数，关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict

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

# 调用后

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

# 复杂调用

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

# 简化后,**extra表示把extra这个dict的所有key-value用关键字参数传入到函数的**kw参数，
# kw将获得一个dict，注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra

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

命名关键字参数，如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数。和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数。

def person(name, age, *, city, job):
    print(name, age, city, job)

# 调用方式

>>> person('Jack', 24, city='Beijing', job='Engineer')
Jack 24 Beijing Engineer

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

def f1(a, b, c=0, *args, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)

def f2(a, b, c=0, *, d, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)

错误

python中也是采用了 try...except...finally... 的错误处理机制。

调用栈：如果错误没有被捕获，它就会一直往上抛，最后被python解释器捕获，打印一个错误信息，然后程序退出。

记录错误：python内置的loggin模块可以非常容易记录错误信息。

import logging
logging.basicConfig(level=logging.INFO)
def foo(s):
    return 10 / int(s)
def bar(s):
    return foo(s) * 2
def main():
    try:
        bar('')
    except Exception as e:
        logging.exception(e)
main()
print('END')

抛出错误：因为错误是class，捕获一个错误就是捕获到该class的一个实例。因为，错误并不是凭空产生的，而是有意创建并抛出的。pyhton的内置函数会抛出很多类型的错误，我们自己编写的函数也可以抛出错误。python中用raise语句抛出一个错误的实例。raise语句如果不带参数，就会把当前错误原样抛出。

class FooError(ValueError):
    pass
def foo(s):
    n = int(s)
    if n==0:
        raise FooError('invalid value: %s' % s)
    return 10 / n
foo('')

一个比较常见的错误处理方式：

def foo(s):
    n = int(s)
    if n==0:
        raise ValueError('invalid value: %s' % s)
    return 10 / n

def bar():
    try:
        foo('')
    except ValueError as e:
        print('ValueError!')
        raise

bar()

捕获错误的目的只是记录一下，便于后续追踪，但是由于当前函数不知道应该怎么处理该错误，所以，最恰当的方式是继续往上抛，让顶层调用者去处理。

函数式编程

函数是Python内建支持的一种封装，我们通过把大段代码拆成函数，通过一层一层的函数调用，就可以把复杂任务分解成简单的任务，这种分解可以称之为面向过程的程序设计。函数就是面向过程的程序设计的基本单元。

函数式编程就是一种抽象程度很高的编程范式，纯粹的函数式编程语言编写的函数没有变量，因此，任意一个函数，只要输入是确定的，输出就是确定的，这种纯函数我们称之为没有副作用。而允许使用变量的程序设计语言，由于函数内部的变量状态不确定，同样的输入，可能得到不同的输出，因此，这种函数是有副作用的。

函数式编程的一个特点就是，允许把函数本身作为参数传入另一个函数，还允许返回一个函数！

Python对函数式编程提供部分支持。由于Python允许使用变量，因此，Python不是纯函数式编程语言。

函数名其实就是指向函数的变量，既然变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数（Higher-order function）。

def add(x, y, f):
    return f(x) + f(y)

高阶函数除了可以接受函数作为参数外，还可以把函数作为结果值返回。相关参数和变量都保存在返回的函数中，这种程序结构称为”闭包（Closure）”。

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum

匿名函数：关键字体lamba表示匿名函数。

装饰器：在函数调用前后对函数进行增强，但是又不希望修改原函数的定义，这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。

import functools

def log(text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            print('%s %s' % (text, func.__name__))
            nest = func(*args, **kwargs)
            print('end call')
            return nest
        return wrapper
    return decorator

@log('execute')
def now(who):
    print(who + ' 2015-3-25')

if __name__ == "__main__":
    now('System say')

python的@语法，可以实现函数的增强功能。

生成器：可以参考这篇文章https://www.cnblogs.com/wongbingming/p/9060989.html

模块

为了编写可维护的代码，我们把很多函数分组，分别放到不同的文件里，这样，每个文件包含的代码就相对较少，很多编程语言都采用这种组织代码的方式。在Python中，一个.py文件就称之为一个模块（Module）。

为了避免模块名冲突，Python又引入了按目录来组织模块的方法，称为包（Package）。

请注意，每一个包目录下面都会有一个__init__.py的文件，这个文件是必须存在的，否则，Python就把这个目录当成普通目录，而不是一个包。__init__.py可以是空文件，也可以有Python代码，因为__init__.py本身就是一个模块，而它的模块名就是包名。

注意：如果 import package 即导入包名的话，只会导入 __init__.py 文件中的变量和函数。如果写做 from package import module 那么就是导入此包下的 module.py 中的变量和函数。

一个hello模块：

 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-

 ' a test module '

 __author__ = 'Michael Liao'

 import sys

 def test():
     args = sys.argv
     if len(args)==1:
         print('Hello, world!')
     elif len(args)==2:
         print('Hello, %s!' % args[1])
     else:
         print('Too many arguments!')

 if __name__=='__main__':
     test()

第1行和第2行是标准注释，第1行注释可以让这个hello.py文件直接在Unix/Linux/Mac上运行，第2行注释表示.py文件本身使用标准UTF-8编码；

第4行是一个字符串，表示模块的文档注释，任何模块代码的第一个字符串都被视为模块的文档注释；

第6行使用__author__变量把作者写进去，这样当你公开源代码后别人就可以瞻仰你的大名；

后面就开始是真正的代码部分。使用sys模块的第一步，就是导入该模块，第8行，但 import 指令，还会做一件重要的事情就是把 import 的那个 module 的代码执行一遍。

第19行和第20行的意思是，Python解释器把一个特殊变量__name__置为__main__，而如果在其他地方导入该hello模块时，if判断将失败，因此，这种if测试可以让一个模块通过命令行运行时执行一些额外的代码，最常见的就是运行测试。

变量和函数作用域：

• 私有的 private 通过下划线_前缀来实现
• 类似 __xxx__ 这样的变量是特殊变量，可以被直接引用，但是有特殊用途，一般我们自己的变量不要用这种变量名
• 公开的 pulic 正常的函数和变量名

安装第三方模块：一般来说，第三方库都会在Python官方的pypi.python.org网站注册，要安装一个第三方库，必须先知道该库的名称，可以在官网或者pypi上搜索。然后用包管理工具pip完成安装，例如 pip install package

面向对象

在Python中，所有数据类型都可以视为对象，当然也可以自定义对象。自定义的对象数据类型就是面向对象中的类（Class）的概念。

面向对象的设计思想是从自然界中来的，因为在自然界中，类（Class）和实例（Instance）的概念是很自然的。Class是一种抽象概念，比如我们定义的Class——Student，是指学生这个概念，而实例（Instance）则是一个个具体的Student，比如，Bart Simpson和Lisa Simpson是两个具体的Student。

在Python中，定义类是通过class关键字：

class Student(object):

    def __init__(self, name, score):
        self.__name = name
        self.__score = score

    def print_score(self):
        print('%s: %s' % (self.name, self.score))

由于类可以起到模板的作用，因此，可以在创建实例的时候，把一些我们认为必须绑定的属性强制填写进去。通过定义一个特殊的__init__方法，在创建实例的时候，就把name，score等属性绑上去。

注意到__init__方法的第一个参数永远是self，表示创建的实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。

有了__init__方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但self不需要传，Python解释器自己会把实例变量传进去。

和普通的函数相比，在类中定义的函数只有一点不同，就是第一个参数永远是实例变量self，并且，调用时，不用传递该参数。除此之外，类的方法和普通函数没有什么区别，所以，你仍然可以用默认参数、可变参数、关键字参数和命名关键字参数。

可以使用type()函数来判断对象类型。

对于class的继承关系来说，使用type()就很不方便。我们要判断class的类型，可以使用isinstance()函数。

如果要获得一个对象的所有属性和方法，可以使用dir()函数，它返回一个包含字符串的list。

如果想要限制实例属性，可以在定义class的时候，定义一个特殊的__slots__变量，来限制该class实例能添加的属性。

Python中可以通过@property和@param.setter这个两个装饰器将普通方法变成属性调用，用起来和get/set一样。

Python中可以有多重继承，这种设计通常称之为 MixIn 。Java中不支持多继承，但是可以实现接口。

Python的class中有许多有特殊用途的函数，可以帮助我们定制类。

• __str__
• __iter__
• __getitem__
• __getattr__
• __call__

枚举：可以从Enum派生出自定义类，例如

from enum import Enum, unique

@unique
class Weekday(Enum):
    Sun = 0 # Sun ? value ???? 0
    Mon = 1
    Tue = 2
    Wed = 3
    Thu = 4
    Fri = 5
    Sat = 6

if __name__ == '__main__':
    print(Weekday.Wed.value)

@unique装饰器可以帮助我们检查保证没有重复值

异常和错误

错误处理机制

try:
    print('try...')
    r = 10 / 0
    print('result:', r)
except ZeroDivisionError as e:
    print('except:', e)
finally:
    print('finally...')
print('END')

python代码规范 https://www.python.org/dev/peps/pep-0008/

官方文档 https://docs.python.org/3/