45-Python知识点第二次查漏补缺

Python知识点第一次查漏补缺

一、模块

1.外部模块

外部模块就是在你 import 什么东西去python 脚本的时候会用到的.例如：

import numpy as np
import matplotlib.pyplot as plt

这里的 Numpy 和 matplotlib 都是外部模块, 需要安装以后才会有的. 他不属于 python 自带的模块.

2.模块安装方法

一般python3安装时会自动安装pip工具，利用该工具就可以轻松安装模块了。
例如：

pip install 你要的模块名

如果没有没有该命令，可能是你没有配置路径，或者python版本问题，有的是pip3进行安装；另个注意点，如果安装速度过慢，可以考虑配置安装源（python pip源配置）。

3.导入自己的模块

有时候写一些比较复杂的问题是，我们需要把代码分开写，然后在一个代码里面调用自己的代码，一般的思路有两个，简单点的可以直接在相同路径下直接import 文件名；例外一种则是较为规范的封装成模块，下面将详细介绍下两种用法。

1.直接引用

举例说明：
建立了两个python文件，目录结构如下：

a1.py:

def sum(a, b):
    return a + b

a2.py:

import a1

print(a1.sum(1, 2))

可以看出，我的目的是在a2里面调用a1写的函数来计算两个数的和，由于两个文本在同一个目录下面，于是可以这样直接import进去，然后直接调用即可。

2.封装成模块

需要注意的是，封装成模块，模块内文件如果没有相互调用那么可以写的跟上面的类似：

a1.py:

import B.b1
import B.b2

print(B.b1.sum(3, 1))
print(B.b2.jian(3, 1))

b1.py

def sum(a, b):
    return a + b

b2.py

def jian(a, b):
    return  a - b

跟什么的类似，这样子在a1中调用就可以了。

但是需要注意的是，如果模块内的文件有相互调用则会报错：
例如将b1.py修改为如下：

import b2 as b2
def sum(a, b):
   print('b1调用b2', b2.jian(a, b))
   return a + b

将b2.py修改为如下：

def jian(a, b):
   return a - b

就会报错，虽然b1和b2在相同路径中，但是依然需要写上文件夹的名称：import B.b2 as b2
即 b1.py:

import B.b2 as b2
def sum(a, b):
   print('b1调用b2', b2.jian(a, b))
   return a + b

一般模块文件夹下都有一个__init__.py文件相当于一个标记作用，一个文件夹中包含这个文件，那么该文件夹在Python中被定义为Module，init.py中可以什么都不写，只要存在就行了。如果不存在，则是就是个文件夹。
所以规范的格式如下：

二、文件

读写文件都是利用 opend打开一个文件，然后利用读入或者写入文件。

（1）写入

方式一

txt = """This is my first test.
	This is the second line.
	This is the third line
"""
f = open('./txt.txt', 'w')
f.write(txt)
f.close()

方式二

txt = 
"""This is my first test.
   This is the second line.
   This is the third line
"""
with open('./txt2.txt', 'w') as f:
   f.write(txt)

（2）读入

方式一

f = open('./txt2.txt', 'r')
txt = f.read()
f.close()
print(txt)

方式二

with open('./txt2.txt', 'r') as f:
  txt = f.read()
print(txt)

（3）按行读入

按行读入有两种，分为一行一行的读入（readline）,每次读入行由运行这个函数的次数决定；一次读入所有行（readlines），一次读入所有行，返回由所有行构成的一个list.
readline
readline() 方法用于从文件读取整行，包括 “\n” 字符。如果指定了一个非负数的参数，则返回指定大小的字节数，包括 “\n” 字符.
语法如下：

fileObject.readline(size)
size – 从文件中读取的字节数。

一次读入一行：

f = open('./txt.txt', 'r')
txt = f.readline()  # 读入第一行字符，包括\n 
print(txt)
txt = f.readline(7) # 读入第二行前7个字符（第二次运行这个函数就是读第二行）
print(txt)
f.close()

一次读入一行，读出所有行：

f = open('./txt.txt', 'r')
line = f.readline()
while line: # 循环读入所有行
    print(line) 
    line = f.readline()
f.close()

readlines
一次读入所有行，并返回list:

f = open('./txt.txt', 'r')
line = f.readlines()
print(line)
f.close()

close()方法

File 对象的 close（）方法刷新缓冲区里任何还没写入的信息，并关闭该文件，这之后便不能再进行写入。
当一个文件对象的引用被重新指定给另一个文件时，Python 会关闭之前的文件。用 close（）方法关闭文件是一个很好的习惯。

三、类（class)

类主要包括：类名，成员函数（成员方法），成员变量。
举一个例子：

