pythone 数组下标 python数组下标为负数

11-列表:以中括号形式的数据集合

#列表可以存取任意类型（也可以叫做数组）
#列表和数组的区别：数组只能存取同种类型，列表各类型都可以存取
my_list = [100,99.9,"abc",True]
#class:list
print(my_list,type(my_list))
运行结果：[100,99.9,'abc',True] <class 'list'>
#下标索引（从0开始）
result = my_list[2]
print(result)
运行结果：abc

result = my_list[1]
#将数据放入列表中不会改变其类型
print(result,type(result))
运行结果：99.9 <class 'float'>
#下标：本质上是一个编号，可以根据下标取出容器中对应的元素

#python：正数下标和负数下标
#正数下标从0开始
#负数下标从-1开始，-1代表倒数第一个元素
result = my_list[-1]
print(result)
运行结果：True

#列表越界
result = my_list[100]
print(result)
运行结果：list index out of range

#列表拷贝
L1=L #意思是将L1也指向L的内存地址
L1=L[:]#意思是复制L的内容并指向新的内存地址

12-列表的增删改查

#定义一个空列表
my_list = []
print（my_list)
#列表增加数据（增删改查，数据库）
my_list.append(1)#append在列表后增加数据
my_list.append("大家好")
print(my_list)
运行结果：[1,'大家好']

#append这个方法没有返回结果，直接操作原本的变量
result = my_list.append(1)
print(result)
运行结果：None

#插入指定数据-根据下标，确定位置，写1就填在第二个位置，写0就填在第一个位置
my_list.insert(1,"abc")
print(my_list)
运行结果：[1,'abc','大家好']

my_fruit = ["西瓜","芒果","草莓"]
my_list.append(my_fruit)
print(my_list)
运行结果：[1,'abc','大家好',True,['西瓜','芒果','草莓']]
#将my_fruit列表整体作为一个元素，拼接到原列表最后一位

#将列表的元素取出来，然后拼接到原有的列表里面
my_list = [100,99.9,"abc",True]
my_str = [50,49,"ac",False]
all = my_list+my_str
print(all)
运行结果：[100, 99.9, 'abc', True, 50, 49, 'ac', False]

#第二种方法：
my_list = [100,99.9,"abc",True]
my_str = [50,49,"ac",False]
my_list.extend(my_str)
print(my_list)
运行结果：[100, 99.9, 'abc', True, 50, 49, 'ac', False]

#修改元素
my_list = [1,"abc","大家好","西瓜","芒果","草莓"]
my_list[0] = "葡萄"
print(my_list)
运行结果：['葡萄', 'abc', '大家好', '西瓜', '芒果', '草莓']

#删除列表中的元素
#删除指定数据（删除出现的第一个数据）
my_list = [1,"abc","大家好","西瓜","abc","草莓"]
my_list.remove("abc")
print(my_list)
运行结果：[1, '大家好', '西瓜', 'abc', '草莓']

#根据下标删除元素（不能列表越界，删除的下标要合法）
my_list = [1,"abc","大家好","西瓜","abc","草莓"]
del my_list[0]#无返回值
print(my_list)
运行结果：['abc', '大家好', '西瓜', 'abc', '草莓']

#使用pop的方式删除数据(pop如果不传任何参数，那么默认删除最后一个）
result = my_list.pop()
print(my_list,result)

#判断指定数据是否在列表当中(有返回True，没有返回False）
my_list = [1,"abc","大家好","西瓜","abc","草莓"]
result = "大家好" in my_list
print(result)
运行结果：True

#查找指定数据的下标
my_list = [1,"abc","大家好","西瓜","abc","草莓"]
result = my_list.index("大家好")
print(result)
运行结果：2

#根据指定数据获取数据在列表中的个数
my_list=[1,1,1,1,2]
result = my_list.count(1)
print(result)
运行结果：4

#列表的生成式：列表推导式（通俗理解为使用for循环快速创建一个列表）
#原方法
my_list = []
for i in range(0,6):
    my_list.append(i)
print(my_list)
运行结果：[0, 1, 2, 3, 4, 5]

#列表生成式的方式创建列表
my_newlist = [value for value in range(0,6)]
print(my_newlist)
运行结果：[0, 1, 2, 3, 4, 5]

#列表生成式可以统计每个元素的个数
my_list = [len(value) for value in ["abc","ab"]]
print(my_list)
运行结果：[3, 2]

#修改value值
my_list = [value*2 for value in range(0,6)]
print(my_list)
运行结果：[0, 2, 4, 6, 8, 10]

#给遍历出来的字符串增加字符串
my_list = [value+"hello" for value in ["abc","ab"]]
print(my_list)
运行结果：['abchello', 'abhello']

#结合if语句来使用
my_list = [value for value in range(1,11) if value % 2 ==0]
print(my_list)

