首页 > 编程语言 >python基础汇总（1）

python基础汇总（1）

时间：2024-07-05 14:58:09浏览次数：24  
标签：python list 元素 基础 汇总 print 列表 tinydict 字典

开始可以借鉴阿里腾讯开发规范——实际中运用会大体相近

1、注释

#：单行注释

‘’‘ ’‘’ 或者“”“ ”“”：多行注释

2、标识符

合法：

ABC、ABC_123、姓名、_123

不合法：

123、1ABC、if(保留字)、init（预定义标识符）

（1)当标识符用作模块名时，应尽量短小，并且全部使用小写字母，可以使用下划线分割多个字母，例如game_main、game_register等。 (2)当标识符用作包的名称时，应尽量短小，并且全部使用小写字母，不推荐使用下划线，例如com.mr、com.mr.book等。 (3)当标识符用作类名时，应采用单词首字母大写的形式。例如，定义一个图书类，可以命名为Book。 (4)模块内部的类名，可以采用“下划线+首字母大写”的形式,如_Book。 函数名、类中的属性名和方法名，应全部使用小写字母，多个单词之间可以用下划线分割。 (5)常量命名应全部使用大写字母，单词之间可以用下划线分割。

  1. 字符集和格式：

    • 标识符可以包含字母（大小写敏感）、数字和下划线 。_

    • 标识符的第一个字符必须是字母（大写或小写）或下划线 。_

  2. 关键字和保留字：

    • 不能使用Python中的关键字和保留字作为标识符。这些包括 , , , , , 等。if``else``for``while``class``def

  3. 大小写敏感：

    • Python是大小写敏感的，因此标识符的大小写会被区分。

  4. 命名约定：

    • Python通常推荐以下划线命名法（Snake Case）来命名变量、函数、方法和模块名。这意味着多个单词用下划线连接，例如 , 。my_variable``calculate_area()

  5. 类命名约定：

    • 类名通常使用首字母大写的驼峰命名法（Pascal Case），例如 ， 。MyClass``MyClassWithMethods

  6. 变量和函数名：

    • 变量名和函数名应该具有描述性，能够清晰地表达其用途或含义。

    • 例如max_value`，calculate_area(), `is_valid(), 等。

  7. 常量命名：

    • Python中没有真正意义上的常量，但是约定上，常量通常使用全大写字母，用下划线分隔单词。例如,MAX_SIZE`,`PI`,`DEFAULT_VALUE.

input函数：

实现用户的输入

eval函数：

以python表达式的方式解析并执行字符串

print函数：

默认是换行的

print（'123'） 换行

print（'123' ,end=" ") 不换行

3、数值类型

基本的数值类型：int、float、string、complex(复数类型：见的少 3+5j )

空值：None,常用于没有返回值的函数结果，

bool：值为true 和 flase

bytes：用bytes()函数进行数据转换；这种类型用于网络数据传输、二进制图片和文件的保存

  • Number（数字）

  • String（字符串）

  • bool（布尔类型）

  • List（列表）

  • Tuple（元组）

  • Set（集合）

  • Dictionary（字典）

Python3 的六个标准数据类型中：

  • 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；

  • 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

此外还有一些高级的数据类型，如: 字节数组类型(bytes)。

（1）浮点类型详解

  1. 十进制形式 这种就是我们平时看到的小数形式，例如 34.6、346.0、0.346。

书写小数时必须包含一个小数点，否则会被 Python 当作整数处理。

     2、指数形式 Python 小数的指数形式的写法为：

aEn 或 aen

a 为尾数部分，是一个十进制数；n 为指数部分，是一个十进制整数；E或e是固定的字符，用于分割尾数部分和指数部分。整个表达式等价于 a×10n。

指数形式的小数举例：

2.1E5 = 2.1×105，其中 2.1 是尾数，5 是指数。 3.7E-2 = 3.7×10-2，其中 3.7 是尾数，-2 是指数。 0.5E7 = 0.5×107，其中 0.5 是尾数，7 是指数。

注意，只要写成指数形式就是小数，即使它的最终值看起来像一个整数。例如 14E3 等价于 14000，但 14E3 是一个小数。

