• 引子

• 数据类型的基本使用及内置方法

• 列表类型

• 元祖

• 字典类型

---

数据类型的基本使用及内置方法

• 列表list的基本使用

• 1、用途：按照位置存放多个任意类型的值

• 2、定义方式：在[ ]内用逗号分隔开多个任意类型的值

 l = [11,11.33,"xxx",[11,22,33]]  # l = list(...)

 print(type(l))

# list数据类型转换：把可迭代的类型转成列表

# 可以被for循环遍历的类型都是可迭代的

 res = list("hello")

 res = list({"k1":111,'K2':2222})

 print(res)

 print(list(range(1000)))

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

=》=》=》优先掌握的操作:(*****)

1、按索引存取值(正向存取+反向存取)：即可存也可以取

 l=[111,222,333]

 print(id(l))

 l[0]=666

 print(l)

 print(id(l))

 l=[111,222,333]

 l[0]=666

 l[3]=777  # 列表索引不能超出范围

 l[3]  # 列表索引不能超出范围

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

 l=[11,22,33,44,55,66,77,88,99]

 res=l[1:7:2]

 res=l[:]

 res=l[::-1]

 print(res)

3、长度

 print(len(["aaa",111,2222]))

4、成员运算in和not in

 print(111 in ["aaa",111,2222])

5、追加

 l=[111,222,333]
 l.append(444)
 l.append(555)
  print(l)

## 插入

 l=[111,222,333]
 l.insert(1,6666)  # 索引，值
 print(l)

    
 l=[111,222,333]
 res = l.append(444)   # 值
 res = l.insert(1,444)
 print(res)

6、删除

 l=[111,222,333]  
    
# 万能删除

 del l[0]

 print(l)

# l.remove(指定元素)

 res=l.remove(222)

 print(l)

 print(res)  #None

# l.pop(指定索引)

 res=l.pop(1)

 print(l)

 print(res)

7、循环

 l=[111,222,333]

 for x in l:

    print(x)
 for i,x in enumrate(l)
    print(i,x)

=》=》需要掌握的操作（****）

l = [11,22,33,44,33,55]
new_l = l.copy()   # new_l = l[:]  # 浅拷贝

print(len(l))  # l._len_() # 长度


# l.index()        # 查看某一个元素出现的索引
print(l.index(33))   # 对应2号索引
print(l.index(777))  # 找不到就报错

# l.count()        # 统计某一个元素出现的个数
print(l.count(33)) # 3  出现3次

# l.clear          # 清空列表，把列表里面所有元素都删掉
l.clear()
print(l)           # [] 剩下空列表

# l.extend         # 往列表里面一次加多个值
l.extend('hello')  # 底层相当于调了一个for循环
l.extend([1,2,3])  
l.append([1,2,3])  # 往列表里加了一个子列表
print(l)

# l.reverse()      # 把列表里面的元素倒过来
l.reverse()
print()

# l.sort()         # 排序
l=[11,-3,9,7,99,73]
l.sort()           # 默认从小到大的顺序
l.sort(reverse=Ture) # 从大到小的顺序
print(l)           

• 该类型总结

  ​ 存多个值

  ​ 有序

​ 可变

---

• 元组tuple的基本使用

• 1、用途：元组就相当于一种不可变的列表，所以说元组也是按照位置存放多个任意类型的元素

• 2、定义方式：在 () 内用逗号分隔开多个任意类型的元素

x = (11)
print(x,type(x))  # 11 <class 'int'>

#   整型  浮点型  字符串    列表
t = (11, 11.33, "xxx", [44,55])
print(t[-1][0])   # 44
print(type(t))    # <class 'tuple'>

# tuple数据类型转换:只要是可迭代的类型都可以转换成元组tuple

# 注意：如果元组内只有一个元素，那么必须用逗号分隔

t = (11,)
print(type(t))    # <class 'tuple'>

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

优先掌握操作：（****）

1、按索引取值（正向取+反向取）：只能取，不能改

t = (11, 22, 33)
t[0] = 7777   # 元组不支持赋值操作

2、切片（顾头不顾尾，步长）

t = (11, 22, 33, 44, 55, 666)
print(t[0:4:2])  # (11, 33)

3、长度

t = (11, 22, 33, 44, 55, 666)
print(len(t))    #  6

4、成员运算in和not in

t = (11, 22, 33, [44, 55, 666])
print([44, 55, 666] in t)     # True

5、循环

t = (11, 22, 33, [44, 55, 666])
for x in t:
print(x)

• 需要掌握的

