python3基础

* 编程是一种技能和工具，是理解计算机的有效途径，是一种新的思考方式。
 
#### 特点
* 语法简洁
* 类库丰富
* 跨平台
* 可拓展
* 开源
 
#### 历史
* 1990，诞生
* 2000，2.0发布
* 2008，3.0发布
* 2010，2的最后一个版本2.7
 
#### 数据类型
1. 整型：int  8
2. 浮点型：float   8.5
3. 字符：str  "6"
4. 布尔型：bool   true  false
###### 数据类型操作
* type()：查看数据类型
* 相同数据类型的数据才可以一起操作，例："6"必须先转换成整型或浮点型才可以进行计算
 
#### 序列
###### 定义
它的成员都是有序排列，并且可以通过下标偏移量访问它的成员。
###### 范围
1. 字符串 "abc"
2. 列表 [4,6,7] 成员可以变更
3. 元组 ("234", "hi") 成员不可变更
###### 序列基本操作
* 成员关系操作符：对象(in, not in)序列
* 连接操作符：序列 + 序列
* 重复操作符：序列 * 整数
* 切片操作符：序列[开始下标:结束下标]
```
# 下标从0开始，包含开头，不包含结尾
# 格式：序列[开始下标:结束下标]
a = [4,6,7]
a[1]  # 结果为：6
a[1:2]  # 结果为：[6]
```
 
###### 列表基本操作
* 添加元素，添加到最后面
`list.append("x")`
* 删除元素，删除最前面的一个元素
`list.remove("x")`
 
 
#### 字典{}
* 以键值对的形式出现，key会被进行hash运算存起来所以key不能重复，
* 类型int float string tuple都可以进行hash运算可以作为key。
* 查询使用 get，如果查询的值不存在，我们也可以给一个默认值，比如 score.get(‘yase’,99)。
 
#### 集合{}
* 集合（set）是一个**无序的不重复元素序列**。
* 可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
* `s = set(['a', 'b', 'c'])`
 
 
 
#### 条件语句if
```
if 条件:
  执行语句
elif 条件:
  执行语句
else:
  执行语句
```
#### 循环语句while
```
while 条件:
  执行语句
```
#### 循环语句for
``` 
for 迭代变量 in 可迭代对象:
  执行语句
```
#### 映射类型：字典{}
* 以键值对的形式出现
 
#### 文件操作
#### 错误≠异常
#### 迭代器
* 迭代是Python最强大的功能之一，是访问集合元素的一种方式。
* 迭代器是一个可以记住遍历的位置的对象。
* 迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
* 迭代器有两个基本的方法：iter() 和 next()。
* 字符串，列表或元组对象都可用于创建迭代器：
 
#### 生成器
* 跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。
* 在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。
调用一个生成器函数，返回的是一个迭代器对象。
在 Python 中，使用了 yield 的函数被称为生成器（generator）。
 
#### a,b=b,a+b 和 a=b b=a+b 的区别
```
a,b=0,1
a, b = b, a+b
# 这种赋值，先计算等值 右边 就是 b=1 a+b=1
# 再赋值给a和b，那么 a=1, b=1
#然后就是依次这样
 
a = b
# 此时 b=1, 那么a=1
b = a+b
# 那么 b=2
```
#### 匿名函数lambda
* lambda 只是一个表达式，函数体比 def 简单很多。
* lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
* lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
* 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
###### 一个语法
* lambda的语法是唯一的
```
 lambda argument_list: expression
```
###### 三个特性
1. **lambda函数是匿名的**：所谓匿名函数，通俗地说就是没有名字的函数。lambda函数没有名字。
2. **lambda函数有输入和输出**：输入是传入到参数列表argument_list的值，输出是根据表达式expression计算得到的值。
3. **lambda函数一般功能简单**：单行expression决定了lambda函数不可能完成复杂的逻辑，只能完成非常简单的功能。由于其实现的功能一目了然，甚至不需要专门的名字来说明。
 
###### 四个用法
1. 将lambda函数赋值给一个变量，通过这个变量间接调用该lambda函数。
2. 将lambda函数赋值给其他函数，从而将其他函数用该lambda函数替换。
3. 将lambda函数作为其他函数的返回值，返回给调用者。
4. 将lambda函数作为参数传递给其他函数。
###### 一个争议
* 关于lambda在Python社区是存在争议的
* 支持方认为使用lambda编写的代码更紧凑，更“pythonic”。
* 反对方认为，lambda函数能够支持的功能十分有限，其不支持多分支程序if...elif...else...和异常处理程序try ...except...。并且，lambda函数的功能被隐藏，对于编写代码之外的人员来说，理解lambda代码需要耗费一定的理解成本。他们认为，使用for循环等来替代lambda是一种更加直白的编码风格。
 
