怎么编写app软件/seo点击器

5.1 数据容器认识

5.2 python列表

5.2.1 列表的定义

'''
演示数据容器之：list
语法：[元素，元素，....]
'''

#定义一个列表List
List = ['itheima','uityu','gsdfg']
List1 = ['itheima','6666','True']
print(List)
print(List1)
print(type(List))
print(type(List1))

#定义嵌套列表
List2 = [[1,2,3],['dadd','dadad','fefefe']]
print(List2)
print(type(List2))

5.2.2 列表的下标索引

'''
通过下标索引取出对应位置的数据
'''#定义列表
List = ['tom','python','lalal']#列表[下标索引]，从前向后从0开始，每次+1，   从后往前从-1开始，每次-1
print(List[0])
print(List[1])
print(List[-1])#定义嵌套列表
List1 = [[1,2,3],[123,333,444]]
#取出嵌套索引的元素
print(List1[0][1])
print(List1[1][-2])

5.2.3 列表的常用操作方法

'''
演示数据容器之：List列表常用操作
'''my_list = [11111,'num',['qqqqq',676767]]#1.1 查找某元素在列表内的下标索引                           列表.index
index = my_list.index(['qqqqq',676767])
print(f'[qqqqq,676767]在列表中的下标索引是：{index}')# 1.2如果查找的元素不存在，会报错
# index = my_list.index(0000)
# print(f'0000在列表中的下标索引是：{index}')#2 修改特定下标索引的值
my_list[0] = 9999
print(f'列表被修改后的值是：{my_list}')#3 在特定位置插入新元素                                    列表.insert
my_list.insert(1,777777)
print(f'列表插入元素后它的结果是：{my_list}')#4 在元素列表中追加一个元素，在列表尾部加入新元素               列表.append
my_list.append('学python')
print(f'列表在追加元素后，结果是：{my_list}')#5 在元素列表中追加一个新列表，在列表尾部加入新列表              列表.extend
my_list2 = [1,'best']
my_list.extend(my_list2)
print(f'列表在追加列表后，结果是：{my_list}')#6 删除列表中的元素（两种方法）
my_list3 = [11111,'num',['qqqqq',676767]]
#6.1 del方法  列表[下标]
del my_list3[2][1]
print(f'del方法删除后的结果是{my_list3}')
#6.2 方法2： 列表.pop(下标)                                 列表.pop
my_list3 = [11111,'num',['qqqqq',676767]]
my_list3.pop(1)
print(f'列表.pop(下标)方法删除后的结果是{my_list3}')#7  删除某元素在列表的第一个匹配项                             列表.remove
my_list4 = [11111,11111,111111,111111,'num','num','num',['qqqqq',676767]]
my_list4.remove('num')
my_list4.remove('num')
my_list4.remove('num')
print(f'通过remove方法移除元素后，列表的结果是：{my_list4}')#8 清空列表                                                列表.clear
my_list4.clear()
print(f'列表被清空了，结果是：{my_list4}')#9  统计列表内某元素的数量                                    列表.count
my_list5 = [11111,11111,111111,111111,'num','num','num',['qqqqq',676767]]
count = my_list5.count('num')
print(f'列表中num的数量为：{count}')#统计列表中有多少元素                                         len（列表）
my_list6 = [11111,11111,111111,111111,'num','num','num',['qqqqq',676767]]
count = len(my_list6)
print(f'列表中的元素数量为：{count}')

5.2.4 列表的基础操作案例

age = [21,25,21,23,22,20]#追加31到列表末尾
age.append(31)
print(age)#追加新列表到列表尾部
age1 = [29,33,30]
age.extend(age1)
print(age)#取出第一个元素
age.pop(0)
print(age)#取出最后一个元素
del age[7]
print(age)#查看31在列表中的下表位置
index = age.index(31)
print(index)

5.3 元组

5.3.1 元组的定义和操作

