Python入门知识总结

Python是一种计算机程序设计语言。

Python就为我们提供了非常完善的基础代码库，覆盖了网络、文件、GUI、数据库、文本等大量内容，被形象地称作“内置电池（batteries included）”。用Python开发，许多功能不必从零编写，直接使用现成的即可。

除了内置的库外，Python还有大量的第三方库，也就是别人开发的，供你直接使用的东西。当然，如果你开发的代码通过很好的封装，也可以作为第三方库给别人使用。**

正式开始了python的学习，学习的动力是窥探别人的隐私。应该会长期更新。
最后说说Python的缺点。

第一个缺点就是运行速度慢，和C程序相比非常慢，因为Python是解释型语言，你的代码在执行时会一行一行地翻译成CPU能理解的机器码，这个翻译过程非常耗时，所以很慢。而C程序是运行前直接编译成CPU能执行的机器码，所以非常快。
第二个缺点就是代码不能加密。如果要发布你的Python程序，实际上就是发布源代码，这一点跟C语言不同，C语言不用发布源代码，只需要把编译后的机器码（也就是你在Windows上常见的xxx.exe文件）发布出去。要从机器码反推出C代码是不可能的，所以，凡是编译型的语言，都没有这个问题，而解释型的语言，则必须把源码发布出去。

1.安装编译环境

a. mac 默认自带python,打开终端，输入python,就会进去python编译环境；

2.输出内容：交互式环境的提示符>>>下

a. print(你要打印的东西)
b. 输入100+200，回车，就能得到结果；
c. print(“hello python”)，回车就能输出结果；
d. exit()，回车退出编译环境。

3.输入内容：input()

a. name = input()

4.变量

第一个字符必须是字母或者下划线“_”
剩下的部分可以是字母、下划线“_”或数字（0-9）
变量名称是对大小写敏感的，myname和myName不是同一个变量。
a. 字符串 - 表示一串字符，需要用”或”“引起来
name = ‘Crossin’
b. 整数
myVar = 123
c. 浮点数 - 就是小数
price = 5.99
d. bool（布尔） - 这个比较特殊，是用来表示逻辑“是”“非”的一种类型，它只有两个值，True和False。（注意这里没有引号，有了引号就变成字符串了）
visible = True

5.变量命名规则

第一个字符必须是字母或者下划线“_”
剩下的部分可以是字母、下划线“_”或数字（0-9）
变量名称是对大小写敏感的，myname和myName不是同一个变量。
a. 字符串 - 表示一串字符，需要用”或”“引起来
name = ‘Crossin’
b. 整数
myVar = 123
c. 浮点数 - 就是小数
price = 5.99
d. bool（布尔） - 这个比较特殊，是用来表示逻辑“是”“非”的一种类型，它只有两个值，True和False。（注意这里没有引号，有了引号就变成字符串了）
visible = True

6.bool 类型

：大于
<：小于
=：大于等于
<=：小于等于
==：等于。比较两个值是否相等。之所以用两个等号，是为了和变量赋值区分开来。
!=：不等与
not：逻辑“非”。如果x为True，则not x为False
and：逻辑“与”。如果x为True，且y为True，则x and y为True
or：逻辑“或”。如果x、y中至少有一个为True，则x or y为True

7.字符串

字符串就是一组字符的序列
python中最常用的字符串表示方式是单引号（‘’）和双引号（”“）
\被称作转译字符，除了用来表示引号，还有比如用
\表示字符串中的\
\n表示字符串中的换行
字符串之间可以用“＋”连接；eg: str1 + str2
但是字符串与数字之间不行，需要使用占位符或者使用str(18)转成str；
eg：print ‘My age is %d’ % 18
或者 print “%s’s score is %d” % (‘Mike’, 87)

8.字符串的操作

