Python入门学习

学习资源来源：慕课网Python入门

注释

单行注释#
多行注释''' ''''
注释中文# -*- coding:utf-8 -*

print语句

Python2 里面print可以直接接字符串或者运算。
Python3 里面print变成了一个函数，必须用一个括号括起来，否则会报告语法错误。
print语句也可以跟上多个字符串，用逗号“,”隔开，就可以连成一串输出：print会依次打印每个字符串，遇到逗号“,”会输出一个空格

数据类型

1.整数：可以处理任意大小的的整数，二进制0,1,-1，十六进制0xff78，计算机内部存储为精确的
2.浮点数：3.14,1.23e9,4.56e-5，计算机内部存储可能有四舍五入的误差
3.字符串：''或""包含的为字符串 'hello world',"haha"
   转换大写 'abc'.upper()
4.布尔值：只有True、False，可以用and、or、not运算
5.空值 None
6.列表list l=['hello',123,True] list中包含的元素并不要求都必须是同一种数据类型，可以包含各种数据
   空list emptylist=[]
   访问元素 L[0],L[1],L[-1]
   追加元素 L.append('new')
   插入元素 L.insert(0,'first')
   删除元素 L.pop(),L.pop(2)
   替换元素 L[2]='newone'
   切片 L[0:3],L[:3],L[:],L[2:3],L[::2](第三个参数表示每N个取一个) 切片包含起始索引，不包含结束索引
   倒序切片 L[-2:],L[:-2],L[-3:-1],L[-4:-1:2] 倒序切片包含起始索引，不包含结束索引
7.元组：tuple t=('hello',123,True) tuple一旦创建完毕，就不能修改了
   空tuple emptytuple=()
   单元素 tuple t=(1,)
   "可变"tuple t=(1,2,['a','b']) l=t[2] l=['x','y']
   切片 t[0:3],t[:3],t[:],t[2:3],t[::2](第三个参数表示每N个取一个) 切片包含起始索引，不包含结束索引
   倒序切片 t[-2:],t[:-2],t[-3:-1],t[-4:-1:2] 倒序切片包含起始索引，不包含结束索引
8.字典dict 花括号 {} 表示这是一个dict，然后按照 key: value, 写出来即可
   d = {
       'Adam': 95,
       'Lisa': 85,
       'Bart': 59
   }
   访问元素 d['key'] d.get('key')返回value或者none
   遍历元素 for key in d:
   dict的第一个特点是查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降
   不过dict的查找速度快不是没有代价的，dict的缺点是占用内存大，还会浪费很多内容，list正好相反，占用内存小，但是查找速度慢
   由于dict是按 key 查找，所以，在一个dict中，key不能重复
   dict的第二个特点就是存储的key-value序对是没有顺序的
   dict的第三个特点是作为 key 的元素必须不可变，Python的基本类型如字符串、整数、浮点数都是不可变的，都可以作为 key
9.集合set 持有一系列元素，但是元素没有重复，而且是无序的
   s = set(['A', 'B', 'C', 'C'])=>s = set(['A', 'B', 'C'])
   访问元素 访问set中的某个元素实际上就是判断一个元素是否在set中 'A' in s
   添加元素 s.add(member)
   删除元素 s.remove(member) 如不存在则会报错
   set的内部结构和dict很像，唯一区别是不存储value，因此，判断一个元素是否在set中速度很快
   set存储的元素和dict的key类似，必须是不变对象，因此，任何可变对象是不能放入set中的
   set存储的元素也是没有顺序的
 

变量

变量名为英文和数字的组合，开头不能是数字
可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以是不同类型的变量
字符串变量在内存的表示，如a='ABC'
1. 在内存中创建了一个'ABC'的字符串；
2. 在内存中创建了一个名为a的变量，并把它指向'ABC'
b=a，实际为创建了变量b，并把b指向a指向的字符串'ABC'

字符串

转义\n \' \" \\
单行转义前缀r''
多行转义前缀r''' ''''
Unicode码
u'显示中文'
u'''多行
显示中文'''
# -*- coding: utf-8 -*-目的是告诉Python解释器，用UTF-8编码读取源代码。
    

逻辑运算

