Python入门笔记

Python入门

• Life is short.You need Python

1、数据类型

1.1、基本数据类型

# 整数 Python可以处理任意大小的整数，当然包括负整数，在程序中的表示方法和数学上的写法一模一样
2
-5

# 浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的
0.1
1.58e10
3e-4

# 认识运算符
print(1+2)   # 加法
print(1-2)   # 减法
print(1*2)   # 乘法
print(1/2)   # 除法
print(1//2)  # 整除 (向下取整)
print(1%2)   # 取余数
print(2**2)  # 幂运算
print(2020- 5*5/2 +8**1)   #结合顺序和一般的数学运算符一样

# 浮点数的计算精度
0.1+0.2

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FiFsN6ZV-1612923339828)(Python基础.assets/95c8303d008e41b89744d87f4d57c3775f5a28339f3e4d16bae7829695d93b56)]

# 字符串是以单引号'或双引号"括起来的任意文本
'this is a string'
"yes"

'爸爸说："今天我做饭"'
"爸爸说：\"今天我做饭\""

len('hello world!')

# 布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值布尔值 布尔值可以用and、or和not运算。
# 注意大小写！
True or False

# 空值 空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。
None

1.2、组合数据类型

列表 list

list1 = [1, 2, 3, 4, 5 ]
list2 = ["a", "b", "c", "d","e","f"]
list3 = ['physics', 'chemistry', 1997, 2000]

元组 tuple

另一种有序列表叫元组：tuple。tuple和list非常类似，但是tuple一旦初始化就不能修改

tuple1 = (1, 2, 3, 4, 5 )
tuple2 = ("a", "b", "c", "d","e","f")
tuple3 = ('physics', 'chemistry', 1997, 2000)

字典 dict

Python内置了字典：dict的支持，dict全称dictionary，在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C6J7g2Kt-1612923339831)(Python基础.assets/ea92541b62604edf86225919fa7ff7764283ead3f2aa42518caa0b0093b627c7)]

word = {'apple':'苹果','banana':'香蕉'}
scores = {'小张':100, '小李':80}
grad = {4:'很好',3: '好',2:'中',1:'差',0:'很差'}

# word['apple']=苹果

集合 set

set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。

set([1,1,2,3,4])
# 结果为[1,2,3,4],可以用来降重

2、流程控制

2.1、if语句

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Y1y8mmln-1612923339834)(Python基础.assets/4641c6fa80214666ac1a7477a0f00baefd3be071a3ec4a5484ea92c2446bbea0)]

light = '红灯'

if light == '红灯':
    print('停')
elif light == '绿灯':
    print('行')
else:
    print('等一等')

2.2、循环语句

while循环

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-e1pdgPzt-1612923339840)(Python基础.assets/9da3e74ac43e431ab6f038fbc0b621d6d216ffcde63942318348397a0d661c3d)]

my_number = 3200  # 这是真实的价格
guess_number = input('这台冰箱多少钱？') 
guess_number = int(guess_number)
while guess_number != my_number:
    if guess_number<my_number:   
        guess_number = input('猜低了！再猜')
        guess_number = int(guess_number)
    else:
        guess_number = input('猜高了！再猜')
        guess_number = int(guess_number)
print('\n恭喜您，猜对了！\n')

for循环

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-t2laW7rU-1612923339843)(Python基础.assets/15162c27a1e442b99943ddaedd14fdcc635c832476734395b7649bb36ddf4364)]

for i in range(9):
    print(i+1)

2.3、break continue pass

如果希望在中间离开循环，也就是 for 循环结束重复之前或者 while 循环找到结束条件之前。有两种⽅式来做到：

• 使⽤ break 语句来完全终⽌循环。

# continue : 跳过本轮 
# 打印1-10中的偶数 
for i in range(10):
    num = i+1
    if num%2 != 0:
        continue

    print(num)
    print(num**2)

• 使⽤ continue 语句直接跳到循环的下⼀次迭代。

