# 自学<a=>变量定义<print()>屏幕显示信息，直接显示变量，显示文本需加<“”或‘’>
from icecream import ic  # 调用调试函数并赋名ic ic可代替print

ic ("可用ic代替print来查看运行结果")

"""
a = "国庆"
b = "快乐"
c = a+b
print('我的天，终于成功了！！！')
print(c)"""

# \\ "{0} {1}".formart("wodediannao,af","好神奇"),

# 1.1 <while b>循环 条件
# 			<end= |>结束符“|”
'''a,b,c=0,1,2
while b<100:
	print(b,end="|")
	a,b=b,a+b'''

# 1.2<input()>等待输入内容
# 		//<if age>判断 条件
# 		//<elif age>达到条件跳出并显示信息
# 		//<==>判断是否相等

'''
age=int(input("请输入狗狗的年龄:"))
print("")
if age<0:
	print("请输入正确年龄。")
elif age==1:
	print("相当于14岁的人。")
elif age==2:
	print("相当于22岁的人。")
elif age>2:
	human=22+(age-2)*5
	print("对应人类年龄：",human)
# 推出提示
input('点击enter退出')
'''

# 1.3 数据类型
'''
a,b,c,d,=20,5.5,True,4+3J
print(type(a),type(b),type(c),type(d))
'''

# 1.4 各种计算符

'''
a=1+2	          		//正整数
b=5.5/2					//浮点运算
c=9%2					//余数
d=12*5					//乘数
e=91//3					//整除
f=3**3					//乘方数
g=12*2
print(a,b,c,d,e,f,g)
'''

# 1.5<type()>显示字符的类型
# 							//<r>在字符串前面加r字符串内/会失去作用直接显示
'''
s=r'yes.he doesn\'t'
print(s,type(s),len(s))
'''

# 1.6  <>字符串可以用+连接，也可用*重复
'''
print('str'+'in \\ ...g','my'*3)
'''

'''a,b=1,2
while b<101:
	a,b=a+b,b+1
	print(a)'''

# # 1.7   //[]内的数字用来显示第几位的字符，正数从0开始是第一个字符，
# # 										负数从-1开始是最后一个字符
# # 										<:>从第几个到第几个
'''
word='pythonowi09'
print(word[0],word[5],word[-1],word[-6],word[3:6],word[:],word[6:],word[-6:-3],word)'''

# 1.8
'''
a=['him',25,100,'her']
a=a+[4,3,2]
a[0]=9
a[1:3]=[8,'a',9]
b=['我们走啊']
print(a,b)
'''
# https://www.runoob.com/python3/python3-tutorial.html


# 1.9

'''
tup=(1,2,3,4,5,6,7)
print(tup[0],tup[1:5])
stu={'top',"jim",'mar','top','jac','ros'}
sra=set('alskdjfkaspdfoiwioeu')
srb=set('aslkjdfhwiueryiwueykjasdlkfj')
print(stu)
print(sra|srb)
'''

'''
tel={'as':1234,'we':123412,'kj':1212,'aa':29988}
dict(adf=11231,oi=123123,op=123)
print(tel)
print(tel['as'])
print(tel.keys())
'''

# 总结：
# 变量中·数字可直接被赋予变量；''中为字符串；[]中为列表；（）中为元组；{}中为集合，
# 可用{}或者set()来创建;字典有多种形式进行赋予，在{}中字符串加：，：左侧是字符串或者叫键，右侧是数字或者叫值；
# 其中列表，元组，集合，字典都有自己的函数可用，并且可用运算符进行增减组合。


'''
b=123
a=234
c=b+a
print(c)
if (a==100):
	print('adengyu100')
else:
	print('a1')
'''

'''
运算符						描述
**	    					幂，x的y次幕，指数 (最高优先级)
~ + -						按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % //					乘，除，求余数和取整除，运算符
+ -							加法减法，运算符
>> <<						右移，左移运算符
&							位 'AND'
^ |							两值结果对比，位运算符
<= < > >=					比较运算符
== !=						等于或不等于，等于运算符
= %= /= //= -= += *= **=	赋予某值，自身等于自身与赋予值的运算结果，赋值运算符
is   is not					xx是否和yy引用至同一对象，值相同但不一定是同一对象，身份运算符
in not in					xx是否在yy里面，成员运算符
not and or					非或与，逻辑运算符
'''
# 1.9 数据类型与转换
# Python数据类型转换
# 有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。
# 以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。
# 函数                          描述
# int(x [,base])              将x转换为一个整数
# float(x)                    将x转换到一个浮点数
# complex(real [,imag])       创建一个复数
# str(x)                      将对象 x 转换为字符串
# repr(x)                     将对象 x 转换为表达式字符串
# eval(str)                   用来计算在字符串中的有效Python表达式,并返回一个对象
# tuple(s)                    将序列 s 转换为一个元组
# list(s)                     将序列 s 转换为一个列表
# set(s)                      转换为可变集合
# dict(d)  					  创建字典。d 必须是一个 (key, value)元组序列。
# frozenset(s)                转换为不可变集合
# chr(x)                      将一个整数转换为一个字符
# ord(x)                      将一个字符转换为它的整数值
# hex(x)                      将一个整数转换为一个十六进制字符串
# oct(x)                      将一个整数转换为一个八进制字符串
# 不可转换的类型
# bool						只有两个值True（真）和False（假）
# type(x)					显示某个值的类型
# range(x,y,z) 				从x到y的数列，以z的步进排列。按顺序排列的数，或者以步进方式显示值
# bytes						不可更改的字节串

'''
a=[1,2,3,4]
b=a

print(b is a)
print(b==a)
b=a[:]  # b取a的值，但不等于a
print(a)
print(b)
print(b is a)
print(b==a)'''

'''
text =('我的世界我来掌控')
print(text)
text=('抬头看我却在你的世界中')
print(text)
import tkinter
import tkinter.messagebox #弹窗库
tkinter.messagebox.showinfo('此话没毛病','人生苦短，别想太多')
'''
# 2.0
# 运行的语句按缩进的位置来判断语句属于哪一层，用：表示接下来是满足条件的语句
# 2.0 l1
'''a=1
while a<7:
	if(a%2==0):
		print(a,'is 好')
	else:
		print(a,"is 不好")
	a+=1
'''

# 2.0 l2 当if的值不为0时运行条件，当为0时则跳过不运行
'''var1=100
if var1:
	print("2-if表达式条件为true")
	print(var1)

var2=0
if var2:
	print("2-if 表达式条件为true")
	print(var2)
print("good bye!")'''

# 2.0 l3 true为真，false为假

'''print(5==6)
x=5
y=6
print(x==y)'''

# 2.0 l4猜字游戏

'''
number=7
guess=-1
# 导入随机数模块random
import random
# 赋值number 最小是1，最大是99的随机数
number= random.randint(1,99)
print("数字猜谜游戏最小为1，最大为99")
while guess != number:
	guess=int(input("请输入你猜的数字："))

	if guess ==number:
		print("恭喜你猜对了！")
	elif guess < number:
		print("小了小了，往大了猜")
	elif guess > number:
		print("大了大了，往小了猜")
'''

# 2.1  循环格式“ while 判断条件： ”当结果等于条件的时候跳出循环

'''
n=100
a=0
b=1
while b<=n:
	a=a+b
	b+=1
	print("从1开始加到 %d等于%d"% (n,a))'''

# 2.2 循环判断语句 for xx in xx：语句的应用 循环打印字符串组
# 2.2 l1循环打印a的字符串内容
'''
a=["c","c++",'parl',"python"]
for x in a:
	print(x)
'''

# 2.2 l2 for和if的合用，break:跳出if的条件，else:跳出for的条件
'''
a = ["ham","spam","aggs","nuts"]
b = "nuts1"
print (a)
for food in a:
	if food == b:
		print ("找到到aggs后跳出!")
		break
	print("找到字符组 "+food)
else:
	print("我没有找到 "+b)
print("显示完毕，所有能显示的都在这里了！" +food)
'''

# 2.2 l3 range的应用，以步进的方式生成序列

'''
for i in range (9):
	print(i)
print("以步进方式显示0-9以内的数字")
print ("#"*30)


for i in range (10,13):
	print (i)
print ("以步进方式显示10-13以内的数字")
print ("#"*30)

for i in range(10,100,10):
	print (i)
print ("以步进的方式每隔10的增长显示10-100以内的数字")
'''

# range()和len（）组合来步进方式显示列表的值
'''
a=['good','bad','ab','little','爸爸','妈妈','悦悦']
for i in range (len(a)):
	print(i,a[i])
print ("显示列表a序列中的值")


b=list(range(5))
print(b)
print ("通过range直接建立数字形式的列表")
'''

# 2.2 l4 break和continue，else子句的应用；break跳出for和while的循环，如果跳出，else的语句将不执行。
# continue语句是跳过当前循环中的剩余语句，直接进入下一轮循环。else在for或while循环或条件变为假，
# 循环终止时被执行。但循环被break终止时不执行，break当循环到此处时直接终止继续循环。

'''
a =0
for n in range (2,1000):
	for x in range(2,n):
		if n % x == 0:
			print(n,'找到可被x值整除的最小合数结果',x,'*',n//x,'=',n)
			break
	else:
		a+=1
		print(n,'循环中没有找到x适合的结果，此数值',n,'为第',a,'个质数或叫素数')
'''
# 2.2 l5continue应用，跳过本循环并继续循环
'''
n=10
while n>0:
	n-=1
	if n ==5:
		continue
		print ('这一行被跳过了，但会继续接下来的循环，因为前面有continue',n)
	if n==2:
		break
		print('在这里直接跳出循环了，因为break')
	print(n)
print('循环结束')
'''

