元组、布尔、集合内置方法以及数据类型内置方法总结

昨日内容回顾

【一】列表类型内置方法

（一）类型强制转换

• 字符串可以转换成列表 字符串中的每一个元素
• 字典 转换为列表以后是 字典的键
• 元组 转换为列表
• 集合 转换为列表 集合的去重性和无序性 ---> 一旦转换成功 这个列表就定死

（二）按照索引取值

• 正向： 从0开始
• 反向：从-1开始
• 可以取值并将取到的值位置的索引值替换掉
• 索引取值的情况下，如果没有索引的值就会报错

（三）切片

• 顾头不顾尾：range

• [起始位置：截止位置：步长]

• [：：-1] ：翻转

• 负索引取值的时候第一个起始位置要从右向左取

• [：：-2]

name = 'gdyandhyt'
print(name[0:4:2])			# gy

• 从右向左开始

name = 'gdyandhyt'
print(name[-1:-4:-1])		# tyh

（四）计算长度

• 语法：len(变量名)

（五）成员运算

• 可以判读当前元素是否在当前列表

• in

• not in

• 可以将字典的键转换为列表 用成员运算判断当前输入的用户名是否存在于当前列表中

（六）操作方法

（1）增加

• extend(直接放列表)
• insert(索引位置，值)
  • 插入到指定索引位置上
• append() 将元素默认追加到结尾

（2）查看

• 直接打印列表
• 索引取值

（3）删除

• pop() ：如果不写参数则默认删除最后位置的元素 可以将元素弹出可以用变量名接受
• pop(索引)： 直接弹出指定索引位置的元素
• remove(值) ：在列表中存在的值才能被remove
• del 列表[索引位置]： 将从列表中按照索引位置取出来的值删除掉

（4）修改

• 直接索引取值 = 修改的新值

（七）颠倒元素

• 列表.reverse(): 将列表中的所有元素翻转

• list(reversed(列表))

（八）对列表中的元素进行排序

• 列表.sort() : 将原来的列表进行排序 ---> 影响到的是原来的列表

• sorted(列表)：有返回值，返回值就是排序后的列表，并且原本的列表不受影响

• 有一个参数 reverse=True:将排序号的结果翻转

（九）遍历列表

• for 循环获取列表中每一个元素
• for + range 关键 ：可以放指定区间 ---> 根据索引坐标获取列表值
• while 列表的长度： 内部有count 根据索引指定索引对应的值

【二】字典类型内置方法

【1】定义风格

• 在一个{}里面放一个k:v键值对

【2】字典操作

（1）增加

• 有则修改，无则添加
• 字典[key] = value
• 字典.update({k:v}) ---> 更新原来的字典
• 字典.update(k=v) ---> 更新原来的字典
• setdefault(k,v) ---> 有返回值返回值是你设置进去的键值对的值

（2）查看

• 字典[key] 取值 ---> 拿到指定键对应的值，取不到会报错
• 字典.get(key) 取值 ---> 拿到指定键对应的值，取不到的话不会报错
• 查看字典的键对 字典.keys() dict.keys 支持成员运算
• 值对 字典.values()
• 键值对 字典.items() ：在列表中存在的一个个的元组 (key,value)
• for key,value in 字典.items(): 解压赋值

（3）修改

（4）删除

• pop() ---> 弹出最后的元素
• del 字典[key]：把查询的键和对应的值全部删除
• 清空字典 字典.clear()
• 删除键值对 字典.popitem()

【3】遍历循环

for key in user: 拿到的值就是键

今日内容

元组内置方法

【一】元组的定义

• 在元组的内部，只有一个元素的时候 + “，”

【二】类型强制转换

• 整数类型和布尔类型不可以

print(tuple([1,2,3]))
print(tuple('dream'))
print(tuple({1,2,2}))
print(tuple({'username':"dream"}))

【三】索引取值

num_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9)
print(num_tuple[0])

• 切片：顾头不顾尾
• 不支持根据索引修改指定的索引值

num_tuple[0] = 999

【四】计算元素个数

print(len((1,2,3)))				# 3

【五】成员运算

print(4 in (1,2,3))				# False

【六】支持遍历

for i in (1,2,3,4):
    print(i)					# 结果：将1234输出一遍
# for + range ---> 索引取值

【七】元组拼接

• 两个列表+起来 ，可以得到一个新列表，其中包括了两个列表的元素

print([1, 2, 3] + [4, 5, 6])			# [1, 2, 3, 4, 5, 6]

• 两个元组+起来，可以得到一个新元组，其中包括两个元组的的元素

print((1, 2, 3) + (4, 5, 6))			# (1, 2, 3, 4, 5, 6)

