python学习笔记 | 基础语法（二）

参考：廖雪峰python教程

python内置的数据类型

list

list是一种有序集合，可以随时添加和删除元素。

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

操作：

1. 获取长度len()

print(len(classmates))

3

2. 访问元素（用索引访问，同数组，不可越界）
   特别：用负数索引，-1表示最后一个元素

print(classmates[-1]) #可获取最后一个元素
print(classmates[-2]) #类推，倒数第二个元素

Tracy
Bob

3. 向末尾追加元素 append()

classmates.append('Adam')

4. 将元素插入到指定位置insert()

classmates.insert(1, 'Jack') #插到索引为1的位置
# ['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']

5. 删除末尾元素pop()

classmates.pop()
# Adam

6. 删除指定位置元素pop(i)（i为索引）

classmates.pop(1)

7. 替换，可以通过直接赋值给对应索引。

classmates[1] = 'Sarah'

补充：

1. list中的元素数据类型可以不同

 L = ['Apple', 123, True]

2. list中的元素可以是另一个list

s = ['python', 'java', ['asp', 'php'], 'scheme']
len(s) #4

3. 空list

L=[]
len(L) #0

tuple

tuple和list非常类似，但是tuple一旦初始化就不能修改.即没有插入删除替换等这些操作。
意义： 因为tuple不可变，所以代码更安全。

1. 定义一个tuple

t = (1, 2)
#空tuple
t = ()

2. 定义一个只有1个元素的tuple。如果t = (1)会产生歧义，因为这样定义的是t变量，初值为1. 所以应当如下定义：

t = (1,)

3. “可变”的tuple
   tuple中有list元素，list里面的元素是可以改变的。

t = ('a', 'b', ['A', 'B'])
t[2][0] = 'X'
t[2][1] = 'Y'

dict

相似于map，<key,value>存储

d={'Michael':5,'Bob':6,'Alice':7}   #大括号，冒号
d['Michael'] #取值用中括号
d['Adam']=9  #添加新值

判断key值是否存在

'Tomas' in d   #False
'Bob' in d     #True

get()方法

d.get('Thomas')      #返回None
d.get('Thomas', -1)  #key存在，则返回value;key不存在，则返回-1

删除pop(key)

d.pop('Bob')

dict是用空间来换取时间的一种方法.

补充：
dict的key必须是不可变对象。字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key。

set

• set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。
• set可以看成数学意义上的无序和无重复元素的集合。

1. 创建set，需要一个list作为输入集合。重复元素会被自动过滤

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

2. 添加元素add(key)

>>> s.add(4)
>>> s
{1, 2, 3, 4}
>>> s.add(4)    #重复添加没有作用
>>> s
{1, 2, 3, 4}

3. 删除元素remove(key)

>>> s.remove(4)
>>> s
{1, 2, 3}

4. 类似集合的交集并集操作

>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2    #交集
{2, 3}
>>> s1 | s2    #并集
{1, 2, 3, 4}

补充

不可变对象
对可变对象（list）的操作可以改变内容：

>>> a = ['c', 'b', 'a']
>>> a.sort()   #一个排序操作
>>> a
['a', 'b', 'c']

对于不可变对象（str）操作内容没有改变：

>>> a = 'abc'
>>> a.replace('a', 'A')  #一个替换操作
'Abc'
>>> a
'abc'   #a并没有改变

replace操作实际上产生了一个新的字符串，即：

>>> a = 'abc'
>>> b = a.replace('a', 'A')
>>> b
'Abc'
>>> a
'abc'

选择不可变对象作为key很重要，最常用的key是字符串。