a.遍历
通过for…in可以遍历字符串中的每一个字符。
word = ‘helloworld’
for c in word:
print c
b.索引访问
通过[]加索引的方式，访问字符串中的某个字符，但是不能去修改
print word[0]
print word[-2]
c.切片
通过两个参数，截取一段子串，具体规则和list相同。
print word[5:7]
print word[:-5]
print word[:]
d.连接字符
join方法也可以对字符串使用，作用就是用连接符把字符串中的每个字符重新连接成一个新字符串。
newword = ‘,’.join(word)

9.类型转换

int(x) #把x转换成整数
float(x) #把x转换成浮点数
str(x) #把x转换成字符串
bool(x) #把x转换成bool值
在python中，以下数值会被认为是False：
为0的数字，包括0，0.0
空字符串，包括”，””
表示空值的None
空集合，包括()，[]，{}
其他的值都认为是True。

10.函数

• def saySome(name, some):
  print ‘%s say %s! % (name,some)’
• saySome(“lily”,hello)
  def hello(name = ‘world’):
  print ‘hello ’ + name

11.控制流

if a == 1:
print ‘one’
elif a == 2:
print ‘two’
else:
print ‘wrong’

12.break 与 continue

break是彻底地跳出循环，而continue只是略过本次循环的余下内容，直接进入下一次循环。
无论是continue还是break，其改变的仅仅是当前所处的最内层循环的运行，如果外层还有循环，并不会因此略过或跳出。

13.列表list

处理一组有序项目的数据结构
在python中可以用下列方式表示：list = [365, ‘everyday’, 0.618, True] #组中的元素可以是不同类型
for indexValue in list: #遍历列表l中的元素
print indexValue
访问：可以用 list[index索引] 访问元素;
修改：用 list[index索引] ＝ 211 赋值元素
添加：用 list.append(1024) 向list添加一个新的元素
删除：用 del list[index索引] 删除元素
list[-1]表示l中的最后一个元素。
list[-3]表示倒数第3个元素。

14.列表list切片

可以用 list[1,3] 分割元素,冒号前的数表示切片的开始位置，冒号后的数字表示切片到哪里结束。同样，计数从0开始。开始位置包含在切片中，而结束位置不包括。
如果不指定第一个数，切片就从列表第一个元素开始。
如果不指定第二个数，就一直到最后一个元素结束。
都不指定，则返回整个列表的一个拷贝。

15.字符串与数组list

a.split : split()会把字符串按照其中的空格进行分割，分割后的每一段都是一个新的字符串，最终返回这些字符串组成一个list。
name = “i am” name.split() —> [“i”,”am”]
b.join : join则是把一个list中的所有字符串连接成一个字符串
‘;’.join([‘apple’, ‘pear’, ‘orange’]) –> “apple;pear;orange”

16.读文件

f = file(‘相对路径或者绝对路径’) #打开文件，默认是只读打开,也可以使用open(文件路径) or f = open(‘相对路径或者绝对路径’)
data = f.read() ＃读文件内容
f.close() # 关闭文件流
多行文件的处理
f = file(‘scores.txt’)
lines = f.readlines()
f.close()
for line in lines
print line

17.写文件 –> 因为默认是只读打开，所以需要加入写的权限

f = file(‘output.txt’, ‘w’)
f.write(‘a string you want to write’) #write的参数可以是一个字符串，或者一个字符串变量。
f.close # 关闭文件流
‘w’就是writing，以这种模式打开文件，原来文件中的内容会被你新写入的内容覆盖掉，如果文件不存在，会自动创建文件。
不加参数时，file为你默认为’r’，reading，只读模式，文件必须存在，否则引发异常。
另外还有一种模式是’a’，appending。它也是一种写入模式，但你写入的内容不会覆盖之前的内容，而是添加到文件中。

18.异常处理

try:
代码块
except:
代码块

19.字典

