Python学习笔记-入门篇

相关网站

• Python官方文档：https://docs.python.org/3/
• iPython（网页编程）：http://ipython.org/
• jupyter notebook（网页编程）：https://jupyter-notebook.readthedocs.io/en/latest/
• PyCharm：https://www.jetbrains.com/pycharm/
• pip：http://pip.pypa.io/en/stable/installing/
• pep8规范：https://www.python.org/dev/peps/pep-0008/

---

安装

mac：

下载相应系统的安装包安装即可（下载地址：https://www.python.org/downloads/）
检验安装成功与否：

$ python3

Linux：

下载源码压缩包：https://www.python.org/downloads/source/

tar -zxvf Python-3.6.1.tgz
cd Python-3.6.1
./configure
make && make install
# 检查 Python3 是否正常可用
python3 -V

其他环境见https://www.runoob.com/python3/python3-install.html

获取帮助文档：

$ python3
$ help(filter)

安装autopep8

1. 安装：$ pip3 install autopep8
2. 进入pycharm菜单Preference - Tools - External Tools
3. 点击+按钮
4. 填写

• Name: autopep8
• Program: /Library/Frameworks/Python.framework/Versions/3.8/bin/autopep8
• Arguments: --in-place --aggressive --aggressive $FilePath$
• Working directory: $ProjectFileDir$
• Output filters: $FILE_PATH$\:$LINECOLUMN$:.*

---

基本数据类型

• Number（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Set（集合）
• Dictionary（字典）

不可变数据：Number（数字）、String（字符串）、Tuple（元组）
可变数据：List（列表）、Dictionary（字典）、Set（集合）

多变量赋值：

a = b = c = 1
a, b, c = 1, 1.1, 'abc'

一个变量可以通过赋值指向不同类型的对象

判断数据类型：

type('123')  # 
isinstance(123, int) # True

isinstance 和 type 的区别在于：
type()不会认为子类是一种父类类型；
isinstance()会认为子类是一种父类类型。

---

Number（数字）

• 支持 int、float、complex（复数）等数值类型
• 整型是没有限制大小的，可以当作 Long 类型使用
• 浮点型可以使用科学计数法表示：2.5e2 = 2.5 x 10^2 = 250
• 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型
• 数据类型不允许改变，如改变数字数据类型的值，将重新分配内存空间
• 在混合计算时，将把整型转换成为浮点数
• 数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数

数值运算：

5 + 4  # 9
4.3 - 2 # 2.3
3 * 7  # 21
2 / 4  # 0.5，得到一个浮点数
2 // 4 # 0，得到一个整数
17 % 3 # 2，取余 
2 ** 5 # 32，乘方

数值类型转换：

x, y, z, k = 1, 2.5, 0xA0F, 0o37
int(y) # 2
float(x) # 1.0
complex(x) # (1+0j)
complex(x, y) # (1+2.5j)
z # 十六进制，等于2575
k # 八进制，等于31

---

String（字符串）

