python语法总结2

数据容器

一、list列表

定义

列表内的每一个数据，称之为元素

以 [ ] 作为标识
列表内每一个元素之间用, 逗号隔开
元素的数据类型没有任何限制，甚至元素也可以是列表，这样就定义了嵌套列表

演示代码：

1
2
name1_list = ['欧阳无双','上官婉儿','tom','black']
print(name1_list)

下标索引：列表中的每一个元素，都有其位置下标索引，从前向后的方向，从0开始，依次递增

如果列表是嵌套的列表，同样支持下标索引

1
2
3
#取出嵌套列表的元素
my_list2 = [[1,2,3],[4,5,6]]
print(my_list2[1][1])

列表的常用方法

Python22.png

演示代码：

1
2
3
mylist = ["itCSDN", "itlove", "python"]
mylist.append("CSDN程序员")
print(f"列表在追加了元素后，结果是：{mylist}")

Python列表脚本操作符

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

如下所示：

Python 表达式 结果 描述
len([1, 2, 3]) 3 长度
[1, 2, 3] + [4, 5, 6] [1, 2, 3, 4, 5, 6] 组合
[‘Hi!’] * 4 [‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’] 重复
3 in [1, 2, 3] True 元素是否存在于列表中
for x in [1, 2, 3]: print(x, end=” “) 1 2 3 迭代

*可以使得列表重复

print（ ，end=“？”）表示用？代替print默认的换行符

截取操作与字符串类似

列表比较需要引入operator的eq方法

1
2
3
4
5
6
7
8
# 导入 operator 模块
import operator

a = [1, 2]
b = [2, 3]
c = [2, 3]
print("operator.eq(a,b): ", operator.eq(a,b))
print("operator.eq(c,b): ", operator.eq(c,b))

以上代码输出结果为：

1
2
operator.eq(a,b):  False
operator.eq(c,b):  True

python列表包含的方法&函数

函数：

1 len(list)列表元素个数
2 max(list)返回列表元素最大值
3 min(list)返回列表元素最小值
4 list(seq)将元组转换为列表

方法：

1 list.append(obj)在列表末尾添加新的对象
2 list.count(obj)统计某个元素在列表中出现的次数
3 list.extend(seq)在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4 list.index(obj)从列表中找出某个值第一个匹配项的索引位置
5 list.insert(index, obj)将对象插入列表
6 list.pop([index=-1])移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7 list.remove(obj)移除列表中某个值的第一个匹配项
8 list.reverse()反向列表中元素
9 list.sort( key=None, reverse=False)对原列表进行排序
10 list.clear()清空列表
11 list.copy()复制列表

二、tuple元组

元组与列表类似，但是元组的元素不能修改，并且用（）代替[]

1
2
3
4
5
>>> tup1 = ('Google', 'Runoob', 1997, 2000)
>>> tup2 = (1, 2, 3, 4, 5 )
>>> tup3 = "a", "b", "c", "d"   #  不需要括号也可以
>>> type(tup3)
<class 'tuple'>

在定义单个元素时需要加，否则被当成int类型

1
2
3
4
5
6
7
>>> tup1 = (50)
>>> type(tup1)     # 不加逗号，类型为整型
<class 'int'>

>>> tup1 = (50,)
>>> type(tup1)     # 加上逗号，类型为元组
<class 'tuple'>

元组不可进行修改，但是可以连接

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#!/usr/bin/python3
 
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
 
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
 
# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)

# 删除整个元组
del tup

元组同样可以进行运算

Python 表达式 结果 描述
len((1, 2, 3)) 3 计算元素个数
`>>> a = (1, 2, 3)

b = (4, 5, 6)
c = a+b
c
(1, 2, 3, 4, 5, 6)| (1, 2, 3, 4, 5, 6) | 连接，c 就是一个新的元组，它包含了 a 和 b 中的所有元素。 | |>>> a = (1, 2, 3)
b = (4, 5, 6)
a += b
a
(1, 2, 3, 4, 5, 6)| (1, 2, 3, 4, 5, 6) | 连接，a 就变成了一个新的元组，它包含了 a 和 b 中的所有元素。 | |(‘Hi!’,) * 4| ('Hi!', 'Hi!', 'Hi!', 'Hi!') | 复制 | |3 in (1, 2, 3)| True | 元素是否存在 | |for x in (1, 2, 3):
print (x, end=” “)` | 1 2 3 | 迭代 |

