1.Python环境的搭建
1.1运行环境 Python的安装
找到官方网站
找到download for windows
最好把add勾上，以后用第三方库会用到
安装好后打开python.exe就可以写python代码了
1.2开发环境的安装 pycharm
找到pycharm官网，往下翻找到社区版
点击download
选择安装路径
等待安装即可
创建项目
右击新建（名字必须带后缀.py，否则没法运行）
点击运行，即可运行
2.基础语法(1)
2.1 什么是常量、表达式、变量
我们可以把python当成一个计算器，做一些运算
如上图 1+2-3和1+2*3就是两个表达式，他们返回的值就是表达式的运算结果
1、 2、 3就是字面常量，+ - * / 就是运算符
熟悉C的人都知道 2/3 这种在C返回的是0，但是在Python它会返回一个小数的值
eg.给定四个分数, 67.5, 89.0, 12.9, 32.2 , 编写代码, 求这四个分数的平均数.
print((67.5 + 89.0 + 12.9 + 32.2)/4)有的时候我们计算可能要复杂一点，需要保存一下中间值，这时候就有了变量
eg、给定四个分数, 67.5, 89.0, 12.9, 32.2 , 编写代码, 求这四个分数的方差. PS: 方差的计算过程: 取每一项, 减去平均值, 计算平方, 再求和, 最后除以 (项数 - 1）
求他们的方差，所以我们需要变量来保存一下中间值
avg = (67.5 + 89.0 + 12.9 + 32.2) / 4
total = (67.5 - avg) ** 2 + (89.0 - avg) ** 2 + (12.9 - avg) ** 2 + (32.2-avg) ** 2
result = total / 3
print(result)
2.2 变量的类型
（1） 整数
和C不同，python的整数类型是无限大的没有范围
（2）浮点数
python里不分单精度和双精度，python的float基本就相当于c的双精度
ps：双精度相对于单精度就是开的内存多了，小数更精确
（3） 字符串
使用 ' ' 或者 " " 引起来的, 称为 字符串. 可以用来表示文本.
可以用len求字符串长度
字符串相加其实就是拼接操作
（4）布尔类型
布尔类型在以后进行逻辑操作时是很有用的
（5）其他
除了这些类型，我们还有list，dict，tuple等自定义类型，我们在后面会介绍
python的类型可以动态变化，和c和java都不一样。这也是个双刃剑
2.3 注释
(1) 注释行 使用 # 开头的行都是注释.
(2) 文档字符串 使用三引号引起来的称为 "文档字符串", 也可以视为是一种注释.
可以包含多行内容, 一般放在 文件/函数/类 的开头. """ 或者 ''' 均可 (等价).
2.4 输入和输出
输入输出最基本的方法就是控制台，Pycharm运行完下面的窗口就是控制台，window系统的cmd程序也是控制台
Python 使用 print 函数输出到控制台.
更多时候，我们希望字符串和变量混在一起输出，这时候我们只要在前面带一个f 后面跟着要输出的字符串，把变量内容放在{}里，就能完成混合输出，也就是格式化输出
python的输入是由 input函数完成的
input的返回值是字符串类型，如果想操作input输入的值要先进行类型转换
input函数的参数相当于你要提示用户的信息
由此可以发现，此处的+做的是字符串的拼接，并不是整数的运算
想进行整数的运算，我们需要把a和b 转换成整数类型
a = int(a)
b = int(b)
2.5 运算符
（1）算术运算符
像+ - * / % ** // 都属于算术运算符
notice 1：
/分母不能为0 ，如果分母为0 会出现抛出异常
notice 2：
整数/整数 得到一个小数，不会发生截断
notice 3:
**相当于乘方，不仅能算整数次方，也可以算小数
notice 4:
//表示地板除，向下取整
（2）关系运算符
< >= == != 都是关系运算符，他们表示操作数的关系
如果关系符合，则表达式返回True
否则，返回False
关系运算符不仅可以操作整数和浮点数，还可以比较字符串
比较字符串时就比较字母的字典序大小，何为字典序？就是从第一个字母开始比较，如果首个字母相等，就比较第二个字母，字母如果越靠前越小
对于浮点数，不可直接用 == 判断相等
因为小数在计算机的存储是有误差的
可以看到0.1 + 0.2并不等于0.3，而是带了一个小尾巴
不只是python这样 主流语言都有这样的问题 这是IEE754的标准带来的问题
（3）逻辑运算符
and or not 都为逻辑运算符
and 的两个操作数都为真，才为真，一个为假，就为假
or的两个操作数一个为真就是真，两个都不为真才为假
not 逻辑取反，如果not的操作数本身为真，则加了not为假
python不同于其他语言特殊的写法
a<b and b<c 可以直接写成a<b<c
关于短路求值
对于 and, 如果左侧表达式为 False, 则整体一定为 False, 右侧表达式不再执行. 对于 or, 如果左侧表达式为 True, 则整体一定为 True, 右侧表达式不再执行.
（4）赋值运算符
链式赋值
a = b = 10
多元赋值
a,b = 10,20
eg：交换两个变量
基础写法
a = 10
b = 20
tmp = a
a = b
b = tmp
基于多元赋值
a = 10
b = 20
a,b = b,a复合赋值运算符
Python 还有一些 复合赋值运算符. 例如 += -= *= /= %= 其中 a += 1 等价于 a = a + 1 . 其他复合赋值运算符也是同理.
3.基础语法（2）
3.1 条件语句
条件语句又叫分支语句，表示了接下来的逻辑会有几种走向
Python中使用If、else来表示条件语句
if，else命中条件后执行的“语句块”，要用缩进来表示
if expression:
do_something1
else:
do_something2
next_thing如果expression值为True，则执行do_something1
否则执行do_something2
if expression1:
do_something1
elif expression2:
do_something2
else:
do_something3如果expression1的值为True，则执行do_something1
如果expression2的值为True，则执行do_something2
否则执行3
eg：输入 1 表示愿意认真学习, 输入 2 表示躺平摆烂.
choice = input("输入1表示认真学习，输入2表示躺平摆烂")
if choice == 1:
print('你会找到好工作！')
elif choice == 2:
print('你可能毕业就失业了！')
else:
print('你的输入有误')eg:输入一个整数, 判定是否是奇数
a = int(input('请输入一个整数'))
if a%2 == 0:
print('偶数')
else:
print('奇数')
eg:输入一个整数，判断它是正数还是负数
a = int(input('请输入一个整数'))
if a > 0:
print('正数')
elif a < 0:
print('负数')
else:
print('是0')
eg:判定年份是否是闰年
year = int(input('请输入年份'))
if year % 100 == 0:
# 判断世纪闰年
if year % 400 == 0:
print('闰年')
else:
print('平年')
else:
# 判断普通闰年
if year % 4 == 0:
print('闰年')
else:
print('平年')
简短版本
simple edition
year = int(input('请输入年份'))
if (year % 100 != 0 and year % 4 == 0) or year % 400 == 0:
print('闰年')
else:
print('平年')
空语句pass
代码示例
eg:输入一个数字，如果是1，打印'hello'
a = int(input('请输入一个数字'))
if a == 1:
print('hello')
等价于
a = int(input('请输入一个数字')
if a != 1:
pass
else
print('hello')此时pass只是占了一个位置，防止分支因为没有语句而报错
3.2 循环语句
(1)while 循环
语法体
while 条件:
循环体
num = 1
while num <= 10:
print(num)
num += 1
eg:计算1到100的和
sum = 0
num = 1
while num <= 100:
sum += num
num += 1
print(sum)eg:计算5的阶乘
num = 1
result = 1
while num <= 5:
result *= num
num += 1
print(result)eg:求1! + 2! + 3! + 4! + 5!
num = 1
sum = 0
while num <= 5:
factorResult = 1
i = 1
while i <= num:
factorResult *= i
i += 1
sum += factorResult
num += 1
print(sum)(2)for循环
for循环的语法格式
for 循环变量 in 可迭代对象
所谓的可迭代对象就是说，内部含有多个元素，能把这些元素一一取出来的特殊变量
eg: 打印1到10
for i in range(1,11)
print(i)
range函数可以生成一个可迭代对象，生成的范围是1到11左闭右开区间，也就是1到10十个元素
eg：打印2，4，6，8，10
for i in range(2,12,2)
print(i)通过range的步长，可以指定迭代时的步长，也就是让一次循环变量加几
eg:打印10到1
for i in range(10,0,-1)
print(i)步长可以设置为负数
eg:求1到100的和
sum = 0
for i in range(1,101)
sum += i
print(sum)
接下来我们介绍一下cotinue 和 break
continue 表示结束这次循环，进入下次循环
eg:模拟吃包子，吃到第三个包子吃出个虫
for i in range(1,6):
if i == 3:
continue
print(f'吃完第{i}个包子')
break表示结束循环
eg：模拟吃包子，吃到第三个包子迟到半只虫，不吃了
for i in range(1,6):
if i == 3:
break
print(f'吃完第{i}个包子')eg:输入若干个数字，求平均值
sum = 0
count = 0
while True:
num = input('请输入数字')
if num == ';':
break
num = float(num)
sum += num
count += 1
print(sum/count)(3)人生重开模拟器小程序
4.基础语法（3）
4.1 函数
编程中的函数，是一种可以重复使用的代码片段，可以提高代码效率
eg:求数列的和，不适用函数
# 求100到200的和
sum = 0
for i in range(100,201):
sum += i
print(sum)
# 求300到400
sum = 0
for i in range(300,401)
sum += i
print(sum)
像这种代码很相似，我们可以把他提取出来做成一个函数，如果需要的话直接调用这个函数
eg: 求数列的和，使用函数
# 定义函数
def calcSum(begin,end)
sum = 0
for i in range(begin,end + 1)
sum += i
print(sum)
#调用函数
calcSum(1,100)
calcSum(200,300)由此，大家可以看到定义函数的语法格式为
def 函数名(形参列表):
函数体
return 返回值
test3()
def test3:
print('hello')
# 像这样，还没执行到定义，就先调用了，如此就会报错关于形参和实参，python和c语言是一样的
def calcSum(beg,end):
sum = 0
for i in range(beg,end + 1):
sum += i
print(sum)
calcSum(1,100)也可以写成
def calcSum(beg,end):
sum = 0
for i in range(beg,end):
sum += i
return sum
result = calcSum(1,100)
print(result)我们会比较倾向于第二种写法，我们有个原则，即逻辑与用户交互分离，如果用第一种写法的话，那我们以后要进行诸如把计算结果存在文件里，或者发送到网络上，就会出现问题，所以我们一般用第二种写法，函数体只进行逻辑运算，在函数外进行用户交互
一个函数中是可以有多个return的语句的
eg:判断是否为奇数
def isOdd(num):
if num % 2 == 0:
return False
else:
retirm True
result = isOdd(10)
print(result)
也可以直接写成下图这样
def isOdd(num):
if num % 2 == 0:
return True
return False如果num是偶数，就直接进入到分支，在该分支里return回到调用的地方了 也不会往下执行了，所以我们在这里可以不写else
一个函数是可以一次返回多个返回值的,使用，来分割不同返回值
def getPoint()
x = 10
y = 20
return x , y
a,b = getPoint()如果只想返回部分返回值，则可以用_来忽略不想要的返回值
def getPoint()
x = 10
y = 20
return x , y
_ , b = getPoint()def getPoint():
x = 10
y = 20
return x,y
x,y = getPoint()
观察上面的代码，可以发现函数体里有x,y,外面也有x,y
但是这两组变量并不是 同一个变量
只是恰好名字一样了
在函数定义的变量，一旦超出范围，就不能在使用了，否则会报错
def getPoint()
x = 10
y = 20
return x,y
print (x,y)
在不同的作用域中，允许存在同名变量，他们虽然名字相同，但确实不是同一变量
x = 20
def test():
x = 10
print(f'函数内部x = {x}')
test()
print(f'函数外部 x = {x}')
在函数内部定义的变量，就称为局部变量，在函数外部定义的变量就称为全局变量
如果函数内部访问局部变量找不到，就会去全局作用域里找
x = 20
def test()
print(f'x = {x}')
test()
如果想要在函数内部，修改函数外的值，这时候我们就要引入一个global关键字声明
x = 20
def test():
global x
x = 10
print(f'函数内部 x = {x}')
test()
print(f'函数外部 x = {x}‘)
如果此处没有globa,则函数内的x = 10就会被认作是创建一个函数内的局部变量，这样就和全局变量不相关了
把一个函数的返回值作为另一个函数的参数，这种操作叫做函数的链式调用
def isOdd(num):
if num % 2 == 0:
return False
return True
result = isOdd(10)
print(result)
# 也可以直接写成
print(isOdd(10))
函数的递归 函数的递归是一种特殊的嵌套调用，指的是函数调用它自己
函数内部还可以调用其他函数，这种操作叫做嵌套调用
eg：递归计算 5！
def factor(n):
if n == 1:
return 1
return n * factor(n-1)
result = factor(5)
print(result)递归代码必须存在结束条件，比如说 n = 1的时候，递归结束
每次递归的时候要保证实参接近结束条件
Python的函数可以给形参指定默认值，带有默认值的参数，在调用的时候可以不传参
eg:计算两个数字的和
def Add(x,y,debug = false):
if debug:
print(f'调试信息x = {x},y = {y}')
return x + y
print(Add(10,20))
print(Add(10,20,True)带有默认值的参数应该放在不带有默认值的参数的后面
在调用函数的时候，需要给函数指定形参，一般情况下是按照形参的顺序，在Python里，还可以通过关键字参数来调整传参顺序
def test(x,y):
print(f'x = {x}')
print(f'y = {y}')
test(x = 10, y = 20)
test(y = 20,x = 10)4.2列表和元组
在编程中，经常需要变量来保存数据
有时候如果数据比较多，我们可以用列表和元组来一次性表示多个数据
元组和列表是非常相似的，只不过列表在创建好之后里面的元素是可以修改的，但是元组里的元素是不能修改的
如何创建列表，创建列表有两个方式，[ ]表示一个空的列表
alist = [ ]
alist = list()
print(type(alist))
如果需要初始值，可以在[ ]写入初始值
可以直接用print打印列表的内容
列表中存放的元素可以是不同类型的元素
alist = [2,'hello',2.55]
print(alist)访问下标，可以用下标访问操作符[]来获取到列表中的任意元素
下标是从0开始计数的
alist = [1,2,3,4]
alist[2]
通过下标不仅能读取元素的值，还能修改元素的值
alist = [1,2,3,4]
alist[2] = 100
print(alist)如果下标超出列表的有效范围，则会抛出异常
因为下标是从0开始的，因此下标的有效范围是[0,列表长度-1]，使用len可以获得元素个数
alist = [1,2,3,4]
print(len(alist))下标可以写成负数，表示倒数第几个元素
alist[-1] == alist[len{alist) - 1]切片操作
通过下标是取出其中的一个元素，而通过切片可以取出一系列连续的元素
使用[ : ]进行切片
alist = [1,2,3,4]
print(alist[1:3])
[1:3]表示的是从下标1到下标3的左闭右开区间，也就是从下标为1到下标为2的元素
切片操作也可以忽略前后边界.
alist = [1,2,3,4]
print(alist[1: ]) # 省略后边界，表示从下标为1的元素一直取到最后一个元素
print(alist[ :-1] # 省略前边界，表示从开头开始获取
print(alist[ : ]) # 省略前后边界，表示取出所有元素
切片操作也可以指定步长，所谓步长，就是说取出一个元素后，下标自增几步
alist = [1,2,3,4,5,6,7,8,9,10]
print(alist[::1])
print(alist[::2])
print(alist[::3])
print(alist[::5])
切片操作的步长也可以是负数
alist = [1,2,3,4,5,6,7,8,9,10]
print(alist[::-1])
print(alist[::-2])
print(alist[::-3])
print(alist[::-5])
如果切片中填写的数字越界了，并不会有负面效果，只是会尽可能的取到能取到的元素
那么，我们该如何遍历列表元素呢？
遍历，就是把元素一个个的取出来，然后再分别进行处理
遍历最简单的办法就是for 循环
alist = [1,2,3,4]
for elem in alist:
print(elem)
也可以用for按照范围生成下标，按下标访问
alist = [1,2,3,4]
for i in range(0,len(alist)):
print(alist[i])
除此之外，还可以使用while 循环，手动控制下标的变化
alist = [1,2,3,4]
i = 0
while i < len(alist):
print(alist[i])
i += 1
那么，如何新增元素呢？
这时候就要引入我们的方法了，那么什么是方法呢，方法就是函数，只不过它需要依赖于对象，像我们新增元素的方法就是append 和 insert
append 就相当于咱们数据结构里的尾插
alist = [1,2,3,4]
alist.append('hello')
print(alist)
而insert 则可以指定要插入的下标
alist = [1,2,3,4]
alist.insert(1,'hello')
print(alist)insert的第一个参数就是要插入元素的下标，第二个参数就是要插入的元素
学完了新增元素的方法，那么紧接着我们学一下如何查找元素
第一种是使用in 操作符，判断元素是否在列表中存在，返回值是布尔类型
alist = [1,2,3,4]
print(2 in alist)
print(10 in alist)
另一种方法就是使用index查找元素在列表里的下标，如果存在，会返回一个整数，如果不存在，则会抛出异常
alist = [1,2,3,4]
print(alist.index(2))
print(alist.index(10))删除，使用pop方法删除最末尾元素
alist = [1,2,3,4]
alist.pop()
print(alist)
此外，pop也能指定下标删除元素.
alist = [1,2,3,4]
alist.pop(2)
print(alist)
使用remove 方法，可以按照值来删除元素
.
alist = [1,2,3,4]
alist.remove(2)
print(alist)
连接列表
使用+可以把两个列表拼接在一起
此时的+会生成一个新的列表，而不会影响原来的列表
alist = [1,2,3,4]
blist = [5,6,7]
print(alist + blist)另一个方法就是extend方法，可以把后一个列表拼接到前一个列表后面，会改变前一个列表，而不会改变后面拼接的列表
最后就是关于元组的知识
元组和列表的功能基本上是一致的
元组使用（）来表示
atuple = ()
atuple = tuple()
元组不可以修改 里面的元素，而列表是可以修改的
列表里面读取的操作，列表里使用的读取元素的方法对元组也是适用的，比如说访问下标，切片 遍历，in ,index ,+等，都是支持的，而列表里新增元素，删除元素，extend在元组里是不适用的
另外，元组在python中很多时候是默认的集合类型，比如说，当一个函数返回多个值的时候
def getPoint():
return 10,20
result = getpoint()
print(type(result))
既然有了列表了，那我们为什么还需要元组呢？
比如说你有一个列表，你要传到一个函数里，那么这个函数会不会把这个列表打乱呢？为了防止元素被打乱，你可以用元组
另一方面，下一节我们字典的键要求必须是可哈希对象，也就是不可变的，元组是不可变的也就是可哈希的而列表不是也就不行
扫一扫
9730
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
