1.列表剩余补充

1.升序.sort() 

列表内元素升序
	ll = [33, 22, 11, 22, 11,33, 22, 77,66, 55, 44]
	ll.sort()
	print(ll)
	[11, 11, 22, 22, 22, 33, 33, 44, 55, 66, 77]

2.降序.sort(reverse=True) 

列表内元素降序  # reverse为翻转，可以翻转列表内元素的位置，通过.sort()升序后在翻转，可以理解为降序
	ll = [33, 22, 11, 22, 11,33, 22, 77,66, 55, 44]
	ll.sort(reverse=True)
	print(ll)
	[77, 66, 55, 44, 33, 33, 22, 22, 22, 11, 11]
# .reverse()可以在代码中单独使用，为翻转的意思

3.列表索引

索引也可以使列表内元素顺序颠倒
	ll = [33, 22, 11, 22, 11,33, 22, 77,66, 55, 44]
	print(ll[:])  # 索引出列表内元素
	print(ll[::-1])  # 倒序索引出列表内元素
	print(ll[:5])  # 左边从头开始，到5内结束
	print(ll[1:])  #从1开始到结束

4.列表比较运算采用相同索引位置比较，0索引比较出结果就结束 

列表比较
	l1 = [888,999]
	l2 =[111,222,444]
	print(l1 > l2)
	True
#字符串也可以根据索引值进行对比，需要转成ASCII对应的数字进行比较

字典的基本操作

1.字典的定义

#大括号内存放多个以K：V键值对，逗号隔开的元素
#K使对V的描述性性质的信息，一般使字符串
#K必须使不可变类型
#K不能是重复的，如果是重复的会表现出来为指向后一个V的变量
#V是真正的数据，相当于变量，可以是任意数据类型

2.字典类型转换.fromkeys 

1.直接转换()内的内容
	print(dict(name='tony',age='20',hobby='read'))
	{'name':'tony','age':'20','hobby':'read'}
2.列表转字典
	info=dict([['name','tony'],('age',18)])
	info
	{'age': 18, 'name': 'tony'}
3.fromkeys会从元组中取出每个值当做key，然后与None组成key:value放到字典中
	{}.fromkeys(('name','age','sex'),None)  
	{'age': None, 'sex': None, 'name': None}

3.按K取值

按K取值，K不存在，直接报错

按照K取值
	dict_1={'name':'tony','age':'20','hobby':'read'}
	print(dict_1[name])
	tony

4.按K修改值，没K新增键值对

按K修改值,新增键值对
	dict_1={'name':'tony','age':'20','hobby':'read'}
	dict_1['name'] = 'tonyyy'
	print(dict_1)
	{'name': 'tonyyy', 'age': '20', 'hobby':'read'}
# K存在则修改 V
	dict_1={'name':'tony','age':'20','hobby':'read'}
	dict_1['xxxx']='jjj'
	print(dicct_1)
	{'name': 'tony', 'age': '20', 'hobby': 'read','xxxx': 'jjj'}

5.删除元素

1.del
	dict_1={'name':'tony','age':'20','hobby':'read'}
	del dict_1{'name'}
	print(dict_1)
	{'age':'20','hobby':'read'}
2..pop()  # ()内需要放K.指定K，弹出键值对，给出VV可以继续使用
	dict_1={'name':'tony','age':'20','hobby':'read'}
	dict_1.pop('name')
	print(dict_1.pop('name'))
	tony
	print(dict_1)
	{'age':'20','hobby':'read'}
#  使用.pop()进行删除字典元素

6.获取V值.get()取值不存在不会报错

字典取值有一定要用.get()

.get()
	dict_1={'name':'tony','age':'20','hobby':'read'}
	print(dict_1.get('xxx'))
	None
#  字典取值不存在V值返回None
	dict_1={'name': 'tony', 'age': '20','hobby':'read'}
	print(dict_1.get('xxx','hahaha'))
	hahaha
#取字典K值不存在返回hahah，自定义返回结果

7.取K:V,整个字典的值keys() .valuse() .items() 

1.取出全部的K值
    dict_1={'name':'tony','age':'20','hobby':'read'}
	l1 = dict_1.keys()
	print(l1)
	dict_keys(['name', 'age', 'hobby'])
# 可以将取出来的值看成列表
2.去除所有的V值
	dict_1={'name':'tony','age':'20','hobby':'read'}
	l1 = dict_1.values()
	print(l1)
	dict_values(['tony', '20', 'read'])
#可以将取出来的值看成列表
3.获取字典里的键值对，获取的值为列表，里面包含元组，每个元组有两个元素，为k,V
	dict_1={'name':'tony','age':'20','hobby':'read'}
	l1 = dict_1.items()
	print(l1)
	dict_items([('name', 'tony'), ('age', '20'), ('hobby', 'read')])

8.统计字典内键值对的个数.len

9.成员运算，只暴露K。in not in会以True，False的形式返回

