python基础

python简介

  • python是一门解释型，面向对象的高级编程语言。开源免费，支持交互式，可跨平台移植的脚本语言。

优点：

  1. 开源，易于维护。
  2. 可移植。
  3. 易于使用，简单优雅。
  4. 广泛的库。

缺点：

  1. 运行速度慢。
  2. 代码不能加密。
  • python的应用：数据分析，科学计算，网络爬虫，软件开发，web开发，人工智能

python基础

变量

  • 变量可以是任意的数据类型。
  • 变量名必须是的大小写英文，数字和下划线组成，且不能以数字开头。

标识符和关键字

  • 关键字是一些具有特殊功能标识符。
  • python中不允许自定义和关键字相同的名字的标识符。

输出

  • 普通输出
  • 格式化输出
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
print("标准化输出字符穿")
a = 10
print("这是变量：",a)

print("格式化输出")
age = 20
print("我的名字是: %s, 我的国籍是: %s" %("bkys","中国"))
print("我的年纪是: %d 岁" %age)

print("a","b","c")
print("www","baidu","com",sep=".")
print("hello", end="")  # 输出不换行
print("world", end="\t") # 制表符
print("python", end="\n") # 换行

print("输入")
password = input("请输入密码：")
print("您输入的密码是：",password)

a = int(input("输入："))
print("输入一个数字: %s" %a)

输入

  • input（）的小括号放入提示信息
  • input（）在从键盘获取了数据以后，会存放到等号左边的变量中
  • input（）函数接受的输入必须是表达式

运算符和表达式

运算符

  • 算数运算符：+，-，*，/。%（求余），**（幂），//（整除）
  • 比较运算符：==，！=，<，>，<=，>=
  • 赋值运算符：=，+=，-=，*=，/+，%=，**=，//=（c += a，c = c + a）
  • 位运算符：&，|，^，~，<<，>>
  • 逻辑运算符：and，or，not
  • 成员运算符：in，not in
  • 身份运算符：is，is not

运算符优先级：

判断语句和循环语句

判断语句：

1
2
3
4
if True:
    print("True")
else:
    print("False")
  • 分数评级
1
2
3
4
5
6
7
8
9
10
11
12
score = int(input("请输入你的分数："))

if score >= 90 and score < 100:
    print("优秀")
elif score >= 80 and score < 90:
    print("良好")
elif score >= 70 and score < 80:
    print("中")
elif score >= 60 and score < 70:
    print("及格")
else:
    print("不及格")
  • 石头剪刀布

循环语句：

  • for语句
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
for i in range(5):
    print(i)
    print("\n")

for j in range(0,10,3):  # 0-10,每次加3，不包含10
    print(j, end= "")
    print("\n")

name = "xian"

for x in name:
    print(x, end= "\t")
    print("\n")

a = ["aa", "bb", "cc", "dd"]  # 通过列表的下标打印
for i in  range(len(a)):
    print(i, a[i])
  • while语句
1
2
3
4
5
6
7
count = 0
while count < 5 :
    print("第%d次执行循环"%(count+1))
    print("count = %d" %count)
    count += 1
else:
    print(count,"大于等于5")
  • 1-100求和
  • 九九乘法表

break，continue，pass语句：

  • break语句可以跳出for和while的循环体
  • continue语句跳过当前循环，进入下一轮循环
  • pass是空语句，占位语句

字符串，列表，元组，字典

字符串（string）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
word = '字符串'
sentence = '这是一个句子'
paragraph = """ 0
  这是一个段落
由多行组成
"""
print(word)
print(sentence)
print(paragraph)

str1 = "I'm a student"
print(str1)
str2 = 'I\'m a student'  # 外面用单引号内部要使用转义字符
print(str2)
print(str1[0])
print(str1[0:5])
print(str1[0:7:2])   # [起始位置：结束位置：步进值]
print(str1[:5])      # 从0到下标5，不包含下标5
print(str1[5:])      # 从下标5到结束

print(str1 + str2)
print(str1 + "str2")
print(str1 * 3)    	 # pyhon中对字符串进行相加减

print("hello\npython")
print(r"hello\npython")  #前面加r，表示显示原始字符串，不进行转义
  • 转义字符
1
2
3
4
5
6
7
8
9
10
11
\\  # 反斜杠
\'
\"
\a  # 响铃
\b  # 退格
\000  # 空
\n
\v  # 纵向制表符
\t  # 横向制表符
\r  # 回车
\f  # 换页
  • 字符串的常见操作