# 2.2 l5 pass的应用，让程序什么都不做，有些代码不完整，可以用pass来填坑，
# 		以后有可用的函数或数值时，把pass替换掉

'''
while True:
 	pass
'''
'''
for letter in 'python':
	if letter == 'h':
		pass
		print ('这里是pass块')
	print ('当前字母：',letter)
print ("运行完毕")
'''

'''
class MyEmptyClass:
	pass
'''

# 3.1 l1 迭代器与生成器 迭代器在类中需要 _iter_()与_next_()来实现。
# 用_iter_()返回一个迭代器对象，这个对象用_next_()来完成

'''
list = [1,2,3,4,5,6]
it = iter(list)     # 创建迭代器对象

print (next(it))

print (next(it))

print (next(it))

print (next(it))

print (next(it))

print (next(it))


# print (next(it))     #因为列表中只有6个字符串，第7个会没有可打印的东西
'''

# 3.1 l2 for语句中迭代器的应用 print中函数end=是连接符的应用，

'''
list = [1,2,3,4,5]
it = iter(list) #创建迭代器对象
for x in it:
	print (x,end="-") # end=""分隔符用空格
'''

# 3.1 l3 next函数的应用 注意语句区分大小写

'''
import sys

list = [1,2,3,4,5]
it = iter(list)
while True:
	try:
		print(next(it))
	except StopIteration:
		sys.exit()

'''

# 3.1 l4 __iter__()与__next__()。"下划线_是两个"可以把类作为迭代器使用,
# 	该案例可以把迭代器中生成的数值一直执行下去

'''
class MyNumbers:
	def __iter__(self):
		self.a = 1
		return self

	def __next__(self):
		x = self.a
		self.a += 1
		return x

myclass = MyNumbers()
myiter = iter(myclass)

a =0
while a<9 :
	print(next(myiter))
	a += 1
print ('从这里隔开')
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
'''

# 3.2 l5 在迭代器中设置到一定条件时StopIteration来结束迭代

'''
class MyNumbers:
	def __iter__ (self):
		self.a = 1
		return self

	def __next__ (self):
		if self.a <=20:
			x=self.a
			self.a += 1
			return x
		else:
			raise StopIteration

myclass =MyNumbers()
myiter = iter(myclass)

for x in myiter:
	print(x)'''

# 3.3 用import导入某模块，用yield生成一个迭代器，yield生成的迭代器在循环中每次读到时会读取上次的值。

'''
import sys   #导入sys模块

def fibonacci(n):  # 生成函数fibonacci
	a,b,counter=0,1,0
	while True: #循环成立
		if(counter>n):
			return
		yield a  # 生成器yield 生成一个迭代器函数a，并且再次循环到此处时，读取上次的值
		a,b=b,a+b
		counter+=1
f=fibonacci(20)  #当函数值n赋予20时

while True:
	try:
		print (next(f),end="-")
	except StopIteration:
		sys.exit()
'''

# 4.1 函数的应用 def接函数标识符和圆括号来生成函数，圆括号中逗号之间可以用于定义参数，引用函数时，
# 必须该参数赋值，不然会出错，用return接参数来结束函数，并返回运算的参数值。
'''
def max(a,b): #生成函数max 并有两个可赋值a和b
	if a>b:
		return a
	else:
		return b

a=6
b=5
print (max(a,b))
'''

# 4.2 函数多值应用返回多个值，键入多个值，就必须提前设置相应的变量，并且返回的值与设置的值数量对应。
'''
def max(a,b,c,d):   #可赋多个参数，返回时可不完全返回，但给参数赋值时必须全部赋值。不然会输出错误
	c=a*b
	a=a+4
	b=b+1
	d=a+b+c
	return a,b,c,d
a=1
b=2
c=3
d=8  # 函数中有几个参数就要有几个赋值的参数
print (max(a,b,c,d)) # 必须把参数全部打印完毕
'''

# 4.3 返回字符串和返回计算过的结果

'''
def area(width,height): #面积的计算函数
	width+=1   # 参数值+1
	height+=2  # 参数值+2
	return width*height # 将所赋值参数计算后再相乘的结果返回。

def print_welcome(name):
	print("Welcome",name) #直接打印这个参数

print_welcome("Runoob") #直接运行函数，函数中有打印函数，所以结果是直接打印所赋值
w=4
h=5
print("长(width)",w,"宽(height)",h,"面积（area）=",area(w,h))  #打印所赋值，和所生成的函数返回值
'''

# 4.4 函数中直接打印和返回参数的打印区别

'''
def printme(str):     					# 生成函数
	print(str)							# 没任何改动直接打印
	str=str+"---->"+"成功"  				# 函数增加个成功
	print(str)							# 打印参数
	return str*2+"|这是返回的信息"		# return返回附加值的参数

printme("第一次打印")
printme("再次打印")
print("#"*100)
print(printme("又打印一次"))
'''

# 4.5 传不可变对象，同函数，同内部id，数值变换id也变换

'''
def change(a):
	print(id(a))
	a=10
	print(id(a))
	a=11
	print(id(a))

a=1
print(id(a))
change(a)
'''

# 4.6 传可变对象，函数参数生成，函数内对赋值运算后，数值变更，以后在函数外，数值也是变更后的值
'''
def changeme( mylist ):
	"修改传入的列表"
	mylist.append([1,2,3,4])
	print("函数内取值：", mylist)

	return

# 调用changeme函数
mylist = [10,20,30]
changeme( mylist )
print("函数外取值：",mylist)
'''

# 4.7 必须参数，分为必须参数，关键参数，默认参数，不定长参数。

'''
def printme(str):
    "打印任何传入的字符串"
    print(str)
    return

# 输入参数时 str= 和“”直接输入时一样的结果
printme("we")  # 必须输入参数，如果不加参数会输出错误，
printme(str="we")
'''
# 4.8 默认参数 和参数顺序，

'''
def printinfo(name, age=20):
    print("名字：", name)
    print("年龄：", age)
    return


# 如果参数不止一个时，传入参数不用按顺序传入
printinfo(age=39, name="sdf")
print("#" * 80)
# 参数有默认值时，如果不给参数赋值，会使用默认参数
printinfo(name="永远")
'''

# 4.9 不定长参数，一个参数，能够处理比定义的参数多的赋值，这些参数叫不定长参数
# 一种为*号来定义元组，参数可以以元组的形势来赋值多个值。
'''
def printinfo(arg1, *vartuple):
    print("输出： ")
    print(arg1)
    print(vartuple)

# 如果元组的参数没有赋值，打印时为空
printinfo(10)
# 加了*的定义参数，会以元组（tuple）的方式保存参数，
printinfo(70, 60, 50, 30)
'''

# 4.10 如果传递元组，赋值可以为空，

'''
def printinfo(arg1, *vartuple):
    print("输出：")
    print(arg1)
    for a in vartuple:
        print(a)
    return


printinfo(10)
printinfo(90, 80, 70, 60, 50, 4, 3, 2)
'''

# 4.11 字典的导入,两个*号是参数定义为字典，**后面的参数为字典。格式为x=yy,zz=aa

'''
def printinfo(arg1, **vardict): # **后面为字典的定义
    print("输出：")
    print(arg1)
    print(vardict)
    return


printinfo(1, a=2, b=3, c=4) # 赋值时 字典要用=号来赋值。
'''

# 4.12 当*号单独出现时，*号后面的赋值，必须以关键字的形式出现

'''
def f(a, b, *, c):
    return a + b + c

f(1, 2, c=3)  # *好后面的参数必须使用关键字的方式赋值，x=yy

# f(1, 2, 3)  # 这样会错误
print(f(1, 2, c=3)) # 这样才对
'''

# 4.13 匿名函数，使用lambda来创建匿名函数
# 语法： lambda a,b:a+b
'''
def sum(a, b): return a + b  # 格式为sum=lambda a,b:a+b 保存后会自动变成def形式

print("相加后值为：", sum(10, 20)) # 直接调用函数sum

f = 90
d = 12
print("相加后值为：", sum(f, d)) #函数的另一种赋值方法
'''

# 4.14 return 的应用 如函数内有计算，和return的返回值可分别计算和现实

'''
def sum(a, b):
    t = a + b
    print("函数内计算：", t)
    return t + 1


i = sum(80, 88)
print("函数外显示：", i)  # 运行时会打印两次，一次是函数内的打印，一次是，本次打印
'''

# 4.15 强制位置参数，下例中ab必须指定位置，cd可以是位置型参数，也可以是关键字形参，ef必须为关键字型参数。
'''
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)

f(11, 23, c=13, d=43, e=13, f=44) # 首先*好后面的必须用关键字，*好前面如果使用关键字，必须从后往前使用，
# 									不能跳着使用
# f(2, b=123, 12, 4, e=23, f=4) # b=123会导致c和d都使用关键字来赋值，不能直接赋值，会出错
'''

# 5.0 数据结构 列表