它的基本格式是（key是键，alue是值）：
d = {key1 : value1, key2 : value2 }
键/值对用冒号分割，每个对之间用逗号分割，整个字典包括在花括号中。
关于字典的键要注意的是：
1.键必须是唯一的；
2.键只能是简单对象，比如字符串、整数、浮点数、bool值。
3.list就不能作为键，但是可以作为值。
python字典中的键/值对没有顺序，我们无法用索引访问字典中的某一项，而是要用键来访问。
空字典 dicc
if dicc is None:
score = {}
a.遍历 –> 遍历的变量中存储的是字典的键。
for name in dicc:
print dicc[name]
b.新增
dicc[‘a’] = “aaa” #确认这个 key 无对应的value，否则就是修改
c.修改
dicc[‘a’] = “aaa”
d.删除
del dicc[‘a’]

20.模块

模块可以理解为是一个包含了函数和变量的py文件。在你的程序中引入了某个模块，就可以使用其中的函数和变量。
a. dir()方法,列出模块中有哪些函数和变量
dir(模块名)
b. 如果只用到模块中某一个函数或变量，也可以通过from 模块名 import 函数 指明
from random import randint
随机数：from random import randint；
eg：randint(5, 10)：这样将会产生一个5到10之间（包括5和10）的随机整数。
c.为了便于理解和避免冲突，你还可以给引入的函数换名
from random import randint as suijishu
d.常用库
random（随机数）、re（正则表达式）、time（时间）、urllib2（网络请求）

21.JSON

导入 import json
data = json.loads(content) #从字符串转成json类型
value = data[‘key’]
可是使用基本函数 type(变量) 查看该变量类型

22.面向对象 : 类

通过dir()方法可以查看一个类/变量的所有属性：
dir(s)
dir(list)
//定义一个类
class Person:
name = ‘lily’ //属性
def\ init(self, name):
self.name = name

def eat(self, time):
print ‘need %f hour(s)’ % (time / 2.0)

def sayHello(self): #方法
print ‘%s say hello’ % (self.name)

//实例一个类并做相关操作
personA = Person()
print personA.name
personA.name = ‘susan’
personA.sayHello

//继承
class Student(Person):
def __init__(self, name, age):
Person.__init__(self, name)
self.age = age

def eat(self, time):
    Person.eat(self, time)
    print '%f age need %f hours' % (self.age,time)

__init__函数会在类被创建的时候自动调用，用来初始化类。它的参数，要在创建类的时候提供。
class定义后面的括号里表示这个类继承于哪个类。
Student类中，我们又重新定义了init和eat函数，这样会覆盖掉它继承自Person的同名函数。但我们依然可以通过“Person.函数名”来调用它的超类方法。以此来获得它作为Person所具有的功能。注意，因为是通过类名调用方法，而不是像之前一样通过对象来调用，所以这里必须提供self的参数值。在调用超类的方法之后，我们又给Student增加了一个age属性，并且在eat中多输出一行信息。

23.and-or技巧

在一个bool and a or b语句中，当bool条件为真时，结果是a；当bool条件为假时，结果是b。
and or语句是利用了python中的逻辑运算实现的。当a本身是个假值（如0，”“）时，结果就和 bool?a:b 差别很大；
and-or真正的技巧在于，确保a的值不会为假。最常用的方式是使 a 成为 [a] 、 b 成为 [b]，然后使用返回值列表的第一个元素：c = (True and [a] or [b])[0]

24.元组

元组（tuple）也是一种序列，和我们用了很多次的list类似，只是元组中的元素在创建之后就不能被修改。
eg：print ‘%s is %d years old’ % (‘Mike’, 23)
eg：def get_pos(n):
return (n/2, n*2)
x, y = get_pos(50)
print x
print y
pos = get_pos(50)
print pos[0]
print pos[1]

25.数学运算math

官方文档：http://docs.python.org/2/library/math.html
import math
math.pi –> 圆周率π：3.141592…
math.e –> 自然常数：2.718281…

