python学习笔记

学习《Python编程从入门到实践》摘记

1. 列表：

用方括号 [ ] 来表示列表， 并用逗号来分隔其中的元素。创建空列表empty_list = []

利用print()打印列表内容， 包括方括号。利用方括号索引（from 0）访问元素之，而不包括方括号和引号。

列表是动态的，列表创建后，可随着程序的运行增删元素。成员函数append(elem)在列表末尾添加元素；成员函数insert
(idx, elem)在列表任何位置添加新元素；已知待删除元素的索引时，可使用全局语句del list_name[idx] 删除指定元素。成员函数pop()删除列表末尾元素。成员函数pop(idx)带索引参数删除指定的元素。至于使用del语句还是pop()成员函数，一个简单的判断标准是 如果要从列表中删除一个元素，且不再以任何方式使用它，就使用del语句； 如果要在删除元素后还能继续使用它，就使用方法pop()成员函数。如果不知道要删除元素在列表中的位置，可使用成员函数remove(elem)删除第一个指定为elem的元素，所以如果别表中药有个该值时，也只能删除第一个等于改值的元素。

当列表中元素类型统一为str类型时，成员函数sort(reverse = False)可以按字母顺序永久排序列表元素，当参数reverse = True可以按字母逆序永久排序列表元素，或者直接使用成员函数reverse()实现永久逆序排序。全局函数sorted(list_name)可不改list_name列表原始内容顺序的情况下给出排序后的列表内容，同样该全局函数也有reverse参数。

使用全局函数len(list_name)可快速获取列表中元素个数。

利用for elem in list_name: 遍历列表中元素。

全局函数range(start, end, step)可用于生成一系列数字。for value in range(1,5): print(value)。将全局函数range(start, end)作为list()的参数，可以创建一个数字列表： list(range(1,6))      Out[49]: [1, 2, 3, 4, 5]； 全局函数range()可以指定步长，默认为1。In [50]: list(range(2,11,2))      Out[50]: [2, 4, 6, 8, 10]

利用全局函数min(list_name)，max(list_name)和sum(list_name)可以对数字列表执行简单的统计计算。

列表解析 将for 循环和创建新元素的代码合并成一行， 并自动附加新元素。squares = [value**2 for value in range(1,11)]; 注意此处的for循环结尾处没有冒号。

切片能力可生成任何列表的子集列表list_name[start_idx, end_idx]，截取start_idx至end_idx-1直接的所有元素组成新的子列表。可用同时省略起始索引和终止索引[:]实现列表复制。
 

2.元组

列表非常适合用于存储在程序运行期间可能变化的数据集。 列表是可以修改的。然而， 有时候你需要创建一系列不可修
改的元素， 元组可以满足这种需求。 Python将不能修改的值称为不可变的 ， 而不可变的列表被称为元组 。

元组看起来犹如列表， 但使用圆括号而不是方括号来标识。 定义元组后， 就可以使用索引来访问其元素， 就像访问列表元素一样，也使用方括号[]。

像列表一样， 也可以使用for 循环来遍历元组中的所有值：
 

3. 字典

字典 是一系列键—值对 。 每个键 都与一个值相关联， 你可以使用键来访问与之相关联的值。 与键相关联的值可以是数字、 字符串、 列表乃至字典。 事实上， 可将任何Python对象用作字典中的值。字典用放在花括号{} 中的一系列键—值对表示，键和值之间用冒号分隔，而键—值对之间用逗号分隔alien_0 = {'color': 'green', 'points': 5}， 定义空字典dict_empty = {}
通过键访问字典中的值：print(alien_0['color'])
字典是一种动态结构， 可随时在其中添加键—值对。Python不关心键—值对的添加顺序， 而只关心键和值之间的关联关系。

In [19]: alien_0 = {'color': 'green', 'points': 5}
In [20]: alien_0
Out[20]: {'color': 'green', 'points': 5}
In [21]: alien_0['x_position'] = 0; alien_0['y_position'] = 25
In [22]: print(alien_0)
{'color': 'green', 'points': 5, 'x_position': 0, 'y_position': 25}
对于字典中不再需要的信息， 可使用全局del语句将相应的键—值对彻底删除。使用del语句时， 必须指定字典名和要删除的键。

