数据类型内置方法下 字典、元组、集合、字符编码理论

+数据类型内置方法下 字典、元组、集合、字符编码理论

目录

• §一、字典的内置方法
  • 1、字典的类型转换dict()
  • 2、字典相关操作
    • 1.按key取值（不推荐使用）
    • 2.按内置方法get取值（推荐使用）
    • 3.修改数据值
    • 4.新增键值对
    • 5.删除数据del 、pop
    • 6.统计字典中键值对的个数 len()
    • 7.字典三剑客
    • 8.补充说明
• §二、元组的内置方法
  • 1、类型转换
  • 2、元组必须掌握的方法
    • 1.索引取值、切片间隔
    • 2.统计元组内数据值的个数len
    • 3.统计元组内某个数据值出现的次数count
    • 4.统计元组内制定数据值的索引值index
    • 5.关于元组的注意要点
• §三、集合的内置方法
  • 1、类型转换
  • 2、set集合做交集、并集、差集运算
• §四、字符编码理论
  • 1、理论了解及发展史
  • 2、字符编码实操

§一、字典的内置方法

1、字典的类型转换dict()

# 语句
dict()
字典的转换一般不使用关键字，而是自己手动转换

# 举例
a = [['jack', 123],['uzi', 123]]
res = dict(a)
print(res)

可以看出来字典的转换在格式上有很多限制，所以一般不用

2、字典相关操作

1.按key取值（不推荐使用）

# 语句
字典名['k值']

lpl = {
    'tes': 'jackeylove',
    'jdg': 369,
    'edg': ['viper', 'meiko', 'scout']
}
print(lpl['tes'])  # jackeylove 存在则正常输出
print(lpl['rng'])  # 不存在该键则正常报错

2.按内置方法get取值（推荐使用）

# 语句
字典+ .get('要取的values的keys')

1.正确取值
print(lpl.get('edg'))
------------------
['viper', 'meiko', 'scout']
2.要取的keys不存在  # 返回None
print(lpl.get('rng'))
------------------
None
3.进阶用法
字典+ .get('要取的values','当不存在对应的keys时返回这串字符')
print(lpl.get('edg','当不存在对应的keys时返回这串字符'))
print(lpl.get('rng','当不存在对应的keys时返回这串字符'))
------------------
['viper', 'meiko', 'scout']
当不存在对应的keys时返回这串字符

3.修改数据值

# 语句
字典['要改变values的keys'] = '要改变的values'

当要改变的键存在  # 会直接改变这个键的数据值

print(id(lpl))
lpl['tes'] = 'knight'
print(lpl)
print(id(lpl))
------------------
4367933568
{'tes': 'knight', 'jdg': 369, 'edg': ['viper', 'meiko', 'scout']}
4367933568

4.新增键值对

# 语句
字典['要增加的keys'] = '要增加的values'  # 会直接在字典末尾增添新的键值对


lpl['rng'] = 'knight'
print(lpl)
------------------
{'tes': 'jackeylove', 'jdg': 369, 'edg': ['viper', 'meiko', 'scout'], 'rng': 'knight'}

5.删除数据del 、pop

1.del
# 语句
del +字典['要删除的keys']

del lpl['tes']
print(lpl)
------------------
{'jdg': 369, 'edg': ['viper', 'meiko', 'scout']}

2.pop 弹出
字典.pop('要弹出的keys')

a = lpl.pop('tes')
print(lpl)
print(a)
------------------
{'jdg': 369, 'edg': ['viper', 'meiko', 'scout']}
jackeylove

3.popitem
popitem() 用来随机删除一个键值对

print(lpl1.popitem())
-----------------
('edg', ['viper', 'meiko', 'scout'])

6.统计字典中键值对的个数 len()

len(要统计的字典)  # 输出的数字

print(len(lpl))  # 3

7.字典三剑客

• 一次性获取字典所有的键

字典.keys() 

print(lpl.keys())
------------------
dict_keys(['tes', 'jdg', 'edg'])

• 一次性获取字典所有的值

字典.values() 

print(lpl.values())
------------------
dict_values(['jackeylove', 369, ['viper', 'meiko', 'scout']])

• 一次性获取字典的键值对数据

字典.items() 

print(lpl.keys())
------------------
dict_items([('tes', 'jackeylove'), ('jdg', 369), ('edg', ['viper', 'meiko', 'scout'])])

8.补充说明

• fromkeys生成相同数据值不同键的字典

# 语句
dict.fromkeys(['要生成的列表的keys'], 要生成的数据值values)
# 这里生成的可以是不同的键，但他们内的值都是相同的，相当于把一个数据值赋值给不同的键

print(dict.fromkeys(['faker','chovy','ruler'],123))
res = dict.fromkeys(['faker','chovy','ruler'],[])
print(res)
------------------
{'faker': 123, 'chovy': 123, 'ruler': 123}
{'faker': [], 'chovy': [], 'ruler': []}

• append 为数据值为空列表的时候添加数据值

'''当第二个公共值是可变类型的时候 一定要注意 通过任何一个键修改都会影响所有'''

