python中的数据结构

标签：包含   重复   双引号   操作   代码   split   cap   xtend   直接   

一、索引

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

1、我们可以通过索引位读取序列中的指定元素，索引可以分为正向索引和负向索引

2、索引的表达方式：str[x]其中x是需要我们自己填写的一个数据。

　　如，str[1]、str[0]

3、索引中，正向索引从0开始，负向索引从-1开始

4、表示不隔位

　　[起始索引位：结束索引位：步长值]

　　切片语法中：(1)包含起始不包含结束

　　　　　　　　(2)隔位不能为0，可以为1，从2开始有效果

5、range(遍历函数)

 

　 （起始位：结束位：隔位）

　　　　print（list（range（1，10，3）））

　　　　打印结果为[1，4，7]

　　遍历函数中：包含起始不包含结束，隔位不能为0，可以为1

　　　　print（list（range（10）））

　　　　打印结果为：[0，1，2，3，4，5，6，7，8，9]

　　　　print（list（range（2,10）））

　　　　打印结果为：[2，3，4，5，6，7，8，9]

　　　　print（list（range（2,10,3）））

二、切片

1、切片表达式：str：[start_index:end_index:step]

　　　　　　　　　  开始索引：结束索引：步长值

2、解释：start_index:开始索引（可以取值）

　　　　  end_index :结束索引（不能取值）

　　　　  step：步长值（脚跨几个楼梯）

3、注意

　　　　(1)切片中，如果步长不写默认为1

　　　　(2)切片取值从索引开始到索引结束，结果不包括索引结束位置的值（取到索引结束前一位）

　　　　(3)步长从开始索引走起，步长分正负

三、常见的字符串函数

字符串的定义：要用单引号或双引号（英文）括起来表示

　　str=‘abc123‘

　　print(type(str))

　　打印类型：

　　str1="admin:123456"

　　print(type(str1))

　　打印类型：

1、str.capitalize():实现首字母大写,其它字母小写输出

　　str="dasfagfg"
　　print(str.capitalize())
　　输出结果：Dasfagfg
　　

　　tr="dasAagfg"
　　print(str.capitalize())
　　输出结果：Dasaagfg
2、str.count(‘xx‘):统计xx字符在str中的数量

　　str="dasAagfg"
　　print(str.count(‘a‘))
　　输出结果：2

　　str="dasAagfg1111"
　　print(str.count("1"))
　　输出结果：4
　　总结：在count函数中，统计字符时，如果是数字，必须加引号
3、"".join(‘xx‘):拼接函数，自动定义分割，来分割当前的字符串（自定义符号）
　　str="123456"
　　print("_".join(str))
　　输出结果：1_2_3_4_5_6
4、str.split("xx"):分割函数，指定当前字符串作为一个字符串，且返回一个列表
　　str=“abc123”
　　num=str.split("b")
　　print(num)
　　输出结果：“a”，“c123”
5、str.strip("x"):删除字符串开头和结尾的字符
　　str="abc123"
　　print(str.strip("ab"))
　　输出结果：c123
6、str.lstrip("x"):删除字符串开头的字符
　　str="abc123"
　　print(str.lstrip("ab"))
　　输出结果：c123
7、str.rstrip("x"):删除字符串结尾的字符
　　str="abc123"
　　print(str.rstrip("23"))
　　输出结果：abc1
8、str.startswith("x"):判断字符串是否以x开头，若是：返回True；否则，返回False
　　str="abc123"
　　str.startswith("abc")
　　输出结果：True
9、str.endswith("x"):判断字符串是否以x结尾，若是：返回True；否则，返回False

　　str="abc123"
　　str.endswith("123")
　　输出结果：True

