Python笔记10-元组&字典&集合

最新推荐文章于 2022-09-11 21:14:07 发布
最新推荐文章于 2022-09-11 21:14:07 发布
阅读量270 收藏
点赞数
文章标签： python 开发语言 后端

一、元组【了解】

1.概念

和列表相似，本质上是一种有序的集合

元组和列表的不同之处：

a.列表:[]     元组：()

b.列表中的元素可以进行增加和删除操作，但是，元组中的元素不能修改【元素：一旦被初始化，将不能发生改变】

2.和列表比较

创建列表:

创建空列表：list1 = []

创建有元素的列表：list1 = [元素1，元素2，。。。。。]

创建元组

创建空元组：tuple1 = ()

创建有的元组：tuple1 = (元素1，元素2，。。。。)

3.元组操作

# 1.概念
"""
列表：列表是一种有序的，可变的，可以存储重复元素的，可以存储不同类型数据的集合
元组：元组是一种有序的，不可变的，可以存储重复元素的，可以存储不同类型数据的集合
"""

# 2.定义
l1 = [34,5,67,5,5,True,'abc']
print(l1,type(l1))  # <class 'list'>
t1 = (34,5,67,5,5,True,'abc')
print(t1,type(t1))  # <class 'tuple'>

# 注意:当元组中只有一个元素时，需要在元素的后面添加逗号，以消除歧义
l2 = [10]
print(l2,type(l2))  # <class 'list'>
# t2 = (10)  # 等价于t2 = 10
# print(t2,type(t2))  # <class 'int'>
t2 = (10,)
print(t2,type(t2))  # (10,) <class 'tuple'>

# 3.元素的访问
# a.获取
print(l1[0])
print(t1[0])
print(l1[-1])
print(t1[-1])

# 注意：元组和列表的索引相同，都有正数索引和负数索引，也都不能越界
# print(l1[10])  # IndexError: list index out of range
# print(t1[10])    # IndexError: tuple index out of range

# b.修改
# 注意：元组一旦定义完成，只能获取其中的元素，无法修改元素
l1[0] = 100
print(l1)
# t1[0] = 100  # TypeError: 'tuple' object does not support支持 item元素 assignment赋值

# 【面试题】
tuple1 = (3,5,'aga',False,[1,2,3])
tuple1[-1][1] = 100   # 修改的是列表
print(tuple1)   # (3, 5, 'aga', False, [1, 100, 3])

# 4.遍历
for ele in t1:
    print(ele)
for i in range(len(t1)):
    print(i,t1[i])
for i,ele in enumerate(t1):
    print(i,ele)

# 5.系统功能
# 注意：元组是不可变的，所以元组没有增删改的相关系统功能
# a.len()
print(len(t1))
# b.max(0/min()
t1 = (34,5,67,5,5)
print(max(t1))
print(min(t1))

# c.index()
print(t1.index(5))

# d.count()
print(t1.count(5))

# e.list()/tuple():列表和元组之间的相互转化
t1 = (34,5,67,5,5)
print(t1,type(t1))
l1 = list(t1)
print(l1,type(l1))
t2 = tuple(l1)
print(t2,type(t2))

# 6.元组的意义
"""
a.在实际项目开发中，因为列表相对比较灵活，可以增删改查的操作，所以使用列表较多
b.在多进程和多线程中，一般需要不能被随意修改的数据，元组比列表功能强大
"""

二、字典【重点掌握】

1.概念

列表和元组的使用缺点：当存储的数据要动态添加、删除的时候，我们一般使用列表，但是列表有时会遇到一些麻烦

解决方案：既能存储多个数据，还能在访问元素的很方便的定位到需要的元素，采用字典

# 1.需求：存储5个人的年龄，获取张三的年龄

# 使用列表或元组存储，可以存储多个数据，因为列表和元组都是有序的，只能通过索引的方式获取元素
# 但是，如果要定位张三的年龄，无法定位
age_list = [34,6,22,46,10]     # 可变的，可以增删改
age_tuple = (34,6,22,46,10)    # 不可变的，无法修改

print(age_list[1])
print(age_tuple[1])


# 使用字典存储
age_dict = {'小明':34,"张三":6,'小王':22,'老张':46,"李四":10}
age = age_dict['张三']
print(age)

