Python基础-高级变量类型
1.高级变量类型
"""
数值型:int float bool compex
非数值型:str list set dict tuple
"""
# 保存所有人的姓名信息?
# str = '秦海根张刚'
# 获取第二个人的姓名
"""------------------ 定义列表 ------------------"""
# 定义列表保存我们班所有人的姓名
# nameList = ['秦海根','张刚','昌子为','易文']
# print(nameList)
# 列表可以保存不同的数据类型吗?
# nameList = ['秦海根','张刚','昌子为','易文',20,1.23,True]
# print(nameList)
"""------------------ 访问列表中某一个元素 ------------------"""
# nameList = ['秦海根','张刚','昌子为','易文']
# 秦海根 张刚 昌子为 易文
# 0 1 2 3
# 访问第三个元素
# 两种方式操作效果都是一样的
# ele = nameList[2]
# ele = nameList.__getitem__(2)
# print(ele)
"""------------------ 遍历列表 ------------------"""
nameList = ['秦海根', '张刚', '昌子为', '易文']
# for ele in nameList:
# print(ele)
# while循环可不可以遍历nameList中所有的元素?
# 1:可以 2:不可以
index = 0
while index < len(nameList):
# 获取当前元素
ele = nameList[index]
print(ele)
# 修改循环变量
index += 1
list列表的增删:
# nameList = ['秦海根', '张刚', '昌子为', '易文']
"""------------------ 列表增加 ------------------"""
# append增加朱烜甫 在末尾追加一条数据
# nameList.append('朱烜甫')
# print(nameList)
# insert添加 在特定的位置添加数据
# nameList.insert(1,'朱烜甫')
# print(nameList)
# nameList = ['秦海根', '张刚', '昌子为', '易文']
# l = ['张三','李四']
# # extend 将另外一个容器中所有的元素添加到当前容器中
# nameList.extend(l)
# print(nameList)
"""------------------ 删除 ------------------"""
nameList = ['秦海根', '张刚', '李四','昌子为','张三', '易文']
# del删除张三 按照索引删除
# del nameList[4]
# print(nameList)
# remove 删除某一个数据
# nameList.remove('李四')
# print(nameList)
# pop(索引)删除 可以返回删除的数据
# deleteEle = nameList.pop(4)
# print(deleteEle)
# print(nameList)
# pop没有参数 删除末尾元素
# deleteEle = nameList.pop()
# print(deleteEle)
# print(nameList)
# 清空列表
nameList.clear()
print(nameList)
nameList.append('凤姐')
print(nameList)
列表其他操作:
"""------------------ 列表修改 ------------------"""
# nameList = ['秦海根', '张刚', '张三','昌子为', '易文']
# 修改张三 为 张四
# nameList[2] = '张四'
# print(nameList)
"""------------------ 列表查询 ------------------"""
# nameList = ['秦海根', '张刚', '张三','昌子为', '易文']
# 查询某一个元素
# print(nameList[2])
# index 查询角标
# 查看张三的角标
# i = nameList.index('张三')
# print(i)
# del nameList[nameList.index('张三')]
# print(nameList)
# 列表中可以存储多个相同的元素
# count
# nameList = ['秦海根', '张刚', '张三','昌子为', '易文','张三']
# # 查看张三在列表中出现多少次
# c = nameList.count('李四')
# print(c)
列表的排序和最值:
"""------------------ 列表的排序 ------------------"""
ageList = [90,10,30,20,50,70]
# 从小到大 升序
# ageList.sort()
# print(ageList)
# 从大到小 降序
# ageList.sort(reverse=True)
# reverse 将列表进行反转
# ageList.reverse()
# print(ageList)
"""------------------ 最值 ------------------"""
# 最大值
maxValue = max(ageList)
print(maxValue)
minValue = min(ageList)
print(minValue)
冒泡排序:
"""
有一个数字集合[9,8,7,6,5,4,3,2,1],请手动对这个集合正序排序(不要使用sort方法)
"""
# l = [9, 8, 7, 6, 5, 4, 3, 2, 1]
l = [9, 68, 17, 6, 45, 4, 133, 2, 121]
# 不借助于sort函数(帮你实现了算法)
# 1.定义双层循环
row = 0
while row < len(l) - 1:
col = 0
while col<len(l)-1-row:
# 当前元素: l[col]
# 下一个元素:l[col+1]
# 如果下一个元素比当前元素小 交换
if l[col]>l[col+1]:
# 交换
tmp = l[col]
l[col]=l[col+1]
l[col+1] = tmp
col += 1
row += 1
print(l)
选择排序
"""
[9,8,7,6,5,4,3,2,1]
通过选择排序 升序排序
"""
# l = [9, 8, 7, 6, 5, 4, 3, 2, 1]
l = [95, 88, 7, 46, 15, 4, 113, 452, 21]
row = 0
while row < len(l) - 1:
# 新的一轮
# 假定最小值角标 row
# 实际最小值角标
index = row
# 里层循环
col = row + 1
while col < len(l):
# 对比当前元素和实际最小值角标元素
if l[col]<l[index]:
# 修改index
index = col
col += 1
# 一轮结束 如果假定的最小值角标和实际的最小值角标不一致,交换数据
if row!=index:
# 交换数据
tmp = l[row]
l[row] = l[index]
l[index] = tmp
row += 1
print(l)
嵌套列表:
"""
1班有三位同学:林青霞 狄龙 郑少秋
2班有2位同学:张曼玉 梁朝伟
"""
# nameList = ['林青霞','狄龙','郑少秋' ,'张曼玉','梁朝伟']
nameList = [['林青霞','狄龙','郑少秋'],['张曼玉','梁朝伟']]
# 查询张曼玉
print(nameList[1][0])
# 修改狄龙 史泰龙
nameList[0][1] = '史泰龙'
print(nameList)
# 知道梁朝伟角标
index = nameList.index(['张曼玉','梁朝伟'])
print(index)
.列表嵌套练习:
"""
需求:
一个学校，有3个办公室，现在有8位老师等待工位的分配，
请编写程序:
1. 完成随机的分配
2. 获取办公室信息 (每个办公室中的人数，及分别是谁)
分析:
1.3个办公室(办公室:列表) 列表嵌套
2.8位老师 列表中保存
3.遍历老师的列表
4.随机存放到办公室中
"""
import random
"""------------------ 随机分配办公室 ------------------"""
# # 1.3个办公室(办公室:列表) 列表嵌套
# classroomList = [[], [], []]
# # 2.8位老师 列表中保存
# teachers = ['袁腾飞', '罗永浩', '俞敏洪', '李永乐', '王芳芳', '马云', '李彦宏', '马化腾']
# # 3.遍历老师的列表
# for teacher in teachers:
# # 随机办公室的角标 Ctrl+P查看提示
# # Ctrl+Alt+V 提取变量
# index = random.randint(0, 2)
# # 4.随机存放到办公室中
# classroom = classroomList[index]
#
# classroom.append(teacher)
# print(classroomList)
"""------------------ 每一个办公室至少有一个人 ------------------"""
# TDD开发
# 1.3个办公室(办公室:列表) 列表嵌套
classroomList = [[], [], []]
# 2.8位老师 列表中保存
teachers = ['袁腾飞', '罗永浩', '俞敏洪', '李永乐', '王芳芳', '马云', '李彦宏', '马化腾']
# 3.每一个办公室中添加一名老师,遍历办公室还是老师列表 办公室:1 老师 2
for classroom in classroomList:
# 随机获取一名老师
# teacher = teachers[random.randint(0,len(teachers)-1)]
# 添加到办公室中
classroom.append(teachers.pop(random.randint(0,len(teachers)-1)))
# 从老师列表中删除这个元素
# del teachers[index]
# teachers.remove(teacher)
# print(classroomList)
# print(teachers)
# 4.把剩下的老师随机分配到办公室中
for teacher in teachers:
# 随机办公室的角标 Ctrl+P查看提示
# Ctrl+Alt+V 提取变量
index = random.randint(0, 2)
# 4.随机存放到办公室中
classroom = classroomList[index]
classroom.append(teacher)
# 清空teachers
teachers.clear()
print(classroomList)
print(teachers)
素数练习:
"""
需求:
列出1~1000内的所有素数
素数:除了1和它本身以外,不能被其它数据整除
2:1 2
3:1 3
5:1 5
7
11
13
17
19
分析:
1.1到1000列举出来 while for
2.6 2..5 7 2 6 11 2..10
看当前数据是否能被从2到当前数据小1的数据整除,只要有一个可以整除,就不是素数
如果所有都不能整除,就是素数
"""
# 执行效率
# 11 1 11 2..6 7
# 1.1到1000列举出来 while for
for ele in range(1,1001):
# 看当前数据是否能被从2到当前数据小1的数据整除,只要有一个可以整除,就不是素数
# 如果所有都不能整除,就是素数
# for a in range(2,ele):# 1000 减少循环次数
for a in range(2,ele//2+1):# 1000 减少循环次数
if ele %a==0:
# 能够被当前数据整除
# print('%d 不是素数'%ele)
break
else:
print(ele)
登录验证练习:
"""
需求:
判断登录用户名是否合法(不能用正则表达式)
用户名是数字字母或者_,需要在3到20位,必须有2个或以上大写字母,2个或以上小写字母,3个或以上数字
hhew2383dW_fkf&E@^
分析:
1.数字字母或者_
2.需要在3到20位
3.必须有2个或以上大写字母
4.2个或以上小写字母
5.3个或以上数字
步骤:
1.定义三个容器分别存放数字 大写字母 小写字母
2.遍历用户名字符串
3.查看元素
1.是否在三个容器中或者是_ 用户名不满足
2.统计数字 小写字母 大写字母
4.循环结束之后,判断数字 字母是否满足长度需求
"""
name = 'hhew2383dW_fkfE'
# 1.定义三个容器分别存放数字 大写字母 小写字母
numberStr = '0123456789'
lowerStr = 'abcdefghijklmnopqrstuvwxyz'
upperStr = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
# 数字个数 小写字母个数 大写字母个数
numberCount = 0
lowerCount = 0
upperCount = 0
# 2.遍历用户名字符串
for ele in name:
# 1.是否在三个容器中或者是_ 用户名不满足
# if (ele in numberStr) or (ele in lowerStr) or (ele in upperStr) or ele == '_':
if (ele in numberStr):
# 数字
# 2.统计数字 小写字母 大写字母
numberCount += 1
elif (ele in lowerStr):
# 小写字母
lowerCount += 1
elif (ele in upperStr):
# 大写字母
upperCount += 1
elif ele == '_':
pass
else:
# 不合法字符
print('密码不合法')
# 跳出循环
break
else:
# 需要在3到20位, 必须有2个或以上大写字母, 2
# 个或以上小写字母, 3
# 个或以上数字
if (len(name)>=3 and len(name)<=20) and upperCount>=2 and lowerCount>=2 and numberCount>=3:
print('密码合法')
else:
print('密码不合法')
2.元组的定义和特点
"""------------------ 元组的定义 ------------------"""
# 定义元组 保存同学姓名
# t = ('秦海根','朱烜甫','张刚')
"""------------------ 元组特点 ------------------"""
# 获取某一个元素
# ele = t[0]
# print(ele)
# 不能增加元素
# 不能修改元素
# t[0] = '易文'
# 能不能删除元素
# del t[0]
# print(type(t))
"""------------------ 元组元素可以重复的 ------------------"""
"""------------------ 一个元组元组的定义:需要在元组后面加上, ------------------"""
# 空列表
# l = []
# print(type(l))
# 空元组
# t = ()
# print(type(t))
# 定义一个元素的元组
t = ('张曼玉',)
print(type(t))
元组的操作:
t = ('秦海根', '张刚', '朱烜甫', '张刚')
"""------------------ 查询 ------------------"""
# 查询某一个元素
# ele = t[0]
# print(ele)
# 获取元素的索引
# index = t.index('张刚')
# print(index)
# 张刚出现的次数
# print(t.count('张刚'))
for ele in t:
print(ele)
列表的作用:
# t = ('秦海根', '张刚', '朱烜甫', '张刚')
"""------------------ 元组的自动组包 ------------------"""
# a = 10
# b = 20
# 同时定义了多个变量
# a,b = 10,20
# 自动组包
# a = 10,20
# print(type(a))
"""------------------ 元组的自动解包 ------------------"""
# t = ('秦海根', '张刚', '朱烜甫')
# name1 =t[0]
# name2 =t[1]
# name3 =t[2]
# print(name1,name2,name3)
# 自动解包 保证接收的变量和元组的元素个数保持一致
# name1,name2,name3 = t
# print(name1,name2,name3)
"""------------------ 数据交换 ------------------"""
a = 10
b = 20
# 交换a和b
# tmp = a
# a = b
# b = tmp
# go语言
a,b = b,a # 组包(20,10) 解包:a:20 b:10
# print(a,b)
"""------------------ 格式化输出 ------------------"""
# t = (10,20)
# print('第一个数据:%d,第二个数据:%d'%(t[0],t[1]))
# print('第一个数据:%d,第二个数据:%d'%t)
"""------------------ 让列表不可变 ------------------"""
l = ['秦海根', '张刚', '朱烜甫']
# 可以把列表变成元组 让它不可修改
t = tuple(l)
print(t)
3.集合
"""
python数据类型:
数值型:int float bool compex
高级变量类型: list tuple set dict str
list:容器 可以增删改查 有序 元素不唯一
"""
# l = ['张三','李四','王五','张三']
# print(l)
# t = ('张三','李四','王五','张三')
# print(t)
"""------------------ 创建集合 ------------------"""
# 集合特点:元素唯一的
# s = {'张三','李四','王五','张三'}
# 容器中元素是无序的
# s = {'张三','李四','王五'}
# print(s)
"""------------------ 数据类型 ------------------"""
# s = {'张三','李四','王五'}
# print(type(s))
"""------------------ 集合的遍历 ------------------"""
# s = {'张三','李四','王五'}
# for ele in s:
# print(ele)
"""------------------ 获取集合中第二个元素 ------------------"""
# 能 1 不能 2
# ele = s[1]
# print(ele)
"""------------------ 集合中添加元素 ------------------"""
# s = {'张三','李四','王五'}
# l = ['张曼玉','林青霞','赵六']
# # 添加赵六 add
# # s.add('赵六')
# # print(s)
#
# # update添加
# s.update(l)
# print(s)
"""------------------ 删除元素 ------------------"""
s = {'张三','李四','王五'}
# 删除张三 remove 删除元素,如果元素不存在,删除失败
# s.remove('张三')
# print(s)
# s.remove('林青霞')
# pop 随机删除
# s.pop()
# print(s)
# discard 删除元素 如果元素不存在,不做任何处理
s.discard('林青霞')
print(s)
集合的其它操作:
"""------------------ 子集和超集 ------------------"""
# s1 = {1,2,3}
# s2 = {1,2,3}
# result = s2.issubset(s1)
# print(result)
# result = s1.issuperset(s2)
# print(result)
"""------------------ 并集 ------------------"""
# s1 = {1,2,3}
# s2 = {3,4,5}
# result = s1.union(s2)
# print(result)
"""------------------ 交集 ------------------"""
# s1 = {1,2,3}
# s2 = {3,4,5}
# result = s1.intersection(s2)
# print(result)
"""------------------ 抑或 ------------------"""
s1 = {1,2,3}
s2 = {3,4,5}
# result = s1.symmetric_difference(s2)
# print(result)
s1.symmetric_difference_update(s2) # 更新s1为抑或的结果
print(s1)
# s1.symmetric_difference(s2)
# s1.symmetric_difference_update(s2) 更新s1为异或的结果
集合的作用:
l = ['张三','李四','王五','张三']
# newL = []
# for ele in l:
# if ele not in newL:
# newL.append(ele)
#
# print(newL)
# 通过集合对列表去重
# s = set(l)
# print(s)
# l = list(s)
# print(l)
"""------------------ list tuple set相互转换 ------------------"""
# list转换成set
# s = set(l)
# print(s)
# list转换成tuple
t = tuple(l)
# print(t)
# tuple转换成set
s = set(t)
# print(s)
l = list(s)
print(l)
4.字符串:
"""------------------ 字符串的定义 ------------------"""
# 字符:a b c d e f 中 过 华
# str = 'hello'
# str = "hello"
# str = 'hel'你好'lo'
# str = 'hel\'你好\'lo'
# # print(str)
#
# str = "hel\"你好\"lo"
# # print(str)
#
# str = "hel'你好'lo"
"""------------------ 获取某一个元素 ------------------"""
# str = 'hello'
# 获取第三个元素
# ele = str[2]
# print(ele)
"""------------------ 遍历字符串中每一个元素 ------------------"""
# for ele in str:
# print(ele)
"""------------------ 原样输出字符串 ------------------"""
# str = 'hello'
# str = "hello"
# 省
# 市
# 区
# str = '广东省\n深圳市\n宝安区'
# kotlin
str = '''广东省
深圳市
宝安区'''
print(str)
字符串判断:
# str = 'a'
"""------------------ isalpha ------------------"""
# result = str.isalpha()
# print(result)
"""------------------ isdecimal ------------------"""
# 字符串非空 并且都是数字 返回True
# str = ''
# result = str.isdecimal()
# print(result)
"""------------------ islower ------------------"""
# str = '123123a'
# result = str.islower()
# print(result)
"""------------------ isupper ------------------"""
# str = '1203123A'
# result = str.isupper()
# print(result)
"""------------------ startwith ------------------"""
# str = 'helloworld'
# result = str.startswith('w',5)
# print(result)
"""------------------ endwith ------------------"""
# str = 'helloworld'
# result = str.endswith('o',2,5)
# print(result)
查找和替换:
# str = 'helloworld'
"""------------------ find ------------------"""
# find返回在字符串中的角标 如果不存在返回-1
# result = str.find('z')
# print(result)
# 首字母对应的角标
# result = str.find('loww')
# 返回的角标 3 4 5
# print(result)
# 默认找到第一个当前元素 返回它的角标
# 可以通过start以及end指定查找范围
# result = str.find('l',5)
# print(result)
"""------------------ rfind:从右边开始找到第一个结束 ------------------"""
# str = 'helloworld'
# print(str.find('l'))
# print(str.rfind('l',1,5))
"""------------------ index ------------------"""
# 如果不存在 就报错 存在返回索引
# str = 'helloworld'
# print(str.index('o'))
# print(str.index('z'))
"""------------------ rindex ------------------"""
# 从右边开始 如果存在返回索引 不存在就报错
"""------------------ replace ------------------"""
str = 'helloworld'
# 如果替换的字符串不存在 不做任何处理
# newStr = str.replace("loww",'up')
# 默认 只要遇到字符串就替换 可以通过第三个参数指定替换的个数
newStr = str.replace("l",'up',2)
print(str)
print(newStr)
字符串拆分和连接:
# str = 'helloworld'
"""------------------ partition ------------------"""
# 根据str将字符串拆分 返回元组 (str前 str str后)
# result = str.partition('low')
# print(result)
"""------------------ rpartition ------------------"""
# str = 'helloworldhelloworld'
# result = str.partition('low')
# result = str.rpartition('low')
# print(result)
"""------------------ split ------------------"""
# 对字符串进行分割 返回列表 不会保存分割字符串
# str = '张三hello李四hello王五hello赵六'
# result = str.split('hello')
# print(result)
"""------------------ splitlines ------------------"""
# 按\n换行符分割
# str = '广东省\n深圳市\n宝安区'
# str = '''广东省
# 深圳市
# 宝安区'''
# result= str.splitlines()
# print(result)
"""------------------ + ------------------"""
# str1 = 'hello'
# str2 = 'world'
# newStr = str1 +str2
# print(newStr)
"""------------------ join ------------------"""
l = ['张三','李四','王五']
str = 'hello'
# 将容器中所有的元素加上当前字符串分割输出
result = str.join(l)
print(result)
大小写转换:
"""------------------ lower ------------------"""
# str = 'HELLOw12312'
# 字符串转换小写
# result = str.lower()
# print(result)
"""------------------ upper ------------------"""
str = 'helloA1231中国'
result = str.upper()
print(result)
文本对齐:
"""------------------ ljust ------------------"""
# str = 'hello'
# result = str.ljust(10,'-')
# print(str)
# print(result)
"""------------------ rjust ------------------"""
# str = 'hello'
# result = str.rjust(10,'*')
# print(result)
"""------------------ center ------------------"""
# str = 'hello'
# result = str.center(10,"&")
# print(result)
去空白:
"""------------------ lstrip ------------------"""
# 去除左边的空白
# str = ' hello '
# result = str.lstrip()
# print(result)
# str = '----hello '
# result = str.lstrip('-')
# print(result)
"""------------------ rstrip ------------------"""
# str = ' he**llo****'
# result = str.rstrip('*')
# print(result)
"""------------------ strip ------------------"""
str = ' hello '
result = str.strip()
print(result)
字符串练习-判断用户名和密码.:
"""
需求:
用户名和密码格式校验程序
要求从键盘输入用户名和密码，校验格式是否符合规则，如果不符合，打印出不符合的原因，并提示重新输入
用户名长度6-20，用户名必须以字母开头
密码长度至少6位，不能为纯数字，不能有空格
分析:
1.从键盘输入用户名(需要while循环)
2.长度6-20
3.必须字母开头
4.输入密码(while循环)
5.密码长度至少6位
6.不能为纯数字
7.不能有空格
"""
while True:
# 1.从键盘输入用户名(需要while循环)
name = input('请输入用户名:')
# 2.长度6-20
if not (len(name) >= 6 and len(name) <= 20):
print('用户名必须6到20位')
continue
# 3.必须字母开头 ab A-Z
# 获取第一个字母 是否是a-z A-Z a
ele = name[0]
if not ele.isalpha():
print('用户名第一个必须为字母')
continue
# 用户名满足
print('用户名合法')
break
# 4.输入密码(while循环)
while True:
pwd = input('请输入密码')
# 5.密码长度至少6位
if len(pwd) < 6:
print('密码长度至少为6位')
continue
# 6.不能为纯数字
if pwd.isdecimal():
print('密码不能为纯数字')
continue
# 7.不能有空格
# ' 张 三 '
if ' ' in pwd:
print('密码不能有空格')
continue
print('密码合法')
break
print('开始登录')
5.字典
"""------------------ 字典的定义 ------------------"""
# d = {'中国':'China','英国':'England','美国':'America',30:'sadf',(10,20,30):'afdsf'}
# key只能是数字 字符串 元组类型
# d = {'中国':'China','英国':'England','美国':'America',30:'sadf',(10,20,30):'afdsf',1.2323:12,True:243234}
# vlaue可以是任意类型
# d = {'中国':'China','英国':'England','美国':'America',30:[1,2,3],40:{1,2,3}}
# print(d)
"""------------------ key必须是唯一的 ------------------"""
# key必须要唯一 如果出现多个相同的key 后面的会覆盖前面的内容
# key相当于字典的索引
d = {'中国':'China','英国':'England','美国':'America','美国':'USA'}
print(d)
字典的增删改:
"""------------------ 增加 ------------------"""
# d = {'中国':'China','英国':'England','美国':'America'}
# 添加 法国
# 字典[key] = value
# d['法国'] = 'France'
# print(d)
# d.setdefault('法国','France')
# print(d)
"""------------------ 删除 ------------------"""
# d = {'中国':'China','英国':'England','美国':'America'}
# 删除美国 如果键不在字典中,会报错
# del d['法国']
# print(d)
# pop 删除元素 并且返回删除元素的值 如果删除不存在会报错
# result = d.pop('法国')
# print(d)
# print(result)
# del d
# del d # 销毁当前容器 不能再继续使用
# print(d)
# 清空容器中的数据 还可以继续使用
# d.clear()
# print(d)
# d['中国'] = 'China'
# print(d)
"""------------------ 修改 ------------------"""
d = {'中国':'China','英国':'England','美国':'America'}
# 修改美国
# d['美国'] = 'USA'
# d.setdefault('美国','USA')
# d['法国'] = 'France'
# print(d)
字典的查询和遍历:
"""------------------ 字典查询键对应的值 ------------------"""
# d = {'中国':'China','英国':'England','美国':'America'}
# 根据键获取值 如果键值对不存在,就会报KeyError
# ele = d['法国']
# print(ele)
# get 获取键对应的值 如果键值对不存在,不会报错 返回的结果是None
# ele = d.get('英国')
# if ele:
# print('成功',ele)
# else:
# print('失败')
"""------------------ 查询所有的键值对 ------------------"""
# d = {'中国':'China','英国':'England','美国':'America'}
# 查询所有的键 视图对象
# result = d.keys()
# 视图转换成列表
# keyList = list(result)
# print(keyList)
# 获取所有的values 返回视图
# result = d.values()
# 视图转换成list
# valuesList = list(result)
# print(valuesList)
# items获取所有的键值对 返回列表 列表中每一个元素是键值对的元组
# result = d.items()
# 视图转换成list
# itemsList = list(result)
# print(itemsList)
"""------------------ 遍历 ------------------"""
d = {'中国':'China','英国':'England','美国':'America'}
print(len(d))
# for ele in 遍历 ele代表键
# for ele in d:
# print(ele,d[ele])
# 获取所有的键
# for key in d.keys():
# print(key)
# 打印所有的values
# for value in d.values():
# print(value)
# items打印所有的键值对
# for ele in d.items():
# print(ele)
for key,value in d.items():
print(key,value)
字典的应用场景:
# 描述人 姓名 电话 年纪 性别 动态行为 吃饭 开车 学习
# l = ['张三','12321',40,'男']
# 字典
d = {'name':'张三','phone':'12332','age':40,'性别':'男'}
l = []
l.append(d)
d = {'name':'李四','phone':'12332','age':40,'性别':'男'}
l.append(d)
print(l)
空字典:
# 空列表
l = []
# 空元组
# d = ()
# d = (10,)
# 空字典 {}
# d = {}
# print(type(d))
# 空集合 不能通过{}定义 需要通过set定义
s = set()
print(s)
字典练习:
students = [
{"name": "阿土",
"age": 20,
"gender": True,
"height": 1.7,
"weight": 75.0},
{"name": "小美",
"age": 19,
"gender": False,
"height": 1.6,
"weight": 45.0},
]
"""------------------ 判断如下列表中是否存在name为'阿土'的元素 ------------------"""
mark = False
# 遍历列表
for ele in students:
# 遍历每一个字典的数据
for key,value in ele.items():
# name=='阿土'是否存在
if key=='name' and value=='阿土图':
print('找到了数据')
mark = True
break
if mark:
break
else:
print('没有这个数据')
高级变量练习:
"""
需求:
有10个球分别3红、3蓝、4白，现需要将这10个球放入这3个盒子，要求每个盒子至少有一个白球，请用程序实现
一个容器保存所有的球
分析:
1.定义容器保存所有的球
2.定义三个盒子 嵌套列表
3.遍历三个盒子,每个盒子添加一个白球
三个容器保存三种球
1.定义三个容器保存三种球
2.定义三个盒子 嵌套列表
3.白球分配到三个盒子中
4.三个容器合并,再进行分配
"""
"""------------------ 一个容器保存所有的球 ------------------"""
# import random
# # 1.定义容器保存所有的球
# balls = ['白','蓝','白','白','红','白','蓝','蓝','红','红']
# # 2.定义三个盒子 嵌套列表
# boxes = [[],[],[]]
# # 3.遍历三个盒子,每个盒子添加一个白球
# for box in boxes:
# # 找到白球
# # 添加白球
# box.append(balls.pop(balls.index('白')))
# # 从balls容器把添加的白球删除掉
# # for box in boxes:
# # # 找到白球
# # index = balls.index('白')
# # ball = balls[index]
# # # 添加白球
# # box.append(ball)
# # # 从balls容器把添加的白球删除掉
# # balls.remove(ball)
#
# # print(balls)
# # print(boxes)
#
# # 4.剩下的球再进行分配
# # 球 1 盒子 2
# for ball in balls:
# index = random.randint(0,2)
# # 随机获取box
# box = boxes[index]
# # 添加球到盒子中
# box.append(ball)
#
# balls.clear()
# print(balls)
# print(boxes)
"""------------------ 三个容器保存三种球 ------------------"""
import random
# 1.定义三个容器保存三种球
whiteBalls = ['白','白','白','白']
redBalls = ['红','红','红']
blueBalls = ['蓝','蓝','蓝']
# 2.定义三个盒子 嵌套列表
boxes = [[],[],[]]
# 3.白球分配到三个盒子中
for box in boxes:
# 找到白球
# 添加白球
box.append(whiteBalls.pop(whiteBalls.index('白')))
# print(boxes)
# print(whiteBalls)
# 4.三个容器合并,再进行分配
l = []
l.extend(whiteBalls)
l.extend(redBalls)
l.extend(blueBalls)
whiteBalls.clear()
redBalls.clear()
blueBalls.clear()
for ball in l:
index = random.randint(0,2)
# 随机获取box
box = boxes[index]
# 添加球到盒子中
box.append(ball)
print(boxes)
6.内置函数:
# d = {'name':'张三','age':40}
# del d
# print(len(d))
# print(d)
s = {20,50,100}
# print(max(s))
d = {20:60,90:40}
print(max(d))
运算符:
"""------------------ + ------------------"""
str1 = 'hello'
str2 = 'world'
newStr = str1+str2
# result = str1+10
# print(newStr)
# 列表+
# l1 = [1,2,3]
# l2 = [4,5,6]
# newL = l1+l2
# print(newL)
# 元组+
# t1 = (1,2,3)
# t2 = (4,5,6)
# newT = t1+t2
# print(newT)
"""------------------ * ------------------"""
str = 'hello'
# print(str * 5)
# l = [1,2,3]
# print(l * 5)
# t = (1,2,3)
# print(t * 5)
"""------------------ in 和not in ------------------"""
# 字典中in和not in判断的是key是否在字典中
"""------------------ 比较 ------------------"""
# str1 = 'hemlo'
# str2 = 'hfllo'
# print(str1 < str2)
l1 = [1,2,3]
l2 = [1]
print(l1 > l2)
切片:
"""
切片:字符串 列表 元组
"""
# str = '中华人民共和国欢迎您'
"""------------------ 切片的简单使用 ------------------"""
# 获取前三个文字
# newStr = str[0:3:1]
# print(newStr)
# 步长:默认1 省略默认步长
# newStr = str[0:3:]
# 不写步长 可以省略步长前面的:
# newStr = str[0:3]
# 索引从0开始 可以省略开始索引,不能省略:
# newStr = str[:3]
# 后5个元素
# newStr = str[5:10]
# 结束索引是在最后 可以省略结束索引
# newStr = str[5:]
# print(newStr)
"""------------------ 步长 ------------------"""
# str = '中华人民共和国欢迎您'
# newStr = str[0:8:3]
# print(newStr)
倒序索引:
"""
需求:
str = "中华人名共和国欢迎您"
把字符串中从第一个到倒数第二个(不包含)打印出来
"""
str = "中华人名共和国欢迎您"
# 把字符串中从第一个到倒数第二个(不包含)打印出来
# newStr = str[:8]
# 开始位置 正序 结束位置:倒序
newStr = str[:-2]
print(newStr)
负数步长:
"""
需求:
str = "中华人名共和国欢迎您"
把从角标为2到7(包含)倒序打印出来
"""
str = "中华人名共和国欢迎您"
# 把从角标为2到7(包含)倒序打印出来
# 欢国和共名人
# newStr = str[2:8:-1]
# 步长为负 索引也应该逆序索引
newStr = str[7:1:-1]
print(newStr)
高级变量练习:
"""
需求:
完成字符串的逆序以及统计
设计一个程序，要求只能输入长度低于31的字符串，否则提示用户重新输入
打印如下内容:
您输入的字符串: ...
长度: ...
逆序后为: ...
字符统计结果: ...(afsfdsf) a:1 f:3 s:2 d:1
zhangsanlisi
分析
1.输入字符串(while循环)
2.字符串长度小于31位,否则提示重新输入
3.您输入的字符串: ...
4.长度: ...
5.逆序后为: ... (切片)
6.字符统计结果: ...(afsfdsf) a:1 f:3 s:2 d:1
safljdsfl s:2 a:1 f:2 l:2 j:1 d:1
"""
while True:
# 1.输入字符串(while循环)
str = input('请输入字符串')
# 2.字符串长度小于31位,否则提示重新输入
if len(str)>=31:
print('不能超过31位,请重新输入')
continue
# 跳出循环
break
print('输入正确')
# 3.您输入的字符串: ...
print('您输入的字符串:%s'%str)
# 4.长度: ...
print('长度:%d'%len(str))
# 5.逆序后为: ... (切片)
# hello olleh
newStr = str[::-1]
# print('逆序后为:%s'%newStr)
# 6.字符统计结果: ...(afsfadsf) a:1 f:3 s:2 d:1
# 1.字典 保存结果 {}
resultDict = {}
# 2. 如果字典中没有这个a a添加进去 {'a':1}
for ele in str:
# 3.字典中有a 将元素个数+1
if ele not in resultDict:
resultDict[ele] = 1
else:
resultDict[ele] += 1
print('字符统计结果:{}'.format(resultDict))
7.列表推导式
# l = []
# for ele in range(1,10001):
# if ele % 2 ==0:
# l.append(ele)
#
# print(l)
"""------------------ 推导式 ------------------"""
# 需要定义列表保存从1到10000的数据,怎么做?
# l = [ele for ele in range(1,10001)]
# print(l)
"""------------------ 2.创建包含1到10000中所有偶数的列表 ------------------"""
# l = [ele for ele in range(1, 10001) if ele % 2 == 0]
# print(l)
"""------------------ 3.创建嵌套列表(列表每个元素是两个元素的元组) ------------------"""
# l = [(1,2),(2,4),(3,6)..,(100,200)]
# l = [(ele,ele*2)for ele in range(1,101)]
# print(l)
"""------------------ 4.创建嵌套列表(列表每个元素是三个元素的元组) ------------------"""
# l = [(1,2,3),(2,4,6),(3,6,9)..,(100,200,300)]
# l = [(ele,ele*2,ele*3)for ele in range(1,101)]
# print(l)
推导式练习:
"""
需求:
请写出一段 Python 代码实现分组一个 list 里面的元素
比如 [1,2,3,...100]变成 [[1,2,3],[4,5,6]....[100]]
"""
l = [ele for ele in range(1,101)]
# print(l)
# [[1,2,3],[4,5,6]....[100]]
# [[ele,ele+1,ele+2]for ele in l if ]
# 切片 0:3 3:6 6:9
newL = [l[ele:ele+3]for ele in range(0,len(l)) if ele %3==0]
print(newL)
# str = 'hello'
# print(str[3:10])
集合和字典推导式:
"""------------------ 集合推导式 ------------------"""
# s = {ele for ele in range(1,101)}
# print(s)
"""------------------ 字典的推导式 ------------------"""
# 需求:
# 定义{"1":1,"2":4,'3':9,..,'10':100}这样的字典
# d = {str(ele):ele**2 for ele in range(1,11)}
# print(d)
l1 = [ele for ele in range(1,11)]
l2 = [ele for ele in range(21,31)]
# {1:21,2:22,3:23}
# 错误写法
# d = {key:value for key in l1 for value in l2}
# 正确写法 l1和l2打包一起 一起遍历 zip
d = {key:value for key,value in zip(l1,l2)}
print(d)
来源：CSDN
作者：苏凯勇往直前
链接：https://blog.csdn.net/qq_15204179/article/details/104593008