Python基础
python中的输出函数
print()
函数- 可以输出的内容
- 数字
- 字符串
- 含有运算符的表达式(会返回表达式计算的结果)
- 内容输出的目的地
- 显示器
- 文件
# 将数据输入文件中,注意点——所指的盘必须存在——使用file=fp fp = open('路径','模式') print('hello',file = fp) fp.close
- 输出形式
- 换行
- 不换行
print('word','hh')
- 可以输出的内容
转义字符
为什么需要转义字符?
- 当字符串中包含反斜杠、单引号和双引号等有特殊用途的字符时,必须使用反斜杠对这些字符进行转义(转换一个含义)
- 反斜杠:\
- 单引号:’
- 双引号:"
- 当字符串中包含换行、回车,水平制表符或退格等无法直接表示的特殊字符时,也可以使用转义字符当字符串中包含换行.回车,水平制表符或退格等无法直接表示的特殊字符时,也可以使用转义字符
- 换行:\n
- 回车:\r
- 水平制表符:\t
- 退格:\b
变量的定义和使用
变量是内存中一个带标签的盒子
变量由三部分组成
- 标识:表示对象所存储的内存地址,使用内置函数id(obj)来获取
- 类型:表示的是对象的数据类型,使用内置函数type(obj)来获取
- 值:表示对象所存储的具体数据,使用print(obj)可以将值进行打印输出
数据类型
-
常用类型
- 整数类型 -> int -> 98
- 浮点数类型 -> float -> 3.14
- 布尔类型 -> bool -> True Flase
- 字符串类型 -> str -> ‘ssss’
-
整数类型
- 可正 可负 可为0
- 十进制-默认
- 二进制-以0b开头
- 八进制-以0o开头
- 十六进制-以0x开头
-
浮点类型
- 由整数部分和小数部分组成
- 浮点数存储不精确
- 解决方案(导入decimal)
from decimal from Decimal print(Decimal('1.1')+Decimal('2.2'))
-
布尔类型
- 可转化为整数 True->1 False->0
-
字符串
- 可以用单引号’'双引号""三引号
- 单引号、双引号的字符串必须在同一行
- 三引号的字符串可以分布在连续多行 类似JavaScript的``
数据类型转换
- str()
- 将其他数据类型转成字符串
- 也可以用引号转换
- int()
- 将其他数据类型转成整数
- 文字类和小数类字符串无法转换为整数
- 浮点数转换为整数:抹零取整
- float()
- 将其他数据类型转化为浮点数
- 文字类型无法转化成整数
- 整数转浮点数:末尾补.0
注释
在代码中对代码的功能进行解释说明的标注性文字,可以提高代码的可读性
注释的内容会被Python解释器忽略·通常包括三种类型的注释
- 单行注释→以"#"开头,直到换行结束
- 多行注释→并没有单独的多行注释标记,将一对三引号之间的代码称为多行注释
- 中文编码声明注释→在文件并头加上中文声明注释,用以指定源码文件的编码格式
输入函数 input
input函数
- 作用->接收来自用户的输入
- 返回值类型->输入值的类型为str
- 值的存储->使用=对输入值进行存储
运算符
- 算数运算符
- 标准运算符 (±*/ //整除是一正一反向下取整)
- 取余运算符 (%)一正一反要遵循 余数=被除数-除数*商
- 幂运算符(**)
- 赋值运算符
- 支持链式赋值a=b=0 注意链式赋值时的变量们的地址会相同
- 支持参数赋值 += -= *=
- 支持系列解包赋值 a,b,c = 20,30,40
- 当内存中有相同的基础类型值时,会直接将该值的地址赋给新的变量,使得两个相同的值的变量地址相同。而引用类型的值会重新指向一个新的内存地址
- 比较运算符
- is 用于判断地址id是否相同 == 用于判断值是否相同
- 布尔运算符
- and
- not
- or
- 位运算符
- 位与 &
- 位或 |
- 左移位运算符<< -> 高位溢出舍弃,低位补0
- 右移位运算符>> -> 低位溢出舍弃,高位补0
优先级:** *///% ± <<>> & | ><>=<===!= and or =
对象的布尔值
python一切皆对象
- False
- 数值0
- None
- 空字符串
- 空列表[] list()
- 空元组() tuple()
- 空字典 {} dict()
- 空集合 set()
以上皆为false,其他对象的布尔值均为true
分支结构
if a>b:
a = b-2
elif a==b:
a = c
else:
if a==b:
print(1)
else:
条件表达式
语句 if 条件 else 语句
类似JavaScript的三元运算符
pass语句
该语句什么都不做,只是一个占位符,用在语法上需要语句的地方
常用于还没想好代码怎么写 先搭建语法结构
range()函数
range为一个内置函数
- 用于生成一个整数序列
- 创建range对象有三种方式
# 第一种创建方式 range(stop)
r = range(10)
print(r) # range(0,10)
print(list(r)) # [0,1,2,3,4,5,6,7,8.9]
# 第二种创建方式 range(start,stop)
r = range(1,10)
print(list(r)) # [1,2,3,4,5,6,7,8.9]
# 第三种创建方式 range(start,stop,step)
r = range(1,10,2)
print(list(r)) # [1,3,5,7,9]
- 返回值是一个对象
- range类型的优点:不管range对象表示的整数序列有多长,所有range对象占用的内存空间都是相同的,因为仅仅需要存储start,stop和step,只有当用到range对象时,才会去计算序列中的相关元素
- in与not in判断整数序列中是否存在(不存在)指定的整数
循环结构
while 条件:
执行体
for 自定义变量 in 可迭代对象:
循环体
else:
# 没有遇到break的时候会执行else
列表
- 变量可以存储一个元素,而列表是一个“大容器”可以存储N多个元素,程序可以方便地对这些数据进行整体操作
- 列表相当于其他语言中的数组
#创建列表的第一种方式 使用[]
lst = ['sss','fsdf']
#创建列表的第二方式,使用内置函数list()
lst = list(['ss','gg'])
列表的特点
- 列表元素按顺序有序排列
- 索引映射唯一数据
- 列表可以存储重复数据
- 任意数据类型混存
- 根据需要动态分配和回收内存
列表的查询操作
- 获取列表中指定元素的索引 index(‘元素’,‘起始位置’,‘终止位置’)
- 获取列表中的单个元素
- 判断指定元素在列表中是否存在
元素 in 列表名
元素 not in 列表名
- 元素遍历
for 变量 in 列表名
列表的切片操作
lst = ['sss','fsdf']
lst['起始','结束','步长']
列表元素的增删改
- 增加
append()
在列表末尾添加一个元素extend()
在列表的末尾至少添加一个元素insert()
在列表的任意位置添加一个元素- 切片 在列表的任意位置添加至少一个元素
- 删除
remove()
一次删除一个元素,重复元素只删第一个,元素不存在就报错pop()
删除一个指定索引上的元素- 切片 一次至少删除一个元素
clear()
清空del
删除列表
- 修改
- 为指定索引的元素赋予一个新值
- 为指定的切片赋予一个新值
列表的排序操作
- 调用sort()方法,列有中的所有元素默认按照从小到大的顺序进行排序,可以指定reverse=True,进行降序排序
- 调用内置函数sorted(),可以指定reverse=True,进行降序排序,原列表不发生改变
列表生成式
lst = [i*i for i in range(1,10)]
字典
- Python内置的数据结构之一,与列表一样是一个可变序列
- 以键值对的方式存储数据,字典是一个无序的序列
- 字典的实现原理与查字典类似,查字典是先根据部首或拼音查立的页码,Python中的字典是根据key查找value所在的位置
字典的创建方式
# 第一种方法 花括号
scores = {'张三':100,'李四':98,'王五':45}
# 第二种方法 内置函数dict()
dict(name='jack',age=30)
字典元素的获取
# 方法一 []
scores['张三']
# 方法二 get()
scores.get('张三')
# 如果没有 则可以返回默认值
scores.get('hh',99)
- 取值与使用get()取值的区别
- 如果字典中不存在指定的key,抛出keyError异常
- get()方法取值,如果字典中不存在指定的key,并不会抛出KeyError而是返回None,可以通过参数设置默认的value,以便指定的key不存在时返回
字典常用操作
- key的判断
'张三' in scores
'hh' not in scores
- 删除
del scores['张三']
- 新增
scores['jack'] = 90
字典视图的三个方法
- keys() 获取字典中所有key
- values() 获取字典中的所有values
- items() 获取字典中所有key,value对
字典的遍历
for item in scores:
print(item)
字典的特点
- 字典中的所有元素都是一个 key-value对, key不允许重复, value可以重复
- 字典中的元素是无序的
- 字典中的key必须是不可变对象·字典也可以根据需要动态地伸缩
- 字典会浪费较大的内存,是一种使用空间换时间的数据结构
元组
Python内置的数据结构之一,是一个不可变序列
不可变序列 与 可变序列
- 不变可变序:字符串、元组(没有增、删、改的操作)
- 可变序列:列表、字典(可以增删改操作,对象地址不发生改变)
元组的创建
# 第一种 直接小括号
t = ('python','hello',90)
# 第二种 内置函数
t = tuple(('python','hello',90))
# 第三种 只包含一个元组的元素需要使用逗号和小括号
t = (10,)
为什么要将元组设计成不可变序列
- 在多任务环境下,同时操作对象时不需要加锁·因此,在程序中尽量使用不可变序列
- 注意事项:元组中存储的是对象的引用
- 如果元组中对象本身不可对象,则不能再引用其它对象
- 如果元组中的对象是可变对象,则可变对象的引用不允许改变,但数据可以改变
元组的遍历
元组是可迭代对象
for...in...
集合
- python语言提供的内置数据结构
- 与列表、字典一样都属于可变类型的序列
- 集合是没有value的字典
集合的创建方式
# 第一种 直接{}
s = { 'Python','hello',90 }
# 第二种 内置函数set()
s = set(range(6))
集合中的元素不允许重复,重复的会自动舍去
集合的相关操作
- 集合元素的判断操作
-in或not in - 集合元素的新增操作
- 调用add()方法,一次添中一个元素
- 调用update()方法至少添中一个元素
- 集合元素的删除操作
- 调用remove()方法,一次删除一个指定元素,如果指定的元素不存在抛KeyError
- 调用discard()方法,一次删除一个指定元素,如果指定的元素不存在不抛异常
- 调用pop()方法,一次只删除一个任意元素
- 调用clear()方法,清空集合
集合间的关系
- 两个集合是否相等
-可以使用运算符==或!=进行判断 - 一个集合是否是另一个集合的子集
- 可以调用方法issubset()进行判断
- B是A的子集
- 一个集合是否是另一个集合的超集
- 可以调用方法issuperset()进行判断
- A是B的超集
- 两个集合是否没有交集
- 可以调用方法isdisjoint()进行判断
集合的数学关系
- 交集 s1 & s2
- 并集 s1.union(s2) s1|s2
- 差集 s1.difference(s2) s1-s2
- 对称差集 s1.symmetric_difference(s2) s1^s2
字符串
在Python种字符串是基本数据类型,是一个不可变的字符串序列
字符串的驻留机制
仅保存一份相同且不可变字符串的方法,不同的值被存放在字符串的驻留池中, Python的驻留机制对相同的字符串只保留―份拷贝,后续创建相同字符串时,不会开辟新空间,而是把该字符串的地址赋给新创建的变量
- 驻留机制的几种情况(交互模式)
- 字符串的长度为0或1时
- 符合标识符的字符串
- 字符串只在编译时进行驻留,而非运行时
- [-5,256]之间的整数数字
- sys中的intern方法强制2个字符串指向同一个对象
- PyCharm对字符串进行了优化处理
字符串的常用操作
-
查找
- index() 查找字符串substr第一次出现的位置,如果查找的子串不存在时,报错
- rindex() 查找字符串substr最后一次出现的位置,如果查找的子串不存在时,报错
- find() 查找子串substr第一次出现的位置,如果查找的子串不存在时,返回-1
- rfind() 查找子串substr最后一次出现的位置,如果查找的子串不存在时,返回-1
-
大小写转换
- upper() 把字符串中所有字符串都转化成大写字母
- lower() 把字符串中所有字符串都转化成小写字母
- swapcase() 把字符串中所有大写字母转成小写字母,把所有小写字母都转化成大写字母
- capitalize() 把第一个字符转化成大写,把其余字符转化为小写
- title() 把每一个单词的第一个字符转化为大写,把每个单词的剩余字符转化为小写
-
内容对齐
- center() 居中对齐,第1个参数指定宽度,第2个参数指定填充符,第2个参数是可选的,默认是空格,如果设置宽度小于实际宽度则则返回原字符串
- ljust() 左对齐,第1个参数指定宽度,第2个参数指定填充符,第2个参数是可选的,默认是空格如果设置宽度小于实际宽度则则返回原字符串
- rjust() 右对齐,第1个参数指定宽度,第2个参数指定填充符,第2个参数是可选的,默认是空格如果设置宽度小于实际宽度则则返回原字符串
- zfill() 右对齐,左边用0填充,该方法只接收一个参数,用于指定字符串的宽度,如果指定的宽度小于等于字符串的长度,返回字符串本身
-
劈分操作
- split()
- 从字符串的左边开始劈分,默认的劈分字符是空格字符串,返回的值都是一个列表
- 以通过参数sep指定劈分字符串是的劈分符
- 通过参数maxsplit指定劈分字符串时的最大劈分次数,在经过最大次劈分之后,剩余的子串会单独做为一部分
- rsplit()
- 从字符串的右边开始劈分,默认的劈分字符是空格字符串,返回的值都是一个列表
- 以通过参数sep指定劈分字符串是的劈分符
- 通过参数maxsplit指定劈分字符串时的最大劈分次数,在经过最大次劈分之后,剩余的子串会单独做为一部分
- split()
-
判断操作
- isidentifier() 判断指定的字符串是不是合法的标识符
- isspace() 判断指定的字符串是否全部由空白字符组成(回车、换行,水平制表符)
- isalpha() 判断指定的字符串是否全部由字母组成
- isdecimal() 判断指定字符串是否全部由十进制的数字组成
- isnumeric() 判断指定的字符串是否全部由数字组成
- isalnum() 判断指定字符串是否全部由字母和数字组成
-
其他操作
- replace() 第1个参数指定被替换的子串,第2个参数指定替换子串的字符串,该方法返回替换后得到的字符串,替换前的字符串不发生变化,调用该方法时可以通过第3个参数指定最大替换次数
- join() 将列表或元组中的字符串合并成一个字符串
-
字符串的比较操作
- 运算符:>,>=,<,<=,==,!=
- 比较规则:首先比较两个字符串中的第一个字符,如果相等则继续比较下一个字符,依次比较下去,直到两个字符串中的字符不相等时,其比较结果就是两个字符串的比较结果,两个字符串中的所有后续字符将不再被比较
- 比较原理:两上字符进行比较时,比较的是其ordinal value(原始值),调用内置函数ord可以得到指定字符的ordinal value。与内置函数ord对应的是内置函数chr,调用内置函数chr时指定ordinal value可以得到其对应的字符
-
字符串的切片
- 字符串是不可变类型
- 不具备增删改等操作
- 切片操作将产生新的对象
# [start:stop:step] 包括start不包括stop, 没有start和stop就是从0到最后一个元素 s = 'hello' s[1:5:1]
- 字符串是不可变类型
-
格式化字符串
# 方式一 %
name = '张三'
age = 18
print('我叫%s' % (name))
# %10.3f 宽度为10,最多三位小数
# 方式二 {}
print('我叫{0},今年{1},我叫{0}'.format(name,age))
# {0:.3}表示第0个 一共三位数
# {0:10.3f} 宽度为10,最多三位小数
# 方法三 f模式
print(f'我叫{name},今年{age}')
- 字符串的编码转换
- 编码: 将字符串转换二维码数据(bytes)
- 解码:将bytes类型的数据转换成字符串类型
# 编码
s = '哈哈哈哈'
print(s.encode(encoding='GBK')) # 在GBK这种编码格中 一个中文占两个字节
print(s.encode(encoding='UTF-8')) # 在UTF-8这种编码格式中,一个中文占三个字节
# 解码
byte = s.encode(encoding='GBK')
print(byte.decode(encoding='GBK'))
# 编码和解码的格式一定要相同
函数
什么是函数? 函数是执行特定任和以完成特定功能的一段代码
为什么需要函数? 1、复用代码 2、隐藏实现细节 3、提高可维护性 4、提高可读性便于调试
函数的创建
def 函数名 ([输入参数]):
函数体
[return xxx]
def calc(a,b=10): # 默认参数
c = a+b
return c
resultA = calc(10,20) # 位置传参
resultB = calc(b=10,a=20) # 关键字传参
print(resultA,resultB)
函数参数传递的内存分析
def fun(arg1,arg2):
print(arg1)
print(arg2)
arg1 = 100
arg2.append(10)
print(arg1)
print(arg2)
n1 = 11
n2 = [22,33,44]
fun(n1,n2)
'''在函数调用过程中,进行参数的传递
如果是不可变对象,在函数体的修改不会影响实参的值arg1的修改为100,不会影响n1的值
如果是可变对象,在函数体的的修改会影响到实参的值arg2的修改,append(10),会影响到n2的值
'''
函数的返回值
- 如果函数没有返回值【函数执行完毕之后,不需要给调用处提供数据】return可以省略不写
- 函数的返回值,如果是1个,直接返回类型
- 函数的返回值,如果是多个,返回的结果为元组
可变参数
- 个数可变的位置参数
- 定义函数时,可能无法事先确定传递的位置实参的个数时,使用可变的位置参数
- 使用*定义个数可变的位置形成
- 结果为一个元组
- 个数可变的关键字形参
- 定义函数时,无法事先确定传递的关键字实参的个数时,使用可变的关键字形参
- 使用**定义个数可变的关键字形参
- 结果为一个字典
def calculate_sum(*arg,**kwargs):
s = 0
for i in args:
s += i
print(s)
for k , v in kwargs.items():
print(k,v)
变量作用域
- 局部变量
- 在函数内定义并使用的变量,只在函数内部有效,局部变量使用
global
声明,这个变量就会就成全局变量
- 在函数内定义并使用的变量,只在函数内部有效,局部变量使用
- 全局变量
- 函数体外定义的变量,可作用于函数内外
递归函数
- 什么是递归函数
- 如果在一个函数的函数体内调用了该函数本身,这个函数就称为递归函数
- 递归的组成部分
- 递归调用与递归终止条件
- 递归的调用过程
- 每递归调用一次函数,都会在栈内存分配一个栈帧,
- 每执行完一次函数,都会释放相应的空间
- 递归的优缺点
- 缺点:占用内存多,效率低下
- 优点:思路和代码简单
def fib(n)
if n == 1:
return 1
elif n == 2:
return 1
else :
retrun fib(n-1)+fib(n-2)
Lambda表达式
Lambda表达式 又称为 匿名函数
- 程序只执行一次,不需要定义函数名
- 在某些函数中必须以函数作为参数,但函数本身十分简单而且只在一处使用
上述情况可用匿名函数
匿名函数的用法有点像js中的回调函数的箭头函数
错误与异常
常见的bug类型
- 粗心导致的语法错误
SyntaxError
- 索引越界导致的
IndexError
python的异常处理机制
try...except
try:
xxx
except KeyError:
xxx
except ValueError:
xxx
except 语句主要有以下几种用法:
- 捕获所有异常:
except:
- 捕获指定异常:
except <异常名>:
- 捕获异常名 1 或异常名 2
except (异常名 1, 异常名 2):
- 捕获指定异常及其附加的数据
except <异常名> as <数据>:
- 捕获异常名 1 或者异常名 2 及异常的附加数据
except (异常名 1, 异常名 2) as <数据>:
try...except...else
当没有异常时执行else中的代码
try...except...else...finally
finally块无论是否发生异常都会被执行,能常用来释放try块中申请的资源
常见的内建异常可以查询csdn或者书本P148-150
异常名 | 描述 |
---|---|
AttributeError | 调用不存在的方法引发的异常 |
EOFError | 遇到文件末尾引发的异常 |
ImportError | 导入模块出错引发的异常 |
IndexError | 列表越界引发的异常 |
IOError | I/O操作引发的异常,如打开文件出错等 |
KeyError | 使用字典中不存在的关键字引发的异常 |
NameError | 使用不存在的变量名引发的异常 |
TabError | 语句块缩进不正确引发的异常 |
ValueError | 搜索列表中不存在的值引发的异常 |
ZeroDivisionError | 除数为0引发的异常 |
traceback模块
使用traceback模块打印异常信息
import traceback
try:
print(1/0)
except:
traceback.print_exc()
面向对象
类的创建
类的组成:
- 类属性
- 实例方法
- 静态方法
- 类方法
class Student:
native_place = '佛山' #类属性
def __init__(self,name,age,address): #name,age为实例属性
self.name = name
self.age = age
self.__address = address #定义私有方法
#实例方法
def info(self):
print('我叫'+self.name,'年龄是'+self.age)
#类方法
@classmethod
def cm(cls):
print('类方法')
#静态方法
@staticmethod
def sm():
print('静态方法')
在类之外定义的叫函数,在类之内定义的叫方法
对象实例的创建
但对象创建后,会重新开辟一个空间,这个实例对象空间有个类指针指向类对象
stud1 = Student('好好',20)
# 两种调用方法的方式
Student.info(stud1)
stud1.info()
类方法 类属性 静态方法
- 类属性:类中方法外的变量称为类属性,被该类的所有对象所共享
- 类方法:使用@classmethod修饰的方法,使用类名直接访问的方法
- 静态方法:使用@staticmethod修饰的主法,使用类名直接访问的方法
动态绑定属性和方法
一个Student类可以创建N个Student类的实例对象。每个实体对象的属性值不同
stu = Student('张三',10)
stu.gender = '男' #动态绑定属性
def show():
print('lll')
stu.show = show #动态绑定方法
stu.show()
面向对象的三大特征
封装、继承、多态
封装
- 将数据(属性)和行为(方法)包装到类对象中。在方法内部对属性进行操作,在类对象的外部调用方法。这样,无需关心方法内部的具体实现细节,从而隔离了复杂度。
- 在Python中没有专门的修饰符用于属性的私有,如果该属性不希望在类对象外部被访问,前边使用两个“_”。
- 但是我们可以这样
_Student.__address
访问被封装的属性
继承
- 提高代码的复用性
class Animal:
def __init__(self,name):
self.name = name
def play(self):
print('我是'+self.name)
class Dog(Animal):
pass
dog = Dog('旺财')
dog.play()
方法重写 与 调用父类
class Animal:
def __init__(self,name):
self.name = name
def play(self):
print('我是'+self.name)
class Dog(Animal):
#如果子类定义了构造方法,则父类的构造函数__init__不会被调用,需要在子类专门调用
def __init__(self,name):
super(Dog,self).__init__(name)
self.hh = name
def play(self):
print(1111)
dog = Dog('旺财')
dog.play()
Object类
- object类是所有类的父类,因此所有类都有object类的属性和方法。
- 内置函数dir()可以查看指定对象所有属性
- Object有一个__str__()方法,用于返回一个对于“对象的描述”,对应于内置函数str()经常用于print()方法,帮我们查看对象的信息,所以我们经常会对__str__()进行重写
多态
- 提高程序的可扩展性和可维护性
- 简单地说,多态就是“具有多种形态”,它指的是:即便不知道一个变量所引用的对象到底是什么类型,仍然可以通过这个变量调用方法,在运行过程中根据变量所引用对象的类型,动态决定调用哪个对象中的方法。
class Animal(object):
def eat(self):
print('动物会吃')
class Dog(Animal):
def eat(self):
print('狗吃骨头')
class Cat(Animal):
def eat(self):
print('猫吃鱼')
class Person(object):
def eat(self):
print('人吃动物')
def fun(animal):
animal.eat()
fun(Dog())
fun(Cat())
fun(Person())
静态语言实现多态的三个必要条件:
- 继承
- 方法重写
- 父类引用指向子类对象
特殊方法和特殊属性
特殊属性:
- dict:获得类对象或实例对象所绑定的所有属性和方法的字典
- class:输出对象所属的类
- bases:输出父类的元组
- base:输出最近的父元素
- mro:输出类的继承结构
- subclasses:子类的列表
特殊方法: - len():通过重写__len__()方法,让内置函数len()的参数可以是自定义类型
- add():通过重写__add__()方法,可使用自定义对象具有’+'功能
- new():用于创建对象
- init():对创建的对象进行初始化
类的浅拷贝和深拷贝
- 变量的赋值操作:只是形成两个变量,实际上还是指向同一个对象
- 浅拷贝: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)
print(cpu2)#内存地址相同,赋值操作实际上和js数据存储堆栈中的栈相同
# 类的浅拷贝
disk = Disk()
computer = Computer(cpu1,disk)
import copy
computer2 = copy.copy(computer)
print(computer,computer.cpu,computer.disk)
print(computer2,computer2.cpu,computer2.disk)# 只创建了一个和原来相同的实例对象空间,但内容的指针都没变。所以两者内容地址都相同,并没有额外创建新的内存空间
# 类的深拷贝
disk = Disk()
computer = Computer(cpu1,disk)
import copy
computer3 = copy.deepcopy(computer)#会把类似js的原型链上的所有元素都拷贝一份
模块
一个模块可以包含N多个函数
在Python中一个.py文件就是一个模块
创建模块:新建一个.py文件,名称尽量不要与Python自带的标准模块名称相同
导入模块
import 模块名称 [as 别名]
from 模块名称 import 函数/变量/类
以主程序的形式运行
在每个模块的定义中都包括一个记录模块名称的变量__name__
,程序可以检查该变量,以确定他们在哪个模块中执行。如果一个模块不是被导入到其它程序中执行,那么它可能在解释器的顶级模块中执行。顶级模块的__name__
变量的值为__main__
if __name__ == '__main__':
pass #只有运行的是当前文件,而不是文件因为模块而被调用时,才能被调用的部分
Python中的包
包是一个分层次的目录结构,它将一组功能相近的模块组织在一个目录下
作用:
- 代码规范
- 避免模块名称冲突
包与目录的区别 - 包含__init__.py文件的目录称为包
- 目录里通常不包含__init__.py文件
包的导入 import 包名.模块名
标准库
Python官方提供了不少的包和模块
sys
import sys
# 识别操作系统
print(sys.platform)
# 处理命令行参数
print(sys.argv)
# 退出程序
sys.exit(0) # 0为正常退出,其他为异常
# 获取模块搜索路径
for path in sys.path:
print(path)
##我们可以像修改列表一样修改路径
sys.path.append('c:\\')
# 查找已导入的模块
print(sys.modules.keys())
print(sys.modules.values())
print(sys.modules['os'])
os
import os
# 获取当前文件所在目录
print(__file__)
print(os.path.dirname(__file__))
# 获取当前路径以及切换当前路径
print(os.getcwd()) ## 获取当前执行程序的路径
os.chdir("c:\\") ## 可以切换当前的路径
# 重命名文件
os.rename('a.text','b.text')## 会将a.text文件重命名为b.text
# 查看指定的路径是否存在
print(os.path.exists("c:\windows")) ## 存在则返回true
# 判断给出的路径是否是一个文件
print(os.path.isfile("c:\\windows\\system32"))
# 判断给出的路径是否是一个目录
print(os.path.isdir("c:\\windows\\system32"))
# 获取系统环境变量
for k,v in os.environ.items():
print(k,"=>",v)
# 创建单层目录
os.mkdir("d:\\01kuaixue")
# 创建多层目录
os.makedirs("d:\\01kuaixue\\02kuaixue")
math
import math
# 常量
math.pi
math.e
# 运算函数
math.ceil(1.7) # 2 向上取整
math.floor(1.7) # 1 向下取整
math.pow(15,5) # 指数运算
math.log(100,10) # math.log(数,底数) 对数运算
math.sqrt(4) # 平方根
math.sin(math.pi)
math.cos(math.pi)
math.tan(0)
math.degrees(math.pi) # 转角度
math.radians(90) # 转弧度
random
# 生产1-10的随机数
random.random()
# 生成指定范围的随机数
random.uniform(1,150)
# 生成一个指定范围内的整数
random.randint(1,50)
# 在给定序列中获取一个随机元素
seq1 = (1,5,2,111)
print(random.choice(seq1))
# 将一个列表中的元素打乱
random.shuffle(sqe1)
第三方包
在命令行窗口中操作
-
显示版本号和包路径
pip --version
-
搜索想要的包
pip search 关键字
-
安装包
pip install 软件包名
或者pip install 软件包==版本号
-
卸载包
pip uninstall 软件包
可以使用conda进行包管理,不使用pip。
文件与IO
打开文件,利用open()创建文件对象
file = open(filename[,mode,encoding]) # mode打开模式(通常为可读) encoding字符的编写模式 具体模式可自查
文件对象的常用方法
方法名 | 说明 |
---|---|
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() | 把缓冲区的内容写入文件,同时关闭文件,释放文件对象相关资源 |
with语句 上下文管理器
with语句可以自动管理上下文资源,不论什么原因跳出with块,都能确保文件正确的关闭,以此来达到释放资源的目的
with open("/tmp/foo.txt") as file:
data = file.read()
具体with原理可看这个文章http://t.csdn.cn/KvT51