Python基础

变量和数据类型

一、整数
十六进制用0x前缀和0-9，a-f表示，例如：0xff00,0xa5b4c3d2

整数和浮点数混合运算的结果变成浮点数。整数除法，除不尽时，结果仍是整数，余数直接被扔掉。同时，Python提供了一个求余的运算%可以计算余数11%4

如果要计算11/4的精确结果，按照“整数和浮点数混合运算的结果是浮点数”的法则，把两个数中的一个变成浮点数再运算即可。

二、浮点数
把10用e表示，1.23x10^9就是1.23e9,0.000012可以写成1.2e-5
整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（包括除法运算），而浮点数运算则可能会有四舍五入的误差。

三、字符串

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

a = True
print a and ‘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解释器在做布尔运算时，只要提前确定计算结果，直接返回结果。

五、空值
空值是Python里一个特殊的值，用None表示

此外，Python还提供了列表、字典等多种数据类型，还允许创建自定义数据类型。

print语句
多个字符串，用逗号“，”隔开，输出空格

变量
变量名必须是大小写英文、数字和下划线（_）的组合，且不能用数字开头

转义符
字符串包括 ‘和“，需要用\对某些特殊字符进行”转义“，转义字符\不计入字符串的内容中

#常用转义字符
\n    表示换行
\t    表示一个制表符
\\    表示 \ 字符本身

raw与多行字符串
多行字符串转义，在前面加前缀r，表示这是一个raw字符串，里面的字符不需要转义。但r‘. . .‘不能表示多行字符串，也不能表示包含’和“的字符串

表示多行字符串，可以用‘‘‘...‘‘‘

‘‘‘Line 1
Line 2
Line 3‘‘‘

#等同于
‘Line 1\nLine 2\nLine 3’

还可以在多行字符串前面添加r,把多行字符串变为raw字符串

r‘‘‘Python is created by "Guido".
It is free and easy to learn.
Let‘s start learn Python in imooc!‘‘‘

Unicode字符串
计算机智能处理数字，如果要处理文本，必须先把文本转换为数字才能处理。最早的计算机在设计时采用8个比特（bit）作为一个字节（byte），所以，一个字节能表示的最大整数就是255，0-255被用来表示大小写英文字母、数字和一些符号，这个编码表被称为ASCII编码。

要表示中文，至少需要两个字节，而且不能喝ASCII编码冲突，所以，中国制订了GB2312编码。类似的，日文和韩文等其他语言也有这个问题。为了统一所有文字的编码，Unicode应运而生。Unicode通常用两个字节表示一个字符，原有的英文编码从单字节变成双字节，只需要把高字节全部填为0即可。

因为Python的诞生比Unicode标准发布的时间要早，所以最早额Python只支持ASCII编码。后来添加了对Unicode的支持，以Unicode表示的字符串用u‘...‘

print u‘中文‘

Unicode字符串除了多一个u外，与普通字符串没有区别，转义字符和多行表示仍然有效。

如果中文字符串在Python环境下遇到UnicodeDecodeError，这是因为.py文件保存的格式有问题。可以在第一行添加注释

# - *-coding: utf-8-*-

List和Tuple类型

创建List
Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。

由于Python是动态语言，所以list中包含的元素并不要求都必须是同一种数据类型。

按照索引访问list
索引从0开始，第一个元素的索引是0，第二个元素的索引是1，以此类推。

倒序访问list
可以用-1这个索引来表示最后一个元素，倒数第二用-2，以此类推。

添加新元素
用list的append()方法，把新元素追加到list的末尾。append()总是把新的元素添加到list的尾部。

用list的insert()方法，它接受两个参数，第一个参数是索引号，第二个参数是待添加的新元素

L = [‘Adam‘,‘Lisa‘,‘Bart‘]
L.insert(0,‘Paul‘)
print L
[‘Paul‘,‘Adam‘,‘Lisa‘,‘Bart‘]
# L.insert(0,‘Paul‘)，‘Paul‘将被添加到索引为0的位置，其它元素自动向后移动一位。

从list删除元素
如果元素在最后一位，可以用list的pop()方法删除。pop()方法总是删除list的最后一个元素，并且它还返回这个元素，所以执行L.pop()后，会打印这个元素。

如果元素不是最后一位，则先定位元素位置，比如第三位，再用pop(2)把元素删除。后面的元素位置自动往前移动一位。

替换元素
对list中的某一个索引赋值，可以直接用新的元素替换掉原来的元素，list包含的元素个数保持不变。由于末尾元素可以用-1做索引，因此，可以用L[-1]完成替换。

