python基础学习_序列_2021/1/13_day4_ZHOU125disorder_

其他 2021-02-01 14:18:44 阅读次数: 0

序列

序列是一种数据存储的方式，用来存储一系列的数据;
万物皆对象;
python中的序列包括(字符串、列表、元组、字典、集合);

列表

例如__value=[“我的名字叫卡卡西”,“age”,30,“我的愿望是成为火影”]
列表里面的元素可以是任意的类型;

列表对象的常用方法

  • append
>>> value=["我的名字叫卡卡西","年龄",30]
>>> value
['我的名字叫卡卡西', '年龄', 30]
>>> value.append("我的愿望是成为火影")#将元素增加到列表_value的尾部
>>> value
['我的名字叫卡卡西', '年龄', 30, '我的愿望是成为火影']
  • extend
>>> content=["我杀了琳","我对不起带土"]
>>> value.extend(content)#将列表content的所有元素加到列表value的尾部
>>> value
['我的名字叫卡卡西', '年龄', 30, '我的愿望是成为火影', '我杀了琳', '我对不起带土']
  • insert
>>> value.insert(0,"我爱罗")#在指定的位置添加元素
>>> value
['我爱罗', '我的名字叫卡卡西', '年龄', 30, '我的愿望是成为火影', '我杀了琳', '我对不起带土']
  • remove
>>> value.remove(30)#在列表间删除第一次出现的该元素
>>> value
['我爱罗', '我的名字叫卡卡西', '年龄', '我的愿望是成为火影', '我杀了琳', '我对不起带土']
  • pop
>>> value.pop(4)#删除并返回该元素默认是最后一个元素(删除的元素)
'我杀了琳'
>>> value
['我爱罗', '我的名字叫卡卡西', '年龄', '我的愿望是成为火影', '我对不起带土']
  • clear
>>> value.clear()#删除全部的元素但是不删除列表
>>> value
[]
  • del
>>> value=["卡卡西","带土","琳"]
>>> del value[2]
>>> value
['卡卡西', '带土']
>>> del value#全部删除
>>> value
Traceback (most recent call last):
  File "<pyshell#77>", line 1, in <module>
    value
NameError: name 'value' is not defined
  • index
>>> value=['我爱罗', '我的名字叫卡卡西', '年龄', '我的愿望是成为火影', '我对不起带土']
>>> value.index("我爱罗")#返回第一个该元素的位置没有就报错
0
>>> value.index(18)#返回第一个该元素的位置没有就报错
Traceback (most recent call last):
  File "<pyshell#48>", line 1, in <module>
    value.index(18)
ValueError: 18 is not in list
  • 通过索引直接访问元素
>>> value=["卡卡西","带土","琳"]
>>> value
['卡卡西', '带土', '琳']
>>> value[0]
'卡卡西'
>>> value[1]
'带土'
  • count()_len()#获得指定元素在列表中出现的次数
>>> value=["我","卡卡西","我爱罗","薛之谦","我"]
>>> value
['我', '卡卡西', '我爱罗', '薛之谦', '我']
>>> value.count("我")
2
>>len(value)
5
  • reverse
>>>value
['我爱罗', '我的名字叫卡卡西', '年龄', '我的愿望是成为火影', '我对不起带土']
>>> value.reverse()#将所有的元素原地翻转
>>> value
['我对不起带土', '我的愿望是成为火影', '年龄', '我的名字叫卡卡西', '我爱罗']
  • sort
>>> value.sort()#把所有的元素排序
>>> value
['年龄', '我对不起带土', '我爱罗', '我的名字叫卡卡西', '我的愿望是成为火影']
>>> value.copy()#返回列表对象的拷贝值
['年龄', '我对不起带土', '我爱罗', '我的名字叫卡卡西', '我的愿望是成为火影']

创建列表

  1. 普通方法
 value=["我的名字叫卡卡西","我的愿望是世界和平"]#或者
 value=[]#创造一个空的列表
  1. list()
>>> value=list()#创造空的列表
>>> value
[]
>>> value=list(range(8))#range()为创造整数列表
>>> value
[0, 1, 2, 3, 4, 5, 6, 7]
>>> value=list("卡卡西,我爱罗")
>>> value
['卡', '卡', '西', ',', '我', '爱', '罗']
  1. range()整数列表

