Python学习笔记——python基础 2. 高级变量类型（列表、元祖、字典）

一、列表

列表是Python中内置有序、可变序列，列表的所有元素放在一对中括号“[]”中，并使用逗号分隔开；
当列表元素增加或删除时，列表对象自动进行扩展或收缩内存，保证元素之间没有缝隙；
在Python中，一个列表中的数据类型可以各不相同，可以同时分别为整数、实数、字符串等基本类型，甚至是列表、元组、字典、集合以及其他自定义类型的对象。

1、列表常用方法

方法	说明
lst.append(x)	将元素x添加至列表lst尾部
lst.extend(L)	将列表L中所有元素添加至列表lst尾部
lst.insert(index, x)	在列表lst指定位置index处添加元素x，该位置后面的所有元素后移一个位置
lst.remove(x)	在列表lst中删除首次出现的指定元素，该元素之后的所有元素前移一个位置
lst.pop([index])	删除并返回列表lst中下标为index（默认为-1）的元素
lst.clear()	删除列表lst中所有元素，但保留列表对象
lst.index(x)	返回列表lst中第一个值为x的元素的下标，若不存在值为x的元素则抛出异常
lst.count(x)	返回指定元素x在列表lst中的出现次数
lst.reverse()	对列表lst所有元素进行逆序
lst.sort(key=None, reverse=False)	对列表lst中的元素进行排序，key用来指定排序依据，reverse决定升序（False），还是降序（True）
lst.copy()	返回列表lst的浅复制

示例

name_list = ["zhangsan", "lisi", "wangwu"]

# 1. 取值和取索引
# list index out of range - 列表索引超出范围
print(name_list[2])

# 知道数据的内容，想确定数据在列表中的位置2
# 使用index方法需要注意，如果传递的数据不在列表中，程序会报错！
print(name_list.index("wangwu"))

# 2. 修改
name_list[1] = "李四"
# list assignment index out of range
# 列表指定的索引超出范围，程序会报错！
# name_list[3] = "王小二"

# 3. 增加
# append 方法可以向列表的末尾追加数据
name_list.append("王小二")
# insert 方法可以在列表的指定索引位置插入数据
name_list.insert(1, "小美眉")

# extend 方法可以把其他列表中的完整内容，追加到当前列表的末尾
temp_list = ["孙悟空", "猪二哥", "沙师弟"]
name_list.extend(temp_list)

# 4. 删除
# remove 方法可以从列表中删除指定的数据
name_list.remove("wangwu")
# pop 方法默认可以把列表中最后一个元素删除
name_list.pop()
# pop 方法可以指定要删除元素的索引
name_list.pop(3)
# clear 方法可以清空列表
name_list.clear()

print(name_list)

name_list = ["张三", "李四", "王五", "王小二", "张三"]

# len(length 长度) 函数可以统计列表中元素的总数
list_len = len(name_list)
print("列表中包含 %d 个元素" % list_len)

# count 方法可以统计列表中某一个数据出现的次数
count = name_list.count("张三")
print("张三出现了 %d 次" % count)

# 从列表中删除第一次出现的数据，如果数据不存在，程序会报错
name_list.remove("张三")

print(name_list)

name_list = ["zhangsan", "lisi", "wangwu", "wangxiaoer"]
num_list = [6, 8, 4, 1, 10]

# 升序
name_list.sort()
num_list.sort()
print(name_list)
print(num_list)
print("---------")
# 降序
name_list.sort(reverse=True)
num_list.sort(reverse=True)
print(name_list)
print(num_list)
print("---------")
# 逆序（反转）
name_list.reverse()
num_list.reverse()

print(name_list)
print(num_list)
print("---------")

2、 列表的遍历

name_list = ["张三", "李四", "王五", "王小二"]

# 使用迭代遍历列表
"""
顺序的从列表中依次获取数据，每一次循环过程中，数据都会保存在　
my_name 这个变量中，在循环体内部可以访问到当前这一次获取到的数据

for my_name in 列表变量:

    print("我的名字叫　%s" % my_name)

"""
for my_name in name_list:

    print("我的名字叫　%s" % my_name)

