1
2
3
4

Ctrl+c	 										#终止程序
Ctrl+z											#返回上一步
Ctrl+z+Shift									#返回下一步
Shift+alt+f										#vscode规整代码

1
2
3
4

help(func)										#查看函数的原型
type(parameter)									#查看参数的类型
import keyword
keyword.iskeyword(parameter)  					#判断是否为python的保留标识符(即关键字)

1
2
3
4
5
6
7

Import random
#方法一
a=random.randint(1, 100)						#返回[1,100]范围内的随机数
x=random.getstate()								#攻击假随机数，使其与前面随机数输出一样
random.setstate(x)
#方法二
a=int(100*random())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

#数据输入
a = input("请输入：")							#默认输入的类型是字符串
a = int(input("请输入一个整数:"))				#获取数值输入，并强制转int类型
a = eval(input("请输入一个数:"))					#获取数值输入，自动类型转换

#求小数
import decimal
a = decimal.Decimal('0.1')
b = decimal.Decimal('0.2')
c = a + b

#复数
c = 1-2j
print(c)
print(c.real,c.imag)							#输出都是浮点数

#地板除”//”与除”/”
print(3/2)										#1.5
print(3//2)										#1
print(divmod(3,2))						 		#输出(1, 1)，第一个数是3//2,第二个数是3/2,返回一个数组
a=divmod(3,2)
print(a[0])
print(a[1])

#绝对值abs()
z=3-4j
print(abs(z))									#若为复数，返回复数的模

#e/E细节
a=+3e4											#同a=3e+4

#pow与**
print(pow(2, 3))
print(pow(2,3,5))								#先进行2的3次方再进行%5
print(2 ** 3)									#同pow(2,3)

#complex:构造复数
a=complex(1,2)
a=complex("1+2j")

#bool:默认空,False,None,数字或复数0为False

#逻辑运算符:and or not(if true 则 false..)
print(3 and 4)
print(4 or 5)
print("ELee" and "Norman")
print("ELee" and 5)
#and中含有0，则返回0；均为非0时,返回后一个值;or中,至少有一个非0时,返回第一个非0
优先级：not>and>or

#if,elif,else
#条件成立时语句 if condition else 条件不成立时执行的语句:
print("乐") if 4<3 else print("蚌埠")

#5. 字符输出
#print连接
a=111
print("你的名字",a,"是吧")

a="ELee"
print("你的名字"+a+"是吧")

#print默认以换行符结束，即自动换行,若想同行输出:
print(xx语句xx,end=" ")

#6. for循环
for 变量 in 可迭代对象 :
  statement(s)
a={564,99,45,"gtre",44,"qe",9,99}
b=[1,5,62,2,6,"eq",6]

c="whlcj"
print(c[0])

for i in b:
	print(i)

#range: 
range(stop)          	 						# [0,stop)
range(start,stop)			    				# [start,stop)
range(start,stop,step)		  

1
2

rhyme=[1,2,3,4,5,"whlcj"]
print(rhyme[-1])								#最后一个元素的下标索引可以为-1,倒数第二个为-2....

1
2
3
4

print(rhyme[0:3])   							#输出为[1,2,3]
print(rhyme[:3])    							#输出为[1,2,3]
print(rhyme[3:])    							#输出为[[4, 5, 'whlcj']#输出字符串为单引号
print(rhyme[:]) == print(rhyme) != print(rhyme[]) #输出[1, 2, 3, 4, 5, 'whlcj']

1
2

print(rhyme[::2])   							#[1, 3, 5]
print(rhyme[::-1])  							#倒序输出

1
2

rhyme.append("heor")       						#一次只能添加一个元素
rhyme.extend(["qwe",33,"Elee"])		  			#添加一个可迭代对象

1
2
3

#在start的位置起，将后面length个元素修改为[parameter1,para2,...]
rhyme[start:0]=[parameter1,para2,...]  			#在start位置添加元素，其余元素依次后移
rhyme[start:]=[parameter1,para2,...]  			#将列表修改为[parameter1,para2,...] 

1
2
3
4

rhyme.insert(index:parameter)					#在index位置插入parameter其余元素依次后移
rhyme.remove(parameter)							#若出现多个匹配元素，只会删除第一个，若没有该元素则出现异常
rhyme.pop(index) 								#删除index处的元素
rhyme.clear()   								#清空列表

1
2
3
4
5
6
7

rhyme.sort()    	 							#从小到大排序
rhyme.reverse()== rhyme.sort(reverse=True)		#从大到小排序
rhyme.count()    								#返回元素的个数同len(rhyme)
rhyme.count(parameter)      					#查找列表中parameter的个数
rhyme.index(parameter) 		 					#返回第一个parameter的索引值
rhyme.index(parameter,start,end) 				#返回start到end内parameter的索引值
rhyme[rhyme.index(old_parameter)]=new_parameter #修改元素

1
2
3
4
5
6

rhyme1 = rhyme.copy()	
rhyme1 = rhyme[:] 								#切片拷贝

import copy	
rhyme1 = copy.copy(rhyme)     	 	 			#函数拷贝
rhyme1 = rhyme 					 	 			#只是让rhyme1引用了rhyme!	

1
2

import copy
matrix1=copy.deepcopy(matrix)  

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

matrix=[[1,2,3],
     [4,5,6],
     [7,8,9]]
for i in matrix:
  	for each in i:
    	print(each,end=" ")						#依次打印每一个元素

A=[0]*3                
for i in range(3):     
A[i]=[0]*3          							#正确定义
b=[[0]*3]*3             						#错误定义

1
2
3
4
5
6
7

rhyme = [i*2 for i in rhyme]    				#列表中元素*2
rhyme = [i*2 for i in "whlcj"] 					#输出rhyme=['ww','hh','ll','cc','jj']
rhyme = [i for i in range(10)] 					#定义一个[0,1,2,3...9]的列表
rhyme = [ord(i) for i in "whlcj"] 				#输出ASCII
rhyme = [i[1] for i in matrix]   				#输出矩阵中每一组的第2个元素
rhyme = [matrix[i][i] for i in range(len(matrix))]  #获取对角线元素
#列表推导式是创建一个新的列表，不同于迭代循环

1
2
3
4

#先执行for target in iterable再执行 if condition 最后执行expression
even =[i for i in range(10) if i%2==0] 	 		#返回偶数
rhyme =[col for row in matrix for col in row] 	#多维化成一维
rhyme =[[x,y] for x in range(10) if x%2 == 0 for y in range(10) if y%3==0]

1
2
3
4
5
6

#元组的打包和解包
rhyme=(1,2,3,4,5,"whlcj") == rhyme=1,2,3,4,5,"whlcj" 

#生成一个元组称为元组的打包
x,y,z,q,w,e=rhyme    							#将元组一次性赋值的行为称为解包
x,y,*z=rhyme      								#z赋值为[3,4,5,"whlcj"]列表

1
2
3
4
5
6

capitalize()									#首字母变为大写，其余变为小写，是返回生成一个新的字符串
casefold() 		 								#返回所有字母都小写的字符串(可处理多种语言大小写)
title()			 								#每个单词的首字母大写其余小写
swapcase()			 							#将所有字母大小写翻转
upper()			 								#所有字母都大写
lower()											#将所有字母小写(只能处理英语)

1
2
3
4
5
6

#前提：width大于字符串长度,fillchar是填充字符，默认是空格
center(width,fillchar='')   					#居中
ljust(width,fillchar='')						#左对齐
rjust(width,fillchar='')						#右对齐
zfill(width)									#用0填充左侧
用法:  "whlcj".center(20)

1
2
3
4
5

count(parameter,start,end)		 				#在[start,end]方位内查找元素
find(parameter)				    				#从左往右查找
rfind(parameter,start,end)						#从右往左,找不到返回-1,同上
index(parameter,start,end)						#从左往右,找不到抛出异常,同下
rindex(parameter,start,end)						#从右往左查找

1
2
3

expandtabs(n)   								#将字符串中的tab缩进转换为n个空格
replace(old,new,count=-1)						#替换元素,count是替换次数默认-1,即替换全部old字符
translate(table)	 							#将字符串中的对应字符通过表格映射

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

#都返回bool类型的值,index为[start,end]表范围,parameter,,表示可以多个参数
startswith(parameter,,,index)  					#判断parameter是否在开头
endswith(parameter,,,index)						#判断是否在结尾
istitle() 										#每个单词第一个字母都为大写？
isupper()
isalpha()             							#只由字母构成
isspace()										#是否空白字符串(空格,tab,\n)
isprintable()									#是否可打印字符(\n等无法打印)
isdecimal() 									#是否是十进制
isdigit()										#是否为数字
isnumeric() 									#是否为数字,分数(可中文，罗马数字等等)
isalnum()										#上3种加isalpha()任意一种都返回true
isidentifier()									#是否为合法标识符

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

strip(parameter)           						#去除左右空白
lstrip(parameter)								#去除左侧空白
rstrip(parameter)								#去除左侧空白
#若传入parameter则挨个字符匹配去除，直到没有相同

#eg:
"weierxunbushigeshou".lstrip("www")  			#输出eierxunbushigeshou,仅去掉了w
removeprefix(parameter)							#删除前缀parameter
removesuffix(parameter)							#删除后缀parameter

#拆分和拼接
partition(parameter)							#从左到右找分隔符,然后把字符串拆分为3份
rpartition()									#从右往左
split(parameter,count)		

#默认切分空格,或根据参数分割为列表,count为分割次数默认-1
rsplit()										#从右往左
splitlines()									#默认无参,按行分割不受系统换行符不同的限制,若参数为true分割包含换行符
parameter.join(iterable) 						#跟分割相反,在iterable中以parameter拼接

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

print("爱你{}遍{}".format(3000,"辣！"))		 	#爱你3000遍辣！
print("{first}{0}{first}{0}".format("非",first="是"))	#是非是非
a = "{1:>10}{0:<10}".format(250, 520)    		#    520250    
a = "{1:%>10}{0:*<10}".format(250, 520)   		#%%%%%%%520250*******
a = "{0:010}".format(520)          				#0000000520
a = "{:0=10}".format(-520)          			#-000000520
##
a="{:+}{:-}".format(520,-250)  					#+520-250
a="{:,}".format(1234567)    		 			#1,234,567		表示千位制,同{:_}
a="{:.2f}".format(3.1415)    					#3.14		限定小数点后几位
a="{:.2g}".format(3.1415)    					#3.1	限定小数点前后总共有多少个数位
a="{:.6}".format("parameter")  					#parame截取前6位,但是不能作用在整数上

##
'b':二进制输出
'c':Unicode字符输出
'd':十进制输出
'o':八进制输出
'x':十六进制输出
'X':十六进制输出
'e'或'E':科学计数法输出
'f'或'F':同c语言f类型,默认小数点后6位
'g'或'G':同c语言g,默认6位
'%':先乘以100再加上%,默认小数点后6位
若"#b"则输出"0b"+二进制结果,以此类推

1
2
3

times=3000
a=f"爱你{times}遍!"
print(a) 										#爱你3000遍

1
2
3

id(identifier)					
A is B 											#A,B地址是否相同
A in B 											#B是否包含A

1
2
3

del A,B 							
del A[parameter1,,,]
del A[::step]

1
2
3
4
5
6

list(string)
list(tuple)
tuple(string)
tuple(list)
str(list)
str(tuple)

1
2
3
4
5
6
7

max(sequence,default='')		 				#返回最大最小值,若为字符串则比较ASCII码
min(sequence,default='')  						#若为空则返回default内容
len()
sum(sequence,parameter)							#求和,先加上parameter
sorted(sequence,reverse=True)					#返回一个新列表,区别sequence.sort()
all()											#所有元素为真
any()											#存在一个元素为真

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

sorted(iterable,key=len) 						#比较字符串的长度,同sort(key=len)														#若无key则只比较ASCII码
reversed() 										#返回一个参数的反向迭代器
list(reversed()) 								#将迭代器转换回列表,结果等同于list.reverse() 
##
enumerate()			 							#将列表中每个元素抽离出来加上index构成元组列表
zip(A,B,C,,)			 						#返回一个元组列表迭代器,每个元组为(A[i],B[i],,)
list(zip(A,B))		 							#最短的可迭代对象终止时结束操作

import itertools
itertools.zip_longest(A,B,C,,) 					#zip到最长的列表元素个数,自动填充none

map(function,,,sequence,,)	
#每次得到sequence中一个元素或字符,交给function执行,返还迭代器

#eg:
list(map(pow,[1,2,3],[4,2,3]))==[pow(1,4),pow(2,2),pow(3,3)]  
#输出[1,4,27]最短的可迭代对象终止时结束操作

list(filter(function,iterable))		
#跟map类似但是只返还function判断为true的结果

1
2
3
4
5
6
7

a={"吕布":"口口布","关羽":"关习习","刘备":"刘baby"}
b=dict(吕布="口口布",关羽="关习习",刘备="刘baby")
c=dict([("吕布","口口布"),("关羽","关习习"),("刘备","刘baby")])
d=dict({"吕布":"口口布","关羽":"关习习","刘备":"刘baby"})
e=dict({"吕布":"口口布","关羽":"关习习"},刘备="刘baby")
f=dict(zip(["吕布","关羽","刘备"],["口口布","关习习","刘baby"]))
g=dict.fromkeys("whlcj",520)					 #创建了5个字符为键,键值都为520的字典

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

Dict[键] = 值									#对键的值进行修改,若没有该键,则增添新键
Dict.pop(键,"没有")								#删除键,若不存在,则抛出异常或指定default
Dict.popitem()									#删除最后一个键
del dic[键]										#通过del删除
Dict.update({dict})								#类似第一种方法,但可以同时修改或增加多个对象
Dict.get(键,"没有")								#常用查找方法,没有找到则返回"没有"
Dict.setdefault(键,值)							#返回键值,若没有该键则新增键和后面的值
Dict.keys()										#获取键的视图对象
Dict.values()									#获取值的视图对象
Dict.items()									#获取键值对的视图对象

1
2
3
4
5
6
7

Dict1=dict.copy()								 #浅拷贝
len(dict)										 #获取键值对的数量
键 in dict 										 #判断键是否存在于字典中
list(dirt)										 #得到所有键构成的列表
List(dirt.values)								 #得到所有的值构成的列表
iter(dirt)										 #所有键构成一个迭代器
Reversed(dict)									 #逆向排序

1
2
3

a={"吕布":{"语文":70,"数学":80,"英语":90},"关羽":[123,456,789]}
print(a["吕布"]["语文"])
print(a["关羽"][1])

1
2

a={v:k for k,v in a.items() if v>100}			 #返回值大于100的键值对换
a={x:ord(x) for x in "whlcj"}					 #创建以ASCII为值的字典

1
2
3
4
5

a={12,"whlcj","Elee"}
a={s for s in "whlcj"}
a=set("whlcj")
a=set([1,1,2,3,5])								 #使用列表创建集合可以实现去重
len(list) == len(set(list))						 #可判断列表中是否有重复元素

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

set.copy()										#浅拷贝
set1.isdisjoint(iterable)						#集合1与可迭代对象是否没有相同元素
se1.issubset(iterable)							#集合1是否是可迭代对象的子集
set1.issuperset(iterable)						#集合1是否是可迭代对象的超集
set.union(iterable)								#并集
set.intersection(iterable)						#交集
set.difference(iterable)						#差集

#上三种都支持多参数
set.symmetric_difference(iterable) 				#对称差集

1
2
3
4
5
6
7
8

set <= set1										 #检测子集
set <  set1										 #检测真子集
set >= set1										 #检测超集
set >  set1										 #检测真超集
set | set1 | set2,,								 #并集
set & set1 & set2,,								 #交集
set - set1 - set2,,								 #差集
set ^ set1 ^ set2,,								 #对称差集

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

set.update(*others)								#增加参数
set.intersection_update(*others)  				#将集合更改为交集
set.difference_update							#将集合更改为差集
set.symmetric_difference_update(*others)		#将集合更新为对称差集
Set.add(parameter)								#单独增加某个元素
#注意,update插入字符串会单独插入字符串的每个字符,add则会插入整个字符串

set.remove(parameter)
set.discard(parameter)							#删除集合元素
#若删除的元素不存在,remove会抛出异常,discard会静默处理
#只有可哈希的对象才有资格做为字典的键和集合的元素,列表不可哈希 

1
2
3
4

def funcname(name,times="3"):					 #若没有参数传入则调用默认参数但是
  for i in range(times):						 #默认参数应该放在最后
    print(f"520{name}")							 #def开头,不用写返回类型甚至不用写return,默认返回none
return times							 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

funcname("you",3)								#位置参数,按顺序传入
funcname(times=3,name="you")					#关键字参数传入
funcname("you",times=3)							#位置参数必须在关键字参数之前
def funcname(name,/,times="3"):
#函数定义参数中的/表示左边的必须是位置参数
def funcname(name,*,times="3"):
#函数定义参数中的*表示右边的必须是关键字参数
pass语句:函数内占位
global(parameter)  								#在函数内修改全局变量parameter
nonlocal parameter								#函数内修改上一级变量parameter

1
2
3
4

def A():
  def B():
   	  pass
  B()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

def outer():
  x = 0
  y = 0
  def inner(x1, y1):
      nonlocal x, y
   	  x += x1
      y += y1    
      print(f"现在,x={x},y={y}")
  return inner
move = outer()
move(1, 2)
move(-2, -2)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

import time
def time_master(func):
  	print("开始运行程序")
  	start=time.time()
  	func()
  	stop=time.time()
 	print(f"一共耗费了{(stop-start):.2f}毫秒")
@time_master
def myfunc():
  	time.sleep(2)
 	 print("Hello Ender")

'''
解构装饰器: myfunc=time_master(myfunc)
多重装饰器从下往上依次执行！
装饰器带参数=再嵌套一层函数
'''

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

#eg:
def squareX(x):
  	return x*x

b = lambda y:y*y								#b(3) = squareX(3)

#应用示例:
y=[lambda x:x*x,2,3]
print(y[0](y[1]))
mapped= map(lambda x: ord(x)+10,"whlcj")
print(list(mapped))
print(list(filter(lambda x:x%2,range(10))))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

#每次返回yield后的值,下一次调用该函数从上一次yield后开始
def counter():
    i=0
    while i<=5:
        yield i
        i+=1

for i in counter():
	print(i)									#输出0,1,2,3,4,5
    
c = counter()
print(next(c))
print(next(c))
print(next(c))
print(next(c))
print(next(c))
print(next(c))									#输出0,1,2,3,4,5

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#生成器:
def fib():
    x1=0
    x2=1
    while True:
        yield x1
        x1,x2=x2,x1+x2
        
a=fib()
for i in range(0,10):
  	print(next(a))

#闭包:	
def fib():
    x1=0
    x2=1
    def fib1():
        nonlocal x1,x2
        print(x1)
        x1,x2=x2,x1+x2
    return fib1
a=fib()
for i in range(10):
    a()

1
2
3

a = (i ** 2 for i in range(10))
for i in a:
  print(i)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

	def exchange(dollar, rate=6.32):
	  """
	  功能:汇率转换,美元->人民币
	  参数:
	  - dollar 美元数量
	  - rate 汇率,默认值是6.32(2022-03-08)
	  返回值:
      - 人民币的数量
	  """
	  return dollar*rate
	  help(exchange)

1
2
3
4

	def times( n:int,s:list = ["whlcj,123"]) -> str:
		return s*n
	print(times(5))
#现实作者期待的输入数据类型,但是不强制

1
2
3

print(times.__annotations__) 			 		#打印函数的类型注释(两个参数和一个返回值)
print(exchange.__doc__)		  					#打印函数文档
print(myfunc.__name__)							#打印自身函数

1
2
3
4
5
6

import functools
def add(x, y):
  	return x+y
functools.reduce(add, [1, 2, 3, 4, 5])
#reduce(func,iterable),将iterable依次传入func中返回累积的结果
print(functools.reduce(lambda x,y:x*y,range(1,11)))		

1
2
3
4
5

#将函数的多个参数拆分多次进行传递
c=functools.partial(pow,exp=3)
print(c(2))										#输出9
c=functools.partial(pow,3)
print(c(2))										#输出8

1
2
3
4
5

print(f.tell())									#返回读取字符的位置(包括\n等)
for each in f:
  print(each)
f.seek(0)										#将指针位置归零
print(f.readline())						

1
2
3
4
5
6
7

'r':读取(默认)
'w':写入(如果文件已经存在则先清空文件)
'x':排他性创建文件(如果文件已存在则打开失败)
'a':追加(如果文件已存在则在末尾追加内容)
'b':二进制模式
't':文本模式(默认)
'+':更新文件(读取和写入)

1
2
3
4
5
6
7
8
9

f = open("f1.txt","w")							#创建文件	
f.write("I love python\n")						#写入字符串,返回写入字符的数量
f.writelines(["whlcj\n","Elee"])				#将一系列字符串写入到文件中
f.close()										#将文件关闭同时将缓冲区字符写入f.flush()													#将缓存区字符输入到文件中
f = open("f1.txt", "r+")						#文件读写
print(f.readable())						
print(f.writable())								#检查文件是否可读可写
f.truncate(position)						
#将文件对象截取到position位置,若无参数则截断到当前指针位置

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

from pathlib import Path
print(Path.cwd())								#获取当前目录的路径
p = Path("D:/临时/pythonsg")					   #设置路径
q = p/"f2.txt"									#添加路径
print(q)
f = q.open("w")									#打开文件,同f=open("f2.txt","w")		
q1 = p/"whlcj"
q1.mkdir()										#创建文件夹,若已存在则报错
q1.mkdir(exist_ok=True)							#忽略报错信息
q1 = p/"whlcj/A/B/C"
q1.mkdir(parents=True,exist_ok=True)			#多级创建文件夹
print(p.is_dir())								#判断是否为文件夹
print(p.is_file())								#判断是否为文件
print(p.exist())								#判断是否存在
print(p.name())									#获取路径的最后一个部分
print(p.stem())									#获取文件的文件名
print(p.suffix())								#获取文件的后缀
print(p.parent())								#获取父级目录
ps = p.parents							
#获取逻辑祖先路径构成的序列,返回的ps是一个iterable
for each in ps:
  print(each)									#依次从父级输出到文件最上级
print(ps[0])									#父级目录
print(ps[1])									#支持索引
print(q.parts)
#将文件的各个组件拆分成元组,输出结果为:('D:\\', '临时', 'pythonsg', 'f2.txt')
print(p.stat())									#查询文件或者文件夹的一个状态信息
for i in p.iterdir():
  print(i)										#打印当前路径下的所有文件和文件夹
a=[x for x in p.iterdir() if x.is_file()]
print(a)										#将文件(等)整理成列表
q.rename("")									#改名,并将文件移动到工作区
q.replace(q1)									#将文件q,移动q1的路径下
q1.rmdir()										#删除文件夹(文件夹需为空)
q1.unlink()										#删除文件
q.glob("*.txt")									#返回相对路径下txt文件的可迭代器
list(q.glob("*/*.txt"))							#当前目录下的下一级目录中所有txt
list(q.glob("**/*.txt"))						#查找当前及以下的所有子目录

1
2
3

f = open("f1.txt", "w")
f.write("I love python\n")
f.close()

1
2

with open("f1.txt","w") as f:				
  	f.write("I love python\n")					#自动关闭文件