Python青少年简明教程:列表(List)、元组(tuple)和字典(dict)

2024-08-28 04:44

本文主要是介绍Python青少年简明教程:列表(List)、元组(tuple)和字典(dict),希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

Python青少年简明教程:列表(List)、元组(tuple)和字典(dict)

在Python中,列表(List)、元组(Tuple)和字典(Dict)既是常用的数据类型,也是常用的数据结构。

【数据类型:在编程语言中,数据类型定义了一个变量的存储方式以及可以对该变量执行的操作。从 Python 语言的角度来看,Python 中的列表、元组和字典都属于数据类型。

数据结构:数据结构是指一种组织和存储数据的方式,使得数据可以被有效地访问和修改。从计算机科学的角度来看,列表、元组和字典在Python中也是常用的数据结构,因为它们定义了组织和存储数据的方式。列表是动态数组结构,元组是静态数组结构,字典是哈希表结构。】

列表(list

在Python中,没有传统意义上像C或Java那样的“数组”数据类型,但Python提供了几种可以模拟数组行为的数据结构,如列表(list)、元组(tuple)其中最常用的是列表(List)。

列表是一种可变的、有序的数据结构,可以随时添加和删除其中的元素。

说明:从列表中取值时,如果 超出索引范围,程序会报错。

列表(list)的元素是按顺序存储的,每个元素都有一个对应的序号,也称为索引(index)。理解列表的索引对于访问和操作列表元素至关重要。

正向索引:

从左到右,从0开始递增,第一个元素的索引是0,第二个元素的索引是1,以此类推。

负向索引:

从右到左,从-1开始递减,最后一个元素的索引是-1,倒数第二个元素的索引是-2,以此类推。

Python 的列表是一个可变的序列,允许你存储不同类型的元素。

创建列表(List)的方法或方式

1.使用方括号 []:

my_list = [1, 2, 3, 4, 5]

list1 = [1, 'a', True, 3.14]

2.使用 list() 构造函数:

my_list = list(range(1, 6))  # 创建一个包含1到5的列表

list2 = list()  # 创建空列表

list3 = list("hello")  # 将字符串转换为字符列表

list4 = list(range(5))  # 使用 range 创建列表

3.列表推导式(后面还有介绍):

my_list = [x * 2 for x in range(5)]  # 生成 [0, 2, 4, 6, 8]

遍历列表中的所有元素

可以使用 for 循环遍历列表中的所有元素。例如:

fruits = ["苹果", "香蕉", "橘子", "草莓"]
for fruit in fruits:print(fruit)

列表切片(slicing)

在Python中,允许你获取列表中的一部分元素,并可以返回一个新的列表。切片操作的基本语法如下:

list[start:stop:step]

其中

start(开始位置): 切片开始的位置(包括该位置的元素)。如果省略,默认为列表的开始位置(索引0)。

stop(结束位置): 切片结束的位置(不包括该位置的元素)。如果省略,默认为列表的结束位置(即列表的长度)。

step(步长): 切片时元素之间的间隔。如果省略,默认为1。步长可以是正数也可以是负数,分别代表向前或向后切片。

列表切片示例:

# 创建一个示例列表
my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]# 基本切片
print(my_list[2:5])    # 输出:[2, 3, 4]# 从起始位置开始切片
print(my_list[:4])     # 输出:[0, 1, 2, 3]# 从特定位置切片到结束
print(my_list[5:])     # 输出:[5, 6, 7, 8, 9]# 使用步长
print(my_list[::2])    # 输出:[0, 2, 4, 6, 8]# 反向切片
print(my_list[::-1])   # 输出:[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]# 指定步长
print(my_list[1:8:3])  # 输出:[1, 4, 7]# 使用负索引
print(my_list[-3:])    # 输出:[7, 8, 9]
print(my_list[:-3])     # 输出:[0, 1, 2, 3, 4, 5, 6]
print(my_list[-5:-2])   # 输出:[5, 6, 7]
print(my_list[::-1])   # 使用负步长可以反转列表:[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

列表(List)的方法

“方法”指的是绑定到某个对象的函数,或者说,“方法”是指属于某个对象的函数,能够直接操作或查询该对象的数据。

