浅尝python 二

一、 逻辑控制语句

1、if判断语句

demo1

1 定义score 变量记录考试分数
2 如果分数是 >=90分 显示优
3 >=80 & <90 显示良
4 >=70 & <80 中
5 >=60 & <70 差
6 其他 不及格

score = float(input('录入考试分数'))
if score >= 90:
    print("优")
elif score >= 80:
    print('良')
elif score >= 70:
    print('中')
elif score >= 60:
    print('差')
else:
    print('不及格')

demo2

取款机取钱的过程：密码：123456 ，账户余额为1000
提示输入密码
密码正确提示输入取款金额
判断取款的金额和余额的关系

pwd = int(input("输入密码"))
if pwd == 123456:
    cash = float(input("本次取款金额"))
    if cash <= 1000:
        print('取款成功')
    else:
        print('余额不足')
else:
    print('密码不正确')

demo3 逻辑控制+随机数

从控制台输入划拳手势 石头（1）/剪刀（2）/布（3）
电脑随机出拳 – 先假定电脑只会出石头，完成整体代码功能
比较胜负
steps
玩家划拳手势 （石头（1）剪刀（2）布（3））
电脑随机出拳
判断胜负

import random

rand_num = random.randint(1, 3)
huaquan = int(input('写入划拳手势'))
if (rand_num == 1 and huaquan == 2) or (rand_num == 2 and huaquan == 3) or (rand_num == 3 and huaquan == 1):
    print(f'很遗憾你输了,电脑出{rand_num},你出{huaquan}')
elif rand_num == huaquan:
    print(f'平局,电脑出{rand_num},你出{huaquan}')
else:
    print(f'恭喜你赢了,电脑出{rand_num},你出{huaquan}')

demo4

输入年份是否为闰年 条件： 能被4整除但不能被100整除 或者 能被400整除 即可判定为闰年

inputYear = int(input("请输入年份"))
if (inputYear % 4 == 0 and inputYear % 100 != 0) or inputYear % 400 == 0:
    print(f'当前输入年份 {inputYear}为闰年')
else:
    print(f'当前输入年份 {inputYear}不是闰年')

其他

下面是其他练习，想巩固基础的宝贝儿可以搞下：

1 定义一个整数变量记录年龄，判断是否满18岁（>=），如果满18岁，允许进网吧嗨皮

2 获取用户输入的用户名信息
如果用户名信息是admin ，就在控制台输出

3 定义两个整数变量python_score、c_score ,使用input获取成绩，编写代码判断成绩
只要有一门成绩 >60 分就输出合格

4 获取用户输入用户名，判断用户名是admin时，在控制台输出：欢迎admin登录
用户名是test时，在控制台输出：欢迎test登录，如果是其他信息，在控制台输出：查无此人！

执行后从控制台输入年龄后，会根据判断条件输出对应内容

2、while 循环语句

demo1

老爸把老妈惹生气了，说100遍 “老婆我错了”

i = 0
while i < 100:
    i += 1
    print(f'老婆我错了{i}')
print('终止循环')

demo2 累加：0+1+2+3+… +100 的结果

i = int(0)
sum = int(0)
while i < 100:
    i += 1
    sum += i
print(sum)

demo3 多次完划拳

规则：从控制台输入划拳手势 石头（1）/剪刀（2）/布（3）
电脑随机出拳 – 先假定电脑只会出石头，完成整体代码功能
比较胜负
steps
玩家划拳手势 （石头（1）剪刀（2）布（3））
电脑随机出拳
判断胜负

import random

while True:
    rand_num = random.randint(1, 3)
    huaquan = int(input('写入划拳手势 1：石头，2:剪刀 ，3:布 ，0 ：退出'))
    if huaquan == 0:
        print('欢迎下次来玩')
        break
    elif (rand_num == 1 and huaquan == 2) or (rand_num == 2 and huaquan == 3) or (rand_num == 3 and huaquan == 1):
        print(f'很遗憾你输了,电脑出{rand_num},你出{huaquan}')
    elif rand_num == huaquan:
        print(f'平局,电脑出{rand_num},你出{huaquan}')
    elif huaquan > 3 or huaquan < 1:
        print(f'输入错误，请重新输入,电脑出{rand_num},你出{huaquan}')
        continue
    else:
        print(f'恭喜你赢了,电脑出{rand_num},你出{huaquan}')

