python基础

基本数据类型

• Number（数字）int float bool complex

• String（字符串）""

• List（列表）[]

• Tuple（元组）() 输入时可以没有括号，如tuple=1,2,3 但是一般会带括号，用于复杂表达式

• Set（集合）{}不用键值对的方式则为集合，可以通过set方法设置，构建空集合必须使用set=({})的形式

• Dictionary（字典）{}键值对

  要点：

  1. 与C不同python字符串(String)不能被改变，列表(List)可以被改变，列表被截取后返回一个新列表

     list()函数构建列表

     list(hello)

  2. 元祖(Tuple)与列表类似，但是元祖不能被改变,元祖只有一个元素时须在元素后边添加一个逗号，

  3. 集合(set)重复元素将被去掉，达到去重的目的，集合是无序的

     集合的方法：

     • add()/update()添加元素,update参数可以是列表，元祖，字典
     • remove()/discard()移除，discard移除不存在不会报错，remove会报错
     • pop()随机删除一个元素

  4. 字典(Dictionary)
     dict()函数可以直接从键值对中构建字典

     
     dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
     {'Taobao': 3, 'Runoob': 1, 'Google': 2}
      
     {x: x**2 for x in (2, 4, 6)}
     {2: 4, 4: 16, 6: 36}
      
     dict(Runoob=1, Google=2, Taobao=3)
     {'Runoob': 1, 'Google': 2, 'Taobao': 3}
     

     技巧：

     获取键与值：

     	for i,k in dict.items():
     	print(i,k)
     

序列常用方法：

len（x） 返回序列长度
max（）返回序列最大元素
min（）返回序列最小元素
sum（）返回序列所有元素的和（元素必须是数值类型）
any（）真值测试，有真返回True
all（） 真值测试，全真返回True

常用字符串解析方法:

• split(str,num)-以str分割字符串，分割次数num
• s.join(interrable)-以s字符串分割可迭代序列，返回分割后的字符串，利用该特性可以用list=''.join(list)将序列变为字符串
• len(s)-返回字符串的长度
• s.replace(old, new[, max])-把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。
• s.find(str, beg=0, end=len(string))-检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果指定范围内如果包含指定索引值，返回的是索引值在字符串中的起始位置。如果不包含索引值，返回-1。findr反向查找
• max(s)/min(s)-返回字符串中的字符最大/最小值
• s.count(char, start= 0,end=len(string))-统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。
• ‘H’ in str/‘H’ not in str 判断字符是否在/不再字符串中，相应的返回True/false

列表常用方法：

方法	描述
list.append(x)	向列表末尾添加元素
list.extend(list1)	向列表末尾添加list1元素，如果用append添加的是一个列表，结果是列表嵌套
del list[0]	删除list列表第i个元素，（可以进行切割）del list[2:4]
list.insert(i,x)	在list列表第i个位置处添加x内容
list.remove(x)	删除列表中值为x的第一个元素，如果存在返回错误
list.pop(i)	删除第i个元素，如果不指定i默认为最后一个（pop方法会返回删除值）
list.clear()	清除列表所有项
list.index(x)	返回第一个值为x的索引，不存在返回错误
list.count(x)	返回list列表x出现的次数
list.sort()/list.reverse()	正序/倒序排列
list.copy()	list列表的浅复制

列表还有很多特殊技巧,如:

	list=[x for x in range(2,100) if x<20]

---

Python身份运算符
判是否引用自同一对象

用于判断身份

	a=[1,2,3]
	b=a
	print(b is a)#True
	print(id(b)==id(a))#True id用于获取对象内存地址，与is类似
	
	b=a[:]
	print(b is a)#False
	print(b is not a)#True
	print(id(b)==id(a))#False

---

python随机数函数-引入random库