In [1]: alien_0 = {'color': 'green', 'points': 5}; print(alien_0)
{'color': 'green', 'points': 5}
In [3]: del alien_0['color']; print(alien_0)
{'points': 5}
利用for循环和字典成员函数items()遍历字典。注意：便遍历字典时，键—值对的返回顺序也与存储顺序不同。Python不关心键—值对的存储顺序， 而只跟踪键和值之间的关联关系。

In [6]: user_0 = {
...: 'username': 'efermi',
...: 'first': 'enrico',
...: 'last': 'fermi',
...: }

In [7]: for key, value in user_0.items():
...: print(" Key: " + key)
...: print(" Value: " + value)
在不需要使用字典中的值时，成员函数keys()很有用，可直接遍历字典中的所有键。遍历字典时， 会默认遍历所有的键， 因此， 如果将上述代码中的for name in favorite_languages.keys(): 替换为for name in favorite_languages: 输出结果保持不变。成员函数keys()实际上返回了一个包含字典中所有键的列表。

字典总是明确地记录键和值之间的关联关系， 但获取字典的元素时， 获取顺序是不可预测的。 这不是问题， 因为通常你想要的只是获取与键相关联的正确的值。要以特定的顺序返回元素， 一种办法是在for 循环中对返回的键进行排序。 为此， 可使用全局函数sorted() 来获得按特定顺序排列的键列表的副本：

In [14]: favorite_languages = {
...: 'jen': 'python',
...: 'sarah': 'c',
...: 'edward': 'ruby',
...: 'phil': 'python',
...: }
...: 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.
如仅需字典包含的值，可使用成员函数values()。类似于keys()成员函数，该values()成员函数同样返回一个列表值，而不包含任何键。

for language in favorite_languages.values():
print(language.title())
这种做法提取字典中所有的值， 而没有考虑是否重复。 涉及的值很少时， 这也许不是问题， 但如果被调查者很多， 最终的列表可能包含大量的重复项。 为剔除重复项， 可使用集合（set） 。 集合 类似于列表， 但每个元素都必须是独一无二的：

for language in set(favorite_languages.values()):
print(language.title())
4. 嵌套

有时候， 需要将一系列字典存储在列表中， 或将列表作为值存储在字典中， 这称为嵌套。

alien_0 = {'color': 'green', 'points': 5}
alien_1 = {'color': 'yellow', 'points': 10}
alien_2 = {'color': 'red', 'points': 15}
aliens = [alien_0, alien_1, alien_2]
for alien in aliens:
print(alien)

output:
{'color': 'green', 'points': 5}
{'color': 'yellow', 'points': 10}
{'color': 'red', 'points': 15}
动态创建和修改（利用切片实现局部修改）嵌套结构

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

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

for alien in aliens[0:3]:
if alien['color'] == 'green':
alien['color'] = 'yellow'
alien['speed'] = 'medium'
alien['points'] = 10

# 显示前五个外星人
for alien in aliens[0:5]:
print(alien)
print("...")
在字典中存储列表

favorite_languages = {
'jen': ['python', 'ruby'],
'sarah': ['c'],
'edward': ['ruby', 'go'],
'phil': ['python', 'haskell'],
}
for name, languages in favorite_languages.items():
print(" " + name.title() + "'s favorite languages are:")
for language in languages:
print(" " + language.title())
5. 函数

用关键字def来定义函数，

#函数定义
def greet_user(username):
"""显示简单的问候语"""
print("Hello, " + username.title() + "!")

# 函数调用
greet_user('jesse')
当函数定义中包含多个形参时，函数调用的方式可使用位置实参 ， 这要求实参的顺序与形参的顺序相同； 也可使用关键
字实参 ， 其中每个实参都由变量名和值组成； 还可使用列表和字典。

def describe_pet(animal_type, pet_name):
"""显示宠物的信息"""
print(" I have a " + animal_type + ".")
print("My " + animal_type + "'s name is " + pet_name.title() + ".")


# 位置实参调用方式, 实参位置顺序很重要
describe_pet('dog', 'peter')

