python基础

Python语言和开发环境

一、Python语言概述

Python（蟒蛇）是一种叫解释型，面向对象，动态数据类型的高级程序设计语言。由吉多-范-罗萨姆于1989年研发出来的，1991年发布了第一个版本。

Python语言特点：

1. 免费自由的软件
2. 良好的跨平台性（win\Linux\Mac）
3. 强大功能和扩展性强
4. ......

Python应用领域：

1. 自动驾驶
2. 谷歌搜索引擎
3. 网易游戏服务器
4. 豆瓣网主体架构
5. 教育行业....

问题1：为什么学习开发语言（Python）？

1. 了解开发原理，可以更好的发现缺陷
2. 方便和开发沟通
3. 自动化测试
4. 面试要求
5. ......

1. 开发环境

Python + PyCharm + Git(管理开发版本)+ MySQL + Linux(Docker)+ HTML(Vue) +…

开发分为前端和后端，前端管界面，Python属后端

1. Python的安装和调试

1. 地址：Python Releases for Windows | Python.org
2. 安装：
3. 调试：win + R --> cmd --> python -->  >>>

1. PyCharm的安装和调试

1. 地址：http://www.jetbrains.com/pycharm/
2. 安装
3. 调试：这个按照个人的爱好更改就可以，比如英语掌握的好就可以不需要汉化。

• 汉化：文件(file) -> 设置(settings) -> 插件 -> 汉
• 主题：文件(file) -> 设置(settings) -> 外观和行为 -> 外观 -> 主题
• 字体：文件(file) -> 设置(settings) -> 编辑器 -> 字体

1. Git的安装和调试

1. 地址：http://git-scm.com/
2. 安装：
3. 调试：

• git config --global user.name "mdn"
• git config --global user.email "mdn@163.com"
• git config --list

• git配置：文件 -> 设置 -> 版本控制 -> Git

• 数据类型

Python中常见的数据类型有：

1. 简单类型

整数类型(int)、浮点数类型(float)、布尔类型(bool)

1. 高级(序列)类型

字符串(str)、列表(list)、元组(tuple)、字典(dict)、集合(set)

1. 变量

变量：变化的量，存储在电脑内存中，可以使用变量来存储数据。

语法格式：变量名 = 变量值   （位置永远不变）

说明：= 表示赋值符号，== 表示等号

将右边的变量值赋值给左边的变量名

例如：π = 3.14  （3.14就是变量值，π就是变量）

1. 整数类型(int)

整数类型包含正整数，负整数，零

n1 = 999

n2 = -99                       普通赋值

n3 = 0

------------------------------------------------------

x = y = z = 789                链式赋值

------------------------------------------------------

x1,y1,z1 = 999,-99,0           同时赋值

1. 浮点数类型(float)

浮点数类型又称小数类型

n4 = 3.14                     普通赋值

n5 = 3.2434

--------------------------------------------------------------

n6 = 1.23 * 105

n7 = 1.23e5                   科学计数法

n8 = -2.34E-3

n9 = -2.34 * 10-3

--------------------------------------------------------------

x1 = 0.98

x2 = .98                      省略整数部分0

x3 = 9.0

x4 = 9.                       省略小数部分的0

--------------------------------------------------------------

x5,x6,x7 = 999,3.14,0

1. 布尔类型(bool)

布尔类型用于表示逻辑值，值包含：True（正确）和False（错误）

n1 = False

n2 = True

1. 字符串(str)  ---  基础

字符串就是有序的字符集合，用于存储或者描述，由单引号、双引号、三个单引号、三个双引号括起来的字符

s1 = 'abcdefg'

s2 = "123456789"

s3 = '''北京市朝阳区'''

s4 = """Python是最牛的语言"""

-------------------------------------------------------------------

s5 = "Python是'最'流行的编程语言之一"   (单对双，双对单)

s6 = 'Python是"最"流行的编程语言之一'

s7 = "select * from emp where name = 'rose'"

口诀：单对双，双对单

1. 代码注释

1. 单行注释

单行注释以 # 字符开始的注释

单行注释的快捷键：Ctrl + /？（按一次填注释，再按一次取消或者选中）

1. 多行注释

