首页 > 其他分享 >数据类型的内置方法

数据类型的内置方法

时间：2023-12-02 20:12:35浏览次数：31  
标签：info 内置 name Xanadu 数据类型 list num print 方法

数据类型的内置方法

一、数字类型（整数类型和浮点数类型）：

[1]整数类型（int）：

  • 在Python中，整数类型是一种不可变类型，及一旦创建其值就不能被修改

（1）类型强转

  • 使用int()将符合整数格式的字符串转换成整数类型
num = "123"
print(num, type(num))  # 123 <class 'str'>
print(int(num), type(int()))  # 123 <class 'int'>

（2）进制之间的转换

①十进制转化为其他进制：
print(bin(100))  # 0b1100100 十进制转化为二进制bin()
print(oct(100))  # 0o144 十进制转化为八进制oct()
print(hex(100))  # 0x64 十进制转化为十六进制hex()
②其他进制转化为十进制：
# 使用int(),想要转化的进制
print(int('0b1100100', 2)) # 100
print(int('0o144', 8)) # 100
print(int('0x64', 16)) # 100

[2]浮点数类型（float）：

(1)类型强转

  • 将符合浮点数类型的字符串转化为浮点数类型
 num = "3.14"
print(num, type(num))  # 3.14 <class 'str'>
print(float(num), type(float((num))))  # 3.14 <class 'float'>

(2)取整

  • 取整遵循四舍五入的原则
# 使用round()函数取整
print(round(3.4)) # 3
print(round(3.5)) # 5

[3]判断数字类型（函数.isdight()）：

num1 = b'5'  # bytes
num2 = '5'   # unicode
num3 = '五'  # 中文数字
num4 = 'V'   # 罗马数字

print(num1.isdigit())  # Ture
print(num2.isdigit())  # Ture 符合数字类型的字符串也判断为Ture	
print(num3.isdigit())  # False
print(num4.isdigit())  # False

二、字符串类型（str）：

[1]索引取值

  • 通过索引下标进行取值，下标为负数时会报错
name = "Xanadu"
print(name[0]) # X
print(name[2]) # n
print(name[4]) # d

[2]字符串拼接

# 第一种拼接方法
word_1 = "Hello"
word_2 = "World"
print(word_1 + word_2)  # HelloWorld

# 第二种拼接方法 ---join
word_new = '-'.join(word_1)
print(word_new)  # H-e-l-l-o ，将指定的字符插入每个字符之间

[3]切片

name = "Xanadu"
name_new_1 = name[0] + name[2]
print(name_new_1)  # Xn
name_new_2 = name[1:5]
print(name_new_2)  # anad 字符串的切片也是顾头不顾尾，尾部位置需要将想要的位置加一
name_new_3 = name[0:5:2]
print(name_new_3)  # Xnd 切片也可以设置步长
# 特殊用法
name_new_4 = name[::2]
print(name_new_4)  # Xnd 
name_new_5 = name[2::]
print(name_new_5)  # nadu
name_new_6 = name[-1:-4:-2]
# 我们可以这样理解先去除从 -1 到 -4 的 为 udan(因为是反向取值的原因先去到的是u）,然后是步长隔一个字符去第1、3个字符使用是 u a
print(name_new_6)  # ua

[4]计算长度

# 使用len()函数
name = "Xanadu"
print(len(name)) # 6

[5]成员运算

#使用 in 关键字 来 进行成员判断，返回布尔类型
name = "Xanadu"
print('a' in name)  # True
print('b' in name)  # False

[6]去除空格

#使用.strip()来去除字符串收尾的空格，无返回值，直接改变字符串
name = "    Xanadu    "
print(name.strip())  # Xanadu

#使用.lstri()和.rstrip()来去除字符串首或为的空格
print(name.rstrip())  #     Xanadu
print(name.lstrip())  # Xanadu    

#还可以自定义去除指定字符
name = "%%Xanadu%%"
print(name.strip("%"))  # Xanadu

[7]切分

# 使用.split() 来进行字符串的切分
# 默认的切分符号是空格，切分符号不会被输出
# 切分的返回值时序列
sentence = "my name is Xanadu"
print(sentence.split())  # ['my', 'name', 'is', 'Xanadu']
print(sentence.split("a"))  # ['my n', 'me is X', 'n', 'du']

