python 计算列表相邻数据的差值

1. 集合
1.1 集合简介
集合表现形式 set集合和列表⾮常相似
不同点:
集合只能存储不可变对象
#存储不可变对象
s={[1,2,3],[4,5,6]}
print(s,type(s))$TypeError: unhashable type: 'list'
集合中存储的对象是⽆序的
#存储对象是无序的
s={1,5,3,4}
print(s,type(s))#{1, 3, 4, 5} 
集合不能出现重复元素
#集合中不能出现重复的元素
s={1,5,3,4,4,4,4}
print(s,type(s))#{1, 3, 4, 5} 
使⽤{}来创建集合
#创建集合{}
s={1,2,3,4}
print(s,type(s))#{1, 2, 3, 4} 
注意：
s={}
print(s,type(s)) #{} 字典
可以通过set()来将序列和字典转换成集合
s=set()
print(s,type(s))#set() 
#可以通过序列转化为集合
s=set([1,2,3,4,5,12,3,1])
print(s,type(s))#{1, 2, 3, 4, 5, 12} 
s=set('python')
print(s,type(s))#{'h', 't', 'y', 'n', 'p', 'o'} 
s=set({'a':1,'b':2}) #使用set()函数将字典转化为集合，只包括字典的键key
print(s,type(s))#{'b', 'a'} 
#索引
# s={'a','b',1,2,3}
# print(s[0])#TypeError: 'set' object does not support indexing
s={'b','a',1,2,3}
print(list(s)[1])#1(一般不一样)
len() 使⽤len()来获取集合中元素的数量
# 创建一个集合
s = {'a','b',1,2,3}
#in 和 not in来检查集合中的元素
print('b' in s) #True
#
# # len() 获取集合的长度或者元素的数量
print(len(s)) #5
add()像集合中添加元素
# 创建一个集合
s = {'a','b',1,2,3}
# # add() 向集合中添加元素
s.add(20)
print(s)#{1, 2, 3, 'a', 20, 'b'}
s.add(50)
print(s)#{1, 2, 3, 'a', 50, 20, 'b'}
update()将⼀个集合中的元素添加到另⼀个集合当中
s = {'a','b',1,2,3}
s2 = set('hello')
#
s.update(s2)
print(s)#{1, 2, 3, 'l', 'e', 'o', 'h', 'a', 'b'}
#
pop()随机删除集合中的⼀个元素⼀般是删除最后⼀个元素
s = {'a','b',1,2,3}
#pop() 随机删除集合中的一个元素 返回值(删除的元素)
result = s.pop()
print(result)#1
remove() 删除集合中指定的元素
s = {'a','b',1,2,3}
s.remove(2)
print(s)#{1, 'b', 3, 'a'}
clear() 清空集合
s = {'a','b',1,2,3}
#clear() 清空集合
s.clear()
print(s)#set()
1.2 集合的运算
& 交集运算
s1={1,2,3,4,5}
s2={4,5,6,7,8}
#交集
result=s1&s2
print(s1,s2,result) #{1, 2, 3, 4, 5} {4, 5, 6, 7, 8} {4, 5}
#==================
| 并集运算
s1={1,2,3,4,5}
s2={4,5,6,7,8}
result=s1|s2
print(s1,s2,result)#{1, 2, 3, 4, 5} {4, 5, 6, 7, 8} {1, 2, 3, 4, 5, 6, 7, 8}
#=====================
- 差集运算
s1={1,2,3,4,5}
s2={4,5,6,7,8}
result1=s1-s2
print(result1)#{1, 2, 3}
result2=s2-s1
print(result2)#{8, 6, 7}
#=====================
^ 亦或集
s1={1,2,3,4,5}
s2={4,5,6,7,8}
result=s1^s2
print(result)#{1, 2, 3, 6, 7, 8}
<= 检查⼀个集合是否是另⼀个集合的⼦集
a={1,2,4}
b={1,2,3,4,5}
result=a<=b#a集合为b集合的子集 b集合是a集合的超集
print(result)#True
< 检查⼀个集合是否是另⼀个集合的真⼦集
a={1,2,4}
b={1,2,3,4,5}
result=a
print(result)#True
>=检查⼀个集合是否是另⼀个集合的超集
>检查⼀个集合是否是另⼀个集合的真超集
2.函数(一)
2.1 函数简介
函数也是一个对象
函数用来保存一些可执行的代码，并且可以在需要时，对这些语句进行多次调用
语法：
def 函数名([形参1,形参2,形参3....]):
代码块
调用几次执行几次
#函数中的代码不会立即执行，需要调用才会执行
def fn():
print('这是我的第一个函数')
print(fn) #内存地址
#调用几次执行几次
fn()#这是我的第一个函数
fn()#这是我的第一个函数
#fn()函数对象 fn()调用函数

