[Python知识库]Python基础语法学习记录

目录

输入输出：

输出函数print()

输入函数input()

转义字符 \

二进制

数据类型转化

注释

运算符

赋值

比较运算符

布尔运算

位运算

三目运算符

运算符优先级

对象的布尔值

pass语句

内置函数

range()函数

循环

常见数据结构

列表[]/dist([])

字典{}/dict()

元组()/tuple()

集合{}/set([])

字符串

函数的创建和调用

Python异常处理机制

类与对象

类的创建

类的组成

对象的创建

面向对象的三大特征

Object类

模块和包

模块

包

Python中常见的内置模块

文件读写原理

常见的文件打开模式

文件对象的常见方法

with语句

目录操作

项目打包

输入输出：

输出函数print()

1、输出到显示器

#换行
print('helloworld') 
#不换行
print('helloworld',end='')

2、输出到文件

#文件资源手动释放
fp = open('hellot.txt','a+')
#使用print()输出到文件中
print(str,file=fp)
#fp.write(str)
fp.close()
#文件资源自动释放
with open('hello.txt','a+') as fp:   #a+是追加写入
    fp.write(str)

输出多个相同的字符串

print('hello' * 5)

输入函数input()

a = input('note')

bote是提示语，提示需要输入的内容，a是得到的输入，默认是字符串，所以如果输出的是整数，那么

a = int(input('note'))

转义字符 \

换行(newline)：\n

水平制表符(tab，前面占满一个制表符就重写一个制表符，否则不重新开)：\t

回车(return，回到本行开始的位置)：\r

退格(backspace，回到前一个字符的位置)：\b

\\ \' \''等

不希望字符串中的转义字符起作用，在字符串前面加上r或者R即可。字符串最后一个字符不能是\

二进制

chr(data)：将十进制数转化为相应字符

ord(c)：将字符转化为相应十进制数

将十进制数转化为二进制数 bin(data)

将十进制数转化为八进制数 oct(data)

将十进制数转化为十六进制 hex(data)

print(chr(100))
print(ord('a'))
print(bin(100))
print(oct(100))
print(hex(100))

数据类型转化

str(data)：将其它数据类型转换为字符串

int(data)：将其它数据类型转化为整数类型，data是浮点数时值截取整数部分，data是字符串时，data只能是整数串，不能是文字串或者小数串

float(data)：data是整数，转化为data.0，data是字符串，可以是小数串，但不能是文字串

a = 10;
b = 123.45
c = True
print(str(a) + str(b) + str(c))

a = '12'
b = 14
c = 14.6
d = False
print(int(a) + int(b) + int(c) + int(d))

注释

单行注释(ctrl+/)：#

中文编码声明：在代码最前面加上注释：#encoding=gbk

多行注释：''' '''

运算符

?+ - * /

//：整除运算(一正一负，向下取整)

%：取余运算(一正一负：余数=被除数-除数*整除运算结果)

**：幂运算

