05 python数据容器

5.1 数据容器认识

5.2 python列表

5.2.1 列表的定义

'''
演示数据容器之：list
语法：[元素，元素，....]
'''

#定义一个列表List
List = ['itheima','uityu','gsdfg']
List1 = ['itheima','6666','True']
print(List)
print(List1)
print(type(List))
print(type(List1))

#定义嵌套列表
List2 = [[1,2,3],['dadd','dadad','fefefe']]
print(List2)
print(type(List2))

5.2.2 列表的下标索引

'''
通过下标索引取出对应位置的数据
'''


#定义列表
List = ['tom','python','lalal']

#列表[下标索引]，从前向后从0开始，每次+1，   从后往前从-1开始，每次-1
print(List[0])
print(List[1])
print(List[-1])

#定义嵌套列表
List1 = [[1,2,3],[123,333,444]]
#取出嵌套索引的元素
print(List1[0][1])
print(List1[1][-2])

5.2.3 列表的常用操作方法

'''
演示数据容器之：List列表常用操作
'''

my_list = [11111,'num',['qqqqq',676767]]

#1.1 查找某元素在列表内的下标索引                           列表.index
index = my_list.index(['qqqqq',676767])
print(f'[qqqqq,676767]在列表中的下标索引是：{index}')

# 1.2如果查找的元素不存在，会报错
# index = my_list.index(0000)
# print(f'0000在列表中的下标索引是：{index}')

#2 修改特定下标索引的值
my_list[0] = 9999
print(f'列表被修改后的值是：{my_list}')

#3 在特定位置插入新元素                                    列表.insert
my_list.insert(1,777777)
print(f'列表插入元素后它的结果是：{my_list}')

#4 在元素列表中追加一个元素，在列表尾部加入新元素               列表.append
my_list.append('学python')
print(f'列表在追加元素后，结果是：{my_list}')

#5 在元素列表中追加一个新列表，在列表尾部加入新列表              列表.extend
my_list2 = [1,'best']
my_list.extend(my_list2)
print(f'列表在追加列表后，结果是：{my_list}')

#6 删除列表中的元素（两种方法）
my_list3 = [11111,'num',['qqqqq',676767]]
#6.1 del方法  列表[下标]
del my_list3[2][1]
print(f'del方法删除后的结果是{my_list3}')
#6.2 方法2： 列表.pop(下标)                                 列表.pop
my_list3 = [11111,'num',['qqqqq',676767]]
my_list3.pop(1)
print(f'列表.pop(下标)方法删除后的结果是{my_list3}')


#7  删除某元素在列表的第一个匹配项                             列表.remove
my_list4 = [11111,11111,111111,111111,'num','num','num',['qqqqq',676767]]
my_list4.remove('num')
my_list4.remove('num')
my_list4.remove('num')
print(f'通过remove方法移除元素后，列表的结果是：{my_list4}')

#8 清空列表                                                列表.clear
my_list4.clear()
print(f'列表被清空了，结果是：{my_list4}')

#9  统计列表内某元素的数量                                    列表.count
my_list5 = [11111,11111,111111,111111,'num','num','num',['qqqqq',676767]]
count = my_list5.count('num')
print(f'列表中num的数量为：{count}')

#统计列表中有多少元素                                         len（列表）
my_list6 = [11111,11111,111111,111111,'num','num','num',['qqqqq',676767]]
count = len(my_list6)
print(f'列表中的元素数量为：{count}')

5.2.4 列表的基础操作案例

age = [21,25,21,23,22,20]

#追加31到列表末尾
age.append(31)
print(age)

#追加新列表到列表尾部
age1 = [29,33,30]
age.extend(age1)
print(age)

#取出第一个元素
age.pop(0)
print(age)

#取出最后一个元素
del age[7]
print(age)

#查看31在列表中的下表位置
index = age.index(31)
print(index)

5.3 元组

5.3.1 元组的定义和操作

