| ❤️欢迎来到我的博客❤️ |
要想能够进行 Python 开发, 就需要搭建好 Python 的环境
需要安装的环境主要是两个部分:
- 运行环境: Python
- 开发环境: PyCharm
安装Python运行环境
下载
以Windows为例： 先找到Python官网
点这去官网
然后下载安装包
安装
下载完之后打开Python安装包
安装完成后在开始菜单中就能找到
点击第二个Python 3.13（64-bit） 就会出现一个控制台，可以完成一些基础的工作：
这样我们的运行环境就已经安装完成了
安装开发环境PyCharm
下载
点击去官网
安装
下载完成后打开安装包
修改安装路径 - 下一步
之后点击下一步 - 安装
安装完成后，可以在桌面快捷方式启动，也可以在开始菜单中找到
打开之后点击下一步
配置
我们新建一个项目：之后来到这个页面
最后点击创建即可
创建Python文件，就可以编写代码了
这样我们的开发环境也安装完成了
基础语法
基础语法只会讲解与C语言有区别的语法
注：Python中不支持 ++ – 这样的自增自减操作，如：a++ \ a–
运算符
**n 表示乘方运算，**2即为求平方
print(2**3)
// 表示地板除法（取整除法），会对计算的结果进行向下取整
print(7 // 2)
print(-7 // 2)
变量
注意: 和 C++ / java 等语言不同，Python 变量的类型不需要显式指定，而是在赋值的时候确定的
Python 中的 float就是双精度浮点数等同于 C+ + / java 里的 double
Python程序运行过程中，变量的类型可能会发生改变，如下：
a = 10
print(type (a))a = 1.5
print(type (a))# 引号使用'或者"都是可以的
a = 'a'
print(type (a))a = False
print(type (a))
字符串相关
len = > length（长度）
a = 'hello'print(len(a))
如果字符串里面包含了 双引号 表示字符串就可以用 单引号 引起来
如果字符串里面包含了 单引号 表示字符串就可以使用 双引号 引起来
a = 'HAHAHA "hahaha"'
print(a)
如果同时有单引号，和双引号，咋办??
Python 中还有一种字符串，使用 三引号 表示~’ ’ '或者" " "
a = ''' "HAHAHA" 'hahaha' '''
print(a)
字符串拼接
a = 'hello'
b = ' world'print(a + b)
形如这样的代码，就是"字符串拼接"
也就是把后面的字符串拼接到前一个字符串的未尾
得到了一个更大的字符串(对于原来的 a1，a2 是没有影响的)
注：不能把字符串和数字混合相加
在Python中报错有两种情况:
1.语法错误，在程序运行之前，Python解释器，就能把错误识别出来
2.运行错误，在程序运行之前，识别不了的，必须要执行到对应的代码，才能发现问题
前面说到不能把字符串和数字混合相加：因此这种也是不可以的
a = 10
print("a = " + a)
如果想打印a = 10则需要修改代码：
a = 10
print(f"a = {a}")
print(f"a = {a}“)
这个语法，是叫做“格式化字符串”
f-string
此处的f表示"format”
此时就可以使用 {} 这样的语法，往字符串里嵌入变量或者表达式
字符串比较
字符串的比较是按照字典序的：
字典序！
在英文词典上，单词是按照一定的顺序来排列的~
先看首字母在字母表上的顺序谁小，谁就排在前面
如果首字母相同，依次比较第二个字母，第三个字母…
字符串在词典上越靠前，就越小，越靠后，就越大
针对中文进行字符串大小比较，是没有意义的
至少按照默认的字典序来说，是没意义的
在计算机里，表示中文，其实是用多个字节构成的一个比较大的数字来进行比较
a = 'hello'
b = 'world'print(a < b)
print(a > b)
print(a <= b)
print(a >= b)
print(a == b)
print(a != b)
浮点数比较
针对浮点数来说，使用 == 比较相等，存在一定的风险
因为浮点数在内存中的存储和表示，是可能存在误差的这样的误差在进行算术运算的时候就可能被放大，从而导致 == 的判定出现误判
比如下面这种场景：
print(0.1 + 0.2 == 0.3)print(0.1)
print(0.2)
print(0.1 + 0.2)
print(0.3)
正确的比较浮点数相等：
作差，看差值是否小于预期的误差范围
a = 0.1 + 0.2
b = 0.3# 判断a - b 的差是否在预期误差以内
print(- 0.000001 < (a - b) < 0.000001)
Python中支持这种连续小于的写法
判定a-b既是 小于 0.000001 又是 大于 -0.000001
输入输出
input返回的值,其实是一个 str
如果只是单纯的拿到用户的输入，然后打印，此时就按照str打印即可
如果需要根据用户输入的内容进行算术计算，此时就需要先把读到的str->int
可以使用int()
a = input('请输入第一个数字->')
b = input('请输入第二个数字->')print(f'两数之和为： {a + b}')
#类型转换
a = int(a)
b = int(b)print(f'两数之和为： {a + b}')
逻辑运算符
逻辑运算符中的重要细节：短路求值
对于and操作来说，如果左侧表达式为False，那么整体的值一定是False，右侧表达式不求值
对于or操作来说，如果左侧表达式为True，那么整体的值一定是True，右侧表达式不求值
a = 10
b = 20
c = 30print(a < b and b < c)
print(a < b and b > c)print(a > b or b < c)
print(a < b or b > c)
print(a > b or b > c)print(not a < b)
print(not a > b)# 左侧为False，整个表达式为False，右侧不再求值所以不会报错
print(a > b and 10 / 0 == 1)
多元赋值
传统交换方法：
a = 10
b = 20
tmp = a
a = b
b = tmpprint(a,b)
和传统交换不同，Python可以直接使用多元赋值，如下：
a = 10
b = 20
print(a,b)# 多元赋值操作
a,b = b,a
print(a,b)
条件语句
注意：Python中的条件语句写法，和很多编程语言不太一样 if后面的条件表达式，没有（)，使用：作为结尾，
if/else命中条件后要执行的”语句块”，使用缩进（通常是4个空格或者1个tab)来表示，而不是{}
对于多条件分支,不是写作else if,而是elif(合体了)
choice = input("选择1 或者 2->")if choice == '1':print("选择了1")
elif choice == '2':print("选择了2")
else:print("你输入的数字有误")
a = input("请输入一个整数->")if a == '1':print("aaaa")print("bbbb")
a = input("请输入一个整数->")if a == '1':print("aaaa")
print("bbbb")
在Python中，缩进表示代码块
在if，else，elif，while，for…需要跟上代码块的部分，都是需要使用缩进来表示的
如下代码：
a = input("请输入第一个整数->")
b = input("请输入第二个整数->")if a == '1':if b == '2':print("aaa")print("bbb")
print("ccc")两个条件都满足，才会打印aaa，因为打印aaa的语句有两级缩进，相当于是if b == ‘2’ 条件内部的代码块
第一个条件满足，就会打印bbb，因为打印bbb的语句只有一级缩进，相当于是if b ==’ 1’ 条件内部的代码块
两个条件即使都不满足，也能打印ccc，因为打印ccc的语句，没有缩进，相当于和两个if都无关
空语句
a = input("请输入一个整数->")if a == '1':# 啥都不做
else:print("hello")
虽然希望条件满足的时候，啥都不做，但是由于Python对于语法格式
尤其是缩进和代码块要求较高，所以如果啥都不写（只写个注释）是不符合语法要求的
这种情况，可以使用空语句进行占位
pass
a = input("请输入一个整数->")if a == '1':# 啥都不做pass
else:print("hello")
循环语句
while
语法格式：
while 条件:循环体
- 条件为真，则执行循环体代码
- 条件为假，则结束循环
# 打印 1 - 10
num = 1
while num <= 10:print(num)num += 1
# 求 1! + 2 ! + 3! + 4! + 5!
num = 1
sum = 0
while num <= 5:factorResult = 1i = 1while i <= num:factorResult *= ii += 1sum += factorResultnum += 1print(f'sum = {sum}')
for循环
for 循环变量 in 可迭代对象:循环体
可迭代对象：特殊的变量，内部包含了很多其他的值
注意:
python的for和其他语言不同，没有“初始化语句”，"循环条件判定语句”，"循环变量更新语句”，而是更加简单
所谓的“可迭代对象”，指的是“内部包含多个元素，能一个一个把元素取出来的特殊变量”
# 打印 1 - 10
for i in range(1,11):print(i)
range是一个内建函数
起到的效果就是得到一个”可迭代对象“
这个可选代对象中就包含了一系列的整数
range(beg, end) => [beg, end)
range还提供了第三个参数，表示”步长“默认的步长是‘1’
# 打印 2 4 6 8 10
for i in range(2,12,2):#范围[2，12) 步长：2print(i)
# 打印 10 8 6 4 2
for i in range(10,0,-2):#范围[10，0) 步长：-2print(i)
continue和break
for i in range(1,6):if i == 3:continueprint(i)
for i in range(1,6):if i == 3:breakprint(i)
函数
创建函数/定义函数
def 函数名（形参列表)：函数体return 返回值
调用函数/使用函数
函数名（实参列表) //不考虑返回值
返回值 ＝ 函数名（实参列表) //考虑返回值
# 定义一个求和函数
def calcSum(beg,end):Sum = 0for i in range(beg, end + 1):Sum += iprint(Sum)# 调用函数
# 求1 - 100的和
calcSum(1,100)
# 求300 - 400的和
calcSum(300,400)
# 求 1 - 1000的和
calcSum(1,1000)
def add(x, y):return x + yprint(add(10,20))
print(add('hello',' world'))
在python中函数的形参没有类型要求，但是得保证传入的形参数据在函数中能被正确运算
函数多返回值 / 多元赋值
函数可以返回多个值，我们也可以通过多元赋值给多个变量赋值
def getPoint():x = 10y = 20return x, y# 多元赋值
a, b = getPoint()print(a,b)
如果只想要获取函数中的一部分返回值，则可以使用 _ 来进行占位
def getPoint():x = 10y = 20return x, ya = 5# 不要x的值，只要y的值
_,b = getPoint()print(a,b)
链式调用
用一个函数的返回值，作为另一个函数的参数
def isOdd(num):if num % 2 == 0:return Falsereturn Truedef add(x,y):return x + y# 链式调用
# 先执行add(参数为5，5)
# 之后用add的返回值(10)调用isOdd
# 最后再用isOdd的返回值(False)调用print
print(isOdd(add(5,5)))
嵌套调用
# 嵌套调用
def a():print('函数 a')def b():print('函数 b')a()def c():print('函数 c')b()def d():print('函数 d')c()d()
函数形参的默认值
通过默认值可以让函数的设计更灵活
比如我们希望在函数内部加上打印信息，方便我们调试，但是我们只希望在debug下能显示调试信息，则可以这样定义函数
def add(x, y, debug = False):if debug:print(f'x = {x}, y = {y}')return x + yresult = add(10,20 , True)
print(result)
要求带有默认值的形参，得在形参列表的后面而不能在前面/中间！
关键字传参
def test(x, y):print(f'x = {x}')print(f'y = {y}')test(y = 20,x = 10)
位置参数和关键字参数还能混着用，只不过混着用的时候要求位置参数在前
关键字参数在后
关键字参数，一般也就是搭配默认参数来使用的
一个函数，可以提供很多的参数，来实现对这个函数的内部功能做出一些调整设定
为了降低调用者的使用成本，就可以把大部分参数设定出默认值
当调用者需要调整其中的一部分参数的时候，就可以搭配关键字参数来进行操作
变量的作用域
在函数里尝试读取全局变量，是可以的！
当函数中尝试访问某个变量的时候，会先尝试在局部变量中查找，如果找到，就直接访问如果没找到，就会往上一级作用域中进行查找
# 全局变量，在整个程序中都有效
x = 10def test():# 局部变量，只在函数内部中有效x = 20print(f'函数内部：{x}')test()
print(f'函数外部：{x} ')
可以通过 global 和 nonlocal 关键字显式修改变量的作用域
# 全局变量，在整个程序中都有效
x = 10# 使用这个函数，把全局变量 x 改成 20
def test():global xx = 20test()
print(f'x = {x}')
没有global，此时就会把x= 20当做是在函数内部创建了一个局部变量x而实际上是要修改全局变量x
为了让函数里面知道x是个全局变量就使用global关键字先声明一下
for i in range(1,11):print(i)print('------------------')
print(i)
在Python中只有函数和类才会影响到变量的作用域
控制结构（if / for / while）不会创建新作用域（变量会共享当前作用域）
列表和元组
变量就是内存空间，用来表示 / 存储数据
如果表示的数据少，直接定义几个变量就行了
也有时候要表示的数据比较多
Python，列表和元组就类似与其他编程语言的 “数组”
列表和元组大部分功能都是差不多，但是有一个功能是非常明显的区别：
- 列表是可变的：创建好了之后，随时能修改
- 元组是不可变的：创建好了之后改不了，要想修改只能丢弃旧的，搞个新的
# 创建列表# 1.直接使用字面值来创建
# []就表示一个空的列表
a = []
print(type(a))# 2.使用list()来创建
b = list()
print(type(b))
C++/Java里面要求一个数组里只能存相同类型的变量
Python里的列表则无限制，放啥类型都可以
# 可以在创建列表的时候在 []中指定列表的初始值
# 元素之间使用 , 来分割
a = [1, 2, 3, 4]
print(a)# 可以在同一个列表中放不同的类型
a = [1, 'hello', True, [1, 2, 3]]
print(a)
负数下标访问
在Python中的下标，可以写成负数
# Python中的下标，可以写成负数
# 例如写成 -1， 就等价于len(a) - 1
a = [1, 2, 3, 4]
print(a[len(a) - 1])
# 也可以理解为: -1 就是倒数第一个元素
print(a[-1])
切片
# 1. 切片操作的基本使用
a = [1, 2, 3, 4]
print(a[1:3])
切片操作中，[] 里面有两个数字，表示了一段区间
1表示开始区间的下标
3表示结束区间的下标
1:3
取到下标为1一直到下标为3的元素
（包含1，不包含3)
[1, 3)
# 使用切片得时候，省略边界
a = [1, 2, 3, 4]
print(a[1:])
省略后边界，意思是从开始位置，一直取到整个列表结束
# 省略前边界
a = [1, 2, 3, 4]
print(a[:2])
省略前边界，意思是从列表 0 号元素开始取，一直取到结束的后边界
# 表示从开头一直取到倒数第一个元素（不包括）
a = [1, 2, 3, 4]
print(a[:-1])
此处切片中的下标，也可以写成负数
a = [1, 2, 3, 4]
print(a[:])
也可以把开始边界和结束边界都省略掉
切片操作是一个比较高效的操作，进行切片的时候，只是取出了原有列表中的一个部分，并不涉及到”数据的拷贝
假设有一个很大的列表，进行切片，切片的范围也很大，即使如此，切片操作仍然非常高效
切片操作还可以指定步长
# 带有步长的切片操作
a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
# 这里多加一个:，再多加一个整数，这个数字就是步长
# 每隔一个元素，来取一下列表中的元素
print(a[::1])# 步长修改为2
print(a[::2])# 步长修改为3
print(a[::3])print(a[1:-1:2])# 步长也可为负数，步长为负数的时候，就是从后往前取
print(a[::-2])
tips：当切片中的范围超出有效下标之后，不会出现异常，而是尽可能的把符合的元素给获取到
列表的遍历
# 1.使用for循环来遍历列表
a = [1, 2, 3, 4, 5]
# elem代表列表里面的每个元素
for elem in a:print(elem)
下面这种方式可以修改数值，上面的则不行
# 2.使用for循环遍历(使用下标)
a = [1, 2, 3, 4, 5]
for i in range(0,len(a)):print(a[i])for i in range(0,len(a)):a[i] += 10print(a)
# 3.使用while循环(使用下标)
a = [1, 2, 3, 4, 5]
i = 0
while i < len(a):print(a[i])i += 1
列表的插入
# 1.使用append往列表末尾新增一个元素
a = [1, 2, 3, 4]
a.append(5)
a.append('hello')
print(a)
# 2.还可以使用insert，往列表任意位置新增元素
a = [1, 2, 3, 4, 5]
# 往下标为 1 的位置插入'hello'
a.insert(1,'hello')
print(a)
列表的查找和删除
查找元素
# 1.使用 in 来判定某个元素是否在列表中存在
a = [1, 2, 3, 4]# 判断 1 是否在列表a中
print(1 in a)
# 判断 10 是否在列表a中
print(10 in a)# 判断 1 是否不在列表a中
print(1 not in a)# 判断 10 是否不在列表a中
print(10 not in a)
# 2.使用 index，来判定，当前元素在列表中的位置，得到的是一个下标
a = [1, 2, 3, 4]
print(a.index(2))
print(a.index(3))
print(a.index(10))
在Python中，当元素不存在（找不到）的时候并不会返回 -1 ，而是直接抛出异常
删除元素
# 1.使用 pop 删除列表中最末尾的元素
a = [1, 2, 3, 4]
a.pop()
print(a)# 2.使用 pop 删除任意位置的元素(pop可以传递一个下标)
a = [1, 2, 3, 4]
a.pop(1)
print(a)# 3.使用 remove 按照值来删除
a = ['aa', 'bb', 'cc', 'dd']
a.remove('cc')
print(a)
列表的拼接
# 1. 使用 + 针对两个列表进行拼接
a = [1, 2, 3, 4]
b = [5, 6, 7, 8]
c = a + b
print(c)
使用 + 号拼接，只是针对当前生成了一个更大的列表，原有列表的内容是不变的
# 2. 使用 extend 来进行拼接
# 这个拼接是把后一个列表的内容拼接到前一个列表里
a = [1, 2, 3, 4]
b = [5, 6, 7, 8]
c = a.extend(b)
print(a)
print(b)
print(c)
# 3. 使用 += 来进行拼接
a = [1, 2, 3, 4]
b = [5, 6, 7 ,8]
a += b
print(a)
a+=b
等价于 a= a+ b（多了三步操作：1.构造新的大列表 2.把大的列表的值赋给a 3.把 a 的旧值释放）
a.extend(b)则是直接把 b 的内容拼到了 a 的后面（高效）
元组
# 1. 创建元组
a = ()
b = tuple()
print(type(a))
print(type(b))a = (1, 2, 3, 4)
print(a)b = (1, 2, 'hello', True, [])
print(b)
元组的增删查改操作和列表一致（元组的操作都是只读的，也就是说不可以修改，有些修改性质的操作元组不支持）
tips：当进行多元赋值的时候，其实本质上是按照元组的方式来进行工作的
a = (1, 2, 3, 4)
a[0] = 100
字典
字典的创建
# 1.创建字典
a = {}
b = dict()
print(type(a))
print(type(b))# 2.创建字典的同时创建初始值
a = {'id': 1,'name': 'zhangsan',
}
字典a中，包含了两个键值对：
1.id:1 ：key就是’id’， value就是1
2.‘name’:‘zhangsan’ ：key: ‘name’ ，value : ‘zhangsan’
字典查找key
a = {'id': 1,'name': 'zhangsan',# key也可以是整数100: 'lisi'
}# 使用in来判断某个key是否在字典中存在
print('id' in a)
print('classid' in a)# not in 来判断 key 在字典中不存在
print('id' not in a)
print('classid' not in a)# 使用 [ ] 来根据 key 获取到value
print(a['id'])
print(a['name'])
print(a[100])
in只是判定key是否存在，和value无关
对于字典来说使用 in 或 [ ] 来获取value都是非常高效的操作
对于列表来说，使用 in 是比较低效的（需要把整个列表遍历一遍），而使用 [ ]是比较高效的
注：字典中的 key 不能重复
字典的增删查改
字典的各种操作都是针对 key 来进行的（新增 / 删除 / 获取value / 修改value）
# 1. 在字典中新增元素，使用 [ ] 来进行
a = {'id': 1,'name': 'zhangsan',
}# 这个操作就是往字典中插入新的键值对
# 如果 key 不存在，往里写入，相当于新增键值对
# 如果 key 存在，往里写入，则根据 key 修改 value
a['score'] = 90 # 新增
print(a)# 2. 在字典中根据 key 修改 value，也是使用 [ ]
a['score'] = 100 # 修改
print(a)# 3. 使用 pop 方法，根据 key 来删除键值对
a.pop('score')
print(a)
字典的遍历
遍历指的就是能够把一个可选代对象，里面包含的元素依次的取出来，并进行一些操作，整个过程要求不重不漏
字典被设计出来的初衷，不是为了实现遍历，而是为了增删查改（能够以“常数级”时间复杂度来完成增删查改）
字典是哈希表，进行增删改查操作，效率都是非常高的
而字典的遍历则效率就要差一些
keys：获取到字典中的所有key
values：获取到字典中的所有value
items：获取到字典中的所有键值对
# 直接使用 for 循环来遍历字典
a = {'id': 1,'name': 'zhangsan','score': 90
}# 把每个键值对都取出来，并且获取 key 和 value
for key in a:print(key, a[key])print(a.keys()) # 返回的结果是一个自定义类型(也可以直接当作列表来使用)
print(a.values()) # 同上
print(a.items()) # 首先是一个列表一样的结构，里面每个元素又是一个元组，元组里面包含了键和值# 也可以通过上述函数来获取想要的值
for key, value in a.items():print(key, value)
合法的 key 类型
不是所有的类型都可以作为字典的key
字典本质上是一个哈希表，哈希表的key要求是”可哈希的”，也就是可以计算出一个哈希值
可以使用hash函数计算某个对象的哈希值
但凡能够计算出哈希值的类型，都可以作为字典的key
# 使用 hash 函数计算出一个变量的哈希值
print(hash(0))
print(hash(3.14))
print(hash('hello'))
print(hash(True))
print(hash((1, 2, 3)))
# 以上都是有哈希值的(可以作为字典的 key)# 有的类型是不能计算哈希值的
print(hash([1, 2, 3])) # 不可哈希
print(hash({ })) # 不可哈希
不可变的对象，一般就是可哈希的
可变的对象，一般就是不可哈希的
字典，列表，元组都是 Python 中非常常用的内置类型，相比于int,str,float…
它们内部可以再包含其他元素
以上就是本篇文章的全部内容了，希望大家看完能有所收获
| ❤️创作不易，点个赞吧❤️ |