多行注释以三个单引号或者三个双引号开头和结尾的

1. 标识符规范

标识符就是用来标识变量名、函数名、类名、包名，起名规则的

1. 标识符中第一个字母，必须是字母或者下划线，其余字符可以是字母，数字、下划线
2. 标识符中不能包含空格
3. 严格区分大小写
4. 不能包含Python关键字

----------------------------------------------------------------

1. 一般不使用双下滑线开头和结尾
2. Python3中，支持中文起名

----------------------------------------------------------------

变量名命名时，尽量达到“见名知意”  -- 不成文的规定

• 输入和输出函数

1. 输出函数

print()  表示输出结果，并换行  # 可以一次输出多个值，使用逗号分隔

1. 输入函数

input()  表示获取键盘输入的数据，并返回字符串类型数据。

• 运算符和表达式

1. 算数运算符和表达式

+（加）  -（减）  *（乘）  /（除）

**（乘方）  //（整除）  %（取余）

案例：# 算式运算符和表达式
a = 10  b = 3  c = 2  d = 70

# +
# 变量名 = 变量值
res1 = a + b
print(res1)       # 结果：13

# -
res2 = c - d
print(res2)       # 结果：-68

# *
res3 = b * c
print(res3)       # 结果：6

# /
res4 = a / b
print(res4)       # 结果：3.3333333335
res5 = a / c
print(res5)       # 结果：5.0  注意：默认除法结果是浮点数

# ** （乘方）
res6 = c ** b
print(res6)       # 结果：8

# //  (整除)
res7 = a / b   # 除法
print(res7)       # 结果：3.333333335
res8 = a // b  # 整除
print(res8)       # 结果：3

# % （取余）
res9 = a % b  # 10 % 3
print(res9)       # 结果：1
res0 = a % c  # 10 % 2
print(res0)       # 结果：0
# 如果余数是0，表示被整除；

1. 复合赋值运算符

+=  -=  *=  /=  **=  //=  %=

a = 10

a += 25 相当于a = a + 25

print(a)

案例：# 复合赋值运算符
a = 10
b = 9
c = 2

# +=
a += 20   # a = a + 20
print(a)    # 结果：30

# -=
b -= 30   # b = b - 30
print(b)    # 结果：-21

# *=
c *= 10   # c = c * 10
print(c)    # 结果：20

# **=
c **= 9   # c = c ** 9
print(c)    # 结果：512000000000   # 因为是从上往下计算，上面的c结果已经是20了，所有得出来的数是512000000000

1. 关系运算符和表达式  （结果是布尔类型）

>  <  ==  >=  <=  !=

>=  表示大于或等于

<=  表示小于或等于

注：关系运算符比较的结果是逻辑值，True 或者 False

案例：# 关系运算符和表达式
a = 100
b = 200
c = 100

# 变量名 = 变量值
res1 = b > a
print(res1)       # 结果：True
res2 = a == c
print(res2)       # 结果：True
res3 = b < a
print(res3)       # 结果：False
res4 = a != b1
print(res4)       # 结果：True
res5 = a >= c
print(res5)       # 结果：True
# 关系运算符比较的结果是逻辑值，True 或者 False

1. 逻辑运算符和表达式

and（与）  or（或）  not（非）

案例：# 逻辑运算符和表达式 a = -10 b = -30 res1 = a < 0 and b < 0 print(res1)       # 结果：True res2 = a < 0 and b > 0 print(res2)       # 结果：False res3 = a < 0 and 1 / 2 print(res3)       # 结果：0.5 res4 = a > 0 and 1 / 2 print(res4)       # 结果：False   短路 res5 = a > 0 and b < 0 print(res5)       # 结果：False print('----------------------------------------') res6 = a > 0 or b < 0 print(res6)       # 结果：True res7 = a > 0 or b > 0 print(res7)       # 结果：False res8 = a < 0 or 1 / 2 print(res8)       # 结果：True   短路 res9 = a > 0 or 1 / 2 print(res9)       # 结果：0.5 print('----------------------------------------') res0 = a > 0 and b < 0 print(res0)       # 结果：False print(not res0)   # 结果：True res11 = a > 0 or 1 / 2 print(res11)      # 结果：0.5 print(not res11)  # 结果：False