注意：
函数名必须符合标识符的规范(可以包含字母、数字、下划线但是不能以数字开头)
print是函数对象 print()是调用函数
2.2 函数的参数
2.2.1 形参和实参
#函数的参数
#定义一个函数 来求任意两个函数的和
def s():
print(1+2)#3
s()
def s():
a=1
b=2
print(a+b)#3
s()
• 形参(形式参数) 定义形参就相当于在函数内部声明了变量，但是并不是赋值
• 实参(实际参数)指定了形参，那么在调用函数时必须传递实参，实参将会赋值给对应的形参，简单来说有几个形参就要有几个实参
函数的参数
#在定义函数的时候，可以在函数后面()中定义数量不等的形参 多个形参之间用逗号隔开
def s(a,b):
a=None
b=None
print(a+b)#少了两个实际的参数(实参)TypeError: s() missing 2 required positional arguments: 'a' and 'b'
s()
def s(a,b):
print('a=',a)#a= 1
print('b=',b)#b= 2
print(a,'+',b,'=',a+b)#1 + 2 = 3
s(1,2)
2.2.2 函数的传递方式
• 定义形参时,可以为形参指定默认值。指定了默认值以后，如果用户传递了参数则默认值不会生效。如果用户没有传递，则默认值就会生效
• 位置参数：位置参数就是将对应位置的实参赋值给对应位置的形参
#函数的传递方式
#定义形参是可以为形参指定默认值
#如果用户传递参数，默认值不会生效
#位置传参
def fn(a,b,c=20):
print('a=',a)
print('b=',b)
print('c=',c)
fn(1,2,3)
#a=1
#b=2
#c=3
#用户没有传递参数，默认值会生效
def fn(a,b,c=20):
print('a=',a)
print('b=',b)
print('c=',c)
fn(1,2)
#a=1
#b=2
#c=20
• 关键字参数 : 关键字参数可以不按照形参定义的顺序去传递，而根据参数名进行传递
#关键字传参
def fn(a=10,b=30,c=20):
print('a=',a)
print('b=',b)
print('c=',c)
fn(b=1,c=2,a=3)
#a=3
#b=1
#c=2
• 混合使用位置参数和关键字参数的时候必须将位置参数写到关键字参数前面去
#两者可以混合使用 但位置传参必须在关键字传参之前
def fn(a=10,b=30,c=20):
print('a=',a)
print('b=',b)
print('c=',c)
fn(2,c=50)
#a=2
#b=30
#c=50
fn(c=2,50) #SyntaxError: positional argument follows keyword argument
实参的类型
实参的类型
def fn2(a):
print('a=',a)#a= 123
b=123
fn2(b)
def fn():
print('这是我的第一个函数')
print(fn) #内存地址
def fn2(a):
print('a=',a)#a= 
fn2(fn)
def fn3(a,b):
print(a+b)#3
fn3(1,2)
#在函数中对形参赋值，不会影响其他变量
#================
#id改变(改变量)
def fn4(a):
a=20
print('a=',a,id(a)) #a= 20 1445364432
c=10
fn4(c)
print('c=',c,id(c))#c=10 1445364112
#================
#id不改变(改对像的值)
def fn4(a):
a[0]=20
print('a=',a,id(a)) #a= [20, 2, 3] 1554237875784
c=[1,2,3]
fn4(c)
print('c=',c,id(c))#c= [20, 2, 3] 1554237875784
#================
#id改变
def fn4(a):
a=[4,5,6]
print('a=',a,id(a)) #a= [4, 5, 6] 2097466238536
c=[1,2,3]
fn4(c)
print('c=',c,id(c)) #c= [1, 2, 3] 2097466237896
#================
#id改变
def fn4(a):
a[0]=20
print('a=',a,id(a)) #a= [20, 5, 6] 1864612308744
c=[1,2,3]
fn4(c.copy())
print('c=',c,id(c)) #c= [1, 2, 3] 1864612308552
#================
#id改变
def fn4(a):
a[0]=20
print('a=',a,id(a)) #a= [20, 5, 6] 2176056813320
c=[1,2,3]
fn4(c[:])
print('c=',c,id(c)) #c= [1, 2, 3] 2176056813128
2.3. 不定长参数
• 定义函数时，可以在形参前面加一个 * ,这样这个形参可以获取到所有的实参，它会将所有的实参保存到一个元组中
def fn(*a):
print('a=',a,type(a))#a= () 
fn()