3、for循环

demo1 累加：0+1+2+3+… +100 的结果

sum = 0
for i in range(101):
    sum += i
print(sum)

demo2 循环次数由容器中数据的个数决定

每次循环从容器中取出一个数据保存到变量中
容器中数据取完，遍历结果（即循环结束）

for i in 'hello':
    print(f'所以你会一直幸福下去   {i}')

demo3 for循环可以指定循环次数

for n in range(3):
    print('最近天气很热')

二、常见数据类型操作

1、字符串的操作

常见字符串的定义

str1 = '嗷呜！'  # 单引号
str2 = "嗷呜！"  # 双引号
str3 = """嗷呜！"""  # 三双引号
str4 = '''嗷呜！'''  # 三单引号

字符串本身包含单引号，定义的时候，不能使用单引号定义，使用双引号定义
字符串本身包含双引号，定义的时候，不能使用双引号定义，使用单引或者三引号定义

demo 1

str1 = '''i'm  tom'''  # 输出：i'm  tom
print(str1)

demo2 :转义字符 ’ ’ " 转义后 为 "

str2 = 'i\'m  tom'  # 输出：i'm  tom
print(str2)

demo3:字符串本身包含(斜杠和单引) \ ’ ， i’m tom ，\ 转义后为\

str3 = ' i\\\'m  tom '  # 输出 i\'m  tom
print(str3)

demo4:原生字符串，字符串前边加上 r"" , 表示字符串中的内容不会进行转义。

一般用在windows的路径中，也可直接用于html语句文本

str4 = r"i\'m  tom"  # 输出：i\'m  tom
print(str4)
str5 = r"i\\\'m  tom"  # 输出：i\\\'m  tom
print(str5)

1.1、索引和下标

索引（下标）是数据在容器中的位置编号，对于字符串来说，就是字符在整个字符串中的位置。
1 一般情况下，使用的都是正数索引（从左到右），从0开始
2、python 中支持负数索引（从右到左），-1表示容器中最后一个数据
3、使用索引（下标）可以获取容器中指定位置的数据
4、下标是整数数字
str6 = ‘abcdefg’

• 打印输出字符串中第一个字符

print(str6[0])  # 输出：a

• 打印输出字符串中最后一个字符

print(str6[-1])  # 输出：g

• 获取下标为3的位置和数据

print(str6[3])  # 输出：d
print(str6[30])  # 输出：数组下标越界 下面是输出内容

Traceback (most recent call last):
  File "/Users/gina/FeiHe/SourceCode/python_base1/python_2.py", line 14, in <module>
    print(str6[30])  # 输出：数组下标越界
IndexError: string index out of range

1.2、字符串遍历

分别使用for 循环和while循环对字符串进行便利（即从字符串中取出每个字符进行打印）

str7 = 'bcdefgh'

for i in str7:
    print(i, end='  ')
print('\n', 'for-----------end')
i = 0
a = str7[0]

while i < len(str7):
    a = str7[i]
    i += 1
    print(a, end='  ')
print('\n', 'while-----------end')

print('xx¥@--' * 30)  # 输出 30个xx¥@--

1.3、切片

1 使用下标（索引）可以获取字符串中指定位置的一个字符
2 使用切片可以获取字符中 多个字符

• 字符串 （start：end：step）
• start ：开始位置的下标，从哪个位置开始取字符
• end：结束位置下标，取到哪结束（end的数据不能取到）[ start,end)就是小时候数学里的前闭后开
• step：步长，所取字符串中相邻两个数据下标之间的间隔
  所取数据对应的下标分别为：
  start ，start+step ，start+step+step ，start+step +step +step

str7 = 'abcdefg'

# 1 取出字符串中 abc
print(str7[0:3:1])  # 输出 abc

# 1.1如果步长1，可以不写
print(str7[0:3])  # 输出 abc

