Python基础（杂）

1.深浅拷贝

• 浅copy与deepcopy（What）
  • 浅copy： 不管多么复杂的数据结构，浅拷贝都只会copy一层
  • deepcopy : 深拷贝会完全复制原变量相关的所有数据，在内存中生成一套完全一样的内容，我们对这两个变量中任意一个修改都不会影响其他变量

2.python垃圾回收机制

• 引计数

  • 原理
    • 当一个对象的引用被创建或者复制时，对象的引用计数加1；当一个对象的引用被销毁时，对象的引用计数减1.
    • 当对象的引用计数减少为0时，就意味着对象已经再没有被使用了，可以将其内存释放掉。
  • 优点
    • 引用计数有一个很大的优点，即实时性，任何内存，一旦没有指向它的引用，就会被立即回收，而其他的垃圾收集技术必须在某种特殊条件下才能进行无效内存的回收。
  • 缺点
    • 引用计数机制所带来的维护引用计数的额外操作与Python运行中所进行的内存分配和释放，引用赋值的次数是成正比的，
    • 显然比其它那些垃圾收集技术所带来的额外操作只是与待回收的内存数量有关的效率要低。
    • 同时，因为对象之间相互引用，每个对象的引用都不会为0，所以这些对象所占用的内存始终都不会被释放掉。

• 标记－清除

  • 它分为两个阶段：第一阶段是标记阶段，GC会把所有的活动对象打上标记，第二阶段是把那些没有标记的对象非活动对象进行回收。
  • 对象之间通过引用（指针）连在一起，构成一个有向图
  • 从根对象（root object）出发，沿着有向边遍历对象，可达的（reachable）对象标记为活动对象，不可达的对象就是要被清除的非活动对象。
  • 根对象就是全局变量、调用栈、寄存器。
    
  • 在上图中，可以从程序变量直接访问块1，并且可以间接访问块2和3,程序无法访问块4和5
  • 第一步将标记块1，并记住块2和3以供稍后处理。
  • 第二步将标记块2，第三步将标记块3，但不记得块2，因为它已被标记。
  • 扫描阶段将忽略块1，2和3，因为它们已被标记，但会回收块4和5。

• 分代回收

  • 分代回收是建立在标记清除技术基础之上的，是一种以空间换时间的操作方式。
  • Python将内存分为了3“代”，分别为年轻代（第0代）、中年代（第1代）、老年代（第2代）
  • 他们对应的是3个链表，它们的垃圾收集频率与对象的存活时间的增大而减小。
  • 新创建的对象都会分配在年轻代，年轻代链表的总数达到上限时，Python垃圾收集机制就会被触发
  • 把那些可以被回收的对象回收掉，而那些不会回收的对象就会被移到中年代去，依此类推
  • 老年代中的对象是存活时间最久的对象，甚至是存活于整个系统的生命周期内。

3.is和==区别

• is不仅数据一样内存地址也一样
• == 只判断数据和数据类型一样即可

4.读写文件

• 读写文件（python如何读取大文件）：https://www.cnblogs.com/xiaonq/p/7860309.html

• 经典面试题：现在有一个5G的文件，用python写入另一个文件里

  • read(): 指定读取指定大小的文件（默认一次读取所有）
  • readline(): 逐行读取，适合读大文件
  • readlines(): 一次性读取所有文件， 将文件按行读取成列表

• 我们使用了一个 while 循环来读取文件内容，每次最多读取 8kb 大小

• 这样可以避免之前需要拼接一个巨大字符串的过程，把内存占用降低非常多。

#!/usr/bin/python
# -*- coding: utf-8 -*-
def read_big_file_v(fname):
    block_size = 1024 * 8
    with open(fname,encoding="utf8") as fp:
        while True:
            chunk = fp.read(block_size)
            # 当文件没有更多内容时，read 调用将会返回空字符串 ''
            if not chunk:
                break
            print(chunk)
path = r'C:\aaa\luting\edc-backend\tttt.py'
read_big_file_v(path)

5.字符编码

• 各种编码由来

  • ASCII : 不支持中文（一个字母一个字节：a/b/c）
  • GBK : 是中国的中文字符，其包含了简体中文和繁体中文的字符
  • Unicode : 万国编码（Unicode 包含GBK）