在Python中,对于列表(list)这样的对象,方法是指那些可以在列表上调用的函数,这些函数能够直接操作列表中的数据。换句话说,方法是属于特定对象的函数,它们定义了对象的行为。

在Python中,列表(list)是一个非常灵活的数据结构,它提供了多种方法来操作和管理数据。以下是一些常用的列表方法及其示例:

1. append()

向列表末尾添加一个新元素。

my_list = [1, 2, 3]

my_list.append(4)

print(my_list)  # 输出: [1, 2, 3, 4]

2. extend()

将另一个可迭代对象的元素添加到列表末尾。

my_list = [1, 2, 3]

my_list.extend([4, 5])

print(my_list)  # 输出: [1, 2, 3, 4, 5]

3. insert()

在指定位置插入一个元素。

my_list = [1, 2, 3]

my_list.insert(1, 'a')

print(my_list)  # 输出: [1, 'a', 2, 3]

4. remove()

删除列表中第一个匹配的元素。如果元素不存在,会引发 ValueError。

my_list = [1, 2, 3, 2]

my_list.remove(2)

print(my_list)  # 输出: [1, 3, 2]

还可以使用clear() 方法,用于清空列表中的所有元素。

lst = [1, 2, 3, 4]

lst.clear()  # lst 变为 []

5. pop()

移除并返回列表中指定位置的元素(默认最后一个元素)。如果列表为空,会引发 IndexError。

my_list = [1, 2, 3]

last_element = my_list.pop()

print(last_element)  # 输出: 3

print(my_list)       # 输出: [1, 2]

6. index()

返回指定元素的第一个索引。如果元素不存在,会引发 ValueError。

my_list = [1, 2, 3]

index_of_2 = my_list.index(2)

print(index_of_2)  # 输出: 1

7. count()

返回列表中指定元素的出现次数。

my_list = [1, 2, 2, 3, 2]

count_of_2 = my_list.count(2)

print(count_of_2)  # 输出: 3

8. sort()

对列表中的元素进行排序。排序是原地进行的,即改变原列表。可以通过 reverse=True 参数进行降序排序。

my_list = [3, 1, 2]

my_list.sort()

print(my_list)  # 输出: [1, 2, 3]

my_list.sort(reverse=True)

print(my_list)  # 输出: [3, 2, 1]

9. reverse()

反转列表中的元素。排序是原地进行的,即改变原列表。

my_list = [1, 2, 3]

my_list.reverse()

print(my_list)  # 输出: [3, 2, 1]

10. copy()

返回列表的浅拷贝。即创建一个新的列表,其中包含原列表的相同元素。

my_list = [1, 2, 3]

new_list = my_list.copy()

print(new_list)  # 输出: [1, 2, 3]

还可以使用del 语句删除列表中的单个元素或切片或整个列表。注意,它是 Python 的一个语句,而不是列表的方法。例如:

lst = [1, 2, 3, 4]

del lst[1]  # lst 变为 [1, 3, 4]

del lst  # 完全删除列表

del语句删除切片例子