'''
演示tuple元组的定义和操作
'''
#定义元祖
t1 = (1,'hello',True)
t2 = ()
t3 = tuple()
print(f't1的类型是{type(t1)},内容是{t1}')
print(f't2的类型是{type(t2)},内容是{t2}')
print(f't3的类型是{type(t3)},内容是{t3}')#定义单个元素的元素(单个元素需要带上单个逗号)
t4 = (1,)
t5 = (2)
print(f't4的类型是{type(t4)},内容是{t4}')
print(f't5的类型是{type(t5)},内容是{t5}')# 元组的嵌套
t6 = ((1,2,3),(9,0,34))
print(f't6的类型是{type(t6)},内容是{t6}')# 下标索引取出内容
num = t6[1][1]
print(f'从嵌套元祖中取出的数据是：{num}')#元组的操作：index查找方法
t1 = (1,0,'hello',True,False,True,False,True,False,'hhhh')
index = t1.index(False)
print(f'True在t1中的下标是：{index}')#元组的操作： count统计方法
num = t1.count(True)
print(f'在元祖中统计True的数量有{num}个')#元祖的操作：len函数统计元组元素的的数量
num = len(t1)
print(f'元祖的数量有：{num}个')#元组的遍历 while循环
index = 0
while index < len(t1):print(f"元组的元素有：{t1[index]}")index += 1#元组的遍历 for循环
for i in t1:print(f"2元组的元素有：{i}")# 定义一个元组
#元组的元素不可修改，但元组内列表内容元素可以修改
t10 = (1,2,[3333,5555])
print(f't10的内容是：{t10}')
t10[2][0] = '黑马python'
t10[2][1] = '西八'
print(f't10的内容是：{t10}')

5.3.2 元组的基本操作案例

#定义元组
information = ('周几轮',18,['basketball','rap'])#查询年龄所在下标位置
index = information.index(18)
print(f'年龄所在下标位置：{index}')#查询学生姓名
name = information[0]
print(f"学生姓名是{name}")#删除学生爱好basketball
del information[2][0]
print(information)#增加爱好dance
information[2].append('dance')
print(information)

5.4 字符串

5.4.1 字符串的定义和操作

'''
演示以数据容器的角色，学习字符串的相关操作
'''my_str = 'python learning time'
#通过下标索引取值
a = my_str[3]
b = my_str[-6]
print(f'下标为2的值是：{a}，下标为-6的值是{b}')# index方法
c = my_str.index('learning')
print(f'learing的起始下标是：{c}')#replace方法
new_my_str = my_str.replace("i",'程序')
print(f'{my_str}替换i后结果是：{new_my_str}')#split方法 字符串的分割
my_str3 = 'aaabbaddaeeaggakka'
my_str3_list = my_str3.split('a')
print(f'字符串{my_str3}按照a进行split分割后得到：{my_str3_list}，类型是：{type(my_str3_list)}')#strip方法  去除字符串收尾元素
my_str = '  123python   learning   time21   '
new_my_str = my_str.split() #不传入参数，则去除首尾空格
print(new_my_str)
new_my_str2 = my_str.split('12')
print(new_my_str2)#统计字符串某字符串出现的次数
my_str = '  123python   learning   time21   '
count = my_str.count('2')
print(f'2出现的次数是{count}')#统计字符串的长度
count = len(my_str)
print(f'字符串{my_str}的长度是{count}')#字符串的while的循环遍历
my_str2 = 'whoiam'
index = 0
while index < len(my_str2):print(my_str2[index])index += 1#字符串的for的循环遍历
for i in my_str3:print(i)

5.4.2字符串的大小比较

'''
演示字符串的大小比较
'''#abc 比较abd
print(f"abc 小于 abd的结果是：{'abd' > 'abc'}")#ab比较a
print(f"a小于 ab的结果是：{'ab' > 'a'}")#ab比较A
print(f"A小于 a的结果是：{'a' > 'A'}")#key1比较key2
print(f"key1小于 key2的结果是：{'key2' > 'key1'}")

5.4.3字符串的基础操作案例

str = 'itheima itcast boxuegu'#统计字符串内it数量
count = str.count('it')
print(f'字符串内it数量有：{count}')#将空格替换为|
new_str = str.replace(' ','|')
print(f'将字符串{str}内空格替换为|的结果为{new_str}')#按照|字符分割为列表
new_str_list = new_str.split("|")
print(new_str_list)

5.5 对数据容器进行切片操作

5.5.1 演示对序列进行切片操作

'''
演示对序列进行切片操作
'''#对list进行切片，从1开始，4结束，步长1
my_list = [0,1,2,3,4,5,6]
re = my_list[1:4]       #步长默认1，可以不写
print(f'结果1：{re}')#对tuple进行切片，最开始，到最后结束，步长1
my_tuple = (0,1,2,3,4,5,6)
re2 = my_tuple[:]       #步长默认1，可以不写
print(f'结果2：{re2}')#对str进行切片，最开始，到最后结束，步长2
my_str = '0123456'
re3 = my_str[::2]
print(f'结果3：{re3}')#对str进行切片，最开始，到最后结束，步长-1
my_str = '0,1,2,3,4,5,6'
re4 = my_str[::-1]
print(f'结果4：{re4}')#对列表进行切片，从3开始，1结束，步长-1
my_list = [0,1,2,3,4,5,6,7,8,9,100]
re5 = my_list[3:1:-1]
print(f'结果5：{re5}')#对元祖进行切片，最开始，到最后结束，步长-2
my_tuple = (0,1,2,3,4,5,6,3333,7,89,99,99999)
re6 = my_tuple[::-2]
print(f'结果6：{re6}')

