首页 > 其他分享 >第五章组合类型数据

第五章组合类型数据

时间：2024-07-14 20:30:43浏览次数：15  
标签：10 lst2 组合 item 列表 print lst 第五章 类型

一、序列和索引

1、序列和索引
序列用于存储多个值的连续空间，每个值都对应一个整数的编号，称为索引

点击查看代码 
示例5-1使用索引检索字符串中的元素
#正向递增
s='helloworld'
for i in range(0,len(s)):
    print(i,s[i],end='\t\t')
print('\n----------------------')

#反向递减
for i in range(-10,0):
    print(i,s[i],end='\t\t')

print('\n',s[9],s[-1])

2、切片操作


序列[start:end:step]

点击查看代码 
示例5-2序列的切片操作
s='HelloWorld'
#切片操作
s1=s[0:5:2] #索引从0开始，到5结束（不包含5）步长为2
print(s1)
#省略开始位置，start默认从0开始
print(s[:5:1])

#省略开始位置,省略步长step,默认步长为1
print(s[:5:])
#省略结束位置
print(s[0::1])#stop默认到序列最后一个(包含最后一个）

print(s[5::])
print(s[5:])#12行代码与13行代码功能相同，省略了结束，省略了步长
#更改步长，步长更改为2
print(s[0:5:2])

#省略开始与结束只写步长
print(s[::2])#分别获取 0,2,4,8索引上的元素
#步长为负数
print(s[::-1])
#可以替换为
print(s[-1:-11:-1])

3、序列的相加操作

点击查看代码 
示例5-3序列的相加和相乘操作
s='hello'
s2='world'
print(s+s2)#产生一个新的字符串序列

#序列的相乘
print(s*5)
print('-'*40)

点击查看代码 
示例5-4序列的相关操作符和函数的使用
s=('helloworld')
print('e在helloworld中存在吗？',('e'in s))#in的使用
print('v在helloworld中存在吗？',('v'in s))
#not in 的使用
print('e在helloworld中存在吗？',('e'not in s))#not in的使用
print('v在helloworld中存在吗？',('v'not in s))

#内置函数的使用
print('len():',len(s))
print('max():',max(s))
print('min():',min(s))

#序列对象的相关方法，使用序列名称打点调用
print('s.index():',s.index('o')) #o在s中第一次出现的索引位置
#print('s.index():',s.index('v'))#ValueError: substring not found,报错的原因是v在字符串中不存在，所以找不到
print('s.count():',s.count('o'))#统计o在s中出现的次数

二、列表类型

1、列表的创建方式
1）使用[]直接创建列表
列表名=[element1,element2......,elementN]
2）使用内置函数list()创建列表
列表名=list(序列)
列表的删除
del 列表名

点击查看代码 
示例5-5列表的创建与删除
#直接使用【】创建列表
lst=['hello','world',98,100.5]
print(lst)

#可以使用内置函数list()创建列表
lst2=list('helloworld')
lst3=list(range(1,10,2))#从1开始到10结束，步长为2，不包含10
print(lst2)
print(lst3)

#列表是序列中的一种，对序列的操作符，运算符，函数均可以使用
print(lst+lst2+lst3)
print(len(lst))
print(max(lst3))
print(min(lst3))

print(lst2.count('o'))#统计o的个数
print(lst2.index('o'))#o在列表lst2中第一次出现的位置

#列表的删除
lst4=[10,20.30]
#删除列表
del lst4
#print(lst4)#NameError: name 'lst4' is not defined. Did you mean: 'lst'?

enumerate函数的使用语法结构

for index,item in enumerate(lst)
#输出index(序号，从0开始)和item
点击查看代码 
示例5-6列表的遍历操作
lst=['hello','world','pathon','php']
#使用遍历循环for遍历列表元素
for item in lst:
    print(item)

#使用for循环，range(),len()函数，根据索引进行遍历
for i in range(0,len(lst)):
    print(i,'-->',lst[i])

#第三种遍历方式enumerate()函数
for index,item in enumerate(lst):
    print(index,item)#index是序号，不是索引
#手动修改序号的起始值
for index,item in enumerate(lst,start=1):#省略start不写，直接写起始值
    print(index,item)

2、列表的相关操作

点击查看代码 
示例5-7列表的相关操作
lst=['hello','world','pathon']
print('原列表：',lst,id(lst))
#增加元素的操作
lst.append('sql')
print('增加元素之后',lst,id(lst))
#使用insert(_index,x)在指定位置插入元素x
lst.insert(1,100)
print(lst)

