【Python基础】列表元组字典集合

目录

一 列表

一 定义与索引

二 修改 添加 删除

1 修改元素

2 添加元素

3 删除元素

三 组织列表

四 操作列表

1 for循环遍历列表

2 避免缩进错误

3 创建数字列表

4 使用列表的一部分

二 元组

一 定义元组

二 修改元组变量

三 字典

一 定义与访问

1 注意点

二 修改 添加 删除

1 修改字典中的值

2 添加 键-值对

3 删除 键-值对

三 遍历字典

1 遍历所有的键-值对

2 遍历所有的键

3 遍历所有的值

四 字典内置函数&方法

1 Python字典包含的内置函数

2 Python字典包含的内置方法

四 集合

一 定义

二 集合特性

1 集合推导式

三 添加 删除

1 添加元素

2 删除元素

四 集合内置方法

---

列表

一 定义与索引

1 在Python中，第一个列表元素的下标为 0

2 通过将索引指定为 -1 ，可以让Python返回最后一个列表元素

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

二 修改 添加 删除

1 修改元素

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

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']

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 使用 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']

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

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']

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

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

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

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

四 操作列表

1 for循环遍历列表

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

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

2 避免缩进错误

• 忘记缩进或者忘记缩进额外的代码行

• 不必要的缩进(注意: 循环后的不必要的缩进)

• 遗漏了冒号

3 创建数字列表

a 使用函数 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...

b 创建数字列表

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]

c 简单的统计计算

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

d 列表推导式

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

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

4 使用列表的一部分

a 切片

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

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

b 遍历切片

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

c 复制列表

my_food = ['pizza', 'falafel', 'carrot cake']f
riend_food = my_food[:]
print('My favorite foods are')
print(my_food)
print("My 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']

---

元组

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

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

一 定义元组

🍭使用圆括号标识

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

二 修改元组变量

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

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

-------------------------------------------
('pizza', 'falafel', 'carrot cake')
('sword', 'shield', 'armor')

---

字典

一 定义与访问

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

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

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

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

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

1 注意点

• 不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个会被记住

• 键必须不可变，所以可以用数字，字符串或元组充当，而用列表不行

二 修改 添加 删除

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.

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 删除 键-值对

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

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

三 遍历字典

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

2 遍历所有的键

keys()

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

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

3 遍历所有的值

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

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

四 字典内置函数&方法

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

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

---

集合

一 定义

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

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

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

• 创建格式：

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

二 集合特性

>>> fruits = {'apple','orange','apple','pear','orange','banana'}
>>> print(fruits)#去重功能
{'apple', 'banana', 'pear', 'orange'}
#判断元素是否在集合内
>>> 'apple' in fruitsTrue
>>> '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'}

1 集合推导式

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

三 添加 删除

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'}

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'

四 集合内置方法

>>> 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'}