lst2= [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

del lst2 [::2]  # 删除带步长的切片,lst2变为[1, 3, 5, 7, 9]

列表(List)的常用操作

Python中的列表(List)其它常用操作(不是方法但常用):

1. len(list)

功能:返回列表中的元素个数。

my_list = [1, 2, 3, 4, 5]

length = len(my_list)

print(length)  # 输出: 5

2. in 操作符

功能:检查某个元素是否存在于列表中。如果存在,返回 True;否则,返回 False。

my_list = [1, 2, 3, 4, 5]

print(3 in my_list)  # 输出: True

print(6 in my_list)  # 输出: False

3. 列表连接(+):将两个列表连接成一个新的列表。

list1 = [1, 2, 3]

list2 = [4, 5, 6]

combined_list = list1 + list2

print(combined_list)  # 输出: [1, 2, 3, 4, 5, 6]

4. 列表重复(*):重复列表中的元素。

my_list = [1, 2, 3]

repeated_list = my_list * 3

print(repeated_list)  # 输出: [1, 2, 3, 1, 2, 3, 1, 2, 3]

5. 列表拆包:将列表的元素拆分到多个变量中(通常用于函数返回值)。

my_list = [1, 2, 3]

a, b, c = my_list

print(a, b, c)  # 输出: 1 2 3

列表(list)模拟二维数组

Python本身没有内置的二维数组类型,但可以使用嵌套列表来实现类似的功能。示例:

# 创建一个3x3的二维数组
matrix = [[1, 2, 3],[4, 5, 6],[7, 8, 9]
]# 访问元素
print(matrix[0][0])  # 输出: 1
print(matrix[1][2])  # 输出: 6# 修改元素
matrix[2][1] = 10
print(matrix)  # 输出: [[1, 2, 3], [4, 5, 6], [7, 10, 9]]# 遍历二维数组
for row in matrix:for element in row:print(element, end=' ')print()  # 换行

列表综合例题

例1、创建一个包含100以内所有素数的列表

def is_prime(num):"""判断一个数是否为素数。"""if num <= 1:return Falsefor i in range(2, int(num**0.5) + 1):if num % i == 0:return Falsereturn Trueprimes = [num for num in range(2, 100) if is_prime(num)]
print(f"100 以内的所有素数:{primes}")

例2、使用列表的猜数字游戏

import randomdef play_guessing_game():"""猜数字游戏。"""secret_number = random.randint(1, 100)guesses = []attempts = 0print("欢迎来到猜数字游戏!")print("我已选择一个 1 到 100 之间的数字。")while True:try:guess = int(input("请输入你的猜测:"))guesses.append(guess)attempts += 1if guess < secret_number:print("太低了!")elif guess > secret_number:print("太高了!")else:print(f"恭喜你!你猜对了!你用了 {attempts} 次尝试。")print(f"你猜过的数字:{guesses}")breakexcept ValueError:print("请输入一个有效的数字。")play_guessing_game()

列表推导

使用列表推导可以简洁地创建新的列表。

列表推导(List Comprehension)是一种简洁而强大的 Python 语法,它允许你通过一行代码创建新的列表,而无需使用传统的 for 循环。它以一种紧凑且易读的方式表达列表创建逻辑。

列表推导的语法:

[expression for item in iterable if condition]

expression: 你想要在新的列表中包含的元素的表达式。

item: 迭代器中的每个元素。

iterable: 可迭代对象,例如列表、元组、字符串等。

condition (可选): 一个条件表达式,用于过滤可迭代对象中的元素。只有满足条件的元素才会被包含在新的列表中。

举例:

1)创建包含平方数的列表:
squares = [x**2 for x in range(10)]
print(squares)  # 输出: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
在这个例子中,x**2 是表达式,x 是迭代器中的每个元素,range(10) 是可迭代对象。代码将遍历 range(10) 中的每个数字,计算其平方,并将结果添加到新的列表 squares 中。

2)创建包含所有偶数的列表:
even_numbers = [x for x in range(10) if x % 2 == 0]
print(even_numbers)  # 输出: [0, 2, 4, 6, 8]
在这个例子中,x 是表达式,x 是迭代器中的每个元素,range(10) 是可迭代对象,x % 2 == 0 是条件表达式。代码将遍历 range(10) 中的每个数字,检查它是否为偶数,如果是,则将其添加到新的列表 even_numbers 中。

3)创建包含偶数的列表:
even_numbers = [x for x in range(20) if x % 2 == 0]

4)将列表中的所有字符串转换为大写:
words = ["apple", "banana", "orange"]
uppercase_words = [word.upper() for word in words]
print(uppercase_words)  # 输出: ['APPLE', 'BANANA', 'ORANGE']
在这个例子中,word.upper() 是表达式,word 是迭代器中的每个元素,words 是可迭代对象。代码将遍历 words 列表中的每个单词,将其转换为大写,并将结果添加到新的列表 uppercase_words 中。
 

除了列表推导式,Python还支持字典推导式和集合推导式,语法类似。

列表推导的优势:

简洁性: 列表推导比传统的 for 循环更简洁,代码更易读。

效率: 列表推导通常比传统的 for 循环更有效率,因为它们在底层使用 Python 的迭代器协议,减少了循环的开销。

可读性: 列表推导使代码更易于理解,因为它将列表创建逻辑集中在一个表达式中。

