Python基础知识

为个人笔记 可能存在问题 感谢指出

初始python

print函数

使用

输出内容:数字 字符串 含有运算符的表达式

内容输出的目的地:显示器 文件

将数据输出到文件中,使用file=

输出形式:换行 不换行

不进行换行输出

print("hello","world")

转义字符

\+想要实现转义功能首字母

原字符:不希望字符串中的转义字符起作用,在字符串之前加上r或R

最后一个字符不能是\,但可以是\\

标识符

保留字符查看

import keyword

print(keyword.kwlist)

变量,函数,类,模块和其他对象起的名字就叫标识符

字母,数字,下划线……

不能以数字开头

不能是保留字

严格区分大小写

变量

标识:表示对象所储存的内存地址,使用内置函数id(obj)来获取

类型:表示的是对象的数据类型,使用内置函数type(obj)来获取

值:表示对象所储存的具体数据,使用print(obj)可以将值进行打印输出

当多次赋值后,变量会指向新的空间

常用的数值类型

整数类型 int

浮点数类型 float

布尔类型 bool

字符串类型 str

整数类型

英文为integer,简写为int,可以表示正数,负数和0

整数的不同进制表示方法

十进制->默认的进制

二进制->以0b开头

八进制->以0o开头

十六进制->0x开头

浮点类型

浮点数整数部分和小数部分组成

浮点数储存不精确性

使用浮点数进行计算时,可能会出现小数位数不确定的情况

布尔类型

用来表示真或假的值

True表示真,False表示为假

布尔值可以转换为整数

True->1

False->0

字符串类型

字符串又被称为不可变的字符序列

可以使用单引号,双引号,三引号来定义

单引号和双引号定义的字符串必须在一行

三引号定义的字符串可以分布在连续的多行

数据类型转换

str()将其他数据类型转换成字符串也可以用引号转换

int()将其他数据类型转成整数文字类和小数类字符串,无法转换成整数 浮点数转换成整数 抹零取整

float()将其他数据类型转换成浮点数文字类无法转成整数 整数转成浮点数,末尾为

注释

在代码中对代码功能进行解释说明的标注性文字,可以提高代码的可读性

单行注释

以#开头 直到换行结束

多行注释

并没有单独的多行注释标记,将一对三引号之间的代码称为多行注释

中文编码声明注释 在文件开头加上中文声明注释,用以指定源码文件的编码格式

#coding:gbk

input函数

作用:接受来自用户的输入

返回值类型:输入值的类型为str

值得存储:使用=对输入的值进行存储

运算符

算术运算符

+加

-减

*乘

/除

%取余余数=被除数-除数*商

**幂运算

//整数(一正一负向下取整)

赋值运算符

=

执行顺序:右->左

支持链式赋值:a=b=c=20

支持参数赋值:+=,-=,*=,/=,//=,%=

支持系列解包赋值:a,b,c=20,30,40

比较运算符

>,<,>=,<=,!=

== 对象value的比较

is,is not 对象id的比较

布尔运算符

and

并且

or

或者

not

取反

in

not in

位运算符

位与&对应数位都是1,结果数位才是1,否则为0

位或|对于数位都是0,结果数位才是0,否则为1

左移位运算符<<高位溢出舍弃,低位补0

右移位运算符>>低位溢出舍弃,高位补0

对象的布尔值

python一切皆对象,所有对象都有一个布尔值

获取对象的布尔值

使用内置函数bool()

以下对象的布尔值为False

False

数值0

空字符串

空列表

空元组

空字典

空集合

分支结构

单分支结构

if 条件表达式:

条件执行体n

双分支结构

if 条件表达式

条件执行体1

else 条件表达式

条件执行体2

多分支机构

if 条件表达式1

条件执行体1

elif 条件执行体2

条件执行体2

elif 条件表达式n

条件执行体n

else

条件执行体n+1

条件表达式

x if 条件 else y

若条件成立,执行x,否则执行y

pass语句

语句什么都不做,只是一个占位符,用在语法上需要语句的地方

range()函数

