一、索引
索引在公司中一般也叫下标，或角标
定义：可我们可以直接使用索引来访问序列中的元素，同时索引可分为正向索引和负向索引两种，而切片也会用到索引，如下图：
Python中有序列：字符，列表，元组
无序：集合
正向索引：从0开始
负向索引：-1开始
二、切片
定义：切片是指对操作的对象截取其中一部分的操作，字符串，列表，元组都支持切片操作
切片的语法：【开始索引：结束索引 ：步长】
备注：显示结果：包含开始值，不包含结束值
str="abcdefghigklmn" print(str[1:3]) # 结果：bc print(str[0]) #结果：a print(str[:])#print(str[:]) print(str[3:]) #print(str[:]) 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', '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",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)) 案例2：
str="abc" print(type(str)) s=list(str) print(type(s))
1、列表中索引和切片
（1）通过索引添加值（覆盖原有值）
案例：
list1=[1,2,3,4,5] list1[1]="s" print(list1) #结果:[1, 's', 3, 4, 5] (2)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)
（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)
（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))
（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)
（10）pop 函数 默认移除列表中最后一个元素，并返回元素值
list1=[9,2,0,4,3,5] list1.pop() print(list1) #[9, 2, 0, 4, 3] ==================================== 元组 元组不可变 定义：元组是python中一种数据结构，元组由不同的元素组成，每个元素可存储不同类型的数据；如字符串，数字，甚至元组， 元组是“写保护”的，即元组中元素作为一个整体，创建后不能做任何修改操作。
a=(1,2,3) print(type(a)) print(a)
当出现一个字符时，加上逗号，（就变成了元组） b=(1,) print(type(b)) print(b) 元组函数运用： （1）index 索引
a=(1,2,3) print(a.index(2))
（2）元组需要修改，只能将元组转换成列表，使用列表的函数操作，列表操作完在转换成元组
a=(1,2,3) print(type(a)) b=list(a) #通过list将元组转换成列表 print(type(b)) print(b) b.insert(2,"s") #通过列表中的函数取操作转换后的元组 print(b) yz=tuple(b) #通过tuple 将列表转换成元组 print(type(yz)) print(yz) #打印元组
（3）元组转换列表
a=(1,2,3) print(type(a)) b=list(a) print(type(b))
（4）列表转换成元组
s=[1,2,3] print(type(s)) c=tuple(s) print(type(c)) print(c) （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))
cc=dict(c)
print(type(cc))
print(cc)
字典中常见的函数：
1、添加一个键值对
（1）新的键和值
s={'a': 1, 'b': 2, 'c': 3}
s["d"]=4
print(s)
（2）添加已经存在的键值对 （键不变，值改变）
s={'a': 1, 'b': 2, 'c': 3}
s["c"]=4
print(s) # 说明插入的值比默认的值的优先级高
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'])
5、字典中默认添加元素 setdefault
（1）当新增的键值都显示（不存在）
s={'a': 1, 'b': 2, 'c': 3}
s.setdefault("d",4)
print(s)
（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)
8、for循环遍历字典， （1）遍历所有的键 案例：
s={'a': 1, 'b': 2, 'c': 3}
for i in s:
print(i,end="")
（2）
遍历所有的键和值
s={'a': 1, 'b': 2, 'c': 3}
for i in s:
print(i,s[i])
（3）使用items（）完成遍历
s={'a': 1, 'b': 2, 'c': 3}
for k,v in s.items():
print(k,v)
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) #
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)
print(c)
12、copy函数复制字典 案例1:
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"))
==================================== 集合:最重要功能是去重 第一种：可变集合 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)) print(s)
#{1, 2, 3, 4, 6, 8}
2、对字符去重
a="abcdasmoa" s=set(a) print(type(s)) print(s)
3、函数的用法 (1)add 集合中添参数
list=[1,2,3,6,4,4,2,8]
s=set(list)
s.add("a")
print(s)
（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)
print(s)#{1, 2, 3, 4, 6, 8}
s.pop()
print(s)#{2, 3, 4, 6, 8}
（4）clear 清除
list=[1,2,3,6,4,4,2,8]
s=set(list)
print(s)#{1, 2, 3, 4, 6, 8}
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)#
print(v)#{1, 'a', 'b'}
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})
=================================== 字符，列表，元组，字典，集合 （可变集合，不可变集合） 作业： 1、python有哪些字符类型？ str,list,tuple,dict,set 2、列表，元组区别？
列表属于可变序列，它的元素可以随时修改或删除，元组是不可变序列，其中元素不可修改，只能整体替换。
列表可以使用append()、extend()、insert()、remove()和pop()等方法实现添加和修改，元组则没有这几个方法。
列表可以使用切片访问和修改列表中的元素，元组也支持切片，但是它只能通过切片访问。
元组比列表的访问和处理速度快，如果只需要访问不需要修改，建议使用元组。
列表不能作为字典的键，而元组则可以
3、字符，列表，元组，字典，集合的了解？
Python中常用的序列结构有：
- 字符串、
- 列表、
- 元组、
- 字典、
- 集合
a。字符串就是一种序列。
b。列表是内置可变序列，是包含多个元素的有序连续的内存空间。列表定义的标准语法格式：
a = [10,20,30,40]
其中，10,20,30,40 这些称为：列表a 的元素。
列表中的元素可以各不相同，可以是任意类型。比如：
a = [10,20,‘abc’,True]
c。元组tuple
列表属于可变序列，可以任意修改列表中的元素。
元组属于不可变序列，不能修改元组中的元素。
因此，元组没有增加元素、修改元素、删除元素相关的方法。
因此，我们只需要学习元组的创建和删除，元组中元素的访问和计数即可。元组支持如下操作：
索引访问
切片操作
连接操作
成员关系操作
比较运算操作
计数：元组长度len()、最大值max()、最小值min()、求和sum()等。
d。字典介绍
字典是“键值对”的无序可变序列，字典中的每个元素都是一个“键值对”，包含：“键对象”和“值对象”。可以通过“键对象”实现快速获取、删除、更新对应的“值对象”。
列表中我们通过“下标数字”找到对应的对象。字典中通过“键对象”找到对应的“值对象”。“键”是任意的不可变数据，比如：整数、浮点数、字符串、元组。但是：列表、字典、集合这些可变对象，不能作为“键”。并且“键”不可重复。
“值”可以是任意的数据，并且可重复。一个典型的字典的定义方式：
a = {'name':'gaoqi','age':18,'job':'programmer'}
e。集合概念
集合是无序可变，元素不能重复。实际上，集合底层是字典实现，集合的所有元素都是字典中的“键对象”，因此是不能重复的且唯一的。
扫一扫
1567
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
