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<99
print 0xff==255

123456
learn Python in mooc
learn Python in mooc
False
True

python print 语句

print 300+100
print 400
print '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 / 4
print 7.5/8
print 11/4
print 11%4
print 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'
python
world

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]=1
print t 

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

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

python 条件判断和循环

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


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


if

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

print 'END'

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

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

if-elif-else

score = 85
if 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.0
for x in L:
   sum=sum+x
print sum / 4 #2500

while循环

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

break退出循环

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

continue继续循环

sum = 0
x = 0
while True:
    x = x + 1
    if x>100:
       break
    if x%2==0:
        continue
    sum =sum+x
print 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 s
result: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
... 
Lisa
Adam
Bart

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 sum

print square_of_sum([1, 2, 3, 4, 5])

print square_of_sum([-5, 0, 5, 15, 25])

result:55
       900


python之函数返回多值

import math
def 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 : 85
Adam : 95
Bart : 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]