#使用rspliet 和 split 还有其中的参数来精准控制切分的方向和次数
sentence = "my name is Xanadu"
print(sentence.rsplit(" ", 2))  # ['my name', 'is', 'Xanadu']
print(sentence.split(" ", 2))  # ['my', 'name', 'is Xanadu']

[8]遍历

#使用for循环来进行遍历
name = "Xanadu"
for i in name:
    print(i, end=" ")  # X a n a d u

[9]重复

#直接使用 * + 要重复的次数 来重复字符串
name = "Xanadu"
print(name * 3)  # XanaduXanaduXanadu

[10]大小写转换

# 使用.upper()和.lower()函数进行大小写的转换
name = "Xanadu"
print(name.upper())  # XANADU
print(name.lower())  # xanadu

#使用.isupper()和.islower()函数进行大小写的判断，返回布尔类型
name_1 = "XANADU"
name_2 = "xanadu"
print(name_1.isupper())  # True
print(name_2.islower())  # True

[11]首尾字符判断

name = "Xanadu"

#使用.startswith()方法判断字符串是否以指定字符开头
print(name.startswith("a"))  # False
print(name.startswith("X"))  # True

#使用.startswith()方法判断字符串是否以指定字符结尾
print(name.endswith("b"))  # False
print(name.endswith("u"))  # True

[12]格式化输出

name = "Xanadu"
age = 20
# 第一种使用 %s %d 等占位符（%s 可以站位字符串类型变量，%d站位数字类型变量）
print("my name  is %s, my age is %s" % (name, age)) 
# my name  is Xanadu, my age is 20

# 第二种使用format()函数
print("my name  is {}, my age is {}".format(name, age))
# my name  is Xanadu, my age is 20

#第三种使用f + {} 
print(f"my name  is {name}, my age is {age}")
# my name  is Xanadu, my age is 20

[13]替换

#使用.replace()方法进行字符串的替换
name = "Xanadu"
print(name.replace("Xanadu", "bridge"))  # bridge

[14]判断字符串类型是否符合数字类型格式

# 使用.isdigit()来判断字符串类型是否符合数字类型格式
age = input("年龄 :>>> ")
if age.isdigit():
    print(age, type(age))
else:
    print("出错了")
# 输入不符合数字类型格式的字符串 年龄 :>>> l 出错了

# 输入符合数字类型格式的字符串 年龄 :>>> 20 20 <class 'str'>

三、列表类型（list）：

[1]类型强制转换：

  • 但凡能被for循环遍历的数据类型都可以传给list()转换成列表类型
    • list()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到列表中
# 字符串类型强转成列表类型就是将每一个元素都拿出，凑成一个列表
name = "name"
print(list(name))  # ['n', 'a', 'm', 'e']

# 元组类型强转成列表类型，元组中的每一个元素就是列表的每一个元素
name_tuple = ("Xanadu", "bridge", "water", "Farm")
print(list(name_tuple))  # ['Xanadu', 'bridge', 'water', 'Farm']

# 集合类型强转成列表类型，集合中的每一个元素就是列表的每一个元素
name_set = {"Xanadu", "bridge", "water", "Farm"}
print(list(name_set))  # ['bridge', 'Xanadu', 'water', 'Farm']

# 字典类型强转成列表类型，字典中的每一个键就是列表中的每一个元素
name_dict = {"name": "Xanadu", "age": 20}
print(list(name_dict))  # ['name', 'age']

#布尔类型不支持，数字类型也不支持

#特殊：range
# 可将range区间生成新的列表
print(list(range(1, 5)))  # [1, 2, 3, 4]

[2]索引取值：

#可以正反方向索引取值
name_list = ["Xanadu", "bridge", "water", "Farm"]
print(name_list[1])  # bridge
print(name_list[-1])  # Farm

[3]切片

# 列表的切片也是顾头不顾尾，具体参照字符串切片
name_list = ["Xanadu", "bridge", "water", "Farm"]
print(name_ist[1:3])  # ['bridge', 'water']