#### 内建函数
###### filter()
* filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。
* 该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
 
```
filter(function, iterable)
# function -- 判断函数。
# iterable -- 可迭代对象。
# 返回一个迭代器对象
```
```
def is_odd(n):
    return n % 2 == 1
tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
newlist = list(tmplist)
print(newlist)
# 结果为：[1, 3, 5, 7, 9]
```
 
###### map()
* map() 会根据提供的函数对指定序列做映射。
* 第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
 
```
map(function, iterable, ...)
# function -- 函数
# iterable -- 一个或多个序列
# Python 2.x 返回列表。
# Python 3.x 返回迭代器。
```
```
# 使用 lambda 匿名函数
map(lambda x: x ** 2, [1, 2, 3, 4, 5])  
# [1, 4, 9, 16, 25]
# 提供了两个列表，对相同位置的列表数据进行相加
map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
# [3, 7, 11, 15, 19]
```
###### reduce()
* reduce() 函数会对参数序列中元素进行累积。
* 函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。
* 在 Python3 中，reduce() 函数已经被从全局名字空间里移除了，它现在被放置在 functools 模块里，如果想要使用它，则需要通过引入 functools 模块来调用 reduce() 函数：
 
```
reduce(function, iterable[, initializer])
# function -- 函数，有两个参数
# iterable -- 可迭代对象
# initializer -- 可选，初始参数
```
```
from functools import reduce
def add(x,y):
    return x + y
print (reduce(add, range(1, 3)), 4)
# 10
```
###### zip()
* zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。
* 我们可以使用 list() 转换来输出列表。
* 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
 
```
zip([iterable, ...])
# iterabl -- 一个或多个迭代器;
# python3返回的是对象，python2返回的是列表
```
```
z = zip([1,2,3],[4,5,6])
print(list(z))
# [(1, 4), (2, 5), (3, 6)]
```
#### 闭包
* 形成闭包的条件
1. 必须要有一个内嵌函数
2. 内嵌函数中要对自由变量的引用
3. 外部函数必须返回内嵌函数
 
```
# a * x + b = y
def line(a,b):
    def arg_x(x):
        return a * x + b
    return arg_x
a_line = line(2,5)
print(a_line(1))
# 7
```
#### 装饰器
* 从字面上理解，就是装饰对象的器件。**可以在不修改原有代码的情况下，为被装饰的对象增加新的功能或者附加限制条件或者帮助输出。**装饰器有很多种，有函数的装饰器，也有类的装饰器。装饰器在很多语言中的名字也不尽相同，它体现的是设计模式中的装饰模式，强调的是开放封闭原则。装饰器的语法是将@装饰器名，放在被装饰对象上面。
 
```
import time
def timer(func):
    def wrapper():
        start_time  = time.time()
        func()
        stop_time  = time.time()
        print(stop_time-start_time)
    return wrapper
# 装饰器
@timer 
def i_can_sleep():
    time.sleep(2)
 
i_can_sleep()
```
#### 函数的基本概念
* 函数名：foo、outer、inner
* 函数体：函数的整个代码结构
* 返回值：return后面的表达式
* 函数的内存地址：id(foo)、id(outer)等
* 函数名加括号：对函数进行调用，如foo()、outer(foo)
* 函数名作为参数：outer(foo)中foo本身是一个函数，但作为参数传递给了outer函数
* 函数名加括号作为参数：先调用函数，再将它的返回值当做别的函数的参数，例如outer(foo())
* 返回函数名：return inner
* 返回函数名加括号：return inner()，其实就是先执行inner()函数，再将其返回值作为别的函数的返回值。
 
#### 上下文管理器
* 用于规定某个对象的使用范围。一旦进入或者离开该使用范围，会有特殊操作被调用 (比如为对象分配或者释放内存)。它的语法形式是with...as...
* 上下文管理器协议：是指类需要实现 __ enter __ 和 __ exit __ 方法。
* 就跟迭代器有迭代器协议一样，迭代器协议需要实现 __ iter __ 和 __ next __ 方法。
* 上下文管理器，也就是支持上下文管理协议的对象，简单点讲就是，实现了 __ enter __ 和 __ exit __两个方法的类。这个类也叫做，上下文管理器的类。
 
