8_python笔记-元组-字典-集合

8_python笔记-元组-字典-集合


博客cpen_web

知识点1 容器类型 - 列表 回顾

知识点2 练习

有一个列表[‘python’, ‘Java’, ‘C’ ]
·向列表中追加一个元素:‘我是追加’
·删除第一个元素和最后一个元素
·判断”Cali”是否在列表里
·知道列表元素的总数
·插入一个子列表[‘liu’,‘cali’,123,456]到父列表的第2个元素位置

示例

lst = ['python', 'Java', 'C']
# 追加
lst.append("我是追加")
# 删除
del lst[0]
del lst[-1]
# 判断
if "Cali" in lst:
    print('"Cali"在列表里')
else:
    print('"Cali"不在列表里')
# 元素总数
print(f"元素总数:{len(lst)}")
# 插入子列表
lst.insert(1,['liu','cali',123,456])

知识点3 元组(tuple)

什么是元组
·元组是处理一组有序项目的数据结构
·元组和字符串一样是不可变的 , 即你不能修改元组
·元组可以包含任何类型的对象:字符串、数字甚至其他列表
·适应场景:性别选择,数据库的查询结果
·Example: 表示一个购物清单
·goods= (‘牛奶’、‘运动鞋’、‘咖啡’、‘手机’、‘羊肉’、‘葡萄’、‘桔子’)

示例

>>> a = ()
>>> type(a)
<class 'tuple'>
>>> a = (1)			#(注:括号还可以代表集合)
>>> type(a)
<class 'int'>

元组中只有一个元素的时候,需要在元素后面加个,区分这个括号是表示结合还是表示元组

>>> a = (1,)			#(注:元组中只有1个元素时,需要加逗号(,)表示元组)
>>> type(a)
<class 'tuple'>

知识点4

>>> a = tuple()		(注:定义空元组)
>>> type(a)
<class 'tuple'>
>>> a
()

知识点5 元组基本操作

·索引
·切片
·统计
·查下标
·遍历
·成员关系

知识点6 元组基本操作 - 索引

索引
·通过下标访问列表中的元素,下标从0开始计数,可取出一个元素
·正索引、负索引
·注意:下标不能越界(IndexError: list index out of range)

示例:下标不能越界,越界会报错

>>> a = ("a",1,1.2,True,print)
>>> a[5]
	Traceback (most recent call last):
  	File "<stdin>", line 1, in <module>
	IndexError: tuple index out of range

示例:索引

>>> a = ("a",1,1.2,True,print)
>>> a[4]
<built-in function print>
>>> a[3]
True

知识点7 元组基本操作 - 切片

切片
·切片是通过下标访问元组中的元素,切片可以取出一个子元组
·格式:sample[start🔚step]
·起止区间:[ start, end )
·step : 默认=> 1
·start: 默认=> step为正时,start为0;step为负时, start为-1
·end : 默认=> step为正时,end为列表结尾;step为负时, end为列表开始
·注意:三个值都为选填项
·正切片
·负切片
·起始位置有误时,切出来会是空(不会报错)
·切片对象(slice函数)
slice函数的用途:生成一个slice对象,相当于可以给要切的内容取个名字。

示例:切片

>>> a = ("a",1,1.2,True,print)
>>> a[1:3]
(1, 1.2)

知识点8 元组基本操作 - 不可变性

示例:不可变性

>>> a
('a', 1, 1.2, True, <built-in function print>)
>>> a[0] = 1					#(注:报错)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> tu1 = (1,2)
>>> tu2 = (3,4)
>>> tu3 = tu1 + tu2
>>> tu3
(1, 2, 3, 4)

知识点9 元组包含列表时 列表可以改变

元组里面包含列表,列表可以改变
只要列表的内存地址没变,对于元组来说 没有变化

示例

