basicPython-1

元组

"""
目录:
1.创建元组
2.元组的拼接
3.元组的解压赋值
4.元组的切片
5.元组的元素的索引
6.元组的嵌套
7.统计某个元素的个数
""""""创建元组(元组不可变)"""
# 1.强制:tuple()
# 2.普通
tuple_0 = (1,)
tuple_1 = 1, 2, 3, "apple", "red"
tuple_2 = (1, 2, 3, "banana", "blue")
print(type(tuple_1), type(tuple_2))"""元组的拼接"""
tuple_new = tuple_1 + tuple_2"""元组的解压赋值"""
tuple_3 = (1, 2, 3)
a, b, c = tuple_3"""元组的切片(并非修改其内容)"""
print(tuple_3[::-1])"""知道‘元组的元素’查看其‘索引’"""
print(tuple_1.index("apple"))"""元组的嵌套"""
tuple_4 = ((1, 8, 3), (5, 1))"""统计某个元素的个数"""
tuple_5 = (5, 6, 1, 3, 1, 2, 1, 8)
res = tuple_5.count(1)
print("有%d个数字‘1’" % res)

列表

"""
目录:
1.创建列表
2.列表的拼接
3.列表的解压赋值
4.列表的切片
5.列表的元素的索引
6.列表的嵌套
7.统计某个元素的个数
8.列表的元素添加
9.列表的元素删除
10.替换元素
11.元素排序
12.列表推导式
13.拷贝
""""""创建列表"""
# 1.强制:使用list()
# 2.普通:
list_0 = []
list_1 = [1]
list_2 = [2, 3, 4, 5]"""列表的拼接"""
list_new_1 = list_1 + list_2
list_new_2 = list_1 * 3"""列表的解压赋值"""
list_3 = [1, 2, 3]
a, b, c = list_3"""列表的切片"""
print(list_3[0:3:2])
# 从第零个开始拿,直到3-1为止.每走两步向下拿个东西print(list_3[::])
# 全部‘顺序’切片,等价于list_3[::1]print(list_3[::-1])
# 全部‘倒序’切片"""知道‘列表的元素’查看其‘索引’"""
print(list_3.index(1))"""列表的嵌套"""
list_3 = [[1, 2], [1, 2, 3, 4], [0]]"""列表推导式"""
list_4 = [i for i in range(9) if i < 5]
list_5 = [i for i in "hello_world"]"""列表的元素添加"""
list_6 = [66, 77, 88, 99]str_1 = "每次只能添加一个元素"
list_6.append(str_1)list_new_3 = [211, "extend是并入一个列表", 985]
list_6.extend(list_new_3)"""列表的元素删除"""
str_2 = "remove() 函数用于移除列表中某个值的第一个匹配项,没有返回值"
list_6.remove(str_2)str_3 = "pop() 函数用于移除列表中的一个元素(默认最后一个元素)并且返回该元素的值"
list_6.pop()list_6.clear()  # 清空列表"""替换元素"""
list_6[0] = 233
list_6[:3:] = 1, 2, 3"""元素排序"""
list_7 = [5, 9, 1, 7, 3]
# 顺序:sort()
list_7.sort()
print(list_7)
# 逆序:reverse() or sort(reverse=True)
list_7.reverse()
print(list_7)"""统计某个元素的个数"""
res = list_7.count(1)"""拷贝"""
# 1.浅拷贝:copy()---仅拷贝父对象,不会拷贝对象的内部的子对象
list_8 = [[1, 2], 3, 4, 5]
print("原来的>>>", list_8)res_1 = list_8.copy()
res_1[3] = 55
print(res_1)
print(list_8)list_8 = [[1, 2], 3, 4, 5]
print("原来的>>>", list_8)res_2 = list_8.copy()
res_2[0][0] = 22
print(res_2)
print(list_8)# 2.深拷贝:---完全拷贝了父对象及其子对象
import copyres_3 = copy.deepcopy(list_8)

字典