Python把0、空字符串''和None看成 False，其他数值和非空字符串都看成 True

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解释器在做布尔运算时，只要能提前确定计算结果，它就不会往后算了，直接返回结果。

if语句

Python代码的缩进规则：具有相同缩进的代码被视为代码块。缩进习惯写法：4个空格，不要使用Tab，更不要混合Tab和空格
if、else、elif语句后接表达式，然后用:表示代码块开始

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

for循环

Python的 for 循环就可以依次把list或tuple的每个元素迭代出来

for name in L:
    print name

   

while循环

while 循环根据表达式判断循环是否结束
如果没有这一个语句，while循环在判断 x < N 时总是为True，就会无限循环下去，变成死循环

while x < N:
    print x
    x = x + 1

   

break退出循环

用 for 循环或者 while 循环时，如果要在循环体内直接退出循环，可以使用 break 语句

continue继续循环

在循环过程中，用continue跳过后续循环代码，继续下一次循环

函数

定义一个函数要使用 def 语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用 return 语句返回
函数体内部的语句在执行时，一旦执行到return时，函数就执行完毕，并将结果返回。因此，函数内部通过条件判断和循环可以实现非常复杂的逻辑
如果没有return语句，函数执行完毕后也会返回结果，只是结果为 None
Python的函数返回多值其实就是返回一个tuple
默认参数 简化调用，你只需要把必须的参数传进去。又可以传入额外的参数来覆盖默认参数值。由于函数的参数按从左到右的顺序匹配，所以默认参数只能定义在必需参数的后面

def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

定义可变参数，如果想让一个函数能接受任意个参数，可以定义一个可变参数：def fn(*args):

迭代

Python 的 for循环不仅可以用在list或tuple上，还可以作用在其他任何可迭代对象上
因此，迭代操作就是对于一个集合，无论该集合是有序还是无序，我们用 for 循环总是可以依次取出集合的每一个元素
注意: 集合是指包含一组元素的数据结构，我们已经介绍的包括：
1. 有序集合：list，tuple，str和unicode；
2. 无序集合：set
3. 无序集合并且具有 key-value 对：dict
迭代是一个动词，它指的是一种操作，在Python中，就是 for 循环。

索引迭代

Python中，迭代永远是取出元素本身，而非元素的索引。
对于有序集合，元素确实是有索引的。想在 for 循环中拿到索引，需要使用 enumerate() 函数，我们可以在for循环中同时绑定索引index和元素

def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

实际上，enumerate() 函数把：['Adam', 'Lisa', 'Bart', 'Paul']
变成了类似：[(0, 'Adam'), (1, 'Lisa'), (2, 'Bart'), (3, 'Paul')]
因此，迭代的每一个元素实际上是一个tuple：

def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

如果我们知道每个tuple元素都包含两个元素，for循环又可以进一步简写为：

for index, name in enumerate(L):
    print index, '-', name

这样不但代码更简单，而且还少了两条赋值语句。
可见，索引迭代也不是真的按索引访问，而是由 enumerate() 函数自动把每个元素变成 (index, element) 这样的tuple，再迭代，就同时获得了索引和元素本身。

迭代dict的value

dict 对象有一个 values() 方法，这个方法把dict转换成一个包含所有value的list

for v in d.values():
    print v

dict除了values()方法外，还有一个 itervalues() 方法，用 itervalues() 方法替代 values() 方法，迭代效果完全一样：

for v in d.itervalues():
    print v

这两个方法的区别
1. values() 方法实际上把一个 dict 转换成了包含 value 的list。
2. 但是 itervalues() 方法不会转换，它会在迭代过程中依次从 dict 中取出 value，所以 itervalues() 方法比 values() 方法节省了生成 list 所需的内存。

迭代dict的key和value

在一个 for 循环中，同时迭代 key和value

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

生成列表

range(1, 11) #[1,2,3,4,5,6,7,8,9,10]
range(1, 11, 2) #[1,3,5,7,9]
for x in range(1, 11):
    L.append(x * x)
[x * x for x in range(1, 11)] #[1,4,9,16,25,36,49,64,81,100]
[x * x for x in range(1, 11) if x % 2 == 0] #[4,16,36,64,100]
[m + n for m in 'ABC' for n in '123'] #['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']