# continue : 跳过本轮 
# 打印1-10中的偶数 
for i in range(10):
    num = i+1
    if num%2 == 0:
        print(num)
    else:
        continue

# pass： 占位，还没想好怎么写，先让程序跑起来
for i in range(5):
    pass

3、字符串进阶

3.1、索引

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IMv7UUWJ-1612923339844)(Python基础.assets/8e341e7d1d31461695d3ed18665b157ad3e94b00de95454a86c471f01c30b77e)]

# 如图一个字符串
str1='Molly'
# 其中 str[0]=M  str[1]=o,以此类推
# str[-1]=y str[-2]=l 以此类推

3.2、常用函数

count 计数功能

显示自定字符在字符串当中的个数

find 查找功能

返回从左第一个指定字符的索引，找不到返回-1

index 查找

返回从左第一个指定字符的索引，找不到报错

split 字符串的拆分

按照指定的内容进行分割

字符串的替换

从左到右替换指定的元素，可以指定替换的个数，默认全部替换

字符串标准化

默认去除两边的空格、换行符之类的，去除内容可以指定

字符串的变形

my_string = 'hello_world'
my_string.upper()# 大写
my_string.lower()# 小写
my_string.capitalize()# 首字母大写

3.3、字符串输出

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZzAByM4n-1612923339845)(Python基础.assets/581e707258a44e4b9ce667d83f15c34b1d7a6111be75403a8261de5e02f89220)]

%

name = 'Molly'
hight = 170.4
score_math = 95
score_english = 89
print('大家好！我叫%s，我的身高是%d cm, 数学成绩%.2f分,英语成绩%d分' % (name, hight, score_math, score_english))

format

'Hello, {name:}, 成绩提升了{score:.1f}分，百分比为 {percent:.1f}%'\
    .format(name='小明', 
            score=6, 
            percent = 17.523)

f-string

name = 'Molly'
hight = 170.4
score_math = 95
score_english = 89
print(f"大家好！我叫{name}，我的身高是{hight:.3f} cm, 数学成绩{score_math}分,英语成绩{score_english}分")

4、list进阶

索引与函数与字符串类似，不加赘述

# 删除元素

list1 = ['a','b','a','d','a','f']
print(list1.pop(3)) 
print(list1)
list1.remove('a')
print(list1)

4.1、列表生成式

# 1-10之间所有数的平方 构成的字符串列表
[str((n+1)**2) for n in range(10)]
#就等于
str1=[]
for n in range(10):
    str1.append((n+1)**2)

4.2、生成器

通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。

# 练习 斐波那契数列
def feb(max_num):
    n_1 = 1
    n_2 = 1
    n = 0
    while n<max_num:
        if n == 0 or n == 1:
            yield 1
            n += 1
        else:
            yield n_1 + n_2
            new_n_2 = n_1 
            n_1 = n_1 + n_2
            n_2 = new_n_2
            n += 1

5、异常与错误的处理

异常即是一个事件，该事件会在程序执行过程中发生，影响了程序的正常执行。

一般情况下，在 Python 无法正常处理程序时就会发生一个异常。

异常是 Python 对象，表示一个错误。

当 Python 脚本发生异常时我们需要捕获处理它，否则程序会终止执行。

try:
<语句>        #运行别的代码
except <名字>：
<语句>        #如果在try部份引发了'名字'异常
except <名字>，<数据>:
<语句>        #如果引发了'名字'异常，获得附加的数据
else:
<语句>        #如果没有异常发生
finally:
<语句>        #有没有异常都会执行

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ilkf36L3-1612923339847)(Python基础.assets/21c45fe2d0504dd3a3f6239a86fa8e3b216011d51d3c41a198324c68ab1cc28a)]

6、函数

6.1、定义与调用

# 定义
def 函数名():
    
    
# 调用
函数名()

6.2、参数传递

位置参数

位置参数是最简单的一种函数调用的方式。位置参数须以正确的顺序传入函数、数量必须和声明时的一样。

