本篇文章给大家谈谈python 基础 详细,以及python基础大全,希望对各位有所帮助,不要忘了收藏本站喔。
Python编程基础
- Python语言是一个由编程牛人领导设计并开发的编程语言
- Python语言是一个有开放、开源精神的编程语言
- Python语言应用于火星探测、搜索引擎、引力波分析等众多领域
编译和解释
- 计算机执行源程序的两种方式:编译和解释
- 编译:将源代码一次性转换成目标代码的过程
- 解释:将源代码逐条转换成目标代码同时逐条运行的过程
Python的两种编程方式
- 交互式:对每个输入语句即时运行结果,适合语法练习
- 文件式:批量执行一组语句并运行结果,编程的主要方式
实例1:圆面积的计算
r = 25
area = 3.1415 * r * r
print(area)
print(" {:.2f}F".format(area))
输出结果如下:
1963.4375000000002
1963.44F
实例2:温度转换
TempStr = input("请输入带有符号的温度值: ")
if TempStr[-1] in ['F', 'f']:
C = (eval(TempStr[0:-1]) - 32)/1.8
print("转换后的温度是{:.2f}C".format(C))
elif TempStr[-1] in ['C', 'c']:
F = 1.8*eval(TempStr[0:-1]) + 32
print("转换后的温度是{:.2f}F".format(F))
else:
print("输入格式错误")
Python语法分析
缩进
-
严格明确:缩进是语法的一部分,缩进不正确程序运行错误
-
所属关系:表达代码间包含和层次关系的唯一手段
-
长度一致:程序内一致即可,一般用4个空格或1个TAB
注释
-
单行注释:以#开头,其后内容为注释
# 这里是单行注释
-
多行注释:以’’'开头和结尾
''' 这是多行注释第一行 这是多行注释第二行 '''
变量
- 变量采用标识符(名字) 来表示,关联标识符的过程叫命名
- 可以使用等号(=)向变量赋值或修改值,=被称为赋值符号
命名
-
命名规则: 大小写字母、数字、下划线和汉字等字符及组合
count=1 Count=2 q23=3 啊=4 cat_pig=5
-
注意事项: 大小写敏感、首字符不能是数字、不与保留字相同
Python和python是不同变量
保留字
- Python语言有33个保留字(也叫关键字)
- 保留字是编程语言的基本单词,大小写敏感
and | as | assert | break | class | continue |
---|---|---|---|---|---|
def | del | elif | else | except | finally |
for | from | False | global | if | import |
in | is | lambda | nonlocal | not | None |
or | pass | raise | return | try | True |
while | with | yield |
数据类型
-
整数类型:10011101
-
字符串类型:“10,10,10”
-
列表类型:【10,011,101】
数字类型
类型 | 示例 | 说明 |
---|---|---|
整数 | 123 456 | 无范围限制 |
布尔型 | True False | True:1 False:0 |
浮点数 | 12.13 66.8 | 精度约17位 |
复数 | 1+2j 1-2j | z.real z.imag |
字符串
-
字符串由一对单引号或一对双引号表示
"请输入带有符号的温度值: "或者 ‘C’
-
字符串是字符的有序序列,可以对其中的字符进行索引
“请” 是 "请输入带有符号的温度值: " 的第0个字符
字符串的使用
-
索引:返回字符串中单个字符 <字符串>[M]
"请输入带有符号的温度值: "[0] 或者 TempStr[-1]
-
切片:返回字符串中一段字符子串 <字符串>[M: N]
"请输入带有符号的温度值: "[1:3] 或者 TempStr[0:-1]
字符串的切片高级用法
- <字符串>[M: N],M缺失表示至开头,N缺失表示至结尾
- <字符串>[M: N: K],根据步长K对字符串切片
字符串的特殊字符
-
转义符表达特定字符的本意
“这里有个双引号(”)" 结果为 这里有个双引号(")
-
转义符形成一些组合,表达一些不可打印的含义
"\b"回退 "\n"换行(光标移动到下行首) “\r” 回车(光标移动到本行首)
列表类型
-
列表使用[ ]表示,采用逗号(,)分隔各元素
[‘F’,‘f’]表示两个元素’F’和’f’
-
使用保留字 in 判断一个元素是否在列表中
TempStr[-1] in [‘C’,‘c’]判断前者是否与列表中某个元素相同
语句与函数
赋值语句
-
赋值语句用来给变量赋予新的数据值
C=(eval(TempStr[0:-1])-32)/1.8 #右侧运算结果赋给变量C
-
赋值语句右侧的数据类型同时作用于变量
TempStr=input("") #input()返回一个字符串,TempStr也是字符串
分支语句
-
使用保留字if elif else构成条件判断的分支结构
-
每个保留字所在行最后存在一个冒号(😃,语法的一部分
冒号及后续缩进用来表示后续语句与条件的所属关系
函数
-
类似数学中的函数, y = f(x)
print(“输入格式错误”) #打印输出 “输入格式错误”
-
函数采用 <函数名>(<参数>) 方式使用
eval(TempStr[0:-1]) # TempStr[0:-1]是参数
-
函数三要素:参数、功能、返回值
Python程序的输入输出
输入函数input()
-
input()函数的使用格式:
<变量> = input(<提示信息字符串>)
-
用户输入的信息以字符串类型保存在<变量>中
TempStr = input(“请输入”) # TempStr保存用户输入的信息
输出函数 print()
-
print()函数的基本使用格式:
print(<拟输出字符串或字符串变量>)
-
字符串类型的一对引号仅在程序内部使用,输出无引号
print(“输入格式错误”) # 向控制台输出 输入格式错误
-
print()函数end参数控制分隔符
-
print()函数的格式化:
print("转换后的温度是{:.2f}C".format(C))
{ }表示槽,后续变量填充到槽中
{ :.2f }表示将变量C填充到这个位置时取小数点后2位
评估函数 eval()
-
eval()函数的基本使用格式:
eval(<字符串或字符串变量>)
-
eval():去掉参数最外侧引号并执行余下语句的函数
程序的控制结构
-
顺序结构
-
分支结构
-
循环结构
单分支结构
根据判断条件结果而选择不同向前路径的运行方式
二分支结构
guess = eval(input())
if guess == 99:
print("猜对了")
else :
print("猜错了")
二分支紧凑形式
<表达式1> if <条件> else <表达式2>
guess = eval(input())
print("猜{}了".format("对" if guess==99 else "错"))
多分支结构
score = eval(input())
if score >= 90:
grade = "A"
elif score >= 80:
grade = "B"
elif score >= 70:
grade = "C"
elif score >= 60:
grade = "D"
print("输入成绩属于级别{}".format(grade))
for循环
-
从遍历结构中逐一提取元素,放在循环变量中
-
由保留字for和in组成,完整遍历所有元素后结束
-
每次循环,所获得元素放入循环变量,并执行一次语句块
for <循环变量> in <遍历结构> : <语句块>for c in "Python123": print(c, end=",") 输入结果:P,y,t,h,o,n,1,2,3,
while循环
-
由条件控制的循环运行方式
-
反复执行语句块,直到条件不满足时结束
while <条件> : <语句块> a = 3 while a > 0 : a = a - 1 print(a)
循环控制保留字
-
break跳出并结束当前整个循环,执行循环后的语句
-
continue结束当次循环,继续执行后续次数循环
-
break和continue可以与for和while循环搭配使用
for c in "PYTHON" : if c == "T" : continue print(c, end="") 输出:PYHON
循环的扩展
-
循环与else
-
循环没有被break语句退出时,执行else语句块
-
else语句块作为"正常"完成循环的奖励
for <变量> in <遍历结构> : <语句块1> else : <语句块2> while <条件> : <语句块1> else : <语句块2>
Python集合类型
集合类型的定义
- 集合类型与数学中的集合概念一致
- 集合元素之间无序,每个元素唯一,不存在相同元素
- 集合用大括号 {} 表示,元素间用逗号分隔
- 建立集合类型用 {} 或 set()
- 建立空集合类型,必须使用set()
>>>A={"python",123,("python",123)} #使用{}建立集合
>{123, 'python', ('python', 123)}
>>>> B=set("pypy123") #使用set()建立集合
>{'1', 'p', '2', '3', 'y'}
>>>> C = {"python", 123, "python",123}
>{'python', 123}
集合类型操作
集合操作符
6个操作符
操作符及应用 | 描述 |
---|---|
S | T | 返回一个新集合,包括在集合S和T中的所有元素 |
S - T | 返回一个新集合,包括在集合S但不在T中的元素 |
S & T | 返回一个新集合,包括同时在集合S和T中的元素 |
S ^ T | 返回一个新集合,包括集合S和T中的非相同元素 |
S <= T 或 S < T | 返回True/False,判断S和T的子集关系 |
S >= T 或 S > T | 返回True/False,判断S和T的包含关系 |
4个增强操作符
操作符及应用 | 描述 |
---|---|
S |= T | 更新集合S,包括在集合S和T中的所有元素 |
S -= T | 更新集合S,包括在集合S但不在T中的元素 |
S &= T | 更新集合S,包括同时在集合S和T中的元素 |
S ^= T | 更新集合S,包括集合S和T中的非相同元素 |
集合类型方法
操作函数或方法 | 描述 |
---|---|
S.add(x) | 如果x不在集合S中,将x增加到S |
S.discard(x) | 移除S中元素x,如果x不在集合S中,不报错 |
S.remove(x) | 移除S中元素x,如果x不在集合S中,产生KeyError异常 |
S.clear() | 移除S中所有元素 |
S.pop() | 随机返回S的一个元素,更新S,若S为空产生KeyError异常 |
操作函数或方法 | 描述 |
---|---|
S.copy() | 返回集合S的一个副本 |
len(S) | 返回集合S的元素个数 |
x in S | 判断S中元素x,x在集合S中,返回True,否则返回False |
x not in S | 判断S中元素x,x不在集合S中,返回False,否则返回True |
set(x) | 将其他类型变量x转变为集合类型 |
集合类型应用场所
- 数据去重:集合类型所有元素无重复
>>> ls = ["p", "p", "y", "y", 123]
>>>>s = set(ls)
>{'p', 'y', 123}
>>>> lt = list(s)
>['p', 'y', 123]
序列类型
序列类型定义
- 序列是具有先后关系的一组元素
- 序列是一维元素向量,元素类型可以不同
- 类似数学元素序列: s0, s1, … , sn-1
- 元素间由序号引导,通过下标访问序列的特定元素
- 元组用于元素不改变的应用场景,更多用于固定搭配场景
- 列表更加灵活,它是最常用的序列类型
- 最主要作用:表示一组有序数据,进而操作它们
序列类型
序列类型通用操作符
6个操作符
操作符及应用 | 描述 |
---|---|
x in s | 如果x是序列s的元素,返回True,否则返回False |
x not in s | 如果x是序列s的元素,返回False,否则返回True |
s + t | 连接两个序列s和t |
sn 或 ns | 将序列s复制n次 |
s[i] | 索引,返回s中的第i个元素,i是序列的序号 |
序列类型通用函数和方法
5个函数和方法
函数和方法 | 描述 |
---|---|
len(s) | 返回序列s的长度 |
min(s) | 返回序列s的最小元素,s中元素需要可比较 |
max(s) | 返回序列s的最大元素,s中元素需要可比较 |
s.index(x) 或 s.index(x, i, j) | 返回序列s从i开始到j位置中第一次出现元素x的位置 |
s.count(x) | 返回序列s中出现x的总次数 |
元组类型
- 元组是一种序列类型,一旦创建就不能被修改
- 使用小括号 () 或 tuple() 创建,元素间用逗号 , 分隔
- 可以使用或不使用小括号
- 元组继承了序列类型的全部通用操作
- 元组因为创建后不能修改,因此没有特殊操作
>>> creature = "cat", "dog", "tiger", "human"
>>> creature
('cat', 'dog', 'tiger', 'human')
>>> color = (0x001100, "blue", creature)
>>> color
(4352, 'blue', ('cat', 'dog', 'tiger', 'human'))
列表类型及操作
列表类型
-
列表是一种序列类型,创建后可以随意被修改
-
使用方括号 [] 或list() 创建,元素间用逗号 , 分隔
-
列表中各元素类型可以不同,无长度限制
列表类型操作函数和方法
函数或方法 | 描述 |
---|---|
ls[i] = x | 替换列表ls第i元素为x |
ls[i: j: k] = lt | 用列表lt替换ls切片后所对应元素子列表 |
del ls[i] | 删除列表ls中第i元素 |
del ls[i: j: k] | 删除列表ls中第i到第j以k为步长的元素 |
ls += lt | 更新列表ls,将列表lt元素增加到列表ls中 |
>>> ls = ["cat", "dog", "tiger", 1024]
>>>> ls[1:2] = [1, 2, 3, 4]
>['cat', 1, 2, 3, 4, 'tiger', 1024]
>>>> del ls[::3]
> [1, 2, 4, 'tiger']
> >>> ls*2
> [1, 2, 4, 'tiger', 1, 2, 4, 'tiger']
函数或方法 | 描述 |
---|---|
ls.append(x) | 在列表ls最后增加一个元素x |
ls.clear() | 删除列表ls中所有元素 |
ls.copy() | 生成一个新列表,赋值ls中所有元素 |
ls.insert(i,x) | 在列表ls的第i位置增加元素x |
ls.pop(i) | 将列表ls中第i位置元素取出并删除该元素 |
>>> ls = ["cat", "dog", "tiger", 1024]
>>>> ls.append(1234)
>['cat', 'dog', 'tiger', 1024, 1234]
>>>> ls.insert(3, "human")
>['cat', 'dog', 'tiger', 'human', 1024, 1234]
>>>> ls.reverse()
>[1234, 1024, 'human', 'tiger', 'dog', 'cat']
定义空列表lt >>> lt = []
向lt新增5个元素 >>> lt += [1,2,3,4,5]
修改lt中第2个元素 >>> lt[2] = 6
向lt中第2个位置增加一个元素 >>> lt.insert(2, 7)
从lt中第1个位置删除一个元素 >>> del lt[1]
删除lt中第1-3位置元素 >>> del lt[1:4]
判断lt中是否包含数字0 >>> 0 in lt
向lt新增数字0 >>> lt.append(0)
返回数字0所在lt中的索引 >>> lt.index(0)
lt的长度 >>> len(lt)
lt中最大元素 >>> max(lt)
清空lt >>> lt.clear()
字典类型
字典类型定义
- 理解“映射”
- 映射是一种键(索引)和值(数据)的对应
- 映射无处不在,键值对无处不在
- 最主要作用:表达键值对数据,进而操作它们
- 键值对:键是数据索引的扩展
- 字典是键值对的集合,键值对之间无序
- 采用大括号{}和dict()创建,键值对用冒号: 表示
字典类型得用法
字典的定义和使用
字典类型操作函数和方法
函数或方法 | 描述 |
---|---|
del d[k] | 删除字典d中键k对应的数据值 |
k in d | 判断键k是否在字典d中,如果在返回True,否则False |
d.keys() | 返回字典d中所有的键信息 |
d.values() | 返回字典d中所有的值信息 |
d.items() | 返回字典d中所有的键值对信息 |
>>> d = {"中国":"北京", "美国":"华盛顿", "法国":"巴黎"}
>>> "中国" in d
True
>>> d.keys()
dict_keys(['中国', '美国', '法国'])
>>> d.values()
dict_values(['北京', '华盛顿', '巴黎'])
函数或方法 | 描述 |
---|---|
d.get(k, ) | 键k存在,则返回相应值,不在则返回None值 |
d.pop(k, ) | 键k存在,则取出相应值,并删除该元素,不在则返回None值 |
d.popitem() | 随机从字典d中取出一个键值对,以元组形式返回,并删除该元素 |
d.clear() | 删除所有的键值对 |
len(d) | 返回字典d中元素的个数 |
>>> d = {"中国":"北京", "美国":"华盛顿", "法国":"巴黎"}
>>>> d.get("中国","伊斯兰堡")
>'北京'
>>>> d.get("巴基斯坦","伊斯兰堡")
>'伊斯兰堡'
>>>> d.popitem()
>('美国', '华盛顿')
字符串操作–知识扩展
操作符及应用 | 描述 |
---|---|
replace(old, new [, max]) | 将字符串中的old替换成 new,如果max指定则替换不超过max次。 |
isalpha() | 如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False |
isdigit() | 如果字符串只包含数字则返回 True 否则返回 False. |
islower() | 如果字符串中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是小写,则返回 True,否则返回 False |
isupper() | 如果字符串中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是大写,则返回 True,否则返回 False |
str = "this is string example....wow!!!"
print (str.replace("is", "was", 3))
str = input().replace(',',' ').replace('.',' ').replace('!',' ').replace('?',' ').split()print(str)
Python常用模块
-
time库
-
datetime库
-
random库
-
os库
Time模块
- import xx 引入某个库
- import xx as xx 库别名
- from xx import xx 引入某个库中的数据、方法
类、子库
import time
import time as t
from time import ctime
time库概述
- 计算机时间的表达
- 提供获取系统时间并格式化输出功能
- 提供系统级精确计时功能,用于程序性能分析
- 时间获取:time() ctime() gmtime() localtime()
- 时间格式化:strftime() strptime()
- 时间转换 mktime()
- 程序计时:sleep(), perf_counter()
时间获取
时间格式化
-
格式化:类似字符串格式化,需要有展示模板
-
展示模板由特定的格式化控制符组成
-
strftime()方法
格式化控制符
程序计时
- 程序计时指测量起止动作所经历时间的过程
- 测量时间:perf_counter()
- 产生时间:sleep()
文本进度条
datetime库
- datetime库提供了操作日期和时间功能
- datetime(时间日期类型)
- date(日期类型)
- time(时间类型)
- timedelta(时间差类型)
random库
-
伪随机数: 采用梅森旋转算法生成的(伪)随机序列中元素
-
random库主要用于生成随机数
-
使用random库: import random
-
基本随机数函数: seed(), random()
-
扩展随机数函数: randint(), getrandbits(), uniform(),
randrange(), choice(), shuffle()
基本随机数函数
扩展随机数函数
随机数函数得使用
- 能够利用随机数种子产生"确定"伪随机数
- 能够产生随机整数
- 能够对序列类型进行随机操作
from random import random
from time import perf_counter
DARTS = 1000*1000
hits = 0.0
start = perf_counter()
for i in range(1, DARTS+1):
x, y = random(), random()
dist = pow(x ** 2 + y ** 2, 0.5)
if dist <= 1.0:
hits = hits + 1
pi = 4 * (hits/DARTS)
print("圆周率值是: {}".format(pi))
print("运行时间是: {:.5f}s".format(perf_counter()-start))
os库
os库基本介绍
- os库是Python标准库,包含几百个函数
- 常用路径操作、进程管理、环境参数等几类
- os库提供通用的、基本的操作系统交互功能
- 路径操作:os.path子库,处理文件路径及信息
- 进程管理:启动系统中其他程序
- 环境参数:获得系统软硬件信息等环境参数
os库之路径操作
- os.path子库以path为入口,用于操作和处理文件路径
- import os.path 或 import os.path as op
import osprint(os.path.abspath(__name_)) # 获取当前文件绝对路径
print(os.path.dirname(__file__)) # 获取当前文件夹路径
print(os.path.basename(__file__)) # 获取当前文件名字
函数 | 描述 |
---|---|
os.path.abspath(path) | 返回path在当前系统中的绝对路径**>>>os.path.abspath(“file.txt”)’C:\Users\Tian Song\Python36-32\file.txt’** |
os.path.normpath(path) | 归一化path的表示形式,统一用\分隔路径**>>>os.path.normpath(“D://PYE//file.txt”)’D:\PYE\file.txt’** |
os.path.relpath(path) | 返回当前程序与文件之间的相对路径 (relative path)>>>****os.path.relpath(“C://PYE//file.txt”)****’…\…\…\…\…\…\…\PYE\file.txt’ |
函数 | 描述 |
---|---|
os.path.dirname(path) | 返回path中的目录名称**>>>os.path.dirname(“D://PYE//file.txt”)’D://PYE’** |
os.path.basename(path) | 返回path中最后的文件名称**>>>os.path.basename(“D://PYE//file.txt”)’file.txt’** |
os.path.join(path, *paths) | 组合path与paths,返回一个路径字符串**>>>os.path.join(“D:/”, “PYE/file.txt”)**'D:/PYE/file.txt’ |
函数 | 描述 |
---|---|
os.path.exists(path) | 判断path对应文件或目录是否存在,返回True或False**>>>****os.path.exists(“D://PYE//file.txt”)**False |
os.path.isfile(path) | 判断path所对应是否为已存在的文件,返回True或False**>>>****os.path.isfile(“D://PYE//file.txt”)**True |
os.path.isdir(path) | 判断path所对应是否为已存在的目录,返回True或False**>>>****os.path.isdir(“D://PYE//file.txt”)**False |
函数 | 描述 |
---|---|
os.path.getatime(path) | 返回path对应文件或目录上一次的访问时间**>>>****os.path.getatime(“D:/PYE/file.txt”)**1518356633.7551725 |
os.path.getmtime(path) | 返回path对应文件或目录最近一次的修改时间**>>>****os.path.getmtime(“D:/PYE/file.txt”)**1518356633.7551725 |
os.path.getctime(path) | 返回path对应文件或目录的创建时间**>>time.ctime(os.path.getctime(“D:/PYE/file.txt”))’Sun Feb 11 21:43:53** 2018’ |
os.path.getsize(path) | 返回path对应文件的大小,以字节为单位**>>>****os.path.getsize(“D:/PYE/file.txt”)**180768 |
os库之进程管理
- os.system(command)
- 执行程序或命令command
- 在Windows系统中,返回值为cmd的调用返回信息
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xxcwaPJb-1635067431886)(Python总结img/进程管理1.png)]
os之环境参数
函数 | 描述 |
---|---|
os.chdir(path) | 修改当前程序操作的路径**>>>**os.chdir(“D:”) |
os.getcwd() | 返回程序的当前路径**>>>os.getcwd()’D:\’** |
os.getlogin() | 获得当前系统登录用户名称**>>>os.getlogin()’Tian Song’** |
os.cpu_count() | 获得当前系统的CPU数量**>>>****os.cpu_count()**8 |
os.urandom(n) | 获得n个字节长度的随机字符串,通常用于加解密运算**>>>os.urandom(10)b’7\xbe\xf2!\xc1=\x01gL****\xb3****’** |
for列表推导式–知识扩展
pyton代码复用
- 第三方库安装
- 函数
- 类和对象
- 异常处理
第三方库安装
- pip 是 Python 包管理工具,该工具提供了对Python 包的下载、安装、卸载的功能python用turtle画简单树形图。
- pip install xx 安装某个库
- pip uninstall xx 卸载某个库
- pip freeze 查看已安装的包(除自带包)
- pip list 查看已安装的包
- python -m pip install --upgrade pip pip升级
函数
函数得定义
- 函数是一段具有特定功能的、可重用的语句组
- 函数是一种功能的抽象,一般函数表达特定功能
- 两个作用:降低编程难度 和 代码复用
- 函数定义时,所指定的参数是一种占位符
- 函数定义后,如果不经过调用,不会被执行
- 函数定义时,参数是输入、函数体是处理、结果是输出 (IPO)
def <函数名>(<参数(0个或多个)>) : <函数体> return <返回值>
函数得调用过程
可选参数传递
- 函数定义时可以为某些参数指定默认值,构成可选参数
函数的返回值
- 函数可以返回0个或多个结果
- return保留字用来传递返回值
- 函数可以有返回值,也可以没有,可以有return,也可以没有
- return可以传递0个返回值,也可以传递任意多个返回值
局部变量和全局变量
- 基本数据类型,无论是否重名,局部变量与全局变量不同
- 可以通过global保留字在函数内部声明全局变量
- 组合数据类型,如果局部变量未真实创建,则是全局变量
lambda函数
- lambda函数是一种匿名函数,即没有名字的函数
- 使用lambda保留字定义,函数名是返回结果
- lambda函数用于定义简单的、能够在一行内表示的函数
- lambda函数主要用作一些特定函数或方法的参数
- lambda函数有一些固定使用方式,建议逐步掌握
- 一般情况,建议使用def定义的普通函数
>>> f = lambda x, y : x + y
>>> f(10, 15)
25
>>> f = lambda : "lambda函数"
>>> print(f())
lambda函数
函数递归
- 链条:计算过程存在递归链条
- 基例:存在一个或多个不需要再次递归的基例
递归的调用过程
类和对象
-
面向对象程序设计(Object Oriented Programming,OOP):使用对象进行程序设计,实现代码复用和设计复用,使得软件开发更高效方便。
-
类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
-
继承:即一个派生类(derived class)继承基类(base class)的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如,有这样一个设计:一个Dog类型的对象派生自Animal类,这是模拟"是一个(is-a)"关系(例图,Dog是一个Animal)。
-
实例化:创建一个类的实例,类的具体对象。
-
Python是面向对象的高级动态编程语言,完全支持面向对象的基本功能,如封装、继承、多态以及对基类方法的覆盖或重写。
-
Python中对象的概念很广泛,Python中的一切内容都是对象,除了数值、字符串、列表、元组、字典、集合、range对象等等,函数也是对象,类也是对象。
例如:字符串类和字符串对象
>>> s1=str(123)
>>>> s2='abc'
>>>> print(s1+' '+s2)
>123 abc
>>>> s1.islower()
>False
>>>> s2.isnumeric()
>False
类和对象的创建和使用
Python使用class关键字来定义类。Python定义类:
class Student:
name = ‘小张’ #属性
def f(self): #方法
return ‘hello world’
创建对象
定义了类之后,可以用来实例化对象,并通过“对象名.成员”的方式来访问其中的数据成员或方法成员。
s1 = Student(‘小王’)
s1.getInfo()
在Python中,可以使用内置方法isinstance()来测试一个对象是否为某个类的实例。
>>> isinstance(s1, Student)
>>> True
>>> isinstance(s1, str)
>>> False
类的使用
class BMI:
def __init__(self, name, age, weight, height):#构造方法
self.name = name
self.age = age
self.weight = weight
self. height = height
def getBMI(self): #计算BMI
bmi = self.weight / (self. height * self. height )
return round(bmi * 100) / 100
def getStatus(self):
bmi = self.getBMI()
if bmi < 18.5:
return "偏瘦"
elif bmi < 24:
return "正常"
elif bmi < 30:
return "偏胖"
else:
return "肥胖"
bmi1 = BMI("赵四", 18, 70, 1.75)
print( bmi1.name, "的BMI是", bmi1.getBMI(), bmi1.getStatus())
bmi2 = BMI(“张三”, 38, 75, 1.70)
print( bmi2.name, "的BMI是", bmi2.getBMI(), bmi2.getStatus())
程序的异常处理
当用户没有输入整数时,会产生异常,怎么处理?
num = eval(input("请输入一个整数: "))print(num**2)
文件的使用
- 文件的类型
- 文件的打开和关闭
- 文件内容的读取
- 数据的文件写入
文件理解
-
文件是数据的抽象和集合
-
文件是存储在辅助存储器上的数据序列
-
文件是数据存储的一种形式
-
文件展现形态:文本文件和二进制文件
文本文件 vs. 二进制文件
-
文本文件和二进制文件只是文件的展示方式
-
本质上,所有文件都是二进制形式存储
-
形式上,所有文件采用两种方式展示
文本文件
- 文件是数据的抽象和集合
- 由单一特定编码组成的文件,如UTF-8编码
- 由于存在编码,也被看成是存储着的长字符串
- 适用于例如:.txt文件、.py文件等
二进制文件
- 直接由比特0和1组成,没有统一字符编码
- 一般存在二进制0和1的组织结构,即文件格式
- 适用于例如:.png文件、.avi文件等
文本形式
中国是个伟大的国家!
二进制形式
b'\xd6\xd0\xb9\xfa\xca\xc7\xb8\xf6\xce\xb0\xb4\xf3\xb5\ xc4\xb9\xfa\xbc\xd2\xa3\xa1'
文件的打开和关闭
打开模式
文件的打开模式 | 描述 |
---|---|
’r’ | 只读模式,默认值,如果文件不存在,返回FileNotFoundError |
’w’ | 覆盖写模式,文件不存在则创建,存在则完全覆盖 |
’x’ | 创建写模式,文件不存在则创建,存在则返回FileExistsError |
’a’ | 追加写模式,文件不存在则创建,存在则在文件最后追加内容 |
’b’ | 二进制文件模式 |
’t’ | 文本文件模式,默认值 |
’+' | 与r/w/x/a一同使用,在原功能基础上增加同时读写功能 |
文件关闭
of.close()
文件内容的读取
操作方法 | 描述 |
---|---|
.read(size=-1) | 读入全部内容,如果给出参数,读入前size长度**>>>**s = **f.read(2)**中国 |
.readline(size=-1) | 读入一行内容,如果给出参数,读入该行前size长度**>>>**s = **f.readline()**中国是一个伟大的国家! |
.readlines(hint=-1) | 读入文件所有行,以每行为元素形成列表如果给出参数,hint为-1表示读入所有行,如果hint大于前n行的总字数但小于前n+1行的总字数,则执行函数会读取文件的前n+1行;**>>>**s = f.readlines()[‘中国是一个伟大的国家!’] |
文件的全文本操作
文件的逐行操作
数据的文件写入
操作方法 | 描述 |
---|---|
.write(s) | 向文件写入一个字符串或字节流**>>>f.write("中国是一个伟大的国家!"****)** |
.writelines(lines) | 将一个元素全为字符串的列表写入文件**>>>ls = **["中国",** “法国”**, **"美国"]>>>****f.writelines(ls)**中国法国美国 |
文件的使用
- 文件的使用方式:打开-操作-关闭
- 文本文件&二进制文件,open( , )和.close()
- 文件内容的读取:.read() .readline() .readlines()
- 数据的文件写入:.write() .writelines() .seek()
一维数据的格式化和处理
- 数据的组织的维度
- 一维数据的表示
- 一维数据的存储
- 一维数据的处理
数据组织的维度
- 一个数据表达一个含义
- 一组数据表达一个或多个含义
一维数据
- 由对等关系的有序或无序数据构成,采用线性方式组织
二维数据
- 由多个一维数据构成,是一维数据的组合形式
多维数据
- 由一维或二维数据在新维度上扩展形成
高维数据
- 仅利用最基本的二元关系展示数据间的复杂结构
{
"firsstName" : "Tian",
"lastName" : "Song",
"address" : {
"streetAddr" : "中关村南大街5号",
"city" : "北京市",
"zipcode" : "100081"
}
"professional" : ["Computer Networkinng" , "Security"]
}
数据的操作周期
- 存储 < - > 表示 < - > 操作
一维数据的表示
- 如果数据间有序:使用列表类型
- 列表类型可以表达一维有序数据
- for循环可以遍历数据,进而对每个数据进行处理
ls = [3.1398, 3.1349, 3.1376]
- 如果数据间无序:使用集合类型
- 集合类型可以表达一维无序数据
- for循环可以遍历数据,进而对每个数据进行处理
st = {3.1398, 3.1349, 3.1376}
一维数据的储存
存储方式一:空格分隔
中国 美国 日本 德国 法国 英国 意大利
- 使用一个或多个空格分隔进行存储,不换行
- 缺点:数据中不能存在空格
存储方式二:逗号分隔
中国,美国,日本,德国,法国,英国,意大利
- 使用英文半角逗号分隔数据进行存储,不换行
- 缺点:数据中不能有英文逗号
存储方式三:其他方式
中国$美国$日本$德国$法国$英国$意大利
- 使用其他符号或符号组合分隔,建议采用特殊符号
- 缺点:需要根据数据特点定义,通用性较差
一维数据的处理
一维数据的读入处理
从空格分隔的文件中读入数据
中国 美国 日本 德国 法国 英国 意大利
txt=open("1.txt","r",encoding="utf-8")
l=txt.read()
ls=l.split()
print(ls)
txt.close()
输出:['中国', '美国', '日本', '德国', '法国', '英国', '意大利']
从特殊符号分隔的文件中读入数据
中国$美国$日本$德国$法国$英国$意大利
txt=open("1.txt","r",encoding="utf-8")
l=txt.read()
ls=l.split("&")
print(ls)
txt.close()
输出:['中国', '美国', '日本', '德国', '法国', '英国', '意大利']
一维数据的写入
采用空格分隔方式将数据写入文件
ls=['中国','美国','日本']
f=open("2.txt","w",encoding="utf-8")
f.write(' '.join(ls))
f.close()
写入:中国 美国 日本
采用特殊分隔方式将数据写入文件
ls=['中国','美国','日本']
f=open("2.txt","w",encoding="utf-8")
f.write('$'.join(ls))
f.close()
写入:中国$美国$日本
单元小结–一维数据的格式化和处理
- 数据的维度:一维、二维、多维、高维
- 一维数据的表示:列表类型(有序)和集合类型(无序)
- 一维数据的存储:空格分隔、逗号分隔、特殊符号分隔
- 一维数据的处理:字符串方法 .split() 和 .join()