Python萌新快速上手+老鸟案例

Python变量和数据类型

数据类型

计算机可以处理数据，同时可以处理文本、图形、音频、视频、网页等其他数据，不同的数据，需要定义不同的数据类型。如下类型是Python中能够直接处理的数据类型。

整数

概述

Python中可以处理任意大小的整数

表示

与数学上的写法一模一样

例子

十六进制用0x前缀表示，如【0xff00】

浮点数

概述

小数点位置可变

表示

用e代替10

例子

如【1.29e9 == 1.23*10^9】

强调

整数和浮点数在计算机内部存储方式是不同的，整数运算永远是精确的，而浮点数运算则可能会有四舍五入的误差

字符串

概述

表示文本，用字符数组来表示

表示

用‘’或者“”括起来的人以文本

例子

如【"abc",'abc'】

特例

a.若其中包含‘’，“”，则用转义字符来进行转义\",\'

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

布尔值

概述

与布尔代数完全一致

表示

True、False

例子

and、or、not运算

a = True
print a and 'a=T' or 'a=F'
//=====结果是'a=T'
原因：
1. 0，空字符串''和None被视为False
2. 其他被视为True
3. 且存在and,or的短路计算
所以：
1. a and 'a=T'因为a是True，所以结果取决于'a=T'
2. 'a=T' or 'a=F'在or中若第一个为1即T，为0则F，所以取决于'a=T'
便返回了'a=T'

空值

概述

特殊的值

表示

用None进行表示

强调

不可理解为0，因为0是有意义的

基本操作

print

语句：print 'hello world!'   #单引号双引号都可以

对于\\转义字符，用r'...'可以省略，但是不可包含'',""以免对应错误。raw字符串中转义字符无用

Unicode中对中国文字进行了编码支持GB2312.

表示多行字符可用'''xxx'''方法。且Print中一般先识别此符号

'''Line1
Line2
Line3'''
等同于'Line1\nLine2\nLine3'

print '''''''               报错