Python 只有一种小数类型，就是 float。C语言有两种小数类型，分别是 float 和 double：float 能容纳的小数范围比较小，double 能容纳的小数范围比较大。

【实例】小数在 Python 中的使用：

f1 = 12.5
print("f1Value: ", f1)
print("f1Type: ", type(f1))
 
f2 = 0.34557808421257003
print("f2Value: ", f2)
print("f2Type: ", type(f2))
 #当数值过小时Python会自动将其转换为科学计数法的形式，以更方便地显示和理解极小的数值。
f3 = 0.0000000000000000000000000847
print("f3Value: ", f3)
print("f3Type: ", type(f3))
 
f4 = 345679745132456787324523453.45006
print("f4Value: ", f4)
print("f4Type: ", type(f4))
 
f5 = 12e4
print("f5Value: ", f5)
print("f5Type: ", type(f5))
 
f6 = 12.3 * 0.1
print("f6Value: ", f6)
print("f6Type: ", type(f6))

4、字符串的索引和切片

这个不多说看菜鸟教程，一看就会

'+'在字符串中有连接作用；

len(s)：返回s的长度或其他组合类型的元素个数

# 用法示例
my_list = [1, 2, 3, 4, 5]
print(len(my_list))  # 输出: 5
​
my_string = "Hello, World!"
print(len(my_string))  # 输出: 13
​
my_dict = {'a': 1, 'b': 2, 'c': 3}
print(len(my_dict))  # 输出: 3
​

str(s):把元素(s)转换为字符串

chr(‘65’):返回‘A’;

5、数据类型转换

1、type()

对变量进行类型的判断

自动类型的转换(不同类型混合运算生成的结果为最宽的类型)

type(10/4*4)
flaot
123+4.0=127.0

2、isinstance()

跟提供的类型进行对比

isinstance(3，int)
true
isinstance(3.2,int)
flase
isinstance(3.2,(int,float,str))
true

6、正则表达式的常用函数

re.complie()使正则表达式变为正则表达式对象——一般使用网上工具

import re
strpat = r'(\d+)'(\.\d*)?‘
txt=.....
pats=re.complie(strpat)

re.match()扫描提供的对象，查找是否有匹配的

escape()

如果特殊字符太多，需要输入大量反斜杠，可以使用escape()

7、列表、元组、字典

列表（List）

  1. 有序集合：列表是有序的，可以通过索引访问元素，适合存储顺序相关的数据。

  2. 可变性：列表是可变的，可以动态增删元素，适合需要频繁修改数据的场景。

  3. 适用场景：

    • 存储同类型或不同类型的数据集合，例如存储一组学生名单、待办事项列表等。

    • 需要动态增删元素的情况，例如管理用户的收藏列表、网站的文章列表等。

元组（Tuple）

  1. 不可变性：元组一旦创建后，其内容不可修改，具有保护数据的特性。

  2. 性能优势：元组比列表更加轻量和高效，适合作为常量集合使用。

  3. 适用场景：

    • 存储不会改变的数据集合，例如存储一组坐标、日期时间信息等。

    • 作为函数返回值，可以确保数据不被修改。

    • 在多线程环境下作为安全的数据结构使用。

字典（Dictionary）

  1. 键值对：字典存储的是键值对，可以通过键快速查找值，适合需要快速访问和查找数据的场景。

  2. 动态性：字典是可变的，可以方便地增删键值对，适合动态更新和管理数据。

  3. 适用场景：

    • 存储具有映射关系的数据，例如用户信息、产品属性等。

    • 需要快速查找和更新数据的情况，例如建立用户ID到详细信息的映射、存储配置信息等。

    • JSON 格式数据的解析和处理。

总结

  • 列表适合存储有序的元素集合，需要频繁增删操作的场景。

  • 元组适合不可变的、静态数据集合，用于保护数据或作为常量集合使用。

  • 字典适合存储键值对，需要快速查找和更新数据的场景。

(1)列表

（1）索引和切片

#!/usr/bin/python3
​
list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[0] )
print( list[1] )
print( list[2] )
​
#反向索引
#!/usr/bin/python3
​
list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[-1] )
print( list[-2] )
print( list[-3] )

（2）切片

