Python基础之基本数据类型转换及内置方法

基本数据类型转换及内置方法

数据类型转换

获取数据类型
可以使用 type() 函数获取任何对象的数据类型：

    x = 10
    # 打印变量 x 的数据类型
    print(type(x))

数据类型转换
数据类型的转换，一般情况下你只需要将数据类型作为函数名即可对数据内置的类型进行转换

隐式类型转换 - 自动完成
Python 会将较小的数据类型转换为较大的数据类型，以避免数据丢失。

'''对两种不同类型的数据进行运算，较低数据类型（整数）就会转换为较高数据类型（浮点数）以避免数据丢失。'''

num_int = 123   # <class 'int'>
num_flo = 1.23  # <class 'float'>

num_new = num_int + num_flo  # 124.23  <class 'float'>

不同数据类型运算结果会报错， Python 在这种情况下无法使用隐式转换

# 整型数据与字符串类型的数据进行相加，运算结果会报错，输出 TypeError

num_int = 123   # <class 'int'>
num_str = "456"  # <class 'str'>

print(num_int+num_str)  # TypeError: unsupported operand type(s) for +: 'int' and 'str'

显式类型转换 - 需要使用类型函数来转换
在显式类型转换中，用户将对象的数据类型转换为所需的数据类型。

x = int(2.8)  # x 输出结果为 2  <class 'int'>
y = float("3")   # y 输出结果为 3.0  <class 'float'>
z = str(3.0)  # z 输出结果为 '3.0'  <class 'str'>

整型和字符串类型进行运算，就可以用强制类型转换来完成：

num_int = 123   # <class 'int'>
num_str = "456"  # <class 'str'>

# 强制转换为整型
num_str = int(num_str)  # 输出 num_str 数据类型 <class 'int'>

num_sum = num_int + num_str  # 579  <class 'int'>

以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。

函数	描述	实例
int(x [,base])	将x转换为一个整数	x = int(29)
float(x)	将x转换到一个浮点数	x = float(29.5)
complex(real [,imag])	创建一个复数	x = complex(1j)
str(x)	将对象 x 转换为字符串	x = str("Hello World")
repr(x)	将对象 x 转换为表达式字符串	x = repr(123)
eval(str)	用来计算在字符串中的有效Python表达式,并返回一个对象	x = eval('2 + 2')
tuple(s)	将序列 s 转换为一个元组	s = tuple(("apple", "banana", "cherry"))
list(s)	将序列 s 转换为一个列表	s = list(("apple", "banana", "cherry"))
dict(d)	创建一个字典。d 必须是一个 (key, value)元组序列。	d = dict(name="Bill", age=36)
set(s)	转换为可变集合	x = set(("apple", "banana", "cherry"))
frozenset(s)	转换为不可变集合	x = frozenset(("apple", "banana", "cherry"))
chr(x)	将一个整数转换为一个字符	print chr(0x30), chr(0x31), chr(0x61)
ord(x)	将一个字符转换为它的整数值	a = ord('a')

进制转换

函数	描述	实例
ord(x)	将一个整数（十进制）转换为一个二进制字符串	print(bin(100))
oct(x)	将一个整数（十进制）转换为一个八进制字符串	print(otc(100))
hex(x)	将一个整数（十进制）转换为一个十六进制字符串	print(hex(100))

内置方法

内置方法可以简单的理解成是每个数据类型自带的功能（内建函数）

使用数据类型的内置方法统一采用句点符

	数据类型.方法名()
    	eg:
         'jason'.字符串具备的方法()
        
         name = 'jason'
         name.字符串具备的方法()

   ''' 借助于编辑器自动提示,快速查看某个数据类型的内置方法  '''

字符串相关方法

>>> str1 = 'hello python!'

# 1.按索引取值(正向取，反向取)：
# 1.1 正向取(从左往右)
>>> str1[6]
p
# 1.2 反向取(负号表示从右往左)
>>> str1[-4]
h
# 1.3 对于str来说，只能按照索引取值，不能改
>>> str1[0]='H' # 报错TypeError


