python学习笔记

python===### 地址1. mac 下python 2.7的地址 /Library/Python/2.7/3.6/Library/Frameworks/Python.framework/Versions/3.6/- 避免循环导入依赖的方法依赖放在最后面------# 正则表达式+表示至少一个字符{n}表示n个字符 *表示任意个字符?表示0个或一个字符.可以匹配任何字符\w匹配字母\d匹配数字\s匹配一个空格r代表正则表达式^表示行的开头，$表示行的结束\d$必须以数字结束\w$必须以字母结束多加一个\代表转义字符'ABC\\-001'匹配:abc\001\d{3} 可以匹配:010, 230,123\s+ 表示至少一个空格\s{4}表示至少4个空格\d{3,8} 表示3到8个数字\d{3}\s+\d{3,8}\d{3} 三个数字，\s匹配一个空格 \d{3-8}3-8个数字## 进阶 [0-9a-zA-Z\_] 匹配一个数字，一个字母，或者下划线[0-9a-zA-Z\_]+ 匹配至少由一个数字字母或者下划线组成的字符串[a-zA-Z\_][0-9a-zA-Z\_]匹配由字母或者下划线开头，后接任意个由一个数字，字母，下划线组成的字符串### 方法- match 表示是否匹配，如果匹配返回match对象，否则返回None- split() 方法用于切割 'ab c'.split(' ')- ###### finditer : 返回string中所有与pattern相匹配的全部字串，返回形式为迭代器。 ### 提取子字符串sd=re.match(r'^(\d{3})-(\d{6})','021-2345678')### 输出第几组函数print(sd.group(1))输出第一组函数### 替换字符串re.subpath = re.sub('[_]', '/', url1)将_全部替换为/### |是或的意思，匹配到两个的任何一个都行sd=re.compile('| {7}')## 预编译正则表达式每次使用都要编译所以先预编译一下### 两个字符串或匹配sd=re.compile('/places/default/(index|view)/.*?[\d]$')#### 正则Demo```find_id = re.compile('\w{0,5}-\w{0,5}-\w{0,7}-\d{0,3}')str='fan-jia-liang-57'```## numpy函数: 1.shape函数：计算数组大小 2.mat函数将目标数据转换为矩阵 3.zero 函数将数组初始化为0 4.numpy.array将list转换为numpy的数组 5.random ranint 取随机数 6.去掉字符串最后的换行符:line=line[:-1] 7.numpy比较两个array是否全部相同， if(arry1==array2).all() print(true)### python读取文件的三种方法：- f = open("foo.txt") # 返回一个文件对象 line = f. adline() # 调用文件的 readline()方法 while line: print line, # 后面跟 ',' 将忽略换行符 #####print(line, end = '')　　　# 在 Python 3中使用 line = f.readline() f.close()- for line in open("foo.txt"): print line,- f = open("c:\\1.txt","r") lines = f.readlines()#读取全部内容 for line in lines print line python 往txt写内容： with open('a.txt','w') as f: for i in a: f.write(i) ### python 字符乱码问题 ### 字符串编码encoding 将str转换为机器码decoding 将机器码转换为str#### plt 乱码- 在/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages下- 在py中加 plt.rcParams['font.sans-serif']=['SimHei']将simhei字体下载放在pyplot中即可解决乱码#### requests乱码# list- list.index()求元素的下标- str list和 int list 互相转换 nums=[int (i) for i in nums]- s = re.findall("\d+",nums)找出字符串中所有数字- list1 = ["这", "是", "一个", "测试"] for index, content in enumerate(list1): print (index) print (content)- 元组转List tuple =list(tuple)- list 去除重复元素 list=set(list)- 查找元素 a.index(s) 查找s元素的下标位置- 逆序输出list reversed(a)- list的复制 ``` import copy a=[123,234,677] b=a[:] print(b) c=copy.deepcopy(a) print(c) ```### tuple1. 对于不可变类型，不管是深拷贝还是浅拷贝，都只是创建一个引用2. 元组为不可变类型3. 对于str类型，如果两个str相同，那么是is和=的，这是python的优化方法,善意的谎言。。。4. 在小的整数上也会采取这种措施停留interning5. ### dict#### 散列方法获得dict[key]的值，首先调用hash(key)来计算key的散列值，把这个值的低几位数字作为偏移量，在散列表中查找表元，如果表元是空的，就抛出异常。如果不为空，则检查key是否等于found_key如果相等则返回结果。如果不相等，发生散列冲突，发生的原因:在寻找元素值时，如果发生了冲突，算法会在散列值中另外取几位。然后将新得到的数字当做索引来寻找表元。如果找到的为空，抛出keyerror，如果冲突，重复刚才步骤#### 带来的后果##### dict 的key值必须是可散列的, 也就是说是固定不变的，str,bytes 还有数字类型##### 消耗的空间比较大##### 键值的查询很快键值的次序取决于添加顺序对于不存在的dict 会抛出keyerror,解决方法:重写missing方法- 字典sd，设置元素sd[i]=i,得到元素 sd.getvalue(i)- 储存 like_dict['a']=we- 得到dict类型的key和value print(dict.keys()) print(dict.values())- 遍历字典 for (k,v) in dict.items() 1. #### list 和tuple 的相同点和不同点 - list和tuple 可以相互转换，list可变,tuple不可变 - tuple比list更快更安全 - tuple是可以hash的，list不行 2. dict的内部实现，算法的实现 tuple 和list作为dict 的key值有什么问题: 3. python的多进程，协程实现和多线程 GIL全局锁 #### 查看dict 是否有某个key值 dict.get(key)- 字典的复制 dict.copy()- python字符串反转 str[::-1]- extends 函数a=[1,2,3,4]b=[1,2,3,4,5]a.extend(b for i in b not in a)a=[1,2,3,4,1,2,3,4,5]### 字典20.判断一个属性是否在字典中 print d.has_key('site') if 'sa' in dic.keys(): 应该用后面的,python3不能用前面的了?21: if value[i].get(each[i]) == None: value[i][each[i]] = 1 else: value[i][each[i]] += 122.import sys 　　sys.version 　import django 　django.VERSION 查看各种安装包的版本23.启动ipython python3 -m IPython notebook-----------# python 的魔法函数## list__set__item(): __get__item():__ len __ 求元素的长度__delete_item()通过类似于list的用法，实现修改和插入。通过对方法的重写，方便## function__repr ___ 将对象用字符串表示出来，如果没实现，输出类似于__str __是在调用 str()函数时，或者print 时才会使用

