数据类型及常用方法

阅读目录

　　一、引子

　　二、数字

　　三、字符串

　　四、列表

　　五、元祖

　　六、字典

　　七、集合

　　八、数据类型总结

　　九、运算符

　　十、字符编码

　　十一、文件处理

　　十二、作业

　　# 一 引子

　　　1 什么是数据？

　　　　　x=10，10是我们要存储的数据

　　　2 为何数据要分不同的类型

　　　　数据是用来表示状态的，不同的状态就应该用不同的类型的数据去表示

　　   3 数据类型

　　　　数字（整形，长整形，浮点型，复数）

　　　　字符串

　　　　字节串：在介绍字符编码时介绍字节bytes类型

　　　　列表

　　　　元组

　　　　字典

　　　　集合

　　4 按照以下几个点展开数据类型的学习

#======================================基本使用======================================
#1、用途

#2、定义方式

#3、常用操作+内置的方法

#======================================该类型总结====================================
#存一个值or存多个值
    
#有序or无序

#可变or不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）

　　

　　二、数字
　　整形与浮点型

# 整形(int)

# ======================================基本使用======================================
# 1、用途:存储手机号，请求号，身份证号

# 2、定义方式
# age = 18  # 在内存中开辟一个新的名称空间 将18存入名称空间
# 本质：是age = int(18)
# s = '1.11'
# res = int(s)
# print(res)
# s = '123'
# res = int(s)
# print(res)  #
# l = 'jasonascd123'  # 结论：int只能转存数字的字符串，float小数点也不可以进行转换
# p = int(l)
# print(p)  # ValueError: invalid literal for int() with base 10: 'jasonascd123'

# 3、常用操作+内置的方法


# ======================================该类型总结====================================
# 整形和浮点型存一个值
# 有序

# 不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
"""
可变类型：值变，id不变，说明改的是原值
不可变类型：值改变，id变说明是重新开辟一个新的内存空间
"""

# 浮点型
# 作用：salary = 1.11 # 本质salary = float(1.11)
res = float('1.12345')
print(res,type(res))
# 1.12345 <class 'float'>

　

　#二进制，十进制，八进制，十六进制  之间的转换

# 进制转换：
# 其他进制转换10进制
# 1，二进制转换十进制 0,1
# 10  # 1*(2**1) + 0*(2**0) >>>2
# 110  # 1*(2**2) + 1*(2**1) + 0*(2**0) >>>6

# 2.八进制转换十进制 0,7 》》表示最大值 长度不限
# 121: # 1*(8**2) + 2*(8**1) + 1*(8**0)  >>>81

# 3.十六进制转换10进制 0-9 A-F
# 216 # 2*(16**2) + 1*(16**1) + 6*(16**0)
# print(int('1100', 2))  #  二进制转换10进制
# 1*(2**3)+1*(2**2)
# print(int('14', 8))
# 1*(8**1) + 4
# print(int('c',16))  # 0-9 A-F

　　

# 10进制转其他进制的内置方法

# 10进制转其他进制的内置方法
# 1.>>>10进制转二进制
print(bin(12))  # 0b1100  0b表示的是后面的数字是二进制数

# 2.>>>10进制转八进制
print(oct(12))  # 0o14   #0o表示的四后面的数字是二进制数

# 2.>>>10进制转换16进制
print(hex(12))  #  # 0xc  0x表示后面的数字是十六进制

　　#三、 字符串

# 字符串

# ======================================基本使用======================================
# 1、用途：用来描述事物的内容

# 2、定义方式：单引号 双引号 三引号

# 3、常用操作+内置的方法

# 1.按索引取值（正向取 和反向取值）：只能取
s = 'my baby'
print(s[1])

# 2.切片
# print(len(s))
# print(s[0:6:1])  # my bab 字符串索引切片骨头套不顾尾
# print(s[0:-1])  # my bab
# print(s[0:6:2])  # 步长为2，步长默认为1 这里相当于每隔一个取一个值
#

# 了解负数取值
# print(s[-1])  # 取最后一个
# print(s[0:6:-2])  # 这是自相矛盾 0:6默认从左往右 -2从后往前相反了

