Python学习笔记

hyhVersion="1.0"

2.3.1使用方法修改字符串的大小写
name = "ada lovelace" 
print(name.title())
title()以首字母大写的方式显示每个单词
name.upper()
name.lower()


2.3.2合并（拼接）字符串
Python使用加号（+）来合并字符串
2.3.3使用制表符或换行符来添加空白
字符串中添加制表符，可使用字符组合\t
添加换行符，可使用字符组合\n
2.3.4删除空白
要确保字符串末尾没有空白，可使用方法rstrip()。
左删除lstrip()和两边删除strip()
2.4.3使用函数str()避免类型错误
age = 23 
message = "Happy " + str(age) + "rd Birthday!" 
在Python 2中，除法中，务必确保至少有一个操作数为浮点数


motorcycles = ['honda', 'yamaha', 'suzuki'] 
3.1.1访问列表元素
通过将索引指定为-1，可让Python返回最后一个列表元素：motorcycles[-1]
3.2.2在列表中添加元素   列表末尾append 


motorcycles.append('ducati') 
使用方法insert()可在列表的任何位置添加新元素
motorcycles.insert(1, 'ducati') 
3.2.3从列表中删除元素 del+..
1. 使用del语句删除元素
del motorcycles[2] 
2. 使用方法pop()删除元素 .pop() 
方法pop()可删除列表末尾的元素，并让你能够接着使用它
popped_motorcycle = motorcycles.pop() 
print(motorcycles) #['honda', 'yamaha']
print(popped_motorcycle) #suzuki
3. 弹出列表中任何位置处的元素 .pop(0) 
first_owned = motorcycles.pop(0) 
4. 根据值删除元素 remove
motorcycles.remove('ducati')


3.3.1 使用方法 sort()对列表进行永久性排序
反序 cars.sort(reverse=True)
3.3.2 使用函数 sorted()对列表进行临时排序
print(sorted(cars))
临时反序 也可向函数sorted()传递参数reverse=True。
3.3.3 倒着打印列表
cars.reverse()
3.3.4 确定列表的长度len(cars)

4.1 遍历整个列表 for ... in ... :
for magician in magicians:
在for循环后面，没有缩进的代码都只执行一次，而不会重复执行。

4.3 创建数值列表
4.3.1 使用函数 range()
for value in range(1,5):
print(value)
4.3.2 使用 range()创建数字列表  使用函数list()将range()的结果直接转换为列表
numbers = list(range(1,6))
两个星号（**）表示乘方运算


4.3.3 对数字列表执行简单的统计计算
digits = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
min(digits) max(digits) sum(digits)
4.3.4 列表解析
squares = [value**2 for value in range(1,11)]

4.4使用列表的一部分
4.4.1切片
指定索引0~3，这将输出分别为0、1和2的元素。
指定1-3  print(players[1:4])
始于开头print(players[:4])
终于最后print(players[2:]) 
最后三名队员print(players[-3:])
4.4.2遍历切片
for player in players[:3]: 
print(player.title())
4.4.3复制列表
friend_foods = my_foods[:] 
不用切片时，直接赋值，则将类似C里面的索引或指针。。


4.5元组
4.5.1定义元组   不可变的列表被称为元组
dimensions = (200, 50) 
4.5.2遍历元组中的所有值
4.5.3修改元组变量   重新定义整个元组


5.1if语句   分号不可漏
if car == 'bmw':
5.2.5检查多个条件
1. 使用and检查多个条件;2 使用or检查多个条件
5.2.6检查特定值是否包含在列表中
要判断特定的值是否已包含在列表中，可使用关键字in
5.2.7检查特定值是否不包含在列表中 Not in
5.3.3 if-elif-else结构
5.4 使用 if 语句处理列表
5.4.2 确定列表不是空的
requested_toppings = []
if requested_toppings:
....
5.5 设置 if 语句的格式


