0217-0221流程控制和数据类型内置方法

0217-0221

流程控制

控制事物的执行流程

1.顺序结构

之前我们写的代码都是顺序结构

2.分支结构

2.1什么是分支结构

分支结构就是根据条件判断的真假来执行各分支结构的子代码

2.2为什么用分支结构

人有时候需要根据不同的情况来做不同的事，程序中也应有相应机制控制计算机具备人的这种能力

2.3如何使用分支机构

2.3.1 if语法

#1.单if判断
if 条件1:
    print('')
   
#2.双分支结构
if 条件1:
    条件成立执行的子代码块
else:
    条件不成立执行的子代码块
    
#3.多分支结构
if 条件1:
    条件1成立执行的子代码块
elif:
    条件1不成立，条件2成立执行的子代码块
elif:
    条件1、2不成立，条件3成立执行的子代码块
else:
    以上条件都不成立时执行的子代码块 # else语句是可有可无的

'''
注意：
	1.根据条件的成立与否，我们来决定是否执行if代码块
	2.我们通过缩进代码块来确定代码间的从属关系
	3.推荐使用缩进4格
	4.不是所有的代码都拥有子代码块
	5.属于同一个代码块的子代码块缩进量必定一致
	ps:冒号后回车换行缩进
'''
    

2.3.2 if判断之嵌套

#遇到漂亮小姐姐的执行流程
age = 18
height = 1.6
weight = 90
is_beautiful = True
is_success = True
if age <20 and weight <100 and height == 1.6 and is_beautiful:
    print('小姐姐，加一下微信呗~')
    if is_success:
        print('吃吃喝喝，看看电影')
    else:
        print('886')
else:
    print('嘤嘤嘤')

2.3.3 if案例

1. 写一个登录功能，用户名是：kevin 密码是：123
# 要求：用户名和密码输入正确，打印登录成功，否则登录失败
username = input('用户名：\n')
password = input('密码：\n')

if username == 'kevin' and password == '123':
    print('登陆成功')
else：
	print('登陆失败')
    
2. 根据用户名的不同打印不同的身份
kevin:管理员  jack:保安  tom:保洁  tank:销售 其余都是普通人
username = input('请输入用户名：\n')
if username == 'kevin':
    print('管理员')
elif username == 'jack':
    print('保安')
elif username == 'tom':
    print('保洁')
elif username == 'tank':
    print('销售')
else:
    print('普通人')

3.循环结构

3.1什么是循环结构

重复循环执行某段代码块

3.2为什么用循环结构

人有时候需要重复做某些事，程序中也应有相应机制控制计算机具备人的这种能力

3.3如何使用循环结构

3.3.1 while循环语法

#1.while语法格式
while 条件:
    条件成立执行的循环体
    
#2.while+break
while 条件:
    循环体
    break#结束当前循环
    
#3.while嵌套+break
while 条件1:
    循环体1
    while 条件2:
        循环体2
        break#结束本层循环,即第二层循环
    break #结束第一层循环
    
#4.while嵌套+标志位的使用
flag = True
while flag:
    循环体1
    if 条件1:
        条件1成立执行的子代码块
        while flag:
            if 条件2：
            	flag = False #结束程序
                
#5.while+continue
while 条件:
    循环体
    continue #结束本次循环，并且回到while循环的条件处继续判断
    
#6.while+else(了解)
'''当while循环没有被中断（break)时，就会执行else下的子代码'''

#7.死循环
'''再循环中，可千万不能出现死循环，时间过长会使内存占满，cpu过热，计算机死机'''
'''能用for循环实现的都不要使用while循环'''

'''
当循环体执行完成后，每次都要回到while的循环条件，再次判断条件是否成立，决定是否执行
'''

3.3.2 while循环案例

#1.while+break
#寻找1到100之间数字7最大的倍数（结果是98）
num = 100
while num <101:
    a = num%7
    if a == 0:
        print(num)
        break
    else:
        num -= 1

