python数剧类型以及理论总结·
Python
目录
编程语言... 2
编译型特点... 3
解释型特点（一行一行解释）... 3
python解释器分类... 3
编程语言思想分类（面向对象和面向过程）... 4
Python优点... 4
Python缺点... 5
Python标识符命名规定... 5
变量名命名规则和使用... 5
数据类型... 6
字符串... 7
字符串特点... 7
元组... 18
元组内置函数... 18
列表... 20
元组和列表的区别... 26
集合... 26
字典... 31
python内置函数... 37
数值类型... 42
赋值运算符... 42
Python算术运算符... 43
比较运算符... 43
赋值运算符... 44
用于判断... 44
逻辑运算符... 45
for 循环... 46
Python九九乘法表... 46
消除重复数据... 47
冒泡排序... 48
质数之和... 48
水仙花束... 49
选择法排序... 49
乘阶之和... 50
Python函数... 51
命名函数步骤组成... 51
函数书写格式... 51
函数使用... 52
return的作用... 53
函数全局变量和全局变量区别... 53
函数参数类型... 53
匿名函数定义：... 57
Python：读写txt文件，对文件进行操作... 57
函数嵌套... 59
Python面向对象、分为类和对象... 59
面向对象书写格式... 59
2 初始化方法... 62
类和对象属性的区别... 65
面向对象特点... 65
单继承例子... 66
面向对象------多态... 67
连接mysql数据库步骤... 68
python的第三方库cmd下载工具... 69
1 操作excel表格... 70
1：import xlrd 读取文件... 70
写入数据... 73
OS内模块作用与计算机进行交互... 74
时间模块... 83
Python操作数据库... 87
Python连接linux系统... 92
Python正则表达式... 94
模块，包，库的区别... 98
爬虫定义... 98
爬虫实例... 99
爬取图片... 100
python发送邮件步骤... 102
带附件的邮件发送... 105
编程语言
C、c++、java、python、php、shell
编译型特点
1 一次性的编译成平台相关的机器语言文件，运行时脱离开发环境，运行效率高
2与特定平台相关，一半无法移植到其他平台
3现有的c、c++都属于编译语言
解释型特点（一行一行解释）
1解释型语言每次运行都需要将源代码解释成机器码并执行，效率低
2只要平台提供相应的解释器，就可以运行源代码，所以可以方便程序移植
3 python属于解释型语言
python解释器分类
1cpython：是将python解释称c语言的字节码
2jpython：是将python解释成java语言的字节码
3pypy：加速解释python 提高效率
编程语言思想分类（面向对象和面向过程）
1面向过程：以过程为中心的一种编程思想一步一步按顺序实现解决问题的步骤
特点
性能高，不易扩展
2面向对象：以对象为中心的一种编程思想将函数分类封装，使开发更高效
特点：易扩展，易于维护，性能低
注面向对象（将整个看成一个）
Python是一种面向对象的解释型的高级的计算机程序设计语言
应用领域：自动化测试、爬虫、人工智能
Python优点
简单易学、免费开源、跨平台性（前提有相应解释器）、可移植性、丰富的库、规范的代码、可扩展性（）
Python缺点
运行速度慢、不能加密
标识符在机器语言中是一个允许被作为名字的有效字符串。Python中标识符主要体现在变量，函数，类模块，对象等的命名
Python标识符命名规定
1只能由字母和数字下划线组成
2 标识符不能以数字开头，以下划线开头的具有特殊意义，使用注意
3不能命名成python中的函数
4标识符区分大小写
变量名命名规则和使用
1变量名只能包含字母、数字、下划线、变量名可以以字母或下划线打头，但不能以数字开头
2变量名不能包含空格，但可以使用下划线来分割其中的单词
3不要将python关键字和函数名作为变量名，既不要使用python中用于特殊用途的单词
4变量名应简短和具有描述性
5慎用小写字母i和大写字母o
6pythin支持多变量命名
例如 a，b，c=1,2,3
数据类型
1字符串str
2数值int
3列表list
4集合
5元组
6字典
判断数据类型相等
if type(j)==list:
字符串
1在python中用单引号括起来的都是字符串，其中的引号也可以是双引号，也可以是单引号
2能够在字符串中包含引号和撇号
字符串特点
1不可变
2支持索取（通过下标位置取对应数据）
格式（ [ ]）
3支持切片（从开始位置取，结束位置不取）
例如a=’small’
Ptint(a[0:3])
结果sma
一个冒号的时候：冒号在前代表从开始取，冒号在后代表开始值取到最后
两个冒号是：冒号在前，以数字的个数分组支取组中得第一个。
例如 a=’abcdse’
Print(a[1::2])
结果为bde
注1代表下滑数是1的显示 2代表以几个一组
冒号在后，代表从开始值取到最后。冒号前的数字代表一组中的位置，冒号后的数字代表取几个字符为一组
例如a=’abcdse’
Print(a[1::])
结果为bcdse
注 取从序号是1的开始到最
字符串的使用
1 find（内容）查找字符串的内容
从左往右找 找到显示下标位置
2 求字符串中最大的，根据ascll码算的
Max
3 求字符串中最小的根据ascll码算的
Min
4列表数据翻转 print（a[::-1]）
5将字符串小写变大写
upper() 前面加变量名如a.upper()
例如a=’abcd’ 或 a=’abcd’
b=a.upper() print(a.upper())
Print(b) 结果为ABCD
结果为ABCD
注 a.upper()是格式 括号里不填内容
6 将字符串大写变小写
lower()
例如a=’AScd’ 或 a=’ABcd’
b=a.lower() print(a.lower())
Print(b) 结果为abcd
结果为ascd
注格式一样
6 将字符串首个字母大写
title()
例如 a=’abcd’
b=a.title() 或print(a.title())
Print(b)
结果为Abcd
7 将字符串小写变大写，大写变小写
swapcase()
例如 a=’aBCd’
b=a.swapcase()
Print(b)
结果为AbcD
8 将字符串的中字符更改为其他数据
replace(‘内容’，’替换的内容’，’替换数量’)例如 a=’123412’
b=a.replace(‘1’,’q’,’2’)
Print(b)
结果为q234q2
扩展加变量 可以变化用
9 以括号中的数据为分隔符，将字符串分割成列表 转列表
Split(‘分隔符’) 括号里面 ，加数字指定分割几次
例如a=’cadacd’
10判断字符串是否以括号中的元素开头
Startswith(‘开头内容’)
例如一
例如二
11 判断字符串是否以括号中的元素结尾
Endswith(‘结尾内容’)
例如一
例如二
如果是以括号内容开头的显示true 如果不是显示false
12 以某个数据列表连接起来形成新的字符串
分隔符 join（元素序列）例如 ‘-’，join（a）
13 格式化字符串 { }站位（添加新的内容到字符串中）
format（内容）
将{ }中添加为（内容）
14 %占位：%s能填充所有，%d填充数字
格式:’%s 填充的内容 ’%（变量名）
%d填充数字
格式化字符串
X=”dfdfdfdfdfd”
Print(f”你好{x}”)
15去除字符串中左右空白格键strip（）
去除字符串中左边空格键lstrip（）
去除字符串中右边空格键rstrip（）
16 isdigit（）判断是否全部是数字
17 istitle（）判断是否为标题（只有首字符大写）
18 isupper判断字符串是否全部为大写
19 islower判断字符串是否全部为小写
20 isalnum判断字符串中所有的字符由数字或字母组成，是返回true不是返回false
21 isalpha判断字符串中所有的字符全部是字母 是返回true不是返回false
22 isspace判断字符串中只包含空格白字符， 是返回true不是返回false
空白字符（空格、\n、\t、\r、回车）
23 Isdecimal判断字符串是否包含十进制数字，是返回true不是返回false
回文格式 aba、 abba
元组
元组：是一组数组的集合数据与数据之间用逗号隔开用（内容）用小括号表示
元组特点1不可变 支持重复输出
2 支持索取
3支持切片
元组内置函数 共两个
翻转（：：-1）
1统计括号中的数据在元组中有多少个
Count（数据）
例如
2统计查看括号中的数据在元组中的下标位置
index（数据）
查看数据类型
查看数据类型
type（）
列表
一组数据的集合，以中括号为标识，中间用逗号隔开
[字符串、数字、列表、字典、集合、字典 ]
特点
1有序的可变的 列表中的格式不能赋予名字
2支持索取 格式为 a=['a','b','c']
a.pop(1)
print(a)
3支持切片
1列表添加数据，默认添加到列表最后
列表名.append（数据）一次只能一个， 不能赋予变量名
2列表添加数据到指定位置，第一个是下标号，第二的是数据insert（X，数据）
3删除括号中的数据
列表名.remove（删除的数据）
支持删除多个
4列表根据下标位置删除数据
Pop（下标号）
5列表排序 sort()
reverse
6列表数据翻转，如果在执行一次数据再次翻转回来 reverse（）
7将b列表中的数据更新到a列表
列表名.extend(b)
8统计括号中元素在列表中的个数
Count（元素）
9查询括号中的元素在列表中的下标位置
index（元素）
10清空列表
列表名.Clear（）
11复制列表
列表名.copy()
浅复制和深复制
元组和列表的区别
1元组是不可变的，列表是可变的
2元组是以小括号为标识，以逗号隔开、列表是以中括号为标识以逗号隔开
3元组中只有一个元素时，元素后面加逗号，才是元素，列表不需要加
集合
一串数据的集合，以大括号{}为标识，以逗号隔开特点1无序的，2不可重复的，3可变的里面元素为;字符串、元组、数值 set()空集合1添加数据只能添加一个数据add（数据）
2删除一个数据remove（内容）如果没有就报错
3随机删除一个数据pop()
4指定删除一个元素discard（内容）
5 update（‘b集合’）:将集合B中的元素添加到集合A里
7 copy（）：复制集合
8 clear（）：清空集合
9 difference(集合b)求集合b相对于集合a的差集
10 difference_update 删除差集11 intersection(集合b)求集合a、b的交集，没有交集返回空集
12 intersection_update(集合b)删除不是交集的部分
13 isdisjoint（集合b）判断集合a、b是否存在交集不存在返回true存在返回false
14 issuperset（‘集合B’）：判断集合B中的元素是否全部在集合A中，是返回True，不是返回False
15、symmtric_difference（）：找出两个集合中不相同的元素，返回一个新集合；
16、symmtric_difference_update(集合B)：对集合A操作，先清空集合A，再将集合A、B不同的元素放到集合A中；
17、union（‘’集合B）：求集合A，B的并集，返回一个新的集合，重复的元素只出现一次；
18、列表推导式
Print（[i for i in range() if 条件]）
19 内置库 导入模块import random
random randint（1,10）随机出现1到10的数字 可以用来选择取下标位置
字典
一组数据的集合，以大括号为标识，里面的数据是键对值格式{key:value}key是键value是值
特点：可变的、无序的、键必须是唯一（包含字符串、元组、数值）
值可以一个或多个（数值、字符串、元组、集合、列表、字典类型）
1 Clear（）删除全部
2 Copy 复制字典
3 获取所有的键名可以用于循环
Keys（）
4 获取所有的值values（）可以用于循环
5 单独获取一个时即print（变量名[键名]）
6 单独获取一个时即print（a.get(键名)）
7 获取所有的键值对
items（）
8 itmes可以循环取值
9 添加数据（没有数据就添加，有数据就更改）
名字[‘键名’]=’值’
10删除一个键 pop(‘键名’) 如果删除的键不存在就会报错
11默认删除最后一个键 popitem()
12 求键名的个数 len（变量名）
13 fromkeys(x，y)新建字典
Seq 传入一个有序的对象，列表，字符串，元组
Values 设置字典键对应的值，也可以不写none代表空
7更新数据，将字典b中的数据更新到新的a字典 update（）
8当字典或集合都是空的时候则字典用{ }或用dice()集合用（）
9 Setdefault（键，默认值）向字典中添加键值对并设置默认值 键存在不更改键值
命名空集合时，默认的是字典的数据类型
9去除重复的数据 set（）
python内置函数
max最大 min最小
numerate(内容) 生成编号
numerate(内容) 生成编号
2统计元素个数 len（列表名）或数组名
空格也算元素
3将列表中每个数据的下标位置和数据对应显示 enumerate（）
4十进制转十六进制hex（内容）
5十进制转八进制进制oct（内容）
6十进制转二进制bin（内容）
7任何进制转十进制int（内容如下）
8将数字转换为ascll表中的字符
Chr（数字）
9 ascll表中的字符转换为数字
Ord（内容）
10对数字求和sum（）不能用大括号
1种方法
2种方法
11整数求余divmod(数字，数字)
例如 a,b=divmod(16,8)
a代表除结果整数
b代表余数
12数据翻转 （a[::-1]）
数值类型
1 int 整数
2float 浮点型（小数）
3布尔型应用于条件判断
真是True False 假
4 复数
赋值运算符
= 赋值
条件语句input（）
input（输入内容）
Python算术运算符
+加、-减、*乘、/除、//求整、**幂运算（乘方）、%求余
数据类型int（整数）和str（字符串） 不能进行运算
必须转换过来
例如int（）
Str（）
比较运算符
用于两个变量之间值得比较
==等于
>大于
<小于
>=大于等于
<=小于等于
！=不等于
赋值运算符
= 赋值 、+=累加、-=累减、*=累乘、/=累除、%=累余、//=、**=（累计求幂次方）
用于判断
1 in在.....里面
2 not in 不在...里面
逻辑运算符
1 and与 两个条件同时为true 结果才是true
2 Or 或 有一个条件为true 结果就是true
3 not 非 一个条件 true变成false flase变为true
数值0、空字符串、空列表、空元组、空集合、空字典、默认是false（什么也不输出）
None：代表空的是函数里的返回值的一种
for 循环
格式 for i in xx：
代码语句
XX：代表的是可以迭代的对象（有字符串、列表、元组、集合、字典）
i 变量：代表 XX某一个具体的值
循环字典时拿到只有字典的键
Python九九乘法表 循环一个函数
for i in range（a，b）a到b这个范围
消除重复数据
冒泡排序
质数之和
水仙花束
选择法排序
乘阶之和
Python函数
定义：函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段
命名函数步骤组成
1 第一个关键字 def
2 函数名子，命名规则和变量名命名规则一样
3函数的参数
4 返回值
函数书写格式：
def 函数名（参数）：
代码块
*print（结果值）
*return返回值（结果值）（表示函数结束）
*函数名（需要的参数）
求和
Sum（） python的内置函数
函数使用
第一步：先写函数的名字
第二步：（）如果里面有参数，则传入值
第三步：使用函数的时候就必须传入值
例子1
例子2
return的作用
1 返回值
2 表示一个函数的结束
3 当一个函数没有返回值 print（函数名）结果是空（也可以没有）
函数全局变量和全局变量区别
全局变量 ：全局变量定义之后 整个脚本都能用
局部变量：局部变量定义之后，只能在特定范围内使用
函数参数类型
1必填参数、2默认参数、3可变长参数
参数类型1 必填参数
参数类型第二种 默认参数
1默认参数y=100 y后面是默认值
2在使用函数时，如果不对默认值进行赋值，那么使用默认值
3 给默认值赋值，就是用传入值（就用赋予的值运行）
4 也适用于列表，字符串类型
参数类型第三种 可变长参数
可变长参数 *args、**kwargs
*args 特点
1 传入多个值
2 args是元组的形式
3 传入的多个值是一个元组
例子
4 传入值可以一个或多个
**kwargs
特点
1传入值的时候以字典的形式
2 因为是字典可以用字典的函数
3（a1=2）的形式
匿名函数定义：
“lambda 参数：表达式” 减少代码量，无法取代def常规函数；常用来简单计算;只能写一行，一行中间不能中断，不支持循环，判断语句！
def a(x):
return (x+1)
a(2)
f=lambda x:x+1 #匿名求和
print(f(2))
c=lambda z,y:(y-3)*z #匿名求差
print(c(0,100))
Python：读写txt文件，对文件进行操作
解释
file: 指的是文件名字、或表者说文件在计算机中存放的位置（必填参数）
mode：‘r’表示读取， ‘w’表示写入，会自动创建一个文件（文件不存在的时候创建）
‘x’：创建文件并写入数据到文件中。 'a':向文件里添加（追加）数据。 'b':二进制的形式
'rb'：应用于读取照片、mp3、MP4、‘wb’：应用于写入照片
1建立一个txt文件
格式
1读取文件
f = open(file='a.txt',encoding='utf-8')
print(f.read()) #read()读取全部
print(f.readlines()) # 读取出来的数据以列表的形式保存
2 写入数据
f = open(file='a.txt',mode='w', encoding='utf-8')
f.write('hello world')
3追加（添加）数据
f = open(file='a.txt',mode='a', encoding='utf-8')
f.write('\n hello world') # ()追加的内容 |n换行 在打开文件就可看到
4插入图片
1打开照片
f = open(file='/Users/oldman/Desktop/e.png', mode='rb') # 找到图片的路径
2 将照片里的内容以二进制的形式读取出来，
s = f.read()
3打开另一照片
d = open(file='kkk.png', mode='wb')
4 向照片里写入二进制数据
d.write(s)
函数嵌套
就是将上一个函数的结果值赋予到下一个函数中
#函数嵌套
# def k():
# print("k 函数的代码")
#def f():
# k() 2 a=k() 执行def k（）的结果
# f() 1运行def f（a）
Python面向对象、分为类和对象
先类后对象
面向对象特点：1 封装 、2继承（分为单继承和多继承）、3多态 4对象是最后的
类的组成：1属性（六种基本数据类型，整数、浮点型） 2方法（函数）
面向对象书写格式：
Class 类名（）：
类的代码
代码包括，循环、判断、函数
方法 对象为最后引用的
变量名=类名（） b=a（）{对象}
变量名.xx(定义的函数名)b.pp()
Class a（object）类名
B=123455 类的属性
def __init__(self,q,w,e)
Self.q=q
Self.w=w 三个属于对象属性
Self.e=e
def b（self）： 属于方法
Print（self.B+self.q）
ww=a（必填参数init里面的） 属于对象
例如1
object #中文叫做对象
object: 所有类的基础
self ：在方法里面第一个参数必须是self **********
self：指代的对象的本身
类的使用
第一步，创建对象
a=zoo() #a对象
第二步 使用对象操作类的属性，方法
print(a.属性名)
a.biaoyan()
类的组成
1 属性：
#从公有私有的角度？
共有的属性：
私有的属性
#从类，对象的角度？
类属性
对象属性==实例属性
2方法：静态、类方法、实例（普通方法）、魔法方法(初始化方法是def __init__())、
2 初始化方法
def __init__(self,类名1，类名2，) 双下横杠
例子
类属性：公有、私有两种
公有属性例如：
ke=['语文','数学','外语','生物'] 类公有属性
私有属性，用英文下划线开头，例如
__grade ='1903' 类私有属性
def __init__(self,a,b):
self.a=a 公有的对象属性
self.__b=b 双下划线代表私有对象属性
例如3****************************************
执行要求
结果
类和对象属性的区别
1类不能使用对象的属性
2类名代表代表类
3类可以访问类的属性
对象能否使用对象属性，类属性
1对象可以访问对象属性
2对象可以访问类属性
面向对象特点：
1封装：指的是对数据和代码逻辑的处理。
2继承；分为单继承（b类继承a类）、多继承（b类继承a类，c类）
3 多态
单继承例子：
结果
面向对象------多态
1 子类的方法与父类方法名一致
2 如果想使用父类的方法：
在子类中定义一个方法
在函数里写super（）.父类方法名
3 子类对象在使用父类方法名是，只需通过对象，子类中定义的方法
例如
连接mysql数据库步骤
1先给数据库授权全部连接
2如图
python的第三方库cmd下载工具 ：命令 pip
第三方库
进入cmd 输入 pip
pip install 库名； 下载库
pip list； 查看已下载的库
导入 pymysql第三方库
第一步：与mysql建立连接 connect():建立连接
第二步：创建一个游标，类似mysql进入命令行模式 > select * from xx;
第三步：写入SQL语句
第四步：执行sql语句 execute（放入需要执行的SQL语句）：作用就是执行SQL
查询具体结果
1 操作excel表格
先在cmd上下载 xlrd xlwt库 ，将一个空的表格放在python安装目录下
1：import xlrd 读取文件 进入库
操作 Excel 的xlrd读取excel文件 xlwt写入数据到excel文件
2 打开excel
d =xlrd.open_workbook(filename='d1.xlsx')
3 选中一个表
table=d.sheets()[0] # .sheets()[0] 为格式
第二种选中表的方法
table=d.sheet_by_index(0)
4 获取数据
获取某行数据
a=table.row_values(1) #获取某行数据（）必须制定获取的行号
print(a) #查看获取的行信息
a1=table.col_values(1) # 获取某列数据 （）必填
6 获取某行的某一个数据
先获取这行数据
a=table.row_values(1)
在通过列表的索引值获取到元素
print(table.row(1)[1].value) # row()代表哪一行[ ]获取的第几个数据
7 获取某列的某个数据
在通过列表的索引值获取到元素----- .value 获取到具体的值
先获取某列数据
a1 =table.col_values(1) # 获取整列数据
print(a1)
print（table.col(1)[1].values） col()获取的某一列[ ]获取的某一个数据
8 通过行，列索引获取具体的单元格值
print(table.cell(a,b).value) #格式
a代表第几行
b代表第几个
9获取行数，列数
# """
nrows: 获取的是行数
ncols： 获取的是列数
# """
print(table.nrows)
如何获取所有行的数据
n = table.nrows
for i in range(0,n):
k = table.row_values(i)
print(k)
sheet_names(): 找出文件中所有表的名字
print(d.sheet_names())
写入数据
1 import xlwt #写入数据
2 d = xlwt.Workbook() #xlwt.workbook() 新建一个excel文件
第二步 新建一个excel表 add_sheet(工作表的名字)表名必填
table
= d.add_sheet("表一")
第三步 写入数据到excel表中，一次写入一个单元格
# #write（行号，列号，数据）
table.write(0,0,"张三")
第四步 保存Excel
# # save （’excel 文件名‘）
d.save('aaa.xls')
写入数据a=[[123,123],[12333,344],[1232324,23]]
for i in range(len(a)):
# for j in range(len(a[i])):
# table.write(i,j,a[i][j])
# print('这个是abc代码')
""""
if __name__=='__main__':
__name__ 代表当前文件的名字
"__main__"自动获取当前文件的名字
print('这是if语句下的代码')
"""
# python 程序入口，只能在当前文件下执行 if if __name__=='__main__':
# 低下的代码，离开这个文件
if __name__=='__main__': 条件就不成立
# if __name__=='__main__':
# print('这是if语句下的代码')
OS内模块作用与计算机进行交互
import os #必须写
# getcwd（）获取当前路径
Print(os. getcwd()) 查看当前路径
# chdir（路径的名字） 切换路径或目录
os.chdir(‘A’)
Print(os.getcwd()) 查看切换的
# . 代表当前目录==os.curdir
Print(os.curdir())
# . .代表上一级目录==os.pardir
Print(os.pardir())
#返回原始目录 os.chdir('..')
print(print(os.getcwd())
#os.name 获取操作系统的类型有 windows、mas、uninx、liunx
print(os.name)
# 创建多级目录 os.makedirs（'多级目录'） a/b/c
os.makedirs('A/B/C')
# 创建一个目录
os.mkdir('目录名字')
os.mkdir('a123')
# 删除多个目录
目录必须为空
os.removedirs('目录名字')
os.removedirs('A/B/C')
#删除单个目录：目录必须为空 rmdir（'目录名字'）
os.rmdir('123')
#查看当前路径下所有的文件和目录 os.listdir（'路径的名字'）
d=os.listdir(r'C:\PycharmProjects\untitled3')
print(d)
#对文件、目录进行重命名 os.rename('老名字','新名字')
a=os.rename('123','456')
print(a)
#删除文件 os.remove('绝对路径加文件名字')
a=os.remove(r'C:\PycharmProjects\untitled3\abc')
print(a)
# 执行系统命令 os.popen('需要执行的命令')
a=os.popen('dir')
print(a.read())
# os.path 类
对文件的操作，返回文件件的路径，例如绝对路径，相对路径，判断文件，目录
#返回文件的绝对路径
abspath('文件名')
a=os.path.abspath('a1.xlsx')
print(a)
#返回上一级的路径 dirname('路径') 例如：a/b/c/a.tst------=a/b/c/
a=os.path.dirname(r'C:\PycharmProjects\untitled3\a1.xlsx')
print(a)
# # 返回当前文件或目录名字 basename（'路径'） b=os.path.basename(r'C:\PycharmProjects\untitled3\a1.xlsx')
print(b)
# # 判断文件或目录是否存在----=返回布尔值 True False exists('路径名/目录名')
print(os.path.exists(r'C:\PycharmProjects\untitled3\.idea'))
# #判断是否为目录 返回布尔值 True False isdir（'路径名'）(名字)
c=os.path.isdir(r'C:\PycharmProjects\untitled3\.idea')
print(c)
# #判断是否为文件 ----=返回布尔值 True False isfile('路径名/文件名')
d=os.path.isfile(r'C:\Users\wuming\Desktop/123')
print(d)
# # 判断是否为链接文件 返回布尔值 True False
islink（'路径名/文件名'）
a1=os.path.islink(r'C:\Users\wuming\Desktop/123')
print(a1)
# # 路径拼接 join（'路径一','路径二'）
print(os.path.join('/A/','B'))
# #文件路径分离 将最后一个文件或目录分离 split（'路径的名字'）
print(os.path.split(r'C:\Users\wuming\Desktop'))
# #分割文件的后缀名 splitext('文件名') 返回一个元组
k=os.path.splitext('123.txt')
print(k)
时间模块
import time
# #sleep（浮点数/整数）
print('睡眠之前')
# time.sleep(0.5) #休眠时间
print('睡眠之后')
# # clock（）计算的是执行代码时cpu花费的时间
print(time.clock())
# # ctime() asctime()
获取当前时间
print(time.ctime())
print(time.asctime())
# #输出时间 localtime（） 本地时区
print(time.localtime())
# #格式化输出时间 strftime（'关于时间的字符串'）
print(time.strftime('%A
%B %H: %M: %S'))
# # strptime('关于时间的字符串')
# # %y 年份
# # %d 一月第几天
# # %b 表示月份
print(time.strptime('30 Nov 00','%d %b %y'))
# # 计算计算机元年到现在所有秒的总和 time（）
print(time.time())
# from datetime
import
datetime,date,timedelta # 精确导入
import datetime # 整体导入
# 获取当前时间，日期
datetime.now()
print(datetime.datetime.now())
#获取指定的时间，日期 datetime（整数数字）
print(datetime.datetime(2019,7,30))
# 时间字符串转成datetime里的日期 strptime（）
print(datetime.datetime.strptime('1937
7 7 12:00:00','%Y %m %d %H:%M:%S'))
将日期转为字符串 strftime（）
print(datetime.datetime.now().strftime('%H:%M:S'))
#日期加减
#求当前时间
a=datetime.datetime.now()
print(a)
# #加3天
b=a+datetime.timedelta(days=4)
#获取当前日期 today（）
print(datetime.date.today())
# # 对日期进行加减
# #步骤一： 获取当前日期
# #步骤二：加减日期
timedelta（days=xxx）
f=datetime.date.today()
+ datetime.timedelta(days=1)
print(f)
Python操作数据库
第一步连接数据库
1导入pymysql模块
import pymysql
2 与mysql建立连接
d=pymysql.connect(
host='192.168.10.65', # 数据库所在的主机IP地址/域名【云服务器--mysql数据库】
port=3306, # mysql的端口号
user="root", #
mysql的用户名
password="654321", # mysql的用户密码，授权密码
charset="utf8" ,#
mysql数据的编码方式
database="zouxin",
# 指定数据库，不写这个参数，默认使用所有的数据库
)
#3.创建一个游标;mysql进入命令行模式
e=d.cursor() 必写*********
4.写SQL语句
sql='show databases'想要执行的要求 查看库
5.执行Sql语句 "execute"放入传入的sql语句，执行sql语句
data=e.execute(sql) 必写
# e.executemany('sql语句') # 执行多条sql语句
print(data) 查看sql语句结果即库的个数
#第五步查询具体结果
print(e.fetchall())#查询执行sql后的所有结果
#e.fetchmany(数字)#查询执行sql后的指定结果 获取数字的前几行
#e.fetchone()#查询执行sql后的第一个结果
例如创建一个库
w='create database fqw
character set utf8'
e.execute(w) 执行创建库的语句
print(e.fetchall()) # 查看创建好的库
先创后看
查看库中的表 制定好库
创建一个表
sql2='create table a(`ID` char(20),`name` char(30),`age` char(10))
character set utf8'
a=e.execute(sql2) 执行
print(e.fetchall())#查询执行sql后的所有结果
查看表
# 数据插入
sql4 = "insert into aa values('5','李二','dsds'),('3','李三','ss')"
e.execute(sql4)
d.cmmit() 保存操作
"""
a:找到链接
b:使用commit（）------ 保存数据到数据库
"""
d.commit()
#更新操作
sql5 = "update user set name='李四 '
where name='李三'"
e.execute(sql5)
d.commit()
查看表中内容
指定库名 查看表
ql='show tables'
#5.执行Sql语句 "execute"放入传入的sql语句，执行sql语句
e.execute(sql)
print(e.fetchall()) 查看所有表
a='select * from user'
e.execute(a)
print(e.fetchall())
查看内容
Python连接linux系统
现在cmd上下载库 paramiko
import paramiko 注释：用于远程连接linux系统、文件下载，上传
注释：面向过程ssh协议进行链接 可以执行linux命令
第一步：创造一个ssh客户端、
client=paramiko.SSHClient()
第二步： 信任远程linux主机
paramiko.AutoAddPolicy() 自动添加信任密文
client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
第三步：通过客户端链接liunx主机
client.connect(
hostname='192.168.10.100', liunx
ip
port=22, 端口号
username='root', 用户名
password='123456' 密码
)
第四部：执行linux命令
#e.xec_command( 需要执行的命令) :结果是一个元素
# stdin 输入：ls
-al stdout：输出结果 stderr：错误信息
stdin, stdout, stderr=client.exec_command('ls -al')
# read() ;读取
#decode（）： 把xxx编译成xxx
第五步 查看输入命令的结果
print(stdout.read().decode())
文件下载与上传
# Transport（（‘ip’）） 作用类似于ftp服务器
第一步创建服务器
ftp=paramiko.Transport(('192.168.10.100',22))
第二步 建立与远程linux服务器链接
用户名、密码
ftp.connect(username='root',password='123456')
第三步 创建一个类似于ftp的客户端
paramiko.SFTPClient.from_transport( )
sftp=paramiko.SFTPClient.from_transport(ftp)
第四步 下载远程文件 get（参数1，参数2）
# # 参数1代表远程文件
# # 参数2代表本地文件
x1='/home/排序.sh'
x2=r'C:\PycharmProjects\untitled3\排序.sh'
sftp.get(x1,x2) 执行
# # 将本地文件发送到linux服务器 put（参数1，参数2）
参数1 本地文件
参数2 远程文件文字
x1=r'C:\PycharmProjects\untitled3\数据库.py'
x2='/home/数据库.py'
sftp.put(x1,x2)
Python正则表达式
# python 正则表达式
re正则模块（只能操作字符串）
import re
"""
1、 点 在python里表示除了换行符\n以外匹配任意一个字符
2、* 匹配* 前面的字符0次或多处
3、+ 匹配+ 前面的字符1次或多处
4、？匹配？ 前面的字符0次或1处
5、$ 以某个字符结尾
6、 ^ 以某个字符开头
7、{m}匹配{}前面的字符m次
8,、{m,n} 匹配{}前面的字符m到n次 最少m次最多n次
9、[abc] 匹配中括号里的任意一个字符
"""
s =
"15845634446"
# search(参数1，参数2) ：搜索
# 参数1：已经编译好的正则表达式
#参数2：要匹配的字符串
#写正则表达式的步骤
#第一步：编译正则表达式,
re.compile(r'.') 这是编译的过程， r1 代表编译完成的
# r1=re.compile(r'.')
# r2=re.compile(r'123*')
# r3=re.compile(r'6+')
# r4=re.compile(r'0?')
# r5=re.compile(r'6$')
# r6=re.compile(r"^5")
# r7=re.compile(r'1{1}')
# r8=re.compile(r'1{1,3}')
# r9=re.compile(r'158[1-9]{8}')
# 第二步 执行正则表达式
# print(re.search(r9,s))
"""
match 与 search区别
match:一旦匹配不到，立刻结束匹配
search： 匹配继续匹配，知道匹配成功第一次或字符串结束为止
如果继续存在的符合的字符串，不输出
共同点
直到匹配成功第一次之后停止
"""
#\d[0-9]
#\D除了0到9以外的任意一个字符
#\s 表示空白字符Unicode
\t\r\n\f\v
#\S 表示出了空白字符以外的任意字符
#贪婪模式
"""
指的是尽可能的匹配更多的字符
"""
#非贪婪模式
"""
指的是匹配到符合规则的，就停止匹配
"""
#sub(参数1、参数2、参数3) 替换的意思
和str.replace("旧的","新的")用法一样
#参数1：指的是正则
#参数2：新的字符
#参数3：被更改的字符串
#froup（）组 作用是将我们匹配到的内容拿出来
#group（）多个分组
# URL="http://www.bai.com"
# r1=re.compile(r'\.(.*)\.')
# a=re.search(r1,URL).group()
# print(a)
# b=re.sub(r'\.','',a)
# print(b)
# URL="http://www.bai.com://www.jingdonmg.com"
# r1=re.compile(r'\.(.*?)\.') #非贪婪模式 #或r1=re.compile(r'\.(.*)\.')贪婪模式
# a=re.search(r1,URL).group()
# print(a)
# b=re.sub(r'\.','',a)
# print(b)
#findall（） 结果是列表每个元素都是字符串
#作用：找出字符串中所有符合正则规则的结果
URL="http://www.bai.com://www.jingdonmg.com"
r11=re.compile(r'\.(.*?)\.')
res_1=re.findall(r11,URL) #结果是列表每个元素都是字符串
print(res_1)
模块，包，库的区别
模块：一个.py文件
包：多个.py文件组成
python包：特点必须存在一个__init__.py文件，没有就是一个目录
库：有多个包，模块集成的一个新的集合
爬虫定义
爬虫定义：通过python代码自动获取网络中的数据资源（图片、视频等）
#反爬虫：防止网络资源被爬虫代码获取
#反爬机制:属于反爬虫的技术手段机制
#最常见的反爬虫机制:1.封锁IP地址
# 2.封锁机器物理Mac地址
# 3.验证码
# 4.服务器传输给浏览器的数据通过异步加载
爬虫实例
1 通过cmd 下载一个第三方库即为requests 作用是请求或响应数据
2导入正则模块 import re 用来匹配标题获取资源
3 导入爬虫模块 import requests
import re
import requests
4 建立一个伪装游览器
例如
w={
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.142 Safari/537.36"
}
# "User-Agent" 代表Python伪装浏览器
5 get 请求获取资源
例如
x=requests.get(url='https://www.fpzw.com/xiaoshuo/87/87590/17125664.html',headers=w)
注释：url=‘网址为要抓取内容的网址’，headers=伪装游览器的变量名
6 获取响应的数据 content.decode 方法获取
data=x.content.decode(encoding=’gbk’)
注释：先查看其编码方式有gbk和utf-8
7 print(data) 查看所有的内容是以字符加文字组成的（可以不用看）
8 ctrl f 搜索需要的标题
例如 r2=re.compice(r.’标题’) 将标题中的中文改为（.*?）即可
f=re.findall(r2.date)
print(f) 爬取的内容
例如：# r2=re.compile(r' (.*?)<br />') #获取一个标题的内容 点击上次的结果 ctrl f 键 搜索 标题 #将文字改成（.*?）即可
f=re.findall(r2,date) print(f)
爬取图片
第一步导入正则模块re 和爬虫模块requests
import re
import requests
第二步 建立一个面向对象 即建立一个伪装游览
a= {
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.142 Safari/537.36"
}
第三步建立方法（建立伪装游览器和编码方式）
def __init__(self):
#局部变量
x=requests.get(url='https://www.58pic.com/newpic/35193652.html',headers=self.a) #url=图片网址
#对象属性 headers=伪装游览的变量名
self.d=x.content.decode(encoding='gbk') 编码方式
第四步建立方法（选择抓取图片的标题）
def we(self):
r1=re.compile(r'<img
src="(.*?)" class="show-area-pic"')
注释爬取图片标题和爬取文字一样
#用正则匹配
data=re.findall(r1,self.d)
print(data)
urls=[]
for i in data:
urls.append('http:'+ i)
return urls #加返回值
第五步 获取图片
def download(self):
n=0
for i in self.we(): # urls:4个图片url
req=requests.get(url=i,headers=self.a)
#接受响应结果
jiegou= req.content #图片 二进制
f = open(file=f'{n}.jpg',mode='wb')
f.write(jiegou)
n+=1
p1=photo()
p1.download() 运行成功可以查看
python发送邮件步骤
导入库 smtplib email 是内置库 作用：用于发送，接受邮件
import smtplib
from email.mime.text import MIMEText
from email.header import Header
from email.mime.multipart import MIMEMultipart
from email.mime.image import MIMEImage
第一步 服务信息即网易邮箱
mail_host='smtp.163.com'
第二步 用户信息即账户名
mail_user='15206265349@163.com'
第三步 授权码 在邮箱设置中自己设置
mail_pass='123456w'
第四步 设置服务器端口号 默认端口为465
mail_port=465
第五步 设置发送方（发送者账户）地址
sender='15206265349@163.com'
第六步 接收方地址以列表的形式 可以多个
receivers=['17629759472@163.com']
第七步 设置邮箱主题
subject='python邮件测试'
第八步 设置正文
content='陈跃飞发送'
第九步 设置类 MIMEText（）类
( )三个参数：第一个为文本内容，第二个：plain 设置文本格式 ，第三个：utf-8 设置编码
message=MIMEText(content,'plain','utf-8')
第十步 发送邮件过程
1添加发送者头部
message['From']=Header(sender)
2添加接受者头部 转成字符串
message['To']=Header(str(';'.join(receivers)))
3添加邮箱主题
message['Subject']=Header(subject)
第十一步 连接邮箱服务器发送邮件
1登录邮箱
s=smtplib.SMTP_SSL(host=mail_host,port=mail_port)
2 输入账号 密码
s.login(mail_user,mail_pass)
3 第三步 发送邮件
s.sendmail(sender,receivers,message.as_string())
print('success') （提示句）
4 退出登录
s.close()
或 s.quit()
带附件的邮件发送
import smtplib
from email.mime.text import MIMEText
from email.header import Header
from email.mime.multipart import MIMEMultipart
from email.mime.image import MIMEImage
第一步 服务信息即网易邮箱
mail_host='smtp.163.com'
第二步 用户信息即账户名
mail_user='15206265349@163.com'
第三步 授权码 在邮箱设置中自己设置
mail_pass='123456w'
第四步 设置服务器端口号 默认端口为465
mail_port=465
第五步 设置发送方（发送者账户）地址
sender='15206265349@163.com'
第六步 接收方地址以列表的形式 可以多个
receivers=['17629759472@163.com']
第七步 设置邮箱主题
subject='python邮件测试'
第八步 设置正文
content='陈跃飞发送'
第九步 设置类 MIMEText（）类
( )三个参数：第一个为文本内容，第二个：plain 设置文本格式 ，第三个：utf-8 设置编码
message=MIMEText(content,'plain','utf-8')
第十步 邮件发送过程
1 添加一个MIMEMultipart类 作用：将正文及附件添加到邮件里
massage=MIMEMultipart()
message['From']=Header(sender)
2 添加接受者头部 转成字符串
message['To']=Header(str(';'.join(receivers)))
3第三步：添加邮箱主题
message['Subject']=Header(subject)
4 准备要发送的正文，以html网页形式
先建立一个html文件
读取html文件
with open(file='正文内容.html' 'mode=r',encoding='utf-8') as f:
content=f.read()
5 设置html格式
p1=MIMEText(content,'html','utf-8')
6 准备一个要发送的邮件（txt文件 读取）
with open('file=133txt',mode='r',encoding='UTF-8')as
f:
d=f.read()
设置格式
p2=MIMEText(d,'plain','utf-8')
7 将文本转成二进制流
p2['Content-Type'] = 'application/octet-stream'
8对附件添加一个名字
p2['Content-Disposition'] = 'attachment;filename="133.txt"'
9 添加一个照片作为附件
with open(file='0.jpg',mode='rb') as f:
d=f.read()
MIMEImage 加载2进制图片
10步加载图片
p3 = MIMEImage(d)
p3['Content-Type'] = 'application/octet-stream'
p3['Content-Disposition']='attachment;filename="0.jpg'
11 将三部分添加到邮箱里
massage.attach(p1)
massage.attach(p2)
massage.attach(p3)
12步 发送
# # 第一步：登录邮箱
s=smtplib.SMTP_SSL(host=mail_host,port=mail_port)
# #第二步：输入账号，密码
s.login(mail_user,mail_pass)
# # 第三步 发送邮件
s.sendmail(sender,receivers,message.as_string())
print('success')
# #第四步：退出登录
s.close()
# #或 s.quit()