range(start，end ，step)#基本语法
start：可不写，表示起始数字，默认是 0;
end：必须写，表示结尾数字;
step：可不写，表示步长，默认为 1;
range()返回的是一个 range 对象，而不是列表，我们需要通过 list()的方法将其转换成列表对象。

>>> list(range(4,8,1))#包括第一个但是不包括最后一个
[4, 5, 6, 7]
>>> list(range(1,10,2))
[1, 3, 5, 7, 9]

4.推导式生成列表

>>> value=[i*3 for i in range(8)]#循环创建多个元素
>>> value
[0, 3, 6, 9, 12, 15, 18, 21]
>>> value=[j*4 for j in range(648)if j%17==0]#通过 if语句过滤元素
>>> value
[0, 68, 136, 204, 272, 340, 408, 476, 544, 612, 680, 748, 816, 884, 952, 1020, 1088, 1156, 1224, 1292, 1360, 1428, 1496, 1564, 1632, 1700, 1768, 1836, 1904, 1972, 2040, 2108, 2176, 2244, 2312, 2380, 2448, 2516, 2584]

成员操作符

not in/in 关键字，判断某个字符(子字符串)是否存在于字符串中.

>>> name=["卡卡西","带土","千手"]
>>> name
['卡卡西', '带土', '千手']
>>> '卡卡西' in name
True
>>> '我爱罗' not in name
True

字符串(slice)切片操作

> [:] 提取整个字符串.
> [start:]从 start 索引开始到结尾.
> [:end]从头开始知道 end-1.(包头不包尾)
> [start:end]从 start 到 end-1.(包头不包尾)
> [start，end，step]从 start 提取到
> end-1，步长是 step.(包头不包尾)

当数字是负数时;
以下可以自己去试一下

>>> name[-1:]
'罗'
>>> name[:-1]
'忍界大战我爱'
>>> name[-1:-2]
''
>>> name[-2:-1]
'爱'
>>> name[-5:-1:2]
'大我'
>>> name[-5:-1:-2]
''
>>> name[::-1]
'罗爱我战大界忍'
>>> name[::-2]
'罗我大忍'

列表的遍历

>>> value=["卡卡西","我爱罗","初代"]
>>> value
['卡卡西', '我爱罗', '初代']
>>> for i in value:
	print(i);

	
卡卡西
我爱罗
初代

复制列表所有的元素到新列表对象

>>> list1=["我爱罗","卡卡西"]
>>> list1
['我爱罗', '卡卡西']
>>> list2=list1
>>> list2
['我爱罗', '卡卡西']
>>> id(list1)
1338483823552
>>> id(list2)
1338483823552

>>> list1=["我爱罗","卡卡西"]
>>> list2=[]+list1
>>> id(list1)==id(list2)
False

使用数组2=[]+数组1的方法复制到新的数组

列表排序

  • 修改原列表，不建新列表的排序
>>> num=[12,15,13,14,15,926]
>>> num
[12, 15, 13, 14, 15, 926]
>>> num.sort()		#默认是升序排列
>>> num
[12, 13, 14, 15, 15, 926]
>>> num.sort(reverse=True)		#降序排列
>>> num
[926, 15, 15, 14, 13, 12]
>>> import random
>>> random.shuffle(num)
>>> num
[15, 15, 14, 12, 13, 926]
>>> random.shuffle(num)		#打乱顺序
>>> num
[13, 15, 12, 15, 14, 926]

建新列表的排序

>>> num=[12,3,45,6,78]
>>> num
[12, 3, 45, 6, 78]
>>> num = sorted(num)		#默认是升序排列
>>> num
[3, 6, 12, 45, 78]
>>> num=sorted(num,reverse=True)		#降序排列
>>> num
[78, 45, 12, 6, 3]

reversed()返回迭代器

>>> num1=[12,3,123,14]
>>> num1
[12, 3, 123, 14]
>>> num2=reversed(num1)
>>> num2
<list_reverseiterator object at 0x00000241748B7550>
>>> list(num2)
[14, 123, 3, 12]
>>> list(num2)
[]

我们打印输出 num2 发现提示是：list_reverseiterator。也就是一个迭代对象。同时，我们使用
list(num2)进行输出，发现只能使用一次。第一次输出了元素，第二次为空。那是因为迭代对象
在第一次时已经遍历结束了，第二次不能再使用。