#2.while+continue
#打印1到10之间，除7以外的所有数字
count = 0
while count < 10:
    count += 1
    if count == 7:
        continue
    print(count)    

#3.while+else(了解)
count=0
while count < 10:
    if count ==5:
        count+=1
        continue
    print(count)
    count+=1
else:
    print('哈哈哈哈')
#输出是0-9和'哈哈哈哈'，如果是break的话输出是0-4

#4.死循环
while True:
    print(100)

3.3.3 while循环练习

# 猜年龄的游戏
"""
	1. 普通要求
		三次机会
	2. 拔高要求
		三次之后再次询问是否继续输入
"""
# 三次机会,猜对了，就直接结束
# 先写主体功能

#1.先定义一个年龄出来
real_age = 18

#定义一个计数器
count = 1
while count < 4:
    #2.输入用户年龄,把字符串的数字转换为整型，不过int可能会出现bug
    guess_age = int(input('请输入你猜测的年龄'))
    #3.判断输入的年龄和真实年龄是否一致
    if quess_age > real_age:
        print('大了大了')
    elif quess_age < real_age:
        print('小了小了')
    else:
        print('对喽对喽')
        break
    count += 1
    
    
'''拔高，三次之后再次询问是否继续输入'''
#1.先定义一个年龄出来
real_age = 18

#定义一个计数器
count = 1
while count < 4:
    #2.输入用户年龄,把字符串的数字转换为整型，不过int可能会出现bug
    guess_age = int(input('请输入你猜测的年龄'))
    #3.判断输入的年龄和真实年龄是否一致
    if quess_age > real_age:
        print('大了大了')
    elif quess_age < real_age:
        print('小了小了')
    else:
        print('对喽对喽')
        break
    count += 1
    if count == 4:
        #4.询问：是否再次输入
        que = intput('三次机会使用完了，是否再次输入\nyes/no')
        if que == 'yes':
            count = 1
        else:
            print('结束')
            break

3.3.4 for循环语法

#1.语法格式
for 变量 in 可迭代对象(字符串、列表、字典、元组):
    print()
    
for i in 'helloworld':
    print(i)
    
'''
for后面的变量名命名的时候，如果没有特殊的含义，我们一般使用i,j,k,v,item等等
'''
#重点
d = {'username':'kevin', 'age':18, 'hobby':'music'}
for i in d:
    print(i, d[i])#for in遍历字典的时候输出的值是K值

3.3.4.1 range关键字

#配合for循环使用
#1.一个参数，打印数字列表，从0开始
for i in range(10):
    print(i)#输出0-9
    
#2.顾头不顾尾
for i in range(6,20):
    print(i)#输出6-19
    
#3.步长
for i in range(3,15,4):
    print(i)#输出3，7，11
    
#4.拓展知识：输出豆瓣10页网页
url = 'https://movie.douban.com/top250?start=%s&filter='#%是唯一变量，其他都是常量，用格式符代替
for i in range(0,226,25):
    print(url % i)
    
'''小补充：range在不同解释器版本中是有区别的。'''

3.3.4.2 for+break

for i in range(10):
    if i == 3:
        break
    print(i)#输出0-2

3.3.4.3 for+continue

for i in range(10):
    if i == 3:
        continue
    print(i)#输出0-9除了3

3.3.4.4 for+else

for i in range(10):
    if i == 3:
        break
    print(i)
else:
    print('哈哈哈哈')#输出0-2

3.3.4.5 for循环嵌套

#写出九九乘法表
'''思路：设置2个参数i,j
i=1时，j=1,
i=2时，j=1至2
……
i=9时，j=1至9
'''
for i in range(1,10):
    for j in range(1,i+1):
        print('%s*%s=%s' %(i,j,i*j),end=' ')
    print()#这里表示分行

数据类型内置方法

1.整型