"""
目录:
1.创建字典
2.字典的get函数
3.字典的拼接
4.字典的嵌套
5.统计字典有多少个‘键值对’
6.字典推导式
7.字典元素的添加
8.字典元素的修改
9.字典元素的删除
10.拷贝
11.字典的 items()函数
""""""创建字典"""
# 1.强制:dict()
# 2.普通:
dict_0 = {}
dict_1 = {"key": 150}
dict_2 = {"name": "小明","age": 18,"hobby": "打篮球"
}"""字典的get函数"""
res = dict_2.get("name", "查无此人")  # res:小明 若"name"键不存在 则返回后面的"查无此人""""字典的拼接"""
dict_3 = {**dict_1, **dict_2}
print(dict_3)"""字典的嵌套"""
dict_4 = {"叶寻": {"age": 20, "height": 180},"小明": {"age": 15, "height": 165}
}"""统计字典有多少个‘键值对’"""
print(len(dict_3))
print(len(dict_4))"""字典推导式"""
dict_5 = {i: i ** 2 for i in range(5)}"""字典元素的添加(直接添加即可)"""
dict_6 = {}
dict_6["age"] = 15
dict_6["name"] = 8"""字典元素的修改"""
dict_7 = {"age": 18}
dict_7["age"] = 50"""字典元素的删除"""
del dict_7["age"]
dict_7.clear()  # 清空字典
del dict_7  # 删除字典"""拷贝"""
# 1.浅拷贝:copy()---仅拷贝父对象,不会拷贝对象的内部的子对象
dict_8 = {"color": {"red": "红色", "yellow": "黄色"}, "weight": 50}
print("原来的>>>", dict_8)res_1 = dict_8.copy()
res_1["weight"] = 999
print(res_1)
print(dict_8)dict_8 = {"color": {"red": "红色", "yellow": "黄色"}, "weight": 50}
print("原来的>>>", dict_8)res_2 = dict_8.copy()
res_2["color"]["red"] = "玫瑰红"
print(res_2)
print(dict_8)# 2.深拷贝:---完全拷贝了父对象及其子对象
import copyres_3 = copy.deepcopy(dict_8)"""字典的 items()函数"""
# items()的作用是把字典中的每对key和value组成一个元组 并把这些元祖放在列表中返回
d = {"red": 1, "blue": 2, "green": 3}
for i, v in d.items():print(i, v)

集合

"""
目录:
1.创建集合
2.去重
3.成员操作符(in_or_not_int)
4.枚举(列举)
5.增、删
6.交集
7.并集
"""""" 创建集合"""
# 创建空集合(必须使用 set() 而不是 {} 因为 s = {} 默认创造出的是空‘字典’):
set_0_0 = set()  # 强转‘虚无’为集合
set_0_1 = set(())  # 强转‘空元组’为集合
set_0_2 = set([])  # 强转‘空列表’为集合
set_0_3 = set({})  # 强转‘空字典’为集合# 创建非空集合(可以直接使用 s = {} 创建非空集合,但内容必须填上,且不能填‘键值对’):
set_1 = {4, 5, 6}list_temp = [55, 66, 77]
set_2 = set(list_temp)"""去重"""
list_new = [1, 1, 1, 1, 1, 2, 3, 4, 5]
set_3 = set(list_new)  # 自动去除重复内容"""成员操作符(in_or_not_int)"""
print(5 in set_3)  # True or False"""枚举(列举)"""
s = {1, 2, 3, 4, 5}
for i, v in enumerate(s, start=0):# enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列# 同时列出数据和数据下标,一般用在 for 循环当中# 索引默认从0开始(即:start = 0)print('index: %s,value: %s' % (i, v))"""增、删"""
s.add(10)  # 增加一个元素
s.update([5, 2, 3, 6])  # 添加多个元素s.pop()  # 删除最前面的元素【第一个】
s.remove(5)  # 指定删除某个元素"""交集"""
s1 = {1, 2, 99, 88}
s2 = {1, 2, 55, 66}
s3 = {1, 2, 10, 20}
print(s1.intersection(s2, s3))  # intersection()方法用于返回两个或更多集合的‘交集’
# 符号方法更简单 --->>>  print(s1 & s2 & s3)"""并集"""
print(s1.union(s2, s3))  # union()方法用于返回两个或更多集合的‘并集’
# 符号方法更简单 --->>>  print(s1 | s2 | s3)"""差集"""
print(s1 - s2)"""对称差集"""
print(s1 ^ s2)
# 上面的一行等价于 --->>>  print((s1 - s2) | (s2 - s1))"""父子集"""
print(s1 > s2)

