【Python3】列表字典集合元组

1 列表

1.1 定义与索引

在Python中，第一个列表元素的下标为 0通过将索引指定为 -1

可以让Python返回最后一个列表元素

inventory = ['sword', 'armor', 'shield',
            'big sword', 'big shiled'];
print(inventory[-1]);

1.2 修改 添加 删除

1.2.1 修改元素

inventory = ['sword', 'armor', 'shield',
            'big sword', 'big shield'];
inventory[-1] = 'small shield'
print(inventory)
'''
运行结果：
['sword', 'armor', 'shield', 'big sword', 'small shield']
'''

1.2.2 添加元素

• 在列表末尾添加元素

inventory1 = ['sword', 'armor', 'shield',
            'big sword'];
inventory1.append('small shield');
print(inventory1)
#结果：['sword', 'armor', 'shield', 'big sword', 'small shield']

• 在列表中插入元素

inventory2 = ['armor', 'shield',
            'big sword', 'small shield'];
inventory2.insert(0, 'sword');
print(inventory2)
#结果：['sword', 'armor', 'shield', 'big sword', 'small shield']

1.2.3 删除元素

• 使用 del 语句删除元素-----可以是任意位置

inventory = ['sword', 'armor', 'shield',
            'big sword', 'big shield'];
del inventory[0];
print(inventory)
#结果：['armor', 'shield', 'big sword', 'small shield']

• 使用 pop( ) 删除(弹出)元素-----可以是任意位置

inventory = ['sword', 'armor', 'shield',
            'big sword', 'big shield'];
popped_inventory = inventory.pop(4);
print(inventory)    #结果1
print(popped_inventory)        #结果2
#结果1：['sword', 'armor', 'shield', 'big sword']
#结果2：small shield

• 使用 remove( ) 根据值删除元素

inventory = ['sword', 'sword', 'armor', 'shield',
            'big sword', 'big shield'];
inventory.remove('sword');
print(inventory);
#结果：['sword', 'armor', 'shield', 'big sword', 'small shield']

注意：它只会删除第一个指定的值

1.3 组织列表

1.3.1 使用 sort() 对列表进行 永久性 排列

mylist = ['sword', 'armor', 'big shield'];
mylist.sort();
print(mylist);
#结果1：['armor', 'big shield', 'sword']

mylist.sort(reverse = True);
print(mylist);
#结果2：['sword', 'big shield', 'armor']

1.3.2 使用 sorted() 对列表进行 临时 排列

mylist = ['sword', 'armor', 'big shield'];
print(mylist);    #结果1：['sword', 'armor', 'big shield'];
print(sorted(mylist));        #结果2：['armor', 'big shield', 'sword']
print(mylist);    #结果3：['sword', 'armor', 'big shield'];

1.1.3 使用 reverse() 倒着打印列表

mylist = ['sword', 'armor', 'big shield'];
print(mylist.reverse());
#结果：['big shield', 'armor', 'sword']

1.1.4 使用 len() 确定列表的长度

mylist = ['sword', 'armor', 'big shield'];
len(mylist);
#结果：3

1.4 操作列表

1.4.1 for循环遍历列表

magicians = ['alice', 'david', 'jack'];
for magician in magicians:
    print(magician.title());

-------------------------------------------
Alice
David
Jack

1.4.2 避免缩进错误

• 忘记缩进或者忘记缩进额外的代码行
• 不必要的缩进(注意: 循环后的不必要的缩进)
• 遗漏了冒号

1.4.3 创建数字列表

1.4.3.1 使用函数 range()

print('...START...');
for value in range(1, 6):    #Only 1 to 5
    print('NO: ' + str(value));
print('...OVER...');

-------------------------------------------
...START...
NO: 1
NO: 2
NO: 3
NO: 4
NO: 5
...OVER...

1.4.3.2 创建数字列表

numbers = list(range(10, 1, -1));
numbers.append(1);
delete = numbers.pop(0);
print("...Erase " + str(delete) + '...');
print(numbers);

-------------------------------------------
...Erase 10...
[9, 8, 7, 6, 5, 4, 3, 2, 1]

1.4.3.3 简单的统计计算

numbers = range(1, 5);
print('min: ');
print(min(numbers));
print('max: ');
print(max(numbers));
print('sum: ');
print(sum(numbers));

-------------------------------------------
min:
1
max:
4
sum:
10

1.4.3.4 列表推导式

squares = [value**2 for value in range(1, 11)]
print(squares);

-------------------------------------------
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

1.4.4 使用列表的一部分

1.4.4.1 切片

my_food = ['pizza', 'falafel', 'carrot cake'];
friend_food = my_food[0:1];
#1 如果没有指定起始索引，默认从开头开始提取
#2 要让切片终于末尾，类似 #1
print('My favorite foods are');
print(my_food);
print("\nMy friend's favorite foods are");
print(friend_food);

-------------------------------------------
My favorite foods are
['pizza', 'falafel', 'carrot cake']

My friend's favorite foods are
['pizza']

1.4.4.2 遍历切片

