Python基础第9讲 - 集合和函数_python中数字的集合怎么表示

Python基础第9讲 - 集合和函数

一、集合：

1.1 集合的表现形式 set ，集合和列表基本一致

不同点：

1、集合只能存储不可变对象

2、集合中存储的对象无序的

s = {1,10,2,3,7,4}
print(s,type(s))      # {1, 2, 3, 4, 7, 10} <class 'set'>
1
2

3、集合中不能出现重复的元素

s = {1,10,2,3,7,4,1,2,2}
print(s)              # {1, 2, 3, 4, 7, 10}
1
2

1.2 set()函数创建集合

1.2.1 set()函数创建集合

s = set([1,2,3,4,5,4,5,4,5,4])
print(s,type(s))        # {1, 2, 3, 4, 5} <class 'set'>
1
2

1.2.2 使用set()函数将字典转换为集合的时候，只会包含字典的键

s1 = set({'a':1,'b':2})   
print(s1,type(s1))      # {'a', 'b'} <class 'set'>

s2 = set('python')
print(s2,type(s2))      # {'o', 't', 'n', 'p', 'y', 'h'} <class 'set'>
1
2
3
4
5

1.2.3 集合只能存储不可变对象

错误的：

s = {[1,2,3],[4,5,6]}
print(s)              # TypeError: unhashable type: 'list'
1
2

1.2.4 集合没有索引，不能用索引值返回值,所以要转换为列表

s3 = {'a','b',1,2,3}
print(s3,type(s3))       # {1, 2, 3, 'a', 'b'} <class 'set'>
print(list(s3)[0])       # 1
1
2
3

1.3 集合的使用

1.3.1 in 和 not in 来检查集合中的元素，结果会返回一个bool值

s3 = {'a','b',1,2,3}
print('b' in s3)     # True
1
2

1.3.2 len()获取集合中元素的长度

s3 = {'a','b',1,2,3}
print('b' in s3)     # 5
1
2

1.3.3 add()可以向集合中添加元素

s3 = {'a','b',1,2,3}
s3.add(55)
s3.add(60)
print(s3)           #{1, 2, 3, 'a', 55, 'b', 60}
1
2
3
4

1.3.4 update() 讲一个集合中的元素添加到当前集合中

s = {'a','b',1,2,3}
s1 = set('python')
s.update(s1)
print(s)            #{1, 'a', 3, 2, 'p', 'h', 't', 'n', 'b', 'y', 'o'}
1
2
3
4

1.3.5 pop() 随机删除集合中的一个元素

s = {'a','b',1,2,3}
result = s.pop()
print(result)     # 结果是s的随机一个
1
2
3

1.3.6 remove() 删除集合中指定的元素

s = {'a','b',1,2,3}
s.remove(1)
print(s)    # {2, 3, 'b', 'a'}
1
2
3

1.3.7 clear() 删除集合中指定的元素

s = {'a','b',1,2,3}
s.clear()
print(s)     # set()
1
2
3

1.4 集合的运算

二、集合的运算

2.1 交集运算（&）

s = {1,2,3,4,5}
s2 = {3,4,5,6,7}
res = s & s2
print(s,s2,'result =',res)    #  {1, 2, 3, 4, 5} {3, 4, 5, 6, 7} result = {3, 4, 5}
1
2
3
4

2.2 并集运算（|）

s = {1,2,3,4,5}
s2 = {3,4,5,6,7}
res = s | s2
print(s,s2,'result =',res)    # {1, 2, 3, 4, 5} {3, 4, 5, 6, 7} result = {1, 2, 3, 4, 5, 6, 7}
1
2
3
4

2.2 差集运算（-）

s = {1,2,3,4,5}
s2 = {3,4,5,6,7}
res = s - s2     # 返回 1，2
res = s2 - s     # 返回 6，7
print(s,s2,'result =',res)
1
2
3
4
5

2.3 亦或集运算（^）

s = {1,2,3,4,5}
s2 = {3,4,5,6,7}
res = s ^ s2
print(s,s2,'result =',res)   # {1, 2, 3, 4, 5} {3, 4, 5, 6, 7} result = {1, 2, 6, 7}
1
2
3
4

2.4 检查一个集合是否另一个集合的子集（<=） ，结果返回的是一个bool值

a = {1,2,3}
b = {1,2,3,4,5}
res = a <= b
print(res)   			  #  True
1
2
3
4

2.5 检查一个集合是否另一个集合的真子集（<），结果返回的是一个bool值

a = {1,2,3}
b = {1,2,3,4,5}
result = {1,2,3} < {1,2,3}
print(result)     			#  False
1
2
3
4

2.6 检查一个集合是否另一个集合的超集（=>）

a = {1,2,3}
b = {1,2,3,4,5}
res = a >= b
print(res)    #  False
1
2
3
4

2.7 检查一个集合是否另一个集合的真超集（>）

a = {1,2,3}>
b = {1,2,3,4,5}
res = a > b
print(res)    # False
1
2
3
4

三、函数

3.1 函数也是一个对象

对象是内存中专门用来存数据的一块区域
函数用来保存一些可以执行的代码，并且可以在需要的时候对这些语句多次调用

创建函数
语法：
def 函数名([形参1,形参2,形参3...]):
	代码块
1
2
3
4
5
6
7

def fn():

    print('这是我第一个函数')
    print('abc','bcd')
    print('python')
    print('hahaha')
# 打印fn
print(fn) 		# <function fn at 0x0058A930>
# 运行函数
print(fn())
1
2
3
4
5
6
7
8
9
10

四、函数的参数