# list.append(x)	把一个元素添加到列表的结尾，相当于 a[len(a):] = [x]。
# list.extend(L)	通过添加指定列表的所有元素来扩充列表，相当于 a[len(a):] = L。
# list.insert(i, x)	在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引，a.insert(len(a), x)
# 					相当于 a.append(x) 。
# list.remove(x)	删除列表中值为 x 的第一个元素。如果没有就会返回一个错误。
# list.pop([i])		从列表的指定位置移除元素，并将其返回。如果没有指定索引，a.pop()返回最后一个元素。元素随即
# 					从列表中被移除。（方法中 i 两边的方括号表示这个参数是可选的，而不是要求你输入一对方括号，
# list.clear()		移除列表中的所有项，等于del a[:]。
# list.index(x)		返回列表中第一个值为 x 的元素的索引。如果没有元素就会返回一个错误。
# list.count(x)		返回 x 在列表中出现的次数。
# list.sort()		对列表中的元素进行排序。
# list.reverse()	反转排列列表中的元素。
# list.copy()		返回列表的浅复制，等于a[:]。
'''
a = [66.55, 333, 333, 1, 123.5, 2]
print(a.count(333), a.count(1), a.count(3))  # count返回值在列表里出现的次数

print("*" * 80)
a.insert(2, 345)  # 在指定位置插入数据，0为第一个位置，a.insert(len(a),x)等同于a.append(x)为最后面添加数据
a.append(999)
print(a)

print("*" * 80)
print(a.index(333))  # 返回第一个值为x的元素，如果没有会返回错误
# print(a.index(789)) #错误，因为值里没有789这个数据
print("*" * 80)
a.remove(333)  # 删除列表值中为x的第一个元素，如果没有，会返回错误
print(a)

print("*" * 80)
a.sort()  # 对列表中的数据进行正排序。 a.reverse()对列表进行倒排序。
print(a)

print("*" * 80)
a.reverse() # 队列表中数据按目前顺序反转，
print(a)

print("*" * 80)
a.clear() # 清空列表的数据。
print(a)
'''

# 5.1 列表的堆栈使用方式方法，append()来增加到堆栈的最末端，用pop()把最后一个堆栈取出并释放。

'''
s = [3, 4, 5]
s.append(6)  # 在列表的最后添加6
s.append(7)  # 在列表的最后添加7
print(s)

print(s.pop())  # 删除并返回最后一个数据
print(s)
print(s.pop())
print(s.pop())
print(s)
s.reverse()
print(s)
s.reverse()
print(s)
'''

# 5.2 将列表当作列队使用，collections建立容器，并导入deque模块来操作
'''
from collections import deque # 设置容器，并以列表形式
queue = deque(["eric", "john", "小华", "水韧"])
queue.append("jierui") # 在结尾添加
queue.append("yueyue")
print(queue.popleft()) # 把前面的数据取出并从列表移除
print(queue.popleft()) # 把前面的数据取出并从列表移除
print(queue)
'''

# 5.3 列表推导式
'''
vec = [2, 4, 6, 8, 0, 1, 123, -2]
print([3 * x for x in vec])
print([[x, x**2] for x in vec])
'''
# 5.4 用strip去除列表开头和结尾的”默认“空格或者其它字符
'''
freshfruit = [' banana ', '    loganberry9', '  a  iyayaya ']
print(freshfruit)
print([weapon.strip("9") for weapon in freshfruit]) # 去除字符9
print([weapon.strip() for weapon in freshfruit]) # 去除空格
'''

# 5.5 用if 做过滤语句，过滤掉符合或者不符合条件的数据
''''
vec = [1, 2, 4, 6, 7, 82]
print([3 * x for x in vec if x > 3 and x < 8])
print([3 * x for x in vec if x < 3])
'''

# 5.6 双列表循环计算技巧，列表中数值分别计算，或者 对应列计算
'''
vec1 = [2, 4, 6]
vec2 = [4, 5, -9]
print([x * y for x in vec1 for y in vec2])
print([x + y for x in vec1 for y in vec2])
print([vec1[i] * vec2[i] for i in range(len(vec1))]) # 以步进的方式取值并计算
'''

# 5.7 列表的生成，由其他函数生成的固定列表
'''
print([str(round(355 / 113, i))
       for i in range(1, 20)])  # str 将目标转换成可读的形式，range步进方式显示位数。
'''
# 5.8 嵌套列表解析，矩阵列表转换
'''
matrix = [
    [1, 2, 3, 4, 5],
    [6, 7, 8, 9, 10],
    [11, 12, 13, 14, 15], [16, 17, 18, 19, 20],
]
# 方法1
print(matrix)
print([[row[i] for row in matrix] for i in range(5)])  # 将横向列表转换成竖向列表

print("分隔符" * 18)
# 方法2
transposed = []
for i in range(5):
    transposed.append([row[i] for row in matrix])

print(transposed)

print("分隔符" * 18)
# 方法3
for i in range(5):
    transposed_row = []
    for row in matrix:
        transposed_row.append(row[i])
    transposed.append(transposed_row)

print(transposed)
'''
# 5.9 del语句的应用
'''
a = [-1, 1, 55, 77, 77, 345.3]

del a[0]  # 删除第一个数据
print(a)
del a[2:4]  # 删除第3到第4个数据，但不包括：4的数据
print(a)
del a[:]  # 删除全部数据
print(a)
'''

# 5.10 元组和序列的组合应用
'''
t = 12345, 54321, '你好' # 元组建立时可以没有括号
print(t[0]) # 元组在输出时是有括号的，可以正常的操作值，
print(t)
u = t, (1, 2, 3, 4, 5) #如果元组是更大表格的一部分，就必须有括号
print(u)
'''
# 5.11 l1 集合的操作 删除与检测数据是否存在
'''
basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(basket)  # 无论输入时如何，在输出时集合中不会出现重复数据
print('orange' in basket)  # 检测数据是否存在输出真“True”或假"False"
print('crabgrass' in basket)
'''
# 5.11 l2 用set生成的集合，和操作方法
'''
a = set('adsfasdfasdfadsfa')
b = set('afqwerqwerqwer')
print(a) # a中的唯一字符
print(a - b) # 在a中但不在b中的字符
print(a | b) # a和b中所有的字符
print(a & b) # a和b都存在的字符
print(a ^ b) # a和b中不重复的字符
'''
'''
a = {x for x in 'asdfwqerasdf' if x not in "asf"} # 如果x在集合中，条件是x不是asf
print(a) 
'''

# 5.12 字典的操作
'''
tel = {'永': 45446, '悦悦': 312, '水韧': 45446}  # 建立字典tel，整数数据部分不能以0开头
tel['参数'] = 915  # 增加字典数据
print(tel)  # 显示字典内容
print(tel['永'])  # 显示字典内“永”的key
del tel['永']  	# 删除键“永”
print(tel)
tel['冷血人'] = 2345  # 增加新字典数据
print(tel)
print(list(tel.keys()))  # 以列表方式显示所有键
print(sorted((tel.keys())))  # 按顺序排列键
print('冷血人' in tel)  # 查看某数据是否在字典中，返回为真True或假False
print('lll' in tel)

print(dict([('sa', 99), ('we', 88), ('la', 77)])) # 用dict直接建立字典
print({x: x**2 for x in (2, 3, 4, 5, 6, 8)})  # 用公式建立数字做键值的字典
print(dict(asd=23, wee=89, qw=34)) # 如果键全是字符串的情况下，简单的建立字典
'''
# 5.13 字典的遍历操作技巧
'''
knights = {'yueyue': 312, 'shuiren': 'yong', 'yongzhen': 'lan'}
for t, v in knights.items():  # 将字典中键与key分开显示
    print('账号：', t, '密码：', v)
    print('第二种方式：{0},key是{1}'.format(t, v)) # format的应用

for i, v in enumerate(['t', 'tac', 'toe']):  # enumerate将列表或元组或字符串组合成序列逐条显示
    print(i, v)

questions = ['name', 'quest', 'favorite', 'yong']
answers = ['lanlan', 'teh', 'blue', "yoiu"]
for q, a, s in zip(questions, answers, knights):  # zip组合打包成元组列表显示
    print('你的名字是{0}? it is {1}.还有{2}'.format(q, a, s))
    # {0}代表format(x,y,z)中的x，{2}代表z，

for f in sorted(set(questions)):  # 使用sorted来返回一个已排序“set”的序列，不修改值
    print(f)
'''
# 6.0 模块引用，提前做好的，包含所定义的函数和变量的文件，后缀是py，为了可以被别的程序所引用，
# 方便使用该模块的函数和变量等功能，用户可以自己做模块，系统本身也带一些标准库。
'''
import sys  # 使用import来引用sys.py模块
print('命令行参数如下：')
for i in sys.argv:  #列出sys.argv的参数
    print(i) 

print('\n\nPython 路径为：\n', sys.path, '\n') # 使用sys.path命令来列出python所需模块的路径列表。\n是换行符
'''
# 6.1 import语句,一个模块在使用时，只会被导入一次，不管执行多少次import，都不会重复导入同一个模块，
# 模块可以放到编译文件同一文件夹下，也可以放在python的模块目录下，可以用sys.path输出一个列表
'''
# 先建立文件support.py内容为
# def print_func(par):
#	print("Hello:",par)
#	return

import support # 导入刚才建好的模块
support.print_func("renoob") # 使用模块内的函数
'''
# 6.2斐波那契数列模块应用，一个模块中可以建立多个函数，使用"模块名.函数"的形式来使用

# 先建立模块fibo.py
# def fib(n):
# 	a,b=0,1
# 	while b<n:
# 		print(b,end=' ')
# 		a,b=b,a+b
# 	print()

