Day14 集合与函数

变量：记录状态变化

五大基本类型

1.可变不可变：

-可变：列表，字典（Key是不可变类型）

-不可变（需要修改时会新开辟内存空间）：数字、字符串、元组

---

2.访问顺序

-顺序访问：字符串、列表、元组

-映射访问：字典

-直接访问：数字

---

3.存放元素个数

-容器类型：列表、元组、字典

-原子：数字、字符串

---

一、集合

定义：由不同元素组成的集合，集合中是一组无序排列的可hash值，可以作为字典的Key特性

基本格式：大括号{}括起来，元素用逗号,分割

s = set('Hello')

集合Set类定义的方法：

-add():添加元素，只能传一个参数

-clear():清空

-copy():拷贝

-pop():随机删除

-remove(value):指定删除,若value不存在则报错

-discard(value):指定删除，若value不存在不会报错

-isdisjoint():判断两个集合是否有交集

-issubset():是否为子集

-issuperset():是否为父集

-update():求并集并更新

关系运算

交∩：& intersection()

并∪：| union()

补：^ symmetric_difference()

差：- difference()【difference_update()】

集合是可变类型，但是用frozenset()可以变为不可变类型

集合也可以用于简单的去重操作

二、字符串格式化和Format方式

【记住常用的即可】必须一一对应

%：占位符

%s：可接受任意类型

%d：之可接受整形

%.2f：接受浮点数，保留两位小数

%%：百分号

%(key)s：使用键值对进行获取

%s：字符串占位符,可以接收字符串，也可接收数字

#%s字符串占位符：可以接收字符串，也可接收数字
print('My name is %s,my age is %s' %('egon',18))
#%d数字占位符：只能接收数字
print('My name is %s,my age is %d' %('egon',18))
print('My name is %s,my age is %d' %('egon','18')) #报错

#接收用户输入，打印成指定格式
name=input('your name: ')
age=input('your age: ') #用户输入18,会存成字符串18,无法传给%d

print('My name is %s,my age is %s' %(name,age))

#注意：
#print('My name is %s,my age is %d' %(name,age)) 
#age为字符串类型,无法传给%d,所以会报错

三、函数

函数是逻辑结构化和过程化的一种编程方法

• 代码重用
• 保持一致性，易维护性
• 可扩展性

函数定义语法

def test(x):

    “function description”

    x+=1

    return x

def——定义函数的关键字

test()——函数名

"xxx"——函数功能描述，非必要，但阅读方便

(x)——内可定义形参

x+=1——代码块，处理逻辑

return——返回值（可以返回多个值，以元组方式返回;没有返回值则返回None）

函数参数

形参：只有在被调用时才分配内存单元，调用结束则立刻释放所分配的内存单元

实参：可以是任意类型的量，在被调用时必须要有确定的值，其本身占据内存空间

位置参数和关键字参数：标准调用时实参与形参位置一一对应；关键字调用时位置无需固定

位置参数必须在关键字参数的左边

对同一个形参不可以重复传值

默认参数：def handle(x, type='asodf')，形参在定义时就已经为其赋值

参数组:变长输入，**字典，*列表。*args要在**kwargs前面，原理和位置参数和关键字参数位置一样

*args参数：可接受任意个位置参数，当函数调用时，所有未使用（未匹配）的位置参数会在函数内自动组装进一个tuple对象中，此tuple对象会赋值给变量名args

**kwargs参数：可接受任意个关键字参数，当函数调用时，所有未使用（未匹配）的关键字参数会在函数内组装进一个dict对象中，此dict对象会赋值给变量名kwargs。

定义函数

*参数收集所有未匹配的位置参数组成一个tuple对象，局部变量args指向此tuple对象

**参数收集所有未匹配的关键字参数组成一个dict对象，局部变量kwargs指向此dict对象

调用函数

*参数用于解包tuple对象的每个元素，作为一个一个的位置参数传入到函数中

**参数用于解包dict对象的每个元素，作为一个一个的关键字参数传入到函数中

#===========*args===========

def foo(x,y,*args):

    print(x,y)

    print(args)

foo(1,2,3,4,5)

print("*******************")


def foo(x,y,*args):

    print(x,y)

    print(args)

foo(1,2,*[3,4,5])

print("*******************")

def foo(x,y,z):

    print(x,y,z)

foo(*[1,2,3])

print("*******************")


# 输出
1 2

(3, 4, 5)

*******************

1 2

(3, 4, 5)

*******************

1 2 3

*******************

#===========**kwargs===========

def foo(x,y,**kwargs):

    print(x,y)

    print(kwargs)

foo(1,y=2,a=1,b=2,c=3)

print("*******************")


def foo(x,y,**kwargs):

    print(x,y)

    print(kwargs)

foo(1,y=2,**{'a':1,'b':2,'c':3})

print("*******************")


def foo(x,y,z):

    print(x,y,z)

    foo(**{'z':1,'x':2,'y':3})

print("*******************")

# 输出
1 2

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

*******************

1 2

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

*******************

2 3 1

*******************

def foo(x,y,*args,a=1,b,**kwargs):

    print(x,y)

    print(args)

    print(a)

    print(b)

    print(kwargs)


foo(1,2,3,4,5,b=3,c=4,d=5)



#输出

1 2

(3, 4, 5)

1

3

{'c': 4, 'd': 5}

def test(x, *args):

    print(x)

    print(args)



test(1, ['x', 'y', 'z'])#把列表当作一个元素

print('-----------------')

test(1, *['x', 'y', 'z'])#依次遍历


#输出

1

(['x', 'y', 'z'],)

-----------------

1

('x', 'y', 'z')

def test1(x, **kwargs):

    print(x)

    print(kwargs)



test1(1, y=2, z=3)#正确

test1(1,1,1,2,3, y=2, z=3)#报错

test1(1, **{'x1':'z1'})

test1(1, {'x1':'z1'})#报错

函数即“变量”，“变量”必须先定义后引用。未定义而直接引用函数，就相当于在引用一个不存在的变量名。但也要区分好定义阶段和调用阶段

#定义阶段
def foo():
    print('from foo')
    bar()

def bar():
    print('from bar')

#调用阶段
foo()         #不会报错

函数在定义解读按只监测语法，如果出现逻辑错误只会在执行时才会知道

空函数，只是在定义程序结构时使用，如父类，定义一些抽象函数