python字符类型

python中的字符类
一、索引
使用索引来访问序列中的元素
正向索引：0123456
负向索引：  -3 -2-1

二、根据索引切片
公式：开始值，结束值，步长
包含开始值，不包含结束值，
索引从0开始
案例：
str1="abcdefghijk"
#正向索引：01234567
print(str1[0:1]) #0索引，包含开始值，不包含结束值
print(str1[0:3]) #abc 0是开始值，3是结束值
print(str1[-1:-3:-1]) #-1开始值，-3结束值，-1反向
print(str1[-3:-1]) #ij  #-3开始值，-1结束值
print(str1[2:]) #cdefghijk  2开始值，空格，代表所有
print(str1[:5]) #abcde  开始值空，所有值，5结束值
print(str1[1:6:2]) #bdf  1开始值，6是结束值，2步长（间隔）
print(str1[::3]) #adgj  间隔3
print(str1[:])##abcdefghijk 显示所有内容
print(str1[::-1]) #kjihgfedcba 反转

三、字符类型
str 字符类型
str2="abcefghakla2masz"
str3="ABC"
str4="asdf"
str5="1345"
str6="Anmmm"
# print(str2.capitalize()) #Abcefg hijklmn 首个字母大写
# print(str2.title()) #Abcefg Hijklmn #首个字母大写，每个字母大写
# print(str2.count("a")) # 2  统计字符个数
# print("*".join(str2)) #把集合中的字符按自定义的分隔符连接在一起
# print(str2.split("h")) #把字符串通过指定标识符进行分割
# print(str2.strip("a")) #删除字符串开头和结尾有a或b的字符 bcefg hijklmn
# print(str2.rstrip("a")) #删除字符串结尾有a序列字符abcefg hijklmn
# print(str2.lstrip("a")) #删除字符串开头有ab序列bcefg hijklmna
# print(str2.startswith("a")) #判断字符串是否以什么开始 #True
# print(str2.startswith("b")) #判断字符串是否以什么开始 False
# print(str2.endswith("n")) #True判断字符串是否以什么结束
# print(str2.endswith("m")) #False判断字符串是否以什么结束
# print(str2.find("a")) #0显示查找到的索引位，左边开始查，找到就停止查找
# print(str2.find("x")) #-1 查找不存在显示-1
# print(str2.rfind("a")) #11  索引位，右边开始查，找到就停止查找
# print(str2.rfind("p")) #-1 查找不存在显示-1
# print(str2.replace("a","1")) #1bcefghijkl1mn 将所有指定字符替换
# print(str2.replace("a","1",2)) #1bcefgh1klamasz 指定替换字符次数
# print(str3.lower()) #abc方法转换字符串中所有大写字符为小写
# print(str4.upper())#ASDF  将小写转换成大写
# print(str1.isdigit()) #False 判断全数字
# print(str5.isdigit()) #True 判断全数字
# print(str1.isalnum()) #True判断字符串当中是否全都为数字，全为字母，或者数字字母组合
print(str2.isalpha()) #False判断是否纯字母
print(str6.istitle()) #True判断字符串中首字母是否为大写，其他是否为小写，其他不为小写则为否
print(str3.isupper()) #True判断是否纯大写
print(str3.islower()) #False 判断是否纯小写

练习题：
把字符串user_controller转换为驼峰命名UserController大驼峰在java用作变量命名
（前英文为大写后英文为小写） 小驼峰：作为变量命名
方法1：
str8="user_controller"
a=str8.title()
b=a.split("_")
print("".join(b))

方法2：
# a=str8.split("_")
# b=""
# print(a)
# for i in  a:
#     b=b+str(i).capitalize()
# print(b) #UserController
四、列表
字符类型：list
符号：【】
定义：列表好似一组有序存储的数据，也是python常见的序列值，序列中的每个元素都分配一个索引，
定义列表的方法：
方法一：通过list定义
案例：
a="a1234"
print(type(a)) #<class 'str'>
s=list(a)
print(s) #['a', '1', '2', '3', '4']
print(type(s)) #<class 'list'>

