python总结(数据类型、逻辑控制、函数、类与对象、推导式、解包、类型转换、异常、上下文、jsonpath、定时器)

'''使用python3.6以上版本才有数据类型定义    '''
import math  #数学函数
i:int=1
f:float=1.22
s:str='字符串'
print(f'{i,f,s}')
'''int和float转化'''
#整数转小数
print(float(i))
#四舍五入保留2位小数
print(round(3.526,2))
#向下取整
print(math.floor(3.526))
#向上取整
print(math.ceil(3.526))
#将整数和小数分开打印输出，格式元组
print(math.modf(3.526))
'''数字类型和str'''
#只有字符串里面的数据类型是数字类型或者浮点型类型就可以用对应的方法转化
print(int('12'))
print(float('12.1'))

# # 定义
dict1 = {'key': 'value'}
d = dict(name='Bob', age=20, score=88)
print(dict1)
# 取值
print(dict1['key'])
# 增加
dict1['cc'] = 22
# 修改
dict1['cc'] = 33
# 删除
del dict1['cc']
# 清空字典的值
dict1.clear()
print(dict1)
# update方法  存在就修改，不存在则删除
dict1.update({1: 1, 2: 2})
dict1.update({1: 1.0, 3: 3})
print(dict1)
# pop方法：删除指定的键值对并返回值
print(dict1.pop(2))
print(dict1)
# 遍历键值对
dict2 = {1: 1, 2: 2}
for k, v in dict2.items():
    print(k, v)
if 'kk' not in d:
    print('kk不在字典d中')
    d.update({'kk': 99})
    if d.pop('kk') == 99:
        print('kk被新增了，但是又被我干掉了')

# 定义
list1 = [1, "2", "进阶"]
print(list1)
# 嵌套
list2 = [1, "2", "进阶", [1, 2]]
print(list2)
# 取值(细节)
list3 = ['c', 'a', 'd', 'g']
print(list3[1])  # 取索引为1的值，结果为字符串 'a'
print(list3[1:2])  # 取索引为1的值，结果为列表 ['a']
# 增删改查拼乘
list4 = ['c+'] + ['+']
print(list4)
list5 = ['2', '1', 2, 4, "dd"]
print(list5 * 3)
# 新增 末尾新增
list5.append(1)
print(list5)
# insert(index, x)在列表lst指定位置index处添加元素x，该位置后面的所有元素后移一个位置
list5.insert(1, 'xl')
# pop方法 删除并返回列表lst中下标为index（默认为-1）的元素
list5.pop()
list5.pop(0)
print(list5)  # ['1']
# index()方法 返回列表lst中第一个值为x的元素的下标，若不存在值为x的元素则抛出异常
print(list5.index(2))
# count(x) 统计元素出现的次数
print(list5.count(1))
print(list5)
# reverse() 对列表lst所有元素进行逆序
list5.reverse()  # 这个运行结果没有返回值
print(list5)
print(list5[::-1])  # 这个是有返回值，其实是取值
'''写个方法 校验列表是否有相同的元素'''
def chan(l):
    for i in l:
        if  l.count(i)>1:
            return i

# 定义
'''
集合：
    无序，没有索引
    不支持数据重复
'''
set1 = {1, 2, 3, 4, 1, "5"}
print(set1)  # {1, 2, 3, 4, '5'} 重复之会出现一个
# 集合特殊操作
# 去除指定的元素
print({1, 2, 3, 4, 5} - {1, 2})
# 找到指定元素相同的元素
print({1, 2, 3, 4, 5} & {1, 2})
# 合并去重
print(({1, 2, 3, 4, 5} | {3, 5, 6, 7}))
# 定义一个空的集合
print(type(set()))  # <class 'set'>
print(type({}))  # <class 'dict'>

# 定义
str1 = '1jaskj'
# 切片操作         结果
'''
字符串[开始索引：结束索引：步长]
切取字符串为开始索引到结束索引-1内的字符串(取头不取尾)
步长不指定时步长为1 字符串[开始索引:结束索引]
'''
print(str1[0])  # 1
print(str1[-1])  # j
print(str1[1:3])  # ja
# 翻转
print(str1[::-1])  # jksaj1
a='a\a\a\a'
#原生字符串，不会被里面的转义所影响
b=r'a\a\a\a'

