python 的字符类型

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

 

Python中有序列：字符，列表，元组
无序：集合
正向索引：从0开始
负向索引：-1开始
二、切片
定义：切片是指对操作的对象截取其中一部分的操作，字符串，列表，元组都支持切片操作
切片的语法：【开始索引：结束索引 ：步长】
备注：显示结果：包含开始值，不包含结束值

案例：

str="abcdefghijk"
print(str[1]) #b
print(str[-1]) #k
print(str[1:5]) #bcde   包含开始值，不包含结束值
print(str[1:5:2]) #bd  1表示开始值，5表示的结束值，2表示步长
print(str[:]) #abcdefghijk  空表示所有
print(str[2:]) #cdefghijk  2开始，后面所有的显示
print(str[:2]) # ab
print(str[::-1]) #反转
print(str[-5:-1]) #ghij
print(str[-1:-5:-1]) #kjih
print(str[:-1]) #abcdefghij

二、字符类型

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', 'defname']
print(str.strip("a")) #删除字符的开头和结尾的字符 #bcdefname
print(str.lstrip("a")) #删除字符的开头字符 #bcdefnamea
print(str.rstrip("a")) #删除字符的末尾字符 #abcdefname
print(str.startswith("a")) #判断字符串是否以某个字符开头 #True
print(str.startswith("b")) #判断字符串不是以某个字符开头 #False
print(str.endswith("a")) #判断字符串是以某个字符结尾 #True
print(str.endswith("b")) #判断字符串不是以某个字符结尾 False
print(str.find("c")) #find是从左边开始查 #2
print(str.rfind("c")) #rfind是从右边开始查 #9
print(str.replace("c","123")) #替换，"c"是原值，"123"是新值
print(str.replace("c","123",9)) #指定替换的次数，是从左往右替换
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：

list1=[1,2,3,4,5]
print(type(list1)) #<class 'list'>
str1="1234"
print(type(str1)) #<class 'str'>
print(type(list(str1))) #['1', '2', '3', '4'] #<class 'list'>
列表的函数：
1、通过索引添加内容

 2、append  添加元素  默认添加到最后一位

list1=[1,2,3,4,5]
list1.append("6")
print(list1)

 3、insert  插入，根据索引位插入 ，不会覆盖

list1=[1,2,3,4,5]
list1.insert(2,"8")
print(list1)

 4、extend  连接两个表

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

5、remove删除元素   ，删除指定内容

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

[1, 2, 3, 4]
 
6、del 删除  ，根据索引删除

 7、pop 函数   

默认删除列表中最后一个元素，并返回元素值

plist1=[1,2,3,4,5]
list1.pop()
print(list1)

 8、revers函数   反转

list1=[1,2,3,4,5]
list1.reverse()
print(list1)

 9、sort  排序 ，升序

 10、sorted  升序和降序

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

 11、index 找到内容对应的索引

list1=[1,2,9,3,4,5]
print(list1.index(9))

 元组

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

不可变的

字符类型：tuple

案例1：

t=(1,2,3,4)
print(type(t)) #<class 'tuple'>
案例2：两个字符或者两个字符以上

t=(1,)
print(type(t)) #<class 'tuple'>
元组函数：
1、count

t=(1,2,3,4,5,1)
print(t.count(1))

 2、index  查看内容的索引位

t=(1,2,3,4,5,1)
print(t.index(2))

 3、如果要修改元组中内容，我们将通过list将元组转换称列表进行修改，修改后在通过tuple转回成元组

案例：

t=(1,2,3,4,5,1)
print(type(t)) #<class 'tuple'>
list1=list(t)  #通过list将元组转换成列表
print(type(list1)) #<class 'list'>
list1.append(9)
print(list1) #[1, 2, 3, 4, 5, 1, 9]
t1=tuple(list1) #通过tuple 将列表转换成元组
print(type(t1)) #<class 'tuple'>


4、元组和列表区别
1、元组不可变，列表可变
2、元组比列表更安全，
3、符号不样：元组（），列表是【】
4、字符类型：元组tuple ，列表 list

四、字典：

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

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

 

4、整个字典用{}包含

 

5、字典键唯一，值不是唯一的

 

定义字典的方式：

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

d={"name":"zs","age":"18"}
print(type(d)) #<class 'dict'>

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

list=[("name","zs"),("age","18")]
print(type(list)) #<class 'list'>
d=dict(list)
print(type(d)) #<class 'dict'>

字典函数使用：
1、添加字典的键值对
(1)添加字典中不存在的键值对

 