方法二：通过【】定义
案例：
list1=[1,2,3,4,5]
print(type(list1))
1、常用的函数
（1）添加函数 ，通过索引切片
案例：
list1=[1,2,3,4,5]
list1[2]="a"  #插入数据，将原来数据覆盖
print(list1)
（2）addend添加（默认添加在末尾）
案例：
list1=[1,2,3,4,5]
list1.append("s") #[1, 2, 3, 4, 5, 's']
print(list1)
（3）insert 插入（根据索引插入内容，原来的数据向后移动一位）
list1=[1,2,3,4,5]
list1.insert(2,"a")
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]
（5）romove 删除函数（根据元素删除）
案例：
list1=[1,2,3,4,5]
list1.remove(1)
print(list1) #[2, 3, 4, 5]
案例2：
list1=[1,2,3,4,5,1,1]
list1.remove(1)
print(list1) #[2, 3, 4, 5, 1, 1] 
多个元素时只删除前一个
（6）del根据索引删除 
案例：
list1=[1,2,3,4,5,1,1]
del list1[2]
print(list1)
（7）pop删除 （默认删除后一位）
案例：
list1=[1,2,3,4,5,1,1]
list1.pop()  #默认删除最后一位
print(list1) #[1, 2, 3, 4, 5, 1]
（8）index 根据内容查看索引位
案例：
list1=[1,2,3,4,5,1,1]
print(list1.index(5))
（9）sort 排序， 升序
案例：
list1=[1,2,3,4,5,1,1]
list1.sort()
print(list1) #[1, 1, 1, 2, 3, 4, 5]
（10）sorted 函数  ：
升序、降序
案例：
list1=[1,2,3,4,5,1,1]
print(sorted(list1,reverse=True)) 降序
print(sorted(list1,reverse= False)) 升序
（11）reverse  函数：反转
案例：
list1=[1,2,3,4,5,1,1]
list1.reverse()
print(list1) #[1, 1, 5, 4, 3, 2, 1]
五、元组
定义：元祖是python中的一种数据结构，元组由不同的元素组成，
每个元素可存储不同类型的数据；如字符串，数值等。
元祖是“写保护”，元祖作为一个整体，创建后不能做任何修改操作。
符号：（）
字符类型：tuple
创建元组：
案例
t=(1,2,3)
print(type(t)) #<class 'tuple'>
注意点：当一个元素的时候，要加一个，号
元组运用：
（t=(1,2,3,4,2)
print(type(t)) #<class 'tuple'>
（1）print(t.index(3)) #2  根据内容查看索引位
（2）print(t.count(2)) #2  统计元素出现的次数
（3）元组要修改，先通过list将元组改成列表修改，在通过tuple将列表转换元组
案例：
t=(1,2,3,4,2)
print(type(t))
s=list(t)  #通过list将元组转换成列表
print(type(s))
s.append("w") #利用列表的函数修改内容
print(s)
c=tuple(s) #过tuple 将列表转换成元组
print(type(c))
print(c)
4、元组和列表的区别
相同点： 有序、都支持切片
不同点：
（1）列表的字符类型：lsit，元组的字符类型是：tuple
（2）列表是可变对象，元组是不可变对象
（3）列表的符号【】，元组用的（）
 （4）元列相对列表比较安全

六、字典
(1)字典的字符类型:dict
(2)符号：{}
（3）存储方式：键值对
（4）字典的键唯一，值是变化的
（5）创建字典：
方法一：{} 定义字典
案例：
d={"name":"zs","age":18}
print(type(d))#<class 'dict'>

