一、元组

1.1 元组的简介

元组的表现形式 tuple
元组是一个不可变的序列
在开发过程中，如果我们不希望序列发生变化就使用元组，其余情况一律使用列表

1.2 创建元组

创建元组共有三种方式

第一种：()

tup = ()     #创建一个空的元组
           #元组中的元素可以是任意的数字类型包括整型、浮点型、列表、元组、字符串等
           tup1 = (1,1.2,"haha",[1,2],{"name":"hw","age":18},(1,2))

第二种：tuple()

tup = tuple()           #创建一个空的元组
         tup1 = tuple("hello")   #创建一个非空的元组（将字符串强制类型转换为元组）
         print(tup1)             #返回值为('h', 'e', 'l', 'l', 'o')

第三种：加“，”方式

tup = 10,               #若创建的是一个非空元组，则至少需要有一个“，”
       tup1 = 10,"h",20,1.2    #创建一个非空元组
       print(tup,type(tup))

1.3 访问元组中的元素

访问字典中元素的方法和访问列表中元素的方法一致

语法为：

元组名[索引值]

索引值从0开始，最后一个元组元素的索引值为len(元组名)-1

tup = (1,2,'s','h','d')
         print(tup[3])   #返回索引值为3的元素，返回值为“h”

注：

元组是一个不可变的序列，因此不可以对元组进行增、删、改、

查的操作

1.4 元组的解包

解包：将元组中的每一个元素赋值给每一个变量

tup1 = 10,20,30,40
         a,b,c,d = 10,20,30,40   #元组解包

         a,b = 10,20,30,40   #元组解包
         print("a = ",a,"b = ",b)  #报错  ValueError: too many values to unpack

      解决方案：
         a,b,*c = 10,20,30,40
         #除开始的两个元素赋值给a,b之外，其余元素均以列表的形式赋值给c
         print("a = ",a,"b = ",b,"c = ",c)  #返回结果 a =  10 b =  20 c= [30, 40]
        
         a,*b,c = 10,20,30,40
         #除开始和两个元素赋值给a,c之外，其余元素均以列表的形式赋值给b
         print("a = ",a,"b = ",b,"c = ",c)  #返回结果 a =  10 b =  [20,30] c=  40

         *a,b,c = 10,20,30,40
         #除最后两个元素赋值给a,c之外，其余元素均以列表的形式赋值给a
         print("a = ",a,"b = ",b,"c = ",c)  #返回结果 a =  [10,20] b =  30 c=  40

元组在解包过程中，变量的数量应该与元组中元素的个数保持一致
当元组元素个数与变量不一致时，可以在变量前添加*，使多余的元组元素以列表的形式赋值给该变量（*变量名）
不能由多个*

二、可变对象

在Python中，整型、浮点型、字符串、元组均是不可变的；字典、列表、集合是可变的。

每一个对象在内存中都储存了三个值

id (标识)

type（类型）

value（值）

所谓可变对象改变的就是该对象的value值，但该对象的地址值并未发生改变

a = [1,2,3]
      a[0] = 10  #先找到a变量，在修改a变量所对应对象的值，不会改变a变量所指向的对象

      a = [4,5,6] #修改a变量，修改了a变量所指向的对象

Python基础-08 元组和字典一、元组1.3 访问元组中的元素二、可变对象三、 ==和is的区别四、字典五、浅复制copy()六、遍历字典

黑线为第一种情况的变化图，红线为第二种情况的变化图

a = [1,2,3]
    b = a     #将a赋值给b(a和b的内存地址值一样，指向同一个对象)
    b[0]=10
    print(a,id(a))   #返回结果[10, 2, 3] 22175216
    print(b,id(b))   #返回结果[10, 2, 3] 22175216

Python基础-08 元组和字典一、元组1.3 访问元组中的元素二、可变对象三、 ==和is的区别四、字典五、浅复制copy()六、遍历字典

三、 ==和is的区别

== （!=）比较的是两个变量的值是否相等

is (is not) 比较的是两个变量的内存地址值是否相等

a = [1,2,3]
        b = [1,2,3]
        print(a == b)     #返回值为True
        printI(a is b)    #返回值为Fals

四、字典

4.1 字典简介

字典的表现形式为 dict
字典是一种新的数据结构，称为映射(mapping).
列表与字典的区别：列表的数据存储性能好但数据查询性能较差，而在字典中每一个元素都有一个唯一的名字，我们可以通过名字来查找指定的元素
每个元素的唯一的名字称为键(key)，通过key可以查找到对应的元素值(value)
字典又称之为键值对
每个字典中可以有多个键值对，每个键值对称为一个项(item)

4.2 创建字典

创建字典有两种方式：

