变量：
记录事务的状态，状态可变或者可以理解为临时存储数据
变量命名规则：
字母、下划线、数字的任意组合
不能以数字开头
关键字不能声明为变量，如：and def、class、break...
is与==区别：
is比较id是否相等
==比较值是否相等
>>> l1 = [1, 3, [1, 2]]
>>> l2 = l1
>>> id(l1)
1752167654976
>>> id(l2)
1752167654976
>>> l1 is l2
True
>>>
>>>
>>> l3 = [1, 3, [1, 2]]
>>> id(l3)
1752126857152
>>>
>>> l1 is l3
False
>>> l1 == l3
True
常用数据类型：
int 整型：
>>> int(3)
3
浮点型 float
>>> float(3)
3.0
布尔 bool:
显式布尔值: true、false
隐式布尔值：其中0、None、空（空字符串、空列表等），代表的布尔值为False，其余为True
字符串(str)
索引对应值，可通过索引获取，支持步长；元素不可变
定义字符串时，需要使用引号（''，""，''' '''，""" """）单引号，双引号，三个单引号，三个双引号;
字符串嵌套，内层单引号，外层双引号；内层双引号，外层单引号；或者反斜杠（"\"）转义；
# 索引取值
>>> s = 'hello word'
>>> s
'hello word'
>>> s[0]
'h'
>>> s[0:5]
'hello'
# 步长为2
>>> s[0:5:2]
'hlo'
# 从末尾取值
>>> s[-5:]
' word
列表 list
索引对应值，索引从0开始；
列表有序，可变
在[]内用逗号分隔开任意类型的值，一个值称为一个元素
类型转换
但凡能被for循环遍历的类型，都可以作为参数传给list()转换成列表
>>> list('hello')
['h', 'e', 'l', 'l', 'o']
# 字典，将key值转换成列表
>>> d = dict(a=1, b=2)
>>> d
{'a': 1, 'b': 2}
>>> list(d)
['a', 'b']
内置方法
# 正向取值>>> l = ['ricky', 18, 'python']
>>> l[0]
'ricky'
# 反向取值
>>> l[-1]
'python'
# 修改元素 索引不存在，则报错
>>> l[0]='RICKY'
>>> l
['RICKY', 18, 'python']
>>> l[3]='aaa'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list assignment index out of range
# append()添加
>>> l.append('aaaa')
>>> l
['RICKY', 18, 'python', 'aaaa']
# 指定索引位置插入
>>> l.insert(1, 'bb')
>>> l
['RICKY', 'bb', 18, 'python', 'aaaa']
# 合并列表
>>> l2 = [1, 2, 3]
>>> l.extend(l2)
>>> l
['RICKY', 'bb', 18, 'python', 'aaaa', 1, 2, 3]
# 字符串也可以extend()，能被for循环遍历
>>> s = 'klj'
>>> l.extend(s)
>>> l
['RICKY', 'bb', 18, 'python', 'aaaa', 1, 2, 3, 'k', 'l', 'j']
## 删除
# del根据索引删除，无返回值
>>> del l[1]
>>> l
['RICKY', 18, 'python', 'aaaa', 1, 2, 3, 'k', 'l', 'j']
# pop()不指定索引时，默认从列表末尾开始删除，返回索引对应值
>>> x = l.pop()
>>> print(x)
j
>>> x = l.pop(0)
>>> print(x)
RICKY
>>> l
[18, 'python', 'aaaa', 1, 2, 3, 'k', 'l']
# remove()指定元素值删除，返回None
>>> re = l.remove(18)
>>> print(re)
None
# count()统计元素在列表中出现的次数
['python', 'aaaa', 1, 2, 3, 'k', 'l']
>>> l4 = ['python', 4, 'Python', 'o', 'python']
>>> l.extend(l4)
>>> l
['python', 'aaaa', 1, 2, 3, 'k', 'l', 'python', 4, 'Python', 'o', 'python']
>>> l.count('python')
3
# clear()清空列表
>>> l4
['python', 4, 'Python', 'o', 'python']
>>> l4.clear()
>>> l4
[]
# index()，返回元素值的索引，多个相同元素值，返回最近元素值的索引
['python', 'aaaa', 1, 2, 3, 'k', 'l', 'python', 4, 'Python', 'o', 'python']
>>> l.index('python')
0
# reverse()，倒叙，永久改变，不生产新列表
>>> l
['python', 'aaaa', 1, 2, 3, 'k', 'l', 'python', 4, 'Python', 'o', 'python']
>>> l.reverse()
>>> l
['python', 'o', 'Python', 4, 'python', 'l', 'k', 3, 2, 1, 'aaaa', 'python']
# sort()排序，改变源列表，只能对列表进行操作
>>> l5 = [1, 4, 2, 6, 4, 3, 9]
>>> l5.sort()
>>> l5
[1, 2, 3, 4, 4, 6, 9]
# sorted()是内建函数，不改变源列表，返回一个排序后的新列表
>>> l6 = [1, 4, 2, 6, 4, 3, 9]
>>> new_l = sorted(l6)
>>> print(new_l)
[1, 2, 3, 4, 4, 6, 9]
>>> print(l6)
[1, 4, 2, 6, 4, 3, 9]
# sort()与reverse()结合使用
>>> l6
[1, 4, 2, 6, 4, 3, 9]
>>> l6.sort(reverse=True)
>>> l6
[9, 6, 4, 4, 3, 2, 1]
list的函数：索引获取值（正反方向）、修改元素值（l[3]=2），append()追加，insert()插入、extend()合并列表、index()获取索引、del l[0]删除元素，pop()删除，有返回值、remove('元素值')删除，count()、clear()、reverse()、sort()、sorted()、
元组tuple
有序，不可变
可以理解为，元组相当于一个不可变的列表
作用：按索引/位置存放多个值，只用于读，不用于写
定义：()内用逗号分隔开多个任意类型的元素
元组一旦设置，不能增删改，只能读，元组变量可重新赋值
类型转换
和list一样，能被for循环遍历的，都可以转换成tuple
>>> tuple('hello')('h', 'e', 'l', 'l', 'o')
>>> l = [1, 2, 3, 4]
>>> tuple(l)
(1, 2, 3, 4)
>>> d = {'a':1, 'b':2}
>>> tuple(d)
('a', 'b')
>>> s = {'a', 2, 3}
>>> tuple(s)
(2, 3, 'a')
内置方法
tuple除了不可变，和list没什么区别，都是按索引取值，可正向反向取、切片、统计count、长度len、循环、成员运算(in 与 not in)、index
字典 dict:
字典：key-value对应值，key对值具有描述性功能；
字典无序，可变，key唯一
在{}内用逗号分隔多个key:value值，key字符串需要引号
定义空字典
>>> d = {}>>> d1 = dict()
类型转换
>>> info = [['name', 'ricky'], ('age', 18), ['sex', 'male']]>>> d = dict(info)
>>> d
{'name': 'ricky', 'age': 18, 'sex': 'male'}
内置方法
len、in/not in、clear (这几个函数和list一样)
赋值时：key存在，则更改；key不存在，则创建新的key（列表赋值时，如果索引不存在，则会报错）
>>> len(d)3
>>> d1 = {'1':1}
>>> d1
{'1': 1}
>>> d1.clear()
>>> d1
{}
字典删除操作
del 、pop()、popitem()
>>> d{'name': 'ricky', 'age': 18, 'sex': 'male'}
# del 无返回值
>>> del d['name']
>>> d
{'age': 18, 'sex': 'male'}
# pop返回key对应的value
>>> re = d.pop('age')
>>> re
18
>>> d
{'sex': 'male'}
>>> d['k1'] = 1
>>> d['k2'] = 1
>>> d
{'sex': 'male', 'k1': 1, 'k2': 1}
# popitem随机删除，返回key-value对，元组格式
>>> re1 = d.popitem()
>>> re1
('k2', 1)
获取字典操作
keys()、values()、items()
python3中，python对这些操作进行了优化，生成的是一条语句，只有再用的时候才执行获取结果，减少空间的浪费
python2中，直接返回的是列表
>>> d{'sex': 'male', 'k1': 1}
# keys()返回key列表
>>> d.keys()
dict_keys(['sex', 'k1'])
# values()返回value的列表
>>> d.values()
dict_values(['male', 1])
# items()返回列表套元组的key-value
>>> d.items()
dict_items([('sex', 'male'), ('k1', 1)])
其它函数：
update()
# update() 用新的字典更新旧的字典，以新的字典为准，没有的则增加；存在的key，如果value不一样，则更新
>>> d{'sex': 'male', 'k1': 1, 'k2': 2, 'k3': 2, 'k4': 2}
>>>
>>> d2={'k1':1, 'k2':2, 'k3':3, 'k4': 4}
>>> d2
{'k1': 1, 'k2': 2, 'k3': 3, 'k4': 4}
>>> d.update(d2)
>>>
>>> d
{'sex': 'male', 'k1': 1, 'k2': 2, 'k3': 3, 'k4': 4}
>>>
>>> d2
{'k1': 1, 'k2': 2, 'k3': 3, 'k4': 4}
get()
常规获取字典的数据，是通过key值获取（d['k1']），如果key不存在则报错；而get()与常规取值的区别是 ，就算key不存在也不会报错，而是返回None
>>> d{'sex': 'male', 'k1': 1, 'k2': 2, 'k3': 3, 'k4': 4}
>>> d['k1']
1
>>> d['k5']
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'k5'
>>>
>>> d.get('k1')
1
>>> re = d.get('k5')
>>> print(re)
None
setdefault()
# setdefault(key,vaule) 设置默认值，即如果字典中存在key则忽略setdefault，如果不存在则设置setdefault的参数d = {'k1': 11, 'k2': 22}
# 如果key存在，则不添加，返回key的值
res = d.setdefault('k1', 11)
print(res, d)
res1 = d.setdefault('k2', 33) # 只匹配key，key存在则不添加，更不会更改原有的key对应的value
print(res1, d)
# 如果key不存在，则添加，返回key的值
res2 = d.setdefault('k3', 33)
print(res2, d)
集合 set
集合无序、不可变、唯一
作用：
关系运算
去重
定义：在{}内用逗号分隔开 多个元素，多个元素满足以下三个条件：
1、集合内元素必须为不可变类型(不能是列表、字典)
2、集合内元素无序
3、集合内元素没有重复
# 默认定义的是空字典，如果需要定义空集合，则需要显试调用set()函数
>>> s = {}>>> s1 = set({})
>>> print(type(s), type(s1))
<class 'dict'> <class 'set'>
类型转换
重复的会去掉，不能对可变类型转换，如果对象元素中存在可变类型，则会报错
# list转set>>> l
[1, 2, 3, 4]
>>> set(l)
{1, 2, 3, 4}
# 如果可变类型的元素中存在可变类型，则无法转换成set(set不可变)
>>> l2 = [[1, 2], 'a', 'b']
>>> set(l2)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
>>>
>>>
# 集合转list
>>> s = {1, 2, 3, 4, 4}
>>> s
{1, 2, 3, 4}
>>> print(type(s))
<class 'set'>
>>> list(s)
[1, 2, 3, 4]
内置方法
集合中使用较多的主要是关系运算的内置方法
s1 = {'aa', 'bb', 'abc', 'bgd'}s2 = {'aa', 'bhg', 'bb'}
# 取交集
>>> s1 & s2
{'aa', 'bb'}
# 取并集
>>> s1 | s2
{'abc', 'bb', 'bgd', 'aa', 'bhg'}
# 取差集,有顺序，s1 - s2，表示以s1为准，减去共同的部分，保留s1的差
>>> s1 - s2
{'abc', 'bgd'}
# 取共同的差值，即两个集合的不同部分
>>> s1 ^ s2
{'abc', 'bgd', 'bhg'}
# 父子集
s3 = {1, 2, 3}
s4 = {1, 2}
>>> s1 > s2
False
>>> s3 = {1, 2, 3}
>>> s4 = {1, 2}
>>> s3 > s4
True
上面是符号的关系运算，也可以用函数
交集:intersection()
S1.intersection(s2)
并集:union()
差集:difference()
对称差值:symmetric_difference()
父子集:issuperset()
其它函数
discard()、remove()、pop()、update()、add()、isdisjoint()
s1 = {1, 2, 3, 4}s2 = {5, 6, 7, 8}
# 删除操作，不存在，不报错,返回None
>>> s1.discard(1)
>>> s1
{2, 3, 4}
>>> re = s1.discard(5)
>>> print(re)
None
# 删除操作，不存在，则报错
>>> re1 = s1.remove(5)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 5
# 随机删除，返回值
>>> s2.pop()
8
# update() 更新集合
>>> s1
{2, 3, 4, 5}
>>> s2
{5, 6, 7}
>>> s1.update(s2)
>>> s1
{2, 3, 4, 5, 6, 7}
# add() 增加元素（单个增加）
>>> s1.add(5)
>>> s1
{2, 3, 4, 5}
# isdisjoint() 判断是否存在交集，不存在则为True
>>> s1.isdisjoint(s2)
False