""" 编写一个简易计算器程序(v1.0)，该计算器实现加减乘除功能，获取键盘输入的两个数据，进行计算，输出结果 """ # 获取键盘输入的2个数据      输入       赋值       转换    # 100  -->  '100'  -->  100 b = float(input('请输入第一个数：')) c = float(input('请输入第二个数：')) # 加法计算 set1 = b + c # 减法计算 set2 = b - c # 乘法计算 set3 = b * c # 除法计算 set4 = b / c # 输出结果 print('加结果', set1) print('减结果', set2) print('乘结果', set3) print('除结果', set4) #TypeError: unsupported operand type(s) for -: 'str' and 'str'  不支持字符串减字符串

• 高级数据类型

1. 字符串（str） --- 高级

1. 复习自定义字符串

案例：# 复习定义字符串
s1 = 'asdf'
s2 = "fdsgf"
s3 = '''desfvf'''
s4 = """fsdfd"""
s5 = 'dft"f"dg'        # 单对双
s6 = "sfdg'h'gh"       # 双对单
s7 = input('请输入您的数据：')
# 我们通过type（）函数，来判断数据类型
print(s1, type(s1))
print(s7, type(s7))

1. 字符串运算

1. 支持加法运算
2. 支持乘法运算

案例：# 字符串（str） -- 字符串运算
s1 = 'abc'
s2 = "12345"
# 加法运算
res1 = s1 + s2    # + 表示连接符
print(res1)       # 结果：abc12345
# 乘法运算
res2 = s1 * 3     # 不能乘字符串，可以乘数
print(res2)       # 结果：abcabcabc
# 口诀：加连接，乘复制

1. 转义字符

转义字符就是在字符串中的，某些特定字符前，加上一个斜杠(\)，这是该字符被解释为另外一种意思。

\n    表示换行符

\t    表示制表符

\\    表示输出一个斜杠(\)

\'    表示输出单引号字符串中的单引号

\"    表示输出双引号字符串中的双引号

案例：# 字符串（str） -- 转义字符

# \n

s1 = 'sdsfdd'
print(s1)
s1  = 'abcd\nefg'
print(s1)

print('*\n**\n***\n****\n*****')

# \t
s2 = 'Python\tJava\tC++'
print(s2)

# \\  用于构建路径
path = 'C:\Program Files\Git\bin'
print(path)
path1 = 'C:\\Program Files\\Git\\bin'
print(path1)

# \'
s3 = 'Python是\'最流行\'的编程语言之一'    # 输出单引号字符串中的单引号
print(s3)

# \"
s4 = "Python是\"最流行\"的编程语言之一"    # 输出双引号字符串中的双引号
print(s4)

1. 格式化字符

格式化字符就是在字符串中，以%开头的特殊字符，在代码运行的时候，可以改变字符串中的内容。

%d    表示十进制整数

%f    表示浮点数

%s    表示字符串

%%    表示%

%c    表示单个字符

案例：# 字符串（str） --- 格式化字符
a = 100
b = 200

# %d
res1 = a + b
print(res1)          # 结果：300
print(a, b, res1)    # 结果：100 200 300
print(a, '+', b, '=', res1)       # 结果：100 + 200 = 300
print('%d', res1)    # 结果：%d 300
print('%d' % res1)   # 结果：300
print('%d%d%d' % (a, b, res1))    # 结果：100200300
print('%d+%d=%d' % (a, b, res1))  # 结果：100+200=300

# f
c = 10.5
d = 3.14
res2 = c - d
print(c, '-', d, '=', res2)      # 结果：10.5 - 3.14 = 7.359999999999999
print('%f-%f=%f' % (c,d,res2))   # 结果：10.500000-3.140000=7.360000    （f自动保留6位小数）
print('%.2f-%.2f=%.2f' % (c,d,res2))   # 结果：10.50-3.14=7.36   （保留2位小数）
# %f默认保留小数点后六位，%.2f表示保留小数点后两位

# %s   --  占位符
name = input('请输入您的姓名：')
print('您输入的姓名是：%s' % name)

# %%
num = float(input('请输入折扣：'))
print('您的折扣是：%d%%' % num)