__doc__在方法中''' ''' 写的注释可以得到

__call__ 调用函数的对象时默认执行的方法，可以重写

### 下划线

单下划线，私有变量不能通过导入来调用

双下划线，受保护变量子类也不能调用

前后下划线: 系统定义的名字

## 函数式编程

map(func,rang(2)) 将func函数的返回值写入list,然后将list返回

print reduce(lambda x, y: x * y, range(1, 5)) 将1,2传入然后计算出结果，x=2,y=3,然后将结果给x,再找一个数给

---------------

### pickle

1.pickle存中文字符

pickle.dump(json.dumps(data,ensure_ascii=False),output)

2. pickle 写文件时必须指定文件名

# I/O操作

#### 按行读取

```import csv

with open('A.csv','rb') as csvfile:

reader = csv.reader(csvfile)

rows = [row for row in reader] print rows

```

#### 一次读取为str

with open('html.txt','r') as opener:

html=opener.read()

#### 按行读取，忽略首行元素

headers=next(reader)

## 追加写入csv文件

with open("filename.csv","a+") as csvfile:

rU 或 Ua 以读方式打开, 同时提供通用换行符支持 (PEP 278)

a+表示追加写入

w 以写方式打开，

a 以追加模式打开 (从 EOF 开始, 必要时创建新文件)

