python预测数据精度 python预测数据的方法

一.列表其他内置方法

1 # 1.列表内容升序（必须是想同类型的元素）
 2 l1 = [44, 22, 11, 33, 99, 77, 88, 66] # int比较
 3 l1.sort()
 4 print(l1)  # [11, 22, 33, 44, 66, 77, 88, 99]
 5 l2 = ['jason', 'jack', 'tom']
 6 l2.sort()
 7 print(l2)  # ['jack', 'jason', 'tom']  # str比较是根据ASCII表进行比较的。
 8 l2 = ['jason', 'jack', 'tom']
 9 l2.reverse()  # 顺序颠倒
10 print(l2)  # ['tom', 'jack', 'jason']
11 print(l1[:1])  # 左边安不写表示从零开始
12 print(l2[1:])  # 右边不要表示到最后一位
13 print(l2[:])  # 冒号左右两边不写数字表示默认全都要

 二.字典数据类型内置方法

2.1  按照k取值

1 dict = {'name': 'jason', 'age': 18, 'hobbies': 'movie'}
2 # 1.按k取值  k如果不存在会直接报错
3 print(dict['name'])  # jason

 2.2 按照k值修改

1 # 按照k值修改 新增键值对（使用频率最高）
2 dict['name'] = 'jasonNB'  # k值如果存在的修改元素
3 print(dict)
4 dict['sex'] = '男'# {'age': 18, 'hobbies': 'movie', 'sex': '男'} k值如果不存在的话直接添加新的元素
5 print(dict)

 2.3 统计字典内部键值对的个数

1 # 统计字典内部键值对的个数
2 print(len(dict))  # 统计的是kv键值对的个数

 2.4 成员运算

1 # 成员运算 默认值暴露k 会自动转变为布尔值(in和not in)
2 print('jack' in dict)   # True
3 print('jason' in dict)  # False

  2.5 删除元素

1 # 删除元素
 2 # 方式一
 3 del dict['name']  # 默认暴露给外界也是k值
 4 print(dict)
 5 # 方式二 指定k弹出键值对，给出v
 6 print(dict.pop('age'))  # 18
 7 print(dict)
 8 # 方式三 弹出键值对，组织成元组的形式，第一个元素是k，第二个元素是v
 9 print(dict.popitem())
10 print(dict)

 2.6 获取v值

1 # key()相当于k值 values()相当于v值 items() 在Python2中是列表  在Python3中是迭代器
2 print(dict.keys())  # dict_keys(['name', 'age', 'hobbies'])
3 print(dict.values())  # dict_values(['jason', 18, 'movie'])
4 print(dict.items())  # 将字典里面的键值对转换成元组的形式，元组内有两个元素，第一个是k，第二个是v

 2.7 更新字典

# 更新字典，键值存在就可以修改，不存在则创建。
dict.update({'sex': '男', 'school': '家里蹲'})
print(dict)

 

 

 2.8 了解知识

1 # 初始化字典
2 print(dict.fromkeys(['k1', 'k2', 'k3'], []))
3 d7 = dict.fromkeys(['jason', 'lucy', 'sian'], [])
4 print(d7)
5 d7['jason'].append(111)
6 print(d7)
7 # 在键存在的情况下，不修改而是获取对应的键值
8 print(d7.setdefault('name', '123'))
9 print(d7)

 

 

 三.元组内置方法

 3.1 基本数据类型转换

1 # 元组内置方法
 2 """
 3 小括号括起来，内部可以存放多个元素，元素与元素之间逗号隔开
 4 元素可以是任意数据，但元组内元素不支持'修改'（索引指向的元素的内存地址不能改变）
 5 也可以简单地认为它是一个不可变列表。
 6 """
 7 # 类型转换 能够支持for循环的数据都可以转换成元组
 8 # print(tuple(111))  # 报错
 9 # print(tuple(222))  # 报错
10 print(tuple('hello'))  # 字符串不可变类型
11 """元组哪怕内部只有一个元素，也需要加上逗号
12 容器类型：内部可以存放多个值的数据类型都可以称为容器类型，
13 所有的容器类型在存储数据的时候，如果内部只有一个元素最好是也加上逗号，不加的话容易变成其他数据类型。
14 """

 

 

 3.2 元组索引取值

1 t = (1, 2, 3, 4, 5, 6, 7, 7, 7, 7, 7)
2 # 索引取值
3 print(t[0])  # 1
4 print(t[-1])  # 7

 

 

 

 3.3 元组切片操作

1 # 切片操作
2 print(t[1:5])  # 原则类似于字典切片
3 print(t[1:])  # 右边没有索引值得话默认到最后一位
4 print(t[:6])  # 左边没有的默认从零开始
5 print(t[:])  # 左右两边都没有索引值得话从零开始到最后一位

3.4 元组步长

1 # 步长
2 print(t[1:5:2])  # (2, 4) 步长是最后一位参数，可以看做是一个等差数列。

3.5 统计元组内元素个数

1 # 统计元组内元素的个数
2 print(len(t))  # 7

3.6 for循环

1 # for循环
2 for i in t:
3     print(i)

3.7 count计数

1 #  count计数
2 t = (1, 2, 3, 4, 5, 6, 7, 7, 7, 7, 7)
3 print(t.count(7))

 

 四.集合去重操作

1 # 1.定义空集合需要用关键字set
2 s1 = set()
3 # 2.类型转换  能够支持for循环的数据类型都可以转成集合（元素是不可变类型）
4 """集合内元素是无序的"""
5 # 3.去重
6 s1 = {89, 56, 47, 49, 30, 30}
7 print(s1)

 

 五.集合关系运算

1 # 关系运算
 2 """两个群体之间做差异比较    共同好友 共同关注..."""
 3 friends1 = {"zero", "kevin", "jason", "eg"}  # 用户1的好友们
 4 friends2 = {"Jy", "ricky", "jason", "eg"}  # 用户2的好友们
 5 # 1.求两个用户的共同好友
 6 print(friends1 & friends2)  # {'jason', 'eg'}
 7 # 2.求两个用户所有的好友
 8 print(friends1 | friends2)  # {'kevin', 'ricky', 'jason', 'zero', 'Jy', 'eg'}
 9 # 3.求用户1独有的好友
10 print(friends1 - friends2)  # {'zero', 'kevin'}
11 # 4.求用户2独有的好友
12 print(friends2 - friends1)  # {'ricky', 'Jy'}
13 # 5.求用户1和用户2各自的好友
14 print(friends1 ^ friends2)  # {'Jy', 'zero', 'kevin', 'ricky'}
15 # 6.父集与子集
16 s1 = {11, 22, 33, 44}
17 s2 = {11, 33}
18 print(s1 > s2)  # 判断s1是否是s2的父集   True
19 print(s2 < s1)  # 判断s2是否是s1的子集   True