一、流程控制结构

流程：计算机执行代码的顺序

流程控制：对计算执行代码的顺序进行有效的管理，只有流程控制才能实现在开发当中的业务逻辑

流程控制的分类：顺序流程、选择流程、循环流程

[code]import random
start=int(input('请输入1开始游戏,输入其他退出游戏'))
if start!=1:
exit()
index=0#获胜次数
while start==1:
player = int(input('请出拳【0：拳头 1：剪刀 2：布】'))
while player>2 or player<0:
player = int(input('请输入0-2之间的值'))
computer=random.randint(0,2)
print('电脑出拳：%d'%(computer))
if player==0 and computer==1:
index += 1
print('you win,total %d times'%(index))
elif player==1 and computer==2:
index += 1
print('you win,total %d times' % (index))
elif player==2 and computer==0:
index += 1
print('you win,total %d times' % (index))
elif player==computer:
print('planishing')
else:
print('you lose')
start=int(input('输入1继续游戏，输入其他则退出'))

我不装了，其实我熟悉java，所以这边就直接写个猜拳小游戏，直接把流程都走一遍。

下面一个是while循环嵌套，九九乘法表

[code]row=1
while row<=9:
col = 1
while row>=col:
k=col*row
# print('%d*%d=%d'%(row,col,k),end=' ')
print('{}*{}={}'.format(row,col,k),end=' ')
col+=1
print()
row+=1

还有一个for循环，可以遍历字符串

[code]#for循环
a='python'
for i in a:
print(i,end=' ')

print()
a='我叫鹿鸣松'
for i in a:
print(i,end=' ')

print()
#range函数可以生成一个数据集合列表
#range(起始，结束，步长) 步长不能为0
#range生成的集合是一个左闭右开区间
for date in range(1,100):
print(date,end=' ')

print()
for date in range(1,100,8):
print(date, end=' ')

再来一个for做的九九乘法表，看着比while简单一点

[code]for row in range(1,10):
for col in range(1,10):
if row<=col:
print('%d*%d=%d'%(row,col,row*col),end=' ')
print()

break跳出循环和continue跳过本次循环

[code]for i in range(1,20):
print(i,end=' ')
if i==10:
break
print()
for i in range(1,20):
if i%2==0:
continue
print(i, end=' ')

for…else用法，在for循环中没有被break的情况下正常结束，就可以执行else中语句

[code]account='鹿鸣松'
pwd='123'
for i in range(3):
zh=input('请输入您的账号：')
pd=input('请输入您的密码：')
if account==zh and pd==pwd:
print("恭喜您登录成功")
break
else:
print('您输入的帐号密码有误，请重新输入')
else:
print('超过三次登录失败，您的帐号已被锁定')

while…else用法类似

[code]account='鹿鸣松'
pwd='123'
i=1
while i<=3:
zh = input('请输入您的账号：')
pd = input('请输入您的密码：')
if account == zh and pd == pwd:
print("恭喜您登录成功")
break
else:
print('您输入的帐号密码有误，请重新输入')
i+=1
else:
print('超过三次登录失败，您的帐号已被锁定')

二、高级数据类型

2.1序列

定义：是一组按照顺序排列的值【数据集合】

种类：字符串、列表、元组

优点：支持索引和切片的操作

特征：第一个正索引为0，指向的是左端，第一个索引为负数时，指向的是右端

2.1.1字符串操作

切片：是指截取字符串中的一段内容。

使用语法：[起始下标：结束下标：步长]切片截取的内容不包含结束下标对应的数据，步长指的是隔几个下标获取一个字符，默认为1。

[code]str='python'
for i in str:
print(i,end=' ')
print()
#首字母变大写capitalize
name='kirio'
print(name.capitalize())

#去除空格strip
a=' hello '
print(a)
print(a.strip())
print(a.lstrip())#删除左边的空格
print(a.rstrip())#删除右边的空格

#复制字符串
b=a
'''
id函数可以查看一个对象的内存地址，把a赋值给b，其实就是将b指向a所指向的内存地址，也就是所谓的开箱装箱
'''
print('a的内存地址%d'%id(a))
print('b的内存地址%d'%id(b))

