可变序列，无序，集合中元素不能重复
一、创建set1 = {'sad', '2', 3} # 直接使用花括号
print(set1)
set2 = set(range(6))
print(set2)
set3 = set([1, 3, 2]) # 将列表转化为集合
print(set3)
set4 = set((1, 1, 2, 4, 5, 2)) # 将元组转化为集合
print(set4)
set5 = set('python') # 将字符串转化为集合元素
print(set5)
set6 = set({1, 2, 5, 6, 2, 3, 6, 0})
print(set6)
二、增删改操作
set1 = {'sad', '2', 3, 4}
list1 = [1, 3, 5, 'hh', 2.2]
set1.add(2)#增加一个元素
set1.update(list1)#至少增加一个元素，括号里是可迭代对象
set1.discard('sad') # 没有不抛异常
set1.remove(3) # 指定元素不存在抛一场
set1.pop() # 没有参数，删除一个任意元素 # set1.clear()#清空集合
三、集合之间关系，数学操作set1 = {'sad', '2', 3, 4}
set2 = {'2', 'sad', 4, 3}
print(set1 == set2)
print(set1 != set2) # 用==,!=来判断集合是否相等，元素相等就相等
set3 = {'sad', 3}
print(set3.issubset(set1)) # 判断集合是否是另一个的子集
print(set1.issubset(set3))
print(set1.issuperset(set3)) # 判断集合是否为另一个集合的超集
print(set3.isdisjoint(set1)) # 两个集合是否没有交集 有交集为false，没有为、、、
数学操作：
set1 = {'sad', '2', 3, 4}
set2 = {'sad', 3, 6, 'ggg'}
print(set2.intersection(set1))
print(set1 & set2) # 集合的交集
print(set1.union(set2))
print(set1 | set2) # 集合的并集
print(set1.difference(set2))
print(set1 - set2) # 集合的差集
print(set1.symmetric_difference(set2))
print(set1 ^ set2) # 集合的对称差集
二、列表、字典、元组、集合总结
列表(list)： 可变 可重复 有序 []
元组(tuple)：不可变 可重复 有序 ()
字典(dict)： 可变 key不可重复，value可 无序 {key:value}
集合(set)： 可变 不可重复 无序 {}
三、字符串操作创建： a = 'python' b = "python" c = '''python''' print(id(a), id(b), id(c)) # 新建字符串存在时直接指向其地址
查找子串：
s = 'hello,hello'
print(s.index('lo')) # 查找字串第一次出现位置，找不到报错
print(s.rindex('lo')) # 最后一次
print(s.find('h')) # 第一次，找不到返回-1
print(s.rfind('s')) # 最后一次
大小写转换： s = 'hello,Hello' print(s.upper()) # 产生一个新的字符串对象，转大写 print(s.lower()) # 转小写 print(s.swapcase()) # 大小写互换 print(s.capitalize()) # 第一个字符转大写，其他小写 print(s.title()) # 每个单词第一个字符大写
对齐： s = 'hello,Python' print(s.center(20, '*')) # 第一个参数总长，第二个为填充符可选默认空格 print(s.ljust(20, '-')) # 左对齐 print(s.rjust(30, '^')) # 右对齐 print(s.zfill(25)) # 右对齐，0填充·
字符串切分： s = 'hello Python a' print(s.split()) # 默认分隔符空格 print(s.split(sep=' ', maxsplit=1)) # 第二个参数指定最大分割次数 print(s.rsplit(sep=' ', maxsplit=1)) # 从右边开始
判断字符串：
print('_hello1'.isidentifier())#由数字字母下划线组成，不能以数字开头,判断是否为合法标识符
print('t'.isspace())#判断是否为空白字符
print('ab'.isalpha())#判断是否为字母组成
print('123'.isdecimal())#判断是否为十进制数字组成
print('一二三'.isnumeric())#判断是否为数字
print('21a8d'.isalnum())#判断是否为数字字母
字符串替换合并：
s = 'hello,python,python,python'
print(s.replace('python', 'java')) # 用java替换python
print(s.replace('python', 'java', 2)) # 指定最大替换次数
list1 = ['hello', 'world', 'dasd']
print('-'.join(list1)) # 把可迭代对象用—连接成字符串
字符串切片
s = 'dsada46846'
s2 = 'hhhhhh2'
print(s[1:8:2]) # 开始结束步数，字符串不可变对象，产生新的对象
print(s[::-1])
print(s + s2) # 连接
字符串比较：
print('apple' > 'app')
print('apple' > 'banana') # 从头开始一一比较其原始值
print(ord('a'), ord('b'))
print(chr(97), chr(98)) # 获取原始值对应的字符
print('杨' > '贵')
print(ord('杨'), ord('贵'))
# ==与is的区别：==比较其value，is比较id
格式化字符串
name = '张三'
age = 22
print('我叫:%s,今年%d岁' % (name, age)) # %为占位符
print('我叫：{0}，今年{1}岁，真的叫{0}'.format(name, age)) # {}占位符
print(f'我叫{name},今年{age}岁') # f格式化字符串
print('%10.
2f' % 3.1415926) # 指定宽度，小数点后位数
print('{0:.3}'.format(3.1415926)) # 三位有效数字
print('{0:10.3f}'.format(3.1415926)) # 宽度10小数点后三位
字符串编码转换 s = '我是你爸爸' print(s.encode(encoding='GBK')) # 在GBK中一个中文两个字符 print(s.encode(encoding='UTF-8')) # 一个中文三字节 byte = s.encode(encoding='GBK') # 编码 print(byte.decode(encoding='GBK')) # 解码 print(byte.decode(encoding='UTF-8')) # 解码和编码方式要相同是四、函数
为什么需要函数：复用代码，隐藏实现细节，提高可维护性，提高可读性便于阅读
一、函数创建def 函数名([输入参数]):
函数体
return xxx
二、参数例子：
def add(a, b):#a，b为形式参数，简称形参
c = a + b
print(c)
return 0
add(1, 2)#1,2为实际参数，简称实参，传参时按照位置把1传给a，2传给b
add(b=1, a=2)#1,2传参时按照关键字把1传给b，2传给a
函数的参数传递过程中：
def fun(arg1, arg2):
print(arg1)
print(arg2)
arg1 = 100
arg2.append(10)
print(arg1)
print(arg2)
n1 = 11
n2 = [22, 33, 44]
fun(n1, n2)
print(n1) # 在函数调用过程中，对不可变对象修改不会影响值，可变对象会影响
print(n2)
参数定义：
# 个数可变的位置参数,结果为一个元组
def fun(*arges):
print(arges)
fun(10)
fun(10, 20)
# 个数可变的关键词参数,结果为一个字典
def fun1(**args):
print(args)
fun1(a=10)
fun1(a=20, b=20)
三、函数的返回值
def fun(num):
odd = []
even = []
for i in num:
if i % 2:
odd.append(i)
else:
even.append(i)
return odd, even
print(fun([1, 4, 33, 55, 33, 2, 90, 38])) # 如果函数没有返回值return省略
# 函数的返回值，如果是一个返回原类型，如果是多个，返回元组
四、函数的调用
def fun(a, b, c):
print(a)
print(b)
print(c)
fun(1, 2, 3)
list1 = [2, 3, 4]
fun(*list1) # 将列表中的每个元素都转化为位置实参传入
fun(a=2, b=2, c=23)
dic = {'a': 11, 'b': 22, 'c': 33}
fun(**dic) # 将列表中的每个键值对转化为关键字实参
def fun(a, b=4): # b为默认值形参
print(a)
print(b)
def fun2(*args): # 个数可变的位置形参 结果为元组
print(args)
def fun3(**args): # 个数可变的关键字形参 结果为字典
print(args)
fun2(2, 3, 5, 6)
fun3(a=2, b=2, c=9, d=10)
def fun4(a, b, *, c, d): # 后两个参数只能是关键字参数传递
print(a)
print(b)
print(c)
print(d)
fun4(1, 2, c=1, d=3)
五、递归函数
在一个函数体内调用了该函数本身，称为递归函数，占用内存较多
def fac(n):
if n == 1:
return 1
else:
return n * fac(n - 1)
print(fac(6))
斐波那契数列：
def fib(n):
if n == 1:
return 1
elif n == 2:
return 1
else:
return fib(n - 1) + fib(n - 2)
for i in range(1,6):
print(fib(i), end='')
五、变量作用域
def fun(a, b):
c = a + b
print(c) # a,b,c为局部变量在函数外不可调用
name = 'gyq' # 全局变量,函数内也可以调用
print(name)
def fun2():
print(name)
fun2()
def fun3():
global age # 将其定义为全局变量
age = 30
print(age)
fun3()
print(age)
六、异常处理
while 1: # 捕获异常的顺序按照先父类后子类
try:
n1 = int(input('请输入一个被除数'))
n2 = int(input('输人除数'))
result = n1 / n2
print(result)
except ZeroDivisionError:
print('除数不为0')
except ValueError:
print('只能输入数字')
except baseException as e:
print(e)
print('结束')
while 1: # 捕获异常的顺序按照先父类后子类
try:
n1 = int(input('请输入一个被除数'))
n2 = int(input('输人除数'))
result = n1 / n2
except baseException as e:
print(e)
else:
print(result)
finally: # 常用来释放try块中申请的资源
print('无论是否异常都会执行的代码')
print('程序结束')
常见错误类型：
ZeroDivisionError:除或取模零
IndexError:序列中没有此索引
KeyError:映射中没有这个键
NameError:未声明/初始化对象
SyntaxError:Python语法
ValueError:传入无效参数
