Python学习笔记_python中inrange

Python学习笔记

python语言基础

变量

变量名规范：
1.只能由字母，数字，下划线组成
2.不能数字开头
3.不能用Python内置关键之命名

数据类型

int      整形
float    浮点型
str      字符串
bool     布尔型
tuple    元组
list     列表
set      集合
dict     字典
1
2
3
4
5
6
7
8

格式化

%s 格式化输出字符串
%f 格式化输出浮点型
%d 格式化输出有符号的十进制整数
1
2
3

输入

input() 输入 接受用户输入的信息
语法: input(“提示信息”)
特点:

1. 控制台遇到input后会处于冻结状态,等待用户输入信息后,程序继续运行
2. input输入的内容一般会赋值给变量

eval 提取变量值的数据类型
a='0.1'
eval(a) 运行后a不再是字符型。而变成了浮点型
1
2
3

语法结构

单分支选择结构

语法:
if 条件:
条件 True False
执行语句

一定要注意缩进！！！！

age = 13
if age > 18:
    # 只有满足if条件才会输出以下三个输出语句,不满足的话只会输出最后一个输出语句
    print("你已经成年了,可以上网")
    print("欢迎光临")
    # 一个单独的输出语句,不牵扯if语句,无论满不满足if条件，都会输出
print("您的年龄不够")
1
2
3
4
5
6
7

双分支选择结构

if 条件表达式:
代码块1
else:
代码块2

age = int(input("请输入你的年龄:"))
if age > 18:
    print(f"你的年龄是{age}岁,你已经成年了")
    print("欢迎光临")
else:
    print(f"你的年龄是{age},你还未成年")
    print("想上网请联系网管")
print("系统关闭~")
1
2
3
4
5
6
7
8

多分支选择结构

if (条件表达式1):
代码块1
elif (条件表达式2):
代码块2
else(条件表达式3):
代码块3

grade = eval(input("请输入你的分数:\n"))
if 100 >= grade >= 60:
    print(f"你的成绩是{grade},及格了")
    print("奖励一颗巧克力")
elif grade >= 0:
    print(f"你的成绩是{grade},你的成绩不及格")
    print("提桶进厂吧")
else:
    print("你小子不对劲")
1
2
3
4
5
6
7
8
9

for循环

for 循环变量 in range():
循环体

 for i in range(0, 10, 2):
     # 0是初始值,可以不写,默认值为0. 10是结束值,但是输出的结果不包括10, 2是步数,就好比我一步走两个数,就是求2的倍数
     print(i)

 b = 0;
 for i in range(101): # range 取的是整数
     if i % 2 == 0:
         b += i
print(f"1~100的偶数和是{b}")
1
2
3
4
5
6
7
8
9

break和continue

break 跳出循环 结束整个循环
continue 跳出本次循环 继续下次循环

for i in range(1, 6):
    if i == 3:
        # break   # 输出到3结束循环
        continue  # 跳过数字3继续下次循环
    print(i)
1
2
3
4
5

while else和for else

for … else:
else内的语句是循环正常结束后执行的语句
如果循环是使用brake结束的,else内的语句将不再被执行
while … else:
else内的语句是循环正常结束后执行的语句
如果循环是使用brake结束的,else内的语句将不再被执行

for i in range(1, 5):
    print(i)
else:
    print("循环结束")   # 循环正常结束会运行else里的内容
print("诶嘿嘿")
1
2
3
4
5

数据结构

初始字符串

定义单行字符串   ''  ""
''' '''  """ """    定义多行字符串 \n \t也能正常输出
1
2

字符串的索引和切片