[4]计算长度

#使用len()函数
name_list = ["Xanadu", "bridge", "water", "Farm"]
print(len(name_list))  # 4

[5]成员运算

#使用‘ "要判断的字符" in list（要判断的列表）’进行成员运算
name_list = ["Xanadu", "bridge", "water", "Farm"]
print("Xanadu" in name_list)  # True 结果会返回布尔类型值，表示成员存在与否

[6]增加

# 第一种方法使用.append()方法 要增加的值会插入列表的最后，不会有返回值，直接改变原来的列表
name_list = ["Xanadu", "bridge", "water", "Farm"]
name_list.append("road")
print(name_list)  # ['Xanadu', 'bridge', 'water', 'Farm', 'road']

#第二种方法使用.extend()方法，要增加的值会插入列表的最后，同样不会有返回值，直接改变原来的列表
name_list = ["Xanadu", "bridge", "water", "Farm"]

#这种方法的好处是可以插入不同类型的值，具体每一种插入的值参照列表的强制转换方法
name_list.extend([1, 2])
name_list.extend((3, 4))
name_list.extend({5, 6})
name_list.extend({"name": "road", "age": 20})  
print(name_list)  # ['Xanadu', 'bridge', 'water', 'Farm', 1, 2, 3, 4, 5, 6, 'name', 'age']

#第三种方法.insert()，可以输入参数来通过索引下标选择插入位置和值
name_list = ["Xanadu", "bridge", "water", "Farm"]
name_list.insert(1, "road")
print(name_list)  # ['Xanadu', 'road', 'bridge', 'water', 'Farm']

[7]删除

# 方法一使用 del 通过下标查找并删除列表中的元素，没有返回值 
# 如果输入的下标位置没有元素就会报错
name_list = ['Xanadu', 'bridge', 'water', 'Farm']
del name_list[0]
print(name_list)  # ['bridge', 'water', 'Farm']

# 方法二 使用.pop()通过下标查找并删除列表中的元素，返回删掉的元素

# 不输入参数值默认删除列表最后一个元素
name_del = name_list.pop()
print(name_del)  # Farm
print(name_list)  # ['Xanadu', 'bridge', 'water']
# 输入了参数值就删除指定元素，如果输入的下标位置没有元素就会报错
name_del = name_list.pop(0)
print(name_del)  # Xanadu
print(name_list)  # ['bridge', 'water', 'Farm']

#方法三使用.remove(),要输入指定元素进行删除，没有返回值 
name_list = ['Xanadu', 'bridge', 'water', 'Farm']
name_list.remove("Xanadu")
print(name_list)  # ['bridge', 'water', 'Farm']

[8]修改

# 直接使用索引取出对应元素重新赋值就可
name_list = ['Xanadu', 'bridge', 'water', 'Farm']
name_list[0] = "road"
print(name_list)  # ['road', 'bridge', 'water', 'Farm']

[9]颠倒元素

# 使用.reverse()方法，直接改变列表，没有返回值
name_list = ['Xanadu', 'bridge', 'water', 'Farm']
name_list.reverse()
print(name_list)  # ['Farm', 'water', 'bridge', 'Xanadu']

[10]排序方法

# 使用.sort()方法 默认从小到大排序 有返回值就是排序好的列表
number_list = [1, 5, 2, 4, 3, 6]
number_list.sort()
print(number_list)  # [1, 2, 3, 4, 5, 6]

# 可以添加参数（reverse = Ture）来进行从大到小进行排序
# 原理就是先按照从小到大排好，之后用 reverse 反转 ，所以就变成了 从大到小
number_list = [1, 5, 2, 4, 3, 6]
number_list.sort(reverse=True)
print(number_list)  # [6, 5, 4, 3, 2, 1]

[11]迭代循环

#使用for循环进行迭代
name_list = ['Xanadu', 'bridge', 'water', 'Farm']
for i in name_list:
    print(i, end=" ")  # Xanadu bridge water Farm

    
 #加入range()进行for循环迭代
name_list = ['Xanadu', 'bridge', 'water', 'Farm']
for i in range(len(name_list)):
    print(name_list[i], end=" ")  # Xanadu bridge water Farm

    
 #使用while循环进行迭代
