python基础——set——函数——异常处理——装饰器

set的操作

set: 类似dict 是一组key的集合，不存储value
他是无序和无重复元素的集合
set 没有索引，没有顺序

创建

#创建set需要一个list 或者tuple或者dict作为输入集合
sl=set([1,2,3,4,2,4])

有重复的自动过滤

print(sl)
s2=set((1,2,3,4,5,5,4))
print(s2)
s3=set({1:'good',2:'not'})
print(s3)

添加

ss=set([1,2,3,4,5,6,7])
print(ss)
ss.add(8)  #可以添加重复，但没有效果
#ss.add([7,8,9]) #set的元素不能是列表   列表是可变的对象
ss.add((7,8,9))
#ss.add({1:'a'}) #set的元素不能是字典，字典是可变的
print(ss)

插入整个list,tuple,字符串，打碎插入

s1=set([1,2,3,4,5,6,7])
s1.update([6,7,8])
s1.update('python')
print(s1)

#删除

s2=set([1,2,3,4,5,6,7])
s2.remove(4)
print(s2)

#遍历
s3=set('python')
for i in s3:
    print(i)

#交集

s4=set([2,3,4,5])
s5=set([4,5,6,7,8])
al=s4&s5
print(al)

#并集

a2=s4|s5
print(a2)

#类型转换

'''
list    set
set(a)

set    list
list(a)

set    tuple
tuple(a)

tuple set
set(a)
'''

函数

1.化代码结构，怎加代码的复用度
2.想修改某些功能或bug,修改相应的函数即可

定义函数格式

def 函数名（参数列表）：
    语句
    return 表达式

def：函数代码块以def关键字开始
函数名：遵循标识符规则
参数列表（参数1，参数2，参数3）任何传入函数的参数和变量
必须放在圆括号之间，逗号分割，函数从函数调用这那里获取的信息，
冒号：函数内容（封装功能）冒号开始
return：一般用于借宿函数，并返回信息给函数调用者

def my():
    print('a')
    print('abc')
print(my())

函数的调用
格式：函数名（参数列表）
函数名：使用功能的函数名
参数列表：调用者给函数传递的信息
调用的本质：实参给形参复制的过程

实参 实参本质时值

def name(a,b):
    print(a,b)
name('python is a good',22)

函数返回值

def sum(q,w):
    return q+w
aa=sum(1,2)
print(aa)

值传递

def fun(sum):
    sum=10
temp=22
fun(temp)
print(temp)

引用传递 传递的可变类型

# list,dict,set 时可变的
def lis(ls):
    ls[0]=100
bb=[1,2,3,4,5]

lis(bb)
print(bb)

'''
关键字参数
：允许函数调用时参数的顺序与定义不一致
'''
def name(b,a):
    print(a,b)
name(b='python is a good',a=22)

默认参数
调用函数时，如果没有传递参数，则使用默认参数
'''
#以后如过使用默认参数，最好将默认参数放到最后
def name(a='python is a good',b=22):
    print(a,b)
name('pycharm',11)

不定长参数
能处理比定义时更多的参数
#加了星号的变量存放所有未命名的变量参数，
# 如果调用时没有指定参数，他就是一个空元组
def name(name,*arr): #  *arr存放所有未命名的参数
                #也可以arrgs
    print(name)
    for x in arr:
        print(x)
name('pycharm','22','1','3333')

def sm(*l):
    sum=0
    for i in l:
        sum+=i
    return sum
print(sm(1,2,3,4,5,6,7,8,9,))

'''
匿名函数
不能使用def这样的语句定义函数
使用lambda来创建匿名函数
特点：
1，lambda只是一个表达式，函数体比def简单
2，lambda的主体是一个表达式，而不是代码块，
仅仅只能再lambda表达式中封装简单的逻辑
3，lambda函数有自己的命名空间，且不能自由参数列表之外的或全局命名空间的参数
4，虽然lambda是一个表达式且看起来之恩写一行，与C和C++内联函数不同
格式：lambda 参数1，参数2，参数3，：expression
'''

su=lambda num1,num2:num1+num2
print(su(1,2))

异常处理

需求：当程序遇到问题时不让程序结束，而越过错误继续向下执行

'''
try        except   else
格式：
try:
    语句t
except 错误表示码 as e:
    语句1
except 错误表示码 as e:
    语句2
except 错误表示码 as e:
    语句n
else:
    语句e
注意：else语句可有可无

作用：检测try语句块中的错误，从而让except捕获错误信息并处理

逻辑：当程序执行到try-except-else语句时
1，当try“语句t”执行错误时，会匹配第一个错误码，如果匹配上就执行对应的“语句”
2.如果try“语句”执行没有错误，没有匹配的异常，错误将会被提交到上上一层的try语句
    或者到程序的最上层
3，如果try语句执行没有错误，执行else下的语句e（你得有才行）
'''

try:
    print(1/0)
except ZeroDivisionError as e:
    print('为0了')
finally:
    print('必须执行')

装饰器

是一个闭包，把一个函数单座参数返回一个替代版的函数，
本质是一个返回函数的函数
不改变原函数内容，添加新内容

简单的装饰器

def func1():
    print(2)
    print('python is a boy')

def outre(func):
    def inner():
        print('************')
        print(3)
        func()
        print(1)
    return inner


f=outre(func1)
f()

复杂一点的装饰器

def outer(func):
    def inner(age):
        if age<0:
            age=0
        func(age)
    return inner
@outer   #等于say=outer(say)
def say(age):
    print('%d is a good boy' % (age))


say(12)
# say=outer(say)
say(-10)

文章末尾

xiaofengfeng的博客
你要坚持努力而不是你努力坚持——xiaofengfeng