print(11 // -2)   #一正一负，向下取整 -6
print(-11 // 2)
print(11 % -2)    #一正一负：余数 = 被除数 - 除数 * 商 11 - (-2) * (-6) = -1
print(-11 % 2)    #-11 - 2 * (-6) = 1

赋值

1、支持链式赋值：

a = b = c = 1

2、支持解包赋值：

a,b,c = 10,20,30

3、支持交换赋值：

a,b = b,a

比较运算符

>? <? >=? <=? ==? !=

is：比较两个变量的id

a is b   #比较a,b的id
a == b   #比较a,b的值

is not

布尔运算

与或非：and or not

in/not in：可用于判断某个元素是否在列表中等

位运算

位与&

位或|

左移<<，低位补0

右移>>，高位补0

#位运算
a,b = 4,8
print(a & b)  #按位与
print(a | b)  #按位或
print(a << 1)  #左移 低位补0
print(a >> 1) #右移 高位补零

三目运算符

true语句 if 条件 else false语句

print('答对了' if a == 0 else '答错了')

运算符优先级

幂运算，乘除，加减，位运算，布尔运算

对象的布尔值

? ? ? ? Python一切皆对象，所有对象都有一个布尔值，可以通过bool()函数获取。以下对象的布尔值是False：

pass语句

? ? ? ? 什么都不做，只做一个占位符：在写一个函数而不知道具体功能时，就可以在该函数体中写一个pass，到最后功能确定之后再写入

def fun():
    pass

内置函数

内置函数：可以直接使用的函数，不用调包

range()函数

range(start,stop,step)：用于生成一个序列，左闭右开[start,stop)

默认start为0，step为1

range()函数优点：只有用到其中元素的时候，才会计算序列中的相关元素，没有用到的时候，只存储start,stop,step

循环

while/for in

while 条件:
    pass
for i in range():
    pass

break：用于结束循环结构

continue：直接进行下一次循环

while/for与break、else配合使用：循环完也没有break，那么执行else语句

while/for :
    pass
    break
else:
    pass

常见数据结构

列表[]/dist([])

列表使用[]或者list([])来创建，相当于数组，但是时可变长、能存多种数据类型

特点：有序排列，可以通过索引获取元素。索引0,1,2,...或者-1,-2,-3,...

lst = [1,'hello',1.21]

获取列表指定元素的索引index()：是第一次出现的索引，若不存在，则抛出异常ValueError。也可以指定查找范围

lst.index('hello')
lst.index('hello',0,2)  #指定查找范围，左闭右开

根据索引获取元素[]：正向索引，负向索引：。索引不存在，抛出异常

print(lst[0],lst[-1])

获取列表的多个元素：切片lst[start:step:stop]

start默认是0，step默认是1，左闭右开

lst1 = lst[1:4:2]   #lst[1],lst[3]
lst2 = lst[::-1]    #lst[N-1],lst[N-2],...,lst[0]

判断是否再列表中in/not in

遍历列表for in

列表元素的添加lst.append()/lst.extend([])/lst.insert()/切片

lst.append(1)  #在列表尾添加一个元素
lst.extend(['hello','world'])   #在列表尾添加一个列表
lst.append(idx,1)   #在索引1位置处插入一个元素
lst[start:stop] = ['hello','world']  #将lst[start,stop)的元素替换为别的列表

列表元素的删除lst.remove()/lst.pop()/切片/lst.clear()/del lst

lst.remove('hello')   #删除第一个出现的'hello'
lst.pop(1)            #删除索引是1的元素，不填参数，就将最后一个元素删除
lst[1:2] = []         #切片，将[1,2)中所有元素删除
lst.clear()           #将lst中的所有元素清空
del lst               #删除lst

列表元素的修改：通过索引修改和通过切片修改

lst[1] = 'hi'
lst[1:3] = ['hi','Java']

列表元素的排序：lst.sort()/list.sort(reverse=True)/内置函数sorted()

lst = [1,2,5,4,3]
lst.sort()                 #升序排列
lst.sort(reverse = True)   #倒序排列
#内置函数sorted()进行升序排列，会产新的列表对象，lst顺序不变，lst1是lst升序排列
lst1 = sorted(lst)         
lst1 = sorted(lst,reverse = True)   #降序排列

enumerate()函数：将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标

lst = [12,21,34,54,65,32]
for i,v in enumerate(lst):     
    print(i,v)

列表生成器

#i*i是需要生成的表达式，列表实际存的是表达式的值
[i*i for i in range(1,10)]

字典{}/dict()

字典：可变(增删改)且无序的序列，以键值对(key:value，键需要进行哈希处理hash(key)，所以key是不可变序列)的方式存储数据

字典创建：{}/dict()

dic = {'123':321,'456':654}
dic = dict(name = 321,age = 654)

字典元素获取：dic[key]/dic.get(key)

dic = dict(name = '张三',age = 20)
print(dic['name'])      #这种获取方式，key不存在会报错
print(dic.get('age'))   #这种获取方法，key不存在不会报错，返回None
print(dic.get('gender','男'))  #key不存在，默认返回value

判断字典中键是否存在：in/not in

删除字典元素：del

清除字典clear()

通过[]增加或修改元素

dic = {'name':'张三','age':20}
print('name' in dic)   #判断键是否存在
del dic['name']        #删除键
dic.clear()            #清除字典
dic['gender'] = '男'   #通过[]新增元素
dic['gender'] = '女'   #通过[]修改字典

获取字典的视图：keys()/values()/items()

keys = dic.keys()        #获取字典所有的键，是列表
values = dic.values()    #获取字典所有的值，是列表
items = dic.items()      #获取字典所有的键值对，是列表，列表元素是键值对，以元组方式保存

字典的遍历

通过上面获得的键、值、键值对来进行遍历

for i in keys:
    print(dic.get(i),end=' ')

字典生成式

通过键列表、值列表以及内置函数zip()来产生字典{k:v for k,v in zip(keys,values)}

keys = ['name','age','gender','grade']
values = ['张三',20,'男',98]
dic = {k:v for k,v in zip(keys,values)}
for i in keys:
    print(dic.get(i),end='   ')

字典的特点：

键不能重复，会覆盖以前的键值，值可以重复

字典元素式无序的，字典可以动态伸缩，字典耗内存，空间换时间，查找时间快

元组()/tuple()

元组是不可变序列

元组的创建：()/tuple()

a = (12,'hello',32.5)    #通过()创建元组
a = 12,'hello',32.5      #可以去掉()
a = 12,                  #只有一个元素的元组需要加上逗号，以示区别
a = tuple((12,'hello',32.5))       #通过tuple(())创建元组
a = tuple((12,))

元组元素的获取

a = (12,'hello',23.4)
print(a[0]) ? ?#元组元素的获取：通过[]获取

将元组设计为不可变序列的原因：

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

2、元组中存的是各个元素的引用。元组中每个元素的引用不可修改，比如：某个元素是列表，那么不可将其修改为整数，但是可以对该列表进行增删改操作，同时列表的内存地址不变

元组的遍历

a = (12,'hello',23.4)
for i in a:
    print(i,end=' ')

集合{}/set([])

集合是可变类型序列，是没有value的字典。内存地址是通过哈希计算得到，所以是无序。自动实现去重操作

集合创建方式：{}/set([])/set(())/set({})/set('')

s = {12,'hello',34.5}
s = set([12,'hello',34.5])
s = set({12,'hello',34.5})
s = set('hello,world')    #通过字符串创建集合，集合元素是字符串的各个字符

集合元素的相关操作

in/not in

增加add()/update()

删除remove()/discard()/pop()/clear()

s = {12,'hello',34.5}
print(12 in s)          #判断是否存在
s.add(False)            #add()只能增加一个元素
s.update([23,'world'])  #updata()可以添加多个元素
s.update({90,'hi'})
s.update(('hii',))
s.remove('hii')         #remove()删去指定的一个，不存在报错
s.discard('90')         #discard()删去指定的一个，不存在不报错
s.pop()                 #pop()随机删除一个
s.clear()               #清空

集合之间的关系

判断集合是否相等== !=

判断是否是子集issubset()

判断是否是超集issuperset()

判断是否存在交集isdisjoint()

a = {1,2,3}
b = {1,2,4}
print(a == b)
print(a.issubset(b))
print(a.issuperset(b))
print(a.isdisjoint(b))

?集合之间的数学操作

交集intersection()或者&

并集union()或者|

差集difference()或者-

对称差集symmetric()_difference或者^

a = {1,2,3}
b = {1,2,4}
print(a.intersection(b),a & b)
print(a.union(b),a | b)
print(a.difference(b),a - b)
print(a.symmetric_difference(b),a ^ b)

集合生成式

就是将列表生成式的[]变成{}。没有元组生成式

s = {i*i for i in range(10)}

字符串

字符串是不可变的字符序列，修改字符串，那么地址变化

字符串的驻留机制：仅保留一份且不可变字符串的方法。对相同的字符串只保留一份拷贝，后续创建相同的字符串时，不会开辟新空间，而是将该字符串的地址赋值给新创建的变量。

驻留机制的优缺点：

1、当需要值相同的字符串时，可以直接从字符池中拿来使用，避免了频繁的创建和销毁，提升效率和节约内存，因此拼接字符串和修改字符串是比较影响性能的

2、当需要进行字符串拼接时建议使用str类型的join()，而非+。因为join()是先计算出所有字符串的长度，然后再拷贝，只new一次对象，效率要比+效率高

字符串的常用操作

字符串查询操作：index()/rindex()/find()/rfind()

s = 'hello,world,hello,world'
print(s.index('lo'))     #子串substr第一次出现的位置，不存在抛异常
print(s.rindex('lo'))    #子串substr最后一次出现的位置，不存在抛异常
print(s.find('lo'))      #子串substr第一次出现的位置，不存在返回-1
print(s.rfind('lo'))     #子串substr最后一次出现的位置，不存在返回-1

字符串的大小写转化upper()/lower()/swapcase()/capitalize()/title()

s = 'hello,wORld,hELlo,world'
print(s.upper())    #字符串全部字符转化为大写
print(s.lower())    #全部转化为小写
print(s.swapcase()) #大写变小写，小写变大写
print(s.capitalize())  #首字母变大写，其余变小写
print(s.title())       #每个单词的第一个字符变大写，其余变小写

字符串内容对齐操作：center()/ljust()/rjust()/zfill()

s = 'hello'
#居中对齐，第一个参数指定了字符串长度，后一个参数指定了填充字符，默认填充为空格
print(s.center(10,'*'))    
print(s.ljust(10,'*'))     #左对齐，参数同上
print(s.rjust(10,'*'))     #右对齐，参数同上
print(s.zfill(10))         #右对齐，默认填充0

字符串劈分：split()/rsplit()

s = 'hello,world,hello,world'
#通过参数sep设置分隔符，默认是空格，通过参数maxsplit来指定分隔的个数，结果是列表
print(s.split(sep=',',maxsplit=2))
print(s.rsplit(sep=',',maxsplit=2))   #从右侧开始分隔，参数同上

字符串去掉首尾指定的字符：strip([char])

s = '   hello    '
print(s.strip(' '))   #移除首尾所有的空格

判断字符串组成的方法：isidentifier()/isspace()/isalpha()/isdecimal()/sinumerc()/isalnum()

s = 'hello'
print(s.isidentifier())    #判断字符串是否是标识符(字母数字下划线)
print(s.isspace())         #判断字符串是否由空白字符组成(回车换行水平制表符)    
print(s.isalpha())         #是否由字母组成
print(s.isdecimal())       #是否由十进制数组成，不包括罗马数字等数字
print(s.isnumeric())       #是否由数字组成，包括罗马数字
print(s.isalnum())         #是否由字母和数字组成

字符串替换：replace()

s = 'hello,world,hello,world'
#第一个参数是需要替换的子字符串，后一个参数是替换后的字符串
print(s.replace('hello','hi'))   

字符串拼接：str.join([])

例如：'-'.join([a,b,c,d])'a-b-c-d'

'-'.join(['a','b','c','d'])    #'a-b-c-d'
''.join(['a','b','c','d'])     #'abcd'

字符串的比较操作：>= > < >= == !=(is比较的是地址)

比较规则：首先比较第一个字符，若不相同，结果就是这两个字符的比较结果，否则继续比较下一个字符

比较原理：比较其原始值，就是ordinal value，调用内置函数ord()可以得到原始值，chr()可以根据原始值得到相应字符

print(ord('a'))
print(chr(100))
a = 'apple'
b = 'app'
c = 'banana'
print(a == b)
print(a > b)
print(a < c)

字符串切片操作

字符串是不可变类型，不具备增删改操作，切片之后会产生新的对象

s = 'abcdefg'
s1 = s[1:5:2]   #[start:stop:step]：start默认0，stop默认是字符串长度，step默认是1
print(s,s1)

格式化字符串

进行格式化字符串的原因：按一定格式输出字符串

?格式化字符串的两种方式：

1、%用作占位符?

#%s字符串 %i或%d整数 %f浮点数。字符串后面加%()
s = '%s   %i    %d     %f'%('hello',10,20,12.3)
print(s)
#%ad前面填充空格使整个长度为a      %.af浮点数保留a位小数
s = '%10d     %.3f   %10.3f'%(10,12.3,12.3)
print(s)

2、{}用作占位符

%{}用作占位符，从0开始标号
s = '{0}   {1}   {2}'.format('hello',10,20)
print(s)
%{0：3}整个数占3位，{0：.3f}小数位占3位，{0：10.3f}整个数占10位，小数位3位
s = '{0:3}{1:.3f}{2:10.3f}'.format(12,12.3,12.3)
print(s)

3、f-string

name = '张三'
age = 20
print(f'{name}   {age}')

字符串的编码转换

进行字符串编码转换的原因：计算机之间传输通过二进制，需要将字符串进行编码转换为字节

编码：将字符串转换为二进制数据encode()方法

解码：将二进制数据转换为字符串类型decode()方法

编码和解码必须是同一个编码方式(GBK,UTF-8)

byte1 = '学Python'.encode(encoding='GBK')
byte2 = '学Java'.encode(encoding='UTF-8')
print(byte1)
print(byte2)
print(byte1.decode(encoding='GBK'))
print(byte2.decode(encoding='UTF-8'))

函数的创建和调用

函数的优点：复用代码、隐藏实现细节、提高可维护性、提高可读性便于调试

函数的创建

def fun([arg1,arg2,...]):
    pass
    [return xxx]

def add(a,b):
    return a + b

函数的参数传递

? ? ? ? 形参：函数定义处的参数

? ? ? ? 实参：函数调用处的参数

? ? ? ? 传参方式：

????????????????位置实参：按顺序传

????????????????关键字实参：根据形参名进行实参传递

def sub(a,b):
    return a - b
fun(10,20)   #位置实参
fun(b = 10,a = 20)   #关键字实参

不可变对象传递，在方法体中被修改之后，在执行完方法该对象的值不变；而列表、集合等可变对象在方法体中被修改之后，执行完方法后，该对象的值是修改后的值

a = 10
b = [11,12,13]
print(a,b)
fun(a,b)
print(a)
print(b)

函数的返回值

1、如果函数没有返回值，return可以不写

2、函数的返回值有多个，结果为元组

def fun():
    a = []
    b = []
    for i in range(11):
        if i % 2 == 0:
            a.append(i)
        else:
            b.append(i)
    return a,b
print(type(fun()))

函数的参数定义

1、在定义时对形参设置默认值，这样在调用函数时就不要对对应的实参进行赋值；当需要修改该形参时再对该参数进行赋值

2、个数可变的位置形参(只能有一个)：调用函数时实参数量不确定fun(*args)

? ? ? ? 形参是一个元组

def fun1(*args):
    print(args)   #这里打印的args是元组

fun1(10)
fun1(10,20)
fun1(10,20,30)
fun1(*[10,20,30])  #可以直接传列表作为实参

3、个数可变的关键字形参(只能有一个)：fun(**args)

? ? ? ? 形参是个字典

def fun2(**args):
    print(args)    #这里打印的args是字典

fun2(a = 10)
fun2(a = 10,b = 20,c = 30)
fun2(**{'a':10,'b':20,'c':30})    #可以直接传字典作为实参

变量的作用域

? ? ? ? 局部变量：函数内部定义的变量，只在函数内有效

? ? ? ? 全局变量：函数外定义的变量，在函数内外都有效

? ? ? ? 局部变量前面加上global变成全局变量

def fun():
    global a
    a = 100
fun()
print(a)

递归函数

? ? ? ? 递归的组成部分：递归调用和递归终止条件

? ? ? ? 每递归调用一次函数，都会在栈内存中分配一个栈帧

? ? ? ? 每执行完一次函数，都会释放相应的空间

#递归求解斐波那契数列
def fib(n):
    if n == 1:
        return 1
    elif n == 2:
        return 1
    else :
        x = fib(n-1) + fib(n-2)
        return x

print(fib(6))

递归函数的优缺点

? ? ? ? 缺点：占用内存多，效率低下

? ? ? ? 优点：思路和代码简单

Python异常处理机制

try:
    pass
except Exception1:     #捕获异常的顺序：先父类后子类
    pass
except Exception2:
    pass
except BaseException:  #为避免遗漏可能出现的异常，可以在最后加上BaseException
    pass

try:
    pass
except BaseException as e:
    print(e)     #打印异常
else:            #如果没有异常，那么执行else块
    pass

try:
    pass
except BaseException as e:
    print(e)     
else:            
    pass
finally:         #无论是否发生异常都会执行，常用来释放try块中申请的资源
    pass

类与对象

? ? ? ? 类：多个类似事物组成的群体的统称

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

? ? ? ? ? ? ? ? 使用内置函数type()可以查看变量的类型

? ? ? ? 对象：每个类实例化出来的个例

? ? ? ? Python中一切皆对象

类的创建

class ClassName:   #首字母大写
    pass

类的组成

? ? ? ? 类包括：类属性、初始化方法、实例方法、静态方法、类方法

#类的属性和方法
class Student:
    #类属性：直接写在类里面的变量，被所有对象所共有
    native_space = '南京'
    
    #初始化方法：对实例化出来的对象的属性进行初始化
    def __init__(self,name,age):
        self.name = name
        self.age = age

    #实例方法：通过对象或类名来调用
    def eat(self):
        print('吃饭')

    #静态方法：使用类名调用，需要加@staticmethod修饰
    @staticmethod
    def staMet():
        print('静态方法')

    #类方法:使用类名调用，需要加@classmethod修饰
    @classmethod
    def claMe(cls):
        print('类方法')

类里面定义的叫方法，类外面定义的叫函数

对象的创建

? ? ? ? 对象的创建又叫类的实例化

#对象的创建
stu = Student('Jack',20)
print(stu.name,stu.age)
stu.eat()
stu.staMet()
stu.claMe()
print(Student.native_space)
print(stu.native_space)
#类方法的调用
Student.claMe()
#静态方法的调用
Student.staMet()

动态绑定属性和方法(该属性和方法只属于该对象)

? ? ? ? 每个对象都有一个类指针指向创建它的类

? ? ? ? 动态绑定属性：创建好一个对象之后，可以给这个对象额外添加一个属性

? ? ? ? 动态绑定方法：创建好一个对象之后，可以给这个对象额外添加一个方法

#为stu对象动态绑定属性
stu.gender = '女'
print(stu.gender)

#为stu对象动态绑定方法
def show():
    print('为stu动态绑定方法')

stu.show = show
stu.show()

面向对象的三大特征

? ? ? ? 封装：提高程序的安全性

#封装
class People:
    def __init__(self,name,age):
        self.name = name
        self.__age = age      #加__使属性为私有的
    def show(self):
        print(self.name,self.__age)
    def info(self):
        print('姓名：{0}，年龄：{1}'.format(self.name,self.__age))
    def eat(self):
        print('人吃五谷杂粮')

? ? ? ? 继承：提高程序的复用性，默认是继承Object，不用写

#继承
class Teacher(People):       #可以同时继承多个父类
    def __init__(self,name,age,year):
        super().__init__(name,age)      #继承得到父类所有的属性
        self.year = year                #特有的属性
    #方法重写
    def info(self):
        super().info()
        print('教龄',self.year)

tea = Teacher('Jack',30,2)
tea.info()

? ? ? ? 多态：提高程序的可扩展性和可维护性

Object类

? ? ? ? Object类是所有类的父类，所以所有类都有Object类的属性和方法

? ? ? ? 使用dir()查看对象的所有属性和方法

? ? ? ? Object类有__str__()方法，由于会返回对一个对象的描述，所以经常对其进行重写。

#Object类
class Animal:   #相当于Animal(Object)
    #pass
    def __init__(self,name,age):
        self.name = name
        self.age = age
    #重写__str__()方法
    def __str__(self):
        return '名字{0},年龄{1}'.format(self.name,self.age)
    def eat(self):
        print('动物会吃')

ani = Animal('宝宝',2)
print(dir(ani))          #打印对象的所有属性和方法
print(ani.__str__())     
print(ani)               #默认调用__str__()方法，print(对象)就会调用对象的__str__()方法

类的浅拷贝和深拷贝
????????类变量的赋值操作：只是形成两个变量，实际上还是指向同一个对象
????????浅拷贝：Python拷贝一般都是浅拷贝，拷贝时对象包含的子对象内容不拷贝。因此源对象与拷贝对象会引用同一个子对象(拷贝产生新的对象，地址变了，但是该新对象的子对象(他的属性)仍然是原对象的子对象，地址不变)
????????深拷贝：使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象，源对象和拷贝对象所有的子对象也不相同(拷贝出来的新对象地址变量，而且其子对象(属性)地址也会发生改变)

#类的深拷贝和浅拷贝
import  copy
class CPU:
    pass
class DISK:
    pass
class Computer:
    def __init__(self,cpu,disk):
        self.cpu = cpu
        self.disk = disk

cpu1 = CPU()
disk = DISK()
computer = Computer(cpu1,disk)
#浅拷贝：拷贝本身，但是子对象仍然指向原来的
computer2 = copy.copy(computer)
print('---------------浅拷贝--------------')
print(computer,computer.cpu,computer.disk)
print(computer2,computer2.cpu,computer2.disk)
print('--------------深拷贝------------')
#深拷贝：递归拷贝所有对象，包括本身和其子对象
computer3 = copy.deepcopy(computer)
print(computer,computer.cpu,computer.disk)
print(computer3,computer3.cpu,computer3.disk)

模块和包

模块

? ? ? ? 一个模块包含很多函数、类(包括类属性、实例方法、类方法、静态方法)、语句。一个扩展名是.py的文件就是一个模块(module)

? ? ? ? 使用模块的好处：

? ? ? ? ? ? ? ? 1、方便其它程序和脚本的导入并使用

? ? ? ? ? ? ? ? 2、避免函数名和变量名冲突

? ? ? ? ? ? ? ? 3、提高代码的可维护性

? ? ? ? ? ? ? ? 4、提高代码的可重用性

模块的导入：

#导入整个模块
import math  #为后面调用的方便可以使用别名，import math as m
print(math.pi)
print(math.ceil(9.01))      #大于参数的最小整数
print(math.floor(9.01))     #小于参数的最大整数

#导入模块的某个函数/变量/类
from math import pi
print(pi)
from math import pow
print(pow(2,3)) 

导入自定义模块的方法：使存放模块的项目变成源根

? ? ? ? Make Directory as Source root

以主程序形式运行

????????当点击运行该模块时，就会执行该__name__()方法，别的模块调用该模块时，不会执行该方法。

def add(a,b):
    return a + b

if __name__ == '__main__':
    print(add(10,20))

包

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

? ? ? ? 作用：代码规范，避免模块名称冲突

? ? ? ? 包和目录的区别：

? ? ? ? ? ? ? ? 包含__init__().py文件的目录称为包

? ? ? ? ? ? ? ? 目录中通常不包含__init__().py文件

Python中常见的内置模块

#Python中常见的内置模块
import sys
print(sys.getsizeof(12))
print(sys.getsizeof(True))
print(sys.getsizeof(1100))

import time
#time.time()获取从1970.1.1到此时过了多少浮点秒数
print(time.time()) 
#time.localtime()将浮点秒数转化为年月日时分秒格式
print(time.localtime(time.time())) 
#得到类似'Tue Dec 11 18:07:14 2008'的时间表达
print(time.asctime(time.localtime(time.time()))) 
#将年月日时分秒转化为想要的格式
print(time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time())))
 
