python

数据类型

可变数据类型：列表list[ ]、字典dict{ }

不可变数据类型：整型int、字符串str’ '、元组tuple（）

闭包

  1. 如果在一个函数的内部定义了另一个函数，外部的我们叫他外函数，内部的我们叫他内函数。
  2. 在一个外函数中定义了一个内函数，内函数里运用了外函数的临时变量，并且外函数的返回值是内函数的引用。这样就构成了一个闭包。
  3. 一般情况下，如果一个函数结束，函数的内部所有东西都会释放掉，还给内存，局部变量都会消失。但是闭包是一种特殊情况，如果外函数在结束的时候发现有自己的临时变量将来会在内部函数中用到，就把这个临时变量绑定给了内部函数，然后自己再结束。
def adder(x):
    def wrapper(y):
        return x + y
    return wrapper
adder5 = adder(5)
print(adder5(adder5(6)))
因为wrapper是闭包 所以adder5返回的是wrapper函数 接下来adder5(6) 返回的是11=5+6 同理 再调用一次就是16 = 11+5

复数

1.表示复数的语法是real + image j

2.实部和虚部都是浮点数

3.虚部的后缀可以是 “j” 或者 “J”

4.复数的 conjugate 方法可以返回该复数的共轭复数。

字符串格式化语法

python里面%d表数字，%s表示字符串，%%表示一个%；
单引号内嵌套单引号需要转义字符 ;单引号内嵌套双引号不需要转义字符；
双引号内嵌套双引号需要转义字符\；双引号内引用单引号不需要转义字符

filter函数

filter(function, iterable)
filter函数是python中的高阶函数, 第一个参数是一个筛选函数, 第二个参数是一个可迭代对象, 返回的是一个生成器类型, 可以通过next获取值. 这里大致讲述下原理,
filter()把传入的function依次作用于iterable的每个元素, 满足条件的返回true, 不满足条件的返回false, 通过true还是false决定将该元素丢弃还是保留.

func = lambda x:x%2
result = filter(func, [1, 2, 3, 4, 5])
print(list(result))
#[1,3,5]
所以对2和4取余为0舍弃1.3.5取余为1为真保留；

python内存管理

Python 是弱类型脚本语言，变量就是变量，没有特定类型，因此不需要声明。
但每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
用 del 语句可以释放已创建的变量（已占用的资源）

1.变量无需事先声明
2.变量无需指定类型
3.程序员不用关心内存管理
4.变量名会被“回收”
5.del语句能够直接释放资源
6.变量只有被创建和赋值后才能被使用

复制，深拷贝，浅拷贝

import copy
a = [1, 2, 3, 4, ['a', 'b']]
b = a
c = copy.copy(a)
d = copy.deepcopy(a)
a.append(5)
a[4].append('c')
总结：
# a=[1, 2, 3, 4, ['a', 'b','c'],5] 
b=[1, 2, 3, 4, ['a', 'b','c'],5] 
c=[1, 2, 3, 4, ['a', 'b','c']] 
d=[1, 2, 3, 4, ['a', 'b']] 
b=a,只是换了一个名字，a怎么变b就怎么变，
c是浅复制，若父对象发生变化，c不会变化，因为它已经复制了所有父对象，假如子对象发生变化则c会变
d是深复制，完全复制了a的所有值，已经完全与a无关，对a的任何操作都不会影响d
---------------------------------------------------
1.对象的赋值 
都是进行对象引用（内存地址）传递，即‘’ b is a‘’ ，a 变 b 也变
2.浅拷贝
会创建一个新的对象,即 “c is not a” ，但是，对于对象中的元素，浅拷贝就只会使用原始元素的引用（内存地址），也就是说”c[i] is a[i]”
当我们使用下面的操作的时候，会产生浅拷贝的效果：

使用切片[:]操作
使用工厂函数（如list/dir/set）
使用copy模块中的copy()函数
3.深拷贝 
会创建一个新的对象，即”d is not a” ，并且 对于对象中的元素，深拷贝都会重新生成一份（有特殊情况，下面会说明），而不是简单的使用原始元素的引用（内存地址）
拷贝的特殊情况

其实，对于拷贝有一些特殊情况：

对于非容器类型（如数字、字符串、和其他’原子’类型的对象）没有拷贝这一说
如果元祖变量只包含原子类型对象，则不能深拷贝

对象池

python中对于小整数对象有一个小整数对象池，范围在[-5,257）之间。
对于在这个范围内的整数，不会新建对象，直接从小整数对象池中取就行。

py2和py3

import math
print math.floor(5.5)
Python3中答案是5，向下取整，结果为整型，Python2中答案是5.0
print type(1/2)
Python2 中除法默认向下取整，因此 1/2 = 0，为整型
而 Python3 中的除法为正常除法，会保留小数位，因此 1/2 = 0.5，为浮点型

正则表达式

import re
str1 = “Python’s features”
str2 = re.match( r’(.)on(.?) .*’, str1, re.M|re.I)print str2.group(1)

re模块实现正则的功能
re.match(正则表达式,要匹配的字符串，[匹配模式])

要匹配的字符串为str1 = “Python’s features”

正则表达式r’(.*)on(.*?) .*’
r表示后面的字符串是一个普通字符串（比如\n会译为\和n，而不是换行符）
()符号包住的数据为要提取的数据，通常与.group()函数连用。
.匹配单个任意字符
*匹配前一个字符出现0次或无限次
?匹配前一个字符出现0次或1次
(.*)提取的数据为str1字符串中on左边的所有字符，即Pyth
(.*?)提取的数据为str1中on右边，空格前面，即’s

.group(0)输出的是匹配正则表达式整体结果
.group(1) 列出第一个括号匹配部分，.group(2) 列出第二个括号匹配部分

多个标志可以通过按位 OR(|) 来指定
re.M：多行匹配，影响 ^ 和 $
re.I：使匹配对大小写不敏感
分组：即用圆括号将要提取的数据包住，通过 .group（）获取，一般和“|”结合使用
re.match( r’(.*)on(.*?) .*’, str1, re.M|re.I)，将on左边和右边分组

>>print(str2.group(0))
Python's features
>>print(str2.group(1))
Pyth
>>print(str2.group(2))
's

解释性语言和编译型语言

解释性语言和编译性语言的定义：
计算机不能直接理解高级语言，只能直接理解机器语言，所以必须要把高级语言翻译成机器语言，计算机才能执行高级语言编写的程序。
翻译的方式有两种，一个是编译，一个是解释。两种方式只是翻译的时间不同。

解释性语言的定义：
解释性语言的程序不需要编译，在运行程序的时候才翻译，每个语句都是执行的时候才翻译。这样解释性语言每执行一次就需要逐行翻译一次，效率比较低。
现代解释性语言通常把源程序编译成中间代码，然后用解释器把中间代码一条条翻译成目标机器代码，一条条执行。

编译性语言的定义：
编译性语言写的程序在被执行之前，需要一个专门的编译过程，把程序编译成为机器语言的文件，比如exe文件，以后要运行的话就不用重新翻译了，直接使用编译的结果就行了（exe文件），因为翻译只做了一次，运行时不需要翻译，所以编译型语言的程序执行效率高。