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

1.1 变量

变量的命名：

• 在使用标识符时，需要注意如下规则：
• 标识符可以由字母、数字、下画线（_）组成，其中数字不能打头。
• 标识符不能是 Python 关键字，但可以包含关键字。
• 标识符不能包含空格。

# 变量定义与使用
message = "hello python world"
print(message)

1.2 字符串

注意：

字符串的引号可以是单引号也可以是双引号

# 字符串
message = "this is a String"
message1 = 'this is a String'

1.2.1 使用方法修改字符串大小

1. title()：以大写形式显示每个单词

   # 使用方法修改字符串大小
   name = "ada lovelace"
   print(name.title())
   

   输出结果：

   Ada Lovelace
   

2. upper()和lower():分别是将字符串改为大写和全部小写

   name = "ada lovelace"
   print(name.upper()) # ADA LOVELACE
   print(name.lower()) # ada lovelace
   

3. 在字符串中使用变量

   # 在字符串中使用变量
   frist_name = "ada"
   last_name = "lovelace"
   full_name = f"{frist_name}{last_name}"
   # f：format的缩写，{}：里放变量
   print(full_name)# adalovelace
   

4. 删除空白(rstrip():末尾空白， lstrip(): 去除开头空白， strip(): 去除两边空白){注意strip()的功能是暂时的}

   # 删除空白
   favorite_language = 'python  '
   name = 'liuyu'
   print(favorite_language.rstrip())// 删除末尾的空格
   print(f'{favorite_language}{name}')
   favorite_language = favorite_language.rstrip()
   print(f'{favorite_language}{name}')
   '''
   结果为：
   python（此处无空格）
   python  liuyu
   pythonliuyu
   '''
   '''
   我们还可以看见：
   rstrip()的删除作用只是暂时的，如果要永久需要将新值关联到旧值上
   '''
   

1.3 数

注意：结果包含小数位数可能是不确定的

>>> 0.2 + 0.1
0.300000000000004
>>>3 * 0.1
0.300000000000004

注意：书写数较大的数时可以使用下划线将数字分组

>>> universe_age = 14_000_000_000
>>> print(universe_age)
14000000000

第二章 列表

2.1 列表概念

列表是由一系列按特定顺序排序的元素组成。

# 列表
price = 1200
bicycle = ["bike", 'redMi', price, 141241]
print(bicycle)# ['bike', 'redMi', 1200, 141241]

2.2 列表的相关操作

2.2.1 修改元素

# 修改元组元素
motorcycle = ['honda', 'han', 'dao']
print(motorcycle)
motorcycle[0]  = 'nuct'# ['honda', 'han', 'dao']
print(motorcycle)# ['nuct', 'han', 'dao']

2.2.2 添加元素

1. 末尾添加元素

# 末尾添加元素
motorcycle = ['honda', 'han', 'dao']
print(motorcycle)# ['honda', 'han', 'dao']
motorcycle.append('nuct')
print(motorcycle)# ['honda', 'han', 'dao', 'nuct']

1. 列表中添加元素

# 列表中添加元素
motorcycle = ['honda', 'han', 'dao']
print(motorcycle)# ['honda', 'han', 'dao']
motorcycle.insert(0, 'nuct')
print(motorcycle)# ['nuct', 'honda', 'han', 'dao']

2.2.3 从列表中删除数据

方法1：使用del语句删除元素

# 列表中删除数据——del
motorcycle = ['honda', 'han', 'dao']
print(motorcycle)# ['honda', 'han', 'dao']
del motorcycle[0]
print(motorcycle)# [ 'han', 'dao']

方法2： 使用pop()函数删除元素

# 列表中删除数据——pop()
motorcycle = ['honda', 'han', 'dao']
print(motorcycle)# ['honda', 'han', 'dao']
poped_motorcycle = motorcycle.pop()
print(motorcycle)# [ 'han', 'dao']
print(poped_motorcycle)# 'dao'

方法3：弹出列表中任意位置元素：

# 弹出列表中任意位置元素
motorcycle = ['honda', 'han', 'dao']
print(motorcycle)# ['honda', 'han', 'dao']
first_owned = motorcycle.pop(1)
print(first_owned) # han

方法4： 根据值删除元素

# 根据值删除元素
motorcycle = ['honda', 'han', 'dao']
print(motorcycle)# ['honda', 'han', 'dao']
motorcycle.remove('honda')
print(motorcycle) # ['han', 'dao']

2.3 组织列表

2.3.1 使用sort()方法列表实现永久排序

# 使用sort()方法列表实现永久排序
cars = ['bem', 'ak', 'awp']
cars.sort()
print(cars)# ['ak', 'awp', 'bem']

