python(列表,字典,元组,字符串,枚举enumerate)

一、列表相关知识

1.1 什么是列表?

#列表/序列/数组
#容器类型,一般是用来存储数据
#列表,可以用来存储各种各样的数据,列表存储的数据有顺序
#列表数据都有索引 第一条数据的索引为0,以此类推12345.。
1.2 添加数据

#1.使用append()函数,向列表中追加数据,会把添加的数据放在列表的最后
#object:对象,要添加到列表中的数据
list_1.append('2018-1-23')
print(list_1)
#2.使用insert(index,object) 函数,向列表中插入一条数据
# index 索引 object 要插入的数据 如果超出最大索引,会将数据放在列表最后。若index为负值,位置会从后向前查找,最后一条数据索引为-1
list_1.insert(4,'oppo')
print(list_1)
#3.使用extend()函数,可以将一个可迭代对象的所有数据追加到该列表中
#extend(iterable)
#可迭代对象   例如: 列表 字符串 字典 元组
list_2 =['a','b','c','e','f']
list_1.extend(list_2)
print(list_1)
1.3 修改数据

#index()函数 可以根据数据,查找数据的索引
#1.数据 2. 开始搜索的位置3.结束搜索的位置
#如果数据不在列表中(或不在指定范围),会出现异常错误
# 'hello' is not in list 原因1:列表中确实没有该元素 原因2:指定的范围没有该元素
index = list_1.index('oppo',0,5)
print(index)
list_1[3] = True
print(list_1)
#根据索引修改数据
list_1[index] = 'vivo'
print(list_1)
1.4 删除数据

#1.根据索引删除数据
#delete: 删除
del list_1[4]
print(list_1)
# 2.pop(index) 从列表中将数据移出,移出之后列表中就不存在数据了
# index 可以指定取出数据的索引,如果不指定的话,默认取出最后一条数据
s = list_1.pop(2)
print(s)
print(list_1)
# 3.remove(object) 根据数据内容 从列表中移除数据
# object 要删除的数据
# list.remove(x): x not in list  要删除的数据不在列表中
# 判断数据是否在列表
# object in list 如果object在列表中,返回True,不在 返回False
# object not in list  如果object不在列表中 返回True  在 返回False
if 'ssss'  in list_1:
    list_1.remove('ssss')
else:
    print('ssss不在列表中,无法执行删除操作!')
#4.移除列表中所有的数据
#clear:清除
# list_1.clear()
# print(list_1)
1.5 查询数据

# 1.根据索引取出列表中数据,取出之后列表中还有数据
s = list_1[2]
print(s)
print(list_1)
# 2.使用pop()函数,取出列表中数据,取出之后列表中的数据就会移除
s = list_1.pop(2)
print(s)
print(list_1)

# 3.列表切片,切片之后会得到一个新列表
# start:stop   包含start 不包含stop
# start开始位置,一定要小于stop结束位置,否则截取出来就是一个空列表
result = list_1[3:5]
print(result)

#[:结束位置]  从第0个位置开始切片,一直到结束位置(不包含结束位置)
result = list_1[:5]
print(result)

#[开始位置:] 从开始位置开始切片,知道列表中最后一个元素
result = list_1[3:]
print(result)

#开始位置一定要小于结束位置,否则会出现结果为空列表的情况
result = list_1[4:2]
print(result)

#填写负值
result = list_1[-5:-1]
print(result)
# 4.取出列表中的所有数据
# 使用for循环,遍历列表
# range(start,stop,step)
# start 范围的开始位置  stop 范围结束的位置  step x的增量 默认为1
# range范围 包含start 不包含stop
# 遍历列表:将列表中的所有数据一个一个取出来
# len() 获取列表中存放的数据个数
length = len(list_1)
print('列表中存放数据的个数为:%s' % length)
for x in range(0, len(list_1)):
    # 把x的值作为索引,取出列表中的数据
    s = list_1[x]
    print(s)
# 泛型遍历
for s in list_1:
    print(s)
1.6 其他函数

#列表的其他函数
list_3 = [4,5,11,88,44,33.4,67,28,1,1,1,1,1,1,1,1]
#sort() 排序函数 默认升序排列
#指定降序排列
list_3.sort(reverse=True)
#默认升序
# list_3.sort()
print(list_3)
#reverse()反向排序
list_3.reverse()
print(list_3)
#count()函数 统计某条数据在列表中出现的次数
count = list_3.count(1)
print('出现的次数:', count)
1.7 自己实现一个count函数