字符串

"""
目录:
1.创建字符串
2.访问字符串中的值
3.字符串拼接
4.转义字符
5.成员运算符
6.字符串的切片
7.字符串常用函数
""""""创建字符串"""
# 1.强制转换str()
# 2.普通
name = "Xiao_Ming""""访问字符串中的值"""
str_1 = "abcdfg"
print(str_1[0])"""字符串拼接"""
str_2 = "i love "
str_3 = "you"
str_4 = str_2 + str_3"""转义字符"""
# 响铃 \userDate.txt
# 换行 \n
# 横向制表符 \t
# 纵向制表符 \v"""成员运算符"""
str_5 = "abc"
print("userDate.txt" in str_5)"""字符串的切片"""
str_6 = "abcdefg"
print(str_6[:5:])
# 结果展示:userDate.txt b.txt c d e
# 索引展示:0 1 2 3 4"""
字符串常用函数
1.join()
2.replace()
"""""" 1.join()函数(返回值是"字符串类型")"""
res_1 = ":".join("快遍历并插入进来")
res_2 = "".join(["我", "是", "一", "个", "数", "组"])  # 列表转换为字符串的方法""" 2.replace() """
# replace() 方法把字符串中的 old(旧字符串) 替换成 new(新字符串),
# 如果指定第三个参数max,则替换不超过 max 次
str_n = "我是他朋友"
print(str_n.replace("他", "你"))

格式化输出

# (一)占位符
'''
%s 字符串
%c 字符
%d 十进制(整数)
%o 八进制整数
%x 十六进制整数
'''
print("我的年龄为%d" % 28)
print("我是%s,它是%s" % ("小明", "金刚"))
print("你看看它们,一个是%(male)s,一个是%(female)s" % {"female": 1, "male": 2})# (二)字符串的拼接
a = "你好呀!"
b = "我是XXX"
c = a + b
print(c)# (三)格式化填充a = '{0:🤭^10}'.format('567')
# 符号:后面是填充符
# 符号^表示居中,
# 如果为符号<则是居左
# 10表示总长度
print(a)b = '{:02}:{:02}:{:02}'.format(13, 4, 57)
# 0是填充符,2是width,表示位数为2
# 结果:
'13:04:57'
print(b)"""  1.整数的输出  """
# print('%o' % 20)  # 八进制
# print('%d' % 20)  # 十进制
# print('%x' % 20)  # 十六进制"""  2.浮点数输出  """
# print('%f' % 1.11)  # 默认保留6位小数
# print('%0.1f' % 1.11)  # 取1位小数
# print('%e' % 1.11)  # 默认取6位小数,用科学计数法
# print('%0.3e' % 1.11)  # 取3位小数,用科学计数法
# print('%g' % 1111.1111)  # 默认取6位有效数字
# print('%.7g' % 1111.1111)  # 取7位有效数字
# print('%.2g' % 1111.1111)  # 取2位有效数字,自动转换为科学计数法"""  3.字符串输出  """
# print('%s' % 'hello world')  # 字符串输出
# print('%+20s' % 'hello world')  # 右对齐,取20位,不够则补位
# print('%-20s' % 'hello world')  # 左对齐,取20位,不够则补位
# print('%.2s' % 'hello world')  # 取2位
# print('%10.2s' % 'hello world')  # 右对齐,取2位
# print('%-10.2s' % 'hello world')  # 左对齐,取2位# 常用转义字符
'''
\   续行符
\\  反斜杆符号
\'  单引号
\"  双引号
\a  响铃
\b  退格(Backspace)
\000 空
\n  换行
\r  回车
\v  纵向制表符
\t  横向制表符
\f  换页
'''# 综合练习b = '{num:.2f}'.format(num=3.1415926)
# 2f的意思是以四舍五入的方式保留2位小数。
print(b)print('%-8s' % '{}x{}={}'.format(1, 2, 3))

循环语句

""" for循环实例 """
# 九九乘法表
for i in range(1, 10):for j in range(1, i + 1):print("%-7s" % "{}x{}={}".format(j, i, j * i), end=" ")print()""" while循环实例 """
# 符号楼梯
while True:# 信息录入height = int(input("请输入楼梯高度>>>"))symbol = input("请输入符号>>>")if height <= 0:continue# 生成符号楼梯i = 0while i <= height:print(symbol * i)i += 1# 是否退出if input("按Q键退出,否则继续").upper() == 'Q':break

生成式

"""元组生成式 由于元组不可变 所以不能往元组里面‘添加新的值’ 即不可‘生成’""""""列表生成式"""# 基本操作:
list_basic = ["神兽金刚", "百变金刚", "雷神风暴"]
list_1 = []
for name in list_basic:if name.endswith("金刚"):list_1.append(name)# 生成式操作:
list_1 = [name for name in list_basic if name.endswith("金刚")]"""字典生成式"""
list_basic = ["神兽金刚", "百变金刚", "神兽金刚", "金刚雷神风暴"]
dict_1 = {list_basic.index(i): i for i in (list_basic)}"""集合生成式"""
list_basic = ["神兽金刚", "百变金刚", "金刚雷神风暴", "神兽金刚"]
set_1 = {name for name in list_basic if name.endswith("金刚")}"""生成器表达式"""
list_basic = ["神兽金刚", "百变金刚", "金刚雷神风暴", "神兽金刚"]
res = (name for name in list_basic)"""
知识补充:
———————————————————————————————————————————————————————————
1.
Python中生成器能做到迭代器能做的所有事,
而且因为自动创建了__iter__()和next()方法,
生成器显得特别简洁。
而且生成器也是高效的,
使用生成器表达式取代列表解析,同时节省内存。
除了创建和保持程序状态的自动生成,当发生器终结时
还会自动抛出StopIterration异常。
———————————————————————————————————————————————————————————
2.
列表、元组、字典、字符串都是可迭代对象。
数字、布尔值都是不可迭代的。
———————————————————————————————————————————————————————————
3.
什么是迭代器?
迭代器对象要求支持迭代器协议的对象。
在Python中,支持迭代器协议
就是实现对象的__iter__()和next()方法。
其中__iter__()方法返回迭代器对象本身,
next()方法返回容器的下一个元素,在结尾时引发StopIteration异常。例子:
list = [1,2,3,4] # list是可迭代对象
lterator = iter(list) # 通过iter()方法取得list的迭代器
print(next(lterator)) # 1 通过next()获取下一个位置的值
print(next(lterator)) # 2
print(next(lterator)) # 3
print(next(lterator)) # 4输出:
1
2
3
4———————————————————————————————————————————————————————————
4.
什么是生成器?
生成器(generator)就是一个函数,
它提供了一种实现迭代器协议的便捷方式。
生成器与普通函数的区别在于它包含 yield 表达式,
并且不需要定义 __iter__()和__next__()。
生成器是一种惰性的序列,
如果我们需要创建一个 0~1000000000 的序列,
这样大的序列创建出来会占用比较多的内存,
生成器就是为了解决这样的问题。例子:# 普通序列
g = []
for x in range(5):g.append(x)# g ----> [0, 1, 2, 3, 4]# 生成器
def f():for x in range(5):yield x # 返回并记录函数状态# next
f = f()
>>> next(f) # 每调用一次next,就执行一次yield | 依靠这种需要才生产的工作机制,大大的节省资源
0
>>> next(f)
1
>>> next(f)
2
>>> next(f)
3
>>> next(f)
4# for next
>>> for x in range(5):
>>>  print(next(f))
0
1
2
3
4
———————————————————————————————————————————————————————————"""

异常处理

"""try:子代码块except (异常类型A, 异常类型B, 异常类型C)子代码块except 异常类型2 as 别名子代码块except 异常类型3 as bbb  # bbb 拿到的是捕获异常所拿到的提示信息子代码块except 异常类型4 as eee子代码块except Exception as 别名:它是最后的防线,可以捕捉所有的异常!但它根据需求,可写也可不写else:子代码块: 会在try的子代码块没有异常的时候执行finally:子代码块无论如何都执行"""

