python基础知识笔记
第一章 Python语言基础
1.语法特点
注释规则：
单行注释语法：(从符合“#”开始，直到换行为主)
# 注释内容
多行注释语法：(用一对三引号)
'''......'''
代码缩进：
同一级别代码块的缩进量必须相同
定义变量：
语法：变量名=赋值
使用内置函数type()可返回变量类型:
print(type(变量名))
使用内置函数id()可返回变量所指的内存地址:
id(变量名)
基本数据类型：
(1)数字：整数、浮点数
(2)字符串：通常使用单引号、双引号、三引号括起来（注：单引号、双引号的内容必须在一行。三引号用于内容夸行）
(3)布尔类型
数据类型的转换：
所要转换的数据类型(变量名) 例：str(x) 指把x转换为字符串
第二章 运算符与表达式
1.算术运算符
+：加
-：减
*：乘
/：除
%：求余
//：取整除，即返回商的整数部分。例：7//2=3
**：求幂 例：2**4=16
2.赋值运算符
=
3.比较运算符
>：大于
<：小于
==：等于
!=：不等于
>=：大于等于
<=：小于等于
#例：
math=80
china=100
c=65
vag=(math+china+c)/3
print("3门课的平均分为："+str(vag)) #有引号时，必须把数字型转换为字符串型，否则会报错
print(c if c>math else math)
4.逻辑运算符
and：逻辑与
or：逻辑或
not：逻辑非
#例：
print("打折活动进行中.....")
strweek = input("请输入中文星期：") #输入星期
inttime = int(input("请输入时间（范围：0~23）：")) #输入数字时间并强制转换为
#用if语句来判断是否满足活动条件
if(strweek=="星期二" and(inttime>=19 and inttime<=20))or(strweek=="星期六" and(inttime>=17 and inttime<=19)):
print("正在活动中")
else:
print("活动已结束")
第三章 流程控制语句
1.选择语句
（1）if语句语法
if表达式:
语句块
（2）if...else语句语法
if表达式:
语句块1
else:
语句块2
（3）if...elif...else语句语法
if表达式1:
语句块1
elif表达式2:
语句块2
elif表达式3:
语句块3
...
else:
语句块n
2.循环语句
（1）while循环语法
while条件表达式:
循环体
（2）for循环语法
for迭代变量 in 对象:
循环体
例：
print("计算1到100的累加和为：")
s=0
for i in range(101):
s+=i
print(s)
函数range(start,end,step)用于生成一系列连续整数
start：用于指定计算的起始值，可忽略，忽略默认为从0开始
end：用于指定计数的结束值（但不包括该值）不能忽略
step：用于指定步长，即两个数之间的间隔数。可忽略，忽略时默认为1
#例：使用循环嵌套打印九九乘法表
for i in range(1,10): #输出9行
for j in range(1,i+1): #输出与行数相同的列
print(str(j)+"*"+str(i)+"="+str(i*j)+"\t",end='') #\t水平制表符 end=''让输出结果在一行上显示
print('')#换行
第四章 列表与元组
1.序列的概述
（1）索引：即序列中每个元素的编号，(正数编号时)从左到右第一个数从0开始，(负数编号时)从右到左第一个数从-1开始。
通过索引可以访问序列中的任何元素
语法：序列名[索引号]
（2）切片：是访问序列中元素的另一种方法
语法：sname[start:end:step]
sname:表示序列的名称
start:表示切片的开始位置（包括该位置），如果不指定默认为0
end:表示切片终止的位置（不包括该位置），如果不指定默认为该序列的长度
step:表示切片的步长，如果省略，默认为1
注：sname[:]表示复制整个序列
（3）序列相加：指把相同类型序列连接起来，用“+”运算符实现
语法：sname1+sname2
（4）乘法：使用数字n乘以一个序列生成一个新的序列(即原序列内容被重复n次形成一个新系列)
语法：sname*n
（5）检查某个元素是否是序列的成员(元素)
语法：要检查的元素 in 指定的序列名
（6）相关函数的运用
len():计算序列的长度
max():返回序列中的最大值
min():返回序列中的最小值
list():将序列转换为列表
str():将序列转换为字符串
sum():计算元素和
#例：
xulie1=[10,20,30,40,50,60]
xulie2=[9,8,7,6,5,4]
print(xulie1[2]) #通过索引输出第三个元素
print(xulie2[1:3]) #通过切片输出前两个元
print(xulie1+xulie2)#序列相加
print(xulie1*2) #序列相乘
print(100 in xulie1)#查询
print(len(xulie1)) #计算序列长度
2.列表[list]
（1）列表的创建和删除
a、使用赋值运算符直接创建列表
语法：列表名=[元素1,元素2...]
b、创建空列表
语法：列表名=[]
c、删除列表
语法：del 列表名
#例：访问列表元素
import datetime #导入日期时间类
liebiao=["赵","钱","孙","李","周","吴","郑"] #定义一个列表
day=datetime.datetime.now().weekday() #获取当前日期所对应的星期
print(liebiao[day]) #输出日期所对应的元素
#datetime.datetime.now()：获取当前日期
#weekday()：获取星期，其值为0~6,0表示星期一
3.遍历列表
1.直接使用for循环实现
语法：for item in listname: #输出item
item：用于保存获取到的元素，要输出元素内容时，直接输出该变量即可
listname：列表名
#例：
liebiao=["赵","钱","孙","李","周","吴","郑","王"] #定义一个列表
for item in liebiao:
print(item,end='') #在同一行遍历输出
2.使用for循环和enumerate()函数实现
语法：for index,item in enumerate(listname): #输出index,item
#例：
liebiao=["赵","钱","孙","李","周","吴","郑","王"] #定义一个列表
for index,item in enumerate(liebiao):
print(index,item)
3.添加、修改和删除列表元素
利用append()在列表末尾添加元素：
语法：listname.append(obj)
listname：为要添加元素的列表名称
obj：要添加的元素
利用insert()方法向列表中指定位置添加元素：
语法：listname.insert(索引数,obj)
利用extend()方法将一个列表的全部元素添加到另一个列表中：
语法：listname.extend(seq)
listname：原列表名
seq：要添加的列表名
修改元素只需要通过索引获取该元素，然后再重新赋值即可。
#例：
liebiao=["赵","钱","孙","李","周","吴","郑","王"] #定义一个列表
liebiao[2]="修改" #把“孙”修改
print(liebiao)
利用del根据索引删除元素：
语法：del listname[索引号]
利用remove()方法根据元素值删除：
语法：listname.remove(要删除的元素)
利用pop删除末尾的元素并返回
#例：
liebiao=["赵","钱","孙","李","周","吴","郑","王"] #定义一个列表
del liebiao[0] #利用索引删除赵
print(liebiao)
liebiao.remove("王") #删除王
print(liebiao)
4.对列表进行统计计算
1.利用count()获取指定元素出现的次数
语法：listname.count(指定元素)
2.利用index()获取指定元素首次出现的下标/索引值
语法：listname.index(指定元素)
3.利用sum()统计数值列表的元素和
语法：sum(listname)
#例：
shuzi=[10,20,30,40,40,50,40]
cishu=shuzi.count(40) #40出现的次数
xiabiao=shuzi.index(20) #20的下标
he=sum(shuzi) #列表shuzi元素的和
print(cishu,xiabiao,he)
5.对列表进行排序
1.使用sort()方法对列表中元素进行排列，排列后原列表中的元素顺序将改变
语法：listname.sort(key==None,reverse=False)
listname：列表名
key：英文字符串排列时使用，当设置为“key==str.lower”时表示在排序时不区分字母大小写。默认时区分字母大小写，先排大写后排小写。
reverse：可选参数，如果将其值设置为True，表示降序排列。设置为False，表示升序排列。默认时为升序排列。
2.使用sorted()方法对列表中元素进行排列，排列后原列表中的元素顺序不发生改变
语法：sorted(listname,key==None,reverse=False)
#例：
shuzi=[11,99,88,55,22,33,66,77,44]
zimu=['li','Fu','chang','Tom']
shuzi.sort() #sort()
print("升序：",shuzi)
shuzi.sort(reverse=True)
print("降序：",shuzi)
zimu.sort(key=str.lower)
print("不区分字母大小写：",zimu)
shuzi_as=sorted(shuzi,reverse=True) #sorted()
print("降序排列：",shuzi_as)
6.列表推导式
1.生成指定范围的数值列表
语法：listname=[Expression for var in range()]
listname：表示生成的列表名
Expression：表达式，用于计算新列表的元素
var：循环变量
range()：调用函数
#例：在10~100内生成10个随机数
import random #导入random标准库
number=[random.randint(10,100)for i in range(10)]
print("生成的随机数为：",number)
2.根据列表生成指定要求的列表
语法：newlistname=[Expression for var in listname]
newlistname：新生成的列表名
Expression：表达式，用于计算新列表元素
var：变量，值为原列表的每个元素值
listname：原列表名
#例：计算打五折后的价格
price=[1200,2200,4400,800,6200]
sale=[int(x*0.5)for x in price]
print("原价格为：",price)
print("打折后价格为：",sale)
3.从列表中选择符合条件的元素组成新的列表
语法：newlistname=[Expression for var in listname if condition]
newlistname：新生成的列表名称
Expression：表达式，用于计算新列表元素
var：变量，值为原列表的每个元素值
listname：原列表名
condition：条件表达式，用于指定筛选条件
#例：筛选出大于5000的元素
price=[1200,2200,4400,800,6200]
sale=[x for x in price if x>5000]
print("原价格为：",price)
print("大于5000的数为：",sale)
7.二维列表
定义：二维列表的信息以行和列的形式来表示，第一行下标代表元素所在行，第二个下标代表元素所在的列。
创建二维列表的方法：
1.直接定义赋值法：
语法：listname=[[元素11,元素12,...],[元素21,,元素22,...],[...]]
2.使用嵌套的for循环创建：
#例：创建一个4行5列的二维列表
arr=[] #创建一个空列表
for i in range(4):
arr.append([]) #在空列表中再添加一个空列表
for j in range(5):
arr[i].append(j) #为内层列表添加元素
print(arr)
3.使用列表推导式创建
#例：创建一个4行5列的二维列表
arr=[[j for j in range(5)]for i in range(4)]
print(arr)
8.元组（tuple）
定义：元组与列表类似，它是由一系列按特定顺序排列的元素组成。它是不可变序列，其中元素不可单独修改。
1.元组的创建和删除
（1）使用赋值运算符直接创建元组
语法：tuplename=(元素1,元素2,...)
tuplename：元组名称
注：如果创建的元组织包括一个元素，必须在元素的后面加一个逗号“,”
（2）空元组的创建
语法：tuplename=()
（3）创建数值元组
语法：tuple(data)
data：表示可以转换为元组的数据，其类型可以是range()、字符串、元组或其它。
（4）删除元组
语法：del tuplename
2.访问元组元素
（1）全部访问：直接使用print()函数
（2）单个访问：
语法：print(tuple[索引号])
3.修改元组
元组不能单个修改，只能全部重新赋值
4.元组推导式
只是将拉列表推导式中的中括号“[]”修改为小括号“()”
5.元组与列表的区别
a、列表属于可变序列，它的元素可以随时修改或者删除。而元组属于不可变序列，其中的元素不可修改，只能全部替换。
b、元组比列表的访问和处理速度快
c、列表不能作为字典的键，而元组可以。
第五章 字典与集合
1.字典{dictionary}
定义：和列表类似，也是可变序列，不过与列表不同，它是无序的可变序列，保存的内容是以“键—值对”的形式存放的
特征：
a、通过键而不是通过索引来读取
b、字典是任意对象的无序集合
c、字典是可变的，并且可以任意嵌套
d、字典中的键必须唯一
e、字典中的键必须不可变
2.字典的创建和删除
1.字典的语法格式
语法：dictionary={'key1':'value1','key2':'value2',...}
dictionary：表示字典名称
key1，key2：表示元素的键，必须是唯一
value1，value2：表示元素的值
2.空字典的创建
语法：dictionary={}
语法：dictionary=dict()
3.通过映射函数创建字典
语法：dictionary=dict(zip(list1,list2))
dictionary：字典名称
zip()函数：用于将多个列表或元组对于位置的元素组合为元组，并返回包含这些内容的zip对象
list1：表示一个列表，用于指定生成字典的键
list2：表示一个列表，用于指定生成字典的值
4.通过给定的“键-值对”创建字典
语法：dictionary=dict(key1=value1,key2=value2,...)
5.字典的删除
（1）直接全部删除
语法：del dictionary
（2）只删除字典的全部元素
语法：dictionary.clear()
3.访问字典
1.直接全部访问
语法：print()
2.根据指定的键单个访问
语法(1)：print(dictionary['key'])
#例：
dictionary={'1':'李','2':'wang','动物':'小狗'} #创建字典
print("动物是：",dictionary['动物']if dictionary else "字典里没有动物") #使用if语句对不存在的情况进行处理
语法(2)：dictionary.get(key,default)
key：指定的键
default：为可选项，用于当指定的键不存在时，返回一个默认值，如果省略，则返回None
#例：
dictionary={'1':'李','2':'wang','动物':'小狗'} #创建字典
print("植物是：",dictionary.get('植物','字典里没有植物')) #使用get()方法
4.通过for循环遍历字典
#例1：通过items()全部输出全部“键-值对”
dictionary={'qq':'2935197','小明':'112233','小红':'2222222','小东':'444444'} #创建字典
for i in dictionary.items():
print(i)
#例2：通过keys()和values()方法遍历输出
dictionary={'qq':'2935197','小明':'112233','小红':'2222222','小东':'444444'} #创建字典
for key,value in dictionary.items():
print(key,"的电话号码是：",value)
4.修改、添加和删除字典元素
#例：
dictionary={'qq':'2935197','小明':'112233','小红':'2222222','小东':'444444'} #创建字典
dictionary["小加"]=888888 #添加字典元素
print("添加元素后为：",dictionary)
dictionary["qq"]=1111111 #替换字典元素
print("修改元素后为：",dictionary)
del dictionary["qq"] #知道存在直接删除
print("删除元素后为：",dictionary)
if "小明" in dictionary: #使用if语句先判断是否存在
del dictionary["小明"]
print(dictionary)
else:
print("不存在")
5.字典推导式
#例：
import random #导入random标准库
dictionary={i:random.randint(10,100)for i in range(1,5)}
print("生成的字典为：",dictionary)
6.集合{set:为无序可变序列}
定义：与数学中的集合概念类似，也是用于保存不重复的元素。所有元素放入一对大括号“{}”内。
1.创建集合
（1）直接使用“{}”创建
语法：setname={元素1,元素2,...}
setname:集合名称
（2）使用set()函数创建
语法：setname=set(iteration)
iteration：表示要转换为集合的可迭对象，可以是列表、元组、range对象等
#例：
ste2=set(range(1,5))
print(ste2)
2.向集合中添加元素
语法：setname.add(element)
stename：要添加元素的集合名
element：表示要添加的元素内容。只能是字符串、数字或布尔型的True或者False，不能使用列表、元组等可迭代对象
3.从集合中删除元素
#例：
set={10,20,30,40,50,60,70,80,90,100}
set.add(0) #添加一个元素
print("添加后结果为：",set)
set.pop() #删除一个元素
print(set)
if 1000 in set: #判断元素是否存在
set.remove(1000) #删除一个指定元素
print(set)
else:
print("无")
set.clear() #清空集合
print(set)
4.集合的交集、并集和差集运算
定义：交集运算时用：“&”
并集运算时用：“|”
差集运算时用：“-”
#例：
set1={10,20,30,40,50,60,70,80,90,100}
set2={0,10,100,11,22,33}
print("交集运算：",set1&set2)
print("并集运算：",set1|set2)
print("差集运算：",set1-set2)
第六章 字符串
1.字符串编码转换
GBK和GB2312是我国制定的中文编码，UTF-8是国际通用编码。
两种长见的字符串类型：str和bytes，这两种类型的字符串不能拼接在一起使用
1.使用encode()方法编码，它是str对象的方法。
语法：str.encode([encoding="utf-8"],[errors="strict"])
str：表示要进行转换的字符串
encoding="utf-8"：可选参数，用于指定进行转码时采用的字符编码，默认为UTF-8
errors="strict"：可选参数，用于指定错误处理方式，可选择值为：strict(遇见非法字符就抛出异常，默认值)、ignore(忽略非法字符)、replace(用“？”代替非法字符)等
#例：
str="好好学习，天天向上"
byte=str.encode(encoding="utf-8",errors="strict")
print(byte)
2.使用decode()方法解码，它是bytes对象方法
语法：bytes.encode([encoding="utf-8"],[errors="strict"])
2.字符串常用操作
1.拼接字符串
使用“+”运算符可以完成对多个字符串的拼接。不能与其它类型的数据直接拼接，需强制转换成字符串类型才能拼接。
#例：
str1="好好学习，天天向上"
num=100
str2="分"
str3=str1+str(num)+str2
print(str3)
2.计算字符串的长度
语法：len(string)
string：用于指定要进行长度统计的字符串
#例：
str1="好好学习，天天向上"
length1=len(str1) #直接使用len()函数计算
print(length1)
length2=len(str1.encode("utf-8")) #计算采用utf-8编码方式的字符串长度
print(length2)
3.截取字符串(通过索引来实现)
语法：string[start:end:step]
#例：
str="好好学习，天天向上"
str1=str[0] #通过索引号来截取第一个字符
str2=str[5:] #从第六个字符开始截取
str3=str[:4] #从左开始截取四个字符
str4=str[5:9] #截取第六个字符到九个字符
print(str1+"\n"+str2+"\n"+str3+"\n"+str4)
4.分割、合并字符串
分割字符串是把字符串分割为列表，而合并字符串是把列表合并为字符串
（1）分割字符串
语法：str.split(sep,maxsplit)
str：表示要分割的字符串
sep：用于指定分割符
maxsplit：可选参数，用于指定分割次数，如果不指定或者为-1，则分割次数没有限制
注：如果不指定sep参数，那么也不能指定maxsplit参数
（2）合并字符串
语法：strnew=string.join(iterable)
strnew：合并后生成的新的字符串
string：用于指定合并时的分界符
iterable：可迭代对象，该迭代中的所以元素将被合并为一个新的字符串，string作为分界点分割出来。
#例：
list_name=["小明","小红","小南","小刚"]
str_new='@'.join(list_name) #以@符号来连接，第一个元素前无符号
print(str_new)
5.检索字符串
（1）count()方法：用于检索指定某个字符串在字符串中出现的次数
语法：str.count(sub,start,end)
str：字符串名
sub：要检索的子字符串
start：可选参数，表示索引范围的起始位置
end：可选参数，表示索引范围的结束位置
#例：
str="好好学习天天向上"
number1=str.count("天",0,5) #在索引范围内检索
print(number1)
number2=str.count("天") #默认检索范围为全部
print(number2)
（2）find()方法：用于检索指定的字符串是否存在,如果不存在返回-1，否则返回首次出现该子字符串时的索引。
语法：str.find(sub,start,end)
如果只是判断指定字符串是否存在，可以使用in关键字。
语法：print(sub in str) 如果存在返回True否则返回False
（3）index()方法：与find()方法相似，只是当指定字符不存在时，会抛出异常
语法：str.index(sub,start,end)
（4）startswith()方法：用于检索字符串是否以指定子字符串开头，如果是返回True否则返回False
语法：str.startswith(sub,start,end)
（5）endswith()方法：：用于检索字符串是否以指定子字符串结尾，如果是返回True否则返回False
语法：str.endswith(sub,start,end)
6.字母的大小写转换
（1）lower()方法：将字符串中的全部大写字母转换为小写字母。如果没有应该被转换的字符，则将原字符返回
语法：str.lower()
str：为要转换的字符串名
（2）upper()方法：将字符串中的全部小写字母转换为大写字母。如果没有应该被转换的字符，则将原字符返回
语法：str.upper()
7.去除字符串中的空格和特殊字符
（1）strip()方法：用于去掉字符串左右两侧的空格和特殊字符
语法：str.strip(chars)
str：字符串名
chars：可选参数，用于指定要去除的字符，可以指定多个。如果不指定，默认全部去除
#例：
str="@好好学习，天天向上$"
print(str.strip('@'+'$'))
（2）lstrip()方法：用于去掉字符串左两侧的空格和特殊字符
语法：str.lstrip(chars)
（3）rstrip()方法：用于去掉字符串右两侧的空格和特殊字符
语法：str.rstrip(chars)
8.格式化字符串
定义：格式化字符串的意思是先制定一个模块，在这个模块中预留几个空位，然后再根据需要填上相应的内容。
（1）使用%操作符
语法：'%[-][+][0][m][.n]格式化字符'%exp
-：可选参数，用于指定左对齐，正数前面无符号，负数前面加负号
+：可选参数，用于指定右对齐，正数前面加正号，负数前面加负号
0：可选参数，表示右对齐，正数前面无符号，负数前面加负号，用0填充空白处(一般与m参数一起使用)
m：可选参数，表示占有宽
.n：可选参数，表示小数点后保留几位数
格式化字符：用于指定类型
%s：字符串（采用str()显示） %r：字符串（采用repr()显示）
%c：单个字符 %o：八进制整数
%d或者%i：十进制整数 %e：指数
%x：十六进制整数 %E：指数
%f或者%F：浮点数 %%：字符%
exp：要转换的项，如果要指定的项有多个，需要通过元组的形式来进行指定，不能用列表
#例：
eg='编号: %09d\t 公司名称: %s\t官网： http//www.%s.com' #定义模板
context1=(7,'百度','baidu') #定义要转换的模板1
context2=(8,'明日学院','mingrixueyuan')
print(eg%context1) #格式化输出
print(eg%context2)
（2）使用字符串对象的format()方法(推荐使用)
语法：str.format(args)
str：定义字符串的显示样式(即模板)
args：用于指定要转换的项，如果有多项，则用逗号进行分隔
模板创建：{[index][:[[fill]align][sign][#][width][.precision][type]]}
index：可选参数，用于指定要设置格式的对象在参数列表中的索引位置，索引值从0开始。如果省略，则根据值的先后顺序自动分配。
fill：可选参数，用于指定空白处填充的字符
align：可选参数，用于指定对齐方式，值为“<”表示内容左对齐；值为“>”表示右对齐；值为“^”表示内容居中，需要配合width一起使用
sign：可选参数，用于指定有无符号数
#：可选参数，对于二进制、八进制、十六进制，如果加上“#”，表示会显示0b/0o/0x前缀，否则不显示前缀
width：可选参数，用于指定所占宽
.precision：可选参数，用于指定保留的小数位数
type：可选参数，用于指定类型
S：对字符串格式化 b：将十进制整数自动转换成二进制表示再格式化
D：十进制整数 o：将十进制整数自动转换成八进制表示再格式化
C：将十进制整数自动转换成对应的Unicode字符 x或X：将十进制整数自动转换成十六进制表示再格式化
e或者E：转换为科学计数法在格式化 f或F：转换为浮点型再格式化
g或G：自动在e和f或者E和F中切换 %：显示百分比
#例1：
eg='编号: {:0>9s}\t 公司名称: {:s}\t官网： http//www.{:s}.com' #定义模板
context1=eg.format('7','百度','baidu') #定义要转换的模板1
context2=eg.format('8','明日学院','mingrixueyuan')
print(context1) #格式化输出
print(context2)
#例2：
import math
print('1251+3950的结果是(以货币形式显示): ￥{:,.2f}元'.format(1251+3950)) #以货币显示
print('{0:.1f}用科学计数法表示：{0:E}'.format(120000.1)) #用科学计数法表示
print('{0:d}的16进制结果是：{0:#x}'.format(100)) #输出十六进制
print('天才是由{:.0%}的灵感，加上{:.0%}的汗水。'.format(0.01,0.99)) #输出百分比，并且不带小数
第七章 Python中使用正则表达式
1.正则表达式语法
1.行定位符：用于描述字符串的边界。“^”表示行的开始；“$”表示行的结尾
2.元字符：
.：匹配除换行符外的所有字符 \w：匹配字母或数字或下划线或汉字
\s：匹配任意的空白符 \d：匹配数字
\b：匹配单词的开始或结束 ^：匹配字符串的开始
$：匹配字符串的结束
例：\bmr\w*\b：指先是从mr单词开始(\b)，接着匹配任意数量的字母或数字(\w*)，最后是单词结束处(\b)
3.限定符：
?：匹配前面的一个字符零次或一次 +：匹配前面的一个字符一次或多次
*：匹配前面的一个字符零次或多次 {n}：匹配前面的一个字符n次
{n,}：匹配前面的一个字符最少n次 {n,m}：匹配前面的一个字符最少n次，最多m次
例：^\d{8}$：匹配8位QQ号
4.排除字符：由行开始符合中括号组成
[^a-zA-Z] 指匹配一个不是字母的字符
5.选择字符：“|”理解为或
例：身份证号的匹配；长度为15位或18位。15位全数字；18位前17位数字，最后一位是校正为数字或者X或x
(^\d{15}$)|(^\d{18}$)|(^\d{17})(\d|X|x)$
6.转义字符：符号“\”将特殊字符(“.”“?”“\”)转义为普通字符
7.分组：符号“()”
8.原生字符串表示法：在模式字符串前加r或R
例：'r\bmr\w*\b'
2.使用re模块实现正则表达式操作
re模块的导入：
语法：imptrt re
1.使用match()方法进行匹配
此方法用于从字符串的开始处进行匹配，如果在起始位置匹配成功，则返回Match对象，否则返回None。
语法：re.match(pattern,string,[flags])
pattern：表示模式字符串，由要匹配的正则表达式转换而来
string：表示要匹配的字符串
flags：可选参数，表示标志位，用于控制匹配方式。常用标志符如下：
A或者ASCII：对于\w、\W、\b、\B、\d、\D、\s和\S只进行ASCII匹配
I或者IGNORECASE：执行不区分字母大小写的匹配
M或MULTILINE：将^和$用于包括整个字符串的开始和结尾的每一行
S或DOTALL：使用“.”字符匹配所以，包括换行符
X或VERBOSE：忽略模式字符串中未转义的空格和注释
#例：手机号码的校对
import re #导入re模块
pattern=r'(18[3-4]\d{8})$|(15[012]\d{8})$' #[3-4]指从中随便取一位数；\d{8}指任意匹配八位数字
mobile='15011112222'
match=re.match(pattern,mobile) #进行模式匹配
if match==None: #判断
print(mobile,'不是我的手机号')
else:
print(mobile,'是我的手机号')
mobile='18011112222'
match=re.match(pattern,mobile)
if match==None:
print(mobile,'不是我的手机号')
else:
print(mobile,'是我的手机号')
2.使用search()方法进行匹配
此方法用于在整个字符串中搜索第一个匹配的值，如果在起始位置匹配成功，则返回Match对象，否则返回None
语法：re.search(pattern,string,[flags])
#例：验证是否出现危险字符
import re
pattern=r'(黑客)|(抓包)|(监听)|(Trojan)' #模式字符串
about='我是一名程序员，我喜欢看黑客方面的书籍，想研究一下Trojan'
match=re.search(pattern,about) #进行匹配模式
if match==None:
print(about,'@安全！')
else:
print(about,'@出现危险词汇！')
3.使用findall()方法进行匹配
此方法用于在整个字符串中搜索所有符合正则表达式的字符串，并以列表的形式返回
语法：re.findall(pattern,string,[flags])
如果在指定的模式字符串中包含分组，想获取整个模式字符串的匹配，可以给模式字符串使用一对小括号进行分组然后在获取结果时，只取返回值列表的每个元素(是一个元组)的第一个元素
#例：
import re
pattern1=r'[1-9]{1,3}(\.[0-9]{1,3}){3}' #模式字符串中包含分组
srt1='127.0.0.1 192.168.1.66' #要配置的字符串
match1=re.findall(pattern1,srt1) #进行匹配模式
print(match1) #模式字符串中包含分组，则返回与分组匹配的文本列表
pattern2=r'([1-9]{1,3}(\.[0-9]{1,3}){3})' #对模式字符串加一对小括号
match2=re.findall(pattern2,srt1)
for item in match2:
print(item[0]) #去列表的第一个元素
4.使用sub()方法实现字符串的替换
语法：re.sub(pattern,repl,string,count,flags)
pattern：表示模式字符串，由要匹配的正则表达式转换而来
repl：表示替换的字符串
string：表示要被查找替换的原字符串
count：可选参数，表示模式匹配后替换的最大次数，默认值为0，表示替换所有的匹配
flags：可选参数，表示标志位，用于控制匹配方式
#例：隐藏手机号
import re
pattern=r'1[0-9]\d{9}' #定义要替换的模式字符串
string='中将号码为：88888888 联系方式为：15012341234'
result=re.sub(pattern,'1xxxxxxxxxx',string) #替换字符串
print(result)
5.使用正则表达式分割字符串
语法：re.split(pattern,string,[maxsplit],[flage])
maxsplit：可选参数，表示最大的拆分次数
#例：
import re
str1='@小李@小王@小丁'
pattern=r'@' #以@分割字符串
str2=re.split(pattern,str1)
print('你@的好友有：')
for item in str2: #循环遍历输出每一个值
if item!="":
print(item)
第八章 函数
1.函数的创建的调用
1.创建函数(定义函数)：
语法:def functionname(parameterlist):
['''comments''']
[functionbody]
functionname：函数名称，在调用函数时使用
parameterlist：可选参数，用于指定向函数中传递的参数。如果有多个参数，使用逗号“,”分割
```comments```：可选参数，表示为函数指定注释
functionbody：用于指定函数体，即函数被调用后，要执行的功能代码
2.调用函数：
语法：functionname(parametersvalue)
parametersvalue：可选参数，用于指定各个参数的值。如果有多个参数需用“,”逗号分隔
#例：
def function_tips():
'''功能：每天输出一条励志文字
'''
import datetime
#定义一个列表
mot=["坚持下去不是因为我很坚强，而是因为我别无选择",
"含泪播种的人一定能笑着收获",
"做对的事情比把事情做对重要",
"命运给予我们不是失望之酒，而是机会之杯",
"明日永远新鲜如初，纤尘不染",
"求知若饥，虚心若愚",
"成功将属于那些从不说'不可能'的人"]
day=datetime.datetime.now().weekday() #获取当前星期
print(mot[day]) #输出每日一贴
function_tips() #调用函数
2.参数传递
在调用函数时，大多数情况下，主调函数和背调用函数之间有数据传递关系，这就是有参数的函数形式。
函数参数在定义函数时放在函数名称后面的一对小括号中：
例：def fun_name--函数名(height,weight--函数参数):
1.了解形式参数和实际参数
形式参数：在定义函数时，函数名后面括号中的参数为“形式参数”
实际参数：在调用一个函数时，函数后面括号中的为“实际参数”。也就是将函数的调用者提供给函数的参数称为实际参数
实际参数可分为：值传递和引用传递
当实际参数为不可变对象时，进行的是值传递。当实际参数为可变对象时，进行的是引用传递。
区别在于：进行值传递后，改变形式参数的值，实际参数的值不改变；而进行引用传递后，改变形式参数的值，实际参数的值也一起改变
#例：
def fun_bmi(person,height,weight):
'''功能：根据身高和体重计算BMI指数
person：姓名
height：身高
weight：体重
'''
print(person+"的身高："+str(height)+"米\t体重："+str(weight)+"千克")
bmi=weight/(height*height) #引用计算BMI指数
print(person+"的BMI指数为："+str(bmi)) #输出BMI
#判断身材是否合理
if bmi<18.5:
print("你的体重过轻\n")
if bmi>=18.5 and bmi<24.9:
print("正常范围，注意保持\n")
if bmi>=29.9:
print("肥胖\n")
#**************调用函数***************#
fun_bmi("小李",1.67,56)
fun_bmi("小飞",1.74,80)
fun_bmi(height=1.67,weight=55,person="小王") #使用关键字参数赋值调用
2.位置参数
定义：也称必备参数，是必须按照正确的顺序传递到函数中，即调用时的数量和位置必须与定义时的一致
例：当数量和位置不一样时，调用函数fun_bmi会出错
fun_bmi("小李"，1.67) #调用时数量与定义时不一样，出错
fun_bmi(1.67,"小李",56) #调用时位置与定义时不一样，出错
3.关键字参数
定义：关键字参数是指在调用函数时使用形式参数定义的名字来确定输入的参数值。通过该方式指定实际参数时，不再需与形式参数的位置完全一致。
4.为参数设置默认值
语法：def fun_name(...,person="某某"):
[functionbody]
注：在定义函数时，指定默认的形式参数必须在所有参数的最后，否则将产生错误。
#例：
def fun_bmi(height,weight,person="某某"): #为参数设置默认值
'''功能：根据身高和体重计算BMI指数
person：姓名
height：身高
weight：体重
'''
print(person+"的身高："+str(height)+"米\t体重："+str(weight)+"千克")
bmi=weight/(height*height) #引用计算BMI指数
print(person+"的BMI指数为："+str(bmi)) #输出BMI
#判断身材是否合理
if bmi<18.5:
print("你的体重过轻\n")
if bmi>=18.5 and bmi<24.9:
print("正常范围，注意保持\n")
if bmi>=29.9:
print("肥胖\n")
#**************调用函数***************#
fun_bmi(1.83,52,"不知道")
fun_bmi(1.83,52) #调用函数时没给person参数赋值
5.可变参数
定义：也称不定长参数，即传入函数中的实际参数可以是零个或多个
方法一：*parameter
这种形式表示接收任意多个实际参数并将其放到一个元组中
#例：输出咖啡名
listname=["蓝山","摩卡","等等"] #定义一个列表
def printcoffee(*coffeename): #定义函数并设置可变参数*coffeename
print("\n我喜欢的咖啡有：")
for item in coffeename:
print(item) #输出咖啡名称
############调用函数##############
printcoffee("蓝山")
printcoffee("蓝山","卡布奇洛","等等")
printcoffee(*listname) #通过列表指定函数的可变参数（在列表名前加 * 号）
#例：根据身高、体重计算BMI指数
def fun_bmi(*person):
"""功能：根据身高和体重计算BMI指数(升级版)
*person：可变参数该参数中需要传递带3个元素的列表，分别为：
姓名、身高、体重
"""
for list_person in person:
for item in list_person:
person=item[0] #姓名
height=item[1] #身高
weight=item[2] #体重
print('\n'+"="*10,person,"="*10) #格式设计
print("身高："+str(height)+"米\t体重："+str(weight)+"千克")
bmi=weight/(height*height) #引用计算BMI指数
print("BMI指数为："+str(bmi)) #输出BMI
#判断身材是否合理
if bmi<18.5:
print("你的体重过轻\n")
if bmi>=18.5 and bmi<24.9:
print("正常范围，注意保持\n")
if bmi>=29.9:
print("肥胖\n")
#**************调用函数***************#
list_1=[("小李",1.70,55),("小红",1.72,66),("小明",1.80,64)]
list_2=[("小三",1.60,50),("小四",1.72,46),]
fun_bmi(list_1,list_2) #调用函数指定可变参数
方法二：**parameter
这种形式表示接收任意多个类似关键字参数一样显示赋值的实际参数，并将其放到一个字典中。
#例：
dict={'小红':'双子座','小丁':'摩羯座'} #定义一个字典
def printsign(**sign): #定义函数名并设置输出参数
print() #输出一个空行
for key,value in sign.items(): #遍历字典
print("["+key+"]的星座是："+value) #输出组合后的信息
############调用函数############
printsign(小李="射手座",小明="水瓶座")
printsign(**dict) #调用函数输出已知字典（即在字典名前加两个 ** 号）
3.返回值
定义：将函数的处理结果返回给调用它的函数
语法：return [value]
return：为函数指定返回值，在调用函数时，可以把它赋值给一个变量，用于保存函数的返回结果
value：可选参数，用于指定要返回的值，可以返回一个或多个值
#例：
def fun_checkout(money):
'''功能：计算商品合计金额并进行折扣处理
money：保存商品金额的列表
返回商品的合计金额和折扣后的金额
'''
money_old = sum(money) #计算合计金额
money_new = money_old
if money_old >= 500 and money_old < 1000: #满500可享受9折优惠
money_new = '{:.2f}'.format(money_old*0.9) #格式化字符串
elif money_old >= 1000 and money_old < 2000: #满1000可享受8折优惠
money_new = '{:.2f}'.format(money_old*0.8)
elif money_old >= 2000 and money_old <3000:
money_new = '{:.2f}'.format(money_old*0.7)
elif money_old >= 3000:
money_new = '{:.2f}'.format(money_old*0.6)
return money_old,money_new #返回总金额和折扣后的金额
#**********************调用函数***********************#
print("\n开始计算\n")
list_money = [] #定义保存商品金额的列表
while True:
#请不要输入非法金额，否则将抛出异常
inmoney = float(input("输入商品价格（输入0表示输入完毕）:"))
if int(inmoney) == 0:
break #退出循环
else:
list_money.append(inmoney) #将金额添加到金额列表中
money = fun_checkout(list_money) #调用函数
print("合计金额：",money[0],"应付金额：",money[1]) #显示应付金额
4.变量的作用域
1.局部变量
定义：指在函数内部定义使用的变量，它只在函数内部有效。
#例：
def fun_demo():
message = "为有被追赶时，你才能真正的奔跑" #在函数内定义变量
print("局部变量message=",message)
fun_demo()
2.全局变量
定义：能够作用于函数内外的变量
（1）直接在函数体外定义一个变量
#例：
message = "为有被追赶时，你才能真正的奔跑" #在函数外定义变量
def fun_demo():
print("函数体内：全局变量message=",message)
fun_demo()
print("函数体外：全局变量message=",message)
（2）在函数体内定义变量，并且使用关键字global修饰后，该变量也可为全局变量
#例：
def fun_demo():
global message #将message声明为全局变量
message = "命运给予我们的不是失望之酒，而是机会之杯"
print("函数体内：message=",message)
fun_demo()
print("函数体外：message=",message)
5.匿名函数
定义：指没有名字的函数，使用lambda表达式创建
语法：result = lambda [arg1[,arg2,...argn]]:expression
result：用于调用lambda表达式
[arg1[,arg2,...]]：可选参数，用于指定要传送的参数列表多个参数间使用逗号分隔。
expression：必须参数，用于指定一个实现具体功能的表达式。如果有参数，那么在该表达式中将应用这些参数
#例：
import math
r=10 #半径
result = lambda r:math.pi*r*r #计算圆的面积
print("半径为：",r,"的圆的面积为：",result(r))
第九章 面向对象程序设计
1.面向对象概述
（1）对象：一个抽象概念。现实生活中，顺处可见的一个事物就是对象，例如“人”
通常将对象分为两部分，即静态部分与动态部分。
静态部分被称为“属性”，任何对象都具备自身属性，如：人有手、头等
动态部分指对象的行为，如：人的行走、吃东西
（2）类：类是封装对象的属性和行为的载体，反过来说，具有相同属性和行为的一类实体被称为类。
（3）面向对象程序设计的特点
a.封装：将对象的属性和行为封装起来，而将对象的属性和行为封装起来的载体就是类
b.继承：是实现重复利用的重要手段，子类通过继承复用了父类的属性和行为的同时，又添加了子类特有的属性和行为
c.多态：将父类对象应用于子类的特征
2.类的定义和使用
类：表示具有相同属性和方法的对象的集合
1.定义类：使用关键字class来实现
语法：
class ClassName:
'''类的帮助信息''' #类文档字符串，用于说明解释
statement #类体
ClassName:类名，一般使用大写字母开头
statement:类体，主要由类变量、方法、属性等定义语句组成。在定义类时，没想好类的具体功能，可以直接用pass语句代替
2.创建类的实例
定义一个类后，并不会真正创建一个实例。这有点像一辆汽车的设计图，它只能告诉你这辆汽车咋样，但设计图本身不是一辆汽车
语法：instanceName = ClassName(parameterlist)
instanceName：实例名称
ClassName：必选参数，用于指定具体的类
parameterlist：可选参数
3.创建__init__()方法
在创建类后，通常会创建一个__init__()方法，该方法是一个特殊的方法，每当创建一个类的新实例时，Python都会自动执行它。
__init__(self)方法必须包含一个self参数，并且必须是第一个参数。
self参数是一个指向实例本身的引用，用于访问类的属性和方法
#例：
class People: #定义类
'''人类'''
def __init__(self,hand,foot): #构造方法
print("人类居住在地球")
print(hand) #输出
print(foot)
hand_1="用手劳作"
foot_1="用脚赶路"
WlidPeople = People(hand_1,foot_1) #创建类的实例
4.创建类的成员并访问
类的成员主要由实例方法和数据成员组成。在类中创建了类的成员后，可以通过类的实例进行访问
（1）创建实例方法并访问
所谓实例方法，是指在类中定义的函数
语法：def functionName(self,parameterlist):
block
functionName：用于指定方法名，一般使用小写字母开头
self：必要参数，表示类的实例
parameterlist：用于指定除self以外的参数
block：方法体，实现的具体功能
实例方法创建完后，可以通过类的实例名称和点(.)操作符进行访问：
语法：instanceName.functionName(parametervalue)
instanceName：类的实例名称
functionName：要调用的方法名称
parametervalue：表示为方法指定对应的实际参数，其值的个数与创建实例方法中parameterlist的个数相同
#例：
class People: #定义类(1)
'''人类'''
def __init__(self,hand,foot): #构造方法(2)
print("人类居住在地球")
print(hand) #输出
print(foot)
def work(self,state): #创建实例方法(4)
print(state)
#*************调用方法**************#
hand_1="用手劳作"
foot_1="用脚赶路"
WlidPeople = People(hand_1,foot_1) #创建实例(3)
WlidPeople.work("共同创建美好家园") #调用实例方法(5)
（2）创建数据成员并访问
数据成员是指在类中定义的变量，即属性，根据定义位置，又可以分为类属性和实例属性。
a、类属性：指定义在类中，并且在函数体外的属性。类属性可以在类的所有实例之间共享值，也就是在所有实例化的对象中共用。
类属性可以通过类名称或者实例名访问
#例：
class People: #定义类
'''人类'''
hand = "用手劳作" #在类中定义变量/属性
foot = "用脚赶路"
def __init__(self): #构造方法
print("人类居住在地球")
print(People.hand) #通过类名访问属性，然后输出
print(People.foot)
WlidPeople = People() #创建实例
class People: #定义类
'''人类'''
hand = "用手劳作" #在类中定义变量/属性
foot = "用脚赶路"
number = 0 #编号
def __init__(self): #构造方法
People.number += 1
print("\n我是第"+str(People.number)+"个人")
print("人类居住在地球")
print(People.hand) #通过类名访问属性，然后输出
print(People.foot)
#创建4个人类的对象/相当于有四个人
list1 = []
for i in range(4): #循化4次
list1.append(People()) #创建实例
print("一共有"+str(People.number)+"个人")
#WlidPeople = People() #创建实例
People.eye = "用眼睛发现身边的美" #添加类属性
print("第一个人：",list1[0].eye) #访问类属性
b、实例属性：指定义在类的方法中的属性，只作用于当前实例
实例属性只能通过实例名访问
#例：
class People: #定义类
'''人类'''
def __init__(self): #构造方法
hand = "用手劳作" # 在类的方法中定义实例属性
foot = "用脚赶路"
print("人类居住在地球")
print(hand) #通过实例属性名称访问该属性，然后输出
print(foot)
WlidPeople = People() #创建实例
对于实例属性可以通过实例名称修改，与类属性不同，通过实例名称修改实例属性后，并不影响该类的另一个实例中相应的实例属性的值
#例：
class People: #定义类
'''人类'''
def __init__(self): #构造方法
hand = "用手劳作" # 在类的方法中定义实例属性
print(hand) #通过实例属性名称访问该属性，然后输出
People1 = People() #创建实例
People2 = People()
People1.hand = "勤劳的双手" #修改实例属性
print("People1的hand的属性：",People1.hand)
print("People2的hand的属性：",People2.hand)
5.访问限制
在类的内部可定义属性和方法，而在类的外部则可以直接调用属性或方法来操作数据，从而隐藏了类内部的复杂逻辑
为了保证类内部的某些属性或方法不被外部访问，可以在属性或方法名前面添加单下划线、双下划线或首尾加双下划线，从而限制访问权限
(1)_foo:以单下划线开头的表示保护类型的成员，只允许类本身和子类进行访问，但不能使用“from module import*”导入
保护属性可以通过实例名称访问
#例：
class People: #定义类
'''人类'''
_hand = "用手劳作" # 定义保护属性
def __init__(self): #构造方法
print("在实例方法中访问：",People._hand) #在实例方法中访问保护属性
WlidPeople = People() #创建实例
print("直接访问：",WlidPeople._hand) #通过实例名称直接访问
(2)__foo:双下划线表示私有类型的成员，只允许定义该方法的类本身进行访问，不能通过类的实例名称进行访问，可以通过“类的实例名._类名__xxx”访问
#例：
class People: #定义类
'''人类'''
__hand = "用手劳作" # 定义私有属性
def __init__(self): #构造方法
print("在实例方法中访问：",People.__hand)
WlidPeople = People() #创建实例
print("加入类名直接访问：",WlidPeople._People__hand)#通过“实例名._类名__hand”访问
(3)__foo__:首尾双划线表示定义特殊方法，一般是系统定义名称，如：__init__()
3.属性(property)
1.创建用于计算的属性
在Python中，可以通过@property（装饰器）将一个方法转换为属性，从而实现用于计算的属性。
将方法转换为属性后，可以直接通过方法名来访问方法
语法:@property
def methodname(self):
block
methodname：用于指定方法名，一般使用小写字母开头。该名称最后将作为创建的属性名
self：必要参数，表示类的实例
block：方法体，实现的具体功能。在方法体中，通常以return语句结束，用于返回计算结果。
#例：
class Rect: #定义类
def __init__(self,width,height): #构造方法
self.width = width #矩形的宽
self.height = height #矩形的高
@property #将方法转为属性
def area(self): #定义计算矩形的面积的方法
return self.width*self.height #返回矩形的面积
rect = Rect(800,600) #创建类的实例
print("矩形的面积为：",rect.area) #输出属性的值
2.为属性添加安全保护机制
在Python中，默认情况下，创建的类属性或者实例时可以在类体外进行修改的，如果想要限制其不能在类体外修改，可以将其设置为私有的，但设置为私有后，在类体外也不能获取它的值。
如果想要创建一个可以读取，但不能修改的属性，可以使用@property实现只读属性。
#例:
class TVshow: #定义电视节目类
def __init__(self,show): #构造方法
self.__show = show #定义私有的实例属性
@property #将方法转换为属性
def show(self): #定义show()方法
return self.__show #返回私有属性的值
tvshow = TVshow("正在播放《攀登者》") #创建类的实例
print("默认：",tvshow.show) #获取属性值
#例：定义一个电视节目类TVshow，并在该类中定义一个类属性，用于保存电影列表，然后在__init__()方法中定义一个私有实例属性，在将该属性转换为可读、可修改的属性，最后创建类的实例，并获取和修改属性值
class TVshow: #定义电视节目类
list_film=["攀登者","中国机长","我和我的祖国"]
def __init__(self,show): #构造方法
self.__show = show #定义私有的实例属性
@property #将方法转换为属性
def show(self): #定义show()方法
return self.__show #返回私有属性的值
@show.setter #设置setter方法，让属性可修改
def show(self,value):
if value in TVshow.list_film: #判断值是否在列表中
self.__show = "你选择了《"+value+"》,稍后将播放"
else:
self.__show = "你点播的电影不存在"
tvshow = TVshow("《攀登者》") #创建类的实例
print("正在播放：",tvshow.show) #获取属性值
print("你可以从",tvshow.list_film,"中选择要点播的电影")
tvshow.show = "中国机长" #修改属性值
print(tvshow.show) #获取属性值
4.继承
在面向对象编程中，被继承的类称为父类或基类，新的类称为子类或派生类
1.继承的基本语法
语法：class ClassName(baseclasslist):
'''类的帮助信息'''
Statement
ClassName：子类名
baseclasslist：指定要继承的父类名，多个之间用逗号分隔，如果不指定，将使用所有Python对象的根类object
Statement：类体，主要由类变量、方法、属性等定义语句组成。如果不写，可在类体中用pass语句代替
#例：
class Fruit: #定义水果类（父类）
color = "绿色" #定义类属性
def harvest(self,color):
print("水果是："+color+"的") #输出的是形式参数color
print("水果已经收获")
print("水果原来是："+Fruit.color+"的") #输出的是类属性
class Apple(Fruit): #定义苹果类（子类）
color = "红色"
def __init__(self):
print("我是苹果")
apple = Apple() #创建实例
apple.harvest(apple.color) #调用父类的harvest方法
2.方法重写
当父类中的方法不完全适用与子类时，就需要在子类中重写父类的这个方法
#例：
class Fruit: #定义水果类（父类）
color = "绿色" #定义类属性
def harvest(self,color):
print("水果是："+color+"的") #输出的是形式参数color
print("水果已经收获")
print("水果原来是："+Fruit.color+"的") #输出的是类属性
class Apple(Fruit): #定义苹果类（子类）
color = "红色"
def __init__(self):
print("我是苹果")
def harvest(self,color): #方法重写
print("苹果是：" + color + "的") # 输出的是形式参数color
print("苹果已经收获")
print("苹果原来是：" + Fruit.color + "的") # 输出的是类属性
apple = Apple() #创建实例
apple.harvest(apple.color) #调用父类的harvest方法
3.派生类中调用基类的__init__()方法
在子类中定义__init__()方法时，不会自动调用父类的__init__()方法。需要在子类中使用super()函数才能调用
#例：
class Fruit: #定义水果类（父类）
def __init__(self,color = "绿色"):
Fruit.color = color #定义类属性
def harvest(self):
print("水果原来是："+Fruit.color+"的") #输出的是类属性
class Apple(Fruit): #定义苹果类（子类）
def __init__(self):
print("我是苹果")
super().__init__() #调用父类的__init__()方法
apple = Apple() #创建实例
apple.harvest() #调用父类的harvest方法
#例：综合实例运用
class Fruit: #定义水果类（父类）
def __init__(self,color = "绿色"):
Fruit.color = color #定义类属性
def harvest(self,color):
print("水果是：" + self.color + "的") # 输出的是形式参数color
print("水果原来是："+Fruit.color+"的") #输出的是类属性
class Orange(Fruit): #定义子类
color = "黄色"
def __init__(self):
print("我是橘子")
super().__init__() #调用父类的__init__()方法
class Apple(Fruit): #定义苹果类（子类）
def __init__(self,color):
print("我是苹果")
super().__init__() #调用父类的__init__()方法
def harvest(self,color): #重写harvest()方法
print("苹果是："+color+"的")
print("苹果原来是："+Fruit.color+"的")
orange = Orange()
orange.harvest(orange.color)
apple = Apple("青色") #创建实例
apple.harvest("红色") #调用父类的harvest方法
第十章 模块（Modules）
1.模块的概述
定义：一个扩展名为.py的文件就是一个模块（一个程序文件）
2.自定义模块
1.创建模块
创建模块可以将模块中相关的代码（变量定义和函数定义等）编写在一个单独的文件中，并且将文件名命名为：“模块名+.py”的形式
注：创建模块时，设置的模块名不能是python自带的标准模块名称
2.使用import语句导入模块
语法：import modulename [as alias]
modulename：导入模块的名称
as alias：为模块起的别名，通过该别名调用次模块
3.使用form…import语句导入模块
使用form...import语句导入模块后，不需要再添加前缀，直接通过具体的变量、函数和类名等访问即可。
语法：form modelname import member
modelname：导入的模块名称
member：用于指定要导入的变量、函数或者类等。
4.模块搜索目录
3.Python中的包
1.Python程序的包结构
2.创建和使用包
3.以主程序的形式执行
4.引用其他模块
1.导入和使用标准模块
#例：生成有数字、字母组成的4位验证码
import random #导入标准模块random()用于生成随机数
if __name__=="__main__":
checkcode ="" #保存验证码的变量
for i in range(4): #循环四次
index =random.randrange(0,4) #生成0~3中的一个数
if index != i and index + 1 != i:
checkcode += chr(random.randint(97,122)) #生成a~z中的一个小写字母
elif index + 1 ==i:
checkcode += chr(random.randint(65,90)) #生成A~Z中的一个大写字母
else:
checkcode += str(random.randint(1,9)) #生成1~9中的一个数字
print("验证码：",checkcode)
第十一章 异常处理及程序调试
1.异常概述
2.异常处理语句
1.try…except语句
2.
3.程序调试
4.
第十二章 文件及目录操作
1.基本文件操作
1.创建和打开文件
在Python中，想要操作文件需要先创建或者打开指定的文件并创建文件对象，这可以通过内置的open()函数实现；
语法：
file=open(filename[,mode[,buffering]])
file：被创建的文件对象
filename：要创建或者打开文件的名称，需要使用单引号或者双引号括起来。如果要打开的文件和当前文件在同一目录，可以直接写文件名，否则需要指定完整路径。
mode：可选参数，用于指定文件的打开模式
r：以只读模式打开文件
rd：以二进制格式打开文件，并且采用只读模式。一般用于非文本文件，如图片、音乐
r+：打开文件后，可以读取文件内容，也可以写入新的内容覆盖原有内容
rd+：以二进制模式打开文件，并且采用读写模式。一般用于非文本文件，如图片、音乐
w：以只写模式打开文件
........
buffering：可选参数，用于指定读写文件的缓冲模式，值为0表示不缓存，值为1表示缓存；如果大于1，表示缓冲区的大小。默认为缓存模式
open()方法经常实现以下几个功能
1.打开一个不存在的文件时先创建该文件
在默认情况下，使用open()函数打开一个不存在的文件，会抛出异常，通常有两种解决方式：
a：在当前目录下创建一个名称为status.txt的文件
b：在调用open()函数时，指定mode的参数值为w 、w+、a、a+ 这样当要打开的文件不存在时，就可以创建新的文件了。
2.以二进制形式打开文件
3.打开文件时指定编码方式
file = open('new.txt','r',encoding='填编码方式')
2.关闭文件
关闭文件可以使用文件对象的close()方法实现
语法：
file.close()
3.打开文件时使用with语句
with语句，用于在处理文件时，无论是否抛出异常，都能保证with语句执行完毕后关闭已经打开的文件。
语法：
with expression as target:
with-body
expression：用于指定一个表达式，可以是打开文件的open()函数
target：用于指定一个变量，并且将expression的结果保存到该变量中
with-body：用于指定with语句体，其中可以是执行with语句后相关的一些操作语句。如果不想执行任何语句，可以直接用pass代替
4.写入文件内容
write()方法，可以向文件中写入内容。
使用write()函数的前提：打开文件时，指定的打开模式为：w或者a(追加) 否则将抛出异常
语法：
file.write(string)
file：为打开的文件对象
string：要写入的字符串
#例：
print("\n","="*10,"文件","="*10)
text = open("D:\\message.txt",'w') #创建或打开保存信息的文件
#写入一条动态信息
text.write("python例题12.1.4：写入文件内容")
print("\n 写入了一条动态.......\n")
text.close() #关闭文件对象
5.读取文件
1.读取指定字符
使用read()方法读取指定个数的字符，从文件的开头读取。
使用read()方法的前提：指定的打开模式为：r(只读)或者r+(读写)，否则将报错
语法：
file.read(size)
size：可选参数，用于指定要读取的字符个数，如果省略则表示一次读取全部内容
#例：
with open('D:\\message.txt','r')as text: #打开文件
string = text.read(6) #读取前6个字符
print(string)
如果想要读取部分数据，可以先使用文件对象的seek()方法将文件的指针移到新的位置，然后再应用read(size)方法读取
语法：
file.seek(offset[,whence])
offset：用于指定移动的字符个数；注：此方法一个汉字占两个字符、英文和数字占一个字符计算
whence：用于指定从什么位置开始计算，值为0表示从文件的开头计算，1表示从文件当前位置开始计算，2表示从文件尾开始计算，默认值为0
#例：
with open('D:\\message.txt','r')as text:
text.seek(4,0) #移动文件指针到新的位置
string = text.read(6) #读取6个字符
print(string)
2.读取一行
使用readline()方法每次读取一行数据
使用readline()方法的前提：指定的打开模式为：r(只读)或者r+(读写)，否则将报错
语法：
file.readline()
#例：使用while语句创建循环，并调用readline()方法读取一条消息并输出，判断内容是否已经读取完毕，完毕后使用break语句跳出循环
with open('D:\\message.txt','r')as text:
number = 0
while True:
number += 1
line = text.readline()
if line=='':
break
print(number,line,end="\n")
3.读取全部行
读取全部行的作用与调用read()方法是不指定size类似，只不过读取全部行时，返回的是一个字符串列表，每个元素为文件的一行内容
使用readlines()方法的前提：指定的打开模式为：r(只读)或者r+(读写)，否则将报错
语法：
file.readlines()
2.目录操作
1.os和os.path模块
在python中，内置了os模块及其子模块os.path用于对目录或文件进行操作。
os模块提供的与目录相关的函数：
getcwd()：返回当前工作目录
listdir(path)：返回指定路径下的文件和目录信息
mkdir(path[,mode])：创建目录
makedirs(path1/path2...[,mode])：创建多级目录
rmdir(path)：删除目录
removedirs(path1/path2...)：删除多级目录
chdir(path)：把path设置为当前工作目录walk(top[,topdown[,onerror]])：遍历目录树，该方法返回一个元组，包括所有路径名、所有目录列表和文件列表3个元素
os.path模块提供的一些操作目录的函数
abspath(path)：用于获取文件或目录的绝对路径
exists(path)：用于判断目录或文件是否存在，如果存在返回True，否则返回False
join(path,name)：将目录与目录或者文件名拼接起来
splitext()：分离文件名和扩展名
basename(path)：从一个目录中提取文件名
dirname(path)：从一个路径中提取文件路径，不包括文件名
isdir(path)：用于判断是否为有效路径
2.路径
1.相对路径
import os
print(os.getcwd()) #输出当前目录
2.绝对路径
print(os.path.abspath(path)) #获取绝对路径
path：可以为绝对路径的相对路径，也可以是文件，也可以是目录
3.拼接路径
os.path.join(path1[,path2[,...]]) #拼接字符串
3.判断目录是否存在
os.path.exists(path)
path：要判断的目录，可以采用绝对路径，也可以采用相对路径
返回值：如果存在返回True，否则返回False
4.创建目录
1.创建一级目录
os.mkdir(path,mode=0o777) #注：如果创建的目录存在，则抛出异常
path：用于指定要创建的目录，可以使用绝对路径，也可以使用相对路径
mode：用于指定数值模式，默认值为0o777
#例：先判断目录是否存在，再创建目录
import os
path = "D:\\python练习" #指定要创建的目录
if not os.path.exists(path): #判断目录是否存在
os.mkdir(path) #创建目录
print("创建成功")
else:
print("该目录已建成")
2.创建多级目录
os.makedirs(name,mode=0o777)
5.删除目录
os.rmdir(path) #只能删除空目录;如果要删除的目录不存在，将抛出异常
如果要删除非空目录，则可以使用shutil模块下的rmtree()函数实现
import shutil
shutil.rmtree(path)
6.遍历目录
os.walk(top[,topdown][,onerror][,followlinks])
top：用于指定要遍历内容的根目录
topdown：可选参数，用于指定遍历的顺序，如果值为True，表示自上而下遍历；如果值为False，表示自下而上。默认值为True
onerror：可选参数，用于指定错误处理方式，，默认忽略
followlinks：可选参数
7.高级文件操作
os模块提供的与文件相关的函数
access(path,accessmode)：获取对文件是否有指定的访问权限(读取、写入、执行权限)。accessmode的值是R_OK(读取)、W_OK(写入)、X_OK(执行)、F_OK(存在)。如果有指定权限，则返回1，否则返回0
chmod(path,mode)：修改path指定文件的访问权限
remove(path)：删除path指定的文件路径
rename(src,dst)：将文件或目录src重命名为dst
stat(path)：返回path指定文件的信息
startfile(path[,operation])：使用关联的应用程序打开path指定的文件
#例：
import os
src = "D:\\python练习" #要重命名的文件
dst = "D:\\python练习12.2.7" #重命名后的文件名
if os.path.exists(src): #判断目录是否存在
os.rename(src,dst) #重命名文件
print("目录重命名完毕")
else:
print("目录不存在")
8.获取文件基本信息
通过os模块的stat()函数可以获取文件的基本信息
os.stat(path)
path：为要获取文件基本信息的文件路径，可以是相对路径，也可以是绝对路径
stat()函数的返回值是一个对象，该对象包含很多性。通过这些属性可以获取文件的基本信息
st_mode：保护模式 st_dev：设备名
st_ino：索引号 st_uid：用户ID
st_nlink：硬链接号（被连接数目） st_gid：组ID
st_size：文件大小，单位为字节 st_atime：最后一次访问时间
st_mtime：最后一次修改时间 st_ctime：最后一次状态变化时间
#例：未对输出结果进行格式化，输出的结果为一长串的整数
import os
fileinfo = os.stat("D:\\python练习12.2.7") #获取文件的基本信息
print("文件完整路径：",os.path.abspath("python练习12.2.7")) #获取文件的完整路径
#####输出文件的基本信息#######
print("索引号：",fileinfo.st_ino)
print("设备名：",fileinfo.st_dev)
print("文件大小：",fileinfo.st_size,"字节")
print("最后一次访问时间：",fileinfo.st_atime)
print("最后一次修改时间：",fileinfo.st_mtime)
print("最后一次状态改变时间：",fileinfo.st_ctime)
为了使结果显示的更加直观，还需要对这样的数值进行格式化
#例：
import os
def formatTime(longtime):
'''格式化日期时间的函数
longtime:要格式化的时间
'''
import time #导入时间模块
return time.strftime('%Y-%m-%d%H:%M:%S',time.localtime(longtime))
def formatByte(number):
'''格式化文件大小的函数
number:要格式化的字节数
'''
for(scale,label)in [(1024*1024*1024,"GB"),(1024*1024,"MB"),(1024,"KB")]:
if number>=scale: #如果文件大小大于等于1kb
return "%.2f %s" %(number*1.0/scale,label)
elif number == 1: #如果文件大小为1字节
return "1字节"
else: #处理小于1kb的情况
byte = "%.2f" % (number or 0)
#去掉结尾的.00，并且加上单位“字节”
return (byte[:-3] if byte.endswith('.00') else byte+"字节")
if __name__ =='__main__':
fileinfo = os.stat("D:\\python练习12.2.7") #获取文件的基本信息
print("文件完整路径：",os.path.abspath("python练习12.2.7")) #获取文件的完整路径
#####输出文件的基本信息#######
print("索引号：",fileinfo.st_ino)
print("设备名：",fileinfo.st_dev)
print("文件大小：",formatByte(fileinfo.st_size))
print("最后一次访问时间：",formatTime(fileinfo.st_atime))
print("最后一次修改时间：",formatTime(fileinfo.st_mtime))
print("最后一次状态改变时间：",formatTime(fileinfo.st_ctime))
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
