【Python】0基础学Python——函数参数传递、函数细分、类的信息、元类、自定义元类、pickle序列化、序列化升级

函数参数传递

参数传递

不可变类型: 值传递(深拷贝)
可变类型: 引用传递(浅拷贝)

类型标注

基本类型： int float bool None bytes Any
引用类型: from typing import
List,Tuple,Set,Dict,
Union[int,str]:混合数据类型
Iterable: 可迭代对象
Callable: 函数，可调用
Any:任意类型

from typing import List, Tuple, Set, Dict, Union, Iterable, Callable, Any


def fn(it: Iterable, task: Callable, hh: bytes, any: Any) -> str:
    pass


def test(n) -> Union[str, int, Callable]:
    n += 1
    return n


a = 10
test(a)
print(a)  # 10


def test2(ls):
    ls[0] += 1
    return ls


l = [10, 20, 30]
test2(l)
print(l[0])  # 11

函数细分

根据参数和返回值进行函数分类:
任务型函数: 没有参数，没有返回值
消费型函数: 有参数，没有返回值
生产型函数: 没有参数，有返回值
功能型函数: 有参数，有返回值
断言型函数：一种特殊的功能型函数，返回的是bool类型

task任务型函数

# 写一个函数执行某个任务
# task:任务型函数
def fn(task: Callable):
    task()


fn(lambda: print('喵喵'))  # 喵喵
fn(lambda: print('汪汪'))  # 汪汪

consumer消费型函数

# 写一个函数用来消费列表中的数据
# consumer:消费型函数
def consumer(ls, consumer: Callable):
    for item in ls:
        consumer(item)


l = [10, 20, 30]
consumer(l, lambda item: print(item * 2))
consumer(l, print)

functional功能型函数

# 定义 map_ls 返回新的处理后的列表   [1,2,3]=>[2,4,9]  [1,2,3]=>[11,12,13]
# functional:功能型函数
def map_ls(ls, function: Callable):
    # nls = []
    # for item in ls:
    #     res = function(item)
    #     nls.append(res)
    # return nls
    return [function(item) for item in ls]


print(map_ls(l, lambda item: item * 2))
print(map_ls(l, lambda item: item + 66))

类的信息

class Person:
    """
        -----类注释-----
    """
    PI = 3.14

    def __init__(self, name):
        self.name = name

    def __str__(self):
        return f'{self.name}'

    def eat(self):
        return f'{self.name}在偷吃'


p = Person('张三')
print(p.eat())

# 查看对象所有信息
print(p.__dict__)  # 属性字典信息  # {'name': '张三'}

# 查看类的信息
print(Person.__doc__)  # 查看类注释  # -----类注释-----
print(Person.__name__)  # 查看类名  #Person
print(Person.__class__)  # 查看类的类型  # <class 'type'>
print(Person.__dict__)  # 类的成员组成的字典
print(Person.__bases__)  # 父类元组  # (<class 'object'>,)

元类

万物皆为对象，类也是个对象，类也有所属类型
type(元类)：类的类型，创建类的
type的类型还是type
type的父类是object

class Person:
    """
        -----类注释-----
    """
    PI = 3.14

    def __init__(self, name):
        self.name = name

    def __str__(self):
        return f'{self.name}'

    def eat(self):
        return f'{self.name}在偷吃'


p = Person('张三')
print(p.eat())
print(type(10))  # <class 'int'>
print(type(p))  # <class '__main__.Person'>
print(p.__class__)  # <class '__main__.Person'>
print(type(Person))  # <class 'type'>
print(Person.__class__)  # <class 'type'>
print(type(type))  # <class 'type'>

type作用

1.判断数据的类型
2.创建一个新的类型(类)
3.拦截类的信息，修改类的创建过程

# type('类型',父类元组,类成员字典)
myclass = type('Person', (object,), {
    'PI': 3.14,
    '__init__': lambda self, name: setattr(self, 'name', name),
    '__doc__': '-----类注释-----',
    'eat': lambda self: print(f'{self.name}在偷吃')
})
# myclass是别名
print(myclass.__name__)  # Person
zs = myclass('张三')
zs.eat()  # 张三在偷吃
print(zs.PI, zs.name, zs.__doc__)  # 3.14 张三 -----类注释-----
print(lambda item: item % 2 == 0)
ls = [1, 2, 3, 4, 1, 2]
for index in range(len(ls)):
    if ls[0] < 3:
        ls.pop(0)
    else:
        break
print(ls)

自定义元类

元类(type)：类的类型
作用:
1.type(val) 获取数据类型
2.创建类
3.自定义元类，拦截类的信息,改变类的创建过程

class A:
    pass


# 自定义元类,需要继承type
class MyType(type):
    # args[0]: 父类元组列表
    # args[1]:类成员字典
    def __new__(cls, *args, **kwargs):
        args = list(args)
        # print(args)
        args[0] = 'MyType'  # 修改类名
        args[1] = (A,)  # 修改父类元组列表
        args[2]['__doc__'] = '修改类注释'
        args[2]['show'] = lambda self: print('添加类方法')
        return type(args[0], args[1], args[2])


class Person(object, metaclass=MyType):
    """
        Person--类注释
    """
    PI = 3.14

    def __init__(self, name):
        self.name = name


print(Person.__dict__)
print(Person.__doc__)  # 修改类注释
print(Person.__bases__)  # (<class '__main__.A'>,)
print(Person.__name__)  # MyType
p = Person('张三')
p.show()  # 添加类方法

pickle序列化

json:跨平台，适用于不同语言，序列化为字符串， 公开传输
pickle: python专用， 序列化为二进制， 不公开传输，可以序列化自定义的对象

序列化

import pickle

datas = [{'name': '张三', 'age': 20}, {'name': 'mary', 'age': 30}]


b = pickle.dumps(datas)
print(b)  # 字节

反序列化

print(pickle.loads(b))  # [{'name': '张三', 'age': 20}, {'name': 'mary', 'age': 30}]

with open('./datas.txt', 'wb') as f:
    pickle.dump(datas, f)

with open('./datas.txt', 'rb') as f:
    # print(pickle.load(f))  # [{'name': '张三', 'age': 20}, {'name': 'mary', 'age': 30}]
    print(pickle.load(f)[0])  # {'name': '张三', 'age': 20}

序列化升级

pickle可以直接序列化自定义对象
pickle反序列化的结果任然是对象

import json
import pickle
from json import JSONEncoder, JSONDecoder


class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age


datas = [Student('张三', 18), Student('李四', 28)]

# pickle可以直接序列化自定义对象
s = pickle.dumps(datas)
print(s)
# pickle反序列化的结果任然是对象
s1 = pickle.loads(s)
print(s1)
# print(s1[0].__dict__)  # {'name': '张三', 'age': 18}


# json序列化自定义对象
# s = json.dumps(datas, ensure_ascii=False, default=lambda o: {'name': o.name, 'age': o.age})
s = json.dumps(datas, ensure_ascii=False, default=lambda o: o.name)
print(s)  # ["张三", "李四"]

class MyJSONEncoder(JSONEncoder):
    def default(self, o):
        return {'name': o.name, 'age': o.age}


s = json.dumps(datas, ensure_ascii=False, cls=MyJSONEncoder)
print(s)


class MyJSONDecoder(JSONDecoder):
    def decode(self, s):
        s = json.loads(s)
        return [Student(item.get('name'), item.get('age')) for item in s]


b = json.loads(s, cls=MyJSONDecoder)
print(b)
print(b[0].__dict__)  # {'name': '张三', 'age': 18}
print(b[0].name)  # 张三