Python笔记（三）

Python笔记

• Python笔记（一）
• Python笔记（二）
• 六、字符串
• • 6.1、字符串的驻留机制
  • 6.2、字符串的常用操作
  • • 6.2.1、字符串的查询操作的方法
    • 6.2.2、字符串的大小写转换操作的方法
    • 6.2.3、字符串内容对齐操作的方法
    • 6.2.4、字符串劈分操作的方法
    • 6.2.5、判断字符串操作的方法
    • 6.2.6、字符串操作的其它方法
  • 6.3、字符串的比较
  • 6.4、字符串的切片操作
  • 6.5、格式化字符串
  • 6.6、字符串的编码转换
• 七、函数
• • 7.1、函数的创建和调用
  • 7.2、函数的参数传递
  • 7.3、函数的返回值
  • 7.4、函数的参数定义
  • 7.5、变量的作用域
  • 7.6、递归函数
  • 7.7、Python的异常处理机制
  • 7.8、Python中常见的异常类型
• 八、类与面向对象
• • 8.1、 类的创建
  • 8.2、 对象的创建
  • 8.3、类属性、类方法、静态方法
  • 8.4、动态绑定属性和方法
  • 8.5、面向对象的三大特征
  • • 8.5.1、封装
    • 8.5.2、继承
    • 8.5.3、方法重写
    • 8.5.4、多态
    • 8.5.5、类的浅拷贝与深拷贝
• 九、模块
• • 9.1、 模块导入
  • 9.2、以主程序形式运行
  • 9.3、包的导入
• 十、文件操作
• 10.1、文件的读写操作
• 10.2、常用的文件打开模式
• 10.3、文件对象的常用方法
• 10.4、with语句(上下文管理器)
• 10.5、OS模块
• 其他有关Python的笔记

Python笔记（一）

一、概述
二、数据类型与字符串
三、流程控制
点此跳转

Python笔记（二）

四、列表与元组
五、字典与集合
点此跳转

六、字符串

在Python中字符串是基本数据类型，是一个不可变的字符序列

6.1、字符串的驻留机制

仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串的驻留池中
Python的驻留机制对相同的字符串只保留一份拷贝，后续创建相同字符串时，不会开辟新空间，而是把该字符串的地址赋给新创建的变量
驻留机制的几种情况(交互模式)
·字符串的长度为0或1时
·符合标识符的字符串
·字符串只在编译时进行驻留，而非运行时
·[-5,256]之间的整数数字

6.2、字符串的常用操作 6.2.1、字符串的查询操作的方法

方法	作用
index()	查找子串substr第一次出现的位置,如果查找的子串不存在时，则抛出ValueError
rindex()	查找子串substr最后一次出现的位置，如果查找的子串不存在时，则抛出ValueError
find()	查找子串substr第一次出现的位置,如果查找的子串不存在时，则返回-1
rfind()	查找子串substr最后一次出现的位置,如果查找的子串不存在时，则返回-1

s='hello, hello'
print(s.index('lo')) #3
print(s.find(' lo')) #3
print(s.rindex('lo')) #9
print(s.rfind('lo') )#9

6.2.2、字符串的大小写转换操作的方法

方法	作用
upper()	把字符串中所有字符都转成大写字母
lower()	把字符串中所有字符都转成小写字母
capitalize()	把第一个字符转换为大写，把其余字符转换为小写
title()	把每个单词的第一个字符转换为大写，把每个单词的剩余字符转换为小写
swapcase()	把字符串中所有大写字母转成小写字母，把所有小写字母都转成大写字母

s='hello,HELLO'
print(s.upper())#HELLO,HELLO
print(s.lower())#hello,hello
print(s.capitalize())#Hello,hello
print(s.title())#Hello,Hello
print(s.swapcase())#HELLO,hello

6.2.3、字符串内容对齐操作的方法

方法	作用
center()	居中对齐，第1个参数指定宽度，第2个参数指定填充符,第2个参数是可选的，默认是空格,如果设置宽度小于实际宽度则则返回原字符串
ljust()	左对齐，第1个参数指定宽度，第2个参数指定填充符,第2个参数是可选的，默认是空格如果设置宽度小于实际宽度则则返回原字符串
rjust()	右对齐,第1个参数指定宽度，第2个参数指定填充符,第2个参数是可选的，默认是空格如果设置宽度小于实际宽度则则返回原字符串
zfill()	右对齐，左边用0填充,该方法只接收一个参数，用于指定字符串的宽度，如果指定的宽度小于等于字符串的长度，返回字符串本身

s=' hello, Python'
'''居中对齐'''
print(s.center (20,'*')) #*** hello, Python***
'''左对齐'''
print(s.ljust (20,'*')) #*** hello, Python***
print(s.ljust(10))# hello, Python
print(s.ljust(20))#hello, Python
'''右对齐，使用0进行填充'''
print(s.zfill(20)) #000000 hello, Python
print(s.zfill(10))#hello, Python
print('-8910'.zfill(8))#-0008910