2.3.2 使用sorted()对列表实现暂时的排序

# 使用sorted()对列表实现暂时的排序
cars = ['bem', 'ak', 'awp']
print(cars)# ['bem', 'ak', 'awp']
print(sorted(cars))# ['ak', 'awp', 'bem']
print(cars)# ['bem', 'ak', 'awp']

2.3.3 列表反转

# 列表反转
cars = ['bem', 'ak', 'awp']
reverse(cars)
print(cars)# ['awp', 'ak', 'bem']

2.3.4 列表长度

cars = ['bem', 'ak', 'awp']
print(len(cars))# 3

2.4 操作列表

2.4.1 遍历列表

实例代码：

magicians = ['alice', 'david', 'carolina']
for magician in magicians:print(f"{magician.title()}, that was a trick!")
# Alice, that was a trick!
# David, that was a trick!
# Carolina, that was a trick!

2.4.2 创建数值列表

2.4.2.1 使用range()函数

## 创建数值列表
for value in range(1, 5):print(value)
# 1
# 2
# 3
# 4

2.4.2.2 使用list() 函数

list()函数将range()的结果直接转换为列表。

## list()
numbers = list(range(2, 11, 2))
print(numbers)# [2, 4, 6, 8, 10]

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

2.4.2.3 对数字列表执行简单的统计计算max、 min和sum

digit = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
min(digit)
Out[4]: 0
max(digit)
Out[5]: 9
sum(digit)
Out[6]: 45

2.4.2.4 列表解析

# name = [表达式 变量取值]
squares = [values**2 for values in range(1, 11)]
print(squares)# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

2.4.3 使用列表的一部分

2.4.3.1 切片

# 切片
players = ['charles', 'martina', 'michanl', 'florence', 'eli']
print(players[0:3])# ['charles', 'martina', 'michanl']

如果没有指定第一个索引元素，那么Python将自动从首个元素开始。同理，如果没有指定最后一个索引元素，那么Python以最后一个元素结束。

players = ['charles', 'martina', 'michanl', 'florence', 'eli']
print(players[:3])# ['charles', 'martina', 'michanl']

2.4.3.2 遍历切片

# 遍历切片
players = ['charles', 'martina', 'michanl', 'florence', 'eli']
print("look there are:")
for player in players[:3]:print(player)
# look there are:
# charles
# martina
# michanl

2.4.3.3 复制列表

注意：复制列表不可以 my_food = friend_food,这不是将副本赋值给新的变量

# 复制列表
my_Food = ['pizza', 'falafel', 'lisa']
friend_food = my_Food[:]
friend_food.append('ice cream')
my_Food.append('shit')
print(friend_food)
print(my_Food)
# ['pizza', 'falafel', 'lisa', 'ice cream']
# ['pizza', 'falafel', 'lisa', 'shit']

2.4.4 元组

python将不能修改的值称为不可变， 而不可变的列表称为元组

2.4.4.1 定义元组

元组看起来像列表，但使用圆括号而非中括号来标识。定义元组后， 就可以使用索引来访问。

## 定义元组
dimensions = (200, 50)
print(dimensions[0])
print(dimensions[1])
# 200
# 50

严格来说，元组只是由逗号标记的，圆括号只是让元组看起来更整洁，更清晰。如果你要定义只包含一个元素的元组，必须在这个元素后面的加上逗号：
例如： my_t = （3，）
创建只包含一个元素的元组通常是没有意义的， 但是自动生成的元组可能就只有一个元素

2.4.4.2 遍历与修改元组的值

1. 遍历

dimensions = (200, 50)
for value in dimensions:print(value)

1. 修改

元组不可以被修改，但是可以被重新定义

## 修改元组
dimensions = (200, 50)
for dimension in dimensions:print(dimension)
dimensions = (400, 100)# 重新定义
for dimension in dimensions:print(dimension)
# 200
# 50
# 400
# 100

第三章 if语句

3.1 条件测试

3.1.1 大小写

Python检查时严格区分大小写

car = 'AUDI'
car== 'audi'
Out[4]: False

3.1.2 检查多个条件

3.1.2.1 使用and检查多个条件

age_0 = 22
age_1 = 18
age_0 >= 21 and age_1 >= 21
Out[4]: False
age_1 = 22
age_0 >= 21 and age_1 >= 21
Out[6]: True

3.1.2.2 使用or检查多个条件

age_1 = 18
age_0 = 22
age_0 >= 21 or age_1 >= 21
Out[9]: True
age_0 = 18
age_0 >= 21 or age_1 >= 21
Out[11]: False

3.1.2.3 检查特定值是否在列表中

要判断特定值是否在已包含列表中，可以使用关键词in。如果要检查不在，则使用not in。