3.元组内置

括号内部由逗号隔开多个元素的组成
元素是任意数据类型，元组内元素不支持‘修改’（索引指向的元素内存地址不能更改）#内部可以有列表，可以增加列表的值
可以认定为一个比可变的列表
#只能针对不可变类型
#集合本身无序，去重之后无法保留原来的顺序

1.类型转换

支持for循环的数据都可以转换成列表
#不可以转换整形，字符串
1.字符串
	print(tuple('hello'))
	('h', 'e', 'l', 'l', 'o')
2.列表
	print(tuple([22,33.4,55]))
	(22, 33.4, 55)
3.字典
	print(tuple({'name':'jason','pwd':123}))
	('name', 'pwd')
4.集合
	print(tuple({22,33.4,55}))
	(33.4, 22, 55)

2.元组单元素定义

l1 = (111,)
l2 = (11.11,)
l3 = ('hello',)
#元组就是只有一个元素也要添加逗号。

3.容器类型

#内部可以存放多个之的数据类型都可以称之为容器类型
#所有容器类型在储存数据的时候，如果内部只有一个元素，也要添加上逗号

4.元组内置集结

1.索引，方向取值
2.切片，左切，又切，全部切
3.步长
4.len统计元素个个数
5.成员运算
6.for循环
	for i in 元组：
#依次取出
7..count()
#记数

4.集合内置

大括号内部多个元素由逗号隔开
元素只能是不可变类型，元素不能重复
#定义空集合需要关键字
l1=set()
l2={}  # 空大括号定义为字典

1.类型转换

可以被for循环的数据都可以被转换为集合，被转换的类型内部元素必须是不可变类型
	s = set([1,2,3,4])
	{1, 2, 3, 4}

	s1 = set((1,2,3,4))
	{1, 2, 3, 4}

	s2 = set({'name':'jason',})
	{'name'}

	s3 = set('egon')
	{'e', 'o', 'g', 'n'}

2.内置使用

1.合集
	l1 = {"zero","kevin","jason","hello"}
	l2 = {"Jy","ricky","jason","hello"}
	print(l1 | l2)
	{'zero', 'hello', 'ricky', 'kevin', 'Jy', 'jason'}
#去掉重复的元素保留一个
2.交集
	l1 = {"zero","kevin","jason","hello"}
	l2 = {"Jy","ricky","jason","hello"}
	print(l1 & l2)
	{'hello', 'jason'}
#取出重复的元素
3.差集
	l1 = {"zero","kevin","jason","hello"}
	l2 = {"Jy","ricky","jason","hello"}
	print(l1 - l2)
	{'zero', 'kevin'}
#一列表减二列表取出一列表内二列表不包含的值
	l1 = {"zero","kevin","jason","hello"}
	l2 = {"Jy","ricky","jason","hello"}
	print(l2 - l1)
	{'Jy', 'ricky'}
#同上
4.值朱否相等(==)
	l1 = {"zero","kevin","jason","hello"}
	l2 = {"Jy","ricky","jason","hello"}
	print(l2 == l1)
	False
#得到True或者False
5.父集，子集
	l1 = {1,2,3}
	l2 = {1,2}
	print(l2 < l1)
	True
#得到True或者False，判断是否包含与另一个集合相同的元素

3.练习

普通；去重
困难；去重并保留原来的顺序
地狱：去重并保留原来的顺序，打印出来后在降序
1.去重
	l1 = [33, 22, 11, 22, 11, 44, 33, 22, 55, 66, 77, 77, 66, 55, 44]
	s1 = set(l2)
	l4 = list(s3)
	print(l4)
	[33, 66, 11, 44, 77, 22, 55]
#1.先将列表转换为集合
#2去重后再将集合转换为列表
#3.最后打印
	ll = [33, 22, 11, 22, 11, 44, 33, 22, 55, 66, 77, 77, 66, 55, 44]
	# 1.建立一个空的列表
	l1 = []
	# 2.for循环ll列表内的元素依此赋值给i
	for i in ll:
    	# 3.判断取出来的元素i在不在新的新的l1列表中
    	if i not in l1:
        	# 4.i里面的值不在l1中就依此添加到l1中
        	l1.append(i)
	# 5,最后打印出来
	print(l1)
	[33, 22, 11, 44, 55, 66, 77]
#最后结束
	ll = [33, 22, 11, 22, 11, 44, 33, 22, 55, 66, 77, 77, 66, 55, 44]
	# 1.建立一个空的列表
	l1 = []
	# 2.for循环ll列表内的元素依此赋值给i
	for i in ll:
		# 3.判断取出来的元素在不在新的新的列表中
		if i not in l1:
		# 4.不在新的列表中就添加进去
		l1.append(i)
	# 5.再将l1里面的元素降序
	l1.sort(reverse=True)
	print(l1)
	[77, 66, 55, 44, 33, 22, 11]
#最后结束

2021-11-09 19:58:12 星期二