str1 = 'abcdefg'
#   下标又叫索引  从0开始顺序编号
#   格式：[下标]     下标可以是正数也可以是负数
print(str1[0])      # a
print(str1[-4])     # d
#   切片  [开始下标(包含)：结束下标(不包含)：步长]
print(str1[0:3:1])  # abc
print(str1[0:3:2])  # ac
print(str1[0:3])    # 步长可省 默认为1
print(str1[:3])     # 开始下标可以省略，默认从0开始
print(str1[1:])     # 结束下标也可以省略，默认到结束为止
print(str1[::-1])   # str1[::-1]倒序输出
# 字符串是一个不可变的，无法进行增删改的操作
1
2
3
4
5
6
7
8
9
10
11
12
13

案列

'''
货币转换：人民币￥和美元$的转换
用户输入需要转换的金额和货币符号，以￥或$结束
如果用户输入的是美元，转换为人民币 汇率6.382
如果用户输入的是人民币，转换为美元 汇率是0.1567
如果用户输入的没有符号，提示报错，重新输入
最终结果保留两位小数
'''
while True:
    money = input('请输入需要转换的金额和货币符号，以￥或$结束：')
    if money[-1] == '$':
        USD = eval(money[0:-1])
        money1 = USD * 6.382
        print(f'您输入的金额为{USD}, 转换后的金额为{money1:.2f}')
        break
    elif money[-1] == '￥':
        RMB = eval(money[0:-1])
        money2 = RMB * 0.1567
        print(f'您输入的金额为{RMB}, 转换后的金额为{money2:.2f}')
        break
    else:
        print('您输入的格式错误，请重新输入!')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

字符串的增删改

str1 = 'hello,python'
# find('子串',开始下标,结束下标)  查找下标
# find找的是第一个下标、返回的是第一个子串下标，找不到返回-1
# print(str1.find('y'))                  # 查找y的下标
# print(str1.find('o'))                 # 查找o的下标、返回的是第一个子串的下标
# print(str1.find('o', 5, 11))            # 开始包含、结束不包含
# print(str1.rfind('l'))                  # 默认从右边开始查找
# index() 查找
# index('子串',开始下标,结束下标)  查找
# print(str1.index('a'))      # 返回是第一个子串的下标，找不到报错
# count() 统计子串的个数,如果不存在返回0
# count('子串',开始下标,结束下标)
print(str1.count('y'))
1
2
3
4
5
6
7
8
9
10
11
12
13

字符串的替换

# replacer('旧子串','新子串')
str1 = 'hello python'
# 把python 替换成world
str2 = str1.replace('python', 'world')
print(str1)
print(str2)
1
2
3
4
5
6

字符串的方法

# split('分隔符')  把一个字符串分割成多个对象
# 多个对象使用列表储存
'''
str1 = 'hello,python'
print(str1.split(','))
'''
# strip()   去除字符串前后的符号，多用来去除空格
'''
str2 = '==hello=='
print(str2)
print(str2.strip(''))   # 去除空格的
print(str2.strip('='))
print(str2.strip('=').strip(','))   # 去除左右不一样的符号
'''
# str.join(stp) 是把str加入到stp里面
# stp可以是字符串也可以是列表
'''str3 = 'hello'
li1 = ['h', 'e', 'l', 'l', 'o']
print(','.join(str3))
print(''.join(li1))'''
# lower() 全部转换为小写
'''str4 = 'JJHJHKJDSDSD'
print(str4.lower())'''
# upper() 全部转换为大写
'''str5 = 'adsddddfds'
print(str5.upper())'''
# title()  首字母大写
'''str6 = 'hello,python'
print(str6.title())'''
# len(字符串名) 获取字符串的长度
'''str7 = 'aaaaaaaaaaaaaaaaaaa'
print(len(str7))'''
# max(字符串名) 取最大值  按26字母
'''str8 = 'abcdefgABCDEFG'
print(max(str8))'''  # g
# min(字符串名) 取最小值
'''print(min(str8))'''  # A
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

元组

初始元组

tuple() 强制转换为元组
1

元组的索引和切片

元组[下标] 可以为正数也可以为负数

切片[开始:结束:步长] 包含开始 不包含结束

