python day4 元组/字典/集合类知识点补充 – Python量化投资

python day4 元组/字典/集合类知识点补充

目录 python day4 元组/字典/集合类知识点补充 1. 元组tuple知识点补充 2. 字典dict的知识点补充 3. 基本数据类型set 4. 三元运算,又叫三目运算 5. 深复制浅复制 6. 函数 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)=x y 2,f是函数名,x,y是参数,x y 2是函数执行语句。 定义函数的语法: 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’} 为动态参数传入列表,字典,元组时, 列表,表示将列表中的每个元素都当作位置参数的实参传入, 字典,就是将字典中的每个键值对都当作关键字参数。 全局变量和局部变量 函数内部中的变量只作用于该函数内部,对外界没有影响。 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))https://www.cnblogs.com/lanxing0422/p/pythonday4.html

「点点赞赏,手留余香」

    还没有人赞赏,快来当第一个赞赏的人吧!
GO
0 条回复 A 作者 M 管理员
    所有的伟大,都源于一个勇敢的开始!
欢迎您,新朋友,感谢参与互动!欢迎您 {{author}},您在本站有{{commentsCount}}条评论