python编程：从入门到实践(复习总结篇）

1、Ch2 变量和简单数据类型

1.1 字符串

1.1.1 修改大小写

s.title()
s.lower()
s.upper()

1.1.2 合并（拼接）字符串

+

1.1.3 使用制表符或换行符来添加空白

\n \t

1.1.4 删除空白

# 去掉开头和结尾的字符串
s = s.strip()
# 去掉开头的字符串
s = s.lstrip()
# 去掉结尾的字符串
s = s.rstrip()

1.2 数字

1.2.1 整数

1.2.2 浮点数

！包含的小数位数可能是不确定的

>>> 0.1 + 0.2
0.30000000000000004

1.2.3 使用str()避免类型错误

str(numb)

2 Ch3 列表

列表 由一系列按特定顺序排列的元素组成。你可以创建包含字母表中所有字母、数字0~9或所有家庭成员姓名的列表；也可以将任何东西加入列表中，其中的元素之间可以没有任何关系。鉴于列表通常包含多个元素，给列表指定一个表示复数的名称（如letters 、digits 或names ）是个不错的主意。

2.1 修改、添加和删除元素

2.1.1 修改元素

根据下标修改

2.1.2 添加元素

末尾添加

append()

列表中添加

insert()
>>> fruit =['apple','pear','peach']
>>> fruit.insert(1,'orange')
>>> fruit
['apple', 'orange', 'pear', 'peach']

删除

• del 根据索引删除，可以删除任何位置

>>> del fruit[1]
>>> fruit
['apple', 'pear', 'peach']

• pop()删除，一般删除末尾，也可以根据下标删除，和del的不同是，pop可以得到返回值

>>> fruit
['apple', 'pear', 'peach']
>>> fruit.pop()
'peach'
>>> fruit
['apple', 'pear']


>>> fruit = ['apple','orange','pear','peach']
>>> fruit.pop(1)
'orange'
>>> fruit
['apple', 'pear', 'peach']

• 根据值删除元素
  remove()，只喊出第一个指定的值，如果出现多次，需要使用循环判断来删除。

>>> fruit
['apple', 'pear', 'peach']
>>> fruit.remove('pear')
>>> fruit
['apple', 'peach']

2.2 组织列表

2.2.1 使用sort()对列表永久性排序

>>> numb = [43,2,87,34]
>>> numb.sort()
>>> numb
[2, 34, 43, 87]

2.2.2 使用sorted()对列表临时排序

>>> numb = [43,2,87,34]
>>> sorted(numb)
[2, 34, 43, 87]
>>> numb
[43, 2, 87, 34]

2.2.3 倒序 reverse()

>>> numb
[43, 2, 87, 34]
>>> numb.reverse()
>>> numb
[34, 87, 2, 43]

2.2.4 列表长度

当列表为空时，用list[-1]访问最后一个元素会出错

2.3 操作列表

2.3.1 遍历列表

遍历整个列表可以用 for 循环

2.3.2 创建数值列表

2.3.2.1 使用range创建

使用range函数

>>> for value in range(1,5):
...     print(value)
... 
1
2
3
4

创建数字列表

>>> a = list(range(1,5))
>>> a
[1, 2, 3, 4]

2.3.2.2 数字列表的简单统计计算 min max sum

>>> a
[1, 2, 3, 4]
>>> min(a)
1
>>> max(a)
4
>>> sum(a)
10

2.3.2.3 列表解析写法

>>> a
[1, 2, 3, 4]
>>> squares = [value ** 2 for value in a]
>>> squares
[1, 4, 9, 16]

2.3.3 使用列表的一部分

>>> a = list(range(1,10))
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a[:3]
[1, 2, 3]
>>> a[6:]
[7, 8, 9]
>>> a[::-1]
[9, 8, 7, 6, 5, 4, 3, 2, 1]

2.3.3.1 复制列表[:]

下面比较一下有加：和没加的区别。
b没加，c加，当a改变时，b列表会发生改变，和a保持一直。
理解：python如何管理对象和变量

Python没有C语言中的变量。在C语言中，变量不止是个名字，它是字节集合并真实存在于内存某个位置上。而在Python中，变量仅仅是指向对象的标签。

a = list(range(1,10))创建了一个指引指向列表 list(range(1,10))，但是a不是列表本身。
b = a并没有复制到a所指引的列表，只是创建了一个新的标签b，然后将其指向a所指向的列表。所以如果a修改了，b也会修改。**内建函数id()**可以返回对象的唯一id。该id是对象的内存地址。可以看到id(a)和id(b)指向同个地址。
但是c得到的方法是，切片运算符[:]返回一个序列的切片。切片过程是切下列表的一部分，创建新的列表，将切下的部分复制到新列表。

>>> a = list(range(1,10))
>>> b = a
>>> c = a[:]
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> b
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> c
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a[0]=10
>>> a
[10, 2, 3, 4, 5, 6, 7, 8, 9]
>>> b
[10, 2, 3, 4, 5, 6, 7, 8, 9]
>>> c
[1, 2, 3, 4, 5, 6, 7, 8, 9]


>>> id(a)
139894890651208
>>> id(b)
139894890651208

3. 元组

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

3.1 定义元组

元组使用括号，可以通过索引来访问元组。

>>> dimensions = (200,50)
>>> dimensions[0]
200

3.2 遍历元组中的所有值

for

3.3 修改元组变量

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

>>> dimensions
(200, 50)
>>> dimensions = (400, 100)
>>> dimensions
(400, 100)

4.字典

字典是一系列键-值，放在{}里。

4.1 字典常用操作

4.1.1 访问字典中的值

指定字典名和方括号里面的键

>>> alien = {'color': 'green', 'age':0}
>>> alien['color']
'green'

4.1.2 添加键值对

字典名[键] = 值

>>> alien['x_position'] = 0
>>> alien['y_position'] = 25
>>> alien
{'color': 'green', 'age': 0, 'x_position': 0, 'y_position': 25}

4.1.3 创建空字典

alien = {}

4.1.4 修改字典中的值

字典名[键] = 新值

4.1.5 删除键值对

del

>>> del alien['age']
>>> alien
{'color': 'green', 'x_position': 0, 'y_position': 25}

4.2 遍历字典

for items 遍历字典 键值对

for k,v in dict.items():
    print(k,v)

注意，即便遍历字典时，键—值对的返回顺序也与存储顺序不同。Python不关心键—值对的存储顺序，而只跟踪键和值之间的关联关系。
for keys遍历字典键，也可以不加上 keys()
for values() 遍历字典的值
sorted() 按顺序遍历字典中的所有键

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

4.3 嵌套

4.3.1 字典列表

创建一个列表，列表每个值都是字典

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

{'color': 'green', 'points': 5}
{'color': 'yellow', 'points': 10}
{'color': 'red', 'points': 15}

4.3.2 在字典中存储列表

值为列表

4.3.3 在字典中存储字典

5. 常用语句

5.1 条件语句 if

5.1.1 常用测试

== 检查是否相等时考虑大小写，大小写可以通过 upper() lower()改变
!= 检查是否不相等
and 检查多个条件，同时成立
or 检查多个条件
in 检查特定值是否包含在列表中
not in 检查特定值是否不包含在列表中
布尔表达式

5.1.2 if语句

if
if-else
if-elif-else
多个if测试多个条件

5.1.3 if语句处理列表

• 检查特殊元素
• 确定列表不是空的

>>> if requested_toppings:
...     print('get')
... else:
...     print('None')
... 
None

5.2 while循环

while + 条件
满足条件则运行while里面的代码，直到不满足条件，跳出循环
使用break跳出循环
使用continue跳出当前循环

6. 函数

6.1 实参和形参

函数定义的时候，变量名是形参，函数调用的时候，传递给函数的是实参

6.2 传递实参

6.2.1 位置实参

调用函数时，Python必须将函数调用中的每个实参都关联到函数定义中的一个形参。为此，最简单的关联方式是基于实参的顺序。这种关联方式被称为位置实参 。
位置实参的顺序很重要。

6.2.2 关键字实参

是传递给函数的名称—值对。直接在实参中将名称和值关联起来了，因此向函数传递实参时不会混淆（不会得到名为Hamster的harry这样的结果）。关键字实参让
你无需考虑函数调用中的实参顺序，还清楚地指出了函数调用中各个值的用途。

6.2.3 默认值

编写函数时，可给每个形参指定默认值 。在调用函数中给形参提供了实参时，Python将使用指定的实参值；否则，将使用形参的默认值。因此，给形参指定默认值后，可在函数调用中省略相应的实参。使用默认值可简化函数调用，还可清楚地
指出函数的典型用法。

6.2.4 让实参变成可选的

def get_formatted_name(first_name, middle_name, last_name):
def get_formatted_name(first_name, last_name, middle_name=''):

6.2.5 传递任意数量的实参

使用形参 *parameters
比如下面的

>>> def make_pizza(*toppings):
...     print(toppings)

>>> make_pizza('pepperoni')
('pepperoni',) #tuple
>>> make_pizza('mushrooms', 'green peppers', 'extra cheese')
('mushrooms', 'green peppers', 'extra cheese') #tuple

6.2.6 结合使用位置实参和任意数量实参

Python先匹配位置实参和关键字实参，再将余下的实参都收集到最后一个形参中。
例如，如果前面的函数还需要一个表示比萨尺寸的实参，必须将该形参放在形参*toppings 的前面：

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

Making a 16-inch pizza with the following toppings:
- pepperoni
>>> make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

Making a 12-inch pizza with the following toppings:
- mushrooms
- green peppers
- extra cheese

6.2.7 使用任意数量的关键字实参

有时候，需要接受任意数量的实参，但预先不知道传递给函数的会是什么样的信息。在这种情况下，可将函数编写成能够接受任意数量的键—值对——调用语句提供了多少就接受多少。和上面的接受任意数量的形参的区别就是，输入是一系列键值对。
一个这样的示例是创建用户简介：你知道你将收到有关用户的信息，但不确定会是什么样的信息。在下面的示例中，函数build_profile() 接受名和姓，同时还接受任意数量的关键字实参：

>>> 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')
>>> user_profile
{'first_name': 'albert', 'last_name': 'einstein', 'location': 'princeton', 'field': 'physics'}

6.3 传递列表

将列表传递给函数后，函数就可对其进行修改。在函数中对这个列表所做的任何修改都是永久性的。
禁止函数修改列表，使用[:]传入列表副本

6.3 返回值

7 类

7.1 创建类

比如创建Dog类

>>> class Dog():
...     def __init__(self, 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!")

7.1.1 方法 __init__()

__init__()是创建实例的时候就会调用的

7.1.2 根据类创建实例

my_dog = Dog('willie', 6)

运行这行代码时，init()会创建一个表示特定小狗的示例，并且设置name，age属性值，该方法并未显式包含return语句，但是返回了一个表示这条小狗的实例，并存储再变量my_dog里面。
接下来便可以访问属性和调用方法了

my_dog.name
my_dog.sit()

还可以创建多个实例

7.2 使用类和实例

7.2.1 给属性指定默认值

7.2.3 修改属性的值

• 直接修改
• 通过方法修改
• 通过方法对属性的值进行递增

7.3 继承

如果要编写的类是另一个现成类的特殊版本，可使用继承 。一个类继承另一个类时，它将自动获得另一个类的所有属性和方法；原有的类称为父类 ，而新类称为子类 。子类继承了其父类的所有属性和方法，同时还可以定义自己的属性和方法。

7.3.1 子类的方法__init__()

class Car():
	"""一次模拟汽车的简单尝试"""
	def __init__(self, make, model, year):
		self.make = make
		self.model = model
		self.year = year
		self.odometer_reading = 0
		
	def get_descriptive_name(self):
		long_name = str(self.year) + ' ' + self.make + ' ' + self.model
		return long_name.title()
		
	def read_odometer(self):
		print("This car has " + str(self.odometer_reading) + " miles on it.")
		
	def update_odometer(self, mileage):
		if mileage >= self.odometer_reading:
		    self.odometer_reading = mileage
		else:
		    print("You can't roll back an odometer!")
		    
	def increment_odometer(self, miles):
		self.odometer_reading += miles
		
class ElectricCar(Car):
	"""电动汽车的独特之处"""
	def __init__(self, make, model, year):
	    """初始化父类的属性"""
	    super().__init__(make, model, year)
	
my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name())

创建子类时，父类必须包含在当前文件中，且位于子类前面。定义子类时，必须在括号内指定父类的名称。方法__init__() 接受创建Car 实例所需的信息。
super() 是一个特殊函数，帮助Python将父类和子类关联起来。这行代码让Python调用ElectricCar 的父类的方法__init__() ，让ElectricCar 实例包含父类的所
有属性。父类也称为超类 （superclass），名称super因此而得名。

7.3.2 给子类定义属性和方法

class ElectricCar(Car):
	"""电动汽车的独特之处"""
	def __init__(self, make, model, year):
	"""初始化父类的属性"""
		super().__init__(make, model, year)
		self.battery_size = 70
	def describe_battery(self):
		"""打印一条描述电瓶容量的消息"""
		print("This car has a " + str(self.battery_size) + "-kWh battery.")

my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name())
my_tesla.describe_battery()

