数据内置方法

1 元组类型内置方法

【一】元组的定义

() 在元组的内部，只有一个元素的时候要+ ’ , ‘ 。如果不加’ , ‘就会变成了一个字符串或者是其他的类型。

【二】类型强转

转换其他数据类型为元组

整数类型不行，布尔类型也不行

print(tuple([1,2,3]))  #(1,2,3)
print(tuple('happy')) #('h','a','p','p','y')
print(tuple({1,2,2}))  #(1,2)
print(tuple({'username':"happy"}))  # ('username',)

【三】索引取值

num_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9)
print(num_tuple[0])  # 1
# 切片：顾头不顾尾
print(num_tuple[0:5]) #(1, 2, 3, 4, 5)
#不支持根据索引修改指定索引的值
num_tuple[0] = 999   #error

【四】计算元素个数

print(len((1, 2, 3，4，5)))  # 5

【五】成员运算

 print(3 in (1,2,3))  #Trueprint(4 in (1,2,3))  #Fales

【六】支持遍历

for i in (1,2,3,4):print(i)
#1
#2
#3
#4
for + range ---> 索引取值
range ： 顾头不顾尾for i in range(len(name)):print(name[i])  #由于len(name)是5 然后range取值是从0开始 0-4正好是dream
#d
#r
#e
#a
#m       

【七】元组拼接

 print('silence' + '666') #silence666
# 两个列表进行 + 运算，得到了一个两个列表元素拼到一起的新列表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)
# 如果元组 用 * 运算得到的是一个新的元组
#如果列表用 * 运算得到的是一个新的列表

2 布尔类型的内置方法

# 布尔类型的内置方法
# 强制类型转换# 强制将其他类型转换为布尔类型
print(bool(0))  #False
print(bool(1))  #True
print(bool(2))  #True# 在Python中为假
# 布尔值False
# 数字 0
# 空值

3 集合类型的内置方法

【一】集合的定义

{} 并且每一个元素是单独的，区分于字典，因为字典是键值对

集合内部的元素不能放可变数据类型

【二】集合的特性

无序性，去重性

无序性
#相对于其他类型来说
#数字类型的hash值是死的
print({1, 2, 3, 4, 5, 6, 999, 55, 33, 77, 88, 44})
#{1, 2, 3, 4, 5, 6, 999, 33, 44, 77, 55, 88}print({1, 2, 3, 4, 5, 6, 999, 55, 'd', 77, 'ee', 44}) #数字不动 字符串到处乱跑
#{1, 2, 3, 4, 5, 6, 999, 'd', 44, 77, 'ee', 55}
#{1, 2, 3, 4, 5, 6, 999, 44, 77, 55, 'ee', 'd'}去重性
# 在一个集合内不会出现重复的元素

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

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

name = 'silence'
print(set(name))  #{'n', 's', 'i', 'e', 'c', 'l'}#{'n', 'e', 'i', 'c', 's', 'l'}
print(set({'username': "silence", 'password': "<PASSWORD>"}))
#{'password', 'username'} 还是拿的键值

【四】集合操作

【1】添加元素

# （1）add方法只能接收一个元素不能查过两个
num_set = {1, 2, 3}
num_set.add(999)
print(num_set)    #{1, 2, 3, 999}
num_set.add(999,66666)
print(num_set)      #Errornum_set = {1, 2, 3}    
num_set.update([1, 2, 3, 4])  #{1, 2, 3, 4}
num_set.update((4, 5, 6))   {1, 2, 3, 4, 5, 6}
print(num_set)num_set = {1, 2, 3}
num_set.update({'username': "silence"})
print(num_set)   #{1, 2, 3, 'username'}还是获取的键值#了解就行
# 把注册过的用户名全部扔到集合中    
# 利用集合的去重性判断当前用户是否注册过
username_tuple = {'slience', 'opp'}
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)   #Error# discard 删除不存在的元素不会报错
num_set.discard(999)  #不会报错，并且还有返回值{1, 2, 3}
# pop 在其他数据类型可以指定参数，但是在集合中不能指定参数
num_set.pop()
print(num_set)

【五】集合的运算

【1】交并差补

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

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}

补集：在整体内除去自己有的

A = {1, 2, 3, 4, 5}
B = {3, 4}
# 使用差集操作获取补集
A_complement = A - B
print(A_complement)

集合是否相等

set1 = {1, 2, 3, 4, 5}
set2 = {2, 4}# 判断两个集合是否相等
is_equal = set1 == set2
print(is_equal)
# 输出: False

集合列表转换

l_old = ['a', 'b', 1, 'a', 'a']
s = set(l_old)  # 将列表转成了集合
print(s)
# {'b', 'a', 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'}
]
'''

【六】计算长度 len()

计算集合长度set1 = {1, 2, 3, 4, 5}
length = len('uset1')
print(length)   # 5

【七】支持遍历

my_set = {1, 2, 3, 'a', 'b'}# 遍历集合for item in my_set:print(item)
#1
#2
#3
#a
#b

【八】支持成员运算

[1] in

my_set = {1, 2, 3, 'a', 'b'}
is_in_set = 'a' in my_set
print(is_in_set)
# 输出: True

[2] not in

my_set = {1, 2, 3, 'a', 'b'}
is_not_in_set = 6 not in my_set
print(is_not_in_set)
# 输出: True

4 数据类型总结

【一】按存值个数区分

• 只能存一个值：可称为标量/原子类型
  • 数字类型，字符串
• 可以存放多个值：可称为容器类型
  • 列表，元组，字典

【2】按照访问方式区分

• 直接访问：只能通过变量名访问整个值
  • 数字类型
• 顺序访问：可以通过索引访问指定的值，索引代表顺序，又称为序列类型
  • 字符串，列表，元组
• key访问：可以用key访问指定的值，又称为映射类型
  • 字典

【3】按可变不可变区分

• 可变类型
  • 列表，字典
• 不可变类型
  • 数字，字符串，元组

【4】可迭代与不可迭代

• 可迭代就是可以被for遍历
  • 元组，集合 、列表，字典，字符串
• 不可迭代
  • 数字、布尔