#查找数据
print(str.find('y'))#输出结果是1，也就是在第二位，这个值是下标
print(str.find('p'))#输出结果是0，这就表明这个函数是从下标0开始找，找到第一个匹配的就给你返回，不是多个返回
print(str.find('z'))#输出结果为-1，说明没有找到
print(str.index('y'))#输出结果是1,和find一样，返回下标
# print(str.index('z'))#输出结果报错
params='py pt hon'
substr='pt'
print(params.rfind(substr))#输出结果为3，返回的是匹配的字符串的首字母的下标

#判读字符串是不是以什么为开始
print(str.startswith('p'))
#判读字符串是不是以什么为结尾
print(str.endswith('n'))

#全转换为小写
print(str.lower())
#全转换为大写
print(str.upper())

#取出第二个到第四个之间的数据
print(str[1:4])#输出的是yth，说明这个是一个左闭右开区间
print(str[1:])#从第二个值一直取到最后
print(str[:3])#从第一个字符输出到第三个
print(str[:6:2])#从左往右，每两位，输出一个
print(str[::-1])#倒序输出
print(str[-1:-3:-1])#倒序输出第一和第二个字符

#判断是否是字母和数字
print(str.isalnum())#输出结果为true

#判断是否为字母
print(str.isalpha())#输出结果为true

#判断是否为数字
print(str.isnumeric())#输出结果为false
print(str.isdigit())#输出结果为false

#判断是否为小写
print(str.islower())#输出结果为true,要全部为小写才为true
#判断是否为大写
print(str.isupper())#输出结果为flas，要全部为大写才为true

#循环取出所有的值，并用xx去连接，如下所示，循环取出str中的值，并用空白符去连接
print(' '.join(str))

#大写变小写，小写变大写
str1='PyThon'
print(str1.swapcase())

#切割字符串
str2=' '.join(str)
print(str2.split(' '))#以空格为分隔符，全部分割
print(str2.split(' ',1))#以空格为分隔符，分成两个、

#把每个单词的首字母大变成大写
str3='i#like!python very*much'
print(str3.title())#只要中间被非a-z的字母隔离开了，那么就会认为是个单词，并将首字母大写

#批量替换字符
print(str3.replace('h','H'))#输出结果 i#like!pytHon very*mucH
#在第三项上加上了数字，表示替换多少项，不加则表示全部替换
print(str3.replace('h','H',1))#输出结果为 i#like!pytHon very*much

#统计某个字符出现的次数
print(str3.count('h'))#输出结果为2

2.1.2列表操作

定义：是一种有序的数据集合

特点：

• 可以进行增删改查
• 列表中的数据项是可以变化的，但是列表本身的内存地址是不会变的
• 数据项之间用逗号分隔，其中数据项可以是任何类型
• 支持索引和切片

查找：

[code]print('==============查找===============')
print(listA)  # 打印出列表中的所有数据项
print(len(listA))  # 打印出列表中数据项的个数
print(listA[1])  # 打印出列表中第二个数据项，也是通过下标索引
print(listA[1:4])  # 从左往右，以此打印出从第二个到第四个数据项
print(listA[2:])  # 打印出从第三项开始到最后的数据项
print(listA[-1:-3:-1])  # 倒序打印，从右往左打印两项
print(listA * 2)  # 输出2次列表中的数据
print(listA[-1:-3:-1] * 2)  # 倒序打印，从右往左打印两项，输出2次
print(listA.index(2.1))#在列表中找对应的值，返回的是对应的下标1
print(listA.index(2.1,1,5))#从列表中第二项开始找元素2.1，连续找五个，返回的是对应的下标1，如果找不到会报错

增加：insert、append、extend，这里两个函数的区别，append是把一个对象加入进去，而extend是把一个序列中的内容加入进去

