1

如果list只包含几个元素，这样写还行，如果list包含1万个元素，我们就不可能写1万行print。 这时，循环就派上用场了。 Python的 for 循环就可以依次把list或tuple的每个元素迭代出来： L = ['Adam', 'Lisa', 'Bart'] for name in L: print name 注意: name 这个变量是在 for 循环中定义的，意思是，依次取出list中的每一个元素，并把元素赋值给 name，然后执行for循环体（就是缩进的代码块）。 这样一来，遍历一个list或tuple就非常容易了。

注意: else 后面有个“:”。

利用 if ... else ... 语句，我们可以根据条件表达式的值为 True 或者 False ，分别执行 if 代码块或者 else 代码块。

if语句可以判断出变量的值是否大于等于60。

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

缩进请严格按照Python的习惯写法：4个空格

Python中什么是变量

等差数列，用变量 x 表示等差数列的第一项，用 d 表示公差，请计算数列1 4 7 10 13 16 19 ... 前 100 项的和。

x = 1; #第一个
d = 3; #公差
n = 0; #个数
result = 0;  # 结果
while (n < 100):
  result+=x;
  x = (x + d); # 下一项
  n+=1;
print result;

Python中整数和浮点数

• 整数运算结果仍然是整数；

• 浮点数运算结果仍然是浮点数；

• 整数和浮点数运算结果仍然是浮点数；

Python中布尔类型

print 3 + 4;  # ==>7 整数运算
print 2.5 + 10.0;  # ==> 12.5 浮点数运算
print 2 + 10.0;  # ==> 12.0 整数和浮点数运算

truthy值： 其他数值，非空字符串

falsy值：0，空字符串''，None

短路计算

# encoding:utf-8
print(a and b);
print(True and '哈哈');  #'哈哈'
print(False and '哈哈'); #False

a = True， 结果返回b；
a = False,   结果返False；

print(True or '哈哈');  #True
print(False or '哈哈');  #'哈哈'

a = True， 结果返回True；
a = False,   结果返回b；

Python创建list

list对象

L = ["Adam", "Lisa", "Bart"]
print L

1. 取值
   print L[0];     #  "Adam"  正序取值
   print L[-1];   #  "Bart"   倒序取值
   

2. 赋值
   L[0] = 'Bart';
   L[-1] = 'Adam';
   

3. append(value) 尾部添加元素value
   L.append('Zhang');    ['Adam', 'Lisa', 'Bart','Zhang']
   

4. insert(index,value) 添加元素value到索引值index的位置，后边的元素全部后退一位
   L.insert(2,'paul')；['Adam', 'paul','Lisa', 'Bart']
   

5. pop(index) 删除元素
   L.pop()等价于L.pop(-1) 
   默认删除List的尾部倒数第一个元素
   ['Adam', 'Lisa']
   
   L.pop(0)  删除第一个元素
   [ 'Lisa', 'Bart']

tuple元组

tuple一旦创建完毕，就不能修改了。

t = ('Adam', 'Lisa', 'Bart')
print t

1. 取值    与list的取值方式相同

2. 创建单元素   
   t = ('Adam',)
   print t
   因为用()定义单元素的tuple有歧义，所以 Python 规定，单元素 tuple 要多加一个逗号“,”
   
   t = ('Adam')
   因为()既可以表示tuple，又可以作为括号表示运算时的优先级，结果 ('Adam') 被Python解释器计算出结果 'Adam'，导致我们得到的不是tuple，而是'Adam'

3. 可变的tupe
   t = ('a', 'b', ['A', 'B'])
   L = t[2]
   L[1] = 'C'
   print t        # ==>  ('a', 'b', ['A', 'C'])
   L和t[2]只指向的同一地址，也就是一个指针

切片

  L[start: stop: step]    
  start:   计数开始下标，默认从0开始，L[0:2] 等价于L[:2]
  stop:  计数结束下标，但不包含stop    
  step:  步长
  start的位置必须位于stop前边，否则无效。

L = range(1, 10)
print L  #==>  [1, 2, 3, 4, 5, 6, 7, 8, 9]
# range(start,stop[,step]);   range() 函数可创建一个整数列表

1. 正序切片
   print L[:2]   #==>  [1,2]
   print L[1:5]  #==> [2,3,4,5]
   print L[0:9:3]  #==>[1,4,7]
   

2. 倒序切片
   print L[5:-1]   #==>[6,7,8]
   print L[-4:-1]  #==>[6,7,8]
   

Python之什么是dict

dict 字典

d = {
    'Adam': 95,
    'Lisa': 85,
    'Bart': 59
}

 取值：d['Adam']     #==> 95 
 赋值：d['Bpart'] = 100
 get(key)  当key不存在的时候，返回None    
 d.get('Adam')      #==> 95

 字典是无序的

obj = {    
    'Adam': 95, 
    'Lisa': 85,
    'Bart': 59,
    'paul': 75
}