# 2.切片(顾头不顾尾，步长)
# 2.1 顾头不顾尾：取出索引为0到8的所有字符
>>> str1[0:9]  
hello pyt
# 2.2 步长：0:9:2,第三个参数2代表步长，会从0开始，每次累加一个2即可，所以会取出索引0、2、4、6、8的字符
>>> str1[0:9:2]  
hlopt 
>>> str1[::2]  # 针对整个字符串 隔一个取一个
hlopto!
# 2.3 反向切片
>>> str1[::-1]  # -1表示从右往左依次取值
!nohtyp olleh

# 3.长度len
# 3.1 获取字符串的长度，即字符的个数，但凡存在于引号内的都算作字符)
>>> len(str1) # 空格也算字符
13

# 4.成员运算 in 和 not in	
# 4.1 int:判断hello 是否在 str1里面
>>> 'hello' in str1  
True
# 4.2 not in:判断tony 是否不在 str1里面
>>> 'tony' not in str1 
True

# 5.strip移除字符串首尾指定的字符(默认移除空格)
# 5.1 括号内不指定字符，默认移除首尾空格
>>> str1 = '  life is short!  '
>>> str1.strip()  
life is short!

# 5.2 括号内指定字符，移除首尾指定的字符
>>> str2 = '**tony**'  
>>> str2.strip('*')  
tony

# 6.切分split
# 6.1 括号内不指定字符，默认以空格作为切分符号
>>> str3='hello world'
>>> str3.split()
['hello', 'world']
# 6.2 括号内指定分隔字符，则按照括号内指定的字符切割字符串
>>> str4 = '127.0.0.1'
>>> str4.split('.')  
['127', '0', '0', '1']  # 注意:split切割得到的结果是列表数据类型


# 7.循环
>>> str5 = '今天你好吗？'
>>> for line in str5:  # 依次取出字符串中每一个字符
...     print(line)
...
今
天
你
好
吗
？

字符串内建函数

方法	描述
capitalize()	把首字符转换为大写。
casefold()	把字符串转换为小写。
center()	返回居中的字符串。
count()	返回指定值在字符串中出现的次数。
encode()	返回字符串的编码版本。
endswith()	如果字符串以指定值结尾，则返回 true。
expandtabs()	设置字符串的 tab 尺寸。
find()	在字符串中搜索指定的值并返回它被找到的位置。
format()	格式化字符串中的指定值。
format_map()	格式化字符串中的指定值。
index()	在字符串中搜索指定的值并返回它被找到的位置。
isalnum()	如果字符串中的所有字符都是字母数字，则返回 True。
isalpha()	如果字符串中的所有字符都在字母表中，则返回 True。
isdecimal()	如果字符串中的所有字符都是小数，则返回 True。
isdigit()	如果字符串中的所有字符都是数字，则返回 True。
isidentifier()	如果字符串是标识符，则返回 True。
islower()	如果字符串中的所有字符都是小写，则返回 True。
isnumeric()	如果字符串中的所有字符都是数，则返回 True。
isprintable()	如果字符串中的所有字符都是可打印的，则返回 True。
isspace()	如果字符串中的所有字符都是空白字符，则返回 True。
istitle()	如果字符串遵循标题规则，则返回 True。
isupper()	如果字符串中的所有字符都是大写，则返回 True。
join()	把可迭代对象的元素连接到字符串的末尾。
ljust()	返回字符串的左对齐版本。
lower()	把字符串转换为小写。
lstrip()	返回字符串的左修剪版本。
maketrans()	返回在转换中使用的转换表。
partition()	返回元组，其中的字符串被分为三部分。
replace()	返回字符串，其中指定的值被替换为指定的值。
rfind()	在字符串中搜索指定的值，并返回它被找到的最后位置。
rindex()	在字符串中搜索指定的值，并返回它被找到的最后位置。
rjust()	返回字符串的右对齐版本。
rpartition()	返回元组，其中字符串分为三部分。
rsplit()	在指定的分隔符处拆分字符串，并返回列表。
rstrip()	返回字符串的右边修剪版本。
split()	在指定的分隔符处拆分字符串，并返回列表。
splitlines()	在换行符处拆分字符串并返回列表。
startswith()	如果以指定值开头的字符串，则返回 true。
strip()	返回字符串的剪裁版本。
swapcase()	切换大小写，小写成为大写，反之亦然。
title()	把每个单词的首字符转换为大写。
translate()	返回被转换的字符串。
upper()	把字符串转换为大写。
zfill()	在字符串的开头填充指定数量的 0 值。

