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'}

为动态参数传入列表，字典，元组时，列表，表示将列表中的每个元素都当作位置参数的实参传入，字典，就是将字典中的每个键值对都当作关键字参数。

全局变量和局部变量

函数内部中的变量只作用于该函数内部，对外界没有影响。

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))