1. choice()-从序列元素中随机挑选一个元素
2. randrange([start,] stop [,step])-从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1
3. random()-随机生成[0,1)的随机数
4. seed()-设置种子，如果不设置python会自动给你设置，也可以引入time库通过random.seed(time)的方式设置种子
5. random.shuffle(a)-将序列中的所有元素随机排列
6. uniform(x,y)-随机生成下一个实数，它在[x,y]范围内。与randrangge的区别于randrangge为整数，uniform为随机实数
7. sample(range(100),100)-从range（100）中抽样10个数

---

循环控制
8. while…else else为条件语句为false时执行，可以不写
9. for i in seq i为序列的迭代值
10. pass语句为空语句，做占位符

---

迭代器与生成器
迭代器的两个基本方法：iter() 和 next()

	list=[1,2,345,45]
	it=iter(list)#iter用于创建对象
	print(next(it))#next用于指向迭代对象的下一元素

生成器-函数中使用了yield的函数被称为生成器

迭代器可以使用for…int 遍历

---

函数

python中的函数命名及调用：

	def hello():
	    print("Hello World!")
		return#不指定return值则返回None
	hello()

可变参数和不可变参数：

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

将它们作为参数传入函数时传递的是本身与引用的区别

关键字传参：

关键词传参可以不按照顺序传入参量

	def printinfo(name,age):
	    print("年龄是：",name)
	    print("岁数是：",age)
	printinfo(age=12,name='name')
	#年龄是： name
    #岁数是： 12

默认参数：

当未进行传参时函数使用默认参数

	def printf(name=12,age=13):
	    print(name,age)
	    return
	printf()
	#12 13

不定长参数：

函数参数有可能过长，python使用*解决该问题：

加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。

	# 可写函数说明
	def printinfo( arg1, *vartuple ):
	   "打印任何传入的参数"
	   print (arg1)
	   print (vartuple)
	 
	# 调用printinfo 函数
	printinfo( 70, 60, 50 )
	
	#70
	#(60, 50)

加两个星号**以字典的形式写入

	def printinfo( arg1, **vardict ):
	   print (arg1)
	   print (vardict)
	 
	# 调用printinfo 函数
	printinfo(1, a=2,b=3)
	
	#1
	#{'a': 2, 'b': 3}

匿名函数
使用lambda创建匿名函数

	sum=lambda n1,n2:n1-n2
	print("3-2=",sum(3,2))
	
	#3-2= 1

变量作用域

使用global和nonlocal关键字定义全局变量

• global：作用域为全局

    num = 1
   def fun1():
       global num  # 需要使用 global 关键字声明
       print(num) 
       num = 123
       print(num)
   fun1()
   print(num)
   
   #1
   #123
   #123

• nonlocal：作用域为上一级嵌套

外层非全局作用域的变量使用nonlocal

    def outer():
       num = 10
       def inner():
           nonlocal num   # nonlocal关键字声明
           num = 100
           print(num)
       inner()
       print(num)
   outer()
   
   #100
   #100

---

遍历技巧

字典

获取键和值

	dict={'aa':11,'bb':22}
	for i,j in dict.items():
	    print(i,j)
#aa 11
#bb 22

用dict.keys()和dict.values()单独获取键和值

序列

遍历序列时可以使用enumerate()同时获得序列和值

	for i, v in enumerate(('tic', 'tac', 'toe')):
	    print(i, v)
	    
	    #0 tic
		#1 tac
		#2 toe	   

同时遍历多个序列，使用zip()组合

	list1=[1,2,3,4]
	list2=[5,6,7,8]
	for i,j in zip(list1,list2):
	    print(i,j)
	
	#1 5
	#2 6
	#3 7
	#4 8

• sorted()方法进行排序遍历
• reversed()方法反向遍历

---

引入模块

方法

1. import module //引入模块
2. from module import function //引入函数
3. from module import * //导入一个包中全部内容,这种方法尽量少使用

__name__属性

模块被另一程序第一次引入时，会执行主程序，如果想在模块被引入时，某一程序段不执行，可以使用__name__属性使该程序段仅在模块自身运行时运行

if __name__=='__main__':
    print('程序自身运行')