# 2.使用的场景
# 列表：如果需要存储同类型的数据，建议列表
list1 = ['张三','李四','jack']
score_list = [66,100,56]

# 字典：可以存储同一个对象的不同信息 或者 需要精确定位某个数据，建议字典
age_dict = {'小明':34,"张三":6,'小王':22,'老张':46,"李四":10}
info_dict = {'name':"张三",'age':18,'hobby':"篮球"}

"""
【面试题】：简述列表，元组，字典，集合和字符串的区别
列表的本质：list,是一种有序的，可变的，可以存储重复元素的，可以存储不同类型的集合
元组的本质：tuple,是一种有序的，不可变的，可以存储重复元素的，可以存储不同类型的集合
字典的本质：dict,是一种有序的【Python3.7之后】，可变的，key不可以重复，
          但是value可以重复，key只能是不可变的数据类型，vlue可以是任意的类型的 集合
集合的本质：set,是一种无序的，可变的，不可以存储重复元素的，可以存储不同类型的集合
字符串的本质：str,是一种有序的，不可变的，可以存储重复字符的集合
"""

2.定义字典

语法：{键1:值1, 键2:值2, 键3:值3, …, 键n:值n}

说明：

  • 字典和列表类似，都可以用来存储多个数据
  • 在列表中查找某个元素时，是根据下标进行的；字典中找某个元素时，是根据’名字’（就是冒号:前面的那个值，例如上面代码中的’name’、‘id’、‘sex’）
  • 字典中的每个元素都由2部分组成，键:值。例如 ‘name’:‘班长’ ,'name’为键，'班长’为值
  • 键可以使用数字、布尔值、元组，字符串等不可变数据类型，但是一般习惯使用字符串，切记不能使用列表等可变数据类型,值可以是任意类型的数据
  • 每个字典里的key都是唯一的，如果出现了多个相同的key,后面的value会覆盖之前的value，但是value可以重复

习惯使用场景：

  • 列表更适合保存相似数据，比如多个商品、多个姓名、多个时间

  • 字典更适合保存不同数据，比如一个商品的不同信息、一个人的不同信息

    【面试题】如何定义字典，至少列出两种方式

    1.

    dict1 = {‘name’:“张三”,‘age’:18,‘hobby’:“篮球”}
    print(dict1)

    2. *****

    dict2 = {}
    dict2[‘a’] = 100 # 添加键值对
    dict2[‘b’] = 200
    print(dict2)

    3.

    int(x) float(x) str() bool() list() tuple() dict() set()

    dict(key1=value1,key2=value2…):必须以name=value的方式传值，而且name只能是变量

    dict3 = dict(a = 10,b = 20,c = 30)
    print(dict3)

    dict31 = {1:100,2:200}
    print(dict31)

    dict31 = dict(1=100,2=200)

    print(dict31)

    4.

    dict(iterable):iterable必须是二维的

    工作原理：

    d = {}

    for k,v in [[‘x’,11],[‘y’,22],[‘z’,33]]:

    d[k] = v

    print(d)

    dict4 = dict([[‘x’,11],[‘y’,22],[‘z’,33]])
    print(dict4)
    dict4 = dict([(‘x’,11),(‘y’,22),(‘z’,33)])
    print(dict4)
    dict4 = dict(((‘x’,11),(‘y’,22),(‘z’,33)))
    print(dict4)

    5. ******

    dict(zip(所有的key,所有的value))

    dict5 = dict(zip([‘name’,‘age’,‘score’],[‘tom’,10,100]))
    print(dict5)
    dict5 = dict(zip((‘name’,‘age’,‘score’),(‘tom’,10,100)))
    print(dict5)
    dict5 = dict(zip((‘name’,‘age’,‘score’),[‘tom’,10,100]))
    print(dict5)
    dict5 = dict(zip([‘name’,‘age’,‘score’,‘gender’],[‘tom’,10,100]))
    print(dict5)
    dict5 = dict(zip([‘name’,‘age’,‘score’],[‘tom’,10,100,46,67,8,8]))
    print(dict5)

    注意：不管通过哪种方式定义字典，字典中的key都是不可变的数据类型

    “”"
    不可变的类型：int float bool str tuple
    可变的数据类型：list dict set
    “”"

3.基本使用

# 列表/元组：列表/元组[索引]
# 字典：字典[key]

