python中的索引

定义：索引、切片、字符串、列表、元组、字典、集合

切片实例、列表对应的函数、字典中的函数

一、索引：

（1） 索引：通过索引号访问数据（我们可以直接使用索引来访问序列中的元素，同时索引可分为

正向和负向两种，而切片也会用到索引）

（2）索引分为：正向索引，负向索引

正向索引：从0开始

负向索引：从-1开始

（3）索引的格式：

开始值：结束值：步长     显示结果：不包含结束值  步长就是间隔

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

切片操作。

切片语法：[start_index:end_index:step]    start_index表示起始索引  end_index表示结束索引  step表示步长，步长不能为0，且默认值为1

注意点：切片操作是指按照步长，截取从起始索引到结束索引，但不包含结束索引（也就是结束索引减1）的所有元素。

语句: 

#索引、切片实例：
# str1="abcdewfghigk"
# print(str1[1]) #b  索引位从0开始左边，
# print(str1[-1]) #k  索引的负向索引是-1开始
# print(str1[1:6:2]) #bdw  1表示开始值，6表示结束值（不包含结束值），2步长（间隔）
# print(str1[2:]) #2是开始值，空代表所有
# print(str1[:]) #abcdewfghigk   显示所有的值
# print(str1[::-1]) #反转 #kgihgfwedcba  ：反转输出面试题常遇
# print(str1[-1:-5:-1]) #kgih  负向索引要用步长也要-负
# print(str1[-5:-1]) #ghig   正向索引要用步长也要-正
# print(str1[:-1]) #abcdewfghig  开始值倒数第二个数

TypeError: ‘str’ object is not callable字面上意思:
就是str不可以被系统调用,其实原因就是：

你正在调用一个不能被调用的变量或对象，具体表现就是调用函数、变量的方式错误

这个错误就是：str()是系统自带的，你不能在用它的时候自己同时定义一个别的叫做str的变量，这样会冲突.

出现这个情况错误一般是：
1.str变量重复定义 把str 改成 s 等其他变量能解决问题
2.变量重复定义 不能同时定义同一个名字叫name的,会冲突.改成name1
3.函数或者字符串调用错误 检查代码

二、字符串常用的函数

字符串是Python中最常用的数据类型。我们可以使用单引号''或者双引号""来创建字符串

字符类型：通过引号 "" ,'' 定义

<class 'str'>

#字符串常用函数
# str="abcdef cnamceaca"
# str1="abc"
# str2="EFG"
# str3="123"
# str4="abc@123"
# str5="Abc789"
# print(str.capitalize()) #首个字符大写 # Abcdefcnamceac
# print(str.title()) #首个字符大写 Abcdef Cnamceac
# # 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是从右边开始查  #14
# print(str.replace("c","123")) #替换，"c"是原值，"123"是新值
# print(str.replace("c","123",2)) #指定替换的次数，是从左往右替换
# print(str1.upper()) #将字符所有的小写字符转换成大写字母输出 #BC
# print(str2.lower()) #将字符所有的大写字符转换成小写字母输出
# print(str.isdigit())  #判断字符串中是否全是数字 #False
# print(str3.isdigit())  #判断字符串中是否全是数字#True
# print(str4.isalpha())  #判断字符串中是全是字母#False
# print(str2.isalpha())  #判断字符串中是全是字母#True
# print(str4.isalnum())  ##判断字符串中是全是字母或全是数字或数字和字母组合 #True
# print(str.istitle()) #判断首个字母是否大写 #False #必须是只有首个字符大写，其他字母为小写
# print(str5.istitle()) # True
# print(str1.islower()) #判断字符是否都是小写
# print(str2.isupper())#判断字符是否都是大写

三、列表

列表（list）是一组有序存储的数据，也是python常见的序列之一，序列中的每个元素都分配一个索引，第一个元素索引是0，第二个元素索引是1，依此类推。序列都可以进行的操作包括索引，切片，加，乘，检查成员

类型：<class 'list'>

表达符号：[]