数值运算：
math.ceil(x) –> 对x向上取整，比如x=1.2，返回2
math.floor(x) –> 对x向下取整，比如x=1.2，返回1
math.pow(x,y) –> 指数运算，得到x的y次方
math.log(x) –> 对数，默认基底为e。可以使用base参数，来改变对数的基底。比如math.log(100,base=10)
math.sqrt(x) –> 平方根
math.fabs(x) –> 绝对值

三角函数: 注意：这里的x是以弧度为单位，所以计算角度的话，需要先换算
math.sin(x)
math.cos(x)
math.tan(x)
math.asin(x)
math.acos(x)
math.atan(x)

角度和弧度互换:
math.degrees(x) –> 弧度转角度
math.radians(x) –> 角度转弧度

26.真值表

这种被称为“真值表”的东西，罗列了基本逻辑运算的结果。
为了便于看清，我用<=>来表示等价关系。
<=>左边表示逻辑表达式，<=>右边表示它的结果。
NOT
not False <=> True
not True <=> False
（not的结果与原值相反）

OR
True or False <=> True
True or True <=> True
False or True <=> True
False or False <=> False
（只要有一个值为True，or的结果就是True）

AND
True and False <=> False
True and True <=> True
False and True <=> False
False and False <=> False
（只要有一个值为False，or的结果就是False）

NOT OR
not (True or False) <=> False
not (True or True) <=> False
not (False or True) <=> False
not (False or False) <=> True

NOT AND
not (True and False) <=> True
not (True and True) <=> False
not (False and True) <=> True
not (False and False) <=> True

!=
1 != 0 <=> True
1 != 1 <=> False
0 != 1 <=> True
0 != 0 <=> False

==
1 == 0 <=> False
1 == 1 <=> True
0 == 1 <=> False
0 == 0 <=> True

27.正则表达式

m = re.findall(r”hi”, text) #查找text中所有符合 hi 字符的串，r是raw的意思,表示对字符串不进行转义
re是python里的正则表达式模块。findall是其中一个方法，用来按照提供的正则表达式，去匹配文本中的所有符合条件的字符串。返回结果是一个包含所有匹配的list。
“\b” 在正则表达式中表示单词的开头或结尾；如果我们只想找到“hi”这个单词，而不把包含它的单词也算在内，那就可以使用“\bhi\b”这个正则表达式。
[] 这个符号。在正则表达式中，[]表示满足括号中任一字符。比如“[Hh]i”，就可以既匹配“Hi”，又匹配“hi”了。
“.” 在正则表达式中表示除换行符以外的任意字符。
“\S” 它表示的是不是空白符的任意字符。注意是大写字符S。
“*” 是表示数量，包括0，也就是没有数字的空字符也会被匹配出来。
“+” 是表示数量，表示1个或者更多
“” 在匹配时，会匹配尽可能长的结果。如果你想让他匹配到最短的就停止，需要用“.?”,这种匹配方式被称为懒惰匹配，而原本尽可能长的方式被称为贪婪匹配。
[] 它表示其中任意一个字符。所以数字可以用[0123456789]，有一种简化的写法：[0-9]。类似的还有[a-zA-Z]的用法。还有另一种表示数字的方法：\d，要表示任意长度的数字，就可以用 [0-9]* 或者 \d*
{} 如果要限定长度，就用{}代替+，大括号里写上你想要的长度。比如11位的数字：\d{11}
\w - 匹配字母或数字或下划线或汉字（我试验下了，发现3.x版本可以匹配汉字，但2.x版本不可以）
\s - 匹配任意的空白符
^ - 匹配字符串的开始
$ - 匹配字符串的结束
\S 其实就是\s的反义，任意不是空白符的字符。同理，还有：
\W - 匹配任意不是字母，数字，下划线，汉字的字符
\D - 匹配任意非数字的字符
\B - 匹配不是单词开头或结束的位置
[a]的反义是[^a]，表示除a以外的任意字符。[^abcd]就是除abcd以外的任意字符。
之前我们用过*、+、{}来表示字符的重复。其他重复的方式还有：
? - 重复零次或一次
{n,} - 重复n次或更多次
{n,m} - 重复n到m次
可以看一篇正则表达式的文章：正则表达式30分钟入门教程 –> http://www.cnblogs.com/deerchao/archive/2006/08/24/zhengzhe30fengzhongjiaocheng.html