元组是不可变的数据类型 但是如果元组内放的是列表这类可变的数据类型 可以更改列表内的数据

元组的查找

index() 返回第一个匹配元素的下标 找不到会报错

count() 返回匹配元素的个数

列表

初始列表

定义列表      列表里面可以存放所有的数据类型
定义空列表 []  list()  两种定义空列表形式
定义有数据的列表  [数据1, 数据2, 数据n]     list(数据)   两种定义有数据的列表
list() 把其他类型转换成列表
1
2
3
4

len() 返回列表的长度

max() 返回最大值

min() 返回最小值

列表的索引和切片

下标，从0开始顺序分配一个下标
列表名[下标] 下标可以为正数可以为负数

列表是可变的数据类型，可以进行增、删、改、查的操作

列表的增加

append()  追加数据到列表的最后面
语法：列表名.append(数据)

extend()  追加数据到列表的最后面

insert(下标, 数据)  将数据插入到固定的位置
1
2
3
4
5
6

列表的查找

index() 返回查找的第一个数据的下标
count() 统计数据的个数
1
2

列表的删除

del 删除    公共方法  删除所有的数据类型
del 变量名
del 列表名[下标]  删除固定下标的元素
1
2
3

pop() 删除      列表名.pop(下标)		删除固定下标的元素，并返回该元素的值
pop()如果不写下标则删除最后一个元素
1
2

remove() 删除   移除匹配的第一个元素
1

sort()    排序的，默认从小到大      reverse=False   默认值 从小到大
reverse()     倒序输出
1
2

字典

初始字典

dict 字典
{key1:value1, key2:value2}
key值是唯一的，如果key重复，输出最后一个
{} 定义空字典
1
2
3
4

dict() 工厂函数
dict创建空字典
1
2

dict()创建有key-value字典
key不能加引号
1
2

zip() 把多个数据进行合并   以最少的元素进行合并
1

fromkeys(keys,value) 如果value省略，输入none
定义一个字典key不同，value相同的字典
1
2

字典的新增