序列化和反序列化

'''1 什么是序列化和反序列化?内存中的数据类型 ---(序列化)---> 特定的格式 ( json格式 或者 pickle格式 )内存中的数据类型 <---(反序列化)--- 特定的格式 ( json格式 或者 pickle格式 )2 为何要序列化?序列化得到的结果 -> 特定的格式内容有两种用途2.1 可用于储存(如:游戏存档)2.2 传输给其他平台使用(如:跨平台数据交互)Python ------------------------Java列表 -------- 特定格式 --------- 数组.                              ..                              ..                              .集合(Python特色,无法转换)3 强调!!!针对用途1的特定格式:应该用一种专门的格式比较好,pickle只有Python可以识别,但它可以很好的保留Python的特色针对用提2的特定格式:应该用一种通用的,能被所有语言识别的格式 -> json4 补充~~~(了解)l = json.loads('[1, "abc", true, false]') ----- A1l = json.loads(b'[1, 'abc', True, False]') ----- A2上面两式子都能成功转换!!【Python版本(2.7~3.4)&(3.6~now)】注意!Python 3.5 中,A2式子会报错A1中的内容是json格式,它是str类型A2中的内容是 bytes类型'''# 实例!!!''' 1  json的实例 '''import json# # 1 如何序列化和反序列化
# # 1.1 序列化
# res = json.dumps([1, 'abc', True, False])
# print(res, type(res))
#
# # 1.2 反序列化
# l = json.loads(res)
# print(l, type(l))# 2 在文件中以json格式写入信息和读取信息# # 2.1.1 写入信息(复杂方法)
# with open(r'C:\Users\叶寻\Desktop\Python\new_course\test.txt', 'wt', encoding='utf-8') as f:
#     res1 = json.dumps([1, 'abc', True, False])
#     f.write(res1)
#
# # 2.1.2 读取信息(复杂方法)
# with open(r'C:\Users\叶寻\Desktop\Python\new_course\test.txt', 'rt', encoding='utf-8') as f:
#     res2 = f.read()
#     l = json.loads(res2)
#     print(l, type(l))# # 2.2.1 写入信息(简单方法)
# with open(r'C:\Users\叶寻\Desktop\Python\new_course\test.txt', 'wt', encoding='utf-8') as f:
#     res1 = json.dump([1, 'abc', True, False], f)
#
# # 2.2.2 读取信息(简单方法)
# with open(r'C:\Users\叶寻\Desktop\Python\new_course\test.txt', 'rt', encoding='utf-8') as f:
#     l = json.load(f)
#     print(l, type(l))''' 2  pickle的实例 '''import pickleres = pickle.dumps({1, 2, 3, 4, 5})
print(res, type(res))s = pickle.loads(res)
print(s, type(s))