# 1.2如果步长为整数（>0），开始位置为0，可以不写 ,截取前几位
print(str7[:3])  # 输出 abc

# 2 取出字符串efg ，下标从0开始
print(str7[4:7])

# 2.1结束位置是字符串的长度（最后一个数据要取到），可以不写
print(str7[4:])  # 输出efg
print(str7[:])  # 输出全部。从0开始取到最后一个字符，步长1 输出abcdefg
print(str7[::2])  # 步长为2，输出全部。从0 开始，取到最后，步长2 输出：aceg
print(str7[1:-1:3])  # 所取下标为（1,4），输出：b ，e
print(str7[:-1:2])  # 所取下标为 （0，2，4） a，c，e 

# 特殊情况，步长为负数，表示从右向左获取数据，一般用法：字符串的反转，倒置
print(str7[::-1])

1.4、字符串查找方法

print('abc'.find('a'))  # 存在返回第一次出现的下标，如果有多个也只会返回第一个，不存在返回-1 ，输出 0

# 现有字符串数据'你好哇咔咔，好困好困'
str = '你好哇咔咔，好困好困'
# 判断 输入咔或困是否存在于数据中
name = input('输入咔或困是否存在于数据中')
# 如果数据存在，则输出数据所在的位置
if name == '咔' or name == '困':
    print(str.find(name))
print(str)

1.5、 字符串替换方法

# g 换为G ，如果不做指定，默认全量替换
str = 'g g stu ,d d up'
print(str.replace('g', 'G'))  # 输出：G G stu ,d d up
print(str)  # 输出：g g stu ,d d up
# 第一个g换为G ，指定替换个数，默认从左侧开始替换
print(str.replace('g', 'G', 1))  # 输出：G G stu ,d d up
# 第二个g替换为G
print(str.replace('g', 'G', 2).replace('G', 'g', 1))

1.6、 字符串拆分和连接

• 拆分

str1 = 'hello python\tand\init and theam'
# 1、默认按空格为间隔符来拆分字符串 str.split() == str.split(' ')
rs = str1.split()  # 输出：['hello', 'python', 'and\\init', 'and', 'theam']
print(rs)
rs = str1.split(' ')  # 输出：['hello', 'python', 'and\\init', 'and', 'theam']
print(rs)
# 2、按照and 进行拆分
rs = str1.split('and')
print(rs)
str1 = 'hello pythontandinit and theam'
rs = str1.split('and')
print(rs)

• 连接
  字符串.json（容器）; 容器一般使用的都是列表，通过指定字符串将列表中的内容连一起，得到一个新的字符串

# ps：容器（列表）中的数据必须都是字符串类型
my_list = ['hello python', 'init ', ' theam']
# 用空格把列表内容连成一个字符串
str1 = ' '.join(my_list)
print(str1)
# 用逗号把列表中内容连成一个字符串
str2 = ','.join(my_list)
print(str2)

2、列表操作

2.1、定义列表

• 方式1：name_list=[] , name_list=["tom","jack","lily"] 用[]定义，数据之间使用英文逗号分隔

my_list2 = []
print(my_list2)
my_list2 = ['hello', '小强']
print(my_list2, len(my_list2))
输出：
[]
['hello', '小强'] 2

• 方式2：通过类实例化方式定义：data_list=list()

my_list = list();
print(my_list, type(my_list))
my_list = list('hello');
print(my_list, len(my_list))
输出
[] <class 'list'>
['h', 'e', 'l', 'l', 'o'] 5

2.2、列表支持下标和切片

my_list = ['小明', 18, 1.81, True]
print(my_list[0])  # 取出第一个数据
print(my_list[-1])  # 取出最后一个数据
print(my_list[:2])  # 取出前两个数据，切片得到的是一个新的列表
输出：

小明
True
['小明', 18]

2.3、列表的查询

2.3.1、列表的遍历

for i in my_list:
    print(i, end=' ')

i = 0
while i < len(my_list):
    print(my_list[i], end=' ')
    i += 1

2.3.2、列表数量