# 字典是可变的数据类型
dict1 = {'name': '阿达', 'age': 20}
'''
print(dict1[0])         # 字典不支持下标和切片
print(dict1['name'])    # 可以使用key去返回value
'''
# 字典名[key] = value  增加一个key-value
'''
dict1['name'] = '阿飞'     # 如果key存在，修改value值
dict1['height'] = '183cm'   # 如果key不存在，则增加一个key-value
print(dict1)
'''
# 字典名.update()      增加多个key-value
'''
dict2 = {'width': 140, 'hobby': '玩手机'}
dict1.update(dict2)
print(dict1)
'''
# setdefault(key, value)      增加一个key-value
'''
dict1.setdefault('girlfriend', 'lili')  # 如果key不存在，则增加一个key-value
dict1.setdefault('width', '150')      # 如果key存在，不能修改value值
print(dict1)
'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

字典的删除

del 字典名  删除整个字典
字典名.pop(key) 删除key-value，并返回value
popitem()     删除最后一个key-value
clear() 清空字典
1
2
3
4

字典的查找

字典名[key] 返回该key的value
字典名.get(key) 返回该key的value
keys() 返回所有的key
values() 返回所有的value
items() 返回所有的key-value
1
2
3
4
5

集合

初始集合

set{元素1，元素2，元素n}
集合有自动去重的功能
{}定义空字典，不能定义空集合
set()强制转换成集合
集合是无序的，无法索引(下标)和切片,也不能连接，也不能查，也不能统计
1
2
3
4
5

集合的删除和增加

add() 新增  一次增加一个数据
update()  新增  增加多个数据，可以是列表，元组，集合
pop() 删除
remove()  删除  删除固定的值
sorted() 排序   默认从小到大
copy() 复制
1
2
3
4
5
6

学生管理系统

student = []
# str.center(40, '*')   让文字居中显示 使str的长度变为40，不足的补*
print('欢迎进入学生管理系统'.center(30, '='))
while True:
    print('''请输入序号选择相应的功能：
        1、新增学生信息
        2、删除学生信息
        3、修改学生信息
        4、查询学生信息
        5、查询所有学生
        6、退出当前系统''')
    num = input('请输入功能对应的序号：')
    if num == '1':              # 新增学生信息
        '''
        1.学生信息：班级100，年龄21，学号1000，性别，姓名
        学生信息以字典存储
        2.判断学号是否存在：学号是唯一的
        如果学号存在：无法添加该学生的信息
        如果学号不存在，把学生信息追加到student列表里append()
        '''
        print('新增学生信息界面'.center(30, '-'))
        new_class = input('请输入学生的班级：')
        new_age = input('请输入学生的年龄：')
        new_id = input('请输入学生的学号：')
        new_name = input('请输入学生的姓名：')
        stu_dict = {}           # 空字典接收学生信息
        for i in student:
            if new_id == i.get('id'):
                print('学生已经存在')
            else:
                stu_dict['class'] = new_class
                stu_dict['age'] = new_age
                stu_dict['id'] = new_id
                stu_dict['name'] = new_name
                student.append(stu_dict)
                print(student)
    elif num == '2':
        '''
        需求分析：
        1.根据学号进行删除
        2.如果学号存在，把该学生删除
        3.如果学号不存在，无法删除
        '''
        print('删除学生信息界面'.center(30, '-'))
        del_id = input('请输入需要删除学生的学号：')
        # for...else
        #
        for i in student:
            if del_id == i['id']:
                student.remove(i)
                break
        else:
                print('该学号不存在，请确定后再删除')
        print(student)
    elif num == '3':
        print('修改学生信息'.center(30, '*'))
        """
        根据学号修改学生信息：
        1.输入学号
        2.判断学号是否存在  2-1 存在，修改信息     2—2 不存在，查无此人
        """
        modify_id = input('请输入需要修改学生的学号：')
        for i in student:
            if modify_id == i.get('id'):
                i['class'] = input('请输入新的班级：')
                i['age'] = input('请输入新的年龄：')
                i['name'] = input('请输入新的名字：')
                break
        else:
            print('查无此人')
    elif num == '4':
        print('查询学生信息'.center(30, '*'))
        query_id = input('请输入需要查询学生的学号：')
        for i in student:
            if query_id == i['id']:
                print(f'班级是{i["class"]}, 学号是{i["id"]}, 年龄是{i["age"]}, 姓名是{i["age"]}')
                break
        else:
            print('查无此人')
    elif num == '5':
        print('查询所有学生'.center(30, '*'))
        print('班级\t年龄\t学号\t姓名')
        for i in student:
            print(i["class"], i["age"], i['id'], i['name'])
    elif num == '6':
        ty = input('是否退出当前系统(输入 y or n)：')
        if ty == 'y':
            break               # break 结束整个循环
        else:
            continue            # continue 结束当前循环，继续下一次
    else:
        print('输入序号有误，请重新输入：')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

推导式（生成式）

# 推导式（生成式） 简化代码
# 语法:变量 for 变量 in 范围
# 列表推导式[变量 for 变量 in 范围]
# [0，1，2，3，4，5，6，7，8，9]
li1 = []
for i in range(10):
    li1.append(i)
print(li1)
li2 = [i for i in range(10)]
print(li2)
li3 = [1, 2, 1.1, 'a', 20.4, 'jj', 8]
# [变量 for 变量 in 范围 if 条件]
li4 = [i for i in li3 if type(i) == int]
print(li4)
str1 = 'ABC'
str2 = '123'
print([i+j for i in str1 for j in str2])
# 字典推导式{key:value}
print({i: j for i in str1 for j in str2})
# 生成一个字典，键是1，2，3，4，5 值是他们的平方
print({i: i**2 for i in range(1, 6)})
# 集合推导式{}
l1 = [1, 2, 3, 1, 2, 3, 4, 5, 6]
# 把l1内的每个元素的平方放到集合里
print({i**2 for i in l1})       # 集合是无序的，自动去重
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

函数

函数的定义和使用

函数的作用是为了更高效的实现代码的复用，提高代码的一致性
函数的定义：
def 函数名(参数列表):
    """说明文档(注释)一般放到第一行"""
    函数体(代码)
调用函数: 函数名(参数)
注意事项：1、不同的需求，参数可有可无
2、在python中，函数必须先定义再使用
3、函数必须要调用后才能使用
1
2
3
4
5
6
7
8
9

函数的参数

函数的参数：是为了使函数变得更加灵活
形参：定义函数时，同时定义了结束数据的参数
实参：调用函数时，传递的真实数据
1
2
3

函数的返回值

return 返回值，返回一个值给调用函数的地方
return:
1. 如果没有return，会返回一个None
2. return代表结束当前函数，return下方的语句不会被执行
3. 如果想要返回多个值，直接在return后面写多个值，多个值以元组的形式返回给调用函数的对象
4. 返回值可以是任意的数据类型
5. 返回值可以赋值给变量，也能当成一个实参传递给下一个函数
1
2
3
4
5
6
7

函数的参数进阶

# 位置参数  根据参数的位置进行传递     参数的位置和个数都是固定的
def test01(name, age, sex):
    print(f'姓名是{name}，年龄是{age}岁，性别是{sex}')
test01('聪儿', 1, '未知')
# 关键字参数  以“键=值”的形式进行传递
test01(name='阿甘', age=21, sex='男')
test01(age=21, sex='男', name='阿甘')     # 参数的顺序不影响输出结果，比位置参数更灵活
# 缺省参数，默认参数  传递参数的过程中，默认参数可以不传实参    默认参数必须要在参数列表的最后面
def test02(name, age, sex='男'):
    print(f'姓名是{name}，年龄是{age}，性别是{sex}')
test02('阿达', 19)
test02('阿萨', 28, '女')
# 不定长参数（不确定长度）
# 1.包裹位置参数 *args  以元组的形式传递参数
def test03(*args):              # test03(*aaa)参数名任意
    sum = 0
    for i in args:
        #sum = sum + i
        sum += i
    print(sum)
test03(10, 34, 45, 76, 99)
test03(100, 999999)
def test04(a, b, *args):
    print(args, a, b)
test04(1, 2, 3, 4, 5, 6, 7)
# 2.包裹关键字参数 **kwargs
def test05(**kwargs):
    for i in kwargs:
        print(i)
test05(name='阿卡', age=19, sex='男')
# 定义函数。输出列表里最大值，和最小值
def test06(*args):
    args = list(args)
    a = max(args)
    b = min(args)
    print(f"您输入的数最大值是{a},最小值是{b}")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

函数的变量作用域

# 变量作用域：变量起作用的区域
# 局部变量：在函数内定义的变量，起作用的区域是函数内，一旦函数执行完毕，这个变量就会被销毁
def test01():
    a = 10
    print(a)
test01()
# print(a)    # a 是局部变量，在函数外调用会报错
# 全局变量：在函数内外都能用的变量
b = 3
def test02():
    global b    # 声明b是全局变量
    b = 10
    print(id(b))
    print(b)
test02()
print(f'全局 变量的值为{b}')
print(id(b))
# 局部变量的速度比全局变量速度快，在使用的过程中优化使用局部变量
# 测试局部变量和全局变量
# import math as m        # 给math起名为m
import math
import time
qj = math.sqrt
def quanju():
    start = time.time()
    for i in range(10000000):
        qj(199)
    end = time.time()
    print(f'全局变量的执行时间{end-start}')
def jubu():
    jb = math.sqrt
    start = time.time()
    for i in range(10000000):
        jb(199)
    end = time.time()
    print(f'局部变量的执行时间{end-start}')
quanju()
jubu()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38