[python Cookbook]阅读笔记

Posted 2021-12-23 Jucway

文章目录

• • 更新迭代记录
  • 第二章 惰性匹配
  • • 2.1（. * ?）
    • 2.2字符串拼接
  • 第三章，数字，日期时间
  • • 3.1数据
    • • 3.11 浮点数取整（固定位数）
    • 3.2 浮点数计算存在误差
    • 3.3 二进制，十进制，八进行，十六进制
    • 3.4 复数
    • 3.5 随机数
    • 3.6 时间换算
  • 第四章 迭代器和生成器
  • • 4.1 访问元素
    • 4.2 多个迭代对象
    • 4.3 合并多个有序序列
  • 第五章 文件和IO
  • • 5.1 读写文本数据
    • 5.2 处理路径名
    • 5.3 将对象转为字节流
  • 第六章数据编码与处理
  • • 6.1 读写CSV数据
    • 6.2 读取JSON数据
    • 6.3 B64编码和解码
  • 第七章 函数
  • • 7.1 接受任意类型的函数
    • 7.2 函数返回多个值
    • 7.3 定义匿名函数或内联函数
  • 第八章类与对象
  • • 8.1 修改实例字符串表示
    • 8.2 对象支持上下文管理
  • 需要重新看的章节部分

前记：为了补充一下python语法知识，感谢网友的推荐阅读了pythonCookbook,这本书确实不错，以问题为导向，引导解决思路。
这个博文是从阅读笔记typora中直接复制过来的没有排版，仅作为记录！方便自己查询使用！书还没看完！持续更新！代码部分是直接使用IDLE运行的；

更新迭代记录

操作	时间	备注
阅读前八章	2021/11/27 23:04:12	Jucw

第二章 惰性匹配

2.1（. * ?）

1. . 匹配任意除换行符外
2. *匹配前一个字符出现0次或者无限次
3. ？匹配前边字符的0次或者1次重复
4. +或者*后面跟着？表示匹配0次或者1次出现，为非贪婪匹配，匹配最短

---

2.2字符串拼接

1. 对于可迭代容器中的每个元素是字符串时候，使用join 进行字符串拼接

   parts = ['my', 'is', 'a', 'handsome', 'boy']
   t = ' '.join(parts)
   print(t)
   # 'my is a handsome boy'
   
   

   针对列表，元组，字典，文件，集合，生成器

   针对简单的直接拼接的时候，使用 + 进行拼接 ；

   +可以连接多个字符，之后拼接成完整的字符串

---

2. 打印的时候使用字符进行分割

   a = 0
   b = 2
   c = 5
   print(a,b,c,sep=':') # 使用这种方法更好
   print(':'.join(a,b,c))
   

3. 格式化文本

   # 
   import textwrap
   text = ""
   print(textwrap.fill(text,40,initial_indent='')) # 每40个为一行，最后使用空字符结尾
   
   

---

4. 在字节串执行

   能在文本字符串上执行的操作都能在字节字符串上进行

   Byte String

   打印的时候将字节字符串转化为ascii码进行打印，这个时候就跟文本字符串一样

   print(bString.decode(‘ascii’))

---

第三章，数字，日期时间

3.1数据

3.11 浮点数取整（固定位数）

round(num, n) 进行四舍五入到指定小数点后面几位

执行之后的id 是不一样的，也就是在内存的位置是不一样的

1852106442928

id ©
1852106442928
id (d)
1852106441840
c==d
True
id ©==id(d)
False

当处于中间数的时候，取值是最接近的偶数

1.5=2 2.5=2

round(1.5)
2
round(2.5)
2

---

3.2 浮点数计算存在误差

这是CPU计算浮点数的特性

from decimal import Decimal

将浮点数转为字符串进行计算

---

3.3 二进制，十进制，八进行，十六进制

将一个整数转为二进制，八进制，十六进制

bin()

oct()

hex()

这一种转化会出现前缀，可以使用切片进行处理
如果使用不想出现前缀使用

format(a, ‘b’) # 二进制

format(a, ‘o’) # 八进制

format(a, ‘x’) # 十六进制

将字符串的形式不同进制转换为整数，需要使用 int 同时指定 当前字符串所代表的进制类型就可以转为整数

int(‘4b2’,16)

int(‘010101’,2)

---

3.4 复数

a.real

a.imag

a.conjugate()

对复数进行运算

import cmath

cmath.sin()

cmath.cos()

