python求线段的中心点坐标 python中点的作用

本章内容来自书籍，记录下来仅方便复习，如有侵权，请联系作者删除。

一、一个简单的字典

下面是一个简单的字典，存储了外星人的颜色和点数的信息。

alien_0 = {'color':'red','points':5}
print(alien_0['color'])
print(alien_0['points'])

运行结果
red
5

二、使用字典

在Python中，字典是一系列键-值对。每一个键都有一个值相关联，可以使用键来访问与之关联的值。值可以包括数字、字符串、列表、字典等，任何Python对象都可以作为值保存在字典中。
在Python中，字典用放在花括号{}中的一系列键值对表示。

1. 访问字典中的值
访问规则：使用字典名[键]，需要指定字典名，键，Python会返回相应的值。

alien_0 = {'color':'red','points':5}
point_data = alien_0['points']
print("You just earned "+str(point_data)+" points!")
运行结果：
You just earned 5 points!

2. 添加键-值对
添加规则：字典名[键]=值，需要指定字典名，键，传入值。
字典是一种动态结果，可随时在其中添加键-值对，可一次指定字典名，用方括号括起的键和想关联的值。
如下所示：给外星人添加x坐标，y坐标

alien_0 = {'color':'red','points':5}
print(alien_0)
alien_0['x_position'] = 3
alien_0['y_position'] = 5
print(alien_0)
运行结果
{'color': 'red', 'points': 5}
{'color': 'red', 'points': 5, 'x_position': 3, 'y_position': 5}

Python不关心键值对的顺序，只关心键和值之间的关联关系。

3. 先创建一个空字典
创建规则：可用一对空的花括号{}定义一个空字典

alien_0 = {}
alien_0['color'] = 'red'
alien_0['points'] = 5
print(alien_0)
运行结果：
{'color': 'red', 'points': 5}

使用字典来存储用户提供的数据或者编写能自动生成大量键-值对的代码时，通常需要先定义一个空字典。

4. 修改字典中的值
修改规则：字典名[键] = 新值

alien_0 = {'color':'red','points':5}
alien_0['color'] = 'green'
alien_0['points'] = alien_0['points'] + 3
print(alien_0)
运行结果
{'color': 'green', 'points': 8}

5. 删除键-值对
删除规则： del 字典名[键] 永久删除指定键
对于字典中不在需要的信息，可使用del语句将相应的键-值对彻底删除。使用del语句时，不许指定字典名和要删除的键。

alien_0 = {'color':'red','points':5}
del alien_0['points']
print(alien_0)
运行结果
{'color': 'red'}

6. 由类似对象组成的字典
字典可以存储一个对象的多种信息，也可以用来存储众多对象的同一种信息。

如下所示，很多人最喜欢的编程语言：

favorite_languages = {
    'jen':'python',
    'sarah':'c',
    'edward':'ruby',
    'phil':'java',
}

print("Sarah's favorite language is "+
    favorite_languages['sarah'].title()+
    "."
)
运行结果：
Sarah's favorite language is C.

（1）可以在最后一个键-值对后面也加上逗号，为以后再下一行添加键-值对做好准备
（2）print() 语句可分成多行，用拼接运算符（+）连接

三、遍历字典

遍历字典有多种方式，可遍历字典的所有键-值对，键，值

1. 遍历所有的键-值对
遍历方式：for循环+字典的方法items()，for k,v in 字典名.items() 第一部分，声明两个变量，用于存储键-值对中的键和值，可使用任何名称；
第二部分，包含字典名和items()方法，可返回一个键-值对列表。

for循环依次将每个键-值对存储到指定的两个变量中。遍历字典时，键-值对的返回顺序与存储顺序不同，Python不关心键-值对的存储顺序，只跟踪键和值之间的关联关系。

favorite_languages = {
    'jen':'python',
    'sarah':'c',
    'edward':'ruby',
    'phil':'java',
}

for name,language in favorite_languages.items():
    print(name.title()+"'s favorite language is "+
        language.title()+"."
    )
    