else:
    def fib(n):
        a, b = 0, 1
        while b < n:
            print(b, end=' ')
            a, b = b, a + b
        print()

当在__main__仅在自身运行，其他模块中不能执行__main__中内容

dir()函数

dir(modulename)函数可以查看模块中定义的名称

包

引入包时必须在目录只有包含一个叫做 __ init__.py 的文件才会被认作是一个包，主要是为了避免一些滥俗的名字（比如叫做 string）不小心的影响搜索路径中的有效模块。

folder1/
     __ init__.py
    folder1/
        __ init__.py
         func1.py
         func2.py

一般放一个空文件夹就行，或者一些初始化代码

from module import * 存在的问题

Python 会进入文件系统，找到这个包里面所有的子模块，一个一个的把它们都导入进来。

但是很不幸，这个方法在 Windows平台上工作的就不是非常好，因为Windows是一个大小写不区分的系统。
在这类平台上，没有人敢担保一个叫做 ECHO.py 的文件导入为模块 echo 还是 Echo 甚至 ECHO。

（例如，Windows 95就很讨厌的把每一个文件的首字母大写显示）而且 DOS 的 8+3 命名规则对长模块名称的处理会把问题搞得更纠结。

为了解决这个问题，只能烦劳包作者提供一个精确的包的索引了。

导入语句遵循如下规则：如果包定义文件 __ init__.py 存在一个叫做 __ all__ 的列表变量，那么在使用from package import *的时候就把这个列表中的所有名字作为包内容导入。

__ all__ = [“echo”, “surround”, “reverse”]

其实最好就不用这种方式引入包

---

输入和输出

str()和repr()

str()将输出值转化为字符串
repr()将输出值转化为解释器能够读懂的形式

for x in range(2,4):
    print(123,repr(x).rjust(3))
  	
  	#123   2
	#123   3

上面示例如果不用repr()是没法使用字符串对象下的rjust(x)方法的

rjust(x)、ljust(x)、center(x)

rjust(x)输出对象占3列，靠右对齐

另外两个方法同理（靠左和居中），还有zfill(x)方法，在字符串左边补x个0

以上方法均是返回新的字符串

str.format()

使用str.format()格式化输出

print('{1}网址："{0}"'.format('focehack','forcehack.fun'))
#forcehack.fun网址："focehack"

{} 中的参数用于指定对应参数列表中的位置，如果不指定则顺序进行替换

{}中也可以使用关键字，str.format()中使用keyword=‘’的方式进行替换

使用{lr}和{ls}z在格式化前对字符串进行str()和repr()操作

可以使用{x:.3f}对字符串进行格式化输出x为字段位置或者字段名，后边为输出格式，与C相似，输出小数点后三位

旧式字符串格式化

	import math
	print("这是%.3f"%math.pi)
	
	#这是3.142

就是使用%的方法格式化，因为str.format()新函数，%的形式最终可能从语言中移除，新学习推荐使用str.format()的方法进行格式化输出

使用str=input()方法输入

---

文件操作

	f=open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
	str=f.read()
	print(str)
	f.close()

open()方法第二个参数为打开模式，常用有：

mode	描述
r	以只读方式打开文件，文件指针放在文件开头，默认为该模式
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。

额外还有一些模式，可以查看：以二进制打开在模式后边加 b

其他参数说明：

• buffering：设置缓冲
• encoding：编码格式，一般为utf-8
• errors：报错级别
• newline：区分换行符
• closefd：传入的是否是file参数类型
• opener：

文件对象常用的方法（其他方法可以查看文档）

方法	描述
f.read(size)	读取size长的内容
f.readline()	读取文本中的一行
f.readlines()	返回文本中的所有行
for line in f	迭代获取每行
num=f.write()	写入内容并返回写入字符长度，如果写入内容不是字符串需用str()方法进行转换
f.writelines()	向文件写入序列字符串列表
f.tell()	返回当前所在文件中的位置
f.seek(offset,from_what)	第一个参数移动长度，正数为向后移动，负数为向前移动。第二个参数为0表示开头、1表示当前位置、2表示结尾，如果不指定第二个参数则默认从开头开始
f.truncate( [ size ])	从第一个字符开始截断size个字符，截断后的文本会被删除

