一 变量和简单数据类型
1. 变量名包含字母/数字/下划线，不能以数字开头；
Python根据缩进来判断代码行与前一个代码行的关系；
2. 字符串处理：字符串单引双引均可以；
a.title() //对字符串a中的单词首字母大写；
a.upper() //将字符串改为全大写；
a.lower() //将字符串改为全小写；
a.rstrip() //删除字符串末尾的空白；
a.lstrip() //删除字符串开头的空白；
a.rstrip() //删除字符串两端的空白；
撇号位于双引之间，
3. 数字
a. 3**2表示乘方，9；
b. 浮点数的小数点位数不确定；
>>> 0.1+1.3
1.4000000000000001 c. 将整数类型改为字符串；str(a) //将非字符串表示为字符串；常在print里打印整数时用；
d. 3/2 结果是1，只取整；3.0/3结果是1.5；至少一个取浮点数
二 列表
1. 用[]表示列表，逗号分分隔；
a=['aa','bb','cc']
a[0].title()即Aa；
a[-2]即倒数第二个；
2. 增删查改：
a. append('dd') //结果a=['aa','bb','cc','dd']
a.insert(0,'zz') //结果a=['zz','aa','bb','cc']
del a[0] //结果a=['bb','cc']
b=a.pop() //结果a=['aa','bb'],b=['cc']
b=a.pop(0) //结果b=['aa'],a=['bb','cc']
a.remove('bb) //结果a=['aa','cc'],只删除第一个指定的值；
3. 组织列表:
a.sort() //永久排序，以字母排序；a.sort(reverse=True) //字母顺序降序；不能print(a.sort())
print(a.sorted()) //临时排序，a的值不变；也可加reverse=True；
a.reverse() //结果a倒叙
len(a) //a的长度，3
三 操作列表
1. 遍历整个列表
cats=['cata','catb','catc','catd']
for cat in cats:
print(cat.title()+", that is a great cat!")
print("\nthank u!") 此行无缩进，只执行1次；有\n中间空一行；
2. 创建数值列表
a. for value in range(1,5):
print(vlaue) 打印1到4
b. numbers=list(range(1,5))
print(numbers) 打印1到4，也可以加步长list(range(1,5,2))结果是1和3
c. 对数字列表执行简单的统计计算
min(numbers) numbers的最小值，max/sum()分别是最大值/总和；
d. 列表解析
squares=[value**2 for value in range(1,11)]
print(squares) 打印1，4，9，16到100
3. 列表的部分元素，切片
a. print(cats[0:3]) 输出0，1，2索引的元素；[:3]不指定第一个索引时从0开始；[3:]表示从索引2到最后；
b. 遍历切片
for cat in cats[:3]:
print(cat.title()) 打印前三个cats元素；[‘’,‘’,‘’,‘’]这种格式打印
c. 复制列表
cat_copy=cats[:] 复制cats表的所有元素到cat_copy
cat_copy=cats 这个是只有一个表，对两个表的操作会同时作用于cat_copy和cats；
4. 元组：不可变的列表
a. 访问元组
dimensions=(200,50,10)
print(dimensions[0]) 元组访问元素的方法与列表同；打印格式是一行一个元素；
b. 遍历所有元素
for dimension in dimensions:
print(dimension)
c. 修改元组变量：重新定义整个元组
5. 设置代码格式
a. PEP 8建议每级缩进都使用四个空格，这既可提高可读性，又留下了足够的多级缩进空间;
可将输入的制表符转换为指定数量的空格;
b. 很多Python程序员都建议每行不超过80字符;
PEP 8还建议注释的行长都不超过72字符，因为有些工具为大型项目自动生成文档时，会在每行注释开头添加格式化字符;
四. if语句
1. 例：for car in cars:
if car='bmw':
print(car.upper())
else:
print(car.title())
2. 条件测试
car=='bmw' //返回true或false；区分大小写，如果想不区分大小写，可以car.tower(),改成小写比较；
car !='bmw'
car >= 0 and car <=20 ;用and或or检查多个条件；用in检查特定值是否包含在列表中(not in相反)；
3. if-elif-else结构，一个个判断； 中间可加多个elif；最后的else也可不加；
if 'cat1' in cats:
print()
if 'cat2' in cats:
print()
以上两个if，用于测试多个条件时；判断多个元素满足条件；
五. 字典：一系列键值对；值可以是字符串/数字/列表/元组；
1. 简单字典：
alien_0={'color':'green','points':5}
print(alien_0['color']) //打印green
2. 使用字典
a. 访问字典中的值：alien_0['color']
b. 增加键值对：alien_0['x_position']=0 //在字典里的顺序不确定
c. 先创建一个空字典：alien_0={}
d. 修改字典中的值：alien_0['color']='yellow'
e. 删除键值对：del alien_0['points']
3. 遍历字典
a. 遍历所有的键值对：for key,value in alien_0(): //也可用k,v
b. 遍历字典中的所有键：
for name in alien_0.keys():
print(name.title()) //使用keys()
if name in ~: //此处可加一个判断name是不是在某一个列表里；
c. 按顺序遍历字典中的所有键：
for name in sorted(alien_0.keys()) //使用函数sorted按特定顺序排序，字母升序；
d. 遍历字典中的所有值：alien_0.vlaues()
使用集合set，类似于列表，每个元素都必须是独一无二的：set(alien_0.values())
4. 嵌套：将字典存储在列表中，或将列表存储在字典中。
a. 字典列表：
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]
b. 在字典中存储列表
pizza = {
'crust': 'thick',
'toppings': ['mushrooms', 'extra cheese'], }例2：for name, languages in favorite_languages.items(): //name/languages分别代表favorite_languages的键值；
c. 在字典中存储字典
users = {
'aeinstein': {
'first': 'albert', 'last': 'einstein', 'location': 'princeton', },
'mcurie': {
'first': 'marie', 'last': 'curie', 'location': 'paris', },}
for username, user_info in users.items():
....
location=user_info['location']
六. 用户输入和while循环
1. input() //用户输入文本,raw_input()输入的都是字符串；input()则要严格遵守python语法；3.0版本合并了这两个；2.7的版本最好只用raw_input()
a. 例：message = input("Tell me something, and I will repeat it back to you: ")
print(message)
b. 使用int()获取数值；input()获取的是字符串，用int()将字符串形式作为数字；%求模运算；
2. while循环
a.使用标志：
prompt = "\nTell me something, and I will repeat it back to you:"
prompt += "\nEnter 'quit' to end the program. "
active = True
while active:
message = input(prompt)
if message == 'quit':
active = False
else:
print(message)
b.在循环中使用break/continue；避免无限循环；
3.使用while循环来处理列表和字典
for 循环是一种遍历列表的有效方式，但在for 循环中不应修改列表，否则将导致Python难以跟踪其中的元素。要在遍历列表的同时对其进行修改，可使用while 循环。
a.在列表之间移动元素
# 首先，创建一个待验证用户列表
# 和一个用于存储已验证用户的空列表
unconfirmed_users = ['alice', 'brian', 'candace']confirmed_users = []
# 验证每个用户，直到没有未验证用户为止
# 将每个经过验证的列表都移到已验证用户列表中
while unconfirmed_users:
current_user = unconfirmed_users.pop() //pop()从列表中取值，类似于栈，从后取；
print("Verifying user: " + current_user.title())
confirmed_users.append(current_user)
# 显示所有已验证的用户
print("\nThe following users have been confirmed:")for confirmed_user in confirmed_users:
print(confirmed_user.title())
b.删除包含特性值的列表元素
pets = ['dog', 'cat', 'dog', 'goldfish', 'cat', 'rabbit', 'cat'] print(pets)
while 'cat' in pets:
pets.remove('cat')
c.使用用户输入来填充字典
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
# 调查结束，显示结果
print("\n--- Poll Results ---")
for name, response in responses.items():print(name + " would like to climb " + response + ".")
七. 函数
def greet_user(username):
print('Hello,'+username.title()+'!')
greet_user('min')
a. 关键字实参：传递给函数的名称—值对。以下两个函数调用是等价的，实参的位置与值无关了。
describe_pet(animal_type='hamster', pet_name='harry')
describe_pet(pet_name='harry', animal_type='hamster')
b. 默认值：定义函数时给一个默认值，调用函数时有值则可忽略此值。
def describe_pet(pet_name, animal_type='dog'):
c. 让实参变成可选的：
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_namereturn full_name.title()
musician = get_formatted_name('jimi', 'hendrix')
print(musician)
musician = get_formatted_name('john', 'hooker', 'lee')
print(musician)
d. 返回字典
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',age=27)
print(musician) 返回{'age': 27, 'last': 'hendrix', 'first': 'jimi'}
e. 传递列表
def greet_users(names):
for name in names:
msg = "Hello, " + name.title() + "!"
print(msg)
usernames = ['hannah', 'ty', 'margot']
greet_users(usernames)
f. 禁止函数修改列表：function_name(list_name[:]),将列表的副本传递给函数
例：print_models(unprinted_designs[:], completed_models) //函数获得了所有未打印的设计的名称，但它使用的是列表unprinted_designs 的副本，而不是列 表unprinted_designs 本身。
g. 传递任意数量的实参：def make_pizza(*toppings): //*toppings 中的星号让Python创建一个名为toppings 的空元组，并将收到的所有值都封装到这个元组中。
//参数中可添加其他形参；
def build_profile(first, last, **user_info): //形参**user_info 中的两个星号让Python创建一个名为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) //打印：{'field': 'physics', 'first_name': 'albert', 'last_name': 'einstein', 'location': 'princeton'}
h. 将函数存储在模块中：import pizza
from module_name import function_0, function_1, function_2 //导入特定的函数，多函数用逗号分隔。
from pizza import make_pizza as mp //导入函数名与现有名称冲突，可用as指定别名。也可以给模块指定别名：import pizza as p。
from pizza import * //导入模块中的所有函数。
八. 类
1. 创建和使用类
class Dog(): //首字母大写指的是类；
def __init__(self, name, age): //Python调用__init__() 来创建Dog 实例时，将自动传入实参self 。每个与类相关联的方法调用都自动传递实参self ，它是一个指向实例本身的引用，让实例能够访问类中的属性和方法。
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!")
python2.7中创建类：class Dog(object):
2. 使用类和实例
a. 给属性指定默认值
def __init__(self, make, model, year):
self.make = make
self.model = modelself.year = year
self.odometer_reading = 0 // 默认值
b. 修改属性的值
def update_odometer(self, mileage):
self.odometer_reading = mileage
3. 继承
a. 定义
class ElectricCar(Car): //父类car
def __init__(self, make, model, year):
super().__init__(make, model, year) //初始化父类的属性；
self.battery_size = 70
python2.7中的继承：
class ElectricCar(Car):
def __init__(self, make, model, year):super(ElectricCar, self).__init__(make, model, year)
b. 重新父类的方法：直接覆盖
c. 将实例用作属性
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()
4. 导入类
a. 导入单个类：
from car import Car //car是car.py，Car是类；
b. 从一个模块中导入多个类：
from car import Car,ElectricCar
c. 导入整个模块
import car
d. 导入模块中的所有类
from module_name import *
5. python 标准库
from collections import OrderedDict //OrderedDict 实例的行为几乎与字典相同，区别只在于记录了键—值对的添加顺序
九. 文件和异常
1. 从文件中读取数据
a. 读取整个文件
with open('pi_digits.txt') as file_object: //关键字with 在不再需要访问文件后将其关闭。文件在python_work中时。
也可以调用open() 和close() 来打开和关闭文件，但 这样做时，如果程序存在bug，导致close() 语句未执行，文件将不会关闭。
contents = file_object.read()
print(contents)
print(contents.rstrip()) //rstrip()删除多出来的空行；
b. 文件路径
with open('text_files/filename.txt') as file_object: //相对文件路径，文件在python_work中；win用反斜杠；
file_path = '/home/ehmatthes/other_files/text_files/filename.txt'
with open(file_path) as file_object: //也可以绝对路径；
c. 逐行读取
filename = 'pi_digits.txt'
with open(filename) as file_object:
for line in file_object:
print(line)
d. 创建一个包含文件各行内容的列表
filename = 'pi_digits.txt'
with open(filename) as file_object:lines = file_object.readlines()
for line in lines:
print(line.rstrip()) //为删除每行左边的空格，可用strip()；
2. 写入文件
a. 写入空文件
filename = 'programming.txt'
with open(filename, 'w') as file_object:
file_object.write("I love programming.")可指定读取模式 ('r' )、写入模式 ('w' )、附加模式 ('a' )或让你能够读取和写入文件的模式('r+' )；如果你要写入的文件不存在，函数open() 将自动创建它；然而，以写入('w' )模式打开文件时千万要小心，因为如果指定的文件已经存在，Python将在返回文件对象前清空该文件。
b. 写入多行 //需要加换行；file_object.write("I love programming.\n")
c. 附加到文件
with open(filename, 'a') as file_object:
file_object.write("I also love finding meaning in large datasets.\n")
3. 异常
Python使用被称为异常的特殊对象来管理程序执行期间发生的错误。每当发生让Python不知所措的错误时，它都会创建一个异常对象。如果你编写了处理该异常的代码，程序将继续运行;如果你未对异常进行处理，程序将停止，并显示一个traceback，其中包含有关异常的报告。try-except 代码块处理的；
a. 使用try-except代码块和else代码块
try:
answer = int(first_number) / int(second_number)
except ZeroDivisionError:
print("You can't divide by zero!")else:
print(answer)
b. 处理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)
c. 失败时一声不吭
except FileNotFoundError:
pass
else:
4.存储数据
模块json 让你能够将简单的Python数据结构转储到文件中，并在程序再次运行时加载该文件中的数据。你还可以使用json 在Python程序之间分享数据。
a. 使用json.dump()和json.load()保存和读取用户生成的数据
import json
numbers = [2, 3, 5, 7, 11, 13]
filename = 'numbers.json'
with open(filename, 'w') as f_obj:json.dump(numbers, f_obj) //参数：要存储的数据，用于存储数据的文件对象；
使用json.load()将这个列表读取到内存中：
with open(filename) as f_obj:
numbers=json.load(f_obj) //
print(numbers)
十. 测试代码
1. 单元测试和测试用例：Python标准库中的模块unittest 提供了代码测试工具；
要为函数编写测试用例，可先导入模块unittest 以及要测试的函数，再创建一个继承unittest.TestCase 的类，并编写一系列方法对函数行为的不同方面进行测试。
name_function.py文件：
def get_formatted_name(first, last):
"""Generate a neatly formatted full name."""full_name = first + ' ' + last
return full_name.title()names.py文件：
from name_function import get_formatted_name
print("Enter 'q' at any time to quit.")
while True:
first = input("\nPlease give me a first name: ")
if first == 'q':
break
last = input("Please give me a last name: ")if last == 'q':
break
formatted_name = get_formatted_name(first, last)
print("\tNeatly formatted name: " + formatted_name + '.')
测试例test_name_function.py
import unittest
from name_function import get_formatted_nameclass 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') //使用了unittest 类最有用的功能之一:一个断言 方法。断言方法用来核实得到的结果是否与期望的结果一致。
unittest.main() //代码行unittest.main() 让Python运行这个文件中的测试。
输出如下：（第一行句点表明又一个测试通过了，接下来的一行指出Python运行了一个测试，用时不到0.001秒。最后的OK 表明该测试用例中的所有单元测试都通过）
。
----------------------------------------------------------------------
Ran 1 test in 0.000s
OK