基本数据类型

时间：2020-06-09 14:34:27 阅读：85 评论：0 收藏：0 [点我收藏+]

标签：lvm 字符串元祖 apple 报错常用操作去掉初始化多个

1.元祖用途：
2、定义方式:
- 类型转换
3、常用操作+内置的方法
4.内容总结
1、字典用途：
2、定义方式：
- 类型转换
3、常用操作+内置的方法
4.字典总结
1.集合作用
2.定义：
3.类型转换
4.关系运算
5.集合去重复有局限性
6.其他操作

1.元祖用途：

元组就是一个不可变的列表

2、定义方式:

在小括号()内用逗号分隔开多个任意类型的值
l=[111,222,333]
t=(111,222,333) # t=tupe((111,222,333))
print(type(t))

类型转换

tuple(任意能够被for循环遍历的类型) # ===> 元组
list(任意能够被for循环遍历的类型) # ===> 列表

3、常用操作+内置的方法

优先掌握的操作：

1、按索引取值(正向取+反向取)：只能取

2、切片(顾头不顾尾，步长)

t=(111,222,333)
print(t[0:2])
print(t)

3、长度

t = (111, 222, 333)
print(len(t))

4、成员运算in和not in

t = (111, 222, 333)
print(111 in t)

5、循环

for i in t:
    print(i)

需要掌握的内置方法

t = (4444, 5555,111,222, 111,111,333)
print(t.index(111))
print(t.index(111123123123123123)) # 找不到则报错

4.内容总结

存多个值

有序

不可变（1、可变：值变，id不变。可变不可hash 2、不可变：值变，id就变。不可变可hash）

t = (111, 222, 333,[444,555])

t[0]=123123123123123
t[3] = 6666666666
print(id(t[3]))
t[3][0]=44444444444444444444444444
print(t)
print(id(t[3]))

1、字典用途：

存多个不同属性的值，用key对应value，key必修是不可变类型，key通常应该是
字符串类型，因为字符串类型对值value会有解释说明的效果

2、定义方式：

在{}内用逗号分隔开多个key:value元素，其中key必须是不可变类型，并且key不同重复
而value可以是任意类型

d={"k1":1111,"k2":222} # d=dict({"k1":1111,"k2":222})
print(type(d))

d={‘k‘:111,‘k‘:222,‘k‘:333,‘k‘:444}
print(d)

类型转换

d=dict([("name","egon"),["age",18],("gender",18)])
print(d)

res=dict(x=111,y=222,z=333)
print(res)

定义空
d={} # 定义空字典

print(type(d))

s=‘‘
print(type(s))

l=[]
print(type(l))

t=()
print(type(t))
t=("abc",) # 当元组内只有一个元素时，必须加逗号
print(t)
print(type(t))

s=set() # 定义空集合

3、常用操作+内置的方法

优先掌握的操作：

1、按key存取值：可存可取

d={‘name‘:‘egon‘,‘age‘:18}
l=[111,222,333]

print(d[‘name‘])
print(l[0])

d[‘gender‘]=‘male‘ # 可以通过不存在的key完成赋值操作来达到为字典添加值的效果
print(d)

l[3]=444 # 列表不行

2、长度len

d={‘name‘:‘egon‘,‘age‘:18}
print(len(d))

3、成员运算in和not in:判断的是字典的key

d={‘name‘:‘egon‘,‘age‘:18}
print("name" in d) # 判断的字典的key
print("egon" in d) # 判断的不是value，结果为False

4、删除

a：万能删除法

d={‘name‘:‘egon‘,‘age‘:18}
del d[‘name‘]
print(d)

b:删除-》取走

res=d.popitem() # 随机删除，返回一个删除元素的小元组
print(res) # (‘age‘, 18)

res=d.pop(‘name‘) # 返回key对应的那一个值
print(res)

print(d)

 5、键ke

ys()，值values()，键值对items()

Python 2.7.18 (v2.7.18:8d21aa21f2, Apr 19 2020, 20:48:48)
[GCC 4.2.1 Compatible Apple LLVM 6.0 (clang-600.0.57)] on darwin
Type "help", "copyright", "credits" or "license" for more information.

d={‘name‘:‘egon‘,‘age‘:18}

d.keys()
[‘age‘, ‘name‘]
d.values()
[18, ‘egon‘]
d.items()
[(‘age‘, 18), (‘name‘, ‘egon‘)]

6、循环

d={‘name‘:‘egon‘,‘age‘:18}

for k in d.keys():
    print(k)

for k in d:
    print(k)


for v in d.values():
    print(v)

for k,v in d.items(): # k,v=(‘age‘, 18)
    print(k,v)

字典需要掌握的内置方法

d={‘name‘:‘egon‘,‘age‘:18}
d.clear()
print(d)

d.update(age=19,gender=‘male‘)
d.update({‘age‘:19,"gender":"male"})
print(d)

print(d.get(‘name111‘)) # key不存在不会报错，会返回None
print(d["name111"]) # key不存在则报错

了解**

