day00 预习 ------基础数据类型预习 ,int ,str ,bool ,dict ,set ,切片,等相关

知识点明确

1 int

2 str

3 元祖

4.列表

5. 字典

6 集合

7 布尔

1  int  数据类型

　　　int 数据类型指的是. 数字型的内容 ,主要用于计算,

2 str 字符类型

　　　　str 类型是常用的字符串类型. 最常用的数据类型, 包含很多相关操作知识点,,   切片,字符去空格,倒叙,去重,等等

　　@1  字符串角标     字符串都是有单独的角标

　　　　　　ep:

　　　　　　zifu = 'ABCDEF'

　　　　　　print(zifu[0])

　　　　　　输出 A

　　　　　　print(zifu[1])

　　　　　　输出 B

　　@ 2   切片    首先要明确字符串的基本配置 , 步长,起点,断点         内容[起始:终点:步长]

　　　　ep

　　　　　　key = 'ABCDEF'

　　　　　　　　　012345

　　　　　　print(key[1:])     第一种,从头拿到尾巴    类似坐标从左边一直拿步长默认为1 拿到没有为止

　　　　　　输出 BCDEF

　　　　　　print(key[-1:])  第二种, 同样类似坐标, -1 就是倒着拿,  从右 往左一个一个拿  由于步长是正的(默认正的所以,只能拿一个)

　　　　　　输出 F

　　　　　　print(key[-1::-1])

　　　　　　输出 FECDBA      从右向左拿,没有终点,每次向左拿一个

　　　　　　print(key[2:4])

　　　　　　输出 CDE        第三种 ,从第3个为止拿到第5个为止

　　　　　　print(key[-2::-4])

　　　　　　输出EA         从右往左拿,没有终点,负数像左查4个

3 tuple  元祖   具体操作和列表相似, 但是不允许修改

　　　　### 元祖里面的内容,如  ([123],[321,[132]])

　　　　　　　　　　　　　　里面的允许修改

4 list  列表   列表操作相关的有   增,删,改,查 ,函数

　　　　　　首先明确列表的基本配置      由   [ ..  ] 组成  同样每个都有索引

　　　　　　　　如     ep :   key = ['123','132','321']

　　　　　　　　　　                       0         1       2

　　　　　　　　　　　　　print(key[1])

　　　　　　　　　　　　　　输出  132

　　　　　　　　@ 增加         分为三种  :分别是 1  .按照索引位置增加,     2 直接默认增加到最后,   3 按照迭代增加到最后

　　　　　　　　　　　　1   :  函数    insert(索引,内容)

　　　　　　　　　　　　　　ep :

　　　　　　　　　　　　　　　key.insert(0,'456')

　　　　　　　　　　　　　　　print(key)

　　　　　　　　　　　　　　　　>>>>['456','123','132','321']

　　　　　　　　　　　　2    : 函数   append(内容)

　　　　　　　　　　　　　　　ep:

　　　　　　　　　　　　　　　　key.append('678')

　　　　　　　　　　　　　　　　print(key)

　　　　　　　　　　　　　　　　>>>>>['456','123','132','321','678']

　　　　　　　　　　　　3   :函数  expend(可迭代对象)              #列表.     #字符串

　　　　　　　　　　　　　　 # 如果可迭代对象是列表

　　　　　　　　　　　　　　　　ep:

　　　　　　　　　　　　　　      key.expend(['q,w,e'])

　　　　　　　　　　　　　　　　print(key)

　　　　　　　　　　　　　　　　>>>>>['456','123','132','321','678','q,w,e']

　　　　　　　　　　　　　　　　key.expend(['a,b,c'],['2,3'])

　　　　　　　　　　　　　　　　print(key)

　　　　　　　　　　　　　　　　>>>>>['456','123','132','321','678','a,b,c','2,3']

# 如果可迭代对象是字符串

　　　　　　　　　　　　　　　　ep:

　　　　　　　　　　　　　　　　key.expend('def')

　　　　　　　　　　　　　　　　print(key)

　　　　　　　　　　　　　　　　>>>>>>['456','123','132','321','678','a,b,c','2,3','d','e','f']

　　　　　　　　 @  删除       删除分为  4种  ,    1 按照索引位置删除 ,返回值

　　　　　　　　　　　　　　　　　　　　　　2 按照索引位置删除  ,也可以切片删除,没有返回值　　　　　　　　　　　　　　　　　　　　　　　

　　　　　　　　　　　　　　　　　　　　　　3 按照元素内容删除

　　　　　　　　　　　　　　　　　　　　　　4 直接清空所有列表

　　　　　　　　　　　 1    按照索引位置删除,有返回值     ,返回值是删除的内容

　　　　　　　　　　　　　　函数  pop(索引)   返回值为所删除的内容

　　　　　ep:

　　　　　　　　　　　　　　　　　key = ['123','132','312']

　　　　　　　　　　　　　　　　　l = key.pop(1)

　　　　　　　　　　　　　　　　　print(key)

　　　　　　　　　　　　　　　　　　>>>>>['123','312']

　　　　　　　　　　　　　　　　　print(l)

　　　　　　　　　　　　　　　　　　>>>>>132

　　　　　　　　　　　2    按照索引位置删除  没有返回值

　　　　　　　　　　　　　　函数 del   列表名[索引]

　　　　　　　　　　　　　　　　 del   列表名[索引切片]

　　　　　　　　　　　　　　ep:

　　　　　　　　　　　　　　　　key = ['123','132','312']

　　　　　　　　　　　　　　　　del key[1]

　　　　　　　　　　　　　　　　print(key)

　　　　　　　　　　　　　　　　>>>>>['123','312']

　　　　　　　　　　　　　　　　del  key[1:2]

　　　　　　　　　　　　　　　　print(key)

　　　　　　　　　　　　　　　　>>>>['123']

　　　　　　　　　　　3  按照元素内容删除      没有返回值

　　　　　　　　　　　　　　函数  列表名.remove(内容)

　　　　　　　　　　　　　　　　ep

　　　　　　　　　　　　　　　　　key = ['123','321','132']

　　　　　　　　　　　　　　　　　　key.remove('321')

　　　　　　　　　　　　　　　　　print(key)

　　　　　　　　　　　　　　　　　>>>>>>['123','132']

　　　　　　　　　　 4      列表清空

　　　　　　　　　　　　　　函数  列表名.clear()

　　　　　　　　　　　　　　　　ep

　　　　　　　　　　　　　　　　　key = ['123','132','312']

　　　　　　　　　　　　　　　　　　key.clear()

　　　　　　　　　　　　　　　　　print(key)

　　　　　　　　　　　　　　　　　>>>>>>[]

　　　　　　　　@  改     分为两种     ,分别为

　　　　　　　　　　　　　　　　　　　　1 具体位置更改

　　　　　　　　　　　　　　　　　　　　 2  切片更改

　　　　　　　　　　　　1  列表的具体位置更改

　　　　　　　　　　　　　　ep

　　　　　　　　　　　　　　key = ['123','132','312']

　　　　　　　　　　　　　　　key[2] = '999'

　　　　　　　　　　　　　　print(key)

　　　　　　　　　　　　　　>>>>>['123','132','999']

　　　　　　　　　　　　2 切片更改

　　　　　　　　　　　　　 ep

　　　　　　　　　　　　　　key = ['123','132','321','666']       #注意切片顾头不顾尾

　　　　　　　　　　　　　　　　　　0       1      2      3

　　　　　　　　　　　　　　　　key[1:3]  = ['888','999']

　　　　　　　　　　　　　　print(key)

　　　　　　　　　　　　　　>>>>>['123','888','999','666']

5 字典  字典相关操作有 增,删 ,改,查

　　　　  字典的定义 : dict ,字典都是由键值对组成的. key- value

　　　　　　

字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组。

　　字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

　　　　　　dic = {1:'a',2:'b',3:'c'}

　　　　>1 增加

　　　　　　@ 1     由字典直接操作,如果已经存在键则直接替换对应得值

　　　　　　　　　　dic[4] = 'd'

　　　　　　@ 2     函数  setdefault    如果没有则增加.如果已经有了则不做变动

　　　　　　　　　setdefault('key','vlaue')

>2 删除

　　　　　　@ 1  函数  pop('key')   ,没有返回值   删除键对应值得内容

　　　　　　@2  clear()          ,没有返回值 ,清空字典所有内容

　　　 > 3 改

　　　　　　　@1 直接在  变量名['key' ] = '新值'

　　　　　> 4查

　　　　　　　@ 1  通过深入键 获取值得内容

　　　　　　　@  2 通过get('键') 获取值得内容

　　　　　> 其他相关操作

　　　　　　　>函数   @1 item()

主要是迭代操作,通过循环把内容从字典 中取出

　　　　　　　　　　　　取出的内容以元祖的形式体现

　　　　　　　　　　　@2 key()

　　　　                      获取字典中键的内容,以字典的形式体现出来

　　　　　　　　　　　@ 3 value

　　　　　　　　　　　获取字典中值得内容, 以字典的形式体现出来

6 集合     集合是没有规律的存储形式  , 集合内部是无序的,唯一的

　　　　 >1 集合的定义

　　　　　　set1 = {'1','2','3'}　　　

　　　　　@ 1增加

　　　　　　　set1.add('内容')

　　　　　@  2 删除

set1. pop()　　  # 随机删除一个

　　　　　　　set1.remove('内容')   # 删除指定内容