print obj  # ==>  {'Lisa': 85, 'paul': 75, 'Adam': 95, 'Bart': 59}

dict 的特点

优点：

1. 查找速度快

2. 存储的key-value序对是无序的

3. 作为key的元素是不可变的
   

缺点：

     dict 占用内存大，浪费很大内容
     list   占用内存小，查找内容慢

set 
  set  和list很像，持有一系列元素
  set  和dict的key很像，set的元素是没有重复的，并且是无序的

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

  判断一个元素是否在set中

print 'Adam' in s   # ==>  True

  方法：add(value)，remove(value)

s = set(['Adam', 'Lisa', 'Paul'])
s.add('zhang')     # ==> set(['Adam', 'Lisa', 'Paul', 'zhang'])
s.remove('Adam')  # ==> set(['Lisa', 'Paul', 'zhang'])

set特点

1. set的内部结构和dict很像，唯一区别是不存储value

2. set存储的元素和dict的key类似，必须是不变对象。同时key没有重复，也是无序的

Python之迭代

索引迭代

L = ['Adam', 'Lisa', 'Bart', 'Paul']
for index, name in enumerate(L):
    print index, '-', name
    
#  0 - Adam
#  1 - Lisa
#  2 - Bart
#  3 - Paul

print list(enumerate(L))   #[(0, 'Adam'), (1, 'Lisa'), (2, 'Bart'), (3, 'Paul')]

enumerate() 函数, 可以在for循环中同时绑定索引index和元素name。
enumerate()函数，把['Adam', 'Lisa', 'Bart', 'Paul'] 变成了类似  [(0, 'Adam'), (1, 'Lisa'), (2, 'Bart'), (3, 'Paul')];
因此迭代的每一个元素实际上是一个tuple  (0, 'Adam')

迭代dict的value

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

#  85  74  95  59

values() 和 itervalues()不同之处

1. values() 方法把一个dict转换成包含value的list

2. itervalues() 方法 在迭代过程中依次从 dict 中取出 value。节省了生成 list 所需的内存。

迭代dict的key和value

d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59, 'Paul': 74 }

print d.items()   #[('Lisa', 85), ('Paul', 74), ('Adam', 95), ('Bart', 59)]

for key, value in d.items():  
  print key, value

#  Lisa 85
#  Paul 74
#  Adam 95
#  Bart 59

 items() 和  iteritems()的区别

1.   items() 方法把dict对象转换成了包含tuple的list.
   

2.   iteritems() 方法在迭代过程中不断给出 tuple，所以， iteritems() 不占用额外的内存

   
   

Python之列表表达式

print [a*100+b*10+c for a in range(1,10) for b in range(0,10) for c in range(0,10) if a == c]
# a*100+b*10+c 输出值
# for in 表示多个嵌套循环
# if a == c 条件判断

Python之函数

内置函数，绝对值abs(val)，比较函数  cmp(x, y)，其他类型转换str str(val) ，
int(val,10)10表示10进制，sum(list)求和函数

def greet(x=1,y=2): 
    return x,y
print greet()  #==>(1, 2)
print greet(3,4)  #==>(3, 4)

函数的greet的参数x,y默认值1,2
函数的返回值是tuple

定义可变参数

def average(*args):    
    return argsprint
average(0,1,2)   #==>(0, 1, 2)

扩展知识！！

整数与浮点数混合结果是浮点数

在Python中，布尔类型还可以与其他数据类型做 and、or和not运算，请看下面的代码：

a = True
print a and 'a=T' or 'a=F'

计算结果不是布尔类型，而是字符串 'a=T'，这是为什么呢？

因为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。

所以Python解释器在做布尔运算时，只要能提前确定计算结果，它就不会往后算了，直接返回结果。

enumerate() 函数把：

['Adam', 'Lisa', 'Bart', 'Paul']

变成了类似：

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

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

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

我们可以在字符串前面加个前缀 r，表示这是一个 raw 字符串，里面的字符就不需要转义了。

要表示字符串 Bob said "I'm OK".
由于 ' 和 " 会引起歧义，因此，我们在它前面插入一个\表示这是一个普通字符，不代表字符串的起始，因此，这个字符串又可以表示为

'Bob said \"I\'m OK\".'

常用的转义字符还有：

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

Python之 多重循环

在循环内部，还可以嵌套循环，我们来看一个例子：

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

x 每循环一次，y 就会循环 3 次，这样，我们可以打印出一个全排列：

A1
A2
A3
B1
B2
B3
C1
C2
C3

任务

对100以内的两位数，请使用一个两重循环打印出所有十位数数字比个位数数字小的数，例如，23（2 < 3）。

• ?不会了怎么办

• 十位数循环从1至9，个位数循环从0至9。

  参考代码:

  for x in [1, 2, 3, 4, 5, 6, 7, 8, 9]:     for y in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]:         if x < y:             print x * 10 + y