5.5.2 对数据容器操作的基础案例

str = '万过薪月，员序程马黑来，nohtyp学'#方法一   切片，倒序取出
re = str[9:4:-1]
print(re)#方法二  倒序取出，然后切片
re2 = str[::-1][9:14]
print(re2)#方法三，split分割，replace分割“来”为空，倒序字符串
re3 = str.split('，')[1].replace('来','')[::-1]
print(re3)

5.6 集合

5.6.1 集合的定义和操作

'''
演示数据容器集合
'''
#定义集合  集合会去重，不支持重复元素
my_set = {'sss','qqq','wwww','rrr','ww'}
my_set_empty = set() #定义空集合
print(f'{my_set}，{type(my_set)}')
print(f'{my_set_empty}，{type(my_set_empty)}')#添加新元素
my_set.add("python")
print(f'{my_set}')#移除元素
my_set.remove('python')
print(f'{my_set}')#从集合中随机取出元素
element =my_set.pop()
print(f'{my_set},{element}')#清空集合
my_set.clear()
print(f'{my_set}')#取出两个集合的差集  会产生新集合，集合1和2不变
set1 = {1,2,3}
set2 = {1,5,3}
set3 = set1.difference(set2)
print(f'{set1},{set2},{set3}')#消除两个集合的差集  不会产生新集合，集合1变
set1 = {1,2,3}
set2 = {1,5,3}
set3 = set1.difference_update(set2)
print(f'{set1},{set2}')#两个集合合并    会产生新集合，集合1和2不变
set1 = {1,2,3}
set2 = {1,5,3}
set3 = set1.union(set2)
print(f'{set1},{set2},{set3}')#统计集合数量
count = len(set3)
print(f'{count}')#集合的遍历
#集合不支持下标索引，不可以while循环
for i in set3:print(f"{i}")'''
集合的基本操作案例
'''
my_list = [1,2,3,4,5,6,7,8,9,0,5,6,5,3,21,1,334,4,3,2,1]#定义空集合
set = set()#通过for循环遍历列表
#将列表中元素添加到集合中
for i in my_list:print(f'{i}')set.add(i)
print(f"{set}")

5.7 字典

5.7.1 字典的定义和操作

'''
演示字典的定义
'''#定义字典  字典中的key不可以重复 {key，value}
my_dict = {'网咯红':99 ,'周几轮':88 ,'林俊杰':77 }
#定义空字典
my_dict2 = {}
my_dict3 = dict()
print(f'{my_dict},{type(my_dict)},\n'f'{my_dict2},{type(my_dict2)},\n'f'{my_dict3},{type(my_dict3)}')#从字典中基于key获取value
score = my_dict['林俊杰']
print(f'{score}')#字典的嵌套，key，value可以是任意数据类型，（key不可为字典）
stu_score_dict = {'王力宏':{'aa':77,'bb':55,'cc':66},'周杰伦':{'aa': 47,'bb': 555,'cc': 106},'林俊杰':{'aa': 127,'bb': 545,'cc': 876}
}
print(f'{stu_score_dict}')#查看学生成绩
score = stu_score_dict['周杰伦']['aa']
print(f'{score}')'''
字典的常用操作
'''
my_dict = {'网咯红':99 ,'周几轮':88 ,'林俊杰':77 }
#新增元素
my_dict['张学友'] = 62
print(f'{my_dict}')#更新元素
my_dict['周几轮'] = 9
print(f'{my_dict}')#删除元素score = my_dict.pop('周几轮')
print(f'{my_dict}，{score}')#清空元素
my_dict.clear()
print(f'{my_dict}')#遍历字典
#获取全部key
my_dict = {'网咯红':99 ,'周几轮':88 ,'林俊杰':77 }
keys = my_dict.keys()
print(f'{keys}')
# 方式1  通过获取所有key来遍历字典
for key in keys:print(f'{key},{my_dict[key]}')#方式2 通过直接对字典进行for循环，每一次循环得到key
for key in my_dict:print(f'222\t{key},aaaa\t{my_dict[key]}')#统计字典内的元素数量
num = len(my_dict)
print(f'{num}')'''
字典的基本操作案例
'''#定义字典
my_dict = {'王力宏':{'部门':'科技部','工资':3000,'级别':1},'周杰伦':{'部门': '市场部','工资': 5000,'级别': 2},'林俊杰':{'部门': '市场部','工资': 7000,'级别': 3},'张学友':{'部门': '科技部','工资': 4000,'级别': 1},'刘德华':{'部门': '市场部','工资': 6000,'级别': 2}
}
#遍历字典，找到name这个key
for name in my_dict:#判断name key对应的级别是否为1if my_dict[name]['级别'] == 1:#如果是级别加1，工资加1000my_dict[name]['级别'] += 1my_dict[name]['工资'] += 1000
print(f'{my_dict}')