# 1.获取
# a.
# 每个字典里的key都是唯一的，如果出现了多个相同的key,后面的value会覆盖之前的value
d1 = {'a':10,'b':20,"a":30}
print(d1)  # {'a': 30, 'b': 20}

# b.方式一：字典[key]
dict1 = {'name':"张三",'age':18,'hobby':"篮球"}
print(dict1)
print(dict1['age'])
# 注意：如果key不存在，则无法获取
# print(dict1['score'])  # KeyError: 'score'

# 优化
if 'score' in dict1:
    print(dict1['score'])
else:
    print("key不存在")

# b.方式二:字典.get(key)    ******
# 注意：如果key存在，则获取对应的值，如果key不存在，则返回None
print(dict1.get('age'))
print(dict1.get('score'))

# 2.修改，主要目的是为修改value
# 语法：字典[key] = value,作用：如果key存在，则表示修改对应的值，但是，如果key不存在，则表示添加键值对
print(dict1)
dict1['age'] = 66
print(dict1)

dict1['score'] = 100
print(dict1)

# 3.遍历字典
# a         *******
for key in dict1:
    print(key,dict1[key])

# b.
print(dict1.keys())   # 获取字典中所有的key
for key in dict1.keys():
    print(key,dict1[key])

# c.
print(dict1.values())
for value in dict1.values():
    print(value)

# d.   *******
print(dict1.items())
for key,value in dict1.items():
    print(key,value)


# 练习1:已知如下字典，获取张三的年龄，获取到的结果是否唯一？唯一
age_dict = {'小明':34,"张三":6,'小王':22,'老张':6,"李四":6}
age = age_dict['张三']
print(age)   # 6

# 练习2：已知如下字典，获取年龄为6的学生的名字，获取到的结果是否唯一？不一定
age_dict = {'小明':34,"张三":6,'小王':22,'老张':6,"李四":6}
for key,value in age_dict.items():
    if value == 6:
        print(key)

"""
总结：
    通过key获取到的value是唯一的，但是，通过value获取到的key不一定是唯一的
"""

4.字典系统功能

# 一、增
dict1 = {'a':10,'b':20}
print(dict1)

# 1.字典[key] = value,当key不存在时，表示增加键值对     *****
# dict1['c'] = 30
# print(dict1)

# 2.update():更新，合并字典，将指定字典中的键值对添加到原字典中     ******主要会出现在面试题中
# dict1.update(dict2):将dict2中的键值对添加到dict1中
new_dict = {'x':34,'y':75}
dict1.update(new_dict)
print(dict1)
print(new_dict)


# 3.setdefault(key,default):通过设置默认值的方式增加键值对，了解
dict1 = {'a':10,'b':20}
print(dict1)
# a.default省略,则向指定字典中添加：key:None
dict1.setdefault('abc')
print(dict1)  # {'a': 10, 'b': 20, 'abc': None}

# b.default未省略，则向指定字典中添加：key:default
dict1.setdefault('xyz',88)
print(dict1)  # {'a': 10, 'b': 20, 'abc': None, 'xyz': 88}


# 二、删
# 1.pop(key):弹出，删除指定key对应的键值对，     ********
# 【实际工作原理：将指定键值对从字典中移除，但是在内存中】
dict1 = {'name':"张三",'age':18,'hobby':"篮球"}
print(dict1)
r = dict1.pop('age')   # pop跟列表中的用法类似，返回被删除的数据
print(dict1)
print(r)

# 2.popitem():在Python3.7之前，表示随机删除一对，在3.7之后，删除最后一对
dict1 = {'name':"张三",'age':18,'hobby':"篮球"}
print(dict1)
dict1.popitem()
print(dict1)

# 3.clear()
dict1 = {'name':"张三",'age':18,'hobby':"篮球"}
print(dict1)
dict1.clear()
print(dict1)

# 4.del
dict1 = {'name':"张三",'age':18,'hobby':"篮球"}
print(dict1)
del dict1['age']
print(dict1)

# del dict1     # 删除字典

# 三、改
dict1 = {'name':"张三",'age':18,'hobby':"篮球"}
print(dict1)
dict1['age'] = 66
print(dict1)

# 四、查
print(len(dict1))  # 获取键值对的对数
print(dict1.keys())
print(dict1.values())
print(dict1.items())

