python入门知识

python 变量和数据类型

http://www.cnblogs.com/linjiqin/p/3608541.html
http://www.cnblogs.com/yueya/p/5811998.html

python 数据类型

print 45678+0x12fd2 print "learn Python in mooc"print 'learn Python in mooc'

print 100<99print 0xff==255

123456
learn Python in mooc
learn Python in mooc
False
True

python print 语句

print 300+100print 400print 'The quick brown fox','jump over','the lazy dog'print 'hello ,','python'

400
400
The quick brown fox jump over the lazy dog
hello , python

python   注释

#print 'hello'

python 变量

a=1;a='hello'print a#下面是错的  好像python不能有指定的数据类型#int b=200#b='python'#print b

python  定义字符串

s = 'Python was started in 1989 by \"Guido\".\n Python is free and easy to learn.'print s

\n 表示换行
\t 表示一个制表符
\\ 表示 \ 字符本身

Python中raw字符串与多行字符串

字符串前面加个r就不需要转义了  但是但是r'...'表示法不能表示多行字符串，也不能表示包含'和 "的字符串
如果要表示多行字符串，可以用'''...'''表示
r'''.....''' 就可以表示' "这种转义了

print r'\(~_~)/ \(~_~)/'print r'''"To be, or not to be": that is the question.Whether it's nobler in the mind to suffer.'''

\(~_~)/ \(~_~)/
"To be, or not to be": that is the question.
Whether it's nobler in the mind to suffer.

Python中Unicode字符串

# -*- coding: utf-8 -*-print '''静夜思  床前明月光，  疑是地上霜。 举头望明月， 低头思故乡。''' print '中文'  #这个1为什么会出错  不是已经是utf-8的编码了吗 

Python中整数和浮点数

print 2.5 + 10.0 / 4print 7.5/8print 11/4print 11%4print 11.0/4

5.0
0.9375
2
3
2.75

python  布尔运算

除了与java 相同的与 ，或，非运算外
Python把0、空字符串''和None看成 False，其他数值和非空字符串都看成 True


True and 'a=T' 计算结果是 'a=T'
继续计算 'a=T' or 'a=F' 计算结果还是 'a=T'


要解释上述结果，又涉及到 and 和 or 运算的一条重要法则：短路计算。

1. 在计算 a and b 时，如果 a 是 False，则根据与运算法则，整个结果必定为 False，因此返回 a；如果 a 是 True，则整个计算结果必定取决与 b，因此返回 b。

2. 在计算 a or b 时，如果 a 是 True，则根据或运算法则，整个计算结果必定为 True，因此返回 a；如果 a 是 False，则整个计算结果必定取决于 b，因此返回 b。

a = 'python'print 'hello,'and a or 'world'b = ''print 'hello,'and b or 'world'pythonworld

python List（对比JAVA的List集合的遍历，索引，表示等）

list是一种有序的集合，可以随时添加删除其中的元素
使用的[] 把list所有的元素都括起来，就是一个list对象
由于python是动态语言，所以list中的元素并不要求都必须是同一种数据类型
（可以对比java中的List集合 打印出来也是使用[] 括起来的）


Python按照索引（倒序索引）访问list

L = [95.5,85,59]print L[0]print L[-1]

result：
95.5
59

python之list 添加新元素

L = ['Adam', 'Lisa', 'Bart']L.append('Paul')#这个方法总是添加到list末尾L.insert(0,'FirstOne')#这个方法可以添加指定的索引位置print L

python之list 删除元素

L = ['Adam', 'Lisa', 'Paul', 'Bart']L.pop()#如果参数为空那就是默认的删除list的最后一个元素L.pop(2)#就是删除索引位置为2的元素print L

result: ['Adam', 'Lisa']


python之list 替换元素

L = ['Adam', 'Lisa', 'Bart']L[-1] ='Adam'L[0] = 'Bart'print L

result:['Bart', 'Lisa', 'Adam']

python tuple

tuple是另外一种有序的列表，中文翻译为“元组”,tuple和list非常类似，但是
tuple一旦被创建就不能被修改了（也就是没有所谓的append(),insert(),pop()方法了，也没有什么方法去修改tuple）。
tuple的创建和list唯一不同之处是用() 替代了[]。


获取tuple元素的方式和list是一样的，可以用t[0],t[1]等索引方式访问元素，但是并不能复制成别的元素（也就是所谓的修改元素）


Python之创建单元素tuple
t = ('Adam',) 需要在后面加一个(,)，不然的话就会被解析成一个括号
表示的是算数的优先级：t=(1) 打印出来结果就是一个整数1


Python之“可变”的tuple

t = ('a', 'b', ['A', 'B'])print t[2]t[2][0]=1print t 

result:
['A', 'B']
('a', 'b', [1, 'B'])