列表相关的其他内置函函数

>>> num=[12,52,23,53,31]
>>> num
[12, 52, 23, 53, 31]
>>> max(num)#最大值
53
>>> min(num)#最小值
12
>>> sum(num)#和
171

二维列表

>>> content=[["卡卡西","6代火影"],["漩涡鸣人","7代火影"]]
>>> content
[['卡卡西', '6代火影'], ['漩涡鸣人', '7代火影']]

元组(tuple)

列表属于可变序列，可以任意修改列表中的元素。元组属于不可变序列，不能修改元组中的
元素。因此，元组没有增加元素、修改元素、删除元素相关的方法。

元组支持如
下操作：
1. 索引访问
2. 切片操作
3. 连接操作
4. 成员关系操作
5. 比较运算操作
6. 计数：元组长度 len()、最大值 max()、最小值 min()、求和 sum()等。

元组的创建

  1. 通过()创建元组。小括号可以省略。
content=("卡卡西","我爱罗")&content="卡卡西","我爱罗"
num=(4,5,6)&num=4,5,6

如果元组只有一个元素，则必须后面加逗号。

>>> num=(456)
>>> type(num)
<class 'int'>
>>> num=(456,)
>>> num
(456,)
>>> type(num)
<class 'tuple'>
  1. 通过 tuple()创建元组

>>> value=tuple()
>>> value
()
>>> value=tuple("卡卡西")
>>> value
('卡', '卡', '西')
>>> value=tuple("456")
>>> value
('4', '5', '6')
>>> value=tuple(range(4))
>>> value
(0, 1, 2, 3)
>>> value=tuple([4,5,6])
>>> value
(4, 5, 6)

总结：
tuple()可以接收列表、字符串、其他序列类型、迭代器等生成元组。
list()可以接收元组、字符串、其他序列类型、迭代器等生成列表。

元组的元素访问和计数

  1. 元组的元素不能修改
  2. 元组的元素访问和列表一样，只不过返回的仍然是元组对象。
  3. . 列表关于排序的方法 list.sorted()是修改原列表对象，元组没有该方法。如果要对元组排
    序，只能使用内置函数 sorted(tupleObj)，并生成新的列表对象。

>>> num=(1,24,62,23)
>>> num
(1, 24, 62, 23)
>>> sorted(num)
[1, 23, 24, 62]

zip

zip(列表 1，列表 2，…)将多个列表对应位置的元素组合成为元组，并返回这个 zip 对象。

>>> name=["卡卡西","我爱罗","漩涡鸣人"]
>>> age=[30,20,20]
>>> value=["火影","火影","火影"]
>>> content=zip(name,age,value)
>>> list(content)
[('卡卡西', 30, '火影'), ('我爱罗', 20, '火影'), ('漩涡鸣人', 20, '火影')]
>>>

生成器推导式创建元组

从形式上看，生成器推导式与列表推导式类似，只是生成器推导式使用小括号。列表推
导式直接生成列表对象，生成器推导式生成的不是列表也不是元组，而是一个生成器对象。
我们可以通过生成器对象，转化成列表或者元组。也可以使用生成器对象的__next__()
方法进行遍历，或者直接作为迭代器对象来使用。不管什么方式使用，元素访问结束后，如
果需要重新访问其中的元素，必须重新创建该生成器对象。

【操作】生成器的使用测试

>>> value=(i*2 for i in range(4))
>>> value
<generator object <genexpr> at 0x000002417487EEB0>
>>> tuple(value)
(0, 2, 4, 6)
>>> list(value)
[]
>>> value
<generator object <genexpr> at 0x000002417487EEB0>
>>> tuple(value)
()
>>> value=(i*2 for i in range(4))
>>> value.__next__()
0
>>> value.__next__()
2
>>> value.__next__()
4
>>> value.__next__()
6

元组总结

  1. 元组的核心特点是：不可变序列。
  2. 元组的访问和处理速度比列表快。
  3. 与整数和字符串一样，元组可以作为字典的键，列表则永远不能作为字典的键使用。

字典