定义列表：list 或者 []   list1=[1,2,3,4,5,8,10]或list2=list('1234')

list1=[1,2,3,4,5,8,10] #通过[]定义list
print(type(list1)) #<class 'list'>
a="12345"
print(type(a)) #<class 'str'>
b=list(a) #list将字符列转换成列表
print(type(b)) #<class 'list'>
print(b)

list1=[1,2,3,4,5,6,78,10] #插入的值覆盖原来的值

list1[2]=7 #2是索引，第三位，7是插入值

print(list1)

list1=[1,2,3,4,5,8,10]  #插入的值覆盖原来的值,插在第四位，第四位原来的值挪到后面了

list1.insert(3,6)   #3是索引第四位，6是插入的值，

print(list1)  #[1,2,3,6,4,5,8,10]

列表中索引和切片赋值，实操

（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） 在指定位置插入数据（根据索引插入值,原有的值索引位+1）

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)

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

（5）del   索引删除值（根据索引删除）

list1=[1,2,3,4,3,5]

del   list1[3] #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]

list1=[9,2,0,4,3,5]

list1.pop(2) #根据索引删除数据

print(list1)  #[9, 2,  4, 3]

（11）index 查看元素的索引位

list1=[1,2,3,4,5,1,8,10]
print(list1.index(8)) #索引是6

四、python之字符类型（元组、字典、集合）

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

表达符：()      

定义：tuple1=(1,2,3)  注意：当元组只有一个元素时,后面要加逗号，如：tuple1=（1,）

1.字符类型：<class 'tuple'>

t=(1)
t1=(1,2)
print(type(t)) #<class 'int'>
print(type(t1)) #<class 'tuple'>

2.符号：（） ，两个元素以上

3.元组特性：不可变，相对列表安全

4.元组中的函数

（1）count函数

t1 = (1, 2,3,5,6,7,1)
print(t1.count(1)) #2

（2）index  查看元素所在的索引

t1=(1,2,3,5,6,7,1)
print(t1.index(7)) #5,7是内容，得出的5是索引

5.如果要改变元组：通过list将元组转换成列表，使用列表函数操作内容，tuple 将列表转换成元组

t1 = (1,2,3,5,6,7,1)
print(type(t1))  #<class 'tuple'>
s=list(t1)
print(type(s)) #<class 'list'>
s.append(8)
print(s)  #[1, 2, 3, 5, 6, 7, 1, 8]
t3=tuple(s)
print(type(t3)) #<class 'tuple'>
print(t3)  #(1, 2, 3, 5, 6, 7, 1, 8)

6.元组和列表的区别

相同：

1.都是序列类型的容器对象，可以存放任何类型的数据

2.支持切片、迭代等操作

不同：

1.list 是可变的对象，元组tuple是不可变的对象

2.tuple不可变，所以使用tuple可以使代码更安全

五、字典

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

list5=[("name","zs"),("age",18)]
print(type(list5))  #<class 'list'>
d2=dict(list5)
print(type(d2))   #<class 'dict'>
print(d2)  #{'name': 'zs', 'age': 18}

#a、（不存在的键）

d1={"name":"zd","age":18}
d1["sex"]="男"
print(d1) #{'name': 'zd', 'age': 18, 'sex': '男'}

#b、（不存在的键）

d1={"name":"zd","age":18}
d1["age"]=20  #插入值优先级高于字典中的值
print(d1) #{'name': 'zd', 'age': 20}

2、keys  获取键（keys显示所有的键）

d1={"name":"zd","age":18}
print(d1.keys()) #dict_keys(['name', 'age'])

3、values 获字典中的值

d1={"name":"zd","age":18}
print(d1.values()) #dict_values(['zd', 18])

4、根据键取值

d1={"name":"zd","age":18}
print(d1["name"]) #zd

5、setdefault 设置默认值

d1={"name":"zd","age":18}
print(d1.setdefault("age",20)) #18

6、del  删除字典
#a、删除整个字典

d1={"name":"zd","age":18}
del d1

