Python基本数据类型

字符串（str）

字符串常用功能

# 字符串切片就是通过索引（索引：索引：步长）截取字符串的一段，形成新的字符串（原则就是顾头不顾腚）。
str = 'ABCDEFGHIJK'
print(str[0:3])
print(str[2:5])
print(str[0:]) #默认到最后
print(str[0:-1]) #-1就是最后一个
print(str[0:5:2]) #加步长
print(str[5:0:-2]) #反向加步长

# 字符串的常用操作
# upper(),lower()
s7 = 'XiaoBai'
print(s7.upper())  # 转志大写
print(s7.lower())  # 转成小写

# startswith(),endswith()
print(s7.startswith('X'))  # 以X开头,是则为True
print(s7.endswith('ai'))  # 以ai结尾,是则为True
print(s7.startswith('B', 4, 6)) # 以X开头,从索引4到6匹配，是则为True

# replace
s8 = '小白很傻，小白像可爱，小白很萌'
print(s8.replace('小白', '大黄'))  # 默认替换全部
print(s8.replace('小白', '大黄', 2))

# strip():去空白:空格，\t,\n
s9 = '  \nabc\t'
print(s9.strip())
#去除指定的字符
s10 = 'sadf小白sagfg'
print(s10.strip('fdasg'))

# split()分割，默认空格
s11 = 'abc def gh'
print(s11.split())
# 指定字符分割
s12 = 'abc,df,gh'
print(s12.split(','))
s13 = ',abc,df,gh'
print(s13.split(','))
print(s13.split(',', 2))

# join() 拼接成新的字符串
s14 = 'abc'
print('+'.join(s14))
l = ['a', 'b', 'c']
print(':'.join(l))  # 前提：列表时的元必须为str类型

# count 计算某个字符出现的次数
s15 = 'asojadasajdsanaksdasdl'
print(s15.count('a'))

 注：所有字符串操作都是生成新的字符串

字符串内置方法

# 把字符串的第一个字符大写
string.capitalize()

# 返回内容是原字符串居中,并使用空格填充至长度为 width 的新字符串
string.center(width)

# 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
string.count(str, beg=0, end=len(string))

# 以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的 异 常 ， 除 非 errors 指 定 的 是 'ignore' 或 者'replace'

string.decode(encoding='UTF-8', errors='strict')
# 以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'
string.encode(encoding='UTF-8', errors='strict')

# 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
string.endswith(obj, beg=0, end=len(string))

# 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。
string.expandtabs(tabsize=8)

# 检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
string.find(str, beg=0, end=len(string))

# 跟find()方法一样，只不过如果str不在 string中会报一个异常.
string.index(str, beg=0, end=len(string))

# 如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
string.isalnum()

# 如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False
string.isalpha()   

# 如果 string 只包含十进制数字则返回 True 否则返回 False.
string.isdecimal()   

# 如果 string 只包含数字则返回 True 否则返回 False.
string.isdigit()   

# 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
string.islower()   

# 如果 string 中只包含数字字符，则返回 True，否则返回 False
string.isnumeric()   

# 如果 string 中只包含空格，则返回 True，否则返回 False.
string.isspace()  

# 如果 string 是标题化的(见 title())则返回 True，否则返回 False
string.istitle()   

# 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
string.isupper()    

# 以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
string.join(seq)    

# 返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
string.ljust(width)  

# 转换 string 中所有大写字符为小写.
string.lower()   

# 截掉 string 左边的空格
string.lstrip()    

# maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
string.maketrans(intab, outtab])      

# 返回字符串 str 中最大的字母。
max(str)     

# 返回字符串 str 中最小的字母。
min(str)  

# 有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string.
string.partition(str)  
 
# 把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.
string.replace(str1, str2,  num=string.count(str1))  

# 类似于 find()函数，不过是从右边开始查找.
string.rfind(str, beg=0,end=len(string) )   
 
# 类似于 index()，不过是从右边开始.
string.rindex( str, beg=0,end=len(string))  

# 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串
string.rjust(width)  

# 类似于 partition()函数,不过是从右边开始查找.
string.rpartition(str)    

# 删除 string 字符串末尾的空格.
string.rstrip()    

# 以 str 为分隔符切片 string，如果 num有指定值，则仅分隔 num 个子字符串
string.split(str="", num=string.count(str)) 

# 按照行分隔，返回一个包含各行作为元素的列表，如果 num 指定则仅切片 num 个行.
string.splitlines(num=string.count('\n'))  