>>> a = ()
>>> b = [1,2,3]			#(注:b 列表)
>>> a = (1,2,3)			#(注:a 元组)
>>> a = (1,2,3,b)			#(注:元组里包含列表)
>>> a
(1, 2, 3, [1, 2, 3])
>>> a[3][0]				#(注:元组第4个元素,该元素下第1个子元素)
1						#(注:[1, 2, 3])
>>> a = (1,2,3)
>>> b = ["a","b","c"]
>>> a = (1,2,3,b)
>>> a
(1, 2, 3, ['a', 'b', 'c'])
>>> a[3][0]
'a'
>>> a[3][0] = "x"			#(注:元组里的 列表 发生替换  元组本身不变)
>>> a
(1, 2, 3, ['x', 'b', 'c'])

知识点10 元组基本操作 - 统计

统计

示例:统计

>>> a = ('a','b','c')
>>> print(len(a))
3

知识点11 元组基本操作 - 遍历元组

遍历元组

示例:遍历元组

>>> a = [1,2,3]
>>> for i in enumerate(a):
...     print(i)
... 
(0, 1)		#(注:返回值 是 元组)
(1, 2)
(2, 3)
>>> for i,j in enumerate(a):
...     print(f"{i}---{j}")		#(注:用两个参数 来接收 返回值)
... 
0---1
1---2
2---3

知识点12 元组基本操作 - 成员关系

成员关系: in , not in

示例

>>> a = ("a","b","c")
>>> "a" in a
True
>>> "d" not in a
True

知识点13 列表与元组的异同

相同点

·序列的两个主要特点是索引操作符和切片操作符
·索引操作符让我们可以从序列中抓取一个特定项目。
·切片操作符让我们能够获取序列的一个切片,即一部分序列。
不同点
·list : 可变对象
·tuple: 不可变对象,不能增加修改删除
·tuple中嵌套list时,list是可修改的

列表与元组的异同

相同点:
1、都是一组有序项目数据结构
2、都可以包含任意类型数据对象
不同点:
1、列表是可变数据类型
2、元组是不可变数据类型。元组一旦被定义,就不能做修改
3、元组中包含列表,列表中的值是可以被修改的

知识点14 列表与元组 的 相互转换

list和tuple的相互转换

示例

>>> a = (1,2,3)
>>> b = list(a)		#(注:元组转列表)
>>> b
[1, 2, 3]
>>> c = tuple(b)		#(注:列表转元组)
>>> c
(1, 2, 3)

字符串转元组

>>> a = tuple('abc')	#(注:字符串转元组)
>>> a
('a', 'b', 'c')

练习15 用户检测小工具

用户检测小工具
·欢迎语:”欢迎使用用户检测系统“
·定义一个用户列表,包含用户名密码:[(‘root’, ‘123456’), (‘admin’, ‘admin’),]
·键盘输入用户名、密码
·判断并验证用户密码,并给予相应提醒

示例

print("欢迎使用用户检测系统")
lst = [('root', '123456'), ('admin', 'admin')]
username = input("请输入用户名:")
passwd = input("请输入密码:")
if (username, passwd) in lst:		#(注:* )
    print("登录成功!")
else:
    print("登录失败!")

知识点16 字典 dict

(注:一一对应的关系 用字典保存)

什么是字典( dict )

·字典是Python中一个键值映射的数据结构 (注:{key:value})
·字典是无序的 (注:不能通过切片去获取)
·字典是可变对象
·key必须是唯一的, 天生去重
·example:
singer = { key1:value , key2:value }
singer = {“李圣杰”: ‘痴心绝对’, ‘张韶涵’: ‘阿刁’, ‘汪峰’:‘普通迪斯高’}

知识点17 字典的定义

字典的定义
·字典通过花括号中用键/值对用冒号分割,而各个对 用逗号分割
·定义空字典

示例

# 方法1:
>>> a = {}		#(注:定义空字典)
# 方法2:
>>> b = dict()	#(注:定义空字典,工厂函数)
>>> type(a)
<class 'dict'>
>>> type(b)
<class 'dict'>
>>> c = [('root','123456'),('admin','admin')]
>>> d = dict(c)		#(注:列表转换成字典) (注:工厂函数)
>>> d
{'root': '123456', 'admin': 'admin'}
>>> e = [1,2,3]
>>> e
[1, 2, 3]
>>> dict(e)			#(注:注:转换的对象要有 键值映射 的格式)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: cannot convert dictionary update sequence element #0 to a sequence