用于生成一个整数序列

创建range对象的三种方式

range(stop)创建一个[0,stop)之间的整数序列,步长为1

range(start,stop)创建一个[start,stop)之间的整数序列,步长为1

range(start,stop,step)创建一个[start,stop)之间的整数序列,步长step

 

 

返回值是一个迭代器对象

range类型的优点 :

不管range对象表示的整数序列有多长,所有range对象占用的内存空间都是相同的,因为仅仅需要存储start,stop和step,只有当用到range对象时,才会去计算序列中的相关元素

in与not in 判断整数序列中是否存在(不存在)指定的整数

循环结构

循环的分类

while 条件表达式:

条件执行体

四部循环法

初始化变量

条件判断

条件执行体

改变变量

for-in循环

in表达从(字符串,序列等)中依次取值,又称为遍历

for-in遍历的对象必须是可迭代对象

for-in的语法结构

for 自定义的变量 in 可迭代对象

循环体

循环体内不需要访问自定义变量,可以将自定义变量替代为下划线

break语句

用于结束循环结构,通常与分支结构if一起使用

continue语句

用于结束当前循环,进入下一次循环,通常与分支结构if一起使用

else语句

与else语句配合使用的三种情况

if……

else……if条件表达式不成立时执行else

while……

else……没有碰到break时执行else

for……

else……没有碰到break时执行else

嵌套循环

循环语句中又嵌套另外的完整的循环结构,其中内层循环做为外层循环的循环体执行

二重循环中的break和continue用于控制本层循环

列表

可重复,有序

变量可以储存一个元素,而列表可以储存N多个元素,程序可以方便的对这些数据进行整体操作

列表相当于其他语言中的数组

列表的创建

列表需要使用[],元素之间使用英文的逗号进行分割

列表的创建方式

使用中括号

调用内置函数list()

列表的特点

列表元素按顺序有序排序

索引映射唯一个数据

列表可以储存重复数据

任意数据类型混存

根据需要动态分配和回收内存

列表的查询操作

index()

如查列表中存在N个相同元素,只返回相同元素中的第一个元素的索引

如果查询的元素在列表中不存在,则会抛出ValueError

还可以在指定的start和stop之间进行查询

获取列表中的单个元素

正向索引从0到N-1,

逆向索引从-N到-1

指定索引不存,抛出indexError

获取列表中的多个元素

列表名[start:stop:step]

切片操作

切片的结果:列表片段的拷贝

切片的范围:[start,stop)

step默认为1:简写为[start:stop]

step为正数:[:stop:step] 切片的第一个元素默认是列表的第一个元素

[start::step] 切片的最后一个元素默认是列表的最后一个元素 从start开始往后计算切片

step为负数:[:stop:step] 切片的第一个元素默认是列表的最后一个元素

[start::step] 切片的最后一个元素默认是列表的第一个元素 从start开始往前计算切片

列表元素的添加操作

append() 在列表的末尾添加一个元素

extend() 在列表的末尾至少添加一个元素

insert()在列表的任意位置添加一个元素

切片 在列表的任意位置添加至少一个元素

列表元素的删除操作

remove()

一次删除一个元素

重复元素只删除第一个

元素不存在抛出ValueError

不指定索引,删除列表中最后一个元素

pop()

删除一个指定索引位置上的元素

指定索引不存在抛出IndexError

不指定索引,删除列表中最后一个元素

切片

一次至少删除一个元素,将产生一个新的列表

clear() 清空列表

del 删除列表

列表元素的修改操作

为指定索引的元素赋予一个新值

为指定的切片赋予一个新值

列表元素的排序操作

调用sort()方法,列有中的所有元素默认按照从小到大的顺序进行排序,可以指定reverse=True,进行降序排序

调用内置函数sorted(),可以指定reverse=True,进行降序排序,原列表不发生变化

列表生成试

i*i for i in range(1,10)

表示列表元素的表达式中通常包含自定义变量

字典

key不可重复,value可重复,无序

python内置的数据结构之一,与列表一样是一个可变序列