# def fib2(n):
# 	result=[]
# 	a,b=0,1
# 	while b<n:
# 		result.append(b)
# 		a,b=b,a+b
# 	return result
'''
import fibo
print(fibo.fib(1000))  		# 使用fibo中第一个fib函数
print(fibo.fib2(100))		# 使用fibo中第二个fib函数
print(fibo.__name__)		# 查看模块的名字

fib = fibo.fib  # 如果经常使用一个模块的函数，可以赋予一个本地名称fib
print(fib(500))
'''
# 6.3 from ...import*语句,把一个模块的所有函数都导入到当前空间进行使用
'''
from fibo import fib, fib2  # 使用from...import导入固定函数
print(fib(200)) 			# 导入后可直接使用模块中函数
print(fib2(800))

from fibo import *  		# 使用*号导入fibo中所有的函数
print(fib(500))
print(fib2(8999))
'''

# 6.4__name__属性
'''
if __name__ == '__main__':		# "__name__"名字的值等于“__main__”时代表模块名来判断是否以模块来运行
    print("程序自身运行")			# 直接运行程序会显示此行
else:
    print("正在以模块形式运行") 		# 当其他程序导入这个模块时会显示此行
'''
# 6.5 dir()函数，得到一个模块中定义的属性列表
'''
import fibo
import sys
print(dir(fibo)) 		# 显示fibo中所有可用的属性列表
print('分隔符' * 10)
print(dir(sys))			# 显示sys中所有可用属性的列表
print('分隔符' * 10)
a = [1, 2, 3, 4, 5]
fib = fibo.fib
print(dir())			# 显示当前所用模块的列表
print('分隔符' * 10)
a = 5
print(dir())
print('分隔符' * 10)
del a 					# 删除a变量
print(dir())
'''

# 6.6标准模块 标准模块就是python本身带的一些模块库，这些模块可以被直接引入程序中。
# 不同的系统会匹配不同的模块，但有些模块是针对某系统的，比如winreg只有win系统下有
# sys是一个特殊模块，他内置在解析其中，变量sys.ps1和sys.ps2定义了主提示符和副提示符
'''
import sys
sys.ps1
sys.ps2
sys.ps1 = 'c=>'
'''
# 包 一种管理模块的形式，可以理解为一个文件夹下的模块组，可以预防导入模块时出现相同名称的模块
# 导入形式为 “包.模块名”或者“包.包.模块名”来解决不同包中同名模块的情况
# 目录中包含一个__init__.py的文件才叫包，__init__.py可以为空文件
'''
import sound.effects.echo 
sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)
# 或者使用 
from sound.effects import echofilter 
echofilter(imput,output,delay=0.7,atten=4)
'''

# 7.0输入输出，输出格式美化
# str（）将输出转换成字符串，函数返回一个用户易读的表达形式
# repr（）将输出转换成字符串，产生一个解析器易读的表达式
'''
s = 'hello,大家'
print(s)
print(str(s))		# 输出无双引号
print(repr(s))		# 带双引号，方便其他函数直接使用或导入
print(str(1 / 7))	# 将数值，转换成字符串输出
x = 10 * 3.25
y = 200 * 200
s = 'x的值为：' + str(x) + ',y的值为：' + repr(y) + '......'
# 使用转换函数和不适用转换函数的区别输出时有空格
print(s)
print('x的值为：',x, ',y的值为：' ,y,'......')

hello = 'hello,baobao\n' 	# 直接输出，\n 为换行符
hellos = repr(hello)		# 转换成字符串输出，\n 以字符串形式直接输出
print(hello)
print(hellos)
print(repr((x, y, ('google', 'haha'))))		# 除，号以外全部以字符串形式输出
'''
# 7.0 l2 rjust(x) 字符串向右靠x个位置，ljust（x）字符串像左靠x个位置
'''
for x in range(1, 33):
    print(repr(x).ljust(1), repr(x * x).rjust(3),
          repr(x * x * x).rjust(4), end=' ') 	# end有链接下一行的作用，如果结尾没有end，下行x**4会单独显示
    print(repr(x * x * x * x).rjust(8))
'''
# 7.0 l3 遍历中format的应用，end 可使用与本行公式内，并可连接下行字符串函数
'''
for x in range(1, 11):
    print('{0:2d}{1:4d}{2:4d}'.format(x, x * x, x**3),end=' ') # end只连接函数前后
    print('lanlan')
    print('daqin')
'''

# 7.0 l4 zfill() 从左边以0填充
'''
print('12'.zfill(5), end='  ')  # zfill从左到右填充0，end来连接下一行
print('12'.rjust(5))			# 填充空格
print('-123'.zfill(8))			# 负号在0的前面，字符串与zfill函数之间用点来连接
'''

# 7.0 l5 str.format()基本使用 {}大括号成为格式化字段，格式化字段的参数可以被format（）的参数替代
# 替代时可以使用序号来指定位置，也可不使用序号，默认为0-1-2~~~~，还可以使用关键字来定义
'''
print('{}网址："{}!"'.format('教程', "www.baidu.com"))  # 默认状态
print('{0}和{2}还有{2}'.format('兰兰', '花花', '天天'))  # 使用序号状态
print('{name}来啊：{star}？'.format(name='你过', star='你能拿我怎样'))  # 使用关键字定义
print('我的{0}是{1}的{c}。'.format('悦悦', '爸爸', c='最爱')) # 序号和关键字可以同时使用
'''
# 7.0 l6 直接使用函数或模块的值，使用！a“ascii格式”、！s“使用str格式”、！r使用repr格式“可直接格式化引用的值
# 格式化参数 !a、!s、!r等
'''
import math		# 引用运算模块，
print('常量PI的值近似为：{}。'.format(math.pi))  # 直接取派的值
print('常量PI的值近似为：{!r}。'.format(math.pi))  # 以str格式取派的值
# 可选项：和格式标识符可以跟着字段名，对值分段格式化。f为浮点数
print('常量PI的值近似为：{0:.5f}.'.format(math.pi))  # f小数后面x位，没f是全部x位
print('常量pi的近似值为：{!s}'.format(math.pi))
print('常量PI的值近似为：{0:.125f}.'.format(math.pi)) 
'''
# 7.0 l7 冒号：后面传入一个整数可以保证该区域至少有x的宽度，可用于美化表格
'''
table = {'东龙': 234, '水韧': 2, '悦悦': 3}  # 建立字典
for name, number in table.items():			# 以字典的键和值循环打印
    print('{0:8}==>{1:10d}'.format(name, number))  # d代表什么？冒号后面表示占几个位置
# 使用[]括号来访问键值
print('东龙:{0[东龙]:d};水韧:{0[水韧]:d};悦悦:{0[悦悦]:d}'.format(table))	# 字典的键值，在一行内显示
# 使用**来实现以上功能
print('东龙:{东龙:d};水韧:{水韧:d};悦悦:{悦悦:d}'.format(**table))
'''
# 7.1 旧式字符串格式化,%的功能是旧版本的格式化方法，以后会从版本中剔除等同于str.format()
'''
import math
print('常量pi的值近似为：%5.3f。' % math.pi)
'''
# 7.2 读取键盘输入 input()
'''
str = input("请输入：")
print("刚输入的是：", str)
'''
# 7.3 读写文件，open() 将会返回一个 file 对象，基本语法格式如下:
# open(filename, mode)
# filename：包含了你要访问的文件名称的字符串值。
# mode：决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。
# 这个参数是非强制的，默认文件访问模式为只读(r)。
# 模式	描述
# r		以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
# rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。
# r+	打开一个文件用于读写。文件指针将会放在文件的开头。
# rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
# w		打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，
# 		即原有内容会被删除。如果该文件不存在，创建新文件。
# wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，
# 		并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
# w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，
# 		即原有内容会被删除。如果该文件不存在，创建新文件。
# wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，
# 		即原有内容会被删除。如果该文件不存在，创建新文件。
# a		打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，
# 		新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
# ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。
# 		也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
# a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。
# 		文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
# ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。
# 		如果该文件不存在，创建新文件用于读写。

# 模式			r	r+	w	w+	a	a+
# 读				+	+		+		+
# 写					+	+	+	+	+
# 创建					+	+	+	+
# 覆盖					+	+
# 指针在开始		+	+	+	+
# 指针在结尾						+	+
# 7.3 l1 生成一个文件并写入数据，然后关闭
'''
f = open("foo.txt", "w") 	# 打开一个文件，“w”写入数据
f.write("水韧是一个很好的人。\n是的，非常的好！！\n")	# .write写入数据
f.close()		# 关闭文件
'''
# 7.3 l2 .read 读取文件内容，并打印
'''
f = open("foo.txt", "r")  # 以只读方式打开文件
str = f.read(13) 	# 读取文件的13个子
print(str)
f.close()
'''
# 7.3 l3 f.readline() 每次读取一行，截至换行符\n。如果读取到的为空字符，这表示已读取到最后一行
'''
f = open("foo.txt", "r")
str = f.readline() 			# 设函数为文件的第一行
print(str)
print(f.readline())			# 继续打印文件的下一行
print(f.readline())			# 继续打印下一行
print(str)					# 打印函数，因函数的赋值为文件的第一行，所以打印的还是第一行
f.close()
'''