5.8 数据容器的通用操作

'''
演示数据容器的通用操作
'''list1  =  [17,27,30,4,45]
tuple1 =  (10,2,3,44,5)
str1   =  'abcdefghij'
set1   =  {1,2,3,4,5}
dict1  =   {'key8':9,'key2':8,'key6':7,'key4':6,'key7':4}#len元素个数
num = len(list1)
print(f'{num}')num = len(tuple1)
print(f'{num}')num = len(str1)
print(f'{num}')num = len(set1)
print(f'{num}')num = len(dict1)
print(f'{num}')#max 最大元素
print(f'列表 最大的元素是：{max(list1)}')
print(f'元组 最大的元素是：{max(tuple1)}')
print(f'字符串最大的元素是：{max(str1)}')
print(f'集合 最大的元素是：{max(set1)}')
print(f'字典 最大的元素是：{max(dict1)}')#min最小元素
print(f'列表 最小的元素是：{max(list1)}')
print(f'元组 最小的元素是：{max(tuple1)}')
print(f'字符串最小的元素是：{max(str1)}')
print(f'集合 最小的元素是：{max(set1)}')
print(f'字典 最小的元素是：{max(dict1)}')#类型转换：容器转列表
print(f'列表   列表转换为列表的结果是：{list(list1)}')
print(f'元组   元组转换为列表的结果是：{list(tuple1)}')
print(f'字符串转字符串换为列表的结果是：{list(str1)}')
print(f'集合   集合转换为列表的结果是：{list(set1)}')
print(f'字典   字典转换为列表的结果是：{list(dict1)}')#类型转换：容器转元组
print(f'列表   列表转换为元组的结果是：{tuple(list1)}')
print(f'元组   元组转换为元组的结果是：{tuple(tuple1)}')
print(f'字符串转字符串换为元组的结果是：{tuple(str1)}')
print(f'集合   集合转换为元组的结果是：{tuple(set1)}')
print(f'字典   字典转换为元组的结果是：{tuple(dict1)}')#类型转换：容器转字符串
print(f'列表   列表转换为字符串的结果是：{str(list1)}')
print(f'元组   元组转换为字符串的结果是：{str(tuple1)}')
print(f'字符串转字符串换为字符串结果是：  {str(str1)}')
print(f'集合   集合转换为字符串的结果是：{str(set1)}')
print(f'字典   字典转换为字符串的结果是：{str(dict1)}')#类型转换：容器转集合
print(f'列表   列表转换为集合的结果是：{set(list1)}')
print(f'元组   元组转换为集合的结果是：{set(tuple1)}')
print(f'字符串  字符串换为集合的结果是：{set(str1)}')
print(f'集合   集合转换为集合的结果是：{set(set1)}')
print(f'字典   字典转换为集合的结果是：{set(dict1)}')#容器的通用排序功能 排序后结果会变成列表对象
print(f'列表   列表排序的结果是：{sorted(list1)}')
print(f'元组   元组排序的结果是：{sorted(tuple1)}')
print(f'字符串  字符排序的结果是：{sorted(str1)}')
print(f'集合   集合排序的结果是：{sorted(set1)}')
print(f'字典   字典排序的结果是：{sorted(dict1)}')#反向排序
print(f'列表   列表反向排序的结果是：{sorted(list1,reverse=True)}')
print(f'元组  元组反向排序的结果是：{sorted(tuple1,reverse=True)}')
print(f'字符串  字符反向排序的结果是： {sorted(str1,reverse=True)}')
print(f'集合   集合反向排序的结果是： {sorted(set1,reverse=True)}')
print(f'字典   字典反向排序的结果是：{sorted(dict1,reverse=True)}')