Python学习笔记
1.起步
print("Hello world")
-
输入：
# 单个输入 b=input() # input()接受的是string类型，需要使用数据类型转化 # 多个输入,使用分割字符串的方式 b=map(int,input().split(' ')) -
输出：
# 输出 print(1,2,34) # 当遇到,是会空格显示
2.变量和简单的数据类型
1.变量
-
声明：
a="heloo"
2.字符串
- 用单引号和双引号都可
a="hhhh";
a.title(); #首字母大写
a.upper() #全部大写
a.lowper() #全部小写
b=a+"ooo" #字符串合并用+
c="mm "
c.rstrip() #删除空白
d=" dad"
d.lstrip() #删除前面的空白
d.strip() #删除后面的空白
# 但删除并不是真正的删除
d=" hjhsad"
print(d.rstirp); #显示hjhsad
print(d) #显示 hjsad
3.数字
-
python支持正常的加减乘除
1*2 # 2 1/2 # 1.5 3+2 # 5 3-2 # 1 -
要注意不同的浮点数相加可能不会得到正确答案
0.1+0.2 # 0.30000000000000004 -
使用str()避免类型错误
month=1 day=2 print("生日是"+str(month)+"月"+str(day)+"日") #生日是1月2日
4. 注释
-
单行注释用 #
#这是一个单行注释 -
多行注释用三个单引号或双引号
''' 这是一个多行注释 ''' """ 这是一个多行注释 """
3.列表
1.声明
a=["hahdh","sdas","red",120]
print(a) #['hahdh', 'sdas', 'red', 120]
2. 访问列表元素
a=["hahdh","sdas","red",120]
print(a[0].upper()) #HAHDH
print(a[-1]) # 120 a[-1]是最后一个元素
3.修改，添加和删除元素
name=["lihua","xiaoming","xiaogou","xiaohong"]
# 插入元素
name.append("xiaohu") #在末尾添加元素 "xiaohu"
name.insert(4,"hhh") #4是下标，在name[4]的地方添加元素"hhh"原来的元素往后移
# 删除元素
del name[3] # 删除name[3]所在的元素
a=name.pop(3) #删除name[3]所在元素的同时，将该删除元素赋给a
name.remove("lihua") '''删除值为"lihua"的元素，但他只删除第一个，如果后面还有值为"lihua"的元素就需要用循环来做'''
4.组织列表
1. 排序
-
永久性排序,使用sort()
a=['a','c','b','f','e'] print(a) #['a', 'c', 'b', 'f', 'e'] a.sort() #使用sort是顺序排列从a-z print(a) #['a', 'b', 'c', 'e', 'f'] b=['a','c','b','f','e'] print(b) #['a', 'c', 'b', 'f', 'e'] b.sort(reverse=True) #使用sort(reverse=True)是逆序排列 从z-a print(b) #['f', 'e', 'c', 'b', 'a'] -
临时性排序，sorted()
a=['a','c','b','f','e'] print(sorted(a)) #['a', 'b', 'c', 'e', 'f'] 顺序 print(a) #['a', 'c', 'b', 'f', 'e'] print(sorted(a,reverse=True)) #['f', 'e', 'c', 'b', 'a'] 逆序 print(a) #['a', 'c', 'b', 'f', 'e'] -
要反转列表元素的排列顺序，可使用方法reverse() 。
a=['a','c','b','f','e'] print(a) #['a', 'c', 'b', 'f', 'e'] a.reverse() #反转列表排列顺序 print(a) #['e', 'f', 'b', 'c', 'a']- 注意，reverse() 不是指按与字母顺序相反的顺序排列列表元素，而只 是反转列表元素的排列顺序
- 方法reverse() 永久性地修改列表元素的排列顺序，但可随时恢复到原 来的排列顺序，为此只需对列表再次调用reverse() 即可
2.确定列表长度
-
使用函数len() 可快速获悉列表的长度
a=['a','c','b','f','e'] c=len(a) print(c) #5
5.操作列表
1.遍历整个列表
-
for循环
for+变量+in +遍历结构： 语句块1 else： 语句2 -
遍历列表
a=['a','c','b','f','e'] for i in a: print(i)
2.创建数字列表
-
使用函数range()
# 打印数字 for i in range(1,5): print(i) # i 实际会显示 1-4- 函数range() 让Python从你指定的第一个值开 始数，并在到达你指定的第二个值后停止，因此输出不包含第二个值
-
使用函数range()创建数字列表
a=list(range(1,5)) print(a) #[1, 2, 3, 4]-
使用函数range() 时，还可指定步长
# 打印十以内的偶数 a=list(range(0,10,2)) # 2是步长 print(a) #[0, 2, 4, 6, 8] -
打印1-10的平方
a=[] #创建空列表 for i in range(1,11): a.append(i**2) print(a) #[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
-
-
对数字列表执行简单的统计计算
a=list(range(1,11)) print(max(a)) #最大值 print(min(a)) #最小值 print(sum(a)) #求和 -
列表解析
# 用列表解析打印1-10的平方 a=[i**2 for i in range(1,11)]
3.使用列表的一部分
-
切片：
c=list(rang(1,10)) print(c[0:4]) #[1, 2, 3, 4] print(c[:5]) #[1, 2, 3, 4, 5] print(c[2:]) #[3, 4, 5, 6, 7, 8, 9] print(c[:]) #[1, 2, 3, 4, 5, 6, 7, 8, 9] print(c[-3:]) #[7,8,9] 打印后面三个元素- 要创建切片，可指定要使用的第一个元素和最后一个元素的索引（Python在到达你指定的第二个索引前面的元素后停止）
- 如果你没有指定第一个索引，Python将自动从列表开头开始
- 如果你没有指定第二个索引，Python将要让切片终止于列表末尾，且最后一个元素打印
- 如果两个索引都省略，则打印全列表
- 负数索引返回离列表末尾相应距离的元素，因此 你可以输出列表末尾的任何切片
-
遍历切片
# 获取列表的最大值 c=list(range(0,11)) c.sort(reverse=True) print(c[0:3]) for a in c[0:3]: print(a) -
复制列表
c=list(range(1,11)) d=c[:] print(c) #[1, 2, 3, 4, 5, 6, 7, 8, 9, 10] print(d) #[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
4.例题
-
打印消息“The first three items in the list are:”，再使用切片来打 印列表的前三个元素
s='The first three items in the list are:' d=[] b=0 for a in range(len(s)): if s[a]==' ': d.append(s[b:a]) b=a print(d[0:3])
5.元组
定义：在python中将不能修改的值称为不可变的，而不可变的列表成为元组
-
声明：
a=(111,222) -
遍历元组
for i in a: print(i) -
修改元组的值
a=(111,222) a=(111,333)- 无法单独修改元组元素
- 但可以重新定义该元组
-
小练习-自助餐
# 自助餐小练习 a=('西红柿炒鸡蛋','红烧茄子','兰州拉面','红烧肉','鱼香肉丝') # 显示当前菜单 print('当前菜单为：') for i in a: print("\t\t"+i) # 修改菜单 a=('可乐鸡翅','红烧茄子','蛋炒饭','红烧肉','鱼香肉丝') # 显示修改的菜单 print('修改后的菜单为：') for i in a: print("\t\t\t"+i)
6.设置代码格式
- 缩进用四个空格
- 每行的行长不超过80个字符
- 合理使用空格组织程序
6.列表推导式
-
意义：
旧列表推导出所列表
-
格式：
""" [表达式 for 变量 in 旧列表] 或者 [ 表达式 for 变量 in 旧列表 if 条件] """ -
例子：
names=['tom','lily','abc','jack','steven','bob','ha'] # 过滤掉长度小于或者等于3的人名 result=[name.capitalize() for name in names if len(name)>3] print(result) # 求1~100之间能被3和5整除的数 newlist=[i for i in range(1,101) if i %3 ==0 and i%5==0] print(newlist) # 推导式的多重循环 newlist2=[(x,y) for x in range(5) if x%2==0 for y in range(10) if y%2!=0] print(newlist2) # 获取多个列表的最后一个列表 list1=[[1,2,3],[4,5,6],[7,8,9],[1,3,5]] newlist3=[i[-1] for i in list1] print(newlist3) # 推导式的if-else结构 """ 例题：工资大于等于5000的加200，小于5000的加500 dict1={'name':'tom','salary':5000} dict2={'name':'lucy','salary':8000} dict3={'name':'jack','salary':4500} dict4={'name':'lily','salary':3000} """ dict1={'name':'tom','salary':5000} dict2={'name':'lucy','salary':8000} dict3={'name':'jack','salary':4500} dict4={'name':'lily','salary':3000} list2=[dict1,dict2,dict3,dict4] newlist4=[employee['salary']+200 if employee['salary']>=5000 else employee['salary'] +500 for employee in list2] print(newlist4) -
延伸：
-
集合推导式：
""" 格式：{表达式 for 变量 in 旧列表} 或者 { 表达式 for 变量 in 旧列表 if 条件} 类似于列表推导式，在列表推导式的基础上添加了一个去除重复项的功能 """ # 例子： list3=[1,2,3,2,3,5,6,1] set1={x for x in list3} print(set1) -
字典推导式：
-
4.字典
1. 声明
alien_0={
'color':'red',
'points':5
}
2.使用字典
在python中，字典用放在花括号{}中的一系列的键值对表示
-
访问字典中的值
print(alien_0['color']) -
添加键值对
alien_0['x_position']=0 alien_0['y_position']=25 -
创建空字典
alien_1={} alien_1['color']='red' alien_1['points']=5 -
修改字典中的值
alien_1['color']='green' -
删除键值对
# 使用del删除 del alien_1['color']
3. 遍历字典
-
遍历字典的所有的键值对
for k,v in alien_0.items(): print(k+'=>'+str(v)) -
遍历字典的所有键
for key in alien_0.keys(): print(key) -
遍历字典的所有值
for value in alien_0.values(): print(value) # 获得非重复的所有值 for value in set(alien_0.values()): print(value)
4.嵌套
-
列表嵌套字典(字典列表)
alien_0={ 'color':'green', 'points':5 } alien_1={ 'color':'green', 'points':5 } aliens=[alien_0,alien_1] for alien in aliens: print(alien) -
在字典中储存列表
aliens={ 'alien_0':['green',5], 'alien_1':['red',10] } for alien in aliens.items(): print(alien) -
字典的嵌套
name={ 'lihua':{ 'fast_name':'hua', 'last_name':'li' }, 'xiaoming':{ 'fast_name':'xiao', 'last_name':'ming' } }
5流程控制和函数
流程控制
-
选择结构
if a == 0: print('I`m 0') elif a == 1: print('I`m 1') else: print('I`am not 1 or 0') -
for循环结构
a=['1',5,6] for c in a: print(c) """ for···in 用来迭代序列类型或字典 """ -
while循环
while i>0: print(i) i-=1 else: print(0) """ while 也存在else分支。值得注意的时while循环正常结束或者使用continue时，会执行else。但当使用break结束时，则else分支不执行 """
函数
-
定义：
def people (name,age): """ 语句 """ -
函数的参数：
必备参数，关键词参数，默认参数，不定长参数
def people (name,age,height=1.8,*like，**family): """ 必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。 关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。例如 people(....age=0....) 调用函数时，默认参数的值如果没有传入，则被认为是默认值。例如height 不定长参数：你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数。加了星号（*）的变量名会存放所有未命名的变量参数。例如参数like 一个*的参数类是元组，两个*的参数类型是字典例如people('farther'='lihua') """ -
函数的调用和返回
# 调用 函数名（参数） people（） # 返回值 用return返回 -
lambda函数
a=lambda x,y:x*y print(a(1,2))
6.类和对象
-
类的定义：
class ClassName(father class name):# ClassName表示为自定义类名，statement是类成员表达式，既可以为属性也可以为方法 # father class name shijicheng 是继承的父类名 -
类的实例化：
直接调用类名方法创建
-
类的方法：
- 类方法的第一个参数必须是self
- 类方法里面调用类本身的属性和方法都必须在属性和方法前面加self
- 类方法的名字开头可以为下划线或者字母，不可以为其他字符。如果类方法名字的开头为两个下划线并且结尾不为两个下划线，就是私有方法。私有方法就是只能为类的其他方法调用的方法
-
类的特殊方法
-
类的初始化函数和析构函数：
-
__init__:在类被实例化为对象是调用的函数
-
__del_:在对象被del操作符从内存中卸载时所调用的函数
-
-
类的操作符方法：
操作符方法就是让类支持加减乘除等各种运算的方法
-
-
类的继承：
定义：继承又称泛化，是使一个类获得另一个类所有属性和方法的能力，被继承的类称为父类或基类
-
继承语法：
class 类名 （父类） 单一继承：一个子类只有一个父类
多重继承：一个子类有好几个父类
-
重载：
对于单一继承来说，自定义的方法B会覆盖继承的方法B
对于多重继承来说，重载的顺序是从右往左的，在同名的方法中保留的是第一父类的方法
-
类的关联和依赖
-
依赖
在代码上为依赖的类的某个方法以被依赖的类作为参数
class Person(object): def gobyboat(self,boat): boat.overriver() class Boat(object): def overriver(self): pass a=Person() b=Boat() a.gobyboat(b) -
关联
一个类作为另一个类的成员属性
class student(object): name="lihua" age=18 class school: def __init__(self): self.students=student()
-
-
类的聚合和组合
区别：聚合和组合都是关联的特例，它们的区别在于聚合的两个对象是可分离的，他们有各自的生命周期组合往往表现为唇亡齿寒
-
例子：
class a(object): pass class b(object): pass class c(object): A=a() B=b() class d(object): B=b() # a和c是组合，b和c则是聚合
7.异常捕获和抛出
-
异常处理
-
Traceback：由信息头，出错位置，异常信息三部分组成
- 信息头：提醒使用者这是个Traceback信息
- 出错位置：一般异常信息的位置在最下面
- 异常信息：显示异常的类型
-
捕获异常：
用 try....except语法
try: statements 1 except A: statements 2 """ 语法规则：先运行statements 1,如果没有异常则直接运行之后的代码。若存在异常，则把异常类型与类型A进行比较，结果一致就执行statement2 """ -
多重异常处理：
try: statements 1 except A,B: statements 2 except C,D: statements 3 except: statements 4 -
except衔接else和finally的使用：
try: statements 1 except A: statements 2 else: statements 3 finally: statements 4 """ else的作用是：当statements 1发生异常时，则else的statements 3不会运行 finally的作用是：无论statements 1是否发生异常，statements 4都会运行 """ -
获得异常参数
try: statements 1 except A as e: statements 2 # e为异常的参数
-
-
常见的异常类型：
- InderError:列表元素不存在
- KeyError：访问字典中不存在的key
- IOError：一个不存在的文件或者其他I/O错误
- NameError：一个不存在的变量名
- TypeError：一个类型使用一个不支持的操作
- ZeroDivisionError：被除数为0
-
抛出异常：
-
语法：
# 1 raise后接实例化对象 raise NameEroor("aa") # 2 raise后接异常名 raise NameError # 3 raise后接异常对象和类的初始化参数来实例化对象 raise NameError("aa")
-
-
自定义异常类型：
class a(Exception): def __init__(self,value): self.value=value def __str__(self): return repr(self.value)
8.模块和包
-
模块：单个py文件
# mian.py的代码如下： def sayHello(): print('hello')# 第一种导入方法 import main as a a.sayHello() # 第二种导入方法 from main import sayHello sayHello() # 第三种导入方法 from main import (sayHello) sayHello() # 第四种导入方法（将所有的成员导入当前模块） from main import * sayHello() -
包：一组模组的集合,即存放若干个python文件的目录
- 创建people包：
包.png
-
在
__init__.py导入所有模组import people.sayHello import people.sayAge __all__=['sayHello','sayAge'] -
调用包
import people people.sayHello.sayHello() people.sayAge.sayAge() -
包的导入：
前三种导入方法与模组的导入类似，但第四种的导入存在不同
不同：
__init__.py代码：import people.sayHello import people.sayAge __all__=['sayHello','sayAge'] """ 若设置了一个__all__列表，当执行form people import *时，他会根据__all__列表的模组名进行导入 若没有设置，则form people import *不会导入任何子模组 """
9.元类和新型类
1.元类：
-
使用type创建类：
""" type(类名，继承的父类，命名空间（属性，方法）) """ #创建类 def sell(self): print(self.hobby) # hobby="hello" Hello=type('Hello',(),{'sell':sell, 'hobby':"hello"}) #实例化类 hello=Hello() hello.sell() 元类概念：类的类，类就是元类的实例
-
元类的创建：
# 元类的创建 class change(type): def __new__(cls, name, bases, dict): def test_msg(self): print("this test_msg is changed") dict["test_msg"] = test_msg return type.__new__(cls, name, bases, dict) # 元类的实例化 class example(metaclass=change): def __init__(self): print("this is test_msg!") def test_msg(self): print("this is test_msg")
2.新型类
定义：继承与object的类
-
静态方法,类方法和普通方法的区别
class A(object): numbers=18 @staticmethod def b(): print("hello ,I`m static b") @classmethod def c(cls): print("hello ,I`m classmethod c "+str(cls.numbers)) def d(self): print("hello ,I`m d")
| 实例方法（普通方法） | 类方法 | 静态方法 | |
|---|---|---|---|
| 实例调用a=A() | a.d() 可以调用 | a.c() | a.b() |
| 类调用A | 不可以调用 | A.c() | A.b() |
-
新型类的特定方法
-
__new__和___init__方法-
___new___方法：当一个类实例化时，首先调用
__new__方法来返回该类的实例 -
__init__方法：当调用
__new__方法后，然后调用```init``方法来初始化这个实例 -
例如
class A(object): def __new__(cls,name,age): cls.name=name cls.age=age return object.__new__(cls) def __init__(self,name,age): print("我被创建了！！！") a=A("lihua",18) print(a.name) print(a.age)
-
-
__GETATTRUBUTE__方法- 新型类调用属性和方法时，都会先调用该方法
class a(object): def test(self): print("this is test") def __getattribute__(self, name): print("this is to"+name) return object.__getattribute__(self,name) A=a() A.test() -
新型类的特定属性
内建property类用来绑定类实例的方法，并将其返回值绑定为一个类属性
语法如下：
attrib=property(fget=None,fset=None,fdel=None,doc=None) """ 假设设在一个类C中如上定义了 attrib属性(通过 property来创建的)，而x是C的一个实例，那么当引用 x attrib时， Python会调用fget0方法取值：当为x.attrib=value时， Python会调用 fset()方法，并且 value值作为fsetO方法的参数：当执行 del x.attrib时，Python调用 fdel()方法，传过去的名为doc的参数即为该属性的文档字符串。如果不定义fset()和 fuel()方法，那么 attrib将是一个只读属性 """例子：
class Rectangle(object): def __init__(self,height,width): self.width=width self.height=height def getArea(self): return self.width * self.height area=property(fget=getArea,doc="area of the rectangle") rectangle=Rectangle(5,6) print(rectangle.area) -
类的super()方法
-
单个继承：
主要是调用父类的方法的
多个继承：
-
-
10.迭代器，生成器和修饰器
1.迭代器
-
定义：
迭代器是一个可以记住遍历位置的对象。迭代器对象从集合的第一个元素开始访问，知道所有元素被访问结束，迭代器只能往前不会后退。
-
内置方法：
- 方法iter()：返回对象本身，是for语句使用迭代器的要求
- 方法next()：用于返回容器中下一个元素或数据，当使用完容器中的数据时会引发StopIteration异常
-
创建并使用迭代器
""" 迭代类的属性,该类为2的n次方 """ class Use: def __init__(self, x=2, max=50): self.mull, self.x = x, x self.max = max def __iter__(self): return self def __next__(self): if self.x and self.x != 1: self.mull *= self.x if self.mull <= self.max: return self.mull else: raise StopIteration else: raise StopIteration if __name__=='__main__': use=Use() for x in use: print(x)注意：在Python程序中使用迭代器类时，一定要在某个条件下心法StopIteration错误。这样可以结束遍历，否则会陷入死循环
-
使用内置迭代器协议方法iter()
""" 有两种使用iter()的方法 第一种是：iter(iterable) 第二种是：iter(callable,sentinel) 对上述两种使用方法的具体说明如下所示 第一种只有一个参数 iterable,要求参数为可送代的类型，也可以使用各种序列类型 第二种：具有两个参数，第一个参数 callable表示可调用类型，一般为函数：第二个参数 sentinel是一个标记，当第一个参数（函数）调用返回值等于第二个参数的值时，送代或遍历会马上停止。 """ """ 迭代序列 """ if __name__=='__main__': # 第一种用法 a=[1,2,3] it=iter(a) for x in it: print(x) # 第二种用法 class Counter: def __init__(self,x=0): self.x=x counter=Counter() def user_iter(): counter.x+=2 return counter.x for i in iter(user_iter,12): print('当前遍历的数值为：',i)
2.生成器
-
生成的运行机制：
在 Python程序中，生成器是一个记住上一次返回时在函数体中位置的函数。对生成器函数的第二次(或第n次)调用跳转至该函数中间，而上次调用的所有局部变量都保持不变生成器不仅“记住”了它的数据状态，还“记住”了它在流控制构造(在命令式编程中，这种构造不只是数据值)中的位置。
概括来说，生成器的特点如下所示。
(1)生成器是一个函数，而且函数的参数都会保留。
(2)当送代到下一次的调用时，所使用的参数都是第一次所保留下的。也就是说，在整个函数调用的参数都已第一次所调用时保留的，而不是新创建的 -
创建生成器
def shengYield(n): while n>0: print('开始生成') yield n print('生成结束') n-=1 if __name__=='__main__': # 可以使用for循环来进行迭代 for i in shengYield(4): print(i) # 可以使用next()进行人工的方法进行遍历 sheng_Yield=shengYield(3) print(sheng_Yield.__next__()) print(sheng_Yield.__next__()) print(sheng_Yield.__next__()) print(sheng_Yield.__next__()) -
生成器的第一次调用
在第一次调用生成器时，不能传送给生成器None以外之的值
-
使用协程重置生成序列
""" 使用协程重置生成器序列 """ def xie(): print('其他队员等待接受处理任务...') while True: data=(yield ) print('收到任务:',data) def producer(): c=xie() c.__next__() for i in range(3): print('游泳名将x杨发送了一个任务...','任务%d'%i) c.send('任务%d'%i) if __name__=='__main__': producer()
3.装饰器
-
创建装饰器
@ zz def han_fun(): pass -
使用装饰器修饰函数
""" 使用装饰器修饰无参的函数 """ def zz(fun): def wrapper(*args,**bian): print('比赛开始了') fun(*args,**bian) print('比赛结束了') return wrapper @zz def demo_decoration(x): a=[] for i in range(x): a.append(i) print(a) @zz def hello(name): print('Hello',name) if __name__=='__main__': demo_decoration(5) print() hello('中国跳水梦之队') """ 装饰器修饰有参数函数 """ def zz(func): def aa(a,b): sum=func(a,b) print(sum) return aa @zz def sum(a,b): return a+b if __name__=='__main__': a,b=map(int,input().split(' ')) sum(a,b) """ 使用装饰器修饰类 """ def zz(myclass): class A: def __init__(self,z=0): self.z=z self.wrapper=myclass() def postion(self): self.wrapper.postion() print('z轴的坐标为',self.z) return A @zz class a: def __init__(self,x=0,y=0): self.x=x self.y=y def postion(self): print('x轴的位置',self.x) print('y轴的位置',self.y) if __name__=='__main__': c=a() c.postion()
4.命名空间
-
命名空间的本质
在Python中一般分为三种命名空间：局部命名空间，全局命名空间，内置命名空间
-
查找命名空间
在Python程序中，当某一行代码要使用变量x的值时，会用到所有可用的名字空间去查找这个变量，按照如下所示的顺序进行查找：局部命名空间，全局命名空间，内置命名空间，如果还没有则引发NameError异常。
对于嵌套函数的命名空间来说，查找顺序为：当前函数的命名空间，父函数的命名空间，模块命名空间，内置模块命名空间
-
命名空间的生命周期
- 内置命名空间在 Python解释器启动时创建，会一直保留下去，不会被删除
- 模块的全局命名空间在模块定义被读入时创建，通常模块命名空间也会一直保存
解释器退出 - 当函数被调用时创建一个局部命名空间，当函数返回结果或抛出异常时被删除。每一个递归调用的函数都拥有自己的命名空间。
-
命名空间访问函数locals()和globals():
- 访问局部变量时，选用locals()。访问全局变量时采用globals()。
- 在 Python程序中, locals实际上没有返回局部名字空间，它返回的是一个拷贝。所以对
它进行改变对局部名字空间中的变量值并无影响。而 globals返回实际的全局名字空间，而
不是一个拷贝。所以对 globals所返回的 dictionary I的任何改动都会直接影响到全局变量
5.闭包
-
定义：
在Python中一个闭包就是你调用了一个函数A，这个函数A返回了一个函数B给你。这个函数B就叫做闭包。你调用函数A时，传递的参数就是一个自由变量
11.文件操作处理
1.文件操作基础
-
open()函数：
在Python中可以通过open函数来打开文件。
""" open()函数的常用形式时接受两个参数即open(file,mode='r') """ open('a.txt', mode='r') """ open()函数的完整语法格式为： """ 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 通用换行模式（不推荐）。 r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。 rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。 r+ 打开一个文件用于读写。文件指针将会放在文件的开头。 rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。 w 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。 w+ 打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。 a 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 ab 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 a+ 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。 ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写 默认为文本模式，如果要以二进制模式打开，加上 b 。
2.File对象
-
File的内置属性：
属性 描述 file.closed返回True如果文件已被关闭，否则返回False file.mode返回被打开文件的访问模式 file.name返回文件名称 foo=open('a.txt', mode='wb') print('文件名字：',foo.name) print('是否关闭',foo.closed) print('访问模式：',foo.mode) -
File的内置函数
序号 方法及描述 1 file.close()关闭文件。关闭后文件不能再进行读写操作。2 file.flush()刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。3 file.fileno()返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。4 file.isatty()如果文件连接到一个终端设备返回 True，否则返回 False。5 file.next()返回文件下一行。6 file.read([size])从文件读取指定的字节数，如果未给定或为负则读取所有。7 file.readline([size])读取整行，包括 "\n" 字符。8 file.readlines([size])读取所有行并返回列表，若给定sizeint>0，则是设置一次读多少字节，这是为了减轻读取压力。9 file.seek(offset[,where])设置文件当前位置10 file.tell返回文件当前位置。11 file.truncate(size)截取文件，截取的字节通过size指定，默认为当前文件位置。12 file.write(str)将字符串写入文件，返回的是写入的字符长度。13 file.writelines(sequence)向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。 -
常用方法介绍
#fileno() fid=foo.fileno() print('文件的描述符是',fid) #isatty() ret=foo.isatty() print('是否连接到终端',ret) """ 在Python程序中，File对象不支持方法next() 在 Python3程序中，内置函数next()通过迭代器调用方法'__next__()'返回下一项。在循环 中，方法 next()会在每次循环中调用，该方法返回文件的下一行。如果到达结尾(EOF),则触发 Stoplteration异常，使用方法next() 的语法格式如下所示。 next(iterator[,default]) """ for index in range(3): line=next(foo) print(line) #read() line2=foo.read(-1) print(line2) #flush() foo.flush() #close() foo.close()
3.使用OS对象
-
OS对象介绍：
在Python中File对象只能对某个文件进行操作。但有时需要对某个文件夹目录进行操作，姿势就需要使用OS对象来实现。
- 常见内置函数
https://www.runoob.com/python3/python3-os-file-methods.html（懒得弄图片了）
- 常见内置函数
-
使用方法
access():-
功能介绍：
检验对当前文件的操作权限模式
-
语法格式：
os.acces(path,mode)- 参数“path”：用于检测是否有访问权限的路径
- 参数“mode”：表示测试当前路径的模式，主要包括四种取值模式。
-
os.F_OK:测试path是否存在 -
os.R_ok:测试path是否可读 -
os.W_ok:测试path是否可写
-
os.X_ok:测试path是否可执行
-
-
access()有返回值，如果允许访问就返回True，否则返回False
-
例子：
import os,sys if __name__=='__main__': ret=os.access("a.txt",os.F_OK) print(ret) ret=os.access("a.txt",os.R_OK) print(ret) ret=os.access("a.txt",os.W_OK) print(ret) ret=os.access("a.txt",os.X_OK) print(ret)
- 使用方法
chdir():- 功能介绍：
修改当前工作目录到指定的路径
-
语法格式
os.chdir(path)
```
- 参数`path`表示要切换的新路径
- 返回值：允许修改返回True，否则返回False
-
例子
import os,sys if __name__=='__main__': path='people' print(os.getcwd()) os.chdir(path) print(os.getcwd())
-
使用方法
chmod()-
功能介绍：
修改文件或目录的权限
-
语法格式：
os.chmod(path,flags)- 参数
path:文件名路径或目录路径 - 参数
mode:表示不同的权限级别- stat.S_IXOTH: 其他用户有执行权0o001
- stat.S_IWOTH: 其他用户有写权限0o002
- stat.S_IROTH: 其他用户有读权限0o004
- stat.S_IRWXO: 其他用户有全部权限(权限掩码)0o007
- stat.S_IXGRP: 组用户有执行权限0o010
- stat.S_IWGRP: 组用户有写权限0o020
- stat.S_IRGRP: 组用户有读权限0o040
- stat.S_IRWXG: 组用户有全部权限(权限掩码)0o070
- stat.S_IXUSR: 拥有者具有执行权限0o100
- stat.S_IWUSR: 拥有者具有写权限0o200
- stat.S_IRUSR: 拥有者具有读权限0o400
- stat.S_IRWXU: 拥有者有全部权限(权限掩码)0o700
- stat.S_ISVTX: 目录里文件目录只有拥有者才可删除更改0o1000
- stat.S_ISGID: 执行此文件其进程有效组为文件所在组0o2000
- stat.S_ISUID: 执行此文件其进程有效用户为文件所有者0o4000
- stat.S_IREAD: windows下设为只读
- stat.S_IWRITE: windows下取消只读
- 无返回值
- 参数
-
例子：
import os,sys,stat if __name__=='__main__': # 设置文件可以通过用户组执行 os.chmod("a.txt",stat.S_IXGRP) # 设置文件可以被其他用户写入 os.chmod('a.txt',stat.S_IWOTH)
-
-
打开，写入和关闭
-
open()方法：功能介绍：打开文件
-
语法格式：
os.open(file,mode,flags)-
file:要打开的文件 -
mode：可选参数，默认为0770 -
flags：该参数可以是以下选项，多个使用 "|" 隔开：- os.O_RDONLY: 以只读的方式打开
- os.O_WRONLY: 以只写的方式打开
- os.O_RDWR : 以读写的方式打开
- os.O_NONBLOCK: 打开时不阻塞
- os.O_APPEND: 以追加的方式打开
- os.O_CREAT: 创建并打开一个新文件
- os.O_TRUNC: 打开一个文件并截断它的长度为零（必须有写权限）
- os.O_EXCL: 如果指定的文件存在，返回错误
- os.O_SHLOCK: 自动获取共享锁
- os.O_EXLOCK: 自动获取独立锁
- os.O_DIRECT: 消除或减少缓存效果
- os.O_FSYNC : 同步写入
- os.O_NOFOLLOW: 不追踪软链接
- open()有返回值，返回新打开文件的描述符
-
-
方法
write()：功能介绍：写入字符串到文件描述符fd中，返回实际写入的字符串长度
-
语法：
os.write(fd,str)-
fd:表示文件描述符 -
str:表示写入的字符串
-
-
方法
close():-
功能介绍：
关闭指定文件的描述符fd
-
语法格式：
os.close(fd)- fd:表示文件描述符
- 无返回值
-
-
实例：
import os,sys,stat if __name__=='__main__': """ 打开，写入，关闭 """ fd=os.open('a.txt',os.O_RDWR|os.O_CREAT) str="你好，我是A" ret=os.write(fd,bytes(str,'UTF-8')) os.close(fd)
-
-
打开，读取，关闭
-
read():功能介绍：从文件描述符fd中读取最多n个字节
-
语法格式：
os.read(fd,n)-
fd:表示文件描述符 -
n:表示读取的字节数 - 返回一个空字符串
-
-
实例：
import os,sys if __name__=='__main__': """ 打开，读取，关闭 """ fd=os.open('a.txt',os.O_RDWR) ret=os.read(fd,5) print(ret) os.close(fd)
-
-
创建目录
-
mkdir():功能介绍：创建目录
-
语法格式：
os.mkdir(path,mode)-
path:表示要创建的一个目录 -
mode：表示为目录设置的权限数字模式 - 返回值为包含读取字节的字符串
-
-
例子
import os,sys if __name__=='__main__': path='x' os.mkdir(path)
-
makedirs()功能：递归创建目录（可以创建子目录）
-
语法形式：
os.makedirs(path,mode=0o777)-
path:表示要递归创建的目录 -
mode:表示为目录设置的权限数字模式 - 返回值为包含读取字节的字符串
-
-
例子
import os,sys if __name__=='__main__': path='y/x' os.makedirs(path)
-
12.标准库函数
1.字符串处理函数
-
分割字符串
-
内置模块string的split()
-
语法：
str.split(str=" ",num=string.count(str)) # str是需要分割的字符串，num是分割次数若不写则全分割 -
例子：
sTr="hjgfjdhfkjfdjhsfks dhfjk dfhjkdgkskjfrjebdbjfsjd" print(sTr.split()) #默认空字符为分隔符，包括换行“\n”，空格，\t等 print(sTr.split('d')) # 以d为分隔符，进行全部分割 print(sTr.split('d',2)) # 以d为分隔符，进行2次分割
-
-