f.close()在文本文件中 (那些打开文件的模式下没有 b 的), 只会相对于文件起始位置进行定位。当你处理完一个文件后, 调用 f.close()来关闭文件并释放系统的资源，如果尝试再调用该文件，则会抛出异常。通常使用with处理文件是一个很好的方法，它会帮你正确的关闭文件

	with open('G://test.txt','r') as f:
	    str=f.read()
	    print(str)
	
	print(f.closed)
	
	
	#abcdefghijklmnopqrstuvwxyz
	#True

pickle模块
python的pickle模块实现了基本的数据序列和反序列化。

通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储。

通过pickle模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象。
如果不使用pickle模块，则传入的是字符串

存储序列：

	pickle.dump(obj, file, [,protocol])

• protocol:可选，协议版本，不填默认为0，负数为最高版本。pickle字典使用protocol 0，pickle列表使用protocol -1（最高版本）

重构序列：

	data1 = pickle.load(pkl_file)

---

os模块

用红色标记的方法可以在另一篇博文中查看详解：os模块部分方法详解

上面讲的对文件的操作是python的内置方法
python还可以使用os模块处理文件和目录，常用方法如下（只列举windows系统的常用方法，unix系统可以查看文档 python3 os和目录操作方法）：

方法	描述
os.open(file, flags[, mode])	打开文件
os.access(path,mode)	检验路径访问权限，第一个参数为访问路径，第二个参数有如下：os.F_OK 、os.R_OK、os.W_OK、os.X_OK分别是该路径存在、可读、可写、可执行，均在返回值中获取结果，如果满足为True、相反为False
os.chdir(path)	改变当前工作路径
os.getcwd()	获取当前工作路径
os.closerange(fd_low,fd_high)	关闭所有文件描述符，从fd_low到fd_high
os.dup(fd)	复制文件描述符fd
os.dup2(fd,fd2)	将文件描述符复制到fd2
os.isatty(fd)	如果文件描述打开，且与tty（类似）设备连接则返回True，否则返回False
os.link(src,dst)	创建一个从dst指向src
os.listdir(path)	返回指定文件夹中的文件或者文件夹组成的列表
os.lseek(fd,pos,how)	用于设置在文件中的当前位置，fd：文件描述符，pos：相对于how的位置，how：文件内参考位置（0：开始位置，1：当前位置，2：结尾位置）
os.fstat(fd)|os.lstat(path)	返回文件描述符fd的状态（信息），lstat列出path路径的文件信息
os.fsync(fd)	强制将文件描述符代表的文件写入硬盘
os.makedirs()	递归创建目录。像 mkdir(), 但创建的所有intermediate-level文件夹需要包含子目录。
os.mkdir(path[, mode])	创建目录
os.read(fd,n)	读取文件描述n字节长的内容，如果已达到结尾返回空字符串
os.remove(path)|os.removedirs(path)|os.rmdir(path)	1.删除路径为path的文件，如果为目录则抛出错误2.递归删除目录3.删除目录
os.unlink(path)	与os.remove(path)功能相同，是传统unix系统中的名字
os.rename(src,dst)	用于命名文件或目录，如果dst存在则会抛出错误（用来改变文件或者目录的位置）
os.utime(path,times)	设置路径文件最后的修改和访问事件，如果times为None，则设置为当前时间，否则应该传入一个二元的元祖序列(atime,mtime)做访问和修改时间
os.write(fd,str)	写入str到文件描述符fd中，返回写入的长度
os.walk(top, topdown=True, οnerrοr=None, followlinks=False)	os.walk() 方法用于通过在目录树种游走输出在目录中的文件名，向上或者向下
os.path模块

---