#截取列表['a','b','c','d']中的前三个元素
my_list = ['a','b','c','d']
my_list = my_list[0:3:1]#最后一个1是步长
print(my_list)
运行结果：
['a', 'b', 'c']

13-条件语句的应用

#接受用户输入的数据
score = int(input("请输入你的分数："))
# 判断输入的分数，根据分数输出不同的状态
if score >= 90 and score <= 100:
    print("优秀")
elif score >=80 and score <90:
    print("良好")
elif score >=70 and score <80:
    print("一般")
elif score >=60 and score <70:
    print("及格")
else:
    print("不及格")

14-格式化输出符

#格式化符号：%s,%d,%f,%x
# %s:输出字符串
# %f:输出float类型（默认保留6位小数，会四舍五入）
# %d:输出int类型
# %x：输出16进制类型
name = "张三丰"
print("我叫%s" % name)
score = 100
print("python的考试分数为%d" % score)
pi = 3.1415926
print("圆周率%f" % pi)
print("圆周率%.2f" % pi)
运行结果：我叫张三丰
python的考试分数为100
圆周率3.141593
圆周率3.14

15-元组

// An highlighted block
#以小括号形式的数据集合，（1，2，"abc"，True）
# 可以存储任意数据类型
#注意：元组可以根据下标获取数据，但是不能对元组进行数据修改
my_tuple =  (1,4,"abc",True,1.2)
print(my_tuple,type(my_tuple))
运行结果：(1, 4, 'abc', True, 1.2) <class 'tuple'>

#根据下标取值
value = my_tuple[-1]
print(value)
运行结果：1.2

#元组不能根据下标删除数据
my_tuple =  (1,4,"abc",True,1.2)
del my_tuple[2]
print(my_tuple)
运行结果：'tuple' object doesn't support item deletion
#元组不能根据下标修改数据
my_tuple =  (1,4,"abc",True,1.2)
my_tuple[0] = 3
print(my_tuple)
运行结果：'tuple' object does not support item assignment

#可以通过新建元组或列表来访问元组进而进行修改
my_tuple=(1,[2,3])
my_list = my_tuple[1]
print(my_list)
my_list = [1,2]
print(my_tuple)
运行结果：[2, 3]
(1, [2, 3])

#定义一个空的元组
#坑：如果定义的元组只有一个元素，那么元组的类型为元素的类型
my_tuple = (1)
print(my_tuple,type(my_tuple))
运行结果：1 <class 'int'>
#如果指定只传一个元素，还想保证是元组类型，那么需要加上逗号
my_tuple = (1,)
print(my_tuple,type(my_tuple))
运行结果：(1,) <class 'tuple'>

#判断数据是否正在元组里面
my_tuple = (10,5,10,10)
result = 5 in my_tuple
print(result)
result =3 not in my_tuple
print(result)
运行结果：True
True

#输出元组中元素的下标（字符串，列表，元组都是有下标的，有序的）
my_tuple = (10,5,10,10)
result = my_tuple.index(5)
print(result)
运行结果：1

#元组中元素的个数
my_tuple = (10,5,10,10)
result = my_tuple.count(10)
print(result)
运行结果：3

16-字典

#以大括号形式的键值对数据组合，{"name":"张三","age":18}
#一般key（99%都是字符串类型）
my_dict={"name":"张三","age":18}
print(my_dict,type(my_dict))
运行结果：{'name': '张三', 'age': 18} <class 'dict'>

#字典是无序的（没有下标的概念）
#通过key值来取value
my_dict={"name":"张三","age":18}
value = my_dict["name"]
print(value)
运行结果：张三

#如果没有此键，使用[]会崩溃
my_dict={"name":"张三","age":18}
value = my_dict["sex"]
print(value)
运行结果：KeyError: 'sex'

#如果使用get方式取值不会崩溃，会返回None
my_dict={"name":"张三","age":18}
result = my_dict.get("sex")
print(result)
运行结果：None

#get函数返回指定键的值，如果值不在字典中，返回默认值
#get()方法语法：dict.get(key, default=None)
my_dict={"name":"张三","age":18}
result = my_dict.get("sex","男")
print(result)
print(my_dict)
运行结果：男
{'name': '张三', 'age': 18}#没有改变原字典的值

#可以通过固定格式，来确定键在前，或者值在前
vocab = ["dsds","dsdacv","dasd"]
aa ={idx:char for idx, char in enumerate(vocab)}
print(aa)

aa ={idx:idx for idx, char in enumerate(vocab)}
print(aa)

aa ={char:idx for idx, char in enumerate(vocab)}
print(aa)
运行结果：
{0: 'dsds', 1: 'dsdacv', 2: 'dasd'}
{0: 0, 1: 1, 2: 2}
{'dsds': 0, 'dsdacv': 1, 'dasd': 2}