#进制转换
print(bin(10))# 0b1010
print(oct(10))# 0o12
print(hex(10))# 0xa

print(int('0b0101'),2)
print(int('0o12'),8)
print(int('0xa'),16)

2.浮点型

#数据类型转换
s = '12.3'
print(float(s),type(float(s)))
(12.3, <class 'float'>)

3.字符串的内置方法[重点]

#1.数据类型转换
print(str(18))
print(str(18.7))
print(str([3,4,5]))
print(str((3,4,5)))
print(str({'name':'kevin','gender':'male'}))
print(str({3,4,5}))
print(str(True))

#2 strip lstrip rstrip 移除首尾字符串指定字符
s = '  hello '
print(s.strip()) # 括号内不指定字符，默认移除首尾空白字符(空格、\n、\t)
print(s.lstrip()) # 去除的是字符串左边的空格
print(s.rstrip()) # 去除的是字符串右边的空格
print(s.strip('*')) # 括号内指定字符，移除首位指定字符

'''在一般的用户登录程序中，会用到strip(),将用户误打的左右空格去除'''

#3 按索引取值(正向取，反向取)
str = 'hello world'
str[1] # e 正向取(从左往右)
str[-1] # d 反向取(从右往左)
str[0] = 'H' # 报错TypeError

'''对于str来说，只能按照索引取值，不能更改'''

#4 切片(顾头不顾尾，支持步长，切片的时候注意左边数据<右边数据,否则数据为空，不报错)
str[::-1] #-1表示从右往左依次取值，实现的功能是字符串翻转
str[1:] #切取数据从左边索引位置开始一直到末尾
str[:8] #切取数据从开头索引位置一直到索引8之前
str[:] #从头到尾

'''支持正向和反向切片'''

#5 长度len
len(str) # 空格也算字符

#6 成员运算in/not in
'hello' in str # True
'tony' not in str #True

#7 切分split rsplt
str.split() # ['hello','world'] 默认以空格作为切分符号
str.split('.') # 括号内指定分隔字符，按照指定字符切割字符串
str.rsplit('/',2)#从右往左切割，指定切割次数
'''split切割得到的结果是列表数据类型'''

#8 循环
str = '你今天还好吗？'
for i in str: # 依次取出字符串中每一个字符
    print(i)
今
天
你
好
吗
？

#9 lower() upper()
res = 'keViN123 oldGirl'
print(res.lower) # kevin123 oldgirl 转全小写
print(res.upper) # KEVIN123 OLDGIRL 转全大写
#案例：解决图片验证码不区分大小写的问题，常见图片、滑动、短信验证码
#补充：
print(res.islower()) #False
print(res.isupper()) #False

#10 starswith() endswith() 以什么开头 以什么结尾
res = 'keViN123 oldGirl'
print(res.starswith('k')) # True 
print(res.starswith('K')) # False

#11 format格式化输出
#法一
s = 'my name is {}, my age is {}，{}{}{}'
print(s.format('kevin', 20, 'a', 'b', 'c'))
#法二
s = '{0}my name is {1}, my age is {0}{0}{0}{0}{0}, {2}'
print(s.format('tony', 22, 'helloworld'))
#法三
s = '{age}my name is {name}, my age is {age}{name}{name}{name}
print(s.format(name='kevin', age=20))

#12 join 字符串拼接
l = ['tony', 'kevin', 'jack', 'tom']
print('|'.join(l)) # 'tony|kevin|jack|tom'

'''从可迭代对象中取出多个字符串，然后按照指定的分隔符进行拼接，拼接的结果为字符串'''

#13 replace 替换字符串
replace(old_str,new_str,count)
s = 'my name is kevin kevin kevin kevin'
print(s.replace('kevin', 'jack', 2)) #'my name is jack jack kevin kevin'

#14 isdigit 判断字符串是否是纯数字组成，返回结果为True或False
str8 = '5201314'
print(str8.isdigit()) #True