banned_users = ['andrew', 'carolina', 'david']
user = 'marie'
if user not in banned_users:print(f"{user.title()}, you can post a response if you wish.")
# Marie, you can post a response if you wish.

3.2 if语句

3.2.1 if语句

if condition_test:do something

3.2.2 if-else语句

age = 17
if age >= 18:print("age >= 18")
else:    print("<18")
# <18

3.2.3 if-elif-else 结构

age = 17
if age >= 18:print("age > 18")
elif age == 18: print("== 18")
else: print("<18")
# <18

3.2.4 其他结构

比如：省略else， 多个elif等

3.3 使用if语句处理列表

3.3.1 确定列表不是空

requested_toppings = []
if requested_toppings:print("okk")
else:     print("Are you sure you want a plain pizza")
# Are you sure you want a plain pizza

第四章 字典

字典是一系列键值对。每一个键值对都与一个值相关联，你可以使用键来访问相关联的值。与值相关联的值是数、字符串、列表甚至是字典。事实上，任何Python对象都可以作为字典中的值。

示例：

alien_0 = {'color': 'green'}

4.1 字典基本操作

4.1.1 访问字典中的值

alien_0 = {'color': 'green'}
print(alien_0['color'])
# green

4.1.2 添加键值对

字典是一种动态结构，可随时在其中添加键值对。要添加键值对，可依次指定字典名、用方括号括起来的键和相关联的值。

alien_0 = {'color': 'green'}
print(alien_0['color'])
green
alien_0['x_position'] = 0
alien_0['y_position'] = 25
print(alien_0)
# {'color': 'green', 'x_position': 0, 'y_position': 25}

4.1.3 创建空字典

alien_0 = {}

4.1.4 修改字典中的值

alien_0 = {'color': 'green'}
print(alien_0['color'])
green
alien_0['x_position'] = 0
alien_0['y_position'] = 25
print(alien_0)
# {'color': 'green', 'x_position': 0, 'y_position': 25}
alien_0['color'] = 'orange'
print(alien_0)
# {'color': 'orange', 'x_position': 0, 'y_position': 25}

4.1.5 删除键值对

可使用del语句将相应的键值对彻底删除。

alien_0['point'] = 15
print(alien_0)
# {'color': 'orange', 'x_position': 0, 'y_position': 25, 'point': 15}
del alien_0['points']
del alien_0['point']
print(alien_0)
# {'color': 'orange', 'x_position': 0, 'y_position': 25}

注意：删除的键值对，会永远消失

4.1.6 由类似对象组成的字典

在最后一个键值对后面加上逗号，为以后在下一行添加键值对做好准备。

favorite_language = {'jen': 'python','sarah' : 'c',}

4.1.7 使用get()来访问值

就字典而言， 我们可以使用方法get()在指定的键不存在时返回第一个默认值，从而避免这样的错误。
方法第一个参数用于指定键，是必不可少的；第二个参数为指定的键不存在时要返回的值，是可选的。

print(alien_0['points'])
Traceback (most recent call last):File "D:\Anaconda\lib\site-packages\IPython\core\interactiveshell.py", line 3437, in run_codeexec(code_obj, self.user_global_ns, self.user_ns)File "<ipython-input-35-f1f50dde710a>", line 1, in <module>print(alien_0['points'])
KeyError: 'points'
point_value = alien_0.get('points', 'No point value assigned.')
print(point_value)
# No point value assigned.

如果指定的键不存在，应考虑使用方法get()， 而不是方括号法。

4.2 遍历字典

4.2.1 遍历所有键值对

1. key与value可以使用任意名称，注意用看的懂的名称
2. items()

user_0 = {"user_name": "liuYu", 'first': 'enrico', 'second' : 'feiMao'}
for key, value in user_0.items():print(f"\nkey{key}")print(f"Value:{value}")
#keyuser_name
#Value:liuYu
#keyfirst
#Value:enrico
#keysecond
#Value:feiMao

4.2.2 遍历所有的键

在不需要使用字典的值时，可以使用keys()

favorite_language = {'jen': 'python','sarah' : 'c',}
for name in favorite_language.keys():print(name)
#jen
#sarah

4.2.3 按照特定顺序遍历字典中所有的键

favorite_language = {'jen': 'python','sarah' : 'c',}
for name in sorted(favorite_language.keys()):print(name)

4.2.4 遍历字典中所有值

在不需要使用字典的键时，可以使用values()

favorite_language = {'jen': 'python','sarah' : 'c',}
for language in favorite_language.values():print(language)

为了剔除重复项，可以使用set()。不同与列表与字典，集合不会以特定的顺序存储元素

