《Python编程：从入门到实践》读书笔记

第2章 变量和简单数据类型

1. 变量

1. 命名和使用：
   1. 变量名：字母、数字、下划线。字母或下划线打头。
   2. 不能包含空格。
   3. 不能是关键字
   4. 变量名尽量使用小写

message = "Hello Python!"

2. 字符串

1. 引号括起来的就是字符串，单引号和双引号均可。

'I told my friend, "Python is my favorite language!"'
"The language 'Python' is named after Monty Python, not the snake."

2. 大小写方法
   1. title()：首字母大写
   2. upper()：全部大写
   3. lower()：全部小写

name = "ada lovelace"
print(name.upper())
print(name.lower())
print(name.title())

3. 合并字符串：+号

first_name = "ada"
last_name = "lovelace"
full_name = first_name + " " + last_name

4. 添加空白
   1. 制表符：\t
   2. 换行符：\n
   3. 同时包含：\n\t

print("\tPython")
print("Languages:\nPython\nC\nJavaScript")
print("Languages:\n\tPython\n\tC\n\tJavaScript")

5. 删除空白
   1. rstrip()：删除末尾的空白
   2. lstrip()：删除头部的空白
   3. strip()：删除两边的空白

3. 数字

1. 整数：+，-，*，/
   1. Python2和Python3的除法不一样
2. 浮点数：+，*
3. str()：将非字符串表示为字符串

4. 注释

1. 写法：#

第3章 列表

1. 列表定义

1. 方括号[]表示列表

bicycles = ['trek', 'cannondale', 'redline', 'specialized']
print(bicycles)

2. 访问列表元素

bicycles = ['trek', 'cannondale', 'redline', 'specialized']
print(bicycles[0])

3. 索引从0开始不是1
4. 访问最后的列表元素：负数。-1返回倒数第一个。

2. 修改、添加和删除元素

1. 修改元素

motorcycles = ['honda', 'yamaha', 'suzuki']
motorcycles[0] = 'ducati'

2. 添加元素
   1. 添加到末尾：append('元素')
   2. 中间插入：insert(位置，'元素')
3. 删除元素
   1. del：删除某个位置的元素
   2. pop()：删除末尾的元素
   3. pop(位置)：删除某个位置的元素
   4. remove('值')：根据值删除元素

motorcycles = ['honda', 'yamaha', 'suzuki']
del motorcycles[0]
popped_motorcycle = motorcycles.pop()
first_owned = motorcycles.pop(0)
motorcycles.remove('ducati')

3. 组织列表

1. sort()：对列表进行排序（永久）
2. sorted()：对列表进行排序（临时）
3. reverse()：倒着打印列表
4. len()：获悉列表的长度

cars = ['bmw', 'audi', 'toyota', 'subaru']
cars.sort()
cars.sort(reverse=True)
print(sorted(cars))
cars.reverse()
len(cars)

4. 操作列表

1. 遍历
   1. for循环(缩进)

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

2. 创建数值列表
   1. range()：生成一系列数字（左闭右开）
      1. 可以设置步长range(左，右，步长)
   2. list()：生成一个列表

for value in range(1,5):
	print(value)

numbers = list(range(1,6))

squares = []
for value in range(1,11):
	square = value**2		# 平方
	squares.append(square)
	print(squares)

3. 列表统计

   1. min()
   2. max()
   3. sum()

4. 列表解析：将for循环和创建新元素的代码合并成一行，自动附加新元素

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

输出结果
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

5. 使用列表的一部分

1. 切片
   1. 指定左右索引（左闭右开）
   2. 未指定第一个索引（从列表头开始）
   3. 未指定第二个索引（从列表尾开始）
   4. 负数：输出到末尾的所有元素

players = ['charles', 'martina', 'michael', 'florence', 'eli']
print(players[0:3])
print(players[1:4])
print(players[:4])
print(players[2:])
print(players[-3:])

输出结果
['charles', 'martina', 'michael']
['martina', 'michael', 'florence']
['charles', 'martina', 'michael', 'florence']
['michael', 'florence', 'eli']
['michael', 'florence', 'eli']