17-字典的增删改查

#定义一个空的字典
my_dict = {}
print(my_dict,type(my_dict))
运行结果：{} <class 'dict'>

#给字典增加键值对
my_dict = {}
my_dict["name"] = "张三"
#key是唯一的（如果增加重复，会更新value）
my_dict["name"]="李四"
print(my_dict)
运行结果：{'name': '李四'}

#继续给字典增加键值对
my_dict = {}
my_dict["name"] = "张三"
my_dict["age"] = 18
my_dict["sex"] = "女"
my_dict["address"] = "上海"
print(my_dict)
#修改键值对
my_dict["age"]=66
print(my_dict)
运行结果：
#字典是无序的
{'name': '张三', 'age': 18, 'sex': '女', 'address': '上海'}
{'name': '张三', 'age': 66, 'sex': '女', 'address': '上海'}

#删除（删除整个字典）
my_dict = {}
my_dict["name"] = "张三"
del my_dict
print my_dict
运行结果：NameError: name 'my_dict' is not defined

#删除字典中的元素（随机删除）
my_dict={"name":"张三","age":18,"sex":"男"}
value = my_dict.popitem()#删除字典中随机一个键值对，并返回被删除键值对的值
print(my_dict,value)
运行结果：{'name': '张三', 'age': 18} ('sex', '男')

#指定数据删除(返回值是删除数据的value）
my_dict={"name":"张三","age":18,"sex":"男"}
value =my_dict.pop("age")
print(my_dict,value)
运行结果：{'name': '张三', 'sex': '男'} 18

#获取所有的value
my_dict={"name":"张三","age":18,"sex":"男"}
result = my_dict.values()
print(result)
运行结果：dict_values(['张三', 18, '男'])#以元组的形式

#获取所有的key
my_dict={"name":"张三","age":18,"sex":"男"}
result = my_dict.keys()
print(result)
运行结果：dict_keys(['name', 'age', 'sex'])#以元组的形式

#判断key是否在字典里面(不能判断value）
my_dict={"name":"张三","age":18,"sex":"男"}
result = "age" in my_dict
print(result)
运行结果：True

18-循环（while循环，for循环）

#根据条件循环执行某种操作
#while执行5次循环
num =0
while num<5:
    print(num)
    num+=1
运行结果：
0
1
2
3
4
#for循环 结合range来使用(range代表一个范围）
#range(0-4)
for value in range(5):
    print(value)
运行结果：
0
1
2
3
4
#(0,6,1)其中0是起始数据，6是结束数据（结束数据不执行循环），步长（）
for value in range(0,6,2):
    print(value)
运行结果：
0
2
4

#while循环可以结合else语句来使用
num = 5
while num>=1:
    print(num)
    num-=1
else:
    print("循环结束")
运行结果：
5
4
3
2
1
循环结束

#for循环可以结合else语句来使用
for value in range(3):
    print("ok")
else:
    print("循环结束")
运行结果：
ok
ok
ok
循环结束

#在使用for循环时，break会不执行else里的代码
for value in range(1,5):
    if value == 2:
        break
    print(value)
else:
    print("结束循环")

19-continue结束本次循环，然后继续下一个循环，整个循环不一定结束、break跳出当前循环

#结束本次循环，然后继续下一个循环，整个循环不一定结束；break:跳出当前循环
num = 0
while num <5:
    num+=1
    if num ==2:
        continue
    print(num)
else:
    print("结束循环")

运行结果：
1
3
4
5
结束循环
#break:跳出当前循环
#注意：break会不执行else里的代码
num = 0
while num <5:
    num+=1
    if num == 2:
        break
    print(num)
else:
    print("结束循环")   
运行结果：1

#仅跳出当前循环
for i in range(0,2):
    for j in range(10,15):
        if(j==12):
            break
        print(j,end=" ")
    print(i)
运行结果：
10 11 0
10 11 1

总结：不可以单独使用break和continue，必须结合循环使用

20-集合：以大括号形式表现的数据集合，集合里面的数据不可以重复（有去重的作用）（列表，元组，集合三者可以相互转换）

#集合是一个无序的集合，也可以添加和删除

#定义一个空的集合
my_set = set()
print(my_set,type(my_set))
运行结果：
set() <class 'set'>

#和字典很像，但是没有键值对
my_set = {1,4,"abc","hello"}
print(my_set)
运行结果：
{1, 'abc', 4, 'hello'}

#删除数据（删除指定数据）--不能删除没有的数据，会报错
my_set = {1,4,"abc","hello"}
my_set.remove("hello")#不能删除没有的数据
print(my_set)
运行结果：
{1, 4, 'abc'}
my_set.remove("he")#不能删除没有的数据
运行结果：KeyError: 'he'