'''
演示tuple元组的定义和操作
'''
#定义元祖
t1 = (1,'hello',True)
t2 = ()
t3 = tuple()
print(f't1的类型是{type(t1)},内容是{t1}')
print(f't2的类型是{type(t2)},内容是{t2}')
print(f't3的类型是{type(t3)},内容是{t3}')

#定义单个元素的元素(单个元素需要带上单个逗号)
t4 = (1,)
t5 = (2)
print(f't4的类型是{type(t4)},内容是{t4}')
print(f't5的类型是{type(t5)},内容是{t5}')

# 元组的嵌套
t6 = ((1,2,3),(9,0,34))
print(f't6的类型是{type(t6)},内容是{t6}')

# 下标索引取出内容
num = t6[1][1]
print(f'从嵌套元祖中取出的数据是：{num}')

#元组的操作：index查找方法
t1 = (1,0,'hello',True,False,True,False,True,False,'hhhh')
index = t1.index(False)
print(f'True在t1中的下标是：{index}')

#元组的操作： count统计方法
num = t1.count(True)
print(f'在元祖中统计True的数量有{num}个')

#元祖的操作：len函数统计元组元素的的数量
num = len(t1)
print(f'元祖的数量有：{num}个')

#元组的遍历 while循环
index = 0
while index < len(t1):
    print(f"元组的元素有：{t1[index]}")
    index += 1

#元组的遍历 for循环
for i in t1:
    print(f"2元组的元素有：{i}")

# 定义一个元组
#元组的元素不可修改，但元组内列表内容元素可以修改
t10 = (1,2,[3333,5555])
print(f't10的内容是：{t10}')
t10[2][0] = '黑马python'
t10[2][1] = '西八'
print(f't10的内容是：{t10}')

5.3.2 元组的基本操作案例

#定义元组
information = ('周几轮',18,['basketball','rap'])

#查询年龄所在下标位置
index = information.index(18)
print(f'年龄所在下标位置：{index}')

#查询学生姓名
name = information[0]
print(f"学生姓名是{name}")

#删除学生爱好basketball
del information[2][0]
print(information)

#增加爱好dance
information[2].append('dance')
print(information)

5.4 字符串

5.4.1 字符串的定义和操作

'''
演示以数据容器的角色，学习字符串的相关操作
'''

my_str = 'python learning time'
#通过下标索引取值
a = my_str[3]
b = my_str[-6]
print(f'下标为2的值是：{a}，下标为-6的值是{b}')

# index方法
c = my_str.index('learning')
print(f'learing的起始下标是：{c}')

#replace方法
new_my_str = my_str.replace("i",'程序')
print(f'{my_str}替换i后结果是：{new_my_str}')

#split方法 字符串的分割
my_str3 = 'aaabbaddaeeaggakka'
my_str3_list = my_str3.split('a')
print(f'字符串{my_str3}按照a进行split分割后得到：{my_str3_list}，类型是：{type(my_str3_list)}')

#strip方法  去除字符串收尾元素
my_str = '  123python   learning   time21   '
new_my_str = my_str.split() #不传入参数，则去除首尾空格
print(new_my_str)
new_my_str2 = my_str.split('12')
print(new_my_str2)

#统计字符串某字符串出现的次数
my_str = '  123python   learning   time21   '
count = my_str.count('2')
print(f'2出现的次数是{count}')

#统计字符串的长度
count = len(my_str)
print(f'字符串{my_str}的长度是{count}')

#字符串的while的循环遍历
my_str2 = 'whoiam'
index = 0
while index < len(my_str2):
    print(my_str2[index])
    index += 1

#字符串的for的循环遍历
for i in my_str3:
    print(i)

5.4.2字符串的大小比较

'''
演示字符串的大小比较
'''

#abc 比较abd
print(f"abc 小于 abd的结果是：{'abd' > 'abc'}")

#ab比较a
print(f"a小于 ab的结果是：{'ab' > 'a'}")

#ab比较A
print(f"A小于 a的结果是：{'a' > 'A'}")

#key1比较key2
print(f"key1小于 key2的结果是：{'key2' > 'key1'}")

5.4.3字符串的基础操作案例

str = 'itheima itcast boxuegu'