# print(s[::-1])  # 倒序ybab ym
# print(s[6:0:-1])  # ybab y 顾头不顾尾 不能写成[0:6:-2] 
# print(s[-1:-6:-1])

# 、len():统计的是字符串的个数 包含空格
# print(len(s))  # 7


# 4.成员运算in或not in 》》判断一个子字符串是在存在于一个大的字符串中
# print('my' in 'my baby ')  # True
# print('a' in 'my baby')  # True
# print('koko' in 'my baby')  # False
# print('coco' not in 'my baby')  # True

# 5.去除空格strip() ,lstrip(),rstrip()

# name = '     $$$$@##$$jason#@￥￥￥  '
# print(name.strip())
# print(name.lstrip())
# print(name)
# print(name.strip())
# print(name)
# name = '$$$@$$jason$$%$$$'
# print(name.strip(' $@#￥'))  # 取空格和特殊字符直接输入就可以了
# print(name.lstrip('$'))  # 单一符号 删除左边
# print(name.rstrip('$'))  #  遇到其他符号直接停至删除右边，
#


# 6. split切分：针对某个分割符号将字符串进行切分，最终切分的是列表,用来切分的符号会被去除
# l = 'jason|123|password|money'
# res = l.split('|')  # ['jason', '123', 'password', 'money']
# print(res)
#
# res1 = l.split('o',2)  # 因为切割的顺序是从左到右2是可以将制定切分个数
# print(res1)
# res2 =l.rsplit('o',1)
# print(res2)  # rspilt是将字符串从左边切


# 7.循环
# for i in enumerate(l):  # 枚举(0, 'j') 第一个是索引 第二个是对应的元素
#     print(i)

# ======================================该类型总结====================================
# 存一个值

# 有序:可以索引取值都是有序类型

# 不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）

　　# 需要掌握的

# 需要掌握的
#1、strip,lstrip,rstrip  # 去除空格和特殊字符
#2、lower,upper

name = 'My loNe baBy'
res = name.lower()  # 全部变成小写my lone baby
print(res)
res1 = name.upper()  # 全部转为为小写MY LONE BAB
print(res1)


#3、startswith,endswith  # 以什么开头/以什么结尾一般是用来判断
l = 'jason is alxxoo'
print(l.startswith('jason'))  # True和False
print(l.endswith('p'))  # False 一个单字符或多个字符串



#4、format的三种玩法

# 1.按照位置站位 和%s 原理一样
# str1 = 'my name is {},my age is {}'.format('jason',18)
# print(str1)  # my name is jason,my age is 18 位置没有指定可以调换

# 2.按照索引进行传值
# str2 = 'my name is {0},my{1} age is {1}'.format('jason',18)
# print(str2)  # 想放哪就放哪 my name is jason,my18 age is 18


# 3.关键字传参(指名道姓)
# str3 = 'my name is {name},my age is {age}'.format(name='jason',age=18)
# print(str3)  # my name is jason,my age is 18 {必须指定关键字}


#5、split,rsplit
#6、join
# data = ['123','a','b','p']  # 容器里面必须是同一类型才可以进行拼接
# res = '@'.join(data)
# print(res)  # 123@a@b@p 将容器类型中的多个元素通过指定的符号拼接成字符串
# res1 = '|'.join(data)
# print(res1)  # 123|a|b|p

#7、replace 替换
# name = 'egon is very good'
# res = name.replace('egon','jason',1)
# print(res)  # jason is very good



#8、isdigit # 判断字符串中包含的是否为存数字
# while True:
#     pwd = input('》》》:').strip()
#     if pwd.isdigit():
#         pwd = int(pwd)
#         print('yes')
#         break
#     else:
#         print('不是数字')
#

 

　

# 需要了解的内置方法

#1、find,rfind,index,rindex,count


# name = 'egon is vTry gPod'
# print(name.find('egon'))  # 返回的是第一个第一个字符所在的索引
# print(name.find('en'))  # -1
# #
# rs = name.capitalize()
# print(rs)