7.3.3 重写父类的方法

Python将不会考虑这个父类方法，而只关注你在子类中定义的相应方法

7.3.4 将实例用作属性

使用代码模拟实物时，你可能会发现自己给类添加的细节越来越多：属性和方法清单以及文件都越来越长。在这种情况下，可能需要将类的一部分作为一个独立的类提取出来。
可以将大型类拆分成多个协同工作的小类。
例如，不断给ElectricCar 类添加细节时，我们可能会发现其中包含很多专门针对汽车电瓶的属性和方法。在这种情况下，我们可将这些属性和方法提取出来，放到另一个名为Battery 的类中，并将一个Battery 实例用作ElectricCar 类的一个属性：

class Car():
	# snip

class Battery():
	'''模拟电动汽车电瓶'''
	def __init__(self, battery_size = 70):
		self.battery_size = battery_size
	def descreble_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)
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()

7.4 导入类

7.4.1 导入单个类

7.4.2 在一个模块中存储多个类

class Car():
    # snip

class Battery():
    # snip

class ElectricCar(Car)
    # snip

7.4.3 从一个模块中导入多个类

from car import Car, ElectricCar

7.4.4 导入整个模块

import car
my_beetle = car.Car('volkswagen', 'beetle', 2016)
my_tesla = car.ElectricCar('tesla', 'roadster', 2016)