知识点18 字典是无序的

Python3.6之后,字典的存储做了优化
[root@localhost ~]# python3

>>> a = {'a':1, 'b':2, 'c':3}                                                                                                
>>> a
{'a': 1, 'b': 2, 'c': 3}
>>> 

(注:python3.6后 做了小优化。但还是无序的)
[root@localhost ~]# python2

>>> a = {'a':1, 'b':2, 'c':3}
>>> a
{'a': 1, 'c': 3, 'b': 2}

知识点19 字典的定义

字典的key必须是可hash对象 (注:不可变数据类型)
python中所有字符串、数字、元组、布尔值、None都是可hash对象
字典的value可以是任何值

可hash对象一般指不可变数据类型

>>> a = {True:2}
>>> a
{True: 2}
>>> a = {True:2,"ab":2}
>>> a = {True:2,"ab":2,3:4}
>>> a
{3: 4, True: 2, 'ab': 2}
>>> a = {True:2,"ab":2,3:4,[1,2]:5}	#(注:列表不是可hash对象,不能作为key)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

总结

字典、列表不能作为key
函数也可以作为key

>>> a = {True:2,"ab":2,3:4,(3,4):6,print:4}

重复定义key,只会取最后一次定义的数值

>>> b = {"a":1,"b":2,"a":3}
>>> b
{'a': 3, 'b': 2}

知识点20 字典基本操作

查看
新增
删除
遍历
统计长度
成员关系

知识点21 字典基本操作 - 取值

取值
用法1:dicts[key] => 当key不存在时,会报错

  • 用法2:dict.get(key,default) => 当key不存在时,返回default值

示例

>>> a = {"a":4,"b":2}
>>> a['a']=3			#(注:修改key=”a”的 value 值)
>>> a
{'a': 3, 'b': 2}
>>> a['c']=4			#(注:增加键值对)
>>> a
{'a': 3, 'b': 2, 'c': 4}
>>> a['c']			#(注:取值)
4
>>> a['d']			#(注:key不存在,报错)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'd'

推荐:
用法2 dict.get(key,default)
获取key的值,获取不到就返回默认default的值
容错率高
推荐使用get
获取到d 把d的值输出
获取不到d的值 输出默认值

示例

>>> a
{'a': 3, 'b': 2, 'c': 4}
>>> a.get('d')		#(注:不报错)
>>> c = a.get('d')
>>> print(c)
None					#(注:默认值没有设置)

(注:获取到d 把d的值输出
获取不到d的值 输出默认值)

>>> a
{'a': 3, 'b': 2, 'c': 4}
>>> c = a.get('d',0)
>>> c
0					#(注:返回默认值)
>>> c = a.get('a',0)
>>> c
3					#(注:获取到a,输出a的值)

知识点22 字典基本操作 - 增加/修改

增加/修改
用法1:dicts[key] = value
·当key不存在时,表示增加一个键值对
·当key存在时, 表示修改对应的value值
示例如下:

示例:修改

>>> a
{'a': 3, 'b': 2, 'c': 4}
>>> a['a'] = 5
>>> a
{'a': 5, 'b': 2, 'c': 4}

示例:新增

>>> a['d'] = False
>>> a
{'a': 5, 'b': 2, 'c': 4, 'd': False}

知识点23 字典基本操作 - 删除

删除
·用法1:dicts.pop(key)
·用法2:dicts.popitem()
示例如下:

示例:dicts.pop(key)

>>> a = {'a':5,'b':2,'c':4,'d':False}
>>> a.pop('a')		(注:删除 key=‘a’ 的元素)
5					(注:pop有返回值)
>>> c = a.pop('b')		(注:获取返回值)
>>> c
2
>>> a
{'c': 4, 'd': False}

示例:dicts.popitem()

·python3里面删除的是最后一个

