python学习

1.print
格式：
print''
print()

2.IDE
什么是IDE？英文叫做Integrated Development Environment，中文就是集成开发环境。
打个不恰当的比方，如果说写代码是制作一件工艺品，那IDE就是机床。再打个不恰当的比方，PS就是图片的IDE，Word就是doc文档的IDE，PowerPoint就是ppt文件的IDE。python也有自己的IDE，而且还有很多。

3.input
 接收命令的函数
格式：
 input''
 input()
 a=input()
 raw_input()  #把所有输入都直接当成一串字符，就可以不加引号
  对于raw_input函数来说输入都是一个字符串。可以通过int等等把这个字符串转换为整数，并把它存储在变量中。事实上，int是一个类，不过你想在对它所需了解的只是它把一个字符串转换为一个整数（假设这个字符串含有一个有效的整数文本信息）。
  ex:guess = int(raw_input('Enter an integer : '))
显示：
  Enter an integer : 此处自己输入数字
 
4.#
  python的注释符号
  在python编写代码的时候，避免不了会出现或是用到中文，这时候你需要在文件开头加上中文注释。如果开头不声明保存编码的格式是什么，那么它会默认使用ASKII码保存文件，这时如果你的代码中有中文就会出错了，即使你的中文是包含在注释里面的。所以加上中文注释很重要。
#coding=utf-8
或者：
#coding=gbk
以上两种都可以代表中文注释，看过的更多人使用urf-8这种的比较多。

在python中也会有注释有很多行的时候，这种情况下就需要批量多行注释符了。多行注释是用三引号'''   '''包含的
5.python里创建一个变量的方法很简单，给它起个名字，然后给它一个值。举起几个栗子，分别代表了python中较常见的四种基本类型：
   name = 'Crossin' #字符串 - 表示一串字符，需要用''或""引起来

   myVar = 123      #整数

   price = 5.99     #浮点数 - 就是小数

   visible = True   #bool（布尔） - 这个比较特殊，是用来表示逻辑“是”“非”的一种类型，它只有两个值，True和False。（注意这里没有引号，有了引号就变成字符串了）

6.通过用“>”“<”来比较两个数值，我们就得到了一个bool值。这个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.if
  语法为：

if 条件:

       选择执行的语句

特别说明：条件后面的冒号不能少，同样必须是英文字符。

特别特别说明：if内部的语句需要有一个统一的缩进，一般用4个空格。

和else块的组合：
if  xxx=xx:
    xxxxx
elif xxx<xx:
    xxxxx
else:
    xxxxx
8.while
程序执行到while处，“当”条件为True时，就去执行while内部的代码，“当”条件为False时，就跳过。
语法为：

while 条件:

    循环执行的语句

9.用以上语法做一个猜数字大小游戏

num=15
print'guess what the number is'
bingo=False
while bingo==False:
    answer=input()
    if answer<num:
        print'too small'
    if answer>num:
        print'too big'
    if answer==num:
        print'bingo'
        bingo=True
10.print和input，它们的作用是实现控制台的输入和输出。除此之外，python还提供了很多模块，用来实现各种常见的功能，比如时间处理、科学计算、网络请求、随机数等等等等

11.引入模块的方法：
   from 模块名 import 方法名

12.产生一个随机的整数
   from random import randint
   num = randint(1, 100)
使用randint的时候后面也要有()。而且，还要在括号中提供两个数字，先后分别是产生随机整数范围的下限和上限

13.for
  格式：
  for i in range(1,101) #从1开始，不包括101，依次走

14.字符串的表示方式

最常用的字符串表示方式是单引号（‘’）和双引号（""）。我还是要再说：一定得是英文字符！
'string'和“string”的效果是一样的。

如果你想表示一段带有英文单引号或者双引号的文字，那么表示这个字符串的引号就要与内容区别开。
内容带有单引号，就用双引号表示

"It's good"
反之亦然
‘You are a "BAD" man’