#列表元素的删除操作、
lst.remove('world')
print('删除元素之后的列表：',lst,id(lst))

#使用pop(index),根据索引将元素取出，然后再删除
print(lst.pop(1))
print(lst)

#清除列表中所有元素clear()
# lst.clear()
# print(lst,id(lst))

#列表的反向
lst.reverse()#不会产生新的列表，在原列表的基础上进行的、
print(lst)

#列表的拷贝，将产生一个新的列表对象
new_lst=lst.copy()
print(lst,id(lst))
print(new_lst,id(new_lst))

#列表元素的修改
#根据索引进行修改元素
lst[1]='mysql'
print(lst)

3、列表的排序操作
1）列表对象的sort方法
lst.sort(key=None,reverse=False)

key表示排序的规则，reverse表示排序方式（Flase默认升序，True表示降序）

2)内置函数sorted()
sorted(iterable,key=None,reverse=False)

iterable表示排序对象

点击查看代码 
示例5-8列表的排序操作
lst=[4,56,3,78,40,56,89]
print('原列表:',lst)

#列表排序，默认升序、
lst.sort()#排序在原列表基础上产生，不会产生新的列表
print('升序',lst)

#排序，降序
lst.sort(reverse=True)
print('降序',lst)

print('------------------------')
lst2=['banana','apple','Cat','Orange']
print('原列表',lst2)

#升序排列先拍大写再排小写
lst2.sort()
print('升序',lst2)

#降序先排小写，再排大写
lst2.sort(reverse=True)
print('降序',lst2)

#忽略大小写进行比较
lst2.sort(key=str.lower)#转成小写在进行排序
print(lst2)

示例5-9列表的排序
lst=[4,56,3,78,40,56,89]
print('原列表:',lst)
#排序
asc_lst=sorted(lst)
print('升序',asc_lst)
print('原列表',lst)

#降序
desc_lst=sorted(lst,reverse=True)
print('降序',desc_lst)
print('原列表',lst)


lst2=['banana','apple','Cat','Orange']
print('原列表',lst2)

#忽略大小写进行排序
new_lst2=sorted(lst2,key=str.lower)
print('原列表',lst2)
print('排列后的列表',new_lst2)

4、列表生成式
lst=[expression for item in range]
lst=[expression for item in range if condition]

点击查看代码 
示例5-10列表生成式的使用
import random
lst=[item for item in range(1,11)]
print(lst)

lst=[item*item for item in range(1,11)]
print(lst)

lst=[random.randint(1,100) for _ in range(10)]
print(lst)

#从列表中选择符合元素组成新的列表
lst=[i for i in range(10) if i%2==0]
print(lst)

5、二维列表的遍历

for row in 二维列表:
     for item in row:
       pass
点击查看代码 
示例5-11二维列表的遍历和生成式
#创建二维列表
lst=[
    ['城市','环比','同比'],
    ['北京',102,103],
    ['上海',104,504],
    ['深圳',100,39]
]
print(lst)

#遍历二维列表使用双层for循环
for row in lst:#行
    for item in row:#列
        print(item,end='\t')
    print()

#列表生成式生成一个4行5列的二维列表
lst2=[[j for j in range(5)] for i in range(4)]
print(lst2)

三、元组类型

不可变类型，没有相关增删改一系列操作，只可以获取和用for遍历元素

1、元组的创建
1）使用()直接创建元组
元组名=(element1,element2,......,elementN)
2)使用内置函数tuple()创建元组
元组名=tuple(序列)

2、删除元组
del 元组名

点击查看代码 
示例5-12元组的创建与删除
#使用（）创建元组
t=('hello',[10,20,30],'pathon','world')
print(t)

#使用内置函数创建元组
t=tuple('helloworld')
print(t)

t=tuple([10,20,30])
print(t)

print('10在元组是否存在：',(10 in t))
print('10在元组是否存在：',(10 not in t))
print('最大值：',max(t))
print('最小值：',min(t))
print('len；',len(t))
print('t.index:',t.index(10))
print('t.count:',t.count(10))

#如果元组中只有一个元素
t=(10)
print(t,type(t))
#如果元组中只有一个元素，逗号不能省
y=(10,)
print(y,type(y))

#元组的删除
del t
#print(t)#NameError: name 't' is not defined,删除后不存在t

示例5-13元组的访问与遍历
t=('pathon','hello','world')
#根据索引访问元组
print(t[0])
t2=t[0:3:2]#元组支持切片操作
print(t2)