name_list = ['Xanadu', 'bridge', 'water', 'Farm']
count = 0
while count < len(name_list):
    print(name_list[count], end=" ")  # Xanadu bridge water Farm
    count += 1

[12补充]

（1）步长：

#可以通过切片的步长来进行列表和字符串的反转
name_list = ['Xanadu', 'bridge', 'water', 'Farm']
name_list = name_list[::-1]
print(name_list)  # ['Farm', 'water', 'bridge', 'Xanadu']
name = "Xanadu"
name = name[::-1]
print(name)  # udanaX

（2）字符串大小比较:

ASCII 一览表（https://c.biancheng.net/c/ascii/）

#字符串可以通过ASCII 表中对应的码值进行大小的比较
a = 'abc'
b = 'acd'
#"a"对应的码值是61  "b"对应的是62 "c"对应的是63 ，以此类推
print(a > b)  # False

四、字典类型（dict）：

[1]取值

# 字典类型 ---- dict
# 键值对定义 {'key':"value",}
# key : 建议使用不可变数类型 -- 字符串 / 数字类型
# value ：可以是任意的数据类型

# 第一种方法：通过'key'值来取 "value" 格式如下： dict[key]
# 如果key值字典中没有，就会报错
info = {"name": "Xanadu", "age": 20}
name = info["name"]
print(name) # Xanadu

# 第二种方法：使用.get 函数通过key值来取value值   
# 如果如果key值字典中没有，会返回None ；也可以设定参数，找不到时返回指定参数
info = {"name": "Xanadu", "age": 20}
name = info.get("name")
print(name)  # Xanadu

[2]计算长度

  # 使用len()函数
info = {"name": "Xanadu", "age": 20}
print(len(info)) # 2

[3]成员运算

  #使用 "想要判断的元素" in 字典名 这样只能判断字典里的key值
info = {"name": "Xanadu", "age": 20}
print("name" in info)  # True
print("Xanadu" in info)  # False

[4]增加

  # 方法一，使用字典名[key] = value 
  # 没有相同key，就新增一个（key :value），有相同就修改value
info = {"name": "Xanadu", "age": 20}
info["height"] = 177.5
print(info)  # {'name': 'Xanadu', 'age': 20, 'height': 177.5}

# 方法二使用.update()方法，参数格式为 key=value，可以同时增加多组数据
# 没有相同key，就新增一个（key :value），有相同就修改value
info = {"name": "Xanadu", "age": 20}
info.update(name="bridge")
print(info)  # {'name': 'bridge', 'age': 20}
info.update(height=177.5)
print(info)  # {'name': 'bridge', 'age': 20, 'height': 177.5}

# 可以同时增加多组数据
info = {"name": "Xanadu", "age": 20}
info.update(name="bridge", height=177.5)
print(info)  # {'name': 'bridge', 'age': 20, 'height': 177.5}

# 还可以直接以字典为增加元素，字典中也可以嵌套列表字典等
info = {"name": "Xanadu", "age": 20}
info_add = {"bobby": ["music"], }
info.update(info_add)
print(info)  # {'name': 'Xanadu', 'age': 20, 'bobby': ['music']}

# 方法三，使用.setdeflalt()方法，参数格式为(key，value)，一次只能增加一组数据
# 返回值为参数中的value， 没有相同key，就新增一个（key :value），有相同就修改value
info = {"name": "Xanadu", "age": 20}
res = info.setdefault("height", 177.5)
print(res)  # 177.5
print(info)  # {'name': 'Xanadu', 'age': 20, 'height': 177.5}

[5]删除

# 第一种方法使用del 字典名[key],来删除key指定的键值对，找不到对应key会报错
info = {"name": "Xanadu", "age": 20}
del info["name"]
print(info)  # {'age': 20}

# 第二种方法使用.pop()方法，参数为key，返回值为删除的value，找不到对应key会报错
info = {"name": "Xanadu", "age": 20}
info_del = info.pop("name")
print(info_del)  # Xanadu
print(info)  # {'age': 20}