2. 切片遍历
3. 复制列表：创建一个包含整个列表的切片，省略两个索引。
   • 不能直接赋值。考虑java和C++的引用。

my_foods = ['pizza', 'falafel', 'carrot cake']
friend_foods = my_foods[:]

6. 元祖

1. 定义：
   1. 列表适合用于存储可能变化的数据集。列表式可以修改的。不可变的列表称为元祖。
   2. 使用圆括号标识，使用索引访问元素。

dimensions = (200, 50)
print(dimensions[0])
print(dimensions[1])

2. 遍历：for循环（同列表）
3. 修改元祖变量：给存储元祖的变量赋值。

第5章 if语句

1. 条件测试

1. 相等：==
2. 不相等：!=
3. 比较数字：>, =, <, >=, <=
4. 多个条件：and，or，in，not in

age_0 >= 21 and age_1 >= 21
age_0 >= 21 or age_1 >= 21
'mushrooms' in requested_toppings
'mushrooms' not in requested_toppings

2. if语句

1. if
2. if-else
3. if-elif-else

3. if处理列表

1. 检查某个元素
2. 确定列表不为空

requested_toppings = []
if requested_toppings:
	for requested_topping in requested_toppings:
		print("Adding " + requested_topping + ".")
	print("\nFinished making your pizza!")
else:
	print("Are you sure you want a plain pizza?")

3. 使用多个列表

第6章 字典

1. 定义

1. 字典：键-值对

alien_0 = {
     'color': 'green', 'points': 5}   # 新建一个字典
print(alien_0['color'])	# 访问字典的值
alien_0['x_position'] = 0   # 添加一个键-值对
alien_0 = {
     } # 创建一个空字典
alien_0['color'] = 'yellow' #修改一个键值对
del alien_0['points'] # 删除键值对

2. 字典遍历

1. 遍历所有键-值对：items()

user_0 = {
     
	'username': 'efermi',
	'first': 'enrico',
	'last': 'fermi',
	}
for key, value in user_0.items():
	print("\nKey: " + key)
	print("Value: " + value)

2. 遍历所有键：keys()

for name in favorite_languages.keys():
	print(name.title())

3. 遍历所有值：values()
   1. 如果有重复元素，使用set()去重

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

3. 嵌套

1. 在列表中嵌套字典

aliens = []
for alien_number in range (0,30):
	new_alien = {
     'color': 'green', 'points': 5, 'speed': 'slow'}
	aliens.append(new_alien)

2. 在字典中存储列表

pizza = {
     
	'crust': 'thick',
	'toppings': ['mushrooms', 'extra cheese'],
	}

3. 在字典中存储字典

users = {
     
	'aeinstein': {
     
		'first': 'albert',
		'last': 'einstein',
		'location': 'princeton',
		},
	'mcurie': {
     
		'first': 'marie',
		'last': 'curie',
		'location': 'paris',
		},
}

第7章 用户输入和while循环

1. 用户输入

1. input()：让程序暂停运行，等待用户输入。参数为输入提示。

message = input("Tell me something, and I will repeat it back to you: ")
print(message)

2. 使用int()获取数值输入

age = input("How old are you? ")
How old are you? 21
age = int(age)

3. 求摸运算符：%

2. while循环

1. 普通使用

current_number = 1
while current_number <= 5:
	print(current_number)
	current_number += 1

2. 用户选择何时退出

message = ""
while message != 'quit':
	message = input(prompt)
	if message != 'quit':
		print(message)

3. 使用标志

active = True
while active:
	message = input(prompt)
	if message == 'quit':
		active = False
	else:
		print(message)

4. 使用break退出循环

while True:
	city = input(prompt)
	if city == 'quit':
		break
	else:
		print("I'd love to go to " + city.title() + "!")

5. 使用continue退出本次循环

current_number = 0
while current_number < 10:
	current_number += 1
	if current_number % 2 == 0:
		continue
	print(current_number)

3. 使用while循环处理列表和字典

