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)) #True
print(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) #Error
num_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遍历
- 元组，集合 、列表，字典，字符串
- 不可迭代
- 数字、布尔