字典是“键值对”的无序可变序列，字典中的每个元素都是一个“键值对”，包含：“键
对象”和“值对象”。可以通过“键对象”实现快速获取、删除、更新对应的“值对象”。
列表中我们通过“下标数字”找到对应的对象。字典中通过“键对象”找到对应的“值
对象”。“键”是任意的不可变数据，比如：整数、浮点数、字符串、元组。但是：列表、
字典、集合这些可变对象，不能作为“键”。并且“键”不可重复。
“值”可以是任意的数据，并且可重复。

	>>> value={
    
    'name':'卡卡西','age':'30','hope':'成为火影'}
>>> value
{
    
    'name': '卡卡西', 'age': '30', 'hope': '成为火影'}

字典的创建

  1. 通过{}、dict()来创建字典对象。
>>> a1={
    
    'name':'卡卡西','age':'30','job':'6代火影'}
>>> a1
{
    
    'name': '卡卡西', 'age': '30', 'job': '6代火影'}
>>> a2=dict(name='卡卡西',age=30,job='6代火影')
>>> a2
{
    
    'name': '卡卡西', 'age': 30, 'job': '6代火影'}
>>> a1=dict([('name','卡卡西'),('age',30)])
>>> a1
{
    
    'name': '卡卡西', 'age': 30}
>>> a3={
    
    }
>>> a3
{
    
    }
>>> a4=dict()
>>> a4
{
    
    }
  1. 通过 zip()创建字典对象
>>> a1=['name','age','job']
>>> a2=['卡卡西',30,'6代火影']
>>> a3=dict(zip(a1,a2))
>>> a3
{
    
    'name': '卡卡西', 'age': 30, 'job': '6代火影'}
  1. 通过 fromkeys 创建值为空的字典
>>> a1=dict.fromkeys(["name","age","job"])
>>> a1
{
    
    'name': None, 'age': None, 'job': None}

字典元素的访问

  1. 通过 [键] 获得“值”。若键不存在，则抛出异常。
>>> obj={
    
    "name":'卡卡西',"age":'30',"job":'6代火影'}
>>> obj
{
    
    'name': '卡卡西', 'age': '30', 'job': '6代火影'}
>>> obj["name"]
'卡卡西'
>>> obj["love"]
Traceback (most recent call last):
  File "<pyshell#57>", line 1, in <module>
    obj["love"]
KeyError: 'love'
  1. 通过 get()方法获得“值”。推荐使用。优点是：指定键不存在，返回 None；也可以设
    定指定键不存在时默认返回的对象。推荐使用 get()获取“值对象”。
>>> obj={
    
    "name":'卡卡西',"age":'30',"job":'6代火影'}
>>> obj
{
    
    'name': '卡卡西', 'age': '30', 'job': '6代火影'}
>>> obj.get("name")
'卡卡西'
>>> obj.get("love")
>>> print(obj.get("love"))
None
>>> obj={
    
    "name":'卡卡西',"age":'30',"job":'6代火影'}
>>> obj
{
    
    'name': '卡卡西', 'age': '30', 'job': '6代火影'}
>>> obj.get("name")
'卡卡西'
>>> obj.get("love")
>>> print(obj.get("love"))
None
>>> obj.get("love","带土和琳")
'带土和琳'
  1. 列出所有的键值对
>>> obj.items()
dict_items([('name', '卡卡西'), ('age', '30'), ('job', '6代火影')])
  1. 列出所有的键，列出所有的值
>>> obj.keys()
dict_keys(['name', 'age', 'job'])
>>> obj.values()
dict_values(['卡卡西', '30', '6代火影'])
  1. len()长度
>>>len(obj)
3
  1. 检测一个“键”是否在字典中
>>> obj={
    
    "name":'卡卡西',"age":'30',"job":'6代火影'}
>>> "name" in obj
True

字典元素添加、修改、删除

  1. 给字典新增“键值对”。如果“键”已经存在，则覆盖旧的键值对；如果“键”不存在，则新增“键值对”。
>>> obj={
    
    "name":'卡卡西',"age":'30',"job":'6代火影'}
>>> obj
{
    
    'name': '卡卡西', 'age': '30', 'job': '6代火影'}
>>> obj["name"]="我爱罗"
>>> obj
{
    
    'name': '我爱罗', 'age': '30', 'job': '6代火影'}
>>> obj["love"]="带土和琳"
>>> obj
{
    
    'name': '我爱罗', 'age': '30', 'job': '6代火影', 'love': '带土和琳'}
  1. 使用 update()将新字典中所有键值对全部添加到旧字典对象上。如果 key 有重复，则直接覆盖。
