一、集合
1.定义
由不同元素组成的集合，集合中是一组无序排列的可hash值，可以作为字典的key。
2.特性
集合本身是可变类型，但是集合中的元素必须是不可变类型，并且是不重复的，无序的。
3.作用
关系测试；去重
二、集合的常用方法
1.创建一个集合，有两种方式：
#s1 = {1,2,3,3,3,3,4}或者s = set(‘hello‘)
2.添加元素
# s1.add(5)
# s1.add(6,7,8,9) #只能接收一个值，传4个值会报错
3.清空集合
# s.clear()
4.拷贝
# s1 = s.copy()
5.删除
# s = {‘sb‘,1,2,3,4,5,6}
#随机删
# s.pop()
#指定删除
# s.remove(‘sb‘)
# s.remove(‘hellol‘) #删除不存在的元素会报错
# s.discard(‘sbbbb‘)#删除不存在的元素不会报错
6.更新
# s1={1,2}
# s2={1,2,3}
# s1.update(s2) #update可以更新多个值，把s1中没有的但是s2中有的元素加到s1中
# print(s1) # s1的元素变了
# s1.union(s2) # 求两者的并集，并不是更新
# print(s1) # s1中的元素并没有改变
#s1.update((3,4)) #可以传进去，列表、元组都可以传，只要是可迭代
三、关系测试
# op=[‘zyh‘,‘yyq‘,‘zjq‘]
# ec=[‘zjq‘,‘cyh‘]
# p_s=set(op) # for循环列表中的元素，生成一个集合
# l_s=set(ec)
1.求交集
# print(p_s,l_s)
# print(p_s.intersection(l_s))
# print(p_s&l_s)
2.求并集
# print(p_s.union(l_s))
# print(p_s|l_s)
3.求差集
# print(‘差集‘,p_s-l_s) #存在于p_s中但不存在于l_s中的元素，就是我有你没有的元素
# print(p_s.difference(l_s))
# print(‘差集‘,l_s-p_s) #存在于l_s中但不存在于p_s中的元素，就是我有你没有的元素
# print(l_s.difference(p_s))
4.交叉补集（先求并集，然后取出两者没有重复的元素）
# print(‘交叉补集‘,p_s.symmetric_difference(l_s))
# print(‘交叉补集‘,p_s^l_s)
s1 = {1,2,3,4}
s2 = {2,3,5}
print(s1^s2) # {1, 4, 5}
5.两个集合有没有交集，返回True(有)或者False(没有)
# s1={1,2}
# s2={2,3,5}
# print(s1.isdisjoint(s2))
6.子集、父集
s1={1,2}
s2={1,2,3}
print(s1.issubset(s2))#s1 是s2 的子集
print(s2.issubset(s1))#False
print(s2.issuperset(s1))#s1 是s2 的父集
四、字符串格式化
1.字符串格式化两种方法：百分号和format，%s可以接受一切
2.百分号形式
格式：%[(name)][flags][width].[precision]typecode
(name) 可选，用于选择指定的key
flags 可选，可供选择的值有:
+ 右对齐；正数前加正好，负数前加负号；
- 左对齐；正数前无符号，负数前加负号；
空格 右对齐；正数前加空格，负数前加负号；
0 右对齐；正数前无符号，负数前加负号；用0填充空白处
width 可选，占有宽度
.precision 可选，小数点后保留的位数
typecode 必选
简单示例：print("hello %s" %"yyq")
###打印字符串###
# msg=‘i am %s my hobby is %s‘ % (‘yyq‘,‘zyh‘)
# print(msg)
#i am yyq my hobby is zyh
# msg = "i am {0}, age {1}, really".format("seven",18)
# print(msg)
# msg=‘i am %s my hobby is %s‘ % (‘yyq‘,1)
# print(msg)
# i am seven, age 18, really
# msg=‘i am %s my hobby is %s‘ % (‘yyq‘,[1,2])
# print(msg)
# i am yyq my hobby is [1, 2]
# name=‘yyq‘
# age=19
# msg=‘i am %s my hobby is %s‘ % (name,age)
# print(msg)
# i am yyq my hobby is 19
###打印浮点数###
# tpl = "percent %.2f" % 99.976234444444444444 # 打印百分数，保留小数点后两位
# print(tpl)
# percent 99.98
###打印百分比###
# tpl = ‘percent %.2f%%‘ % 99.976234444444444444 #打印百分数，保留小数点后两位，%%打印百分号
# print(tpl)
# percent 99.98%
###对齐###
# msg=‘i am %(name)+60s my hobby is zyh‘ %{‘name‘:‘yyq‘}右对齐60个位置
# print(msg)
3.format格式
格式:[[fill]align][sign][#][0][width][,][.precision][type]
fill [可选]空白处填充的字符
align [可选]对齐方式（需配合width使用）
<，内容左对齐
>，内容右对齐(默认)
＝，内容右对齐，将符号放置在填充字符的左侧，且只对数字类型有效。 即使：符号+填充物+数字
^，内容居中
sign [可选]有无符号数字
+，正号加正，负号加负；
-，正号不变，负号加负；
空格，正号空格，负号加负；
# [可选]对于二进制、八进制、十六进制，如果加上#，会显示 0b/0o/0x，否则不显示
， [可选]为数字添加分隔符，如：1,000,000
width [可选]格式化位所占宽度
.precision [可选]小数位保留精度
type [可选]格式化类型
###示例###
# tpl = "i am {name}, age {age}, really {name}".format(name="seven", age=18) 按照顺序取
# tpl = "i am {0}, age {1}, really".format("seven",18) # 不一一对应则报错，按元组下标方式取
# tpl = "i am {name}, age {age}, really {name}".format(**{"name": "seven", "age": 18})#这种是字典的形式，所以传值也要字典的格式，而且要到**
# tpl = "i am {:s}, age {:d}".format(*["seven", 18]) :s是字符串类型，:d是数字类型，*是表示要传入列表
# tpl = "i am {:s}, age {:d}".format("seven", 18)
#
# l=["seven", 18]
# tpl = "i am {:s}, age {:d}".format(*l)相当于format("seven", 18)
# print(tpl)
tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%},{}".format(15, 15, 15, 15, 15, 15.87623, 2)
print(tpl)
:b二进制
:o八进制
:x十六进制abcdef
:X十六进制ABCDE
:%显示成百分比，默认保留小数点后6位
五、函数
1.定义
python中的函数是逻辑结构化和过程化的一种编程方法。而“过程“”就是没有返回值的函数,没有return。但是python默认返回None，所以忘记“过程”这一说法
2.格式
# def test(x):
# y=2*x+1
# return y
def:定义函数的关键字
test：函数名
()：内可定义形参
"":文档描述（非必要，但是强烈建议为你的函数添加描述信息）
y=2*x+1：泛指代码块或程序处理逻辑
return：定义返回值
调用运行：可以带参数也可以不带
函数名()
3.使用函数的好处：
代码重用
保持一致性，易维护
可扩展性
4.返回值
作用：获取函数的执行结。在实际的生产中，后面的代码可能会根据这个结果进行不同的操作。
# def test03():
# msg = ‘test03‘
# print(msg)
# return 1,2,3,4,‘a‘,[‘alex‘],{‘name‘:‘alex‘},None # 当返回值是多个值的时候，函数return一个元组
# def test04():
# msg = ‘test03‘
# print(msg)
# return {‘name‘:‘alex‘} # 返回字典
总结：
返回值个数=0:返回None
返回值个数=1:返回object
返回值个数>1:返回tuple
5.参数
形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量
实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值
def calc(x,y): #x=2,y=3 #x,y是形参，只有在被调用（传值）时才分配内存单元
res=x**y
return res
a=calc(2,3) #2,3是实参
print(a)
###默认参数###
def stu_register(name,age,course,country="CN"):
常用于安装软件时，默认安装路径，默认安装一大推不需要的东西
###位置参数###
stu_register(name,age,course,country="USA") # name,age,course这种是位置参数
###关键字参数###
正常情况下，给函数传参数要按顺序，不想按顺序就可以用关键参数，只需指定参数名即可，但记住一个要求就是，关键参数必须放在位置参数之后。
stu_register(age=22,name=‘yyq‘,job="op") # 这种key=value形式的就是关键字参数
###参数组(**字典，*列表)###
若你的函数在定义时不确定用户想传入多少个参数，就可以使用非固定参数。
# *args(列表)
# def test(x,*args):
# print(x)
# print(args)
# test(1,2,3,4,5) # 返回1和(2,3,4,5)
# test(1,{‘name‘:‘alex‘})# 返回1和({‘name‘: ‘alex‘},)
# test(1,(‘x‘,‘y‘,‘z‘)) # 返回1和((‘x‘, ‘y‘, ‘z‘),)
# test(1,[‘x‘,‘y‘,‘z‘]) # 把列表当做一个整体传入args，返回1和([‘x‘, ‘y‘, ‘z‘],)
# test(1,*[‘x‘,‘y‘,‘z‘]) # 循环列表里面的元素然后传入args，把列表中的元素传入args，返回1和(‘x‘, ‘y‘, ‘z‘)
# test(1,*(‘x‘,‘y‘,‘z‘)) # 循环元组里面的元素然后传入args，把元组的元素传入args，返回1和(‘x‘, ‘y‘, ‘z‘)
总结：*args:把剩余的非key-value参数组成一个列表，然后传入函数，如果不给它传值也不会报错
# **kwargs(字典)
# def test(x,**kwargs):
# print(x)
# print(kwargs)#返回一个字典
# test(1,y=2,z=3)
# test(1,1,2,2,2,2,2,y=2,z=3)会报错，因为未知参数只有一个
# test(1,y=2,z=3,z=3)#会报错 ：一个参数不能传两个值
# *args&**kwargs
# def test(x,*args,**kwargs):
# print(x)
# print(args,args[-1])
# print(kwargs,kwargs.get(‘y‘))
# test(1,1,2,1,1,11,1,x=1,y=2,z=3) #报错
# test(1,1,2,1,1,11,1,y=2,z=3)
# test(1,*[1,2,3],**{‘y‘:1})
原文地址：https://www.cnblogs.com/liangjiongyao/p/8497181.html