10、find、rfind通过具体的值来找到对应值的索引位
　　从左往右查找，找到第一个返回当前字符的索引位，如果找不到，返回-1
　　str="abcad123"
　　print(str.find("a"))
　　输出结果：0
　　从右往左查找，找到第一个返回当前字符的索引位，如果找不到，返回-1
　　str=“abc123”
　　print（str.rfind("1")）
　　输出结果：3
11、str.replace( "x","y" ,5 ):替换指定字符串，且可以指定替换次数
　　str="abc1231"
　　print(str.replace("1","ycy",3))
　　输出结果：abcycy23ycy
12、str.lower()：将字符串中的所有大写字母改为小写字母
　　str="ABC12ed"
　　print(str.lower(str))
　　输出结果：abc12ed
13、str.upper:将字符串中的所有小写字母改为大写字母
　　str="ABC12ed"
　　print(str.upper())
　　输出结果：ABC12ED
四、字符串的判断方法
以下都是字符串的判断，返回结果只有true or false
1、isalnum:判断字符串是否是字母、数字或数字字母组合
　　
　　str="abc"
　　print(str.isalnum())
　　输出结果：True
　　特殊情况：
　　str=“中国”
　　print(str.isalnum())
　　print（str.encode(utf-8).isalnum()）
　　输出结果：True
　　　　　　   Faluse
　　str=“123”
　　print(str.isalnum())
　　输出结果：True
2、str.isdigit():判断字符串是否全为数字
　　str="123"
　　print(str.isdigit())
　　输出结果：True
s
3、str.islower():判断字母是否都为小写
　　str=“abc1”
　　print(str.lower())
　　输出结果：True
4、str.isupper():判断字母是否为大写
　　str="ABC1"
　　print（str.issupper()）
　　输出结果：True
5、str.istitle():判断首字母是否为大写，其它字母是否为小写
　　str="Avv1"
　　print(str.istitle())

　　输出结果：true
五、python中的列表
　　字符串：str""
　　列表：list=[]
　　元组：tuple（）
　　字典：dict{}
　　集合：可变集合，不可变集合
　　1、list列表
　　　　定义列表的两种方法：
　　　　(1)通过 [ ] 来直接定义
　　　　　　list=[1,2,3,4,5,‘test‘  ]
　　　　　　print(type(list))
　　　　　　输出结果：列表类型
　　
　　　　(2)通过list来转换
　　　　　　a=‘hello‘
　　　　　　print(type(a))
　　　　　　输出结果：
　　　　　　b=list(a)
　　　　　　print(type(b))
　　　　　　输出结果：
　　　　　　print(b)
　　　　　　输出结果：[‘h‘,‘e‘,‘l‘,‘l‘,‘o‘]　　
　　
　　　　(3)对列表进行操作
　　　　　　通过索引赋值：格式 列表名[索引]=“新值”
　　　　　　通过切片赋值：格式 列表名[索引：]=“新值”
　　　　　　append：添加函数
　　　　　　exend：添加函数，两个表拼接
　　　　　　insert：插入
　　　　　　remove：删除
　　　　　　del：删除
　　　　　　sort：升序
　　　　　　sorted：降序
　　　　　　reverse：反转
　　　　　　pop：删除
　　　　　　index：索引位
　　2、根据索引来对列表赋值
　　　　(1)索引方式赋值
　　　　　　list=[1,2,3,4,5,"rest"]
　　　　　　list[4]="yy"
　　　　　　print(list)
　　　　　　打印结果：[1,2,3,4,"yy","rest"]
　　　　(2)从索引位开始赋值
　　　　　　list=[1,2,3,4,5]
　　　　　　list[3:]="老王吃屁"
　　　　　　print(list)
　　　　　　输出结果：[1, 2, 3, ‘老‘, ‘王‘, ‘吃‘, ‘屁‘]
　　3、列表添加元素：append
　　　　
　　　　a=[1,2,3,4,5]
　　　　print（a.append（“hello”））
　　　　输出结果：返回结果none
　　　　a=[1,2,3,4,5]
　　　　print(a.append("hello"))
　　　　输出结果：[1,2,3,4,5，“hello”]
　　4、列表拼接：extend
　　　　a=[1,2,3]
　　　　b=[4,5,6]
　　　　a.extend(b)
　　　　print(a)
　　　　输出结果：[1,2,3,4,5,6]

　　　　a=[1,2,3]
　　　　b=[4,5,6]
　　　　print(a.extend(b))
　　　　输出结果：none
　　5、列表中插入一个值：insert
　　　　(1)超出的索引值
　　　　　　a=[1,2,3,4,5]
　　　　　　a.insert(10,"helllo")
　　　　　　print(a)
　　　　　　输出结果：[1,2,3,4,5,"hello"]
　　　　(2)存在的索引值（插入到索引位前面）

　　　　　　a=[1,2,3,4,5]
　　　　　　a.insert(0,"helllo")
　　　　　　print(a)
　　　　　　输出结果：[“hello”，1,2,3,4,5]
　　　　(3)负向索引（插入到索引位前面）

