实训第 4 天 ------ 7.18

一.元祖(tuple)

元祖的含义:
1.元祖是一个不可变的序列。
2.它的操作方式基本上和列表是一致的。
3.所以你在操作元祖时，就把元祖当成是一个不可变的列表就ok了。
4.一般当我们希望数据不改变时，就使用元祖，其余情况都使用列表。
备注：元祖使用’小括号’创建。

---

my_tuple=()   #只要是 一个变量/常量=() 就是元祖的写法
print('元祖的类型吗：',type(my_tuple))   #<class 'tuple'>
#如何给元祖赋值呢？
my_tuple1=('孙悟空','abc','12','wang里')
print('元祖my_tuple1的值为：',my_tuple1)
#如何给元祖开辟内存大小呢？
my_tuple2=(10,120) #如果（）有大于等于2个以上的int，表示的不是内存，内存只能写一个int值
my_tuple3=(120)   #内存大小为120
#元祖时不可变对象，不能尝试为元祖中的元素重新赋值
my_tuple3=('王老师','李老师','赵老师',)

获取元祖的下标去拿3值，或者修改值等操作 ---- 元祖不能重新赋值 ----重点

#my_tuple4[1]='李四'
my_tuple5=12,123,121545,'王老师'#此写法也是元祖的写法 但是不建议使用  Why？
my_tuple6=('王老师','李老师','赵老师',)

（）有2层解释含义

1.（）表示的是一个函数
2.（）表示一个可以带参数/不带参数的方法
思考： 假设函数没有（）， 效率咋样？
结果： 在企业工作里面使用（）函数式元祖赋值，不建议省略（），影响数据的性能问题！

---

my_tuple7=('王老师','李老师','赵老师',12,1235)
print('没有删除元祖之前的值为：',my_tuple7)
del my_tuple7
#print('删除元祖之后的值为：',my_tuple7)

重点内容 ： 和python的sel函数功能一样
思考： delete 和drop有什么区别？
（1）.delete只能操作表数据，但是不能操作表结构，也不能改变表结构等
python的del也不能操作表结构，只能删除元祖、list列表中的数据！
（2）.drop执行drop命令会将表和表数据彻底删除，并且drop回破坏表结构，
会导致内存溢出，数据很难维护。
总结：企业优化sql里面不能使用drop -------作业：如何优化sql？

my_tuple7=('aaa','bbbb','ccccc')
print('通过截取元祖1:2的 值为：',my_tuple7[1:2])
print('通过截取元祖1:2的 值为：',my_tuple7[2:3:2])  #步长

备注：元祖的截取是通过list列表的切片机制操作！
总结：计算机语言的括号的使用规则 ([]) {[]} " ‘’"

#多维元祖：大于等于2个()()的定义

my_tuple8 = (),()
my_tuple9 = [],[]
print('多维元祖：',type(my_tuple8))
print('多维列表1：',type(my_tuple9))
my_tuple10 = []
print('多维列表2：',type(my_tuple10))

备注：
利用一个[]可以创建一个list列表，但是定义2或者2个以上的[]，表示的是多维元祖
--------列表其实是特殊的的元祖，元祖里面包含列表
my_tuple=(12) #元祖值为 12 12为长度 (‘ccccc’,) ,表示切片终止

备注：（12）有2种解释：
1.值为12
2.python解释器在内存里面执行的时候，会按照内存12操作数据

my_tuple11=('a','b','v','d')
num=len(my_tuple11)        #len表示元素的个数，和内存大小有区别
print('my_tuple11的元祖长度为：',num)

my_tuple12=(12,12222,1516,1616,-1,-2)
my_tuple13=(12,22222,1516,1616,-1,-2)
num1=max(my_tuple12)
num2=max((my_tuple12,my_tuple13))    #max有2种用法 1.取最大值 2.可以带多个参数，将元素原样输出！
num3=min(my_tuple12)
print('max1的最大值为：',num1)
print('max2的最大值为：',num2)
print('min的最小值为：',num3)

代码快捷键 ctrl+/ 调试bug ctrl+l