def student_name_and_age(name, age):
    print('姓名：%s 年龄 %s' %(name, age))

缺省参数

调用函数时，缺省参数的值如果没有传入，则被认为是默认值。

def student_name_and_age(name, age='不愿透露'):
    "设置默认参数"
    print('姓名：%s 年龄 %s' %(name, age))

# 也可以为默认参数赋值
student_name_and_age('张三', 18)

可变参数

顾名思义，可变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个。

def all_student_names(*names):
    for name in names:
        print('姓名：', name)

all_student_names('张三','李四','王五')

可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。

关键字参数

关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。

def student_info(name, age, **kw):
    print(f'我的名字叫：{name},年龄：{age},其它信息：{kw}')

student_info('张三', 18, height=180)

命名关键字参数

如果要限制关键字参数的名字，就可以用命名关键字参数

def print_person_info(name, age, *, height, weight):
    print('我的名字叫：', name, '年龄：', age,'身高', height, '体重', weight)

print_person_info('张三', 18, height=180, weight=75)

参数的组合

在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

def student_info(name, age=18, *books, **kw):
    print('我的名字叫：', name, '年龄：', age,'其它信息：',kw)
    if 'city' in kw:
        print('来自：', kw['city'])
    for book in books:
        print('我有',book,'书')

student_info('张三', 18, '语文','数学','计算机', city='北京', height=180, weight=75)

6.3、变量的作用域与lambda匿名函数

作用域

1.局部变量 作用域:在函数内

2.全局变量 作用域:在函数外

函数优先使用局部变量 在没有局部变量的情况下， 使用全局变量

lambda函数

lambda 的主体是一个表达式，而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。

lambda 函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。

虽然 lambda 函数看起来只能写一行，却不等同于 C 或 C++ 的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

# lambda 若干个输入参数 : 返回值的表达式
lambda arg1, arg2: arg1 + arg2

6.3、高阶函数

map()

函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-avYClTGw-1612923339848)(Python基础.assets/eb6612cd9eb642198275c6fc5d59e44566d43c42e5184ccd91df8c90d882de16)]

reduce()

用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，依此类推，最后得到一个结果。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pUclLYWR-1612923339848)(Python基础.assets/944ffffc054a476e9784f17951918b6c62a7d83eb8df475f91f4e3f55c0467bd)]

7、面向对象

7.1、前置知识点

sorted()

Python中sorted()函数可对所有可迭代的对象进行排序操作

sorted(iterable, key=None, reverse=False)
# iterable：可迭代对象。
# key：主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
# reverse：排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

pop()

Python中pop()函数可用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。

list.pop([index])
# index：index为可选参数，用于表示要移除列表元素的索引值，不能超过列表总长度，默认为index值为“-1”，即删除列表中的最后一个值

id()

Python中id()函数可返回对象的唯一标识符，标识符是一个整数。CPython 中id()可用于获取对象的内存地址。

id(object)
# object：需要获取标识符的对象。

dir()

Python中dir()函数不带参数时，可返回当前范围内的变量、方法和定义的类型列表；带参数时，可返回参数的属性、方法列表。如果参数包含方法dir()，该方法将被调用。如果参数不包含dir()，该方法将最大限度地收集参数信息。

dir(object)
# object：对象、变量、类型。

split()

Python中split()函数可通过指定分隔符对字符串进行分割，如果参数num有指定值，则分隔num+1个子字符串。

str.split("sign", num)
# sign：分隔符，用于指定对字符串进行分割的单位，常见的分隔符有空格、逗号等。
# num：分割次数，需要注意的是，分割之后的字符串个数等于分割次数加一。

help()

Python中help()函数可用于查看函数或模块用途的详细说明。help()函数相当于一个内置的Python帮助手册，当我们遇到一些新的函数名称时，掌握好help()函数的使用可以让我们更快更清晰地理解Python里面这些新函数的作用。

help(object)
# object：需要查看详细说明信息的对象。

threading模块

threading，基于线程的并行，这个模块在较低级的模块 _thread (底层多线程 API)基础上建立较高级的线程接口。