t = (33, 22, 33, [44, 55, 666])
print(t.count(33))   # 2  统计某个元素出现的个数
print(t.index(33, 1, 4)) # 2 指定范围从1开始找

• 该类型总结

​ 存多个数

​ 有序

​ 不可变：(元组指的不可变，是元组索引对应的内存地址不可变，

​ 如果元组内子元素是列表的话是可以改的)

---

• 字典dict的基本使用

• 1、用途：按照key:value的方式存放多个值，其中key对value应该有描述性的效果

• 2、定义方式：在{}内用逗号分隔开多个元素，每个元素都是key:value的组合，其中value可以是

  任意类型但是key必须是不可变类型，通常是字符串类型,并且key不能重复

  d={1:111111,1.1:22222222222,"k1":333333,(1,2,3):44444444,[1,2,3]:5555}  # d=dict(...)
  print(d[1])
  print(d[1.1])
  print(d[(1,2,3)])
  # TypeError: unhashable type: 'list'
  # <class 'tuple'>
  
  # dict数据类型转换 (数据类型的转换比较狭窄)
  res = dict([("name","egon"),["age",18],["gender","male"]])
  print(res) # {'name':'egon', 'age': 18, 'gender':'male'}
  
  res = dict(a=1,b=2,c=3)  # 可以用这种方式造字典
  print(res)             # {'a':1, 'b':2, 'c':3}
  
  d={}                # 造空字典
  d=dict()
  print(type(d))
  
  # {} + fromkeys 可以快速初始化字典
  
  res = {}.fromkeys(['name',"age","gender"],None) # 前面每一个值都跟None配对
  res = {}.fromkeys(['name',"age","gender"],11)  #前面每一个值都跟11配对
  res["name"]=666       # 只有name值变了，其余的都不变
  
  # key先准备好，value值先置空None，保证初始状态之后再赋值给value
  # 通常都是None
  res = {}.fromkeys(['name',"age","gender"],[])
  res["name"]=666
  print(res)
  res["name"].append(1111111)
  print(res)
  

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

  =》=》=》优先掌握的操作：(*****)

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

d={"k1":111,'k2':222}
print(d['k1'])

d['k1']=6666
d['k3']=6666     # 字典是可以根据不存在的key往里面加值的
print(d)

2、长度len

d={"k1":111,'k2':222}
print(len(d))   # 2 

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

d={"name":"egon",'age':18}
print("egon" in d)    #   False
print("name" in d)    #   True

4、删除

d={"name":"egon",'age':18}
print(d)
del d["name"]      # 万能删除法

v = d.pop("name")  # 指定key删除
print(d)           # 显示key已经删除
print(v)           # pop删除功能会把删除key对应的value值返回 

item = d.popitem()
print(item)  # popitme删除法会把删除的key和value值存成元组返回
print(d)

5、键keys()，值values()，键值对items()

d={"name":"egon",'age':18,"gender":"male"}
print(d.keys())
print(d.values())
print(d.items())

6、循环

d={"name":"egon",'age':18,"gender":"male"}
for k in d.keys():
    print(k)

for k in d:         # 不加.keys()默认就是
    print(k)    

for v in d.values(): # 只遍历value
    print(v)

for k,v in d.items():  # k,v = ('gender', 'male'),
    print(k,v)

# 用list的方式还原成Python 2 的样子
print(list(d.keys()))
print(list(d.values()))
print(list(d.items()))

7、d.get()（取值方式）

d={"name":"egon",'age':18,"gender":"male"}
print(d["name"])      # 通常取值用这种方式
print(d.get("name"))


print(d["xxx"])      # key不存在 报错
print(d.get("xxx"))  # 没取到key返回None ，key值不存在的时候采用此种方式

=》=》需要掌握（****）

d={"name":"egon",'age':18,"gender":"male"}
d.clear()     # 清空字典里面的key和value值
print(d)      # {}

d.copy()      # 浅copy

d={"name":"egon",'age':18,"gender":"xxx"}
if "gender" not in d:
    d['gender']="male" 
print(d)

d.setdefault()  # key不存在则添加key:value,key如果存在则什么都不做
d.setdefault("gender","male")   # 与上面if 同种功能
print(d)


d.update()  # 更新字典，不相同的加入老字典，相同的新替旧
d={"name":"egon",'age':18,"gender":"male"}
d.update({"k1":111,"name":"xxx"})   #
print(d)

• 该类型总结

​ 存多个值

​ 无序

​ 可变

d={'k1':111}
print(id(d))
d['k1']=2222222
print(id(d))