字符串的拼接

res1 = 'hello'
res2 = 'world'
print(res1 + res2)  # 字符串支持加号拼接
print(res1 * 10)  # 字符串支持乘号重复

'''从可迭代对象中取出多个字符串，然后按照指定的分隔符进行拼接，拼接的结果为字符串'''
print(''.join(['hello', 'world', 'hahaha']))  # join方法拼接
print('|'.join(['hello', 'world', 'hahaha']))  # join方法拼接
print('$'.join(['jason', 'say', 666]))  # 列表中的数据都必须是字符串类型  报错!!!

字符串的格式化输出
format()

# format括号内在传参数时完全可以打乱顺序，但仍然能指名道姓地为指定的参数传值，name=‘tony’就是传给{name}
>>> str4 = 'my name is {name}, my age is {age}!'.format(age=18,name='tony')
>>> str4  
'my name is tony, my age is 18!'

>>> str4 = 'my name is {name}{name}{name}, my age is {name}!'.format(name='tony', age=18)
>>> str4  
'my name is tonytonytony, my age is tony!'

format()的其他使用方式

# 类似于%s的用法，传入的值会按照位置与{}一一对应
>>> str4 = 'my name is {}, my age is {}!'.format('tony', 18)
>>> str4 
my name is tony, my age is 18!

使用索引号 {0} 来确保参数被放在正确的占位符中：

# 把format传入的多个值当作一个列表，然后用{索引}取值
>>> str4 = 'my name is {0}, my age is {1}!'.format('tony', 18)
>>> str4
my name is tony, my age is 18!

>>> str4 = 'my name is {1}, my age is {0}!'.format('tony', 18)
>>> str4  
my name is 18, my age is tony!

>>> str4 = 'my name is {1}, my age is {1}!'.format('tony', 18)
>>> str4  
my name is 18, my age is 18!

f-string格式化字符串
f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去

>>> name = 'Runoob'
>>> f'Hello {name}'  # 替换变量
'Hello Runoob'
>>> f'{1+2}'         # 使用表达式
'3'

>>> w = {'name': 'kwan', 'url': 'https://home.cnblogs.com/u/yi-chun'}
>>> f'{w["name"]}: {w["url"]}'
'kwan: https://home.cnblogs.com/u/yi-chun'

strip(), lstrip(), rstrip()

>>> str1 = '**tony***'

>>> str1.strip('*')  # 移除左右两边的指定字符
'tony'
>>> str1.lstrip('*')  # 只移除左边的指定字符
tony***
>>> str1.rstrip('*')  # 只移除右边的指定字符
**tony

lower(),upper()

>>> str2 = 'My nAme is tonY！'

>>> str2.lower()  # 将英文字符串全部变小写
my name is tony！
>>> str2.upper()  # 将英文字符串全部变大写
MY NAME IS TONY！

startswith(),endswith()

>>> str3 = 'tony jam'

# startswith()判断字符串是否以括号内指定的字符开头，结果为布尔值True或False
>>> str3.startswith('t') 
True
>>> str3.startswith('j')
False
# endswith()判断字符串是否以括号内指定的字符结尾，结果为布尔值True或False
>>> str3.endswith('jam')
True
>>> str3.endswith('tony')  
False

split(),rsplit()

# split会按照从左到右的顺序对字符串进行切分，可以指定切割次数
>>> str5='C:/a/b/c/d.txt'
>>> str5.split('/',1)
['C:', 'a/b/c/d.txt']  

# rsplit刚好与split相反，从右往左切割，可以指定切割次数
>>> str5='a|b|c'
>>> str5.rsplit('|',1)
['a|b', 'c']