3、成员资格判断

"""
使用in关键字来判断一个值是否存在于列表中，返回结果为“True”或“False”。
"""
>>> aList
[3, 4, 5, 5.5, 7, 9, 11, 13, 15, 17]
>>> 3 in aList
True
>>> 18 in aList
False
>>> bList = [[1], [2], [3]]
>>> 3 in bList
False
>>> 3 not in bList
True
>>> [3] in bList
True
>>> aList = [3, 5, 7, 9, 11]
>>> bList = ['a', 'b', 'c', 'd']
>>> (3, 'a') in zip(aList, bList)
True
>>> for a, b in zip(aList, bList):
           print(a, b)

☆☆☆3、切片操作

"""
切片适用于列表、元组、字符串、range对象等类型，但作用于列表时功能最强大。可以使用切片来截取列表中的任何部分，得到一个新列表，也可以通过切片来修改和删除列表中部分元素，甚至可以通过切片操作为列表对象增加元素。
切片使用2个冒号分隔的3个数字来完成：
第一个数字表示切片开始位置（默认为0）。
第二个数字表示切片截止（但不包含）位置（默认为列表长度）。
第三个数字表示切片的步长（默认为1），当步长省略时可以顺便省略最后一个冒号。
切片操作不会因为下标越界而抛出异常，而是简单地在列表尾部截断或者返回一个空列表，代码具有更强的健壮性。
"""
>>> aList = [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
>>> aList[::]                             #返回包含所有元素的新列表
[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
>>> aList[::-1]                           #逆序的所有元素
[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]
>>> aList[::2]                            #偶数位置，隔一个取一个
[3, 5, 7, 11, 15]
>>> aList[1::2]                           #奇数位置，隔一个取一个
[4, 6, 9, 13, 17]
>>> aList[3::]                            #从下标3开始的所有元素
[6, 7, 9, 11, 13, 15, 17]
>>> aList[3:6]                             #下标在[3, 6)之间的所有元素
[6, 7, 9]
>>> aList[0:100:1]                       #前100个元素，自动截断
[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
>>> aList[100:]                            #下标100之后的所有元素，自动截断
[]
>>> aList[100]                             #直接使用下标访问会发生越界
IndexError: list index out of range

#可以使用切片来原地修改列表内容
>>> aList = [3, 5, 7]
>>> aList[len(aList):] = [9]                       #在尾部追加元素
>>> aList
[3, 5, 7, 9]
>>> aList[:3] = [1, 2, 3]                            #替换前3个元素
>>> aList
[1, 2, 3, 9]
>>> aList[:3] = []                                        #删除前3个元素
>>> aList
[9]
>>> aList = list(range(10))
>>> aList
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> aList[::2] = [0]*5                                  #替换偶数位置上的元素
>>> aList
[0, 1, 0, 3, 0, 5, 0, 7, 0, 9]
>>> aList[::2] = [0]*3                                    #切片不连续，两个元素个数必须一样多
ValueError: attempt to assign sequence of size 3 to extended slice of size 5

#使用del与切片结合来删除列表元素
>>> aList = [3,5,7,9,11]
>>> del aList[:3]                                    #删除前3个元素
>>> aList
[9, 11]
>>> aList = [3,5,7,9,11]
>>> del aList[::2]                              #删除偶数位置上的元素
>>> aList
[5, 9]

#切片返回的是列表元素的浅复制
>>> aList = [3, 5, 7]
>>> bList = aList                                    #bList与aList指向同一个内存
>>> bList
[3, 5, 7]
>>> bList[1] = 8                                    #修改其中一个对象会影响另一个
>>> aList
[3, 8, 7]
>>> aList == bList                                #两个列表的元素完全一样
True
>>> aList is bList                                 #两个列表是同一个对象
True
>>> id(aList)                                        #内存地址相同
19061816
>>> id(bList)
19061816
"""
所谓浅复制，是指生成一个新的列表，并且把原列表中所有元素的引用都复制到新列表中。如果原列表中只包含整数、实数、复数等基本类型或元组、字符串这样的不可变类型的数据，一般是没有问题的。
"""
>>> aList = [3, 5, 7]
>>> bList = aList[::]                              #切片，浅复制
>>> aList == bList                              #两个列表的元素完全一样
True
>>> aList is bList                                  #但不是同一个对象
False
>>> id(aList) == id(bList)                      #内存地址不一样
False
>>> bList[1] = 8                                    #修改其中一个不会影响另一个
>>> bList
[3, 8, 7]
>>> aList
[3, 5, 7]
"""
如果原列表中包含列表之类的可变数据类型，由于浅复制时只是把子列表的引用复制到新列表中，这样的话修改任何一个都会影响另外一个。
"""
>>> x = [1, 2, [3,4]]
>>> y = x[:]
>>> x[0] = 5
>>> x
[5, 2, [3, 4]]
>>> y
[1, 2, [3, 4]]
>>> x[2].append(6)
>>> x
[5, 2, [3, 4, 6]]
>>> y
[1, 2, [3, 4, 6]]

4、用于序列操作的常用内置函数

"""
len(列表)：返回列表中的元素个数，同样适用于元组、字典、集合、字符串等。
max(列表)、 min(列表)：返回列表中的最大或最小元素，同样适用于元组、字典、集合、range对象等。
sum(列表)：对列表的元素进行求和运算，对非数值型列表运算需要指定start参数，同样适用于元组、range。
"""
>>> sum(range(1, 11))                                     #sum()函数的start参数默认为0
55
>>> sum(range(1, 11), 5)                                 #指定start参数为5，等价于5+sum(range(1,11))
60
>>> sum([[1, 2], [3], [4]], [])                                #这个操作占用空间较大，慎用
[1, 2, 3, 4]

#zip()函数返回可迭代的zip对象。
>>> aList = [1, 2, 3]
>>> bList = [4, 5, 6]
>>> cList = zip(a, b)                                       #返回zip对象
>>> cList
<zip object at 0x0000000003728908>
>>> list(cList)                                                  #把zip对象转换成列表
[(1, 4), (2, 5), (3, 6)]

"""
enumerate(列表):枚举列表元素，返回枚举对象，其中每个元素为包含下标和值的元组。该函数对元组、字符串同样有效。
"""
>>> for item in enumerate('abcdef'):
           print(item)

(0, 'a')
(1, 'b')
(2, 'c')
(3, 'd')
(4, 'e')
(5, 'f')

二、元祖

Python的元组与列表类似，不同之处在于元组的元素不能修改,元组使用小括号,列表使用方括号,元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可

一、创建元组

代码如下:

tup1 = ('physics', 'chemistry', 1997, 2000);
tup2 = (1, 2, 3, 4, 5 );
tup3 = "a", "b", "c", "d";

创建空元组

tup1 = ();

元组中只包含一个元素时，需要在元素后面添加逗号来消除歧义

tup1 = (50,);

元组与字符串类似，下标索引从0开始，可以进行截取，组合等。

2、基本使用

info_tuple = ("zhangsan", 18, 1.75, "zhangsan")

# 1. 取值和取索引
print(info_tuple[0])
# 已经知道数据的内容，希望知道该数据在元组中的索引
print(info_tuple.index("zhangsan"))

# 2. 统计计数
print(info_tuple.count("zhangsan"))
# 统计元组中包含元素的个数
print(len(info_tuple))

3、元组遍历

info_tuple = ("zhangsan", 18, 1.75)

# 使用迭代遍历元组
for my_info in info_tuple:

    # 使用格式字符串拼接 my_info 这个变量不方便！
    # 因为元组中通常保存的数据类型是不同的！
    print(my_info)

三、字典

字典是无序、可变序列。
定义字典时，每个元素的键和值用冒号分隔，元素之间用逗号分隔，所有的元素放在一对大括号“｛｝”中。
字典中的键可以为任意不可变数据，比如整数、实数、复数、字符串、元组等等。
globals()返回包含当前作用域内所有全局变量和值的字典。
locals()返回包含当前作用域内所有局部变量和值的字典。

1、字典的定义

正常创建字典

# 字典是一个无序的数据集合，使用print函数输出字典时，通常
# 输出的顺序和定义的顺序是不一致的！
xiaoming = {"name": "小明",
            "age": 18,
            "gender": True,
            "height": 1.75,
            "weight": 75.5}

print(xiaoming)

使用dict利用已有数据创建字典：

>>> keys = ['a', 'b', 'c', 'd']
　　>>> values = [1, 2, 3, 4]
　　>>> dictionary = dict(zip(keys, values))
　　>>> dictionary
　　{'a': 1, 'c': 3, 'b': 2, 'd': 4}
　　>>> x = dict() 　　	#空字典
　　>>> x
　　{}

使用dict根据给定的键、值创建字典

　>>> d = dict(name='xiao', age=17)
　>>> d
　　{'age': 17, 'name': 'xiao'}

以给定内容为键，创建值为空的字典

　　>>> adict = dict.fromkeys(['name', 'age', 'sex'])
　　>>> adict
　　{'age': None, 'name': None, 'sex': None}

可以使用del删除整个字典

2、字典元素的基本使用

xiaoming_dict = {"name": "小明"}

# 1. 取值
print(xiaoming_dict["name"])
# 在取值的时候，如果指定的key不存在，程序会报错！
# print(xiaoming_dict["name123"])

# 2. 增加/修改
# 如果key不存在，会新增键值对
xiaoming_dict["age"] = 18
# 如果key存在，会修改已经存在的键值对
xiaoming_dict["name"] = "小小明"

# 3. 删除
xiaoming_dict.pop("name")
# 在删除指定键值对的时候，如果指定的key不存在，程序会报错！
# xiaoming_dict.pop("name123")

print(xiaoming_dict)

xiaoming_dict = {"name": "小明",
                 "age": 18}

# 1. 统计键值对数量
print(len(xiaoming_dict))

# 2. 合并字典
temp_dict = {"height": 1.75,
             "age": 20}

# 注意：如果被合并的字典中包含已经存在的键值对，会覆盖原有的键值对
xiaoming_dict.update(temp_dict)

# 3. 清空字典
xiaoming_dict.clear()

print(xiaoming_dict)

使用字典对象的items()方法可以返回字典的键、值对
使用字典对象的keys()方法可以返回字典的键
使用字典对象的values()方法可以返回字典的值

　　>>> aDict={'name':'xiao', 'sex':'male', 'age':17}
　　>>> for item in aDict.items():
　　　　　　print(item)

  ('name', 'xiao')
　('sex', 'male')
　('age', 17)
　
　　>>> for key in aDict: 　　　　 #不加特殊说明，默认输出键
　　　　　　print(key)
  　age
　　name
　　sex
　　
　　>>> for key, value in aDict.items(): 　　　　 #序列解包用法
　　　　　　print(key, value)


　　age 17
　　name xiao
　　sex male
　　
　　>>> aDict.keys() 　　　　 #返回所有键
　　dict_keys(['name', 'sex', 'age'])
　　
　　>>> aDict.values() 　　　　 #返回所有值
　　dict_values(['xiao', 'male', 17])

3、字典元素的遍历

xiaoming_dict = {"name": "小明",
                 "qq": "123456",
                 "phone": "10086"}

# 迭代遍历字典
# 变量k是每一次循环中，获取到的键值对的key
for k in xiaoming_dict:

    print("%s - %s" % (k, xiaoming_dict[k]))

4、字典的应用场景

# 使用 多个键值对，存储 描述一个 物体 的相关信息 —— 描述更复杂的数据信息
# 将 多个字典 放在 一个列表 中，再进行遍历
card_list = [
    {"name": "张三",
     "qq": "12345",
     "phone": "110"},
    {"name": "李四",
     "qq": "54321",
     "phone": "10086"}
]

for card_info in card_list:

    print(card_info)