该模块定义了以下函数：

threading.active_count() 返回当前存活的线程类 Thread 对象。返回的计数等于 enumerate() 返回的列表长度。

threading.current_thread() 返回当前对应调用者的控制线程的 Thread 对象。如果调用者的控制线程不是利用 threading 创建，会返回一个功能受限的虚拟线程对象。

threading.get_ident() 返回当前线程的 “线程标识符”。它是一个非零的整数。它的值没有直接含义，主要是用作 magic cookie，比如作为含有线程相关数据的字典的索引。线程标识符可能会在线程退出，新线程创建时被复用。

更多关于threading的详细说明，可前往Python官网文档查看，地址如下：

https://docs.python.org/zh-cn/3.7/library/threading.html

zipfile模块

ZIP 文件格式是一个常用的归档与压缩标准。 这个模块提供了创建、读取、写入、添加及列出 ZIP 文件的工具。 任何对此模块的进阶使用都将需要理解此格式，其定义参见 PKZIP 应用程序笔记。

此模块目前不能处理分卷 ZIP 文件。它可以处理使用 ZIP64 扩展（超过 4 GB 的 ZIP 文件）的 ZIP 文件。它支持解密 ZIP 归档中的加密文件，但是目前不能创建一个加密的文件。解密非常慢，因为它是使用原生 Python 而不是 C 实现的。

下面展示一下zipfile的几个常用函数：

ZipFile.close() 关闭归档文件。 你必须在退出程序之前调用 close() 否则将不会写入关键记录数据。

ZipFile.getinfo(name) 返回一个 ZipInfo 对象，其中包含有关归档成员 name 的信息。 针对一个目前并不包含于归档中的名称调用 getinfo() 将会引发 KeyError。

ZipFile.infolist() 返回一个列表，其中包含每个归档成员的 ZipInfo 对象。 如果是打开一个现有归档则这些对象的排列顺序与它们对应条目在磁盘上的实际 ZIP 文件中的顺序一致。

ZipFile.namelist() 返回按名称排序的归档成员列表。

ZipFile.open(name, mode=‘r’, pwd=None, *, force_zip64=False) 以二进制文件类对象的形式访问一个归档成员。 name 可以是归档内某个文件的名称也可以是某个 ZipInfo 对象。 如果包含了 mode 形参，则它必须为 ‘r’ (默认值) 或 ‘w’。 pwd 为用于解密已加密 ZIP 文件的密码。

更多关于zipfile的详细说明，可前往Python官网文档查看，地址如下：

https://docs.python.org/zh-cn/3.7/library/zipfile.html

7.2、类

定义

class Athlete:

• 第一部分：class定义类的关键字，Athlete符合python标识符命名规则，：表示类内容的开始

def init(self,a_name,a_dob=None,a_times=[]):

• 第二部分：def定义函数的关键字，init 方法是一个特殊方法会在实例化对象时自动调用，我们会在这个方法中对数据进行赋值。self作为类中函数的第一个参数，方便该方法调用该类的其他属性和方法。
• 第三部分：自定义的属性和方法

使用类

1.创建对象

对象名 = 类名(参数)

2.使用.调用类的方法和属性

对象.属性名

对象.方法名

类属性

所有对象共享的数据

在 init 之上，或者说在类的范围内与方法同等级别，书写变量名=值

调用：

类名.类属性

类方法

所有对象共享的方法

定义：

方法定义时，使用@classmethod标记

调用：

类名.类方法

对象.类方法

变量或方法名字前面加__前面设为私有的，不可以被对象直接调用

7.3、方法重写

子类方法与父类方法完全相同，子类若重写了父类的方法，则子类对象调用方法时就是调用的自己类中重新的方法。

mark1 = get_coach_data('mywork/mark.txt')
mark2 = get_coach_data('mywork/mark1.txt')
mark3 = get_coach_data('mywork/mark2.txt')