>>> obj={
    
    "name":'卡卡西',"age":'30',"job":'6代火影'}
>>> value={
    
    "name":'我爱罗',"hope":'有许多朋友'}
>>> obj.update(value)
>>> obj
{
    
    'name': '我爱罗', 'age': '30', 'job': '6代火影', 'hope': '有许多朋友'}
  1. 字典中元素的删除，可以使用 del()方法；或者 clear()删除所有键值对；pop()删除指定键值对，并返回对应的“值对象”；
>>> obj={
    
    "name":'卡卡西',"age":'30',"job":'6代火影'}
>>> obj
{
    
    'name': '卡卡西', 'age': '30', 'job': '6代火影'}
>>> del(obj["age"])
>>> obj
{
    
    'name': '卡卡西', 'job': '6代火影'}
>>> value=obj.pop("job")
>>> value
'6代火影'
>>> obj.clear()
>>> obj
{
    
    }
  1. popitem() ：随机删除和返回该键值对。字典是“无序可变序列”,
    因此没有第一个元素、最后一个元素的概念；popitem 弹出随机的项，
    为字典并没有"最后的元素"或者其他有关顺序的概念。
>>> obj={
    
    "name":'卡卡西',"age":'30',"job":'6代火影'}
>>> obj.popitem()
('job', '6代火影')
>>> obj
{
    
    'name': '卡卡西', 'age': '30'}
>>> obj.popitem()
('age', '30')
>>> obj
{
    
    'name': '卡卡西'}

序列解包

序列解包可以用于元组、列表、字典。序列解包可以让我们方便的对多个变量赋值。

>>> a,b,c=(1,2,3)
>>> a
1
>>> b
2
>>> c
3
>>> (a,b,c)=(1,2,3)
>>> a
1
>>> [a,b,c]=[1,2,3]
>>> a
1

序列解包用于字典时，默认是对“键”进行操作； 如果需要对键值对操作，则需要使用
items()；如果需要对“值”进行操作，则需要使用 values()；

>>> obj={
    
    "name":'卡卡西',"age":'30',"job":'6代火影'}
>>> name,age,job=obj		#默认对键进行操作
>>> job
'job'
>>> name,age,job=obj.items()		#对键值对进行操作
>>> age
('age', '30')
>>> name,age,job=obj.values()		#对值进行操作
>>> name
'卡卡西'

表格数据使用字典和列表存储，并实现访问

>>> a1={
    
    "name":'卡卡西',"age":'30'}
>>> a2={
    
    "name":'我爱罗',"age":'20'}
>>> table=[a1,a2]
>>> table
[{
    
    'name': '卡卡西', 'age': '30'}, {
    
    'name': '我爱罗', 'age': '20'}]
>>> print(table[0].get("name"))
卡卡西
>>> for i in range(len(table)):
	print(table[i].get("name"))

	
卡卡西
我爱罗
>>> for j in range(len(table)):
	print(table[j].get("name"),table[j].get("age"))

	
卡卡西 30
我爱罗 20
>>>

字典核心底层原理(重要)

字典对象的核心是散列表。散列表是一个稀疏数组（总是有空白元素的数组），数组的
每个单元叫做 bucket。每个 bucket 有两部分：一个是键对象的引用，一个是值对象的引
用。
由于，所有 bucket 结构和大小一致，我们可以通过偏移量来读取指定 bucket。


>>> value={
    
    }
>>> value["name"]="卡卡西"
>>> value
{
    
    'name': '卡卡西'}

假设字典 value 对象创建完后，数组长度为 4：
我们要把”name”=”卡卡西”这个键值对放到字典对象 a 中，首先第一步需要计算
键”name”的散列值。Python 中可以通过 hash()来计算。

>>> a={
    
    }
>>> a["name"]="卡卡西"
>>> a
{
    
    'name': '卡卡西'}
>>> bin(hash("name"))
'-0b100001101100011101101101001000010010001101001111011010010001001'

由于数组长度为 8，我们可以拿计算出的散列值的最右边 3 位数字作为偏移量，即
“101”，十进制是数字 5。我们查看偏移量 5，对应的 bucket 是否为空。如果为空，则
将键值对放进去。如果不为空，则依次取右边 3 位作为偏移量，即“100”，十进制是数字4。
再查看偏移量为 4 的 bucket 是否为空。直到找到为空的 bucket 将键值对放进去。