replace()

# 用新的字符替换字符串中旧的字符
>>> str7 = 'my name is tony, my age is 18!'  # 将tony的年龄由18岁改成73岁
>>> str7 = str7.replace('18', '73')  # 语法:replace('旧内容', '新内容')
>>> str7
my name is tony, my age is 73!

# 可以指定修改的个数
>>> str7 = 'my name is tony, my age is 18!'
>>> str7 = str7.replace('my', 'MY',1) # 只把一个my改为MY
>>> str7
'MY name is tony, my age is 18!'

isdigit()

# 判断字符串是否是纯数字组成，返回结果为True或False
>>> str8 = '5201314'
>>> str8.isdigit()
True

>>> str8 = '123g123'
>>> str8.isdigit()
False

列表相关方法

# 1.按索引存取值(正向存取+反向存取)：即可存也可以取  
# 1.1 正向取(从左往右)
>>> my_friends=['tony','jason','tom',4,5]
>>> my_friends[0]  
tony
# 1.2 反向取(负号表示从右往左)
>>> my_friends[-1]  
5
# 1.3 对于list来说，既可以按照索引取值，又可以按照索引修改指定位置的值，但如果索引不存在则报错
>>> my_friends = ['tony','jack','jason',4,5]
>>> my_friends[1] = 'martthow'
>>> my_friends
['tony', 'martthow', 'jason', 4, 5]


# 2.切片(顾头不顾尾，步长)
# 2.1 顾头不顾尾：取出索引为0到3的元素
>>> my_friends[0:4] 
['tony', 'jason', 'tom', 4]
# 2.2 步长：0:4:2,第三个参数2代表步长，会从0开始，每次累加一个2即可，所以会取出索引0、2的元素
>>> my_friends[0:4:2]  
['tony', 'tom']

# 3.长度
>>> len(my_friends)
5

# 4.成员运算in和not in
>>> 'tony' in my_friends
True
>>> 'xxx' not in my_friends
True

# 5.循环
# 循环遍历my_friends列表里面的值
for line in my_friends:
	print(line) 
'tony'
'jack'
'jason'
4
5

list内建方法

方法	描述
append()	在列表的末尾添加一个元素
clear()	删除列表中的所有元素
copy()	返回列表的副本
count()	返回具有指定值的元素数量。
extend()	将列表元素（或任何可迭代的元素）添加到当前列表的末尾
index()	返回具有指定值的第一个元素的索引
insert()	在指定位置添加元素
pop()	删除指定位置的元素
remove()	删除具有指定值的项目
reverse()	颠倒列表的顺序
sort()	对列表进行排序

list添加

append()列表尾部追加元素

>>> l1 = ['a','b','c']
>>> l1.append('d')
>>> l1
['a', 'b', 'c', 'd']

extend()一次性在列表尾部添加多个元素

>>> l1.extend(['a','b','c'])   # 括号里面必须是支持for循环的数据类型   for循环+append()
>>> l1
['a', 'b', 'c', 'd', 'a', 'b', 'c']

insert()在指定位置插入元素

>>> l1.insert(0,"first")  # 0表示按索引位置插值
>>> l1
['first', 'a', 'b', 'c', 'd', 'a', 'b', 'c']

删除

del

>>> l = [11,22,33,44]
>>> del l[2]  # 删除索引为2的元素
>>> l
[11,22,44]

pop()默认删除列表最后一个元素，并将删除的值返回，括号内可以通过加索引值来指定删除元素

>>> l = [11,22,33,22,44]
>>> res=l.pop()
>>> res
44
>>> res=l.pop(1)
>>> res
22

remove()括号内指名道姓表示要删除哪个元素，没有返回值

>>> l = [11,22,33,22,44]
>>> res=l.remove(22) # 从左往右查找第一个括号内需要删除的元素
>>> print(res)
None

reverse()颠倒列表内元素顺序

>>> l = [11,22,33,44]
>>> l.reverse() 
>>> l
[44,33,22,11]

sort()给列表内所有元素排序