#元组的遍历
for item in t:
    print(item)

#for+range()+len()
for i in range(len(t)):
    print(i,t[i])

#使用enumerate()
for index,item in enumerate(t):
    print(index,'--->',item)

for index,item in enumerate(t,start=11):#序号从11开始
    print(index,'--->',item)

示例5-14元组生成式
t=(i for i in range(1,4))
print(t)#输出生成器对象
# t=tuple(t)
# print(t)

#遍历
# for item in t:
#     print(item)

print(t.__next__())
print(t.__next__())
print(t.__next__())

t=tuple()
print(t)

字典类型

可变数据类型，字典中key无序，‘key’唯一且为不可变序列

1、字典类型的创建方式
1）使用{}直接创建字典
d={key1:value1,key2......}

2)使用内置函数dict()创建字典
dict(key1=value1,key2=value2......)

  • 通过映射函数创建字典
    zip(lst1,lst2)

点击查看代码 
示例5-15字典的创建与删除
#(1)创建字典
d={10:'cat',20:'dog',30:'pet',20:'zoo'}
print(d)#key相同时，value值进行了覆盖

#(2)zip函数
lst1=[10,20,30,40]
lst2=['cat','dog','pet','zoo','car']
zipobj=zip(lst1,lst2)
print(zipobj)#<zip object at 0x0000025F0D533FC0>
#print(list(zipobj))#[[(10, 'cat'), (20, 'dog'), (30, 'pet'), (40, 'zoo')]
d=dict(zipobj)
print(d)#{10: 'cat', 20: 'dog', 30: 'pet', 40: 'zoo'}

#使用参数创建字典
d=dict(cat=10,dog=20)#左侧cat是key，右侧的是value
print(d)


t=(10,20,30)
print({t:10})#t是key，10是value，元组可以作为字典中的key

# lst=[10,20,30]
# print({lst:10})#TypeError: unhashable type: 'list';列表不能作为字典中的key

#字典属于序列
print('max',max(d))
print('min',max(d))
print('len',len(d))
#字典的删除
del d
#print(d)

2、字典的访问与遍历
字典元素的取值
d[key]或d.get(key)
字典元素的遍历
1)遍历出key和value的元组

for element in d.items():
     pass

2)分别遍历出key 和value

for key.value in d.items():
      pass
点击查看代码 
示例5-16字典的访问与遍历
d={'hello':10,'world':20,'pathon':30}
#访问字典中的元素
#（1）使用d[key]
print(d['hello'])
#(2)d.get(key)
print(d.get('hello'))

#二者之间是有区别的，如果key不存在，d[get]报错d.get(key)可以指定默认值
# print(d['java'])#KeyError: 'java'
print(d.get('java'))#None
print(d.get('java','不存在'))

#字典的遍历
for item in d.items():
    print(item)#key=value组成的一个元素

#使用for循环遍历时，分别获取key和value
for key,value in d.items():
    print(key,'--->',value)

3、字典的相关操作

点击查看代码 
示例5-17字典的相关操作
d={1001:'李梅',1002:'王华',1003:'张锋'}
print(d)

#向字典中添加元素
d[1004]='张丽丽'#直接使用赋值运算符向字典中添加元素
print(d)

#获取字典中的元素
keys=d.keys()
print(keys)#dict_keys([1001, 1002, 1003, 1004])
print(list(keys))
print(tuple(keys))

#获取字典中所有的value
values=d.values()
print(values)
print(list(values))
print(tuple(values))

#如何将字典中的数据转为键值对的形式
lst=list(d.items())
print(lst)

d=dict(lst)
print(d)

#使用pop函数
print(d.pop(1001))
print(d)

print(d.pop(1008,'不存在'))

#随即删除
print(d.popitem())
print(d)

#清空字典中所有元素
d.clear()
print(d)
#Pathon中一切对皆象，每个对象都有一个bool值
print(bool(d))

4、字典生成式

d={key:value for item in range}
d={key:value for key,value in zip(lst1,lst2)}
点击查看代码 
示例5-18字典生成式
import random
d={item :random.randint(1,100) for item in range(4)}
print(d)

#创建两个列表
lst=[1001,100,1003]
lst2=['陈美美','王一一','李乐乐']
d={key:value for key,value in zip(lst,lst2)}
print(d)

集合类型

1、集合创建
1）使用{}创建集合
s={element1,element2,....,elementN}
2）使用内置函数创建集合
s=set(可迭代对象)
2、集合的删除
del 集合名