# 关键字实参调用方式，直接将实参和函数定义中的形参关联
# 关键字实参让你无需考虑函数调用中的实参顺序， 还清楚地指出了函数调用中各个值的用途
describe_pet(animal_type='cat', pet_name='lili')
# 或者
describe_pet(pet_name='lili', animal_type='cat')
编写函数时， 可给每个形参指定默认值 。 在调用函数中给形参提供了实参时， Python将使用指定的实参值； 否则， 将使用形参的默认值。

def describe_pet(pet_name, animal_type='dog'):
"""显示宠物的信息"""
print(" I have a " + animal_type + ".")
print("My " + animal_type + "'s name is " + pet_name.title() + ".")

describe_pet(pet_name='willie')
#或
describe_pet('willie')
在函数中， 可使用return 语句将值返回到调用函数的代码行。将程序的大部分繁重工作移到函数中去完成， 从而简化主程序。

def get_formatted_name(first_name, last_name, middle_name=''):
"""返回整洁的姓名"""
# Python将非空字符串解读为True
if middle_name:
full_name = first_name + ' ' + middle_name + ' ' + last_name
else:
return full_name.title()

musician = get_formatted_name('jimi', 'hendrix')
print(musician)

musician = get_formatted_name('john', 'hooker', 'lee')
print(musician)
函数可返回任何类型的值， 包括列表和字典等较复杂的数据结构。

def build_person(first_name, last_name, age=''):
"""返回一个字典， 其中包含有关一个人的信息"""
person = {'first': first_name, 'last': last_name}
if age:
person['age'] = age
return person

musician = build_person('jimi', 'hendrix')
print(musician)
列表变量作为函数形参。

def greet_users(names):
"""向列表中的每位用户都发出简单的问候"""
for name in names:
msg = "Hello, " + name.title() + "!"
print(msg)

usernames = ['hannah', 'ty', 'margot']
greet_users(usernames)
将列表传递给函数后，函数就可对其进行修改，在函数中对这个列表所做的任何修改都是永久性的。

def print_models(unprinted_designs, completed_models):
"""模拟打印每个设计， 直到没有未打印的设计为止打印每个设计后， 都将其移到列表completed_models中"""
while unprinted_designs:
current_design = unprinted_designs.pop()
# 模拟根据设计制作3D打印模型的过程
print("Printing model: " + current_design)
completed_models.append(current_design)


def show_completed_models(completed_models):
"""显示打印好的所有模型"""
print(" The following models have been printed:")
for completed_model in completed_models:
print(completed_model)

unprinted_designs = ['iphone case', 'robot pendant', 'dodecahedron']
completed_models = []

print_models(unprinted_designs, completed_models)
show_completed_models(completed_models)
但是，有时为了避免在函数内的修改影响到实参列表变量（即永久性修改问题），可向函数传递列表的副本而不是原件；这样函数所做的任何修改都只影响副本， 而丝毫不影响原件。

# 切片表示法[:]创建列表的副本
function_name(list_name[:])
虽然向函数传递列表的副本可保留原始列表的内容， 但除非有充分的理由需要传递副本， 否则还是应该将原始列表传递给函数， 因为让函数使用现成列表可避免花时间和内存创
建副本， 从而提高效率， 在处理大型列表时尤其如此。

在函数定义时，利用星号*标注形参的方式来实现传递任意数量的实参。注意， Python将实参封装到一个元组中， 即便函数只收到一个值也如此。

# 形参*tops的星号让Python创建一个名为tops的空元组，并将收到的所有值都封装到这个元组中。
def make_pizza(size, *tops):
"""概述要制作的比萨"""
print(" Making a " + str(size) + "-inch pizza with the following tos:")
# 查看形参
print(tops)
for topping in tops:
print("- " + topping)

make_pizza(16, 'pepperoni')
make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')
在函数定义时，利用两个星号(**)标注形参的方式来实现任意数量的关键字实参。注意，函数调用需要以“键—值对”形式。

# 形参**user_info中的两个星号让Python创建一个名为user_info 的空字典， 并将收到的所有名称—值对都封装到这个字典中。
def build_profile(first, last, **user_info):
"""创建一个字典， 其中包含我们知道的有关用户的一切"""
profile = {}
profile['first_name'] = first
profile['last_name'] = last
for key, value in user_info.items():
profile[key] = value
return profile

