模块

1.json模块

json文件是一种特殊的字符串，里面可以有列表，字符串等。是不同编程语言之间信息传递的一种方法。

1.1序列化

python的列表等转换成jason格式叫做序列化，json转编程语言叫做反序列化，序列化会把字符串的引号转换为双引号，jason只认字符串为双引号。

v = [12,3,4,{‘name‘:‘ran‘},True,‘ranhao‘] #先定义一个列表，里面有字典，布尔，字符串，数字
import json
#导入json模块
v1 = json.dumps(v) #序列化
print(v1)
#输出：[12, 3, 4, {"name": "ran"}, true, "ranhao"]

1.2反序列化

拿到json这种特殊的字符串，必须反序列化成为字典或列表，才方便进行下一步的操作。

import json
v2 =‘["ran",123]‘ #这是一个json，字符串格式，内部为列表
v3 = json.loads(v2) #反序列化
print(v3)
#输出：[‘ran‘, 123]

在json格式中没有元组

2.pickle模块

2.1 和json对比

• json优点：所有语言通用； 缺点：只能序列化基本的数据类型 list/dict/int
• pickle优点：python中所有的东西都能被它序列化 (除开socket对象); 缺点：序列化的内容只有python认识
• json序列化得到str字符串，pickle序列化得到bytes字节

3.shutil模块

shutil.rmtree(‘test‘) 删除tset目录

shutil.move(‘test‘,‘xx‘) 把test目录重命名为xx

shutil.make_archive(‘zzh‘,‘zip‘,‘D:\code\ran‘) 把ran这个文件压缩为zzh.zip

4.datetime模块

获取时间

from datetime import datetime,timezone,timedelta
val = datetime.now()
print(val)#获取当前本地时间

val2 = datetime.utcnow()#当前UTC时间(零时区)

tz = timezone(timedelta(hours=7))
v3 = datetime.now(tz)#获取东7区时间

字符串时间和datetime时间之间的转换

意义：方便计算机计算，例如四十天后是几月几日等，通过time就难以做到

v1 = datetime.now()
v2 = v1.strftime("%Y-%M-%d %H:%M:%S")#拿出其中的年和月转换成字符串
--------------反向转换-----------------
v1 = datetime.strptime(‘2011-11-11‘,‘%y-%m-%d‘)
print(v1) #反转的意义：方便计算机计算，例如四十天后是几月几日等
v2 = v1 +timedelta(days=40 ) #加40天的操作

时间戳和datetime的关系

import time
ctime = time.time() #创建一个时间戳，指从1970年到现在的秒数

datetime.fromtimestamp(ctime) #把以秒计的时间戳转化为datetime格式

异常处理语法

在程序执行中加入语法，使得程序不会报错

try:
    val = input("输入数字")
    num = int(val)
except Exception as e:
    print(‘操作异常‘)

原本输入数字以外的东西就会报错，加入这个语法后可以确保程序继续执行

迭代器

1迭代器基础

• 迭代器不用自己写，需要了解、会用
• 迭代器，帮助你对某种对象(str/list/tuple/dict/set类创建的对象)中的元素进行逐一获取
• 迭代完就会报错，可以用上面的异常处理语法进行处理
• 迭代器本身不储存值，每次都不停的调用
• 如何判断一个对象是否是迭代器：看内部是否有__next__功能，可以被for循环的也是可迭代对象
• 常用的for循环内部其实就是迭代器

v1 = [11, 22, 33, 44] #先定义一个列表

v2 = iter(v1) #把v1变成迭代器
v1 = [11, 22, 33, 44].__iter__()#和上排代码作用相同


result1 = v2.__next__() #第一次迭代，取到11
result2 = v2.__next__() #第二次迭代，取到22

2生成器(函数的变异)

• 函数中如果存在yield，那么该函数就是一个生成器函数，只有被for循环时，生成器函数才会被执行，碰到yield就终止当此循环，return一个yield后面的值

#函数
def func():
    return 123
func()

#生成器函数(内部是否有yield)
def func():
    arg = arg +1
    yield 1
    yield 2
    yield 100

#函数内部代码不会执行，返回一个生成器对象
v1 = func(2000)

#生成器可以被for循环，一旦开始循环，那么函数内部代码就会开始执行
for item in v1： #这下func函数才开始执行，每循环一次， 就把一行yield的值return出来

python3.3之后的新功能：yield from 语句

def func1():
    yield 11
    yield from func2()
    yield 22
    yield 33

def func2():
    yield "XX"

for i in func1():
    print(i) #这样打印11，过后会进入到func2函数中，然后继续22、33

面向对象 ：封装、继承、多态

1.基本格式

class 类名：
	def 方法1(self,name):
    	print(name)
    def 方法2(self,age):
    	print(age)
    def 方法3(self,sex):
    	print(sex)
    def 方法4(self,job):
    	print(job)
  #相当于把函数分成不同类别

#然后创建该类对象
obj = 类名() #也叫实列化

#调用方法
obj.方法1(‘ran’)

应用场景：遇到很多函数，需要对函数归类划分

2.对象的作用

封装在里面，可以有自己的值供自己调用

3.初始化

在命名class后，可以加入初始化函数。 作用为当实列化这个class的时候，会自动执行初始化函数

#首先命名一个类
class 类名： 
	def __init__(self):
        print(‘初始化完成‘)
        
#实列化这个类
类名()
or
p1 = 类名()

#这样__init__(self)函数会自动执行

4.总结

4.1什么时候使用面向对象？

• 如果写代码时，函数比较多比较乱，可以将函数归类，放到同一个class中、
• 函数如果有一个重复使用的公共值，则可以放到对象中，避免重复传递(用init初始化功能)

5.继承

创建父类，子类，在执行对象时，优先在自己的类中找，如果没有就去父类中找

#父类or基类
class Base:
    def f1(self):
        pass

#子类or派生类
class Foo(Base):#如果此处继承了2个类，那么从左到右依次找
    def f2(self):
        pass
    
    
#实列化子类
obj = Foo()
obj.f1()#现在自己中寻找f1，找不到再去父类中寻找
#如果执行父类，是不会去子类中寻找的

注意事项：

• self到底是谁？
• self是哪个类创建的，就从此类开始找，自己没有就找父类

6.多态(多种形态/多种类型/鸭子模型)

对于一个函数而言，python对于参数的类型不会限制，那么传入的可以是各种类型，但是在函数中如果有arg.send方法，那么就是对于传入类型的一个限制(类型必须有send方法)。

def func(arg):
    v = arg[1] #这时候arg可以是多种类型
    arg.append(2) #这个时候arg就必须是支持append的类型

Python函数与装饰器入门二

原文：https://www.cnblogs.com/buono/p/12715101.html