第三课 Python之字符类型（索引.切片.字符串.列表.元组.字典）

一、索引

索引在公司中一般也叫下标，或角标

定义：可我们可以直接使用索引来访问序列中的元素，同时索引可分为正向索引和负向索引两种，而切片也会用到索引，如下图：

Python中的序列：字符串（String），列表（List），元组（Tuple）

无序：集合

正向索引：从0开始

负向索引：-1开始

二、切片

定义：切片是指对操作的对象截取其中一部分的操作，字符串，列表，元组都支持切片操作。

切片的语法：【开始索引：结束索引 ：步长】
步长不能为0，且默认值为1
备注：显示结果：包含开始值，不包含结束值

str="abcdefghigklmn"
print(str[1:3])   #结果：bc
print(str[0])     #结果：a
print(str[:])     #结果：abcdefghijklmn
print(str[3:])    #结果：defghijklmn

print(str[::-1]) #nmlkgihgfedcba 反转（重点）

print(str[::1])   #结果：abcdefghigklmn
print(str[1:8:2]) #结果：bdfh
print(str[-1:-8:-2]) #结果：nlgh
print(str[0:-1])  #开始到倒数第二个 #abcdefghigklm
print(str[2:3])   #结果：c

========================================
字符串：

str="abcdefcnamceac"
str1="abc"
str2="EFG"
str3="123"
str4="abc123"
str5="Abc789"

print(str.capitalize()) #首个字符大写 # Abcdef
print(str.title())      #首个字符大写 Abcdef

区别：

print(str.count('a')) # 统计字符个数     #2个
print(' '.join(str))  # 把集合中字符按照符号分隔 #a/b/c/d/e/f/n/a/m/e
print(str.split("c")) # 通过制定的内容进行表示分割  #['ab', 'def', 'nam', 'ea', '']

print(str.strip("a"))  #删除字符的开头和结尾的字符 #bcdefcnamceac
print(str.lstrip("a")) #删除字符的开头字符  #bcdefcnamceac
print(str.rstrip("a")) #删除字符的末尾字符       #abcdefname

print(str.startswith("a"))  #判断字符串是否以某个字符开头 #True
print(str.startswith("b"))  #判断字符串不是以某个字符开头 #False
print(str.endswith("c"))    #判断字符串是以某个字符结尾 #True
print(str.endswith("b"))    #判断字符串不是以某个字符结尾 False

print(str.find("c"))      #find是从左边开始查  #2
print(str.rfind("c"))     #rfind是从右边开始查  #13

print(str.replace("c","123"))   #替换，"c"是原值，"123"是新值
print(str.replace("c","123",2)) #指定替换的次数，是从左往右替换

print(str1.upper()) #将字符所有的小写字符转换成大写字母输出
print(str2.lower()) #将字符所有的大写字符转换成小写字母输出

print(str.isdigit())   #判断字符串中是否全是数字 #False
print(str3.isdigit())  #判断字符串中是否全是数字 #True
print(str4.isalpha())  #判断字符串中是全是字母   #False
print(str4.isalnum())  #判断字符串中是全是字母或全是数字或数字和字母组合 #True
print(str.istitle())   #判断首个字母是否大写 #False #必须是只有首个字母大写，其他字母为小写
print(str5.istitle())  # True
print(str1.islower())  #判断字符是否都是小写
print(str2.isupper())  #判断字符是否都是大写

========================================
列表：

类型：<class 'list'>
符号：[ ]
定义：列表（list） 是一组有序存储的数据，也是python常见的序列之一，序列中的每个元素都分配一个索引，第一个元素索引是0，第二个元素索引是1，依次类推，序列都可以进行的操作包括索引，切片。

定义列表的方法有两种：
方法一：list1=[1,2,3,4] #直接通过[]进行定义
方法二：list2=list（'12345'） #直接通过list转换

案例1：
list=[1,2,3,4,5]
print(type(list))   结果：<class 'list'>

案例2：
str="abc"
print(type(str))
s=list(str)
print(type(s))      结果：<class 'str'>
                         <class 'list'>

