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

---

---

Python变量和数据类型

---

数据类型

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

整数

1. 概述Python中可以处理任意大小的整数
2. 表示与数学上的写法一模一样
3. 例子十六进制用0x前缀表示，如【0xff00】

浮点数

1. 概述小数点位置可变
2. 表示用e代替10
3. 例子如【1.29e9 == 1.23*10^9】
4. 强调整数和浮点数在计算机内部存储方式是不同的，整数运算永远是精确的，而浮点数运算则可能会有四舍五入的误差

字符串

1. 概述表示文本，用字符数组来表示
2. 表示用‘’或者“”括起来的人以文本
3. 例子如【"abc",'abc'】

4. 特例

   a.若其中包含‘’，“”，则用转义字符来进行转义\",\'
b.\n表示换行，\t表示一个制表符，\\表示字符本身

布尔值

1. 概述与布尔代数完全一致
2. 表示True、False
3. 例子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'

空值

1. 概述特殊的值
2. 表示用None进行表示
3. 强调不可理解为0，因为0是有意义的

---

基本操作

print

1. 语句：print 'hello world!' #单引号双引号都可以
2. 对于\\转义字符，用r'...'可以省略，但是不可包含'',""以免对应错误。raw字符串中转义字符无用
3. Unicode中对中国文字进行了编码支持GB2312.
4. 表示多行字符可用'''xxx'''方法。且Print中一般先识别此符号

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

print '''''''               报错

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


print u'中文'                输出中文

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

注释

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

变量

1. 命名规范大小写英文+数字+下划线，不可用数字开头
2. 静态语言和动态语言

3. 例子a=’ABC’

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

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

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

---

---

集合

---

List类型

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

构造

1. 直接用[ ]把list的所有元素括起来
2. 由于Python是动态语言，所以List中包含的元素并不要求都必须为同一种数据类型
3. 空列表

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

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

empty_List = [ ]

按索引访问List

1. 索引排列仍为0-(n-1)
2. 倒序索引，倒序第一个为-1，往前推

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

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

List中添加和删除元素

1. 添加新元素----在末尾添加元素
2. 添加新元素----在某个位置上添加元素，并把原来此位置上的元素和后面的元素统一向后移
3. 删除元素----删除List中的最后一个元素，并且返回这个元素
4. 删除元素----删除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进行切片提取

1. a[l:r]从第l个索引一直提取到第r个索引但不包括第r个索引所对应的值
2. 若第一个索引为0，可以省略
3. 单一个:即从头到尾
4. 第三个参数是step的含义
5. 倒序切片

>>> 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类型

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

构造

1. 直接用( )把list的所有元素括起来
2. 空列表
3. 单元素有歧义，添加','来避免歧义

>>> 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创建

1. 创建key-value

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

Dict访问

1. 通过key来访问
2. 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特点

1. Dict查找速度快。查找速度不会随着元素的数量增加而增加。而List的查找速度随着元素增加而逐渐下降。
2. Dict占用内存大，还会浪费很多内容。而List占用内存小。
3. Dict按key查找，在一个Dict中key不能重复。
4. 存储的key-value序对是没有顺序的。
5. 作为key的元素是必须【不可变】的，可用字符串、整数、浮点数，而List显然是不可以用的了。

Dict增添和更新

1. 可以直接用赋值语句来进行增加。若原来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遍历

1. 通过直接遍历，可以把key直接遍历获得。
2. 在通过d[key]来遍历元素。

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

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

Dict的相关函数

1. keys获取键值，values获取值。values实质上把dict转换成了包含value的List，会多出内存。
2. itervalues获取数值。而itervalues不会转换，会在迭代过程中依次从dict中提取出value，用了时间但节省了内存。
3. items()方法获得包含了tuple的List。
4. 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特点

1. set内部结构和dict很像，但不存储value.
2. set存储的元素和dict的key类似，必为不变对象.
3. 无序.

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更新

1. 把新的元素添加到set中
2. 把已有元素从set中删除
3. 注意事项：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

---

---

函数

---

函数定义语法

1. 函数返还值的实质是返回一个Tuple
2. 默认参数只能定义在必需参数的后面
3. 用pass示意空函数
4. 可以让一个函数能够接受任意参数，用*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

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