favorite_language = {'jen': 'python','sarah' : 'c',}
for name in set(favorite_language.keys()):# 此处使用set来提取值中不同的的元素print(name)

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 在字典中存储列表

favorite_languages = {'jen':['python', 'ruby'], 'sarah' : ['c'], 'edward':['ruby', 'go'], 'phil':['python', 'haskell'],}
for name, languages in favorite_languages.items():print(f"\n{name.title()}'s favorite language are:")for language in languages:print(f"\t{language.title()}")
"""
Jen's favorite language are:PythonRuby
Sarah's favorite language are:C
Edward's favorite language are:RubyGo
Phil's favorite language are:PythonHaskell
"""

4.3.3 在字典中存储字典

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

第五章 用户输入与while循环

5.1 函数input() 的工作原理

message = input("tell me what the truth")
print(message)
# 创建多行提示：
prompt = "if you tell us who you are, we can personlize the message you see."
prompt += "\nWhat is your first name?"
name = input(prompt)

5.2 使用int() 来获取数值输入

在函数input()时，Python将用户输入解读为字符串。如果还是把输入当成数值来使用，那么会出现错误。

为了解决这个问题，我们可以使用函数int(),他让PYthon将输入认为是数值。函数int()将数的字符串表示转换为数值表示。

#使用int() 来获取数值输入
age = input('How tall you are, in inches?')
How tall you are, in inches?>? 12
age = int(age)
age > 18
Out[55]: False

5.3 while循环

5.3.1 使用while循环

使用标志（flag）

5.3.2 使用break退出循环

5.3.3 在循环中使用continue跳过某流程

5.3.4 使用while循环处理列表与字典

while unconfirmed_users:current_user = unconfirmed_users.pop()print(f"Verifying user: {current_user.title()}")confirmed_users.append(current_user)
print("\nthe following users have been confirmed:")
# Verifying user: Brain
# Verifying user: Alice

当前一个字典变为空时，即此时False

5.3.5 删除为特定值的所有列表元素

pets = {}
pets = ['dog', 'cat', 'monkey']
while 'cat' in pets:pets.remove('cat')
print(pets)

第六章 函数

6.1 定义函数

def greet_user(): print("Hello")greet_user()
# Hello

6.2 实参与形参

形参：函数完成工作所需的信息
实参：调用函数时传递给函数的信息

6.2.1 传递实参

6.2.1.1 位置实参

此时根据函数参数位置来选择参数。如果位置出错，可能出现意想不到的错误

def describe_pet(animal_type, pet_name):print(f"My {animal_type}'s name is {pet_name.title()}.")
describe_pet('hamster', 'harry')
# My hamster's name is Harry.

6.2.1.2 关键字实参

def describe_pet(animal_type, pet_name):print(f"My {animal_type}'s name is {pet_name.title()}.")
describe_pet(animal_type = 'hamster', pet_name = 'harry')# 这两种都行
describe_pet(pet_name = 'harry', animal_type = 'hamster')
# My hamster's name is Harry.
# My hamster's name is Harry.

6.2.1.3 默认值

def describe_pet(animal_type = 'dog', pet_name):print(f"My {animal_type}'s name is {pet_name.title()}.")
describe_pet('Harry')
# My dog's name is Harry.

6.3 返回值

6.3.1 返回可选值

如果返回可选值，可以使用默认值来处理

def get_formatted_name(first_name, last_name, middle_name = ' '):if middle_name:full_name = f"{first_name} {middle_name} {last_name}"else:full_name = f"{first_name} {last_name}"return full_name.title()
mucian = get_formatted_name('jimi', 'hendrix')
print(mucian)
# Jimi   Hendrix

注意：禁止函数直接修改列表
function_name(list_name[:])-------->>>这个可以实现副本传递

6.3.2 传递任意数量的实参

def make_pizza(*toppings):print(toppings)
make_pizza('pepperoni')
make_pizza('mushroom', 'green peppers', 'extra cheese')
#('pepperoni',)
#('mushroom', 'green peppers', 'extra cheese')

形参名*toppings中的星号让python创建一个名为toppings的空元组，并将收到的所有值收入到这个元组中。注意：函数体python将实数参数封装到一个元组中，即使函数只收到一个值。

注意：我们还可以结合使用位置和任意数量参数
例：def make_pizza(size, *topping)

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

有时候需要接受任意数量的实参，但预先不知道传递给函数的会是什么样的信息。在这种情况下，可将函数编成能够接受任意数量的键值对——调用语句提供多少就接受多少。

def build_profile(first, last, **user_info):user_info['first_name'] = firstuser_info['last_name'] = lastreturn user_info
user_profile = build_profile('albert', 'einstein', location = 'princeton', filed = 'physics')
print(user_profile)
# {'location': 'princeton', 'filed': 'physics', 'first_name': 'albert', 'last_name': 'einstein'}