1、列表中索引和切片
（1）通过索引添加值（覆盖原有值）
案例：

list1=[1,2,3,4,5]
list1[1]="s"
print(list1)   #结果:[1, 's', 3, 4, 5]

list1=[1,2,3,4,5]
list1[2:]="我们暴富15班"
print(list1)   #结果:[1, 2, '我', '们', '暴', '富', '1', '5', '班']

2、列表中对应的函数
(1)append函数：添加一个元素 (默认添加在最后一位)

案例：
list1=[1,2,3,4,5]
list1.append("name")
print(list1)      结果：[1, 2, 3, 4, 5, 'name']

（2）extend函数：连接两个列表

list1=[1,2,3,4,5]
list2=[6,7,8,9,10]
list1.extend(list2)
print(list1) #[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(list2) #[6, 7, 8, 9, 10]

（3）insert（ index，value）函数：在指定位置插入一条数据

list1=[1,2,3,4,5]
list1.insert(2,"t")
print(list1)      结果：[1, 2, 't', 3, 4, 5]

（4）remove 函数：（移除元素），删除列表中的值，从左开始删除，只删除第一个

list1=[1,2,3,4,5]
list1.remove(3)
print(list1)      结果：[1, 2, 4, 5]

（5）del 索引删除值

list1=[1,2,3,4,3,5]
del   list1[3]
print(list1)      结果：[1, 2, 3, 3, 5]

（6）index 函数：在列表中查找元素所对应的索引值

list1=[1,2,3,4,3,5]     #索引位是3
print(list1.index(4))     #结果：3

（7）sort 函数:实现列表的升序排列

list1=[9,2,0,4,3,5]
list1.sort()
print(list1)     #结果：[0, 2, 3, 4, 5, 9]

（8）sorted 函数：实现降序排列

list1=[9,2,0,4,3,5]
print(sorted(list1,reverse=True))  #降序 #[9, 5, 4, 3, 2, 0]
print(sorted(list1,reverse=False)) #升序 #[0, 2, 3, 4, 5, 9]

（9）reverse 函数：列表元素反转

list1=[9,2,0,4,3,5]
list1.reverse()
print(list1)      #结果：[5, 3, 4, 0, 2, 9]

（10）pop 函数
默认移除列表中最后一个元素，并返回元素值
list1=[9,2,0,4,3,5]
list1.pop()
print(list1) #结果：[9, 2, 0, 4, 3]
注：在列表中pop函数是唯一 一个既能改变列表元素又有返回值。

============================
元组
定义：元组（tuple）是python中常用的一种数据结构，元组由不同的元素组成，每个元素可存储不同类型的数据，如字符串，数字，甚至元组。
元组是“写保护”的，即元组中元素作为一个整体，创建后不能做任何修改操作。

注：元组中的值不可以直接改变，可以间接改变（先改成列表，通过列表改值，再改成元组）。

a=(1,2,3)
print(type(a))
print(a)    结果：<class 'tuple'>
                 (1, 2, 3)

当出现一个字符时，加上逗号，（就变成了元组）

b=(1,)
print(type(b))
print(b)    结果：<class 'tuple'>
                 (1,)

元组函数运用：
（1）index 索引

a=(1,2,3)
print(a.index(2))    结果：1

conct 统计

t2=(1,2,1,3)
print(t2.count(1)) #  统计元素个数

（2）元组需要修改，只能将元组转换成列表，使用列表的函数操作，列表操作完再转换成元组

a=(1,2,3)
print(type(a))  # <class 'tuple'>
b=list(a)       #通过list将元组转换成列表
print(type(b))  # <class 'list'>
print(b)        # [1,2,3]

b.insert(2,"s")  #列表中的函数操作
print(b)         # [1, 2, 's', 3]
yz=tuple(b)      #通过tuple将列表转换成元组
print(type(yz))
print(yz)        # (1, 2, 's', 3)

（3）元组转换列表