# 排序时列表元素之间必须是相同数据类型，不可混搭，否则报错
>>> l = [11,22,3,42,7,55]
>>> l.sort()
>>> l 
[3, 7, 11, 22, 42, 55]  # 默认从小到大排序
>>> l = [11,22,3,42,7,55]
>>> l.sort(reverse=True)  # reverse用来指定是否跌倒排序，默认为False
>>> l 
[55, 42, 22, 11, 7, 3]

了解知识：

# 我们常用的数字类型直接比较大小，但其实，字符串、列表等都可以比较大小，原理相同：都是依次比较对应位置的元素的大小，如果分出大小，则无需比较下一个元素，比如
>>> l1=[1,2,3]
>>> l2=[2,]
>>> l2 > l1
True
# 字符之间的大小取决于它们在ASCII表中的先后顺序，越往后越大
>>> s1='abc'
>>> s2='az'
>>> s2 > s1 # s1与s2的第一个字符没有分出胜负，但第二个字符'z'>'b',所以s2>s1成立
True
# 所以我们也可以对下面这个列表排序
>>> l = ['A','z','adjk','hello','hea']
>>> l.sort()
>>> l
['A', 'adjk', 'hea', 'hello','z']

练习

# 1.基于字符串充当数据库完成用户登录(基础练习)
# 	data_source = 'jason|123'  # 一个用户数据
#   	获取用户用户名和密码 将上述数据拆分校验用户信息是否正确

data_source = 'jason|123'  # 一个用户数据

res = data_source.split('|')  # 切割字符串

while True:
    # 输入数据 获取数据
    user_name = input('请输入用户名：')
    user_pwd = input('请输入密码：')
    # 判断登录
    if user_name == res[0] and user_pwd == res[1]:
        print('登录成功！')
        break
    else:
        print('登录失败！')
        print('\n')


# 2.基于列表充当数据库完成用户登录(拔高练习)  # 多个用户数据
data_source = ['jason|123', 'kevin|321', 'oscar|222']

while True:
    # 获取数据
    user_name = input('请输入用户名：')
    user_pwd = input('请输入密码：')
    for i in data_source:   # 遍历数组
        # 判断登录
        if user_name == i.split('|')[0] and user_pwd == i.split('|')[1]:  # 验证 切割字符串
            print('登录成功！')
            break
    else:
        print('登录失败！')
        print('\n')

元组内置方法

元组是有序且不可更改的集合。元组是用圆括号括起来，中间元素用逗号隔开。

方法	描述
count()	返回元组中指定值出现的次数。
index()	在元组中搜索指定的值并返回它被找到的位置。

'''元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用'''

>>> tup1 = (50)
>>> type(tup1)     # 不加逗号，类型为整型
<class 'int'>

>>> tup1 = (50,)
>>> type(tup1)     # 加上逗号，类型为元组
<class 'tuple'>

使用

>>> tuple1 = (1, 'hhaha', 15000.00, 11, 22, 33) 
# 1、按索引取值(正向取+反向取)：只能取，不能改否则报错！  
>>> tuple1[0]
1
>>> tuple1[-2]
22
>>> tuple1[0] = 'hehe'  # 报错：TypeError:

# 2、切片(顾头不顾尾，步长)
>>> tuple1[0:6:2] 
(1, 15000.0, 22)

# 3、长度
>>> len(tuple1)  
6

# 4、成员运算 in 和 not in
>>> 'hhaha' in tuple1 
True
>>> 'hhaha' not in tuple1  
False 

# 5、循环
>>> for line in tuple1:
...     print(line)
1
hhaha
15000.0
11
22
33

del删除元组
元组中的元素值是不允许删除的，但可以使用del语句来删除整个元组

thistuple = ("kwan", "123", "lili")
del thistuple

print(thistuple) # 这会引发错误，因为元组已不存在。

字典相关方法

