Python基础知识-下

版权声明：转载请联系我获得授权

参考视频：python全套教程

Python基础

列表

相当于其他语言中的数组，存储$N$个元素

从后往前采取负数索引

# 创建与删除
		# 中括号
lst = [ ]
		# 内置函数list()
lst = list([ ])

# 查询
		# 获取列表中指定元素的索引
lst.index('hello',start,stop)	#相同元素只返回第一个元素的索引，值不存在返回ValueError，索引不存在返回IndexError
# 切片操作
lst[start : stop : step]
lst[1:6:] # 写不写最后一个:都可以，默认步长为1
# 遍历
for item in lst :
for item not in lst:

# 增、删、改
# 排序
lst.sort(reverse=True) 		# 默认升序
new_lst = sorted(lst, reverse=True)
# 列表生成式
[ i for i in range(10) ]

lst.clear()清空列表中的所有元素

del lst 将列表对象删除

修改：

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

为指定切片赋予新值

字典

可变的无序序列，但key是不可变对象，且不允许重复，value可以重复

以键值对的方式存储数据，存储位置根据hash函数计算

# 创建
		# 花括号
dic = {' ':  ,  ' ': }
		# 内置函数dict()
lst = dict( key=' ', value=)

# 查询
dic[key] # 不存在key返回KeyError
dic.get(key)	# 不存在key返回None
key in dic
key not in dic

# 增、删、改
dic[key]=value
del dic[key]  # 删除指定键值对
dic.clear()		# 清空字典的元素

# 视图操作
dic.keys() 			 # 产生list
dic.values()		# 产生list
dic.items()			# 产生tuple

# 字典生成式
lst = zip(keys,values)		# 将对象中的元素打包成元组，返回由这些元组组成的列表

元组

不可变的可迭代序列，没有增删改的操作，没有生成式

优点：多任务环境下，操作对象不需要加锁

# 创建
		# 小括号
tup = {' ' ,  ' '}
		# 内置函数tuple()
lst = tuple( (' ', ' ' ) )
		# 特殊情况，只包含一个元素，需要逗号和小括号
lst = (10, ) 

集合

集合是可变无序的序列，像没有value的字典

# 创建
		# 花括号
s = {' ' ,  ' '}
		# 内置函数set()
s = set( anytype )

# 交集
s1.intersection(s2) 等价于 s1&s2
# 并集
s1.union(s2) 等价于  s1|s2
# 差集
s1.difference(s2) 等价于 s1-s2
# 对称差集
s1.symmetric_difference(s2) 等价于 s1^s2

# 集合生成式
{ i for i in range(10) }

字符串

不可变的字符序列

字符串驻留机制 不同的值被存放在字符串的驻留池中，对相同字符串只保留一份拷贝，后续创建相同字符串不会开辟新空间。

字符串的比较：从两个字符串的第一个字符开始比较，比较其ordinal value原始ASCII值。

ord() 获取字符对应的ASCII编码

chr() 获取ASCII编码对应的字符

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

格式化字符串

%作占位符

%宽度.精度f
print('%10.3f' % 3.1415926)

{}作占位符