# 检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查.
string.startswith(obj, beg=0,end=len(string))   

# 在 string 上执行 lstrip()和 rstrip()
string.strip([obj])      

# 翻转 string 中的大小写
string.swapcase()    

# 返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
string.title()  

# 根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中
string.translate(str, del="")   

# 转换 string 中的小写字母为大写
string.upper()  

列表

列表是python中的基础数据类型之一，其他语言中也有类似于列表的数据类型，比如js中叫数组，他是以[]括起来，每个元素以逗号隔开，而且他里面可以存放各种数据类型比如：

li = [‘alex’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{‘name’:’alex’}]

列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。

增

append()增加到最后

li = ['a','b',123,'你好',1]
li.append('abc')   # append增加到最后
print(li)
输出结果 ：['a', 'b', 123, '你好', 1, 'abc']

insert()插入，按照索引去增加

li = ['a','b',123,'你好',1]
li.insert(2,'早')
print(li)
输出结果 ：['a', 'b', '早', 123, '你好', 1]

 extend ()迭代的去增

li = ['a','b',123,'你好',1]
li.extend('abcdef')
print(li)
li.extend([1,2,3])
输出结果 ：
['a', 'b', 123, '你好', 1, 'a', 'b', 'c', 'd', 'e', 'f']
['a', 'b', 123, '你好', 1, 'a', 'b', 'c', 'd', 'e', 'f', 1, 2, 3]

删

pop()按索引进行删除，有返回值，返回删除元素

li = ['a','b',123,'你好',1]
li.pop(1)
print(li)
输出结果 ：['a', 123, '你好', 1]

li = ['a','b',123,'你好',1]
print(li.pop(1)) #打印删除的值
输出结果 ：b

remove()指定元素删除,如果有重名元素，默认删除从左数第一个

li = ['a','b',123,'你好',1]
li.remove('你好')
print(li)

输出结果 ：['a', 'b', 123, 1] 

clear()清空列表元素

li = ['a','b',123,'你好',1]
li.clear()
print(li)

输出结果 ：[] 

del

按照位置去删除，也可切片删除没有返回值。

li = ['a','b',123,'你好',1]
del li[1:3]
print(li)
输出结果 ：['a', '你好', 1]

li = ['a','b',123,'你好',1]
del li[1]
print(li)
输出结果 ：['a', 123, '你好', 1]

 整个列表删除

li = ['a','b',123,'你好',1]
del li

改

按索引来改

li = ['a','b',123,'你好',1]
li[0] = '早'
print(li)
输出结果 ：['早', 'b', 123, '你好', 1]

按切片来改

li = ['a','b',123,'你好',1]
li[0:3] = 'safsafkf'  # 先删除切片索引元素，再按元素一个一个迭代修改
print(li)
输出结果 ：['s', 'a', 'f', 's', 'a', 'f', 'k', 'f', '你好', 1]
 
li = ['a','b',123,'你好',1]
li[0:3] = ['a12','wqwqw']  
print(li)
输出结果 ：['a12', 'wqwqw', '你好', 1]

count

统计某个元素在列表中出现的次数

a = ["q","w","q","r","t","y"]
print(a.count("q"))
输出结果 ：2

index

用于从列表中找出某个值第一个匹配项的索引位置

a = ["q","w","r","t","y"]
print(a.index("r"))
输出结果 ：2   #索引从0开始计算

排序

# sort()从小到大排序
l1 = [5, 2, 1, 4, 3, 6]
l1.sort()
print(l1)  # [1, 2, 3, 4, 5, 6]

# reverse=True 从大到小排序
l1 = [5, 2, 1, 4, 3, 6]
l1.sort(reverse=True)
print(l1)  # [6, 5, 4, 3, 2, 1]

# 元素反转
l1 = [5, 2, 1, 4, 3, 6]
l1.reverse()
print(l1)  # [6, 3, 4, 1, 2, 5]

列表的相加与整数相乘

l1 = [1, 2, 3]
l2 = [4, 5, 6]

print(l1+l2)  # [1, 2, 3, 4, 5, 6]

print(l1*3)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]

循环列表，改变列表大小的问题

l1 = [11, 22, 33, 44, 55]，请把索引为奇数对应的元素删除（不能一个一个删除，此l1只是举个例子，里面的元素不定）。

循环列表删除：

l1 = [11, 22, 33, 44, 55]
for index in range(len(l1)):
    if index % 2 == 1:
        l1.pop(index)