foods = ['pizza', 'falafel', 'carrot cake'];
print('My favorite foods are');
for food in foods[:3]:
    print(food.title());

-------------------------------------------
My favorite foods are
Pizza
Falafel
Carrot Cake

1.4.4.3 复制列表

my_food = ['pizza', 'falafel', 'carrot cake'];
friend_food = my_food[:];
print('My favorite foods are');
print(my_food);
print("\nMy friend's favorite foods are");
print(friend_food);
-------------------------------------------
My favorite foods are
['pizza', 'falafel', 'carrot cake']

My friend's favorite foods are
['pizza', 'falafel', 'carrot cake']

---

---

---

2 元组

列表非常适合用于存储在程序运行期间可能变化的数据集

但有时需要一系列不可修改的元素, 元组可以满足这种需求

2.1 定义元组

使用圆括号标识

foods = ('pizza', 'falafel', 'carrot cake');
print('My favorite foods are');
for food in foods[:3]:
    print(food.title());
-------------------------------------------
My favorite foods are
Pizza
Falafel
Carrot Cake

2.2 修改元组变量

虽然不能元组的元素，但可以给存储元组的变量赋值

foods = ('pizza', 'falafel', 'carrot cake');
print(foods);
foods = ('sword', 'shield', 'armor');
print(foods);
-------------------------------------------
('pizza', 'falafel', 'carrot cake')
('sword', 'shield', 'armor')

---

---

---

3 字典

3.1 定义与访问

在Python中，字典 是一系列 键-值对。每个 键 都与一个 值 相关联，可以使用键来访问与之相关的值

与键相关联的 值 可以是 数字，字符串，列表乃至字典

事实上，可将任何Python对象用作字典中的值，但键不行

fruit = {
    'name': 'apple',
    'color': 'red',
    'quantity': 5
    };
print(fruit['name']);
print(fruit['color']);
print(fruit['quantity']);

-------------------------------------------
apple
red
5

3.1.1 注意点

• 不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个会被记住
• 键必须不可变，所以可以用数字，字符串或元组充当，而用列表不行

3.2 修改 添加 删除

3.2.1 修改字典中的值

apple = {'color': 'green'};
print('The apple is ' + apple['color'] + '.');

apple['color'] = 'red';
print('The apple is now ' + apple['color'] + '.');

-------------------------------------------
The apple is green.
The apple is now red.

3.2.2 添加 键-值对

fruit = {
    'name': 'apple',
    'color': 'red',
    'quantity': 5
    };
print(fruit);

fruit['x_position'] = 0;
fruit['y_position'] = 12;
print(fruit);

-------------------------------------------
{'name': 'apple', 'color': 'red', 'quantity': 5}
{'name': 'apple', 'color': 'red', 'quantity': 5, 'x_position': 0, 'y_position': 12}

3.2.3 删除 键-值对

fruit = {
    'name': 'apple',
    'color': 'red',
    'quantity': 5
    };
print(fruit);

del fruit['quantity'];
print(fruit);

-------------------------------------------
{'name': 'apple', 'color': 'red', 'quantity': 5}
{'name': 'apple', 'color': 'red'}

3.3 遍历字典

3.3.1 遍历所有的键-值对

items()

people = {
    'name': 'vivian',
    'gender': 'man',
    'hobby': 'python',
    };
for key,value in people.items():
    print(key.title() + ' : ' + value.title());

-------------------------------------------
Name : Vivian
Gender : Man
Hobby : Python

3.3.2 遍历所有的键

keys()

people = {
    'name': 'vivian',
    'gender': 'man',
    'hobby': 'python',
    };
for key in people.keyes():
    print(key.title());

-------------------------------------------
Name
Gender
Hobby

3.3.3 遍历所有的值

people = {
    'name': 'vivian',
    'gender': 'man',
    'hobby': 'python',
    };
for value in people.values():
    print(value.title());

-------------------------------------------
Vivian
Man
Python

3.4 字典内置函数&方法

3.4.1 Python字典包含的内置函数

people = {
   'name': 'vivian',
   'gender': 'man',
   'hobby': 'python',
   };

函数及描述	实例
len(dict) 计算字典元素个数	>>>len(people) 3
str(dict) 输出字典，可以打印的字符串表示	>>>str(people) {'name': 'vivian', 'gender': 'man', 'interest': 'python'}
type(variable) 返回变量类型	>>>type(people) <class 'dict'>

3.4.2 Python字典包含的内置方法

people = {
    'name': 'vivian',
    'gender': 'man',
    'hobby': 'python',
    };