# 五、其他
# 但凡是可变的数据类型，都有copy()
# 字典同样可以使用copy(),copy.copy(),copy.deepcopy()
# 字典同样遵循和列表一样的深浅拷贝的特征

5.字典推导式

"""
列表推导式:[元素的规律 for循环  if语句]
字典推导式：{key:value for循环  if语句}
"""

# 1.已知字典d1 = {'a':10,'b':20},生成一个新的字典，{10:'a',20:'b'}
d1 = {'a':10,'b':20}
# 方式一
d2 = {}
for k in d1:
    d2[d1[k]]  = k
print(d2)

# 方式二
d2 = {}
for k,v in d1.items():
    d2[v]  = k
print(d2)

# 方式三
d2 = dict(zip(d1.values(),d1.keys()))
print(d2)

# 方式四
d2 = {v:k for k,v in d1.items()}
print(d2)

# 方式五：
d2 = {d1[k]:k for k in d1}
print(d2)

# 2.生成字典:{0:0,2:4,4:16,6:36,8:64}
dict2 = {i:i ** 2 for i in range(0,9,2)}
print(dict2)

dict2 = {i:i ** 2 for i in range(0,10) if i % 2 == 0}
print(dict2)

# 3.和列表推导式相同，在字典推导式中，也可以使用多个for或者多个if，从左往右表示依次嵌套的关系
list1 = [a + b for a in 'xyz' for b in '123']
print(list1)  # ['x1', 'x2', 'x3', 'y1', 'y2', 'y3', 'z1', 'z2', 'z3']

dict1 = {a:b for a in 'xyz' for b in '123'}
print(dict1)  # {'x': '3', 'y': '3', 'z': '3'}

三、集合【了解】

1.概念

Python中的集合跟数学上的集合是一致的，不允许有重复元素，而且可以进行交集、并集、差集等运算

set与dict类似，但是与dict的区别在于只是一组key的集合，不存储value

本质：无序且无重复元素的集合

表示：{}，注意：如果直接使用{}则默认表示字典

2.创建

# 1.概念
"""
【面试题】：简述列表，元组，字典，集合和字符串的区别
列表的本质：list,是一种有序的，可变的，可以存储重复元素的，可以存储不同类型的集合
元组的本质：tuple,是一种有序的，不可变的，可以存储重复元素的，可以存储不同类型的集合
字典的本质：dict,是一种有序的【Python3.7之后】，可变的，key不可以重复，
          但是value可以重复，key只能是不可变的数据类型，vlue可以是任意的类型的 集合
集合的本质：set,是一种无序的，可变的，不可以存储重复元素的，可以存储不同类型的集合
字符串的本质：str,是一种有序的，不可变的，可以存储重复字符的集合
"""

# 2.定义
# a.定义一个空集合
# {}默认表示字典
dict1 = {}
print(type(dict1))

set1 = set()
print(set1)

# b.定义一个非空集合
set2 = {3,5,6}
print(set2,type(set2))

# c.去重
set3 = {3,3,3,3,4,5,6,6,6,6}
print(set3)

# d.无序
set4 = {7,2,45,2,6,7,8,9,10}
print(set4)

# 练习：去重一个列表中的重复元素
list1 = [45,67,7,8,2,2,2]
list2 = list(set(list1))
print(list2)

3.集合间的运算

# 3.运算
s1 = {1,2,3}
s2 = {3,4,5}
# 3.1符号
# a.交集
print(s1 & s2)  # {3}
# b.并集
print(s1 | s2)  # {1, 2, 3, 4, 5}
# c.差集
print(s1 - s2)  # {1, 2}

# 3.2系统功能
# a.交集
r1 = s1.intersection(s2)  # {3}
print(r1)
# b.并集
r1 = s1.union(s2)  # {1, 2, 3, 4, 5}
print(r1)
# c.差集
r1 = s1.difference(s2)
print(r1)   # {1, 2}

4.集合系统功能

# 集合和字典之间的联系：集合相当于存储了字典中的key

# 一、增
# 1.add(x),x只能是不可变的数据类型，如果x是一个可迭代对象，则整体加入
s1 = {11,22,33}
print(s1)
s1.add(44)
print(s1)
s1.add("abc")
print(s1)
s1.add(True)
print(s1)
s1.add((55,66))
print(s1)
# s1.add([55,66])   # TypeError: unhashable type: 'list'
# s1.add({'a':10})    # TypeError: unhashable type: 'dict'