28.随机数random模块

random.randint(a, b) 可以生成一个a到b间的随机整数，包括a和b。a、b都必须是整数，且必须b≥a。等于的时候产生的永远都是a
random.random() 生成一个0到1之间的随机浮点数，包括0但不包括1
random.uniform(a, b) 生成a、b之间的随机浮点数。不过与randint不同的是，a、b无需是整数，也不用考虑大小。
random.choice(seq) 从序列中随机选取一个元素。seq需要是一个序列，比如list、元组、字符串。
random.randrange(start, stop, step) 生成一个从start到stop（不包括stop），间隔为step的一个随机数。start、stop、step都要为整数，且start

29.时间之time模块

time.time()返回1970到现在的毫秒数
time.sleep(secs) 可以让程序暂停secs秒。

30.python序列化pickle

pickle。它可以把任何 Python 对象存储在文件中，再把它原样取出来。
存储：
import pickle
test_data = [‘Save me!’, 123.456, True]
f = file(‘test.data’, ‘w’)
pickle.dump(test_data, f)
f.close()
取出来：
import pickle
f = file(‘test.data’)
test_data = pickle.load(f)
f.close()
dump 方法可以增加一个可选的参数，来指定用二进制来存储：
pickle.dump(data, f, True)
而 读取方法 load 会自动检测数据是二进制还是文本格式，无需手动指定。
Python 还提供了另一个模块 cPickle，它的功能及用法和 pickle 模块完全相同，只不过它是用C语言编写的，因此要快得多（比pickle快1000倍）。因此你可以把上述代码中的 pickle 全部替换为 cPickle，从而提高运行速度

31.列表综合 –> 列表解析 or 列表表达式

通过一个已有的列表生成一个新的列表。
eg： list_1 = [1, 2, 3, 5, 8, 13, 22]
list_2 = [i for i in list_1 if i % 2 == 0] #[i for i in list_1] 会把 list_1 中的每一个元素都取出来，构成一个新的列表,如果需要对其中的元素进行筛选，就在后面加上判断条件 if。
print list_2

32.函数参数

我们把函数定义时的参数名（arg1、arg2）称为形参，调用时提供的参数（3、7）称为实参。
在调用时，也可以根据形参的名称指定实参。
def func(arg2=3, arg1=7)
提供的参数会按顺序先匹配前面位置的参数，后面未匹配到的参数使用默认值。但要注意，没有指定参数名的参数必须在所有指定参数名的参数前面，且参数不能重复。
def calcSum(*args):可以接受任意数量的参数。
在变量前加上星号前缀（*），调用时的参数会存储在一个 tuple（元组）对象中，赋值给形参。在函数内部，需要对参数进行处理时，只要对这个 tuple 类型的形参（这里是 args）进行操作就可以了。因此，函数在定义时并不需要指明参数个数，就可以处理任意参数个数的情况。
func(**kargs):是把参数以键值对字典的形式传入。
字典是无序的，所以在输出的时候，并不一定按照提供参数的顺序。同样在调用时，参数的顺序无所谓，只要对应合适的形参名就可以了。于是，采用这种参数传递的方法，可以不受参数数量、位置的限制。

def func(x, y=5, *a, **b):
print x, y, a, b