函数与描述	实例
dict.clear( )	>>>people.clear(); >>>len(people); 0
dict.copy( )	>>>person = people.copy(); >>>person {'name': 'vivian', 'gender': 'man', 'hobby': 'python'}
dict.fromkeys(seq[, value]) 中括号内是选填	>>> seq = ('name','sex','hobby') >>> person = dict.fromkeys(seq) >>> person {'name': None, 'sex': None, 'hobby': None} >>> person = dict.fromkeys(seq,666) >>> person {'name': 666, 'sex': 666, 'hobby': 666}
dict.get(key, default = None)	>>> people = { ... 'name': 'vivian', ... 'gender': 'man', ... 'hobby': 'python', ... }; >>> people.get('name') 'vivian' >>> people.get('name').title() 'Vivian' >>> people.get('nam') #啥都没有
dict.setdefault(key, defalut = None) 如果键不存在，将会添加键并将值设为默认值	>>> people.setdefault('nam',None) >>> people.setdefault('name',None) 'vivian' >>> people {'name': 'vivian', 'gender': 'man', 'hobby': 'python', 'nam': None}
dict.update(dict2) 把 dict2 添加到指定字典 dict 中	>>> people.update({'age': 18}) >>> people {'name': 'vivian', 'gender': 'man', 'hobby': 'python', 'nam': None, 'age': 18}
dict.pop(key[, defalut]) 中括号内是选填 key：要删除的键值 返回被删除的值	>>> people.pop('name') 'vivian'
dict.popitem() 随机返回并删除字典中的最后一对键和值 如果字典已经为空，还使用它，则会报错	>>> people.popitem(); ('hobby', 'python') >>> people.popitem(); ('gender', 'man')

---

---

---

4 集合

4.1 定义

• 集合（set）是一个无序的不重复元素序列

• 可以使用大括号 { } 或者 set() 函数创建集合

• 注意：创建一个空集合必须用 set() 而不是 { } ，因为 { } 是用来创建一个空字典

• 创建格式：

parame = {value01, value02......}
或者
set(value)

4.2 集合特性

>>> fruits = {'apple','orange','apple','pear','orange','banana'}
>>> print(fruits)
#去重功能
{'apple', 'banana', 'pear', 'orange'}
#判断元素是否在集合内
>>> 'apple' in fruits
True
>>> 'onion' in fruits
False
#两个集合之间的运算
>>> a = set('sgjahsgs')
>>> b = set('skajkshgs')
>>> a
{'s', 'g', 'j', 'a', 'h'}
>>> b
{'s', 'j', 'g', 'a', 'k', 'h'}
>>> b - a    # b 比 a 多的部分
{'k'}

>>> a | b    # 并集
{'s', 'g', 'j', 'a', 'k', 'h'}
>>> a & b    # 交集
{'s', 'g', 'j', 'a', 'h'}
>>> a ^ b    # 以它们并集为全集，两者交集的补集
{'k'}

4.2.1 集合推导式

>>> a = {value for value in 'absjhagjgs' if value not in 'abc'}
>>> a
{'j', 'h', 's', 'g'}

4.3 添加 删除

4.3.1 添加元素

>>> fruit = {'apple','banana','strawberry','onion'}
#1 使用add(element) 如果在集合中，element元素已经存在了，则不会进行任何操作
>>> fruit.add('grape')

#2 使用update(x)
#其参数可以是列表，元组，字典等
>>> fruit.update('h')
>>> fruit
{'onion', 'apple', 'grape', 'banana', 'h', 'strawberry'}

>>> fruit = {'apple','banana','strawberry','onion'}
>>> fruit.update([1,3])
>>> fruit
{1, 'onion', 3, 'apple', 'banana', 'strawberry'}

4.3.2 删除元素

>>> fruit
{1, 'onion', 3, 'apple', 'banana', 'strawberry'}
>>> fruit.remove(1)        #如果集合中不存在要移除的元素，则会发生错误
>>> fruit
{'onion', 3, 'apple', 'banana', 'strawberry'}

>>> fruit.discard(3)    #如果集合中不存在要移除的元素，不会发生错误
>>> fruit
{'onion', 'apple', 'banana', 'strawberry'}

>>> fruit.pop()        #随机删除，并返回被删除的元素
'onion'
>>> fruit.pop()
'apple'

4.4 集合内置方法

>>> x = set('abcdf')
>>> y = set('abcrg')
>>> z = set('abczh')
>>> m = set('dhfjk')

函数与描述	实例
set.difference(set) 返回集合的差集	>>> z = x.difference(y) >>> z {'d', 'f'}
set.difference_update(set) 移除两个集合都包含的元素 无返回值	>>> x.difference_update(y) >>> x {'f', 'd'}
set.intersection(set1, set2 ... etc) 返回集合的交集	>>> m = x.intersection(y, z) >>> m {'c', 'b', 'a'}
set.intersection_update(set1, set2 ... etc) 无返回值	>>> x.intersection_update(y, z) >>> x {'c', 'b', 'a'}
isdisjoint() 判读两个集合是否包含相同元素 如果 没有 返回True	>>> x.isdisjoint(y) False
set.issubset(set) 判断是否是被包含	>>> x.issubset(y) True
issuperset 判断是否包含	>>> y.issuperset(x) True
symmetric_difference() 返回交集在并集中的补集	>>> m = x.symmetric_difference(y) >>> m {'g', 'r'}
symmetric_difference_update() 无返回值	>>>x.symmetric_difference_update(y) >>> x {'g', 'r'}
union() 返回并集	>>> n = x.union(m) >>> n {'f', 'b', 'd', 'h', 'k', 'a', 'c', 'j'}