• Unicode（每个字母需要用两个字节：a/b/c）

  • 存储所有字符串都用连个字节
  • Unicode 是为了解决传统的字符编码方案的局限而产生的，它为每种语言中的每个字符设定了统一并且唯一的二进制编码
  • 规定所有的字符和符号最少由 16 位来表示（2个字节），即：2 **16 = 65536
  • 这里还有个问题：使用的字节增加了，那么造成的直接影响就是使用的空间就直接翻倍了

• Utf-8 : 可变长码, 是Unicode 的扩展集

  • UTF-8编码：是对Unicode编码的压缩和优化，他不再使用最少使用2个字节，而是将所有的字符和符号进行分类

  • ascii码中的内容用1个字节保存、欧洲的字符用2个字节保存，东亚的字符用3个字节保存…

  • 存一个a字母用一个字节，存一个中文用三个字节

• python2与python3的几个区别

  • Python2默认 编码方式为ASCII， Python3 默认编码方式为UTF-8（是Unicode 的扩展集）
  • python2中字符串有str和unicode两种类型， python3 中字符串有str和字节(bytes) 两种类型
  • python3中不再支持u中文的语法格式

• python2和python3中编码转换

  • 在python3中字符串默认是unicode所以不需要decode()，直接encode成想要转换的编码如gb2312
  • 在python2中默认是ASCII编码，必须先转换成Unicode，Unicode 可以作为各种编码的转换的中转站

5.常用模块

https://www.cnblogs.com/xiaonq/p/7866925.html
（补录）

6.python如何读取大文件？

6.1、open函数用来打开文件

• 6.1.1、open(name[, mode[, buffering]]) 打开文件可传的参数

  • 1). open函数使用一个文件名作为唯一的强制参数，然后返回一个文件对象。
  • 2).模式(mode)和缓冲(buffering)参数都是可选的

• 6.1.2、打开文件的模式有

  • r，只读模式（默认）。
  • w，只写模式。【不可读；不存在则创建；存在则删除内容；】
  • a，追加模式。【可读； 不存在则创建；存在则只追加内容；】
  • 注： “+” 表示可以同时读写某个文件
  • w，只写模式。【不可读；不存在则创建；存在则删除内容；】
  • w+，写读
  • a+，同a

• 6.1.3、with语句

  • 作用：将打开文件写在with中当对文件操作完成后with语句会自动帮关闭文件，避免忘记写f.close()

#	with读文件
with open("data1.txt",'r',encoding = 'utf-8') as f:
    for line in f:
        print(line)

6.2、三种读操作比较

• 1、 readline()每次读取一行，当前位置移到下一行

• 2、readlines()读取整个文件所有行，保存在一个列表(list)变量中，每行作为一个元素

• 3、 read(size)从文件当前位置起读取size个字节，如果不加size会默认一次性读取整个文件（适用于读取小文件）

示例：

#1. read()一次读取所有内容
'''aaa111
bbb222'''
f = open(r"data.txt")
print(f.read())
f.close()

#2. readline()，每次只读取一行，光标下移
'''
0: aaa111

1: bbb222
'''
f = open(r"data.txt")
for i in range(2):
    print(str(i) + ": " + f.readline(),)

#3. 一次读取所有，每行作为列表的一个值
'''['aaa111\n', 'bbb222\n']'''
f = open(r"data.txt")
print(f.readlines())

6.3、使用read()读文件

1. read(n)——读取指定长度的文件

read读取指定长度字符串（示例）

f = open(r"somefile.txt")
print(f.read(7))        # Welcome        		先读出 7 个字符
print(f.read(4))        #‘ to ‘                接着上次读出 4 个字符
f.close()

2. seek(offset[, whence]) ——随机访问
   作用：从文件指定位置读取或写入

#从指定位置写入
f = open(r"somefile.txt", "w")
f.write("01234567890123456789")
f.seek(5)
f.write("Hello, World!")
f.close()
f = open(r"somefile.txt")
print(f.read())                 # 01234Hello, World!89

3. tell ——返回当前读取到文件的位置下标

#返回读取位置下标
f = open(r"somefile.txt")
f.read(1)
f.read(2)
print(f.tell())             # 3     3就是读取到文件的第三个字符

6.4、readline()读文件

作用：readline 的用法，速度是fileinput的3倍左右，每秒3-4万行，好处是 一行行读 ，不占内存，适合处理比较大的文件，比如超过内存大小的文件

