Python

变量和简单数据类型

变量

x = xxx

字符串

用双引号或单引号括起
a = '"xxx"xxx'/"xx'xxx'"
字符串处理函数，一般不改变原始字符串，而是将修改后字符串作为结果返回
a.title()/upper()/lower()/rstrip()［返回去除字符串末尾的空白后的字符串，原字符串未改变］/lstrip()［返回去除字符串开头的空白的字符串，原字符串未改变］/strip() 去除首尾空白
通过相加拼接

数字

+
-
*
/
** 乘方
?=
str(arg) 将参数变换为对应字符串，作为结果返回

＃用作行注释

列表

x = [1, 2, 3]
print(x) # [1, 2, 3]
print(x[0]) # 1
print(x[-1]) # 3			用索引-1表示列表最后一个元素，索引-n访问列表倒数第ｎ个元素
列表方法
.append(..) ＃ 在列表尾部添加元素
.insert(..)
.pop() # 删除列表末尾元素，将其作为返回值返回
.pop(i) # 删除列表ｉ位置元素，将其作为返回值返回
.remove(value) # 删除列表中值为value的元素，只删除首个遇到的元素
.sort() # 对列表排序
.sort(reverse=True) # 递减排序
.sorted() # 排序后列表作为结果返回，原始列表不变
.reverse() # 改变列表存储次序
列表删除
del x[i] # 删除列表ｉ位置元素
len(x) # 返回列表元素个数

for x in listx:

Python利用缩进来表达块的概念
没有显式的{}

range(s, e) # 返回由[s,e)区间数字构成的集合对象
range(s, e, step = 1)
list(range(s, e)) # 得到由[s,e)区间数字构成的列表对象
min(listx) # 返回列表最小值
max(listx)
sum(listx)

listx[s＝０,e＝尾后索引] # 返回列表[s,e)区间元素构成的子列表
直接对列表对象赋值时，两个对象指向同一个底层列表［引用］
lista = listb
现在，lista,listb指向同一个列表

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

元组用圆括号标识
定义元组后，可用索引来访问其元素，元素不可修改
其他用法和列表类似

每条if的核心都是一个值为True或False的表达式

==
<
>
<=
>=
!=
and
or
a in listx #　检查列表是否包含a
not in

if xxx:
	xxx1
else:
	xxx2

if xxx:
	xxx1
elif xx:
	xxx2
else:
	xxx3

在if语句中将列表名用在条件表达式中时，在列表非空时，表达式为True，列表空时，表达式为False

字典

y={}
x={'1':'1', '2':2}
x['1']
x['2']
x['3']='new'
print(x) #{'1':'1', '2':2, '3':'new'}
del x['1']
for key, value in x.items():
	xxx1
	...
	
for key in x.keys():
	xx1
	...

for k in sorted(x.keys()):
	xx1
	...

for v in x.values():
	xx1
	...

for k in set(x.values()):
	xx1
	...

x1={1:1,2:2}
x2={11:11}
x=[x1,x2]

p={
	'1':1,
	'11':[1,2,3],
	}

x ={
	'1':{
		1:1,
		11:2,
		},
	'2':2,
	}

用户输入和while循环

x=input("tips") # x是字符串
int(x) % 200

python2.7使用 raw_input()获取输入

while循环简介

while x:
	xx

对列表
x=[1,2,3]
item=x.pop()
x.append(item)

x={}
for k, v in x.items():
	xxx

函数

def x(arg='2'):
	xxx

x('1')
或
x(arg='1')

非空字符串变量在逻辑判断中等价于True，空字符串变量等价于False
对容器类型，变量名只是对底层存储数据的引用，赋值后，多个变量指向同一底层数据

def x(*y):
	xxx
*y让Python创建一个名为y的空元组，将收到的所有值都封装到这个元组中
无论实参传递多少个参数，函数内ｙ对应一个元组，每个传递的实参是元组的一个元素