#统计字符串内it数量
count = str.count('it')
print(f'字符串内it数量有：{count}')

#将空格替换为|
new_str = str.replace(' ','|')
print(f'将字符串{str}内空格替换为|的结果为{new_str}')

#按照|字符分割为列表
new_str_list = new_str.split("|")
print(new_str_list)

5.5 对数据容器进行切片操作

5.5.1 演示对序列进行切片操作

'''
演示对序列进行切片操作
'''

#对list进行切片，从1开始，4结束，步长1
my_list = [0,1,2,3,4,5,6]
re = my_list[1:4]       #步长默认1，可以不写
print(f'结果1：{re}')

#对tuple进行切片，最开始，到最后结束，步长1
my_tuple = (0,1,2,3,4,5,6)
re2 = my_tuple[:]       #步长默认1，可以不写
print(f'结果2：{re2}')

#对str进行切片，最开始，到最后结束，步长2
my_str = '0123456'
re3 = my_str[::2]
print(f'结果3：{re3}')

#对str进行切片，最开始，到最后结束，步长-1
my_str = '0,1,2,3,4,5,6'
re4 = my_str[::-1]
print(f'结果4：{re4}')

#对列表进行切片，从3开始，1结束，步长-1
my_list = [0,1,2,3,4,5,6,7,8,9,100]
re5 = my_list[3:1:-1]
print(f'结果5：{re5}')



#对元祖进行切片，最开始，到最后结束，步长-2
my_tuple = (0,1,2,3,4,5,6,3333,7,89,99,99999)
re6 = my_tuple[::-2]
print(f'结果6：{re6}')

5.5.2 对数据容器操作的基础案例

str = '万过薪月，员序程马黑来，nohtyp学'

#方法一   切片，倒序取出
re = str[9:4:-1]
print(re)

#方法二  倒序取出，然后切片
re2 = str[::-1][9:14]
print(re2)

#方法三，split分割，replace分割“来”为空，倒序字符串
re3 = str.split('，')[1].replace('来','')[::-1]
print(re3)

5.6 集合

5.6.1 集合的定义和操作

'''
演示数据容器集合
'''
#定义集合  集合会去重，不支持重复元素
my_set = {'sss','qqq','wwww','rrr','ww'}
my_set_empty = set() #定义空集合
print(f'{my_set}，{type(my_set)}')
print(f'{my_set_empty}，{type(my_set_empty)}')

#添加新元素
my_set.add("python")
print(f'{my_set}')

#移除元素
my_set.remove('python')
print(f'{my_set}')

#从集合中随机取出元素
element =my_set.pop()
print(f'{my_set},{element}')

#清空集合
my_set.clear()
print(f'{my_set}')

#取出两个集合的差集  会产生新集合，集合1和2不变
set1 = {1,2,3}
set2 = {1,5,3}
set3 = set1.difference(set2)
print(f'{set1},{set2},{set3}')

#消除两个集合的差集  不会产生新集合，集合1变
set1 = {1,2,3}
set2 = {1,5,3}
set3 = set1.difference_update(set2)
print(f'{set1},{set2}')

#两个集合合并    会产生新集合，集合1和2不变
set1 = {1,2,3}
set2 = {1,5,3}
set3 = set1.union(set2)
print(f'{set1},{set2},{set3}')

#统计集合数量
count = len(set3)
print(f'{count}')

#集合的遍历
#集合不支持下标索引，不可以while循环
for i in set3:
    print(f"{i}")


'''
集合的基本操作案例
'''
my_list = [1,2,3,4,5,6,7,8,9,0,5,6,5,3,21,1,334,4,3,2,1]

#定义空集合
set = set()

#通过for循环遍历列表
#将列表中元素添加到集合中
for i in my_list:
    print(f'{i}')
    set.add(i)
print(f"{set}")

5.7 字典

5.7.1 字典的定义和操作

'''
演示字典的定义
'''