```
class Resource():
    def __enter__(self):
        print('===connect to resource===')
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        print('===close resource connection===')
        
    def operate(self):
        print('===in operation===')
        
with Resource() as res:
    res.operate()
 
输出：
===connect to resource===
===in operation===
===close resource connection===
```
 
#### 面向对象
* 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
* 方法：类中定义的函数。
* 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
* 数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
* 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
* 局部变量：定义在方法中的变量，只作用于当前实例的类。
* 实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
* 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
* 实例化：创建一个类的实例，类的具体对象。
* 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。
 
* 两个下划线“__”开头的属性和方法是私有的
* \_\_init__ 是 构造方法
 
###### 继承
* 子类继承父类的属性和方法，可以继承多个，当多个父类有相同方法时，默认从左向右取第一个父类的方法
 
```
class Test:
    def prt(self):
        print(1)
 
 
class Test2:
    def prt(self):
        print(2)
 
 
class Test3(Test, Test2):
    def __init__(self):
        print(3)
 
 
t = Test3()
t.prt()
 
# 3  1
```
 
#### 多线程
* 每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
* 每个线程都有他自己的一组CPU寄存器，称为线程的上下文，该上下文反映了线程上次运行该线程的CPU寄存器的状态。
* 指令指针和堆栈指针寄存器是线程上下文中两个最重要的寄存器，线程总是在进程得到上下文中运行的，这些地址都用于标志拥有线程的进程地址空间中的内存。
 
```
import threading
import time
from threading import current_thread
 
 
def my_thread(arg1, arg2):
    print(current_thread().getName(), "start")
    print("%s %s" % (arg1, arg2))
    time.sleep(2)
    print(current_thread().getName(), "stop")
 
 
for i in range(1,6,1):
    t1 = threading.Thread(target=my_thread, args=(i, i+1))
    t1.start()
 
 
print(current_thread().getName(), "end")
 
Thread-1 start
# 1 2
# Thread-2 start
# 2 3
# Thread-3 start
# 3 4
# Thread-4 start
# 4 5
# Thread-5 start
# MainThread end
# 5 6
# Thread-4 stop
# Thread-3 stop
# Thread-1 stop
# Thread-2 stop
# Thread-5 stop
```
 
#### 正则表达式
* 正则前面加上 r 表示规则不被转译
* re.compile() 设置匹配规则
* re.match()是从开头开始匹配，开头不符合直接返回None
* re.search()是匹配整个字符串，有一个符合的就返回，没有一个符合的返回None
* re.findall()是匹配整个字符串，返回所有符合的字符串组成的列表
* re.sub()是替换字符串
 
 
#### Python是如何进行内存管理的
1. 对象的引用计数机制
* Python内部使用引用计数，来保持追踪内存中的对象，所有对象都有引用计数。
引用计数增加的情况：
* 一个对象分配一个新名称
* 将其放入一个容器中（如列表、元组或字典）
引用计数减少的情况：
* 使用del语句对对象别名显示的销毁
* 引用超出作用域或被重新赋值
 
2. 垃圾回收
当一个对象的引用计数归零时，它将被垃圾收集机制处理掉。
 
3. 内存池机制
* Python提供了对内存的垃圾收集机制，但是它将不用的内存放到内存池而不是返回给操作系统:
* Pymalloc机制：为了加速Python的执行效率，Python引入了一个内存池机制，用于管理对小块内存的申请和释放。
* 对于Python对象，如整数，浮点数和List，都有其独立的私有内存池，对象间不共享他们的内存池。也就是说如果你分配又释放了大量的整数，用于缓存这些整数的内存就不能再分配给浮点数。
 
#### Numpy
* NumPy 数组存储在一个均匀连续的内存块中，不需要对内存地址进行查找；而列表 list 的元素在系统内存中是分散存储的，需要对内存地址进行查找。
* 在内存访问模式中，缓存会直接把字节块从 RAM 加载到 CPU 寄存器中。因为数据连续的存储在内存中，NumPy 直接利用现代 CPU 的矢量化指令计算，加载寄存器中的多个连续浮点数。 
* NumPy 中的矩阵计算可以采用多线程的方式，充分利用多核 CPU 计算资源，大大提升了计算效率。
* 提升内存和提高计算资源的利用率：避免采用隐式拷贝，而是采用就地操作的方式。