user_profile = build_profile('albert', 'einstein', location='princeton', field='physics')
print(user_profile)
模块

将函数存储在被成为模块的独立文件中，可将代码块和主程序分离，通过给函数调用，让主程序清晰、易于理解。通过import语句将模块导入到主程序中，实现运行在当前程序文件中使用模块中的代码块。通过将函数存储在独立的文件中， 可隐藏程序代码的细节， 将重点放在程序的高层逻辑上。同时易于代码的重用和共享。导入方法： 只需编写一条import 语句并在其中指定模块名，就可在程序中使用该模块中的所有函数。 如果你使用这种import 语句导入了名为module_name.py的整个模块， 就可使用下面的语法来使用其中任何一个函数：

# Python会在幕后将该模块中的所有函数都复制到这个程序中
import module_name
module_name.function_name()
另一种导入方式：导入模块中的特定函数，此种方式导入特定函数后，直接使用函数名的方式function_name()调用函数即可，无需module.function_name()的调用方式。

from module_name import function_name
# 通过用逗号分隔函数名， 可根据需要从模块中导入任意数量的函数
from module_name import function_0, function_1, function_2
如果导入的函数的名称可能与程序中现有的名称冲突，或函数名太长，可在导入的同时给函数起别名。

from module import function_name as func_name
#通过别名调用函数
func_name()
还可以给模块起别名。通过给模块指定简短的别名（如给模块pizza 指定别名p ）， 方便后续调用模块中的函数。

import module_name as mn
mm.fun()
使用星号（* ） 运算符可让Python导入模块中的所有函数， 这样在调用模块中的具体代码时就无需module.function_name()的形式了，可直接使用function_name()的调用方式。注意，这种方式容易引起冲突。

from module_name import *
fun()

类

类的定义和函数定义类似，不过使用class关键字，而不是def关键字，在类命后同样需要有一个括号和一个冒号()：。类成员函数的定义参数列表中的第一个参数必须时self。self参数实现将根据类创建的实例的属性和形参。

# 定义类
class Dog():
'''一次模拟小狗的简单尝试'''
# 在创建实例对象时，python会自动调用该函数
def __init__(self, name, age):
'''初始化属性name和age'''
self.name = name
self.age = age

def sit(self):
print(self.name.title() + "is now sitting.")

def roll_over(self):
'''模拟小狗被命令时蹲下'''
print(self.name.title() + "rolled over!")


#创建和使用实例
my_dog = Dog('willie', 6)
my_dog.sit()
my_dog.roll_over()
print("My dog's name is " + my_dog.name.title() + ".")
print("My dog is " + str(my_dog.age) + " years old.")
类中的每个属性都必须有初始值， 哪怕这个值是0或空字符串。 在有些情况下，如设置默认值时，在方法__init__()内指定这种初始值是可行的；如果你对某个属性这样做了，就无需包含为它提供初始值的形参。

修改实例对象属性值：直接修改属性值 实例对象名.属性命=新值； 通过成员函数修改属性的值。

一个类继承另一个类时，它将自动获得另一个类的所有属性和方法；原有的类称为父类 ，而新类称为子类。子类继承了其父类的所有属性和方法，同时还可以定义自己的属性和方法。创建子类的实例时，Python首先需要完成的任务是给父类的所有属性赋值。 为此，子类的方法__init__() 需要父类施以援手。

# 在括号中指定父类
class Chinadog(Dog):
"""通过类继承定义特定狗的独特之处"""
def __init__(self, name, age, year):
super().__init__(name, age)
self.year = year

def get_descriptive_name(self):
desc = self.name.title() + ' ' + str(self.age) + ' ' + str(self.year)
print(desc)

your_dog = Chinadog('tesla', 3, 2014)
your_dog.get_descriptive_name()
对于父类的方法， 只要它不符合子类模拟的实物的行为， 都可对其进行重写。

在同一个独立模块(*.py文件)中，可以根据需要存储任意数量的类。在使用的时候可以具体到处相应的类，例如：

from car import Car, ElectricCar
需要从一个模块中导入很多类时， 最好导入整个模块， 并使用 module_name.class_name 语法来访问类。
 

Python标准库

