1、python 3种基本数据类型

'''使用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'))

2、python 字典

# # 定义
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被新增了，但是又被我干掉了')

3、python 列表

# 定义
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

4、python 集合

# 定义
'''
集合：无序，没有索引不支持数据重复
'''
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'>

5、python 字符串

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

6、python 元组

# 定义
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也是元组

7、python 运算符（成员、比较、算术、赋值、身份、逻辑）

7.1、成员运算符

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

7.2、比较运算符

# 比较运算符返回布尔值
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

7.3、算术运算符

# 加减乘除
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

7.4、身份运算符

'''
总结：对象的三个特征 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

7.5、逻辑运算符

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

8、python 逻辑控制

8.1、if

'''
非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=3if a==1:print('a=1')
elif a==2:print('a=2')
else:print('a==0')
a=2
print(a)

8.2、for

'''几次常规用法'''
for i in range(1,4):#从1开始  1 2 3print(i)for i in range(4): #从0开始 0 1 2 3print(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)

8.3、while

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

8.4、循环跳出和冒牌排序

'''
break是直接结束当前循环
continue是结束当前循环的剩余语句进行下一论的循环
continue 语句是一个删除的效果，他的存在是为了删除满足循环条件下的某些不需要的成分
'''for i in 'py1thon':if i == '1':breakprint(i)print('-------------------------------------')
for i in 'py1thon':if i == '1':continueprint(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]

9、python 函数的多个参数和多个返回值

9.1、多个参数

'''
默认参数:
它是如何工作的名为 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 + bprint(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
'''

9.2、多个返回值

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

10、python 匿名函数

'''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']

11、python 变量链式赋值和作用域

11.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 3a,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

11.2、作用域

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

12、python 面向对象-基本用法

class Person:role = 'person'def __init__(self, name, attack, hp):self.name = nameself.attack = attackself.hp = hpdef hit(self, dog):# self 代表人类的对象，dog代表狗类的对象dog.hp -= self.attackclass Dog:role = 'dog'def __init__(self, name, breed, attack, hp):self.name = nameself.breed = breed  # 品种self.attack = attackself.hp = hpdef 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

13、python 面向对象-封装

class A:'''私有属性和方法只能在类内部使用'''__x = 1y = 2def __gai_y(self):self.y += 1def 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_yclass B(A):'''继承的类不能使用父类的私有属性和方法'''__b='b'bb='bb'def b1(self):print(self.__b)# print(A.__x) 会报错b=B()
b.b1()

14、python 面向对象-抽象类

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

15、python 面向对象-特殊属性类方法静态方法

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

16、python 面向对象-继承

class A:a=1def __init__(self,aa,aaa):self.aa=aaself.aaa=aaadef 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=bbdef 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()

17、python 面向对象-面向对象的组合用法

'''一个类的属性是另外一个类的对象'''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 = nameself.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())

18、python 面向对象-面向对象的组合用法

'''一个类的属性是另外一个类的对象'''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 = nameself.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())

19、python 列表、字典推导式

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)

20、python 解包列表、元组、字典

'''*解包 把 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}

21、python 提前申明变量类型

'''变量注解    更多详情参考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))

22、python 字典、列表、字符串类型转化

'''列表 和 字符串'''
import randomlist1 = [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 dict2elif len(l1) > len(l2):for i in range(len(l1)):if i >= len(l2):dict2[l1[i]] = Noneelse:dict2[l1[i]] = l2[i]return dict2else:k = 0for i in range(len(l2)):k += 1if i >= len(l1):dict2['k{}'.format(k)] = l2[i]else:dict2[l1[i]] = l2[i]return dict2print(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()])

23、python 把浏览器headers直接复制使用

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))

24、python @contextmanager上下文

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:yieldexcept FileNotFoundError as e:print(file_name)file_name = 'data1.txt'
with file_open(file_name):open(file_name, mode='r')

25、python args和kwargs

