元组的内置方法

【一】元组的定义

() 在元组的内部，只有一个元素的时候要加逗号 ','

【二】类型强转

转换其他数据类型为元组，整数类型和布尔类型不可以强转

print(tuple([1,2,3]))
# (1, 2, 3)
print(tuple('qwer'))
# ('q', 'w', 'e', 'r')
print(tuple({1,2,3,3}))
# (1, 2, 3)
print(tuple({'1':'2'}))
# ('1',)

【三】索引取值

num_tuple= (1,2,3,4,5,6,7)
print(num_tuple[0])
# 1
num_tuple[0] = 990
报错  不支持根据索引修改指定索引的值

切片 顾头不顾尾
print(num_tuple[0:5])
# (1, 2, 3, 4, 5)

【四】计算元素个数

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

【五】成员运算

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

【六】遍历循环

for i in (1,2,3,4,5)
	print(i)
1
2
3
4
5

for + range 索引取值  顾头不顾尾
for i in range(1,7):
	print(i)
1
2
3
4
5
6

【七】元组拼接

字符串
print('qwer' + '12')
# qwer12

列表  加法运算，得到一个两个列表元素拼到一起的新列表
print([1,23,3] + [1,23,4])
# [1, 23, 3, 1, 23, 4]

元组 得到一个两个元组元素拼到一起的新元组
print((1,2,3) + (1,2,33))
# (1, 2, 3, 1, 2, 33)

【八】*号运算

得到一个新元组
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))
print(bool(1))
print(bool(2))
False
True
True

集合

【一】集合定义

{}每一个元素都是单独的

区分于字典，因为字典是键值对

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

【二】特性

无序性

数字类型的hash值是死的，字符串的hash值会变
都输出三次看输出内容
print({1,2,3,4,3242,13,123})
# {1, 2, 3, 4, 3242, 123, 13}
# {1, 2, 3, 4, 3242, 123, 13}
# {1, 2, 3, 4, 3242, 123, 13}

print({1,2,3,4,'a',3242,'adads',13,123})
# {'a', 1, 2, 3, 4, 3242, 'adads', 13, 123}
# {1, 2, 3, 4, 'adads', 3242, 'a', 13, 123}
# {1, 2, 3, 4, 3242, 13, 'adads', 'a', 123}
当集合内放了字符串，输出时字符串位置不固定

去重性

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

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

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

# 字符串
name = 'qwre'
print(set(name))
# {'w', 'q', 'e', 'r'}
# {'r', 'w', 'q', 'e'}
每次输出都不一样

# 字典  只转换键，且无序
user = {'username' : 'qwer' , 'password' : 'asdawd'}
print(set(user))
# {'password', 'username'}
#转换值 无序
print(set(user.value))
# {'qwer', 'asdawd'}
# {'asdawd', 'qwer'}

【四】集合操作

【1】添加元素

# add方法 只能接收一个元素
num_set = {1,2,3}
num_set.add(1234)
print(num_set)
# {1, 2, 3, 1234}
num_set.add(1234,23)  #输出会报错

# 把注册过的用户全部仍到集合中
# 利用集合的去重性判断当前用户是否注册过

username_tuple = {'qew','qweasd'}
username = input(>>>>>>)
username_tuple.add(username)

【2】删除元素

# remove方法 删除集合中不存在的值时会报错
num_set.remove(3)
print(num_set)
# {1, 2, 1234}
num_set.remove(3)
删除两次报错

# discard方法  删除不存在的元素不会报错
num_set.discard(3)
# None 不报错

#pop 在其他数据类型中可以指定参数，但是在集合中不能指定  会弹出最后一个参数（谁倒霉谁在后）
num_set.pop()
print(num_set.pop())
print(num_set)
# 1
# {2, 1234}  1被随机排到了最后，所以1被弹出了

【五】集合的运算

交集：两集合共有的元素

并集：两个集合去重后的所有元素

补集：大集合A 包含小集合B

​ A中B没有的所有元素叫做B对于A的补集

差集：你有我没有的

判断两集合是否相等

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()
# 【七】支持遍历
# 【八】支持成员运算

【六】计算长度

num_set = {1,2,3}
print(len(num_set))
# 3

【七】支持遍历

去重后输出
num_set = {1,2,3,123,3,4,1,}
for i in num_set:
    print(i)
1
2
3
4
123

【八】支持成员运算

num_set = {1,2,3,123,3,4,1,}
if 2 in num_set:
    print('yes')
# yes

数据类型总结

# 【一】按存储值的个数进行划分
# 存一个： 数字、字符串
# 很多个：列表、元祖、字典

# 【二】按照访问方式分
# 【1】直接访问：数字 布尔
# 【2】按照索引：列表、集合、元组
# 【3】按照关键字：字典 映射类型

# 【三】按照可变和不可变区分
# 【1】不可变
# 字符串、数字、布尔、元组，集合
# 【2】可变
# 列表，字典，

# 【四】可迭代与不可迭代
# 【1】可迭代就是可以被for遍历 元组，集合 、列表，字典，字符串、
# 【2】不可迭代 数字、布尔

区分可变不可变的依据：更改元素过后查看他的ID看是否变化，

若发生变化则为不可变类型，反之为可变数据类型。