#第三种方法使用字典名.clear()来讲指定字典清空
info = {"name": "Xanadu", "age": 20}
info.clear()
print(info)  # {}

#第四种方法使用字典名.popitem()，删除指定字典的结尾键值对	
info = {"name": "Xanadu", "age": 20}
info_del = info.popitem()
print(info_del)  # ('age', 20)
print(info)  # {'name': 'Xanadu'}

[6]遍历

# 使用for循环进行遍历，遍历出的值是key
info = {"name": "Xanadu", "age": 20}
for i in info:
    print(i, end=" ")  # name age

for key, value in info.items():
    print(key, value, end=" ")  # name Xanadu age 20

[7]字典的排序

# 字典类型没有 sort 方法
# user_dict.sort()报错
info = {"name": "Xanadu", "age": 20}
info_num = {"number1": 1, "number2": 2, "number3": 3}
res_1 = sorted(info.items())
res_2 = sorted(info_num)
print(res_1)  # [('age', 20), ('name', 'Xanadu')]
print(res_2)  # ['number1', 'number2', 'number3']

[8]键对，值对，键值对

# 字典名.keys() .values() .items() 分别可以返回指定字典的键对，值对和键值对
info = {"name": "Xanadu", "age": 20}
print("name" in info.keys())  # True
print("sex" in info.keys())  # False
print(info.keys())  # dict_keys(['name', 'age'])
print(info.values())  # dict_values(['Xanadu', 20])
print(info.items())  # dict_items([('name', 'Xanadu'), ('age', 20)])
for key, value in info.items():
    print(key, value, end=" ")  # name Xanadu age 20

五、元组类型（tuple）：

# 【】元组类型 --- tuple
# 定义 --- 一个元素的时候要 加 ,
# name_tuple = ('Xanadu',)
# print(name_tuple, type(name_tuple))  # ('Xanadu',) <class 'tuple'>

[1]类型强转

num_list = [1, 2, 3, 4]
name = "Xanadu"
set_1 = {1, 2, 3, 4}
info = {"name": "Xanadu", "age": 20}

# 支持列表强转成元组类型
num_tuple = tuple(num_list)
print(num_tuple)  # (1, 2, 3, 4)

# 字符串支持
name_tuple = tuple(name)
print(name_tuple)  # ('X', 'a', 'n', 'a', 'd', 'u')

# 集合也支持转成元组
tuple_set =tuple(set_1)
print(tuple_set)  #  (1, 2, 3, 4)

# 字典支持，但是字典转换完以后是键
info_tuple = tuple(info)
print(info_tuple)  # ('name', 'age')

# 数字类型不支持

[2]取值

# 可以索引取值，但是不支持索引取出来再修改
name_tuple = ("Xanadu", "bridge", "water", "farm")
name = name_tuple[0]
print(name)  # Xanadu

[3]计算长度

# 使用len()函数
name_tuple = ("Xanadu", "bridge", "water", "farm")
print(len(name_tuple))  # 4

[4]切片

# 顾头不顾尾 [起始索引:结束索引:步长]
name_tuple = ("Xanadu", "bridge", "water", "farm")
print(name_tuple[0:4:2])  # ('Xanadu', 'water')

六、集合类型（set）：

# num_set = {1, 2, 3, 4, 5, 6}
# 集合里面的元素可以是单独的一个元素，可以不加 ,
# num_set_one = {1}
# print(num_set_one,type(num_set_one))

[1]类型强转

# 集合的特点就是无序性
# print(set('dream'))
# 集合的另一大特性就是去重，去除重复的元素
# print(set('dreame'))

num_list = [1, 2, 3, 4]
dict_user = {"name": "Xanadu", "age": 20}
num_tuple = (1, 2, 3, 4, 5)
name = "Xanadu"

# 列表类型可以强转成集合类型
print(set(num_list))  # {1, 2, 3, 4}
# 字典类型可以强转成集合类型
print(set(dict_user.values()))  # {'Xanadu', 20}
# 元组类型可以强转成集合类型
print(set(num_tuple))  # {1, 2, 3, 4, 5}
# 字符串类型可以强转成集合类型
print(set(name))  # {'u', 'n', 'd', 'a', 'X'}
# 数字类型不可以
# print(set(1))