print(l1)  # [11, 33, 44]

最终的结果应该是：l1 = [11, 33, 55],但是你得到的结果却是： l1 = [11, 33, 44] 。

当你循环到22时，你将列表中的22删除了，但是你带来的影响是：33,44,55都会往前进一位，他们的索引由原来的2,3,4变成了1,2,3 所以你在往下进行循环时，就会发现不对了。

那这个怎么解决呢？有三种解决方式：

# 直接删除
l1 = [11, 22, 33, 44, 55]
del l1[1::2]
print(l1)  # [11, 33, 55]

# 倒序删除
l1 = [11, 22, 33, 44, 55]
for index in range(len(l1) - 1, -1, -1):
    if index % 2 == 1:
        l1.pop(index)
print(l1)  # [11, 33, 55]

# 思维置换
l1 = [11, 22, 33, 44, 55]
new_l1= []
for index in range(len(l1)):
    if index % 2 == 0:
        new_l1.append(l1[index])
l1 = new_l1
print(l1)  # [11, 33, 55]

所以，我们要总结一下：

在循环一个列表时的过程中，如果你要改变列表的大小（增加值，或者删除值），那么结果很可能会出错或者报错。

列表转字符串

l = ["hi","hello","world"]
print(" ".join(l))
输出：
hi hello world

元组

元组被称为只读列表，即数据可以被查询，但不能被修改，所以，字符串的切片操作同样适用于元组。例：（1，2，3）（"a","b","c"）

如，元组内元素含有列表等可变元素，（1，2，3，[2, 'aa', 3]）元组内的元素不可变，列表内的元素可变

tu = (1,2,3,'张三',[2,3,4,'qq'],'李四')
print(tu[3]) #查找元祖下标3的元素
结果：张三
 
print(tu[0:4]) #查找元祖下标0-4的元素
结果：(1, 2, 3, '张三')
 
for i in tu:
    print(i) #循环元祖里的元素，只循环一次。