面向对象
python是面向对象的语言，不了解面向对象编程知识可以先了解面向对象方面的知识。

简单示例

	class Animal:
	    i=123
	    #self代表类的实例，不是类
	    def eat(self):
	        return "eat"
	dog=Animal()
	str=dog.eat()
	print(str,dog.i)
	
	#eat 123

__init__
python中使用 __init__ 做构造函数，在进行实例化时自动调用，python可以传递参数

	class Animal:
	    def __init__(self,a,b):
	        self.food=a
	        self.weight=b
	cat=Animal("fish",50)
	print("猫的体重为：{}".format(cat.weight))
	print("猫的食物是：{}".format(cat.food))
	
	#猫的体重为：50
	#猫的食物是：fish

类的方法
同样使用函数的def定义方法，不同的是必须包含self参数，self

下面构造一个动物 (Animal) 的类，定义睡眠时间这个方法

	class Animal:
	    def __init__(self,a,b,c):
	        self.food=a
	        self.weight=b
	        self.time=c
	    def sleep(self):
	        print("猫的睡眠时间为：{}".format(self.time))
	cat=Animal("fish",50,10)
	print("猫的体重为：{}".format(cat.weight))
	print("猫的食物是：{}".format(cat.food))
	cat.sleep()
	
	#猫的体重为：50
	#猫的食物是：fish
	#猫的睡眠时间为：10

python中的继承

• 单继承

既然python面向对象，并且又有类的概念，那么肯定存在继承，不然类的意义就会少很多，继承父类在定义类的括号中写

python子类可以覆盖和重写父类中的方法

	#单继承
	class Animal:
	    def __init__(self,a,b,c):
	        self.food=a
	        self.weight=b
	        self.time=c
	    def sleep(self):
	        print("人的睡眠时间为（父类调用的）：{}".format(self.time))
	
	# 继承Animal
	class people(Animal):
	    def __init__(self,a,b,c,d):
	        self.thin=d
	        # 调用父类构造函数传参
	        Animal.__init__(self,a,b,c)
	    def think(self):
	        print("人是否可以思考？：{}".format(self.thin))
	    #     覆盖父类的方法
	    def sleep(self):
	        print("人的睡眠时间为（子类中调用的）：{}".format(self.time))
	
	
	
	people=people("fish",50,10,True)
	print("调用父类的方法：")
	print("人的体重为：{}".format(people.weight))
	print("人的食物是：{}".format(people.food))
	people.sleep()
	print("********************************************")
	print("调用子类自身的方法：")
	people.think()

	#调用父类的方法：
	#人的体重为：50
	#人的食物是：fish
	#人的睡眠时间为（子类中调用的）：10
	#********************************************
	#调用子类自身的方法：
	#人是否可以思考？：True

上述例子，人（people）继承了Animal（动物），并在人（people）中重写了父类的方法，进行方法调用的时候，调用的子类中的方法

• 多继承

python支持多继承，同样是在圆括号中填写父类，但是需要注意的是圆括号中的父类顺序，当多个父类有同样的方法时，子类会从左到右顺序查找

	class Animal:
	 def __init__(self,a,b,c):
	        self.food=a
	        self.weight=b
	        self.time=c
	    def sleep(self):
	        print("人的睡眠时间为（Animal父类调用的）：{}".format(self.time))
	
	# 在创建一个父类，为多继承做准备
	class Monkey:
	    def __init__(self,c):
	        self.time=c
	    def sleep(self):
	        print("人的睡眠时间为（Monkey父类中调用的）：{}".format(self.time))
	
	# 继承Animal
	class people(Monkey,Animal):
	    def __init__(self,a,b,c,d):
	        self.thin=d
	        # 调用父类构造函数
	        Animal.__init__(self,a,b,c)
	        Monkey.__init__(self,c)
	
	# 实例化类
	people=people("fish",50,10,True)
	print("调用父类的方法：")
	print("人的体重为：{}".format(people.weight))
	print("人的食物是：{}".format(people.food))
	
	people.sleep()

	#调用父类的方法：
	#人的体重为：50
	#人的食物是：fish
	#人的睡眠时间为（Monkey父类中调用的）：10

