一个布尔值 只有true。false两种
b1=true
b2=false
print（b1，b2）
空值：是python里一个特殊的值，用none表示。none不能理解为0
因为0是有意义的，而none是一个特殊值。
n=none
print（n） none
#存储五个人的年龄，求平均年龄
age1=18
age2=19
age3=20
age4=21
age5=22
print（（age1+。。。+age5）/5）
#嵌套最好不要嵌套
while index<5
SUM+=LIST2[INDEX]
INDEX+=1
IF INDEX==5
PRINT("%D"(SUM/5))
#思考：存储一百个人的年龄
#解决;使用列表解决
#本质：是一种有序的集合
#创建列表
#格式;列表名=【列表选项1，列表选项2，。。。。n】
#创建一个空列表
list1=【】
print=（list1）
#创建带有元素的列表
list2=【18，19，20，21，22】
#注意：内部数据可以使不同类型
list3=【1，2，true，“sunck”】
print=（list3）
#列表元素的访问
#注意不要越界（超出范围）
#取值 格式：列表名【下标】
list4=【1，2，3，4，5】
print(list4(2))
#替换
list4[2]=300
list4[5]=300错误，超界
print(list4)
#列表操作：
#列表组合
list5=【1，2，3】
list6=【4，5，6】
list7=list5+list6
print(list7)
#列表重复
list8=【1，2，3】
print（list8 * 3）
#判断元素是不是在列表中
list9=【12345】
print（3 in list9） true
print（6 in list9） false
#列表截取
list10=【123456789】
print（list【2：5】）
print（list【2：】）
print（list【：5】）
#二维列表
list11=【【1，2，3】，【4，5，6】，【7，8，9】】
print（list【1】【1】） 结果 5
#列表方法
# append添加新的元素
list12=【12345】
list12.append（6）
list12.append（【789】）
print（list12） 123456 123456【789】
#extend 在末尾一次性追加另一个列表中的多个值
list13=【12345】
list.extend（【678】）
print（list13）
#inser 在下标处添加一个元素，不覆盖源数据，元数据顺延
list14=【12345】
list14.insert（2，100）
print（list14） 12100345
#pop（x=list【-1】） 移除列表中指定下标出的元素，默认最后一个元素
并返回删除的数据
list15=【12345】
list15.pop（） 1234
list15.pop（2） 124
print（list15）
#remove 移除列表中的某个元素第一个匹配结果
list16=【12345425】
list16.remove（4）
print（list16）1235425
#clear 全清
list17=【12345】
list17.clear（）
print（print）全清
#index 从列表中找出某个值的第一个匹配值下标
#
list18=【123453】
index18=list18.index（3） 2
#len列表中元素个数
list20=【12345】
print（len（list20）） 5
#max获取最大值
list21=【12345】
print（max（list21）） 5
#min获取最小值
list22=【12345】
print（min（list22）） 1
#查看元素在列表中出现的次数
list23=【123454353356】
print（list23.count（3）） 4
删除全部3
num24=0
all=list23.count（3）
while num24=65 and ord(str2(i))<=90:
str1=str1+chr(ord(str(i))+31)
elif ord(str2(i))>=97 and ord(str2(i))<=122:
str1=str1+chr(ord(str2(i))-31)
else:
str1=str1 + str2(i)
i+=1
print(str1)
第四天
#tuple是一种有序集合
特点：
1.与列表非常相似
2.一旦初始化就不能修改
3.使用小括号
定义只有一个的元素的元组
tuple3=（1，） 一定要有逗号
print（tuple3）
print（type（tuple3））
#元组元素的访问
#格式：元组名[下标】
tuple4=（12345）
print（tuple4【0】） 1
print（tuple4【5】） 越界
print（tuple4【-1】） 获取最后一个元素
print（tuple4【-2】） 获取倒数第二个元素
#修改元组
tuple5=（1234【567】）
tuple5[0]=（100）#报错，元组不能变
tuple5【-1】[0]=500 （1234【500 67】）
print（tuple5）
#删除元组，完全删除
tuple6=（123）
del tuple6
print（tuple6）
#元组的操作
t7=（123）
t8=（456）
print（t7+t8）(123456)
#元组重复
t10=（123）
print（t10*3）
#判断元组是否在元组中
t11=（123）
print（4 in t11）
#元组的截取
#格式：元组名[开始下标：结束下标]
#从开始下标截取，截取到结束下标之前
t12=（123456789）
print（t12【3：7】）（4567）
#二维元组
t13=（（1，2），（3，4），（5，6））
print（t13【1】【1】） 4
#元组的方法
t14=（12345）
#len（） 返回元组中元素的个数
print（len（t14））
#max返回最大值 min最小值
print（max（（12345）））
#将列表转元组
list=【123】
t15=tuple（list）
print（t15） （123）
元组的遍历
for i in （12345）
print（i） 1 2 3 4 5
#字典
概述;使用键-值（key-value）存储，具有极快的查找速度
key的特性：注意，字典是无序的
1.字典中的key必须唯一，
2.key必须是不可变的对象
3.字符串，整数等都是不可变的，可以作为key
4.list是可变的，不能作为key
思考;保存多位学生的姓名和成绩
使用字典，学生姓名作为key，成绩作为值
dict1=｛"tom"：60，"lilei"：70｝
#元素的访问
#获取：字典名【key】
print（dict1【"lilei"】）
#print（dict1【"sunck"】｝）报错，以为没有
print(dict1.get("sunck")) none
ret=dict1.get("sunck")
if ret==none；
print（"没有"）
else：
print（"有"）
#添加
dict1【"hanmeimei"】=99
#因为一个key对应一个value，所以多次对一个key的value
赋值，其实就是修改值
dict1【"lilei"】=80
print(dict1)
#删除
dict1.pop（"tom"）
print(dict1)
#遍历
for key in dict1：
print（key，dict1【key】） lilei 80
hanmeimei 99
for value in dict1.values（）#【60，80，99】
print（value） 60 80 99
print（dict1.items（））
for k，v in dict1.items（）：
print（k，v） lilei 80
hanmeimei 99
字典是无序的
for i，v2 in enumerate（dict1）：
print（i，v2） 0 tom
1 lilei
2 hanmeimei
#和list的比较
1.查找和插入的速度极快，不会随着key-value的增加而变慢
2.需要占用大量的内存，内存浪费多
练习：一个单词总共出现多少次
list=str。split（""）
w=""
dict={}
for v in list:
c==dict.get(v)
if c==none:
dict[v]=1
else:
dict[v]+=1
print(dict[w])
list=str.split("")
word=""
dict={}
for i in list:
if dict.get(i)==none:
dict[i]=1
else:
dict[i]+=1
print(dict[word])
第五天
#set类似dict，是一组key集合，不存储value
本质：无序和无重复元素集合
# 创建
#创建set需要一个list或者tuple或者dict作为输入集合
#重复元素在set中会自动被过滤
s1=set（【1，2，3，4，3，2】）
print（s1） ｛1，2，3，4｝
s3=（｛1：“nice”，2：“good”｝） ｛1，2｝
#添加
s4=set（【1，2，3，4，5】）
s4.add（6）｛123456｝
s4.add（3）#可以添加重复，但不会有效果
s4.add（【7，8，9】）报错因为list列表是可变的
s4.add（｛｝）报错，字典可变
s4.add（（7，8，9））｛1，2，3，4，5（7，8，9）｝
#插入整个list，tuple字符串，打碎插入
s5=set（【1，2，3，4，5】）
s5.update（【6，7，8】）
print（s5）｛1，2，3，4，5，6，7，8｝
s5.update（（9，10））同上
#删除
s6=set（【1，2，3，4，5】）
s6.remove（3）
print（s5）｛1，2，4，5
#遍历
s7=set（【1，2，3，4，5】）
for i in s7：
print（i）12345
#set 没有索引
#交集
s8=set（【1，2，3】）
s9=set（【2，3，4】）
a1=s8&s9
print（a1） ｛2，3｝
#并集
a2=s8 | s9
print（a2）｛1，2，3，4｝
类型转换
list-->set
list1=【1，2，3】
set1=set(list)
tuple-->set
tuple1=(1,2,3)
set2=set(tuple)
set-->list
set3={1,2,3}
list3=list(set3)
set-->tuple
set4={1,2,3}
list4=tuple(set4)
list去重复
list=【1，2，3，3】
set5=set（list）
list5=list（set5）
#
from collections import iterable
from collections import iterator
可迭代对象:可以直接作用于for循环的对象统称为可迭代对(interable）
可以用isinstance（）去判断一个对象是否是iterable对象
可以直接作用于for的数据类型一般分为两种
1.集和数据类型，如list。tuple。dict。set。string
2.是generator，包括生成器和带yield的generator function
print（isinstrance（【】，iterable））true
print（isinstrance（（），iterable））true
print（isinstrance（｛｝，iterable））true
print（isinstrance（“”，iterable））true
print（isinstrance（x for x in range（10），iterable））true
迭代器;不但可以作用于for循环，还可以被next（）函数不断的调用并
返回下一个值，直到最后跑出一个stopiteration错误，表示无法
继续返回下一个值
可以被next（）函数调用并不断返回下一个值的对象称为迭代器（iterator对象）
可以使用 isinstance（）函数判断一个对象是否是iterator对象
print（isinstrance（【】，iterator））false
print（isinstrance（（），iterator））false
print（isinstrance（｛｝，iterator））false
print（isinstrance（“”，iterator））false
print（isinstrance（x for x in range（10），iterator））true
只有最后一个是迭代器
l=（x for x in range（10））
print（next（l）） 0
print（next（l）） 1
print（next（l）） 2
print（next（l）） 3
print（next（l）） 4
list1=【1，2，3，4】
print（next（list1））报错
可以转一下就行了
a=iter（【1，2，3，4】）
print（next(a)）1
print（next(a)）2
print（isinstrance（iter（【】），iterator））true
print（isinstrance（iter（“”），iterator））true
print（isinstrance（iter（｛｝），iterator））true
print（isinstrance（iter（（）），iterator））true
案例题
endstr="end"
str=“”
for line in iter（input，endstr）
str+=line + "\n"
print(str)
函数概述：
认识函数：在一个完整的项目中，某些功能会反复的使用。
那么我们会将功能封装成函数，当我们想使用功能的
时候直接调用函数即可
本质：函数就是对功能的封装
优点：
1.简化代码结构，增加了代码的复用度（重复使用的长度）
2.如果想修改某些功能或者修改某个bug，只需要修改对应的函数即可
定义函数;
格式：
def 函数名（参数1，参数2，。。。参数n）：
语句
return 表达式
def：函数代码块以def关键字开始
函数名 ;遵循标识符规则
（）：是参数列表的开始和结束
参数列表（参数1，参数2，。。。参数n）：任何传入函数的变量和参数
必须放在圆括号之间，用逗号分隔。函数从函数的调用者那里获取的信息
冒号：函数内容（封装的功能）以冒号开始，并且缩进
语句：函数封装的功能
return：一般用于结束函数，并返回信息给函数的调用者
、表达式：即为要返回给函数的调用者的信息，
注意：左后的return表达式，可以不写，相当于return none
凯 = “帅”
print（凯） 帅 （一般不这样用）
最简单的函数（无参数无返回值）
def myprint（）：
print（“”）
print（“”）
print（“”）
函数的调用
格式：函数名（参数列表）
函数名：就是 要使用的功能的函数函数名字
参数列表：函数的调用者给函数传递的信息，如果没有参数，小括号也不能省略
函数调用的本质：实参给形参赋值的过程
myprint（）
函数的参数
#需求：编写一个函数，给函数一个字符串和一个年龄，在函数内部打印出来
#形参（形式参数）：定义函数时小括号中的变量，本质是变量
#参数必须按顺序传递，个数目前要对应，一一对应不能少
def myprint（str，age）：
print（str，age）
#实际参数：调用函数时给函数传递的数据，本质是值
a=18
myprint（“sunck is a good man”，a）
函数的返回值
#需求;编写函数，实现功能，给函数两个数，返回这两个数的和
def mySum（num1，num2）：
#将结果返回给函数的调用者
sum=num1+num2
reture sum
#执行完return语句，该函数结束，后面的代码不执行
res = mysum（1，2）
print（res）
传递参数
值传递：传递的不可变类型
string，tuple，number是不可变的
def func1（num）：
num = 10
temp = 20
func1（temp） #num = temp
print（temp） 20
引用传递：传递的可变类型
list，dict，set是可变的
def func2（list）：
list【0】 = 100
list1 = 【12345】
func2（list1）
print（list1）
关键字参数
概念：允许函数调用时参数的顺序与定义时不一致
def myprint（str，age）：
print（str，age）
myprint（age=18，str=“sunck is a good man”）
默认参数
概念：调用函数时，如果没有传递参数，则使用默认参数
#以后要用默认参数，最好将 默认参数放到最后
def myprint（str=“sunck”，age = 18）：
print（str，age）
myprint
不定长参数
概念：能处理比定义时更多的参数
#加了星号*的变量存放所有位命名的变量参数，如果在函数调用时没有指定参数
他就是一个空元组
def func（name，*args）
print（name）
for x in arr
print（x）
func（“sunck”，“nice”，“good”） sunck nice good
#**代表键值对的参数，和*所代表的意义类似
def func2（**kwargs）：
print（kwargs）
func2（x=1，y=2，z=3） {x:1,y:2,c:3}
def func3（*args，**kwargs）接受任何信息
pass 空语句
匿名函数
概念：不实用def这样的语句定义函数，使用lambda来创建匿名函数
特点：
1.lambda只是一个表达式，函数体比def简单
2.lambda的主体是一个表达式，而不是代码块，仅仅只能在
lambda表达式中封装简单的逻辑
3.lambda函数有自己的命名空间且不能访问自由列表之外的或全局命名空间里的参数
4.虽然lambda是一个表达式且只能写一行，它与c和c++内联函数不同。
格式：lambda参数1，参数2，。。。参数n：expression
sum=lambda num1，num2：num1+num2
print（sum（1，2）） 3
第六天
装饰器:
概念：是一个闭包，把一个函数当作参数，返回一个替代版的函数
本质上就是一个返回函数的函数
#简单装饰器
def func1（）
print（“sunck”）
def outer(func)
def inner（）：
print（“*****”）
func（）
return inner
f=outer（func1）
f（）
复杂一点的装饰器
def say（age）：
print（“ is a %d”%（age））
def outer(func)
def inner（age）：
if age《0：
age=0
print（“*****”） 这个装饰器只有一个变量，而且还是个整数
func（age）
return inner
say=outer（say）
say（-10）
#使用@符号将装饰器应用到函数
@outer #相当于say=outer（say）
def say（age）：
print（“ is a %d”%（age））
通用装饰器（想写啥写啥）
def outer（func）：
def inner（*args，**kwargs）：
#添加修饰的功能
func（*args，**kwargs）
return inner
@outer
def say（name，age）：#函数的参数最好不要超过六到七个
print（"%s，%d"，（name，age））
say（sunck，18）
偏函数
import functools
# 进制
print（int（“1010”，base=2）） 10
#偏函数
def int2（str，base=2）：
return int（str，base）
print（int2（“1011”）） 11
#把一个参数固定住，形成一个新的函数
int3=functools。partial（int，base=2）
#变量的作用域
作用域：变量可以使用的范围
程序的变量并不是在所有的位置都能使用，访问的权限决定于变量的位置
作用域：
局部作用域
全局作用域
内建作用域
异常处理：
#需求：当程序遇到问题是不让程序结束，而越过错误，继续向下执行
try......except.....else
格式：
try：
语句t
except 错误码 as e:
语句1
except 错误码 as e:
语句2
except 错误码 as e:
语句n
else：
语句e
注意：else语句可有可无
作用：用来检测try语句块中的错误，从而让except语句捕获错误信息并处理
逻辑：当程序执行到try......except.....else语句时
1.如果当try"语句t"执行出现错误时，会匹配第一个错误码
如果匹配上就执行对应的“语句”
2.如果当try"语句t"执行出现错误时，没有匹配的异常，错误
将会被提交到上一层的try语句。或者到程序的最上层
3.如果当try"语句t"执行出现没有错误时，执行else下的“语句e”
（你得有）
try：
print（3/0）
except nameerror1 as e:
print("没有该变凉")
except nameerror2 as e:
print("除数为零")
else:
print("代码没问题")
print("******")
#使用except而不使用任何的错误类型
try：
print（4/0）
except：
print（“程序出现异常”）
#使用except带着多种异常
try：
print（5/0）
except（错误码1，错误码2）：
print（“出现了错误码1或错误码2”）
#特殊
1.错误就是class（类），所有的错误都继承自BaseException，所以在捕获的时候，它捕获了该类型的错误，还把子类一网打尽
try：
print（3/0）
except BaseException as e:
print("")
except nameerror2 as e:
print("")
2.跨越多层调用，main调用了func2，func2调用了func1，func1出现错误
这是只要main捕获到了解可以处理
def func1（num）：
print（1/num）
def func2(num)
func1(num)
def main():
func2(2)
main() 0.5
try：
main（）
except BaseException as e:
print("")
#try......except.....finally
格式：try......except.....finally
格式：
try：
语句t
except 错误码 as e:
语句1
except 错误码 as e:
语句2
except 错误码 as e:
语句n
finally：
语句f
作用：语句t无论是否有错误都执行最后的语句f
try：
print（3/0）
except BaseException as e:
print("")
finally：
print（“必须执行我”）
#断言
def func（num，div）
assert(div != 0),"div不能为0"
return num/div
print（func（10，0））
1.读文件
读文件过程：
1.打开文件
2。读文件内容
3.关闭文件
打开文件
open（path，flag【，encoding】【，errors】）
path：要打开文件的路径
flag：打开方式 r rb r+ w wb w+ a a+
r 以只读的方式打开文件，文件的描述符放在文件的开头
rb 以二进制格式打开一个文件而且用于只读，文件的描述符放在文件的开头
r+ 打开一个文件用于读写，文件的描述符放在文件的开头
w 打开一个文件只用于写入，如果该文件已经存在会覆盖，不存在则创建一个新文件
wb 打开一个文件只用于写入二进制，如果该文件已经存在会覆盖，不存在则创建一个新文件
w+ 打开一个文件用于读写，如果该文件已经存在会覆盖，不存在则创建一个新文件
a 打开一个文件用于追加，如果文件存在，文件描述符将会被放到文件末尾
a+
encoding;编码方式
errors：错误处理
path = r“路径”
f = open（path，“r”，encoding=“utf-8”，errors=“ignore”）
一般不写 一般不写
2.读文件内容
1。读取文件的全部内容
str1=f。read（）
print（str1）
2.读取指定字符数
str2=f。read（10）
print（str2）
3.读取整行，包括“|n”字符
str4=f。rendline（）
print（str4）
str5=f。rendline（）
print（str5）
4.读取指定字符数
str6=f。rendline（10）
print（str6）
5.读取所有行并返回列表
list7=f。readlines（）
print（list7）
6.若给定的数字大于0，返回实际size字节的行数
list8=f。readlines（25）
print（list8）
#seek修改描述符的位置
f。seek（10） s a good man
str9=f。read（）
print（str9）
3关闭文件
f。close（）
#一个完整的过程
try：
f1=open（path，“r”，encoding=“utf-8”）
print（f1.read（））
finally：
if f1：
f1.close（）
#最简单的
with open（path，“r”，encoding=“utf-8”） as f2：
print（f2.read（））
第七天
函数也是一种数据类型
def sum（a，b）：
return a+b
res=sum(1，2）
print（res）
写文件
path=r“路径”
f=open（path，“w”）
#写文件
1.将信息写入缓冲区
f。write（“sunck”）
2.刷新缓冲区 直接把内部缓冲区的数据立刻写入文件，而不是被动的等待自动刷新缓冲区写入
f。flush（）
f。close（）
#编码与解码
path=r“路径”
with open（path，“wb”）as f1：
str=“sunck”
f1.write（str。encode（utf-8）））
with open（path，“rb”）as f2：
data=f2.read（）
print（data）
newdata=data。decode（“utf-8”）
print（newdata）
#list\tuple\dict\set的文件操作
import pickle #数据持久性模块
mylist=【1，2，3，“sunck”】
path=r“路径”
f=open（path，“wb”）
pickle。dump（mylist，f）
f。close（）
#读取
f1=open（path，“rb”）
templist=pickle。load（f1）
print。dump（mylist，f）
f1.close（）
os模块
import os
os：包含了普遍的操作系统的功能
#获取操作系统类型 nt-->windows posix-->linux，unix或mac
print（os.name） nt
#操作系统详细信息（windows不支持）
print（os.uname）
#获取操作系统中的所有环境变量
print（os.environ）
#获取指定环境变量
print（os.environ。get（“”））
#获取当前目录
print（os.curdir）
#获取当前工作目录，即当前python脚本所在的目录
print（os.getcwd（））
#以列表的形式返回指定目录下的所有文件
print（os.listdir（））
#在当前目录下创建新目录
os.mkdir（“sunck”）
#删除目录
os.mrmir（“sunck”）
#获取文件属性
print（os.stat（“sunck”））
#重命名
os.rename（“sunck”，“kaige”）
#删除普通文件
os.remove（“file1.txt”）
#运行shell命令
os.system（“notepad”）
#有些方法错在0s模块里，有些存在0s。path里
#查看当前的绝对路径
print（os。path。abspath（“。”））
#拼接路径
p1=r“”
p2="sunck"
注意：参数2里面开始不要有斜杠
print(os.path.join(p1,p2))
#拆分路径
path2=r“”
print（os。path。split（path2））
#获取扩展名
print（os。path。splittext（path2））
#判断是否是目录
print（os。path。isdir（path2））
#判断文件是否存在
print（os。path。isfile（path2））
#判断目录是否存在
print（os。path。exists（path2））
#获得文件大小（字节）
print（os。path。getsize（path2））
#获取文件的目录
print（os。path。dirname（path2））
#获取文件名
print（os。path。basename（path2））
#控制窗体的显示和隐藏
import win32com
import win32gui
import time
#找出窗体的编号
qqwin=win32gui。findwindow（“”，“”）
#隐藏窗体
win32gui。showwindow（qqwin，win32con。sw_hide）
time。sleep（2）藏2秒
#显示窗体
win32gui。showwindow（qqwin，win32con。sw_show）
while true：
qqwin=win32gui。findwindow（“”，“”）
win32gui。showwindow（qqwin，win32con。sw_hide）
time。sleep（2）
win32gui。showwindow（qqwin，win32con。sw_show）
time。sleep（1）
#控制窗体的位置和大小
import win32com
import win32gui
import time
import random
qqwin=win32gui。findwindow（“”，“”）
#参数1：控制的窗体
#参数2：大致位置
#参数3：位置的x
#参数4：位置的y
#参数5：长度
#参数6：宽度
while true：
x = random.randrange(900)
y = random.randrange(600)
win32gui。setwindowpos（qqwin，win32con。hwnd_topmost，100，100，600，300，win32con.swp_showwindow）
#语音合成
import win32com。client
dehua = win32com。client。dispatch（“sapi。spvoice”）
dehua。speck（“sunck”）
while 1：
dehua。speck（“sunck”）
time。sleep(3)
#内存修改
#进程模块
import win32process
#系统
import win32con
import win32gui
import win32api
import ctypes
process_ALL_ACCESS=(0X000F0000|0X00100000|0XFFF)
#找窗体
win=win32gui。findwindow（“”，“”）
#根据窗体找进程号
hid，pid=win32process。getwindowthreadprocessid（win）
#以最高权限打开进程
p=win32api。openprocess（process_ALL_ACCESS，flase，pid）
data=ctypes。c_long（）
#加载内核模块
md=ctypes。windll。loadlibrary（“路径”）
#读取内存
md.readprocessmemory(int(p),内存,ctypes.byref(data)，4，none)
print("data=",data)
#新植
newdata=ctypes.c_long(10000)
#修改
md.writeprocessmemory(int(p),内存,ctypes.byref(data)，4，none)
第八天
#递归
递归的调用：一个函数，如果调用了自身，这种调用称为递归调用
递归函数：一个会调用自身的函数
凡是循环能干的事，递归都能干
方式：
1.写出临界条件
2.找这一次和上一次的关系
3.假设当前函数已经能用，调用自身计算上一次的结果，
再求出本次的结果
#输入一个数（大于等于1）求1+2+...n的和
def sum(n)：
sum=0
for i in range(1,n+1):
sun+=i
return sum
print(sum)
def sum(n）
if n==1:
return 1
else:
return n+sum2(n-1)
res=sum2(5)
print(res)
#栈（先进后出）
#模拟栈结构
stack = 【】
#压栈（向栈里存数据）
stack。append（“a”）
print（stack）【‘a’】
stack。append（“b”）
print（stack）【‘a’，‘b’】
stack。append（“c”）
print（stack）【‘a’，‘b’，‘c’】
#出栈（在栈里取数据）
res1= stack。pop（）
print（“res=”，res） c
print（stack）【‘a’，‘b’】
res2= stack。pop（）
print（“res2=”，res2） b
print（stack）【‘a’】
#队列（先进先出）
import collections
#创建一个队列
queue=collections.deque()
print(queue) deque（【】）
#进队（存数据）
queue。append（“a”）
print(queue) deque（【“a”】）
#出队（取数据）
res1=queue。popleft（）
print（"res1”。res1）
print（queue） deque（【】）
#递归遍历目录
import os
def getalldir（path，sp=“ ”）：
#得到当前目录下所有文件
fileslist=os。listdir（path）
print（）
#处理每一个文件
sp+=“ ”
for filename in fileslist：
#判断是否是路径（用绝对路径）
if os.path.ISDIR（os.path.join(path,filename)）：
print("目录",filename)
getalldir（os.path.joim(path,filename)，sp）
else:
print("普通文件",filename)
getalldir(r“目录地址”)
#栈模拟递归遍历目录(深度遍历)
def getalldirde(path):
stack=【】
stack.append(path)
#处理栈，当栈为空的时候结束循环
while len （strack）！=0
#从栈里取出数据
dirth =stack.pop（）
#目录下所有文件
fileslist = os.listdir(dirpath)
#处理每一个文件，如果是普通文件打印出来，如果是
目录则将该目录的地址压栈
for filename in fileslist:
fileadspath=os.path.join(dirpath,filename)
if os.path.isdir(fileabspath)
#是目录就压栈
print("目录;"+filename)
stack.append(fileabspath)
else:
#打印普通文件
print（"普通文件;"+filename）
getalldirde(r"路径")
#队列模拟递归遍历目录（广度遍历）
import os
from collections
def getalldirqu(path):
queue=collections.deque()
#进队
queue.append(path)
while len(queue) !=0
#出队数据
dirpath=queue.popleft()
#找出所有的文件
fileslist=os.listdir(dirpath)
for filename in fileslist:
#绝对路径
fileabspath=os.path.join(dirpatn,filename)
if os.path.isdir(fileabspath):
print("目录",filename)
queue.append(fileabspath)
else:
print("普通文件",filename)
#time
UTC(世界协调时间)：格林尼治时间，在中国是utc+8
DST(夏令时)：是一种节约能源而认为规定时间制度，在夏季
调快一个小时
时间的表示形式：
1.时间戳：以整形或浮点型表示时间的一个以秒为单位的时间间隔
这个时间的基础值是从1970年1月1日开始算起
2.元组：一种python的数据结构表示，这个元组有9个整型内容
year
month
day
hours
minutes
seconds
weekday
julia day
flag (1或-1或0)
3.格式化的字符串
#返回当前时间的时间戳，浮点数形式，不需要参数
import time
c=time.time()
print(c)
#将时间戳转成utc时间元组
t=time.gmtime(c)
print(t)
#将时间戳转成本地时间元组
b=time.localtime（c）
print（b）
#将本地时间元组转成时间戳
m=time.mktime(b)
print(m)
#将时间元组转成字符串
s=time.asctime(b)
print(s)
#将时间戳转成字符串
p=time.ctime(c)
print(p)
#将时间元组转换成给定格式字符串，参数2为时间元组，如果没有，默认当前时间
Q=time.strftime("%Y-%m-%d %H:%M:%S"，b)
PRINT(Q)
#将时间字符串转换为时间元组
w=time.strptime(q,"%Y-%m-%d %H:%M:%S")
print(w)
#延迟一个时间，整型或者浮点型
time.sleep(4)
#clock返回当前程序的cpu执行时间
#Unix始终返回全部的运行时间
#windows从第二次开始，都是以第一次调用此函数的开始时间戳作为基数
y=time.clock（）
print（y）
#性能测试
import time
time.clock()
sum=0
for i in range（1000）：
sum+=i
print(time.clock())
#datetime
datetime比time高级了不少，可以理解为datetime基于time进行了封装
提供了个未使用的函数，datetime模块的接口更直观，更容易调用
模块中的类：datetime 同时有时间和日期
timedelta 主要用于计算时间的跨度
tzinfo 时区相关
time 只关注时间
date 只关注日期
#获取当前时间
d1=datetime.datetime.now()
print(d1)
#获取指定时间
d2=datetime.datetime(1999,10,1,10,28,25,123456)
print(d2)
#将时间转为字符串
d3=d1.strftime（“%y-%m-%d %X”）
print(d3)
#将格式化字符串转为datetime对象
#注意：转换的格式要与字符串一致
d4=datetime.datetime.strptime(d3,“%y-%m-%d %X”)
print(d4)
d7=d1-d2
#提取天数
print（d7.days）
#间隔天数除外的秒数
print（d7.seconds）
#calendar日历模块
import calendar
#使用
#返回指定某年某月的日历
print（calendar.month(2017,7)）
#返回指定年的日历
print（calendar.calendar(2017)）
#判断闰年返回true，否则false
print（calendar.isleap(2000)）
#返回某个月的weekday的第一天和这个月的天数
print（calendar.monthrange(2017，7)）
#返回某个月以每一周为元素的列表
print（calendar.monthcalendar(2017，7)）
第九天
#引入模块
import sys
#获取命令行参数的列表
for i in say.argv：
print（i）
#自动查找所需模块路径的列表
print(sys.path)
#使用自定义模块
#一个.py文件就是一个模块
比如sunck.py
def saygood（）：
print（“sunck”）
def saygood（）：
print（“sunck”）
def saygood（）：
print（“sunck”）
#引入自定义模块，不用加.py
import sunck
#注意：一个模块只会被引入一次，防止模块被多次引入
#使用模块中的内容
#格式：模块名.函数名/变量名
sunck.saygood()
#使用自定义模块（from......import语句）
#from...import语句
#作用：从模块中导入一个指定的部分到当前命名空间
#格式：from module import name1
from sunck import saygood
saygood()
#使用自定义模块from....import*语句
作用;把一个模块中的所有内容全部倒入当前命名空间
from sunck import *
say good
最好不要过多使用
#
__name__属性：
模块就是一个可执行的.py文件，一个模块被另一个程序引入。不想让模块中的代码执行
可以使用__name__属性来使程序仅调用模块的一部分
#没一个模块都有一个__name__属性，当其值等于__main__
时，表明该模块自身在执行，否则被引入其他文件
if __name__==“__main__”：
print（）
else：
print（）
#周末作业
import os
from collections
def work（path）
respath=r""
#打开文件
with open (path,"r") as f:
#处理每一行数据
while true:
#12344@163.com---11111
lineinfo=f.readline()
if len(lineinfo)<5
break
#邮箱字符串
#12344@163.com---11111
mailstr=lineinfo.split("---")[0]
#邮箱类型的目录
filetype=mailstr.split(“@”).split(".")
dirstr=os.path.join(respath,filetype)
if not os.path.exists(dirstr):
os.mkdir(dirstr)
filepath=os.path.join(dirstr,filetype+"txt")
with open(filepath,"a") as fw:
fw.write(mailstr+"\n")
def getalldirqu(path):
queue=collections.deque()
#进队
queue.append(path)
while len(queue) !=0
#出队数据
dirpath=queue.popleft()
#找出所有的文件
fileslist=os.listdir(dirpath)
for filename in fileslist:
#绝对路径
fileabspath=os.path.join(dirpatn,filename)
if os.path.isdir(fileabspath):
print("目录",filename)
queue.append(fileabspath)
else:
#处理普通文件
work（fileabspath）
#包
思考：如果不同人编写模块重名咋办？
解决：为了解决模块命名冲突，引入里按目录来组织模块的方法，称为包
特点:引入了包以后，只要顶层的包不予其他人发生冲突，模块就不会发生冲突
注意：目录只有包含一个叫做“__init__”的文件才被认作是一个包
import a.sunck
import b.sunck
a.sunck.saygood
b.sunck.saygood
#安装第三方模块
WINDOWS:勾选里pip和add python.exe to path
mac,linux自带
#要安装三方模块，需要知道模块的名字
#pillow 非常强的的处理图像的工具库
pip install pillow
#windows如果报错，则输入pip install --upgrade pip
#引入了三方库
from PIL import image
#打开图片
im = Image.open("111.jpg")
#查看图片信息
print(im.format,im.size,im.mode)
#设置图片的大小
im.thumbnail((150,100))
#保存成新图片
im.save("temp.jpg","JPEG")
第十天
#第一个python类（创建类）
类名：见名知意，首字母大写，其他遵循驼峰原则
属性：见名知意，其他遵循驼峰原则
行为（方法/功能）：见名知意，其他遵循驼峰原则
类：一种设计类型，本身不占内存空间，跟所学的number
string，boolean等类似。用类创建实例化对象（变量）
对象占内存空间
格式：class 类名（父类列表）：
属性
行为
# object；基类，超类，所有类的父类
一般没有合适的就用object
class Person(object)：
#定义属性（定义变量）
name=“”
age=“”
#定义方法（定义函数）
#注意：方法的参数必须以self当第一个参数
#self代表类的实例（某个对象）
def run（self）：
print（“run”）
def run（self，food）
print（“eat”+food）
#实用类实例化对象
实例化对象：
格式： 对象名=类名（参数列表）
注意：没有参数，小括号也不能省略
#实例化一个对象
per1=Person（）
print（pre1）
per2=Person（）
print（pre2）
#访问对象的属性和方法
per=Person（）
访问属性：
格式：对象名.属性名
赋值：对象名.属性名=新值
per.name="tom"
per.age="18"
print(per.name,per.age) tom 18
访问方法：
格式：对象名.方法名（参数列表）
per.run()
#问题;目前来看person创建的所有对象属性都是一样的
#对象的初始状态（构造函数）
class Person(object)：
#定义属性（定义变量）
name=“”
age=“”
#定义方法（定义函数）
#注意：方法的参数必须以self当第一个参数
#self代表类的实例（某个对象）
def run（self）：
print（“run”）
def run（self，food）
print（“eat”+food）
def __init__(self,name,age)
self.name=name
self.age=age
#构造函数：__init__()在使用类创建对象的时候自动调用
#注意：如果不显示的写出构造函数，默认一个空的
per=Person("hanhan",20)
print(per.name,per.age)
per=Person("lilei",22)
print(per.name,per.age)
#self
self代表类的实例，而非类
哪个对象调用方法，那么该方法中的self就代表那个对象
self.__class__ 代表类名
class Person(object)：
#定义属性（定义变量）
name=“”
age=“”
#定义方法（定义函数）
#注意：方法的参数必须以self当第一个参数
#self代表类的实例（某个对象）
def run（self）：
print（“run”）
def run（self，food）
print（“eat”+food）
def say("%s,%d"%(self.name,self.age))
def __init__(self,name,age)
self.name=name
self.age=age
per.Person("lilei",22)
per.say()
#析构
析构函数：__del__（）释放对象时自动调用
class Person(object)：
#定义属性（定义变量）
name=“”
age=“”
#定义方法（定义函数）
#注意：方法的参数必须以self当第一个参数
#self代表类的实例（某个对象）
def run（self）：
print（“run”）
def run（self，food）
print（“eat”+food）
def say("%s,%d"%(self.name,self.age))
def __init__(self,name,age)
self.name=name
self.age=age
def__del__(self)
print("这里是析构函数")
per=Person("hanmeimei",20)
#手动释放
del per
#对象释放以后就不能在访问了
#在函数里定义的对象，会在函数结束时自动释放，这样可以用来减少内存空间的浪费
def func（）
per2=Person（“aa”，1，1，1）
func（）
#重写 __repr__与__str__函数
重写：将函数重新定义写一遍
__str__（）：再调用print打印对象时自动调用，是给用户用的
__repr__（）：是给机器用的，在python解释器里面直接敲对象回车后的方法
注意：在没有str时，且有repr，str=repr
class Person(object)：
def run（self）：
print（“run”）
def run（self，food）
print（“eat”+food）
def say("%s,%d"%(self.name,self.age))
def __init__(self,name,age)
self.name=name
self.age=age
def __str__（self）
return（“%s-%d”%（self.name,self.age））
#晚间作业：人开枪射击子弹
人
类名：Person
属性：gun
行为：fire
枪
类名：Gun
属性：bulletbox
行为：shoot
弹夹
类名：Bulletbox
属性：bulletcount
行为：
class Bulletbox(object):
def __init__(self,count)
self.bulletcount=count
class Gun(object):
def __init__(self,bulletbox)
self.bulletbox =bulletbox
def shoot(self):
if self.bulletbox.bulletcount==0
print("meizidan")
else:
self.bulletbox.bulletcount-=1
print("shengyuzidan:%d"%(self.bulletbox.bullercount))
class Person(object):
def __init__(self,gun)
self.gun = gun
def fire(self):
self.gun.shoot()
#装子弹
def fillbullet(self):
self.gun.bulletbox.bulletcount=count
from person import person
from gun import gun
from bulletbox import bulletbox
#弹夹
bulletbox=bulletbox(5)
#枪
gun=gun(bulletbox)
#人
per=Person(gun)
per.fire()
per.fire()
per.fire()
per.fire()
per.fire()
#访问限制
class Person(object)：
def run（self）：
print（“run”）
def eat（self，food）
print（“eat”+food）
def say("%s,%d"%(self.name,self.age))
def __init__(self,name,age，money)
self.name=name
self.age=age
self.__money=money
#通过内部的方法，修改私有属性
#通过自定义的方法实现对私有属性的赋值和取值
def setMoney(self,money)
#数据的过滤
if money<0
money=0
self.__money=money
def getMoney(self)
return self.__money
per=Person("hanmeimei",20)
per=10
print（per.age）10
#如果要让内部的属性不被外部直接访问,在属性前加两个下划线（__）
在python中如果在属性前加两个下划线，那么这个属性就变成了私有属性
per.setMoney(10)
print(per.getMoney())
#不能直接访问per__money是因为python解释器把__money
变成里_Person__money，仍然可以用_Person__money，但不建议
#在python中__XX__ 属于特殊变量，可以直接访问
print（per.__age__）
#在python中 _xx变量，可以直接访问，但是按照约定规则，当我们看到这样的变量时
意思是“虽然可以访问，但请把我视为私有变量，不要直接访问我”
print（per._height）
#单继承的实现
class Person(object):
def __init__(self,name,age)
self.name=name
self.age=age
def run(self):
print("run")
def eat(self,food):
print("eat"+food)
from person import Person
class Student(Person):
def __init__(self,name,age)
#调用父类中的__init__
super(Student,self).__init__(name,age)
#子类可以有一些自己独有的属性
self.stuid=1000
from student from Student
stu=Student("tom",18)
print(stu.name,self.age) tom 18
stu.run() run
第十一天
#盖房子
class Person (boject)
def func(self):
print("gaifangzi")
per=Person()
per.func()
#多类
class Father(object):
def __init__(self,money)
self.money=money
def play(self):
print("play")
def func(self):
print("func1")
class Mother(object):
def __init__(self,facevalue)
self.facevalue=facevalue
def eat(self):
print("eat")
def func(self):
print("func2")
#child
from father import Father
from mother import Mother
class Child(Father,Mother):
def __init__(self,money,facevalue):
#写法
Father.__init__(self，money)
Mother.__init__(self，facevalue)
from child import Child
def main():
c=Child(300,100)
print(c.money,c.facevalue)
c.paly ()
c.eat ()
if __name__=="__main__"
main()
#多态
多态：一种事物的多种形态
最终目标：人可以喂任何一种动物
class Cat(object):
def __init__(self,name)
self.name=name
def eat(self):
print(self.name+"吃")
class Mouse(object):
def __init__(self,name)
self.name=name
def eat(self):
print(self.name+"吃")
from cat import Cat
tom=Cat("tom")
tom.eat()
#思考：添加一百种动物，都有name属性和eat方法
#定义一个有name属性和eat方法的Animal类，让所有的动物类都继承自Animal
class Animal(object):
def __init__(self,name)
self.name=name
def eat(self):
print(self.name+"吃")
from animlal import Animal
class Cat(Animal)
def __init__(self,name)
super(Cat,self).__init__(name)
#定义一个人类，可以喂猫和老鼠吃东西
class Person(object):
def feedCat(self，cat):
print("给你食物")
cat.eat()
def feedMouse(self，mouse):
print("给你食物")
mouse.eat()
from person import Person
per=Person()
per.feedCat(tom)
给啥喂啥
def feedAnimal(self,ani)
print("geinishiwu")
ani.eat()
per=feedAnimal(tom)
#对象属性与类属性
class Person(object):
#这里的属性实际上属于类属性（用类名来调用）
name="person"
def __init__(self,name)
#对象属性
self.name=name
print（Person.name） person
per=Person("tom")
#对象属性优先级高于类属性
print(per.name) tom
#动态的给对象添加对象属性
per.age=18 #只针对于当前对象生效，对于类创建的其他对象没作用
print（Person.name） person
per=Person（“lilei”）
print（per2.age）#没有age属性
#删除对象中的某个属性,再调用会使用到同名的类属性
del per.name
print(per.name)
#注意;以后千万不要将类属性和对象属性重名，因为对象属性会
屏蔽类属性，但是删除对象属性后，在使用又能使用类属性了
#动态给实例添加属性和方法
#创建一个空类
from types import MethodType
class Person(object):
__slots__=("name","age","speak")
per=Person（）
#动态添加属性，这体现了动态语言的特点（特点）
per.name=“tom”
print（per.name） tom
#动态添加方法
def say(self):
print("my name is"+self.name)
per.speak=MethodType(say,per)
per.speak()
#思考：如果我们想要限制实例的属性怎么办？
#比如，只允许给对象添加name，age，height属性
#解决：定义类的时候，定义一个是特殊的属性（__slots__）
可以限制动态添加的属性
#@property
class Person(object)
def __init__(self,age)
#直接对外暴露
# self.age=age
self.__age=age
#方法名为受限制的变量去掉双下划线
@property
def age(self):
return self.__age
@age.setter #去掉下划线.setter
def age(self,age):
if age<0
age=0
self.__age=age
习惯用的点语法
per=Person(18)
per.age=100 #相当于调用setAge
print(per.age) 100 #相当于调用getAge
#运算符重载
print(1+2) 3
print("1"+"2") 12
class Person(object):
def __init__(self,num):
self.num=num
# 运算符重载
def__add__(self,other):
return Person(self.num + other.num)
def __str__(self)：
return"num="+str(self.num)
per1=Person(1)
per2=Person(2)
print(per1+per2)
#发短信
#发邮件
import smtplib
#邮件文本
from email.mime.text import MIMEText
SMTPServer=“smtp.163.com”
#发邮件地址
Sender="suncksunck@163.com"
#发送者邮箱密码
passwd=“123456789”
#设置发送的内容
message=“sunck is a good man”
#转换成邮件文本
msg=MIMEText（message）
#标题
msg【“Subject”】=“来自帅哥的问候”
#发送者
msg【"From"】=Sender
#创建SMTP服务器
mailServer=smtplib.SMTP(SMTPServer,25)
#登录邮箱
mailServer.login(sender,passwd)
#发送邮件
mailServer.sendmail(Sender.["sunckcunck@163.com","m1873370097@163.com"],msg.as_string())
#退出邮箱
mailServer.quit()
第十二天银行存管系统
人
类名：User
属性;姓名 身份证号 电话号 卡
行为：
卡
类名：Card
属性; 卡号，密码，余额
行为：
提款机：
类名：ATM
属性;
行为：开户，查询，取款，存款，转转，改密码，锁定，解锁，补卡，销户，退出
管理员
类名：Admin
属性;
行为：管理员界面，管理员登录，系统功能界面
from admin import Admin
from atm import ATM
def main()：
#存储所有用户的信息
allUsers=｛｝
#管理员对象
admin=Admin（）
#管理员开机
admin.printAdminView():
if admin.adminOption():
return -1
while True：
admin.printsysFunctionView（）
#等待用户操作
option=input（“请输入你的操作：”）
if option=“1”
print（“开户”）
elif option=‘2’
print（“查询”）
elif option=‘3’
print（“查询”）
elif option=‘4’
print（“查询”）
elif option=‘5’;
print（“查询”）
elif option=‘6’
print（“查询”）
elif option=‘11’
print（“退出”）
if admin.adminOption():
return -1
time.sleep(2)
if __name__="__main__"
main()
import time
class Admin(object):
admin=“1”
passwd=“2”
def printAdminView(self):
print("***************")
print(" ")
print(" ")
print(" 欢迎登陆 ")
print(" ")
print(" ")
print("***************")
def printsysFunctionView(self):
print("***************")
print("开户（1） 查询（2）")
print("取款（3） 存款（4）")
print("转账（5） 改密（6）")
print("锁定（7） 解锁（8）")
print("补卡（9） 销户（10）")
print("退出（11） ")
print("***************")
#验证登录
def adminOption(self):
inputAdmin=input("请输入管理员帐号：")
if self.admin != inputAdmin:
print("账号输入错误")
return -1
inputPasswd=input("请输入管理员密码：")
if self.passwd != inputPasswd:
print("密码输入错误")
return -1
#能执行到这了说明帐号密码正确
print（“登陆成功，请稍候”）
time.sleep(2)
return 0
#退出函数
def adminQuit（self）:
#ATM类
from card import Card
from user import User
class ATM(object):
def __init__(self):
self.allUsers=｛｝
#开户
def creatUser(self):
#目标;向用户字典中添加一对键值对（卡号-用户）
name=input("请输入名字")
idCard=input("输入身份证号码")
phone=input（“输入电话号码”）
prestoreMoney=（“预存款金额”）
if int（prestoreMoney）<0；
print（“失败”）
return -1
onePasswd=int（input（“设置密码;”））
if not self.checkPasswd(onePasswd):
print("密码输入错误，开户失败")
return -1
#所有需要的信息就全了
cardId=self.randomCardId()
card=Card(cardId,onePasswd,prestoreMoney)
user=User(name,idCard,phone,card)
#存到字典
self.allUser[cardStr]=user
print("开户成功，牢记卡号（%s）"%（cardStr）)
#查询
def searchUserInfo(self):
pass
#取款
def getMoney（self）：
pass
#存款
def saveMoney（self）：
pass
#转账
def transferMoney（self）：
pass
#改密
def changeMoney（self）：
pass
#锁定
def savemoney（self）：
pass
#解锁
def savemoney（self）：
pass
#补卡
def newcard（self）：
pass
#销户
def lillUser（self）：
pass
#user类
class User(object)：
def __init__(self,name,idCard,phone,card)
self.name=name
self.idCard=idCard
self.phone=phone
self.card=card
#card 类
class Card(object):
def __init__(self,cardId.cardPasswd,cardMoney)
self.cardId=cardId
self.cardPasswd=cardPasswd
self.cardMoney=cardMoney
#验证密码
def checkPasswd(self,realPasswd)：
for i in range(3):
tempPasswd=input("请输入密码")
if tempPasswd==realPasswd
return true
return False
#生成卡号
import random
def randomCardId(self):
while true:
str=""
for i in range(6):
ch=chr(random.randrange(ord('0'),ord('9')+1)
str+=ch
return str
#判断是否重复
if not self.allUsers.get(str):
return str
‘’‘NAVH-WK6A-DMVK-DKW3’‘’
网友评论