r+ 以读写模式打开

w+ 以读写模式打s开 (参见 w )

a+ 以读写模式打开 (参见 a )

rb 以二进制读模式打开

wb 以二进制写模式打开 (参见 w )

ab 以二进制追加模式打开 (参见 a )

rb+ 以二进制读写模式打开 (参见 r+ )

wb+ 以二进制读写模式打开 (参见 w+ )

ab+ 以二进制读写模式打开 (参见 a+ )

## csv

将list写入csv文件

writer=csv.writer(open('ip_message.csv','w'))

### 按行写入

writer.writerow(fields)

for i in result:

writer.writerow((i,result[i]))

#### 将dict 写入csv文件

```

with open('dict.csv', 'wb') as csv_file:

writer = csv.writer(csv_file)

for key, value in mydict.items():

writer.writerow([key, value])

```

#### 将tuple 写入csv

```

def write_in_csv(tuple):

with open('message.csv', 'a')as opener:

writers=csv.writer(opener)

writers.writerow(tuple)

```

## 文件目录和文件读写

```

print(__file__)

print(os.path.abspath(__file__))

上面文件目录

path=os.path.abspath(os.path.dirname(__file__))

image_path=os.path.join(path,'dataset')

# 将目录下文件名转换为List

file=os.listdir(image_path)

```

# yeild

## 回调函数

将一个函数以参数形式传到另一个函数中

--------

# 输出

## 输出格式

print ('a%sb%s'%(a,b))

### format

print('好的代理:{}'.format(each))

#### 多个format

print("sd{1}{0}".format(b,a))

----------https://www.baidu.com/s?wd=14.118.254.90

将变量放在字符串中输出

```

cc=China

url='{}/{cc}/{cc}.gif'.format(BASE_URL,cc=cc.lower())

http://flupy.org/data/flags/china/china.gif

```

## 不换行输出

pyhton2:

## 编码

中文无法显示的话

i.decode(encoding='utf-8')

--------

# Exception

## raise

类似于java 中的throw 可以根据情况自己抛出异常

if response.code==200:

raise RuntimeError("wwe")

except RuntimeError as e:

print(e.args)

ValueError 数据转换异常

IndexError 数组下标异常

在异常中加的参数作为args参数

### 自定义异常类

class OutboundsError(Exception):

def __init__(self,errormsg):

self.errormsg=errormsg

def __str__(self):

print("调用了这里")

return self.errormsg

当打印对象时会调用 __ str__ 方法

### except

多个异常:

(KeyError,FilenotFoundError) as e:

## 配置logging

首先new一个handler

RotatingFileHandler

然后添加到app.logger

------

# 日期和日历

## datetime

```

a = datetime(2012, 9, 23)

```

from datetime import datetime

获得过几天的日期

yesterday = today - datetime.timedelta(days=1) #用今天日期减掉时间差，参数为1天，获得昨天的日期

tomorrow = today + datetime.timedelta(days=1) #用今天日期加上时间差，参数为1天，获得明天的日期

print(afterday.year)

print(afterday.month)

print(afterday.day)

------

# 神奇的函数

### lambda 表达式的学习

a=[1,2,3,4]

g=lambda x:x**2

for each in a:

print(g(each))

pydoc3 -p:5000 在5000端口查看消息

##### 根据字母表获得所有字母

a=[chr(i) for i in rang(97,123)]

ord(a)=97

#### sys.argv[1]

#### 在console导入路径或者py文件

import sys

sys.path.append("/path/to/your/test.py")

### 迭代器

```

a=iter(a)

print(next(a))

```

next函数，返回迭代器的下一个对象

## 并发

并发是指一次处理多件事。

并行是指一次做多件事。

二者不同，但是有联系。

一个关于结构，一个关于执行。