• 字符串用单引号 ' 或双引号 " 括起来
• 使用三引号('''或""")可以指定一个多行字符串
• 不支持单字符类型，单字符是作为一个字符串使用
• 反斜杠可以用来转义，使用r可以让反斜杠不发生转义
• 字符串有两种索引方式，从左往右以0开始，从右往左以-1开始
• 字符串不能被改变。向一个索引位置赋值，比如word[0] = 'm'会导致错误

字符串的截取：

str = 'abcd'
str[0] # a
str[1:3] # bc
str[0:-1] # abc
str[1:] # bcd

字符串其他操作：

str = 'abc'
str[a * 3] # abcabcabc，重复
str + 'def' # abcdef，连接
print('abc\ndef')
# abc
# def，\ 转义特殊字符

print(r'abc\ndef') # abc\ndef，字符串前面添加一个 r，表示原始字符串

# 字符串格式化
print ("我叫 %s 今年 %d 岁!" % ('小陈', 28)) # 我叫 小陈 今年 28 岁!

# f-string
name = 'chan'
f'hello {name}' # hello chan
f'{1+2}' # '3'
rect = {'w': 100, 'h': 150}
f'宽度：{rect["w"]}, 高度：{rect["h"]}' # 宽度：100, 高度：150

# 字符串更新
str = 'hello world'
str[:6] + 'chan' # hello chan

---

List（列表）

• 和字符串一样，可以被索引和切片
• List可以使用+操作符进行拼接
• List中的元素是可以改变的
• 列表截取的语法：变量[头下标:尾下标]

基本操作：

list = [1, 2, 3, 'a', 'b', 'c', 1.1, True]
list2 = [0, 9, 8]

list[1] # 2
list[1:4] # [2, 3, 'a']
list[2:] # [3, 'a', 'b', 'c', 1.1, True]
list * 2 # [1, 2, 3, 'a', 'b', 'c', 1.1, True, 1, 2, 3, 'a', 'b', 'c', 1.1, True]
list + list2 # [1, 2, 3, 'a', 'b', 'c', 1.1, True, 0, 9, 8]

len(list) # 8，获取长度
del list[2] # 删除第三个元素
3 in list # True，元素是否存在于列表中
for x in list: print(x) # 迭代输出
list(tuple) # 将元组转换为列表

list.append('z') # [1, 2, 3, 'a', 'b', 'c', 1.1, True, 'z']，在列表末尾添加新的对象
list.count(2) # 1，统计某个元素在列表中出现的次数
list.extend([5, 6, 7]) # [1, 2, 3, 'a', 'b', 'c', 1.1, True, 'z', 5, 6, 7]，在列表末尾一次性追加另一个序列中的多个值
list.index('a') # 3，从列表中找出某个值第一个匹配项的索引位置
list.insert(6, 'd') # [1, 2, 3, 'a', 'b', 'c', 'd', 1.1, True, 'z', 5, 6, 7]，将对象插入列表
list.pop() # [1, 2, 3, 'a', 'b', 'c', 'd', 1.1, True, 'z', 5, 6]，移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.remove(1.1) # [1, 2, 3, 'a', 'b', 'c', 'd', True, 'z', 5, 6]，移除列表中某个值的第一个匹配项
list.reverse() # [6, 5, 'z', True, 'd', 'c', 'b', 'a', 3, 2, 1]，反向列表中元素
list.sort() # 排序
list2 = list.copy() # 复制列表
list.clear() # []，清空列表

# 遍历获取列表索引
for i, v in enumerate(list):
    print('第', i, '行的值是', v)

# 同时遍历两个数组
people = ['Lily', 'Lucy', 'Sam']
age = [18, 20, 22]
for p, a in zip(people, age):
    print('{0} 的年龄是 {1}'.format(p, a))
# Lily 的年龄是 18
# Lucy 的年龄是 20
# Sam 的年龄是 22

列表推导式：

list = [1, 3, 6]
list2 = [x * x for x in list]
print(list2) 
# [1, 9, 36]
list3 = [[x, x % 2] for x in list]
print(list3) 
# [[1, 1], [3, 1], [6, 0]]
list4 = ['chi', '   chi ', 'chi   ']
list5 = [x.strip() for x in list4]
print(list5) 
# ['chi', 'chi', 'chi']
list6 = [x for x in list if x > 2]
print(list6) 
#  [3, 6]
matrix = [
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12]
]
matrix2 = [[row[i] for row in matrix] for i in range(4)]
print(matrix2)
# [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
# 3X4的矩阵列表转换为4X3列表

---

Tuple（元组）

• 与列表类似，不同之处在于元组的元素不能修改
• 元组写在小括号 () 里，元素之间用逗号隔开
• 只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用
• 元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组

基本操作：

tuple = (1, 2, 3, 'a', 'b', 'c')
tuple2 = 4, 5, 6, 'd', 'e', 'f' # 不用括号也可以
tuple3 = (10)
tuple4 = (10,)
type(tuple2) # 
type((tuple3) # 
type((tuple4) # 
len(tuple) # 6
tuple4 * 5 # (10, 10, 10, 10, 10)
for x in tuple: print(x) # 迭代输出
tuple(list) # 将列表转为元组
del tuple # 删除

---

Dict 字典

• 字典是一种可变容器模型，且可存储任意类型对象
• 格式：d = {key1 : value1, key2 : value2 }
• 键必须是唯一且不可变，可以用数字，字符串或元组，列表不行
• 如果同一个键被赋值两次，以后一个为准
• 值可以取任何数据类型

基本操作：

dict = {
    'name': 'cyc',
    'age': 28
}
dict2 = { 'cyc': 'good' }

dict['name'] # cyc
dict['age'] # 28
dict['sex'] = 'male' # {'name': 'cyc', 'age': 28, 'sex': 'male'}
del dict['sex'] # 删除元素，{'name': 'cyc', 'age': 28}
dict[3] = 'c' # 键可以是数字

dict.get('age') # 28
len(dict) # 3，获取元素个数
str(dict) # 转字符串，{'name': 'cyc', 'age': 28, 3: 'c'}
'name' in dict # True，是否有该键

list(dict.keys()) # ['name', 'age', 3]
list(dict.values()) # ['cyc', 28, 'c']
list(dict.items()) # [('name', 'cyc'), ('age', 28), (3, 'c')]

dict.copy() # 浅复制
dict.update(dict2) # {'name': 'cyc', 'age': 28, 3: 'c', 'cyc': 'good'}，把字典dict2的键/值对更新到dict里
dict.pop('name') # cyc，删除字典给定键 key 所对应的值，返回值为被删除的值
dict.popitem() # ('cyc', 'good')，返回并删除字典中的最后一对键和值

dict.clear() # 清空字典
del(dict) # 删除字典

dict2 = dict2.fromkeys(('Tom', 'Ben', 'Sam'), 10) 
# {'Tom': 10, 'Ben': 10, 'Sam': 10}
# 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值

# 元组列表转字典
dict = dict([('Lucy', 18), ('Lily', 20), ('Ben', 22)])
print(dict) # {'Lucy': 18, 'Lily': 20, 'Ben': 22}
# 遍历技巧
for k, v in dict.items():
    print(k, "is ", v, ' age years old')
# Lucy is  18  age years old
# Lily is  20  age years old
# Ben is  22  age years old

字典推导式：

square = {x : x * x for x in (2, 4, 6)}
print(square) # {2: 4, 4: 16, 6: 36}

---

Set 集合

• 是一个无序的不重复元素序列
• 使用大括号 { } 或者 set() 函数创建集合
• 创建一个空集合必须用 set() 而不是 { }

基本操作

fruit = {'apple', 'banana', 'lemon', 'orange'}
print('apple' in fruit) # True，判断是否存在与集合中

set1 = set('abcdefg') # {'f', 'd', 'c', 'a', 'b', 'e', 'g'}
set2 = set('efgh') # {'h', 'e', 'g', 'f'}
set1 - set2 # {'a', 'b', 'd', 'c'}，集合set1中包含而集合set2中不包含的元素
set1 | set2 # {'f', 'h', 'd', 'b', 'a', 'c', 'e', 'g'}，集合set1或set2中包含的所有元素
set1 & set2 # {'e', 'g', 'f'}，集合set1和set2中都包含了的元素
set1 ^ set2 # {'h', 'd', 'c', 'a', 'b'}，不同时包含于set1和set2的元素
set2.add('ij') # {'f', 'h', 'e', 'g', 'ij'}，添加元素

set3 = set(('Tom', 'Ben', 'Sam')) # {'Ben', 'Tom', 'Sam'}
set3.update({'Lily', 'Lucy'}) # {'Tom', 'Sam', 'Ben', 'Lily', 'Lucy'}，添加元素
set3.update(['Kaka', 'Fango'], ['Trump', 'Bush']) # {'Fango', 'Bush', 'Kaka', 'Sam', 'Ben', 'Lily', 'Lucy', 'Tom', 'Trump'}，添加元素
len(set3) # 9，获取集合元素个数
set3.remove('Trump') # 删除元素，元素不存在会报错
set3.discard('Bush') # 删除元素，元素不存在也不会报错
print(set3.pop()) # 随机删除一个元素，并返回该元素
set3.clear() # set()，情况集合

集合推导式：

set1 = {x for x in 'chenyuchi' if x not in 'chen'}
print(set1) # {'u', 'i', 'y'}

---

条件控制

• 每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块
• 使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块
• Python中没有switch – case语句

if 1 == 1:
    print(True)
print(False)

# if 1 == 2 and 1 != 2:
# if 1 == 2 or 1 != 2:
# if not 1 == 2:
# if 1 in [1, 2, 3]:
# if 1 not in [1, 2, 3]

a = 0
while a < 10:
    if a % 2 == 0:
        print(a, '是偶数')
    else:
        print(a, '是奇数')
    a += 1

age = int(input("你几岁？: "))
if age < 28:
    print("你比我小！")
elif age == 28:
    print("跟我一样！")
elif age > 28:
    print("你比我大")

# 退出提示
input("点击 enter 键退出")

---

循环语句

• Python 中有while和for等循环语句，没有 do..while 循环

# 计算从 0 加到 100 之和
i, sum = 0, 0
while i < 100:
    i += 1
    sum += i
print(sum) # 5050

# while...else语句
x = 0
while x < 10:
    print('%d小于10' % x)
    x += 1
else:
    print('%d大于10' % x)

# 循环遍历列表
people = ['Ben', 'Lucy', 'Lily', 'Sam']
for x in people:
    print(x)
# break语句
for y in people:
    print(y)
    if 'L' in y:
        print('名字有L，break')
        break
# continue语句
for y in people:
    if 'L' in y:
        print('名字有L，不输出')
        continue
    print(y)

# range函数，会生成数列
for i in range(5):
    print(i, end()) # 0,1,2,3,4

for i in range(5, 9):
    print(i) # 5,6,7,8

for i in range(0, 10, 3):
    print(i) # 0,3,6,9

for i in range(len(people)):
    print(i, people[i]) # 0 Ben,1 Lucy,2 Lily,3 Sam

list = list(range(5)) # [0, 1, 2, 3, 4]

# pass是空语句，是为了保持程序结构的完整性。
# pass不做任何事情，一般用做占位语句
for letter in 'chenyuchi':
    if letter == 'y':
        pass
        print('执行 pass 块')
    print('当前字母 :', letter)

---

函数

• 不带表达式的return相当于返回 None

# 简单示例
def area(width, height):
    return width * height
w = 4
h = 5
print('宽为', w, '，高为', h, '的长方形，面积是 ', area(w, h))
# 宽为 4 ，高为 5 的长方形，面积是  20

# 不带return
def func():
  a = 0
print(func()) # None，不带表达式的return相当于返回 None

# 参数为不可变类型
# 如 整数、字符串、元组，传递的只是x的值，没有影响x对象本身，只是修改另一个复制的对象
def setVal(x):
    x += 1
    print(x) # 1
x = 0
setVal(x)
print(x) # 0

# 参数为可变类型
# 如 列表，字典，函数内修改后外部的变量也会受影响
def setList(list):
    list.append(['a', 'b', 'c'])
    print(list) # [1, 2, 3, ['a', 'b', 'c']]
list = [1, 2, 3]
setList(list)
print(list) # [1, 2, 3, ['a', 'b', 'c']]

参数：

• 必需参数：须以正确的顺序传入函数。调用时的数量必须和声明时的一样
• 关键字参数
• 默认参数
• 不定长参数

def func1(str, num): 
  print(str, num)
# str和num为必传参数，调用时数量和顺序必须和声明时的一样

def func2(str, num, arg = 30):
    print(str, num, arg)
func(num=10, str='abc') # abc 10 30
# str和num为关键字参数，调用时顺序可与申明时不一样，arg为默认参数

def func3(arg1, arg2, *others):
    print(arg1, arg2, others)
func2(1, 2, 3, 4, 5) # 1 2 (3, 4, 5)
# 不定长参数，前面用*号开头，带*号参数会以元组的形式导入，存放所有未命名的变量参数

def func4(arg1, arg2, **others):
    print(arg1, arg2, others)
func3(1, 2, a=3, b=4, c=5) # 1 2 {'a': 3, 'b': 4, 'c': 5}
# 前面用**号开头的，会以字典的形式导入

def func5(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
# 强制位置参数
# a 和 b 必须使用指定位置参数，c 或 d 可以是位置形参或关键字形参，而 e 或 f 要求为关键字形参
# f(10, 20, 30, d=40, e=50, f=60)，正确
# f(10, b=20, c=30, d=40, e=50, f=60) 错误，b不能使用关键字参数的形式
# f(10, 20, 30, 40, 50, f=60)，错误，e必须使用关键字参数的形式

匿名函数：

使用 lambda 来创建匿名函数

• lambda的主体是一个表达式，而不是一个代码块
• lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数
• 语法：lambda [arg1 [,arg2,.....argn]]:expression

sum = lambda arg1, arg2: arg1 + arg2
print(sum(10, 30)) # 40

iter 迭代器：

list = [1, 2, 3]
it = iter(list)
print(next(it)); # 1
print(next(it)); # 2

yield语句：

def frang (start, stop, step):
    x = start
    while x < stop:
        yield x
        x += step

for i in frang(0, 5, 0.5):
    print(i, end=',')
# 0,0.5,1.0,1.5,2.0,2.5,3.0,3.5,4.0,4.5

常用内置函数：

l = [1, 2, 3, 4, 5, 6 , 7, 8, 9, 10]
# filter
l2 = list(filter(lambda x : x > 5, l))
print(l2) # [6, 7, 8, 9, 10]
# map
l3 = list(map(lambda x : x * 10, l))
print(l3) # [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
# reduce
l4 = reduce(lambda x, y : x + y, l, 1)
print(l4) # 56
# zip
t = (1, 2, 3)
t2 = (4, 5, 6)
for i in zip(t, t2):
    print(i)
# (1, 4)
# (2, 5)
# (3, 6)
d = {'a': 'aa', 'b': 'bb'}
d2 = zip(d.values(), d.keys())
print(dict(d2))
# {'aa': 'a', 'bb': 'b'}

闭包：

def counter(start = 0):
    l = [start]
    def addOne() :
        l[0] += 1
        return l[0]
    return addOne
num5 = counter(5)
num10 = counter(10)
print(num5()) # 6
print(num5()) # 7
print(num10()) # 11
print(num10()) # 12
print(num10()) # 13

def line_func(a, b):
    return lambda x : a * x + b
line1 = line_func(3, 5)
line2 = line_func(5, 8)
print(line1(10))
print(line2(10))

装饰器：

import time

def timer(func):
    def wrapper():
        start_time = time.time()
        func()
        end_time = time.time()
        print('程序运行了 %f 秒' % (end_time - start_time))
    return wrapper

@timer
def mySleep():
    time.sleep(3)

mySleep()

def communicate(word):
    def do(func):
        def wrapper(name, something):
            print(word, end=',')
            print(name, end=' ')
            func(name, something)
            print(something)
        return wrapper
    return do

@communicate('hello')
def eat(name, something):
    print('is eating', end=' ')

@communicate('good moring')
def find(name, something):
    print('is finding', end=' ')

eat('Tom', 'apple') # hello,Tom is eating apple
find('Ben', 'a pen') # good moring,Ben is finding a pen

---

模块

模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数等功能。

import 语句

import module1[, module2[,... moduleN]
# 使用别名
import time as t

from … import 语句

# from modname import name1[, name2[, ... nameN]]
from fibo import fib, fib2
fib(500)

from … import * 语句

把一个模块的所有内容全都导入到当前的命名空间

from modname import *

__name__属性

if __name__ == '__main__':
   print('程序自身运行')
else:
   print('在其他模块运行')

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称

import my_module
my_module.hello('Ben')
print(dir(my_module))
# ['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'bye', 'hello', 'morning']

---

包（package）

• 包是一种管理 Python 模块命名空间的形式
• 目录只有包含一个叫做 init.py 的文件才会被认作是一个包

import pA.pAA.mA
pA.pAA.mA.afternoon('Tom')
# 必须使用全名去访问

from pA.pAA import mA
mA.afternoon('Tom')

from pA.pAA.mA import afternoon
afternoon('Tom')

---

File文件

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

• filename：文件名称的字符串值
• mode：打开文件的模式
• buffering: 设置缓冲
• encoding: 一般使用utf8
• errors: 报错级别
• newline: 区分换行符
• closefd: 传入的file参数类型

mode	解释
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

f = open('file.text', 'w+')
f.read(size) # 读取一定数目的数据
f.readline() # 读取整行，包括 "\n" 字符，如果返回一个空字符串, 说明已经已经读取到最后一行
f.readlines(sizehint,) # 读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区
f.write('123') # 写入字符串到文件中, 返回写入的字符数
f.writelines(sequence) # 向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符
f.tell() # 返回文件对象当前所处的位置, 从文件开头开始算起的字节数
f.seek(5) # 移动到文件的第六个字节
f.seek(-3, 2) # 移动到文件的倒数第三字节
f.flush() # 刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
f.close() # 关闭文件并释放系统的资源

---

错误和异常

try/except 异常处理

try:
  x = int(input("请输入一个数字: "))
except ValueError:
  print("您输入的不是数字，请再次尝试输入！") 

try:
    f = open('myfile.txt')
    s = f.readline()
    i = int(s.strip())
except OSError as err:
    print("OS 错误: {0}".format(err))
except ValueError:
    print("无法将数据转换为整型")
except:
    print("其他错误:", sys.exc_info()[0])
    raise

try/except...else

else 子句将在 try 子句没有发生任何异常的时候执行

for arg in sys.argv[1:]:
    try:
        f = open(arg, 'r')
    except IOError:
        print('打开不了', arg)
    else:
        print(arg, '内容为：', len(f.readlines()), 'lines')
        f.close()

try-finally

无论是否发生异常都将执行最后的代码

抛出异常

raise [Exception [, args [, traceback]]]

x = 10
if x > 5:
    raise Exception('x 不能大于 5。x 的值为: {}'.format(x))

---

面向对象

声明类：

class Animal():
    # 构造函数
    def __init__(self, color, food): # self代表类的实例，而非类
        self.color = color
        self.food = food
    # 类方法
    def move(self):
        print('I can move')
    def getInfo(self):
        print('This animal is %s, eats %s' %(self.color, self.food))

私有变量和私有方法以两个下划线开头

实例化：

tiger = Animal('yello', 'meat')
tiger.getInfo() # This animal is yello, eats meat

继承 & 方法重写：

class Cat(Animal):
    def __init__(self, color, food):
        super().__init__(color, food)
    def move(self): # 方法重写
        print('Of couse, I can move!')
    def catch_mouse(self):
        print('I can catch mouse')
cat = Cat('black', 'fish and mouse')
cat.getInfo() # This animal is black, eats fish and mouse
cat.catch_mouse() # I can catch mouse
cat.move() # Of couse, I can move!
super(Cat, cat).move() # I can move , 调用父类已被覆盖的方法

# 多继承：class DerivedClassName(Base1, Base2, Base3):

---

pip源的设置和使用

$ cd ~
$ mkdir .pip
$ vi pip.conf

编辑pip.conf文件内容：

[global]
timeout=30000
index-url=http://mirrors.aliyun.com/pypi/simple/
[install]
trusted-host=mirrors.aliyun.com

临时配置：

$ pip3 -i http://mirrors.aliyun.com/pypi/simple/ install XXX