# 定义
tuple1 = (1, "2", "进阶")
print(tuple1)
# 嵌套
tuple2 = (1, "2", "进阶", (1, 2))
print(tuple2)
# 取值(细节)
tuple3 = ('c', 'a', 'd', 'g')
print(tuple3[1])  # 取索引为1的值，结果为字符串 'a'
print(tuple3[1:2])  # 取索引为1的值，结果为列表 ('a',)，会有个逗号
print(tuple3[1:3])  # 取索引为1和2的值，结果为列表 ('a', 'd')
# 定义只有一个元素的元组
print((1))  # 这是'1'
print((1,))  # 这是元组(1,)
'''神奇'''
a = {1: 1},
print(type(a))  # <class 'tuple'>  a也是元组
b = [1, 2],
print(type(b))  # <class 'tuple'>  b也是元组

print(1 in[1,'2m'])      #True
print(1 not in[1,'2m'])  #False
#这样只能判断字典的key 是不是存在
print('c' in {'c':1}) #True
print(1 in {'c':1})  # False

# 比较运算符返回布尔值
print(1 == 1)  # True
print(1 >= 1)  # True
print(1 <= 1)  # True
print(1 > 1)  # False
print(1 < 1)  # False
print(1 != 1)  # False
b = 1
b += b >= 1
print(b>=1) #True
print(int(True)) #结果为1
print(b) #结果为2

# 加减乘除
print(1 + 1)
print(1 - 1)
print(1 * 1)
print(4 / 2)  # 2.0
# 取余
print(7 % 2)  # 1
# 多次方
print(2 ** 2)  # 4
print(2 ** 5)  # 32

'''
总结：
    对象的三个特征 id value type
    只有三个特征都相等时 使用 is 的结果才为True
    而使用==时只需要value的结果就是True
'''
# 基本使用
print(1 is 1)  # True
print(1 is not 2)  # True
print('1' is 1)  # False
# ==和is区别
print(1 is 1.0)  # False
print(1 == 1.0)  # True
print(1 == True)  # True
print(1 is True)  # False
a = {1, 2, 3}
print(id(a))  # 2257202349000
b = {1, 3, 2}
print(id(b))  # 2257200217896
print(a == b)  # True
print(a is b)  # False
# 判断数据的类型
print(type(1) == int)  # True
print(isinstance(1, int))  # True
print(isinstance("2", str))  # True
print(isinstance(1, (int, str, float)))  # True
print(isinstance({1: 1}, (int, str, float)))  # False

print(True and True)
print(False and True)
print(False and False)
print(True or True)
print(False or True)
print(False or False)

'''
非0和非空（null）值为true，0 或者 null为false。
'''
if 0:  # if false 不满足无法打印
    print('0为false')
if None:  # if false 不满足无法打印
    print('表达式为None')
if 1:  # if true 满足打印
    print('非0为true')
if '1':  # if true 满足打印
    print('表达式为非空')
a=3
if a==1:
    print('a=1')
elif a==2:
    print('a=2')
else:
    print('a==0')
a=2
print(a)

'''几次常规用法'''
for i in range(1,4):#从1开始  1 2 3
    print(i)
for i in range(4): #从0开始 0 1 2 3
    print(i)
a=[1,2,3,'ll','24']
for i in a: #遍历每个列表元素
    print(i)
b={'k1':'v1','k2':'v2','k3':'v3'}
for i in b.keys(): #遍历字典键
    print(i)
for i in b.values(): #遍历字典值
    print(i)
for k,v in b.items(): #键值对一起遍历
    print(k,v)

import random
a=1
while a<3:
    print('进来时a={}'.format(a))
    a+=1
    print('出去时a={}'.format(a))
print('循环运行完的a={}'.format(a))
count=0
while a<=7:
    count+=1
    a+=random.randint(2,9)