7.4.5 在一个模块中导入另一个模块

7.4.5 导入模块中的所有类

from module_name import *

8. 文件和异常

8.1 从文件中读取数据

8.1.1 读取整个文件

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

先通过open()打开文件，open()接受一个参数，要打开的文件名。执行这行代码时，Python在当前执行的文件所在的目录中查找指定的文件。open()返回一个表示文件的对象，存储在后面使用的变量中。
关键字with 在不再需要访问文件后将其关闭。在这个程序中，注意到我们调用了open() ，但没有调用close() ；你也可以调用open() 和close() 来打开和关闭文件，但这样做时，如果程序存在bug，导致close() 语句未执行，文件将不会关闭。这看似微不足道，但未妥善地关闭文件可能会导致数据丢失或受损。如果在程序中过早地调用close() ，你会发现需要使用文件时它已关闭 （无法访问），这会导致更多的错误。并非在任何情况下都能轻松确定关闭文件的恰当时机，但通过使用前面所示的结构，可让Python去确定：你只管打开文件，并在需要时使用它，Python自会在合适的时候自动将其关闭。

8.1.2 逐行读取

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

8.1.3 创建一个包含文件各行内容的列表

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

8.2 写入文件

8.2.1 写入空文件 open(filename, 'w')

打开文件时，可指定读取模式 （‘r’ ）、写入模式 （‘w’ ）、附加模式 （‘a’ ）或让能够读取和写入文件的模式（‘r+’ ）。如果省略了模式实参，Python将以默认的只读模式打开文件。
如果写入的文件不存在，使用**（‘w’)**打开会自动创建，如果已经存在，python在返回文件对象前，会清空该文件。