def COUNT(list_1,object):
    count = 0
    for content in list_1:
        if content == object:
            count +=1
    return count
    # 如果有返回object在list_1中出现的次数
    # 如果没有 返回0
list_1 =[1,1,1,2,'hello',False,3.14,'world']
count = COUNT(list_1,1)
print(count)
1.8 自己实现一个index函数

def INDEX(list_1,object):
    index_list = []
    if object in list_1:
        #enumerate 枚举
        #  拿到之后 一个一个的小元组,小元组中放的是数据索引和数据
        for item in enumerate(list_1):
            # item[1] 取出小元组中的数据
            if item[1] == object:
                # item[0] 数据对应的索引
                index_list.append(item[0])
        # 如果有元素返回object在list_1中的索引
        # 如果没有返回-1
        return index_list

index_list = INDEX(list_1,1)
print(index_list)
二、字典

2.1 什么是字典?

# 字典用法
# 字典:python 中一个内置的容器类,具有增添改查的操作
# 字典中存储数据的特点
# 1.字典存数数据 遵循ket:value(键值对)形式进行数据存储,一个key(键)对应一个值(value),使用键来替代列表中的索引,所有的增删改查都是通过key(键)完成的
# 2.字典中存储的数据是无序的
# 3. key(键)必须是惟一的,必须是不可变
# PEP8 编码规范 标点符号后面跟个空白格(空格)
dict1 = {'name': '张三', 'age': 22, 'phone': 110}
print(dict1)
2.2 添加数据

# 添加数据,如果字典中没有这个key,做添加数据操作
dict1['sex'] = '男'
print(dict1)
#如果字典中有这个key,做修改数据操作
dict1['sex'] = '女'
print(dict1)
2.3 删除数据

# 1.根据key删除字典中的数据
del dict1['sex']
print(dict1)
#2.使用pop(key)移出字典中对应key的元素
name = dict1.pop('name')
print(name)
# 3.随机从字典中取出一堆键值对,取出的是小元组
rs = dict1.popitem()
print(rs)
#4.清空字典中所有键值对
# dict1.clear()
2.4 获取数据

#1.获取字典中所有的key
keys = dict1.keys()
#for 循环遍历key,根据key取出对应的value
for key in keys:
    value = dict1[key]

#2.获取字典中所有的value值
values = dict1.values()
for value in values:
    print(value)
#3.获取字典中所有key和值(key,value)元组
items = dict1.items()
#for 循环遍历items
for key,value in items:
    print(key,value)

# 4.判断字典中是否拥有某个key
# python2 直接使用 dict1.has_key(key)  如果key存在,返回True 不存在 返回False
# python3 使用 key in  dict1.keys 如果存在返回True 不存在 返回False
# key not in dict1.keys()  如果存在返回False  不存在返回True
if 'name' in dict1.keys():
    print('字典中有name这个key')
else:
    print('字典中没有name这个key')
三、元组

3.1 什么是元组?

# 1.tuple元组的用法
# 元组也是python 内置的一个容器类,
# 元组中的数据一旦确定就不可更改,不能进行添加、删除、 修改的操作
# 可以认为元组就是一个不可变的列表(list)
# 声明元组,如果元组中只有一个元素,在python2 中,必须在元素后添加一个,逗号,python3中可以不用加
tuple_1 = (3.14,'hello','world',3,4,6,7)
print(tuple_1)
# 声明一个元组时,可以省略小括号,这种方式也可以生成一个元祖
tuple_2 = 1,2,3,4,5,6,7,8
print(type(tuple_2))

3.2 获取元组数据

# 1.根据索引取出元组中的数据
num = tuple_1[0]
print(num)
# 2.元组也支持切片操作,切片之后返回一个新的元组
result = tuple_1[1:3]
print(result)
# 元组支持for循环遍历
for x in range(0,len(tuple_1)):
    # 把x的值作为索引,取出数据
    content = tuple_1[x]
    print(content)
# for 循环遍历
for content in tuple_1:
    print(content)
# 3.使用枚举
rs = enumerate(tuple_1)
# for循环遍历枚举对象
# for item in rs:
    # print(item)