元组内置函数

| 1 | len(tuple)计算元组元素个数。 | `>>> tuple1 = (‘Google’, ‘Runoob’, ‘Taobao’)

len(tuple1)
3

| | --- | --- | --- | | 2 | max(tuple)返回元组中元素最大值。 |>>> tuple2 = (‘5’, ‘4’, ‘8’)
max(tuple2)
‘8’
| | 3 | min(tuple)返回元组中元素最小值。 |>>> tuple2 = (‘5’, ‘4’, ‘8’)
min(tuple2)
‘4’
| | 4 | tuple(iterable)将可迭代系列转换为元组。 |>>> list1= [‘Google’, ‘Taobao’, ‘Runoob’, ‘Baidu’]
tuple1=tuple(list1)
tuple1
(‘Google’, ‘Taobao’, ‘Runoob’, ‘Baidu’)` |

关于元组不可变，所谓元组的不可变指的是元组所指向的内存中的内容不可变。

1
2
3
4
5
6
7
8
9
10
>>> tup = ('r', 'u', 'n', 'o', 'o', 'b')
>>> tup[0] = 'g'     # 不支持修改元素
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> id(tup)     # 查看内存地址
4440687904
>>> tup = (1,2,3)
>>> id(tup)
4441088800    # 内存地址不一样了

从以上实例可以看出，重新赋值的元组 tup，绑定到新的对象了，不是修改了原来的对象。

三、字典dict

一种可变容器模型，且可存储任意类型对象。

字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示：

d = {key1 : value1, key2 : value2, key3 : value3 }

1
2
tinydict1 = { 'abc': 456 }
tinydict2 = { 'abc': 123, 98.6: 37 }

使用{}创建空字典

使用dict（）创建字典

访问字典的值

1
2
3
4
5
6
#!/usr/bin/python3
 
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
print ("tinydict['Name']: ", tinydict['Name'])
print ("tinydict['Age']: ", tinydict['Age'])

修改字典的值

1
2
3
4
5
6
7
8
9
10
#!/usr/bin/python3
 
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
tinydict['Age'] = 8               # 更新 Age
tinydict['School'] = "菜鸟教程"  # 添加信息
 
 
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])

键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行

字典内置函数&方法

| 1 | len(dict)计算字典元素个数，即键的总数。 | `>>> tinydict = {‘Name’: ‘Runoob’, ‘Age’: 7, ‘Class’: ‘First’}

len(tinydict)

3| | --- | --- | --- | | 2 | str(dict)输出字典，可以打印的字符串表示。 |>>> tinydict = {‘Name’: ‘Runoob’, ‘Age’: 7, ‘Class’: ‘First’}
str(tinydict)
“{‘Name’: ‘Runoob’, ‘Class’: ‘First’, ‘Age’: 7}”| | 3 | type(variable)返回输入的变量类型，如果变量是字典就返回字典类型。 |>>> tinydict = {‘Name’: ‘Runoob’, ‘Age’: 7, ‘Class’: ‘First’}
type(tinydict)
<class ‘dict’>` |

方法

1 dict.clear()删除字典内所有元素
2 dict.copy()返回一个字典的浅复制
3 dict.fromkeys()创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
4 dict.get(key, default=None)返回指定键的值，如果键不在字典中返回 default 设置的默认值
5 key in dict如果键在字典dict里返回true，否则返回false
6 dict.items()以列表返回一个视图对象
7 dict.keys()返回一个视图对象
8 dict.setdefault(key, default=None)和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9 dict.update(dict2)把字典dict2的键/值对更新到dict里
10 dict.values()返回一个视图对象
11 dict.pop(key[,default])删除字典 key（键）所对应的值，返回被删除的值。
12 dict.popitem()返回并删除字典中的最后一对键和值。