# print(name.rfind('o'))  # 从边开始找第一'o'的索引15
# print(name.find('e',1,3))  # -1 e的索引为0 不在不会报错-1
# print(name.index('n',0,3))  # -1 顾头不顾尾
# print(name.index('P'))  # 区分大小写

# p = '天空飘过天天一朵乌云'
# print(p.replace('云','云朵'))  # 替换
#
# print(p.count('天'))  # 统计出现的个数



#2、center,ljust,rjust,zfill



# name = 'jason'
# print(name.center(11,'*'))  # 第一个参数是表示总的字符长度，第二个是用什么符号进行补全
#
# print(name.ljust(13,'$'))  # z总字符数13右侧进行补全



#4、captalize,swapcase,title
name = 'egon is vTry gPod'
res = name.capitalize()
print(res)  # Egon is vtry gpod # 首字母大写其余全部转成小写
res3 = name.swapcase()
print(res3)  # EGON IS VtRY GpOD 大小写互换
res4 = name.title()  # Egon Is Vtry Gpod 每个单词的首字母大写
print(res4)

#5、is数字系列
num1=b'4' #bytes
num2=u'4' #unicode,python3中无需加u就是unicode
num3='壹' #中文数字
num4='Ⅳ' #罗马数字
# ''.isnumeric(): unicode,中文数字，罗马数字    只要是表示数字都识别
print(num2.isnumeric())
print(num3.isnumeric())
print(num4.isnumeric())

# ''.isdecimal(): unicode   只识别普通的阿拉伯数字
print(num2.isdecimal())
print(num3.isdecimal())
print(num4.isdecimal())

# ''.isdigit() :bytes,unicode    通常情况下使用isdigit就已经满足需求了
print(num1.isdigit())
print(num2.isdigit())
print(num3.isdigit())
print(num4.isdigit())

 

# 写代码,有如下变量,请按照要求实现每个功能 （共6分，每小题各0.5分）
name = " aleX"
# 1)    移除 name 变量对应的值两边的空格,并输出处理结果
# 2)    判断 name 变量对应的值是否以 "al" 开头,并输出结果

# 3)    判断 name 变量对应的值是否以 "X" 结尾,并输出结果

# 4)    将 name 变量对应的值中的 “l” 替换为 “p”,并输出结果
# 5)    将 name 变量对应的值根据 “l” 分割,并输出结果。
# 6)    将 name 变量对应的值变大写,并输出结果

# 7)    将 name 变量对应的值变小写,并输出结果

# 8)    请输出 name 变量对应的值的第 2 个字符?
# 9)    请输出 name 变量对应的值的前 3 个字符?
# 10)    请输出 name 变量对应的值的后 2 个字符?

# 11)    请输出 name 变量对应的值中 “e” 所在索引位置?

# 12)    获取子序列,去掉最后一个字符。如: oldboy 则获取 oldbo。

 

# 写代码,有如下变量,请按照要求实现每个功能 （共6分，每小题各0.5分）
name = " aleX"
# 1)    移除 name 变量对应的值两边的空格,并输出处理结果
print(name.strip())

# 2)    判断 name 变量对应的值是否以 "al" 开头,并输出结果

print(name.startswith('al'))  # False 有空格也是字符

# 3)    判断 name 变量对应的值是否以 "X" 结尾,并输出结果

print(name.endswith('X'))  # True

# 4)    将 name 变量对应的值中的 “l” 替换为 “p”,并输出结果
print(name.replace('l','p'))  # 结果：apeX

# 5)    将 name 变量对应的值根据 “l” 分割,并输出结果。
res = name.split('l')
print(res)  # [' a', 'eX'] l去除返回的是列表 元素间逗号隔开

# 6)    将 name 变量对应的值变大写,并输出结果

res1 = name.upper()
print(res1)  #  ALEX


# 7)    将 name 变量对应的值变小写,并输出结果

res2 = name.lower()
print(res2)  # alex

# 8)    请输出 name 变量对应的值的第 2 个字符?
print(name[1])

# 9)    请输出 name 变量对应的值的前 3 个字符?
print(name[0:3])