# %c
sex = input('请输入您的性别：')
print('您的性别是：%c' % sex)

----------------------------------------------------------

我们还可以通过f"被格式化的字符串"格式，进行格式化字符，并输出结果

案例：# 格式化字符 --- f""
n1 = float(input('请输入第一个数'))
n2 = float(input('请输入第二个数'))
res1 = n1 + n2

print(n1, '+', n2, '=', res1)
print('%.1f + %.1f = %.1f' % (n1, n2, res1))
print(f'{n1} + {n2} = {res1}')
# 通过{}中添加变量名或表达式，获取值

1. 字符串切片

字符串是一个有序的字符集合，字符串中的每个字符都会被自动编号，编号从0开始，我们可以通过编号（下标）来获取相应的字符。

语法格式1：字符串名称[下标]

例如：str01[9],表示获取字符串str01中，编号（下标）是9号的字符。

语法格式2：字符串名称[下标:下标]  （从几号位置切到几号位置）

例如：str01[1:7],表示获取字符串str01中从第1号下标开始到第7号下标结束的字符，输出结果不包含7号下标，其中下标可以被省略。

案例：# 字符串切片
str01 = 'ABCDEFGHIJKLMN'
#        0123456789(下标/编号)
#                       -1
print(str01[5])        # 结果：F
print(str01[-5])       # 结果：J
# 编号（下标）也可以是负数，从-1开始，表示倒数第一个字符
print('------------------------------------------------------')
print(str01[1:6])     # 结果：BCDEF
print(str01[:6])      # 结果：ABCDEF
print(str01[3:])      # 结果：DEFGHIJKLMN
print(str01[:])       # 结果：ABCDEFGHIJKLMN
print(str01[-6:])     # 结果：IJKLMN
print(str01[:-3])     # 结果：ABCDEFGHIJK

1. 字符串解包和比较

1. 字符串解包

str01 = 'abc'

s1, s2, s3 = str01

print(s1) = a

1. 比较

案例：# 字符串解包和比较
str01 = 'ABC'
s1, s2, s3 = str01    # s1, s2, s3 = 'ABC'   # 解包（将字符串一一拆开，并赋值给变量）
print(s1)      # 结果：A
print(s3)      # 结果：C

str02 = 'Python是最流行的编程语言之一'
str03 = 'Python是最流行的编程语言之一'
str04 = 'Python'
str05 = 'python'
print(str02 == str03)    # 结果：True
print(str03 == str05)    # 结果：False
# 预期结果 == 实际结果   结果相同(True)不是缺陷，结果不同(False)是缺陷
print(str04 in str02)    # 结果：True
print(str05 in str02)    # 结果：False
# 严格区分大小写，写大小写是两个意思

1. 字符串常见函数

1. len(str)  获取字符串的长度
2. index()  表示一个字符串在另外一个字符串中，首次出现的位置（下标）。
3. count()   表示一个字符串在另外一个字符串中，出现的次数
4. split()    表示指定某个分隔符，将字符串拆分成多个小字符串，并以列表形式显示
5. strip()    表示去掉字符串两端的空格
6. upper() /lower()   表示将字符串转换为大写或者小写显示
7. startswith()/endswith()  表示检查字符串是否以某个字符开头/结尾的。
8. isalpha()（字母）、isdigit()（数字）、isspace() （空格）  表示判断字符串是否全部都是字母、数字、空格
9. eval()   表示用于执行字符串表达式并返回结果

