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

(学习资源来自老男孩教育)

2019/10/7

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

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