点击查看代码 
示例5-19集合的创建与删除
#使用{}创建集合
s={10,20,30}
print(s)
#集合只能存储不可变数据类型
# s={[10,20],[30,40]}#TypeError: unhashable type: 'list'
# print(s)
#使用set()创建集合

s=set()#创建了空集合，空集合的布尔值为Flase
print(s)

s={}#创建的是集合还是字典？
print(s,type(s))#创建的是字典

s=set('helloworld')
print(s)#无序且不重复

s2=set([10,20,30])
print(s2)

s3=set(range(1,10))
print(s3)

#集合属于序列的一种
print('max',max(s3))
print('min',min(s3))
print('len',len(s3))
print('9在集合中存在吗',(9 in s3))
print('9在集合中不存在吗',(9 not in s3))

#集合的删除
del s3
#print(s3)#NameError: name 's3' is not defined. Did you mean: 's'?

3、集合的相关操作符

交集 A&B
并集 A|B
差集 A-B
补集 A^B
点击查看代码 
示例5-20集合的操作符
A={10,20,30,40,50}
B={30,50,88,76,20}
#交集操作
print(A&B)
#并集操作
print(A|B)
#差集操作
print(A-B)
#补集操作
print(A^B)

4、集合的相关操作

点击查看代码 
示例5-21集合的相关操作
s={10,20,30}
#向集合中添加元素
s.add(100)
print(s)
#删除元素
s.remove(20)
print(s)
#清空集合中所有元素
# s.clear()
# print(s)

#集合的遍历操作
for item in s:
    print(item)


#使用enumerate()函数
for index,item in enumerate(s):
    print(index,'--->',item)

#集合的生成式
s={i for i in range(1,10)}
print(s)

s={i for i in range(1,10) if i%2==1}
print(s)

Pathon3.11的新特性

1、结构模式匹配

match data:
   case {}:
        pass
    case []:
        pass
    case ():
        pass
    case _:
        pass
点击查看代码 
示例5-22结构的模式匹配
data=eval(input('请输入要匹配的数据:'))
match data:
    case {'name':'ysj','age':20}:
        print('字典')
    case [10,20,30]:
        print('元组')
    case (10,20,40):
        print('元组')
    case _:
        print('相当于多重if中的else')

2、字典合并运算符 |

点击查看代码 
示例5-23合并字典的运算符
d1={'a':10,'b':20}
d2={'c':30,'d':40}
print(d1|d2)
3、同步迭代 
match data1,data2:
     case data1,data2:
          pass
点击查看代码 
示例5-24同步迭代
fruits=['apple','orange','pear','grape']
counts=[10,3,4,5]
for f,c in zip(fruits,counts):
    match f,c:
        case 'apple',10:
            print('10个苹果')
        case 'orange',3:
            print('3个橘子')
        case 'pear',4:
            print('4个梨')
        case 'grape',5:
            print('5串葡萄')

点击查看代码 
实战一
lst=[88,89,92,98,00,99]
print('原列表为：',lst)
#遍历列表
#方法一
# for index in range(len(lst)):
#     if str(lst[index])!='0':
#         lst[index]='19'+str(lst[index])#拼接年份再赋值
#     else:
#         lst[index] = '200' + str(lst[index])
# print(lst)

#方法2
for index,value in enumerate(lst):
    if str(lst[index]) != '0':
        lst[index]='19'+str(value)#拼接年份再赋值
    else:
        lst[index] = '200' + str(value)
print(lst)
    
#我的思路
#实战1
# lst=[88,89,92,98,00,99]
# print('原列表：',lst)
#
# for i in range(0,len(lst)):
#    if lst[i]==00:
#        lst2=lst[i]
#        lst.pop(i)
#        lst.insert(i,2000+lst2)
#    else:
#        lst2 =lst[i]
#        lst.pop(i)
#        lst.insert(i, 1900+ lst2)
# print(lst)

编写代码时存在问题：在列表中判断商品时，无法实现部分匹配——>可以采用切片操作

点击查看代码 
实战二
#我的思路
lst=list()
for i in range(5):
  commodity=input('请输入商品编号和名称进行商品入库，每次只能输入一个商品：')
  lst.append(commodity)

for j in range(0,len(lst)):
   print(lst[j])

lst2=list()
for k in range(0,len(lst)):
    com1=input('请输入要购买的编号：')
    for l in range(0,len(lst)):
      if com1==lst[l][0:4]:
       print('商品已成功添加到购物车')
       lst2.append(lst[l])
       break
    if com1!=lst[l][0:4] and  com1!='q':
       print('该商品不存在')
    if com1=='q':
     break