func(1) –> 1 5 () {}
func(1,2) –> 1 2 () {}
func(1,2,3) –> 1 2 (3,) {}
func(1,2,3,4) –> 1 2 (3,4) {}
func(x=1) –> 1 5 () {}
func(x=1,y=1) –> 1 2 () {}
func(x=1,y=1,a=1) –> 1 2 () {‘a’: 1}
func(x=1,y=1,a=1,b=1) –> 1 2 () {‘a’: 1,’b’: 1}
func(1,y=1) –> 1 1 () {}
func(1,2,3,4,a=1) –> 1 2 (3,4) {‘a’: 1}
func(1,2,3,4,k=1,t=2) –> 1 2 (3,4) {‘k’: 1,’t’: 2}
在混合使用时，首先要注意函数的写法，必须遵守：
带有默认值的形参(arg=)须在无默认值的形参(arg)之后；
元组参数(*args)须在带有默认值的形参(arg=)之后；
字典参数(**kargs)须在元组参数(*args)之后。
可以省略某种类型的参数，但仍需保证此顺序规则。
调用时也需要遵守：
指定参数名称的参数要在无指定参数名称的参数之后；
不可以重复传递，即按顺序提供某参数之后，又指定名称传递。
而在函数被调用时，参数的传递过程为：
1.按顺序把无指定参数的实参赋值给形参；
2.把指定参数名称(arg=v)的实参赋值给对应的形参；
3.将多余的无指定参数的实参打包成一个 tuple 传递给元组参数(*args)；
4.将多余的指定参数名的实参打包成一个 dict 传递给字典参数(**kargs)。

33.lambda 表达式

lambda 表达可以被看做是一种匿名函数。lambda 表达式的语法格式：lambda 参数列表: 表达式 —> sum = lambda a, b, c: a + b + c
def fn(x):
return lambda y: x + y
a = fn(2)
print a(3)
fn 函数的返回值是一个 lambda 表达式，也就等于是一个函数对象。当以参数2来调用 fn 时，得到的结果就是：lambda y: 2 + y

34.函数作用域

在 Python 的函数定义中，可以给变量名前加上 global 关键字，这样其作用域就不再局限在函数块中，而是全局的作用域。
def func():
global x
print ‘X in the beginning of func(x): ‘, x
x = 2
print ‘X in the end of func(x): ‘, x
x = 50
func()
最终x的值为2

35.map 函数

map 是 Python 自带的内置函数，它的作用是把一个函数应用在一个（或多个）序列上，把列表中的每一项作为函数输入进行计算，再把计算的结果以列表的形式返回。map 可以看作是把一个序列根据某种规则，映射到另一个序列。
lst_1 = [1,2,3,4,5,6]
def double_func(x):
return x * 2
lst_2 = map(double_func, lst_1)
print lst_2
map 的第一个参数是一个函数，之后的参数是序列，可以是 list、tuple。
所以上面程序可以这样：
lst_1 = (1,2,3,4,5,6)
lst_2 = map(lambda x: x * 2, lst_1)
print lst_2
两个列表相加
lst_1 = [1,2,3,4,5,6]
lst_2 = [1,3,5,7,9,11]
lst_3 = map(lambda x, y: x + y, lst_1, lst_2)
print lst_3
当 map 中的函数为 None 时，结果将会直接返回参数组成的列表。

36.reduce 函数

reduce 做的事情就是把一个序列根据某种规则，归纳为一个输出。
reduce(function, iterable[, initializer])
第一个参数是作用在序列上的方法，第二个参数是被作用的序列，这与 map 一致。另外有一个可选参数，是初始值。
function 需要是一个接收2个参数，并有返回值的函数。它会从序列 iterable 里从左到右依次取出元素，进行计算。每次计算的结果，会作为下次计算的第一个参数。
提供初始值 initializer 时，它会作为第一次计算的第一个参数。否则，就先计算序列中的前两个值。
eg：
lst = xrange(1, 101)
def add(x, y):
return x + y
print reduce(add, lst)
或者
reduce((lambda x, y: x + y), xrange(1, 101))
Python3 里，reduce已经被移出内置函数，使用 reduce 需要先通过 from functools import reduce 引入。