还有一种在字符串中表示引号的方法，就是用\，可以不受引号的限制
\'表示单引号，\"表示双引号

‘I\'m a \"good\" teacher’

python中还有一种表示字符串的方法：
三个引号（‘’‘）或者（"""）
在三个引号中，你可以方便地使用单引号和双引号，并且可以直接换行

'''
"What's your name?" I asked.

"I'm Han Meimei."

'''

15.\
\被称作转译字符，除了用来表示引号，还有比如用

\\表示字符串中的\

\n表示字符串中的换行

\还有个用处，就是用来在代码中换行，而不影响输出的结果：

"this is the\

same line"

16. 字符串格式化

如果你想把两段字符连起来输出
str1 = 'good'
str2 = 'bye'
你可以
print str1 + str2
或者还可以把字符变量一个字符串相加
print 'very' + str1
print str1 + ' and ' + str2

但如果你想要把一个数字加到文字后面输出，程序就会报错。因为字符和数字不能直接用+相加。

一种解决方法是，用str()把数字转换成字符串
print 'My age is' + str(18)
或
num = 18
print 'My age is' + str(num)

还有一种方法，就是用%对字符串进行格式化
num = 18
print 'My age is %d' % num
输出的时候，%d会被%后面的值替换。输出
My age is 18

这里，%d只能用来替换整数。如果你想格式化的数值是小数，要用%f
print ‘Price is %f’ % 4.99
输出
Price is 4.990000

如果你想保留两位小数，需要在f前面加上条件：%.2f
print ‘Price is %.2f’ % 4.99
输出
Price is 4.99

另外，可以用%s来替换一段字符串
name = 'Crossin'
print '%s is a good teacher.' % name
输出
Crossin is a good teacher.

或者
print 'Today is %s.' % 'Friday'

输出
Today is Friday.

有时候，仅仅代入一个值不能满足我们构造字符串的需要。假设你现在有一组学生成绩的数据，你要输出这些数据。在一行中，既要输出学生的姓名，又要输出他的成绩。例如

Mike's score is 99.
在python中，你可以这样实现：

print "%s's score is %d" % ('Mike', 87)
('Mike', 87)这种用()表示的一组数据在python中被称为元组（tuple），是python的一种基本数据结构

1.循环的嵌套
ex1：打出5*5的星星
for i in range(0, 5):

    for j in range(0, 5):

        print'*',
 
    print
第二个print的缩进和内层的for是一样的，这表明它是外层for循环中的语句，每次i的循环中，它会执行一次。

print后面没有写任何东西，是起到换行的作用，这样，每输出5个*，就会换行。

ex2：输出
*

**

***

****

*****

for i in range(0, 5):

    for j in range(0, i+1):

        print '*',

    print
内层的j每次从0到i+1进行循环。
这样，当第一次i=0时，j就是range(0,1)，只输出1个*。
而当最后一次i=4时，j就是range(0,5)，输出5个*。

ex3：输入一个大于等于1的值n，输出星号（*）组成的等腰三角形，底边长为n

n=input()
for i in range(1, n+1):     #一共循环n次，从1到n行
    for j in range(0, n-i):  #第i行前面空n-i个空格
        print '',    #输出一个空字符加逗号，起输出空格的作用
    for j in range(0,i):     #第i行输出i个*
        print'*',      #记得逗号
    print             #换行

2.range()函数
range返回一个序列的数。这个序列从第一个数开始到第二个数为止。例如，range(1,5)给出序列[1, 2, 3, 4]。默认地，range的步长为1。如果我们为range提供第三个数，那么它将成为步长。例如，range(1,5,2)给出[1,3]。记住，range 向上 延伸到第二个数，即它不包含第二个数。

3.break语句
   break语句是用来 终止 循环语句的，彻底地跳出循环即哪怕循环条件没有称为False或序列还没有被完全递归，也停止执行循环语句。
一个重要的注释是，如果你从for或while循环中 终止 ，任何对应的循环else块将不执行。

4.continue语句
略过本次循环的余下内容，直接进入下一次循环。

continue语句被用来告诉Python跳过当前循环块中的剩余语句，然后继续进行下一轮循环。
ex：
s = raw_input('Enter something : ')
if len(s) < 3:
   continue
print 'Input is of sufficient length'
显示：
 Enter something : a
 Enter something : 12
 Enter something : abc
 Input is of sufficient length

无论是continue还是break，其改变的仅仅是当前所处的最内层循环的运行，如果外层还有循环，并不会因此略过或跳出。

5.python在定义一个变量时不需要给它限定类型。变量会根据赋给它的值，自动决定它的类型。你也可以在程序中，改变它的值，于是也就改变了它的类型。虽然类型可以随意改变，但当你对一个特定类型的变量进行操作时，如果这个操作与它的数据类型不匹配，就会产生错误.
这种情况下，python提供了一些方法对数值进行类型转换：
int(x) #把x转换成整数

float(x) #把x转换成浮点数

str(x) #把x转换成字符串

bool(x) #把x转换成bool值

6.函数
如果我们要自己写一个函数，就需要去 定义 它。python里的关键字叫def（define的缩写），格式如下：
def sayHello():

   print 'hello world!'

sayHello是这个函数的名字，后面的括号里是参数，这里没有，表示不需要参数。但括号和后面的冒号都不能少。下面缩进的代码块就是整个函数的内容，称作函数体。

7.list
中文可以翻译成列表，是用来处理一组有序项目的数据结构。
for循环做的事情其实就是遍历一个列表中的每一项，每次循环都把当前项赋值给一个变量（这里是i），直到列表结束。
for i in range(1, 10):
print range(1,10)
得到的结果是：
[1, 2, 3, 4, 5, 6, 7, 8, 9]

我们也可以定义自己的列表，格式就是用中括号包围、逗号隔开的一组数值：
l = [1, 1, 2, 3, 5, 8, 13]
（1）访问list中的元素
list中的每个元素都对应一个递增的序号。与现实中习惯的序号不同在于，计算机中的计数通常都是从0开始.
要访问l中的第1个元素365，只要用l[0]就可以了。依次类推，
（2）修改list中的元素
修改list中的某一个元素，只需要直接给那个元素赋值就可以了：
l[0] = 123
（3） 向list中添加元素
list有一个append方法，可以增加元素。以l这个列表为例，调用的方法是：
l.append(1024)
输出l，你会看到1024被添加到了l，成为最后一个元素。
（4）删除list中的元素
删除list中的某一个元素，要用到del：
del l[0]

8.random的另一个方法：choice。它的作用是从一个list中随机挑选一个元素。
from random import choice

9.list有两类常用操作：索引(index)和切片(slice)。
除了指定位置进行索引外，list还可以处理负数的索引。
l = [365, 'everyday', 0.618, True]
l[-1]表示l中的最后一个元素。
l[-3]表示倒数第3个元素。

切片操作符是在[]内提供一对可选数字，用:分割。冒号前的数表示切片的开始位置，冒号后的数字表示切片到哪里结束。同样，计数从0开始。
注意，开始位置包含在切片中，而结束位置不包括。
l[1:3]
得到的结果是['everyday', 0.618]。
如果不指定第一个数，切片就从列表第一个元素开始。
如果不指定第二个数，就一直到最后一个元素结束。
都不指定，则返回整个列表的一个拷贝。
l[:3]

l[1:]

l[:]
同索引一样，切片中的数字也可以使用负数。比如：
l[1:-1]
得到['everyday', 0.618]

10.假设你现在拿到了一个英语句子，需要把这个句子中的每一个单词拿出来单独处理。
sentence = 'I am an Englist sentence'
这时就需要对字符串进行分割。
sentence.split()
split()会把字符串按照其中的空格进行分割，分割后的每一段都是一个新的字符串，最终返回这些字符串组成一个list。于是得到
['I', 'am', 'an', 'Englist', 'sentence']

原来字符串中的空格不再存在。除了空格外，split()同时也会按照换行符\n，制表符\t进行分割。所以应该说，split默认是按照空白字符进行分割。
之所以说默认，是因为split还可以指定分割的符号。比如你有一个很长的字符串
section = 'Hi. I am the one. Bye.'
通过指定分割符号为'.'，可以把每句话分开

section.split('.')

得到
['Hi', ' I am the one', ' Bye', '']
这时候，'.'作为分割符被去掉了，而空格仍然保留在它的位置上。
注意最后那个空字符串。每个'.'都会被作为分割符，即使它的后面没有其他字符，也会有一个空串被分割出来。例如

'aaa'.split('a')
将会得到['', '', '', '']，由四个空串组成的list。

11.join
join则是把一个list中的所有字符串连接成一个字符串。

首先你需要有一个字符串作为list中所有元素的连接符，然后再调用这个连接符的join方法，join的参数是被连接的list：
s = ';'

li = ['apple', 'pear', 'orange']

fruit = s.join(li)

print fruit

得到结果'apple;pear;orange'。

也可以直接在shell中输入：
';'.join(['apple', 'pear', 'orange'])

用来连接的字符串可以是多个字符，也可以是一个空串：
''.join(['hello', 'world'])
得到'helloworld'，字符串被无缝连接在一起。

12.符串的一些与list相似的操作：
1） 遍历

通过for...in可以遍历字符串中的每一个字符。
word = 'helloworld'
for c in word:
    print c
2） 索引访问
通过[]加索引的方式，访问字符串中的某个字符。
print word[0]
print word[-2]
与list不同的是，字符串不能通过索引访问去更改其中的字符。
word[1] = 'a'
这样的赋值是错误的。
3） 切片
通过两个参数，截取一段子串，具体规则和list相同。
print word[5:7]
print word[:-5]
print word[:]
4） 连接字符
join方法也可以对字符串使用，作用就是用连接符把字符串中的每个字符重新连接成一个新字符串。
newword = ','.join(word)

2016/10/14 16：17

1.读文件
要读取文件，先得有文件。我们新建个文件，就叫它data.txt。在里面随便写上一些话，保存。把这个文件放在接下来你打算保存代码的文件夹下，这么做是为了方便我们的程序找到它。
打开一个文件的命令很简单：
file('文件名')
这里的文件名可以用文件的完整路径，也可以是相对路径。因为我们把要读取的文件和代码放在了同一个文件夹下，所以只需要写它的文件名就够了。
f = file('data.txt')
但这一步只是打开了一个文件，并没有得到其中的内容。变量f保存了这个文件，还需要去读取它的内容。你可以通过read()函数把文件内所有内容读进一个字符串中。
data = f.read()
做完对文件的操作之后，记得用close()关闭文件，释放资源。虽然现在这样一个很短的程序，不做这一步也不会影响运行结果。但养成好习惯，可以避免以后发生莫名的错误。
ex：
f = file('data.txt')
data = f.read()
print data
f.close()
读取文件内容的方法还有
readline() #读取一行内容
readlines() #把内容按行读取至一个list中

2.写文件
python默认是以只读模式打开文件。如果想要写入内容，在打开文件的时候需要指定打开模式为写入：

f = file('output.txt', 'w')

'w'就是writing，以这种模式打开文件，原来文件中的内容会被你新写入的内容覆盖掉，如果文件不存在，会自动创建文件。
不加参数时，file为你默认为'r'，reading，只读模式，文件必须存在，否则引发异常。
另外还有一种模式是'a'，appending。它也是一种写入模式，但你写入的内容不会覆盖之前的内容，而是添加到文件中。

打开文件还有一种方法，就是open()，用法和file()是一致的。
ex：
data = 'I will be in a file.\nSo cool!'
out = open('output.txt', 'w')
out.write(data)
out.close()

写入内容的方法同样简单：
f.write('a string you want to write')

write的参数可以是一个字符串，或者一个字符串变量。

2016/10/15 20：03
1.字典（dictionary）
在字典中，名字叫做“键”，对应的内容信息叫做“值”。字典就是一个键/值对的集合。
它的基本格式是（key是键，value是值）：
d = {key1 : value1, key2 : value2 }
键/值对用冒号分割，每个对之间用逗号分割，整个字典包括在花括号中。
关于字典的键要注意的是：
1.键必须是唯一的；
2.键只能是简单对象，比如字符串、整数、浮点数、bool值。
list就不能作为键，但是可以作为值。

我们无法用索引访问字典中的某一项，而是要用键来访问。
print score['段誉']
注意，如果你的键是字符串，通过键访问的时候就需要加引号，如果是数字作为键则不用。

字典也可以通过for...in遍历：

for name in score:
   print score[name]

注意，遍历的变量中存储的是字典的键。

如果要改变某一项的值，就直接给这一项赋值：
score['虚竹'] = 91

增加一项字典项的方法是，给一个新键赋值：
score['慕容复'] = 88

删除一项字典项的方法是del：
del score['萧峰']
注意，这个键必须已存在于字典中。

如果你想新建一个空的字典，只需要:

d = {}

2.模块：模块可以理解为是一个包含了函数和变量的py文件
ex：
import random

import语句告诉python，我们要用random模块中的内容。然后便可以使用random中的方法，比如：
random.randint(1, 10)
random.choice([1, 3, 5])
注意，函数前面需要加上“random.”，这样python才知道你是要调用random中的方法。

想知道random有哪些函数和变量，可以用dir()方法：
dir(random)

如果你只是用到random中的某一个函数或变量，也可以通过from...import...指明：

from math import pi
print pi

为了便于理解和避免冲突，你还可以给引入的方法换个名字：

from math import pi as math_pi
print math_pi

2016/11/4
1. urllib2
用来发送网络请求，获取数据

打开一个链接：
import urllib2
web = urllib2.urlopen('http://www.baidu.com')
content = web.read()
print content
你把content保存到一个以“.html”结尾的文件中，再打开这个html文件，就会看到“百度的首页”，只是这个首页在你的电脑上，所以你无法进行搜索。
2. json
用来解析获得的数据

1.
关键字class加上类名用来创建一个类。之后缩进的代码块是这个类的内部。在这里，我们用pass语句，表示一个空的代码块。
class MyClass:
    pass
mc = MyClass()
print mc
类名加圆括号()的形式可以创建一个类的实例，也就是被称作对象的东西。我们把这个对象赋值给变量mc。于是，mc现在就是一个MyClass类的对象。

2.我们给这个类加上一些域：

class MyClass:
    name = 'Sam'

    def sayHi(self):
        print 'Hello %s' % self.name

mc = MyClass()
print mc.name  #调用类变量的方法是“对象.变量名”。你可以得到它的值，也可以改变它的值。
mc.name = 'Lily'
mc.sayHi()

我们给MyClass类增加了一个类变量name，并把它的值设为'Sam'。然后又增加了一个类方法sayHi。

3.
__init__函数是左右各两个下划线。这是python系统定义的名称。其他还有很多系统定义的方法和属性也是用双下划线包围的。
__init__函数会在类被创建的时候自动调用，用来初始化类。它的参数，要在创建类的时候提供。

4.
   if a > 0:
   
       print "big"

   else:
   
       print "small"
可以直接写成：
   print (a > 0) and "big" or "small"

a = "heaven"

b = "hell"

c = True and a or b

print c
这里的and or语句是利用了python中的逻辑运算实现的。当a本身是个假值（如0，""）时，结果就不会像你期望的那样。

所以，and-or真正的技巧在于，确保a的值不会为假。最常用的方式是使 a 成为 [a] 、 b 成为[ b ] ，然后使用返回值列表的第一个元素：
a = ""

b = "hell"

c = (True and [a] or [b])[0]

print c
由于[a]是一个非空列表，所以它决不会为假。即使a是0或者''或者其它假值，列表[a]也为真，因为它有一个元素。

5.
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。可以使用第二个参数，来改变对数的基底。比如math.log(100, 10)

math.sqrt(x)
平方根

math.fabs(x)
绝对值

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

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

math.radians(x)
角度转弧度

6.
正则表达式就是记录文本规则的代码。

所以正则表达式并不是python中特有的功能，它是一种通用的方法。python中的正则表达式库，所做的事情是利用正则表达式来搜索文本。要使用它，你必须会自己用正则表达式来描述文本规则。
import re

text = "Hi, I am Shirley Hilton. I am his wife."

m = re.findall(r"hi", text)

if m:
   
    print m

else:
   
    print 'not match'

“\b”在正则表达式中表示单词的开头或结尾，空格、标点、换行都算是单词的分割。而“\b”自身又不会匹配任何字符，它代表的只是一个位置。所以单词前后的空格标点之类不会出现在结果里。
在前面那个例子里，“\bhi\b”匹配不到任何结果。但“\bhi”的话就可以匹配到1个“hi”，出自“his”。

[]这个符号。在正则表达式中，[]表示满足括号中任一字符。比如“[hi]”，它就不是匹配“hi”了，而是匹配“h”或者“i”。在前面例子中，如果把正则表达式改为“[Hh]i”，就可以既匹配“Hi”，又匹配“hi”了。

7.
r"hi"

这里字符串前面加了r，是raw的意思，它表示对字符串不进行转义。
>>> print "\bhi"
hi
>>> print r"\bhi"
\bhi

因为python的字符串碰到“\”就会转义它后面的字符。如果你想在字符串里打“\”，则必须要打“\\”。

8. “.” “*” “\S” “?”
1）“.”在正则表达式中表示除换行符以外的任意字符
    Hi, I am Shirley Hilton. I am his wife.
    如果我们用“i.”去匹配，就会得到
         ['i,', 'ir', 'il', 'is', 'if']
2）与“.”类似的一个符号是“\S”，它表示的是：不是空白符的任意字符
3）“*”则不是表示字符，而是表示数量：它表示前面的字符可以重复任意多次（包括0次），只要满足这样的条件，都会被表达式匹配上。
结合前面的“.*”，用“I.*e”去匹配，想一下会得到什么结果？
['I am Shirley Hilton. I am his wife']

是不是跟你想的有些不一样？也许你会以为是
['I am Shirle', 'I am his wife']

这是因为“*”在匹配时，会匹配尽可能长的结果。如果你想让他匹配到最短的就停止，需要用“.*?”。如“I.*?e”，就会得到第二种结果。这种匹配方式被称为懒惰匹配，而原本尽可能长的方式被称为贪婪匹配。

序列：分为可变序列（序列里的某个元素支持在原位被改变）和不可变序列
  可变序列：list列表
         可以包含任意对象（比如浮点型、字符型等等）的有序集合；
         通过下标索引（位置偏移）来访问元素；
         可变长度、异质（可以包含任意类型的嵌套），可任意嵌套（在列表里面可以再包含一个列表
               比如：y = [1,2,3,['tom','jerry']]）；
         支持原位改变；
         对象引用数组；

序列的通用操作
     判断元素是否在序列之内
       >>> names = ['tom','jerry','mike']
       >>> 'mike' in names
            True
       >>>scores = [99,98,100]
       >>> 101 not in scores
            True
     连接序列 s1+s2
       >>> x = list(range(4))
       >>> x
          [0, 1, 2, 3]
       >>> y = [98,99,100]
       >>> x + y
          [0, 1, 2, 3, 98, 99, 100]
     重复序列元素 s*n
     下标获取元素 s[i]
     访问指定索引范围 s[i:j]
     按步长访问指定索引范围 s[i:j:k] k是步长
     获取序列长度 len(s)
     获取最大值、最小值 max(s)、min(s)
     统计总和 sum(s)
     检索某个元素第一次出现位置的下标 s.index(x)
     统计元素出现次数 s.count(x)