Python标准库 是一组模块， 安装的Python都包含它。使用标准库中的任何函数和类，只需在程序开头包含一条简单的import 语句。例如下面演示使用collections模块 中的一个类——OrderedDict，该类可以记录“键-值对”的添加顺序，其他几乎与普通的字典{}相同。

from collections import OrderedDict

favorite_languages = OrderedDict()
favorite_languages['jen'] = 'python'
favorite_languages['sarah'] = 'c'
favorite_languages['edward'] = 'ruby'
favorite_languages['phil'] = 'python'

for name, language in favorite_languages.items():
print(name.title() + " 's favorite language is " + language.title() + ".")
模块random 包含以各种方式生成随机数的函数， 其中的randint() 返回一个位于指定范围内的整数

# 返回一个1~6内的整数
from random import randint
x = randint(1,6)
类名应采用驼峰命名法 ， 即将类名中的每个单词的首字母都大写， 而不使用下划线。 实例名和模块名都采用小写格式， 并在单词之间加上下划线。对于每个类， 都应紧跟在类定义后面包含一个文档字符串， 简要描述类的功能。每个模块也都应包含一个文档字符串， 对其中的类可用于做什么进行描述。在类中， 可使用一个空行来分隔方法； 而在模块中， 可使用两个空行来分隔类。先编写导入标准库模块的import 语句， 再添加一个空行， 然后编写导入你自己编写的模块的import 语句。

文件
可以一次性读取文件的全部内容，也可以以每次一行的方式逐步读取。

# 一次性读取全部内容
with open('pi_digits.txt') as file_object:
contents = file_object.read() # python会读取文件中全部内容，并自动在末尾加
print(contents.rstrip())

filename = 'pi_digits.txt'
with open(filename) as file_object:
for line in file_object:
print(line)
也可以通过列表的方式将文件内容按行存储在列表中。

with open(filename) as file_object:
lines = file_object.readlines() # 按行读取文件中的每一行，并存储在列表中。

for line in lines:
print(line.rstrip())
要将文本写入文件， 你在调用open() 时需要提供另一个实参， 告诉Python你要写入打开的文件。注意：Python只能将字符串写入文本文件。 要将数值数据存储到文本文件中， 必须先使用函数str() 将其转换为字符串格式。

异常

python使用一种被称为异常的特殊对象来管理程序执行期间发生的错误。每当发生让Python不知所措的错误时，它都会创建一个异常对象。如果你编写了处理该异常的代码，程序将继续运行；如果你未对异常进行处理，程序将停止，并显示一个traceback， 其中包含有关异常的报告。

异常是使用try-except 代码块处理的。try-except 代码块让Python执行指定的操作， 同时告诉Python发生异常时怎么办。使用了try-except代码块时，即便出现异常，程序也将继续运行，显示你编写的友好的错误消息，而不是令用户迷惑的traceback。

print("Give me two numbers, and I'll divide them.")
print("Enter 'q' to quit.")

while True:
first_number = input(" First number: ")
if first_number == 'q':
break
second_number = input("Second number: ")
try:
answer = int(first_number) / int(second_number)
except ZeroDivisionError: # ZeroDivisionError异常对象
print("You can't divide by 0!")
else:
print(answer)
try-except-else 代码块的工作原理大致如下： Python尝试执行try 代码块中的代码； 只有可能引发异常的代码才需要放在try 语句中。有时候，有一些仅在try代码块成功执行时才需要运行的代码；这些代码应放在else代码块中。except代码块告诉Python， 如果它尝试运行try 代码块中的代码时引发了指定的异常，该怎么办。
处理FileNotFoundError异常

filename = 'alice.txt'
try:
with open(filename) as f_obj:
contents = f_obj.read()
except FileNotFoundError:
msg = "Sorry, the file " + filename + " does not exist."
print(msg)
文本分析

str的成员函数split() 以空格为分隔符将字符串分拆成多个部分， 并将这些部分都存储到一个列表中。

title = "Alice in Wonderland"
title.split()
Out[42]: ['Alice', 'in', 'Wonderland']
让程序在失败时一声不吭，可像通常那样编写try 代码块，但在except 代码块中明确地告诉Python什么都不要做。Python有一个pass 语句，可在代码块中使用它来让Python什么都不要做。

try:
# do something
except FileNotFoundError:
pass
else:
# if no any exception do thess things.