#了解
1.find #从指定范围内查找子字符串的起始索引，找得到则返回数字1，找不到则返回-1
msg='tony say hello'
msg.find('o',1,3)  # 1
2.index #同find,但在找不到时会报错
msg.index('e',2,4) # 报错ValueError
3.count # 统计字符串出现的次数
msg.count('e')  # 1
msg.count('e',1,6)  # 字符串e在索引1~5范围内出现的次数
4.center/rjusr/ljusr/zfill
name.center(30,'-')  # 总宽度为30，字符串居中显示，不够用-填充
name.ljust(30,'*')  # 总宽度为30，字符串左对齐显示，不够用*填充
name.rjust(30,'*')  # 总宽度为30，字符串右对齐显示，不够用*填充
name.zfill(50)  # 总宽度为50，字符串右对齐显示，不够用0填充
6.capitalize/title/swapcase
#capitalize 首字母大写
#title 每个单词的首字母大写
#swapcase 大小写翻转

4.列表的内置方法[重点]

#1 数据类型转换
# print(list(123))  不可
# print(list(1.11)) 不可
print(list('hello')) # ['h', 'e', 'l', 'l', 'o']
print(list([11, 22, 33, 44])) # [11, 22, 33, 44]
print((list({'username':"kevin", "age":20})))  # ['username', 'age']
print(list((11, 22, 33, 44)))  # [11, 22, 33, 44]
print(list({11, 22, 33, 44}))  # [33, 11, 44, 22]

#2 索引存取值 正取向，反取向
my_friends = ['tony','jack','jason',4,5]
my_friends[1] = 'martthow' #['tony', 'martthow', 'jason', 4, 5]
'''对于list来说，既可以按照索引取值，又可以按照索引修改指定位置的值，但如果索引不存在则报错'''

#3 切片 顾头不顾尾，支持步长
my_friends = ['tony', 'jason', 'tom', 4]
my_friends[0:4:2] # ['tony', 'tom']
my_friends[::-1] # 颠倒顺序[法二]

#4 长度
len(my_friends) # 4

#5 成员运算
'tony' in my_friends #True
'xxx' not in my_friends #True

#6 循环
for line in my_friends: # 循环遍历my_friends列表里面的值
	print(line) 
'tony'
'jack'
'jason'
4

#7 增加
my_friends = ['tony', 'jason', 'tom', 4, 5]
#法一
my_friends.append(666) # 追加到末尾位置
my.friend.append([11,22,33]) #把列表的整体添加到末尾
#法二
my_friends.insert(1,999) # 根据索引精确增加
#法三
my.friend.extend([11,22,33]) # 列表的合并

# l = ['kevin', 'jack', 'tom']
# l1 = ['a', 'b', 'c', 'd']
# l.extend(l1)  # for循环+append
# print(l)

# for i in l1:
#     l.append(i)
#
# print(l)

#8 修改
#即2中的索引存值

#9 删除
my_friends = ['tony', 'jason', 'tom', 4, 5, 6, 7, 8]
#法一：
del my_friends[0] # 根据索引删除元素
法二：
aa = my_friends.remove('tony') # 括号中直接写删除的元素,没有返回值
print(aa) # None 空
法三：
my_friends.pop()  # 默认删除列表最后一个元素，并将删除的值返回，括号内可以通过加索引值来指定删除元素
aa = my_friends.pop()
print(aa) # 8

#10 sort()给列表内所有元素排序
l = [11,22,3,42,7,55]
l.sort()  # [3, 7, 11, 22, 42, 55] 从小到大排序 (前提是：纯数字比较)
l.sort(reverse=True)# [55, 42, 22, 11, 7, 3] 从大到小排序(前提是:纯数字比较)[法三]

#11 reverse()颠倒列表内元素顺序[法一]
l = [11,22,33,44]
l.reverse() # [44,33,22,11]