8.2.2 写入多行

函数write() 不会在你写入的文本末尾添加换行符，因此如果你写入多行时，write()语句中要包含换行符。

8.2.3 附加到文件('a')

添加到文件末尾

9. 零零碎碎

9.1 函数input()工作原理

函数input() 让程序暂停运行，等待用户输入一些文本。获取用户输入后，Python将其存储在一个变量中，以方便使用。
使用int()获取数值输入

9.2 collections

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

favorite_languages为有序字典，遍历favorite_languages ，以添加的顺序获取调查结果。

9.3 异常

编写了处理该异常的代码，程序将继续运行；如果你未对异常进行处理，程序将停止，并显示一个traceback，其中包含有关异常的报告。

9.3.1 处理ZeroDivisionError异常

>>> print(5/0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero

9.3.2 使用try-except代码

try:
    print(5/0)
except ZeroDivisionError:
    print("You can't divide by zero!")

9.3.3 else代码块

try:
    answer = 5/0
except ZeroDivisionError:
    print("You can't divide by zero!")
else:
    print(answer)

Python尝试执行try 代码块中的代码；只有可能引发异常的代码才需要放在try 语句中。有时候，有一些仅在try 代码块成功执行时才需要运行的代码；这些代码应放在else 代码块中。except 代码块告诉Python，如果它尝试运行try 代码块中的代码时引发了指定的异常，该怎么办。

9.3.4 处理FileNotFoundError异常

>>> with open('test.txt') as f_obj:
...     contents = f_obj.read()
... 
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
FileNotFoundError: [Errno 2] No such file or directory: 'test.txt'

>>> file = 'test.txt'
>>> try:
...     with open(file) as f_obj:
...         contents = f_obj.read()
... except FileNotFoundError:
...     msg = 'Sorry, can not found ' + file
...     print(msg)
... 
Sorry, can not found test.txt

9.4 存储数据

9.4.1 json.dump()和json.load()

函数json.dump() 接受两个实参：要存储的数据以及可用于存储数据的文件对象。
json.load()加载文件。

import json
numbers = [1,3,4,5,6]
filename = 'numbers.json'
with open(filename, 'w') as f_obj:
    json.dump(numbers, f_obj)

with open(finename) as f_obj:
    numbers = json.load(f_obj)