6.1 一个简单的字典
alien_0 = {'color': 'green', 'points': 5}
print(alien_0['color'])
print(alien_0['points'])
6.2 使用字典
字典是一系列键—值对
键—值对是两个相关联的值。指定键时， Python将返回与之相关联的值。键和值之间用冒号分隔，而键—值对之间用逗号分隔。
6.2.1 访问字典中的值
要获取与键相关联的值，可依次指定字典名和放在方括号内的键
6.2.2 添加键—值对
字典是一种动态结构，可随时在其中添加键—值对。要添加键—值对，可依次指定字典名、用方括号括起的键和相关联的值
Python不关心键—值对的添加顺序，而只关心键和值之间的关联关系。
6.2.3 先创建一个空字典
alien_0 = {}
alien_0['color'] = 'green'
alien_0['points'] = 5
6.2.4修改字典中的值
alien_0['color'] = 'yellow'  
6.2.5删除键—值对
使用del语句时，必须指定字典名和要删除的键。
del alien_0['color']
6.3遍历字典
Python不关心键—值对的存储顺序，而只跟踪键和值之间的关联关系。
6.3.1遍历所有的键—值对
for k, v in user_0.items():
6.3.2遍历字典中的所有键
for name in favorite_languages.keys(): #使用方法keys()可让代码更容易理解
print(name.title())
6.3.3按顺序遍历字典中的所有键 函数sorted()
for name in sorted(favorite_languages.keys()):
6.3.4遍历字典中的所有值
for language in sorted(favorite_languages.values()):
通过对包含重复元素的列表调用set()，可让Python找出列表中独一无二的元素，并使用这些元素来创建一个集合
for language in set(favorite_languages.values()): 
6.4.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)
6.4.2在字典中存储列表
pizza = { 
'crust': 'thick', 
'toppings': ['mushrooms', 'extra cheese'], 
} 


for topping in pizza['toppings']: 
print("\t" + topping) 
6.4.3在字典中存储字典
users = { 
'aeinstein': { 
'first': 'albert', 
'last': 'einstein', 
'location': 'princeton', 
}, 
'mcurie': { 
'first': 'marie', 
'last': 'curie', 
'location': 'paris', 
}, 
}


7.1 函数 input()的工作原理
函数int()字符转换数字
7.1.4 在 Python 2.7 中获取输入
函数raw_input()来提示用户输入
7.2.1 使用 while 循环
current_number = 1
while current_number <= 5:
print(current_number)
current_number += 1
7.2 while循环简介
current_number = 1 
while current_number <= 5: 
print(current_number) 
current_number += 1 #不能是++
7.2.4使用break退出循环
7.2.5在循环中使用continue
7.3.1在列表之间移动元素
7.3.2删除包含特定值的所有列表元素
pets =['dog', 'cat', 'dog', 'goldfish', 'cat', 'rabbit', 'cat'] 
while 'cat' in pets: 
pets.remove('cat') 
7.3.3使用用户输入来填充字典


8.1定义函数
def greet_user(username): 
"""显示简单的问候语"""
print("Hello, " + username.title() + "!") 
greet_user('jesse') 
8.2.2关键字实参 传递给函数的名称—值对
 以下一样
describe_pet(animal_type='hamster', pet_name='harry')
describe_pet(pet_name='harry',animal_type='hamster')
8.2.3默认值
def describe_pet(pet_name, animal_type='dog'):
print("My " + animal_type + "'s name is " + pet_name.title() + ".") 
describe_pet(pet_name='willie')
describe_pet(pet_name='harry', animal_type='hamster')
8.2.4等效的函数调用
8.3.1返回简单值return
8.3.2让实参变成可选的
8.3.3返回字典
def build_person(first_name, last_name):
person = {'first': first_name, 'last': last_name} 
return person 
musician = build_person('jimi', 'hendrix') 
8.4传递列表
8.4.1在函数中修改列表
8.4.2 禁止函数修改列表
调用时这样function_name(list_name[:])
8.5 传递任意数量的实参
def make_pizza(*toppings):
8.5.1结合使用位置实参和任意数量实参
让函数接受不同类型的实参，必须在函数定义中将接纳任意数量实参的形参放在最后。 Python先匹配位置实参和关键字实参，再将余下的实参都收集到最后一个形参中。
def make_pizza(size, *toppings): 
调用
make_pizza(16, 'pepperoni') 
make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')
8.5.2使用任意数量的关键字实参
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) 
8.6将函数存储在模块中  （引用其他文件）
import pizza 
pizza.make_pizza(16, 'pepperoni') 
pizza.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese') 
8.6.2导入特定的函数
from module_name import function_0, function_1, function_2
范例
from pizza import make_pizza
8.6.3使用as给函数指定别名  指定后，原函数不可访问
from pizza import make_pizza as mp 
8.6.4使用as给模块指定别名
import module_name as mn
8.6.5导入模块中的所有函数
from pizza import *


9.1创建和使用类
根据约定，在Python中，首字母大写的名称指的是类。
class Dog():
def __init__(self, name, age): 
self.name = name
self.age = age
self.color = "black"
def sit(self): 
print(self.name.title() + " is now sitting.")
def roll_over(self):
print(self.name.title() + " rolled over!") 
1. 方法__init__()  两个下划线
__init__()是一个特殊的方法，每当你根据Dog类创建新实例时，Python都会自动运行它