案例：# 字符串常见函数 str01 = 'ABCDEF' # len()      长度 str_len = len(str01) print(f'字符串长度是：{str_len}')  # 结果:字符串长度是：6 # index()    出现的首次位置 str02 = 'abcabcabc123' str03 = 'ca' str_index = str02.index(str03) print(f'字符串出现的位置是：{str_index}')    # 结果:字符串出现的位置是：2 # count()   出现的次数 str04 = 'abc123abc123abc' str05 = 'abc' str_count = str04.count(str05) print(f'字符串出现的次数：{str_count}')     # 结果：字符串出现的次数：3 # split() str06 = '苹果,西瓜,香蕉,樱桃,荔枝,橘子' str_split = str06.split(',') print(str_split)            # 结果：['苹果', '西瓜', '香蕉', '樱桃', '荔枝', '橘子'] # strip() str07 = '   今天北京的室外温度是34°   ' print(str07.strip())     # 结果：今天北京的室外温度是34° # upper() / lower() str08 = 'ABCdefGhIJklMN' print(f'原始字符串：{str08}')       # 结果：原始字符串：ABCdefGhIJklMN print(f'字符串大写显示：{str08.upper()}')      # 结果：字符串大写显示：ABCDEFGHIJKLMN print(f'字符串小写显示：{str08.lower()}')      # 结果：字符串小写显示：abcdefghijklmn # startswith() / endswith() url01 = 'www.tmooc.cn' url02 = 'http://teacher.tmooc.cn' print(url01.startswith('www'))     # 结果：True print(url02.endswith('.cn'))       # 结果：True print(url01.startswith('www') and url01.endswith('.cn')) # isalpha()、isdigit()、isspace() str09 = 'Python是最牛的编程语言之一' str10 = '今天是节后的第二天' str11 = '123456789' print(str09.isalpha())       # 结果：True  # 在Python的世界里，中文也看成字母 print(str11.isdigit())        # 结果：True print(str10.isspace())       # 结果：False # eval() a = 100 b = 'a * 5' print(b)            # 结果：a * 5 print(eval(b))       # 结果：500

练习1： """ 网上购物 ---> 订单编号 '...尊敬的顾客张三，您好，您的订单已发送，订单编号是1102023，欢迎下次惠顾....' """ str01 = '...尊敬的顾客张三，您好，您的订单已发送，订单编号是：1102023，欢迎下次惠顾....' start_str = '订单编号是：' end_str = '，欢迎下次惠顾' start_str_len = len(start_str) # 获取开始字符串下标 start_str_index = str01.index(start_str) + start_str_len print(f'开始字符串下标：{start_str_index}') # 获取结束字符串下标 end_str_index = str01.index(end_str) print(f'结束字符串下标：{end_str_index}') # 获取订单编号 print(str01[start_str_index:end_str_index]) # 结果：1102023 练习2：""" 编写一个用户登录程序，用户名，密码，验证码 获取键盘输入的用户名(username),密码(password),验证码(yzm)和正确的用户名、密码、验证码比较，如果相同，给出True提示，失败给出False提示 用户名：admin 密码：Abc123 验证码：V58R """ username = input('请输入您的用户名：').strip() password = input('请输入您的密码：') yzm = input('请输入您的验证码：').upper() res = username == 'admin' and password == 'Abc123' and yzm == 'V58R' print(f'登录结果{res}')

1. 列表（list）

列表是Python中使用最频繁的数据类型之一，列表是有序、可变的，同一个列表中，可以有不同的数据类型。

1. 定义列表

列表名 = [数据1,数据2,......,数据n]

列表名 = [

  [数据1,数据2,......,数据n],

  [数据1,数据2,......,数据n],

......

  [数据1,数据2,......,数据n]

]

说明：列表是[]括起来的数据集合，不同数据之间使用,（逗号）分隔，数据可以是不同的数据类型

案例：# 列表
# 定义列表
list01 = [100, 200, 300, 400, 500]
list02 = [101, 'rose', 20, 87.5, '1年1班', True]
list03 = [
    ['case01', 'admin', 'abc123', 'BC12', True],
    ['case02', 'admin', 'abcdef', 'BC12', False],
    ['case03', ' ', 'abc123', 'BC12', False]
]

1. 使用列表

1. 通过列表名使用  ---  最简单的

print(列表名)

1. 切片(列表名 + 下标)
2. 解包

案例：# 使用列表
# n通过列表名使用
print(list01)
print(list02)
print(list03)
# n切片(列表名 + 下标)
print(list01[2])     # 结果：300
print(list02[4])     # 结果：1年1班
print(list02[-2])    # 结果：1年1班
print(list03[1])     # 结果：['case02', 'admin', 'abcdef', 'BC12', False]
print(list03[1][1])  # 结果：admin     # 仅限二维列表可以使用
print(list02 [1:4])  # 结果：['rose', 20, 87.5]
# n解包
case01, case02, case03 = list03
print(case03)     # 结果：['case03', ' ', 'abc123', 'BC12', False]
# 解包不适合用于数据特别多的变量。

