理乐志

chihchao's blog

0%

Python学习笔记-3-容器

发表于 分类于

本章节学习Python列表、元组和字典。

1 Python列表

列表是一种可变序列类型，用方括号[]包围，使用函数 list() 表示。列表的数据项不需要具有相同的类型，创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。

1.1 创建列表

  • 直接创建列表
1
2
3
4
l1 = [1, 2, 3, 4, 5 ]
l2 = ['A','b','c']
l3 = [8,'F',2.4,1+2j,[1,2,3]]
print(l1,'\n',l2,'\n',l3)
1
2
3
[1, 2, 3, 4, 5] 
['A', 'b', 'c'] 
[8, 'F', 2.4, (1+2j), [1, 2, 3]]
  • 使用函数创建数值列表

在创建列表中，最常用的函数是 range(start, stop, step) 。不过，range()函数只能创建整数列表，不能生成浮点数。

1
2
3
print(list(range(10)))
print(list(range(0, 10, 2)))
print(list(range(0, -10, -2)))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 2, 4, 6, 8]
[0, -2, -4, -6, -8]
  • 使用列表解析式创建列表

列表解析式是Python的一大亮点，可大大缩短代码。下面分别使用普通方法和列表解析式的创建一个平方数列表。

1
2
3
4
5
squares = []
for value in range(1,11):
    square = value**2
    squares.append(square)
print(squares)
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

使用列表解析式则简单明了： 

1
2
squares = [value**2 for value in range(1,11)]
print(squares)
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

1.2 列表的索引

只需知道列表中某元素的位置或索引就可以访问该元素了。列表使用方括号[ ]来标识。如果某个列表有N个元素，那么列表的正向访问顺序为 0 到 N-1，列表的逆向访问则为 -N 到 -1。

1
2
3
4
5
Languages = ['Python', 'C', 'C++', 'Java', 'JavaScript']
print(Languages[0])
print(Languages[0:3])
print(Languages[-1])
print(Languages[-3:-1])
Python
['Python', 'C', 'C++']
JavaScript
['C++', 'Java']

1.3 修改列表中的元素

1
2
3
4
Languages = ['Python', 'C', 'C++', 'Java', 'JavaScript']
print(Languages)
Languages[0] = 'Fortran'
print(Languages)
['Python', 'C', 'C++', 'Java', 'JavaScript']
['Fortran', 'C', 'C++', 'Java', 'JavaScript']

1.4 添加元素

  • 使用方法 append() 在列表末尾添加新的元素
1
2
3
4
Languages = ['Python', 'C', 'C++', 'Java', 'JavaScript']
print(Languages)
Languages.append('Fortran')
print(Languages)
['Python', 'C', 'C++', 'Java', 'JavaScript']
['Python', 'C', 'C++', 'Java', 'JavaScript', 'Fortran']
  • 使用方法 insert() 在列表的任何位置添加新元素
1
2
3
4
Languages = ['Python', 'C', 'C++', 'Java', 'JavaScript']
print(Languages)
Languages.insert(1, 'Fortran')
print(Languages)
['Python', 'C', 'C++', 'Java', 'JavaScript']
['Python', 'Fortran', 'C', 'C++', 'Java', 'JavaScript']

1.5 删除列表中的元素

  • 使用 del 语句删除列表中某元素
1
2
3
4
Languages = ['Python', 'C', 'C++', 'Java', 'JavaScript']
print(Languages)
del Languages[1]
print(Languages)
['Python', 'C', 'C++', 'Java', 'JavaScript']
['Python', 'C++', 'Java', 'JavaScript']
  • 使用方法 pop() 根据索引删除列表中的某元素,如果不指定索引则默认删除列表最后一个元素。需要注意的是，方法pop()在删除元素后，可以让你接着使用它
1
2
3
4
5
Languages = ['Python', 'C', 'C++', 'Java', 'JavaScript']
print(Languages)
poped_Lang = Languages.pop(0)
print(poped_Lang)
print(Languages)
['Python', 'C', 'C++', 'Java', 'JavaScript']
Python
['C', 'C++', 'Java', 'JavaScript']
  • 使用方法 remove() 该方法是根据值而非索引来实现删除操作的。remove()方法在删除元素后，并不能让你接着使用它。此外，remove()只删除列表中第一个出现的该元素，如果列表中有多个此元素，则需要使用其他方法。
