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

Python知识点第一次查漏补缺

文章目录

  • 一、模块
    • 1.外部模块
    • 2.模块安装方法
    • 3.导入自己的模块
      • 1.直接引用
      • 2.封装成模块
  • 二、文件
    • (1)写入
    • (2)读入
    • (3)按行读入
    • close()方法
  • 三、类(class)
  • 四、输入 (input)
  • 五、容器对象-tuple list set dict
    • 1.[list](https://docs.python.org/zh-cn/3/library/stdtypes.html?highlight=dict#sequence-types-list-tuple-range)
    • 2. [tuple ](https://docs.python.org/zh-cn/3/library/stdtypes.html?highlight=dict#sequence-types-list-tuple-range)
    • 3. [set](https://docs.python.org/zh-cn/3/library/stdtypes.html?highlight=set#set-types-set-frozenset)
    • 4. [dict](https://docs.python.org/zh-cn/3/library/stdtypes.html?highlight=dict#mapping-types-dict)
  • 六、import
  • 七、异常处理 try
  • 八、zip、lambda 、map
    • 1.zip
    • 2.lambada
    • 3.map
  • 九、copy & deepcopy 浅复制 & 深复制
    • 1.id
    • 2.浅拷贝
    • 3.深拷贝
  • 十、pickle
    • pickle 读入
    • pickle 写入

一、模块

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.封装成模块

需要注意的是,封装成模块,模块内文件如果没有相互调用那么可以写的跟上面的类似:
45-Python知识点第二次查漏补缺_第1张图片
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

45-Python知识点第二次查漏补缺_第2张图片
就会报错,虽然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

45-Python知识点第二次查漏补缺_第3张图片
一般模块文件夹下都有一个__init__.py文件相当于一个标记作用,一个文件夹中包含这个文件,那么该文件夹在Python中被定义为Module,init.py中可以什么都不写,只要存在就行了。如果不存在,则是就是个文件夹。
所以规范的格式如下:
45-Python知识点第二次查漏补缺_第4张图片

二、文件

读写文件都是利用 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()

45-Python知识点第二次查漏补缺_第5张图片
一次读入一行,读出所有行:

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

45-Python知识点第二次查漏补缺_第6张图片
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)

结果如下:
45-Python知识点第二次查漏补缺_第7张图片

五、容器对象-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)

运行结果:
45-Python知识点第二次查漏补缺_第8张图片

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)

你可能感兴趣的:(python)