# 10)    请输出 name 变量对应的值的后 2 个字符?

print(name[-2:])  # eX
# 11)    请输出 name 变量对应的值中 “e” 所在索引位置?

print(name.find('e'))  # 3
# 12)    获取子序列,去掉最后一个字符。如: oldboy 则获取 oldbo。
print(name[0:-1])

View Code

 

#四、 列表：list

# ======================================基本使用======================================
# 1、用途:作用是可以存储多个值

# 2、定义方式 ：[] 中括号内元素用逗号隔开，元素可以是任意类型
# 本质是 name = list({'name':'jason','age':18})
# l = list({'name': 'jason', 'age': 18})
# print(l)  # ['name', 'age'] 内部是将for循环取值，然后一个个塞到列表中
# 3、常用操作+内置的方法
# 优先掌握的方法
# 1.#1、按索引存取值(正向存取+反向存取)：即可存也可以取

l = [1,2,3,4,5]
print(l[0])  #
print(l[1])  #
print(l[3])  #
print(l[::-1])  # 倒序 反向取值
print(l[-1])  # 5
print(l[0:4:2])  # [1, 3]  #顾头不顾尾 步长是默认值唯一

# 2.切片顾头不顾尾

# 3.添加容器类型数据

 # append

# 1.尾部添加一666元素
# p.append(66)  # 没有返回值 改的是原值
# print(p)  # [11, 22, 33, 44, 55, 66]直接添加元素


# 2.尾部添加[88,99,00]
# p.append([88,99,69])  # 么有返回值 不要用变量去接 添加后直接
# print(p)  # [11, 22, 33, 44, 55, [88, 99, 69]] 是将整个列表作为一个元素添加

# extend # 容器类型

# extend # 容器类型
l.extend([11,22,33])  # 添加的必须是容器类型
print(l)  # [1, 2, 3, 4, 5, 11, 22, 33]

#  insert

# 3.任意位置添加元素

# l.insert(2,123)  # 索引位置 和插入对象
print(l)  # [1, 2, 123, 3, 4, 5] 在索引2的位置
l.insert(-2,8)  # [1, 2, 3, 8, 4, 5] 支持负数添加
# l.insert(len(l),7)  # [1, 2, 3, 4, 5, 7] 末尾添加
print(l)

# 3.长度
len(l) 


# 4.成员运算in/ not in

res = 11 in p  # True
print(22 not in p)  # False
print(res)

# 5.删除 remove
切记没有返回值


del(l[2])  # 指定索引
print(l)

p = [11,22,33,44,55] 

p.remove(55)  # 直接删除元素
print(p)  # [11, 22, 33, 44]

res= l.pop(2) # 索引删除 print(res)
热水 = l.pop()不指定索引者默认尾部删除
# ======================================该类型总结==================================== # 
list可以存多个值 # 有序 # 可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）

 补充：算是字符串的拼接

#6、join
data = ['123','a','b','p']  # 容器里面必须是同一类型才可以进行拼接
res = '@'.join(data)
print(res)  # 123@a@b@p 将容器类型中的多个元素通过指定的符号拼接成字符串
res1 = '|'.join(data)
print(res1,type(data),type(res1))  # 123|a|b|p <class 'list'> <class 'str'>

. 有列表data=['alex',49,[1900,3,18]]，分别取出列表中的名字，年龄，出生的年，月，日赋值给不同的变量

2. 用列表模拟队列

3. 用列表模拟堆栈

4. 有如下列表，请按照年龄排序（涉及到匿名函数）
l=[
    {'name':'alex','age':84},
    {'name':'oldboy','age':73},
    {'name':'egon','age':18},
]
答案：
l.sort(key=lambda item:item['age'])
print(l)

 

# 队列
# l = [1,2]
# l.extend([11,22,33])
# print(l)  # [1, 2, 11, 22, 33]
for i in l:
    print(i)  # 先进先出
l.pop(0)
l.pop(1)
l.pop(2)


# 堆栈 先进后出
print(l.pop())
print(l.pop())
print(l.pop())

 

　#五、 元祖