>>> a = {"x":1,"y":2,"z":3}
>>> a.popitem()
('z', 3)
>>> a.popitem()
('y', 2)
>>> a.popitem()
('x', 1)			

(注:python3.6后做了优化,python3输入的是什么样子,存放在内存里面就什么样子,但还是无序的)
(注:python3里面删除的是最后一个)
字典 不属于有序集合,不能使用索引切片

示例:python2 dicts.popitem()

>>> a = {"x":1,"y":2,"z":3,"p":4,"s":2,"o":1}
>>> a
{'o': 1, 'p': 4, 's': 2, 'y': 2, 'x': 1, 'z': 3}
>>> a.popitem()     #(注:python2类似于随机删除)
('o', 1)
>>> a.popitem()
('p', 4)
>>> a.popitem()
('s', 2)
>>> a.popitem()
('y', 2)
>>> a.popitem()
('x', 1)
>>> a.popitem()
('z', 3)

知识点24 字典基本操作 - 合并字典

合并字典
用法1:dict1.update(dict2) => 将dict2合并到dict1
用法2:dict(dict1, **dict2) => 将dict1与dict2合并生成一个新字典

示例:dict1.update(dict2)

>>> a = {"x":1,"y":3}
>>> b = {"q":2,"w":3}
>>> a.update(b)	#(注:a自带的属性)
>>> a
{'x': 1, 'y': 3, 'q': 2, 'w': 3}
>>> b
{'q': 2, 'w': 3}

示例:dict(dict1, **dict2)

>>> a = {"x":1,"y":3}
>>> b = {"q":2,"w":3}
>>> dict(a,**b)	#(注:工厂函数,返回一个字典  a和b的合并)
{'x': 1, 'y': 3, 'q': 2, 'w': 3}
>>> a	#(注:a本身没有改变)
{'x': 1, 'y': 3}
>>> dict()
{}
>>> c = dict(a,**b)
>>> c
{'x': 1, 'y': 3, 'q': 2, 'w': 3}

知识点24.2 **a

>>> a = {"x":1,"y":3}
>>> d = {3:'a',4:'b'}
>>> dict(a,**d)	#(注:key为 字符串和数字 混合  会报错)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: keyword arguments must be strings
>>> a.update(d)	#(注:key为 字符串和数字 混合  不会报错)
>>> a
{'x': 1, 'y': 3, 3: 'a', 4: 'b'}

解释:
因为用dict去定义,相当于生成1个新字典

d = {3:'a',4:'b'}
dict(a,**d)
dict(a,3='a',4='b')

**d的含义:
**d ==> 3=‘a’,4=‘b’
标识符不能数字开头

示例

>>> dict(a,str1 = 2)
{'x': 1, 'y': 3, 3: 'a', 4: 'b', 'str1': 2}

同样的:
元组的定义不符合标识符的定义

>>> e = {(1,2):"元组"}
>>> dict(a,**e)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: keyword arguments must be strings

知识点25 **a 的使用

**a 的使用

>>> a = {"name":"wen","age":18}
>>> print("my name is {name}, my age is {age}".format(name='wen',age=18))
my name is wen, my age is 18
>>> print("my name is {name}, my age is {age}".format(name=a["name"],age=a["age"]))
my name is wen, my age is 18
>>> print("my name is {name}, my age is {age}".format(**a))
my name is wen, my age is 18

总结

**a作为一个参数传进去
**a ==> name=”wen”,age=18
Python里面的 unpack操作 (解包操作)
解包操作 字典—{“a”:1,“b”:2}——> a=1,b=2 一般作为形参

示例

def dict_test(x,y):                 # 传x, y两个参数
    print(f"x is {x}, y is {y}")

a = {"x":"xxxxx","y":"yyyyyyy"}
dict_test(x="123",y="456")	# x is 123, y is 456
dict_test(x = a['x'],y = a['y'])	# x is xxxxx, y is yyyyyyy
dict_test(**a)      # ** 解包字典	# x is xxxxx, y is yyyyyyy

dict_test(1,2)	# x is 1, y is 2