1. 列表之间移动元素

unconfirmed_users = ['alice', 'brian', 'candace']
confirmed_users = []

while unconfirmed_users:
	current_user = unconfirmed_users.pop()
	print("Verifying user: " + current_user.title())
	confirmed_users.append(current_user)

2. 删除包含特定值的所有列表元素

pets = ['dog', 'cat', 'dog', 'goldfish', 'cat', 'rabbit', 'cat']
while 'cat' in pets:
	pets.remove('cat')

3. 使用用户输入填充字典

responses = {
     }
polling_active = True
while polling_active:
	name = input("\nWhat is your name? ")
	response = input("Which mountain would you like to climb someday? ")
	responses[name] = response
	repeat = input("Would you like to let another person respond? (yes/ no) ")
	if repeat == 'no':
		polling_active = False

第8章 函数

1.函数定义

1. 使用def定义一个函数：函数名，函数体，文档字符串（描述函数作用）
   1. 向函数传递信息：括号内添加参数。

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

greet_user('jesse')

2. 传递实参

1. 根据位置关联形参
2. 根据关键字关联形参
3. 默认值：使用默认值时，在形参列表中必须先列出没有默认值的形参，再列出有默认值的实参。
4. 混合调用

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

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

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

5. 让实参变成可选的：将可选实参给一个默认值—空字符串，并移到形参列表末尾。

def get_formatted_name(first_name, last_name, middle_name=''):
"""返回整洁的姓名"""
	if middle_name:
		full_name = first_name + ' ' + middle_name + ' ' + last_name
	else:
		full_name = first_name + ' ' + last_name
	return full_name.title()

6. 传递列表
   1. 列表传递给函数后，函数对列表的修改是永久性的
   2. 禁止函数修改列表：传递列表的副本

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

usernames = ['hannah', 'ty', 'margot']
greet_users(usernames)

function_name(list_name[:]) # 切片表示法[:]创建列表的副本。

7. 传递任意数量的实参
   1. 结合使用位置实参和任意数量实参
   2. 使用任意数量的关键字实参

def make_pizza(*toppings):
	"""打印顾客点的所有配料"""
	print(toppings)
make_pizza('pepperoni')
make_pizza('mushrooms', 'green peppers', 'extra cheese')

def make_pizza(size, *toppings):
	"""概述要制作的比萨"""
	print("\nMaking a " + str(size) + "-inch pizza with the following toppings:")
	for topping in toppings:
		print("- " + topping)
make_pizza(16, 'pepperoni')
make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

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)

3. 返回值

1. return
2. 返回字典

4. 将函数存储在模块中

1. 导入整个模块：
   1. 模块：扩展名为 .py 的文件
   2. 使用模块中的函数
2. 导入特定函数
3. 使用as给函数指定别名
4. 使用as给模块指定别名
5. 导入模块中的所有函数：使用*

import pizza
pizza.make_pizza(16, 'pepperoni')

from module_name import function_name

from pizza import make_pizza as mp

import pizza as p

from pizza import *

第9章 类

1. 创建和使用类

1. 创建类：
   1. 方法__init__()：每当创建新实例时自动调用。
      1. 形参self：指向实例本身的引用，让实例访问类中的方法和属性。self会自动传递。只需传递其他的参数。
   2. 其他方法。

class Dog():
	"""一次模拟小狗的简单尝试"""
	def __init__(self, name, age):
		"""初始化属性name和age"""
		self.name = name
		self.age = age
	def sit(self):
		"""模拟小狗被命令时蹲下"""
		print(self.name.title() + " is now sitting.")

2. 根据类创建实例
   1. 访问属性：使用句点访问
   2. 调用方法：使用句点调用
   3. 创建多个实例

my_dog = Dog('willie', 6)
print("My dog's name is " + my_dog.name.title() + ".")

my_dog.name
my_dog.sit()

2. 使用类和实例

1. 给属性指定默认值：在__init()__方法内指定初始值。

