一、Python基础语法
1、输入与输出
（1）输入示例
# 变量的输入，直接使用input输入的是字符串
a = input()
# 输入其他类型，在input()函数前面加上强制类型转换
# 整型
a = int(input())
# 长整型
a = long(input())
# 浮点型
a = float(input())
a = double(input())
（2）输出示例
# 输出一个变量a
print(a)
# Python的print自带换行，若无需换行需配置end参数
# 多参数同一行输出，直接print多参数名称，中间逗号隔开
# 一行输出a，b两个变量，并用空格分割
print(a, b, end=' ')2、变量的定义
# Python的变量定义需要带上变量的初始化
# 定义字符串，下面的方式即定义了一个空字符串
str = ''
# 定义整型
a = 0
# 定义浮点型
a = 0.003、运算符
# 数值类型运算(包括整型以及浮点型)
# 加法
c = a + b
# 减法
c = a - b
# 乘法
c = a * b
# 除法
c = a / b
# 求绝对值
a = abs(a)
# 取余运算(求两个整数除法运算之后的余数)
c = divmod(a, b)
# 幂运算
c = pow(2, 3) # 表示2的3次方
# 字符串类型运算
# 字符串的加法(即字符串的拼接)
str3 = str1 + str2 # 得到的str3是将str1拼接到str2后面
# 求字符串长度
k = len(str)
# 统计某个字符在字符串中出现的次数
str = 'aaaabbbccc'
num = str.cout('a')
print(num)
# 结果为5
# 查找字符串
str = 'abcad'
is = str.find('ab')
print(is)
# 输出结果为0
# find()函数查询字符串中是否含有某个子串，若不存在返回-1，若存在，返回子串在原字符串中开始的下标
4、组合数据类型
? ? 由于后面的循环与判断主要控制的便是这些组合数据类型，故此处先讲简介组合数据类型后分析控制结构
（1）元组
# 元组
"""
特点：元组不可以被修改，元组建立后即确定了元组的长度以及每个位置的值（即长度和值不可修改）。
"""
# 元组的建立
# 形式一
tuple1 = tuple((1, 2, 3))
# 形式二（推荐）
tuple2 = (1, 2, 3, 4, 5, 6, 7, 8, 9)
# 元组的访问：直接以下标的形式访问
# 直接访问元组名，得到整个元组
print(tuple1)
>>> (1, 2, 3)
# 下标访问
print(tuple1[0])
>>> 1
# 元组的删除
del tuple1
# 元组的加法
# 元组虽然不可修改，但是多元组之间可以通过加法的形式进行合并
tuple3 = tuple1 + tuple2（2）列表
# 列表
"""
列表可视为可变元组，长度以及内部值均可以修改
"""
# 列表的定义
list1 = ['A', 'B', 'C']
# 列表的访问
# 列表名访问：直接得到整个列表
print(list1)
>>> ['A', 'B', 'C']
# 下标索引访问
print(list1[0])
>>> A
print(list1[-1])
>>> C
# 列表的索引可以为负数，就是从列表尾部往前查
# 列表的运算
# 列表加法（即列表拼接）
list2 = ['D', 'E', 'F']
list3 = list1 + list2
print(list3)
>>> ['A', 'B', 'C', 'D', 'E', 'F']
# 列表的嵌套：列表的内部还能再嵌套
list4 = ['A', 'B', 'C', ['D', 'E', 'F']]
# 嵌套索引时变成二维
>>> print(list4[2][0])
C
>>> print(list4[3][2])
F
# 列表相关操作
# 增加，往列表后面添加元素
list4.append('G')
>>> print(list4)
['A', 'B', 'C', ['D', 'E', 'F'], 'G']
# 删除，删除列表中的尾部的元素
a = list4.pop()
>>> print(a)
G
# 修改
list4[2] = 'H'
>>> print(list4)
['A', 'B', 'H', ['D', 'E', 'F']]
（3）字典
# 字典
# 字典的定义
# 方式一
d = dict()
# 方式二
dt = {}
# 字典的初始化
d1 = dict(zip([1,2,3],["a","b","c"])) #具有明显的映射关系
d2 = dict(zip(("a","b","c"),(1,2,3,5))) #第二个元组多个5，不影响映射。
d3 = dict({1:"a",2:"b",5:"c"})
>>> print(d1)
{1: 'a', 2: 'b', 3: 'c'}
>>> print(d2)
{'a': 1, 'b': 2, 'c': 3}
>>> print(d3)
{1: 'a', 2: 'b', 5: 'c'}
# 映射规则，zip()的第一个参数作为索引，第二个参数为字典内容
# 字典的访问
# 根据索引进行访问
k1 = d1[1]
k2 = d2['b']
>>> print(k1)
a
>>> print(k2)
2（4）集合
# 集合
"""
集合元素是不可变类型，所以可以使用数值，字符串，元组，而不能使用列表，字典当做元素值。
(即内部元素不可修改)
"""
# 集合的创建
k1 = set()
# 集合初始化
# 集合一般与列表关联使用
list1 = ['A', 'B', 'C']
k1 = set(list1)
（5）分片操作
- 一般形式：
l2=[4,6,1,7,9]
e = l2[2:4]
print(e)
>>> [1, 7]????????分析可得冒号前部分数字为分片的起始位置，冒号后面的数字结束位置，且分片得到的数据不包含列表结尾位置的数据，即：若操作为[n:m]实际范围为n ~ m - 1
- 步长：
? ? ? ? ? ?分片的步长默认为1，即在你n ~ m - 1 这个范围内，它经过了每个位置，当我们想要跳过某些数据时，可以通过设置步长的方式，如：
l4 = [3,5,1,6,2]
e4 = l4[0:5:2]
>>> print(e4)
[3, 1, 2]????????我将步长调节2，它就能够隔一个选取一个?
- 索引下标为负数
- 下标为负数和列表下标负数等同
- 步长为负数，则从右往左截取（默认为从左往右)
l5=[4,5,7,1,9]
e5 = l5[-2:-4:-1]
>>> print(e5)
[1, 7]
"""
解释：
首先开始位置为-2，对应的为1，
结束位置对应的是-4，对应的是为5，
步长为-1，为从左往右，每次移动幅度为1，故是[1, 7]
"""?
5、控制结构（循环与判断）
（1）分支结构
# 分支结构（判断）
# 单分支结构
if score >= 60:
print('合格')
# 双分支结构
if score >= 60:
print('合格')
else:
print('不合格')
# 多分支结构
if score >= 90 and score <= 100:
print('A')
elif score >= 80 and score <= 89:
print('B')
elif score >= 70 and score <= 79:
print('C')
elif score >= 60 and score <= 69:
print('D')
else:
print('E')
"""
注意：
1、Python是对于缩进有严格要求的，每一个判断语句（同等级的语句）之后都需要缩进一下
2、对于多分支结构的最后一个分支依旧是else
3、多判断条件条件的情况下，若是多条件都需要满足，则每个条件之间使用and连接，如上述例子；
若多条件只需要满足一个，则是使用or连接
"""（2）循环结构
# 循环结构
# for循环
# 方式一：根据参数调用
# 给定循环的列表(或元组等)，给定参数存储循环的位置
lists = ['A', 'B', 'C', 'D', 'E']
for it in lists:
print(it, end=' ')
print()
# 结果为: A B C D E
# 方式二：根据下标索引调用
# 这种方式循环先是得到下标值，然后操作列表，可以方便同时操作多个列表
lists = ['A', 'B', 'C', 'D', 'E']
k = len(lists)
for i in range(0, k):
print(lists[i], end=' ')
print()
# 结果为： A B C D E
# while循环
# 在while后面给定一个条件，当不满足条件后，结束循环
lists = ['A', 'B', 'C', 'D', 'E']
k = len(lists)
while k > 0:
k = k - 1
print(lists[k], end=' ')
# 结果为：E D C B A
二、进阶操作
1、文件操作：
（1）基本操作：
"""
mode:
r: 只能读文件
w: 只能写入(清空文件内容)
a+: 读写(文件追加写入内容)
"""
#1.打开文件
f = open('hello.txt',mode='a') ##文件是自己建立在当前目录，w写，a追加
#2.文件读写操作
f.write('java\n')
#3.关闭文件(核心:打开之后必须关闭)
"""
方法一:
调用close()方法关闭文件。文件使用完毕后必须关闭，因为文件对象会占用操作系统的资源，
并且操作系统同一时间能打开的文件数量也是有限的：
"""
f.close()
（2）with和seek
"""
with语句:python中的with语句使用于对资源进行访问的场合，
保证不管处理过程中是否发生错误或者异常都会自动执行规定的(“清理”)操作，
释放被访问的资源，比如有文件读写后自动关闭、线程中锁的自动获取和释放等。
seek:seek(offset, from)有2个参数: offset:偏移量 from:方向
0:表示文件开头;
1:表示当前位置;
2:表示文件末尾
1). 把位置设置为:从文件开头,偏移5个字节
2). 把位置设置为:文件最开始
3). 把位置设置为:文件最末尾
"""
with open('hello.txt','w+') as f: #w+先清空在写
f.write('hello westos\n') ##写入文件 #先清空原来的hello,写入hello westos
f.seek(0,0) ##移动指针到文件最开始
print("当前指针的位置:",f.tell())
f.seek(0,2) ##移动指针到文件末尾
print("当前指针的位置:", f.tell())
print(f.read()) ##读取文件内容