import urllib.request as uq
#获取某个网站的信息
print(uq.urlopen('http://www.baidu.com').read())   

文件读写原理

? ? ? ? 文件读写俗称：IO操作

? ? ? ? 文件读写操作流程：python操作文件打开或新建文件读写文件关闭资源

? ? ? ? 文件读写操作：内置函数open()创建文件对象

#fp被创建的文件对象，filename要打开或创建的文件名称，mode读写等，encoding编码格式
fp = open(filename[,mode,encoding])
fp.readlines()   #返回一个列表

常见的文件打开模式

file = open('a.txt','r',encoding='utf-8')
print(file.readlines())     #返回的是列表，列表中的每一个元素对应文件的每一行
file.close()

file = open('b.txt','w',encoding='utf-8')
file.write('hello')
file.close()

file = open('a.txt','a',encoding='utf-8')
file.write('hello')
file.close()

src_file = open('logo.jpg','rb')   #以二进制方式读取图片
tar_file = open('copy.png','wb')   #以二进制方式写入图片
tar_file.write(src_file.read())
src_file.close()
tar_file.close()

文件对象的常见方法

#文件对象的常见方法
file = open('a.txt','r',encoding='utf-8')
print(file.read())   #read()读取文件全部内容
print(file.read(10))  #read([size])：读取文件前size个字符
print(file.readline())   #读取一行
print(file.readlines())  #读取所有行
file = open('a.txt','a')  #a追加
lst = ['\n','java','python','c++']
file.writelines(lst)     #写多行
file.close()