#了解
# 列表比较大小
# l1 = [666,777]
# l2 = [111, 222, 333, 444 ,555, 666]
# print(l1 > l2)  # True  列表的比较是比较索引对应位置的元素值，只要有一个比较出来，都不再往下比较


s1 = 'hello'
s2 = 'world'
print(s1 > s2) # 字符之间的大小取决于它们

5.字典的内置方法

'''
	大括号括起来，内部存放多个元素，元素之间逗号隔开，K:V键值对的形式
		k: 是对V的描述性信息，一般是字符串类型和不可变类型（整数，字符串）
		V: 才是真正的数据值，其实就是变量值，可以是任意的数据类型
'''
# 定义：
	dic = {'username':'kevin', 'age':18}

#1 数据类型转换
info = {'name':'tony', 'age':18}
#转换1
info=dict([['name','tony'],('age',18)])
#转换2，fromkeys会从元组中取出每个值当做key，然后与None组成key:value放到字典中[作初始化操作]
{}.fromkeys(('name','age','sex'),None) #{'age': None, 'sex': None, 'name': None}

#2 按Key存取值
dic = {
    'name': 'xxx',
    'age': 18,
    'hobbies': ['play game', 'basketball']
 }
#1取值
dic['name'] #按key取值，没有则报错
dic.get('name') #按key取值，没有返回None，推荐用这个方法取值
dic.get('name','jack')#若key存在，取原来的值 'xxx'
dic.get('gender','male')#若key不存在，取第二个参数的值 'male'
#2改值
dic['name'] = 'tony'#若kay存在，则修改值
dic['gender'] = 'male'  # 若key原先不存在于字典，则会新增key:value

#3 长度len()
len(dic) # 3

#4 成员运算in/not in
'name' in dic  # 判断某个值是否是字典的key #True

#5 删除
#法一：
del dic['name']
#法二：
dic.pop('name') # 删除指定的key对应的键值对,并返回值,必须加参数

#6 3兄弟 keys() values() items()
data = dic.keys() # 获取字典所有的key,不能直接取，需要for循环
data = dic.values() # 获取字典所有的value,不能直接取，需要for循环
data = dic.items() # 获取字典所有的键值对，返回元组，分别取出k,v有2种方式
dict_items([('name', 'xxx'), ('age', 18), ('hobbies', ['play game', 'basketball'])])	
    #索引取值 
    for i in data:
        print(i[0],i[1])
    #解压赋值
    for k,v in data:
        print(k,v)

#7 popitem()
dic= {'k1':'jason','k2':'Tony','k3':'JY'}
item = dic.popitem()  # 删除最后一组键值对,并将删除的键值放到元组内返回
dic
{'k3': 'JY', 'k2': 'Tony'}
item
('k1', 'jason')

#8 update()
# 用新字典更新旧字典，有则修改，无则添加
dic= {'k1':'jason','k2':'Tony','k3':'JY'}
dic.update({'k1':'JN','k4':'xxx'})
dic
{'k1': 'JN', 'k3': 'JY', 'k2': 'Tony', 'k4': 'xxx'}

#9 循环
1. 默认遍历的是字典的key
for key in dic:
    print(key)
age
hobbies
name
2. 只遍历key
for key in dic.keys():
    print(key)
age
hobbies
name
3. 只遍历value
for value in dic.values():
    print(value)
18
['play game', 'basketball']
xxx
4. 遍历key与value
for key in dic.items():
    print(key)
('age', 18)
('hobbies', ['play game', 'basketball'])
('name', 'xxx')

#了解 setdefault()
# key不存在则新增键值对，并将新增的value返回
dic={'k1':111,'k2':222}
res=dic.setdefault('k3',333)
res
333
dic # 字典中新增了键值对
{'k1': 111, 'k3': 333, 'k2': 222}

