Python基础总结（一）

一、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.00

3、运算符

# 数值类型运算(包括整型以及浮点型)

# 加法
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())       ##读取文件内容