1
2
3
4
5
Languages = ['Python', 'C', 'C++', 'Java', 'JavaScript']
print(Languages)
removed_Lang = Languages.remove('Python')
print(removed_Lang)
print(Languages)
['Python', 'C', 'C++', 'Java', 'JavaScript']
None
['C', 'C++', 'Java', 'JavaScript']
1
2
3
4
5
# 利用python中集合元素惟一性特点，将列表转为集合，将转为列表返回。
# 极度简洁，使用python原生方法效率最高
Languages = ['Python', 'C', 'Python','C++', 'Python','Java', 'Python','JavaScript']
new_language = list(set(Languages))
print(new_Languages)
['JavaScript', 'C', 'Java', 'Python', 'C++']

1.6 排列列表

  • 使用方法 sort() 对列表进行永久性排序
1
2
3
4
cars = ['bmw','audi','toyota','subaru']
print(cars)
cars.sort() # 方法sort.()永久性修改了列表元素的排列顺序
print(cars)
['bmw', 'audi', 'toyota', 'subaru']
['audi', 'bmw', 'subaru', 'toyota']
1
2
3
# 按照与字母顺序相反的顺序排列
cars.sort(reverse=True)
print(cars)
['toyota', 'subaru', 'bmw', 'audi']

  • 使用函数 sorted() 对列表进行临时排序 sorted(iterable, *, key=None, reverse=False)

    根据 iterable 中的项返回一个新的已排序列表。具有两个可选参数，它们都必须指定为关键字参数。key 指定带有单个参数的函数，用于从 iterable 的每个元素中提取用于比较的键 (例如 key=str.lower)。 默认值为 None (直接比较元素)。reverse 为一个布尔值。 如果设为 True，则每个列表元素将按反向顺序比较进行排序

1
2
3
4
5
6
alist = ['a','b','d','c','B','A']
print(alist)
# 函数sorted()对列表的排序不影响原始列表
# 默认按字符ascii码排序
print(sorted(alist))
print(alist)
['a','b','d','c','B','A']
['A', 'B', 'a', 'b', 'c', 'd']
['a','b','d','c','B','A']
1
2
3
# 反向排序
print(sorted(alist))
print(sorted(alist, reverse = True))
['A', 'B', 'a', 'b', 'c', 'd']
['d', 'c', 'b', 'a', 'B', 'A']
1
2
3
4
5
# 默认按字符ascii码排序
print(sorted(alist)) 
# 转换成小写后再排序，'a'和'A'值一样，'b'和'B'值一样
print(sorted(alist, key = str.lower))
print(sorted(alist, key = str.lower, reverse = True))
['A', 'B', 'a', 'b', 'c', 'd']
['a', 'A', 'b', 'B', 'c', 'd']
['d', 'c', 'b', 'B', 'a', 'A']
  • 使用方法 reverse() 反序排列列表

注意：reverse()不是按与字母顺序相反的顺序排列列表，而只是反转列表元素的排列顺序。

1
2
3
4
5
6
7
print(alist)
# 方法reverse.()永久性反转列表
alist.reverse()
print(alist)
# 只需再次调用reverse()即可恢复原来顺序
alist.reverse()
print(alist)
['a','b','d','c','B','A']
['A', 'B', 'c', 'd', 'b', 'a']
['a','b','d','c','B','A']

1.7 遍历整个列表

  • 使用for循环遍历整个列表。

在对列表的命名时，选择使用单数和复数式的名称，可有效区分列表元素与列表集合。

1
2
3
magicians = ['alice','david','carolina']
for magician in magicians:
    print(magician)
alice
david
carolina

在for循环中，想包含多少行代码都可以，for语句后每个缩进的代码行都是循环的一部分，且对列表中的每个值都执行一次。

1
2
3
4
magicians = ['alice','david','carolina']
for magician in magicians:
    print(magician.title() + ', that was a great trick!')
    print("I can't wait to see your next trick, " + magician.title() + '.\n')
Alice, that was a great trick!
I can't wait to see your next trick, Alice.

David, that was a great trick!
I can't wait to see your next trick, David.