tuple一开始指向的list并没有改成别的list，
所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变

python 条件判断和循环

在这之前特别注意的是python代码的缩进规则
缩进请严格按照Python的习惯写法：
4个空格，不要使用Tab，更不要混合Tab和空格，
否则很容易造成因为缩进引起的语法错误。


如果你在Python交互环境下敲代码
还要特别留意缩进，并且退出缩进需要多敲一行回车


if

score = 55if score >=60:    print 'passed'    print 'yes'print 'END'

其中3,4行构成了一个代码块而第5行不是
if-else

score = 55if score >=60:    print 'passed'else:    print 'failed'   #result failed

if-elif-else

score = 85if score>=90:    print 'excellent'elif score>=80:    print 'good'elif score>=60:    print 'passed'else:    print 'failed'  #result good

for循环
遍历list tuple

L = [75, 92, 59, 68]sum = 0.0for x in L:   sum=sum+xprint sum / 4 #2500

while循环

sum = 0x = 1while x<100:    sum = sum+x    x=x+2print sum #2500

break退出循环

sum = 0x = 1while True:    if x>100:        break    sum = sum+x    x=x+2print sum #2500

continue继续循环

sum = 0x = 0while True:    x = x + 1    if x>100:       break    if x%2==0:        continue    sum =sum+xprint sum  #2500

多重循环

for x in ['A', 'B', 'C']:    for y in ['1', '2', '3']:        print x,y

result:
A 1
A 2
A 3
B 1
B 2
B 3
C 1
C 2
C 3

for x in ['A', 'B', 'C']:    for y in ['1', '2', '3']:        print x+y

如果输出使用+链接 而不是， 结果是不样的
+链接中间没有空格
A1
A2
A3
B1
B2
B3
C1
C2
C3

Python之dict（字典）（类似于java的map集合）

花括号 {} 表示这是一个dict，
然后按照 key: value, 写出来即可。
最后一个 key: value 的逗号可以省略。

d = {    'Adam': 95,    'Lisa': 85,    'Bart': 59}>>>len(d)  # result 3 获取集合长度

python之访问dict

 d[key] 的形式来查找对应的 value
当访问的key值不存在对应的value时就会报错所以：
一：

if 'Paul' in d:    print d['Paul']  #不存在返回false

二：

print d.get('Bart')  #不存在返回None

python之dict的特点

dict的第一个特点是查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。

不过dict的查找速度快不是没有代价的，dict的缺点是占用内存大，还会浪费很多内容，list正好相反，占用内存小，但是查找速度慢。

由于dict是按 key 查找，所以，在一个dict中，key不能重复。

dict的第二个特点就是存储的key-value序对是没有顺序的！

dict的第三个特点是作为 key 的元素必须不可变，Python的基本类型如字符串、整数、浮点数都是不可变的，都可以作为 key。但是list是可变的，就不能作为 key

Python之dict的更新（update insert）

d = {    95: 'Adam',    85: 'Lisa',    59: 'Bart'}d[72]='Paul'print d[72]d[72]='Paul2'print d[72]

result
Paul
Paul2


python之遍历dict

d = {    'Adam': 95,    'Lisa': 85,    'Bart': 59}for key in d:    print key,':',d[key]

result:
Lisa : 85
Adam : 95
Bart : 59

Python之set(类似于Java的set集合 无序不重复)

dict的作用是建立一组 key 和一组 value 的映射关系，dict的key是不能重复的。

有的时候，我们只想要 dict 的 key，不关心 key 对应的 value，目的就是保证这个集合的元素不会重复，这时，set就派上用场了。

set 持有一系列元素，这一点和 list 很像，但是set的元素没有重复，而且是无序的，这点和 dict 的 key很像。

s = set(['Adam','Lisa','Bart','Paul'])print sresult:set(['Lisa', 'Paul', 'Adam', 'Bart'])

python之访问set


由于set存储的是无序集合，所以不能通过索引来访问
访问 set中的某个元素实际上就是判断一个元素是否在set中。

>>> s = set(['Adam', 'Lisa', 'Bart', 'Paul'])>>> 'Bart' in s

True
>>> 'bart' in s
False
大小写很重要


python之set的特点

set的内部结构和dict很像，唯一区别是不存储value，因此，判断一个元素是否在set中速度很快。

set存储的元素和dict的key类似，必须是不变对象，因此，任何可变对象是不能放入set中的。

最后，set存储的元素也是没有顺序的。

months = set(['MON', 'TUE', 'WED', 'THU', 'FRI', 'SAT', 'SUN'])x1 = 'Feb'x2 = 'Sun'if x1 in months:    print 'x1: ok'else:    print 'x1: error'if x2 in months:    print 'x2: ok'else:    print 'x2: error'

result:
x1: error
x2: error


python之遍历set