可以使用str的成员函数count() 来确定特定的单词或短语在字符串中出现了多少次。

line = "Row, row, row your boat"
line.count('row')
Out[43]: 2
存储数据

一种简单的方式是使用模块json 来存储数据。注意：JSON（JavaScript Object Notation） 格式最初是为JavaScript开发的，但随后成了一种常见格式，被包括Python在内的众多语言采用。使用json.dump() 来存储数据；使用json.dump()加载数据。

import json

numbers = [2, 3, 5, 7, 11, 13]
filename = 'numbers.json'

# 演示存储数据
with open(filename, 'w') as f_obj:
json.dump(numbers, f_obj)

# 演示加载数据
with open(filename) as f_obj:
nn = json.load(f_obj)
print(nn)
测试
Python标准库中的模块unittest 提供了代码测试工具。要为函数编写测试用例， 可先导入模块unittest 以及要测试的函
数， 再创建一个继承unittest.TestCase 的类， 并编写一系列方法对函数行为的不同方面进行测试。方法名必须以test_打头，
这些方法由Python自动调用， 无需编写调用它们的代码。

import unittest
from name_function import get_formatted_name
class NamesTestCase(unittest.TestCase):
"""测试name_function.py"""

# 方法名必须以test_打头
def test_first_last_name(self):
"""能够正确地处理像Janis Joplin这样的姓名吗？ """
formatted_name = get_formatted_name('janis', 'joplin')

#利用断言方法用来核实得到的结果是否与期望的结果一致
self.assertEqual(formatted_name, 'Janis Joplin')

# 方法名必须以test_打头
def test_first_last_middle_name(self):
"""能够正确地处理像Wolfgang Amadeus Mozart这样的姓名吗？ """
formatted_name = get_formatted_name('wolfgang', 'mozart', 'amadeus')
self.assertEqual(formatted_name, 'Wolfgang Amadeus Mozart')


# 所有以test打头的方法都将自动运行
unittest.main()
除了可以编写针对单个函数的测试，还可以编写针对类的测试。Python在unittest.TestCase 类中提供了很多断言方法。
 

unittest Module中的断言方法
方法 用途
assertEqual(a, b) 核实 a == b
assertNotEqual(a, b) 核实a != b
assertTrue(x) 核实x 为True
assertFalse(x) 核实x 为False
assertIn(item , list ) 核实 item 在 list 中
assertNotIn(item , list ) 核实 item 不在 list 中
类的测试与函数的测试相似——所需要做的大部分工作都是测试类中方法的行为，但存在一些不同之处。unittest.TestCase 类包含方法setUp() ， 让我们只需创建这些对象一次， 并在每个测试方法中使用它们。 如果你在TestCase 类中包含了方法setUp() ， Python将先运行它， 再运行各个以test_打头的方法。 这样， 在你编写的每个测试方法中都可使用在方法setUp() 中创建的对象了。
 

import unittest
from survey import AnonymousSurvey

class TestAnonymousSurvey(unittest.TestCase):
"""针对AnonymousSurvey类的测试"""

def setUp(self):
"""创建一个调查对象和一组答案， 供使用的测试方法使用"""
question = "What language did you first learn to speak?"
self.my_survey = AnonymousSurvey(question)
self.responses = ['English', 'Spanish', 'Mandarin']

def test_store_single_response(self):
"""测试单个答案会被妥善地存储"""
self.my_survey.store_response(self.responses[0])
self.assertIn(self.responses[0], self.my_survey.responses)

def test_store_three_responses(self):
"""测试三个答案会被妥善地存储"""
for response in self.responses:
self.my_survey.store_response(response)

for response in self.responses:
self.assertIn(response, self.my_survey.responses)

unittest.main()
外星人入侵游戏开发案例

在conda中安装pygame的指令： pip install pygame

数据可视化

利用plot()绘制简单折线，

import matplotlib.pyplot as plt

input_values = [x for x in range(1,6)]
squares=[x**2 for x in input_values]

plt.plot(input_values, squares, linewidth=5)
# 设置图表标题， 并给坐标轴加上标签
plt.title("Square Numbers", fontsize=24)
plt.xlabel("Value", fontsize=14)
plt.xlabel("Square of Value", fontsize=14)
# 设置刻度标记的大小
plt.tick_params(axis='both', labelsize=14)