【八】* 号运算

print((1, 2, 3) * 6)			# (1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3)

布尔类型的内置方法

【一】强制类型转换

• 强制将其他类型转换为布尔类型

print(bool(0))				# False
print(bool(1))				# True
print(bool(2))				# True

# 在python中结果为假的情况
# 布尔值false
# 空值

集合类型的内置方法

【一】集合的定义

• 集合是用{}的定义的，并且每一个元素但是单独的，区分与字典的是，字典中是键值对
• 集合内部的元素不能放可变数据类型

【二】集合的特性

• 无序性

  • 相对于其他类型来说

• 数字类型的hash值是死的

print({1, 2, 3, 4, 5, 6, 999, 55, 'a', 77, 'c', 44})

• 去重性
  • 在一个集合内不会出现重复的元素

【三】其他类型的数据强转

• 强转的时候会沿用集合的特性，无序且去重

name = 'hanyutong'
print(set(name))			# {'u', 'h', 'y', 'a', 'o', 'n', 't', 'g'}
print(set({'username': "hyt", 'password': "123"}))			# {'username', 'password'}

【四】集合操作

【1】添加元素

num_set = {1, 2, 3}
num_set.add(999)			# add的方法只能添加一个元素
print(num_set)				# {1, 2, 3, 999}

num_set.update([1, 2, 3, 4])
num_set.update((4, 5, 6))		# 无论是列表还是元组添加进来之后都是以集合的形式存在	
print(num_set)					# {1, 2, 3, 4, 5, 6, 999}

• 把注册过的用户名全部扔到集合中

• 利用集合的去重性判断当前用户是否注册过

username_tuple = {'gdy', 'hyt'}
username = input(':>>>')
username_tuple.add(username)

【2】删除元素

• 删除已经存在的值

num_set = {1, 2, 3,999}
num_set.remove(999)
print(num_set)				# {1, 2, 3}

• remove 删除集合中不存在的值是会报错

num_set.remove(999)			#直接报错
print(num_set)

• discard 删除不存在的元素时不会报错，而是返回原来的集合

num_set.discard(999)		#{1, 2, 3}
print(num_set)

• pop 在其他的数据类型可以指定参数，但是在集合中不能指定参数，默认删除左1

num_set = {1, 2, 3,999}
num_set.pop()
print(num_set)			# {2, 3, 999}

【五】集合的运算

• 交集 ： 两个集合中共有的元素

set1 = {1, 2, 3}
set2 = {3, 4, 5}
intersection_set = set1.intersection(set2)
print(intersection_set) 			 # 输出: {3}

• 并集：将两个集合中的元素合并到一起

set1 = {1, 2, 3}
set2 = {3, 4, 5}
union_set = set1.union(set2)
print(union_set) 			 # 输出: {1, 2, 3, 4, 5}

• 差集：你有但是我没有的数据

set1 = {1, 2, 3}
set2 = {3, 4, 5}
difference_set = set1.difference(set2)
print(difference_set)  					# 输出: {1, 2}

• 判断两个集合是否相等

is_equal = set1 == set2
print(is_equal)					# 输出: False

• 将列表转成了集合

list = ['a','b',1,'a']
num = set(list)	
print(num)				# {'a', 'b', 1}

l_new = list(s)  # 再将集合转回列表
print(l_new)  # 去除了重复，但是打乱了顺序			# ['b', 'a', 1]

• 针对不可变类型，并且保证顺序则需要我们自己写代码实现，例如

l_second = [
    {'name': 'lili', 'age': 18, 'sex': 'male'},
    {'name': 'jack', 'age': 73, 'sex': 'male'},
    {'name': 'tom', 'age': 20, 'sex': 'female'},
    {'name': 'lili', 'age': 18, 'sex': 'male'},
    {'name': 'lili', 'age': 18, 'sex': 'male'},
]

new_l_second = []

for dic in l_second:
    if dic not in new_l_second:
        new_l_second.append(dic)

print(new_l_second)
# 结果：既去除了重复，又保证了顺序，而且是针对不可变类型的去重
'''
[
{'name': 'lili', 'age': 18, 'sex': 'male'}, 
{'name': 'jack', 'age': 73, 'sex': 'male'}, 
{'name': 'tom', 'age': 20, 'sex': 'female'}
]
'''

数据类型小结

按存值个数来算

只能存一个：字符串、数字类型、布尔

能放多个：列表、元组、集合、字典

按访问当时区分

能索引取值：字符串、列表、元组

能键取值：字典

不能取值：数字类型、布尔、集合

按可变和不可变

能变化的：列表、字典

不能变化的：数字类型、字符串、集合、元组、布尔