`f格式化

f'我叫{name}, 今年{age}岁'
# .3表示一共三位数
print( '{0:.3}'.format(3.1415926) )
# .3f 表示共3位小数
print( '{0:.3f}'.format(3.1415926) )

字符串的编码与解码

# 编码与解码的格式要相同
byte = s.encode(encoding='UTF-8')	# 一个中文占两个字节
print(byte.decode(encoding='UTF-8'))		# 一个中文占三个字节

函数

传参

个数不可变

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

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

个数可变（只能是1个）

位置参数：*args 为形参时，结果为一个包含所有值的元组

关键字参数：**args为形参时，结果为一个包含所有变量名和变量值字典

局部变量和全局变量

用global声明局部变量可以将其变成全局变量

返回值

函数返回多个值时，结果为元组；返回1个值时，结果为原始类型

如果不需要给调用处提供数据，return可以不写。

bug常见类型

异常处理机制

try-except-else ：try中抛出异常执行else，不抛出异常执行except。

try-except-else-finally ： 无论是否有异常都会执行finally。

import traceback
try:
except:
    traceback.print_exc()

类对象与实例对象

比如类对象<class 'int'>和它的实例对象1。实例对象中有一个类指针指向类对象。

编程界两大阵营

# 类的创建
class Student:
    # 类属性 （直接写在类里的变量）
    native_place='湖南'		
    #name,age为实例属性
    # 初始化方法
    def __init__(self,name,age):		
        self.name = name
        self.age = age
     # 实例方法	（类之外定义的为函数，类之内定义的为方法）
    def info(self):
        pass
    # 类方法
    @classmethod
    def cm(cls):
        pass
    # 静态方法
    @staticmethod
    def sm():	# 无任何默认参数
        pass
# 类的实例化
stu = Student('Jack', 20)

# 为实例动态绑定属性		应在类对象和实例对象创建后添加
stu1.gender='女'  # 此时stu1有该属性而stu2没有
# 为实例动态绑定方法 
def show():
    pass
stu1.show = show
stu1.show()

装饰器和语法糖

面向对象的三大特征

封装

将数据属性和行为方法包装到类对象中

如果不希望该属性在类对象外部被访问，前边加“__”

继承

class Child(Parents):
    def __init__(self, name, age, score):
        super().__init__(name, age)
        self.score = score

子类的方法可以从父类继承过来

方法重写 如果子类对继承父类的某个属性或方法不满意，可在子类中重新编写。子类重写后的方法中可以通过super().xxx()调用父类中被重写的方法。

object类是所有类的父类 dir()可以查看指定对象的所有属性。没有继承任何类默认继承object类。

经常对父类的def __str__(self): return '姓名:{0}, 年龄:{1}'.format(self.name, self.age)进行重写，该方法常用来返回对于对象的描述。

多态

def fun(aniaml):
    animal.eat()
# 这里的animal可以传入父类的 Animal()，也可以传入 Dog()、Cat()、Person()等子类。

动态语言只关心是否具有这个方法，而不关心对象的类型

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

（1）继承

（2）方法重写

（3）父类引用指向子类对象

Java是静态语言，Python是动态语言。

特殊方法和特殊属性

类的浅拷贝和深拷贝

• 变量的赋值操作

形成两个变量，实际上指向同一对象。即地址相同。

• 浅拷贝（未特殊说明类一般都是浅拷贝）

只拷贝源对象，生成一个不同地址的拷贝对象。源对象和拷贝对象引用同一个子对象。

import copy
computer2 = copy.copy(computer)
print(computer, computer.cpu, computer.disk)
print(computer2, computer2.cpu, computer2.disk)
# computer与computer2的地址不同，但子对象cpu和disk地址相同

• 深拷贝

递归拷贝对象中包含的子对象，源对象和拷贝对象所有子对象也不相同。

import copy
computer2 = copy.deepcopy(computer)
print(computer, computer.cpu, computer.disk)
print(computer2, computer2.cpu, computer2.disk)
# computer与computer2的地址不同，子对象cpu和disk地址也不同

模块化编程

一个.py文件 就是一个模块（Modules）。

# 模块的导入
import modules as M
from modules import function, classes, variables

当导入模块报错时，去当前所在包在右键 ‘Mark Directory as’ 选择’Source Root’

常用内置模块

schedule 周期任务神器

第三方模块的安装

pip install module
import mudule

主程序形式运行

if __name__ = '__main__':
# 只有运行当前程序时会执行，如果该程序是被动调用则不执行

包package

import package.module as m

编码格式

处理全球范围内的字符集，优先使用UTF-8，只处理中文字符，使用gbk编码更合适。

文件读写

文件读写俗称IO操作，实际是队列数据结构。

.py从File中读数据。写入数据到File中。

file = open('a.txt', 'r')	# 打开文件
print(file.readlines())		# 按行读文件	 readlines()返回列表
# file.read() 读取全部内容
file.close()						# 关闭资源

如果此时乱码，reload in GDK

文件对象的常用方法

with上下文管理器

无论什么原因跳出with块，都能确保文件正确关闭，以此来释放资源

无须手动 file.close()

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

os模块

import os
os.system('notepad.exe')
os.startfile(r'C:\filename')

import os.path
os.path.abspath('name.py')