1.集合的使用
- 1.1集合的操作
- len(),返回集合的长度。
s = set('python')#s为{'p','y','t','h','o','n'} len(s)#值为6
- add(),为集合添加单个元素(可以是任何对象),如果原集合中有添加的对象,集合不变(自动去重)。
s = set('python')#s为{'p','y','t','h','o','n'} s.add(1)#s的值为{'p','y','t','h','o','n',1}
- update(),把括号内的对象(可以迭代)的值(字典是key)添加到原集合中,如果原集合中有添加的元素,则自动去重。
s =set('python')#s为{'p','y','t','h','o','n'} s.add(1)#s的值为{'p','y','t','h','o','n',1} s1 = [2,3,1] s.update(s1)#s为{'p','y','t','h','o','n',1,2,3}
- pop(),随机去除集合中的一个值并返回该值。
s =set('python')#s为{'p','y','t','h','o','n'} a=s.pop() print(s,a)#我这次的运行结果为{'p', 't', 'y', 'o', 'h'} n
- remove()去除集合中指定的元素。如果元素不存在,则系统给出KeyError。
s =set('python')#s为{'p','y','t','h','o','n'} s.remove('n')#s为{'p','y','t','h','o'} s.remove('e')#KeyError:'e'
- clear(),清空集合。
s =set('python')#s为{'p','y','t','h','o','n'} s.clear()#s为set()
- 1.2集合的运算
- 交集,两个集合都包含的元素集合,语法
集合a & 集合b
或a.intersection(b)
。 - 差集,在集合A中但不在集合B中的元素集合,语法
集合a - 集合b
,也可以使用difference(),语法a.difference(b)
。 - 并集,在集合A中或在集合B中的元素集合,语法
集合a | 集合b
或a.union(b)
。 - 异或集,在集合A中但不在集合B中或者在集合B中但不在集合A中,语法
集合a ^ 集合b
或a.symmetric_difference(b)
。 - 子集,真子集,超集,真超集。语法为
a = {1,2,3} b = {1,2,3,4,5} c = {1,2,3,4,5} print(f'a是b的子集:{a <= b},a是b的真子集:{a < b}') print(f'c是b的子集:{c <= b},c是b的真子集:{c < b}') print(f'b是a的超集:{b >= a},b是a的真超集:{b > a}') print(f'b是c的超集:{b >= c},b是c的真超集:{b > c}') ''' 运行结果为: a是b的子集:True,a是b的真子集:True c是b的子集:True,c是b的真子集:False b是a的超集:True,b是a的真超集:True b是c的超集:True,b是c的真超集:False '''
- 交集,两个集合都包含的元素集合,语法
2.可变对象
- 2.1对象三要素:id,type,value。可变对象是指在id,type都不变的情况下value可以改变。把变量a赋值给b时,就是把对象的三要素都传给了b,当a为可变变量时,a或b的值改变会影响到另外一个变量值的改变;当a为不可变量时,值是不能改变的,需要改变值,实际上是变量重新赋值,这时变量a的id改变了,但b的id没有改变,所以此时a和b实际表示的不同对象,所以互不影响。
a = [1,2,3,4]
b = a
a[0] = 10
print(f'a的值是{a},{id(a)}')
print(f'b的值是{b},{id(b)}')
'''
运行结果为:
a的值是[10, 2, 3, 4],97830280
b的值是[10, 2, 3, 4],97830280
'''
a = 1,2,3,4
b = a
a = 10,2,3,4
print(f'a的值是{a},{id(a)}')
print(f'b的值是{b},{id(b)}')
'''
运行结果为:
a的值是(10, 2, 3, 4),10070488
b的值是(1, 2, 3, 4),10068368
'''
3.函数
- 3.1函数
- 函数是一个存放固定功能代码块的对象。
- 语法
def 对象名(形参1,形参2,形参3): 代码块
- 调用,函数不调用不执行,每调用一次,执行一次,调用语法
对象名()
。
- 3.2函数的参数
- 形参,定义函数时在对象名后面括号中定义的参数为形参。
- 实参,调用函数时实际传入函数的参数。
- 函数参数传递方式,主要有位置参数和关键字参数;每个函数可以有且只能有一个不定长位置参数(args),放置在位置参数之后关键字参数之前;每个函数可以有且只能有一个不定长关键字参数(kwargs),放置在所有参数之后。
- 函数的解包,在需要传递可迭代对象(非字典)元素时可以用,但要保证可迭代对象元素个数与位置参数个数一致,在需要传递字典的值时可以用*,但要保证字典items的个数与关键字参数个数一致。
def add(a,b,*args,c=6,f=9,**kwargs): num_sum = a + b for each in args: num_sum += each num_sum += c num_sum += f for key in kwargs: num_sum += kwargs[key] print(f'a参数值为{a}') print(f'b参数值为{b}') print(f'c参数值为{c}') print(f'f参数值为{f}') print(f'args参数值为{args}') print(f'kwargs参数值为{kwargs}') return num_sum t = [100,2,6,76,12] d = {'x':98,'y':99,'z':3} r = add(*t,g=71,**d) print(r) ''' 运行结果为: a参数值为100 b参数值为2 c参数值为6 f参数值为9 args参数值为(6, 76, 12) kwargs参数值为{'g': 71, 'x': 98, 'y': 99, 'z': 3} 482 '''
4.函数的返回值
- 4.1返回值,我理解为函数运行的结果,函数实现功能后将你需要的结果返回。通常用return来返回需要的值。一般用变量来存储函数返回值,以便程序使用。
def add_fun(*args): r = 0 for n in args: r += n return r add = add_fun(1,5,100)#add变量存储了函数add_fun的返回值
- 4.2return后面可以跟任何对象。
def fn(): #return 123 #return 'python' #return [1,2,'a'] #return {2,3,4,5} def fn1(): return 9 return fn1#可以return数字、字符串、序列、函数等所以对象 b = fn()()#b的值为9
5.文档字符串
- 5.1help()函数来验证
help(print) ''' 运行结果: Help on built-in function print in module builtins: print(...) print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False) Prints the values to a stream, or to sys.stdout by default. Optional keyword arguments: file: a file-like object (stream); defaults to the current sys.stdout. sep: string inserted between values, default a space. end: string appended after the last value, default a newline. flush: whether to forcibly flush the stream. '''
- 5.2主要用来说明函数体作用的文档字符串
def sum_num(*args): ''' 求任意数的和 :param args: 不定位置参数,可以接受多个加数 :return: add ''' add = 0 for i in args: add += i return add help(sum_num) ''' 运行结果: Help on function sum_num in module __main__: sum_num(*args) 求任意数的和 :param args: 不定位置参数,可以接受多个加数 :return: add '''
6.函数的作用域
- 6.1作用域就是变量生效的区域。
- 6.2全局作用域和函数作用域。
a = 30 class Cla: a = 20 def fn(self): a = 10 print(f'Cla类内fn函数内a的值是{a}') d = Cla() d.fn() print(f'Cla类外a的值是{a}') print(f'Cla类内fn函数外a的值是{d.a}') ''' 运行结果为: Cla类内fn函数内a的值是10 Cla类外a的值是30 Cla类内fn函数外a的值是20 '''
- 6.3关键字global,可以在函数体或类中声明变量为全局。
a = 30
class Cla:
a = 20
def fn(self):
global a
a = 10
print(f'Cla类内fn函数内a的值是{a}')
d = Cla()
d.fn()
print(f'Cla类外a的值是{a}')
print(f'Cla类内fn函数外a的值是{d.a}')
'''
运行结果为:
Cla类内fn函数内a的值是10
Cla类外a的值是10
Cla类内fn函数外a的值是20
'''
7.命名空间
用来保存函数变量的字典,变量名为字典的keys。
locals(),用来获取当前作用域的命名空间。
a = 123
b = 1,2,3
c = {'one':1,'two':2,'three':3}
d = [1,2,3]
def fn():
return 123
local_dict = locals()
print(local_dict)
'''
运行结果为:{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at \
0x0019AF40>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'C:/Python3/function/命名空间.py', \
'__cached__': None, 'a': 123, 'b': (1, 2, 3), 'c': {'one': 1, 'two': 2, 'three': 3}, 'd': [1, 2, 3], 'fn': <function fn at 0x0060DCD0>, \
'local_dict': {...}}
'''
8.递归函数
- 8.1递归是一种解题思路,它是把一个大问题分解为若干个小问题,然后通过解决一个一个小问题来解决大问题的方法。
- 8.2递归函数:
- 递归函数简单的说就是自己调用自己。
- 递归函数使用条件:
- 基线条件,可以把大问题分解为小问题,当满足基线条件时,递归结束。
- 递归条件,将问题继续分解的条件
- 8.3递归函数练习
- 任意数的幂运算
def fn(n,i): if i == 1: r = n else: r = n*fn(n,i-1) return r fn(10,9)#1000000000
- 判断回文字符串
def fn(n): if len(n)<2: return True elif n[0]!=n[-1]: return False else: return fn(n[1:-1]) fn('adlsjdajslda')#False
- 8.3我的思考,递归思想是一种很好的解决问题的方法,但是也要考虑运行效率,有些问题用递归快而明了,有些问题则不然。要成为一个优秀的程序员必须要学会计算机资源的充分利用。
作业
用递归解决汉诺塔游戏。
解题思路:1 A-->C
2 1个盘子A-->B(A-->B),A-->C,1个盘子B-->C(B-->C)
3 2个盘子A-->B(A-->C,A-->B,C-->B),A-->C,2个盘子B-->C(B-->A,B-->C,A-->C)
……
n-1 n-2个盘子A-->Bf(n-2,a,c,b),A-->C,n-2个盘子B-->Cf(n-2,b,a,c)
n n-1个盘子A-->Bf(n-1,a,c,b),A-->C,n-1个盘子B-->Cf(n-1,b,a,c)
当A上有n个盘子,先将n-1个盘子放到B上,然后将A上的最大的第n个盘中方到C上,在将B上n-2个盘在放到A上,将B上第n-1盘子方到C上以此类推至最后最小的盘放到C上。
def hanoi(n,a,b,c):
if n == 1:
print(f'{a}-->{c} ',end='')
else:
hanoi(n - 1,a,c,b) # 把A上n-1个盘子放到B上
print(f'{a}-->{c} ',end='') # 把第n个盘子放到C上
hanoi(n - 1,b,a,c) # 把B上n-1个盘子放到C上
hanoi(6,'A','B','C')
'''
运行结果为:
A-->B A-->C B-->C A-->B C-->A C-->B A-->B A-->C B-->C B-->A C-->A B-->C \
A-->B A-->C B-->C A-->B C-->A C-->B A-->B C-->A B-->C B-->A C-->A C-->B \
A-->B A-->C B-->C A-->B C-->A C-->B A-->B A-->C B-->C B-->A C-->A B-->C \
A-->B A-->C B-->C B-->A C-->A C-->B A-->B C-->A B-->C B-->A C-->A B-->C \
A-->B A-->C B-->C A-->B C-->A C-->B A-->B A-->C B-->C B-->A C-->A B-->C \
A-->B A-->C B-->C
'''