#readline（）读取大文件
f1 = open('test02.py','r')
f2 = open('test.txt','w')
while True:
    line = f1.readline()
    if not line:
        break
    f2.write(line)
f1.close()
f2.close()

6.5、readlines()读文件

作用：readlines会把文件都读入内存，速度大大增加，但是木有这么大内存,那就只能乖乖的用readline

#readlines（）读文件
f1=open("readline.txt","r")
for line in f1.readlines():
    print(line)

6.6、将data1.txt中内容读取并写入到data2.txt中

#将data1.txt内容读取到data2.txt
f1 = open('data1.txt','r')
f2 = open('data2.txt','w')

for line in f1:
    f2.write(line)

f1.close()
f2.close()

6.7、使用eval()方法将文件读取成字典

f = open('data1.txt')
f1 = (f.read())
data = eval(f1)
f.close()
print(data)         # 运行结果： {'k2': 'v2', 'k3': 'v3', 'k1': 'v1'}

6.8、将文件内容读取成列表

lock = []
f = open("password.txt")
for name in f.readlines():
    lock.append(name.strip('\n'))
print(lock)
运行结果： ['aaa 111', 'bbb 222', 'ccc 333']

7、四大高阶函数

7.1、filter（）

• filter()函数可以对序列做过滤处理，就是说可以使用一个自定的函数过滤一个序列，把序列的每一项传到自定义的过滤函数里处理，并返回结果做过滤。最终一次性返回过滤后的结果。
• filter()函数有两个参数：
  • 第一个，自定函数名，必须的
  • 第二个，需要过滤的列，也是必须的

#利用 filter、lambda表达式 获取l1中元素小于33的所有元素 l1 = [11, 22, 33, 44, 55]
l1= [11,22,33,44,55]
a = filter(lambda x: x<33, l1)
print(list(a))

7.2、map（）

• map（）函数用指定函数在指定可迭代对象中的每一个元素运行此函数
• map使用：第一个参数接收一个函数名，第二个参数接收一个可迭代对象

#基本使用
lt = [1, 2, 3, 4, 5, 6]
def add(num):
    return num + 1
rs = map(add, lt)
print(list(rs))           #运行结果：  [2, 3, 4, 5, 6, 7]

7.3、reduce（）

• reduce()函数即为化简函数，它的执行过程为：每一次迭代，都将上一次的迭代结果与下一个元素一同传入二元func函数中去执行。
• 在reduce()函数中，init是可选的，如果指定，则作为第一次迭代的第一个元素使用，如果没有指定，就取seq中的第一个元素。

#使用reduce（）求和
from functools import reduce
def f(x, y):
 return x + y

print(reduce(f, [1, 3, 5, 7, 9]))  # 25
# 1、先计算头两个元素：f(1, 3)，结果为4；
# 2、再把结果和第3个元素计算：f(4, 5)，结果为9；
# 3、再把结果和第4个元素计算：f(9, 7)，结果为16；
# 4、再把结果和第5个元素计算：f(16, 9)，结果为25；
# 5、由于没有更多的元素了，计算结束，返回结果25。

print( reduce(lambda x, y: x + y, [1, 3, 5, 7, 9])  )  # 25

#使用reduce将字符串反转
s = 'Hello World'
from functools import reduce

result = reduce(lambda x,y:y+x,s)
# 1、第一次：x=H,y=e  => y+x = eH
# 2、第二次：x=l,y=eH  => y+x = leH
# 3、第三次：x=l,y=leH  => y+x = lleH
print( result )      # dlroW olleH

7.3、sorted（）

1）sorted和sort区别

• sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
• sort 是对已经存在的列表进行操作，无返回值，而 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
  2）sorted使用
• sorted 语法：sorted(iterable, cmp=None, key=None, reverse=False)
  • iterable – 可迭代对象。
  • cmp – 比较的函数
  • key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
  • reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

#对列表排序
students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
print( sorted(students, key=lambda s: s[2], reverse=False) )    # 按年龄排序
# 结果：[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

#对字典排序
d = {'k1':1, 'k3': 3, 'k2':2}
# d.items() = [('k1', 1), ('k3', 3), ('k2', 2)]
a = sorted(d.items(), key=lambda x: x[1])
print(a)            # [('k1', 1), ('k2', 2), ('k3', 3)]