6.4 将函数存储在模块中

使用函数的最大优点是可将代码块与主程序相分离。我们还可以更进一步，将函数的存储在称为模块的独立文件中。再将文件模块导入主程序中。

6.4.1 导入整个模块

要让模块可导，得先创建模块。模块是扩展名为.py的文件。
下面我们创建pizza.py的文件

# pizza.py
def make_pizza(size, *toppings):print(f"\nMaking a {size} - inch pizza with the following toppings:")for topping in toppings:print(f"-{topping}")

我们再创建一个make_pizzas.py的文件，调用此函数。

import pizza
pizza.make_pizza(16, 'peppereroni')
pizza.make_pizza(12, 'peppereroni', 'mushroom', 'extra cheese')

6.4.2 导入特定的函数

# 格式1：
from module_name import function_name
# 格式2：
from module_name import function_name1, function_name2, function_name3

# 示例：
from pizza import make_pizzamake_pizza(12, 'papper')

6.4.3 使用as给函数指定别名

# 格式：
from module_name import function_name as fn

# 示例：
from pizza import make_pizza as mp
mp(16, 'pepperoni')

6.4.4 使用as给模块指定别名

# 格式：
import module_name as mn

# 示例：
import pizza as p
p.make_pizza(16, 'pepperoni')

注意：使用*可以导入全部函数

第七章 类

7.1 创建和使用类

7.1.1 创建Dog类

class Dog:def _init_(self, name, age):self.name = nameself.age = agedef sit(self):    print(f"{self.name} is now sitting.") def roll_over(self):print(f"{self.name}roll over!")

方法_init_():
此方法为特殊方法，每当你使用Dog类创建新对象时，Python会自动调用该方法。在这个方法的名称中，开头语末尾都有两个下划线，这个是一个约定，旨在避免python默认方法与普通方法发生冲突。务必保证两边都有两个下划线，否则当函数调用时将不会自动调用该函数，进而引起难以发现的问题。
我们将方法__init__()定义的成包含是三个形参：self、 name和age。在这个方法的定义中，形参self() 必不可少，而且必须位于其他形参的前面。为何必须在方法定义中包含形参self呢？因为Python调用这个方法来创建Dog实例时，将自动传入实参self。每个与实例相关联的方法调用都自动传递实参self,它是一个指向实例本身的引用，让实例能够访问类中的属性和方法。创建Dog实例时，Python将调用Dog类的方法_init_()。我们将通过实参向Dog()传递名字和年龄，self会自动传递，因此不需要传递它。每当根据Dog类创建实例时，都只需给最后两个形参（name和age）提供值。

7.1.2 根据类创建实例

my_dog = Dog('Willie', 6)print(f"My dog's name is {my_dog.name}.")
print(f"My dog is {mydog.age} years old.")

1. 访问属性：

my_dog.name

1. 调用方法

my_dog.sit()

1. 创建多个实例

洛洛洛

7.2 使用类和实例

7.2.1 Car类

class Car:def __init__(self, make, model, year):self.make = makeself.model = modelself.year = yeardef get_descriptive_name(self):long_name = f"{self.year}{self.make}{self.mode}"return long_name.title()
my_new_car = Car('audi', 'a4', 2019)
print(my_new_car.get_descriptive_name())

7.2.2 给属性指定默认值

class Car:def __init__(self, make, model, year):self.make = makeself.model = modelself.year = 0

7.2.3 修改属性的值

1. 直接修改属性的值

my_new_car.odometer_reading = 23
my_new_car.read_odomenter()

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

def update——odometer(self, milage):self.odometer_reading = mileage
my_new_car.update_odometer(23)
my_new_car.read_odometer()

7.3 继承

在继承时，并非总是要从空白开始。如果要编写的类是另一个现成类的特殊版本，可以使用继承。一个类继承另一个类时，将自动获得另一个类的所有属性与方法。原有的类称为父类，而新的类称为子类。子类继承了父类所有属性和方法，同时还有属于自己的方法。

7.3.1 子类的方法__init__()

下面创建ElectricCar类的一个简单版本，他具备Car类的所有功能

class Car:def __init__(self, make, model, year):self.make = makeself.model = modelself.year = yeardef get_descriptive_name(self):long_name = f"{self.year}{self.make}{self.mode}"return long_name.title()def update——odometer(self, milage):self.odometer_reading = mileage
class ElectricCar(Car):def __init__(self, make, model, year):super().__init__(make, model, year)
my_tesla = ElectricCar('tesla', 'model s', 2019)
print(my_tesla.get_descriptive_name())