#定义字典  字典中的key不可以重复 {key，value}
my_dict = {'网咯红':99 ,'周几轮':88 ,'林俊杰':77 }
#定义空字典
my_dict2 = {}
my_dict3 = dict()
print(f'{my_dict},{type(my_dict)},\n'
      f'{my_dict2},{type(my_dict2)},\n'
      f'{my_dict3},{type(my_dict3)}')

#从字典中基于key获取value
score = my_dict['林俊杰']
print(f'{score}')

#字典的嵌套，key，value可以是任意数据类型，（key不可为字典）
stu_score_dict = {
    '王力宏':{
        'aa':77,
        'bb':55,
        'cc':66
    },
    '周杰伦':{
        'aa': 47,
        'bb': 555,
        'cc': 106
    },
    '林俊杰':{
        'aa': 127,
        'bb': 545,
        'cc': 876
    }
}
print(f'{stu_score_dict}')

#查看学生成绩
score = stu_score_dict['周杰伦']['aa']
print(f'{score}')

'''
字典的常用操作
'''
my_dict = {'网咯红':99 ,'周几轮':88 ,'林俊杰':77 }
#新增元素
my_dict['张学友'] = 62
print(f'{my_dict}')

#更新元素
my_dict['周几轮'] = 9
print(f'{my_dict}')

#删除元素

score = my_dict.pop('周几轮')
print(f'{my_dict}，{score}')

#清空元素
my_dict.clear()
print(f'{my_dict}')

#遍历字典
#获取全部key
my_dict = {'网咯红':99 ,'周几轮':88 ,'林俊杰':77 }
keys = my_dict.keys()
print(f'{keys}')
# 方式1  通过获取所有key来遍历字典
for key in keys:
    print(f'{key},{my_dict[key]}')

#方式2 通过直接对字典进行for循环，每一次循环得到key
for key in my_dict:
    print(f'222\t{key},aaaa\t{my_dict[key]}')

#统计字典内的元素数量
num = len(my_dict)
print(f'{num}')


'''
字典的基本操作案例
'''

#定义字典
my_dict = {
    '王力宏':{
        '部门':'科技部',
        '工资':3000,
        '级别':1
    },
    '周杰伦':{
        '部门': '市场部',
        '工资': 5000,
        '级别': 2
    },
    '林俊杰':{
        '部门': '市场部',
        '工资': 7000,
        '级别': 3
    },
    '张学友':{
        '部门': '科技部',
        '工资': 4000,
        '级别': 1
    },
    '刘德华':{
        '部门': '市场部',
        '工资': 6000,
        '级别': 2
    }
}
#遍历字典，找到name这个key
for name in my_dict:
    #判断name key对应的级别是否为1
    if my_dict[name]['级别'] == 1:
        #如果是级别加1，工资加1000
            my_dict[name]['级别'] += 1
            my_dict[name]['工资'] += 1000
print(f'{my_dict}')

5.8 数据容器的通用操作

'''
演示数据容器的通用操作
'''

list1  =  [17,27,30,4,45]
tuple1 =  (10,2,3,44,5)
str1   =  'abcdefghij'
set1   =  {1,2,3,4,5}
dict1  =   {'key8':9,'key2':8,'key6':7,'key4':6,'key7':4}

#len元素个数
num = len(list1)
print(f'{num}')

num = len(tuple1)
print(f'{num}')

num = len(str1)
print(f'{num}')

num = len(set1)
print(f'{num}')

num = len(dict1)
print(f'{num}')

#max 最大元素
print(f'列表 最大的元素是：{max(list1)}')
print(f'元组 最大的元素是：{max(tuple1)}')
print(f'字符串最大的元素是：{max(str1)}')
print(f'集合 最大的元素是：{max(set1)}')
print(f'字典 最大的元素是：{max(dict1)}')

#min最小元素
print(f'列表 最小的元素是：{max(list1)}')
print(f'元组 最小的元素是：{max(tuple1)}')
print(f'字符串最小的元素是：{max(str1)}')
print(f'集合 最小的元素是：{max(set1)}')
print(f'字典 最小的元素是：{max(dict1)}')