　　　　　　a=[1,2,3,4,5]
　　　　　　a.insert(-1,"helllo")
　　　　　　print(a)
　　　　　　输出结果：[1,2,3,4,“hello”，5]
　　6、删除列表中的元素：remove，del
　　　　(1)remove删除具体的值

　　　　　　a=[“a”,1,2,3,"a",4,5,"b"]
　　　　　　a.remove("helllo")
　　　　　　print(a)
　　　　　　输出结果：[1,2,3,"a",4,5,"b"]
　　　　　　备注：多个同样的值，只能删除一个；可以删除数字、字母、字符
　　　　(2)del通过索引位删除
　　　　　　a=[1,2,3,4,5]
　　　　　　del a[1]
　　　　　　print(a)
　　　　　　输出结果：[1,3,4,5]
　　　　　　备注：超出索引位报错
　　7、升序：sort
　　　　a=[1,5,4,3,2]
　　　　a.sort()
　　　　print(a)
　　　　输出结果：[1,2,3,4,5]
　　　　备注：字母、字符不能进行排序，会报错

　　　　a=[1,5,4,3,2]
　　　　print(sorted（a,reverse=False）)
　　　　输出结果：[1,2,3,4,5]

　　8、降序：sorted

　　　　a=[1,5,4,3,2]
　　　　print(sorted（a,reverse=True）)
　　　　输出结果：[5,4,3,2,1]
　　　　备注：ture和false 中的首个字母大写
　　9、反转输出：reverse

　　　　a=[1,2,5,4,5]
　　　　a.reverse()
　　　　print(a)
　　　　输出结果：[5,4,5,2,1]
　　10、删除函数：pop

　　　　a=[1,2,3,4,5]
　　　　a.pop()
　　　　print(a)
　　　　输出结果：[1，2，3，4]
　　　　备注：默认删除末尾值

　　　　a=[1,2,3,4,5]
　　　　print(a.pop())
　　　　输出结果：[5]
　　　　备注：输出被删除的值

　　　　a=[1,2,3,4,5]
　　　　a.pop(1)
　　　　print(a)
　　　　输出结果：[1，3，4，5]
　　　　备注：删除索引位为1的值

　　　　a=[1,2,3,4,5]
　　　　print(a.pop(1))
　　　　输出结果：[2]
　　　　备注：删除索引位为1的值并输出删除值
　　11、删除具体的值：remove
　　　　a=[1,2,‘a‘,‘b‘,3,‘a‘]
　　　　a.remove(‘a‘)
　　　　print(a)
　　　　输出结果：[1,2,‘b‘,3,‘a‘]
　　　　备注：默认删除一个值
　　12、根据索引位输出具体值：index
　　　　a=[1,2,3,4,5]
　　　　print(a.index(2))
　　　　输出结果：3
六、python中的元组
　　元组的类型为：tuple ()
　　字符串的类型为：str =“”
　　列表的类型为：list =[]
　　元组定义后由于不可直接修改则相对于代码来说要更加安全
　　注意：当元组中只有一个值时，需要在值的后面加上逗号（，）
　　列表和元组的区别：列表可变，原则不可变
　　 注意：1、当（）中只有一个值的情况下，输入什么值，这个值就是什么类型
　　　　　 2、如果要让一个值的输出为元组，值后面要加逗号
　　1、元组转列表，通过list的方法
　　　　a=(1,2,3,4,5)
　　　　print(type(a))
　　　　输出结果：
　　　　b=list(a)
　　　　print(a)
　　　　输出结果：
　　2、转换成列表再进行修改、增加、删除