'''
不能将**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})

26、python 异常(手动抛出、自定义)

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)

27、jsonpath(精准、模糊、过滤)

import jsonpathd = {"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)]'))

28、定时器

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()

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

1. Python基础（六）--类与对象

   目录 Python基础(六)--类与对象 1 类与对象的基本概念 1.1 什么是对象 1.2 什么是类 1.3 类与对象的关系 2 定义与初始化 2.1 类的定义 2.2 对象的初始化 2.3 动态增 ...

2. Python 判断数据类型的函数

   #Python 判断数据类型的函数 可使用内置函数 isinstance() 函数来判断一个对象是否是一个已知的类型,类似 type(). 举例1 >>>arg=1234567 &g ...

3. python二元多次函数拟合_对python实现二维函数高次拟合的示例详解

   在参加"数据挖掘"比赛中遇到了关于函数高次拟合的问题,然后就整理了一下源码,以便后期的学习与改进. 在本次"数据挖掘"比赛中感觉收获最大的还是对于神经网络的认识 ...

4. 站长在线python精讲：在Python中使用len()函数计算字符串的长度详解

   欢迎你来到站长在线的站长学堂学习Python知识,本文学习的是<在Python中使用len()函数计算字符串的长度详解>.本知识点主要内容有:在Python中使用len()函数计算字符串在 ...

5. python中的面向对象：类与对象（重点！！！）

   Python中重点与难点,必须熟练掌握!!! 一.面向对象 1.面向对象概念 面向对象(Object Oriented,OO)是软件开发方法,是一种思想.面向对象的对象是指客观世界存在的事物. 我们之 ...

6. python类和对象基础详解

   类和对象 1 面向对象的思想 面向过程:面向处理理,更多的是从计算机⻆角度思考,注重计算每⼀一个步骤,程序更 像是⼀一本cpu操作⼿手册. 面向对象:以日常生活的角度思考问题的解决,更接近人的思维方式 ...

7. Python基本数据类型及其函数

   目录 Python数据类型 1. Number 1.1 整型 1.2 浮点型 1.3 复数类型 1.4 Number相关函数 (1) 数值运算 (2) 三角函数 (3) 类型转换 (4) 随机数函数 ...

8. Python基础day08【面向对象(类、对象、属性)、魔方方法(init、str、del、repr)】

   视频.源码.课件.软件.笔记:超全面Python基础入门教程[十天课程]博客笔记汇总表[黑马程序员]   目录 0.复习 1.类外部添加和获取对象属性 2.类内部操作属性 3.魔法方法 3.1.__i ...

9. （四）nodejs循序渐进-函数,类和对象（基础篇）

   上一篇文章讲到了基本数据类型和运算符,相信大家都能做简单的运算,本篇文章将讲述函数,类,对象. 函数 在nodejs中,一个函数可以作为另一个函数的参数.我们可以先定义一个函数,然后传递,也可以在传递 ...

10. Python使用---面向对象OOP（类和对象）--完善中

    来源于此 目录 1.面向对象(OOP)基本概念 1.1 过程和函数(科普) 1.2 面相过程 和 面相对象 基本概念 2 类和对象 2.1 类 2.2 对象 2.3 类和对象的关系 3 类的设计 4 ...

最新文章

1. 2021清华本科特奖答辩现场：有人用AI识别甲骨文，有人研究6G，奥运冠军：走下领奖台一切归零...
2. myeclipse部署项目后，debug模式启动，总是弹出Class.class文件
3. 三、python沉淀之路--列表（list)
4. CodeForces - 985F Isomorphic Strings(字符串哈希)
5. Linux(CentOS)网络流量实时监控（iftop）
6. 解决浏览器拦截弹出窗口问题
7. php状态机,有限状态机FSM的原理与GO的实现
8. java 使用 lamba 表达式处理二维数组
9. Centos 7 下 Mysql 5.7 Galera Cluster 集群部署
10. H5网站模板——前台和后台
11. 8086c语言编译器,8086汇编语言编译器MKStudio安装使用教程
12. 已安装flash插件，chrome仍提示未安装的解决方法
13. Excel绘制排名变化曲线图（折线图），附源文件
14. HFUT雨课堂形式与政策【支持考试】
15. idata 单片机 新唐_【nuvoton新唐8051单片机】NuTiny-SDK-N76E003开发板
16. 简记_磁学基础(一)
17. repmat()函数用法
18. 蒙特卡罗MCNP学习汇总（二）--几何体基础，构建几何体
19. 两次获得微信生态支持的如祺出行，如何破局网约车市场？
20. Linux数据库管理——day10——分库分表、数据库硬件优化

热门文章

1. 淘宝客如何通过闲鱼引流？如何抓住用户眼球实现精准引流？
2. Python OpenCV开发MR智能人脸识别打卡系统(一、需求分析与系统设计)
3. Java数据结构--Linkedlist
4. java数据结构--hashset
5. 使用ADB命令卸载安卓设备上的应用
6. c++ sin\cos函数引用
7. 浅谈在软件开发中的开发与测试 - 下
8. 移动设备软件开发测试
9. Android 跳转电话、邮件、短信等系统页面
10. NaN表示什么？typeof NaN结果是什么？