[code]print('==============增加================')
listA.append(['Word', '鹿鸣松'])  # 增加两项,append加的是object
listA.insert(1, '这是插入在第二项的数据')  # 第一个参数表示列表的下标，后面一个参数是值，也就是把值插入到第二项中
rsDate = list(range(10))#生成数据项为0-9的列表
rsDate1 = range(10,20)
# for item in rsDate:
#     print(item, end=' ')
listA.extend(rsDate)#追加一个序列里的内容
listA.extend(rsDate1)#追加一个序列里的内容
print(listA)

修改：

[code]print('==============修改================')
listB=[1, '这是插入在第二项的数据', 2.1, 'Hello', True, ['Word', '鹿鸣松']]
listB[0]='修改了'
print(listB)

删除：

[code]print('==============删除================')
del listB[0]#删除第一项
del listB[0:2]#批量删除多项，这边是删了第一、二项
listB.remove('Hello')#删除指定的元素，从左往右删，找到对应的第一项就删除，后面的不删
listB.pop(1)#参数是下标，通过索引找到对应的值，并删除
print(listB)

2.1.3元组操作

定义：是一种不可变的序列，在创建之后不能做任何修改

特点：

• 不可变
• 用（）创建元组类型，数据项之间用逗号隔开
• 数据项可以是任何类型
• 当元组中只有一个元素时，要加上逗号，不然解释器会当作整型处理
• 同样支持切片操作

[code]#元组的创建 不能进行修改，也就是没有删除、修改、增加的内置函数
tupleA=('鹿鸣松',123,45.6,[11.23,45],'age',213)
print(tupleA[3])#通过下标去取数据，获取的是单个数据项
print(tupleA[1:3])#取二到三项
print(tupleA[::-2])#反转字符串，每两个取一个
print(tupleA[-2:-1:])#倒着取下标为[-2，-1)区间的元素

#不能对元组进行修改，但可以对元组中的列表进行修改
tupleA[3][0]='hello'
print(tupleA)

print(tupleA.count(123))#查找元素出现的次数

2.1.4字典操作

定义：是有键值对组成的集合，用键来访问数据，效率较高，和list一样，支持数据的添加、修改、删除操作

特点：

• 不是序列类型，没有下标，是一个无需的键值集合，是内置的高级数据类型
• 用{}来表示字典对象，每个键值对用逗号分隔
• 键必须是不可变的类型，如元组、字符串，值是可以任何类型
• 每个键必定是唯一的，如果存在重复的键，那么后者会覆盖前者

[code]# 创建字典
dictA = {'name': '鹿鸣松'}
dictA['age'] = 24  # 添加
print(dictA)  # 输出完整的字典
print(len(dictA))  # 输出字典的长度

# 查找
print(dictA['name'])  # 根据键去查找对应的值
# 获取所有的键
print(dictA.keys())
# 获取所有的值
print(dictA.values())
# 获取所有的数据项,也就是键和值
print(dictA.items())
for key, value in dictA.items():
print('{}:{}'.format(key, value))

# 修改
dictA['age'] = 25
print(dictA['age'])
dictA.update({'age': 24})
dictA.update({'hobby': '编程'})
print(dictA['age'])

# 删除
# del dictA['name']  # 根据指定键删除
# dictA.pop('age')# 根据指定键删除
# print(dictA)

#排序
dictB = {'name': 1,'age':2,'hobby':3}
print(sorted(dictB.items(),key=lambda d:d[0]))#按照key进行排序
print(sorted(dictB.items(),key=lambda d:d[1]))#按照value进行排序

2.1.4高级数据的一些共有方法

[code]#共有方法+
#字符串合并
strA='Hello'
strB='Word'
print(strA+strB)
#列表合并
listA=[12]
listB=[25.6]
print(listA+listB)
#元组合并
tupleA=(12,'鹿鸣松')
tupleB=(34,)
print(tupleA+tupleB)

#复制*
#字符串输出三次
print(strA*3)
#列表输出三次
print(listA*3)
#元组输出三次
print(tupleA*3)

#in对象是否存在，返回布尔值
print('e'in strA)
print(12 in listA)
print('鹿鸣松' in tupleA)
dictA={'name':'鹿鸣松'}
print('name' in dictA)#这边只能根据key找，判断key是否存在