Python语法基础

一、运算符、表达式与内置对象

Python常用内置对象

• 元组：若元组中只有一个元素，则后面的逗号不能省略 (2,)

• 内置函数 isinstance()用于测试变量是2否为指定类型 isinstance(x,int)

• 标准库fractions中的Fractions对象支持分数运算。支持分数间四则运算，自动进行同分。

  from fractions import Fraction
  
  x = Fraction(3,5)
  y = Fraction(3,7)
  
  print(x.numerator)  # 查看分子
  print(x.denominator) # 查看分母
  

Python运算符与表达式

• 位运算符：
  位运算符只能用于整数。其内部执行过程为：首先将整数转换成二进制数，然后右对齐，左补零，按位进行运算。

• 集合运算符：

  >>> {
        1,2,3}|{
        3,4,5}  #并集，自动去除重复元素
  {
        1, 2, 3, 4, 5}
  >>> {
        1,2,3}&{
        3,4,5}  #交集
  {
        3}
  >>> {
        1,2,3}^{
        3,4,5}  #对称差集
  {
        1, 2, 4, 5}
  >>> {
        1,2,3}-{
        3,4,5}  #差集
  {
        1, 2}
  

• 逻辑运算符：
  运算符 or 和 and 不一定会返回True或False ，而是得到最后一个被计算的表达式的值，但运算符 not 一定会返回bool值。

  >>> 3 and 5
  5
  >>> not 3
  False
  >>> not 0
  True
  

• 矩阵乘法运算符：

  import numpy    
  x = numpy.ones(3)			#ones()函数用于生成全1矩阵，参数表示矩阵大小
  m = numpy.eye(3) * 3  		#eye()函数用于生成单位矩阵
  m[0,2] = 5					#设置矩阵制定位置上元素的值
  m[2,0] = 3
  print(x @ m)				#矩阵相乘
  

Python常用内置函数

类型转换与类型判断

• bin()二进制；oct()八进制；hex()十六进制。

• int()转化为整数：当参数为数字字符串时，还允许制定第二个参数base用来说明数字字符串的进制。

• float()转化为实数，complex()可以生成复数。

  >>> float('3.5')			#把数字字符串转化成实数
  3.5
  >>> float('inf')			#inf为无穷大
  inf
  >>> complex(3,5)
  (3+5j)
  

• ord()返回单个字符的Unicode码，chr()返回Unicode对应的字符，str()将其他类型参数转化成字符串。

• 内置类bytes 用于生成字节串，或把指定对象转换为特定的编码字节串。

  >>> bytes(3)
  b'\x00\x00\x00'
  >>> bytes('董付国','utf-8')
  b'\xe8\x91\xa3\xbb\x98\xe5\x9b\xbd'
  

• list()、tuple()、dict()、set()、frozenset()用来把其他类型的数据分别转换成：列表、元组、字典、可变集合、不可变集合。

• 内置函数 type()和 isinstance()判断数据类型。

最值与求和

• max()、min()支持default参数和key参数。default用来指定可迭代对象为空时默认返回的最大或最小值。key参数指定比较大小的一依据。

  >>> max(['2','111'],key=len)  		#返回最长的字符串
  '111'
  >>> from rendom import randint
  >>> lst = [[randint(1,50) for i in range(5)] for j in range(30)]
  >>> max(lst,key=sum)				#返回元素之和最大的子列表
  >>> max(lst,key=lambda x:x[1])		#所有子列表中第二个元素最大的子列表
  

• sum()函数支持start参数。用来控制求和的初始值。

基本输入输出

• print()函数中使用sep参数指定数据之间的分割符。使用file参数指定输出位置。

  >>> print(1,3,5,7,sep='\t') 		#修改默认分隔符
  >>> with open ('text.txt','a+') as fp:
      print('Hello world!',file=fp)	#将内容输出到文件中
  

排序与逆序