#!/usr/bin/python3
​
nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
print(nums[0:4])
​
#反向所以截止
#!/usr/bin/python3
​
list = ['Google', 'Runoob', "Zhihu", "Taobao", "Wiki"]
​
# 读取第二位
print ("list[1]: ", list[1])
# 从第二位开始（包含）截取到倒数第二位（不包含）
print ("list[1:-2]: ", list[1:-2])

（3）修改和更新

#!/usr/bin/python3
​
list = ['Google', 'Runoob', 1997, 2000]
​
print ("第三个元素为 : ", list[2])
list[2] = 2001
print ("更新后的第三个元素为 : ", list[2])
​
list1 = ['Google', 'Runoob', 'Taobao']
list1.append('Baidu')
print ("更新后的列表 : ", list1)
​
#输出
第三个元素为 :  1997
更新后的第三个元素为 :  2001
更新后的列表 :  ['Google', 'Runoob', 'Taobao', 'Baidu']

（4）删除(del)

#!/usr/bin/python3
 
list = ['Google', 'Runoob', 1997, 2000]
 
print ("原始列表 : ", list)
del list[2]
print ("删除第三个元素 : ", list)

#输出
原始列表 :  ['Google', 'Runoob', 1997, 2000]
删除第三个元素 :  ['Google', 'Runoob', 2000]

（5）拼接和比较

>>> squares = [1, 4, 9, 16, 25]
>>> squares += [36, 49, 64, 81, 100]
>>> squares
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>>

#嵌套
>>> a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

#比较
# 导入 operator 模块
import operator

a = [1, 2]
b = [2, 3]
c = [2, 3]
print("operator.eq(a,b): ", operator.eq(a,b))
print("operator.eq(c,b): ", operator.eq(c,b))

#输出
operator.eq(a,b):  False
operator.eq(c,b):  True

（6）列表的函数和方法

函数：
len(list)
列表元素个数
max(list)
返回列表元素最大值
min(list)
返回列表元素最小值
list(seq)
将元组转换为列表

方法：
list.append(obj)
在列表末尾添加新的对象
这个list就是所设的变量，随条件而变化，基本的写法就是只要写list.append(obj)，但obj只添加一个值
list.count(obj)
统计某个元素在列表中出现的次数
list.extend(seq)
在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.index(obj)
从列表中找出某个值第一个匹配项的索引位置
list.insert(index, obj)
将对象插入列表
list.pop([index=-1])
移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.remove(obj)
移除列表中某个值的第一个匹配项
这个时候想为什么不能删除重复的值，但为什么不用集合能，这个就没想到，要对数据类型更加熟悉
list.reverse()
反向列表中元素q
list.sort( key=None, reverse=False)
对原列表进行排序
list.clear()
清空列表
list.copy()
复制列表

（2）元组

元组除了内容不可修改外性质跟列表差不多——以下写的是与列表略微不同的地方

这个括号可有可无，当要写，规范格式

（1）修改

#!/usr/bin/python3
#元组中的元素值是不允许修改的，但我们可以对元组进行连接组合 
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
 
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
 
# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)

（2）删除

#!/usr/bin/python3
#元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组 
tup = ('Google', 'Runoob', 1997, 2000)
 
print (tup)
del tup
print ("删除后的元组 tup : ")
print (tup)

#输出
删除后的元组 tup : 
Traceback (most recent call last):
  File "test.py", line 8, in <module>
    print (tup)
NameError: name 'tup' is not defined

（3）特性：元组不可变

>>> tup = ('r', 'u', 'n', 'o', 'o', 'b')
>>> tup[0] = 'g'     # 不支持修改元素
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> id(tup)     # 查看内存地址
4440687904
>>> tup = (1,2,3)
>>> id(tup)
4441088800    # 内存地址不一样了

#从以上实例可以看出，重新赋值的元组 tup，绑定到新的对象了，不是修改了原来的对象。

（4）函数

函数：
len(tuple)
列表元素个数
max(tuple)
返回列表元素最大值
min(tuple)
返回列表元素最小值
tuple(iterable)
将可迭代系列转换为元组

（3）字典

定义：

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中

d = {key1 : value1, key2 : value2, key3 : value3 }

（1）创建空字典