6.2.4、字符串劈分操作的方法

方法	作用
split()	从字符串的左边开始劈分，默认的劈分字符是空格字符串,返回的值都是一个列表;以通过参数sep指定劈分字符串是的劈分符；通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大次劈分之后，剩余的串会单独做为一部分
rsplit()	从字符串的右边开始劈分，默认的劈分字符是空格字符串,返回的值都是一个列表;以通过参数sep指定劈分字符串是的劈分符;通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大次劈分之后，剩余的串会单独做为一部分

s='hello world Python'
lst=s.split()
print(lst) #['hello', 'world', 'Python']
s1=' hello|world|Python'
print(s1.split(sep='|')) #[' hello', 'world', 'Python']
print(s1.split(sep=' l', maxsplit=1)) #[' hello|world|Python']

6.2.5、判断字符串操作的方法

方法	作用
isidentifier()	判断指定的字符串是不是合法的标识符
isspace()	判断指定的字符串是否全部由空白字符组成(回车、换行，水平制表符)
isalpha ()	判断指定的字符串是否全部由字母组成
isdecimal()	判断指定字符串是否全部由十进制的数字组成
isnumeric()	判断指定的字符串是否全部由数字组成
isalnum()	判断指定字符串是否全部由字母和数字组成

s=' hello, python'
print('1.',s.isidentifier())#False
print('2.','hello'.isidentifier()) #True
print('3.','张三_'.isidentifier()) #True
print('4.','张三_123'.isidentifier()) #True
print('5.','t'.isspace()) #True
print('6.', 'abc'. isalpha()) #True
print('7.','张三'.isalpha()) #True
print('8.','张三1'.isalpha()) #False
print('9.','123'.isdecimal())
print('10.','123四'.isdecimal())#False
print('11.','123' . isnumeric())#True
print('12.','123四'. isnumeric())#True
print('13.','II II ll '.isnumeric()) #True
print('14.', 'abc1' .isalnum())#True
print('15.','张三123'.isalnum())#True
print('16.','abc ! ' .isalnum())#False

6.2.6、字符串操作的其它方法

方法	作用
replace()	字符串替换
join()	字符串的合并

s='hello, Python'
print(s.replace(' Python', 'Java')) #hello,Java
lst=['hello', 'java', ' Python']
print('|'.join(lst))#hello|java| Python

6.3、字符串的比较

运算符:>,>=,<,<=,==,!=
比较规则:首先比较两个字符串中的第一个字符，如果相等则继续比较下一个字符，依次比较下去，直到两个字符串中的字符不相等时，其比较结果就是两个字符串的比较结果，两个字符串中的所有后续字符将不再被比较

print ('apple'>'app') #True
print('apple'>'banana') #False

'''==与is的区别=比较的是value
is比较的是id是否相等'''
a=b='Python'
c='Python'
print(a=-b)#True
print(b==c)#True
print (a is b)#True
print(a is c ) #True
print(id(a)) #2204259933168
print(id(b)) #2204259933168
print(id(c)) #2204259933168

6.4、字符串的切片操作

s='hello,Python'
s1=s[:5]
s2=s[6:]
s3='!'
newstr=s1+s3+s2
print(s1)#hello
print(s2)#Python
print(newstr)#hello!Python

6.5、格式化字符串

格式化字符串的两种方式

1. %作占位符

name='张三'
age=20
print('我叫%s,今年%d岁'% (name,age))#我叫张三,今年20岁

2. {}作占位符

print('我叫{0〕,今年{1}岁'.format (name, age))

3. f-string

print(f'我叫{name} ,今年{age}岁')

print('%10.3f' % 3.1415926)#一共总宽度为10，小数点后3位
print('{0 :.3}' .format (3.1415926)) #.3表示的是一共是3位数
print('{0:.3f] '.format(3.1415926)) #.3f表示是3位小数

6.6、字符串的编码转换

1. 编码

s='人生苦短'
print (s. encode (encoding='GBK'))

2. 解码

 s='人生苦短'
 byte=s.encode(encoding='GBK’)#编码
 print(byte.decode(encoding='GBK')) #解玛

七、函数

1. List item

7.1、函数的创建和调用

def 函数名（参数):
		函数体
	return xxx
def add(a,b):
	c=a+b
	return c

7.2、函数的参数传递

1. 位置实参
   根据形参对应的位置进行实参传递

def sub(a,b):
	c=a-b
	return c
sub(1,2)

2. 关键字实参
   根据形参名称进行实参传递

def sub(a,b):
	c=a-b
	return c
sub(b=2,a=1)

7.3、函数的返回值

函数返回多个值时，结果为元组

7.4、函数的参数定义