super()是一个特殊函数，让你能够调用父类的方法。这行代码让python调用Car类的方法__init__(),让ELectricCar 实例包含这个方法中定义的所有属性。父类也称为超类（superclass）， 名称super就此而来。

7.3.2 给子类定义属性和方法

class ElectricCar(Car):def __init__(self, make, model, year):super().__init__(make, model, year)self.battery_size = 75# 定义子类特有属性def describe_battery(self):# 定义子类特有方法print(f"This car has a {self.battery_size}-kwh battery.")

7.3.3 重写子类的方法

class class ElectricCar(Car):def fill_gas_tank(self):print("This car does't have tank.")

现在如果有人对电动车调用方法fill_gas_tank(), Python将忽略Car类中的方法，转而运行上述代码。使用继承时，可让子类保证从父类继承的是精华。

7.3.4 将实例用作属性

class Car:--snip--
class Battery:def __init__(self, battery_size = 75):self.battery_size = battery_sizedef describe_battery(self):print(f"This car has a {self.battery_size}-kwh battery.")
class ElectricCar(Car):def __init__(self, make, model, year):super().__init__(make, model, year)self.battery = Battery()# 定义子类特有属性def describe_battery(self):# 定义子类特有方法print(f"This car has a {self.battery_size}-kwh battery.")my_tesla = ElectricCar('tesla', 'models', 2019)print(my_tesla.battery.describe_battery())# 我们可以将实例作为属性

7.4 导入类

7.4.1 导入单个类

# car.py
# 一个可以用于表示汽车的类
class Car:"""这是一个汽车类"""def __init__(self, make, model, year):"""描述汽车的属性"""self.make = makeself.model = modelself.year = yearself.odometer_reading = 0def get_descriptive_name(self):"""返回整洁的描述性名称"""long_name = f"{self.year}{self.name}{self.model}."return long_name.title()def read_odometer(self):"""打印一条关于里程的消息"""print(f"This car has {self.obometer_reading} miles on it.")

# my_car.py
from car import Car# 导入单个类
my_new_car = Car('audi', 'a4', 2019)
print(my_new_car.get_descriptive_name())my_new_car.obometer_reading = 23
my_new_car.read_obometer()

注意：书写类时，我们应包含模块级文档字符串，对该模块的内容作出简要的描述。此外，导入类简化了主程序文件。

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

虽然同一个类之间应存在某种相关性，但可以根据需要在一个模块中存储任意数量的类。

# 这里只是示例
class Car:--snip--
class ElctricCar:--snip--

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

# 语法结构
from module_name import class_name1, class_name2, ...

7.4.4 导入整个模块

# 语法结构
import car

7.4.5 导入模块中的所有类

# 语法结构
from module_name import *

注意：这不推荐使用此方法，因为其导入类不够明确。所以，容易导致重名的情况。如果需要从一个模块导入很多类，最好是导入整模块，并使用module_name.ClassName语法来访问类。

7.4.6 使用别名

# 语法规范
from module_name import ElectricCar as EC

7.5 类编码风格

类名都要采用驼峰命名法，即类名中每个字母的首字母都要大写，而使用下划线。实例名和模块名采用小写格式，并且在单词之间添加下横线。

第八章 文件和异常

8.1 从文件中读取数据

8.1.1 读取整个文件

要读取文件，需要一个包含几行文本的文件。下面首先创建一个包含几行文本的文件。下面首先创建一个文件，它包含精确到小数点后30位的圆周率值，并且小数点后每10位换行：

# pi_digits.py
3.141592653589793238462643383279

# 执行程序
with open('pi_digit.txt') as file_object:contents = file_object.read()
print(contents)
'''
res:
3.141592653589793238462643383279'''

在这个程序中，我们注意到open(), 但没有调用close()。也可以调用close()，但这样做时，如果程序中存在bug导致方法close()未执行。文件将不会关闭。这看似微不足道，但未妥善关闭文件会导致数据丢失或受损。如果程序中过早调用close(),你会发现这可能在使用过程中，文件已经关闭，这样导致的错误会更多。我们其实就可以使用前面所示的结构，可让python确定：你只管打开文件，并在需要的时候使用它，python会自动将其关闭。

我们还发现结果末尾还多出一个空行，这是由于read()到文件末尾时返回一个空字符串，而将这个空字符串显示出来就是一个空行。我们可以使用下面程序去掉空行。

# 去除空行
with open('pi_digit.txt') as file_object:contents = file_object.read()
print(contents.rstrip())
'''
res:
3.141592653589793238462643383279
'''

8.1.2 文件路径

1. 相对路径：