else:
    print('a运行了{}次就大于7了，a={}'.format(count,a))

'''
break是直接结束当前循环
continue是结束当前循环的剩余语句进行下一论的循环
continue 语句是一个删除的效果，他的存在是为了删除满足循环条件下的某些不需要的成分
'''
for i in 'py1thon':
    if i == '1':
        break
    print(i)
print('-------------------------------------')
for i in 'py1thon':
    if i == '1':
        continue
    print(i)
print('-------------------------------------')
# 冒泡排序 ：左右比较并互换位置
a = [2, 1, 4, 6, 2, 3, 5, 9, 7]
# print(len(a))  # 9
for i in range(len(a)-1):
    for j in range(len(a)-1):
        if a[j] >= a[j + 1]:
            #互换之术
            a[j],a[j+1]=a[j+1],a[j]

'''
默认参数:
它是如何工作的
名为 func 的函数有一个没有默认参数值的参数，后跟两个各自带有默认参数值的参数。
在第一次调用python函数时，func(3, 7)，参数 a 获得了值 3，参数 b 获得了值 7，而 c 获得了默认参数值 10。
在第二次调用函数时，func(25, c=24)，由于其所处的位置，变量 a 首先获得了值 25。然后，由于命名——即关键字参数——指定，变量 c 获得了值 24。变量 b 获得默认参数值 5。
在第三次调用函数时，func(c=50, a=100)，我们全部使用关键字参数来指定值。在这里要注意到，尽管 a 在 c 之前定义，但我们还是在变量 a 之前指定了变量 c。
'''
def sum(a, b=1):
    return a + b
print(sum(1))
def func(a, b=5, c=10):
    print(a, b, c)
func(3, 7)
func(25, c=24)
func(c=50, a=100)
def t(a,*b,c=2):
    print(a)
    print(b)
    print(c)
t(1,2,1,c=5)
'''
结果
1
(2, 1)
5
'''

def aa():
    a=1
    b=2
    #这种返回是返回一个元组 (1, 2)
    # return a,b
    #也可以用字典访问
    return {'a':a,'b':b}
a=aa()
print(type(a))
def bb():
    c=2
    d=4
    return c,d
'''还可以这样访问使用函数返回的2个参数'''
c,d=bb()
print(c,d)

'''lambda 匿名函数用法 add和add1 实现的是一样的功能'''
def add(x, y):
    return x+ y
print(add(3,4))
add1 = lambda x,y:x+y
print(add1(3,4))
#输入一个int，返回一个列表
ge=lambda a : [int(a),str(a)]
l=ge(1)
print(l) #[1, '1']

d=1,2,3
print(d) #元组(1, 2, 3)
'''a,b=[1,2,2] 需要一一对应，不管是1,2,3，[1,2,3]，(1,2,3)都需要一一对应'''
a,b,c=1,2,3
print(a,b,c) #1 2 3
a,b,c=[1,2,3]
print(a,b,c) #1 2 3
print(type(a)) #<class 'int'>
a,b,c=(1,2,3)
print(a,b,c) #1 2 3
print(type(a)) #<class 'int'>
a=b=c=1 #1 1 1
print(a,b,c)
c=2
print(a,b,c) #1 1 2

'''要调用这个方法后才能使用这个函数里面的局部变量，感觉不好用'''
def text():
    global add
    add= "http://c.biancheng.net/java/"
    print("函数体内访问：",add)
text()
print('函数体外访问：',add)

class Person:
    role = 'person'
    def __init__(self, name, attack, hp):
        self.name = name
        self.attack = attack
        self.hp = hp
    def hit(self, dog):
        # self 代表人类的对象，dog代表狗类的对象
        dog.hp -= self.attack
class Dog:
    role = 'dog'
    def __init__(self, name, breed, attack, hp):
        self.name = name
        self.breed = breed  # 品种
        self.attack = attack
        self.hp = hp
    def bite(self, person):
        # self 代表狗类的对象，person代表人类的对象
        person.hp -= self.attack