猴子补丁

'''当使用别人的模块不是很顺利的时候
我们可以在执行文件的入口处加上一个自己的补丁
当我们想要反悔的时候
删掉入口文件中的补丁即可'''# 例如:假设当前文件为执行的入口,ujson是比json更强的模块,
# 但是我们已经用json写了很多功能了!!又不想牵一发而动全身
# 这时,我们可以在入口文件(即本文件)加入补丁import json
import ujsondef monkey_patch_json():json.__name__ = 'ujson'json.dumps = ujson.dumpsjson.loads = ujson.loads# 在入口文件中运行
monkey_patch_json()

知识补充

# coding:utf-8# 交叉赋值
m = 10
n = 20
n, m = m, n# 解压赋值
# 取前面部分的值
l = [1, 2, 3, 4, 5, 6, 7]
x, y, z, *aaa = l
a, b, c, *_ = l
print(aaa)
print(_)# 取后面部分的值
ll = [1, 2, 3, 4, 5, 6, 7]
*_, a1, b1, c1 = ll
print(_)# 百分之78
print("百分率>>> %s  %%" % 78)

在这里插入图片描述

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/651043.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

MYSQL表的约束详解!

文章目录 前言一、空属性二、默认值三、列描述四、zerofill五、主键六、自增长七、唯一键八、外键 前言 真正约束字段的是数据类型&#xff0c;但是数据类型约束很单一&#xff0c;需要有一些额外的约束&#xff0c;更好的保证数据的合法性&#xff0c;从业务逻辑角度保证数据…