创建tuple
tuple是另一种有序的列表，中文为“元组”。tuple和list非常类似，但是，tuple一旦创建完毕，就不能修改。
创建tuple和创建list唯一不同之处是用()替代[]

创建单元素tuple
包含0个元素的tuple，也就是空tuple，直接用()表示

t = ()
print t
# ()

t = (1)
print t
# 1

因为()既可以表示tuple，又可以作为括号表示运算时的优先级，结果(1)被Python解释器计算出结果1，导致得到的不是tuple，而是整数1。

正是因为()定义单元素的tuple有歧义，所以Python规定，单元素tuple要多加一个逗号”,”，这样就避免了歧义。

t = (1,)
print t
# (1,)

Python在打印单元素tuple时，自动添加了一个“，”,更明确地告知这是一个tuple。

“可变”的tuple

#“可变”的tuple
t = (‘a‘,‘b‘,[‘A‘,‘B‘])

注意到t有3个元素：’a’，’b’和一个list：[‘A’,’B’]。list作为一个整体是tuple的第3个元素。list对象可以通过t[2]获得。

tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是指，tuple的每个元素，指向永远不变。即指向’a’，就不能改成指向’b’，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的。

条件判断和循环

if语句
注意：Python代码的缩进规则。具有相同缩进的代码被视为代码块，if语句后接表达式，用：表示代码块开始。
Python缩进的习惯写法：4个空格，不要使用Tab，更不要混合Tab和空格，否则很容易造成因为缩进引起的语法错误。
如果在Python交互环境下写代码，还要特别留意缩进，并且推出缩进需要多敲一行回车

if-else

if age >= 18:
    print ‘adult‘
else:
    print ‘teenager‘

if-elif-else
特别注意：这一系列条件判断会从上到下依次判断，如果某个判断为True，执行完对应的代码块，后面的条件判断就直接忽略，不再执行。

if age >= 18:
    print ‘adult‘
elif age >= 6:
    print ‘teenager‘
elif age >= 3:
    print ‘kid‘
else:
    print ‘baby‘

for循环

L = [‘Adam‘,‘Lisa‘,‘Bart‘]
for name in L:
print name

注意：name这个变量是在for循环中定义的，依次取出list中的每一个元素，并把元素赋值给name，然后执行for循环体。

while循环

break退出循环
2的N次方2**n，判断偶数n%2 == 0

continue继续循环
在循环过程中，可以用break退出当前循环，还可以用continue跳过后续循环代码，继续下一次循环。

多重循环

Dict和Set类型

字典dict
用dict表示“名字”-“成绩”的查找表：

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

把名字称为key，对应的成绩称为value，dict通过key来查找value。
花括号{}表示这是一个dict，然后按照key:value，写出来即可。最后一个key:value的逗号可以省略。

由于dict也是集合，len()函数可以计算任意集合的大小

访问dict
使用d[key]的形式来查找对应的value，这和list很像，不同之处是，list必须使用索引返回对应的元素，而dict使用key

要避免KeyError发生，有两个办法：
一是先判断一下key是否存在，用in操作符：

if ‘Paul‘ in d:
    print d[‘Paul‘]

如果’Paul’不存在，if语句判断为False

二是使用dict本身提供的一个get方法，在key不存在的时候，返回None：

print d.get(‘Paul‘)
# None

dict的特点
dict的第一个特点是查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。
不过，dict的查找速度快不是没有代价的，dict的缺点是占用内存大，还会浪费很多内容，list正好相反。
由于dict是按key查找，所以，在一个dict中，key不能重复。

dict的第二个特点就是存储的key-value序对是没有顺序的，这和list不一样。dict内部是无序的，不能用dict存储有序的集合。

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

不可变这个限制仅作用于key，value是否可变无所谓。

更新dict

d={
    ‘Adam‘:95,
    ‘Lisa‘:85,
    ‘Bart‘:59
}
#把新的元素加进去，用赋值语句
d[‘Paul‘] = 72

遍历dict

#使用for循环遍历如下的dict，打印出name:score来。
d={
    ‘Adam‘:95,
    ‘Lisa‘:85,
    ‘Bart‘:59
}
for key in d:
    print key,‘:‘,d[key]

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

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

创建set的方式是调用set()并传入一个list，list的元素将作为set的元素，set内部存储的元素是无序的。set不能包含重复的元素

s = set([‘A‘,‘B‘,‘C‘])