统计目标数据在列表中出现的次数：列表.count(目标数据) 如果目标数据不存在则返回0

my_list = [1, 3, 2, 3, 1, 'hello']
print(my_list.count('hello'))  # 1
print(my_list.count(1))  # 2
print(my_list.count(5))  # 0

输出：
1
2
0

2.4、列表增删改操作

2.4.1、增加元素

• demo1：
  列表.append(), 对原列表产生作用。
  局限：一次只能添加一个数据

my_list = []
my_list.append('tom')
print(my_list)
my_list.append('jimi')
my_list.append('lily')
print(my_list)
输出：

['tom']
['tom', 'jimi', 'lily']

• 增加 demo2

import random
# 使用随机数 向列表添加10个 1-20之间的随机数
my_list2 = []
for i in range(10):
    my_list2.append(random.randint(1, 20))
print(f'列表元素：{my_list2}')

2.4.2、删除元素：

my_list=['tom', 'jimi', 'lily']
# 删除列表中最后一个数据，返回删除的数据，作用于原列表
rs = my_list.pop()  # 
print(f'{my_list},删除的数据为{rs}')
输出：

['tom', 'jimi'],删除的数据为lily

2.4.3、修改元素：

my_list=['tom', 'jimi', 'lily']
my_list[0] = 'jerry'
print(my_list)
# 修改第一个数据为8
my_list[0] = 8
print(my_list)
# 再次统计 数据8出现的次数
print(my_list.count(8))

输出：
['jerry', 'jimi', 'lily']
[8, 'jimi', 'lily']
1

2.5、列表反转

• m1:不会修改原列表，得到一个新列表 列表[::-1] ;

my_list = [1, 3, 2]
print(my_list)
my_list = my_list[::-1]  # 切片进行的反转，原列表不会发生改变
print(my_list)
输出：
[1, 3, 2]
[2, 3, 1]

• m2:直接修改原列表：列表.reverse（）

my_list = [1, 3, 2]
my_list.reverse()  # 切片进行的反转，原列表发生改变
print(my_list)
输出：
[2, 3, 1]

2.6、列表排序

• 列表排序
  一般是对列表中数字进行排序，即相同类型进行排序,列表值会改变 ，升序：列表.sort() ,降序：列表.sort（reverse=True）

my_list2 = [1, 4, 3, 5]
print(my_list2)
my_list2.sort()
print(my_list2)
my_list2.sort(reverse=True)
print(my_list2)
输出：
[1, 4, 3, 5]
[1, 3, 4, 5]
[5, 4, 3, 1]

2.7、列表的嵌套

my_list = [['张三', '18', '黑盒测试'], ['丽萨', '28', '接口测试']]
# 打印第一个人的名字和年龄
print(my_list[0][:2])
# 最后一个人的名字
print(my_list[-1][0])

# 打印每个人的名字，年龄和工作：通过for循环来做
for i in my_list:
    print(f'for循环来做：{i}')
# 打印每个人的名字，年龄和工作 这种方式显然更轻量简洁
print(f'列表嵌套+切片 ：{my_list[::][::]}')
输出：

['张三', '18']
丽萨
for循环来做：['张三', '18', '黑盒测试']
for循环来做：['丽萨', '28', '接口测试']
列表嵌套+切片 ：[['张三', '18', '黑盒测试'], ['丽萨', '28', '接口测试']]

2.8、列表去重

集合set，表现形式{数据，数据，数据}
先将列表转换为 集合类型，再将集合转换为列表类型
in/not in 可以判断数据是否存在容器中，对于字典来说，判断的是 键（key）是否存在

my_list = [1, 2, 3,  2, 'a', 'a', 'c']
my_list = list(set(my_list))
print(my_list)
输出【set后为乱序，不能保证原数据顺序】：
[1, 2, 3, 'a', 'c']

if 3 in my_list:
    print('存在')
else:
    print('不存在')
输出：
存在

数据 in 容器 ，判断数据是否存在，若存在，返回true ，若不存在返回false
数据 not in 容器，判断数据是否不存在，如果不存在则返回true ，若数据存在则返回false