方法：dict转换
案例：
li=[("a",1),("b",2)]
print(type(li)) #<class 'list'>
d=dict(li)
print(type(d)) #<class 'dict'>
print(d) #{'a': 1, 'b': 2}
（6）字典的函数
1、添加键值对
d={"name":"zs","age":18}
d["h"]=3
print(d) #{'name': 'zs', 'age': 18, 'h': 3}
2、取出所有的键：
d={"name":"zs","age":18}
print(d.keys()) #dict_keys(['name', 'age'])
3、取出所有值
d={"name":"zs","age":18}
print(d.values()) #dict_values(['zs', 18])
4、根据键取出值
d={"name":"zs","age":18}
print(d["name"])
5、添加默认值（优先级小于表格中的元素）
案例1：
d={"name":"zs","age":18}
d.setdefault("c","1")
print(d)
案例2：
d={"name":"zs","age":18}
d.setdefault("age","1")
print(d) #{'name': 'zs', 'age': 18}
案例3：添加内容的优先级：   直接添加> 本身元素>默认添加元素
d={"name":"zs","age":18}
d["age"]= "10"
print(d)
6、删除字典指定键
案例：
d={"name":"zs","age":18}
del  d["name"]
print(d)
7、clear清除一个字典
案例：
d={"name":"zs","age":18}
d.clear()
print(d) #{}
8、pop 删除字典
案例1：删除指定的内容
d={"name":"zs","age":18}
d.pop("name")
print(d) #{'age': 18}
9、get根据键获取值
案例
d={"name":"zs","age":18}
print(d.get("name")) #zs
10、popitem 默认删除一组键值
d={"name":"zs","age":18}
print(d.popitem()) #('age', 18) 
11、update两个字典合并
案例：
d={"name":"zs","age":18}
d1={"fs":"88","cj":20}
d.update(d1)
print(d) #{'name': 'zs', 'age': 18, 'fs': '88', 'cj': 20}
12、copy 复制字典
案例：
d={"name":"zs","age":18}
s=d.copy()
print(d) #{'name': 'zs', 'age': 18}
print(s) #{'name': 'zs', 'age': 18}
13、for循环 遍历字典
案例1：遍历键和值
d={"name":"zs","age":18}
for i  in d:
    print(i,d[i])
案例2：遍历所有键
d={"name":"zs","age":18}
for i  in d:
    print(i)
14、使用items 遍历键和组
案例
d={"name":"zs","age":18}
for k，v  in d.items():
    print(k,v)
15、formkeys快速生成字典
案例：
print({}.fromkeys(["name","age"])) #{'name': None, 'age': None}
print({}.fromkeys(["name","age"],"1")) #{'name': '1', 'age': '1'}
16、update 合并字典
# d1 = {"name": "zs", "age": 18}
# d2={"a":1,"b":2,"c":3,"d":4}
# d1.update(d2)
# print(d1) #{'name': 'zs', 'age': 18, 'a': 1, 'b': 2, 'c': 3, 'd': 4}
# print(d2) #{'a': 1, 'b': 2, 'c': 3, 'd': 4}

七、集合
最主要作用：去重
集合：无序

（1）可变集合 ：set
字符类型：<class 'set'>
1、集合去重
案例：list1=[1,2,3,4,5,1,1]
s=set(list1)
print(type(s)) #<class 'set'>
print(s) #{1, 2, 3, 4, 5}
2、copy复制集合
list1=[1,2,3,4,5,1,1]
s=set(list1)
c=s.copy()
print(c)
print(s)
3、clear 清除集合
list1=[1,2,3,4,5,1,1]
s=set(list1)
print(s.clear()) #None
4、pop删除
list1=[1,2,3,4,5,1,1]
s=set(list1)
s.pop()
print(s)
5、add 添加元素
list1=[1,2,3,4,5,1,1]
s=set(list1)
s.add(9)
print(s)
6、remove 删除集合的内容
案例
list1=[1,2,3,4,5,1,1]
s=set(list1)
s.remove(3)
print(s)
7、update 将两个集合合并成一个集合
list1=[1,2,3,4,5,1,1]
list2=[6,6,7787]
s=set(list1)
m=set(list2)
s.update(m)
print(s)
（2）不可变集合：frozenset
1、只有一个从copy函数可以使用：
案例
list1=[1,2,3,4,5,1,1]
s=frozenset(list1)
c=s.copy()
print(c)

以上都字符类型：
int（数值）、str（字符）、list（列表）、tuple（元组）、dict（字典）、set（集合） 、frozenset（不可变集合）
整理下每个字符类型的内容

面试题:
1.python的字符类型有哪些？

2、列表和元组的区别？

3、字符、列表、元组、字典、集合的了解？