#作用：存多个值，对比列表来说，元组不可变（是可以当做字典的key的），主要是用来读

#定义：与列表类型比，只不过[]换成()
age=(11,22,33,44,55)本质age=tuple((11,22,33,44,55))
循环一个一个丢到tuple这个

容器进行存储

#优先掌握的操作：
#1、按索引取值(正向取+反向取)：只能取   
#2、切片(顾头不顾尾，步长)
#3、长度
#4、成员运算in和not in

#5、循环

# 作用：能够存储多个元素，元素与元素之间用逗号隔开，里面元素可以是任意类型，元祖不能被修改


# 定义：与列表相比，其实将[]换成了()
# 内部存储本质 tuple1 = tuple((1,2,3,['q',11,44])) 将tuple1进行循环一个个存入tuple1中

# 1、按索引取值(正向取+反向取)：只能取
print(tuple1[0])  #
print(tuple1[1])
print(tuple1[-1])  # [1, 2, 3] 可以取到最后一个
print(tuple1[-2])

# 2、切片(顾头不顾尾，步长)
print(tuple1[0:4:1])  # (1, 2, 34, 'abd') 正向取值顾头不顾尾 也就是最后一个取不到
print(tuple1[::-1])  # 倒序
print(tuple1[4:0:-2])  # 注意倒序是方向要一致从索引4的位置开始往0回走 默认步长为1 这是每隔一个取一个

# 3、长度
# print(len(tuple1))  # 元素的个数5
# 4、成员运算in和not in
# print('abd' in tuple1)  # True
# print(34 not in tuple1)  # False
# 5.修改
# tuple1 = (1, 2, 34, 'abd', [1, 2, 3])
# tuple1[-1][0] = '1让改了'  # 可将内部内部容器进行添加或修改或者删除
# print(tuple1)  # 》》》(1, 2, 34, 'abd', ['1让改了', 2, 3])
# 添加
# tuple1[-1].append(666)
# print(tuple1)
tuple1[-1].pop(2)  # (1, 2, 34, 'abd', [1, 2])通过索引拿到内部的列表进行list操作
print(tuple1)
# 6、循环
# for i in tuple1:
#     print(i)  # 1 2 34 abd [1, 2, 3] 取出来是每一个值

# 7.注意细节：
t2 = list([1, ])
print(t2, type(t2))
# [1] <class 'list'>
t1 = tuple((1,))
print(t1, type(t1))  # TypeError: 'int' object is not iterable:
# (1,) <class 'tuple'>

# 注意:在定义容易类型的时候，哪怕只有一个元素也要用逗号隔开 >>>区分这是容器类型

"""
小结：
作用：存多个值
是否有序：通过索引取值 有序
可变还是不可变：不可变
应用场景：重要的数据只能看不能进行修改

"""

 

#简单购物车,要求如下：
实现打印商品详细信息，用户输入商品名和购买个数，则将商品名，价格，购买个数加入购物列表，如果输入为空或其他非法输入则要求用户重新输入　　

msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
} 

 

　# 六、字典

# 字典：
# 作用：能偶偶存储多组数据，key对value具有描述性作用，取值用dic[key]拿到对应的值
# 注意：字典中的key是不能重复的，要标识唯一一条数据，如果重复只按照最后一条进行存储

# 优先掌握的操作：
# 1，按key存取：既可以存也可以取值

# my_dic = {'name':'jason','age':18,'pwd':'123'}
# 》》》取
# print(my_dic['name'])  # jason
# print(my_dic['age'])  # 18
# print(my_dic['pwd'])  # 123
# 》》》存
# my_dic['money'] = 1000  # {'name': 'jason', 'age': 18, 'pwd': '123', 'money': 1000}
# print(my_dic)  # 赋值语句当字典key不存在的是，自动添加一组新的健值对

# 2、len()
# print(len(my_dic))  # 3 >>>统计的是键值对的个数

# 3.成员运算in /not in 》》》对于字典来说判断是的字典的key(唯一性和value是不会暴露给外界开的：通过取值)
# print('name' in my_dic)  # True
# print('age' in my_dic)  # True
# print('xxx' in my_dic)  # False