#类型转换：容器转列表
print(f'列表   列表转换为列表的结果是：{list(list1)}')
print(f'元组   元组转换为列表的结果是：{list(tuple1)}')
print(f'字符串转字符串换为列表的结果是：{list(str1)}')
print(f'集合   集合转换为列表的结果是：{list(set1)}')
print(f'字典   字典转换为列表的结果是：{list(dict1)}')

#类型转换：容器转元组
print(f'列表   列表转换为元组的结果是：{tuple(list1)}')
print(f'元组   元组转换为元组的结果是：{tuple(tuple1)}')
print(f'字符串转字符串换为元组的结果是：{tuple(str1)}')
print(f'集合   集合转换为元组的结果是：{tuple(set1)}')
print(f'字典   字典转换为元组的结果是：{tuple(dict1)}')

#类型转换：容器转字符串
print(f'列表   列表转换为字符串的结果是：{str(list1)}')
print(f'元组   元组转换为字符串的结果是：{str(tuple1)}')
print(f'字符串转字符串换为字符串结果是：  {str(str1)}')
print(f'集合   集合转换为字符串的结果是：{str(set1)}')
print(f'字典   字典转换为字符串的结果是：{str(dict1)}')

#类型转换：容器转集合
print(f'列表   列表转换为集合的结果是：{set(list1)}')
print(f'元组   元组转换为集合的结果是：{set(tuple1)}')
print(f'字符串  字符串换为集合的结果是：{set(str1)}')
print(f'集合   集合转换为集合的结果是：{set(set1)}')
print(f'字典   字典转换为集合的结果是：{set(dict1)}')

#容器的通用排序功能 排序后结果会变成列表对象
print(f'列表   列表排序的结果是：{sorted(list1)}')
print(f'元组   元组排序的结果是：{sorted(tuple1)}')
print(f'字符串  字符排序的结果是：{sorted(str1)}')
print(f'集合   集合排序的结果是：{sorted(set1)}')
print(f'字典   字典排序的结果是：{sorted(dict1)}')

#反向排序
print(f'列表   列表反向排序的结果是：{sorted(list1,reverse=True)}')
print(f'元组  元组反向排序的结果是：{sorted(tuple1,reverse=True)}')
print(f'字符串  字符反向排序的结果是： {sorted(str1,reverse=True)}')
print(f'集合   集合反向排序的结果是： {sorted(set1,reverse=True)}')
print(f'字典   字典反向排序的结果是：{sorted(dict1,reverse=True)}')

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

smartKettle离线部署及问题记录

smartKettle离线部署及问题记录

目录 &#x1f4da;第一章 前言&#x1f4d7;背景&#x1f4d7;目的&#x1f4d7;总体方向 &#x1f4da;第二章 部署&#x1f4d7;源码下载&#x1f4d7;后端部署&#x1f4d5;导入后端项目&#x1f4d5;修改settings.xml(自动下载相关jar包)&#x1f4d5; 编译&#x1f4d5; …
阅读更多...
0x13 链表与邻接表

0x13 链表与邻接表

0x13 链表与邻接表 数组是一种支持随机访问&#xff0c;但不支持在任意位置插入和删除元素的数据结构。与之相对应&#xff0c;链表支持在任意位置插入或删除元素&#xff0c;但只能按顺序依次访问其中元素。我们可以使用一个struct来表示链表的节点&#xff0c;其中可以存储任…
阅读更多...
MySQL线上死锁案例分析

MySQL线上死锁案例分析

项目场景 项目开发中有两张表&#xff1a;c_bill(账单表)&#xff0c;c_bill_detail(账单明细表)&#xff0c;他们的表结构如下&#xff08;这里只保留必要信息&#xff09;&#xff1a; CREATE TABLE c_bill_detail (id bigint unsigned NOT NULL AUTO_INCREMENT COMMENT 主…
阅读更多...
Gin之GORM 查询语句

Gin之GORM 查询语句