快速初始化好一个字典

d={}.fromkeys(["name","age","gender"],None)
print(d)

d={‘age‘:18}

保证字典中肯定有一个key是"name"

if "name" not in d:
    d["name"]="egon"
d["name"]


val=d.setdefault("name","egon")
print(d)

print(val)

4.字典总结

存多个值

无序

可变

d={‘k1‘:111,‘k2‘:2222}
print(id(d))
d[‘k1‘]=333333333333333
print(id(d))
print(d)

1.集合作用

：list、tuple、dict一样都可以存放多个值，但是集合主要用于：去重、关系运算

2.定义：

在{}内用逗号分隔开多个元素，集合具备以下三个特点：
1：每个元素必须是不可变类型
2：集合内没有重复的元素
3：集合内元素无序

s = {1,2,3,4}  # 本质 s = set({1,2,3,4})

# 注意1：列表类型是索引对应值，字典是key对应值，均可以取得单个指定的值，而集合类型既没有索引也没有key与值对应，所以无法取得单个的值，而且对于集合来说，主要用于去重与关系元素，根本没有取出单个指定值这种需求。

# 注意2:{}既可以用于定义dict，也可以用于定义集合，但是字典内的元素必须是key:value的格式，现在我们想定义一个空字典和空集合，该如何准确去定义两者?
d = {} # 默认是空字典 
s = set() # 这才是定义空集合

3.类型转换

# 但凡能被for循环的遍历的数据类型（强调：遍历出的每一个值都必须为不可变类型）都可以传给set()转换成集合类型
 s = set([1,2,3,4])
 s1 = set((1,2,3,4))
 s2 = set({‘name‘:‘jason‘,})
 s3 = set(‘egon‘)
 s,s1,s2,s3
{1, 2, 3, 4} {1, 2, 3, 4} {‘name‘} {‘e‘, ‘o‘, ‘g‘, ‘n‘}

4.关系运算

我们定义两个集合friends与friends2来分别存放两个人的好友名字，然后以这两个集合为例讲解集合的关系运算

friends1 = {"zero","kevin","jason","egon"} # 用户1的好友们 
friends2 = {"Jy","ricky","jason","egon"}   # 用户2的好友们

1.合集/并集(|)：求两个用户所有的好友（重复好友只留一个）

friends1 | friends2
{‘kevin‘, ‘ricky‘, ‘zero‘, ‘jason‘, ‘Jy‘, ‘egon‘}

2.交集(&)：求两个用户的共同好友

friends1 & friends2
{‘jason‘, ‘egon‘}

3.差集(-)：

friends1 - friends2 # 求用户1独有的好友
{‘kev

in‘, ‘zero‘}
friends2 - friends1 # 求用户2独有的好友
{‘ricky‘, ‘Jy‘}

4.对称差集(^) # 求两个用户独有的好友们（即去掉共有的好友）

friends1 ^ friends2
{‘kevin‘, ‘zero‘, ‘ricky‘, ‘Jy‘}

5.值是否相等(==)

friends1 == friends2
False

6.父集：一个集合是否包含另外一个集合

6.1 包含则返回True

{1,2,3} > {1,2}
True
{1,2,3} >= {1,2}
True

6.2 不存在包含关系，则返回False

{1,2,3} > {1,3,4,5}
False
{1,2,3} >= {1,3,4,5}
False

7.子集

{1,2} < {1,2,3}
True
{1,2} <= {1,2,3}

True

5.集合去重复有局限性

# 1. 只能针对不可变类型
# 2. 集合本身是无序的，去重之后无法保留原来的顺序

示例如下

>>> l=[‘a‘,‘b‘,1,‘a‘,‘a‘]
>>> s=set(l)
>>> s # 将列表转成了集合
{‘b‘, ‘a‘, 1}
>>> l_new=list(s) # 再将集合转回列表
>>> l_new
[‘b‘, ‘a‘, 1] # 去除了重复，但是打乱了顺序

# 针对不可变类型，并且保证顺序则需要我们自己写代码实现，例如
l=[
    {‘name‘:‘lili‘,‘age‘:18,‘sex‘:‘male‘},
    {‘name‘:‘jack‘,‘age‘:73,‘sex‘:‘male‘},
    {‘name‘:‘tom‘,‘age‘:20,‘sex‘:‘female‘},
    {‘name‘:‘lili‘,‘age‘:18,‘sex‘:‘male‘},
    {‘name‘:‘lili‘,‘age‘:18,‘sex‘:‘male‘},
]

new_l=[]

for dic in l:
    if dic not in new_l:
        new_l.append(dic)

print(new_l)
# 结果：既去除了重复，又保证了顺序，而且是针对不可变类型的去重
[
    {‘age‘: 18, ‘sex‘: ‘male‘, ‘name‘: ‘lili‘}, 
    {‘age‘: 73, ‘sex‘: ‘male‘, ‘name‘: ‘jack‘}, 
    {‘age‘: 20, ‘sex‘: ‘female‘, ‘name‘: ‘tom‘}