# 7.3 l4 f.readlines() 返回该文件中包含的所有行，包括分隔符
'''
f = open("foo.txt", "r")
str = f.readlines()			# 将变量一次性赋值文件内所有内容，包括分隔符。
print(str)
f.close()
'''
# 7.3 l5 使用迭代器输出文件
'''
f = open("foo.txt", "r")
for a in f:
    print(a, end="-")
f.close()
'''
# 7.3 l1 f.write() 将文本写入文件，并返回写入的字符数
'''
f = open("foo.py", "w")				# 可生成任意文件但输入必须是字符串
num = f.write("我自己。\n还能有谁?\n  还能干什么。")
print(num)
f.close()
# 打开文件看一下内容
f = open('foo.py', 'r')
print(f.readlines())
f.close()
'''

# 7.3 l2 f.write(“x”) 将x写入文件，并返回写入的字符数
'''
f = open('foo.txt', 'w+')		# w+写入并可读取
value = ('www.baidu.com', 14)
s = str(value)					# 转换函数为字符串
f.write(s)						# 将转换的字符串写入到文件中
print(f.readline())				# 写入的字符串打印出
f.close()

f = open('foo.txt', 'rb')		# 以b模式读取文件
print(f.readlines())
# f.seek(x,y) y可以为0，1，2 。默认为0从起始位开始移动x个字符，1为从当前位置往后移动x个位置
# 2从结尾往前移动x个字符，用-x。
f.seek(6)						# 从文件首位往后移动6个字符
print(f.read(1))				# 打印当前位置的字符
f.seek(-3, 2)					# 从文件结尾往前移动3个字符
print(f.read(1))
print(f.tell())					# 返回当前所在位置
f.close()						# 关闭文件，并释放内存资源
'''
# 7.3 l3 使用with关键字在结束后会更好的正确关闭文件，语句简短
'''
with open('foo.txt', 'r') as f:
    read_data = f.read()
    print(read_data)

print(f.closed)					# 返回结果为true真
'''
# 7.4 pickle模块 数据序列化和反序列化保存，使用方法：prckle.dump(当时数据,文件名【,1or2】)
'''
import pickle # 引用模块

data1 = {'a': [1, 2.0, 3, 4 + 6j],
         'b': ('开始', u'kaishi'),
         'c': None}

selfref_list = [1, 2, 3]

selfref_list.append(selfref_list)		
print(selfref_list)
print(data1)
output = open('data.pkl', 'wb')			# 建立文件data.pkl，可读写

pickle.dump(data1, output)				# 将数据data1反序列化存储到文件中

pickle.dump(selfref_list, output, -1) 	# 在光标的当前位置存储selfref_list到文件中

output.close()
output = open('data.pkl', 'rb')
print(output.readlines())
output.close()
'''

'''
import pprint							# 引用模块打印用
import pickle 							# 引用反序列模块
pkl_file = open('data.pkl', 'rb')		# 以b形式读取文件

data1 = pickle.load(pkl_file)			# 读取文件内容
pprint.pprint(data1)					# 以正序打印读取的数据
data2 = pickle.load(pkl_file)			# 读取下个数据内容
pprint.pprint(data2)					# 打印数据
pkl_file.close()
'''
##############################################################################
# 8.0 文件的操作
# 完整格式：
# open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None,
# closefd=True, opener=None)
##########################################################################
# file: 必需，打开文件的路径（相对或者绝对路径）。
# mode: 可选，文件打开模式
# buffering: 设置缓冲
# encoding: 一般使用utf8
# errors: 报错级别
# newline: 区分换行符
# closefd: 传入的file参数类型
# opener: 设置自定义开启器，开启器的返回值必须是一个打开的文件描述符。
#####################################################################
# mode模式		描述
# t			文本模式 (默认)。
# x			写模式，新建一个文件，如果该文件已存在则会报错。
# b			二进制模式。
# +			打开一个文件进行更新(可读可写)。
# U			通用换行模式（Python 3 不支持）。
# r			以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
# rb		以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
# 			一般用于非文本文件如图片等。
# r+		打开一个文件用于读写。文件指针将会放在文件的开头。
# rb+		以二进制格式打开一个文件用于读写。指针在文件的开头。一般用于非文本文件如图片等。
# w			打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，
# 			即原有内容会被删除。如果该文件不存在，创建新文件。
# wb		以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，
# 			即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
# w+		打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，
# 			即原有内容会被删除。如果该文件不存在，创建新文件。
# wb+		以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，
# 			即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
# a			打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，
# 			新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
# ab		以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。
# 			也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
# a+		打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会
# 			是追加模式。如果该文件不存在，创建新文件用于读写。
# ab+		以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。
# 			如果该文件不存在，创建新文件用于读写。
##################################################################
# 方法 							及描述
# file.close() 				关闭文件。关闭后文件不能再进行读写操作。
# file.flush() 				刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件,
# 							而不是被动地等待输出缓冲区写入。
# file.fileno() 			返回一个整型的文件描述符(file descriptor FD 整型),
# 							可以用在如os模块的read方法等一些底层操作上。
# file.isatty()				如果文件连接到一个终端设备返回 True，否则返回 False。
# file.next()				返回文件下一行。（Python 3 中的 File 对象不支持 next() 方法。）
# file.read([size])			从文件读取指定的字节数，如果未给定或为负则读取所有。
# file.readline([size])		读取整行，包括 "\n" 字符。
# file.readlines([sizeint])	读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节
# 							的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区。
# file.seek(offset[, whence])	移动文件读取指针到指定位置
# file.tell()					返回文件当前位置。
# file.truncate([size])		从文件的首行首字符开始截断，截断文件为 size 个字符，无 size 表示
# 							从当前位置截断；截断之后后面的所有字符被删除，其中 windows 系统
# 							下的换行代表2个字符大小。
# file.write(str)				将字符串写入文件，返回的是写入的字符长度。
# file.writelines(sequence)	向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。
########################################################################
# 9.0 os模块 文件和目录的操作方法

# 方法 		 					描述

