Python起步

标签（空格分隔）：未分类

输入和输出

python2中的有两个输入函数分别是input 和raw_input input可以保持输入的数据类型 raw_input则永远反水字符串

python数据类型

Python常用的数据类型

列表(list)
元组(tuple)
字符串(string)
字典(dict)
集合(set)

序列的通用操作

其中列表(list)、元组(tuple)、字符串(string)都属于序列类型。序列是python最基本的数据结构，所有的序列类型都有一些通用的操作：

索引
切片
迭代
加
乘

还可以检查某个元素是否属于序列的成员，计算序列的长度等等。

为了检查元素是否在序列中可以使用in操作

In [234]: s = "helloworld"

In [235]: "he"  in s
Out[235]: True

In [236]: "ll"  in s
Out[236]: True

In [237]: "ls"  in s
Out[237]: False

序列中的所有元素都可以通过索引来获取，索引从0开始

列表

列表也是序列，并且它是可变的。常用的操作方法有：

index
count
append
extend
insert
pop
remove
reverse
sort

index返回列表元素的第一个位置

In [205]: l = list("helloworld")

In [206]: l
Out[206]: ['h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd']

In [207]: l.index("h")
Out[207]: 0

In [208]: l.index("l")
Out[208]: 2

count返回元素在列表里出现的次数

In [205]: l = list("helloworld")
In [209]: l.count("l")
Out[209]: 3

append向列表的末尾追加元素

In [210]: l.append("test")

In [211]: l
Out[211]: ['h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd', 'test']

extend合并两个列表

In [212]: a =[1,2,3]

In [213]: b = [4,5,6]

In [214]: a.extend(b)

In [215]: a
Out[215]: [1, 2, 3, 4, 5, 6]

insert在指定的的列表位置插入元素

In [216]: a = list("hello world")