　　　　a=(1,2,3,4,5)
　　　　b=list(a)
　　　　b.append("yy")
　　　　print(b)
　　　　输出结果：[1,2,3,4,5,"yy"]
　　3、将列表转换成元组，使用tuple
　　　　a=[1,2,3,4,5]
　　　　print(type（a）)
　　　　输出结果：
　　　　b=type（a）
　　　　print（type（b））
　　　　输出结果：
　　4、元组可以通过切片操作
　　　　a=（1，2，3，4，5，6，7，8，9）
　　　　print（a[1:]）
　　　　输出结果：（2，3，4，5，6，7，8，9）
　　　　备注：a[1:]的意思是，从索引位1开始到末尾，步长值为1
　　　　print（a[::-1]）
　　　　输出结果：(9,8,7,6,5,4,3,2,1)
　　5、元组可以通过索引位取值
　　　　a=（1,2,3,4,5）
　　　　print(a[2])
　　　　输出结果：3
七、python中的字典：dict类型
　　字典是由键值对组成，键是唯一，值可以不唯一。
　　{}英文的大括号，也叫花括号
　　字典中，键值是一个整体，多个键值时需要用逗号隔开。
　　整数类型不需要加单双引号，其他的都需要加单双引号
　　键和值中间用英文的：冒号，比如，name：张三   定义一个字典
　　1、定义一个字典
　　　　d={"name":"张三","age":18}
　　　　print(type(d))
　　　　print(d)　　　　                                                                                                                                                      
　　　　输出结果：{"name":"张三","age":18}
　　2、列表转化成字典步骤（重点）
　　　　a=[(‘name‘,‘张三‘),(‘age‘,18)]
　　　　b=dict(a)
　　　　print(type(b))
　　　　输出结果：
　　　　print(b)
　　　　输出结果：{"name":"张三","age":18}
　　3、字典中添加键值对的格式：变量名[键]=值

　　　　a={"name":"张三","age":18}
　　　　a[‘sex‘]="男"
　　　　print(a)
　　　　输出结果：{‘name‘: ‘张三‘, ‘age‘: 18, ‘sex‘: ‘男‘}
　　4、替换字典中的值

　　　　a={"name":"张三","age":18}
　　　　a[‘name‘]="李四"
　　　　print(a)
　　　　输出结果：{‘name‘: ‘李四‘, ‘age‘: 18}
　　5、通过keys取出相应的键

　　　　a={"name":"张三","age":18}
　　　　print(a.keys())
　　　　输出结果：dict_keys([‘name‘, ‘age‘])
　　6、通过values取出相应的值

　　　　a={"name":"张三","age":18}
　　　　print(a.values())
　　　　输出结果：dict_values([‘张三‘, 18])
　　7、通过键来获取相应的值

　　　　a={"name":"张三","age":18}
　　　　print(a["name"])
　　　　输出结果：张三
　　8、添加设置默认键值

　　　　a={"name":"张三","age":18}
　　　　a.setdefault(‘sex‘,‘男‘)
　　　　print(a)
　　　　输出结果：{‘name‘: ‘张三‘, ‘age‘: 18, ‘sex‘: ‘男‘}
　　　　备注：字典的默认值优先级特别低
　　9、修改字典键值

　　　　a={"name":"张三","age":18}
　　　　a["name"]="李四"
　　　　print(a)
　　　　输出结果：{‘name‘: ‘李四‘, ‘age‘: 18}
　　10、删除键

　　　　a={"name":"张三","age":18}
　　　　del a["name"]
　　　　print(a)
　　　　输出结果：{‘age‘: 18}
　　11、使用for循环获取key

　　　　a={"name":"张三","age":18}
　　　　for k in a:
　　　　print(k)
　　12、使用for循环获取key，values

　　　　a={"name":"张三","age":18}
　　　　for k in a:
　　　　print(k，a[k])
　　　　输出结果：name 张三     age 18
　　13、通过iteams（）方法获取对应键值对

　　　　a={"name":"张三","age":18}
　　　　for k，v in a.items():
　　　　print(k，v)
　　　　输出结果：name 张三 age 18
　　14、通过pop函数删除指定的键，打印返回对应键的值

　　　 　a={"name":"张三","age":18}
　　　　print(a.pop("name"))
　　　　输出结果：张三
　　　　print（a）
　　　　输出结果：{‘age‘: 18}
　　15、打印删除后字典的内容（默认删除最后）

　　　　 a={"name":"张三","age":18}
　　　　print（a.popitem()）
　　　　输出结果：(‘age‘, 18)
　　16、清空当前字典的内容：clear

　　　　 a={"name":"张三","age":18}
　　　　a.clear()
　　　　print(a)
　　　　输出结果：{}
　　17、通过键获取对应的值

　　　　 a={"name":"张三","age":18}
　　　　print（a）
　　　　print（a.get(name)）
　　　　输出结果：张三
　　　　备注：如果是一个不存在的键，返回的值时none
　　18、快速生成一个字典的方法fromkeys
　　　　print{}.fromkeys([‘name‘,‘age‘])
　　　　输出结果：{‘name‘: None, ‘age‘: None}
　　　　a={}.fromkeys([‘name‘,‘age‘])
　　　　print（a）
　　　　输出结果：{‘name‘: None, ‘age‘: None}
　　19、生成一个字典和值
　　　　print（{}.fromkeys(["name","age"],"a")）
　　　　输出结果：{‘name‘: ‘a‘, ‘age‘: ‘a‘}
　　20、已生成字典，通过fromkeys赋值

