1. Python的安装和简介
1.1 Python基础常识
1.1.1 简介
Python是一门面向对象的解释性计算机设计语言
1.1.2 Python语言特色
- python是一门解释性语言
- 解释性语言：在系统中运行时需要使用解释器（如Java、php等）
- 编译性语言：在系统中运行时不需要使用解释器（如C，C++）
- 弱类型语言
- 弱类型语言：变量在使用之前不需要提前声明变量的类型就可以直接使用
- 强类型语言：变量在使用之前需要提前声明变量的类型
- 面向对象的语言
- Python支持面向对象的编程，也在一定程度上支持面向过程和面向函数
- 胶水语言
- Python的底层和扩张库都是由C语言写成，可以很好支持C和C++
1.2.3 Python语言的优点
- 简单
- 易学
- 速度快（这里指python的开发速度相对较快，python的运行速度相对一般）
- 免费，开源
- 高层语言（这里的高低指的是距离硬件的远近，python距离硬件相对比较远）
- 可移植性（python在linux，windows，mac os都可以使用）
- 可扩张性
- 可嵌入性
1.2 Python安装及版本检测
1.2.1 Python windows上安装需要注意事项
勾选add python to paith 若没有勾选就需要手动去配置环境变量
1.2.2 Python版本检测
- 方法一：在cmd中直接输入python，第一行会显示python的当前版本
- 方法二：在cmd中输入python -V
- 方法三：打开idle
1.3 程序执行
- 交互式
- 优势：适合探索、研究、学习需求
- 劣势：不能做大项目
- 四种执行方式：
- 系统自带的Shell
- IPython：增强版的Shell
- QTconsole：GUI版的IPython
- Jupyter Notebook:重要 =======================
- 工程式
- 优势：做大项目
- 劣势：不适合研究性项目
- 四种执行方式：
- 新建py文件，命令行直接执行
- 注意编码问题，能用编辑器修改编码
- IDLE:兼具交互式和工程式执行
- VScode:代码编辑器
- PyCharm：重要 ======================
2. Python基本语法
2.1 注释、语句分类、关键字
2.1.1 注释
定义：即注解，解释。分为单行注释和多行注释
作用：
1.给代码做出标注，进行解释和说明。方便别人阅读和理解代码 2.在debug的时候，可以通过注解来一行一行查找问题
2.1.1.1 单行注释
以#号开始，#后面的内容就是注解的内容。计算机不会去阅读#后面的内容
2.1.1.2 多行注释
以”’ 或者”“” 将注释内容包裹起来
2.1.1.3 注释的选择原则
单行注释 # 里面可以使用多行注释 ”’ 或者 “”“
多行注释”’ 或者 “”” 里面可以使用单行注释#
多行注释中可以使用另一种多行注释。如：”’ 中可以使用”“” 在”“”中可以使用”’
2.1.2 Python 语句分类
Python语句分为 单行语句 和 代码组（代码块）
单行语句：一行python代码
代码组：特定的语言结构，标志是：和缩进（如if ，while等）
2.1.3 关键字
定义：关键字指系统已经使用的具有特殊功能的保留标识符
查看系统保留关键字的方法：
import keyword print（keyword.kwlist）
3. Python变量及数据类型
3.1 变量
变量的定义：变量就是可以变化的量（在Python中更像是把变量的值贴到值上面，之后使用这个值就直接用贴在它上面的名字即可）
变量赋值：（三种方式）
方法一：（基本格式） 变量 = 值 方法二：（给多个变量赋相同的值） 变量1 = 变量2 = 变量3 ... = 值 方法三：（给多个变量赋不同的值） 变量1，变量2，变量3... = 值1，值2，值3...获取变量的类型：（两种方法）
1. type（） print（type（变量）） 2. isinstance（）-------> isinstance（查看的变量，类型） 返回的值是bool True or False print（isinstance（4，int））获取变量在内存中的id：
id（） print（id（变量））更改变量的值：（对变量重新赋值即可）
val = 1 val = 2 print(val)变量的命名规则：
1. 使用英文，禁止使用中文 2. 可以使用数字，但是不能用数字开头 3. 特殊符号只能使用下划线_ 4. 区分大小写 5. 命名必须要有意义 6. 避免和系统保留的关键字冲突
3.2 数据类型
- Number 整型 (包含 ：int、float、bool、complex)
- String 字符串
- List 列表
- Tuple 元组
- Set 集合
- Dict 字典
ps：
* Number中包含： int、float、bool、complex
* 容器数据类型： String、List、Tuple、Set、Dict
* 有序数据类型： String、List、Tuple
* 无序数据类型： Set、Dict3.2.1 Number类型
3.2.1.1 Number类型：int
int整型的声明方式：（十进制、二进制、八进制、十六进制）
1. 十进制（0-9） 变量 = 十进制数字 2. 二进制（0-1） 变量 = 0b二进制数字 3. 八进制（0-7） 变量 = 0o八进制数字 4. 十六进制（0-9a-f） 变量 = 0x十六进制数字
3.2.1.2 Number类型：float
float浮点型声明方式：（小数和科学记数法）
1. 小数： 变量 = 带小数点的数字 num = 3.14 2. 科学计数法 e相当于10 变量 = 314e-2
3.2.1.3 Number类型：bool
- bool类型只有两个值：True 和 False （True和False的首字母都要大写！）
- True：表示肯定的，确定的答案
- False：表示否定的答案
3.2.1.4 Number类型：complex
复数定义：由实数部分和虚数部分组成，实数部分是实际存在的数字，虚数部分是现实世界中不存在的数字。在计算机中虚数的单位为j。
声明一个复数的方法：
方法一： 变量 = a + bj 方法二： 变量 = complex（实数 + 虚数） 实数和虚数都只要填入纯数字即可，虚数部分不需要填入单位：j 如： complex1 = complex（3，4） == complex1 = 3 + 4j
3.2.2 String 字符串类型
String在所有语言中都是使用最多的数据类型
String类型声明方式：（三种）
方法一：单引号 '' 变量 = '字符串内容' 方法二：双引号 " " 变量 = "字符串内容" 方法三：三引号 ''' ''' 或者 """ """ 变量 = '''字符串内容''' 或者 变量 = """字符串内容"""String声明方式选择原则：
1. 单引号中可以使用双引号 2. 双引号中可以使用单引号 3. 三引号中可以使用单双引号转义字符：\
1. 转义单引号：\' （使单引号失去原有的特殊意义） str1 = '古人说：\'nnb\'' 2. 转义双引号：\" （使双引号失去原有的特殊意义） str1 = "古人说，\"nnb\"" 3. 换行操作符：\n str1 = "人之初，\n性本善。" 4. 缩进操作符：\t str1 = "\t人之初，性本善" 5. 对\自身进行转义：\\ str1 = '在字符串中输出\\' 6. 续行符：\ str1 = '在单行语句\' '过长时使用，自动续行' 7. 原字符串：在字符串前面加上 r 或者 R ，转义字符串中所有的字符 str1 = r'你好，\n再见\t！'
3.2.3 List 列表类型
列表类型的标志：[ ] 中括号
列表的声明方式：
变量 = [值1，值2，值3......]创建一个空列表：
方法一： 变量 = [] 方法二： 变量 = list()列表索引值
正向索引： 0 1 2 3 4 list1 = [100,200,300,400,500] 反向索引：-5 -4 -3 -2 -1通过索引访问和修改列表中特定的值
列表[index] 列表[index] = 新的值 可以通过下标来修改列表中的值
3.2.4 Tuple 元组类型
元组类型的标志：，逗号
元组类型的声明方式：
方法一： 变量 = (值1，值2，值3....) 方法二： 变量 = 值1，值2，值3....元组索引值
正向索引 0 1 2 3 4 tuple1 = (100,200,300,400,500) 反向索引 -5 -4 -3 -2 -1通过索引查看元组中的某个值
元组[index] 元组中的值不能随意修改
3.2.5 Set 集合类型
集合的标志：无
集合是无序容器，无法通过索引来访问其中的某个值
集合中所有的数据都是唯一的，出现重复的会只保留唯一的其他删除
集合的声明方式：
变量 = {100,200,300,400,500}创建空集合：
变量 = set（）
3.2.6 Dict 字典类型
字典的标志：{ }
字典是无序数据，无法通过索引来访问其中的某个值
字典的声明方式：
变量 = {键：值，键：值，键：值...}访问和修改字典中的值 ：
字典是无序容器，不能使用索引来访问字典中的值。但是可以通过字典特有的键来访问字典中的值： dict[键] 修改字典中的值： dict[键] = 新的值创建一个空字典：
变量 = dict() dict1 = dict() 变量 = {} dict1 = {}
3.2.7 查看数据类型的方法
3.2.7.1 type（）
正常工作的时候不能用，因为效率太低了。工作原理是把目标数据和所有数据类型一一匹配询问，找到同目标数据类型相同的类型。
result = type（变量名）
print（result）3.2.7.2 isinstance（）
工作效率比较高，把目标变量和指定的类型做比对，如果目标变量和指定类型为相同类型，则返回True；否则返回False
* 方法一，使用isinstance查看单一类型
isinstance(变量，类型)
如：
var = 123
result = isinstance(var,int)
print(result)
* 方法二，使用isinstance查看目标变量是否属于两个类型中
isinstance（变量，(类型一，类型二)）
如：
var = 123
result = isinstance（var，（int，str））
print（result）3.3 数据类型转换
3.3.1 自动数据类型转换
自动数据类型转换是系统自发的，不需要人工干预的
自动数据类型转换会从精确度较小的数据类型向精确度较高的数据类型进行转换
自动数据类型转换多发生在运算或者判断的时候
如： num1 = 25 num2 = 25.0 print(num1 + num2) 又如： if 1: print('1会自动转化成True')
3.3.2 强制数据类型转换
3.3.2.1 int（）
将其他数据类型转换成整型
整型： 无需转换
浮点数： 去掉小数部分，只保留整数部分
布尔值： True 转换成 1，False 转换成 0
复数： 复数无法转换成整型
字符串： 只有纯整数字符串才能转换成int。
列表，元组，集合，字典都不能转换成整型3.3.2.2 float（）
将其他数据类型转换成浮点数
整型： 在整数后面加上.0
浮点数： 无需转换
布尔值： True 转换成 1.0 False 转换成 0.0
复数： 复数无法转换成浮点数
字符串： 只有纯整数字符串和纯浮点数字符串才能转换成浮点数
列表，元组，集合，字典都不能转换成浮点数3.3.2.3 bool（）
其他类型中，相当于bool中的False的情况
整型： 0
浮点型： 0.0
bool： False
复数： 0j 或者 0+0j
字符串： ''(空字符串)
列表： [] 或者 list()
元组： () 或者 tuple()
集合： set()
字典： {} 或者 dict()3.3.2.4 complex()
其他类型转换成复数complex（）
整型： 整型+0j
浮点数： 浮点数+0j
布尔值： True：1+0j False：0j 或者 0+0j
复数： 无需转换
字符串： 字符串中只有纯整数，纯浮点数或者纯复数才能转换成复数
列表、元组、集合、字典都不能转换成复数3.3.2.5 str（）
其他类型转换成字符串
所有类型都可以转换成字符串，系统会自动给其他类型加上''让它变成字符串
如果要打印出带引号的字符串，可以使用命令repr()
如：
list1 = [1,2,3]
list1 = str(list1)
print(repr（list1）)3.3.2.6 list（）
其他类型转换成列表
整型、浮点型、复数、布尔值都不能转换成列表
字符串：字符串转换成列表，把字符串中的每个值转换成列表中的每一个值，顺序保持不变
列表： 无需转换
元组： 把元组中的每个值转换成列表中的值，顺序保持变
集合： 把集合转换成列表中的每一个值，顺序随机
字典： 把字典中的键转换成列表中的值，顺序随机3.3.2.7 tuple（）
其他类型转换成元组
整型、浮点数、复数、布尔值都不能转换成元组
字符串：字符串中的每个字符转换成元组中的一个值，顺序不变
列表： 列表中的每一个值转换成元组中的值，顺序不变
元组： 无需转换
集合： 集合中的每个值转换成元组中的每个值，顺序随机
字典： 字典中的每个键转换成元组中的一个值，顺序随机3.3.2.8 set（）
其他类型转换成集合
整型、浮点型、复数、布尔值都不能转换成集合
字符串： 字符串中的每个字符转换成集合中的一个值，顺序随机
列表： 列表中的每个值转换成集合中的一个值，顺序随机
元组： 元组中的每个值转换成集合中的一个值，顺序随机
集合： 无需转换
字典： 字典中的每个键转换成集合中的一个值，顺序随机3.3.2.9 dict（）
其他类型转换成字典
* 整型、浮点型、复数、布尔值都不能转换成字典
* 字符串： 不能转换成字典
* 列表： 只有特定的列表格式可以转换成字典
1. 二级列表（且第二级容器的长度一样）
list1 = [[键，值],[键，值],[键，值],[键，值],[键，值]] or list1 = [(键，值),(键，值),(键，值),(键，值)]
2. 一级列表：只含有两个字符的一级列表
list1 = ['键值','键值','键值','键值']
* 元组： 只有特定的元组格式才可以转换成字典
1. 二级元组（且第二级容器的长度一样）
tuple1 = ((键，值),(键，值),(键，值),(键，值))
2. 一级元组：只含有两个字符的一级元组
tuple1 = （'键值','键值','键值','键值'）
* 集合： 只有特定的集合格式才可以转换成字典
1. 二级集合（且第二级容器的长度一样）
set1 = {(键，值),(键，值),(jia),()}4. Python运算符
- 算术运算符
- 比较运算符（关系运算符）
- 逻辑运算符
- 位运算符
- 赋值运算符
- 成员运算符
- 身份运算符
- 转义字符
4.1 算术运算符
** 幂运算（最高优先级）
* 乘法运算
/ 除法运算
// 取商运算（地板除）
% 取余运算
+ 加法运算
- 减法运算4.2 比较运算符（关系运算符）
比较运算符运算结果为布尔值： True 、False
<= 小于等于
>= 大于等于
< 小于
> 大于
== 等于
!= 不等于4.3 赋值运算符
变量 = 变量 操作符 值 ——————————-> 变量 操作符= 值
**= 幂运算赋值
*= 乘法赋值
/= 除法赋值
//= 取商赋值
%= 取余赋值
+= 加法赋值
-= 减法赋值
= 普通赋值4.4 逻辑运算
逻辑运算是布尔值之间的运算
not 逻辑非运算 （逻辑运算中优先级最高）
真变假，假变真 not True == False not False == Trueand 逻辑与运算
有假则假 只有当 and 左右的两个条件都满足的时候 and 的结果才是为真 True and False == False True and True == True False and False == Falseor 逻辑或运算
有真则真 当 or 左右两个条件有一个满足，则 or 的结果就是为真 True or False == True False or False == False True or True == Truexor 逻辑异或运算
不同为真，相同为假 在python中不支持异或操作。 True xor False == True True xor True == False False xor False == False
4.5 位运算符
位运算就是在二进制基础上进行的逻辑运算
& 按位与运算
| 按位或运算
~ 按位反转
^ 按位异或运算
<< 左移 << 1 左移1位，相当于*2
>> 右移 >> 1 右移1位，相当于//24.6 成员运算符
检测变量是否在容器类数据中
in ：
变量 in 容器类数据（string,list,tuple,set,dict），检测字典的时候，只检测字典的键
检测变量是不是在容器中
not in :
变量 not in 容器类数据
检测变量是不是不在容器中4.7 身份运算符
判断两个变量在内存中的地址是否相同。
is：
检测两个变量是否是同一个值
is not：
检测两个变量是否不是同一个值当数值相同的时候，哪些数据类型的id会相同
1. 整数： -5以上的整数
2. 浮点数： 0以上的浮点数
3. 布尔值： 永远相同
4. 复数： 实数部分为0，虚数部分在0j以上
5. 字符串： 永远相同 4.8 转移字符
转义字符： 通过某种特定的格式使得字符的意义发生改变，这就是转义字符，常见转义字符如下：
转义字符 作用描述 使用率
\ 续行符 *
\\ 反斜杠符号(\) ***
\' 单引号 *****
\" 双引号 *****
\a 响铃
\b 退格(backspace)
\e 转义
\000 空
\n 换行 *****
\v 纵向制表符
\t 横向制表符 *****
\r 回车 *****
\f 换页
\oyy 八进制数，yy代表的字符，例如：\o12代表换行
\xyy 十六进制数，yy代表的字符，例如：\x0a代表换行
\other 其它的字符以普通格式输出5.流程控制
流程:
做事情的顺序就是流程,计算机中的流程就是代码执行的顺序.默认是从上到下流程分类:
- 顺序结构
- 分支结构(单向分支,双向分支,多向分支,巢状结构)
- 循环结构(while循环 死循环 for…in循环)
5.1 顺序结构
python默认的代码执行顺序,默认从上到下执行代码
5.2 分支结构
5.2.1 单向分支
基本格式:
if 条件判断:
条件为真时,执行语句
...如:
num = 10
if num > 9:
print(num)5.2.2 双向分支
基本格式:
if 条件判断:
条件为真的时候执行代码
...
else:
条件为假的时候执行代码
...如:
num = 10
if num > 10:
print(num)
else:
print(num,'比10小')5.2.3 多向分支
基本格式:
if 条件1判断:
条件1为真的时候执行代码
...
elif 条件2判断:
条件2为真的时候执行代码
...
elif 条件3判断:
条件3为真的时候执行代码
...
else:
条件1,条件2,条件3都不满足执行代码
...
如:
day = 1
if day == 1:
print('黄焖鸡')
elif day == 2:
print('面条')
elif day == 3:
print('快餐')
elif day == 4:
print('汉堡')
else:
print('不吃了')5.2.4 巢状分支
基本结构:
if 条件1判断:
条件1满足执行代码
if 条件2判断:
条件2满足执行代码
if 条件3判断:
条件1,条件2,条件3都满足执行代码
else:
条件3不满足执行代码
else:
条件2不满足执行代码
else:
条件1不满足执行代码如:
schooldoor = True
buildingdoor = True
classdoor = True
if schooldoor == True:
print('校门开了,走到教学楼')
if buildingdoor == True:
print('教学楼门开了,走到教室')
if classdoor == True:
print('教室门开了,走进教室开始学习')
else:
print('教室门没开,班长帮忙开个门')
else:
print('教学楼门没开,班主任帮忙开个门')
else:
print('校门没开,大爷帮忙开个门')
5.3 循环结构
5.3.1 while 循环
基本格式:
while 条件判断:
条件为真时,执行代码
....如: 计算0-100(包含100)所有数之和
num = 0
total = 0
while num <= 100:
total += num
num += 1
print(total)又如: 输出十行十列的星星
i = 0
while i < 10:
j = 0
while j < 10:
print('✨',end= '')
j += 1
print('\n',end='')
i += 1又如: 使用单循环输出10行10列的星星
i = 0
while i < 100:
print('✨',end = '')
if i % 10 == 9:
print()
i += 1又如: 输出十行十列星星,隔行变色
i = 0
while i < 10:
j = 0
while j < 10:
if i % 2 == 0:
print('✨',end = '')
else:
print('❤️',end = '')
j += 1
print()
i += 1又如: 使用单循环实现隔行变色
i = 0
while i < 100:
if (i // 10) % 2 == 0:
print('✨',end = '')
else:
print('❤️',end = '')
if i % 10 == 9:
print()
i += 15.3.2 死循环
基本格式:
while True:
循环内容
... 如: 判断用户输入的密码是否正确
error = False
passwd = 123
while True:
userinput = input('请输入密码:')
# 检查密码格式是否正确
for each in userinput:
if each not in '0987654321':
error = True
break
if error == True:
print('密码格式错误,请重新输入纯数字密码!')
error = False
continue
else:
if userinput == str(passwd):
print('密码正确,登录成功!')
break
else:
print('密码错误,请重新输入!')
5.3.3 for … in 循环
基本格式:
for 变量 in 容器:
循环体
...遍历除字典外的不等长的二级容器(列表,元组,集合)
for 变量1 in 容器:
for 变量2 in 变量1:
循环体
...遍历字典中的键和值:
遍历键和值
for key in dict1:
print(key,dict1[key])
遍历键
for i in xiaoming:
print(i)
#同时遍历目录和值
for key,value in dict1.items():
print(key,value)
#同时遍历目录和值
for k,v in games.items():
print(k,v)遍历等长的二级容器;
list1 = [
['a','b','c'],
['d','e','f'],
['g','h','i']
]
for x,y,z in list1:
print(x,y,z)
5.3.4遍历列表
变量 = 0
while 变量 < 4： #4表示列表个数
print(列表变量 [变量])
变量= 变量 + 1
5.3.5 break 和 continue
break: 终止循环
如: 输出0-100(包含100)的数字,遇到44则停止循环
i = 0:
while i <= 100:
if i == 44:
break
print(i)
i += 1continue: 跳过本次循环,开始下一次循环. 开始下一次循环的同时要进行判断
如: 输出0 -100(包含100)的数字,遇到任何带4的则跳过
i
最低0.47元/天 解锁文章
扫一扫
83
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
