整型int
不可变类型
作用：记录个数，年龄，日期
定义方法：age = 18 # age = int(18)
int功能只可以把纯数字的字符串转换成int类型
经常用于算数运算与比较运算
浮点型float
不可变类型
作用： 记录价格，身高，体重，薪资
定义：salary = 3.1 # salary = float(3.1)
float功能可以把浮点数组成的字符串转换成float类型
经常用于算数运算符与比较运算
布尔True和Flase
判断真与假
有显性和隐性
=======================================================================
字符串str
不可变类型
作用：记录描述性质的状态，姓名，文章
定义在‘’“ ” ''' ''' """ """ 内部包含一段字符
（1）所有引号的相同点：定义得到的都是str类型
（2）所有引号的不同点：注意引号的嵌套，外层用双引号内层就要用单引号
str功能可以把任意类型转换成str类型
1.按索引取值
s = 'hello world'
print(s[0],type(s[0])) # 打印出‘h’
print(s[-1]) # 打印出最后一个字符
2.切片（顾头不顾尾，属于拷贝操作）
new_s = s[1:7]
print(new_s)
print(s) # 原变量名的值并没有改变
new_s = [1:7:2]
print(new_s) # 输出的结果是‘el ’注意是有空格的
print(:7:2) # 省略了起始位
3.长度len
print(len(s))
4.成员运算in和not in
print('hel' in s) # True
print('egon' not in s)
5.移除左右指定字符strip
s = '\n he llo \t '
new_s = s.strip()
print(new_s) # he llo
6.切分spilt
把字符串按照某一个分隔符切分成一个列表
userinfo = "egon_dsb:123:18:3.1"
res = userinfo.split(":") # 以字符串中的：为分隔符 分割成列表
print(res[0])
print(res)
7.lower，upper，swapcase大小写操作
8.startswith，endswith开头结尾判断操作
9.replace替换操作
10.format的方式
name = "egon"
age = 18
res1="my name is {} my age is {}".format(name,age) # 这样操作跟%s的操作差不多
res1="{0}{0}{0}{1}".format(name,age) #利用索引来赋值
res1="my name is {name} my age is {age}".format(age=18,name="egon") 也可以用 key来赋值
print(res1)
11.find寻找指定字符串的索引位置
12.index跟find差不多 找不到会报错
13.count计数操作
14.center，ljust，rjust，zfill各种填充操作
15captalize，title标题大写操作
16is判断操作
=========================================================
列表list
作用：按照顺序记录多个值，优点是可以按照索引取指定位置的值
定义在[]内以逗号分割，按照从左到右的顺序一个一个的存放多个任意类型的值
# 数据类型转换
# res=list("hello")
# res=list({"k1":1,"k2":2,"k3":3})
# print(res)
# 3、常用操作+内置的方法
# ===============3.1 优先掌握的操作：
# 1、按索引存取值(正向存取+反向存取)：即可以取可以改值,不能加值
# l1 = [11,22,33,44,55]
# print(l1[0])
# print(l1[10])
# print(l1[-1])
# print(id(l1))
# l1[0] = 100
# print(id(l1))
# l1[5] = 11111 # 不能加值 这个操作会报错
# d = {'k1':2}
# d['kkkk']=22222 # 但是字典可以直接加值
# print(d)
# 2、切片(顾头不顾尾，步长)
# l1 = [11,22,[66,77]]
# res=l1[2:4]
# print(res)
# print(l1)
# 了解：
# res=l1[-1:-4:-1]
# res=l1[::-1]
# print(res) # 倒切
# 浅拷贝
# l1 = [111,222,[33,44]]
# l2 =l1[:] # 和下面一条操作相同
# l2= l1.copy()
# print(id(l1[0]))
# print(id(l2[0]))
# print(id(l2[2][0]))
#
# l1[0]=1000
# print(id(l1[0]))
# print(id(l2[0])) # l2的ID并没有改变 l1里不可变类型的值的变化改动不会影响l2
#
# l1 [-1][0] = 666
# print(l1)
# print(l2) # 这里改变l1的值 却影响到了l2 因为已知list是可变类型 这里子列表对于l1和l2是同一块内存地址 所以牵一发而动全身 这就是浅拷贝
# print(id(l2[2][0]))
#
# from copy import deepcopy # 调用深拷贝的模块
# l3= deepcopy(l1)
# l1[2][0]=777
# print(l1) # [1000, 222, [777, 44]]
# print(l3) # [1000, 222, [666, 44]] 这里l3没有改变 因为深拷贝在遇见可变类型的时候 会生成一块新的内存地址来单独存放
# print(id(l3[2][0]))
# print(id(l1[2][0]))
# 3、长度
# l1 = [11,22,[66,77]]
# print(len(l1))
# 4、成员运算in和not in
# l1 = [111,22,[66,77]]
# print([66,77] in l1)
# print(66 in l1)
# print(66 not in l1)
# 5.追加
l1 = [11, 22]
l1.append(33)
l1.append(44)
l1.append([55, 66]) # 可以追加任意类型的值
l1.append((77, 88))
print(l1)
l1.insert(1, 'aaa') # 在指定位置插入
print(l1)
# 6.删除
l1 = [11, 22, [33, 44]]
# 6.1 万能删除，没有返回值，代表的是单纯的删除
del l1[0]
print(l1)
# 6.2 指定元素删除,没有返回值，代表的是单纯的删除
# res=l1.remove([1,2])
# print(l1)
# print(res)
# 6.3 指定索引删除，有返回值，代表的是取走操作
# res=l1.pop(1)
# print(l1)
# print(res)
# 7、循环
# l1=[11,222,[1,2]]
# for x in l1:
# print(x)
# 需要掌握的操作：
l1 = [11, 22, 333, 333, 333]
# l1.clear() # 清空列表
# print(l1)
print(l1.count(333)) # 看指定元素有几个
# l2=[444,555]
# for item in l2:
# # l1.append(item)
# l1.extend(l2) # 与上面的for循环操作一样
l1.extend("hello")
print(l1) # [11, 22, 333, 333, 333, 'h', 'e', 'l', 'l', 'o']
# l1=[11,22,333,333,333]
# res=l1.index(333,0,)
# res=l1.index(444) #在列表中查找某个元素并输出对应的索引值 找不到就报错
# print(res)
# l1=[11,22,"aaa",'bbb']
# l1.reverse() # 翻转
# # l1=l1[::-1] # 跟上面方法一样
# print(l1)
# l1 = [11, 22, "aaa", 'bbb']
# l1 = [-3,99,12,-5,93]
# l1.sort(reverse=True) # 从小到大排序 在进行翻转
# print(l1)
============================================================
字典dict
作用：按key.value记录多个值，优点的key对value由描述性的功能
定义：在{}内意逗号为分割，存放多个元素，每个元素都是由key：value组成
# # 类型转换
# d = dict([['name','age'],('Hans',20)])
# print(d)
#
# # 操作方法 取值
# '''
# 字典默认暴露给外界的可操作的只有字典的key
# 字典是无序的 没有索引
#
# 程序员第一准侧
# 能少写一个绝不多写一个
# '''
# d = {'name':'jason','password':1123}
# print(d['name']) # 不推荐使用该方法
# # print(d['xxx']) # 会直接报爱错
#
# # get 方法
# res = d.get('xxx')
# print(res) # 这个方法虽然多一行 但是如果没有找到对应key会返回None 提升代码的健壮性
#
# res = d.get('name','搞什么飞机')
# print(res) # key存在返回对应的值
# res = d.get('xxx','你搞什么飞机，这个键不存在')
# print(res) # 键不存在返回第二个值
#
# # 字典新增键值对
# # 方式一
# d['hobby'] = 'study' # 不存在的key直接新增
# print(d)
# d['name'] = 'Hans' # 存在的key直接修改
# print(d)
# # 方式二
# d.update(name='HAns') # 特点同上
# print(d)
# # 方式三
# d.setdefault('xxx',123)
# print(d) # key存在就是新增
# # res = d.setdefault('name',123)
# # print(d)
# # print(res)
# 快速构造字典
res = {}.fromkeys(['k1','k2','k3'],[]) # 这里的空列表是三个key共享的空间
# print(res) # {'k1': [], 'k2': [], 'k3': []}
res.get('k1').append(666) # 这里三个键指向的是同一个列表空间
print(res) # 选B
print(id(res['k1']))
print(id(res['k2']))
print(id(res['k3'])) # 查看ID可知 这三个key的ID都一样
"""
A
{'k1': [123], 'k2': [], 'k3': []}
B
{'k1': [123], 'k2': [123], 'k3': [123]}
C
报错
D
我TMD的也不知道
"""
# 弹出
# res = d.pop('username') # 将括号内指定的key对应的value弹出
# print(d,res) # jason
# res1 = d.popitem() # 将弹出的键值对组织成元组的形式返回出去
# print(d,res1) # {'username': 'jason'} ('password', 123)
# 字典方法三剑客
# print(d.keys()) # 获取字典所有的key
# print(d.values()) # 获取字典所有的value
# print(d.items()) # 获取字典所有的key和value组织成小元组
"""
可以直接只看里面的数据结构
dict_keys(['username', 'password'])
dict_values(['jason', 123])
dict_items([('username', 'jason'), ('password', 123)])
"""
# for key in d.keys():
# print(key)
# for value in d.values():
# print(value)
# for item in d.items():
# print(item)
# for k, v in d.items():
# print(k,v)
# 清空
# d.clear()
# print(d)
==============================================================
元组tuple
# 什么是元组？
# 元组就是一个不可变的列表
#
# 1、用途: 按照索引存放多个任意类型的值，索引反应的是位置/顺序
# 2、定义方式：在()内用逗号分隔开多个任意类下的值/元素
# t=(10)
# print(type(t))
# 强调:当元组内只有一个元素时，必须加逗号
# t=(10,)
# print(type(t))
# t=(10,1.1,"aaa",[11,22])
# print(t[-1][0])
# t[0]=11111 # 不可变 会报错
# t[-1]=333333
# t=(11,22,[33,44])
# print(id(t[0]),id(t[1]),id(t[2]))
#
# t[2][0]=333333333
# # print(t)
# print(id(t[0]),id(t[1]),id(t[2]))
# t=(11,22) # t=tuple(...)
# print(type(t))
# 类型转换
# tuple(所有可以被for循环遍历的类型)
# t=() # 空元组
# print(t)
# print(type(t))
# 3、常用操作+内置的方法
# 优先掌握的操作：
# 1、按索引取值(正向取+反向取)：只能取
# t=(10,1.1,"aaa",[11,22])
# print(t[0])
# 2、切片(顾头不顾尾，步长)
# t=(11,22,33,44,55)
# print(t[0:3])
# 3、长度
# t=(11,22,33,44,55)
# print(len(t))
# 4、成员运算in和not in
# t=(11,22,33,44,55)
# print(11 in t)
# 5、循环
# for x in t:
# print(x)
============================================================
集合set
'''
作用：
1，去重
集合内不可能出现重复元素
2，关系运算
共同好友共同关注
交叉并集
集合就是用上面两个功能，如果用不上，那么就不要用
'''
# 定义
s = {1, 2, 3, 4, 5, 6}
print(type(s))
'''
1，集合内的元素必须是不可变类型
2，元素之间用逗号隔开，不是键值对
3，集合内元素是无序的
'''
# 如何定义空集合 一定要用set关键字
ss = set()
print(type(ss))
# 类型转换
# 能够被for循环的数据类型都能被转成集合
s1 = set('egon is o DSB')
print(s1)
s2 = {1, 1, 1, 1, 1, 2, 2, 23, 3, 3, 3}
print(s2)
s3 = {'name': 'Hans', 'password': 123}
print(s3)
# 去重
s = {1, 1, 1, 2, 2, 2, 3, 33, 3, 3}
print(s) # 会自动去重
l = [4, 8, 3, 4, 6, 4, 3, 18, 4, 141, 64, 8, 4, 13, 59, 4, 9, 7, 5, 6, 2, 1, 3, 7]
s = set(l)
print(s) # 无序去重
new_l = []
for i in l:
if i not in new_l:
new_l.append(i)
print(new_l) # 按照原来顺序排序
# 关系运算
# 用户1的好友列表
friends1 = {'jason','tank','tony','jerry'}
# 用户2的好友列表
friends2 = {'jason','tony','owen','oscar'}
# 1 求两个用户的共同好友 交集
# res = friends1 & friends2
# print(res) # {'jason', 'tony'}
# 2 求两个用户所有的好友
# res = friends1 | friends2
# print(res) # {'jerry', 'jason', 'oscar', 'tony', 'tank', 'owen'}
# 3 求用户1独有的好友
# res1 = friends1 - friends2
# res2 = friends2 - friends1
# print(res1,res2) # {'jerry', 'tank'} {'owen', 'oscar'}
# 4 求两个用户各自独有的好友 对称差集
# res = friends1 ^ friends2
# print(res) # {'owen', 'jerry', 'tank', 'oscar'}
# 5 子集 父集
s1 = {12,3,4,5,6}
s2 = {12,6}
print(s1 > s2) # s1是否是s2的父集
print(s2 < s1) # s2是否是s1的子集
===========================================================