有前缀self。以self为前缀的变量都可供类中的所有方法使用，我们还可以通过类的任何实例来访问这些变量
可通过实例访问的变量称为属性


在Python 2.7中创建类时，需要做细微的修改——在括号内包含单词object：
class ClassName(object): 
9.1.2根据类创建实例
my_dog = Dog('willie', 6) 
print("My dog's name is " + my_dog.name.title() + ".") 
print("My dog is " + str(my_dog.age) + " years old.")
1. 访问属性  
my_dog.name
2. 调用方法
my_dog = Dog('willie', 6)
my_dog.sit() 
my_dog.roll_over() 
9.2使用类和实例
9.2.2给属性指定默认值
9.2.3修改属性的值
1. 直接修改属性的值
my_dog.color = "yellow"
2. 通过方法修改属性的值
def update_color(self,newcolor):
self.color = newcolor
my_dog.update_color("yellow")
3. 通过方法对属性的值进行递增
9.3继承
9.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): #让ElectricCar实例包含父类的所有属性
super().__init__(make, model, year) #父类也称为超类（superclass），名称super因此而得名。
my_tesla = ElectricCar('tesla', 'model s', 2016) 
print(my_tesla.get_descriptive_name()) 


Python 2.7 中的继承
class Car(object):
def __init__(self, make, model, year):
--snip--
class ElectricCar(Car):
def __init__(self, make, model, year):
super(ElectricCar, self).__init__(make, model, year)
--snip--
函数super()需要两个实参：子类名和对象self。
9.3.3 给子类定义属性和方法
9.3.4 重写父类的方法
对于父类的方法，只要它不符合子类模拟的实物的行为，都可对其进行重写。
9.3.5 将实例用作属性
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
def fill_gas_tank(self):
#电动汽车没有油箱
print("This car need a gas tank!###")
class ElectricCar(Car): #定义子类时，必须在括号内指定父类的名称
def __init__(self, make, model, year): #让ElectricCar实例包含父类的所有属性
super().__init__(make, model, year) #父类也称为超类（superclass），名称super因此而得名。
self.battery_size = 70
def describe_battery(self):
print("This car has a " + str(self.battery_size) + "-kWh battery.")
def fill_gas_tank(self):
#电动汽车没有油箱
print("This car doesn't need a gas tank!")
my_car = Car('bentian','model L',2018)
print(my_car.get_descriptive_name()) 
my_car.fill_gas_tank()


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


my_tesla.describe_battery()
my_tesla.fill_gas_tank()


9.3.6 模拟实物
9.4.1 导入单个类 from car import Car 
9.4.2在一个模块中存储多个类 
9.4.3从一个模块中导入多个类 from car import Car, ElectricCar
用逗号分隔了各个类
9.4.4导入整个模块
9.4.5导入模块中的所有类 from module_nameimport * （不推荐使用这种导入方式）
9.4.6在一个模块中导入另一个模块
9.4.7自定义工作流程
9.5  Python标准库
9.6类编码风格
类名应采用驼峰命名法，即将类名中的每个单词的首字母都大写，而不使用下划线。
实例名和模块名都采用小写格式，并在单词之间加上下划线。


10.1从文件中读取数据
10.1.1读取整个文件
with open('pi_digits.txt') as file_object: 
contents = file_object.read() 
print(contents) 


with open('include/a.c','r',encoding='UTF-8') as file_object: 
在Windows系统中，在文件路径中使用反斜杠（\）而不是斜杠（/）：
在Linux和OS X中
file_path = '/home/ehmatthes/other_files/text_files/filename.txt' 
with open(file_path) as file_object: 
在Windows系统中
file_path = 'C:\Users\ehmatthes\other_files\text_files\filename.txt' 
with open(file_path) as file_object: 
10.1.3逐行读取
for line in file_object: 
print(line.rstrip()) 
10.1.4创建一个包含文件各行内容的列表
with open(filename) as file_object: 
lines = file_object.readlines() 
10.1.5使用文件的内容
读取文本文件时，Python将其中的所有文本都解读为字符串
如果你读取的是数字，并要将其作为数值使用，就必须使用函数int()将其转换为整数
10.1.6包含一百万位的大型文件
print(pi_string[:52] + "...")
#if birthday in pi_string:


10.2.1写入空文件
filename = 'programming.txt'
with open(filename, 'w') as file_object: 
file_object.write("I love programming.") 


可指定读取模式（'r'）、写入模式（'w'）、附加模式（'a'）
或让你能够读取和写入文件的模式（'r+'）
10.3.1处理ZeroDivisionError异常
如果try-except代码块后面还有其他代码，程序将接着运行，因为已经告诉了Python如何处理这种错误。
try: 
print(5/0) 
except ZeroDivisionError: 
print("You can't divide by zero!")
10.3.3使用异常避免崩溃
10.3.4 else代码块
print("Give me two numbers, and I'll divide them.") 
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)
10.3.5 处理 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)
10.3.6 分析文本
字符串调用方法split()的结果
words = contents.split()
num_words = len(words)
10.3.7 使用多个文件
10.4.1 使用 json.dump()和 json.load()
函数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)
====
import json 
filename = 'numbers.json' 
with open(filename) as f_obj: 
numbers = json.load(f_obj) 
print(numbers)


10.4.2保存和读取用户生成的数据
import json 
username = input("What is your name? ")


filename = 'username.json'
with open(filename, 'w') as f_obj: 
json.dump(username, f_obj)
print("We'll remember you when you come back, " + username + "!")
======
import json 


filename = 'username.json'


with open(filename) as f_obj: 
username = json.load(f_obj) 
print("Welcome back, " + username + "!") 
======
filename = 'username.json' 
try: 
with open(filename) as f_obj: 
username = json.load(f_obj) 
except FileNotFoundError: 
username = input("What is your name? ") 


with open(filename, 'w') as f_obj: 
json.dump(username, f_obj) 
print("We'll remember you when you come back, " + username + "!") 
else: 
print("Welcome back, " + username + "!") 
========
10.4.3重构


def get_stored_username(): 
"""如果存储了用户名，就获取它"""
filename = 'username.json'
try: 
with open(filename) as f_obj: 
username = json.load(f_obj) 
except FileNotFoundError: 
return None
else: 
return username


def get_new_username(): 
"""提示用户输入用户名""" 
username = input("What is your name? ") 
filename = 'username.json' 
with open(filename, 'w') as f_obj: 
json.dump(username, f_obj) 
return username


def greet_user(): 
username = get_stored_username() 
if username: 
print("Welcome back, " + username + "!") 
else:
username = get_new_username()
print("We'll remember you when you come back, " + username + "!") 

greet_user()

======

11.1.1单元测试和测试用例
11.1.2可通过的测试self.assertEqual
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') 
unittest.main() 

11.2.2一个要测试的类
survey.py 
# -*- coding: UTF-8 -*- 
class AnonymousSurvey(): 
    """收集匿名调查问卷的答案""" 
    def __init__(self, question): 
        """存储一个问题，并为存储答案做准备""" 
        self.question = question 
        self.responses = [] 
    def show_question(self):
        """显示调查问卷  此处书上有错"""
        print(self.question)
    def store_response(self, new_response): 
        """存储单份调查答卷""" 
        self.responses.append(new_response) 
    def show_results(self): 
        """显示收集到的所有答卷  此处书上有错""" 
        print("Survey results:") 
        for response in self.responses: 
            print('- ' + response) 
===
language_survey.py
# -*- coding: UTF-8 -*-
from survey import AnonymousSurvey

#定义一个问题，并创建一个表示调查的AnonymousSurvey对象
question = "What language did you first learn to speak?"
my_survey = AnonymousSurvey(question)
#显示问题并存储答案
my_survey.show_question() 

print("Enter 'q' at any time to quit.\n") 
while True: 
    response = input("Language: ") 
    if response == 'q':
        break 
    my_survey.store_response(response)
# 显示调查结果
print("\nThank you to everyone who participated in the survey!") 
my_survey.show_results() 

11.2.3测试AnonymousSurvey类  self.assertIn('English', my_survey.responses) 

# -*- coding: UTF-8 -*-

import unittest 
from survey import AnonymousSurvey 
class TestAnonmyousSurvey(unittest.TestCase):
    """针对AnonymousSurvey类的测试""" 
    def test_store_single_response(self): 
        """测试单个答案会被妥善地存储""" 
        question = "What language did you first learn to speak?" 
        my_survey = AnonymousSurvey(question) 
        my_survey.store_response('English') 
        self.assertIn('English', my_survey.responses) 
unittest.main()
=====生成器===
yield：返回列表

decorator

11.2.4方法setUp()

项目1 外星人入侵
武装飞船