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) # 张三