# os.access(path, mode)			检验权限模式
# os.chdir(path)					改变当前工作目录
# os.chflags(path, flags)			设置路径的标记为数字标记。
# os.chmod(path, mode)			更改权限
# os.chown(path, uid, gid)		更改文件所有者
# os.chroot(path)					改变当前进程的根目录
# os.close(fd) 					闭文件描述符 fd
# os.closerange(fd_low, fd_high) 	关闭所有文件描述符，从 fd_low (包含) 到 fd_high (不包含),
# 								错误会忽略
# os.dup(fd) 						复制文件描述符 fd
# os.dup2(fd, fd2) 				将一个文件描述符 fd 复制到另一个 fd2
# os.fchdir(fd) 					通过文件描述符改变当前工作目录
# os.fchmod(fd, mode) 			改变一个文件的访问权限，该文件由参数fd指定，参数mode是Unix下
# 								的文件访问权限。
# os.fchown(fd, uid, gid) 		修改一个文件的所有权，这个函数修改一个文件的用户ID和用户组ID，
# 								该文件由文件描述符fd指定。
# os.fdatasync(fd) 				强制将文件写入磁盘，该文件由文件描述符fd指定，但是不强制更新
# 								文件的状态信息。
# os.fdopen(fd[, mode[, bufsize]]) 	通过文件描述符 fd 创建一个文件对象，并返回这个文件对象
# os.fpathconf(fd, name) 			返回一个打开的文件的系统配置信息。name为检索的系统配置的值，
# 								它也许是一个定义系统值的字符串，这些名字在很多标准中
# 								指定（POSIX.1, Unix 95, Unix 98, 和其它）。
# os.fstat(fd) 					返回文件描述符fd的状态，像stat()。
# os.fstatvfs(fd) 				返回包含文件描述符fd的文件的文件系统的信息，Python 3.3 相
# 								等于 statvfs()。
# os.fsync(fd) 					强制将文件描述符为fd的文件写入硬盘。
# os.ftruncate(fd, length) 		裁剪文件描述符fd对应的文件, 所以它最大不能超过文件大小。
# os.getcwd() 					返回当前工作目录
# os.getcwdu() 					返回一个当前工作目录的Unicode对象
# os.isatty(fd) 					如果文件描述符fd是打开的，同时与tty(-like)设备相连，则
# 								返回true, 否则False。
# os.lchflags(path, flags) 		设置路径的标记为数字标记，类似 chflags()，但是没有软链接
# os.lchmod(path, mode) 			修改连接文件权限
# os.lchown(path, uid, gid) 		更改文件所有者，类似 chown，但是不追踪链接。
# os.link(src, dst) 				创建硬链接，名为参数 dst，指向参数 src
# os.listdir(path) 				返回path指定的文件夹包含的文件或文件夹的名字的列表。
# os.lseek(fd, pos, how) 			设置文件描述符 fd当前位置为pos, how方式修改: SEEK_SET
# 								或者 0 设置从文件开始的计算的pos; SEEK_CUR或者 1 则从当前
# 								位置计算; os.SEEK_END或者2则从文件尾部开始. 在unix，Win中有效
# os.lstat(path) 					像stat(),但是没有软链接
# os.major(device) 				从原始的设备号中提取设备major号码 (使用stat中的st_dev或
# 								者st_rdev field)。
# os.makedev(major, minor) 		以major和minor设备号组成一个原始设备号
# os.makedirs(path[, mode]) 		递归文件夹创建函数。像mkdir(), 但创建的所有intermediate-level
# 								文件夹需要包含子文件夹。
# os.minor(device) 				从原始的设备号中提取设备minor号码 (使用stat中的st_dev或
# 								者st_rdev field )。
# os.mkdir(path[, mode]) 			以数字mode的mode创建一个名为path的文件夹.默认的mode是0777八进制。
# os.mkfifo(path[, mode]) 		创建命名管道，mode 为数字，默认为 0666 (八进制)
# os.mknod(filename[, mode=0600, device]) 	创建一个名为filename文件系统节点（文件，
# 								设备特别文件或者命名pipe）。
# os.open(file, flags[, mode]) 	打开一个文件，并且设置需要的打开选项，mode参数是可选的
# os.openpty() 					打开一个新的伪终端对。返回 pty 和 tty的文件描述符。
# os.pathconf(path, name) 		返回相关文件的系统配置信息。
# os.pipe() 						创建一个管道. 返回一对文件描述符(r, w) 分别为读和写
# os.popen(command[, mode[, bufsize]]) 	从一个 command 打开一个管道
# os.read(fd, n) 					从文件描述符 fd 中读取最多 n 个字节，返回包含读取字节的字符串，
# 								文件描述符 fd对应文件已达到结尾, 返回一个空字符串。
# os.readlink(path) 				返回软链接所指向的文件
# os.remove(path) 				删除路径为path的文件。如果path 是一个文件夹，将抛出OSError;
# 								查看下面的rmdir()删除一个 directory。
# os.removedirs(path) 			递归删除目录。
# os.rename(src, dst) 			重命名文件或目录，从 src 到 dst
# os.renames(old, new) 			递归地对目录进行更名，也可以对文件进行更名。
# os.rmdir(path) 					删除path指定的空目录，如果目录非空，则抛出一个OSError异常。
# os.stat(path) 					获取path指定的路径的信息，功能等同于C API中的stat()系统调用。
# os.stat_float_times([newvalue]) 	决定stat_result是否以float对象显示时间戳
# os.statvfs(path) 				获取指定路径的文件系统统计信息
# os.symlink(src, dst) 			创建一个软链接
# os.tcgetpgrp(fd) 				返回与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组
# os.tcsetpgrp(fd, pg) 			设置与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组为pg。
# os.tempnam([dir[, prefix]]) 	返回唯一的路径名用于创建临时文件。Python3 中已删除。
# os.tmpfile() 					返回一个打开的模式为(w+b)的文件对象 .这文件对象没有文件夹入口，
# 								没有文件描述符，将会自动删除。Python3 中已删除。
# os.tmpnam() 					Python3 中已删除。为创建一个临时文件返回一个唯一的路径
# os.ttyname(fd) 					返回一个字符串，它表示与文件描述符fd 关联的终端设备。如果fd 没有与
# 								终端设备关联，则引发一个异常。
# os.unlink(path) 				删除文件路径
# os.utime(path, times) 			返回指定的path文件的访问和修改的时间。
# os.walk(top[, topdown=True[, onerror=None[, followlinks=False]]]) 	输出在文件夹中的文件名通过
# 								在树中游走，向上或者向下。
# os.write(fd, str) 				写入字符串到文件描述符 fd中. 返回实际写入的字符串长度
# os.path  						模块获取文件的属性信息。
# os.pardir() 					获取当前目录的父目录，以字符串形式显示目录名。
#####################################################################
# 10.0错误
'''
while True print('hello,shuiren') 	# invalid语法错误，应该在print前面加：，错误的位置会出现箭头
'''
# 10.1 异常的处理 try需要执行的代码，如果执行的代码没有错误就一直执行，如果出现错误，就跳到except
# 一个try可以包含多个except，except错误和except匹配，成功时执行的代码 ，不匹配转到下个except，
# 如果没有except就转回try语句
'''
while True: 			#为真时循环
    try: 									# 如果没有错误，就继续执行以下代码，如果出现错误转到except
        x = int(input("请输入数字：")) 			# int整数，如果输入的不是数字，会发生错误
        break
    except ValueError:						# 当发生错误时运行以下代码
        print("输入的不是数字，请再次输入！")
'''
# 10.2 一个except可以包含匹配多个错误
'''
except(RuntimeError, TypeError, NameError): 	# 以元组的方式直接匹配多个错误
    pass
'''
# 10.3 多个错误的处理，并打印错误信息
'''
import sys

try: 								# 正常执行的代码
    f = open('foo.txt')
    s = f.readline()
    i = int(s.strip())
except OSError as err:
    print("OS error:{0}".format(err))
except ValueError:
    print("Conld not convert data to an integer.")
except:
    print("Uvexpected error:", sys.exc_info()[0])
    raise
'''
# 10.4 try/except与else的应用
# 例子：
# try:
# 	执行的代码
# except:
# 	发生异常时执行的代码
# else:
# 	没发生任何异常时执行的代码
'''
import sys

for arg in sys.argv[1:]:
    try:
        f = open(foo.txt, 'r')  			# 读取文件foo.txt
    except IOError:								# 如果出现io错误就只行以下代码
        print('cannot open', arg)
    else:														# 如果没有错误就显示以下代码
        print(arg, 'has', len(f.readlines()), 'lines')
        f.close()
'''
# 10.5 调用的函数出现错误时一样可以用try来处理
'''
def this_fails():
	x=1/0
try:
	this_fails()
except ZeroDivisionError as err:
	print('Handling run-time error:',err)
'''
# 10.6 try-finally语句的应用无论是否出现错误都执行以下代码
'''
try :
	runoob()
except NameError as error:
	print(error)
else:
	try:
		with open('file.log') as file:
			read_data =file.read()
	except FileNotFoundError as fnf_error:  	# 如果出现file错误就只行以下代码
		print(fnf_error) 			# 打印函数fnf_error，函数内容是file的错误
finally:					# 以下代码无论是否出现错误都会执行
	print('这句话无论是否异常都会打印。')
'''
# 10.7 抛出异常，raise 某异常（'异常解释'）把不符合要求的结果当成异常
# 10.7 l1
'''
x=10
if x>5:
	raise Exception('x不能大于5.x的值为：{}'.format(x))
'''
# 10.7 l2 抛出一个异常但是不去处理
'''
try:
	raise NameError('HiThere')
except NameError:
	print('An exception flew by!')
	raise
'''
# 10.8 l1用户自定义异常
'''
class MyError(Exception):  			# 用MyError来替换Exception错误
	def __init__(self,value):
		self.value=value
	def __str__(self):
		return repr(self.value)
try:
	raise MyError(2*2)							# 抛出错误MyError
except MyError as e:
	print('My exception occurred,value:',e.value)
'''
# 10.8 l2 根据不同情况定义不同的异常子类
'''
class Error(Exception):
	"""base class for exceptions in this module."""
	pass

class InputError(Error):
	"""Exception raised for errors in the input.

	Attributes:
	expression -- input expression in which the error occurred
	message -- explanation of the error
	"""

def __init__(self,expression,message):
	self.expression=expression
	self.message=message

class TransitionError(Error):
	"""Raised when an operation attempts a state transition that's not
	allowed.

	Attributes:
		previous -- state at beginning of transition
		next --attempted new state
		message -- explanation of why the specific transition is not allowed.
	"""

def __init__(self,previous,next,message):
	self.previous=previous
	self.previous=next
	self.message=message
'''
# 10.9 定义清理行为
'''
try:
	raise KeyboardInterrupt
finally:
	print('Goodbye,world!')
'''
# l2
'''
def divide(x,y):
	try:
		result=x/y
	except ZeroDivisionError:			# 如果赋值0就打印下面的提示
		print("division by zero!")
	else:
		print("result is",result)
	finally:
		print("executing finally clause")

divide(2,1)

divide(2,0) 		# 会抛出错误赋值不能为0
divide("2","1")
'''
# 10.10预定义清理行为 for打开文件后不会关闭，而with结束后会关闭
'''
for line in open("linux记录.txt"):
	print(line,end=" ")

with open("linux记录.txt") as f:
	for line in f:
		print(line,end=" ")
'''
#  11.1 l1 python3面向对象
# 类(Class)	：用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
# 方法 				：类中定义的函数。
# 类变量			：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
# 数据成员		：类变量或者实例变量用于处理类及其实例对象的相关的数据。
# 方法重写		：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为
# 							方法的重写。
# 局部变量		：定义在方法中的变量，只作用于当前实例的类。
# 实例变量		：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
# 继承				：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作
# 							为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"
# 							关系（例图，Dog是一个Animal）。
# 实例化 			：创建一个类的实例，类的具体对象。
# 对象 				：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。
'''
class MyClass: 						# 定义一个类
	"""一个简单的类实例"""
	i=12345										# 类的属性
	def f(self): 							# 以函数的形式定义类
		return 'hello world'
# 实例化类
x= MyClass() 								# 类赋值给x

# 访问类的属性和方法
print("MyClass 类的属性 i 为：",x.i) 				# 调用类格式：类.属性
print ("MyClass类的方法f输出为",x.f()) 		# 类的方法：类.属性（）
'''

# 11.1 l2 类的构造方法 通过__init__可以直接构建类节省步骤
'''
def __init__(self):
    self.data = []


x = MyClass()
print(x.data)
'''

'''
class Complex:
    def __init__(self, realpart, imagpart):
        self.r = realpart
        self.i = imagpart

x = Complex(3.0, -4.5)
print(x.r, x.i)
'''