# 1、按key存取值：可存可取
# 1.1 取
>>> dic = {
...     'name': 'xxx',
...     'age': 18,
...     'hobbies': ['play game', 'basketball']
... }
>>> dic['name']
'xxx'
>>> dic['hobbies'][1]
'basketball'
# 1.2 对于赋值操作，如果key原先不存在于字典，则会新增key:value
>>> dic['gender'] = 'male'  
>>> dic
{'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball'],'gender':'male'}
# 1.3 对于赋值操作，如果key原先存在于字典，则会修改对应value的值
>>> dic['name'] = 'tony'
>>> dic
{'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball']}


# 2、长度len
>>> len(dic) 
3


# 3、成员运算in和not in
>>> 'name' in dic  # 判断某个值是否是字典的key
True


# 4、删除
>>> dic.pop('name')  # 通过指定字典的key来删除字典的键值对
>>> dic
{'age': 18, 'hobbies': ['play game', 'basketball']}


# 5、键keys()，值values()，键值对items()
>>> dic = {'age': 18, 'hobbies': ['play game', 'basketball'], 'name': 'xxx'}
# 获取字典所有的key
>>> dic.keys()  
dict_keys(['name', 'age', 'hobbies'])
# 获取字典所有的value
>>> dic.values()
dict_values(['xxx', 18, ['play game', 'basketball']])
# 获取字典所有的键值对
>>> dic.items()
dict_items([('name', 'xxx'), ('age', 18), ('hobbies', ['play game', 'basketball'])])


# 6、循环
# 6.1 默认遍历的是字典的key
>>> for key in dic:
...     print(key)
... 
age
hobbies
name
# 6.2 只遍历key
>>> for key in dic.keys():
...     print(key)
... 
age
hobbies
name
# 6.3 只遍历value
>>> for key in dic.values():
...     print(key)
... 
18
['play game', 'basketball']
xxx
# 6.4 遍历key与value
>>> for key in dic.items():
...     print(key)
... 
('age', 18)
('hobbies', ['play game', 'basketball'])
('name', 'xxx')

字典内建方法

方法	描述
clear()	删除字典中的所有元素
copy()	返回字典的副本
fromkeys()	创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
get()	返回指定键的值
items()	返回包含每个键值对的元组的列表
keys()	返回包含字典键的列表
pop()	删除字典 key（键）所对应的值，返回被删除的值。
popitem()	删除最后插入的键值对
setdefault()	返回指定键的值。如果该键不存在，则插入具有指定值的键。
update()	使用指定的键值对字典进行更新
values()	返回字典中所有值的列表

get()

>>> dic= {'k1':'kwan','k2':'Tony','k3':'JY'}
>>> dic.get('k1')
'kwan'  # key存在，则获取key对应的value值
>>> res=dic.get('xxx') # key不存在，不会报错而是默认返回None
>>> print(res)
None  
>>> res=dic.get('xxx',666) # key不存在时，可以设置默认返回的值
>>> print(res)
666 
# ps:字典取值建议使用get方法

pop()

>>> dic= {'k1':'kwan','k2':'Tony','k3':'JY'}
>>> v = dic.pop('k2')  # 删除指定的key对应的键值对,并返回值
>>> dic
{'k1': 'kwan', 'kk2': 'JY'}
>>> v
'Tony'

popitem()

>>> dic= {'k1':'kwan','k2':'Tony','k3':'JY'}
>>> item = dic.popitem()  # 删除最后插入一组键值对,并将删除的键值放到元组内返回
>>> dic
{'k3': 'JY', 'k2': 'Tony'}
>>> item
('k1', 'kwan')

update()

# 修改字典数据   键存在则是修改  键不存在则是新增
>>> dic= {'k1':'kwan','k2':'Tony','k3':'JY'}
>>> dic.update({'k1':'JN','k4':'xxx'})
>>> dic
{'k1': 'JN', 'k3': 'JY', 'k2': 'Tony', 'k4': 'xxx'}

fromkeys()

>>> dic = dict.fromkeys(['k1','k2','k3'],[])
>>> dic
{'k1': [], 'k2': [], 'k3': []}



# 快速构造字典  给的值默认情况下所有的键都用一个
res = dict.fromkeys([1, 2, 3], None)
print(res)  # {1: None, 2: None, 3: None}