# 使用大括号 {} 来创建空字典
emptyDict = {}
 
# 打印字典
print(emptyDict)
 
# 查看字典的数量
print("Length:", len(emptyDict))
 
# 查看类型
print(type(emptyDict))
#输出
{}
Length: 0
<class 'dict'>

（2）使用内建函数 dict() 创建字典

emptyDict = dict()
 
# 打印字典
print(emptyDict)
 
# 查看字典的数量
print("Length:",len(emptyDict))
 
# 查看类型
print(type(emptyDict))
#输出
{}
Length: 0
<class 'dict'>

（3）索引

#!/usr/bin/python3
 
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
print ("tinydict['Name']: ", tinydict['Name'])
print ("tinydict['Age']: ", tinydict['Age'])
#输出
tinydict['Name']:  Runoob
tinydict['Age']:  7

#如果用字典里没有的键访问数据，会输出错误如下
#!/usr/bin/python3
 
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
print ("tinydict['Alice']: ", tinydict['Alice'])
#输出
Traceback (most recent call last):
  File "test.py", line 5, in <module>
    print ("tinydict['Alice']: ", tinydict['Alice'])
KeyError: 'Alice'

（4）修改字典

#!/usr/bin/python3
#向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对 
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
tinydict['Age'] = 8               # 更新 Age
tinydict['School'] = "菜鸟教程"  # 添加信息
 
 
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])
#输出
tinydict['Age']:  8
tinydict['School']:  菜鸟教程

（5）删除字典

能删单一的元素也能清空字典，清空只需一项操作。

显式删除一个字典用del命令，如下实例

#!/usr/bin/python3
 
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
del tinydict['Name'] # 删除键 'Name'
tinydict.clear()     # 清空字典
del tinydict         # 删除字典
 
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])
#输出
Traceback (most recent call last):
  File "/runoob-test/test.py", line 9, in <module>
    print ("tinydict['Age']: ", tinydict['Age'])
NameError: name 'tinydict' is not defined

（6）字典的特性

字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。

两个重要的点需要记住：
1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
#!/usr/bin/python3
 
tinydict = {'Name': 'Runoob', 'Age': 7, 'Name': '小菜鸟'}
 
print ("tinydict['Name']: ", tinydict['Name'])
#输出
tinydict['Name']:  小菜鸟
2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，如下实例：
#!/usr/bin/python3
 
tinydict = {['Name']: 'Runoob', 'Age': 7}
 
print ("tinydict['Name']: ", tinydict['Name'])
#输出
Traceback (most recent call last):
  File "test.py", line 3, in <module>
    tinydict = {['Name']: 'Runoob', 'Age': 7}
TypeError: unhashable type: 'list'

（7）函数

len(dict)
计算字典元素个数，即键的总数。
str(dict)
输出字典，可以打印的字符串表示。
type(variable)
返回输入的变量类型，如果变量是字典就返回字典类型。

（8）方法

1	dict.clear()
删除字典内所有元素
2	dict.copy()
返回一个字典的浅复制
3	dict.fromkeys()
创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
4	dict.get(key, default=None)
返回指定键的值，如果键不在字典中返回 default 设置的默认值
5	key in dict
如果键在字典dict里返回true，否则返回false
6	dict.items()
以列表返回一个视图对象
7	dict.keys()
返回一个视图对象
8	dict.setdefault(key, default=None)
和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9	dict.update(dict2)
把字典dict2的键/值对更新到dict里
10	dict.values()
返回一个视图对象
11	pop(key[,default])
删除字典 key（键）所对应的值，返回被删除的值。
12	popitem()
返回并删除字典中的最后一对键和值。

8、集合

定义：集合是一个无序的不重复元素序列

可以使用{}创建集合当不能是空集合，也可以用set()函数创建(创建空集合必须用set()函数)

parame = {value01,value02,...}
或者
set(value)
set1 = {1, 2, 3, 4}            # 直接使用大括号创建集合
set2 = set([4, 5, 6, 7])      # 使用 set() 函数从列表创建集合

