1、.title() 每个单词首字母大写
.upper() 所有字母大写
.lower() 所有字母小写
2、 \t 空白 转义字符只能用在""内
\n 换行
3、.rstrip() 删除末尾空白
.lstrip() 删除开头空白
.strip() 删除两端空白
4、Python将带小数点的数都称为浮点数
5、Python的字符串既可以用单引号也可以用双引号 引号内部还有单引号时，只能用""
str() 可以将非字符串值表示为字符串 //将23转为'23',而不能将abc转为'abc'
Python 用+来合并字符串 "wanyu" + " " + "shuai"
创建多行字符串可以用+=运算符
prompt = "\nTell me something, and I will repeat it back to you:"
prompt += "\nEnter 'quit' to end the program. "
6、单行注释 #
多行注释 """ """ 或者 ''' '''
7、[ ] 表示列表 ,分隔其中元素
访问元素 正数 [ ]里从0开始 print(bike[0])
倒数 -1 print(bike[-1])
修改元素 指定列表名和元素索引并指定新值 bike[0]='abc'
添加元素 .append() 在末尾添加元素(可创建空列表然后用一系列.append()语句来添加) bike.append('bcd')
.insert( , ) 插入元素，需指定新元素的索引与值 bike.insert(0,'cde')
删除元素 del 列表名[] 删除已知位置的列表元素 del bike[0]
列表名.pop() 删除索引位置并且能够再次被调用 即弹出效果 bike.pop(2)
del和pop()使用后，列表里对应元素均被删除，但是pop()可以继续调用 根据删除后是否还需使用元素选取del和pop
列表名.remove() 删除已知元素值 bike.remove('abc')
8、列表排序（注意有的方法，有的是函数）
.sort() 永久性按字母顺序排序 bike.sort()
.sort(reverse=true) 永久性按字母倒序排序 bike.sort(reverse=true)
sorted(列表名) 临时性按字母顺序显示 print(sorted(bike))
sorted(列表名,reverse=True)) 临时性按字母倒序显示 print(sorted(bike,reverse=True))
.reverse() 永久性按列表倒序排序 bike.reverse()
9、len(列表名) 获得列表长度
10、for 变量 in 列表： for循环，且for循环后的每一句代码，没有缩进的只执行一次，缩进的重复执行 注意‘:’和缩进
magicians = ['alice', 'david', 'carolina']
for magician in magicians:
print(magician.title() + ", that was a great trick!")
print("I can't wait to see your next trick, " + magician.title() + ".\n") print("Thank you everyone, that was a great magic show!")
11、创建数值列表
第一步：创建了从x到y-1的数，步长为z range(x,y,z): range(1,5,1):
第二步：创建了从x到y-1的列表，步长为z 列表名=list(range(x,y,z)) message=list(range(1,5,1))
列表解析：将for循环和创建新元素的代码合并，并自动添加附加新元素 squares=[value**2 for value in range(1,11)]
12、+ - * / 加减乘除
% 求模 除2取余可以用来判断奇偶数
** 表示乘方运算
13、min(列表名) 最小值
max(列表名) 最大值
sum(列表名) 求和
14、变量名只包含字母、数字、下划线，但不能以数字打头，不能包含空格、Python关键字和函数名
15、切片：列表名[x:y] 列表里第x+1到第y个元素
x未写则表示从头开始，y未写则表示到尾结束
x、y都未写则可用于列表的复制 friends_foods=my_foods[:] 如果只是简单的把一个列表赋给一个变量，就不能得到两个列表
x若为负数，则为返回列表的后x位
遍历切片只需在切片里用for循环 for player in players[0:3]；
16、()表示元组 即不可变的列表，逗号隔开元素,访问元素与列表相同
遍历元组则用for循环 for bike in bikes:
元组的元素不可以被修改，但是整个元组可以被重新赋值 bikes=(200,100) bikes=(50,100)
17、代码格式PEP8 https://www.python.org/dev/peps/pep-0008/
缩进每次用4个空格
利用空行让代码看上去整洁
==、>=、<= 两边各添加一个空格
包含多个函数时，建议每个函数之间空2行
18、if条件语句 ①if + 条件:
else:
②if + 条件:
elif + 条件:
else:
注意（1）冒号：不能丢
（2）if、else后面的语句换行写时要缩进
（3）elif可以有多句，else可以没有
（4）当需要执行多个代码块，也可以用多个if语句
requested_toppings = ['mushrooms', 'french fries', 'extra cheese']
if 'mushrooms' in requested_toppings:
print() #省略没写
elif 'french fries' in requested_toppings:
print()
elif 'extra cheese' in requested_toppings:
print()
第一个mushrooms检测通过了，程序将跳过下面的elif结构，不再检查其他内容，所以if-elif-else结构仅适用于只有一个条件满足的情况
而想要检测多个条件满足的情况应该用多个if语句
requested_toppings = ['mushrooms', 'french fries', 'extra cheese']
if 'mushrooms' in requested_toppings:
print() #省略没写
if 'french fries' in requested_toppings:
print()
if 'extra cheese' in requested_toppings:
print()
19、= 赋值
== 等于 检查字符是否相等时，会区分大小写，若要不区分的话，可使用.lower()
!= 不等于
and 与
or 或
in 包含在列表中
not in 未包含在列表中
>>>bikes=['a','b','c']
>>>'a' in bikes
>>>True
if + 列表名： 如果列表不为空，则会返回True;如果列表为空，返回值为False
20、布尔表达式 True / False
21、字典是放在{}里的一系列键值对，键需要加''而值不一定 键值之间用:隔开 键值对之间用,隔开
字典名={'键':值} alien_0={'color':'gerrn','points':5}
访问字典值 可依次指定字典名和放在[]的键 即 字典名['键'] print(alien_0['color'])
添加键值对 依次指定字典名、[]括起来的键和关联的值 即 字典名['键']=值
Python不关心键值对的顺序，只关心键和值的对应关系
alien_0['x_position']=0
alien_0['y_position']=25
很多时候是先建立一个空字典，再分别添加键值对 字典名={}
修改字典值 指定字典名、[]括起来的键和关联的新值 即 字典名['键']=新值 alien_0['color']='yellow'
删除键值对 del 字典名['键'] del alien_0['color']
较长的列表和字典，可以将键值对放在不同的行里，注意行前缩进
alien_0={
'color':'gerrn',
'points':5,
'head':'big',
'phil':'python'}
遍历字典中键值对 for 变量名1,变量名2 in 字典名.items()： for循环将每个键值对存储到指定的变量中,变量1为键，变量2为值
for key,value in user_0.items():
print("\nKey: " + key)
print("Value: " + value)
遍历字典中键 for 变量名 in 字典名.keys() for name in user_0.keys():
.keys()方法实质上是返回一个列表，包含字典的所有键，因此其还可以用于判断某值是否在字典的键里
if 'erin' not in alien_0.keys():
print()
按顺序获取返回元素可在for里调用sorted()函数 for key in sorted(alien_0.keys()):
遍历字典中值 for 变量名 in 字典名.values() for name in user_0.values():
如需去掉重复值，则在for里调用set函数 for name in set(user_0.values()):
关于键值重复的问题，键从逻辑上讲是不能重复的，但重复了不会报错，只会认为是对键重新赋值，值可以重复
22、print打印的内容较长时，也可以将内容分行写以获得整洁的代码界面
23、在列表里存储字典 将多个字典放入列表中 aliens=[alien_0,alien_1,alien_2]
在字典里存储列表 即 键 对应的 值 可以为列表
pizza = {
'crust': 'thick',
'toppings': ['mushrooms', 'extra cheese'],
}
在字典里存储字典 即键对应的值可以为字典
users = {'aeinstein': {'first': 'albert',
'last': 'einstein',
'location': 'princeton'},
'mcurie': {'first': 'marie',
'last': 'curie',
'location': 'paris'},
24、 input()函数用来等待用户输入，括号里可以为字符串变量也可以为字符串。其返回的值永远是用户输入的字符串
input("\nTell me something, and I will repeat it back to you: ")
int()函数可以将input的字符串转为数值，以达到相应的要求
age=input("How old are you ?")
year=int(age)
25、用好标志（True,False）可以简化判断、循环语句
26、while循环：while 语句 :
break终止整个循环，continue退出当前循环，返回到循环开头
注意避免无限循环，可以用ctrl+c退出
27、while 列表: 或 while 变量 in 列表: 对列表的循环
while unconfirmed_users:
current_user = unconfirmed_users.pop()
while 'cat' in pets:
pets.remove('cat')
28、def 函数名(参数): 函数的语句要缩进
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('harry', 'hamster')
关键字实参 describe_pet(animal_type='hamster', pet_name='harry') 关键字实参即指定实参的形参类型，所以就无需区分位置
编写函数时，还可以给某一形参给定默认值，在调用函数时，就无需再指定此形参的实参，函数会使用默认值。
注意：在编写函数时，形参列表中必须先列出没有默认值的形参，再列出有默认值的形参。
在指定默认值时，等号两边不要有空格，调用时也是如此，当然如果不适用默认值，那么就可以重新传递新的实参
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('harry', 'hamster') #不使用默认值，传递位置实参
describe_pet(pet_name='harry', animal_type='hamster') #不使用默认值，传递关键字实参
describe_pet(animal_type='hamster', pet_name='harry') #不使用默认值，传递关键字实参
有时候需要将函数的实参变成可选的，因为函数的参数并不是所有情况下都需要，这时可以将那个不一定需要的形参设为空，即''，再来个判断语句
def get_formatted_name(first_name,last_name,middle_name='')
if middle_name:
print()
else:
print()
函数形参过多时，导致代码长度超出80，不符合PEP8，可将 形参都放到下一行，甚至下几行，要注意缩进(2个tab)
def fuction_name(
a,b,c,
d,e.f):
fuction body...
函数的返回值可以任何类型的值 结构为 return 返回内容
返回简单值 return full_name.title()
返回字典
def build_person(first_name, last_name, age=''):
person = {'first': first_name, 'last': last_name}
return person
函数的参数也可以是一个列表，即传递列表
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[:]) 这样就可以保留原始列表的内容
除非有充分理由使用副本，否则少使用，提高效率。函数使用现成列表可以避免浪费时间和内存创建副本，尤其处理大型列表时
函数传递任意数量的实参，可将函数的形参设为 *名称 def pizza(*pizzas)：
这样就创建了一个名为pizzas的空元组，函数能将所有收到的实参都放进这个元组里
想让函数接受不同类型的实参时，必须将任意数量实参放到最后，Python将先匹配位置实参和关键字实参，余下的实参将收集到最后一个形参中去
def make_pizza(size,*toppings)
print()
make_pizza(16,'mushrooms','cheese')
使用任意数量的关键字实参，可传递给函数键值对，将形参设为**名称，再利用for循环
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
29、导入模块，在当前.py的目录中再创建一个.py的文件，里面可以放函数，然后在当前py里导入这个模块,语句为import 所有的import语句放在开头
再调用函数时，其前面还需要加上模块名，即 模块名.函数名
比如 pizza.py文件里定义了一个函数 def do_pizza(size, *toppings): （内容此处省略）
则在pizza.py文件的目录里的另一个文件make_pizza里可以导入模块
import pizza
pizza.do_pizza()
也可以导入指定模块的指定函数,格式为 from module_name import function_0,function_1
使用*可以导入模块中的所有函数 from module_name import *
这样在调用模块中的函数时就无需写模块.函数，直接调用函数名，但一般不推荐使用，因为如果不是自己写的模块，可能会有很多函数重名
as可以给指定模块和函数起别名，就可以用别名来调用函数和模块
from module_name import function_name as fn
import module_name as mn
30、类
创建类 class 名称(): class Dog(): 注意：名称的首字母要大写
类里可以定义不同的方法 def 方法名称():
第一个定义的方法一般是_init_() 当我们使用类时，Python会自动运行它，注意其名称，且其形参第一个为self，之后为其他信息
且用句点表示法获取值
def __init__(self, name, age):
self.name = name
self.age = age
之后可以定义其他的方法，如果不需要其他的信息，方法的形参只有一个self
def sit(self):
print(self.name.title() + " is now sitting.")
def roll_over(self):
print(self.name.title() + " rolled over!")
根据类创建实例,Python将使用实参调用类中的方法_init_()创建表示特定的实例，并自动返回给一个变量，这个变量可以自己设置
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.")
还可以调用类中定义的方法，仍然为句点表示法
my_dog = Dog('willie', 6)
my_dog.sit()
当需要给某个属性添加默认值时，就无需包含为它提供初始值的形参
class Car():
def __init__(self, manufacturer, model, year):
self.manufacturer = manufacturer
self.model = model
self.year = year
self.odometer_reading = 0 #此值设为默认值，所以在设置形参时没有设置这个量
有时候需要修改属性的值，有三种方法
（1）直接修改属性的值，通过实例直接访问（基于上面定义过的方法举例）
my_new_car=Car('audi','',2016)
my_new_car.odometer_reading=23 #这样就直接修改了默认值0
（2）通过方法修改属性的值 即定义一个修改属性的方法
def update_odometer(self,mileage):
self.odometer_reading = mileage
my_new_car.update_odometer(23) #也修改了默认值0
（3）通过方法对属性的值进行递增/递减
def increment_odometer(self,miles)
self.odometer_reading += miles
my_new_car.increment_odometer(100) #通过+=改变了属性值
继承
编写一个类的时候可以继承另一个类，原先的类称为父类，新的类称为子类。子类可以自动获得父类的全部属性和方法，同时还可以定义自己的属性和方法
创建子类时，父类必须在此文件中，且必须在子类的前面 格式为 class 子类名(父类名):
class Car(): #省略了父类的内容
class ElectricCar(Car)：
子类需要写继承父类属性的语句（举例接着上面的内容） 即调用super()函数
class Car(): #省略了父类的内容
class ElectricCar(Car)：
def __init__(self, manufacturer, model, year): #初始化父类的属性
super().__init__(manufacturer, model, year) #此行代码调用父类的方法_init_()
super()函数调用之后，可添加新属性和新方法
class Car(): #省略了父类的内容
class ElectricCar(Car)：
def __init__(self, manufacturer, model, year): #初始化父类的属性
super().__init__(manufacturer, model, year) #此行代码调用父类的方法_init_()
self.battery_size = 70 #添加了子类的新属性
def describe_battery(self): #添加了新方法
print()
父类的方法没有任何用处时，你可以重写它。语句就是普通的定义
class ElectricCar(Car)：
def fill_gas_tank(): #重新定义父类的方法
print()
可以定义一个新的类，作为另一个类的一个属性
class Battery():
def __init__(self, battery_size=60):
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, manufacturer, model, year):
super().__init__(manufacturer, model, year)
self.battery = Battery() #属性是一个类
my_tesla = ElectricCar('tesla','model s',2016)
my_tesla.battery.describe_battery() #调用实例的battery属性里的方法
导入类，将一个类写在一个.py文件里，在另一个.py文件里导入这个类 格式为 from 模块名 import 类名
举例 Car类在car.py里，则在my_car.py里导入Car可写为 from car import Car
可以导入一个模块的多个类 from 模块名 import 类名1,类名2 在调用类时，直接建立实例就可以，不需要其他格式
当然也可以导入整个模块，格式为 import 模块名
但是在建立实例时，就需要用点号表达式 my_beetle = car.Car()
编写类时，应该写好注释
类中，用一个空行分隔方法
模块中，用两个空行分隔类
导入模块时，先写导入标准库的语句，再写导入自己编写的模块的语句
31、文件
读取文件 with open('路径') as 变量:
with open('pi_digits.txt') as file_object: #关键字with在不再需要访问文件后将文件关闭
contents = file_object.read() #方法.read()读取文件的全部内容
print(contents)
上例open()函数里只有文件名，是因为其和.py文件在相同目录。()里也可以放文件的绝对路径
但绝对路径在windows系统里，是用\隔开，例如D:\code_work\Python\pi_digits.txt
过长的路径影响美观，所以可以将其放在一个变量里
file_path = 'D:\code_work\Python\pi_digits.txt' #注意一定是字符串
with open(file_path) as file_project:
逐行读取文件只需使用for循环将每一行的内容放到变量中即可
for line in file_object: #每一行的内容就放到了line中
使用关键字with时，open()返回的文件对象只能在with代码块中使用，要想在代码块外访问文件内容，可将文件的各行存储在一个列表里，并在代码块外使用该列表
with open('pi_digits.txt') as file_object:
lines = file_object.readlines() #用方法readlines()将每一行的内容放到了lines列表中
for line in lines:
print()
读取文本文件时，Python 将其中所有内容都解读为字符串，如果要作为数值使用，就必须用int()或者float()转换
写入文件格式为 with open(文件,‘w’) as 变量: 'r' 读取模式 'w'写入模式 'a'附加模式 'r+' 读取和写入模式 若省略模式参数，则默认为读取模式
如果写入的文件不存在，Python将自动创建它。如果写入的文件存在，那么将在返回对象前清空文件
写入的语句用放方法.write()
file_path = 'D:\code_work\Python\pi_digits.txt'
with open(file_path,'w') as file_object:
file_object.write('I lOVE YOU') #如果要写入多行语句，则需要添加换行符号
'w'写入模式将原文件内容清空，写入新的语句，如果不想清空原文件，则可以使用'a'附加模式，写入的内容将会被添加到文件末尾
with open('programming.txt', 'a') as file_object:
file_object.write("I also love finding meaning in large datasets.\n")
32、异常
当发生错误时，如果编写了处理问题的代码，程序将继续运行，如果没有，程序将会停止，且会返回一个traceback
处理问题的代码块为 try-except
print(5/0) 将会返回一个traceback，里面的ZeroDivisionError则是一个异常对象，那么就要对异常进行处理
try:
print(5/0)
except ZeroDivisionError:
print("you can't divide by zero !")
找不到文件的异常对象为FileNotFoundError
filename = 'alice.txt'try:
with open(filename) as f_obj:
contents = f_obj.read()
except FileNotFoundError as e:
msg = "Sorry, the file " + filename + " does not exist."
print(msg)
try-except-else 代码块，适用于包含正常情况发生的代码
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)
可以将try-except-else结构写为函数，多处使用
如果希望程序在碰到异常对象时一声不吭，则可以在except的语句里写pass，当这种错误发生的时候，既没有traceback，也没有任何输出
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:
pass
else:
print(answer)
34、模块json能将简单的Python数据结构转储到文件中，并在程序再次运行时加载文件中的数据
json模块里有json.dump()函数，接受两个实参，要存储的数据和可用于存储数据的文件对象 dump：转储
import json #导入json模块
numbers = [2, 3, 5, 7, 11, 13] #创建一个数字列表
filename = 'numbers.json' #指定所存储的文件名称
with open(filename, 'w') as file_object: #以写入模式打开文件，让json能够将数据写入其中
json.dump(numbers, file_object) #使用json.dump()函数将数字列表存储到文件中
json模块里有json.load()函数，能够加载文件中的数据
import json #导入模块
filename = 'numbers.json' #之前写入的文件
with open(filename) as file_object: #读取模式打开文件
numbers = json.load(file_object) #使用ison.load()加载存储在文件里的信息，并将其存储到变量numbers中
print(numbers)
使用json保存用户的数据很方便，便于储存和记忆
import json def get_stored_username():
"""Get stored username if available."""
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():
"""Prompt for a 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():
"""Greet the user by name."""
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()
35、重构：将代码分为一系列完成具体工作的函数，使得代码更清晰、更易于理解、更容易扩展
36、测试代码
欢迎阅读，有任何错误可以指出，感谢