class Calculator:
    name='good calculator' # 成变量
    price=18
    def __init__(self,name,price,hight=10,width=14,weight=16): #后面三个属性设置默认值,查看运行 （初始化方法，可以有也可以没有）
        self.name=name     # 对成员变量赋值
        self.price=price
        self.h=hight
        self.wi=width
        self.we=weight
        area = self.getarea() # 调用自己的成员方法
        print(area)

    def getarea(self): # 普通成员方法
        return self.h * self.wi

    def printf(self):
        print(self.name, self.price, self.h, self.wi, self.we)

ca = Calculator('na', 20) # 构建一个对象实例，并传入必要的参数
ca.printf()  # 调用对象的成员方法

四、输入 (input)

variable=input() 表示运行后，可以在屏幕中输入字符，该数字会赋值给变量，默认类型是字符串。如过需要读入整数，需要自己转化格式。

x = input('请输入---\n')
print(type(x))
# 如过需要读入整数，需要自己转化格式
x = int(input('请输入一个整数'))
print(type(x), x)

结果如下：

五、容器对象-tuple list set dict

1.list

Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。
使用方法见下例：

name = ['a', 'b', 'c', 'd', 'f', 'e', 'g']
print(name[0])     # 输出第一个项
print(name[-1])    # 输出第二项
print(name[0:-1])  # 输出低0项到最后第二项
name.pop()  # 删除末尾的元素
print(name)
name.pop(0) # 删除下标为0的元素
print(name)
name[0] = 'xxxx'  # 修改当前下表为0的元素
print(name)

运行结果：

2. tuple

另一种有序列表叫元组：tuple。tuple和list非常类似，但是tuple一旦初始化就不能修改。它也没有append()，insert()这样的方法。其他获取元素的方法和list是一样的，你可以正常地使用classmates[0]，classmates[-1]，但不能赋值成另外的元素。因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple。
**tuple的陷阱：**当你定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来，比如：

t = (1, 2)
print(t)

运行结果：

(1, 2)

如果要定义一个空的tuple，可以写成()：

 t = ()

但是，要定义一个只有1个元素的tuple，如果你这么定义：

t = (1)
print(t)

输出：

1

定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。
所以，只有1个元素的tuple定义时必须加一个逗号,，来消除歧义：

t = (1,)
print(t)

输出结果：

(1,)

看一个“可变的”tuple：

t = ('a', 'b', ['A', 'B'])
t[2][0] = 'X'
t[2][1] = 'Y'
print(t)

输出结果：

(‘a’, ‘b’, [‘X’, ‘Y’])

表面上看，tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向’a’，就不能改成指向’b’，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！

3. set

set 对象是由具有唯一性的 hashable 对象所组成的无序多项集。 常见的用途包括成员检测、从序列中去除重复项以及数学中的集合类计算，例如交集、并集、差集与对称差集等等。
基本用户见实例：

myset = set([1, 2, 3, 3, 4, 5])
print(myset)
myset.add(6)  # 添加元素
print(myset)
myset.remove(6)  # 从集合中移除元素 elem。 如果 elem 不存在于集合中则会引发 KeyError。
print(myset)
print(myset.discard(7)) #如果元素 elem 存在于集合中则将其移除。
if 1 in myset: # 判断是否存在
    print('存在')
myset.clear()
print(myset)

运行结果：

{1, 2, 3, 4, 5}
{1, 2, 3, 4, 5, 6}
{1, 2, 3, 4, 5}
None
存在
set()

4. dict

mapping 对象会将 hashable 值映射到任意对象。 映射属于可变对象。 目前仅有一种标准映射类型 字典。 （关于其他容器对象请参看 list, set 与 tuple 等内置类，以及 collections 模块。）
字典的键 几乎 可以是任何值。 非 hashable 的值，即包含列表、字典或其他可变类型的值（此类对象基于值而非对象标识进行比较）不可用作键。 数字类型用作键时遵循数字比较的一般规则：如果两个数值相等 (例如 1 和 1.0) 则两者可以被用来索引同一字典条目。 （但是请注意，由于计算机对于浮点数存储的只是近似值，因此将其用作字典键是不明智的。）
基本用法见实例：

# 多种声明方式
a = dict(one=1, two=2, three=3)
b = {
     'one': 1, 'two': 2, 'three': 3}
c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
d = dict([('two', 2), ('one', 1), ('three', 3)])
e = dict({
     'three': 3, 'one': 1, 'two': 2})
print(a == b == c == d == e)
# 增
a['a'] = 1  # 如果该键存在则覆盖，没有则新增一个
print(a)
# 删
del a['a']
print(a)
# 改
a['one'] = 111
print(a)
# 查
print(a.get('one'), a.get('1111')) #如果 key 存在于字典中则返回 key 的值，否则返回 default。 如果 default 未给出则默认为 None，因而此方法绝不会引发 KeyError。
# 判断
if 'one' in a:
    print('存在：', a['one'])