(1)添加字典中存在的键值对（优先级：添加的键值，要高于字典本身）

 （2）keys 返回所有的键

d={"name":"zs","age":"18"}
print(d.keys())

（3）values返回字典中的值

d={"name":"zs","age":"18"}
print(d.values())

 （4）根据键取出具体的键值

d={"name":"zs","age":"18"}
print(d["age"])

 （5）setdefault字典中添加默认值

  （1）添加一个不存在键值

 

（2）添加一个存在键值 （默认值优先级低于字典本身）

d={"name":"zs","age":"18"}
d.setdefault("age",20)
print(d)

（6）clear  清空字典

d={"name":"zs","age":"18"}
d.clear()
print(d) #{}
（7）del  删除指定的键

d={"name":"zs","age":"18"}
del d["age"]
print(d)

 （8）for 循环 遍历字典

 （9）for  循环 中iteam 

d={"name":"zs","age":"18"}
for  i ,j  in d.items():
    print(i,j)

 

（10）pop  删除函数
a、打印删除的内容

 b、打印删除后的内容

d={"name":"zs","age":"18"}
d.pop("name")
print(d)

 11、popitem() 默认删除末尾的字典值

 12、update  将多个字典合并成一个字典

d={"name":"zs","age":"18"}
d1={"id":"1","fs":80}
d.update(d1) #
print(d)#{'name': 'zs', 'age': '18', 'id': '1', 'fs': 80}
print(d1) #{'id': '1', 'fs': 80}
13、copy 复制字典

 14、通过get  获取键的值

d={"name":"zs","age":"18"}
print(d.get("name"))

 15、fornkeys 快速生成字典

a、print({}.fromkeys(["name","age"]))

 b、fornkeys 快速生成字典键值

print({}.fromkeys(["name","age"],"1"))

六、集合

集合:最重要功能是去重
第一种：可变集合 set

通过set 转换成可变集合
第二种：不可变集合 frozenset
字符类型：<class 'set'>
注意：无序

案例：
1、对列表去重

list1=[1,2,3,4,1,1,1,6,9]
s=set(list1)
print(type(s)) #<class 'set'>
print(s) #{1, 2, 3, 4, 6, 9}

2、对字符去重
a="abcdasmoa"
s=set(a)
print(type(s))
print(s)
3、函数的用法
(1)add 集合中添参数  注意点：添加内容是无序

# list1=[1,2,3,4,1,1,1,6,9]
list1="abcdsaaaaaaac"
s=set(list1)
s.add(8)
print(s)

（2）remove 删除具体的参数

list1=[1,2,3,4,1,1,1,6,9]
s=set(list1)
s.remove(9)
print(s)

 

（3）pop 删除数据  （随机删除）
list=[1,2,3,6,4,4,2,8]
s=set(list)
s.pop()
print(s)

 

（4）clear 清除

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

（5）copy 复制

list1=[1,2,3,4,1,1,1,6,9]
s=set(list1)
d=s.copy()
print(d)
print(s)

（6）update 将两个集合合并

list1=[1,2,3,4,1,1,1,6,9]
list2=["a","a","a","b","c"]
s=set(list1)
m=set(list2)
s.update(m)
print(s)
print(m)

不可变结合：
frozenset

1、copy不可变集合

list1=[1,2,3,4,1,1,1,6,9]
list2=["a","a","a","b","c"]
s=frozenset(list1)
c=s.copy()
print(c) #frozenset({1, 2, 3, 4, 6, 9})

百度去重python中去重方法有几种？

set 去重

在Python中，有几种方法可以删除重复数据。
一、使用set去重
set是Python中的一种数据结构，它可以自动去除重复的元素。只需要将列表、元组、字典等数据类型转换成set，再转换回来即可去重。例如：
a = [1,2,2,3,4,4,5]
b = list(set(a))
print(b)
输出结果为：[1, 2, 3, 4, 5]
二、使用字典去重
字典是Python内置的数据类型，可以用于存储无序的键值对。如果将列表中的元素作为字典的键，那么重复的元素只会保留一个。例如：

a = [1,2,2,3,4,4,5]
b = {}.fromkeys(a).keys()
print(list(b))
```
输出结果为：[1, 2, 3, 4, 5]
三、使用列表推导式去重
列表推导式是Python中一种简洁的写法，可以快速创建列表。通过对原列表进行遍历，将不重复的元素添加到新列表中即可。例如：
a = [1,2,2,3,4,4,5]
b = []
[b.append(i) for i in a if i not in b]
print(b)

输出结果为：[1, 2, 3, 4, 5]

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