VS生成报错:MSB8036 The Windows SDK version 8.1 was not found.找不到 Windows SDK 版本 8.1

目录 一、查看本机SDK二、 解决法一&#xff1a;适配本电脑的SDK法二&#xff1a;下载SDK 8.1 VS生成报错&#xff1a;MSB8036 找不到 Windows SDK 版本 8.1。请安装所需版本的 Windows SDK&#xff0c;或者在项目属性页中或通过右键单击解决方案并选择“重定解决方案目标”来更…

NAT地址转换协议

目录 NAT应用场景静态NAT动态NATNAPTEasy IPNAT服务器 点击跳转NAT配置&#xff08;动态nat&#xff0c;静态nat&#xff0c;Easy IP&#xff09; NAT应用场景 - 随着网络设备的数量不断增长&#xff0c;对IPv4地址的需求也不断增加&#xff0c;导致可用IPv4地址空间逐渐耗尽…

C++17中lambda表达式新增加支持的features

C17中对lambda表达式新增加了2种features&#xff1a;lambda capture of *this和constexpr lambda 1.lambda capture of *this: *this:拷贝当前对象,创建副本&#xff1a;捕获*this意味着该lambda生成的闭包将存储当前对象的一份拷贝 。 this:通过引用捕获。 当你需…

Jmeter接口测试总结

&#x1f345; 视频学习&#xff1a;文末有免费的配套视频可观看 &#x1f345; 关注公众号【互联网杂货铺】&#xff0c;回复 1 &#xff0c;免费获取软件测试全套资料&#xff0c;资料在手&#xff0c;涨薪更快 Jmeter介绍&测试准备 Jmeter介绍&#xff1a;Jmeter是软件…

Linux第36步_创建正点原子的TF-A工作区

创建正点原子的TF-A工作区&#xff0c;目的是想查看正点原子的设备树文件“stm32mp157d-atk.dts”和设备树头文件“stm32mp157d-atk.dtsi”&#xff0c;了解设备树是什么样子&#xff0c;为后期基于“ST公司的源码”创建自己的设备树提供参考&#xff0c;同时也是为了学习移植u…

人体组织展示可视化模型:探索生命奥秘的新窗口

在医学领域&#xff0c;人体组织是研究疾病、生理机制和药物作用的关键。然而&#xff0c;传统的组织学研究方法往往局限于切片观察&#xff0c;难以全面、直观地展示组织结构和功能。随着科技的发展&#xff0c;人体组织展示可视化模型为医学研究带来了革命性的变革。 使用山海…

Mysql第一天

数据库概述 1. 为什么要使用数据库 持久化(persistence)&#xff1a;把数据保存到可掉电式存储设备中以供之后使用。(可掉电:内存 使用高电压和低电压来区别0和1进行数据的一个存储但是一旦断电了电压都没了 0和1也就没有了)大多数情况下&#xff0c;特别是企 业级应用&#…

计算机毕业设计 | SpringBoot 求职招聘管理系统(附源码)

1&#xff0c;绪论 1.1 开发背景 高学历人群是网络求职者的主体&#xff0c;且结构趋向固定。而在疫情肆虐的今日&#xff0c;线上招聘成了越来越多企业和个人选择的方式。在疫情期间线下招聘转为线上招聘&#xff0c;是疫情防控的需要。不能否定的是新的招聘模式的出现一定会…

大创项目推荐 行人重识别(person reid) - 机器视觉 深度学习 opencv python

文章目录 0 前言1 技术背景2 技术介绍3 重识别技术实现3.1 数据集3.2 Person REID3.2.1 算法原理3.2.2 算法流程图 4 实现效果5 部分代码6 最后 0 前言 &#x1f525; 优质竞赛项目系列&#xff0c;今天要分享的是 &#x1f6a9; 深度学习行人重识别(person reid)系统 该项目…