b、删除字典中某一个键和值

d1={"name":"zd","age":18}
del d1["age"]
print(d1) #{'name': 'zd'}

d1={"name":"zd","age":18}
for  i  in d1:
    print(i,d1[i]) #name zd  age 18  i是键，后一个i是值

d1={"name":"zd","age":18}
for  i  in d1:
    print(i)  #name age

d1={"name":"zd","age":18}
for  k,v  in d1.items():
    print(k,v) #name zd age 18

d1={"name":"zd","age":18}
d1.pop("age")
print(d1)  #{'name': 'zd'}

d1={"name":"zd","age":18}
d1.clear()
print(d1)  #{}

d1={"name":"zd","age":18}
print(d1.get("age")) #18

#print({}.fromkeys(["name",'age'])) #{'name': None, 'age': None}
#快速生成字典和值
#print({}.fromkeys(["name",'age'],"2")) #{'name': '2', 'age': '2'}

d1={"name":"zd","age":18}
print(d1.popitem())  #('age', 18)

d1={"name":"zd","age":18}
d2={"sg":180,"sex":"男"}
d1.update(d2)
print(d1) #{'name': 'zd', 'age': 18, 'sg': 180, 'sex': '男'}
print(d2) #{'sg': 180, 'sex': '男'}

d1={"name":"zd","age":18}
d3=d1.copy()
print(d1) #{'name': 'zd', 'age': 18}
print(d3) #{'name': 'zd', 'age': 18}

list6=[1,3,4,5,6,1,9,1]
print(type(list6)) #<class 'set'>
jh=set(list6)
print(type(jh)) #<class 'set'>
print(jh) #{1, 3, 4, 5, 6, 9}

2、不可变集合frozenset    字符类型：<class 'frozenset'>

test='hello'

a=frozenset(test)

b=a.copy()

b.add('888')#报错AttributeError:'frozenset'objecthasnoattribute'add'

print(b)

函数copy

list6=[1,3,7,5,7,7,9,9]
bkb=frozenset(list6)
print(type(bkb)) #<class 'frozenset'>
m=bkb.copy()
print(bkb) #frozenset({1, 3, 5, 7, 9})
print(m) #frozenset({1, 3, 5, 7, 9})

七、集合的函数

（1）add添加集合参数

# list6=[1,3,4,5,6,1,9,1]
# jh=set(list6)
# jh.add("a")
# print(jh)  #{1, 3, 4, 5, 6, 9, 'a'}

#(2)remove删除参数
# list6=[1,3,4,5,6,1,9,1]
# jh=set(list6)
# jh.remove(9)
# print(jh) #{1, 3, 4, 5, 6}

#(3)pop删除（默认删除最后一位）
# list6=[1,3,4,5,6,1,9,1]
# jh=set(list6)
# jh.pop()
# print(jh) #{3, 4, 5, 6, 9}

#(4)clear清除集合
# list6=[1,3,4,5,6,1,9,1]
# jh=set(list6)
# jh.clear()
# print(jh) #set()

#copy 复制一个集合
# list6=[1,3,4,5,6,1,9,1]
# jh=set(list6)
# s=jh.copy()
# print(jh) #{1, 3, 4, 5, 6, 9}
# print(s)  #{1, 3, 4, 5, 6, 9}

#（6）update  将两个集合合并
# list6=[1,3,7,5,7,7,9,9]
# list9=[2,4,6,8,10,2,4,6]
# jh1=set(list6)
# jh2=set(list9)
# print(jh1)  #{1, 3, 5, 7, 9}
# print(jh2)  #{2, 4, 6, 8, 10}
# jh1.update(jh2)
# print(jh1)  #{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

思维图：

区别与联系

元组中可存储数值，字符串，列表，元组等任何类型的数据。与列表类似，区别在于列表中的元素是可修改的，而元组一经创建，元素不可更改。tuple（data）创建元祖，data表示可以转化为元组的数据如字符串，元组，range对象等。

超文本：页面不止文本，还有图片链接等等