运行结果
Jen's favorite language is Python.
Sarah's favorite language is C.
Edward's favorite language is Ruby.
Phil's favorite language is Java.

在这里，for循环处的代码让Python遍历字典中的每个键-值对，并将键存储在name中，值存储在language中。

2. 遍历字典中的所有键
遍历方式：for循环+字典的方法keys()， for k in 字典名.keys() 第一部分，声明一个变量，用于存储键-值对中的键，可使用任何名称；
第二部分，包含字典名和keys()方法，可返回包含所有键的列表。遍历字典时，Python默认遍历所有的键，所以在这里方法keys()可以省略。

favorite_languages = {
    'jen':'python',
    'sarah':'c',
    'edward':'ruby',
    'phil':'java',
}

for name in favorite_languages.keys():
    print("Hello "+name.title()+", What's your favorite language?")

运行结果
Hello Jen, What's your favorite language?
Hello Sarah, What's your favorite language?
Hello Edward, What's your favorite language?
Hello Phil, What's your favorite language?

在这里，keys()可返回字典中的所有键，并依次将他们存储到变量name中。接下来省略方法keys()，也可以通过字典名[键]的方式访问字典中的值

favorite_languages = {
    'jen':'python',
    'sarah':'c',
    'edward':'ruby',
    'phil':'java',
}

for name in favorite_languages:
    print(name.title()+"'s favorite language is "+
        favorite_languages[name]+"."
    )
运行结果
Jen's favorite language is python.
Sarah's favorite language is c.
Edward's favorite language is ruby.
Phil's favorite language is java.

如下所示，字典的keys()方法返回一个列表，可以结合if语句，判断某个值是否包含在该列表中

favorite_languages = {
    'jen':'python',
    'sarah':'c',
    'edward':'ruby',
    'phil':'java',
}

if 'jen' not in favorite_languages.keys():
    print("Jen, please take our poil")
else:
    print("Jen, thank you for taking the poil")
    
if 'erin' not in favorite_languages.keys():
    print("Erin, please take our poil!")
else:
    print("Jen, thank you for taking the poil")
    
运行结果
Jen, thank you for taking the poil
Erin, please take our poil!

3. 按顺序遍历字典中的所有键
排序方式：使用函数sorted() 字典总是明确地记录键和值之间的关联关系，当获取字典的元素时，获取的顺序是不可预测的。如果想要特定的顺序返回元素，可在for循环中对返回的键进行排序，因此，可使用函数sorted()来获得按特定顺序排列的键列表副本。

favorite_languages = {
    'jen':'python',
    'sarah':'c',
    'edward':'ruby',
    'phil':'java',
}

for name in sorted(favorite_languages.keys()):
    print(name.title())
        
运行结果：
Edward
Jen
Phil
Sarah

4. 遍历字典中的所有值
遍历方式：for循环+字典的方法values()，for v in 字典名.values() 第一部分，声明一个变量，用于存储键-值对中的键，可使用任何名称；
第二部分，包含字典和values()方法，可返回包含所有值的列表。可调用集合（set）去除重复项。

favorite_languages = {
    'jen':'python',
    'sarah':'c',
    'edward':'ruby',
    'phil':'python',
}

for language in favorite_languages.values():
    print(language)
运行结果
python
c
ruby
python

按照上式，for语句提取字典中的每个字，并将他们依次存储到变量language中。这种做法提取字典中的所有值，不考虑是否重复。为了剔除重复项，可使用集合（set）。集合类似于列表，但集合中不能包含重复元素。

favorite_languages = {
    'jen':'python',
    'sarah':'c',
    'edward':'ruby',
    'phil':'python',
}

for language in set(favorite_languages.values()):
    print(language)
运行结果
c
python
ruby

按照上式，使用set()提取favorite_languages.values()中的不同语言，得到一个不重复的列表。

四、嵌套

有时候，需要将一系列的字典存储在列表中，或者将列表存储在字典中，这称为嵌套。可用于列表嵌套字典，字典嵌套列表，字典嵌套字典等。