# 实例一个人和一只狗
xiao_wang = Person('小王', 10, 1000)
re_ha = Dog('二哈', '哈士奇', 3, 500)
# 开打前双方血量展示
print('小王的血条={}'.format(xiao_wang.hp))
print('二哈的血条={}'.format(re_ha.hp))
#小王的血条=1000
#二哈的血条=500
#攻击开始
'''小王连续踢了三下狗'''
for i in range(3):
    xiao_wang.hit(re_ha)
'''二哈咬了一下小王'''
re_ha.bite(xiao_wang)
# 打完后双方血量展示
print('小王的血条={}'.format(xiao_wang.hp))
print('二哈的血条={}'.format(re_ha.hp))
#小王的血条=997
#二哈的血条=470

class A:
    '''私有属性和方法只能在类内部使用'''
    __x = 1
    y = 2
    def __gai_y(self):
        self.y += 1
    def du_y(self):
        print('y的值为{}'.format(self.y))
    def test(self):
        self.__gai_y()
        print(self.__x)
# a=A()
# a.test()
# a.du_y()
# print(a.y)
##虽然是私有属性、方法，但是还是可以通过类名和方法(变量)名来访问的，不建议使用
# print(a._A__x)
#a._A__gai_y
class B(A):
    '''继承的类不能使用父类的私有属性和方法'''
    __b='b'
    bb='bb'
    def b1(self):
        print(self.__b)
        # print(A.__x) 会报错
b=B()
b.b1()

'''从实现角度来看，抽象类与普通类的不同之处在于：抽象类中有抽象方法，该类不能被实例化，只能被继承，且子类必须实现抽象方法'''
import abc #利用abc模块实现抽象类
class All_file(metaclass=abc.ABCMeta):
    all_type='file'
    @abc.abstractmethod #定义抽象方法，无需实现功能
    def read(self):
        '子类必须定义读功能'
        pass
    @abc.abstractmethod #定义抽象方法，无需实现功能
    def write(self):
        '子类必须定义写功能'
        pass