for index,value in rs:
    # index就是小元组中的索引,value就是小元组中的数据
    print(index,value)
3.3 列表元祖嵌套

# 列表元组嵌套
list1 = [['张三',22,110],['李四',22,239],(1,2,3),(3,2,1)]
# 元组嵌套列表,元组不可修改,但是元组中的列表可以进行修改
tuple1 = (1,2,['张三',22,112],(3,2,1))
tuple1[2].append('hello')
print(tuple1)
# 列表和元组中间可以互相转换
list2 = [1,2,3,4]
# 把列表转换为元组
tuple2 = tuple(list2)
print(type(tuple2))
# 把元组转换为列表
list2 = list(tuple2)
print(type(list2))
3.4 其他函数

# index(x,start,end)查找某个元素在元祖中的位置
# x 指要查找索引的元素 start 开始查找的位置 end结束查找的位置
# 查找位置 如果不指定 从开始位置到末尾查找 指定位置从start开始到end之前,不包含end
index = tuple2.index(3,0,3)
print(index)
# count(x)统计某个元素在元祖中出现的次数
# x 要查找出现次数的元素
count = tuple2.count(1)
print(count)
四、字符串

4.1字符串用法

# 字符串的用法
string1='abcd'
string2="abcd"
# ''' '''三个单引号对,声明的字符串,会保留其格式
string3='''
        1.猜猜看
        2.就不猜
        3.猜不猜
        4.拜拜 
        '''
print(string3)
string4="""
        1....
        2....
        3....
        4....
        """
print(string4)
print([string4])
#r'' 原样字符串,不会将字符串中的转义字符进行转义,会原样的输出
print(r'1\n2')

4.2 字符串的拼接

#1. 使用占位符拼接字符串
a = 100
b = 200
# %d 整数占位符,在字符串中,如果只有一个占位符,不需要在后面加(),只需要%变量名,如果有两个以上占位符,就需要将变量放在()小括号中%(a,b)
string5 = 'a的值为:%d,b的值为:%d'%(a,b)
print(string5)
# %f 小数类型占位符
# %.2f 保留小数点后两位
a = 1.1111
b = 2.9999
string6 = 'a的值为:%.2f,b的值为:%f'%(a,b)
print(string6)

# %s 通用占位符,字符串、整数、小数、字典、元组、列表。。。都可以使用这个占位符
list1 = ['张三',22,120]
print('这个列表的内容为:%s'%list1)
#2.使用+号,拼接字符串
name = '张三'
age = '22'
phone = '110'
result = '姓名:' + name + '\n年龄:' + age + '\n手机:' + phone
print(result)
#字符串的乘法运算
name= name * 10
print(name)

# 3.format()函数 格式化字符串
string7 = '再过{}天该放假了!'.format(8)
print(string7)
# {}大括号中如果不填索引的话,默认从0开始取值,然后依次向后取值
string8 = '今天是周{2},明天是周{1},后天是周{0}'.format('一','二','三')
print(string8)
#{}大括号中内容是后面format中的索引,默认从0开始,依次向后加1,也可以在{}中指定取出的数据索引
string9 = '姓名:{2} 年龄:{0} 性别:{1} 电话:{3}'.format('22','男','张三','110')
print(string9)
4.3 字符串和数字之间的转换

#字符串和数字之间的转换
string10 = '1234523456'
#使用int()把一个纯数字的字符串转换为整数
# ValueError: invalid literal for int() with base 10: '1234abcd890'
numbers1 = int(string10)
print(numbers1)
print(type(numbers1))
string11 = '3.1415'
# 使用float()转换为浮点类型的数据,也要求要转字符串必须为纯数字
numbers2 = float(string11)
print(type(numbers2))
print(numbers2)
#把float或int转换为字符串
string12 = str(numbers2)
print(type(string12))
4.4 练习

找到qwer的位置:

老师的方法:
string13 = 'dweqgfyufyrqwerhfiahfvjdqwerlvjfdlv'
#找到qwer的位置,使用find函数,如果找到返回的是小字符串开始的位置,如果没找到返回的是-1
# sub 要查找位置的字符串 start开始查找的位置 end结束查找的位置
# index = string13.find('qwer',3,60)
# print(index)