plt.show()
利用scatter()绘制离散点，matplotlib允许指定散点图中的各个点颜色。默认为蓝色点和黑色轮廓，在散点图包含的数据点不多时效果很好。但绘制很多点时，黑色轮廓可能会粘连在一起。要删除数据点的轮廓，可在调用scatter()时传递实参edgecolor='none' ，要修改数据点的颜色，可向scatter() 传递参数c ，并将其设置为要使用的颜色的名称，c='red' 或c=(1.0, 0.0, 0.0);

使用颜色映射， 颜色映射 （colormap） 是一系列颜色， 它们从起始颜色渐变到结束颜色。模块pyplot 内置了一组颜色映射。 要使用这些颜色映射， 你需要告诉pyplot 该如何设置数据集中每个点的颜色。 下面演示了如何根据每个点的 y 值来设置其颜色：

plt.scatter(x_values, y_values, c=y_values, cmap=plt.cm.Blues, edgecolor='none', s=40)
自动保存图表，要让程序自动将图表保存到文件中， 可将对plt.show() 的调用替换为对plt.savefig() 的调用：
plt.savefig('squares_plot.png', bbox_inches='tight')

plt.savefig('squares_plot.png', bbox_inches='tight')

随机漫步

"""File: random_walk.py， 生成随机漫步数据"""
from random import choice

class RandomWalk():
"""一个生成随机漫步数据的类"""

def __init__(self, num_points=5000):
"""初始化随机漫步的属性"""
self.num_points = num_points

# 所有随机漫步都始于(0,0)
self.x_value = [0]
self.y_value = [0]

def fill_walk(self):
"""计算随机漫步包含的所有点"""

# 不断漫步，直到列表达到指定的长度
while len(self.x_value) < self.num_points:
# 决定前进方向以及沿这个方向前进的距离
x_direction = choice([1, -1])
x_distance = choice([0, 1, 2, 3, 4])
x_step = x_direction * x_distance

y_direction = choice([1, -1])
y_distance = choice([0, 1, 2, 3, 4])
y_step = y_direction * y_distance

# 拒绝原地踏步
if x_step == 0 and y_step == 0:
continue

# 计算下一个点的x和y值
next_x = self.x_value[-1] + x_step
next_y = self.y_value[-1] + y_step

self.x_value.append(next_x)
self.y_value.append(next_y)


"""File: rw_visual.py, 绘制随机漫步图"""
import matplotlib.pyplot as plt
from random_walk import RandomWalk

# 只要程序处理活动状态，就不断地模拟随机漫步
while True:
# 创建一个RandomWalk实例，并将其包含的点都绘制出来
rw = RandomWalk()
rw.fill_walk()

# 设置绘图窗口的尺寸
plt.figure(figsize=(15, 9))

point_num = list(range(rw.num_points))
plt.scatter(rw.x_value, rw.y_value, c=point_num, edgecolor='none',
cmap=plt.cm.Blues, s=15)

# 突显起点和终点
plt.scatter(0, 0, c='green', edgecolors='none', s=100)
plt.scatter(rw.x_value[-1], rw.y_value[-1], c='red', edgecolors='none',
s=100)

# 隐藏坐标轴
#frame = plt.gca()
#frame.axes.get_xaxis().set_visible(False)
#frame.axes.get_yaxis().set_visible(False)
# 关闭坐标刻度
plt.xticks([])
plt.yticks([])
# 关闭坐标轴
plt.axis('off')

plt.show()

keep_running = input("Make another walk? (y/n): ")
if keep_running == 'n':
break
 

模拟掷骰子
使用Python可视化包Pygal可生成具有缩放能力的矢量图形文件。对于以在线方式展示的图表，请考虑使用Pygal，使其图表在任何设备上显示时都会很美观。
 

enumerate使用

animals = ['cat', 'dog', 'monkey']
for idx, animal in enumerate(animals):
print('#%d: %s' % (idx + 1, animal))

---------------------
作者：noon1252
来源：CSDN
原文：https://blog.csdn.net/noon1252/article/details/82941015
版权声明：本文为博主原创文章，转载请附上博文链接！