1. 字典列表
目标：建立30外星人的信息，并将这些信息打印出来。
字典alien_0中包含了一个外星人的各种信息，但是无法存储其他外星人的信息，需要再次创建多个字典来存储其他外星人的信息，然后将这些字典都放在一个名为aliens的列表中。

#创建一个用于存储外星人的空列表
aliens = []

#创建30个绿色的外星人
for alien_numbers in range(30):
    new_alien = {'color':'green','points':5,'speed':'slow'}
    aliens.append(new_alien)

#显示前5个外形人
for alien in aliens[:5]:
    print(alien)
print('-'*10)
#查看外星人的数量
print("Total number of aliens:"+str(len(aliens)))

运行结果
{'color': 'green', 'points': 5, 'speed': 'slow'}
{'color': 'green', 'points': 5, 'speed': 'slow'}
{'color': 'green', 'points': 5, 'speed': 'slow'}
{'color': 'green', 'points': 5, 'speed': 'slow'}
{'color': 'green', 'points': 5, 'speed': 'slow'}
----------
Total number of aliens:30

每个外星人都是独立的，可以单独修改每个外星人的信息。创建好30个外星人后，需要把前三个外星人的颜色改为黄色，移动速度设置为‘medium’，点数设置为10，如下：

#创建一个用于存储外星人的空列表
aliens = []

#创建30个绿色的外星人
for alien_numbers in range(30):
    new_alien = {'color':'green','points':5,'speed':'slow'}
    aliens.append(new_alien)

#修改前3个外星人的信息
for alien in aliens[:3]:
    alien['color']='green'
    alien['speed']='medium'
    alien['points']=10

#显示前5个外外星人的信息
for alien in aliens[:5]:
    print(alien)
print('-'*10)
#查看外星人的数量
print("Total number of aliens:"+str(len(aliens)))

运行结果
{'color': 'green', 'points': 10, 'speed': 'medium'}
{'color': 'green', 'points': 10, 'speed': 'medium'}
{'color': 'green', 'points': 10, 'speed': 'medium'}
{'color': 'green', 'points': 5, 'speed': 'slow'}
{'color': 'green', 'points': 5, 'speed': 'slow'}
----------
Total number of aliens:30

2. 在字典中存储列表

当需要在字典中，将一个键关联到多个值时，都可以在字典中嵌套一个列表。如下所示，当一个人喜欢的语言有多个时，可以保存在一个列表中。

favorite_languages = {
    'jen':['python','ruby','haskell'],
    'sarah':'c',
    'edward':['ruby','go'],
    'phil':['python'],
}

for name,languages in favorite_languages.items():
    if len(languages)>1:
        print("\n"+name.title()+"'s favorite languages are:")
        for language in languages:
            print(language)
    else:
        print("\n"+name.title()+"'s favorite language is:")
        for language in languages:
            print(language)

运行结果
Jen's favorite languages are:
python
ruby
haskell

Sarah's favorite language is:
c

Edward's favorite languages are:
ruby
go

Phil's favorite language is:
python

注意：列表和字典的嵌套层级不应该太多

3. 在字典中存储字典

字典中嵌套字典，比较复杂。应该使得每个嵌套的字典的结构都相同，即每个字典都包含相同的键，让遍历过程相对简单。

例子：一个字典表示一个人，字典中保存人的姓名，居住地址。让这些人保存在一个更大的字典中。

users = {
    'tom':{
        'first':'tom',
        'last':'einstein',
        'location':'princeton',
    },
    'lisa':{
        'first':'lisa',
        'last':'stevn',
        'location':'beijing',
    }
}

for user_name,user_info in users.items():
    full_name = user_info['first']+' '+user_info['last']
    location = user_info['location']
    print("\n Username: "+user_name)
    print("\tFull name: "+full_name)
    print("\tLocation: "+location)
运行结果

 Username: tom
        Full name: tom einstein
        Location: princeton

 Username: lisa
        Full name: lisa stevn
        Location: beijing

五、小结

学习了如何定义字典，如何使用字典，如何访问和修改字典中的元素，遍历字典中的所有信息，嵌套列表，嵌套字典。