def FIND(string,sub,start=0,stop=-1):
    '''

    1.for 循环遍历字符串,根据小字符串的长度对大字符串进行截取,并且截取出的字符串必须跟小字符串长度一致
    2.如果截取的字符串和小字符串长度一致,判断俩个字符是否一致,如果一致说明该字符串就是要查找的字符串,直接return x的值(开始位置)
    3.如果for循环执行完毕 meiyoufanhui9一个结果,直接返回-1 表示没找到
    '''
    if stop == -1:
        stop = len(string)
    for x in range(start,stop):
        #x可以作为截取字符串的开始位
        #end= x+len(sub)作为截取的结束位置
        end= x + len(sub)
        #截取字符串
        sub_str = string[x:end]
        #判断字符串是否一致
        if len(sub_str) == len(sub):
            #如果截取的字符串也等于小字符串,说明找到了
            if sub_str == sub:
                print('找到{}的位置为{}'.format(sub,x))
                return x
        else:
            break
    #没有找到字符串,返回-1
    return -1
print(FIND(string13,'qwer'))
#我的查找qwerde 位置
    # for x in range(0, len(string)):
    #     if string13[x] == 'q':
    #         s = string13[x:x+4]
    #         if s == 'qwer':
    #             print('qwer的位置:',x)
4.5 其他函数

list1 = [1,2,3,4,5,6,7]
#len(列表) 获取列表中存放数据的个数
print(len(list1))
string = 'hfwhrfuigbdfhasfgvbahguyweg'
#len(字符串) 获取字符串的长度
print(len(string))
#字符串中的每一个字符都是有索引的 第一个索引为0,第二个为1,以此类推。
content= string[3]
print(content)
#字符串支持切片特性
rs= string[:4]
print(rs)
rs = string[4:8]
print(rs)
rs = string[4:]
print(rs)
4.6 常用函数

#1.find(sub,start,end) 查找第一个匹配的子字符串的起始位置
#sub 要查找的位置的子字符串 start开始位置 end结束查找位置
#如果找到返回位置,找不到返回-1
index= string.find('a')
print(index)
#2.index() 查找子字符串在大字符串中的位置,如果找到返回起始位置,找不到抛出异常
# 没有找到 抛出异常:ValueError: substring not found
##sub 要查找的位置的子字符串 start开始位置 end结束查找位置
index =string.index('a')
#3. count(x,start,end) 函数 统计某个字符串在大字符串中出现的次数
#x 要查找的次数的字符串 start开始位置 end结束查找位置
count = string.count('b')
print(count)

#4.转换大小写
#upper()把字符串全部转换为大写,会把转换之后的字符串返回
upper_str = string.upper()
print(upper_str)

#5,大小写字符全部转化为小写字符
lower_str = upper_str.lower()
print(lower_str)
#6.strip(chars) 去除字符串首尾两端的指定字符,不指定默认去除空格
#chars 要去除的字符
string= '\n张\n\n\n\n三\n'
strip_str = string.strip('\n')
print(strip_str)
#7.replace()函数 可以将字符串中的字符进行替换
#old 要替换的字符串 new替换后的字符串 count替换的次数
replace_str = strip_str.replace('\n','==',7)
print(replace_str)
#8.split(seq,maxsplit) 函数 可以根据指定的字符对字符串进行分割,分割之后得到的是一个列表
string = '1;2;3;4;5;6;7;8;9'
#seq 指定的分割字符 maxsplit最大的分割次数 不指定就是全部分割
rs = string.split(';')
print(rs)
#9.join()函数
#iterable 可迭代对象
string = '*'.join(rs)
print(string)
#10. startswitch()函数  判断某个字符串是否以某个字符串开头
#如果以某个字符串开头,返回True 否则 返回false
print(string.startswith('1'))
#11. endswitch() 判断某个字符串是否以某个字符串结束
#如果以某个字符串结束,返回true 否则返回false
print(string.endswith('10'))

五、枚举enumerate()

# enumerate 使用场景:对一个列表或者数组既要遍历索引又要遍历元素时使用
# 例如:
#     比如:
# for index,value in enumerate(list):
#       print index,value
# 当然也可以
# for i in range(0,len(list)):
#       print i,list[i]
# enumerate 的参数为可遍历的变量,如字符串,列表等;返回值为enumerate类









©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页