并发用于制定方案，用来解决可能（但未必）并行的问题。

### yield

### 协程

```

def simple_coroutine():

print('corroutine is start')

x=yield

print('corrountine reeived',x)

mycoro=simple_coroutine()

print mycoro

next(mycoro)

#向yield发送一个值，输出x为23

mycoro.send(23)

```

###### 先要调用next函数,作为预激协程的指令，让协程跳转到第一个yield表达式产出变量的初始值None

next函数可以包装为装饰器

```

def start(func):

def star(*args,**kwargs):

sd=func(*args,**kwargs)

next(sd)

return sd

return star

```

个人体会:通过send语句将值传递给yield对象

执行下一个yield让协程进入下一个状态

当执行完后，协程为yield状态

python3 查看生成器状态:

##### from inspect import getgeneratorstate

协程来处理异常类:

如果传入的异常无法处理，协程就会终止

协程的四个状态:

gen_created: 等待开始执行 (只有在多线程应用中才能看到)

gen_running:解释器正在执行

gen_suspended:在yield表达式处暂停

gen_closed 执行结束

类似于return 的关键字，返回的类型为生成器

不过不会直接退出函数

而是等到循环结束，返回一个list

#### yield from

可以简化yield语法

### GIL

global interpreter lock 全局解释锁

一次只能有一个线程在运行

gIL对io密集型任务的影响很小

Python 标准库中的所有阻塞型 I/O 函数都会释放 GIL，允许其他线程运

行。time.sleep() 函数也会释放 GIL。因此，尽管有 GIL，Python 线程还是能在 I/O

密集型应用中发挥作用

当某个线程在等待I/O时，python调度程序会切换到另一个线程

ProcessPool 使用了多进程来绕开多线程

### cpu密集

ProcessPoolExecutor 多进程的多少个核就有多少个进程

multiprocessing 绕开GIL

python-parallelize库

定义一个python-parallelize 装饰器，可以应用到任何函数上

生成器: 类似于链表推导，

只不过只会放入内存一次

也就是说只能输出一次,用完就没了

#### *args,**kwargs

*args是tuple

**kwrgs是dict

def play(*args,**kwargs):

print(args)

print(kwargs)

(2, 3)

{'age': 3, 'name': 2}

play(2,3,name=2,age=3)

#### filter 函数

过滤函数?

- a=range(10)

print(filter(lambda x:x>3,a))

#### random

values=[1,2,3,4]

- random.choice

random.choice(values)

从List中随机选择元素

- 提取出n个不同的样本

random.sample(values,2)

- random 打乱顺序

random.shuffle(values)

- 生产随机整数

random.randint(0,10)

- 生成0-1 范围内均匀分布的浮点数

random.random()

- 生成n位随机二进制整数

random.getrandbits(200)

### 运算符

& 按位运算符取交集

| 按位运算符取并集

^ 当二进制位不相等时，取1

~ 按位取反

<< 左移运算符高位丢弃，低位补0

>> 右移，低位丢弃，高位补0

### 生成器

节省内存

```

pos = (n for n in mylist if n > 0)

for each in pos:

print each

```

- 列表推导

b=[for each in b if b>0] //占用内存比较多

- 求list中最大的元素

print(max(mylist))

- chr(97)-> a 输入数字，输出字母

- join 函数， b.join(a) b加入a中每个b加入到a的每个元素中

a="sbv" b="-" c=b.join(a)

print(c)

- xrange返回的为xrange类型，本质为生成器，性能不会放入内存

### input

input 会自动判断类型

raw_input不会

input 输入不能有空格

raw_ input可以

还是raw_input合适点

### id

查看变量地址空间

##### isinstance和type的区别

isinstance 是广义上的判断，可以根据父类来判断

----

# 面向对象

## 继承

## 构造方法的初始化

```

class A:

def spam(self):

print('A.spam')

class B(A):

def spam(self):

print('B.spam')

super().spam() # Call parent spam()

```