（1）添加元素

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.add("Facebook")
>>> print(thisset)
{'Taobao', 'Facebook', 'Google', 'Runoob'}
#还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等：update
>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.update({1,3})
>>> print(thisset)
{1, 3, 'Google', 'Taobao', 'Runoob'}
>>> thisset.update([1,4],[5,6])  
>>> print(thisset)
{1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'}
>>>

(2)删除

#有两种——s.remove()|s.discard()|pop()-随机删除

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.remove("Taobao")
>>> print(thisset)
{'Google', 'Runoob'}
>>> thisset.remove("Facebook")   # 不存在会发生错误
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Facebook'
>>>

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.discard("Facebook")  # 不存在不会发生错误
>>> print(thisset)
{'Taobao', 'Google', 'Runoob'}

方法：

add()	为集合添加元素
clear()	移除集合中的所有元素
copy()	拷贝一个集合
difference()	返回多个集合的差集
difference_update()	移除集合中的元素，该元素在指定的集合也存在。
discard()	删除集合中指定的元素
intersection()	返回集合的交集
intersection_update()	返回集合的交集。
isdisjoint()	判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
issubset()	判断指定集合是否为该方法参数集合的子集。
issuperset()	判断该方法的参数集合是否为指定集合的子集
pop()	随机移除元素
remove()	移除指定元素
symmetric_difference()	返回两个集合中不重复的元素集合。
symmetric_difference_update()	移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
union()	返回两个集合的并集
update()	给集合添加元素
len()	计算集合元素个数

9、推导式

[表达式 for 变量 in 列表] 
[out_exp_res for out_exp in input_list]

或者 

[表达式 for 变量 in 列表 if 条件]
[out_exp_res for out_exp in input_list if condition]
>>> names = ['Bob','Tom','alice','Jerry','Wendy','Smith']
>>> new_names = [name.upper()for name in names if len(name)>3]
>>> print(new_names)
['ALICE', 'JERRY', 'WENDY', 'SMITH']

>>> multiples = [i for i in range(30) if i % 3 == 0]
>>> print(multiples)
[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]

（1）字典推导式

{ key_expr: value_expr for value in collection }

或

{ key_expr: value_expr for value in collection if condition }

listdemo = ['Google','Runoob', 'Taobao']
# 将列表中各字符串值为键，各字符串的长度为值，组成键值对
>>> newdict = {key:len(key) for key in listdemo}
>>> newdict
{'Google': 6, 'Runoob': 6, 'Taobao': 6}

>>> dic = {x: x**2 for x in (2, 4, 6)}
>>> dic
{2: 4, 4: 16, 6: 36}
>>> type(dic)
<class 'dict'>

（2）集合推导式

>>> setnew = {i**2 for i in (1,2,3)}
>>> setnew
{1, 4, 9}

>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'d', 'r'}
>>> type(a)
<class 'set'>

（3)元组

>>> a = (x for x in range(1,10))
>>> a
<generator object <genexpr> at 0x7faf6ee20a50>  # 返回的是生成器对象

>>> tuple(a)       # 使用 tuple() 函数，可以直接将生成器对象转换成元组
(1, 2, 3, 4, 5, 6, 7, 8, 9)

9、迭代器

定义：访问集合元素的一种方式。迭代器是一个可以记住遍历位置的对象。迭代器对象从第一个元素开始访问，直到所有元素被访问。

迭代器有两个基本的方法：iter()和next()

(1)使用iter()或者next() 函数可以将可迭代对象（如列表、字典、字符串等）转换为迭代器

>>> list=[1,2,3,4]
>>> it = iter(list)    # 创建迭代器对象
>>> print (next(it))   # 输出迭代器的下一个元素
1
>>> print (next(it))
2
>>>

#!/usr/bin/python3
 
import sys         # 引入 sys 模块
 
list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
 
while True:
    try:
        print (next(it))
    except StopIteration:
        sys.exit()

也可以使用常规for语句进行遍历：

#!/usr/bin/python3
 
list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
for x in it:
    print (x, end=" ")

(2)面向对象时

把一个类作为一个迭代器使用需要在类中实现两个方法 iter() 与 next() 。

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self
 
  def __next__(self):
    x = self.a
    self.a += 1
    return x
 
myclass = MyNumbers()
myiter = iter(myclass)
 
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))