以键值对的方式储存数据,字典是一个无序的序列

字典实现的原理

字典的实现原理与查字典类似,查字典是根据部首或拼音查找对应的页码,python中的字典是根据key查找value所在的位置

字典的创建

最常用的方式:使用花括号

scores={key value}

scores={'张三':100,'李四':98}

使用内置函数dict()

dict(name='jack',age=20)

字典元素的获取

[]scores['张三']

get()scores.get('张三')

[]取值与使用get()取值的区别

[]如果字典中不存在指定的key,抛出keyError异常

get()方法取值,如果字典中不存在指定的key,并不会抛出Key Error而是返回None,可以通过参数设置默认的value,以便指定的key不存在时返回

key的判断

in指定的key在字典中返回True'张三'in scores

not in指定的key在字典中不存在返回True 'Marry' not in scores

字典元素的删除

del scores['张三']

scores.clear() 清空字典的元素

字典元素的新增

scores['jack']=90

获取字典视图

keys()获取字典中所有的key

values()获取字典中所有value

items()获取字典中所有key,value对

字典元素的遍历

for item in scores:

print(item)

字典的特点

字典中的所有元素都是一个key-value对,key不允许重复,value可以重复

字典中的元素是无序的

字典中的key必须是不可变对象

字典也可以根据需要动态的伸缩

字典会浪费较大的内存,是一种使用空间换时间的数据结构

字典生成试

items=['Fruits','Books','Others']

prices=[96,78,85]

{'Fruits':96,'Books':78,'Others':85}

内置函数zip()

用于将可迭代的对象作为参数,将对象中对应的元素打包成一个元组,然后返回由这些元组组成的列表

items=['Fruits','Books','Others']

prices=[96,78,85]

lst=zip(items,prices)

print(list(lst))

元组

可重复,有序

python内置的数据结构之一,是一个不可变序列

不可变序列和可变序列

不可变序列:字符串,元组

没有增,删,改的操作

可变序列:列表,字典

可以对序列执行增,删,改操作,对象地址不发生更改

元组的创建方式

直接小括号 可以省略()

t=('python','hello',90)

使用内置函数tuple()

t=tuple(('python','hello',90))

只包含一个元组的元素需要使用逗号和小括号

t=(10,)

为什么要将元组设计成不可变序列

在多任务环境下,同时操作对象时不需要加锁

因此,在程序中尽量使用不可变序列

 

注意事项:元组中存储的是对象的引用

如果元组中对象本身不可对象,则不能再引用其它对象

如果元组中的对象是可变对象,则可变对象的引用不允许改变,但数据可以改变

元组的遍历

元组是可迭代对象,所以可以使用for…in进行遍历

t=tuple(('Python','hello',90))

for item in t:

print(item)

集合

不可重复,无序

 

Python语言提供的内置数据结构

与列表、字典一样都属于可变类型的序列

集合是没有value的字典

创建方式

直接{}

s={'python','hello',90}

使用内置函数set()

s=set(range(6))

print(s)

print(set([3,4,53,56]))

print(set((3,4,43,435)))

print(set('Python'))

print(set({124,3,4,4,5}))

print(set())

集合的相关操作

集合元素的判断操作

in或not in

集合元素的新增操作

调用add()方法,一次添中一个元素

调用update()方法至少添中一个元素

集合元素的删除操作

调用remove()方法,一次删除一个指定元素,如果指定的元素不存在抛出KeyError

调用discard()方法,一次删除一个指定元素,如果指定的元素不存在不抛异常

调用pop()方法,一次只删除一个任意元素

调用clear()方法,清空集合

集合间的关系

两个集合是否相等

可以使用运算符==或!=进行判断

一个集合是否是另一个集合的子集

可以调用方法issubset进行判断

B是A的子集

一个集合是否是另一个集合的超集

可以调用方法issuperset进行判断

A是B的超集

两个集合是否没有交集

可以调用方法isdisjoint进行判断

集合的数据操作

交集操作

print(s1,intersection(s2))

print(s1 & s2)

并集操作