----

## 抽象类

## 装饰器

装饰器是可调用对象，其参数是另一个函数

不改变函数的前提下，增强函数的功能

在导入时执行调用

1. @property

将方法变为属性

本质是为了增加原的功能。

将原函数作为参数传到另一个函数中

相当于方法套了一层方法。

def identify(f):

print(f())

return ()

def foo():

return 'bar'

identify(foo)

上面等价于:

def identify(f):

print(f())

@identify

def foo():

return "sd"

闭包;

## 一些坑

- a//2 还是int 类型 a/=2 就是float类型

-----

## pip

- pip list --outdate

列出所有可以升级的软件

- pip install --upgrade requests

升级一个包

- 升级所有可用的包

for i in `pip list -o --format legacy|awk '{print $1}'` ; do pip install --upgrade $i; done

# OS

__ file __ 属性为当前py文件的路径

execv(file,args)

execv()执行一个新的程序，用新的程序代替子进程的空间

### 面试问题

1. 深拷贝和浅拷贝的区别深拷贝和浅拷贝复制一个对象，然后把之前的对象删掉，引用技术应该怎么变

2. 对一个对象进行如何操作才能使他的引用计数增加或者减少

3. python垃圾回收机制

4. 复制一个list的方法

5. python内部list和tuple的实现的数据结构数组

6. 数据库索引，b树和b+树的实现和区别，为什么不用红黑树

7. ping的端口号基于什么协议的

基于iCMP协议，没有端口号控制报文协议

8. python _ _init_ _方法和_ _ _new_ _的区别

new: 创造对象是调用，会返回当前对象的一个实例

init: 创造完对象后调用，无返回值

同时存在，会优先调用new方法

new_是静态方法,init是实例方法

9. python的闭包函数变量在闭包中调用的次序

10. 每行大小为16个字节，总共1G大小的文件，限制内存1MB,找出频率出现次数最多的单词

解决方法: 1mb内存可以处理 2^16次方个单词，首先进行切分为100个文件，然后

11. 如何从一个很长的字符串来找一个子字符串 KMP算法

哪些是可变类型

哪些是不可变类型

深拷贝和浅拷贝的区别

装饰器的特点

装饰器有哪些优点

1. 便于开发

2. 便于代码复用

## python语言内部

#### 内存管理

1. 引用计数

将一个对象放入列表中，引用增加

分配一个新的名称，引用增加

引用计数减少: 显式的销毁

sys.getrefcount( )函数可以获得对象的当前引用计数

2. 垃圾回收

当引用计数清零时，垃圾回收机制

3. == 和is 的区别

==比较对象的数据，is比较对象的标识(id)

4. copy和deepcopy

copy了后，内部对象的引用还没有变，仅仅是复制了表面

deepcopy是递归复制，完全是两个不同的对象

5. numpy就是一个很好地例子，它的运行速度真的非常快，因为很多算术运算其实并不是通过Python实现的。

6. 答：“猴子补丁”就是指，在函数或对象已经定义之后，再去改变它们的行为。

7. 偶尔也会出现引用循环（reference cycle）。垃圾回收器会定时寻找这个循环，并将其回收。举个例子，假设有两个对象o1和o2，而且符合o1.x == o2和o2.x == o1这两个条件。如果o1和o2没有其他代码引用，那么它们就不应该继续存在。但它们的引用计数都是1。

8. 答：print的输出是标准输出，可以指向任何可以输出的流，包括http输出

9. 闭包: 外部函数的返回值必须是内嵌函数，可以通过外部函数的返回值来继续调用内嵌函数，推迟函数的

鸭子类型:

走起路来像鸭子，只关心行为

又比如list.extend()方法中,我们并不关心它的参数是不是list,只要它是可迭代的,所以它的参数可以是list/tuple/dict/字符串/生成器等.