列表（list）

  • 列表中元素的类型可以不相同，可以是数字，字符串甚至是列表（嵌套）
  • 列表是写在方括号[]内，用逗号分隔的元素列表。
  • 列表索引值0为开始值，-1为末尾的开始位置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
namelist = ["张", "王", "李", "赵"]
print(namelist[0])

typelist = [1, "张"]
print(type((typelist[0])))
print(type((typelist[1])))

# for循环遍历列表
for name in namelist:
    print(name)
    
# while循环遍历列表
len = len(namelist)
i = 0
while i< len:
    print(namelist[i],end= "")
    i += 1
增
1
2
3
4
5
6
7
8
9
# append（在末尾增加元素,整体添加） extend（逐一添加）
nametemp = input("请输入添加学生的姓名：")
namelist.append(nametemp)

# insert（第一个表示下标，第二个表示元素，指定下标位置插入元素）
a = [0,1,2]
a.insert(1,3)
print(a)

删
1
2
3
4
5
6
7
moviename = ["肖申克的救赎", "阿甘正传", "速度与激情", "黑客帝国", "骇客帝国"]

# del moviename[2]  # 在指定下标处删除
# moviename.pop()   # 在末尾删除最后一个元素
moviename.remove("速度与激情")  # 直接删除指定内容,删除找到的第一个

print(moviename)
改
1
2
3
4
5
moviename = ["肖申克的救赎", "阿甘正传", "速度与激情", "黑客帝国", "骇客帝国"]

moviename[3] = "泰坦尼克号"   # 修改指定下标的元素内容

print(moviename)
查
1
2
3
4
5
6
7
8
9
10
11
12
13
14
namelist = ["张", "王", "李", "赵", "孙"]

findName = input("请输入你要查找的学生姓名：")

if findName in namelist:
    print("已找到")
else:
    print("没有找到")
    

a = ["a", "b", "c", "a", "b"]

print(a.index("a",1,4))  # 找到指定元素的下标，范围区间左闭右开
print(a.count("b"))      # 统计某个元素出现了几次
排序
1
2
3
4
5
6
7
8
9
10
a = [1,4,2,3]

a.reverse() # 反转
print(a.reverse())

a.sort()  # 排序（升序）
print(a)

a.sort(reverse=True)  # 降序
print(a)
  • 列表的应用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import random

offices = [[],[],[]]

names = ["A","B","C","D","E","F","G","H"]

for name in names:
    index = random.randint(0,2)
    offices[index].append(name)

i = 1
for office in offices:
    print("办公室%d 的人数为：%d" %(i,len(office)))
    i += 1
    for name in office:
        print("%s" %name, end= "\t")
    print("\n")

元组（tuple）

  • tuple与list类似，tuple中的元素不能修改。
  • tuple写在小括号里，元素之间用逗号隔开。
  • 元组得元素不可变，但可以包含可变对象。
1
2
3
4
5
6
7
tup1 = ()  # 创建空元组
print(type(tup1))

# tup2 = (50) # <class 'tuple'>
tup2 = (50,)  # 当只有一个数据时，应给后面加上逗号

print(type(tup2))
1
2
3
4
5
6
7
8
9
tup1 = ("abc","def",2000,2020)

print(tup1[0])
print(tup1[-1])  # 最后一个元素
print(tup1[1:5])  # 左闭右开

tup2 = (1,2,3)
tup = tup1 + tup2
print(tup)
字典（dict）
  • 字典是无序得对象集合，使用键-值（key-value）存储。
  • 键（key）必须使用不可变类型。
  • 同一个字典中，键必须是唯一的。
1
2
3
4
5
6
7
8
9
10
info = {"name":"bkys", "age":"18"}  # 定义一个字典

print(info["name"])
print(info["age"])

# 访问不存在得键
# print(info["gender"])  # 直接访问报错
# print(info.get("gender"))  # 使用get方法，默认返回：None
print(info.get("age", 20))
print(info.get("gender", "10"))  # 没找到默认值
增
1
2
3
4
info = {"name":"bkys", "age":"18"}
newID = input("请输入新学号")
info["id"] = newID
print(info["id"])
删
1
2
3
4
5
6
info = {"name":"bkys", "age":"18"}
print("del前: %S" %info["name"])

del info["name"]  #del

# print("del后: %S" %info["name"])  # del删除的是整个键值对，再次访问会报错
1
2
3
4
5
6
info = {"name":"bkys", "age":"18"}
print("clear前: %s" %info)

info.clear()