# 4.删除
# my_dic = {'name':'jason','age':18,'pwd':'123'}
# 1.》》》删除整个字典
# del my_dic
# print(my_dic)  # NameError: name 'my_dic' is not defined >>>已删除

# 2.》》》删除单个key
# del my_dic['name']
# print(my_dic)  # {'age': 18, 'pwd': '123'} 可以删除指定的key

# 3.》》》pop
# res = my_dic.pop('name')  # key一一对应
# print(res)  # jason 按照指定的key删除(弹出)返回的对应的value值

# res1 = my_dic.pop('age')
# print(res1)  # 18
# print(my_dic)  # {'name': 'jason', 'pwd': '123'} age已删除

# 4.clear
# my_dic.clear()
# print(my_dic)  # {} q清除所有的key:value 内存空间还在
#

# 4.定义字典的三种方式()
# 1、掌握自定义
# dic = {'name':'jason','age':18}

# 2、实例化化对象创建字典
# dic1 = dict(name='jason', age=16, pwd='123')
# print(type(dic1),dic1)  # <class 'dict'> {'name': 'jason', 'age': 16, 'pwd': '123'}

# 3、列表解压赋值
# my_dic = {}
# list_info = [['name','jason'],['age',18],['hobby','read']]
# for i in list_info:
# for key,value in list_info:

    # print(i)  # ['name', 'jason']
    # print(key,value)  # name jason
    # my_dic[i[0]] = i[1]  # {'name': 'jason', 'age': 18, 'hobby': 'read'} 字典的赋值
#     my_dic[key] = value  # {'name': 'jason', 'age': 18, 'hobby': 'read'}
# print(my_dic)

# my_dic = {'name': 'jason', 'age': 18, 'hobby': 'read'}
# 5、keys(),values(),items()
# for i in my_dic:
#     print(my_dic)  # 拿到是key
#     print(my_dic[i])  # 循环通过key得到value

# >>>keys()
# for i in my_dic.keys():
    # print(i,end=' ')  # name仅仅是拿到key name age hobby

# print(my_dic.keys())  # dict_keys(['name', 'age', 'hobby']) 老母猪

# >>>values()
# for i in my_dic.values():
    # print(i)  # jason 拿到具体的值
# print(my_dic.values())  # dict_values(['jason', 18, 'read']) 老母猪

# >>>items()
# for i in my_dic.items():
#     print(i)  # ('name', 'jason')
# print(my_dic.items())  # dict_items([('name', 'jason'), ('age', 18), ('hobby', 'read')])
# 得到的列表套元祖，元祖第一个参数的是字典的key：第二参数是字典的values

# 6.内置方法：
# my_dic = {'name': 'jason', 'age': 18, 'hobby': 'read'}
# 1.get()取值 拿到value 他有两个参数 参数：当字典有这个key 则会返回对应的value,没有的话可以自定义返回内容，不写的返回None
# print(my_dic.get('age','自定义返回值'))  # 没有才会触发

# 2.fromkeys

# l = ['age','money','pwd']
# res_dic = dict.fromkeys(l,123)  # 返回值
# print(res_dic)  # 注意两个参数第一个可迭代容器类型对象，第二个参数是可以自定义（None）后期通过dict[key]改
res_dic = {'age': 123, 'money': 123, 'pwd': 123}
# 3.
res1 = res_dic.setdefault('name','jason')
res2 = res_dic.setdefault('age',18)

print(res1)
print(res2)
# 4.update()
# d1 = res_dic.update(name=666)  # 无则添加
res_dic.update(age='jason')  # 有则改值更新
print(res_dic)

# 4.popitem()
res = res_dic.popitem()
print(res)  # ('name','jason')返回的是删除的键值对弹出


# 7.循环for


# 小结：
"""
存多个值
无序
可变类型

"""

 

1 有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中

即： {'k1': 大于66的所有值, 'k2': 小于66的所有值}

 

2 统计s='hello alex alex say hello sb sb'中每个单词的个数

