Python的基本数据类型和内置方法

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) #  =========x1ong

lower(),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 X1ONG

startswith(),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) # False

split()和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()) # True

4、列表

定义

由[]包裹起来,列表中的每个值之间使用逗号进行间隔。列表中可以是任意数据类型。包裹列表本身。

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的版本时,字典就变成有序的了。

Python的基本数据类型和内置方法插图

字典中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名

Python的基本数据类型和内置方法插图1

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

Python的基本数据类型和内置方法插图2

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

Python的基本数据类型和内置方法插图3

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) # 将存在的值返回  x1ong

7、集合

作用

集合(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)  报错示例

使用

关系运算

我们分别定义两个集合,分贝为friends1friends2,分别存放两个人的好友列表。

friends1 = {'tony','pony','sunny','egon'}   # 好友列表1
friends2 = {'sunny','token','zhang','tony'} # 好友列表2 

他们的关系图就是:

Python的基本数据类型和内置方法插图4

friends1friends2他们之间有共同的好友,分别是tonysunny

那么我们如何通过代码找出他们之间的共同好友呢?

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

本文作者: x1ong
免责声明:本博客所有文章仅用于学习交流
转载声明:文章为作者原创文章 转载请注明来源
本文链接: https://www.giaoblog.com/python/17394.html
上一篇
下一篇