In [217]: a
Out[217]: ['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

In [218]: a.insert(2,"test")

In [219]: a
Out[219]: ['h', 'e', 'test', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

pop 删除列表指定位置的元素，默认是最后一个

In [219]: a
Out[219]: ['h', 'e', 'test', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

In [220]: a.pop()
Out[220]: 'd'

In [221]: a
Out[221]: ['h', 'e', 'test', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l']

In [222]: a.pop(0)
Out[222]: 'h'

In [223]: a
Out[223]: ['e', 'test', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l']

remove 方法用于移除列表中的某个匹配元素，如果有多个匹配，则移除第一个。

In [224]: a = list("hello")

In [225]: a
Out[225]: ['h', 'e', 'l', 'l', 'o']

In [226]: a.remove("l")

In [227]: a
Out[227]: ['h', 'e', 'l', 'o']

reverse 方法用于将列表中的元素进行反转。

In [227]: a
Out[227]: ['h', 'e', 'l', 'o']

In [228]: a.reverse()

In [229]: a
Out[229]: ['o', 'l', 'e', 'h']

元组

在 Python 中，元组是一种不可变序列，它使用圆括号来表示

In [192]: t = (1,2,4)

In [193]: t
Out[193]: (1, 2, 4)

空元组

In [194]: t1 = ()

In [195]: t1
Out[195]: ()

一个元素的元组

In [196]: t2 = (1,)

In [197]: t2
Out[197]: (1,)

In [198]: type(t2)
Out[198]: tuple

元组也是一种序列，因此也可以对它进行索引、分片等。由于它是不可变的，因此就没有类似列表的 append, extend, sort 等方法。

字符串

字符串也是一种序列，支持常用的序列操作。比如索引、分片、加乘、迭代

In [145]: s1 = "hello world"

In [147]: s1[0]
Out[147]: 'h'

In [148]: s1[1]
Out[148]: 'e'

In [149]: s1[1:9]
Out[149]: 'ello wor'

In [150]: s1 + "add"
Out[150]: 'hello worldadd'

In [151]: s1 + "add" * 2
Out[151]: 'hello worldaddadd'

字符串常用的操作方法

find
split
join
strip
replace
translate
lower/upper

find 方法用于在一个字符串中查找子串，它返回子串所在位置的最左端索引，如果没有找到，则返回 -1。

In [153]: s1
Out[153]: 'hello world'

In [155]: s1.find("s")
Out[155]: -1

In [156]: s1.find("h")
Out[156]: 0

In [157]: s1.find("e")
Out[157]: 1

split 方法用于将字符串分割成序列。

In [163]: s1
Out[163]: 'hello world'

In [164]: s1.split("l")
Out[164]: ['he', '', 'o wor', 'd']

join 方法可以说是 split 的逆方法，它用于将序列中的元素连接起来。

"".join(['h', 'e', 'l', 'l', 'o'])

strip 方法用于移除字符串左右两侧的空格，但不包括内部，当然也可以指定需要移除的字符串。

In [179]: s1 = "##&  hello &** "

In [180]: s1.stripe()

In [181]: s1.strip()
Out[181]: '##&  hello &**'

In [182]: s1.strip("*")
Out[182]: '##&  hello &** '

In [183]: s1.strip("* ")
Out[183]: '##&  hello &'

In [184]: s1.strip("* #&")
Out[184]: 'hello'

lower/upper 用于返回字符串的大写或小写形式。

In [186]: s1 = "Hello World"

In [187]: s1.lower()
Out[187]: 'hello world'

In [188]: s1.upper()
Out[188]: 'HELLO WORLD'

replace 方法用于替换字符串中的所有匹配项。

In [186]: s1 = "Hello World"

In [191]: s1.replace("Hello","test")
Out[191]: 'test World'

字典

字典是 Python 中唯一的映射类型，每个元素由键（key）和值（value）构成，键必须是不可变类型，比如数字、字符串和元组。

创建

使用字面亮或者dict函数创建

In [1]: d1 = {"name":'cailei',"age":26,"sex":"female"}

In [2]: d1
Out[2]: {'age': 26, 'name': 'cailei', 'sex': 'female'}

In [3]: type(d1)
Out[3]: dict

In [4]: d2 =  dict(age=26,name="cailei",sex="female") # 使用 dict 函数

In [5]: d2
Out[5]: {'age': 26, 'name': 'cailei', 'sex': 'female'}

In [6]: d3 = dict([("name","cailei"),("age",26),("sex","female")])

In [7]: d3
Out[7]: {'age': 26, 'name': 'cailei', 'sex': 'female'}

判断键是否存在

使用关键词in判断字典里的键是否存在

In [22]: "name" in d2
Out[22]: True

In [23]: del d2['name']

In [24]: "name" in d2
Out[24]: False

遍历字典

In [26]: for key in d3:
    ...:     print "%s:%s"%(key,d3[key])
    ...:
    ...:
age:26
name:cailei
sex:female

#  使用keys获取所有的键名的列表
In [27]: for key in d3.keys():
    ...:     print "%s:%s"%(key,d3[key])
    ...:
    ...:
age:26
name:cailei
sex:female

常用方法

clear
copy
get
setdefault
update
pop
popitem
keys/iterkeys
values/itervalues
items/iteritems
fromkeys

clear 方法用于清空字典中的所有项，这是个原地操作，所以无返回值（或者说是 None）。

In [28]: d3
Out[28]: {'age': 26, 'name': 'cailei', 'sex': 'female'}

In [29]: d3.clear()

In [30]: d3
Out[30]: {}

copy 方法实现的是浅复制（shallow copy）。它具有以下特点：

对可变对象的修改保持同步；
对不可变对象的修改保持独立；

In [75]: d1 = {"name":'zero'}

In [76]: id(d1)
Out[76]: 55149728

In [77]: d2 = d1

In [78]: id(d2)
Out[78]: 55149728

In [79]: d3 = d1.copy()

In [80]: id(d3)
Out[80]: 53351968

当我们试图访问字典中不存在的项时会出现 KeyError，但使用 get 就可以避免这个问题。

In [119]: d1 = {"name":'zero'}

In [122]: d1.get("name")
Out[122]: 'zero'

In [124]: result = d1.get("age")
In [126]: type(result)
Out[126]: NoneType

values 方法将字典的值以列表形式返回 itervalues 则返回针对值的迭代器。 keys 方法将字典的key以列表形式返回 iterkeys 则返回针对key的迭代器。 items 方法将所有的字典项以列表形式返回，这些列表项的每一项都来自于（键，值）。我们也经常使用这个方法来对字典进行遍历。 iteritems 方法返回字典项列表的迭代器。

In [130]: d1 = dict(name="zero",age=27,sex="female")

In [131]: d1
Out[131]: {'age': 27, 'name': 'zero', 'sex': 'female'}

In [132]: d1.values()
Out[132]: [27, 'zero', 'female']

In [133]: d1.keys()
Out[133]: ['age', 'name', 'sex']

In [134]: d1.itervalues()
Out[134]: <dictionary-valueiterator at 0x35e1f18>

In [142]: d1
Out[142]: {'age': 27, 'name': 'zero', 'sex': 'female'}

In [143]: d1.items()
Out[143]: [('age', 27), ('name', 'zero'), ('sex', 'female')]

In [144]: d1.iteritems()
Out[144]: <dictionary-itemiterator at 0x36035d0>

update 方法用于将一个字典添加到原字典，如果存在相同的键则会进行覆盖。

In [135]: d1.update({'test':'test'})

In [136]: d1
Out[136]: {'age': 27, 'name': 'zero', 'sex': 'female', 'test': 'test'}

pop 方法用于将某个键值对从字典移除，并返回给定键的值。

Out[136]: {'age': 27, 'name': 'zero', 'sex': 'female', 'test': 'test'}

In [137]: d1.pop("test")
Out[137]: 'test'

In [138]: d1
Out[138]: {'age': 27, 'name': 'zero', 'sex': 'female'}

popitem 用于随机移除字典中的某个键值对。

集合

set 数据类型是一组key的集合，集合是一种特殊的元素里面的key不能够重复。

创建集合

s1 = {1,2,3,4,5}  # 使用{}
>>> {1, 2, 3, 4, 5}
s2 = set([1,2,3,4,5])  # 使用set接受一个列表
>>> {1, 2, 3, 4, 5}
s3 = set("helloworld") # 使用set接受一个字符串
>>> {'d', 'e', 'h', 'l', 'o', 'r', 'w'}

遍历集合

In [3]: s1  = set("hello world")

In [4]: s1
Out[4]: {' ', 'd', 'e', 'h', 'l', 'o', 'r', 'w'}

In [5]: for i in s1:
   ...:     print  i
   ...:

e
d
h
l
o
r
w

添加元素

使用add添加元素

In [6]: s1 = set(["a","e","i","o","u"])

In [7]: s1
Out[7]: {'a', 'e', 'i', 'o', 'u'}

In [8]: s1.add("c")

In [9]: s1
Out[9]: {'a', 'c', 'e', 'i', 'o', 'u'}

删除元素

remove 删除元素

In [33]: s = {1,2,4,5,"hello"}

In [34]: s.remove("hello")

In [35]: s
Out[35]: {1, 2, 4, 5}

交集 && 并集 && 差集

In [38]: s1 = {1,2,3,4,5}

In [39]: s2 = set([4,5,6,7,8])

In [40]: s1 & s2  # 交集
Out[40]: {4, 5}

In [41]: s1 | s2  # 并集
Out[41]: {1, 2, 3, 4, 5, 6, 7, 8}

In [42]: s1 - s2  # 差集
Out[42]: {1, 2, 3}

判断集合超集 || 子集

使用 issubset 判断子集使用 issuperset 判断超集

In [43]: s1 = {1,2,3,4,5}

In [44]: s2 = {4,5}

In [45]: s1.issubset(s2)
Out[45]: False

In [46]: s1.issuperset(s2)
Out[46]: True

函数

函数使用关键字def定义

In [241]: def hello():
     ...:     return "hello"
     ...:

In [242]: s = hello()

In [243]: s
Out[243]: 'hello'

函数参数

必选参数
默认参数
可变参数
关键字参数

必选参数理解起来最为简单，顾名思义就是调用函数的时候传入数量一致的参数，比如：

In [256]: def hello(name,age):
     ...:     return "hello " + name +  " age is " + str(age)
     ...:
     ...:
     ...:

In [257]: s = hello('cailei',26)

In [258]: s
Out[258]: 'hello cailei age is 26'

默认参数同样很好理解，和必须参数相反，默认参数可以传入数量不一致的参数，但是没有传入的参数必须设置默认值

>>> def add(x, y, z=1):     # x, y 是必选参数，z 是默认参数，默认值是 1
...     print x + y + z
...
>>> add(1, 2, 3)            # 1+2+3
6
>>> add(1, 2)               # 没有传递 z，自动使用 z=1，即 1+2+1
4

默认参数应该放在必选参数之后

默认参数应该是不可变对象

可变参数

在默写情况我们无法预估函数应该制定多少个参数，这时候可以使用不可变参数，也就是函数的参数是不确定的。

In [285]: def sum(*numbers):
     ...:     print numbers
     ...:

In [286]: sum(1,2,3,4,5)
(1, 2, 3, 4, 5)

可以利用可变参数实参传递一个序列给函数，函数会一一对应不可变参数

In [293]: def test(a,b,c):
     ...:     return a+b+c
     ...:

In [294]: a = [1,2,3]

In [295]: test(*a)
Out[295]: 6

可以直接利用序列直接覆盖可变参数

In [285]: def sum(*numbers):
     ...:     print numbers
     ...:

In [288]: a = (1,2,3)

In [289]: sum(*a)
(1, 2, 3)

关键词参数

可变参数允许你将不定数量的参数传递给函数，而关键字参数则允许你将不定长度的键值对, 作为参数传递给一个函数。

In [296]: def hello(**kw):
     ...:     print kw
     ...:

In [297]: hello(name="cailei")
{'name': 'cailei'}

In [298]: hello("cailei")

使用字典直接度改关键词参数

In [302]: hello(**{"age":"cailei"})
{'age': 'cailei'}

参数组合

在实际的使用中，我们经常会同时用到必选参数、默认参数、可变参数和关键字参数或其中的某些。但是，需要注意的是，它们在使用的时候是有顺序的，依次是必选参数、默认参数、可变参数和关键字参数。

如果函数没有设定return则会自动return None

函数式编程

生成器和迭代器

类

面向对象编程主要有以下特点：

多态（Polymorphism）：不同类（Class）的对象对同一消息会做出不同的响应。
封装（Encapsulation）：对外部世界隐藏对象的工作细节。
继承（Inheritance）：以已有的类（父类）为基础建立专门的类对象。

类和实例

类是一个很抽象的概念，我们可以把它理解为具有相同属性和方法的一组对象的集合，而实例则是一个具体的对象。我们还是先来看看在 Python 中怎么定义一个类。

正则表达式

进程、线程

调试

使用id函数查看变量内存地址

In [73]: var = "name"

In [74]: id(var)
Out[74]: 140165763272304

DanceSmile / dancesmile.github.io

简明的python #5

Python起步

输入和输出

python数据类型

序列的通用操作

列表

元组

字符串

字典

创建

判断键是否存在

遍历字典

常用方法

集合

创建集合

遍历集合

添加元素

删除元素

交集 && 并集 && 差集

判断集合超集 || 子集

函数

函数参数

可变参数

关键词参数

参数组合

函数式编程

生成器和迭代器

类

类和实例

正则表达式

进程、线程

调试

使用id函数查看变量内存地址

DanceSmile / dancesmile.github.io

简明的python #5

Python起步

输入和输出

python数据类型

序列的通用操作

列表

元组

字符串

字典

创建

判断键是否存在

遍历字典

常用方法

集合

创建集合

遍历集合

添加元素

删除元素

交集 && 并集 && 差集

判断集合超集 || 子集

函数

函数参数

可变参数

关键词参数

参数组合

函数式编程

生成器 和 迭代器

类

类和实例

正则表达式

进程 、线程

调试

使用id函数查看变量内存地址

生成器和迭代器

进程、线程