class Txt(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('txt文本数据的读取方法')
    def write(self):
        print('txt文本数据的写入方法')
class Execl(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('execl文本数据的读取方法')
    def write(self):
        print('execl文本数据的写入方法')

from math import pi
class G:
    '''@property 直接把方法的返回值当作一个属性值，存储在属性名为当前方法名的属性里面，可以通过对象.之间访问'''
    def __init__(self,r):
        self.r=r
    @property
    def area(self):
        return  self.r**2*pi
g=G(2)
print(g.area)
class Method:
    '''类方法可以之间类来调用，而实例方法需要用对象来调用'''
    a=1
    @classmethod
    def test_cls(cls):
        print('类方法里使用变量a={}'.format(cls.a))
    def test_self(self):
        print('实例方法里面使用变量a={}'.format(self.a))
    @staticmethod
    def ha():
        '''静态方法里面无法使用self，也无法使用类里面的属性值和方法，只是一个普通的方法挂在这个类下面方便查找'''
        print('打印日志')
me=Method()
me.test_cls()
me.test_self()
Method.test_cls()
# Method.test_self() 会报错
Method.ha()

class A:
    a=1
    def __init__(self,aa,aaa):
        self.aa=aa
        self.aaa=aaa
    def ay(self):
        print('A')
class B(A):
    '''B继承A，B的对象可以调用A和B的属性和方法'''
    def by(self):
        print('B')
# b=B(1,11)
# b.ay()
# b.by()
# print(b.a)
class C(A):
    '''继承父类的构造方法，2种写法，如果继承多个类就不要用super()这种方法了'''
    def __init__(self,aa,aaa,bb):
        # A.__init__(self,aa,aaa)
        super().__init__(aa,aaa)
        self.bb=bb
    def cy(self):
        print('C')
# c=C('aa','aaa','bb')
# c.ay()
# c.cy()
# print(c.aaa)
# print(c.bb)
class D(A):
    '''重写父类方法,方法名相同,如果想使用父类被重新的方法，可以使用super().ay()或者A.ay(self)使用'''
    def dy(self):
        print('D')
    def ay(self):
        print('重新父类方法A-D')
    def ay_A(self):
        A.ay(self)
        super().ay()
# d=D('aa','aaa')
# d.ay()
# d.dy()
# d.ay_A()

'''一个类的属性是另外一个类的对象'''
class Skill:
    def Q(self):
        print('哈撒k')
    def W(self):
        print('风墙')
    def E(self):
        print('踏前斩')
    def R(self):
        print('狂风觉息斩')
class Hero:
    def __init__(self, name):
        self.name = name
        self.skill = Skill()
'''需求：亚索放技能
2Q，EQ双风W接R
'''
ya_sou = Hero('亚索')
ya_sou.skill.Q()
ya_sou.skill.Q()
ya_sou.skill.E()
ya_sou.skill.Q()
ya_sou.skill.W()
ya_sou.skill.R()
'''
圆环是由两个圆组成的，圆环的面积是外面圆的面积减去内部圆的面积。圆环的周长是内部圆的周长加上外部圆的周长。
这个时候，我们就首先实现一个圆形类，计算一个圆的周长和面积。然后在"环形类"中组合圆形的实例作为自己的属性来用
'''
from math import pi
# 圆
class Circle:
    def __init__(self, r):
        self.r = r
    # 周长
    def perimeter(self):
        return 2 * pi * self.r
    # 面积
    def area(self):
        return pi * self.r * self.r
# 圆环
class CircularRing:
    def __init__(self, inside_r, outer_r):
        # 内圈 圆
        self.inside_track = Circle(inside_r)
        # 外圈 圆
        self.outer_ring = Circle(outer_r)
    # 周长 外圈圆的周长+外圈圆的周长
    def perimeter(self):
        return self.inside_track.perimeter() + self.outer_ring.perimeter()
    # 面积 外圈圆的面积-外圈圆的面积
    def area(self):
        return self.outer_ring.area() - self.inside_track.area()
cr = CircularRing(3, 5)
print(cr.perimeter())
print(cr.area())

'''一个类的属性是另外一个类的对象'''
class Skill:
    def Q(self):
        print('哈撒k')
    def W(self):
        print('风墙')
    def E(self):
        print('踏前斩')
    def R(self):
        print('狂风觉息斩')
class Hero:
    def __init__(self, name):
        self.name = name
        self.skill = Skill()
'''需求：亚索放技能
2Q，EQ双风W接R
'''
ya_sou = Hero('亚索')
ya_sou.skill.Q()
ya_sou.skill.Q()
ya_sou.skill.E()
ya_sou.skill.Q()
ya_sou.skill.W()
ya_sou.skill.R()
'''
圆环是由两个圆组成的，圆环的面积是外面圆的面积减去内部圆的面积。圆环的周长是内部圆的周长加上外部圆的周长。
这个时候，我们就首先实现一个圆形类，计算一个圆的周长和面积。然后在"环形类"中组合圆形的实例作为自己的属性来用
'''
from math import pi
# 圆
class Circle:
    def __init__(self, r):
        self.r = r
    # 周长
    def perimeter(self):
        return 2 * pi * self.r
    # 面积
    def area(self):
        return pi * self.r * self.r
# 圆环
class CircularRing:
    def __init__(self, inside_r, outer_r):
        # 内圈 圆
        self.inside_track = Circle(inside_r)
        # 外圈 圆
        self.outer_ring = Circle(outer_r)
    # 周长 外圈圆的周长+外圈圆的周长
    def perimeter(self):
        return self.inside_track.perimeter() + self.outer_ring.perimeter()
    # 面积 外圈圆的面积-外圈圆的面积
    def area(self):
        return self.outer_ring.area() - self.inside_track.area()
cr = CircularRing(3, 5)
print(cr.perimeter())
print(cr.area())

import random
#基本推导
print([i for i in 'dadasd']) #['d', 'a', 'd', 'a', 's', 'd']
# 实现把a列表里面的int类型取出来组成一个新列表b
a = ['1', 2, 'kk', 4, 0]
b = [i for i in a if isinstance(i, int)]
print(b)  # [2, 4, 0]
d1 = {'one': 1, 'two': 2, 'three': 3, 1: 1}
d2 = {i for i in d1}
print(d2)  # {'one', 'three', 'two'}
# 实现把值大于1的键值对组成一个新的字典
d3 = {k: v for k, v in d1.items() if v > 1}
print(d3)  # {'two': 2, 'three': 3}
# 实现字典翻转
d4 = {v: k for k, v in d1.items()}
print(d4)  # {1: 1, 2: 'two', 3: 'three'} 重复的会被去重'one': 1 被 1:1 所取代
# 生成20个学生和学生成绩，找出大于92分的人
d5 = {'li{}'.format(i): random.randint(60, 100) for i in range(20)}
d6 = {k: v for k, v in d5.items() if v >= 90}
print(d6)
# 把学生的名字收集起来
d7 = [i for i in d6]
print(d7)
# 取1到100之间的大于60的偶数
d8 = [i for i in range(1, 101) if i % 2 == 0 and i>=60]
print(d8)

'''*解包 把 oo拆成3个值'''
oo=(1,2,3)
ll=[2,4,6]
def uu(a,b,c):
    print(a,b,c)
uu(*oo) #1 2 3
uu(*ll) #2 4 6
'''**解包 拆解字典解字典为这样的格式 a=1,b=2,c=3，*拆解字典的话只能得到键的值'''
dd={'a':1,'b':2,'c':3}
# 一个星解包字典只会把键拿出来 *dd 就是 'a','b','c'  uu()函数返回结果是 a b c
uu(*dd)
# **dd 相当于 a=1,b=2,c=3 传到uu()函数里面 uu()函数返回结果是 1 2 3
uu(**dd)
'''解包合并字典和列表'''
list1=[1,2,3]
list2=[4,5,6]
print([*list1,*list2])  #[1, 2, 3, 4, 5, 6]
dict1={1:1,2:2}
dict2={3:3,4:4}
print({**dict1,**dict2}) #{1: 1, 2: 2, 3: 3, 4: 4}

'''变量注解    更多详情参考https://www.dusaiphoto.com/article/164/  建议python3.9使用再去参考，现在先就用这些'''
age = 20
print(type(age))
#  <class 'int'>
age = '20'
print(type(age))
#  <class 'str'>
b:int =1
b='2'
#不运行这行代码时不会报错，但是会标记出来
print(b) # 结果是'2' 但是不会报错
# print(b+1) #但是这里就会报错了，在运行代码前看到直接的错误标记并修改可以提前发现问题
a: int = 3
b: float = 3.14
c: str = 'abc'
d: bool = False
'''函数注解 定义函数的返回类型'''
#1.普通参数
def st(s:str) -> str:
    return s+'字符串'
print(st('1'))
#2.对象参数
def hello(p: 'Person') -> str:
    return f'Hello, {p.name}' #f''和format()方法一样的写法
#为了避免类定义在方法定义之后，先用字符把类名包起来
class Person:
    def __init__(self, name: str):
        self.name = name
p=Person('kk')
print(hello(p))

'''列表 和 字符串'''
import random
list1 = [1, '2', 3, 'kk']
print(str(list1))
'''
join()方法 是以字符串里面的内容分割每个列表的元素，然后变为字符串
需要注意的是该方法需要list中的元素为字符型，若是整型，则需要先转换为字符型后再转为str类型
'''
s = "".join([str(i) for i in list1])
print(s)
str1 = 'klo10'
l = list(str1)
print(l)
'''字典 和 字符串'''
d1 = {1: 1, 2: 2}
d2 = str(d1)
print('d2的值{}，类型为{}'.format(d2, type(d2)))  # d2的值{1: 1, 2: 2}，类型为<class 'str'>
'''把d2要重新转化为字典格式直接用dict(d2)是会报错的'''
# print(dict(d2))
d3 = eval(d2)
print('d3的值{}，类型为{}'.format(d3, type(d3)))  # d3的值{1: 1, 2: 2}，类型为<class 'dict'>
'''eval()函数 可以字符里面写表达式储存起来，再用eval()函数使用赋值给变量'''
# 随机文本
random_str = "'测试{}'.format(random.randint(100,99999))"
print(eval(random_str))
'''列表 和 字典'''
list1 = ['1', '2', '3']
list2 = [1, 2, 3, 1]
print('相同长度的列表(多余的会自动干掉)转换为字典（哪个列表在前面就是键）{}'.format(dict(zip(list2, list1))))
'''写个方法，当列表长度不一样是可以自动补充键值'''
def l_d(l1, l2):
    dict2 = {}
    if len(l1) == len(l2):
        for i in range(len(l1)):
            dict2[l1[i]] = l2[i]
        return dict2
    elif len(l1) > len(l2):
        for i in range(len(l1)):
            if i >= len(l2):
                dict2[l1[i]] = None
            else:
                dict2[l1[i]] = l2[i]
        return dict2
    else:
        k = 0
        for i in range(len(l2)):
            k += 1
            if i >= len(l1):
                dict2['k{}'.format(k)] = l2[i]
            else:
                dict2[l1[i]] = l2[i]
        return dict2
print(l_d(list1, list2))
dict0 = {'ll': 2, 'cc': 0, 'dd': '1'}
'''键转为列表'''
print([i for i in dict0.keys()])
'''值转为列表'''
print([i for i in dict0.values()])

from copyheaders import headers_raw_to_dict
x=b'''
{
    "hasThird":false,
    "thirdCarrierName":"",
    "thirdCarrierNo":true,
    "thirdPlatForm":null,
    "thirdContractNo":"",
    "thirdContractName":"",
    "shiftWaybillDTOList":[
        {
            "waybillId":xxx
        }
    ]
}
'''
r=headers_raw_to_dict(x)
print(r)
print(type(r))

from contextlib import contextmanager
# 一个应用场景，给一个书名前后加上书名号
@contextmanager
def book_mark():
    print('《', end='')
    yield  # yield 后面不一定要返回结果，纯粹起一个中断作用
    print('》', end='')
with book_mark():
    print("年少不努力", end='')
# 打开文件，文件不存在打印出不存在的文件名
@contextmanager
def file_open(file_name):
    try:
        yield
    except FileNotFoundError as e:
        print(file_name)
file_name = 'data1.txt'
with file_open(file_name):
    open(file_name, mode='r')

'''
不能将**kwargs置于*args前，否则将产生错误；
“args kwargs ”是一个标准化规范 使用其他的名称也是可以的 *args 和 *没有区别 kwargs也是
最好使用标准规范
'''
'''传参查看参数'''
def a(b, *c):
    print(f'b={b}---c={c}')
a(1, (1, 2, 3, 4))  # b=1---c=((1, 2, 3, 4),)
a(1, 2, 3, 4, 5)  # b=1---c=(2, 3, 4, 5)
a({1:1}) #b={1: 1}---c=()
def b(b, **c):
    print(f'b={b}---c={c}')
b(1, d=1, c=1)  # b=1---c={'d': 1, 'c': 1}
'''使用'''
def lis(*args):
    print(f'args={args},类型为{type(args)}')
lis(1,2,3) #args=(1, 2, 3),类型为<class 'tuple'>
a=[1,3,'d']
b=(1,3,'d')
lis(a) #args=([1, 3, 'd'],),类型为<class 'tuple'>
lis(b) #args=((1, 3, 'd'),),类型为<class 'tuple'>
def dic(**kwargs):
    print(f'kwargs={kwargs},类型为{type(kwargs)}')
dic(d=1,c=2) #kwargs={'d': 1, 'c': 2},类型为<class 'dict'>
#这样写要报错的 dic({1:1,2:2})

a=[1,2,3]
#异常捕获处理
try:
    # print(1)
    print(a[4]) #索引异常
    # print(1 / 0) #被除数为0异常
except ZeroDivisionError:
    print('被除数为0异常')
    #可以打印出具体异常信息
except IndexError as e:
    print(f'索引异常。异常信息：{e}')
    #父类异常，可以接受所有异常，父类异常写在最后
except Exception:
    print('没有发现上述异常，未知异常')
else:
    print('没有异常')
finally:
    print('有无异常我都执行')
#手动抛出异常
x=2
if x>2:
    #这里可是使用所有的异常类型
    raise Exception('x不能大于2')
#自定义异常
class NameLengthError(Exception):
    '''当名字长度大于5位时抛出该异常'''
    # 自定义异常类型的初始化
    def __init__(self,length :int):
        self.length=length
    # 返回异常类对象的说明信息
    def __str__(self):
        if self.length>5:
            return f'姓名的长度最大为5位,您输入的位数为{self.length}位'
        return ''
length=3
try:
    raise NameLengthError(length)
except NameLengthError as e:
    print(e)

import jsonpath
d = {
    "error_code": 0,
    "stu_info": [
        {
            "id": 2059,
            "name": "亚索",
            "sex": "男",
            "age": 28,
            "addr": "德玛西亚",
            "grade": "天蝎座",
            "info": {
                "card": 434345432,
                "bank_name": '中国银行',
                'name': 'dddd'
            }
        },
        {
            "id": 2067,
            "name": "李青",
            "sex": "男",
            "age": 28,
            "addr": "虾子岛",
            "grade": "天蝎座",
        }
    ]
}
# $表示最外层的{},取出来的格式都是列表list，注意自行处理
# 指定查找 [2067] 等同于 d['stu_info'][1]['id']
print(jsonpath.jsonpath(d, '$.stu_info.1.id'))
# 在第一层里面找是否有键值=name的，未找到返回False
print(jsonpath.jsonpath(d, '$.name'))
# 在第二层找是否有键值=name的,有2个['亚索', '李青']
print(jsonpath.jsonpath(d, '$..name'))
# 在第二层找是否有键值=card的,有一个[434345432]
print(jsonpath.jsonpath(d, '$...card'))
# 数字索引提取，适用于列表  $表示最外层的[]
a = [1, 2, [3, 4, [5, 6]]]
# 第一个2是[3,4,[5,6]]，第二个2是[5,6],0是5
print(jsonpath.jsonpath(a, '$.2.2.0'))  # [5]
# 过滤
c = {'code': 200,
     'data': [
         {'create_time': '2016-01-29 13:49:13',
          'link': 'http://www.ehoutai.com/', 'uid': 7, 'name': '易后台'},
         {'create_time': '2016-01-29 13:42:15',
          'link': 'http://www.sanjieke.com/', 'uid': 4, 'name': '三节课'},
         {'create_time': '2016-01-29 13:40:53',
          'link': 'https://www.aliyun.com/', 'uid': 1, 'name': '阿里云'},
         {'create_time': '2016-01-29 14:01:59',
          'link': 'http://xmanlegal.com/', 'uid': 8, 'name': '未来法律'}]}
# 只筛选data下uid等于4的一条数据 ：[{'create_time': '2016-01-29 13:42:15', 'link': 'http://www.sanjieke.com/', 'uid': 4, 'name': '三节课'}]
print(jsonpath.jsonpath(c, '$.data[?(@.uid==4)]'))
print(jsonpath.jsonpath(c, '$.data[?(@.uid==4)][name]')) #['三节课']
print(jsonpath.jsonpath(c, '$.data[?(@.uid>4)]')) #大于4的有2条数据
#使用in也可以 [{'create_time': '2016-01-29 14:01:59', 'link': 'http://xmanlegal.com/', 'uid': 8, 'name': '未来法律'}]
print(jsonpath.jsonpath(c,'$.data[?("xm" in @.link)]'))

import threading
import time
# 函数里面不能写变量
def run():
    ##这里直接写主体内容
    print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))  # 输出当地时间
    timer = threading.Timer(2, run)  # 设置一个定时器，循环输出时间,单位秒
    timer.start()  # 启动线程
run()