python day4 元组/字典/集合类知识点补充
(学习资源来自老男孩教育)
2019/10/7
1. 元组tuple知识点补充
- 创建和转换
t = (11,22,33)
t = tuple(iterable)，比如tuple([11,22,33])
- 元组的特性
元组的特性：元组的元素不可修改，但是元素的元素可以被修改。即元组的儿子不能变，但是元组的孙子可以变。
t = (11,22,33,['lan',{'name':'lanxing'}])
t[5]=44 #会报错，因为元组的元素不可修改
t[3][0]='xing' #不会报错，因为元组的孙子可以修改。
2. 字典dict的知识点补充
- 创建和转换
dict1 = {'k1':33,'k2':'xy'}
dict2=dict(k1=33,k2='xy')` 本质上都是用的第二种方法。
- fromkeys值的指向是同一个内存地址
d1 ={'k1':[],'k2':[],'k3':[]}
d1['k1'].append('x')
print(d1)
d2 =d1.fromkeys(d1,[])
x1 = d2['k1'].append('x')
print(d2) # 因为fromkeys(iterable,v)，这个v指向是同一个内存地址
3. 基本数据类型set
集合set是一个无序且元素唯一的元素集合。集合主要用来做关系测试。
- 创建一个集合
s1 = {1,2,'x','y',True}
s2 = set((1,2,'x','y',True)) set()中的参数是可迭代对象。
本质上集合set就是字典的keys。
- 集合的方法
add,clear,difference,difference_update,discard,remove,intersection,isdisjoint,issubset,
s2 = set((1,2,'x','y',True))
s2.add(3) #往集合里面添加元素3
s2.add('z')
s1 = {1,2,'x','y',True,'name'}
s1.difference(s2) # 找s1中存在，s2中不存在的元素。即找差集
s1-s2 # 找s1中存在，s2中不存在的元素。与difference功能一样
s1.difference_update(s2) # 找s1中存在，s2中不存在的元素，并更新自己,也就是s1把两者之间的交集去掉。
s1.discard('x') #移除指定元素，元素不存在也不报错。
s1.discard('x') #移除指定元素，不存在则会报错。
s1.intersection(s2) #找交集，即s1中存在，s2中也存在的元素。
s1.isdisjoint(s2) #判断是否没有交集，有交集是False,没有交集是False。
s1.issubset(s2) # 判断s1是否是s2是子集合
s1.symmetric_difference(s2) #求对称差集，即s1中存在，s2中也存在，但不是双方都存在的元素。
s1 ^ s2 # 求对称差集
s1.union(s2) #求并集。
s1 | s2 #求并集
作业：
有两个字典old_dict和new_dict，要求：
- 两个字典的key相同的，将old_dict[key]中的值更新为new_dict[key]的值。
- new_dict.keys()存在的，在old中添加，不存在的，old中删除。
old_dict =dict(#1=11,#2=22,#3=100)
new_dict = dict(#1=33,#4=22,#7=100)
# 字典的key相同即判断是否有交集,所以第一步先找出交集
s1 = set(old_dict.keys())
s2 = set(new_dict.keys())
s3 = s1.intersection(s2)
# 使用for迭代来更新old中的值
for i in s3:
old_dict[i] = new_dict[i]
# 找到s1与s2的差集，并进行迭代，删除旧元素。
s4 = s1 - s2
for i in s4:
old_dict.pop(i)
s5 = s2 - s1
for i in s5:
old_dict[i]=new_dict[i]
print(old_dict)
4. 三元运算，又叫三目运算
if 1==1:
name ='x'
else:
name='y'
name ='x' if 1==1 else 'y' #这就叫三元运算。
5. 深复制浅复制
- 对于数字和字符串来说，不需要追究深浅复制的不同，因为他们是不可变对象，永远指向的同一个内存地址。
- 对于列表，字典，元组，集合等，深浅复制是不同的。
浅复制时，只复制第一层内存地址，而深复制时，全部复制。
import copy
li1 = [1,2,[3,4]]
li2 = copy.copy(li1) # 浅复制，只是复制第一层元素的内存地址引用。即li2的嵌套列表的悠会影响原列表的嵌套列表。
id(li1) == id(li2)
li2[2].append(5)
li2.append(6)
print(li1,li2)
li3 = copy.deepcopy(li1) # 深复制，li3的任何修改都与li1无关了。
li3[2].append(5)
li3.append(6)
print(li1,li3)
6. 函数
编程有三类：函数式编程，面向对象过程，面向过程编程。
- 面向过程编程：根据业务逻辑从上到下按顺序实现功能，开发过程中最常见的操作就是粘贴复制，也就是将之前的代码块复制到现需功能。
- 函数式编程：即将指定的功能编成函数，想用的时候就拿出来。在函数式编程中，每一个功能都是一个函数。函数式编程，先考虑动词。
- 面向对象编程：将不同对象进行分类，再考虑不同对象拥有哪些功能。开发时先考虑名词，即不同的对象。
- 定义函数
函数就是拥有功能的代码块,可以不断进行复用。
数学函数：f(x,y)=xy2,f是函数名，x,y是参数，xy2是函数执行语句。
- 定义函数的语法：
def funcname(x,y,z='hello',*args,**kwargs): #定义函数
print(x,y,z,args,kwargs) #函数的执行语句
return x,y,z,args,kwargs #函数的返回值
- def是定义函数的关键字，funcname是函数的名称，是一个变量,可以不断修改，()里面是函数的参数，return关键字后面的内容是函数的返回值。调用函数时，遇到return就结束了。如果没有return关键字，则默认返回None(空)。
函数的调用，如果要使用函数，funcname(1,2)，即函数名+括号(参数1，参数2)即可，就会自动执行函数体(函数的执行语句)。
- 函数的参数
def func(x,y,z='hello'):
pass #pass关键字是什么也不做，表示占位符
- 括号里面的x,y,z叫做参数中的位置参数，等到执行的时候，func(1,2)，即表示将1，2赋值给了x,y，也叫1，2传入了参数x,y。这里1，2叫做实参。
- z叫做默认参数，默认参数在函数调用时，是可选传入的，如果不传入，则默认z的实参就是'hello'。
- 函数调用时，参数的传值默认按照位置形参的位置进行传入。默认参数的实参必须在位置参数的后面。但如果指定形参传入实参，可以不按照顺序
func(1,2),func(y=2,x=1)是一样的效果，没有传入形参z的实参，因为z有默认值。
func(1,2,4) 与func(y=2,z=4,x=1)是一样的效果。
函数的动态参数：动态参数可以接收无限个实参。
def myfunc(x,y,z='hello',*args,**kwargs): # 其中*args叫做动态位置参数，**kwargs叫动态关键字参数
print(x,y,z,args,kwargs,sep=',') #函数的执行语句
return x,y,z,args,kwargs #函数的返回值
函数调用时，动态位置参数必须在动态关键字参数前面。 动态位置参数是一个元组，动态关键字参数是一个字典。
myfunc(1, 2, 'hellow world', 4, 5, k='hello,lanxing', my='lanxing')
1,2,hellow world,(4, 5),{'k': 'hello,lanxing', 'my': 'lanxing'}
4. 为动态参数传入列表，字典，元组时，列表，表示将列表中的每个元素都当作位置参数的实参传入，字典，就是将字典中的每个键值对都当作关键字参数。
- 全局变量和局部变量
函数内部中的变量只作用于该函数内部，对外界没有影响。
a=1 #全局函数，都有作用
def func1():
b=2 #局部变量
global a #通过关键字global 声明a是全局变量，会影响函数外部的a
a = 3 #修改了全局变量a的赋值
print(a) #全局变量作用于整个页面
print(b)
print(a) #这里输出的是修改了的全局变量a
print(b) #会报错，因为局部变量只作用于函数内部
func1() #调用函数
def countLength(s):
li1 = []
li2 = []
li3 = []
for i in range(len(s)):
if s[i].isdigit():
li1.append(s[i])
elif s[i].isalpha():
li2.append(s[i])
elif s[i].isspace():
li3.append(s[i])
return len(li1), len(li2), len(li3), len(s)-len(li1)-len(li2)-len(li3)
#countLength(' 123 xyz aa 蓝星***')
def countLen(obj):
if len(obj) >= 5:
print('%s长度大于5' % obj)
else:
print('%s长度小于5' % obj)
# countLen([1, 2, 3, 4])
def isSpace(obj):
a = 0
for i in obj:
for j in i:
if j.isspace():
a += 1
return a
li = ['x y', 'abc12 4 5', ' z y ']
# print(isSpace(li))
def chlist(li):
if len(li) > 2:
return li[:2]
return li
#print(chlist([1, 2, 3, 4]))
def oddSeq(li):
list1 = []
for i in range(len(li)):
if i % 2 != 0:
list1.append(li[i])
return list1
#print(oddSeq([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]))
dict1 = {'k1': 'v1v1', 'k2': [11, 22, 33, 44]}
def lenDict(**kwargs):
for k, v in kwargs.items():
if len(v) > 2:
kwargs[k] = v[:2]
return kwargs
# print(lenDict(**dict1))
def feibonaqi(n):
if n == 0:
return 0
elif n==1:
return 1
else:
return feibonaqi(n-2)+feibonaqi(n-1) #递归就是在函数内部调用自己，相当于数学函数中的f(x)=f(x-1),f(0)=0
print(feibonaqi(9))
i = 0
li =[]
while i<10:
li.append(feibonaqi(i))
i +=1
print(li,len(li))