def s(*a):
# 定义一个变量 保存结果
result = 0
# 遍历元组，将元组中的元素进行累加
for r in a:
result += r
print(result)#572
s(12,560)
• 带号的形参只能有一个，可以和其他参数配合使用


**不定长参数不一定都要写在后面，但是注意 带的参数后面的所有参数，必须以关键字形式来传递**
def fn2(a,*b,c):
# TypeError: fn2() missing 1 required keyword-only argument: 'c' 计算机不知道怎么分配
print('a =', a)
print('b =', b)
print('c =', c)
fn2(1,2,3,4,5)

def fn2(*a,b,c):
#TypeError: fn2() missing 2 required keyword-only arguments: 'b' and 'c'
print('a =', a)
print('b =', b)
print('c =', c)
fn2(1,2,3,4,5)
#========================
def fn2(*a,b,c):
print('a =', a)#a = (1, 2, 3)
print('b =', b)#b=4
print('c =', c)#c=5
fn2(1,2,3,b=4,c=5)
• *形参只能接受位置参数，不能接受关键字参数
def fn3(*a):
#TypeError: fn3() got an unexpected keyword argument 'b'
print('a =', a)
fn3(b=2,d=1,c=3)
• **形参可以接收其他的关键字参数,它会将这些参数统一保存到字典当中。字典的key就是参数的名字,字典的value就是参数的值
• **形参只有一个，并且必须写在所有参数的后面
def fn3(**a):
print('a =', a)
#a = {'b': 2, 'd': 1, 'c': 3}
fn3(b=2,d=1,c=3)
*a 处理的是位置参数 **a 是处理的是关键字参数
2.4. 参数的解包

def fn(a,b,c):
print('a =', a) #a=20
print('b =', b)#b=30
print('c =', c)#c=40
# 创建一个元组
t = (20,30,40)
fn(t[0],t[1],t[2])
• 传递实参时，也可以在序列类型的参数前添加星号，这样它会自动的将序列中元素依次作为参数传递
def fn(a,b,c):
print('a =', a) #a=20
print('b =', b)#b=30
print('c =', c)#c=30
# 创建一个元组
t = (20,30,40)
# 传递实参时候，也可以在序列类型的参数前面添加*号，这样它会自动的将序列三种的元素依次作为参数传递
fn(*t)
#====================
# 创建一个字典
# 可以通过**来对字典进行解包
d = {'a':1,'b':2,'c':3}
fn(**d)
#a = 1
#b = 2
#c = 3
• 要求序列中的元素的个数必须和形参的个数一致
def fn(a,b,c):
print('a =', a)
print('b =', b)
print('c =', c)
# 创建一个元组
t = (20,30,40,50)
#TypeError: fn() takes 3 positional arguments but 4 were given
fn(*t)
后期经过第二次解包