#删除数据（删除指定数据）--不能删除没有的数据，不报错
my_set = {1,4,"abc","hello"}
my_set.discard("he")#不能删除没有的数据
print(my_set)
运行结果：
{'hello', 1, 'abc', 4}

#添加数据
my_set = {1,4,"abc","hello"}
my_set.add("5")
print(my_set)
运行结果：
{1, 4, 5, 'hello', 'abc'}#因为无序，所以下标会随意改变

#添加重复数据（不可以添加重复数据）
my_set = {1,4,"abc","hello"}
my_set.add("5")
my_set.add("5")
my_set.add("5")
运行结果：
{1, 4, '5', 'abc', 'hello'}

#根据下标修改数据会报错（集合是无序的）
my_set = {1,4,"abc","hello"}
my_set[0] = 2
print(my_set)
运行结果：
TypeError: 'set' object does not support item assignment

#取出数据容器里面的每个元素，就是遍历
my_set = {1,4,"abc","hello"}
for value in my_set:
    print(value)
运行结果：
hello
1
4
abc

#将集合转换成列表，转换成元组（三种数据容器类型相互转换）
#将集合转换成列表
my_set = {1,4,"abc","hello"}
my_set = list(my_set)
print(my_set,type(my_set))
运行结果：
[1, 4, 'hello', 'abc'] <class 'list'>

#将集合转换成元组
my_set = {1,4,"abc","hello"}
my_set = tuple(my_set)
print(my_set,type(my_set))
运行结果：
('hello', 1, 4, 'abc') <class 'tuple'>

#将列表转换成集合（集合不允许有重复数据，转换会去重）
my_list = [1,4,5,4]
my_tuple = (5,7)
my_set = {4,9}
result = set(my_list)
print(result)
result = set(my_tuple)
print(result)
运行结果：
{1, 4, 5}
{5, 7}

#列表转换成元组
my_list = [1,4,5,4]
result = tuple(my_list)
print(result)
运行结果：
(1, 4, 5, 4)
#集合转换成元组
my_set = {4,9}
result = tuple(my_set)
print(result)
运行结果：
(9, 4)
#将集合和元组转换成列表
my_tuple = (5,7)
my_set = {4,9}
result = list(my_set)
print(result)
result = list(my_tuple)
print(result)
运行结果：
[9, 4]
[5, 7]

21-for的使用：

#for循环最经常使用的方式就是遍历（所有容器类型）
#获取所有容器里面的元素，就是遍历（字符串，列表，元组，字典，集合）
#字符串
str ="abc"
for value in str:
    print(value)
运行结果：
a
b
c
#列表
my_list = ["苹果","草莓"]
for value in my_list:
运行结果：
苹果
草莓

#把列表当中的元素都遍历出来，还显示对应的下标
my_list = enumerate(["苹果","草莓"])
print(type(my_list))
for value in my_list:
    print(value,type(value))
运行结果：
<class 'enumerate'>
(0, '苹果') <class 'tuple'>
(1, '草莓') <class 'tuple'>

#拆包：获取容器类型中所有的元素和所有对应的下标
for index,value in enumerate((1,5)):
    print(index,value)
运行结果：
0 1
1 5

#不拆包，以元组形式按组的形式输出
my_list = enumerate(["苹果","草莓"])
for value in my_list:
    print(value)
运行结果：
(0, '苹果')
(1, '草莓')

#字典遍历
my_dict={"name":"朱杰","age":6}
#遍历（默认遍历出来的是key）
for key in my_dict:
    print(key)
运行结果：
name
age

#遍历value
my_dict={"name":"朱杰","age":6}
for value in my_dict.values():
    print(value)
运行结果：
朱杰
6

#将key和value全部都遍历出来
my_dict={"name":"朱杰","age":6}
for key,value in my_dict.items():
    print(key,value)

#遍历集合
my_set = {1,3,5}
for value in my_set:
    print(value)
运行结果：
1
3
5

22-拆包

#把容器类型（字符串，列表，元组，字典，集合）中每一个数据都用变量保存一下

#字符串
my_str = "abc"
a,b,c = my_str
print(a,b,c)
运行结果：
a b c

#列表
my_list = [1,5]
num1,num2 = my_list
print(num1,num2)
运行结果：
1 5

#元组
my_tuple = (1,5)
num1,num2=my_tuple
print(num1,num2)
运行结果：
1 5

#拆字典(默认拆的是key）
my_dict = {"name":"胡亮","age":"20"}
a,b=my_dict
print(a,b)
运行结果：
name age

#拆字典里的value
my_dict = {"name":"胡亮","age":"20"}.values()
a,b=my_dict
print(a,b)
运行结果：
胡亮 20

#拆集合
my_set = {3,5}
num1,num2=my_set
print(num1,num2)
运行结果：
3 5