元组(tuple

元组是一个有序的不可变序列,可以包含多个元素,元素可以是不同的数据类型。

Python中元组(tuple)的元素索引与列表(list)的索引在索引和切片操作上表现相同,主要区别在于元组是不可变的,而列表是可变的。

括号的使用:虽然元组可以用圆括号 () 来定义,但实际上,如果元素之间用逗号分隔,Python 也会自动识别为元组。例如,1, 2, 3 被视为一个元组,在不使用括号的情况下。决定生成元组的其实是逗号而不是圆括号。

不可变性:元组一旦创建,就不能修改(例如,不能添加、删除或更改元素)。这与列表不同,列表是可变的。

元组的创建:可以通过以下方式创建元组:

使用括号:t = (1, 2, 3)

不使用括号:t = 1, 2, 3

单个元素元组需加逗号:t = (1,)

如果创建的元组中只有一个字符串类型的元素时,该元素后面必须要加一个逗号,否则 Python 解释器会将它视为字符串。

创建元组(Tuple)的方法或方式

1.使用小括号 ():

my_tuple = (1, 2, 3, 4, 5)

也可以不使用圆括号(推荐在多元素时使用圆括号):

Tuple1 = 1, 2, 3, 4, 5

2.使用 tuple() 构造函数:

Tuple2 = tuple()  # 创建空元组

Tuple3 = tuple([1, 2, 3])  # 将列表转换为元组

Tuple4 = tuple("hello")  # 将字符串转换为字符元组

创建单元素元组,要注意使用逗号:

Tuple5 = (42,)

Tuple6 = 42,

访问元组元素

可以通过索引访问元组中的元素,例如,t[0] 将访问第一个元素。
t = (1, 'hello', [3, 4])
print(t[0])  # 输出: 1
print(t[-1])  # 输出: [3, 4]

元组常用方法
count(): 计算元素出现的次数
index(): 查找元素的索引
t = (1, 2, 2, 3, 4)
print(t.count(2))  # 输出: 2
print(t.index(3))  # 输出: 3
 

元组切片

Python中元组(tuple)的切片操作与列表(list)非常相似。两者都使用相同的切片语法,主要区别在于元组是不可变的,而列表是可变的。

元组切片都语法:

tuple[start:stop:step]

start 是切片的起始索引(包括该索引所在的元素)。

stop 是切片的结束索引(不包括该索引所在的元素)。

step 是步长,默认为 1。

示例:

# 创建一个元组和一个列表
my_tuple = (0, 1, 2, 3, 4, 5)# 基本切片
print(my_tuple[1:4])  # 输出: (1, 2, 3)# 使用步长
print(my_tuple[::2])  # 输出: (0, 2, 4)# 反向切片
print(my_tuple[::-1])  # 输出: (5, 4, 3, 2, 1, 0)

注意:

对元组进行切片会返回一个新的元组,而对列表进行切片会返回一个新的列表。您可以对列表切片的结果进行修改,但不能修改元组切片的结果。

python元组嵌套
元组可以嵌套,这意味着你可以在一个元组中包含其他元组。下面是一个关于元组嵌套的简单示例:
nested = ((1, 2), (3, 4))

元组与列表可以转换
t = (1, 2, 3)
l = list(t)  # 元组转列表
t2 = tuple(l)  # 列表转元组

元组特性(特点)及解释
☆不可变性:
含义:一旦创建,元组的内容就不能被改变。
解释:
不能修改现有元素的值。
不能添加新元素。
不能删除现有元素。
示例:
t = (1, 2, 3)
# t[0] = 4  # 这会引发 TypeError
# t.append(4)  # 元组没有 append 方法
# del t[0]  # 这也会引发 TypeError
注意:如果元组中包含可变对象(如列表),这些对象的内容可以改变。
☆有序:
含义:元组中的元素保持它们被创建时的顺序。
解释:
可以通过索引访问元素。
索引从 0 开始。
支持正向和反向索引。
示例:
t = ('a', 'b', 'c', 'd')
print(t[0])   # 输出: 'a'
print(t[-1])  # 输出: 'd'
☆允许重复元素:
含义:元组可以包含多个相同的值。
解释:
重复元素各自占据独立的位置和索引。
这与集合(set)不同,集合不允许重复。
示例:
t = (1, 2, 2, 3, 1)
print(t.count(1))  # 输出: 2
☆可以包含不同类型的数据:
含义:单个元组可以存储不同数据类型的元素。
解释:
这提供了很大的灵活性。
可以混合使用整数、字符串、列表等。
示例:
t = (1, "hello", [1, 2], (3, 4))
print(type(t[0]))  # 输出: <class 'int'>
print(type(t[1]))  # 输出: <class 'str'>
print(type(t[2]))  # 输出: <class 'list'>
print(type(t[3]))  # 输出: <class 'tuple'>


思考题,python元组能排序吗?
元组本身是不可变的(immutable),所以不能直接对元组进行排序。但是,我们可以使用sorted() 函数创建一个排序后的新元组。
sorted() 函数是 Python 内置的一个函数,用于对可迭代对象进行排序并返回一个新的列表。它不会修改原始数据,而是返回一个新的已排序列表。例如:
# 创建一个新的排序元组
original_tuple = (3, 1, 4, 1, 5, 9, 2)
sorted_tuple = tuple(sorted(original_tuple))
print(sorted_tuple)  # 输出: (1, 1, 2, 3, 4, 5, 9)
 

字典(dictdictionary)

字典是一种可变的、无序的数据结构,存储键值对(key-value pairs)。每个键(key)都是唯一的,并且可以通过键来快速查找对应的值(value)。

值可以取任何数据类型,但键必须是不可变的,如字符串,数字或元组。

可以使用大括号 {} 或 dict() 函数来创建字典。

创建字典(Dict)的方法或方式

1.使用花括号 {}:
my_dict = {'name': 'Alice', 'age': 25 , 'city': 'Beijing' }
dict1 = {1: 'one', 2: 'two', 3: 'three'}
dict2 = {"西瓜": 2.6, "桃子": 2, "苹果":3, "樱桃":10.5}
dict3 = {"西瓜":"2.6元", "桃子": "2元", "苹果":"3元", "樱桃":"10.5元"}
2.使用 dict() 构造函数:
my_dict = dict(name='Alice', age=25)  # 关键字参数
dict4 = dict()  # 创建空字典
3.使用键值对列表:
my_dict = dict([('name', 'Alice'), ('age', 25)])  # 从列表创建字典
4.字典推导式:
my_dict = {x: x ** 2 for x in range(5)}  # 生成 {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

访问字典的值
可以通过键访问字典中的值。
print(my_dict["name"])  # 输出: Alice
print(my_dict["age"])   # 输出: 25

修改字典
可以为字典中的键赋值、删除键值对或添加新键值对。例如:
# 修改值
my_dict["age"] = 26

# 添加新键值对
my_dict["city"] = "New York"

# 删除键值对
del my_dict["is_student"]

字典的方法

字典提供了多种内置方法来操作数据:

my_dict.keys():返回字典中的所有键。

my_dict.values():返回字典中的所有值。

my_dict.items():返回字典中的所有键值对。

my_dict.get(key):安全地获取键的值,如果键不存在返回 None。

my_dict.pop(key):删除指定键并返回其值。

my_dict.update(another_dict):用另一个字典更新当前字典。

字典的基本特性
☆键唯一性:
每个键在字典中必须是唯一的(字典使用哈希表实现,键的唯一性是哈希表的基本要求)。
行为:如果尝试插入已存在的键,新值会覆盖旧值。
示例:
d = {'a': 1, 'b': 2}
d['a'] = 3  # 覆盖旧值
print(d)  # 输出: {'a': 3, 'b': 2}
☆无序性:
定义:传统上,字典中的元素没有固定的顺序。
注意:虽然从 Python 3.7 开始,字典保持插入顺序,但这是一个实现细节,在使用时,你不能依赖于元素的顺序来访问数据。
影响:不能像列表那样通过数字索引访问元素。
示例:
d = {'c': 3, 'a': 1, 'b': 2}
print(d)  # 输出顺序可能是 {'c': 3, 'a': 1, 'b': 2},但不应依赖这个顺序
使用建议:如果需要有序存储,考虑使用 OrderedDict。
☆可变性:
字典的内容可以在创建后修改。可以添加新的键值对、修改现有键的值、删除键值对。
示例:
d = {'a': 1}
d['b'] = 2  # 添加新键值对
d['a'] = 10  # 修改现有键的值
del d['b']  # 删除键值对
☆键类型限制:
键必须是不可变(可哈希)的数据类型。
原因:字典使用哈希表实现,键的哈希值用于确定存储位置。
常用键类型:字符串、数字、元组(只包含不可变元素)。
值的类型:没有限制,可以是任何数据类型。
示例:
d = {
    'string': 'value',
    42: 'answer',
    (1, 2): 'tuple key',
    # [1, 2]: 'list'  # 这会引发错误,因为列表是可变的
}

字典综合示例

源码如下:

# 创建字典
person = {"name": "Alice","age": 30,"city": "Wonderland"
}# 访问字典
print(person["name"])  # 输出: Alice# 修改字典
person["age"] = 31# 添加新键值对
person["hobby"] = "Reading"# 删除键值对
del person["city"]# 使用字典方法
print(person.keys())    # 输出: dict_keys(['name', 'age', 'hobby'])
print(person.values())  # 输出: dict_values(['Alice', 31, 'Reading'])
print(person.items())   # 输出: dict_items([('name', 'Alice'), ('age', 31), ('hobby', 'Reading')])

 

解包(unpacking

Python 中,解包(unpacking)是指将一个可迭代对象(如列表、元组、字典等)中的元素提取出来,并分别赋值给多个变量的过程。

示例
1.序列解包:
将元组或列表中的元素解包到多个变量中。
# 使用元组解包
coordinates = (10, 20)
x, y = coordinates
print(x)  # 输出: 10
print(y)  # 输出: 20

# 使用列表解包
values = [1, 2, 3]
a, b, c = values
print(a)  # 输出: 1
print(b)  # 输出: 2
print(c)  # 输出: 3

2.字典解包:
可以使用 ** 来解包字典,将字典中的键值对传递给函数。
def print_info(name, age):
    print(f"Name: {name}, Age: {age}")

person = {'name': 'Alice', 'age': 30}
print_info(**person)  # 输出: Name: Alice, Age: 30

3.可变数量的解包:
使用星号 * 可以将剩余的元素捕获到一个列表中。

a, *b = [1, 2, 3, 4, 5]
print(a)  # 输出: 1
print(b)  # 输出: [2, 3, 4, 5]

c, *d, e = [1, 2, 3, 4, 5]
print(c)  # 输出: 1
print(d)  # 输出: [2, 3, 4]
print(e)  # 输出: 5
解包在处理多个变量时非常方便,特别是在处理函数参数、元组和列表等可迭代对象时。
 

例、使用元组作为函数的返回值可以一次返回多个值

元组可以作为函数的返回值,并且可以一次返回多个值。在Python中,函数可以返回一个元组,调用方可以通过解包来获取这些值——将返回的元组元素值解包到多个变量中。

下面是一个简单的示例:

def calculate(a, b):sum_value = a + bproduct_value = a * breturn sum_value, product_value  # 返回一个元组# 调用函数并解包返回值
result_sum, result_product = calculate(5, 3)print("Sum:", result_sum)          # 输出: Sum: 8
print("Product:", result_product)   # 输出: Product: 15

这篇关于Python青少年简明教程:列表(List)、元组(tuple)和字典(dict)的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/1113766

相关文章

Spring Security 从入门到进阶系列教程

Spring Security 入门系列 《保护 Web 应用的安全》 《Spring-Security-入门(一):登录与退出》 《Spring-Security-入门(二):基于数据库验证》 《Spring-Security-入门(三):密码加密》 《Spring-Security-入门(四):自定义-Filter》 《Spring-Security-入门(五):在 Sprin

python: 多模块(.py)中全局变量的导入

文章目录 global关键字可变类型和不可变类型数据的内存地址单模块(单个py文件)的全局变量示例总结 多模块(多个py文件)的全局变量from x import x导入全局变量示例 import x导入全局变量示例 总结 global关键字 global 的作用范围是模块(.py)级别: 当你在一个模块(文件)中使用 global 声明变量时,这个变量只在该模块的全局命名空

Makefile简明使用教程

文章目录 规则makefile文件的基本语法:加在命令前的特殊符号:.PHONY伪目标: Makefilev1 直观写法v2 加上中间过程v3 伪目标v4 变量 make 选项-f-n-C Make 是一种流行的构建工具,常用于将源代码转换成可执行文件或者其他形式的输出文件(如库文件、文档等)。Make 可以自动化地执行编译、链接等一系列操作。 规则 makefile文件

【C++】_list常用方法解析及模拟实现

相信自己的力量,只要对自己始终保持信心,尽自己最大努力去完成任何事,就算事情最终结果是失败了,努力了也不留遗憾。💓💓💓 目录   ✨说在前面 🍋知识点一:什么是list? •🌰1.list的定义 •🌰2.list的基本特性 •🌰3.常用接口介绍 🍋知识点二:list常用接口 •🌰1.默认成员函数 🔥构造函数(⭐) 🔥析构函数 •🌰2.list对象

【Python编程】Linux创建虚拟环境并配置与notebook相连接

1.创建 使用 venv 创建虚拟环境。例如,在当前目录下创建一个名为 myenv 的虚拟环境: python3 -m venv myenv 2.激活 激活虚拟环境使其成为当前终端会话的活动环境。运行: source myenv/bin/activate 3.与notebook连接 在虚拟环境中,使用 pip 安装 Jupyter 和 ipykernel: pip instal

【机器学习】高斯过程的基本概念和应用领域以及在python中的实例

引言 高斯过程(Gaussian Process,简称GP)是一种概率模型,用于描述一组随机变量的联合概率分布,其中任何一个有限维度的子集都具有高斯分布 文章目录 引言一、高斯过程1.1 基本定义1.1.1 随机过程1.1.2 高斯分布 1.2 高斯过程的特性1.2.1 联合高斯性1.2.2 均值函数1.2.3 协方差函数(或核函数) 1.3 核函数1.4 高斯过程回归(Gauss

【学习笔记】 陈强-机器学习-Python-Ch15 人工神经网络(1)sklearn

系列文章目录 监督学习:参数方法 【学习笔记】 陈强-机器学习-Python-Ch4 线性回归 【学习笔记】 陈强-机器学习-Python-Ch5 逻辑回归 【课后题练习】 陈强-机器学习-Python-Ch5 逻辑回归(SAheart.csv) 【学习笔记】 陈强-机器学习-Python-Ch6 多项逻辑回归 【学习笔记 及 课后题练习】 陈强-机器学习-Python-Ch7 判别分析 【学

nudepy,一个有趣的 Python 库!

更多资料获取 📚 个人网站:ipengtao.com 大家好,今天为大家分享一个有趣的 Python 库 - nudepy。 Github地址:https://github.com/hhatto/nude.py 在图像处理和计算机视觉应用中,检测图像中的不适当内容(例如裸露图像)是一个重要的任务。nudepy 是一个基于 Python 的库,专门用于检测图像中的不适当内容。该

SWAP作物生长模型安装教程、数据制备、敏感性分析、气候变化影响、R模型敏感性分析与贝叶斯优化、Fortran源代码分析、气候数据降尺度与变化影响分析

查看原文>>>全流程SWAP农业模型数据制备、敏感性分析及气候变化影响实践技术应用 SWAP模型是由荷兰瓦赫宁根大学开发的先进农作物模型,它综合考虑了土壤-水分-大气以及植被间的相互作用;是一种描述作物生长过程的一种机理性作物生长模型。它不但运用Richard方程,使其能够精确的模拟土壤中水分的运动,而且耦合了WOFOST作物模型使作物的生长描述更为科学。 本文让更多的科研人员和农业工作者

pip-tools:打造可重复、可控的 Python 开发环境,解决依赖关系,让代码更稳定

在 Python 开发中,管理依赖关系是一项繁琐且容易出错的任务。手动更新依赖版本、处理冲突、确保一致性等等,都可能让开发者感到头疼。而 pip-tools 为开发者提供了一套稳定可靠的解决方案。 什么是 pip-tools? pip-tools 是一组命令行工具,旨在简化 Python 依赖关系的管理,确保项目环境的稳定性和可重复性。它主要包含两个核心工具:pip-compile 和 pip