（一）基础知识

基础
类型
语句
函数、模块、包
类、对象、面向对象编程
文件操作 import pickle

Python

基础

运算顺序：先乘除再加减括号最优先
基础类型：
- 变量
- 数值
- 字符串
- 转义字符
- %s 占位

逻辑关系

== 等于
！ = 不等于
大于
= 大于等于
< 小于
<= 小于等于
and 与

or 或

类型

#coding:utf-8
#上面的编码，防止中文出错
a = 100  #a->变量 100->数值
b = "Hello World"  #"Hello World"->字符串
print ” point = %s \n \” %s \” ” % (a, b) # \n->转义字符（回车） %s->占位符

列表 [ ]
- 列表名 [索引号]：索引列表中的元素
```
#coding:utf-8
d=["张三","李四","王五"]
d[0] #d[0]->列表 d 中的第0个元素 “张三”
```
- 用列表名[起:止]：切片，从列表中切出相应的元素前闭后开

#coding:utf-8
c = [1,2,3,4,5,6,7]
c[0:2] # 列表c中从第0个元素切到第1（2-1）个元素：切出 [1,2]
c[:] # 切出全部

用列表名[起:止:步长]：带步长的切片，步长有方向

#coding:utf-8
c = [1,2,3,4,5,6,7]
c[4:0:-1] # 列表c中从第4个元素开始，反向步长为1（-1），切到第1（0--1）个元素：切出 [5,4,3,2]
c[4::-1] # 列表c中从第4个元素开始，反向步长为1（-1），切到最后：切出[5,4,3,2,1]
c[-2::-2] # 列表c中从倒数第2个元素开始，反向步长为2（-2），切到最后：切出[6,4,2]

操作
- 修改：列表名 [索引号]=新值
- 删除：del 列表名 [索引号]
- 插入：列表名.insert（插入位置索引号，新元素）
```
#coding:utf-8
c = [1,2,3,4,5,6,7]
c[3]=8 # c=[1,2,3,8,5,6,7]
c.insert(3,38) # c=[1,2,3,38,8,5,6,7]
del c[3] # c=[1,2,3,8,5,6,7]
```

元组( )
```
#coding:utf-8
f = (1,2,3)
```

字典{ }

字典名[键]：索引字典中的值

操作

修改：字典名[键]=新值
删除：del 字典名[键]

插入：字典名[新键] = 新值

#coding:utf-8
dic={1:"123","name":"zhangsan","height":180}
dic["name"] # 输出zhangsan
deL dic["name"] # dic={1:"123","height":180}
dic["name"] = "lisi" # dic={1:"123","name":"lisi","height":180}

语句

条件语句

#coding:utf-8
age = input("请输入你的年龄\n")
if age > 18:
  print "大于十八岁"
elif age == 18:
  print "今年十八了"
else：
  print "还未成年"

语句层次：四个空格缩进

循环语句

for 变量 in range(开始值，结束值)

#coding:utf-8
for i in range(0:5):
print "Hello World %s" %i  # 打出4次

for 变量 in 列表名

#coding:utf-8
h = ["a","b","c","d"]
for i in h:
print i
for j in h :
   print j
#aabcdbabcdcabcddabcd

while 条件

#coding:utf-8
x = 1
y = 2
while x < 5 and y < 5:
x = x + 1
y = y + 1
print x,y
#2 3,3 4, 4 5

break：终止循环

函数、模块、包

函数
- def 函数名(参数表)：定义函数
- 函数名(参数)：使用函数
- return：函数返回值
```
#coding:utf-8
def add(a,b):
return a + b
c = add(5,6)
c #11
```
模块

模块（module）：是一个 Python 文件，以 .py 结尾，包含了Python函数等语句。先导入，再使用，用模块.函数名调用。

#coding:utf-8
import time
time.asctime() # 输出当前时间

包：包含多个模块

#coding:utf-8
from PIL import Image

类、对象、面向对象编程

类、对象：对象是类的实例。类是可实例化出对象的模具。对象实实在在存在，完成具体工作。
面向对象：程序员反复修改优化类，类实例化出对象，对象调用类里的函数执行具体的操作。
pass：作为函数体占位
有父类，写(父类)；没有父类，可不写或( )
self：类里定义函数，语法规定的第一个参数
init：在新对象实例化时会自动运行，用于给新对象赋初值
对象.函数名()/变量名：对象调用类里的函数/变量
self.函数名()/变量名：类内定义函数时，如调用自身或父类的函数/变量

访问控制

_foo：protected 类型变量，只能允许其本身与子类进行访问，不能用于 from module import *
__foo：private 类型变量，只能是允许这个类本身进行访问

foo：特列方法，类似__init()之类的

#coding:utf-8
class Animals:  # 无父类，可以不写（）
# pass # 占位
def breathe(self):
   print "breathing"
def move(self):
   print "moving"
def eat(self):
   print "eating food"
class Mammals(Animals): #有父类，写（父类）
def breastfeed(self):  # 首个参数self
   print "feeding young"
class Cats(Mammals):
def __init__(self,spots): # 实例化时，赋初值
   self.spots = spots #self.变量名，调用自身变量定义
def catch_mouse(self):
   print "catch mouse"
def left_foot_forward(self):
   print "left foot forward"
def left_foot_backward(self):
   print "left foot backward"
def dance(self):
   self.left_foot_forward()
   self.left_foot_backward()
   self.left_foot_forward()
   self.left_foot_backward()
kitty = Cats(10) # 实例化类Cat为对象kitty
print kitty.spots # 对象.变量，调用对象变量
kitty.dance() # 对象.函数()，调用相对应的函数
kitty.breastfeed()
kitty.move()

文件操作 import pickle

写

开：文件变量 = open(“文件路径文件名,”wb”)
存： pickle.dump(待写入变量,文件变量)

关：文件变量 .close()

#coding:utf-8
import pickle
game_data={"position":"N2 E3","pocket":["key","knife"],"money":160} # 待写入变量
save_file=open("save.dat","wb") # 开
pickle.dump(game_data,save_file) # 存
save_file.close() # 关

读

开：文件变量 = open(“文件路径文件名”,”rb”)
取：放内容的变量 = pickle.load(文件变量)

关：文件变量 .close()

#coding:utf-8
import pickle
load_file=open("save.dat","rb") # 开
load_game_data=pickle.load(load_file) # 取，赋值给变量
load_file.close() #先关，然后再对变量做处理
load_game_data

基础

类型

语句

函数、模块、包

类、对象、面向对象编程

文件操作 import pickle