由于 set 也是一个集合，所以，遍历 set 和遍历 list 类似，都可以通过 for 循环实现。

>>> s = set(['Adam', 'Lisa', 'Bart'])>>> for name in s:...     print name... LisaAdamBart

s = set([('Adam', 95), ('Lisa', 85), ('Bart', 59)])for x in s:    print x[0],':',x[1]

result:
Lisa : 85
Adam : 95
Bart : 59


python之更新set(including insert  delete)

s = set(['Adam', 'Lisa', 'Paul'])L = ['Adam', 'Lisa', 'Bart', 'Paul']for name in L:    if name in s:        s.remove(name)    else:        s.add(name)print s

result:set(['Bart'])


所以用add()可以直接添加，而remove()前需要判断。

python之函数

如果没有return语句，函数执行完毕后也会返回结果，只是结果为 None。

return None可以简写为return。

编写一个函数计算list的平方和

def square_of_sum(L):    sum=0    for x in L:        x=x*x        sum=x+sum        return sumprint square_of_sum([1, 2, 3, 4, 5])print square_of_sum([-5, 0, 5, 15, 25])

result:55
       900


python之函数返回多值

import mathdef quadratic_equation(a, b, c):   # s=b*b-4*a*c   # x1 =(-b+math.sqrt(s))/2*a   # x2 =(-b-math.sqrt(s))/2*a   # return x1,x2    t = math.sqrt(b * b - 4 * a * c)    return (-b + t) / (2 * a),( -b - t )/ (2 * a)print quadratic_equation(2, 3, 0)print quadratic_equation(1, -6, 5)

result:
(0.0, -1.5)
(5.0, 1.0)

用print打印返回结果，原来返回值是一个tuple！

但是，在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值，
所以，Python的函数返回多值其实就是返回一个tuple，但写起来更方便。

python之递归函数

def move(n, a, b, c):    if n ==1:        print a, '-->', c        return    move(n-1, a, c, b)    print a, '-->', c    move(n-1, b, a, c)move(4, 'A', 'B', 'C')

result:
A --> B
A --> C
B --> C
A --> B
C --> A
C --> B
A --> B
A --> C
B --> C
B --> A
C --> A
B --> C
A --> B
A --> C
B --> C


python之定义默认参数

def greet(name='world'):    print 'Hello, ' + name + '.'greet()greet('Bart')

result:
Hello, world.
Hello, Bart.


python之定义可变参数函数

def average(*args):    sum =0.0    if len(args)==0:        return sum      for x in args:        sum=sum+x    return sum/len(args)print average()print average(1, 2)print average(1, 2, 2, 3, 4)

result:
0.0
1.5
2.4

python之list切片

记住倒数第一个元素的索引是-1。倒序切片包含起始索引，不包含结束索引。
（这点就像java的substring()方法一样 包括起始不包括结尾）

利用倒序切片对 1 - 100 的数列取出：

* 最后10个数；

* 最后10个5的倍数。

L = range(1, 101)print L[-10:]print L[-46::5]

python之对字符串进行切片
字符串 'xxx'和 Unicode字符串 u'xxx'也可以看成是一种list，每个元素就是一个字符。因此，字符串也可以用切片操作，只是操作结果仍是字符串：


把字符串首字母变成大写

def firstCharUpper(s):    return s[:1].upper()+s[1:]print firstCharUpper('hello')print firstCharUpper('sunday')print firstCharUpper('september')

Hello
Sunday
September






python之迭代
在Python中，如果给定一个list或tuple，我们可以通过for循环来遍历这个list或tuple，这种遍历我们成为迭代（Iteration）。


注意: 集合是指包含一组元素的数据结构，我们已经介绍的包括：
1. 有序集合：list，tuple，str和unicode；
2. 无序集合：set
3. 无序集合并且具有 key-value 对：dict


找到在1-100以内7的倍数

for i in range(1,101):    if i%7==0:        print i    else:        continue

python之索引迭代
Python中，迭代永远是取出元素本身，而非元素的索引。


对于有序集合，元素确实是有索引的。有的时候，我们确实想在 for 循环中拿到索引，怎么办？


方法是使用 enumerate() 函数：

>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']>>> for index, name in enumerate(L):...     print index, '-', name

... 
0 - Adam
1 - Lisa
2 - Bart
3 - Paul


使用 enumerate() 函数，我们可以在for循环中同时绑定索引index和元素name。但是，这不是 enumerate() 的特殊语法。实际上，enumerate() 函数把：
['Adam', 'Lisa', 'Bart', 'Paul']


变成了类似：

[(0, 'Adam'), (1, 'Lisa'), (2, 'Bart'), (3, 'Paul')]

因此，迭代的每一个元素实际上是一个tuple：

for t in enumerate(L):    index = t[0]    name = t[1]    print index, '-', name