结果：
1
3
张三
[2, 3, 4, 'qq]
李四
 
tu[4][3]=tu[4][3].upper()
print(tu) #把元祖里面的列表一个元素全部大写
结果：(1, 2, 3, '张三', [2, 3, 4, 'QQ'], '李四')
 
tu[4].append('aa')
print(tu) #在元祖里面的列表里增加元素
结果：(1,2,3,'张三',[2,3,4,'qq','aa'],'李四')
 
range() #就是一个元祖
例子：
     for i in range(3,10):
         print(i) #循环打印一次，3-9的数字。
     for i in range(10):
         print(i) #循环打印一次，0-9的数字。
     for i in range(0,10,3):
         print(i) #循环打印一次，0-9的数字，步长3，间接输出0-9所有的被3整除的数。
     for i in range(10,0,-2):
         print(i) #循环打印一次，10-1的数字，反向步长为2。
     for i in range(10,-1,-2):
         print(i) #循环打印一次，10-0的数字，反向步长为2。

 python中元组有一个特性，元组中如果只含有一个元素且没有逗号，则该元组不是元组，与改元素数据类型一致，如果有逗号，那么它是元组。

tu = (1)
print(tu,type(tu))  # 1 <class 'int'>
tu1 = ('a')
print(tu1,type(tu1))  # 'a' <class 'str'>
tu2 = ([1, 2, 3])
print(tu2,type(tu2))  # [1, 2, 3] <class 'list'>

tu = (1,)
print(tu,type(tu))  # (1,) <class 'tuple'>
tu1 = ('a',)
print(tu1,type(tu1))  # ('a',) <class 'tuple'>
tu2 = ([1, 2, 3],)
print(tu2,type(tu2))  # ([1, 2, 3],) <class 'tuple'>

元组也有一些其他的方法：

index：通过元素找索引（可切片），找到第一个元素就返回，找不到该元素即报错。

tu = ('a', [1, 2, 3, ], 'b', 'c')
print(tu.index('a')) # 0

count: 获取某元素在列表中出现的次数

tu = ('a', 'a', 'b', 'c')
print(tu.count('a')) # 2

字典(dict) 

        字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组。

　　字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

　   在Python3.5版本（包括此版本）之前，字典是无序的。

　   在Python3.6版本之后，字典会按照初建字典时的顺序排列(即第一次插入数据的顺序排序)。

增

dic = {
    'name':'张三',
    'age':20,
    'sex': 'male',
}
dic['high'] = '185cm'  #没有相同的key时，添加
print(dic)
输出结果：{'name': '张三', 'age': 20, 'sex': 'male', 'high': '185cm'}

dic['name'] = '李四'  #有相同的key时，替换
print(dic)
输出结果：{'name': '李四', 'age': 20, 'sex': 'male', 'high': '185cm'}

# setdefault 在字典中添加键值对，如果只有键那对应的值是none,但是如果原字典中存在设置的键值对，则他不会更改或者覆盖。
dic.setdefault('K')  #只有键那对应的值是none
print(dic)
输出结果：{'name': '李四', 'age': 20, 'sex': 'male', 'high': '185cm', 'K': None}

dic.setdefault('weight',50)  
print(dic)
输出结果：{'name': '李四', 'age': 20, 'sex': 'male', 'high': '185cm', 'K': None, 'weight': 50}

dic.setdefault('name','王五')#原字典中存在设置的键值对，不会更改或者覆盖
print(dic)
输出结果：{'name': '李四', 'age': 20, 'sex': 'male', 'high': '185cm', 'K': None, 'weight': 50}

删

dic = {
    'name':'张三',
    'age':20,
    'sex': 'male',
    'v':'abc'
}
dic.pop('sex')  #按键去删除，有返回值，可直接print打印
print(dic)  # {'name': '张三', 'age': 20, 'v': 'abc'}
print(dic.pop('v')) # abc
print(dic.pop('aaa',None))  #按键去删除，如果没有此键，可设置返回值，不设置返回值直接打印会报错


dic.popitem()  #python3.5之前版本随机删除字典中的某个键值对，将删除的键值对以元祖的形式返回，python3.6删除最后一个键值对
print(dic)
print(dic.popitem()) #将删除的键值对以元祖的形式返回
输出结果：
{'name': '张三', 'age': 20, 'sex': 'male'}
('sex', 'male')

dic.clear() #清空字典
print(dic)   #输出结果：｛｝
del dic #删除字典

改

dic = {
    'name':'张三',
    'age':20,
    'sex': 'male',
    'v':'abc'
}
dic['name'] = '李四'  #按键来修改值
print(dic)
输出结果：{'name': '李四', 'age': 20, 'sex': 'male', 'v': 'abc'}

查

dic = {'age':18,'name':'liu','sex':'male'}
 
print(dic.keys()) #字典的键值对 以列表形式输出 但是类型是键值对型
结果：dict_keys(['age', 'name', 'sex'])
 
print(dic.values()) #字典的值 以列表形式输出 但是类型是键值对型
结果：dict_values([18, 'liu', 'male'])
 
print(dic.items()) #字典的键值对 以元祖形式输出 但是类型是键值对型
结果：dict_items([('age', 18), ('name', 'liu'), ('sex', 'male')])
for i in dic: #默认打印出键值，后面跟.value可以打印出数值，后面跟.items可以打印键值对
    print(i)
结果：age
         name
         sex
 
print(dic.get('age')) #根据键找对应的数值，不报错 可以自定义值 默认返回 none
结果：18

update

dic = {'name': '小米', 'age': 18}
dic.update(sex='男', height=175)
print(dic) # {'name': '小米', 'age': 18, 'sex': '男', 'height': 175}

dic = {'name': '小米', 'age': 18}
dic.update([(1, 'a'),(2, 'b'),(3, 'c'),(4, 'd')])
print(dic) # {'name': '小米', 'age': 18, 1: 'a', 2: 'b', 3: 'c', 4: 'd'}

dic1 = {"name":"jin","age":18,"sex":"male"}
dic2 = {"name":"小米","weight":75}
dic1.update(dic2)
print(dic1) # {'name': '小米', 'age': 18, 'sex': 'male', 'weight': 75}
print(dic2) # {'name': '小米', 'weight': 75} 

fromkeys

创建一个字典：字典的所有键来自一个可迭代对象，字典的值使用同一个值。

dic = dict.fromkeys('abcd','小米')
print(dic) # {'a': '小米', 'b': '小米', 'c': '小米', 'd': '太小米'}

dic = dict.fromkeys([1, 2, 3],'小米')
print(dic) # {1: '小米', 2: '小米', 3: '小米'}

# 这里有一个坑，就是如果通过fromkeys得到的字典的值为可变的数据类型，那么你的小心了。
dic = dict.fromkeys([1, 2, 3], [])
dic[1].append(666)
print(id(dic[1]),id(dic[2]),id(dic[3]))  # {1: [666], 2: [666], 3: [666]}
print(dic)  # {1: [666], 2: [666], 3: [666]}

循环字典，改变字典大小的问题

 dic = {'k1':'小米','k2':'barry','k3': '米米', 'age': 18} 请将字典中所有键带k元素的键值对删除

dic = {'k1':'小米','k2':'barry','k3': '米米', 'age': 18}
for i in dic:
    if 'k' in i:
        del dic[i]
print(dic)

你会发现，报错了。。。。。
错误原因：
RuntimeError: dictionary changed size during iteration
翻译过来是：字典在循环迭代时，改变了大小。

字典在循环时，不要改变字典的大小，只要改变大小，就会报错！

解决方式

# 方式1
dic = {'k1':'小米','k2':'barry','k3': '米米', 'age': 18}
l = []
for key in dic.keys():
    if 'k' in key:
        l.append(key)
for i in l:
    dic.pop(i)
print(dic)  # {'age': 18}


# 方式2,方式1的简化版
dic = {'k1':'小米','k2':'barry','k3': '米米', 'age': 18}
for key in list(dic.keys()):  # list(dic.keys())相当于['k1', 'k2', 'k3', 'age']
    if 'k' in key:
        dic.pop(key)
print(dic)  # {'age': 18}

所以说：在循环一个字典的过程中，不要改变字典的大小（增，删字典的元素），这样会直接报错。

集合（set）

集合是无序的，不重复的数据集合，它里面的元素是可哈希的(不可变类型)，但是集合本身是不可哈希（所以集合做不了字典的键）的。以下是集合最重要的两点：

1、去重，把一个列表变成集合，就自动去重了。

2、关系测试，测试两组数据之前的交集、差集、并集等关系。

集合的创建

set1 = set({1,2,'barry'})
set2 = {1,2,'barry'}
set3 = set()  # 空集合
print(set1, set2, set3)  # {1, 2, 'barry'}, {1, 2, 'barry'},set()

集合的增

# add只能添加一个
set1 = {'a','b','c','d','e'}
set1.add('f')
print(set1)

# update：迭代着增加
set1.update('A')
print(set1)
set1.update('老师')
print(set1)
set1.update([1,2,3])
print(set1)

集合的删

set1 = {'a','b','c','d','e'}

set1.remove('b')  # 删除一个元素
print(set1)

set1.pop()  # 随机删除一个元素
print(set1)

set1.clear()  # 清空集合
print(set1)

del set1  # 删除集合
print(set1)

 交集（&  或者 intersection）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 & set2)  # {4, 5}
