python基础内容整理（一）

基本数据类型

字符串 String

字符串是不可变类型

字符串的分割：

s.split(sep)以给定的sep为分隔符对s进行分割。

In [4]:

s = "hello world"
s.split()

Out[4]:

['hello', 'world']

In [11]:

line = "1,2,3,4,5"
numbers = line.split(',')

连接

与分割相反，s.join(str_sequence)的作用是以s为连接符将字符串序列str_sequence中的元素连接起来，并返回连接后得到的新字符串：

In [13]:

s = ','
s.join(numbers)

Out[13]:

'1,2,3,4,5'

替换

s.replace(part1, part2)将字符串s中指定的部分part1替换成想要的部分part2，并返回新的字符串。 每个部分都会替换 不止是第一个 s的值本身没有发生变化 只是生成一个新的字符串

In [17]:

s = "hello world"
s.replace('l', ' python ')

Out[17]:

'he python  python o wor python d'

In [19]:

s

Out[19]:

'hello world'

大小写转换

s.upper()方法返回一个将s中的字母全部大写的新字符串。

s.lower()方法返回一个将s中的字母全部小写的新字符串。

这两种方法也不会改变原来s的值：

In [20]:

"hello world".upper()

Out[20]:

'HELLO WORLD'

数字

取整

In [7]:

round(21.6)

Out[7]:

22

列表

删除元素

Python提供了删除列表中元素的方法 'del'。

删除列表中的第一个元素：

In [22]:

a = [1002, 'a', 'b', 'c']
del a[1]
a

Out[22]:

[1002, 'b', 'c']

In [25]:

a = [1002, 'a', 'b', 'c']
del a[1:]
a

Out[25]:

[1002]

删除间隔的元素

In [24]:

a = ['a', 1, 'b', 2, 'c']
del a[::2]
a

Out[24]:

[1, 2]

列表方法

不改变列表的方法

列表中某个元素个数count

l.count(ob) 返回列表中元素 ob 出现的次数。

a = [11, 12, 13, 12, 11]
a.count(11)

列表中某个元素位置index

l.index(ob) 返回列表中元素 ob 第一次出现的索引位置，如果 ob 不在 l 中会报错。

In [25]:

a.index(12)

Out[25]:

1

不存在的元素会报错：

In [26]:

a.index(1)
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-26-ed16592c2786> in <module>()
----> 1 a.index(1)

ValueError: 1 is not in list

改变列表的方法

向列表添加单个元素

l.append(ob) 将元素 ob 添加到列表 l 的最后。

In [27]:

a = [10, 11, 12]
a.append(11)
print a
[10, 11, 12, 11]

append每次只添加一个元素，并不会因为这个元素是序列而将其展开：

In [28]:

a.append([11, 12])
print a
[10, 11, 12, 11, [11, 12]]

向列表添加序列

l.extend(lst) 将序列 lst 的元素依次添加到列表 l 的最后，作用相当于 l += lst。

In [29]:

a = [10, 11, 12, 11]
a.extend([1, 2])
print a
[10, 11, 12, 11, 1, 2]

插入元素

l.insert(idx, ob) 在索引 idx 处插入 ob ，之后的元素依次后移。

In [30]:

a = [10, 11, 12, 13, 11]
# 在索引 3 插入 'a'
a.insert(3, 'a')
print a
[10, 11, 12, 'a', 13, 11]

移除元素

l.remove(ob) 会将列表中第一个出现的 ob 删除，如果 ob 不在 l 中会报错。

In [31]:

a = [10, 11, 12, 13, 11]
# 移除了第一个 11
a.remove(11)
print a
[10, 12, 13, 11]

弹出元素

l.pop(idx) 会将索引 idx 处的元素删除，并返回这个元素。

In [32]:

a = [10, 11, 12, 13, 11]
a.pop(2)

Out[32]:

12

排序

l.sort() 会将列表中的元素按照一定的规则排序：

In [33]:

a = [10, 1, 11, 13, 11, 2]
a.sort()
print a
[1, 2, 10, 11, 11, 13]

如果不想改变原来列表中的值，可以使用 sorted 函数：

In [34]:

a = [10, 1, 11, 13, 11, 2]
b = sorted(a)
print a
print b
[10, 1, 11, 13, 11, 2]
[1, 2, 10, 11, 11, 13]

list.sort(cmp=None, key=None, reverse=False)
key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）

# 获取列表的第二个元素
def takeSecond(elem):
    return elem[1]

# 列表
random = [(2, 2), (3, 4), (4, 1), (1, 3)]

# 指定第二个元素排序
random.sort(key=takeSecond)

# 输出类别
print '排序列表：', random

输出：排序列表：[(4, 1), (2, 2), (1, 3), (3, 4)]

列表反向

l.reverse() 会将列表中的元素从后向前排列。

In [35]:

a = [1, 2, 3, 4, 5, 6]
a.reverse()
print a
[6, 5, 4, 3, 2, 1]

如果不想改变原来列表中的值，可以使用这样的方法：

In [36]:

a = [1, 2, 3, 4, 5, 6]
b = a[::-1]
print a
print b
[1, 2, 3, 4, 5, 6]
[6, 5, 4, 3, 2, 1]

元组

基本操作

与列表相似，元组Tuple也是个有序序列，但是元组是不可变的，用()生成。

In [1]:

t = (10, 11, 12, 13, 14)
t

(10, 11, 12, 13, 14)

但是元组是不可变的：

单个元素的元组生成

由于()在表达式中被应用，只含有单个元素的元组容易和表达式混淆，所以采用下列方式定义只有一个元素的元组：

In [5]:

a = (10,)
print a
print type(a)

(10,)
<type 'tuple'>

In [6]:

a = (10)
print type(a)

<type 'int'>

将列表转换为元组：

In [7]:

a = [10, 11, 12, 13, 14]
tuple(a)

Out[7]:

(10, 11, 12, 13, 14)

元组方法

由于元组是不可变的，所以只能有一些不可变的方法，例如计算元素个数 count 和元素位置 index ，用法与列表一样。

a.count(10)
a.index(12)

字典

空字典

Python 使用 {} 或者 dict() 来创建一个空的字典：

In [1]:

a = {}
type(a)

dict

a = dict()
type(a)

dict

b = {'one': 'this is number 1', 'two': 'this is number 2'}
b['one']

'this is number 1'

字典没有顺序

当我们 print 一个字典时，Python并不一定按照插入键值的先后顺序进行显示,因为字典中的键本身不一定是有序的。

print(a)
{'two': 'this is number 2', 'one': 'this is number 1, too'}

因此，Python中不能用支持用数字索引按顺序查看字典中的值，而且数字本身也有可能成为键值，这样会引起混淆：

键必须是不可变的类型 ,而值可以是任意的Python对象。

使用 dict 初始化字典

除了通常的定义方式，还可以通过 dict() 转化来生成字典：

inventory = dict(
    [('foozelator', 123),
     ('frombicator', 18),
     ('spatzleblock', 34),
     ('snitzelhogen', 23)
    ])
inventory

{'foozelator': 123, 'frombicator': 18, 'snitzelhogen': 23, 'spatzleblock': 34}

利用索引直接更新键值对：

In [15]:

inventory['frombicator'] += 1
inventory

{'foozelator': 123, 'frombicator': 19, 'snitzelhogen': 23, 'spatzleblock': 34}

适合做键的类型

在不可变类型中，整数和字符串是字典中最常用的类型；而浮点数通常不推荐用来做键，原因：浮点数的精度问题

有时候，也可以使用元组作为键值，例如，可以用元组做键来表示从第一个城市飞往第二个城市航班数的多少：

In [19]:

connections = {}
connections[('New York', 'Seattle')] = 100
connections[('Austin', 'New York')] = 200
connections[('New York', 'Austin')] = 400

元组是有序的，因此 ('New York', 'Austin') 和 ('Austin', 'New York') 是两个不同的键：

字典方法

get 方法

用索引可以找到一个键对应的值，但是当字典中没有这个键的时候，Python会报错，这时候可以使用字典的 get 方法来处理这种情况，其用法如下：

`d.get(key, default = None)`

返回字典中键 key 对应的值，如果没有这个键，返回 default 指定的值（默认是 None ）。

In [21]:

a = {}
a["one"] = "this is number 1"
a["two"] = "this is number 2"

a["three"]

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-22-8a5f2913f00e> in <module>()
----> 1 a["three"]

KeyError: 'three'

print a.get("three")

None

pop 方法删除元素

pop 方法可以用来弹出字典中某个键对应的值，同时也可以指定默认参数：

