python期末复习
博主最近考完四六级考试以及web前端中级证书考试，鉴于python期末考试快到了，所以写这个博客，权当复习。
python还是比较简单容易学得，语法比较容易上手，函数跟javascript很类似，总而言之，阅读相关入门书籍，是很容易掌握的。
-
常用数据类型
-
列表：
创建列表、列表元素访问（索引，切片）、增删改查、列表遍历
列表统计、列表排序、列表生成式
1.创建列表
emptylist=[] //创建空列表
emptylist=['岑', '铭', '忠'] //为空列表赋值，也可以直接建立此列表，而不需要上一步2.删除列表
del emptylist //删除emptylist这个空列表3.访问列表元素
emptylist=['岑', '铭', '忠']
print(emptylist) //访问列表元素
//输出结果为：['岑', '铭', '忠']
print(emptylist[2]) //访问emptylist列表里下标为2的元素
//输出结果为：忠 ，下标由0,1,2...开始4.切片：有[ ], [ : ], [ : : ]形式
emptylist=['岑', '铭', '忠']
print(emptylist[0]) //打印下标为0的元素
//结果是：岑
print(emptylist[1:2]) //打印下标为由1开始，从下标2结束的元素
//结果是：['铭'] ， 切片是闭开结构，从下标1开始且包括下标1，从下标2结束但不包括下标2
emptylist=['岑', '铭', '忠','好']
print(emptylist[0:3:2]) //打印下标为由0开始，从下标3结束，且间隔为2的元素
//结果是：['岑', '忠'] 5.列表遍历
emptylist=['岑', '铭', '忠'] //简单的for循环
for i in emptylist: //这里的i可以改为其他的单词
print(i)
//结果为：
岑 //会自动换行
铭
忠
emptylist=['岑', '铭', '忠']
for i in emptylist:
print(i, end='') //加上end=''就不会换行
//结果为：岑铭忠6.添加列表元素
emptylist=['岑', '铭', '忠']
emptylist.append('好') //appand()函数在列表末尾加上元素
print(emptylist)
//结果为：['岑', '铭', '忠', '好']
emptylist=['岑', '铭', '忠']
otherlist=['好', '厉', '害']
emptylist.extend(otherlist) //extend（）函数满足扩展其他列表里面的元素
print(emptylist)
//结果为：['岑', '铭', '忠', '好', '厉', '害']
emptylist=['岑', '铭', '忠']
otherlist=['好', '厉', '害']
emptylist.append(otherlist) //append()对比extend()，append()是插入，
//extend()可以 添加一个列表里面的全部元素
print(emptylist)
//结果为：['岑', '铭', '忠', ['好', '厉', '害']]
emptylist=['岑', '铭', '忠']
emptylist.insert(2, '好') //insert()函数可以在指定位置插入元素
print(emptylist)
//结果为：['岑', '铭', '好', '忠']
emptylist=['岑', '铭', '忠']
after = emptylist.copy() //copy()方法可以复制列表
print(after)
print(emptylist)
//结果为：
['岑', '铭', '忠']
['岑', '铭', '忠']
emptylist=['岑', '铭', '忠']
after = emptylist //直接赋值与上面结果是一样的
print(after)
print(emptylist)
//结果为：
['岑', '铭', '忠']
['岑', '铭', '忠']
7.修改列表元素
emptylist=['岑', '铭', '忠']
emptylist[1] = '好' //直接用下标修改即可
print(emptylist)
//结果为：['岑', '好', '忠']
emptylist=['岑', '铭', '忠']
emptylist=['岑', '好', '忠'] //也可以直接重新赋值，不过博主不推荐
print(emptylist)
//结果为：['岑', '好', '忠']8.删除列表元素
emptylist=['岑', '铭', '忠']
del emptylist[0] //用del语句，直接删除下标
print(emptylist)
//结果为：['铭', '忠']
emptylist=['岑', '铭', '忠']
emptylist.remove("岑") //用remove方法，删除列表的值
print(emptylist)
//结果为：['铭', '忠']
emptylist=['岑', '铭', '忠']
after = emptylist.pop(0) //用pop方法，可以删除指定下标的值，并且可以返回这个值
print(after)
print(emptylist)
//结果为：
岑
['铭', '忠']
emptylist=['岑', '铭', '忠']
after = emptylist.clear() //用clear()方法，可以删除列表里面的值，但是会保留
//列表对象
print(after)
print(emptylist)
//结果为：
None
[]
9.列表统计
emptylist=['岑', '岑', '铭', '忠']
num = emptylist.count("岑") //用count()方法来计算元素在列表中出现的次数
print(num)
//结果为：2
emptylist=['岑', '岑', '铭', '忠']
num = emptylist.index("岑") //用index()方法获取元素在列表中首次出现的下标
print(num)
//结果为：0
emptylist=[1, 2, 3, 4, 5]
num = sum(emptylist) //用sum()方法来统计列表元素中的和
print(num)
//结果为：1510.列表排序
emptylist=[1, 2, 3, 4, 5, 9, 8, 7, 6]
emptylist.sort(reverse=True) //sort()方法用来对列表中的元素进行排序
//reverse = True，表明按照降序排序
print(emptylist)
//结果为：[9, 8, 7, 6, 5, 4, 3, 2, 1]
emptylist=[1, 2, 3, 4, 5, 9, 8, 7, 6]
emptylist.sort() //sort()方法用来对列表中的元素进行排序
print(emptylist)
//结果为：[1, 2, 3, 4, 5, 6, 7, 8, 9]
emptylist=['a', 'b', 'c', 'A', 'B', 'C']
emptylist.sort() //sort()方法对字母排序时，默认先排序大写字母
print(emptylist)
//结果为：['A', 'B', 'C', 'a', 'b', 'c']
emptylist=['a', 'b', 'c', 'A', 'B', 'C']
emptylist.sort(key = str.lower) //sort()方法添加key = str.lower参数时
//表明不区分大小写
print(emptylist)
//结果为：['a', 'A', 'b', 'B', 'c', 'C']
emptylist=['a', 'b', 'c', 'A', 'B', 'C']
after = sorted(emptylist) //sorted()方法不会改变原本列表的顺序
print(after) //sort()方法和sorted()方法作用基本相同
print(emptylist)
//结果为：
['A', 'B', 'C', 'a', 'b', 'c']
['a', 'b', 'c', 'A', 'B', 'C']11.列表生成式
import random //导入random库
num = [random.randint(1, 10) for i in range(5)] //生成随机数字
//random.randint(1, 10)表示随机生成1到10（包括10）的数
//range(5)表示范围是5个数字
print(num)
//结果为：[10, 3, 7, 4, 7]
emptylist = [1, 3, 5, 7, 9]
num = [i**2 for i in emptylist] //i**2表示i的2次方
print(num)
//结果为：[1, 9, 25, 49, 81]
emptylist = [1, 3, 5, 7, 9]
num = [i**2 for i in emptylist if i > 5] //添加 if语句，增加条件
print(num)
//结果为：[49, 81]元组
创建元组、删除元组、元组元素访问、元组生成式
列表与元组区别
1.创建元组
tuple = () //创建空元组
print(tuple)
//结果为：()
emptytuple = ("岑", "铭", "忠") //直接赋值
print(emptytuple)
//结果为：('岑', '铭', '忠')
emptytuple = tuple(range(4, 8, 3)) //使用tuple()方法创建数值元组，range(4, 8, 3)表示
//从4开始，到8结束（不包括8），间隔为3
print(emptytuple)
//结果为：(4, 7)
2.删除元组
emptytuple = ("岑", "铭", "忠")
del emptytuple //使用del语句删除元组
print(emptytuple)
//结果为：NameError: name 'emptytuple' is not defined ,显示emptytuple元组没有被定义3.访问元组
emptytuple = ("岑", "铭", "忠")
print(emptytuple) //直接打印元组
//结果为：('岑', '铭', '忠')
emptytuple = ("岑", "铭", "忠")
print(emptytuple[1]) //使用下标打印元组
//结果为：铭
emptytuple = ("岑", "铭", "忠")
print(emptytuple[0:2:1]) //使用切片方法打印元组
//emptytuple[0:2:1]表明从下标0开始，到下标2结束
//（不包括2）,间隔为1的元素
//结果为：('岑', '铭')
4.遍历元组
emptytuple = ("岑", "铭", "忠")
for i in emptytuple: //for循环遍历元组
print(i)
//结果为：
岑
铭
忠
emptytuple = ("岑", "铭", "忠")
for i in enumerate(emptytuple): //enumerate()方法，可以把元组内的元素同时列出下标和数据
print(i)
//结果为：
(0, '岑')
(1, '铭')
(2, '忠')
5.修改元组
emptytuple = ("岑", "铭", "忠")
emptytuple = ("好", "厉", "害") //修改元组，需要重新赋值
print(emptytuple)
//结果为：('好', '厉', '害')
emptytuple = ("岑", "铭", "忠")
after = emptytuple + ("好", "厉", "害") //可以使用+运算符对元组增加元素
print(after)
print(emptytuple)
//结果为：
('岑', '铭', '忠', '好', '厉', '害')
('岑', '铭', '忠')
emptytuple = ("岑", "铭", "忠")
after = emptytuple + ["好", "厉", "害"] //加上[]列表，会产生错误，元组后面只能加元组
print(after)
//结果为：TypeError: can only concatenate tuple (not "list") to tuple
emptytuple = ("岑", "铭", "忠")
emptytuple[0] = "好" //直接修改会出现错误，元组是不可变序列
print(emptytuple)
//结果为：TypeError: 'tuple' object does not support item assignment
emptytuple = ("岑", "铭", "忠")
after = emptytuple + ("好") //元组只有一个元素时，时需要在此元组后添
//要加逗号，不然会出错
print(after)
//结果为：TypeError: can only concatenate tuple (not "str") to tuple
emptytuple = ("岑", "铭", "忠")
after = emptytuple + ("好",) //在此元组后添加逗号
print(after)
//结果为：('岑', '铭', '忠', '好')
6.元组生成式
import random //导入random库
emptytuple = (random.randint(1, 10) for i in range(5)) //建立随机元组生成器对象
emptylist = [random.randint(1, 10) for i in range(5)] //建立随机列表生成器对象
aftertuple = tuple(emptytuple) //使用tuple()方法将其转为元组
afterlist = list(emptylist) //使用list()方法将其转为列表
print(emptytuple) //打印生成器对象
print(aftertuple) //打印元组
print(afterlist) //打印列表
//结果为：
<generator object <genexpr> at 0x000001AD888C2BC8>
(5, 5, 6, 2, 7)
[1, 1, 1, 10, 10]7.元组和列表的区别
- 列表是可变序列，元组是不可变序列
- 列表可以用append(), extend(), insert(), remove(), pop()等方法修改列表，而元组是不可变序列
- 列表可以通过切片来访问和修改元素，而元组只能通过切片访问
- 元组的处理速度比列表快
- 列表不能做字典的键，而元组可以
字典
创建字典、删除字典、字典元素访问
1.创建字典
emptydict = {} //创建字典
print(emptydict)
//结果为：{}
emptydict = dict() //通过dict()方法，创建字典
print(emptydict)
//结果为：{}
lista = ['a', 'b', 'c']
listA = ['A', 'B', 'C'] //建立列表
emptydict = dict(zip(lista, listA)) //通过zip()方法，可以建立数值已存在的字典
print(emptydict)
//结果为：{'a': 'A', 'b': 'B', 'c': 'C'}
lista = ('a', 'b', 'c') //建立元组，键一定得是元组
listA = ('A', 'B', 'C') //值可以是元组，也可以是列表
listB = ['A', 'B', 'C']
emptydict = {lista : listA} //直接赋值
print(emptydict)
emptydict = {lista : listB} //重新赋值
print(emptydict)
//结果为：
{('a', 'b', 'c'): ('A', 'B', 'C')}
{('a', 'b', 'c'): ['A', 'B', 'C']}
emptydict = {'a': 'A', 'b': 'B', 'c': 'C'} //通过直接赋值的方法创建字典
print(emptydict)
//结果为：{'a': 'A', 'b': 'B', 'c': 'C'}
emptydict = {'a', 'b', 'c'}
after = dict.fromkeys(emptydict) //通过dict()方法下的fromkeys()方法创建值为空的字典
print(after)
//结果为：{'c': None, 'b': None, 'a': None}
2.删除字典
emptydict = {'a': 'A', 'b': 'B', 'c': 'C'}
del emptydict //用del语句，删除字典
print(emptydict)
//结果为：NameError: name 'emptydict' is not defined
emptydict = {'a': 'A', 'b': 'B', 'c': 'C'}
del emptydict['a'] //用del语句，删除字典元素
print(emptydict)
//结果为：{'b': 'B', 'c': 'C'}
emptydict = {'a': 'A', 'b': 'B', 'c': 'C'}
emptydict.clear() //用clear()方法，删除字典元素
print(emptydict)
//结果为：{}
emptydict = {'a': 'A', 'b': 'B', 'c': 'C'}
emptydict.pop('a') //用pop方法，删除指定下标的键的元素
print(emptydict)
//结果为：{'b': 'B', 'c': 'C'}
emptydict = {'a': 'A', 'b': 'B', 'c': 'C'}
after = emptydict.popitem() //用popitem方法，删除一个元素并返回这个元素
print(after)
//结果为：('c', 'C')3.访问字典
emptydict = {'a': 'A', 'b': 'B', 'c': 'C'}
print(emptydict) //直接打印字典
//结果为：{'a': 'A', 'b': 'B', 'c': 'C'}
emptydict = {'a': 'A', 'b': 'B', 'c': 'C'}
print(emptydict['a']) //通过键打印值
//结果为：A
emptydict = {'a': 'A', 'b': 'B', 'c': 'C'}
print(emptydict['d'] if 'd' in emptydict else '字典没有这个字母') //给键添加if语句，添
//加条件
结果为：字典没有这个字母
emptydict = {'a': 'A', 'b': 'B', 'c': 'C'}
print(emptydict.get('a')) //使用get()方法，获取键对应的值
结果为：A
4.遍历字典
emptydict = {'a': 'A', 'b': 'B', 'c': 'C'}
for i in emptydict.items(): //使用items()方法，可以获取字典的键值对列表
print(i)
//结果为：
('a', 'A')
('b', 'B')
('c', 'C')
emptydict = {'a': 'A', 'b': 'B', 'c': 'C'}
for x, y in emptydict.items(): //要访问具体的元素，要用两个变量
print(x, y)
//结果为：
a A
b B
c C
emptydict = {'a': 'A', 'b': 'B', 'c': 'C'}
for x, y in emptydict.items(): //或者单独访问
print( y)
//结果为：
A
B
C5.添加 修改字典
emptydict = {'a': 'A', 'b': 'B', 'c': 'C'}
emptydict['d'] = 'D' //通过赋值添加字典元素
print(emptydict)
//结果为：{'a': 'A', 'b': 'B', 'c': 'C', 'd': 'D'}
emptydict = {'a': 'A', 'b': 'B', 'c': 'C'}
emptydict['a'] = 'D' //通过重新赋值，修改键的值
print(emptydict)
//结果为：{'a': 'D', 'b': 'B', 'c': 'C'}
6.字典生成式
import random
emptydict = {i : random.randint(1, 10) for i in range(5)} //建立随机字典
print(emptydict)
//结果为：{0: 7, 1: 6, 2: 5, 3: 3, 4: 2}
lista = ['a', 'b', 'c']
listA = ['A', 'B', 'C']
emptydict = {x + '在' : y for x, y in zip(lista, listA)} //建立字典需要两个变量
print(emptydict)
//结果为：{'a在': 'A', 'b在': 'B', 'c在': 'C'}集合
集合特点，创建集合、删除集合
1.创建集合
emptyset = {'岑', '铭', '忠'} //创建集合
print(emptyset)
//结果为：{'忠', '岑', '铭'} ,集合是无序的，结果每次都可能不相同
emptyset = set(['岑', '铭', '忠']) //使用set()方法，创建集合
print(emptyset)
//结果为：{'岑', '忠', '铭'}，,集合是无序的，结果每次都可能不相同
2.添加 删除集合元素
emptyset = set(['岑', '铭', '忠'])
emptyset.add('好') //使用add()方法，添加一个集合元素
print(emptyset)
//结果为：{'岑', '铭', '忠', '好'}
emptyset = set(['岑', '铭', '忠'])
emptyset.remove('岑') //使用remove()方法，删除一个指定集合元素
print(emptyset)
//结果为：{'忠', '铭'}
emptyset = set(['岑', '铭', '忠'])
emptyset.clear() //使用clear()方法，删除所有集合元素
print(emptyset)
//结果为：set()
emptyset = set(['岑', '铭', '忠'])
emptyset.pop() //使用pop()方法，删除一个集合元素
print(emptyset)
//结果为：{'岑', '忠'}
3.集合的交集 并集 差集运算
emptyset = set(['岑', '铭', '忠', '好', '厉', '害'])
otherset = set(['岑', '铭', '忠'])
print(emptyset & otherset) //交集运算
print(emptyset | otherset) //并集运算
print(emptyset - otherset) //差集运算
//结果为：
{'岑', '铭', '忠'}
{'岑', '忠', '铭', '好', '厉', '害'}
{'害', '厉', '好'}
字符串
字符串表示，字符串索引、切片
字符串格式化（格式字符、format方法）
字符串常用方法：find( )、rfind()、index()、rindex()、count()、split()、join()
lower()、upper()、replace()、strip()、isalnum()、isalpha()、
isdigit()、isdecimal()、isnumeric()、isspace()、isupper()、islower()
字符串比较多函数，但是也比较简单，多加练习很快可以掌握
1.字符串表示
emptystr = "岑铭忠好厉害" //字符串赋值
print(emptystr)
//结果为：岑铭忠好厉害
emptystr = "岑铭忠好厉害"
after = emptystr.encode() //使用encode()方法，对字符串进行编码
print(emptystr)
print(after)
afterstr = after.decode() //使用decode()方法，对已经编码的字符串进行解码
print(afterstr)
//结果为：
岑铭忠好厉害
b'\xe5\xb2\x91\xe9\x93\xad\xe5\xbf\xa0\xe5\xa5\xbd\xe5\x8e\x89\xe5\xae\xb3'
岑铭忠好厉害
emptystr = "岑铭忠"
otherstr = "好厉害"
print(emptystr + otherstr) //使用+运算符可以把字符串拼接起来
//结果为：岑铭忠好厉害
2.字符串索引 切片
emptystr = "岑铭忠好厉害"
print(emptystr[2]) //字符串下标索引
//结果为：忠
emptystr = "岑铭忠好厉害"
print(emptystr[0:5:2]) //字符串切片查找
//结果为：岑忠厉
3.字符串格式化
emptystr = "%02d号%s\t岑铭忠%c级任务完成了%.2f\t好厉害" //%d, %s, %c, %f格式化字符串，
//制定模板
otherstr = (7, '特工','S', 0.99)
print(emptystr % otherstr) //格式化输出
//结果为：07号特工 岑铭忠S级任务完成了0.99 好厉害
emptystr = "{:0>2d}号{:s}岑铭忠{:s}级任务完成了{:.2f}好厉害"//制定格式化模板
after= emptystr.format(7, '特工', 'S', 0.99) //使用format()方法
print(after)
//结果为：07号特工岑铭忠S级任务完成了0.99好厉害4.字符串常用方法
emptystr = "我今天想去广州"
after = len(emptystr) //使用len()方法，计算字符串长度
print(after)
//结果为：7
emptystr = "我今天想去广州"
after = len(emptystr.encode()) //使用encode()方法，可以计算准确字节数
print(after)
//结果为：21
emptystr = "我今天想去广州"
after = emptystr.split('想') //使用split()方法，分隔字符串
print(after)
otherafther = ''.join(after) //使用join()方法,连接字符串
print(otherafther)
//结果为：
['我今天', '去广州']
我今天去广州
emptystr = "我今天想去广州"
num = emptystr.count('想') //使用count()方法，计算字符串出现个个数
print(num)
//结果为：1
emptystr = "我今天想去广州"
after = emptystr.find('想') //使用find()方法，找到字符串出现的位置的下标
print(after)
//结果为：3
emptystr = "我今天想去广州"
after = emptystr.index('想') //使用index()方法，找到字符串出现位置的下标
//与find()方法想必，此方法找不到结果时会报错
print(after)
//结果为：3
emptystr = "我今天想去广州"
after = emptystr.startswith('我今天') //使用startwith()方法，检测是否以特定字符串开
//头，如果是返回True,否则返回False
print(after)
//结果为:True
emptystr = "我今天想去广州"
after = emptystr.endswith('广州') //使用endwith()方法，检测是否以特定字符串结
//尾，如果是返回True,否则返回False
print(after)
//结果为:True
emptystr = "Wo Jin Tian Xiang Qu Guang Zhou"
after = emptystr.lower() //使用lower()方法，把字符串转为小写
print(after)
//结果为:wo jin tian xiang qu guang zhou
emptystr = "Wo Jin Tian Xiang Qu Guang Zhou"
after = emptystr.upper() //使用upper()方法，把字符串转为大写
print(after)
//结果为:WO JIN TIAN XIANG QU GUANG ZHOU
emptystr = "我今天"
otherstr = "我今天想去广州"
after = emptystr.replace(emptystr, otherstr) //使用replace()方法，替换字符串
print(after)
//结果为：我今天想去广州
emptystr = " \t\n\t Wo Jin Tian Xiang Qu Guang Zhou \t\n\t "
after = emptystr.strip() //使用strip()方法，取出字符串两侧的空格或特殊字符
print(after)
//结果为:Wo Jin Tian Xiang Qu Guang Zhou
after = emptystr.lstrip() //使用lstrip()方法，取出字符串左侧的空格或特殊字符
after = emptystr.rstrip() //使用rstrip()方法，取出字符串右侧的空格或特殊字符
5.字符串判断
emptystr = "我今天想去广州"
after = emptystr.isdigit() //判断字符是否为数字
print(after)
//结果为：False
after = emptystr.isalnum() //是否是字母数字
print(after)
//结果为：True
after = emptystr.isdecimal() //是否为十进制数
print(after)
//结果为：False
after = emptystr.isalpha() //是否字母
print(after)
//结果为：True
after = emptystr.islower() //是否小写
print(after)
//结果为：False
after = emptystr.isupper() //是否大写
print(after)
//结果为：False
after = emptystr.isnumeric() //测试是否为数值
print(after)
//结果为：False
after = emptystr.isprintable() //是否为可打印字符
print(after)
//结果为：True
after = emptystr.isspace() //是否空格
print(after)
//结果为：False
after = emptystr.istitle() //判断首字母是否是大写
print(after)
//结果为：False
文件读写
常见编码
文本文件、二进制文件区别
文件基本操作：打开 open(name, mode)，关闭close( )，文件读写
文件遍历，多文件访问
1.创建和打开文件
file = open('test.txt', 'w') //创建一个文件
file = open('test.png', 'w') //创建一张图片
file = open('test.png', 'w', encoding = 'utf8') //以utf8编码格式创建一张图片
file.close() //关闭文件
with open('test.txt', 'w') as file: //用with语句创建或者打开文件
print('我今天想去广州')
file = open('test.txt', 'w')
file.write('我想去广州') //用write()方法，写入文件
file.close() //用close()方法，关闭文件，一定要用，不然保存不了文件
//结果为：我想去广州
with open('test.txt', 'r') as file:
str = file.read(3) //用read()方法，读取文件
print(str)
//结果为：我想去
with open('test.txt', 'r') as file:
file.seek(6) //使用seek()方法，在文件中指定开始读取位置，一个汉字
//占去两个字符，数字和字母占据一个字符，与read()方法不太一样
str = file.read()
print(str)
//结果为：想去广州
with open('test.txt', 'r') as file:
str = file.readline() //用readline()方法，读取一行
print(str)
//结果为：我今天想去广州
with open('test.txt', 'r') as file:
str = file.readlines() //用readlines()方法，读取全部行，会返回字符串列表
print(str)
//结果为：['我今天想去广州\n', '好的']
2.目录操作
import os
print(os.getcwd()) //os.getcwd()方法，输出当前路径
//结果为:C:\Users\Administrator\PycharmProjects\review
import os
print(os.path.abspath('test.txt')) //用os.path.abspath()方法，输出绝对路径
//结果为:C:\Users\Administrator\PycharmProjects\review\test.txt
import os
print(os.path.join('test.txt', 'test.png')) //用os.path.join方法，拼接路径
//结果为：test.txt\test.png ，如果没有绝对路径，那么就是相对路径
import os
after = os.path.join('test.txt', 'test.png')
print(os.path.exists(after)) //用os.path.exists()方法，判断路径是否存在
//结果为：False
3.创建 删除目录
import os
os.mkdir('C:\\test') //使用os.mkdir()方法，创建目录
import os
path = 'C:\\test'
if not os.path.exists(path): //检测目录是否存在
os.mkdir('C:\\test')
print('目录创建好了')
else:
print('目录已经存在')
//结果为：目录已经存在
import os
path = 'C:\\test\\tes\\te\\t'
if not os.path.exists(path):
os.makedirs('C:\\test\\tes\\te\\t') //用os.makedirs()方法，创建多级目录
print('多级目录建好了')
else:
print('目录已经存在')
//结果为：多级目录建好了
import os
path = 'C:\\test\\tes\\te\\t'
os.rmdir(path) //用os.rmdir()方法，删除空目录
if not os.path.exists(path):
print('目录已经删除了')
else:
print('目录还存在')
//结果为：目录已经删除了
import os
path = 'C:\\test'
after = os.walk(path) //用os.walk()方法，遍历目录
for i in after:
print(i, '\n')
//结果为：
('C:\\test', ['tes'], [])
('C:\\test\\tes', ['te'], [])
('C:\\test\\tes\\te', [], [])
4.删除文件 重命名文件 获取文件基本信息
import os
os.remove('test.png') //使用os.remove()方法，删除图片文件
import os
os.rename('test.txt', 't.txt') //使用os.rename()方法，重命名文件
import os
afther = os.stat('t.txt') //使用os.stat()方法，获取文件状态信息
print(afther.st_atime)
print(afther.st_mtime)
print(afther.st_ctime)
print(afther.st_size)
print(afther.st_ino)
print(afther.st_dev)
//结果为：
1577109049.6646597
1577106714.7874308
1577105320.7951963
20
10414574138558993
676911549异常处理
捕获已知错误，捕获未知错误
异常传递
def check():
try: //try，捕获异常
assert if a<b: //assert, 应用断言调试，只在调试阶段有效
raise ValueError('数字异常') //raise语句，抛出异常
except ZeroDivisionError: //except,捕获ZeroDivisionError异常
print('捕获ZeroDivisionError异常')
else: //else，没有抛出异常时进行
print('没有抛出异常时进行')
finally: //不管有没有异常，最后都执行这里的语句
print('不管有没有异常，最后都执行这里的语句')
if __name__ == '__main__': //初始化实例
check()进程与线程
程序、进程、线程基本概念
创建进程常用方法：multiprocessing模块，Process类常用方法，Pool类常用方法
进程间通信：队列基本特点，Queue类常用方法
创建线程：Threading模块，Thread子类
线程间通信：共享全局变量，互斥锁，线程间队列通信
1.创建进程
from multiprocessing import Process //导入模块
def sonprocess(i):
print('我是子进程(%d)'% i)
def main():
print('主线程开始')
p = Process(target=sonprocess, args=(1,)) //实例化Process进程类
p.start() //启动子进程
print('主线程结束')
if __name__=='__main__':
main()
//结果为：
主线程开始
主线程结束
我是子进程(1)
创建两个子进程，并记录子进程运行时间：
from multiprocessing import Process //导入模块
import time
import os
def child1(i):
print('子进程(%s)开始执行，父进程为（%s)'%(os.getpid(), os.getppid()))
start = time.time()
time.sleep(i)
end = time.time()
print("子进程(%s)执行时间为'%0.2f'秒"%(os.getpid(), end-start))
def child2(i):
print('子进程(%s)开始执行，父进程为（%s)' % (os.getpid(), os.getppid()))
start = time.time()
time.sleep(i)
end = time.time()
print("子进程(%s)执行时间为'%0.2f'秒"%(os.getpid(), end-start))
if __name__ == '__main__':
print("------父进程------")
print("父进程PID: %s" % os.getpid())
p1 = Process(target=child1,args=(1,)) //实例化进程
p2 = Process(target=child2,args=(2,))
p1.start() //启动进程
p2.start()
print("p1.is_alive=%s"%p1.is_alive())
print("p2.is_alive=%s"%p2.is_alive())
print("p1.name=%s" % p1.name)
print("p1.pid=%s" % p1.pid)
print("p2.name=%s" % p2.name)
print("p2.pid=%s" % p2.pid)
print("------等待子进程------")
p1.join() //等待进程结束
p2.join()
print("------父进程结束------")
//结果为：
------父进程------
父进程PID: 11812
p1.is_alive=True
p2.is_alive=True
p1.name=Process-1
p1.pid=17400
p2.name=Process-2
p2.pid=4232
------等待子进程------
子进程(17400)开始执行，父进程为（11812)
子进程(4232)开始执行，父进程为（11812)
子进程(17400)执行时间为'1.00'秒
子进程(4232)执行时间为'2.00'秒
------父进程结束------2.使用Process子类创建进程
from multiprocessing import Process
import time
import os
class SubProcess(Process):
def __init__(self, i, name=''):
Process.__init__(self) //调用Process父类的初始化方法
self.i = i
if name:
self.name = name
def run(self): //重写Process类的run()方法
print('子进程(%s)开始执行，父进程为（%s)'%(os.getpid(), os.getppid()))
start = time.time()
time.sleep(self.i)
end = time.time()
print("子进程(%s)执行时间为'%0.2f'秒" % (os.getpid(), end - start))
if __name__ == '__main__':
print("------父进程------")
print("父进程PID: %s" % os.getpid())
p1 = SubProcess(i = 1, name = 'cenmingzhong')
p2 = SubProcess(i = 2)
p1.start()
p2.start()
print("p1.is_alive=%s"%p1.is_alive())
print("p2.is_alive=%s"%p2.is_alive())
print("p1.name=%s" % p1.name)
print("p1.pid=%s" % p1.pid)
print("p2.name=%s" % p2.name)
print("p2.pid=%s" % p2.pid)
print("------等待子进程------")
p1.join()
p2.join()
print("------父进程结束------")
//结果为：
------父进程------
父进程PID: 4896
p1.is_alive=True
p2.is_alive=True
p1.name=cenmingzhong
p1.pid=13824
p2.name=SubProcess-2
p2.pid=6740
------等待子进程------
子进程(13824)开始执行，父进程为（4896)
子进程(6740)开始执行，父进程为（4896)
子进程(13824)执行时间为'1.00'秒
子进程(6740)执行时间为'2.00'秒
------父进程结束------3.进程池pool
from multiprocessing import Pool
import time
import os
def task(name):
print('子进程(%s)执行task%s...' % (os.getpid(), name))
time.sleep(1) #休眠一秒
if __name__=='__main__':
print("父进程(%s)." % os.getpid())
p = Pool(3) #定义一个进程池
for i in range(10): #从0开始循环十次
p.apply_async(task, args=(i,)) #使用非阻塞方式调用task()方法
print("等待所有子进程结束...")
p.close() #关闭进程池，不接受新的请求
p.join() #等待子进程结束，必须在close()方法后使用
print("所有子进程结束")
#结果为：
父进程(16000).
等待所有子进程结束...
子进程(15620)执行task1...
子进程(15164)执行task0...
子进程(10908)执行task2...
子进程(15620)执行task3...
子进程(15164)执行task4...
子进程(10908)执行task5...
子进程(15620)执行task6...子进程(15164)执行task7...
子进程(10908)执行task8...
子进程(15620)执行task9...
所有子进程结束
from multiprocessing import Pool
import time
import os
def task(name):
print('子进程(%s)执行task%s...' % (os.getpid(), name))
time.sleep(1)
if __name__=='__main__':
print("父进程(%s)." % os.getpid())
p = Pool(3)
for i in range(10):
p.apply(task, args=(i,)) #使用阻塞方式调用task()方法，等待上一个进程
#退出才能运行下一个进程
print("等待所有子进程结束...")
p.close()
p.join()
print("所有子进程结束")
#结果为：
父进程(16720).
子进程(4208)执行task0...
子进程(17248)执行task1...
子进程(16892)执行task2...
子进程(4208)执行task3...
子进程(17248)执行task4...
子进程(16892)执行task5...
子进程(4208)执行task6...
子进程(17248)执行task7...
子进程(16892)执行task8...
子进程(4208)执行task9...
等待所有子进程结束...
所有子进程结束4.进程间通信
进程之间不可以共享全局变量
from multiprocessing import Queue
if __name__=='__main__':
q = Queue(3) #初始化一个Queue对象，最多可以接受3条消息
q.put("消息1")
q.put("消息2")
print(q.full())
q.put("消息3")
print(q.full)
try:
q.put("消息4", True, 2) #等待2秒，再抛出异常
except:
print("消息队列已满，现有消息数量：%s" % q.qsize())
try:
q.put_nowait("消息4")
except:
print("消息队列已满,现有消息数量：%s" % q.qsize())
if not q.empty(): #如果不是空，就读取
print("---从队列中获取消息---")
for i in range(q.qsize()):
print(q.get_nowait())
if not q.full(): #如果没有满，就写入
q.put_nowait("消息4")
#结果为：
False
<bound method Queue.full of <multiprocessing.queues.Queue object at 0x000001C7F0E9CC88>>
消息队列已满，现有消息数量：3
消息队列已满,现有消息数量：3
---从队列中获取消息---
消息1
消息2
消息3
from multiprocessing import Process,Queue
import time
def writetask(q):
if not q.full():
for i in range(5):
message = "消息" + str(i)
q.put(message)
print("写入：%s" % message)
def readtask(q):
time.sleep(1) #休眠一秒
while not q.empty():
print("读取： %s" % q.get(True, 2)) #等待2秒，没有读取任何消息就抛出异常
if __name__=='__main__':
print('---父进程---')
q = Queue() #父进程创建Queue,并传给各个子进程
pw = Process(target=writetask, args=(q,)) #实例化写入队列的子进程，并且传递队列
pr = Process(target=readtask, args=(q,))
pw.start()
pr.start()
pw.join()
pr.join()
print("---父进程结束---")
//结果为:
---父进程---
写入：消息0
写入：消息1
写入：消息2
写入：消息3
写入：消息4
读取： 消息0
读取： 消息1
读取： 消息2
读取： 消息3
读取： 消息4
---父进程结束---5.创建线程
import threading,time
def process():
for i in range(3):
time.sleep(1)
print("thread name is %s" % threading.current_thread().name)
if __name__=='__main__':
print("---主线程开始---")
threads = [threading.Thread(target=process) for i in range(4)] #创建四个线程，存入
#列表
for t in threads:
t.start()
for t in threads:
t.join()
print("---主线程结束---")
//结果为：
---主线程开始---
thread name is Thread-3thread name is Thread-4thread name is Thread-1
thread name is Thread-2
thread name is Thread-4thread name is Thread-3thread name is Thread-1
thread name is Thread-2
thread name is Thread-1
thread name is Thread-2
thread name is Thread-3
thread name is Thread-4
---主线程结束---#很明显，线程的执行顺序是不确定的
import threading,time
class SubThread(threading.Thread): #继承threading.Thread类
def run(self): #重写run()方法
for i in range(3):
time.sleep(1)
msg = "子线程" + self.name + '执行， i = '+ str(i) #name属性中保存当前线程的名字
print(msg)
if __name__ == '__main__':
print("主线程开始")
t1 = SubThread() #创建子线程t1
t2 = SubThread()
t1.start()
t2.start()
t1.join()
t2.join()
print("---主进程结束---")
//结果为：
主线程开始
子线程Thread-1执行， i = 0子线程Thread-2执行， i = 0
子线程Thread-2执行， i = 1子线程Thread-1执行， i = 1
子线程Thread-1执行， i = 2子线程Thread-2执行， i = 2
---主进程结束---6.线程间通信
线程之间可以共享全局变量
from threading import Thread,Lock #导入Lock模块
import time
n = 100 #共100张票
def task():
global n
mutex.acquire() #上锁
temp = n #赋值给临时变量
time.sleep(1) #休眠1秒
n = temp - 1
print("购买成功，剩余%d张电影票" % n)
mutex.release() #释放锁
if __name__ =='__main__':
mutex = Lock() #实例化Lock类
tlist = []
for i in range(10):
t = Thread(target=task) #实例化线程类
tlist.append(t) #线程存入列表
t.start()
for t in tlist:
t.join()
//结果为：
购买成功，剩余99张电影票
购买成功，剩余98张电影票
购买成功，剩余97张电影票
购买成功，剩余96张电影票
购买成功，剩余95张电影票
购买成功，剩余94张电影票
购买成功，剩余93张电影票
购买成功，剩余92张电影票
购买成功，剩余91张电影票
购买成功，剩余90张电影票
#使用队列在线程中通信
from queue import Queue
import random,threading,time
class Producer(threading.Thread):
def __init__(self, name, queue):
threading.Thread.__init__(self, name = name)
self.data = queue
def run(self):
for i in range(5):
print("生产者%s将产品%d加入队列！" % (self.getName(), i))
self.data.put(i)
time.sleep(random.random())
class Consumer(threading.Thread):
def __init__(self, name, queue ):
threading.Thread.__init__(self, name = name)
self.data = queue
def run(self):
for i in range(5):
val = self.data.get()
print("消费者者%s将产品%d取出队列！" % (self.getName(), val))
time.sleep(random.random())
print("消费者%s完成！" % self.getName())
if __name__ == '__main__':
print('---主线程开始---')
queue = Queue() #实例化队列
producer = Producer('Producer', queue) #实例化线程Producer,并闯入队列作为参数
consumer = Consumer('Consumer', queue)
producer.start() #启动线程Producer
consumer.start()
producer.join()
consumer.join()
print("---主线程结束---")
//结果为：
---主线程开始---
生产者Producer将产品0加入队列！
消费者者Consumer将产品0取出队列！
生产者Producer将产品1加入队列！
消费者者Consumer将产品1取出队列！
生产者Producer将产品2加入队列！
生产者Producer将产品3加入队列！
消费者者Consumer将产品2取出队列！
消费者者Consumer将产品3取出队列！
生产者Producer将产品4加入队列！
消费者者Consumer将产品4取出队列！
消费者Consumer完成！
---主线程结束---网络编程
TCP协议建立连接基本流程，TCP / UDP区别
Socket套接字作用、创建方法，通信流程，常用方法
客户端服务器基本应用程序设计与测试
1.socket
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) #创建Internet进程间通信，TCP/IP套接字
s = socket.socket(socket.UNIX, socket.SOCK_DGRAM) #创建本机进程间通信，UDP/IP套接字2.TCP
#创建TCP客户端
import socket #导入socket模块
s = socket.socket() #创建TCP/IP套接字
host = '127.0.0.1' #获取主机地址
port = 8080 #设置端口号
s.connect((host, port)) #主动初始化TCP服务器连接
send_data = input("请输入要发送的数据：") #提示用户输入数据
s.send(send_data.encode()) #发送TCP数据
recvData = s.recv(1024).decode()
print("接受到的数据为：", recvData)
s.close() #关闭套接字
#制作简易聊天窗口
#server
import socket
host = socket.gethostname()
port = 12345
s = socket.socket(socket.AF_INET, socket.SOCK_DGRERM)
s.bind((host, port))
s.listen(1)
sock, addr = s.accept()
print("连接已经建立")
info = socket.recv(1024).decode()
while info !='byebye':
if info:
print("接收到的内容为：" + info)
send_data = input("输入发送内容：")
sock.send(send_data.encode())
if send_data == 'byebye':
break
info = sock.recv(1024).decode()
sock.close()
s.close()
#client
import socket
s = socket.socket()
port = 12345
s.connect((host, port))
print("已连接")
info = ''
while info !='byebye':
send_data = input("输入发送内容：")
sock.send(send_data.encode())
if send_data == 'byebye':
break
info = sock.recv(1024).decode()
print("接收到的内容为:" + info)
s.close()3.UDP
#创建UDP服务器
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.bind('127.0.0.1', 8888)
print("绑定UDP到8888端口")
data, addr = s.recvfrom(1024)
data = float(data)*1.8 + 32
send_data = '转换后的温度（单位：华氏温度）：' + str(data)
print('Received from %s:%s' % addr)
s.sendto(send_data.encode(), addr)
s.close()
#创建UDP客户端
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
data = input("请输入要转换的温度（单位：设置度）：")
s.sendto(data.encode(), ('127.0.0.1', 8888))
print(s.recv(1024).decode())
s.close()
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