标签：python,list,元素,基础,汇总,print,列表,tinydict,字典
From： https://blog.csdn.net/weixin_60256922/article/details/140162429

相关文章

  • 《python机器学习从入门到高级》
    《python机器学习从入门到高级》分类算法：引言我们在之前的文章已经介绍了机器学习的一些基础概念，当拿到一个数据之后如何处理、如何评估一个模型、以及如何对模型调参等。接下来，我们正式开始学习如何实现机器学习的一些算法。回归和分类是机器学习的两大最基本的问题，对于......
  • python数据结构（树和二叉树）
    树非线性结构一对多根结点（无前驱）多个叶子结点（无后继）其他数据元素（一个前驱，多个后驱）树与二叉树转换树与二叉树均可用二叉链表作为存储结构，则以二叉链表为媒介可导出树之间的一个对应关系-----即给定一颗树，可以找到唯一一颗二叉树与之对应。把树转化为二叉树步骤一：加线......
  • 面试必会之JAVA基础篇
    1.Final有什么用？被final修饰的类不可以被继承被final修饰的方法不可以被重写被final修饰的变量不可以被改变被final修饰不可变的是变量的引用，而不是引用指向的内容，引用指向的内容是可以改变的finalArrayList<Integer>finalList=newArrayList<>();//初始化后，finalL......
  • Box，一个字典操作python库
     Box介绍Box是一个让字典操作变得异常简单与直观，支持通过属性访问字典内容的库。 特点概述属性访问Box允许用户像访问对象属性一样访问字典的值，提升了代码的可读性和易用性。无缝嵌套自动将嵌套的字典转换为Box对象，使得处理复杂字典结构变得轻而易举。灵活性......
  • Python速通（条件语句）
    （牛牛的选择）牛牛在牛客网经过了两次笔试分别获得了Tencent和Alibaba的面试资格，不巧的是这两次面试的时间冲突了。两家公司牛牛都想去，他决定通过笔试的成绩判断去参加哪家公司的面试。现在输入两行浮点数，分别表示牛牛在Tencent和Alibaba的笔试成绩，请比较两个成绩，输出笔试成绩较高的......
  • 小白也能看懂的Python基础教程（9）
    目录Python文件操作1、文件操作概述什么是文件？文件操作包含哪些内容呢？文件操作的作用2、文件的基本操作open()打开函数mode访问模式详解读操作相关方法read()方法：readlines()方法：readline()方法：file读取文件之readfile读取文件之readlines和reanline相对和绝对......
  • 全网最全网络安全入门指南（2024版）零基础可学_网络安全学习指南
    下一个十年的饭碗就是它了！据悉，2019年9月27日，工信部发布**《关于促进网络安全产业发展的指导意见（征求意见稿）》，明确提出2025年培育形成一批营收20亿元以上的网络安全企业，网络安全产业规模超过2000亿元的发展目标；据市场调研机构Gartner预测，我国网络安全预计将以......
  • 数据库（基础篇）
    什么是数据库：数据库(DatabaseDB)是按照数据结构来组织、存储和管理数据的仓库(存储数据的仓库)，它产生于距今六十多年前，随着信息技术和市场的发展，特别是二十世纪九十年代以后，数据管理不再仅仅是存储和管理数据，而转变成用户所需要的各种数据管理的方式。数据库有很多种类型，从最......
  • ipython的使用技巧整理
    IPython是一个强大的交互式Python环境，提供了许多高级功能和快捷键，以下是非常详细的IPython使用技巧整理，覆盖了每个知识点（但本文是基于有一定基础的同学看的）：IPython的使用基础：一、安装与基本操作安装Anaconda建议直接下载安装Anaconda，其中包含丰富的库，以及我们需要使用......
  • Linux虚拟机配置杂项问题汇总
    下面提到的相关问题，大部分是基于Ubuntu系统进行操作的，因为CentOS在我目前实践中涉及较少。因此如无明确提及系统，均默认在Ubuntu、debian一类系统中操作。1、更新root密码：新创建的虚拟机有时没有设置root密码导致进入root权限麻烦，使用如下命令可以设置密码。sudopasswdroot2......

赞助商

阅读排行

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

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

Copyright © 2020-2023 IPS99 版权所有 IPS99