lpl = {'tes':[],'edg':[], 'jdg':[]}
lpl['tes'].append('jason')
lpl['edg'].append(123)
lpl['jdg'].append('study')
print(lpl)
------------------
{'tes': ['jason'], 'edg': [123], 'jdg': ['study']}

• detdefault 默认值 None

setdefault() 方法用来返回某个 key 对应的 value
	当指定的 key 不存在时，setdefault() 会先为这个不存在的 key 设置一个默认的 defaultvalue，然后再返回 defaultvalue。
	也就是说，setdefault() 方法总能返回指定 key 对应的 value：
  
	1.如果该 key 存在，那么直接返回该 key 对应的 value；
	2.如果该 key 不存在，那么先为该 key 设置默认的 defaultvalue，然后再返回该 key 对应的 defaultvalue。

a = {'数学': 95, '语文': 89, '英语': 90}
print(a)
#key不存在，指定默认值
a.setdefault('物理', 94)
print(a)
#key不存在，不指定默认值
a.setdefault('化学')
print(a)
#key存在，指定默认值
a.setdefault('数学', 100)
print(a)
------------------
{'数学': 95, '语文': 89, '英语': 90}
{'数学': 95, '语文': 89, '英语': 90, '物理': 94}
{'数学': 95, '语文': 89, '英语': 90, '物理': 94, '化学': None}
{'数学': 95, '语文': 89, '英语': 90, '物理': 94, '化学': None}

§二、元组的内置方法

1、类型转换

# 语句
tuple() 支持for循环的数据类型都可以转换为元组

2、元组必须掌握的方法

1.索引取值、切片间隔

1.索引取值
元组[索引值]
# 其中 索引值可以是正数也可以是负数 ，负数代表了方向从右往左
2.切片间隔
元组[起始索引:结束索引:步长step]

2.统计元组内数据值的个数len

tup = (11, 22, 11, 22, 33, 44, 55, 123, 123, 321)
print(len(tup))
------------------
10

3.统计元组内某个数据值出现的次数count

元组.count(数据值)

tup = (11, 22, 11, 22, 33, 44, 55, 123, 123, 321)
print(tup.count(11))
------------------
2

4.统计元组内制定数据值的索引值index

Index访问元组中的某个元素,得到的是这个元素的索引值

print(tup.index(22))
------------------
1

5.关于元组的注意要点

• 元组内如果只要一个数据值那么逗号不能少
• 元组内索引绑定的内存地址不能被修改（注意区分 可变与不可变）
• 元组内不能新增或者删除数据

§三、集合的内置方法

1、类型转换

set()
# 集合内数据必须是不可变类型(整型、浮点型、字符串、元组)
#	集合内数据也是无序的,没有索引的概念

集合常常应于 去重和关心运算

2、set集合做交集、并集、差集运算

运算操作	运算符	含义	例子
交集	&	取两集合公共的元素	set1 & set2
并集	|	取两集合全部的元素	set1 | set2
差集	-	取一个集合中另一集合没有的元素	set1 - set2 {1,2} set2 - set1
对称差集	^	取集合 A 和 B 中不属于 A&B 的元素	set1 ^ set2

1. 取交集 intersection()
set3 = set1.intersection()
2. 判断子集 issuperset()
set1.issuperset(set2) 判断 set2 是否是 set1 的子集

# 判断set1是否是set2的父集 输出值为布尔值
 print(set1 > set2)
 print(set1 < set2)

§四、字符编码理论

1、理论了解及发展史

1.字符编码只针对文本数据
2.回忆计算机内部存储数据的本质
3.既然计算机内部只认识01 为什么我们却可以敲出人类各式各样的字符
	肯定存在一个数字跟字符的对应关系 存储该关系的地方称为>>>:字符编码本
4.字符编码发展史
	4.1.一家独大
		ASCII码:记录了英文字母跟数字的对应关系
  # 用8bit(1字节)来表示一个英文字符
            
 	4.2.群雄割据
	# 中国人
    GBK码:记录了英文、中文与数字的对应关系
   	用至少16bit(2字节)来表示一个中文字符，很多生僻字还需要使用更多的字节，英文还是用8bit(1字节)来表示
	# 日本人
    shift_JIS码:记录了英文、日文与数字的对应关系
	# 韩国人
    Euc_kr码:记录了英文、韩文与数字的对应关系
  		"""
  		每个国家的计算机使用的都是自己定制的编码本，不同国家的文本数据无法直接交互 会出现"乱码"
  		"""
  	4.3.天下一统
  # unicode万国码
       兼容所有国家语言字符，起步就是两个字节来表示字符 
  # utf系列:utf8 utf16 ...
       专门用于优化unocide存储问题，英文还是采用一个字节，中文三个字节

2、字符编码实操

1.当我们遇到乱码不要慌，切换编码试一试即可
2.编码与解码
	编码:将人类的字符按照指定的编码编码成计算机能够读懂的数据
        # 字符串.encode()
 	解码:将计算机能够读懂的数据按照指定的编码解码成人能够读懂
        # bytes类型数据.decode()
3.python2与python3差异
	python2默认的编码是ASCII
	1.文件头
        # encoding:utf8
    2.字符串前面加u
        u'你好啊'
 	python3默认的编码是utf系列(unicode)