print('------------------------')

lst2.sort(reverse=True)
print('您的购物车产品为：')
for m in range(0,len(lst2)):
  print(lst2[m])

#老师思路
#创建一个空列表，用于存储入库商品信息
lst=[]
for i in range(5):
    goods=input('请输入商品编号和名称进行商品入库，每次只能输入一个商品：')
    lst.append(goods)
#输出所有的商品信息
for item in lst:
    print(item)

#创建一个空列表，用于存储购物车中的shangp
cart=[]
while True:
    flag=False#没有商品
    num=input('请输入要购物的商品编号：')
    #遍历商品列表，查询一下购买商品是否存在
    for item in lst:
        if num==item[0,4]:#切片操作，从商品中切出序号
            flag=True#代表商品已经找到
            cart.append(item)
            print('商品已成功添加到购物车')
            break#退出for循环
    if not flag and num!='q': #not flag==False
        print('该商品不存在')
    if num=='q':
        break
print('-'*50)
print('您购物车已选商品为：')
cart.reverse()
for item in cart:
    print(item)

点击查看代码 
#创建二维列表
lst=[
    ['车次','出发站-到达站','出发时间','到达时间间隔','历时时长'],
    ['G1569','北京南-天津南','18:06','18:39','00:33'],
    ['G1567','北京南-天津南','18:15','18:49','00:34'],
    ['G8917','北京南-天津南','18:20','19:19','00:59'],
    ['G203','北京南-天津南','18:35','19:09','00:34']
]

for row in lst:
    for item in row:
        print(item,end='\t')
    print()
print('----------')
train=input('请输入要购买的车次：')
passager=input('请输入乘车人，如果是多位乘车人使用逗号分隔：')
lst2=[]#存储乘车信息
for item in lst:
    lst2.append(item[0])
    if train==item[0]:
        print('您已购买',item[0],item[1],item[2],'开，请',passager,'尽快换取纸质车票.[铁路客服]')
        break
    lst2.clear()

点击查看代码 
#我的思路
#创建二维列表
lst=[
    ['车次','出发站-到达站','出发时间','到达时间间隔','历时时长'],
    ['G1569','北京南-天津南','18:06','18:39','00:33'],
    ['G1567','北京南-天津南','18:15','18:49','00:34'],
    ['G8917','北京南-天津南','18:20','19:19','00:59'],
    ['G203','北京南-天津南','18:35','19:09','00:34']
]

for row in lst:
    for item in row:
        print(item,end='\t')
    print()
print('----------')
train=input('请输入要购买的车次：')
passager=input('请输入乘车人，如果是多位乘车人使用逗号分隔：')
lst2=[]#存储乘车信息
for item in lst:
    lst2.append(item[0])
    if train==item[0]:
        print('您已购买',item[0],item[1],item[2],'开，请',passager,'尽快换取纸质车票.[铁路客服]')
        break
    lst2.clear()

#老师思路
#创建字典存储车票信息，使用车次做key，其他信息作为你value
dict_ticket={
    'G1569':['北京南-天津南','18:06','18:39','00:33'],
    'G1567':['北京南-天津南','18:15','18:49','00:34'],
    'G8917':['北京南-天津南','18:20','19:19','00:59'],
    'G203':['北京南-天津南', '18:35', '19:09', '00:34']
}
print('车次    出发站——到达站    出发时间    到达时间    历时时长')
#遍历字典中的元素
for key in dict_ticket.keys():
    print(key,end=' ')#为什么不换行，因为车次和车次的详细信息在一行显示
    #根据key获取的信息是一个列表
    for item in dict_ticket.get(key):#根据key获取值
        print(item,end=' \t\t')
    #换行
    print()

#输入用户的购票车次
train_no=input('请输入要购买的车次：')
#根据key获取值
info=dict_ticket.get(train_no,'车次不存在')#info是一个列表类型
#判断车次是否存在
if info!='车次不存在':
    person=input('请输入乘车人，如果是多位乘车人使用逗号分隔：')
    #获取车次的出发站——到达站，还有出发时间
    s=info[0]+' '+info[1]+'开'
    print('您已购买了'+train_no+' '+s+',请'+person+'尽快获取纸质车票。【铁路客服】')
else:
    print('对不起，选择车次不存在')

点击查看代码 