第一种：{}

my_dict = {}      #创建一个空字典
        my_dict1 = {"name":"haha","age":19}          #创建一个非空字典
        my_dict1 = {
                              "name":"haha",
                              "age" : 19,
                              "name":"hehe"
                             }
        print(my_dict1)    #返回结果为{'name': 'hehe', 'age': 19}

第二种：dict()

my_dict = dict()     #创建一个空字典
      my_dict1 = dict(name = "haha",age = 19)   #创建一个非空字典

在字典中，字典的值可以是任意值（int，float，string，list，tuple,dict…）

字典的键可以是任意不可变的对象（int，float，string…）

字典的键是不可以重复的，一旦出现重复，后面的键所对应的值会替换原先的值

4.3 访问字典中的元素

语法：

字典名[key]

my_dict1 = {
                              "name":"haha",
                              "age" : 19 
                             }
       print(my_dicr1["name"])           #返回值为“haha”

4.4 字典的使用

1.字典的创建

my_dict2 = dict([("name","hehe"),("age",19)])
           #[("name","hehe"),("age",19)]称为双值子序列

dict() 可以将双值子序列转换为字典

双值序列：序列中的元素只有2个（如：[1,2],(1,2),‘sy’）

子序列：如果一个序列中的元素也为一个序列，那么我们就称这个元素为子序列

2. 获取字段中的元素值

dict2 = {"a":1,"b":2,"c":3,"d":4,"e":5}
         print(dict2["f"])      #当字典中不存在相应的key时，会报错 KeyError: 'f'

       解决方法
        dict2 = {"a":1,"b":2,"c":3,"d":4,"e":5}
        print(dict2.get("f"))    #返回空 None
        print(dict2.get("f","没有这个键"))   #返回默认值  "没有这个键"

get(key[,default]) 返回指定key所对应的的value值

当不设置dafault的值时，如果获取的key值不在字典中会返回空None；

当设置了默认值后，如果获取的key值不在字典中会返回默认值

3. 获取字典的长度

dict2 = {"a":1,"b":2,"c":3,"d":4,"e":5}
         print(len(dict2))    #返回字典中元素的个数(字典的长度)  5

4.检查字典中是否包含指定的key

dict2 = {"a":1,"b":2,"c":3,"d":4,"e":5}
        print("a" in dict2)  #返回结果为True
in 检查字典中是否包含指定的key
not in 检查字典中是否不包含指定的key

5.修改字典的值

通过赋值来修改字典中的元素值

如果所修改元素的key存在，则覆盖原先key所对应的value值

如果所修改元素的key不存在，则增加新的key-value

dict2 = {"a":1,"b":2,"c":3,"d":4,"e":5}
      dict2["b"] = 10
      print(dict2)     #返回结果{'a': 1, 'b': 10, 'c': 3, 'd': 4, 'e': 5}

      dict2["f"] = 8
      print(dict2)    #返回结果{'a': 1, 'b': 10, 'c': 3, 'd': 4, 'e': 5,"f":8}

通过setdefault()函数修改字典的值

如果所修改元素的key存在，则不对字典进行任何操作，返回原先key所对应的value值

如果所修改元素的key不存在，则增加新的key-value

dict2 = {"a":1,"b":2,"c":3,"d":4,"e":5}
      dict2.setdefault("a",3)
      print(dict2)     #返回结果{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

      dict2setdefault("f",8)
      print(dict2)    #返回结果{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5,"f":8}

update() 将一个字典添加到另一个字典中

如果两个字典中有重复的key值，则用添加字典中的值覆盖原先的值

dict2 = {"a":1,"b":2,"c":3,"d":4,"e":5}
       dict1 = {"a":3,"f":8,"g":10}
       dict2.update(dict1)
       print(dict2)     #返回值为 {"a":3,"b":2,"c":3,"d":4,"e":5,"f":8,"g":10}

6.删除字典

利用del()删除指定的key-value

dict2 = {"a":1,"b":2,"c":3,"d":4,"e":5}
        del dict2["f"]
        print(dict2)      #返回值为{"a":1,"c":3,"d":4,"e":5}

利用popitem()随机删除一个key-value,一般为最后一个，并以元组的形式返回所删除的key，value值

dict2 = {"a":1,"b":2,"c":3,"d":4,"e":5}
      result = dict2.popitem()
      print("result = ",result)    #结果为 result =  ('e', 5)
      print(dict2)    # {'a': 1, 'b': 2, 'c': 3, 'd': 4}

利用pop(key[,default])删除指定key-value，返回所删除key对应的value值

当未设置default时，如果删除的key在字典中不存在，会报错 KeyError