根据键查找“键值对”的底层过程

当我们调用 a.get("name")，就是根据键"name"查找到"键值对"，从而找到值
对象"卡卡西"。
第一步，我们仍然要计算"name"对象的散列值：

>>> bin(hash("name"))
'-0b1010111101001110110101100100101'

和存储的底层流程算法一致，也是依次取散列值的不同位置的数字。 假设数组长度为
8，我们可以拿计算出的散列值的最右边 3 位数字作为偏移量，即“101”，十进制是数字
5。我们查看偏移量 5，对应的 bucket 是否为空。如果为空，则返回 None。如果不为空，
则将这个 bucket 的键对象计算对应散列值，和我们的散列值进行比较，如果相等。则将对
应“值对象”返回。如果不相等，则再依次取其他几位数字，重新计算偏移量。依次取完后，
仍然没有找到。则返回 None。

用法总结：
1. 键必须可散列
(1) 数字、字符串、元组，都是可散列的。
(2) 自定义对象需要支持下面三点：

1 支持 hash()函数
2 支持通过__eq__()方法检测相等性。
3 若 a==b 为真，则 hash(a)==hash(b)也为真。
2. 字典在内存中开销巨大，典型的空间换时间。
3. 键查询速度很快
4. 往字典里面添加新建可能导致扩容，导致散列表中键的次序变化。因此，不要在遍历字
典的同时进行字典的修改。

集合

集合是无序可变，元素不能重复。实际上，集合底层是字典实现，集合的所有元素都是字典
中的“键对象”，因此是不能重复的且唯一的。

  1. 使用{}创建集合对象，并使用 add()方法添加元素。
>>> gather={
    
    1,2,3,4,5}
>>> gather
{
    
    1, 2, 3, 4, 5}
>>> gather.add(996)
>>> gather
{
    
    1, 2, 3, 4, 5, 996}
  1. 使用 set()，将列表、元组等可迭代对象转成集合。如果原来数据存在重复数据，则只保留一个。
>>> value=["卡卡西","我爱罗"]
>>> value
['卡卡西', '我爱罗']
>>> gather=set(value)
>>> gather
{
    
    '卡卡西', '我爱罗'}
  1. remove()删除指定元素；clear()清空整个集合
>>> content={
    
    "卡卡西","琳","带土","我爱罗","迪达拉"}
>>> content
{
    
    '迪达拉', '卡卡西', '带土', '琳', '我爱罗'}
>>> content.remove("琳","带土")		#只可以删除一个
Traceback (most recent call last):
  File "<pyshell#99>", line 1, in <module>
    content.remove("琳","带土")
TypeError: set.remove() takes exactly one argument (2 given)
>>> content.remove("琳")
>>> content
{
    
    '迪达拉', '卡卡西', '带土', '我爱罗'}
>>> content.clear()
>>> content
set()

集合相关操作

>>> a1={
    
    30,"卡卡西","火影"}
>>> a2={
    
    20,"漩涡鸣人","火影"}
>>> a1|a2		#交集
{
    
    '卡卡西', 20, '火影', '漩涡鸣人', 30}
>>> a1&a2		#并集
{
    
    '火影'}
>>> a1-a2		#差集
{
    
    '卡卡西', 30}
>>> a1.union(a2)		#交集
{
    
    '卡卡西', 20, '火影', '漩涡鸣人', 30}
>>> a1.intersection(a2)		#交集
{
    
    '火影'}
>>> a1.difference(a2)		#交集
{
    
    '卡卡西', 30}

猜你喜欢

转载自blog.csdn.net/ZHOU125disorder/article/details/112366787
今日推荐
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
周排行
rbac——界面、权限
Apache CXF + SpringMVC 整合发布WebService
so插件化
Vue.js实战系列---图标字体制作（svg格式）
PAT乙级 1007 素数对猜想(孪生素数对) (20分) ---（C语言 + 详细注释）
被IRM保护的文档，打开失败
Calendar和Date计算日期差的小问题
win10子系统ubuntu18.4安装docker
利用Wrap Shell Script定位Android Native内存泄漏
MySQL: Transaction (Part I - Basic Concept)
每日归档
更多
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022