class Car():
	def __init__(self, make, model, year):
		"""初始化描述汽车的属性"""
		self.make = make
		self.model = model
		self.year = year
		self.odometer_reading = 0

	def read_odometer(self):
		"""打印一条指出汽车里程的消息"""
		print("This car has " + str(self.odometer_reading) + " miles on it.")

2. 修改属性的值
   1. 直接修改属性的值
   2. 通过方法修改属性的值

my_new_car.odometer_reading = 23

class Car():
	--snip--
	def update_odometer(self, mileage):
		"""将里程表读数设置为指定的值"""
		self.odometer_reading = mileage
my_new_car = Car('audi', 'a4', 2016)
my_new_car.update_odometer(23)

3. 继承

1. 继承父类的所有属性和方法

class ElectricCar(Car):
	"""电动汽车的独特之处"""
	def __init__(self, make, model, year):
		"""初始化父类的属性"""
		super().__init__(make, model, year)

2. 给子类定义属性和方法

class ElectricCar(Car):
	"""Represent aspects of a car, specific to electric vehicles."""
	def __init__(self, make, model, year):
		"""
		电动汽车的独特之处
		初始化父类的属性，再初始化电动汽车特有的属性
		"""
		super().__init__(make, model, year)
		self.battery_size = 70

3. 重写父类的方法
4. 将实例用作属性：新建一个类，将这个新类的实例作为之前某个类的一个属性。

class Car():

class Battery():
	"""一次模拟电动汽车电瓶的简单尝试"""
	def __init__(self, battery_size=70):
		"""初始化电瓶的属性"""
		self.battery_size = battery_size
	def describe_battery(self):
		"""打印一条描述电瓶容量的消息"""
		print("This car has a " + str(self.battery_size) + "-kWh battery.")

class ElectricCar(Car):
	"""电动汽车的独特之处"""
	def __init__(self, make, model, year):
		"""
		初始化父类的属性，再初始化电动汽车特有的属性
		"""
		super().__init__(make, model, year)
		self.battery = Battery()
        
my_tesla = ElectricCar('tesla', 'model s', 2016)
my_tesla.battery.describe_battery()

4. 导入类

1. 导入单个类
   1. 每个模块只有单个类
   2. 每个模块存储多个类

from car import Car
from car import ElectricCar

2. 导入多个类
   1. 从一个模块导入多个类
   2. 导入整个模块，再用句号表示法访问需要的类。
   3. 导入模块中的所有类

from car import Car, ElectricCar
import car
from module_name import *

3. 在一个模块中导入另一个模块

5. 类编码风格

1. 类名：驼峰命名法
2. 实例名/模块名：小写，单词之间加下划线

第10章 文件和异常

1. 从文件中读取数据

1. 读取整个文件：
   1. with：不再需要访问文件后将其关闭
   2. open()：打开文件
   3. read()：读取文件内容。到达文件末尾时返回一个空字符串。显示出来为一空行。
      • 在print语句中使用rstrip()删除空行。

with open('pi_digits.txt') as file_object:
	contents = file_object.read()
	print(contents)

2. 文件路径
   1. 相对路径：
      1. Linux：/
      2. Windows：\
   2. 绝对路径

with open('text_files/filename.txt') as file_object:
with open('text_files\filename.txt') as file_object:
    
file_path = '/home/ehmatthes/other_files/text_files/filename.txt'
file_path = 'C:\Users\ehmatthes\other_files\text_files\filename.txt'
with open(file_path) as file_object:

3. 逐行读取：for循环
   • 会出现空白行。因为文件每行的末尾有一个看不见的换行符，print语句也会加上一个换行符。每行末尾有两个换行符。
   • 消除空白行：在print语句中使用rstrip()。

filename = 'pi_digits.txt'
with open(filename) as file_object:
	for line in file_object:
	print(line)

4. 读取文件并存储在列表
   1. readlines()：从文件中读取每一行，并将其存储在列表中。

filename = 'pi_digits.txt'
with open(filename) as file_object:
	lines = file_object.readlines()
for line in lines:
	print(line.rstrip())

2. 写入文件