a=(1,2,3)
print(type(a))
b=list(a)
print(type(b))
print(b)       #[1, 2, 3]

（4）列表转换成元组

s=[1,2,3]
print(type(s))
c=tuple(s)
print(type(c))
print(c)       #(1, 2, 3)

（5）元组和列表的区别(重要)：
**相同：
1、都是序列类型的容器对象，可以存放任何类型的数据
2、都支持切片、迭代等操作
**不同：
1、列表list是可变对象，元组tuple是不可变对象
2、tuple不可变，使用tuple编写的代码更安全
3、列表是【 】，元组是（ ）
4、列表的字符类型：list ，元组的字符类型：tuple

====================================
字典：
字典的字符类型 <class 'dict'>
符号：{ }

1、字典（dict）是一种可变容器模型，且可存储任意类型对象
2、字典的每个键值key：value对用冒号 键值对形式
3、键值用：分割，每个键值对之间用逗号分隔
4、整个字典用{ }包含
5、字典键唯一，值不是唯一的

定义字典的方式：

方法一：通过{ }定义字典

d={'name':'hz','age':18}
print(type(d))

方法二：通过dict来转换成字典

c=[('a',1),('b',2),('c',3)]
print(type(c))   #<class 'list'>
cc=dict(c)
print(type(cc))  #<class 'dict'>
print(cc)        #{'a': 1, 'b': 2, 'c': 3}

字典中常见的函数：
1、添加一个键值对
（1）新的键和值

s={'a': 1, 'b': 2, 'c': 3}
s["d"]=4
print(s)            结果：{'a': 1, 'b': 2, 'c': 3, 'd': 4}

（2）添加已经存在的键值对 （键不变，值改变）

s={'a': 1, 'b': 2, 'c': 3}
s["c"]=4
print(s) #说明插入的值比默认的值的优先级高    结果：{'a': 1, 'b': 2, 'c': 4}

2、使用keys取出所有键返回列表

s={'a': 1, 'b': 2, 'c': 3}
print(s.keys( ))     结果：dict_keys(['a', 'b', 'c'])

3、使用values取出所有值返回列表

s={'a': 1, 'b': 2, 'c': 3}
print(s.values( ))   结果：dict_values([1, 2, 3])

4、取出具体键的值

s={'a': 1, 'b': 2, 'c': 3}
print(s['c'])        结果：3

5、字典中默认添加元素 setdefault
（1）当新增的键值都显示（不存在）

s={'a': 1, 'b': 2, 'c': 3}
s.setdefault("d",4)
print(s)             结果：{'a': 1, 'b': 2, 'c': 3, 'd': 4}

（2）插入存在的键值，新值不会覆盖原值（默认值优先级要低于字典中的键值）

s={'a': 1, 'b': 2, 'c': 3}
s.setdefault("c",4)
print(s)            #{'a': 1, 'b': 2, 'c': 3}

6、 clear 清空字典

s={'a': 1, 'b': 2, 'c': 3}
s.clear( )
print(s)        #结果：{ }

7、删除字典中指定的键，连同值也删除

案例1：
s={'a': 1, 'b': 2, 'c': 3}
del s["b"]
print(s)       #{'a': 1, 'c': 3}

案例2：
s={'a': 1, 'b': 2, 'c': 3}
del s["b"]
del s['c']
print(s)       #结果：{'a': 1}

8、字典的遍历：for循环遍历字典
（1）遍历所有的键

s={'a': 1, 'b': 2, 'c': 3}
for  i  in  s:
    print(i,end=" ")    结果：abc

（2）遍历所有的键和值

s={'a': 1, 'b': 2, 'c': 3}
for  i  in  s:
    print(i,s[i])       结果:a 1
                            b 2
                            c 3

（3）使用items（ ）完成遍历

s={'a': 1, 'b': 2, 'c': 3}
for  k,v  in  s.items():
    print(k,v)              结果：a 1
                             b 2
                             c 3

8、pop 删除函数
删除指定键并返回删除的值