print(s1.union(s2))

print(s1 | s2)

差集操作

print(s1.difference(s2))

print(s1-s2)

对称差集

print(s1.symmetric_difference(s2))

print(s1^s2)

集合生成试

{i*i for i in range(1,10)}

字符串的驻留机制

字符串

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

 

字符串驻留机制

仅保存一份相同且不可变字符串的方法,不同的值被存放在字符串的驻留池中,Python的驻留机制对相同的字符串只保留一份拷贝,后续创建相同字符串时,不会开辟新空间,而是把该字符串的地址赋给新创建的变量 

驻留机制的几种情况

字符串的长度为0或1时

符合标识符的字符串

字符串只在编译时进行驻留,而非运行时

[-5,256]之间的整数数字

字符串的查询操作

字符串的大小写转换方法

字符串内容对齐操作方法

 

字符串劈分操作

判断字符串操作的方法

 

字符串操作的其他方法

 

字符串的比较操作

运算符:>,>=,<,<=,==,!=

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

比较原理:两上字符进行比较时,比较的是其ordinal value(原始值),调用内置函数ord可以 得到指定字符的ordinal value。与内置函数ord对应的是内置函数chr,调用内置函数chr时指定ordinal value可以得到其对应的字符

==与is的区别

==比较的是value

is比较的是id是否相等

字符串的切片操作

字符串是不可变类型

不具备增、删、改等操作

切片操作将产生新的对象

格式化字符串

%作为占位符

{}作为占位符

字符串的编码转化

编码:将字符串转换为二进制数据

解码:将bytes类型的数据转换成字符串类型

函数的创建与调用

函数

函数就是执行特定任和已完成特定功能的一段代码

为什么要使用函数

复用代码

隐藏实现细节

提高可维护性

提高可读性便于调试

函数的创建

def 函数名([输入参数]):#形式参数,简称形参,形参的位置是在函数的定义出

函数体

[return xxx]

函数的调用

函数名 ([实际参数]) #实际参数,简称实参,实参的位置是函数的调用处

def calc(a,b):

c=a+b

return c

result=calc(10,20)

print(result)

res=calc(10,20)

print(result)

函数调用的参数传递

位置实参

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

关键字实参

根据形参名称进行实参传递

def fun(a,b=10):

print(a,b)

fun(100)

fun(20,30)

实参名称与形参名称可以不一致

如果是不可变对象,在函数体内修改不会影响实参的值

如果是可变对象,在函数体内的修改,会影响到实参的值

函数的返回值

如果函数没有返回值[函数执行完毕后,不需要给调用除提供数据] return可以省略不写

函数的返回值,如果是一个,直接返回类型

函数的返回值,如果是多个,返回的结果为元组

函数的参数定义

函数定义默认值参数

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

个数可变的位置参数

定义函数时,可能无法事先确定传递的位置实参的个数,使用可变的位置参数

使用*定义个数可变的位置形参

结果为一个元组

个数可变的位置形参,只能是一个

个数可变的关键字形参

 

定义函数时,无法事先确定传递的关键字实参的个数时,使用可变的关键字形参

使用**定义个数可变的关键字形参

结果为一个字典

个数可变的关键字形参,只能是一个

def fun(*args):

print(args)

fun(10)

fun(100,10)

fun(10,10,50)

def fun1(**args):

print(args)

fun1(a=10)

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

在一个函数的定义过程中,既有个数可变的关键字形参,也有个数可变的位置形参,要求个数可变的位置形参放在个数可变的关键字形参前面

 

 

 

def fun4(a,b,*,c,d):

从*之后只能采用关键字形参,*称之为关键字形参

变量的的作用域

程序代码能访问该变量的区域

根据变量的有效范围可分为

局部变量

在函数定义并使用的变量,只有在函数内部有效,局部变量使用global声明,这个变量就会成为全局变量

全局变量

函数体外定义的变量,可作用于函数内外

def fun(a,b):

c=a+b

print(c)

name="123"

print(name)

def fun2():

print(name)

fun2()

def fun3():