当设置default时，如果删除的key在字典中不存在，则会返回默认值

dict2 = {"a":1,"b":2,"c":3,"d":4,"e":5}
      result = dict2.pop("c")
      print("result = ",result)    #结果为 result =  3
      print(dict2)    # {'a': 1, 'b': 2, 'd': 4,'e':5}

      print(dict2.pop("f","没有这个键"))     #返回结果为"没有这个键"

利用clear() 请空字典

dict2 = {"a":1,"b":2,"c":3,"d":4,"e":5}
           dict2.clear()
           print(dict2)    #返回结果为 {}

五、浅复制copy()

复制将两个变量独立出来，即两个变量的值相等，但地址值不同，修改其中一个其中变量，另一个变量并不会受到影响。

dict2 = {"a":1,"b":2,"c":3,"d":4,"e":5}
        dict1 = dict2  #将dict2 赋值给dict1,这两个变量的内存地址和指向对象均相同
        dict1["a"]  = 10
        print(dict1,id(dict1))   #返回结果为{'a': 10, 'b': 2, 'c': 3, 'd': 4, 'e': 5} 5296176
        print(dict2,id(dict2))   #返回结果为{'a': 10, 'b': 2, 'c': 3, 'd': 4, 'e': 5} 5296176

        dict2 = {"a":1,"b":2,"c":3,"d":4,"e":5}
        dict1 = dict2.copy()  #将dict2 复制给dict1,这两个变量的内存地址不同指向对象均不同，但指向对象的值相等
        dict1["a"]  = 10
        print(dict1,id(dict1))   #返回结果为{'a': 10, 'b': 2, 'c': 3, 'd': 4, 'e': 5} 21811296
        print(dict2,id(dict2))   #返回结果为{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5} 21811248

copy()只能复制简单的字典，当字典中值也是一个字典时，是不会被复制的

dict2 = {"a":{”name”:"haha","age":19},"b":2,"c":3,"d":4,"e":5}
        dict1 = dict2.copy()  #将dict2 复制给dict1,这两个变量的内存地址不同指向对象均不同，但指向对象的值相等
        dict1["a"]["name"]  = "hehe"
        print(dict1,id(dict1))   #返回结果为{'a': {”name”:"hehe","age":19}, 'b': 2, 'c': 3, 'd': 4, 'e': 5} 21156272
        print(dict2,id(dict2))  #返回结果为{'a': {”name”:"hehe","age":19}, 'b': 2, 'c': 3, 'd': 4, 'e': 5} 21155936

六、遍历字典

6.1 通过keys()遍历字典

该方法会返回字典所有的键

dict2 = {"name":"haha","age":12,"gender":"男"}
    for k in dict2.keys():
           print(dict2[k])
    
    输出结果为：
                haha
				12
				男

6.2 通过values()遍历字典

该方法会返回字典所有的值

dict2 = {"name":"haha","age":12,"gender":"男"}
        for v in dict2.values():
              print(v)
           
        输出结果为：
                haha
				12
				男

6.3 通过items()遍历字典

该方法会返回一个双值子序列，双值为字典的key和value

dict2 = {"name":"haha","age":12,"gender":"男"}
        for k,v in dict2.items():
              print(k,"=",v)
        
        输出结果为：
             name = haha
		     age = 12
		     gender = 男

Python基础-08 元组和字典一、元组1.3 访问元组中的元素二、可变对象三、 ==和is的区别四、字典五、浅复制copy()六、遍历字典

一、元组

1.1 元组的简介

1.2 创建元组

1.3 访问元组中的元素

1.4 元组的解包

二、可变对象

三、 ==和is的区别

四、字典

4.1 字典简介

4.2 创建字典

4.3 访问字典中的元素

4.4 字典的使用

五、浅复制copy()

六、遍历字典

6.1 通过keys()遍历字典

6.2 通过values()遍历字典

6.3 通过items()遍历字典

继续阅读

Python基础 Zero to Hero面向对象编程(二)

tqdm作用及使用作用效果使用注意事项

yield和return的区别

python 创建线程

python字符串基础，超级详细，超全面

为什么Python是机器学习的最佳选择？带你揭秘Python关于Python技术储备

我，阿里的程序员，工作5年，揭秘阿里员工的真实收入和工作经历关于Python技术储备

Python3.6 基础知识

Python基础--元组&字典&集合

day17面向对象面向对象

python基础（三）元组@字典1.元组2.字典3.可变对象

Python基础（三）——列表，元组，字典一.列表二.元组三.字典

《笨方法学 Python 3》29. if语句

聚类算法--无监督学习

python的函数抽象复用--以定时器为例简单的内循环方法函数化functooldecoratordecorator的局限性coroutine