[2]增加元素

#方法一，使用.add()方法
num_set = {1, 2, 3, 4, 5}
num_set.add(6)
print(num_set)  # {1, 2, 3, 4, 5, 6}

#方法二，使用.update方法
# 可以更新多个元素到原来的集合中
# 放的参数要是可迭代类型(字符串/列表/字典/元组)
# 重复的元素会按照集合的特性进行去重
# 不重复的元素就会被加进去
num_set = {1, 2, 3, 4, 5}
num_set.update({5, 6, 7})
num_set.update({8, 9, 10})
num_set.update("Xanadu")
print(num_set)  # {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 'n', 'a', 'X', 'd', 'u'}

[3]删除元素

#第一种方法，使用.remove()方法，按照集合中的值删除掉指定元素
num_set = {1, 2, 3, 4, 5}
num_set.remove(1)
print(num_set)  # {2, 3, 4, 5}
# 没有找到指定元素的时候就会报错
num_set.remove(6)
print(num_set)

#第二种方式，使用.discard()方法
num_set = {1, 2, 3, 4, 5}
# 根据指定的值删除掉集合中指定的元素
num_set.discard(1)
print(num_set)  # {2, 3, 4, 5}
#如果删除的值在集合中不存在，那就会无反应，不会报错
num_set.discard(0)
print(num_set)  # {2, 3, 4, 5}

# 第三种方式，使用.pop()方法，会返回删掉的元素
num_set = {1, 2, 3, 4, 5}
res = num_set.pop()
# 把集合的第一个元素删除掉了
print(res)  # 1
print(num_set)  # {2, 3, 4, 5}

[4]集合的运算方法

# 并集/交集/差集
num_set_1 = {1, 2, 3, 4}
num_set_2 = {3, 4, 5, 6}
# 并集
union_set_1 = num_set_1.union(num_set_2)
#  交集
union_set_2 = num_set_1.difference(num_set_2)
#  差集
union_set_3 = num_set_1.intersection(num_set_2)
#  对称差集
union_set_4 = num_set_1.symmetric_difference(num_set_2)
print(union_set_1)  # {1, 2, 3, 4, 5, 6}
print(union_set_2)  # {1, 2}
print(union_set_3)  # {3, 4}
print(union_set_4)  # {1, 2, 5, 6}

[5]判断是否相等

print({1,2,3,4} == {1,2,3}) # False

[6]计算长度

print(len({1, 2, 3, })) # 3

[7]遍历

num_set = {1, 2, 3, 4, 5}
for i in num_set:
    print(i, end=" ")  # 1 2 3 4 5

[8]成员运算

# 在就是 true 不在就是 false
print(1 in {1, 2, 3}) # True

七、布尔类型（bool）

# 强制类型转换
num = 1
print(bool(num), type(bool(num)))  # True <class 'bool'>
# 代表真的情况：数字类型1 ---> 有值的数字类型都是真
# 有值的字符串/列表/字典/元组/集合 --> 真

name = 'Xanadu'
print(bool(name), type(bool(name)))  # True <class 'bool'>

# 假的情况 ：
# 数字类型 ： 0
# 空的字符串 / 列表 /元组 /字典
num_one = 0
print(bool(num_one), type(bool(num_one)))  # False <class 'bool'>
name = ''
print(bool(name), type(bool(name)))  # False <class 'bool'>

八、数据类型总结

按存值个数区分
只能存一个值：可称为标量/原子类型 数字类型、字符串
可以存放多个值：可称为容器类型 列表、元祖、字典
按照访问方式区分
直接访问：只能通过变量名访问整个值 数字类型
顺序访问：可以通过索引访问指定的值，索引代表顺序，又称为序列类型 字符串、列表、元祖
key访问：可以用key访问指定的值，又称为映射类型 字典
按可变不可变区分
可变类型 列表、字典
不可变类型 数字、字符串、元祖

标签：info,内置,name,Xanadu,数据类型,list,num,print,方法
From： https://www.cnblogs.com/taoyuanshi/p/17872149.html

