Python基础（未完）

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指定劈分字符串时的最大劈分次数，在经过最大次劈分之后，剩余的子串会单独做为一部分

• 判断操作

  • 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...finallyfinally块无论是否发生异常都会被执行，能常用来释放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