d.pop(key, default = None)`

删除并返回字典中键 key 对应的值，如果没有这个键，返回 default 指定的值（默认是 None ）。

与列表一样，del 函数可以用来删除字典中特定的键值对，例如：

In [30]:

del a["one"]
a

update方法更新字典

之前已经知道，可以通过索引来插入、修改单个键值对，但是如果想对多个键值对进行操作，这种方法就显得比较麻烦，好在有 update 方法：

d.update(newd)

将字典newd中的内容更新到d中去。

In [31]:

person = {}
person['first'] = "Jmes"
person['last'] = "Maxwell"
person['born'] = 1831
print person
{'born': 1831, 'last': 'Maxwell', 'first': 'Jmes'}

把'first'改成'James'，同时插入'middle'的值'Clerk'：

In [32]:

person_modifications = {'first': 'James', 'middle': 'Clerk'}
person.update(person_modifications)
print person
{'middle': 'Clerk', 'born': 1831, 'last': 'Maxwell', 'first': 'James'}

in查询字典中是否有该键

In [33]:

barn = {'cows': 1, 'dogs': 5, 'cats': 3}
'chickens' in barn

False

keys 方法，values 方法和items 方法

d.keys()

返回一个由所有键组成的列表；

d.values()

返回一个由所有值组成的列表；

d.items()

返回一个由所有键值对元组组成的列表；

In [36]:

barn.keys()

['cows', 'cats', 'dogs']

barn.values()

[1, 3, 5]

barn.items()

[('cows', 1), ('cats', 3), ('dogs', 5)]

集合

列表和字符串都是一种有序序列，集合 set 是一种无序的序列。

因为集合是无序的，所以当集合中存在两个同样的元素的时候，Python只会保存其中的一个（唯一性）；同时为了确保其中不包含同样的元素，集合中放入的元素只能是不可变的对象（确定性）。

集合生成

可以用set()函数来显示的生成空集合：

In [1]:

a = set()
type(a)

也可以使用一个列表来初始化一个集合：

In [2]:

a = set([1, 2, 3, 1])
a

{1, 2, 3}

集合会自动去除重复元素 1。

可以看到，集合中的元素是用大括号{}包含起来的，这意味着可以用{}的形式来创建集合：

In [3]:

a = {1, 2, 3, 1}
a

{1, 2, 3}

但是创建空集合的时候只能用set来创建，因为在Python中{}创建的是一个空的字典：

集合操作

并

两个集合的并，返回包含两个集合所有元素的集合（去除重复）。

可以用方法 a.union(b) 或者操作 a | b 实现。

交

两个集合的交，返回包含两个集合共有元素的集合。

可以用方法 a.intersection(b) 或者操作 a & b 实现。

差

a 和 b 的差集，返回只在 a 不在 b 的元素组成的集合。

可以用方法 a.difference(b) 或者操作 a - b 实现。

对称差

a 和b 的对称差集，返回在 a 或在 b 中，但是不同时在 a 和 b 中的元素组成的集合。

可以用方法 a.symmetric_difference(b) 或者操作 a ^ b 实现（异或操作符）。

包含关系

两个集合A、B，集合A中任意一个元素都是集合B中的元素，我们就说这两个集合有[包含]关系，称集合A为集合B的子集

要判断 b 是不是 a 的子集，可以用 b.issubset(a) 方法，或者更简单的用操作 b <= a ：

方法只能用来测试子集，但是操作符可以用来判断真子集：( 如果集合A是集合B的子集，并且集合B不是集合A的子集 )

a <= a

True

自己不是自己的真子集：

a < a

False

集合方法

add 方法向集合添加单个元素

跟列表的 append 方法类似，用来向集合添加单个元素。

s.add(a)

将元素 a 加入集合 s 中。

t = {1, 2, 3}
t.add(5)
t

{1, 2, 3, 5}

如果添加的是已有元素，集合不改变：

update 方法向集合添加多个元素

跟列表的extend方法类似，用来向集合添加多个元素。

s.update(seq)

将seq中的元素添加到s中。

t.update([5, 6, 7])
t

{1, 2, 3, 5, 6, 7}

remove 方法移除单个元素

s.remove(ob)

从集合s中移除元素ob，如果不存在会报错。

pop方法弹出元素

由于集合没有顺序，不能像列表一样按照位置弹出元素，所以pop 方法删除并返回集合中任意一个元素，如果集合中没有元素会报错。

t.pop()

{3, 5, 6, 7}

discard 方法

作用与 remove 一样，但是当元素在集合中不存在的时候不会报错。

difference_update方法

a.difference_update(b)

从a中去除所有属于b的元素：

不可变集合

对应于元组（tuple）与列表（list）的关系，对于集合（set），Python提供了一种叫做不可变集合（frozen set）的数据结构。

使用 frozenset 来进行创建：

s = frozenset([1, 2, 3, 'a', 1])
s

frozenset({1, 2, 3, 'a'})

与集合不同的是，不可变集合一旦创建就不可以改变。

不可变集合的一个主要应用是用来作为字典的键，例如用一个字典来记录两个城市之间的距离：

In [2]:

flight_distance = {}
city_pair = frozenset(['Los Angeles', 'New York'])
flight_distance[city_pair] = 2498
flight_distance[frozenset(['Austin', 'Los Angeles'])] = 1233
flight_distance[frozenset(['Austin', 'New York'])] = 1515
flight_distance

Out[2]:

{frozenset({'Austin', 'New York'}): 1515,
 frozenset({'Austin', 'Los Angeles'}): 1233,
 frozenset({'Los Angeles', 'New York'}): 2498}

由于集合不分顺序，所以不同顺序不会影响查阅结果：

In [3]:

flight_distance[frozenset(['New York','Austin'])]

Out[3]:

1515

In [4]:

flight_distance[frozenset(['Austin','New York'])]

Out[4]:

1515