访问set
由于set存储的是无需集合，所以无法通过索引来访问。访问set中的某个元素实际上就是判断一个元素是否在set中。可以用in操作符判断，区别大小写

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

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

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

遍历set
注意：for循环在遍历set时，元素的顺序和list的顺序很可能不同，而且不同的机器上运行的结果也可能不同。

#用for循环遍历如下的set，打印出name:score来。
s = set([(‘Adam‘,95),(‘Lisa‘,85),(‘Bart‘,59)])
for x in s:
    print x[0],‘:‘,x[1]

更新set
由于set存储的是一组不重复的无序元素，因此，更新set主要做两件事：
一是新的元素添加到set中，二是把已有元素从set中删除。

添加元素时，用set的add()方法，如果添加的元素已经存在于set中，add()不会报错，但是元素不会加入set中。

s = set([1,2,3])
s.add(4)
print s

删除set中的元素时，用set的remove()方法，如果删除的元素不存在set中，remove()会报错。
所以用add()可以直接添加，而remove()前需要判断。

#针对下面的set，给定一个list，对list中的每一个元素，如果在list中，就将其删除，如果不在set中，就添加进去。

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
函数

调用函数
调用函数的时候，如果传入的参数数量不对，会报TypeError的错误，并且Python会明确地告诉你：abd()有且仅有1个参数，但给出了两个。

如果传入的参数数量是对的，但参数类型不能被函数所接受，也会报TypeError的错误，并且给出错误信息：str是错误的参数类型。

比较函数cmp(x,y)就需要两个参数，如果x < y，返回-1；如果x == y，返回0；如果x > y，返回1

Python内置的常用函数还包括数据类型转换函数，比如，int()函数可以把其他数据类型转换为整数，str()函数把其他类型转换为str

#sum()函数接受一个list作为参数，并返回list所有元素之和。请计算1*1+2*2+3*3+...+100*100
L = []
x = 1
while x <= 100:
    L.append(x * x)
    x = x + 1
print sum(L)

编写函数
在Python中，定义一个函数使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。

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

#定义一个square_of_sum函数，它接受一个list，返回list中每个元素平方的和。
def square_of_sum(L):
    sum = 0
    for x in L:
        sum = sum + x*x
    return sum
print square_of_sum([1,2,3,4,5])

返回多值
math包提供了sin()和cos()函数，可以先用import引用它。

Python的函数返回多值其实就是返回一个tuple

递归函数
如果一个函数在内部调用自身，这个函数就是递归函数。

计算阶乘用函数fact()表示，fact()可以表示为n*fact(n-1)，只有n=1时需要特殊处理。

使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈(stack)这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。

定义默认参数
Python自带的int()函数，其实有两个参数，既可以传一个参数，又可以传两个参数。
int()函数的第二个参数是转换进制。

函数的默认参数的作用是简化调用，只需要把必须的参数传进去，又可以传入额外的参数覆盖默认参数值。

由于函数的参数按从左到右的顺序匹配，所以默认参数只能定义在必需参数的后面

#定义一个greet()函数，包含一个默认参数，如果没有传入，打印‘Hello,world.’，如果传入，打印‘Hello,xxx.‘
def greet(name=‘World‘):
    print ‘Hello,‘+name+‘.‘
greet ()
greet(‘Bart‘)　

定义可变参数
如果让一个函数能接受任意个参数，可以定义一个可变参数：

def fn(*args)
    print args

Python解释器把传入的一组参数组装成一个tuple传递给可变参数，因此，在函数内部，直接把变量args看成一个tuple

#编写接受可变参数的average()函数。
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)

切片

对list进行切片
对于经常取指定索引范围的操作，用循环十分繁琐，因此，Python提供了切片Slice操作符，能大大简化这种操作。

#取前3个元素，用一行代码可以完成切片
L[0:3]    表示，从索引0开始取，直到索引3为止，但不包括索引3
L[:3]    如果第一个索引是0，还可以省略
L[1:3]    从索引1开始，取出2个元素
L[:]        表示从头到尾，实际上复制了一个新list

切片操作还可以指定第三个参数
L[::2]    第三个参数表示每N个取一个，上面的L[::2]会每两个元素取出一个，也就是隔一个取一个

把list换成tuple，切片操作完全相同。

#range()函数可以创建一个数列：
range(1,101)
[1,2,3,...,100]
利用切片，取出
1、3的倍数
2、不大于50的5的倍数

L = range(1，101)