前期工作可以看之前的&#xff08;连接数据库&#xff1b;以及确定要操作的库&#xff09; Gin之GORM 操作数据库&#xff08;MySQL&#xff09;-CSDN博客https://blog.csdn.net/m0_72264240/article/details/134948202?spm1001.2014.3001.5502这次我们操作gin库下的另外一个…
阅读更多...
Lenovo联想拯救者Legion Y9000X 2021款(82BD)原装出厂Windows10系统

Lenovo联想拯救者Legion Y9000X 2021款(82BD)原装出厂Windows10系统

链接&#xff1a;https://pan.baidu.com/s/1GRTR7CAAQJdnh4tHbhQaDQ?pwdl42u 提取码&#xff1a;l42u 联想原厂WIN10系统自带所有驱动、出厂主题壁纸、系统属性专属LOGO标志、Office办公软件、联想电脑管家等预装程序 所需要工具&#xff1a;16G或以上的U盘 文件格式&am…
阅读更多...
记录汇川：套接字TCP通信-梯形图

记录汇川：套接字TCP通信-梯形图

H5U集成一路以太网接口。使用AutoShop可以通过以太网方便、快捷对H5U进行行监控、下载、上载以及调试等操作。同时也可以通过以太网与网络中的其他设备进行数据交互。H5U集成了Modbus-TCP协议&#xff0c;包括服务器与客户端。可轻松实现与支持Modbus-TCP的设备进行通讯与数据交…
阅读更多...
Redis哨兵模式：什么是哨兵模式、哨兵模式的优缺点、哨兵模式的主观下线和客观下线、投票选举、Redis 哨兵模式搭建

Redis哨兵模式：什么是哨兵模式、哨兵模式的优缺点、哨兵模式的主观下线和客观下线、投票选举、Redis 哨兵模式搭建

文章目录 什么是哨兵模式哨兵模式的优缺点主观下线和客观下线投票选举哨兵模式场景应用Redis version 6.0.5 集群搭建下载文件环境安装解压编译配置文件启动关闭密码设置 什么是哨兵模式 哨兵模式是Redis的高可用解决方案之一&#xff0c;它旨在提供自动故障转移和故障检测的功…
阅读更多...
数据分析基础之《numpy（3）—基本操作》

数据分析基础之《numpy（3）—基本操作》

一、基本操作 1、adarray.方法() 2、np.函数名() 二、生成数组的方法 1、生成0和1的数组 为什么需要生成0和1的数组&#xff1f; 我们需要占用位置&#xff0c;或者生成一个空的数组 &#xff08;1&#xff09;ones(shape[, dtype, order]) 生成一组1 shape&#xff1a;形…
阅读更多...
STM32读取EEPROM存储芯片AT24C512故障然后排坑记录

STM32读取EEPROM存储芯片AT24C512故障然后排坑记录

背景&#xff1a; 有一个项目用到STM32F091芯片去读取 AT24C512C-SSHD EEPROM 芯片&#xff0c;我直接移植了之前项目的IIC库&#xff0c;结果程序运行后&#xff0c;读不出EEPROM里面的数据。 摘要&#xff1a; 本文主要介绍一个基于STM32F091芯片和AT24C512C-SSHD EEPROM芯片…
阅读更多...
Java面向对象思想以及原理以及内存图解

Java面向对象思想以及原理以及内存图解

文章目录 什么是面向对象面向对象和面向过程区别创建一个对象用什么运算符?面向对象实现伪代码面向对象三大特征类和对象的关系。 基础案例代码实现实例化创建car对象时car引用的内存图对象调用方法过程 成员变量和局部变量作用范围在内存中的位置 关于对象的引用关系简介相关…
阅读更多...
6、生产者压缩算法面面观

6、生产者压缩算法面面观

生产者压缩算法面面观 1、怎么压缩&#xff1f;2、何时压缩&#xff1f;2.1、生产者端2.2、Broker 端 3、何时解压缩&#xff1f;4、各种压缩算法对比 压缩的思想&#xff0c;实际就是用时间去换空间的经典 trade-off 思想&#xff0c;在 Kafka 中&#xff0c;就是用 CPU 时间去…
阅读更多...
Linux | 多线程

Linux | 多线程

