python 基础 详细,python基础介绍

大家好，小编为大家解答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弧形7段数码管绘制。
• 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()