new_dict = dict.fromkeys(['name', 'pwd', 'hobby'], [])  # {'name': [], 'pwd': [], 'hobby': []}

new_dict['name'] = []
new_dict['name'].append(123)

# new_dict['pwd'].append(123)   # 'pwd': [123, 'read']
# new_dict['hobby'].append('read')  # 'hobby': [123, 'read']

print(new_dict)   # {'name': [123], 'pwd': [], 'hobby': []}

setdefault()

# 键存在则获取键对应的值 键不存在则设置 并返回设置的新值
car = {
  "brand": "Porsche",
  "model": "911",
  "year": 1963
}

x = car.setdefault("color", "white")

print(x)

集合相关方法

集合的关系运算

# 1.合集(|)：求两个用户所有的好友（重复好友只留一个）
>>> friends1 | friends2
{'kevin', 'ricky', 'zero', 'kwan', 'Jy', 'oscar'}

# 2.交集(&)：求两个用户的共同好友
>>> friends1 & friends2
{'kwan', 'oscar'}

# 3.差集(-)：
>>> friends1 - friends2 # 求用户1独有的好友
{'kevin', 'zero'}
>>> friends2 - friends1 # 求用户2独有的好友
{'ricky', 'Jy'}

# 4.对称差集(^) # 求两个用户独有的好友们（即去掉共有的好友）
>>> friends1 ^ friends2
{'kevin', 'zero', 'ricky', 'Jy'}

# 5.值是否相等(==)
>>> friends1 == friends2
False

# 6.父集：一个集合是否包含另外一个集合
# 6.1 包含则返回True
>>> {1,2,3} > {1,2}
True
>>> {1,2,3} >= {1,2}
True
# 6.2 不存在包含关系，则返回True
>>> {1,2,3} > {1,3,4,5}
False
>>> {1,2,3} >= {1,3,4,5}
False


# 7.子集
>>> {1,2} < {1,2,3}
True
>>> {1,2} <= {1,2,3}
True

去重
集合去重复有局限性

只能针对不可变类型
集合本身是无序的，去重之后无法保留原来的顺序

>>> l=['a','b',1,'a','a']
>>> s=set(l)
>>> s # 将列表转成了集合
{'b', 'a', 1}
>>> l_new=list(s) # 再将集合转回列表
>>> l_new
['b', 'a', 1] # 去除了重复，但是打乱了顺序

# 针对不可变类型，并且保证顺序则需要我们自己写代码实现，例如
l=[
    {'name':'lili','age':18,'sex':'male'},
    {'name':'jack','age':73,'sex':'male'},
    {'name':'tom','age':20,'sex':'female'},
    {'name':'lili','age':18,'sex':'male'},
    {'name':'lili','age':18,'sex':'male'},
]

new_l=[]

for dic in l:
    if dic not in new_l:
        new_l.append(dic)

print(new_l)
# 结果：既去除了重复，又保证了顺序，而且是针对不可变类型的去重
[
    {'age': 18, 'sex': 'male', 'name': 'lili'}, 
    {'age': 73, 'sex': 'male', 'name': 'jack'}, 
    {'age': 20, 'sex': 'female', 'name': 'tom'}
]

集合内建方法

方法	描述
add()	向集合添加元素。
clear()	删除集合中的所有元素。
copy()	返回集合的副本。
difference()	返回包含两个或更多集合之间差异的集合。
difference_update()	删除此集合中也包含在另一个指定集合中的项目。
discard()	删除指定项目。
intersection()	返回为两个其他集合的交集的集合。
intersection_update()	删除此集合中不存在于其他指定集合中的项目。
isdisjoint()	返回两个集合是否有交集。
issubset()	返回另一个集合是否包含此集合。
issuperset()	返回此集合是否包含另一个集合。
pop()	从集合中删除一个元素。
remove()	删除指定元素。
symmetric_difference()	返回具有两组集合的对称差集的集合。
symmetric_difference_update()	插入此集合和另一个集合的对称差集。
union()	返回包含集合并集的集合。
update()	用此集合和其他集合的并集来更新集合。

添加

add()