Carolina, that was a great trick!
I can't wait to see your next trick, Carolina.

  • 使用Python内置函数map()遍历列表 map(function, iterable, ...)

    返回一个将 function 应用于 iterable 中每一项并输出其结果的迭代器。如果传入了额外的 iterable 参数，function 必须接受相同个数的实参并被应用于从所有可迭代对象中并行获取的项。 当有多个可迭代对象时，最短的可迭代对象耗尽则整个迭代就将结束。map()函数不改变原有的 list，而是返回一个新的 list。利用map()函数，可以把一个 list 转换为另一个 list，只需要传入转换函数。 map()函数是一个非常有用的功能强大的内置函数，需要引起重视。

1
2
3
4
5
6
7
def squ(x):
    return x ** 2

a = list(range(1,6))
b = list(map(squ, a))
print(a)
print(b)
[1, 2, 3, 4, 5]
[1, 4, 9, 16, 25]
1
2
3
# 使用lambda匿名函数，
# 提供了两个列表，对相同位置的列表数据进行相加
list(map(lambda x, y: x + y, a, b))
[2, 6, 12, 20, 30]

  • 使用Python内置函数filter()过滤列表 filter(function, iterable)

    用 iterable 中函数 function 返回真的那些元素，构建一个新的迭代器。iterable 可以是一个序列，一个支持迭代的容器，或一个迭代器。如果 function 是 None ，则会假设它是一个身份函数，即 iterable 中所有返回假的元素会被移除。通俗来讲，filter()函数就是使用指定方法过滤可迭代对象的元素。 filter()函数是一个非常有用的功能强大的内置函数，需要引起重视。

1
2
3
4
5
6
7
def if_odd(x):
    return x % 2 == 1

a = list(range(1,11))
b = list(filter(if_odd, a))
print(a)
print(b)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 3, 5, 7, 9]

1.8 合并列表

zip(*iterables)

创建一个聚合了来自每个可迭代对象中的元素的迭代器。当所输入可迭代对象中最短的一个被耗尽时，迭代器将停止迭代。zip() 与 * 运算符相结合可以用来拆解一个列表，可简单理解为解压。

1
2
3
4
x = [1, 2, 3]
y = [4, 5, 6]
z = list(zip(x, y))
print(z)
[(1, 4), (2, 5), (3, 6)]
1
2
3
4
5
x1, y1 = zip(*z)
x1 = list(x1)
y1 = list(y1)
print(x1)
print(y1)
[1, 2, 3]
[4, 5, 6]

2 Python元组

元组是一个不可变的序列类型，可以把元组理解为不可修改的列表，除了不可修改之外，其他适用于列表的操作同样适用于元组。元组使用圆括号( )来标识。

1
2
tuple_Lang = ('Python', 'C', 'C++', 'Java', 'JavaScript')
print(tuple_Lang)
('Python', 'C', 'C++', 'Java', 'JavaScript')

修改元组中的元素会引发错误，如果想修改元组，只能对其重新赋值

1
2
tuple_Lang = ('Fortran', 'C', 'C++', 'Java', 'JavaScript')
print(tuple_Lang)
('Fortran', 'C', 'C++', 'Java', 'JavaScript')

3 字典

在Python中，字典是一系列键-值对，每个键都与一个值相关联，你可以使用键来访问与之相关联的值。与键相关联的值可以是数字、字符串、列表乃至字典。事实上，可将任何Python对象用作字典中的值。字典用花括号{}表示，键和值之间用冒号:分隔,键-值对之间用逗号,分隔。字典中可包含任意数量的键-值对，可存储的信息量几乎不受限制。

3.1 创建并访问字典

3.1.1 直接创建字典

1
2
user = {'name':'Jack', 'age':18}
print(user)
{'name': 'Jack', 'age': 18}

3.1.2 使用 dict() 函数创建字典

1
2
new_user = dict(name = 'Jack', age = 18)
print(new_user)
{'name': 'Jack', 'age': 18}

3.1.3 使用列表函数创建字典

1
2
3
4
key_list = ['name', 'age']
value_list = ['Jack', '18']
user = dict(zip(key_list, value_list))
print(user)
{'name': 'Jack', 'age': 18}
1
2
another_user = dict([('name', 'Jack'), ('age', 18)])
print(another_user)
{'name': 'Jack', 'age': 18}