1. 特殊情况列表

1. list01 = []          空列表
2. list02 = list()       空列表
3. list() 

1. 删除列表

1. 删除列表中的数据

del 列表名[下标]

1. 删除列表对象

del 列表名

案例：# n删除列表
list04 = [101, 'rose', 20, 87.5, '1年1班', True]
# 删除列表中的数据
print(f'删除前：{list04}')     # 结果：[101, 'rose', 20, 87.5, '1年1班', True]
del list04[1]
print(f'删除后：{list04}')     # 结果：[101, 20, 87.5, '1年1班', True]]

# # 删除列表对象
# del list04
# print(f'删除后：{list04}')
# # NameError: name 'list04' is not defined. Did you mean: 'list01'?

1. 列表运算（加连接 乘复制）

1. 支持加法运算
2. 支持乘法运算

案例：# 列表运算
list05 = [100, 200, 300]
list06 = ['A', 'B', 'C']
# 加法运算
res = list05 + list06
print(res)     # 结果：[100, 200, 300, 'A', 'B', 'C']
# 乘法运算
res1 = list06 * 3
print(res1)     # 结果：['A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C']

1. 类型转换

1. 字符串转换为列表

split()    将字符串拆分成列表

1. 列表转换为字符串

str()      -- 将列表强行转换为字符串

join()      -- 只能用于列表中的数据库全部都是字符串类型

案例：# 类型转换
str01 = 'Python, Java, C++'
list07 = ['A', 'B', 'C']
list08 = ['rose', 20, '女']
# 字符串转换为列表  --  分隔
str_split_list = str01.split(',')
print(str_split_list, type(str_split_list))   # 结果：['Python', ' Java', ' C++'] <class 'list'>
# 列表转换为字符串
str02 = str(list07)        #  将列表强行转换为字符串 -- 强转
print(str02, type(str02))    # 结果：['A', 'B', 'C'] <class 'str'>   样子没变，但是字符变了
str03 = ''.join(list07)      # 当列表当中数据都是字符串类型才能使用，中间有别的类型是无法转换的
print(str03, type(str03))    # 结果：ABC <class 'str'>
print('-------------------------------------')
str04 = str(list08)
print(str04, type(str04))    # 结果：['rose', 20, '女'] <class 'str'>
# str05 = ''.join(list08)
# print(str05, type(str05))
# ''.join() 只可以用于列表中的数据全部都是字符串类型

1. 列表常用函数

1. len()       获取列表中数据长度
2. index()     获取某个元素（数据）在列表中首次出现的位置
3. count()     获取某个元素（数据）在列表中出现的次数
4. append()    向列表尾部追加一个数据
5. insert()     向列表中指定位置插入数据
6. pop()       删除列表中指定位置上的数据
7. clear()     清空列表中的数据

案例：# 列表常见函数
list01 = [101, '张三', 20, '男', 101, 3456.78, False]
# len()
list_len = len(list01)
print('列表的长度是：', list_len)      # 结果：列表的长度是：6

# index()
list_index = list01.index('张三')
print('列表中数据的位置：', list_index)      # 结果：列表中数据的位置：1

# count()
list_count = list01.count(101)
print('列表中数据出现的次数：', list_count)      # 结果：列表中数据出现的次数：2

# append()
list01.append('北京市')
print('追加后，列表中的数据：', list01)    # 结果：追加后，列表中的数据：[101, '张三', 20, '男', 101, 3456.78, False, '北京市']

# insert()
list01.insert(4, 'zhangsan@163.com')
print('插入后列表中的数据：', list01)    # 结果：插入后列表中的数据： [101, '张三', 20, '男', 'zhangsan@163.com', 101, 3456.78, False, '北京市']

# pop()
list01.pop(5)
print('删除后列表中的数据：', list01)    # 结果：删除后列表中的数据： [101, '张三', 20, '男', 'zhangsan@163.com', 3456.78, False, '北京市']

# clear()
list01.clear()
print('清空后列表中的数据：', list01)     # 结果：清空后列表中的数据： []