# 遍历
for k, v in a.items():
    print('---', k, v)
# 取所有键和值
print(a.keys())
print(a.values())
# 清空
a.clear()
print(a)

六、import

• import time
• import time as t # 取个别名
• from time import time,localtime # 只import自己想要的功能
• from time import * 输入模块的所有功能

七、异常处理 try

一个例子：

try:
    file=open('eeee.txt','r')  #会报错的代码
except Exception as e:  # 将报错存储在 e 中
    print(e)

八、zip、lambda 、map

1.zip

zip函数接受任意多个（包括0个和1个）序列作为参数，合并后返回一个tuple列表。

a=[1,2,3]
b=[4,5,6]
ab=zip(a,b)
print(list(ab))  #需要加list来可视化这个功能

输出：

[(1, 4), (2, 5), (3, 6)]

2.lambada

lambda定义一个简单的函数，实现简化代码的功能，看代码会更好理解。
fun = lambda x,y : x+y, 冒号前的x,y为自变量，冒号后x+y为具体运算。

fun = lambda x, y : x + y
x = 1
y = 2
print(fun(x,y))

输出：

3

3.map

map是把函数和参数绑定在一起。

def fun(x,y):
    return (x+y)
print(list(map(fun,[1],[2])))
print(list(map(fun,[1,2],[3,4])))

输出：

[3]
[4, 6]

九、copy & deepcopy 浅复制 & 深复制

1.id

什么是id？一个对象的id值在CPython解释器里就代表它在内存中的地址。

>>> import copy
>>> a=[1,2,3]
>>> b=a
>>> id(a)
"""
4382960392
"""
>>> id(b)
"""
4382960392
"""
>>> id(a)==id(b)    #附值后，两者的id相同，为true。
True
>>> b[0]=222222  #此时，改变b的第一个值，也会导致a值改变。
>>> print(a,b)
[222222, 2, 3] [222222, 2, 3] #a,b值同时改变

2.浅拷贝

当使用浅拷贝时，python只是拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。

>>> import copy
>>> a=[1,2,3]
>>> c=copy.copy(a)  #拷贝了a的外围对象本身,
>>> id(c)
4383658568
>>> print(id(a)==id(c))  #id 改变 为false
False
>>> c[1]=22222   #此时，我去改变c的第二个值时，a不会被改变。
>>> print(a,c)
[1, 2, 3] [1, 22222, 3] #a值不变,c的第二个值变了，这就是copy和‘==’的不同

>>> a=[1,2,[3,4]]  #第三个值为列表[3,4],即内部元素
>>> d=copy.copy(a) #浅拷贝a中的[3，4]内部元素的引用，非内部元素对象的本身
>>> id(a)==id(d)
False
>>> id(a[2])==id(d[2])
True
>>> a[2][0]=3333  #改变a中内部原属列表中的第一个值
>>> d             #这时d中的列表元素也会被改变
[1, 2, [3333, 4]]

可以见直接用copy即浅拷贝，对于列表内元素是完全复制了一份，但是如果里面还有引用的，它只是复制了一份引用，还是会指向同一个地方。

3.深拷贝

deepcopy对外围和内部元素都进行了拷贝对象本身，而不是对象的引用。

#copy.deepcopy()

>>> e=copy.deepcopy(a) #e为深拷贝了a
>>> a[2][0]=333 #改变a中内部元素列表第一个的值
>>> e
[1, 2, [3333, 4]] #因为时深拷贝，这时e中内部元素[]列表的值不会因为a中的值改变而改变

十、pickle

模块 pickle 实现了对一个 Python 对象结构的二进制序列化和反序列化。 “pickling” 是将 Python 对象及其所拥有的层次结构转化为一个字节流的过程，而 “unpickling” 是相反的操作，会将（来自一个 binary file 或者 bytes-like object 的）字节流转化回一个对象层次结构。 pickling（和 unpickling）也被称为“序列化”, “编组” 1 或者 “平面化”。而为了避免混乱，此处采用术语 “封存 (pickling)” 和 “解封 (unpickling)”。

pickle 读入

pickle 是一个 python 中, 压缩/保存/提取 文件的模块. 最一般的使用方式非常简单. 比如下面就是压缩并保存一个字典的方式. 字典和列表都是能被保存的.

import pickle

a_dict = {
     'da': 111, 2: [23,1,4], '23': {
     1:2,'d':'sad'}}

# pickle a variable to a file
file = open('pickle_example.pickle', 'wb')
pickle.dump(a_dict, file)
file.close()

pickle 写入

提取的时候相对简单点, 同样我们以读的形式打开那个文件, 然后 load 进一个 python 的变量.

# reload a file to a variable
with open('pickle_example.pickle', 'rb') as file:
    a_dict1 =pickle.load(file)

print(a_dict1)