机器学习 | 利用Pandas进入高级数据分析领域

目录 初识Pandas Pandas数据结构 基本数据操作 DataFrame运算 文件读取与存储 高级数据处理 初识Pandas Pandas是2008年WesMcKinney开发出的库&#xff0c;专门用于数据挖掘的开源python库&#xff0c;以Numpy为基础&#xff0c;借力Numpy模块在计算方面性能高的优势&am…

Android如何通过按钮实现页面跳转方法

Hello大家好&#xff01;我是咕噜铁蛋&#xff01;在Android应用开发中&#xff0c;页面跳转是一项基本且常见的功能。通过按钮实现页面跳转可以为用户提供更好的交互体验&#xff0c;使应用更加灵活和易用。本文将介绍Android Studio中如何通过按钮实现页面跳转的方法&#xf…

JVM简介

一、什么是JVM JVM是Java Virtual Machine&#xff08;Java虚拟机&#xff09;的缩写&#xff0c;JVM是一种用于计算设备的规范&#xff0c;它是一个虚构出来的计算机&#xff0c;是通过在实际的计算机上仿真模拟各种计算机功能来实现的。Java虚拟机包括一套字节码指令集、一组…

vivado 放置I/O端口

放置I/O端口 I/O规划视图布局提供了几种将I/O端口分配给封装引脚的方法。你可以在“I/O端口”窗口中选择单个I/O端口、I/O端口组或接口&#xff0c;然后分配将它们封装到封装窗口中的封装引脚或设备窗口中的I/O焊盘。在“程序包”窗口中&#xff0c;您可以&#xff1a; •将端…

飞机发动机和飞机压缩机的关系是什么?各自的作用是什么?飞机压缩机类似于汽车涡轮增压器吗?

问题描述&#xff1a;飞机发动机和飞机压缩机的关系是什么&#xff1f;各自的作用是什么&#xff1f;飞机压缩机类似于汽车涡轮增压器吗&#xff1f; 问题解答&#xff1a; 飞机发动机和飞机压缩机是飞机涡轮引擎中的两个主要组成部分&#xff0c;它们共同协作以产生推力&…

基于springboot+vue的明星周边产品销售网站(前后端分离)

博主主页&#xff1a;猫头鹰源码 博主简介&#xff1a;Java领域优质创作者、CSDN博客专家、公司架构师、全网粉丝5万、专注Java技术领域和毕业设计项目实战 主要内容&#xff1a;毕业设计(Javaweb项目|小程序等)、简历模板、学习资料、面试题库、技术咨询 文末联系获取 研究背景…

redis哨兵机制

1)哨兵机制本质上是通过独立的进程来体现的&#xff0c;和之前的redis-server进程是完全不同的进程&#xff0c;redis-sentinel不负责存储数据&#xff0c;只是针对于其他的redis-server进程起到监控的效果&#xff0c;但是通常来说哨兵节点&#xff0c;也会搞一个集合&#xf…

Kotlin快速入门系列2

Kotlin的基本数据类型 Kotlin 的基本数值类型包括 Byte、Short、Int、Long、Float、Double 等。不同于 Java 的是&#xff0c;字符不属于数值类型&#xff0c;是一个独立的数据类型。 Java和kotlin数据类型对照如下&#xff1a; Java基本数据类型 Kotlin对象数据类型 数据类…

goland课程管理(6)

项目目录结构如下图所示&#xff1a; core包下面&#xff1a; class.go package coreimport "github.com/gin-gonic/gin"func Class1(ctx *gin.Context) {}course.go package coreimport (. "cookie/database". "cookie/model""fmt"…

【Python】02快速上手爬虫案例二:搞定验证码

文章目录 前言1、不要相信什么验证码的库2、以古诗文网为例&#xff0c;获取验证码1&#xff09;code_result.py2&#xff09;gsw.py 前言 提示&#xff1a;以古诗文网为例&#xff0c;获取验证码&#xff1a; 登录&#xff1a;https://so.gushiwen.cn/user/login.aspx 1、不…