一、数字类型
整型 int
1.用途
年龄、生日、整数类型等整数数据
2.定义方式
age = 18 # 等价于 age = int(18)
3.类型转换
'''python中不同数据之间无法直接交互'''
int() 可以将括号内数据转换为整型,但转换的数据只能是纯数字！
print(int(666))
print(int("666")，type(int("666")))
...
out
666
666 <class 'int'>
print(int('[1,2,3,4,5]')) # 报错
print(int('hello world')) # 报错
print((int('66.66')) # 报错
# 待转换的数据内部只能是纯整数数字
4.进制转换
print(bin(100)) # bin()将十进制数转换为二进制数 out>>> 0b1100100
print(oct(100)) # oct()将十进制数转换为八进制数 out>>> 0o144
print(hex(100)) # hex()将十进制数转换位十六进制数 out>>> 0x64
"""
0b开头表示二进制数
0o开头表示八进制数
0x开头表示十六进制数
"""
print(int('0b1100100',2)) # int()将二进制数转换为十进制数，‘2’指二进制数
print(int('0o144',8)) # int()将八进制数转换为十进制数，‘8’指八进制数
print(int('0x64',16)) # int()将十六进制数转换为十进制数，‘16’指十六进制数
...
out
100
100
100
浮点型 float
1.用途
身高、体重、薪资等带有小数点的数字数据
2.定义方式
weight = 66.6 # 等价于 weight = float(66.6)
在纯数字基础上，多一个小数点
3.类型转换
float()同int()类型一样，能将括号内数据转换为浮点,但转换的数据只能是纯数字！
print(float(996.5))
print(float('996.5')，type(float('996.5')))
...
out
996.5
996.5 <class 'float'>
print(float('hello world')) # 报错
4.拓展：整型int()与浮点型float()能够相互转化
print(float(666)) # out>>> 666.0
print(int(996.55)) # out>>> 996 浮点型转整型时，只取小数点前的整数
print(int('11.11')) # out>>> 11
二、字符串类型str
1.用途
名字、国际、性别、地址等描述性信息
2.类型定义：一串字符在单引号/双引号/三双引号/三单引号内组成
name = 'hello world!'
3.类型转换
'''可以将任何数据类型转换为字符串类型'''
print(str(18),type(str(18)))
print(str(11.11),type(str(11.11)))
print(str('hello'),type(str('hello')))
print(str([1,2,3,4]),type(str([1,2,3,4])))
print(str({'name':'jason'}),type(str({'name':'jason'})))
print(str(True),type(str(True)))
...
out
18 <class 'str'>
11.11 <class 'str'>
hello <class 'str'>
[1, 2, 3, 4] <class 'str'>
{'name': 'jason'} <class 'str'>
True <class 'str'>
4.内置方法
1)索引取值（只能取值）
name = 'hello world!'
# 正向取
print(name[0])
print(name[6])
...
out
h
w
# 反向取
print(name[-1]) # -1表示最右一个元素
print(name[-5])
...
out
!
O
# 取值方向：正数取值从左向右，从0号位开始；负数取值从右向左，从-1号位开始。
# 注：只能取不能改，字符串中的空格和符号都算字符
2)切片(顾头不顾尾)
'''截取一段内容'''
书写格式:[起始索引:终止索引:步长]
name = 'hello world!'
print(name[1:4]) # 顾头不顾尾 out>>> 1 2 3
print(name[-1:-5:-1]) # 默认的切片方向都是从左往右，-1 则可修改成从右往左， out>>> !dlr
print(name[1:4:2]) # 第三个参数2 表示步长，即间隔一个参数取值， out>>> el
"""
总结：当步长位数字为正，根据步长并以默认方向取值
当步长位数字为负，则改变默认方向并根据步长取值
"""
3)读取字符串长度 len()
'''统计字符串里面的字符个数'''
name = 'hello world!'
print(len(name)) # 空格和符号都算字符
...
out
12
4)成员运算in和not in
name = 'hello world!'
print('hello' in name)
print('richer' not in name)
...
out
True
True
5)移除字符串首尾指定字符.strip()、.lstrip()、.rstrip()
# 移除指定的首尾字符.strip()
print(" richer ".strip()) # 移除首尾空格 out>>> "richer"
username = input('username>>>:').strip() # 移除用户输入时的首尾空格
print(username)
...
out
username>>>: richer
richer
lastname = '$$$ri$ch$er%$$'
print(lastname.strip('$')) # 移除指定首、尾的所有字符 $，但中间的$无法移除，只移除首尾
...
out
ri$ch$er%
# 移除首指定的字符.lstrip()
name = '***##lili**'
print(name.lstrip('*')) # 移除首*， out>>> ##lili**
print(name.lstrip('#')) # #在内不在首，不移除， out>>> ***##lili**
# 移除尾指定的字符.rstrip()
name = '+++kaka+++--- '
print(name.rstrip('-')) # 尾部为空格，-不移除， out>>> +++kaka+++---
print(name.rstrip()) # 默认移除尾部所有空格，out>>> +++kaka+++---
6)切分.split()、.rsplit()
res = 'name|age|bday'
print(res.split('|'))
name = '张三*李四*王麻子'
print(name.split('*'))
...
out
['name', 'age', 'bday']
['张三', '李四', '王麻子']
# 总结：a.指定切割的字符不保留，此处为'|'和'*'，且元素之间用逗号隔开；
b.切割之后的数据类型是一个列表！
name = '张三*李四*王麻子*金蛋*银蛋*驴粪蛋*张全蛋'
print(name.split('*',maxsplit=2)) # 从左往右切割指定次数
...
out
['张三', '李四', '王麻子*金蛋*银蛋*驴粪蛋']
# .rspilt()
print(name.rsplit('*',maxsplit=4)) # 从右往左切割指定次数
...
out
['张三*李四', '王麻子', '金蛋', '银蛋', '驴粪蛋']
7)循环
name = '张三李四'
for i in name:
print(i) # 依次获取字符串中的单个字符
...
out
张
三
李
四
8)字母的大小写转换.upper()、.lower()、.title()、.capitalize()
msg = 'my NaMe Is RIcher 996'
print(msg.upper()) # 将所有的英文字母转成大写 out>>> MY NAME IS RICHER 996
print(msg.lower()) # 将所有的英文字母转成小写 out>>> my name is richer 996
print(msg.title()) # 将所有单词首字母大写，单词剩余字母改为小写 out>>> My Name Is Richer 996
print(msg.capitalize()) # 句子首字母大写 后面统一变小写 out>>> My name is richer 996
"""实际案例中，遇到图片验证码校验，忽略大小写就可用到.upper()、.lower()"""
code = 'NaRTs6'
my_code = input('code>>>:')
if code.lower() == my_code.lower():
print('验证码正确')
...
out
code>>> narts6
验证码正确
9)判断.isupper()、.islower()、.startswith()、.endswith()、.isdigit、.isalpha()...
msg = 'my NaMe Is RIcher 996'
print(msg.isupper()) # 判断字符串所有的英文字母是否是大写 out>>> False
print(msg.islower()) # 判断字符串所有的英文字母是否是大写 out>>> False
print(msg.startswith('my')) # 判断字符串是否以'my'开头 out>>> True
print(msg.endswith('996')) # 判断字符串是否以'996'结尾 out>>> True
print(msg.isdigit()) # 判断字符串是否是纯数字 out>>> False
print(msg.isalpha()) # 判断字符串是否是非数字与非特殊符号组成 out>>> False
# 第一种，用法与%s一致，按照个数位置依次传值
res = 'my name is {} my age is {}'
print(res.format('richer',25))
...
out
my name is richer my age is 25
# 第二种，按照索引取值，可以反复取值
res = 'my name is {0} my age is {1} {0} {1} {2}'
print(res.format('richer',25,996))
...
out
my name is richer my age is 25 richer 25 996
# 第三种，通过关键字参数，指名道姓取值，可以反复使用
res = 'my name is {name} my age is {age} {name} {age} '
print(res.format(name='richer',age=25))
...
out
my name is richer my age is 25 richer 25
11)计数.count()
'''统计字符串中，指定字符出现的个数'''
res = '明日复明日，明日何其多。我生待明日，万事成蹉跎' # 一个汉字是一个字符
print(res.count('日')) # out>>> 4
print(res.count('日',1,10)) # 指定范围统计1~10，out>>> 3
12)替换.replace()
res = 'my name is richer richer richer'
# 全局替换，将字符串中所有的richer替换成NB
print(res.replace('richer', 'NB')) # out>>> my name is NB NB NB
# 局部替换，可以限制替换的个数，从左往右，将第一个richer替换成NB
print(res.replace('richer', 'NB', 1)) # out>>> my name is NB richer richer
13)拼接.jion()
'''能将列表多个元素拼接成字符串'''
res = ['lili','kaka','mimi','qiqi']
res1 = ['lili','kaka','mimi','qiqi',123]
# 可以用指定字符将列表中字符串拼接，与.split()用法刚好相反
print('*'.join(res)) # out>>> lili*kaka*mimi*qiqi
print('|'.join(res1)) # 报错，只能是字符串类型拼接
三、列表类型list
1.用途
储存任意数据类型的集合
2.定义方式
中括号括起来，内部可以存放多个元素，元素与元素之间用逗号隔开，元素可以是任意数据类型
name_list = ['kaka','lili','mimi'] # 等价于name_list = list(['kaka','lili','mimi'])
3.类型转换
print(type(list(18))) # 报错
print(type(list(11.11))) # 报错
print(type(list('hello')),list('hello')) # out>>> <class 'list'> ['h', 'e', 'l', 'l', 'o']
print(type(list([1,2,3,4]))) # out>>> <class 'list'>
# 针对字典需要注意只有key被转换
print(type(list({'name':'jason'})),list({'name':'jason'})) # <class 'list'> ['name']
print(type(list(True))) # 报错
# 总结：能够支持for循环的数据，都能够被list转换成列表
4.内置方法
1)索引取值
#位号 0 1 2 3
# -4 -3 -2 -1
l = ['richer','jack','liming','tom']
print(l[0]) # 从左往右取 out>>> richer
print(l[-1]) # 从右往左取 out>>> tom
# 只能取，不能改
2)切片
# 书写方式：[起始索引:终止索引:步长]
l = ['richer','jack','liming','tom']
print(l[0:2]) # 同字符串，从左往右顾头不顾尾，默认步长为1，out>>> ['richer', 'jack']
Print(l[0:2:2] # 顾头不顾尾，步长为2，out>>> ['richer']
print(l[-1:-3:-1]) # 从右往左，步长为1，out>>> ['tom', 'liming']
3)len()
'''统计列表中元素的个数'''
l = ['richer','jack','liming','tom']
print(len(l))
...
out
列表元素的CURD(增删改查)
4)增：.append()、.insert()、.estend
# 末尾增加单个元素.append()即将括号内的数据当作列表的一个元素
l = ['richer','jack','liming','tom']
l.append('tony')
print(l)
# l.append([11,22,33,44,55])
# print(l)
...
out
['richer', 'jack', 'liming', 'tom', 'tony']
['richer', 'jack', 'liming', 'tom','[11,22,33,44,55]')
# 指定位置插入列表.insert()也是将括号内的数据当作列表的一个元素
l = ['richer','jack','liming','tom']
l.insert(2,'tony') # 在二号位插入'tony'
print(l)
# l.append([11,22,33,44,55])
# print(l)
...
out
['richer', 'jack', 'tony', 'liming', 'tom']
['richer', 'jack', '[11,22,33,44,55]', 'liming', 'tom']
# 扩展列表，将另一个列表中的元素单个单个增加在目标列表中的末尾.extend()
l = ['richer','jack','liming','tom']
l1 = ['lili','kaka','qiqi']
# for i in l1:
# l.append(i)
# print(l)
# 利用 for+append 等价于 .extend()
l.extend(l1)
print(l)
...
out
['richer', 'jack', 'liming', 'tom', 'lili', 'kaka', 'qiqi']
# ps:也可以通过加号做扩展 但是不推荐
# l3 = [11,22,33]
# l4 = [44,55,66]
# print(l3 + l4) out>>> [11,22,33,44,55,66]
5)删：del、.pop()、.remove()
# 通用删除 del 列表[索引]
l = ['richer','jack','liming','tom']
del l[2]
print[l] # 使用del()语句删除任何位置处的列表元素，删除后的元素无法访问
...
out
['richer', 'jack', 'tom']
# 弹出元素.pop()
# 默认尾部弹出元素
l = ['richer','jack','liming','tom']
res = l.pop()
print(l) # out>>> ['richer','jack','liming']
print(res) # 方法pop()可删除列表末尾的元素，删除后依然能访问删除的值 out>>> 'tom'
# 弹出指定索引位置的元素
l = ['richer','jack','liming','tom']
res = l.pop(1)
print(name_list) # out>>> ['richer','liming','tom']
print(res) # out>>> 'jack'
# 指定元素删除.remove()
# 在不知道列表中删除的值所处的位置，只是删除元素的值，可使用remove()
l = ['richer','jack','liming','tom']
res = l.remove('liming')
print(l) # out>>> ['richer', 'jack', 'tom']
print(res) # 无法访问删除后的值 out>>> None
6)改
# 列表[索引] = 新值
l = ['richer','jack','liming','tom']
l[1] = 'xiaoming' # 按照索引位置修改即可
print(l)
...
out
['richer', 'xiaoming', 'liming', 'tom']
7)查 in、not in、.count()、.index()
l = ['richer','jack','liming','tom']
print('tom' in l)
print('tom' not in l)
...
out
True
False
# 统计列表中某个元素出现的次数.count()
l2 = [11,22,33,3,3,3,2,3,23,4,34,3,4,3,4]
print(l2.count(3))
...
out
6
# 查列表元素的位置.index
print(l.index('tom'))
...
out
3
8)清空列表.clear()
l = ['richer','jack','liming','tom']
l.clear()
print(l)
...
out
[]
9)排序.sort()、.reverse()
l3= [11,88,22,44,33,77,66,55]
# 默认升序
l3.sort()
print(l3)
...
out
[11, 22, 33, 44, 55, 66, 77, 88]
# 降序，利用reverse=True
l3.sort(reverse=True)
print(l3)
...
out
[88, 77, 66, 55, 44, 33, 22, 11]
# 倒序,反转 .reverse()
l3.reverse()
print(l3) # 只是将列表翻转，并没有排序
...
out
[55, 66, 77, 33, 44, 22, 88, 11]
5.练习
# 队列 先近先出
l = [] # 先定义空列表
l.append('first name') # l = ['first name']
l.append('second name') # l = ['first name','second name']
l.append('third name') # l = ['first name','second name','third name']
print(l.pop(0)) # out>>> first name # l = ['second name','third name']
print(1.pop(0)) # out>>> second name # l = ['third name']
print(l.pop(0)) # out>>> third name # l = []
# 堆栈 先进后出
l = [] # 先定义空列表
l.append('first name') # l = ['first name']
l.append('second name') # l = ['first name','second name']
l.append('third name') # l = ['first name','second name','third name']
print(l.pop()) # out>>> third name #l = ['first name','second name']
print(l.pop()) # out>>> second name #l = ['first name']
print(l.pop()) # out>>> first name #l = []
四、字典类型dict
1.用途
需要快速根据某个值，查对应的值，用来传递对象
2.定义方式
大括号括起来，内部可以存放多个元素，元素的表现形式是以K:V键值对形式
K是对V的描述性信息，是不可变类型，有整型 浮点型 字符串
V可以是任意类型
3.内置方法
1)存取值：按key取值、.get()
d1 = {
'username':'richer',
'password':'996',
'hobby':['sing','read']
}
print(d1['username']) # out>>> richer
print(id(d1))
d1['username'] = 'tom'
print(d1['username']) # out>>> tom
print(id[d1]) # v值虽然改变，但地址未发生改变。说明字典是可变类型
print(d1['age]) # 键不存在，直接报错
d1['age'] = 18 # 键存在则修改，不存在但成键值对则新建
print(d1)
...
out
{'username': 'richer', 'password': 996, 'hobby': ['sing','read'], 'age': 18}
# dict.get() 使用频率最为广泛，也是通过字典的key获取字典的value，建议使用此方法取值
print(d1.get('username')) # out>>> 'richer'
print(d1['username']) # out>>> 'richer'
# 与按key取值的区别
# 当key不存在时
print(d1['age']) # 当key不存在时,直接报错
print(d1.get('age')) # .get()方法键不存在也不会报错，返回None(什么都没有)
'''get()方法还可以给第二个参数,键存在则不使用,键不存在则返回第二个参数,不写默认返回None'''
print(d1.get('username','jack')) # out>>> richer
print(d1.get('age','18')) # out>>> 18
2)长度len()
'''统计字典中键值对的个数'''
d1 = {
'username':'richer',
'password':'996',
'hobby':['sing','read']
}
print(len(d1))
...
out
3
3)成员运算in和not in
d1 = {
'username':'richer'
'password':'996'
'hobby':['sing','read']
}
print('richer' in d1) # out>>> False 字典默认只判断key，不判断value，如果想取，一般只能通过key
print('username' in d1) # out>>> True
4)删除del、.pop()
'''字典不能使用索引删除!!!'''
d1 = {
'username':'richer',
'password':'996',
'hobby':['sing','read']
}
# del
del d1['password']
print(d1) # out>>> {'username': 'richer', 'hobby': ['sing','read']}
# .pop() 弹出
res = d1.pop('password')
print(d1) # out>>> {'username': 'richer', 'hobby': ['sing','read']}
print(res) # out>>> 996
5)键.keys()、值.values()、键值对.item()
d1 = {
'username':'richer',
'password':'996',
'hobby':['sing','read']
}
# 将keys()的结果可以直接看成是列表
ptint(d1.keys()) # 获取字典中所有的key
"""
python2与python3对比:
# 和range()一样节省空间，要的时候给你取
python3 out>>> dict_keys(['username', 'password', 'hobby'])
python2 out>>> ['username', 'password', 'hobby']
"""
for k in d1.keys():
print(k)
...
out
username
password
hobby
# 将values()的结果可以直接看成是列表
print(d1.values()) # 获取字典中所有的value
"""
python2与python3对比:
python3 out>>> dict_values(['richer', '996', ['sing', 'read']])
python2 out>>> ['richer', '996', ['sing', 'read']]
"""
for k in d1.values():
print(k)
...
out
richer
996
['sing', 'read']
# 将items()的结果可以直接看成是列表[]套元组()
print(d1.items()) # 获取所有键值对
"""
python2与python3对比:
python3 out>>> # 节省空间机制
dict_items([('username', 'richer'), ('password', '996'), ('hobby', ['sing', 'read'])])
python2 out>>> [('username', 'richer'), ('password', '996'), ('hobby', ['sing', 'read'])]
"""
for k,v in d1.items(): # 解压赋值，结合for循环取值，此处取的是一个个元组()
peint(k,v)
...
out
('username', 'richer')
('password', '996')
('hobby', ['sing', 'read'])
6)for循环
'''字典for循环只能获取到key'''
d1 = {
'username':'richer',
'password':'996',
'hobby':['sing','read']
}
for i in d1:
print(i)
...
out
username
password
hobby
7)清空字典.clear
d1 = {
'username':'richer',
'password':'996',
'hobby':['sing','read']
}
d1.clear
print(d1)
...
out
{}
l = ['username','pwd','hobby']
res = dict.fromkeys(l,None)
print(res)
...
out
{'username': None, 'pwd': None, 'hobby': None}
9)弹出键值对.popitem()
d1 = {
'username':'richer',
'password':'996',
'hobby':['sing','read']
}
res = d1.popitem() # 随机弹出一组键值对
print(d1)
print(res)
...
out
{'username': 'richer', 'password': '996'}
('hobby', ['sing', 'read'])
10)获取key对应的value，.setdefault()
d2 = {'name':'richer','pwd':996}
d2.setdefault('age',18) # 键不存在时，则新建字典，将新键值对放入字典中
print(d2) # out>>> {'name':'richer','pwd':996, 'age': 18}
res = d2.setdefault('name','tom') # 若键存在，不会修改原值。获得键对应的值
print(d2,res) out>>> {'name': 'richer', 'pwd': 996, 'age': 18} richer
11)更新.update()
d2 = {'name':'richer','pwd':123}
d2.update({'age':18}) # 键不存在,则新建
d2.update({'name':'tom'}) # 键存在则修改
print(d2)
# 还不如使用下列方式,简单快捷
d2['age'] = 18
d2['name'] = 'jason'
创建字典的方式
# 第一种，直接创建
d = {'k1':'v1','k2':'v2'} # dict({'k1':'v1','k2':'v2'})
# 第二种，指定关键字
res = dict(name='richer',pwd=996,hobby=['sing','read'])
print(res)
...
out
{'name': 'jason', 'pwd': 123, 'hobby': ['read', 'run']}
# 第三种，建立空字典
l = [
['username':'richer'],
['password':'996'],
['hobby':['sing','read']]
]
d = {} # 建空字典，再利用for循环
for i in l # 遍历子列表
d[i[0]] = i[1] # d['username'] = 'richer'
print(d)
"""或者"""
d = {}
for k,v in l: # 键与值分别对应子列表取值
d[k] = v
print(d)
...
out
{'username': 'ricehr', 'password': 996, 'hobby': ['sing', 'read']}
# 第四种，利用.formkeys(),快速生成字典，然后替换value值
五、元组tuple
1.用途
简化关系名，在处理实际问题时，如果关系的名字很长，使用起来就会感到不方便，这时可以设一个较短名字的元组变量来简化关系
可以当字典的key，主要是用来读
2.定义方式
小括号括起来，括号内可以存放多个元素，元素与元素之间逗号隔开，元素可以是任意类型
元组也可以简单的理解为是列表，同时元组属于不可变类型
t1 = (1,2,3,4,5,6)
print(type(t1)) # out>>> tuple
3.类型转换
# 与list一致，支持for循环的都可以转换为元组，但要注意
"""
元组当内部只有一个元素的时候,逗号不能省略
避免出错，只要是容器类型,无论内部有几个元素，都必须要有逗号
尤其是只有一个元素的情况下
(1,)
[1,]
{'username':'jason',}
"""
t1 = (1)
print(type(t1)) # out>>> int
t2 = ('a')
print(type(t2)) # out>>> str
l1 =（[1])
print(type(l1)) # out>>> list
t1 = (1,)
print(type(t1)) # out>>> tuple
t2 = ('a',)
print(type(t2)) # out>>> tuple
l1 =（[1],)
print(type(l1)) # out>>> tuple
4.内置用法
1)索引取值
'''只能取'''
# 正向取值
t1 = (11,22,33)
print(t1[0]) # out>>> 11
t1[0] = 666
print(t1) # 报错，只能取不能重新赋值
"""
元组内元素的内存地址不能修改,但是如果元素是可变类型 那么元素值可以改
"""
t2 = (11,22,[11,22])
t2[2].append(33)
print(t2)
...
out
(11, 22, [11, 22, 33])
2)切片
# 与字符串、列表一致，顾头不顾尾，书写方式：[起始索引:终止索引:步长]
t3 = (11,22,33,44,55,66,77,88,99)
print(t3[1:6:2])
...
out
(22, 44, 66)
3)长度len
# 与字符串、列表一致，统计元素个数
t3 = (11,22,33,44,55,66,77,88,99)
print(len(t3))
...
out
9
4)成员运算in和not in
t4 = ('richer', 996, [11, 22, 33])
print('11' in t4[2]) # out>>> False 列表中是整型不是字符串
print([11, 22, 33] not in t4) # out>>> False
5)for循环
for i in (11,22,33):
print(i)
...
out
11
22
33
练习题
t = (11,22,[11,22])
t[2].append(33)
print(t)
问:是否报错
六、集合set
1.用途
a.关系运算
两个群体间判断交集并集等，共同好友、共同关注、共同点赞等
b.去重操作
去除重复的元素
2.定义方式
大括号括起来，内部可以存放多个元素，元素与元素之间逗号隔开(不是k:v键值对)，元素只能是不可变类型(整型、浮点型、字符串、 元组)
3.类型转换
s = {1,2,3,4,5} # 等价于 s = set(1,2,3,4,5)
print(type(se)) # out>>>set
# d1 = {}
# s1 = {}
# print(type(d1),type(s1)) # out>>> <class 'dict'> <class 'dict'>
"""定义空集合 需要使用关键字set"""
s = set()
print(ss,type(ss)) # out>>> set
s = {11,1.1,'hello',(1,2,3)}
4.内置方法
1)关系运算
f1 = {'richer','tom','kaer','tony'}
f2 = {'richer','jack','oscar','kaer'}
# 共同好友
print(f1 & f2) # out>>> {'kaer', 'richer'}
# f1独有的好友
print(f1 - f2) # out>>> {'tony', 'tom'}
# f2独有的好友
print(f2 - f1) # out>>> {'jack', 'oscar'}
# 所有的好友
print(f1 | f2) # out>>> {'richer', 'oscar', 'kaer', 'tom', 'tony', 'jack'} "|" 管道符
# 求各自好友 不包含共有的
print(f1 ^ f2) # out>>> {'oscar', 'tony', 'tom', 'jack'}
2)去重运算
l = [11,22,33,22,11,44,33,22,55,66,66,66]
# for循环一个个元素，判断当前元素是否已存在
new_l = []
for i in l:
if i not in new_l: # 如果i不在空列表里面，执行if子代码
new_l.append(i)
print(new_l) # out>>> [11, 22, 33, 44, 55, 66]
# 将列表转换成集合
res = set(l)
print(res) # out>>> {33, 66, 11, 44, 22, 55} 集合是无序的
'''集合内默认不能出现重复的元素 如果出现了会自动去重'''
r1 = {11,22,22,22,11,44,44,44}
print(r1) # out>>> {11, 44, 22}
3)父集，子集
"""
父集:A包含B，那么A就是B的父集
子集:A包含B，那么B就是A的子集
"""
s1 = {1,2,3,4,5}
s2 = {1,2,3}
print(s1 > s2) # out>>> True
print(s1 < s2) # out>>> False
可变不可变
"""
可变类型:列表、字典
值改变 内存地址不变
不可变类型：整型、浮点型、字符串、元组、字典的key
值改变 内存地址一定变
"""
# 不可变类型
a = 1
print(id(a))
a = 2
print(id(a))
# 可变类型
l1 = [11,22]
print(id(l1))
l1.append(666)
print(id(l1))
浙公网安备 33010602011771号