python-基础知识
目录：
0、正则表达式
一、变量和简单数据类型
二、列表
三、操作列表
四、if语句
五、字典
六、用户输入与while循环
七、函数
八、类
九、文件和异常
十、测试代码
################################################################################
0、正则表达式
1、
一 变量和简单数据类型
1. 变量名包含字母/数字/下划线，不能以数字开头；
Python根据缩进来判断代码行与前一个代码行的关系；
2. 字符串处理：字符串单引双引均可以；反斜杠\转义，如果不想转义 字符串前加r，r'ab\t'位abt；'a'*3 为aaa复制三个。
a.title() //对字符串a中的单词首字母大写；
a.upper() //将字符串改为全大写；
a.lower() //将字符串改为全小写；
a.rstrip() //删除字符串末尾的空白；
a.lstrip() //删除字符串开头的空白；
a.strip() //删除字符串两端的空白；
1)撇号位于双引之间:单引号和双引号都可引字符串，单引号中可有双引号，不用转义；双引号中也可有双引号，也不用转义；三引号(单引号或双引号)，对应换行的字符串。
2)字符串格式化：%f或%F浮点数，%.4f取到小数点后4位；%b二进制；%d或%i十进制整数；%o八进制；%x 十六进制； %e或%E指数，基底写为e或E；%g或%G，指数e/E或浮点数(根据显示长度)。
3. 数字
a. 3**2表示乘方，9；
b. 浮点数的小数点位数不确定；
>>> 0.1+1.3
1.4000000000000001
c. 将整数类型改为字符串；
str(a) //将非字符串表示为字符串；常在print里打印整数时用；
d. 3/2 结果是1.5，浮点型；3.0/2结果是1.5；3//2为1，取整。
e.复数，可以是浮点，可以用x=a+bj,也可以用complex(a,b) 实数部分和虚数部分为x.real和x.imag
二 列表
1. 用[]表示列表，逗号分分隔；
a=['aa','bb','cc']
a[0].title()即Aa；
a[-2]即倒数第二个；左0开始，右-1开始。
2. 增删查改：
a. append('dd') //结果a=['aa','bb','cc','dd']
a.insert(0,'zz') //结果a=['zz','aa','bb','cc']
del a[0] //结果a=['bb','cc']
b=a.pop() //结果a=['aa','bb'],b=['cc']
b=a.pop(0) //结果b=['aa'],a=['bb','cc']
a.remove('bb) //结果a=['aa','cc'],只删除第一个指定的值；
3. 组织列表:
a.sort() //永久排序，以字母排序；a.sort(reverse=True) //字母顺序降序；不能print(a.sort())
print(a.sorted()) //临时排序，a的值不变；也可加reverse=True；
a.reverse() //结果a倒叙
len(a) //a的长度，3
三 操作列表
1. 遍历整个列表
cats=['cata','catb','catc','catd'] for cat in cats: print(cat.title()+", that is a great cat!") print("\nthank u!") 此行无缩进，只执行1次；有\n中间空一行；
2. 创建数值列表
a. for value in range(1,5):
print(vlaue) 打印1到4
b. numbers=list(range(1,5))
print(numbers) 打印1到4，也可以加步长list(range(1,5,2))结果是1和3
c. 对数字列表执行简单的统计计算
min(numbers) numbers的最小值，max/sum()分别是最大值/总和；
d. 列表解析
squares=[value**2 for value in range(1,11)]
print(squares) 打印1，4，9，16到100
3. 列表的部分元素，切片
a. print(cats[0:3]) 输出0，1，2索引的元素；[:3]不指定第一个索引时从0开始；[3:]表示从索引3到最后；
b. 遍历切片
for cat in cats[:3]:
print(cat.title()) 打印前三个cats元素；[‘’,‘’,‘’,‘’]这种格式打印
c. 复制列表
cat_copy=cats[:] 复制cats表的所有元素到cat_copy
cat_copy=cats 这个是只有一个表，对两个表的操作会同时作用于cat_copy和cats；
4. 元组：不可变的列表（元组：tuple）
a. 访问元组
dimensions=(200,50,10)
print(dimensions[0]) 元组访问元素的方法与列表同；
b. 遍历所有元素
for dimension in dimensions:
print(dimension) 打印(200,50,10)
c. 修改元组变量：重新定义整个元组
5. 设置代码格式
a. PEP 8建议每级缩进都使用四个空格，这既可提高可读性，又留下了足够的多级缩进空间;
可将输入的制表符转换为指定数量的空格;
b. 很多Python程序员都建议每行不超过80字符;
PEP 8还建议注释的行长都不超过72字符，因为有些工具为大型项目自动生成文档时，会在每行注释开头添加格式化字符;
四. if语句
1. 例：
for car in cars:
if car='bmw':
print(car.upper()) else:
print(car.title())
2. 条件测试
car=='bmw' //返回true或false；区分大小写，如果想不区分大小写，可以car.tower(),改成小写比较； car !='bmw' car >= 0 and car <=20 ;用and或or检查多个条件；用in检查特定值是否包含在列表中(not in相反)；
3. if-elif-else结构，一个个判断； 中间可加多个elif；最后的else也可不加；
if 'cat1' in cats: print() if 'cat2' in cats: print() 以上两个if，用于测试多个条件时；判断多个元素满足条件；
五. 字典：一系列键值对；值可以是字符串/数字/列表/元组；（字典：dict）
1. 简单字典：
alien_0={'color':'green','points':5}
print(alien_0['color']) //打印green
2. 使用字典
a. 访问字典中的值：alien_0['color']
b. 增加键值对：alien_0['x_position']=0 //在字典里的顺序不确定
c. 先创建一个空字典：alien_0={}
d. 修改字典中的值：alien_0['color']='yellow'
e. 删除键值对：del alien_0['points']
3. 遍历字典
a. 遍历所有的键值对：for key,value in alien_0(): //也可用k,v
b. 遍历字典中的所有键：
for name in alien_0.keys(): print(name.title()) //使用keys() if name in ~: //此处可加一个判断name是不是在某一个列表里；
c. 按顺序遍历字典中的所有键：
for name in sorted(alien_0.keys()) //使用函数sorted按特定顺序排序，字母升序；
d. 遍历字典中的所有值：alien_0.vlaues()
使用集合set，类似于列表，每个元素都必须是独一无二的：set(alien_0.values())
集合set()常用add和update增加和修改集合中数据。
4. 嵌套：将字典存储在列表中，或将列表存储在字典中。
a. 字典列表：
alien_0 = {'color': 'green', 'points': 5}
alien_1 = {'color': 'yellow', 'points': 10}
alien_2 = {'color': 'red', 'points': 15}
aliens = [alien_0, alien_1, alien_2]
b. 在字典中存储列表
pizza = { 'crust': 'thick', 'toppings': ['mushrooms', 'extra cheese'], }
例2：for name, languages in favorite_languages.items(): //name/languages分别代表favorite_languages的键值；
#字典.items() 函数以列表返回可遍历的(键, 值) 元组数组.
c. 在字典中存储字典
users = { 'aeinstein': { 'first': 'albert', 'last': 'einstein', 'location': 'princeton', }, 'mcurie': {'first': 'marie', 'last': 'curie', 'location': 'paris', }, } for username, user_info in users.items(): ....
location=user_info['location']
六. 用户输入和while循环
1. input() //用户输入文本,raw_input()输入的都是字符串；input()则要严格遵守python语法；3.0版本合并了这两个；2.7的版本最好只用raw_input()
a. 例：message = input("Tell me something, and I will repeat it back to you: ")
print(message)
b. 使用int()获取数值；input()获取的是字符串，用int()将字符串形式作为数字；%求模运算；
#int()语法：class int(x, base=10)，base默认10进制；若x为数字，则不能有base，作用是取整；若x为str，则base可有可无，此时会检查x是不是base进制，int("9",2)返错，因为2进制没有9，int("1001",2)返回9.
2. while循环
a.使用标志：
prompt = "\nTell me something, and I will repeat it back to you:" prompt += "\nEnter 'quit' to end the program. " active = True while active: message = input(prompt) if message == 'quit': active = False else:
print(message)
b.在循环中使用break/continue；避免无限循环；
3.使用while循环来处理列表和字典
for 循环是一种遍历列表的有效方式，但在for 循环中不应修改列表，否则将导致Python难以跟踪其中的元素。要在遍历列表的同时对其进行修改，可使用while 循环。
a.在列表之间移动元素
# 首先，创建一个待验证用户列表 # 和一个用于存储已验证用户的空列表 unconfirmed_users = ['alice', 'brian', 'candace'] confirmed_users = [] # 验证每个用户，直到没有未验证用户为止 # 将每个经过验证的列表都移到已验证用户列表中
while unconfirmed_users: current_user = unconfirmed_users.pop() //pop()从列表中取值，类似于栈，从后取； print("Verifying user: " + current_user.title()) confirmed_users.append(current_user) # 显示所有已验证的用户 print("\nThe following users have been confirmed:") for confirmed_user in confirmed_users: print(confirmed_user.title())
b.删除包含特性值的列表元素
pets = ['dog', 'cat', 'dog', 'goldfish', 'cat', 'rabbit', 'cat'] print(pets) while 'cat' in pets: pets.remove('cat')
c.使用用户输入来填充字典
responses = {} # 设置一个标志，指出调查是否继续polling_active = True while polling_active: # 提示输入被调查者的名字和回答 name = input("\nWhat is your name? ") response = input("Which mountain would you like to climb someday? ") # 将答卷存储在字典中responses[name] = response # 看看是否还有人要参与调查 repeat = input("Would you like to let another person respond? (yes/ no) ") if repeat == 'no': polling_active = False # 调查结束，显示结果 print("\n--- Poll Results ---") for name, response in responses.items(): print(name + " would like to climb " + response + ".")
七. 函数
1、基本功能
def greet_user(username): print('Hello,'+username.title()+'!') greet_user('min')
a. 关键字实参：传递给函数的名称—值对。以下两个函数调用是等价的，实参的位置与值无关了。
describe_pet(animal_type='hamster', pet_name='harry') describe_pet(pet_name='harry', animal_type='hamster')
b. 默认值：定义函数时给一个默认值，调用函数时有值则可忽略此值。
def describe_pet(pet_name, animal_type='dog'):
c. 让实参变成可选的：
def get_formatted_name(first_name, last_name, middle_name=''): """返回整洁的姓名""" //三个双引号/单引号均可作为注释； if middle_name: full_name = first_name + ' ' + middle_name + ' ' + last_name else: full_name = first_name + ' ' + last_name return full_name.title() musician = get_formatted_name('jimi', 'hendrix') print(musician) musician = get_formatted_name('john', 'hooker', 'lee') print(musician)
d. 返回字典
def build_person(first_name, last_name,age=''): person = {'first': first_name, 'last': last_name} if age: person['age']=age return person musician = build_person('jimi', 'hendrix',age=27) print(musician) 返回{'age': 27, 'last': 'hendrix', 'first': 'jimi'}
e. 传递列表
def greet_users(names): for name in names: msg = "Hello, " + name.title() + "!" print(msg) usernames = ['hannah', 'ty', 'margot'] greet_users(usernames)
f. 禁止函数修改列表：function_name(list_name[:]),将列表的副本传递给函数
例：print_models(unprinted_designs[:], completed_models) //函数获得了所有未打印的设计的名称，但它使用的是列表unprinted_designs 的副本，而不是列 表unprinted_designs 本身。
g. 传递任意数量的实参：
def make_pizza(*toppings): //*toppings 中的星号让Python创建一个名为toppings 的空元组，并将收到的所有值都封装到这个元组中。 //参数中可添加其他形参； def build_profile(first, last, **user_info): //形参**user_info 中的两个星号让Python创建一个名为user_info 的 空字典，并将收到的所有名称—值对都封装到这个字典中。 profile = {} profile['first_name'] = first profile['last_name'] = last for key, value in user_info.items(): profile[key] = value return profile user_profile = build_profile('albert', 'einstein', location='princeton',field='physics') print(user_profile) //打印：{'field': 'physics', 'first_name': 'albert', 'last_name': 'einstein', 'location': 'princeton'}
h. 将函数存储在模块中：import pizza
from module_name import function_0, function_1, function_2 //导入特定的函数，多函数用逗号分隔。 from pizza import make_pizza as mp //导入函数名与现有名称冲突，可用as指定别名。也可以给模块指定别名：import pizza as p。 from pizza import * //导入模块中的所有函数。
2、python列表函数
1）list函数
list() 方法用于将元组转换为列表；
sort() 是list的内置方法，只有list有 ：sort(cmp=None, key=None, reverse=False)
sorted()方法是Python内置的，可以对所有可迭代的序列排序生成新的序列，只要可迭代就行，返回的都是一个list：sorted(iterable, cmp=None, key=None, reverse=False) ;
参数：
cmp：比较函数，比较什么参数由key决定。
key：用列表元素的某个属性或函数作为关键字。
reverse：排序规则，可以选择True或者False。
iterable：待排序的可迭代类型的容器
区别：
a.sort()修改待排序的列表内容,返回空，print(a)返回排序后的a；
sorted(a)，返回一个新的列表，而对a不产生影响;
2）cmp/len/max/min函数
cmp(list1, list2)
比较两个列表的元素
len(list)
列表元素个数
max(list)
返回列表元素最大值
min(list)
返回列表元素最小值
3）方法
list.append(obj)
在列表末尾添加新的对象
list.count(obj)
统计某个元素在列表中出现的次数
list.extend(seq)
在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.index(obj)
从列表中找出某个值第一个匹配项的索引位置
list.insert(index, obj)
将对象插入列表
list.pop([index=-1])
移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
ist.remove(obj)
移除列表中某个值的第一个匹配项
ist.reverse()
反向列表中元素
list.sort(cmp=None, key=None, reverse=False)
对原列表进行排序
八. 类
1. 创建和使用类
class Dog(): //首字母大写指的是类； def __init__(self, name, age): //Python调用__init__() 来创建Dog 实例时，将自动传入实参self 。每个与类相关联的方法调用都自动传递实参self ，它是一个指向实例本身的引用，让实例能够访问类中的属性和方法。 self.name = name self.age = age def sit(self): print(self.name.title()+ " is now sitting.") def roll_over(self): print(self.name.title()+ " rolled over!")
2. 使用类和实例
a. 给属性指定默认值
def __init__(self, make, model, year): self.make = make self.model = model self.year = year self.odometer_reading = 0 // 默认值
b. 修改属性的值
def update_odometer(self, mileage): self.odometer_reading = mileage
3. 继承
a. 定义
class ElectricCar(Car): //父类car def __init__(self, make, model, year): super().__init__(make, model, year) //初始化父类的属性； self.battery_size = 70 python2.7中的继承： class ElectricCar(Car): def __init__(self, make, model, year): super(ElectricCar, self).__init__(make, model, year)
b. 重新父类的方法：直接覆盖
c. 将实例用作属性
class ElectricCar(Car): def __init__(self, make, model, year): super().__init__(make, model, year) self.battery = Battery() my_tesla = ElectricCar('tesla', 'model s', 2016) print(my_tesla.get_descriptive_name()) my_tesla.battery.describe_battery()
4. 导入类
a. 导入单个类：
from car import Car //car是car.py，Car是类；
b. 从一个模块中导入多个类：
from car import Car,ElectricCar
c. 导入整个模块
import car
d. 导入模块中的所有类
from module_name import *
5. python 标准库
from collections import OrderedDict //OrderedDict 实例的行为几乎与字典相同，区别只在于记录了键—值对的添加顺序
九. 文件和异常
文本文件：默认为文本文件。存储普通‘字符’文本，默认为unicode字符集，可以记事本打开。word软件编辑的不是。
二进制文件：把数据内容用‘字节’存储，无法用记事本打开，需要专用软件解码，例图片/音频/视频/doc文档等。
1.文件操作相关模块及属性方法
1）文件操作相关模块
|
名称 |
说明 |
|
io模块 |
文件流的输入和输出操作 input output |
|
os模块 |
基本操作系统功能，包括文件操作 |
|
glob模块 |
查找符合特定规则的文件路径名 |
|
fnmatch模块 |
使用模式来匹配文件路径名 |
|
fileinput模块 |
处理多个输入文件 |
|
filecmp模块 |
用于文件的比较 |
|
cvs模块 |
用于csv文件处理 |
|
pickle和cPickle |
用于序列化和反序列化 |
|
xml包 |
用于xml数据处理 |
|
bz2、gzip、zipfile、zlib、tarfile |
用于处理压缩和解压缩文件(分别对于不同的算法) |
2）文件对象常用属性：
name ：返回文件的名字
mode ：返回文件的打开模式
closed：若文件被关闭，则返回True；file.closed。
3）文件对象的打开模式
open(name,mode,buffering,encoding=None) #用于打开一个文件，创建一个file对象。name为文件路径和文件名；mode打开模式，r/w/b/a/+，读/写(不存在则创建，存在则重写内容)/追加(不存在则创建，存在则在文件末尾追加内容)/二进制模式/读写模式；r+为读写，w+为读写；buffering=0,不使用缓冲区，仅在二进制模式下有效，=1，仅用于文本模式，使用缓冲区，大于1，则表示缓冲区大小，-1，表示系统默认缓冲区大小；
r/r+/rb+：指针放在文件开始；r/r+文件必须存在；w/w+/wb+：执行后指针在文件开始；a/a+/ab+：文件如果存在，指针在文件结尾。
4）文件对象的常用方法
read()指读(输出)全文；readline()读一行；readlines() 读取整个文件，但是返回的是可迭代对象，是字符串列表，例['a', 'b']；这三个函数每次读完指针都后移。
read([size]) 从文件中读取size个字节或字符的内容返回。例read(4)读取4个字符。
write(a)把字符串a写入到文件中； writelines(b)把字符串列表写入文件中，不添加换行符。
with语句自动执行file.close()来释放文件资源。
seek(offset[,whence]) //把文件指针移动到新的位置，offset表示相对于whence的多少个字节的偏移量；offset：off为正往结束方向移动，为负往开始方向移动；whence：0从文件头开始计算(默认)，1从当前位置开始计算，2从文件尾开始计算。
tell() //返回文件指针的当前位置
truncate([size]) //不论指针在什么位置，只留下前size个字节的内容，其余删除。若无size，则从指针位置到末尾全删。
flush() //缓冲区内容写入文件，不关闭文件。
close() //把缓冲区内容写入文件，同时关闭文件，释放文件对象相关资源。
举例：
with open(file,'r+',encoding='utf-8') as f: f.seek(20,0) //20对于英文20个字符，中文指针3为一个字； print(f.tell()) //输出20 print(f.read()) f.seek(20,0) f.truncate(20) f.seek(0,0) print(f.read()) //输出删除后，前20个字节。 结果： 20 know 你知道吗？ dont file文件： 你知道吗？ dont know
如果加flush()当没有输入回车键时，数据也依然写入到文件中；如果没有flush()方法的话，那么只有按下回车键才会把数据保存到文件中
f = open(file, "w") f.write("aaaaaa") #f.flush() #强行把缓冲区中的内容放到磁盘中 s = input("请输入回车键") f.close()
2. 从文件中读取数据
a. 读取整个文件
with open('pi_digits.txt') as file_object: //关键字with 在不再需要访问文件后将其关闭。文件在python_work中时。 也可以调用open() 和close() 来打开和关闭文件，但这样做时，如果程序存在bug，导致close() 语句未执行，文件将不会关闭。 contents = file_object.read() print(contents) print(contents.rstrip()) //rstrip()删除多出来的空行；
b. 文件路径
with open('text_files/filename.txt') as file_object: //相对文件路径，文件在python_work中；win用反斜杠； file_path = '/home/ehmatthes/other_files/text_files/filename.txt' with open(file_path) as file_object: //也可以绝对路径；
c. 逐行读取
filename = 'pi_digits.txt' with open(filename) as file_object: for line in file_object: print(line)
d. 创建一个包含文件各行内容的列表
filename = 'pi_digits.txt' with open(filename) as file_object: lines = file_object.readlines() for line in lines: print(line.rstrip()) //为删除每行左边的空格，可用strip()；
3. 写入文件
a. 写入空文件
filename = 'programming.txt' with open(filename, 'w') as file_object: file_object.write("I love programming.") 可指定读取模式 ('r' )、写入模式 ('w' )、附加模式 ('a' )或让你能够读取和写入文件的模式('r+' )；如果你要写入的文件不存在，函数open() 将自动创建它；然而，以写入('w' )模式打开文件时千万要小心，因为如果指定的文件已经存在，Python将在返回文件对象前清空该文件。
b. 写入多行 //需要加换行；file_object.write("I love programming.\n")
c. 附加到文件
with open(filename, 'a') as file_object: file_object.write("I also love finding meaning in large datasets.\n")
4、文件操作补充
1）pickle序列化
序列化反序列化原因：对象本质上是‘存储数据的内存块’，当需要将‘内存块的数据’保存到硬盘上，或者通过网络传到其他计算机上，这时候需要“序列化和反序列化”。
序列化：将对象转换成‘串行化’数据形式，存储到硬盘或通过网络传输到其他地方。
反序列化：相反的过程，将读取到的‘串行化数据’转化成对象。
pickle.dump(obj,file) //obj就是要被序列化的对象，file指的是存储的文件；
pickle.load(file) //从file读物数据，反序列化成对象；
import pickle file='/Users/姓名/min-py/filedemo03' with open(file,'wb') as f: a1='世界' a2=[20,30,40] a3=234 pickle.dump(a1,f) pickle.dump(a2,f) pickle.dump(a3,f) with open(file,'rb') as f: a1=pickle.load(f) a2=pickle.load(f) a3=pickle.load(f) print(a1,a2,a3) 输出： 世界 [20, 30, 40] 234
2）CSV文件的操作
csv(comma Separated Values)是逗号分隔符文本格式，常用于数据交换/excel文件和数据库数据的导入和导出。csv中值没有类型，所有值都是字符串。
import csv with open('/Users/姓名/min-py/csvdemo.csv') as f: f_csv=csv.reader(f) //创建csv对象，它是一个包含所有数据的列表，每一行为一个元素 headers=next(f_csv) //获得列表对象，包含标题行的信息(第一行) print(headers) for row in f_csv: //循环打印各行内容 print(row) 输出： ['姓名', '年龄', '工作', '薪水'] ['张三', '18', '老师', '50000'] csvdemo.csv内容： 姓名,年龄,工作,薪水 张三,18,老师,50000
import csv headers=['工号','姓名','月薪'] rows=[('1001','张三','50000'),('1002','李四','60000')] with open('/Users/姓名/min-py/csvdemo01.csv','w+') as f: f_csv=csv.write(f) f_csv.writerow(headers) //写入一行标题 f_csv.writerows(rows) //写入多行数据 输出： 工号,姓名,月薪 1001,张三,50000 1002,李四,60000
3）os 和os.path模块
os模块可以帮助我们直接对操作系统进行操作。可以直接调用操作系统的可执行文件/命令，直接操作文件/目录等，是系统运维的核心基础。linux的命令行操作更容易，可以通过os.system更容易的调用相关的命令行。
os.system可以直接调用系统的命令。
import os os.system('pip') 结果： 显示pip软件的help(),之后通过exit()。如果是python3，则会调用python3的进程。mac/linux没有os.startfile,可用os.system代替。
>>> import os >>> os.system('ping www.baidu.com') PING www.a.shifen.com (110.242.68.3): 56 data bytes 64 bytes from 110.242.68.3: icmp_seq=0 ttl=51 time=28.213 ms 64 bytes from 110.242.68.3: icmp_seq=1 ttl=51 time=45.092 ms ctrl+z退出
os和os.path下 文件和目录操作：
os下 文件操作：
|
方法名 |
描述 |
|
remove(path) |
删除指定的文件 |
|
rename(src,dest) |
重命名文件或目录 |
|
start(path) |
返回文件的所有属性,win命令。如果是linux或mac，可进到相应目录，然后o s.system('ls -all') |
|
listdir(path) |
返回path目录下的文件和目录列表 |
>>> import os >>> os.rename('text1.txt','one1/text.txt') >>> os.listdir('one1') ['text.txt'] >>> os.remove('one1/text.txt') >>> os.listdir('one1') //返回列表 []
os下 目录操作：
| 方法名 |
描述 |
|
mkdir(path) |
创建目录 |
|
makedirs(path1/path2/path3/...) |
创建多级目录 |
|
rmdir(path) |
删除目录 |
|
removedirs(path1/path2/path3/...) |
删除多级目录 |
|
getcwd() |
返回当前目录 |
|
chdir(path) |
把path设为当前工作目录 |
|
walk() |
遍历目录树 |
|
sep |
当前操作系统所使用的路径分隔符 |
>>> import os >>> os.mkdir('one') >>> os.makedirs('one/one1/one2') >>> os.removedirs('one/one1/one2') >>> os.getcwd() '/Users/姓名' >>> os.mkdir('one') >>> os.chdir('one') >>> os.getcwd <built-in function getcwd> >>> os.getcwd() '/Users/姓名/one' >>> os.mkdir('one1') >>> os.listdir() ['one1'] >>> os.sep //win为\ linux或mac为/ '/' >>> repr(os.linesep) "'\\n'" >>> os.linesep '\n' >>> os.stat('/Users/姓名/one') //返回path指定的路径信息。 os.stat_result(st_mode=16877, st_ino=16112016, st_dev=16777220, st_nlink=3, st_uid=501, st_gid=20, st_size=96, st_atime=1662872562, st_mtime=1662868835, st_ctime=1662868835) >>>os.walk('/Users/姓名/one')
<generator object walk at 0x7fe76b399390>
os.path模块提供了目录相关(路径判断/路径划分/路径连接/文件夹遍历)的操作
| 方法 | 描述 |
| isabs(path) | 判断path是否绝对路径 |
| isdir(path) | 判断path是否为目录（当前目录下） |
| isfile(path) | 判断path是否为文件（当前目录下） |
| exists(path) | 判断制定路径下的文件/目录是否存在（当前目录下） |
| getsize(filename) | 返回文件的大小 |
| abspath(path) | 返回绝对路径 |
| dirname(path) | 返回目录的路径(path至少包括当前目录) |
| getatime(filename) | 返回文件的最后访问时间 |
| getmtime(filename) | 返回文件的最后修改时间 |
| walk(top,func,arg) | 递归方式遍历目录 |
| join(path,*paths) | 连接多个path |
| split(path) | 对路径进行分割，以列表形式返回 |
| splitext(path) | 从路径中分割文件的扩展名 |
>>> os.path.split('/Users/one') //返回元组：目录，文件 ('/Users', 'one') >>> os.path.splitext('/Users/one/text.py') //返回元组：路径，扩展名 ('/Users/one/text', '.py') >>> os.path.join('aa','bb','cc') //返回路径 'aa/bb/cc'
列出指定目录下所有.py文件，并输出文件名：
import os import os.path path=os.getcwd() file_list=os.listdir(path) '''方法1''' for filename in file_list: pos=filename.rfind('.') if filename[pos+1:]=='py': print(filename,end='\t') '''方法2''' file_list2=[filename for filename in os.listdir(path) if filename.endswith('.py')] for filename in file_list2: print(filename,end='\t')
walk()递归遍历所有文件和目录：
os.walk()方法返回一个3个元素的元组，(dirpath,dirnames,filenames),(指定目录的路径/目录下的所有文件夹/目录下的所有文件)。
使用walk()遍历所有文件和目录：
import os all_files=[] path=os.getcwd() list_files=os.walk(path) for dirpath,dirnames,filenames in list_files: for dir in dirnames: //dirnames是该目录下的所有文件夹地址 all_files.append(os.path.join(dirpath,dir)) //此时的dirpath为当前目录 for name in filenames: //filenames是该目录及所有子目录下的所有文件名 all_files.append(os.path.join(dirpath,name)) //此时的dirpath包括所有子目录 for file in all_files: print(file)
4）shutil模块(拷贝和压缩)
是python标准库提供，只有用来做文件和文件夹的拷贝、移动、删除等；还可以做文件、文件夹的压缩、解压缩操作。
shutil.make_archive(base_name, format[, root_dir[, base_dir, verbose, dry_run, owner, group, logger])
base_name：压缩包的文件名，也可以是压缩包的路径；只是文件名时，则保存至当前目录下，否则保存至指定路径。
format：压缩包种类，“zip”, “tar”, “bztar”，“gztar”。
base_dir：指定要压缩文件的路径，可以指定路径下的文件名，也可以指定路径。
root_dir：指定要压缩的路径根目录（默认当前目录），只能指定路径，优先级低于base_dir。
>>> shutil.make_archive('one1','zip','one/') '/Users/姓名/min-py/one1.zip' >>> shutil.make_archive('one1/o','zip','one') '/Users/姓名/min-py/one1/o.zip'
class zipfile.ZipFile(file[, mode[, compression[, allowZip64]]])
创建一个zipfile对象；mode默认值为'r'，表示读已经存在的zip文件，'w'表示新建一个zip文档或覆盖一个已经存在的zip文档，'a'表示将数据附加到一个现存的zip文档中；compression表示在写zip文档时使用的压缩方法，它的值可以是zipfile. ZIP_STORED 或zipfile. ZIP_DEFLATED；如果要操作的zip文件大小超过2G，应该将allowZip64设置为True；
>>> z=zipfile.ZipFile('a.zip','w') >>> z.write('one1/demo08.py') >>> z.close()
ZipFile.extractall([path[, members[, pwd]]])
解压zip文档中的所有文件到当前目录。参数members的默认值为zip文档内的所有文件名称列表，也可以自己设置，选择要解压的文件名称。
>>> z2=zipfile.ZipFile('a.zip','r') >>> z2.extractall('one1') //解压到one1目录下。 >>> z2.close()
【例】实现递归的拷贝文件夹内容(使用shutil模块)
>>> shutil.copytree('one','one1',ignore=shutil.ignore_patterns('*.html','*.htm')) //只有one1文件夹不存在时可用。忽略html和htm 'one1'
5. 异常
Python使用被称为异常的特殊对象来管理程序执行期间发生的错误。每当发生让Python不知所措的错误时，它都会创建一个异常对象。如果你编写了处理该异常的代码，程序将继续运行;如果你未对异常进行处理，程序将停止，并显示一个traceback，其中包含有关异常的报告。try-except 代码块处理的；
1、实现结构
1）.使用try-except代码块和else代码块：如果try中没有抛出异常，则执行else代码块；如果抛出异常，则执行except，不执行else。
try: answer = int(first_number) / int(second_number) except ZeroDivisionError: print("You can't divide by zero!") else: print(answer)
try 被监控的可能引发异常的语句块 except Exception1: 处理Exception1的语句块 except Exception2: 处理Exception2的语句块 ... except BaseException: 处理可能被遗漏的语句块
3）.try...except...finally：finally无论是否发生异常都会执行，通常用来释放try块中申请的资源。
4）.由于return有两种作用：结束方法运行/返回值。所以一般不把return放到异常处理结构中，而是放到方法最后（else/finally之后）。
5）.常见异常的解决
SyntaxError：语法错误
>>> int a=3 File "<stdin>", line 1 int a=3 ^ SyntaxError: invalid syntax
NameError：尝试申请一个没有申请的变量
>>> print(m) Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name 'm' is not defined
ZeroDivisionError：除数为零错误
>>> 3/0 Traceback (most recent call last): File "<stdin>", line 1, in <module> ZeroDivisionError: division by zero
ValueError：数值错误
>>> float('abc') Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: could not convert string to float: 'abc'
TypeError：类型错误
>>> 123+'abc' Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: unsupported operand type(s) for +: 'int' and 'str'
AttributeError：访问对象不存在的属性
>>> a=100 >>> a.sayh() Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: 'int' object has no attribute 'sayh'
IndexError：索引越界异常
>>> a=[1,2,3] >>> a[4] Traceback (most recent call last): File "<stdin>", line 1, in <module> IndexError: list index out of range
keyError：字典的关键字不存在
>>> a={'a':12,'b':18}
>>> a['c']
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'c'
常见异常类型汇总：
| 异常名字 | 说明 |
| ArithmeticError | 所有数值计算错误的基类 |
| AssertionError | 断言语句失败 |
| AttributeError | 对象没有这个属性 |
| BaseException | 所有异类的基类 |
| DeprecationWarning | 关于被弃用的特性的警告 |
|
EnvironmentError |
操作系统错误的基类 |
| EOFError | 没有内建输入，到达EOF标记 |
| Exception | 常规错误的基类 |
| FloatingPointError | 浮点计算错误 |
| FutureWarning | 关于构造将来语义会有改变的警告 |
| GeneratorExit | 生成器(generator)发生异常来通知退出 |
| ImportError | 导入模块/对象失败 |
| IndentationError | 缩进错误 |
| IndexError | 序列中没有此索引(index) |
| IOError | 输入/输出操作失败 |
| KeyboardInterrupt | 用户中断执行(通常是输入^C) |
| KeyError | 映射中没有这个键 |
| LookupError | 无效数据查询的基类 |
| MemoryError | 内存溢出错误(对于Python解释器不是致命的) |
| NameError | 未声明/初始化对象(没有属性) |
| NotImplementedError | 尚未实现的方法 |
| OSError | 操作系统错误 |
| OverflowError | 数值运算超出最大限制 |
| OverflowWarning | 旧的关于自动提升为长整型(long)的警告 |
| PendingDeprecationWarning | 关于特性将会被废弃的警告 |
| ReferenceError | 弱引用(weak reference)视图访问已经被垃圾回收了的对象 |
| RuntimeError | 一般的运行时错误 |
| RuntimeWarning | 可疑的运行时行为(runtime behavior)的警告 |
| StandardError | 所有的内建标准异常的基类 |
| StopIteration | 迭代器没有更多的值 |
| SyntaxError | python语法错误 |
| SyntaxWarning | 可疑的语法的警告 |
| SystemError | 一般的解释器系统错误 |
| SystemExit | 解释器请求退出 |
| TabError | Tab和空格混用 |
| TypeError | 对类型无效的操作 |
| UnboundLocalError | 访问未初始化的本地变量 |
| UnicodeDecodeError | Unicode解码时的错误 |
| UnicodeEncodeError | Unicode编码时的错误 |
| UnicodeError | Unicode相关的错误 |
| UnicodeTranslateError | Unicode转换时错误 |
| UserWarning | 用户代码生成的警告 |
| ValueError | 传入无效的参数 |
| Warning | 警告的基类 |
| WindowsError | 系统调用失败 |
| ZeroDivisionError | 除(或取模)零（所有数据类型) |
6）with上下文管理
finally一般用做释放代码资源。可以通过with上下文管理，更方便的实现释放资源的操作。
with context_expr [as var]:
语句块
with上下文管理可以自动管理资源，在with代码块执行完毕后自动还原进入该代码之前的现场或上下文，不论何种原因跳出with块，不论是否有异常，总能保证资源正常释放。在文件操作/网络通信相关的场合非常常用。
7）traceback模块
使用traceback模块打印异常信息
>>> import traceback >>> try: ... print('step1') ... num=1/0 ... except: ... traceback.print_exc() ... step1 Traceback (most recent call last): File "<stdin>", line 3, in <module> ZeroDivisionError: division by zero
使用traceback将异常信息写入日志文件
>>> import traceback >>> try: ... print('step1') ... num=1/0 ... except: ... with open('one.txt','a') as f: ... traceback.print_exc(file=f) ... step1 >>> exit() localhost:min-py 姓名$ cat one.txt Traceback (most recent call last): File "<stdin>", line 3, in <module> ZeroDivisionError: division by zero
8）自定义异常类
通常继承Exception或其子类即可，命名一般以Error/Exception为后缀。
自定义异常由raise语句主动抛出。
class AgeError(Exception): def __init__(self,errorInfo): Exception.__init__(self) self.errorInfo=errorInfo def __str__(self): return str(self.errorInfo)+',年龄错误，应该在1-150之间' if __name__=='__main__': age=int(input('input one age:')) if age<1 or age>150: raise AgeError(age) else: print('the age:',age)
输出：
input one age:159 Traceback (most recent call last): File "/Users/姓名/eclipse-workspace/pydemo01/demo01/demo01/exceptiondemo01.py", line 10, in <module> raise AgeError(age) __main__.AgeError: 159,年龄错误，应该在1-150之间
10）开发环境的调试
进行调试的核心是设置断点。
step1:设置断点方法：最前面行号处双击，再双击取消断点。或者是debug视图下，run-toggle breakpoint
step2:进入调试视图：eclipse里进入debug视图。通过run-debug进入。
step3:运行：run-debug或者蜘蛛图标选择文件。
step4:结果检查：右侧variables里是所有参数，属性/类等。下框中console里为运行到断点处的结果。
2、异常类
python中内建异常类的继承层次。
a.例
while True: try: x=int(input('请输入一个数字：')) print('您输入的数字是：',x) if x==88: print('退出程序') break except: print('异常，输入的不是数字！')
b.处理FileNotFoundError异常
filename = 'alice.txt' try: with open(filename) as f_obj: contents = f_obj.read() except FileNotFoundError: msg = "Sorry, the file " + filename + " does not exist." print(msg)
c. 失败时一声不吭
except FileNotFoundError: pass else:
6.存储数据
模块json 让你能够将简单的Python数据结构转储到文件中，并在程序再次运行时加载该文件中的数据。你还可以使用json 在Python程序之间分享数据。
a. 使用json.dump()和json.load()保存和读取用户生成的数据
import json numbers = [2, 3, 5, 7, 11, 13] filename = 'numbers.json' with open(filename, 'w') as f_obj: json.dump(numbers, f_obj) //参数：要存储的数据，用于存储数据的文件对象； 使用json.load()将这个列表读取到内存中： with open(filename) as f_obj: numbers=json.load(f_obj) // print(numbers)
十. 测试代码
1. 单元测试和测试用例：Python标准库中的模块unittest 提供了代码测试工具；
要为函数编写测试用例，可先导入模块unittest 以及要测试的函数，再创建一个继承unittest.TestCase 的类，并编写一系列方法对函数行为的不同方面进行测试。
name_function.py文件： def get_formatted_name(first, last): """Generate a neatly formatted full name.""" full_name = first + ' ' + last return full_name.title() names.py文件： from name_function import get_formatted_name print("Enter 'q' at any time to quit.") while True: first = input("\nPlease give me a first name: ") if first == 'q': break last = input("Please give me a last name: ") if last == 'q': break formatted_name = get_formatted_name(first, last) print("\tNeatly formatted name: " + formatted_name + '.') 测试例test_name_function.py import unittest from name_function import get_formatted_name class NamesTestCase(unittest.TestCase): """测试name_function.py""" def test_first_last_name(self): """能够正确地处理像Janis Joplin这样的姓名吗?""" formatted_name = get_formatted_name('janis', 'joplin') self.assertEqual(formatted_name, 'Janis Joplin') //使用了unittest 类最有用的功能之一:一个断言 方法。断言方法用来核实得到的结果是否与期望的结果一致。 unittest.main() //代码行unittest.main() 让Python运行这个文件中的测试。 输出如下：（第一行句点表明又一个测试通过了，接下来的一行指出Python运行了一个测试，用时不到0.001秒。最后的OK 表明该测试用例中的所有单元测试都通过）
----------------------------------------------------------------------
Ran 1 test in 0.000s OK