• sorted()对可迭代对象进行排序并返回新列表。reversed()返回可迭代的对象。

  >>> x = list(range(11))
  >>> import random 
  >>> random.shuffle(x)						#打乱数组顺序
  >>> x
  [3, 4, 1, 2, 9, 5, 0, 6, 8, 7, 10]
  >>> sorted(x,reverse=False)    				#升序
  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  >>> sorted(x,reverse=True)
  [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]			#降序
  >>> sorted(x,key=lambda item:len(str(item)),reverse=True)
  [10, 3, 4, 1, 2, 9, 5, 0, 6, 8, 7]			#按转换成字符串以后的长度降序排列
  

枚举

• enumerate()函数，返回可迭代的对象包括索引和值的元组。参数start用来指定枚举时的索引起始值。

  >>> list(enumerate('abcd'))							#枚举字符串中的元素
  (0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')
  >>> for index,value in enumerate(range(10,15)):		#枚举range对象
      print((index,value),end=' ')
  (0, 10) (1, 11) (2, 12) (3, 13) (4, 14) 
  >>> for item in enumerate(range(5)，6)：
  	print(item,end=' ')
  (6,0) (7,1) (8,2) (9,3) (10,4)
  

map()、reduce()、filter()函数式

• 内置函数 map()，数据一次流入和流出一系列函数。

  list(map(str,range(5)))						#把列表中的元素转换为字符串
  
  def add(v,u):								#把双参数函数映射到一个序列的所有函数
      return v + u
  list(map(add5,range(5),range(5,10)))
  list(map(lambda x,y:x+y,range(5),range(5,10)))
  
  import random								#提取大整数每位上的数字
  x = random.randint(1,1e30)
  list(map(int,str(x)))
  

• 标准库functools中函数 reduce()将一个双参数函数通过迭代累积从左到右依次作用到一个可迭代对象的所有元素上，允许指定一个初始值。累。

  from functools import reduce
  import operator
  seq = list(range(1,10))
  reduce(operator.add,map(str,seq))			#转换成字符串再累加
  

• 内置函数 filter()将一单参数函数作用到一个可迭代对象上，返回满足True 或False的元素。

  seq = ['fool','x41','?',',','***']
  list(filter(lambda x:x.isalnum(),seq))		#测试是否为字母或数字
  
  list(filter(None,[1,2,3,4,0,0,5]))			#指定函数为None
  

zip()

把多个可迭代对象中的元素压缩到一起，每个元素左对齐，构成元组，长度取决于最短的元素。

二、Python序列结构

列表

列表的常用方法

• append()、insert()、extend()extend()函数在尾部追加多个元素。 x.extend([5,6,7])
• count()、index()
  count()用于返回指定元素的出现次数，index()返回指定元素在列表中首次出现的位置。
• sort()和reverse()原地，sorted()和reversed()另外。
• .copy()浅复制 .deepcopy()深复制 [copy库]

列表推导式语法

• 嵌套列表的平铺

  >>> vec = [[1,2,3],[4,5,6],[7,8,9]]
  >>> [num for elem in vec for num in elem]
  [1,2,3,4,5,6,7,8,9]
  

• 过滤不符合条件的元素

  >>> aList = [-1,-4,6,7.5,-2.3,9,-11]
  >>> [i for i in aList if i>0]			#所有大于0的数字
  

• 同时遍历多个列表或可迭代对象

  >>> [(x,y) for x in [1,2,3] for y in [3,1,4] if x!=y]
  [(1,3),(1,4),(2,3),(2,1),(2,4),(3,1),(3,4)]
  

• 实现矩阵转置

  >>> matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
  >>> [[row[i] for row in matrix] for i in range(4)]
  [[1,5,9],[2,6,10],[3,7,11],[4,8,12]]
  

元组

生成器推导式

• 无法再次访问已访问过的元素，不支持使用下标直接访问其中任意元素。

• 使用 __next__()方法或 next()函数进行遍历。

  >>> g = ((i+2)**2 for i in range(10))		#创建生成器对象
  >>> tuple(g)
  (4, 9, 16, 25, 36, 49, 64, 81, 100, 121)
  >>> list(g)									#生成器对象已遍历结束，没有元素了
  []
  >>> g = ((i+2)**2 for i in range(10))
  >>> g.__next__()
  4
  >>> next(g)
  9
  

字典

元素的访问、添加

• get()方法返回指定腱对应的值，不存在时返回指定默认值。

  import random
  z = ''.join((random.choice(x) for i in range(1000)))
  d = dict()
  for ch in z:					#遍历字符串，统计频次
      d[ch] = d.get(ch,0) + 1
  for k,v in sorted(d.items()):
      print(k,':',v)
  

• setdefault()返回指定键对应的值，若不存在则创建一个新元素。

• 对字典直接进行迭代或者遍历时默认遍历“键”，对象：.item()；值：.value()

标准库collections

• OrderedDict类：可以严格记住元素插入顺序的字典。

  import collections
  x = collections.OrderedDict()
  x['a'] = 3
  x['b'] = 4
  x['c'] = 5
  >>> x
  OrderedDict([('a',3),('b',4),('c',5)])
  

• Counter类：统计频次

  >>> from collections import Counter
  >>> frequences = Counter(z)
  >>> frequences.item()
  >>> frequences.most_common(1)			#返回出现次数最多的一个字符及其频率
  >>> frequences.most_common(3)			#返回出现次数前三的字符及其频率
  

集合

操作与运算

• add()方法增加新元素，update()方法合并另外一个集合。都自动忽略重复值。
• 关系运算符在集合时表示集合之间的包含关系。
• pop()方法随机删除并返回集合中的一个元素，集合若空则抛出异常。
  remove()方法删除集合中的特定值的元素，若不存在则抛出异常。
  discard()方法从集合中删除特定元素，不存在则忽略操作。
  clear()方法清空集合。

序列解包

x,y,z = 1,2,3					#多个变量同时赋值
x,y,z = range(3)				#对range对象进行序列解包
x,y,z = iter([1,2,3])			#使用迭代器对象进行序列解包
x,y,z = map(str,range(3))		#使用可迭代的map对象进行序列解包
a,b = b,a						#交换两个变量的值

三、字符串

转义字符

1. ‘\b’：退格，把光标移动到前一列位置。
2. ‘\f’：换页符
3. ‘\ooo’：3位八进制数对应的字符。
4. ‘\xhh’：2位十六进制数对应的字符。
5. ‘\uhhhh’：4位十六进制数表示的Unicode字符。

字符串格式化

用%符号进行格式化

'% [-] [+] [0] [m] [.n] 格式字符' % x

1. 格式标志，表示格式开始。
2. 指定左对齐输出。
3. 对正数加正号。
4. 指定空位填0。
5. 指定最小宽度。
6. 指定精度。
7. 指定类型。
8. 格式运算符。
9. 带转换的表达式。

>>> x = 1235
>>> so = '%o' %x
>>> so
'2323'
>>> sh = '%x' %x
>>> sh
'4d3'

format()方法进行字符串格式化

>>> 1/3
0.3333333333
>>> print('{0:.3f}'.format(1/3))  			#保留3位小数
0.333
>>> print('The number {0:,} in hex is: {0:x}',
          'the number {1} in oct is {1:o}'.format(5555,55))
The number 5,555 in hex is: 15b3, the number 55 in oct is 67.
>>> print('my name is {name}, my age is {age}, and my QQ is {qq}'.format(name==
          'Dong',qq=='306467355',age==38))
my name is Dong, my age is 38, and my QQ is 306467355.

Template模板

>>> from string import Template
>>> t = Template('My name is ${name},and is ${age} years old.')		#创建模板
>>> d = {
    'name':'Dong','age':39}
>>> t.substitute(d)													#替换
'My name is Dong, and is 39 years old.'

字符串常用操作

• find()/rfind()方法分别查找一个字符串在另一个字符串指定范围内的首次/最后一次出现的问题。若不存在则返回-1，index()/rindex()则抛出异常。

• split()/rsplit()用来以指定字符为分隔符，从字符串左端和右端开始将其分割成多个字符串。返回包含分割结果的列表。属性maxsplit指定最大分割次数。

• partition/rpartition()以指定字符串为分隔符将其分为3分。

• join()将列表中多个字符串进行连接，并在相邻两个字符串间插入指定字符，返回新字符串。

  >>> li = ['apple','peach','banana','pear']
  >>> ':',join(li)
  

• swapcase()大小写互换。

• maketrans()与 translate()方法组合可同时处理多个不同的字符。

  #创建映射表，将字符'abcdef123'一一对应转换为'uvwxyz@#$'
  table = ''.maketrans('abcdef123','uvwxyz@#$')
  s = 'Python is a great programming language.'
  s.translate(table)
  

• zfill()返回指定宽度的字符串，在左侧以0进行补充。

四、函数

可调用对象与修饰器

1. 可调用对象：

   #使用函数嵌套
   def linear(a,b):
       def result(x):
           return a*x + b
       return result
   
   #使用__call__()方法：
   class linear:
       def __init__(self,a,b):
           self.a,self.b = a,b
       def __call__(self,x):
           return self.a * x + self.b
       
   #上述嵌套函数或类这两种方式任何一种，都可以以下放啊发定义一个可调用对象；
   taxes = linear(0.3,2)
   taxes(5)
   

2. 修饰器：

   def before(func):							#定义修饰器
       def wrapper(*args,**kwargs):
           print('Before function called.')
           return func(*args,**kwargs)
       return wrapper
   
   def after(func):							#定义修饰器
       def wrapper(*args,**kwargs):
           result = func(*args,**kwargs)
           print('After function called.')
           return result
       return wrapper
   
   @before
   @after
   def test():									#同时使用两个修饰器改造函数
       print(3)
   #调用被修饰的函数
   test()
   

函数参数

1. 可变长度参数：

   两种形式：*parameter和 **parameter，前者用于接受任意多个位置实参并将其放入一个元组中，后者用于接受类似于关键参数一样显示赋值形式的多个实参并将其放入字典中。

   def demo(*p):  
       print(p)
   demo(1,2,3)
   
   def demo(**p):
       for item in p.items():
           print(item)
   demo(x=1,y=2,z=3)
   

2. 传递参数时的自动解包：
   以可迭代对象作为参数，并在实参名称前接一个星号，Python解析器自动进行解包。

   def demo(a,b,c):
       print(a+b+c)
   seq = [1,2,3]
   demo(*seq)
   

   若实参为字典，则使用两个星号对其进行解包，将其转化成类似关键参数的形式进行参数传递。
   顺序：位置参数，默认值参数，一个星号的可变长度参数，两个星号的可变长度参数。

变量作用域

一个变量在函数外已定义，若在函数内需要修改这个变量的值，并将修改的结果反映到函数之外，可以在函数内用关键字global明确声明要使用已定义的同名全局变量。

lambda表达式

>>> f = lambda x,y,z: x+y+z
>>> print(f(1,2,3))
6
>>> g = lambda x,y=2,z=3: x+y+z
>>> print(g(1))
6
>>> L = [(lambda x: x**2),(lambda x: x**3),(lambda x: x**4)]
>>> print(L[0](2),L[1](2),L[2](2))
4 8 16
>>> L = [1,2,3,4,5]
>>> list(map(lambda x: x+10,L))
[11, 12, 13, 14, 15]

生成器函数

yield语句可以用来创建生成器对象。每次执行到yield语句并返回一个值之后会暂停或挂起后面代码的执行，下次通过生成器对象的__next()__方法、for循环遍历生成器对象元素恢复执行。生成器具有惰性求值的特点。

#斐波那契数列中前10个元素
def f():
    a,b = 1,1					#序列解包，同时为多个元素赋值
    while True:					
        yield a					#暂停执行，需要时再产生一个新元素
        a,b = b,a+b				#序列解包，继续生成新元素
a = f()							#创建生成器对象
for i in range(10):
    print(a.__next__(),end=' ')


>>> def f():
    yield from 'abcdefg'		#使用yield表达式创建生成器
>>> x = f()
>>> next(x)
'a'
>>> next(x)
'b'
>>> for item in x:				#输出x中的剩余元素
    pritn(item,end' ')
c d e f g 

五、正则表达式

正则表达式语法

常用集锦

1. '[pjc]ython'：‘python’, ‘jython’, ‘cython’。
2. [a-zA-Z0-9]：一个任意大小写字母或数字。
3. '[^abc]'：任意除’a’, ‘b’, 'c’外的字符。
4. 'python|perl'或 'p(ython|erl)'都可以匹配’python’或’perl’。
5. r'(http://)?(www\.)?python\.org'只能(http://)(www.)python.org
6. '^http'只能匹配所有以"http"开头的字符串。
7. '(pattern)*'允许模式重复0次或多次。
8. '(pattern)+'允许模式重复一次与多次。
9. (pattern){m,n}：允许模式重复m~n次。
10. '(a|b)*c'：匹配多个a或b，后面紧跟c
11. 'ab{1,}'：等价于 ab+，匹配以字母a开头后面紧跟一个或多个字母b的字符串。
12. ^[a-zA-Z]{1}([a-zA-Z0-9._]){4,19}$：匹配长度为5~20的字符串，必须以字母开头并后面数字、字母、“_”、“.”的字符串。
13. '^(\w){6,20}$'：匹配长度为6~20的字符串，可以包含字母、数字、下划线。
14. ^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$：检查给定字符串是否为合法IP地址。
15. '^(13[4-9]\d{8})|(15[01289]\d{8})$'：检查给定字符串是否为移动手机号码。
16. '^[a-zA-Z]+$'：检查给定字符串是否是只包含英文大小写字母。
17. '^\w+@(\w+\.)+\w+$'：检查是否为合法电子邮件地址。
18. '^(\-)?\d+(\.\d{1,2})?$'：检查给定字符串是否为最多带有2位小数的正数或负数。
19. '[\u4e00-\u9fa5]'：匹配给定字符串中的常用汉字。
20. '^\d{18}|\d{15}$'：检查给定字符串是否为合法身份证格式。
21. '\d{4}-\d{1,2}-\d{1,2}'：匹配指定日期格式。

六、面向对象程序设计

数据成员与成员方法

从形式上看，在定义类的成员时，如果成员名以两个或更多下划线开头但不以两个或多个下划线结尾的，则表示的是私有成员，否则就不是私有成员。

1. __xxx__ 前后各两个下划线，系统定义的特殊成员
2. _xxx 以一个下划线开头，保护成员，只有类对象和子对象可以访问这些成员
3. __xxx 以两个或更多下划线开头，不以两个或更多的下划线结束，表示私有成员，一般只有类对象自己能访问，子类对象也不能访问，但在成员外部可以通过 私有数据成员语法：对象名._类名__xxx 来访问。

方法

Python类的成员方法大致可以分为公有方法、私有方法、静态方法、类方法和抽样方法。

所有实例方法（公有方法、私有方法、抽样方法和某些特殊的方法）都必须至少有一个名为self 的参数，并且必须是方法的第一个形参，self参数代表当前对象。

静态方法和类方法都可以通过类名和对象名调用，但不能直接访问属于对象的成员，只能访问属于类的成员。

class Root:
        __total = 0
        def __init__(self,v):           # 构造方法，特殊方法
                self.__value = v
                Root.__total += 1

        def show(self):                 # 普通实例方法，一般以self 作为第一个参数的名字
                print("self.__value:",self.__value)
                print("self.__total",self.__total)

        @classmethod                    # 修饰器，声明类方法
        def classShowTotal(cls):        # 类方法，一般以 cls 作为第一个参数的名字
                print(cls.__total)

        @staticmethod                   # 修饰器，声明静态方法
        def staticShowTotal():          # 静态方法，可以没有参数
                print(Root.__total)

r = Root(3)					
r.classShowTotal()			# 通过对象来调用类方法
Root.classShowTotal()		# 通过类名调用类方法
Root.show(r)				# 可以通过这种方法来调用方法并访问实例成员

属性

class Test:
    def __init__(self, value):
        self.__value = value
    
    def __get(self):
        return self.__value

    def __set(self, v):
        self.__value = v

    def __del(self):
        del self.__value

    value = property(__get, __set, __del)	# 可读、可写、可删除性质

    def show(self):
        print(self.__value)

动态性与混入机制

import types
class Car(object):
    price = 10000                                   # 属于类的数据成员
    def __init__(self,c):
        self.color = c                              # 属于对象的数据成员

car1 = Car('Red')                                   # 实例化的对象
print(car1.color,Car.price)                         # 访问对象和类的数据成员
Car.price = 100                                     # 修改类的属性
Car.name = 'BMW'                                    # 动态增加类属性
car1.color = 'yellow'                               # 修改实例属性
print(car1.color,car1.price,Car.name)

def setSpeed(self,s):
    self.speed = s
car1.setSpeed = types.MethodType(setSpeed,car1)     # 动态为对象增加成员对象**
car1.setSpeed(50)                                   # 调用对象的成员方法
print(car1.speed)

继承、多态

继承

派生类可继承父类的共有成员，若需在派生类中调用基类的方法，可以使用内置函数 super()或通过 基类名.方法名() 实现

class Person(object):
    def __init__(self,name='',age=20,sex='man'):
        # 通过调用方法进行初始化
        self.setName(name)
        self.setAge(age)
        self.setSex(sex)

    def setName(self,name):
        if not isinstance(name,str):
            raise Exception('name must be a string.')
        self.__name = name

    def setAge(self,age):
        if type(age) != int:
            raise Exception('age must be an integer.')
        self.__age = age

    def setSex(self,sex):
        if sex not in ('man','woman'):
            raise Exception('sex must be "man" or "woman".')
        self.__sex = sex

    def show(self):
        print(self.__name,self.__age,self.__sex,sep='\n')

# 派生类
class Teacher(Person):
    def __init__(self,name='',age=30,sex='man',department='Computer'):
        # 调用基类构造方法初始化基类的私有数据成员
        super(Teacher,self).__init__(name,age,sex)
        # 也可以这样初始化基类的私有数据成员
        # Person.__init__(self,name,age,sex)
        # 初始化派生类的数据成员
        self.setDepartment(department)

    def setDepartment(self,department):
        if type(department) != str:
            raise Exception('department must be a string.')
        self.__department = department

    def show(self):
        super(Teacher,self).show()
        print(self.__department)

if __name__ == '__main__':
    zzs = Person('zzs',19,'man')
    zzs.show()
    print('=' * 30)

    z3 = Teacher('z3',32,'man','math')
    z3.show()

多态

class Animal(object):
    def show(self):
        print('I am an animal.')

class Cat(Animal):      # 派生类，覆盖了基类的show()方法
    def show(self):
        print('I am a cat.')

class Test(Animal):     # 派生类，没有覆盖基类的show()方法
    pass

x = [item() for item in (Animal, Cat, Test)]
for item in x:
    item.show()

七、文件

文件内容操作

内置函数open()

open(file,mode='r',buffering=-1,encoding=None,errors=None,newline=None,

closefd=True,opener=None)

1. file: 指定要打开或创建的文件名称，使用相对路径或绝对路径。
2. mode: “r”读；“w”写，若已存在清空原文件；“x”写，若已存在则抛出异常；“a”追加，不覆盖文件原有内容；“b”二进制模式。

文件内容操作完成后，一定要使用方法.close关闭文件。

文件对象常用使用方法

1. close(): 把缓冲区的内容写入文件，并关闭文件，释放文件对象。
2. flush(): 把缓冲区的内容写入文件，但不关闭文件。
3. read([size]): 从文件中读取size个字符内容，若省略则读取所有内容。
4. readline(): 从文件中读取一行。
5. readlines(): 把文件中的每行作为一个字符串存入列表。
6. write(s): 把字符串s 的内容写入文件。
7. seek(offset[,whence]): 把文件指针移动到新的位置，offset表示相对于whence的位置，whence为0时表示从文件头开始，为1时从当前位置开始计算，为2时从文件末尾开始计算。

上下文管理语句with

with open(filename, mode, encoding) as fp:

with open('test.txt','r') as src, open('test_new.txt','w') as dst:
    dst.write(src.read())

CSV模块

import csv

def write_csv_demo1():
    headers = ['username', 'age', 'height']
    values = [
        ('张三', 18, 180),
        ('李四', 19, 190),
        ('王五', 20, 170)
    ]

    with open('classroom.csv', 'w', encoding='utf-8', newline='') as fp:
        writer = csv.writer(fp)
        writer.writerow(headers)
        writer.writerows(values)

def write_csv_demo2():
    headers = ['username', 'age', 'height']
    values = [
        {
    'username': "张三", 'age': 17, 'height': 170},
        {
    'username': "李四", 'age': 18, 'height': 180},
        {
    'username': "王五", 'age': 17, 'height': 190}
    ]
    with open('classroom1.csv','w',encoding='utf-8',newline='') as fp:
        writer = csv.DictWriter(fp,headers)
        writer.writeheader()
        writer.writerows(values)


if __name__ == '__main__':
    write_csv_demo2()

文件与文件夹操作

os模块

>>> import os
>>> import os.path
>>> os.rename('C:\\dfg.txt','D:\\text2.txt')		#rename()实现文件的改名和移动
>>> [fname for fname in os.listdir('.')				#listdir(path)返回path目录下的文件和目录列表
... if fname.endwith(('.py','.pyc','.pyw'))]		#查看当前文件夹中指定类型的文件

>>> os.mkdir(os.getcwd()+'\\temp')					#创建目录
>>> os.chdir(os.getcwd()+'\\temp')					#改变当前工作目录
>>> os.rmdir('temp')								#删除目录
>>> os.environ.get('path')							#获取系统变量path的值

使用os模块的scandir()输出当前文件夹中的所有扩展名为py的文件：

for entry in os.scandir():
    if entry.is_file and entry.name.endwith('.py'):
        print(entry.name)

os.path模块

1. abspath(path)返回绝对路径。

2. basename(path)返回指定路径的最后一个组成部分。

3. commonpath(paths)返回给定的多个路径中的最长公共路径。

   commonprefix(paths)返回给定多个路径中的最长前缀。

4. dirname(p)返回文件夹的部分。

5. exists(path)判断文件是否存在。

6. getatime(filename)返回文件的最后访问时间。
   getctime(filename)返回文件的创建时间。
   getmtime(filename)返回文件最后修改时间。

7. join(path,*path)连接两个或多个path。

8. split(path)以路径中的最后一个\为分隔符，分为两个部分为元组。
   splitext(path)从路径中分离文件扩展名，返回元组。

shutil模块

1. copy(src,dst)复制文件，新文件具有同样的文件属性，若目标文件已存在，则抛出异常。
2. copyfile(src,dst)复制文件，不复制文件属性，若目标文件已存在则覆盖，
3. copyfileobj(fsrc,fdst)在两个文件之间复制数据，如：copyfileobj(open(‘123.txt’),open(‘456.txt’,‘a’))
4. move(src,dst)移动文件或递归移动文件夹，也可以给文件和文件夹重命名。
5. make_archive(base_name,format,root_dir=None,base_dir=None)
   创建TAR或ZIP格式的压缩文件。
6. unpack_archive(base_name,format,root_dir=None,base_dir=None)
   解压压缩文件。

八、异常处理结构与单元测试

异常处理结构

1. try…except

try
	# 可能会引发异常的代码，先执行一下试试
except Exception[ as reason]:
    # 若try中的代码抛出异常并被except捕捉，就执行这里的代码

# 实现接收用户输入，并要求用户必须输入整数
while True:
    x = input('Please input:')
    try:
        x = int(x)
        print('You have input {}'.format(x))
        break
    except Exception as e:
        print('Error.')

2. try…except…else

try:
    # 可能会引发异常的代码
except Exception[ as reason]:
    # 处理异常的代码
else:
    # 若try子句中的代码没有引发异常，则继续执行这里的代码

3. try…except…finally

try:
    # 可能会引发异常的代码
except Exception[ as reason]:
    # 处理异常的代码
finally:
    # 无论try子句中的代码是否引发异常，都会执行这里的代码