s={'a': 1, 'b': 2, 'c': 3}
print(s.pop("a"))    #1

9、get（key）方法，通过key获取值，当键不存在，返回none

案例1：
s={'a': 1, 'b': 2, 'c': 3}
print(s.get("b"))   #2
案例2：
s={'a': 1, 'b': 2, 'c': 3}
print(s.get("d"))   #None

10、popitem 函数随机删除返回删除字典中的键值对（一般默认删除末尾的键值）

s={'a': 1, 'b': 2, 'c': 3}
v=s.popitem()
print(v)      # ('c', 3) 删除的键值
print(s)      # {'a': 1, 'b': 2}

11、update函数利用一个字典更新另一个字典

案例1:
s={'a': 1, 'b': 2, 'c': 3}
c={'d': 4, 'e': 5}
s.update(c)
print(s)  #{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
print(c)  #{'d': 4, 'e': 5}

案例2: 有重复键，显示覆盖的字典中的值
s={'a': 1, 'b': 2, 'c': 3}
c={'a': 4, 'e': 5}
s.update(c)
print(s)   #{'a': 4, 'b': 2, 'c': 3, 'e': 5}
print(c)

12、copy函数复制字典

s={'a': 1, 'b': 2, 'c': 3}
v=s.copy()
print(v)

13、fromkeys 函数可以给具体的键指定值

（1）快速创建字典
print({ }.fromkeys(["name",'age']))  
结果：{'name': None, 'age': None}

（2）快速创建字典键和值
print({ }.fromkeys(["name",'age'],"1"))  
结果：{'name': '1', 'age': '1'}

====================================
集合:最重要的功能是去重

第一种：可变集合 set
第二种：不可变集合 frozenset
字符类型：<class 'set'>
无序

案例：

1、对列表去重
list=[1,2,3,6,4,4,2,8]
print(type(list))  #<class 'list'>
s=set(list)
print(type(s))     #<class 'set'>
print(s)           结果：{1, 2, 3, 4, 6, 8}

2、对字符去重
a="abcdasmoa"
s=set(a)
print(type(s))
print(s)           结果：{'a', 'c', 'b', 'o', 'd', 's', 'm'}

3、函数的用法
(1)add 集合中添参数

list=[1,2,3,6,4,4,2,8]
s=set(list)
s.add("a")
print(s)           结果：{1, 2, 3, 4, 6, 8, 'a'}

（2）remove 删除具体的参数

list=[1,2,3,6,4,4,2,8]
s=set(list)
s.remove(3)
print(s)           #{1, 2, 4, 6, 8}

（3）pop 删除数据
注：随机删除内容，但不会对纯数字内容随机删除，会从小到大排序后删除第一个

list=[1,2,3,6,4,4,2,8]
s=set(list)
s.pop( )
print(s)            结果：{2, 3, 4, 6, 8}

（4）clear 清除

list=[1,2,3,6,4,4,2,8]
s=set(list)
s.clear( )
print(s)       #set( )

（5）copy 复制

list=[1,2,3,6,4,4,2,8]
s=set(list)
print(s）       #{1, 2, 3, 4, 6, 8}
k=s.copy()
print(k)        #{1, 2, 3, 4, 6, 8}

（6）update 将两个集合合并

list=[1,2,3,4,4,4,5,7,8,10,9,1]
s=set(list)
print(s)
list6=["a","b",1]
v=set(list6)
s.update(v)
print(s)        #{1, 2, 3, 4, 5, 7, 8, 9, 10, 'b', 'a'}

===============================
不可变结合：
frozenset

1、copy不可变集合
list=[1,2,3,6,4,4,2,8]
s=frozenset(list)
k=s.copy()
print(k) #frozenset({1, 2, 3, 4, 6, 8})
百度去重python中去重方法有几种？

===================================
数值 int，字符str，列表list，元组tuple，字典dict，集合 set （可变集合，不可变集合）
作业：
1、python有哪些字符类型？
2、列表，元组区别？
3、字符，列表，元组，字典，集合的了解？