global age

age=20

print(age)

fun3()

print(age)

python的异常处理机制

python提供了异常处理机制,可以在异常出现时及时捕获,然后内部消化,让程序继续运行

try:

n1=int(input('请输入一个整数'))

n2=int(input('请输入另一个整数'))

result=n1/n2

print('结果为:',result)

except ZeroDivisionError:

print('除数不能为零')

多个except结构

捕获异常的顺序按照先子类后父类的顺序,为了避免遗漏可能出现的异常,可以在最后增加BaseException

try...except...else结构

如果try块中没有抛出异常,则执行else块,如果try块抛出异常,则执行except结构

try...except...else...finally结构

finally块无论是否发生异常都会被执行,常用来释放try块中申请的资源

 

python中常见的异常类型

trackback模块

使用traceback模块打印异常信息

类和对象

类是多个类似事物组成的群体的统称。能够帮助我们快速理解和判断事物的性质

数据类型

不同的数据类型属于不同的类

使用内置函数查看数据类型

print(type(100))

对象

100,99,250都是int类之下包含的相似的不同个例,这个例专业术语称为实例或对象

python中一切皆对象

类的创建

创建类的语法

class student:

pass

类的组成

类属性

实例方法

静态方法

类方法

class student:

native_pace='123' #直接写在类里的变量,称之为类属性

#实例方法

def __init__(self,name,age):

self.name=name #self.name称为实体属性,进行了一个赋值的操作,将局部变量的name的值赋给实体属性

self.age=age

def eat(self):

print('123') #在类之外定义的称之为函数,在类之内定义的称之为实例

#静态方法

@staticmethod

def method():

print('123') #使用了staticemthod进行修饰,所以是静态方法

#类方法

@classmethod

def cm(cls):

print('123') #使用了classmethod进行修饰,所以是类方法

对象的创建

对象的创建又称为类的实例化

语法

实例名=类名()

类属性,类方法,静态方法

类属性:类中方法外的变量称之为类属性,被该类的所有对象所共享

类方法:使用@classmethod修饰的方法,使用类名直接访问的方法

静态方法:使用@staticmethod修饰的方法,使用类名直接访问的方法

print(student.native_place) #访问类属性

student.cm() #调用类方法

student.sm() #调用静态方法

动态绑定属性和方法

python是动态语言,在创建对象后,可以动态的绑定属性和方法

一个类可以创建多个类的实例对象,每个实例对象的属性值可以不同

stu.gender='男'动态绑定性别

stu2.show=show动态绑定方法

class student:

def __init__(self,name,age):

self.name=name

self.age=age

def eat(self):

print(self.name+'eating')

 

stu1=student('zhangsan',20)

stu2=student('lisi',30)

#为stu2绑定动态属性

stu2.gender='g'

print(stu1.name,stu1.age)

print(stu2.name,stu2.age,stu2.gender)

stu1.eat()

stu2.eat()

def show():

print('定义在类之外的,称为函数')

stu1.show=show

stu1.show()

#stu2.show 因为stu2并没有绑定show方法

面向对象的三大特征

封装:

提高程序的安全性

将数据(属性)和行为(方法)包装到类对象中。在方法内部对属性进行操作,在类对象的外部调用方法。这样,无需关心方法内部的具体实现细节,从而隔离了复杂度

class car:

def __init__(self,brand):

self.brand=brand

def start(self):

print('123')

car=car('456')

car.start()

print(car.brand)

在python中没有专门的修饰符用于属性的私有,如果该属性不希望在类对象外部被访问,前面使用两个'_'

class student:

def __init__(self,name,age):

self.name=name

self.__age=age #年龄不希望在类的外部使用,所以加了两个__

def show(self):

print(self.name,self.__age)

 

stu=student('zhangsan',20)

stu.show()

#在类的外面使用name与age

print(stu.name)

#print(stu.__age)

print(dir(stu))

print(stu._student__age) #在类的外部可以通过 _student__age访问

继承:

提高代码的复用性

语法格式

class 子类类名(父类1,父类2...):