b = [3,4]
dict_test(1,2)	# x is 1, y is 2
dict_test(*b)       # * 解包列表	# x is 3, y is 4
dict_test(3,4)	# x is 3, y is 4

c = ('a','b')
dict_test(*c)        # 解包元组	# x is a, y is b

x is 123, y is 456
x is xxxxx, y is yyyyyyy
x is xxxxx, y is yyyyyyy
x is 1, y is 2
x is 1, y is 2
x is 3, y is 4
x is 3, y is 4
x is a, y is b

知识点26 字典基本操作 - 成员关系

成员关系
用法:
item in dicts
item not in dicts
默认的成员关系 对比的是key值
想对比value值 用.values()去获取

示例

>>> a = {"x":1,"y":2,"z":3}
>>> a
{'x': 1, 'y': 2, 'z': 3}
>>> 'x' in a		#(注:in  默认 对比的是key值)
True
>>> 2 in a
False
>>> 2 in a.values()		#(注:a.values()对比的是value值)
True

知识点27 字典基本操作 - 遍历字典

遍历字典
默认遍历的是 key

示例

>>> a
{'x': 1, 'y': 2, 'z': 3}

示例:遍历key值

# 示例:遍历key值
>>> for i in a:
...     print(i)
... 
x              #(注:遍历key值)
y
z
>>> a.keys()
dict_keys(['x', 'y', 'z'])
>>> a.values()
dict_values([1, 2, 3])

示例:遍历value值

>>> for i in a.values():
...     print(i)
... 
1               #(注:遍历value值)
2
3

既想获得key 也想获得value
3种方式
items返回的是元组

方式1

>>> for i in a.items():
...     print(i)
... 
('x', 1)
('y', 2)
('z', 3)

方式2

>>> for i,j in a.items():	#(注:2个参数获取返回值key,value)
...     print(f"key is {i}, value is {j}")
... 
key is x, value is 1
key is y, value is 2
key is z, value is 3

方式3

>>> for i in a.items():
...     print(f"key is {i[0]}, value is {i[1]}")	#(注:索引获取参数)
... 
key is x, value is 1
key is y, value is 2
key is z, value is 3

练习28 字典练习

字典练习
company={ ‘BOSS’:‘唐僧’,‘CTO’:‘悟空’,‘CFO’: ‘八戒’, ‘搬砖’:‘沙僧’, ‘苦力’:‘白龙马’ }
·打印CTO信息
·打印BOSS信息
·打印company中所有人物及角色,结果示例:CTO是悟空
·判断悟空白骨精(接收用户输入)是否在company中

示例

company = {'BOSS':'唐僧','CTO':'悟空','CFO':'八戒','搬砖':'沙僧','苦力':'白龙马'}
# 1、2
print(company.get('CTO'))
print(company.get('BOSS'))
# 3
for i in company.items():
    print(f"{i[0]}是{i[1]}")
# 4
character = input("请输入人物:")
if character in company.values():
    print(f"{character}在company中")
else:
    print(f"{character}不在company中")

练习29 用户检测

用户检测(无限次)
·欢迎语:”欢迎使用用户检测系统“
·定义一个用户表,包含用户名密码:
·{‘root’:‘123456’, ‘admin’:‘admin’}
·键盘输入用户名、密码
·判断并验证用户密码,并给予相应提醒(验证成功/验证失败)
·当用户输入的值为‘quit’的时候,退出查找

示例

print("欢迎使用用户检测系统")
user_table = {'root': '123456', 'admin': 'admin'}
while True:
    username = input("请输入用户名:")
    passwd = input("请输入密码:")
    if username in user_table:
        if passwd == user_table[username]:
            print("登录成功")
            break
        else:
            print("账号错误,请重新输入!")
    exit = input("输入exit退出:")
    if exit == "exit":
        print("退出查找!")
        break

知识点30 集合( set )

什么是集合( set )

·集合是一个无序的,不重复的数据组合
·集合是一个只含有key的字典

集合的作用

·去重:把一个列表变成集合,就自动去重了
·关系测试:测试两组数据之前的交集、差集、并集等关系
·example:
singer = {“李圣杰”, ‘张韶涵’, ‘汪峰’}

