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 引入。