file = open('a.txt','r')
file.seek(4)     #将文件指针定位在某个位置
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块，都能确保文件资源正常的关闭，因此来达到释放资源的目的(不用手动释放资源)

#with语句：不用手动关闭文件资源
with open('a.txt','r') as file:
    print(file.read())

#with语句实现图片的复制
with open('logo.jpg','rb') as src_file:
    with open('copypic.png','wb') as tar_file:
            tar_file.write(src_file.read())

目录操作

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

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

import os
os.system('notepad.exe')   #打开记事本
os.system('calc.exe')      #打开计算器
#直接调用可执行文件
os.startfile('D:\\copytranslator\\install\\copytranslator.exe')

? ? ? ? os模块操作目录的相关函数

#os模块操作目录相关函数
print(os.getcwd())
lst = os.listdir('../hello')   #返回指定路径下的文件和目录信息
print(lst)

os.mkdir('newdir')    #创建新目录(在当前目录下)
os.makedirs('A/B/C')   #创建多级目录
os.rmdir('newdir')
os.removedirs('A/B/C')
os.chdir('D:\\python\\project\\hello\\mulu')   #修改工作目录
print(os.getcwd())
lst_file = os.walk(path)    #递归某个目录，得到这个目录下所有文件(包括子目录下)

? ? ? ? os.path模块操作目录相关函数

#os.path模块操作目录相关函数
import os.path as op
print(op.abspath('a.txt'))   #获取文件或目录的绝对路径
print(op.exists('b.txt'),op.exists('d.txt'))
print(op.join('D:\\python\\project','a.txt'))  #路径拼接
print(op.splitext('a.txt'))    #将文件的文件名和扩展名拆分
print(op.basename('D:\\python\\project\\hello\\fifth.py'))   #提取文件名
print(op.dirname('D:\\python\\project\\hello\\fifth.py'))  #提取目录
print(op.isdir('D:\\python\\project\\hello'))  #判断是否是路径

项目打包

? ? ? ? 将写好的能够正常运行的.py文件打包为可执行文件.exe

步骤：

1、下载第三方模块

pip install PyInstaller

2、执行打包操作

pyinstaller -F ?D:\python\project\studentsys\studentsys.py