相关文章

  • SQLBI_精通DAX课程笔记_02_数据类型
    SQLBI_精通DAX课程笔记_02_数据类型PowerBi和AnalysisServices在数据加载环节，无论数据源是什么类型，都会自动将数据转化为DAX可用的数据类型集。以下链接为微软官方文档，也可以参考浏览：https://learn.microsoft.com/zh-cn/power-bi/connect-data/desktop-data-types一：数据类......
  • 代码阅读方法与实践
    《代码阅读方法与实践》阅读笔记总体印象：《代码阅读方法与实践》是一本引人深思的书籍，旨在帮助开发者更有效地阅读、理解和应用代码。作者以清晰而生动的语言，深入浅出地探讨了代码阅读的方法和实践，为读者提供了宝贵的思考和工作工具。核心观点：代码即文档：作者强调代码本身就......
  • 什么是 Spartacus 的 ConfigModule.withConfig 方法
    Spartacus是一个开源的JavaScript商业前端库，使用Angular和RxJS构建，用于SAPCommerceCloud。它允许开发人员创建SPA（SinglePageApplication）应用，提供灵活的配置，以便灵活地适应不同的业务需求。在Spartacus中，ConfigModule.withConfig是一个非常重要的方法，它可以用于......
  • 无涯教程-Erlang - 数据类型
    您可能希望存储各种数据类型的信息，例如string，character，widecharacter，integer，floatingpoint，Boolean等，系统根据变量的数据类型分配内存。内置数据类型Erlang提供了多种内置数据类型，以下是在Erlang中定义的数据类型的列表-Number  - 在Erlang中，它们是integers和floats。......
  • Matlab中边缘提取方法简析
    ​ 1、Matlab简述Matlab是国际上最流行的科学与工程计算的软件工具，它起源于矩阵运算，已经发展成一种高度集成的计算机语言。有人称它为“第四代”计算机语言，它提供了强大的科学运算、灵活的程序设计流程、高质量的图形可视化界面设计、便捷的与其它程序和语言接口的功能。随......
  • Photoshop批量替换图层的方法
    平时做图片，应该有遇到这样的场景，比如P奖状、P邀请函，内容是一样的，但是图片上的名字是不一样的，要是要P100张的话，一个个手动复制改名字肯定会吐血(╯°□°）╯︵┻━┻Photoshop里有个变量的功能，就是专门解决这个问题的。先将要批量替换的图层，通常是文字图层，单独新建一层。然后在图......
  • AbstractApplicationContext的核心方法refresh()解析
    AbstractApplicationContext的refresh()是Spring最核心的方法，没有之一，上帝就是用这个方法创造了Spring的世界。这是一个同步方法，用synchronized关键字来实现的。该方法包含以下12个方法（步骤）。prepareRefresh()obtainFreshBeanFactory()prepareBeanFactory(beanFactory)......
  • wangeditor 富文本 使用及 上传本地图片的方法
    文章标题：Vue组件实现富文本编辑器文章摘要：本文介绍了如何使用Vue和Wangeditor插件实现富文本编辑器组件，并详细解释了组件中的各个部分和功能。Vue组件实现富文本编辑器在Web开发中，富文本编辑器是一个非常常见的功能，它能够让用户以所见即所得的方式编辑和排版文本内容。......
  • 无涯教程-D语言 - 类静态方法函数
    让我们尝试以下示例以了解静态数据成员的概念-importstd.stdio;classBox{public:staticintobjectCount=0;//构造函数定义this(doublel=2.0,doubleb=2.0,doubleh=2.0){writeln("Constructorcalled.");length=l;......
  • OOM了？物理内存不够了？试试这个方法来提升内存容量，不花钱的
    通过增加虚拟内存来提高内存使用本文解决的实际问题：当我们物理内存小的时候，会出现OOM，然后服务自动死掉的情况。因为物理内存大小是固定的，有没有其他好的办法来解决呢？这里我们可以适当调整Linux的虚拟内存来协作。问题描述：最近遇到一个情况，物理内存不够，导致项目一两天就自动死掉了。......

赞助商

阅读排行

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

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

Copyright © 2020-2023 IPS99 版权所有 IPS99