前言 本文主要介绍多线程基础知识&#xff0c;以及使用多线程技术进行并发编程&#xff1b;最后会介绍生产者消费者模型&#xff1b; 一、线程基本认识 1、什么是线程 如果你是科班出生&#xff0c;你肯定听过线程相关概念&#xff1b;但是你可能没有真正搞懂什么是线程&#…
阅读更多...
十八）Stable Diffusion使用教程：艺术二维码案例

十八）Stable Diffusion使用教程：艺术二维码案例

今天说说怎么样使用SD生成艺术二维码。 我们直接上图。 方式有三种，分别如下： 1）方式一：直接 contronet 的tile模型进行控制 使用QRBTF Classic生成你的二维码。 首先输入网址，选择喜欢的二维码样式（推荐第一种就行）： 然后选择相应参数，这里推荐最大的容错率，定…
阅读更多...
Linux 安装图形界面 “startx”

Linux 安装图形界面 “startx”

———————————————— 报错&#xff0c;如下&#xff1a; bash :startx command not found ———————————————— 解决方法&#xff1a; 1.先安装 — X Windows System&#xff0c;输入以下命令&#xff1a; yum groupinstall “X Window System”…
阅读更多...
第一个“hello Android”程序

第一个“hello Android”程序

1、首先安装Android studio&#xff08;跳过&#xff09; Android Studio是由Google推出的官方集成开发环境&#xff08;IDE&#xff09;&#xff0c;专门用于Android应用程序的开发。它是基于JetBrains的IntelliJ IDEA IDE构建的&#xff0c;提供了丰富的功能和工具&#xff0…
阅读更多...
2002-2023年各省环境规制力度数据（ZF报告词频环境规制关键词词频统计）

2002-2023年各省环境规制力度数据（ZF报告词频环境规制关键词词频统计）

2002-2023年各省环境规制力度数据&#xff08;ZF报告词频环境规制关键词词频统计&#xff09; 1、时间&#xff1a;2001-2022年 2、指标&#xff1a;文本总长度、仅中英文-文本总长度、文本总词频-全模式、文本总词频-精确模式、环境规制力度词频和、环境保护、环保、污染、能…
阅读更多...
Linux常用命令(二)

Linux常用命令(二)

目录 Linux常用命令(二)1、grep命令2、df命令3、hostname命令4、ps命令5、top命令6、echo命令7、cal命令8、firewall-cmd命令9、du命令10、netstat命令 Linux常用命令(二) 1、grep命令 功能说明&#xff1a;查找文件里符合条件的字符串。 举 例&#xff1a;ps aux | grep yum…
阅读更多...
高通平台开发系列讲解（SIM卡篇）SIM卡基础概念

高通平台开发系列讲解（SIM卡篇）SIM卡基础概念

文章目录 一、SIM卡基本定义二、卡的类型三、SIM卡的作用三、SIM卡基本硬件结构四、SIM卡的内部物理单元五、卡文件系统沉淀、分享、成长，让自己和他人都能有所收获！😄 📢本篇文章将介绍SIM的相关组件。 一、SIM卡基本定义 功能和作用：SIM卡的主要功能是存储用户的身份信…
阅读更多...
【Hadoop】Hadoop基础架构的变化

【Hadoop】Hadoop基础架构的变化

1.x版本架构2.x版本架构3.x版本架构参考 1.x版本架构 NameNode&#xff1a;&#xff0c;负责文件系统的名字空间(Namespace)管理以及客户端对文 件的访问。NameNode负责文件元数据的管理和操作。是单节点。 Secondary NameNode&#xff1a;它的职责是合并NameNode的edit logs到…
阅读更多...
什么是自我力量？如何提高自我力量？

什么是自我力量？如何提高自我力量？

自我力量 &#xff0c;是承受力和容纳力的评估指标&#xff0c;可以理解为不逃避&#xff0c;承受情感、冲动和幻想的能力&#xff0c;提高学习和工作效率。在企业人才测评中&#xff0c;ES用于评估工作能力&#xff0c;在校学生则可用于评估学习效率。 自我力量 &#xff0c;…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站