上述例子中，人（people）继承了猴子（Monkey）和动物（Animal）的属性，并使用了猴子（Monkey）和动物（Animal）中共有的sleep方法，依据从左到右查找的原理，上面例子，打印的是Monkey父类中的方法

• 方法重写

上边其实已经列举了方法重写例子，但是重写后我们想调用父类的方法怎么处理呢？要用到super()方法

	class Animal:
	     def __init__(self,a,b,c):
	            self.food=a
	            self.weight=b
	            self.time=c
	     def sleep(self):
	            print("人的睡眠时间为（Animal父类调用的）：{}".format(self.time))
	
	
	# 继承Animal
	class people(Animal):
	    def __init__(self,a,b,c):
	        # 调用父类构造函数
	        Animal.__init__(self,a,b,c)
	    def sleep(self):
	        print("人的睡眠时间为（子类调用的）：{}".format(self.time))
	
	# 实例化类
	c=people("fish",50,10)
	# 子类的方法
	c.sleep()
	# 用子类对象调用父类的方法
	super(people,c).sleep()

	#人的睡眠时间为（子类调用的）：10
	#人的睡眠时间为（Animal父类调用的）：10

• 类的属性和方法

类的私有属性和方法

类中的私有属性和方法均使用__private两个下划线的形式进行定义

	class Animal:
	     __time=123
	     time=456
	     def sleep(self):
	         print("睡觉")
	     def __eat(self):
	         print("吃饭")
	
	people=Animal()
	print("基本属性：",end="")
	print(people.time,end=",")
	people.sleep()
	print("私有属性：",end="")
	people.__eat()
	print(people._time)

	#Traceback (most recent call last):
	#基本属性：456,睡觉
	#None
  	#File "G:/python程序/hello.py", line 14, in <module>
	#私有属性：    print(people.__eat())
	#AttributeError: 'Animal' object has no attribute '__eat'

获取基本属性和方法，获取私有属性时报错了，是访问不到的

运算符重载

类的专有方法：

• __init__ : 构造函数，在生成对象时调用
• __del__ : 析构函数，释放对象时使用
• __repr__ : 打印，转换
• __setitem__ : 按照索引赋值
• __getitem__: 按照索引获取值
• __len__: 获得长度
• __cmp__: 比较运算
• __call__: 函数调用
• __add__: 加运算
• __sub__: 减运算
• __mul__: 乘运算
• __truediv__: 除运算
• __mod__: 求余运算
• __pow__: 乘方

