本课程来源为MIT6_0001F16公开课，希望对大家有所帮助，有疑问的地方也请大家提出来。
一种较为经典的IO调用方法：
path = './test.txt'
try:
file_name = open(path, 'w')
print('write length: ', file_name.write('love minmin'))
finally:
if file_name:
file_name.close()
不过可以用with字段来对代码进行改进，其中这是比较好的一篇博客
with open(path, 'w') as f:
f_name = open(path, 'w')
print('write length: ', f_name.write('love minmin'))
文件读取的迭代操作
path = './test.txt'
f_name = open(path, 'r')
while True:
# c_str = f_name.readline(1) 按行操作
c_str = f_name.read(1) # 按字节操作
print('read str is:', c_str)
if not c_str:
break
f_name.close()
当解释器遇到import语句时，如果模块在当前路径就会被导入，搜索路径是一个解释器，会先搜索吧所有目录的列表。搜索路径是由一系列目录名组成的，Python解释器会一次从这些目录寻找引入的模块，搜索路径是在Python编译或者安装的时候确定的，被存储在sys模块的path变量中，可这样查看搜索路径。
import sys
print('Python的搜索路径为： %s' %sys.path)
import有两种使用方式
# 导入模块的两种方式
# 导入整个模块
import math
import math as m(取别名)
# 导入模块中制定的对象到当前命名空间
from math import pi
from math import pi, sin(导入多个)
多个赋值操作同时进行,这种方式为序列解包（sequence unpacking）
x,y,z = 1,2,3
student = {'name':'minmin', 'age':18}
key, value = student.popitem()
nums = 1,2,3
a,b,c = nums
链式赋值
a,b,c = 1,2,3
下面值作为布尔变量时，以下值为被解释器看作假，False和0等价，True和1等价：
False, None, 0, '', (), [], {}
>>> True == 1
True
>>> False == 0
True
>>> True + False +2
3
如果在一个内部函数里对外部函数（不是在全局作用域）的变量进行引用，内部函数就被认为是闭包。
#!/usr/bin/python3
#-*-coding:UTF-8-*-
def sum_late(*args):
def calc_sum():
sum = 0
for n in args:
sum += n
return sum
return calc_sum
print('调用sum_late的结果： ', sum_late(1,2,3,4))
calc_sum = sum_late(1,2,3,4)
print('调用calc_sum的结果: ', calc_sum())
# 运行结果
调用sum_late的结果： <function sum_late.<locals>.calc_sum at 0x000000000344A840
>
调用calc_sum的结果: 10
再看另外一个例子
def count():
fs = []
for n in range(1,4):
def f():
return n * n
fs.append(f)
return fs
f1, f2, f3 = count()
print('f1运行的结果是：', f1())
print('f2运行的结果是：', f2())
print('f3运行的结果是：', f3())
# 运行结果
f1运行的结果是： 9
f2运行的结果是： 9
f3运行的结果是： 9
由输出结果可以看到，返回的三个函数输出结果相同，因为它并非立刻执行，等到三个函数都返回了，其引用的变量n已经变成3，所以最终结果都为9。
注：返回闭包时，返回函数不要引用任何循环变量或者后续会发生变化的变量，否则很容易出错，上面的代码可以改为如下，已达到预期的效果。
#!/usr/bin/python3
#-*-coding:UTF-8-*-
def count():
def f(i):
def g():
return i * i
return g
fs = []
for n in range(1,4):
fs.append(f(n))
return fs
f1, f2, f3 = count()
print(f1, f2, f3)
print(f1(), f2(), f3())
最简单的求阶乘递归代码
def fact(n):
if n == 1:
return 1
return n * fact(n-1)
当递归次数太多，这时会发生栈溢出现象，此时可以用尾递归优化来解决。 尾递归是指在函数返回时调用函数本身，并且return语句不能包含表达式，这样编译器和解释器就可以进行优化，使得递归本身无论调用多少次都只占用一个栈帧。
书中给出的例子：
def tail_recursion(num, product):
if num == 1:
return product
return tail_recursion(num - 1, num * product)
print(tail_recursion(5, 1))
print(tail_recursion(900, 1))
不过有[博客][1]指出python不支持尾递归，这点有待考证
在程序一次性使用，不需要定义函数名时，用匿名函数可以节省内存中变量定义空间，并且让程序更简洁，这是可以使用lambda表达式。
# 常规方法
list1 = [1,2,3,4,5]
list2 = []
for n in list1:
if n > 2:
list2.append(n)
print(list2)
# 函数式编程
def func(x):
return x > 3
# filter返回的是一个迭代器
list3 = filter(func, list1)
print(list(list3))
# lambda表达式
print([item for item in filter(lambda x: x>3, list1)])
````
[1]: https://blog.csdn.net/qq_39521554/article/details/80112748
Python种最基本的数据结构是序列（Sequence），其中包含了6种内建序列，列表（List），元组（Tuple），字符串，Unicode字符串，buffer对象，xrange对象。
>>> field='just do it'
>>> field[-3:] = 'ok'
Traceback (most recent call last):
File "<pyshell#28>", line 1, in <module>
field[-3:] = 'ok'
TypeError: 'str' object does not support item assignment
>>>
str类型的对象不支持修改。
>>> print('hello, %s' %'world')
hello, world
%s为占位符，用来格式化字符串，此处主要记录语法。
>>> print('%s %s %d' %('2019','02',16))
2019 02 16
>>> print('%s %s %d' %['2019','02',16])
SyntaxError: invalid syntax
>>>
>>> print('%*.*f' %(10, 5, 3.1415926))
3.14159
>>>
注：只有元组和字典可以格式化一个以上的值。
字典是Python里唯一内建的映射类型，字典指定值并没有特殊顺序，都存储在一个特殊的键（Key）里，键可以是数字，字符串和元组。 字典是一种可变容器模型，可以存储任意类型对象。
键必须是唯一的，且不可变，如字符串，数字和元组，值可以是任意类型。
>>> a = dict(one=1, two=2, three=3)
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
>>> d = dict([('two', 2), ('one', 1), ('three', 3)])
>>> e = dict({'three': 3, 'one': 1, 'two': 2})
>>> a == b == c == d == e
True
也可以通过构造器创建
class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)
>>> p=dict([('name','minmin'),('age',17)])
>>> p
{'name': 'minmin', 'age': 17}
>>> p['name']
'minmin'
>>> type(p)
<class 'dict'>
>>> print('name: %(name)s' %p)
name: minmin
2019年猪年年初七开始在上海实习，由于部门需要用Python写自动化测试用例，笔者从今天开始系统学习Python（版本为3.7.2），因此新开一个博客类别作为读书笔记，书本为》《Python3.5从零开始学》，书中所写难免有错误，希望大家发现后指出，一起学习交流。
Python的创始人是Guido van Rossum，一位荷兰的天才，Python这个名字来自于Guido所挚爱的电视剧——Monty Python’s Flying Circus。更多关于Python的历史与介绍可以自行wiki。
简单来说，Python是一个简单，解释型，交互式，可移植，动态的，面向对象的超高级语。
Python目前支持六种数据类型：Number，String，List，Tuple，Sets，Dictionary。（这种分类参考书上，与官网有所不一致。） Python3支持三种不同的数据类型，int， float，complex，去掉了Python2的long。
>>> 3*3 # 表达式
9
>>> print(3*3) # 语句
9
>>> a=3*3 # 语句
>>>
观察以上代码，在交互模式下，对于前两个命令，解释器总是输出所有表达式的值（内部都使用相同的函数对结果进行呈现），而第三个赋值语句没有输出结果，因为语句不是表达式，所以没有值可供交互式解释器输出。
赋值语句有两个作用：一是建立新的变量，二是将值赋予变量，语句的特性即，它改变了事物。
Python支持7中运算符：算术运算符，比较运算符，赋值运算符，逻辑运算符，位运算符，成员运算符，身份运算符。 这里记录一些之前没接触过的。
a ** b， 同pow(a, b), 表示a的b次幂。a // b, 取整除。 9 // 2 = 4， 9.0 // 2 = 4.0!=， Python2中不等于是<>.1. a and b， 若a为False或0，则返回False或0， 反之返回b。
a or b， 若a不为0（False）， 则返回a，反之返回b。not a， 若a为0（False），则返回True，反之返回False。a in List（a not in List）， 作用为查找a是否在在指定的序列里。
a is b（a is not b）， 作用为判断a，b是否引用自一个对象。