3.2 添加 / 修改 字典中的值

1
2
3
4
user = {'name':'Jack', 'age':18}
user['sex'] = 'man'
user['height'] = 180
print(user)
{'name': 'Jack', 'age': 18, 'sex': 'man', 'height': 180}
1
2
3
print(f"{user['name']} is only {user['age']} years old!")
user['age'] = 30
print(f"{user['name']} is already {user['age']} years old!")
Jack is only 18 years old!
Jack is already 30 years old!
1
2
3
4
5
# del语句永久删除
user = {'name':'Jack', 'age':18}
print(user)
del user['age']
print(user)
{'name': 'Jack', 'age': 18}
{'name': 'Jack'}

3.3 遍历字典

一个Python字典可能包含几个键-值对，也可能包含数百万个键-值对。鉴于字典可能包含大量的数据，Python支持对字典遍历。字典可用于以各种方式存储信息，因此有多种遍历字典的方式：可遍历字典的所有键-值对、键或值。

3.3.1 遍历所有的键-值对

1
2
3
4
5
6
user = {'name':'Jack', 'age':18}

# 方法items()返回一个键-值对列表
for key, value in user.items():
    print('Key: ' + key)
    print('Value: ' + str(value))
Key: name
Value: Jack
Key: age
Value: 18
1
2
3
4
5
6
7
8
9
favorite_languages = {
    'jen': 'python',
    'edward': 'ruby',
    'phil': 'java',
    'sarah': 'c',
    }

for name, language in favorite_languages.items():
    print(f"{name.title()}'s favorite language is {language.title()}.")
Jen's favorite language is Python.
Edward's favorite language is Ruby.
Phil's favorite language is Java.
Sarah's favorite language is C.

3.3.2遍历所有的键

1
2
3
4
5
6
7
8
9
10
favorite_languages = {
    'jen': 'python',
    'edward': 'ruby',
    'phil': 'java',
    'sarah': 'c',
    }

# 方法keys.()返回字典中的键
for name in favorite_languages.keys():
    print(name.title())
Jen
Edward
Phil
Sarah

在这种循环中，可使用当前键来访问与之相关联的值。

1
2
3
4
5
6
7
8
9
10
favorite_languages = {
    'jen': 'python',
    'edward': 'ruby',
    'phil': 'java',
    'sarah': 'c',
    }

# 方法keys.()返回字典中的键
for name in favorite_languages.keys():
    print(favorite_languages[name].title())
Python
Ruby
Java
C
1
2
3
4
5
6
7
8
9
10
11
12
favorite_languages = {
    'jen': 'python',
    'edward': 'ruby',
    'phil': 'java',
    'sarah': 'c',
    }

friends = ['phil', 'sarah']
for name in favorite_languages.keys():
    print(name.title())
    if name in friends:
        print(f"\tHi {name.title()}, I see your favorite language is {favorite_languages[name].title()}")
Jen
Edward
Phil
    Hi Phil, I see your favorite language is Java!
Sarah
    Hi Sarah, I see your favorite language is C!

还可以用keys()确定某人是否接受流量调查

1
2
3
4
5
6
7
8
9
favorite_languages = {
    'jen': 'python',
    'edward': 'ruby',
    'phil': 'java',
    'sarah': 'c',
    }

if 'erin' not in favorite_languages.keys():
    print('Erin, please take our poll!')
Erin, please take our poll!
  • 按顺序遍历字典中所有的键

字典中明确的记录键和值之间的关联，但获取字典的元素时，获取顺序是不可预测的。要以特定的顺序返回元素，一种办法是在for循环中对返回的键进行排序，可使用函数sorted()来获得按特定顺序排列的键列表的副本。

1
2
3
4
5
6
7
8
9
favorite_languages = {
    'jen': 'python',
    'edward': 'ruby',
    'phil': 'java',
    'sarah': 'c',
    }

for name in sorted(favorite_languages.keys()):
    print(name.title() + ', thank you for taking the poll.')
Edward, thank you for taking the poll.
Jen, thank you for taking the poll.
Phil, thank you for taking the poll.
Sarah, thank you for taking the poll.

3.3.3遍历字典中所有的值