# 11.2 self代表类的实例，而非类
'''
class Test:
    def prt(self):
        print(self)
        print(self.__class__)


t = Test()
t.prt()
print('*' * 60)
Test().prt()
'''
# 11.3 self是可被代替的,可以用任何非内建函数代替
'''
class Test:							# 建立一个类
	def prt(runoob):
		print(runoob)
		print(runoob.__class__)
t=Test()
t.prt()
'''
# 11.4 类的方法
'''
class people:
	# 定义基本属性
	name='' 
	age=0
	# 定义私有属性,私有属性在类外部无法直接进行访问
	__weight__ =0
	# 定义构造方法
	def __init__(self,n,a,w):
		self.name=n
		self.age=a
		self.__weight=w
	def speak(self):
		print("%s 说:我 %d 岁." %(self.name,self.age))

#实例化类
悦悦=people('妈妈',40,30)
悦悦.speak()
'''

# 11.5 继承 必须与派生类定义在一个作用域内。除了类，还可以用表达式，基类定义在另一个模块中时这一点非常有用
'''
class people:
    # 定义基本属性
    name = ''
    age = 0
    # 定义私有属性，私有属性在类外部无法直接进行访问
    __weight__ = 0

    # 定义构造方法
    def __init__(self, n, a, w):
        self.name = n
        self.age = a
        self.__weight__ = w

    def speak(self):
        print("%s 说：我%d 岁 。" % (self.name, self.age))


# 单继承实例
class student(people):
    grade = ''

    def __init__(self, n, a, w, g):
        # 调用父类的构函
        people.__init__(self, n, a, w)
        self.grade = g

    # 覆写父类的方法
    def speak(self):
        print("%s 说：我%d 岁了，我在读%d 年级" % (self.name, self.age, self.grade))


s = student('悦悦', 10, 60, 3)
s.speak()
'''

# 11.6多继承
'''
class 人:
	# 定义基本属性
	name = ''
	age = 0
	# 定义私有属性，私有属性在类外部无法直接进行访问
	__weight = 0
	
	# 定义构造方法
	def __init__ (self,n,a,w):
		self.name = n
		self.age = a
		self.__weight = w
	
	def speak (self):
		print ("%s 说：我 %d岁。" % (self.name,self.age))


# 单继承示例
class 学生 (人):
	grade = ''
	
	def __init__ (self,n,a,w,g):
		# 调用父类的构函
		人.__init__ (self,n,a,w)
		self.grade = g
	
	# 覆写父类的方法
	def speak (self):
		print ("%s 说:我%d岁了，我在读%d年级" % (self.name,self.age,self.grade))


# 另一个类，多重继承之前的准备
class speaker ():
	topic = ''
	name = ''
	
	def __init__ (self,n,t):
		self.name = n
		self.topic = t
	
	def speak (self):
		print ("我叫%s,我是一个演说家，我演讲的主题是%s" % (self.name,self.topic))


class sample (speaker,学生):
	a = ''
	
	def __init__ (self,n,a,w,g,t):
		学生.__init__ (self,n,a,w,g)
		speaker.__init__ (self,n,t)


test = sample ("悦悦",25,80,4,"英语")
test.speak ()  # 方法名同，默认调用的是在括号中排前地父类的方法
'''

# 11.7 方法重写,父类方法的功能不能满足需求，可以在子类重写父类的方法.

"""
class Parent:  # 定义父类
	def myMethod(self):
		ic('调用父类方法')


class Child(Parent):  # 定义子类
	def myMethod(self):
		ic('调用子类方法')


c = Child()  # 子类实例
c.myMethod()  # 子类调用重写方法
# super() 是调用父类(超累)的一个方法
super(Child, c).myMethod()  # 用子类对象调用父类已被覆盖的方法

ic(Parent().myMethod())  # 直接打印父类的信息
"""
# 11.8类属性与方法
# 类的私有属性__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接
# 							访问。在类内部的方法中使用时 self.__private_attrs。

# 类的方法:在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须
# 			包含参数 self，且为第一个参数，self 代表的是类的实例。

# self 的名字并不是规定死的，也可以使用 this，但是最好还是按照约定是用 self。

# 类的私有方法__private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，
# 							不能在类的外部调用。self.__private_methods。
"""
class JustCounter:
	__secretCount=0  	# 私有变量,只有类内部可使用,外部使用会出错
	publicCount=0 		# 公开变量
	def count(self):
		self.__secretCount+=1
		self.publicCount+=1
		print(self.__secretCount)

counter=JustCounter()
counter.count()
counter.count()
ic(counter.publicCount)
print('-'*70)
counter.count()
print('-'*70)
ic(counter.publicCount)
# ic(counter.__secretCount)  		# 因__secretCount是私有变量,所以出错
counter.count()
"""