print("clear后: %s" %info)
改
1
2
3
info = {"name":"bkys", "age":"18"}
info["age"] = 20
print(info["age"])
查
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
info = {"name":"bkys", "age":"18"}
print(info.keys())  # 得到所有的键（列表）
print(info.values())  # 打印所有的值（列表）
print(info.items())   # 打印所有的项（列表），每个键值对是一个元组

# 遍历所有的值
for key in info.keys():
    print(key)

# 遍历所有的键
for value in info.values():
    print(value)

# 遍历所有的键值
for key,value in info.items():
    print("key=%s,value=%s" %(key,value))
1
2
3
4
5
# 使用枚举函数，同时拿到列表中的下标和元素内容
mylist = ["a", "b", "c", "d"]

for i, x in enumerate(mylist):
    print(i, x)

集合(set)

  • set和dict类似，是一组key的集合，不储存value。（key不重复）
  • set是无序的，重复的元素在set中自动过滤
是否有序 是否可变类型
列表[] 有序 可变类型
元组() 有序 不可变类型
字典{} 无序 key不可变，value可变
集合{} 无序 可变类型（不重复）

函数

  • 无参数，无返回值
1
2
def 函数名():
	代码
  • 有参数
1
2
3
4
5
def add2num(a,b):
    c = a + b
    print(c)

add2num(11, 22)
  • 有参数，有返回值
1
2
3
4
5
def add2num(a,b):
    return a + b

result = add2num(11,22)
print(result)
  • 返回多个值
1
2
3
4
5
6
def divid(a, b):
    shang = a//b
    yushu = a % b
    return shang,yushu
sh,yu = divid(5, 2)
print("商：%d，余数：%d" %(sh,yu))
  • 全局变量和局部变量
  • 在一个函数中定义的变量，只能在本函数中用
  • 在函数外定义的变量，可以在所有的函数中使用

文件操作

模式 描述
r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
w 打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
w+ 打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
rb+ 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。
wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+ 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。 
1
2
3
4
5
f = open("test.txt", "w")  # 打开文件，w模式，文件不存在则新建

f.write("hello world")   # 将字符串写入文件中

f.close()   # 关闭文件
  • read方法，读取指定的字符，开始时定位在文件头部，每执行一次，向后移动指定数
1
2
3
4
5
6
7
8
9
f = open("test.txt","r")

content = f.read(5)
print(content)

content = f.read(5)
print(content)

f.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# readlines方法，读完所有文档，形成一个列表
f = open("test.txt","r")

content = f.readline()
print(content)  # 直接打印,每次读一行

content = f.readline()
print(content)  # 直接打印
print("-" * 100)

content = f.readlines()
print(content)  # 直接打印
print("-" * 100)

i = 1
for temp in content:
    print("%d：%s " %(i,temp))  # 分行打印
    i += 1

f.close()
  • os模块
1
2
3
import os

os.rename("test.txt", "retest.txt")

文件错误与异常

1
2
3
4
5
print("test1")

f = open("123.txt", "r")     # 只读模式打开不存在文件，报错

print("text2")   			#  这句代码不会执行
  • 捕获异常
1
2
3
4
5
6
7
8
9
10
try:
    print("test1")

    f = open("123.txt", "r")

    print("text2")

except IOError:    # 文件没找到，属于IO异常（输入输出异常）
    pass		  # 捕获异常后，执行的代码

1
2
3
4
try:
    print(num)
except NameError:
    print("NameError")
1
2
3
4
5
6
7
8
9
10
try:
    print("test1")

    f = open("123.txt", "r")

    print("text2")

    print(num)
except (NameError,IOError):   # 将可能出现的错误都放在这里
    print("出现错误")
  • 获取错误描述
1
2
3
4
5
6
7
8
9
10
11
try:
    print("test1")

    f = open("123.txt", "r")

    print("text2")

    print(num)
except (NameError,IOError) as result:
    print("出现错误")
    print(result)
  • 获取所有异常
1
2
3
4
5
6
7
8
9
10
11
try:
    print("test1")

    f = open("123.txt", "r")

    print("text2")

    print(num)
except Exception as result:  # Exception可以承接任何异常
    print("出现错误")
    print(result)
  • 异常处理
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import time

try:
    f = open("123.txt", "r")

    try:
        while True:
            content = f.readline()
            if len(content) == 0:
                break
            time.sleep(2)
            print(content)
    finally:                                # 无论如何一定会执行的
        f.close()

except Exception as result:
    print("发生异常")