1、在定义函数的时候，可以在函数名后面的括号里面定义数量不等的形参
2、多个形参我们用逗号（,）隔开
3、形参（形式参数）定义形参就是相当于在函数内部定义了变量，但是并没有赋值
4、实参（实际参数）函数定义时指定了形参，那么 调用函数的时候也必须传递是实参
5、实参将会赋值给对应的形参，有几个形参就传几个实参

# 定义一个函数来实现任意两个数字的和
 def sum():
     a = 1
     b = 2
     res = a + b
     print(res)
 sum()
 结果：3
1
2
3
4
5
6
7
8

def fn2(a,b):
    # a = None
    # b = None
    print('a =',a)
    print('b =',b)
fn2(101,11)       
结果：a = 101
	  b = 11
1
2
3
4
5
6
7
8

五、函数的传递方式

1.定义形参的时候我们可以为形参指定一个默认值

2.指定了默认值以后，如果用户传递了参数，默认值是不会有任何作用的

3.如果用户没有传递，则默认值会生效

def fn(a = 5,b = 8,c = 10):
    print('a =', a)
    print('b =', b)
    print('c =', c)
fn()
# 结果：
 	 a = 5
	 b = 8
	 c = 10
1
2
3
4
5
6
7
8
9

5.1 位置传参:位置传参就是将对应位置的实参传递对应位置的形参

5.2 关键字传参：可以不按照形参定义的顺序去传参，而根据参数名来传递参数

位置传参也可以和关键字传参混合使用
混合使用的时候，必须把位置位置参数写到关键字参数前面,位置传参写到最后面

def fn(a = 5,b = 8,c = 10):
    print('a =', a)
    print('b =', b)
    print('c =', c)
fn(b=1,c=2,a=3)
# 结果：
    a = 3
    b = 1
    c = 2
1
2
3
4
5
6
7
8
9

with open(‘xxx’,‘wb’,encoding=‘utf8’) as f:

pass

六 实参的类型

1.函数在调用的时候，解释器不会检查实参的类型

2.实参的类型可以是任意对象

def fn3(a):
    print('a =',a)

b = 123
b = 'python'
b = True
b = False
b = [123]

fn3(fn)    # 结果： a = <function fn at 0x00AEA930>
1
2
3
4
5
6
7
8
9
10

def fn4(a,b):
    print(a + b)
fn4(1,1)            #  2
fn4(1,'2')          # TypeError: unsupported operand type(s) for +: 'int' and 'str'
1
2
3
4

def fn5(a):
    # 在函数中对形参重新复制不会影响其他变量
    a = 30
    print('a =', a, id(a))    #结果 a = 30 1381525120
c = 10
c = [1,2,3]
fn5(c)

print('c =',c,id(c))          # 结果 c = [1, 2, 3] 16795128
1
2
3
4
5
6
7
8
9

def fn6(a):
    # 如果形参在执行的时候，当我们通过形参去修改对象时，会影响到指向该对象的变量
    a[0] = 50
    print('a =', a, id(a))   # a = [50, 2, 3] 16795128
c = 10
c = [1, 2, 3]
fn6(c)

print('c =', c, id(c))       # c = [50, 2, 3] 16795128
1
2
3
4
5
6
7
8
9

七、 不定长参数

需求： 定义一个函数来实现任意数的和

7.1 在定义函数的时候，可以在形参的前面加上一个*,这样这个形参将会获取到所有的形参， 它会将所有的实参保存到一个元祖中

def s(*a):

    # 定义一个变量来保存 结果
    r = 0
    # 遍历元祖，将元祖中的元素取出来并进行累加
    for n in a:
        r += n
    print(r)

s(1,2,3,4,5,6)         
结果： 21
1
2
3
4
5
6
7
8
9
10
11

def fn2(a,b,*c):

    print('a =',a)
    print('b =',b)
    print('c =',c)

fn2(1,2,3,4,5,6)
结果：  a=1
       b=2
       c=(3,4,5,6)
1
2
3
4
5
6
7
8
9
10

7.2 可变长参数不是必须要写到最后的，但是注意 带*的参数后面的参数，必须以关键字的形式传参

def fn2(a,*b,c=6):

    print('a =',a)
    print('b =',b)
    print('c =',c)
 结果： a = 1
       b = (2, 3, 4, 5, 6)
       c = 6
1
2
3
4
5
6
7
8

def fn2(*a,b,c):

    print('a =',a)
    print('b =',b)
    print('c =',c)

fn2(1,2,3,4,b=5,c=6)
结果： a = (1, 2, 3, 4)
      b = 5
      c = 6
1
2
3
4
5
6
7
8
9
10

7.3 若果在形参的开头直接写一个*，则要求我们但是所有的参数要以关键字的形式来传递

def fn2(*,a,b,c):

    print('a =',a)
    print('b =',b)
    print('c =',c)

fn2(a=3,b=4,c=5)
1
2
3
4
5
6
7

7.4 **形参可以接收其他的关键字参数，它会将这些参数统一保存到一个字典当中， 字典当中的key是参数的名字，字典当中的value是参数的值， **形参只能有一个，并且必须写在最后面

def fn3(b,c,**a):
    print('a =', a,type(a))

    print('b =',b)
    print('c =',c)

fn3(b=1,d=2,c=3,e=4,f=5)
# 结果：a = {'d': 2, 'e': 4, 'f': 5} <class 'dict'>
#      b = 1
#      c = 3
1
2
3
4
5
6
7
8
9
10

八、 参数解包

def fn4(a,b,c):
    print('a =', a)
    print('b =', b)
    print('c =', c)
1
2
3
4

这里面要求序列中的元素的个数必须和形参的个数一致

t = (5,6,7,8)

d = {'a':100,'b':200,'c':300}


fn4(**d)
# 结果：
		 a = 100
		 b = 200
		 c = 300
1
2
3
4
5
6
7
8
9
10