print L[2::3]
print L[4:50:5]或print L[-10:][4::5]

倒序切片
倒数第一个元素的索引是-1。倒叙切片包含起始索引，不包含结束索引。

#利用倒序切片对1-100的数列取出：
最后10个5的倍数
L = range(1,101)
print L[4::5][-10:]

对字符串切片
Python没有针对字符串的截取函数，只需要切片一个操作就可以完成。

字符串upper()方法可以把字符变成大写字母：‘abc‘.upper()–>ABC，但它会把所有字母都变成大写。

#设计一个函数，接受一个字符串，然后返回一个仅首字母变成大写的字符串
def firstCharUpper(s):
    return s[:1].upper()+s[1:]
print firstCharUpper(‘hello‘)

迭代

在Python中，如果给定一个list或tuple，可以通过for循环来遍历这个list或tuple，这种遍历称为迭代(Iteration)。在Python中，迭代是通过for...in来完成。可以看出，Python的for循环抽象程序程度要高于Java的for循环。

for (i=0;i<list.length;i++){
    n=list[i];    
}

因为Python的for循环不仅可以用在list或tuple上，还可以作用在其他任何可迭代对象上。
因此，迭代操作就是对于一个集合，无论该集合是有序还有无序，用for循环总是可以依次取出集合的每一个元素。

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

迭代是一个动词，它指的是一种操作，在Python中，就是for循环。

迭代与按下标访问数组最大的不同是，后者是一种具体的迭代实现方式，而前者只关心迭代结果，根本不关心迭代内部是如何实现。

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

对于有序集合，元素确实是有索引的。方法是使用enumerate()函数

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

使用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

每个tuple元素都包含两个元素，for循环又可以进一步简写为：

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

这样不但代码更简单，而且还少了两条赋值语句。

可见，索引迭代不是真的按索引访问，而是由enumerate()函数自动把每个元素变成(index,element)这样的tuple，再迭代，就同时获得了索引和元素本身。

#zip()函数可以把两个list变成一个list：
zip([1,2,3],[‘A‘,‘B‘,‘C‘])
[(1,‘A‘),(2,‘B‘),(3,‘C‘)]

迭代dict的value
dict对象本身就是可迭代对象，用for循环直接迭代dict，可以每次拿到dict的一个key。

dict对象有一个values()方法，这个方法把dict转换成一个包含所有value的list，这样，迭代的就是dict的每一个value

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

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

两个方法不同之处：
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
在一个for循环中，同时迭代key和value。dict对象的items()方法返回的值。

print d.items()

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

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

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

列表生成式

生成列表

#生成[1x1,2x2,...,10x10]
方法一是循环：
L = []
for x in range(1,11):
    L.append(x*x)

方法二：循环太繁琐，而列表生成式则可以用一行语句代替循环生成上面的list：
[x*x for x in range(1,11)]

这种写法就是Python特有的列表生成式。利用列表生成式，可以以非常简洁的代码生成list
写列表生成式时，把要生成的元素x*x放到前面，后面跟for循环，就可以了把list创建出来。

#利用列表生成式生成列表[1x2,3x4,...,99x100]
print [x*(x+1) for x in range(1,100,2)]

复杂表达式
使用for循环的迭代不仅可以迭代普通的list，还可以迭代dict。

d = {‘Adam‘:95,‘Lisa‘:85,‘Bart‘:59}
#可以通过一个复杂的列表生成式把它变成一个HTML表格
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文件，即可在浏览器中看到效果。

条件过滤
列表生成式的for循环后面还可以加上if判断

1，isinstance(x,str)可以判断变量x是否是字符串
2，字符串的upper()方法可以返回大写的字母

#编写一个函数，它接受一个list，然后把list中的所有字符串变成大写后返回，非字符串元素将被忽略。
def toUppers(L):
    return [str.upper(x) for x in L if isinstance(x,str)]
print toUppers([‘Hello‘,‘world‘,101])

多层表达式
for循环可以嵌套，因此，在列表生成式中，也可以用多层for循环来生成列表。

#对于字符串‘ABC‘和‘123‘，可以使用两层循环，生成全排列
[m+n for m in ‘ABC‘ for n in ‘123‘]

#翻译成循环代码
L=[]
for m in ‘ABC‘:
    for n in ‘123‘:
        L.append(m+n)

#利用3层for循环的列表生成式，找到对称的3位数。
print [int(str(a)+str[b]+str[c]) for a in range(1,10) for b in range(10) for c in range(1,10) if a==c]