　　　　a={"name":"张三","age":18}
　　　　print（{}.fromkeys(["name","age"],"a")）
　　　　输出结果：{‘name‘: ‘a‘, ‘age‘: ‘a‘}
　　21、将多个字典合并：update

　　　　a={"name":"张三","age":18}
　　　　c={"sex":"男"}
　　　　a.update(c)
　　　　print(c)
　　　　输出结果：{‘name‘: ‘张三‘, ‘age‘: 18, ‘sex‘: ‘男‘}
　　22、复制字典：copy

　　　　a={"name":"张三","age":18}
　　　　b=a.copy()
　　　　print(b)
　　　　输出结果：{‘name‘: ‘张三‘, ‘age‘: 18}
　　23、删除字典字段

　　　　a={"name":"张三","age":18}
　　　　del a["name"]
　　　　print(a)
　　　　输出结果：{‘age‘: 18}
八、集合
　　集合是不同元素的无序集合，与序列不同，集合没有切片操作。set集合最重要的功能就是去重，
集合可分为：可变集合、不可变集合。
　　（1）可变集合（set）：集合里面的元素是可以发生动态变化的，集合中可以动态的增加和删除。
　　（2）不可变集合（frozenset）：集合里面的元素不可以发生变换。
　　　备注：集合中的元素是无序的，且集合后元素不重复。
　　1、可变集合
　　　　1、对列表数据重复的进行去重
　　　　2、对一个字符串进行去重
　　2、对列表数据重复的进行去重
　　　　new=[1,2,3,44,3,2,1,55,44]
　　　　print(type(new))
　　　　输出结果：
　　　　print(new)
　　　　输出结果：[1, 2, 3, 44, 3, 2, 1, 55, 44]
　　　　yy=set(new)
　　　　print(type(yy))
　　　　输出结果：
　　　　print(yy)
　　　　输出结果：{1, 2, 3, 44, 55}
　　3、对一个字符串进行去重：set
　　　  向集合里添加元素：update、add
　　　　str="hello"
　　　　yy=set(str)
　　　　print(yy)
　　　　输出结果：{‘l‘, ‘h‘, ‘e‘, ‘o‘}
　　　　yy.update("8")
　　　　print(yy)
　　　　输出结果：{‘o‘, ‘e‘, ‘8‘, ‘l‘, ‘h‘}
　　　　yy.add("9")
　　　　print(yy)
　　　　输出结果：{‘8‘, ‘h‘, ‘o‘, ‘e‘, ‘9‘, ‘l‘}
　　　　备注：集合是无序的
　　4、清除集合中的内容：clear

　　　　xx="hello"
　　　　yy=set（xx）
　　　　yy.clear()
　　　　print(yy)
　　　　输出结果：set()
　　5、随机删除集合里的内容：pop

　　　　xx="hello"
　　　　yy=set（xx）
　　　　yy.pop()
　　　　print(yy)
　　　　输出结果：{‘h‘, ‘o‘, ‘l‘}
　　6、删除指定内容：remove

　　　　xx="hello"
　　　　yy=set（xx）
　　　　yy.remove("l")
　　　　print(yy)
　　　　输出结果：{‘h‘, ‘o‘, ‘e‘}
　　7、复制集合：copy

　　　　xx="hello"
　　　　yy=set（xx）
　　　　a=yy.copy()
　　　　print(a)
　　　　输出结果：{‘e‘, ‘l‘, ‘h‘, ‘o‘}
　　8、不可变集合：frozenset
　　　　不可变集合只能使用copy，进行添加或删除都会报错

　　　　xx="hello"
　　　　yy=forzenset（xx）
　　　　a=yy.copy()
　　　　print(a)
　　　　输出结果：frozenset({‘h‘, ‘l‘, ‘e‘, ‘o‘})

　

 

 

 

 

 

 

 

 

 

 

      

 

 

 

 

 

 

　　　　　　 

python中的数据结构

标签：包含   重复   双引号   操作   代码   split   cap   xtend   直接   

原文地址：https://www.cnblogs.com/yuecaoyu/p/14256622.html