1
2
3
4
5
6
7
8
9
10
11
12
favorite_languages = {
    'jen': 'python',
    'edward': 'ruby',
    'phil': 'java',
    'sarah': 'c',
    'erin':'python'
    }

# 方法value.()返回字典中的值
print('The following languages have been mentioned:')
for language in favorite_languages.values():
    print(language.title())
The following languages have been mentioned:
Python
Ruby
Java
C
Python

上述方法提取字典中所有的值，但没有考虑重复的问题。为剔除重复项，可使用集合set()。集合类似于列表，但每个元素都必须独一无二。对包含重复元素的列表调用集合set()，可让python找出列表中独一无二的元素，并使用这些元素来创建一个集合。

1
2
3
4
5
6
7
8
9
10
11
12
favorite_languages = {
    'jen': 'python',
    'edward': 'ruby',
    'phil': 'java',
    'sarah': 'c',
    'erin':'python'
    }

# 方法value.()返回字典中的值
print('The following languages have been mentioned:')
for language in set(favorite_languages.values()):
    print(language.title())
The following languages have been mentioned:
C
Ruby
Java
Python

3.4嵌套

有时候，需要将一系列字典存储在列表中，或将列表存储在字典中，这称为嵌套。你可以在列表中嵌套字典、在字典中嵌套列表，甚至在字典中嵌套字典。

3.4.1在列表中嵌套字典

1
2
3
4
5
6
7
8
user_0 = {'name':'Jack', 'age':18}
user_1 = {'name':'Tom', 'age':20}
user_2 = {'name':'Jame', 'age':22}

users = [user_0, user_1, user_2]

for user in users:
    print(user)
{'name': 'Jack', 'age': 18}
{'name': 'Tom', 'age': 20}
{'name': 'Jame', 'age': 22}

通常用户数目有很多，且每个用户都是使用代码自动生成的。在下面的示例中，我们使用range()生成30个用户。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 创建一个用于存储用户的空列表
users = []

# 创建30个用户
for user_number in range(30):
    new_user = {'name':'user', 'age':20}
    users.append(new_user)

# 显示前五个用户
for user in users[:5]:
    print(user)
print('...')

#显示创建了多少个用户
print('Total number of users:' + str(len(users)))
{'name': 'user', 'age': 20}
{'name': 'user', 'age': 20}
{'name': 'user', 'age': 20}
{'name': 'user', 'age': 20}
{'name': 'user', 'age': 20}
...
Total number of users:30
1
2
3
4
5
6
7
8
# 修改前三项用户年龄
for user in users[:3]:
    if user['age'] == 20:
        user['age'] = 18

# 显示前五个用户
for user in users[:5]:
    print(user)
{'name': 'user', 'age': 18}
{'name': 'user', 'age': 18}
{'name': 'user', 'age': 18}
{'name': 'user', 'age': 20}
{'name': 'user', 'age': 20}

3.4.2在字典中嵌套列表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
favorite_languages = {
    'jen':['python','ruby'],
    'sarah':['c'],
    'edward':['ruby','go'],
    'phil':['python','fortran'],
    }

for name,values in favorite_languages.items():
    if len(values) == 1:
        print(f"\n{name.title()}'s favorite language is:")
        print(f"  {values[0].title()}")
    else:
        print(f"\n{name.title()}'s favorite language are:")
        for value in values:
            print(f"  {value.title()}")
Jen's favorite language are:
  Python
  Ruby

Sarah's favorite language is:
  C

Edward's favorite language are:
  Ruby
  Go

Phil's favorite language are:
  Python
  Fortran

3.4.3在字典中嵌套字典

1
2
3
4
5
6
7
8
9
10
11
users = {
    'aeinstein':{'first_name':'albert', 'last_name':'einstein', 'location':'princeton'},
    'mcurie':{'first_name':'marie', 'last_name':'curie', 'location':'paris'}
    }

for username,user_info in users.items():
    print('\nUsername: ' + username)
    full_name = user_info['first_name'] + ' ' + user_info['last_name']
    location = user_info['location']
    print('\tFull name: ' + full_name.title())
    print('\tLocation: ' + location.title())
Username: aeinstein
    Full name: Albert Einstein
    Location: Princeton

Username: mcurie
    Full name: Marie Curie
    Location: Paris