# 将一个项添加到集合
>>> thisset = {"apple", "banana", "cherry"}
>>> thisset.add("orange")
>>> print(thisset)
{'apple', 'banana', 'cherry', 'orange'}

update()

# 将多个项添加到集合中
>>> thisset = {"apple", "banana", "cherry"}
>>> thisset.update(["orange", "mango", "grapes"])
>>> print(thisset)
{'mango', 'orange', 'apple', 'banana', 'cherry', 'grapes'}

删除

remove()

>>> thisset = {"apple", "banana", "cherry"}
>>> thisset.remove("banana")
>>> print(thisset)
{'apple', 'cherry'}

# ps:如果要删除的项目不存在，则 remove() 将引发错误。

discard()

>>> thisset = {"apple", "banana", "cherry"}
>>> thisset.discard("banana")
>>> print(thisset)
{'apple', 'cherry'}

# 如果要删除的项目不存在，则 discard() 不会引发错误。

pop()

# 集合是无序的，在使用 pop() 方法时，随机删除项目
>>> thisset = {"apple", "banana", "cherry"}
>>> x = thisset.pop()
>>> print(x)
apple
>>> print(thisset)
{'banana', 'cherry'}

clear()

# 清空集合
>>> thisset = {"apple", "banana", "cherry"}
>>> thisset.clear()
>>> print(thisset)
set()

del

# 彻底删除集合
>>> thisset = {"apple", "banana", "cherry"}
>>> del thisset
>>> print(thisset)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'thisset' is not defined

练习

# 1.利用列表编写一个员工姓名管理系统
# 	输入1执行添加用户名功能
# 	输入2执行查看所有用户名功能
#  	输入3执行删除指定用户名功能
# 	ps:思考如何让程序循环起来并且可以根据不同指令执行不同操作
# 	提示: 循环结构 + 分支结构
# 	拔高: 是否可以换成字典或者数据的嵌套使用完成更加完善的员工管理而不是简简单单的一个用户名(能写就写 不会没有关系)

employee_data = []

while True:
    inp_num = input('请输入需要执行的指令：')
    if inp_num.isdigit():
        inp_num = int(inp_num)
        if inp_num == 1:
            add_name = input('请输入需添加的用户名：').strip()
            employee_data.append(add_name)
            print('已成功添加！')
        elif inp_num == 2:
            print(employee_data)
        elif inp_num == 3:
            del_name = input('请输入需要删除的用户名：')
            if del_name in employee_data:
                employee_data.remove(del_name)
                print('已成功删除 %s' % del_name)
            else:
                print('没有这个用户！')
        else:
            print('请输入正确的指令！')
    else:
        print('操作失败！请输入正确的指令！')

while True:
    inp_num = input('请输入需要执行的指令：')
    if inp_num.isdigit():
        inp_num = int(inp_num)
        print(inp_num, type(inp_num))
        break
    else:
        print('操作失败！请输入正确的指令！')
        print()


# 2.去重下列列表并保留数据值原来的顺序
# 	eg: [1,2,3,2,1] 去重之后 [1,2,3]
# 	l1 = [2,3,2,1,2,3,2,3,4,3,4,3,2,3,5,6,5]

l1 = [2, 3, 2, 1, 2, 3, 2, 3, 4, 3, 4, 3, 2, 3, 5, 6, 5]

new_l1 = []

for data in l1:
    if data not in new_l1:
        new_l1.append(data)

print(new_l1)


# 3.有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
pythons = {'jason', 'oscar', 'kevin', 'ricky', 'gangdan', 'biubiu'}
linuxs = {'kermit', 'tony', 'gangdan'}

# 　　1. 求出即报名python又报名linux课程的学员名字集合
print(pythons & linuxs)

# 　　2. 求出所有报名的学生名字集合
print(pythons | linuxs)

# 　　3. 求出只报名python课程的学员名字
print(pythons - linuxs)

# 　　4. 求出没有同时这两门课程的学员名字集合
print(pythons ^ linuxs)

posted @ 2022-06-26 16:59 梦想有双休阅读(290) 评论(0) 收藏举报

刷新页面返回顶部

yi-chun