with open('test_file/ file_name.txt') as file_object:
# 注意：显示文件路径时，Windows使用的是反斜杠（\）而不是斜杆（/），但是代码中依然可以使用斜杠。

1. 绝对路径：

file_path = 'C:\Windows\addins'
with open(file_path) as file_object:
# 如果在文件路径中直接使用反斜杠，将引发错误，因为与转义字符冲突。可对文件路径的每一个反斜杠进行转义，如：“C:\\Windows\\addins”

8.1.3 逐行读取

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

将要读取的文件的名称赋值给变量filename。这是使用文件时的一种常见的做法。变量filename表示的并非实际文件——他只是一个让python知道到哪里查找文件的字符串。因此可以将’pi_digit.txt’替换为要使用的另一个文件的名称。调用open()后，将一个表示文件及其内容的对象赋给了变量file_object。这时候发现空行更多了，可以依旧采用上文方法来消除空行。

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

如果要使用文件中内容的，就要把文件内容保存下来。

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

readlines()从文件中读取每一行，并将其存储在一个列表中。接下来，该列表的被赋值给变量lines。

8.1.5 使用文件的内容

在读取文件时，Python将其中的所有文本都解读为字符串。如果读取的是数，并将其作为数值使用，就必须使用int()将其转换，或者使用float()函数转换为浮点数。

8.2 写入文件

8.2.1 写入空文件

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

在本例中， 调用open()时提供两个实参。第一个是要打开的文件名称， 第二个实参(‘w’)告诉Python， 要以写入模式打开这个文件。打开文件时，可指定读取模式(‘r’)、写入模式(‘w’)、附加模式(‘a’)和读写模式(‘r+’)。如果省略第模式参数，将以只读模式打开文件。

如果要写入的文件不存在，函数open()将自动创建它。然而，以写入模式（‘w’）打开文件时千万要小心，因为如果指定的文件已经存在，Python将在返回文件时清空该文件的内容。

Python只能将字符串写入文本文件。要将数值数据存储到文本文件中，必须先要使用str()将其装换为字符串格式。

8.2.2 写入多行

注意：函数write()不会在写入的文本末尾添加换行符，因此如果写入多行时没有指定换行符，文件看起来不会像你希望的那样。

filename = 'programming.txt'with open(filename) as file_object:file_object.write("I love programming.\n")file_object.write("I don't love gamming.\n")

8.2.3 附加到文件

如果要给文件添加内容，而不是覆盖原来内容，可以以附加模式打开文件。如果指定的文件不存在，Python将为你创建一个文件。

8.3 异常

8.3.1 处理ZeroDivisionError异常

# 以下会出现错误
print(5/0)

8.3.2 使用try-except代码块

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

使用异常可以避免程序奔溃。

8.3.3 else代码块

--snip--
while True:--snip--if second_number == 'q'breaktry:answer = int(first_number)/int(second_number)except ZeroDivisionError:print("error")else:print(answer)

有时候，有一些仅仅try代码块成功时才需要执行的代码，这些代码放在else代码块中。

8.3.4 处理FileNotFoundError异常

file_name = 'alice.txt'with open(filename, encoding = 'utf-8') as f:contents = f.read()

这里有两个不同之处：一是使用变量f来表示文件对象，这是一种常见方法。二是给参数encoding指定了值，在系统默认编码与要读取文件使用的编码不一致时，必须这样做。

file_name = 'alice.txt'try：with open(filename, encoding = 'utf-8') as f:contents = f.read()
except FileNotFoundError：print('error')

8.3.5 静默失败

Python有个pass语句，可让Python在代码块中什么都不要做：

def count_words(filename):try:--snip--except:passelse:--snip--
filename = ['alice.txt', 'litte_women.txt']
for filename in filenames:count_words(filename)

pass语句还充当占位符，提醒你在那里什么没做，并且也许要做什么。

8.4 存储数据

很多程序都要求用户输入某种信息，如让用户存储游戏信息什么的。用户关闭程序时还要保存数据。一种简单的方式就是使用模块json来存储数据。
模块json让你能够将简单的Python数据结构转存到文件中，并在程序运行时加载该文件。使用json还可以在python程序之间分享数据。

8.4.1 使用json.dump()和json.load()

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

import jsonnumber = [2, 3, 4, 5, 6]filename = 'number.json'
with open(filename, 'w') as f:json.dump(number, f)

这个程序没有输出，当打开文件 number.json 来看看内容。数据存储格式与python中的一样：

[2, 3, 4, 5, 6]

下面使用json.load()将列表读取到内存中：

import jsonfilename = 'number.json'
with open(filename) as f:numbers = json.load(f)
print(numbers)
# [2, 3, 4, 5, 6]

这是在程序之间共享数据的简单方式。