1. 函数定义默认值参数
   函数定义时，给形参设置默认值，只有与默认值不符的时候才需要传递实参

def add(a,b=10):
	c=a+b
	print(c)

add(1)#11
add(1,100)#101

2. 个数可变的位置参数
   定义函数时，可能无法事先确定传递的位置实参的个数时，使用可变的衍置参数
   使用*定义个数可变的位置形参
   结果为一个元组

def fun(*args):
	print(args)

fun(1)#(1,)
fun(1,2,3,4)#(1, 2, 3, 4)

3. 个数可变的关键字形参
   定义函数时，无法事先确定传递的关键字实参的个数时，使用可变的关键字形参
   使用**定义个数可变的关键字形参
   结果为一个字典

def fun (**args):
	print(args)

fun(a=10)
fun(a=10, b=20,c=30)

7.5、变量的作用域

1. 局部变量
   在函数内定义并使用的变量，只在函数内部有效，局部变量使用global声明，这个变量
   就会就成全局变量
2. 全局变量
   函数体外定义的变量，可作用于函数内外

def fun(a, b):
	c=a-b
	#c,就称为局部变量，因为c在是函数体内进行定义的变量, a, b为函数的形参，作用范围也是函数内部，相当于局部变量
	print(c)

def fun3():
	global age#函数内部定义的变量，局部变量，局部变量使用global声明，这个变量实际上就变成了全局变量age=20
	print(age)
	
print(age)

7.6、递归函数

如果在一个函数的函数体内调用了该函数本身，这个函数就称为递归函数

def fac(n) :
	if n==1:
		return 1:
	else:
		return n*fac (n-1)

print (fac(6))

7.7、Python的异常处理机制

try…except…else结构

try:
	n1=int(input('请输入一个整数:'))
	n2=int(input('请输入另一个整数:'))
	result=n1/n2
except baseException as e :
	print('出错了')
	print(e)
else:
	print('结果为:',result)

try…except…else…finally结构

try:
	n1=int(input('请输入一个整数:'))
	n2=int(input('请输入另一个整数:'))
	result=n1/n2
except baseException as e :
	print('出错了')
	print(e)
else:
	print('结果为:',result)
finally:
	print('无论是否产生异常，总会被执行的代码')

7.8、Python中常见的异常类型

异常类型	描述
ZeroDivisionError	除(或取模)零(所有数据类型)
IndexError	序列中没有此索引(index)
KeyError	映射中没有这个键
NameError	未声明/初始化对象(没有属性)
syntaxError	Python语法错误
ValueError	传入无效的参数

八、类与面向对象 8.1、 类的创建

1. 创建类的语法

class stu:
	pass

2. 类的组成·
   类属性
   实例方法
   静态方法
   类方法

class stu:
    address='school' #直接写在类里的变量，称为类属性

    #初始化方法
    def __init__(self,name,age):
        self.name=name #self.name称为实体属性，进行了一个赋值的操作，将局部变量的name的值赋给实体属性
        self.age=age

    #实例方法
    def study(self):
        print('学习')

    #静态方法
    @staticmethod
    def method():
        print('静态方法')

    #类方法
    @classmethod
    def cm(cls):
        print('类方法')

8.2、 对象的创建

实例名=类名()

stu1=stu('YoRHa',20)
stu1.study()
print(stu1.name)
print(stu1.age)

8.3、类属性、类方法、静态方法

类属性:类中方法外的变量称为类属性，被该类的所有对象所共享
类方法:使用@classmethod修饰的方法,使用类名直接访问的方法
静态方法:使用@staticmethod修饰的主法，使用类名直接访问的方法

print(stu.address)#访问类属性
stu.cm() #调用类方法
stu.method()#调用静态方法

8.4、动态绑定属性和方法

stu1=stu('YoRHa',20)
stu1.sex='null' # 动态绑定属性

def show():
    print('Show 函数')
stu1.show=show()
stu1.show

8.5、面向对象的三大特征 8.5.1、封装

提高程序的安全性
在Python中没有专门的修饰符用于属性的私有，如果该属性不希望在类对象外部被访问，前边使用两个“_”。

class formatage:
	def set_age(self, age);
		if 0<=age<=120:
			self.__age=age
		else:
			self.__age=18


print (stu._formatage_age)#在类的外部可以通过_类名__ 私有属性名 进行访问

8.5.2、继承

提高代码的复用性
语法格式
class 子类类名 (父类1,父类2…) :
pass

class son (Father):
	super().xxxxx
	pass

8.5.3、方法重写

与父类方法同名即可重写

8.5.4、多态

提高程序的可扩展性和可维护性

class Animal(object):
    def eat(self):
        print('动物会吃')
class Dog(Animal):
    def eat(self):
        print('狗吃骨头...')
class Cat (Animal) :
    def eat(self):
        print('猫吃鱼...')