# 11.8l2私有类的实用
'''
class Site:
	def __init__(self,name,url):
		self.name = name
		self.__url = url
	
	def who(self):
		print('name:',self.name)
		print('url:',self.__url)
	
	def __foo(self):
		print("这是私有方法")
	
	def foo(self):
		print("这是公有方法")
		self.__foo()


x = Site('我的教程','www.kali.org')
x.who()  # 正常输出信息
x.foo()  # 只输出公有方法
x.__foo()  # 会报错
'''
# 11.9类的专有方法:
# __init__ : 构造函数，在生成对象时调用
# __del__ : 析构函数，释放对象时使用
# __repr__ : 打印，转换
# __setitem__ : 按照索引赋值
# __getitem__: 按照索引获取值
# __len__: 获得长度
# __cmp__: 比较运算
# __call__: 函数调用
# __add__: 加运算
# __sub__: 减运算
# __mul__: 乘运算
# __truediv__: 除运算
# __mod__: 求余运算
# __pow__: 乘方
# 11.10运算符重载
'''
class Vector:
	def __init__(self,a,b):
		self.a=a
		self.b=b
	def __str__(self):
		return 'Vector (%d,%d)'%(self.a,self.b)
	def __add__(self,other):
		return Vector(self.a+other.a,self.b+other.b)

v1=Vector(2,10)
v2=Vector(5,-2)
print(v1+v2)
ic(v1+v2)
'''
# 12.1命名空间和作用域
# 有四种作用域：
# L（Local）：最内层，包含局部变量，比如一个函数/方法内部。
# E（Enclosing）：包含了非局部(non-local)也非全局(non-global)的变量。比如两个嵌套函数，一个函数（或类） A 里面又包含了一个函数 B ，那么对于 B 中的名称来说 A 中的作用域就为 nonlocal。
# G（Global）：当前脚本的最外层，比如当前模块的全局变量。
# B（Built-in）： 包含了内建的变量/关键字等。，最后被搜索
# 规则顺序： L –> E –> G –>gt; B。
'''
var1=5 				# 全局变量
def some_func():
	
	var2=6 			# 局部变量
	print(var2)
	def some_inner_func():
		
		var3=7 		# 内嵌局部变量
		print("这是内嵌局部变量",var3,var2,var1)
	print("*"*70)
	print(some_inner_func())
	# print(var3,var2,var1) # 出错,职能找到var2和1
	
ic(var1,some_func())
print("这是运行结果",var1,some_func())
'''
# 12.2全局变量和局部变量
'''
total = 0  # 全局变量

def sum(arg1, arg2):
    total = arg1 + arg2  # 这里是局部变量虽然同名
    print("函数内是局部变量:", total)
    return total

sum(10, 20)  # 直接调用sum函数
print("函数外是全局变量:", total)  # 这里是调用的全局变量
ic(sum(3, 4))  # 调试函数
'''
# 12.3global和nanlocal关键字的应用，global是对全局变量的应用，nanlocal是对非全局变量的引用
'''
num = 1
def fun1 ():
	global num  # 引用全局变量需要使用global关键字声明
	print (num)  # 打印没更改的函数值
	num = 123
	print (num)  # 打印更改后的函数

fun1 ()  # 调用函数
num = 3
print (num)  # 由于内部global修改了外部函数的值，所以这里值也跟着改变
ic (fun1 ())
print ('=' * 70)

def outer ():
	num = 10
	def inner ():
		nonlocal num  # 引用外层非全局函数需要nonlocal关键字声明
		num = 100
		print (num)

	inner ()
	print (num)

outer ()
'''
# 12.4函数的传递方式
'''
a = 10

def test ():
	global a  # 通过global来传递外部函数
	a = a + 1
	print (a)

test ()

def test1 (a):  # 或者通过函数参数来传递
	a = a + 1
	print (a)

test1 (a)
'''
# 13.1标准库的操作，操作系统接口
# dir() 列出模块所有函数
# help() 打开模块的帮助文件
# os模块主要是与操作系统关联的函数
# shutil针对日常文件和目录管理，更易于使用
'''
import os
os.getcwd() 				# 当前工作目录
os.chdir('/windows') 		# 修改当前工作目录
os.system('mkdir today') 	# 执行系统命令（mkdir）可以是其他命令

import shutil
shutil.copy('1.txt','2.txt') 	# 复制文件1.txt到2.txt
shutil.move('build/executables','installdir') 	# 移动文件xx到yy,也可用作重命名


'''
# 13.2文件通配符 可以用dos通配符*？等
'''
import glob
glob.glob('*.py') 		# 可以使用通配符，glob返回当前目录下所有的py文件
'''
# 13.3命令行参数 脚本调用命令行参数，命令行参数以链表的形式储存在sys模块的argv变量里
'''
import sys
print(sys.argv) 		# 显示储存的命令行
'''
# 13.4模块sys中的stdin（）错误输出，stdout（）重定向和stderr（）程序终止
'''
import sys
sys.stderr.write('这里是错误信息提示')
'''
# 13.5字符串正则匹配 re模块
'''
import re 		# re模块是高级字符串处理正则表达式工具，
re.findall(r'\bf[a-z]*','which foot or hand fell fastest') 	# 匹配开头字符为f的单词
re.sub(r'(\b[a-z]+) \1',r' \1','cat in in the the hat') 	# 每个个单词匹配一次，去掉重复的单词
'tea for too'.replace('too','two') 		# 匹配前面的too，并换成two
'''
# 13.6数字 math模块浮点计算和random模块随机数
'''
import math 		 		# math浮点计算的方式
math.cos(math.pi / 4) 		# Π的值除以4
math.log(1024,2) 			# **

import random
random.choice(['apple','pear','banana']) 	# 随机选择单词
random.sample(range(100),10) 				# 随机取100以内的10个数字
random.random()								# 随机取一以下浮点数
random.randrange(6) 						# 取6以内随机整数
'''
# 13.7 访问互联网
'''
# 没整明白-_-||!
from urllib.request import urlopen
for line in urlopen('http://tycho.nsno.navy.mil/cgi-bin/timer.pl'):
	line=line.decode('utf-8') 				# decoding the binary data
	if 'est' in line or 'EDT' in line: 		# look for Eastern Time
		print(line)
'''
'''
import smtplib
# 没整明白-_-||!
server=smtplib.SMTP('mail.163.com')
server.sendmail('sheroz@163.com','dzsheroz@163.com',
				"""Toj:dzsheroz@163.com
				from:soothsayer@example.org 
				Beware the Ides of March."""
				)
server.quit()
'''
# 13.8日期和时间
# 今天 today = datetime.date.today()
# 昨天 yesterday = today - datetime.timedelta(days=1)
# 上个月 last_month = today.month - 1 if today.month - 1 else 12
# 当前时间戳 time_stamp = time.time()
# 时间戳转datetime datetime.datetime.fromtimestamp(time_stamp)
# datetime转时间戳 int(time.mktime(today.timetuple()))
# datetime转字符串 today_str = today.strftime("%Y-%m-%d")
# 字符串转datetime today = datetime.datetime.strptime(today_str, "%Y-%m-%d")
# 补时差 today + datetime.timedelta(hours=8)
'''
from datetime import date
now=date.today()
print(now)
ic(now)
# detetime.strftime的参数 %y年，月%m，日%d，星期%A，%b月
ic(now.strftime("%m-%d-%y.%d %b %y 今天是星期 %A。 %B月的第 %d 天."))

birthday=date(1964,7,31)

print('1964年7月31日距离今天',(now-birthday).days,'天') 	# 今天的日期减去设定日期
ic(now-birthday) 	# datetime.today-datetime(1964,7,31)
'''
# 13.9 l1数据压缩
'''
import zlib

s = b'avc avc 123 whic abcd abcd python python lan lan sheroz sheroz'
print ("源数据长度", len (s))
t = zlib.compress (s)
print ('压缩后长度', len (t))
print ('压缩后数据', t)
a = zlib.decompress (t)
print ('解压缩数据', a)
zlib.crc32 (s)
print ('原效验码', zlib.crc32 (s))
print ('压缩后效验码', zlib.crc32 (t))
print ('解压后效验码', zlib.crc32 (a))
'''
# 13.9 l2文件压缩
'''
import zlib  # 导入压缩和解压缩模块

# 创建一个待压缩文件
f = open ("in.txt", "w")  # 打开一个文件，“w”写入数据
f.write ("123123123123123123123123123123123\n")  # .write写入数据
f.close ()  # 关闭文件

# 准备压缩的函数
def compress (infile, dst, level = 9):
	infile = open (infile, 'rb')  # b模式读取文件
	dst = open (dst, 'wb')  # b模式写入文件
	compress = zlib.compressobj (level)  # 设置压缩对象和等级
	data = infile.read (1024)  # 设置打开文件的函数
	while data:  # 开始执行打开文件进行压缩
		dst.write (compress.compress (data))  # 确定准备压缩的文件对象
		data = infile.read (1024)  # 读取文件内容
	dst.write (compress.flush ())  # 将压缩内容写入文件

# 准备解压缩的函数
def decompress (infile, dst):
	infile = open (infile, 'rb')  # b模式读取文件
	dst = open (dst, 'wb')  # b模式写入文件
	decompress = zlib.decompressobj ()  # 指定要解压缩
	data = infile.read (1024)  # 读取文件
	while data:
		dst.write (decompress.decompress (data))  # 指定准备解压的文件
		data = infile.read (1024)  # 读取待解压文件内容
	dst.write (decompress.flush ())  # 将解压内容保存到文件

# 将in.txt导入函数开始执行压缩和解压缩的过程
if __name__ == "__main__":
	compress ('in.txt', 'out.txt')
	decompress ('out.txt', 'out_decompress.txt')

import glob  # 导入查找文件的模块

# 查看刚才运行压缩和解压缩所产生的文件
a = glob.glob ('*.txt')  # 查找刚才创建的*.txt文件
print ('显示刚才生成的文件',a)  # 显示刚才创建的文件  # 13.10性能度量
# 将刚才生成的文件删除
import os
b=['in.txt','out.txt','out_decompress.txt'] 	# 生成刚才创建的文件列表
for i in range (len(b)): 						# 遍历列表文件
	print('这次删除了',b[i]) 						# 显示删除的文件
	os.unlink(b[i]) 							# 删除遍历列表
	print('剩余待删除文件',glob.glob('*.txt')) 	# 显示删除后的剩余文件
'''
# 13.10性能度量timeit模块，也可以用pstats模块来测量大范围的性能
'''
from timeit import Timer
it=Timer('t=a;a=b;b=t','a=1;b=2').timeit()
print(it)
it1=Timer('a,b=b,a','a=1;b=2').timeit()
print(it1)
ic(it)
'''

# 13.11：21年2月16日，测试模块doctest和unittest
''''
def average (values):
	"""Computes the arithmetic mean of a list of numbers.
	>>> print(average([20,30,70]))
	40.0
	"""
	return sum (values) / len (values)

import doctest
docteat.testmod() 				# 自动验证嵌入测试，不用特殊设置
ic(doctest.testmod ())
'''
# unittest的应用
'''
import unittest
class TestStatisticalFunctions(unittest.TestCase):

	def test_average(self): 			# 这里设置一个错误，以下函数不匹配
		self.assertEqual(average([20,30,70]),40.0) 		# average和test_average不匹配
		self.assertEqual(round(average([1,5,7]),1),4.3)
		self.assertRaises(ZeroDivisionError,average,[])
		self.assertRaises(TypeError,everage,20,30,70)

unittest.main() # 测试环境输出内容会以表格方式提示
'''

################################################################
##                       基础学习已结束                          ##
##                       接下来学习案例                          ##
################################################################

# 例1 下载bilibili或者其他视频网站的视频
# 先安装 you-get 命令行下pip install you-get
# 可在命令行下直接使用格式为 you-get -o d:\bili “网址”
# 全目录下载 ： you-get --playlist -o d:\bili "网址"
#
'''
import you_get

you_get.any_download(url='网址',stream_id='mp4',info_only=false,output_dir=r'd:\bili',merge=True)
'''

# 例2 小乌龟画圈圈
'''
import turtle as t
from random import randint as rint
t.shape("turtle")
t.pensize(5)
t.colormode(255)
t.bgcolor("black")
t.tracer(False)
for x in range(700):
    t.color(rint(0,255),rint(0,255),rint(0,255))
    t.circle(2*(1+x/4),5)
    t.speed(30)
    t.tracer(True)
'''
# 例3 石头剪子布

import random

guess_list = ['石头', '剪刀', '布'] 			# 设置集
guize = [['石头', '剪刀'], ['剪刀', '布'], ['布', '石头']] 	# 设置正确的结果

computer = random.choice (guess_list) 		# 随机选择集内的数据

people = input ("石头, 剪刀, 布:\n").strip () 	# 提示请输入数据

isTrue = True

while isTrue:
	if people not in guess_list: 			# 如果输入的数据没有在集里
		people = input ("石头, 剪刀, 布:\n").strip () # 提示重新输入
	else:
		isTrue = False 			# 否则循环为假，退出循环
print (computer) 				# 提示随机的结果
if people == computer: 			# 如果输入的和随即结果一样
	print ('平局') 				# 提示平局
elif [computer, people] in guize: 		# 如果为结果和组集重复 ，那就是输了
	print ('你输了！要再来一把不？')
else: 									# 如果结果没有在所有集中，那么结果为胜
	print ('恭喜！你赢了！')

print("sdf")
({[]})

'''
************powermode插件设置***********
在设置中搜索 settings.json

4.点击 “在 settings.json 中编辑” ，然后将以下代码复制粘贴进去，再选择你想要的效果样式解除注释（ctrl + /）即可，不懂的看注释，我都有写
注意：效果样式只能存在一个，要哪个就解开哪个用，并把不要的那行用 （ctrl + /）的方式注释掉
以下是代码段：
//powser mode
//“powermode.enabled”: true,
//样式
// 火焰
// “powermode.presets”: “flames”,
// 炸裂
// “powermode.presets”: “exploding-rift”,
// 爆炸
// “powermode.presets”: “simple-rift”,
// 粒子
“powermode.presets”: “particles”,
// 烟花
// “powermode.presets”: “fireworks”,
// 魔法
// “powermode.presets”: “magic”,
// 回形针
// “powermode.presets”: “clippy”,
// 时间间隔
“powermode.comboTimeout”: 0,
// 抖动
// “powermode.enableShake”: true,
// 随字体颜色变化
// “powermode.backgroundMode”: “mask”,
'''