知识点31 集合的定义

集合的定义
·集合通过花括号中,而各个元素用逗号分割
·定义集合
·集合元素必须是可hash对象,跟字典一样
·set和dict的唯一区别仅在于没有存储对应的value

示例:定义空集合(2种方式)

>>> a = {1,2,3}	#(注:第1种方式)
>>> type(a)
<class 'set'>
>>> a = set()	#(注:第2种方式)
>>> a
set()
>>> type(a)
<class 'set'>

知识点32 集合转换

>>> a = set("abc")	#(注:str转换成set)
>>> a
{'c', 'b', 'a'}
>>> a = set([1,2,3])	#(注:list转换成set)
>>> a
{1, 2, 3}
>>> a = set((1,2,3,4))	#(注:tuple转换成set)
>>> a
{1, 2, 3, 4}
>>> a = set({'x':1,'y':2})	#(注:dict转换成set)
>>> a
{'y', 'x'}	#(注:返回key值)

可迭代的对象,都可以转换成 集合
可以用for循环遍历的,都是可迭代的
list tuple set 都是可迭代的
集合元素必须是可hash对象,跟字典一样
set和dict的唯一区别仅在于没有存储对应的value
集合元素必须是可hash对象,跟字典一样(注:可hash 不可变数据类型)

>>> a = {"x",[1]}	#(注:;列表 可变数据类型 报错)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

知识点33 去重(set)

去重:把一个列表变成集合,就自动去重了

示例

>>> a = [1,2,3,1,2,2]
>>> set(a)		#(注:列表的去重)
{1, 2, 3}
>>> list(set(a))		#(注:集合转换成列表)
[1, 2, 3]
>>> list(1)		#(注:list()参数不能是数字)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable
>>> list({"x":1,"y":2})	#(注:取 key值)
['x', 'y']

list()函数可以传的参数有: (注:list() 工厂函数)
集合、字典、列表、字符串、元组(可迭代对象[for循环遍历])
数字不可以传(数字不能迭代)
set()、tuple()同理
字典dict()有key,value的对应关系。需要有这样的关系,才能转化
String 也属于 容器类型 ,可迭代
str()是工厂函数,万物接可str

>>> str(True)
'True'
>>> str({"x":1})
"{'x': 1}"

现在学的容器类型 是可迭代对象

知识点34 dict() 转换成字典

字典dict()有key,value的对应关系。需要有这样的关系,才能转化

示例

>>> a = [("a",1),("b",2)]	#(注:列表里面放元组)
>>> dict(a)	#(注:转换成字典)
{'a': 1, 'b': 2}
>>> a = (("a",1),("b",2))	#(注:元组里面放元组)
>>> dict(a)	#(注:转换成字典)
{'a': 1, 'b': 2}

知识点35 集合基本操作 - 添加

添加
·用法: s.add(item) => 添加一项
·用法: s.update(someitems) => 添加多项

示例

>>> s = {1,2,3}
>>> s.add(4)
>>> s
{1, 2, 3, 4}
>>> s.update("str")	#(注:str被扩展进来,是一个一个被扩展进来的)
>>> s
{1, 2, 3, 4, 't', 'r', 's'}
>>> s.update({"x":1,"y":2})	#(注:字典  扩展的是 key值)
>>> s
{1, 2, 3, 4, 'x', 't', 'y', 'r', 's'}

列表 的 添加 (注:同理)

>>> lst = [1,2]
>>> lst.extend((3,4))	#(注:同理)
>>> lst
[1, 2, 3, 4]
>>> lst.extend({"x":1,"y":2})	#(注:同理)
>>> lst
[1, 2, 3, 4, 'x', 'y']

知识点36 集合基本操作 - 移除

移除
·用法1: s.remove (item) => 移除一项(item不存在会报错)

  • ·用法2: s.discard(item) => 移除一项(item不存在则什么也不做) (注:推荐)

示例