class Person :
    def eat(self):
        print('人吃五谷杂粮')

#定义一个函数
def fun(obj) :
    obj.eat ()
#开始调用函数
fun(Cat())#猫吃鱼...
fun(Dog())#狗吃骨头...
fun(Animal())#动物会吃

8.5.5、类的浅拷贝与深拷贝

变量的赋值操作
只是形成两个变量，实际上还是指向同一个对象
浅拷贝
Python拷贝一般都是浅拷贝，拷贝时，对象包含的子对象内容不拷贝，因此，源对象与拷贝对象会引用同一个子对象
深拷贝
使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象,源对象和拷贝对象所有的子对象也不相同

class CPU:
    pass
class Disk:
    pass
class Computer:
    def __init__(self,cpu,disk):
        self.cpu=cpu
        self.disk=disk

cpu1=CPU()
cpu2=cpu1
#变量的赋值操作
print(id(cpu1))#2411981901296
print(id(cpu2))#2411981901296
#浅拷贝
disk=Disk()
computer1=Computer(cpu1,disk)
import copy
computer2=copy.copy(computer1)
print(computer1,computer1.cpu,computer1.disk)
#  
print(computer2,computer2.cpu,computer2.disk)
#  

#深拷贝
computer3=copy.deepcopy(computer1)
print(computer1,computer1.cpu,computer1.disk)
#  
print(computer3,computer3.cpu,computer3.disk)
#  <_Disk 0x000001A48BF10970>

九、模块

在Python中一个扩展名为.py的文件就是一个模块

9.1、 模块导入

import 模块名称 [as别名]

import math

from 模块名称 import函数/变量/类

from math import pi

9.2、以主程序形式运行

if _name_= '__main_' :
	pass

9.3、包的导入

import包名.模块名

十、文件操作 10.1、文件的读写操作

file = open(filename[,mode,encoding])

file:被创建的文件对象
open:创建文件对象的函数
filename:要创建或打开的文件名称
mode:打开模式默认为只读
encoding:默认文本文件中字符的编写格式为gbk

file=open('a.txt','r')
print (file.readlines())
file.close()

10.2、常用的文件打开模式

打开模式	描述
r	以只读模式打开文件，文件的指针将会放在文件的开头
w	以只写模式打开文件，如果文件不存在则创建，如果文件存在，则覆盖原有内容，文件指针在文件的开头
a	以追加模式打开文件，如果文件不存在则创建，文件指针在文件开头，如果文件存在，则在文件末尾追加内容，文件指针在原文件末尾
b	以二进制方式打开文件，不能单独使用，需要与共它模式一起使用，rb，或者wb
+	以读写方式打开文件，不能单独使用，需要与其它模式一起使用，a+

10.3、文件对象的常用方法

方法名	说明
read([size])	从文件中读取size个字节或字符的内容返回。若省略[size]，则读取到文件末尾，即一次读取文件所有内容
readline()	从文本文件中读取一行内容
readlines()	把文本文件中每一行都作为独立的字符串对象，并将这些对象放入列表返回
write(str)	将字符串str内容写入文件
writelines(s_list)	将字符串列表s_list写入文本文件，不添加换行符
seek(offset, whence])	把文件指针移动到新的位置，offset表示相对于whence的位置:offset:为正往结束方向移动，为负往开始方向移动。whence不同的值代表不同含义:0:从文件头开始计算（默认值)1:从当前位置开始计算2:从文件尾开始计算
tell()	返回文件指针的当前位置
flush()	把缓冲区的内容写入文件，但不关闭文件
close()	把缓冲区的内容写入文件，同时关闭文件，释放文件对象相关资源

10.4、with语句(上下文管理器)

with语句可以自动管理上下文资源,不论什么原因跳出with块,都能确保文件正确的关闭，以此来达到释放资源的目的

with open ('a.txt','r') as file:
	print(file.read ())

#复制文件
with open('logo.png', 'rb') as src_file:
	with open('copy2logo. png', 'wb') as target_file:
		target_file.write(src_file.read ())

10.5、OS模块

os模块是Python内置的与操作系统功能和文件系统相关的模块,该模块中的语句的执行结果通常与操作系统有关,在不同的操作系统上运行,得到的结果可能不一样。

os.system('notepad.exe')#记事本
os.system('calc.exe')#计算器
os.startfile('D:\Application\网易云音乐\CloudMusic\cloudmusic.exe')#网易云音乐播放器

函数	说明
getcwd()	返回当前的工作目录
listdir(path)	返回指定路径下的文件和目录信岛
mkdir(path[,mode])	创建目录
makedirs(path1/path2… . [, mode])	创建多级目录
rmdir(path)	删除目录
removedirs(path1/path2… …)	删除多级目录
chdir(path)	将path设置为当前工作目录

其他有关Python的笔记

点此跳转