print(set1.intersection(set2))  # {4, 5}

并集（| 或者 union）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 | set2)  # {1, 2, 3, 4, 5, 6, 7,8}
print(set2.union(set1))  # {1, 2, 3, 4, 5, 6, 7,8}

差集（- 或者 difference）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 - set2)  # {1, 2, 3}
print(set1.difference(set2))  # {1, 2, 3}

反交集（^ 或者 symmetric_difference）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 ^ set2)  # {1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2))  # {1, 2, 3, 6, 7, 8}

子集与超集

set1 = {1,2,3}
set2 = {1,2,3,4,5,6}

print(set1 < set2)
print(set1.issubset(set2))  # 这两个相同，都是说明set1是set2子集。

print(set2 > set1)
print(set2.issuperset(set1))  # 这两个相同，都是说明set2是set1超集。

frozenset不可变集合，让集合变成不可变类型

s = frozenset('barry')
print(s,type(s))  # frozenset({'a', 'y', 'b', 'r'}) <class 'frozenset'>

 枚举（enumerate）

对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值。

li = ['张三','五五','李四','李白','大量']
for i in enumerate(li):
    print(i)
结果：
(0, '张三')
(1, '五五')
(2, '李四')
(3, '李白')
(4, '大量')

for index,name in enumerate(li,1):
    print(index,name)
结果：
1 张三
2 五五
3 李四
4 李白
5 大量

for index, name in enumerate(li, 100):  # 起始位置默认是0，可更改
    print(index, name)　
结果：
100 张三
101 五五
102 李四
103 李白
104 大量

range

for i in range(1,10):
    print(i)

for i in range(1,10,2):  # 步长
    print(i)

for i in range(10,1,-2): # 反向步长
    print(i)

利用len和range打印列表的索引

l1 = ['a', 'b', 'c', 'd', 12, 666]
for i in range(len(l1)):
    print(i)