调用这些方法来实现二进制算术运算 (+, -, *, @, /, //, %, divmod(), pow(), **, <<, >>, &, ^, |)。例如，求表达式 x + y 的值，其中 x 是具有__add__() 方法的类的一个实例，则会调用 x.__add__(y)。

	class Mathr:
	    def __init__(self,a,b):
	        self.a=a
	        self.b=b
	    #     字符串格式化方法
	    def __str__(self):
	        return "{}|{}".format(self.a,self.b)
	    def __add__(self, other):
	         return Mathr(self.a+other.a,self.b+other.b)
	
	math1=Mathr(1,2)
	math2=Mathr(2,3)
	print(math1+math2)

	#3|5

---

python标准库示例

1. os模块，上边已经有讲解就不多提了

2. 在类似os模块这种大模块上学会使用dir()和help()方法，dir()查看属性和方法,help()查看详解，不一定只用于模块，不懂得方法也可以使用help()查看详解

3. 在日常得文件和目录管理中shutil模块提供了更方便使用得接口

   	import shutil
   	shutil.copyfile('data.db', 'archive.db')
   	shutil.move('/build/executables', 'installdir')
   

4. glob模块提供了从目录使用通配符查找文件得接口

   	import glob
   	print(glob.glob("*.py"))
   
   	#['fibo.py', 'hello.py']
   

5. 获取命令行参数

   	import sys
   	print(sys.argv)
   

6. 错误重定向，大多数得脚本中止程序退出使用sys.exit()

   	import sys
   	sys.stderr.write("warning!!")
   	
   	#warning!!
   

7. 使用re模块处理字符串正则匹配

8. 使用math模块处理浮点C运算

9. 使用random模块生成随机数

10. 有几个模块用于访问互联网以及处理网络通信协议。其中最简单的两个是用于处理从 urls 接收的数据的 urllib.request

    	from urllib.request import urlopen
    	for line in urlopen("http://www.forcehack.fun"):
    		print(line)
    
    

11. datetime模块处理日期和时间

    模块提供了用于以简单和复杂的方式操作日期和时间的类。在支持日期时间数学运算的同时，实现的关注点更着重于如何能够更有效地解析其属性用于格式化输出和数据操作。方法较多可以查看文档

    	from datetime import  date
    	now=date.today()
    	#b月份得缩写
    	#%y不带世纪得年
    	# %Y带世纪的年
    	# %A当地工作日全名
    	# %B丹迪月份全名
    	ftime=now.strftime("%m-%d-%y. %d %b %Y is a %A on the %d day of %B.")
    	print(now)
    	print(ftime)
    
    	#2019-05-14
    	#05-14-19. 14 May 2019 is a Tuesday on the 14 day of May.
    

12. 使用zlib模块处理数据压缩

    zlib.compress(data, level=-1)

    压缩 data 中的字节，返回含有已压缩内容的 bytes 对象。参数 level 为整数，可取值为 0 到 9 或 -1，用于指定压缩等级。1 (Z_BEST_SPEED) 表示最快速度和最低压缩率，9 (Z_BEST_COMPRESSION) 表示最慢速度和最高压缩率。0 (Z_NO_COMPRESSION) 表示不压缩。参数默认值为 -1 (Z_DEFAULT_COMPRESSION)。Z_DEFAULT_COMPRESSION 是速度和压缩率之间的平衡 (一般相当于设压缩等级为 6)。函数发生错误时抛出 error 异常。

    		import zlib
    		str=b'witch which has which witches wrist watch'
    		print(len(str))
    		t=zlib.compress(str)
    		print(len(t))
    		# 解压
    		print(zlib.decompress(t))
    		# 计算循环冗余校验值
    		print(zlib.crc32(str))
    
    		#41
    		#37
    		#b'witch which has which witches wrist watch'
    		#226805979
    

13. timeit模块提供了一种简单的方法来计算一小段 Python 代码的耗时。

    		import timeit
    		time1=timeit.Timer('temp=x;x=y;y=temp','x=2;y=4').timeit()
    		time2=timeit.Timer('x,y=y,x','x=2;y=4').timeit()
    		print(time1)
    		print(time2)
    
    		#0.019235111111111113
    		#0.01662755555555556
    

---

一些参考方法：

数组翻转指定个数元素：

	def rotateList(arr,d,n):
    for i in range(0,d):
        temp=arr[0]
        arr.pop(0)
        arr.append(temp)
	arr=[x for x in range(1,8)]
	rotateList(arr,2,7)
	print(arr)

复制列表：

	list1=[1,2,3,4]
	list2=[]
	list2.extend(list1)

字符串移除指定位置字符：

	str="12313gfagj"
	newStr=''
	for i in range(0,len(str)):
	         if(i!=2):
	                newStr=newStr+str[i]
	print(newStr)

__init__包的作用

指定初始化操作

from helper import parse

上面代码在__init__包中指定，那么通过直接引入import helper时只能使用parse包，其他没有的不可以

__all__变量类似，指定导出内容

from helper.parse import parseFn

__all__ = [
    "parseFn",
]

通过import helper整体引入时只能使用parseFn方法，也可以用过from helper import parseFn直接引入了

如果没有上述指定，那么只能通过from helper import ...引入变量、函数、包