使用
输出内容:数字 字符串 含有运算符的表达式
内容输出的目的地:显示器 文件
将数据输出到文件中,使用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
作用:接受来自用户的输入
返回值类型:输入值的类型为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
语句什么都不做,只是一个占位符,用在语法上需要语句的地方
用于生成一个整数序列
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 判断整数序列中是否存在(不存在)指定的整数
条件执行体
四部循环法
初始化变量
条件判断
条件执行体
改变变量
in表达从(字符串,序列等)中依次取值,又称为遍历
for-in遍历的对象必须是可迭代对象
for-in的语法结构
for 自定义的变量 in 可迭代对象
循环体
循环体内不需要访问自定义变量,可以将自定义变量替代为下划线
用于结束循环结构,通常与分支结构if一起使用
用于结束当前循环,进入下一次循环,通常与分支结构if一起使用
与else语句配合使用的三种情况
if……
else……if条件表达式不成立时执行else
while……
else……没有碰到break时执行else
for……
else……没有碰到break时执行else
循环语句中又嵌套另外的完整的循环结构,其中内层循环做为外层循环的循环体执行
二重循环中的break和continue用于控制本层循环
可重复,有序
变量可以储存一个元素,而列表可以储存N多个元素,程序可以方便的对这些数据进行整体操作
列表相当于其他语言中的数组
列表需要使用[],元素之间使用英文的逗号进行分割
列表的创建方式
使用中括号
调用内置函数list()
列表元素按顺序有序排序
索引映射唯一个数据
列表可以储存重复数据
任意数据类型混存
根据需要动态分配和回收内存
如查列表中存在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()在列表的任意位置添加一个元素
切片 在列表的任意位置添加至少一个元素
一次删除一个元素
重复元素只删除第一个
元素不存在抛出ValueError
不指定索引,删除列表中最后一个元素
删除一个指定索引位置上的元素
指定索引不存在抛出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('张三')
[]如果字典中不存在指定的key,抛出keyError异常
get()方法取值,如果字典中不存在指定的key,并不会抛出Key Error而是返回None,可以通过参数设置默认的value,以便指定的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}
用于将可迭代的对象作为参数,将对象中对应的元素打包成一个元组,然后返回由这些元组组成的列表
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可以得到其对应的字符
==比较的是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提供了异常处理机制,可以在异常出现时及时捕获,然后内部消化,让程序继续运行
try:
n1=int(input('请输入一个整数'))
n2=int(input('请输入另一个整数'))
result=n1/n2
print('结果为:',result)
except ZeroDivisionError:
print('除数不能为零')
捕获异常的顺序按照先子类后父类的顺序,为了避免遗漏可能出现的异常,可以在最后增加BaseException
如果try块中没有抛出异常,则执行else块,如果try块抛出异常,则执行except结构
finally块无论是否发生异常都会被执行,常用来释放try块中申请的资源
使用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类的属性和方法
内置函数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
包是一个分层次的的目录结构,他将一组功能相近的模块组织在一个目录下
作用
代码规范
避免模块名称冲突
包与目录的区别
包含_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可以导入包,模块,函数,变量
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块,都能确保文件正确的关闭,以此来达到释放资源的目的
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模块是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))
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】凌霞软件回馈社区,博客园 & 1Panel & Halo 联合会员上线
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】博客园社区专享云产品让利特惠,阿里云新客6.5折上折
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步
· 在鹅厂做java开发是什么体验
· 百万级群聊的设计实践
· WPF到Web的无缝过渡:英雄联盟客户端的OpenSilver迁移实战
· 永远不要相信用户的输入:从 SQL 注入攻防看输入验证的重要性
· 浏览器原生「磁吸」效果!Anchor Positioning 锚点定位神器解析