pass

如果一个类没有继承任何类,则默认继承object

python支持多继承

定义子类时,必须在其构造函数中调用父类的构造函数

class person(object):

def __init__(self,name,age):

self.name=name

self.age=age

def info(self):

print(self.name,self.age)

class student(person):

def __init__(self,name,age,stu_no):

super().__init__(name,age)

self.stu_no=stu_no

class teacher(person):

def __init__(self,name,age,teacheryear):

super().__init__(name,age)

self.teacheryear=teacheryear

 

 

stu=student('zhangsan',20,'1001')

teacher=teacher('lisi',34,21)

stu.info()

teacher.info()

方法重写

如果子类对继承自父类的某个属性或方法不满意,可以在子类中对其(方法体)进行重新编写

子类重写后的方法可通过super().xxx()调用父类中被重新编写过的方法

class person(object):

def __init__(self,name,age):

self.name=name

self.age=age

def info(self):

print(self.name,self.age)

class student(person):

def __init__(self,name,age,stu_no):

super().__init__(name,age)

self.stu_no=stu_no

def info(self):

super().info()

print(self.stu_no)

 

class teacher(person):

def __init__(self,name,age,teacheryear):

super().__init__(name,age)

self.teacheryear=teacheryear

def info(self):

super().info()

print(self.teacheryear)

 

stu=student('zhangsan',20,'1001')

teacher=teacher('lisi',34,21)

stu.info()

teacher.info()

object类

object类是所有类的父类,因此所有类都有object类的属性和方法

内置函数dir()可以查看指定对象所有属性

object有一个__str__()方法,用于返回一个对于"对象的描述",对应内置函数str()经常用于print()方法,帮我们查看对象信息,所以我们经常会对__str()__进行重写

class student:

def __init__(self,name,age):

self.name=name

self.age=age

def __str__(self):

return 'name:{0},age:{1}'

stu=student('zhangsan',20)

print(dir(stu))

print(stu) #默认会调用__str()__这样的方法

print(type(stu))

多态:

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

简单地说,多态就是具有多种形态,它指的是:即便不知道一个变量所应用的对象到底是什么类型,任然可以通过这个变量调用的方法,在运行过程中根据变量所引用对象的类型,动态决定调用哪个对象中的方法

class anmail(object):

def eat(self):

print("anmail can eat")

class dog(anmail):

def eat(self):

print('dog eat rou')

class cat(anmail):

def eat(self):

print('cat eat flash')

class person:

def eat(self):

print('person eat food')

 

#定义一个函数

def fun(obj):

obj.eat()

 

#开始调用函数

fun(cat())

fun(dog())

fun(anmail())

 

fun(person())

静态语言与动态语言

静态语言和动态语言的区别

静态语言实现多态的三个必要条件

继承

方法重写

父类引用指向子类对象

动态语言的多态崇尚鸭子类型,当看到一只鸟走起来像鸭子,游泳起来像鸭子、收起来也像鸭子,那么这只鸟就可以被称为鸭子。在鸭子类型中,不需要关心对象是什么类型,到底是不是鸭子,只关心对象的行为。

特殊属性和特殊方法

#print(dir(object))

class a:

pass

class b:

pass

class c(a,b):

def __init__(self,name):

self.name=name

class d(a):

pass

#创建c类对象

x=c('jack') #x是c类型的一个实例对象

print(x.__dict__) #实例对象的属性字典

print(c.__dict__)

print(x.__class__) #<class '__main__.c'> 输出了对象所属的类

print(c.__bases__) #c类的父类类型的元素

print(c.__base__) #类的基类(最近的那个类)

print(c.__mro__) #类的层次结构

print(a.__subclasses__())#子类的列表

 

a=20

b=100

c=a+b

d=a.__add__(b) #两个整数类型的对象的相加操作

print(c)

print(d)

class student:

def __init__(self,name):

self.name=name

def __add__(self, other):

return self.name+other.name

def __len__(self,name):

return len(self.name)

 

stu1=student('zhangsan')

stu2=student('liisi')

 