# key存在则不做任何修改，并返回已存在key对应的value值
dic={'k1':111,'k2':222}
res=dic.setdefault('k1',666)
res
111
dic # 字典不变
{'k1': 111, 'k2': 222}

6.元组

#1 数据类型转换
# 但凡能被for循环的遍历的数据类型都可以传给tuple()转换成元组类型
# print(tuple(123)) 不可
# print(tuple(123.11)) 不可
print(tuple('hello'))  # ('h', 'e', 'l', 'l', 'o')
print(tuple([11, 22, 33, 44]))  # (11, 22, 33, 44)
print(tuple((1,2,3,4)))   # (1, 2, 3, 4)
print(tuple({'username':'kevin', 'age':19}))   # ('username', 'age')
print(tuple({111,222,33,444}))  # (33, 444, 222, 111)

#2 取值
 tuple1 = (1, 'hhaha', 15000.00, 11, 22, 33) 
print(tuple1[0]) 
tuple1[0] = 'hehe'# 报错：TypeError: 只能取，不能改否则报错！

#3 切片(顾头不顾尾，步长)
tuple1[0:6:2]

#4 长度
len(tuple1) 

#5 成员运算
'hhaha' in tuple1 
'hhaha' not in tuple1

#6 循环
for line in tuple1:
...     print(line)
1
hhaha
15000.0
11
22
33

'''元组笔试题'''
t = (111)
t1 = (111.11)
t2 = ('hello')
t3 = ('hello', )  # 当元组内部哪怕是一个元素，也要加一个逗号隔开，否则就不是元组类型
l = ['hello',]  # list
'''容器类型：可以存放多个元素的数据类型都是容器类型
    推荐：如果是容器类型，内部就算有一个元素，也最后都加上一个逗号隔开
'''
print(type(t)) # <class 'int'>
print(type(t1)) # <class 'float'>
print(type(t2)) # <class 'str'>
print(type(t3)) # <class 'tuple'>
print(type(l)) # <class 'list'>

7.集合类型

"""
	作用：去重、关系运算
	大括号括起来，内部存放多个元素，元素之间逗号隔开，数据类型只能是不可变的类型
	不能直接取值
"""
定义：
	s = {11,22,33,44}
    s = {}
# 如何定义一个空集合
s = {11,22,33,44}
print(type(s))  # set
# 定义空集合
print(type({}))  # dict
s1 = set()
print(type(s1))  # set

d = {}
d1=dict()
l = list()
l = []
print(type(d1))  # dict
print(type(l))  # list

#1 数据类型转换
s = set([1,2,3,4])
print(s)  # {1, 2, 3, 4}
print(set((1,2,3,4)))  # {1, 2, 3, 4}
print(set({'name':'jason','age':20}))  # {'name', 'age'}
print(set('hello'))  # {'e', 'o', 'l', 'h'}

#2 关系运算
friends1 = {"zero","kevin","jason","egon"} # 用户1的好友们 
friends2 = {"Jy","ricky","jason","egon"} 
# 1.合集/并集(|)：求两个用户所有的好友（重复好友只留一个）
friends1 | friends2 
# 2.交集(&)：求两个用户的共同好友
friends1 & friends2
# 3.差集(-)：
friends1 - friends2 # 求用户1独有的好友
friends2 - friends1 # 求用户2独有的好友
# 4.对称差集(^) # 求两个用户独有的好友们（即去掉共有的好友）
friends1 ^ friends2

#3 去重
l=['a','b',1,'a','a']
s=set(l)
s # 将列表转成了集合 {'b', 'a', 1}
l_new=list(s) # 再将集合转回列表
l_new # ['b', 'a', 1] # 去除了重复，但是打乱了顺序

#4 长度len() 成员运算 循环

8.可变类型与不可变类型

"""
	可变类型：列表
		值改变，内存地址没有改变
	不可变类型：整型 浮点型 字符串
		值改变，内存地址也改变
"""