结果如：{'hello': 2, 'alex': 2, 'say': 1, 'sb': 2}

  七、集合

#作用：去重，关系运算，
#定义集合:
            集合：可以包含多个元素，用逗号分割，
            集合的元素遵循三个原则：
             1：每个元素必须是不可变类型(可hash，可作为字典的key)
             2:没有重复的元素
             3：无序

注意集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值
 

# 优先掌握的操作：
# 1、长度len
# s = {1,2,3,4}
# print(len(s))
# 2、成员运算in和not in
# print(1 in s)  # True

# 3、|合集:所有人 自动去重

# 4、&交集：共同好友，都报了两门课程

# 5、-差集  >>>是只报了其中一门
# 6、^对称差集  # 都没有
# 7、==
# s1 = {1,3,5,7,9}
# s2 = {3,5,7,9,1}
# print(s1 == s2)  # True 集合无序



# 8、父集：>,>=

s1 = {1, 3,5, 7, 9}
s2 ={1, 3, 5}
print(s1 >= s2)  # s1是s2的父集True

# 9.集合几个内置方法

# 9.几个内置方法
s = {11,22,33,33,44}
# print(id(s))
# print(type(s))  # <class 'set'>
# s.add(999)
# print(s,id(s))  # 可变类型 {33, 11, 22, 999}
# s.update((110,))  # 添加值的时候需要注意传入的是可迭代对象

# print(s)  # {33, 999, 11, 110, 22}

# print(s)  # 集合去重无序

# s.remove(111)  # 删除集合没有的元素
# print(s)  # {33, 44, 22}
s.discard(11)  # {33, 44, 22}
s.discard(111)  # 删除集合么有的不会报错
print(s)

 

一.关系运算
　　有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
　　pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}
　　linuxs={'wupeiqi','oldboy','gangdan'}
　　1. 求出即报名python又报名linux课程的学员名字集合
　　2. 求出所有报名的学生名字集合
　　3. 求出只报名python课程的学员名字
　　4. 求出没有同时这两门课程的学员名字集合

pythons = {'alex','tank','koko','wupeiqi','jason','biubiu','egon'}
linuxs = {'wupeiqi','oldboy','jason','egon'}
# 1. 求出即报名python又报名linux课程的学员名字集合

# 方法一：for循环每一个值 然后进行成员运算 对比 都在的打印出来
for name in pythons:
    if name in linuxs:
        print(name,end=' ')  # jason wupeiqi egon 集合无序 >>>无索引


# 方法二：利用集合的特殊内方法
res = pythons & linuxs  交集
print(res)  # {'wupeiqi', 'egon', 'jason'}

# 2. 求出所有报名的学生名字集合:集合有自动去重的功能  并集
print(pythons | linuxs)  # {'wupeiqi', 'koko', 'egon', 'oldboy', 'alex', 'jason', 'biubiu', 'tank'}

# 3. 求出只报名python课程的学员名字

res1 = pythons - linuxs 差集
print(res1)  # {'koko', 'tank', 'alex', 'biubiu'}

# 求出只报名linux课程的学员名字
res2 = linuxs - pythons 差集 
print(res2)  # {'oldboy'}

# 4. 求出没有同时这两门课程的学员名字集合
res3 = pythons ^ linuxs # 上尖号 表示对称差集
print(res3)  # {'koko', 'tank', 'oldboy', 'alex', 'biubiu'}

 

　八、数据类型总结

　　1.可以分可变与不可变

　　　　1.可变：值变，id不变  

　　　　2.不可变：值变，id也变 新开辟一个内存空间将值放进行去

　　2.有序或无序

      　　1.有序： 字符串、列表、 元组、

　　　　2.无序：集合、字典,bool.int.float

　　3.取值方式：

　　　　　   索引：字符串、列表、元组

                     key:字典 dic[]key[ 注意是 与get()的区别

　　　　　   直接取：bool.int.float

　　4. 存值：

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

　　　　　  一个：字符串  数据类型，bool

　　

 

 

　　　　

　　　　

转载于:https://www.cnblogs.com/mofujin/p/11129962.html