print ''''
‘’‘                         正常输出一个'

print u'中文'                输出中文

预留问题，为什么raw字符串中不可以有”或者”

注释

以#开头，为简单的行注释

变量

命名规范

大小写英文+数字+下划线，不可用数字开头

静态语言和动态语言

例子a=’ABC’

a.在内存中创建了一个字符串'ABC'

b.在内存中创建了一个名为a的变量，并把它指向'ABC‘

c.若把变量啊赋值给另一个变量b【b==a】，则是把变量b指向变量a所指向的数据

集合

List类型

内置的一种数据类型，列表。List是一种有序的集合，且符合数学意义，可以随时添加和删除其中的元素。

构造

直接用[ ]把list的所有元素括起来

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

空列表

classmates = ['Michael','Bob','Mary']

L = ['Michael',100,True']

empty_List = [ ]

按索引访问List

索引排列仍为0-(n-1)

倒序索引，倒序第一个为-1，往前推

>>> classmates = ['Michael','Bob','Mary']
>>> classmates[2]
'Mary'

>>> classmates[-1]
'Mary'
>>> classmates[-2]
'Bob'

List中添加和删除元素

添加新元素----在末尾添加元素

添加新元素----在某个位置上添加元素，并把原来此位置上的元素和后面的元素统一向后移

删除元素----删除List中的最后一个元素，并且返回这个元素

删除元素----删除List中的某个位置上的元素，再把此位置之后的元素提前

>>> classmates.append('newappend')
>>> classmates
['Michael', 'Bob', 'Mary', 'newappend']

>>> classmates.insert(0,'0newinsert')
>>> classmates
['0newinsert', 'Michael', 'Bob', 'Mary', 'newappend']

>>> classmates.pop()
'newappend'
>>> classmates
['0newinsert', 'Michael', 'Bob', 'Mary']

>>> classmates.pop(0)
'0newinsert'
>>> classmates
['Michael', 'Bob', 'Mary']

判断是否在List中存在

>>> a = [1,2,3]
>>> 1 in a
True
>>> 8 in a
False
>>> 8 not in a
True

对List进行切片提取

a[l:r]从第l个索引一直提取到第r个索引但不包括第r个索引所对应的值

若第一个索引为0，可以省略

单一个:即从头到尾

第三个参数
10673
是step的含义

倒序切片

>>> a
[0, 1, 2, 3]
>>> a[1:3]
[1, 2]

>>> a[:3]
[0, 1, 2]
>>> a[0:3]
[0, 1, 2]

>>> a[:]

>>> a[0:4:2]
[0, 2]

>>> a[-3:-1]
[2, 3]

List和Matlab中数组的区别

Matlab	Python	备注
直接索引 a = [1,2,3,4]	a(4) -> 4	a[3] -> 4 a[-1] ->4
间隔索引 a = [1,2,3,4]	a(1:2:4) = 1,3	a[1:2:4] = 2
全索引	a(:)会使得向量变成列向量	a[:]List属性不改变
操作	符合线性代数	用生成列表式来进行操作

Tuple类型

有序列表，中文翻译为”元组“。一旦创建完毕便不可修改

构造

直接用( )把list的所有元素括起来

空列表

单元素有歧义，添加','来避免歧义

>>> t = ('a','b','c')
>>> t
('a', 'b', 'c')

>>> a = ()
>>> a
()

>>> t = ('Adam')
>>> t           #被误解为字符串
'Adam'
>>> t = ('Adam',)
>>> t
('Adam',)       #添加一个,来说明这是一个tuple
>>> t = ('Adam','jkl',)
>>> t
('Adam', 'jkl') #若多元素，最后一个,将被省略

”可变“的Tuple

即tuple每个元素的指向都不会变，都指向原来内存中新建的数据的位置。所以tuple值的还是原来的List，但是这个List中的元素的指向变了。所以不是Tuple自身变了

>>> t = (1,2,['a','b'])
>>> t
(1, 2, ['a', 'b'])

>>> prt = t[2]
>>> prt[0] = 'x'
>>> prt[1] = 'y'

>>> t
(1, 2, ['x', 'y'])

Dict类型

Dict为查找表，通过key-value来对应，进行值的查找；

Dict创建

创建key-value

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

Dict访问

通过key来访问

KeyError返回key不存在的错误。可用if语句、或Dict实例所有的方法get来防止出现错误

>>> d['Lisa']
85

>>> d['a']
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'a'
>>> if 'a' in d:
...     print d['a']

>>> d.get('a')
>>> d.get('Lisa')
85

Dict特点

Dict查找速度快。查找速度不会随着元素的数量增加而增加。而List的查找速度随着元素增加而逐渐下降。

Dict占用内存大，还会浪费很多内容。而List占用内存小。

Dict按key查找，在一个Dict中key不能重复。

存储的key-value序对是没有顺序的。

作为key的元素是必须【不可变】的，可用字符串、整数、浮点数，而List显然是不可以用的了。

Dict增添和更新

可以直接用赋值语句来进行增加。若原来Key已经存在了，则会用心的value来代替原来的Value。

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

>>> d['angel'] = 10
>>> d
{'Lisa': 85, 'Adam': 95, 'angel': 10, 'Bart': 59}

>>> d['angel'] = 20
>>> d
{'Lisa': 85, 'Adam': 95, 'angel': 20, 'Bart': 59}

Dict遍历

通过直接遍历，可以把key直接遍历获得。

在通过d[key]来遍历元素。

>>> for k in d:
...     print k
Lisa
Adam
angel
Bart

>>> for k in d:
...     print d[k]
85
95
20
59

Dict的相关函数

keys获取键值，values获取值。values实质上把dict转换成了包含value的List，会多出内存。

itervalues获取数值。而itervalues不会转换，会在迭代过程中依次从dict中提取出value，用了时间但节省了内存。

items()方法获得包含了tuple的List。

iteritems()。而这个方法是在迭代过程中直接不断地给出tuple，不占用额外内存。

若一个对象说自己可以迭代，便可以用for去循环，对迭代对象内部的数据没有其他要求

>>> d
{'a': 11, 'b': 33}
>>> d.keys()
['a', 'b']
>>> d.values()
[11, 33]

Set类型

持有一系列元素，但是没有重复、而且是无序的。

Set创建和

>>> s = [1,1,2,3]
>>> s = set(s)
>>> s
set([1, 2, 3])

Set访问

set存储的是无序集合，所以我们无法通过索引来访问。访问set中的某个元素即判断一个元素是否在set中。

Set特点

set内部结构和dict很像，但不存储value.

set存储的元素和dict的key类似，必为不变对象.

无序.

Set遍历

>>> s
set([1, 2, 3])
>>> for i in s:
...     print i
...
1
2
3

>>> s = set([('a',95),('b',70),('c',44)])
>>> for name in s:
...     print ("%s : %d \n" % (name[0],name[1]))
...
b : 70

a : 95

c : 44

Set更新

把新的元素添加到set中

把已有元素从set中删除

注意事项：add()可直接使用，remove()防止出现KeyError错误

>>> a = [1,2,3,4,4]
>>> s = set(a)
>>> a
[1, 2, 3, 4, 4]
>>> s
set([1, 2, 3, 4])

//添加
>>> s.add(4)
>>> s
set([1, 2, 3, 4])
>>> s.add(5)
>>> s
set([1, 2, 3, 4, 5])

//移除
>>> s.remove(5)
>>> s
set([1, 2, 3, 4])
>>> s.remove(5)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 5

string

处理方法

//1
>>> s = str(123)+'hello'
>>> s
'123hello'

//2
>>> a
['a', 'b', 'c', 'd']
>>> s
'add'
>>> s = '+'
>>> s.join(a)
'a+b+c+d'

对字符串进行切片提取

>>> def FirstCharUpper(s):
...     return s[0].upper()+s[1:]
...
>>> print FirstCharUpper('hello')
Hello

汇总

表达式

List生成式

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

复杂表达式

带变量的表达式+迭代获得表达式中的变量

>>> d
{'a': 11, 'b': 33}

>>> tds = ['<tr><td>%s</td><td>%s</td></tr>'%(name,score) for name,score in d.iteritems()]

条件表达式

在for语句后方+if条件语句

>>> tds = ['<tr><td>%s</td><td>%s</td></tr>'%(name,score) for name,score in d.iteritems() if score>22]
>>> tds
['<tr><td>b</td><td>33</td></tr>']

多层表达式

>>> [m+n for m in 'ABC' for n in '123']
['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']
//等同
>>> for m in 'ABC':
...     for n in '123':
...         a.append(m+n)

逻辑

if条件语法

if condition:
statement1
statement2
elif condition1:
statement3
statement4
else:
statement5
statement6

for循环语法

for i in list/tuple:
print i

while循环语法

while x < 10:
print x

函数

函数定义语法

函数返还值的实质是返回一个Tuple

默认参数只能定义在必需参数的后面

用pass示意空函数

可以让一个函数能够接受任意参数，用*args可以定义一个可变参数。实质为把传入的实参打包成【Tuple】传递

def funcname(x):

return None == return;

return nx,ny;       #返回多个值

#空函数
def fun(a,b=2):
...     pass

索引迭代

等同于把原来的集合的每个元素e组成了(index,e)的tuple新集合

>>> a = ['a','b','c','d']
>>> for index,name in enumerate(a):
...     print index,'-',name
...
0 - a
1 - b
2 - c
3 - d
>>> for index in enumerate(a):
...     print index
...
(0, 'a')
(1, 'b')
(2, 'c')
(3, 'd')

常用函数

1.判断变量x是否是某种类型

>>> isinstance('sdf',str)
True
>>> isinstance(d,str)
False
>>> isinstance(d,dict)
True

字符串的upper()方法可以返回大写字母