>>> s
{1, 2, 3, 4, 'x', 't', 'y', 'r', 's'}
>>> s.remove('r')
>>> s
{1, 2, 3, 4, 'x', 't', 'y', 's'}
>>> s.remove('p')	#(注:“p”不存在,报错)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'p'
>>> s
{1, 2, 3, 4, 'x', 't', 'y', 's'}
>>> s.discard('o')	#(注:不存在 不报错  什么也不做)
>>> s.discard('x')
>>> s
{1, 2, 3, 4, 't', 'y', 's'}

知识点37 集合基本操作 - 集合操作

创建集合

示例

>>> set('hello')
{'e', 'o', 'l', 'h'}

注:自动去重

练习38 set()函数自动去重

查看字符串 特定字符 出现了多少次

示例

str = input("请输入字符串:")
str_set = set(str)		#(注:去重)
for i in str_set:		
    print(f"{i}出现了{str.count(i)}")

知识点39 集合基本操作 - 集合操作

并集、交集、差集、对称差集
并集:t 和 s的并集 ,返回一个新的 set 包含 s 和 t 中的每一个元素
s1 | s2
s1.union(s2)
交集: t 和 s的交集 , 返回一个新的 set 包含 s 和 t 中的公共元素
s1 & s2
差集: 返回一个新的 set 包含 s 中有但是 t 中没有的元素
s1 - s2
对称差集: 返回一个新的 set 包含 s 和 t 中不重复的元素(在t或s中,但不会同时出现在二者中)
s1 ^ s2
示例如下:

示例:并集

>>> s1 = {1,2,3}
>>> s2 = {2,3,4}
>>> s1 | s2
{1, 2, 3, 4}
>>> s1.union(s2)
{1, 2, 3, 4}

示例:交集

>>> s1 = {1,2,3}
>>> s2 = {2,3,4}
>>> s1 & s2
{2, 3}
>>> s1.intersection(s2)
{2, 3}

示例:差集

>>> s1 = {1,2,3}
>>> s2 = {2,3,4}
>>> s1 - s2
{1}

注:s1里面有的,s2里面没有的

>>> s2 - s1
{4}

对称差集

>>> s1 = {1,2,3}
>>> s2 = {2,3,4}
>>> s1 ^ s2
{1, 4}

(注:除了交集 的部分)

92讲视频课+16大项目实战+源码+¥800元课程礼包+讲师社群1V1答疑+社群闭门分享会=99元   为什么学习数据分析?       人工智能、大数据时代有什么技能是可以运用在各种行业的?数据分析就是。       从海量数据中获得别人看不见的信息,创业者可以通过数据分析来优化产品,营销人员可以通过数据分析改进营销策略,产品经理可以通过数据分析洞察用户习惯,金融从业者可以通过数据分析规避投资风险,程序员可以通过数据分析进一步挖掘出数据价值,它和编程一样,本质上也是一个工具,通过数据来对现实事物进行分析和识别的能力。不管你从事什么行业,掌握了数据分析能力,往往在其岗位上更有竞争力。    本课程共包含五大模块: 一、先导篇: 通过分析数据分析师的一天,让学员了解全面了解成为一个数据分析师的所有必修功法,对数据分析师不在迷惑。   二、基础篇: 围绕Python基础语法介绍、数据预处理、数据可视化以及数据分析与挖掘......这些核心技能模块展开,帮助你快速而全面的掌握和了解成为一个数据分析师的所有必修功法。   三、数据采集篇: 通过网络爬虫实战解决数据分析的必经之路:数据从何来的问题,讲解常见的爬虫套路并利用三大实战帮助学员扎实数据采集能力,避免没有数据可分析的尴尬。   四、分析工具篇: 讲解数据分析避不开的科学计算库Numpy、数据分析工具Pandas及常见可视化工具Matplotlib。   五、算法篇: 算法是数据分析的精华,课程精选10大算法,包括分类、聚类、预测3大类型,每个算法都从原理和案例两个角度学习,让你不仅能用起来,了解原理,还能知道为什么这么做。
©️2020 CSDN 皮肤主题: 技术工厂 设计师:CSDN官方博客 返回首页