mark1 = OtherAthlete(mark1.pop(0),mark1.pop(0),mark1.pop(0),mark1)
mark2 = OtherAthlete(mark2.pop(0),mark2.pop(0),mark2.pop(0),mark2)
mark3 = OtherAthlete(mark3.pop(0),mark3.pop(0),mark3.pop(0),mark3)

print('姓名：%s,生日：%s,深蹲：%s个,最快的3次成绩：%s' %(mark1.name,mark1.dob,mark1.squat,mark1.top3()))
print('姓名：%s,生日：%s,深蹲：%s个,最快的3次成绩：%s' %(mark2.name,mark2.dob,mark2.squat,mark2.top3()))
print('姓名：%s,生日：%s,深蹲：%s个,最快的3次成绩：%s' %(mark3.name,mark3.dob,mark3.squat,mark3.top3()))
姓名：mark,生日：2010-2-4,深蹲：300个,最快的3次成绩：['3.11', '3.11', '3.23']
姓名：mark,生日：2010-2-4,深蹲：111个,最快的3次成绩：['3.11', '3.11', '3.23']
姓名：mark,生日：2010-2-4,深蹲：222个,最快的3次成绩：['3.11', '3.11', '3.23']

loren = get_coach_data('mywork/loren.txt')
mark = get_coach_data('mywork/mark.txt')

loren = Rugby(loren.pop(0),loren.pop(0),loren.pop(0),loren)
mark = OtherAthlete(mark.pop(0),mark.pop(0),mark.pop(0),mark)

print(loren.name)
print(loren.dob)
print(loren.squat)
print(loren.top3())

print(mark.name)
print(mark.dob)
print(mark.squat)
print(mark.top3())
2011-11-3
270
3.59
['4.11', '4.21', '4.21']
mark
2010-2-4
300
['3.11', '3.11', '3.23']

loren = get_coach_data('mywork/loren.txt')
mark = get_coach_data('mywork/mark.txt')

loren = Rugby(loren.pop(0),loren.pop(0),loren.pop(0),loren)
mark = OtherAthlete(mark.pop(0),mark.pop(0),mark.pop(0),mark)

def print_rugby(athlete):

    print(athlete.name)
    print(athlete.dob)
    print(athlete.squat)
    print(athlete.top3())

print_rugby(loren)
print_rugby(mark)
2011-11-3
270
3.59
['4.11', '4.21', '4.21']
mark
2010-2-4
300
['3.11', '3.11', '3.23']

多态性：一个事物多种形态

上面例子中print_rugby的参数athlete，athlete.name，athlete.top3()的行为由athlete的子类决定。

多态的好处是：减少重复代码，分离经常改变的代码与不经常改变的代码，使得代码可维护性提高。

7.4、多继承

class Father(): 
    def talk(self):
        print("---爸爸的表达能力---")

class Mather():
    def smart(self):
        print("---妈妈聪明的头脑---")

class Child(Father,Mather):
    pass

child1 = Child()
child1.talk()
child1.smart()
# 输出
---爸爸的表达能力---
---妈妈聪明的头脑---

#多个父类有相同的属性或方法名，这种情况应该避免
class Father(): 
    def __init__(self):
        self.color = 'black'

    def talk(self):
        print("---爸爸的表达能力---")

class Mather():
    def __init__(self):
        self.color = 'white'
    def talk(self):
        print("--妈妈也能表达")
    def smart(self):
        print("---妈妈聪明的头脑---")

class Child(Father,Mather):
    pass

child1 = Child()
child1.talk()
child1.smart()
print(child1.color)
# 输出
---爸爸的表达能力---
---妈妈聪明的头脑---
black

class Father(): 
    def __init__(self):
        self.color = 'black'
    def talk(self):
        print("---爸爸的表达能力---")

class Mather():
    def __init__(self):
        self.height = 170
    def smart(self):
        print("---妈妈聪明的头脑---")

class Child(Father,Mather):
    def __init__(self):
        Father.__init__(self)
        Mather.__init__(self)