s=stu1+stu2 #实现了两个对象的加法操作(因为在student类中 编写__add__()特殊的方法)

print(s)

s=stu1.__add__(stu2)

print(s)

 

 

 

lst=[11,22,33,44]

print(len(lst)) #len是内置函数len

print(lst.__len__())

print(len(stu1))

class person(object):

def __new__(cls,*args,**kwargs):

print('__new__被调用执行,cls的id值为{0}'.format(id(cls)))

obj=super().__new__(cls)

print('创建对象的id为{0}'.format(id(obj)))

return obj

def __init__(self,name,age):

print('__init__被调用了,self的id值为{0}'.format(id(self)))

self.name = name

self.age=age

print('obiect这个类对象的id为{0}'.format(id(object)))

print('person这个类对象的id为{0}'.format(id(person)))

#创建person类的实例对象

p1=person('zhangsan',20)

print('p1这个person类的实例对象的id为{0}'.format(id(p1)))

类的赋值与浅拷贝

变量的赋值操作

只是形成两个变量,实际上还是指向一个对象

浅拷贝

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(cpu1,id(cpu1))

print(cpu2,id(cpu2))

#类的浅拷贝

disk=disk()#创建一个硬盘类的对象

computer=computer(cpu1,disk)#创建一个计算机类的对象

 

#浅拷贝

import copy

print(disk)

computer2=copy.copy(computer)

print(computer,computer.cpu,computer.disk)

print(computer2,computer2.cpu,computer2.disk)

 

#深拷贝

computer3=copy.deepcopy(computer)

print(computer3.cpu,computer3.disk)

print(computer.cpu,computer.disk)

模块

模块的英文为modules

函数与模块的关系

一个模块中可以包含n多个函数

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

使用模块的好处

方便其他程序和脚本的导入并使用

避免函数名和变量名冲突

提高代码的可维护性

提高代码的复用性

自定义模块

创建模块

新建一个.py文件,名称尽量不要与python自带的标准模块名相同

导入模块

import 模块名称 [as别名]

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

import math

print(id(math))

print(type(math))

print(math)

print(math.pi)

print(dir(math))

print(math.pow(2,3),type(math.pow(2,3)))

print(math.ceil(9.001))

 

from math import pi

print(pi)

以主程序形式运行

在每个模块的定义都包括一个记录模块名称的变量__name__,程序可以检查该变量,以确定他们在哪个模块中执行,如果一个模块不是被导入到其他程序中执行,那么他可能在解释器的顶级模块中执行,顶级模块的__name__变量的值为__main__

if __name__ = '__main__':

pass

python中的包

包是一个分层次的的目录结构,他将一组功能相近的模块组织在一个目录下

作用

代码规范

避免模块名称冲突

包与目录的区别

包含_init_.py文件的目录称为包

目录里通常不包含_init_.py文件

包的导入

import 包名.模块名

 

29.py

#在29.py中导入1包

import pageage1.module1 as a #amodule1这个模块的别名

 

print(a.a)

pageage1/module1.py

a=100

#导入带有包的模块时注意事项

import pageage1

import bcm

#使用import方式进行导入时,只能跟包名或模块名

from pageage1 import module1

from pageage1.module1 import a

#使用form...import可以导入包,模块,函数,变量

python中常用的内置模块

 

 

import sys

import time

import urllib.request

print(sys.getsizeof(24))

print(sys.getsizeof(30))

print(sys.getsizeof(True))

print(sys.getsizeof(False))

print(time.time())

print(time.localtime(time.time()))

print(urllib.request.urlopen('https://www.mzfxshs.top').read())

第三方模块的安装与使用

第三方模块的安装

pip install 模块名

第三方模块的使用

import 模块名

文件操作

编码格式

常见的字符编码格式

python的解释器使用的是unicode(内存)

.py文件在磁盘上使用的是UTF-8(外存)

#encoding=gbk

print('hello')

文件读写的原理

文件的读写俗称"IO操作"

文件读写操作流程

.py文件->解释器->OS->硬盘

操作原理

