导图社区 Python知识点记录
- 40
- 2
- 1
- 举报
Python知识点记录
对慕课上python课程学习中的基础篇, 提高篇知识点记录。框架清晰，内容丰富，希望对小伙伴有所帮助~
编辑于2022-06-30 08:49:29- 爬虫
- python入门
- python提高
- 相似推荐
- 大纲
python基础篇
条件
复杂条件及处理
成员运算符
in
在指定序列中找到值，返回Ture,反之
not in
在指定序列没有找到值，返回Ture,反之
身份运算符
is
判断两个标识符是否引自一个对象，是，返回Ture
not is
判断两个标识符是否引自一个对象，不是，返回Ture
>>> i=t=1>>> i is tTrue
子主题
条件分支和循环
if
单分支判断
双分支判断
多分支判断
注意冒号注意缩进
while
示例一
>>> i=0>>> while i<3:... i+=1... print(i)... 123
示例二
>>> i,j=0,2>>> while i<2:... while i<j:... print("%d"%((i+1)*j))... j-=1... i+=1... 21
for
for <> in <>： 子代码块else: 子代码块
自定义实现for循环
>>> fish_record='鲫鱼5条，鲤鱼8条，鲢鱼7条，草鱼2条，黑鱼6条，乌龟1只'>>> i=0>>> for var in fish_record:... if var=='条':... i+=1... print(i)... 12345
range()实现for()循环
>>> for i in range(9):... if i%2==0:... print('%d'%(i))... 02468
range()的另一种的用法
range(start,stop[,step])
>>> for i in range(0,9,2):... print('%d'%(i))... 02468
循环控制语句
break
先执行循环，判断条件，满足后break，结束循环
continue
先执行循环，判断条件，满足后continue,返回for循环，重新开始
运算符优先级
运算符优先级 优先级顺序 运算符 运算符名称1 ** 指数2 ~,+,- 按位翻转，数前正、负号3 *,/.%,// 乘、除、取模、取整4 +,- 加、减5 >>,<< 右移、左移6 & 与7 ^,| 异或、或8 ==,!=,<,<=,>,>= 比较运算符9 =,%=,/=,//=,-=,+=,*=,**= 赋值运算符10 is,is not 身份运算符11 in,in not 成员运算符12 not,or,and 逻辑运算符
字典dict
键值对
键key
唯一性
如若存在一样的键，将保留最后一个
不可变性
:
值value
操作
D字典对象，k,键;d值
注意
属一对一映射关系的数据类型
列表通过L[x]=value的方法，修改对应下标X的元素字典通过D[k]=value的方法，为字典增加新元素，k为指定键,且k在字典中不存在
字典的操作方法全
.clear()
清空字典
.copy()
复制生成另一个字典
.fromkeys()
使用给定的键建立新字典，键对应的值默认为NONE
.get()
根据指定键，返回对应值，键不存时，返回None
.items()
以元组数组的形式返回字典中的元素
.pop()
删除指定键的元素，并返回对应值
.popitem()
随机返回元素，并删除
.setdefault()
当键不存在时，设置键值对；存在键时，返回键对应值
.update()
利用一个字典更新另一个字典
.keys()
可以浏览的、类似列表形式返回字典中的键
.values()
可以浏览的、类似列表形式返回字典中的值
字典值查找
D[k]
D.get(k[,d])
如若找一个不存在的键，显示空值
字典元素增加
赋值
>>> d1 = {1:'tom',2:'lin'}>>> d1[3] = 'ken'>>> d1{1: 'tom', 2: 'lin', 3: 'ken'}>>> d1[4] = 5>>> d1{1: 'tom', 2: 'lin', 3: 'ken', 4: 5}
.setdefault()
D.setdefault(k[,d])
字典值修改
赋值
>>> d1 = {1:'tom',2:'lin'}>>> d1[2] = 'tom'>>> d1{1: 'tom', 2: 'tom'}
D.update(d1)
d1内键D有，更新；没有，增加对应键值
D.update() 增加，更新
D.setdefault() 增加、显示
字典元素删除
del(k)
>>> d1{1: 'tom', 2: 'tom'}>>> del(d1[2])>>> d1{1: 'tom'}
.pop(k[,d])
.popitem()
操作不存在的元素，报错
字典遍历操作
所有键值对
D.item()
所有键
D.keys()
in d1
所有值
D.values()
通过遍历所有键，遍历所有值
其他操作
in成员
D.clear()
D.copy()
列表与元组
列表
列表基本操作方法
方法 功能.append() 尾部添加元素.clear() 列表清空.copy() 复制生成另外一个列表.count() 统计指定元素个数.extend() 两个列表元素合并.index() 返回指定元素下标.insert() 指定位置插入新元素.pop() 删除并返回指定下标对应元素.remove() 删除指定元素.reverse() 发转元素顺序.sort() 对元素排序
列表增加
.append(元素)
末尾
.insert(下标，元素)
指定位置
列表查找
.index()
返回下标
in成员判断
>>> list=['tom',1,2,3]>>> 'q' in listFalse
切片
用下角标读对应元素
列表删除
.clear()
清除
.pop()
弹出并删除
.remove()
一次删一个
del函数
>>> list=['tom',1,2,3]>>> print(list)['tom', 1, 2, 3]>>> del list>>> print(list)<class 'list'>
列表元素合并
+
.extend()
>>> list=['tom',1,2,3]>>> list1=[1,2,3]>>> list.extend(list1)>>> print(list)['tom', 1, 2, 3, 1, 2, 3]>>> id(list)139782139463816
列表排序
.sort()
L.sort(key=None,reverse=False)
key为可选参数，用于比较之前，key=str.lower,字符串大写变小写reverse=True,减序：反之（默认增序）
.sorted()
不改变原有列表
其他操作方法
.copy()
.count()
统计
.reverse()
实现列表反向
列表解析
>>> num=[i**2 for i in range(0,11) if i>0]>>> print(num)[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]>>> num=[i**2 for i in range(0,11,2) if i>0]>>> print(num)[4, 16, 36, 64, 100]
列表算法
冒泡排序
取左边第一个元素，与后面元素依次比较，一轮完成后，较大元素后沉，进行第二轮比较，比较次数较上轮减一，以此类推
二分法查找
在有序集合中，对下标范围通过取中位法获取对应元素值，进行叠代查找比较，直至找到对应元素
元组Tuple
python提供了一种特殊的默认格式，只要有“，”，就把他看作元组
性质
不允许对元素进行变动
元组用小括号，列表用中括号
元组基本格式及用法
注意：给元组变量赋一个变量时，记得后面带一个“，”，以防歧义
基本操作
.index()
查找
.count()
直接统计数量
方法
del()
删除函数
len()
sum()
type()
获得对象类型
函数
标准库Standard Library
标准库知识
内置了大量函数和类,是解释器核心功能之一
内置对象
Built-in Functions内置函数
print()
Built-in Constants内置常量
False
Built-in Types内置类型
各种数据类型
Built-in Exceptions内置异常
常见模块
Data Types数据类型
datetimes
时间日期模块
Numeric and Mathematical数字和数学
math
数学函数
random
生成伪随机数
Generic Operating System Servicers通用操作系统服务
os
各种操作系统相关接口
sys
系统特定的参数和功能
time
时间访问和转换
标准库各模块
见python-模块
模块
再论模块
函数模块文件
自定义函数模块的代码文件
类模块文件
自定义类模块的代码文件
主要供主程序调用
主程序模块文件
执行的主程序代码
所有代码,可help()查看
在非搜索路径下,指定文件绝对路径
导入绝对路径下模块文件
help()
包
注意:包必须安在解释器可以搜到的路径下,通过sys.path()设置临时搜索路径,或默认搜索路径\
当模块文件多起来时,将模块文件分类存放
建立顶级包目录package
此目录存放一个名为__init__.py的空文件 为说明此文件夹目录为包目录
解释器搜索路径时,可得到明显区分 该目录名称为包的名称
把模块文件分类存到包下
导入包模块
方法 import
import 顶级目录.子目录.模块文件
窥探标准库原码
例子ma.py
from datetime import datetime,date,time #从datetime调用指定函数import math as m #给模块重命名x = 2.3y = 22.5z = x-yz = m.trunc(m.fabs(z)) #绝对值,取整print(z)x1 = m.log10(z) #底为10的z的对数y1 = m.pow(10,x1) #10的x1次幂print('10为底的%d的指数是%f,10的%f次时%f'%(z,x1,x1,y1))date1 = date(2000,3,1) #日期函数date2 = date(1961,10,15)print('%s和%s相差'%(date1.ctime(),date2.ctime()),date1-date2) #方法,获取"星期,月,日,时,分,妙,年"格式字符串time1 = time(8,50,18) #时间函数time2 = time(14,0,7)print(datetime.combine(date1,time2)-datetime.combine(date1,time1)) #绑定日期,时间,生成新的datetime对象tt = datetime.combine(date1,time2)-datetime.combine(date1,time1)print(tt.total_seconds()) #两个时间的总差,,seconds为差,忽略天数,微秒 2010为底的20的指数是1.301030,10的1.301030次时20.000000Wed Mar 1 00:00:00 2000和Sun Oct 15 00:00:00 1961相差 14017 days, 0:00:005:09:4918589.0
函数
通过专门的代码组织,实现特定的功能的代码段,具有相对的独立性,可供其他代码重复调用
在函数return执行返回值后,下一行出现的代码不可被执行,属于隐性代码缺失.
调用函数
导入整个模块
import 函数模块名
导入指定函数
form 函数模块名 import 指定函数
导入全部函数
from 函数模块名 import * *表示模块内所有函数
模块名,函数名 过长可用as
>>> from factor_docstring import *>>> import factor_docstring as aa1>>> aa1.find_factor(8)' 1 2 4 8'>>> print(aa1.find_factor(8)) 1 2 4 8
import 名 as 新名
/home/cc/_file
as还可解决函数名冲突
模块搜索路径
当模块变多,统一放入一个子文件夹,方便管理
在不同文件夹下的不同模块调用,需解决路径问题
用sys.path方法指定特定搜索模块路径
>>> import sys>>> sys.path[0] = '/home/cc/_file'>>> from factor_docstring import *>>> import factor_docstring as aa1>>> print(aa1.find_factor(8)) 1 2 4 8
/home/cc
自定义函数
def 函数名([参数]): 函数体 [return 返回值]
参数
默认值
为参数设定默认值,没有给定参数时,选择默认值
位置参数
传递参数值时,位置应一一对应,不可乱打
不定长参数
允许编写不定长参数,方便函数调 用,根据实际情况传递值数量
*
函数名([param1,...]*paramX)
可以传递任何type()类型的参数
**
传递键值对
关键字参数
参数名 = 值
避免出错,可无视位置顺序
传递
元组
列表
字典值
传递后会出现同步u变化不希望出现,.copy()方法
不可变对象
数字
字符串
元组
可变对象
列表
字典
头
def
函数与变量作用域
变量
全局变量
局部变量
global关键字
函数内部默认只读全局变量,修改全局变量,global关键字事先声明,否则会报错.
nonlocal关键字
修改闭包,不建议使用
闭包
j = 5 #全局变量def sum0(): #外部函数 k = 2 #闭包函数 def sum1(): #嵌套内部函数 i = k+j #局部变量 return i return sum1()
介于全局变量及局部变量的一种特殊的变量
闭包定义位置位于外部与内部函数之间
匿名函数
lambde
定义
lambde [para1,para2,]:expression
para任何类型,决定于expression
具有return功能
在一行内实现所有定义
递归函数
通过一种重复,把问题分为同类的子类问题而解决问题的方法
凡是通过循环语句实现的,都可用递归法来实现
递归一次,开辟一个新空间,记录递归状态,一直递归分到最小范围,要么得出答案,要么无
缩小范围层层返回
类
class Class1(): def __init__(self,student1 = [],teacher1 = []): self.student = student1 self.teacher = teacher1 def len_people(self,people): return len(people) teachers = [11,22,33]students = [22,432,43,5756,87,4134,423,212,3]show = Class1(students,teachers)print('有%d个学生,%d个老师'%(show.len_people(show.student),show.len_people(show.teacher)))#实例.方法(属性) cc@cigar:~/_file$ python3 Class_class.py 有9个学生,3个老师
#实例.方法(属性)
初识
类的特性通过数据体现 行为通过函数操作
面向对象
格式
class 类名(): #类名首字母大写 ''' ''' #类文档说明 #函数 def __init__(self,**,...): #用来初始化 ,不被外部直接调用, self.* = ** #方法 def volume(self): #去self不可被实例调用 return self.*
属性使用
通过__init__函数定义,通过self传递,数据类型
初始化
直接赋值
传递参数初始化
修改
直接对属性值修改
>>> class Box1():... def __init__(self):... self.length = 0... self.width = 0... self.height = 0... >>> B1 = Box1()>>> print(B1.length)0>>> B1.length = 10>>> print(B1.length)10
通过方法修改
>>> class Box2():... def __init__(self):... self.height = 0... self.width = 0... self.length = 0... def setnew_length(self,length1):... self.length = length1... >>> b1 = Box2>>> b1.setnew_length(17)>>> print(b1.setnew_length(18))None>>> print(b1.length)18
把类赋给属性
#property_box_class.py#coding = utf-8class Color1(): '''docstring for Color1''' def __init__(self, index = 0): self.set_color = ['white','red','black','green'] self.index = index def setColor(self): return self.set_color[self.index] class Box1(): '''求立方体的类''' def __init__(self,length1,width1,height1,c1 = 0): self.lenght = length1 self.width = width1 self.height = height1 self.color0 = Color1(c1).setColor() def volume(self): return self.length*self.width*self.height my_box = Box1(10,10,10,1)print(my_box.color0) >>>red
通过Box1()类内部调用颜色类Color1(),并把其对应的.setColor()方法得到的颜色赋给color0属性最后通过创建my_box1例子,可以灵活设置需要的颜色值
类改造问题
继承
#inher_box_class.py#coding=utf-8#Box2子类继承Box1父类class Box1(): '''求立方体的类''' def __init__(self,length1,width1,height1): self.length = length1 self.width = width1 self.height = height1 def volume(self): return self.length*self.width*self.height class Box2(Box1): def __init__(self,length1,width1,height1): super().__init__(length1,width1,height1) #super实现父类子类关联 self.color = 'white' self.material = 'paper' self.type = 'fish' def area(self): #新加表面积方法<函数`` re = self.length*self.width+self.length*self.height+self.width*self.height return re*2 my_box2 = Box2(10,10,10)print('立方体的体积为%d'%(my_box2.volume()))print('立方体的面积为%d'%(my_box2.area()))print('立方体颜色%s,材料%s,类型%s'%(my_box2.color,my_box2.material,my_box2.type)) >>>立方体的体积为1000立方体的面积为600立方体颜色white,材料paper,类型fish
继续对其他属性定义,追加其他方法,一:直接对原码改造二:利用继承
继承原有类功能的基础上,增加新功能,(属性,方法),形成新的子类被继承的为父类
继承使用方法
1.在子类名声明时,引入父类名,如 class Box2(Box1):2.重新定义子类的__init__函数,若父类__init__函数有参数,则照抄父类的参数.3.在子类__init__函数里提供super函数,实现子类与父类的关联,若父类有参数则需同步参数(self除外),如: super().init(length1,width1,height1)4.可以在子类里添加新属性定义,如 self.color = 'white'55.可以在子类里添加新方法定义,如 def area(self):
注意
继承可多层python2里面,父类要加参数(object),同时在子类的super()里添加两个参数一个子类名,一个self,如(Box2,self)
重写方法
#inher_box_class.py def area(self): #新加表面积方法<函数`` re = self.length*self.width+self.length*self.height+self.width*self.height return re*2 def volume(self,num = 1): return self.length*self.width*self.height*num my_box2 = Box2(10,10,10)print('5个立方体的体积为%d'%(my_box2.volume(5)))
在子类最后重新定义要重写的方法,函数名与父类一致即可
私有
#class_private.py#coding=utf-8class TeatPrivate(object): """docstring for TeatPrivate.""" def __init__(self): self.__say = 'ok' def p(self): print(self.__say) def __p1(self): print(self.__say) show = TeatPrivate()show.p() #IDLE中只能看到.p()方法
IDLE中双下划线屏蔽了私有化的对象
把类放到模块中
建立独立类模块过程
(1)建一个空白python模块,起一个易识别的名字,Class_module.py(2)把自定义放到Class_module.py里,(3)在主代码程序中Main_program.py引用, form Class_module import *(4)Main_program.py里写主程序
与建立模块过程一样
类回顾
动态类
可创建实例
静态类
#StaticClass.py#coding=UTF-8class Static(): name = 'Tom' age = 20 address = 'China' call = 4189579-534 def a(): i = 0 i += 1 print('第一个函数%d'%(i)) def b(add = 1): pirnt('第二个函数%d'%(add)) def c(add = 1): print('第三个函数%d'%(add)) return add
变化是同步的
不实例化使用
#直接调用变量或函数print('name:%s'%(Static.name))print('age:%d'%(Static.age))print('address:%s'%(Static.address))print(Static.a())print(Static.b(2))print(Static.c(3)) >>>name:Tomage:20address:China第一个函数1None第二个函数2None第三个函数33
区别
静态类没有self关键字,不能被实例化静态类不可通过类名传递参数静态类不支持init()初始函数可以集成变量或函数,是一个带结构体的数据类型
总结
类与面向对象编程
封装
把属性定义,方法定义,集成在一起
继承
子类属性从祖先那里继承得来
多态
相同的函数可以作用于不同种类的类型的对象上体现不同的结果,不同的对象,可以产生不同的结果
类编写其他事项
重名问题
方法与属性不可重名
不要直接使用动态类里的数据变量
易混乱
但类庞大时可进行合理拆分,如继承
可以在类中引用自定义函数,只需开始时引用即可
数据类型
变量
字符串String
数字Numeric
列表List
元组Tuple
字典Dictionary
数字
分类
整数
浮点数
只要式子中有一个浮点数值为浮点数
复数
>>> (1-2j)(1-2j)>>> (1-2j)*(2-3j)(-4-7j)>>> (1-2j).real1.0>>> (1-2j).imag-2.0
布尔Boolean
逻辑
and
or
not
二进制{用0b开头表示}
bin()为二进制转十进制
运算符
& 与 遇零为零
| 或 遇一为一
^ 异或 异=1,同=0
～ 取反
<< 左移 补零
>> 右移 补零
进制
十进制
八进制{0o
十六进制{0x
运算符
算数运算符
+ 加-- 减* 乘/ 除% 模（余数** 乘方// 商取整数
比较运算符
==
等于
!=
不等于
>
<
>=
<=
字符串比较比较ASCII码
赋值运算符
=
赋值
+=
加法赋值
-=
减法赋值
*=
乘法赋值
/=
除法赋值
**=
//=
<<=
>>=
&=
|=
^=
优先级
算数>位>比较>逻辑
数据类型转换
int()
float()
complex(x,y)
复数
str()
字符串
bin(x)
二进制（x>=0)
oct(x)
八进制（x>=0)
hex(x)
十六进制（x>=0）
chr(x)
十进制转ASCII字符（x为十进制）
ord(x)
字符转十进制
字符串(左到右，从零开始)>>>name="Tom is a cat!"
成对的"" , '' , ''' ''' ,
基本操作
读取
切片
>>>name[1:2] == om
负数从右向左
>>>name[::2] == Tmi a!
第二个：后为步长
合并
>>> name = 'Tom'>>> job = 'teacher'>>> record = name + "," + job>>> print(record)Tom,teacher
修改
>>> name='Three cool cat'>>> new_name=name[::1]+'dogs'>>> print(new_name)Three cool catdogs
删除
>>>del(name)
其他操作
获得长度
>>> name='hi!'>>> len(name)3
r/R对转义字符的控制
>>> print('C:\back\name')Cackame >>> print(r'C:\back\name')C:\back\name
* 重复输出
>>> print('cat'*2)catcat
% 格式字符串
>>> age=10>>> print("Tom`s name is %d"%(age))Tom`s name is 10
实例：猫猫钓鱼
异常
程序中出现的问题
低级错误
代码语法错误
>>> if Ture: #语法出错 File "<stdin>", line 1 if Ture ^SyntaxError: invalid syntax #提示无效语法 缺冒号
中级错误
代码存在隐形错误
正确运行
def print_d(dic): #打印字典类型元素 i = 0 len1 = len(dic) while i<len1: print(dic.popitem()) i += 1print_d({1:22,2:33}) cc@cigar:~/_file$ python3 ma.py(2, 33)(1, 22)
错误
def print_d(dic): i = 0 len1 = len(dic) while i<len1: print(dic.popitem()) i += 1print_d([1,2]) cc@cigar:~/_file$ python3 ma.pyTraceback (most recent call last): File "ma.py", line 27, in <module> print_d([1,2]) #错误传输对象 File "ma.py", line 25, in print_d print(dic.popitem())AttributeError: 'list' object has no attribute 'popitem'
有些隐性错误甚至不报错
高级错误
软件面对不确定性的异常错误
不确定性的异常错误,代码,数据等没错,根据运行环境的不确定性导致异常
软件尝试打开一个文件,这个文件已被破坏或被独占
软件在数据库中插入数据时,网络中断,数据丢失
软件运行过程中硬件故障,软件无法运行
数据库系统被破坏,软件读写数据报错
软件输入内容过于复杂或存在误操作
......
捕捉异常
但程序运行发生代码异常后,可以通过捕捉语句来实现对异常信息的确定和处理
基本异常捕捉语句
try: #异常捕捉语句开始 代码模块1 #正常需要执行的代码模块except: #用来捕捉异常信息,并给出出错提示 代码模块2
异常捕捉流程
捕捉异常实例
def print_d(dic): i = 0 try: #捕捉机制开始 len1 = len(dic) while i<len1: print(dic.popitem()) i += 1 except: #捕捉异常信息 print('传递值类型出错,必须为字典型') #给出友好提示print_d({1:22,3:22})print_d([1,2]) cc@cigar:~/_file$ python3 ma.py(3, 22)(1, 22)传递值类型出错,必须为字典型
带finally子句的异常处理
try: 代码模块1except: 代码模块2finally: 代码模块3
程序运行中存在一种特殊功能,无论程序运行过程中是否报错,最后都要处理一些代码
例:打开文件读取字符出错,先提示打开错误,然后最好把以打开的文件关闭,防止反复打开消耗内存;读取完毕后,也要及时关闭这个文件.
捕捉特定的异常信息
except(Exception1[,Exception2,...])Exception1.2.3...n,继承自Exception
从Exception父类继承的部分异常子类
异常类名 功能说明 ValueError 对象值不正确 IndexError 指定字符串,元组,列表等的下标元素不存在 NameError 指定对象名不存在 KeyError 指定字典键不存在 TypeError 提供错误类型对象 ModuleNoFoundError 模块文件找不到,模块文件名写错 SynatxvError 语法无效 AttributeError 对象属性,方法引用或父子不当
抛出异常
raise [Exception]
可程序员自己抛出
不带参数
>>> raiseTraceback (most recent call last): File "<stdin>", line 1, in <module>TypeError: exceptions must be old-style classes or derived from BaseException, not NoneType
带参数
Python提高篇
文件处理
文本文件 .txt
具有初步存放,编辑各类数据的能力, 持久保留和数据共享
建立文件
#build_new_file.py#coding=utf-8newfile = r'/home/cc/_file/file/1.txt'b_new_file = open(newfile,'w')b_new_file.close()print('%s成功建立'%(newfile)) cc@cigar:~/_file/file$ ls1.txt
分析
文本名称本身是字符串,要考虑转义字符对路径或是名称的影响在不同的操作系统下.指定的路径必须在,否则报错.
open()函数建立(打开)文件open(file,mode='w') file==文件名[+文件路径];mode指定操作方式
mode参数
mode参数的详细用法参数值 功能描述 'r’ 只读已存在文件 'w’ 只写,若文件不在,建一个 'x’ 新建 'a’ 追加写入打开一个文件;若文件不存在,新建,再追加写入'b’ 二进制模式 't’ 文本模式 '+’ 读写 'U’ 通用换行符模式(不建议使用) 默认mode=’rt’ 常见组合:’rb’,’wb’,’xb’,’ab’,’rt’,’wt’,’xt’,’at’,’r+’,’w+’,’x+’,'a+'
可以打开二进制文件包括:图片,exe(黑客)等
用.close()的方法关闭新建文件不关闭,一直占用内存,数量太多时,可能会导至内存溢出等错误
标配:务必养成良好的习惯
基本读写文件
#build_new_file.py#coding=utf-8newfile = r'/home/cc/_file/file/1.txt'# b_new_file = open(newfile,'w')b_new_file = open(newfile,'r')# t_n = b_new_file.write('I like Python!\n')t_m = b_new_file.read(8)print(t_m)b_new_file.close()print('%s成功建立'%(newfile))# print('向文本类写入%d个字节内容'%(t_n)) cc@cigar:~/_file$ python3 build_new_file.py /home/cc/_file/file/1.txt成功建立向文本类写入15个字节内容cc@cigar:~/_file$ python3 build_new_file.py I like P/home/cc/_file/file/1.txt成功建立
建立或打开文件后,对其进行基本的读写操作
用文件对象write(s)方法写内容 f.write(s) 后返回写入的字节数
用文件对象read(size)方法读内容 f.read(size) size读取的参数,没指定读尽可能大的内容
连续用.read() .write()方法caozuo文件
不建议这样做,因为读取数据不确定性问题
复杂读写文件
基础操作之上,多行操作
一次写入多行
#complex_do_file.py#coding=utf-8nums = ['one','two','three','four','five']t = open(r'/home/cc/_file/file/2.txt','a')for get_one in nums: t.write(get_one+'\n')t.close()
结束标志符
\r
mac
\n
linux
win
一次读一行
#complex_do_file.py#coding=utf-8nums = ['one','two','three','four','five']t = open(r'/home/cc/_file/file/2.txt','a')for get_one in nums: t.write(get_one+'\n')t.close()t1 = open(r'/home/cc/_file/file/2.txt','r')dd = 1while dd: dd = t1.readline() print(dd) cc@cigar:~/_file$ python3 complex_do_file.py #第二次执行,多次执行,重复几次one two three four five one two three four five
f.readline(s)
以列表格式读取多行
f.readlines()
连续读特定字节数量内容
f.readline()有参数读参数,没有参数,读本行f.read()连续读取参数
指定位置读内容
f.tell()返回当前文件可以读写的位置(字节)
f.seek(offset[,whence])重新指定当前要写的位置,
offset
位置偏移量参数
whence
可选,确定起针位置
0
开始位置+偏移量
1
代表当前位置
2
从结尾起针
在指定位置写内容
>>> f3 = open(r'/home/cc/_file/file/2.txt','w')>>> f3.seek(17)>>> print(f3.write('---'))None>>> f3.close()
执行完,原内容丢失,只有在第十七字节处'---'
文件异常处理
#except_file.py#coding=utf-8f_n = r'/home/cc/_file/file/3.txt'flag = Falsetry: f = open(f_n,'r') print(f.read()) flag = Tureexcept: print('打开%s文件出错,清检查!'%(f_n))finally: if flag: f.close() print('文件做关闭处理') else: print('程序关闭') cc@cigar:~/_file$ python3 except_file.py 打开/home/cc/_file/file/3.txt文件出错,清检查!程序关闭
在文件操作代码编写时,添加异常捕捉机制,是针对文件操作代码的第二个标配代码
文件与路径
可以固定,也可动态指定或判断
与路径的相关操作
os模块,,通过.path()的各种方法实现对路径的操作
获取程序的当前路径
os.path.abspath(p)以字符串的形式返回平台绝对路径,P为路径名称,P==.,,代表当前路径
存在Ture
不存在False
判断路径下是否存在文件
os.path.cxist()
存在Ture
不存在False
判断指定路径是否存在文件
os.path.isdirt()
存在Ture
不存在False
建文件夹
os.makedirs()
成功无返回值
不成功抛出OSError
动态路径下建新文件
#path_except_file.py#coding=utf-8import osimport sysget_cur_path = os.path.abspath(os.path.curdir) #获取程序当前路径f_n = get_cur_path+'/pyfile' #在当前路径的子路径下try: if not os.path.isdir(f_n): os.makedirs(f_n)except: print('子文件夹%s建立出错'%(f_n)) sys.exit() f_n = f_n+'/1.txt'flag = False #后期的参数try: f = open(f_n,'w') print(f.write('OK OK!')) flag = True print('文件%s写入正常'%(f_n))except: print('打开文件%s出错,请检查'%(f_n))finally: if flag: f.close() print('文件作关闭处理') else: print('程序关闭') cc@cigar:~/_file$ python path_except_file.py None文件/home/cc/_file/pyfile/1.txt写入正常文件作关闭处理
JSON格式文件
JavaScript Object Notation,Java脚本对应标注符
一种轻量级的数据交换格式
数据共享的标准技术
JSON格式(带格式的字符串)过程叫 序列化
反向转换为python数据叫 反序列化
序列化后可存在文件或数据中,也可通网络传输
JSON格式
py2
JSON常用的两种数据类型
键-值对的集合
对象Object
记录Record
结构Struct
字典Dictionary
哈希表Hash Table
关联数组Associative Array
值的有序列表
大部分语言中的数组 Array
python主要为 列表,元组
JSON与Python间数据转化
JSON数据与Python数据之间的转化 从python开始序列化 从JSON开始行反序列化 python JSON python dict字典 object dict list,tuple列表,元组 array list str字符串 string str int,float等及派生 number(int) int TRUE TRUE TRUE FALSE FALSE FALSE none null none
操作
>>> import json>>> p = {'tom':29,'jack':20,'jim':12}>>> p{'jim': 12, 'jack': 20, 'tom': 29}>>> p_j = json.dumps(p) #python转化JSON>>> p_j'{"jim": 12, "jack": 20, "tom": 29}'>>> j_p = json.loads(p_j) #JSON转化python>>> p_j'{"jim": 12, "jack": 20, "tom": 29}'
JSON所有数据都是字符串
python转JSON
json.dumps()
序列化
JSON转python
json.loads()
反序列化
读写JSON文件
#rw_json.py#coding:utf-8import jsonimport sysdef save_to_json(filename,dicobj): flag = False if type(dicobj) != dict: #只允许保留字典类型数据 return flag try: j_file = open(filename,'a') json.dump(dicobj,j_file,ensure_ascii = True) flag = True except: print('往%s里写数据出错'%(j_file)) finally: if flag: j_file.close() return flag#==========================================def get_to_json(filename): flag = False dicobj = {} try: j_file = open(filename,'r') dicobj = json.load(j_file) flag = True except: print('从%s里读数据出错'%(filename)) finally: if flag: j_file.close() return dicobj#==========================================d_student = {'name':'丁丁','age':'12','birthday':'2006.12.25'}filename = 'student.json'f_ok = save_to_json(filename,d_student)if f_ok: print('学生信息成功保存到%s里'%(filename))else: sys.exit()d_get_s = get_to_json(filename)if d_get_s: print(d_get_s) cc@cigar:~/_file$ python rw_json.py 学生信息成功保存到student.json里{u'age': u'12', u'birthday': u'2006.12.25', u'name': u'\u4e01\u4e01'}
搞错带不带s会导致隐性错误.
dunp(obj,f,ensure_ascii=Ture,...)函数
把python数据写到JSON中
obj参数,数据对象
f参数,字符串形式指明需要存储的文件名,可带上路径,建议加上扩展名(随意)
ensure_ascii参数,默认Ture,只接受ascii表内数据(中文存储时会变成带\u的十六进制) False时,可接受其他非ascii字符
dump...
load(f,...)
从JSON中读文件
f参数,字符串指明需要存储的文件名
load....
dumps是将dict转化成str格式，loads是将str转化成dict格式。dump和load也是类似的功能，只是与文件操作结合起来了。
特别注意
XML格式文件
初识
带格式标准的标记语言,可以以文件格式共享和处理数据
定义了一组规则,以人类可读,和机器可读的格式对文档进行编码
数据结构
树形结构的XML数据格式
待记录的表
仓库的部分商品 一级分类 二级分类 商品名称 数量 价格(元) 淡水鱼 鲫鱼 18 8鱼 咸水鱼 .... 温带水果 猕猴桃 10 10水果 热带水果 ....
XML数据结构
根元素
必须包括更文档,实例中为 <storehouse>...</storehouse>
子元素
除了根元素,其他成对出现的成员都是子元素,例如<goods>...</goods> <title>...</title>子元素可以嵌套子元素 一层一层
标签
带有''<>''标志的,有开始标签,结束标签
嵌套元素采用四个空格等长的缩进
元素中的属性
提供了元素以外的其他信息,相当于给同级元素的分类标签例如:<goods>...</goods>提供了 category = "fish" 的属性格式为:<goods category = "fish">...</goods>
文本
标签中间的信息
树形结构主要包括元素,属性,文本,三要素
还可以是多根元素的平行结构
生成XML文件
#build_xml.py#coding=utf-8..... cc@cigar:~/_file$ python3 build_xml.py 往/home/cc/_file/file/storehouse.xml写内容完成
技巧注意
为确保后续xml内容可供读取,open函数那里明确指定 encoding='utf-8' 默认为None,为ascii字符,否则读取将报错
严格遵守数据格式
不可有多余的空格
xml模块
提供了两个最基本和广泛应用的API接口
处理相应的xml文件
SAX
(Simple API for XML)简单处理API是在解析XML时的过程中通过触发一个个的事件,调动用户定义的回调函数处理XML.也可以读取部分内容文件
DOM
(Document Object Model)文档对象模型一个万维互联网的协议,其中整个文件被读入内存,并以树的结构形式存储以表示XML的特征
处理大文件时,DOM更有优势
单用DOM在小文件上,可以真正主动清除内存占用的资源
SAX只读DOM可读可写相互补充,经常用于大型软件
SAX读XML文件
python在 xml.sax 模块下为操作xml提供所示函数
make_parser(parser_list=[]) 建立并返回一个SAX解释器的XMLReader对象parser_list若提供,则指定第一个解释器的模块名称 parse(filename_or_stream,handler,error_handler=handler.ErrorHandler()) 建立一个SAX解释器,解析xml文档 filename_or_stream为指定的xml文件名; handler为SAX的ContentHandler实例对象; error_handler参数,若设置新值,必须是一个ErrorHandler对象 parseString(string,handler, error_handler=handler.ErrorHandler())和parse函数类似,但是从string参数提供的字符串解析xml SAXException(msg,exception=None) 封装了xml的相关错误或警告,但xml解析出错, 提供错误信息,msg是提供出错描述信息
用SAX解析XML文档<涉及两部分>
解释器
负责读取XML文档,并向事件处理器发生器发送事件,如元素的开始和结束事件;进而事件处理器负责对对应的事件作出响应,对传递的数据进行处理
流程
parser = xml.sax.make_parser() #创建一个解释器的XMLReader 对象parser.setFeature(xml.sax.handler.feature_namespaces,0) #关闭命令解析命令hand = GetStorehouse() #建立事件处理器实例parser.setContentHandler(hand) #为解释器设置事件处理器实例parser.parse('/home/cc/_file/file/storehouse.xml') #正式解析指定xml文件内容print(get_record) #打印全局列表的获取结果
子主题
事件处理器
由ContentHandler类来实现,该类包括 以下主要事件调用方法
ContentHan方法dler实例主要事件回调 .characters(content) 解释器将调用此方法来报告每个字符数据块.SAX可能将所有连续的字符数据返回单个块中 用或着将其分割为多块 单个事件的所有字符必须来自同个外部实体以便信息有 contentc参数为获取字符数据,有这么几种情况:从行开始,遇标签之前存在字符,content为这些字符串. 从一个标签到下一个标签,存在字符,content为这些字符串 从一个标签,到结束符之前,存在字符,content为这些字符串.startDocument() SAX在文档启动解析时,调用一次.endDocument() SAX解析到文档结尾时,调用一次.startElement(name,attrs) 在文件模式下,遇到xml开始标签时,调用一次,name是标签名字,attrs是标签属性字典.endElement(name) 在文件模式下,遇到结束标签时,调用一次,name是标签名字
例子
#sax_parse_xml.py ['淡水鱼', '鲫鱼', '18', '8', ' ', '温带水果', '猕猴桃', '10', '10', ' ', '\n']
DOM读写XML文件
文件对象模型 是可扩展标记语言的标准编程接口
解释器在解析完XML文档后,一次性读取整个文档,把内容保存在一个树结构内,之后利用DOM提供的不同函数对内容读取还是修改,还可以把修改过程写入XML文件
DOM解释器
xml.dom.minidom子模块
最小的解释器功能,主要对xml文档的读、修改在内存
xml.dom.minidom.parse(filename_or_file,parser = None,bufsize = None)
该解释器解析成功,返回XML对象filename_or_file为指定的xml文档(可带路径
xml.dom.pulldom子模块
实现对XML文档的读取,修改,(在内存),建立操作
xml.dom.pulldom.parse(stream_or_string,parser = None,bufsize = None)
该解释器解释成功,返回XML文档的DOMEEentStream对象
DOM相关函数
有了DOM文档对象,可以通过属性,方法访问XML文档的各个部分
DOM对象函数接口分类
接口对象名 功能说明DOMImplementation 提供DOM对象底层功能实现Node 文档中大多数对象的基本接口NodeList 一系列节点的接口 DocumentType 关于处理文档所需要声明的信息Document 整个文档的对象Element 文档层次结构中的元素节点Attr 元素节点上的属性值节点Comment 在文档中表示评论Text 文档中节点所包含的文本内容ProcessingInstruction 处理指令表示
DOMImplementation 提供DOM对象底层功能实现
Node 文档中大多数对象的基本接口
Node.childNodes
返回当前节点所含的节点列表
只读
NodeList 一系列节点的接口
DocumentType 关于处理文档所需要声明的信息
Document 整个文档的对象
Document.documentElement
返回文档所有函数
Document.getElementsByTanName(tagname)
搜索具有特定元素类型名下的子函数,返回元素合集
Element 文档层次结构中的元素节点
Element.hasAttribute(name)
如果具有指定name命名的属性,返回true
Element.getAttribute(name)
以字符串的形式返回指定name命名的属性的值;若不存在,则返回空字符串
Element.setAttribute(name,value)
设置name标签指定的值
Element.removeAttribute(name)
删除name标签指定的值
Attr 元素节点上的属性值节点
Comment 在文档中表示评论
Text 文档中节点所包含的文本内容
ProcessingInstruction 处理指令表示
DOM实现对XML文件的解析
API应用程序编程接口)是一些预先的函数
用到的模块
sys
os
json
三酷猫自建数据库
子主题
图形用户界面GUI<图形用户接入口
初识图形用户界面
组件
代表某一类功能的
窗体
组件依托与窗体<也就是窗口
事件
窗体和组件受外界刺激,产生的各种操作动作
属性
窗体,组件的可读写数据相关对象
方法
窗体,组件自带可以调用的函数
相关开发工具
tkinker
自带GUI开发包
PyGObject
开源,支持多端
PyGTK
开源,支持多端
PyQt
部分开源,多端
PySide
开源,
wxPython
跨平台GUI开发包
tkinker 开发包
窗体
建立窗口界面程序
关于组件
主要存放于tkinter,tkinter.ttk,tkinter.tix,tkinter.scrolledtext模块下
窗口组件的定位
.pack(o)
side='top'
缺省,默认
side='bottom'
side='left'
side='right'
,
padx,pady默认单位像素
padx='1m'
c厘米
m毫米
i英寸
p打印机的点=1/27英寸
,
anchor=''
w左对齐
e右对齐
n顶对齐
s底对齐
nw左顶对齐
sw左底对齐
se右底对齐
ne右顶对齐
center中间对齐 默认
常见的事件类型
鼠标事件
<Button-1>
<Button-2>
<Button-3>
触发鼠标左1中2右3键时,触发该事件,Button可用ButtonPress代替
<B1-Motion>
B1为左键,移动鼠标指针B2为中键,移动鼠标指针B3为右键,移动鼠标指针
<ButtonRelease-1>
左键松开时,鼠标指针的当前位置会以事件实例的xy坐标成员形式传给回调函数
<Double-Button-1>
左键双击,触发事件
<Enter>
指针接触组件,触发事件
<Leave>
鼠标指针离开组件,触发事件
键盘事件
<FocusIn>
焦点切换到当前组件,触发事件
<FocusOut>
焦点离开当前组件时(切换到另一组件),触发事件
<Return>
使用者按Enter键,可映射所有按键
<Key>
按任何键,都会以event对象的char成员递给callback对于特殊按键会是一个空字符串
a
输入a,所有可打印字符都可以这样用,空格<space>和少于<less>例外注意:::1映射1 <1>是鼠标映射
<Shift-Up>
用户按住shift+up,可以使用像alt+shift+control一样的各种组合
<Configure>
改变组件大小,(某些是位置),新形状以event对象中width与height属性的形式,传给回调函数
常见的属性对象
有些组件没有个别属性,判断组件支持属性,需
>>> import tkinter>>> help(tkinter.Button)
background(bg)
bg='black'设置背景色
foreground(fg)
fg='black'设置子体色
highlightcolor
用法同上组件框架高亮显示
highlightbackground
用法同上高亮显示背景色
black,green,red...
highlightthickness
highlightthickness=2.5设置高亮框架线粗
非负浮点数(默认像素
relief
relief=RAISED设置组件3D外观
RAISED FLAT SOLIDSUNKEY RIDGE GROOVE
takefocus
takefocus=YES决定窗口在键盘遍历时,是否接受焦点
1,0,YES,NO
wideth
wideth=32设置组件横向宽
整数,小于等于0则自适应
font
font='Arial'设置组件显示字体
Arial...
cursor
cursor=man设置鼠标指针格式
Arrow,man,boat...
.bind()公共方法,检测对象是否发生事件
.bind(sequence,func,add = '')sequence代表事件类型的字符串funce(x)一个自定义函数,x用于传递对象的事件实例,在事件发生时被调用,统称,回调函数add可选,为 ''或'+' ''表示这个绑定要替换其他任何绑定 '+'表示这个绑定要被添加到此事件类型的函数列表内
基本组件
组件清单
Button
按钮,鼠标单击时执行事件
Label
标签,输入文本或图表,提示
Entry
单行文本输入框
Text
多行文本输入框
Checkbutton
复选框按钮
Radiobutton
单选按钮
Frame
框架,屏幕显示矩形区域,多用于其他组件容器
LabelFrame
标签框架容器,多用复杂窗口布局
Listbox
列表框
Scrollbar
滚动条
Scale
刻度条,为输出限定范围的数字区间
Message
信息提示对话框
Spinbox
输入控件,于Entry类似,但可以指定输入范围
PanedWindow
窗口布局管理插件,包含一或多个子控件
Toplevel
子窗口容器控件,提供一个单独对话框
Menu
菜单,显示菜单栏,下拉菜单,弹出菜单
Canvas
画布
使用案例
#base_easy.py
经验
.pack()定位方式下后一组件位置相对前一个组件而言
可以利用Frame,LabelFrame容器组件,把一组相同方向的组件一起定位,也可考虑容器嵌套,界面更加整齐
在设置界面时,鼓励采用相对位置进行设置,避免像素绝对位置定位,当改变窗体i大小时,会大乱
变量子类实例,可用.get()获取,,,也可.set()设置新值var = StringVar()v = IntVar()...
Menu组件及messagebox组件的使用案例
下拉菜单
弹出菜单
实例
经验
继承类处的Frame组件可替换为其他组件类,如Entry,Label
messagebox组件,在组件中经常需要被使用,单独存放在messagebox子模块下
messagebox组件提供如下提示信息方法
xxx('---','----')
showinfo
showwarning
showerror
askokcancel
askquestion
askyesno
asktrycancel
askyesnocancel
Canvas(画布)组件使用案例
可以绘制图形,创建图形编辑器,实现各种自定义组件
提公共不少以坐标系为定位规则的画图方法
1>create_rectangle(x0,y0,x1,y1) x0,y0为左上坐标点数 x1,y1为右下坐标点数 宽=X1-X0,高=Y1-Y02>create_line(x0,y0,x1,y1) x0,y0为开始坐标 x1,y1为结束坐标3>create_arc(x0,y0,x1,y1) 分别为圆弧的左上和右下坐标4>create_oval(x0,y0,x1,y1) 围成的矩形区域内的圆形或椭圆形5>create_polygon(x0,y0,x1,y1,.......) 开始坐标,第一,二,三.......坐标,依次连接形成多变形图案阿
PhotoImage组件及案例使用
可以将GIF格式图片在其他具有窗体结构的组件上呈现
案例
ttk子模块下组件
Combobox下拉框组件
Notebook页签组件
一个窗体页面上,具备多页分类步设组件和显示更多内容作用,避免频繁切换不同窗体的麻烦,提高软件操作效率
Progressbar组件
提示安装进程进度
Sizegrip可拉伸窗体组件
Treeview结构化数据的显示和处理组件
一种一行是一行
一种是树状结构
tix子模块下组件
组件类型
DirList
路径及子路径里列表框,可供选择路径
DirTree
树状结构显示路径框,可供路径选择
案例
DirSelectDialog
对话框选择文本路径
DirSelectBox
路径选择框,可记忆路径,方便用户快速选择
ExFileSelectBox
可嵌套的文件选择框
FileSelectBox
文件选择框
FileEntry
可输入文件名的输入框
文件选择类组件
ButtonBox
多按钮组合操作 类似messagebox
案例
该模块对tkinter,ttk进一步补充,完善
线程与进程.................
简介
进程
类似任务
线程
轻量级的进程
守护线程
周期执行,等待,处理发生事件
多线程模块
_thread(thread)模块
面向底层技术,有缺陷,仅保留_thread
threading模块
取代thread模块,提供了更多的高级线程相关功能
函数
active_count()
返回当前活动的线程对象的数量
current_thread()
返回当前线程对象
get_ident()
返回当前线程ID,这是一个非零整数
enumerate()
枚举函数,返回当前活动的搜有线程对象(以列表形式)
main_thread()
返回主线程对象,正常情况下,主线程为python解释器启动的线程
settrace(func)
为从线程模块启动的所有线程启动跟踪功能,func为自定义函数名
setprofile(func)
为从线程模块启动的所有线程设置配置文件功能,func为自定义函数名
stack_size([size])
返回创建新线程时使用的线程堆栈大小,size可选参数为0~~32768(32K)范围的数值,默认为0
常量
treading提供TIMEOUT_MAX常量
Lock.acquire()RLock.acquire()Condition.wait()
爬虫.......................
requests库
方法
.request()
构造一个请求,支持以下各方法的基础方法
.get()
获取HTML网页的主要方法,对应HTTP的GET
.head()
获取网页头信息的方法,对应HTTP的HEAD
.post()
向HEML网页提交POST请求的方法,对应POST
.put()
提交PUT请求的方法,
.patch()
提交局部修改的申请
.delete()
33个保留字
异常
try
except
finally
raise
用来主动抛出异常的关键字
布尔
False
Ture
逻辑
and
not
or
成员
is
in
条件
if
elif
while
for
else
break
continue
函数
del
global
函数内修改全局变量前声明
lambda
匿名函数关键字
return
nonlocal
闭包变量声明后修改i,变局部变量
import
as
def
from
类
class
Nole
空
with
yield
pass
assert
python库
标准库
datetime 时间日期操作方法
Datetime模块独立存放于/lib/datetime.py内
部分方法
datetime.now()
获得当天日期,时间
datetime.date(t)
获得当天日期
datetime.time(t)
获得当天时间
datetime.ctime(t)
获取"星期,月,日,时,分,妙,年"格式字符串
datetime.utcnow()
获取当前UTC日期时间
datetime.timestamp(t)
获取当天时间戳(UNIX时间戳)
datetime.fromtimestamp(t)
根据时间戳返回UTC日期时间,t为时间戳浮点数
datetime.combine(date1,time1)
绑定日期,时间,生成新的datetime对象
datetime.timetuple(t)
把datetime对象所有属性转换为时间元组形式
datetime.strptime(dt_str,sf)
根据日期字符串和指定格式生成新对象
t.strftime(dt_str)
获取自定义格式日期时间字符串,dt_str为指定格式
t.isocalendar()
获取ISO形式的日期(元组)
t为datetime实例对象
.seconds()
时间差的秒数<忽略微妙,天数
.total_seconds()
两个时间的总差
.strftime().strptime()符号及意思
%
a
本地简化星期名称
A
本地完全星期名称
b
本地简化月份名称
B
本地完整月份名称
c
本地相应日期,时间表示
d
0-31月内中的一天
H
0-23小时
I
12小时制的24小时
j
000-366的一天
m
0-12月份
M
00-59分钟
p
本地A.M.或P.M.的等价符
S
00-59秒
U
00-53一年中的星期数,星期天为星期的开始
w
0-6星期天数,星期天为第一天
W
00-53一年中的星期数,星期一为星期的开始
x
本地相应日期
X
本地相应时间
y
00-99两位数的年份
Y
0000-9999四位数年份
Z
当前时区名称
%
%
math数学计算函数
部分函数
trunc()
注意和//区别
对浮点数直接舍去小数,返回整型
round()
四舍五入,取整型
ceil()
对浮点数取一个大于等于的最小整数,返回整型
fabs()
对一个数绝对值,返回浮点数
abs()
与被返回值格式一致
fsum()
对迭代器里的(元组,列表等)集合求和,返回浮点数
sum()
与被返回值格式一致
内置函数,非math库
random生成一系列随机数计算均值,正态(高斯)分布,对数正态分布,伽玛(Gamma)和贝塔(Beta)分布等
部分常见函数
random()
生成一个基于0.0<=x<1.0的浮点数
uniform(a,b)
指定范围内获取一个随机浮点数
triangular(low,high,mode)
返回三角分布的随机数,上下限,mode为中值
betavariate(alpha,beta)
求Beta分布的随机数
os为操作系统的访问提供了相关支持
几种功能
文件的相关操作
系统访问Path路径
shell操作
Linux扩展属性操作
流程管理
CPU等硬件相关信息获取
基于操作系统的随机数的操作
与操作系统相关的一些系统常量的提供
常用函数
environ()
获取操作系统里的环境变量
getcwd()
获取表示当前工作路径的字符串
system(command)
在子shell中执行命令(command为字符串命令)
urandom(n)
获取一个适合加密使用的n字节大小的随机数 字符串
sys与解释器密切相关的变量和函数
常见函数
path()
获取模块文件搜索路径的字符串,或临时指定新搜索路径
platform()
操作系统标识符判断函数
操作系统 标识符Linux 'Linux'Windows 'win32'Windows/Cygwin 'cygwin'Mac OS 'darwin'
getwindowsversion()
返回描述当前正在运行的Win版本信息的元组
time与datetime很相似
time中特有的部分函数
sleep(s)
暂停所执行的调用线程达到给定的秒数,再恢复代码正常的执行
clock()
以当前CPU处理器时间以秒为单位的浮点数
strftime(str_f)
据带时间格式符号的字符串时间,返回字符串
time()
自纪元(Epoch)年起以秒为单位后返回浮点数时间
爬虫
HTTP协议
与https简单的区别
超文本传输协议HTTP协议被用于在Web浏览器和网站服务器之间传递信息，HTTP协议以明文方式发送内容，不提供任何方式的数据加密，如果攻击者截取了Web浏览器和网站服务器之间的传输报文，就可以直接读懂其中的信息，因此，HTTP协议不适合传输一些敏感信息，比如：信用卡号、密码等支付信息。为了解决HTTP协议的这一缺陷，需要使用另一种协议：安全套接字层超文本传输协议HTTPS，为了数据传输的安全，HTTPS在HTTP的基础上加入了SSL协议，SSL依靠证书来验证服务器的身份，并为浏览器和服务器之间的通信加密
超文本传输协议
是一个基于"请求与响应"模式的,无状态的应用层协议
HTTP协议采用URL作为定位网络资源的标识,URL格式: http://host[:port][path]
host:合法的主机域名或IP地址port:端口号,缺省端口为80path:请求资源的路径
例子:http://www.baidu.comhttp://220.181.111.188/dutyURL理解:通过http协议存取网络路径,一个URL对应一个数据资源
HTTP协议对资源的操作
"盗亦有道"
爬虫的尺寸
爬网页,
规模小,数据量小,速度不敏感
requests库
爬网站
中规模,数据较大,速度敏感
Scrapy库
爬全网
大规模,建立搜索引擎,速度非常关键
对爬虫的限制
来源审查 : 判断User-Agent进行限制
检查来访HTTP协议头部的user-agent域,只响应浏览器或友好爬虫访问
发布公告 : Robots协议
Robots协议的遵守方式
实例
#coding:utf-8 import requests#url1 = 'https://item.jd.com/100000381451.html'#京东购物# try:# r = requests.get(url1)# r.raise_for_status()# #若返回200,则;否则,报错,except# r.encoding = r.apparent_encoding# print(r.text[:1000])# except:# print('爬取失败') #url2 = 'https://www.amazon.cn/dp/B00C7D7XMQ/ref=Oct_DLandingS_rdp_eb0de913'#亚马逊页面爬取# try:# kv = {'user-agent' : 'Mozilla/5.0'}# r = requests.get(url2,headers = kv)# #网页加入路径查询,拒绝爬虫访问,修改头部信息,模拟浏览器访问# r.raise_for_status()# r.encoding = r.apparent_encoding# print(r.text)# except:# print('爬取失败') # #向百度,360提交关键词# keyword = 'python'# try:# kv = {'q' : keyword}# r = requests.get("http://www.so.com/s",params = kv)# print(r.request.url)# r.raise_for_status()# print(len(r.text))# except:# print('爬取失败') # import os# url = 'https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1585166085350&di=7d2d924aed77209a1e56617dae10587e&imgtype=0&src=http%3A%2F%2Fimg.pconline.com.cn%2Fimages%2Fupload%2Fupc%2Ftx%2Fitbbs%2F1407%2F22%2Fc11%2F36571563_1406002014149.jpg'# root = "/home/cc/_file/picture/"# # path = root + url.split('/')[-1]# path = root + '1134545.jpg'# try:# if not os.path.exists(root):# os.mkdir(root)# if not os.path.exists(path):# r = requests.get(url)# with open(path,'wb') as f:# f.write(r.content)# f.close()# print('文件保存成功')# else:# print('文件已存在')# except:# print('爬取失败') #IP地址爬取url = 'https://ip.tool.chinaz.com/'try: r = requests.get(url + '202.204.80.112') r.raise_for_status() #r.status_code r.encoding = r.apparent_encoding print(r.text[-500:])except: print('爬取失败')
实例一 : 京东商品
实例二 : 亚马逊商品页面的爬取
实例三 : 百度,360搜索关键字提交
实例四 : 网络图片的爬取和存储
实例五 : IP地址归属地的自动查询
Beautiful Soup库
解析树状标签库的能手
解析html文件
元素
Tag
标签,最基本的信息组织单元,分别用<>和</>标明开头和结尾
Name
标签的名字<p>...</p>中的'p' 格式为<tag>.name
Attributes
标签的属性,字典型式, 格式为<tag>.attrs
NavigableString
标签内非属性字符串 <>...</>中的字符串 格式为<tag>.string
Comment
标签内字符串的注释部分,一种特殊的comment类型
对标签树施行遍历
下行遍历
子主题
requests库
方法
.request()
一法括六法
构造一个请求,支持以下各方法的基础方法
.get()
获取HTML网页的主要方法,对应HTTP的GET
.head()
获取网页头信息的方法,对应HTTP的HEAD
.post()
向HTML网页提交POST请求的方法,对应POST
.put()
向HTML网页提交PUT请求的方法,
.patch()
向HTML网页提交局部修改的申请
区别
若有一组好多类型的数据,.patch()可以只修改局部一种数据,而.put()必须将所有类型数据提交, 才可达到修改某一种的要求
.delete()
向HTML网页提交删除请求
方法用法
r = requests.request(method,url,**kwargs)
r = requests.request('get',url**kwargs)
r = requests.get(url,params = None,**kwargs)
url服务器资源对象<连接>params额外参数,字典和字节流格式,可选
**kwargs12个控制访问参数
12个kwargs可选参数
form
json
JSON格式数据,作为request的内容
headers
字典,HTTP定制头
cookies
字典或CookieJar,request中的cookie
auth
元组,支持HTTP认证功能
files
字典类型,传输文件
fs = {'file' : open('data.xls' , 'rb')}
proxies
字典类型,设定访问代理服务器,可以增加登录认证
allow_redirects
默认为True,重定向开关
stream
默认为True,获得内容立即下载开关
verify
默认为True,认证SSL开关
cert
本地SSL证书路径
timeout
设定超时时间,单位为秒
data
字典,字节或文件对象,作为request的内容
params
字典或字节序列,作为参数增加到url中
Response对象属性
r.status_code
请求返回状态,200成功,404失败
rtext
响应内容的字符串形式,即url的页面内容
r.encoding
从HTTP header中猜测响应内容的编码方式
r.apparent_encoding
从内容中分析出的响应内容编码方式(备选)
r.content
HTTP响应内容的二进制形式
爬虫网页的通用代码框架
网络连接有风险异常处理很重要
异常
requests.ConnectionError
网络连接错误,如DNS查询失败,拒绝连接...
requests.HTTPError
HTTP异常错误
requests.URLRequired
ULR缺失异常
requests.TooManyReadirects
超过最大重定向次数,产生异常
ConnectTimeout
连接远程服务超时异常
requests.Timeout
连接超时,产生超时异常
框架代码