cmath.exp()

Python 的标准库默认是不会产生复数值，所以计算复数的时候使用cmath 或者 numpy 是可以对复数进型运算的

import cmath
a = 1-2j
a.real
1.0

a.imag
-2.0
a.conjugate()
(1+2j)
cmath.sin(a)

---

3.5 随机数

random 使用马特赛特旋转算法（梅森旋转算法）来计算随机数，这是一个确定性的算法。通过random.seed() 来修改 初始的种子值；

1. 随机数选择

   import random

   random.choice() # 随机选择一个数

2. 随机数生成

   随机采样n个数

   random.sample(a, N)

3. 对元素进行原地打乱

---

3.6 时间换算

天数转为秒，小时转为分钟

datatime 可以实现不同的时间单位的换算

datadelta表示时间间隔

now = datatime.datatime

datatime.timedelta(days = 2, minutes = 20, seconds = 10) # 都要加上s 来表示时间单位，然后可以往前推导出时间

计算上周五的日期

上周五是几月几号

from datetime import datetime, timedelta
weeksday = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']

---

第四章 迭代器和生成器

4.1 访问元素

next() 进行迭代

items._iter_()

生成器只会在响应迭代操作时候才会运行

一旦生成器函数返回，迭代也就停止，如果执行for 语句的时候这些是不需要进行考虑的；

---

定义一个反向迭代

def __reversed__(self):
   n = 1
   while n < self.start:
        yield n
        n = n + 1

​ 迭代器和生成器是没法执行普通的切片操作

使用itertools.islice() 返回一个生成器，这是通过访问生成器然后丢弃掉开始索引之前的元素来实现切片操作

这里会消耗掉前面丢弃的数据，因为生成器是没法倒回去的，如果需要倒回去需要将生成器转为列表之后再进行操作

import itertools

跳过文件的注释行

from itertools import dropwhile

with open(“”) as f:
	for line in dropwhile(lambda line: line.startswith('#'), f)
    print(line, end=' ')
    

排列组合

iterations.permutations # 排列 考虑顺序

iterations.combinations # 组合 a, b 和 b, a 是一样的只会出现一次，不考虑顺序

iterations.combinations_with_replacement # 选择过之后的数字仍然可以在一次选择， a, a, a 相当于有放回的选择小球

迭代一个序列保存序列的下标

a = [1, 2, 3, 4, 5]
for idx, val in enumerate(a):
print(idx, val)

0 1
1 2
2 3
3 4
4 5

索引下标是从0开始的

同时迭代多个序列使用 zip

a = []

b = []

for x,y in zip(a,b):

​ 同时迭代a and b 这两个序列

​ print （x, y）

zip 的工作原理是创建出一个迭代器，该迭代器可以产生元组，（x ,y） 当其中某个序列没有元素可以进行迭代的时候，迭代过程结束；

如果要匹配最长迭代对象

import iterations.zip_longest

这个时候产生的是最长迭代队列，短的序列使用None来替代

zip 返回的是一个迭代器，必要时候需要将其转换为列表；

---

4.2 多个迭代对象

处理多个迭代对象，返回一个迭代器

1. 包

   from iterations import chain

   from iterations import chain 
   a = [1, 1, 2]
   b = ['i', 'love', 'you']
   for i in chainm(a,b):
       print(i, end=' ')
       
   1 1 2 i love you
   

set = iteration()

inactive_items = set()

---

4.3 合并多个有序序列

1. 包

   import heapq

import  heapq
a = [1,5,2]
d = [4,5,6]
b = [1,2,3]
for c in heapq.merge(a,b):
    print(c, end=' ')

print(end='\\n')
for e in heapq.merge(d,b):
    print(e, end=' ')
    
1 1 2 3 5 2 
1 2 3 4 5 6 

如果序列不是有序的，合并之后还是不会对序列进行排序，这个使用对进行合并不会一次性进行读取，而是在合并过程中边读取边比较

主要是用在将两个有序的序列进行合并之后保证序列还是有序的

只是简单的检查每个序列的第一个元素，比较之后将第一个元素较小的发送出去，之后再从新的序列读取下一个元素，重复操作直到元素读取结束

---

第五章 文件和IO

5.1 读写文本数据

换行符： \\r\\n 和 \\n 这是 UNIX 和 Window 之间的区别

输出进行重定向 也就是将读取的内容重新写入到新的文件中，

with open(“…txt”, ‘’wt’) as f:

使用 print(“text”, file = f) # 只要是确保文件是使用文本格式打开的就行，如果是使用二进制打开可能会打印失败！

以不同的分割符打印数据

print(, seq = ‘;’, end=‘!!\\n’) # 读取的内容使用; 进行分割，最后结尾部分使用!!还有换行进行输出

检查文件是否已经存在

import os
if not os.path.exists(''):
    with open ('', '') as f: ##使用xb 模式进行打开就不用判读， 将会直接进行覆盖
        f.read()
    else:
        print("File is exitst!!")

5.2 处理路径名

os.path.basename() # 获取最后的文件名称

os.path.dirname() #获取路径名

os.path.join(‘’，‘’，os.path.basename(path)) # 将多个字符串组装成新的路径

5.3 将对象转为字节流

import pickle

data = …

with open(‘’, ‘’) as f:

pickle.dump(data, f)

在字节流中重新创建出对象

pickle.load() 这是在文件传输过程中需要进行序列化的一种方式。这样比较高效的进行文件传输；

---

第六章数据编码与处理

6.1 读写CSV数据

写入数据到csv文件中

head = []

rows = [(),()]

with open(‘’, ‘’) as f:

f_csv = csv.writer(f):

f_csv.writerow(head)

f_csv.write
rows(rows)

---

数据是字典，也就是使用列表存储字典，之后将字典的对应的值映射到表格中

headers = []

rows = []

with open() as f:

f_csv = csv.DictWriter(f, headers) # 将表头和文件进行建立联系

f_csv.writeheader() # 先将表头写入到表格中

f_csv.writerows(rows) # 将每行对应数据写入到表格中

---

6.2 读取JSON数据

json.dumps()

json.loads()

数据是字典的格式

使用json.dumps(data)

将数据dumps 到 json 文件中去

读取json文件

读取的网页信息使用功pprint 进行打印，可以更好的展示结果

这个过程使用的是json 会将信息以字典或者列表的形式进行存储

---

6.3 B64编码和解码

import base64.b64encode()

import base64.B64decode()

面向字节的编码

字节串和字节数组

编码之后输出字节串 之后可以转换为decode(‘ascii’)

---

第七章 函数

7.1 接受任意类型的函数

def avg(fist, *rest):
    return (first + sum(rest))/(1+len(rest))
# rest 可以是多个数据

>>> def avg(first, *rest):
	return (first + sum(rest))/(1+len(rest))

>>> c = avg(1,2,3,4,5,6)
>>> c
3.5 = 21/6

rest 作为一个元组传来，代码将其作为一个序列进行处理

*rest 和 ** kwargs
前者传递位置参数（元组）
后者是传递关键字参数（字典）
size = 'large', quantity = 6 # 这里是传递一个字典
(1, 2, 3) # 这里是传递一个位置参数，这是一个元组

注意： * 打头的只能作为最后一个位置参数出现，以 ** 打头的只能作为最后一个参数出现

也就是说以 * 打头之后的参数只能是关键字参数

---

7.2 函数返回多个值

只要简单的返回一个元组，就可以实现函数返回多个值

---

7.3 定义匿名函数或内联函数

add = lambda x, y: x+y # 将x, y 直接连接起来

>>> x = 10
>>> b = lambda y:x+y
>>> x = 20
>>> c = lambda y:x+y
>>> b()10
SyntaxError: invalid syntax
>>> b(10) # 这里执行的时候x是20
30
>>> c(10) # 这里执行的时候x也是20
30

lambda 中的变量是在执行的是后进行绑定，也就是说执行是变量时多少就是多少，而不是定义的时候的值

---

第八章类与对象

8.1 修改实例字符串表示

通过定义_repr_()

_str_()方法实现

_repr_()返回的是实例的代码表示，通常可以用他返回的字符串文本来重新创建这个实例，内建的repr()函数可以用来返回这个字符串，_str_()将实例转为字符串，这就是使用print() 和 str() 这两个方法产生的效果，

p = Pair(3,4) # _repr_() output 输出的时候使用!r 表示使用特殊的格式化代码输出

print§ # _str_()

8.2 对象支持上下文管理

with 要实现_enter_() and _exit_()函数

如果_enter_()有返回值的话，被放置在使用as作为限定下

---

需要重新看的章节部分

2.19这一章还没看

5.19/5.20这一章需要重新看

6.12 Struct 复习

---

time: 2021-11-27