students=['jack','tom','john','amy','kim','sunny’]
 print(students)
 tuple1=tuple(students) print(tuple1)  #此代码表示强制类型转换

person=['jack','tom','john','amy','kim','sunny']
print('列表的值为',person)
#将列表转化为元祖
my_tuple14=tuple(person)
print('转换之后的值为：',my_tuple14)

列表转化为元祖的特性 --------重点面试
1.列表是有序的，列表可以改变值，元祖时固定位置，并且不可以改变值------
2.元祖的优先级大于列表的，在工作里面，尽量使用元祖
3.列表存放数据没有元祖安全、数据没有元祖容易维护、元祖查询数据的速度比列表快！
4.万物皆为对象----对象的属性、方法等就属于元素-----元素属于元祖

python的字典内容 -----重点
语法结构：字典名={key1:value1,key2:value2} —键值对

my_dict={1001,'王老师',1002,'李老师',1003,'赵老师'}  #字典
print('my_dict的值为：',type(my_dict))   #my_dict的值为： <class 'set'>

字典的核心特性：
1.字典使用{} —Why？ json{} {}表示键值对的写法，此写法传输数据的速度极快
2.字典的关键字dict
3.字典通过键取值，键不可以重复，值可以重复 ------和java中Map一样 ------面试必问(Map List Set课下研究)
4.字典的键 和 数据库的id主键原理一样！

---

字典的键可以是任意的不可变对象(int,str,bool,tuple…),但是一般我们都会使用str
Map<Integer,String>Map =new Map<Integer,String>。
备注：python为什么key也用 str呢？ 因为服务器永远是字符串 -------胶水语言
students={‘name’:‘Tom’,
‘age’:18,
‘sex’:‘男’,
‘name’:‘jack’,
} #代码具有可读性
print(‘通过students的键值对取值：’,students[‘name’]) #获取一个值
print(‘通过students的键值对取多个值值：’,students[‘name’],students[‘age’],students[‘sex’])
#如果使用了字典中不存在的键，会报错
print(‘通过students的键值对取值：’,students[‘121’]) #KeyError: ‘121’ -----空指针

my_tuple15=[12,1555,1442]
my_tuple16=(112, 55)
my_tuple17=my_tuple15+my_tuple16   #[(1,2),(3,4)]     Traceback (most recent call last):
print('my_tuple17是通过列表和元祖拼接的结果：',my_tuple17)
my_tuple18=[(1,2),(3,4)]
print('my_tuple18',type(my_tuple18))                 #my_tuple18 <class 'list'>

students1={'name':'Tom',
          'age':18,
          'sex':'男',
          #'name1':''
          }    #代码具有可读性
print('len的个数：',len(students1))
#get方法
print('get方法的作用：',students1.get('name'))     #有值
print('get方法的作用：',students1.get('name1'))    #无值  ---get方法的作用：none  ----企业大量使用

总结：
1.在key-value里面，企业通过key获取值，不建议使用index获取值！
2.检定义为str类型
3.键获取值的原理是什么？ -----Mapping映射关系
扩展：映射的作用是什么？ 为什么企业框架 ssm ssh都会采用映射呢？
1.通过映射可以减少开发代码量！
2.映射可以很好的将项目的业务进行关联维护！ -------springMVC 课下看

students2={'name':'Tom',
          'age':18,
          'sex':'男',
          'name1':''
          }    #代码具有可读性
students2['name1']='蔡徐坤'   #如果有相同的key，覆盖
print('students2：',students2)
students2['name2']='王老师'     #如果没有，新增
print('students2：',students2)

result=students2.setdefault('age',145)
print('result的结果集是：',result)
result=students2.setdefault('dada',145)     #----------重点
print('result的结果集是：',result)

d1={'a':1,'b':2}
d2={'a':1,'b':6,'c':3}     # ---------更新操作
d1.update(d2)
print(d1)
print(d2)

CRUD操作 list 元祖 set集合 ------切片操作 ------遍历结果集 ------3大循环
#定义一个字典

person1={'1001':'王老师','name':'赵老师','age':12,'birthday':100}
person2=['1001王老师','name赵老师','age12']
print('person1的字典值为：',type(person1))
print('person1的返回次数为：',len(person1))
print('person2的返回次数为：',len(person2))

适应看底层源代码去学习编程 快捷键 ctrl + 鼠标左键

person3={‘1001’:‘王老师’,‘name’:‘赵老师’,‘age’:12,‘birthday’:100}
思考：如何获取person3的值？ 用get key index 切片
1.通过str可以将{值} [值]一次性输出，并且不需要类型转换！
2.str不仅仅表示一个字符串，还表示一个函数功能，也是一个方法！

result2=str(person3)   #通过str表示的是将元素的值按照字符串输出
print('此时person3的类型是：',type(person3))
print('result的结果是：',result2)

seq1=('name','age','sex')
result3 = dict.fromkeys(seq1)  #fromkeys(seq) ---seq 表示一个对象或者参数都可以解释
print('result3的值为：',result3)   #fromkeys(seq)表示的是将字典，元祖里面的值作为键输出
seq2={'name':'fhf','age':'fdffdf','sex':'kjk'}
result4 = dict.fromkeys(seq2)
print('result4的值为：',result4)

此方法就是对key的一个扩展，Why？
1万条数据 10页 1000 key1=1000 key2=100
------fromkeys可以处理海量数据

**备注：**元祖里面嵌套字典/列表，对于key -values来讲会发生key -values的值的不确定性！

dict1={'name':['tom','jack'],'age':18,'sex':'男',18:19}
name=('name','age','sex')
if 'name' in dict1:
 print("name在字典中存在")
else:
 print("name在字典中不存在")

dict2 = {'name': ['tom', 'jack'], 'age': 18, 'sex': '男', 18: 19}
print(dict2.keys())           #结果：dict_keys(['name', 'age', 'sex', 18])

keys 和index的区别是什么？

keys的底层实现原理 —keys可以一次性查询去所有键，Why？
1.D.keys() -> a set-like object providing a view on D’s keys
keys底层其实就是实现一个like函数的查询方法！ 但是like查询的效率太低
like不可以满足查询海量数据的操作！
补充回顾 (优化sql) -------面试必问
2.like有几种用法？
select name from emp like name =’% 王%’
select name from emp like name =‘王%’
select name from emp like name =’%王’
select name from emp like name =’%’
3.like的缺点
(1).like查询数据会产生缓存！----jd 淘宝 —查询数据(slor的核心是《lunces》)全文检索
(2).like在操作数据的时候会将数据切片！数据可能不是很完整！-----不再使用！

dict1={'name':'tom','age':18}
print(dict1.values())