1. 写入空文件：
   1. open()：
      1. 参数1：打开文件的名称。文件不存在则自动创建。已存在则会清空该文件。
      2. 参数2：打开文件的模式。
         1. 'w'：写入模式
         2. 'r'：读取模式
         3. 'a'：附加模式
         4. 'r+'：读取和写入文件的模式
         5. 省略：只读模式

filename = 'programming.txt'
with open(filename, 'w') as file_object:
	file_object.write("I love programming.")

2. 写入多行：末尾添加换行符

3. 异常

• 使用``try-except`处理异常

1. ZeroDivisionError

try:
	print(5/0)
except ZeroDivisionError:
	print("You can't divide by zero!")
    
print("Enter 'q' to quit.")
while True:
	first_number = input("\nFirst number: ")
	if first_number == 'q':
		break
	second_number = input("Second number: ")
	try:
		answer = int(first_number) / int(second_number)
	except ZeroDivisionError:
		print("You can't divide by 0!")
	else:
		print(answer)

2. 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)

3. 分析文本：split()方法

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)
else:
	# 计算文件大致包含多少个单词
	words = contents.split()
	num_words = len(words)
	print("The file " + filename + " has about " + str(num_words) + " words.")

4. 失败时跳过：pass

def count_words(filename):
	"""计算一个文件大致包含多少个单词"""
	try:
		--snip--
	except FileNotFoundError:
		pass
	else:
		--snip--

4. 存储数据

1. json.dump()：存储数组。实参：存储的数据和存储数据的文件对象
2. json.load()：读取json

import json
numbers = [2, 3, 5, 7, 11, 13]
filename = 'numbers.json'
with open(filename, 'w') as f_obj:
	json.dump(numbers, f_obj)
	numbers = json.load(f_obj)

第11章 测试代码

1. 测试函数

1. 单元测试和测试用例
   1. 单元测试：核实函数的某个方面没有问题
   2. 测试用例：一组单元测试，测试各种情形。
2. 测试过程：
   1. 导入模块unittest和测试函数
   2. 创建一个unittest.TestCase的类。该类必须继承unittest.TestCase
   3. 断言方法：assertEquals()：参数为两个比较。
   4. unittest.main()：运行测试。
      1. 句点：通过
      2. E：有一个单元测试出现了错误。

import unittest
from name_function import get_formatted_name
class NamesTestCase(unittest.TestCase):
	"""测试name_function.py"""
	test_first_last_name(self):
		"""能够正确地处理像Janis Joplin这样的姓名吗？"""
		formatted_name = get_formatted_name('janis', 'joplin')
		self.assertEqual(formatted_name, 'Janis Joplin')
unittest.main()

2. 测试类

1. 断言方法
   1. assertEqual(a, b)：a == b
   2. assertNotEqual(a, b)：a != b
   3. assertTrue(x)：a为True
   4. assertFalse(x)：x为False
   5. assertIn(item, list)：item在list中
   6. assertNotIn(item, list)：item不在list中

import unittest
from name_function import get_formatted_name
class NamesTestCase(unittest.TestCase):
	"""测试name_function.py """
	def test_first_last_name(self):
		"""能够正确地处理像Janis Joplin这样的姓名吗？"""
		formatted_name = get_formatted_name('janis', 'joplin')
		self.assertEqual(formatted_name, 'Janis Joplin')
	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')
unittest.main()

2. 测试的类

import unittest
from survey import AnonymousSurvey
class TestAnonymousSurvey(unittest.TestCase):
	"""针对AnonymousSurvey类的测试"""
	def test_store_single_response(self):
		"""测试单个答案会被妥善地存储"""
		--snip--
	def test_store_three_responses(self):
		"""测试三个答案会被妥善地存储"""
		question = "What language did you first learn to speak?"
		my_survey = AnonymousSurvey(question)
		responses = ['English', 'Spanish', 'Mandarin']
		for response in responses:
			my_survey.store_response(response)
		for response in responses:
			self.assertIn(response, my_survey.responses)
unittest.main()

3. 方法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()