python操作文件->打开或新建文件->读,写文件->关闭资源

文件的读写操作

内置函数open()创建文件对象

语法规则

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

file=open('output.txt','r')

print(file.readlines())

file.close()

常用的文件打开模式

文件的类型

按文件中数据的组织形式,文件分为以下两大类

文本文件:储存的是普通字符文本,默认为unicode字符集,可以使用记事本程序打开

二进制文件:把数据内容用字节进行储存,无法用记事本打开,必须使用专用的软件打开

 

 

file=open('a.txt','w')

file.write('helloworld')

file.close()

file=open('a.txt','a')

file.write('helloworld')

file.close()

src_file=open('zhen.jpg','rb')

target_file=open('copy.jpg','wb')

target_file.write(src_file.read())

file.close()

文件对象的常用方法

 

 

file=open('a.txt','r')

print(file.read(2))

print(file.readline())

print(file.readlines())

file.close()

file=open('b.txt','a')

file.write('hello')

lst=['java','go','python']

file.writelines(lst)

file.close()

file=open('a.txt','r')

file.seek(3)

print(file.read())

print(file.tell())

file.close()

file=open('c.txt','a')

file.write('hello')

file.flush()

file.write('world')

file.close

with语句(上下文管理器)

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

 

print(type(open))

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

print(file.read())

#mycontentmgr实现了特殊方法__enter__();__exit__()称为该类对象遵守了上下文管理器协议,该类的实例对象成为上下文管理器

#mycontentmgr()

class mycontentmgr:

def __enter__(self):

print('enter')

return self

def __exit__(self,exc_type,exc_val,exc_tb):

print('exit')

def show(self):

print('show')

with mycontentmgr() as file: #相当于file=mycontenemgr()

file.show()

 

with open('zhen.jpg','rb') as s:

with open('123.jpg',"wb") as b:

b.write(s.read())

os模块的常用函数

目录操作

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

os模块与os.path模块用于对目录或文件进行操作

 

 

 

#os模块与操作系统相关的一个模块

import os

#os.system('notepad.exe')

#os.startfile('C:\\Program Files (x86)\\Tencent\\QQ\\Bin\\QQ.exe')

print(os.getcwd())

lst=os.listdir('pageage1')

print(lst)

#os.mkdir('test')

#os.makedirs('a/b/c')

#os.rmdir('a/b/c')

#os.removedirs('a/b')

os.chdir('E:\\vscode\\python\\demo')

 

 

import os.path

print(os.path.abspath('1.cpp'))

print(os.path.exists('1.cpp'),os.path.exists('222.py'))

print(os.path.join('E:\\vscode\\python','1.cpp'))

print(os.path.split('E"\\vscode\\python\\1.cpp'))

print(os.path.splitext('1.cpp'))

print(os.path.basename('E:\\vscode\\python\\1.cpp'))

print(os.path.dirname('E:\\vscode\\python\\1.cpp'))

print(os.path.isdir('E:\\vscode\\python\\1.cpp'))

 

#列出指定目录下的所有py文件

import os

path=os.getcwd()

lst=os.listdir(path)

for filename in lst:

if filename.endswith('.py'):

print(filename)

 

import os

path=os.getcwd()

lst_files=os.walk(path)

for dirpath,dirname,filename in lst_files:

'''print(dirpath)

print(dirname)

print(filename)

print('---------------------------')'''

for dir in dirname:

print(os.path.join(dirpath,dir))

print('------------------')

for file in filename:

print(os.path.join(dirpath,file))

posted @   梦在飞翔SHS  阅读(17)  评论(0编辑  收藏  举报
相关博文:
阅读排行:
· 在鹅厂做java开发是什么体验
· 百万级群聊的设计实践
· WPF到Web的无缝过渡:英雄联盟客户端的OpenSilver迁移实战
· 永远不要相信用户的输入:从 SQL 注入攻防看输入验证的重要性
· 浏览器原生「磁吸」效果!Anchor Positioning 锚点定位神器解析
点击右上角即可分享
微信分享提示