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

    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'}
  • 相关阅读:
    JVM认识之垃圾收集算法
    # 用acme.sh申请证书（含泛域名）
    web前端期末大作业：美食文化网页设计与实现——美食餐厅三级(HTML+CSS+JavaScript)
    超强、超详细Redis入门教程
    Postgresql源码（60）事务系统框架总结
    MAC下downie下载网页视频报错“转换错误”解决方案
    Dubbo—dubbo admin安装
    Linux Debian12使用git将本地项目上传到码云(gitee)远程仓库
    常用机器视觉开发软件介绍
    P02 Look And Feel
  • 原文地址：https://www.cnblogs.com/ohwell2aha/p/16492675.html