函数的四种基本类型：
1. 无参数，无返回值，一般用于提示信息打印。
2. 无参数，有返回值，多用在数据采集中，比如获取系统信息。
3. 有参数，无返回值，多用在设置某些不需要返回值的参数设置。
4. 有参数，有返回值，一般是计算型的，需要参数，最终也要返回结果。
变量的作用域
变量的作用域：变量起作用的范围，不同作用域的同名变量之间互不影响，分为全局变量和局部变量。
全局变量：在函数和类定义之外声明的变量，作用域为定义的模块
- 全局变量降低了函数的通用性和可读性，应避免使用
- 全局变量一般做常量使用
- 函数要改变全局变量的值，应使用global声明
局部变量：
- 在函数体（包含形参）声明的变量，在函数内部定义，作用域仅仅局限在函数的内部
- 栈帧：调用函数的时候启动一个栈帧，栈帧外部访问不了栈帧内部，栈帧内部可以访问栈帧外部，stack frame，调用完会删除，用于储存局部变量
- 不同的函数可以定义相同的局部变量，但是各自用各自的，不会产生影响
- 局部变量的作用：为了临时的保存数据，需要在函数中定义来进行存储
- 函数内部不可直接使用全局变量名称进行修改全局变量，而需要使用关键字global进行声明global pro ；pro = ‘abc’
*如果全局变量和局部变量重名，程序优先使用函数内部的变量
*局部变量的查询和访问速度比全局变量块，在特别强调效率的地方可以通过将全局变量转为局部变量来提高运行速度
变量和对象之间的关系
万物皆对象，函数，列表等都是对象
变量是对象的引用，a=1，a是变量，1是对象(解释器开辟新的内存地址，a在内存中存储的是1的内存地址)；a=2时，2会开辟新的内存地址，a存的内存地址将会变为2的内存地址，变量本身没有存储信息，只是指向不同的内存地址，也就是一种引用，不同的赋值是不同的引用
def funcx(x):
print('x的地址：'.format(id(x))
pass
print('a的地址：'.format(id(a)))
func(a)此时a和x的打印的地址是相同的，因为指向的值相同，地址相同，在函数内部改变为x=2，则a和x的地址不再相同，因为a=1是int不可变类型，重新赋值会分配新的存储空间
#不可变类型
a=1
def func(x):
print('x的地址{}'.format(id(x)))
x=2
print('x的地址{}'.format(id(x)))
pass
#调用函数
print('a的地址：{}'.format(id(a)))
func(a)
print(a)
#可变类型
li=[]
def testRenc(parms):
print(id(parms))
li.append([1,3,4,5,3,53])
print(id(parms))
print('内部的{}'.format(parms))
pass
print(id(li))
testRenc(li)
print('外部的{}'.format(li))
#python中万物皆对象，函数调用的时候，实参传递的是对象的引用。
#了解了原理后，就可以更好的把控，函数内部的处理是否影响函数外部的数据变化
#参数的传递是通过对象引用来完成。
匿名函数
python中使用lambda关键字创建匿名函数，所谓匿名即这个函数没有名字不用def关键字创建标准的函数。
语法结构：lambda arg1,arg2,arg3…:<表达式> 其中arg1,arg2,arg3为函数的参数，<表达式>相当于函数体
使用lambda表达式计算两个数和：
test = lambda x,y:x +y
test(1,3)
test(4,5)
换成普通函数其实就是这样的
def test(x,y):
return x + y
特点：
- 使用lambda表达式定义
- 没有名字
- 匿名函数后边的表达式有且仅有一个，是表达式不是语句
- 匿名函数自带return，而这个return的结果就是表达式计算后的结果
缺点：
- lambda只能是单个表达式，不是一个代码块，lambda的设计是为了满足简单函数的场景
- 仅仅能封装有限的逻辑，复杂逻辑实现不了，必须使用def处理
调用：通过变量去调用匿名函数
lambda与三元运算：（替代传统双分支的计算）
if a:
b else:
c
能够由以下等效的表达式来模拟：
b if a else c
这样的表达式（三元运算）能够放在lambda中，它们能够在lambda函数中来实现选择逻辑
两种调用方式：直接或间接（见如下的代码）
def computer(x,y):
"""
计算数据和
:param x:
:param y:
:return:
"""
return x+y
pass
computer(10,55)
print(computer(10,55))
#对应的匿名函数
M=lambda x,y:x+y
#通过变量去调用匿名函数
print(M(23,19))
result=lambda a,b,c:a*b*c
print(result(12,23,3))
#lambda与三元运算符
age=15
print('可以参军'if age>18 else '继续上学' )#可以替换传统双分支的写法
funcTest=lambda x,y:x if x>y else y
print(funcTest(12,2))
rs=(lambda x,y:x if x>y else y)(16,12)#直接传参并调用
print(rs)
varRs=lambda x:(x**2)+890
print(varRs(10))递归函数
递归函数 如果一个函数在内部不调用其它的函数，而是自己本身的话，这个函数就是递归函数。
条件
- 自己调用自己
- 递归函数必须有一个结束条件，否则递归无法结束会一直递归下去，只到到达最大递归深度报错
优点
- 递归使代码看起来更加整洁、优雅
- 可以用递归将复杂任务分解成更简单的子问题，逻辑简单
- 使用递归比使用一些嵌套迭代更容易
缺点
- 递归逻辑很难调试，递归条件处理不好容易造成程序无法结束，直到达到最大递归错误。
- 递归占用大量内存，耗费计算机资源，容易导致内存栈溢出，内存资源紧张，甚至内存泄漏事件的发生
举例：阶乘
#求阶乘
#循环的方式去实现
def jiecheng(n):
result=1
for item in range(1,n+1):
result*=item
pass
return result
print('5的阶乘{}'.format(jiecheng(5)))
#递归方式去实现
def diguiJc(n):
"""
递归实现
:param n:阶乘参数
:return:
"""
if n==1:
return 1
else:
return n*diguiJc(n-1)
pass
diguiJc(5)
print('5的阶乘{}'.format(diguiJc(5)))案例：模拟实现树形结构的遍历（获取当前路径下的所有文件）
#递归案例 模拟实现树形结构的遍历
import os #引入文件操作模块
def findFile(file_Path):
listRs=os.listdir(file_Path) #得到该路径下面所有的文件和文件夹
for fileItem in listRs:
full_path=os.path.join(file_Path,fileItem)#获取完整的文件路径
if os.path.isdir(full_path):#判断是否是文件夹
file_Path(full_path)#如果是一个文件夹，再次去递归
else:
print(fileItem)
pass
pass
else:
return
pass
#调用搜索文件夹对象
findFile('F://Python1//Day_1')内置函数
内置函数
所谓内置函数就是python安装后就自带有的函数
如同人一生下来就有手有脚，会吃会喝一样，具备基本的能力 ，随着成长和学习，我们学会了说话、学会了工作，学会了技能等，而这些能力就如同我们 Python 的扩展函数或扩展库
内置函数功能列表
Python内置函数 python内置了一系列的常用函数，以便于我们使用。所有内置函数官网文档 https://docs.python.org/3/library/functions.html 内置函数
常用数学运算函数
abs() 求绝对值函数
#描述: abs() 函数返回数字的绝对值
#语法: abs( x )
#参数: x -- 数值表达式
#返回值: 函数返回x（数字）的绝对值
>>> abs(10)
10
>>> abs(-10)
10
>>> abs(-10.023)
10.023
>>>round() 取近似值
#描述: round() 方法对浮点数进行近似取值，保留几位小数
#语法: round( x [, n] )
#参数:
x -- 数值表达式
n -- 数值表达式，保留几位小数
#返回值: 返回浮点数x的近似值
*注意：这里不完全是按照四舍五入或者四舍六入五成双来进行取值的，取值和python的版本有关，还和浮点数的精度有关
>>> round(2.6)
3
>>> round(2.4)
2
>>> round(2.5)
2
>>> round(2.55,1)
2.5
>>> round(2.675,2)
2.67
pow() 求次方
#描述: pow()方法返回 x^y（x的y次方） 的值
#语法: pow(x, y[, z])
#参数:
x -- 数值表达式
y -- 数值表达式
z -- 数值表达式
#返回值:返回 xy（x的y次方） 的值
>>> pow(2,3)
8
>>> pow(2,3,2)
0
>>> pow(2,3,4)
0
>>> pow(2,3,5)
3
>>>
divmod() 求商和余数
#语法: divmod(a, b)
#参数:
a: 数字
b: 数字
#返回值: 一个包含商和余数的元组(a // b, a % b)
>>> divmod(7,3)
(2, 1)
>>> divmod(9,3)
(3, 0)
>>>
max() 求最大值
#描述: max() 方法返回给定参数的最大值，参数可以为序列
#语法: max( x, y, z, .... )
#参数:
x -- 数值表达式
y -- 数值表达式
z -- 数值表达式
#返回值:返回给定参数的最大值
>>> max(80,100,1000)
1000
>>> max(-20,-50,1,30)
30
>>> max(0,100,-300)
100
>>>
min() 求最小值
#描述: min() 方法返回给定参数的最小值，参数可以为序列
#语法: min( x, y, z, .... )
#参数:
x -- 数值表达式
y -- 数值表达式
z -- 数值表达式
#返回值: 返回给定参数的最小值
>>> min(80, 100, 1000)
80
>>> min(-20, 100, 400)
-20
>>> min(-80, -20, -10)
-80
>>> min(0, 100, -400)
-400
>>>
sum() 求和
#描述: sum() 方法对系列进行求和计算
#语法: sum(iterable[, start])
#参数:
iterable -- 可迭代对象，如：列表、 元组、集合。
start -- 指定相加的参数，如果没有设置这个值，默认为0
#返回值: 返回计算结果
>>>sum([0,1,2])
3
>>> sum((2, 3, 4), 1)
10
>>> sum([0,1,2,3,4], 2)
12
eval() 动态的执行字符串表达式，将字符串str当成有效的表达式来求值并返回计算结果
#描述: eval() 函数用来执行一个字符串表达式，并返回表达式的值
#语法: eval(expression[, globals[, locals]])
#参数:
expression -- 表达式
globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象
locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象
#返回值: 返回表达式计算结果
>>> a=1
>>> b=2
>>> c =3
>>> eval('a+b')
3
>>> eval('a+b+c',{'c':3,'a':1,'b':3})
7
# eval 执行表达式
a,b,c=1,2,3
print('动态执行的函数={}'.format(eval('a*b+c-30')))
def TestFun():
print('我执行了吗?')
pass
# eval('TestFun()') #可以调用函数执行类型转换
int() 转为整型
#描述: int() 函数用于将一个字符串或数字转换为整型
#语法: class int(x, base=10)
#参数:
x -- 字符串或数字
base -- 进制数，默认十进制
#返回值: 返回整型数据
>>> int('666')
666
>>> int(3.6)
3
float() 转为浮点数
#描述: float() 函数用于将整数和字符串转换成浮点数
#语法: class float([x])
#参数: x -- 整数或字符串
#返回值:返回浮点数
>>> float(3)
3.0
>>> float('3')
3.0
>>>
str() 转为字符串
#描述: str() 函数将对象转化为适于人阅读的形式
#语法: class str(object='')
#参数: object -- 对象
#返回值:返回一个对象的string格式
>>> a = 1
>>> type(a)
<class 'int'>
>>> b = str(a)
>>> type(b)
<class 'str'>
>>>
ord() 字符转数字
#描述: ord() 函数是 chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于 Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常
#语法: ord(c)
#参数: c -- 字符
#返回值:返回值是对应的十进制整数
>>> ord('A')
65
>>> ord('a')
97
chr() 数字转字符
#描述: chr() 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符
#语法: chr(i)
#参数: i -- 可以是10进制也可以是16进制的形式的数字
#返回值:返回值是当前整数对应的ascii字符
>>> chr(65)
'A'
>>> chr(66)
'B'
>>> chr(67)
'C'
bool() 转为布尔型
#描述: bool() 函数用于将给定参数转换为布尔类型，如果没有参数，返回 False
#语法: class bool([x])
#参数: x -- 要进行转换的参数
#返回值:返回 Ture 或 False
*下列对象都相当于False：[],(),{},0, None, 0.0, ''
>>> bool(0)
False
>>> bool([])
False
>>> bool('a')
True
>>>bin() 转为二进制
#描述: bin() 返回一个整数 int 或者长整数 long int 的二进制表示
#语法: bin(x)
#参数: x -- int 或者 long int 数字
#返回值:字符串
>>> bin(52)
'0b110100'
>>> bin(12)
'0b1100'
hex() 转为16进制
#描述: hex() 函数用于将10进制整数转换成16进制，以字符串形式表示
#语法: hex(x)
#参数: x -- 10进制整数
#返回值:返回16进制数，以字符串形式表示
>>> hex(32)
'0x20'
>>> hex(63)
'0x3f'
oct() 转为八进制
#描述: oct() 函数将一个整数转换成8进制字符串
#语法: oct(x)
#参数: x -- 整数
#返回值:返回8进制字符串
>>> oct(56)
'0o70'
>>> oct(9)
'0o11'
>>> oct(8)
'0o10'
>>>list() 元组转为列表
#描述: list() 方法用于将元组转换为列表
#语法: list( tup )
#参数: tup -- 要转换为列表的元组
#返回值:返回列表
>>> list((1,2,3))
[1, 2, 3]
>>>
tuple() 列表转为元组
#描述: tuple()函数将列表转换为元组
#语法: tuple(seq)
#参数: seq -- 要转换为元组的序列
#返回值: 返回元组
>>> tuple([2,3,4])
(2, 3, 4)
>>> tuple({'a':1,"b":2})
('b', 'a')
>>>
dict() 创建字典
#描述: dict() 函数用于创建一个字典
#语法:
class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)
#参数:
**kwargs -- 关键字
mapping -- 元素的容器
iterable -- 可迭代对象
#返回值: 返回一个字典
>>> dict(a=1,b="hello",c=[1,2,3])
{'b': 'hello', 'a': 1, 'c': [1, 2, 3]}
>>>
bytes() 转为字节数组
#描述: bytes()方法返回一个新字节数组，这个数组里的元素是可变的，并且每个元素的值
#范围: 0 <= x < 256
#语法: class bytearray([source[, encoding[, errors]]])
#参数:
source 为整数，则返回一个长度为 source 的初始化数组；
source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；encoding为将 要转换的文字类型，中文/英文/其他国家语言
source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytes
如果没有输入任何参数，默认就是初始化数组为0个元素
#返回值:返回新字节数组
>>> bytes('中'.encode('utf-8'))
b'\xe4\xb8\xad'
>>> bytes('中'.encode('gbk'))
b'\xd6\xd0'
*以上均为强制转换类型，使用方式相同
*输出为0x开头(0x17)表示16进制，嵌入式编程，和底层进阶互动时，传值的方式往往是16进制来传递
小练习：
# 类型转换函数
# print(bin(10)) #转换二进制
# print(hex(23)) #十六进制 输出为0x开头(0x17)表示16进制，嵌入式编程，和底层进阶互动时，传值的方式往往是16进制来传递
# 元组转换为列表
tup=(1,2,3,4)
# print(type(tup))
li=list(tup) #强制转换
# print(type(li))
li.append('强制转换成功')
# print(li)#输出了append的内容，说明转换成列表成功，才可以进行修改操作
tupList=tuple(li)
# print(type(tupList))
# 字典操作 dict()
# dic=dict(name='小明',age=18) #创建一个字典，以键值对的方式赋值就可，不要太复杂
# # print(type(dic))
# # # dict['name']='小明'
# # # dict['age']=18
# # print(dic)
# bytes转换
# print(bytes('我喜欢python',encoding='utf-8'))#这里的encoding指转换为何种语言，中文/英文/其他国家语言，utf-8指的是中文序列操作
特点：可对任何可遍历的对象进行序列操作（字符串/元组/列表）
序列操作函数
all() 用于判断序列中的数据是不是我们所需要的
all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False元素除了是 0、空、FALSE 外都算 TRUE（可迭代对象这里就理解成序列就可以）
函数等价于：
#语法: all(iterable)
#参数: iterable -- 元组或列表
#返回值:如果iterable的所有元素不为0、''、False或者iterable为空，all(iterable)返回True，否则返回False；布尔类型
>>> li = [1,2,3]
>>> all(li)
True
>>> li = [1,2,3,0]
>>> all(li)
False
*注意：空元组、空列表返回值为True，这里要特别注意
# 序列操作 str 元组、 list
# all() result:bool 对象中的元素除了是 0、空、FALSE 外都算 TRUE, 所有的元素都为True
# 结果就为True
# print(all([])) #True
# print(all(())) #True
# print(all([1,2,4,False]))#False
# print(all([1,2,4]))#True
# print(all((3,4,0)))#False
any()
any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True
函数等价于：
元素除了是 0、空、FALSE 外都算 TRUE
#语法: any(iterable)
#参数: iterable -- 元组或列表
#返回值:如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true
>>> li = [1,2,3,0]
>>> any(li)
True
>>>
# any result:bool 类似于逻辑运算符 or的判断，只要有一个元素为True 结果就为True
# print('--------any-------------')
# print(any(('',False,0)))
# print(any((1,2,3)))sorted()
sorted() 函数对所有可迭代的对象进行排序操作
sort与sorted 区别：
- sort是应用在 list 上的方法（只可用于列表类型），sorted 可以对所有可迭代的对象进行排序操作
- list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作
- 对元组，字符串等不可修改的类型使用sorted进行排序
#语法: sorted(iterable[, cmp[, key[, reverse]]])
#参数:
iterable -- 可迭代对象
cmp -- 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函
数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0
key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可
迭代对象中，指定可迭代对象中的一个元素来进行排序
reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）
#返回值:返回重新排序的列表
>>> sorted([1,2,3,5,6,9])
[1, 2, 3, 5, 6, 9]
>>> sorted([1,2,3,5,6,9],reverse=False)
[1, 2, 3, 5, 6, 9]
>>> sorted([1,2,3,5,6,9],reverse=True)
[9, 6, 5, 3, 2, 1]
>>> sorted(['a','b','C','D','d'],key=str.lower) # 字符串无关大小写排序
['a', 'b', 'C', 'D', 'd']
# sort 和sorted
li=[2,45,1,67,23,10] #原始对象
# li.sort() #list的排序方法 直接修改的原始对象
tupArray=(2,45,1,67,23,10)
# print('--------排序之前---------{}'.format(li))
# # # varList=sorted(li) #升序排列
# # varList=sorted(li,reverse=True) #降序排序
# # print('--------排序之后---------{}'.format(varList))
# varRs=sorted(tupArray,reverse=False)
# print(varRs)reverse()
reverse() 函数用于反向列表中元素
#语法: list.reverse()
#返回值:该方法没有返回值，但是会对列表的元素进行反向排序()
>>> a = [1,2,3,4,5]
>>> a.reverse()
>>> a
[5, 4, 3, 2, 1]
c=[1,2,3,4]
c.reverse()
print(c.reverse()) #None
print(c) #反向列表range()
range() 函数可创建一个整数列表，一般用在 for 循环中
#语法: range(start, stop[, step])
#参数:
start: 计数从 start 开始默认是从 0 开始例如range（5）等价于range（0， 5）;
stop: 计数到 stop 结束，但不包括 stop例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
step：步长，默认为1例如：range（0， 5） 等价于 range(0, 5, 1)
>>> for i in range(10):
... print(i)
...
0
1
2
3
4
5
6
7
8
9
>>> for i in range(0,10,2):
... print(i)
...
0
2
4
6
8
>>>zip()
zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表
#语法: zip([iterable, ...])
#参数: iterabl -- 一个或多个迭代器;
#返回值:返回元组列表
>>> zip([1,2,3],['a','b','c'])
<zip object at 0x7f5c2f9d7fc8>
>>>
>>> a = zip([1,2,3],['a','b','c'])
>>> list(a)
[(1, 'a'), (2, 'b'), (3, 'c')]
如果可迭代对象的元素个数不一样，那么按照最少的那个迭代压缩最少元素进行可迭代对象结束后退出
>>> a = zip([1,2,3],['a','b','c','d','e'])
>>> list(a)
[(1, 'a'), (2, 'b'), (3, 'c')]
# zip() :就是用来打包的，会把序列中对应的索引位置的元素存储为一个元组
# s1=['a','b','c']
# s2=['你','我','c他','peter']
# s3=['你','我','c他','哈哈','呵呵']
# # print(list(zip(s1))) 压缩一个数据#输出还是s1，但是有逗号，因为是元组类型
# zipList=zip(s2,s3) #压缩两个参数
# print(list(zipList))d=zip(a,c)
print(d) #不能输出压缩后的元组
print(list(d)) #成功了案例：
def printBookInfo():
'''
zip 函数的使用
:return:
'''
books=[] #存储所有的图书信息
id=input('请输入编号: 每个项以空格分隔') #str
bookName = input('请输入书名: 每个项以空格分隔') #str
bookPos = input('请输入位置: 每个项以空格分隔')
idList=id.split(' ')
nameList = bookname.split(' ')
posList = bookPos.split(' ')#位置分割
bookInfo=zip(idList,nameList,posList) #打包处理
for bookItem in bookInfo:
'''
遍历图书信息进行存储
'''
dictInfo={'编号':bookItem[0],'书名':bookItem[1],'位置':bookItem[2]}
books.append(dictInfo) #将字典对象添加到list容器中，字典没有顺序，不可以直接遍历
pass
for item in books:
print(item)
# printBookInfo()enumerate()
enumerate()函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列（也可以接收字典），同时列出数据和数据下标，一般用在 for 循环当中
#语法: enumerate(sequence, [start=0])
#参数:
sequence -- 一个序列、迭代器或其他支持迭代对象
start -- 下标起始位置（默认是从0开始）
#返回值:返回 enumerate(枚举) 对象，是元组的类型，我们可以单独的取出部分
>>> seasons = ['spring','summer','fall','winter']
>>> list(enumerate(swasons))
[(0, 'spring'), (1, 'summer'), (2, 'fall'), (3, 'winter')]
>>> list(enumerate(swasons,start=5))
[(5, 'spring'), (6, 'summer'), (7, 'fall'), (8, 'winter')]
# enumerate 函数用于将一个可遍历的数据对象
# (如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，
# 一般用在 for 循环当中
listObj=['a','b','c']
# for index,item in enumerate(listObj,5):#从小标为5的元素开始
# print(index,item)#同时输出数据和数据下标，不指明也是都输出，但是是元组类型
# pass
#遍历字典（在enumerate中，字典也是可以遍历的，因为为对象分配了下标，本来字典是没有顺序的）
dicObj={}
dicObj['name']='李易峰'
dicObj['hobby']='唱歌'
dicObj['pro']='艺术设计'
# print(dicObj)
for item in enumerate(dicObj):
print(item)
print(item[1])#单独输出对象
For index, item in enumerate(dicObj):
print(index)#单独输出索引
print(item)#单独输出对象
Set集合
set（集合） 也是python中的一种数据类型，是一个无序且不重复的元素集合，不支持索引和切片，更像是一种字典，但是又只有key，没有value，在应用中可以很好的发挥去重的作用，将数据类型转换为集合类型去重
创建集合方式?
# 第一种方式
set1 = {"1","2"}
# 第二种方式
list1 = ['1','5','4','3']
set2 = set(list1) #直接强制转换，这部可直接去重
特点：
- 不支持切片，是一个不重复且无序的容器，类似于字典，但只有key，没有value
集合操作函数
add()
添加一个元素
>>> set1 = {'1','2'}
>>> set1.add('3')
>>> set1
{'2', '1', '3'}
>>>
clear()
清空集合的元素
>>> set1
{'2', '1', '3'}
>>>
>>> set1.clear()
>>> set1
set()
>>>
difference()
两个集合的差集，a中存在，b中不存在，两种方式：difference/-
>>> a = {32,12,34}
>>> b = {12,43,23}
>>> a.difference(b)
{32, 34}
>>> a – b
{32, 34}
intersection()
两个集合的交集，a中存在，b中也存在的，intersection/&
>>> a = {32,12,34}
>>> b = {12,43,23}
>>> a.intersection(b)
{12}
>>> a & b
{12}
union()
union 并集 包含a中的元素，也包含b中的元素，两种方式：union/｜
>>> a = {32, 12, 34}
>>> b = {12, 43, 23}
>>> a.union(b)
{32, 34, 23, 43, 12}
>>> a | b
{32, 34, 23, 43, 12}
pop()
pop 集合pop随机移除某个元素并且获取那个参数,集合pop没有参数
>>> a = {32,12,34}
>>> a.pop()
32
>>> a
{34, 12}
>>>
discard()
discard 移除指定元素
>>> a = {32,12,34}
>>> a.discard(12)
>>> a
{32, 34}
>>>
update()
更新集合
>>> a={1,2,3}
>>> b={4,5,6}
>>> a.update(b)
>>> a
{1, 2, 3, 4, 5, 6}
#创建集合
set1={1,2,3}
print(type(set1)) #结果是集合
dic1={}
print(type(dic1))#结果是字典，虽然都是使用{},但是传入的数据类型不同，集合只有key，因此系统判断为是set类型
dic1={1:3}
print(type(dic1))#结果是字典
#添加操作
set1.add('python')
print(set1)
#清空操作
set1.clear()
print(set1)
#取差集，得到的元素是a中存在，b中不存在的，两种方式：difference/-
set1={1,2,3}
set2={2,3,4}
rs=set1.difference(set2)#生成了新的对象
print(rs)
print(set1-set2)
#取交集操作,两种方式：intersection/&
print(set1.intersection(set2))#也可以不用变量接收结果
print(set1&set2)
#取并集操作，两种方式：union/｜
print(set1.union(set2))
print(set1|set2)
#删除操作，pop就是从集合中拿数据同时删除,随机拿去
print(set1)
quData=set1.pop()
print(quData)
print(set1)
#指定移除数据
print(set1.discard(3))
#更新集合
set1.update(set2)
print(set1)#并集，改变了set1，重复的不再出现
240
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