zip()函数可以把两个 list 变成一个 list：

>>> zip([10, 20, 30], ['A', 'B', 'C'])[(10, 'A'), (20, 'B'), (30, 'C')]

打出名字+名次

L = ['Adam', 'Lisa', 'Bart', 'Paul']S=zip(range(1,len(L)+1),L)for index, name in S:    print index, '-', name

result:
1 - Adam
2 - Lisa
3 - Bart
4 - Paul


迭代dict的value

d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }print d.values()# [85, 95, 59]for v in d.values():    print v# 85# 95# 59

可以使用dict.values()或者dict.itervalues() 两个效果完全一样


两个方法有何不同之处呢？


1. values() 方法实际上把一个 dict 转换成了包含 value 的list。

2. 但是 itervalues() 方法不会转换，它会在迭代过程中依次从 dict 中取出 value，所以 itervalues() 方法比 values() 方法节省了生成 list 所需的内存。

3. 打印 itervalues() 发现它返回一个 <dictionary-valueiterator> 对象，这说明在Python中，for 循环可作用的迭代对象远不止 list，tuple，str，unicode，dict等，任何可迭代对象都可以作用于for循环，而内部如何迭代我们通常并不用关心。

如果一个对象说自己可迭代，那我们就直接用 for 循环去迭代它，可见，迭代是一种抽象的数据操作，它不对迭代对象内部的数据有任何要求。

迭代dict的key和value

我们了解了如何迭代 dict 的key和value，那么，在一个 for 循环中，能否同时迭代 key和value？答案是肯定的。

首先，我们看看 dict 对象的 items() 方法返回的值：

>>> d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }>>> print d.items()[('Lisa', 85), ('Adam', 95), ('Bart', 59)]

可以看到，items() 方法把dict对象转换成了包含tuple的list，我们对这个list进行迭代，可以同时获得key和value：

>>> for key, value in d.items():...     print key, ':', value... Lisa : 85Adam : 95Bart : 59

和 values() 有一个 itervalues() 类似， items() 也有一个对应的 iteritems()，iteritems() 不把dict转换成list，而是在迭代过程中不断给出 tuple，所以， iteritems() 不占用额外的内存。

python之生成列表

>>> L = []>>> for x in range(1, 11):...    L.append(x * x)... >>> L[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

生成列表

>>> [x * x for x in range(1, 11)][1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

range(1, 100, 2) 可以生成list [1, 3, 5, 7, 9,...]
range()函数包括起始，不包括末尾也就是生成的最大数为99


请利用列表生成式生成列表 [1x2, 3x4, 5x6, 7x8, ..., 99x100]

print [x*(x+1) for x in range(1,100,2)]

复杂表达式：

tds = ['<tr><td>%s</td><td>%s</td></tr>' % (name, score) for name, score in d.iteritems()]print '<table>'print '<tr><th>Name</th><th>Score</th><tr>'print '\n'.join(tds)print '</table>'

注：字符串可以通过 % 进行格式化，用指定的参数替代 %s。字符串的join()方法可以把一个 list 拼接成一个字符串。


把打印出来的结果保存为一个html文件，就可以在浏览器中看到效果了：

<table border="1"><tr><th>Name</th><th>Score</th><tr><tr><td>Lisa</td><td>85</td></tr><tr><td>Adam</td><td>95</td></tr><tr><td>Bart</td><td>59</td></tr></table>

在生成的表格中，对于没有及格的同学，请把分数标记为红色。


提示：红色可以用 <td style="color:red"> 实现。

d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }def generate_tr(name, score):    if score<60:        return '<tr><td>%s</td><td style="color:red">%s</td></tr>' % (name, score)    return '<tr><td>%s</td><td>%s</td></tr>' % (name, score)tds = [generate_tr(name,score) for name, score in d.iteritems()]print '<table border="1">'print '<tr><th>Name</th><th>Score</th><tr>'print '\n'.join(tds)print '</table>'

条件过滤：

>>> [x * x for x in range(1, 11) if x % 2 == 0][4, 16, 36, 64, 100]

遍历之后进行条件过滤最后才是x.upper()

#def toUppers(L):    #for x in L:    #   if(isinstance(x,str)):     #       return upper(x)          #return [x]def toUppers(L):    return [x.upper() for x in L if isinstance(x, str)]print toUppers(['Hello', 'world', 101])result：['HELLO', 'WORLD']

多层表达式

>>> [m + n for m in 'ABC' for n in '123']['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']

翻译成循环代码就像下面这样：

L = []for m in 'ABC':    for n in '123':        L.append(m + n)

找出对称的三位数：

print [100*n1+10*n2+n3 for n1 in range(1,10) for n2 in range(0,10) for n3 in range(0,10) if n1==n3]