python3基础：变量与常用数据类型（在python3中标准数据类型包括）

python3基础：变量与常用数据类型（在python3中标准数据类型包括）

变量：

记录事务的状态，状态可变或者可以理解为临时存储数据

变量命名规则：

字母、下划线、数字的任意组合

不能以数字开头

is与==区别：

is比较id是否相等

==比较值是否相等

>>> l1 = [1, 3, [1, 2]]>>> l2 = l1>>> id(l1)1752167654976>>> id(l2)1752167654976>>> l1 is l2True>>>>>>>>> l3 = [1, 3, [1, 2]]>>> id(l3)1752126857152>>>>>> l1 is l3False>>> l1 == l3True

常用数据类型：

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 "", line 1, in 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')>>> re18>>> 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 "", line 1, in 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对应的valueprint(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))

类型转换

重复的会去掉，不能对可变类型转换，如果对象元素中存在可变类型，则会报错

# 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 "", line 1, in TypeError: unhashable type: 'list'>>>>>># 集合转list>>> s = {1, 2, 3, 4, 4}>>> s{1, 2, 3, 4}>>> print(type(s))>>> 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 > s2False>>> s3 = {1, 2, 3}>>> s4 = {1, 2}>>> s3 > s4True

上面是符号的关系运算，也可以用函数

交集: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 "", line 1, in 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

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。