child1 = Child()
child1.talk()
child1.smart()
print(child1.color)
print(child1.height)
# 输出
---爸爸的表达能力---
---妈妈聪明的头脑---
black
170

7.5、导入

在每个需要Athlete的时候，我都需要把Athlete类的定义复制粘贴要用的代码上方。可以用import导入

import sys
sys.path.append('mywork')

# import athlete
# print(dir(athlete))
from athlete import *

import sys
导入sys模块 sys.path.append(‘work’)
将模块athlete.py添加到模块搜索路径
from athlete import *
导入athlete模块，使用athlete模块下的所有代码

8、文件管理

8.1、函数

open() 为bif（内置函数），参数有多个，必须的是文件路径。 返回的一个文件对象。

file.readline(),读取文件中的一行。

file.read(10)，按字节读取

file.write() 写入

f = open('路径')  ##打开
print(f.read())  ##操作：读取
f.close  ##关闭

8.2、数据问题解决办法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uF8YCGEj-1612923339850)(Python基础.assets/image-20210210091542537.png)]

try - catch语句

1.使用异常跳过有问题的数据 2.增加代码判断

#使用异常
f = open('work/train_data_wrg.txt')
for line in f:
  
    data = line.strip().split(',')
    try:

        print('姓名：'+data.pop(0)+'生日：'+data.pop(0)+'时间：'+str(data))
    except:
        pass
f.close()

代码判断

#代码判断
f = open('work/train_data_wrg.txt')#1
for line in f:#2
  
    data = line.strip().split(',')

    if len(data) != 1:
        print('姓名：'+data.pop(0)+'生日：'+data.pop(0)+'时间：'+str(data))

f.close()#3

8.3、JSON

json的形式保存到变量

with open('work/json.txt','w') as f:
    json.dump(ath_json,f)

读取json文件内容

with open('work/json.txt') as f:

    ath = json.load(f)
    print(ath)

8.4、目录访问

import os
#返回当前工作目录
current_path = os.getcwd()
print('当前路径：'+current_path)


#改变当前工作目录
os.chdir('/home/aistudio/work')
#运行mkdir命令
os.system('mkdir today')


from pathlib import Path
#返回当前绝对路径
abs_path = os.path.abspath('')
print('abs_path：'+abs_path)
#路径是否存在
Path(abs_path).exists()


print('当前路径：'+os.getcwd())
listdir = os.listdir()
#返回当前路径下文件和文件夹名
print(listdir)

#是否为文件夹
os.path.isdir('/home/aistudio/work/today')

import os
# 显示work文件路径下所有的txt文件

def recur(path):
    path = '/home/aistudio/work'
    listdir = os.listdir(path)
    for name in listdir:
        if name[0] is '.' or name[0] is '_':
            continue
        next_path = path+'/'+name
        if os.path.isfile(next_path) :
            # print(next_path + '=====isfile')
            temp = name.split('.')
            (filename,filetype) = (temp.pop(0),temp.pop(0))
            if filetype == 'txt':
                target.append(name)
        else:
            recur(next_path)

    return os.path.dirname(next_path)
path = '/home/aistudio/work'
target = []
recur(path)
print(target)

8.5、进程与线程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TTYb09em-1612923339851)(Python基础.assets/11849cfea6994a4f8892e58647206963701bc5c26ac04b03aa58cad4841caba8)]

import threading, zipfile

class AsyncZip(threading.Thread):
    def __init__(self, infile, outfile):
        threading.Thread.__init__(self)
        self.infile = infile
        self.outfile = outfile

    def run(self):
        f = zipfile.ZipFile(self.outfile, 'w', zipfile.ZIP_DEFLATED)
        f.write(self.infile)
        f.close()
        print('压缩完成，您要的文件在:', self.outfile)

background = AsyncZip('work/loren.txt', 'work/myarchive.zip')

print('压缩作业开始了，请您耐心等待...')
background.start()
print('我正在为您压缩，请问还需要帮您做什么呢？')
background.join()