s=set()
for i in range(1,5):
  #i=str(i)
  #num=input('请输入第'+i+'位好友的姓名与电话：')
num=input('请输入第{i}位好友的姓名与电话：')
  s.add(num)
for item in s:
    print(item)

标签：10,lst2,组合,item,列表,print,lst,第五章,类型
From： https://www.cnblogs.com/pl-blog1/p/18274569

相关文章

  • Nuxt.js 错误侦探：useError 组合函数
    title:Nuxt.js错误侦探：useError组合函数date:2024/7/14updated:2024/7/14author:cmdragonexcerpt:摘要：文章介绍Nuxt.js中的useError组合函数，用于统一处理客户端和服务器端的错误，提供statusCode、statusMessage和message属性，示例展示了如何在组件中使用它来捕获和显......
  • C语言 底层逻辑详细阐述指针（一）万字讲解 #指针是什么？ #指针和指针类型 #指针的解引用 #
    文章目录前言序1：什么是内存？序2：地址是怎么产生的？一、指针是什么1、指针变量的创建及其意义：2、指针变量的大小二、指针的解引用 三、指针类型存在的意义四、野指针1、什么是野指针2、野指针的成因a、指针未初始化b、指针越界访问c、指针指向的空间释放3、如何......
  • js 一个函数有几种类型的属性
    在JavaScript中，函数对象可以拥有多种类型的属性。主要可以分为以下几类：实例属性（Instanceproperties）：这些属性是在通过函数构造函数创建实例时绑定到实例上的属性。原型属性（Prototypeproperties）：这些属性是绑定到函数对象的原型上的属性。实例可以通过原型链访问这些......
  • ts一个class有几种类型的属性
    在TypeScript中，一个类（class）可以拥有以下几种类型的属性：实例属性（Instanceproperties）：这些属性是在类的构造函数中使用this关键字定义的。每个实例都有自己独立的实例属性。原型属性（Prototypeproperties）：这些属性是定义在类的原型对象上的，所有实例共享同一个原型对......
  • PMP-组织结构类型
      职能型、矩阵型（强、弱、均衡）、项目导向（复合型、混合型），最常考，矩阵型为主。 矩阵型具有多重的的汇报关系，但是他有专门的项目目的，好处是更高的提升项目的资源使用效率，又让项目不至于太高的人力成本。职能型组织 ▪层级型结构，横向沟通困难，项目一般在职能部门内执行为主......
  • MySQL数据类型，如何选择数据类型
    数据类型一、整数类型标准SQL支持INTEGER和SMALLINT两种整数类型，另外还扩展支持TINYINT、MEDIUMINT、BIGINT。二、浮点数类型和定点数类型浮点数类型包括单精度（FLOAT）和双精度（DOUBLE）,定点数类型（DECIMAL）。三、CAHR类型和VARCHAR类型四、TEXT类型和BLOB类型TEXT和BLOB类......
  • 基本数据类型缓存池
    基本数据类型的包装类除了Float和Double之外，其他六个包装器类（Byte、Short、Integer、Long、Character、Boolean）都有常量缓存池。Byte：-128~127，也就是所有的byte值Short：-128~127Long：-128~127Character：\u0000-\u007FBoolean：true和falseInteger：-128~127......
  • C#可空类型与数组
    文章目录可空类型NULL合并运算符（??）数组数组声明数组初始化数组赋值数组访问多维数组交错数组数组类数组类的常用属性数组类的常用方法可空类型  C#提供了一种特殊的数据类型，nullable类型（可空类型），可空类型可以表示其基础值类型正常范围内的值，再加上一个null值......
  • 代码随想录day 23 组合总和 | 组合总和II | 分割回文串
    组合总和组合总和解题思路利用回溯算法进行遍历，由于数组内的数字可以重复调用，因此在套用模板进行遍历时，下一次递归的startIndex是当前遍历的下标。剪枝操作则是通过比较和是否大于目标值，如果大于则不进行下一次的递归，以此来减少循环遍历的次数，这个条件需要加到for循环中。知......
  • 《JavaSE》------4.＜基础语法（数据类型与变量）＞
    包含java注释，标识符，关键字，数据类型与变量，Ascii码与Unicode码，类型转换....语言只是工具，不能决定你好不好找工作，决定你好不好找工作的是你的能力！！！！！学历本科及以上就够用了！！！！！！！！！！！！！！！！！！！！！！！！！！！！目录一、注释二、标识符三、关键字四、数据类型与变量4.1字面常量4.1.1字面常量的分类4.2数据......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99