print("*" * 30)

# 2.update(x)，x只能是可迭代对象，只会将可迭代对象中的元素加入【打碎加入】
# 可迭代对象：list,tuple,dict,set,set，range()等容器
s1 = {11,22,33}
print(s1)
# s1.update(44)  # TypeError: 'int' object is not iterable可迭代对象
s1.update("abc")
print(s1)
# s1.update(True)  # TypeError: 'bool' object is not iterable
s1.update((55,66))
print(s1)
s1.update([77,88])
print(s1)
s1.update({'x':10,'y':20})   # 注意：如果x是字典，只能添加key
print(s1)

# 二、删
# 1.remove(x):x表示需要删除的元素     ******
s1 = {11,22,33,4,78,79}
print(s1)
s1.remove(33)
print(s1)
# s1.remove(100)  # KeyError: 100

# 2.pop():因为集合是无序的，所以pop表示随机删除一个
s1 = {11,22,33,4,78,79}
print(s1)
s1.pop()
print(s1)

# 3.discard(x):和remove用法相同，如果被删除的元素不存在，remove会报错，但是discard不会报错  *****
s1 = {11,22,33,4,78,79}
print(s1)
s1.discard(33)
print(s1)
s1.discard(100)

# 4.clear():清空
s1.clear()
print(s1)  # set()

# 三、查
s1 = {11,22,33,4,78,79}
s2 = s1.copy()

print(len(s1))
print(max(s1))
print(min(s1))