def x(**y):
	xxx
y对应的实参可由一个或多个k=v的键值对实参构成，
在函数内部，ｙ代表所有键值对构成的一个字典
对字典y
for v,k in y.items():
	xxx


可将函数存储在被称为模块的独立文件中，
再将模块导入到主程序中
import语句允许在当前运行的程序文件中使用模块中的代码
将函数存储在独立文件中，可隐藏程序代码的细节，能让你在多个不同程序中重用函数

导入整个模块

模块是拓展名为.py的文件
1.py
def fun():
	xxx

2.py
import 1　# 让Python打开文件1.py，将其中所有函数复制到这个程序
1.fun()

导入待定的函数

3.py
from 1 import fun
from 1 import class # 从模块2导入类class
fun() # 使用时无需加1.

导入时指定别名
4.py
from 1 import fun as funx	
funx() # 可避免与本程序的fun名字冲突

使用as给模块指定别名
import x as y

from x import * # 导入模块ｘ内所有函数和类，此后可直接用函数名调用

类
x.py
class x():
	def fun1(...):
		xxx1
	def fun2(...):
		xxx2
	def __init__(self, i1, i2):
		xxx

x = x(1,2)

类的方法__init__，每当创建类的实例，该方法自动被调用
每个类的方法第一个参数必为self,指向实例本身，由python自动传入
__init__参数１外的其他参数依赖产生类实例时传入

在2.7版本
class x(object):
	xxx

x.py
class base():
	def __init__(self, i1, i2):
		xxx
	
class driv(base):
	def __init__(self, i1, i2):
		super().__init__(i1, i2)

＃　2.7版本的继承
class base(object):
	def __init__(self, i1, i2):
		xxx

class drive(base):
	def __init__(self, i1, i2):
		super(drive, self).__init__(i1,i2)

导入模块中的类

from car[模块名，每个独立的.py文件构成一个模块] import Car[类名]

自定义工作流程

Python标准库

from collections import OrderDict
xxx = OrderDict()
x[1]=xxx1
x['2']=xxx2
for name, language in xxx.items():
	// name.tite() language.title()

文件和异常

从文件读数据

with[由python替你关闭,文件访问对象只能在with代码块内有效] open('x.xxx')[只需传入文件路径] as file_obj[文件访问对象]:
	contents = file_obj.read()
	print(contents)

file = 'xxx'
with open(file) as obj:
	for line in obj:
		print(line)

file = 'xxx'
with open(file) as obj:
	lines = obj.readlines()
for line in lines:
	print(line.rstrip())// rstrip,lstrip,strip

写入文件

filename = 'xxx'
with open(filename, 'w'['a']) as obj:
	obj.write("xxx")

异常

try:
	print(5/0)
except ZeroDivisionError[类似的还有FileNotFoundError]:
	print("xxx")[pass表示此时什么都不做]


try-except-else
尝试执行try块中代码
except执行try块发生异常时执行
else执行try块正常时执行

存储数据

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)

测试

１．导入unittest
２．定义继承自unittest.TestCase的测试类
３．编写测试方法
４．执行unittest.main()调用
import unittest
class NameTestCase(unittest.TestCase):
	def test_xxx(self):
		...
		self.assertEqual(执行结果，预期结果)	

unittest.main()// 自动运行所有test_开头的函数

unittest可用的断言方法
assertEqual/assertNotEqual/assertTrue/assertFalse/assertIN/assertNotIn
５．测试类可定义setUp方法
此方法在unittest.main()下先执行，可作一些测试准备，随后每个test_函数，可利用setUp中的准备结果进一步方便测试
	import unittest
	class NameTestCase(unittest.TestCase): 
		def setUp(self):
			xxx // 可通过将一些初始化工作写入self成员，以使后续其他test_可通过self进行访问

		def test_xxx(self):
			...
			self.assertEqual(执行结果，预期结果)	

unittest.main()// 自动运行所有test_开头的函数