1、前言
不同的数据类型可以记录事物的状态，而事物的状态是不断变化的。
所以我们需要不同的数据类型来频繁的记录某个事物的状态，Python针对这种操作。内置了一些列的方法。本章内容主要讲解各数据类型的定义、以及转换。
2、数字类型之int和float
定义
# 整数的定义
age = 17 # 实质: age = int(17)
# 浮点数的定义
weight = 65.5 # 实质: weight = float(65.5)
'''
PS: 在大多数编程语言中名字+括号，通常是调用某个功能(方法 or 函数)。
比如:
print() # 调用打印功能
input() # 调用输入功能
'''类型转换
# int()函数可以将包含纯数字的字符串转换为int类型。字符串若包含非数字字符，则报错
age = '17'
print(age,type(age))
age = int(age) # 由于int和float类型是不可变数据类型，所以我们需要将int()函数返回的值赋值给age，那么此时age才会是int类型。
print(age,type(age))
# 在Python中小数是不能转换为int类型的,否则会报错
print(int('50.3')) # 错误演示
######################################################################
# float()函数可以将全为数字的字符串。转换为float类型，若字符串中有非数字字符。则报错
salary = '3.3'
print(type(salary)) # <class 'str'>
salary = float(salary)
print(salary,type(salary)) # 3.3 <class 'float'>
# int类型也可以被转换为float类型,但是float类型不能转为float类型
demo = '3'
print(type(demo)) # <class 'str'>
demo = float(demo)
print(demo,type(demo)) # 3.0 <class 'float'>
# 如果一个字符串中包含非数字字符，那么再使用float()函数转换,则会报错。
error_ex = '123a'
# print(float(error_ex)) # 报错示例
# 进制转换
num = 100
# 使用bin()函数可以将其他进制转为二进制
# 在Python中使用0b开头表示二进制
print(bin(num)) # 0b1100100
# 使用bin()函数可以将其他进制转为八进制
# 在Python中使用0o开头表示八进制
print(oct(num)) # 0o144
# 使用hex()函数可以将其他进制转为十六进制
# 在Python中使用0x开头表示十六进制
print(hex(num)) # 0x64
print(hex(0o144)) # 0x64使用
数字类型主要用于数学运算和比较运算。因此数字类型除了与运算符结合使用之外，并无需要掌握的内置方法即可。
3、字符串
定义
# 定义: 在单引号\双引号\三个单引号\三个双引号包裹起来的字符
a = 'helloworld'
b = "x1ong"
c = '''你好世界'''
d = """世界"""
print(a,type(a)) # helloworld <class 'str'>
print(b,type(b)) # x1ong <class 'str'>
print(c,type(c)) # 你好世界 <class 'str'>
print(c,type(d)) # 你好世界 <class 'str'>类型转换
# str()函数可以将任意数据类型修改为字符串类型
a = 123
print(type(a)) # <class 'int'>
a = str(a) #
print(a,type(a)) # 123 <class 'str'>
b = False
print(type(b)) # <class 'bool'>
b = str(b)
print(b,type(b)) # <class 'str'>使用
优先掌握
str1 = 'hello world'
# 按索引取值(正(反)向取值)
######################## 正向取值(从左往右) ########################
print(str1[6]) # 下标是从0开始的，所以6是w。(空格也是一个字符)
######################## 反向取值(从右往左) ########################
print(str1[-1]) # 取字符串中的最后一个字符即d
print(str1[-2]) # 取字符串中的倒数第二个字符,即l
# 对于string类型来说,只能通过索引去取值。并不能通过索引去修改某个值
# str1[0] = "H" # 报错示例
######################## 切片(包含开始不包含结束) ########################
demo = '我爱你,爱着你,就像老鼠爱大米'
# 取出字符串中0-5的所有字符(包含开始不包含结束，所以我们需要设置为0:6)
print(demo[0:6]) # 我爱你,爱着
print(demo[::]) # 我爱你,爱着你,就像老鼠爱大米 取出字符串的所有值
## 切片的步长 0:6:2 第三个参数表示步长,第一个从0开始,之后每次累加一个步长(2)即可
print(demo[0:6:2]) # 我你爱
## 反向切片
print(demo[::-1]) # 米大爱鼠老像就,你着爱,你爱我 (将字符串反过来)
######################## len()函数 ########################
# len()函数可以获取字符串的长度,即字符串的个数。从1开始数
demo = '米大爱鼠老像就,你着爱,你爱 我' # 但凡在用引号之间的都算作,包含空格
print(len(demo)) # 16
######################### strip() #########################
#移除字符串首尾指定的字符(不指定则默认移除空白字符)
demo = ' x1ong I love You '
print(demo.strip()) # x1ong I love You(前后空格已去除,但是不会去除中间的字符)
demo = '****x1ong****'
demo = demo.strip('*') # 指定去除前后的*号
print(demo) # x1ong
demo = '**==//I lvoe you//**=='
demo = demo.strip('*=/') # 指定取出首尾的*和=以及/
print(demo) # I lvoe you
######################## 切分split()函数 ########################
# split()括号里面不指定字符。默认以空格进行分割。切分成一个列表
demo = 'hello world 你好 世界'
demo = demo.split()
print(demo) # ['hello', 'world', '你好', '世界']
# split()指定以+号进行分割
demo = 'hello+world+nihao+shijie'
demo = demo.split('+')
print(demo) # ['hello', 'world', 'nihao', 'shijie']
#注意: split()函数分割的结果是一个列表类型
# split() 指定分割的次数
msg = 'my+name+is+x1ong'
print(msg.split('+',1)) # '['my','name+is+x1ong']' # 指定分割1次
需要掌握的操作
strip(), lstrip(), rstrip()方法的使用:
demo = '****x1ong*****'
res = demo.strip('*') # 移除左右两边的*
print(res) # x1ong
demo = '=========x1ong============='
res = demo.lstrip('=') # 只移除左边的=号
print(res) # x1ong=============
demo = '=========x1ong============='
res = demo.rstrip('=') # 只移除右边的=号
print(res) # =========x1onglower(),upper()方法的使用:
# lower() 和 upper()
str1 = 'My Name is Mr x1ong'
str1 = str1.lower() # 将所有字母转为小写字母
print(str1) # my name is mr x1ong
str1 = str1.upper() # 将所有字母转为大写字母
print(str1) # MY NAME IS MR X1ONGstartswith(),endswith()方法的使用：
## startswith 和 endswith
msg = 'you are a single dog'
# startswith() 判断一个字符串是否以指定的字符开始，返回值是一个布尔值。即True和False
res = msg.startswith('you') # 判断一个字符串是否以某个字符开头
print(res) # True
# endswith() 判断一个字符串是否以指定的字符开始,返回值是一个布尔值。即True和False
res = msg.endswith('dog') # 判断一个字符串是否以指定字符结尾
print(res) # True
demo = 'you are a dsb'
demo = demo.startswith('your')
print(demo) # Falsesplit()和rsplit()方法的使用:
# split() 和 rsplit()
# split()可以将字符以指定的字符进行切分(从左往右)。返回的是一个列表，我们还可以指定分割的次数(默认为分割所有)
msg = 'you=are=a=single=dog'
res = msg.split('=') # ['you','are','a','single','dog']
print(res)
# split()指定分割的次数
msg = 'you=age=a=single=dog'
res = msg.split('=',2) # ['you','age','a=single=dog']
print(res)
# rsplit() 刚好和split()相反，它是从右往左切割。 也可以指定分割次数
msg = 'my+name+is+x1ong'
res = msg.rsplit('+')
print(res) # ['my', 'name', 'is', 'x1ong']
res = msg.rsplit('+',1) # ['my+name+is', 'x1ong']
print(res)join()方法的使用
# join()方法
# 从可迭代对象中取出多个字符串。最后按照指定的分隔符进行拼接。最后拼接的结果为字符串
msg = ['x1ong','17','china','student','male']
res = '+'.join(msg) # 指定以+作为分隔符。
print(res) # # x1ong+17+china+student+male
# 注意: join()只能对值全为字符串的可迭代对象有效。否则会报错:
msg = ['x1ong',17]
# error_exam = '*'.join(msg) # 报错示例replace()方法的使用
# replace() 方法
# replace() 用于指定旧的字符串，替换为新的字符串(字符串替换操作)
info = 'I love you,Do you love me ?'
res = info.replace('love','❤') # 将指定的字符love替换为新字符❤
print(res) # I ❤ you,Do you ❤ me ?
# replace() 还可以指定替换的次数
msg = 'I love you do you love me ?'
res = msg.replace('you','❤',1) # 指定替换次数为1次
print(res) # I love ❤ do you love me ?isdigit()方法的使用
# isdigit()方法
# 判断指定的字符是否由纯数字组成
msg = 'x1ong'
res = msg.isdigit()
print(res) # False
info = '123123123123'
res = msg.isdigit()
print(res) # True
# 小案例:
while True:
in_tel = input('please input your tel Nubmer: ').strip()
if (in_tel.isdigit()):
if ( len(in_tel) == 11 ):
print('您的电话号码为:' + in_tel)
break
else:
print('你输入的电话号码长度非法!')
else:
print('您输入的电话号码格式非法,请重新输入')了解的操作：
# find(),index(),rfind(),rindex(),count() 方法的使用
################### find()方法 ###################
# find() 从指定的范围内查找指定的字符串第一次出现的起始索引,如果查找到则返回起始下标。否则返回-1。
# find()方法取最左边出现的字符下标
msg = 'my name is x1ong or name is Mr x1ong'
res = msg.find('x1ong') # 如果不指定范围,默认从头查到尾
print(res)
info = 'nice day and nice day'
result = info.find('e',0,3) # 从索引为0到索引3(顾头不顾尾,实际上只查找0-2之间)之前查找字符串
print(result) # -1 没有查找到 返回False
# rfind()方法同find()方法 只不过它取的是最右边出现的下标返回
test = 'nice day and nice day'
result = test.rfind('a')
print(result) # 19
################### index()方法 ###################
# index()同find()方法，只不过index()查找不到则报错。而find()查找不到返回-1
msg = 'my name is x1ong or name is Mr x1ong'
res = msg.index('x1ong')
print(res) # 11
info = 'my name is x1ong or name is Mr x1ong'
# info = info.index('test') 查找不到报错
# rindex()方法同rfind()方法
msg = '欢迎访问Mr x1ong的博客，欢迎访问我的博客'
res = msg.rindex('博客')
print(res) # 22
################### count() ####################
# count()方法用于查找指定字符出现的次数
info = 'the is x1ong the is x1ong x1ong x1ong x1ong'
res = info.count('x1ong')
print(res) # 5
###### center(),ljust(),rjust(),zfill()
############# center() ###############
# center()返回一个原字符串的居中,并且需要指定宽度,如果字符串宽度(个数)不够,则默认使用空格填充。
'''
content()参数:
参数1: width --- 字符串的总宽度
参数2: fillchar --- 填充的字符 (不指定默认为空格)
'''
name = 'x1ong'
content = name.center(30) # 不指定默认为空格
print(content) # x1ong
name = 'x1ong'
content = name.center(30,'#') # 指定宽度为30,不够使用#号填充
print(content) # ############x1ong#############
name = 'fxxxx'
content = name.center(5,'#') # 如果字符串达到了center()指定的宽度,则什么都不会填充,也不会居中
print(content)
########### ljust() ##########
# ljust()方法与center()方法基本一致,只不过center是两边填充,然后居中。而ljust()则是文字居左,右边填充
user = 'admin'
res = user.ljust(20) # 文字巨左,右边填充
print(res) # admin###############
######## rjust() #########
# rjust()方法与ljust()方法基本一致,只不过ljust()是居左,右边填充。而rjust()则刚好相反，它是文字居右,左边填充。
user = 'test'
wrapper = user.rjust(20,'#')
print(wrapper)
########## zfill() #########
# zfill()与rjust()基本一致,只不过zfill()只能使用0进行填充。并没有参数2。
test = 'admin'
result = test.zfill(20)
print(result) # 000000000000000admin
########### expandtabs() ##########
name = 'hello\tworld' # \t表示我们的制表符
print(name) # hello world
# 一般情况下,一个tab键,一般代表4个空格,我们可以使用expandtabs()指定制表符的空格数量
res = name.expandtabs(1) # 指定tab键的空格为1
print(res) # hello world
# capitalize(),swapcase(),title()
############# capitalize() ############
# capitalize() 首字母大写
str1 = 'hello world'
res = str1.capitalize() # 字符串中的首字母大写
print(res) # Hello world
############# swapcase() ###########
# swapcase() 大小写翻转,小写变大写,大写变小写
str2 = 'My Name Is X1ong'
content = str2.swapcase()
print(content) # mY nAME iS x1ONG
############# title() #############
# title() 每个单词的首字母大写(使用空格区分每个单词)
str3 = 'my name is x1ong age is 17'
content = str3.title()
print(content) # My Name Is X1Ong Age Is 17
## is数字系列
# 在Python中数字的表现形式:
num1 = b'100' # bytes 字节
num2 = u'2' # unicode,python3中无需在前面加u,默认就是unicode
num3 = '四' # 中文表示的数字4
num4 = 'Ⅳ' # 罗马数字
# isdigit() 检查字符串是否由数字组成
print(num1.isdigit()) # True
print(num2.isdigit()) # True
print(num3.isdigit()) # Fasle
print(num4.isdigit()) # Fasle
# isdecimal() 方法检查字符串是否只包含十进制字符。这种方法只存在于unicode对象
# print(num1.isdecimal()) # 报错 bytes无isdecimal()方法
print(num2.isdecimal()) # True
print(num3.isdecimal()) # Fasle
print(num4.isdecimal()) # False
# isnumeric() 方法检测字符串是否由数字组成
# print(num1.isnumeric()) # 报错 bytes没有isnumberic()方法
print(num2.isnumeric()) # True
print(num3.isnumeric()) # True
print(num4.isnumeric()) # True
# PS: isdigit()、isdecimal()、isnumeric() 三者判断浮点数,结果均为False
'''
总结:
最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景
如果要判断中文数字或罗马数字,则需要用到isnumeric。
'''
## is其他
## isalnum()
# isalnum() 判断一个字符串是否由数字和英文字母组成
name = 'x1ong'
print(name.isalnum()) # True
# 如果字符串包含其他非字母和数字字符,则直接返回False
name = 'x1ong..'
print(name.isalnum()) # Fasle
# isalpha()
# isalpha() 判断一个字符串是否全由字母组成
print(name.isalpha()) # False
name = 'xiong'
print(name.isalpha()) # True
# isidentifier()
# 检查字符串是否是一个有效的标识符
print(name.isidentifier()) # True
# islower()
# 检查字符串是否是全小写
msg = 'abcdef'
print(msg.islower()) # True
# isupper()
# 检查字符串是否是全大写
# isspace()
# 检查字符串是否是空格(空白)
msg = ' '
print(msg.isspace()) # True
msg = '123 '
print(msg.isspace()) # False
# istitle()
# 检查字符串中的每个单词的首字母是否都大写(以空格区分每个单词)
name = 'My name is X1ong'
print(name.istitle()) # False
name = 'My Name Is Xiong'
print(name.istitle()) # True4、列表
定义
由[]包裹起来，列表中的每个值之间使用逗号进行间隔。列表中可以是任意数据类型。包裹列表本身。
list1 = ['x1ong',1,2,3,[1,2,3,4,5],{1,2,3,'x1ong'},{'name':'x1ong','age':17}]
print(list1,type(list1)) 类型转换
但凡能被for循环遍历的数据类型，都可以使用list()方法，将其转换为list类型。
循环遍历一个字符串：
for i in 'hello world':
print(i) # 逐个字符依次取出,并打印使用list()将字符串类型转为list类型
1、对字符串使用list()方法转为list类型
a = 'hello world'
a_list = list(a)
print(a_list,type(a_list)) # ['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd'] <class 'list'>2、对字典使用list()方法转为list类型
info = {'name':'x1ong','age':17,'addr':'China'}
res = list(info)
print(res,type(res)) # ['name', 'age', 'addr']对字典使用list()方法转为list类型，其返回的是以key名，为值的列表。
3、对元组使用list()方法转为list类型
info = (1,2,3,'hello')
info = list(info)
print(info,type(info)) # [1, 2, 3, 'hello'] <class 'list'>4、对集合使用list()方法转为list类型
info = {1,2,3,'hello','world'}
info = list(info)
print(info,type(info)) # [1, 2, 3, 'hello', 'world'] <class 'list'>使用
优先掌握
列表索引取值和修改值
# 按照索引取值(正向反取)对于列表使用索引 即可修改也可以取
# 通过索引取列表中的某个值
# 正向(数)取值
info = ['x1ong',17,'china']
print(info[0]) # x1ong
# 反向(负数)取值
print(info[-1]) # -1 取得是列表中最后一个值 china
print(info[-2]) # -2 取得是列表中倒数第二个值 17
# 通过索引修改某个索引的值
# 对于列表来说，可以通过索引取值，也可以通过索引修改某个值
info[0] = 'Mr X1ong'
print(info) # ['Mr X1ong', 17, 'china']
# 如果修改的索引不存在，则直接报错
# info[3] = 'erro example' # 错误示例
列表切片
# 切片(包含开始不包含结束)
msg = ['x1ong',17,'china','student']
print(msg[0:2]) # 0:2 只能取出索引为0和为1的值。包含开始不包含结束。结果为 x1ong 和 17
# 步长
print(msg[0:4:2]) # 从0开始,之后依次加2,那么取出来的就是索引0 和 2 结果为 x1ong 和 china获取列表的长度
# 获取列表的长度
# len()函数 获取列表值的个数
list1 = ['x1ong',17,'student','male']
print(len(list1)) # 4成员运算符在列表中的应用
# in 判断某个字符是否在in后面的变量值中
example = ['x1ong',17,'student']
print('x1ong' in example) # True
print('test' in example) # False
# not in 某个字符不再in后面的变量值中
print('x1ong' not in example) # False
print('test' not in example) # True列表的内置方法
append()方法向列表的末尾追加数据类型
# append()方法
list1 = ['x1ong',17,'student','male']
list2 = ['lxx',19,'student','female']
list1.append(list2) # 将list2追加到list1的后面
print(list1) # ['x1ong', 17, 'student', 'male', ['lxx', 19, 'student', 'female']]
msg = {1,2,3,'x1ong'}
list3 = ['x1ong',17]
res = list3.append(msg) # ['x1ong', 17, {1, 2, 3, 'x1ong'}]
print(list3)
print(res) # None append()方法没有返回值。append()方法会追加数据追加到列表的末尾。并且append()方法可以追加任意数据类型(列表中本身可以有的数据类型)。
由于列表是可变类型，所以列表的内置方法，一般返回值都为None。
extend()方法向列表的末尾追加元素
# extend() 向列表尾部追加多个值
list1 = ['x1ong',17]
list2 = ['a','b','c']
res = list1.extend(list2) # 将list2的所有值追加到list1的尾部
print(list1) # ['x1ong', 17, 'a', 'b', 'c']
print(res) # None 注意：append()方法是将指定的数据类型加入到某个列表中，而extend()则是将数据类型中的元素加入到列表中。
对于extend()如果追加的数据类型是字典,则将字典的key名，追加到列表中(不会追加字典的value)。
dic = {'name':'x1ong','age':17,'addr':'china'}
list1 = ['xxx']
list1.extend(dic)
print(list1) # ['xxx', 'name', 'age', 'addr']insert()方法在指定的位置插入数据类型
# insert()方法
list1 = ['x1ong',17,'china']
res = list1.insert(0,'xxx') # 在下标为0的地方插入字符串 'xxx'
print(list1) # ['xxx', 'x1ong', 17, 'china']
print(res) # None
list1.insert(3,[1,2,3]) # 在下标为3的地方插入列表
print(list1) # ['xxx', 'x1ong', 17, [1, 2, 3], 'china']
list1.insert(0,{'name':'x1ong','age':17})
print(list1) # [{'name': 'x1ong', 'age': 17}, 'xxx', 'x1ong', 17, [1, 2, 3], 'china']注意：insert()方法是将数据类型插入到对应的位置中，插入的如果是字典，则列表里面插入的是字典类型。插入其他类型也是一致。
删除列表元素的操作
# del
a = ['x1ong',17,'student']
# a = del a[1] # 如果del被赋值给变量则会报错
del a[1]
print(a) # ['x1ong', 'student']
del a[0:2]
print(a) # []可以使用del删除掉列表中的某个元素。注意del不能赋值给变量，否则会报错。
pop()方法删除列表中的某个元素
# pop()方法 删除列表中的某个元素
info = ['x1ong',17,'student','male']
info.pop() # 不指定删除的元素,默认则删除列表中的最后一个元素,索引则为 -1
print(info)
res = info.pop(0) # 删除列表中索引为0的元素,即 'x1ong'
print(info) # [17, 'student']
print(res) # 返回值 x1ong pop()方法的返回值，则是被删除掉的那个元素。
remove()方法用于移除列表中某个值的第一个匹配项
# remove()
msg = ['x1ong','lxx','fxx','zxx','x1ong']
msg.remove('x1ong') # 删除'x1ong'
print(msg) # ['lxx', 'fxx', 'zxx', 'x1ong']
demo = [{'name':'x1ong','age':17,'gender':'male'},'x1ong',17,[1,2,3]]
res = demo.remove({'name':'x1ong','age':17,'gender':'male'}) # 指定删除这个字典
print(demo) # ['x1ong', 17, [1, 2, 3]]
print(res) # None
# demo.remove('xxx') # 如果要删除的元素不存在,则报错sort()方法给列表中的元素排序
# sort()
list1 = [10,50,20,100,70]
list1.sort() # 不指定reverse参数则默认从小到大排序
print(list1) # [10, 20, 50, 70, 100]
list1.sort(reverse=True)
print(list1) # 指定reverse参数为True则从大到小排序
list1.sort(reverse=False) # reverse参数默认值为False
print(list1) # [10, 20, 50, 70, 100]那么以上是sort()方法对纯数字列表的排序，那么如果列表的值是全字符串呢？
# sort()
list1 = ['d','z','a','e','h']
list1.sort() # 不指定reverse参数为True 默认从小到大排序
print(list1) # ['a', 'd', 'e', 'h', 'z']
'''
全字符串的列表，他们之间的比较,比较的是ASCII码。
以下为他们的对应关系:
d =====> 100
z =====> 122
a =====> 97
e =====> 101
h =====> 104
从小到大
97 < 100 < 101 < 104 < 122
a < d < e < h < z
'''
# 当字符串不再是一个字符的时候,那么他们会先比较四者的第一个字符。如果第一个字符的ASCII码没有分出胜负,则平局的字符他们继续比较第二个字符。
# 比如下面的 'zero' 和 'zacd'他们首字母比较的时候,打成了平局,那么继续比较两者的第二个字符串ASCII,可以发现，a 小于 e,因此从小到大排序,就把小a排到了前面
list2 = ['abc','efg','hijk','zero','zacd']
list2.sort()
print(list2) # ['abc', 'efg', 'hijk', 'zero']
# 对于列表和列表之间也是逐个PK,和字符串一致。注意：列表中的字典是不能相互比较的。不然会报错。还有就是，列表中比较的数据类型必须一致才可以，否则报错。
reverse()列表的反转
# reverse() 让列表反转
list1 = [1,2,3,4,5,'hello',['x1ong','student']]
list1.reverse() # 列表反转
print(list1) # [['x1ong', 'student'], 'hello', 5, 4, 3, 2, 1]
# 使用索引让列表反转
list1 = [1,2,3,4,5,'hello',['x1ong','student']]
print(list1[::-1]) # [['x1ong', 'student'], 'hello', 5, 4, 3, 2, 1]队列与堆栈
# 1、队列: FIFO(first input first out),先进先出
l = []
# 入队操作
l.append('first')
l.append('second')
l.append('third')
# 出队操作
print(l.pop(0)) # first
print(l.pop(0)) # second
print(l.pop(0)) # third
# 2、堆栈: LIFO(last input first output),后进先出
# 入栈操作:
l.append('first')
l.append('second')
l.append('third')
# 出队操作:
print(l.pop()) # third
print(l.pop()) # second
print(l.pop()) # first先有个印象，egon老师说后面有用。
堆栈就类似于叠衣服。先叠好放到柜子里面的衣服，一定是最后一个拿出来的，反而最后一个叠好放进去的衣服。而是第一个被拿出来的。
5、元组
作用
按照索引/位置存放多个值。只用于读不用于改
元组是一个"不可变的列表"
定义
# 在()内使用逗号间隔凯多个任意数据类型
a = (1,2,3,4,'hello',[1,2,3])
print(a,type(a)) # (1, 2, 3, 4, 'hello', [1, 2, 3]) <class 'tuple'>
# 注意:
# 单个值被()括起来,并不是一个元组,解释器会认为,10只是被()括起来的int类型而已。
x = (10)
print(x,type(x)) # 10 <class 'int'>
# 我们的元组如果是单个值,那么我们需要在其后面添加逗号。以告诉Python解释器这是一个元组
y = (10,)
print(y,type(y)) # (10,) <class 'tuple'>注意：我们的元组如果是单个值,那么我们需要在其后面添加逗号。以告诉Python解释器这是一个元组
类型转换
# 使用tuple()函数可以将任意类型转为元组类型
x = [1,2,3,'x1ong',True]
y = 'helloworld'
z = {'name':'x1ong','age':17,'addr':'china'}
res = tuple(x)
print(res,type(res)) # (1, 2, 3, 'x1ong', True) <class 'tuple'>
res = tuple(y)
print(res,type(res)) # ('h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd') <class 'tuple'>
res = tuple(z) # 对于字典转元组,只会去其中的key作为元组的元素
print(res,type(res)) # ('name', 'age', 'addr') <class 'tuple'>使用
info = ('x1ong',17,'china','student','male')
print(info)
# 元组只可以读,但是不可以通过索引修改某个值,否则报错。
# info[0] = 'xxx' # 报错示例换句话来说，只要元组的堆区指向的值内存地址变了，那么就会报错。
假设元组里面包含一个可变类型的列表呢？那么这个列表是否可以通过索引修改？
info = ('x1ong',17,['male','student'])
print(id(info[2])) # 4314015040
print(id(info[2][0])) # 4376943152
info[2][0] = 'female'
print(info) # ('x1ong', 17, ['female', 'student'])
print(id(info[2])) # 4314015040 # 在元组存放的列表内存地址没有发生变化
print(id(info[2][0])) # 4376943536 列表里面的元素内存地址发生了变化可以看到，只要元组的元素的id不变，则意味着你没有改变元组(不看列表里面的内存地址是否改变)。
可以发现，修改之后的列表id地址和修改之前的id是一样的。那么我们就不会报错。
如果我们改变了元组指向的列表内存地址，那么程序则会报错：
info = ('x1ong',17,['male','student'])
# info[2] = [123,456] # 报错示例总结：元组不能改指的是不改里面元素的内存地址。如果元组的内存地址不变，我们就没有该这个元组。特殊的是元组里面嵌套一个可变类型，我们可以将可变类型里面的元素改变，但是不能修改可变元素本身的内存地址。
内置方法
优先掌握的操作
元组按照索引取值
# 按索引取值(正反向取值) 只能取不能通过索引改
msg = ('x1ong',17,'student','male')
# 正向取值
print(msg[0]) # x1ong
print(msg[1]) # 17
# 反向取值
print(msg[-1]) # male
print(msg[-2]) # student
# 只能取不能改
# msg[0] = 123 报错示例元组的切片(包含开始不包含结束)
# 元组的切片
msg = ('x1ong',17,'student','male',1,2,3)
print(msg[0:2]) # ('x1ong', 17) 从0开始,包含开始不包含结束,所以取不到索引为2的值
# 步长
print(msg[1:6:2]) # 从1开始,后续都是依次加2(步长),所以结果就是 (17,'male',2)
# 元组元素的反转(利用步长)
print(msg[::-1]) # (3, 2, 1, 'male', 'student', 17, 'x1ong')获取元组的长度
# len()方法
msg = ('x1ong',17,'student','male',1,2,3)
res = len(msg)
print(res) # 7元组使用成员运算符
msg = ('x1ong',17,'student','male',1,2,3)
print('x1ong' in msg) # True
print('x1ong' not in msg) # False循环遍历元组
msg = ('x1ong',17,'student','male',[1,2,3])
for i in msg:
print(i)
'''
result:
x1ong
17
student
male
[1, 2, 3]
'''元组的index()方法和count()方法
msg = ('x1ong',17,'student','male',111,111,111)
res = msg.index(111) # index()方法用于查找某个值在元组中的第一次出现的位置，返回索引。
print(res)
# 如果index()在元组中没有查找到则会报错
# res = msg.index('123') # error example
# count()方法用于查找指定数据在元组中出现的次数。
result = msg.count(111)
print(result)6、字典
定义
被{}包裹的元素，每个元素之间使用逗号进行间隔，其中的每一个元素使用key:value的形式，其中value可以是任意数据类型，而key则必须是不可变数据类型。
dic = {'name':'x1ong','age':17,'job':'student'}
print(dic,type(dic)) # {'name': 'x1ong', 'age': 17, 'job': 'student'} <class 'dict'>
# 也可以这么这么定义字典
demo = dict(name = 'x1ong',age = '17',addr = 'China' )
print(demo,type(demo))
d = {} # 默认出来的是空字典(后续还有个类似这样的空集合)
print(d,type(d)) # {} <class 'dict'>
a = dict() # dict()函数不指定定义的也是空字典
print(a,type(a)) # {} <class 'dict'>
# 造字典的特殊方式：
list1 = [
['name','x1ong'],
['age',17],
['addr','china']
]
dic = {}
for x,y in list1:
dic[x] = y
print(dic) # {'name': 'x1ong', 'age': 17, 'addr': 'china'}
# 注意点：
# # key名只能是不可变类型，而value值则可以是任意类型
# name = {['1,2,3']:'x1ong'} # key名不能是可变类型
name = {'info':['x1ong',17,'student','male']} # value可以是任意类型
name = {1:2}
# 简单逻列一下Python的可变类型和不可变类型有哪些?
# 不可变数据类型: int类型、float类型、string类型、tuple类型
# 可变类型: list类型、dict类型、set类型在Python2版本中，字典是无序的。而到了Python3的版本时，字典就变成有序的了。
字典中key重复的问题：
# 在字典中的key如果重复指定，则前者的key会被后者替换。
dic = {'name':'x1ong','age':17,'addr':'china','name':'xxx'} # name重复，x1ong被替换
print(dic) # {'name': 'xxx', 'age': 17, 'addr': 'china'} 类型转换
# 使用dict()可以将一些数据类型转换为字典类型
'''
PS: 列表中，必须包含着子列表或者元组，而子列表中或元组中的值必须为两个。
第一个作为字典的KEY名
第二个值则作为字典的VALUE值。
'''
list1 = [['name','x1ong'],['age',17],('job','student')]
res = dict(list1)
print(res) # {'name': 'x1ong', 'age': 17, 'job': 'student'}
# 如果列表中没有包含两个子列表(或两个元组),就被转换为了字典,则直接报错。
'''
报错示例:
list2 = ['name','x1ong']
demo = dict(list2)
print(demo)
'''
# 元组中包含了两个列表
list3 = (['name','x1ong'],['age',17])
dic = dict(list3)
print(dic,type(dic)) # {'name': 'x1ong', 'age': 17} <class 'dict'>
# 元组中包含了一个列表(报错)
'''报错示例
list4 = (['name','x1ong'])
res = dict(list4)
print(res,type(res)
'''1
# fromkeys() 函数用于创建一个新字典，以参数1中元素做字典的键，参数2为字典所有键对应的初始值。
'''
fromkeys()
参数1: 字典键值的列表或元组
参数2: (可选参数)value
'''
dic = {} # 定义一个空字典
res = dic.fromkeys(['name','age','addr'],None)
print(res) # {'name': None, 'age': None, 'addr': None}使用
优先掌握的操作
字典的存取
# 按key取值 可取可改
# 取
dic = {'name':'x1ong','age':17,'addr':'china'}
print(dic['name']) # x1ong
print(dic['addr']) # china
# 改
dic['name'] = 'xxx'
print(dic) # {'name': 'xxx', 'age': 17, 'addr': 'china'}对于赋值操作,如果key不存在于字典中，则会创建这个key:value
dic = {'name':'x1ong','age':17,'addr':'china'}
dic['gender'] = 'male' # gender并不存在字典中,它会自动追加到字典
print(dic) # {'name': 'x1ong', 'age': 17, 'addr': 'china', 'gender': 'male'}对于赋值操作，如果key存在这个字典中，则会替换对应的值，保留新值
dic = {'name':'x1ong','age':17,'addr':'china'}
dic['name'] = 'xxx' # 如果这个key存在字典中,则会更新对应key的值
print(dic) # {'name': 'xxx', 'age': 17, 'addr': 'china'}获取字典的长度len()
dic = {
'name':'x1ong',
'age':17,
'job':'student',
'gender':'male'
}
print(len(dic)) # 4 len()方法的判断依据是根据key的个数进行判断。
成员运算符在字典中的应用
dic = {
'name':'x1ong',
'age':17,
'job':'student',
'gender':'male'
}
print('name' in dic) # True 判断某个值是否在字典的key中。看的是KEY
print('male' not in dic) # True 判断某个值是否不在字典的key中。male不在字典的key中，所以返回True字典元素的删除
dic = {
'name':'x1ong',
'age':17,
'job':'student',
'gender':'male'
}
# 万能的删除 del
del dic['name']
print(dic) # {'age': 17, 'job': 'student', 'gender': 'male'}
# pop()方法删除
res = dic.pop('age') # 删除key为age的键和值
print(res) # 返回删除的value
print(dic) # {'job': 'student', 'gender': 'male'}
# popitem()方法
# popitem()方法删除字典中最后一个key值。并且将删除的key和value返回。
'''
注意: 在Python2中字典是无序的,所以popitem()可能会随机删除一个。
但是到了Python3,字典是有序的。删除的一般的都是最后一个
'''
dic = {
'name':'x1ong',
'age':17,
'job':'student',
'gender':'male'
}
result = dic.popitem()
print(result) # 将删除的key和value返回 ('gender', 'male')
print(dic) # {'name': 'x1ong', 'age': 17, 'job': 'student'}获取字典中键、值、键值对的内置方法
keys()方法 获取字典的所有key名
keys()方法在Python2中，是直接返回一个以字典的key为元素的列表。这是很占用系统资源的。比如说字典中有10万个key，那么返回的就是10万个值的列表。而在Python3中做了优化，而是将字典的key返回了一个语法。我们可以这么想。把Python2的返回机制比喻成一筐鸡蛋。而Python3的机制，则比喻成为一个会下蛋的老母鸡。当我们需要的时候，这个老母鸡就会下蛋。这就对内存的占用了进行了一些优化。
# keys() # 获取字典的所有key名
info = {'name':'x1ong','age':17,'addr':'china','gender':'male'}
res = info.keys()
print(res) # dict_keys(['name', 'age', 'addr', 'gender'])
# 调用
list1 = []
for i in info.keys():
list1.append(i)
print(list1)values()方法 获取字典的所有value
Python2和Python3的返回值不一致。Python3做了优化，优化与keys()一致。不再赘述
# value() # 获取字典的所有value
info = {'name':'x1ong','age':17,'addr':'china','gender':'male'}
res = info.values() # dict_values(['x1ong', 17, 'china', 'male'])
print(res)
list2 = []
for y in info.values():
list2.append(y)
print(list2) # ['x1ong', 17, 'china', 'male']items()方法 获取字典的所有key和value
Python2和Python3的返回值不一致。Python3做了优化，优化与keys()一致。不再赘述
# items() # 获取字典的所有key和value
info = {'name':'x1ong','age':17,'addr':'china','gender':'male'}
res = info.items() # dict_items([('name', 'x1ong'), ('age', 17), ('addr', 'china'), ('gender', 'male')])
print(res)
dic = dict(res) # 再转为字典
print(dic)循环
# 循环
info = {'name':'x1ong','age':17,'addr':'china','gender':'male'}
# 默认遍历返回的是key
for j in info:
print(j) # name age addr gender
# 只遍历key
for i in info.keys():
print(i) # name age addr gender
# 只遍历value
for v in info.values():
print(v) # x1ong 17 china male
# 遍历key和value
for item in info.items():
print(item) # ('name', 'x1ong') ('age', 17) ('addr', 'china') ('gender', 'male')需要掌握的操作
get()方法的字典取值
dic = {'k1':111,'k2':222,'k3':333}
# print(dic['k4']) # 如果key不存在则报错
# get()
# 正常情况下下,如果key不存在则会报错。但是get()方法就很好的避免了这个问题
# get()方法如果指定的key不存在,则默认返回None。就不会报错
res = dic.get('k4') # None
print(res)
# get()方法如果指定的key存在,就返回key对应的值
print(dic.get('k1')) # 111
demo = {'name':'xxx','age':17}
res = demo.get('addr')
print(res) # 如果查找的key不存在并且在不指定返回值的情况,则默认返回None
res = demo.get('addr','傻瓜没有纸') # 如果查找的key不存在并且指定了返回值,那么get的返回值则是我们指定的那个值,不再是None
print(res) # 傻瓜没有纸update()更新旧字典，有则更新，无则追加
# update() 用于更新旧字典,有则更新，无则追加
dic = {'name':'x1ong','age':17,'addr':'china'}
# name 和 age 存在,所以会更新对应的值,而gende不存在则会追加对应的key和value
res = dic.update({'name':'xxx','age':20,'gender':'male'})
print(dic) # {'name': 'xxx', 'age': 20, 'addr': 'china', 'gender': 'male'}
print(res) # None 返回值setdefault() 设置默认值
# setdefault() 设置默认值
msg = {'name':'x1ong','k':123}
# 如果key不存在,则在字典的尾部追加
res = msg.setdefault('age',17)
print(msg) # {'name': 'x1ong', 'k': 123, 'age': 17}
print(res) # 17 返回的是追加的value
# 如果key存在,啥也不会干
demo = msg.setdefault('name','xxx') # key存在,啥也不会干
print(msg) # {'name':'x1ong', 'k': 123, 'age': 17} # 字典不变
print(demo) # 将存在的值返回 x1ong7、集合
作用
集合(set) 和 列表(list)、元组(tuple)、字典(dict)一样，都可以保存多个值。但是集合常用语去重、关系运算。
定义
# 定义
'''
在{}内使用逗号间隔开多个元素,集合需要具备如下三个特点:
1. 每个元素必须是不可变类型
2. 集合内没有重复(同数据类型同值)的元素
3. 集合是无序的
'''
set1 = {1,2,3,'x1ong',17,'student'}
# 集合是无序的,所以定义的顺序和打印出来的顺序不同
print(set1) # {1, 2, 3, 'x1ong', 'student', 17}
'''
注意:
在集合中是没有下标和key概念的。
那么我们想取出集合中的某个值怎么办?
答: 在集合中是无法单独取出某个值的,只能将整个集合中的所有元素取出;
而对于集合,也没有单独取出的必要,因为集合一般都用于去重和关系运算
'''
# 如何定义一个空集合?
set3 = {} # 如果这样定义的话,那么它会是一个字典。
print(type(set3)) # <class 'dict'>
# 所以我们需要使用set()方法定义一个空集合
set4 = set()
print(set4,type(set4)) # set() <class 'set'>
# 如果集合中包含了可变类型,比如列表,则直接报错。所以集合中只能是不可变类型
# set5 = {'1',[1,2,3]} # error example
# 假设我们在定义集合中,包含了多个重复的元素,那么会自动去重。
set6 = {'x1ong','x1ong','x1ong','x1ong','x1ong'}
print(set6) # 经过去重之后,集合中只有一个元素 {'x1ong'}
set7 = {'1',1}
print(set7) # '1' 和 1 他们是两个不同的数据类型,所以不会被去重。输出的结果为{1, '1'}类型转换
# 所有可以被for循环遍历的数据类型,都可以被转为集合类型。(注意: 遍历出来的元素必须都是不可变类型,否则会报错)
# 使用set()方法可以转为集合类型
list1 = [1,2,3,'x1ong','student','x1ong']
res = set(list1)
print(res) # 去重之后得: {1, 2, 3, 'student', 'x1ong'}
str1 = 'helloworld'
res = set(str1)
print(res) # 去重之后得: {'h', 'd', 'e', 'w', 'r', 'o', 'l'}
tup = (1,2,3,4,'x1ong')
res = set(tup)
print(res) # {1, 2, 3, 4, 'x1ong'}
# 字典被转为集合类型之后,会将字典中的key作为集合中的值
dic = {'name':'x1ong','age':17,'addr':'china'}
res = set(dic)
print(res) # {'addr', 'name', 'age'}
# 如果集合中包含了可变类型,那么会直接报错
error_example = [1,2,3,['x1ong','student']]
# res = set(error_example) 报错示例使用
关系运算
我们分别定义两个集合，分贝为friends1和friends2，分别存放两个人的好友列表。
friends1 = {'tony','pony','sunny','egon'} # 好友列表1
friends2 = {'sunny','token','zhang','tony'} # 好友列表2 他们的关系图就是：
friends1和friends2他们之间有共同的好友，分别是tony和sunny。
那么我们如何通过代码找出他们之间的共同好友呢？
friends1 = {'tony','pony','sunny','egon'} # 好友列表1
friends2 = {'sunny','token','zhang','tony'} # 好友列表2
for friend in friends1:
if friend in friends2:
print(friend) # sunny tony但是这个代码不够精简。要想再精简一些，就需要使用我们的关系运算符里面的交集运算符。
交集运算符&
1. 交集(&) 求两个用户的共同好友:
friends1 = {'tony','pony','sunny','egon'} # 好友列表1
friends2 = {'sunny','token','zhang','tony'} # 好友列表2
res = friends1 & friends2
print(res,type(res)) # {'sunny', 'tony'} 返回一个集合
# 在Python中两个集合之间使用&相连，表示使用交集运算符。而交集运算符除了可以使用&表示以外，还有其对应的方法。
# intersection()方法与&的结果一致。
friends1 = {'tony','pony','sunny','egon'} # 好友列表1
friends2 = {'sunny','token','zhang','tony'} # 好友列表2
res = friends1.intersection(friends2)
print(res) # {'tony', 'sunny'}
# intersection()可以指定多个集合，表示从n个集合中查找他们之间相同的好友
friends1 = {'tony','pony','sunny','egon'} # 好友列表1
friends2 = {'sunny','token','zhang','tony'} # 好友列表2
friends3 = {'sunny','x1ong','test','male'} # 好友列表3
res = friends1.intersection(friends2,friends3)
print(res) # {'sunny'}并(合)集运算符 |
假设我们现在有这样一个需求，就是将两个集合的东西，合并到一个集合当中(并且去重)。
看下方代码：
friends1 = {'tony','pony','sunny','egon'} # 好友列表1
friends2 = {'sunny','token','zhang','tony'} # 好友列表2
friends1 = list(friends1)
friends2 = list(friends2)
friends1.extend(friends2)
print(set(friends1)) # {'sunny', 'egon', 'zhang', 'tony', 'token', 'pony'}但是代码依旧不简洁。所以我们还需要用到关系运算符里面的并集运算符
# 并集运算符| (将两个集合合并到一个集合当中)
friends1 = {'tony','pony','sunny','egon'} # 好友列表1
friends2 = {'sunny','token','zhang','tony'} # 好友列表2
res = friends1 | friends2
print(res) # {'token', 'pony', 'sunny', 'egon', 'zhang', 'tony'}
# 在Python中两个集合之间使用 | 相连，表示使用并集运算符。而并集运算符除了可以使用 | 表示以外，还有其对应的方法。
# union()方法
friends1 = {'tony','pony','sunny','egon'} # 好友列表1
friends2 = {'sunny','token','zhang','tony'} # 好友列表2
res = friends1.union(friends2)
print(res) # {'tony', 'token', 'egon', 'pony', 'sunny', 'zhang'}
# union()同样可以指定多个集合，其功能就是将多个集合合并到一个集合当中
friends1 = {'tony','pony','sunny','egon'} # 好友列表1
friends2 = {'sunny','token','zhang','tony'} # 好友列表2
friends3 = {'test','x1ong','sunny'} # 好友列表3
res = friends1.union(friends2,friends3)
print(res) # {'tony', 'token', 'egon', 'pony', 'sunny', 'zhang'}差集运算符( – )
假设我们有这样一个需求，我们需要求出friends1中它独有的好友。我们应该怎么做?
friends1 = {'tony','pony','sunny','egon'} # 好友列表1
friends2 = {'sunny','token','zhang','tony'} # 好友列表2
for friend in friends1:
if friend not in friends2:
print(friend) # pony egon但是代码依旧不整洁,我们还是有对应的关系运算符。那就是差集运算符。
# 差集运算符(-) 取某个集合中独有的元素
friends1 = {'tony','pony','sunny','egon'} # 好友列表1
friends2 = {'sunny','token','zhang','tony'} # 好友列表2
# 求friends1 和 friends2 之间 friends1独有的好友:
print(friends1 - friends2) # {'pony', 'egon'}
# 求friends2 和 friends1 之间 friends2独有的好友:
print(friends2 - friends1) # {'token', 'zhang'}
# 同样的,集合中差集运算符除了使用 - 之外，还有其对应的方法。
# difference() 也可以指定多个集合，那么如果指定了多个集合，就是在n个集合中找到某个集合中特有的元素
# 求friends1 和 friends2 之间 friends1独有的好友:
res = friends1.difference(friends2)
print(res) # {'egon', 'pony'}
# 求friends1 和 friends2 之间 friends2独有的好友:
res = friends2.difference(friends1)
print(res) # {'token', 'zhang'}对称差集(^)
假设我们仍然有需求，就是求两个集合中他们独有的好友(即去掉共有的好友)
# 差集运算符(-) 取某个集合中独有的元素
friends1 = {'tony','pony','sunny','egon'} # 好友列表1
friends2 = {'sunny','token','zhang','tony'} # 好友列表2
list1 = []
for friend in friends1:
if friend not in friends2:
list1.append(friend)
for friend in friends2:
if friend not in friends1:
list1.append(friend)
print(set(list1)) # {'token', 'egon', 'zhang', 'pony'}但是可以看到，这个代码是不间接的(可能有比我写的还简洁的哈哈哈哈哈哈哈，一时没想到，就写这个做example了)。其实我们还可以使用关系运算符中的对称交集运算符解决这个问题。
# 对称交集运算符(^) 取两个集合中不同的元素
friends1 = {'tony','pony','sunny','egon'} # 好友列表1
friends2 = {'sunny','token','zhang','tony'} # 好友列表2
# 取两个集合中不同的元素
print(friends1 ^ friends2) # {'token', 'egon', 'zhang', 'pony'}
# 同样的，除了使用^表示对称交集以外，对称交集还有其对应的方法
# symmetric_difference() 可以指定多个集合，使用逗号间隔，其意思就是从多个集合中查找不同的元素(忽略相同的元素)
res = friends1.symmetric_difference(friends2)
print(res) # {'pony', 'zhang', 'token', 'egon'}相等运算符(==)
friends1 = {'tony','pony','sunny','egon'} # 好友列表1
friends2 = {'sunny','token','zhang','tony'} # 好友列表2
# 判断两个集合是否相等
print(friends1 == friends2) # False
friends1 = {'tony','pony','sunny','egon'} # 好友列表1
friends2 = {'tony','pony','sunny','egon'} # 好友列表2
print(friends1 == friends2) # True父集(一个集合是否包含另外一个集合)
# 父级(一个集合是否包含另外一个集合的全部元素,如果包含,那么这个集合则是另外一个集合他爹)
friends1 = {'tony','pony'} # 好友列表1
friends2 = {'sunny','token','pony','tony'} # 好友列表2
# friends1是否包含friends2
print(friends2 > friends1) # True
# 不存在包含关系则返回False
set1 = {1,2,3}
set2 = {1,2,5,6}
print(set1 > set2) # False子集(一个集合被其父级包含)
# 子集
friends1 = {'tony','pony'} # 好友列表1
friends2 = {'sunny','token','pony','tony'} # 好友列表2
print(friends1 < friends2) # True friends1是friends2的子集,所以返回True
set1 = {1,2,3}
set2 = {1,2,3,4}
print(set1 <= set2) # True set1 是set2的子集,所以返回True去重
1、由于集合中不能包含可变类型，所以去重只针对不可变类型
2、由于集合自身是无序的，所以去重之后无法保证原来的顺序
去重示例：
# example1
set1 = {'a','x1ong','x1ong','x1ong',17,'student'}
print(set1)
# example2
list1 = ['x1ong','x1ong','x1ong','male','shuaib']
res = set(list1) # 将列表转为集合
print(res) # {'shuaib', 'x1ong', 'male'} 去除了重复,但是打乱了顺序
# 如果想要去重，并且保留原有的顺序，那么我们需要自写功能实现
list1 = [] # 定义一个空列表
list2 = [
{'name':'x1ong','age':17,'gender':'male','job':'student'},
{'name':'lxx','age':19,'gender':'female','job':'student'},
{'name':'fxx','age':18,'gender':'female','job':'student'},
{'name':'x1ong','age':17,'gender':'male','job':'student'},
{'name':'fxx','age':18,'gender':'female','job':'student'}
]
for item in list2:
if item not in list1:
list1.append(item)
print(list1)
'''list1的结果：即去重，由保证了原来的顺序不变。
[
{'name': 'x1ong', 'age': 17, 'gender': 'male', 'job': 'student'},
{'name': 'lxx', 'age': 19, 'gender': 'female', 'job': 'student'},
{'name': 'fxx', 'age': 18, 'gender': 'female', 'job': 'student'}
]
'''其他操作
# 1.长度len()
friends = {'x1ong','male','x1ong','17','student'}
print(len(friends)) # 集合会自动去重，所以结果为 4
# 成员运算符
friends = {'x1ong','male','x1ong','17','student'}
print('x1ong' in friends) # True
print('x1ong' not in friends) # False
# 循环
for item in friends:
print(item) # student male x1ong 17