# int()/float()/bool()/list()/tuple()/dict()/set()
seeAurora
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
初学者python笔记（元组、字典）
12-22
我们可能知道字符串、数字、列表、元组、字典是python中的五大基本数据类型。前面的文章已经介绍过数字、字符串、列表，这篇则是关于元组和字典方面的一些重点知识。(还会提到元组的修改) 元组(与列表最大的区别就是...
Python数据类型——字典
weixin_46039719的博客
01-13 793
目录 1 概述 1.1字典基本操作 1.2 字典常用方法 2 字典基本操作 2.1 创建字典 2.2遍历字典 2.3判断键是否在字典里面 3字典常用方法 3.1clear 3.2copy 3.3get 3.4 setdefault 3.5update 3.6items/iteritems 3.7keys/iterkeys 3.8values/itervalues 3.9pop 3.10popitem ...
GridSearchCV-提示错误KeyError: ‘mean_train_score‘
huazi99的博客
01-19 4361
代码： test_means = grid.cv_results_[ ‘mean_test_score’ ] test_stds = grid.cv_results_[ ‘std_test_score’ ] train_means = grid.cv_results_[ ‘mean_train_score’ ] train_stds = grid.cv_results_[ ‘std_train_score’ ] 错误： 原因：没有指定训练级 解决：在 GridSearchCV()方法中增加 return_
Day-8字典和元组
HunterQAQ的博客
06-01 159
三目运算符
Python列表，元组，字典，集合 练习
也许会有_hui的博客
01-02 5939
目录 1.元组元素求和： b=(1,2,3,4,5,6,7,8,9) 2.输出元组内7的倍数及个位是7的数 3.列表倒数 方法一： 方法二： 4.写代码，有如下列表，利用切片实现每一个功能 （1）通过切片获取新的列表 lst2, lst2=[1,2,4,5] （2）通过切片获取新的列表 lst3,lst3=[3,’a’,’b’] （3）通过切片获取新的列表 lst4,lst4=[...
python基础练习题（三）---列表、字典、元组、集合
weixin_45044349的博客
12-27 9078
一、单选题 1.阅读下面一段示例程序： demo_list = [] demo_list.append(“A”,“B”) print(demo_list) 运行程序，其最终执行的结果为（6.0分） A、[‘A’] B、[‘A’, ‘B’] C、[‘B’, ‘A’] D、程序出现TypeError异常 append(x)：将参数中的数组作为一个元素添加 extend(x,y,z)：将参数中的数组作为多个元素添加 2.请看下面的一段程序： info = {1:‘小明’, 2:‘小黄’,3:‘小兰’} name
02-python-字典-集合-不可变集合-赋值机制
02-08
在Python编程语言中，字典、集合和不可变集合是三种重要的数据结构，它们各自具有独特的特性和用途。本篇文章将深入探讨这些概念，并详细解释它们的赋值机制。 首先，我们来了解一下**字典（Dictionary）**。字典是...
1.8-元组和字典的应用(代码加笔记)
最新发布
04-01
在IT行业中，数据结构是编程基础的重要组成部分，元组和字典是Python编程语言中两种常用的数据结构。元组（Tuple）与字典（Dictionary）虽然都是用来存储数据的容器，但它们各自有着独特的特性和用途。在此，我们将...
Python学习笔记--皮大庆.pdf.zip
10-11
3. **列表、元组、字典与集合**：这些是Python的主要数据结构，列表是可变序列，元组是不可变序列，字典是键值对的集合，集合则是一组不重复的元素。理解它们的特点和操作方法，如索引、切片、增删改查、迭代等。 4...
【python练习题2】列表、元组、字典、集合
weixin_52451652的博客
09-11 2222
比1大但不是素数的数称为合数。所以我们在第一个循环遍历所有数，第二个循环我们寻找他的另外一个数也就是整数本身，这个期间如果有一个能整除的数那么我们就flag=False然后不将他加进新的列表中，然后最后输出就好了。1到100的素数有：2,3,5,7,11,13,17,19,23,29,31,37,41,43,53,59,61,67,71,73,79,83,89,97。一、有一堆硬币，每次只能拿一个或者两个，求最少多少次可以拿完硬币，[10, 8, 5, 3, 27, 99]），求最小值，求平均值、求和。
Python字符串元组和集合相关及字符串习题
qq_48276142的博客
04-21 915
字符串元组和集合相关 元组 什么是元组(tuple) 容器:将()作为容器的标志,里面多个元素用逗号隔开:(元素1,元素2,元素3,…) 不可变的(不支持增删除),有序的(支持下标操作) 元素:任何数据 元组就是不可变的列表 列表中除了和可变相关的操作，其他操作元组都支持 示例: # 空元组 t1 = () # 只有一个元素的元组 - 唯一的这个元素后面必须加逗号 t2 = (100,) print(t2, type(t2)) # (100,) <class 'tuple'> # 在没有歧
python元组的定义形式_Python序列——元组，字典和集合试题3
weixin_39913141的博客
11-24 703
1.以下定义元组错误的是：A.a_tuple = (3)B.a_tuple = ()C.a_tuple = (3,5)D.a_tuple = (3,)2.元组和列表的区别有哪些？3.使用_________函数将序列转换为列表，使用__________函数将序列转换为元组。4.1)用两种方法创建空字典分别是a_Dict, b_Dict2)向a_Dict字典中添加26组元素，第一组元...
python集合例题_【Python爬虫】- 第4天列表、元组、集合练习题
weixin_39765796的博客
12-04 1383
一、定义列表:list1 = ['life','is','short'],list2 = ['you','need','python']完成以下几个要求：1)输出python及其下标list1 = ['life','is','short']list2 = ['you','need','python']print(list2.index('python'))2)在list2后追加 '!' , 在 '...
老王python之基本数据结构——元组和集合习题
lichunliang的博客
06-21 605
基本数据结构之元组和集合习题 **一、 元组；a = (1,2,3) 1 有2种方法输出实现下面的结果：(5,2,3) 2 判断2是否在元组里** &gt;&gt;&gt; a = (1,2,3) &gt;&gt;&gt; b = list(a) &gt;&gt;&gt; b.insert(0,5) &gt;&gt;&gt; b.remove(1) &gt;&gt;&gt; b
元组、列表、字典及集合练习
cxx2637969257的博客
09-06 4237
列表练习题： #假定有下面这样的列表: #names = ['lily', 'denny', 'jenny', 'apple'] #输出结果为:'I have lily,denny, jenny and apple.'   names = ['lily', 'denny', 'jenny', 'apple'] print 'I have ' + ','.join(names[:-1])...
第一章 变量与数据类型
zxl061的博客
12-18 2156
自学python教程
KeyError: 'train_score'
sky的博客
11-02 4058
参数加入return_train_score=True 举例： cv_results = model_selection.cross_validate(alg, data1[data1_x_bin], data1[Target], cv = cv_split, return_train_score=True)
菜鸟的Python笔记.pdf
11-17
菜鸟的Python笔记.pdf

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值