8.4.2 保存与读取用户生成的数据

使用json保存的用户数据大有裨益，因为如果不是以某种方式存储，用户的信息会在程序停止运行时丢失。

熬夜整理两万字Python知识点相关推荐

1. 干货分享丨精心整理了份Python知识点高清速查表！太受用了！

   去年底北大保安"神仙打架"的新闻,让本来就火得一塌糊涂的Python又上了把热搜. 资料来源 @北大官微 不过,最吸引我的不是这条微博本身,而是一条"学会Python,可 ...

2. 熬夜整理2022最新Python最全学习资料，看进度条就知道有多强了

   Python最新学习资料和视频 一.Python软件 安装教程 视频教程 二.学习规划 阶段一:Python基础 阶段二:Python核心编程 阶段三:web前端开发 阶段四:数据库 阶段五:后端开发 ...

3. python n个list如何组成矩阵_学完Python，我决定熬夜整理这篇总结...

   来源:http://suo.im/5wzRqt 前言:学完Python,我决定熬夜整理这篇总结- 一.了解Python Python之父 Guido Van Rossum,一位荷兰程序员,在1989年 ...

4. ❤️思维导图整理大厂面试高频数组: 两万字详解各种数组求和(建议收藏)❤️

   此专栏文章是对力扣上算法题目各种方法的总结和归纳, 整理出最重要的思路和知识重点并以思维导图形式呈现, 当然也会加上我对导图的详解. 目的是为了更方便快捷的记忆和回忆算法重点(不用每次都重复看题解), ...

5. Python知识点整理（完整）

   Python知识点整理 ✅作者简介:大家好我是编程ID

6. python知识点整理

   1.对缺省参数的理解.给出代码 缺省参数在python中是与函数绑定在一起的. 也就是说,一个函数中定义了一个缺省参数,那么这个参数会随着被调用而改变. def extendList(val, lis ...

7. tensorflow和python先学哪个-前辈说先学会了这些Python知识点，再谈学习人工智能！...

   原标题:前辈说先学会了这些Python知识点,再谈学习人工智能! 首先我们看一看Python的优势: 开源,跨平台. 社区.不要小看这一点.社区意味着有很多教程.书籍,出了问题很容易google到,乃 ...

8. [Github项目推荐] 机器学习 Python 知识点速查表

   2019年第 21 篇文章,总第 45 篇文章 今天推荐三份知识点的速查表,分别是机器学习.深度学习和 Python 三方面的知识点速查表.其中前两份都是来自斯坦福大学的课程,分别是 CS229 机器 ...

9. Linux常用命令详解(两万字超长文)

   Linux常用命令详解 作为一枚程序员,熟练掌握一些常见的linux命令是很有必要的,掌握这些命令能帮助我们更好地管理Linux系统,提高工作效率,并有效地解决各种问题,为了方便自己后续查阅以及帮助不 ...

最新文章

1. 3.11 总结-深度学习第四课《卷积神经网络》-Stanford吴恩达教授
2. 登录微信用android设备,Android 之微信登录
3. 每天都有所收获_使技术保持最新状态会有所收获
4. 20200702：最长公共子序列（leetcode1143）
5. UltimateAndroid快速开发框架教程
6. 能量，功率，能量谱和功率谱密度
7. Shell脚本-Dong
8. PHP-SDK实现微信付款码支付
9. 移动开发采用什么平台好?
10. 给设计师的建设性反馈
11. 百度关键词分析工具_【轰炸类】关键词百度首页分析【澳门XXX】【实战分析】...
12. 二叉树的遍历（前序遍历，中序遍历，后序遍历）
13. Bootstrap-maxlength使用
14. 【Android】更换头像的实现
15. 微信订阅号的订阅模式有哪些？
16. 商品模块数据库表解析（一）
17. ICG-PEG-MAL,吲哚箐绿-聚乙二醇-马来酰亚胺；用于标记肽，蛋白质，寡核苷酸和一些小分子中的巯基
18. JavaScript中string与number
19. java自定义注解枚举_java_自定义注解
20. 隐藏隧道通信：HTTP/HTTPS 代理转发

热门文章

1. Jmeter使用教学
2. 【绝对管用】彻底的卸载干净oracle 11g
3. mysql slave-skip-errors_mysql之slave_skip_errors选项
4. php前台限制输入text字符,限制字符输入数功能(jquery版和原生JS版)
5. 高效能人士的七个习惯及亚马逊十四条领导力准则
6. [JavaScript]如何将www.xxx.com变为com.xxx.www
7. CSS-Sprite（雪碧图）
8. 修改elementui组件el-input样式
9. 树分治（挑战p360）
10. oracle量子,量子计算